diff --git a/pandas/__init__.py b/pandas/__init__.py
index 9505d0481ee19..6ee0cf5ae07d5 100644
--- a/pandas/__init__.py
+++ b/pandas/__init__.py
@@ -23,13 +23,15 @@
 
 try:
     from pandas._libs import hashtable as _hashtable, lib as _lib, tslib as _tslib
-except ImportError as e:  # pragma: no cover
-    module = e.name
+except ImportError as err:  # pragma: no cover
+    module = err.name
     raise ImportError(
         f"C extension: {module} not built. If you want to import "
         "pandas from the source directory, you may need to run "
         "'python setup.py build_ext --force' to build the C extensions first."
-    ) from e
+    ) from err
+else:
+    del _tslib, _lib, _hashtable
 
 from pandas._config import (
     get_option,
diff --git a/pandas/tests/api/test_api.py b/pandas/tests/api/test_api.py
index ec20bc49c8a4b..8beacf6828a6b 100644
--- a/pandas/tests/api/test_api.py
+++ b/pandas/tests/api/test_api.py
@@ -188,12 +188,9 @@ class TestPDApi(Base):
     # private modules in pandas namespace
     private_modules = [
         "_config",
-        "_hashtable",
-        "_lib",
         "_libs",
         "_is_numpy_dev",
         "_testing",
-        "_tslib",
         "_typing",
         "_version",
     ]
diff --git a/pandas/tests/internals/test_internals.py b/pandas/tests/internals/test_internals.py
index 199c4e64f18fd..ef313b2840107 100644
--- a/pandas/tests/internals/test_internals.py
+++ b/pandas/tests/internals/test_internals.py
@@ -494,7 +494,6 @@ def test_copy(self, mgr):
 
     def test_sparse(self):
         mgr = create_mgr("a: sparse-1; b: sparse-2")
-        # what to test here?
         assert mgr.as_array().dtype == np.float64
 
     def test_sparse_mixed(self):
@@ -502,8 +501,6 @@ def test_sparse_mixed(self):
         assert len(mgr.blocks) == 3
         assert isinstance(mgr, BlockManager)
 
-        # TODO: what to test here?
-
     @pytest.mark.parametrize(
         "mgr_string, dtype",
         [("c: f4; d: f2", np.float32), ("c: f4; d: f2; e: f8", np.float64)],
diff --git a/pandas/tests/io/formats/test_to_html.py b/pandas/tests/io/formats/test_to_html.py
index a61e77bec9828..aa8508d8e8942 100644
--- a/pandas/tests/io/formats/test_to_html.py
+++ b/pandas/tests/io/formats/test_to_html.py
@@ -452,43 +452,59 @@ def test_to_html_invalid_justify(justify):
         df.to_html(justify=justify)
 
 
-def test_to_html_index(datapath):
-    # TODO: split this test
-    index = ["foo", "bar", "baz"]
-    df = DataFrame(
-        {"A": [1, 2, 3], "B": [1.2, 3.4, 5.6], "C": ["one", "two", np.nan]},
-        columns=["A", "B", "C"],
-        index=index,
-    )
-    expected_with_index = expected_html(datapath, "index_1")
-    assert df.to_html() == expected_with_index
-
-    expected_without_index = expected_html(datapath, "index_2")
-    result = df.to_html(index=False)
-    for i in index:
-        assert i not in result
-    assert result == expected_without_index
-    df.index = Index(["foo", "bar", "baz"], name="idx")
-    expected_with_index = expected_html(datapath, "index_3")
-    assert df.to_html() == expected_with_index
-    assert df.to_html(index=False) == expected_without_index
-
-    tuples = [("foo", "car"), ("foo", "bike"), ("bar", "car")]
-    df.index = MultiIndex.from_tuples(tuples)
-
-    expected_with_index = expected_html(datapath, "index_4")
-    assert df.to_html() == expected_with_index
+class TestHTMLIndex:
+    @pytest.fixture
+    def df(self):
+        index = ["foo", "bar", "baz"]
+        df = DataFrame(
+            {"A": [1, 2, 3], "B": [1.2, 3.4, 5.6], "C": ["one", "two", np.nan]},
+            columns=["A", "B", "C"],
+            index=index,
+        )
+        return df
 
-    result = df.to_html(index=False)
-    for i in ["foo", "bar", "car", "bike"]:
-        assert i not in result
-    # must be the same result as normal index
-    assert result == expected_without_index
-
-    df.index = MultiIndex.from_tuples(tuples, names=["idx1", "idx2"])
-    expected_with_index = expected_html(datapath, "index_5")
-    assert df.to_html() == expected_with_index
-    assert df.to_html(index=False) == expected_without_index
+    @pytest.fixture
+    def expected_without_index(self, datapath):
+        return expected_html(datapath, "index_2")
+
+    def test_to_html_flat_index_without_name(
+        self, datapath, df, expected_without_index
+    ):
+        expected_with_index = expected_html(datapath, "index_1")
+        assert df.to_html() == expected_with_index
+
+        result = df.to_html(index=False)
+        for i in df.index:
+            assert i not in result
+        assert result == expected_without_index
+
+    def test_to_html_flat_index_with_name(self, datapath, df, expected_without_index):
+        df.index = Index(["foo", "bar", "baz"], name="idx")
+        expected_with_index = expected_html(datapath, "index_3")
+        assert df.to_html() == expected_with_index
+        assert df.to_html(index=False) == expected_without_index
+
+    def test_to_html_multiindex_without_names(
+        self, datapath, df, expected_without_index
+    ):
+        tuples = [("foo", "car"), ("foo", "bike"), ("bar", "car")]
+        df.index = MultiIndex.from_tuples(tuples)
+
+        expected_with_index = expected_html(datapath, "index_4")
+        assert df.to_html() == expected_with_index
+
+        result = df.to_html(index=False)
+        for i in ["foo", "bar", "car", "bike"]:
+            assert i not in result
+        # must be the same result as normal index
+        assert result == expected_without_index
+
+    def test_to_html_multiindex_with_names(self, datapath, df, expected_without_index):
+        tuples = [("foo", "car"), ("foo", "bike"), ("bar", "car")]
+        df.index = MultiIndex.from_tuples(tuples, names=["idx1", "idx2"])
+        expected_with_index = expected_html(datapath, "index_5")
+        assert df.to_html() == expected_with_index
+        assert df.to_html(index=False) == expected_without_index
 
 
 @pytest.mark.parametrize("classes", ["sortable draggable", ["sortable", "draggable"]])
diff --git a/pandas/tests/io/json/test_json_table_schema.py b/pandas/tests/io/json/test_json_table_schema.py
index 89b8783462f7e..b204d3bb97b6e 100644
--- a/pandas/tests/io/json/test_json_table_schema.py
+++ b/pandas/tests/io/json/test_json_table_schema.py
@@ -185,14 +185,11 @@ def test_as_json_table_type_date_dtypes(self, date_dtype):
     def test_as_json_table_type_timedelta_dtypes(self, td_dtype):
         assert as_json_table_type(td_dtype) == "duration"
 
-    @pytest.mark.parametrize("str_dtype", [object])  # TODO
+    @pytest.mark.parametrize("str_dtype", [object])  # TODO(GH#14904) flesh out dtypes?
     def test_as_json_table_type_string_dtypes(self, str_dtype):
         assert as_json_table_type(str_dtype) == "string"
 
     def test_as_json_table_type_categorical_dtypes(self):
-        # TODO: I think before is_categorical_dtype(Categorical)
-        # returned True, but now it's False. Figure out why or
-        # if it matters
         assert as_json_table_type(pd.Categorical(["a"]).dtype) == "any"
         assert as_json_table_type(CategoricalDtype()) == "any"
 
diff --git a/pandas/tests/io/parser/common/test_file_buffer_url.py b/pandas/tests/io/parser/common/test_file_buffer_url.py
index 0855a469ae58d..4a8f734a34abf 100644
--- a/pandas/tests/io/parser/common/test_file_buffer_url.py
+++ b/pandas/tests/io/parser/common/test_file_buffer_url.py
@@ -28,7 +28,6 @@
 
 @tm.network
 def test_url(all_parsers, csv_dir_path):
-    # TODO: FTP testing
     parser = all_parsers
     kwargs = {"sep": "\t"}
 
diff --git a/pandas/tests/io/pytables/test_store.py b/pandas/tests/io/pytables/test_store.py
index 83c86d4da05e6..cbca8bb64e350 100644
--- a/pandas/tests/io/pytables/test_store.py
+++ b/pandas/tests/io/pytables/test_store.py
@@ -972,7 +972,8 @@ def test_columns_multiindex_modified(setup_path):
         )
         cols2load = list("BCD")
         cols2load_original = list(cols2load)
-        df_loaded = read_hdf(path, "df", columns=cols2load)  # noqa
+        # GH#10055 make sure read_hdf call does not alter cols2load inplace
+        read_hdf(path, "df", columns=cols2load)
         assert cols2load_original == cols2load
 
 
diff --git a/pandas/tests/io/test_sql.py b/pandas/tests/io/test_sql.py
index 92a53a443b217..cb8ee4891a41e 100644
--- a/pandas/tests/io/test_sql.py
+++ b/pandas/tests/io/test_sql.py
@@ -2128,7 +2128,7 @@ def test_get_engine_auto_error_message(self):
         # Expect different error messages from get_engine(engine="auto")
         # if engines aren't installed vs. are installed but bad version
         pass
-        # TODO fill this in when we add more engines
+        # TODO(GH#36893) fill this in when we add more engines
 
 
 class _TestSQLAlchemyConn(_EngineToConnMixin, _TestSQLAlchemy):
diff --git a/pandas/tests/reductions/test_stat_reductions.py b/pandas/tests/reductions/test_stat_reductions.py
index 0d1bb05c27564..2f1ae5df0d5d4 100644
--- a/pandas/tests/reductions/test_stat_reductions.py
+++ b/pandas/tests/reductions/test_stat_reductions.py
@@ -43,15 +43,14 @@ def test_dt64_mean(self, tz_naive_fixture, box):
         assert obj.mean(skipna=False) is pd.NaT
 
     @pytest.mark.parametrize("box", [Series, pd.Index, PeriodArray])
-    def test_period_mean(self, box):
+    @pytest.mark.parametrize("freq", ["S", "H", "D", "W", "B"])
+    def test_period_mean(self, box, freq):
         # GH#24757
         dti = pd.date_range("2001-01-01", periods=11)
         # shuffle so that we are not just working with monotone-increasing
         dti = dti.take([4, 1, 3, 10, 9, 7, 8, 5, 0, 2, 6])
 
-        # use hourly frequency to avoid rounding errors in expected results
-        #  TODO: flesh this out with different frequencies
-        parr = dti._data.to_period("H")
+        parr = dti._data.to_period(freq)
         obj = box(parr)
         with pytest.raises(TypeError, match="ambiguous"):
             obj.mean()
diff --git a/pandas/tests/reshape/concat/test_append_common.py b/pandas/tests/reshape/concat/test_append_common.py
index b8b254e786194..d5d86465dd91b 100644
--- a/pandas/tests/reshape/concat/test_append_common.py
+++ b/pandas/tests/reshape/concat/test_append_common.py
@@ -10,48 +10,50 @@
 )
 import pandas._testing as tm
 
+dt_data = [
+    pd.Timestamp("2011-01-01"),
+    pd.Timestamp("2011-01-02"),
+    pd.Timestamp("2011-01-03"),
+]
+tz_data = [
+    pd.Timestamp("2011-01-01", tz="US/Eastern"),
+    pd.Timestamp("2011-01-02", tz="US/Eastern"),
+    pd.Timestamp("2011-01-03", tz="US/Eastern"),
+]
+td_data = [
+    pd.Timedelta("1 days"),
+    pd.Timedelta("2 days"),
+    pd.Timedelta("3 days"),
+]
+period_data = [
+    pd.Period("2011-01", freq="M"),
+    pd.Period("2011-02", freq="M"),
+    pd.Period("2011-03", freq="M"),
+]
+data_dict = {
+    "bool": [True, False, True],
+    "int64": [1, 2, 3],
+    "float64": [1.1, np.nan, 3.3],
+    "category": Categorical(["X", "Y", "Z"]),
+    "object": ["a", "b", "c"],
+    "datetime64[ns]": dt_data,
+    "datetime64[ns, US/Eastern]": tz_data,
+    "timedelta64[ns]": td_data,
+    "period[M]": period_data,
+}
+
 
 class TestConcatAppendCommon:
     """
     Test common dtype coercion rules between concat and append.
     """
 
-    def setup_method(self, method):
-
-        dt_data = [
-            pd.Timestamp("2011-01-01"),
-            pd.Timestamp("2011-01-02"),
-            pd.Timestamp("2011-01-03"),
-        ]
-        tz_data = [
-            pd.Timestamp("2011-01-01", tz="US/Eastern"),
-            pd.Timestamp("2011-01-02", tz="US/Eastern"),
-            pd.Timestamp("2011-01-03", tz="US/Eastern"),
-        ]
-
-        td_data = [
-            pd.Timedelta("1 days"),
-            pd.Timedelta("2 days"),
-            pd.Timedelta("3 days"),
-        ]
-
-        period_data = [
-            pd.Period("2011-01", freq="M"),
-            pd.Period("2011-02", freq="M"),
-            pd.Period("2011-03", freq="M"),
-        ]
-
-        self.data = {
-            "bool": [True, False, True],
-            "int64": [1, 2, 3],
-            "float64": [1.1, np.nan, 3.3],
-            "category": Categorical(["X", "Y", "Z"]),
-            "object": ["a", "b", "c"],
-            "datetime64[ns]": dt_data,
-            "datetime64[ns, US/Eastern]": tz_data,
-            "timedelta64[ns]": td_data,
-            "period[M]": period_data,
-        }
+    @pytest.fixture(params=sorted(data_dict.keys()))
+    def item(self, request):
+        key = request.param
+        return key, data_dict[key]
+
+    item2 = item
 
     def _check_expected_dtype(self, obj, label):
         """
@@ -71,192 +73,189 @@ def _check_expected_dtype(self, obj, label):
         else:
             raise ValueError
 
-    def test_dtypes(self):
+    def test_dtypes(self, item):
         # to confirm test case covers intended dtypes
-        for typ, vals in self.data.items():
-            self._check_expected_dtype(Index(vals), typ)
-            self._check_expected_dtype(Series(vals), typ)
+        typ, vals = item
+        self._check_expected_dtype(Index(vals), typ)
+        self._check_expected_dtype(Series(vals), typ)
 
-    def test_concatlike_same_dtypes(self):
+    def test_concatlike_same_dtypes(self, item):
         # GH 13660
-        for typ1, vals1 in self.data.items():
+        typ1, vals1 = item
 
-            vals2 = vals1
-            vals3 = vals1
+        vals2 = vals1
+        vals3 = vals1
 
-            if typ1 == "category":
-                exp_data = Categorical(list(vals1) + list(vals2))
-                exp_data3 = Categorical(list(vals1) + list(vals2) + list(vals3))
-            else:
-                exp_data = vals1 + vals2
-                exp_data3 = vals1 + vals2 + vals3
-
-            # ----- Index ----- #
-
-            # index.append
-            res = Index(vals1).append(Index(vals2))
-            exp = Index(exp_data)
-            tm.assert_index_equal(res, exp)
-
-            # 3 elements
-            res = Index(vals1).append([Index(vals2), Index(vals3)])
-            exp = Index(exp_data3)
-            tm.assert_index_equal(res, exp)
-
-            # index.append name mismatch
-            i1 = Index(vals1, name="x")
-            i2 = Index(vals2, name="y")
-            res = i1.append(i2)
-            exp = Index(exp_data)
-            tm.assert_index_equal(res, exp)
-
-            # index.append name match
-            i1 = Index(vals1, name="x")
-            i2 = Index(vals2, name="x")
-            res = i1.append(i2)
-            exp = Index(exp_data, name="x")
-            tm.assert_index_equal(res, exp)
-
-            # cannot append non-index
-            with pytest.raises(TypeError, match="all inputs must be Index"):
-                Index(vals1).append(vals2)
-
-            with pytest.raises(TypeError, match="all inputs must be Index"):
-                Index(vals1).append([Index(vals2), vals3])
-
-            # ----- Series ----- #
-
-            # series.append
-            res = Series(vals1).append(Series(vals2), ignore_index=True)
-            exp = Series(exp_data)
-            tm.assert_series_equal(res, exp, check_index_type=True)
-
-            # concat
-            res = pd.concat([Series(vals1), Series(vals2)], ignore_index=True)
-            tm.assert_series_equal(res, exp, check_index_type=True)
-
-            # 3 elements
-            res = Series(vals1).append(
-                [Series(vals2), Series(vals3)], ignore_index=True
-            )
-            exp = Series(exp_data3)
-            tm.assert_series_equal(res, exp)
-
-            res = pd.concat(
-                [Series(vals1), Series(vals2), Series(vals3)],
-                ignore_index=True,
-            )
-            tm.assert_series_equal(res, exp)
-
-            # name mismatch
-            s1 = Series(vals1, name="x")
-            s2 = Series(vals2, name="y")
-            res = s1.append(s2, ignore_index=True)
-            exp = Series(exp_data)
-            tm.assert_series_equal(res, exp, check_index_type=True)
-
-            res = pd.concat([s1, s2], ignore_index=True)
-            tm.assert_series_equal(res, exp, check_index_type=True)
-
-            # name match
-            s1 = Series(vals1, name="x")
-            s2 = Series(vals2, name="x")
-            res = s1.append(s2, ignore_index=True)
-            exp = Series(exp_data, name="x")
-            tm.assert_series_equal(res, exp, check_index_type=True)
-
-            res = pd.concat([s1, s2], ignore_index=True)
-            tm.assert_series_equal(res, exp, check_index_type=True)
-
-            # cannot append non-index
-            msg = (
-                r"cannot concatenate object of type '.+'; "
-                "only Series and DataFrame objs are valid"
-            )
-            with pytest.raises(TypeError, match=msg):
-                Series(vals1).append(vals2)
-
-            with pytest.raises(TypeError, match=msg):
-                Series(vals1).append([Series(vals2), vals3])
-
-            with pytest.raises(TypeError, match=msg):
-                pd.concat([Series(vals1), vals2])
-
-            with pytest.raises(TypeError, match=msg):
-                pd.concat([Series(vals1), Series(vals2), vals3])
-
-    def test_concatlike_dtypes_coercion(self):
+        if typ1 == "category":
+            exp_data = Categorical(list(vals1) + list(vals2))
+            exp_data3 = Categorical(list(vals1) + list(vals2) + list(vals3))
+        else:
+            exp_data = vals1 + vals2
+            exp_data3 = vals1 + vals2 + vals3
+
+        # ----- Index ----- #
+
+        # index.append
+        res = Index(vals1).append(Index(vals2))
+        exp = Index(exp_data)
+        tm.assert_index_equal(res, exp)
+
+        # 3 elements
+        res = Index(vals1).append([Index(vals2), Index(vals3)])
+        exp = Index(exp_data3)
+        tm.assert_index_equal(res, exp)
+
+        # index.append name mismatch
+        i1 = Index(vals1, name="x")
+        i2 = Index(vals2, name="y")
+        res = i1.append(i2)
+        exp = Index(exp_data)
+        tm.assert_index_equal(res, exp)
+
+        # index.append name match
+        i1 = Index(vals1, name="x")
+        i2 = Index(vals2, name="x")
+        res = i1.append(i2)
+        exp = Index(exp_data, name="x")
+        tm.assert_index_equal(res, exp)
+
+        # cannot append non-index
+        with pytest.raises(TypeError, match="all inputs must be Index"):
+            Index(vals1).append(vals2)
+
+        with pytest.raises(TypeError, match="all inputs must be Index"):
+            Index(vals1).append([Index(vals2), vals3])
+
+        # ----- Series ----- #
+
+        # series.append
+        res = Series(vals1).append(Series(vals2), ignore_index=True)
+        exp = Series(exp_data)
+        tm.assert_series_equal(res, exp, check_index_type=True)
+
+        # concat
+        res = pd.concat([Series(vals1), Series(vals2)], ignore_index=True)
+        tm.assert_series_equal(res, exp, check_index_type=True)
+
+        # 3 elements
+        res = Series(vals1).append([Series(vals2), Series(vals3)], ignore_index=True)
+        exp = Series(exp_data3)
+        tm.assert_series_equal(res, exp)
+
+        res = pd.concat(
+            [Series(vals1), Series(vals2), Series(vals3)],
+            ignore_index=True,
+        )
+        tm.assert_series_equal(res, exp)
+
+        # name mismatch
+        s1 = Series(vals1, name="x")
+        s2 = Series(vals2, name="y")
+        res = s1.append(s2, ignore_index=True)
+        exp = Series(exp_data)
+        tm.assert_series_equal(res, exp, check_index_type=True)
+
+        res = pd.concat([s1, s2], ignore_index=True)
+        tm.assert_series_equal(res, exp, check_index_type=True)
+
+        # name match
+        s1 = Series(vals1, name="x")
+        s2 = Series(vals2, name="x")
+        res = s1.append(s2, ignore_index=True)
+        exp = Series(exp_data, name="x")
+        tm.assert_series_equal(res, exp, check_index_type=True)
+
+        res = pd.concat([s1, s2], ignore_index=True)
+        tm.assert_series_equal(res, exp, check_index_type=True)
+
+        # cannot append non-index
+        msg = (
+            r"cannot concatenate object of type '.+'; "
+            "only Series and DataFrame objs are valid"
+        )
+        with pytest.raises(TypeError, match=msg):
+            Series(vals1).append(vals2)
+
+        with pytest.raises(TypeError, match=msg):
+            Series(vals1).append([Series(vals2), vals3])
+
+        with pytest.raises(TypeError, match=msg):
+            pd.concat([Series(vals1), vals2])
+
+        with pytest.raises(TypeError, match=msg):
+            pd.concat([Series(vals1), Series(vals2), vals3])
+
+    def test_concatlike_dtypes_coercion(self, item, item2):
         # GH 13660
-        for typ1, vals1 in self.data.items():
-            for typ2, vals2 in self.data.items():
-
-                vals3 = vals2
-
-                # basically infer
-                exp_index_dtype = None
-                exp_series_dtype = None
-
-                if typ1 == typ2:
-                    # same dtype is tested in test_concatlike_same_dtypes
-                    continue
-                elif typ1 == "category" or typ2 == "category":
-                    # TODO: suspicious
-                    continue
-
-                # specify expected dtype
-                if typ1 == "bool" and typ2 in ("int64", "float64"):
-                    # series coerces to numeric based on numpy rule
-                    # index doesn't because bool is object dtype
-                    exp_series_dtype = typ2
-                elif typ2 == "bool" and typ1 in ("int64", "float64"):
-                    exp_series_dtype = typ1
-                elif (
-                    typ1 == "datetime64[ns, US/Eastern]"
-                    or typ2 == "datetime64[ns, US/Eastern]"
-                    or typ1 == "timedelta64[ns]"
-                    or typ2 == "timedelta64[ns]"
-                ):
-                    exp_index_dtype = object
-                    exp_series_dtype = object
-
-                exp_data = vals1 + vals2
-                exp_data3 = vals1 + vals2 + vals3
-
-                # ----- Index ----- #
-
-                # index.append
-                res = Index(vals1).append(Index(vals2))
-                exp = Index(exp_data, dtype=exp_index_dtype)
-                tm.assert_index_equal(res, exp)
-
-                # 3 elements
-                res = Index(vals1).append([Index(vals2), Index(vals3)])
-                exp = Index(exp_data3, dtype=exp_index_dtype)
-                tm.assert_index_equal(res, exp)
-
-                # ----- Series ----- #
-
-                # series.append
-                res = Series(vals1).append(Series(vals2), ignore_index=True)
-                exp = Series(exp_data, dtype=exp_series_dtype)
-                tm.assert_series_equal(res, exp, check_index_type=True)
-
-                # concat
-                res = pd.concat([Series(vals1), Series(vals2)], ignore_index=True)
-                tm.assert_series_equal(res, exp, check_index_type=True)
-
-                # 3 elements
-                res = Series(vals1).append(
-                    [Series(vals2), Series(vals3)], ignore_index=True
-                )
-                exp = Series(exp_data3, dtype=exp_series_dtype)
-                tm.assert_series_equal(res, exp)
-
-                res = pd.concat(
-                    [Series(vals1), Series(vals2), Series(vals3)],
-                    ignore_index=True,
-                )
-                tm.assert_series_equal(res, exp)
+        typ1, vals1 = item
+        typ2, vals2 = item2
+
+        vals3 = vals2
+
+        # basically infer
+        exp_index_dtype = None
+        exp_series_dtype = None
+
+        if typ1 == typ2:
+            # same dtype is tested in test_concatlike_same_dtypes
+            return
+        elif typ1 == "category" or typ2 == "category":
+            # The `vals1 + vals2` below fails bc one of these is a Categorical
+            #  instead of a list; we have separate dedicated tests for categorical
+            return
+
+        # specify expected dtype
+        if typ1 == "bool" and typ2 in ("int64", "float64"):
+            # series coerces to numeric based on numpy rule
+            # index doesn't because bool is object dtype
+            exp_series_dtype = typ2
+        elif typ2 == "bool" and typ1 in ("int64", "float64"):
+            exp_series_dtype = typ1
+        elif (
+            typ1 == "datetime64[ns, US/Eastern]"
+            or typ2 == "datetime64[ns, US/Eastern]"
+            or typ1 == "timedelta64[ns]"
+            or typ2 == "timedelta64[ns]"
+        ):
+            exp_index_dtype = object
+            exp_series_dtype = object
+
+        exp_data = vals1 + vals2
+        exp_data3 = vals1 + vals2 + vals3
+
+        # ----- Index ----- #
+
+        # index.append
+        res = Index(vals1).append(Index(vals2))
+        exp = Index(exp_data, dtype=exp_index_dtype)
+        tm.assert_index_equal(res, exp)
+
+        # 3 elements
+        res = Index(vals1).append([Index(vals2), Index(vals3)])
+        exp = Index(exp_data3, dtype=exp_index_dtype)
+        tm.assert_index_equal(res, exp)
+
+        # ----- Series ----- #
+
+        # series.append
+        res = Series(vals1).append(Series(vals2), ignore_index=True)
+        exp = Series(exp_data, dtype=exp_series_dtype)
+        tm.assert_series_equal(res, exp, check_index_type=True)
+
+        # concat
+        res = pd.concat([Series(vals1), Series(vals2)], ignore_index=True)
+        tm.assert_series_equal(res, exp, check_index_type=True)
+
+        # 3 elements
+        res = Series(vals1).append([Series(vals2), Series(vals3)], ignore_index=True)
+        exp = Series(exp_data3, dtype=exp_series_dtype)
+        tm.assert_series_equal(res, exp)
+
+        res = pd.concat(
+            [Series(vals1), Series(vals2), Series(vals3)],
+            ignore_index=True,
+        )
+        tm.assert_series_equal(res, exp)
 
     def test_concatlike_common_coerce_to_pandas_object(self):
         # GH 13626
diff --git a/pandas/tests/reshape/merge/test_merge.py b/pandas/tests/reshape/merge/test_merge.py
index 371a7fed543e4..2f9f31ebb0485 100644
--- a/pandas/tests/reshape/merge/test_merge.py
+++ b/pandas/tests/reshape/merge/test_merge.py
@@ -597,7 +597,7 @@ def test_merge_all_na_column(self, series_of_dtype, series_of_dtype_all_na):
         tm.assert_frame_equal(actual, expected)
 
     def test_merge_nosort(self):
-        # GH#2098, TODO: anything to do?
+        # GH#2098
 
         d = {
             "var1": np.random.randint(0, 10, size=10),
diff --git a/pandas/tests/series/indexing/test_get.py b/pandas/tests/series/indexing/test_get.py
index 23db91e25125d..e8034bd4f7160 100644
--- a/pandas/tests/series/indexing/test_get.py
+++ b/pandas/tests/series/indexing/test_get.py
@@ -158,8 +158,7 @@ def test_get_with_default():
     "arr",
     [np.random.randn(10), tm.makeDateIndex(10, name="a").tz_localize(tz="US/Eastern")],
 )
-def test_get2(arr):
-    # TODO: better name, possibly split
+def test_get_with_ea(arr):
     # GH#21260
     ser = Series(arr, index=[2 * i for i in range(len(arr))])
     assert ser.get(4) == ser.iloc[2]
diff --git a/pandas/tests/series/indexing/test_setitem.py b/pandas/tests/series/indexing/test_setitem.py
index 7082edb877ec1..3e8e1b3f436ec 100644
--- a/pandas/tests/series/indexing/test_setitem.py
+++ b/pandas/tests/series/indexing/test_setitem.py
@@ -107,7 +107,7 @@ def test_setitem_with_tz(self, tz, indexer_sli):
         tm.assert_series_equal(ser, exp)
 
     def test_setitem_with_tz_dst(self, indexer_sli):
-        # GH XXX TODO: fill in GH ref
+        # GH#14146 trouble setting values near DST boundary
         tz = "US/Eastern"
         orig = Series(date_range("2016-11-06", freq="H", periods=3, tz=tz))
         assert orig.dtype == f"datetime64[ns, {tz}]"
diff --git a/pandas/tests/test_algos.py b/pandas/tests/test_algos.py
index 17efdd7e4f98b..fcb50e463d9f9 100644
--- a/pandas/tests/test_algos.py
+++ b/pandas/tests/test_algos.py
@@ -1721,9 +1721,9 @@ def test_hashtable_factorize(self, htable, tm_dtype, writable):
         ],
     )
     def test_hashtable_large_sizehint(self, hashtable):
-        # GH 22729
+        # GH#22729 smoketest for not raising when passing a large size_hint
         size_hint = np.iinfo(np.uint32).max + 1
-        tbl = hashtable(size_hint=size_hint)  # noqa
+        hashtable(size_hint=size_hint)
 
 
 def test_unique_label_indices():