Add more overflow tests for timedelta64 operations

pandas/tests/arithmetic/test_timedelta64.py

@@ -4,7 +4,20 @@
     datetime,
     timedelta,
 )
+from itertools import (
+    chain,
+    combinations_with_replacement,
+    product,
+)
+from operator import attrgetter
+from typing import (
+    NamedTuple,
+    Type,
+    Union,
+)
 
+from hypothesis import given
+import hypothesis.strategies as st
 import numpy as np
 import pytest
 
@@ -31,12 +44,92 @@
     Int64Index,
     UInt64Index,
 )
+from pandas.core.arrays import (
+    DatetimeArray,
+    TimedeltaArray,
+)
 from pandas.tests.arithmetic.common import (
     assert_invalid_addsub_type,
     assert_invalid_comparison,
     get_upcast_box,
 )
 
+timedelta_types = (Timedelta, TimedeltaArray, TimedeltaIndex, Series, DataFrame)
+timestamp_types = (Timestamp, DatetimeArray, DatetimeIndex, Series, DataFrame)
+containers = slice(1, None)
+get_item_names = lambda t: "-".join(map(attrgetter("__name__"), t))
+
+
+class BinaryOpTypes(NamedTuple):
+    """
+    The expected operand and result types for a binary operation.
+    """
+
+    left: Type
+    right: Type
+    result: Type
+
+    def __str__(self) -> str:
+        return get_item_names(self)
+
+    def __repr__(self) -> str:
+        return f"BinaryOpTypes({self})"
+
+
+positive_tds = st.integers(min_value=1, max_value=Timedelta.max.value).map(Timedelta)
+
+xfail_no_overflow_check = pytest.mark.xfail(reason="No overflow check")
+
+
+@pytest.fixture(
+    name="add_sub_types",
+    scope="module",
+    params=tuple(combinations_with_replacement(timedelta_types, 2)),
+    ids=get_item_names,
+)
+def fixture_add_sub_types(request) -> BinaryOpTypes:
+    """
+    Expected types when adding, subtracting Timedeltas.
+    """
+    return_type = max(request.param, key=lambda t: timedelta_types.index(t))
+    return BinaryOpTypes(request.param[0], request.param[1], return_type)
+
+
+@pytest.fixture(
+    name="ts_add_sub_types",
+    scope="module",
+    params=tuple(product(timedelta_types, timestamp_types)),
+    ids=get_item_names,
+)
+def fixture_ts_add_sub_types(request) -> BinaryOpTypes:
+    """
+    Expected types when adding, subtracting Timedeltas and Timestamps.
+    """
+    type_hierarchy = {
+        name: i
+        for i, name in chain(enumerate(timedelta_types), enumerate(timestamp_types))
+    }
+    return_type = timestamp_types[max(type_hierarchy[t] for t in request.param)]
+
+    return BinaryOpTypes(request.param[0], request.param[1], return_type)
+
+
+def wrap_value(value: Union[Timestamp, Timedelta], type_):
+    """
+    Return value wrapped in a container of given type_, or as-is if type_ is a scalar.
+    """
+    if issubclass(type_, (Timedelta, Timestamp)):
+        return type_(value)
+
+    if issubclass(type_, pd.core.arrays.ExtensionArray):
+        box_cls = pd.array
+    elif issubclass(type_, pd.Index):
+        box_cls = pd.Index
+    else:
+        box_cls = type_
+
+    return type_(tm.box_expected([value], box_cls))
+
 
 def assert_dtype(obj, expected_dtype):
     """
@@ -275,6 +368,123 @@ def test_comparisons_coverage(self):
 # Timedelta64[ns] dtype Arithmetic Operations
 
 
+@given(positive_td=positive_tds)
+def test_add_raises_expected_error_if_result_would_overflow(
+    add_sub_types: BinaryOpTypes,
+    positive_td: Timedelta,
+):
+    left = wrap_value(Timedelta.max, add_sub_types.left)
+    right = wrap_value(positive_td, add_sub_types.right)
+
+    if add_sub_types.result is Timedelta:
+        msg = "|".join(
+            [
+                "int too big to convert",
+                "Python int too large to convert to C long",
+            ]
+        )
+    else:
+        msg = "Overflow in int64 addition"
+
+    with pytest.raises(OverflowError, match=msg):
+        left + right
+
+    with pytest.raises(OverflowError, match=msg):
+        right + left
+
+
+@xfail_no_overflow_check
+@given(positive_td=positive_tds)
+def test_sub_raises_expected_error_if_result_would_overflow(
+    add_sub_types: BinaryOpTypes,
+    positive_td: Timedelta,
+):
+    left = wrap_value(Timedelta.min, add_sub_types.left)
+    right = wrap_value(positive_td, add_sub_types.right)
+
+    msg = "Overflow in int64 addition"
+    with pytest.raises(OverflowError, match=msg):
+        left - right
+
+    with pytest.raises(OverflowError, match=msg):
+        (-1 * right) - abs(left)
+
+
+@given(td_value=positive_tds)
+def test_add_timestamp_raises_expected_error_if_result_would_overflow(
+    ts_add_sub_types: BinaryOpTypes,
+    td_value: Timedelta,
+):
+    left = wrap_value(td_value, ts_add_sub_types.left)
+    right = wrap_value(Timestamp.max, ts_add_sub_types.right)
+
+    ex = (OutOfBoundsDatetime, OverflowError)
+    msg = "|".join(["Out of bounds nanosecond timestamp", "Overflow in int64 addition"])
+
+    with pytest.raises(ex, match=msg):
+        left + right
+
+    with pytest.raises(ex, match=msg):
+        right + left
+
+
+@xfail_no_overflow_check
+@given(td_value=positive_tds)
+def test_sub_timestamp_raises_expected_error_if_result_would_overflow(
+    ts_add_sub_types: BinaryOpTypes,
+    td_value: Timedelta,
+):
+    right = wrap_value(td_value, ts_add_sub_types[0])
+    left = wrap_value(Timestamp.min, ts_add_sub_types[1])
+
+    ex = (OutOfBoundsDatetime, OverflowError)
+    msg = "|".join(["Out of bounds nanosecond timestamp", "Overflow in int64 addition"])
+
+    with pytest.raises(ex, match=msg):
+        left - right
+
+
+@given(value=st.floats().filter(lambda f: abs(f) > 1))
+def test_scalar_multiplication_raises_expected_error_if_result_would_overflow(
+    value: float,
+):
+    td = Timedelta.max
+
+    msg = "|".join(
+        [
+            "cannot convert float infinity to integer",
+            "Python int too large to convert to C long",
+            "int too big to convert",
+        ]
+    )
+    with pytest.raises(OverflowError, match=msg):
+        td * value
+
+    with pytest.raises(OverflowError, match=msg):
+        value * td
+
+
+@xfail_no_overflow_check
+@given(value=st.floats().filter(lambda f: abs(f) > 1))
+@pytest.mark.parametrize(
+    argnames="td_type",
+    argvalues=timedelta_types[containers],  # type: ignore[arg-type]
+    ids=attrgetter("__name__"),
+)
+def test_container_scalar_multiplication_raises_expected_error_if_result_would_overflow(
+    value: float,
+    td_type: Type,
+):
+    td = wrap_value(Timedelta.max, td_type)
+
+    msg = "Overflow in int64 addition"
+    with pytest.raises(OverflowError, match=msg):
+        td * value
+
+    with pytest.raises(OverflowError, match=msg):
+        value * td
+
+
 class TestTimedelta64ArithmeticUnsorted:
     # Tests moved from type-specific test files but not
     #  yet sorted/parametrized/de-duplicated
@@ -687,30 +897,6 @@ def test_tdarr_add_timestamp_nat_masking(self, box_with_array, str_ts):
                 assert res[1] is NaT
 
     def test_tdi_add_overflow(self):
-        # See GH#14068
-        # preliminary test scalar analogue of vectorized tests below
-        # TODO: Make raised error message more informative and test
-        with pytest.raises(OutOfBoundsDatetime, match="10155196800000000000"):
-            pd.to_timedelta(106580, "D") + Timestamp("2000")
-        with pytest.raises(OutOfBoundsDatetime, match="10155196800000000000"):
-            Timestamp("2000") + pd.to_timedelta(106580, "D")
-
-        _NaT = NaT.value + 1
-        msg = "Overflow in int64 addition"
-        with pytest.raises(OverflowError, match=msg):
-            pd.to_timedelta([106580], "D") + Timestamp("2000")
-        with pytest.raises(OverflowError, match=msg):
-            Timestamp("2000") + pd.to_timedelta([106580], "D")
-        with pytest.raises(OverflowError, match=msg):
-            pd.to_timedelta([_NaT]) - Timedelta("1 days")
-        with pytest.raises(OverflowError, match=msg):
-            pd.to_timedelta(["5 days", _NaT]) - Timedelta("1 days")
-        with pytest.raises(OverflowError, match=msg):
-            (
-                pd.to_timedelta([_NaT, "5 days", "1 hours"])
-                - pd.to_timedelta(["7 seconds", _NaT, "4 hours"])
-            )
-
         # These should not overflow!
         exp = TimedeltaIndex([NaT])
         result = pd.to_timedelta([NaT]) - Timedelta("1 days")

pandas/tests/series/test_reductions.py

@@ -1,3 +1,5 @@
+from hypothesis import given
+import hypothesis.strategies as st
 import numpy as np
 import pytest
 
@@ -51,29 +53,71 @@ def test_td64_sum_empty(skipna):
     assert result == pd.Timedelta(0)
 
 
-def test_td64_summation_overflow():
-    # GH#9442
-    ser = Series(pd.date_range("20130101", periods=100000, freq="H"))
-    ser[0] += pd.Timedelta("1s 1ms")
+@given(
+    st.integers(
+        min_value=0,
+        max_value=10 ** (np.finfo(np.float64).precision),
+    ).map(pd.Timedelta)
+)
+def test_td64_summation_retains_ns_precision_over_expected_range(value: pd.Timedelta):
+    result = Series(value).sum()
 
-    # mean
-    result = (ser - ser.min()).mean()
-    expected = pd.Timedelta((pd.TimedeltaIndex(ser - ser.min()).asi8 / len(ser)).sum())
+    assert result == value
 
-    # the computation is converted to float so
-    # might be some loss of precision
-    assert np.allclose(result.value / 1000, expected.value / 1000)
 
-    # sum
-    msg = "overflow in timedelta operation"
-    with pytest.raises(ValueError, match=msg):
-        (ser - ser.min()).sum()
+@given(
+    st.integers(
+        min_value=10 ** (np.finfo(np.float64).precision),
+        max_value=pd.Timedelta.max.value - 2**9,
+    )
+    .filter(lambda i: int(np.float64(i)) != i)
+    .map(pd.Timedelta)
+)
+def test_td64_summation_loses_ns_precision_if_float_conversion_rounds(
+    value: pd.Timedelta,
+):
+    result = Series(value).sum()
+
+    assert result != value
+
+
+@given(
+    st.integers(
+        min_value=pd.Timedelta.max.value - 2**9 + 1,
+        max_value=pd.Timedelta.max.value,
+    ).map(pd.Timedelta)
+)
+def test_td64_summation_raises_spurious_overflow_error_for_single_elem_series(
+    value: pd.Timedelta,
+):
+    s = Series(value)
 
-    s1 = ser[0:10000]
+    msg = "int too big to convert|Python int too large to convert to C long"
+    with pytest.raises(OverflowError, match=msg):
+        s.sum()
+
+
+@given(st.integers(min_value=1, max_value=2**10).map(pd.Timedelta))
+def test_td64_summation_raises_overflow_error_for_small_overflows(value: pd.Timedelta):
+    s = Series([pd.Timedelta.max, value])
+
+    msg = "int too big to convert|Python int too large to convert to C long"
+    with pytest.raises(OverflowError, match=msg):
+        s.sum()
+
+
+@given(
+    st.integers(
+        min_value=2**10 + 1,
+        max_value=pd.Timedelta.max.value,
+    ).map(pd.Timedelta)
+)
+def test_td64_summation_raises_value_error_for_most_overflows(value: pd.Timedelta):
+    s = Series([pd.Timedelta.max, value])
+
+    msg = "overflow in timedelta operation"
     with pytest.raises(ValueError, match=msg):
-        (s1 - s1.min()).sum()
-    s2 = ser[0:1000]
-    (s2 - s2.min()).sum()
+        s.sum()
 
 
 def test_prod_numpy16_bug():