diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/masked/__init__.py b/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/masked/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/masked/__pycache__/__init__.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/masked/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e6db3aa5edf86e8779152839f279dc1f15a27eaa
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/masked/__pycache__/__init__.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/masked/__pycache__/test_arithmetic.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/masked/__pycache__/test_arithmetic.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b596da9daaca5050e52356d345e27e0cbf02eb48
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/masked/__pycache__/test_arithmetic.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/masked/__pycache__/test_arrow_compat.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/masked/__pycache__/test_arrow_compat.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b32afa22163f83e512eec175064ab25bfe753710
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/masked/__pycache__/test_arrow_compat.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/masked/__pycache__/test_function.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/masked/__pycache__/test_function.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..01cc213b6570aa387897e1f4ab37cd9447fca5c1
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/masked/__pycache__/test_function.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/masked/__pycache__/test_indexing.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/masked/__pycache__/test_indexing.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d72de019fa3becd67c756de40fbb7046654cf486
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/masked/__pycache__/test_indexing.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/masked/test_arithmetic.py b/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/masked/test_arithmetic.py
new file mode 100644
index 0000000000000000000000000000000000000000..f4b571ca627b3da34e943972ba70b03bae74417a
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/masked/test_arithmetic.py
@@ -0,0 +1,248 @@
+from __future__ import annotations
+
+from typing import Any
+
+import numpy as np
+import pytest
+
+import pandas as pd
+import pandas._testing as tm
+
+# integer dtypes
+arrays = [pd.array([1, 2, 3, None], dtype=dtype) for dtype in tm.ALL_INT_EA_DTYPES]
+scalars: list[Any] = [2] * len(arrays)
+# floating dtypes
+arrays += [pd.array([0.1, 0.2, 0.3, None], dtype=dtype) for dtype in tm.FLOAT_EA_DTYPES]
+scalars += [0.2, 0.2]
+# boolean
+arrays += [pd.array([True, False, True, None], dtype="boolean")]
+scalars += [False]
+
+
+@pytest.fixture(params=zip(arrays, scalars), ids=[a.dtype.name for a in arrays])
+def data(request):
+    """Fixture returning parametrized (array, scalar) tuple.
+
+    Used to test equivalence of scalars, numpy arrays with array ops, and the
+    equivalence of DataFrame and Series ops.
+    """
+    return request.param
+
+
+def check_skip(data, op_name):
+    if isinstance(data.dtype, pd.BooleanDtype) and "sub" in op_name:
+        pytest.skip("subtract not implemented for boolean")
+
+
+def is_bool_not_implemented(data, op_name):
+    # match non-masked behavior
+    return data.dtype.kind == "b" and op_name.strip("_").lstrip("r") in [
+        "pow",
+        "truediv",
+        "floordiv",
+    ]
+
+
+# Test equivalence of scalars, numpy arrays with array ops
+# -----------------------------------------------------------------------------
+
+
+def test_array_scalar_like_equivalence(data, all_arithmetic_operators):
+    data, scalar = data
+    op = tm.get_op_from_name(all_arithmetic_operators)
+    check_skip(data, all_arithmetic_operators)
+
+    scalar_array = pd.array([scalar] * len(data), dtype=data.dtype)
+
+    # TODO also add len-1 array (np.array([scalar], dtype=data.dtype.numpy_dtype))
+    for scalar in [scalar, data.dtype.type(scalar)]:
+        if is_bool_not_implemented(data, all_arithmetic_operators):
+            msg = "operator '.*' not implemented for bool dtypes"
+            with pytest.raises(NotImplementedError, match=msg):
+                op(data, scalar)
+            with pytest.raises(NotImplementedError, match=msg):
+                op(data, scalar_array)
+        else:
+            result = op(data, scalar)
+            expected = op(data, scalar_array)
+            tm.assert_extension_array_equal(result, expected)
+
+
+def test_array_NA(data, all_arithmetic_operators):
+    data, _ = data
+    op = tm.get_op_from_name(all_arithmetic_operators)
+    check_skip(data, all_arithmetic_operators)
+
+    scalar = pd.NA
+    scalar_array = pd.array([pd.NA] * len(data), dtype=data.dtype)
+
+    mask = data._mask.copy()
+
+    if is_bool_not_implemented(data, all_arithmetic_operators):
+        msg = "operator '.*' not implemented for bool dtypes"
+        with pytest.raises(NotImplementedError, match=msg):
+            op(data, scalar)
+        # GH#45421 check op doesn't alter data._mask inplace
+        tm.assert_numpy_array_equal(mask, data._mask)
+        return
+
+    result = op(data, scalar)
+    # GH#45421 check op doesn't alter data._mask inplace
+    tm.assert_numpy_array_equal(mask, data._mask)
+
+    expected = op(data, scalar_array)
+    tm.assert_numpy_array_equal(mask, data._mask)
+
+    tm.assert_extension_array_equal(result, expected)
+
+
+def test_numpy_array_equivalence(data, all_arithmetic_operators):
+    data, scalar = data
+    op = tm.get_op_from_name(all_arithmetic_operators)
+    check_skip(data, all_arithmetic_operators)
+
+    numpy_array = np.array([scalar] * len(data), dtype=data.dtype.numpy_dtype)
+    pd_array = pd.array(numpy_array, dtype=data.dtype)
+
+    if is_bool_not_implemented(data, all_arithmetic_operators):
+        msg = "operator '.*' not implemented for bool dtypes"
+        with pytest.raises(NotImplementedError, match=msg):
+            op(data, numpy_array)
+        with pytest.raises(NotImplementedError, match=msg):
+            op(data, pd_array)
+        return
+
+    result = op(data, numpy_array)
+    expected = op(data, pd_array)
+    tm.assert_extension_array_equal(result, expected)
+
+
+# Test equivalence with Series and DataFrame ops
+# -----------------------------------------------------------------------------
+
+
+def test_frame(data, all_arithmetic_operators):
+    data, scalar = data
+    op = tm.get_op_from_name(all_arithmetic_operators)
+    check_skip(data, all_arithmetic_operators)
+
+    # DataFrame with scalar
+    df = pd.DataFrame({"A": data})
+
+    if is_bool_not_implemented(data, all_arithmetic_operators):
+        msg = "operator '.*' not implemented for bool dtypes"
+        with pytest.raises(NotImplementedError, match=msg):
+            op(df, scalar)
+        with pytest.raises(NotImplementedError, match=msg):
+            op(data, scalar)
+        return
+
+    result = op(df, scalar)
+    expected = pd.DataFrame({"A": op(data, scalar)})
+    tm.assert_frame_equal(result, expected)
+
+
+def test_series(data, all_arithmetic_operators):
+    data, scalar = data
+    op = tm.get_op_from_name(all_arithmetic_operators)
+    check_skip(data, all_arithmetic_operators)
+
+    ser = pd.Series(data)
+
+    others = [
+        scalar,
+        np.array([scalar] * len(data), dtype=data.dtype.numpy_dtype),
+        pd.array([scalar] * len(data), dtype=data.dtype),
+        pd.Series([scalar] * len(data), dtype=data.dtype),
+    ]
+
+    for other in others:
+        if is_bool_not_implemented(data, all_arithmetic_operators):
+            msg = "operator '.*' not implemented for bool dtypes"
+            with pytest.raises(NotImplementedError, match=msg):
+                op(ser, other)
+
+        else:
+            result = op(ser, other)
+            expected = pd.Series(op(data, other))
+            tm.assert_series_equal(result, expected)
+
+
+# Test generic characteristics / errors
+# -----------------------------------------------------------------------------
+
+
+def test_error_invalid_object(data, all_arithmetic_operators):
+    data, _ = data
+
+    op = all_arithmetic_operators
+    opa = getattr(data, op)
+
+    # 2d -> return NotImplemented
+    result = opa(pd.DataFrame({"A": data}))
+    assert result is NotImplemented
+
+    msg = r"can only perform ops with 1-d structures"
+    with pytest.raises(NotImplementedError, match=msg):
+        opa(np.arange(len(data)).reshape(-1, len(data)))
+
+
+def test_error_len_mismatch(data, all_arithmetic_operators):
+    # operating with a list-like with non-matching length raises
+    data, scalar = data
+    op = tm.get_op_from_name(all_arithmetic_operators)
+
+    other = [scalar] * (len(data) - 1)
+
+    err = ValueError
+    msg = "|".join(
+        [
+            r"operands could not be broadcast together with shapes \(3,\) \(4,\)",
+            r"operands could not be broadcast together with shapes \(4,\) \(3,\)",
+        ]
+    )
+    if data.dtype.kind == "b" and all_arithmetic_operators.strip("_") in [
+        "sub",
+        "rsub",
+    ]:
+        err = TypeError
+        msg = (
+            r"numpy boolean subtract, the `\-` operator, is not supported, use "
+            r"the bitwise_xor, the `\^` operator, or the logical_xor function instead"
+        )
+    elif is_bool_not_implemented(data, all_arithmetic_operators):
+        msg = "operator '.*' not implemented for bool dtypes"
+        err = NotImplementedError
+
+    for other in [other, np.array(other)]:
+        with pytest.raises(err, match=msg):
+            op(data, other)
+
+        s = pd.Series(data)
+        with pytest.raises(err, match=msg):
+            op(s, other)
+
+
+@pytest.mark.parametrize("op", ["__neg__", "__abs__", "__invert__"])
+def test_unary_op_does_not_propagate_mask(data, op):
+    # https://github.com/pandas-dev/pandas/issues/39943
+    data, _ = data
+    ser = pd.Series(data)
+
+    if op == "__invert__" and data.dtype.kind == "f":
+        # we follow numpy in raising
+        msg = "ufunc 'invert' not supported for the input types"
+        with pytest.raises(TypeError, match=msg):
+            getattr(ser, op)()
+        with pytest.raises(TypeError, match=msg):
+            getattr(data, op)()
+        with pytest.raises(TypeError, match=msg):
+            # Check that this is still the numpy behavior
+            getattr(data._data, op)()
+
+        return
+
+    result = getattr(ser, op)()
+    expected = result.copy(deep=True)
+    ser[0] = None
+    tm.assert_series_equal(result, expected)
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/masked/test_arrow_compat.py b/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/masked/test_arrow_compat.py
new file mode 100644
index 0000000000000000000000000000000000000000..7a89656bd5aa0bff079f58fb1acaa1f7742ed8e8
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/masked/test_arrow_compat.py
@@ -0,0 +1,209 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+import pandas._testing as tm
+
+pytestmark = pytest.mark.filterwarnings(
+    "ignore:Passing a BlockManager to DataFrame:DeprecationWarning"
+)
+
+pa = pytest.importorskip("pyarrow")
+
+from pandas.core.arrays.arrow._arrow_utils import pyarrow_array_to_numpy_and_mask
+
+arrays = [pd.array([1, 2, 3, None], dtype=dtype) for dtype in tm.ALL_INT_EA_DTYPES]
+arrays += [pd.array([0.1, 0.2, 0.3, None], dtype=dtype) for dtype in tm.FLOAT_EA_DTYPES]
+arrays += [pd.array([True, False, True, None], dtype="boolean")]
+
+
+@pytest.fixture(params=arrays, ids=[a.dtype.name for a in arrays])
+def data(request):
+    """
+    Fixture returning parametrized array from given dtype, including integer,
+    float and boolean
+    """
+    return request.param
+
+
+def test_arrow_array(data):
+    arr = pa.array(data)
+    expected = pa.array(
+        data.to_numpy(object, na_value=None),
+        type=pa.from_numpy_dtype(data.dtype.numpy_dtype),
+    )
+    assert arr.equals(expected)
+
+
+def test_arrow_roundtrip(data):
+    df = pd.DataFrame({"a": data})
+    table = pa.table(df)
+    assert table.field("a").type == str(data.dtype.numpy_dtype)
+
+    result = table.to_pandas()
+    assert result["a"].dtype == data.dtype
+    tm.assert_frame_equal(result, df)
+
+
+def test_dataframe_from_arrow_types_mapper():
+    def types_mapper(arrow_type):
+        if pa.types.is_boolean(arrow_type):
+            return pd.BooleanDtype()
+        elif pa.types.is_integer(arrow_type):
+            return pd.Int64Dtype()
+
+    bools_array = pa.array([True, None, False], type=pa.bool_())
+    ints_array = pa.array([1, None, 2], type=pa.int64())
+    small_ints_array = pa.array([-1, 0, 7], type=pa.int8())
+    record_batch = pa.RecordBatch.from_arrays(
+        [bools_array, ints_array, small_ints_array], ["bools", "ints", "small_ints"]
+    )
+    result = record_batch.to_pandas(types_mapper=types_mapper)
+    bools = pd.Series([True, None, False], dtype="boolean")
+    ints = pd.Series([1, None, 2], dtype="Int64")
+    small_ints = pd.Series([-1, 0, 7], dtype="Int64")
+    expected = pd.DataFrame({"bools": bools, "ints": ints, "small_ints": small_ints})
+    tm.assert_frame_equal(result, expected)
+
+
+def test_arrow_load_from_zero_chunks(data):
+    # GH-41040
+
+    df = pd.DataFrame({"a": data[0:0]})
+    table = pa.table(df)
+    assert table.field("a").type == str(data.dtype.numpy_dtype)
+    table = pa.table(
+        [pa.chunked_array([], type=table.field("a").type)], schema=table.schema
+    )
+    result = table.to_pandas()
+    assert result["a"].dtype == data.dtype
+    tm.assert_frame_equal(result, df)
+
+
+def test_arrow_from_arrow_uint():
+    # https://github.com/pandas-dev/pandas/issues/31896
+    # possible mismatch in types
+
+    dtype = pd.UInt32Dtype()
+    result = dtype.__from_arrow__(pa.array([1, 2, 3, 4, None], type="int64"))
+    expected = pd.array([1, 2, 3, 4, None], dtype="UInt32")
+
+    tm.assert_extension_array_equal(result, expected)
+
+
+def test_arrow_sliced(data):
+    # https://github.com/pandas-dev/pandas/issues/38525
+
+    df = pd.DataFrame({"a": data})
+    table = pa.table(df)
+    result = table.slice(2, None).to_pandas()
+    expected = df.iloc[2:].reset_index(drop=True)
+    tm.assert_frame_equal(result, expected)
+
+    # no missing values
+    df2 = df.fillna(data[0])
+    table = pa.table(df2)
+    result = table.slice(2, None).to_pandas()
+    expected = df2.iloc[2:].reset_index(drop=True)
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.fixture
+def np_dtype_to_arrays(any_real_numpy_dtype):
+    """
+    Fixture returning actual and expected dtype, pandas and numpy arrays and
+    mask from a given numpy dtype
+    """
+    np_dtype = np.dtype(any_real_numpy_dtype)
+    pa_type = pa.from_numpy_dtype(np_dtype)
+
+    # None ensures the creation of a bitmask buffer.
+    pa_array = pa.array([0, 1, 2, None], type=pa_type)
+    # Since masked Arrow buffer slots are not required to contain a specific
+    # value, assert only the first three values of the created np.array
+    np_expected = np.array([0, 1, 2], dtype=np_dtype)
+    mask_expected = np.array([True, True, True, False])
+    return np_dtype, pa_array, np_expected, mask_expected
+
+
+def test_pyarrow_array_to_numpy_and_mask(np_dtype_to_arrays):
+    """
+    Test conversion from pyarrow array to numpy array.
+
+    Modifies the pyarrow buffer to contain padding and offset, which are
+    considered valid buffers by pyarrow.
+
+    Also tests empty pyarrow arrays with non empty buffers.
+    See https://github.com/pandas-dev/pandas/issues/40896
+    """
+    np_dtype, pa_array, np_expected, mask_expected = np_dtype_to_arrays
+    data, mask = pyarrow_array_to_numpy_and_mask(pa_array, np_dtype)
+    tm.assert_numpy_array_equal(data[:3], np_expected)
+    tm.assert_numpy_array_equal(mask, mask_expected)
+
+    mask_buffer = pa_array.buffers()[0]
+    data_buffer = pa_array.buffers()[1]
+    data_buffer_bytes = pa_array.buffers()[1].to_pybytes()
+
+    # Add trailing padding to the buffer.
+    data_buffer_trail = pa.py_buffer(data_buffer_bytes + b"\x00")
+    pa_array_trail = pa.Array.from_buffers(
+        type=pa_array.type,
+        length=len(pa_array),
+        buffers=[mask_buffer, data_buffer_trail],
+        offset=pa_array.offset,
+    )
+    pa_array_trail.validate()
+    data, mask = pyarrow_array_to_numpy_and_mask(pa_array_trail, np_dtype)
+    tm.assert_numpy_array_equal(data[:3], np_expected)
+    tm.assert_numpy_array_equal(mask, mask_expected)
+
+    # Add offset to the buffer.
+    offset = b"\x00" * (pa_array.type.bit_width // 8)
+    data_buffer_offset = pa.py_buffer(offset + data_buffer_bytes)
+    mask_buffer_offset = pa.py_buffer(b"\x0E")
+    pa_array_offset = pa.Array.from_buffers(
+        type=pa_array.type,
+        length=len(pa_array),
+        buffers=[mask_buffer_offset, data_buffer_offset],
+        offset=pa_array.offset + 1,
+    )
+    pa_array_offset.validate()
+    data, mask = pyarrow_array_to_numpy_and_mask(pa_array_offset, np_dtype)
+    tm.assert_numpy_array_equal(data[:3], np_expected)
+    tm.assert_numpy_array_equal(mask, mask_expected)
+
+    # Empty array
+    np_expected_empty = np.array([], dtype=np_dtype)
+    mask_expected_empty = np.array([], dtype=np.bool_)
+
+    pa_array_offset = pa.Array.from_buffers(
+        type=pa_array.type,
+        length=0,
+        buffers=[mask_buffer, data_buffer],
+        offset=pa_array.offset,
+    )
+    pa_array_offset.validate()
+    data, mask = pyarrow_array_to_numpy_and_mask(pa_array_offset, np_dtype)
+    tm.assert_numpy_array_equal(data[:3], np_expected_empty)
+    tm.assert_numpy_array_equal(mask, mask_expected_empty)
+
+
+@pytest.mark.parametrize(
+    "arr", [pa.nulls(10), pa.chunked_array([pa.nulls(4), pa.nulls(6)])]
+)
+def test_from_arrow_null(data, arr):
+    res = data.dtype.__from_arrow__(arr)
+    assert res.isna().all()
+    assert len(res) == 10
+
+
+def test_from_arrow_type_error(data):
+    # ensure that __from_arrow__ returns a TypeError when getting a wrong
+    # array type
+
+    arr = pa.array(data).cast("string")
+    with pytest.raises(TypeError, match=None):
+        # we don't test the exact error message, only the fact that it raises
+        # a TypeError is relevant
+        data.dtype.__from_arrow__(arr)
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/masked/test_function.py b/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/masked/test_function.py
new file mode 100644
index 0000000000000000000000000000000000000000..b259018cd6121c53c767e36e3c757211643262d6
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/masked/test_function.py
@@ -0,0 +1,74 @@
+import numpy as np
+import pytest
+
+from pandas.core.dtypes.common import is_integer_dtype
+
+import pandas as pd
+import pandas._testing as tm
+from pandas.core.arrays import BaseMaskedArray
+
+arrays = [pd.array([1, 2, 3, None], dtype=dtype) for dtype in tm.ALL_INT_EA_DTYPES]
+arrays += [
+    pd.array([0.141, -0.268, 5.895, None], dtype=dtype) for dtype in tm.FLOAT_EA_DTYPES
+]
+
+
+@pytest.fixture(params=arrays, ids=[a.dtype.name for a in arrays])
+def data(request):
+    """
+    Fixture returning parametrized 'data' array with different integer and
+    floating point types
+    """
+    return request.param
+
+
+@pytest.fixture()
+def numpy_dtype(data):
+    """
+    Fixture returning numpy dtype from 'data' input array.
+    """
+    # For integer dtype, the numpy conversion must be done to float
+    if is_integer_dtype(data):
+        numpy_dtype = float
+    else:
+        numpy_dtype = data.dtype.type
+    return numpy_dtype
+
+
+def test_round(data, numpy_dtype):
+    # No arguments
+    result = data.round()
+    expected = pd.array(
+        np.round(data.to_numpy(dtype=numpy_dtype, na_value=None)), dtype=data.dtype
+    )
+    tm.assert_extension_array_equal(result, expected)
+
+    # Decimals argument
+    result = data.round(decimals=2)
+    expected = pd.array(
+        np.round(data.to_numpy(dtype=numpy_dtype, na_value=None), decimals=2),
+        dtype=data.dtype,
+    )
+    tm.assert_extension_array_equal(result, expected)
+
+
+def test_tolist(data):
+    result = data.tolist()
+    expected = list(data)
+    tm.assert_equal(result, expected)
+
+
+def test_to_numpy():
+    # GH#56991
+
+    class MyStringArray(BaseMaskedArray):
+        dtype = pd.StringDtype()
+        _dtype_cls = pd.StringDtype
+        _internal_fill_value = pd.NA
+
+    arr = MyStringArray(
+        values=np.array(["a", "b", "c"]), mask=np.array([False, True, False])
+    )
+    result = arr.to_numpy()
+    expected = np.array(["a", pd.NA, "c"])
+    tm.assert_numpy_array_equal(result, expected)
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/masked/test_indexing.py b/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/masked/test_indexing.py
new file mode 100644
index 0000000000000000000000000000000000000000..28ee451a7ddd777bc19b1b7623ec2da64f700ede
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/masked/test_indexing.py
@@ -0,0 +1,60 @@
+import re
+
+import numpy as np
+import pytest
+
+import pandas as pd
+
+
+class TestSetitemValidation:
+    def _check_setitem_invalid(self, arr, invalid):
+        msg = f"Invalid value '{str(invalid)}' for dtype {arr.dtype}"
+        msg = re.escape(msg)
+        with pytest.raises(TypeError, match=msg):
+            arr[0] = invalid
+
+        with pytest.raises(TypeError, match=msg):
+            arr[:] = invalid
+
+        with pytest.raises(TypeError, match=msg):
+            arr[[0]] = invalid
+
+        # FIXME: don't leave commented-out
+        # with pytest.raises(TypeError):
+        #    arr[[0]] = [invalid]
+
+        # with pytest.raises(TypeError):
+        #    arr[[0]] = np.array([invalid], dtype=object)
+
+        # Series non-coercion, behavior subject to change
+        ser = pd.Series(arr)
+        with pytest.raises(TypeError, match=msg):
+            ser[0] = invalid
+            # TODO: so, so many other variants of this...
+
+    _invalid_scalars = [
+        1 + 2j,
+        "True",
+        "1",
+        "1.0",
+        pd.NaT,
+        np.datetime64("NaT"),
+        np.timedelta64("NaT"),
+    ]
+
+    @pytest.mark.parametrize(
+        "invalid", _invalid_scalars + [1, 1.0, np.int64(1), np.float64(1)]
+    )
+    def test_setitem_validation_scalar_bool(self, invalid):
+        arr = pd.array([True, False, None], dtype="boolean")
+        self._check_setitem_invalid(arr, invalid)
+
+    @pytest.mark.parametrize("invalid", _invalid_scalars + [True, 1.5, np.float64(1.5)])
+    def test_setitem_validation_scalar_int(self, invalid, any_int_ea_dtype):
+        arr = pd.array([1, 2, None], dtype=any_int_ea_dtype)
+        self._check_setitem_invalid(arr, invalid)
+
+    @pytest.mark.parametrize("invalid", _invalid_scalars + [True])
+    def test_setitem_validation_scalar_float(self, invalid, float_ea_dtype):
+        arr = pd.array([1, 2, None], dtype=float_ea_dtype)
+        self._check_setitem_invalid(arr, invalid)
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/period/__init__.py b/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/period/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/period/__pycache__/__init__.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/period/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4d4a4f55732163495db22578c5c815ad80e18185
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/period/__pycache__/__init__.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/period/__pycache__/test_arrow_compat.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/period/__pycache__/test_arrow_compat.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1eb7ba5d8d764f1ed548dbb39f81c4e05c8304fc
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/period/__pycache__/test_arrow_compat.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/period/__pycache__/test_astype.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/period/__pycache__/test_astype.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d70c6c3ddb6e3de5cff81deec39b6ec94073b5da
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/period/__pycache__/test_astype.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/period/__pycache__/test_constructors.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/period/__pycache__/test_constructors.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2e4668c8433082847e63f2f5dae51e940104554d
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/period/__pycache__/test_constructors.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/period/__pycache__/test_reductions.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/period/__pycache__/test_reductions.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..65f7874923874ce5722852285f6caee3666fc2a0
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/period/__pycache__/test_reductions.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/period/test_arrow_compat.py b/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/period/test_arrow_compat.py
new file mode 100644
index 0000000000000000000000000000000000000000..431309aca0df21dbe885ae015b10c3c21f0134a2
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/period/test_arrow_compat.py
@@ -0,0 +1,130 @@
+import pytest
+
+from pandas.compat.pyarrow import pa_version_under10p1
+
+from pandas.core.dtypes.dtypes import PeriodDtype
+
+import pandas as pd
+import pandas._testing as tm
+from pandas.core.arrays import (
+    PeriodArray,
+    period_array,
+)
+
+pytestmark = pytest.mark.filterwarnings(
+    "ignore:Passing a BlockManager to DataFrame:DeprecationWarning"
+)
+
+
+pa = pytest.importorskip("pyarrow")
+
+
+def test_arrow_extension_type():
+    from pandas.core.arrays.arrow.extension_types import ArrowPeriodType
+
+    p1 = ArrowPeriodType("D")
+    p2 = ArrowPeriodType("D")
+    p3 = ArrowPeriodType("M")
+
+    assert p1.freq == "D"
+    assert p1 == p2
+    assert p1 != p3
+    assert hash(p1) == hash(p2)
+    assert hash(p1) != hash(p3)
+
+
+@pytest.mark.xfail(not pa_version_under10p1, reason="Wrong behavior with pyarrow 10")
+@pytest.mark.parametrize(
+    "data, freq",
+    [
+        (pd.date_range("2017", periods=3), "D"),
+        (pd.date_range("2017", periods=3, freq="YE"), "Y-DEC"),
+    ],
+)
+def test_arrow_array(data, freq):
+    from pandas.core.arrays.arrow.extension_types import ArrowPeriodType
+
+    periods = period_array(data, freq=freq)
+    result = pa.array(periods)
+    assert isinstance(result.type, ArrowPeriodType)
+    assert result.type.freq == freq
+    expected = pa.array(periods.asi8, type="int64")
+    assert result.storage.equals(expected)
+
+    # convert to its storage type
+    result = pa.array(periods, type=pa.int64())
+    assert result.equals(expected)
+
+    # unsupported conversions
+    msg = "Not supported to convert PeriodArray to 'double' type"
+    with pytest.raises(TypeError, match=msg):
+        pa.array(periods, type="float64")
+
+    with pytest.raises(TypeError, match="different 'freq'"):
+        pa.array(periods, type=ArrowPeriodType("T"))
+
+
+def test_arrow_array_missing():
+    from pandas.core.arrays.arrow.extension_types import ArrowPeriodType
+
+    arr = PeriodArray([1, 2, 3], dtype="period[D]")
+    arr[1] = pd.NaT
+
+    result = pa.array(arr)
+    assert isinstance(result.type, ArrowPeriodType)
+    assert result.type.freq == "D"
+    expected = pa.array([1, None, 3], type="int64")
+    assert result.storage.equals(expected)
+
+
+def test_arrow_table_roundtrip():
+    from pandas.core.arrays.arrow.extension_types import ArrowPeriodType
+
+    arr = PeriodArray([1, 2, 3], dtype="period[D]")
+    arr[1] = pd.NaT
+    df = pd.DataFrame({"a": arr})
+
+    table = pa.table(df)
+    assert isinstance(table.field("a").type, ArrowPeriodType)
+    result = table.to_pandas()
+    assert isinstance(result["a"].dtype, PeriodDtype)
+    tm.assert_frame_equal(result, df)
+
+    table2 = pa.concat_tables([table, table])
+    result = table2.to_pandas()
+    expected = pd.concat([df, df], ignore_index=True)
+    tm.assert_frame_equal(result, expected)
+
+
+def test_arrow_load_from_zero_chunks():
+    # GH-41040
+
+    from pandas.core.arrays.arrow.extension_types import ArrowPeriodType
+
+    arr = PeriodArray([], dtype="period[D]")
+    df = pd.DataFrame({"a": arr})
+
+    table = pa.table(df)
+    assert isinstance(table.field("a").type, ArrowPeriodType)
+    table = pa.table(
+        [pa.chunked_array([], type=table.column(0).type)], schema=table.schema
+    )
+
+    result = table.to_pandas()
+    assert isinstance(result["a"].dtype, PeriodDtype)
+    tm.assert_frame_equal(result, df)
+
+
+def test_arrow_table_roundtrip_without_metadata():
+    arr = PeriodArray([1, 2, 3], dtype="period[h]")
+    arr[1] = pd.NaT
+    df = pd.DataFrame({"a": arr})
+
+    table = pa.table(df)
+    # remove the metadata
+    table = table.replace_schema_metadata()
+    assert table.schema.metadata is None
+
+    result = table.to_pandas()
+    assert isinstance(result["a"].dtype, PeriodDtype)
+    tm.assert_frame_equal(result, df)
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/period/test_astype.py b/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/period/test_astype.py
new file mode 100644
index 0000000000000000000000000000000000000000..9976c3a32580da0b5b237eaa2b839b2337363f51
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/period/test_astype.py
@@ -0,0 +1,67 @@
+import numpy as np
+import pytest
+
+from pandas.core.dtypes.dtypes import PeriodDtype
+
+import pandas as pd
+import pandas._testing as tm
+from pandas.core.arrays import period_array
+
+
+@pytest.mark.parametrize("dtype", [int, np.int32, np.int64, "uint32", "uint64"])
+def test_astype_int(dtype):
+    # We choose to ignore the sign and size of integers for
+    # Period/Datetime/Timedelta astype
+    arr = period_array(["2000", "2001", None], freq="D")
+
+    if np.dtype(dtype) != np.int64:
+        with pytest.raises(TypeError, match=r"Do obj.astype\('int64'\)"):
+            arr.astype(dtype)
+        return
+
+    result = arr.astype(dtype)
+    expected = arr._ndarray.view("i8")
+    tm.assert_numpy_array_equal(result, expected)
+
+
+def test_astype_copies():
+    arr = period_array(["2000", "2001", None], freq="D")
+    result = arr.astype(np.int64, copy=False)
+
+    # Add the `.base`, since we now use `.asi8` which returns a view.
+    # We could maybe override it in PeriodArray to return ._ndarray directly.
+    assert result.base is arr._ndarray
+
+    result = arr.astype(np.int64, copy=True)
+    assert result is not arr._ndarray
+    tm.assert_numpy_array_equal(result, arr._ndarray.view("i8"))
+
+
+def test_astype_categorical():
+    arr = period_array(["2000", "2001", "2001", None], freq="D")
+    result = arr.astype("category")
+    categories = pd.PeriodIndex(["2000", "2001"], freq="D")
+    expected = pd.Categorical.from_codes([0, 1, 1, -1], categories=categories)
+    tm.assert_categorical_equal(result, expected)
+
+
+def test_astype_period():
+    arr = period_array(["2000", "2001", None], freq="D")
+    result = arr.astype(PeriodDtype("M"))
+    expected = period_array(["2000", "2001", None], freq="M")
+    tm.assert_period_array_equal(result, expected)
+
+
+@pytest.mark.parametrize("dtype", ["datetime64[ns]", "timedelta64[ns]"])
+def test_astype_datetime(dtype):
+    arr = period_array(["2000", "2001", None], freq="D")
+    # slice off the [ns] so that the regex matches.
+    if dtype == "timedelta64[ns]":
+        with pytest.raises(TypeError, match=dtype[:-4]):
+            arr.astype(dtype)
+
+    else:
+        # GH#45038 allow period->dt64 because we allow dt64->period
+        result = arr.astype(dtype)
+        expected = pd.DatetimeIndex(["2000", "2001", pd.NaT], dtype=dtype)._data
+        tm.assert_datetime_array_equal(result, expected)
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/period/test_constructors.py b/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/period/test_constructors.py
new file mode 100644
index 0000000000000000000000000000000000000000..d034162f1b46e11bd06204de7707c7343fd9b1b2
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/period/test_constructors.py
@@ -0,0 +1,156 @@
+import numpy as np
+import pytest
+
+from pandas._libs.tslibs import iNaT
+from pandas._libs.tslibs.offsets import MonthEnd
+from pandas._libs.tslibs.period import IncompatibleFrequency
+
+import pandas as pd
+import pandas._testing as tm
+from pandas.core.arrays import (
+    PeriodArray,
+    period_array,
+)
+
+
+@pytest.mark.parametrize(
+    "data, freq, expected",
+    [
+        ([pd.Period("2017", "D")], None, [17167]),
+        ([pd.Period("2017", "D")], "D", [17167]),
+        ([2017], "D", [17167]),
+        (["2017"], "D", [17167]),
+        ([pd.Period("2017", "D")], pd.tseries.offsets.Day(), [17167]),
+        ([pd.Period("2017", "D"), None], None, [17167, iNaT]),
+        (pd.Series(pd.date_range("2017", periods=3)), None, [17167, 17168, 17169]),
+        (pd.date_range("2017", periods=3), None, [17167, 17168, 17169]),
+        (pd.period_range("2017", periods=4, freq="Q"), None, [188, 189, 190, 191]),
+    ],
+)
+def test_period_array_ok(data, freq, expected):
+    result = period_array(data, freq=freq).asi8
+    expected = np.asarray(expected, dtype=np.int64)
+    tm.assert_numpy_array_equal(result, expected)
+
+
+def test_period_array_readonly_object():
+    # https://github.com/pandas-dev/pandas/issues/25403
+    pa = period_array([pd.Period("2019-01-01")])
+    arr = np.asarray(pa, dtype="object")
+    arr.setflags(write=False)
+
+    result = period_array(arr)
+    tm.assert_period_array_equal(result, pa)
+
+    result = pd.Series(arr)
+    tm.assert_series_equal(result, pd.Series(pa))
+
+    result = pd.DataFrame({"A": arr})
+    tm.assert_frame_equal(result, pd.DataFrame({"A": pa}))
+
+
+def test_from_datetime64_freq_changes():
+    # https://github.com/pandas-dev/pandas/issues/23438
+    arr = pd.date_range("2017", periods=3, freq="D")
+    result = PeriodArray._from_datetime64(arr, freq="M")
+    expected = period_array(["2017-01-01", "2017-01-01", "2017-01-01"], freq="M")
+    tm.assert_period_array_equal(result, expected)
+
+
+@pytest.mark.parametrize("freq", ["2M", MonthEnd(2)])
+def test_from_datetime64_freq_2M(freq):
+    arr = np.array(
+        ["2020-01-01T00:00:00", "2020-01-02T00:00:00"], dtype="datetime64[ns]"
+    )
+    result = PeriodArray._from_datetime64(arr, freq)
+    expected = period_array(["2020-01", "2020-01"], freq=freq)
+    tm.assert_period_array_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "data, freq, msg",
+    [
+        (
+            [pd.Period("2017", "D"), pd.Period("2017", "Y")],
+            None,
+            "Input has different freq",
+        ),
+        ([pd.Period("2017", "D")], "Y", "Input has different freq"),
+    ],
+)
+def test_period_array_raises(data, freq, msg):
+    with pytest.raises(IncompatibleFrequency, match=msg):
+        period_array(data, freq)
+
+
+def test_period_array_non_period_series_raies():
+    ser = pd.Series([1, 2, 3])
+    with pytest.raises(TypeError, match="dtype"):
+        PeriodArray(ser, dtype="period[D]")
+
+
+def test_period_array_freq_mismatch():
+    arr = period_array(["2000", "2001"], freq="D")
+    with pytest.raises(IncompatibleFrequency, match="freq"):
+        PeriodArray(arr, dtype="period[M]")
+
+    dtype = pd.PeriodDtype(pd.tseries.offsets.MonthEnd())
+    with pytest.raises(IncompatibleFrequency, match="freq"):
+        PeriodArray(arr, dtype=dtype)
+
+
+def test_from_sequence_disallows_i8():
+    arr = period_array(["2000", "2001"], freq="D")
+
+    msg = str(arr[0].ordinal)
+    with pytest.raises(TypeError, match=msg):
+        PeriodArray._from_sequence(arr.asi8, dtype=arr.dtype)
+
+    with pytest.raises(TypeError, match=msg):
+        PeriodArray._from_sequence(list(arr.asi8), dtype=arr.dtype)
+
+
+def test_from_td64nat_sequence_raises():
+    # GH#44507
+    td = pd.NaT.to_numpy("m8[ns]")
+
+    dtype = pd.period_range("2005-01-01", periods=3, freq="D").dtype
+
+    arr = np.array([None], dtype=object)
+    arr[0] = td
+
+    msg = "Value must be Period, string, integer, or datetime"
+    with pytest.raises(ValueError, match=msg):
+        PeriodArray._from_sequence(arr, dtype=dtype)
+
+    with pytest.raises(ValueError, match=msg):
+        pd.PeriodIndex(arr, dtype=dtype)
+    with pytest.raises(ValueError, match=msg):
+        pd.Index(arr, dtype=dtype)
+    with pytest.raises(ValueError, match=msg):
+        pd.array(arr, dtype=dtype)
+    with pytest.raises(ValueError, match=msg):
+        pd.Series(arr, dtype=dtype)
+    with pytest.raises(ValueError, match=msg):
+        pd.DataFrame(arr, dtype=dtype)
+
+
+def test_freq_deprecated():
+    # GH#52462
+    data = np.arange(5).astype(np.int64)
+    msg = "The 'freq' keyword in the PeriodArray constructor is deprecated"
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        res = PeriodArray(data, freq="M")
+
+    expected = PeriodArray(data, dtype="period[M]")
+    tm.assert_equal(res, expected)
+
+
+def test_period_array_from_datetime64():
+    arr = np.array(
+        ["2020-01-01T00:00:00", "2020-02-02T00:00:00"], dtype="datetime64[ns]"
+    )
+    result = PeriodArray._from_datetime64(arr, freq=MonthEnd(2))
+
+    expected = period_array(["2020-01-01", "2020-02-01"], freq=MonthEnd(2))
+    tm.assert_period_array_equal(result, expected)
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/period/test_reductions.py b/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/period/test_reductions.py
new file mode 100644
index 0000000000000000000000000000000000000000..2889cc786dd71583ca345ad206553907af3a13fa
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/period/test_reductions.py
@@ -0,0 +1,42 @@
+import pytest
+
+import pandas as pd
+from pandas.core.arrays import period_array
+
+
+class TestReductions:
+    def test_min_max(self):
+        arr = period_array(
+            [
+                "2000-01-03",
+                "2000-01-03",
+                "NaT",
+                "2000-01-02",
+                "2000-01-05",
+                "2000-01-04",
+            ],
+            freq="D",
+        )
+
+        result = arr.min()
+        expected = pd.Period("2000-01-02", freq="D")
+        assert result == expected
+
+        result = arr.max()
+        expected = pd.Period("2000-01-05", freq="D")
+        assert result == expected
+
+        result = arr.min(skipna=False)
+        assert result is pd.NaT
+
+        result = arr.max(skipna=False)
+        assert result is pd.NaT
+
+    @pytest.mark.parametrize("skipna", [True, False])
+    def test_min_max_empty(self, skipna):
+        arr = period_array([], freq="D")
+        result = arr.min(skipna=skipna)
+        assert result is pd.NaT
+
+        result = arr.max(skipna=skipna)
+        assert result is pd.NaT
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/sparse/__init__.py b/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/sparse/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/sparse/__pycache__/test_array.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/sparse/__pycache__/test_array.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3d7dec671bfc8f669f8a4c66e77908059d16043b
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/sparse/__pycache__/test_array.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/sparse/__pycache__/test_astype.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/sparse/__pycache__/test_astype.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ba565e4655738da9e8adbeaa4f868f05aa4cb3ce
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/sparse/__pycache__/test_astype.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/sparse/__pycache__/test_combine_concat.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/sparse/__pycache__/test_combine_concat.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ce7986d514a46e78a8104b527fbe318695a29183
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/sparse/__pycache__/test_combine_concat.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/sparse/__pycache__/test_constructors.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/sparse/__pycache__/test_constructors.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..36417d69989910518ebaca6cef6df9ee62e48742
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/sparse/__pycache__/test_constructors.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/sparse/__pycache__/test_libsparse.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/sparse/__pycache__/test_libsparse.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5a83278166c8f2ea5cfff4711217fabf1862a03a
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/sparse/__pycache__/test_libsparse.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/sparse/test_arithmetics.py b/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/sparse/test_arithmetics.py
new file mode 100644
index 0000000000000000000000000000000000000000..ffc93b4e4f176385ac7b2b8a0b51027cb0bad9f6
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/sparse/test_arithmetics.py
@@ -0,0 +1,514 @@
+import operator
+
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import SparseDtype
+import pandas._testing as tm
+from pandas.core.arrays.sparse import SparseArray
+
+
+@pytest.fixture(params=["integer", "block"])
+def kind(request):
+    """kind kwarg to pass to SparseArray"""
+    return request.param
+
+
+@pytest.fixture(params=[True, False])
+def mix(request):
+    """
+    Fixture returning True or False, determining whether to operate
+    op(sparse, dense) instead of op(sparse, sparse)
+    """
+    return request.param
+
+
+class TestSparseArrayArithmetics:
+    def _assert(self, a, b):
+        # We have to use tm.assert_sp_array_equal. See GH #45126
+        tm.assert_numpy_array_equal(a, b)
+
+    def _check_numeric_ops(self, a, b, a_dense, b_dense, mix: bool, op):
+        # Check that arithmetic behavior matches non-Sparse Series arithmetic
+
+        if isinstance(a_dense, np.ndarray):
+            expected = op(pd.Series(a_dense), b_dense).values
+        elif isinstance(b_dense, np.ndarray):
+            expected = op(a_dense, pd.Series(b_dense)).values
+        else:
+            raise NotImplementedError
+
+        with np.errstate(invalid="ignore", divide="ignore"):
+            if mix:
+                result = op(a, b_dense).to_dense()
+            else:
+                result = op(a, b).to_dense()
+
+        self._assert(result, expected)
+
+    def _check_bool_result(self, res):
+        assert isinstance(res, SparseArray)
+        assert isinstance(res.dtype, SparseDtype)
+        assert res.dtype.subtype == np.bool_
+        assert isinstance(res.fill_value, bool)
+
+    def _check_comparison_ops(self, a, b, a_dense, b_dense):
+        with np.errstate(invalid="ignore"):
+            # Unfortunately, trying to wrap the computation of each expected
+            # value is with np.errstate() is too tedious.
+            #
+            # sparse & sparse
+            self._check_bool_result(a == b)
+            self._assert((a == b).to_dense(), a_dense == b_dense)
+
+            self._check_bool_result(a != b)
+            self._assert((a != b).to_dense(), a_dense != b_dense)
+
+            self._check_bool_result(a >= b)
+            self._assert((a >= b).to_dense(), a_dense >= b_dense)
+
+            self._check_bool_result(a <= b)
+            self._assert((a <= b).to_dense(), a_dense <= b_dense)
+
+            self._check_bool_result(a > b)
+            self._assert((a > b).to_dense(), a_dense > b_dense)
+
+            self._check_bool_result(a < b)
+            self._assert((a < b).to_dense(), a_dense < b_dense)
+
+            # sparse & dense
+            self._check_bool_result(a == b_dense)
+            self._assert((a == b_dense).to_dense(), a_dense == b_dense)
+
+            self._check_bool_result(a != b_dense)
+            self._assert((a != b_dense).to_dense(), a_dense != b_dense)
+
+            self._check_bool_result(a >= b_dense)
+            self._assert((a >= b_dense).to_dense(), a_dense >= b_dense)
+
+            self._check_bool_result(a <= b_dense)
+            self._assert((a <= b_dense).to_dense(), a_dense <= b_dense)
+
+            self._check_bool_result(a > b_dense)
+            self._assert((a > b_dense).to_dense(), a_dense > b_dense)
+
+            self._check_bool_result(a < b_dense)
+            self._assert((a < b_dense).to_dense(), a_dense < b_dense)
+
+    def _check_logical_ops(self, a, b, a_dense, b_dense):
+        # sparse & sparse
+        self._check_bool_result(a & b)
+        self._assert((a & b).to_dense(), a_dense & b_dense)
+
+        self._check_bool_result(a | b)
+        self._assert((a | b).to_dense(), a_dense | b_dense)
+        # sparse & dense
+        self._check_bool_result(a & b_dense)
+        self._assert((a & b_dense).to_dense(), a_dense & b_dense)
+
+        self._check_bool_result(a | b_dense)
+        self._assert((a | b_dense).to_dense(), a_dense | b_dense)
+
+    @pytest.mark.parametrize("scalar", [0, 1, 3])
+    @pytest.mark.parametrize("fill_value", [None, 0, 2])
+    def test_float_scalar(
+        self, kind, mix, all_arithmetic_functions, fill_value, scalar, request
+    ):
+        op = all_arithmetic_functions
+        values = np.array([np.nan, 1, 2, 0, np.nan, 0, 1, 2, 1, np.nan])
+        a = SparseArray(values, kind=kind, fill_value=fill_value)
+        self._check_numeric_ops(a, scalar, values, scalar, mix, op)
+
+    def test_float_scalar_comparison(self, kind):
+        values = np.array([np.nan, 1, 2, 0, np.nan, 0, 1, 2, 1, np.nan])
+
+        a = SparseArray(values, kind=kind)
+        self._check_comparison_ops(a, 1, values, 1)
+        self._check_comparison_ops(a, 0, values, 0)
+        self._check_comparison_ops(a, 3, values, 3)
+
+        a = SparseArray(values, kind=kind, fill_value=0)
+        self._check_comparison_ops(a, 1, values, 1)
+        self._check_comparison_ops(a, 0, values, 0)
+        self._check_comparison_ops(a, 3, values, 3)
+
+        a = SparseArray(values, kind=kind, fill_value=2)
+        self._check_comparison_ops(a, 1, values, 1)
+        self._check_comparison_ops(a, 0, values, 0)
+        self._check_comparison_ops(a, 3, values, 3)
+
+    def test_float_same_index_without_nans(self, kind, mix, all_arithmetic_functions):
+        # when sp_index are the same
+        op = all_arithmetic_functions
+
+        values = np.array([0.0, 1.0, 2.0, 6.0, 0.0, 0.0, 1.0, 2.0, 1.0, 0.0])
+        rvalues = np.array([0.0, 2.0, 3.0, 4.0, 0.0, 0.0, 1.0, 3.0, 2.0, 0.0])
+
+        a = SparseArray(values, kind=kind, fill_value=0)
+        b = SparseArray(rvalues, kind=kind, fill_value=0)
+        self._check_numeric_ops(a, b, values, rvalues, mix, op)
+
+    def test_float_same_index_with_nans(
+        self, kind, mix, all_arithmetic_functions, request
+    ):
+        # when sp_index are the same
+        op = all_arithmetic_functions
+        values = np.array([np.nan, 1, 2, 0, np.nan, 0, 1, 2, 1, np.nan])
+        rvalues = np.array([np.nan, 2, 3, 4, np.nan, 0, 1, 3, 2, np.nan])
+
+        a = SparseArray(values, kind=kind)
+        b = SparseArray(rvalues, kind=kind)
+        self._check_numeric_ops(a, b, values, rvalues, mix, op)
+
+    def test_float_same_index_comparison(self, kind):
+        # when sp_index are the same
+        values = np.array([np.nan, 1, 2, 0, np.nan, 0, 1, 2, 1, np.nan])
+        rvalues = np.array([np.nan, 2, 3, 4, np.nan, 0, 1, 3, 2, np.nan])
+
+        a = SparseArray(values, kind=kind)
+        b = SparseArray(rvalues, kind=kind)
+        self._check_comparison_ops(a, b, values, rvalues)
+
+        values = np.array([0.0, 1.0, 2.0, 6.0, 0.0, 0.0, 1.0, 2.0, 1.0, 0.0])
+        rvalues = np.array([0.0, 2.0, 3.0, 4.0, 0.0, 0.0, 1.0, 3.0, 2.0, 0.0])
+
+        a = SparseArray(values, kind=kind, fill_value=0)
+        b = SparseArray(rvalues, kind=kind, fill_value=0)
+        self._check_comparison_ops(a, b, values, rvalues)
+
+    def test_float_array(self, kind, mix, all_arithmetic_functions):
+        op = all_arithmetic_functions
+
+        values = np.array([np.nan, 1, 2, 0, np.nan, 0, 1, 2, 1, np.nan])
+        rvalues = np.array([2, np.nan, 2, 3, np.nan, 0, 1, 5, 2, np.nan])
+
+        a = SparseArray(values, kind=kind)
+        b = SparseArray(rvalues, kind=kind)
+        self._check_numeric_ops(a, b, values, rvalues, mix, op)
+        self._check_numeric_ops(a, b * 0, values, rvalues * 0, mix, op)
+
+        a = SparseArray(values, kind=kind, fill_value=0)
+        b = SparseArray(rvalues, kind=kind)
+        self._check_numeric_ops(a, b, values, rvalues, mix, op)
+
+        a = SparseArray(values, kind=kind, fill_value=0)
+        b = SparseArray(rvalues, kind=kind, fill_value=0)
+        self._check_numeric_ops(a, b, values, rvalues, mix, op)
+
+        a = SparseArray(values, kind=kind, fill_value=1)
+        b = SparseArray(rvalues, kind=kind, fill_value=2)
+        self._check_numeric_ops(a, b, values, rvalues, mix, op)
+
+    def test_float_array_different_kind(self, mix, all_arithmetic_functions):
+        op = all_arithmetic_functions
+
+        values = np.array([np.nan, 1, 2, 0, np.nan, 0, 1, 2, 1, np.nan])
+        rvalues = np.array([2, np.nan, 2, 3, np.nan, 0, 1, 5, 2, np.nan])
+
+        a = SparseArray(values, kind="integer")
+        b = SparseArray(rvalues, kind="block")
+        self._check_numeric_ops(a, b, values, rvalues, mix, op)
+        self._check_numeric_ops(a, b * 0, values, rvalues * 0, mix, op)
+
+        a = SparseArray(values, kind="integer", fill_value=0)
+        b = SparseArray(rvalues, kind="block")
+        self._check_numeric_ops(a, b, values, rvalues, mix, op)
+
+        a = SparseArray(values, kind="integer", fill_value=0)
+        b = SparseArray(rvalues, kind="block", fill_value=0)
+        self._check_numeric_ops(a, b, values, rvalues, mix, op)
+
+        a = SparseArray(values, kind="integer", fill_value=1)
+        b = SparseArray(rvalues, kind="block", fill_value=2)
+        self._check_numeric_ops(a, b, values, rvalues, mix, op)
+
+    def test_float_array_comparison(self, kind):
+        values = np.array([np.nan, 1, 2, 0, np.nan, 0, 1, 2, 1, np.nan])
+        rvalues = np.array([2, np.nan, 2, 3, np.nan, 0, 1, 5, 2, np.nan])
+
+        a = SparseArray(values, kind=kind)
+        b = SparseArray(rvalues, kind=kind)
+        self._check_comparison_ops(a, b, values, rvalues)
+        self._check_comparison_ops(a, b * 0, values, rvalues * 0)
+
+        a = SparseArray(values, kind=kind, fill_value=0)
+        b = SparseArray(rvalues, kind=kind)
+        self._check_comparison_ops(a, b, values, rvalues)
+
+        a = SparseArray(values, kind=kind, fill_value=0)
+        b = SparseArray(rvalues, kind=kind, fill_value=0)
+        self._check_comparison_ops(a, b, values, rvalues)
+
+        a = SparseArray(values, kind=kind, fill_value=1)
+        b = SparseArray(rvalues, kind=kind, fill_value=2)
+        self._check_comparison_ops(a, b, values, rvalues)
+
+    def test_int_array(self, kind, mix, all_arithmetic_functions):
+        op = all_arithmetic_functions
+
+        # have to specify dtype explicitly until fixing GH 667
+        dtype = np.int64
+
+        values = np.array([0, 1, 2, 0, 0, 0, 1, 2, 1, 0], dtype=dtype)
+        rvalues = np.array([2, 0, 2, 3, 0, 0, 1, 5, 2, 0], dtype=dtype)
+
+        a = SparseArray(values, dtype=dtype, kind=kind)
+        assert a.dtype == SparseDtype(dtype)
+        b = SparseArray(rvalues, dtype=dtype, kind=kind)
+        assert b.dtype == SparseDtype(dtype)
+
+        self._check_numeric_ops(a, b, values, rvalues, mix, op)
+        self._check_numeric_ops(a, b * 0, values, rvalues * 0, mix, op)
+
+        a = SparseArray(values, fill_value=0, dtype=dtype, kind=kind)
+        assert a.dtype == SparseDtype(dtype)
+        b = SparseArray(rvalues, dtype=dtype, kind=kind)
+        assert b.dtype == SparseDtype(dtype)
+
+        self._check_numeric_ops(a, b, values, rvalues, mix, op)
+
+        a = SparseArray(values, fill_value=0, dtype=dtype, kind=kind)
+        assert a.dtype == SparseDtype(dtype)
+        b = SparseArray(rvalues, fill_value=0, dtype=dtype, kind=kind)
+        assert b.dtype == SparseDtype(dtype)
+        self._check_numeric_ops(a, b, values, rvalues, mix, op)
+
+        a = SparseArray(values, fill_value=1, dtype=dtype, kind=kind)
+        assert a.dtype == SparseDtype(dtype, fill_value=1)
+        b = SparseArray(rvalues, fill_value=2, dtype=dtype, kind=kind)
+        assert b.dtype == SparseDtype(dtype, fill_value=2)
+        self._check_numeric_ops(a, b, values, rvalues, mix, op)
+
+    def test_int_array_comparison(self, kind):
+        dtype = "int64"
+        # int32 NI ATM
+
+        values = np.array([0, 1, 2, 0, 0, 0, 1, 2, 1, 0], dtype=dtype)
+        rvalues = np.array([2, 0, 2, 3, 0, 0, 1, 5, 2, 0], dtype=dtype)
+
+        a = SparseArray(values, dtype=dtype, kind=kind)
+        b = SparseArray(rvalues, dtype=dtype, kind=kind)
+        self._check_comparison_ops(a, b, values, rvalues)
+        self._check_comparison_ops(a, b * 0, values, rvalues * 0)
+
+        a = SparseArray(values, dtype=dtype, kind=kind, fill_value=0)
+        b = SparseArray(rvalues, dtype=dtype, kind=kind)
+        self._check_comparison_ops(a, b, values, rvalues)
+
+        a = SparseArray(values, dtype=dtype, kind=kind, fill_value=0)
+        b = SparseArray(rvalues, dtype=dtype, kind=kind, fill_value=0)
+        self._check_comparison_ops(a, b, values, rvalues)
+
+        a = SparseArray(values, dtype=dtype, kind=kind, fill_value=1)
+        b = SparseArray(rvalues, dtype=dtype, kind=kind, fill_value=2)
+        self._check_comparison_ops(a, b, values, rvalues)
+
+    @pytest.mark.parametrize("fill_value", [True, False, np.nan])
+    def test_bool_same_index(self, kind, fill_value):
+        # GH 14000
+        # when sp_index are the same
+        values = np.array([True, False, True, True], dtype=np.bool_)
+        rvalues = np.array([True, False, True, True], dtype=np.bool_)
+
+        a = SparseArray(values, kind=kind, dtype=np.bool_, fill_value=fill_value)
+        b = SparseArray(rvalues, kind=kind, dtype=np.bool_, fill_value=fill_value)
+        self._check_logical_ops(a, b, values, rvalues)
+
+    @pytest.mark.parametrize("fill_value", [True, False, np.nan])
+    def test_bool_array_logical(self, kind, fill_value):
+        # GH 14000
+        # when sp_index are the same
+        values = np.array([True, False, True, False, True, True], dtype=np.bool_)
+        rvalues = np.array([True, False, False, True, False, True], dtype=np.bool_)
+
+        a = SparseArray(values, kind=kind, dtype=np.bool_, fill_value=fill_value)
+        b = SparseArray(rvalues, kind=kind, dtype=np.bool_, fill_value=fill_value)
+        self._check_logical_ops(a, b, values, rvalues)
+
+    def test_mixed_array_float_int(self, kind, mix, all_arithmetic_functions, request):
+        op = all_arithmetic_functions
+        rdtype = "int64"
+        values = np.array([np.nan, 1, 2, 0, np.nan, 0, 1, 2, 1, np.nan])
+        rvalues = np.array([2, 0, 2, 3, 0, 0, 1, 5, 2, 0], dtype=rdtype)
+
+        a = SparseArray(values, kind=kind)
+        b = SparseArray(rvalues, kind=kind)
+        assert b.dtype == SparseDtype(rdtype)
+
+        self._check_numeric_ops(a, b, values, rvalues, mix, op)
+        self._check_numeric_ops(a, b * 0, values, rvalues * 0, mix, op)
+
+        a = SparseArray(values, kind=kind, fill_value=0)
+        b = SparseArray(rvalues, kind=kind)
+        assert b.dtype == SparseDtype(rdtype)
+        self._check_numeric_ops(a, b, values, rvalues, mix, op)
+
+        a = SparseArray(values, kind=kind, fill_value=0)
+        b = SparseArray(rvalues, kind=kind, fill_value=0)
+        assert b.dtype == SparseDtype(rdtype)
+        self._check_numeric_ops(a, b, values, rvalues, mix, op)
+
+        a = SparseArray(values, kind=kind, fill_value=1)
+        b = SparseArray(rvalues, kind=kind, fill_value=2)
+        assert b.dtype == SparseDtype(rdtype, fill_value=2)
+        self._check_numeric_ops(a, b, values, rvalues, mix, op)
+
+    def test_mixed_array_comparison(self, kind):
+        rdtype = "int64"
+        # int32 NI ATM
+
+        values = np.array([np.nan, 1, 2, 0, np.nan, 0, 1, 2, 1, np.nan])
+        rvalues = np.array([2, 0, 2, 3, 0, 0, 1, 5, 2, 0], dtype=rdtype)
+
+        a = SparseArray(values, kind=kind)
+        b = SparseArray(rvalues, kind=kind)
+        assert b.dtype == SparseDtype(rdtype)
+
+        self._check_comparison_ops(a, b, values, rvalues)
+        self._check_comparison_ops(a, b * 0, values, rvalues * 0)
+
+        a = SparseArray(values, kind=kind, fill_value=0)
+        b = SparseArray(rvalues, kind=kind)
+        assert b.dtype == SparseDtype(rdtype)
+        self._check_comparison_ops(a, b, values, rvalues)
+
+        a = SparseArray(values, kind=kind, fill_value=0)
+        b = SparseArray(rvalues, kind=kind, fill_value=0)
+        assert b.dtype == SparseDtype(rdtype)
+        self._check_comparison_ops(a, b, values, rvalues)
+
+        a = SparseArray(values, kind=kind, fill_value=1)
+        b = SparseArray(rvalues, kind=kind, fill_value=2)
+        assert b.dtype == SparseDtype(rdtype, fill_value=2)
+        self._check_comparison_ops(a, b, values, rvalues)
+
+    def test_xor(self):
+        s = SparseArray([True, True, False, False])
+        t = SparseArray([True, False, True, False])
+        result = s ^ t
+        sp_index = pd.core.arrays.sparse.IntIndex(4, np.array([0, 1, 2], dtype="int32"))
+        expected = SparseArray([False, True, True], sparse_index=sp_index)
+        tm.assert_sp_array_equal(result, expected)
+
+
+@pytest.mark.parametrize("op", [operator.eq, operator.add])
+def test_with_list(op):
+    arr = SparseArray([0, 1], fill_value=0)
+    result = op(arr, [0, 1])
+    expected = op(arr, SparseArray([0, 1]))
+    tm.assert_sp_array_equal(result, expected)
+
+
+def test_with_dataframe():
+    # GH#27910
+    arr = SparseArray([0, 1], fill_value=0)
+    df = pd.DataFrame([[1, 2], [3, 4]])
+    result = arr.__add__(df)
+    assert result is NotImplemented
+
+
+def test_with_zerodim_ndarray():
+    # GH#27910
+    arr = SparseArray([0, 1], fill_value=0)
+
+    result = arr * np.array(2)
+    expected = arr * 2
+    tm.assert_sp_array_equal(result, expected)
+
+
+@pytest.mark.parametrize("ufunc", [np.abs, np.exp])
+@pytest.mark.parametrize(
+    "arr", [SparseArray([0, 0, -1, 1]), SparseArray([None, None, -1, 1])]
+)
+def test_ufuncs(ufunc, arr):
+    result = ufunc(arr)
+    fill_value = ufunc(arr.fill_value)
+    expected = SparseArray(ufunc(np.asarray(arr)), fill_value=fill_value)
+    tm.assert_sp_array_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "a, b",
+    [
+        (SparseArray([0, 0, 0]), np.array([0, 1, 2])),
+        (SparseArray([0, 0, 0], fill_value=1), np.array([0, 1, 2])),
+        (SparseArray([0, 0, 0], fill_value=1), np.array([0, 1, 2])),
+        (SparseArray([0, 0, 0], fill_value=1), np.array([0, 1, 2])),
+        (SparseArray([0, 0, 0], fill_value=1), np.array([0, 1, 2])),
+    ],
+)
+@pytest.mark.parametrize("ufunc", [np.add, np.greater])
+def test_binary_ufuncs(ufunc, a, b):
+    # can't say anything about fill value here.
+    result = ufunc(a, b)
+    expected = ufunc(np.asarray(a), np.asarray(b))
+    assert isinstance(result, SparseArray)
+    tm.assert_numpy_array_equal(np.asarray(result), expected)
+
+
+def test_ndarray_inplace():
+    sparray = SparseArray([0, 2, 0, 0])
+    ndarray = np.array([0, 1, 2, 3])
+    ndarray += sparray
+    expected = np.array([0, 3, 2, 3])
+    tm.assert_numpy_array_equal(ndarray, expected)
+
+
+def test_sparray_inplace():
+    sparray = SparseArray([0, 2, 0, 0])
+    ndarray = np.array([0, 1, 2, 3])
+    sparray += ndarray
+    expected = SparseArray([0, 3, 2, 3], fill_value=0)
+    tm.assert_sp_array_equal(sparray, expected)
+
+
+@pytest.mark.parametrize("cons", [list, np.array, SparseArray])
+def test_mismatched_length_cmp_op(cons):
+    left = SparseArray([True, True])
+    right = cons([True, True, True])
+    with pytest.raises(ValueError, match="operands have mismatched length"):
+        left & right
+
+
+@pytest.mark.parametrize("op", ["add", "sub", "mul", "truediv", "floordiv", "pow"])
+@pytest.mark.parametrize("fill_value", [np.nan, 3])
+def test_binary_operators(op, fill_value):
+    op = getattr(operator, op)
+    data1 = np.random.default_rng(2).standard_normal(20)
+    data2 = np.random.default_rng(2).standard_normal(20)
+
+    data1[::2] = fill_value
+    data2[::3] = fill_value
+
+    first = SparseArray(data1, fill_value=fill_value)
+    second = SparseArray(data2, fill_value=fill_value)
+
+    with np.errstate(all="ignore"):
+        res = op(first, second)
+        exp = SparseArray(
+            op(first.to_dense(), second.to_dense()), fill_value=first.fill_value
+        )
+        assert isinstance(res, SparseArray)
+        tm.assert_almost_equal(res.to_dense(), exp.to_dense())
+
+        res2 = op(first, second.to_dense())
+        assert isinstance(res2, SparseArray)
+        tm.assert_sp_array_equal(res, res2)
+
+        res3 = op(first.to_dense(), second)
+        assert isinstance(res3, SparseArray)
+        tm.assert_sp_array_equal(res, res3)
+
+        res4 = op(first, 4)
+        assert isinstance(res4, SparseArray)
+
+        # Ignore this if the actual op raises (e.g. pow).
+        try:
+            exp = op(first.to_dense(), 4)
+            exp_fv = op(first.fill_value, 4)
+        except ValueError:
+            pass
+        else:
+            tm.assert_almost_equal(res4.fill_value, exp_fv)
+            tm.assert_almost_equal(res4.to_dense(), exp)
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/sparse/test_astype.py b/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/sparse/test_astype.py
new file mode 100644
index 0000000000000000000000000000000000000000..83a507e679d460d687b27d09a4bed8321e1199e2
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/sparse/test_astype.py
@@ -0,0 +1,133 @@
+import numpy as np
+import pytest
+
+from pandas._libs.sparse import IntIndex
+
+from pandas import (
+    SparseDtype,
+    Timestamp,
+)
+import pandas._testing as tm
+from pandas.core.arrays.sparse import SparseArray
+
+
+class TestAstype:
+    def test_astype(self):
+        # float -> float
+        arr = SparseArray([None, None, 0, 2])
+        result = arr.astype("Sparse[float32]")
+        expected = SparseArray([None, None, 0, 2], dtype=np.dtype("float32"))
+        tm.assert_sp_array_equal(result, expected)
+
+        dtype = SparseDtype("float64", fill_value=0)
+        result = arr.astype(dtype)
+        expected = SparseArray._simple_new(
+            np.array([0.0, 2.0], dtype=dtype.subtype), IntIndex(4, [2, 3]), dtype
+        )
+        tm.assert_sp_array_equal(result, expected)
+
+        dtype = SparseDtype("int64", 0)
+        result = arr.astype(dtype)
+        expected = SparseArray._simple_new(
+            np.array([0, 2], dtype=np.int64), IntIndex(4, [2, 3]), dtype
+        )
+        tm.assert_sp_array_equal(result, expected)
+
+        arr = SparseArray([0, np.nan, 0, 1], fill_value=0)
+        with pytest.raises(ValueError, match="NA"):
+            arr.astype("Sparse[i8]")
+
+    def test_astype_bool(self):
+        a = SparseArray([1, 0, 0, 1], dtype=SparseDtype(int, 0))
+        result = a.astype(bool)
+        expected = np.array([1, 0, 0, 1], dtype=bool)
+        tm.assert_numpy_array_equal(result, expected)
+
+        # update fill value
+        result = a.astype(SparseDtype(bool, False))
+        expected = SparseArray(
+            [True, False, False, True], dtype=SparseDtype(bool, False)
+        )
+        tm.assert_sp_array_equal(result, expected)
+
+    def test_astype_all(self, any_real_numpy_dtype):
+        vals = np.array([1, 2, 3])
+        arr = SparseArray(vals, fill_value=1)
+        typ = np.dtype(any_real_numpy_dtype)
+        res = arr.astype(typ)
+        tm.assert_numpy_array_equal(res, vals.astype(any_real_numpy_dtype))
+
+    @pytest.mark.parametrize(
+        "arr, dtype, expected",
+        [
+            (
+                SparseArray([0, 1]),
+                "float",
+                SparseArray([0.0, 1.0], dtype=SparseDtype(float, 0.0)),
+            ),
+            (SparseArray([0, 1]), bool, SparseArray([False, True])),
+            (
+                SparseArray([0, 1], fill_value=1),
+                bool,
+                SparseArray([False, True], dtype=SparseDtype(bool, True)),
+            ),
+            pytest.param(
+                SparseArray([0, 1]),
+                "datetime64[ns]",
+                SparseArray(
+                    np.array([0, 1], dtype="datetime64[ns]"),
+                    dtype=SparseDtype("datetime64[ns]", Timestamp("1970")),
+                ),
+            ),
+            (
+                SparseArray([0, 1, 10]),
+                str,
+                SparseArray(["0", "1", "10"], dtype=SparseDtype(str, "0")),
+            ),
+            (SparseArray(["10", "20"]), float, SparseArray([10.0, 20.0])),
+            (
+                SparseArray([0, 1, 0]),
+                object,
+                SparseArray([0, 1, 0], dtype=SparseDtype(object, 0)),
+            ),
+        ],
+    )
+    def test_astype_more(self, arr, dtype, expected):
+        result = arr.astype(arr.dtype.update_dtype(dtype))
+        tm.assert_sp_array_equal(result, expected)
+
+    def test_astype_nan_raises(self):
+        arr = SparseArray([1.0, np.nan])
+        with pytest.raises(ValueError, match="Cannot convert non-finite"):
+            arr.astype(int)
+
+    def test_astype_copy_false(self):
+        # GH#34456 bug caused by using .view instead of .astype in astype_nansafe
+        arr = SparseArray([1, 2, 3])
+
+        dtype = SparseDtype(float, 0)
+
+        result = arr.astype(dtype, copy=False)
+        expected = SparseArray([1.0, 2.0, 3.0], fill_value=0.0)
+        tm.assert_sp_array_equal(result, expected)
+
+    def test_astype_dt64_to_int64(self):
+        # GH#49631 match non-sparse behavior
+        values = np.array(["NaT", "2016-01-02", "2016-01-03"], dtype="M8[ns]")
+
+        arr = SparseArray(values)
+        result = arr.astype("int64")
+        expected = values.astype("int64")
+        tm.assert_numpy_array_equal(result, expected)
+
+        # we should also be able to cast to equivalent Sparse[int64]
+        dtype_int64 = SparseDtype("int64", np.iinfo(np.int64).min)
+        result2 = arr.astype(dtype_int64)
+        tm.assert_numpy_array_equal(result2.to_numpy(), expected)
+
+        # GH#50087 we should match the non-sparse behavior regardless of
+        #  if we have a fill_value other than NaT
+        dtype = SparseDtype("datetime64[ns]", values[1])
+        arr3 = SparseArray(values, dtype=dtype)
+        result3 = arr3.astype("int64")
+        tm.assert_numpy_array_equal(result3, expected)
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/sparse/test_combine_concat.py b/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/sparse/test_combine_concat.py
new file mode 100644
index 0000000000000000000000000000000000000000..0f09af269148bc6fec712b9b1df63cca6f44d248
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/sparse/test_combine_concat.py
@@ -0,0 +1,62 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+import pandas._testing as tm
+from pandas.core.arrays.sparse import SparseArray
+
+
+class TestSparseArrayConcat:
+    @pytest.mark.parametrize("kind", ["integer", "block"])
+    def test_basic(self, kind):
+        a = SparseArray([1, 0, 0, 2], kind=kind)
+        b = SparseArray([1, 0, 2, 2], kind=kind)
+
+        result = SparseArray._concat_same_type([a, b])
+        # Can't make any assertions about the sparse index itself
+        # since we aren't don't merge sparse blocs across arrays
+        # in to_concat
+        expected = np.array([1, 2, 1, 2, 2], dtype="int64")
+        tm.assert_numpy_array_equal(result.sp_values, expected)
+        assert result.kind == kind
+
+    @pytest.mark.parametrize("kind", ["integer", "block"])
+    def test_uses_first_kind(self, kind):
+        other = "integer" if kind == "block" else "block"
+        a = SparseArray([1, 0, 0, 2], kind=kind)
+        b = SparseArray([1, 0, 2, 2], kind=other)
+
+        result = SparseArray._concat_same_type([a, b])
+        expected = np.array([1, 2, 1, 2, 2], dtype="int64")
+        tm.assert_numpy_array_equal(result.sp_values, expected)
+        assert result.kind == kind
+
+
+@pytest.mark.parametrize(
+    "other, expected_dtype",
+    [
+        # compatible dtype -> preserve sparse
+        (pd.Series([3, 4, 5], dtype="int64"), pd.SparseDtype("int64", 0)),
+        # (pd.Series([3, 4, 5], dtype="Int64"), pd.SparseDtype("int64", 0)),
+        # incompatible dtype -> Sparse[common dtype]
+        (pd.Series([1.5, 2.5, 3.5], dtype="float64"), pd.SparseDtype("float64", 0)),
+        # incompatible dtype -> Sparse[object] dtype
+        (pd.Series(["a", "b", "c"], dtype=object), pd.SparseDtype(object, 0)),
+        # categorical with compatible categories -> dtype of the categories
+        (pd.Series([3, 4, 5], dtype="category"), np.dtype("int64")),
+        (pd.Series([1.5, 2.5, 3.5], dtype="category"), np.dtype("float64")),
+        # categorical with incompatible categories -> object dtype
+        (pd.Series(["a", "b", "c"], dtype="category"), np.dtype(object)),
+    ],
+)
+def test_concat_with_non_sparse(other, expected_dtype):
+    # https://github.com/pandas-dev/pandas/issues/34336
+    s_sparse = pd.Series([1, 0, 2], dtype=pd.SparseDtype("int64", 0))
+
+    result = pd.concat([s_sparse, other], ignore_index=True)
+    expected = pd.Series(list(s_sparse) + list(other)).astype(expected_dtype)
+    tm.assert_series_equal(result, expected)
+
+    result = pd.concat([other, s_sparse], ignore_index=True)
+    expected = pd.Series(list(other) + list(s_sparse)).astype(expected_dtype)
+    tm.assert_series_equal(result, expected)
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/sparse/test_unary.py b/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/sparse/test_unary.py
new file mode 100644
index 0000000000000000000000000000000000000000..c00a73773fdd4795e3d5d7f030a591a060dc3bfc
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/pandas/tests/arrays/sparse/test_unary.py
@@ -0,0 +1,79 @@
+import operator
+
+import numpy as np
+import pytest
+
+import pandas as pd
+import pandas._testing as tm
+from pandas.core.arrays import SparseArray
+
+
+@pytest.mark.filterwarnings("ignore:invalid value encountered in cast:RuntimeWarning")
+@pytest.mark.parametrize("fill_value", [0, np.nan])
+@pytest.mark.parametrize("op", [operator.pos, operator.neg])
+def test_unary_op(op, fill_value):
+    arr = np.array([0, 1, np.nan, 2])
+    sparray = SparseArray(arr, fill_value=fill_value)
+    result = op(sparray)
+    expected = SparseArray(op(arr), fill_value=op(fill_value))
+    tm.assert_sp_array_equal(result, expected)
+
+
+@pytest.mark.parametrize("fill_value", [True, False])
+def test_invert(fill_value):
+    arr = np.array([True, False, False, True])
+    sparray = SparseArray(arr, fill_value=fill_value)
+    result = ~sparray
+    expected = SparseArray(~arr, fill_value=not fill_value)
+    tm.assert_sp_array_equal(result, expected)
+
+    result = ~pd.Series(sparray)
+    expected = pd.Series(expected)
+    tm.assert_series_equal(result, expected)
+
+    result = ~pd.DataFrame({"A": sparray})
+    expected = pd.DataFrame({"A": expected})
+    tm.assert_frame_equal(result, expected)
+
+
+class TestUnaryMethods:
+    @pytest.mark.filterwarnings(
+        "ignore:invalid value encountered in cast:RuntimeWarning"
+    )
+    def test_neg_operator(self):
+        arr = SparseArray([-1, -2, np.nan, 3], fill_value=np.nan, dtype=np.int8)
+        res = -arr
+        exp = SparseArray([1, 2, np.nan, -3], fill_value=np.nan, dtype=np.int8)
+        tm.assert_sp_array_equal(exp, res)
+
+        arr = SparseArray([-1, -2, 1, 3], fill_value=-1, dtype=np.int8)
+        res = -arr
+        exp = SparseArray([1, 2, -1, -3], fill_value=1, dtype=np.int8)
+        tm.assert_sp_array_equal(exp, res)
+
+    @pytest.mark.filterwarnings(
+        "ignore:invalid value encountered in cast:RuntimeWarning"
+    )
+    def test_abs_operator(self):
+        arr = SparseArray([-1, -2, np.nan, 3], fill_value=np.nan, dtype=np.int8)
+        res = abs(arr)
+        exp = SparseArray([1, 2, np.nan, 3], fill_value=np.nan, dtype=np.int8)
+        tm.assert_sp_array_equal(exp, res)
+
+        arr = SparseArray([-1, -2, 1, 3], fill_value=-1, dtype=np.int8)
+        res = abs(arr)
+        exp = SparseArray([1, 2, 1, 3], fill_value=1, dtype=np.int8)
+        tm.assert_sp_array_equal(exp, res)
+
+    def test_invert_operator(self):
+        arr = SparseArray([False, True, False, True], fill_value=False, dtype=np.bool_)
+        exp = SparseArray(
+            np.invert([False, True, False, True]), fill_value=True, dtype=np.bool_
+        )
+        res = ~arr
+        tm.assert_sp_array_equal(exp, res)
+
+        arr = SparseArray([0, 1, 0, 2, 3, 0], fill_value=0, dtype=np.int32)
+        res = ~arr
+        exp = SparseArray([-1, -2, -1, -3, -4, -1], fill_value=-1, dtype=np.int32)
+        tm.assert_sp_array_equal(exp, res)
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/__init__.py b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/__pycache__/__init__.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a1046edcef6133c19e009e919ecf8e622a38e84c
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/__pycache__/__init__.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/__pycache__/conftest.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/__pycache__/conftest.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..65429e9293f095008d5e72f50a385d248dafaabb
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/__pycache__/conftest.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/__pycache__/test_api.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/__pycache__/test_api.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ec1f2a7e460b5f27e0910175d4d13a4de9bf09bc
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/__pycache__/test_api.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/__pycache__/test_apply.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/__pycache__/test_apply.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c7dbc90cc3382579fa9f86fb89e826fe014ca20f
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/__pycache__/test_apply.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/__pycache__/test_cython_aggregations.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/__pycache__/test_cython_aggregations.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..59277215e558e7780de1f5a31dd68d089a5c17c1
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/__pycache__/test_cython_aggregations.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/__pycache__/test_dtypes.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/__pycache__/test_dtypes.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7b66f84ee8a529a99d61739f4d841acba87c2627
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/__pycache__/test_dtypes.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/__pycache__/test_ewm.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/__pycache__/test_ewm.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ff96e2928fea7ec2306a458f753347ce4bb29044
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/__pycache__/test_ewm.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/__pycache__/test_expanding.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/__pycache__/test_expanding.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ac8e45700471192d280776ed09b7b3b16a189848
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/__pycache__/test_expanding.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/__pycache__/test_groupby.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/__pycache__/test_groupby.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..dd9d6771e0fdd8b97490bad728f513a7c73a0f81
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/__pycache__/test_groupby.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/__pycache__/test_numba.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/__pycache__/test_numba.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..68b69ab07a49ff3900a76455e155240c64be0878
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/__pycache__/test_numba.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/__pycache__/test_online.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/__pycache__/test_online.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ac5d6646df57f43530d97e1ba9165b3e81a7894b
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/__pycache__/test_online.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/__pycache__/test_rolling.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/__pycache__/test_rolling.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..db9e23b64f452a3af157a19a3868eb8ce7869cd9
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/__pycache__/test_rolling.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/__pycache__/test_rolling_functions.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/__pycache__/test_rolling_functions.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9af8aed09309637f717eeec5128534d0dbb71599
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/__pycache__/test_rolling_functions.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/__pycache__/test_rolling_quantile.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/__pycache__/test_rolling_quantile.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..567f1998cc5aca1bf36cfea24abd5d2b2fb6e339
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/__pycache__/test_rolling_quantile.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/__pycache__/test_timeseries_window.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/__pycache__/test_timeseries_window.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8b08c07450500fc6399927544c9e9a3aac4abfa9
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/__pycache__/test_timeseries_window.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/__pycache__/test_win_type.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/__pycache__/test_win_type.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f8e66d8440891c50fc881efacd37f42cca76fef1
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/__pycache__/test_win_type.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/conftest.py b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/conftest.py
new file mode 100644
index 0000000000000000000000000000000000000000..73ab470ab97a77a65001d62aa05be7d372fbc1f5
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/conftest.py
@@ -0,0 +1,146 @@
+from datetime import (
+    datetime,
+    timedelta,
+)
+
+import numpy as np
+import pytest
+
+import pandas.util._test_decorators as td
+
+from pandas import (
+    DataFrame,
+    Series,
+    bdate_range,
+)
+
+
+@pytest.fixture(params=[True, False])
+def raw(request):
+    """raw keyword argument for rolling.apply"""
+    return request.param
+
+
+@pytest.fixture(
+    params=[
+        "sum",
+        "mean",
+        "median",
+        "max",
+        "min",
+        "var",
+        "std",
+        "kurt",
+        "skew",
+        "count",
+        "sem",
+    ]
+)
+def arithmetic_win_operators(request):
+    return request.param
+
+
+@pytest.fixture(params=[True, False])
+def center(request):
+    return request.param
+
+
+@pytest.fixture(params=[None, 1])
+def min_periods(request):
+    return request.param
+
+
+@pytest.fixture(params=[True, False])
+def parallel(request):
+    """parallel keyword argument for numba.jit"""
+    return request.param
+
+
+# Can parameterize nogil & nopython over True | False, but limiting per
+# https://github.com/pandas-dev/pandas/pull/41971#issuecomment-860607472
+
+
+@pytest.fixture(params=[False])
+def nogil(request):
+    """nogil keyword argument for numba.jit"""
+    return request.param
+
+
+@pytest.fixture(params=[True])
+def nopython(request):
+    """nopython keyword argument for numba.jit"""
+    return request.param
+
+
+@pytest.fixture(params=[True, False])
+def adjust(request):
+    """adjust keyword argument for ewm"""
+    return request.param
+
+
+@pytest.fixture(params=[True, False])
+def ignore_na(request):
+    """ignore_na keyword argument for ewm"""
+    return request.param
+
+
+@pytest.fixture(params=[True, False])
+def numeric_only(request):
+    """numeric_only keyword argument"""
+    return request.param
+
+
+@pytest.fixture(
+    params=[
+        pytest.param("numba", marks=[td.skip_if_no("numba"), pytest.mark.single_cpu]),
+        "cython",
+    ]
+)
+def engine(request):
+    """engine keyword argument for rolling.apply"""
+    return request.param
+
+
+@pytest.fixture(
+    params=[
+        pytest.param(
+            ("numba", True), marks=[td.skip_if_no("numba"), pytest.mark.single_cpu]
+        ),
+        ("cython", True),
+        ("cython", False),
+    ]
+)
+def engine_and_raw(request):
+    """engine and raw keyword arguments for rolling.apply"""
+    return request.param
+
+
+@pytest.fixture(params=["1 day", timedelta(days=1), np.timedelta64(1, "D")])
+def halflife_with_times(request):
+    """Halflife argument for EWM when times is specified."""
+    return request.param
+
+
+@pytest.fixture
+def series():
+    """Make mocked series as fixture."""
+    arr = np.random.default_rng(2).standard_normal(100)
+    locs = np.arange(20, 40)
+    arr[locs] = np.nan
+    series = Series(arr, index=bdate_range(datetime(2009, 1, 1), periods=100))
+    return series
+
+
+@pytest.fixture
+def frame():
+    """Make mocked frame as fixture."""
+    return DataFrame(
+        np.random.default_rng(2).standard_normal((100, 10)),
+        index=bdate_range(datetime(2009, 1, 1), periods=100),
+    )
+
+
+@pytest.fixture(params=[None, 1, 2, 5, 10])
+def step(request):
+    """step keyword argument for rolling window operations."""
+    return request.param
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/moments/__init__.py b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/moments/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/moments/__pycache__/__init__.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/moments/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ea459f83aa0c4faa7cd7ea062ad308a76aa8b73b
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/moments/__pycache__/__init__.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/moments/__pycache__/conftest.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/moments/__pycache__/conftest.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0cbb520d52ae144ebc8bb09be7961b9c6e42e6f1
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/moments/__pycache__/conftest.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/moments/__pycache__/test_moments_consistency_ewm.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/moments/__pycache__/test_moments_consistency_ewm.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e049726477e5e75eb8a40750b99db88c29fad65c
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/moments/__pycache__/test_moments_consistency_ewm.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/moments/__pycache__/test_moments_consistency_expanding.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/moments/__pycache__/test_moments_consistency_expanding.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..91d6a192f0d6eb0fcf81f82873dd3df99356b1b4
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/moments/__pycache__/test_moments_consistency_expanding.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/moments/__pycache__/test_moments_consistency_rolling.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/moments/__pycache__/test_moments_consistency_rolling.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0bb6d1f37e3ab4737ec50f73fe65842497faeb0d
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/moments/__pycache__/test_moments_consistency_rolling.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/moments/conftest.py b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/moments/conftest.py
new file mode 100644
index 0000000000000000000000000000000000000000..fccf80c3c7a58d691b818709e51a9f6642956a33
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/moments/conftest.py
@@ -0,0 +1,72 @@
+import itertools
+
+import numpy as np
+import pytest
+
+from pandas import (
+    DataFrame,
+    Series,
+    notna,
+)
+
+
+def create_series():
+    return [
+        Series(dtype=np.float64, name="a"),
+        Series([np.nan] * 5),
+        Series([1.0] * 5),
+        Series(range(5, 0, -1)),
+        Series(range(5)),
+        Series([np.nan, 1.0, np.nan, 1.0, 1.0]),
+        Series([np.nan, 1.0, np.nan, 2.0, 3.0]),
+        Series([np.nan, 1.0, np.nan, 3.0, 2.0]),
+    ]
+
+
+def create_dataframes():
+    return [
+        DataFrame(columns=["a", "a"]),
+        DataFrame(np.arange(15).reshape((5, 3)), columns=["a", "a", 99]),
+    ] + [DataFrame(s) for s in create_series()]
+
+
+def is_constant(x):
+    values = x.values.ravel("K")
+    return len(set(values[notna(values)])) == 1
+
+
+@pytest.fixture(
+    params=(
+        obj
+        for obj in itertools.chain(create_series(), create_dataframes())
+        if is_constant(obj)
+    ),
+)
+def consistent_data(request):
+    return request.param
+
+
+@pytest.fixture(params=create_series())
+def series_data(request):
+    return request.param
+
+
+@pytest.fixture(params=itertools.chain(create_series(), create_dataframes()))
+def all_data(request):
+    """
+    Test:
+        - Empty Series / DataFrame
+        - All NaN
+        - All consistent value
+        - Monotonically decreasing
+        - Monotonically increasing
+        - Monotonically consistent with NaNs
+        - Monotonically increasing with NaNs
+        - Monotonically decreasing with NaNs
+    """
+    return request.param
+
+
+@pytest.fixture(params=[0, 2])
+def min_periods(request):
+    return request.param
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/moments/test_moments_consistency_ewm.py b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/moments/test_moments_consistency_ewm.py
new file mode 100644
index 0000000000000000000000000000000000000000..49dee50954f4f42365d1ee4525fa48a3e18877fe
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/moments/test_moments_consistency_ewm.py
@@ -0,0 +1,243 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    DataFrame,
+    Series,
+    concat,
+)
+import pandas._testing as tm
+
+
+def create_mock_weights(obj, com, adjust, ignore_na):
+    if isinstance(obj, DataFrame):
+        if not len(obj.columns):
+            return DataFrame(index=obj.index, columns=obj.columns)
+        w = concat(
+            [
+                create_mock_series_weights(
+                    obj.iloc[:, i], com=com, adjust=adjust, ignore_na=ignore_na
+                )
+                for i in range(len(obj.columns))
+            ],
+            axis=1,
+        )
+        w.index = obj.index
+        w.columns = obj.columns
+        return w
+    else:
+        return create_mock_series_weights(obj, com, adjust, ignore_na)
+
+
+def create_mock_series_weights(s, com, adjust, ignore_na):
+    w = Series(np.nan, index=s.index, name=s.name)
+    alpha = 1.0 / (1.0 + com)
+    if adjust:
+        count = 0
+        for i in range(len(s)):
+            if s.iat[i] == s.iat[i]:
+                w.iat[i] = pow(1.0 / (1.0 - alpha), count)
+                count += 1
+            elif not ignore_na:
+                count += 1
+    else:
+        sum_wts = 0.0
+        prev_i = -1
+        count = 0
+        for i in range(len(s)):
+            if s.iat[i] == s.iat[i]:
+                if prev_i == -1:
+                    w.iat[i] = 1.0
+                else:
+                    w.iat[i] = alpha * sum_wts / pow(1.0 - alpha, count - prev_i)
+                sum_wts += w.iat[i]
+                prev_i = count
+                count += 1
+            elif not ignore_na:
+                count += 1
+    return w
+
+
+def test_ewm_consistency_mean(all_data, adjust, ignore_na, min_periods):
+    com = 3.0
+
+    result = all_data.ewm(
+        com=com, min_periods=min_periods, adjust=adjust, ignore_na=ignore_na
+    ).mean()
+    weights = create_mock_weights(all_data, com=com, adjust=adjust, ignore_na=ignore_na)
+    expected = all_data.multiply(weights).cumsum().divide(weights.cumsum()).ffill()
+    expected[
+        all_data.expanding().count() < (max(min_periods, 1) if min_periods else 1)
+    ] = np.nan
+    tm.assert_equal(result, expected.astype("float64"))
+
+
+def test_ewm_consistency_consistent(consistent_data, adjust, ignore_na, min_periods):
+    com = 3.0
+
+    count_x = consistent_data.expanding().count()
+    mean_x = consistent_data.ewm(
+        com=com, min_periods=min_periods, adjust=adjust, ignore_na=ignore_na
+    ).mean()
+    # check that correlation of a series with itself is either 1 or NaN
+    corr_x_x = consistent_data.ewm(
+        com=com, min_periods=min_periods, adjust=adjust, ignore_na=ignore_na
+    ).corr(consistent_data)
+    exp = (
+        consistent_data.max()
+        if isinstance(consistent_data, Series)
+        else consistent_data.max().max()
+    )
+
+    # check mean of constant series
+    expected = consistent_data * np.nan
+    expected[count_x >= max(min_periods, 1)] = exp
+    tm.assert_equal(mean_x, expected)
+
+    # check correlation of constant series with itself is NaN
+    expected[:] = np.nan
+    tm.assert_equal(corr_x_x, expected)
+
+
+def test_ewm_consistency_var_debiasing_factors(
+    all_data, adjust, ignore_na, min_periods
+):
+    com = 3.0
+
+    # check variance debiasing factors
+    var_unbiased_x = all_data.ewm(
+        com=com, min_periods=min_periods, adjust=adjust, ignore_na=ignore_na
+    ).var(bias=False)
+    var_biased_x = all_data.ewm(
+        com=com, min_periods=min_periods, adjust=adjust, ignore_na=ignore_na
+    ).var(bias=True)
+
+    weights = create_mock_weights(all_data, com=com, adjust=adjust, ignore_na=ignore_na)
+    cum_sum = weights.cumsum().ffill()
+    cum_sum_sq = (weights * weights).cumsum().ffill()
+    numerator = cum_sum * cum_sum
+    denominator = numerator - cum_sum_sq
+    denominator[denominator <= 0.0] = np.nan
+    var_debiasing_factors_x = numerator / denominator
+
+    tm.assert_equal(var_unbiased_x, var_biased_x * var_debiasing_factors_x)
+
+
+@pytest.mark.parametrize("bias", [True, False])
+def test_moments_consistency_var(all_data, adjust, ignore_na, min_periods, bias):
+    com = 3.0
+
+    mean_x = all_data.ewm(
+        com=com, min_periods=min_periods, adjust=adjust, ignore_na=ignore_na
+    ).mean()
+    var_x = all_data.ewm(
+        com=com, min_periods=min_periods, adjust=adjust, ignore_na=ignore_na
+    ).var(bias=bias)
+    assert not (var_x < 0).any().any()
+
+    if bias:
+        # check that biased var(x) == mean(x^2) - mean(x)^2
+        mean_x2 = (
+            (all_data * all_data)
+            .ewm(com=com, min_periods=min_periods, adjust=adjust, ignore_na=ignore_na)
+            .mean()
+        )
+        tm.assert_equal(var_x, mean_x2 - (mean_x * mean_x))
+
+
+@pytest.mark.parametrize("bias", [True, False])
+def test_moments_consistency_var_constant(
+    consistent_data, adjust, ignore_na, min_periods, bias
+):
+    com = 3.0
+    count_x = consistent_data.expanding(min_periods=min_periods).count()
+    var_x = consistent_data.ewm(
+        com=com, min_periods=min_periods, adjust=adjust, ignore_na=ignore_na
+    ).var(bias=bias)
+
+    # check that variance of constant series is identically 0
+    assert not (var_x > 0).any().any()
+    expected = consistent_data * np.nan
+    expected[count_x >= max(min_periods, 1)] = 0.0
+    if not bias:
+        expected[count_x < 2] = np.nan
+    tm.assert_equal(var_x, expected)
+
+
+@pytest.mark.parametrize("bias", [True, False])
+def test_ewm_consistency_std(all_data, adjust, ignore_na, min_periods, bias):
+    com = 3.0
+    var_x = all_data.ewm(
+        com=com, min_periods=min_periods, adjust=adjust, ignore_na=ignore_na
+    ).var(bias=bias)
+    assert not (var_x < 0).any().any()
+
+    std_x = all_data.ewm(
+        com=com, min_periods=min_periods, adjust=adjust, ignore_na=ignore_na
+    ).std(bias=bias)
+    assert not (std_x < 0).any().any()
+
+    # check that var(x) == std(x)^2
+    tm.assert_equal(var_x, std_x * std_x)
+
+    cov_x_x = all_data.ewm(
+        com=com, min_periods=min_periods, adjust=adjust, ignore_na=ignore_na
+    ).cov(all_data, bias=bias)
+    assert not (cov_x_x < 0).any().any()
+
+    # check that var(x) == cov(x, x)
+    tm.assert_equal(var_x, cov_x_x)
+
+
+@pytest.mark.parametrize("bias", [True, False])
+def test_ewm_consistency_series_cov_corr(
+    series_data, adjust, ignore_na, min_periods, bias
+):
+    com = 3.0
+
+    var_x_plus_y = (
+        (series_data + series_data)
+        .ewm(com=com, min_periods=min_periods, adjust=adjust, ignore_na=ignore_na)
+        .var(bias=bias)
+    )
+    var_x = series_data.ewm(
+        com=com, min_periods=min_periods, adjust=adjust, ignore_na=ignore_na
+    ).var(bias=bias)
+    var_y = series_data.ewm(
+        com=com, min_periods=min_periods, adjust=adjust, ignore_na=ignore_na
+    ).var(bias=bias)
+    cov_x_y = series_data.ewm(
+        com=com, min_periods=min_periods, adjust=adjust, ignore_na=ignore_na
+    ).cov(series_data, bias=bias)
+    # check that cov(x, y) == (var(x+y) - var(x) -
+    # var(y)) / 2
+    tm.assert_equal(cov_x_y, 0.5 * (var_x_plus_y - var_x - var_y))
+
+    # check that corr(x, y) == cov(x, y) / (std(x) *
+    # std(y))
+    corr_x_y = series_data.ewm(
+        com=com, min_periods=min_periods, adjust=adjust, ignore_na=ignore_na
+    ).corr(series_data)
+    std_x = series_data.ewm(
+        com=com, min_periods=min_periods, adjust=adjust, ignore_na=ignore_na
+    ).std(bias=bias)
+    std_y = series_data.ewm(
+        com=com, min_periods=min_periods, adjust=adjust, ignore_na=ignore_na
+    ).std(bias=bias)
+    tm.assert_equal(corr_x_y, cov_x_y / (std_x * std_y))
+
+    if bias:
+        # check that biased cov(x, y) == mean(x*y) -
+        # mean(x)*mean(y)
+        mean_x = series_data.ewm(
+            com=com, min_periods=min_periods, adjust=adjust, ignore_na=ignore_na
+        ).mean()
+        mean_y = series_data.ewm(
+            com=com, min_periods=min_periods, adjust=adjust, ignore_na=ignore_na
+        ).mean()
+        mean_x_times_y = (
+            (series_data * series_data)
+            .ewm(com=com, min_periods=min_periods, adjust=adjust, ignore_na=ignore_na)
+            .mean()
+        )
+        tm.assert_equal(cov_x_y, mean_x_times_y - (mean_x * mean_y))
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/moments/test_moments_consistency_expanding.py b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/moments/test_moments_consistency_expanding.py
new file mode 100644
index 0000000000000000000000000000000000000000..7d2fa1ad5d21175dcfafe9a57dd8169fc4413360
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/moments/test_moments_consistency_expanding.py
@@ -0,0 +1,144 @@
+import numpy as np
+import pytest
+
+from pandas import Series
+import pandas._testing as tm
+
+
+def no_nans(x):
+    return x.notna().all().all()
+
+
+def all_na(x):
+    return x.isnull().all().all()
+
+
+@pytest.mark.parametrize("f", [lambda v: Series(v).sum(), np.nansum, np.sum])
+def test_expanding_apply_consistency_sum_nans(request, all_data, min_periods, f):
+    if f is np.sum:
+        if not no_nans(all_data) and not (
+            all_na(all_data) and not all_data.empty and min_periods > 0
+        ):
+            request.applymarker(
+                pytest.mark.xfail(reason="np.sum has different behavior with NaNs")
+            )
+    expanding_f_result = all_data.expanding(min_periods=min_periods).sum()
+    expanding_apply_f_result = all_data.expanding(min_periods=min_periods).apply(
+        func=f, raw=True
+    )
+    tm.assert_equal(expanding_f_result, expanding_apply_f_result)
+
+
+@pytest.mark.parametrize("ddof", [0, 1])
+def test_moments_consistency_var(all_data, min_periods, ddof):
+    var_x = all_data.expanding(min_periods=min_periods).var(ddof=ddof)
+    assert not (var_x < 0).any().any()
+
+    if ddof == 0:
+        # check that biased var(x) == mean(x^2) - mean(x)^2
+        mean_x2 = (all_data * all_data).expanding(min_periods=min_periods).mean()
+        mean_x = all_data.expanding(min_periods=min_periods).mean()
+        tm.assert_equal(var_x, mean_x2 - (mean_x * mean_x))
+
+
+@pytest.mark.parametrize("ddof", [0, 1])
+def test_moments_consistency_var_constant(consistent_data, min_periods, ddof):
+    count_x = consistent_data.expanding(min_periods=min_periods).count()
+    var_x = consistent_data.expanding(min_periods=min_periods).var(ddof=ddof)
+
+    # check that variance of constant series is identically 0
+    assert not (var_x > 0).any().any()
+    expected = consistent_data * np.nan
+    expected[count_x >= max(min_periods, 1)] = 0.0
+    if ddof == 1:
+        expected[count_x < 2] = np.nan
+    tm.assert_equal(var_x, expected)
+
+
+@pytest.mark.parametrize("ddof", [0, 1])
+def test_expanding_consistency_var_std_cov(all_data, min_periods, ddof):
+    var_x = all_data.expanding(min_periods=min_periods).var(ddof=ddof)
+    assert not (var_x < 0).any().any()
+
+    std_x = all_data.expanding(min_periods=min_periods).std(ddof=ddof)
+    assert not (std_x < 0).any().any()
+
+    # check that var(x) == std(x)^2
+    tm.assert_equal(var_x, std_x * std_x)
+
+    cov_x_x = all_data.expanding(min_periods=min_periods).cov(all_data, ddof=ddof)
+    assert not (cov_x_x < 0).any().any()
+
+    # check that var(x) == cov(x, x)
+    tm.assert_equal(var_x, cov_x_x)
+
+
+@pytest.mark.parametrize("ddof", [0, 1])
+def test_expanding_consistency_series_cov_corr(series_data, min_periods, ddof):
+    var_x_plus_y = (
+        (series_data + series_data).expanding(min_periods=min_periods).var(ddof=ddof)
+    )
+    var_x = series_data.expanding(min_periods=min_periods).var(ddof=ddof)
+    var_y = series_data.expanding(min_periods=min_periods).var(ddof=ddof)
+    cov_x_y = series_data.expanding(min_periods=min_periods).cov(series_data, ddof=ddof)
+    # check that cov(x, y) == (var(x+y) - var(x) -
+    # var(y)) / 2
+    tm.assert_equal(cov_x_y, 0.5 * (var_x_plus_y - var_x - var_y))
+
+    # check that corr(x, y) == cov(x, y) / (std(x) *
+    # std(y))
+    corr_x_y = series_data.expanding(min_periods=min_periods).corr(series_data)
+    std_x = series_data.expanding(min_periods=min_periods).std(ddof=ddof)
+    std_y = series_data.expanding(min_periods=min_periods).std(ddof=ddof)
+    tm.assert_equal(corr_x_y, cov_x_y / (std_x * std_y))
+
+    if ddof == 0:
+        # check that biased cov(x, y) == mean(x*y) -
+        # mean(x)*mean(y)
+        mean_x = series_data.expanding(min_periods=min_periods).mean()
+        mean_y = series_data.expanding(min_periods=min_periods).mean()
+        mean_x_times_y = (
+            (series_data * series_data).expanding(min_periods=min_periods).mean()
+        )
+        tm.assert_equal(cov_x_y, mean_x_times_y - (mean_x * mean_y))
+
+
+def test_expanding_consistency_mean(all_data, min_periods):
+    result = all_data.expanding(min_periods=min_periods).mean()
+    expected = (
+        all_data.expanding(min_periods=min_periods).sum()
+        / all_data.expanding(min_periods=min_periods).count()
+    )
+    tm.assert_equal(result, expected.astype("float64"))
+
+
+def test_expanding_consistency_constant(consistent_data, min_periods):
+    count_x = consistent_data.expanding().count()
+    mean_x = consistent_data.expanding(min_periods=min_periods).mean()
+    # check that correlation of a series with itself is either 1 or NaN
+    corr_x_x = consistent_data.expanding(min_periods=min_periods).corr(consistent_data)
+
+    exp = (
+        consistent_data.max()
+        if isinstance(consistent_data, Series)
+        else consistent_data.max().max()
+    )
+
+    # check mean of constant series
+    expected = consistent_data * np.nan
+    expected[count_x >= max(min_periods, 1)] = exp
+    tm.assert_equal(mean_x, expected)
+
+    # check correlation of constant series with itself is NaN
+    expected[:] = np.nan
+    tm.assert_equal(corr_x_x, expected)
+
+
+def test_expanding_consistency_var_debiasing_factors(all_data, min_periods):
+    # check variance debiasing factors
+    var_unbiased_x = all_data.expanding(min_periods=min_periods).var()
+    var_biased_x = all_data.expanding(min_periods=min_periods).var(ddof=0)
+    var_debiasing_factors_x = all_data.expanding().count() / (
+        all_data.expanding().count() - 1.0
+    ).replace(0.0, np.nan)
+    tm.assert_equal(var_unbiased_x, var_biased_x * var_debiasing_factors_x)
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/moments/test_moments_consistency_rolling.py b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/moments/test_moments_consistency_rolling.py
new file mode 100644
index 0000000000000000000000000000000000000000..be22338c00cb28fb4fbd1bfe7f4b6163e239a432
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/moments/test_moments_consistency_rolling.py
@@ -0,0 +1,244 @@
+import numpy as np
+import pytest
+
+from pandas import Series
+import pandas._testing as tm
+
+
+def no_nans(x):
+    return x.notna().all().all()
+
+
+def all_na(x):
+    return x.isnull().all().all()
+
+
+@pytest.fixture(params=[(1, 0), (5, 1)])
+def rolling_consistency_cases(request):
+    """window, min_periods"""
+    return request.param
+
+
+@pytest.mark.parametrize("f", [lambda v: Series(v).sum(), np.nansum, np.sum])
+def test_rolling_apply_consistency_sum(
+    request, all_data, rolling_consistency_cases, center, f
+):
+    window, min_periods = rolling_consistency_cases
+
+    if f is np.sum:
+        if not no_nans(all_data) and not (
+            all_na(all_data) and not all_data.empty and min_periods > 0
+        ):
+            request.applymarker(
+                pytest.mark.xfail(reason="np.sum has different behavior with NaNs")
+            )
+    rolling_f_result = all_data.rolling(
+        window=window, min_periods=min_periods, center=center
+    ).sum()
+    rolling_apply_f_result = all_data.rolling(
+        window=window, min_periods=min_periods, center=center
+    ).apply(func=f, raw=True)
+    tm.assert_equal(rolling_f_result, rolling_apply_f_result)
+
+
+@pytest.mark.parametrize("ddof", [0, 1])
+def test_moments_consistency_var(all_data, rolling_consistency_cases, center, ddof):
+    window, min_periods = rolling_consistency_cases
+
+    var_x = all_data.rolling(window=window, min_periods=min_periods, center=center).var(
+        ddof=ddof
+    )
+    assert not (var_x < 0).any().any()
+
+    if ddof == 0:
+        # check that biased var(x) == mean(x^2) - mean(x)^2
+        mean_x = all_data.rolling(
+            window=window, min_periods=min_periods, center=center
+        ).mean()
+        mean_x2 = (
+            (all_data * all_data)
+            .rolling(window=window, min_periods=min_periods, center=center)
+            .mean()
+        )
+        tm.assert_equal(var_x, mean_x2 - (mean_x * mean_x))
+
+
+@pytest.mark.parametrize("ddof", [0, 1])
+def test_moments_consistency_var_constant(
+    consistent_data, rolling_consistency_cases, center, ddof
+):
+    window, min_periods = rolling_consistency_cases
+
+    count_x = consistent_data.rolling(
+        window=window, min_periods=min_periods, center=center
+    ).count()
+    var_x = consistent_data.rolling(
+        window=window, min_periods=min_periods, center=center
+    ).var(ddof=ddof)
+
+    # check that variance of constant series is identically 0
+    assert not (var_x > 0).any().any()
+    expected = consistent_data * np.nan
+    expected[count_x >= max(min_periods, 1)] = 0.0
+    if ddof == 1:
+        expected[count_x < 2] = np.nan
+    tm.assert_equal(var_x, expected)
+
+
+@pytest.mark.parametrize("ddof", [0, 1])
+def test_rolling_consistency_var_std_cov(
+    all_data, rolling_consistency_cases, center, ddof
+):
+    window, min_periods = rolling_consistency_cases
+
+    var_x = all_data.rolling(window=window, min_periods=min_periods, center=center).var(
+        ddof=ddof
+    )
+    assert not (var_x < 0).any().any()
+
+    std_x = all_data.rolling(window=window, min_periods=min_periods, center=center).std(
+        ddof=ddof
+    )
+    assert not (std_x < 0).any().any()
+
+    # check that var(x) == std(x)^2
+    tm.assert_equal(var_x, std_x * std_x)
+
+    cov_x_x = all_data.rolling(
+        window=window, min_periods=min_periods, center=center
+    ).cov(all_data, ddof=ddof)
+    assert not (cov_x_x < 0).any().any()
+
+    # check that var(x) == cov(x, x)
+    tm.assert_equal(var_x, cov_x_x)
+
+
+@pytest.mark.parametrize("ddof", [0, 1])
+def test_rolling_consistency_series_cov_corr(
+    series_data, rolling_consistency_cases, center, ddof
+):
+    window, min_periods = rolling_consistency_cases
+
+    var_x_plus_y = (
+        (series_data + series_data)
+        .rolling(window=window, min_periods=min_periods, center=center)
+        .var(ddof=ddof)
+    )
+    var_x = series_data.rolling(
+        window=window, min_periods=min_periods, center=center
+    ).var(ddof=ddof)
+    var_y = series_data.rolling(
+        window=window, min_periods=min_periods, center=center
+    ).var(ddof=ddof)
+    cov_x_y = series_data.rolling(
+        window=window, min_periods=min_periods, center=center
+    ).cov(series_data, ddof=ddof)
+    # check that cov(x, y) == (var(x+y) - var(x) -
+    # var(y)) / 2
+    tm.assert_equal(cov_x_y, 0.5 * (var_x_plus_y - var_x - var_y))
+
+    # check that corr(x, y) == cov(x, y) / (std(x) *
+    # std(y))
+    corr_x_y = series_data.rolling(
+        window=window, min_periods=min_periods, center=center
+    ).corr(series_data)
+    std_x = series_data.rolling(
+        window=window, min_periods=min_periods, center=center
+    ).std(ddof=ddof)
+    std_y = series_data.rolling(
+        window=window, min_periods=min_periods, center=center
+    ).std(ddof=ddof)
+    tm.assert_equal(corr_x_y, cov_x_y / (std_x * std_y))
+
+    if ddof == 0:
+        # check that biased cov(x, y) == mean(x*y) -
+        # mean(x)*mean(y)
+        mean_x = series_data.rolling(
+            window=window, min_periods=min_periods, center=center
+        ).mean()
+        mean_y = series_data.rolling(
+            window=window, min_periods=min_periods, center=center
+        ).mean()
+        mean_x_times_y = (
+            (series_data * series_data)
+            .rolling(window=window, min_periods=min_periods, center=center)
+            .mean()
+        )
+        tm.assert_equal(cov_x_y, mean_x_times_y - (mean_x * mean_y))
+
+
+def test_rolling_consistency_mean(all_data, rolling_consistency_cases, center):
+    window, min_periods = rolling_consistency_cases
+
+    result = all_data.rolling(
+        window=window, min_periods=min_periods, center=center
+    ).mean()
+    expected = (
+        all_data.rolling(window=window, min_periods=min_periods, center=center)
+        .sum()
+        .divide(
+            all_data.rolling(
+                window=window, min_periods=min_periods, center=center
+            ).count()
+        )
+    )
+    tm.assert_equal(result, expected.astype("float64"))
+
+
+def test_rolling_consistency_constant(
+    consistent_data, rolling_consistency_cases, center
+):
+    window, min_periods = rolling_consistency_cases
+
+    count_x = consistent_data.rolling(
+        window=window, min_periods=min_periods, center=center
+    ).count()
+    mean_x = consistent_data.rolling(
+        window=window, min_periods=min_periods, center=center
+    ).mean()
+    # check that correlation of a series with itself is either 1 or NaN
+    corr_x_x = consistent_data.rolling(
+        window=window, min_periods=min_periods, center=center
+    ).corr(consistent_data)
+
+    exp = (
+        consistent_data.max()
+        if isinstance(consistent_data, Series)
+        else consistent_data.max().max()
+    )
+
+    # check mean of constant series
+    expected = consistent_data * np.nan
+    expected[count_x >= max(min_periods, 1)] = exp
+    tm.assert_equal(mean_x, expected)
+
+    # check correlation of constant series with itself is NaN
+    expected[:] = np.nan
+    tm.assert_equal(corr_x_x, expected)
+
+
+def test_rolling_consistency_var_debiasing_factors(
+    all_data, rolling_consistency_cases, center
+):
+    window, min_periods = rolling_consistency_cases
+
+    # check variance debiasing factors
+    var_unbiased_x = all_data.rolling(
+        window=window, min_periods=min_periods, center=center
+    ).var()
+    var_biased_x = all_data.rolling(
+        window=window, min_periods=min_periods, center=center
+    ).var(ddof=0)
+    var_debiasing_factors_x = (
+        all_data.rolling(window=window, min_periods=min_periods, center=center)
+        .count()
+        .divide(
+            (
+                all_data.rolling(
+                    window=window, min_periods=min_periods, center=center
+                ).count()
+                - 1.0
+            ).replace(0.0, np.nan)
+        )
+    )
+    tm.assert_equal(var_unbiased_x, var_biased_x * var_debiasing_factors_x)
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/test_api.py b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/test_api.py
new file mode 100644
index 0000000000000000000000000000000000000000..fe2da210c6fe9d955a359974d8c05b57b64703cf
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/test_api.py
@@ -0,0 +1,398 @@
+import numpy as np
+import pytest
+
+from pandas.errors import (
+    DataError,
+    SpecificationError,
+)
+
+from pandas import (
+    DataFrame,
+    Index,
+    MultiIndex,
+    Period,
+    Series,
+    Timestamp,
+    concat,
+    date_range,
+    timedelta_range,
+)
+import pandas._testing as tm
+
+
+def test_getitem(step):
+    frame = DataFrame(np.random.default_rng(2).standard_normal((5, 5)))
+    r = frame.rolling(window=5, step=step)
+    tm.assert_index_equal(r._selected_obj.columns, frame[::step].columns)
+
+    r = frame.rolling(window=5, step=step)[1]
+    assert r._selected_obj.name == frame[::step].columns[1]
+
+    # technically this is allowed
+    r = frame.rolling(window=5, step=step)[1, 3]
+    tm.assert_index_equal(r._selected_obj.columns, frame[::step].columns[[1, 3]])
+
+    r = frame.rolling(window=5, step=step)[[1, 3]]
+    tm.assert_index_equal(r._selected_obj.columns, frame[::step].columns[[1, 3]])
+
+
+def test_select_bad_cols():
+    df = DataFrame([[1, 2]], columns=["A", "B"])
+    g = df.rolling(window=5)
+    with pytest.raises(KeyError, match="Columns not found: 'C'"):
+        g[["C"]]
+    with pytest.raises(KeyError, match="^[^A]+$"):
+        # A should not be referenced as a bad column...
+        # will have to rethink regex if you change message!
+        g[["A", "C"]]
+
+
+def test_attribute_access():
+    df = DataFrame([[1, 2]], columns=["A", "B"])
+    r = df.rolling(window=5)
+    tm.assert_series_equal(r.A.sum(), r["A"].sum())
+    msg = "'Rolling' object has no attribute 'F'"
+    with pytest.raises(AttributeError, match=msg):
+        r.F
+
+
+def tests_skip_nuisance(step):
+    df = DataFrame({"A": range(5), "B": range(5, 10), "C": "foo"})
+    r = df.rolling(window=3, step=step)
+    result = r[["A", "B"]].sum()
+    expected = DataFrame(
+        {"A": [np.nan, np.nan, 3, 6, 9], "B": [np.nan, np.nan, 18, 21, 24]},
+        columns=list("AB"),
+    )[::step]
+    tm.assert_frame_equal(result, expected)
+
+
+def test_sum_object_str_raises(step):
+    df = DataFrame({"A": range(5), "B": range(5, 10), "C": "foo"})
+    r = df.rolling(window=3, step=step)
+    with pytest.raises(
+        DataError, match="Cannot aggregate non-numeric type: object|string"
+    ):
+        # GH#42738, enforced in 2.0
+        r.sum()
+
+
+def test_agg(step):
+    df = DataFrame({"A": range(5), "B": range(0, 10, 2)})
+
+    r = df.rolling(window=3, step=step)
+    a_mean = r["A"].mean()
+    a_std = r["A"].std()
+    a_sum = r["A"].sum()
+    b_mean = r["B"].mean()
+    b_std = r["B"].std()
+
+    with tm.assert_produces_warning(FutureWarning, match="using Rolling.[mean|std]"):
+        result = r.aggregate([np.mean, np.std])
+    expected = concat([a_mean, a_std, b_mean, b_std], axis=1)
+    expected.columns = MultiIndex.from_product([["A", "B"], ["mean", "std"]])
+    tm.assert_frame_equal(result, expected)
+
+    with tm.assert_produces_warning(FutureWarning, match="using Rolling.[mean|std]"):
+        result = r.aggregate({"A": np.mean, "B": np.std})
+
+    expected = concat([a_mean, b_std], axis=1)
+    tm.assert_frame_equal(result, expected, check_like=True)
+
+    result = r.aggregate({"A": ["mean", "std"]})
+    expected = concat([a_mean, a_std], axis=1)
+    expected.columns = MultiIndex.from_tuples([("A", "mean"), ("A", "std")])
+    tm.assert_frame_equal(result, expected)
+
+    result = r["A"].aggregate(["mean", "sum"])
+    expected = concat([a_mean, a_sum], axis=1)
+    expected.columns = ["mean", "sum"]
+    tm.assert_frame_equal(result, expected)
+
+    msg = "nested renamer is not supported"
+    with pytest.raises(SpecificationError, match=msg):
+        # using a dict with renaming
+        r.aggregate({"A": {"mean": "mean", "sum": "sum"}})
+
+    with pytest.raises(SpecificationError, match=msg):
+        r.aggregate(
+            {"A": {"mean": "mean", "sum": "sum"}, "B": {"mean2": "mean", "sum2": "sum"}}
+        )
+
+    result = r.aggregate({"A": ["mean", "std"], "B": ["mean", "std"]})
+    expected = concat([a_mean, a_std, b_mean, b_std], axis=1)
+
+    exp_cols = [("A", "mean"), ("A", "std"), ("B", "mean"), ("B", "std")]
+    expected.columns = MultiIndex.from_tuples(exp_cols)
+    tm.assert_frame_equal(result, expected, check_like=True)
+
+
+@pytest.mark.parametrize(
+    "func", [["min"], ["mean", "max"], {"b": "sum"}, {"b": "prod", "c": "median"}]
+)
+def test_multi_axis_1_raises(func):
+    # GH#46904
+    df = DataFrame({"a": [1, 1, 2], "b": [3, 4, 5], "c": [6, 7, 8]})
+    msg = "Support for axis=1 in DataFrame.rolling is deprecated"
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        r = df.rolling(window=3, axis=1)
+    with pytest.raises(NotImplementedError, match="axis other than 0 is not supported"):
+        r.agg(func)
+
+
+def test_agg_apply(raw):
+    # passed lambda
+    df = DataFrame({"A": range(5), "B": range(0, 10, 2)})
+
+    r = df.rolling(window=3)
+    a_sum = r["A"].sum()
+
+    with tm.assert_produces_warning(FutureWarning, match="using Rolling.[sum|std]"):
+        result = r.agg({"A": np.sum, "B": lambda x: np.std(x, ddof=1)})
+    rcustom = r["B"].apply(lambda x: np.std(x, ddof=1), raw=raw)
+    expected = concat([a_sum, rcustom], axis=1)
+    tm.assert_frame_equal(result, expected, check_like=True)
+
+
+def test_agg_consistency(step):
+    df = DataFrame({"A": range(5), "B": range(0, 10, 2)})
+    r = df.rolling(window=3, step=step)
+
+    with tm.assert_produces_warning(FutureWarning, match="using Rolling.[sum|mean]"):
+        result = r.agg([np.sum, np.mean]).columns
+    expected = MultiIndex.from_product([list("AB"), ["sum", "mean"]])
+    tm.assert_index_equal(result, expected)
+
+    with tm.assert_produces_warning(FutureWarning, match="using Rolling.[sum|mean]"):
+        result = r["A"].agg([np.sum, np.mean]).columns
+    expected = Index(["sum", "mean"])
+    tm.assert_index_equal(result, expected)
+
+    with tm.assert_produces_warning(FutureWarning, match="using Rolling.[sum|mean]"):
+        result = r.agg({"A": [np.sum, np.mean]}).columns
+    expected = MultiIndex.from_tuples([("A", "sum"), ("A", "mean")])
+    tm.assert_index_equal(result, expected)
+
+
+def test_agg_nested_dicts():
+    # API change for disallowing these types of nested dicts
+    df = DataFrame({"A": range(5), "B": range(0, 10, 2)})
+    r = df.rolling(window=3)
+
+    msg = "nested renamer is not supported"
+    with pytest.raises(SpecificationError, match=msg):
+        r.aggregate({"r1": {"A": ["mean", "sum"]}, "r2": {"B": ["mean", "sum"]}})
+
+    expected = concat(
+        [r["A"].mean(), r["A"].std(), r["B"].mean(), r["B"].std()], axis=1
+    )
+    expected.columns = MultiIndex.from_tuples(
+        [("ra", "mean"), ("ra", "std"), ("rb", "mean"), ("rb", "std")]
+    )
+    with pytest.raises(SpecificationError, match=msg):
+        r[["A", "B"]].agg({"A": {"ra": ["mean", "std"]}, "B": {"rb": ["mean", "std"]}})
+
+    with pytest.raises(SpecificationError, match=msg):
+        r.agg({"A": {"ra": ["mean", "std"]}, "B": {"rb": ["mean", "std"]}})
+
+
+def test_count_nonnumeric_types(step):
+    # GH12541
+    cols = [
+        "int",
+        "float",
+        "string",
+        "datetime",
+        "timedelta",
+        "periods",
+        "fl_inf",
+        "fl_nan",
+        "str_nan",
+        "dt_nat",
+        "periods_nat",
+    ]
+    dt_nat_col = [Timestamp("20170101"), Timestamp("20170203"), Timestamp(None)]
+
+    df = DataFrame(
+        {
+            "int": [1, 2, 3],
+            "float": [4.0, 5.0, 6.0],
+            "string": list("abc"),
+            "datetime": date_range("20170101", periods=3),
+            "timedelta": timedelta_range("1 s", periods=3, freq="s"),
+            "periods": [
+                Period("2012-01"),
+                Period("2012-02"),
+                Period("2012-03"),
+            ],
+            "fl_inf": [1.0, 2.0, np.inf],
+            "fl_nan": [1.0, 2.0, np.nan],
+            "str_nan": ["aa", "bb", np.nan],
+            "dt_nat": dt_nat_col,
+            "periods_nat": [
+                Period("2012-01"),
+                Period("2012-02"),
+                Period(None),
+            ],
+        },
+        columns=cols,
+    )
+
+    expected = DataFrame(
+        {
+            "int": [1.0, 2.0, 2.0],
+            "float": [1.0, 2.0, 2.0],
+            "string": [1.0, 2.0, 2.0],
+            "datetime": [1.0, 2.0, 2.0],
+            "timedelta": [1.0, 2.0, 2.0],
+            "periods": [1.0, 2.0, 2.0],
+            "fl_inf": [1.0, 2.0, 2.0],
+            "fl_nan": [1.0, 2.0, 1.0],
+            "str_nan": [1.0, 2.0, 1.0],
+            "dt_nat": [1.0, 2.0, 1.0],
+            "periods_nat": [1.0, 2.0, 1.0],
+        },
+        columns=cols,
+    )[::step]
+
+    result = df.rolling(window=2, min_periods=0, step=step).count()
+    tm.assert_frame_equal(result, expected)
+
+    result = df.rolling(1, min_periods=0, step=step).count()
+    expected = df.notna().astype(float)[::step]
+    tm.assert_frame_equal(result, expected)
+
+
+def test_preserve_metadata():
+    # GH 10565
+    s = Series(np.arange(100), name="foo")
+
+    s2 = s.rolling(30).sum()
+    s3 = s.rolling(20).sum()
+    assert s2.name == "foo"
+    assert s3.name == "foo"
+
+
+@pytest.mark.parametrize(
+    "func,window_size,expected_vals",
+    [
+        (
+            "rolling",
+            2,
+            [
+                [np.nan, np.nan, np.nan, np.nan],
+                [15.0, 20.0, 25.0, 20.0],
+                [25.0, 30.0, 35.0, 30.0],
+                [np.nan, np.nan, np.nan, np.nan],
+                [20.0, 30.0, 35.0, 30.0],
+                [35.0, 40.0, 60.0, 40.0],
+                [60.0, 80.0, 85.0, 80],
+            ],
+        ),
+        (
+            "expanding",
+            None,
+            [
+                [10.0, 10.0, 20.0, 20.0],
+                [15.0, 20.0, 25.0, 20.0],
+                [20.0, 30.0, 30.0, 20.0],
+                [10.0, 10.0, 30.0, 30.0],
+                [20.0, 30.0, 35.0, 30.0],
+                [26.666667, 40.0, 50.0, 30.0],
+                [40.0, 80.0, 60.0, 30.0],
+            ],
+        ),
+    ],
+)
+def test_multiple_agg_funcs(func, window_size, expected_vals):
+    # GH 15072
+    df = DataFrame(
+        [
+            ["A", 10, 20],
+            ["A", 20, 30],
+            ["A", 30, 40],
+            ["B", 10, 30],
+            ["B", 30, 40],
+            ["B", 40, 80],
+            ["B", 80, 90],
+        ],
+        columns=["stock", "low", "high"],
+    )
+
+    f = getattr(df.groupby("stock"), func)
+    if window_size:
+        window = f(window_size)
+    else:
+        window = f()
+
+    index = MultiIndex.from_tuples(
+        [("A", 0), ("A", 1), ("A", 2), ("B", 3), ("B", 4), ("B", 5), ("B", 6)],
+        names=["stock", None],
+    )
+    columns = MultiIndex.from_tuples(
+        [("low", "mean"), ("low", "max"), ("high", "mean"), ("high", "min")]
+    )
+    expected = DataFrame(expected_vals, index=index, columns=columns)
+
+    result = window.agg({"low": ["mean", "max"], "high": ["mean", "min"]})
+
+    tm.assert_frame_equal(result, expected)
+
+
+def test_dont_modify_attributes_after_methods(
+    arithmetic_win_operators, closed, center, min_periods, step
+):
+    # GH 39554
+    roll_obj = Series(range(1)).rolling(
+        1, center=center, closed=closed, min_periods=min_periods, step=step
+    )
+    expected = {attr: getattr(roll_obj, attr) for attr in roll_obj._attributes}
+    getattr(roll_obj, arithmetic_win_operators)()
+    result = {attr: getattr(roll_obj, attr) for attr in roll_obj._attributes}
+    assert result == expected
+
+
+def test_centered_axis_validation(step):
+    # ok
+    msg = "The 'axis' keyword in Series.rolling is deprecated"
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        Series(np.ones(10)).rolling(window=3, center=True, axis=0, step=step).mean()
+
+    # bad axis
+    msg = "No axis named 1 for object type Series"
+    with pytest.raises(ValueError, match=msg):
+        Series(np.ones(10)).rolling(window=3, center=True, axis=1, step=step).mean()
+
+    # ok ok
+    df = DataFrame(np.ones((10, 10)))
+    msg = "The 'axis' keyword in DataFrame.rolling is deprecated"
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        df.rolling(window=3, center=True, axis=0, step=step).mean()
+    msg = "Support for axis=1 in DataFrame.rolling is deprecated"
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        df.rolling(window=3, center=True, axis=1, step=step).mean()
+
+    # bad axis
+    msg = "No axis named 2 for object type DataFrame"
+    with pytest.raises(ValueError, match=msg):
+        (df.rolling(window=3, center=True, axis=2, step=step).mean())
+
+
+def test_rolling_min_min_periods(step):
+    a = Series([1, 2, 3, 4, 5])
+    result = a.rolling(window=100, min_periods=1, step=step).min()
+    expected = Series(np.ones(len(a)))[::step]
+    tm.assert_series_equal(result, expected)
+    msg = "min_periods 5 must be <= window 3"
+    with pytest.raises(ValueError, match=msg):
+        Series([1, 2, 3]).rolling(window=3, min_periods=5, step=step).min()
+
+
+def test_rolling_max_min_periods(step):
+    a = Series([1, 2, 3, 4, 5], dtype=np.float64)
+    result = a.rolling(window=100, min_periods=1, step=step).max()
+    expected = a[::step]
+    tm.assert_almost_equal(result, expected)
+    msg = "min_periods 5 must be <= window 3"
+    with pytest.raises(ValueError, match=msg):
+        Series([1, 2, 3]).rolling(window=3, min_periods=5, step=step).max()
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/test_apply.py b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/test_apply.py
new file mode 100644
index 0000000000000000000000000000000000000000..136f81632cb0ad1f8847379e656ff5e3bf028cd3
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/test_apply.py
@@ -0,0 +1,328 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    DataFrame,
+    Index,
+    MultiIndex,
+    Series,
+    Timestamp,
+    concat,
+    date_range,
+    isna,
+    notna,
+)
+import pandas._testing as tm
+
+from pandas.tseries import offsets
+
+# suppress warnings about empty slices, as we are deliberately testing
+# with a 0-length Series
+pytestmark = pytest.mark.filterwarnings(
+    "ignore:.*(empty slice|0 for slice).*:RuntimeWarning"
+)
+
+
+def f(x):
+    return x[np.isfinite(x)].mean()
+
+
+@pytest.mark.parametrize("bad_raw", [None, 1, 0])
+def test_rolling_apply_invalid_raw(bad_raw):
+    with pytest.raises(ValueError, match="raw parameter must be `True` or `False`"):
+        Series(range(3)).rolling(1).apply(len, raw=bad_raw)
+
+
+def test_rolling_apply_out_of_bounds(engine_and_raw):
+    # gh-1850
+    engine, raw = engine_and_raw
+
+    vals = Series([1, 2, 3, 4])
+
+    result = vals.rolling(10).apply(np.sum, engine=engine, raw=raw)
+    assert result.isna().all()
+
+    result = vals.rolling(10, min_periods=1).apply(np.sum, engine=engine, raw=raw)
+    expected = Series([1, 3, 6, 10], dtype=float)
+    tm.assert_almost_equal(result, expected)
+
+
+@pytest.mark.parametrize("window", [2, "2s"])
+def test_rolling_apply_with_pandas_objects(window):
+    # 5071
+    df = DataFrame(
+        {
+            "A": np.random.default_rng(2).standard_normal(5),
+            "B": np.random.default_rng(2).integers(0, 10, size=5),
+        },
+        index=date_range("20130101", periods=5, freq="s"),
+    )
+
+    # we have an equal spaced timeseries index
+    # so simulate removing the first period
+    def f(x):
+        if x.index[0] == df.index[0]:
+            return np.nan
+        return x.iloc[-1]
+
+    result = df.rolling(window).apply(f, raw=False)
+    expected = df.iloc[2:].reindex_like(df)
+    tm.assert_frame_equal(result, expected)
+
+    with tm.external_error_raised(AttributeError):
+        df.rolling(window).apply(f, raw=True)
+
+
+def test_rolling_apply(engine_and_raw, step):
+    engine, raw = engine_and_raw
+
+    expected = Series([], dtype="float64")
+    result = expected.rolling(10, step=step).apply(
+        lambda x: x.mean(), engine=engine, raw=raw
+    )
+    tm.assert_series_equal(result, expected)
+
+    # gh-8080
+    s = Series([None, None, None])
+    result = s.rolling(2, min_periods=0, step=step).apply(
+        lambda x: len(x), engine=engine, raw=raw
+    )
+    expected = Series([1.0, 2.0, 2.0])[::step]
+    tm.assert_series_equal(result, expected)
+
+    result = s.rolling(2, min_periods=0, step=step).apply(len, engine=engine, raw=raw)
+    tm.assert_series_equal(result, expected)
+
+
+def test_all_apply(engine_and_raw):
+    engine, raw = engine_and_raw
+
+    df = (
+        DataFrame(
+            {"A": date_range("20130101", periods=5, freq="s"), "B": range(5)}
+        ).set_index("A")
+        * 2
+    )
+    er = df.rolling(window=1)
+    r = df.rolling(window="1s")
+
+    result = r.apply(lambda x: 1, engine=engine, raw=raw)
+    expected = er.apply(lambda x: 1, engine=engine, raw=raw)
+    tm.assert_frame_equal(result, expected)
+
+
+def test_ragged_apply(engine_and_raw):
+    engine, raw = engine_and_raw
+
+    df = DataFrame({"B": range(5)})
+    df.index = [
+        Timestamp("20130101 09:00:00"),
+        Timestamp("20130101 09:00:02"),
+        Timestamp("20130101 09:00:03"),
+        Timestamp("20130101 09:00:05"),
+        Timestamp("20130101 09:00:06"),
+    ]
+
+    f = lambda x: 1
+    result = df.rolling(window="1s", min_periods=1).apply(f, engine=engine, raw=raw)
+    expected = df.copy()
+    expected["B"] = 1.0
+    tm.assert_frame_equal(result, expected)
+
+    result = df.rolling(window="2s", min_periods=1).apply(f, engine=engine, raw=raw)
+    expected = df.copy()
+    expected["B"] = 1.0
+    tm.assert_frame_equal(result, expected)
+
+    result = df.rolling(window="5s", min_periods=1).apply(f, engine=engine, raw=raw)
+    expected = df.copy()
+    expected["B"] = 1.0
+    tm.assert_frame_equal(result, expected)
+
+
+def test_invalid_engine():
+    with pytest.raises(ValueError, match="engine must be either 'numba' or 'cython'"):
+        Series(range(1)).rolling(1).apply(lambda x: x, engine="foo")
+
+
+def test_invalid_engine_kwargs_cython():
+    with pytest.raises(ValueError, match="cython engine does not accept engine_kwargs"):
+        Series(range(1)).rolling(1).apply(
+            lambda x: x, engine="cython", engine_kwargs={"nopython": False}
+        )
+
+
+def test_invalid_raw_numba():
+    with pytest.raises(
+        ValueError, match="raw must be `True` when using the numba engine"
+    ):
+        Series(range(1)).rolling(1).apply(lambda x: x, raw=False, engine="numba")
+
+
+@pytest.mark.parametrize("args_kwargs", [[None, {"par": 10}], [(10,), None]])
+def test_rolling_apply_args_kwargs(args_kwargs):
+    # GH 33433
+    def numpysum(x, par):
+        return np.sum(x + par)
+
+    df = DataFrame({"gr": [1, 1], "a": [1, 2]})
+
+    idx = Index(["gr", "a"])
+    expected = DataFrame([[11.0, 11.0], [11.0, 12.0]], columns=idx)
+
+    result = df.rolling(1).apply(numpysum, args=args_kwargs[0], kwargs=args_kwargs[1])
+    tm.assert_frame_equal(result, expected)
+
+    midx = MultiIndex.from_tuples([(1, 0), (1, 1)], names=["gr", None])
+    expected = Series([11.0, 12.0], index=midx, name="a")
+
+    gb_rolling = df.groupby("gr")["a"].rolling(1)
+
+    result = gb_rolling.apply(numpysum, args=args_kwargs[0], kwargs=args_kwargs[1])
+    tm.assert_series_equal(result, expected)
+
+
+def test_nans(raw):
+    obj = Series(np.random.default_rng(2).standard_normal(50))
+    obj[:10] = np.nan
+    obj[-10:] = np.nan
+
+    result = obj.rolling(50, min_periods=30).apply(f, raw=raw)
+    tm.assert_almost_equal(result.iloc[-1], np.mean(obj[10:-10]))
+
+    # min_periods is working correctly
+    result = obj.rolling(20, min_periods=15).apply(f, raw=raw)
+    assert isna(result.iloc[23])
+    assert not isna(result.iloc[24])
+
+    assert not isna(result.iloc[-6])
+    assert isna(result.iloc[-5])
+
+    obj2 = Series(np.random.default_rng(2).standard_normal(20))
+    result = obj2.rolling(10, min_periods=5).apply(f, raw=raw)
+    assert isna(result.iloc[3])
+    assert notna(result.iloc[4])
+
+    result0 = obj.rolling(20, min_periods=0).apply(f, raw=raw)
+    result1 = obj.rolling(20, min_periods=1).apply(f, raw=raw)
+    tm.assert_almost_equal(result0, result1)
+
+
+def test_center(raw):
+    obj = Series(np.random.default_rng(2).standard_normal(50))
+    obj[:10] = np.nan
+    obj[-10:] = np.nan
+
+    result = obj.rolling(20, min_periods=15, center=True).apply(f, raw=raw)
+    expected = (
+        concat([obj, Series([np.nan] * 9)])
+        .rolling(20, min_periods=15)
+        .apply(f, raw=raw)
+        .iloc[9:]
+        .reset_index(drop=True)
+    )
+    tm.assert_series_equal(result, expected)
+
+
+def test_series(raw, series):
+    result = series.rolling(50).apply(f, raw=raw)
+    assert isinstance(result, Series)
+    tm.assert_almost_equal(result.iloc[-1], np.mean(series[-50:]))
+
+
+def test_frame(raw, frame):
+    result = frame.rolling(50).apply(f, raw=raw)
+    assert isinstance(result, DataFrame)
+    tm.assert_series_equal(
+        result.iloc[-1, :],
+        frame.iloc[-50:, :].apply(np.mean, axis=0, raw=raw),
+        check_names=False,
+    )
+
+
+def test_time_rule_series(raw, series):
+    win = 25
+    minp = 10
+    ser = series[::2].resample("B").mean()
+    series_result = ser.rolling(window=win, min_periods=minp).apply(f, raw=raw)
+    last_date = series_result.index[-1]
+    prev_date = last_date - 24 * offsets.BDay()
+
+    trunc_series = series[::2].truncate(prev_date, last_date)
+    tm.assert_almost_equal(series_result.iloc[-1], np.mean(trunc_series))
+
+
+def test_time_rule_frame(raw, frame):
+    win = 25
+    minp = 10
+    frm = frame[::2].resample("B").mean()
+    frame_result = frm.rolling(window=win, min_periods=minp).apply(f, raw=raw)
+    last_date = frame_result.index[-1]
+    prev_date = last_date - 24 * offsets.BDay()
+
+    trunc_frame = frame[::2].truncate(prev_date, last_date)
+    tm.assert_series_equal(
+        frame_result.xs(last_date),
+        trunc_frame.apply(np.mean, raw=raw),
+        check_names=False,
+    )
+
+
+@pytest.mark.parametrize("minp", [0, 99, 100])
+def test_min_periods(raw, series, minp, step):
+    result = series.rolling(len(series) + 1, min_periods=minp, step=step).apply(
+        f, raw=raw
+    )
+    expected = series.rolling(len(series), min_periods=minp, step=step).apply(
+        f, raw=raw
+    )
+    nan_mask = isna(result)
+    tm.assert_series_equal(nan_mask, isna(expected))
+
+    nan_mask = ~nan_mask
+    tm.assert_almost_equal(result[nan_mask], expected[nan_mask])
+
+
+def test_center_reindex_series(raw, series):
+    # shifter index
+    s = [f"x{x:d}" for x in range(12)]
+    minp = 10
+
+    series_xp = (
+        series.reindex(list(series.index) + s)
+        .rolling(window=25, min_periods=minp)
+        .apply(f, raw=raw)
+        .shift(-12)
+        .reindex(series.index)
+    )
+    series_rs = series.rolling(window=25, min_periods=minp, center=True).apply(
+        f, raw=raw
+    )
+    tm.assert_series_equal(series_xp, series_rs)
+
+
+def test_center_reindex_frame(raw):
+    # shifter index
+    frame = DataFrame(range(100), index=date_range("2020-01-01", freq="D", periods=100))
+    s = [f"x{x:d}" for x in range(12)]
+    minp = 10
+
+    frame_xp = (
+        frame.reindex(list(frame.index) + s)
+        .rolling(window=25, min_periods=minp)
+        .apply(f, raw=raw)
+        .shift(-12)
+        .reindex(frame.index)
+    )
+    frame_rs = frame.rolling(window=25, min_periods=minp, center=True).apply(f, raw=raw)
+    tm.assert_frame_equal(frame_xp, frame_rs)
+
+
+def test_axis1(raw):
+    # GH 45912
+    df = DataFrame([1, 2])
+    msg = "Support for axis=1 in DataFrame.rolling is deprecated"
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        result = df.rolling(window=1, axis=1).apply(np.sum, raw=raw)
+    expected = DataFrame([1.0, 2.0])
+    tm.assert_frame_equal(result, expected)
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/test_base_indexer.py b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/test_base_indexer.py
new file mode 100644
index 0000000000000000000000000000000000000000..104acc1d527cb8dbd92b20211fb760dd413a0757
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/test_base_indexer.py
@@ -0,0 +1,519 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    DataFrame,
+    MultiIndex,
+    Series,
+    concat,
+    date_range,
+)
+import pandas._testing as tm
+from pandas.api.indexers import (
+    BaseIndexer,
+    FixedForwardWindowIndexer,
+)
+from pandas.core.indexers.objects import (
+    ExpandingIndexer,
+    FixedWindowIndexer,
+    VariableOffsetWindowIndexer,
+)
+
+from pandas.tseries.offsets import BusinessDay
+
+
+def test_bad_get_window_bounds_signature():
+    class BadIndexer(BaseIndexer):
+        def get_window_bounds(self):
+            return None
+
+    indexer = BadIndexer()
+    with pytest.raises(ValueError, match="BadIndexer does not implement"):
+        Series(range(5)).rolling(indexer)
+
+
+def test_expanding_indexer():
+    s = Series(range(10))
+    indexer = ExpandingIndexer()
+    result = s.rolling(indexer).mean()
+    expected = s.expanding().mean()
+    tm.assert_series_equal(result, expected)
+
+
+def test_indexer_constructor_arg():
+    # Example found in computation.rst
+    use_expanding = [True, False, True, False, True]
+    df = DataFrame({"values": range(5)})
+
+    class CustomIndexer(BaseIndexer):
+        def get_window_bounds(self, num_values, min_periods, center, closed, step):
+            start = np.empty(num_values, dtype=np.int64)
+            end = np.empty(num_values, dtype=np.int64)
+            for i in range(num_values):
+                if self.use_expanding[i]:
+                    start[i] = 0
+                    end[i] = i + 1
+                else:
+                    start[i] = i
+                    end[i] = i + self.window_size
+            return start, end
+
+    indexer = CustomIndexer(window_size=1, use_expanding=use_expanding)
+    result = df.rolling(indexer).sum()
+    expected = DataFrame({"values": [0.0, 1.0, 3.0, 3.0, 10.0]})
+    tm.assert_frame_equal(result, expected)
+
+
+def test_indexer_accepts_rolling_args():
+    df = DataFrame({"values": range(5)})
+
+    class CustomIndexer(BaseIndexer):
+        def get_window_bounds(self, num_values, min_periods, center, closed, step):
+            start = np.empty(num_values, dtype=np.int64)
+            end = np.empty(num_values, dtype=np.int64)
+            for i in range(num_values):
+                if (
+                    center
+                    and min_periods == 1
+                    and closed == "both"
+                    and step == 1
+                    and i == 2
+                ):
+                    start[i] = 0
+                    end[i] = num_values
+                else:
+                    start[i] = i
+                    end[i] = i + self.window_size
+            return start, end
+
+    indexer = CustomIndexer(window_size=1)
+    result = df.rolling(
+        indexer, center=True, min_periods=1, closed="both", step=1
+    ).sum()
+    expected = DataFrame({"values": [0.0, 1.0, 10.0, 3.0, 4.0]})
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "func,np_func,expected,np_kwargs",
+    [
+        ("count", len, [3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 2.0, np.nan], {}),
+        ("min", np.min, [0.0, 1.0, 2.0, 3.0, 4.0, 6.0, 6.0, 7.0, 8.0, np.nan], {}),
+        (
+            "max",
+            np.max,
+            [2.0, 3.0, 4.0, 100.0, 100.0, 100.0, 8.0, 9.0, 9.0, np.nan],
+            {},
+        ),
+        (
+            "std",
+            np.std,
+            [
+                1.0,
+                1.0,
+                1.0,
+                55.71654452,
+                54.85739087,
+                53.9845657,
+                1.0,
+                1.0,
+                0.70710678,
+                np.nan,
+            ],
+            {"ddof": 1},
+        ),
+        (
+            "var",
+            np.var,
+            [
+                1.0,
+                1.0,
+                1.0,
+                3104.333333,
+                3009.333333,
+                2914.333333,
+                1.0,
+                1.0,
+                0.500000,
+                np.nan,
+            ],
+            {"ddof": 1},
+        ),
+        (
+            "median",
+            np.median,
+            [1.0, 2.0, 3.0, 4.0, 6.0, 7.0, 7.0, 8.0, 8.5, np.nan],
+            {},
+        ),
+    ],
+)
+def test_rolling_forward_window(
+    frame_or_series, func, np_func, expected, np_kwargs, step
+):
+    # GH 32865
+    values = np.arange(10.0)
+    values[5] = 100.0
+
+    indexer = FixedForwardWindowIndexer(window_size=3)
+
+    match = "Forward-looking windows can't have center=True"
+    with pytest.raises(ValueError, match=match):
+        rolling = frame_or_series(values).rolling(window=indexer, center=True)
+        getattr(rolling, func)()
+
+    match = "Forward-looking windows don't support setting the closed argument"
+    with pytest.raises(ValueError, match=match):
+        rolling = frame_or_series(values).rolling(window=indexer, closed="right")
+        getattr(rolling, func)()
+
+    rolling = frame_or_series(values).rolling(window=indexer, min_periods=2, step=step)
+    result = getattr(rolling, func)()
+
+    # Check that the function output matches the explicitly provided array
+    expected = frame_or_series(expected)[::step]
+    tm.assert_equal(result, expected)
+
+    # Check that the rolling function output matches applying an alternative
+    # function to the rolling window object
+    expected2 = frame_or_series(rolling.apply(lambda x: np_func(x, **np_kwargs)))
+    tm.assert_equal(result, expected2)
+
+    # Check that the function output matches applying an alternative function
+    # if min_periods isn't specified
+    # GH 39604: After count-min_periods deprecation, apply(lambda x: len(x))
+    # is equivalent to count after setting min_periods=0
+    min_periods = 0 if func == "count" else None
+    rolling3 = frame_or_series(values).rolling(window=indexer, min_periods=min_periods)
+    result3 = getattr(rolling3, func)()
+    expected3 = frame_or_series(rolling3.apply(lambda x: np_func(x, **np_kwargs)))
+    tm.assert_equal(result3, expected3)
+
+
+def test_rolling_forward_skewness(frame_or_series, step):
+    values = np.arange(10.0)
+    values[5] = 100.0
+
+    indexer = FixedForwardWindowIndexer(window_size=5)
+    rolling = frame_or_series(values).rolling(window=indexer, min_periods=3, step=step)
+    result = rolling.skew()
+
+    expected = frame_or_series(
+        [
+            0.0,
+            2.232396,
+            2.229508,
+            2.228340,
+            2.229091,
+            2.231989,
+            0.0,
+            0.0,
+            np.nan,
+            np.nan,
+        ]
+    )[::step]
+    tm.assert_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "func,expected",
+    [
+        ("cov", [2.0, 2.0, 2.0, 97.0, 2.0, -93.0, 2.0, 2.0, np.nan, np.nan]),
+        (
+            "corr",
+            [
+                1.0,
+                1.0,
+                1.0,
+                0.8704775290207161,
+                0.018229084250926637,
+                -0.861357304646493,
+                1.0,
+                1.0,
+                np.nan,
+                np.nan,
+            ],
+        ),
+    ],
+)
+def test_rolling_forward_cov_corr(func, expected):
+    values1 = np.arange(10).reshape(-1, 1)
+    values2 = values1 * 2
+    values1[5, 0] = 100
+    values = np.concatenate([values1, values2], axis=1)
+
+    indexer = FixedForwardWindowIndexer(window_size=3)
+    rolling = DataFrame(values).rolling(window=indexer, min_periods=3)
+    # We are interested in checking only pairwise covariance / correlation
+    result = getattr(rolling, func)().loc[(slice(None), 1), 0]
+    result = result.reset_index(drop=True)
+    expected = Series(expected).reset_index(drop=True)
+    expected.name = result.name
+    tm.assert_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "closed,expected_data",
+    [
+        ["right", [0.0, 1.0, 2.0, 3.0, 7.0, 12.0, 6.0, 7.0, 8.0, 9.0]],
+        ["left", [0.0, 0.0, 1.0, 2.0, 5.0, 9.0, 5.0, 6.0, 7.0, 8.0]],
+    ],
+)
+def test_non_fixed_variable_window_indexer(closed, expected_data):
+    index = date_range("2020", periods=10)
+    df = DataFrame(range(10), index=index)
+    offset = BusinessDay(1)
+    indexer = VariableOffsetWindowIndexer(index=index, offset=offset)
+    result = df.rolling(indexer, closed=closed).sum()
+    expected = DataFrame(expected_data, index=index)
+    tm.assert_frame_equal(result, expected)
+
+
+def test_variableoffsetwindowindexer_not_dti():
+    # GH 54379
+    with pytest.raises(ValueError, match="index must be a DatetimeIndex."):
+        VariableOffsetWindowIndexer(index="foo", offset=BusinessDay(1))
+
+
+def test_variableoffsetwindowindexer_not_offset():
+    # GH 54379
+    idx = date_range("2020", periods=10)
+    with pytest.raises(ValueError, match="offset must be a DateOffset-like object."):
+        VariableOffsetWindowIndexer(index=idx, offset="foo")
+
+
+def test_fixed_forward_indexer_count(step):
+    # GH: 35579
+    df = DataFrame({"b": [None, None, None, 7]})
+    indexer = FixedForwardWindowIndexer(window_size=2)
+    result = df.rolling(window=indexer, min_periods=0, step=step).count()
+    expected = DataFrame({"b": [0.0, 0.0, 1.0, 1.0]})[::step]
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    ("end_value", "values"), [(1, [0.0, 1, 1, 3, 2]), (-1, [0.0, 1, 0, 3, 1])]
+)
+@pytest.mark.parametrize(("func", "args"), [("median", []), ("quantile", [0.5])])
+def test_indexer_quantile_sum(end_value, values, func, args):
+    # GH 37153
+    class CustomIndexer(BaseIndexer):
+        def get_window_bounds(self, num_values, min_periods, center, closed, step):
+            start = np.empty(num_values, dtype=np.int64)
+            end = np.empty(num_values, dtype=np.int64)
+            for i in range(num_values):
+                if self.use_expanding[i]:
+                    start[i] = 0
+                    end[i] = max(i + end_value, 1)
+                else:
+                    start[i] = i
+                    end[i] = i + self.window_size
+            return start, end
+
+    use_expanding = [True, False, True, False, True]
+    df = DataFrame({"values": range(5)})
+
+    indexer = CustomIndexer(window_size=1, use_expanding=use_expanding)
+    result = getattr(df.rolling(indexer), func)(*args)
+    expected = DataFrame({"values": values})
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "indexer_class", [FixedWindowIndexer, FixedForwardWindowIndexer, ExpandingIndexer]
+)
+@pytest.mark.parametrize("window_size", [1, 2, 12])
+@pytest.mark.parametrize(
+    "df_data",
+    [
+        {"a": [1, 1], "b": [0, 1]},
+        {"a": [1, 2], "b": [0, 1]},
+        {"a": [1] * 16, "b": [np.nan, 1, 2, np.nan] + list(range(4, 16))},
+    ],
+)
+def test_indexers_are_reusable_after_groupby_rolling(
+    indexer_class, window_size, df_data
+):
+    # GH 43267
+    df = DataFrame(df_data)
+    num_trials = 3
+    indexer = indexer_class(window_size=window_size)
+    original_window_size = indexer.window_size
+    for i in range(num_trials):
+        df.groupby("a")["b"].rolling(window=indexer, min_periods=1).mean()
+        assert indexer.window_size == original_window_size
+
+
+@pytest.mark.parametrize(
+    "window_size, num_values, expected_start, expected_end",
+    [
+        (1, 1, [0], [1]),
+        (1, 2, [0, 1], [1, 2]),
+        (2, 1, [0], [1]),
+        (2, 2, [0, 1], [2, 2]),
+        (5, 12, range(12), list(range(5, 12)) + [12] * 5),
+        (12, 5, range(5), [5] * 5),
+        (0, 0, np.array([]), np.array([])),
+        (1, 0, np.array([]), np.array([])),
+        (0, 1, [0], [0]),
+    ],
+)
+def test_fixed_forward_indexer_bounds(
+    window_size, num_values, expected_start, expected_end, step
+):
+    # GH 43267
+    indexer = FixedForwardWindowIndexer(window_size=window_size)
+    start, end = indexer.get_window_bounds(num_values=num_values, step=step)
+
+    tm.assert_numpy_array_equal(
+        start, np.array(expected_start[::step]), check_dtype=False
+    )
+    tm.assert_numpy_array_equal(end, np.array(expected_end[::step]), check_dtype=False)
+    assert len(start) == len(end)
+
+
+@pytest.mark.parametrize(
+    "df, window_size, expected",
+    [
+        (
+            DataFrame({"b": [0, 1, 2], "a": [1, 2, 2]}),
+            2,
+            Series(
+                [0, 1.5, 2.0],
+                index=MultiIndex.from_arrays([[1, 2, 2], range(3)], names=["a", None]),
+                name="b",
+                dtype=np.float64,
+            ),
+        ),
+        (
+            DataFrame(
+                {
+                    "b": [np.nan, 1, 2, np.nan] + list(range(4, 18)),
+                    "a": [1] * 7 + [2] * 11,
+                    "c": range(18),
+                }
+            ),
+            12,
+            Series(
+                [
+                    3.6,
+                    3.6,
+                    4.25,
+                    5.0,
+                    5.0,
+                    5.5,
+                    6.0,
+                    12.0,
+                    12.5,
+                    13.0,
+                    13.5,
+                    14.0,
+                    14.5,
+                    15.0,
+                    15.5,
+                    16.0,
+                    16.5,
+                    17.0,
+                ],
+                index=MultiIndex.from_arrays(
+                    [[1] * 7 + [2] * 11, range(18)], names=["a", None]
+                ),
+                name="b",
+                dtype=np.float64,
+            ),
+        ),
+    ],
+)
+def test_rolling_groupby_with_fixed_forward_specific(df, window_size, expected):
+    # GH 43267
+    indexer = FixedForwardWindowIndexer(window_size=window_size)
+    result = df.groupby("a")["b"].rolling(window=indexer, min_periods=1).mean()
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "group_keys",
+    [
+        (1,),
+        (1, 2),
+        (2, 1),
+        (1, 1, 2),
+        (1, 2, 1),
+        (1, 1, 2, 2),
+        (1, 2, 3, 2, 3),
+        (1, 1, 2) * 4,
+        (1, 2, 3) * 5,
+    ],
+)
+@pytest.mark.parametrize("window_size", [1, 2, 3, 4, 5, 8, 20])
+def test_rolling_groupby_with_fixed_forward_many(group_keys, window_size):
+    # GH 43267
+    df = DataFrame(
+        {
+            "a": np.array(list(group_keys)),
+            "b": np.arange(len(group_keys), dtype=np.float64) + 17,
+            "c": np.arange(len(group_keys), dtype=np.int64),
+        }
+    )
+
+    indexer = FixedForwardWindowIndexer(window_size=window_size)
+    result = df.groupby("a")["b"].rolling(window=indexer, min_periods=1).sum()
+    result.index.names = ["a", "c"]
+
+    groups = df.groupby("a")[["a", "b", "c"]]
+    manual = concat(
+        [
+            g.assign(
+                b=[
+                    g["b"].iloc[i : i + window_size].sum(min_count=1)
+                    for i in range(len(g))
+                ]
+            )
+            for _, g in groups
+        ]
+    )
+    manual = manual.set_index(["a", "c"])["b"]
+
+    tm.assert_series_equal(result, manual)
+
+
+def test_unequal_start_end_bounds():
+    class CustomIndexer(BaseIndexer):
+        def get_window_bounds(self, num_values, min_periods, center, closed, step):
+            return np.array([1]), np.array([1, 2])
+
+    indexer = CustomIndexer()
+    roll = Series(1).rolling(indexer)
+    match = "start"
+    with pytest.raises(ValueError, match=match):
+        roll.mean()
+
+    with pytest.raises(ValueError, match=match):
+        next(iter(roll))
+
+    with pytest.raises(ValueError, match=match):
+        roll.corr(pairwise=True)
+
+    with pytest.raises(ValueError, match=match):
+        roll.cov(pairwise=True)
+
+
+def test_unequal_bounds_to_object():
+    # GH 44470
+    class CustomIndexer(BaseIndexer):
+        def get_window_bounds(self, num_values, min_periods, center, closed, step):
+            return np.array([1]), np.array([2])
+
+    indexer = CustomIndexer()
+    roll = Series([1, 1]).rolling(indexer)
+    match = "start and end"
+    with pytest.raises(ValueError, match=match):
+        roll.mean()
+
+    with pytest.raises(ValueError, match=match):
+        next(iter(roll))
+
+    with pytest.raises(ValueError, match=match):
+        roll.corr(pairwise=True)
+
+    with pytest.raises(ValueError, match=match):
+        roll.cov(pairwise=True)
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/test_cython_aggregations.py b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/test_cython_aggregations.py
new file mode 100644
index 0000000000000000000000000000000000000000..c60cb6ea74ec0aa90cf089841c853c657e1b4c00
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/test_cython_aggregations.py
@@ -0,0 +1,111 @@
+from functools import partial
+import sys
+
+import numpy as np
+import pytest
+
+import pandas._libs.window.aggregations as window_aggregations
+
+from pandas import Series
+import pandas._testing as tm
+
+
+def _get_rolling_aggregations():
+    # list pairs of name and function
+    # each function has this signature:
+    # (const float64_t[:] values, ndarray[int64_t] start,
+    #  ndarray[int64_t] end, int64_t minp) -> np.ndarray
+    named_roll_aggs = (
+        [
+            ("roll_sum", window_aggregations.roll_sum),
+            ("roll_mean", window_aggregations.roll_mean),
+        ]
+        + [
+            (f"roll_var({ddof})", partial(window_aggregations.roll_var, ddof=ddof))
+            for ddof in [0, 1]
+        ]
+        + [
+            ("roll_skew", window_aggregations.roll_skew),
+            ("roll_kurt", window_aggregations.roll_kurt),
+            ("roll_median_c", window_aggregations.roll_median_c),
+            ("roll_max", window_aggregations.roll_max),
+            ("roll_min", window_aggregations.roll_min),
+        ]
+        + [
+            (
+                f"roll_quantile({quantile},{interpolation})",
+                partial(
+                    window_aggregations.roll_quantile,
+                    quantile=quantile,
+                    interpolation=interpolation,
+                ),
+            )
+            for quantile in [0.0001, 0.5, 0.9999]
+            for interpolation in window_aggregations.interpolation_types
+        ]
+        + [
+            (
+                f"roll_rank({percentile},{method},{ascending})",
+                partial(
+                    window_aggregations.roll_rank,
+                    percentile=percentile,
+                    method=method,
+                    ascending=ascending,
+                ),
+            )
+            for percentile in [True, False]
+            for method in window_aggregations.rolling_rank_tiebreakers.keys()
+            for ascending in [True, False]
+        ]
+    )
+    # unzip to a list of 2 tuples, names and functions
+    unzipped = list(zip(*named_roll_aggs))
+    return {"ids": unzipped[0], "params": unzipped[1]}
+
+
+_rolling_aggregations = _get_rolling_aggregations()
+
+
+@pytest.fixture(
+    params=_rolling_aggregations["params"], ids=_rolling_aggregations["ids"]
+)
+def rolling_aggregation(request):
+    """Make a rolling aggregation function as fixture."""
+    return request.param
+
+
+def test_rolling_aggregation_boundary_consistency(rolling_aggregation):
+    # GH-45647
+    minp, step, width, size, selection = 0, 1, 3, 11, [2, 7]
+    values = np.arange(1, 1 + size, dtype=np.float64)
+    end = np.arange(width, size, step, dtype=np.int64)
+    start = end - width
+    selarr = np.array(selection, dtype=np.int32)
+    result = Series(rolling_aggregation(values, start[selarr], end[selarr], minp))
+    expected = Series(rolling_aggregation(values, start, end, minp)[selarr])
+    tm.assert_equal(expected, result)
+
+
+def test_rolling_aggregation_with_unused_elements(rolling_aggregation):
+    # GH-45647
+    minp, width = 0, 5  # width at least 4 for kurt
+    size = 2 * width + 5
+    values = np.arange(1, size + 1, dtype=np.float64)
+    values[width : width + 2] = sys.float_info.min
+    values[width + 2] = np.nan
+    values[width + 3 : width + 5] = sys.float_info.max
+    start = np.array([0, size - width], dtype=np.int64)
+    end = np.array([width, size], dtype=np.int64)
+    loc = np.array(
+        [j for i in range(len(start)) for j in range(start[i], end[i])],
+        dtype=np.int32,
+    )
+    result = Series(rolling_aggregation(values, start, end, minp))
+    compact_values = np.array(values[loc], dtype=np.float64)
+    compact_start = np.arange(0, len(start) * width, width, dtype=np.int64)
+    compact_end = compact_start + width
+    expected = Series(
+        rolling_aggregation(compact_values, compact_start, compact_end, minp)
+    )
+    assert np.isfinite(expected.values).all(), "Not all expected values are finite"
+    tm.assert_equal(expected, result)
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/test_dtypes.py b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/test_dtypes.py
new file mode 100644
index 0000000000000000000000000000000000000000..4007320b5de332ee4aef40b1ad1be9092eeb3347
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/test_dtypes.py
@@ -0,0 +1,173 @@
+import numpy as np
+import pytest
+
+from pandas.errors import DataError
+
+from pandas.core.dtypes.common import pandas_dtype
+
+from pandas import (
+    NA,
+    DataFrame,
+    Series,
+)
+import pandas._testing as tm
+
+# gh-12373 : rolling functions error on float32 data
+# make sure rolling functions works for different dtypes
+#
+# further note that we are only checking rolling for fully dtype
+# compliance (though both expanding and ewm inherit)
+
+
+def get_dtype(dtype, coerce_int=None):
+    if coerce_int is False and "int" in dtype:
+        return None
+    return pandas_dtype(dtype)
+
+
+@pytest.fixture(
+    params=[
+        "object",
+        "category",
+        "int8",
+        "int16",
+        "int32",
+        "int64",
+        "uint8",
+        "uint16",
+        "uint32",
+        "uint64",
+        "float16",
+        "float32",
+        "float64",
+        "m8[ns]",
+        "M8[ns]",
+        "datetime64[ns, UTC]",
+    ]
+)
+def dtypes(request):
+    """Dtypes for window tests"""
+    return request.param
+
+
+@pytest.mark.parametrize(
+    "method, data, expected_data, coerce_int, min_periods",
+    [
+        ("count", np.arange(5), [1, 2, 2, 2, 2], True, 0),
+        ("count", np.arange(10, 0, -2), [1, 2, 2, 2, 2], True, 0),
+        ("count", [0, 1, 2, np.nan, 4], [1, 2, 2, 1, 1], False, 0),
+        ("max", np.arange(5), [np.nan, 1, 2, 3, 4], True, None),
+        ("max", np.arange(10, 0, -2), [np.nan, 10, 8, 6, 4], True, None),
+        ("max", [0, 1, 2, np.nan, 4], [np.nan, 1, 2, np.nan, np.nan], False, None),
+        ("min", np.arange(5), [np.nan, 0, 1, 2, 3], True, None),
+        ("min", np.arange(10, 0, -2), [np.nan, 8, 6, 4, 2], True, None),
+        ("min", [0, 1, 2, np.nan, 4], [np.nan, 0, 1, np.nan, np.nan], False, None),
+        ("sum", np.arange(5), [np.nan, 1, 3, 5, 7], True, None),
+        ("sum", np.arange(10, 0, -2), [np.nan, 18, 14, 10, 6], True, None),
+        ("sum", [0, 1, 2, np.nan, 4], [np.nan, 1, 3, np.nan, np.nan], False, None),
+        ("mean", np.arange(5), [np.nan, 0.5, 1.5, 2.5, 3.5], True, None),
+        ("mean", np.arange(10, 0, -2), [np.nan, 9, 7, 5, 3], True, None),
+        ("mean", [0, 1, 2, np.nan, 4], [np.nan, 0.5, 1.5, np.nan, np.nan], False, None),
+        ("std", np.arange(5), [np.nan] + [np.sqrt(0.5)] * 4, True, None),
+        ("std", np.arange(10, 0, -2), [np.nan] + [np.sqrt(2)] * 4, True, None),
+        (
+            "std",
+            [0, 1, 2, np.nan, 4],
+            [np.nan] + [np.sqrt(0.5)] * 2 + [np.nan] * 2,
+            False,
+            None,
+        ),
+        ("var", np.arange(5), [np.nan, 0.5, 0.5, 0.5, 0.5], True, None),
+        ("var", np.arange(10, 0, -2), [np.nan, 2, 2, 2, 2], True, None),
+        ("var", [0, 1, 2, np.nan, 4], [np.nan, 0.5, 0.5, np.nan, np.nan], False, None),
+        ("median", np.arange(5), [np.nan, 0.5, 1.5, 2.5, 3.5], True, None),
+        ("median", np.arange(10, 0, -2), [np.nan, 9, 7, 5, 3], True, None),
+        (
+            "median",
+            [0, 1, 2, np.nan, 4],
+            [np.nan, 0.5, 1.5, np.nan, np.nan],
+            False,
+            None,
+        ),
+    ],
+)
+def test_series_dtypes(
+    method, data, expected_data, coerce_int, dtypes, min_periods, step
+):
+    ser = Series(data, dtype=get_dtype(dtypes, coerce_int=coerce_int))
+    rolled = ser.rolling(2, min_periods=min_periods, step=step)
+
+    if dtypes in ("m8[ns]", "M8[ns]", "datetime64[ns, UTC]") and method != "count":
+        msg = "No numeric types to aggregate"
+        with pytest.raises(DataError, match=msg):
+            getattr(rolled, method)()
+    else:
+        result = getattr(rolled, method)()
+        expected = Series(expected_data, dtype="float64")[::step]
+        tm.assert_almost_equal(result, expected)
+
+
+def test_series_nullable_int(any_signed_int_ea_dtype, step):
+    # GH 43016
+    ser = Series([0, 1, NA], dtype=any_signed_int_ea_dtype)
+    result = ser.rolling(2, step=step).mean()
+    expected = Series([np.nan, 0.5, np.nan])[::step]
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "method, expected_data, min_periods",
+    [
+        ("count", {0: Series([1, 2, 2, 2, 2]), 1: Series([1, 2, 2, 2, 2])}, 0),
+        (
+            "max",
+            {0: Series([np.nan, 2, 4, 6, 8]), 1: Series([np.nan, 3, 5, 7, 9])},
+            None,
+        ),
+        (
+            "min",
+            {0: Series([np.nan, 0, 2, 4, 6]), 1: Series([np.nan, 1, 3, 5, 7])},
+            None,
+        ),
+        (
+            "sum",
+            {0: Series([np.nan, 2, 6, 10, 14]), 1: Series([np.nan, 4, 8, 12, 16])},
+            None,
+        ),
+        (
+            "mean",
+            {0: Series([np.nan, 1, 3, 5, 7]), 1: Series([np.nan, 2, 4, 6, 8])},
+            None,
+        ),
+        (
+            "std",
+            {
+                0: Series([np.nan] + [np.sqrt(2)] * 4),
+                1: Series([np.nan] + [np.sqrt(2)] * 4),
+            },
+            None,
+        ),
+        (
+            "var",
+            {0: Series([np.nan, 2, 2, 2, 2]), 1: Series([np.nan, 2, 2, 2, 2])},
+            None,
+        ),
+        (
+            "median",
+            {0: Series([np.nan, 1, 3, 5, 7]), 1: Series([np.nan, 2, 4, 6, 8])},
+            None,
+        ),
+    ],
+)
+def test_dataframe_dtypes(method, expected_data, dtypes, min_periods, step):
+    df = DataFrame(np.arange(10).reshape((5, 2)), dtype=get_dtype(dtypes))
+    rolled = df.rolling(2, min_periods=min_periods, step=step)
+
+    if dtypes in ("m8[ns]", "M8[ns]", "datetime64[ns, UTC]") and method != "count":
+        msg = "Cannot aggregate non-numeric type"
+        with pytest.raises(DataError, match=msg):
+            getattr(rolled, method)()
+    else:
+        result = getattr(rolled, method)()
+        expected = DataFrame(expected_data, dtype="float64")[::step]
+        tm.assert_frame_equal(result, expected)
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/test_ewm.py b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/test_ewm.py
new file mode 100644
index 0000000000000000000000000000000000000000..058e5ce36e53e8fc43355ffc86a2336316ab09a4
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/test_ewm.py
@@ -0,0 +1,727 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    DataFrame,
+    DatetimeIndex,
+    Series,
+    date_range,
+)
+import pandas._testing as tm
+
+
+def test_doc_string():
+    df = DataFrame({"B": [0, 1, 2, np.nan, 4]})
+    df
+    df.ewm(com=0.5).mean()
+
+
+def test_constructor(frame_or_series):
+    c = frame_or_series(range(5)).ewm
+
+    # valid
+    c(com=0.5)
+    c(span=1.5)
+    c(alpha=0.5)
+    c(halflife=0.75)
+    c(com=0.5, span=None)
+    c(alpha=0.5, com=None)
+    c(halflife=0.75, alpha=None)
+
+    # not valid: mutually exclusive
+    msg = "comass, span, halflife, and alpha are mutually exclusive"
+    with pytest.raises(ValueError, match=msg):
+        c(com=0.5, alpha=0.5)
+    with pytest.raises(ValueError, match=msg):
+        c(span=1.5, halflife=0.75)
+    with pytest.raises(ValueError, match=msg):
+        c(alpha=0.5, span=1.5)
+
+    # not valid: com < 0
+    msg = "comass must satisfy: comass >= 0"
+    with pytest.raises(ValueError, match=msg):
+        c(com=-0.5)
+
+    # not valid: span < 1
+    msg = "span must satisfy: span >= 1"
+    with pytest.raises(ValueError, match=msg):
+        c(span=0.5)
+
+    # not valid: halflife <= 0
+    msg = "halflife must satisfy: halflife > 0"
+    with pytest.raises(ValueError, match=msg):
+        c(halflife=0)
+
+    # not valid: alpha <= 0 or alpha > 1
+    msg = "alpha must satisfy: 0 < alpha <= 1"
+    for alpha in (-0.5, 1.5):
+        with pytest.raises(ValueError, match=msg):
+            c(alpha=alpha)
+
+
+def test_ewma_times_not_datetime_type():
+    msg = r"times must be datetime64 dtype."
+    with pytest.raises(ValueError, match=msg):
+        Series(range(5)).ewm(times=np.arange(5))
+
+
+def test_ewma_times_not_same_length():
+    msg = "times must be the same length as the object."
+    with pytest.raises(ValueError, match=msg):
+        Series(range(5)).ewm(times=np.arange(4).astype("datetime64[ns]"))
+
+
+def test_ewma_halflife_not_correct_type():
+    msg = "halflife must be a timedelta convertible object"
+    with pytest.raises(ValueError, match=msg):
+        Series(range(5)).ewm(halflife=1, times=np.arange(5).astype("datetime64[ns]"))
+
+
+def test_ewma_halflife_without_times(halflife_with_times):
+    msg = "halflife can only be a timedelta convertible argument if times is not None."
+    with pytest.raises(ValueError, match=msg):
+        Series(range(5)).ewm(halflife=halflife_with_times)
+
+
+@pytest.mark.parametrize(
+    "times",
+    [
+        np.arange(10).astype("datetime64[D]").astype("datetime64[ns]"),
+        date_range("2000", freq="D", periods=10),
+        date_range("2000", freq="D", periods=10).tz_localize("UTC"),
+    ],
+)
+@pytest.mark.parametrize("min_periods", [0, 2])
+def test_ewma_with_times_equal_spacing(halflife_with_times, times, min_periods):
+    halflife = halflife_with_times
+    data = np.arange(10.0)
+    data[::2] = np.nan
+    df = DataFrame({"A": data})
+    result = df.ewm(halflife=halflife, min_periods=min_periods, times=times).mean()
+    expected = df.ewm(halflife=1.0, min_periods=min_periods).mean()
+    tm.assert_frame_equal(result, expected)
+
+
+def test_ewma_with_times_variable_spacing(tz_aware_fixture, unit):
+    tz = tz_aware_fixture
+    halflife = "23 days"
+    times = (
+        DatetimeIndex(["2020-01-01", "2020-01-10T00:04:05", "2020-02-23T05:00:23"])
+        .tz_localize(tz)
+        .as_unit(unit)
+    )
+    data = np.arange(3)
+    df = DataFrame(data)
+    result = df.ewm(halflife=halflife, times=times).mean()
+    expected = DataFrame([0.0, 0.5674161888241773, 1.545239952073459])
+    tm.assert_frame_equal(result, expected)
+
+
+def test_ewm_with_nat_raises(halflife_with_times):
+    # GH#38535
+    ser = Series(range(1))
+    times = DatetimeIndex(["NaT"])
+    with pytest.raises(ValueError, match="Cannot convert NaT values to integer"):
+        ser.ewm(com=0.1, halflife=halflife_with_times, times=times)
+
+
+def test_ewm_with_times_getitem(halflife_with_times):
+    # GH 40164
+    halflife = halflife_with_times
+    data = np.arange(10.0)
+    data[::2] = np.nan
+    times = date_range("2000", freq="D", periods=10)
+    df = DataFrame({"A": data, "B": data})
+    result = df.ewm(halflife=halflife, times=times)["A"].mean()
+    expected = df.ewm(halflife=1.0)["A"].mean()
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize("arg", ["com", "halflife", "span", "alpha"])
+def test_ewm_getitem_attributes_retained(arg, adjust, ignore_na):
+    # GH 40164
+    kwargs = {arg: 1, "adjust": adjust, "ignore_na": ignore_na}
+    ewm = DataFrame({"A": range(1), "B": range(1)}).ewm(**kwargs)
+    expected = {attr: getattr(ewm, attr) for attr in ewm._attributes}
+    ewm_slice = ewm["A"]
+    result = {attr: getattr(ewm, attr) for attr in ewm_slice._attributes}
+    assert result == expected
+
+
+def test_ewma_times_adjust_false_raises():
+    # GH 40098
+    with pytest.raises(
+        NotImplementedError, match="times is not supported with adjust=False."
+    ):
+        Series(range(1)).ewm(
+            0.1, adjust=False, times=date_range("2000", freq="D", periods=1)
+        )
+
+
+@pytest.mark.parametrize(
+    "func, expected",
+    [
+        [
+            "mean",
+            DataFrame(
+                {
+                    0: range(5),
+                    1: range(4, 9),
+                    2: [7.428571, 9, 10.571429, 12.142857, 13.714286],
+                },
+                dtype=float,
+            ),
+        ],
+        [
+            "std",
+            DataFrame(
+                {
+                    0: [np.nan] * 5,
+                    1: [4.242641] * 5,
+                    2: [4.6291, 5.196152, 5.781745, 6.380775, 6.989788],
+                }
+            ),
+        ],
+        [
+            "var",
+            DataFrame(
+                {
+                    0: [np.nan] * 5,
+                    1: [18.0] * 5,
+                    2: [21.428571, 27, 33.428571, 40.714286, 48.857143],
+                }
+            ),
+        ],
+    ],
+)
+def test_float_dtype_ewma(func, expected, float_numpy_dtype):
+    # GH#42452
+
+    df = DataFrame(
+        {0: range(5), 1: range(6, 11), 2: range(10, 20, 2)}, dtype=float_numpy_dtype
+    )
+    msg = "Support for axis=1 in DataFrame.ewm is deprecated"
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        e = df.ewm(alpha=0.5, axis=1)
+    result = getattr(e, func)()
+
+    tm.assert_frame_equal(result, expected)
+
+
+def test_times_string_col_raises():
+    # GH 43265
+    df = DataFrame(
+        {"A": np.arange(10.0), "time_col": date_range("2000", freq="D", periods=10)}
+    )
+    with pytest.raises(ValueError, match="times must be datetime64"):
+        df.ewm(halflife="1 day", min_periods=0, times="time_col")
+
+
+def test_ewm_sum_adjust_false_notimplemented():
+    data = Series(range(1)).ewm(com=1, adjust=False)
+    with pytest.raises(NotImplementedError, match="sum is not"):
+        data.sum()
+
+
+@pytest.mark.parametrize(
+    "expected_data, ignore",
+    [[[10.0, 5.0, 2.5, 11.25], False], [[10.0, 5.0, 5.0, 12.5], True]],
+)
+def test_ewm_sum(expected_data, ignore):
+    # xref from Numbagg tests
+    # https://github.com/numbagg/numbagg/blob/v0.2.1/numbagg/test/test_moving.py#L50
+    data = Series([10, 0, np.nan, 10])
+    result = data.ewm(alpha=0.5, ignore_na=ignore).sum()
+    expected = Series(expected_data)
+    tm.assert_series_equal(result, expected)
+
+
+def test_ewma_adjust():
+    vals = Series(np.zeros(1000))
+    vals[5] = 1
+    result = vals.ewm(span=100, adjust=False).mean().sum()
+    assert np.abs(result - 1) < 1e-2
+
+
+def test_ewma_cases(adjust, ignore_na):
+    # try adjust/ignore_na args matrix
+
+    s = Series([1.0, 2.0, 4.0, 8.0])
+
+    if adjust:
+        expected = Series([1.0, 1.6, 2.736842, 4.923077])
+    else:
+        expected = Series([1.0, 1.333333, 2.222222, 4.148148])
+
+    result = s.ewm(com=2.0, adjust=adjust, ignore_na=ignore_na).mean()
+    tm.assert_series_equal(result, expected)
+
+
+def test_ewma_nan_handling():
+    s = Series([1.0] + [np.nan] * 5 + [1.0])
+    result = s.ewm(com=5).mean()
+    tm.assert_series_equal(result, Series([1.0] * len(s)))
+
+    s = Series([np.nan] * 2 + [1.0] + [np.nan] * 2 + [1.0])
+    result = s.ewm(com=5).mean()
+    tm.assert_series_equal(result, Series([np.nan] * 2 + [1.0] * 4))
+
+
+@pytest.mark.parametrize(
+    "s, adjust, ignore_na, w",
+    [
+        (
+            Series([np.nan, 1.0, 101.0]),
+            True,
+            False,
+            [np.nan, (1.0 - (1.0 / (1.0 + 2.0))), 1.0],
+        ),
+        (
+            Series([np.nan, 1.0, 101.0]),
+            True,
+            True,
+            [np.nan, (1.0 - (1.0 / (1.0 + 2.0))), 1.0],
+        ),
+        (
+            Series([np.nan, 1.0, 101.0]),
+            False,
+            False,
+            [np.nan, (1.0 - (1.0 / (1.0 + 2.0))), (1.0 / (1.0 + 2.0))],
+        ),
+        (
+            Series([np.nan, 1.0, 101.0]),
+            False,
+            True,
+            [np.nan, (1.0 - (1.0 / (1.0 + 2.0))), (1.0 / (1.0 + 2.0))],
+        ),
+        (
+            Series([1.0, np.nan, 101.0]),
+            True,
+            False,
+            [(1.0 - (1.0 / (1.0 + 2.0))) ** 2, np.nan, 1.0],
+        ),
+        (
+            Series([1.0, np.nan, 101.0]),
+            True,
+            True,
+            [(1.0 - (1.0 / (1.0 + 2.0))), np.nan, 1.0],
+        ),
+        (
+            Series([1.0, np.nan, 101.0]),
+            False,
+            False,
+            [(1.0 - (1.0 / (1.0 + 2.0))) ** 2, np.nan, (1.0 / (1.0 + 2.0))],
+        ),
+        (
+            Series([1.0, np.nan, 101.0]),
+            False,
+            True,
+            [(1.0 - (1.0 / (1.0 + 2.0))), np.nan, (1.0 / (1.0 + 2.0))],
+        ),
+        (
+            Series([np.nan, 1.0, np.nan, np.nan, 101.0, np.nan]),
+            True,
+            False,
+            [np.nan, (1.0 - (1.0 / (1.0 + 2.0))) ** 3, np.nan, np.nan, 1.0, np.nan],
+        ),
+        (
+            Series([np.nan, 1.0, np.nan, np.nan, 101.0, np.nan]),
+            True,
+            True,
+            [np.nan, (1.0 - (1.0 / (1.0 + 2.0))), np.nan, np.nan, 1.0, np.nan],
+        ),
+        (
+            Series([np.nan, 1.0, np.nan, np.nan, 101.0, np.nan]),
+            False,
+            False,
+            [
+                np.nan,
+                (1.0 - (1.0 / (1.0 + 2.0))) ** 3,
+                np.nan,
+                np.nan,
+                (1.0 / (1.0 + 2.0)),
+                np.nan,
+            ],
+        ),
+        (
+            Series([np.nan, 1.0, np.nan, np.nan, 101.0, np.nan]),
+            False,
+            True,
+            [
+                np.nan,
+                (1.0 - (1.0 / (1.0 + 2.0))),
+                np.nan,
+                np.nan,
+                (1.0 / (1.0 + 2.0)),
+                np.nan,
+            ],
+        ),
+        (
+            Series([1.0, np.nan, 101.0, 50.0]),
+            True,
+            False,
+            [
+                (1.0 - (1.0 / (1.0 + 2.0))) ** 3,
+                np.nan,
+                (1.0 - (1.0 / (1.0 + 2.0))),
+                1.0,
+            ],
+        ),
+        (
+            Series([1.0, np.nan, 101.0, 50.0]),
+            True,
+            True,
+            [
+                (1.0 - (1.0 / (1.0 + 2.0))) ** 2,
+                np.nan,
+                (1.0 - (1.0 / (1.0 + 2.0))),
+                1.0,
+            ],
+        ),
+        (
+            Series([1.0, np.nan, 101.0, 50.0]),
+            False,
+            False,
+            [
+                (1.0 - (1.0 / (1.0 + 2.0))) ** 3,
+                np.nan,
+                (1.0 - (1.0 / (1.0 + 2.0))) * (1.0 / (1.0 + 2.0)),
+                (1.0 / (1.0 + 2.0))
+                * ((1.0 - (1.0 / (1.0 + 2.0))) ** 2 + (1.0 / (1.0 + 2.0))),
+            ],
+        ),
+        (
+            Series([1.0, np.nan, 101.0, 50.0]),
+            False,
+            True,
+            [
+                (1.0 - (1.0 / (1.0 + 2.0))) ** 2,
+                np.nan,
+                (1.0 - (1.0 / (1.0 + 2.0))) * (1.0 / (1.0 + 2.0)),
+                (1.0 / (1.0 + 2.0)),
+            ],
+        ),
+    ],
+)
+def test_ewma_nan_handling_cases(s, adjust, ignore_na, w):
+    # GH 7603
+    expected = (s.multiply(w).cumsum() / Series(w).cumsum()).ffill()
+    result = s.ewm(com=2.0, adjust=adjust, ignore_na=ignore_na).mean()
+
+    tm.assert_series_equal(result, expected)
+    if ignore_na is False:
+        # check that ignore_na defaults to False
+        result = s.ewm(com=2.0, adjust=adjust).mean()
+        tm.assert_series_equal(result, expected)
+
+
+def test_ewm_alpha():
+    # GH 10789
+    arr = np.random.default_rng(2).standard_normal(100)
+    locs = np.arange(20, 40)
+    arr[locs] = np.nan
+
+    s = Series(arr)
+    a = s.ewm(alpha=0.61722699889169674).mean()
+    b = s.ewm(com=0.62014947789973052).mean()
+    c = s.ewm(span=2.240298955799461).mean()
+    d = s.ewm(halflife=0.721792864318).mean()
+    tm.assert_series_equal(a, b)
+    tm.assert_series_equal(a, c)
+    tm.assert_series_equal(a, d)
+
+
+def test_ewm_domain_checks():
+    # GH 12492
+    arr = np.random.default_rng(2).standard_normal(100)
+    locs = np.arange(20, 40)
+    arr[locs] = np.nan
+
+    s = Series(arr)
+    msg = "comass must satisfy: comass >= 0"
+    with pytest.raises(ValueError, match=msg):
+        s.ewm(com=-0.1)
+    s.ewm(com=0.0)
+    s.ewm(com=0.1)
+
+    msg = "span must satisfy: span >= 1"
+    with pytest.raises(ValueError, match=msg):
+        s.ewm(span=-0.1)
+    with pytest.raises(ValueError, match=msg):
+        s.ewm(span=0.0)
+    with pytest.raises(ValueError, match=msg):
+        s.ewm(span=0.9)
+    s.ewm(span=1.0)
+    s.ewm(span=1.1)
+
+    msg = "halflife must satisfy: halflife > 0"
+    with pytest.raises(ValueError, match=msg):
+        s.ewm(halflife=-0.1)
+    with pytest.raises(ValueError, match=msg):
+        s.ewm(halflife=0.0)
+    s.ewm(halflife=0.1)
+
+    msg = "alpha must satisfy: 0 < alpha <= 1"
+    with pytest.raises(ValueError, match=msg):
+        s.ewm(alpha=-0.1)
+    with pytest.raises(ValueError, match=msg):
+        s.ewm(alpha=0.0)
+    s.ewm(alpha=0.1)
+    s.ewm(alpha=1.0)
+    with pytest.raises(ValueError, match=msg):
+        s.ewm(alpha=1.1)
+
+
+@pytest.mark.parametrize("method", ["mean", "std", "var"])
+def test_ew_empty_series(method):
+    vals = Series([], dtype=np.float64)
+
+    ewm = vals.ewm(3)
+    result = getattr(ewm, method)()
+    tm.assert_almost_equal(result, vals)
+
+
+@pytest.mark.parametrize("min_periods", [0, 1])
+@pytest.mark.parametrize("name", ["mean", "var", "std"])
+def test_ew_min_periods(min_periods, name):
+    # excluding NaNs correctly
+    arr = np.random.default_rng(2).standard_normal(50)
+    arr[:10] = np.nan
+    arr[-10:] = np.nan
+    s = Series(arr)
+
+    # check min_periods
+    # GH 7898
+    result = getattr(s.ewm(com=50, min_periods=2), name)()
+    assert result[:11].isna().all()
+    assert not result[11:].isna().any()
+
+    result = getattr(s.ewm(com=50, min_periods=min_periods), name)()
+    if name == "mean":
+        assert result[:10].isna().all()
+        assert not result[10:].isna().any()
+    else:
+        # ewm.std, ewm.var (with bias=False) require at least
+        # two values
+        assert result[:11].isna().all()
+        assert not result[11:].isna().any()
+
+    # check series of length 0
+    result = getattr(Series(dtype=object).ewm(com=50, min_periods=min_periods), name)()
+    tm.assert_series_equal(result, Series(dtype="float64"))
+
+    # check series of length 1
+    result = getattr(Series([1.0]).ewm(50, min_periods=min_periods), name)()
+    if name == "mean":
+        tm.assert_series_equal(result, Series([1.0]))
+    else:
+        # ewm.std, ewm.var with bias=False require at least
+        # two values
+        tm.assert_series_equal(result, Series([np.nan]))
+
+    # pass in ints
+    result2 = getattr(Series(np.arange(50)).ewm(span=10), name)()
+    assert result2.dtype == np.float64
+
+
+@pytest.mark.parametrize("name", ["cov", "corr"])
+def test_ewm_corr_cov(name):
+    A = Series(np.random.default_rng(2).standard_normal(50), index=range(50))
+    B = A[2:] + np.random.default_rng(2).standard_normal(48)
+
+    A[:10] = np.nan
+    B.iloc[-10:] = np.nan
+
+    result = getattr(A.ewm(com=20, min_periods=5), name)(B)
+    assert np.isnan(result.values[:14]).all()
+    assert not np.isnan(result.values[14:]).any()
+
+
+@pytest.mark.parametrize("min_periods", [0, 1, 2])
+@pytest.mark.parametrize("name", ["cov", "corr"])
+def test_ewm_corr_cov_min_periods(name, min_periods):
+    # GH 7898
+    A = Series(np.random.default_rng(2).standard_normal(50), index=range(50))
+    B = A[2:] + np.random.default_rng(2).standard_normal(48)
+
+    A[:10] = np.nan
+    B.iloc[-10:] = np.nan
+
+    result = getattr(A.ewm(com=20, min_periods=min_periods), name)(B)
+    # binary functions (ewmcov, ewmcorr) with bias=False require at
+    # least two values
+    assert np.isnan(result.values[:11]).all()
+    assert not np.isnan(result.values[11:]).any()
+
+    # check series of length 0
+    empty = Series([], dtype=np.float64)
+    result = getattr(empty.ewm(com=50, min_periods=min_periods), name)(empty)
+    tm.assert_series_equal(result, empty)
+
+    # check series of length 1
+    result = getattr(Series([1.0]).ewm(com=50, min_periods=min_periods), name)(
+        Series([1.0])
+    )
+    tm.assert_series_equal(result, Series([np.nan]))
+
+
+@pytest.mark.parametrize("name", ["cov", "corr"])
+def test_different_input_array_raise_exception(name):
+    A = Series(np.random.default_rng(2).standard_normal(50), index=range(50))
+    A[:10] = np.nan
+
+    msg = "other must be a DataFrame or Series"
+    # exception raised is Exception
+    with pytest.raises(ValueError, match=msg):
+        getattr(A.ewm(com=20, min_periods=5), name)(
+            np.random.default_rng(2).standard_normal(50)
+        )
+
+
+@pytest.mark.parametrize("name", ["var", "std", "mean"])
+def test_ewma_series(series, name):
+    series_result = getattr(series.ewm(com=10), name)()
+    assert isinstance(series_result, Series)
+
+
+@pytest.mark.parametrize("name", ["var", "std", "mean"])
+def test_ewma_frame(frame, name):
+    frame_result = getattr(frame.ewm(com=10), name)()
+    assert isinstance(frame_result, DataFrame)
+
+
+def test_ewma_span_com_args(series):
+    A = series.ewm(com=9.5).mean()
+    B = series.ewm(span=20).mean()
+    tm.assert_almost_equal(A, B)
+    msg = "comass, span, halflife, and alpha are mutually exclusive"
+    with pytest.raises(ValueError, match=msg):
+        series.ewm(com=9.5, span=20)
+
+    msg = "Must pass one of comass, span, halflife, or alpha"
+    with pytest.raises(ValueError, match=msg):
+        series.ewm().mean()
+
+
+def test_ewma_halflife_arg(series):
+    A = series.ewm(com=13.932726172912965).mean()
+    B = series.ewm(halflife=10.0).mean()
+    tm.assert_almost_equal(A, B)
+    msg = "comass, span, halflife, and alpha are mutually exclusive"
+    with pytest.raises(ValueError, match=msg):
+        series.ewm(span=20, halflife=50)
+    with pytest.raises(ValueError, match=msg):
+        series.ewm(com=9.5, halflife=50)
+    with pytest.raises(ValueError, match=msg):
+        series.ewm(com=9.5, span=20, halflife=50)
+    msg = "Must pass one of comass, span, halflife, or alpha"
+    with pytest.raises(ValueError, match=msg):
+        series.ewm()
+
+
+def test_ewm_alpha_arg(series):
+    # GH 10789
+    s = series
+    msg = "Must pass one of comass, span, halflife, or alpha"
+    with pytest.raises(ValueError, match=msg):
+        s.ewm()
+
+    msg = "comass, span, halflife, and alpha are mutually exclusive"
+    with pytest.raises(ValueError, match=msg):
+        s.ewm(com=10.0, alpha=0.5)
+    with pytest.raises(ValueError, match=msg):
+        s.ewm(span=10.0, alpha=0.5)
+    with pytest.raises(ValueError, match=msg):
+        s.ewm(halflife=10.0, alpha=0.5)
+
+
+@pytest.mark.parametrize("func", ["cov", "corr"])
+def test_ewm_pairwise_cov_corr(func, frame):
+    result = getattr(frame.ewm(span=10, min_periods=5), func)()
+    result = result.loc[(slice(None), 1), 5]
+    result.index = result.index.droplevel(1)
+    expected = getattr(frame[1].ewm(span=10, min_periods=5), func)(frame[5])
+    tm.assert_series_equal(result, expected, check_names=False)
+
+
+def test_numeric_only_frame(arithmetic_win_operators, numeric_only):
+    # GH#46560
+    kernel = arithmetic_win_operators
+    df = DataFrame({"a": [1], "b": 2, "c": 3})
+    df["c"] = df["c"].astype(object)
+    ewm = df.ewm(span=2, min_periods=1)
+    op = getattr(ewm, kernel, None)
+    if op is not None:
+        result = op(numeric_only=numeric_only)
+
+        columns = ["a", "b"] if numeric_only else ["a", "b", "c"]
+        expected = df[columns].agg([kernel]).reset_index(drop=True).astype(float)
+        assert list(expected.columns) == columns
+
+        tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("kernel", ["corr", "cov"])
+@pytest.mark.parametrize("use_arg", [True, False])
+def test_numeric_only_corr_cov_frame(kernel, numeric_only, use_arg):
+    # GH#46560
+    df = DataFrame({"a": [1, 2, 3], "b": 2, "c": 3})
+    df["c"] = df["c"].astype(object)
+    arg = (df,) if use_arg else ()
+    ewm = df.ewm(span=2, min_periods=1)
+    op = getattr(ewm, kernel)
+    result = op(*arg, numeric_only=numeric_only)
+
+    # Compare result to op using float dtypes, dropping c when numeric_only is True
+    columns = ["a", "b"] if numeric_only else ["a", "b", "c"]
+    df2 = df[columns].astype(float)
+    arg2 = (df2,) if use_arg else ()
+    ewm2 = df2.ewm(span=2, min_periods=1)
+    op2 = getattr(ewm2, kernel)
+    expected = op2(*arg2, numeric_only=numeric_only)
+
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("dtype", [int, object])
+def test_numeric_only_series(arithmetic_win_operators, numeric_only, dtype):
+    # GH#46560
+    kernel = arithmetic_win_operators
+    ser = Series([1], dtype=dtype)
+    ewm = ser.ewm(span=2, min_periods=1)
+    op = getattr(ewm, kernel, None)
+    if op is None:
+        # Nothing to test
+        pytest.skip("No op to test")
+    if numeric_only and dtype is object:
+        msg = f"ExponentialMovingWindow.{kernel} does not implement numeric_only"
+        with pytest.raises(NotImplementedError, match=msg):
+            op(numeric_only=numeric_only)
+    else:
+        result = op(numeric_only=numeric_only)
+        expected = ser.agg([kernel]).reset_index(drop=True).astype(float)
+        tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize("kernel", ["corr", "cov"])
+@pytest.mark.parametrize("use_arg", [True, False])
+@pytest.mark.parametrize("dtype", [int, object])
+def test_numeric_only_corr_cov_series(kernel, use_arg, numeric_only, dtype):
+    # GH#46560
+    ser = Series([1, 2, 3], dtype=dtype)
+    arg = (ser,) if use_arg else ()
+    ewm = ser.ewm(span=2, min_periods=1)
+    op = getattr(ewm, kernel)
+    if numeric_only and dtype is object:
+        msg = f"ExponentialMovingWindow.{kernel} does not implement numeric_only"
+        with pytest.raises(NotImplementedError, match=msg):
+            op(*arg, numeric_only=numeric_only)
+    else:
+        result = op(*arg, numeric_only=numeric_only)
+
+        ser2 = ser.astype(float)
+        arg2 = (ser2,) if use_arg else ()
+        ewm2 = ser2.ewm(span=2, min_periods=1)
+        op2 = getattr(ewm2, kernel)
+        expected = op2(*arg2, numeric_only=numeric_only)
+        tm.assert_series_equal(result, expected)
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/test_expanding.py b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/test_expanding.py
new file mode 100644
index 0000000000000000000000000000000000000000..aebb9e86c763f265b740e79e3e1e76e7ffe2dd94
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/test_expanding.py
@@ -0,0 +1,723 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    DataFrame,
+    DatetimeIndex,
+    Index,
+    MultiIndex,
+    Series,
+    isna,
+    notna,
+)
+import pandas._testing as tm
+
+
+def test_doc_string():
+    df = DataFrame({"B": [0, 1, 2, np.nan, 4]})
+    df
+    df.expanding(2).sum()
+
+
+def test_constructor(frame_or_series):
+    # GH 12669
+
+    c = frame_or_series(range(5)).expanding
+
+    # valid
+    c(min_periods=1)
+
+
+@pytest.mark.parametrize("w", [2.0, "foo", np.array([2])])
+def test_constructor_invalid(frame_or_series, w):
+    # not valid
+
+    c = frame_or_series(range(5)).expanding
+    msg = "min_periods must be an integer"
+    with pytest.raises(ValueError, match=msg):
+        c(min_periods=w)
+
+
+@pytest.mark.parametrize(
+    "expander",
+    [
+        1,
+        pytest.param(
+            "ls",
+            marks=pytest.mark.xfail(
+                reason="GH#16425 expanding with offset not supported"
+            ),
+        ),
+    ],
+)
+def test_empty_df_expanding(expander):
+    # GH 15819 Verifies that datetime and integer expanding windows can be
+    # applied to empty DataFrames
+
+    expected = DataFrame()
+    result = DataFrame().expanding(expander).sum()
+    tm.assert_frame_equal(result, expected)
+
+    # Verifies that datetime and integer expanding windows can be applied
+    # to empty DataFrames with datetime index
+    expected = DataFrame(index=DatetimeIndex([]))
+    result = DataFrame(index=DatetimeIndex([])).expanding(expander).sum()
+    tm.assert_frame_equal(result, expected)
+
+
+def test_missing_minp_zero():
+    # https://github.com/pandas-dev/pandas/pull/18921
+    # minp=0
+    x = Series([np.nan])
+    result = x.expanding(min_periods=0).sum()
+    expected = Series([0.0])
+    tm.assert_series_equal(result, expected)
+
+    # minp=1
+    result = x.expanding(min_periods=1).sum()
+    expected = Series([np.nan])
+    tm.assert_series_equal(result, expected)
+
+
+def test_expanding_axis(axis_frame):
+    # see gh-23372.
+    df = DataFrame(np.ones((10, 20)))
+    axis = df._get_axis_number(axis_frame)
+
+    if axis == 0:
+        msg = "The 'axis' keyword in DataFrame.expanding is deprecated"
+        expected = DataFrame(
+            {i: [np.nan] * 2 + [float(j) for j in range(3, 11)] for i in range(20)}
+        )
+    else:
+        # axis == 1
+        msg = "Support for axis=1 in DataFrame.expanding is deprecated"
+        expected = DataFrame([[np.nan] * 2 + [float(i) for i in range(3, 21)]] * 10)
+
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        result = df.expanding(3, axis=axis_frame).sum()
+    tm.assert_frame_equal(result, expected)
+
+
+def test_expanding_count_with_min_periods(frame_or_series):
+    # GH 26996
+    result = frame_or_series(range(5)).expanding(min_periods=3).count()
+    expected = frame_or_series([np.nan, np.nan, 3.0, 4.0, 5.0])
+    tm.assert_equal(result, expected)
+
+
+def test_expanding_count_default_min_periods_with_null_values(frame_or_series):
+    # GH 26996
+    values = [1, 2, 3, np.nan, 4, 5, 6]
+    expected_counts = [1.0, 2.0, 3.0, 3.0, 4.0, 5.0, 6.0]
+
+    result = frame_or_series(values).expanding().count()
+    expected = frame_or_series(expected_counts)
+    tm.assert_equal(result, expected)
+
+
+def test_expanding_count_with_min_periods_exceeding_series_length(frame_or_series):
+    # GH 25857
+    result = frame_or_series(range(5)).expanding(min_periods=6).count()
+    expected = frame_or_series([np.nan, np.nan, np.nan, np.nan, np.nan])
+    tm.assert_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "df,expected,min_periods",
+    [
+        (
+            DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]}),
+            [
+                ({"A": [1], "B": [4]}, [0]),
+                ({"A": [1, 2], "B": [4, 5]}, [0, 1]),
+                ({"A": [1, 2, 3], "B": [4, 5, 6]}, [0, 1, 2]),
+            ],
+            3,
+        ),
+        (
+            DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]}),
+            [
+                ({"A": [1], "B": [4]}, [0]),
+                ({"A": [1, 2], "B": [4, 5]}, [0, 1]),
+                ({"A": [1, 2, 3], "B": [4, 5, 6]}, [0, 1, 2]),
+            ],
+            2,
+        ),
+        (
+            DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]}),
+            [
+                ({"A": [1], "B": [4]}, [0]),
+                ({"A": [1, 2], "B": [4, 5]}, [0, 1]),
+                ({"A": [1, 2, 3], "B": [4, 5, 6]}, [0, 1, 2]),
+            ],
+            1,
+        ),
+        (DataFrame({"A": [1], "B": [4]}), [], 2),
+        (DataFrame(), [({}, [])], 1),
+        (
+            DataFrame({"A": [1, np.nan, 3], "B": [np.nan, 5, 6]}),
+            [
+                ({"A": [1.0], "B": [np.nan]}, [0]),
+                ({"A": [1, np.nan], "B": [np.nan, 5]}, [0, 1]),
+                ({"A": [1, np.nan, 3], "B": [np.nan, 5, 6]}, [0, 1, 2]),
+            ],
+            3,
+        ),
+        (
+            DataFrame({"A": [1, np.nan, 3], "B": [np.nan, 5, 6]}),
+            [
+                ({"A": [1.0], "B": [np.nan]}, [0]),
+                ({"A": [1, np.nan], "B": [np.nan, 5]}, [0, 1]),
+                ({"A": [1, np.nan, 3], "B": [np.nan, 5, 6]}, [0, 1, 2]),
+            ],
+            2,
+        ),
+        (
+            DataFrame({"A": [1, np.nan, 3], "B": [np.nan, 5, 6]}),
+            [
+                ({"A": [1.0], "B": [np.nan]}, [0]),
+                ({"A": [1, np.nan], "B": [np.nan, 5]}, [0, 1]),
+                ({"A": [1, np.nan, 3], "B": [np.nan, 5, 6]}, [0, 1, 2]),
+            ],
+            1,
+        ),
+    ],
+)
+def test_iter_expanding_dataframe(df, expected, min_periods):
+    # GH 11704
+    expected = [DataFrame(values, index=index) for (values, index) in expected]
+
+    for expected, actual in zip(expected, df.expanding(min_periods)):
+        tm.assert_frame_equal(actual, expected)
+
+
+@pytest.mark.parametrize(
+    "ser,expected,min_periods",
+    [
+        (Series([1, 2, 3]), [([1], [0]), ([1, 2], [0, 1]), ([1, 2, 3], [0, 1, 2])], 3),
+        (Series([1, 2, 3]), [([1], [0]), ([1, 2], [0, 1]), ([1, 2, 3], [0, 1, 2])], 2),
+        (Series([1, 2, 3]), [([1], [0]), ([1, 2], [0, 1]), ([1, 2, 3], [0, 1, 2])], 1),
+        (Series([1, 2]), [([1], [0]), ([1, 2], [0, 1])], 2),
+        (Series([np.nan, 2]), [([np.nan], [0]), ([np.nan, 2], [0, 1])], 2),
+        (Series([], dtype="int64"), [], 2),
+    ],
+)
+def test_iter_expanding_series(ser, expected, min_periods):
+    # GH 11704
+    expected = [Series(values, index=index) for (values, index) in expected]
+
+    for expected, actual in zip(expected, ser.expanding(min_periods)):
+        tm.assert_series_equal(actual, expected)
+
+
+def test_center_invalid():
+    # GH 20647
+    df = DataFrame()
+    with pytest.raises(TypeError, match=".* got an unexpected keyword"):
+        df.expanding(center=True)
+
+
+def test_expanding_sem(frame_or_series):
+    # GH: 26476
+    obj = frame_or_series([0, 1, 2])
+    result = obj.expanding().sem()
+    if isinstance(result, DataFrame):
+        result = Series(result[0].values)
+    expected = Series([np.nan] + [0.707107] * 2)
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize("method", ["skew", "kurt"])
+def test_expanding_skew_kurt_numerical_stability(method):
+    # GH: 6929
+    s = Series(np.random.default_rng(2).random(10))
+    expected = getattr(s.expanding(3), method)()
+    s = s + 5000
+    result = getattr(s.expanding(3), method)()
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize("window", [1, 3, 10, 20])
+@pytest.mark.parametrize("method", ["min", "max", "average"])
+@pytest.mark.parametrize("pct", [True, False])
+@pytest.mark.parametrize("ascending", [True, False])
+@pytest.mark.parametrize("test_data", ["default", "duplicates", "nans"])
+def test_rank(window, method, pct, ascending, test_data):
+    length = 20
+    if test_data == "default":
+        ser = Series(data=np.random.default_rng(2).random(length))
+    elif test_data == "duplicates":
+        ser = Series(data=np.random.default_rng(2).choice(3, length))
+    elif test_data == "nans":
+        ser = Series(
+            data=np.random.default_rng(2).choice(
+                [1.0, 0.25, 0.75, np.nan, np.inf, -np.inf], length
+            )
+        )
+
+    expected = ser.expanding(window).apply(
+        lambda x: x.rank(method=method, pct=pct, ascending=ascending).iloc[-1]
+    )
+    result = ser.expanding(window).rank(method=method, pct=pct, ascending=ascending)
+
+    tm.assert_series_equal(result, expected)
+
+
+def test_expanding_corr(series):
+    A = series.dropna()
+    B = (A + np.random.default_rng(2).standard_normal(len(A)))[:-5]
+
+    result = A.expanding().corr(B)
+
+    rolling_result = A.rolling(window=len(A), min_periods=1).corr(B)
+
+    tm.assert_almost_equal(rolling_result, result)
+
+
+def test_expanding_count(series):
+    result = series.expanding(min_periods=0).count()
+    tm.assert_almost_equal(
+        result, series.rolling(window=len(series), min_periods=0).count()
+    )
+
+
+def test_expanding_quantile(series):
+    result = series.expanding().quantile(0.5)
+
+    rolling_result = series.rolling(window=len(series), min_periods=1).quantile(0.5)
+
+    tm.assert_almost_equal(result, rolling_result)
+
+
+def test_expanding_cov(series):
+    A = series
+    B = (A + np.random.default_rng(2).standard_normal(len(A)))[:-5]
+
+    result = A.expanding().cov(B)
+
+    rolling_result = A.rolling(window=len(A), min_periods=1).cov(B)
+
+    tm.assert_almost_equal(rolling_result, result)
+
+
+def test_expanding_cov_pairwise(frame):
+    result = frame.expanding().cov()
+
+    rolling_result = frame.rolling(window=len(frame), min_periods=1).cov()
+
+    tm.assert_frame_equal(result, rolling_result)
+
+
+def test_expanding_corr_pairwise(frame):
+    result = frame.expanding().corr()
+
+    rolling_result = frame.rolling(window=len(frame), min_periods=1).corr()
+    tm.assert_frame_equal(result, rolling_result)
+
+
+@pytest.mark.parametrize(
+    "func,static_comp",
+    [
+        ("sum", np.sum),
+        ("mean", lambda x: np.mean(x, axis=0)),
+        ("max", lambda x: np.max(x, axis=0)),
+        ("min", lambda x: np.min(x, axis=0)),
+    ],
+    ids=["sum", "mean", "max", "min"],
+)
+def test_expanding_func(func, static_comp, frame_or_series):
+    data = frame_or_series(np.array(list(range(10)) + [np.nan] * 10))
+
+    msg = "The 'axis' keyword in (Series|DataFrame).expanding is deprecated"
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        obj = data.expanding(min_periods=1, axis=0)
+    result = getattr(obj, func)()
+    assert isinstance(result, frame_or_series)
+
+    msg = "The behavior of DataFrame.sum with axis=None is deprecated"
+    warn = None
+    if frame_or_series is DataFrame and static_comp is np.sum:
+        warn = FutureWarning
+    with tm.assert_produces_warning(warn, match=msg, check_stacklevel=False):
+        expected = static_comp(data[:11])
+    if frame_or_series is Series:
+        tm.assert_almost_equal(result[10], expected)
+    else:
+        tm.assert_series_equal(result.iloc[10], expected, check_names=False)
+
+
+@pytest.mark.parametrize(
+    "func,static_comp",
+    [("sum", np.sum), ("mean", np.mean), ("max", np.max), ("min", np.min)],
+    ids=["sum", "mean", "max", "min"],
+)
+def test_expanding_min_periods(func, static_comp):
+    ser = Series(np.random.default_rng(2).standard_normal(50))
+
+    msg = "The 'axis' keyword in Series.expanding is deprecated"
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        result = getattr(ser.expanding(min_periods=30, axis=0), func)()
+    assert result[:29].isna().all()
+    tm.assert_almost_equal(result.iloc[-1], static_comp(ser[:50]))
+
+    # min_periods is working correctly
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        result = getattr(ser.expanding(min_periods=15, axis=0), func)()
+    assert isna(result.iloc[13])
+    assert notna(result.iloc[14])
+
+    ser2 = Series(np.random.default_rng(2).standard_normal(20))
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        result = getattr(ser2.expanding(min_periods=5, axis=0), func)()
+    assert isna(result[3])
+    assert notna(result[4])
+
+    # min_periods=0
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        result0 = getattr(ser.expanding(min_periods=0, axis=0), func)()
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        result1 = getattr(ser.expanding(min_periods=1, axis=0), func)()
+    tm.assert_almost_equal(result0, result1)
+
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        result = getattr(ser.expanding(min_periods=1, axis=0), func)()
+    tm.assert_almost_equal(result.iloc[-1], static_comp(ser[:50]))
+
+
+def test_expanding_apply(engine_and_raw, frame_or_series):
+    engine, raw = engine_and_raw
+    data = frame_or_series(np.array(list(range(10)) + [np.nan] * 10))
+    result = data.expanding(min_periods=1).apply(
+        lambda x: x.mean(), raw=raw, engine=engine
+    )
+    assert isinstance(result, frame_or_series)
+
+    if frame_or_series is Series:
+        tm.assert_almost_equal(result[9], np.mean(data[:11], axis=0))
+    else:
+        tm.assert_series_equal(
+            result.iloc[9], np.mean(data[:11], axis=0), check_names=False
+        )
+
+
+def test_expanding_min_periods_apply(engine_and_raw):
+    engine, raw = engine_and_raw
+    ser = Series(np.random.default_rng(2).standard_normal(50))
+
+    result = ser.expanding(min_periods=30).apply(
+        lambda x: x.mean(), raw=raw, engine=engine
+    )
+    assert result[:29].isna().all()
+    tm.assert_almost_equal(result.iloc[-1], np.mean(ser[:50]))
+
+    # min_periods is working correctly
+    result = ser.expanding(min_periods=15).apply(
+        lambda x: x.mean(), raw=raw, engine=engine
+    )
+    assert isna(result.iloc[13])
+    assert notna(result.iloc[14])
+
+    ser2 = Series(np.random.default_rng(2).standard_normal(20))
+    result = ser2.expanding(min_periods=5).apply(
+        lambda x: x.mean(), raw=raw, engine=engine
+    )
+    assert isna(result[3])
+    assert notna(result[4])
+
+    # min_periods=0
+    result0 = ser.expanding(min_periods=0).apply(
+        lambda x: x.mean(), raw=raw, engine=engine
+    )
+    result1 = ser.expanding(min_periods=1).apply(
+        lambda x: x.mean(), raw=raw, engine=engine
+    )
+    tm.assert_almost_equal(result0, result1)
+
+    result = ser.expanding(min_periods=1).apply(
+        lambda x: x.mean(), raw=raw, engine=engine
+    )
+    tm.assert_almost_equal(result.iloc[-1], np.mean(ser[:50]))
+
+
+@pytest.mark.parametrize(
+    "f",
+    [
+        lambda x: (x.expanding(min_periods=5).cov(x, pairwise=True)),
+        lambda x: (x.expanding(min_periods=5).corr(x, pairwise=True)),
+    ],
+)
+def test_moment_functions_zero_length_pairwise(f):
+    df1 = DataFrame()
+    df2 = DataFrame(columns=Index(["a"], name="foo"), index=Index([], name="bar"))
+    df2["a"] = df2["a"].astype("float64")
+
+    df1_expected = DataFrame(index=MultiIndex.from_product([df1.index, df1.columns]))
+    df2_expected = DataFrame(
+        index=MultiIndex.from_product([df2.index, df2.columns], names=["bar", "foo"]),
+        columns=Index(["a"], name="foo"),
+        dtype="float64",
+    )
+
+    df1_result = f(df1)
+    tm.assert_frame_equal(df1_result, df1_expected)
+
+    df2_result = f(df2)
+    tm.assert_frame_equal(df2_result, df2_expected)
+
+
+@pytest.mark.parametrize(
+    "f",
+    [
+        lambda x: x.expanding().count(),
+        lambda x: x.expanding(min_periods=5).cov(x, pairwise=False),
+        lambda x: x.expanding(min_periods=5).corr(x, pairwise=False),
+        lambda x: x.expanding(min_periods=5).max(),
+        lambda x: x.expanding(min_periods=5).min(),
+        lambda x: x.expanding(min_periods=5).sum(),
+        lambda x: x.expanding(min_periods=5).mean(),
+        lambda x: x.expanding(min_periods=5).std(),
+        lambda x: x.expanding(min_periods=5).var(),
+        lambda x: x.expanding(min_periods=5).skew(),
+        lambda x: x.expanding(min_periods=5).kurt(),
+        lambda x: x.expanding(min_periods=5).quantile(0.5),
+        lambda x: x.expanding(min_periods=5).median(),
+        lambda x: x.expanding(min_periods=5).apply(sum, raw=False),
+        lambda x: x.expanding(min_periods=5).apply(sum, raw=True),
+    ],
+)
+def test_moment_functions_zero_length(f):
+    # GH 8056
+    s = Series(dtype=np.float64)
+    s_expected = s
+    df1 = DataFrame()
+    df1_expected = df1
+    df2 = DataFrame(columns=["a"])
+    df2["a"] = df2["a"].astype("float64")
+    df2_expected = df2
+
+    s_result = f(s)
+    tm.assert_series_equal(s_result, s_expected)
+
+    df1_result = f(df1)
+    tm.assert_frame_equal(df1_result, df1_expected)
+
+    df2_result = f(df2)
+    tm.assert_frame_equal(df2_result, df2_expected)
+
+
+def test_expanding_apply_empty_series(engine_and_raw):
+    engine, raw = engine_and_raw
+    ser = Series([], dtype=np.float64)
+    tm.assert_series_equal(
+        ser, ser.expanding().apply(lambda x: x.mean(), raw=raw, engine=engine)
+    )
+
+
+def test_expanding_apply_min_periods_0(engine_and_raw):
+    # GH 8080
+    engine, raw = engine_and_raw
+    s = Series([None, None, None])
+    result = s.expanding(min_periods=0).apply(lambda x: len(x), raw=raw, engine=engine)
+    expected = Series([1.0, 2.0, 3.0])
+    tm.assert_series_equal(result, expected)
+
+
+def test_expanding_cov_diff_index():
+    # GH 7512
+    s1 = Series([1, 2, 3], index=[0, 1, 2])
+    s2 = Series([1, 3], index=[0, 2])
+    result = s1.expanding().cov(s2)
+    expected = Series([None, None, 2.0])
+    tm.assert_series_equal(result, expected)
+
+    s2a = Series([1, None, 3], index=[0, 1, 2])
+    result = s1.expanding().cov(s2a)
+    tm.assert_series_equal(result, expected)
+
+    s1 = Series([7, 8, 10], index=[0, 1, 3])
+    s2 = Series([7, 9, 10], index=[0, 2, 3])
+    result = s1.expanding().cov(s2)
+    expected = Series([None, None, None, 4.5])
+    tm.assert_series_equal(result, expected)
+
+
+def test_expanding_corr_diff_index():
+    # GH 7512
+    s1 = Series([1, 2, 3], index=[0, 1, 2])
+    s2 = Series([1, 3], index=[0, 2])
+    result = s1.expanding().corr(s2)
+    expected = Series([None, None, 1.0])
+    tm.assert_series_equal(result, expected)
+
+    s2a = Series([1, None, 3], index=[0, 1, 2])
+    result = s1.expanding().corr(s2a)
+    tm.assert_series_equal(result, expected)
+
+    s1 = Series([7, 8, 10], index=[0, 1, 3])
+    s2 = Series([7, 9, 10], index=[0, 2, 3])
+    result = s1.expanding().corr(s2)
+    expected = Series([None, None, None, 1.0])
+    tm.assert_series_equal(result, expected)
+
+
+def test_expanding_cov_pairwise_diff_length():
+    # GH 7512
+    df1 = DataFrame([[1, 5], [3, 2], [3, 9]], columns=Index(["A", "B"], name="foo"))
+    df1a = DataFrame(
+        [[1, 5], [3, 9]], index=[0, 2], columns=Index(["A", "B"], name="foo")
+    )
+    df2 = DataFrame(
+        [[5, 6], [None, None], [2, 1]], columns=Index(["X", "Y"], name="foo")
+    )
+    df2a = DataFrame(
+        [[5, 6], [2, 1]], index=[0, 2], columns=Index(["X", "Y"], name="foo")
+    )
+    # TODO: xref gh-15826
+    # .loc is not preserving the names
+    result1 = df1.expanding().cov(df2, pairwise=True).loc[2]
+    result2 = df1.expanding().cov(df2a, pairwise=True).loc[2]
+    result3 = df1a.expanding().cov(df2, pairwise=True).loc[2]
+    result4 = df1a.expanding().cov(df2a, pairwise=True).loc[2]
+    expected = DataFrame(
+        [[-3.0, -6.0], [-5.0, -10.0]],
+        columns=Index(["A", "B"], name="foo"),
+        index=Index(["X", "Y"], name="foo"),
+    )
+    tm.assert_frame_equal(result1, expected)
+    tm.assert_frame_equal(result2, expected)
+    tm.assert_frame_equal(result3, expected)
+    tm.assert_frame_equal(result4, expected)
+
+
+def test_expanding_corr_pairwise_diff_length():
+    # GH 7512
+    df1 = DataFrame(
+        [[1, 2], [3, 2], [3, 4]], columns=["A", "B"], index=Index(range(3), name="bar")
+    )
+    df1a = DataFrame(
+        [[1, 2], [3, 4]], index=Index([0, 2], name="bar"), columns=["A", "B"]
+    )
+    df2 = DataFrame(
+        [[5, 6], [None, None], [2, 1]],
+        columns=["X", "Y"],
+        index=Index(range(3), name="bar"),
+    )
+    df2a = DataFrame(
+        [[5, 6], [2, 1]], index=Index([0, 2], name="bar"), columns=["X", "Y"]
+    )
+    result1 = df1.expanding().corr(df2, pairwise=True).loc[2]
+    result2 = df1.expanding().corr(df2a, pairwise=True).loc[2]
+    result3 = df1a.expanding().corr(df2, pairwise=True).loc[2]
+    result4 = df1a.expanding().corr(df2a, pairwise=True).loc[2]
+    expected = DataFrame(
+        [[-1.0, -1.0], [-1.0, -1.0]], columns=["A", "B"], index=Index(["X", "Y"])
+    )
+    tm.assert_frame_equal(result1, expected)
+    tm.assert_frame_equal(result2, expected)
+    tm.assert_frame_equal(result3, expected)
+    tm.assert_frame_equal(result4, expected)
+
+
+def test_expanding_apply_args_kwargs(engine_and_raw):
+    def mean_w_arg(x, const):
+        return np.mean(x) + const
+
+    engine, raw = engine_and_raw
+
+    df = DataFrame(np.random.default_rng(2).random((20, 3)))
+
+    expected = df.expanding().apply(np.mean, engine=engine, raw=raw) + 20.0
+
+    result = df.expanding().apply(mean_w_arg, engine=engine, raw=raw, args=(20,))
+    tm.assert_frame_equal(result, expected)
+
+    result = df.expanding().apply(mean_w_arg, raw=raw, kwargs={"const": 20})
+    tm.assert_frame_equal(result, expected)
+
+
+def test_numeric_only_frame(arithmetic_win_operators, numeric_only):
+    # GH#46560
+    kernel = arithmetic_win_operators
+    df = DataFrame({"a": [1], "b": 2, "c": 3})
+    df["c"] = df["c"].astype(object)
+    expanding = df.expanding()
+    op = getattr(expanding, kernel, None)
+    if op is not None:
+        result = op(numeric_only=numeric_only)
+
+        columns = ["a", "b"] if numeric_only else ["a", "b", "c"]
+        expected = df[columns].agg([kernel]).reset_index(drop=True).astype(float)
+        assert list(expected.columns) == columns
+
+        tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("kernel", ["corr", "cov"])
+@pytest.mark.parametrize("use_arg", [True, False])
+def test_numeric_only_corr_cov_frame(kernel, numeric_only, use_arg):
+    # GH#46560
+    df = DataFrame({"a": [1, 2, 3], "b": 2, "c": 3})
+    df["c"] = df["c"].astype(object)
+    arg = (df,) if use_arg else ()
+    expanding = df.expanding()
+    op = getattr(expanding, kernel)
+    result = op(*arg, numeric_only=numeric_only)
+
+    # Compare result to op using float dtypes, dropping c when numeric_only is True
+    columns = ["a", "b"] if numeric_only else ["a", "b", "c"]
+    df2 = df[columns].astype(float)
+    arg2 = (df2,) if use_arg else ()
+    expanding2 = df2.expanding()
+    op2 = getattr(expanding2, kernel)
+    expected = op2(*arg2, numeric_only=numeric_only)
+
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("dtype", [int, object])
+def test_numeric_only_series(arithmetic_win_operators, numeric_only, dtype):
+    # GH#46560
+    kernel = arithmetic_win_operators
+    ser = Series([1], dtype=dtype)
+    expanding = ser.expanding()
+    op = getattr(expanding, kernel)
+    if numeric_only and dtype is object:
+        msg = f"Expanding.{kernel} does not implement numeric_only"
+        with pytest.raises(NotImplementedError, match=msg):
+            op(numeric_only=numeric_only)
+    else:
+        result = op(numeric_only=numeric_only)
+        expected = ser.agg([kernel]).reset_index(drop=True).astype(float)
+        tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize("kernel", ["corr", "cov"])
+@pytest.mark.parametrize("use_arg", [True, False])
+@pytest.mark.parametrize("dtype", [int, object])
+def test_numeric_only_corr_cov_series(kernel, use_arg, numeric_only, dtype):
+    # GH#46560
+    ser = Series([1, 2, 3], dtype=dtype)
+    arg = (ser,) if use_arg else ()
+    expanding = ser.expanding()
+    op = getattr(expanding, kernel)
+    if numeric_only and dtype is object:
+        msg = f"Expanding.{kernel} does not implement numeric_only"
+        with pytest.raises(NotImplementedError, match=msg):
+            op(*arg, numeric_only=numeric_only)
+    else:
+        result = op(*arg, numeric_only=numeric_only)
+
+        ser2 = ser.astype(float)
+        arg2 = (ser2,) if use_arg else ()
+        expanding2 = ser2.expanding()
+        op2 = getattr(expanding2, kernel)
+        expected = op2(*arg2, numeric_only=numeric_only)
+        tm.assert_series_equal(result, expected)
+
+
+def test_keyword_quantile_deprecated():
+    # GH #52550
+    ser = Series([1, 2, 3, 4])
+    with tm.assert_produces_warning(FutureWarning):
+        ser.expanding().quantile(quantile=0.5)
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/test_groupby.py b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/test_groupby.py
new file mode 100644
index 0000000000000000000000000000000000000000..45e7e07affd75a707c076e225fe6ddc0fac5da4a
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/test_groupby.py
@@ -0,0 +1,1318 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    DataFrame,
+    DatetimeIndex,
+    Index,
+    MultiIndex,
+    Series,
+    Timestamp,
+    date_range,
+    to_datetime,
+)
+import pandas._testing as tm
+from pandas.api.indexers import BaseIndexer
+from pandas.core.groupby.groupby import get_groupby
+
+
+@pytest.fixture
+def times_frame():
+    """Frame for testing times argument in EWM groupby."""
+    return DataFrame(
+        {
+            "A": ["a", "b", "c", "a", "b", "c", "a", "b", "c", "a"],
+            "B": [0, 0, 0, 1, 1, 1, 2, 2, 2, 3],
+            "C": to_datetime(
+                [
+                    "2020-01-01",
+                    "2020-01-01",
+                    "2020-01-01",
+                    "2020-01-02",
+                    "2020-01-10",
+                    "2020-01-22",
+                    "2020-01-03",
+                    "2020-01-23",
+                    "2020-01-23",
+                    "2020-01-04",
+                ]
+            ),
+        }
+    )
+
+
+@pytest.fixture
+def roll_frame():
+    return DataFrame({"A": [1] * 20 + [2] * 12 + [3] * 8, "B": np.arange(40)})
+
+
+class TestRolling:
+    def test_groupby_unsupported_argument(self, roll_frame):
+        msg = r"groupby\(\) got an unexpected keyword argument 'foo'"
+        with pytest.raises(TypeError, match=msg):
+            roll_frame.groupby("A", foo=1)
+
+    def test_getitem(self, roll_frame):
+        g = roll_frame.groupby("A")
+        g_mutated = get_groupby(roll_frame, by="A")
+
+        expected = g_mutated.B.apply(lambda x: x.rolling(2).mean())
+
+        result = g.rolling(2).mean().B
+        tm.assert_series_equal(result, expected)
+
+        result = g.rolling(2).B.mean()
+        tm.assert_series_equal(result, expected)
+
+        result = g.B.rolling(2).mean()
+        tm.assert_series_equal(result, expected)
+
+        result = roll_frame.B.groupby(roll_frame.A).rolling(2).mean()
+        tm.assert_series_equal(result, expected)
+
+    def test_getitem_multiple(self, roll_frame):
+        # GH 13174
+        g = roll_frame.groupby("A")
+        r = g.rolling(2, min_periods=0)
+        g_mutated = get_groupby(roll_frame, by="A")
+        expected = g_mutated.B.apply(lambda x: x.rolling(2, min_periods=0).count())
+
+        result = r.B.count()
+        tm.assert_series_equal(result, expected)
+
+        result = r.B.count()
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "f",
+        [
+            "sum",
+            "mean",
+            "min",
+            "max",
+            "count",
+            "kurt",
+            "skew",
+        ],
+    )
+    def test_rolling(self, f, roll_frame):
+        g = roll_frame.groupby("A", group_keys=False)
+        r = g.rolling(window=4)
+
+        result = getattr(r, f)()
+        msg = "DataFrameGroupBy.apply operated on the grouping columns"
+        with tm.assert_produces_warning(DeprecationWarning, match=msg):
+            expected = g.apply(lambda x: getattr(x.rolling(4), f)())
+        # groupby.apply doesn't drop the grouped-by column
+        expected = expected.drop("A", axis=1)
+        # GH 39732
+        expected_index = MultiIndex.from_arrays([roll_frame["A"], range(40)])
+        expected.index = expected_index
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("f", ["std", "var"])
+    def test_rolling_ddof(self, f, roll_frame):
+        g = roll_frame.groupby("A", group_keys=False)
+        r = g.rolling(window=4)
+
+        result = getattr(r, f)(ddof=1)
+        msg = "DataFrameGroupBy.apply operated on the grouping columns"
+        with tm.assert_produces_warning(DeprecationWarning, match=msg):
+            expected = g.apply(lambda x: getattr(x.rolling(4), f)(ddof=1))
+        # groupby.apply doesn't drop the grouped-by column
+        expected = expected.drop("A", axis=1)
+        # GH 39732
+        expected_index = MultiIndex.from_arrays([roll_frame["A"], range(40)])
+        expected.index = expected_index
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "interpolation", ["linear", "lower", "higher", "midpoint", "nearest"]
+    )
+    def test_rolling_quantile(self, interpolation, roll_frame):
+        g = roll_frame.groupby("A", group_keys=False)
+        r = g.rolling(window=4)
+
+        result = r.quantile(0.4, interpolation=interpolation)
+        msg = "DataFrameGroupBy.apply operated on the grouping columns"
+        with tm.assert_produces_warning(DeprecationWarning, match=msg):
+            expected = g.apply(
+                lambda x: x.rolling(4).quantile(0.4, interpolation=interpolation)
+            )
+        # groupby.apply doesn't drop the grouped-by column
+        expected = expected.drop("A", axis=1)
+        # GH 39732
+        expected_index = MultiIndex.from_arrays([roll_frame["A"], range(40)])
+        expected.index = expected_index
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("f, expected_val", [["corr", 1], ["cov", 0.5]])
+    def test_rolling_corr_cov_other_same_size_as_groups(self, f, expected_val):
+        # GH 42915
+        df = DataFrame(
+            {"value": range(10), "idx1": [1] * 5 + [2] * 5, "idx2": [1, 2, 3, 4, 5] * 2}
+        ).set_index(["idx1", "idx2"])
+        other = DataFrame({"value": range(5), "idx2": [1, 2, 3, 4, 5]}).set_index(
+            "idx2"
+        )
+        result = getattr(df.groupby(level=0).rolling(2), f)(other)
+        expected_data = ([np.nan] + [expected_val] * 4) * 2
+        expected = DataFrame(
+            expected_data,
+            columns=["value"],
+            index=MultiIndex.from_arrays(
+                [
+                    [1] * 5 + [2] * 5,
+                    [1] * 5 + [2] * 5,
+                    list(range(1, 6)) * 2,
+                ],
+                names=["idx1", "idx1", "idx2"],
+            ),
+        )
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("f", ["corr", "cov"])
+    def test_rolling_corr_cov_other_diff_size_as_groups(self, f, roll_frame):
+        g = roll_frame.groupby("A")
+        r = g.rolling(window=4)
+
+        result = getattr(r, f)(roll_frame)
+
+        def func(x):
+            return getattr(x.rolling(4), f)(roll_frame)
+
+        msg = "DataFrameGroupBy.apply operated on the grouping columns"
+        with tm.assert_produces_warning(DeprecationWarning, match=msg):
+            expected = g.apply(func)
+        # GH 39591: The grouped column should be all np.nan
+        # (groupby.apply inserts 0s for cov)
+        expected["A"] = np.nan
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("f", ["corr", "cov"])
+    def test_rolling_corr_cov_pairwise(self, f, roll_frame):
+        g = roll_frame.groupby("A")
+        r = g.rolling(window=4)
+
+        result = getattr(r.B, f)(pairwise=True)
+
+        def func(x):
+            return getattr(x.B.rolling(4), f)(pairwise=True)
+
+        msg = "DataFrameGroupBy.apply operated on the grouping columns"
+        with tm.assert_produces_warning(DeprecationWarning, match=msg):
+            expected = g.apply(func)
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "func, expected_values",
+        [("cov", [[1.0, 1.0], [1.0, 4.0]]), ("corr", [[1.0, 0.5], [0.5, 1.0]])],
+    )
+    def test_rolling_corr_cov_unordered(self, func, expected_values):
+        # GH 43386
+        df = DataFrame(
+            {
+                "a": ["g1", "g2", "g1", "g1"],
+                "b": [0, 0, 1, 2],
+                "c": [2, 0, 6, 4],
+            }
+        )
+        rol = df.groupby("a").rolling(3)
+        result = getattr(rol, func)()
+        expected = DataFrame(
+            {
+                "b": 4 * [np.nan] + expected_values[0] + 2 * [np.nan],
+                "c": 4 * [np.nan] + expected_values[1] + 2 * [np.nan],
+            },
+            index=MultiIndex.from_tuples(
+                [
+                    ("g1", 0, "b"),
+                    ("g1", 0, "c"),
+                    ("g1", 2, "b"),
+                    ("g1", 2, "c"),
+                    ("g1", 3, "b"),
+                    ("g1", 3, "c"),
+                    ("g2", 1, "b"),
+                    ("g2", 1, "c"),
+                ],
+                names=["a", None, None],
+            ),
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_rolling_apply(self, raw, roll_frame):
+        g = roll_frame.groupby("A", group_keys=False)
+        r = g.rolling(window=4)
+
+        # reduction
+        result = r.apply(lambda x: x.sum(), raw=raw)
+        msg = "DataFrameGroupBy.apply operated on the grouping columns"
+        with tm.assert_produces_warning(DeprecationWarning, match=msg):
+            expected = g.apply(lambda x: x.rolling(4).apply(lambda y: y.sum(), raw=raw))
+        # groupby.apply doesn't drop the grouped-by column
+        expected = expected.drop("A", axis=1)
+        # GH 39732
+        expected_index = MultiIndex.from_arrays([roll_frame["A"], range(40)])
+        expected.index = expected_index
+        tm.assert_frame_equal(result, expected)
+
+    def test_rolling_apply_mutability(self):
+        # GH 14013
+        df = DataFrame({"A": ["foo"] * 3 + ["bar"] * 3, "B": [1] * 6})
+        g = df.groupby("A")
+
+        mi = MultiIndex.from_tuples(
+            [("bar", 3), ("bar", 4), ("bar", 5), ("foo", 0), ("foo", 1), ("foo", 2)]
+        )
+
+        mi.names = ["A", None]
+        # Grouped column should not be a part of the output
+        expected = DataFrame([np.nan, 2.0, 2.0] * 2, columns=["B"], index=mi)
+
+        result = g.rolling(window=2).sum()
+        tm.assert_frame_equal(result, expected)
+
+        # Call an arbitrary function on the groupby
+        g.sum()
+
+        # Make sure nothing has been mutated
+        result = g.rolling(window=2).sum()
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("expected_value,raw_value", [[1.0, True], [0.0, False]])
+    def test_groupby_rolling(self, expected_value, raw_value):
+        # GH 31754
+
+        def isnumpyarray(x):
+            return int(isinstance(x, np.ndarray))
+
+        df = DataFrame({"id": [1, 1, 1], "value": [1, 2, 3]})
+        result = df.groupby("id").value.rolling(1).apply(isnumpyarray, raw=raw_value)
+        expected = Series(
+            [expected_value] * 3,
+            index=MultiIndex.from_tuples(((1, 0), (1, 1), (1, 2)), names=["id", None]),
+            name="value",
+        )
+        tm.assert_series_equal(result, expected)
+
+    def test_groupby_rolling_center_center(self):
+        # GH 35552
+        series = Series(range(1, 6))
+        result = series.groupby(series).rolling(center=True, window=3).mean()
+        expected = Series(
+            [np.nan] * 5,
+            index=MultiIndex.from_tuples(((1, 0), (2, 1), (3, 2), (4, 3), (5, 4))),
+        )
+        tm.assert_series_equal(result, expected)
+
+        series = Series(range(1, 5))
+        result = series.groupby(series).rolling(center=True, window=3).mean()
+        expected = Series(
+            [np.nan] * 4,
+            index=MultiIndex.from_tuples(((1, 0), (2, 1), (3, 2), (4, 3))),
+        )
+        tm.assert_series_equal(result, expected)
+
+        df = DataFrame({"a": ["a"] * 5 + ["b"] * 6, "b": range(11)})
+        result = df.groupby("a").rolling(center=True, window=3).mean()
+        expected = DataFrame(
+            [np.nan, 1, 2, 3, np.nan, np.nan, 6, 7, 8, 9, np.nan],
+            index=MultiIndex.from_tuples(
+                (
+                    ("a", 0),
+                    ("a", 1),
+                    ("a", 2),
+                    ("a", 3),
+                    ("a", 4),
+                    ("b", 5),
+                    ("b", 6),
+                    ("b", 7),
+                    ("b", 8),
+                    ("b", 9),
+                    ("b", 10),
+                ),
+                names=["a", None],
+            ),
+            columns=["b"],
+        )
+        tm.assert_frame_equal(result, expected)
+
+        df = DataFrame({"a": ["a"] * 5 + ["b"] * 5, "b": range(10)})
+        result = df.groupby("a").rolling(center=True, window=3).mean()
+        expected = DataFrame(
+            [np.nan, 1, 2, 3, np.nan, np.nan, 6, 7, 8, np.nan],
+            index=MultiIndex.from_tuples(
+                (
+                    ("a", 0),
+                    ("a", 1),
+                    ("a", 2),
+                    ("a", 3),
+                    ("a", 4),
+                    ("b", 5),
+                    ("b", 6),
+                    ("b", 7),
+                    ("b", 8),
+                    ("b", 9),
+                ),
+                names=["a", None],
+            ),
+            columns=["b"],
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_groupby_rolling_center_on(self):
+        # GH 37141
+        df = DataFrame(
+            data={
+                "Date": date_range("2020-01-01", "2020-01-10"),
+                "gb": ["group_1"] * 6 + ["group_2"] * 4,
+                "value": range(10),
+            }
+        )
+        result = (
+            df.groupby("gb")
+            .rolling(6, on="Date", center=True, min_periods=1)
+            .value.mean()
+        )
+        mi = MultiIndex.from_arrays([df["gb"], df["Date"]], names=["gb", "Date"])
+        expected = Series(
+            [1.0, 1.5, 2.0, 2.5, 3.0, 3.5, 7.0, 7.5, 7.5, 7.5],
+            name="value",
+            index=mi,
+        )
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize("min_periods", [5, 4, 3])
+    def test_groupby_rolling_center_min_periods(self, min_periods):
+        # GH 36040
+        df = DataFrame({"group": ["A"] * 10 + ["B"] * 10, "data": range(20)})
+
+        window_size = 5
+        result = (
+            df.groupby("group")
+            .rolling(window_size, center=True, min_periods=min_periods)
+            .mean()
+        )
+        result = result.reset_index()[["group", "data"]]
+
+        grp_A_mean = [1.0, 1.5, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 7.5, 8.0]
+        grp_B_mean = [x + 10.0 for x in grp_A_mean]
+
+        num_nans = max(0, min_periods - 3)  # For window_size of 5
+        nans = [np.nan] * num_nans
+        grp_A_expected = nans + grp_A_mean[num_nans : 10 - num_nans] + nans
+        grp_B_expected = nans + grp_B_mean[num_nans : 10 - num_nans] + nans
+
+        expected = DataFrame(
+            {"group": ["A"] * 10 + ["B"] * 10, "data": grp_A_expected + grp_B_expected}
+        )
+
+        tm.assert_frame_equal(result, expected)
+
+    def test_groupby_subselect_rolling(self):
+        # GH 35486
+        df = DataFrame(
+            {"a": [1, 2, 3, 2], "b": [4.0, 2.0, 3.0, 1.0], "c": [10, 20, 30, 20]}
+        )
+        result = df.groupby("a")[["b"]].rolling(2).max()
+        expected = DataFrame(
+            [np.nan, np.nan, 2.0, np.nan],
+            columns=["b"],
+            index=MultiIndex.from_tuples(
+                ((1, 0), (2, 1), (2, 3), (3, 2)), names=["a", None]
+            ),
+        )
+        tm.assert_frame_equal(result, expected)
+
+        result = df.groupby("a")["b"].rolling(2).max()
+        expected = Series(
+            [np.nan, np.nan, 2.0, np.nan],
+            index=MultiIndex.from_tuples(
+                ((1, 0), (2, 1), (2, 3), (3, 2)), names=["a", None]
+            ),
+            name="b",
+        )
+        tm.assert_series_equal(result, expected)
+
+    def test_groupby_rolling_custom_indexer(self):
+        # GH 35557
+        class SimpleIndexer(BaseIndexer):
+            def get_window_bounds(
+                self,
+                num_values=0,
+                min_periods=None,
+                center=None,
+                closed=None,
+                step=None,
+            ):
+                min_periods = self.window_size if min_periods is None else 0
+                end = np.arange(num_values, dtype=np.int64) + 1
+                start = end.copy() - self.window_size
+                start[start < 0] = min_periods
+                return start, end
+
+        df = DataFrame(
+            {"a": [1.0, 2.0, 3.0, 4.0, 5.0] * 3}, index=[0] * 5 + [1] * 5 + [2] * 5
+        )
+        result = (
+            df.groupby(df.index)
+            .rolling(SimpleIndexer(window_size=3), min_periods=1)
+            .sum()
+        )
+        expected = df.groupby(df.index).rolling(window=3, min_periods=1).sum()
+        tm.assert_frame_equal(result, expected)
+
+    def test_groupby_rolling_subset_with_closed(self):
+        # GH 35549
+        df = DataFrame(
+            {
+                "column1": range(8),
+                "column2": range(8),
+                "group": ["A"] * 4 + ["B"] * 4,
+                "date": [
+                    Timestamp(date)
+                    for date in ["2019-01-01", "2019-01-01", "2019-01-02", "2019-01-02"]
+                ]
+                * 2,
+            }
+        )
+        result = (
+            df.groupby("group").rolling("1D", on="date", closed="left")["column1"].sum()
+        )
+        expected = Series(
+            [np.nan, np.nan, 1.0, 1.0, np.nan, np.nan, 9.0, 9.0],
+            index=MultiIndex.from_frame(
+                df[["group", "date"]],
+                names=["group", "date"],
+            ),
+            name="column1",
+        )
+        tm.assert_series_equal(result, expected)
+
+    def test_groupby_subset_rolling_subset_with_closed(self):
+        # GH 35549
+        df = DataFrame(
+            {
+                "column1": range(8),
+                "column2": range(8),
+                "group": ["A"] * 4 + ["B"] * 4,
+                "date": [
+                    Timestamp(date)
+                    for date in ["2019-01-01", "2019-01-01", "2019-01-02", "2019-01-02"]
+                ]
+                * 2,
+            }
+        )
+
+        result = (
+            df.groupby("group")[["column1", "date"]]
+            .rolling("1D", on="date", closed="left")["column1"]
+            .sum()
+        )
+        expected = Series(
+            [np.nan, np.nan, 1.0, 1.0, np.nan, np.nan, 9.0, 9.0],
+            index=MultiIndex.from_frame(
+                df[["group", "date"]],
+                names=["group", "date"],
+            ),
+            name="column1",
+        )
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize("func", ["max", "min"])
+    def test_groupby_rolling_index_changed(self, func):
+        # GH: #36018 nlevels of MultiIndex changed
+        ds = Series(
+            [1, 2, 2],
+            index=MultiIndex.from_tuples(
+                [("a", "x"), ("a", "y"), ("c", "z")], names=["1", "2"]
+            ),
+            name="a",
+        )
+
+        result = getattr(ds.groupby(ds).rolling(2), func)()
+        expected = Series(
+            [np.nan, np.nan, 2.0],
+            index=MultiIndex.from_tuples(
+                [(1, "a", "x"), (2, "a", "y"), (2, "c", "z")], names=["a", "1", "2"]
+            ),
+            name="a",
+        )
+        tm.assert_series_equal(result, expected)
+
+    def test_groupby_rolling_empty_frame(self):
+        # GH 36197
+        expected = DataFrame({"s1": []})
+        result = expected.groupby("s1").rolling(window=1).sum()
+        # GH 32262
+        expected = expected.drop(columns="s1")
+        # GH-38057 from_tuples gives empty object dtype, we now get float/int levels
+        # expected.index = MultiIndex.from_tuples([], names=["s1", None])
+        expected.index = MultiIndex.from_product(
+            [Index([], dtype="float64"), Index([], dtype="int64")], names=["s1", None]
+        )
+        tm.assert_frame_equal(result, expected)
+
+        expected = DataFrame({"s1": [], "s2": []})
+        result = expected.groupby(["s1", "s2"]).rolling(window=1).sum()
+        # GH 32262
+        expected = expected.drop(columns=["s1", "s2"])
+        expected.index = MultiIndex.from_product(
+            [
+                Index([], dtype="float64"),
+                Index([], dtype="float64"),
+                Index([], dtype="int64"),
+            ],
+            names=["s1", "s2", None],
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_groupby_rolling_string_index(self):
+        # GH: 36727
+        df = DataFrame(
+            [
+                ["A", "group_1", Timestamp(2019, 1, 1, 9)],
+                ["B", "group_1", Timestamp(2019, 1, 2, 9)],
+                ["Z", "group_2", Timestamp(2019, 1, 3, 9)],
+                ["H", "group_1", Timestamp(2019, 1, 6, 9)],
+                ["E", "group_2", Timestamp(2019, 1, 20, 9)],
+            ],
+            columns=["index", "group", "eventTime"],
+        ).set_index("index")
+
+        groups = df.groupby("group")
+        df["count_to_date"] = groups.cumcount()
+        rolling_groups = groups.rolling("10d", on="eventTime")
+        result = rolling_groups.apply(lambda df: df.shape[0])
+        expected = DataFrame(
+            [
+                ["A", "group_1", Timestamp(2019, 1, 1, 9), 1.0],
+                ["B", "group_1", Timestamp(2019, 1, 2, 9), 2.0],
+                ["H", "group_1", Timestamp(2019, 1, 6, 9), 3.0],
+                ["Z", "group_2", Timestamp(2019, 1, 3, 9), 1.0],
+                ["E", "group_2", Timestamp(2019, 1, 20, 9), 1.0],
+            ],
+            columns=["index", "group", "eventTime", "count_to_date"],
+        ).set_index(["group", "index"])
+        tm.assert_frame_equal(result, expected)
+
+    def test_groupby_rolling_no_sort(self):
+        # GH 36889
+        result = (
+            DataFrame({"foo": [2, 1], "bar": [2, 1]})
+            .groupby("foo", sort=False)
+            .rolling(1)
+            .min()
+        )
+        expected = DataFrame(
+            np.array([[2.0, 2.0], [1.0, 1.0]]),
+            columns=["foo", "bar"],
+            index=MultiIndex.from_tuples([(2, 0), (1, 1)], names=["foo", None]),
+        )
+        # GH 32262
+        expected = expected.drop(columns="foo")
+        tm.assert_frame_equal(result, expected)
+
+    def test_groupby_rolling_count_closed_on(self, unit):
+        # GH 35869
+        df = DataFrame(
+            {
+                "column1": range(6),
+                "column2": range(6),
+                "group": 3 * ["A", "B"],
+                "date": date_range(end="20190101", periods=6, unit=unit),
+            }
+        )
+        result = (
+            df.groupby("group")
+            .rolling("3d", on="date", closed="left")["column1"]
+            .count()
+        )
+        dti = DatetimeIndex(
+            [
+                "2018-12-27",
+                "2018-12-29",
+                "2018-12-31",
+                "2018-12-28",
+                "2018-12-30",
+                "2019-01-01",
+            ],
+            dtype=f"M8[{unit}]",
+        )
+        mi = MultiIndex.from_arrays(
+            [
+                ["A", "A", "A", "B", "B", "B"],
+                dti,
+            ],
+            names=["group", "date"],
+        )
+        expected = Series(
+            [np.nan, 1.0, 1.0, np.nan, 1.0, 1.0],
+            name="column1",
+            index=mi,
+        )
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        ("func", "kwargs"),
+        [("rolling", {"window": 2, "min_periods": 1}), ("expanding", {})],
+    )
+    def test_groupby_rolling_sem(self, func, kwargs):
+        # GH: 26476
+        df = DataFrame(
+            [["a", 1], ["a", 2], ["b", 1], ["b", 2], ["b", 3]], columns=["a", "b"]
+        )
+        result = getattr(df.groupby("a"), func)(**kwargs).sem()
+        expected = DataFrame(
+            {"a": [np.nan] * 5, "b": [np.nan, 0.70711, np.nan, 0.70711, 0.70711]},
+            index=MultiIndex.from_tuples(
+                [("a", 0), ("a", 1), ("b", 2), ("b", 3), ("b", 4)], names=["a", None]
+            ),
+        )
+        # GH 32262
+        expected = expected.drop(columns="a")
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        ("rollings", "key"), [({"on": "a"}, "a"), ({"on": None}, "index")]
+    )
+    def test_groupby_rolling_nans_in_index(self, rollings, key):
+        # GH: 34617
+        df = DataFrame(
+            {
+                "a": to_datetime(["2020-06-01 12:00", "2020-06-01 14:00", np.nan]),
+                "b": [1, 2, 3],
+                "c": [1, 1, 1],
+            }
+        )
+        if key == "index":
+            df = df.set_index("a")
+        with pytest.raises(ValueError, match=f"{key} values must not have NaT"):
+            df.groupby("c").rolling("60min", **rollings)
+
+    @pytest.mark.parametrize("group_keys", [True, False])
+    def test_groupby_rolling_group_keys(self, group_keys):
+        # GH 37641
+        # GH 38523: GH 37641 actually was not a bug.
+        # group_keys only applies to groupby.apply directly
+        arrays = [["val1", "val1", "val2"], ["val1", "val1", "val2"]]
+        index = MultiIndex.from_arrays(arrays, names=("idx1", "idx2"))
+
+        s = Series([1, 2, 3], index=index)
+        result = s.groupby(["idx1", "idx2"], group_keys=group_keys).rolling(1).mean()
+        expected = Series(
+            [1.0, 2.0, 3.0],
+            index=MultiIndex.from_tuples(
+                [
+                    ("val1", "val1", "val1", "val1"),
+                    ("val1", "val1", "val1", "val1"),
+                    ("val2", "val2", "val2", "val2"),
+                ],
+                names=["idx1", "idx2", "idx1", "idx2"],
+            ),
+        )
+        tm.assert_series_equal(result, expected)
+
+    def test_groupby_rolling_index_level_and_column_label(self):
+        # The groupby keys should not appear as a resulting column
+        arrays = [["val1", "val1", "val2"], ["val1", "val1", "val2"]]
+        index = MultiIndex.from_arrays(arrays, names=("idx1", "idx2"))
+
+        df = DataFrame({"A": [1, 1, 2], "B": range(3)}, index=index)
+        result = df.groupby(["idx1", "A"]).rolling(1).mean()
+        expected = DataFrame(
+            {"B": [0.0, 1.0, 2.0]},
+            index=MultiIndex.from_tuples(
+                [
+                    ("val1", 1, "val1", "val1"),
+                    ("val1", 1, "val1", "val1"),
+                    ("val2", 2, "val2", "val2"),
+                ],
+                names=["idx1", "A", "idx1", "idx2"],
+            ),
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_groupby_rolling_resulting_multiindex(self):
+        # a few different cases checking the created MultiIndex of the result
+        # https://github.com/pandas-dev/pandas/pull/38057
+
+        # grouping by 1 columns -> 2-level MI as result
+        df = DataFrame({"a": np.arange(8.0), "b": [1, 2] * 4})
+        result = df.groupby("b").rolling(3).mean()
+        expected_index = MultiIndex.from_tuples(
+            [(1, 0), (1, 2), (1, 4), (1, 6), (2, 1), (2, 3), (2, 5), (2, 7)],
+            names=["b", None],
+        )
+        tm.assert_index_equal(result.index, expected_index)
+
+    def test_groupby_rolling_resulting_multiindex2(self):
+        # grouping by 2 columns -> 3-level MI as result
+        df = DataFrame({"a": np.arange(12.0), "b": [1, 2] * 6, "c": [1, 2, 3, 4] * 3})
+        result = df.groupby(["b", "c"]).rolling(2).sum()
+        expected_index = MultiIndex.from_tuples(
+            [
+                (1, 1, 0),
+                (1, 1, 4),
+                (1, 1, 8),
+                (1, 3, 2),
+                (1, 3, 6),
+                (1, 3, 10),
+                (2, 2, 1),
+                (2, 2, 5),
+                (2, 2, 9),
+                (2, 4, 3),
+                (2, 4, 7),
+                (2, 4, 11),
+            ],
+            names=["b", "c", None],
+        )
+        tm.assert_index_equal(result.index, expected_index)
+
+    def test_groupby_rolling_resulting_multiindex3(self):
+        # grouping with 1 level on dataframe with 2-level MI -> 3-level MI as result
+        df = DataFrame({"a": np.arange(8.0), "b": [1, 2] * 4, "c": [1, 2, 3, 4] * 2})
+        df = df.set_index("c", append=True)
+        result = df.groupby("b").rolling(3).mean()
+        expected_index = MultiIndex.from_tuples(
+            [
+                (1, 0, 1),
+                (1, 2, 3),
+                (1, 4, 1),
+                (1, 6, 3),
+                (2, 1, 2),
+                (2, 3, 4),
+                (2, 5, 2),
+                (2, 7, 4),
+            ],
+            names=["b", None, "c"],
+        )
+        tm.assert_index_equal(result.index, expected_index, exact="equiv")
+
+    def test_groupby_rolling_object_doesnt_affect_groupby_apply(self, roll_frame):
+        # GH 39732
+        g = roll_frame.groupby("A", group_keys=False)
+        msg = "DataFrameGroupBy.apply operated on the grouping columns"
+        with tm.assert_produces_warning(DeprecationWarning, match=msg):
+            expected = g.apply(lambda x: x.rolling(4).sum()).index
+        _ = g.rolling(window=4)
+        msg = "DataFrameGroupBy.apply operated on the grouping columns"
+        with tm.assert_produces_warning(DeprecationWarning, match=msg):
+            result = g.apply(lambda x: x.rolling(4).sum()).index
+        tm.assert_index_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        ("window", "min_periods", "closed", "expected"),
+        [
+            (2, 0, "left", [None, 0.0, 1.0, 1.0, None, 0.0, 1.0, 1.0]),
+            (2, 2, "left", [None, None, 1.0, 1.0, None, None, 1.0, 1.0]),
+            (4, 4, "left", [None, None, None, None, None, None, None, None]),
+            (4, 4, "right", [None, None, None, 5.0, None, None, None, 5.0]),
+        ],
+    )
+    def test_groupby_rolling_var(self, window, min_periods, closed, expected):
+        df = DataFrame([1, 2, 3, 4, 5, 6, 7, 8])
+        result = (
+            df.groupby([1, 2, 1, 2, 1, 2, 1, 2])
+            .rolling(window=window, min_periods=min_periods, closed=closed)
+            .var(0)
+        )
+        expected_result = DataFrame(
+            np.array(expected, dtype="float64"),
+            index=MultiIndex(
+                levels=[np.array([1, 2]), [0, 1, 2, 3, 4, 5, 6, 7]],
+                codes=[[0, 0, 0, 0, 1, 1, 1, 1], [0, 2, 4, 6, 1, 3, 5, 7]],
+            ),
+        )
+        tm.assert_frame_equal(result, expected_result)
+
+    @pytest.mark.parametrize(
+        "columns", [MultiIndex.from_tuples([("A", ""), ("B", "C")]), ["A", "B"]]
+    )
+    def test_by_column_not_in_values(self, columns):
+        # GH 32262
+        df = DataFrame([[1, 0]] * 20 + [[2, 0]] * 12 + [[3, 0]] * 8, columns=columns)
+        g = df.groupby("A")
+        original_obj = g.obj.copy(deep=True)
+        r = g.rolling(4)
+        result = r.sum()
+        assert "A" not in result.columns
+        tm.assert_frame_equal(g.obj, original_obj)
+
+    def test_groupby_level(self):
+        # GH 38523, 38787
+        arrays = [
+            ["Falcon", "Falcon", "Parrot", "Parrot"],
+            ["Captive", "Wild", "Captive", "Wild"],
+        ]
+        index = MultiIndex.from_arrays(arrays, names=("Animal", "Type"))
+        df = DataFrame({"Max Speed": [390.0, 350.0, 30.0, 20.0]}, index=index)
+        result = df.groupby(level=0)["Max Speed"].rolling(2).sum()
+        expected = Series(
+            [np.nan, 740.0, np.nan, 50.0],
+            index=MultiIndex.from_tuples(
+                [
+                    ("Falcon", "Falcon", "Captive"),
+                    ("Falcon", "Falcon", "Wild"),
+                    ("Parrot", "Parrot", "Captive"),
+                    ("Parrot", "Parrot", "Wild"),
+                ],
+                names=["Animal", "Animal", "Type"],
+            ),
+            name="Max Speed",
+        )
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "by, expected_data",
+        [
+            [["id"], {"num": [100.0, 150.0, 150.0, 200.0]}],
+            [
+                ["id", "index"],
+                {
+                    "date": [
+                        Timestamp("2018-01-01"),
+                        Timestamp("2018-01-02"),
+                        Timestamp("2018-01-01"),
+                        Timestamp("2018-01-02"),
+                    ],
+                    "num": [100.0, 200.0, 150.0, 250.0],
+                },
+            ],
+        ],
+    )
+    def test_as_index_false(self, by, expected_data, unit):
+        # GH 39433
+        data = [
+            ["A", "2018-01-01", 100.0],
+            ["A", "2018-01-02", 200.0],
+            ["B", "2018-01-01", 150.0],
+            ["B", "2018-01-02", 250.0],
+        ]
+        df = DataFrame(data, columns=["id", "date", "num"])
+        df["date"] = df["date"].astype(f"M8[{unit}]")
+        df = df.set_index(["date"])
+
+        gp_by = [getattr(df, attr) for attr in by]
+        result = (
+            df.groupby(gp_by, as_index=False).rolling(window=2, min_periods=1).mean()
+        )
+
+        expected = {"id": ["A", "A", "B", "B"]}
+        expected.update(expected_data)
+        expected = DataFrame(
+            expected,
+            index=df.index,
+        )
+        if "date" in expected_data:
+            expected["date"] = expected["date"].astype(f"M8[{unit}]")
+        tm.assert_frame_equal(result, expected)
+
+    def test_nan_and_zero_endpoints(self, any_int_numpy_dtype):
+        # https://github.com/twosigma/pandas/issues/53
+        typ = np.dtype(any_int_numpy_dtype).type
+        size = 1000
+        idx = np.repeat(typ(0), size)
+        idx[-1] = 1
+
+        val = 5e25
+        arr = np.repeat(val, size)
+        arr[0] = np.nan
+        arr[-1] = 0
+
+        df = DataFrame(
+            {
+                "index": idx,
+                "adl2": arr,
+            }
+        ).set_index("index")
+        result = df.groupby("index")["adl2"].rolling(window=10, min_periods=1).mean()
+        expected = Series(
+            arr,
+            name="adl2",
+            index=MultiIndex.from_arrays(
+                [
+                    Index([0] * 999 + [1], dtype=typ, name="index"),
+                    Index([0] * 999 + [1], dtype=typ, name="index"),
+                ],
+            ),
+        )
+        tm.assert_series_equal(result, expected)
+
+    def test_groupby_rolling_non_monotonic(self):
+        # GH 43909
+
+        shuffled = [3, 0, 1, 2]
+        sec = 1_000
+        df = DataFrame(
+            [{"t": Timestamp(2 * x * sec), "x": x + 1, "c": 42} for x in shuffled]
+        )
+        with pytest.raises(ValueError, match=r".* must be monotonic"):
+            df.groupby("c").rolling(on="t", window="3s")
+
+    def test_groupby_monotonic(self):
+        # GH 15130
+        # we don't need to validate monotonicity when grouping
+
+        # GH 43909 we should raise an error here to match
+        # behaviour of non-groupby rolling.
+
+        data = [
+            ["David", "1/1/2015", 100],
+            ["David", "1/5/2015", 500],
+            ["David", "5/30/2015", 50],
+            ["David", "7/25/2015", 50],
+            ["Ryan", "1/4/2014", 100],
+            ["Ryan", "1/19/2015", 500],
+            ["Ryan", "3/31/2016", 50],
+            ["Joe", "7/1/2015", 100],
+            ["Joe", "9/9/2015", 500],
+            ["Joe", "10/15/2015", 50],
+        ]
+
+        df = DataFrame(data=data, columns=["name", "date", "amount"])
+        df["date"] = to_datetime(df["date"])
+        df = df.sort_values("date")
+
+        msg = "DataFrameGroupBy.apply operated on the grouping columns"
+        with tm.assert_produces_warning(DeprecationWarning, match=msg):
+            expected = (
+                df.set_index("date")
+                .groupby("name")
+                .apply(lambda x: x.rolling("180D")["amount"].sum())
+            )
+        result = df.groupby("name").rolling("180D", on="date")["amount"].sum()
+        tm.assert_series_equal(result, expected)
+
+    def test_datelike_on_monotonic_within_each_group(self):
+        # GH 13966 (similar to #15130, closed by #15175)
+
+        # superseded by 43909
+        # GH 46061: OK if the on is monotonic relative to each each group
+
+        dates = date_range(start="2016-01-01 09:30:00", periods=20, freq="s")
+        df = DataFrame(
+            {
+                "A": [1] * 20 + [2] * 12 + [3] * 8,
+                "B": np.concatenate((dates, dates)),
+                "C": np.arange(40),
+            }
+        )
+
+        msg = "DataFrameGroupBy.apply operated on the grouping columns"
+        with tm.assert_produces_warning(DeprecationWarning, match=msg):
+            expected = (
+                df.set_index("B")
+                .groupby("A")
+                .apply(lambda x: x.rolling("4s")["C"].mean())
+            )
+        result = df.groupby("A").rolling("4s", on="B").C.mean()
+        tm.assert_series_equal(result, expected)
+
+    def test_datelike_on_not_monotonic_within_each_group(self):
+        # GH 46061
+        df = DataFrame(
+            {
+                "A": [1] * 3 + [2] * 3,
+                "B": [Timestamp(year, 1, 1) for year in [2020, 2021, 2019]] * 2,
+                "C": range(6),
+            }
+        )
+        with pytest.raises(ValueError, match="Each group within B must be monotonic."):
+            df.groupby("A").rolling("365D", on="B")
+
+
+class TestExpanding:
+    @pytest.fixture
+    def frame(self):
+        return DataFrame({"A": [1] * 20 + [2] * 12 + [3] * 8, "B": np.arange(40)})
+
+    @pytest.mark.parametrize(
+        "f", ["sum", "mean", "min", "max", "count", "kurt", "skew"]
+    )
+    def test_expanding(self, f, frame):
+        g = frame.groupby("A", group_keys=False)
+        r = g.expanding()
+
+        result = getattr(r, f)()
+        msg = "DataFrameGroupBy.apply operated on the grouping columns"
+        with tm.assert_produces_warning(DeprecationWarning, match=msg):
+            expected = g.apply(lambda x: getattr(x.expanding(), f)())
+        # groupby.apply doesn't drop the grouped-by column
+        expected = expected.drop("A", axis=1)
+        # GH 39732
+        expected_index = MultiIndex.from_arrays([frame["A"], range(40)])
+        expected.index = expected_index
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("f", ["std", "var"])
+    def test_expanding_ddof(self, f, frame):
+        g = frame.groupby("A", group_keys=False)
+        r = g.expanding()
+
+        result = getattr(r, f)(ddof=0)
+        msg = "DataFrameGroupBy.apply operated on the grouping columns"
+        with tm.assert_produces_warning(DeprecationWarning, match=msg):
+            expected = g.apply(lambda x: getattr(x.expanding(), f)(ddof=0))
+        # groupby.apply doesn't drop the grouped-by column
+        expected = expected.drop("A", axis=1)
+        # GH 39732
+        expected_index = MultiIndex.from_arrays([frame["A"], range(40)])
+        expected.index = expected_index
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "interpolation", ["linear", "lower", "higher", "midpoint", "nearest"]
+    )
+    def test_expanding_quantile(self, interpolation, frame):
+        g = frame.groupby("A", group_keys=False)
+        r = g.expanding()
+
+        result = r.quantile(0.4, interpolation=interpolation)
+        msg = "DataFrameGroupBy.apply operated on the grouping columns"
+        with tm.assert_produces_warning(DeprecationWarning, match=msg):
+            expected = g.apply(
+                lambda x: x.expanding().quantile(0.4, interpolation=interpolation)
+            )
+        # groupby.apply doesn't drop the grouped-by column
+        expected = expected.drop("A", axis=1)
+        # GH 39732
+        expected_index = MultiIndex.from_arrays([frame["A"], range(40)])
+        expected.index = expected_index
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("f", ["corr", "cov"])
+    def test_expanding_corr_cov(self, f, frame):
+        g = frame.groupby("A")
+        r = g.expanding()
+
+        result = getattr(r, f)(frame)
+
+        def func_0(x):
+            return getattr(x.expanding(), f)(frame)
+
+        msg = "DataFrameGroupBy.apply operated on the grouping columns"
+        with tm.assert_produces_warning(DeprecationWarning, match=msg):
+            expected = g.apply(func_0)
+        # GH 39591: groupby.apply returns 1 instead of nan for windows
+        # with all nan values
+        null_idx = list(range(20, 61)) + list(range(72, 113))
+        expected.iloc[null_idx, 1] = np.nan
+        # GH 39591: The grouped column should be all np.nan
+        # (groupby.apply inserts 0s for cov)
+        expected["A"] = np.nan
+        tm.assert_frame_equal(result, expected)
+
+        result = getattr(r.B, f)(pairwise=True)
+
+        def func_1(x):
+            return getattr(x.B.expanding(), f)(pairwise=True)
+
+        msg = "DataFrameGroupBy.apply operated on the grouping columns"
+        with tm.assert_produces_warning(DeprecationWarning, match=msg):
+            expected = g.apply(func_1)
+        tm.assert_series_equal(result, expected)
+
+    def test_expanding_apply(self, raw, frame):
+        g = frame.groupby("A", group_keys=False)
+        r = g.expanding()
+
+        # reduction
+        result = r.apply(lambda x: x.sum(), raw=raw)
+        msg = "DataFrameGroupBy.apply operated on the grouping columns"
+        with tm.assert_produces_warning(DeprecationWarning, match=msg):
+            expected = g.apply(
+                lambda x: x.expanding().apply(lambda y: y.sum(), raw=raw)
+            )
+        # groupby.apply doesn't drop the grouped-by column
+        expected = expected.drop("A", axis=1)
+        # GH 39732
+        expected_index = MultiIndex.from_arrays([frame["A"], range(40)])
+        expected.index = expected_index
+        tm.assert_frame_equal(result, expected)
+
+
+class TestEWM:
+    @pytest.mark.parametrize(
+        "method, expected_data",
+        [
+            ["mean", [0.0, 0.6666666666666666, 1.4285714285714286, 2.2666666666666666]],
+            ["std", [np.nan, 0.707107, 0.963624, 1.177164]],
+            ["var", [np.nan, 0.5, 0.9285714285714286, 1.3857142857142857]],
+        ],
+    )
+    def test_methods(self, method, expected_data):
+        # GH 16037
+        df = DataFrame({"A": ["a"] * 4, "B": range(4)})
+        result = getattr(df.groupby("A").ewm(com=1.0), method)()
+        expected = DataFrame(
+            {"B": expected_data},
+            index=MultiIndex.from_tuples(
+                [
+                    ("a", 0),
+                    ("a", 1),
+                    ("a", 2),
+                    ("a", 3),
+                ],
+                names=["A", None],
+            ),
+        )
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "method, expected_data",
+        [["corr", [np.nan, 1.0, 1.0, 1]], ["cov", [np.nan, 0.5, 0.928571, 1.385714]]],
+    )
+    def test_pairwise_methods(self, method, expected_data):
+        # GH 16037
+        df = DataFrame({"A": ["a"] * 4, "B": range(4)})
+        result = getattr(df.groupby("A").ewm(com=1.0), method)()
+        expected = DataFrame(
+            {"B": expected_data},
+            index=MultiIndex.from_tuples(
+                [
+                    ("a", 0, "B"),
+                    ("a", 1, "B"),
+                    ("a", 2, "B"),
+                    ("a", 3, "B"),
+                ],
+                names=["A", None, None],
+            ),
+        )
+        tm.assert_frame_equal(result, expected)
+
+        expected = df.groupby("A")[["B"]].apply(
+            lambda x: getattr(x.ewm(com=1.0), method)()
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_times(self, times_frame):
+        # GH 40951
+        halflife = "23 days"
+        # GH#42738
+        times = times_frame.pop("C")
+        result = times_frame.groupby("A").ewm(halflife=halflife, times=times).mean()
+        expected = DataFrame(
+            {
+                "B": [
+                    0.0,
+                    0.507534,
+                    1.020088,
+                    1.537661,
+                    0.0,
+                    0.567395,
+                    1.221209,
+                    0.0,
+                    0.653141,
+                    1.195003,
+                ]
+            },
+            index=MultiIndex.from_tuples(
+                [
+                    ("a", 0),
+                    ("a", 3),
+                    ("a", 6),
+                    ("a", 9),
+                    ("b", 1),
+                    ("b", 4),
+                    ("b", 7),
+                    ("c", 2),
+                    ("c", 5),
+                    ("c", 8),
+                ],
+                names=["A", None],
+            ),
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_times_array(self, times_frame):
+        # GH 40951
+        halflife = "23 days"
+        times = times_frame.pop("C")
+        gb = times_frame.groupby("A")
+        result = gb.ewm(halflife=halflife, times=times).mean()
+        expected = gb.ewm(halflife=halflife, times=times.values).mean()
+        tm.assert_frame_equal(result, expected)
+
+    def test_dont_mutate_obj_after_slicing(self):
+        # GH 43355
+        df = DataFrame(
+            {
+                "id": ["a", "a", "b", "b", "b"],
+                "timestamp": date_range("2021-9-1", periods=5, freq="h"),
+                "y": range(5),
+            }
+        )
+        grp = df.groupby("id").rolling("1h", on="timestamp")
+        result = grp.count()
+        expected_df = DataFrame(
+            {
+                "timestamp": date_range("2021-9-1", periods=5, freq="h"),
+                "y": [1.0] * 5,
+            },
+            index=MultiIndex.from_arrays(
+                [["a", "a", "b", "b", "b"], list(range(5))], names=["id", None]
+            ),
+        )
+        tm.assert_frame_equal(result, expected_df)
+
+        result = grp["y"].count()
+        expected_series = Series(
+            [1.0] * 5,
+            index=MultiIndex.from_arrays(
+                [
+                    ["a", "a", "b", "b", "b"],
+                    date_range("2021-9-1", periods=5, freq="h"),
+                ],
+                names=["id", "timestamp"],
+            ),
+            name="y",
+        )
+        tm.assert_series_equal(result, expected_series)
+        # This is the key test
+        result = grp.count()
+        tm.assert_frame_equal(result, expected_df)
+
+
+def test_rolling_corr_with_single_integer_in_index():
+    # GH 44078
+    df = DataFrame({"a": [(1,), (1,), (1,)], "b": [4, 5, 6]})
+    gb = df.groupby(["a"])
+    result = gb.rolling(2).corr(other=df)
+    index = MultiIndex.from_tuples([((1,), 0), ((1,), 1), ((1,), 2)], names=["a", None])
+    expected = DataFrame(
+        {"a": [np.nan, np.nan, np.nan], "b": [np.nan, 1.0, 1.0]}, index=index
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+def test_rolling_corr_with_tuples_in_index():
+    # GH 44078
+    df = DataFrame(
+        {
+            "a": [
+                (
+                    1,
+                    2,
+                ),
+                (
+                    1,
+                    2,
+                ),
+                (
+                    1,
+                    2,
+                ),
+            ],
+            "b": [4, 5, 6],
+        }
+    )
+    gb = df.groupby(["a"])
+    result = gb.rolling(2).corr(other=df)
+    index = MultiIndex.from_tuples(
+        [((1, 2), 0), ((1, 2), 1), ((1, 2), 2)], names=["a", None]
+    )
+    expected = DataFrame(
+        {"a": [np.nan, np.nan, np.nan], "b": [np.nan, 1.0, 1.0]}, index=index
+    )
+    tm.assert_frame_equal(result, expected)
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/test_numba.py b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/test_numba.py
new file mode 100644
index 0000000000000000000000000000000000000000..139e1ff7f65fda615ab149e29b8369e2001050e5
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/test_numba.py
@@ -0,0 +1,455 @@
+import numpy as np
+import pytest
+
+from pandas.errors import NumbaUtilError
+import pandas.util._test_decorators as td
+
+from pandas import (
+    DataFrame,
+    Series,
+    option_context,
+    to_datetime,
+)
+import pandas._testing as tm
+
+pytestmark = pytest.mark.single_cpu
+
+
+@pytest.fixture(params=["single", "table"])
+def method(request):
+    """method keyword in rolling/expanding/ewm constructor"""
+    return request.param
+
+
+@pytest.fixture(
+    params=[
+        ["sum", {}],
+        ["mean", {}],
+        ["median", {}],
+        ["max", {}],
+        ["min", {}],
+        ["var", {}],
+        ["var", {"ddof": 0}],
+        ["std", {}],
+        ["std", {"ddof": 0}],
+    ]
+)
+def arithmetic_numba_supported_operators(request):
+    return request.param
+
+
+@td.skip_if_no("numba")
+@pytest.mark.filterwarnings("ignore")
+# Filter warnings when parallel=True and the function can't be parallelized by Numba
+class TestEngine:
+    @pytest.mark.parametrize("jit", [True, False])
+    def test_numba_vs_cython_apply(self, jit, nogil, parallel, nopython, center, step):
+        def f(x, *args):
+            arg_sum = 0
+            for arg in args:
+                arg_sum += arg
+            return np.mean(x) + arg_sum
+
+        if jit:
+            import numba
+
+            f = numba.jit(f)
+
+        engine_kwargs = {"nogil": nogil, "parallel": parallel, "nopython": nopython}
+        args = (2,)
+
+        s = Series(range(10))
+        result = s.rolling(2, center=center, step=step).apply(
+            f, args=args, engine="numba", engine_kwargs=engine_kwargs, raw=True
+        )
+        expected = s.rolling(2, center=center, step=step).apply(
+            f, engine="cython", args=args, raw=True
+        )
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "data",
+        [
+            DataFrame(np.eye(5)),
+            DataFrame(
+                [
+                    [5, 7, 7, 7, np.nan, np.inf, 4, 3, 3, 3],
+                    [5, 7, 7, 7, np.nan, np.inf, 7, 3, 3, 3],
+                    [np.nan, np.nan, 5, 6, 7, 5, 5, 5, 5, 5],
+                ]
+            ).T,
+            Series(range(5), name="foo"),
+            Series([20, 10, 10, np.inf, 1, 1, 2, 3]),
+            Series([20, 10, 10, np.nan, 10, 1, 2, 3]),
+        ],
+    )
+    def test_numba_vs_cython_rolling_methods(
+        self,
+        data,
+        nogil,
+        parallel,
+        nopython,
+        arithmetic_numba_supported_operators,
+        step,
+    ):
+        method, kwargs = arithmetic_numba_supported_operators
+
+        engine_kwargs = {"nogil": nogil, "parallel": parallel, "nopython": nopython}
+
+        roll = data.rolling(3, step=step)
+        result = getattr(roll, method)(
+            engine="numba", engine_kwargs=engine_kwargs, **kwargs
+        )
+        expected = getattr(roll, method)(engine="cython", **kwargs)
+        tm.assert_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "data", [DataFrame(np.eye(5)), Series(range(5), name="foo")]
+    )
+    def test_numba_vs_cython_expanding_methods(
+        self, data, nogil, parallel, nopython, arithmetic_numba_supported_operators
+    ):
+        method, kwargs = arithmetic_numba_supported_operators
+
+        engine_kwargs = {"nogil": nogil, "parallel": parallel, "nopython": nopython}
+
+        data = DataFrame(np.eye(5))
+        expand = data.expanding()
+        result = getattr(expand, method)(
+            engine="numba", engine_kwargs=engine_kwargs, **kwargs
+        )
+        expected = getattr(expand, method)(engine="cython", **kwargs)
+        tm.assert_equal(result, expected)
+
+    @pytest.mark.parametrize("jit", [True, False])
+    def test_cache_apply(self, jit, nogil, parallel, nopython, step):
+        # Test that the functions are cached correctly if we switch functions
+        def func_1(x):
+            return np.mean(x) + 4
+
+        def func_2(x):
+            return np.std(x) * 5
+
+        if jit:
+            import numba
+
+            func_1 = numba.jit(func_1)
+            func_2 = numba.jit(func_2)
+
+        engine_kwargs = {"nogil": nogil, "parallel": parallel, "nopython": nopython}
+
+        roll = Series(range(10)).rolling(2, step=step)
+        result = roll.apply(
+            func_1, engine="numba", engine_kwargs=engine_kwargs, raw=True
+        )
+        expected = roll.apply(func_1, engine="cython", raw=True)
+        tm.assert_series_equal(result, expected)
+
+        result = roll.apply(
+            func_2, engine="numba", engine_kwargs=engine_kwargs, raw=True
+        )
+        expected = roll.apply(func_2, engine="cython", raw=True)
+        tm.assert_series_equal(result, expected)
+        # This run should use the cached func_1
+        result = roll.apply(
+            func_1, engine="numba", engine_kwargs=engine_kwargs, raw=True
+        )
+        expected = roll.apply(func_1, engine="cython", raw=True)
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "window,window_kwargs",
+        [
+            ["rolling", {"window": 3, "min_periods": 0}],
+            ["expanding", {}],
+        ],
+    )
+    def test_dont_cache_args(
+        self, window, window_kwargs, nogil, parallel, nopython, method
+    ):
+        # GH 42287
+
+        def add(values, x):
+            return np.sum(values) + x
+
+        engine_kwargs = {"nopython": nopython, "nogil": nogil, "parallel": parallel}
+        df = DataFrame({"value": [0, 0, 0]})
+        result = getattr(df, window)(method=method, **window_kwargs).apply(
+            add, raw=True, engine="numba", engine_kwargs=engine_kwargs, args=(1,)
+        )
+        expected = DataFrame({"value": [1.0, 1.0, 1.0]})
+        tm.assert_frame_equal(result, expected)
+
+        result = getattr(df, window)(method=method, **window_kwargs).apply(
+            add, raw=True, engine="numba", engine_kwargs=engine_kwargs, args=(2,)
+        )
+        expected = DataFrame({"value": [2.0, 2.0, 2.0]})
+        tm.assert_frame_equal(result, expected)
+
+    def test_dont_cache_engine_kwargs(self):
+        # If the user passes a different set of engine_kwargs don't return the same
+        # jitted function
+        nogil = False
+        parallel = True
+        nopython = True
+
+        def func(x):
+            return nogil + parallel + nopython
+
+        engine_kwargs = {"nopython": nopython, "nogil": nogil, "parallel": parallel}
+        df = DataFrame({"value": [0, 0, 0]})
+        result = df.rolling(1).apply(
+            func, raw=True, engine="numba", engine_kwargs=engine_kwargs
+        )
+        expected = DataFrame({"value": [2.0, 2.0, 2.0]})
+        tm.assert_frame_equal(result, expected)
+
+        parallel = False
+        engine_kwargs = {"nopython": nopython, "nogil": nogil, "parallel": parallel}
+        result = df.rolling(1).apply(
+            func, raw=True, engine="numba", engine_kwargs=engine_kwargs
+        )
+        expected = DataFrame({"value": [1.0, 1.0, 1.0]})
+        tm.assert_frame_equal(result, expected)
+
+
+@td.skip_if_no("numba")
+class TestEWM:
+    @pytest.mark.parametrize(
+        "grouper", [lambda x: x, lambda x: x.groupby("A")], ids=["None", "groupby"]
+    )
+    @pytest.mark.parametrize("method", ["mean", "sum"])
+    def test_invalid_engine(self, grouper, method):
+        df = DataFrame({"A": ["a", "b", "a", "b"], "B": range(4)})
+        with pytest.raises(ValueError, match="engine must be either"):
+            getattr(grouper(df).ewm(com=1.0), method)(engine="foo")
+
+    @pytest.mark.parametrize(
+        "grouper", [lambda x: x, lambda x: x.groupby("A")], ids=["None", "groupby"]
+    )
+    @pytest.mark.parametrize("method", ["mean", "sum"])
+    def test_invalid_engine_kwargs(self, grouper, method):
+        df = DataFrame({"A": ["a", "b", "a", "b"], "B": range(4)})
+        with pytest.raises(ValueError, match="cython engine does not"):
+            getattr(grouper(df).ewm(com=1.0), method)(
+                engine="cython", engine_kwargs={"nopython": True}
+            )
+
+    @pytest.mark.parametrize("grouper", ["None", "groupby"])
+    @pytest.mark.parametrize("method", ["mean", "sum"])
+    def test_cython_vs_numba(
+        self, grouper, method, nogil, parallel, nopython, ignore_na, adjust
+    ):
+        df = DataFrame({"B": range(4)})
+        if grouper == "None":
+            grouper = lambda x: x
+        else:
+            df["A"] = ["a", "b", "a", "b"]
+            grouper = lambda x: x.groupby("A")
+        if method == "sum":
+            adjust = True
+        ewm = grouper(df).ewm(com=1.0, adjust=adjust, ignore_na=ignore_na)
+
+        engine_kwargs = {"nogil": nogil, "parallel": parallel, "nopython": nopython}
+        result = getattr(ewm, method)(engine="numba", engine_kwargs=engine_kwargs)
+        expected = getattr(ewm, method)(engine="cython")
+
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("grouper", ["None", "groupby"])
+    def test_cython_vs_numba_times(self, grouper, nogil, parallel, nopython, ignore_na):
+        # GH 40951
+
+        df = DataFrame({"B": [0, 0, 1, 1, 2, 2]})
+        if grouper == "None":
+            grouper = lambda x: x
+        else:
+            grouper = lambda x: x.groupby("A")
+            df["A"] = ["a", "b", "a", "b", "b", "a"]
+
+        halflife = "23 days"
+        times = to_datetime(
+            [
+                "2020-01-01",
+                "2020-01-01",
+                "2020-01-02",
+                "2020-01-10",
+                "2020-02-23",
+                "2020-01-03",
+            ]
+        )
+        ewm = grouper(df).ewm(
+            halflife=halflife, adjust=True, ignore_na=ignore_na, times=times
+        )
+
+        engine_kwargs = {"nogil": nogil, "parallel": parallel, "nopython": nopython}
+
+        result = ewm.mean(engine="numba", engine_kwargs=engine_kwargs)
+        expected = ewm.mean(engine="cython")
+
+        tm.assert_frame_equal(result, expected)
+
+
+@td.skip_if_no("numba")
+def test_use_global_config():
+    def f(x):
+        return np.mean(x) + 2
+
+    s = Series(range(10))
+    with option_context("compute.use_numba", True):
+        result = s.rolling(2).apply(f, engine=None, raw=True)
+    expected = s.rolling(2).apply(f, engine="numba", raw=True)
+    tm.assert_series_equal(expected, result)
+
+
+@td.skip_if_no("numba")
+def test_invalid_kwargs_nopython():
+    with pytest.raises(NumbaUtilError, match="numba does not support kwargs with"):
+        Series(range(1)).rolling(1).apply(
+            lambda x: x, kwargs={"a": 1}, engine="numba", raw=True
+        )
+
+
+@td.skip_if_no("numba")
+@pytest.mark.slow
+@pytest.mark.filterwarnings("ignore")
+# Filter warnings when parallel=True and the function can't be parallelized by Numba
+class TestTableMethod:
+    def test_table_series_valueerror(self):
+        def f(x):
+            return np.sum(x, axis=0) + 1
+
+        with pytest.raises(
+            ValueError, match="method='table' not applicable for Series objects."
+        ):
+            Series(range(1)).rolling(1, method="table").apply(
+                f, engine="numba", raw=True
+            )
+
+    def test_table_method_rolling_methods(
+        self,
+        axis,
+        nogil,
+        parallel,
+        nopython,
+        arithmetic_numba_supported_operators,
+        step,
+    ):
+        method, kwargs = arithmetic_numba_supported_operators
+
+        engine_kwargs = {"nogil": nogil, "parallel": parallel, "nopython": nopython}
+
+        df = DataFrame(np.eye(3))
+        roll_table = df.rolling(2, method="table", axis=axis, min_periods=0, step=step)
+        if method in ("var", "std"):
+            with pytest.raises(NotImplementedError, match=f"{method} not supported"):
+                getattr(roll_table, method)(
+                    engine_kwargs=engine_kwargs, engine="numba", **kwargs
+                )
+        else:
+            roll_single = df.rolling(
+                2, method="single", axis=axis, min_periods=0, step=step
+            )
+            result = getattr(roll_table, method)(
+                engine_kwargs=engine_kwargs, engine="numba", **kwargs
+            )
+            expected = getattr(roll_single, method)(
+                engine_kwargs=engine_kwargs, engine="numba", **kwargs
+            )
+            tm.assert_frame_equal(result, expected)
+
+    def test_table_method_rolling_apply(self, axis, nogil, parallel, nopython, step):
+        engine_kwargs = {"nogil": nogil, "parallel": parallel, "nopython": nopython}
+
+        def f(x):
+            return np.sum(x, axis=0) + 1
+
+        df = DataFrame(np.eye(3))
+        result = df.rolling(
+            2, method="table", axis=axis, min_periods=0, step=step
+        ).apply(f, raw=True, engine_kwargs=engine_kwargs, engine="numba")
+        expected = df.rolling(
+            2, method="single", axis=axis, min_periods=0, step=step
+        ).apply(f, raw=True, engine_kwargs=engine_kwargs, engine="numba")
+        tm.assert_frame_equal(result, expected)
+
+    def test_table_method_rolling_weighted_mean(self, step):
+        def weighted_mean(x):
+            arr = np.ones((1, x.shape[1]))
+            arr[:, :2] = (x[:, :2] * x[:, 2]).sum(axis=0) / x[:, 2].sum()
+            return arr
+
+        df = DataFrame([[1, 2, 0.6], [2, 3, 0.4], [3, 4, 0.2], [4, 5, 0.7]])
+        result = df.rolling(2, method="table", min_periods=0, step=step).apply(
+            weighted_mean, raw=True, engine="numba"
+        )
+        expected = DataFrame(
+            [
+                [1.0, 2.0, 1.0],
+                [1.8, 2.0, 1.0],
+                [3.333333, 2.333333, 1.0],
+                [1.555556, 7, 1.0],
+            ]
+        )[::step]
+        tm.assert_frame_equal(result, expected)
+
+    def test_table_method_expanding_apply(self, axis, nogil, parallel, nopython):
+        engine_kwargs = {"nogil": nogil, "parallel": parallel, "nopython": nopython}
+
+        def f(x):
+            return np.sum(x, axis=0) + 1
+
+        df = DataFrame(np.eye(3))
+        result = df.expanding(method="table", axis=axis).apply(
+            f, raw=True, engine_kwargs=engine_kwargs, engine="numba"
+        )
+        expected = df.expanding(method="single", axis=axis).apply(
+            f, raw=True, engine_kwargs=engine_kwargs, engine="numba"
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_table_method_expanding_methods(
+        self, axis, nogil, parallel, nopython, arithmetic_numba_supported_operators
+    ):
+        method, kwargs = arithmetic_numba_supported_operators
+
+        engine_kwargs = {"nogil": nogil, "parallel": parallel, "nopython": nopython}
+
+        df = DataFrame(np.eye(3))
+        expand_table = df.expanding(method="table", axis=axis)
+        if method in ("var", "std"):
+            with pytest.raises(NotImplementedError, match=f"{method} not supported"):
+                getattr(expand_table, method)(
+                    engine_kwargs=engine_kwargs, engine="numba", **kwargs
+                )
+        else:
+            expand_single = df.expanding(method="single", axis=axis)
+            result = getattr(expand_table, method)(
+                engine_kwargs=engine_kwargs, engine="numba", **kwargs
+            )
+            expected = getattr(expand_single, method)(
+                engine_kwargs=engine_kwargs, engine="numba", **kwargs
+            )
+            tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("data", [np.eye(3), np.ones((2, 3)), np.ones((3, 2))])
+    @pytest.mark.parametrize("method", ["mean", "sum"])
+    def test_table_method_ewm(self, data, method, axis, nogil, parallel, nopython):
+        engine_kwargs = {"nogil": nogil, "parallel": parallel, "nopython": nopython}
+
+        df = DataFrame(data)
+
+        result = getattr(df.ewm(com=1, method="table", axis=axis), method)(
+            engine_kwargs=engine_kwargs, engine="numba"
+        )
+        expected = getattr(df.ewm(com=1, method="single", axis=axis), method)(
+            engine_kwargs=engine_kwargs, engine="numba"
+        )
+        tm.assert_frame_equal(result, expected)
+
+
+@td.skip_if_no("numba")
+def test_npfunc_no_warnings():
+    df = DataFrame({"col1": [1, 2, 3, 4, 5]})
+    with tm.assert_produces_warning(False):
+        df.col1.rolling(2).apply(np.prod, raw=True, engine="numba")
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/test_online.py b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/test_online.py
new file mode 100644
index 0000000000000000000000000000000000000000..14d3a39107bc4de7ee3d39e3a5968ab381bc1569
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/test_online.py
@@ -0,0 +1,103 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    DataFrame,
+    Series,
+)
+import pandas._testing as tm
+
+pytestmark = pytest.mark.single_cpu
+
+pytest.importorskip("numba")
+
+
+@pytest.mark.filterwarnings("ignore")
+# Filter warnings when parallel=True and the function can't be parallelized by Numba
+class TestEWM:
+    def test_invalid_update(self):
+        df = DataFrame({"a": range(5), "b": range(5)})
+        online_ewm = df.head(2).ewm(0.5).online()
+        with pytest.raises(
+            ValueError,
+            match="Must call mean with update=None first before passing update",
+        ):
+            online_ewm.mean(update=df.head(1))
+
+    @pytest.mark.slow
+    @pytest.mark.parametrize(
+        "obj", [DataFrame({"a": range(5), "b": range(5)}), Series(range(5), name="foo")]
+    )
+    def test_online_vs_non_online_mean(
+        self, obj, nogil, parallel, nopython, adjust, ignore_na
+    ):
+        expected = obj.ewm(0.5, adjust=adjust, ignore_na=ignore_na).mean()
+        engine_kwargs = {"nogil": nogil, "parallel": parallel, "nopython": nopython}
+
+        online_ewm = (
+            obj.head(2)
+            .ewm(0.5, adjust=adjust, ignore_na=ignore_na)
+            .online(engine_kwargs=engine_kwargs)
+        )
+        # Test resetting once
+        for _ in range(2):
+            result = online_ewm.mean()
+            tm.assert_equal(result, expected.head(2))
+
+            result = online_ewm.mean(update=obj.tail(3))
+            tm.assert_equal(result, expected.tail(3))
+
+            online_ewm.reset()
+
+    @pytest.mark.xfail(raises=NotImplementedError)
+    @pytest.mark.parametrize(
+        "obj", [DataFrame({"a": range(5), "b": range(5)}), Series(range(5), name="foo")]
+    )
+    def test_update_times_mean(
+        self, obj, nogil, parallel, nopython, adjust, ignore_na, halflife_with_times
+    ):
+        times = Series(
+            np.array(
+                ["2020-01-01", "2020-01-05", "2020-01-07", "2020-01-17", "2020-01-21"],
+                dtype="datetime64[ns]",
+            )
+        )
+        expected = obj.ewm(
+            0.5,
+            adjust=adjust,
+            ignore_na=ignore_na,
+            times=times,
+            halflife=halflife_with_times,
+        ).mean()
+
+        engine_kwargs = {"nogil": nogil, "parallel": parallel, "nopython": nopython}
+        online_ewm = (
+            obj.head(2)
+            .ewm(
+                0.5,
+                adjust=adjust,
+                ignore_na=ignore_na,
+                times=times.head(2),
+                halflife=halflife_with_times,
+            )
+            .online(engine_kwargs=engine_kwargs)
+        )
+        # Test resetting once
+        for _ in range(2):
+            result = online_ewm.mean()
+            tm.assert_equal(result, expected.head(2))
+
+            result = online_ewm.mean(update=obj.tail(3), update_times=times.tail(3))
+            tm.assert_equal(result, expected.tail(3))
+
+            online_ewm.reset()
+
+    @pytest.mark.parametrize("method", ["aggregate", "std", "corr", "cov", "var"])
+    def test_ewm_notimplementederror_raises(self, method):
+        ser = Series(range(10))
+        kwargs = {}
+        if method == "aggregate":
+            kwargs["func"] = lambda x: x
+
+        with pytest.raises(NotImplementedError, match=".* is not implemented."):
+            getattr(ser.ewm(1).online(), method)(**kwargs)
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/test_pairwise.py b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/test_pairwise.py
new file mode 100644
index 0000000000000000000000000000000000000000..3ceb58756bac6cbc5f3b1862523d4185c1ad8b47
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/test_pairwise.py
@@ -0,0 +1,445 @@
+import numpy as np
+import pytest
+
+from pandas.compat import IS64
+
+from pandas import (
+    DataFrame,
+    Index,
+    MultiIndex,
+    Series,
+    date_range,
+)
+import pandas._testing as tm
+from pandas.core.algorithms import safe_sort
+
+
+@pytest.fixture(
+    params=[
+        DataFrame([[2, 4], [1, 2], [5, 2], [8, 1]], columns=[1, 0]),
+        DataFrame([[2, 4], [1, 2], [5, 2], [8, 1]], columns=[1, 1]),
+        DataFrame([[2, 4], [1, 2], [5, 2], [8, 1]], columns=["C", "C"]),
+        DataFrame([[2, 4], [1, 2], [5, 2], [8, 1]], columns=[1.0, 0]),
+        DataFrame([[2, 4], [1, 2], [5, 2], [8, 1]], columns=[0.0, 1]),
+        DataFrame([[2, 4], [1, 2], [5, 2], [8, 1]], columns=["C", 1]),
+        DataFrame([[2.0, 4.0], [1.0, 2.0], [5.0, 2.0], [8.0, 1.0]], columns=[1, 0.0]),
+        DataFrame([[2, 4.0], [1, 2.0], [5, 2.0], [8, 1.0]], columns=[0, 1.0]),
+        DataFrame([[2, 4], [1, 2], [5, 2], [8, 1.0]], columns=[1.0, "X"]),
+    ]
+)
+def pairwise_frames(request):
+    """Pairwise frames test_pairwise"""
+    return request.param
+
+
+@pytest.fixture
+def pairwise_target_frame():
+    """Pairwise target frame for test_pairwise"""
+    return DataFrame([[2, 4], [1, 2], [5, 2], [8, 1]], columns=[0, 1])
+
+
+@pytest.fixture
+def pairwise_other_frame():
+    """Pairwise other frame for test_pairwise"""
+    return DataFrame(
+        [[None, 1, 1], [None, 1, 2], [None, 3, 2], [None, 8, 1]],
+        columns=["Y", "Z", "X"],
+    )
+
+
+def test_rolling_cov(series):
+    A = series
+    B = A + np.random.default_rng(2).standard_normal(len(A))
+
+    result = A.rolling(window=50, min_periods=25).cov(B)
+    tm.assert_almost_equal(result.iloc[-1], np.cov(A[-50:], B[-50:])[0, 1])
+
+
+def test_rolling_corr(series):
+    A = series
+    B = A + np.random.default_rng(2).standard_normal(len(A))
+
+    result = A.rolling(window=50, min_periods=25).corr(B)
+    tm.assert_almost_equal(result.iloc[-1], np.corrcoef(A[-50:], B[-50:])[0, 1])
+
+
+def test_rolling_corr_bias_correction():
+    # test for correct bias correction
+    a = Series(
+        np.arange(20, dtype=np.float64), index=date_range("2020-01-01", periods=20)
+    )
+    b = a.copy()
+    a[:5] = np.nan
+    b[:10] = np.nan
+
+    result = a.rolling(window=len(a), min_periods=1).corr(b)
+    tm.assert_almost_equal(result.iloc[-1], a.corr(b))
+
+
+@pytest.mark.parametrize("func", ["cov", "corr"])
+def test_rolling_pairwise_cov_corr(func, frame):
+    result = getattr(frame.rolling(window=10, min_periods=5), func)()
+    result = result.loc[(slice(None), 1), 5]
+    result.index = result.index.droplevel(1)
+    expected = getattr(frame[1].rolling(window=10, min_periods=5), func)(frame[5])
+    tm.assert_series_equal(result, expected, check_names=False)
+
+
+@pytest.mark.parametrize("method", ["corr", "cov"])
+def test_flex_binary_frame(method, frame):
+    series = frame[1]
+
+    res = getattr(series.rolling(window=10), method)(frame)
+    res2 = getattr(frame.rolling(window=10), method)(series)
+    exp = frame.apply(lambda x: getattr(series.rolling(window=10), method)(x))
+
+    tm.assert_frame_equal(res, exp)
+    tm.assert_frame_equal(res2, exp)
+
+    frame2 = frame.copy()
+    frame2 = DataFrame(
+        np.random.default_rng(2).standard_normal(frame2.shape),
+        index=frame2.index,
+        columns=frame2.columns,
+    )
+
+    res3 = getattr(frame.rolling(window=10), method)(frame2)
+    exp = DataFrame(
+        {k: getattr(frame[k].rolling(window=10), method)(frame2[k]) for k in frame}
+    )
+    tm.assert_frame_equal(res3, exp)
+
+
+@pytest.mark.parametrize("window", range(7))
+def test_rolling_corr_with_zero_variance(window):
+    # GH 18430
+    s = Series(np.zeros(20))
+    other = Series(np.arange(20))
+
+    assert s.rolling(window=window).corr(other=other).isna().all()
+
+
+def test_corr_sanity():
+    # GH 3155
+    df = DataFrame(
+        np.array(
+            [
+                [0.87024726, 0.18505595],
+                [0.64355431, 0.3091617],
+                [0.92372966, 0.50552513],
+                [0.00203756, 0.04520709],
+                [0.84780328, 0.33394331],
+                [0.78369152, 0.63919667],
+            ]
+        )
+    )
+
+    res = df[0].rolling(5, center=True).corr(df[1])
+    assert all(np.abs(np.nan_to_num(x)) <= 1 for x in res)
+
+    df = DataFrame(np.random.default_rng(2).random((30, 2)))
+    res = df[0].rolling(5, center=True).corr(df[1])
+    assert all(np.abs(np.nan_to_num(x)) <= 1 for x in res)
+
+
+def test_rolling_cov_diff_length():
+    # GH 7512
+    s1 = Series([1, 2, 3], index=[0, 1, 2])
+    s2 = Series([1, 3], index=[0, 2])
+    result = s1.rolling(window=3, min_periods=2).cov(s2)
+    expected = Series([None, None, 2.0])
+    tm.assert_series_equal(result, expected)
+
+    s2a = Series([1, None, 3], index=[0, 1, 2])
+    result = s1.rolling(window=3, min_periods=2).cov(s2a)
+    tm.assert_series_equal(result, expected)
+
+
+def test_rolling_corr_diff_length():
+    # GH 7512
+    s1 = Series([1, 2, 3], index=[0, 1, 2])
+    s2 = Series([1, 3], index=[0, 2])
+    result = s1.rolling(window=3, min_periods=2).corr(s2)
+    expected = Series([None, None, 1.0])
+    tm.assert_series_equal(result, expected)
+
+    s2a = Series([1, None, 3], index=[0, 1, 2])
+    result = s1.rolling(window=3, min_periods=2).corr(s2a)
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "f",
+    [
+        lambda x: (x.rolling(window=10, min_periods=5).cov(x, pairwise=True)),
+        lambda x: (x.rolling(window=10, min_periods=5).corr(x, pairwise=True)),
+    ],
+)
+def test_rolling_functions_window_non_shrinkage_binary(f):
+    # corr/cov return a MI DataFrame
+    df = DataFrame(
+        [[1, 5], [3, 2], [3, 9], [-1, 0]],
+        columns=Index(["A", "B"], name="foo"),
+        index=Index(range(4), name="bar"),
+    )
+    df_expected = DataFrame(
+        columns=Index(["A", "B"], name="foo"),
+        index=MultiIndex.from_product([df.index, df.columns], names=["bar", "foo"]),
+        dtype="float64",
+    )
+    df_result = f(df)
+    tm.assert_frame_equal(df_result, df_expected)
+
+
+@pytest.mark.parametrize(
+    "f",
+    [
+        lambda x: (x.rolling(window=10, min_periods=5).cov(x, pairwise=True)),
+        lambda x: (x.rolling(window=10, min_periods=5).corr(x, pairwise=True)),
+    ],
+)
+def test_moment_functions_zero_length_pairwise(f):
+    df1 = DataFrame()
+    df2 = DataFrame(columns=Index(["a"], name="foo"), index=Index([], name="bar"))
+    df2["a"] = df2["a"].astype("float64")
+
+    df1_expected = DataFrame(index=MultiIndex.from_product([df1.index, df1.columns]))
+    df2_expected = DataFrame(
+        index=MultiIndex.from_product([df2.index, df2.columns], names=["bar", "foo"]),
+        columns=Index(["a"], name="foo"),
+        dtype="float64",
+    )
+
+    df1_result = f(df1)
+    tm.assert_frame_equal(df1_result, df1_expected)
+
+    df2_result = f(df2)
+    tm.assert_frame_equal(df2_result, df2_expected)
+
+
+class TestPairwise:
+    # GH 7738
+    @pytest.mark.parametrize("f", [lambda x: x.cov(), lambda x: x.corr()])
+    def test_no_flex(self, pairwise_frames, pairwise_target_frame, f):
+        # DataFrame methods (which do not call flex_binary_moment())
+
+        result = f(pairwise_frames)
+        tm.assert_index_equal(result.index, pairwise_frames.columns)
+        tm.assert_index_equal(result.columns, pairwise_frames.columns)
+        expected = f(pairwise_target_frame)
+        # since we have sorted the results
+        # we can only compare non-nans
+        result = result.dropna().values
+        expected = expected.dropna().values
+
+        tm.assert_numpy_array_equal(result, expected, check_dtype=False)
+
+    @pytest.mark.parametrize(
+        "f",
+        [
+            lambda x: x.expanding().cov(pairwise=True),
+            lambda x: x.expanding().corr(pairwise=True),
+            lambda x: x.rolling(window=3).cov(pairwise=True),
+            lambda x: x.rolling(window=3).corr(pairwise=True),
+            lambda x: x.ewm(com=3).cov(pairwise=True),
+            lambda x: x.ewm(com=3).corr(pairwise=True),
+        ],
+    )
+    def test_pairwise_with_self(self, pairwise_frames, pairwise_target_frame, f):
+        # DataFrame with itself, pairwise=True
+        # note that we may construct the 1st level of the MI
+        # in a non-monotonic way, so compare accordingly
+        result = f(pairwise_frames)
+        tm.assert_index_equal(
+            result.index.levels[0], pairwise_frames.index, check_names=False
+        )
+        tm.assert_index_equal(
+            safe_sort(result.index.levels[1]),
+            safe_sort(pairwise_frames.columns.unique()),
+        )
+        tm.assert_index_equal(result.columns, pairwise_frames.columns)
+        expected = f(pairwise_target_frame)
+        # since we have sorted the results
+        # we can only compare non-nans
+        result = result.dropna().values
+        expected = expected.dropna().values
+
+        tm.assert_numpy_array_equal(result, expected, check_dtype=False)
+
+    @pytest.mark.parametrize(
+        "f",
+        [
+            lambda x: x.expanding().cov(pairwise=False),
+            lambda x: x.expanding().corr(pairwise=False),
+            lambda x: x.rolling(window=3).cov(pairwise=False),
+            lambda x: x.rolling(window=3).corr(pairwise=False),
+            lambda x: x.ewm(com=3).cov(pairwise=False),
+            lambda x: x.ewm(com=3).corr(pairwise=False),
+        ],
+    )
+    def test_no_pairwise_with_self(self, pairwise_frames, pairwise_target_frame, f):
+        # DataFrame with itself, pairwise=False
+        result = f(pairwise_frames)
+        tm.assert_index_equal(result.index, pairwise_frames.index)
+        tm.assert_index_equal(result.columns, pairwise_frames.columns)
+        expected = f(pairwise_target_frame)
+        # since we have sorted the results
+        # we can only compare non-nans
+        result = result.dropna().values
+        expected = expected.dropna().values
+
+        tm.assert_numpy_array_equal(result, expected, check_dtype=False)
+
+    @pytest.mark.parametrize(
+        "f",
+        [
+            lambda x, y: x.expanding().cov(y, pairwise=True),
+            lambda x, y: x.expanding().corr(y, pairwise=True),
+            lambda x, y: x.rolling(window=3).cov(y, pairwise=True),
+            # TODO: We're missing a flag somewhere in meson
+            pytest.param(
+                lambda x, y: x.rolling(window=3).corr(y, pairwise=True),
+                marks=pytest.mark.xfail(
+                    not IS64, reason="Precision issues on 32 bit", strict=False
+                ),
+            ),
+            lambda x, y: x.ewm(com=3).cov(y, pairwise=True),
+            lambda x, y: x.ewm(com=3).corr(y, pairwise=True),
+        ],
+    )
+    def test_pairwise_with_other(
+        self, pairwise_frames, pairwise_target_frame, pairwise_other_frame, f
+    ):
+        # DataFrame with another DataFrame, pairwise=True
+        result = f(pairwise_frames, pairwise_other_frame)
+        tm.assert_index_equal(
+            result.index.levels[0], pairwise_frames.index, check_names=False
+        )
+        tm.assert_index_equal(
+            safe_sort(result.index.levels[1]),
+            safe_sort(pairwise_other_frame.columns.unique()),
+        )
+        expected = f(pairwise_target_frame, pairwise_other_frame)
+        # since we have sorted the results
+        # we can only compare non-nans
+        result = result.dropna().values
+        expected = expected.dropna().values
+
+        tm.assert_numpy_array_equal(result, expected, check_dtype=False)
+
+    @pytest.mark.filterwarnings("ignore:RuntimeWarning")
+    @pytest.mark.parametrize(
+        "f",
+        [
+            lambda x, y: x.expanding().cov(y, pairwise=False),
+            lambda x, y: x.expanding().corr(y, pairwise=False),
+            lambda x, y: x.rolling(window=3).cov(y, pairwise=False),
+            lambda x, y: x.rolling(window=3).corr(y, pairwise=False),
+            lambda x, y: x.ewm(com=3).cov(y, pairwise=False),
+            lambda x, y: x.ewm(com=3).corr(y, pairwise=False),
+        ],
+    )
+    def test_no_pairwise_with_other(self, pairwise_frames, pairwise_other_frame, f):
+        # DataFrame with another DataFrame, pairwise=False
+        result = (
+            f(pairwise_frames, pairwise_other_frame)
+            if pairwise_frames.columns.is_unique
+            else None
+        )
+        if result is not None:
+            # we can have int and str columns
+            expected_index = pairwise_frames.index.union(pairwise_other_frame.index)
+            expected_columns = pairwise_frames.columns.union(
+                pairwise_other_frame.columns
+            )
+            tm.assert_index_equal(result.index, expected_index)
+            tm.assert_index_equal(result.columns, expected_columns)
+        else:
+            with pytest.raises(ValueError, match="'arg1' columns are not unique"):
+                f(pairwise_frames, pairwise_other_frame)
+            with pytest.raises(ValueError, match="'arg2' columns are not unique"):
+                f(pairwise_other_frame, pairwise_frames)
+
+    @pytest.mark.parametrize(
+        "f",
+        [
+            lambda x, y: x.expanding().cov(y),
+            lambda x, y: x.expanding().corr(y),
+            lambda x, y: x.rolling(window=3).cov(y),
+            lambda x, y: x.rolling(window=3).corr(y),
+            lambda x, y: x.ewm(com=3).cov(y),
+            lambda x, y: x.ewm(com=3).corr(y),
+        ],
+    )
+    def test_pairwise_with_series(self, pairwise_frames, pairwise_target_frame, f):
+        # DataFrame with a Series
+        result = f(pairwise_frames, Series([1, 1, 3, 8]))
+        tm.assert_index_equal(result.index, pairwise_frames.index)
+        tm.assert_index_equal(result.columns, pairwise_frames.columns)
+        expected = f(pairwise_target_frame, Series([1, 1, 3, 8]))
+        # since we have sorted the results
+        # we can only compare non-nans
+        result = result.dropna().values
+        expected = expected.dropna().values
+        tm.assert_numpy_array_equal(result, expected, check_dtype=False)
+
+        result = f(Series([1, 1, 3, 8]), pairwise_frames)
+        tm.assert_index_equal(result.index, pairwise_frames.index)
+        tm.assert_index_equal(result.columns, pairwise_frames.columns)
+        expected = f(Series([1, 1, 3, 8]), pairwise_target_frame)
+        # since we have sorted the results
+        # we can only compare non-nans
+        result = result.dropna().values
+        expected = expected.dropna().values
+        tm.assert_numpy_array_equal(result, expected, check_dtype=False)
+
+    def test_corr_freq_memory_error(self):
+        # GH 31789
+        s = Series(range(5), index=date_range("2020", periods=5))
+        result = s.rolling("12h").corr(s)
+        expected = Series([np.nan] * 5, index=date_range("2020", periods=5))
+        tm.assert_series_equal(result, expected)
+
+    def test_cov_mulittindex(self):
+        # GH 34440
+
+        columns = MultiIndex.from_product([list("ab"), list("xy"), list("AB")])
+        index = range(3)
+        df = DataFrame(np.arange(24).reshape(3, 8), index=index, columns=columns)
+
+        result = df.ewm(alpha=0.1).cov()
+
+        index = MultiIndex.from_product([range(3), list("ab"), list("xy"), list("AB")])
+        columns = MultiIndex.from_product([list("ab"), list("xy"), list("AB")])
+        expected = DataFrame(
+            np.vstack(
+                (
+                    np.full((8, 8), np.nan),
+                    np.full((8, 8), 32.000000),
+                    np.full((8, 8), 63.881919),
+                )
+            ),
+            index=index,
+            columns=columns,
+        )
+
+        tm.assert_frame_equal(result, expected)
+
+    def test_multindex_columns_pairwise_func(self):
+        # GH 21157
+        columns = MultiIndex.from_arrays([["M", "N"], ["P", "Q"]], names=["a", "b"])
+        df = DataFrame(np.ones((5, 2)), columns=columns)
+        result = df.rolling(3).corr()
+        expected = DataFrame(
+            np.nan,
+            index=MultiIndex.from_arrays(
+                [
+                    np.repeat(np.arange(5, dtype=np.int64), 2),
+                    ["M", "N"] * 5,
+                    ["P", "Q"] * 5,
+                ],
+                names=[None, "a", "b"],
+            ),
+            columns=columns,
+        )
+        tm.assert_frame_equal(result, expected)
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/test_rolling.py b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/test_rolling.py
new file mode 100644
index 0000000000000000000000000000000000000000..f353a7fa2f0fe5f0480c31b40a2907943ff5a5c6
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/test_rolling.py
@@ -0,0 +1,1979 @@
+from datetime import (
+    datetime,
+    timedelta,
+)
+
+import numpy as np
+import pytest
+
+from pandas.compat import (
+    IS64,
+    is_platform_arm,
+    is_platform_power,
+)
+
+from pandas import (
+    DataFrame,
+    DatetimeIndex,
+    MultiIndex,
+    Series,
+    Timedelta,
+    Timestamp,
+    date_range,
+    period_range,
+    to_datetime,
+    to_timedelta,
+)
+import pandas._testing as tm
+from pandas.api.indexers import BaseIndexer
+from pandas.core.indexers.objects import VariableOffsetWindowIndexer
+
+from pandas.tseries.offsets import BusinessDay
+
+
+def test_doc_string():
+    df = DataFrame({"B": [0, 1, 2, np.nan, 4]})
+    df
+    df.rolling(2).sum()
+    df.rolling(2, min_periods=1).sum()
+
+
+def test_constructor(frame_or_series):
+    # GH 12669
+
+    c = frame_or_series(range(5)).rolling
+
+    # valid
+    c(0)
+    c(window=2)
+    c(window=2, min_periods=1)
+    c(window=2, min_periods=1, center=True)
+    c(window=2, min_periods=1, center=False)
+
+    # GH 13383
+
+    msg = "window must be an integer 0 or greater"
+
+    with pytest.raises(ValueError, match=msg):
+        c(-1)
+
+
+@pytest.mark.parametrize("w", [2.0, "foo", np.array([2])])
+def test_invalid_constructor(frame_or_series, w):
+    # not valid
+
+    c = frame_or_series(range(5)).rolling
+
+    msg = "|".join(
+        [
+            "window must be an integer",
+            "passed window foo is not compatible with a datetimelike index",
+        ]
+    )
+    with pytest.raises(ValueError, match=msg):
+        c(window=w)
+
+    msg = "min_periods must be an integer"
+    with pytest.raises(ValueError, match=msg):
+        c(window=2, min_periods=w)
+
+    msg = "center must be a boolean"
+    with pytest.raises(ValueError, match=msg):
+        c(window=2, min_periods=1, center=w)
+
+
+@pytest.mark.parametrize(
+    "window",
+    [
+        timedelta(days=3),
+        Timedelta(days=3),
+        "3D",
+        VariableOffsetWindowIndexer(
+            index=date_range("2015-12-25", periods=5), offset=BusinessDay(1)
+        ),
+    ],
+)
+def test_freq_window_not_implemented(window):
+    # GH 15354
+    df = DataFrame(
+        np.arange(10),
+        index=date_range("2015-12-24", periods=10, freq="D"),
+    )
+    with pytest.raises(
+        NotImplementedError, match="^step (not implemented|is not supported)"
+    ):
+        df.rolling(window, step=3).sum()
+
+
+@pytest.mark.parametrize("agg", ["cov", "corr"])
+def test_step_not_implemented_for_cov_corr(agg):
+    # GH 15354
+    roll = DataFrame(range(2)).rolling(1, step=2)
+    with pytest.raises(NotImplementedError, match="step not implemented"):
+        getattr(roll, agg)()
+
+
+@pytest.mark.parametrize("window", [timedelta(days=3), Timedelta(days=3)])
+def test_constructor_with_timedelta_window(window):
+    # GH 15440
+    n = 10
+    df = DataFrame(
+        {"value": np.arange(n)},
+        index=date_range("2015-12-24", periods=n, freq="D"),
+    )
+    expected_data = np.append([0.0, 1.0], np.arange(3.0, 27.0, 3))
+
+    result = df.rolling(window=window).sum()
+    expected = DataFrame(
+        {"value": expected_data},
+        index=date_range("2015-12-24", periods=n, freq="D"),
+    )
+    tm.assert_frame_equal(result, expected)
+    expected = df.rolling("3D").sum()
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("window", [timedelta(days=3), Timedelta(days=3), "3D"])
+def test_constructor_timedelta_window_and_minperiods(window, raw):
+    # GH 15305
+    n = 10
+    df = DataFrame(
+        {"value": np.arange(n)},
+        index=date_range("2017-08-08", periods=n, freq="D"),
+    )
+    expected = DataFrame(
+        {"value": np.append([np.nan, 1.0], np.arange(3.0, 27.0, 3))},
+        index=date_range("2017-08-08", periods=n, freq="D"),
+    )
+    result_roll_sum = df.rolling(window=window, min_periods=2).sum()
+    result_roll_generic = df.rolling(window=window, min_periods=2).apply(sum, raw=raw)
+    tm.assert_frame_equal(result_roll_sum, expected)
+    tm.assert_frame_equal(result_roll_generic, expected)
+
+
+def test_closed_fixed(closed, arithmetic_win_operators):
+    # GH 34315
+    func_name = arithmetic_win_operators
+    df_fixed = DataFrame({"A": [0, 1, 2, 3, 4]})
+    df_time = DataFrame({"A": [0, 1, 2, 3, 4]}, index=date_range("2020", periods=5))
+
+    result = getattr(
+        df_fixed.rolling(2, closed=closed, min_periods=1),
+        func_name,
+    )()
+    expected = getattr(
+        df_time.rolling("2D", closed=closed, min_periods=1),
+        func_name,
+    )().reset_index(drop=True)
+
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "closed, window_selections",
+    [
+        (
+            "both",
+            [
+                [True, True, False, False, False],
+                [True, True, True, False, False],
+                [False, True, True, True, False],
+                [False, False, True, True, True],
+                [False, False, False, True, True],
+            ],
+        ),
+        (
+            "left",
+            [
+                [True, False, False, False, False],
+                [True, True, False, False, False],
+                [False, True, True, False, False],
+                [False, False, True, True, False],
+                [False, False, False, True, True],
+            ],
+        ),
+        (
+            "right",
+            [
+                [True, True, False, False, False],
+                [False, True, True, False, False],
+                [False, False, True, True, False],
+                [False, False, False, True, True],
+                [False, False, False, False, True],
+            ],
+        ),
+        (
+            "neither",
+            [
+                [True, False, False, False, False],
+                [False, True, False, False, False],
+                [False, False, True, False, False],
+                [False, False, False, True, False],
+                [False, False, False, False, True],
+            ],
+        ),
+    ],
+)
+def test_datetimelike_centered_selections(
+    closed, window_selections, arithmetic_win_operators
+):
+    # GH 34315
+    func_name = arithmetic_win_operators
+    df_time = DataFrame(
+        {"A": [0.0, 1.0, 2.0, 3.0, 4.0]}, index=date_range("2020", periods=5)
+    )
+
+    expected = DataFrame(
+        {"A": [getattr(df_time["A"].iloc[s], func_name)() for s in window_selections]},
+        index=date_range("2020", periods=5),
+    )
+
+    if func_name == "sem":
+        kwargs = {"ddof": 0}
+    else:
+        kwargs = {}
+
+    result = getattr(
+        df_time.rolling("2D", closed=closed, min_periods=1, center=True),
+        func_name,
+    )(**kwargs)
+
+    tm.assert_frame_equal(result, expected, check_dtype=False)
+
+
+@pytest.mark.parametrize(
+    "window,closed,expected",
+    [
+        ("3s", "right", [3.0, 3.0, 3.0]),
+        ("3s", "both", [3.0, 3.0, 3.0]),
+        ("3s", "left", [3.0, 3.0, 3.0]),
+        ("3s", "neither", [3.0, 3.0, 3.0]),
+        ("2s", "right", [3.0, 2.0, 2.0]),
+        ("2s", "both", [3.0, 3.0, 3.0]),
+        ("2s", "left", [1.0, 3.0, 3.0]),
+        ("2s", "neither", [1.0, 2.0, 2.0]),
+    ],
+)
+def test_datetimelike_centered_offset_covers_all(
+    window, closed, expected, frame_or_series
+):
+    # GH 42753
+
+    index = [
+        Timestamp("20130101 09:00:01"),
+        Timestamp("20130101 09:00:02"),
+        Timestamp("20130101 09:00:02"),
+    ]
+    df = frame_or_series([1, 1, 1], index=index)
+
+    result = df.rolling(window, closed=closed, center=True).sum()
+    expected = frame_or_series(expected, index=index)
+    tm.assert_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "window,closed,expected",
+    [
+        ("2D", "right", [4, 4, 4, 4, 4, 4, 2, 2]),
+        ("2D", "left", [2, 2, 4, 4, 4, 4, 4, 4]),
+        ("2D", "both", [4, 4, 6, 6, 6, 6, 4, 4]),
+        ("2D", "neither", [2, 2, 2, 2, 2, 2, 2, 2]),
+    ],
+)
+def test_datetimelike_nonunique_index_centering(
+    window, closed, expected, frame_or_series
+):
+    index = DatetimeIndex(
+        [
+            "2020-01-01",
+            "2020-01-01",
+            "2020-01-02",
+            "2020-01-02",
+            "2020-01-03",
+            "2020-01-03",
+            "2020-01-04",
+            "2020-01-04",
+        ]
+    )
+
+    df = frame_or_series([1] * 8, index=index, dtype=float)
+    expected = frame_or_series(expected, index=index, dtype=float)
+
+    result = df.rolling(window, center=True, closed=closed).sum()
+
+    tm.assert_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "closed,expected",
+    [
+        ("left", [np.nan, np.nan, 1, 1, 1, 10, 14, 14, 18, 21]),
+        ("neither", [np.nan, np.nan, 1, 1, 1, 9, 5, 5, 13, 8]),
+        ("right", [0, 1, 3, 6, 10, 14, 11, 18, 21, 17]),
+        ("both", [0, 1, 3, 6, 10, 15, 20, 27, 26, 30]),
+    ],
+)
+def test_variable_window_nonunique(closed, expected, frame_or_series):
+    # GH 20712
+    index = DatetimeIndex(
+        [
+            "2011-01-01",
+            "2011-01-01",
+            "2011-01-02",
+            "2011-01-02",
+            "2011-01-02",
+            "2011-01-03",
+            "2011-01-04",
+            "2011-01-04",
+            "2011-01-05",
+            "2011-01-06",
+        ]
+    )
+
+    df = frame_or_series(range(10), index=index, dtype=float)
+    expected = frame_or_series(expected, index=index, dtype=float)
+
+    result = df.rolling("2D", closed=closed).sum()
+
+    tm.assert_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "closed,expected",
+    [
+        ("left", [np.nan, np.nan, 1, 1, 1, 10, 15, 15, 18, 21]),
+        ("neither", [np.nan, np.nan, 1, 1, 1, 10, 15, 15, 13, 8]),
+        ("right", [0, 1, 3, 6, 10, 15, 21, 28, 21, 17]),
+        ("both", [0, 1, 3, 6, 10, 15, 21, 28, 26, 30]),
+    ],
+)
+def test_variable_offset_window_nonunique(closed, expected, frame_or_series):
+    # GH 20712
+    index = DatetimeIndex(
+        [
+            "2011-01-01",
+            "2011-01-01",
+            "2011-01-02",
+            "2011-01-02",
+            "2011-01-02",
+            "2011-01-03",
+            "2011-01-04",
+            "2011-01-04",
+            "2011-01-05",
+            "2011-01-06",
+        ]
+    )
+
+    df = frame_or_series(range(10), index=index, dtype=float)
+    expected = frame_or_series(expected, index=index, dtype=float)
+
+    offset = BusinessDay(2)
+    indexer = VariableOffsetWindowIndexer(index=index, offset=offset)
+    result = df.rolling(indexer, closed=closed, min_periods=1).sum()
+
+    tm.assert_equal(result, expected)
+
+
+def test_even_number_window_alignment():
+    # see discussion in GH 38780
+    s = Series(range(3), index=date_range(start="2020-01-01", freq="D", periods=3))
+
+    # behavior of index- and datetime-based windows differs here!
+    # s.rolling(window=2, min_periods=1, center=True).mean()
+
+    result = s.rolling(window="2D", min_periods=1, center=True).mean()
+
+    expected = Series([0.5, 1.5, 2], index=s.index)
+
+    tm.assert_series_equal(result, expected)
+
+
+def test_closed_fixed_binary_col(center, step):
+    # GH 34315
+    data = [0, 1, 1, 0, 0, 1, 0, 1]
+    df = DataFrame(
+        {"binary_col": data},
+        index=date_range(start="2020-01-01", freq="min", periods=len(data)),
+    )
+
+    if center:
+        expected_data = [2 / 3, 0.5, 0.4, 0.5, 0.428571, 0.5, 0.571429, 0.5]
+    else:
+        expected_data = [np.nan, 0, 0.5, 2 / 3, 0.5, 0.4, 0.5, 0.428571]
+
+    expected = DataFrame(
+        expected_data,
+        columns=["binary_col"],
+        index=date_range(start="2020-01-01", freq="min", periods=len(expected_data)),
+    )[::step]
+
+    rolling = df.rolling(
+        window=len(df), closed="left", min_periods=1, center=center, step=step
+    )
+    result = rolling.mean()
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("closed", ["neither", "left"])
+def test_closed_empty(closed, arithmetic_win_operators):
+    # GH 26005
+    func_name = arithmetic_win_operators
+    ser = Series(data=np.arange(5), index=date_range("2000", periods=5, freq="2D"))
+    roll = ser.rolling("1D", closed=closed)
+
+    result = getattr(roll, func_name)()
+    expected = Series([np.nan] * 5, index=ser.index)
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize("func", ["min", "max"])
+def test_closed_one_entry(func):
+    # GH24718
+    ser = Series(data=[2], index=date_range("2000", periods=1))
+    result = getattr(ser.rolling("10D", closed="left"), func)()
+    tm.assert_series_equal(result, Series([np.nan], index=ser.index))
+
+
+@pytest.mark.parametrize("func", ["min", "max"])
+def test_closed_one_entry_groupby(func):
+    # GH24718
+    ser = DataFrame(
+        data={"A": [1, 1, 2], "B": [3, 2, 1]},
+        index=date_range("2000", periods=3),
+    )
+    result = getattr(
+        ser.groupby("A", sort=False)["B"].rolling("10D", closed="left"), func
+    )()
+    exp_idx = MultiIndex.from_arrays(arrays=[[1, 1, 2], ser.index], names=("A", None))
+    expected = Series(data=[np.nan, 3, np.nan], index=exp_idx, name="B")
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize("input_dtype", ["int", "float"])
+@pytest.mark.parametrize(
+    "func,closed,expected",
+    [
+        ("min", "right", [0.0, 0, 0, 1, 2, 3, 4, 5, 6, 7]),
+        ("min", "both", [0.0, 0, 0, 0, 1, 2, 3, 4, 5, 6]),
+        ("min", "neither", [np.nan, 0, 0, 1, 2, 3, 4, 5, 6, 7]),
+        ("min", "left", [np.nan, 0, 0, 0, 1, 2, 3, 4, 5, 6]),
+        ("max", "right", [0.0, 1, 2, 3, 4, 5, 6, 7, 8, 9]),
+        ("max", "both", [0.0, 1, 2, 3, 4, 5, 6, 7, 8, 9]),
+        ("max", "neither", [np.nan, 0, 1, 2, 3, 4, 5, 6, 7, 8]),
+        ("max", "left", [np.nan, 0, 1, 2, 3, 4, 5, 6, 7, 8]),
+    ],
+)
+def test_closed_min_max_datetime(input_dtype, func, closed, expected):
+    # see gh-21704
+    ser = Series(
+        data=np.arange(10).astype(input_dtype),
+        index=date_range("2000", periods=10),
+    )
+
+    result = getattr(ser.rolling("3D", closed=closed), func)()
+    expected = Series(expected, index=ser.index)
+    tm.assert_series_equal(result, expected)
+
+
+def test_closed_uneven():
+    # see gh-21704
+    ser = Series(data=np.arange(10), index=date_range("2000", periods=10))
+
+    # uneven
+    ser = ser.drop(index=ser.index[[1, 5]])
+    result = ser.rolling("3D", closed="left").min()
+    expected = Series([np.nan, 0, 0, 2, 3, 4, 6, 6], index=ser.index)
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "func,closed,expected",
+    [
+        ("min", "right", [np.nan, 0, 0, 1, 2, 3, 4, 5, np.nan, np.nan]),
+        ("min", "both", [np.nan, 0, 0, 0, 1, 2, 3, 4, 5, np.nan]),
+        ("min", "neither", [np.nan, np.nan, 0, 1, 2, 3, 4, 5, np.nan, np.nan]),
+        ("min", "left", [np.nan, np.nan, 0, 0, 1, 2, 3, 4, 5, np.nan]),
+        ("max", "right", [np.nan, 1, 2, 3, 4, 5, 6, 6, np.nan, np.nan]),
+        ("max", "both", [np.nan, 1, 2, 3, 4, 5, 6, 6, 6, np.nan]),
+        ("max", "neither", [np.nan, np.nan, 1, 2, 3, 4, 5, 6, np.nan, np.nan]),
+        ("max", "left", [np.nan, np.nan, 1, 2, 3, 4, 5, 6, 6, np.nan]),
+    ],
+)
+def test_closed_min_max_minp(func, closed, expected):
+    # see gh-21704
+    ser = Series(data=np.arange(10), index=date_range("2000", periods=10))
+    # Explicit cast to float to avoid implicit cast when setting nan
+    ser = ser.astype("float")
+    ser[ser.index[-3:]] = np.nan
+    result = getattr(ser.rolling("3D", min_periods=2, closed=closed), func)()
+    expected = Series(expected, index=ser.index)
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "closed,expected",
+    [
+        ("right", [0, 0.5, 1, 2, 3, 4, 5, 6, 7, 8]),
+        ("both", [0, 0.5, 1, 1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5]),
+        ("neither", [np.nan, 0, 0.5, 1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5]),
+        ("left", [np.nan, 0, 0.5, 1, 2, 3, 4, 5, 6, 7]),
+    ],
+)
+def test_closed_median_quantile(closed, expected):
+    # GH 26005
+    ser = Series(data=np.arange(10), index=date_range("2000", periods=10))
+    roll = ser.rolling("3D", closed=closed)
+    expected = Series(expected, index=ser.index)
+
+    result = roll.median()
+    tm.assert_series_equal(result, expected)
+
+    result = roll.quantile(0.5)
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize("roller", ["1s", 1])
+def tests_empty_df_rolling(roller):
+    # GH 15819 Verifies that datetime and integer rolling windows can be
+    # applied to empty DataFrames
+    expected = DataFrame()
+    result = DataFrame().rolling(roller).sum()
+    tm.assert_frame_equal(result, expected)
+
+    # Verifies that datetime and integer rolling windows can be applied to
+    # empty DataFrames with datetime index
+    expected = DataFrame(index=DatetimeIndex([]))
+    result = DataFrame(index=DatetimeIndex([])).rolling(roller).sum()
+    tm.assert_frame_equal(result, expected)
+
+
+def test_empty_window_median_quantile():
+    # GH 26005
+    expected = Series([np.nan, np.nan, np.nan])
+    roll = Series(np.arange(3)).rolling(0)
+
+    result = roll.median()
+    tm.assert_series_equal(result, expected)
+
+    result = roll.quantile(0.1)
+    tm.assert_series_equal(result, expected)
+
+
+def test_missing_minp_zero():
+    # https://github.com/pandas-dev/pandas/pull/18921
+    # minp=0
+    x = Series([np.nan])
+    result = x.rolling(1, min_periods=0).sum()
+    expected = Series([0.0])
+    tm.assert_series_equal(result, expected)
+
+    # minp=1
+    result = x.rolling(1, min_periods=1).sum()
+    expected = Series([np.nan])
+    tm.assert_series_equal(result, expected)
+
+
+def test_missing_minp_zero_variable():
+    # https://github.com/pandas-dev/pandas/pull/18921
+    x = Series(
+        [np.nan] * 4,
+        index=DatetimeIndex(["2017-01-01", "2017-01-04", "2017-01-06", "2017-01-07"]),
+    )
+    result = x.rolling(Timedelta("2d"), min_periods=0).sum()
+    expected = Series(0.0, index=x.index)
+    tm.assert_series_equal(result, expected)
+
+
+def test_multi_index_names():
+    # GH 16789, 16825
+    cols = MultiIndex.from_product([["A", "B"], ["C", "D", "E"]], names=["1", "2"])
+    df = DataFrame(np.ones((10, 6)), columns=cols)
+    result = df.rolling(3).cov()
+
+    tm.assert_index_equal(result.columns, df.columns)
+    assert result.index.names == [None, "1", "2"]
+
+
+def test_rolling_axis_sum(axis_frame):
+    # see gh-23372.
+    df = DataFrame(np.ones((10, 20)))
+    axis = df._get_axis_number(axis_frame)
+
+    if axis == 0:
+        msg = "The 'axis' keyword in DataFrame.rolling"
+        expected = DataFrame({i: [np.nan] * 2 + [3.0] * 8 for i in range(20)})
+    else:
+        # axis == 1
+        msg = "Support for axis=1 in DataFrame.rolling is deprecated"
+        expected = DataFrame([[np.nan] * 2 + [3.0] * 18] * 10)
+
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        result = df.rolling(3, axis=axis_frame).sum()
+    tm.assert_frame_equal(result, expected)
+
+
+def test_rolling_axis_count(axis_frame):
+    # see gh-26055
+    df = DataFrame({"x": range(3), "y": range(3)})
+
+    axis = df._get_axis_number(axis_frame)
+
+    if axis in [0, "index"]:
+        msg = "The 'axis' keyword in DataFrame.rolling"
+        expected = DataFrame({"x": [1.0, 2.0, 2.0], "y": [1.0, 2.0, 2.0]})
+    else:
+        msg = "Support for axis=1 in DataFrame.rolling is deprecated"
+        expected = DataFrame({"x": [1.0, 1.0, 1.0], "y": [2.0, 2.0, 2.0]})
+
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        result = df.rolling(2, axis=axis_frame, min_periods=0).count()
+    tm.assert_frame_equal(result, expected)
+
+
+def test_readonly_array():
+    # GH-27766
+    arr = np.array([1, 3, np.nan, 3, 5])
+    arr.setflags(write=False)
+    result = Series(arr).rolling(2).mean()
+    expected = Series([np.nan, 2, np.nan, np.nan, 4])
+    tm.assert_series_equal(result, expected)
+
+
+def test_rolling_datetime(axis_frame, tz_naive_fixture):
+    # GH-28192
+    tz = tz_naive_fixture
+    df = DataFrame(
+        {i: [1] * 2 for i in date_range("2019-8-01", "2019-08-03", freq="D", tz=tz)}
+    )
+
+    if axis_frame in [0, "index"]:
+        msg = "The 'axis' keyword in DataFrame.rolling"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = df.T.rolling("2D", axis=axis_frame).sum().T
+    else:
+        msg = "Support for axis=1 in DataFrame.rolling"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = df.rolling("2D", axis=axis_frame).sum()
+    expected = DataFrame(
+        {
+            **{
+                i: [1.0] * 2
+                for i in date_range("2019-8-01", periods=1, freq="D", tz=tz)
+            },
+            **{
+                i: [2.0] * 2
+                for i in date_range("2019-8-02", "2019-8-03", freq="D", tz=tz)
+            },
+        }
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("center", [True, False])
+def test_rolling_window_as_string(center):
+    # see gh-22590
+    date_today = datetime.now()
+    days = date_range(date_today, date_today + timedelta(365), freq="D")
+
+    data = np.ones(len(days))
+    df = DataFrame({"DateCol": days, "metric": data})
+
+    df.set_index("DateCol", inplace=True)
+    result = df.rolling(window="21D", min_periods=2, closed="left", center=center)[
+        "metric"
+    ].agg("max")
+
+    index = days.rename("DateCol")
+    index = index._with_freq(None)
+    expected_data = np.ones(len(days), dtype=np.float64)
+    if not center:
+        expected_data[:2] = np.nan
+    expected = Series(expected_data, index=index, name="metric")
+    tm.assert_series_equal(result, expected)
+
+
+def test_min_periods1():
+    # GH#6795
+    df = DataFrame([0, 1, 2, 1, 0], columns=["a"])
+    result = df["a"].rolling(3, center=True, min_periods=1).max()
+    expected = Series([1.0, 2.0, 2.0, 2.0, 1.0], name="a")
+    tm.assert_series_equal(result, expected)
+
+
+def test_rolling_count_with_min_periods(frame_or_series):
+    # GH 26996
+    result = frame_or_series(range(5)).rolling(3, min_periods=3).count()
+    expected = frame_or_series([np.nan, np.nan, 3.0, 3.0, 3.0])
+    tm.assert_equal(result, expected)
+
+
+def test_rolling_count_default_min_periods_with_null_values(frame_or_series):
+    # GH 26996
+    values = [1, 2, 3, np.nan, 4, 5, 6]
+    expected_counts = [1.0, 2.0, 3.0, 2.0, 2.0, 2.0, 3.0]
+
+    # GH 31302
+    result = frame_or_series(values).rolling(3, min_periods=0).count()
+    expected = frame_or_series(expected_counts)
+    tm.assert_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "df,expected,window,min_periods",
+    [
+        (
+            DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]}),
+            [
+                ({"A": [1], "B": [4]}, [0]),
+                ({"A": [1, 2], "B": [4, 5]}, [0, 1]),
+                ({"A": [1, 2, 3], "B": [4, 5, 6]}, [0, 1, 2]),
+            ],
+            3,
+            None,
+        ),
+        (
+            DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]}),
+            [
+                ({"A": [1], "B": [4]}, [0]),
+                ({"A": [1, 2], "B": [4, 5]}, [0, 1]),
+                ({"A": [2, 3], "B": [5, 6]}, [1, 2]),
+            ],
+            2,
+            1,
+        ),
+        (
+            DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]}),
+            [
+                ({"A": [1], "B": [4]}, [0]),
+                ({"A": [1, 2], "B": [4, 5]}, [0, 1]),
+                ({"A": [2, 3], "B": [5, 6]}, [1, 2]),
+            ],
+            2,
+            2,
+        ),
+        (
+            DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]}),
+            [
+                ({"A": [1], "B": [4]}, [0]),
+                ({"A": [2], "B": [5]}, [1]),
+                ({"A": [3], "B": [6]}, [2]),
+            ],
+            1,
+            1,
+        ),
+        (
+            DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]}),
+            [
+                ({"A": [1], "B": [4]}, [0]),
+                ({"A": [2], "B": [5]}, [1]),
+                ({"A": [3], "B": [6]}, [2]),
+            ],
+            1,
+            0,
+        ),
+        (DataFrame({"A": [1], "B": [4]}), [], 2, None),
+        (DataFrame({"A": [1], "B": [4]}), [], 2, 1),
+        (DataFrame(), [({}, [])], 2, None),
+        (
+            DataFrame({"A": [1, np.nan, 3], "B": [np.nan, 5, 6]}),
+            [
+                ({"A": [1.0], "B": [np.nan]}, [0]),
+                ({"A": [1, np.nan], "B": [np.nan, 5]}, [0, 1]),
+                ({"A": [1, np.nan, 3], "B": [np.nan, 5, 6]}, [0, 1, 2]),
+            ],
+            3,
+            2,
+        ),
+    ],
+)
+def test_iter_rolling_dataframe(df, expected, window, min_periods):
+    # GH 11704
+    expected = [DataFrame(values, index=index) for (values, index) in expected]
+
+    for expected, actual in zip(expected, df.rolling(window, min_periods=min_periods)):
+        tm.assert_frame_equal(actual, expected)
+
+
+@pytest.mark.parametrize(
+    "expected,window",
+    [
+        (
+            [
+                ({"A": [1], "B": [4]}, [0]),
+                ({"A": [1, 2], "B": [4, 5]}, [0, 1]),
+                ({"A": [2, 3], "B": [5, 6]}, [1, 2]),
+            ],
+            "2D",
+        ),
+        (
+            [
+                ({"A": [1], "B": [4]}, [0]),
+                ({"A": [1, 2], "B": [4, 5]}, [0, 1]),
+                ({"A": [1, 2, 3], "B": [4, 5, 6]}, [0, 1, 2]),
+            ],
+            "3D",
+        ),
+        (
+            [
+                ({"A": [1], "B": [4]}, [0]),
+                ({"A": [2], "B": [5]}, [1]),
+                ({"A": [3], "B": [6]}, [2]),
+            ],
+            "1D",
+        ),
+    ],
+)
+def test_iter_rolling_on_dataframe(expected, window):
+    # GH 11704, 40373
+    df = DataFrame(
+        {
+            "A": [1, 2, 3, 4, 5],
+            "B": [4, 5, 6, 7, 8],
+            "C": date_range(start="2016-01-01", periods=5, freq="D"),
+        }
+    )
+
+    expected = [
+        DataFrame(values, index=df.loc[index, "C"]) for (values, index) in expected
+    ]
+    for expected, actual in zip(expected, df.rolling(window, on="C")):
+        tm.assert_frame_equal(actual, expected)
+
+
+def test_iter_rolling_on_dataframe_unordered():
+    # GH 43386
+    df = DataFrame({"a": ["x", "y", "x"], "b": [0, 1, 2]})
+    results = list(df.groupby("a").rolling(2))
+    expecteds = [df.iloc[idx, [1]] for idx in [[0], [0, 2], [1]]]
+    for result, expected in zip(results, expecteds):
+        tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "ser,expected,window, min_periods",
+    [
+        (
+            Series([1, 2, 3]),
+            [([1], [0]), ([1, 2], [0, 1]), ([1, 2, 3], [0, 1, 2])],
+            3,
+            None,
+        ),
+        (
+            Series([1, 2, 3]),
+            [([1], [0]), ([1, 2], [0, 1]), ([1, 2, 3], [0, 1, 2])],
+            3,
+            1,
+        ),
+        (
+            Series([1, 2, 3]),
+            [([1], [0]), ([1, 2], [0, 1]), ([2, 3], [1, 2])],
+            2,
+            1,
+        ),
+        (
+            Series([1, 2, 3]),
+            [([1], [0]), ([1, 2], [0, 1]), ([2, 3], [1, 2])],
+            2,
+            2,
+        ),
+        (Series([1, 2, 3]), [([1], [0]), ([2], [1]), ([3], [2])], 1, 0),
+        (Series([1, 2, 3]), [([1], [0]), ([2], [1]), ([3], [2])], 1, 1),
+        (Series([1, 2]), [([1], [0]), ([1, 2], [0, 1])], 2, 0),
+        (Series([], dtype="int64"), [], 2, 1),
+    ],
+)
+def test_iter_rolling_series(ser, expected, window, min_periods):
+    # GH 11704
+    expected = [Series(values, index=index) for (values, index) in expected]
+
+    for expected, actual in zip(expected, ser.rolling(window, min_periods=min_periods)):
+        tm.assert_series_equal(actual, expected)
+
+
+@pytest.mark.parametrize(
+    "expected,expected_index,window",
+    [
+        (
+            [[0], [1], [2], [3], [4]],
+            [
+                date_range("2020-01-01", periods=1, freq="D"),
+                date_range("2020-01-02", periods=1, freq="D"),
+                date_range("2020-01-03", periods=1, freq="D"),
+                date_range("2020-01-04", periods=1, freq="D"),
+                date_range("2020-01-05", periods=1, freq="D"),
+            ],
+            "1D",
+        ),
+        (
+            [[0], [0, 1], [1, 2], [2, 3], [3, 4]],
+            [
+                date_range("2020-01-01", periods=1, freq="D"),
+                date_range("2020-01-01", periods=2, freq="D"),
+                date_range("2020-01-02", periods=2, freq="D"),
+                date_range("2020-01-03", periods=2, freq="D"),
+                date_range("2020-01-04", periods=2, freq="D"),
+            ],
+            "2D",
+        ),
+        (
+            [[0], [0, 1], [0, 1, 2], [1, 2, 3], [2, 3, 4]],
+            [
+                date_range("2020-01-01", periods=1, freq="D"),
+                date_range("2020-01-01", periods=2, freq="D"),
+                date_range("2020-01-01", periods=3, freq="D"),
+                date_range("2020-01-02", periods=3, freq="D"),
+                date_range("2020-01-03", periods=3, freq="D"),
+            ],
+            "3D",
+        ),
+    ],
+)
+def test_iter_rolling_datetime(expected, expected_index, window):
+    # GH 11704
+    ser = Series(range(5), index=date_range(start="2020-01-01", periods=5, freq="D"))
+
+    expected = [
+        Series(values, index=idx) for (values, idx) in zip(expected, expected_index)
+    ]
+
+    for expected, actual in zip(expected, ser.rolling(window)):
+        tm.assert_series_equal(actual, expected)
+
+
+@pytest.mark.parametrize(
+    "grouping,_index",
+    [
+        (
+            {"level": 0},
+            MultiIndex.from_tuples(
+                [(0, 0), (0, 0), (1, 1), (1, 1), (1, 1)], names=[None, None]
+            ),
+        ),
+        (
+            {"by": "X"},
+            MultiIndex.from_tuples(
+                [(0, 0), (1, 0), (2, 1), (3, 1), (4, 1)], names=["X", None]
+            ),
+        ),
+    ],
+)
+def test_rolling_positional_argument(grouping, _index, raw):
+    # GH 34605
+
+    def scaled_sum(*args):
+        if len(args) < 2:
+            raise ValueError("The function needs two arguments")
+        array, scale = args
+        return array.sum() / scale
+
+    df = DataFrame(data={"X": range(5)}, index=[0, 0, 1, 1, 1])
+
+    expected = DataFrame(data={"X": [0.0, 0.5, 1.0, 1.5, 2.0]}, index=_index)
+    # GH 40341
+    if "by" in grouping:
+        expected = expected.drop(columns="X", errors="ignore")
+    result = df.groupby(**grouping).rolling(1).apply(scaled_sum, raw=raw, args=(2,))
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("add", [0.0, 2.0])
+def test_rolling_numerical_accuracy_kahan_mean(add, unit):
+    # GH: 36031 implementing kahan summation
+    dti = DatetimeIndex(
+        [
+            Timestamp("19700101 09:00:00"),
+            Timestamp("19700101 09:00:03"),
+            Timestamp("19700101 09:00:06"),
+        ]
+    ).as_unit(unit)
+    df = DataFrame(
+        {"A": [3002399751580331.0 + add, -0.0, -0.0]},
+        index=dti,
+    )
+    result = (
+        df.resample("1s").ffill().rolling("3s", closed="left", min_periods=3).mean()
+    )
+    dates = date_range("19700101 09:00:00", periods=7, freq="s", unit=unit)
+    expected = DataFrame(
+        {
+            "A": [
+                np.nan,
+                np.nan,
+                np.nan,
+                3002399751580330.5,
+                2001599834386887.25,
+                1000799917193443.625,
+                0.0,
+            ]
+        },
+        index=dates,
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+def test_rolling_numerical_accuracy_kahan_sum():
+    # GH: 13254
+    df = DataFrame([2.186, -1.647, 0.0, 0.0, 0.0, 0.0], columns=["x"])
+    result = df["x"].rolling(3).sum()
+    expected = Series([np.nan, np.nan, 0.539, -1.647, 0.0, 0.0], name="x")
+    tm.assert_series_equal(result, expected)
+
+
+def test_rolling_numerical_accuracy_jump():
+    # GH: 32761
+    index = date_range(start="2020-01-01", end="2020-01-02", freq="60s").append(
+        DatetimeIndex(["2020-01-03"])
+    )
+    data = np.random.default_rng(2).random(len(index))
+
+    df = DataFrame({"data": data}, index=index)
+    result = df.rolling("60s").mean()
+    tm.assert_frame_equal(result, df[["data"]])
+
+
+def test_rolling_numerical_accuracy_small_values():
+    # GH: 10319
+    s = Series(
+        data=[0.00012456, 0.0003, -0.0, -0.0],
+        index=date_range("1999-02-03", "1999-02-06"),
+    )
+    result = s.rolling(1).mean()
+    tm.assert_series_equal(result, s)
+
+
+def test_rolling_numerical_too_large_numbers():
+    # GH: 11645
+    dates = date_range("2015-01-01", periods=10, freq="D")
+    ds = Series(data=range(10), index=dates, dtype=np.float64)
+    ds.iloc[2] = -9e33
+    result = ds.rolling(5).mean()
+    expected = Series(
+        [
+            np.nan,
+            np.nan,
+            np.nan,
+            np.nan,
+            -1.8e33,
+            -1.8e33,
+            -1.8e33,
+            5.0,
+            6.0,
+            7.0,
+        ],
+        index=dates,
+    )
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    ("func", "value"),
+    [("sum", 2.0), ("max", 1.0), ("min", 1.0), ("mean", 1.0), ("median", 1.0)],
+)
+def test_rolling_mixed_dtypes_axis_1(func, value):
+    # GH: 20649
+    df = DataFrame(1, index=[1, 2], columns=["a", "b", "c"])
+    df["c"] = 1.0
+    msg = "Support for axis=1 in DataFrame.rolling is deprecated"
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        roll = df.rolling(window=2, min_periods=1, axis=1)
+    result = getattr(roll, func)()
+    expected = DataFrame(
+        {"a": [1.0, 1.0], "b": [value, value], "c": [value, value]},
+        index=[1, 2],
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+def test_rolling_axis_one_with_nan():
+    # GH: 35596
+    df = DataFrame(
+        [
+            [0, 1, 2, 4, np.nan, np.nan, np.nan],
+            [0, 1, 2, np.nan, np.nan, np.nan, np.nan],
+            [0, 2, 2, np.nan, 2, np.nan, 1],
+        ]
+    )
+    msg = "Support for axis=1 in DataFrame.rolling is deprecated"
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        result = df.rolling(window=7, min_periods=1, axis="columns").sum()
+    expected = DataFrame(
+        [
+            [0.0, 1.0, 3.0, 7.0, 7.0, 7.0, 7.0],
+            [0.0, 1.0, 3.0, 3.0, 3.0, 3.0, 3.0],
+            [0.0, 2.0, 4.0, 4.0, 6.0, 6.0, 7.0],
+        ]
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "value",
+    ["test", to_datetime("2019-12-31"), to_timedelta("1 days 06:05:01.00003")],
+)
+def test_rolling_axis_1_non_numeric_dtypes(value):
+    # GH: 20649
+    df = DataFrame({"a": [1, 2]})
+    df["b"] = value
+    msg = "Support for axis=1 in DataFrame.rolling is deprecated"
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        result = df.rolling(window=2, min_periods=1, axis=1).sum()
+    expected = DataFrame({"a": [1.0, 2.0]})
+    tm.assert_frame_equal(result, expected)
+
+
+def test_rolling_on_df_transposed():
+    # GH: 32724
+    df = DataFrame({"A": [1, None], "B": [4, 5], "C": [7, 8]})
+    expected = DataFrame({"A": [1.0, np.nan], "B": [5.0, 5.0], "C": [11.0, 13.0]})
+    msg = "Support for axis=1 in DataFrame.rolling is deprecated"
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        result = df.rolling(min_periods=1, window=2, axis=1).sum()
+    tm.assert_frame_equal(result, expected)
+
+    result = df.T.rolling(min_periods=1, window=2).sum().T
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    ("index", "window"),
+    [
+        (
+            period_range(start="2020-01-01 08:00", end="2020-01-01 08:08", freq="min"),
+            "2min",
+        ),
+        (
+            period_range(
+                start="2020-01-01 08:00", end="2020-01-01 12:00", freq="30min"
+            ),
+            "1h",
+        ),
+    ],
+)
+@pytest.mark.parametrize(
+    ("func", "values"),
+    [
+        ("min", [np.nan, 0, 0, 1, 2, 3, 4, 5, 6]),
+        ("max", [np.nan, 0, 1, 2, 3, 4, 5, 6, 7]),
+        ("sum", [np.nan, 0, 1, 3, 5, 7, 9, 11, 13]),
+    ],
+)
+def test_rolling_period_index(index, window, func, values):
+    # GH: 34225
+    ds = Series([0, 1, 2, 3, 4, 5, 6, 7, 8], index=index)
+    result = getattr(ds.rolling(window, closed="left"), func)()
+    expected = Series(values, index=index)
+    tm.assert_series_equal(result, expected)
+
+
+def test_rolling_sem(frame_or_series):
+    # GH: 26476
+    obj = frame_or_series([0, 1, 2])
+    result = obj.rolling(2, min_periods=1).sem()
+    if isinstance(result, DataFrame):
+        result = Series(result[0].values)
+    expected = Series([np.nan] + [0.7071067811865476] * 2)
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.xfail(
+    is_platform_arm() or is_platform_power(),
+    reason="GH 38921",
+)
+@pytest.mark.parametrize(
+    ("func", "third_value", "values"),
+    [
+        ("var", 1, [5e33, 0, 0.5, 0.5, 2, 0]),
+        ("std", 1, [7.071068e16, 0, 0.7071068, 0.7071068, 1.414214, 0]),
+        ("var", 2, [5e33, 0.5, 0, 0.5, 2, 0]),
+        ("std", 2, [7.071068e16, 0.7071068, 0, 0.7071068, 1.414214, 0]),
+    ],
+)
+def test_rolling_var_numerical_issues(func, third_value, values):
+    # GH: 37051
+    ds = Series([99999999999999999, 1, third_value, 2, 3, 1, 1])
+    result = getattr(ds.rolling(2), func)()
+    expected = Series([np.nan] + values)
+    tm.assert_series_equal(result, expected)
+    # GH 42064
+    # new `roll_var` will output 0.0 correctly
+    tm.assert_series_equal(result == 0, expected == 0)
+
+
+def test_timeoffset_as_window_parameter_for_corr(unit):
+    # GH: 28266
+    dti = DatetimeIndex(
+        [
+            Timestamp("20130101 09:00:00"),
+            Timestamp("20130102 09:00:02"),
+            Timestamp("20130103 09:00:03"),
+            Timestamp("20130105 09:00:05"),
+            Timestamp("20130106 09:00:06"),
+        ]
+    ).as_unit(unit)
+    mi = MultiIndex.from_product([dti, ["B", "A"]])
+
+    exp = DataFrame(
+        {
+            "B": [
+                np.nan,
+                np.nan,
+                0.9999999999999998,
+                -1.0,
+                1.0,
+                -0.3273268353539892,
+                0.9999999999999998,
+                1.0,
+                0.9999999999999998,
+                1.0,
+            ],
+            "A": [
+                np.nan,
+                np.nan,
+                -1.0,
+                1.0000000000000002,
+                -0.3273268353539892,
+                0.9999999999999966,
+                1.0,
+                1.0000000000000002,
+                1.0,
+                1.0000000000000002,
+            ],
+        },
+        index=mi,
+    )
+
+    df = DataFrame(
+        {"B": [0, 1, 2, 4, 3], "A": [7, 4, 6, 9, 3]},
+        index=dti,
+    )
+
+    res = df.rolling(window="3d").corr()
+
+    tm.assert_frame_equal(exp, res)
+
+
+@pytest.mark.parametrize("method", ["var", "sum", "mean", "skew", "kurt", "min", "max"])
+def test_rolling_decreasing_indices(method):
+    """
+    Make sure that decreasing indices give the same results as increasing indices.
+
+    GH 36933
+    """
+    df = DataFrame({"values": np.arange(-15, 10) ** 2})
+    df_reverse = DataFrame({"values": df["values"][::-1]}, index=df.index[::-1])
+
+    increasing = getattr(df.rolling(window=5), method)()
+    decreasing = getattr(df_reverse.rolling(window=5), method)()
+
+    assert np.abs(decreasing.values[::-1][:-4] - increasing.values[4:]).max() < 1e-12
+
+
+@pytest.mark.parametrize(
+    "window,closed,expected",
+    [
+        ("2s", "right", [1.0, 3.0, 5.0, 3.0]),
+        ("2s", "left", [0.0, 1.0, 3.0, 5.0]),
+        ("2s", "both", [1.0, 3.0, 6.0, 5.0]),
+        ("2s", "neither", [0.0, 1.0, 2.0, 3.0]),
+        ("3s", "right", [1.0, 3.0, 6.0, 5.0]),
+        ("3s", "left", [1.0, 3.0, 6.0, 5.0]),
+        ("3s", "both", [1.0, 3.0, 6.0, 5.0]),
+        ("3s", "neither", [1.0, 3.0, 6.0, 5.0]),
+    ],
+)
+def test_rolling_decreasing_indices_centered(window, closed, expected, frame_or_series):
+    """
+    Ensure that a symmetrical inverted index return same result as non-inverted.
+    """
+    #  GH 43927
+
+    index = date_range("2020", periods=4, freq="1s")
+    df_inc = frame_or_series(range(4), index=index)
+    df_dec = frame_or_series(range(4), index=index[::-1])
+
+    expected_inc = frame_or_series(expected, index=index)
+    expected_dec = frame_or_series(expected, index=index[::-1])
+
+    result_inc = df_inc.rolling(window, closed=closed, center=True).sum()
+    result_dec = df_dec.rolling(window, closed=closed, center=True).sum()
+
+    tm.assert_equal(result_inc, expected_inc)
+    tm.assert_equal(result_dec, expected_dec)
+
+
+@pytest.mark.parametrize(
+    "window,expected",
+    [
+        ("1ns", [1.0, 1.0, 1.0, 1.0]),
+        ("3ns", [2.0, 3.0, 3.0, 2.0]),
+    ],
+)
+def test_rolling_center_nanosecond_resolution(
+    window, closed, expected, frame_or_series
+):
+    index = date_range("2020", periods=4, freq="1ns")
+    df = frame_or_series([1, 1, 1, 1], index=index, dtype=float)
+    expected = frame_or_series(expected, index=index, dtype=float)
+    result = df.rolling(window, closed=closed, center=True).sum()
+    tm.assert_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "method,expected",
+    [
+        (
+            "var",
+            [
+                float("nan"),
+                43.0,
+                float("nan"),
+                136.333333,
+                43.5,
+                94.966667,
+                182.0,
+                318.0,
+            ],
+        ),
+        (
+            "mean",
+            [float("nan"), 7.5, float("nan"), 21.5, 6.0, 9.166667, 13.0, 17.5],
+        ),
+        (
+            "sum",
+            [float("nan"), 30.0, float("nan"), 86.0, 30.0, 55.0, 91.0, 140.0],
+        ),
+        (
+            "skew",
+            [
+                float("nan"),
+                0.709296,
+                float("nan"),
+                0.407073,
+                0.984656,
+                0.919184,
+                0.874674,
+                0.842418,
+            ],
+        ),
+        (
+            "kurt",
+            [
+                float("nan"),
+                -0.5916711736073559,
+                float("nan"),
+                -1.0028993131317954,
+                -0.06103844629409494,
+                -0.254143227116194,
+                -0.37362637362637585,
+                -0.45439658241367054,
+            ],
+        ),
+    ],
+)
+def test_rolling_non_monotonic(method, expected):
+    """
+    Make sure the (rare) branch of non-monotonic indices is covered by a test.
+
+    output from 1.1.3 is assumed to be the expected output. Output of sum/mean has
+    manually been verified.
+
+    GH 36933.
+    """
+    # Based on an example found in computation.rst
+    use_expanding = [True, False, True, False, True, True, True, True]
+    df = DataFrame({"values": np.arange(len(use_expanding)) ** 2})
+
+    class CustomIndexer(BaseIndexer):
+        def get_window_bounds(self, num_values, min_periods, center, closed, step):
+            start = np.empty(num_values, dtype=np.int64)
+            end = np.empty(num_values, dtype=np.int64)
+            for i in range(num_values):
+                if self.use_expanding[i]:
+                    start[i] = 0
+                    end[i] = i + 1
+                else:
+                    start[i] = i
+                    end[i] = i + self.window_size
+            return start, end
+
+    indexer = CustomIndexer(window_size=4, use_expanding=use_expanding)
+
+    result = getattr(df.rolling(indexer), method)()
+    expected = DataFrame({"values": expected})
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    ("index", "window"),
+    [
+        ([0, 1, 2, 3, 4], 2),
+        (date_range("2001-01-01", freq="D", periods=5), "2D"),
+    ],
+)
+def test_rolling_corr_timedelta_index(index, window):
+    # GH: 31286
+    x = Series([1, 2, 3, 4, 5], index=index)
+    y = x.copy()
+    x.iloc[0:2] = 0.0
+    result = x.rolling(window).corr(y)
+    expected = Series([np.nan, np.nan, 1, 1, 1], index=index)
+    tm.assert_almost_equal(result, expected)
+
+
+def test_groupby_rolling_nan_included():
+    # GH 35542
+    data = {"group": ["g1", np.nan, "g1", "g2", np.nan], "B": [0, 1, 2, 3, 4]}
+    df = DataFrame(data)
+    result = df.groupby("group", dropna=False).rolling(1, min_periods=1).mean()
+    expected = DataFrame(
+        {"B": [0.0, 2.0, 3.0, 1.0, 4.0]},
+        # GH-38057 from_tuples puts the NaNs in the codes, result expects them
+        # to be in the levels, at the moment
+        # index=MultiIndex.from_tuples(
+        #     [("g1", 0), ("g1", 2), ("g2", 3), (np.nan, 1), (np.nan, 4)],
+        #     names=["group", None],
+        # ),
+        index=MultiIndex(
+            [["g1", "g2", np.nan], [0, 1, 2, 3, 4]],
+            [[0, 0, 1, 2, 2], [0, 2, 3, 1, 4]],
+            names=["group", None],
+        ),
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("method", ["skew", "kurt"])
+def test_rolling_skew_kurt_numerical_stability(method):
+    # GH#6929
+    ser = Series(np.random.default_rng(2).random(10))
+    ser_copy = ser.copy()
+    expected = getattr(ser.rolling(3), method)()
+    tm.assert_series_equal(ser, ser_copy)
+    ser = ser + 50000
+    result = getattr(ser.rolling(3), method)()
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    ("method", "values"),
+    [
+        ("skew", [2.0, 0.854563, 0.0, 1.999984]),
+        ("kurt", [4.0, -1.289256, -1.2, 3.999946]),
+    ],
+)
+def test_rolling_skew_kurt_large_value_range(method, values):
+    # GH: 37557
+    s = Series([3000000, 1, 1, 2, 3, 4, 999])
+    result = getattr(s.rolling(4), method)()
+    expected = Series([np.nan] * 3 + values)
+    tm.assert_series_equal(result, expected)
+
+
+def test_invalid_method():
+    with pytest.raises(ValueError, match="method must be 'table' or 'single"):
+        Series(range(1)).rolling(1, method="foo")
+
+
+@pytest.mark.parametrize("window", [1, "1d"])
+def test_rolling_descending_date_order_with_offset(window, frame_or_series):
+    # GH#40002
+    idx = date_range(start="2020-01-01", end="2020-01-03", freq="1d")
+    obj = frame_or_series(range(1, 4), index=idx)
+    result = obj.rolling("1d", closed="left").sum()
+    expected = frame_or_series([np.nan, 1, 2], index=idx)
+    tm.assert_equal(result, expected)
+
+    result = obj.iloc[::-1].rolling("1d", closed="left").sum()
+    idx = date_range(start="2020-01-03", end="2020-01-01", freq="-1d")
+    expected = frame_or_series([np.nan, 3, 2], index=idx)
+    tm.assert_equal(result, expected)
+
+
+def test_rolling_var_floating_artifact_precision():
+    # GH 37051
+    s = Series([7, 5, 5, 5])
+    result = s.rolling(3).var()
+    expected = Series([np.nan, np.nan, 4 / 3, 0])
+    tm.assert_series_equal(result, expected, atol=1.0e-15, rtol=1.0e-15)
+    # GH 42064
+    # new `roll_var` will output 0.0 correctly
+    tm.assert_series_equal(result == 0, expected == 0)
+
+
+def test_rolling_std_small_values():
+    # GH 37051
+    s = Series(
+        [
+            0.00000054,
+            0.00000053,
+            0.00000054,
+        ]
+    )
+    result = s.rolling(2).std()
+    expected = Series([np.nan, 7.071068e-9, 7.071068e-9])
+    tm.assert_series_equal(result, expected, atol=1.0e-15, rtol=1.0e-15)
+
+
+@pytest.mark.parametrize(
+    "start, exp_values",
+    [
+        (1, [0.03, 0.0155, 0.0155, 0.011, 0.01025]),
+        (2, [0.001, 0.001, 0.0015, 0.00366666]),
+    ],
+)
+def test_rolling_mean_all_nan_window_floating_artifacts(start, exp_values):
+    # GH#41053
+    df = DataFrame(
+        [
+            0.03,
+            0.03,
+            0.001,
+            np.nan,
+            0.002,
+            0.008,
+            np.nan,
+            np.nan,
+            np.nan,
+            np.nan,
+            np.nan,
+            np.nan,
+            0.005,
+            0.2,
+        ]
+    )
+
+    values = exp_values + [
+        0.00366666,
+        0.005,
+        0.005,
+        0.008,
+        np.nan,
+        np.nan,
+        0.005,
+        0.102500,
+    ]
+    expected = DataFrame(
+        values,
+        index=list(range(start, len(values) + start)),
+    )
+    result = df.iloc[start:].rolling(5, min_periods=0).mean()
+    tm.assert_frame_equal(result, expected)
+
+
+def test_rolling_sum_all_nan_window_floating_artifacts():
+    # GH#41053
+    df = DataFrame([0.002, 0.008, 0.005, np.nan, np.nan, np.nan])
+    result = df.rolling(3, min_periods=0).sum()
+    expected = DataFrame([0.002, 0.010, 0.015, 0.013, 0.005, 0.0])
+    tm.assert_frame_equal(result, expected)
+
+
+def test_rolling_zero_window():
+    # GH 22719
+    s = Series(range(1))
+    result = s.rolling(0).min()
+    expected = Series([np.nan])
+    tm.assert_series_equal(result, expected)
+
+
+def test_rolling_float_dtype(float_numpy_dtype):
+    # GH#42452
+    df = DataFrame({"A": range(5), "B": range(10, 15)}, dtype=float_numpy_dtype)
+    expected = DataFrame(
+        {"A": [np.nan] * 5, "B": range(10, 20, 2)},
+        dtype=float_numpy_dtype,
+    )
+    msg = "Support for axis=1 in DataFrame.rolling is deprecated"
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        result = df.rolling(2, axis=1).sum()
+    tm.assert_frame_equal(result, expected, check_dtype=False)
+
+
+def test_rolling_numeric_dtypes():
+    # GH#41779
+    df = DataFrame(np.arange(40).reshape(4, 10), columns=list("abcdefghij")).astype(
+        {
+            "a": "float16",
+            "b": "float32",
+            "c": "float64",
+            "d": "int8",
+            "e": "int16",
+            "f": "int32",
+            "g": "uint8",
+            "h": "uint16",
+            "i": "uint32",
+            "j": "uint64",
+        }
+    )
+    msg = "Support for axis=1 in DataFrame.rolling is deprecated"
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        result = df.rolling(window=2, min_periods=1, axis=1).min()
+    expected = DataFrame(
+        {
+            "a": range(0, 40, 10),
+            "b": range(0, 40, 10),
+            "c": range(1, 40, 10),
+            "d": range(2, 40, 10),
+            "e": range(3, 40, 10),
+            "f": range(4, 40, 10),
+            "g": range(5, 40, 10),
+            "h": range(6, 40, 10),
+            "i": range(7, 40, 10),
+            "j": range(8, 40, 10),
+        },
+        dtype="float64",
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("window", [1, 3, 10, 20])
+@pytest.mark.parametrize("method", ["min", "max", "average"])
+@pytest.mark.parametrize("pct", [True, False])
+@pytest.mark.parametrize("ascending", [True, False])
+@pytest.mark.parametrize("test_data", ["default", "duplicates", "nans"])
+def test_rank(window, method, pct, ascending, test_data):
+    length = 20
+    if test_data == "default":
+        ser = Series(data=np.random.default_rng(2).random(length))
+    elif test_data == "duplicates":
+        ser = Series(data=np.random.default_rng(2).choice(3, length))
+    elif test_data == "nans":
+        ser = Series(
+            data=np.random.default_rng(2).choice(
+                [1.0, 0.25, 0.75, np.nan, np.inf, -np.inf], length
+            )
+        )
+
+    expected = ser.rolling(window).apply(
+        lambda x: x.rank(method=method, pct=pct, ascending=ascending).iloc[-1]
+    )
+    result = ser.rolling(window).rank(method=method, pct=pct, ascending=ascending)
+
+    tm.assert_series_equal(result, expected)
+
+
+def test_rolling_quantile_np_percentile():
+    # #9413: Tests that rolling window's quantile default behavior
+    # is analogous to Numpy's percentile
+    row = 10
+    col = 5
+    idx = date_range("20100101", periods=row, freq="B")
+    df = DataFrame(
+        np.random.default_rng(2).random(row * col).reshape((row, -1)), index=idx
+    )
+
+    df_quantile = df.quantile([0.25, 0.5, 0.75], axis=0)
+    np_percentile = np.percentile(df, [25, 50, 75], axis=0)
+
+    tm.assert_almost_equal(df_quantile.values, np.array(np_percentile))
+
+
+@pytest.mark.parametrize("quantile", [0.0, 0.1, 0.45, 0.5, 1])
+@pytest.mark.parametrize(
+    "interpolation", ["linear", "lower", "higher", "nearest", "midpoint"]
+)
+@pytest.mark.parametrize(
+    "data",
+    [
+        [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0],
+        [8.0, 1.0, 3.0, 4.0, 5.0, 2.0, 6.0, 7.0],
+        [0.0, np.nan, 0.2, np.nan, 0.4],
+        [np.nan, np.nan, np.nan, np.nan],
+        [np.nan, 0.1, np.nan, 0.3, 0.4, 0.5],
+        [0.5],
+        [np.nan, 0.7, 0.6],
+    ],
+)
+def test_rolling_quantile_interpolation_options(quantile, interpolation, data):
+    # Tests that rolling window's quantile behavior is analogous to
+    # Series' quantile for each interpolation option
+    s = Series(data)
+
+    q1 = s.quantile(quantile, interpolation)
+    q2 = s.expanding(min_periods=1).quantile(quantile, interpolation).iloc[-1]
+
+    if np.isnan(q1):
+        assert np.isnan(q2)
+    else:
+        if not IS64:
+            # Less precision on 32-bit
+            assert np.allclose([q1], [q2], rtol=1e-07, atol=0)
+        else:
+            assert q1 == q2
+
+
+def test_invalid_quantile_value():
+    data = np.arange(5)
+    s = Series(data)
+
+    msg = "Interpolation 'invalid' is not supported"
+    with pytest.raises(ValueError, match=msg):
+        s.rolling(len(data), min_periods=1).quantile(0.5, interpolation="invalid")
+
+
+def test_rolling_quantile_param():
+    ser = Series([0.0, 0.1, 0.5, 0.9, 1.0])
+    msg = "quantile value -0.1 not in \\[0, 1\\]"
+    with pytest.raises(ValueError, match=msg):
+        ser.rolling(3).quantile(-0.1)
+
+    msg = "quantile value 10.0 not in \\[0, 1\\]"
+    with pytest.raises(ValueError, match=msg):
+        ser.rolling(3).quantile(10.0)
+
+    msg = "must be real number, not str"
+    with pytest.raises(TypeError, match=msg):
+        ser.rolling(3).quantile("foo")
+
+
+def test_rolling_std_1obs():
+    vals = Series([1.0, 2.0, 3.0, 4.0, 5.0])
+
+    result = vals.rolling(1, min_periods=1).std()
+    expected = Series([np.nan] * 5)
+    tm.assert_series_equal(result, expected)
+
+    result = vals.rolling(1, min_periods=1).std(ddof=0)
+    expected = Series([0.0] * 5)
+    tm.assert_series_equal(result, expected)
+
+    result = Series([np.nan, np.nan, 3, 4, 5]).rolling(3, min_periods=2).std()
+    assert np.isnan(result[2])
+
+
+def test_rolling_std_neg_sqrt():
+    # unit test from Bottleneck
+
+    # Test move_nanstd for neg sqrt.
+
+    a = Series(
+        [
+            0.0011448196318903589,
+            0.00028718669878572767,
+            0.00028718669878572767,
+            0.00028718669878572767,
+            0.00028718669878572767,
+        ]
+    )
+    b = a.rolling(window=3).std()
+    assert np.isfinite(b[2:]).all()
+
+    b = a.ewm(span=3).std()
+    assert np.isfinite(b[2:]).all()
+
+
+def test_step_not_integer_raises():
+    with pytest.raises(ValueError, match="step must be an integer"):
+        DataFrame(range(2)).rolling(1, step="foo")
+
+
+def test_step_not_positive_raises():
+    with pytest.raises(ValueError, match="step must be >= 0"):
+        DataFrame(range(2)).rolling(1, step=-1)
+
+
+@pytest.mark.parametrize(
+    ["values", "window", "min_periods", "expected"],
+    [
+        [
+            [20, 10, 10, np.inf, 1, 1, 2, 3],
+            3,
+            1,
+            [np.nan, 50, 100 / 3, 0, 40.5, 0, 1 / 3, 1],
+        ],
+        [
+            [20, 10, 10, np.nan, 10, 1, 2, 3],
+            3,
+            1,
+            [np.nan, 50, 100 / 3, 0, 0, 40.5, 73 / 3, 1],
+        ],
+        [
+            [np.nan, 5, 6, 7, 5, 5, 5],
+            3,
+            3,
+            [np.nan] * 3 + [1, 1, 4 / 3, 0],
+        ],
+        [
+            [5, 7, 7, 7, np.nan, np.inf, 4, 3, 3, 3],
+            3,
+            3,
+            [np.nan] * 2 + [4 / 3, 0] + [np.nan] * 4 + [1 / 3, 0],
+        ],
+        [
+            [5, 7, 7, 7, np.nan, np.inf, 7, 3, 3, 3],
+            3,
+            3,
+            [np.nan] * 2 + [4 / 3, 0] + [np.nan] * 4 + [16 / 3, 0],
+        ],
+        [
+            [5, 7] * 4,
+            3,
+            3,
+            [np.nan] * 2 + [4 / 3] * 6,
+        ],
+        [
+            [5, 7, 5, np.nan, 7, 5, 7],
+            3,
+            2,
+            [np.nan, 2, 4 / 3] + [2] * 3 + [4 / 3],
+        ],
+    ],
+)
+def test_rolling_var_same_value_count_logic(values, window, min_periods, expected):
+    # GH 42064.
+
+    expected = Series(expected)
+    sr = Series(values)
+
+    # With new algo implemented, result will be set to .0 in rolling var
+    # if sufficient amount of consecutively same values are found.
+    result_var = sr.rolling(window, min_periods=min_periods).var()
+
+    # use `assert_series_equal` twice to check for equality,
+    # because `check_exact=True` will fail in 32-bit tests due to
+    # precision loss.
+
+    # 1. result should be close to correct value
+    # non-zero values can still differ slightly from "truth"
+    # as the result of online algorithm
+    tm.assert_series_equal(result_var, expected)
+    # 2. zeros should be exactly the same since the new algo takes effect here
+    tm.assert_series_equal(expected == 0, result_var == 0)
+
+    # std should also pass as it's just a sqrt of var
+    result_std = sr.rolling(window, min_periods=min_periods).std()
+    tm.assert_series_equal(result_std, np.sqrt(expected))
+    tm.assert_series_equal(expected == 0, result_std == 0)
+
+
+def test_rolling_mean_sum_floating_artifacts():
+    # GH 42064.
+
+    sr = Series([1 / 3, 4, 0, 0, 0, 0, 0])
+    r = sr.rolling(3)
+    result = r.mean()
+    assert (result[-3:] == 0).all()
+    result = r.sum()
+    assert (result[-3:] == 0).all()
+
+
+def test_rolling_skew_kurt_floating_artifacts():
+    # GH 42064 46431
+
+    sr = Series([1 / 3, 4, 0, 0, 0, 0, 0])
+    r = sr.rolling(4)
+    result = r.skew()
+    assert (result[-2:] == 0).all()
+    result = r.kurt()
+    assert (result[-2:] == -3).all()
+
+
+def test_numeric_only_frame(arithmetic_win_operators, numeric_only):
+    # GH#46560
+    kernel = arithmetic_win_operators
+    df = DataFrame({"a": [1], "b": 2, "c": 3})
+    df["c"] = df["c"].astype(object)
+    rolling = df.rolling(2, min_periods=1)
+    op = getattr(rolling, kernel)
+    result = op(numeric_only=numeric_only)
+
+    columns = ["a", "b"] if numeric_only else ["a", "b", "c"]
+    expected = df[columns].agg([kernel]).reset_index(drop=True).astype(float)
+    assert list(expected.columns) == columns
+
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("kernel", ["corr", "cov"])
+@pytest.mark.parametrize("use_arg", [True, False])
+def test_numeric_only_corr_cov_frame(kernel, numeric_only, use_arg):
+    # GH#46560
+    df = DataFrame({"a": [1, 2, 3], "b": 2, "c": 3})
+    df["c"] = df["c"].astype(object)
+    arg = (df,) if use_arg else ()
+    rolling = df.rolling(2, min_periods=1)
+    op = getattr(rolling, kernel)
+    result = op(*arg, numeric_only=numeric_only)
+
+    # Compare result to op using float dtypes, dropping c when numeric_only is True
+    columns = ["a", "b"] if numeric_only else ["a", "b", "c"]
+    df2 = df[columns].astype(float)
+    arg2 = (df2,) if use_arg else ()
+    rolling2 = df2.rolling(2, min_periods=1)
+    op2 = getattr(rolling2, kernel)
+    expected = op2(*arg2, numeric_only=numeric_only)
+
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("dtype", [int, object])
+def test_numeric_only_series(arithmetic_win_operators, numeric_only, dtype):
+    # GH#46560
+    kernel = arithmetic_win_operators
+    ser = Series([1], dtype=dtype)
+    rolling = ser.rolling(2, min_periods=1)
+    op = getattr(rolling, kernel)
+    if numeric_only and dtype is object:
+        msg = f"Rolling.{kernel} does not implement numeric_only"
+        with pytest.raises(NotImplementedError, match=msg):
+            op(numeric_only=numeric_only)
+    else:
+        result = op(numeric_only=numeric_only)
+        expected = ser.agg([kernel]).reset_index(drop=True).astype(float)
+        tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize("kernel", ["corr", "cov"])
+@pytest.mark.parametrize("use_arg", [True, False])
+@pytest.mark.parametrize("dtype", [int, object])
+def test_numeric_only_corr_cov_series(kernel, use_arg, numeric_only, dtype):
+    # GH#46560
+    ser = Series([1, 2, 3], dtype=dtype)
+    arg = (ser,) if use_arg else ()
+    rolling = ser.rolling(2, min_periods=1)
+    op = getattr(rolling, kernel)
+    if numeric_only and dtype is object:
+        msg = f"Rolling.{kernel} does not implement numeric_only"
+        with pytest.raises(NotImplementedError, match=msg):
+            op(*arg, numeric_only=numeric_only)
+    else:
+        result = op(*arg, numeric_only=numeric_only)
+
+        ser2 = ser.astype(float)
+        arg2 = (ser2,) if use_arg else ()
+        rolling2 = ser2.rolling(2, min_periods=1)
+        op2 = getattr(rolling2, kernel)
+        expected = op2(*arg2, numeric_only=numeric_only)
+        tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize("unit", ["s", "ms", "us", "ns"])
+@pytest.mark.parametrize("tz", [None, "UTC", "Europe/Prague"])
+def test_rolling_timedelta_window_non_nanoseconds(unit, tz):
+    # Test Sum, GH#55106
+    df_time = DataFrame(
+        {"A": range(5)}, index=date_range("2013-01-01", freq="1s", periods=5, tz=tz)
+    )
+    sum_in_nanosecs = df_time.rolling("1s").sum()
+    # microseconds / milliseconds should not break the correct rolling
+    df_time.index = df_time.index.as_unit(unit)
+    sum_in_microsecs = df_time.rolling("1s").sum()
+    sum_in_microsecs.index = sum_in_microsecs.index.as_unit("ns")
+    tm.assert_frame_equal(sum_in_nanosecs, sum_in_microsecs)
+
+    # Test max, GH#55026
+    ref_dates = date_range("2023-01-01", "2023-01-10", unit="ns", tz=tz)
+    ref_series = Series(0, index=ref_dates)
+    ref_series.iloc[0] = 1
+    ref_max_series = ref_series.rolling(Timedelta(days=4)).max()
+
+    dates = date_range("2023-01-01", "2023-01-10", unit=unit, tz=tz)
+    series = Series(0, index=dates)
+    series.iloc[0] = 1
+    max_series = series.rolling(Timedelta(days=4)).max()
+
+    ref_df = DataFrame(ref_max_series)
+    df = DataFrame(max_series)
+    df.index = df.index.as_unit("ns")
+
+    tm.assert_frame_equal(ref_df, df)
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/test_rolling_functions.py b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/test_rolling_functions.py
new file mode 100644
index 0000000000000000000000000000000000000000..5906ff52db098dfca00d8fdc0a5fa1460b7a35f1
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/test_rolling_functions.py
@@ -0,0 +1,532 @@
+from datetime import datetime
+
+import numpy as np
+import pytest
+
+import pandas.util._test_decorators as td
+
+from pandas import (
+    DataFrame,
+    DatetimeIndex,
+    Series,
+    concat,
+    isna,
+    notna,
+)
+import pandas._testing as tm
+
+from pandas.tseries import offsets
+
+
+@pytest.mark.parametrize(
+    "compare_func, roll_func, kwargs",
+    [
+        [np.mean, "mean", {}],
+        [np.nansum, "sum", {}],
+        [
+            lambda x: np.isfinite(x).astype(float).sum(),
+            "count",
+            {},
+        ],
+        [np.median, "median", {}],
+        [np.min, "min", {}],
+        [np.max, "max", {}],
+        [lambda x: np.std(x, ddof=1), "std", {}],
+        [lambda x: np.std(x, ddof=0), "std", {"ddof": 0}],
+        [lambda x: np.var(x, ddof=1), "var", {}],
+        [lambda x: np.var(x, ddof=0), "var", {"ddof": 0}],
+    ],
+)
+def test_series(series, compare_func, roll_func, kwargs, step):
+    result = getattr(series.rolling(50, step=step), roll_func)(**kwargs)
+    assert isinstance(result, Series)
+    end = range(0, len(series), step or 1)[-1] + 1
+    tm.assert_almost_equal(result.iloc[-1], compare_func(series[end - 50 : end]))
+
+
+@pytest.mark.parametrize(
+    "compare_func, roll_func, kwargs",
+    [
+        [np.mean, "mean", {}],
+        [np.nansum, "sum", {}],
+        [
+            lambda x: np.isfinite(x).astype(float).sum(),
+            "count",
+            {},
+        ],
+        [np.median, "median", {}],
+        [np.min, "min", {}],
+        [np.max, "max", {}],
+        [lambda x: np.std(x, ddof=1), "std", {}],
+        [lambda x: np.std(x, ddof=0), "std", {"ddof": 0}],
+        [lambda x: np.var(x, ddof=1), "var", {}],
+        [lambda x: np.var(x, ddof=0), "var", {"ddof": 0}],
+    ],
+)
+def test_frame(raw, frame, compare_func, roll_func, kwargs, step):
+    result = getattr(frame.rolling(50, step=step), roll_func)(**kwargs)
+    assert isinstance(result, DataFrame)
+    end = range(0, len(frame), step or 1)[-1] + 1
+    tm.assert_series_equal(
+        result.iloc[-1, :],
+        frame.iloc[end - 50 : end, :].apply(compare_func, axis=0, raw=raw),
+        check_names=False,
+    )
+
+
+@pytest.mark.parametrize(
+    "compare_func, roll_func, kwargs, minp",
+    [
+        [np.mean, "mean", {}, 10],
+        [np.nansum, "sum", {}, 10],
+        [lambda x: np.isfinite(x).astype(float).sum(), "count", {}, 0],
+        [np.median, "median", {}, 10],
+        [np.min, "min", {}, 10],
+        [np.max, "max", {}, 10],
+        [lambda x: np.std(x, ddof=1), "std", {}, 10],
+        [lambda x: np.std(x, ddof=0), "std", {"ddof": 0}, 10],
+        [lambda x: np.var(x, ddof=1), "var", {}, 10],
+        [lambda x: np.var(x, ddof=0), "var", {"ddof": 0}, 10],
+    ],
+)
+def test_time_rule_series(series, compare_func, roll_func, kwargs, minp):
+    win = 25
+    ser = series[::2].resample("B").mean()
+    series_result = getattr(ser.rolling(window=win, min_periods=minp), roll_func)(
+        **kwargs
+    )
+    last_date = series_result.index[-1]
+    prev_date = last_date - 24 * offsets.BDay()
+
+    trunc_series = series[::2].truncate(prev_date, last_date)
+    tm.assert_almost_equal(series_result.iloc[-1], compare_func(trunc_series))
+
+
+@pytest.mark.parametrize(
+    "compare_func, roll_func, kwargs, minp",
+    [
+        [np.mean, "mean", {}, 10],
+        [np.nansum, "sum", {}, 10],
+        [lambda x: np.isfinite(x).astype(float).sum(), "count", {}, 0],
+        [np.median, "median", {}, 10],
+        [np.min, "min", {}, 10],
+        [np.max, "max", {}, 10],
+        [lambda x: np.std(x, ddof=1), "std", {}, 10],
+        [lambda x: np.std(x, ddof=0), "std", {"ddof": 0}, 10],
+        [lambda x: np.var(x, ddof=1), "var", {}, 10],
+        [lambda x: np.var(x, ddof=0), "var", {"ddof": 0}, 10],
+    ],
+)
+def test_time_rule_frame(raw, frame, compare_func, roll_func, kwargs, minp):
+    win = 25
+    frm = frame[::2].resample("B").mean()
+    frame_result = getattr(frm.rolling(window=win, min_periods=minp), roll_func)(
+        **kwargs
+    )
+    last_date = frame_result.index[-1]
+    prev_date = last_date - 24 * offsets.BDay()
+
+    trunc_frame = frame[::2].truncate(prev_date, last_date)
+    tm.assert_series_equal(
+        frame_result.xs(last_date),
+        trunc_frame.apply(compare_func, raw=raw),
+        check_names=False,
+    )
+
+
+@pytest.mark.parametrize(
+    "compare_func, roll_func, kwargs",
+    [
+        [np.mean, "mean", {}],
+        [np.nansum, "sum", {}],
+        [np.median, "median", {}],
+        [np.min, "min", {}],
+        [np.max, "max", {}],
+        [lambda x: np.std(x, ddof=1), "std", {}],
+        [lambda x: np.std(x, ddof=0), "std", {"ddof": 0}],
+        [lambda x: np.var(x, ddof=1), "var", {}],
+        [lambda x: np.var(x, ddof=0), "var", {"ddof": 0}],
+    ],
+)
+def test_nans(compare_func, roll_func, kwargs):
+    obj = Series(np.random.default_rng(2).standard_normal(50))
+    obj[:10] = np.nan
+    obj[-10:] = np.nan
+
+    result = getattr(obj.rolling(50, min_periods=30), roll_func)(**kwargs)
+    tm.assert_almost_equal(result.iloc[-1], compare_func(obj[10:-10]))
+
+    # min_periods is working correctly
+    result = getattr(obj.rolling(20, min_periods=15), roll_func)(**kwargs)
+    assert isna(result.iloc[23])
+    assert not isna(result.iloc[24])
+
+    assert not isna(result.iloc[-6])
+    assert isna(result.iloc[-5])
+
+    obj2 = Series(np.random.default_rng(2).standard_normal(20))
+    result = getattr(obj2.rolling(10, min_periods=5), roll_func)(**kwargs)
+    assert isna(result.iloc[3])
+    assert notna(result.iloc[4])
+
+    if roll_func != "sum":
+        result0 = getattr(obj.rolling(20, min_periods=0), roll_func)(**kwargs)
+        result1 = getattr(obj.rolling(20, min_periods=1), roll_func)(**kwargs)
+        tm.assert_almost_equal(result0, result1)
+
+
+def test_nans_count():
+    obj = Series(np.random.default_rng(2).standard_normal(50))
+    obj[:10] = np.nan
+    obj[-10:] = np.nan
+    result = obj.rolling(50, min_periods=30).count()
+    tm.assert_almost_equal(
+        result.iloc[-1], np.isfinite(obj[10:-10]).astype(float).sum()
+    )
+
+
+@pytest.mark.parametrize(
+    "roll_func, kwargs",
+    [
+        ["mean", {}],
+        ["sum", {}],
+        ["median", {}],
+        ["min", {}],
+        ["max", {}],
+        ["std", {}],
+        ["std", {"ddof": 0}],
+        ["var", {}],
+        ["var", {"ddof": 0}],
+    ],
+)
+@pytest.mark.parametrize("minp", [0, 99, 100])
+def test_min_periods(series, minp, roll_func, kwargs, step):
+    result = getattr(
+        series.rolling(len(series) + 1, min_periods=minp, step=step), roll_func
+    )(**kwargs)
+    expected = getattr(
+        series.rolling(len(series), min_periods=minp, step=step), roll_func
+    )(**kwargs)
+    nan_mask = isna(result)
+    tm.assert_series_equal(nan_mask, isna(expected))
+
+    nan_mask = ~nan_mask
+    tm.assert_almost_equal(result[nan_mask], expected[nan_mask])
+
+
+def test_min_periods_count(series, step):
+    result = series.rolling(len(series) + 1, min_periods=0, step=step).count()
+    expected = series.rolling(len(series), min_periods=0, step=step).count()
+    nan_mask = isna(result)
+    tm.assert_series_equal(nan_mask, isna(expected))
+
+    nan_mask = ~nan_mask
+    tm.assert_almost_equal(result[nan_mask], expected[nan_mask])
+
+
+@pytest.mark.parametrize(
+    "roll_func, kwargs, minp",
+    [
+        ["mean", {}, 15],
+        ["sum", {}, 15],
+        ["count", {}, 0],
+        ["median", {}, 15],
+        ["min", {}, 15],
+        ["max", {}, 15],
+        ["std", {}, 15],
+        ["std", {"ddof": 0}, 15],
+        ["var", {}, 15],
+        ["var", {"ddof": 0}, 15],
+    ],
+)
+def test_center(roll_func, kwargs, minp):
+    obj = Series(np.random.default_rng(2).standard_normal(50))
+    obj[:10] = np.nan
+    obj[-10:] = np.nan
+
+    result = getattr(obj.rolling(20, min_periods=minp, center=True), roll_func)(
+        **kwargs
+    )
+    expected = (
+        getattr(
+            concat([obj, Series([np.nan] * 9)]).rolling(20, min_periods=minp), roll_func
+        )(**kwargs)
+        .iloc[9:]
+        .reset_index(drop=True)
+    )
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "roll_func, kwargs, minp, fill_value",
+    [
+        ["mean", {}, 10, None],
+        ["sum", {}, 10, None],
+        ["count", {}, 0, 0],
+        ["median", {}, 10, None],
+        ["min", {}, 10, None],
+        ["max", {}, 10, None],
+        ["std", {}, 10, None],
+        ["std", {"ddof": 0}, 10, None],
+        ["var", {}, 10, None],
+        ["var", {"ddof": 0}, 10, None],
+    ],
+)
+def test_center_reindex_series(series, roll_func, kwargs, minp, fill_value):
+    # shifter index
+    s = [f"x{x:d}" for x in range(12)]
+
+    series_xp = (
+        getattr(
+            series.reindex(list(series.index) + s).rolling(window=25, min_periods=minp),
+            roll_func,
+        )(**kwargs)
+        .shift(-12)
+        .reindex(series.index)
+    )
+    series_rs = getattr(
+        series.rolling(window=25, min_periods=minp, center=True), roll_func
+    )(**kwargs)
+    if fill_value is not None:
+        series_xp = series_xp.fillna(fill_value)
+    tm.assert_series_equal(series_xp, series_rs)
+
+
+@pytest.mark.parametrize(
+    "roll_func, kwargs, minp, fill_value",
+    [
+        ["mean", {}, 10, None],
+        ["sum", {}, 10, None],
+        ["count", {}, 0, 0],
+        ["median", {}, 10, None],
+        ["min", {}, 10, None],
+        ["max", {}, 10, None],
+        ["std", {}, 10, None],
+        ["std", {"ddof": 0}, 10, None],
+        ["var", {}, 10, None],
+        ["var", {"ddof": 0}, 10, None],
+    ],
+)
+def test_center_reindex_frame(frame, roll_func, kwargs, minp, fill_value):
+    # shifter index
+    s = [f"x{x:d}" for x in range(12)]
+
+    frame_xp = (
+        getattr(
+            frame.reindex(list(frame.index) + s).rolling(window=25, min_periods=minp),
+            roll_func,
+        )(**kwargs)
+        .shift(-12)
+        .reindex(frame.index)
+    )
+    frame_rs = getattr(
+        frame.rolling(window=25, min_periods=minp, center=True), roll_func
+    )(**kwargs)
+    if fill_value is not None:
+        frame_xp = frame_xp.fillna(fill_value)
+    tm.assert_frame_equal(frame_xp, frame_rs)
+
+
+@pytest.mark.parametrize(
+    "f",
+    [
+        lambda x: x.rolling(window=10, min_periods=5).cov(x, pairwise=False),
+        lambda x: x.rolling(window=10, min_periods=5).corr(x, pairwise=False),
+        lambda x: x.rolling(window=10, min_periods=5).max(),
+        lambda x: x.rolling(window=10, min_periods=5).min(),
+        lambda x: x.rolling(window=10, min_periods=5).sum(),
+        lambda x: x.rolling(window=10, min_periods=5).mean(),
+        lambda x: x.rolling(window=10, min_periods=5).std(),
+        lambda x: x.rolling(window=10, min_periods=5).var(),
+        lambda x: x.rolling(window=10, min_periods=5).skew(),
+        lambda x: x.rolling(window=10, min_periods=5).kurt(),
+        lambda x: x.rolling(window=10, min_periods=5).quantile(q=0.5),
+        lambda x: x.rolling(window=10, min_periods=5).median(),
+        lambda x: x.rolling(window=10, min_periods=5).apply(sum, raw=False),
+        lambda x: x.rolling(window=10, min_periods=5).apply(sum, raw=True),
+        pytest.param(
+            lambda x: x.rolling(win_type="boxcar", window=10, min_periods=5).mean(),
+            marks=td.skip_if_no("scipy"),
+        ),
+    ],
+)
+def test_rolling_functions_window_non_shrinkage(f):
+    # GH 7764
+    s = Series(range(4))
+    s_expected = Series(np.nan, index=s.index)
+    df = DataFrame([[1, 5], [3, 2], [3, 9], [-1, 0]], columns=["A", "B"])
+    df_expected = DataFrame(np.nan, index=df.index, columns=df.columns)
+
+    s_result = f(s)
+    tm.assert_series_equal(s_result, s_expected)
+
+    df_result = f(df)
+    tm.assert_frame_equal(df_result, df_expected)
+
+
+def test_rolling_max_gh6297(step):
+    """Replicate result expected in GH #6297"""
+    indices = [datetime(1975, 1, i) for i in range(1, 6)]
+    # So that we can have 2 datapoints on one of the days
+    indices.append(datetime(1975, 1, 3, 6, 0))
+    series = Series(range(1, 7), index=indices)
+    # Use floats instead of ints as values
+    series = series.map(lambda x: float(x))
+    # Sort chronologically
+    series = series.sort_index()
+
+    expected = Series(
+        [1.0, 2.0, 6.0, 4.0, 5.0],
+        index=DatetimeIndex([datetime(1975, 1, i, 0) for i in range(1, 6)], freq="D"),
+    )[::step]
+    x = series.resample("D").max().rolling(window=1, step=step).max()
+    tm.assert_series_equal(expected, x)
+
+
+def test_rolling_max_resample(step):
+    indices = [datetime(1975, 1, i) for i in range(1, 6)]
+    # So that we can have 3 datapoints on last day (4, 10, and 20)
+    indices.append(datetime(1975, 1, 5, 1))
+    indices.append(datetime(1975, 1, 5, 2))
+    series = Series(list(range(5)) + [10, 20], index=indices)
+    # Use floats instead of ints as values
+    series = series.map(lambda x: float(x))
+    # Sort chronologically
+    series = series.sort_index()
+
+    # Default how should be max
+    expected = Series(
+        [0.0, 1.0, 2.0, 3.0, 20.0],
+        index=DatetimeIndex([datetime(1975, 1, i, 0) for i in range(1, 6)], freq="D"),
+    )[::step]
+    x = series.resample("D").max().rolling(window=1, step=step).max()
+    tm.assert_series_equal(expected, x)
+
+    # Now specify median (10.0)
+    expected = Series(
+        [0.0, 1.0, 2.0, 3.0, 10.0],
+        index=DatetimeIndex([datetime(1975, 1, i, 0) for i in range(1, 6)], freq="D"),
+    )[::step]
+    x = series.resample("D").median().rolling(window=1, step=step).max()
+    tm.assert_series_equal(expected, x)
+
+    # Now specify mean (4+10+20)/3
+    v = (4.0 + 10.0 + 20.0) / 3.0
+    expected = Series(
+        [0.0, 1.0, 2.0, 3.0, v],
+        index=DatetimeIndex([datetime(1975, 1, i, 0) for i in range(1, 6)], freq="D"),
+    )[::step]
+    x = series.resample("D").mean().rolling(window=1, step=step).max()
+    tm.assert_series_equal(expected, x)
+
+
+def test_rolling_min_resample(step):
+    indices = [datetime(1975, 1, i) for i in range(1, 6)]
+    # So that we can have 3 datapoints on last day (4, 10, and 20)
+    indices.append(datetime(1975, 1, 5, 1))
+    indices.append(datetime(1975, 1, 5, 2))
+    series = Series(list(range(5)) + [10, 20], index=indices)
+    # Use floats instead of ints as values
+    series = series.map(lambda x: float(x))
+    # Sort chronologically
+    series = series.sort_index()
+
+    # Default how should be min
+    expected = Series(
+        [0.0, 1.0, 2.0, 3.0, 4.0],
+        index=DatetimeIndex([datetime(1975, 1, i, 0) for i in range(1, 6)], freq="D"),
+    )[::step]
+    r = series.resample("D").min().rolling(window=1, step=step)
+    tm.assert_series_equal(expected, r.min())
+
+
+def test_rolling_median_resample():
+    indices = [datetime(1975, 1, i) for i in range(1, 6)]
+    # So that we can have 3 datapoints on last day (4, 10, and 20)
+    indices.append(datetime(1975, 1, 5, 1))
+    indices.append(datetime(1975, 1, 5, 2))
+    series = Series(list(range(5)) + [10, 20], index=indices)
+    # Use floats instead of ints as values
+    series = series.map(lambda x: float(x))
+    # Sort chronologically
+    series = series.sort_index()
+
+    # Default how should be median
+    expected = Series(
+        [0.0, 1.0, 2.0, 3.0, 10],
+        index=DatetimeIndex([datetime(1975, 1, i, 0) for i in range(1, 6)], freq="D"),
+    )
+    x = series.resample("D").median().rolling(window=1).median()
+    tm.assert_series_equal(expected, x)
+
+
+def test_rolling_median_memory_error():
+    # GH11722
+    n = 20000
+    Series(np.random.default_rng(2).standard_normal(n)).rolling(
+        window=2, center=False
+    ).median()
+    Series(np.random.default_rng(2).standard_normal(n)).rolling(
+        window=2, center=False
+    ).median()
+
+
+@pytest.mark.parametrize(
+    "data_type",
+    [np.dtype(f"f{width}") for width in [4, 8]]
+    + [np.dtype(f"{sign}{width}") for width in [1, 2, 4, 8] for sign in "ui"],
+)
+def test_rolling_min_max_numeric_types(data_type):
+    # GH12373
+
+    # Just testing that these don't throw exceptions and that
+    # the return type is float64. Other tests will cover quantitative
+    # correctness
+    result = DataFrame(np.arange(20, dtype=data_type)).rolling(window=5).max()
+    assert result.dtypes[0] == np.dtype("f8")
+    result = DataFrame(np.arange(20, dtype=data_type)).rolling(window=5).min()
+    assert result.dtypes[0] == np.dtype("f8")
+
+
+@pytest.mark.parametrize(
+    "f",
+    [
+        lambda x: x.rolling(window=10, min_periods=0).count(),
+        lambda x: x.rolling(window=10, min_periods=5).cov(x, pairwise=False),
+        lambda x: x.rolling(window=10, min_periods=5).corr(x, pairwise=False),
+        lambda x: x.rolling(window=10, min_periods=5).max(),
+        lambda x: x.rolling(window=10, min_periods=5).min(),
+        lambda x: x.rolling(window=10, min_periods=5).sum(),
+        lambda x: x.rolling(window=10, min_periods=5).mean(),
+        lambda x: x.rolling(window=10, min_periods=5).std(),
+        lambda x: x.rolling(window=10, min_periods=5).var(),
+        lambda x: x.rolling(window=10, min_periods=5).skew(),
+        lambda x: x.rolling(window=10, min_periods=5).kurt(),
+        lambda x: x.rolling(window=10, min_periods=5).quantile(0.5),
+        lambda x: x.rolling(window=10, min_periods=5).median(),
+        lambda x: x.rolling(window=10, min_periods=5).apply(sum, raw=False),
+        lambda x: x.rolling(window=10, min_periods=5).apply(sum, raw=True),
+        pytest.param(
+            lambda x: x.rolling(win_type="boxcar", window=10, min_periods=5).mean(),
+            marks=td.skip_if_no("scipy"),
+        ),
+    ],
+)
+def test_moment_functions_zero_length(f):
+    # GH 8056
+    s = Series(dtype=np.float64)
+    s_expected = s
+    df1 = DataFrame()
+    df1_expected = df1
+    df2 = DataFrame(columns=["a"])
+    df2["a"] = df2["a"].astype("float64")
+    df2_expected = df2
+
+    s_result = f(s)
+    tm.assert_series_equal(s_result, s_expected)
+
+    df1_result = f(df1)
+    tm.assert_frame_equal(df1_result, df1_expected)
+
+    df2_result = f(df2)
+    tm.assert_frame_equal(df2_result, df2_expected)
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/test_rolling_quantile.py b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/test_rolling_quantile.py
new file mode 100644
index 0000000000000000000000000000000000000000..d5a7010923563c99b335fd9a309a1d8762d21651
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/test_rolling_quantile.py
@@ -0,0 +1,182 @@
+from functools import partial
+
+import numpy as np
+import pytest
+
+from pandas import (
+    DataFrame,
+    Series,
+    concat,
+    isna,
+    notna,
+)
+import pandas._testing as tm
+
+from pandas.tseries import offsets
+
+
+def scoreatpercentile(a, per):
+    values = np.sort(a, axis=0)
+
+    idx = int(per / 1.0 * (values.shape[0] - 1))
+
+    if idx == values.shape[0] - 1:
+        retval = values[-1]
+
+    else:
+        qlow = idx / (values.shape[0] - 1)
+        qhig = (idx + 1) / (values.shape[0] - 1)
+        vlow = values[idx]
+        vhig = values[idx + 1]
+        retval = vlow + (vhig - vlow) * (per - qlow) / (qhig - qlow)
+
+    return retval
+
+
+@pytest.mark.parametrize("q", [0.0, 0.1, 0.5, 0.9, 1.0])
+def test_series(series, q, step):
+    compare_func = partial(scoreatpercentile, per=q)
+    result = series.rolling(50, step=step).quantile(q)
+    assert isinstance(result, Series)
+    end = range(0, len(series), step or 1)[-1] + 1
+    tm.assert_almost_equal(result.iloc[-1], compare_func(series[end - 50 : end]))
+
+
+@pytest.mark.parametrize("q", [0.0, 0.1, 0.5, 0.9, 1.0])
+def test_frame(raw, frame, q, step):
+    compare_func = partial(scoreatpercentile, per=q)
+    result = frame.rolling(50, step=step).quantile(q)
+    assert isinstance(result, DataFrame)
+    end = range(0, len(frame), step or 1)[-1] + 1
+    tm.assert_series_equal(
+        result.iloc[-1, :],
+        frame.iloc[end - 50 : end, :].apply(compare_func, axis=0, raw=raw),
+        check_names=False,
+    )
+
+
+@pytest.mark.parametrize("q", [0.0, 0.1, 0.5, 0.9, 1.0])
+def test_time_rule_series(series, q):
+    compare_func = partial(scoreatpercentile, per=q)
+    win = 25
+    ser = series[::2].resample("B").mean()
+    series_result = ser.rolling(window=win, min_periods=10).quantile(q)
+    last_date = series_result.index[-1]
+    prev_date = last_date - 24 * offsets.BDay()
+
+    trunc_series = series[::2].truncate(prev_date, last_date)
+    tm.assert_almost_equal(series_result.iloc[-1], compare_func(trunc_series))
+
+
+@pytest.mark.parametrize("q", [0.0, 0.1, 0.5, 0.9, 1.0])
+def test_time_rule_frame(raw, frame, q):
+    compare_func = partial(scoreatpercentile, per=q)
+    win = 25
+    frm = frame[::2].resample("B").mean()
+    frame_result = frm.rolling(window=win, min_periods=10).quantile(q)
+    last_date = frame_result.index[-1]
+    prev_date = last_date - 24 * offsets.BDay()
+
+    trunc_frame = frame[::2].truncate(prev_date, last_date)
+    tm.assert_series_equal(
+        frame_result.xs(last_date),
+        trunc_frame.apply(compare_func, raw=raw),
+        check_names=False,
+    )
+
+
+@pytest.mark.parametrize("q", [0.0, 0.1, 0.5, 0.9, 1.0])
+def test_nans(q):
+    compare_func = partial(scoreatpercentile, per=q)
+    obj = Series(np.random.default_rng(2).standard_normal(50))
+    obj[:10] = np.nan
+    obj[-10:] = np.nan
+
+    result = obj.rolling(50, min_periods=30).quantile(q)
+    tm.assert_almost_equal(result.iloc[-1], compare_func(obj[10:-10]))
+
+    # min_periods is working correctly
+    result = obj.rolling(20, min_periods=15).quantile(q)
+    assert isna(result.iloc[23])
+    assert not isna(result.iloc[24])
+
+    assert not isna(result.iloc[-6])
+    assert isna(result.iloc[-5])
+
+    obj2 = Series(np.random.default_rng(2).standard_normal(20))
+    result = obj2.rolling(10, min_periods=5).quantile(q)
+    assert isna(result.iloc[3])
+    assert notna(result.iloc[4])
+
+    result0 = obj.rolling(20, min_periods=0).quantile(q)
+    result1 = obj.rolling(20, min_periods=1).quantile(q)
+    tm.assert_almost_equal(result0, result1)
+
+
+@pytest.mark.parametrize("minp", [0, 99, 100])
+@pytest.mark.parametrize("q", [0.0, 0.1, 0.5, 0.9, 1.0])
+def test_min_periods(series, minp, q, step):
+    result = series.rolling(len(series) + 1, min_periods=minp, step=step).quantile(q)
+    expected = series.rolling(len(series), min_periods=minp, step=step).quantile(q)
+    nan_mask = isna(result)
+    tm.assert_series_equal(nan_mask, isna(expected))
+
+    nan_mask = ~nan_mask
+    tm.assert_almost_equal(result[nan_mask], expected[nan_mask])
+
+
+@pytest.mark.parametrize("q", [0.0, 0.1, 0.5, 0.9, 1.0])
+def test_center(q):
+    obj = Series(np.random.default_rng(2).standard_normal(50))
+    obj[:10] = np.nan
+    obj[-10:] = np.nan
+
+    result = obj.rolling(20, center=True).quantile(q)
+    expected = (
+        concat([obj, Series([np.nan] * 9)])
+        .rolling(20)
+        .quantile(q)
+        .iloc[9:]
+        .reset_index(drop=True)
+    )
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize("q", [0.0, 0.1, 0.5, 0.9, 1.0])
+def test_center_reindex_series(series, q):
+    # shifter index
+    s = [f"x{x:d}" for x in range(12)]
+
+    series_xp = (
+        series.reindex(list(series.index) + s)
+        .rolling(window=25)
+        .quantile(q)
+        .shift(-12)
+        .reindex(series.index)
+    )
+
+    series_rs = series.rolling(window=25, center=True).quantile(q)
+    tm.assert_series_equal(series_xp, series_rs)
+
+
+@pytest.mark.parametrize("q", [0.0, 0.1, 0.5, 0.9, 1.0])
+def test_center_reindex_frame(frame, q):
+    # shifter index
+    s = [f"x{x:d}" for x in range(12)]
+
+    frame_xp = (
+        frame.reindex(list(frame.index) + s)
+        .rolling(window=25)
+        .quantile(q)
+        .shift(-12)
+        .reindex(frame.index)
+    )
+    frame_rs = frame.rolling(window=25, center=True).quantile(q)
+    tm.assert_frame_equal(frame_xp, frame_rs)
+
+
+def test_keyword_quantile_deprecated():
+    # GH #52550
+    s = Series([1, 2, 3, 4])
+    with tm.assert_produces_warning(FutureWarning):
+        s.rolling(2).quantile(quantile=0.4)
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/test_rolling_skew_kurt.py b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/test_rolling_skew_kurt.py
new file mode 100644
index 0000000000000000000000000000000000000000..79c14f243e7cc93b395ea84e05ec6bc79942b79b
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/test_rolling_skew_kurt.py
@@ -0,0 +1,227 @@
+from functools import partial
+
+import numpy as np
+import pytest
+
+from pandas import (
+    DataFrame,
+    Series,
+    concat,
+    isna,
+    notna,
+)
+import pandas._testing as tm
+
+from pandas.tseries import offsets
+
+
+@pytest.mark.parametrize("sp_func, roll_func", [["kurtosis", "kurt"], ["skew", "skew"]])
+def test_series(series, sp_func, roll_func):
+    sp_stats = pytest.importorskip("scipy.stats")
+
+    compare_func = partial(getattr(sp_stats, sp_func), bias=False)
+    result = getattr(series.rolling(50), roll_func)()
+    assert isinstance(result, Series)
+    tm.assert_almost_equal(result.iloc[-1], compare_func(series[-50:]))
+
+
+@pytest.mark.parametrize("sp_func, roll_func", [["kurtosis", "kurt"], ["skew", "skew"]])
+def test_frame(raw, frame, sp_func, roll_func):
+    sp_stats = pytest.importorskip("scipy.stats")
+
+    compare_func = partial(getattr(sp_stats, sp_func), bias=False)
+    result = getattr(frame.rolling(50), roll_func)()
+    assert isinstance(result, DataFrame)
+    tm.assert_series_equal(
+        result.iloc[-1, :],
+        frame.iloc[-50:, :].apply(compare_func, axis=0, raw=raw),
+        check_names=False,
+    )
+
+
+@pytest.mark.parametrize("sp_func, roll_func", [["kurtosis", "kurt"], ["skew", "skew"]])
+def test_time_rule_series(series, sp_func, roll_func):
+    sp_stats = pytest.importorskip("scipy.stats")
+
+    compare_func = partial(getattr(sp_stats, sp_func), bias=False)
+    win = 25
+    ser = series[::2].resample("B").mean()
+    series_result = getattr(ser.rolling(window=win, min_periods=10), roll_func)()
+    last_date = series_result.index[-1]
+    prev_date = last_date - 24 * offsets.BDay()
+
+    trunc_series = series[::2].truncate(prev_date, last_date)
+    tm.assert_almost_equal(series_result.iloc[-1], compare_func(trunc_series))
+
+
+@pytest.mark.parametrize("sp_func, roll_func", [["kurtosis", "kurt"], ["skew", "skew"]])
+def test_time_rule_frame(raw, frame, sp_func, roll_func):
+    sp_stats = pytest.importorskip("scipy.stats")
+
+    compare_func = partial(getattr(sp_stats, sp_func), bias=False)
+    win = 25
+    frm = frame[::2].resample("B").mean()
+    frame_result = getattr(frm.rolling(window=win, min_periods=10), roll_func)()
+    last_date = frame_result.index[-1]
+    prev_date = last_date - 24 * offsets.BDay()
+
+    trunc_frame = frame[::2].truncate(prev_date, last_date)
+    tm.assert_series_equal(
+        frame_result.xs(last_date),
+        trunc_frame.apply(compare_func, raw=raw),
+        check_names=False,
+    )
+
+
+@pytest.mark.parametrize("sp_func, roll_func", [["kurtosis", "kurt"], ["skew", "skew"]])
+def test_nans(sp_func, roll_func):
+    sp_stats = pytest.importorskip("scipy.stats")
+
+    compare_func = partial(getattr(sp_stats, sp_func), bias=False)
+    obj = Series(np.random.default_rng(2).standard_normal(50))
+    obj[:10] = np.nan
+    obj[-10:] = np.nan
+
+    result = getattr(obj.rolling(50, min_periods=30), roll_func)()
+    tm.assert_almost_equal(result.iloc[-1], compare_func(obj[10:-10]))
+
+    # min_periods is working correctly
+    result = getattr(obj.rolling(20, min_periods=15), roll_func)()
+    assert isna(result.iloc[23])
+    assert not isna(result.iloc[24])
+
+    assert not isna(result.iloc[-6])
+    assert isna(result.iloc[-5])
+
+    obj2 = Series(np.random.default_rng(2).standard_normal(20))
+    result = getattr(obj2.rolling(10, min_periods=5), roll_func)()
+    assert isna(result.iloc[3])
+    assert notna(result.iloc[4])
+
+    result0 = getattr(obj.rolling(20, min_periods=0), roll_func)()
+    result1 = getattr(obj.rolling(20, min_periods=1), roll_func)()
+    tm.assert_almost_equal(result0, result1)
+
+
+@pytest.mark.parametrize("minp", [0, 99, 100])
+@pytest.mark.parametrize("roll_func", ["kurt", "skew"])
+def test_min_periods(series, minp, roll_func, step):
+    result = getattr(
+        series.rolling(len(series) + 1, min_periods=minp, step=step), roll_func
+    )()
+    expected = getattr(
+        series.rolling(len(series), min_periods=minp, step=step), roll_func
+    )()
+    nan_mask = isna(result)
+    tm.assert_series_equal(nan_mask, isna(expected))
+
+    nan_mask = ~nan_mask
+    tm.assert_almost_equal(result[nan_mask], expected[nan_mask])
+
+
+@pytest.mark.parametrize("roll_func", ["kurt", "skew"])
+def test_center(roll_func):
+    obj = Series(np.random.default_rng(2).standard_normal(50))
+    obj[:10] = np.nan
+    obj[-10:] = np.nan
+
+    result = getattr(obj.rolling(20, center=True), roll_func)()
+    expected = (
+        getattr(concat([obj, Series([np.nan] * 9)]).rolling(20), roll_func)()
+        .iloc[9:]
+        .reset_index(drop=True)
+    )
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize("roll_func", ["kurt", "skew"])
+def test_center_reindex_series(series, roll_func):
+    # shifter index
+    s = [f"x{x:d}" for x in range(12)]
+
+    series_xp = (
+        getattr(
+            series.reindex(list(series.index) + s).rolling(window=25),
+            roll_func,
+        )()
+        .shift(-12)
+        .reindex(series.index)
+    )
+    series_rs = getattr(series.rolling(window=25, center=True), roll_func)()
+    tm.assert_series_equal(series_xp, series_rs)
+
+
+@pytest.mark.slow
+@pytest.mark.parametrize("roll_func", ["kurt", "skew"])
+def test_center_reindex_frame(frame, roll_func):
+    # shifter index
+    s = [f"x{x:d}" for x in range(12)]
+
+    frame_xp = (
+        getattr(
+            frame.reindex(list(frame.index) + s).rolling(window=25),
+            roll_func,
+        )()
+        .shift(-12)
+        .reindex(frame.index)
+    )
+    frame_rs = getattr(frame.rolling(window=25, center=True), roll_func)()
+    tm.assert_frame_equal(frame_xp, frame_rs)
+
+
+def test_rolling_skew_edge_cases(step):
+    expected = Series([np.nan] * 4 + [0.0])[::step]
+    # yields all NaN (0 variance)
+    d = Series([1] * 5)
+    x = d.rolling(window=5, step=step).skew()
+    # index 4 should be 0 as it contains 5 same obs
+    tm.assert_series_equal(expected, x)
+
+    expected = Series([np.nan] * 5)[::step]
+    # yields all NaN (window too small)
+    d = Series(np.random.default_rng(2).standard_normal(5))
+    x = d.rolling(window=2, step=step).skew()
+    tm.assert_series_equal(expected, x)
+
+    # yields [NaN, NaN, NaN, 0.177994, 1.548824]
+    d = Series([-1.50837035, -0.1297039, 0.19501095, 1.73508164, 0.41941401])
+    expected = Series([np.nan, np.nan, np.nan, 0.177994, 1.548824])[::step]
+    x = d.rolling(window=4, step=step).skew()
+    tm.assert_series_equal(expected, x)
+
+
+def test_rolling_kurt_edge_cases(step):
+    expected = Series([np.nan] * 4 + [-3.0])[::step]
+
+    # yields all NaN (0 variance)
+    d = Series([1] * 5)
+    x = d.rolling(window=5, step=step).kurt()
+    tm.assert_series_equal(expected, x)
+
+    # yields all NaN (window too small)
+    expected = Series([np.nan] * 5)[::step]
+    d = Series(np.random.default_rng(2).standard_normal(5))
+    x = d.rolling(window=3, step=step).kurt()
+    tm.assert_series_equal(expected, x)
+
+    # yields [NaN, NaN, NaN, 1.224307, 2.671499]
+    d = Series([-1.50837035, -0.1297039, 0.19501095, 1.73508164, 0.41941401])
+    expected = Series([np.nan, np.nan, np.nan, 1.224307, 2.671499])[::step]
+    x = d.rolling(window=4, step=step).kurt()
+    tm.assert_series_equal(expected, x)
+
+
+def test_rolling_skew_eq_value_fperr(step):
+    # #18804 all rolling skew for all equal values should return Nan
+    # #46717 update: all equal values should return 0 instead of NaN
+    a = Series([1.1] * 15).rolling(window=10, step=step).skew()
+    assert (a[a.index >= 9] == 0).all()
+    assert a[a.index < 9].isna().all()
+
+
+def test_rolling_kurt_eq_value_fperr(step):
+    # #18804 all rolling kurt for all equal values should return Nan
+    # #46717 update: all equal values should return -3 instead of NaN
+    a = Series([1.1] * 15).rolling(window=10, step=step).kurt()
+    assert (a[a.index >= 9] == -3).all()
+    assert a[a.index < 9].isna().all()
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/test_timeseries_window.py b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/test_timeseries_window.py
new file mode 100644
index 0000000000000000000000000000000000000000..bd0fadeb3e47565b6bad3e2e96dd7962b0b31d07
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/test_timeseries_window.py
@@ -0,0 +1,715 @@
+import numpy as np
+import pytest
+
+import pandas.util._test_decorators as td
+
+from pandas import (
+    DataFrame,
+    DatetimeIndex,
+    Index,
+    MultiIndex,
+    NaT,
+    Series,
+    Timestamp,
+    date_range,
+)
+import pandas._testing as tm
+
+from pandas.tseries import offsets
+
+
+@pytest.fixture
+def regular():
+    return DataFrame(
+        {"A": date_range("20130101", periods=5, freq="s"), "B": range(5)}
+    ).set_index("A")
+
+
+@pytest.fixture
+def ragged():
+    df = DataFrame({"B": range(5)})
+    df.index = [
+        Timestamp("20130101 09:00:00"),
+        Timestamp("20130101 09:00:02"),
+        Timestamp("20130101 09:00:03"),
+        Timestamp("20130101 09:00:05"),
+        Timestamp("20130101 09:00:06"),
+    ]
+    return df
+
+
+class TestRollingTS:
+    # rolling time-series friendly
+    # xref GH13327
+
+    def test_doc_string(self):
+        df = DataFrame(
+            {"B": [0, 1, 2, np.nan, 4]},
+            index=[
+                Timestamp("20130101 09:00:00"),
+                Timestamp("20130101 09:00:02"),
+                Timestamp("20130101 09:00:03"),
+                Timestamp("20130101 09:00:05"),
+                Timestamp("20130101 09:00:06"),
+            ],
+        )
+        df
+        df.rolling("2s").sum()
+
+    def test_invalid_window_non_int(self, regular):
+        # not a valid freq
+        msg = "passed window foobar is not compatible with a datetimelike index"
+        with pytest.raises(ValueError, match=msg):
+            regular.rolling(window="foobar")
+        # not a datetimelike index
+        msg = "window must be an integer"
+        with pytest.raises(ValueError, match=msg):
+            regular.reset_index().rolling(window="foobar")
+
+    @pytest.mark.parametrize("freq", ["2MS", offsets.MonthBegin(2)])
+    def test_invalid_window_nonfixed(self, freq, regular):
+        # non-fixed freqs
+        msg = "\\<2 \\* MonthBegins\\> is a non-fixed frequency"
+        with pytest.raises(ValueError, match=msg):
+            regular.rolling(window=freq)
+
+    @pytest.mark.parametrize("freq", ["1D", offsets.Day(2), "2ms"])
+    def test_valid_window(self, freq, regular):
+        regular.rolling(window=freq)
+
+    @pytest.mark.parametrize("minp", [1.0, "foo", np.array([1, 2, 3])])
+    def test_invalid_minp(self, minp, regular):
+        # non-integer min_periods
+        msg = (
+            r"local variable 'minp' referenced before assignment|"
+            "min_periods must be an integer"
+        )
+        with pytest.raises(ValueError, match=msg):
+            regular.rolling(window="1D", min_periods=minp)
+
+    def test_on(self, regular):
+        df = regular
+
+        # not a valid column
+        msg = (
+            r"invalid on specified as foobar, must be a column "
+            "\\(of DataFrame\\), an Index or None"
+        )
+        with pytest.raises(ValueError, match=msg):
+            df.rolling(window="2s", on="foobar")
+
+        # column is valid
+        df = df.copy()
+        df["C"] = date_range("20130101", periods=len(df))
+        df.rolling(window="2d", on="C").sum()
+
+        # invalid columns
+        msg = "window must be an integer"
+        with pytest.raises(ValueError, match=msg):
+            df.rolling(window="2d", on="B")
+
+        # ok even though on non-selected
+        df.rolling(window="2d", on="C").B.sum()
+
+    def test_monotonic_on(self):
+        # on/index must be monotonic
+        df = DataFrame(
+            {"A": date_range("20130101", periods=5, freq="s"), "B": range(5)}
+        )
+
+        assert df.A.is_monotonic_increasing
+        df.rolling("2s", on="A").sum()
+
+        df = df.set_index("A")
+        assert df.index.is_monotonic_increasing
+        df.rolling("2s").sum()
+
+    def test_non_monotonic_on(self):
+        # GH 19248
+        df = DataFrame(
+            {"A": date_range("20130101", periods=5, freq="s"), "B": range(5)}
+        )
+        df = df.set_index("A")
+        non_monotonic_index = df.index.to_list()
+        non_monotonic_index[0] = non_monotonic_index[3]
+        df.index = non_monotonic_index
+
+        assert not df.index.is_monotonic_increasing
+
+        msg = "index values must be monotonic"
+        with pytest.raises(ValueError, match=msg):
+            df.rolling("2s").sum()
+
+        df = df.reset_index()
+
+        msg = (
+            r"invalid on specified as A, must be a column "
+            "\\(of DataFrame\\), an Index or None"
+        )
+        with pytest.raises(ValueError, match=msg):
+            df.rolling("2s", on="A").sum()
+
+    def test_frame_on(self):
+        df = DataFrame(
+            {"B": range(5), "C": date_range("20130101 09:00:00", periods=5, freq="3s")}
+        )
+
+        df["A"] = [
+            Timestamp("20130101 09:00:00"),
+            Timestamp("20130101 09:00:02"),
+            Timestamp("20130101 09:00:03"),
+            Timestamp("20130101 09:00:05"),
+            Timestamp("20130101 09:00:06"),
+        ]
+
+        # we are doing simulating using 'on'
+        expected = df.set_index("A").rolling("2s").B.sum().reset_index(drop=True)
+
+        result = df.rolling("2s", on="A").B.sum()
+        tm.assert_series_equal(result, expected)
+
+        # test as a frame
+        # we should be ignoring the 'on' as an aggregation column
+        # note that the expected is setting, computing, and resetting
+        # so the columns need to be switched compared
+        # to the actual result where they are ordered as in the
+        # original
+        expected = (
+            df.set_index("A").rolling("2s")[["B"]].sum().reset_index()[["B", "A"]]
+        )
+
+        result = df.rolling("2s", on="A")[["B"]].sum()
+        tm.assert_frame_equal(result, expected)
+
+    def test_frame_on2(self, unit):
+        # using multiple aggregation columns
+        dti = DatetimeIndex(
+            [
+                Timestamp("20130101 09:00:00"),
+                Timestamp("20130101 09:00:02"),
+                Timestamp("20130101 09:00:03"),
+                Timestamp("20130101 09:00:05"),
+                Timestamp("20130101 09:00:06"),
+            ]
+        ).as_unit(unit)
+        df = DataFrame(
+            {
+                "A": [0, 1, 2, 3, 4],
+                "B": [0, 1, 2, np.nan, 4],
+                "C": dti,
+            },
+            columns=["A", "C", "B"],
+        )
+
+        expected1 = DataFrame(
+            {"A": [0.0, 1, 3, 3, 7], "B": [0, 1, 3, np.nan, 4], "C": df["C"]},
+            columns=["A", "C", "B"],
+        )
+
+        result = df.rolling("2s", on="C").sum()
+        expected = expected1
+        tm.assert_frame_equal(result, expected)
+
+        expected = Series([0, 1, 3, np.nan, 4], name="B")
+        result = df.rolling("2s", on="C").B.sum()
+        tm.assert_series_equal(result, expected)
+
+        expected = expected1[["A", "B", "C"]]
+        result = df.rolling("2s", on="C")[["A", "B", "C"]].sum()
+        tm.assert_frame_equal(result, expected)
+
+    def test_basic_regular(self, regular):
+        df = regular.copy()
+
+        df.index = date_range("20130101", periods=5, freq="D")
+        expected = df.rolling(window=1, min_periods=1).sum()
+        result = df.rolling(window="1D").sum()
+        tm.assert_frame_equal(result, expected)
+
+        df.index = date_range("20130101", periods=5, freq="2D")
+        expected = df.rolling(window=1, min_periods=1).sum()
+        result = df.rolling(window="2D", min_periods=1).sum()
+        tm.assert_frame_equal(result, expected)
+
+        expected = df.rolling(window=1, min_periods=1).sum()
+        result = df.rolling(window="2D", min_periods=1).sum()
+        tm.assert_frame_equal(result, expected)
+
+        expected = df.rolling(window=1).sum()
+        result = df.rolling(window="2D").sum()
+        tm.assert_frame_equal(result, expected)
+
+    def test_min_periods(self, regular):
+        # compare for min_periods
+        df = regular
+
+        # these slightly different
+        expected = df.rolling(2, min_periods=1).sum()
+        result = df.rolling("2s").sum()
+        tm.assert_frame_equal(result, expected)
+
+        expected = df.rolling(2, min_periods=1).sum()
+        result = df.rolling("2s", min_periods=1).sum()
+        tm.assert_frame_equal(result, expected)
+
+    def test_closed(self, regular, unit):
+        # xref GH13965
+
+        dti = DatetimeIndex(
+            [
+                Timestamp("20130101 09:00:01"),
+                Timestamp("20130101 09:00:02"),
+                Timestamp("20130101 09:00:03"),
+                Timestamp("20130101 09:00:04"),
+                Timestamp("20130101 09:00:06"),
+            ]
+        ).as_unit(unit)
+
+        df = DataFrame(
+            {"A": [1] * 5},
+            index=dti,
+        )
+
+        # closed must be 'right', 'left', 'both', 'neither'
+        msg = "closed must be 'right', 'left', 'both' or 'neither'"
+        with pytest.raises(ValueError, match=msg):
+            regular.rolling(window="2s", closed="blabla")
+
+        expected = df.copy()
+        expected["A"] = [1.0, 2, 2, 2, 1]
+        result = df.rolling("2s", closed="right").sum()
+        tm.assert_frame_equal(result, expected)
+
+        # default should be 'right'
+        result = df.rolling("2s").sum()
+        tm.assert_frame_equal(result, expected)
+
+        expected = df.copy()
+        expected["A"] = [1.0, 2, 3, 3, 2]
+        result = df.rolling("2s", closed="both").sum()
+        tm.assert_frame_equal(result, expected)
+
+        expected = df.copy()
+        expected["A"] = [np.nan, 1.0, 2, 2, 1]
+        result = df.rolling("2s", closed="left").sum()
+        tm.assert_frame_equal(result, expected)
+
+        expected = df.copy()
+        expected["A"] = [np.nan, 1.0, 1, 1, np.nan]
+        result = df.rolling("2s", closed="neither").sum()
+        tm.assert_frame_equal(result, expected)
+
+    def test_ragged_sum(self, ragged):
+        df = ragged
+        result = df.rolling(window="1s", min_periods=1).sum()
+        expected = df.copy()
+        expected["B"] = [0.0, 1, 2, 3, 4]
+        tm.assert_frame_equal(result, expected)
+
+        result = df.rolling(window="2s", min_periods=1).sum()
+        expected = df.copy()
+        expected["B"] = [0.0, 1, 3, 3, 7]
+        tm.assert_frame_equal(result, expected)
+
+        result = df.rolling(window="2s", min_periods=2).sum()
+        expected = df.copy()
+        expected["B"] = [np.nan, np.nan, 3, np.nan, 7]
+        tm.assert_frame_equal(result, expected)
+
+        result = df.rolling(window="3s", min_periods=1).sum()
+        expected = df.copy()
+        expected["B"] = [0.0, 1, 3, 5, 7]
+        tm.assert_frame_equal(result, expected)
+
+        result = df.rolling(window="3s").sum()
+        expected = df.copy()
+        expected["B"] = [0.0, 1, 3, 5, 7]
+        tm.assert_frame_equal(result, expected)
+
+        result = df.rolling(window="4s", min_periods=1).sum()
+        expected = df.copy()
+        expected["B"] = [0.0, 1, 3, 6, 9]
+        tm.assert_frame_equal(result, expected)
+
+        result = df.rolling(window="4s", min_periods=3).sum()
+        expected = df.copy()
+        expected["B"] = [np.nan, np.nan, 3, 6, 9]
+        tm.assert_frame_equal(result, expected)
+
+        result = df.rolling(window="5s", min_periods=1).sum()
+        expected = df.copy()
+        expected["B"] = [0.0, 1, 3, 6, 10]
+        tm.assert_frame_equal(result, expected)
+
+    def test_ragged_mean(self, ragged):
+        df = ragged
+        result = df.rolling(window="1s", min_periods=1).mean()
+        expected = df.copy()
+        expected["B"] = [0.0, 1, 2, 3, 4]
+        tm.assert_frame_equal(result, expected)
+
+        result = df.rolling(window="2s", min_periods=1).mean()
+        expected = df.copy()
+        expected["B"] = [0.0, 1, 1.5, 3.0, 3.5]
+        tm.assert_frame_equal(result, expected)
+
+    def test_ragged_median(self, ragged):
+        df = ragged
+        result = df.rolling(window="1s", min_periods=1).median()
+        expected = df.copy()
+        expected["B"] = [0.0, 1, 2, 3, 4]
+        tm.assert_frame_equal(result, expected)
+
+        result = df.rolling(window="2s", min_periods=1).median()
+        expected = df.copy()
+        expected["B"] = [0.0, 1, 1.5, 3.0, 3.5]
+        tm.assert_frame_equal(result, expected)
+
+    def test_ragged_quantile(self, ragged):
+        df = ragged
+        result = df.rolling(window="1s", min_periods=1).quantile(0.5)
+        expected = df.copy()
+        expected["B"] = [0.0, 1, 2, 3, 4]
+        tm.assert_frame_equal(result, expected)
+
+        result = df.rolling(window="2s", min_periods=1).quantile(0.5)
+        expected = df.copy()
+        expected["B"] = [0.0, 1, 1.5, 3.0, 3.5]
+        tm.assert_frame_equal(result, expected)
+
+    def test_ragged_std(self, ragged):
+        df = ragged
+        result = df.rolling(window="1s", min_periods=1).std(ddof=0)
+        expected = df.copy()
+        expected["B"] = [0.0] * 5
+        tm.assert_frame_equal(result, expected)
+
+        result = df.rolling(window="1s", min_periods=1).std(ddof=1)
+        expected = df.copy()
+        expected["B"] = [np.nan] * 5
+        tm.assert_frame_equal(result, expected)
+
+        result = df.rolling(window="3s", min_periods=1).std(ddof=0)
+        expected = df.copy()
+        expected["B"] = [0.0] + [0.5] * 4
+        tm.assert_frame_equal(result, expected)
+
+        result = df.rolling(window="5s", min_periods=1).std(ddof=1)
+        expected = df.copy()
+        expected["B"] = [np.nan, 0.707107, 1.0, 1.0, 1.290994]
+        tm.assert_frame_equal(result, expected)
+
+    def test_ragged_var(self, ragged):
+        df = ragged
+        result = df.rolling(window="1s", min_periods=1).var(ddof=0)
+        expected = df.copy()
+        expected["B"] = [0.0] * 5
+        tm.assert_frame_equal(result, expected)
+
+        result = df.rolling(window="1s", min_periods=1).var(ddof=1)
+        expected = df.copy()
+        expected["B"] = [np.nan] * 5
+        tm.assert_frame_equal(result, expected)
+
+        result = df.rolling(window="3s", min_periods=1).var(ddof=0)
+        expected = df.copy()
+        expected["B"] = [0.0] + [0.25] * 4
+        tm.assert_frame_equal(result, expected)
+
+        result = df.rolling(window="5s", min_periods=1).var(ddof=1)
+        expected = df.copy()
+        expected["B"] = [np.nan, 0.5, 1.0, 1.0, 1 + 2 / 3.0]
+        tm.assert_frame_equal(result, expected)
+
+    def test_ragged_skew(self, ragged):
+        df = ragged
+        result = df.rolling(window="3s", min_periods=1).skew()
+        expected = df.copy()
+        expected["B"] = [np.nan] * 5
+        tm.assert_frame_equal(result, expected)
+
+        result = df.rolling(window="5s", min_periods=1).skew()
+        expected = df.copy()
+        expected["B"] = [np.nan] * 2 + [0.0, 0.0, 0.0]
+        tm.assert_frame_equal(result, expected)
+
+    def test_ragged_kurt(self, ragged):
+        df = ragged
+        result = df.rolling(window="3s", min_periods=1).kurt()
+        expected = df.copy()
+        expected["B"] = [np.nan] * 5
+        tm.assert_frame_equal(result, expected)
+
+        result = df.rolling(window="5s", min_periods=1).kurt()
+        expected = df.copy()
+        expected["B"] = [np.nan] * 4 + [-1.2]
+        tm.assert_frame_equal(result, expected)
+
+    def test_ragged_count(self, ragged):
+        df = ragged
+        result = df.rolling(window="1s", min_periods=1).count()
+        expected = df.copy()
+        expected["B"] = [1.0, 1, 1, 1, 1]
+        tm.assert_frame_equal(result, expected)
+
+        df = ragged
+        result = df.rolling(window="1s").count()
+        tm.assert_frame_equal(result, expected)
+
+        result = df.rolling(window="2s", min_periods=1).count()
+        expected = df.copy()
+        expected["B"] = [1.0, 1, 2, 1, 2]
+        tm.assert_frame_equal(result, expected)
+
+        result = df.rolling(window="2s", min_periods=2).count()
+        expected = df.copy()
+        expected["B"] = [np.nan, np.nan, 2, np.nan, 2]
+        tm.assert_frame_equal(result, expected)
+
+    def test_regular_min(self):
+        df = DataFrame(
+            {"A": date_range("20130101", periods=5, freq="s"), "B": [0.0, 1, 2, 3, 4]}
+        ).set_index("A")
+        result = df.rolling("1s").min()
+        expected = df.copy()
+        expected["B"] = [0.0, 1, 2, 3, 4]
+        tm.assert_frame_equal(result, expected)
+
+        df = DataFrame(
+            {"A": date_range("20130101", periods=5, freq="s"), "B": [5, 4, 3, 4, 5]}
+        ).set_index("A")
+
+        tm.assert_frame_equal(result, expected)
+        result = df.rolling("2s").min()
+        expected = df.copy()
+        expected["B"] = [5.0, 4, 3, 3, 4]
+        tm.assert_frame_equal(result, expected)
+
+        result = df.rolling("5s").min()
+        expected = df.copy()
+        expected["B"] = [5.0, 4, 3, 3, 3]
+        tm.assert_frame_equal(result, expected)
+
+    def test_ragged_min(self, ragged):
+        df = ragged
+
+        result = df.rolling(window="1s", min_periods=1).min()
+        expected = df.copy()
+        expected["B"] = [0.0, 1, 2, 3, 4]
+        tm.assert_frame_equal(result, expected)
+
+        result = df.rolling(window="2s", min_periods=1).min()
+        expected = df.copy()
+        expected["B"] = [0.0, 1, 1, 3, 3]
+        tm.assert_frame_equal(result, expected)
+
+        result = df.rolling(window="5s", min_periods=1).min()
+        expected = df.copy()
+        expected["B"] = [0.0, 0, 0, 1, 1]
+        tm.assert_frame_equal(result, expected)
+
+    def test_perf_min(self):
+        N = 10000
+
+        dfp = DataFrame(
+            {"B": np.random.default_rng(2).standard_normal(N)},
+            index=date_range("20130101", periods=N, freq="s"),
+        )
+        expected = dfp.rolling(2, min_periods=1).min()
+        result = dfp.rolling("2s").min()
+        assert ((result - expected) < 0.01).all().all()
+
+        expected = dfp.rolling(200, min_periods=1).min()
+        result = dfp.rolling("200s").min()
+        assert ((result - expected) < 0.01).all().all()
+
+    def test_ragged_max(self, ragged):
+        df = ragged
+
+        result = df.rolling(window="1s", min_periods=1).max()
+        expected = df.copy()
+        expected["B"] = [0.0, 1, 2, 3, 4]
+        tm.assert_frame_equal(result, expected)
+
+        result = df.rolling(window="2s", min_periods=1).max()
+        expected = df.copy()
+        expected["B"] = [0.0, 1, 2, 3, 4]
+        tm.assert_frame_equal(result, expected)
+
+        result = df.rolling(window="5s", min_periods=1).max()
+        expected = df.copy()
+        expected["B"] = [0.0, 1, 2, 3, 4]
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "freq, op, result_data",
+        [
+            ("ms", "min", [0.0] * 10),
+            ("ms", "mean", [0.0] * 9 + [2.0 / 9]),
+            ("ms", "max", [0.0] * 9 + [2.0]),
+            ("s", "min", [0.0] * 10),
+            ("s", "mean", [0.0] * 9 + [2.0 / 9]),
+            ("s", "max", [0.0] * 9 + [2.0]),
+            ("min", "min", [0.0] * 10),
+            ("min", "mean", [0.0] * 9 + [2.0 / 9]),
+            ("min", "max", [0.0] * 9 + [2.0]),
+            ("h", "min", [0.0] * 10),
+            ("h", "mean", [0.0] * 9 + [2.0 / 9]),
+            ("h", "max", [0.0] * 9 + [2.0]),
+            ("D", "min", [0.0] * 10),
+            ("D", "mean", [0.0] * 9 + [2.0 / 9]),
+            ("D", "max", [0.0] * 9 + [2.0]),
+        ],
+    )
+    def test_freqs_ops(self, freq, op, result_data):
+        # GH 21096
+        index = date_range(start="2018-1-1 01:00:00", freq=f"1{freq}", periods=10)
+        # Explicit cast to float to avoid implicit cast when setting nan
+        s = Series(data=0, index=index, dtype="float")
+        s.iloc[1] = np.nan
+        s.iloc[-1] = 2
+        result = getattr(s.rolling(window=f"10{freq}"), op)()
+        expected = Series(data=result_data, index=index)
+
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "f",
+        [
+            "sum",
+            "mean",
+            "count",
+            "median",
+            "std",
+            "var",
+            "kurt",
+            "skew",
+            "min",
+            "max",
+        ],
+    )
+    def test_all(self, f, regular):
+        # simple comparison of integer vs time-based windowing
+        df = regular * 2
+        er = df.rolling(window=1)
+        r = df.rolling(window="1s")
+
+        result = getattr(r, f)()
+        expected = getattr(er, f)()
+        tm.assert_frame_equal(result, expected)
+
+        result = r.quantile(0.5)
+        expected = er.quantile(0.5)
+        tm.assert_frame_equal(result, expected)
+
+    def test_all2(self, arithmetic_win_operators):
+        f = arithmetic_win_operators
+        # more sophisticated comparison of integer vs.
+        # time-based windowing
+        df = DataFrame(
+            {"B": np.arange(50)}, index=date_range("20130101", periods=50, freq="h")
+        )
+        # in-range data
+        dft = df.between_time("09:00", "16:00")
+
+        r = dft.rolling(window="5h")
+
+        result = getattr(r, f)()
+
+        # we need to roll the days separately
+        # to compare with a time-based roll
+        # finally groupby-apply will return a multi-index
+        # so we need to drop the day
+        def agg_by_day(x):
+            x = x.between_time("09:00", "16:00")
+            return getattr(x.rolling(5, min_periods=1), f)()
+
+        expected = (
+            df.groupby(df.index.day).apply(agg_by_day).reset_index(level=0, drop=True)
+        )
+
+        tm.assert_frame_equal(result, expected)
+
+    def test_rolling_cov_offset(self):
+        # GH16058
+
+        idx = date_range("2017-01-01", periods=24, freq="1h")
+        ss = Series(np.arange(len(idx)), index=idx)
+
+        result = ss.rolling("2h").cov()
+        expected = Series([np.nan] + [0.5] * (len(idx) - 1), index=idx)
+        tm.assert_series_equal(result, expected)
+
+        expected2 = ss.rolling(2, min_periods=1).cov()
+        tm.assert_series_equal(result, expected2)
+
+        result = ss.rolling("3h").cov()
+        expected = Series([np.nan, 0.5] + [1.0] * (len(idx) - 2), index=idx)
+        tm.assert_series_equal(result, expected)
+
+        expected2 = ss.rolling(3, min_periods=1).cov()
+        tm.assert_series_equal(result, expected2)
+
+    def test_rolling_on_decreasing_index(self, unit):
+        # GH-19248, GH-32385
+        index = DatetimeIndex(
+            [
+                Timestamp("20190101 09:00:30"),
+                Timestamp("20190101 09:00:27"),
+                Timestamp("20190101 09:00:20"),
+                Timestamp("20190101 09:00:18"),
+                Timestamp("20190101 09:00:10"),
+            ]
+        ).as_unit(unit)
+
+        df = DataFrame({"column": [3, 4, 4, 5, 6]}, index=index)
+        result = df.rolling("5s").min()
+        expected = DataFrame({"column": [3.0, 3.0, 4.0, 4.0, 6.0]}, index=index)
+        tm.assert_frame_equal(result, expected)
+
+    def test_rolling_on_empty(self):
+        # GH-32385
+        df = DataFrame({"column": []}, index=[])
+        result = df.rolling("5s").min()
+        expected = DataFrame({"column": []}, index=[])
+        tm.assert_frame_equal(result, expected)
+
+    def test_rolling_on_multi_index_level(self):
+        # GH-15584
+        df = DataFrame(
+            {"column": range(6)},
+            index=MultiIndex.from_product(
+                [date_range("20190101", periods=3), range(2)], names=["date", "seq"]
+            ),
+        )
+        result = df.rolling("10d", on=df.index.get_level_values("date")).sum()
+        expected = DataFrame(
+            {"column": [0.0, 1.0, 3.0, 6.0, 10.0, 15.0]}, index=df.index
+        )
+        tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("msg, axis", [["column", 1], ["index", 0]])
+def test_nat_axis_error(msg, axis):
+    idx = [Timestamp("2020"), NaT]
+    kwargs = {"columns" if axis == 1 else "index": idx}
+    df = DataFrame(np.eye(2), **kwargs)
+    warn_msg = "The 'axis' keyword in DataFrame.rolling is deprecated"
+    if axis == 1:
+        warn_msg = "Support for axis=1 in DataFrame.rolling is deprecated"
+    with pytest.raises(ValueError, match=f"{msg} values must not have NaT"):
+        with tm.assert_produces_warning(FutureWarning, match=warn_msg):
+            df.rolling("D", axis=axis).mean()
+
+
+@td.skip_if_no("pyarrow")
+def test_arrow_datetime_axis():
+    # GH 55849
+    expected = Series(
+        np.arange(5, dtype=np.float64),
+        index=Index(
+            date_range("2020-01-01", periods=5), dtype="timestamp[ns][pyarrow]"
+        ),
+    )
+    result = expected.rolling("1D").sum()
+    tm.assert_series_equal(result, expected)
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/test_win_type.py b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/test_win_type.py
new file mode 100644
index 0000000000000000000000000000000000000000..5052019ddb7264c4f81e99ccdd79d88d86865ec4
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/pandas/tests/window/test_win_type.py
@@ -0,0 +1,688 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    DataFrame,
+    Series,
+    Timedelta,
+    concat,
+    date_range,
+)
+import pandas._testing as tm
+from pandas.api.indexers import BaseIndexer
+
+
+@pytest.fixture(
+    params=[
+        "triang",
+        "blackman",
+        "hamming",
+        "bartlett",
+        "bohman",
+        "blackmanharris",
+        "nuttall",
+        "barthann",
+    ]
+)
+def win_types(request):
+    return request.param
+
+
+@pytest.fixture(params=["kaiser", "gaussian", "general_gaussian", "exponential"])
+def win_types_special(request):
+    return request.param
+
+
+def test_constructor(frame_or_series):
+    # GH 12669
+    pytest.importorskip("scipy")
+    c = frame_or_series(range(5)).rolling
+
+    # valid
+    c(win_type="boxcar", window=2, min_periods=1)
+    c(win_type="boxcar", window=2, min_periods=1, center=True)
+    c(win_type="boxcar", window=2, min_periods=1, center=False)
+
+
+@pytest.mark.parametrize("w", [2.0, "foo", np.array([2])])
+def test_invalid_constructor(frame_or_series, w):
+    # not valid
+    pytest.importorskip("scipy")
+    c = frame_or_series(range(5)).rolling
+    with pytest.raises(ValueError, match="min_periods must be an integer"):
+        c(win_type="boxcar", window=2, min_periods=w)
+    with pytest.raises(ValueError, match="center must be a boolean"):
+        c(win_type="boxcar", window=2, min_periods=1, center=w)
+
+
+@pytest.mark.parametrize("wt", ["foobar", 1])
+def test_invalid_constructor_wintype(frame_or_series, wt):
+    pytest.importorskip("scipy")
+    c = frame_or_series(range(5)).rolling
+    with pytest.raises(ValueError, match="Invalid win_type"):
+        c(win_type=wt, window=2)
+
+
+def test_constructor_with_win_type(frame_or_series, win_types):
+    # GH 12669
+    pytest.importorskip("scipy")
+    c = frame_or_series(range(5)).rolling
+    c(win_type=win_types, window=2)
+
+
+@pytest.mark.parametrize("arg", ["median", "kurt", "skew"])
+def test_agg_function_support(arg):
+    pytest.importorskip("scipy")
+    df = DataFrame({"A": np.arange(5)})
+    roll = df.rolling(2, win_type="triang")
+
+    msg = f"'{arg}' is not a valid function for 'Window' object"
+    with pytest.raises(AttributeError, match=msg):
+        roll.agg(arg)
+
+    with pytest.raises(AttributeError, match=msg):
+        roll.agg([arg])
+
+    with pytest.raises(AttributeError, match=msg):
+        roll.agg({"A": arg})
+
+
+def test_invalid_scipy_arg():
+    # This error is raised by scipy
+    pytest.importorskip("scipy")
+    msg = r"boxcar\(\) got an unexpected"
+    with pytest.raises(TypeError, match=msg):
+        Series(range(3)).rolling(1, win_type="boxcar").mean(foo="bar")
+
+
+def test_constructor_with_win_type_invalid(frame_or_series):
+    # GH 13383
+    pytest.importorskip("scipy")
+    c = frame_or_series(range(5)).rolling
+
+    msg = "window must be an integer 0 or greater"
+
+    with pytest.raises(ValueError, match=msg):
+        c(-1, win_type="boxcar")
+
+
+def test_window_with_args(step):
+    # make sure that we are aggregating window functions correctly with arg
+    pytest.importorskip("scipy")
+    r = Series(np.random.default_rng(2).standard_normal(100)).rolling(
+        window=10, min_periods=1, win_type="gaussian", step=step
+    )
+    expected = concat([r.mean(std=10), r.mean(std=0.01)], axis=1)
+    expected.columns = ["<lambda>", "<lambda>"]
+    result = r.aggregate([lambda x: x.mean(std=10), lambda x: x.mean(std=0.01)])
+    tm.assert_frame_equal(result, expected)
+
+    def a(x):
+        return x.mean(std=10)
+
+    def b(x):
+        return x.mean(std=0.01)
+
+    expected = concat([r.mean(std=10), r.mean(std=0.01)], axis=1)
+    expected.columns = ["a", "b"]
+    result = r.aggregate([a, b])
+    tm.assert_frame_equal(result, expected)
+
+
+def test_win_type_with_method_invalid():
+    pytest.importorskip("scipy")
+    with pytest.raises(
+        NotImplementedError, match="'single' is the only supported method type."
+    ):
+        Series(range(1)).rolling(1, win_type="triang", method="table")
+
+
+@pytest.mark.parametrize("arg", [2000000000, "2s", Timedelta("2s")])
+def test_consistent_win_type_freq(arg):
+    # GH 15969
+    pytest.importorskip("scipy")
+    s = Series(range(1))
+    with pytest.raises(ValueError, match="Invalid win_type freq"):
+        s.rolling(arg, win_type="freq")
+
+
+def test_win_type_freq_return_none():
+    # GH 48838
+    freq_roll = Series(range(2), index=date_range("2020", periods=2)).rolling("2s")
+    assert freq_roll.win_type is None
+
+
+def test_win_type_not_implemented():
+    pytest.importorskip("scipy")
+
+    class CustomIndexer(BaseIndexer):
+        def get_window_bounds(self, num_values, min_periods, center, closed, step):
+            return np.array([0, 1]), np.array([1, 2])
+
+    df = DataFrame({"values": range(2)})
+    indexer = CustomIndexer()
+    with pytest.raises(NotImplementedError, match="BaseIndexer subclasses not"):
+        df.rolling(indexer, win_type="boxcar")
+
+
+def test_cmov_mean(step):
+    # GH 8238
+    pytest.importorskip("scipy")
+    vals = np.array([6.95, 15.21, 4.72, 9.12, 13.81, 13.49, 16.68, 9.48, 10.63, 14.48])
+    result = Series(vals).rolling(5, center=True, step=step).mean()
+    expected_values = [
+        np.nan,
+        np.nan,
+        9.962,
+        11.27,
+        11.564,
+        12.516,
+        12.818,
+        12.952,
+        np.nan,
+        np.nan,
+    ]
+    expected = Series(expected_values)[::step]
+    tm.assert_series_equal(expected, result)
+
+
+def test_cmov_window(step):
+    # GH 8238
+    pytest.importorskip("scipy")
+    vals = np.array([6.95, 15.21, 4.72, 9.12, 13.81, 13.49, 16.68, 9.48, 10.63, 14.48])
+    result = Series(vals).rolling(5, win_type="boxcar", center=True, step=step).mean()
+    expected_values = [
+        np.nan,
+        np.nan,
+        9.962,
+        11.27,
+        11.564,
+        12.516,
+        12.818,
+        12.952,
+        np.nan,
+        np.nan,
+    ]
+    expected = Series(expected_values)[::step]
+    tm.assert_series_equal(expected, result)
+
+
+def test_cmov_window_corner(step):
+    # GH 8238
+    # all nan
+    pytest.importorskip("scipy")
+    vals = Series([np.nan] * 10)
+    result = vals.rolling(5, center=True, win_type="boxcar", step=step).mean()
+    assert np.isnan(result).all()
+
+    # empty
+    vals = Series([], dtype=object)
+    result = vals.rolling(5, center=True, win_type="boxcar", step=step).mean()
+    assert len(result) == 0
+
+    # shorter than window
+    vals = Series(np.random.default_rng(2).standard_normal(5))
+    result = vals.rolling(10, win_type="boxcar", step=step).mean()
+    assert np.isnan(result).all()
+    assert len(result) == len(range(0, 5, step or 1))
+
+
+@pytest.mark.parametrize(
+    "f,xp",
+    [
+        (
+            "mean",
+            [
+                [np.nan, np.nan],
+                [np.nan, np.nan],
+                [9.252, 9.392],
+                [8.644, 9.906],
+                [8.87, 10.208],
+                [6.81, 8.588],
+                [7.792, 8.644],
+                [9.05, 7.824],
+                [np.nan, np.nan],
+                [np.nan, np.nan],
+            ],
+        ),
+        (
+            "std",
+            [
+                [np.nan, np.nan],
+                [np.nan, np.nan],
+                [3.789706, 4.068313],
+                [3.429232, 3.237411],
+                [3.589269, 3.220810],
+                [3.405195, 2.380655],
+                [3.281839, 2.369869],
+                [3.676846, 1.801799],
+                [np.nan, np.nan],
+                [np.nan, np.nan],
+            ],
+        ),
+        (
+            "var",
+            [
+                [np.nan, np.nan],
+                [np.nan, np.nan],
+                [14.36187, 16.55117],
+                [11.75963, 10.48083],
+                [12.88285, 10.37362],
+                [11.59535, 5.66752],
+                [10.77047, 5.61628],
+                [13.51920, 3.24648],
+                [np.nan, np.nan],
+                [np.nan, np.nan],
+            ],
+        ),
+        (
+            "sum",
+            [
+                [np.nan, np.nan],
+                [np.nan, np.nan],
+                [46.26, 46.96],
+                [43.22, 49.53],
+                [44.35, 51.04],
+                [34.05, 42.94],
+                [38.96, 43.22],
+                [45.25, 39.12],
+                [np.nan, np.nan],
+                [np.nan, np.nan],
+            ],
+        ),
+    ],
+)
+def test_cmov_window_frame(f, xp, step):
+    # Gh 8238
+    pytest.importorskip("scipy")
+    df = DataFrame(
+        np.array(
+            [
+                [12.18, 3.64],
+                [10.18, 9.16],
+                [13.24, 14.61],
+                [4.51, 8.11],
+                [6.15, 11.44],
+                [9.14, 6.21],
+                [11.31, 10.67],
+                [2.94, 6.51],
+                [9.42, 8.39],
+                [12.44, 7.34],
+            ]
+        )
+    )
+    xp = DataFrame(np.array(xp))[::step]
+
+    roll = df.rolling(5, win_type="boxcar", center=True, step=step)
+    rs = getattr(roll, f)()
+
+    tm.assert_frame_equal(xp, rs)
+
+
+@pytest.mark.parametrize("min_periods", [0, 1, 2, 3, 4, 5])
+def test_cmov_window_na_min_periods(step, min_periods):
+    pytest.importorskip("scipy")
+    vals = Series(np.random.default_rng(2).standard_normal(10))
+    vals[4] = np.nan
+    vals[8] = np.nan
+
+    xp = vals.rolling(5, min_periods=min_periods, center=True, step=step).mean()
+    rs = vals.rolling(
+        5, win_type="boxcar", min_periods=min_periods, center=True, step=step
+    ).mean()
+    tm.assert_series_equal(xp, rs)
+
+
+def test_cmov_window_regular(win_types, step):
+    # GH 8238
+    pytest.importorskip("scipy")
+    vals = np.array([6.95, 15.21, 4.72, 9.12, 13.81, 13.49, 16.68, 9.48, 10.63, 14.48])
+    xps = {
+        "hamming": [
+            np.nan,
+            np.nan,
+            8.71384,
+            9.56348,
+            12.38009,
+            14.03687,
+            13.8567,
+            11.81473,
+            np.nan,
+            np.nan,
+        ],
+        "triang": [
+            np.nan,
+            np.nan,
+            9.28667,
+            10.34667,
+            12.00556,
+            13.33889,
+            13.38,
+            12.33667,
+            np.nan,
+            np.nan,
+        ],
+        "barthann": [
+            np.nan,
+            np.nan,
+            8.4425,
+            9.1925,
+            12.5575,
+            14.3675,
+            14.0825,
+            11.5675,
+            np.nan,
+            np.nan,
+        ],
+        "bohman": [
+            np.nan,
+            np.nan,
+            7.61599,
+            9.1764,
+            12.83559,
+            14.17267,
+            14.65923,
+            11.10401,
+            np.nan,
+            np.nan,
+        ],
+        "blackmanharris": [
+            np.nan,
+            np.nan,
+            6.97691,
+            9.16438,
+            13.05052,
+            14.02156,
+            15.10512,
+            10.74574,
+            np.nan,
+            np.nan,
+        ],
+        "nuttall": [
+            np.nan,
+            np.nan,
+            7.04618,
+            9.16786,
+            13.02671,
+            14.03559,
+            15.05657,
+            10.78514,
+            np.nan,
+            np.nan,
+        ],
+        "blackman": [
+            np.nan,
+            np.nan,
+            7.73345,
+            9.17869,
+            12.79607,
+            14.20036,
+            14.57726,
+            11.16988,
+            np.nan,
+            np.nan,
+        ],
+        "bartlett": [
+            np.nan,
+            np.nan,
+            8.4425,
+            9.1925,
+            12.5575,
+            14.3675,
+            14.0825,
+            11.5675,
+            np.nan,
+            np.nan,
+        ],
+    }
+
+    xp = Series(xps[win_types])[::step]
+    rs = Series(vals).rolling(5, win_type=win_types, center=True, step=step).mean()
+    tm.assert_series_equal(xp, rs)
+
+
+def test_cmov_window_regular_linear_range(win_types, step):
+    # GH 8238
+    pytest.importorskip("scipy")
+    vals = np.array(range(10), dtype=float)
+    xp = vals.copy()
+    xp[:2] = np.nan
+    xp[-2:] = np.nan
+    xp = Series(xp)[::step]
+
+    rs = Series(vals).rolling(5, win_type=win_types, center=True, step=step).mean()
+    tm.assert_series_equal(xp, rs)
+
+
+def test_cmov_window_regular_missing_data(win_types, step):
+    # GH 8238
+    pytest.importorskip("scipy")
+    vals = np.array(
+        [6.95, 15.21, 4.72, 9.12, 13.81, 13.49, 16.68, np.nan, 10.63, 14.48]
+    )
+    xps = {
+        "bartlett": [
+            np.nan,
+            np.nan,
+            9.70333,
+            10.5225,
+            8.4425,
+            9.1925,
+            12.5575,
+            14.3675,
+            15.61667,
+            13.655,
+        ],
+        "blackman": [
+            np.nan,
+            np.nan,
+            9.04582,
+            11.41536,
+            7.73345,
+            9.17869,
+            12.79607,
+            14.20036,
+            15.8706,
+            13.655,
+        ],
+        "barthann": [
+            np.nan,
+            np.nan,
+            9.70333,
+            10.5225,
+            8.4425,
+            9.1925,
+            12.5575,
+            14.3675,
+            15.61667,
+            13.655,
+        ],
+        "bohman": [
+            np.nan,
+            np.nan,
+            8.9444,
+            11.56327,
+            7.61599,
+            9.1764,
+            12.83559,
+            14.17267,
+            15.90976,
+            13.655,
+        ],
+        "hamming": [
+            np.nan,
+            np.nan,
+            9.59321,
+            10.29694,
+            8.71384,
+            9.56348,
+            12.38009,
+            14.20565,
+            15.24694,
+            13.69758,
+        ],
+        "nuttall": [
+            np.nan,
+            np.nan,
+            8.47693,
+            12.2821,
+            7.04618,
+            9.16786,
+            13.02671,
+            14.03673,
+            16.08759,
+            13.65553,
+        ],
+        "triang": [
+            np.nan,
+            np.nan,
+            9.33167,
+            9.76125,
+            9.28667,
+            10.34667,
+            12.00556,
+            13.82125,
+            14.49429,
+            13.765,
+        ],
+        "blackmanharris": [
+            np.nan,
+            np.nan,
+            8.42526,
+            12.36824,
+            6.97691,
+            9.16438,
+            13.05052,
+            14.02175,
+            16.1098,
+            13.65509,
+        ],
+    }
+
+    xp = Series(xps[win_types])[::step]
+    rs = Series(vals).rolling(5, win_type=win_types, min_periods=3, step=step).mean()
+    tm.assert_series_equal(xp, rs)
+
+
+def test_cmov_window_special(win_types_special, step):
+    # GH 8238
+    pytest.importorskip("scipy")
+    kwds = {
+        "kaiser": {"beta": 1.0},
+        "gaussian": {"std": 1.0},
+        "general_gaussian": {"p": 2.0, "sig": 2.0},
+        "exponential": {"tau": 10},
+    }
+
+    vals = np.array([6.95, 15.21, 4.72, 9.12, 13.81, 13.49, 16.68, 9.48, 10.63, 14.48])
+
+    xps = {
+        "gaussian": [
+            np.nan,
+            np.nan,
+            8.97297,
+            9.76077,
+            12.24763,
+            13.89053,
+            13.65671,
+            12.01002,
+            np.nan,
+            np.nan,
+        ],
+        "general_gaussian": [
+            np.nan,
+            np.nan,
+            9.85011,
+            10.71589,
+            11.73161,
+            13.08516,
+            12.95111,
+            12.74577,
+            np.nan,
+            np.nan,
+        ],
+        "kaiser": [
+            np.nan,
+            np.nan,
+            9.86851,
+            11.02969,
+            11.65161,
+            12.75129,
+            12.90702,
+            12.83757,
+            np.nan,
+            np.nan,
+        ],
+        "exponential": [
+            np.nan,
+            np.nan,
+            9.83364,
+            11.10472,
+            11.64551,
+            12.66138,
+            12.92379,
+            12.83770,
+            np.nan,
+            np.nan,
+        ],
+    }
+
+    xp = Series(xps[win_types_special])[::step]
+    rs = (
+        Series(vals)
+        .rolling(5, win_type=win_types_special, center=True, step=step)
+        .mean(**kwds[win_types_special])
+    )
+    tm.assert_series_equal(xp, rs)
+
+
+def test_cmov_window_special_linear_range(win_types_special, step):
+    # GH 8238
+    pytest.importorskip("scipy")
+    kwds = {
+        "kaiser": {"beta": 1.0},
+        "gaussian": {"std": 1.0},
+        "general_gaussian": {"p": 2.0, "sig": 2.0},
+        "slepian": {"width": 0.5},
+        "exponential": {"tau": 10},
+    }
+
+    vals = np.array(range(10), dtype=float)
+    xp = vals.copy()
+    xp[:2] = np.nan
+    xp[-2:] = np.nan
+    xp = Series(xp)[::step]
+
+    rs = (
+        Series(vals)
+        .rolling(5, win_type=win_types_special, center=True, step=step)
+        .mean(**kwds[win_types_special])
+    )
+    tm.assert_series_equal(xp, rs)
+
+
+def test_weighted_var_big_window_no_segfault(win_types, center):
+    # GitHub Issue #46772
+    pytest.importorskip("scipy")
+    x = Series(0)
+    result = x.rolling(window=16, center=center, win_type=win_types).var()
+    expected = Series(np.nan)
+
+    tm.assert_series_equal(result, expected)
+
+
+def test_rolling_center_axis_1():
+    pytest.importorskip("scipy")
+    df = DataFrame(
+        {"a": [1, 1, 0, 0, 0, 1], "b": [1, 0, 0, 1, 0, 0], "c": [1, 0, 0, 1, 0, 1]}
+    )
+
+    msg = "Support for axis=1 in DataFrame.rolling is deprecated"
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        result = df.rolling(window=3, axis=1, win_type="boxcar", center=True).sum()
+
+    expected = DataFrame(
+        {"a": [np.nan] * 6, "b": [3.0, 1.0, 0.0, 2.0, 0.0, 2.0], "c": [np.nan] * 6}
+    )
+
+    tm.assert_frame_equal(result, expected, check_dtype=True)