MAINT: Remove self.assert_* from testing (#16076)

* MAINT: Remove self.assert_almost_equal from testing

* MAINT: Remove self.assert_index_equal from testing

* MAINT: Remove self.assert_categorical_equal from testing

* MAINT: Remove self.assert_numpy_array_equal from testing

* MAINT: Remove self.assert_series_equal from testing

* MAINT: Remove self.assert_frame_equal from testing

* MAINT: Remove self.assert_produces_warning from testing

pandas/tests/dtypes/test_io.py

@@ -13,64 +13,64 @@ def test_convert_sql_column_floats(self):
         arr = np.array([1.5, None, 3, 4.2], dtype=object)
         result = lib.convert_sql_column(arr)
         expected = np.array([1.5, np.nan, 3, 4.2], dtype='f8')
-        self.assert_numpy_array_equal(result, expected)
+        tm.assert_numpy_array_equal(result, expected)
 
     def test_convert_sql_column_strings(self):
         arr = np.array(['1.5', None, '3', '4.2'], dtype=object)
         result = lib.convert_sql_column(arr)
         expected = np.array(['1.5', np.nan, '3', '4.2'], dtype=object)
-        self.assert_numpy_array_equal(result, expected)
+        tm.assert_numpy_array_equal(result, expected)
 
     def test_convert_sql_column_unicode(self):
         arr = np.array([u('1.5'), None, u('3'), u('4.2')],
                        dtype=object)
         result = lib.convert_sql_column(arr)
         expected = np.array([u('1.5'), np.nan, u('3'), u('4.2')],
                             dtype=object)
-        self.assert_numpy_array_equal(result, expected)
+        tm.assert_numpy_array_equal(result, expected)
 
     def test_convert_sql_column_ints(self):
         arr = np.array([1, 2, 3, 4], dtype='O')
         arr2 = np.array([1, 2, 3, 4], dtype='i4').astype('O')
         result = lib.convert_sql_column(arr)
         result2 = lib.convert_sql_column(arr2)
         expected = np.array([1, 2, 3, 4], dtype='i8')
-        self.assert_numpy_array_equal(result, expected)
-        self.assert_numpy_array_equal(result2, expected)
+        tm.assert_numpy_array_equal(result, expected)
+        tm.assert_numpy_array_equal(result2, expected)
 
         arr = np.array([1, 2, 3, None, 4], dtype='O')
         result = lib.convert_sql_column(arr)
         expected = np.array([1, 2, 3, np.nan, 4], dtype='f8')
-        self.assert_numpy_array_equal(result, expected)
+        tm.assert_numpy_array_equal(result, expected)
 
     def test_convert_sql_column_longs(self):
         arr = np.array([long(1), long(2), long(3), long(4)], dtype='O')
         result = lib.convert_sql_column(arr)
         expected = np.array([1, 2, 3, 4], dtype='i8')
-        self.assert_numpy_array_equal(result, expected)
+        tm.assert_numpy_array_equal(result, expected)
 
         arr = np.array([long(1), long(2), long(3), None, long(4)], dtype='O')
         result = lib.convert_sql_column(arr)
         expected = np.array([1, 2, 3, np.nan, 4], dtype='f8')
-        self.assert_numpy_array_equal(result, expected)
+        tm.assert_numpy_array_equal(result, expected)
 
     def test_convert_sql_column_bools(self):
         arr = np.array([True, False, True, False], dtype='O')
         result = lib.convert_sql_column(arr)
         expected = np.array([True, False, True, False], dtype=bool)
-        self.assert_numpy_array_equal(result, expected)
+        tm.assert_numpy_array_equal(result, expected)
 
         arr = np.array([True, False, None, False], dtype='O')
         result = lib.convert_sql_column(arr)
         expected = np.array([True, False, np.nan, False], dtype=object)
-        self.assert_numpy_array_equal(result, expected)
+        tm.assert_numpy_array_equal(result, expected)
 
     def test_convert_sql_column_decimals(self):
         from decimal import Decimal
         arr = np.array([Decimal('1.5'), None, Decimal('3'), Decimal('4.2')])
         result = lib.convert_sql_column(arr)
         expected = np.array([1.5, np.nan, 3, 4.2], dtype='f8')
-        self.assert_numpy_array_equal(result, expected)
+        tm.assert_numpy_array_equal(result, expected)
 
     def test_convert_downcast_int64(self):
         from pandas.io.libparsers import na_values
@@ -80,30 +80,30 @@ def test_convert_downcast_int64(self):
 
         # default argument
         result = lib.downcast_int64(arr, na_values)
-        self.assert_numpy_array_equal(result, expected)
+        tm.assert_numpy_array_equal(result, expected)
 
         result = lib.downcast_int64(arr, na_values, use_unsigned=False)
-        self.assert_numpy_array_equal(result, expected)
+        tm.assert_numpy_array_equal(result, expected)
 
         expected = np.array([1, 2, 7, 8, 10], dtype=np.uint8)
         result = lib.downcast_int64(arr, na_values, use_unsigned=True)
-        self.assert_numpy_array_equal(result, expected)
+        tm.assert_numpy_array_equal(result, expected)
 
         # still cast to int8 despite use_unsigned=True
         # because of the negative number as an element
         arr = np.array([1, 2, -7, 8, 10], dtype=np.int64)
         expected = np.array([1, 2, -7, 8, 10], dtype=np.int8)
         result = lib.downcast_int64(arr, na_values, use_unsigned=True)
-        self.assert_numpy_array_equal(result, expected)
+        tm.assert_numpy_array_equal(result, expected)
 
         arr = np.array([1, 2, 7, 8, 300], dtype=np.int64)
         expected = np.array([1, 2, 7, 8, 300], dtype=np.int16)
         result = lib.downcast_int64(arr, na_values)
-        self.assert_numpy_array_equal(result, expected)
+        tm.assert_numpy_array_equal(result, expected)
 
         int8_na = na_values[np.int8]
         int64_na = na_values[np.int64]
         arr = np.array([int64_na, 2, 3, 10, 15], dtype=np.int64)
         expected = np.array([int8_na, 2, 3, 10, 15], dtype=np.int8)
         result = lib.downcast_int64(arr, na_values)
-        self.assert_numpy_array_equal(result, expected)
+        tm.assert_numpy_array_equal(result, expected)

pandas/tests/dtypes/test_missing.py

@@ -148,18 +148,18 @@ def test_isnull_datetime(self):
         mask = isnull(idx)
         self.assertTrue(mask[0])
         exp = np.array([True] + [False] * (len(idx) - 1), dtype=bool)
-        self.assert_numpy_array_equal(mask, exp)
+        tm.assert_numpy_array_equal(mask, exp)
 
         # GH 9129
         pidx = idx.to_period(freq='M')
         mask = isnull(pidx)
         self.assertTrue(mask[0])
         exp = np.array([True] + [False] * (len(idx) - 1), dtype=bool)
-        self.assert_numpy_array_equal(mask, exp)
+        tm.assert_numpy_array_equal(mask, exp)
 
         mask = isnull(pidx[1:])
         exp = np.zeros(len(mask), dtype=bool)
-        self.assert_numpy_array_equal(mask, exp)
+        tm.assert_numpy_array_equal(mask, exp)
 
     def test_datetime_other_units(self):
         idx = pd.DatetimeIndex(['2011-01-01', 'NaT', '2011-01-02'])

pandas/tests/frame/test_alter_axes.py

@@ -233,7 +233,7 @@ def test_set_index_cast_datetimeindex(self):
         result = df['C']
         comp = pd.DatetimeIndex(expected.values).copy()
         comp.tz = None
-        self.assert_numpy_array_equal(result.values, comp.values)
+        tm.assert_numpy_array_equal(result.values, comp.values)
 
         # list of datetimes with a tz
         df['D'] = i.to_pydatetime()
@@ -436,8 +436,8 @@ def test_rename_multiindex(self):
         new_columns = MultiIndex.from_tuples([('fizz3', 'buzz1'),
                                               ('fizz2', 'buzz3')],
                                              names=['fizz', 'buzz'])
-        self.assert_index_equal(renamed.index, new_index)
-        self.assert_index_equal(renamed.columns, new_columns)
+        tm.assert_index_equal(renamed.index, new_index)
+        tm.assert_index_equal(renamed.columns, new_columns)
         self.assertEqual(renamed.index.names, df.index.names)
         self.assertEqual(renamed.columns.names, df.columns.names)
 
@@ -450,46 +450,46 @@ def test_rename_multiindex(self):
                                              names=['fizz', 'buzz'])
         renamed = df.rename(columns={'fizz1': 'fizz3', 'buzz2': 'buzz3'},
                             level=0)
-        self.assert_index_equal(renamed.columns, new_columns)
+        tm.assert_index_equal(renamed.columns, new_columns)
         renamed = df.rename(columns={'fizz1': 'fizz3', 'buzz2': 'buzz3'},
                             level='fizz')
-        self.assert_index_equal(renamed.columns, new_columns)
+        tm.assert_index_equal(renamed.columns, new_columns)
 
         new_columns = MultiIndex.from_tuples([('fizz1', 'buzz1'),
                                               ('fizz2', 'buzz3')],
                                              names=['fizz', 'buzz'])
         renamed = df.rename(columns={'fizz1': 'fizz3', 'buzz2': 'buzz3'},
                             level=1)
-        self.assert_index_equal(renamed.columns, new_columns)
+        tm.assert_index_equal(renamed.columns, new_columns)
         renamed = df.rename(columns={'fizz1': 'fizz3', 'buzz2': 'buzz3'},
                             level='buzz')
-        self.assert_index_equal(renamed.columns, new_columns)
+        tm.assert_index_equal(renamed.columns, new_columns)
 
         # function
         func = str.upper
         new_columns = MultiIndex.from_tuples([('FIZZ1', 'buzz1'),
                                               ('FIZZ2', 'buzz2')],
                                              names=['fizz', 'buzz'])
         renamed = df.rename(columns=func, level=0)
-        self.assert_index_equal(renamed.columns, new_columns)
+        tm.assert_index_equal(renamed.columns, new_columns)
         renamed = df.rename(columns=func, level='fizz')
-        self.assert_index_equal(renamed.columns, new_columns)
+        tm.assert_index_equal(renamed.columns, new_columns)
 
         new_columns = MultiIndex.from_tuples([('fizz1', 'BUZZ1'),
                                               ('fizz2', 'BUZZ2')],
                                              names=['fizz', 'buzz'])
         renamed = df.rename(columns=func, level=1)
-        self.assert_index_equal(renamed.columns, new_columns)
+        tm.assert_index_equal(renamed.columns, new_columns)
         renamed = df.rename(columns=func, level='buzz')
-        self.assert_index_equal(renamed.columns, new_columns)
+        tm.assert_index_equal(renamed.columns, new_columns)
 
         # index
         new_index = MultiIndex.from_tuples([('foo3', 'bar1'),
                                             ('foo2', 'bar2')],
                                            names=['foo', 'bar'])
         renamed = df.rename(index={'foo1': 'foo3', 'bar2': 'bar3'},
                             level=0)
-        self.assert_index_equal(renamed.index, new_index)
+        tm.assert_index_equal(renamed.index, new_index)
 
     def test_rename_nocopy(self):
         renamed = self.frame.rename(columns={'C': 'foo'}, copy=False)
@@ -587,22 +587,22 @@ def test_reset_index(self):
         # default name assigned
         rdf = self.frame.reset_index()
         exp = pd.Series(self.frame.index.values, name='index')
-        self.assert_series_equal(rdf['index'], exp)
+        tm.assert_series_equal(rdf['index'], exp)
 
         # default name assigned, corner case
         df = self.frame.copy()
         df['index'] = 'foo'
         rdf = df.reset_index()
         exp = pd.Series(self.frame.index.values, name='level_0')
-        self.assert_series_equal(rdf['level_0'], exp)
+        tm.assert_series_equal(rdf['level_0'], exp)
 
         # but this is ok
         self.frame.index.name = 'index'
         deleveled = self.frame.reset_index()
-        self.assert_series_equal(deleveled['index'],
-                                 pd.Series(self.frame.index))
-        self.assert_index_equal(deleveled.index,
-                                pd.Index(np.arange(len(deleveled))))
+        tm.assert_series_equal(deleveled['index'],
+                               pd.Series(self.frame.index))
+        tm.assert_index_equal(deleveled.index,
+                              pd.Index(np.arange(len(deleveled))))
 
         # preserve column names
         self.frame.columns.name = 'columns'

pandas/tests/frame/test_analytics.py

@@ -935,13 +935,13 @@ def test_mean_corner(self):
         # unit test when have object data
         the_mean = self.mixed_frame.mean(axis=0)
         the_sum = self.mixed_frame.sum(axis=0, numeric_only=True)
-        self.assert_index_equal(the_sum.index, the_mean.index)
+        tm.assert_index_equal(the_sum.index, the_mean.index)
         self.assertTrue(len(the_mean.index) < len(self.mixed_frame.columns))
 
         # xs sum mixed type, just want to know it works...
         the_mean = self.mixed_frame.mean(axis=1)
         the_sum = self.mixed_frame.sum(axis=1, numeric_only=True)
-        self.assert_index_equal(the_sum.index, the_mean.index)
+        tm.assert_index_equal(the_sum.index, the_mean.index)
 
         # take mean of boolean column
         self.frame['bool'] = self.frame['A'] > 0
@@ -1758,7 +1758,7 @@ def test_round_issue(self):
 
         dfs = pd.concat((df, df), axis=1)
         rounded = dfs.round()
-        self.assert_index_equal(rounded.index, dfs.index)
+        tm.assert_index_equal(rounded.index, dfs.index)
 
         decimals = pd.Series([1, 0, 2], index=['A', 'B', 'A'])
         self.assertRaises(ValueError, df.round, decimals)

pandas/tests/frame/test_api.py

@@ -60,11 +60,11 @@ def test_get_value(self):
     def test_add_prefix_suffix(self):
         with_prefix = self.frame.add_prefix('foo#')
         expected = pd.Index(['foo#%s' % c for c in self.frame.columns])
-        self.assert_index_equal(with_prefix.columns, expected)
+        tm.assert_index_equal(with_prefix.columns, expected)
 
         with_suffix = self.frame.add_suffix('#foo')
         expected = pd.Index(['%s#foo' % c for c in self.frame.columns])
-        self.assert_index_equal(with_suffix.columns, expected)
+        tm.assert_index_equal(with_suffix.columns, expected)
 
 
 class TestDataFrameMisc(tm.TestCase, SharedWithSparse, TestData):

pandas/tests/frame/test_axis_select_reindex.py

@@ -49,19 +49,19 @@ def test_drop_names(self):
         # errors = 'ignore'
         dropped = df.drop(['g'], errors='ignore')
         expected = Index(['a', 'b', 'c'], name='first')
-        self.assert_index_equal(dropped.index, expected)
+        tm.assert_index_equal(dropped.index, expected)
 
         dropped = df.drop(['b', 'g'], errors='ignore')
         expected = Index(['a', 'c'], name='first')
-        self.assert_index_equal(dropped.index, expected)
+        tm.assert_index_equal(dropped.index, expected)
 
         dropped = df.drop(['g'], axis=1, errors='ignore')
         expected = Index(['d', 'e', 'f'], name='second')
-        self.assert_index_equal(dropped.columns, expected)
+        tm.assert_index_equal(dropped.columns, expected)
 
         dropped = df.drop(['d', 'g'], axis=1, errors='ignore')
         expected = Index(['e', 'f'], name='second')
-        self.assert_index_equal(dropped.columns, expected)
+        tm.assert_index_equal(dropped.columns, expected)
 
     def test_drop_col_still_multiindex(self):
         arrays = [['a', 'b', 'c', 'top'],
@@ -221,7 +221,7 @@ def test_reindex(self):
 
         # pass non-Index
         newFrame = self.frame.reindex(list(self.ts1.index))
-        self.assert_index_equal(newFrame.index, self.ts1.index)
+        tm.assert_index_equal(newFrame.index, self.ts1.index)
 
         # copy with no axes
         result = self.frame.reindex()
@@ -866,7 +866,7 @@ def test_reindex_corner(self):
         index = Index(['a', 'b', 'c'])
         dm = self.empty.reindex(index=[1, 2, 3])
         reindexed = dm.reindex(columns=index)
-        self.assert_index_equal(reindexed.columns, index)
+        tm.assert_index_equal(reindexed.columns, index)
 
         # ints are weird
         smaller = self.intframe.reindex(columns=['A', 'B', 'E'])

pandas/tests/frame/test_block_internals.py

@@ -517,8 +517,8 @@ def test_get_X_columns(self):
                         'd': [None, None, None],
                         'e': [3.14, 0.577, 2.773]})
 
-        self.assert_index_equal(df._get_numeric_data().columns,
-                                pd.Index(['a', 'b', 'e']))
+        tm.assert_index_equal(df._get_numeric_data().columns,
+                              pd.Index(['a', 'b', 'e']))
 
     def test_strange_column_corruption_issue(self):
         # (wesm) Unclear how exactly this is related to internal matters