diff --git a/pandas/tests/indexes/datetimes/test_astype.py b/pandas/tests/indexes/datetimes/test_astype.py
index 6139726dc34e4..916f722247a14 100644
--- a/pandas/tests/indexes/datetimes/test_astype.py
+++ b/pandas/tests/indexes/datetimes/test_astype.py
@@ -1,7 +1,6 @@
 from datetime import datetime
 
 import dateutil
-from dateutil.tz import tzlocal
 import numpy as np
 import pytest
 import pytz
@@ -12,7 +11,7 @@
     Index,
     Int64Index,
     NaT,
-    Period,
+    PeriodIndex,
     Series,
     Timestamp,
     date_range,
@@ -278,81 +277,19 @@ def test_integer_index_astype_datetime(self, tz, dtype):
         expected = pd.DatetimeIndex(["2018-01-01"], tz=tz)
         tm.assert_index_equal(result, expected)
 
+    def test_dti_astype_period(self):
+        idx = DatetimeIndex([NaT, "2011-01-01", "2011-02-01"], name="idx")
 
-class TestToPeriod:
-    def setup_method(self, method):
-        data = [
-            Timestamp("2007-01-01 10:11:12.123456Z"),
-            Timestamp("2007-01-01 10:11:13.789123Z"),
-        ]
-        self.index = DatetimeIndex(data)
-
-    def test_to_period_millisecond(self):
-        index = self.index
-
-        with tm.assert_produces_warning(UserWarning):
-            # warning that timezone info will be lost
-            period = index.to_period(freq="L")
-        assert 2 == len(period)
-        assert period[0] == Period("2007-01-01 10:11:12.123Z", "L")
-        assert period[1] == Period("2007-01-01 10:11:13.789Z", "L")
-
-    def test_to_period_microsecond(self):
-        index = self.index
+        res = idx.astype("period[M]")
+        exp = PeriodIndex(["NaT", "2011-01", "2011-02"], freq="M", name="idx")
+        tm.assert_index_equal(res, exp)
 
-        with tm.assert_produces_warning(UserWarning):
-            # warning that timezone info will be lost
-            period = index.to_period(freq="U")
-        assert 2 == len(period)
-        assert period[0] == Period("2007-01-01 10:11:12.123456Z", "U")
-        assert period[1] == Period("2007-01-01 10:11:13.789123Z", "U")
-
-    @pytest.mark.parametrize(
-        "tz",
-        ["US/Eastern", pytz.utc, tzlocal(), "dateutil/US/Eastern", dateutil.tz.tzutc()],
-    )
-    def test_to_period_tz(self, tz):
-        ts = date_range("1/1/2000", "2/1/2000", tz=tz)
-
-        with tm.assert_produces_warning(UserWarning):
-            # GH#21333 warning that timezone info will be lost
-            result = ts.to_period()[0]
-            expected = ts[0].to_period()
-
-        assert result == expected
-
-        expected = date_range("1/1/2000", "2/1/2000").to_period()
-
-        with tm.assert_produces_warning(UserWarning):
-            # GH#21333 warning that timezone info will be lost
-            result = ts.to_period()
-
-        tm.assert_index_equal(result, expected)
+        res = idx.astype("period[3M]")
+        exp = PeriodIndex(["NaT", "2011-01", "2011-02"], freq="3M", name="idx")
+        tm.assert_index_equal(res, exp)
 
-    @pytest.mark.parametrize("tz", ["Etc/GMT-1", "Etc/GMT+1"])
-    def test_to_period_tz_utc_offset_consistency(self, tz):
-        # GH 22905
-        ts = pd.date_range("1/1/2000", "2/1/2000", tz="Etc/GMT-1")
-        with tm.assert_produces_warning(UserWarning):
-            result = ts.to_period()[0]
-            expected = ts[0].to_period()
-            assert result == expected
-
-    def test_to_period_nofreq(self):
-        idx = DatetimeIndex(["2000-01-01", "2000-01-02", "2000-01-04"])
-        with pytest.raises(ValueError):
-            idx.to_period()
-
-        idx = DatetimeIndex(["2000-01-01", "2000-01-02", "2000-01-03"], freq="infer")
-        assert idx.freqstr == "D"
-        expected = pd.PeriodIndex(["2000-01-01", "2000-01-02", "2000-01-03"], freq="D")
-        tm.assert_index_equal(idx.to_period(), expected)
-
-        # GH 7606
-        idx = DatetimeIndex(["2000-01-01", "2000-01-02", "2000-01-03"])
-        assert idx.freqstr is None
-        tm.assert_index_equal(idx.to_period(), expected)
 
+class TestAstype:
     @pytest.mark.parametrize("tz", [None, "US/Central"])
     def test_astype_category(self, tz):
         obj = pd.date_range("2000", periods=2, tz=tz)
diff --git a/pandas/tests/indexes/datetimes/test_to_period.py b/pandas/tests/indexes/datetimes/test_to_period.py
new file mode 100644
index 0000000000000..5567f98c52211
--- /dev/null
+++ b/pandas/tests/indexes/datetimes/test_to_period.py
@@ -0,0 +1,161 @@
+import dateutil.tz
+from dateutil.tz import tzlocal
+import pytest
+import pytz
+
+from pandas._libs.tslibs.ccalendar import MONTHS
+from pandas._libs.tslibs.frequencies import INVALID_FREQ_ERR_MSG
+
+from pandas import (
+    DatetimeIndex,
+    Period,
+    PeriodIndex,
+    Timestamp,
+    date_range,
+    period_range,
+)
+import pandas._testing as tm
+
+
+class TestToPeriod:
+    def test_dti_to_period(self):
+        dti = date_range(start="1/1/2005", end="12/1/2005", freq="M")
+        pi1 = dti.to_period()
+        pi2 = dti.to_period(freq="D")
+        pi3 = dti.to_period(freq="3D")
+
+        assert pi1[0] == Period("Jan 2005", freq="M")
+        assert pi2[0] == Period("1/31/2005", freq="D")
+        assert pi3[0] == Period("1/31/2005", freq="3D")
+
+        assert pi1[-1] == Period("Nov 2005", freq="M")
+        assert pi2[-1] == Period("11/30/2005", freq="D")
+        assert pi3[-1], Period("11/30/2005", freq="3D")
+
+        tm.assert_index_equal(pi1, period_range("1/1/2005", "11/1/2005", freq="M"))
+        tm.assert_index_equal(
+            pi2, period_range("1/1/2005", "11/1/2005", freq="M").asfreq("D")
+        )
+        tm.assert_index_equal(
+            pi3, period_range("1/1/2005", "11/1/2005", freq="M").asfreq("3D")
+        )
+
+    @pytest.mark.parametrize("month", MONTHS)
+    def test_to_period_quarterly(self, month):
+        # make sure we can make the round trip
+        freq = "Q-{month}".format(month=month)
+        rng = period_range("1989Q3", "1991Q3", freq=freq)
+        stamps = rng.to_timestamp()
+        result = stamps.to_period(freq)
+        tm.assert_index_equal(rng, result)
+
+    @pytest.mark.parametrize("off", ["BQ", "QS", "BQS"])
+    def test_to_period_quarterlyish(self, off):
+        rng = date_range("01-Jan-2012", periods=8, freq=off)
+        prng = rng.to_period()
+        assert prng.freq == "Q-DEC"
+
+    @pytest.mark.parametrize("off", ["BA", "AS", "BAS"])
+    def test_to_period_annualish(self, off):
+        rng = date_range("01-Jan-2012", periods=8, freq=off)
+        prng = rng.to_period()
+        assert prng.freq == "A-DEC"
+
+    def test_to_period_monthish(self):
+        offsets = ["MS", "BM"]
+        for off in offsets:
+            rng = date_range("01-Jan-2012", periods=8, freq=off)
+            prng = rng.to_period()
+            assert prng.freq == "M"
+
+        rng = date_range("01-Jan-2012", periods=8, freq="M")
+        prng = rng.to_period()
+        assert prng.freq == "M"
+
+        with pytest.raises(ValueError, match=INVALID_FREQ_ERR_MSG):
+            date_range("01-Jan-2012", periods=8, freq="EOM")
+
+    def test_period_dt64_round_trip(self):
+        dti = date_range("1/1/2000", "1/7/2002", freq="B")
+        pi = dti.to_period()
+        tm.assert_index_equal(pi.to_timestamp(), dti)
+
+        dti = date_range("1/1/2000", "1/7/2002", freq="B")
+        pi = dti.to_period(freq="H")
+        tm.assert_index_equal(pi.to_timestamp(), dti)
+
+    def test_to_period_millisecond(self):
+        index = DatetimeIndex(
+            [
+                Timestamp("2007-01-01 10:11:12.123456Z"),
+                Timestamp("2007-01-01 10:11:13.789123Z"),
+            ]
+        )
+
+        with tm.assert_produces_warning(UserWarning):
+            # warning that timezone info will be lost
+            period = index.to_period(freq="L")
+        assert 2 == len(period)
+        assert period[0] == Period("2007-01-01 10:11:12.123Z", "L")
+        assert period[1] == Period("2007-01-01 10:11:13.789Z", "L")
+
+    def test_to_period_microsecond(self):
+        index = DatetimeIndex(
+            [
+                Timestamp("2007-01-01 10:11:12.123456Z"),
+                Timestamp("2007-01-01 10:11:13.789123Z"),
+            ]
+        )
+
+        with tm.assert_produces_warning(UserWarning):
+            # warning that timezone info will be lost
+            period = index.to_period(freq="U")
+        assert 2 == len(period)
+        assert period[0] == Period("2007-01-01 10:11:12.123456Z", "U")
+        assert period[1] == Period("2007-01-01 10:11:13.789123Z", "U")
+
+    @pytest.mark.parametrize(
+        "tz",
+        ["US/Eastern", pytz.utc, tzlocal(), "dateutil/US/Eastern", dateutil.tz.tzutc()],
+    )
+    def test_to_period_tz(self, tz):
+        ts = date_range("1/1/2000", "2/1/2000", tz=tz)
+
+        with tm.assert_produces_warning(UserWarning):
+            # GH#21333 warning that timezone info will be lost
+            result = ts.to_period()[0]
+            expected = ts[0].to_period()
+
+        assert result == expected
+
+        expected = date_range("1/1/2000", "2/1/2000").to_period()
+
+        with tm.assert_produces_warning(UserWarning):
+            # GH#21333 warning that timezone info will be lost
+            result = ts.to_period()
+
+        tm.assert_index_equal(result, expected)
+
+    @pytest.mark.parametrize("tz", ["Etc/GMT-1", "Etc/GMT+1"])
+    def test_to_period_tz_utc_offset_consistency(self, tz):
+        # GH#22905
+        ts = date_range("1/1/2000", "2/1/2000", tz="Etc/GMT-1")
+        with tm.assert_produces_warning(UserWarning):
+            result = ts.to_period()[0]
+            expected = ts[0].to_period()
+            assert result == expected
+
+    def test_to_period_nofreq(self):
+        idx = DatetimeIndex(["2000-01-01", "2000-01-02", "2000-01-04"])
+        with pytest.raises(ValueError):
+            idx.to_period()
+
+        idx = DatetimeIndex(["2000-01-01", "2000-01-02", "2000-01-03"], freq="infer")
+        assert idx.freqstr == "D"
+        expected = PeriodIndex(["2000-01-01", "2000-01-02", "2000-01-03"], freq="D")
+        tm.assert_index_equal(idx.to_period(), expected)
+
+        # GH#7606
+        idx = DatetimeIndex(["2000-01-01", "2000-01-02", "2000-01-03"])
+        assert idx.freqstr is None
+        tm.assert_index_equal(idx.to_period(), expected)
diff --git a/pandas/tests/indexes/period/test_asfreq.py b/pandas/tests/indexes/period/test_asfreq.py
index 88e800d66f3ad..8c04ac1177676 100644
--- a/pandas/tests/indexes/period/test_asfreq.py
+++ b/pandas/tests/indexes/period/test_asfreq.py
@@ -1,8 +1,6 @@
-import numpy as np
 import pytest
 
-import pandas as pd
-from pandas import DataFrame, PeriodIndex, Series, period_range
+from pandas import PeriodIndex, period_range
 import pandas._testing as tm
 
 
@@ -98,7 +96,7 @@ def test_asfreq_mult_pi(self, freq):
         assert result.freq == exp.freq
 
     def test_asfreq_combined_pi(self):
-        pi = pd.PeriodIndex(["2001-01-01 00:00", "2001-01-02 02:00", "NaT"], freq="H")
+        pi = PeriodIndex(["2001-01-01 00:00", "2001-01-02 02:00", "NaT"], freq="H")
         exp = PeriodIndex(["2001-01-01 00:00", "2001-01-02 02:00", "NaT"], freq="25H")
         for freq, how in zip(["1D1H", "1H1D"], ["S", "E"]):
             result = pi.asfreq(freq, how=how)
@@ -106,38 +104,18 @@ def test_asfreq_combined_pi(self):
             assert result.freq == exp.freq
 
         for freq in ["1D1H", "1H1D"]:
-            pi = pd.PeriodIndex(
-                ["2001-01-01 00:00", "2001-01-02 02:00", "NaT"], freq=freq
-            )
+            pi = PeriodIndex(["2001-01-01 00:00", "2001-01-02 02:00", "NaT"], freq=freq)
             result = pi.asfreq("H")
             exp = PeriodIndex(["2001-01-02 00:00", "2001-01-03 02:00", "NaT"], freq="H")
             tm.assert_index_equal(result, exp)
             assert result.freq == exp.freq
 
-            pi = pd.PeriodIndex(
-                ["2001-01-01 00:00", "2001-01-02 02:00", "NaT"], freq=freq
-            )
+            pi = PeriodIndex(["2001-01-01 00:00", "2001-01-02 02:00", "NaT"], freq=freq)
             result = pi.asfreq("H", how="S")
             exp = PeriodIndex(["2001-01-01 00:00", "2001-01-02 02:00", "NaT"], freq="H")
             tm.assert_index_equal(result, exp)
             assert result.freq == exp.freq
 
-    def test_asfreq_ts(self):
-        index = period_range(freq="A", start="1/1/2001", end="12/31/2010")
-        ts = Series(np.random.randn(len(index)), index=index)
-        df = DataFrame(np.random.randn(len(index), 3), index=index)
-
-        result = ts.asfreq("D", how="end")
-        df_result = df.asfreq("D", how="end")
-        exp_index = index.asfreq("D", how="end")
-        assert len(result) == len(ts)
-        tm.assert_index_equal(result.index, exp_index)
-        tm.assert_index_equal(df_result.index, exp_index)
-
-        result = ts.asfreq("D", how="start")
-        assert len(result) == len(ts)
-        tm.assert_index_equal(result.index, index.asfreq("D", how="start"))
-
     def test_astype_asfreq(self):
         pi1 = PeriodIndex(["2011-01-01", "2011-02-01", "2011-03-01"], freq="D")
         exp = PeriodIndex(["2011-01", "2011-02", "2011-03"], freq="M")
diff --git a/pandas/tests/indexes/period/test_astype.py b/pandas/tests/indexes/period/test_astype.py
index ec386dd9dd11c..2f10e45193d5d 100644
--- a/pandas/tests/indexes/period/test_astype.py
+++ b/pandas/tests/indexes/period/test_astype.py
@@ -1,8 +1,18 @@
 import numpy as np
 import pytest
 
-import pandas as pd
-from pandas import Index, Int64Index, NaT, Period, PeriodIndex, period_range
+from pandas import (
+    CategoricalIndex,
+    DatetimeIndex,
+    Index,
+    Int64Index,
+    NaT,
+    Period,
+    PeriodIndex,
+    Timedelta,
+    UInt64Index,
+    period_range,
+)
 import pandas._testing as tm
 
 
@@ -41,39 +51,39 @@ def test_astype_conversion(self):
 
     def test_astype_uint(self):
         arr = period_range("2000", periods=2)
-        expected = pd.UInt64Index(np.array([10957, 10958], dtype="uint64"))
+        expected = UInt64Index(np.array([10957, 10958], dtype="uint64"))
         tm.assert_index_equal(arr.astype("uint64"), expected)
         tm.assert_index_equal(arr.astype("uint32"), expected)
 
     def test_astype_object(self):
-        idx = pd.PeriodIndex([], freq="M")
+        idx = PeriodIndex([], freq="M")
 
         exp = np.array([], dtype=object)
         tm.assert_numpy_array_equal(idx.astype(object).values, exp)
         tm.assert_numpy_array_equal(idx._mpl_repr(), exp)
 
-        idx = pd.PeriodIndex(["2011-01", pd.NaT], freq="M")
+        idx = PeriodIndex(["2011-01", NaT], freq="M")
 
-        exp = np.array([pd.Period("2011-01", freq="M"), pd.NaT], dtype=object)
+        exp = np.array([Period("2011-01", freq="M"), NaT], dtype=object)
         tm.assert_numpy_array_equal(idx.astype(object).values, exp)
         tm.assert_numpy_array_equal(idx._mpl_repr(), exp)
 
-        exp = np.array([pd.Period("2011-01-01", freq="D"), pd.NaT], dtype=object)
-        idx = pd.PeriodIndex(["2011-01-01", pd.NaT], freq="D")
+        exp = np.array([Period("2011-01-01", freq="D"), NaT], dtype=object)
+        idx = PeriodIndex(["2011-01-01", NaT], freq="D")
         tm.assert_numpy_array_equal(idx.astype(object).values, exp)
         tm.assert_numpy_array_equal(idx._mpl_repr(), exp)
 
     # TODO: de-duplicate this version (from test_ops) with the one above
     # (from test_period)
     def test_astype_object2(self):
-        idx = pd.period_range(start="2013-01-01", periods=4, freq="M", name="idx")
+        idx = period_range(start="2013-01-01", periods=4, freq="M", name="idx")
         expected_list = [
-            pd.Period("2013-01-31", freq="M"),
-            pd.Period("2013-02-28", freq="M"),
-            pd.Period("2013-03-31", freq="M"),
-            pd.Period("2013-04-30", freq="M"),
+            Period("2013-01-31", freq="M"),
+            Period("2013-02-28", freq="M"),
+            Period("2013-03-31", freq="M"),
+            Period("2013-04-30", freq="M"),
         ]
-        expected = pd.Index(expected_list, dtype=object, name="idx")
+        expected = Index(expected_list, dtype=object, name="idx")
         result = idx.astype(object)
         assert isinstance(result, Index)
         assert result.dtype == object
@@ -85,31 +95,31 @@ def test_astype_object2(self):
             ["2013-01-01", "2013-01-02", "NaT", "2013-01-04"], freq="D", name="idx"
         )
         expected_list = [
-            pd.Period("2013-01-01", freq="D"),
-            pd.Period("2013-01-02", freq="D"),
-            pd.Period("NaT", freq="D"),
-            pd.Period("2013-01-04", freq="D"),
+            Period("2013-01-01", freq="D"),
+            Period("2013-01-02", freq="D"),
+            Period("NaT", freq="D"),
+            Period("2013-01-04", freq="D"),
         ]
-        expected = pd.Index(expected_list, dtype=object, name="idx")
+        expected = Index(expected_list, dtype=object, name="idx")
         result = idx.astype(object)
         assert isinstance(result, Index)
         assert result.dtype == object
         tm.assert_index_equal(result, expected)
         for i in [0, 1, 3]:
             assert result[i] == expected[i]
-        assert result[2] is pd.NaT
+        assert result[2] is NaT
         assert result.name == expected.name
 
         result_list = idx.tolist()
         for i in [0, 1, 3]:
             assert result_list[i] == expected_list[i]
-        assert result_list[2] is pd.NaT
+        assert result_list[2] is NaT
 
     def test_astype_category(self):
-        obj = pd.period_range("2000", periods=2)
+        obj = period_range("2000", periods=2)
         result = obj.astype("category")
-        expected = pd.CategoricalIndex(
-            [pd.Period("2000-01-01", freq="D"), pd.Period("2000-01-02", freq="D")]
+        expected = CategoricalIndex(
+            [Period("2000-01-01", freq="D"), Period("2000-01-02", freq="D")]
         )
         tm.assert_index_equal(result, expected)
 
@@ -118,11 +128,30 @@ def test_astype_category(self):
         tm.assert_categorical_equal(result, expected)
 
     def test_astype_array_fallback(self):
-        obj = pd.period_range("2000", periods=2)
+        obj = period_range("2000", periods=2)
         result = obj.astype(bool)
-        expected = pd.Index(np.array([True, True]))
+        expected = Index(np.array([True, True]))
         tm.assert_index_equal(result, expected)
 
         result = obj._data.astype(bool)
         expected = np.array([True, True])
         tm.assert_numpy_array_equal(result, expected)
+
+    def test_period_astype_to_timestamp(self):
+        pi = PeriodIndex(["2011-01", "2011-02", "2011-03"], freq="M")
+
+        exp = DatetimeIndex(["2011-01-01", "2011-02-01", "2011-03-01"])
+        tm.assert_index_equal(pi.astype("datetime64[ns]"), exp)
+
+        exp = DatetimeIndex(["2011-01-31", "2011-02-28", "2011-03-31"])
+        exp = exp + Timedelta(1, "D") - Timedelta(1, "ns")
+        tm.assert_index_equal(pi.astype("datetime64[ns]", how="end"), exp)
+
+        exp = DatetimeIndex(["2011-01-01", "2011-02-01", "2011-03-01"], tz="US/Eastern")
+        res = pi.astype("datetime64[ns, US/Eastern]")
+        tm.assert_index_equal(pi.astype("datetime64[ns, US/Eastern]"), exp)
+
+        exp = DatetimeIndex(["2011-01-31", "2011-02-28", "2011-03-31"], tz="US/Eastern")
+        exp = exp + Timedelta(1, "D") - Timedelta(1, "ns")
+        res = pi.astype("datetime64[ns, US/Eastern]", how="end")
+        tm.assert_index_equal(res, exp)
diff --git a/pandas/tests/indexes/period/test_constructors.py b/pandas/tests/indexes/period/test_constructors.py
index dcd3c8e946e9a..fcbadce3d63b1 100644
--- a/pandas/tests/indexes/period/test_constructors.py
+++ b/pandas/tests/indexes/period/test_constructors.py
@@ -6,7 +6,16 @@
 from pandas.core.dtypes.dtypes import PeriodDtype
 
 import pandas as pd
-from pandas import Index, Period, PeriodIndex, Series, date_range, offsets, period_range
+from pandas import (
+    Index,
+    NaT,
+    Period,
+    PeriodIndex,
+    Series,
+    date_range,
+    offsets,
+    period_range,
+)
 import pandas._testing as tm
 from pandas.core.arrays import PeriodArray
 
@@ -14,27 +23,25 @@
 class TestPeriodIndex:
     def test_construction_base_constructor(self):
         # GH 13664
-        arr = [pd.Period("2011-01", freq="M"), pd.NaT, pd.Period("2011-03", freq="M")]
-        tm.assert_index_equal(pd.Index(arr), pd.PeriodIndex(arr))
-        tm.assert_index_equal(pd.Index(np.array(arr)), pd.PeriodIndex(np.array(arr)))
+        arr = [Period("2011-01", freq="M"), NaT, Period("2011-03", freq="M")]
+        tm.assert_index_equal(Index(arr), PeriodIndex(arr))
+        tm.assert_index_equal(Index(np.array(arr)), PeriodIndex(np.array(arr)))
 
-        arr = [np.nan, pd.NaT, pd.Period("2011-03", freq="M")]
-        tm.assert_index_equal(pd.Index(arr), pd.PeriodIndex(arr))
-        tm.assert_index_equal(pd.Index(np.array(arr)), pd.PeriodIndex(np.array(arr)))
+        arr = [np.nan, NaT, Period("2011-03", freq="M")]
+        tm.assert_index_equal(Index(arr), PeriodIndex(arr))
+        tm.assert_index_equal(Index(np.array(arr)), PeriodIndex(np.array(arr)))
 
-        arr = [pd.Period("2011-01", freq="M"), pd.NaT, pd.Period("2011-03", freq="D")]
-        tm.assert_index_equal(pd.Index(arr), pd.Index(arr, dtype=object))
+        arr = [Period("2011-01", freq="M"), NaT, Period("2011-03", freq="D")]
+        tm.assert_index_equal(Index(arr), Index(arr, dtype=object))
 
-        tm.assert_index_equal(
-            pd.Index(np.array(arr)), pd.Index(np.array(arr), dtype=object)
-        )
+        tm.assert_index_equal(Index(np.array(arr)), Index(np.array(arr), dtype=object))
 
     def test_base_constructor_with_period_dtype(self):
         dtype = PeriodDtype("D")
         values = ["2011-01-01", "2012-03-04", "2014-05-01"]
-        result = pd.Index(values, dtype=dtype)
+        result = Index(values, dtype=dtype)
 
-        expected = pd.PeriodIndex(values, dtype=dtype)
+        expected = PeriodIndex(values, dtype=dtype)
         tm.assert_index_equal(result, expected)
 
     @pytest.mark.parametrize(
@@ -43,9 +50,9 @@ def test_base_constructor_with_period_dtype(self):
     def test_index_object_dtype(self, values_constructor):
         # Index(periods, dtype=object) is an Index (not an PeriodIndex)
         periods = [
-            pd.Period("2011-01", freq="M"),
-            pd.NaT,
-            pd.Period("2011-03", freq="M"),
+            Period("2011-01", freq="M"),
+            NaT,
+            Period("2011-03", freq="M"),
         ]
         values = values_constructor(periods)
         result = Index(values, dtype=object)
@@ -118,8 +125,8 @@ def test_constructor_arrays_negative_year(self):
 
         pindex = PeriodIndex(year=years, quarter=quarters)
 
-        tm.assert_index_equal(pindex.year, pd.Index(years))
-        tm.assert_index_equal(pindex.quarter, pd.Index(quarters))
+        tm.assert_index_equal(pindex.year, Index(years))
+        tm.assert_index_equal(pindex.quarter, Index(quarters))
 
     def test_constructor_invalid_quarters(self):
         msg = "Quarter must be 1 <= q <= 4"
@@ -184,7 +191,7 @@ def test_constructor_datetime64arr(self):
     @pytest.mark.parametrize("box", [None, "series", "index"])
     def test_constructor_datetime64arr_ok(self, box):
         # https://github.com/pandas-dev/pandas/issues/23438
-        data = pd.date_range("2017", periods=4, freq="M")
+        data = date_range("2017", periods=4, freq="M")
         if box is None:
             data = data._values
         elif box == "series":
@@ -226,52 +233,47 @@ def test_constructor_dtype(self):
             PeriodIndex(["2011-01"], freq="M", dtype="period[D]")
 
     def test_constructor_empty(self):
-        idx = pd.PeriodIndex([], freq="M")
+        idx = PeriodIndex([], freq="M")
         assert isinstance(idx, PeriodIndex)
         assert len(idx) == 0
         assert idx.freq == "M"
 
         with pytest.raises(ValueError, match="freq not specified"):
-            pd.PeriodIndex([])
+            PeriodIndex([])
 
     def test_constructor_pi_nat(self):
         idx = PeriodIndex(
-            [Period("2011-01", freq="M"), pd.NaT, Period("2011-01", freq="M")]
+            [Period("2011-01", freq="M"), NaT, Period("2011-01", freq="M")]
         )
         exp = PeriodIndex(["2011-01", "NaT", "2011-01"], freq="M")
         tm.assert_index_equal(idx, exp)
 
         idx = PeriodIndex(
-            np.array([Period("2011-01", freq="M"), pd.NaT, Period("2011-01", freq="M")])
+            np.array([Period("2011-01", freq="M"), NaT, Period("2011-01", freq="M")])
         )
         tm.assert_index_equal(idx, exp)
 
         idx = PeriodIndex(
-            [pd.NaT, pd.NaT, Period("2011-01", freq="M"), Period("2011-01", freq="M")]
+            [NaT, NaT, Period("2011-01", freq="M"), Period("2011-01", freq="M")]
         )
         exp = PeriodIndex(["NaT", "NaT", "2011-01", "2011-01"], freq="M")
         tm.assert_index_equal(idx, exp)
 
         idx = PeriodIndex(
             np.array(
-                [
-                    pd.NaT,
-                    pd.NaT,
-                    Period("2011-01", freq="M"),
-                    Period("2011-01", freq="M"),
-                ]
+                [NaT, NaT, Period("2011-01", freq="M"), Period("2011-01", freq="M")]
             )
         )
         tm.assert_index_equal(idx, exp)
 
-        idx = PeriodIndex([pd.NaT, pd.NaT, "2011-01", "2011-01"], freq="M")
+        idx = PeriodIndex([NaT, NaT, "2011-01", "2011-01"], freq="M")
         tm.assert_index_equal(idx, exp)
 
         with pytest.raises(ValueError, match="freq not specified"):
-            PeriodIndex([pd.NaT, pd.NaT])
+            PeriodIndex([NaT, NaT])
 
         with pytest.raises(ValueError, match="freq not specified"):
-            PeriodIndex(np.array([pd.NaT, pd.NaT]))
+            PeriodIndex(np.array([NaT, NaT]))
 
         with pytest.raises(ValueError, match="freq not specified"):
             PeriodIndex(["NaT", "NaT"])
@@ -283,40 +285,36 @@ def test_constructor_incompat_freq(self):
         msg = "Input has different freq=D from PeriodIndex\\(freq=M\\)"
 
         with pytest.raises(IncompatibleFrequency, match=msg):
-            PeriodIndex(
-                [Period("2011-01", freq="M"), pd.NaT, Period("2011-01", freq="D")]
-            )
+            PeriodIndex([Period("2011-01", freq="M"), NaT, Period("2011-01", freq="D")])
 
         with pytest.raises(IncompatibleFrequency, match=msg):
             PeriodIndex(
                 np.array(
-                    [Period("2011-01", freq="M"), pd.NaT, Period("2011-01", freq="D")]
+                    [Period("2011-01", freq="M"), NaT, Period("2011-01", freq="D")]
                 )
             )
 
-        # first element is pd.NaT
+        # first element is NaT
         with pytest.raises(IncompatibleFrequency, match=msg):
-            PeriodIndex(
-                [pd.NaT, Period("2011-01", freq="M"), Period("2011-01", freq="D")]
-            )
+            PeriodIndex([NaT, Period("2011-01", freq="M"), Period("2011-01", freq="D")])
 
         with pytest.raises(IncompatibleFrequency, match=msg):
             PeriodIndex(
                 np.array(
-                    [pd.NaT, Period("2011-01", freq="M"), Period("2011-01", freq="D")]
+                    [NaT, Period("2011-01", freq="M"), Period("2011-01", freq="D")]
                 )
             )
 
     def test_constructor_mixed(self):
-        idx = PeriodIndex(["2011-01", pd.NaT, Period("2011-01", freq="M")])
+        idx = PeriodIndex(["2011-01", NaT, Period("2011-01", freq="M")])
         exp = PeriodIndex(["2011-01", "NaT", "2011-01"], freq="M")
         tm.assert_index_equal(idx, exp)
 
-        idx = PeriodIndex(["NaT", pd.NaT, Period("2011-01", freq="M")])
+        idx = PeriodIndex(["NaT", NaT, Period("2011-01", freq="M")])
         exp = PeriodIndex(["NaT", "NaT", "2011-01"], freq="M")
         tm.assert_index_equal(idx, exp)
 
-        idx = PeriodIndex([Period("2011-01-01", freq="D"), pd.NaT, "2012-01-01"])
+        idx = PeriodIndex([Period("2011-01-01", freq="D"), NaT, "2012-01-01"])
         exp = PeriodIndex(["2011-01-01", "NaT", "2012-01-01"], freq="D")
         tm.assert_index_equal(idx, exp)
 
@@ -349,11 +347,11 @@ def test_constructor_simple_new_empty(self):
     @pytest.mark.parametrize("floats", [[1.1, 2.1], np.array([1.1, 2.1])])
     def test_constructor_floats(self, floats):
         with pytest.raises(AssertionError, match="<class "):
-            pd.PeriodIndex._simple_new(floats, freq="M")
+            PeriodIndex._simple_new(floats, freq="M")
 
         msg = "PeriodIndex does not allow floating point in construction"
         with pytest.raises(TypeError, match=msg):
-            pd.PeriodIndex(floats, freq="M")
+            PeriodIndex(floats, freq="M")
 
     def test_constructor_nat(self):
         msg = "start and end must not be NaT"
diff --git a/pandas/tests/indexes/period/test_indexing.py b/pandas/tests/indexes/period/test_indexing.py
index fffc4a7562306..077fa2a0b1c56 100644
--- a/pandas/tests/indexes/period/test_indexing.py
+++ b/pandas/tests/indexes/period/test_indexing.py
@@ -7,7 +7,17 @@
 from pandas._libs.tslibs import period as libperiod
 
 import pandas as pd
-from pandas import DatetimeIndex, Period, PeriodIndex, Series, notna, period_range
+from pandas import (
+    DatetimeIndex,
+    NaT,
+    Period,
+    PeriodIndex,
+    Series,
+    Timedelta,
+    date_range,
+    notna,
+    period_range,
+)
 import pandas._testing as tm
 from pandas.core.indexes.base import InvalidIndexError
 
@@ -22,23 +32,23 @@ def test_ellipsis(self):
         assert result is not idx
 
     def test_getitem(self):
-        idx1 = pd.period_range("2011-01-01", "2011-01-31", freq="D", name="idx")
+        idx1 = period_range("2011-01-01", "2011-01-31", freq="D", name="idx")
 
         for idx in [idx1]:
             result = idx[0]
-            assert result == pd.Period("2011-01-01", freq="D")
+            assert result == Period("2011-01-01", freq="D")
 
             result = idx[-1]
-            assert result == pd.Period("2011-01-31", freq="D")
+            assert result == Period("2011-01-31", freq="D")
 
             result = idx[0:5]
-            expected = pd.period_range("2011-01-01", "2011-01-05", freq="D", name="idx")
+            expected = period_range("2011-01-01", "2011-01-05", freq="D", name="idx")
             tm.assert_index_equal(result, expected)
             assert result.freq == expected.freq
             assert result.freq == "D"
 
             result = idx[0:10:2]
-            expected = pd.PeriodIndex(
+            expected = PeriodIndex(
                 ["2011-01-01", "2011-01-03", "2011-01-05", "2011-01-07", "2011-01-09"],
                 freq="D",
                 name="idx",
@@ -48,7 +58,7 @@ def test_getitem(self):
             assert result.freq == "D"
 
             result = idx[-20:-5:3]
-            expected = pd.PeriodIndex(
+            expected = PeriodIndex(
                 ["2011-01-12", "2011-01-15", "2011-01-18", "2011-01-21", "2011-01-24"],
                 freq="D",
                 name="idx",
@@ -71,11 +81,11 @@ def test_getitem_index(self):
         idx = period_range("2007-01", periods=10, freq="M", name="x")
 
         result = idx[[1, 3, 5]]
-        exp = pd.PeriodIndex(["2007-02", "2007-04", "2007-06"], freq="M", name="x")
+        exp = PeriodIndex(["2007-02", "2007-04", "2007-06"], freq="M", name="x")
         tm.assert_index_equal(result, exp)
 
         result = idx[[True, True, False, False, False, True, True, False, False, False]]
-        exp = pd.PeriodIndex(
+        exp = PeriodIndex(
             ["2007-01", "2007-02", "2007-06", "2007-07"], freq="M", name="x"
         )
         tm.assert_index_equal(result, exp)
@@ -125,16 +135,16 @@ def test_getitem_datetime(self):
         tm.assert_series_equal(rs, ts)
 
     def test_getitem_nat(self):
-        idx = pd.PeriodIndex(["2011-01", "NaT", "2011-02"], freq="M")
-        assert idx[0] == pd.Period("2011-01", freq="M")
-        assert idx[1] is pd.NaT
+        idx = PeriodIndex(["2011-01", "NaT", "2011-02"], freq="M")
+        assert idx[0] == Period("2011-01", freq="M")
+        assert idx[1] is NaT
 
         s = pd.Series([0, 1, 2], index=idx)
-        assert s[pd.NaT] == 1
+        assert s[NaT] == 1
 
         s = pd.Series(idx, index=idx)
-        assert s[pd.Period("2011-01", freq="M")] == pd.Period("2011-01", freq="M")
-        assert s[pd.NaT] is pd.NaT
+        assert s[Period("2011-01", freq="M")] == Period("2011-01", freq="M")
+        assert s[NaT] is NaT
 
     def test_getitem_list_periods(self):
         # GH 7710
@@ -145,7 +155,7 @@ def test_getitem_list_periods(self):
 
     def test_getitem_seconds(self):
         # GH#6716
-        didx = pd.date_range(start="2013/01/01 09:00:00", freq="S", periods=4000)
+        didx = date_range(start="2013/01/01 09:00:00", freq="S", periods=4000)
         pidx = period_range(start="2013/01/01 09:00:00", freq="S", periods=4000)
 
         for idx in [didx, pidx]:
@@ -174,7 +184,7 @@ def test_getitem_seconds(self):
     def test_getitem_day(self):
         # GH#6716
         # Confirm DatetimeIndex and PeriodIndex works identically
-        didx = pd.date_range(start="2013/01/01", freq="D", periods=400)
+        didx = date_range(start="2013/01/01", freq="D", periods=400)
         pidx = period_range(start="2013/01/01", freq="D", periods=400)
 
         for idx in [didx, pidx]:
@@ -216,24 +226,24 @@ def test_where(self, klass):
         tm.assert_index_equal(result, expected)
 
         cond = [False] + [True] * (len(i) - 1)
-        expected = PeriodIndex([pd.NaT] + i[1:].tolist(), freq="D")
+        expected = PeriodIndex([NaT] + i[1:].tolist(), freq="D")
         result = i.where(klass(cond))
         tm.assert_index_equal(result, expected)
 
     def test_where_other(self):
         i = period_range("20130101", periods=5, freq="D")
-        for arr in [np.nan, pd.NaT]:
+        for arr in [np.nan, NaT]:
             result = i.where(notna(i), other=np.nan)
             expected = i
             tm.assert_index_equal(result, expected)
 
         i2 = i.copy()
-        i2 = pd.PeriodIndex([pd.NaT, pd.NaT] + i[2:].tolist(), freq="D")
+        i2 = PeriodIndex([NaT, NaT] + i[2:].tolist(), freq="D")
         result = i.where(notna(i2), i2)
         tm.assert_index_equal(result, i2)
 
         i2 = i.copy()
-        i2 = pd.PeriodIndex([pd.NaT, pd.NaT] + i[2:].tolist(), freq="D")
+        i2 = PeriodIndex([NaT, NaT] + i[2:].tolist(), freq="D")
         result = i.where(notna(i2), i2.values)
         tm.assert_index_equal(result, i2)
 
@@ -241,7 +251,7 @@ def test_where_invalid_dtypes(self):
         pi = period_range("20130101", periods=5, freq="D")
 
         i2 = pi.copy()
-        i2 = pd.PeriodIndex([pd.NaT, pd.NaT] + pi[2:].tolist(), freq="D")
+        i2 = PeriodIndex([NaT, NaT] + pi[2:].tolist(), freq="D")
 
         with pytest.raises(TypeError, match="Where requires matching dtype"):
             pi.where(notna(i2), i2.asi8)
@@ -256,23 +266,23 @@ def test_where_invalid_dtypes(self):
 class TestTake:
     def test_take(self):
         # GH#10295
-        idx1 = pd.period_range("2011-01-01", "2011-01-31", freq="D", name="idx")
+        idx1 = period_range("2011-01-01", "2011-01-31", freq="D", name="idx")
 
         for idx in [idx1]:
             result = idx.take([0])
-            assert result == pd.Period("2011-01-01", freq="D")
+            assert result == Period("2011-01-01", freq="D")
 
             result = idx.take([5])
-            assert result == pd.Period("2011-01-06", freq="D")
+            assert result == Period("2011-01-06", freq="D")
 
             result = idx.take([0, 1, 2])
-            expected = pd.period_range("2011-01-01", "2011-01-03", freq="D", name="idx")
+            expected = period_range("2011-01-01", "2011-01-03", freq="D", name="idx")
             tm.assert_index_equal(result, expected)
             assert result.freq == "D"
             assert result.freq == expected.freq
 
             result = idx.take([0, 2, 4])
-            expected = pd.PeriodIndex(
+            expected = PeriodIndex(
                 ["2011-01-01", "2011-01-03", "2011-01-05"], freq="D", name="idx"
             )
             tm.assert_index_equal(result, expected)
@@ -280,7 +290,7 @@ def test_take(self):
             assert result.freq == "D"
 
             result = idx.take([7, 4, 1])
-            expected = pd.PeriodIndex(
+            expected = PeriodIndex(
                 ["2011-01-08", "2011-01-05", "2011-01-02"], freq="D", name="idx"
             )
             tm.assert_index_equal(result, expected)
@@ -327,25 +337,25 @@ def test_take_misc(self):
 
     def test_take_fill_value(self):
         # GH#12631
-        idx = pd.PeriodIndex(
+        idx = PeriodIndex(
             ["2011-01-01", "2011-02-01", "2011-03-01"], name="xxx", freq="D"
         )
         result = idx.take(np.array([1, 0, -1]))
-        expected = pd.PeriodIndex(
+        expected = PeriodIndex(
             ["2011-02-01", "2011-01-01", "2011-03-01"], name="xxx", freq="D"
         )
         tm.assert_index_equal(result, expected)
 
         # fill_value
         result = idx.take(np.array([1, 0, -1]), fill_value=True)
-        expected = pd.PeriodIndex(
+        expected = PeriodIndex(
             ["2011-02-01", "2011-01-01", "NaT"], name="xxx", freq="D"
         )
         tm.assert_index_equal(result, expected)
 
         # allow_fill=False
         result = idx.take(np.array([1, 0, -1]), allow_fill=False, fill_value=True)
-        expected = pd.PeriodIndex(
+        expected = PeriodIndex(
             ["2011-02-01", "2011-01-01", "2011-03-01"], name="xxx", freq="D"
         )
         tm.assert_index_equal(result, expected)
@@ -382,20 +392,20 @@ def test_get_loc_nat(self):
 
         # check DatetimeIndex compat
         for idx in [didx, pidx]:
-            assert idx.get_loc(pd.NaT) == 1
+            assert idx.get_loc(NaT) == 1
             assert idx.get_loc(None) == 1
             assert idx.get_loc(float("nan")) == 1
             assert idx.get_loc(np.nan) == 1
 
     def test_get_loc(self):
         # GH 17717
-        p0 = pd.Period("2017-09-01")
-        p1 = pd.Period("2017-09-02")
-        p2 = pd.Period("2017-09-03")
+        p0 = Period("2017-09-01")
+        p1 = Period("2017-09-02")
+        p2 = Period("2017-09-03")
 
         # get the location of p1/p2 from
         # monotonic increasing PeriodIndex with non-duplicate
-        idx0 = pd.PeriodIndex([p0, p1, p2])
+        idx0 = PeriodIndex([p0, p1, p2])
         expected_idx1_p1 = 1
         expected_idx1_p2 = 2
 
@@ -415,7 +425,7 @@ def test_get_loc(self):
 
         # get the location of p1/p2 from
         # monotonic increasing PeriodIndex with duplicate
-        idx1 = pd.PeriodIndex([p1, p1, p2])
+        idx1 = PeriodIndex([p1, p1, p2])
         expected_idx1_p1 = slice(0, 2)
         expected_idx1_p2 = 2
 
@@ -436,7 +446,7 @@ def test_get_loc(self):
 
         # get the location of p1/p2 from
         # non-monotonic increasing/decreasing PeriodIndex with duplicate
-        idx2 = pd.PeriodIndex([p2, p1, p2])
+        idx2 = PeriodIndex([p2, p1, p2])
         expected_idx2_p1 = 1
         expected_idx2_p2 = np.array([True, False, True])
 
@@ -446,7 +456,7 @@ def test_get_loc(self):
         tm.assert_numpy_array_equal(idx2.get_loc(str(p2)), expected_idx2_p2)
 
     def test_get_loc_integer(self):
-        dti = pd.date_range("2016-01-01", periods=3)
+        dti = date_range("2016-01-01", periods=3)
         pi = dti.to_period("D")
         with pytest.raises(KeyError, match="16801"):
             pi.get_loc(16801)
@@ -458,7 +468,7 @@ def test_get_loc_integer(self):
     @pytest.mark.parametrize("freq", ["H", "D"])
     def test_get_value_datetime_hourly(self, freq):
         # get_loc and get_value should treat datetime objects symmetrically
-        dti = pd.date_range("2016-01-01", periods=3, freq="MS")
+        dti = date_range("2016-01-01", periods=3, freq="MS")
         pi = dti.to_period(freq)
         ser = pd.Series(range(7, 10), index=pi)
 
@@ -469,7 +479,7 @@ def test_get_value_datetime_hourly(self, freq):
         assert ser[ts] == 7
         assert ser.loc[ts] == 7
 
-        ts2 = ts + pd.Timedelta(hours=3)
+        ts2 = ts + Timedelta(hours=3)
         if freq == "H":
             with pytest.raises(KeyError, match="2016-01-01 03:00"):
                 pi.get_loc(ts2)
@@ -487,7 +497,7 @@ def test_get_value_datetime_hourly(self, freq):
 
     def test_get_value_integer(self):
         msg = "index 16801 is out of bounds for axis 0 with size 3"
-        dti = pd.date_range("2016-01-01", periods=3)
+        dti = date_range("2016-01-01", periods=3)
         pi = dti.to_period("D")
         ser = pd.Series(range(3), index=pi)
         with pytest.raises(IndexError, match=msg):
@@ -501,15 +511,15 @@ def test_get_value_integer(self):
 
     def test_is_monotonic_increasing(self):
         # GH 17717
-        p0 = pd.Period("2017-09-01")
-        p1 = pd.Period("2017-09-02")
-        p2 = pd.Period("2017-09-03")
+        p0 = Period("2017-09-01")
+        p1 = Period("2017-09-02")
+        p2 = Period("2017-09-03")
 
-        idx_inc0 = pd.PeriodIndex([p0, p1, p2])
-        idx_inc1 = pd.PeriodIndex([p0, p1, p1])
-        idx_dec0 = pd.PeriodIndex([p2, p1, p0])
-        idx_dec1 = pd.PeriodIndex([p2, p1, p1])
-        idx = pd.PeriodIndex([p1, p2, p0])
+        idx_inc0 = PeriodIndex([p0, p1, p2])
+        idx_inc1 = PeriodIndex([p0, p1, p1])
+        idx_dec0 = PeriodIndex([p2, p1, p0])
+        idx_dec1 = PeriodIndex([p2, p1, p1])
+        idx = PeriodIndex([p1, p2, p0])
 
         assert idx_inc0.is_monotonic_increasing is True
         assert idx_inc1.is_monotonic_increasing is True
@@ -519,15 +529,15 @@ def test_is_monotonic_increasing(self):
 
     def test_is_monotonic_decreasing(self):
         # GH 17717
-        p0 = pd.Period("2017-09-01")
-        p1 = pd.Period("2017-09-02")
-        p2 = pd.Period("2017-09-03")
+        p0 = Period("2017-09-01")
+        p1 = Period("2017-09-02")
+        p2 = Period("2017-09-03")
 
-        idx_inc0 = pd.PeriodIndex([p0, p1, p2])
-        idx_inc1 = pd.PeriodIndex([p0, p1, p1])
-        idx_dec0 = pd.PeriodIndex([p2, p1, p0])
-        idx_dec1 = pd.PeriodIndex([p2, p1, p1])
-        idx = pd.PeriodIndex([p1, p2, p0])
+        idx_inc0 = PeriodIndex([p0, p1, p2])
+        idx_inc1 = PeriodIndex([p0, p1, p1])
+        idx_dec0 = PeriodIndex([p2, p1, p0])
+        idx_dec1 = PeriodIndex([p2, p1, p1])
+        idx = PeriodIndex([p1, p2, p0])
 
         assert idx_inc0.is_monotonic_decreasing is False
         assert idx_inc1.is_monotonic_decreasing is False
@@ -537,13 +547,13 @@ def test_is_monotonic_decreasing(self):
 
     def test_contains(self):
         # GH 17717
-        p0 = pd.Period("2017-09-01")
-        p1 = pd.Period("2017-09-02")
-        p2 = pd.Period("2017-09-03")
-        p3 = pd.Period("2017-09-04")
+        p0 = Period("2017-09-01")
+        p1 = Period("2017-09-02")
+        p2 = Period("2017-09-03")
+        p3 = Period("2017-09-04")
 
         ps0 = [p0, p1, p2]
-        idx0 = pd.PeriodIndex(ps0)
+        idx0 = PeriodIndex(ps0)
         ser = pd.Series(range(6, 9), index=idx0)
 
         for p in ps0:
@@ -565,25 +575,25 @@ def test_contains(self):
 
     def test_get_value(self):
         # GH 17717
-        p0 = pd.Period("2017-09-01")
-        p1 = pd.Period("2017-09-02")
-        p2 = pd.Period("2017-09-03")
+        p0 = Period("2017-09-01")
+        p1 = Period("2017-09-02")
+        p2 = Period("2017-09-03")
 
-        idx0 = pd.PeriodIndex([p0, p1, p2])
+        idx0 = PeriodIndex([p0, p1, p2])
         input0 = pd.Series(np.array([1, 2, 3]), index=idx0)
         expected0 = 2
 
         result0 = idx0.get_value(input0, p1)
         assert result0 == expected0
 
-        idx1 = pd.PeriodIndex([p1, p1, p2])
+        idx1 = PeriodIndex([p1, p1, p2])
         input1 = pd.Series(np.array([1, 2, 3]), index=idx1)
         expected1 = input1.iloc[[0, 1]]
 
         result1 = idx1.get_value(input1, p1)
         tm.assert_series_equal(result1, expected1)
 
-        idx2 = pd.PeriodIndex([p1, p2, p1])
+        idx2 = PeriodIndex([p1, p2, p1])
         input2 = pd.Series(np.array([1, 2, 3]), index=idx2)
         expected2 = input2.iloc[[0, 2]]
 
@@ -592,22 +602,22 @@ def test_get_value(self):
 
     def test_get_indexer(self):
         # GH 17717
-        p1 = pd.Period("2017-09-01")
-        p2 = pd.Period("2017-09-04")
-        p3 = pd.Period("2017-09-07")
+        p1 = Period("2017-09-01")
+        p2 = Period("2017-09-04")
+        p3 = Period("2017-09-07")
 
-        tp0 = pd.Period("2017-08-31")
-        tp1 = pd.Period("2017-09-02")
-        tp2 = pd.Period("2017-09-05")
-        tp3 = pd.Period("2017-09-09")
+        tp0 = Period("2017-08-31")
+        tp1 = Period("2017-09-02")
+        tp2 = Period("2017-09-05")
+        tp3 = Period("2017-09-09")
 
-        idx = pd.PeriodIndex([p1, p2, p3])
+        idx = PeriodIndex([p1, p2, p3])
 
         tm.assert_numpy_array_equal(
             idx.get_indexer(idx), np.array([0, 1, 2], dtype=np.intp)
         )
 
-        target = pd.PeriodIndex([tp0, tp1, tp2, tp3])
+        target = PeriodIndex([tp0, tp1, tp2, tp3])
         tm.assert_numpy_array_equal(
             idx.get_indexer(target, "pad"), np.array([-1, 0, 1, 2], dtype=np.intp)
         )
@@ -618,13 +628,13 @@ def test_get_indexer(self):
             idx.get_indexer(target, "nearest"), np.array([0, 0, 1, 2], dtype=np.intp)
         )
 
-        res = idx.get_indexer(target, "nearest", tolerance=pd.Timedelta("1 day"))
+        res = idx.get_indexer(target, "nearest", tolerance=Timedelta("1 day"))
         tm.assert_numpy_array_equal(res, np.array([0, 0, 1, -1], dtype=np.intp))
 
     def test_get_indexer_mismatched_dtype(self):
         # Check that we return all -1s and do not raise or cast incorrectly
 
-        dti = pd.date_range("2016-01-01", periods=3)
+        dti = date_range("2016-01-01", periods=3)
         pi = dti.to_period("D")
         pi2 = dti.to_period("W")
 
@@ -652,13 +662,13 @@ def test_get_indexer_mismatched_dtype(self):
 
     def test_get_indexer_non_unique(self):
         # GH 17717
-        p1 = pd.Period("2017-09-02")
-        p2 = pd.Period("2017-09-03")
-        p3 = pd.Period("2017-09-04")
-        p4 = pd.Period("2017-09-05")
+        p1 = Period("2017-09-02")
+        p2 = Period("2017-09-03")
+        p3 = Period("2017-09-04")
+        p4 = Period("2017-09-05")
 
-        idx1 = pd.PeriodIndex([p1, p2, p1])
-        idx2 = pd.PeriodIndex([p2, p1, p3, p4])
+        idx1 = PeriodIndex([p1, p2, p1])
+        idx2 = PeriodIndex([p2, p1, p3, p4])
 
         result = idx1.get_indexer_non_unique(idx2)
         expected_indexer = np.array([1, 0, 2, -1, -1], dtype=np.intp)
@@ -669,7 +679,7 @@ def test_get_indexer_non_unique(self):
 
     # TODO: This method came from test_period; de-dup with version above
     def test_get_loc2(self):
-        idx = pd.period_range("2000-01-01", periods=3)
+        idx = period_range("2000-01-01", periods=3)
 
         for method in [None, "pad", "backfill", "nearest"]:
             assert idx.get_loc(idx[1], method) == 1
@@ -678,10 +688,10 @@ def test_get_loc2(self):
             assert idx.get_loc(idx[1].to_timestamp().to_pydatetime(), method) == 1
             assert idx.get_loc(str(idx[1]), method) == 1
 
-        idx = pd.period_range("2000-01-01", periods=5)[::2]
+        idx = period_range("2000-01-01", periods=5)[::2]
         assert idx.get_loc("2000-01-02T12", method="nearest", tolerance="1 day") == 1
         assert (
-            idx.get_loc("2000-01-02T12", method="nearest", tolerance=pd.Timedelta("1D"))
+            idx.get_loc("2000-01-02T12", method="nearest", tolerance=Timedelta("1D"))
             == 1
         )
         assert (
@@ -710,19 +720,19 @@ def test_get_loc2(self):
                 "2000-01-10",
                 method="nearest",
                 tolerance=[
-                    pd.Timedelta("1 day").to_timedelta64(),
-                    pd.Timedelta("1 day").to_timedelta64(),
+                    Timedelta("1 day").to_timedelta64(),
+                    Timedelta("1 day").to_timedelta64(),
                 ],
             )
 
     # TODO: This method came from test_period; de-dup with version above
     def test_get_indexer2(self):
-        idx = pd.period_range("2000-01-01", periods=3).asfreq("H", how="start")
+        idx = period_range("2000-01-01", periods=3).asfreq("H", how="start")
         tm.assert_numpy_array_equal(
             idx.get_indexer(idx), np.array([0, 1, 2], dtype=np.intp)
         )
 
-        target = pd.PeriodIndex(
+        target = PeriodIndex(
             ["1999-12-31T23", "2000-01-01T12", "2000-01-02T01"], freq="H"
         )
         tm.assert_numpy_array_equal(
@@ -748,8 +758,8 @@ def test_get_indexer2(self):
             np.array([0, 1, 1], dtype=np.intp),
         )
         tol_raw = [
-            pd.Timedelta("1 hour"),
-            pd.Timedelta("1 hour"),
+            Timedelta("1 hour"),
+            Timedelta("1 hour"),
             np.timedelta64(1, "D"),
         ]
         tm.assert_numpy_array_equal(
@@ -759,8 +769,8 @@ def test_get_indexer2(self):
             np.array([0, -1, 1], dtype=np.intp),
         )
         tol_bad = [
-            pd.Timedelta("2 hour").to_timedelta64(),
-            pd.Timedelta("1 hour").to_timedelta64(),
+            Timedelta("2 hour").to_timedelta64(),
+            Timedelta("1 hour").to_timedelta64(),
             np.timedelta64(1, "M"),
         ]
         with pytest.raises(
@@ -778,7 +788,7 @@ def test_indexing(self):
 
     def test_period_index_indexer(self):
         # GH4125
-        idx = pd.period_range("2002-01", "2003-12", freq="M")
+        idx = period_range("2002-01", "2003-12", freq="M")
         df = pd.DataFrame(np.random.randn(24, 10), index=idx)
         tm.assert_frame_equal(df, df.loc[idx])
         tm.assert_frame_equal(df, df.loc[list(idx)])
diff --git a/pandas/tests/indexes/period/test_ops.py b/pandas/tests/indexes/period/test_ops.py
index 2e4bed598b807..196946e696c8d 100644
--- a/pandas/tests/indexes/period/test_ops.py
+++ b/pandas/tests/indexes/period/test_ops.py
@@ -266,10 +266,6 @@ def test_order(self):
             tm.assert_numpy_array_equal(indexer, exp, check_dtype=False)
             assert ordered.freq == "D"
 
-    def test_shift(self):
-        # This is tested in test_arithmetic
-        pass
-
     def test_nat(self):
         assert pd.PeriodIndex._na_value is NaT
         assert pd.PeriodIndex([], freq="M")._na_value is NaT
diff --git a/pandas/tests/indexes/period/test_period.py b/pandas/tests/indexes/period/test_period.py
index 248df3291f040..4db93e850f579 100644
--- a/pandas/tests/indexes/period/test_period.py
+++ b/pandas/tests/indexes/period/test_period.py
@@ -55,9 +55,9 @@ def test_where(self):
     @pytest.mark.parametrize(
         "index",
         [
-            pd.period_range("2000-01-01", periods=3, freq="D"),
-            pd.period_range("2001-01-01", periods=3, freq="2D"),
-            pd.PeriodIndex(["2001-01", "NaT", "2003-01"], freq="M"),
+            period_range("2000-01-01", periods=3, freq="D"),
+            period_range("2001-01-01", periods=3, freq="2D"),
+            PeriodIndex(["2001-01", "NaT", "2003-01"], freq="M"),
         ],
     )
     def test_repeat_freqstr(self, index, use_numpy):
@@ -69,32 +69,32 @@ def test_repeat_freqstr(self, index, use_numpy):
 
     def test_fillna_period(self):
         # GH 11343
-        idx = pd.PeriodIndex(["2011-01-01 09:00", pd.NaT, "2011-01-01 11:00"], freq="H")
+        idx = PeriodIndex(["2011-01-01 09:00", NaT, "2011-01-01 11:00"], freq="H")
 
-        exp = pd.PeriodIndex(
+        exp = PeriodIndex(
             ["2011-01-01 09:00", "2011-01-01 10:00", "2011-01-01 11:00"], freq="H"
         )
-        tm.assert_index_equal(idx.fillna(pd.Period("2011-01-01 10:00", freq="H")), exp)
+        tm.assert_index_equal(idx.fillna(Period("2011-01-01 10:00", freq="H")), exp)
 
-        exp = pd.Index(
+        exp = Index(
             [
-                pd.Period("2011-01-01 09:00", freq="H"),
+                Period("2011-01-01 09:00", freq="H"),
                 "x",
-                pd.Period("2011-01-01 11:00", freq="H"),
+                Period("2011-01-01 11:00", freq="H"),
             ],
             dtype=object,
         )
         tm.assert_index_equal(idx.fillna("x"), exp)
 
-        exp = pd.Index(
+        exp = Index(
             [
-                pd.Period("2011-01-01 09:00", freq="H"),
-                pd.Period("2011-01-01", freq="D"),
-                pd.Period("2011-01-01 11:00", freq="H"),
+                Period("2011-01-01 09:00", freq="H"),
+                Period("2011-01-01", freq="D"),
+                Period("2011-01-01 11:00", freq="H"),
             ],
             dtype=object,
         )
-        tm.assert_index_equal(idx.fillna(pd.Period("2011-01-01", freq="D")), exp)
+        tm.assert_index_equal(idx.fillna(Period("2011-01-01", freq="D")), exp)
 
     def test_no_millisecond_field(self):
         msg = "type object 'DatetimeIndex' has no attribute 'millisecond'"
@@ -138,25 +138,25 @@ def test_shallow_copy_changing_freq_raises(self):
             pi._shallow_copy(pi, freq="H")
 
     def test_view_asi8(self):
-        idx = pd.PeriodIndex([], freq="M")
+        idx = PeriodIndex([], freq="M")
 
         exp = np.array([], dtype=np.int64)
         tm.assert_numpy_array_equal(idx.view("i8"), exp)
         tm.assert_numpy_array_equal(idx.asi8, exp)
 
-        idx = pd.PeriodIndex(["2011-01", pd.NaT], freq="M")
+        idx = PeriodIndex(["2011-01", NaT], freq="M")
 
         exp = np.array([492, -9223372036854775808], dtype=np.int64)
         tm.assert_numpy_array_equal(idx.view("i8"), exp)
         tm.assert_numpy_array_equal(idx.asi8, exp)
 
         exp = np.array([14975, -9223372036854775808], dtype=np.int64)
-        idx = pd.PeriodIndex(["2011-01-01", pd.NaT], freq="D")
+        idx = PeriodIndex(["2011-01-01", NaT], freq="D")
         tm.assert_numpy_array_equal(idx.view("i8"), exp)
         tm.assert_numpy_array_equal(idx.asi8, exp)
 
     def test_values(self):
-        idx = pd.PeriodIndex([], freq="M")
+        idx = PeriodIndex([], freq="M")
 
         exp = np.array([], dtype=np.object)
         tm.assert_numpy_array_equal(idx.values, exp)
@@ -165,17 +165,17 @@ def test_values(self):
         exp = np.array([], dtype=np.int64)
         tm.assert_numpy_array_equal(idx._ndarray_values, exp)
 
-        idx = pd.PeriodIndex(["2011-01", pd.NaT], freq="M")
+        idx = PeriodIndex(["2011-01", NaT], freq="M")
 
-        exp = np.array([pd.Period("2011-01", freq="M"), pd.NaT], dtype=object)
+        exp = np.array([Period("2011-01", freq="M"), NaT], dtype=object)
         tm.assert_numpy_array_equal(idx.values, exp)
         tm.assert_numpy_array_equal(idx.to_numpy(), exp)
         exp = np.array([492, -9223372036854775808], dtype=np.int64)
         tm.assert_numpy_array_equal(idx._ndarray_values, exp)
 
-        idx = pd.PeriodIndex(["2011-01-01", pd.NaT], freq="D")
+        idx = PeriodIndex(["2011-01-01", NaT], freq="D")
 
-        exp = np.array([pd.Period("2011-01-01", freq="D"), pd.NaT], dtype=object)
+        exp = np.array([Period("2011-01-01", freq="D"), NaT], dtype=object)
         tm.assert_numpy_array_equal(idx.values, exp)
         tm.assert_numpy_array_equal(idx.to_numpy(), exp)
         exp = np.array([14975, -9223372036854775808], dtype=np.int64)
@@ -371,7 +371,7 @@ def test_factorize(self):
         tm.assert_numpy_array_equal(arr, exp_arr)
         tm.assert_index_equal(idx, exp_idx)
 
-        idx2 = pd.PeriodIndex(
+        idx2 = PeriodIndex(
             ["2014-03", "2014-03", "2014-02", "2014-01", "2014-03", "2014-01"], freq="M"
         )
 
@@ -414,13 +414,13 @@ def test_contains(self):
     def test_contains_nat(self):
         # see gh-13582
         idx = period_range("2007-01", freq="M", periods=10)
-        assert pd.NaT not in idx
+        assert NaT not in idx
         assert None not in idx
         assert float("nan") not in idx
         assert np.nan not in idx
 
-        idx = pd.PeriodIndex(["2011-01", "NaT", "2011-02"], freq="M")
-        assert pd.NaT in idx
+        idx = PeriodIndex(["2011-01", "NaT", "2011-02"], freq="M")
+        assert NaT in idx
         assert None in idx
         assert float("nan") in idx
         assert np.nan in idx
@@ -433,19 +433,6 @@ def test_periods_number_check(self):
         with pytest.raises(ValueError, match=msg):
             period_range("2011-1-1", "2012-1-1", "B")
 
-    def test_start_time(self):
-        # GH 17157
-        index = period_range(freq="M", start="2016-01-01", end="2016-05-31")
-        expected_index = date_range("2016-01-01", end="2016-05-31", freq="MS")
-        tm.assert_index_equal(index.start_time, expected_index)
-
-    def test_end_time(self):
-        # GH 17157
-        index = period_range(freq="M", start="2016-01-01", end="2016-05-31")
-        expected_index = date_range("2016-01-01", end="2016-05-31", freq="M")
-        expected_index = expected_index.shift(1, freq="D").shift(-1, freq="ns")
-        tm.assert_index_equal(index.end_time, expected_index)
-
     def test_index_duplicate_periods(self):
         # monotonic
         idx = PeriodIndex([2000, 2007, 2007, 2009, 2009], freq="A-JUN")
@@ -565,7 +552,7 @@ def test_convert_array_of_periods(self):
         rng = period_range("1/1/2000", periods=20, freq="D")
         periods = list(rng)
 
-        result = pd.Index(periods)
+        result = Index(periods)
         assert isinstance(result, PeriodIndex)
 
     def test_append_concat(self):
@@ -606,10 +593,8 @@ def test_join_self(self, join_type):
 
     def test_insert(self):
         # GH 18295 (test missing)
-        expected = PeriodIndex(
-            ["2017Q1", pd.NaT, "2017Q2", "2017Q3", "2017Q4"], freq="Q"
-        )
-        for na in (np.nan, pd.NaT, None):
+        expected = PeriodIndex(["2017Q1", NaT, "2017Q2", "2017Q3", "2017Q4"], freq="Q")
+        for na in (np.nan, NaT, None):
             result = period_range("2017Q1", periods=4, freq="Q").insert(1, na)
             tm.assert_index_equal(result, expected)
 
@@ -668,36 +653,36 @@ def test_is_monotonic_with_nat():
     # GH#31437
     # PeriodIndex.is_monotonic should behave analogously to DatetimeIndex,
     #  in particular never be monotonic when we have NaT
-    dti = pd.date_range("2016-01-01", periods=3)
+    dti = date_range("2016-01-01", periods=3)
     pi = dti.to_period("D")
-    tdi = pd.Index(dti.view("timedelta64[ns]"))
+    tdi = Index(dti.view("timedelta64[ns]"))
 
     for obj in [pi, pi._engine, dti, dti._engine, tdi, tdi._engine]:
-        if isinstance(obj, pd.Index):
+        if isinstance(obj, Index):
             # i.e. not Engines
             assert obj.is_monotonic
         assert obj.is_monotonic_increasing
         assert not obj.is_monotonic_decreasing
         assert obj.is_unique
 
-    dti1 = dti.insert(0, pd.NaT)
+    dti1 = dti.insert(0, NaT)
     pi1 = dti1.to_period("D")
-    tdi1 = pd.Index(dti1.view("timedelta64[ns]"))
+    tdi1 = Index(dti1.view("timedelta64[ns]"))
 
     for obj in [pi1, pi1._engine, dti1, dti1._engine, tdi1, tdi1._engine]:
-        if isinstance(obj, pd.Index):
+        if isinstance(obj, Index):
             # i.e. not Engines
             assert not obj.is_monotonic
         assert not obj.is_monotonic_increasing
         assert not obj.is_monotonic_decreasing
         assert obj.is_unique
 
-    dti2 = dti.insert(3, pd.NaT)
+    dti2 = dti.insert(3, NaT)
     pi2 = dti2.to_period("H")
-    tdi2 = pd.Index(dti2.view("timedelta64[ns]"))
+    tdi2 = Index(dti2.view("timedelta64[ns]"))
 
     for obj in [pi2, pi2._engine, dti2, dti2._engine, tdi2, tdi2._engine]:
-        if isinstance(obj, pd.Index):
+        if isinstance(obj, Index):
             # i.e. not Engines
             assert not obj.is_monotonic
         assert not obj.is_monotonic_increasing
diff --git a/pandas/tests/indexes/period/test_scalar_compat.py b/pandas/tests/indexes/period/test_scalar_compat.py
index d9809f0f75611..0f92b7a4e168b 100644
--- a/pandas/tests/indexes/period/test_scalar_compat.py
+++ b/pandas/tests/indexes/period/test_scalar_compat.py
@@ -6,11 +6,13 @@
 
 class TestPeriodIndexOps:
     def test_start_time(self):
+        # GH#17157
         index = period_range(freq="M", start="2016-01-01", end="2016-05-31")
         expected_index = date_range("2016-01-01", end="2016-05-31", freq="MS")
         tm.assert_index_equal(index.start_time, expected_index)
 
     def test_end_time(self):
+        # GH#17157
         index = period_range(freq="M", start="2016-01-01", end="2016-05-31")
         expected_index = date_range("2016-01-01", end="2016-05-31", freq="M")
         expected_index += Timedelta(1, "D") - Timedelta(1, "ns")
diff --git a/pandas/tests/indexes/period/test_setops.py b/pandas/tests/indexes/period/test_setops.py
index dc7805880784f..6f254b7b4408d 100644
--- a/pandas/tests/indexes/period/test_setops.py
+++ b/pandas/tests/indexes/period/test_setops.py
@@ -44,9 +44,9 @@ def test_join_does_not_recur(self):
     @pytest.mark.parametrize("sort", [None, False])
     def test_union(self, sort):
         # union
-        other1 = pd.period_range("1/1/2000", freq="D", periods=5)
-        rng1 = pd.period_range("1/6/2000", freq="D", periods=5)
-        expected1 = pd.PeriodIndex(
+        other1 = period_range("1/1/2000", freq="D", periods=5)
+        rng1 = period_range("1/6/2000", freq="D", periods=5)
+        expected1 = PeriodIndex(
             [
                 "2000-01-06",
                 "2000-01-07",
@@ -62,17 +62,17 @@ def test_union(self, sort):
             freq="D",
         )
 
-        rng2 = pd.period_range("1/1/2000", freq="D", periods=5)
-        other2 = pd.period_range("1/4/2000", freq="D", periods=5)
-        expected2 = pd.period_range("1/1/2000", freq="D", periods=8)
+        rng2 = period_range("1/1/2000", freq="D", periods=5)
+        other2 = period_range("1/4/2000", freq="D", periods=5)
+        expected2 = period_range("1/1/2000", freq="D", periods=8)
 
-        rng3 = pd.period_range("1/1/2000", freq="D", periods=5)
-        other3 = pd.PeriodIndex([], freq="D")
-        expected3 = pd.period_range("1/1/2000", freq="D", periods=5)
+        rng3 = period_range("1/1/2000", freq="D", periods=5)
+        other3 = PeriodIndex([], freq="D")
+        expected3 = period_range("1/1/2000", freq="D", periods=5)
 
-        rng4 = pd.period_range("2000-01-01 09:00", freq="H", periods=5)
-        other4 = pd.period_range("2000-01-02 09:00", freq="H", periods=5)
-        expected4 = pd.PeriodIndex(
+        rng4 = period_range("2000-01-01 09:00", freq="H", periods=5)
+        other4 = period_range("2000-01-02 09:00", freq="H", periods=5)
+        expected4 = PeriodIndex(
             [
                 "2000-01-01 09:00",
                 "2000-01-01 10:00",
@@ -88,13 +88,13 @@ def test_union(self, sort):
             freq="H",
         )
 
-        rng5 = pd.PeriodIndex(
+        rng5 = PeriodIndex(
             ["2000-01-01 09:01", "2000-01-01 09:03", "2000-01-01 09:05"], freq="T"
         )
-        other5 = pd.PeriodIndex(
+        other5 = PeriodIndex(
             ["2000-01-01 09:01", "2000-01-01 09:05", "2000-01-01 09:08"], freq="T"
         )
-        expected5 = pd.PeriodIndex(
+        expected5 = PeriodIndex(
             [
                 "2000-01-01 09:01",
                 "2000-01-01 09:03",
@@ -104,13 +104,13 @@ def test_union(self, sort):
             freq="T",
         )
 
-        rng6 = pd.period_range("2000-01-01", freq="M", periods=7)
-        other6 = pd.period_range("2000-04-01", freq="M", periods=7)
-        expected6 = pd.period_range("2000-01-01", freq="M", periods=10)
+        rng6 = period_range("2000-01-01", freq="M", periods=7)
+        other6 = period_range("2000-04-01", freq="M", periods=7)
+        expected6 = period_range("2000-01-01", freq="M", periods=10)
 
-        rng7 = pd.period_range("2003-01-01", freq="A", periods=5)
-        other7 = pd.period_range("1998-01-01", freq="A", periods=8)
-        expected7 = pd.PeriodIndex(
+        rng7 = period_range("2003-01-01", freq="A", periods=5)
+        other7 = period_range("1998-01-01", freq="A", periods=8)
+        expected7 = PeriodIndex(
             [
                 "2003",
                 "2004",
@@ -126,11 +126,11 @@ def test_union(self, sort):
             freq="A",
         )
 
-        rng8 = pd.PeriodIndex(
+        rng8 = PeriodIndex(
             ["1/3/2000", "1/2/2000", "1/1/2000", "1/5/2000", "1/4/2000"], freq="D"
         )
-        other8 = pd.period_range("1/6/2000", freq="D", periods=5)
-        expected8 = pd.PeriodIndex(
+        other8 = period_range("1/6/2000", freq="D", periods=5)
+        expected8 = PeriodIndex(
             [
                 "1/3/2000",
                 "1/2/2000",
@@ -185,15 +185,16 @@ def test_union_misc(self, sort):
         with pytest.raises(IncompatibleFrequency):
             index.join(index3)
 
+    # TODO: belongs elsewhere
     def test_union_dataframe_index(self):
-        rng1 = pd.period_range("1/1/1999", "1/1/2012", freq="M")
+        rng1 = period_range("1/1/1999", "1/1/2012", freq="M")
         s1 = pd.Series(np.random.randn(len(rng1)), rng1)
 
-        rng2 = pd.period_range("1/1/1980", "12/1/2001", freq="M")
+        rng2 = period_range("1/1/1980", "12/1/2001", freq="M")
         s2 = pd.Series(np.random.randn(len(rng2)), rng2)
         df = pd.DataFrame({"s1": s1, "s2": s2})
 
-        exp = pd.period_range("1/1/1980", "1/1/2012", freq="M")
+        exp = period_range("1/1/1980", "1/1/2012", freq="M")
         tm.assert_index_equal(df.index, exp)
 
     @pytest.mark.parametrize("sort", [None, False])
@@ -294,16 +295,16 @@ def test_intersection_cases(self, sort):
     def test_difference(self, sort):
         # diff
         period_rng = ["1/3/2000", "1/2/2000", "1/1/2000", "1/5/2000", "1/4/2000"]
-        rng1 = pd.PeriodIndex(period_rng, freq="D")
-        other1 = pd.period_range("1/6/2000", freq="D", periods=5)
+        rng1 = PeriodIndex(period_rng, freq="D")
+        other1 = period_range("1/6/2000", freq="D", periods=5)
         expected1 = rng1
 
-        rng2 = pd.PeriodIndex(period_rng, freq="D")
-        other2 = pd.period_range("1/4/2000", freq="D", periods=5)
-        expected2 = pd.PeriodIndex(["1/3/2000", "1/2/2000", "1/1/2000"], freq="D")
+        rng2 = PeriodIndex(period_rng, freq="D")
+        other2 = period_range("1/4/2000", freq="D", periods=5)
+        expected2 = PeriodIndex(["1/3/2000", "1/2/2000", "1/1/2000"], freq="D")
 
-        rng3 = pd.PeriodIndex(period_rng, freq="D")
-        other3 = pd.PeriodIndex([], freq="D")
+        rng3 = PeriodIndex(period_rng, freq="D")
+        other3 = PeriodIndex([], freq="D")
         expected3 = rng3
 
         period_rng = [
@@ -313,15 +314,15 @@ def test_difference(self, sort):
             "2000-01-01 11:00",
             "2000-01-01 13:00",
         ]
-        rng4 = pd.PeriodIndex(period_rng, freq="H")
-        other4 = pd.period_range("2000-01-02 09:00", freq="H", periods=5)
+        rng4 = PeriodIndex(period_rng, freq="H")
+        other4 = period_range("2000-01-02 09:00", freq="H", periods=5)
         expected4 = rng4
 
-        rng5 = pd.PeriodIndex(
+        rng5 = PeriodIndex(
             ["2000-01-01 09:03", "2000-01-01 09:01", "2000-01-01 09:05"], freq="T"
         )
-        other5 = pd.PeriodIndex(["2000-01-01 09:01", "2000-01-01 09:05"], freq="T")
-        expected5 = pd.PeriodIndex(["2000-01-01 09:03"], freq="T")
+        other5 = PeriodIndex(["2000-01-01 09:01", "2000-01-01 09:05"], freq="T")
+        expected5 = PeriodIndex(["2000-01-01 09:03"], freq="T")
 
         period_rng = [
             "2000-02-01",
@@ -332,14 +333,14 @@ def test_difference(self, sort):
             "2000-03-01",
             "2000-04-01",
         ]
-        rng6 = pd.PeriodIndex(period_rng, freq="M")
-        other6 = pd.period_range("2000-04-01", freq="M", periods=7)
-        expected6 = pd.PeriodIndex(["2000-02-01", "2000-01-01", "2000-03-01"], freq="M")
+        rng6 = PeriodIndex(period_rng, freq="M")
+        other6 = period_range("2000-04-01", freq="M", periods=7)
+        expected6 = PeriodIndex(["2000-02-01", "2000-01-01", "2000-03-01"], freq="M")
 
         period_rng = ["2003", "2007", "2006", "2005", "2004"]
-        rng7 = pd.PeriodIndex(period_rng, freq="A")
-        other7 = pd.period_range("1998-01-01", freq="A", periods=8)
-        expected7 = pd.PeriodIndex(["2007", "2006"], freq="A")
+        rng7 = PeriodIndex(period_rng, freq="A")
+        other7 = period_range("1998-01-01", freq="A", periods=8)
+        expected7 = PeriodIndex(["2007", "2006"], freq="A")
 
         for rng, other, expected in [
             (rng1, other1, expected1),
diff --git a/pandas/tests/indexes/period/test_shift.py b/pandas/tests/indexes/period/test_shift.py
index 5689e98c33455..b4c9810f3a554 100644
--- a/pandas/tests/indexes/period/test_shift.py
+++ b/pandas/tests/indexes/period/test_shift.py
@@ -1,7 +1,6 @@
 import numpy as np
 import pytest
 
-import pandas as pd
 from pandas import PeriodIndex, period_range
 import pandas._testing as tm
 
@@ -62,7 +61,7 @@ def test_shift(self):
 
     def test_shift_corner_cases(self):
         # GH#9903
-        idx = pd.PeriodIndex([], name="xxx", freq="H")
+        idx = PeriodIndex([], name="xxx", freq="H")
 
         with pytest.raises(TypeError):
             # period shift doesn't accept freq
@@ -71,19 +70,19 @@ def test_shift_corner_cases(self):
         tm.assert_index_equal(idx.shift(0), idx)
         tm.assert_index_equal(idx.shift(3), idx)
 
-        idx = pd.PeriodIndex(
+        idx = PeriodIndex(
             ["2011-01-01 10:00", "2011-01-01 11:00", "2011-01-01 12:00"],
             name="xxx",
             freq="H",
         )
         tm.assert_index_equal(idx.shift(0), idx)
-        exp = pd.PeriodIndex(
+        exp = PeriodIndex(
             ["2011-01-01 13:00", "2011-01-01 14:00", "2011-01-01 15:00"],
             name="xxx",
             freq="H",
         )
         tm.assert_index_equal(idx.shift(3), exp)
-        exp = pd.PeriodIndex(
+        exp = PeriodIndex(
             ["2011-01-01 07:00", "2011-01-01 08:00", "2011-01-01 09:00"],
             name="xxx",
             freq="H",
@@ -104,7 +103,7 @@ def test_shift_nat(self):
     def test_shift_gh8083(self):
         # test shift for PeriodIndex
         # GH#8083
-        drange = pd.period_range("20130101", periods=5, freq="D")
+        drange = period_range("20130101", periods=5, freq="D")
         result = drange.shift(1)
         expected = PeriodIndex(
             ["2013-01-02", "2013-01-03", "2013-01-04", "2013-01-05", "2013-01-06"],
diff --git a/pandas/tests/indexes/period/test_tools.py b/pandas/tests/indexes/period/test_tools.py
index 23350fdff4b78..dae220006ebe0 100644
--- a/pandas/tests/indexes/period/test_tools.py
+++ b/pandas/tests/indexes/period/test_tools.py
@@ -1,22 +1,19 @@
-from datetime import datetime, timedelta
+from datetime import datetime
 
 import numpy as np
 import pytest
 
 from pandas._libs.tslibs import IncompatibleFrequency
-from pandas._libs.tslibs.ccalendar import MONTHS
 
-import pandas as pd
 from pandas import (
     DatetimeIndex,
+    NaT,
     Period,
     PeriodIndex,
-    Series,
     Timedelta,
     Timestamp,
     date_range,
     period_range,
-    to_datetime,
 )
 import pandas._testing as tm
 
@@ -42,207 +39,33 @@ def test_monthly(self):
     def test_freq(self, freq):
         self._check_freq(freq, "1970-01-01")
 
-    def test_negone_ordinals(self):
-        freqs = ["A", "M", "Q", "D", "H", "T", "S"]
-
-        period = Period(ordinal=-1, freq="D")
-        for freq in freqs:
-            repr(period.asfreq(freq))
-
-        for freq in freqs:
-            period = Period(ordinal=-1, freq=freq)
-            repr(period)
-            assert period.year == 1969
-
-        period = Period(ordinal=-1, freq="B")
-        repr(period)
-        period = Period(ordinal=-1, freq="W")
-        repr(period)
-
-
-class TestPeriodIndex:
-    def test_to_timestamp(self):
-        index = period_range(freq="A", start="1/1/2001", end="12/1/2009")
-        series = Series(1, index=index, name="foo")
-
-        exp_index = date_range("1/1/2001", end="12/31/2009", freq="A-DEC")
-        result = series.to_timestamp(how="end")
-        exp_index = exp_index + Timedelta(1, "D") - Timedelta(1, "ns")
-        tm.assert_index_equal(result.index, exp_index)
-        assert result.name == "foo"
-
-        exp_index = date_range("1/1/2001", end="1/1/2009", freq="AS-JAN")
-        result = series.to_timestamp(how="start")
-        tm.assert_index_equal(result.index, exp_index)
-
-        def _get_with_delta(delta, freq="A-DEC"):
-            return date_range(
-                to_datetime("1/1/2001") + delta,
-                to_datetime("12/31/2009") + delta,
-                freq=freq,
-            )
-
-        delta = timedelta(hours=23)
-        result = series.to_timestamp("H", "end")
-        exp_index = _get_with_delta(delta)
-        exp_index = exp_index + Timedelta(1, "h") - Timedelta(1, "ns")
-        tm.assert_index_equal(result.index, exp_index)
-
-        delta = timedelta(hours=23, minutes=59)
-        result = series.to_timestamp("T", "end")
-        exp_index = _get_with_delta(delta)
-        exp_index = exp_index + Timedelta(1, "m") - Timedelta(1, "ns")
-        tm.assert_index_equal(result.index, exp_index)
-
-        result = series.to_timestamp("S", "end")
-        delta = timedelta(hours=23, minutes=59, seconds=59)
-        exp_index = _get_with_delta(delta)
-        exp_index = exp_index + Timedelta(1, "s") - Timedelta(1, "ns")
-        tm.assert_index_equal(result.index, exp_index)
-
-        index = period_range(freq="H", start="1/1/2001", end="1/2/2001")
-        series = Series(1, index=index, name="foo")
-
-        exp_index = date_range("1/1/2001 00:59:59", end="1/2/2001 00:59:59", freq="H")
-        result = series.to_timestamp(how="end")
-        exp_index = exp_index + Timedelta(1, "s") - Timedelta(1, "ns")
-        tm.assert_index_equal(result.index, exp_index)
-        assert result.name == "foo"
-
-    def test_to_timestamp_freq(self):
-        idx = pd.period_range("2017", periods=12, freq="A-DEC")
-        result = idx.to_timestamp()
-        expected = pd.date_range("2017", periods=12, freq="AS-JAN")
-        tm.assert_index_equal(result, expected)
-
-    def test_to_timestamp_repr_is_code(self):
-        zs = [
-            Timestamp("99-04-17 00:00:00", tz="UTC"),
-            Timestamp("2001-04-17 00:00:00", tz="UTC"),
-            Timestamp("2001-04-17 00:00:00", tz="America/Los_Angeles"),
-            Timestamp("2001-04-17 00:00:00", tz=None),
-        ]
-        for z in zs:
-            assert eval(repr(z)) == z
-
-    def test_to_timestamp_to_period_astype(self):
-        idx = DatetimeIndex([pd.NaT, "2011-01-01", "2011-02-01"], name="idx")
-
-        res = idx.astype("period[M]")
-        exp = PeriodIndex(["NaT", "2011-01", "2011-02"], freq="M", name="idx")
-        tm.assert_index_equal(res, exp)
-
-        res = idx.astype("period[3M]")
-        exp = PeriodIndex(["NaT", "2011-01", "2011-02"], freq="3M", name="idx")
-        tm.assert_index_equal(res, exp)
-
-    def test_dti_to_period(self):
-        dti = pd.date_range(start="1/1/2005", end="12/1/2005", freq="M")
-        pi1 = dti.to_period()
-        pi2 = dti.to_period(freq="D")
-        pi3 = dti.to_period(freq="3D")
-
-        assert pi1[0] == Period("Jan 2005", freq="M")
-        assert pi2[0] == Period("1/31/2005", freq="D")
-        assert pi3[0] == Period("1/31/2005", freq="3D")
-
-        assert pi1[-1] == Period("Nov 2005", freq="M")
-        assert pi2[-1] == Period("11/30/2005", freq="D")
-        assert pi3[-1], Period("11/30/2005", freq="3D")
-
-        tm.assert_index_equal(pi1, period_range("1/1/2005", "11/1/2005", freq="M"))
-        tm.assert_index_equal(
-            pi2, period_range("1/1/2005", "11/1/2005", freq="M").asfreq("D")
-        )
-        tm.assert_index_equal(
-            pi3, period_range("1/1/2005", "11/1/2005", freq="M").asfreq("3D")
-        )
-
-    @pytest.mark.parametrize("month", MONTHS)
-    def test_to_period_quarterly(self, month):
-        # make sure we can make the round trip
-        freq = "Q-{month}".format(month=month)
-        rng = period_range("1989Q3", "1991Q3", freq=freq)
-        stamps = rng.to_timestamp()
-        result = stamps.to_period(freq)
-        tm.assert_index_equal(rng, result)
-
-    @pytest.mark.parametrize("off", ["BQ", "QS", "BQS"])
-    def test_to_period_quarterlyish(self, off):
-        rng = date_range("01-Jan-2012", periods=8, freq=off)
-        prng = rng.to_period()
-        assert prng.freq == "Q-DEC"
-
-    @pytest.mark.parametrize("off", ["BA", "AS", "BAS"])
-    def test_to_period_annualish(self, off):
-        rng = date_range("01-Jan-2012", periods=8, freq=off)
-        prng = rng.to_period()
-        assert prng.freq == "A-DEC"
-
-    def test_to_period_monthish(self):
-        offsets = ["MS", "BM"]
-        for off in offsets:
-            rng = date_range("01-Jan-2012", periods=8, freq=off)
-            prng = rng.to_period()
-            assert prng.freq == "M"
-
-        rng = date_range("01-Jan-2012", periods=8, freq="M")
-        prng = rng.to_period()
-        assert prng.freq == "M"
-
-        msg = pd._libs.tslibs.frequencies.INVALID_FREQ_ERR_MSG
-        with pytest.raises(ValueError, match=msg):
-            date_range("01-Jan-2012", periods=8, freq="EOM")
-
-    def test_period_dt64_round_trip(self):
-        dti = date_range("1/1/2000", "1/7/2002", freq="B")
-        pi = dti.to_period()
-        tm.assert_index_equal(pi.to_timestamp(), dti)
-
-        dti = date_range("1/1/2000", "1/7/2002", freq="B")
-        pi = dti.to_period(freq="H")
-        tm.assert_index_equal(pi.to_timestamp(), dti)
-
-    def test_combine_first(self):
-        # GH#3367
-        didx = pd.date_range(start="1950-01-31", end="1950-07-31", freq="M")
-        pidx = pd.period_range(
-            start=pd.Period("1950-1"), end=pd.Period("1950-7"), freq="M"
-        )
-        # check to be consistent with DatetimeIndex
-        for idx in [didx, pidx]:
-            a = pd.Series([1, np.nan, np.nan, 4, 5, np.nan, 7], index=idx)
-            b = pd.Series([9, 9, 9, 9, 9, 9, 9], index=idx)
-
-            result = a.combine_first(b)
-            expected = pd.Series([1, 9, 9, 4, 5, 9, 7], index=idx, dtype=np.float64)
-            tm.assert_series_equal(result, expected)
 
+class TestSearchsorted:
     @pytest.mark.parametrize("freq", ["D", "2D"])
     def test_searchsorted(self, freq):
-        pidx = pd.PeriodIndex(
+        pidx = PeriodIndex(
             ["2014-01-01", "2014-01-02", "2014-01-03", "2014-01-04", "2014-01-05"],
             freq=freq,
         )
 
-        p1 = pd.Period("2014-01-01", freq=freq)
+        p1 = Period("2014-01-01", freq=freq)
         assert pidx.searchsorted(p1) == 0
 
-        p2 = pd.Period("2014-01-04", freq=freq)
+        p2 = Period("2014-01-04", freq=freq)
         assert pidx.searchsorted(p2) == 3
 
-        assert pidx.searchsorted(pd.NaT) == 0
+        assert pidx.searchsorted(NaT) == 0
 
         msg = "Input has different freq=H from PeriodArray"
         with pytest.raises(IncompatibleFrequency, match=msg):
-            pidx.searchsorted(pd.Period("2014-01-01", freq="H"))
+            pidx.searchsorted(Period("2014-01-01", freq="H"))
 
         msg = "Input has different freq=5D from PeriodArray"
         with pytest.raises(IncompatibleFrequency, match=msg):
-            pidx.searchsorted(pd.Period("2014-01-01", freq="5D"))
+            pidx.searchsorted(Period("2014-01-01", freq="5D"))
 
     def test_searchsorted_invalid(self):
-        pidx = pd.PeriodIndex(
+        pidx = PeriodIndex(
             ["2014-01-01", "2014-01-02", "2014-01-03", "2014-01-04", "2014-01-05"],
             freq="D",
         )
@@ -284,13 +107,21 @@ def test_tolist(self):
         recon = PeriodIndex(rs)
         tm.assert_index_equal(index, recon)
 
+
+class TestToTimestamp:
+    def test_to_timestamp_freq(self):
+        idx = period_range("2017", periods=12, freq="A-DEC")
+        result = idx.to_timestamp()
+        expected = date_range("2017", periods=12, freq="AS-JAN")
+        tm.assert_index_equal(result, expected)
+
     def test_to_timestamp_pi_nat(self):
         # GH#7228
         index = PeriodIndex(["NaT", "2011-01", "2011-02"], freq="M", name="idx")
 
         result = index.to_timestamp("D")
         expected = DatetimeIndex(
-            [pd.NaT, datetime(2011, 1, 1), datetime(2011, 2, 1)], name="idx"
+            [NaT, datetime(2011, 1, 1), datetime(2011, 2, 1)], name="idx"
         )
         tm.assert_index_equal(result, expected)
         assert result.name == "idx"
@@ -356,29 +187,6 @@ def test_to_timestamp_pi_combined(self):
         expected = expected + Timedelta(1, "h") - Timedelta(1, "ns")
         tm.assert_index_equal(result, expected)
 
-    def test_period_astype_to_timestamp(self):
-        pi = pd.PeriodIndex(["2011-01", "2011-02", "2011-03"], freq="M")
-
-        exp = pd.DatetimeIndex(["2011-01-01", "2011-02-01", "2011-03-01"])
-        tm.assert_index_equal(pi.astype("datetime64[ns]"), exp)
-
-        exp = pd.DatetimeIndex(["2011-01-31", "2011-02-28", "2011-03-31"])
-        exp = exp + Timedelta(1, "D") - Timedelta(1, "ns")
-        tm.assert_index_equal(pi.astype("datetime64[ns]", how="end"), exp)
-
-        exp = pd.DatetimeIndex(
-            ["2011-01-01", "2011-02-01", "2011-03-01"], tz="US/Eastern"
-        )
-        res = pi.astype("datetime64[ns, US/Eastern]")
-        tm.assert_index_equal(pi.astype("datetime64[ns, US/Eastern]"), exp)
-
-        exp = pd.DatetimeIndex(
-            ["2011-01-31", "2011-02-28", "2011-03-31"], tz="US/Eastern"
-        )
-        exp = exp + Timedelta(1, "D") - Timedelta(1, "ns")
-        res = pi.astype("datetime64[ns, US/Eastern]", how="end")
-        tm.assert_index_equal(res, exp)
-
     def test_to_timestamp_1703(self):
         index = period_range("1/1/2012", periods=4, freq="D")
 
diff --git a/pandas/tests/scalar/period/test_period.py b/pandas/tests/scalar/period/test_period.py
index 995d47c1473be..b396a88e6eb6a 100644
--- a/pandas/tests/scalar/period/test_period.py
+++ b/pandas/tests/scalar/period/test_period.py
@@ -1565,3 +1565,21 @@ def test_small_year_parsing():
     per1 = Period("0001-01-07", "D")
     assert per1.year == 1
     assert per1.day == 7
+
+
+def test_negone_ordinals():
+    freqs = ["A", "M", "Q", "D", "H", "T", "S"]
+
+    period = Period(ordinal=-1, freq="D")
+    for freq in freqs:
+        repr(period.asfreq(freq))
+
+    for freq in freqs:
+        period = Period(ordinal=-1, freq=freq)
+        repr(period)
+        assert period.year == 1969
+
+    period = Period(ordinal=-1, freq="B")
+    repr(period)
+    period = Period(ordinal=-1, freq="W")
+    repr(period)
diff --git a/pandas/tests/scalar/timestamp/test_rendering.py b/pandas/tests/scalar/timestamp/test_rendering.py
index 6b64b230a0bb9..cab6946bb8d02 100644
--- a/pandas/tests/scalar/timestamp/test_rendering.py
+++ b/pandas/tests/scalar/timestamp/test_rendering.py
@@ -85,3 +85,13 @@ def test_pprint(self):
          {'w': {'a': Timestamp('2011-01-01 00:00:00')}}],
  'foo': 1}"""
         assert result == expected
+
+    def test_to_timestamp_repr_is_code(self):
+        zs = [
+            Timestamp("99-04-17 00:00:00", tz="UTC"),
+            Timestamp("2001-04-17 00:00:00", tz="UTC"),
+            Timestamp("2001-04-17 00:00:00", tz="America/Los_Angeles"),
+            Timestamp("2001-04-17 00:00:00", tz=None),
+        ]
+        for z in zs:
+            assert eval(repr(z)) == z
diff --git a/pandas/tests/series/methods/test_asfreq.py b/pandas/tests/series/methods/test_asfreq.py
new file mode 100644
index 0000000000000..05ec56cf02182
--- /dev/null
+++ b/pandas/tests/series/methods/test_asfreq.py
@@ -0,0 +1,23 @@
+import numpy as np
+
+from pandas import DataFrame, Series, period_range
+import pandas._testing as tm
+
+
+class TestAsFreq:
+    # TODO: de-duplicate/parametrize or move DataFrame test
+    def test_asfreq_ts(self):
+        index = period_range(freq="A", start="1/1/2001", end="12/31/2010")
+        ts = Series(np.random.randn(len(index)), index=index)
+        df = DataFrame(np.random.randn(len(index), 3), index=index)
+
+        result = ts.asfreq("D", how="end")
+        df_result = df.asfreq("D", how="end")
+        exp_index = index.asfreq("D", how="end")
+        assert len(result) == len(ts)
+        tm.assert_index_equal(result.index, exp_index)
+        tm.assert_index_equal(df_result.index, exp_index)
+
+        result = ts.asfreq("D", how="start")
+        assert len(result) == len(ts)
+        tm.assert_index_equal(result.index, index.asfreq("D", how="start"))
diff --git a/pandas/tests/series/methods/test_combine_first.py b/pandas/tests/series/methods/test_combine_first.py
new file mode 100644
index 0000000000000..aed6425e50117
--- /dev/null
+++ b/pandas/tests/series/methods/test_combine_first.py
@@ -0,0 +1,19 @@
+import numpy as np
+
+from pandas import Period, Series, date_range, period_range
+import pandas._testing as tm
+
+
+class TestCombineFirst:
+    def test_combine_first_period_datetime(self):
+        # GH#3367
+        didx = date_range(start="1950-01-31", end="1950-07-31", freq="M")
+        pidx = period_range(start=Period("1950-1"), end=Period("1950-7"), freq="M")
+        # check to be consistent with DatetimeIndex
+        for idx in [didx, pidx]:
+            a = Series([1, np.nan, np.nan, 4, 5, np.nan, 7], index=idx)
+            b = Series([9, 9, 9, 9, 9, 9, 9], index=idx)
+
+            result = a.combine_first(b)
+            expected = Series([1, 9, 9, 4, 5, 9, 7], index=idx, dtype=np.float64)
+            tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/series/methods/test_to_timestamp.py b/pandas/tests/series/methods/test_to_timestamp.py
new file mode 100644
index 0000000000000..44caf1f082a4f
--- /dev/null
+++ b/pandas/tests/series/methods/test_to_timestamp.py
@@ -0,0 +1,54 @@
+from datetime import timedelta
+
+from pandas import Series, Timedelta, date_range, period_range, to_datetime
+import pandas._testing as tm
+
+
+class TestToTimestamp:
+    def test_to_timestamp(self):
+        index = period_range(freq="A", start="1/1/2001", end="12/1/2009")
+        series = Series(1, index=index, name="foo")
+
+        exp_index = date_range("1/1/2001", end="12/31/2009", freq="A-DEC")
+        result = series.to_timestamp(how="end")
+        exp_index = exp_index + Timedelta(1, "D") - Timedelta(1, "ns")
+        tm.assert_index_equal(result.index, exp_index)
+        assert result.name == "foo"
+
+        exp_index = date_range("1/1/2001", end="1/1/2009", freq="AS-JAN")
+        result = series.to_timestamp(how="start")
+        tm.assert_index_equal(result.index, exp_index)
+
+        def _get_with_delta(delta, freq="A-DEC"):
+            return date_range(
+                to_datetime("1/1/2001") + delta,
+                to_datetime("12/31/2009") + delta,
+                freq=freq,
+            )
+
+        delta = timedelta(hours=23)
+        result = series.to_timestamp("H", "end")
+        exp_index = _get_with_delta(delta)
+        exp_index = exp_index + Timedelta(1, "h") - Timedelta(1, "ns")
+        tm.assert_index_equal(result.index, exp_index)
+
+        delta = timedelta(hours=23, minutes=59)
+        result = series.to_timestamp("T", "end")
+        exp_index = _get_with_delta(delta)
+        exp_index = exp_index + Timedelta(1, "m") - Timedelta(1, "ns")
+        tm.assert_index_equal(result.index, exp_index)
+
+        result = series.to_timestamp("S", "end")
+        delta = timedelta(hours=23, minutes=59, seconds=59)
+        exp_index = _get_with_delta(delta)
+        exp_index = exp_index + Timedelta(1, "s") - Timedelta(1, "ns")
+        tm.assert_index_equal(result.index, exp_index)
+
+        index = period_range(freq="H", start="1/1/2001", end="1/2/2001")
+        series = Series(1, index=index, name="foo")
+
+        exp_index = date_range("1/1/2001 00:59:59", end="1/2/2001 00:59:59", freq="H")
+        result = series.to_timestamp(how="end")
+        exp_index = exp_index + Timedelta(1, "s") - Timedelta(1, "ns")
+        tm.assert_index_equal(result.index, exp_index)
+        assert result.name == "foo"