From afe985c54ce39004504098790797df3803e5071d Mon Sep 17 00:00:00 2001
From: Brock <jbrockmendel@gmail.com>
Date: Sun, 10 Dec 2023 10:07:56 -0800
Subject: [PATCH 1/2] rename test_period_asfreq->test_period

---
 pandas/tests/tslibs/{test_period_asfreq.py => test_period.py} | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename pandas/tests/tslibs/{test_period_asfreq.py => test_period.py} (100%)

diff --git a/pandas/tests/tslibs/test_period_asfreq.py b/pandas/tests/tslibs/test_period.py
similarity index 100%
rename from pandas/tests/tslibs/test_period_asfreq.py
rename to pandas/tests/tslibs/test_period.py

From b88e2d1f70ae2a7069f53c51fbc6d967f04439fe Mon Sep 17 00:00:00 2001
From: Brock <jbrockmendel@gmail.com>
Date: Sun, 10 Dec 2023 10:27:51 -0800
Subject: [PATCH 2/2] TST: de-duplicate PeriodIndex constructor tests

---
 .../tests/indexes/period/test_constructors.py | 159 +++++++++++-------
 pandas/tests/indexes/period/test_period.py    | 136 ---------------
 .../tests/indexes/period/test_period_range.py | 137 ++++++++++-----
 pandas/tests/scalar/period/test_period.py     |  57 ++++---
 pandas/tests/tslibs/test_period.py            |   7 +
 5 files changed, 232 insertions(+), 264 deletions(-)

diff --git a/pandas/tests/indexes/period/test_constructors.py b/pandas/tests/indexes/period/test_constructors.py
index aecd3b3bace9a..d53581fab40c7 100644
--- a/pandas/tests/indexes/period/test_constructors.py
+++ b/pandas/tests/indexes/period/test_constructors.py
@@ -19,7 +19,54 @@
 from pandas.core.arrays import PeriodArray
 
 
+class TestPeriodIndexDisallowedFreqs:
+    @pytest.mark.parametrize(
+        "freq,freq_depr",
+        [
+            ("2M", "2ME"),
+            ("2Q-MAR", "2QE-MAR"),
+            ("2Y-FEB", "2YE-FEB"),
+        ],
+    )
+    def test_period_index_frequency_ME_error_message(self, freq, freq_depr):
+        # GH#52064
+        msg = f"for Period, please use '{freq[1:]}' instead of '{freq_depr[1:]}'"
+
+        with pytest.raises(ValueError, match=msg):
+            PeriodIndex(["2020-01-01", "2020-01-02"], freq=freq_depr)
+
+        with pytest.raises(ValueError, match=msg):
+            period_range(start="2020-01-01", end="2020-01-02", freq=freq_depr)
+
+    @pytest.mark.parametrize("freq_depr", ["2SME", "2CBME", "2BYE"])
+    def test_period_index_frequency_invalid_freq(self, freq_depr):
+        # GH#9586
+        msg = f"Invalid frequency: {freq_depr[1:]}"
+
+        with pytest.raises(ValueError, match=msg):
+            period_range("2020-01", "2020-05", freq=freq_depr)
+        with pytest.raises(ValueError, match=msg):
+            PeriodIndex(["2020-01", "2020-05"], freq=freq_depr)
+
+
 class TestPeriodIndex:
+    def test_from_ordinals(self):
+        Period(ordinal=-1000, freq="Y")
+        Period(ordinal=0, freq="Y")
+
+        msg = "The 'ordinal' keyword in PeriodIndex is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            idx1 = PeriodIndex(ordinal=[-1, 0, 1], freq="Y")
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            idx2 = PeriodIndex(ordinal=np.array([-1, 0, 1]), freq="Y")
+        tm.assert_index_equal(idx1, idx2)
+
+        alt1 = PeriodIndex.from_ordinals([-1, 0, 1], freq="Y")
+        tm.assert_index_equal(alt1, idx1)
+
+        alt2 = PeriodIndex.from_ordinals(np.array([-1, 0, 1]), freq="Y")
+        tm.assert_index_equal(alt2, idx2)
+
     def test_keyword_mismatch(self):
         # GH#55961 we should get exactly one of data/ordinals/**fields
         per = Period("2016-01-01", "D")
@@ -131,11 +178,6 @@ def test_constructor_field_arrays(self):
         exp = period_range("2007-01", periods=3, freq="M")
         tm.assert_index_equal(idx, exp)
 
-    def test_constructor_U(self):
-        # U was used as undefined period
-        with pytest.raises(ValueError, match="Invalid frequency: X"):
-            period_range("2007-1-1", periods=500, freq="X")
-
     def test_constructor_nano(self):
         idx = period_range(
             start=Period(ordinal=1, freq="ns"),
@@ -371,49 +413,12 @@ def test_constructor_mixed(self):
         exp = PeriodIndex(["2011-01-01", "NaT", "2012-01-01"], freq="D")
         tm.assert_index_equal(idx, exp)
 
-    def test_constructor_simple_new(self):
-        idx = period_range("2007-01", name="p", periods=2, freq="M")
-
-        with pytest.raises(AssertionError, match="<class .*PeriodIndex'>"):
-            idx._simple_new(idx, name="p")
-
-        result = idx._simple_new(idx._data, name="p")
-        tm.assert_index_equal(result, idx)
-
-        msg = "Should be numpy array of type i8"
-        with pytest.raises(AssertionError, match=msg):
-            # Need ndarray, not int64 Index
-            type(idx._data)._simple_new(Index(idx.asi8), dtype=idx.dtype)
-
-        arr = type(idx._data)._simple_new(idx.asi8, dtype=idx.dtype)
-        result = idx._simple_new(arr, name="p")
-        tm.assert_index_equal(result, idx)
-
-    def test_constructor_simple_new_empty(self):
-        # GH13079
-        idx = PeriodIndex([], freq="M", name="p")
-        with pytest.raises(AssertionError, match="<class .*PeriodIndex'>"):
-            idx._simple_new(idx, name="p")
-
-        result = idx._simple_new(idx._data, name="p")
-        tm.assert_index_equal(result, idx)
-
     @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 "):
-            PeriodIndex._simple_new(floats)
-
         msg = "PeriodIndex does not allow floating point in construction"
         with pytest.raises(TypeError, match=msg):
             PeriodIndex(floats)
 
-    def test_constructor_nat(self):
-        msg = "start and end must not be NaT"
-        with pytest.raises(ValueError, match=msg):
-            period_range(start="NaT", end="2011-01-01", freq="M")
-        with pytest.raises(ValueError, match=msg):
-            period_range(start="2011-01-01", end="NaT", freq="M")
-
     def test_constructor_year_and_quarter(self):
         year = Series([2001, 2002, 2003])
         quarter = year - 2000
@@ -493,7 +498,7 @@ def test_constructor_freq_combined(self):
             expected = PeriodIndex(["2016-01-01 00:00", "2016-01-02 01:00"], freq="25h")
             tm.assert_index_equal(pidx, expected)
 
-    def test_constructor(self):
+    def test_period_range_length(self):
         pi = period_range(freq="Y", start="1/1/2001", end="12/1/2009")
         assert len(pi) == 9
 
@@ -539,9 +544,12 @@ def test_constructor(self):
         assert (i1 == i2).all()
         assert i1.freq == i2.freq
 
+    def test_infer_freq_from_first_element(self):
+        msg = "Period with BDay freq is deprecated"
         with tm.assert_produces_warning(FutureWarning, match=msg):
+            start = Period("02-Apr-2005", "B")
             end_intv = Period("2005-05-01", "B")
-            i1 = period_range(start=start, end=end_intv)
+            period_range(start=start, end=end_intv)
 
             # infer freq from first element
             i2 = PeriodIndex([end_intv, Period("2005-05-05", "B")])
@@ -553,7 +561,12 @@ def test_constructor(self):
         assert len(i2) == 2
         assert i2[0] == end_intv
 
+    def test_mixed_freq_raises(self):
         # Mixed freq should fail
+        msg = "Period with BDay freq is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            end_intv = Period("2005-05-01", "B")
+
         vals = [end_intv, Period("2006-12-31", "w")]
         msg = r"Input has different freq=W-SUN from PeriodIndex\(freq=B\)"
         with pytest.raises(IncompatibleFrequency, match=msg):
@@ -562,10 +575,6 @@ def test_constructor(self):
         with pytest.raises(IncompatibleFrequency, match=msg):
             PeriodIndex(vals)
 
-        # tuple freq disallowed GH#34703
-        with pytest.raises(TypeError, match="pass as a string instead"):
-            Period("2006-12-31", ("w", 1))
-
     @pytest.mark.parametrize(
         "freq", ["M", "Q", "Y", "D", "B", "min", "s", "ms", "us", "ns", "h"]
     )
@@ -594,20 +603,39 @@ def test_map_with_string_constructor(self):
         # lastly, values should compare equal
         tm.assert_index_equal(res, expected)
 
-    @pytest.mark.parametrize(
-        "freq, freq_msg",
-        [
-            (offsets.BYearBegin(), "BYearBegin"),
-            (offsets.YearBegin(2), "YearBegin"),
-            (offsets.QuarterBegin(startingMonth=12), "QuarterBegin"),
-            (offsets.BusinessMonthEnd(2), "BusinessMonthEnd"),
-        ],
-    )
-    def test_offsets_not_supported(self, freq, freq_msg):
-        # GH#55785
-        msg = f"{freq_msg} is not supported as period frequency"
-        with pytest.raises(TypeError, match=msg):
-            Period(year=2014, freq=freq)
+
+class TestSimpleNew:
+    def test_constructor_simple_new(self):
+        idx = period_range("2007-01", name="p", periods=2, freq="M")
+
+        with pytest.raises(AssertionError, match="<class .*PeriodIndex'>"):
+            idx._simple_new(idx, name="p")
+
+        result = idx._simple_new(idx._data, name="p")
+        tm.assert_index_equal(result, idx)
+
+        msg = "Should be numpy array of type i8"
+        with pytest.raises(AssertionError, match=msg):
+            # Need ndarray, not int64 Index
+            type(idx._data)._simple_new(Index(idx.asi8), dtype=idx.dtype)
+
+        arr = type(idx._data)._simple_new(idx.asi8, dtype=idx.dtype)
+        result = idx._simple_new(arr, name="p")
+        tm.assert_index_equal(result, idx)
+
+    def test_constructor_simple_new_empty(self):
+        # GH13079
+        idx = PeriodIndex([], freq="M", name="p")
+        with pytest.raises(AssertionError, match="<class .*PeriodIndex'>"):
+            idx._simple_new(idx, name="p")
+
+        result = idx._simple_new(idx._data, name="p")
+        tm.assert_index_equal(result, idx)
+
+    @pytest.mark.parametrize("floats", [[1.1, 2.1], np.array([1.1, 2.1])])
+    def test_period_index_simple_new_disallows_floats(self, floats):
+        with pytest.raises(AssertionError, match="<class "):
+            PeriodIndex._simple_new(floats)
 
 
 class TestShallowCopy:
@@ -638,6 +666,7 @@ def test_constructor_cant_cast_period(self):
             Series(period_range("2000-01-01", periods=10, freq="D"), dtype=float)
 
     def test_constructor_cast_object(self):
-        s = Series(period_range("1/1/2000", periods=10), dtype=PeriodDtype("D"))
-        exp = Series(period_range("1/1/2000", periods=10))
-        tm.assert_series_equal(s, exp)
+        pi = period_range("1/1/2000", periods=10)
+        ser = Series(pi, dtype=PeriodDtype("D"))
+        exp = Series(pi)
+        tm.assert_series_equal(ser, exp)
diff --git a/pandas/tests/indexes/period/test_period.py b/pandas/tests/indexes/period/test_period.py
index 1354f33291c45..77b8e76894647 100644
--- a/pandas/tests/indexes/period/test_period.py
+++ b/pandas/tests/indexes/period/test_period.py
@@ -1,8 +1,6 @@
 import numpy as np
 import pytest
 
-from pandas._libs.tslibs.period import IncompatibleFrequency
-
 from pandas import (
     Index,
     NaT,
@@ -17,11 +15,6 @@
 
 
 class TestPeriodIndex:
-    def test_make_time_series(self):
-        index = period_range(freq="Y", start="1/1/2001", end="12/1/2009")
-        series = Series(1, index=index)
-        assert isinstance(series, Series)
-
     def test_view_asi8(self):
         idx = PeriodIndex([], freq="M")
 
@@ -66,74 +59,6 @@ def test_values(self):
         exp = np.array([14975, -9223372036854775808], dtype=np.int64)
         tm.assert_numpy_array_equal(idx.asi8, exp)
 
-    def test_period_index_length(self):
-        pi = period_range(freq="Y", start="1/1/2001", end="12/1/2009")
-        assert len(pi) == 9
-
-        pi = period_range(freq="Q", start="1/1/2001", end="12/1/2009")
-        assert len(pi) == 4 * 9
-
-        pi = period_range(freq="M", start="1/1/2001", end="12/1/2009")
-        assert len(pi) == 12 * 9
-
-        msg = "Period with BDay freq is deprecated"
-        with tm.assert_produces_warning(FutureWarning, match=msg):
-            start = Period("02-Apr-2005", "B")
-            i1 = period_range(start=start, periods=20)
-        assert len(i1) == 20
-        assert i1.freq == start.freq
-        assert i1[0] == start
-
-        end_intv = Period("2006-12-31", "W")
-        i1 = period_range(end=end_intv, periods=10)
-        assert len(i1) == 10
-        assert i1.freq == end_intv.freq
-        assert i1[-1] == end_intv
-
-        end_intv = Period("2006-12-31", "1w")
-        i2 = period_range(end=end_intv, periods=10)
-        assert len(i1) == len(i2)
-        assert (i1 == i2).all()
-        assert i1.freq == i2.freq
-
-        msg = "start and end must have same freq"
-        msg2 = "Period with BDay freq is deprecated"
-        with pytest.raises(ValueError, match=msg):
-            with tm.assert_produces_warning(FutureWarning, match=msg2):
-                period_range(start=start, end=end_intv)
-
-        with tm.assert_produces_warning(FutureWarning, match=msg2):
-            end_intv = Period("2005-05-01", "B")
-        with tm.assert_produces_warning(FutureWarning, match=msg2):
-            i1 = period_range(start=start, end=end_intv)
-
-        msg = (
-            "Of the three parameters: start, end, and periods, exactly two "
-            "must be specified"
-        )
-        with pytest.raises(ValueError, match=msg):
-            period_range(start=start)
-
-        # infer freq from first element
-        with tm.assert_produces_warning(FutureWarning, match=msg2):
-            i2 = PeriodIndex([end_intv, Period("2005-05-05", "B")])
-        assert len(i2) == 2
-        assert i2[0] == end_intv
-
-        with tm.assert_produces_warning(FutureWarning, match=msg2):
-            i2 = PeriodIndex(np.array([end_intv, Period("2005-05-05", "B")]))
-        assert len(i2) == 2
-        assert i2[0] == end_intv
-
-        # Mixed freq should fail
-        vals = [end_intv, Period("2006-12-31", "w")]
-        msg = r"Input has different freq=W-SUN from PeriodIndex\(freq=B\)"
-        with pytest.raises(IncompatibleFrequency, match=msg):
-            PeriodIndex(vals)
-        vals = np.array(vals)
-        with pytest.raises(ValueError, match=msg):
-            PeriodIndex(vals)
-
     @pytest.mark.parametrize(
         "field",
         [
@@ -210,23 +135,6 @@ def test_index_unique(self):
         tm.assert_index_equal(idx.unique(), expected)
         assert idx.nunique() == 3
 
-    def test_negative_ordinals(self):
-        Period(ordinal=-1000, freq="Y")
-        Period(ordinal=0, freq="Y")
-
-        msg = "The 'ordinal' keyword in PeriodIndex is deprecated"
-        with tm.assert_produces_warning(FutureWarning, match=msg):
-            idx1 = PeriodIndex(ordinal=[-1, 0, 1], freq="Y")
-        with tm.assert_produces_warning(FutureWarning, match=msg):
-            idx2 = PeriodIndex(ordinal=np.array([-1, 0, 1]), freq="Y")
-        tm.assert_index_equal(idx1, idx2)
-
-        alt1 = PeriodIndex.from_ordinals([-1, 0, 1], freq="Y")
-        tm.assert_index_equal(alt1, idx1)
-
-        alt2 = PeriodIndex.from_ordinals(np.array([-1, 0, 1]), freq="Y")
-        tm.assert_index_equal(alt2, idx2)
-
     def test_pindex_fieldaccessor_nat(self):
         idx = PeriodIndex(
             ["2011-01", "2011-02", "NaT", "2012-03", "2012-04"], freq="D", name="name"
@@ -281,50 +189,6 @@ def test_map(self):
         exp = Index([x.ordinal for x in index])
         tm.assert_index_equal(result, exp)
 
-    @pytest.mark.parametrize(
-        "freq,freq_depr",
-        [
-            ("2M", "2ME"),
-            ("2Q-MAR", "2QE-MAR"),
-            ("2Y-FEB", "2YE-FEB"),
-        ],
-    )
-    def test_period_index_frequency_ME_error_message(self, freq, freq_depr):
-        # GH#52064
-        msg = f"for Period, please use '{freq[1:]}' instead of '{freq_depr[1:]}'"
-
-        with pytest.raises(ValueError, match=msg):
-            PeriodIndex(["2020-01-01", "2020-01-02"], freq=freq_depr)
-
-    def test_H_deprecated_from_time_series(self):
-        # GH#52536
-        msg = "'H' is deprecated and will be removed in a future version."
-
-        with tm.assert_produces_warning(FutureWarning, match=msg):
-            index = period_range(freq="2H", start="1/1/2001", end="12/1/2009")
-        series = Series(1, index=index)
-        assert isinstance(series, Series)
-
-    @pytest.mark.parametrize("freq_depr", ["2A", "A-DEC", "200A-AUG"])
-    def test_a_deprecated_from_time_series(self, freq_depr):
-        # GH#52536
-        freq_msg = freq_depr[freq_depr.index("A") :]
-        msg = f"'{freq_msg}' is deprecated and will be removed in a future version, "
-        f"please use 'Y{freq_msg[1:]}' instead."
-
-        with tm.assert_produces_warning(FutureWarning, match=msg):
-            index = period_range(freq=freq_depr, start="1/1/2001", end="12/1/2009")
-        series = Series(1, index=index)
-        assert isinstance(series, Series)
-
-    @pytest.mark.parametrize("freq_depr", ["2SME", "2CBME", "2BYE"])
-    def test_period_index_frequency_invalid_freq(self, freq_depr):
-        # GH#9586
-        msg = f"Invalid frequency: {freq_depr[1:]}"
-
-        with pytest.raises(ValueError, match=msg):
-            period_range("2020-01", "2020-05", freq=freq_depr)
-
 
 def test_maybe_convert_timedelta():
     pi = PeriodIndex(["2000", "2001"], freq="D")
diff --git a/pandas/tests/indexes/period/test_period_range.py b/pandas/tests/indexes/period/test_period_range.py
index 0d7bedbbe70f6..2543b49089948 100644
--- a/pandas/tests/indexes/period/test_period_range.py
+++ b/pandas/tests/indexes/period/test_period_range.py
@@ -11,7 +11,7 @@
 import pandas._testing as tm
 
 
-class TestPeriodRange:
+class TestPeriodRangeKeywords:
     def test_required_arguments(self):
         msg = (
             "Of the three parameters: start, end, and periods, exactly two "
@@ -20,6 +20,62 @@ def test_required_arguments(self):
         with pytest.raises(ValueError, match=msg):
             period_range("2011-1-1", "2012-1-1", "B")
 
+    def test_required_arguments2(self):
+        start = Period("02-Apr-2005", "D")
+        msg = (
+            "Of the three parameters: start, end, and periods, exactly two "
+            "must be specified"
+        )
+        with pytest.raises(ValueError, match=msg):
+            period_range(start=start)
+
+    def test_required_arguments3(self):
+        # not enough params
+        msg = (
+            "Of the three parameters: start, end, and periods, "
+            "exactly two must be specified"
+        )
+        with pytest.raises(ValueError, match=msg):
+            period_range(start="2017Q1")
+
+        with pytest.raises(ValueError, match=msg):
+            period_range(end="2017Q1")
+
+        with pytest.raises(ValueError, match=msg):
+            period_range(periods=5)
+
+        with pytest.raises(ValueError, match=msg):
+            period_range()
+
+    def test_required_arguments_too_many(self):
+        msg = (
+            "Of the three parameters: start, end, and periods, "
+            "exactly two must be specified"
+        )
+        with pytest.raises(ValueError, match=msg):
+            period_range(start="2017Q1", end="2018Q1", periods=8, freq="Q")
+
+    def test_start_end_non_nat(self):
+        # start/end NaT
+        msg = "start and end must not be NaT"
+        with pytest.raises(ValueError, match=msg):
+            period_range(start=NaT, end="2018Q1")
+        with pytest.raises(ValueError, match=msg):
+            period_range(start=NaT, end="2018Q1", freq="Q")
+
+        with pytest.raises(ValueError, match=msg):
+            period_range(start="2017Q1", end=NaT)
+        with pytest.raises(ValueError, match=msg):
+            period_range(start="2017Q1", end=NaT, freq="Q")
+
+    def test_periods_requires_integer(self):
+        # invalid periods param
+        msg = "periods must be a number, got foo"
+        with pytest.raises(TypeError, match=msg):
+            period_range(start="2017Q1", periods="foo")
+
+
+class TestPeriodRange:
     @pytest.mark.parametrize(
         "freq_offset, freq_period",
         [
@@ -95,7 +151,8 @@ def test_construction_from_period(self):
         tm.assert_index_equal(result, expected)
 
         # downsampling
-        start, end = Period("2017-1", freq="M"), Period("2019-12", freq="M")
+        start = Period("2017-1", freq="M")
+        end = Period("2019-12", freq="M")
         expected = date_range(
             start="2017-01-31", end="2019-12-31", freq="QE", name="foo"
         ).to_period()
@@ -103,7 +160,8 @@ def test_construction_from_period(self):
         tm.assert_index_equal(result, expected)
 
         # test for issue # 21793
-        start, end = Period("2017Q1", freq="Q"), Period("2018Q1", freq="Q")
+        start = Period("2017Q1", freq="Q")
+        end = Period("2018Q1", freq="Q")
         idx = period_range(start=start, end=end, freq="Q", name="foo")
         result = idx == idx.values
         expected = np.array([True, True, True, True, True])
@@ -121,42 +179,43 @@ def test_construction_from_period(self):
         result = period_range(start=end, end=start, freq="W", name="foo")
         tm.assert_index_equal(result, expected)
 
-    def test_errors(self):
-        # not enough params
-        msg = (
-            "Of the three parameters: start, end, and periods, "
-            "exactly two must be specified"
-        )
-        with pytest.raises(ValueError, match=msg):
-            period_range(start="2017Q1")
-
-        with pytest.raises(ValueError, match=msg):
-            period_range(end="2017Q1")
+    def test_mismatched_start_end_freq_raises(self):
+        depr_msg = "Period with BDay freq is deprecated"
+        end_w = Period("2006-12-31", "1w")
 
-        with pytest.raises(ValueError, match=msg):
-            period_range(periods=5)
+        with tm.assert_produces_warning(FutureWarning, match=depr_msg):
+            start_b = Period("02-Apr-2005", "B")
+            end_b = Period("2005-05-01", "B")
 
+        msg = "start and end must have same freq"
         with pytest.raises(ValueError, match=msg):
-            period_range()
-
-        # too many params
-        with pytest.raises(ValueError, match=msg):
-            period_range(start="2017Q1", end="2018Q1", periods=8, freq="Q")
-
-        # start/end NaT
-        msg = "start and end must not be NaT"
-        with pytest.raises(ValueError, match=msg):
-            period_range(start=NaT, end="2018Q1")
-
-        with pytest.raises(ValueError, match=msg):
-            period_range(start="2017Q1", end=NaT)
-
-        # invalid periods param
-        msg = "periods must be a number, got foo"
-        with pytest.raises(TypeError, match=msg):
-            period_range(start="2017Q1", periods="foo")
-
-    def test_period_range_frequency_ME_error_message(self):
-        msg = "for Period, please use 'M' instead of 'ME'"
-        with pytest.raises(ValueError, match=msg):
-            period_range(start="Jan-2000", end="Dec-2000", freq="2ME")
+            with tm.assert_produces_warning(FutureWarning, match=depr_msg):
+                period_range(start=start_b, end=end_w)
+
+        # without mismatch we are OK
+        with tm.assert_produces_warning(FutureWarning, match=depr_msg):
+            period_range(start=start_b, end=end_b)
+
+
+class TestPeriodRangeDisallowedFreqs:
+    def test_constructor_U(self):
+        # U was used as undefined period
+        with pytest.raises(ValueError, match="Invalid frequency: X"):
+            period_range("2007-1-1", periods=500, freq="X")
+
+    def test_H_deprecated_from_time_series(self):
+        # GH#52536
+        msg = "'H' is deprecated and will be removed in a future version."
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            period_range(freq="2H", start="1/1/2001", end="12/1/2009")
+
+    @pytest.mark.parametrize("freq_depr", ["2A", "A-DEC", "200A-AUG"])
+    def test_a_deprecated_from_time_series(self, freq_depr):
+        # GH#52536
+        freq_msg = freq_depr[freq_depr.index("A") :]
+        msg = (
+            f"'{freq_msg}' is deprecated and will be removed in a future version, "
+            f"please use 'Y{freq_msg[1:]}' instead."
+        )
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            period_range(freq=freq_depr, start="1/1/2001", end="12/1/2009")
diff --git a/pandas/tests/scalar/period/test_period.py b/pandas/tests/scalar/period/test_period.py
index 06d82ccd72b8c..aa4a8b152b19f 100644
--- a/pandas/tests/scalar/period/test_period.py
+++ b/pandas/tests/scalar/period/test_period.py
@@ -7,10 +7,7 @@
 import numpy as np
 import pytest
 
-from pandas._libs.tslibs import (
-    iNaT,
-    period as libperiod,
-)
+from pandas._libs.tslibs import iNaT
 from pandas._libs.tslibs.ccalendar import (
     DAYS,
     MONTHS,
@@ -31,7 +28,22 @@
 bday_msg = "Period with BDay freq is deprecated"
 
 
-class TestPeriodConstruction:
+class TestPeriodDisallowedFreqs:
+    @pytest.mark.parametrize(
+        "freq, freq_msg",
+        [
+            (offsets.BYearBegin(), "BYearBegin"),
+            (offsets.YearBegin(2), "YearBegin"),
+            (offsets.QuarterBegin(startingMonth=12), "QuarterBegin"),
+            (offsets.BusinessMonthEnd(2), "BusinessMonthEnd"),
+        ],
+    )
+    def test_offsets_not_supported(self, freq, freq_msg):
+        # GH#55785
+        msg = f"{freq_msg} is not supported as period frequency"
+        with pytest.raises(TypeError, match=msg):
+            Period(year=2014, freq=freq)
+
     def test_custom_business_day_freq_raises(self):
         # GH#52534
         msg = "CustomBusinessDay is not supported as period frequency"
@@ -40,6 +52,18 @@ def test_custom_business_day_freq_raises(self):
         with pytest.raises(TypeError, match=msg):
             Period("2023-04-10", freq=offsets.CustomBusinessDay())
 
+    def test_invalid_frequency_error_message(self):
+        msg = "WeekOfMonth is not supported as period frequency"
+        with pytest.raises(TypeError, match=msg):
+            Period("2012-01-02", freq="WOM-1MON")
+
+    def test_invalid_frequency_period_error_message(self):
+        msg = "for Period, please use 'M' instead of 'ME'"
+        with pytest.raises(ValueError, match=msg):
+            Period("2012-01-02", freq="ME")
+
+
+class TestPeriodConstruction:
     def test_from_td64nat_raises(self):
         # GH#44507
         td = NaT.to_numpy("m8[ns]")
@@ -114,10 +138,14 @@ def test_construction(self):
         with pytest.raises(ValueError, match=msg):
             Period("2007-1-1", freq="X")
 
+    def test_tuple_freq_disallowed(self):
         # GH#34703 tuple freq disallowed
         with pytest.raises(TypeError, match="pass as a string instead"):
             Period("1982", freq=("Min", 1))
 
+        with pytest.raises(TypeError, match="pass as a string instead"):
+            Period("2006-12-31", ("w", 1))
+
     def test_construction_from_timestamp_nanos(self):
         # GH#46811 don't drop nanos from Timestamp
         ts = Timestamp("2022-04-20 09:23:24.123456789")
@@ -1074,13 +1102,6 @@ def test_properties_secondly(self):
         )
 
 
-class TestPeriodField:
-    def test_get_period_field_array_raises_on_out_of_range(self):
-        msg = "Buffer dtype mismatch, expected 'const int64_t' but got 'double'"
-        with pytest.raises(ValueError, match=msg):
-            libperiod.get_period_field_arr(-1, np.empty(1), 0)
-
-
 class TestPeriodComparisons:
     def test_sort_periods(self):
         jan = Period("2000-01", "M")
@@ -1127,15 +1148,3 @@ def test_negone_ordinals():
     repr(period)
     period = Period(ordinal=-1, freq="W")
     repr(period)
-
-
-def test_invalid_frequency_error_message():
-    msg = "WeekOfMonth is not supported as period frequency"
-    with pytest.raises(TypeError, match=msg):
-        Period("2012-01-02", freq="WOM-1MON")
-
-
-def test_invalid_frequency_period_error_message():
-    msg = "for Period, please use 'M' instead of 'ME'"
-    with pytest.raises(ValueError, match=msg):
-        Period("2012-01-02", freq="ME")
diff --git a/pandas/tests/tslibs/test_period.py b/pandas/tests/tslibs/test_period.py
index 149817357fbd6..715e2d3da88db 100644
--- a/pandas/tests/tslibs/test_period.py
+++ b/pandas/tests/tslibs/test_period.py
@@ -7,6 +7,7 @@
 )
 from pandas._libs.tslibs.period import (
     extract_ordinals,
+    get_period_field_arr,
     period_asfreq,
     period_ordinal,
 )
@@ -114,3 +115,9 @@ def test_extract_ordinals_2d(self):
         res = extract_ordinals(arr, freq)
         res2 = extract_ordinals(arr.reshape(5, 2), freq)
         tm.assert_numpy_array_equal(res, res2.reshape(-1))
+
+
+def test_get_period_field_array_raises_on_out_of_range():
+    msg = "Buffer dtype mismatch, expected 'const int64_t' but got 'double'"
+    with pytest.raises(ValueError, match=msg):
+        get_period_field_arr(-1, np.empty(1), 0)