MAINT: Remove self.assertEqual from testing (#16169)

Author: gfyoung

pandas/compat/__init__.py

@@ -104,6 +104,7 @@ def signature(f):
  map = map
  zip = zip
  filter = filter
+ intern = sys.intern
  reduce = functools.reduce
  long = int
  unichr = chr
@@ -146,6 +147,7 @@ def signature(f):
 
  # import iterator versions of these functions
  range = xrange
+ intern = intern
  zip = itertools.izip
  filter = itertools.ifilter
  map = itertools.imap

pandas/tests/computation/test_eval.py

@@ -8,7 +8,7 @@
 from numpy.random import randn, rand, randint
 import numpy as np
 
-from pandas.core.dtypes.common import is_list_like, is_scalar
+from pandas.core.dtypes.common import is_bool, is_list_like, is_scalar
 import pandas as pd
 from pandas.core import common as com
 from pandas.errors import PerformanceWarning
@@ -209,7 +209,7 @@ def check_equal(self, result, expected):
  elif isinstance(result, np.ndarray):
  tm.assert_numpy_array_equal(result, expected)
  else:
- self.assertEqual(result, expected)
+ assert result == expected
 
  def check_complex_cmp_op(self, lhs, cmp1, rhs, binop, cmp2):
  skip_these = _scalar_skip
@@ -610,30 +610,28 @@ def test_scalar_unary(self):
  with pytest.raises(TypeError):
  pd.eval('~1.0', engine=self.engine, parser=self.parser)
 
- self.assertEqual(
- pd.eval('-1.0', parser=self.parser, engine=self.engine), -1.0)
- self.assertEqual(
- pd.eval('+1.0', parser=self.parser, engine=self.engine), +1.0)
-
- self.assertEqual(
- pd.eval('~1', parser=self.parser, engine=self.engine), ~1)
- self.assertEqual(
- pd.eval('-1', parser=self.parser, engine=self.engine), -1)
- self.assertEqual(
- pd.eval('+1', parser=self.parser, engine=self.engine), +1)
-
- self.assertEqual(
- pd.eval('~True', parser=self.parser, engine=self.engine), ~True)
- self.assertEqual(
- pd.eval('~False', parser=self.parser, engine=self.engine), ~False)
- self.assertEqual(
- pd.eval('-True', parser=self.parser, engine=self.engine), -True)
- self.assertEqual(
- pd.eval('-False', parser=self.parser, engine=self.engine), -False)
- self.assertEqual(
- pd.eval('+True', parser=self.parser, engine=self.engine), +True)
- self.assertEqual(
- pd.eval('+False', parser=self.parser, engine=self.engine), +False)
+ assert pd.eval('-1.0', parser=self.parser,
+ engine=self.engine) == -1.0
+ assert pd.eval('+1.0', parser=self.parser,
+ engine=self.engine) == +1.0
+ assert pd.eval('~1', parser=self.parser,
+ engine=self.engine) == ~1
+ assert pd.eval('-1', parser=self.parser,
+ engine=self.engine) == -1
+ assert pd.eval('+1', parser=self.parser,
+ engine=self.engine) == +1
+ assert pd.eval('~True', parser=self.parser,
+ engine=self.engine) == ~True
+ assert pd.eval('~False', parser=self.parser,
+ engine=self.engine) == ~False
+ assert pd.eval('-True', parser=self.parser,
+ engine=self.engine) == -True
+ assert pd.eval('-False', parser=self.parser,
+ engine=self.engine) == -False
+ assert pd.eval('+True', parser=self.parser,
+ engine=self.engine) == +True
+ assert pd.eval('+False', parser=self.parser,
+ engine=self.engine) == +False
 
  def test_unary_in_array(self):
  # GH 11235
@@ -658,50 +656,51 @@ def test_disallow_scalar_bool_ops(self):
  pd.eval(ex, engine=self.engine, parser=self.parser)
 
  def test_identical(self):
- # GH 10546
+ # see gh-10546
  x = 1
  result = pd.eval('x', engine=self.engine, parser=self.parser)
- self.assertEqual(result, 1)
+ assert result == 1
  assert is_scalar(result)
 
  x = 1.5
  result = pd.eval('x', engine=self.engine, parser=self.parser)
- self.assertEqual(result, 1.5)
+ assert result == 1.5
  assert is_scalar(result)
 
  x = False
  result = pd.eval('x', engine=self.engine, parser=self.parser)
- self.assertEqual(result, False)
+ assert not result
+ assert is_bool(result)
  assert is_scalar(result)
 
  x = np.array([1])
  result = pd.eval('x', engine=self.engine, parser=self.parser)
  tm.assert_numpy_array_equal(result, np.array([1]))
- self.assertEqual(result.shape, (1, ))
+ assert result.shape == (1, )
 
  x = np.array([1.5])
  result = pd.eval('x', engine=self.engine, parser=self.parser)
  tm.assert_numpy_array_equal(result, np.array([1.5]))
- self.assertEqual(result.shape, (1, ))
+ assert result.shape == (1, )
 
  x = np.array([False]) # noqa
  result = pd.eval('x', engine=self.engine, parser=self.parser)
  tm.assert_numpy_array_equal(result, np.array([False]))
- self.assertEqual(result.shape, (1, ))
+ assert result.shape == (1, )
 
  def test_line_continuation(self):
  # GH 11149
  exp = """1 + 2 * \
  5 - 1 + 2 """
  result = pd.eval(exp, engine=self.engine, parser=self.parser)
- self.assertEqual(result, 12)
+ assert result == 12
 
  def test_float_truncation(self):
  # GH 14241
  exp = '1000000000.006'
  result = pd.eval(exp, engine=self.engine, parser=self.parser)
  expected = np.float64(exp)
- self.assertEqual(result, expected)
+ assert result == expected
 
  df = pd.DataFrame({'A': [1000000000.0009,
  1000000000.0011,
@@ -1121,15 +1120,15 @@ def test_simple_bool_ops(self):
  ex = '{0} {1} {2}'.format(lhs, op, rhs)
  res = self.eval(ex)
  exp = eval(ex)
- self.assertEqual(res, exp)
+ assert res == exp
 
  def test_bool_ops_with_constants(self):
  for op, lhs, rhs in product(expr._bool_ops_syms, ('True', 'False'),
  ('True', 'False')):
  ex = '{0} {1} {2}'.format(lhs, op, rhs)
  res = self.eval(ex)
  exp = eval(ex)
- self.assertEqual(res, exp)
+ assert res == exp
 
  def test_panel_fails(self):
  with catch_warnings(record=True):
@@ -1169,19 +1168,19 @@ def test_truediv(self):
 
  res = self.eval('1 / 2', truediv=True)
  expec = 0.5
- self.assertEqual(res, expec)
+ assert res == expec
 
  res = self.eval('1 / 2', truediv=False)
  expec = 0.5
- self.assertEqual(res, expec)
+ assert res == expec
 
  res = self.eval('s / 2', truediv=False)
  expec = 0.5
- self.assertEqual(res, expec)
+ assert res == expec
 
  res = self.eval('s / 2', truediv=True)
  expec = 0.5
- self.assertEqual(res, expec)
+ assert res == expec
  else:
  res = self.eval(ex, truediv=False)
  tm.assert_numpy_array_equal(res, np.array([1]))
@@ -1191,19 +1190,19 @@ def test_truediv(self):
 
  res = self.eval('1 / 2', truediv=True)
  expec = 0.5
- self.assertEqual(res, expec)
+ assert res == expec
 
  res = self.eval('1 / 2', truediv=False)
  expec = 0
- self.assertEqual(res, expec)
+ assert res == expec
 
  res = self.eval('s / 2', truediv=False)
  expec = 0
- self.assertEqual(res, expec)
+ assert res == expec
 
  res = self.eval('s / 2', truediv=True)
  expec = 0.5
- self.assertEqual(res, expec)
+ assert res == expec
 
  def test_failing_subscript_with_name_error(self):
  df = DataFrame(np.random.randn(5, 3)) # noqa
@@ -1549,7 +1548,7 @@ def test_bool_ops_with_constants(self):
  else:
  res = self.eval(ex)
  exp = eval(ex)
- self.assertEqual(res, exp)
+ assert res == exp
 
  def test_simple_bool_ops(self):
  for op, lhs, rhs in product(expr._bool_ops_syms, (True, False),
@@ -1561,7 +1560,7 @@ def test_simple_bool_ops(self):
  else:
  res = pd.eval(ex, engine=self.engine, parser=self.parser)
  exp = eval(ex)
- self.assertEqual(res, exp)
+ assert res == exp
 
 
 class TestOperationsPythonPython(TestOperationsNumExprPython):
@@ -1650,14 +1649,14 @@ def test_df_arithmetic_subexpression(self):
 
  def check_result_type(self, dtype, expect_dtype):
  df = DataFrame({'a': np.random.randn(10).astype(dtype)})
- self.assertEqual(df.a.dtype, dtype)
+ assert df.a.dtype == dtype
  df.eval("b = sin(a)",
  engine=self.engine,
  parser=self.parser, inplace=True)
  got = df.b
  expect = np.sin(df.a)
- self.assertEqual(expect.dtype, got.dtype)
- self.assertEqual(expect_dtype, got.dtype)
+ assert expect.dtype == got.dtype
+ assert expect_dtype == got.dtype
  tm.assert_series_equal(got, expect, check_names=False)
 
  def test_result_types(self):

pandas/tests/dtypes/test_cast.py

@@ -164,7 +164,7 @@ def test_maybe_convert_string_to_array(self):
  assert result.dtype == object
 
  result = maybe_convert_string_to_object(1)
- self.assertEqual(result, 1)
+ assert result == 1
 
  arr = np.array(['x', 'y'], dtype=str)
  result = maybe_convert_string_to_object(arr)
@@ -187,31 +187,31 @@ def test_maybe_convert_scalar(self):
 
  # pass thru
  result = maybe_convert_scalar('x')
- self.assertEqual(result, 'x')
+ assert result == 'x'
  result = maybe_convert_scalar(np.array([1]))
- self.assertEqual(result, np.array([1]))
+ assert result == np.array([1])
 
  # leave scalar dtype
  result = maybe_convert_scalar(np.int64(1))
- self.assertEqual(result, np.int64(1))
+ assert result == np.int64(1)
  result = maybe_convert_scalar(np.int32(1))
- self.assertEqual(result, np.int32(1))
+ assert result == np.int32(1)
  result = maybe_convert_scalar(np.float32(1))
- self.assertEqual(result, np.float32(1))
+ assert result == np.float32(1)
  result = maybe_convert_scalar(np.int64(1))
- self.assertEqual(result, np.float64(1))
+ assert result == np.float64(1)
 
  # coerce
  result = maybe_convert_scalar(1)
- self.assertEqual(result, np.int64(1))
+ assert result == np.int64(1)
  result = maybe_convert_scalar(1.0)
- self.assertEqual(result, np.float64(1))
+ assert result == np.float64(1)
  result = maybe_convert_scalar(Timestamp('20130101'))
- self.assertEqual(result, Timestamp('20130101').value)
+ assert result == Timestamp('20130101').value
  result = maybe_convert_scalar(datetime(2013, 1, 1))
- self.assertEqual(result, Timestamp('20130101').value)
+ assert result == Timestamp('20130101').value
  result = maybe_convert_scalar(Timedelta('1 day 1 min'))
- self.assertEqual(result, Timedelta('1 day 1 min').value)
+ assert result == Timedelta('1 day 1 min').value
 
 
 class TestConvert(tm.TestCase):
@@ -291,34 +291,33 @@ def test_numpy_dtypes(self):
  ((np.dtype('datetime64[ns]'), np.int64), np.object)
  )
  for src, common in testcases:
- self.assertEqual(find_common_type(src), common)
+ assert find_common_type(src) == common
 
  with pytest.raises(ValueError):
  # empty
  find_common_type([])
 
  def test_categorical_dtype(self):
  dtype = CategoricalDtype()
- self.assertEqual(find_common_type([dtype]), 'category')
- self.assertEqual(find_common_type([dtype, dtype]), 'category')
- self.assertEqual(find_common_type([np.object, dtype]), np.object)
+ assert find_common_type([dtype]) == 'category'
+ assert find_common_type([dtype, dtype]) == 'category'
+ assert find_common_type([np.object, dtype]) == np.object
 
  def test_datetimetz_dtype(self):
  dtype = DatetimeTZDtype(unit='ns', tz='US/Eastern')
- self.assertEqual(find_common_type([dtype, dtype]),
- 'datetime64[ns, US/Eastern]')
+ assert find_common_type([dtype, dtype]) == 'datetime64[ns, US/Eastern]'
 
  for dtype2 in [DatetimeTZDtype(unit='ns', tz='Asia/Tokyo'),
  np.dtype('datetime64[ns]'), np.object, np.int64]:
- self.assertEqual(find_common_type([dtype, dtype2]), np.object)
- self.assertEqual(find_common_type([dtype2, dtype]), np.object)
+ assert find_common_type([dtype, dtype2]) == np.object
+ assert find_common_type([dtype2, dtype]) == np.object
 
  def test_period_dtype(self):
  dtype = PeriodDtype(freq='D')
- self.assertEqual(find_common_type([dtype, dtype]), 'period[D]')
+ assert find_common_type([dtype, dtype]) == 'period[D]'
 
  for dtype2 in [DatetimeTZDtype(unit='ns', tz='Asia/Tokyo'),
  PeriodDtype(freq='2D'), PeriodDtype(freq='H'),
  np.dtype('datetime64[ns]'), np.object, np.int64]:
- self.assertEqual(find_common_type([dtype, dtype2]), np.object)
- self.assertEqual(find_common_type([dtype2, dtype]), np.object)
+ assert find_common_type([dtype, dtype2]) == np.object
+ assert find_common_type([dtype2, dtype]) == np.object

pandas/tests/dtypes/test_common.py

@@ -30,30 +30,30 @@ def test_invalid_dtype_error(self):
 
  def test_numpy_dtype(self):
  for dtype in ['M8[ns]', 'm8[ns]', 'object', 'float64', 'int64']:
- self.assertEqual(pandas_dtype(dtype), np.dtype(dtype))
+ assert pandas_dtype(dtype) == np.dtype(dtype)
 
  def test_numpy_string_dtype(self):
  # do not parse freq-like string as period dtype
- self.assertEqual(pandas_dtype('U'), np.dtype('U'))
- self.assertEqual(pandas_dtype('S'), np.dtype('S'))
+ assert pandas_dtype('U') == np.dtype('U')
+ assert pandas_dtype('S') == np.dtype('S')
 
  def test_datetimetz_dtype(self):
  for dtype in ['datetime64[ns, US/Eastern]',
  'datetime64[ns, Asia/Tokyo]',
  'datetime64[ns, UTC]']:
  assert pandas_dtype(dtype) is DatetimeTZDtype(dtype)
- self.assertEqual(pandas_dtype(dtype), DatetimeTZDtype(dtype))
- self.assertEqual(pandas_dtype(dtype), dtype)
+ assert pandas_dtype(dtype) == DatetimeTZDtype(dtype)
+ assert pandas_dtype(dtype) == dtype
 
  def test_categorical_dtype(self):
- self.assertEqual(pandas_dtype('category'), CategoricalDtype())
+ assert pandas_dtype('category') == CategoricalDtype()
 
  def test_period_dtype(self):
  for dtype in ['period[D]', 'period[3M]', 'period[U]',
  'Period[D]', 'Period[3M]', 'Period[U]']:
  assert pandas_dtype(dtype) is PeriodDtype(dtype)
- self.assertEqual(pandas_dtype(dtype), PeriodDtype(dtype))
- self.assertEqual(pandas_dtype(dtype), dtype)
+ assert pandas_dtype(dtype) == PeriodDtype(dtype)
+ assert pandas_dtype(dtype) == dtype
 
 
 dtypes = dict(datetime_tz=pandas_dtype('datetime64[ns, US/Eastern]'),