Repository: vacanza/holidays
Pull request #2087 (2024-10-28 19:03:12)

Refactor United States tests
<!--
  Thanks for contributing to holidays!
-->

## Proposed change

<!--
  Describe the big picture of your changes.
  Don't forget to link your PR to an existing issue if any.
-->

Refactor United States tests.

## Type of change

<!--
  Type of change you want to introduce. Please, check one (1) box only!
  If your PR requires multiple boxes to be checked, most likely it needs to
  be split into multiple PRs.
-->

- [ ] New country/market holidays support (thank you!)
- [ ] Supported country/market holidays update (calendar discrepancy fix, localization)
- [x] Existing code/documentation/test/process quality improvement (best practice, cleanup, refactoring, optimization)
- [ ] Dependency update (version deprecation/pin/upgrade)
- [ ] Bugfix (non-breaking change which fixes an issue)
- [ ] Breaking change (a code change causing existing functionality to break)
- [ ] New feature (new `holidays` functionality in general)

## Checklist

<!--
  Put an `x` in the boxes that apply. You can change them after PR is created.
-->

- [x] I've followed the [contributing guidelines][contributing-guidelines]
- [x] I've run `make pre-commit`, it didn't generate any changes
- [x] I've run `make test`, all tests passed locally

<!--
  Thanks again for your contribution!
-->

[contributing-guidelines]: https://github.com/vacanza/holidays/blob/dev/CONTRIBUTING.rst
[docs]: https://github.com/vacanza/holidays/tree/dev/docs/source


codecov[bot]: ## [Codecov](https://app.codecov.io/gh/vacanza/holidays/pull/2087?dropdown=coverage&src=pr&el=h1&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=vacanza) Report
All modified and coverable lines are covered by tests :white_check_mark:
> Project coverage is 100.00%. Comparing base [(`b2e6837`)](https://app.codecov.io/gh/vacanza/holidays/commit/b2e68379e42c36b2dfbb8bb8f95b47ada12c2051?dropdown=coverage&el=desc&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=vacanza) to head [(`42338c1`)](https://app.codecov.io/gh/vacanza/holidays/commit/42338c17e51e782d02335f243fa30ee3dfccdc39?dropdown=coverage&el=desc&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=vacanza).

<details><summary>Additional details and impacted files</summary>


```diff
@@            Coverage Diff            @@
##               dev     #2087   +/-   ##
=========================================
  Coverage   100.00%   100.00%           
=========================================
  Files          191       191           
  Lines        11547     11547           
  Branches      1744      1744           
=========================================
  Hits         11547     11547           
```

</details>

[:umbrella: View full report in Codecov by Sentry](https://app.codecov.io/gh/vacanza/holidays/pull/2087?dropdown=coverage&src=pr&el=continue&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=vacanza).   
:loudspeaker: Have feedback on the report? [Share it here](https://about.codecov.io/codecov-pr-comment-feedback/?utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=vacanza).


Patch:
diff --git a/holidays/countries/cambodia.py b/holidays/countries/cambodia.py
index 2a115585..f4152c52 100644
--- a/holidays/countries/cambodia.py
+++ b/holidays/countries/cambodia.py
@@ -264,10 +264,9 @@ class Cambodia(HolidayBase, InternationalHolidays, StaticHolidays, ThaiCalendarH
         # Pchum Ben Day
         pchum_ben = tr("ពិធីបុណ្យភ្ផុំបិណ្ឌ")
         pchum_ben_date = self._add_pchum_ben(pchum_ben)
-        if pchum_ben_date:
-            self._add_holiday(pchum_ben, _timedelta(pchum_ben_date, -1))
-            if self._year >= 2017:
-                self._add_holiday(pchum_ben, _timedelta(pchum_ben_date, +1))
+        self._add_holiday(pchum_ben, _timedelta(pchum_ben_date, -1))
+        if self._year >= 2017:
+            self._add_holiday(pchum_ben, _timedelta(pchum_ben_date, +1))
 
         # ព្រះរាជពិធីបុណ្យអុំទូក បណ្តែតប្រទីប និងសំពះព្រះខែអកអំបុក
         # Status: In-Use.
@@ -276,9 +275,8 @@ class Cambodia(HolidayBase, InternationalHolidays, StaticHolidays, ThaiCalendarH
         # Water Festival
         bon_om_touk = tr("ព្រះរាជពិធីបុណ្យអុំទូក បណ្តែតប្រទីប និងសំពះព្រះខែអកអំបុក")
         bon_om_touk_date = self._add_loy_krathong(bon_om_touk)
-        if bon_om_touk_date:
-            self._add_holiday(bon_om_touk, _timedelta(bon_om_touk_date, -1))
-            self._add_holiday(bon_om_touk, _timedelta(bon_om_touk_date, +1))
+        self._add_holiday(bon_om_touk, _timedelta(bon_om_touk_date, -1))
+        self._add_holiday(bon_om_touk, _timedelta(bon_om_touk_date, +1))
 
 
 class KH(Cambodia):
diff --git a/holidays/countries/thailand.py b/holidays/countries/thailand.py
index 9ccd2e07..37c99f64 100644
--- a/holidays/countries/thailand.py
+++ b/holidays/countries/thailand.py
@@ -19,11 +19,11 @@ from holidays.groups import InternationalHolidays, StaticHolidays, ThaiCalendarH
 from holidays.observed_holiday_base import (
     ObservedHolidayBase,
     SAT_TO_NEXT_MON,
-    SAT_TO_NEXT_TUE,
-    THU_FRI_TO_NEXT_MON,
+    THU_FRI_TO_NEXT_WORKDAY,
     SAT_SUN_TO_NEXT_MON,
     SAT_SUN_TO_NEXT_TUE,
     SAT_SUN_TO_NEXT_MON_TUE,
+    SAT_SUN_TO_NEXT_WORKDAY,
 )
 
 
@@ -39,6 +39,7 @@ class Thailand(ObservedHolidayBase, InternationalHolidays, StaticHolidays, ThaiC
             - https://resolution.soc.go.th/?prep_id=99159317
             - https://resolution.soc.go.th/?prep_id=196007
             - https://github.com/vacanza/holidays/pull/929
+            - https://www.thairath.co.th/lifestyle/life/2812118
         - [New Year's Day]
             `wikisource.org <http://tiny.cc/wa_wiki_thai_newyear_2483>`_
         - [National Children's Day]
@@ -95,6 +96,7 @@ class Thailand(ObservedHolidayBase, InternationalHolidays, StaticHolidays, ThaiC
             https://dl.parliament.go.th/handle/20.500.13072/92816
             https://e-manage.mju.ac.th/timeline_detail.aspx?key=MTk4
             https://resolution.soc.go.th/PDF_UPLOAD/2510/932141.pdf
+            https://www.myhora.com/ปฏิทิน/วันพืชมงคล.aspx
         - [Royal Thai Armed Forces Day]
             `<https://th.wikipedia.org/wiki/วันกองทัพไทย>`_
         - [Teacher's Day]
@@ -115,7 +117,7 @@ class Thailand(ObservedHolidayBase, InternationalHolidays, StaticHolidays, ThaiC
             Applied Automatically for Workday if on Weekends: 2001-Present
 
     Limitations:
-        - This is only 100% accurate for 1997-2024; any future dates are up to the
+        - This is only 100% accurate for 1997-2025; any future dates are up to the
           Royal Thai Government Gazette which updates on a year-by-year basis.
 
         - Approx. date only goes as far back as 1941 (B.E. 2484) as the Thai
@@ -129,8 +131,6 @@ class Thailand(ObservedHolidayBase, InternationalHolidays, StaticHolidays, ThaiC
         - Royal Ploughing Ceremony Day is date is announced on an annual basis
           by the Court Astrologers, thus need an annual update to the library here
 
-        - This doesn't cover Thai regional public holidays yet, only stubs added
-
     Country created by: `arkid15r <https://github.com/arkid15r>`__
 
     Country maintained by: `PPsyrius <https://github.com/PPsyrius>`__
@@ -221,15 +221,16 @@ class Thailand(ObservedHolidayBase, InternationalHolidays, StaticHolidays, ThaiC
 
             # วันหยุดชดเชยวันสงกรานต์
             # If Songkran happened to be held on the weekends, only one in-lieu
-            #   public holiday is added, No in lieus for SUN-MON-TUE case.
+            #   public holiday is added.
             #   - CASE 1: THU-FRI-SAT -> 1 in-lieu on MON
             #   - CASE 2: FRI-SAT-SUN -> 1 in-lieu on MON
             #   - CASE 3: SAT-SUN-MON -> 1 in-lieu on TUE
+            #   - CASE 4: SUN-MON-TUE -> 1 in-lieu on WED
             # See in lieu logic in `_add_observed(dt: date)`.
             # Status: In Use.
 
             if self._year >= 1995:
-                self._add_observed(dt, rule=THU_FRI_TO_NEXT_MON + SAT_TO_NEXT_TUE)
+                self._add_observed(dt, rule=THU_FRI_TO_NEXT_WORKDAY + SAT_SUN_TO_NEXT_WORKDAY)
 
         # วันแรงงานแห่งชาติ
         # Status: In-Use.
@@ -433,17 +434,13 @@ class Thailand(ObservedHolidayBase, InternationalHolidays, StaticHolidays, ThaiC
         # Status: In-Use.
 
         # Makha Bucha.
-        makha_bucha_date = self._add_makha_bucha(tr("วันมาฆบูชา"))
-        if makha_bucha_date:
-            self._add_observed(makha_bucha_date)
+        self._add_observed(self._add_makha_bucha(tr("วันมาฆบูชา")))
 
         # วันวิสาขบูชา
         # Status: In-Use.
 
         # Visakha Bucha.
-        visakha_bucha_date = self._add_visakha_bucha(tr("วันวิสาขบูชา"))
-        if visakha_bucha_date:
-            self._add_observed(visakha_bucha_date)
+        self._add_observed(self._add_visakha_bucha(tr("วันวิสาขบูชา")))
 
         # วันอาสาฬหบูชา
         # Status: In-Use.
@@ -452,9 +449,9 @@ class Thailand(ObservedHolidayBase, InternationalHolidays, StaticHolidays, ThaiC
         #  - CASE 3: SUN-MON -> 1 in-lieu on TUE
 
         # Asarnha Bucha.
-        asarnha_bucha_date = self._add_asarnha_bucha(tr("วันอาสาฬหบูชา"))
-        if asarnha_bucha_date:
-            self._add_observed(asarnha_bucha_date, rule=SAT_SUN_TO_NEXT_MON_TUE)
+        self._add_observed(
+            self._add_asarnha_bucha(tr("วันอาสาฬหบูชา")), rule=SAT_SUN_TO_NEXT_MON_TUE
+        )
 
         # วันเข้าพรรษา
         # Status: In-Use.
@@ -463,9 +460,7 @@ class Thailand(ObservedHolidayBase, InternationalHolidays, StaticHolidays, ThaiC
         #  - CASE 3: SUN-MON -> 1 in-lieu on TUE
 
         # Buddhist Lent Day.
-        khao_phansa_date = self._add_khao_phansa(tr("วันเข้าพรรษา"))
-        if khao_phansa_date:
-            self._add_observed(khao_phansa_date, rule=SAT_TO_NEXT_MON)
+        self._add_observed(self._add_khao_phansa(tr("วันเข้าพรรษา")), rule=SAT_TO_NEXT_MON)
 
     def _populate_armed_forces_holidays(self):
         # วันกองทัพไทย
@@ -525,8 +520,9 @@ class Thailand(ObservedHolidayBase, InternationalHolidays, StaticHolidays, ThaiC
         # Is dated on an annual basis by the Royal Palace, always on weekdays.
         # For historic research, วันเกษตรแห่งชาติ (National Agricultural Day) also concides with
         #   this from 1966 onwards. For earlier records the date was refered as วันแรกนาขวัญ.
-        # This isn't even fixed even by the Thai Lunar Calendar, but instead
-        #   by Court Astrologers; All chosen dates are all in the first three weeks of May.
+        # This isn't even fixed even by the Thai Lunar Calendar besides being in Month 6
+        #   to concides with the rainy season, but instead by Court Astrologers; All chosen dates
+        #   so far are all in the first three weeks of May.
         # *** NOTE: only observed by government sectors.
         # TODO: Update this annually around Dec of each year.
 
@@ -597,8 +593,9 @@ class Thailand(ObservedHolidayBase, InternationalHolidays, StaticHolidays, ThaiC
             2022: (MAY, 13),
             2023: (MAY, 17),
             2024: (MAY, 10),
+            2025: (MAY, 9),
         }
-        if 1960 <= self._year <= 2024 and self._year != 1999:
+        if 1960 <= self._year <= 2025 and self._year != 1999:
             self._add_observed(
                 # Royal Ploughing Ceremony.
                 self._add_holiday(tr("วันพืชมงคล"), raeknakhwan_dates.get(self._year, (MAY, 13)))
diff --git a/snapshots/countries/TH_COMMON.json b/snapshots/countries/TH_COMMON.json
index 429cdc34..debc0c28 100644
--- a/snapshots/countries/TH_COMMON.json
+++ b/snapshots/countries/TH_COMMON.json
@@ -1287,6 +1287,7 @@
     "2003-04-13": "Songkran Festival",
     "2003-04-14": "Songkran Festival",
     "2003-04-15": "Songkran Festival",
+    "2003-04-16": "Songkran Festival (in lieu)",
     "2003-05-01": "National Labor Day",
     "2003-05-05": "Coronation Day",
     "2003-05-08": "Royal Ploughing Ceremony",
@@ -1463,6 +1464,7 @@
     "2008-04-13": "Songkran Festival",
     "2008-04-14": "Songkran Festival",
     "2008-04-15": "Songkran Festival",
+    "2008-04-16": "Songkran Festival (in lieu)",
     "2008-05-01": "National Labor Day",
     "2008-05-05": "Coronation Day",
     "2008-05-09": "Royal Ploughing Ceremony",
@@ -1677,6 +1679,7 @@
     "2014-04-13": "Songkran Festival",
     "2014-04-14": "Songkran Festival",
     "2014-04-15": "Songkran Festival",
+    "2014-04-16": "Songkran Festival (in lieu)",
     "2014-05-01": "National Labor Day",
     "2014-05-05": "Coronation Day",
     "2014-05-09": "Royal Ploughing Ceremony",
@@ -2087,9 +2090,11 @@
     "2025-04-13": "Songkran Festival",
     "2025-04-14": "Songkran Festival",
     "2025-04-15": "Songkran Festival",
+    "2025-04-16": "Songkran Festival (in lieu)",
     "2025-05-01": "National Labor Day",
     "2025-05-04": "Coronation Day",
     "2025-05-05": "Coronation Day (in lieu)",
+    "2025-05-09": "Royal Ploughing Ceremony",
     "2025-05-11": "Visakha Bucha",
     "2025-05-12": "Visakha Bucha (in lieu)",
     "2025-06-03": "HM Queen Suthida's Birthday",
@@ -2301,6 +2306,7 @@
     "2031-04-13": "Songkran Festival",
     "2031-04-14": "Songkran Festival",
     "2031-04-15": "Songkran Festival",
+    "2031-04-16": "Songkran Festival (in lieu)",
     "2031-05-01": "National Labor Day",
     "2031-05-04": "Coronation Day",
     "2031-05-05": "Coronation Day (in lieu)",
@@ -2480,6 +2486,7 @@
     "2036-04-13": "Songkran Festival",
     "2036-04-14": "Songkran Festival",
     "2036-04-15": "Songkran Festival",
+    "2036-04-16": "Songkran Festival (in lieu)",
     "2036-05-01": "National Labor Day",
     "2036-05-04": "Coronation Day",
     "2036-05-05": "Coronation Day (in lieu)",
@@ -2691,6 +2698,7 @@
     "2042-04-13": "Songkran Festival",
     "2042-04-14": "Songkran Festival",
     "2042-04-15": "Songkran Festival",
+    "2042-04-16": "Songkran Festival (in lieu)",
     "2042-05-01": "National Labor Day",
     "2042-05-04": "Coronation Day",
     "2042-05-05": "Coronation Day (in lieu)",


Test patch:
diff --git a/tests/calendars/test_thai.py b/tests/calendars/test_thai.py
index c2a2a380..6bf6531d 100644
--- a/tests/calendars/test_thai.py
+++ b/tests/calendars/test_thai.py
@@ -14,7 +14,7 @@ import unittest
 from datetime import date
 
 from holidays import calendars
-from holidays.calendars.gregorian import FEB, MAR, MAY, JUN, JUL, AUG, SEP, OCT, NOV
+from holidays.calendars.gregorian import JAN, FEB, MAR, APR, MAY, JUN, JUL, AUG, SEP, OCT, NOV
 from holidays.calendars.thai import KHMER_CALENDAR
 
 
@@ -31,10 +31,26 @@ class TestThaiLunisolarCalendar(unittest.TestCase):
         asarnha_bucha_year_date = {
             self.calendar.START_YEAR - 1: None,
             self.calendar.END_YEAR + 1: None,
+            2010: date(2010, JUL, 26),
+            2011: date(2011, JUL, 15),
+            2012: date(2012, AUG, 2),
+            2013: date(2013, JUL, 22),
+            2014: date(2014, JUL, 11),
+            2015: date(2015, JUL, 30),
+            2016: date(2016, JUL, 19),
+            2017: date(2017, JUL, 8),
+            2018: date(2018, JUL, 27),
+            2019: date(2019, JUL, 16),
+            2020: date(2020, JUL, 5),
+            2021: date(2021, JUL, 24),
             2022: date(2022, JUL, 13),
             2023: date(2023, AUG, 1),
             2024: date(2024, JUL, 20),
             2025: date(2025, JUL, 10),
+            2026: date(2026, JUL, 29),
+            2027: date(2027, JUL, 18),
+            2028: date(2028, JUL, 6),
+            2029: date(2029, JUL, 25),
             2030: date(2030, JUL, 14),
             2040: date(2040, JUL, 23),
             2050: date(2050, AUG, 2),
@@ -148,10 +164,26 @@ class TestThaiLunisolarCalendar(unittest.TestCase):
         khao_phansa_year_date = {
             self.calendar.START_YEAR - 1: None,
             self.calendar.END_YEAR + 1: None,
+            2010: date(2010, JUL, 27),
+            2011: date(2011, JUL, 16),
+            2012: date(2012, AUG, 3),
+            2013: date(2013, JUL, 23),
+            2014: date(2014, JUL, 12),
+            2015: date(2015, JUL, 31),
+            2016: date(2016, JUL, 20),
+            2017: date(2017, JUL, 9),
+            2018: date(2018, JUL, 28),
+            2019: date(2019, JUL, 17),
+            2020: date(2020, JUL, 6),
+            2021: date(2021, JUL, 25),
             2022: date(2022, JUL, 14),
             2023: date(2023, AUG, 2),
             2024: date(2024, JUL, 21),
             2025: date(2025, JUL, 11),
+            2026: date(2026, JUL, 30),
+            2027: date(2027, JUL, 19),
+            2028: date(2028, JUL, 7),
+            2029: date(2029, JUL, 26),
             2030: date(2030, JUL, 15),
             2040: date(2040, JUL, 24),
             2050: date(2050, AUG, 3),
@@ -176,6 +208,13 @@ class TestThaiLunisolarCalendar(unittest.TestCase):
         loy_krathong_year_date = {
             self.calendar.START_YEAR - 1: None,
             self.calendar.END_YEAR + 1: None,
+            2015: date(2015, NOV, 25),
+            2016: date(2016, NOV, 14),
+            2017: date(2017, NOV, 3),
+            2018: date(2018, NOV, 22),
+            2019: date(2019, NOV, 11),
+            2020: date(2020, OCT, 31),
+            2021: date(2021, NOV, 19),
             2022: date(2022, NOV, 8),
             2023: date(2023, NOV, 27),
             2024: date(2024, NOV, 15),
@@ -205,10 +244,26 @@ class TestThaiLunisolarCalendar(unittest.TestCase):
         makha_bucha_year_date = {
             self.calendar.START_YEAR - 1: None,
             self.calendar.END_YEAR + 1: None,
+            2010: date(2010, FEB, 28),
+            2011: date(2011, FEB, 18),
+            2012: date(2012, MAR, 7),
+            2013: date(2013, FEB, 25),
+            2014: date(2014, FEB, 14),
+            2015: date(2015, MAR, 4),
+            2016: date(2016, FEB, 22),
+            2017: date(2017, FEB, 11),
+            2018: date(2018, MAR, 1),
+            2019: date(2019, FEB, 19),
+            2020: date(2020, FEB, 8),
+            2021: date(2021, FEB, 26),
             2022: date(2022, FEB, 16),
             2023: date(2023, MAR, 6),
             2024: date(2024, FEB, 24),
             2025: date(2025, FEB, 12),
+            2026: date(2026, MAR, 3),
+            2027: date(2027, FEB, 21),
+            2028: date(2028, FEB, 10),
+            2029: date(2029, FEB, 27),
             2030: date(2030, FEB, 17),
             2040: date(2040, FEB, 26),
             2050: date(2050, MAR, 7),
@@ -229,6 +284,11 @@ class TestThaiLunisolarCalendar(unittest.TestCase):
         meak_bochea_year_date = {
             self.calendar.START_YEAR - 1: None,
             self.calendar.END_YEAR + 1: None,
+            2015: date(2015, FEB, 3),
+            2016: date(2016, FEB, 22),
+            2017: date(2017, FEB, 11),
+            2018: date(2018, JAN, 31),
+            2019: date(2019, FEB, 19),
             2022: date(2022, FEB, 16),
             2023: date(2023, FEB, 5),
             2024: date(2024, FEB, 24),
@@ -272,6 +332,13 @@ class TestThaiLunisolarCalendar(unittest.TestCase):
         pchum_ben_year_date = {
             self.calendar.START_YEAR - 1: None,
             self.calendar.END_YEAR + 1: None,
+            2015: date(2015, OCT, 12),
+            2016: date(2016, OCT, 1),
+            2017: date(2017, SEP, 20),
+            2018: date(2018, OCT, 9),
+            2019: date(2019, SEP, 28),
+            2020: date(2020, SEP, 17),
+            2021: date(2021, OCT, 6),
             2022: date(2022, SEP, 25),
             2023: date(2023, OCT, 14),
             2024: date(2024, OCT, 2),
@@ -287,6 +354,13 @@ class TestThaiLunisolarCalendar(unittest.TestCase):
         preah_neangkoal_year_date = {
             self.calendar.START_YEAR - 1: None,
             self.calendar.END_YEAR + 1: None,
+            2015: date(2015, MAY, 6),
+            2016: date(2016, MAY, 24),
+            2017: date(2017, MAY, 14),
+            2018: date(2018, MAY, 3),
+            2019: date(2019, MAY, 22),
+            2020: date(2020, MAY, 10),
+            2021: date(2021, APR, 30),
             2022: date(2022, MAY, 19),
             2023: date(2023, MAY, 8),
             2024: date(2024, MAY, 26),
@@ -303,10 +377,26 @@ class TestThaiLunisolarCalendar(unittest.TestCase):
         visakha_bucha_year_date = {
             self.calendar.START_YEAR - 1: None,
             self.calendar.END_YEAR + 1: None,
+            2010: date(2010, MAY, 28),
+            2011: date(2011, MAY, 17),
+            2012: date(2012, JUN, 4),
+            2013: date(2013, MAY, 24),
+            2014: date(2014, MAY, 13),
+            2015: date(2015, JUN, 1),
+            2016: date(2016, MAY, 20),
+            2017: date(2017, MAY, 10),
+            2018: date(2018, MAY, 29),
+            2019: date(2019, MAY, 18),
+            2020: date(2020, MAY, 6),
+            2021: date(2021, MAY, 26),
             2022: date(2022, MAY, 15),
             2023: date(2023, JUN, 3),
             2024: date(2024, MAY, 22),
             2025: date(2025, MAY, 11),
+            2026: date(2026, MAY, 31),
+            2027: date(2027, MAY, 20),
+            2028: date(2028, MAY, 8),
+            2029: date(2029, MAY, 27),
             2030: date(2030, MAY, 16),
             2040: date(2040, MAY, 25),
             2050: date(2050, JUN, 4),
@@ -330,6 +420,13 @@ class TestThaiLunisolarCalendar(unittest.TestCase):
         visaka_bochea_year_date = {
             self.calendar.START_YEAR - 1: None,
             self.calendar.END_YEAR + 1: None,
+            2015: date(2015, MAY, 2),
+            2016: date(2016, MAY, 20),
+            2017: date(2017, MAY, 10),
+            2018: date(2018, APR, 29),
+            2019: date(2019, MAY, 18),
+            2020: date(2020, MAY, 6),
+            2021: date(2021, APR, 26),
             2022: date(2022, MAY, 15),
             2023: date(2023, MAY, 4),
             2024: date(2024, MAY, 22),
diff --git a/tests/countries/test_cambodia.py b/tests/countries/test_cambodia.py
index deee1ee7..9160fecc 100644
--- a/tests/countries/test_cambodia.py
+++ b/tests/countries/test_cambodia.py
@@ -19,7 +19,7 @@ from tests.common import CommonCountryTests
 class TestCambodia(CommonCountryTests, TestCase):
     @classmethod
     def setUpClass(cls):
-        super().setUpClass(Cambodia, years=list(range(1993, 2059)) + [2158])
+        super().setUpClass(Cambodia, years=range(1993, 2050))
 
     def test_country_aliases(self):
         self.assertAliases(Cambodia, KH, KHM)
@@ -136,11 +136,11 @@ class TestCambodia(CommonCountryTests, TestCase):
 
     def test_day_of_victory_over_genocidal_regime(self):
         self.assertHolidayName(
-            "ទិវាជ័យជម្នះលើរបបប្រល័យពូជសាសន៍", (f"{year}-01-07" for year in range(1993, 2058))
+            "ទិវាជ័យជម្នះលើរបបប្រល័យពូជសាសន៍", (f"{year}-01-07" for year in range(1993, 2050))
         )
 
     def test_sangkranta(self):
-        sangkranta_years_apr14 = {
+        years_sangkranta_apr14 = {
             2017,
             2018,
             2021,
@@ -153,8 +153,8 @@ class TestCambodia(CommonCountryTests, TestCase):
             2030,
             2031,
         }
-        for year in set(range(1993, 2058)).difference({2020}):
-            if year in sangkranta_years_apr14:
+        for year in set(range(1993, 2050)).difference({2020}):
+            if year in years_sangkranta_apr14:
                 self.assertHoliday(f"{year}-04-14", f"{year}-04-15", f"{year}-04-16")
             else:
                 self.assertHoliday(f"{year}-04-13", f"{year}-04-14", f"{year}-04-15")
@@ -163,7 +163,7 @@ class TestCambodia(CommonCountryTests, TestCase):
         name = "ព្រះរាជពិធីបុណ្យចម្រើនព្រះជន្ម ព្រះករុណា ព្រះបាទសម្តេចព្រះបរមនាថ នរោត្តម សីហមុនី"
         self.assertNoHolidayName(name, 2004)
         self.assertHolidayName(name, (f"{year}-05-13" for year in range(2005, 2020)))
-        self.assertHolidayName(name, (f"{year}-05-14" for year in range(2005, 2058)))
+        self.assertHolidayName(name, (f"{year}-05-14" for year in range(2005, 2050)))
         self.assertHolidayName(name, (f"{year}-05-15" for year in range(2005, 2020)))
 
     def test_national_day_of_remembrance(self):
@@ -180,11 +180,11 @@ class TestCambodia(CommonCountryTests, TestCase):
     def test_queen_mother_monineath_birthday(self):
         name = "ព្រះរាជពិធីបុណ្យចម្រើនព្រះជន្ម សម្តេចព្រះមហាក្សត្រី ព្រះវររាជមាតា នរោត្តម មុនិនាថ សីហនុ"
         self.assertNoHolidayName(name, 1993)
-        self.assertHolidayName(name, (f"{year}-06-18" for year in range(1994, 2058)))
+        self.assertHolidayName(name, (f"{year}-06-18" for year in range(1994, 2050)))
 
     def test_constitution_day(self):
         self.assertHolidayName(
-            "ទិវាប្រកាសរដ្ឋធម្មនុញ្ញ", (f"{year}-09-24" for year in range(1993, 2058))
+            "ទិវាប្រកាសរដ្ឋធម្មនុញ្ញ", (f"{year}-09-24" for year in range(1993, 2050))
         )
 
     def test_king_sihanouk_memorial_day(self):
@@ -194,7 +194,7 @@ class TestCambodia(CommonCountryTests, TestCase):
             " និងឯកភាពជាតិខ្មែរ ព្រះបរមរតនកោដ្ឋ"
         )
         self.assertNoHolidayName(name, 2011)
-        self.assertHolidayName(name, (f"{year}-10-15" for year in range(2012, 2058)))
+        self.assertHolidayName(name, (f"{year}-10-15" for year in range(2012, 2050)))
 
     def test_paris_peace_agreement_day(self):
         name = "ទិវារំលឹកសន្ធិសញ្ញាសន្តិភាពទីក្រុងប៉ារីស"
@@ -208,60 +208,16 @@ class TestCambodia(CommonCountryTests, TestCase):
             "ព្រះមហាក្សត្រនៃព្រះរាជាណាចក្រកម្ពុជា"
         )
         self.assertNoHolidayName(name, 2003)
-        self.assertHolidayName(name, (f"{year}-10-29" for year in range(2004, 2058)))
+        self.assertHolidayName(name, (f"{year}-10-29" for year in range(2004, 2050)))
 
     def test_national_independence_day(self):
-        self.assertHolidayName("ពិធីបុណ្យឯករាជ្យជាតិ", (f"{year}-11-09" for year in range(1993, 2058)))
+        self.assertHolidayName("ពិធីបុណ្យឯករាជ្យជាតិ", (f"{year}-11-09" for year in range(1993, 2050)))
 
     def test_international_human_rights_day(self):
         name = "ទិវាសិទ្ធិមនុស្សអន្តរជាតិ"
         self.assertHolidayName(name, (f"{year}-12-10" for year in range(1993, 2020)))
         self.assertNoHolidayName(name, 2020)
 
-    def test_meak_bochea(self):
-        name = "ពិធីបុណ្យមាឃបូជា"
-        self.assertHolidayName(
-            name,
-            "2015-02-03",
-            "2016-02-22",
-            "2017-02-11",
-            "2018-01-31",
-            "2019-02-19",
-        )
-        self.assertNoHolidayName(name, 2158)
-
-    def test_visaka_bochea(self):
-        name = "ពិធីបុណ្យវិសាខបូជា"
-        self.assertHolidayName(
-            name,
-            "2015-05-02",
-            "2016-05-20",
-            "2017-05-10",
-            "2018-04-29",
-            "2019-05-18",
-            "2020-05-06",
-            "2021-04-26",
-            "2022-05-15",
-            "2023-05-04",
-        )
-        self.assertNoHolidayName(name, 2158)
-
-    def test_preah_neangkoal(self):
-        name = "ព្រះរាជពិធីច្រត់ព្រះនង្គ័ល"
-        self.assertHolidayName(
-            name,
-            "2015-05-06",
-            "2016-05-24",
-            "2017-05-14",
-            "2018-05-03",
-            "2019-05-22",
-            "2020-05-10",
-            "2021-04-30",
-            "2022-05-19",
-            "2023-05-08",
-        )
-        self.assertNoHolidayName(name, 2158)
-
     def test_pchum_ben(self):
         name = "ពិធីបុណ្យភ្ផុំបិណ្ឌ"
         self.assertHolidayName(
@@ -294,7 +250,6 @@ class TestCambodia(CommonCountryTests, TestCase):
             "2023-10-14",
             "2023-10-15",
         )
-        self.assertNoHolidayName(name, 2158)
 
     def test_bon_om_touk(self):
         name = "ព្រះរាជពិធីបុណ្យអុំទូក បណ្តែតប្រទីប និងសំពះព្រះខែអកអំបុក"
diff --git a/tests/countries/test_laos.py b/tests/countries/test_laos.py
index a1031f98..1c931bb3 100644
--- a/tests/countries/test_laos.py
+++ b/tests/countries/test_laos.py
@@ -20,7 +20,7 @@ from tests.common import CommonCountryTests
 class TestLaos(CommonCountryTests, TestCase):
     @classmethod
     def setUpClass(cls):
-        super().setUpClass(Laos, years=range(1976, 2058), years_non_observed=range(2018, 2058))
+        super().setUpClass(Laos, years=range(1976, 2050), years_non_observed=range(2018, 2050))
 
     def test_country_aliases(self):
         self.assertAliases(Laos, LA, LAO)
@@ -92,7 +92,7 @@ class TestLaos(CommonCountryTests, TestCase):
         )
 
     def test_new_years_day(self):
-        self.assertHoliday(f"{year}-01-01" for year in range(1976, 2058))
+        self.assertHoliday(f"{year}-01-01" for year in range(1976, 2050))
 
         self.assertNoNonObservedHoliday(
             "2012-01-02",
@@ -102,7 +102,7 @@ class TestLaos(CommonCountryTests, TestCase):
         )
 
     def test_international_women_rights_day(self):
-        self.assertHoliday(f"{year}-03-08" for year in range(1976, 2058))
+        self.assertHoliday(f"{year}-03-08" for year in range(1976, 2050))
 
         self.assertNoNonObservedHoliday(
             "2015-03-09",
@@ -112,7 +112,7 @@ class TestLaos(CommonCountryTests, TestCase):
     def test_laos_new_year_day(self):
         songkran_years_apr_13_15 = {2012, 2017}
         songkran_years_apr_13_16 = {2016, 2020, 2024}
-        for year in range(1976, 2058):
+        for year in range(1976, 2050):
             if year in songkran_years_apr_13_15:
                 self.assertHoliday(f"{year}-04-13", f"{year}-04-14", f"{year}-04-15")
             elif year in songkran_years_apr_13_16:
@@ -142,7 +142,7 @@ class TestLaos(CommonCountryTests, TestCase):
         )
 
     def test_labor_day(self):
-        self.assertHoliday(f"{year}-05-01" for year in range(1976, 2058))
+        self.assertHoliday(f"{year}-05-01" for year in range(1976, 2050))
 
         self.assertNoNonObservedHoliday(
             "2016-05-02",
@@ -154,7 +154,7 @@ class TestLaos(CommonCountryTests, TestCase):
         self.assertHoliday(f"{year}-06-01" for year in range(1990, 2018))
 
     def test_lao_national_day(self):
-        self.assertHoliday(f"{year}-12-02" for year in range(1976, 2058))
+        self.assertHoliday(f"{year}-12-02" for year in range(1976, 2050))
 
         self.assertNoNonObservedHoliday(
             "2012-12-03",
diff --git a/tests/countries/test_thailand.py b/tests/countries/test_thailand.py
index 1ed5df75..6a4ab287 100644
--- a/tests/countries/test_thailand.py
+++ b/tests/countries/test_thailand.py
@@ -20,19 +20,17 @@ from tests.common import CommonCountryTests
 class TestThailand(CommonCountryTests, TestCase):
     @classmethod
     def setUpClass(cls):
-        support_range = list(range(1941, 2059)) + [2158]
+        support_range = range(1941, 2050)
         super().setUpClass(Thailand, years=support_range, years_non_observed=support_range)
 
     def test_country_aliases(self):
         self.assertAliases(Thailand, TH, THA)
 
     def test_no_holidays(self):
-        self.assertNoHolidays(Thailand(years=1940))
-        self.assertNoHolidays(Thailand(years=1958, categories=ARMED_FORCES))
+        self.assertNoHolidays(Thailand(years=1940, categories=(PUBLIC, WORKDAY)))
         self.assertNoHolidays(Thailand(years=1942, categories=BANK))
-        self.assertNoHolidays(Thailand(years=1956, categories=GOVERNMENT))
-        self.assertNoHolidays(Thailand(years=1956, categories=SCHOOL))
-        self.assertNoHolidays(Thailand(years=1940, categories=WORKDAY))
+        self.assertNoHolidays(Thailand(years=1956, categories=(GOVERNMENT, SCHOOL)))
+        self.assertNoHolidays(Thailand(years=1958, categories=ARMED_FORCES))
 
     def test_special_holidays(self):
         dt = (
@@ -117,72 +115,9 @@ class TestThailand(CommonCountryTests, TestCase):
         self.assertHoliday(dt, dt_observed)
         self.assertNoNonObservedHoliday(dt_observed)
 
-    def test_2022_all(self):
-        self.assertHolidays(
-            Thailand(categories=(ARMED_FORCES, GOVERNMENT, PUBLIC, SCHOOL, WORKDAY), years=2022),
-            ("2022-01-01", "วันขึ้นปีใหม่"),
-            ("2022-01-03", "ชดเชยวันขึ้นปีใหม่"),
-            ("2022-01-08", "วันเด็กแห่งชาติ"),
-            ("2022-01-13", "วันการบินแห่งชาติ"),
-            ("2022-01-14", "วันอนุรักษ์ทรัพยากรป่าไม้ของชาติ"),
-            ("2022-01-16", "วันครู"),
-            ("2022-01-17", "วันพ่อขุนรามคำแหงมหาราช"),
-            ("2022-01-18", "วันกองทัพไทย"),
-            ("2022-02-03", "วันทหารผ่านศึก"),
-            ("2022-02-16", "วันมาฆบูชา"),
-            ("2022-02-26", "วันศิลปินแห่งชาติ"),
-            ("2022-03-08", "วันสตรีสากล"),
-            ("2022-04-06", "วันจักรี"),
-            ("2022-04-13", "วันสงกรานต์"),
-            ("2022-04-14", "วันสงกรานต์"),
-            ("2022-04-15", "วันสงกรานต์"),
-            ("2022-05-01", "วันแรงงานแห่งชาติ"),
-            ("2022-05-02", "ชดเชยวันแรงงานแห่งชาติ"),
-            ("2022-05-04", "วันฉัตรมงคล"),
-            ("2022-05-13", "วันพืชมงคล"),
-            ("2022-05-15", "วันวิสาขบูชา"),
-            ("2022-05-16", "ชดเชยวันวิสาขบูชา"),
-            (
-                "2022-06-03",
-                "วันเฉลิมพระชนมพรรษาสมเด็จพระนางเจ้าสุทิดา พัชรสุธาพิมลลักษณ พระบรมราชินี",
-            ),
-            ("2022-07-13", "วันอาสาฬหบูชา"),
-            ("2022-07-14", "วันเข้าพรรษา"),
-            ("2022-07-15", "วันหยุดพิเศษ (เพิ่มเติม)"),
-            (
-                "2022-07-28",
-                (
-                    "วันเฉลิมพระชนมพรรษาพระบาทสมเด็จพระปรเมนทรรามาธิบดี"
-                    "ศรีสินทรมหาวชิราลงกรณ พระวชิรเกล้าเจ้าอยู่หัว"
-                ),
-            ),
-            ("2022-07-29", "วันหยุดพิเศษ (เพิ่มเติม)"),
-            ("2022-08-12", "วันเฉลิมพระชนมพรรษาสมเด็จพระบรมราชชนนีพันปีหลวง; วันแม่แห่งชาติ"),
-            ("2022-08-18", "วันวิทยาศาสตร์แห่งชาติ"),
-            ("2022-09-28", "วันพระราชทานธงชาติไทย"),
-            (
-                "2022-10-13",
-                "วันคล้ายวันสวรรคตพระบาทสมเด็จพระบรมชนกาธิเบศร มหาภูมิพลอดุลยเดชมหาราช บรมนาถบพิตร",
-            ),
-            ("2022-10-14", "วันหยุดพิเศษ (เพิ่มเติม)"),
-            ("2022-10-23", "วันปิยมหาราช"),
-            ("2022-10-24", "ชดเชยวันปิยมหาราช"),
-            ("2022-11-08", "วันลอยกระทง"),
-            (
-                "2022-12-05",
-                (
-                    "วันคล้ายวันเฉลิมพระชนมพรรษาพระบาทสมเด็จพระบรมชนกาธิเบศร "
-                    "มหาภูมิพลอดุลยเดชมหาราช บรมนาถบพิตร; วันชาติ; วันพ่อแห่งชาติ"
-                ),
-            ),
-            ("2022-12-10", "วันรัฐธรรมนูญ"),
-            ("2022-12-12", "ชดเชยวันรัฐธรรมนูญ"),
-            ("2022-12-30", "วันหยุดพิเศษ (เพิ่มเติม)"),
-            ("2022-12-31", "วันสิ้นปี"),
-        )
-
     def test_new_years_day(self):
-        self.assertHoliday(f"{year}-01-01" for year in range(1941, 2058))
+        name = "วันขึ้นปีใหม่"
+        self.assertHolidayName(name, (f"{year}-01-01" for year in range(1941, 2050)))
 
         self.assertNoNonObservedHoliday(
             "2011-01-03",
@@ -195,7 +130,6 @@ class TestThailand(CommonCountryTests, TestCase):
 
     def test_national_childrens_day(self):
         name = "วันเด็กแห่งชาติ"
-
         dt = (
             # First Iteration
             "1955-10-03",
@@ -218,10 +152,11 @@ class TestThailand(CommonCountryTests, TestCase):
             "2025-01-11",
         )
         self.assertHolidayName(name, dt)
-        self.assertNoHolidayName(name, 1954, 1964)
+        self.assertNoHolidayName(name, range(1941, 1955), 1964)
 
     def test_chakri_memorial_day(self):
-        self.assertHoliday(f"{year}-04-06" for year in range(1941, 2058))
+        name = "วันจักรี"
+        self.assertHolidayName(name, (f"{year}-04-06" for year in range(1941, 2050)))
 
         self.assertNoNonObservedHoliday(
             "2013-04-08",
@@ -234,29 +169,29 @@ class TestThailand(CommonCountryTests, TestCase):
 
     def test_songkran_festival(self):
         name = "วันสงกรานต์"
-
-        self.assertNoHolidayName(name, 1947)
-        for year in range(1948, 1954):
-            self.assertHoliday(f"{year}-04-13", f"{year}-04-14", f"{year}-04-15")
-        self.assertNoHolidayName(name, range(1954, 1957))
-        self.assertHolidayName(name, (f"{year}-04-13" for year in range(1957, 1989)))
+        # APR 13-14-15
+        for year in [*range(1948, 1954), *range(1998, 2020), *range(2021, 2050)]:
+            self.assertHolidayName(name, (f"{year}-04-13", f"{year}-04-14", f"{year}-04-15"))
+        # APR 12-13-14
         for year in range(1989, 1998):
-            self.assertHoliday(f"{year}-04-12", f"{year}-04-13", f"{year}-04-14")
-        for year in range(1998, 2020):
-            self.assertHoliday(f"{year}-04-13", f"{year}-04-14", f"{year}-04-15")
-        self.assertNoHoliday("2020-04-13", "2020-04-14", "2020-04-15")
-        for year in range(2021, 2058):
-            self.assertHoliday(f"{year}-04-13", f"{year}-04-14", f"{year}-04-15")
+            self.assertHolidayName(name, (f"{year}-04-12", f"{year}-04-13", f"{year}-04-14"))
+        # APR 13
+        self.assertHolidayName(name, (f"{year}-04-13" for year in range(1957, 1989)))
+        # None (2020 is special_public_holidays instead)
+        self.assertNoHolidayName(name, "2020-04-13", "2020-04-14", "2020-04-15")
+        self.assertNoHolidayName(name, range(1941, 1948), range(1954, 1957))
 
         self.assertNoNonObservedHoliday(
             "2012-04-16",
             "2013-04-16",
+            "2014-04-16",
             "2017-04-17",
             "2018-04-16",
             "2019-04-16",
             # 2020 Songkran Festival special in lieus doesn't counts
             "2023-04-17",
             "2024-04-16",
+            "2025-04-16",
             "2028-04-17",
             "2029-04-16",
             "2030-04-16",
@@ -264,10 +199,8 @@ class TestThailand(CommonCountryTests, TestCase):
 
     def test_national_labour_day(self):
         name = "วันแรงงานแห่งชาติ"
-
-        self.assertNoHoliday("1973-05-01")
-        self.assertNoHolidayName(name, 1973)
-        self.assertHoliday(f"{year}-05-01" for year in range(1974, 2058))
+        self.assertHolidayName(name, (f"{year}-05-01" for year in range(1974, 2050)))
+        self.assertNoHolidayName(name, range(1941, 1974))
 
         self.assertNoNonObservedHoliday(
             "2010-05-03",
@@ -280,12 +213,9 @@ class TestThailand(CommonCountryTests, TestCase):
 
     def test_coronation_day(self):
         name = "วันฉัตรมงคล"
-
-        self.assertNoHoliday("1957-05-05")
-        self.assertNoHolidayName(name, 1957)
-        self.assertHoliday(f"{year}-05-05" for year in range(1958, 2017))
-        self.assertNoHolidayName(name, range(2017, 2020))
-        self.assertHoliday(f"{year}-05-04" for year in range(2020, 2058))
+        self.assertHolidayName(name, (f"{year}-05-05" for year in range(1958, 2017)))
+        self.assertHolidayName(name, (f"{year}-05-04" for year in range(2020, 2050)))
+        self.assertNoHolidayName(name, range(1941, 1958), range(2017, 2020))
 
         self.assertNoNonObservedHoliday(
             "2012-05-07",
@@ -297,10 +227,8 @@ class TestThailand(CommonCountryTests, TestCase):
 
     def test_queen_suthida_birthday(self):
         name = "วันเฉลิมพระชนมพรรษาสมเด็จพระนางเจ้าสุทิดา พัชรสุธาพิมลลักษณ พระบรมราชินี"
-
-        self.assertNoHoliday("2018-06-03")
-        self.assertNoHolidayName(name, 2018)
-        self.assertHoliday(f"{year}-06-03" for year in range(2019, 2058))
+        self.assertHolidayName(name, (f"{year}-06-03" for year in range(2019, 2050)))
+        self.assertNoHolidayName(name, range(1941, 2019))
 
         self.assertNoNonObservedHoliday(
             "2023-06-05",
@@ -309,18 +237,17 @@ class TestThailand(CommonCountryTests, TestCase):
         )
 
     def test_national_day(self):
-        self.assertHoliday(f"{year}-06-24" for year in range(1941, 1960))
-        self.assertHoliday(f"{year}-12-05" for year in range(1960, 2058))
+        name = "วันชาติ"
+        self.assertHolidayName(name, (f"{year}-06-24" for year in range(1941, 1960)))
+        self.assertHolidayName(name, (f"{year}-12-05" for year in range(1960, 2050)))
 
         # No in lieus during its existense on June 24th
         # 1960+ In lieus are same as HM King Bhumibol Adulyadej's Birthday
 
     def test_rama_x_birthday(self):
-        name = "วันเฉลิมพระชนมพรรษา พระบาทสมเด็จพระเจ้าอยู่หัว"
-
-        self.assertNoHoliday("2016-07-28")
-        self.assertNoHolidayName(name, 2016)
-        self.assertHoliday(f"{year}-07-28" for year in range(2017, 2058))
+        name = "วันเฉลิมพระชนมพรรษาพระบาทสมเด็จพระปรเมนทรรามาธิบดีศรีสินทรมหาวชิราลงกรณ พระวชิรเกล้าเจ้าอยู่หัว"
+        self.assertHolidayName(name, (f"{year}-07-28" for year in range(2017, 2050)))
+        self.assertNoHolidayName(name, range(1941, 2017))
 
         self.assertNoNonObservedHoliday(
             "2018-07-30",
@@ -333,13 +260,14 @@ class TestThailand(CommonCountryTests, TestCase):
     def test_queen_sirikit_birthday(self):
         name_ix = "วันเฉลิมพระชนมพรรษาสมเด็จพระนางเจ้าสิริกิติ์ พระบรมราชินีนาถ"
         name_x = "วันเฉลิมพระชนมพรรษาสมเด็จพระบรมราชชนนีพันปีหลวง"
+        years_pre = range(1941, 1976)
+        years_ix = range(1976, 2017)
+        years_x = range(2017, 2050)
 
-        self.assertNoHoliday("1975-08-12")
-        self.assertNoHolidayName(name_ix, 1975)
-        self.assertHolidayName(name_ix, (f"{year}-08-12" for year in range(1976, 2017)))
-        self.assertNoHolidayName(name_x, range(1941, 2017))
-        self.assertHolidayName(name_x, (f"{year}-08-12" for year in range(2017, 2058)))
-        self.assertNoHolidayName(name_ix, range(2017, 2058))
+        self.assertHolidayName(name_ix, (f"{year}-08-12" for year in years_ix))
+        self.assertHolidayName(name_x, (f"{year}-08-12" for year in years_x))
+        self.assertNoHolidayName(name_ix, years_pre, years_x)
+        self.assertNoHolidayName(name_x, years_pre, years_ix)
 
         self.assertNoNonObservedHoliday(
             "2012-08-13",
@@ -353,10 +281,9 @@ class TestThailand(CommonCountryTests, TestCase):
     def test_national_mothers_day(self):
         name = "วันแม่แห่งชาติ"
 
-        self.assertNoHolidayName(name, 1949)
         self.assertHolidayName(name, (f"{year}-04-15" for year in range(1950, 1958)))
-        self.assertNoHolidayName(name, range(1958, 1976))
-        self.assertHolidayName(name, (f"{year}-08-12" for year in range(1976, 2058)))
+        self.assertHolidayName(name, (f"{year}-08-12" for year in range(1976, 2050)))
+        self.assertNoHolidayName(name, range(1941, 1950), range(1958, 1976))
 
         # April 15 (1950-1958) exists prior to in lieu laws
         # In lieus are same as HM Queen Sirikit's Birthday
@@ -365,16 +292,17 @@ class TestThailand(CommonCountryTests, TestCase):
         name_ix = "วันคล้ายวันสวรรคตพระบาทสมเด็จพระปรมินทรมหาภูมิพลอดุลยเดช บรมนาถบพิตร"
         name_x = "วันคล้ายวันสวรรคตพระบาทสมเด็จพระบรมชนกาธิเบศร มหาภูมิพลอดุลยเดชมหาราช บรมนาถบพิตร"
         name_x_memorial = "วันนวมินทรมหาราช"
-
-        self.assertNoHoliday("2016-10-13")
-        self.assertNoHolidayName(name_ix, 2016)
-        self.assertNoHolidayName(name_x, range(1941, 2019))
-        self.assertNoHolidayName(name_x_memorial, range(1941, 2023))
-        self.assertHolidayName(name_ix, (f"{year}-10-13" for year in range(2017, 2019)))
-        self.assertHolidayName(name_x, (f"{year}-10-13" for year in range(2019, 2023)))
-        self.assertHolidayName(name_x_memorial, (f"{year}-10-13" for year in range(2023, 2058)))
-        self.assertNoHolidayName(name_ix, range(2019, 2058))
-        self.assertNoHolidayName(name_x, range(2023, 2058))
+        years_pre = range(1941, 2017)
+        years_ix = range(2017, 2019)
+        years_x = range(2019, 2023)
+        years_x_memorial = range(2023, 2050)
+
+        self.assertHolidayName(name_ix, (f"{year}-10-13" for year in years_ix))
+        self.assertHolidayName(name_x, (f"{year}-10-13" for year in years_x))
+        self.assertHolidayName(name_x_memorial, (f"{year}-10-13" for year in years_x_memorial))
+        self.assertNoHolidayName(name_ix, years_pre, years_x, years_x_memorial)
+        self.assertNoHolidayName(name_x, years_pre, years_ix, years_x_memorial)
+        self.assertNoHolidayName(name_x_memorial, years_pre, years_ix, years_x)
 
         self.assertNoNonObservedHoliday(
             "2018-10-15",
@@ -386,9 +314,7 @@ class TestThailand(CommonCountryTests, TestCase):
 
     def test_rama_five_memorial_day(self):
         name = "วันปิยมหาราช"
-        self.assertHoliday(f"{year}-10-23" for year in range(1941, 2058))
-        self.assertNoHoliday("1910-10-23", "1940-10-23")
-        self.assertNoHolidayName(name, Thailand(years=[1910, 1940]))
+        self.assertHolidayName(name, (f"{year}-10-23" for year in range(1941, 2050)))
 
         self.assertNoNonObservedHoliday(
             "2010-10-25",
@@ -405,16 +331,17 @@ class TestThailand(CommonCountryTests, TestCase):
         name_great = (
             "วันคล้ายวันเฉลิมพระชนมพรรษาพระบาทสมเด็จพระบรมชนกาธิเบศร มหาภูมิพลอดุลยเดชมหาราช บรมนาถบพิตร"
         )
+        years_pre = range(1941, 1960)
+        years_reign = range(1960, 2016)
+        years_dead = range(2016, 2019)
+        years_great = range(2019, 2050)
 
-        self.assertNoHoliday("1959-12-05")
-        self.assertNoHolidayName(name_reign, range(1941, 1960))
-        self.assertNoHolidayName(name_dead, range(1941, 2016))
-        self.assertNoHolidayName(name_great, range(1941, 2019))
-        self.assertHolidayName(name_reign, (f"{year}-12-05" for year in range(1976, 2016)))
-        self.assertHolidayName(name_dead, (f"{year}-12-05" for year in range(2016, 2019)))
-        self.assertHolidayName(name_great, (f"{year}-12-05" for year in range(2019, 2058)))
-        self.assertNoHolidayName(name_reign, range(2016, 2058))
-        self.assertNoHolidayName(name_dead, range(2019, 2058))
+        self.assertHolidayName(name_reign, (f"{year}-12-05" for year in years_reign))
+        self.assertHolidayName(name_dead, (f"{year}-12-05" for year in years_dead))
+        self.assertHolidayName(name_great, (f"{year}-12-05" for year in years_great))
+        self.assertNoHolidayName(name_reign, years_pre, years_dead, years_great)
+        self.assertNoHolidayName(name_dead, years_pre, years_reign, years_great)
+        self.assertNoHolidayName(name_great, years_pre, years_reign, years_dead)
 
         self.assertNoNonObservedHoliday(
             "2010-12-06",
@@ -429,13 +356,14 @@ class TestThailand(CommonCountryTests, TestCase):
         name = "วันพ่อแห่งชาติ"
 
         # This concides with HM King Bhumibol Adulyadej's Birthday
-        self.assertNoHolidayName(name, 1979)
-        self.assertHolidayName(name, (f"{year}-12-05" for year in range(1980, 2058)))
+        self.assertHolidayName(name, (f"{year}-12-05" for year in range(1980, 2050)))
+        self.assertNoHolidayName(name, range(1941, 1980))
 
         # In lieus are same as HM King Bhumibol Adulyadej's Birthday
 
     def test_constitution_day(self):
-        self.assertHoliday(f"{year}-12-10" for year in range(1941, 2058))
+        name = "วันรัฐธรรมนูญ"
+        self.assertHolidayName(name, (f"{year}-12-10" for year in range(1941, 2050)))
 
         self.assertNoNonObservedHoliday(
             "2011-12-12",
@@ -447,7 +375,8 @@ class TestThailand(CommonCountryTests, TestCase):
         )
 
     def test_new_years_eve(self):
-        self.assertHoliday(f"{year}-12-31" for year in range(1941, 2058))
+        name = "วันสิ้นปี"
+        self.assertHolidayName(name, (f"{year}-12-31" for year in range(1941, 2050)))
 
         self.assertNoNonObservedHoliday(
             "2012-01-03",
@@ -457,150 +386,30 @@ class TestThailand(CommonCountryTests, TestCase):
             "2029-01-02",
         )
 
-    def test_makha_bucha(self):
-        name = "วันมาฆบูชา"
-
-        dt = (
-            "2010-02-28",
-            "2011-02-18",
-            "2012-03-07",
-            "2013-02-25",
-            "2014-02-14",
-            "2015-03-04",
-            "2016-02-22",
-            "2017-02-11",
-            "2018-03-01",
-            "2019-02-19",
-            "2020-02-08",
-            "2021-02-26",
-            "2022-02-16",
-            "2023-03-06",
-            "2024-02-24",
-            "2025-02-12",
-            "2026-03-03",
-            "2027-02-21",
-            "2028-02-10",
-            "2029-02-27",
-            "2030-02-17",
-        )
-        self.assertHolidayName(name, dt)
-        self.assertNoHolidayName(name, 2158)
-
+    def test_buddhist_holidays_in_lieu(self):
         self.assertNoNonObservedHoliday(
+            # Makha Bucha
             "2010-03-01",
             "2017-02-13",
             "2020-02-10",
             "2024-02-26",
             "2024-02-22",
             "2030-02-18",
-        )
-
-    def test_visakha_bucha(self):
-        name = "วันวิสาขบูชา"
-
-        dt = (
-            "2010-05-28",
-            "2011-05-17",
-            "2012-06-04",
-            "2013-05-24",
-            "2014-05-13",
-            "2015-06-01",
-            "2016-05-20",
-            "2017-05-10",
-            "2018-05-29",
-            "2019-05-18",
-            "2020-05-06",
-            "2021-05-26",
-            "2022-05-15",
-            "2023-06-03",
-            "2024-05-22",
-            "2025-05-11",
-            "2026-05-31",
-            "2027-05-20",
-            "2028-05-08",
-            "2029-05-27",
-            "2030-05-16",
-        )
-        self.assertHolidayName(name, dt)
-        self.assertNoHolidayName(name, 2158)
-
-        self.assertNoNonObservedHoliday(
+            # Visakha Bucha
             "2019-05-20",
             "2022-05-16",
             "2023-06-05",
             "2025-05-12",
             "2026-06-01",
             "2029-05-28",
-        )
-
-    def test_asarnha_bucha(self):
-        name = "วันอาสาฬหบูชา"
-
-        dt = (
-            "2010-07-26",
-            "2011-07-15",
-            "2012-08-02",
-            "2013-07-22",
-            "2014-07-11",
-            "2015-07-30",
-            "2016-07-19",
-            "2017-07-08",
-            "2018-07-27",
-            "2019-07-16",
-            "2020-07-05",
-            "2021-07-24",
-            "2022-07-13",
-            "2023-08-01",
-            "2024-07-20",
-            "2025-07-10",
-            "2026-07-29",
-            "2027-07-18",
-            "2028-07-06",
-            "2029-07-25",
-            "2030-07-14",
-        )
-        self.assertHolidayName(name, dt)
-        self.assertNoHolidayName(name, 2158)
-
-        self.assertNoNonObservedHoliday(
+            # Asarnha Bucha
             "2017-07-10",
             "2020-07-07",
             "2021-07-26",
             "2024-07-22",
             "2027-07-20",
             "2030-07-16",
-        )
-
-    def test_khao_phansa(self):
-        name = "วันเข้าพรรษา"
-
-        dt = (
-            "2010-07-27",
-            "2011-07-16",
-            "2012-08-03",
-            "2013-07-23",
-            "2014-07-12",
-            "2015-07-31",
-            "2016-07-20",
-            "2017-07-09",
-            "2018-07-28",
-            "2019-07-17",
-            "2020-07-06",
-            "2021-07-25",
-            "2022-07-14",
-            "2023-08-02",
-            "2024-07-21",
-            "2025-07-11",
-            "2026-07-30",
-            "2027-07-19",
-            "2028-07-07",
-            "2029-07-26",
-            "2030-07-15",
-        )
-        self.assertHolidayName(name, dt)
-        self.assertNoHolidayName(name, 2158)
-
-        self.assertNoNonObservedHoliday(
+            # Khao Phansa
             "2011-07-18",
             "2014-07-14",
             "2018-07-30",
@@ -608,118 +417,117 @@ class TestThailand(CommonCountryTests, TestCase):
 
     def test_raeknakhwan(self):
         name = "วันพืชมงคล"
-        self.assertHolidays(
-            Thailand(categories=GOVERNMENT, years=range(1960, 2024)),
-            ("1960-05-02", name),
-            ("1961-05-11", name),
-            ("1962-05-07", name),
-            ("1963-05-10", name),
-            ("1964-05-08", name),
-            ("1965-05-13", name),
-            ("1966-05-13", name),
-            ("1967-05-11", name),
-            ("1968-05-10", name),
-            ("1969-05-09", name),
-            ("1970-05-08", name),
-            ("1971-05-07", name),
-            ("1972-05-08", name),
-            ("1973-05-07", name),
-            ("1974-05-08", name),
-            ("1975-05-07", name),
-            ("1976-05-10", name),
-            ("1977-05-12", name),
-            ("1978-05-11", name),
-            ("1979-05-07", name),
-            ("1980-05-14", name),
-            ("1981-05-07", name),
-            ("1982-05-19", name),
-            ("1983-05-11", name),
-            ("1984-05-10", name),
-            ("1985-05-09", name),
-            ("1986-05-09", name),
-            ("1987-05-08", name),
-            ("1988-05-11", name),
-            ("1989-05-11", name),
-            ("1990-05-11", name),
-            ("1991-05-10", name),
-            ("1992-05-14", name),
-            ("1993-05-17", name),
-            ("1994-05-11", name),
-            ("1995-05-10", name),
-            ("1996-05-16", name),
-            ("1997-05-09", name),
-            ("1998-05-08", name),
+        dt = (
+            "1960-05-02",
+            "1961-05-11",
+            "1962-05-07",
+            "1963-05-10",
+            "1964-05-08",
+            "1965-05-13",
+            "1966-05-13",
+            "1967-05-11",
+            "1968-05-10",
+            "1969-05-09",
+            "1970-05-08",
+            "1971-05-07",
+            "1972-05-08",
+            "1973-05-07",
+            "1974-05-08",
+            "1975-05-07",
+            "1976-05-10",
+            "1977-05-12",
+            "1978-05-11",
+            "1979-05-07",
+            "1980-05-14",
+            "1981-05-07",
+            "1982-05-19",
+            "1983-05-11",
+            "1984-05-10",
+            "1985-05-09",
+            "1986-05-09",
+            "1987-05-08",
+            "1988-05-11",
+            "1989-05-11",
+            "1990-05-11",
+            "1991-05-10",
+            "1992-05-14",
+            "1993-05-17",
+            "1994-05-11",
+            "1995-05-10",
+            "1996-05-16",
+            "1997-05-09",
+            "1998-05-08",
             # Not a holiday in 1999 date, was held on MAY, 14.
-            ("2000-05-15", name),
-            ("2001-05-16", name),
-            ("2002-05-09", name),
-            ("2003-05-08", name),
-            ("2004-05-07", name),
-            ("2005-05-11", name),
-            ("2006-05-11", name),
-            ("2007-05-10", name),
-            ("2008-05-09", name),
-            ("2009-05-11", name),
-            ("2010-05-13", name),
-            ("2011-05-13", name),
-            ("2012-05-09", name),
-            ("2013-05-13", name),
-            ("2014-05-09", name),
-            ("2015-05-13", name),
-            ("2016-05-09", name),
-            ("2017-05-12", name),
-            ("2018-05-14", name),
-            ("2019-05-09", name),
-            ("2020-05-11", name),
-            ("2021-05-10", name),
-            ("2022-05-13", name),
-            ("2023-05-17", name),
-            ("2024-05-10", name),
-        )
+            "2000-05-15",
+            "2001-05-16",
+            "2002-05-09",
+            "2003-05-08",
+            "2004-05-07",
+            "2005-05-11",
+            "2006-05-11",
+            "2007-05-10",
+            "2008-05-09",
+            "2009-05-11",
+            "2010-05-13",
+            "2011-05-13",
+            "2012-05-09",
+            "2013-05-13",
+            "2014-05-09",
+            "2015-05-13",
+            "2016-05-09",
+            "2017-05-12",
+            "2018-05-14",
+            "2019-05-09",
+            "2020-05-11",
+            "2021-05-10",
+            "2022-05-13",
+            "2023-05-17",
+            "2024-05-10",
+            "2025-05-09",
+        )
+        gov_holidays = Thailand(categories=GOVERNMENT, years=range(1959, 2026))
+        self.assertHolidayName(name, gov_holidays, dt)
+        self.assertNoHolidayName(name, gov_holidays, 1959, 1999)
+        self.assertNoHolidayName(name)
 
     def test_armed_forces_holiday(self):
         name = "วันกองทัพไทย"
-        self.assertHolidays(
-            Thailand(categories=ARMED_FORCES, years=range(1958, 1960)), ("1959-04-08", name)
+        armed_forces_holidays = Thailand(categories=ARMED_FORCES, years=range(1958, 2050))
+        self.assertHolidayName(
+            name, armed_forces_holidays, (f"{year}-04-08" for year in range(1959, 1980))
         )
-        self.assertHolidays(
-            Thailand(categories=ARMED_FORCES, years=range(1979, 1981)),
-            ("1979-04-08", name),
-            ("1980-01-25", name),
+        self.assertHolidayName(
+            name, armed_forces_holidays, (f"{year}-01-25" for year in range(1980, 2007))
         )
-        self.assertHolidays(
-            Thailand(categories=ARMED_FORCES, years=range(2006, 2008)),
-            ("2006-01-25", name),
-            ("2007-01-18", name),
+        self.assertHolidayName(
+            name, armed_forces_holidays, (f"{year}-01-18" for year in range(2007, 2050))
         )
+        self.assertNoHolidayName(name, armed_forces_holidays, 1958)
+        self.assertNoHolidayName(name)
 
     def test_bank_holiday(self):
-        a_name = "วันหยุดเพิ่มเติมสำหรับการปิดบัญชีประจำปีของธนาคารเพื่อการเกษตรและสหกรณ์การเกษตร"
-        m_name = "วันหยุดภาคครึ่งปีของสถาบันการเงินและสถาบันการเงินเฉพาะกิจ"
-
-        # Start
-        self.assertHolidays(
-            Thailand(categories=BANK, years=range(1942, 1944)),
-            ("1943-04-01", a_name),
-            ("1943-07-01", m_name),
+        name_agri = "วันหยุดเพิ่มเติมสำหรับการปิดบัญชีประจำปีของธนาคารเพื่อการเกษตรและสหกรณ์การเกษตร"
+        name_mid = "วันหยุดภาคครึ่งปีของสถาบันการเงินและสถาบันการเงินเฉพาะกิจ"
+        bank_holidays = Thailand(categories=BANK, years=range(1942, 2023))
+        self.assertHolidayName(
+            name_agri, bank_holidays, (f"{year}-04-01" for year in range(1943, 2022))
         )
-        # End
-        self.assertHolidays(
-            Thailand(categories=BANK, years=range(2017, 2023)),
-            ("2017-04-01", a_name),
-            ("2017-07-01", m_name),
-            ("2018-04-01", a_name),
-            ("2018-07-01", m_name),
-            ("2019-04-01", a_name),
-            ("2020-04-01", a_name),
-            ("2021-04-01", a_name),
+        self.assertHolidayName(
+            name_mid, bank_holidays, (f"{year}-07-01" for year in range(1943, 2019))
         )
+        self.assertNoHolidayName(name_agri, bank_holidays, 1942, range(2022, 2050))
+        self.assertNoHolidayName(name_mid, bank_holidays, 1942, range(2019, 2050))
+        self.assertNoHolidayName(name_agri)
+        self.assertNoHolidayName(name_mid)
 
     def test_school_holiday(self):
-        self.assertHolidays(
-            Thailand(categories=SCHOOL, years=range(1956, 1958)),
-            ("1957-01-16", "วันครู"),
+        name = "วันครู"
+        school_holidays = Thailand(categories=SCHOOL, years=range(1956, 2050))
+        self.assertHolidayName(
+            name, school_holidays, (f"{year}-01-16" for year in range(1957, 2050))
         )
+        self.assertNoHolidayName(name, school_holidays, 1956)
+        self.assertNoHolidayName(name)
 
     def test_workday_1947(self):
         self.assertHolidays(
diff --git a/tests/countries/test_united_states.py b/tests/countries/test_united_states.py
index 045bd9d7..4cd8e361 100644
--- a/tests/countries/test_united_states.py
+++ b/tests/countries/test_united_states.py
@@ -20,13 +20,13 @@ from tests.common import CommonCountryTests
 class TestUnitedStates(CommonCountryTests, TestCase):
     @classmethod
     def setUpClass(cls):
-        super().setUpClass(
-            UnitedStates, years=range(1865, 2050), years_non_observed=range(2000, 2024)
-        )
+        years = range(1865, 2050)
+        super().setUpClass(UnitedStates, years=years, years_non_observed=range(2000, 2024))
         cls.state_hols = {
-            subdiv: UnitedStates(subdiv=subdiv, years=range(1865, 2050))
+            subdiv: UnitedStates(subdiv=subdiv, years=years)
             for subdiv in UnitedStates.subdivisions
         }
+        cls.unofficial_hols = UnitedStates(categories=UNOFFICIAL, years=years)
 
     def test_country_aliases(self):
         self.assertAliases(UnitedStates, US, USA)
@@ -131,8 +131,9 @@ class TestUnitedStates(CommonCountryTests, TestCase):
         name_1 = "Armistice Day"
         name_2 = "Veterans Day"
         self.assertHolidayName(name_1, (f"{year}-11-11" for year in range(1938, 1954)))
-        self.assertHolidayName(name_2, (f"{year}-11-11" for year in range(1954, 1971)))
-        self.assertHolidayName(name_2, (f"{year}-11-11" for year in range(1978, 2050)))
+        self.assertHolidayName(
+            name_2, (f"{year}-11-11" for year in (*range(1954, 1971), *range(1978, 2050)))
+        )
         self.assertNoHolidayName(name_1, range(1865, 1938), range(1954, 2050))
         self.assertNoHolidayName(name_2, range(1865, 1954))
         self.assertHolidayName(
@@ -536,6 +537,7 @@ class TestUnitedStates(CommonCountryTests, TestCase):
     def test_columbus_day_al(self):
         name_1 = "Columbus Day / Fraternal Day"
         name_2 = "Columbus Day / American Indian Heritage Day / Fraternal Day"
+        al_holidays = self.state_hols["AL"]
         dt = (
             "2010-10-11",
             "2011-10-10",
@@ -552,13 +554,14 @@ class TestUnitedStates(CommonCountryTests, TestCase):
             "2022-10-10",
             "2023-10-09",
         )
-        self.assertNoHolidayName(name_1, self.state_hols["AL"], range(1865, 1970))
-        self.assertHolidayName(name_1, self.state_hols["AL"], range(1971, 2000))
-        self.assertHolidayName(name_2, self.state_hols["AL"], range(2000, 2050))
-        self.assertHoliday(self.state_hols["AL"], dt)
+        self.assertNoHolidayName(name_1, al_holidays, range(1865, 1970))
+        self.assertHolidayName(name_1, al_holidays, range(1971, 2000))
+        self.assertHolidayName(name_2, al_holidays, range(2000, 2050))
+        self.assertHoliday(al_holidays, dt)
 
     def test_columbus_day_ca(self):
         name = "Columbus Day"
+        ca_holidays = self.state_hols["CA"]
         dt = (
             "1990-10-08",
             "1995-10-09",
@@ -572,14 +575,14 @@ class TestUnitedStates(CommonCountryTests, TestCase):
             "2007-10-08",
             "2008-10-13",
         )
-        self.assertNoHolidayName(name, self.state_hols["CA"], range(1865, 1970))
-        self.assertNoHolidayName(name, self.state_hols["CA"], range(2009, 2050))
-        self.assertHolidayName(name, self.state_hols["CA"], range(1971, 2009))
-        self.assertHoliday(self.state_hols["CA"], dt)
+        self.assertNoHolidayName(name, ca_holidays, range(1865, 1970), range(2009, 2050))
+        self.assertHolidayName(name, ca_holidays, range(1971, 2009))
+        self.assertHoliday(ca_holidays, dt)
 
     def test_columbus_day_ri(self):
         name_1 = "Columbus Day"
         name_2 = "Indigenous Peoples' Day / Columbus Day"
+        ri_holidays = self.state_hols["RI"]
         dt = (
             "2010-10-11",
             "2011-10-10",
@@ -596,14 +599,15 @@ class TestUnitedStates(CommonCountryTests, TestCase):
             "2022-10-10",
             "2023-10-09",
         )
-        self.assertNoHolidayName(name_1, self.state_hols["RI"], range(1865, 1970))
-        self.assertHolidayName(name_1, self.state_hols["RI"], range(1971, 2022))
-        self.assertHolidayName(name_2, self.state_hols["RI"], range(2022, 2050))
-        self.assertHoliday(self.state_hols["RI"], dt)
+        self.assertNoHolidayName(name_1, ri_holidays, range(1865, 1970))
+        self.assertHolidayName(name_1, ri_holidays, range(1971, 2022))
+        self.assertHolidayName(name_2, ri_holidays, range(2022, 2050))
+        self.assertHoliday(ri_holidays, dt)
 
     def test_columbus_day_sd(self):
         name_1 = "Columbus Day"
         name_2 = "Native Americans' Day"
+        sd_holidays = self.state_hols["SD"]
         dt = (
             "2010-10-11",
             "2011-10-10",
@@ -620,10 +624,10 @@ class TestUnitedStates(CommonCountryTests, TestCase):
             "2022-10-10",
             "2023-10-09",
         )
-        self.assertNoHolidayName(name_1, self.state_hols["SD"], range(1865, 1937))
-        self.assertHolidayName(name_1, self.state_hols["SD"], range(1937, 1990))
-        self.assertHolidayName(name_2, self.state_hols["SD"], range(1990, 2050))
-        self.assertHolidayName(name_2, self.state_hols["SD"], dt)
+        self.assertNoHolidayName(name_1, sd_holidays, range(1865, 1937))
+        self.assertHolidayName(name_1, sd_holidays, range(1937, 1990))
+        self.assertHolidayName(name_2, sd_holidays, range(1990, 2050))
+        self.assertHolidayName(name_2, sd_holidays, dt)
 
     def test_epiphany(self):
         name = "Epiphany"
@@ -642,10 +646,9 @@ class TestUnitedStates(CommonCountryTests, TestCase):
     def test_lee_jackson_day(self):
         name = "Lee Jackson Day"
         self.assertNoHolidayName(name)
-        self.assertNoHolidayName(name, self.state_hols["VA"], range(1865, 1889), range(2021, 2050))
-        self.assertHolidayName(
-            name, self.state_hols["VA"], (f"{year}-01-19" for year in range(1889, 1983))
-        )
+        va_holidays = self.state_hols["VA"]
+        self.assertNoHolidayName(name, va_holidays, range(1865, 1889), range(2021, 2050))
+        self.assertHolidayName(name, va_holidays, (f"{year}-01-19" for year in range(1889, 1983)))
         dt = (
             "1983-01-17",
             "1990-01-15",
@@ -664,7 +667,7 @@ class TestUnitedStates(CommonCountryTests, TestCase):
             "2019-01-18",
             "2020-01-17",
         )
-        self.assertHolidayName(name, self.state_hols["VA"], dt)
+        self.assertHolidayName(name, va_holidays, dt)
 
     def test_inauguration_day(self):
         name = "Inauguration Day"
@@ -718,10 +721,9 @@ class TestUnitedStates(CommonCountryTests, TestCase):
             "2005-02-11",
             "2006-02-13",
         )
-        self.assertHolidayName(
-            name, self.state_hols["CA"], (f"{year}-02-12" for year in range(1971, 2010))
-        )
-        self.assertHolidayName(f"{name} (observed)", self.state_hols["CA"], obs_dt)
+        ca_holidays = self.state_hols["CA"]
+        self.assertHolidayName(name, ca_holidays, (f"{year}-02-12" for year in range(1971, 2010)))
+        self.assertHolidayName(f"{name} (observed)", ca_holidays, obs_dt)
         self.assertNoNonObservedHolidayName(
             f"{name} (observed)", UnitedStates(subdiv="CA", observed=False), obs_dt
         )
@@ -729,21 +731,18 @@ class TestUnitedStates(CommonCountryTests, TestCase):
     def test_susan_b_anthony_day(self):
         name = "Susan B. Anthony Day"
         self.assertNoHolidayName(name)
-        subdiv_start_years = {
-            "CA": 2014,
-            "FL": 2011,
-            "NY": 2004,
-            "WI": 1976,
-        }
-        for subdiv in subdiv_start_years:
+        for subdiv, start_year in (
+            ("CA", 2014),
+            ("FL", 2011),
+            ("NY", 2004),
+            ("WI", 1976),
+        ):
             self.assertHolidayName(
                 name,
                 self.state_hols[subdiv],
-                (f"{year}-02-15" for year in range(subdiv_start_years[subdiv], 2050)),
-            )
-            self.assertNoHolidayName(
-                name, self.state_hols[subdiv], range(1865, subdiv_start_years[subdiv])
+                (f"{year}-02-15" for year in range(start_year, 2050)),
             )
+            self.assertNoHolidayName(name, self.state_hols[subdiv], range(1865, start_year))
 
     def test_mardi_gras(self):
         name = "Mardi Gras"
@@ -770,6 +769,7 @@ class TestUnitedStates(CommonCountryTests, TestCase):
     def test_guam_discovery_day(self):
         name = "Guam Discovery Day"
         self.assertNoHolidayName(name)
+        gu_holidays = self.state_hols["GU"]
         dt = (
             "2010-03-01",
             "2011-03-07",
@@ -786,12 +786,13 @@ class TestUnitedStates(CommonCountryTests, TestCase):
             "2022-03-07",
             "2023-03-06",
         )
-        self.assertHolidayName(name, self.state_hols["GU"], dt)
-        self.assertNoHolidayName(name, self.state_hols["GU"], range(1865, 1970))
+        self.assertHolidayName(name, gu_holidays, dt)
+        self.assertNoHolidayName(name, gu_holidays, range(1865, 1970))
 
     def test_casimir_pulaski_day(self):
         name = "Casimir Pulaski Day"
         self.assertNoHolidayName(name)
+        il_holidays = self.state_hols["IL"]
         dt = (
             "2010-03-01",
             "2011-03-07",
@@ -808,16 +809,15 @@ class TestUnitedStates(CommonCountryTests, TestCase):
             "2022-03-07",
             "2023-03-06",
         )
-        self.assertHolidayName(name, self.state_hols["IL"], dt)
-        self.assertNoHolidayName(name, self.state_hols["IL"], range(1865, 1978))
+        self.assertHolidayName(name, il_holidays, dt)
+        self.assertNoHolidayName(name, il_holidays, range(1865, 1978))
 
     def test_texas_independence_day(self):
         name = "Texas Independence Day"
         self.assertNoHolidayName(name)
-        self.assertHolidayName(
-            name, self.state_hols["TX"], (f"{year}-03-02" for year in range(1874, 2050))
-        )
-        self.assertNoHolidayName(name, self.state_hols["TX"], range(1865, 1874))
+        tx_holidays = self.state_hols["TX"]
+        self.assertHolidayName(name, tx_holidays, (f"{year}-03-02" for year in range(1874, 2050)))
+        self.assertNoHolidayName(name, tx_holidays, range(1865, 1874))
 
     def test_town_meeting_day(self):
         name = "Town Meeting Day"
@@ -844,17 +844,16 @@ class TestUnitedStates(CommonCountryTests, TestCase):
     def test_evacuation_day(self):
         name = "Evacuation Day"
         self.assertNoHolidayName(name)
-        self.assertHolidayName(
-            name, self.state_hols["MA"], (f"{year}-03-17" for year in range(1901, 2050))
-        )
-        self.assertNoHolidayName(name, self.state_hols["MA"], range(1865, 1901))
+        ma_holidays = self.state_hols["MA"]
+        self.assertHolidayName(name, ma_holidays, (f"{year}-03-17" for year in range(1901, 2050)))
+        self.assertNoHolidayName(name, ma_holidays, range(1865, 1901))
         obs_dt = (
             "2012-03-19",
             "2013-03-18",
             "2018-03-19",
             "2019-03-18",
         )
-        self.assertHolidayName(f"{name} (observed)", self.state_hols["MA"], obs_dt)
+        self.assertHolidayName(f"{name} (observed)", ma_holidays, obs_dt)
         self.assertNoNonObservedHolidayName(
             f"{name} (observed)", UnitedStates(subdiv="MA", observed=False), obs_dt
         )
@@ -862,16 +861,15 @@ class TestUnitedStates(CommonCountryTests, TestCase):
     def test_emancipation_day_in_puerto_rico(self):
         name = "Emancipation Day"
         self.assertNoHolidayName(name)
-        self.assertHolidayName(
-            name, self.state_hols["PR"], (f"{year}-03-22" for year in range(1865, 2050))
-        )
+        pr_holidays = self.state_hols["PR"]
+        self.assertHolidayName(name, pr_holidays, (f"{year}-03-22" for year in range(1865, 2050)))
         obs_dt = (
             "1998-03-23",
             "2009-03-23",
             "2015-03-23",
             "2020-03-23",
         )
-        self.assertHolidayName(f"{name} (observed)", self.state_hols["PR"], obs_dt)
+        self.assertHolidayName(f"{name} (observed)", pr_holidays, obs_dt)
         self.assertNoNonObservedHolidayName(
             f"{name} (observed)", UnitedStates(subdiv="PR", observed=False), obs_dt
         )
@@ -879,16 +877,15 @@ class TestUnitedStates(CommonCountryTests, TestCase):
     def test_commonwealth_covenant_day(self):
         name = "Commonwealth Covenant Day"
         self.assertNoHolidayName(name)
-        self.assertHolidayName(
-            name, self.state_hols["MP"], (f"{year}-03-24" for year in range(1865, 2050))
-        )
+        mp_holidays = self.state_hols["MP"]
+        self.assertHolidayName(name, mp_holidays, (f"{year}-03-24" for year in range(1865, 2050)))
         obs_dt = (
             "2012-03-23",
             "2013-03-25",
             "2018-03-23",
             "2019-03-25",
         )
-        self.assertHolidayName(f"{name} (observed)", self.state_hols["MP"], obs_dt)
+        self.assertHolidayName(f"{name} (observed)", mp_holidays, obs_dt)
         self.assertNoNonObservedHolidayName(
             f"{name} (observed)", UnitedStates(subdiv="MP", observed=False), obs_dt
         )
@@ -896,10 +893,9 @@ class TestUnitedStates(CommonCountryTests, TestCase):
     def test_prince_jonah_kuhio_kalanianaole_day(self):
         name = "Prince Jonah Kuhio Kalanianaole Day"
         self.assertNoHolidayName(name)
-        self.assertHolidayName(
-            name, self.state_hols["HI"], (f"{year}-03-26" for year in range(1949, 2050))
-        )
-        self.assertNoHolidayName(name, self.state_hols["HI"], range(1865, 1949))
+        hi_holidays = self.state_hols["HI"]
+        self.assertHolidayName(name, hi_holidays, (f"{year}-03-26" for year in range(1949, 2050)))
+        self.assertNoHolidayName(name, hi_holidays, range(1865, 1949))
         obs_dt = (
             "2011-03-25",
             "2016-03-25",
@@ -907,7 +903,7 @@ class TestUnitedStates(CommonCountryTests, TestCase):
             "2022-03-25",
             "2023-03-27",
         )
-        self.assertHolidayName(f"{name} (observed)", self.state_hols["HI"], obs_dt)
+        self.assertHolidayName(f"{name} (observed)", hi_holidays, obs_dt)
         self.assertNoNonObservedHolidayName(
             f"{name} (observed)", UnitedStates(subdiv="HI", observed=False), obs_dt
         )
@@ -915,13 +911,13 @@ class TestUnitedStates(CommonCountryTests, TestCase):
     def test_sewards_day(self):
         name = "Seward's Day"
         self.assertNoHolidayName(name)
+        ak_holidays = self.state_hols["AK"]
         self.assertHolidayName(
             name,
-            self.state_hols["AK"],
-            (f"{year}-03-30" for year in range(1918, 1921)),
-            (f"{year}-03-30" for year in range(1922, 1955)),
+            ak_holidays,
+            (f"{year}-03-30" for year in (*range(1918, 1921), *range(1922, 1955))),
         )
-        self.assertNoHolidayName(name, self.state_hols["AK"], range(1865, 1918), 1921)
+        self.assertNoHolidayName(name, ak_holidays, range(1865, 1918), 1921)
         dt = (
             "1955-03-28",
             "2010-03-29",
@@ -939,15 +935,23 @@ class TestUnitedStates(CommonCountryTests, TestCase):
             "2022-03-28",
             "2023-03-27",
         )
-        self.assertHolidayName(name, self.state_hols["AK"], dt)
+        self.assertHolidayName(name, ak_holidays, dt)
 
     def test_cesar_chavez_day(self):
         name = "Cesar Chavez Day"
         self.assertNoHolidayName(name)
-        self.assertHolidayName(
-            name, self.state_hols["CA"], (f"{year}-03-31" for year in range(1995, 2050))
-        )
-        self.assertNoHolidayName(name, self.state_hols["CA"], range(1865, 1995))
+        for subdiv, start_year in (
+            ("CA", 1995),
+            ("CO", 2001),
+            ("TX", 2000),
+        ):
+            self.assertHolidayName(
+                name,
+                self.state_hols[subdiv],
+                (f"{year}-03-31" for year in range(start_year, 2050)),
+            )
+            self.assertNoHolidayName(name, self.state_hols[subdiv], range(1865, start_year))
+
         obs_dt = (
             "1996-04-01",
             "2002-04-01",
@@ -958,14 +962,6 @@ class TestUnitedStates(CommonCountryTests, TestCase):
         self.assertNoNonObservedHolidayName(
             f"{name} (observed)", UnitedStates(subdiv="CA", observed=False), obs_dt
         )
-        self.assertHolidayName(
-            name, self.state_hols["CO"], (f"{year}-03-31" for year in range(2001, 2050))
-        )
-        self.assertNoHolidayName(name, self.state_hols["CO"], range(1865, 2001))
-        self.assertHolidayName(
-            name, self.state_hols["TX"], (f"{year}-03-31" for year in range(2000, 2050))
-        )
-        self.assertNoHolidayName(name, self.state_hols["TX"], range(1865, 2000))
 
     def test_transfer_day(self):
         name = "Transfer Day"
@@ -977,10 +973,9 @@ class TestUnitedStates(CommonCountryTests, TestCase):
     def test_emancipation_day(self):
         name = "Emancipation Day"
         self.assertNoHolidayName(name)
-        self.assertHolidayName(
-            name, self.state_hols["DC"], (f"{year}-04-16" for year in range(2005, 2050))
-        )
-        self.assertNoHolidayName(name, self.state_hols["DC"], range(1865, 2005))
+        dc_holidays = self.state_hols["DC"]
+        self.assertHolidayName(name, dc_holidays, (f"{year}-04-16" for year in range(2005, 2050)))
+        self.assertNoHolidayName(name, dc_holidays, range(1865, 2005))
         obs_dt = (
             "2011-04-15",
             "2016-04-15",
@@ -988,7 +983,7 @@ class TestUnitedStates(CommonCountryTests, TestCase):
             "2022-04-15",
             "2023-04-17",
         )
-        self.assertHolidayName(f"{name} (observed)", self.state_hols["DC"], obs_dt)
+        self.assertHolidayName(f"{name} (observed)", dc_holidays, obs_dt)
         self.assertNoNonObservedHolidayName(
             f"{name} (observed)", UnitedStates(subdiv="DC", observed=False), obs_dt
         )
@@ -996,10 +991,9 @@ class TestUnitedStates(CommonCountryTests, TestCase):
     def test_american_samoa_flag_day(self):
         name = "American Samoa Flag Day"
         self.assertNoHolidayName(name)
-        self.assertHolidayName(
-            name, self.state_hols["AS"], (f"{year}-04-17" for year in range(1901, 2050))
-        )
-        self.assertNoHolidayName(name, self.state_hols["AS"], range(1865, 1901))
+        as_holidays = self.state_hols["AS"]
+        self.assertHolidayName(name, as_holidays, (f"{year}-04-17" for year in range(1901, 2050)))
+        self.assertNoHolidayName(name, as_holidays, range(1865, 1901))
         obs_dt = (
             "2004-04-16",
             "2005-04-18",
@@ -1009,7 +1003,7 @@ class TestUnitedStates(CommonCountryTests, TestCase):
             "2021-04-16",
             "2022-04-18",
         )
-        self.assertHolidayName(f"{name} (observed)", self.state_hols["AS"], obs_dt)
+        self.assertHolidayName(f"{name} (observed)", as_holidays, obs_dt)
         self.assertNoNonObservedHolidayName(
             f"{name} (observed)", UnitedStates(subdiv="AS", observed=False), obs_dt
         )
@@ -1044,7 +1038,8 @@ class TestUnitedStates(CommonCountryTests, TestCase):
     def test_holy_thursday(self):
         name = "Holy Thursday"
         self.assertNoHolidayName(name)
-        self.assertHolidayName(name, self.state_hols["VI"], range(1865, 2050))
+        vi_holidays = self.state_hols["VI"]
+        self.assertHolidayName(name, vi_holidays, range(1865, 2050))
         dt = (
             "2010-04-01",
             "2011-04-21",
@@ -1061,7 +1056,7 @@ class TestUnitedStates(CommonCountryTests, TestCase):
             "2022-04-14",
             "2023-04-06",
         )
-        self.assertHolidayName(name, self.state_hols["VI"], dt)
+        self.assertHolidayName(name, vi_holidays, dt)
 
     def test_good_friday(self):
         name = "Good Friday"
@@ -1103,7 +1098,8 @@ class TestUnitedStates(CommonCountryTests, TestCase):
     def test_easter_monday(self):
         name = "Easter Monday"
         self.assertNoHolidayName(name)
-        self.assertHolidayName(name, self.state_hols["VI"], range(1865, 2050))
+        vi_holidays = self.state_hols["VI"]
+        self.assertHolidayName(name, vi_holidays, range(1865, 2050))
         dt = (
             "2010-04-05",
             "2011-04-25",
@@ -1120,7 +1116,7 @@ class TestUnitedStates(CommonCountryTests, TestCase):
             "2022-04-18",
             "2023-04-10",
         )
-        self.assertHolidayName(name, self.state_hols["VI"], dt)
+        self.assertHolidayName(name, vi_holidays, dt)
 
     def test_confederate_memorial_day(self):
         name = "Confederate Memorial Day"
@@ -1146,9 +1142,10 @@ class TestUnitedStates(CommonCountryTests, TestCase):
             self.assertNoHolidayName(name, self.state_hols[subdiv], range(1865, 1866))
             self.assertHolidayName(name, self.state_hols[subdiv], dt)
 
+        ms_holidays = self.state_hols["MS"]
         self.assertHolidayName(
             name,
-            self.state_hols["MS"],
+            ms_holidays,
             "2010-04-26",
             "2011-04-25",
             "2012-04-30",
@@ -1165,19 +1162,19 @@ class TestUnitedStates(CommonCountryTests, TestCase):
             "2023-04-24",
             "2024-04-29",
         )
-        self.assertHolidayName(name, self.state_hols["MS"], range(1866, 2050))
-        self.assertNoHolidayName(name, self.state_hols["MS"], range(1865, 1866))
+        self.assertHolidayName(name, ms_holidays, range(1866, 2050))
+        self.assertNoHolidayName(name, ms_holidays, range(1865, 1866))
 
-        self.assertHolidayName(
-            name, self.state_hols["TX"], (f"{year}-01-19" for year in range(1931, 2050))
-        )
-        self.assertNoHolidayName(name, self.state_hols["TX"], range(1865, 1931))
+        tx_holidays = self.state_hols["TX"]
+        self.assertHolidayName(name, tx_holidays, (f"{year}-01-19" for year in range(1931, 2050)))
+        self.assertNoHolidayName(name, tx_holidays, range(1865, 1931))
 
-        self.assertHolidayName(name, self.state_hols["GA"], range(1866, 2016))
-        self.assertNoHolidayName(name, self.state_hols["GA"], range(2016, 2050))
+        ga_holidays = self.state_hols["GA"]
+        self.assertHolidayName(name, ga_holidays, range(1866, 2016))
+        self.assertNoHolidayName(name, ga_holidays, range(2016, 2050))
         self.assertHolidayName(
             name,
-            self.state_hols["GA"],
+            ga_holidays,
             "2010-04-26",
             "2011-04-25",
             "2012-04-23",
@@ -1188,10 +1185,10 @@ class TestUnitedStates(CommonCountryTests, TestCase):
 
         name = "State Holiday"
         self.assertNoHolidayName(name)
-        self.assertHolidayName(name, self.state_hols["GA"], range(2016, 2050))
+        self.assertHolidayName(name, ga_holidays, range(2016, 2050))
         self.assertHolidayName(
             name,
-            self.state_hols["GA"],
+            ga_holidays,
             "2016-04-25",
             "2017-04-24",
             "2018-04-23",
@@ -1205,14 +1202,14 @@ class TestUnitedStates(CommonCountryTests, TestCase):
     def test_san_jacinto_day(self):
         name = "San Jacinto Day"
         self.assertNoHolidayName(name)
-        self.assertHolidayName(
-            name, self.state_hols["TX"], (f"{year}-04-21" for year in range(1875, 2050))
-        )
-        self.assertNoHolidayName(name, self.state_hols["TX"], range(1865, 1875))
+        tx_holidays = self.state_hols["TX"]
+        self.assertHolidayName(name, tx_holidays, (f"{year}-04-21" for year in range(1875, 2050)))
+        self.assertNoHolidayName(name, tx_holidays, range(1865, 1875))
 
     def test_arbor_day(self):
         name = "Arbor Day"
         self.assertNoHolidayName(name)
+        ne_holidays = self.state_hols["NE"]
         dt = (
             "1989-04-28",
             "2010-04-30",
@@ -1230,15 +1227,14 @@ class TestUnitedStates(CommonCountryTests, TestCase):
             "2022-04-29",
             "2023-04-28",
         )
-        self.assertHolidayName(
-            name, self.state_hols["NE"], (f"{year}-04-22" for year in range(1875, 1989))
-        )
-        self.assertNoHolidayName(name, self.state_hols["NE"], range(1865, 1875))
-        self.assertHolidayName(name, self.state_hols["NE"], dt)
+        self.assertHolidayName(name, ne_holidays, (f"{year}-04-22" for year in range(1875, 1989)))
+        self.assertNoHolidayName(name, ne_holidays, range(1865, 1875))
+        self.assertHolidayName(name, ne_holidays, dt)
 
     def test_primary_election_day(self):
         name = "Primary Election Day"
         self.assertNoHolidayName(name)
+        in_holidays = self.state_hols["IN"]
         dt = (
             "2006-05-02",
             "2008-05-06",
@@ -1255,21 +1251,16 @@ class TestUnitedStates(CommonCountryTests, TestCase):
             "2022-05-03",
             "2023-05-02",
         )
-        self.assertHolidayName(
-            name, self.state_hols["IN"], 2006, 2008, 2010, 2012, 2014, range(2015, 2050)
-        )
-        self.assertNoHolidayName(
-            name, self.state_hols["IN"], range(1865, 2006), 2007, 2009, 2011, 2013
-        )
-        self.assertHolidayName(name, self.state_hols["IN"], dt)
+        self.assertHolidayName(name, in_holidays, 2006, 2008, 2010, 2012, 2014, range(2015, 2050))
+        self.assertNoHolidayName(name, in_holidays, range(1865, 2006), 2007, 2009, 2011, 2013)
+        self.assertHolidayName(name, in_holidays, dt)
 
     def test_truman_day(self):
         name = "Truman Day"
         self.assertNoHolidayName(name)
-        self.assertHolidayName(
-            name, self.state_hols["MO"], (f"{year}-05-08" for year in range(1949, 2050))
-        )
-        self.assertNoHolidayName(name, self.state_hols["MO"], range(1865, 1949))
+        mo_holidays = self.state_hols["MO"]
+        self.assertHolidayName(name, mo_holidays, (f"{year}-05-08" for year in range(1949, 2050)))
+        self.assertNoHolidayName(name, mo_holidays, range(1865, 1949))
         obs_dt = (
             "2010-05-07",
             "2011-05-09",
@@ -1277,7 +1268,7 @@ class TestUnitedStates(CommonCountryTests, TestCase):
             "2021-05-07",
             "2022-05-09",
         )
-        self.assertHolidayName(f"{name} (observed)", self.state_hols["MO"], obs_dt)
+        self.assertHolidayName(f"{name} (observed)", mo_holidays, obs_dt)
         self.assertNoNonObservedHolidayName(
             f"{name} (observed)", UnitedStates(subdiv="MO", observed=False), obs_dt
         )
@@ -1285,8 +1276,9 @@ class TestUnitedStates(CommonCountryTests, TestCase):
     def test_jefferson_davis_birthday(self):
         name = "Jefferson Davis Birthday"
         self.assertNoHolidayName(name)
-        self.assertHolidayName(name, self.state_hols["AL"], range(1890, 2050))
-        self.assertNoHolidayName(name, self.state_hols["AL"], range(1865, 1890))
+        al_holidays = self.state_hols["AL"]
+        self.assertHolidayName(name, al_holidays, range(1890, 2050))
+        self.assertNoHolidayName(name, al_holidays, range(1865, 1890))
         dt = (
             "2010-06-07",
             "2011-06-06",
@@ -1303,15 +1295,14 @@ class TestUnitedStates(CommonCountryTests, TestCase):
             "2022-06-06",
             "2023-06-05",
         )
-        self.assertHolidayName(name, self.state_hols["AL"], dt)
+        self.assertHolidayName(name, al_holidays, dt)
 
     def test_kamehameha_day(self):
         name = "Kamehameha Day"
         self.assertNoHolidayName(name)
-        self.assertHolidayName(
-            name, self.state_hols["HI"], (f"{year}-06-11" for year in range(1872, 2050))
-        )
-        self.assertNoHolidayName(name, self.state_hols["HI"], range(1865, 1872))
+        hi_holidays = self.state_hols["HI"]
+        self.assertHolidayName(name, hi_holidays, (f"{year}-06-11" for year in range(1872, 2050)))
+        self.assertNoHolidayName(name, hi_holidays, range(1865, 1872))
         obs_dt = (
             "2011-06-10",
             "2016-06-10",
@@ -1319,34 +1310,32 @@ class TestUnitedStates(CommonCountryTests, TestCase):
             "2022-06-10",
             "2023-06-12",
         )
-        self.assertHolidayName(f"{name} (observed)", self.state_hols["HI"], obs_dt)
+        self.assertHolidayName(f"{name} (observed)", hi_holidays, obs_dt)
         self.assertNoNonObservedHolidayName(
             f"{name} (observed)", UnitedStates(subdiv="HI", observed=False), obs_dt
         )
-        self.assertNoHolidayName(f"{name} (observed)", self.state_hols["HI"], range(1872, 2011))
+        self.assertNoHolidayName(f"{name} (observed)", hi_holidays, range(1872, 2011))
 
     def test_emancipation_day_in_texas(self):
         name = "Emancipation Day In Texas"
         self.assertNoHolidayName(name)
-        self.assertHolidayName(
-            name, self.state_hols["TX"], (f"{year}-06-19" for year in range(1980, 2050))
-        )
-        self.assertNoHolidayName(name, self.state_hols["TX"], range(1865, 1980))
+        tx_holidays = self.state_hols["TX"]
+        self.assertHolidayName(name, tx_holidays, (f"{year}-06-19" for year in range(1980, 2050)))
+        self.assertNoHolidayName(name, tx_holidays, range(1865, 1980))
 
     def test_west_virginia_day(self):
         name = "West Virginia Day"
         self.assertNoHolidayName(name)
-        self.assertHolidayName(
-            name, self.state_hols["WV"], (f"{year}-06-20" for year in range(1927, 2050))
-        )
-        self.assertNoHolidayName(name, self.state_hols["WV"], range(1865, 1927))
+        wv_holidays = self.state_hols["WV"]
+        self.assertHolidayName(name, wv_holidays, (f"{year}-06-20" for year in range(1927, 2050)))
+        self.assertNoHolidayName(name, wv_holidays, range(1865, 1927))
         obs_dt = (
             "2010-06-21",
             "2015-06-19",
             "2020-06-19",
             "2021-06-21",
         )
-        self.assertHolidayName(f"{name} (observed)", self.state_hols["WV"], obs_dt)
+        self.assertHolidayName(f"{name} (observed)", wv_holidays, obs_dt)
         self.assertNoNonObservedHolidayName(
             f"{name} (observed)", UnitedStates(subdiv="WV", observed=False), obs_dt
         )
@@ -1361,10 +1350,9 @@ class TestUnitedStates(CommonCountryTests, TestCase):
     def test_manua_islands_cession_day(self):
         name = "Manu'a Islands Cession Day"
         self.assertNoHolidayName(name)
-        self.assertHolidayName(
-            name, self.state_hols["AS"], (f"{year}-07-16" for year in range(1983, 2050))
-        )
-        self.assertNoHolidayName(name, self.state_hols["AS"], range(1865, 1983))
+        as_holidays = self.state_hols["AS"]
+        self.assertHolidayName(name, as_holidays, (f"{year}-07-16" for year in range(1983, 2050)))
+        self.assertNoHolidayName(name, as_holidays, range(1865, 1983))
         obs_dt = (
             "2000-07-17",
             "2005-07-15",
@@ -1375,7 +1363,7 @@ class TestUnitedStates(CommonCountryTests, TestCase):
             "2022-07-15",
             "2023-07-17",
         )
-        self.assertHolidayName(f"{name} (observed)", self.state_hols["AS"], obs_dt)
+        self.assertHolidayName(f"{name} (observed)", as_holidays, obs_dt)
         self.assertNoNonObservedHolidayName(
             f"{name} (observed)", UnitedStates(subdiv="AS", observed=False), obs_dt
         )
@@ -1383,17 +1371,15 @@ class TestUnitedStates(CommonCountryTests, TestCase):
     def test_liberation_day_guam(self):
         name = "Liberation Day (Guam)"
         self.assertNoHolidayName(name)
-        self.assertHolidayName(
-            name, self.state_hols["GU"], (f"{year}-07-21" for year in range(1945, 2050))
-        )
-        self.assertNoHolidayName(name, self.state_hols["WV"], range(1865, 1945))
+        gu_holidays = self.state_hols["GU"]
+        self.assertHolidayName(name, gu_holidays, (f"{year}-07-21" for year in range(1945, 2050)))
+        self.assertNoHolidayName(name, gu_holidays, range(1865, 1945))
 
     def test_pioneer_day(self):
         name = "Pioneer Day"
         self.assertNoHolidayName(name)
-        self.assertHolidayName(
-            name, self.state_hols["UT"], (f"{year}-07-24" for year in range(1865, 2050))
-        )
+        ut_holidays = self.state_hols["UT"]
+        self.assertHolidayName(name, ut_holidays, (f"{year}-07-24" for year in range(1865, 2050)))
         self.assertNoHolidayName(name, UnitedStates(subdiv="UT", years=1848))
         obs_dt = (
             "2010-07-23",
@@ -1402,7 +1388,7 @@ class TestUnitedStates(CommonCountryTests, TestCase):
             "2021-07-23",
             "2022-07-25",
         )
-        self.assertHolidayName(f"{name} (observed)", self.state_hols["UT"], obs_dt)
+        self.assertHolidayName(f"{name} (observed)", ut_holidays, obs_dt)
         self.assertNoNonObservedHolidayName(
             f"{name} (observed)", UnitedStates(subdiv="UT", observed=False), obs_dt
         )
@@ -1410,16 +1396,15 @@ class TestUnitedStates(CommonCountryTests, TestCase):
     def test_constitution_day(self):
         name = "Constitution Day"
         self.assertNoHolidayName(name)
-        self.assertHolidayName(
-            name, self.state_hols["PR"], (f"{year}-07-25" for year in range(1865, 2050))
-        )
+        pr_holidays = self.state_hols["PR"]
+        self.assertHolidayName(name, pr_holidays, (f"{year}-07-25" for year in range(1865, 2050)))
         obs_dt = (
             "1999-07-26",
             "2004-07-26",
             "2010-07-26",
             "2021-07-26",
         )
-        self.assertHolidayName(f"{name} (observed)", self.state_hols["PR"], obs_dt)
+        self.assertHolidayName(f"{name} (observed)", pr_holidays, obs_dt)
         self.assertNoNonObservedHolidayName(
             f"{name} (observed)", UnitedStates(subdiv="PR", observed=False), obs_dt
         )
@@ -1427,8 +1412,9 @@ class TestUnitedStates(CommonCountryTests, TestCase):
     def test_victory_day(self):
         name = "Victory Day"
         self.assertNoHolidayName(name)
-        self.assertHolidayName(name, self.state_hols["RI"], range(1948, 2050))
-        self.assertNoHolidayName(name, self.state_hols["RI"], range(1865, 1948))
+        ri_holidays = self.state_hols["RI"]
+        self.assertHolidayName(name, ri_holidays, range(1948, 2050))
+        self.assertNoHolidayName(name, ri_holidays, range(1865, 1948))
         dt = (
             "2010-08-09",
             "2011-08-08",
@@ -1445,13 +1431,14 @@ class TestUnitedStates(CommonCountryTests, TestCase):
             "2022-08-08",
             "2023-08-14",
         )
-        self.assertHolidayName(name, self.state_hols["RI"], dt)
+        self.assertHolidayName(name, ri_holidays, dt)
 
     def test_statehood_day(self):
         name = "Statehood Day"
         self.assertNoHolidayName(name)
-        self.assertHolidayName(name, self.state_hols["HI"], range(1959, 2050))
-        self.assertNoHolidayName(name, self.state_hols["HI"], range(1865, 1959))
+        hi_holidays = self.state_hols["HI"]
+        self.assertHolidayName(name, hi_holidays, range(1959, 2050))
+        self.assertNoHolidayName(name, hi_holidays, range(1865, 1959))
         dt = (
             "2010-08-20",
             "2011-08-19",
@@ -1468,14 +1455,13 @@ class TestUnitedStates(CommonCountryTests, TestCase):
             "2022-08-19",
             "2023-08-18",
         )
-        self.assertHolidayName(name, self.state_hols["HI"], dt)
+        self.assertHolidayName(name, hi_holidays, dt)
 
     def test_bennington_battle_day(self):
         name = "Bennington Battle Day"
         self.assertNoHolidayName(name)
-        self.assertHolidayName(
-            name, self.state_hols["VT"], (f"{year}-08-16" for year in range(1865, 2050))
-        )
+        vt_holidays = self.state_hols["VT"]
+        self.assertHolidayName(name, vt_holidays, (f"{year}-08-16" for year in range(1865, 2050)))
         self.assertNoHolidayName(name, UnitedStates(subdiv="VT", years=1777))
         obs_dt = (
             "2009-08-17",
@@ -1483,7 +1469,7 @@ class TestUnitedStates(CommonCountryTests, TestCase):
             "2015-08-17",
             "2020-08-17",
         )
-        self.assertHolidayName(f"{name} (observed)", self.state_hols["VT"], obs_dt)
+        self.assertHolidayName(f"{name} (observed)", vt_holidays, obs_dt)
         self.assertNoNonObservedHolidayName(
             f"{name} (observed)", UnitedStates(subdiv="VT", observed=False), obs_dt
         )
@@ -1491,10 +1477,9 @@ class TestUnitedStates(CommonCountryTests, TestCase):
     def test_lyndon_baines_johnson_day(self):
         name = "Lyndon Baines Johnson Day"
         self.assertNoHolidayName(name)
-        self.assertHolidayName(
-            name, self.state_hols["TX"], (f"{year}-08-27" for year in range(1973, 2050))
-        )
-        self.assertNoHolidayName(name, self.state_hols["WV"], range(1865, 1973))
+        tx_holidays = self.state_hols["TX"]
+        self.assertHolidayName(name, tx_holidays, (f"{year}-08-27" for year in range(1973, 2050)))
+        self.assertNoHolidayName(name, tx_holidays, range(1865, 1973))
 
     def test_commonwealth_cultural_day(self):
         name = "Commonwealth Cultural Day"
@@ -1520,7 +1505,8 @@ class TestUnitedStates(CommonCountryTests, TestCase):
     def test_white_sunday(self):
         name = "White Sunday"
         self.assertNoHolidayName(name)
-        self.assertHolidayName(name, self.state_hols["AS"], range(1865, 2050))
+        as_holidays = self.state_hols["AS"]
+        self.assertHolidayName(name, as_holidays, range(1865, 2050))
         dt = (
             "2010-10-10",
             "2011-10-09",
@@ -1538,22 +1524,21 @@ class TestUnitedStates(CommonCountryTests, TestCase):
             "2023-10-08",
             "2024-10-13",
         )
-        self.assertHolidayName(name, self.state_hols["AS"], dt)
+        self.assertHolidayName(name, as_holidays, dt)
 
     def test_alaska_day(self):
         name = "Alaska Day"
         self.assertNoHolidayName(name)
-        self.assertHolidayName(
-            name, self.state_hols["AK"], (f"{year}-10-18" for year in range(1917, 2050))
-        )
-        self.assertNoHolidayName(name, self.state_hols["AK"], range(1865, 1917))
+        ak_holidays = self.state_hols["AK"]
+        self.assertHolidayName(name, ak_holidays, (f"{year}-10-18" for year in range(1917, 2050)))
+        self.assertNoHolidayName(name, ak_holidays, range(1865, 1917))
         obs_dt = (
             "2009-10-19",
             "2014-10-17",
             "2015-10-19",
             "2020-10-19",
         )
-        self.assertHolidayName(f"{name} (observed)", self.state_hols["AK"], obs_dt)
+        self.assertHolidayName(f"{name} (observed)", ak_holidays, obs_dt)
         self.assertNoNonObservedHolidayName(
             f"{name} (observed)", UnitedStates(subdiv="AK", observed=False), obs_dt
         )
@@ -1561,10 +1546,9 @@ class TestUnitedStates(CommonCountryTests, TestCase):
     def test_nevada_day(self):
         name = "Nevada Day"
         self.assertNoHolidayName(name)
-        self.assertHolidayName(
-            name, self.state_hols["NV"], (f"{year}-10-31" for year in range(1933, 2000))
-        )
-        self.assertNoHolidayName(name, self.state_hols["NV"], range(1865, 1933))
+        nv_holidays = self.state_hols["NV"]
+        self.assertHolidayName(name, nv_holidays, (f"{year}-10-31" for year in range(1933, 2000)))
+        self.assertNoHolidayName(name, nv_holidays, range(1865, 1933))
         dt = (
             "2000-10-27",
             "2010-10-29",
@@ -1582,7 +1566,7 @@ class TestUnitedStates(CommonCountryTests, TestCase):
             "2022-10-28",
             "2023-10-27",
         )
-        self.assertHolidayName(name, self.state_hols["NV"], dt)
+        self.assertHolidayName(name, nv_holidays, dt)
 
         obs_dt = (
             "1992-10-30",
@@ -1590,7 +1574,7 @@ class TestUnitedStates(CommonCountryTests, TestCase):
             "1998-10-30",
             "1999-11-01",
         )
-        self.assertHolidayName(f"{name} (observed)", self.state_hols["NV"], obs_dt)
+        self.assertHolidayName(f"{name} (observed)", nv_holidays, obs_dt)
         self.assertNoNonObservedHolidayName(
             f"{name} (observed)", UnitedStates(subdiv="NV", observed=False), obs_dt
         )
@@ -1617,8 +1601,9 @@ class TestUnitedStates(CommonCountryTests, TestCase):
         )
         for subdiv in ("DE", "HI", "IL", "LA", "MP", "MT", "NH", "NJ", "WV"):
             self.assertHolidayName(name, self.state_hols[subdiv], dt)
-            self.assertNoHolidayName(name, self.state_hols[subdiv], range(1865, 2008))
-            self.assertNoHolidayName(name, self.state_hols[subdiv], range(2009, 2050, 2))
+            self.assertNoHolidayName(
+                name, self.state_hols[subdiv], range(1865, 2008), range(2009, 2050, 2)
+            )
 
         dt = (
             "2008-11-04",
@@ -1685,56 +1670,43 @@ class TestUnitedStates(CommonCountryTests, TestCase):
             "2020-11-03",
             "2024-11-05",
         )
-        subdiv_us_territories = {"AS", "GU", "MP", "PR", "UM", "VI"}
-        for subdiv in set(UnitedStates.subdivisions) - subdiv_us_territories:
-            self.assertNoHolidayName(
-                name, UnitedStates(subdiv=subdiv, categories=UNOFFICIAL, years=(1844, 1847))
-            )
-            self.assertHolidayName(
-                name,
-                UnitedStates(subdiv=subdiv, categories=UNOFFICIAL),
-                dt,
-            )
-        for subdiv in subdiv_us_territories:
-            self.assertNoHolidayName(
-                name, UnitedStates(subdiv=subdiv, categories=UNOFFICIAL, years=range(1865, 2050))
-            )
+        for subdiv in UnitedStates.subdivisions:
+            holidays = UnitedStates(subdiv=subdiv, categories=UNOFFICIAL, years=range(1865, 2050))
+            if subdiv in {"AS", "GU", "MP", "PR", "UM", "VI"}:
+                self.assertNoHolidayName(name, holidays)
+            else:
+                self.assertNoHolidayName(
+                    name, UnitedStates(subdiv=subdiv, categories=UNOFFICIAL, years=(1844, 1847))
+                )
+                self.assertHolidayName(name, holidays, dt)
 
     def test_valentines_day(self):
         name = "Valentine's Day"
         self.assertNoHolidayName(name)
         self.assertNoHolidayName(name, UnitedStates(categories=UNOFFICIAL, years=1846))
         self.assertHolidayName(
-            name,
-            UnitedStates(categories=UNOFFICIAL),
-            (f"{year}-02-14" for year in range(1865, 2050)),
+            name, self.unofficial_hols, (f"{year}-02-14" for year in range(1865, 2050))
         )
 
     def test_st_patricks_day(self):
         name = "Saint Patrick's Day"
         self.assertNoHolidayName(name)
         self.assertHolidayName(
-            name,
-            UnitedStates(categories=UNOFFICIAL),
-            (f"{year}-03-17" for year in range(1865, 2050)),
+            name, self.unofficial_hols, (f"{year}-03-17" for year in range(1865, 2050))
         )
 
     def test_halloween(self):
         name = "Halloween"
         self.assertNoHolidayName(name)
         self.assertHolidayName(
-            name,
-            UnitedStates(categories=UNOFFICIAL),
-            (f"{year}-10-31" for year in range(1865, 2050)),
+            name, self.unofficial_hols, (f"{year}-10-31" for year in range(1865, 2050))
         )
 
     def test_groundhog_day(self):
         name = "Groundhog Day"
         self.assertNoHolidayName(name)
         self.assertHolidayName(
-            name,
-            UnitedStates(categories=UNOFFICIAL),
-            (f"{year}-02-02" for year in range(1886, 2050)),
+            name, self.unofficial_hols, (f"{year}-02-02" for year in range(1886, 2050))
         )
 
     def test_all_souls_day(self):
@@ -1747,16 +1719,15 @@ class TestUnitedStates(CommonCountryTests, TestCase):
     def test_citizenship_day(self):
         name = "Citizenship Day"
         self.assertNoHolidayName(name)
-        self.assertHolidayName(
-            name, self.state_hols["MP"], (f"{year}-11-04" for year in range(1865, 2050))
-        )
+        mp_holidays = self.state_hols["MP"]
+        self.assertHolidayName(name, mp_holidays, (f"{year}-11-04" for year in range(1865, 2050)))
         obs_dt = (
             "2012-11-05",
             "2017-11-03",
             "2018-11-05",
             "2023-11-03",
         )
-        self.assertHolidayName(f"{name} (observed)", self.state_hols["MP"], obs_dt)
+        self.assertHolidayName(f"{name} (observed)", mp_holidays, obs_dt)
         self.assertNoNonObservedHolidayName(
             f"{name} (observed)", UnitedStates(subdiv="MP", observed=False), obs_dt
         )
@@ -1764,16 +1735,15 @@ class TestUnitedStates(CommonCountryTests, TestCase):
     def test_discovery_day(self):
         name = "Discovery Day"
         self.assertNoHolidayName(name)
-        self.assertHolidayName(
-            name, self.state_hols["PR"], (f"{year}-11-19" for year in range(1865, 2050))
-        )
+        pr_holidays = self.state_hols["PR"]
+        self.assertHolidayName(name, pr_holidays, (f"{year}-11-19" for year in range(1865, 2050)))
         obs_dt = (
             "2000-11-20",
             "2006-11-20",
             "2017-11-20",
             "2023-11-20",
         )
-        self.assertHolidayName(f"{name} (observed)", self.state_hols["PR"], obs_dt)
+        self.assertHolidayName(f"{name} (observed)", pr_holidays, obs_dt)
         self.assertNoNonObservedHolidayName(
             f"{name} (observed)", UnitedStates(subdiv="PR", observed=False), obs_dt
         )
@@ -1819,17 +1789,16 @@ class TestUnitedStates(CommonCountryTests, TestCase):
     def test_robert_lee_birthday(self):
         name_1 = "Robert E. Lee's Birthday"
         name_2 = "State Holiday"
+        ga_holidays = self.state_hols["GA"]
         self.assertNoHolidayName(name_1)
         self.assertNoHolidayName(name_2)
-        self.assertHolidayName(name_1, self.state_hols["GA"], range(1986, 2016))
-        self.assertHolidayName(name_2, self.state_hols["GA"], range(2016, 2050))
-        self.assertNoHolidayName(
-            name_1, self.state_hols["GA"], range(1865, 1986), range(2016, 2050)
-        )
-        self.assertNoHolidayName(name_2, self.state_hols["GA"], range(1865, 2016))
+        self.assertHolidayName(name_1, ga_holidays, range(1986, 2016))
+        self.assertHolidayName(name_2, ga_holidays, range(2016, 2050))
+        self.assertNoHolidayName(name_1, ga_holidays, range(1865, 1986), range(2016, 2050))
+        self.assertNoHolidayName(name_2, ga_holidays, range(1865, 2016))
         self.assertHolidayName(
             name_1,
-            self.state_hols["GA"],
+            ga_holidays,
             "2010-11-26",
             "2011-11-25",
             "2012-11-23",
@@ -1839,7 +1808,7 @@ class TestUnitedStates(CommonCountryTests, TestCase):
         )
         self.assertHolidayName(
             name_2,
-            self.state_hols["GA"],
+            ga_holidays,
             "2016-11-25",
             "2017-11-24",
             "2018-11-23",
@@ -1860,16 +1829,15 @@ class TestUnitedStates(CommonCountryTests, TestCase):
     def test_constitution_day_mp(self):
         name = "Constitution Day"
         self.assertNoHolidayName(name)
-        self.assertHolidayName(
-            name, self.state_hols["MP"], (f"{year}-12-08" for year in range(1865, 2050))
-        )
+        mp_holidays = self.state_hols["MP"]
+        self.assertHolidayName(name, mp_holidays, (f"{year}-12-08" for year in range(1865, 2050)))
         obs_dt = (
             "2012-12-07",
             "2013-12-09",
             "2018-12-07",
             "2019-12-09",
         )
-        self.assertHolidayName(f"{name} (observed)", self.state_hols["MP"], obs_dt)
+        self.assertHolidayName(f"{name} (observed)", mp_holidays, obs_dt)
         self.assertNoNonObservedHolidayName(
             f"{name} (observed)", UnitedStates(subdiv="MP", observed=False), obs_dt
         )
@@ -1894,7 +1862,7 @@ class TestUnitedStates(CommonCountryTests, TestCase):
             self.assertHolidayName(
                 name,
                 self.state_hols[subdiv],
-                (f"{year}-12-24" for year in range(start_year if start_year > 0 else 1865, 2050)),
+                (f"{year}-12-24" for year in range(start_year, 2050)),
             )
             self.assertNoHolidayName(name, self.state_hols[subdiv], range(1865, start_year))
             self.assertHolidayName(f"{name} (observed)", self.state_hols[subdiv], obs_dt)
@@ -1944,21 +1912,20 @@ class TestUnitedStates(CommonCountryTests, TestCase):
             self.assertHolidayName(
                 name,
                 self.state_hols[subdiv],
-                (f"{year}-12-31" for year in range(start_year if start_year > 0 else 1865, 2050)),
+                (f"{year}-12-31" for year in range(start_year, 2050)),
             )
-            if start_year > 0:
-                self.assertNoHolidayName(name, self.state_hols[subdiv], range(1865, start_year))
+            self.assertNoHolidayName(name, self.state_hols[subdiv], range(1865, start_year))
             self.assertHolidayName(f"{name} (observed)", self.state_hols[subdiv], obs_dt)
             self.assertNoNonObservedHolidayName(
                 f"{name} (observed)", UnitedStates(subdiv=subdiv, observed=False), obs_dt
             )
 
     def test_frances_xavier_cabrini_day(self):
-        co_holidays = self.state_hols["CO"]
         name = "Frances Xavier Cabrini Day"
-
-        self.assertNoHolidayName(name, co_holidays, range(2000, 2019))
-        self.assertHolidayName(name, co_holidays, range(2020, 2024))
+        self.assertNoHolidayName(name)
+        co_holidays = self.state_hols["CO"]
+        self.assertNoHolidayName(name, co_holidays, range(1865, 2019))
+        self.assertHolidayName(name, co_holidays, range(2020, 2050))
         self.assertHoliday(
             co_holidays,
             (