Merge pull request #6198 from bwignall/assert_6175_2 (reworked)

* bwignall-assert_6175_2:
  CLN: test_timedeltas, specialize assert_
  CLN: test_resample, specialize assert_
  CLN: test_plotting, specialize assert_
  CLN: Changing some 'assert_'s to 'assert[Not]Equal', as per GH6175

Author: y-p

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()

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'])

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 = [

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,17 +1894,17 @@ 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')
 
         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

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]