diff --git a/pandas/tseries/tests/test_daterange.py b/pandas/tseries/tests/test_daterange.py
index 0af3b6281530b..d1efa12953caa 100644
--- a/pandas/tseries/tests/test_daterange.py
+++ b/pandas/tseries/tests/test_daterange.py
@@ -364,18 +364,18 @@ def test_range_tz(self):
 
         dr = date_range(start=start, periods=3)
         self.assert_(dr.tz == tz('US/Eastern'))
-        self.assert_(dr[0] == start)
-        self.assert_(dr[2] == end)
+        self.assertEqual(dr[0], start)
+        self.assertEqual(dr[2], end)
 
         dr = date_range(end=end, periods=3)
-        self.assert_(dr.tz == tz('US/Eastern'))
-        self.assert_(dr[0] == start)
-        self.assert_(dr[2] == end)
+        self.assertEqual(dr.tz, tz('US/Eastern'))
+        self.assertEqual(dr[0], start)
+        self.assertEqual(dr[2], end)
 
         dr = date_range(start=start, end=end)
-        self.assert_(dr.tz == tz('US/Eastern'))
-        self.assert_(dr[0] == start)
-        self.assert_(dr[2] == end)
+        self.assertEqual(dr.tz, tz('US/Eastern'))
+        self.assertEqual(dr[0], start)
+        self.assertEqual(dr[2], end)
 
     def test_month_range_union_tz(self):
         _skip_if_no_pytz()
diff --git a/pandas/tseries/tests/test_frequencies.py b/pandas/tseries/tests/test_frequencies.py
index 8d95e22e4c6f2..b17a1c11efad7 100644
--- a/pandas/tseries/tests/test_frequencies.py
+++ b/pandas/tseries/tests/test_frequencies.py
@@ -99,18 +99,18 @@ def test_raise_if_too_few(self):
 
     def test_business_daily(self):
         index = _dti(['12/31/1998', '1/3/1999', '1/4/1999'])
-        self.assert_(infer_freq(index) == 'B')
+        self.assertEqual(infer_freq(index), 'B')
 
     def test_day(self):
         self._check_tick(timedelta(1), 'D')
 
     def test_day_corner(self):
         index = _dti(['1/1/2000', '1/2/2000', '1/3/2000'])
-        self.assert_(infer_freq(index) == 'D')
+        self.assertEqual(infer_freq(index), 'D')
 
     def test_non_datetimeindex(self):
         dates = to_datetime(['1/1/2000', '1/2/2000', '1/3/2000'])
-        self.assert_(infer_freq(dates) == 'D')
+        self.assertEqual(infer_freq(dates), 'D')
 
     def test_hour(self):
         self._check_tick(timedelta(hours=1), 'H')
@@ -141,7 +141,7 @@ def _check_tick(self, base_delta, code):
                 exp_freq = '%d%s' % (i, code)
             else:
                 exp_freq = code
-            self.assert_(infer_freq(index) == exp_freq)
+            self.assertEqual(infer_freq(index), exp_freq)
 
         index = _dti([b + base_delta * 7] +
                      [b + base_delta * j for j in range(3)])
@@ -174,7 +174,7 @@ def test_monthly(self):
 
     def test_monthly_ambiguous(self):
         rng = _dti(['1/31/2000', '2/29/2000', '3/31/2000'])
-        self.assert_(rng.inferred_freq == 'M')
+        self.assertEqual(rng.inferred_freq, 'M')
 
     def test_business_monthly(self):
         self._check_generated_range('1/1/2000', 'BM')
@@ -196,7 +196,7 @@ def test_business_annual(self):
 
     def test_annual_ambiguous(self):
         rng = _dti(['1/31/2000', '1/31/2001', '1/31/2002'])
-        self.assert_(rng.inferred_freq == 'A-JAN')
+        self.assertEqual(rng.inferred_freq, 'A-JAN')
 
     def _check_generated_range(self, start, freq):
         freq = freq.upper()
@@ -220,7 +220,7 @@ def _check_generated_range(self, start, freq):
         gen = date_range(start, periods=5, freq=freq)
         index = _dti(gen.values)
         if not freq.startswith('Q-'):
-            self.assert_(infer_freq(index) == gen.freqstr)
+            self.assertEqual(infer_freq(index), gen.freqstr)
         else:
             inf_freq = infer_freq(index)
             self.assert_((inf_freq == 'Q-DEC' and
@@ -236,15 +236,15 @@ def _check_generated_range(self, start, freq):
     def test_infer_freq(self):
         rng = period_range('1959Q2', '2009Q3', freq='Q')
         rng = Index(rng.to_timestamp('D', how='e').asobject)
-        self.assert_(rng.inferred_freq == 'Q-DEC')
+        self.assertEqual(rng.inferred_freq, 'Q-DEC')
 
         rng = period_range('1959Q2', '2009Q3', freq='Q-NOV')
         rng = Index(rng.to_timestamp('D', how='e').asobject)
-        self.assert_(rng.inferred_freq == 'Q-NOV')
+        self.assertEqual(rng.inferred_freq, 'Q-NOV')
 
         rng = period_range('1959Q2', '2009Q3', freq='Q-OCT')
         rng = Index(rng.to_timestamp('D', how='e').asobject)
-        self.assert_(rng.inferred_freq == 'Q-OCT')
+        self.assertEqual(rng.inferred_freq, 'Q-OCT')
 
     def test_not_monotonic(self):
         rng = _dti(['1/31/2000', '1/31/2001', '1/31/2002'])
diff --git a/pandas/tseries/tests/test_offsets.py b/pandas/tseries/tests/test_offsets.py
index a3c63966948ee..6e553959f3ee5 100644
--- a/pandas/tseries/tests/test_offsets.py
+++ b/pandas/tseries/tests/test_offsets.py
@@ -151,7 +151,7 @@ def test_eq(self):
         offset2 = DateOffset(days=365)
 
         self.assert_(offset1 != offset2)
-        self.assert_(not (offset1 == offset2))
+        self.assertNotEqual(offset1, offset2)
 
 
 class TestBusinessDay(TestBase):
@@ -703,7 +703,7 @@ def test_onOffset(self):
 
         for week, weekday, date, expected in test_cases:
             offset = WeekOfMonth(week=week, weekday=weekday)
-            self.assert_(offset.onOffset(date) == expected)
+            self.assertEqual(offset.onOffset(date), expected)
 
 class TestLastWeekOfMonth(TestBase):
     _offset = LastWeekOfMonth
@@ -722,13 +722,13 @@ def test_offset(self):
         offset_sat = LastWeekOfMonth(n=1, weekday=5)
 
         one_day_before = (last_sat + timedelta(days=-1))
-        self.assert_(one_day_before + offset_sat == last_sat)
+        self.assertEqual(one_day_before + offset_sat, last_sat)
 
         one_day_after = (last_sat + timedelta(days=+1))
-        self.assert_(one_day_after + offset_sat == next_sat)
+        self.assertEqual(one_day_after + offset_sat, next_sat)
 
         #Test On that day
-        self.assert_(last_sat + offset_sat == next_sat)
+        self.assertEqual(last_sat + offset_sat, next_sat)
 
         #### Thursday
 
@@ -737,22 +737,22 @@ def test_offset(self):
         next_thurs = datetime(2013,2,28)
 
         one_day_before = last_thurs + timedelta(days=-1)
-        self.assert_(one_day_before + offset_thur == last_thurs)
+        self.assertEqual(one_day_before + offset_thur, last_thurs)
 
         one_day_after = last_thurs + timedelta(days=+1)
-        self.assert_(one_day_after + offset_thur == next_thurs)
+        self.assertEqual(one_day_after + offset_thur, next_thurs)
 
         # Test on that day
-        self.assert_(last_thurs + offset_thur == next_thurs)
+        self.assertEqual(last_thurs + offset_thur, next_thurs)
 
         three_before = last_thurs + timedelta(days=-3)
-        self.assert_(three_before + offset_thur == last_thurs)
+        self.assertEqual(three_before + offset_thur, last_thurs)
 
         two_after = last_thurs + timedelta(days=+2)
-        self.assert_(two_after + offset_thur == next_thurs)
+        self.assertEqual(two_after + offset_thur, next_thurs)
 
         offset_sunday = LastWeekOfMonth(n=1, weekday=WeekDay.SUN)
-        self.assert_(datetime(2013,7,31) + offset_sunday == datetime(2013,8,25))
+        self.assertEqual(datetime(2013,7,31) + offset_sunday, datetime(2013,8,25))
 
     def test_onOffset(self):
         test_cases = [
diff --git a/pandas/tseries/tests/test_period.py b/pandas/tseries/tests/test_period.py
index ca0eba59fe5fe..21e9756da9ad6 100644
--- a/pandas/tseries/tests/test_period.py
+++ b/pandas/tseries/tests/test_period.py
@@ -465,25 +465,25 @@ def test_constructor_corner(self):
 
     def test_constructor_infer_freq(self):
         p = Period('2007-01-01')
-        self.assert_(p.freq == 'D')
+        self.assertEqual(p.freq, 'D')
 
         p = Period('2007-01-01 07')
-        self.assert_(p.freq == 'H')
+        self.assertEqual(p.freq, 'H')
 
         p = Period('2007-01-01 07:10')
-        self.assert_(p.freq == 'T')
+        self.assertEqual(p.freq, 'T')
 
         p = Period('2007-01-01 07:10:15')
-        self.assert_(p.freq == 'S')
+        self.assertEqual(p.freq, 'S')
 
         p = Period('2007-01-01 07:10:15.123')
-        self.assert_(p.freq == 'L')
+        self.assertEqual(p.freq, 'L')
 
         p = Period('2007-01-01 07:10:15.123000')
-        self.assert_(p.freq == 'L')
+        self.assertEqual(p.freq, 'L')
 
         p = Period('2007-01-01 07:10:15.123400')
-        self.assert_(p.freq == 'U')
+        self.assertEqual(p.freq, 'U')
 
 
 def noWrap(item):
@@ -1368,7 +1368,7 @@ def test_indexing(self):
         s = Series(randn(10), index=index)
         expected = s[index[0]]
         result = s.iat[0]
-        self.assert_(expected == result)
+        self.assertEqual(expected, result)
 
     def test_frame_setitem(self):
         rng = period_range('1/1/2000', periods=5)
@@ -1772,12 +1772,12 @@ def test_asfreq_ts(self):
         result = ts.asfreq('D', how='end')
         df_result = df.asfreq('D', how='end')
         exp_index = index.asfreq('D', how='end')
-        self.assert_(len(result) == len(ts))
+        self.assertEqual(len(result), len(ts))
         self.assert_(result.index.equals(exp_index))
         self.assert_(df_result.index.equals(exp_index))
 
         result = ts.asfreq('D', how='start')
-        self.assert_(len(result) == len(ts))
+        self.assertEqual(len(result), len(ts))
         self.assert_(result.index.equals(index.asfreq('D', how='start')))
 
     def test_badinput(self):
@@ -1818,7 +1818,7 @@ def test_pindex_qaccess(self):
         pi = PeriodIndex(['2Q05', '3Q05', '4Q05', '1Q06', '2Q06'], freq='Q')
         s = Series(np.random.rand(len(pi)), index=pi).cumsum()
         # Todo: fix these accessors!
-        self.assert_(s['05Q4'] == s[2])
+        self.assertEqual(s['05Q4'], s[2])
 
     def test_period_dt64_round_trip(self):
         dti = date_range('1/1/2000', '1/7/2002', freq='B')
@@ -1843,21 +1843,21 @@ def test_to_period_quarterlyish(self):
         for off in offsets:
             rng = date_range('01-Jan-2012', periods=8, freq=off)
             prng = rng.to_period()
-            self.assert_(prng.freq == 'Q-DEC')
+            self.assertEqual(prng.freq, 'Q-DEC')
 
     def test_to_period_annualish(self):
         offsets = ['BA', 'AS', 'BAS']
         for off in offsets:
             rng = date_range('01-Jan-2012', periods=8, freq=off)
             prng = rng.to_period()
-            self.assert_(prng.freq == 'A-DEC')
+            self.assertEqual(prng.freq, 'A-DEC')
 
     def test_to_period_monthish(self):
         offsets = ['MS', 'EOM', 'BM']
         for off in offsets:
             rng = date_range('01-Jan-2012', periods=8, freq=off)
             prng = rng.to_period()
-            self.assert_(prng.freq == 'M')
+            self.assertEqual(prng.freq, 'M')
 
     def test_no_multiples(self):
         self.assertRaises(ValueError, period_range, '1989Q3', periods=10,
@@ -1894,7 +1894,7 @@ def test_iteration(self):
 
         result = list(index)
         tm.assert_isinstance(result[0], Period)
-        self.assert_(result[0].freq == index.freq)
+        self.assertEqual(result[0].freq, index.freq)
 
     def test_take(self):
         index = PeriodIndex(start='1/1/10', end='12/31/12', freq='D')
@@ -1902,9 +1902,9 @@ def test_take(self):
         taken = index.take([5, 6, 8, 12])
         taken2 = index[[5, 6, 8, 12]]
         tm.assert_isinstance(taken, PeriodIndex)
-        self.assert_(taken.freq == index.freq)
+        self.assertEqual(taken.freq, index.freq)
         tm.assert_isinstance(taken2, PeriodIndex)
-        self.assert_(taken2.freq == index.freq)
+        self.assertEqual(taken2.freq, index.freq)
 
     def test_joins(self):
         index = period_range('1/1/2000', '1/20/2000', freq='D')
@@ -1913,7 +1913,7 @@ def test_joins(self):
             joined = index.join(index[:-5], how=kind)
 
             tm.assert_isinstance(joined, PeriodIndex)
-            self.assert_(joined.freq == index.freq)
+            self.assertEqual(joined.freq, index.freq)
 
     def test_join_self(self):
         index = period_range('1/1/2000', '1/20/2000', freq='D')
@@ -2128,7 +2128,7 @@ def test_get_loc_msg(self):
         try:
             idx.get_loc(bad_period)
         except KeyError as inst:
-            self.assert_(inst.args[0] == bad_period)
+            self.assertEqual(inst.args[0], bad_period)
 
     def test_append_concat(self):
         # #1815
diff --git a/pandas/tseries/tests/test_plotting.py b/pandas/tseries/tests/test_plotting.py
index e55dd96d64ca0..3c6f97b73a6b4 100644
--- a/pandas/tseries/tests/test_plotting.py
+++ b/pandas/tseries/tests/test_plotting.py
@@ -81,7 +81,7 @@ def test_nonnumeric_exclude(self):
         df = DataFrame({'A': ["x", "y", "z"], 'B': [1,2,3]}, idx)
 
         ax = df.plot() # it works
-        self.assert_(len(ax.get_lines()) == 1) #B was plotted
+        self.assertEqual(len(ax.get_lines()), 1) #B was plotted
         plt.close(plt.gcf())
 
         self.assertRaises(TypeError, df['A'].plot)
@@ -390,7 +390,7 @@ def test_finder_monthly(self):
             ax = ser.plot()
             xaxis = ax.get_xaxis()
             rs = xaxis.get_majorticklocs()[0]
-            self.assert_(rs == xp)
+            self.assertEqual(rs, xp)
             vmin, vmax = ax.get_xlim()
             ax.set_xlim(vmin + 0.9, vmax)
             rs = xaxis.get_majorticklocs()[0]
diff --git a/pandas/tseries/tests/test_resample.py b/pandas/tseries/tests/test_resample.py
index 289c0391fca23..59be80f7012d7 100644
--- a/pandas/tseries/tests/test_resample.py
+++ b/pandas/tseries/tests/test_resample.py
@@ -90,7 +90,7 @@ def test_resample_basic(self):
         expected = Series([s[0], s[1:6].mean(), s[6:11].mean(), s[11:].mean()],
                           index=date_range('1/1/2000', periods=4, freq='5min'))
         assert_series_equal(result, expected)
-        self.assert_(result.index.name == 'index')
+        self.assertEqual(result.index.name, 'index')
 
         result = s.resample('5min', how='mean', closed='left', label='right')
         expected = Series([s[:5].mean(), s[5:10].mean(), s[10:].mean()],
@@ -158,7 +158,7 @@ def test_resample_basic_from_daily(self):
         self.assertEquals(result.irow(0), s['1/2/2005'])
         self.assertEquals(result.irow(1), s['1/3/2005'])
         self.assertEquals(result.irow(5), s['1/9/2005'])
-        self.assert_(result.index.name == 'index')
+        self.assertEqual(result.index.name, 'index')
 
     def test_resample_frame_basic(self):
         df = tm.makeTimeDataFrame()
@@ -201,7 +201,7 @@ def test_resample_loffset(self):
             loffset=Minute(1))
         assert_series_equal(result, expected)
 
-        self.assert_(result.index.freq == Minute(5))
+        self.assertEqual(result.index.freq, Minute(5))
 
                 # from daily
         dti = DatetimeIndex(
@@ -228,7 +228,7 @@ def test_resample_upsample(self):
         self.assertEquals(result[0], s[0])
         self.assertEquals(result[-1], s[-1])
 
-        self.assert_(result.index.name == 'index')
+        self.assertEqual(result.index.name, 'index')
 
     def test_upsample_with_limit(self):
         rng = date_range('1/1/2000', periods=3, freq='5t')
@@ -305,7 +305,7 @@ def test_resample_reresample(self):
         result = bs.resample('8H')
         self.assertEquals(len(result), 22)
         tm.assert_isinstance(result.index.freq, offsets.DateOffset)
-        self.assert_(result.index.freq == offsets.Hour(8))
+        self.assertEqual(result.index.freq, offsets.Hour(8))
 
     def test_resample_timestamp_to_period(self):
         ts = _simple_ts('1/1/1990', '1/1/2000')
@@ -491,12 +491,12 @@ def test_resample_empty(self):
         ts = _simple_ts('1/1/2000', '2/1/2000')[:0]
 
         result = ts.resample('A')
-        self.assert_(len(result) == 0)
-        self.assert_(result.index.freqstr == 'A-DEC')
+        self.assertEqual(len(result), 0)
+        self.assertEqual(result.index.freqstr, 'A-DEC')
 
         result = ts.resample('A', kind='period')
-        self.assert_(len(result) == 0)
-        self.assert_(result.index.freqstr == 'A-DEC')
+        self.assertEqual(len(result), 0)
+        self.assertEqual(result.index.freqstr, 'A-DEC')
 
         xp = DataFrame()
         rs = xp.resample('A')
@@ -549,7 +549,7 @@ def test_resample_anchored_intraday(self):
 
         ts = _simple_ts('2012-04-29 23:00', '2012-04-30 5:00', freq='h')
         resampled = ts.resample('M')
-        self.assert_(len(resampled) == 1)
+        self.assertEqual(len(resampled), 1)
 
     def test_resample_anchored_monthstart(self):
         ts = _simple_ts('1/1/2000', '12/31/2002')
@@ -572,13 +572,13 @@ def test_corner_cases(self):
         len0pts = _simple_pts('2007-01', '2010-05', freq='M')[:0]
         # it works
         result = len0pts.resample('A-DEC')
-        self.assert_(len(result) == 0)
+        self.assertEqual(len(result), 0)
 
         # resample to periods
         ts = _simple_ts('2000-04-28', '2000-04-30 11:00', freq='h')
         result = ts.resample('M', kind='period')
-        self.assert_(len(result) == 1)
-        self.assert_(result.index[0] == Period('2000-04', freq='M'))
+        self.assertEqual(len(result), 1)
+        self.assertEqual(result.index[0], Period('2000-04', freq='M'))
 
     def test_anchored_lowercase_buglet(self):
         dates = date_range('4/16/2012 20:00', periods=50000, freq='s')
@@ -889,7 +889,7 @@ def test_resample_empty(self):
         ts = _simple_pts('1/1/2000', '2/1/2000')[:0]
 
         result = ts.resample('A')
-        self.assert_(len(result) == 0)
+        self.assertEqual(len(result), 0)
 
     def test_resample_irregular_sparse(self):
         dr = date_range(start='1/1/2012', freq='5min', periods=1000)
diff --git a/pandas/tseries/tests/test_timedeltas.py b/pandas/tseries/tests/test_timedeltas.py
index 3d8ee87f6c42f..8863a50e86c2e 100644
--- a/pandas/tseries/tests/test_timedeltas.py
+++ b/pandas/tseries/tests/test_timedeltas.py
@@ -32,21 +32,21 @@ def setUp(self):
     def test_numeric_conversions(self):
         _skip_if_numpy_not_friendly()
 
-        self.assert_(ct(0) == np.timedelta64(0,'ns'))
-        self.assert_(ct(10) == np.timedelta64(10,'ns'))
-        self.assert_(ct(10,unit='ns') == np.timedelta64(10,'ns').astype('m8[ns]'))
+        self.assertEqual(ct(0), np.timedelta64(0,'ns'))
+        self.assertEqual(ct(10), np.timedelta64(10,'ns'))
+        self.assertEqual(ct(10,unit='ns'), np.timedelta64(10,'ns').astype('m8[ns]'))
 
-        self.assert_(ct(10,unit='us') == np.timedelta64(10,'us').astype('m8[ns]'))
-        self.assert_(ct(10,unit='ms') == np.timedelta64(10,'ms').astype('m8[ns]'))
-        self.assert_(ct(10,unit='s') == np.timedelta64(10,'s').astype('m8[ns]'))
-        self.assert_(ct(10,unit='d') == np.timedelta64(10,'D').astype('m8[ns]'))
+        self.assertEqual(ct(10,unit='us'), np.timedelta64(10,'us').astype('m8[ns]'))
+        self.assertEqual(ct(10,unit='ms'), np.timedelta64(10,'ms').astype('m8[ns]'))
+        self.assertEqual(ct(10,unit='s'), np.timedelta64(10,'s').astype('m8[ns]'))
+        self.assertEqual(ct(10,unit='d'), np.timedelta64(10,'D').astype('m8[ns]'))
 
     def test_timedelta_conversions(self):
         _skip_if_numpy_not_friendly()
 
-        self.assert_(ct(timedelta(seconds=1)) == np.timedelta64(1,'s').astype('m8[ns]'))
-        self.assert_(ct(timedelta(microseconds=1)) == np.timedelta64(1,'us').astype('m8[ns]'))
-        self.assert_(ct(timedelta(days=1)) == np.timedelta64(1,'D').astype('m8[ns]'))
+        self.assertEqual(ct(timedelta(seconds=1)), np.timedelta64(1,'s').astype('m8[ns]'))
+        self.assertEqual(ct(timedelta(microseconds=1)), np.timedelta64(1,'us').astype('m8[ns]'))
+        self.assertEqual(ct(timedelta(days=1)), np.timedelta64(1,'D').astype('m8[ns]'))
 
     def test_short_format_converters(self):
         _skip_if_numpy_not_friendly()
@@ -54,43 +54,43 @@ def test_short_format_converters(self):
         def conv(v):
             return v.astype('m8[ns]')
 
-        self.assert_(ct('10') == np.timedelta64(10,'ns'))
-        self.assert_(ct('10ns') == np.timedelta64(10,'ns'))
-        self.assert_(ct('100') == np.timedelta64(100,'ns'))
-        self.assert_(ct('100ns') == np.timedelta64(100,'ns'))
-
-        self.assert_(ct('1000') == np.timedelta64(1000,'ns'))
-        self.assert_(ct('1000ns') == np.timedelta64(1000,'ns'))
-        self.assert_(ct('1000NS') == np.timedelta64(1000,'ns'))
-
-        self.assert_(ct('10us') == np.timedelta64(10000,'ns'))
-        self.assert_(ct('100us') == np.timedelta64(100000,'ns'))
-        self.assert_(ct('1000us') == np.timedelta64(1000000,'ns'))
-        self.assert_(ct('1000Us') == np.timedelta64(1000000,'ns'))
-        self.assert_(ct('1000uS') == np.timedelta64(1000000,'ns'))
-
-        self.assert_(ct('1ms') == np.timedelta64(1000000,'ns'))
-        self.assert_(ct('10ms') == np.timedelta64(10000000,'ns'))
-        self.assert_(ct('100ms') == np.timedelta64(100000000,'ns'))
-        self.assert_(ct('1000ms') == np.timedelta64(1000000000,'ns'))
-
-        self.assert_(ct('-1s') == -np.timedelta64(1000000000,'ns'))
-        self.assert_(ct('1s') == np.timedelta64(1000000000,'ns'))
-        self.assert_(ct('10s') == np.timedelta64(10000000000,'ns'))
-        self.assert_(ct('100s') == np.timedelta64(100000000000,'ns'))
-        self.assert_(ct('1000s') == np.timedelta64(1000000000000,'ns'))
-
-        self.assert_(ct('1d') == conv(np.timedelta64(1,'D')))
-        self.assert_(ct('-1d') == -conv(np.timedelta64(1,'D')))
-        self.assert_(ct('1D') == conv(np.timedelta64(1,'D')))
-        self.assert_(ct('10D') == conv(np.timedelta64(10,'D')))
-        self.assert_(ct('100D') == conv(np.timedelta64(100,'D')))
-        self.assert_(ct('1000D') == conv(np.timedelta64(1000,'D')))
-        self.assert_(ct('10000D') == conv(np.timedelta64(10000,'D')))
+        self.assertEqual(ct('10'), np.timedelta64(10,'ns'))
+        self.assertEqual(ct('10ns'), np.timedelta64(10,'ns'))
+        self.assertEqual(ct('100'), np.timedelta64(100,'ns'))
+        self.assertEqual(ct('100ns'), np.timedelta64(100,'ns'))
+
+        self.assertEqual(ct('1000'), np.timedelta64(1000,'ns'))
+        self.assertEqual(ct('1000ns'), np.timedelta64(1000,'ns'))
+        self.assertEqual(ct('1000NS'), np.timedelta64(1000,'ns'))
+
+        self.assertEqual(ct('10us'), np.timedelta64(10000,'ns'))
+        self.assertEqual(ct('100us'), np.timedelta64(100000,'ns'))
+        self.assertEqual(ct('1000us'), np.timedelta64(1000000,'ns'))
+        self.assertEqual(ct('1000Us'), np.timedelta64(1000000,'ns'))
+        self.assertEqual(ct('1000uS'), np.timedelta64(1000000,'ns'))
+
+        self.assertEqual(ct('1ms'), np.timedelta64(1000000,'ns'))
+        self.assertEqual(ct('10ms'), np.timedelta64(10000000,'ns'))
+        self.assertEqual(ct('100ms'), np.timedelta64(100000000,'ns'))
+        self.assertEqual(ct('1000ms'), np.timedelta64(1000000000,'ns'))
+
+        self.assertEqual(ct('-1s'), -np.timedelta64(1000000000,'ns'))
+        self.assertEqual(ct('1s'), np.timedelta64(1000000000,'ns'))
+        self.assertEqual(ct('10s'), np.timedelta64(10000000000,'ns'))
+        self.assertEqual(ct('100s'), np.timedelta64(100000000000,'ns'))
+        self.assertEqual(ct('1000s'), np.timedelta64(1000000000000,'ns'))
+
+        self.assertEqual(ct('1d'), conv(np.timedelta64(1,'D')))
+        self.assertEqual(ct('-1d'), -conv(np.timedelta64(1,'D')))
+        self.assertEqual(ct('1D'), conv(np.timedelta64(1,'D')))
+        self.assertEqual(ct('10D'), conv(np.timedelta64(10,'D')))
+        self.assertEqual(ct('100D'), conv(np.timedelta64(100,'D')))
+        self.assertEqual(ct('1000D'), conv(np.timedelta64(1000,'D')))
+        self.assertEqual(ct('10000D'), conv(np.timedelta64(10000,'D')))
 
         # space
-        self.assert_(ct(' 10000D ') == conv(np.timedelta64(10000,'D')))
-        self.assert_(ct(' - 10000D ') == -conv(np.timedelta64(10000,'D')))
+        self.assertEqual(ct(' 10000D '), conv(np.timedelta64(10000,'D')))
+        self.assertEqual(ct(' - 10000D '), -conv(np.timedelta64(10000,'D')))
 
         # invalid
         self.assertRaises(ValueError, ct, '1foo')
@@ -103,18 +103,18 @@ def conv(v):
             return v.astype('m8[ns]')
         d1 = np.timedelta64(1,'D')
 
-        self.assert_(ct('1days') == conv(d1))
-        self.assert_(ct('1days,') == conv(d1))
-        self.assert_(ct('- 1days,') == -conv(d1))
+        self.assertEqual(ct('1days'), conv(d1))
+        self.assertEqual(ct('1days,'), conv(d1))
+        self.assertEqual(ct('- 1days,'), -conv(d1))
 
-        self.assert_(ct('00:00:01') == conv(np.timedelta64(1,'s')))
-        self.assert_(ct('06:00:01') == conv(np.timedelta64(6*3600+1,'s')))
-        self.assert_(ct('06:00:01.0') == conv(np.timedelta64(6*3600+1,'s')))
-        self.assert_(ct('06:00:01.01') == conv(np.timedelta64(1000*(6*3600+1)+10,'ms')))
+        self.assertEqual(ct('00:00:01'), conv(np.timedelta64(1,'s')))
+        self.assertEqual(ct('06:00:01'), conv(np.timedelta64(6*3600+1,'s')))
+        self.assertEqual(ct('06:00:01.0'), conv(np.timedelta64(6*3600+1,'s')))
+        self.assertEqual(ct('06:00:01.01'), conv(np.timedelta64(1000*(6*3600+1)+10,'ms')))
 
-        self.assert_(ct('- 1days, 00:00:01') == -conv(d1+np.timedelta64(1,'s')))
-        self.assert_(ct('1days, 06:00:01') == conv(d1+np.timedelta64(6*3600+1,'s')))
-        self.assert_(ct('1days, 06:00:01.01') == conv(d1+np.timedelta64(1000*(6*3600+1)+10,'ms')))
+        self.assertEqual(ct('- 1days, 00:00:01'), -conv(d1+np.timedelta64(1,'s')))
+        self.assertEqual(ct('1days, 06:00:01'), conv(d1+np.timedelta64(6*3600+1,'s')))
+        self.assertEqual(ct('1days, 06:00:01.01'), conv(d1+np.timedelta64(1000*(6*3600+1)+10,'ms')))
 
         # invalid
         self.assertRaises(ValueError, ct, '- 1days, 00')
@@ -122,8 +122,8 @@ def conv(v):
     def test_nat_converters(self):
         _skip_if_numpy_not_friendly()
 
-        self.assert_(to_timedelta('nat',box=False) == tslib.iNaT)
-        self.assert_(to_timedelta('nan',box=False) == tslib.iNaT)
+        self.assertEqual(to_timedelta('nat',box=False), tslib.iNaT)
+        self.assertEqual(to_timedelta('nan',box=False), tslib.iNaT)
 
     def test_to_timedelta(self):
         _skip_if_numpy_not_friendly()
@@ -132,12 +132,12 @@ def conv(v):
             return v.astype('m8[ns]')
         d1 = np.timedelta64(1,'D')
 
-        self.assert_(to_timedelta('1 days 06:05:01.00003',box=False) == conv(d1+np.timedelta64(6*3600+5*60+1,'s')+np.timedelta64(30,'us')))
-        self.assert_(to_timedelta('15.5us',box=False) == conv(np.timedelta64(15500,'ns')))
+        self.assertEqual(to_timedelta('1 days 06:05:01.00003',box=False), conv(d1+np.timedelta64(6*3600+5*60+1,'s')+np.timedelta64(30,'us')))
+        self.assertEqual(to_timedelta('15.5us',box=False), conv(np.timedelta64(15500,'ns')))
 
         # empty string
         result = to_timedelta('',box=False)
-        self.assert_(result == tslib.iNaT)
+        self.assertEqual(result, tslib.iNaT)
 
         result = to_timedelta(['', ''])
         self.assert_(isnull(result).all())
@@ -150,7 +150,7 @@ def conv(v):
         # ints
         result = np.timedelta64(0,'ns')
         expected = to_timedelta(0,box=False)
-        self.assert_(result == expected)
+        self.assertEqual(result, expected)
 
         # Series
         expected = Series([timedelta(days=1), timedelta(days=1, seconds=1)])
@@ -166,12 +166,12 @@ def conv(v):
         v = timedelta(seconds=1)
         result = to_timedelta(v,box=False)
         expected = np.timedelta64(timedelta(seconds=1))
-        self.assert_(result == expected)
+        self.assertEqual(result, expected)
 
         v = np.timedelta64(timedelta(seconds=1))
         result = to_timedelta(v,box=False)
         expected = np.timedelta64(timedelta(seconds=1))
-        self.assert_(result == expected)
+        self.assertEqual(result, expected)
 
     def test_to_timedelta_via_apply(self):
         _skip_if_numpy_not_friendly()
@@ -221,10 +221,10 @@ def test_to_timedelta_on_missing_values(self):
         assert_series_equal(actual, expected)
 
         actual = pd.to_timedelta(np.nan)
-        self.assert_(actual == timedelta_NaT)
+        self.assertEqual(actual, timedelta_NaT)
 
         actual = pd.to_timedelta(pd.NaT)
-        self.assert_(actual == timedelta_NaT)
+        self.assertEqual(actual, timedelta_NaT)
 
     def test_timedelta_ops_with_missing_values(self):
         _skip_if_numpy_not_friendly()
@@ -242,9 +242,9 @@ def test_timedelta_ops_with_missing_values(self):
         NA = np.nan
 
         actual = scalar1 + scalar1
-        self.assert_(actual == scalar2)
+        self.assertEqual(actual, scalar2)
         actual = scalar2 - scalar1
-        self.assert_(actual == scalar1)
+        self.assertEqual(actual, scalar1)
 
         actual = s1 + s1
         assert_series_equal(actual, s2)