TST: Remove assertEquals

pandas/tests/test_categorical.py

@@ -1457,7 +1457,7 @@ def test_describe(self):
 
         # Categoricals should not show up together with numerical columns
         result = self.cat.describe()
-        self.assertEquals(len(result.columns),1)
+        self.assertEqual(len(result.columns),1)
 
 
         # In a frame, describe() for the cat should be the same as for string arrays (count, unique,

pandas/tests/test_common.py

@@ -955,7 +955,7 @@ def test_maybe_convert_string_to_array(self):
         self.assertTrue(result.dtype == object)
 
         result = com._maybe_convert_string_to_object(1)
-        self.assertEquals(result, 1)
+        self.assertEqual(result, 1)
 
         arr = np.array(['x', 'y'], dtype=str)
         result = com._maybe_convert_string_to_object(arr)

pandas/tests/test_frame.py

@@ -10411,7 +10411,7 @@ def test_applymap(self):
         df['timedelta'] = Timedelta('1 min')
         result = df.applymap(str)
         for f in ['datetime','timedelta']:
-            self.assertEquals(result.loc[0,f],str(df.loc[0,f]))
+            self.assertEqual(result.loc[0,f],str(df.loc[0,f]))
 
     def test_filter(self):
         # items

pandas/tests/test_indexing.py

@@ -899,22 +899,22 @@ def f():
         # GH 7814
         s = Series([1,2,3], index=list('abc'))
         result = s.at['a']
-        self.assertEquals(result, 1)
+        self.assertEqual(result, 1)
         self.assertRaises(ValueError, lambda : s.at[0])
 
         df = DataFrame({'A' : [1,2,3]},index=list('abc'))
         result = df.at['a','A']
-        self.assertEquals(result, 1)
+        self.assertEqual(result, 1)
         self.assertRaises(ValueError, lambda : df.at['a',0])
 
         s = Series([1,2,3], index=[3,2,1])
         result = s.at[1]
-        self.assertEquals(result, 3)
+        self.assertEqual(result, 3)
         self.assertRaises(ValueError, lambda : s.at['a'])
 
         df = DataFrame({0 : [1,2,3]},index=[3,2,1])
         result = df.at[1,0]
-        self.assertEquals(result, 3)
+        self.assertEqual(result, 3)
         self.assertRaises(ValueError, lambda : df.at['a',0])
 
     def test_loc_getitem_label_slice(self):

pandas/tests/test_multilevel.py

@@ -92,26 +92,26 @@ def test_append_index(self):
                            (1.2, datetime.datetime(2011, 1, 2, tzinfo=tz)),
                            (1.3, datetime.datetime(2011, 1, 3, tzinfo=tz))]
         expected = Index([1.1, 1.2, 1.3] + expected_tuples)
-        self.assert_(result.equals(expected))
+        self.assertTrue(result.equals(expected))
 
         result = midx_lv2.append(idx1)
         expected = Index(expected_tuples + [1.1, 1.2, 1.3])
-        self.assert_(result.equals(expected))
+        self.assertTrue(result.equals(expected))
 
         result = midx_lv2.append(midx_lv2)
         expected = MultiIndex.from_arrays([idx1.append(idx1), idx2.append(idx2)])
-        self.assert_(result.equals(expected))
+        self.assertTrue(result.equals(expected))
 
         result = midx_lv2.append(midx_lv3)
-        self.assert_(result.equals(expected))
+        self.assertTrue(result.equals(expected))
 
         result = midx_lv3.append(midx_lv2)
         expected = Index._simple_new(
             np.array([(1.1, datetime.datetime(2011, 1, 1, tzinfo=tz), 'A'),
                       (1.2, datetime.datetime(2011, 1, 2, tzinfo=tz), 'B'),
                       (1.3, datetime.datetime(2011, 1, 3, tzinfo=tz), 'C')]
                       + expected_tuples), None)
-        self.assert_(result.equals(expected))
+        self.assertTrue(result.equals(expected))
 
     def test_dataframe_constructor(self):
         multi = DataFrame(np.random.randn(4, 4),

pandas/tests/test_series.py

@@ -303,14 +303,14 @@ def test_get(self):
         df = pd.DataFrame({'i':[0]*3, 'b':[False]*3})
         vc = df.i.value_counts()
         result = vc.get(99,default='Missing')
-        self.assertEquals(result,'Missing')
+        self.assertEqual(result,'Missing')
 
         vc = df.b.value_counts()
         result = vc.get(False,default='Missing')
-        self.assertEquals(result,3)
+        self.assertEqual(result,3)
 
         result = vc.get(True,default='Missing')
-        self.assertEquals(result,'Missing')
+        self.assertEqual(result,'Missing')
 
     def test_delitem(self):
 
@@ -2240,7 +2240,7 @@ def test_sem(self):
         # 1 - element series with ddof=1
         s = self.ts.iloc[[0]]
         result = s.sem(ddof=1)
-        self.assert_(isnull(result))
+        self.assertTrue(isnull(result))
 
     def test_skew(self):
         tm._skip_if_no_scipy()
@@ -2606,7 +2606,7 @@ def test_all_any(self):
 
         # Alternative types, with implicit 'object' dtype.
         s = Series(['abc', True])
-        self.assertEquals('abc', s.any())  # 'abc' || True => 'abc'
+        self.assertEqual('abc', s.any())  # 'abc' || True => 'abc'
 
     def test_all_any_params(self):
         # Check skipna, with implicit 'object' dtype.
@@ -6414,17 +6414,17 @@ def test_pct_change_shift_over_nas(self):
     def test_autocorr(self):
         # Just run the function
         corr1 = self.ts.autocorr()
-        
+
         # Now run it with the lag parameter
         corr2 = self.ts.autocorr(lag=1)
-        
+
         # corr() with lag needs Series of at least length 2
         if len(self.ts) <= 2:
             self.assertTrue(np.isnan(corr1))
             self.assertTrue(np.isnan(corr2))
         else:
             self.assertEqual(corr1, corr2)
-        
+
         # Choose a random lag between 1 and length of Series - 2
         # and compare the result with the Series corr() function
         n = 1 + np.random.randint(max(1, len(self.ts) - 2))

pandas/tests/test_strings.py

@@ -653,13 +653,13 @@ def test_ismethods(self):
         tm.assert_series_equal(str_s.str.isupper(), Series(upper_e))
         tm.assert_series_equal(str_s.str.istitle(), Series(title_e))
 
-        self.assertEquals(str_s.str.isalnum().tolist(), [v.isalnum() for v in values])
-        self.assertEquals(str_s.str.isalpha().tolist(), [v.isalpha() for v in values])
-        self.assertEquals(str_s.str.isdigit().tolist(), [v.isdigit() for v in values])
-        self.assertEquals(str_s.str.isspace().tolist(), [v.isspace() for v in values])
-        self.assertEquals(str_s.str.islower().tolist(), [v.islower() for v in values])
-        self.assertEquals(str_s.str.isupper().tolist(), [v.isupper() for v in values])
-        self.assertEquals(str_s.str.istitle().tolist(), [v.istitle() for v in values])
+        self.assertEqual(str_s.str.isalnum().tolist(), [v.isalnum() for v in values])
+        self.assertEqual(str_s.str.isalpha().tolist(), [v.isalpha() for v in values])
+        self.assertEqual(str_s.str.isdigit().tolist(), [v.isdigit() for v in values])
+        self.assertEqual(str_s.str.isspace().tolist(), [v.isspace() for v in values])
+        self.assertEqual(str_s.str.islower().tolist(), [v.islower() for v in values])
+        self.assertEqual(str_s.str.isupper().tolist(), [v.isupper() for v in values])
+        self.assertEqual(str_s.str.istitle().tolist(), [v.istitle() for v in values])
 
     def test_isnumeric(self):
         # 0x00bc: ¼ VULGAR FRACTION ONE QUARTER
@@ -675,8 +675,8 @@ def test_isnumeric(self):
         tm.assert_series_equal(s.str.isdecimal(), Series(decimal_e))
         unicodes = [u('A'), u('3'), unichr(0x00bc), unichr(0x2605),
                   unichr(0x1378), unichr(0xFF13), u('four')]
-        self.assertEquals(s.str.isnumeric().tolist(), [v.isnumeric() for v in unicodes])
-        self.assertEquals(s.str.isdecimal().tolist(), [v.isdecimal() for v in unicodes])
+        self.assertEqual(s.str.isnumeric().tolist(), [v.isnumeric() for v in unicodes])
+        self.assertEqual(s.str.isdecimal().tolist(), [v.isdecimal() for v in unicodes])
 
         values = ['A', np.nan, unichr(0x00bc), unichr(0x2605),
                   np.nan, unichr(0xFF13), 'four']

pandas/tests/test_util.py

@@ -60,6 +60,26 @@ def f4(new=None):
                 pass
 
 
+class TestTesting(tm.TestCase):
+
+    def test_warning(self):
+
+        with tm.assert_produces_warning(FutureWarning):
+            self.assertEquals(1, 1)
+
+        with tm.assert_produces_warning(FutureWarning):
+            self.assertNotEquals(1, 2)
+
+        with tm.assert_produces_warning(FutureWarning):
+            self.assert_(True)
+
+        with tm.assert_produces_warning(FutureWarning):
+            self.assertAlmostEquals(1.0, 1.0000000001)
+
+        with tm.assert_produces_warning(FutureWarning):
+            self.assertNotAlmostEquals(1, 2)
+
+
 def test_rands():
     r = tm.rands(10)
     assert(len(r) == 10)

pandas/tseries/tests/test_base.py

@@ -39,9 +39,9 @@ def test_ops_properties_basic(self):
 
         # attribute access should still work!
         s = Series(dict(year=2000,month=1,day=10))
-        self.assertEquals(s.year,2000)
-        self.assertEquals(s.month,1)
-        self.assertEquals(s.day,10)
+        self.assertEqual(s.year,2000)
+        self.assertEqual(s.month,1)
+        self.assertEqual(s.day,10)
         self.assertRaises(AttributeError, lambda : s.weekday)
 
     def test_asobject_tolist(self):

pandas/tseries/tests/test_daterange.py

@@ -408,19 +408,19 @@ def test_range_tz_dateutil(self):
         end = datetime(2011, 1, 3, tzinfo=tz('US/Eastern'))
 
         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.assertTrue(dr.tz == tz('US/Eastern'))
+        self.assertTrue(dr[0] == start)
+        self.assertTrue(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.assertTrue(dr.tz == tz('US/Eastern'))
+        self.assertTrue(dr[0] == start)
+        self.assertTrue(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.assertTrue(dr.tz == tz('US/Eastern'))
+        self.assertTrue(dr[0] == start)
+        self.assertTrue(dr[2] == end)
 
     def test_month_range_union_tz_pytz(self):
         tm._skip_if_no_pytz()

pandas/tseries/tests/test_offsets.py

@@ -391,7 +391,7 @@ def test_add(self):
             for tz in self.timezones:
                 expected_localize = expected.tz_localize(tz)
                 result = Timestamp(dt, tz=tz) + offset_s
-                self.assert_(isinstance(result, Timestamp))
+                self.assertTrue(isinstance(result, Timestamp))
                 self.assertEqual(result, expected_localize)
 
             # normalize=True
@@ -407,7 +407,7 @@ def test_add(self):
             for tz in self.timezones:
                 expected_localize = expected.tz_localize(tz)
                 result = Timestamp(dt, tz=tz) + offset_s
-                self.assert_(isinstance(result, Timestamp))
+                self.assertTrue(isinstance(result, Timestamp))
                 self.assertEqual(result, expected_localize)
 
 
@@ -2842,20 +2842,20 @@ def test_Hour(self):
         assertEq(2 * Hour(), datetime(2010, 1, 1), datetime(2010, 1, 1, 2))
         assertEq(-1 * Hour(), datetime(2010, 1, 1, 1), datetime(2010, 1, 1))
 
-        self.assertEquals(Hour(3) + Hour(2), Hour(5))
-        self.assertEquals(Hour(3) - Hour(2), Hour())
+        self.assertEqual(Hour(3) + Hour(2), Hour(5))
+        self.assertEqual(Hour(3) - Hour(2), Hour())
 
-        self.assertNotEquals(Hour(4), Hour(1))
+        self.assertNotEqual(Hour(4), Hour(1))
 
     def test_Minute(self):
         assertEq(Minute(), datetime(2010, 1, 1), datetime(2010, 1, 1, 0, 1))
         assertEq(Minute(-1), datetime(2010, 1, 1, 0, 1), datetime(2010, 1, 1))
         assertEq(2 * Minute(), datetime(2010, 1, 1), datetime(2010, 1, 1, 0, 2))
         assertEq(-1 * Minute(), datetime(2010, 1, 1, 0, 1), datetime(2010, 1, 1))
 
-        self.assertEquals(Minute(3) + Minute(2), Minute(5))
-        self.assertEquals(Minute(3) - Minute(2), Minute())
-        self.assertNotEquals(Minute(5), Minute())
+        self.assertEqual(Minute(3) + Minute(2), Minute(5))
+        self.assertEqual(Minute(3) - Minute(2), Minute())
+        self.assertNotEqual(Minute(5), Minute())
 
     def test_Second(self):
         assertEq(Second(), datetime(2010, 1, 1), datetime(2010, 1, 1, 0, 0, 1))
@@ -2864,8 +2864,8 @@ def test_Second(self):
         assertEq(
             -1 * Second(), datetime(2010, 1, 1, 0, 0, 1), datetime(2010, 1, 1))
 
-        self.assertEquals(Second(3) + Second(2), Second(5))
-        self.assertEquals(Second(3) - Second(2), Second())
+        self.assertEqual(Second(3) + Second(2), Second(5))
+        self.assertEqual(Second(3) - Second(2), Second())
 
     def test_Millisecond(self):
         assertEq(Milli(), datetime(2010, 1, 1), datetime(2010, 1, 1, 0, 0, 0, 1000))
@@ -2874,8 +2874,8 @@ def test_Millisecond(self):
         assertEq(2 * Milli(), datetime(2010, 1, 1), datetime(2010, 1, 1, 0, 0, 0, 2000))
         assertEq(-1 * Milli(), datetime(2010, 1, 1, 0, 0, 0, 1000), datetime(2010, 1, 1))
 
-        self.assertEquals(Milli(3) + Milli(2), Milli(5))
-        self.assertEquals(Milli(3) - Milli(2), Milli())
+        self.assertEqual(Milli(3) + Milli(2), Milli(5))
+        self.assertEqual(Milli(3) - Milli(2), Milli())
 
     def test_MillisecondTimestampArithmetic(self):
         assertEq(Milli(), Timestamp('2010-01-01'), Timestamp('2010-01-01 00:00:00.001'))
@@ -2887,18 +2887,18 @@ def test_Microsecond(self):
         assertEq(2 * Micro(), datetime(2010, 1, 1), datetime(2010, 1, 1, 0, 0, 0, 2))
         assertEq(-1 * Micro(), datetime(2010, 1, 1, 0, 0, 0, 1), datetime(2010, 1, 1))
 
-        self.assertEquals(Micro(3) + Micro(2), Micro(5))
-        self.assertEquals(Micro(3) - Micro(2), Micro())
+        self.assertEqual(Micro(3) + Micro(2), Micro(5))
+        self.assertEqual(Micro(3) - Micro(2), Micro())
 
     def test_NanosecondGeneric(self):
         timestamp = Timestamp(datetime(2010, 1, 1))
-        self.assertEquals(timestamp.nanosecond, 0)
+        self.assertEqual(timestamp.nanosecond, 0)
 
         result = timestamp + Nano(10)
-        self.assertEquals(result.nanosecond, 10)
+        self.assertEqual(result.nanosecond, 10)
 
         reverse_result = Nano(10) + timestamp
-        self.assertEquals(reverse_result.nanosecond, 10)
+        self.assertEqual(reverse_result.nanosecond, 10)
 
     def test_Nanosecond(self):
         timestamp = Timestamp(datetime(2010, 1, 1))
@@ -2907,40 +2907,40 @@ def test_Nanosecond(self):
         assertEq(2 * Nano(), timestamp, timestamp + np.timedelta64(2, 'ns'))
         assertEq(-1 * Nano(), timestamp + np.timedelta64(1, 'ns'), timestamp)
 
-        self.assertEquals(Nano(3) + Nano(2), Nano(5))
-        self.assertEquals(Nano(3) - Nano(2), Nano())
+        self.assertEqual(Nano(3) + Nano(2), Nano(5))
+        self.assertEqual(Nano(3) - Nano(2), Nano())
 
         # GH9284
-        self.assertEquals(Nano(1) + Nano(10), Nano(11))
-        self.assertEquals(Nano(5) + Micro(1), Nano(1005))
-        self.assertEquals(Micro(5) + Nano(1), Nano(5001))
+        self.assertEqual(Nano(1) + Nano(10), Nano(11))
+        self.assertEqual(Nano(5) + Micro(1), Nano(1005))
+        self.assertEqual(Micro(5) + Nano(1), Nano(5001))
 
     def test_tick_zero(self):
         for t1 in self.ticks:
             for t2 in self.ticks:
-                self.assertEquals(t1(0), t2(0))
-                self.assertEquals(t1(0) + t2(0), t1(0))
+                self.assertEqual(t1(0), t2(0))
+                self.assertEqual(t1(0) + t2(0), t1(0))
 
                 if t1 is not Nano:
-                    self.assertEquals(t1(2) + t2(0), t1(2))
+                    self.assertEqual(t1(2) + t2(0), t1(2))
             if t1 is Nano:
-                self.assertEquals(t1(2) + Nano(0), t1(2))
+                self.assertEqual(t1(2) + Nano(0), t1(2))
 
     def test_tick_equalities(self):
         for t in self.ticks:
-            self.assertEquals(t(3), t(3))
-            self.assertEquals(t(), t(1))
+            self.assertEqual(t(3), t(3))
+            self.assertEqual(t(), t(1))
 
             # not equals
-            self.assertNotEquals(t(3), t(2))
-            self.assertNotEquals(t(3), t(-3))
+            self.assertNotEqual(t(3), t(2))
+            self.assertNotEqual(t(3), t(-3))
 
     def test_tick_operators(self):
         for t in self.ticks:
-            self.assertEquals(t(3) + t(2), t(5))
-            self.assertEquals(t(3) - t(2), t(1))
-            self.assertEquals(t(800) + t(300), t(1100))
-            self.assertEquals(t(1000) - t(5), t(995))
+            self.assertEqual(t(3) + t(2), t(5))
+            self.assertEqual(t(3) - t(2), t(1))
+            self.assertEqual(t(800) + t(300), t(1100))
+            self.assertEqual(t(1000) - t(5), t(995))
 
     def test_tick_offset(self):
         for t in self.ticks: