create test_nat.py & consolidate tests

Author: jreback

pandas/tests/scalar/common.py

@@ -0,0 +1,12 @@
+""" scalar common ops """
+
+
+class Base(object):
+
+    # all accessors fields
+    _field_accessors = ['year', 'month', 'day', 'hour', 'minute', 'second',
+                        'microsecond', 'nanosecond', 'dayofweek', 'quarter',
+                        'dayofyear', 'week', 'daysinmonth', 'days_in_month']
+    _bool_accessors = ['is_month_start', 'is_quarter_start', 'is_year_start',
+                       'is_month_end', 'is_quarter_end', 'is_year_end',
+                       'is_leap_year']

pandas/tests/scalar/test_nat.py

@@ -0,0 +1,240 @@
+import pytest
+
+from datetime import datetime, timedelta
+import pytz
+
+import numpy as np
+from pandas import (NaT, Timestamp, Timedelta, Period, DatetimeIndex,
+                    TimedeltaIndex, Series, isnull)
+from pandas.util import testing as tm
+from pandas._libs.tslib import iNaT
+from .common import Base
+
+
+class TestNaT(Base):
+
+    def test_nat_for_period(self):
+        p = Period('NaT', freq='M')
+
+        # confirm Period('NaT') work identical with Timestamp('NaT')
+        for f in ['year', 'month', 'day', 'hour', 'minute', 'second', 'week',
+                  'dayofyear', 'quarter', 'days_in_month']:
+            assert np.isnan(getattr(p, f))
+
+    def test_nat_fields(self):
+        # GH 10050
+        ts = Timestamp('NaT')
+
+        for field in self._field_accessors:
+
+            result = getattr(NaT, field)
+            assert np.isnan(result)
+
+            result = getattr(ts, field)
+            assert np.isnan(result)
+
+        for field in self._bool_accessors:
+
+            result = getattr(NaT, field)
+            assert result is False
+
+            result = getattr(ts, field)
+            assert result is False
+
+    def test_nat_vector_field_access(self):
+        idx = DatetimeIndex(['1/1/2000', None, None, '1/4/2000'])
+
+        for field in self._field_accessors:
+            result = getattr(idx, field)
+            expected = [getattr(x, field) for x in idx]
+            tm.assert_numpy_array_equal(result, np.array(expected))
+
+        s = Series(idx)
+
+        for field in self._field_accessors:
+            result = getattr(s.dt, field)
+            expected = [getattr(x, field) for x in idx]
+            tm.assert_series_equal(result, Series(expected))
+
+        for field in self._bool_accessors:
+            result = getattr(s.dt, field)
+            expected = [getattr(x, field) for x in idx]
+            tm.assert_series_equal(result, Series(expected))
+
+
+@pytest.mark.parametrize('klass', [Timestamp, Timedelta, Period])
+def test_identity(klass):
+    assert klass(None) is NaT
+
+    result = klass(np.nan)
+    assert result is NaT
+
+    result = klass(None)
+    assert result is NaT
+
+    result = klass(iNaT)
+    assert result is NaT
+
+    result = klass(np.nan)
+    assert result is NaT
+
+    result = klass(float('nan'))
+    assert result is NaT
+
+    result = klass(NaT)
+    assert result is NaT
+
+    result = klass('NaT')
+    assert result is NaT
+
+    assert isnull(klass('nat'))
+
+
+@pytest.mark.parametrize('klass', [Timestamp, Timedelta, Period])
+def test_equality(klass):
+
+    # nat
+    if klass is not Period:
+        klass('').value == iNaT
+    klass('nat').value == iNaT
+    klass('NAT').value == iNaT
+    klass(None).value == iNaT
+    klass(np.nan).value == iNaT
+    assert isnull(klass('nat'))
+
+
+@pytest.mark.parametrize('klass', [Timestamp, Timedelta])
+def test_round_nat(klass):
+    # GH14940
+    ts = klass('nat')
+    for method in ["round", "floor", "ceil"]:
+        round_method = getattr(ts, method)
+        for freq in ["s", "5s", "min", "5min", "h", "5h"]:
+            assert round_method(freq) is ts
+
+
+def test_NaT_methods():
+    # GH 9513
+    raise_methods = ['astimezone', 'combine', 'ctime', 'dst',
+                     'fromordinal', 'fromtimestamp', 'isocalendar',
+                     'strftime', 'strptime', 'time', 'timestamp',
+                     'timetuple', 'timetz', 'toordinal', 'tzname',
+                     'utcfromtimestamp', 'utcnow', 'utcoffset',
+                     'utctimetuple']
+    nat_methods = ['date', 'now', 'replace', 'to_datetime', 'today']
+    nan_methods = ['weekday', 'isoweekday']
+
+    for method in raise_methods:
+        if hasattr(NaT, method):
+            with pytest.raises(ValueError):
+                getattr(NaT, method)()
+
+    for method in nan_methods:
+        if hasattr(NaT, method):
+            assert np.isnan(getattr(NaT, method)())
+
+    for method in nat_methods:
+        if hasattr(NaT, method):
+            # see gh-8254
+            exp_warning = None
+            if method == 'to_datetime':
+                exp_warning = FutureWarning
+            with tm.assert_produces_warning(
+                    exp_warning, check_stacklevel=False):
+                assert getattr(NaT, method)() is NaT
+
+    # GH 12300
+    assert NaT.isoformat() == 'NaT'
+
+
+@pytest.mark.parametrize('klass', [Timestamp, Timedelta])
+def test_isoformat(klass):
+
+    result = klass('NaT').isoformat()
+    expected = 'NaT'
+    assert result == expected
+
+
+def test_nat_arithmetic():
+    # GH 6873
+    i = 2
+    f = 1.5
+
+    for (left, right) in [(NaT, i), (NaT, f), (NaT, np.nan)]:
+        assert left / right is NaT
+        assert left * right is NaT
+        assert right * left is NaT
+        with pytest.raises(TypeError):
+            right / left
+
+    # Timestamp / datetime
+    t = Timestamp('2014-01-01')
+    dt = datetime(2014, 1, 1)
+    for (left, right) in [(NaT, NaT), (NaT, t), (NaT, dt)]:
+        # NaT __add__ or __sub__ Timestamp-like (or inverse) returns NaT
+        assert right + left is NaT
+        assert left + right is NaT
+        assert left - right is NaT
+        assert right - left is NaT
+
+    # timedelta-like
+    # offsets are tested in test_offsets.py
+
+    delta = timedelta(3600)
+    td = Timedelta('5s')
+
+    for (left, right) in [(NaT, delta), (NaT, td)]:
+        # NaT + timedelta-like returns NaT
+        assert right + left is NaT
+        assert left + right is NaT
+        assert right - left is NaT
+        assert left - right is NaT
+
+    # GH 11718
+    t_utc = Timestamp('2014-01-01', tz='UTC')
+    t_tz = Timestamp('2014-01-01', tz='US/Eastern')
+    dt_tz = pytz.timezone('Asia/Tokyo').localize(dt)
+
+    for (left, right) in [(NaT, t_utc), (NaT, t_tz),
+                          (NaT, dt_tz)]:
+        # NaT __add__ or __sub__ Timestamp-like (or inverse) returns NaT
+        assert right + left is NaT
+        assert left + right is NaT
+        assert left - right is NaT
+        assert right - left is NaT
+
+    # int addition / subtraction
+    for (left, right) in [(NaT, 2), (NaT, 0), (NaT, -3)]:
+        assert right + left is NaT
+        assert left + right is NaT
+        assert left - right is NaT
+        assert right - left is NaT
+
+
+def test_nat_arithmetic_index():
+    # GH 11718
+
+    dti = DatetimeIndex(['2011-01-01', '2011-01-02'], name='x')
+    exp = DatetimeIndex([NaT, NaT], name='x')
+    tm.assert_index_equal(dti + NaT, exp)
+    tm.assert_index_equal(NaT + dti, exp)
+
+    dti_tz = DatetimeIndex(['2011-01-01', '2011-01-02'],
+                           tz='US/Eastern', name='x')
+    exp = DatetimeIndex([NaT, NaT], name='x', tz='US/Eastern')
+    tm.assert_index_equal(dti_tz + NaT, exp)
+    tm.assert_index_equal(NaT + dti_tz, exp)
+
+    exp = TimedeltaIndex([NaT, NaT], name='x')
+    for (left, right) in [(NaT, dti), (NaT, dti_tz)]:
+        tm.assert_index_equal(left - right, exp)
+        tm.assert_index_equal(right - left, exp)
+
+    # timedelta
+    tdi = TimedeltaIndex(['1 day', '2 day'], name='x')
+    exp = DatetimeIndex([NaT, NaT], name='x')
+    for (left, right) in [(NaT, tdi)]:
+        tm.assert_index_equal(left + right, exp)
+        tm.assert_index_equal(right + left, exp)
+        tm.assert_index_equal(left - right, exp)
+        tm.assert_index_equal(right - left, exp)

pandas/tests/scalar/test_period.py

@@ -110,20 +110,6 @@ def test_period_cons_nat(self):
         p = Period(tslib.iNaT)
         self.assertIs(p, pd.NaT)
 
-    def test_cons_null_like(self):
-        # check Timestamp compat
-        self.assertIs(Timestamp('NaT'), pd.NaT)
-        self.assertIs(Period('NaT'), pd.NaT)
-
-        self.assertIs(Timestamp(None), pd.NaT)
-        self.assertIs(Period(None), pd.NaT)
-
-        self.assertIs(Timestamp(float('nan')), pd.NaT)
-        self.assertIs(Period(float('nan')), pd.NaT)
-
-        self.assertIs(Timestamp(np.nan), pd.NaT)
-        self.assertIs(Period(np.nan), pd.NaT)
-
     def test_period_cons_mult(self):
         p1 = Period('2011-01', freq='3M')
         p2 = Period('2011-01', freq='M')
@@ -854,17 +840,6 @@ def test_properties_secondly(self):
         self.assertEqual(Period(freq='Min', year=2012, month=2, day=1, hour=0,
                                 minute=0, second=0).days_in_month, 29)
 
-    def test_properties_nat(self):
-        p_nat = Period('NaT', freq='M')
-        t_nat = pd.Timestamp('NaT')
-        self.assertIs(p_nat, t_nat)
-
-        # confirm Period('NaT') work identical with Timestamp('NaT')
-        for f in ['year', 'month', 'day', 'hour', 'minute', 'second', 'week',
-                  'dayofyear', 'quarter', 'days_in_month']:
-            self.assertTrue(np.isnan(getattr(p_nat, f)))
-            self.assertTrue(np.isnan(getattr(t_nat, f)))
-
     def test_pnow(self):
 
         # deprecation, xref #13790

pandas/tests/scalar/test_timedelta.py

@@ -6,7 +6,7 @@
 import pandas.util.testing as tm
 from pandas.tseries.timedeltas import _coerce_scalar_to_timedelta_type as ct
 from pandas import (Timedelta, TimedeltaIndex, timedelta_range, Series,
-                    to_timedelta, compat, isnull)
+                    to_timedelta, compat)
 from pandas._libs.tslib import iNaT, NaTType
 
 
@@ -151,14 +151,6 @@ def test_construction(self):
                 500, 'ms').astype('m8[ns]').view('i8')
         self.assertEqual(Timedelta(10.5, unit='s').value, expected)
 
-        # nat
-        self.assertEqual(Timedelta('').value, iNaT)
-        self.assertEqual(Timedelta('nat').value, iNaT)
-        self.assertEqual(Timedelta('NAT').value, iNaT)
-        self.assertEqual(Timedelta(None).value, iNaT)
-        self.assertEqual(Timedelta(np.nan).value, iNaT)
-        self.assertTrue(isnull(Timedelta('nat')))
-
         # offset
         self.assertEqual(to_timedelta(pd.offsets.Hour(2)),
                          Timedelta('0 days, 02:00:00'))
@@ -686,11 +678,6 @@ def test_isoformat(self):
         expected = 'P0DT0H0M0.001S'
         self.assertEqual(result, expected)
 
-        # NaT
-        result = Timedelta('NaT').isoformat()
-        expected = 'NaT'
-        self.assertEqual(result, expected)
-
         # don't strip every 0
         result = Timedelta(minutes=1).isoformat()
         expected = 'P0DT0H1M0S'