TST: additional test coverage for 0.8

Author: Chang She

pandas/core/common.py

@@ -140,21 +140,6 @@ def _unpickle_array(bytes):
     arr = read_array(BytesIO(bytes))
     return arr
 
-def _take_1d_datetime(arr, indexer, out, fill_value=np.nan):
-    view = arr.view(np.int64)
-    outview = out.view(np.int64)
-    _algos.take_1d_bool(view, indexer, outview, fill_value=fill_value)
-
-def _take_2d_axis0_datetime(arr, indexer, out, fill_value=np.nan):
-    view = arr.view(np.int64)
-    outview = out.view(np.int64)
-    _algos.take_1d_bool(view, indexer, outview, fill_value=fill_value)
-
-def _take_2d_axis1_datetime(arr, indexer, out, fill_value=np.nan):
-    view = arr.view(np.uint8)
-    outview = out.view(np.uint8)
-    _algos.take_1d_bool(view, indexer, outview, fill_value=fill_value)
-
 def _view_wrapper(f, wrap_dtype, na_override=None):
     def wrapper(arr, indexer, out, fill_value=np.nan):
         if na_override is not None and np.isnan(fill_value):
@@ -212,7 +197,7 @@ def _get_take2d_function(dtype_str, axis=0):
         return _take2d_axis1_dict[dtype_str]
     elif axis == 'multi':
         return _take2d_multi_dict[dtype_str]
-    else:
+    else: # pragma: no cover
         raise ValueError('bad axis: %s' % axis)
 
 def take_1d(arr, indexer, out=None, fill_value=np.nan):

pandas/core/index.py

@@ -28,7 +28,7 @@ def wrapper(self, other):
         result = func(other)
         try:
             return result.view(np.ndarray)
-        except:
+        except: # pragma: no cover
             return result
     return wrapper
 
@@ -525,7 +525,7 @@ def union(self, other):
                 # contained in
                 try:
                     result = np.sort(self.values)
-                except TypeError:
+                except TypeError: # pragma: no cover
                     result = self.values
 
         # for subclasses

pandas/core/series.py

@@ -2702,7 +2702,7 @@ def _resolve_offset(freq, kwds):
     from pandas.core.datetools import getOffset
 
     if 'timeRule' in kwds or 'offset' in kwds:
-        offset = kwds.get('offset')
+        offset = kwds.get('offset', None)
         offset = kwds.get('timeRule', offset)
         if isinstance(offset, basestring):
             offset = datetools.getOffset(offset)

pandas/tests/test_frame.py

@@ -5649,6 +5649,20 @@ def test_reindex_multi(self):
 
         assert_frame_equal(result, expected)
 
+        df = DataFrame(np.random.randint(0, 10, (3, 3)))
+
+        result = df.reindex(range(3), range(3))
+        expected = df.reindex(range(3)).reindex(columns=range(3))
+
+        assert_frame_equal(result, expected)
+
+        df = df + 1j
+
+        result = df.reindex(range(4), range(4))
+        expected = df.reindex(range(4)).reindex(columns=range(4))
+
+        assert_frame_equal(result, expected)
+
     def test_rename_objects(self):
         renamed = self.mixed_frame.rename(columns=str.upper)
         self.assert_('FOO' in renamed)

pandas/tests/test_index.py

@@ -197,6 +197,9 @@ def test_union(self):
         union = first.union([])
         self.assert_(union is first)
 
+        union = Index([]).union(first)
+        self.assert_(union is first)
+
         # non-iterable input
         self.assertRaises(Exception, first.union, 0.5)
 
@@ -395,6 +398,11 @@ def test_drop(self):
         expected = self.strIndex[1:]
         self.assert_(dropped.equals(expected))
 
+        ser = Index([1,2,3])
+        dropped = ser.drop(1)
+        expected = Index([1,3])
+        self.assert_(dropped.equals(expected))
+
     def test_tuple_union_bug(self):
         import pandas
         import numpy as np
@@ -1468,6 +1476,12 @@ def test_reindex_level(self):
         exp_indexer2 = np.array([0, -1, 0, -1, 0, -1])
         self.assert_(np.array_equal(indexer2, exp_indexer2))
 
+        self.assertRaises(ValueError, self.index.reindex,
+                          self.index, method='pad', level='second')
+
+        self.assertRaises(ValueError, idx.reindex,
+                          idx, method='bfill', level='first')
+
     def test_has_duplicates(self):
         self.assert_(not self.index.has_duplicates)
         self.assert_(self.index.append(self.index).has_duplicates)

pandas/tests/test_series.py

@@ -284,6 +284,14 @@ def test_constructor_dict(self):
         expected = Series([1, 2, nan, 0], index=['b', 'c', 'd', 'a'])
         assert_series_equal(result, expected)
 
+        pidx = tm.makePeriodIndex(100)
+        d = {pidx[0] : 0, pidx[1] : 1}
+        result = Series(d, index=pidx)
+        expected = Series(np.nan, pidx)
+        expected.ix[0] = 0
+        expected.ix[1] = 1
+        assert_series_equal(result, expected)
+
     def test_constructor_subclass_dict(self):
         data = tm.TestSubDict((x, 10.0 * x) for x in xrange(10))
         series = Series(data)
@@ -929,6 +937,12 @@ def test_timeseries_repr_object_dtype(self):
         ts = Series(np.random.randn(len(index)), index)
         repr(ts)
 
+        ts = tm.makeTimeSeries(1000)
+        self.assert_(repr(ts).splitlines()[-1].startswith('Freq:'))
+
+        ts2 = ts.ix[np.random.randint(0, len(ts)-1, 400)]
+        repr(ts).splitlines()[-1]
+
     def test_iter(self):
         for i, val in enumerate(self.series):
             self.assertEqual(val, self.series[i])
@@ -1202,46 +1216,48 @@ def test_all_any(self):
         self.assert_(bool_series.any())
 
     def test_operators(self):
-        series = self.ts
-        other = self.ts[::2]
 
-        def _check_op(other, op, pos_only=False):
+        def _check_op(series, other, op, pos_only=False):
             left = np.abs(series) if pos_only else series
             right = np.abs(other) if pos_only else other
 
             cython_or_numpy = op(left, right)
             python = left.combine(right, op)
             tm.assert_almost_equal(cython_or_numpy, python)
 
-        def check(other):
+        def check(series, other):
             simple_ops = ['add', 'sub', 'mul', 'truediv', 'floordiv']
 
             for opname in simple_ops:
-                _check_op(other, getattr(operator, opname))
-            _check_op(other, operator.pow, pos_only=True)
-
-            _check_op(other, lambda x, y: operator.add(y, x))
-            _check_op(other, lambda x, y: operator.sub(y, x))
-            _check_op(other, lambda x, y: operator.truediv(y, x))
-            _check_op(other, lambda x, y: operator.floordiv(y, x))
-            _check_op(other, lambda x, y: operator.mul(y, x))
-            _check_op(other, lambda x, y: operator.pow(y, x),
+                _check_op(series, other, getattr(operator, opname))
+
+            _check_op(series, other, operator.pow, pos_only=True)
+
+            _check_op(series, other, lambda x, y: operator.add(y, x))
+            _check_op(series, other, lambda x, y: operator.sub(y, x))
+            _check_op(series, other, lambda x, y: operator.truediv(y, x))
+            _check_op(series, other, lambda x, y: operator.floordiv(y, x))
+            _check_op(series, other, lambda x, y: operator.mul(y, x))
+            _check_op(series, other, lambda x, y: operator.pow(y, x),
                       pos_only=True)
 
-        check(self.ts * 2)
-        check(self.ts * 0)
-        check(self.ts[::2])
-        check(5)
+        check(self.ts, self.ts * 2)
+        check(self.ts, self.ts * 0)
+        check(self.ts, self.ts[::2])
+        check(self.ts, 5)
 
-        def check_comparators(other):
-            _check_op(other, operator.gt)
-            _check_op(other, operator.ge)
-            _check_op(other, operator.eq)
-            _check_op(other, operator.lt)
-            _check_op(other, operator.le)
+        def check_comparators(series, other):
+            _check_op(series, other, operator.gt)
+            _check_op(series, other, operator.ge)
+            _check_op(series, other, operator.eq)
+            _check_op(series, other, operator.lt)
+            _check_op(series, other, operator.le)
+
+        check_comparators(self.ts, 5)
+        check_comparators(self.ts, self.ts + 1)
+        bool_ser = self.ts > 0
+        check_comparators(bool_ser, bool_ser[::2])
 
-        check_comparators(5)
-        check_comparators(self.ts + 1)
 
     def test_operators_empty_int_corner(self):
         s1 = Series([], [], dtype=np.int32)
@@ -1941,6 +1957,13 @@ def test_shift(self):
 
         self.assertRaises(ValueError, ps.shift, freq='D')
 
+        #legacy support
+        shifted4 = ps.shift(1, timeRule='B')
+        assert_series_equal(shifted2, shifted4)
+
+        shifted5 = ps.shift(1, offset=datetools.bday)
+        assert_series_equal(shifted5, shifted4)
+
     def test_tshift(self):
         # PeriodIndex
         ps = tm.makePeriodSeries()
@@ -2050,6 +2073,11 @@ def test_asof(self):
         lb = ts.index[14]
         ub = ts.index[30]
 
+        result = ts.asof(list(dates))
+        self.assert_(notnull(result).all())
+        lb = ts.index[14]
+        ub = ts.index[30]
+
         mask = (result.index >= lb) & (result.index < ub)
         rs = result[mask]
         self.assert_((rs == ts[lb]).all())
@@ -2615,6 +2643,10 @@ def test_replace(self):
         ser = Series(self.ts.index)
         assert_series_equal(ser.replace(np.nan, 0), ser.fillna(0))
 
+        # malformed
+        self.assertRaises(ValueError, ser.replace, [1,2,3], [np.nan, 0])
+        self.assertRaises(ValueError, ser.replace, xrange(1,3), [np.nan, 0])
+
     def test_asfreq(self):
         ts = Series([0., 1., 2.], index=[datetime(2009, 10, 30),
                                          datetime(2009, 11, 30),

pandas/tseries/tests/test_timeseries.py

@@ -381,6 +381,25 @@ def test_fillna_nat(self):
         assert_frame_equal(filled, expected)
         assert_frame_equal(filled2, expected)
 
+
+        series = Series([NaT, 0, 1, 2], dtype='M8[us]')
+
+        filled = series.fillna(method='bfill')
+        filled2 = series.fillna(value=series[1])
+
+        expected = series.copy()
+        expected[0] = expected[1]
+
+        assert_series_equal(filled, expected)
+        assert_series_equal(filled2, expected)
+
+        df = DataFrame({'A': series})
+        filled = df.fillna(method='bfill')
+        filled2 = df.fillna(value=series[1])
+        expected = DataFrame({'bfill': expected})
+        assert_frame_equal(filled, expected)
+        assert_frame_equal(filled2, expected)
+
     def test_string_na_nat_conversion(self):
         # GH #999, #858
 
@@ -469,6 +488,11 @@ def test_index_to_datetime(self):
         expected = DatetimeIndex(datetools.to_datetime(idx.values))
         self.assert_(result.equals(expected))
 
+        idx = Index([datetime.today()], dtype=object)
+        result = idx.to_datetime()
+        expected = DatetimeIndex([datetime.today()])
+        self.assert_(result.equals(expected))
+
     def test_range_misspecified(self):
         # GH #1095
 
@@ -584,6 +608,8 @@ def test_repeat(self):
     def test_at_time(self):
         rng = date_range('1/1/2000', '1/5/2000', freq='5min')
         ts = Series(np.random.randn(len(rng)), index=rng)
+        self.assert_(ts.at_time(rng[0]), ts.ix[0])
+
         df = DataFrame(np.random.randn(len(rng), 3), index=rng)
 
         result = ts[time(9, 30)]

pandas/util/testing.py

@@ -237,11 +237,11 @@ def makePeriodIndex(k):
     dr = PeriodIndex(start=dt, periods=k, freq='B')
     return dr
 
-def makeTimeSeries():
-    return Series(randn(N), index=makeDateIndex(N))
+def makeTimeSeries(nper=N):
+    return Series(randn(nper), index=makeDateIndex(nper))
 
-def makePeriodSeries():
-    return Series(randn(N), index=makePeriodIndex(N))
+def makePeriodSeries(nper=N):
+    return Series(randn(nper), index=makePeriodIndex(nper))
 
 def getTimeSeriesData():
     return dict((c, makeTimeSeries()) for c in getCols(K))