CLN: Convert last of assert_(x == y) to assertEqual

pandas/io/tests/test_json/test_ujson.py

@@ -387,16 +387,16 @@ def test_datetime_units(self):
         stamp = Timestamp(val)
 
         roundtrip = ujson.decode(ujson.encode(val, date_unit='s'))
-        self.assert_(roundtrip == stamp.value // 10**9)
+        self.assertEqual(roundtrip, stamp.value // 10**9)
 
         roundtrip = ujson.decode(ujson.encode(val, date_unit='ms'))
-        self.assert_(roundtrip == stamp.value // 10**6)
+        self.assertEqual(roundtrip, stamp.value // 10**6)
 
         roundtrip = ujson.decode(ujson.encode(val, date_unit='us'))
-        self.assert_(roundtrip == stamp.value // 10**3)
+        self.assertEqual(roundtrip, stamp.value // 10**3)
 
         roundtrip = ujson.decode(ujson.encode(val, date_unit='ns'))
-        self.assert_(roundtrip == stamp.value)
+        self.assertEqual(roundtrip, stamp.value)
 
         self.assertRaises(ValueError, ujson.encode, val, date_unit='foo')
 

pandas/io/tests/test_pytables.py

@@ -3140,7 +3140,8 @@ def test_retain_index_attributes(self):
 
             for attr in ['freq','tz','name']:
                 for idx in ['index','columns']:
-                    self.assert_(getattr(getattr(df,idx),attr,None) == getattr(getattr(result,idx),attr,None))
+                    self.assertEqual(getattr(getattr(df,idx),attr,None),
+                                     getattr(getattr(result,idx),attr,None))
 
 
             # try to append a table with a different frequency

pandas/stats/tests/test_ols.py

@@ -294,7 +294,7 @@ def test_r2_no_intercept(self):
         assert_series_equal(model1.beta, model2.beta)
 
         # TODO: can we infer whether the intercept is there...
-        self.assert_(model1.r2 != model2.r2)
+        self.assertNotEqual(model1.r2, model2.r2)
 
         # rolling
 

pandas/tests/test_format.py

@@ -798,7 +798,7 @@ def test_wide_repr(self):
             assert "10 rows x %d columns" % (max_cols - 1) in rep_str
             set_option('display.expand_frame_repr', True)
             wide_repr = repr(df)
-            self.assert_(rep_str != wide_repr)
+            self.assertNotEqual(rep_str, wide_repr)
 
             with option_context('display.width', 120):
                 wider_repr = repr(df)
@@ -824,7 +824,7 @@ def test_wide_repr_named(self):
             rep_str = repr(df)
             set_option('display.expand_frame_repr', True)
             wide_repr = repr(df)
-            self.assert_(rep_str != wide_repr)
+            self.assertNotEqual(rep_str, wide_repr)
 
             with option_context('display.width', 150):
                 wider_repr = repr(df)
@@ -848,7 +848,7 @@ def test_wide_repr_multiindex(self):
             rep_str = repr(df)
             set_option('display.expand_frame_repr', True)
             wide_repr = repr(df)
-            self.assert_(rep_str != wide_repr)
+            self.assertNotEqual(rep_str, wide_repr)
 
             with option_context('display.width', 150):
                 wider_repr = repr(df)
@@ -874,7 +874,7 @@ def test_wide_repr_multiindex_cols(self):
             rep_str = repr(df)
             set_option('display.expand_frame_repr', True)
             wide_repr = repr(df)
-            self.assert_(rep_str != wide_repr)
+            self.assertNotEqual(rep_str, wide_repr)
 
         with option_context('display.width', 150):
             wider_repr = repr(df)
@@ -891,7 +891,7 @@ def test_wide_repr_unicode(self):
             rep_str = repr(df)
             set_option('display.expand_frame_repr', True)
             wide_repr = repr(df)
-            self.assert_(rep_str != wide_repr)
+            self.assertNotEqual(rep_str, wide_repr)
 
             with option_context('display.width', 150):
                 wider_repr = repr(df)

pandas/tests/test_frame.py

@@ -1563,24 +1563,24 @@ def test_set_value_with_index_dtype_change(self):
         # so column is not created
         df = df_orig.copy()
         df.set_value('C', 2, 1.0)
-        self.assert_(list(df.index) == list(df_orig.index) + ['C'])
-        #self.assert_(list(df.columns) == list(df_orig.columns) + [2])
+        self.assertEqual(list(df.index), list(df_orig.index) + ['C'])
+        #self.assertEqual(list(df.columns), list(df_orig.columns) + [2])
 
         df = df_orig.copy()
         df.loc['C', 2] = 1.0
-        self.assert_(list(df.index) == list(df_orig.index) + ['C'])
-        #self.assert_(list(df.columns) == list(df_orig.columns) + [2])
+        self.assertEqual(list(df.index), list(df_orig.index) + ['C'])
+        #self.assertEqual(list(df.columns), list(df_orig.columns) + [2])
 
         # create both new
         df = df_orig.copy()
         df.set_value('C', 'D', 1.0)
-        self.assert_(list(df.index) == list(df_orig.index) + ['C'])
-        self.assert_(list(df.columns) == list(df_orig.columns) + ['D'])
+        self.assertEqual(list(df.index), list(df_orig.index) + ['C'])
+        self.assertEqual(list(df.columns), list(df_orig.columns) + ['D'])
 
         df = df_orig.copy()
         df.loc['C', 'D'] = 1.0
-        self.assert_(list(df.index) == list(df_orig.index) + ['C'])
-        self.assert_(list(df.columns) == list(df_orig.columns) + ['D'])
+        self.assertEqual(list(df.index), list(df_orig.index) + ['C'])
+        self.assertEqual(list(df.columns), list(df_orig.columns) + ['D'])
 
     def test_get_set_value_no_partial_indexing(self):
         # partial w/ MultiIndex raise exception
@@ -8835,7 +8835,7 @@ def test_rename_inplace(self):
 
         self.assert_('C' not in frame)
         self.assert_('foo' in frame)
-        self.assert_(id(frame['foo']) != c_id)
+        self.assertNotEqual(id(frame['foo']), c_id)
 
     def test_rename_bug(self):
         # GH 5344
@@ -9577,7 +9577,7 @@ def test_sort_index_inplace(self):
         df.sort_index(inplace=True)
         expected = frame
         assert_frame_equal(df, expected)
-        self.assert_(a_id != id(df['A']))
+        self.assertNotEqual(a_id, id(df['A']))
 
         df = unordered.copy()
         df.sort_index(ascending=False, inplace=True)

pandas/tests/test_panel.py

@@ -1358,7 +1358,7 @@ def test_swapaxes(self):
         # this works, but return a copy
         result = self.panel.swapaxes('items', 'items')
         assert_panel_equal(self.panel,result)
-        self.assert_(id(self.panel) != id(result))
+        self.assertNotEqual(id(self.panel), id(result))
 
     def test_transpose(self):
         result = self.panel.transpose('minor', 'major', 'items')

pandas/tests/test_panel4d.py

@@ -872,7 +872,7 @@ def test_swapaxes(self):
         # this works, but return a copy
         result = self.panel4d.swapaxes('items', 'items')
         assert_panel4d_equal(self.panel4d,result)
-        self.assert_(id(self.panel4d) != id(result))
+        self.assertNotEqual(id(self.panel4d), id(result))
 
     def test_to_frame(self):
         raise nose.SkipTest("skipping for now")

pandas/tseries/tests/test_offsets.py

@@ -150,7 +150,6 @@ def test_eq(self):
         offset1 = DateOffset(days=1)
         offset2 = DateOffset(days=365)
 
-        self.assert_(offset1 != offset2)
         self.assertNotEqual(offset1, offset2)
 
 
@@ -774,7 +773,7 @@ def test_onOffset(self):
 
         for weekday, date, expected in test_cases:
             offset = LastWeekOfMonth(weekday=weekday)
-            self.assert_(offset.onOffset(date) == expected, date)
+            self.assertEqual(offset.onOffset(date), expected, msg=date)
 
 
 class TestBMonthBegin(TestBase):

pandas/tseries/tests/test_period.py

@@ -199,7 +199,7 @@ def test_period_constructor(self):
 
     def test_freq_str(self):
         i1 = Period('1982', freq='Min')
-        self.assert_(i1.freq[0] != '1')
+        self.assertNotEqual(i1.freq[0], '1')
 
     def test_repr(self):
         p = Period('Jan-2000')
@@ -1191,19 +1191,19 @@ def test_is_(self):
         create_index = lambda: PeriodIndex(freq='A', start='1/1/2001',
                                            end='12/1/2009')
         index = create_index()
-        self.assertTrue(index.is_(index))
-        self.assertFalse(index.is_(create_index()))
-        self.assertTrue(index.is_(index.view()))
-        self.assertTrue(index.is_(index.view().view().view().view().view()))
-        self.assertTrue(index.view().is_(index))
+        self.assertEqual(index.is_(index), True)
+        self.assertEqual(index.is_(create_index()), False)
+        self.assertEqual(index.is_(index.view()), True)
+        self.assertEqual(index.is_(index.view().view().view().view().view()), True)
+        self.assertEqual(index.view().is_(index), True)
         ind2 = index.view()
         index.name = "Apple"
-        self.assertTrue(ind2.is_(index))
-        self.assertFalse(index.is_(index[:]))
-        self.assertFalse(index.is_(index.asfreq('M')))
-        self.assertFalse(index.is_(index.asfreq('A')))
-        self.assertFalse(index.is_(index - 2))
-        self.assertFalse(index.is_(index - 0))
+        self.assertEqual(ind2.is_(index), True)
+        self.assertEqual(index.is_(index[:]), False)
+        self.assertEqual(index.is_(index.asfreq('M')), False)
+        self.assertEqual(index.is_(index.asfreq('A')), False)
+        self.assertEqual(index.is_(index - 2), False)
+        self.assertEqual(index.is_(index - 0), False)
 
     def test_comp_period(self):
         idx = period_range('2007-01', periods=20, freq='M')

pandas/tseries/tests/test_timeseries.py

@@ -1729,9 +1729,9 @@ def test_timestamp_compare_with_early_datetime(self):
         self.assertFalse(stamp == datetime.min)
         self.assertFalse(stamp == datetime(1600, 1, 1))
         self.assertFalse(stamp == datetime(2700, 1, 1))
-        self.assert_(stamp != datetime.min)
-        self.assert_(stamp != datetime(1600, 1, 1))
-        self.assert_(stamp != datetime(2700, 1, 1))
+        self.assertNotEqual(stamp, datetime.min)
+        self.assertNotEqual(stamp, datetime(1600, 1, 1))
+        self.assertNotEqual(stamp, datetime(2700, 1, 1))
         self.assert_(stamp > datetime(1600, 1, 1))
         self.assert_(stamp >= datetime(1600, 1, 1))
         self.assert_(stamp < datetime(2700, 1, 1))
@@ -2593,28 +2593,28 @@ def test_comparison(self):
         val = Timestamp(stamp)
 
         self.assertEqual(val, val)
-        self.assert_(not val != val)
-        self.assert_(not val < val)
+        self.assertFalse(val != val)
+        self.assertFalse(val < val)
         self.assert_(val <= val)
-        self.assert_(not val > val)
+        self.assertFalse(val > val)
         self.assert_(val >= val)
 
         other = datetime(2012, 5, 18)
         self.assertEqual(val, other)
-        self.assert_(not val != other)
-        self.assert_(not val < other)
-        self.assert_(val <= other)
-        self.assert_(not val > other)
-        self.assert_(val >= other)
+        self.assertFalse(val != other)
+        self.assertFalse(val < other)
+        self.assertTrue(val <= other)
+        self.assertFalse(val > other)
+        self.assertTrue(val >= other)
 
         other = Timestamp(stamp + 100)
 
         self.assertNotEqual(val, other)
-        self.assert_(val != other)
-        self.assert_(val < other)
-        self.assert_(val <= other)
-        self.assert_(other > val)
-        self.assert_(other >= val)
+        self.assertNotEqual(val, other)
+        self.assertTrue(val < other)
+        self.assertTrue(val <= other)
+        self.assertTrue(other > val)
+        self.assertTrue(other >= val)
 
     def test_cant_compare_tz_naive_w_aware(self):
         _skip_if_no_pytz()