MAINT: Remove self.assert_* from testing (pandas-dev#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

Author: gfyoung

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