wwvb 4.0.0a0__py3-none-any.whl → 5.0.0__py3-none-any.whl

wwvb/testcli.py

@@ -1,291 +0,0 @@
-#!/usr/bin/python3
-"""Test most wwvblib commandline programs"""
-
-# ruff: noqa: N802 D102
-# Copyright (C) 2011-2020 Jeff Epler <jepler@gmail.com>
-# SPDX-FileCopyrightText: 2021 Jeff Epler
-#
-# SPDX-License-Identifier: GPL-3.0-only
-
-import json
-import os
-import subprocess
-import sys
-import unittest
-from typing import Any, Sequence
-
-coverage_add = ("-m", "coverage", "run", "--branch", "-p") if "COVERAGE_RUN" in os.environ else ()
-
-
-class CLITestCase(unittest.TestCase):
-    """Test various CLI commands within wwvbpy"""
-
-    def programOutput(self, *args: str) -> str:
-        env = os.environ.copy()
-        env["PYTHONIOENCODING"] = "utf-8"
-        return subprocess.check_output(args, stdin=subprocess.DEVNULL, encoding="utf-8", env=env)
-
-    def moduleArgs(self, *args: str) -> Sequence[str]:
-        return (sys.executable, *coverage_add, "-m", *args)
-
-    def moduleOutput(self, *args: str) -> str:
-        return self.programOutput(sys.executable, *coverage_add, "-m", *args)
-
-    def assertProgramOutput(self, expected: str, *args: str) -> None:
-        """Check the output from invoking a program matches the expected"""
-        actual = self.programOutput(*args)
-        self.assertMultiLineEqual(expected, actual, f"args={args}")
-
-    def assertProgramOutputStarts(self, expected: str, *args: str) -> None:
-        """Check the output from invoking a program matches the expected"""
-        actual = self.programOutput(*args)
-        self.assertMultiLineEqual(expected, actual[: len(expected)], f"args={args}")
-
-    def assertModuleOutput(self, expected: str, *args: str) -> None:
-        """Check the output from invoking a `python -m modulename` program matches the expected"""
-        actual = self.moduleOutput(*args)
-        self.assertMultiLineEqual(expected, actual, f"args={args}")
-
-    def assertStarts(self, expected: str, actual: str, *args: str) -> None:
-        self.assertMultiLineEqual(expected, actual[: len(expected)], f"args={args}")
-
-    def assertModuleJson(self, expected: Any, *args: str) -> None:
-        """Check the output from invoking a `python -m modulename` program matches the expected"""
-        actual = self.moduleOutput(*args)
-        self.assertEqual(json.loads(actual), expected)
-
-    def assertModuleOutputStarts(self, expected: str, *args: str) -> None:
-        """Check the output from invoking a `python -m modulename` program matches the expected"""
-        actual = self.moduleOutput(*args)
-        self.assertStarts(expected, actual, *args)
-
-    def assertProgramError(self, *args: str) -> None:
-        """Check the output from invoking a program fails"""
-        env = os.environ.copy()
-        env["PYTHONIOENCODING"] = "utf-8"
-        with self.assertRaises(subprocess.SubprocessError):
-            subprocess.check_output(
-                args,
-                stdin=subprocess.DEVNULL,
-                stderr=subprocess.DEVNULL,
-                encoding="utf-8",
-                env=env,
-            )
-
-    def assertModuleError(self, *args: str) -> None:
-        """Check the output from invoking a `python -m modulename` program fails"""
-        self.assertProgramError(*self.moduleArgs(*args))
-
-    def test_gen(self) -> None:
-        """Test wwvb.gen"""
-        self.assertModuleOutput(
-            """\
-WWVB timecode: year=2020 days=001 hour=12 min=30 dst=0 ut1=-200 ly=1 ls=0
-2020-001 12:30  201100000200010001020000000002000100010200100001020000010002
-""",
-            "wwvb.gen",
-            "-m",
-            "1",
-            "2020-1-1 12:30",
-        )
-
-        self.assertModuleOutput(
-            """\
-WWVB timecode: year=2020 days=001 hour=12 min=30 dst=0 ut1=-200 ly=1 ls=0
-2020-001 12:30  201100000200010001020000000002000100010200100001020000010002
-""",
-            "wwvb.gen",
-            "-m",
-            "1",
-            "2020",
-            "1",
-            "12",
-            "30",
-        )
-
-        self.assertModuleOutput(
-            """\
-WWVB timecode: year=2020 days=001 hour=12 min=30 dst=0 ut1=-200 ly=1 ls=0
-2020-001 12:30  201100000200010001020000000002000100010200100001020000010002
-""",
-            "wwvb.gen",
-            "-m",
-            "1",
-            "2020",
-            "1",
-            "1",
-            "12",
-            "30",
-        )
-
-        self.assertModuleError("wwvb.gen", "-m", "1", "2021", "7")
-
-        # Asserting a leap second
-        self.assertModuleOutput(
-            """\
-WWVB timecode: year=2020 days=001 hour=12 min=30 dst=0 ut1=-500 ly=1 ls=1
-2020-001 12:30  201100000200010001020000000002000100010201010001020000011002
-""",
-            "wwvb.gen",
-            "-m",
-            "1",
-            "-s",
-            "2020-1-1 12:30",
-        )
-
-        # Asserting a different ut1 value
-        self.assertModuleOutput(
-            """\
-WWVB timecode: year=2020 days=001 hour=12 min=30 dst=0 ut1=-300 ly=1 ls=0
-2020-001 12:30  201100000200010001020000000002000100010200110001020000010002
-""",
-            "wwvb.gen",
-            "-m",
-            "1",
-            "-d",
-            "-300",
-            "2020-1-1 12:30",
-        )
-
-    def test_dut1table(self) -> None:
-        """Test the dut1table program"""
-        self.assertModuleOutputStarts(
-            """\
-1972-01-01 -0.2  182 LS on 1972-06-30 23:59:60 UTC
-1972-07-01  0.8  123
-1972-11-01  0.0   30
-1972-12-01 -0.2   31 LS on 1972-12-31 23:59:60 UTC
-""",
-            "wwvb.dut1table",
-        )
-
-    def test_json(self) -> None:
-        """Test the JSON output format"""
-        self.assertModuleJson(
-            [
-                {
-                    "year": 2021,
-                    "days": 340,
-                    "hour": 3,
-                    "minute": 40,
-                    "amplitude": "210000000200000001120011001002000000010200010001020001000002",
-                    "phase": "111110011011010101000100100110011110001110111010111101001011",
-                },
-                {
-                    "year": 2021,
-                    "days": 340,
-                    "hour": 3,
-                    "minute": 41,
-                    "amplitude": "210000001200000001120011001002000000010200010001020001000002",
-                    "phase": "001010011100100011000101110000100001101000001111101100000010",
-                },
-            ],
-            "wwvb.gen",
-            "-m",
-            "2",
-            "--style",
-            "json",
-            "--channel",
-            "both",
-            "2021-12-6 3:40",
-        )
-        self.assertModuleJson(
-            [
-                {
-                    "year": 2021,
-                    "days": 340,
-                    "hour": 3,
-                    "minute": 40,
-                    "amplitude": "210000000200000001120011001002000000010200010001020001000002",
-                },
-                {
-                    "year": 2021,
-                    "days": 340,
-                    "hour": 3,
-                    "minute": 41,
-                    "amplitude": "210000001200000001120011001002000000010200010001020001000002",
-                },
-            ],
-            "wwvb.gen",
-            "-m",
-            "2",
-            "--style",
-            "json",
-            "--channel",
-            "amplitude",
-            "2021-12-6 3:40",
-        )
-        self.assertModuleJson(
-            [
-                {
-                    "year": 2021,
-                    "days": 340,
-                    "hour": 3,
-                    "minute": 40,
-                    "phase": "111110011011010101000100100110011110001110111010111101001011",
-                },
-                {
-                    "year": 2021,
-                    "days": 340,
-                    "hour": 3,
-                    "minute": 41,
-                    "phase": "001010011100100011000101110000100001101000001111101100000010",
-                },
-            ],
-            "wwvb.gen",
-            "-m",
-            "2",
-            "--style",
-            "json",
-            "--channel",
-            "phase",
-            "2021-12-6 3:40",
-        )
-
-    def test_sextant(self) -> None:
-        """Test the sextant output format"""
-        self.assertModuleOutput(
-            """\
-WWVB timecode: year=2021 days=340 hour=03 min=40 dst=0 ut1=-100 ly=0 ls=0 --style=sextant
-2021-340 03:40  \
-🬋🬩🬋🬹🬩🬹🬩🬹🬩🬹🬍🬎🬍🬎🬩🬹🬩🬹🬋🬍🬩🬹🬩🬹🬍🬎🬩🬹🬍🬎🬩🬹🬍🬎🬋🬹🬋🬎🬋🬍🬍🬎🬩🬹🬋🬎🬋🬎🬩🬹🬍🬎🬋🬎🬩🬹🬩🬹🬋🬍🬍🬎🬩🬹🬩🬹🬩🬹🬩🬹🬍🬎🬍🬎🬋🬎🬩🬹🬋🬩🬩🬹🬍🬎🬩🬹🬋🬹🬩🬹🬍🬎🬩🬹🬋🬎🬩🬹🬋🬩🬩🬹🬩🬹🬍🬎🬋🬹🬍🬎🬍🬎🬩🬹🬍🬎🬩🬹🬋🬩
-
-2021-340 03:41  \
-🬋🬍🬋🬎🬩🬹🬍🬎🬩🬹🬍🬎🬍🬎🬩🬹🬋🬹🬋🬩🬍🬎🬍🬎🬩🬹🬍🬎🬍🬎🬍🬎🬩🬹🬋🬹🬋🬎🬋🬍🬍🬎🬩🬹🬋🬎🬋🬹🬩🬹🬩🬹🬋🬎🬍🬎🬍🬎🬋🬍🬩🬹🬍🬎🬍🬎🬍🬎🬍🬎🬩🬹🬩🬹🬋🬎🬩🬹🬋🬍🬍🬎🬍🬎🬍🬎🬋🬎🬩🬹🬩🬹🬩🬹🬋🬹🬩🬹🬋🬍🬩🬹🬩🬹🬍🬎🬋🬎🬍🬎🬍🬎🬍🬎🬍🬎🬩🬹🬋🬍
-
-""",
-            "wwvb.gen",
-            "-m",
-            "2",
-            "--style",
-            "sextant",
-            "2021-12-6 3:40",
-        )
-
-    def test_now(self) -> None:
-        """Test outputting timecodes for 'now'"""
-        self.assertModuleOutputStarts(
-            "WWVB timecode: year=",
-            "wwvb.gen",
-            "-m",
-            "1",
-        )
-
-    def test_decode(self) -> None:
-        """Test the commandline decoder"""
-        self.assertModuleOutput(
-            """\
-201100000200100001020011001012000000010200010001020001000002
-year=2021 days=350 hour=22 min=30 dst=0 ut1=-100 ly=0 ls=0
-""",
-            "wwvb.decode",
-            "201100000200100001020011001012000000010200010001020001000002",
-        )
-
-        self.assertModuleOutput(
-            """\
-201101111200100001020011001012000000010200010001020001000002
-""",
-            "wwvb.decode",
-            "201101111200100001020011001012000000010200010001020001000002",
-        )

wwvb/testdaylight.py

@@ -1,60 +0,0 @@
-#!/usr/bin/python3
-"""Test of daylight saving time calculations"""
-
-# SPDX-FileCopyrightText: 2021 Jeff Epler
-#
-# SPDX-License-Identifier: GPL-3.0-only
-
-import datetime
-import unittest
-
-import wwvb
-from wwvb.tz import Mountain
-
-
-class TestDaylight(unittest.TestCase):
-    """Test of daylight saving time calculations"""
-
-    def test_onset(self) -> None:
-        """Test that the onset of DST is the same in Mountain and WWVBMinute (which uses ls bits)"""
-        for h in [8, 9, 10]:
-            for dm in range(-1441, 1442):
-                d = datetime.datetime(2021, 3, 14, h, 0, tzinfo=datetime.timezone.utc) + datetime.timedelta(minutes=dm)
-                m = wwvb.WWVBMinute.from_datetime(d)
-                self.assertEqual(
-                    m.as_datetime_local().replace(tzinfo=Mountain),
-                    d.astimezone(Mountain),
-                )
-
-    def test_end(self) -> None:
-        """Test that the end of DST is the same in Mountain and WWVBMinute (which uses ls bits)"""
-        for h in [7, 8, 9]:
-            for dm in range(-1441, 1442):
-                d = datetime.datetime(2021, 11, 7, h, 0, tzinfo=datetime.timezone.utc) + datetime.timedelta(minutes=dm)
-                m = wwvb.WWVBMinute.from_datetime(d)
-                self.assertEqual(
-                    m.as_datetime_local().replace(tzinfo=Mountain),
-                    d.astimezone(Mountain),
-                )
-
-    def test_midsummer(self) -> None:
-        """Test that middle of DST is the same in Mountain and WWVBMinute (which uses ls bits)"""
-        for h in [7, 8, 9]:
-            for dm in (-1, 0, 1):
-                d = datetime.datetime(2021, 7, 7, h, 0, tzinfo=datetime.timezone.utc) + datetime.timedelta(minutes=dm)
-                m = wwvb.WWVBMinute.from_datetime(d)
-                self.assertEqual(
-                    m.as_datetime_local().replace(tzinfo=Mountain),
-                    d.astimezone(Mountain),
-                )
-
-    def test_midwinter(self) -> None:
-        """Test that middle of standard time is the same in Mountain and WWVBMinute (which uses ls bits)"""
-        for h in [7, 8, 9]:
-            for dm in (-1, 0, 1):
-                d = datetime.datetime(2021, 12, 25, h, 0, tzinfo=datetime.timezone.utc) + datetime.timedelta(minutes=dm)
-                m = wwvb.WWVBMinute.from_datetime(d)
-                self.assertEqual(
-                    m.as_datetime_local().replace(tzinfo=Mountain),
-                    d.astimezone(Mountain),
-                )

wwvb/testls.py

@@ -1,63 +0,0 @@
-#!/usr/bin/python3
-"""Leap seconds tests"""
-
-# SPDX-FileCopyrightText: 2021 Jeff Epler
-#
-# SPDX-License-Identifier: GPL-3.0-only
-
-import datetime
-import unittest
-
-import leapseconddata
-
-import wwvb
-
-from . import iersdata
-
-ONE_DAY = datetime.timedelta(days=1)
-
-
-def next_month(d: datetime.date) -> datetime.date:
-    """Return the start of the next month after the day 'd'"""
-    d = d.replace(day=28)
-    while True:
-        d0 = d
-        d = d + ONE_DAY
-        if d.month != d0.month:
-            return d
-
-
-class TestLeapSecond(unittest.TestCase):
-    """Leap second tests"""
-
-    maxDiff = 9999
-
-    def test_leap(self) -> None:
-        """Tests that the expected leap seconds all occur."""
-        ls = leapseconddata.LeapSecondData.from_standard_source()
-        assert ls.valid_until is not None
-
-        d = iersdata.start
-        e = min(iersdata.end, ls.valid_until)
-        bench = [ts.start for ts in ls.leap_seconds[1:]]
-        bench = [ts for ts in bench if d <= ts < e]
-        leap = []
-        while d < e:
-            nm = next_month(d)
-            eom = nm - ONE_DAY
-            month_ends_dut1 = wwvb.get_dut1(eom)
-            month_starts_dut1 = wwvb.get_dut1(nm)
-            our_is_ls = month_ends_dut1 * month_starts_dut1 < 0
-            if wwvb.isls(eom):
-                assert our_is_ls
-                self.assertLess(month_ends_dut1, 0)
-                self.assertGreater(month_starts_dut1, 0)
-                leap.append(nm)
-            else:
-                assert not our_is_ls
-            d = datetime.datetime.combine(nm, datetime.time()).replace(tzinfo=datetime.timezone.utc)
-        self.assertEqual(leap, bench)
-
-
-if __name__ == "__main__":  # pragma: no cover
-    unittest.main()

wwvb/testpm.py

@@ -1,33 +0,0 @@
-#!/usr/bin/python3
-"""Test Phase Modulation Signal"""
-
-# SPDX-FileCopyrightText: 2021 Jeff Epler
-#
-# SPDX-License-Identifier: GPL-3.0-only
-
-import unittest
-
-import wwvb
-
-
-class TestPhaseModulation(unittest.TestCase):
-    """Test Phase Modulation Signal"""
-
-    def test_pm(self) -> None:
-        """Compare the generated signal from a reference minute in NIST docs"""
-        ref_am = "201100000200010011120001010002011000101201000000120010010112"
-
-        ref_pm = "001110110100010010000011001000011000110100110100010110110110"
-
-        ref_minute = wwvb.WWVBMinuteIERS(2012, 186, 17, 30, dst=3)
-        ref_time = ref_minute.as_timecode()
-
-        test_am = ref_time.to_am_string(["0", "1", "2"])
-        test_pm = ref_time.to_pm_string(["0", "1"])
-
-        self.assertEqual(ref_am, test_am)
-        self.assertEqual(ref_pm, test_pm)
-
-
-if __name__ == "__main__":  # pragma: no cover
-    unittest.main()

wwvb/testuwwvb.py

@@ -1,221 +0,0 @@
-#!/usr/bin/python3
-"""Test of uwwvb.py"""
-# SPDX-FileCopyrightText: 2021 Jeff Epler
-#
-# SPDX-License-Identifier: GPL-3.0-only
-
-# ruff: noqa: N802 D102
-import datetime
-import random
-import sys
-import unittest
-from typing import Union
-
-import adafruit_datetime
-import uwwvb
-import zoneinfo
-
-import wwvb
-
-EitherDatetimeOrNone = Union[None, datetime.datetime, adafruit_datetime.datetime]
-
-
-class WWVBRoundtrip(unittest.TestCase):
-    """tests of uwwvb.py"""
-
-    def assertDateTimeEqualExceptTzInfo(self, a: EitherDatetimeOrNone, b: EitherDatetimeOrNone) -> None:
-        """Test two datetime objects for equality
-
-        This equality test excludes tzinfo, and allows adafruit_datetime and core datetime modules to compare equal
-        """
-        assert a
-        assert b
-        self.assertEqual(
-            (a.year, a.month, a.day, a.hour, a.minute, a.second, a.microsecond),
-            (b.year, b.month, b.day, b.hour, b.minute, b.second, b.microsecond),
-        )
-
-    def test_decode(self) -> None:
-        """Test decoding of some minutes including a leap second.
-
-        Each minute must decode and match the primary decoder.
-        """
-        minute = wwvb.WWVBMinuteIERS.from_datetime(datetime.datetime(2012, 6, 30, 23, 50, tzinfo=datetime.timezone.utc))
-        assert minute
-        decoder = uwwvb.WWVBDecoder()
-        decoder.update(uwwvb.MARK)
-        any_leap_second = False
-        for _ in range(20):
-            timecode = minute.as_timecode()
-            decoded = None
-            if len(timecode.am) == 61:
-                any_leap_second = True
-            for code in timecode.am:
-                decoded = uwwvb.decode_wwvb(decoder.update(int(code))) or decoded
-            assert decoded
-            self.assertDateTimeEqualExceptTzInfo(
-                minute.as_datetime_utc(),
-                uwwvb.as_datetime_utc(decoded),
-            )
-            minute = minute.next_minute()
-        self.assertTrue(any_leap_second)
-
-    def test_roundtrip(self) -> None:
-        """Test that some big range of times all decode the same as the primary decoder"""
-        dt = datetime.datetime(2002, 1, 1, 0, 0, tzinfo=datetime.timezone.utc)
-        delta = datetime.timedelta(minutes=7182 if sys.implementation.name == "cpython" else 86400 - 7182)
-        while dt.year < 2013:
-            minute = wwvb.WWVBMinuteIERS.from_datetime(dt)
-            assert minute
-            decoded = uwwvb.decode_wwvb([int(i) for i in minute.as_timecode().am])
-            assert decoded
-            self.assertDateTimeEqualExceptTzInfo(minute.as_datetime_utc(), uwwvb.as_datetime_utc(decoded))
-            dt = dt + delta
-
-    def test_dst(self) -> None:
-        """Test of DST as handled by the small decoder"""
-        for dt in (
-            datetime.datetime(2021, 3, 14, 8, 59, tzinfo=datetime.timezone.utc),
-            datetime.datetime(2021, 3, 14, 9, 00, tzinfo=datetime.timezone.utc),
-            datetime.datetime(2021, 3, 14, 9, 1, tzinfo=datetime.timezone.utc),
-            datetime.datetime(2021, 3, 15, 8, 59, tzinfo=datetime.timezone.utc),
-            datetime.datetime(2021, 3, 15, 9, 00, tzinfo=datetime.timezone.utc),
-            datetime.datetime(2021, 3, 15, 9, 1, tzinfo=datetime.timezone.utc),
-            datetime.datetime(2021, 11, 7, 8, 59, tzinfo=datetime.timezone.utc),
-            datetime.datetime(2021, 11, 7, 9, 00, tzinfo=datetime.timezone.utc),
-            datetime.datetime(2021, 11, 7, 9, 1, tzinfo=datetime.timezone.utc),
-            datetime.datetime(2021, 11, 8, 8, 59, tzinfo=datetime.timezone.utc),
-            datetime.datetime(2021, 11, 8, 9, 00, tzinfo=datetime.timezone.utc),
-            datetime.datetime(2021, 11, 8, 9, 1, tzinfo=datetime.timezone.utc),
-            datetime.datetime(2021, 7, 7, 9, 1, tzinfo=datetime.timezone.utc),
-        ):
-            minute = wwvb.WWVBMinuteIERS.from_datetime(dt)
-            decoded = uwwvb.decode_wwvb([int(i) for i in minute.as_timecode().am])
-            assert decoded
-            self.assertDateTimeEqualExceptTzInfo(minute.as_datetime_local(), uwwvb.as_datetime_local(decoded))
-
-            decoded = uwwvb.decode_wwvb([int(i) for i in minute.as_timecode().am])
-            assert decoded
-            self.assertDateTimeEqualExceptTzInfo(
-                minute.as_datetime_local(dst_observed=False),
-                uwwvb.as_datetime_local(decoded, dst_observed=False),
-            )
-
-    def test_noise(self) -> None:
-        """Test of the state-machine decoder when faced with pseudorandom noise"""
-        minute = wwvb.WWVBMinuteIERS.from_datetime(
-            datetime.datetime(2012, 6, 30, 23, 50, tzinfo=datetime.timezone.utc),
-        )
-        r = random.Random(408)
-        junk = [
-            r.choice(
-                [
-                    wwvb.AmplitudeModulation.MARK,
-                    wwvb.AmplitudeModulation.ONE,
-                    wwvb.AmplitudeModulation.ZERO,
-                ],
-            )
-            for _ in range(480)
-        ]
-        timecode = minute.as_timecode()
-        test_input = [*junk, wwvb.AmplitudeModulation.MARK, *timecode.am]
-        decoder = uwwvb.WWVBDecoder()
-        for code in test_input[:-1]:
-            decoded = decoder.update(code)
-            self.assertIsNone(decoded)
-        minute_maybe = decoder.update(wwvb.AmplitudeModulation.MARK)
-        assert minute_maybe
-        decoded_minute = uwwvb.decode_wwvb(minute_maybe)
-        assert decoded_minute
-        self.assertDateTimeEqualExceptTzInfo(
-            minute.as_datetime_utc(),
-            uwwvb.as_datetime_utc(decoded_minute),
-        )
-        self.assertDateTimeEqualExceptTzInfo(
-            minute.as_datetime_local(),
-            uwwvb.as_datetime_local(decoded_minute),
-        )
-
-    def test_noise2(self) -> None:
-        """Test of the full minute decoder with targeted errors to get full coverage"""
-        minute = wwvb.WWVBMinuteIERS.from_datetime(
-            datetime.datetime(2012, 6, 30, 23, 50, tzinfo=datetime.timezone.utc),
-        )
-        timecode = minute.as_timecode()
-        decoded = uwwvb.decode_wwvb([int(i) for i in timecode.am])
-        self.assertIsNotNone(decoded)
-        for position in uwwvb.always_mark:
-            test_input = [int(i) for i in timecode.am]
-            for noise in (0, 1):
-                test_input[position] = noise
-                decoded = uwwvb.decode_wwvb(test_input)
-                self.assertIsNone(decoded)
-        for position in uwwvb.always_zero:
-            test_input = [int(i) for i in timecode.am]
-            for noise in (1, 2):
-                test_input[position] = noise
-                decoded = uwwvb.decode_wwvb(test_input)
-                self.assertIsNone(decoded)
-        for i in range(8):
-            if i in (0b101, 0b010):  # Test the 6 impossible bit-combos
-                continue
-            test_input = [int(i) for i in timecode.am]
-            test_input[36] = i & 1
-            test_input[37] = (i >> 1) & 1
-            test_input[38] = (i >> 2) & 1
-            decoded = uwwvb.decode_wwvb(test_input)
-            self.assertIsNone(decoded)
-        # Invalid year-day
-        test_input = [int(i) for i in timecode.am]
-        test_input[22] = 1
-        test_input[23] = 1
-        test_input[25] = 1
-        decoded = uwwvb.decode_wwvb(test_input)
-        self.assertIsNone(decoded)
-
-    def test_noise3(self) -> None:
-        """Test impossible BCD values"""
-        minute = wwvb.WWVBMinuteIERS.from_datetime(
-            datetime.datetime(2012, 6, 30, 23, 50, tzinfo=datetime.timezone.utc),
-        )
-        timecode = minute.as_timecode()
-
-        for poslist in [
-            [1, 2, 3, 4],  # tens minutes
-            [5, 6, 7, 8],  # ones minutes
-            [15, 16, 17, 18],  # tens hours
-            [25, 26, 27, 28],  # tens days
-            [30, 31, 32, 33],  # ones days
-            [40, 41, 42, 43],  # tens years
-            [45, 46, 47, 48],  # ones years
-            [50, 51, 52, 53],  # ones dut1
-        ]:
-            with self.subTest(test=poslist):
-                test_input = [int(i) for i in timecode.am]
-                for pi in poslist:
-                    test_input[pi] = 1
-                decoded = uwwvb.decode_wwvb(test_input)
-                self.assertIsNone(decoded)
-
-    def test_str(self) -> None:
-        """Test the str() of a WWVBDecoder"""
-        self.assertEqual(str(uwwvb.WWVBDecoder()), "<WWVBDecoder 1 []>")
-
-    def test_near_year_bug(self) -> None:
-        """Test for a bug seen in another WWVB implementaiton
-
-        .. in which the hours after UTC midnight on 12-31 of a leap year would
-        be shown incorrectly. Check that we don't have that bug.
-        """
-        minute = wwvb.WWVBMinuteIERS.from_datetime(datetime.datetime(2021, 1, 1, 0, 0, tzinfo=datetime.timezone.utc))
-        timecode = minute.as_timecode()
-        decoded = uwwvb.decode_wwvb([int(i) for i in timecode.am])
-        assert decoded
-        self.assertDateTimeEqualExceptTzInfo(
-            datetime.datetime(2020, 12, 31, 17, 00, tzinfo=zoneinfo.ZoneInfo("America/Denver")),  # Mountain time!
-            uwwvb.as_datetime_local(decoded),
-        )
-
-
-if __name__ == "__main__":  # pragma no cover
-    unittest.main()