MAINT: Remove assertIsNone from testing

pandas/tests/computation/test_eval.py

@@ -1336,15 +1336,15 @@ def test_multi_line_expression(self):
         c = a + b
         d = c + b""", inplace=True)
         assert_frame_equal(expected, df)
-        self.assertIsNone(ans)
+        assert ans is None
 
         expected['a'] = expected['a'] - 1
         expected['e'] = expected['a'] + 2
         ans = df.eval("""
         a = a - 1
         e = a + 2""", inplace=True)
         assert_frame_equal(expected, df)
-        self.assertIsNone(ans)
+        assert ans is None
 
         # multi-line not valid if not all assignments
         with pytest.raises(ValueError):
@@ -1384,7 +1384,7 @@ def test_multi_line_expression_local_variable(self):
         d = c + @local_var
         """, inplace=True)
         assert_frame_equal(expected, df)
-        self.assertIsNone(ans)
+        assert ans is None
 
     def test_assignment_in_query(self):
         # GH 8664

pandas/tests/frame/test_api.py

@@ -38,7 +38,7 @@ def test_copy_index_name_checking(self):
             ind.name = None
             cp = self.frame.copy()
             getattr(cp, attr).name = 'foo'
-            self.assertIsNone(getattr(self.frame, attr).name)
+            assert getattr(self.frame, attr).name is None
 
     def test_getitem_pop_assign_name(self):
         s = self.frame['A']
@@ -116,7 +116,7 @@ def test_new_empty_index(self):
         df1 = DataFrame(randn(0, 3))
         df2 = DataFrame(randn(0, 3))
         df1.index.name = 'foo'
-        self.assertIsNone(df2.index.name)
+        assert df2.index.name is None
 
     def test_array_interface(self):
         with np.errstate(all='ignore'):

pandas/tests/frame/test_constructors.py

@@ -91,7 +91,7 @@ def test_constructor_dtype_nocast_view(self):
     def test_constructor_dtype_list_data(self):
         df = DataFrame([[1, '2'],
                         [None, 'a']], dtype=object)
-        self.assertIsNone(df.loc[1, 0])
+        assert df.loc[1, 0] is None
         self.assertEqual(df.loc[0, 1], '2')
 
     def test_constructor_list_frames(self):

pandas/tests/frame/test_indexing.py

@@ -81,15 +81,15 @@ def test_get(self):
         b = self.frame.get('B')
         assert_series_equal(b, self.frame['B'])
 
-        self.assertIsNone(self.frame.get('foo'))
+        assert self.frame.get('foo') is None
         assert_series_equal(self.frame.get('foo', self.frame['B']),
                             self.frame['B'])
         # None
         # GH 5652
         for df in [DataFrame(), DataFrame(columns=list('AB')),
                    DataFrame(columns=list('AB'), index=range(3))]:
             result = df.get(None)
-            self.assertIsNone(result)
+            assert result is None
 
     def test_getitem_iterator(self):
         idx = iter(['A', 'B', 'C'])

pandas/tests/frame/test_repr_info.py

@@ -189,7 +189,7 @@ def test_latex_repr(self):
             self.assertEqual(result, df._repr_latex_())
 
         # GH 12182
-        self.assertIsNone(df._repr_latex_())
+        assert df._repr_latex_() is None
 
     @tm.capture_stdout
     def test_info(self):

pandas/tests/frame/test_timeseries.py

@@ -415,8 +415,8 @@ def test_first_last_valid(self):
 
         # GH12800
         empty = DataFrame()
-        self.assertIsNone(empty.last_valid_index())
-        self.assertIsNone(empty.first_valid_index())
+        assert empty.last_valid_index() is None
+        assert empty.first_valid_index() is None
 
     def test_at_time_frame(self):
         rng = date_range('1/1/2000', '1/5/2000', freq='5min')

pandas/tests/groupby/test_groupby.py

@@ -1972,11 +1972,11 @@ def test_apply_frame_yield_constant(self):
         # GH13568
         result = self.df.groupby(['A', 'B']).apply(len)
         self.assertTrue(isinstance(result, Series))
-        self.assertIsNone(result.name)
+        assert result.name is None
 
         result = self.df.groupby(['A', 'B'])[['C', 'D']].apply(len)
         self.assertTrue(isinstance(result, Series))
-        self.assertIsNone(result.name)
+        assert result.name is None
 
     def test_apply_frame_to_series(self):
         grouped = self.df.groupby(['A', 'B'])
@@ -2954,7 +2954,7 @@ def test_no_nonsense_name(self):
         s.name = None
 
         result = s.groupby(self.frame['A']).agg(np.sum)
-        self.assertIsNone(result.name)
+        assert result.name is None
 
     def test_multifunc_sum_bug(self):
         # GH #1065
@@ -3060,7 +3060,7 @@ def test_no_dummy_key_names(self):
         # GH #1291
 
         result = self.df.groupby(self.df['A'].values).sum()
-        self.assertIsNone(result.index.name)
+        assert result.index.name is None
 
         result = self.df.groupby([self.df['A'].values, self.df['B'].values
                                   ]).sum()

pandas/tests/indexes/common.py

@@ -195,7 +195,7 @@ def test_set_name_methods(self):
             res = ind.rename(new_name, inplace=True)
 
             # should return None
-            self.assertIsNone(res)
+            assert res is None
             self.assertEqual(ind.name, new_name)
             self.assertEqual(ind.names, [new_name])
             # with assertRaisesRegexp(TypeError, "list-like"):

pandas/tests/indexes/datetimes/test_datetime.py

@@ -480,7 +480,7 @@ def test_take(self):
             for taken in [taken1, taken2]:
                 tm.assert_index_equal(taken, expected)
                 assert isinstance(taken, DatetimeIndex)
-                self.assertIsNone(taken.freq)
+                assert taken.freq is None
                 self.assertEqual(taken.tz, expected.tz)
                 self.assertEqual(taken.name, expected.name)
 

pandas/tests/indexes/datetimes/test_ops.py

@@ -197,7 +197,7 @@ def test_repeat_range(self):
         rng = date_range('1/1/2000', '1/1/2001')
 
         result = rng.repeat(5)
-        self.assertIsNone(result.freq)
+        assert result.freq is None
         self.assertEqual(len(result), 5 * len(rng))
 
         for tz in self.tz:
@@ -206,14 +206,14 @@ def test_repeat_range(self):
                                     '2001-01-02', '2001-01-02'], tz=tz)
             for res in [index.repeat(2), np.repeat(index, 2)]:
                 tm.assert_index_equal(res, exp)
-                self.assertIsNone(res.freq)
+                assert res.freq is None
 
             index = pd.date_range('2001-01-01', periods=2, freq='2D', tz=tz)
             exp = pd.DatetimeIndex(['2001-01-01', '2001-01-01',
                                     '2001-01-03', '2001-01-03'], tz=tz)
             for res in [index.repeat(2), np.repeat(index, 2)]:
                 tm.assert_index_equal(res, exp)
-                self.assertIsNone(res.freq)
+                assert res.freq is None
 
             index = pd.DatetimeIndex(['2001-01-01', 'NaT', '2003-01-01'],
                                      tz=tz)
@@ -223,7 +223,7 @@ def test_repeat_range(self):
                                    tz=tz)
             for res in [index.repeat(3), np.repeat(index, 3)]:
                 tm.assert_index_equal(res, exp)
-                self.assertIsNone(res.freq)
+                assert res.freq is None
 
     def test_repeat(self):
         reps = 2
@@ -242,7 +242,7 @@ def test_repeat(self):
 
             res = rng.repeat(reps)
             tm.assert_index_equal(res, expected_rng)
-            self.assertIsNone(res.freq)
+            assert res.freq is None
 
             tm.assert_index_equal(np.repeat(rng, reps), expected_rng)
             tm.assertRaisesRegexp(ValueError, msg, np.repeat,
@@ -694,26 +694,26 @@ def test_order(self):
             for idx, expected in [(idx1, exp1), (idx2, exp2), (idx3, exp3)]:
                 ordered = idx.sort_values()
                 tm.assert_index_equal(ordered, expected)
-                self.assertIsNone(ordered.freq)
+                assert ordered.freq is None
 
                 ordered = idx.sort_values(ascending=False)
                 tm.assert_index_equal(ordered, expected[::-1])
-                self.assertIsNone(ordered.freq)
+                assert ordered.freq is None
 
                 ordered, indexer = idx.sort_values(return_indexer=True)
                 tm.assert_index_equal(ordered, expected)
 
                 exp = np.array([0, 4, 3, 1, 2])
                 tm.assert_numpy_array_equal(indexer, exp, check_dtype=False)
-                self.assertIsNone(ordered.freq)
+                assert ordered.freq is None
 
                 ordered, indexer = idx.sort_values(return_indexer=True,
                                                    ascending=False)
                 tm.assert_index_equal(ordered, expected[::-1])
 
                 exp = np.array([2, 1, 3, 4, 0])
                 tm.assert_numpy_array_equal(indexer, exp, check_dtype=False)
-                self.assertIsNone(ordered.freq)
+                assert ordered.freq is None
 
     def test_getitem(self):
         idx1 = pd.date_range('2011-01-01', '2011-01-31', freq='D', name='idx')
@@ -757,10 +757,10 @@ def test_drop_duplicates_metadata(self):
         self.assertEqual(idx.freq, result.freq)
 
         idx_dup = idx.append(idx)
-        self.assertIsNone(idx_dup.freq)  # freq is reset
+        assert idx_dup.freq is None  # freq is reset
         result = idx_dup.drop_duplicates()
         tm.assert_index_equal(idx, result)
-        self.assertIsNone(result.freq)
+        assert result.freq is None
 
     def test_drop_duplicates(self):
         # to check Index/Series compat
@@ -816,14 +816,14 @@ def test_take(self):
                                       '2011-01-06'],
                                      freq=None, tz=idx.tz, name='idx')
             tm.assert_index_equal(result, expected)
-            self.assertIsNone(result.freq)
+            assert result.freq is None
 
             result = idx.take([-3, 2, 5])
             expected = DatetimeIndex(['2011-01-29', '2011-01-03',
                                       '2011-01-06'],
                                      freq=None, tz=idx.tz, name='idx')
             tm.assert_index_equal(result, expected)
-            self.assertIsNone(result.freq)
+            assert result.freq is None
 
     def test_take_invalid_kwargs(self):
         idx = pd.date_range('2011-01-01', '2011-01-31', freq='D', name='idx')
@@ -1145,7 +1145,7 @@ def test_getitem(self):
         fancy_indexed = self.rng[[4, 3, 2, 1, 0]]
         self.assertEqual(len(fancy_indexed), 5)
         assert isinstance(fancy_indexed, DatetimeIndex)
-        self.assertIsNone(fancy_indexed.freq)
+        assert fancy_indexed.freq is None
 
         # 32-bit vs. 64-bit platforms
         self.assertEqual(self.rng[4], self.rng[np.int_(4)])
@@ -1240,7 +1240,7 @@ def test_getitem(self):
         fancy_indexed = self.rng[[4, 3, 2, 1, 0]]
         self.assertEqual(len(fancy_indexed), 5)
         assert isinstance(fancy_indexed, DatetimeIndex)
-        self.assertIsNone(fancy_indexed.freq)
+        assert fancy_indexed.freq is None
 
         # 32-bit vs. 64-bit platforms
         self.assertEqual(self.rng[4], self.rng[np.int_(4)])

pandas/tests/indexes/datetimes/test_setops.py

@@ -65,7 +65,7 @@ def test_union_freq_both_none(self):
 
         result = expected.union(expected)
         tm.assert_index_equal(result, expected)
-        self.assertIsNone(result.freq)
+        assert result.freq is None
 
     def test_union_dataframe_index(self):
         rng1 = date_range('1/1/1999', '1/1/2012', freq='MS')
@@ -137,7 +137,7 @@ def test_intersection(self):
                 result = base.intersection(rng)
                 tm.assert_index_equal(result, expected)
                 self.assertEqual(result.name, expected.name)
-                self.assertIsNone(result.freq)
+                assert result.freq is None
                 self.assertEqual(result.tz, expected.tz)
 
         # empty same freq GH2129
@@ -251,7 +251,7 @@ def test_outer_join(self):
 
         the_join = left.join(right, how='outer')
         assert isinstance(the_join, DatetimeIndex)
-        self.assertIsNone(the_join.freq)
+        assert the_join.freq is None
 
         # non-overlapping, no gap
         left = self.rng[:5]
@@ -265,7 +265,7 @@ def test_outer_join(self):
 
         the_join = self.rng.join(rng, how='outer')
         assert isinstance(the_join, DatetimeIndex)
-        self.assertIsNone(the_join.freq)
+        assert the_join.freq is None
 
     def test_union_not_cacheable(self):
         rng = date_range('1/1/2000', periods=50, freq=Minute())
@@ -395,7 +395,7 @@ def test_outer_join(self):
 
         the_join = left.join(right, how='outer')
         assert isinstance(the_join, DatetimeIndex)
-        self.assertIsNone(the_join.freq)
+        assert the_join.freq is None
 
         # non-overlapping, no gap
         left = self.rng[:5]
@@ -409,7 +409,7 @@ def test_outer_join(self):
 
         the_join = self.rng.join(rng, how='outer')
         assert isinstance(the_join, DatetimeIndex)
-        self.assertIsNone(the_join.freq)
+        assert the_join.freq is None
 
     def test_intersection_bug(self):
         # GH #771

pandas/tests/indexes/test_base.py

@@ -659,12 +659,12 @@ def test_intersection(self):
 
         second.name = 'B'
         intersect = first.intersection(second)
-        self.assertIsNone(intersect.name)
+        assert intersect.name is None
 
         first.name = None
         second.name = 'B'
         intersect = first.intersection(second)
-        self.assertIsNone(intersect.name)
+        assert intersect.name is None
 
     def test_union(self):
         first = self.strIndex[5:20]
@@ -844,7 +844,7 @@ def test_append_empty_preserve_name(self):
         right = Index([1, 2, 3], name='bar')
 
         result = left.append(right)
-        self.assertIsNone(result.name)
+        assert result.name is None
 
     def test_add_string(self):
         # from bug report
@@ -896,12 +896,12 @@ def test_symmetric_difference(self):
         result = idx1.symmetric_difference(idx2)
         expected = Index([1, 5])
         self.assertTrue(tm.equalContents(result, expected))
-        self.assertIsNone(result.name)
+        assert result.name is None
 
         # __xor__ syntax
         expected = idx1 ^ idx2
         self.assertTrue(tm.equalContents(result, expected))
-        self.assertIsNone(result.name)
+        assert result.name is None
 
         # multiIndex
         idx1 = MultiIndex.from_tuples(self.tuples)
@@ -1015,7 +1015,7 @@ def test_format_none(self):
 
         idx = Index(values)
         idx.format()
-        self.assertIsNone(idx[3])
+        assert idx[3] is None
 
     def test_logical_compat(self):
         idx = self.create_index()