new test cases for GH#22591

demonstrates loss of precision and requires no UserWarning is
raised for non standard frequencies

Author: miccoli

pandas/tests/indexes/datetimes/test_scalar_compat.py

@@ -11,6 +11,7 @@
 import pandas as pd
 
 from pandas import date_range, Timestamp, DatetimeIndex
+from pandas.tseries.frequencies import to_offset
 
 
 class TestDatetimeIndexOps(object):
@@ -124,7 +125,7 @@ def test_round(self, tz_naive_fixture):
         expected = DatetimeIndex(['2016-10-17 12:00:00.001501030'])
         tm.assert_index_equal(result, expected)
 
-        with tm.assert_produces_warning():
+        with tm.assert_produces_warning(False):
             ts = '2016-10-17 12:00:00.001501031'
             DatetimeIndex([ts]).round('1010ns')
 
@@ -169,6 +170,43 @@ def test_ceil_floor_edge(self, test_input, rounder, freq, expected):
         expected = DatetimeIndex(list(expected))
         assert expected.equals(result)
 
+    @pytest.mark.parametrize('start, index_freq, periods', [
+        ('2018-01-01', '12H', 25),
+        ('2018-01-01 0:0:0.124999', '1ns', 1000),
+    ])
+    @pytest.mark.parametrize('rounding_freq', [
+        '2ns', '3ns', '4ns', '5ns', '6ns', '7ns',
+        '250ns', '500ns', '750ns',
+        '1us', '19us', '250us', '500us', '750us',
+        '1s', '2s', '3s',
+        '12H', '1D',
+    ])
+    def test_round_int64(self, start, index_freq, periods, rounding_freq):
+        dt = DatetimeIndex(start=start, freq=index_freq, periods=periods)
+        unit = to_offset(rounding_freq).nanos
+        # test floor
+        result = dt.floor(rounding_freq).asi8
+        diff = dt.asi8 - result
+        mod = result % unit
+        assert (mod == 0).all(), "floor not a %s multiple" % (rounding_freq, )
+        assert (0 <= diff).all() and (diff < unit).all(), "floor error"
+        # test ceil
+        result = dt.ceil(rounding_freq).asi8
+        diff = result - dt.asi8
+        mod = result % unit
+        assert (mod == 0).all(), "ceil not a %s multiple" % (rounding_freq, )
+        assert (0 <= diff).all() and (diff < unit).all(), "ceil error"
+        # test round
+        result = dt.round(rounding_freq).asi8
+        diff = abs(result - dt.asi8)
+        mod = result % unit
+        assert (mod == 0).all(), "round not a %s multiple" % (rounding_freq, )
+        assert (diff <= unit // 2).all(), "round error"
+        if unit % 2 == 0:
+            assert (
+                result[diff == unit // 2] % 2 == 0
+            ).all(), "round half to even error"
+
     # ----------------------------------------------------------------
     # DatetimeIndex.normalize
 

pandas/tests/scalar/timestamp/test_unary_ops.py

@@ -13,6 +13,7 @@
 from pandas._libs.tslibs import conversion
 from pandas._libs.tslibs.frequencies import INVALID_FREQ_ERR_MSG
 from pandas import Timestamp, NaT
+from pandas.tseries.frequencies import to_offset
 
 
 class TestTimestampUnaryOps(object):
@@ -70,7 +71,7 @@ def test_round_subsecond(self):
         assert result == expected
 
     def test_round_nonstandard_freq(self):
-        with tm.assert_produces_warning():
+        with tm.assert_produces_warning(False):
             Timestamp('2016-10-17 12:00:00.001501031').round('1010ns')
 
     def test_round_invalid_arg(self):
@@ -154,6 +155,43 @@ def test_round_dst_border(self, method):
         with pytest.raises(pytz.AmbiguousTimeError):
             getattr(ts, method)('H', ambiguous='raise')
 
+    @pytest.mark.parametrize('timestamp', [
+        '2018-01-01 0:0:0.124999360',
+        '2018-01-01 0:0:0.125000367',
+        '2018-01-01 0:0:0.125500',
+        '2018-01-01 0:0:0.126500',
+        '2018-01-01 12:00:00',
+        '2019-01-01 12:00:00',
+    ])
+    @pytest.mark.parametrize('freq', [
+        '2ns', '3ns', '4ns', '5ns', '6ns', '7ns',
+        '250ns', '500ns', '750ns',
+        '1us', '19us', '250us', '500us', '750us',
+        '1s', '2s', '3s',
+        '1D',
+    ])
+    def test_round_int64(self, timestamp, freq):
+        """check that all rounding modes are accurate to int64 precision
+           see GH#22591
+        """
+        dt = Timestamp(timestamp)
+        unit = to_offset(freq).nanos
+        # test floor
+        result = dt.floor(freq)
+        assert result.value % unit == 0, "floor not a %s multiple" % (freq, )
+        assert 0 <= dt.value - result.value < unit, "floor error"
+        # test ceil
+        result = dt.ceil(freq)
+        assert result.value % unit == 0, "ceil not a %s multiple" % (freq, )
+        assert 0 <= result.value - dt.value < unit, "ceil error"
+        # test round
+        result = dt.round(freq)
+        assert result.value % unit == 0, "round not a %s multiple" % (freq, )
+        assert abs(result.value - dt.value) <= unit // 2, "round error"
+        if unit % 2 == 0 and abs(result.value - dt.value) == unit // 2:
+            # round half to even
+            assert result.value // unit % 2 == 0, "round half to even error"
+
     # --------------------------------------------------------------
     # Timestamp.replace