MAINT: Remove assert_equal from testing.py (#16017)

Author: gfyoung

pandas/tests/core/computation/test_compat.py

@@ -30,7 +30,7 @@ def test_invalid_numexpr_version(engine, parser):
     def testit():
         a, b = 1, 2  # noqa
         res = pd.eval('a + b', engine=engine, parser=parser)
-        tm.assert_equal(res, 3)
+        assert res == 3
 
     if engine == 'numexpr':
         try:

pandas/tests/core/computation/test_eval.py

@@ -1020,7 +1020,7 @@ def test_complex_series_frame_alignment(self, engine, parser):
                                       parser=parser)
                 else:
                     res = pd.eval('df2 + s + df', engine=engine, parser=parser)
-                tm.assert_equal(res.shape, expected.shape)
+                assert res.shape == expected.shape
                 assert_frame_equal(res, expected)
 
     def test_performance_warning_for_poor_alignment(self, engine, parser):
@@ -1057,13 +1057,13 @@ def test_performance_warning_for_poor_alignment(self, engine, parser):
             pd.eval('df + s', engine=engine, parser=parser)
 
             if not is_python_engine:
-                tm.assert_equal(len(w), 1)
+                assert len(w) == 1
                 msg = str(w[0].message)
                 expected = ("Alignment difference on axis {0} is larger"
                             " than an order of magnitude on term {1!r}, "
                             "by more than {2:.4g}; performance may suffer"
                             "".format(1, 'df', np.log10(s.size - df.shape[1])))
-                tm.assert_equal(msg, expected)
+                assert msg == expected
 
 
 # ------------------------------------
@@ -1104,17 +1104,17 @@ def test_simple_arith_ops(self):
             else:
                 expec = _eval_single_bin(1, op, 1, self.engine)
                 x = self.eval(ex, engine=self.engine, parser=self.parser)
-                tm.assert_equal(x, expec)
+                assert x == expec
 
                 expec = _eval_single_bin(x, op, 1, self.engine)
                 y = self.eval(ex2, local_dict={'x': x}, engine=self.engine,
                               parser=self.parser)
-                tm.assert_equal(y, expec)
+                assert y == expec
 
                 expec = _eval_single_bin(1, op, x + 1, self.engine)
                 y = self.eval(ex3, local_dict={'x': x},
                               engine=self.engine, parser=self.parser)
-                tm.assert_equal(y, expec)
+                assert y == expec
 
     def test_simple_bool_ops(self):
         for op, lhs, rhs in product(expr._bool_ops_syms, (True, False),
@@ -1149,7 +1149,7 @@ def test_4d_ndarray_fails(self):
 
     def test_constant(self):
         x = self.eval('1')
-        tm.assert_equal(x, 1)
+        assert x == 1
 
     def test_single_variable(self):
         df = DataFrame(randn(10, 2))
@@ -1508,7 +1508,7 @@ def test_check_many_exprs(self):
         expr = ' * '.join('a' * 33)
         expected = 1
         res = pd.eval(expr, engine=self.engine, parser=self.parser)
-        tm.assert_equal(res, expected)
+        assert res == expected
 
     def test_fails_and(self):
         df = DataFrame(np.random.randn(5, 3))
@@ -1736,14 +1736,14 @@ def test_no_new_locals(self, engine, parser):
         pd.eval('x + 1', local_dict=lcls, engine=engine, parser=parser)
         lcls2 = locals().copy()
         lcls2.pop('lcls')
-        tm.assert_equal(lcls, lcls2)
+        assert lcls == lcls2
 
     def test_no_new_globals(self, engine, parser):
         x = 1  # noqa
         gbls = globals().copy()
         pd.eval('x + 1', engine=engine, parser=parser)
         gbls2 = globals().copy()
-        tm.assert_equal(gbls, gbls2)
+        assert gbls == gbls2
 
 
 def test_invalid_engine():
@@ -1810,7 +1810,7 @@ def test_numexpr_builtin_raises(engine, parser):
             pd.eval('sin + dotted_line', engine=engine, parser=parser)
     else:
         res = pd.eval('sin + dotted_line', engine=engine, parser=parser)
-        tm.assert_equal(res, sin + dotted_line)
+        assert res == sin + dotted_line
 
 
 def test_bad_resolver_raises(engine, parser):
@@ -1854,7 +1854,7 @@ def test_inf(engine, parser):
     s = 'inf + 1'
     expected = np.inf
     result = pd.eval(s, engine=engine, parser=parser)
-    tm.assert_equal(result, expected)
+    assert result == expected
 
 
 def test_negate_lt_eq_le(engine, parser):

pandas/tests/core/sparse/test_frame.py

@@ -1183,7 +1183,7 @@ def test_from_to_scipy(spmatrix, index, columns, fill_value, dtype):
     tm.assert_frame_equal(sdf_obj.to_dense(), expected.to_dense())
 
     # Assert spmatrices equal
-    tm.assert_equal(dict(sdf.to_coo().todok()), dict(spm.todok()))
+    assert dict(sdf.to_coo().todok()) == dict(spm.todok())
 
     # Ensure dtype is preserved if possible
     was_upcast = ((fill_value is None or is_float(fill_value)) and
@@ -1193,11 +1193,11 @@ def test_from_to_scipy(spmatrix, index, columns, fill_value, dtype):
                  float if was_upcast else
                  dtype)
     tm.assert_contains_all(sdf.dtypes, {np.dtype(res_dtype)})
-    tm.assert_equal(sdf.to_coo().dtype, res_dtype)
+    assert sdf.to_coo().dtype == res_dtype
 
     # However, adding a str column results in an upcast to object
     sdf['strings'] = np.arange(len(sdf)).astype(str)
-    tm.assert_equal(sdf.to_coo().dtype, np.object_)
+    assert sdf.to_coo().dtype == np.object_
 
 
 @pytest.mark.parametrize('fill_value', [None, 0, np.nan])  # noqa: F811
@@ -1237,12 +1237,12 @@ def test_from_to_scipy_object(spmatrix, fill_value):
     tm.assert_frame_equal(sdf_obj.to_dense(), expected.to_dense())
 
     # Assert spmatrices equal
-    tm.assert_equal(dict(sdf.to_coo().todok()), dict(spm.todok()))
+    assert dict(sdf.to_coo().todok()) == dict(spm.todok())
 
     # Ensure dtype is preserved if possible
     res_dtype = object
     tm.assert_contains_all(sdf.dtypes, {np.dtype(res_dtype)})
-    tm.assert_equal(sdf.to_coo().dtype, res_dtype)
+    assert sdf.to_coo().dtype == res_dtype
 
 
 class TestSparseDataFrameArithmetic(tm.TestCase):

pandas/tests/frame/test_constructors.py

@@ -259,8 +259,8 @@ def test_constructor_dict(self):
         # Dict with None value
         frame_none = DataFrame(dict(a=None), index=[0])
         frame_none_list = DataFrame(dict(a=[None]), index=[0])
-        tm.assert_equal(frame_none.get_value(0, 'a'), None)
-        tm.assert_equal(frame_none_list.get_value(0, 'a'), None)
+        assert frame_none.get_value(0, 'a') is None
+        assert frame_none_list.get_value(0, 'a') is None
         tm.assert_frame_equal(frame_none, frame_none_list)
 
         # GH10856

pandas/tests/frame/test_replace.py

@@ -974,7 +974,7 @@ def test_replace_period(self):
                            'out_augmented_MAY_2011.json',
                            'out_augmented_AUG_2011.json',
                            'out_augmented_JAN_2011.json'], columns=['fname'])
-        tm.assert_equal(set(df.fname.values), set(d['fname'].keys()))
+        assert set(df.fname.values) == set(d['fname'].keys())
         expected = DataFrame({'fname': [d['fname'][k]
                                         for k in df.fname.values]})
         result = df.replace(d)
@@ -997,7 +997,7 @@ def test_replace_datetime(self):
                            'out_augmented_MAY_2011.json',
                            'out_augmented_AUG_2011.json',
                            'out_augmented_JAN_2011.json'], columns=['fname'])
-        tm.assert_equal(set(df.fname.values), set(d['fname'].keys()))
+        assert set(df.fname.values) == set(d['fname'].keys())
         expected = DataFrame({'fname': [d['fname'][k]
                                         for k in df.fname.values]})
         result = df.replace(d)

pandas/tests/frame/test_subclass.py

@@ -229,9 +229,9 @@ def test_subclass_sparse_slice(self):
                                  tm.SubclassedSparseDataFrame(rows[:2]))
         tm.assert_sp_frame_equal(ssdf[:2],
                                  tm.SubclassedSparseDataFrame(rows[:2]))
-        tm.assert_equal(ssdf.loc[:2].testattr, "testattr")
-        tm.assert_equal(ssdf.iloc[:2].testattr, "testattr")
-        tm.assert_equal(ssdf[:2].testattr, "testattr")
+        assert ssdf.loc[:2].testattr == "testattr"
+        assert ssdf.iloc[:2].testattr == "testattr"
+        assert ssdf[:2].testattr == "testattr"
 
         tm.assert_sp_series_equal(ssdf.loc[1],
                                   tm.SubclassedSparseSeries(rows[1]),

pandas/tests/groupby/test_groupby.py

@@ -3275,7 +3275,7 @@ def f(group):
         # we expect 2 zeros because we call ``f`` once to see if a faster route
         # can be used.
         expected_names = [0, 0, 1, 2]
-        tm.assert_equal(names, expected_names)
+        assert names == expected_names
 
     def test_no_dummy_key_names(self):
         # GH #1291
@@ -3987,7 +3987,7 @@ def test_grouping_string_repr(self):
 
         result = gr.grouper.groupings[0].__repr__()
         expected = "Grouping(('A', 'a'))"
-        tm.assert_equal(result, expected)
+        assert result == expected
 
     def test_group_shift_with_null_key(self):
         # This test is designed to replicate the segfault in issue #13813.

pandas/tests/indexes/datetimes/test_tools.py

@@ -1295,7 +1295,7 @@ def test_parsers_time(self):
 
         res = tools.to_time(np.array(arg))
         self.assertIsInstance(res, list)
-        self.assert_equal(res, expected_arr)
+        assert res == expected_arr
 
     def test_parsers_monthfreq(self):
         cases = {'201101': datetime(2011, 1, 1, 0, 0),

pandas/tests/io/formats/test_format.py

@@ -2536,11 +2536,11 @@ def test_nat_representations(self):
 def test_format_percentiles():
     result = fmt.format_percentiles([0.01999, 0.02001, 0.5, 0.666666, 0.9999])
     expected = ['1.999%', '2.001%', '50%', '66.667%', '99.99%']
-    tm.assert_equal(result, expected)
+    assert result == expected
 
     result = fmt.format_percentiles([0, 0.5, 0.02001, 0.5, 0.666666, 0.9999])
     expected = ['0%', '50%', '2.0%', '50%', '66.67%', '99.99%']
-    tm.assert_equal(result, expected)
+    assert result == expected
 
     tm.assertRaises(ValueError, fmt.format_percentiles, [0.1, np.nan, 0.5])
     tm.assertRaises(ValueError, fmt.format_percentiles, [-0.001, 0.1, 0.5])

pandas/tests/io/formats/test_printing.py

@@ -27,9 +27,9 @@ def test_repr_binary_type():
         raw = btype(letters)
     b = compat.text_type(compat.bytes_to_str(raw))
     res = printing.pprint_thing(b, quote_strings=True)
-    tm.assert_equal(res, repr(b))
+    assert res == repr(b)
     res = printing.pprint_thing(b, quote_strings=False)
-    tm.assert_equal(res, b)
+    assert res == b
 
 
 class TestFormattBase(tm.TestCase):