diff --git a/pandas/tests/computation/test_eval.py b/pandas/tests/computation/test_eval.py
index eacbd2b390154..6ec06f75de06d 100644
--- a/pandas/tests/computation/test_eval.py
+++ b/pandas/tests/computation/test_eval.py
@@ -1336,7 +1336,7 @@ 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
@@ -1344,7 +1344,7 @@ def test_multi_line_expression(self):
         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
diff --git a/pandas/tests/frame/test_api.py b/pandas/tests/frame/test_api.py
index 879458a38770d..e060e863c0431 100644
--- a/pandas/tests/frame/test_api.py
+++ b/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'):
diff --git a/pandas/tests/frame/test_constructors.py b/pandas/tests/frame/test_constructors.py
index 3bcc058316f77..737d9f8e50477 100644
--- a/pandas/tests/frame/test_constructors.py
+++ b/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):
diff --git a/pandas/tests/frame/test_indexing.py b/pandas/tests/frame/test_indexing.py
index 12c5b33fcbce9..088f863e5358b 100644
--- a/pandas/tests/frame/test_indexing.py
+++ b/pandas/tests/frame/test_indexing.py
@@ -81,7 +81,7 @@ 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
@@ -89,7 +89,7 @@ def test_get(self):
         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'])
diff --git a/pandas/tests/frame/test_repr_info.py b/pandas/tests/frame/test_repr_info.py
index efbdc05ba23c8..630fa5ad57fad 100644
--- a/pandas/tests/frame/test_repr_info.py
+++ b/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):
diff --git a/pandas/tests/frame/test_timeseries.py b/pandas/tests/frame/test_timeseries.py
index cf42f751f390a..090f742a69b63 100644
--- a/pandas/tests/frame/test_timeseries.py
+++ b/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')
diff --git a/pandas/tests/groupby/test_groupby.py b/pandas/tests/groupby/test_groupby.py
index 05fe1c6f58e9a..02ef9e614150c 100644
--- a/pandas/tests/groupby/test_groupby.py
+++ b/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()
diff --git a/pandas/tests/indexes/common.py b/pandas/tests/indexes/common.py
index ff90c924933f3..fa1f31ded5f1c 100644
--- a/pandas/tests/indexes/common.py
+++ b/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"):
diff --git a/pandas/tests/indexes/datetimes/test_datetime.py b/pandas/tests/indexes/datetimes/test_datetime.py
index 93fc855178800..31e795a80f2e6 100644
--- a/pandas/tests/indexes/datetimes/test_datetime.py
+++ b/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)
 
diff --git a/pandas/tests/indexes/datetimes/test_ops.py b/pandas/tests/indexes/datetimes/test_ops.py
index 235c8f1de1fae..de41f321b245b 100644
--- a/pandas/tests/indexes/datetimes/test_ops.py
+++ b/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,18 +694,18 @@ 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)
@@ -713,7 +713,7 @@ def test_order(self):
 
                 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)])
diff --git a/pandas/tests/indexes/datetimes/test_setops.py b/pandas/tests/indexes/datetimes/test_setops.py
index 3191b0e2c586d..3e6ed7756b9bd 100644
--- a/pandas/tests/indexes/datetimes/test_setops.py
+++ b/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
diff --git a/pandas/tests/indexes/test_base.py b/pandas/tests/indexes/test_base.py
index 7db7410d79349..91d5068ee9f19 100644
--- a/pandas/tests/indexes/test_base.py
+++ b/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()
diff --git a/pandas/tests/indexes/test_multi.py b/pandas/tests/indexes/test_multi.py
index 98fce437d26c8..7a9b3c1c4b5d6 100644
--- a/pandas/tests/indexes/test_multi.py
+++ b/pandas/tests/indexes/test_multi.py
@@ -138,7 +138,7 @@ def test_set_name_methods(self):
             ind.set_names(new_names + new_names)
         new_names2 = [name + "SUFFIX2" for name in new_names]
         res = ind.set_names(new_names2, inplace=True)
-        self.assertIsNone(res)
+        assert res is None
         self.assertEqual(ind.names, new_names2)
 
         # set names for specific level (# GH7792)
@@ -147,7 +147,7 @@ def test_set_name_methods(self):
         self.assertEqual(ind.names, [new_names[0], self.index_names[1]])
 
         res = ind.set_names(new_names2[0], level=0, inplace=True)
-        self.assertIsNone(res)
+        assert res is None
         self.assertEqual(ind.names, [new_names2[0], self.index_names[1]])
 
         # set names for multiple levels
@@ -156,7 +156,7 @@ def test_set_name_methods(self):
         self.assertEqual(ind.names, new_names)
 
         res = ind.set_names(new_names2, level=[0, 1], inplace=True)
-        self.assertIsNone(res)
+        assert res is None
         self.assertEqual(ind.names, new_names2)
 
     def test_set_levels(self):
@@ -182,7 +182,7 @@ def assert_matching(actual, expected, check_dtype=False):
         # level changing [w/ mutation]
         ind2 = self.index.copy()
         inplace_return = ind2.set_levels(new_levels, inplace=True)
-        self.assertIsNone(inplace_return)
+        assert inplace_return is None
         assert_matching(ind2.levels, new_levels)
 
         # level changing specific level [w/o mutation]
@@ -202,13 +202,13 @@ def assert_matching(actual, expected, check_dtype=False):
         # level changing specific level [w/ mutation]
         ind2 = self.index.copy()
         inplace_return = ind2.set_levels(new_levels[0], level=0, inplace=True)
-        self.assertIsNone(inplace_return)
+        assert inplace_return is None
         assert_matching(ind2.levels, [new_levels[0], levels[1]])
         assert_matching(self.index.levels, levels)
 
         ind2 = self.index.copy()
         inplace_return = ind2.set_levels(new_levels[1], level=1, inplace=True)
-        self.assertIsNone(inplace_return)
+        assert inplace_return is None
         assert_matching(ind2.levels, [levels[0], new_levels[1]])
         assert_matching(self.index.levels, levels)
 
@@ -216,7 +216,7 @@ def assert_matching(actual, expected, check_dtype=False):
         ind2 = self.index.copy()
         inplace_return = ind2.set_levels(new_levels, level=[0, 1],
                                          inplace=True)
-        self.assertIsNone(inplace_return)
+        assert inplace_return is None
         assert_matching(ind2.levels, new_levels)
         assert_matching(self.index.levels, levels)
 
@@ -271,7 +271,7 @@ def assert_matching(actual, expected):
         # label changing [w/ mutation]
         ind2 = self.index.copy()
         inplace_return = ind2.set_labels(new_labels, inplace=True)
-        self.assertIsNone(inplace_return)
+        assert inplace_return is None
         assert_matching(ind2.labels, new_labels)
 
         # label changing specific level [w/o mutation]
@@ -291,13 +291,13 @@ def assert_matching(actual, expected):
         # label changing specific level [w/ mutation]
         ind2 = self.index.copy()
         inplace_return = ind2.set_labels(new_labels[0], level=0, inplace=True)
-        self.assertIsNone(inplace_return)
+        assert inplace_return is None
         assert_matching(ind2.labels, [new_labels[0], labels[1]])
         assert_matching(self.index.labels, labels)
 
         ind2 = self.index.copy()
         inplace_return = ind2.set_labels(new_labels[1], level=1, inplace=True)
-        self.assertIsNone(inplace_return)
+        assert inplace_return is None
         assert_matching(ind2.labels, [labels[0], new_labels[1]])
         assert_matching(self.index.labels, labels)
 
@@ -305,7 +305,7 @@ def assert_matching(actual, expected):
         ind2 = self.index.copy()
         inplace_return = ind2.set_labels(new_labels, level=[0, 1],
                                          inplace=True)
-        self.assertIsNone(inplace_return)
+        assert inplace_return is None
         assert_matching(ind2.labels, new_labels)
         assert_matching(self.index.labels, labels)
 
@@ -457,10 +457,10 @@ def test_set_value_keeps_names(self):
             columns=['one', 'two', 'three', 'four'],
             index=idx)
         df = df.sort_index()
-        self.assertIsNone(df.is_copy)
+        assert df.is_copy is None
         self.assertEqual(df.index.names, ('Name', 'Number'))
         df = df.set_value(('grethe', '4'), 'one', 99.34)
-        self.assertIsNone(df.is_copy)
+        assert df.is_copy is None
         self.assertEqual(df.index.names, ('Name', 'Number'))
 
     def test_copy_names(self):
@@ -1158,7 +1158,7 @@ def test_get_loc_level(self):
         loc, new_index = index.get_loc_level((0, 1, 0))
         expected = 1
         self.assertEqual(loc, expected)
-        self.assertIsNone(new_index)
+        assert new_index is None
 
         pytest.raises(KeyError, index.get_loc_level, (2, 2))
 
@@ -2067,12 +2067,12 @@ def test_join_multi(self):
         exp_ridx = np.array([-1, 0, 1, -1, -1, 0, 1, -1, -1, 0, 1, -1, -1, 0,
                              1, -1], dtype=np.intp)
         tm.assert_index_equal(jidx, midx)
-        self.assertIsNone(lidx)
+        assert lidx is None
         tm.assert_numpy_array_equal(ridx, exp_ridx)
         # flip
         jidx, ridx, lidx = idx.join(midx, how='right', return_indexers=True)
         tm.assert_index_equal(jidx, midx)
-        self.assertIsNone(lidx)
+        assert lidx is None
         tm.assert_numpy_array_equal(ridx, exp_ridx)
 
     def test_reindex(self):
@@ -2082,7 +2082,7 @@ def test_reindex(self):
 
         result, indexer = self.index.reindex(list(self.index))
         assert isinstance(result, MultiIndex)
-        self.assertIsNone(indexer)
+        assert indexer is None
         self.check_level_names(result, self.index.names)
 
     def test_reindex_level(self):
diff --git a/pandas/tests/indexes/test_numeric.py b/pandas/tests/indexes/test_numeric.py
index 62aabaaef100c..56e0d858f1f0f 100644
--- a/pandas/tests/indexes/test_numeric.py
+++ b/pandas/tests/indexes/test_numeric.py
@@ -791,7 +791,7 @@ def test_join_left(self):
 
         assert isinstance(res, Int64Index)
         tm.assert_index_equal(res, eres)
-        self.assertIsNone(lidx)
+        assert lidx is None
         tm.assert_numpy_array_equal(ridx, eridx)
 
         # monotonic
@@ -801,7 +801,7 @@ def test_join_left(self):
                          dtype=np.intp)
         assert isinstance(res, Int64Index)
         tm.assert_index_equal(res, eres)
-        self.assertIsNone(lidx)
+        assert lidx is None
         tm.assert_numpy_array_equal(ridx, eridx)
 
         # non-unique
@@ -828,7 +828,7 @@ def test_join_right(self):
         assert isinstance(other, Int64Index)
         tm.assert_index_equal(res, eres)
         tm.assert_numpy_array_equal(lidx, elidx)
-        self.assertIsNone(ridx)
+        assert ridx is None
 
         # monotonic
         res, lidx, ridx = self.index.join(other_mono, how='right',
@@ -838,7 +838,7 @@ def test_join_right(self):
         assert isinstance(other, Int64Index)
         tm.assert_index_equal(res, eres)
         tm.assert_numpy_array_equal(lidx, elidx)
-        self.assertIsNone(ridx)
+        assert ridx is None
 
         # non-unique
         idx = Index([1, 1, 2, 5])
@@ -1031,7 +1031,7 @@ def test_join_left(self):
 
         assert isinstance(res, UInt64Index)
         tm.assert_index_equal(res, eres)
-        self.assertIsNone(lidx)
+        assert lidx is None
         tm.assert_numpy_array_equal(ridx, eridx)
 
         # monotonic
@@ -1041,7 +1041,7 @@ def test_join_left(self):
 
         assert isinstance(res, UInt64Index)
         tm.assert_index_equal(res, eres)
-        self.assertIsNone(lidx)
+        assert lidx is None
         tm.assert_numpy_array_equal(ridx, eridx)
 
         # non-unique
@@ -1074,7 +1074,7 @@ def test_join_right(self):
         tm.assert_numpy_array_equal(lidx, elidx)
         assert isinstance(other, UInt64Index)
         tm.assert_index_equal(res, eres)
-        self.assertIsNone(ridx)
+        assert ridx is None
 
         # monotonic
         res, lidx, ridx = self.index.join(other_mono, how='right',
@@ -1085,7 +1085,7 @@ def test_join_right(self):
         assert isinstance(other, UInt64Index)
         tm.assert_numpy_array_equal(lidx, elidx)
         tm.assert_index_equal(res, eres)
-        self.assertIsNone(ridx)
+        assert ridx is None
 
         # non-unique
         idx = UInt64Index(2**63 + np.array([1, 1, 2, 5], dtype='uint64'))
diff --git a/pandas/tests/indexes/test_range.py b/pandas/tests/indexes/test_range.py
index 0b27eb0c34111..4b622ad3fce49 100644
--- a/pandas/tests/indexes/test_range.py
+++ b/pandas/tests/indexes/test_range.py
@@ -487,7 +487,7 @@ def test_join_left(self):
 
         assert isinstance(res, RangeIndex)
         tm.assert_index_equal(res, eres)
-        self.assertIsNone(lidx)
+        assert lidx is None
         tm.assert_numpy_array_equal(ridx, eridx)
 
         # Join withRangeIndex
@@ -498,7 +498,7 @@ def test_join_left(self):
 
         assert isinstance(res, RangeIndex)
         tm.assert_index_equal(res, eres)
-        self.assertIsNone(lidx)
+        assert lidx is None
         tm.assert_numpy_array_equal(ridx, eridx)
 
     def test_join_right(self):
@@ -514,7 +514,7 @@ def test_join_right(self):
         assert isinstance(other, Int64Index)
         tm.assert_index_equal(res, eres)
         tm.assert_numpy_array_equal(lidx, elidx)
-        self.assertIsNone(ridx)
+        assert ridx is None
 
         # Join withRangeIndex
         other = RangeIndex(25, 14, -1)
@@ -526,7 +526,7 @@ def test_join_right(self):
         assert isinstance(other, RangeIndex)
         tm.assert_index_equal(res, eres)
         tm.assert_numpy_array_equal(lidx, elidx)
-        self.assertIsNone(ridx)
+        assert ridx is None
 
     def test_join_non_int_index(self):
         other = Index([3, 6, 7, 8, 10], dtype=object)
diff --git a/pandas/tests/indexes/timedeltas/test_ops.py b/pandas/tests/indexes/timedeltas/test_ops.py
index adf164977205f..a847467518b92 100644
--- a/pandas/tests/indexes/timedeltas/test_ops.py
+++ b/pandas/tests/indexes/timedeltas/test_ops.py
@@ -620,18 +620,18 @@ def test_order(self):
         for idx, expected in [(idx1, exp1), (idx1, exp1), (idx1, exp1)]:
             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)
@@ -639,7 +639,7 @@ def test_order(self):
 
             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.timedelta_range('1 day', '31 day', freq='D', name='idx')
@@ -681,10 +681,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
@@ -739,12 +739,12 @@ def test_take(self):
             result = idx.take([3, 2, 5])
             expected = TimedeltaIndex(['4 day', '3 day', '6 day'], name='idx')
             tm.assert_index_equal(result, expected)
-            self.assertIsNone(result.freq)
+            assert result.freq is None
 
             result = idx.take([-3, 2, 5])
             expected = TimedeltaIndex(['29 day', '3 day', '6 day'], 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.timedelta_range('1 day', '31 day', freq='D', name='idx')
@@ -808,7 +808,7 @@ def test_repeat(self):
         exp = pd.TimedeltaIndex(['1 days', '1 days', '2 days', '2 days'])
         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 = TimedeltaIndex(['1 days', 'NaT', '3 days'])
         exp = TimedeltaIndex(['1 days', '1 days', '1 days',
@@ -816,7 +816,7 @@ def test_repeat(self):
                               '3 days', '3 days', '3 days'])
         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_nat(self):
         self.assertIs(pd.TimedeltaIndex._na_value, pd.NaT)
diff --git a/pandas/tests/indexes/timedeltas/test_timedelta.py b/pandas/tests/indexes/timedeltas/test_timedelta.py
index 9ca207876520f..b93f76c14dcfe 100644
--- a/pandas/tests/indexes/timedeltas/test_timedelta.py
+++ b/pandas/tests/indexes/timedeltas/test_timedelta.py
@@ -208,7 +208,7 @@ def test_take(self):
         for taken in [taken1, taken2]:
             tm.assert_index_equal(taken, expected)
             assert isinstance(taken, TimedeltaIndex)
-            self.assertIsNone(taken.freq)
+            assert taken.freq is None
             self.assertEqual(taken.name, expected.name)
 
     def test_take_fill_value(self):
diff --git a/pandas/tests/io/formats/test_format.py b/pandas/tests/io/formats/test_format.py
index ba59add4305d8..35a71efbbf5ba 100644
--- a/pandas/tests/io/formats/test_format.py
+++ b/pandas/tests/io/formats/test_format.py
@@ -1126,7 +1126,7 @@ def test_to_string(self):
 
         buf = StringIO()
         retval = biggie.to_string(buf=buf)
-        self.assertIsNone(retval)
+        assert retval is None
         self.assertEqual(buf.getvalue(), s)
 
         assert isinstance(s, compat.string_types)
@@ -1631,7 +1631,7 @@ def test_to_string(self):
         s = self.ts.to_string()
 
         retval = self.ts.to_string(buf=buf)
-        self.assertIsNone(retval)
+        assert retval is None
         self.assertEqual(buf.getvalue().strip(), s)
 
         # pass float_format
diff --git a/pandas/tests/io/formats/test_printing.py b/pandas/tests/io/formats/test_printing.py
index 882c9b9bd42f6..f9d911f523699 100644
--- a/pandas/tests/io/formats/test_printing.py
+++ b/pandas/tests/io/formats/test_printing.py
@@ -151,7 +151,7 @@ def test_publishes(self):
             with opt, make_patch as mock_display:
                 handle = obj._ipython_display_()
                 self.assertEqual(mock_display.call_count, 1)
-                self.assertIsNone(handle)
+                assert handle is None
                 args, kwargs = mock_display.call_args
                 arg, = args  # just one argument
 
diff --git a/pandas/tests/io/formats/test_to_html.py b/pandas/tests/io/formats/test_to_html.py
index 90c6db1dcc7fb..28c6a0e95e0f1 100644
--- a/pandas/tests/io/formats/test_to_html.py
+++ b/pandas/tests/io/formats/test_to_html.py
@@ -1423,7 +1423,7 @@ def test_to_html(self):
 
         buf = StringIO()
         retval = biggie.to_html(buf=buf)
-        self.assertIsNone(retval)
+        assert retval is None
         self.assertEqual(buf.getvalue(), s)
 
         assert isinstance(s, compat.string_types)
diff --git a/pandas/tests/io/parser/common.py b/pandas/tests/io/parser/common.py
index a0c50bb3a573d..deeeaef63da39 100644
--- a/pandas/tests/io/parser/common.py
+++ b/pandas/tests/io/parser/common.py
@@ -641,7 +641,7 @@ def test_no_unnamed_index(self):
 2 2 2 e f
 """
         df = self.read_table(StringIO(data), sep=' ')
-        self.assertIsNone(df.index.name)
+        assert df.index.name is None
 
     def test_read_csv_parse_simple_list(self):
         text = """foo
@@ -1243,7 +1243,7 @@ def test_regex_separator(self):
         df = self.read_table(StringIO(data), sep=r'\s+')
         expected = self.read_csv(StringIO(re.sub('[ ]+', ',', data)),
                                  index_col=0)
-        self.assertIsNone(expected.index.name)
+        assert expected.index.name is None
         tm.assert_frame_equal(df, expected)
 
         data = '    a b c\n1 2 3 \n4 5  6\n 7 8 9'
diff --git a/pandas/tests/io/test_pytables.py b/pandas/tests/io/test_pytables.py
index d077dd879d44a..ea9911d8ee66c 100644
--- a/pandas/tests/io/test_pytables.py
+++ b/pandas/tests/io/test_pytables.py
@@ -878,12 +878,12 @@ def test_append_series(self):
             store.append('ss', ss)
             result = store['ss']
             tm.assert_series_equal(result, ss)
-            self.assertIsNone(result.name)
+            assert result.name is None
 
             store.append('ts', ts)
             result = store['ts']
             tm.assert_series_equal(result, ts)
-            self.assertIsNone(result.name)
+            assert result.name is None
 
             ns.name = 'foo'
             store.append('ns', ns)
@@ -3573,7 +3573,7 @@ def test_retain_index_attributes(self):
                                               periods=3, freq='D'))))
                 store.append('data', df2)
 
-            self.assertIsNone(store.get_storer('data').info['index']['freq'])
+            assert store.get_storer('data').info['index']['freq'] is None
 
             # this is ok
             _maybe_remove(store, 'df2')
@@ -3618,7 +3618,7 @@ def test_retain_index_attributes2(self):
                 df2 = DataFrame(dict(A=Series(lrange(3), index=idx2)))
                 df2.to_hdf(path, 'data', append=True)
 
-            self.assertIsNone(read_hdf(path, 'data').index.name)
+            assert read_hdf(path, 'data').index.name is None
 
     def test_panel_select(self):
 
diff --git a/pandas/tests/plotting/test_boxplot_method.py b/pandas/tests/plotting/test_boxplot_method.py
index 64d0fec2b5646..ce341a1e02e0d 100644
--- a/pandas/tests/plotting/test_boxplot_method.py
+++ b/pandas/tests/plotting/test_boxplot_method.py
@@ -150,7 +150,7 @@ def _check_ax_limits(col, ax):
         _check_ax_limits(df['age'], age_ax)
         self.assertEqual(weight_ax._sharey, height_ax)
         self.assertEqual(age_ax._sharey, height_ax)
-        self.assertIsNone(dummy_ax._sharey)
+        assert dummy_ax._sharey is None
 
     @slow
     def test_boxplot_empty_column(self):
diff --git a/pandas/tests/plotting/test_datetimelike.py b/pandas/tests/plotting/test_datetimelike.py
index 364a561669ed2..f0a56592158d3 100644
--- a/pandas/tests/plotting/test_datetimelike.py
+++ b/pandas/tests/plotting/test_datetimelike.py
@@ -145,7 +145,7 @@ def test_high_freq(self):
 
     def test_get_datevalue(self):
         from pandas.plotting._converter import get_datevalue
-        self.assertIsNone(get_datevalue(None, 'D'))
+        assert get_datevalue(None, 'D') is None
         self.assertEqual(get_datevalue(1987, 'A'), 1987)
         self.assertEqual(get_datevalue(Period(1987, 'A'), 'M'),
                          Period('1987-12', 'M').ordinal)
@@ -1069,7 +1069,7 @@ def test_secondary_legend(self):
         self.assertEqual(leg.get_texts()[1].get_text(), 'B (right)')
         self.assertEqual(leg.get_texts()[2].get_text(), 'C')
         self.assertEqual(leg.get_texts()[3].get_text(), 'D')
-        self.assertIsNone(ax.right_ax.get_legend())
+        assert ax.right_ax.get_legend() is None
         colors = set()
         for line in leg.get_lines():
             colors.add(line.get_color())
@@ -1105,7 +1105,7 @@ def test_secondary_legend(self):
         ax = df.plot(secondary_y=['C', 'D'])
         leg = ax.get_legend()
         self.assertEqual(len(leg.get_lines()), 4)
-        self.assertIsNone(ax.right_ax.get_legend())
+        assert ax.right_ax.get_legend() is None
         colors = set()
         for line in leg.get_lines():
             colors.add(line.get_color())
@@ -1120,7 +1120,7 @@ def test_secondary_legend(self):
         ax = df.plot(secondary_y=['A', 'B'])
         leg = ax.get_legend()
         self.assertEqual(len(leg.get_lines()), 4)
-        self.assertIsNone(ax.right_ax.get_legend())
+        assert ax.right_ax.get_legend() is None
         colors = set()
         for line in leg.get_lines():
             colors.add(line.get_color())
@@ -1133,7 +1133,7 @@ def test_secondary_legend(self):
         ax = df.plot(secondary_y=['C', 'D'])
         leg = ax.get_legend()
         self.assertEqual(len(leg.get_lines()), 4)
-        self.assertIsNone(ax.right_ax.get_legend())
+        assert ax.right_ax.get_legend() is None
         colors = set()
         for line in leg.get_lines():
             colors.add(line.get_color())
diff --git a/pandas/tests/scalar/test_timestamp.py b/pandas/tests/scalar/test_timestamp.py
index c1d5a069c248b..2cf40335f3ded 100644
--- a/pandas/tests/scalar/test_timestamp.py
+++ b/pandas/tests/scalar/test_timestamp.py
@@ -1467,7 +1467,7 @@ def test_dti_slicing(self):
         self.assertEqual(v3, Timestamp('6/30/2005'))
 
         # don't carry freq through irregular slicing
-        self.assertIsNone(dti2.freq)
+        assert dti2.freq is None
 
     def test_woy_boundary(self):
         # make sure weeks at year boundaries are correct
diff --git a/pandas/tests/series/test_api.py b/pandas/tests/series/test_api.py
index 68d8e382ef046..a477bb325061f 100644
--- a/pandas/tests/series/test_api.py
+++ b/pandas/tests/series/test_api.py
@@ -34,13 +34,13 @@ def test_copy_index_name_checking(self):
         # making a copy
 
         self.ts.index.name = None
-        self.assertIsNone(self.ts.index.name)
+        assert self.ts.index.name is None
         self.assertIs(self.ts, self.ts)
 
         cp = self.ts.copy()
         cp.index.name = 'foo'
         printing.pprint_thing(self.ts.index.name)
-        self.assertIsNone(self.ts.index.name)
+        assert self.ts.index.name is None
 
     def test_append_preserve_name(self):
         result = self.ts[:5].append(self.ts[5:])
@@ -60,9 +60,9 @@ def test_binop_maybe_preserve_name(self):
         cp = self.ts.copy()
         cp.name = 'something else'
         result = self.ts + cp
-        self.assertIsNone(result.name)
+        assert result.name is None
         result = self.ts.add(cp)
-        self.assertIsNone(result.name)
+        assert result.name is None
 
         ops = ['add', 'sub', 'mul', 'div', 'truediv', 'floordiv', 'mod', 'pow']
         ops = ops + ['r' + op for op in ops]
@@ -76,7 +76,7 @@ def test_binop_maybe_preserve_name(self):
             cp = self.ts.copy()
             cp.name = 'changed'
             result = getattr(s, op)(cp)
-            self.assertIsNone(result.name)
+            assert result.name is None
 
     def test_combine_first_name(self):
         result = self.ts.combine_first(self.ts[:5])
@@ -170,7 +170,7 @@ def test_iter_box(self):
         for res, exp in zip(s, vals):
             assert isinstance(res, pd.Timestamp)
             self.assertEqual(res, exp)
-            self.assertIsNone(res.tz)
+            assert res.tz is None
 
         vals = [pd.Timestamp('2011-01-01', tz='US/Eastern'),
                 pd.Timestamp('2011-01-02', tz='US/Eastern')]
diff --git a/pandas/tests/series/test_combine_concat.py b/pandas/tests/series/test_combine_concat.py
index cc29c45d74c9d..51a2a5ed6c574 100644
--- a/pandas/tests/series/test_combine_concat.py
+++ b/pandas/tests/series/test_combine_concat.py
@@ -246,7 +246,7 @@ def test_append_concat(self):
         rng1.name = 'foo'
         rng2.name = 'bar'
         self.assertEqual(rng1.append(rng1).name, 'foo')
-        self.assertIsNone(rng1.append(rng2).name)
+        assert rng1.append(rng2).name is None
 
     def test_append_concat_tz(self):
         # GH 2938
diff --git a/pandas/tests/series/test_indexing.py b/pandas/tests/series/test_indexing.py
index 22869fca35931..9872a1982a770 100644
--- a/pandas/tests/series/test_indexing.py
+++ b/pandas/tests/series/test_indexing.py
@@ -164,7 +164,7 @@ def test_getitem_get(self):
         # GH 5652
         for s in [Series(), Series(index=list('abc'))]:
             result = s.get(None)
-            self.assertIsNone(result)
+            assert result is None
 
     def test_iloc(self):
 
diff --git a/pandas/tests/series/test_io.py b/pandas/tests/series/test_io.py
index d45a6ba347c3e..3df32992a4d74 100644
--- a/pandas/tests/series/test_io.py
+++ b/pandas/tests/series/test_io.py
@@ -34,8 +34,8 @@ def test_from_csv(self):
 
             self.series.to_csv(path)
             series = Series.from_csv(path)
-            self.assertIsNone(series.name)
-            self.assertIsNone(series.index.name)
+            assert series.name is None
+            assert series.index.name is None
             assert_series_equal(self.series, series, check_names=False)
             self.assertTrue(series.name is None)
             self.assertTrue(series.index.name is None)
diff --git a/pandas/tests/series/test_timeseries.py b/pandas/tests/series/test_timeseries.py
index 486f129b6814c..430be97845fcb 100644
--- a/pandas/tests/series/test_timeseries.py
+++ b/pandas/tests/series/test_timeseries.py
@@ -373,17 +373,17 @@ def test_first_last_valid(self):
         self.assertEqual(index, ts.index[-6])
 
         ts[:] = np.nan
-        self.assertIsNone(ts.last_valid_index())
-        self.assertIsNone(ts.first_valid_index())
+        assert ts.last_valid_index() is None
+        assert ts.first_valid_index() is None
 
         ser = Series([], index=[])
-        self.assertIsNone(ser.last_valid_index())
-        self.assertIsNone(ser.first_valid_index())
+        assert ser.last_valid_index() is None
+        assert ser.first_valid_index() is None
 
         # GH12800
         empty = Series()
-        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_mpl_compat_hack(self):
         result = self.ts[:, np.newaxis]
@@ -860,7 +860,7 @@ def test_setops_preserve_freq(self):
 
             result = rng[:50].union(rng[60:100])
             self.assertEqual(result.name, rng.name)
-            self.assertIsNone(result.freq)
+            assert result.freq is None
             self.assertEqual(result.tz, rng.tz)
 
             result = rng[:50].intersection(rng[25:75])
@@ -870,12 +870,12 @@ def test_setops_preserve_freq(self):
 
             nofreq = DatetimeIndex(list(rng[25:75]), name='other')
             result = rng[:50].union(nofreq)
-            self.assertIsNone(result.name)
+            assert result.name is None
             self.assertEqual(result.freq, rng.freq)
             self.assertEqual(result.tz, rng.tz)
 
             result = rng[:50].intersection(nofreq)
-            self.assertIsNone(result.name)
+            assert result.name is None
             self.assertEqual(result.freq, rng.freq)
             self.assertEqual(result.tz, rng.tz)
 
diff --git a/pandas/tests/sparse/test_indexing.py b/pandas/tests/sparse/test_indexing.py
index d0e5196570adc..cf91e41624276 100644
--- a/pandas/tests/sparse/test_indexing.py
+++ b/pandas/tests/sparse/test_indexing.py
@@ -303,20 +303,20 @@ def test_get(self):
         s = pd.SparseSeries([1, np.nan, np.nan, 3, np.nan])
         self.assertEqual(s.get(0), 1)
         self.assertTrue(np.isnan(s.get(1)))
-        self.assertIsNone(s.get(5))
+        assert s.get(5) is None
 
         s = pd.SparseSeries([1, np.nan, 0, 3, 0], index=list('ABCDE'))
         self.assertEqual(s.get('A'), 1)
         self.assertTrue(np.isnan(s.get('B')))
         self.assertEqual(s.get('C'), 0)
-        self.assertIsNone(s.get('XX'))
+        assert s.get('XX') is None
 
         s = pd.SparseSeries([1, np.nan, 0, 3, 0], index=list('ABCDE'),
                             fill_value=0)
         self.assertEqual(s.get('A'), 1)
         self.assertTrue(np.isnan(s.get('B')))
         self.assertEqual(s.get('C'), 0)
-        self.assertIsNone(s.get('XX'))
+        assert s.get('XX') is None
 
     def test_take(self):
         orig = pd.Series([1, np.nan, np.nan, 3, np.nan],
diff --git a/pandas/tests/sparse/test_series.py b/pandas/tests/sparse/test_series.py
index dcac0f599fdeb..2fd7ac3d13b98 100644
--- a/pandas/tests/sparse/test_series.py
+++ b/pandas/tests/sparse/test_series.py
@@ -435,7 +435,7 @@ def _check_getitem(sp, dense):
 
     def test_get_get_value(self):
         tm.assert_almost_equal(self.bseries.get(10), self.bseries[10])
-        self.assertIsNone(self.bseries.get(len(self.bseries) + 1))
+        assert self.bseries.get(len(self.bseries) + 1) is None
 
         dt = self.btseries.index[10]
         result = self.btseries.get(dt)
diff --git a/pandas/tests/test_categorical.py b/pandas/tests/test_categorical.py
index b26c015133697..2b9afb8e1dd6b 100644
--- a/pandas/tests/test_categorical.py
+++ b/pandas/tests/test_categorical.py
@@ -931,7 +931,7 @@ def test_rename_categories(self):
         res = cat.rename_categories([1, 2, 3], inplace=True)
 
         # and now inplace
-        self.assertIsNone(res)
+        assert res is None
         tm.assert_numpy_array_equal(cat.__array__(), np.array([1, 2, 3, 1],
                                                               dtype=np.int64))
         tm.assert_index_equal(cat.categories, Index([1, 2, 3]))
@@ -959,7 +959,7 @@ def test_reorder_categories(self):
 
         # inplace == True
         res = cat.reorder_categories(["c", "b", "a"], inplace=True)
-        self.assertIsNone(res)
+        assert res is None
         tm.assert_categorical_equal(cat, new)
 
         # not all "old" included in "new"
@@ -1000,7 +1000,7 @@ def test_add_categories(self):
         # inplace == True
         res = cat.add_categories("d", inplace=True)
         tm.assert_categorical_equal(cat, new)
-        self.assertIsNone(res)
+        assert res is None
 
         # new is in old categories
         def f():
@@ -1040,7 +1040,7 @@ def test_remove_categories(self):
         # inplace == True
         res = cat.remove_categories("c", inplace=True)
         tm.assert_categorical_equal(cat, new)
-        self.assertIsNone(res)
+        assert res is None
 
         # removal is not in categories
         def f():
@@ -1062,7 +1062,7 @@ def test_remove_unused_categories(self):
 
         res = c.remove_unused_categories(inplace=True)
         tm.assert_index_equal(c.categories, exp_categories_dropped)
-        self.assertIsNone(res)
+        assert res is None
 
         # with NaN values (GH11599)
         c = Categorical(["a", "b", "c", np.nan],
diff --git a/pandas/tests/test_panel.py b/pandas/tests/test_panel.py
index af56f0c33df2e..24248d735adb0 100644
--- a/pandas/tests/test_panel.py
+++ b/pandas/tests/test_panel.py
@@ -74,7 +74,7 @@ def test_copy_names(self):
                 getattr(self.panel, attr).name = None
                 cp = self.panel.copy()
                 getattr(cp, attr).name = 'foo'
-                self.assertIsNone(getattr(self.panel, attr).name)
+                assert getattr(self.panel, attr).name is None
 
     def test_iter(self):
         tm.equalContents(list(self.panel), self.panel.items)
diff --git a/pandas/tests/tseries/test_frequencies.py b/pandas/tests/tseries/test_frequencies.py
index e3ab01499e676..c9de997cdf067 100644
--- a/pandas/tests/tseries/test_frequencies.py
+++ b/pandas/tests/tseries/test_frequencies.py
@@ -545,12 +545,12 @@ def _check_tick(self, base_delta, code):
 
         index = _dti([b + base_delta * 7] + [b + base_delta * j for j in range(
             3)])
-        self.assertIsNone(frequencies.infer_freq(index))
+        assert frequencies.infer_freq(index) is None
 
         index = _dti([b + base_delta * j for j in range(3)] + [b + base_delta *
                                                                7])
 
-        self.assertIsNone(frequencies.infer_freq(index))
+        assert frequencies.infer_freq(index) is None
 
     def test_weekly(self):
         days = ['MON', 'TUE', 'WED', 'THU', 'FRI', 'SAT', 'SUN']
@@ -690,7 +690,7 @@ def test_infer_freq_tz_transition(self):
 
         index = date_range("2013-11-03", periods=5,
                            freq="3H").tz_localize("America/Chicago")
-        self.assertIsNone(index.inferred_freq)
+        assert index.inferred_freq is None
 
     def test_infer_freq_businesshour(self):
         # GH 7905
diff --git a/pandas/tests/tseries/test_offsets.py b/pandas/tests/tseries/test_offsets.py
index 335a7f3513da9..ff38d5ec46a44 100644
--- a/pandas/tests/tseries/test_offsets.py
+++ b/pandas/tests/tseries/test_offsets.py
@@ -147,7 +147,7 @@ def test_apply_out_of_range(self):
 
             result = Timestamp('20080101') + offset
             assert isinstance(result, datetime)
-            self.assertIsNone(result.tzinfo)
+            assert result.tzinfo is None
 
             tm._skip_if_no_pytz()
             tm._skip_if_no_dateutil()
diff --git a/pandas/util/testing.py b/pandas/util/testing.py
index d6f3e00b7594d..b28bd6a696bda 100644
--- a/pandas/util/testing.py
+++ b/pandas/util/testing.py
@@ -1066,11 +1066,6 @@ def assertIs(first, second, msg=''):
     assert a is b, "%s: %r is not %r" % (msg.format(a, b), a, b)
 
 
-def assertIsNone(expr, msg=''):
-    """Checks that 'expr' is None"""
-    return assertIs(expr, None, msg)
-
-
 def assert_categorical_equal(left, right, check_dtype=True,
                              obj='Categorical', check_category_order=True):
     """Test that Categoricals are equivalent.