Ejemplo n.º 1
0
    def test_ts_convert_tai_sec_frac(self):
        """This tests that the conversion to and from TAI seconds with fractional parts works as expected."""

        tests_ts = [("0.0", Timestamp(0, 0), "0.0"),
                    ("0.1", Timestamp(0, 1000000000 // 10), "0.1"),
                    ("-0.1", Timestamp(0, 0), "0.0"),
                    ("5", Timestamp(5, 0), "5.0"),
                    ("5.1", Timestamp(5, 1000000000 // 10), "5.1"),
                    ("-5.1", Timestamp(0, 0), "0.0"),
                    ("5.10000000", Timestamp(5, 1000000000 // 10), "5.1"),
                    ("5.123456789", Timestamp(5, 123456789), "5.123456789"),
                    ("5.000000001", Timestamp(5, 1), "5.000000001"),
                    ("5.0000000001", Timestamp(5, 0), "5.0")]

        for t in tests_ts:
            ts = Timestamp.from_sec_frac(t[0])
            self.assertTrue(isinstance(ts, Timestamp),
                            msg="Called with {} {} {}".format(
                                t[0], t[1], t[2]))
            self.assertEqual(ts,
                             t[1],
                             msg="Called with {} {} {}".format(
                                 t[0], t[1], t[2]))
            ts_str = ts.to_sec_frac()
            self.assertEqual(ts_str,
                             t[2],
                             msg="Called with {} {} {}".format(
                                 t[0], t[1], t[2]))
Ejemplo n.º 2
0
 def test_iaddsub(self):
     """This tests integer addition and subtraction on timestamps."""
     ts = Timestamp(10, 0)
     ts += TimeOffset(1, 2)
     self.assertEqual(ts, Timestamp(11, 2))
     ts -= TimeOffset(1, 2)
     self.assertEqual(ts, Timestamp(10, 0))
     ts -= TimeOffset(100, 5)
     self.assertTrue(ts.is_null())
     ts = Timestamp(281474976710655, 999999999)
     ts += TimeOffset(0, 1)
     self.assertEqual(ts, Timestamp(281474976710655, 999999999))
     toff = TimeOffset(10, 0)
     toff -= TimeOffset(100, 0)
     self.assertEqual(toff, TimeOffset(90, 0, -1))
     toff = TimeOffset(10, 0)
     toff -= TimeOffset(0, 1)
     self.assertEqual(toff, TimeOffset(9, 999999999))
     toff = TimeOffset(10, 500000000)
     toff += TimeOffset(0, 500000000)
     self.assertEqual(toff, TimeOffset(11, 0))
     toff = TimeOffset(10, 500000000, -1)
     toff -= TimeOffset(0, 500000000)
     self.assertEqual(toff, TimeOffset(11, 0, -1))
     toff = TimeOffset(10, 0, -1)
     toff += TimeOffset(0, 500000000)
     self.assertEqual(toff, TimeOffset(9, 500000000, -1))
Ejemplo n.º 3
0
    def test_iaddsub(self):
        """This tests integer addition and subtraction on timestamps."""
        with mock.patch('__builtin__.__import__',
                        side_effect=import_mock("pyipputils.ipptimestamp",
                                                False)):
            reload(nmoscommon.timestamp)
            from nmoscommon.timestamp import Timestamp, TimeOffset, IPP_UTILS, TsValueError
            self.assertFalse(IPP_UTILS)

        ts = Timestamp(10, 0)
        ts += TimeOffset(1, 2)
        self.assertEqual(ts, Timestamp(11, 2))
        ts -= TimeOffset(1, 2)
        self.assertEqual(ts, Timestamp(10, 0))
        ts -= TimeOffset(100, 5)
        self.assertTrue(ts.is_null())
        ts = Timestamp(281474976710655, 999999999)
        ts += TimeOffset(0, 1)
        self.assertEqual(ts, Timestamp(281474976710655, 999999999))
        toff = TimeOffset(10, 0)
        toff -= TimeOffset(100, 0)
        self.assertEqual(toff, TimeOffset(90, 0, -1))
        toff = TimeOffset(10, 0)
        toff -= TimeOffset(0, 1)
        self.assertEqual(toff, TimeOffset(9, 999999999))
        toff = TimeOffset(10, 500000000)
        toff += TimeOffset(0, 500000000)
        self.assertEqual(toff, TimeOffset(11, 0))
        toff = TimeOffset(10, 500000000, -1)
        toff -= TimeOffset(0, 500000000)
        self.assertEqual(toff, TimeOffset(11, 0, -1))
        toff = TimeOffset(10, 0, -1)
        toff += TimeOffset(0, 500000000)
        self.assertEqual(toff, TimeOffset(9, 500000000, -1))
Ejemplo n.º 4
0
    def test_get_time_pythonic(self):
        """This tests that the fallback pure python implementation of get_time works as expected."""
        test_ts = [(1512489451.0, Timestamp(1512489451 + 37, 0)),
                   (1512489451.1, Timestamp(1512489451 + 37, 100000000))]

        for t in test_ts:
            with mock.patch("time.time") as time:
                time.return_value = t[0]
                gottime = Timestamp.get_time(force_pure_python=True)
                self.assertEqual(gottime,
                                 t[1],
                                 msg="Times not equal, expected: %r, got %r" %
                                 (t[1], gottime))
Ejemplo n.º 5
0
    def test_from_str(self):
        """Conversion from string formats."""

        tests = [
            ("2015-01-23T12:34:56F00 30000/1001 UTC-05:00 TAI-35",
             Timestamp(1422034531, 17100000)),
            ("2015-01-23T12:34:56.0Z", Timestamp(1422016531, 0)),
            ("now", Timestamp(0, 0)),
        ]

        for t in tests:
            with mock.patch("time.time", return_value=0.0):
                self.assertEqual(
                    Timestamp.from_str(t[0], force_pure_python=True), t[1])
Ejemplo n.º 6
0
    def test_convert_str(self):
        """This tests that various string formats can be converted to timestamps."""

        tests_ts = [
            ("1:2", Timestamp(1, 2)), ("1.2", Timestamp(1, 200000000)),
            ("1", Timestamp(1, 0)),
            ("2015-02-17T12:53:48.5Z", Timestamp(1424177663, 500000000)),
            ("2015-02-17T12:53:48.000102003Z", Timestamp(1424177663, 102003))
        ]

        for t in tests_ts:
            ts = Timestamp.from_str(t[0])
            self.assertTrue(isinstance(ts, Timestamp))
            self.assertEqual(ts, t[1])
Ejemplo n.º 7
0
    def test_to_datetime(self):
        """Conversion to python's datetime object."""

        tests = [
            (datetime(1970, 1, 1, 0, 0, 0, 0,
                      tz.gettz('UTC')), Timestamp(0, 0)),
            (datetime(1983, 3, 29, 15, 45, 0, 0,
                      tz.gettz('UTC')), Timestamp(417800721, 0)),
            (datetime(2017, 12, 5, 16, 33, 12, 196,
                      tz.gettz('UTC')), Timestamp(1512491629, 196000)),
        ]

        for t in tests:
            self.assertEqual(t[0], t[1].to_datetime())
Ejemplo n.º 8
0
    def test_ts_convert_tai_sec_nsec(self):
        """This tests that the conversion to and from TAI second:nanosecond pairs works as expected."""

        tests_ts = [("0:0", Timestamp(0, 0), "0:0"),
                    ("0:1", Timestamp(0, 1), "0:1"),
                    ("-0:1", Timestamp(0, 0), "0:0"),
                    ("5", Timestamp(5, 0), "5:0"),
                    ("5:1", Timestamp(5, 1), "5:1"),
                    ("-5:1", Timestamp(0, 0), "0:0"),
                    ("5:999999999", Timestamp(5, 999999999), "5:999999999")]

        for t in tests_ts:
            ts = Timestamp.from_sec_nsec(t[0])
            self.assertTrue(isinstance(ts, Timestamp),
                            msg="Called with {} {} {}".format(
                                t[0], t[1], t[2]))
            self.assertEqual(ts,
                             t[1],
                             msg="Called with {} {} {}".format(
                                 t[0], t[1], t[2]))
            ts_str = ts.to_sec_nsec()
            self.assertEqual(ts_str,
                             t[2],
                             msg="Called with {} {} {}".format(
                                 t[0], t[1], t[2]))
Ejemplo n.º 9
0
    def test_get_leap_seconds(self):
        """get_leap_seconds should return the correct number of leap seconds at any point in history."""

        tests = [
            (Timestamp(63072008, 999999999), 0),
            (Timestamp(63072009, 0), 10),
            (Timestamp(78796809, 999999999), 10),
            (Timestamp(78796810, 0), 11),
            (Timestamp(94694410, 999999999), 11),
            (Timestamp(94694411, 0), 12),
            (Timestamp(417800721, 0), 21),
            (Timestamp(773020827, 999999999), 28),
            (Timestamp(773020828, 0), 29),
            (Timestamp(1512491629, 0), 37),
        ]

        for t in tests:
            self.assertEqual(t[0].get_leap_seconds(), t[1])
Ejemplo n.º 10
0
    def test_invalid_int(self):
        """This tests that invalid int values fed into timestamp constructor get normalised."""

        tests_ts = [(Timestamp(-1, 0), Timestamp()),
                    (Timestamp(281474976710656,
                               0), Timestamp(281474976710655, 999999999)),
                    (Timestamp(0, 1000000000), Timestamp(0, 999999999)),
                    (Timestamp(0, -1), Timestamp(0, 0))]

        for t in tests_ts:
            self.assertEqual(t[0], t[1])
Ejemplo n.º 11
0
    def test_from_str(self):
        """Conversion from string formats."""
        with mock.patch('__builtin__.__import__',
                        side_effect=import_mock("pyipputils.ipptimestamp",
                                                False)):
            reload(nmoscommon.timestamp)
            from nmoscommon.timestamp import Timestamp, TimeOffset, IPP_UTILS, TsValueError
            self.assertFalse(IPP_UTILS)

        tests = [
            ("2015-01-23T12:34:56F00 30000/1001 UTC-05:00 TAI-35",
             Timestamp(1422034531, 17100000)),
            ("2015-01-23T12:34:56.0Z", Timestamp(1422016531, 0)),
            ("now", Timestamp(0, 0)),
        ]

        for t in tests:
            with mock.patch("time.time", return_value=0.0):
                self.assertEqual(Timestamp.from_str(t[0]), t[1])
Ejemplo n.º 12
0
    def test_convert_tai_sec_nsec(self):
        """This tests that the conversion to and from TAI second:nanosecond pairs works as expected."""
        with mock.patch('__builtin__.__import__',
                        side_effect=import_mock("pyipputils.ipptimestamp",
                                                False)):
            reload(nmoscommon.timestamp)
            from nmoscommon.timestamp import Timestamp, TimeOffset, IPP_UTILS, TsValueError
            self.assertFalse(IPP_UTILS)

        tests_ts = [("0:0", Timestamp(0, 0), "0:0"),
                    ("5", Timestamp(5, 0), "5:0"),
                    ("5:1", Timestamp(5, 1), "5:1"),
                    ("5:999999999", Timestamp(5, 999999999), "5:999999999")]

        for t in tests_ts:
            ts = Timestamp.from_tai_sec_nsec(t[0])
            self.assertTrue(isinstance(ts, Timestamp))
            self.assertEqual(ts, t[1])
            ts_str = ts.to_tai_sec_nsec()
            self.assertEqual(ts_str, t[2])
Ejemplo n.º 13
0
    def test_to_datetime(self):
        """Conversion to python's datetime object."""
        with mock.patch('__builtin__.__import__',
                        side_effect=import_mock("pyipputils.ipptimestamp",
                                                False)):
            reload(nmoscommon.timestamp)
            from nmoscommon.timestamp import Timestamp, TimeOffset, IPP_UTILS, TsValueError
            self.assertFalse(IPP_UTILS)

        tests = [
            (datetime(1970, 1, 1, 0, 0, 0, 0,
                      tz.gettz('UTC')), Timestamp(0, 0)),
            (datetime(1983, 3, 29, 15, 45, 0, 0,
                      tz.gettz('UTC')), Timestamp(417800721, 0)),
            (datetime(2017, 12, 5, 16, 33, 12, 196,
                      tz.gettz('UTC')), Timestamp(1512491629, 196000)),
        ]

        for t in tests:
            self.assertEqual(t[0], t[1].to_datetime())
Ejemplo n.º 14
0
    def test_get_time_pythonic(self):
        """This tests that the fallback pure python implementation of get_time works as expected."""
        with mock.patch('__builtin__.__import__',
                        side_effect=import_mock("pyipputils.ipptimestamp",
                                                False)):
            reload(nmoscommon.timestamp)
            from nmoscommon.timestamp import Timestamp, TimeOffset, IPP_UTILS, TsValueError
            self.assertFalse(IPP_UTILS)

        test_ts = [(1512489451.0, Timestamp(1512489451 + 37, 0)),
                   (1512489451.1, Timestamp(1512489451 + 37, 100000000))]

        for t in test_ts:
            with mock.patch("time.time") as time:
                time.return_value = t[0]
                gottime = Timestamp.get_time()
                self.assertEqual(gottime,
                                 t[1],
                                 msg="Times not equal, expected: %r, got %r" %
                                 (t[1], gottime))
Ejemplo n.º 15
0
    def test_convert_str(self):
        """This tests that various string formats can be converted to timestamps."""
        with mock.patch('__builtin__.__import__',
                        side_effect=import_mock("pyipputils.ipptimestamp",
                                                False)):
            reload(nmoscommon.timestamp)
            from nmoscommon.timestamp import Timestamp, TimeOffset, IPP_UTILS, TsValueError
            self.assertFalse(IPP_UTILS)

        tests_ts = [
            ("1:2", Timestamp(1, 2)), ("1.2", Timestamp(1, 200000000)),
            ("1", Timestamp(1, 0)),
            ("2015-02-17T12:53:48.5Z", Timestamp(1424177663, 500000000)),
            ("2015-02-17T12:53:48.000102003Z", Timestamp(1424177663, 102003))
        ]

        for t in tests_ts:
            ts = Timestamp.from_str(t[0])
            self.assertTrue(isinstance(ts, Timestamp))
            self.assertEqual(ts, t[1])
Ejemplo n.º 16
0
    def test_multdiv(self):
        """This tests multiplication and division on timestamps."""

        tests_ts = [
            (TimeOffset(10, 10) * 0, TimeOffset(0, 0)),
            (TimeOffset(10, 10) * 10, TimeOffset(100, 100)),
            (10 * TimeOffset(10, 10), TimeOffset(100, 100)),
            (TimeOffset(10, 10) * (-10), TimeOffset(100, 100, -1)),
            (TimeOffset(10, 10, -1) * 10, TimeOffset(100, 100, -1)),
            (TimeOffset(100, 100) // 10, TimeOffset(10, 10)),
            (TimeOffset(100, 100) // -10, TimeOffset(10, 10, -1)),
            (TimeOffset(100, 100, -1) // 10, TimeOffset(10, 10, -1)),
            (TimeOffset(281474976710654, 0) // 281474976710655,
             TimeOffset(0, 999999999)),
            (Timestamp(100, 100) // 10, Timestamp(10, 10)),
            (Timestamp(10, 10) * 10, Timestamp(100, 100)),
            (10 * Timestamp(10, 10), Timestamp(100, 100)),
        ]

        count = 0
        for t in tests_ts:
            self.assertEqual(t[0], t[1])
            self.assertEqual(
                isinstance(t[0], Timestamp), isinstance(t[1], Timestamp),
                "Failed on itteration {}, {}, {}".format(
                    count, type(t[0]), type(t[1])))
            count = count + 1
Ejemplo n.º 17
0
    def test_multdiv(self):
        """This tests multiplication and division on timestamps."""
        with mock.patch('__builtin__.__import__',
                        side_effect=import_mock("pyipputils.ipptimestamp",
                                                False)):
            reload(nmoscommon.timestamp)
            from nmoscommon.timestamp import Timestamp, TimeOffset, IPP_UTILS, TsValueError
            self.assertFalse(IPP_UTILS)

        tests_ts = [
            (TimeOffset(10, 10) * 0, TimeOffset(0, 0)),
            (TimeOffset(10, 10) * 10, TimeOffset(100, 100)),
            (10 * TimeOffset(10, 10), TimeOffset(100, 100)),
            (TimeOffset(10, 10) * (-10), TimeOffset(100, 100, -1)),
            (TimeOffset(10, 10, -1) * 10, TimeOffset(100, 100, -1)),
            (TimeOffset(100, 100) / 10, TimeOffset(10, 10)),
            (TimeOffset(100, 100) / -10, TimeOffset(10, 10, -1)),
            (TimeOffset(100, 100, -1) / 10, TimeOffset(10, 10, -1)),
            (TimeOffset(281474976710654, 0) / 281474976710655,
             TimeOffset(0, 999999999)),
            (Timestamp(100, 100) / 10, Timestamp(10, 10)),
            (Timestamp(10, 10) * 10, Timestamp(100, 100)),
            (10 * Timestamp(10, 10), Timestamp(100, 100)),
        ]

        count = 0
        for t in tests_ts:
            self.assertEqual(t[0], t[1])
            self.assertEqual(
                isinstance(t[0], Timestamp), isinstance(t[1], Timestamp),
                "Failed on itteration {}, {}, {}".format(
                    count, type(t[0]), type(t[1])))
            count = count + 1
Ejemplo n.º 18
0
    def test_import_with_ipp(self):
        """This tests the import of the module and ensures that when the pyipputils module is installed it will defer to that module."""
        with mock.patch('__builtin__.__import__',
                        side_effect=import_mock("pyipputils.ipptimestamp",
                                                True)):
            reload(nmoscommon.timestamp)
            from nmoscommon.timestamp import IPP_UTILS, Timestamp
            self.assertTrue(IPP_UTILS)

            mock_imports[
                "pyipputils.ipptimestamp"].ipptimestamp.ipp_ts_gettime.return_value = (
                    1, 23, 17)
            self.assertEqual(Timestamp.get_time(), Timestamp(23, 17))
Ejemplo n.º 19
0
    def test_invalid_int(self):
        """This tests that invalid int values fed into timestamp constructor get normalised."""
        with mock.patch('__builtin__.__import__',
                        side_effect=import_mock("pyipputils.ipptimestamp",
                                                False)):
            reload(nmoscommon.timestamp)
            from nmoscommon.timestamp import Timestamp, TimeOffset, IPP_UTILS, TsValueError
            self.assertFalse(IPP_UTILS)

        tests_ts = [(Timestamp(-1, 0), Timestamp()),
                    (Timestamp(281474976710656,
                               0), Timestamp(281474976710655, 999999999)),
                    (Timestamp(0, 1000000000), Timestamp(0, 999999999)),
                    (Timestamp(0, -1), Timestamp(0, 0))]

        for t in tests_ts:
            self.assertEqual(t[0], t[1])
Ejemplo n.º 20
0
    def test_get_leap_seconds(self):
        """get_leap_seconds should return the correct number of leap seconds at any point in history."""
        with mock.patch('__builtin__.__import__',
                        side_effect=import_mock("pyipputils.ipptimestamp",
                                                False)):
            reload(nmoscommon.timestamp)
            from nmoscommon.timestamp import Timestamp, TimeOffset, IPP_UTILS, TsValueError
            self.assertFalse(IPP_UTILS)

        tests = [
            (Timestamp(63072008, 999999999), 0),
            (Timestamp(63072009, 0), 10),
            (Timestamp(78796809, 999999999), 10),
            (Timestamp(78796810, 0), 11),
            (Timestamp(94694410, 999999999), 11),
            (Timestamp(94694411, 0), 12),
            (Timestamp(417800721, 0), 21),
            (Timestamp(773020827, 999999999), 28),
            (Timestamp(773020828, 0), 29),
            (Timestamp(1512491629, 0), 37),
        ]

        for t in tests:
            self.assertEqual(t[0].get_leap_seconds(), t[1])
Ejemplo n.º 21
0
    def test_convert_tai_sec_frac(self):
        """This tests that the conversion to and from TAI seconds with fractional parts works as expected."""
        with mock.patch('__builtin__.__import__',
                        side_effect=import_mock("pyipputils.ipptimestamp",
                                                False)):
            reload(nmoscommon.timestamp)
            from nmoscommon.timestamp import Timestamp, TimeOffset, IPP_UTILS, TsValueError
            self.assertFalse(IPP_UTILS)

        tests_ts = [("0.0", Timestamp(0, 0), "0.0"),
                    ("5", Timestamp(5, 0), "5.0"),
                    ("5.1", Timestamp(5, 1000000000 / 10), "5.1"),
                    ("5.10000000", Timestamp(5, 1000000000 / 10), "5.1"),
                    ("5.123456789", Timestamp(5, 123456789), "5.123456789"),
                    ("5.000000001", Timestamp(5, 1), "5.000000001"),
                    ("5.0000000001", Timestamp(5, 0), "5.0")]

        for t in tests_ts:
            ts = Timestamp.from_tai_sec_frac(t[0])
            self.assertEqual(ts, t[1])
            ts_str = ts.to_tai_sec_frac()
            self.assertEqual(ts_str, t[2])
Ejemplo n.º 22
0
    def test_compare(self):
        """This tests comparison of timestamps."""

        tests_ts = [(Timestamp(1, 2) == Timestamp(1, 2), True),
                    (Timestamp(1, 2) != Timestamp(1, 3), True),
                    (Timestamp(1, 0) < Timestamp(1, 2), True),
                    (Timestamp(1, 2) <= Timestamp(1, 2), True),
                    (Timestamp(2, 0) > Timestamp(1, 0), True),
                    (Timestamp(2, 0) >= Timestamp(2, 0), True),
                    (Timestamp(2, 0) < Timestamp(1, 0), False),
                    (Timestamp(2, 0) == Timestamp(3, 0), False),
                    (Timestamp(2, 0) == 2, True), (Timestamp(2, 0) > 1, True),
                    (Timestamp(2, 0) < 3, True), (TimeOffset(2, 0) < 3, True),
                    (TimeOffset(1, 0, 1) < TimeOffset(1, 0, -1), False)]

        for t in tests_ts:
            self.assertEqual(t[0], t[1])
Ejemplo n.º 23
0
    def test_convert_iso_utc(self):
        """This tests that conversion to and from ISO date format UTC time works as expected."""

        tests = [
            (Timestamp(1424177663, 102003), "2015-02-17T12:53:48.000102003Z"),

            # the leap second is 23:59:60

            #   30 June 1972 23:59:59 (2287785599, first time): TAI= UTC + 10 seconds
            (Timestamp(78796809, 0), "1972-06-30T23:59:59.000000000Z"),

            #   30 June 1972 23:59:60 (2287785599,second time): TAI= UTC + 11 seconds
            (Timestamp(78796810, 0), "1972-06-30T23:59:60.000000000Z"),

            #   1  July 1972 00:00:00 (2287785600)      TAI= UTC + 11 seconds
            (Timestamp(78796811, 0), "1972-07-01T00:00:00.000000000Z"),
            (Timestamp(1341100833, 0), "2012-06-30T23:59:59.000000000Z"),
            (Timestamp(1341100834, 0), "2012-06-30T23:59:60.000000000Z"),
            (Timestamp(1341100835, 0), "2012-07-01T00:00:00.000000000Z"),
            (Timestamp(1341100835, 1), "2012-07-01T00:00:00.000000001Z"),
            (Timestamp(1341100835,
                       100000000), "2012-07-01T00:00:00.100000000Z"),
            (Timestamp(1341100835,
                       999999999), "2012-07-01T00:00:00.999999999Z"),
            (Timestamp(283996818, 0), "1979-01-01T00:00:00.000000000Z")  # 1979
        ]

        for t in tests:
            utc = t[0].to_iso8601_utc()
            self.assertEqual(utc, t[1])
            ts = Timestamp.from_iso8601_utc(t[1])
            self.assertEqual(ts, t[0])

        bad_params = [
            ("2012-07-01Y00:00:00.000000001Z", ),
            ("2012-07~01T00:00:00.000000001Z", ),
            ("2012-07-01T00:00:00.0000.0001Z", ),
        ]

        for p in bad_params:
            with self.assertRaises(TsValueError):
                Timestamp.from_iso8601_utc(*p)
Ejemplo n.º 24
0
    def test_addsub(self):
        """This tests addition and subtraction on timestamps."""

        tests_ts = [
            (Timestamp(10, 0) + TimeOffset(1, 2), Timestamp(11, 2)),
            (Timestamp(11, 2) - TimeOffset(1, 2), Timestamp(10, 0)),
            (TimeOffset(11, 2) - TimeOffset(1, 2), TimeOffset(10, 0)),
            (Timestamp(10, 0) - TimeOffset(11, 2), Timestamp(0, 0)),
            (TimeOffset(10, 0) - TimeOffset(11, 2), TimeOffset(1, 2, -1)),
            (TimeOffset(10, 0) - Timestamp(11, 2), TimeOffset(1, 2, -1)),
            (Timestamp(10, 0) - Timestamp(11, 2), TimeOffset(1, 2, -1)),
            (Timestamp(11, 2) - Timestamp(10, 0), TimeOffset(1, 2, 1)),
        ]

        for t in tests_ts:
            self.assertEqual(t[0], t[1])
            self.assertEqual(isinstance(t[0], Timestamp),
                             isinstance(t[1], Timestamp))
Ejemplo n.º 25
0
    def test_smpte_timelabel(self):
        """This tests that conversion to and from SMPTE time labels works correctly."""
        with mock.patch('__builtin__.__import__',
                        side_effect=import_mock("pyipputils.ipptimestamp",
                                                False)):
            reload(nmoscommon.timestamp)
            from nmoscommon.timestamp import Timestamp, TimeOffset, IPP_UTILS, TsValueError
            self.assertFalse(IPP_UTILS)

        tests = [("2015-01-23T12:34:56F00 30000/1001 UTC-05:00 TAI-35", 30000,
                  1001, -5 * 60 * 60),
                 ("2015-01-23T12:34:56F01 30000/1001 UTC-05:00 TAI-35", 30000,
                  1001, -5 * 60 * 60),
                 ("2015-01-23T12:34:56F02 30000/1001 UTC-05:00 TAI-35", 30000,
                  1001, -5 * 60 * 60),
                 ("2015-01-23T12:34:56F28 30000/1001 UTC-05:00 TAI-35", 30000,
                  1001, -5 * 60 * 60),
                 ("2015-01-23T12:34:56F29 30000/1001 UTC-05:00 TAI-35", 30000,
                  1001, -5 * 60 * 60),
                 ("2015-07-01T00:59:59F00 30000/1001 UTC+01:00 TAI-35", 30000,
                  1001, 60 * 60),
                 ("2015-07-01T00:59:59F01 30000/1001 UTC+01:00 TAI-35", 30000,
                  1001, 60 * 60),
                 ("2015-07-01T00:59:59F29 30000/1001 UTC+01:00 TAI-35", 30000,
                  1001, 60 * 60),
                 ("2015-07-01T00:59:60F00 30000/1001 UTC+01:00 TAI-35", 30000,
                  1001, 60 * 60),
                 ("2015-07-01T00:59:60F29 30000/1001 UTC+01:00 TAI-35", 30000,
                  1001, 60 * 60),
                 ("2015-07-01T01:00:00F00 30000/1001 UTC+01:00 TAI-36", 30000,
                  1001, 60 * 60),
                 ("2015-06-30T18:59:59F29 30000/1001 UTC-05:00 TAI-35", 30000,
                  1001, -5 * 60 * 60),
                 ("2015-06-30T18:59:60F00 30000/1001 UTC-05:00 TAI-35", 30000,
                  1001, -5 * 60 * 60),
                 ("2015-06-30T18:59:60F29 30000/1001 UTC-05:00 TAI-35", 30000,
                  1001, -5 * 60 * 60),
                 ("2015-06-30T19:00:00F00 30000/1001 UTC-05:00 TAI-36", 30000,
                  1001, -5 * 60 * 60)]

        for t in tests:
            ts = Timestamp.from_smpte_timelabel(t[0])
            self.assertEqual(t[0], ts.to_smpte_timelabel(t[1], t[2], t[3]))

        bad_params = [
            ("potato", ),
            ("the quick brown fox jumps over the lazy dog", ),
            ("", ),
            ('\u3069\u3082\u3042\u308a\u304c\u3068\u3046\u3001\u30df\u30b9\u30bf\u30fc\u30fb\u30ed\u30dc\u30c8\u30fc',
             ),
            ("About half nine on tuesday", ),
            ("0315-13~35T25:63:60F56 50000/1002 UTC-25:35 TAY-2", ),
        ]
        for p in bad_params:
            with self.assertRaises(TsValueError):
                Timestamp.from_smpte_timelabel(*p)

        bad_params = [
            (0, 1),
            (1, 0),
        ]
        for p in bad_params:
            with self.assertRaises(TsValueError):
                Timestamp(0, 0).to_smpte_timelabel(*p)

        with mock.patch("time.timezone", 0):
            with mock.patch("time.localtime") as localtime:
                localtime.tm_isdst = 1
                ts = Timestamp.from_smpte_timelabel(
                    "2015-07-01T00:59:59F00 30000/1001 UTC+01:00 TAI-35")
                self.assertEqual(
                    "2015-07-01T00:59:59F00 30000/1001 UTC+01:00 TAI-35",
                    ts.to_smpte_timelabel(30000, 1001))
Ejemplo n.º 26
0
    def test_convert_iso_utc(self):
        """This tests that conversion to and from ISO date format UTC time works as expected."""
        with mock.patch('__builtin__.__import__',
                        side_effect=import_mock("pyipputils.ipptimestamp",
                                                False)):
            reload(nmoscommon.timestamp)
            from nmoscommon.timestamp import Timestamp, TimeOffset, IPP_UTILS, TsValueError
            self.assertFalse(IPP_UTILS)

        tests = [
            (Timestamp(1424177663, 102003), "2015-02-17T12:53:48.000102003Z"),

            # the leap second is 23:59:60

            #   30 June 1972 23:59:59 (2287785599, first time): TAI= UTC + 10 seconds
            (Timestamp(78796809, 0), "1972-06-30T23:59:59.000000000Z"),

            #   30 June 1972 23:59:60 (2287785599,second time): TAI= UTC + 11 seconds
            (Timestamp(78796810, 0), "1972-06-30T23:59:60.000000000Z"),

            #   1  July 1972 00:00:00 (2287785600)      TAI= UTC + 11 seconds
            (Timestamp(78796811, 0), "1972-07-01T00:00:00.000000000Z"),
            (Timestamp(1341100833, 0), "2012-06-30T23:59:59.000000000Z"),
            (Timestamp(1341100834, 0), "2012-06-30T23:59:60.000000000Z"),
            (Timestamp(1341100835, 0), "2012-07-01T00:00:00.000000000Z"),
            (Timestamp(1341100835, 1), "2012-07-01T00:00:00.000000001Z"),
            (Timestamp(1341100835,
                       100000000), "2012-07-01T00:00:00.100000000Z"),
            (Timestamp(1341100835,
                       999999999), "2012-07-01T00:00:00.999999999Z"),
            (Timestamp(283996818, 0), "1979-01-01T00:00:00.000000000Z")  # 1979
        ]

        for t in tests:
            utc = t[0].to_iso8601_utc()
            self.assertEqual(utc, t[1])
            ts = Timestamp.from_iso8601_utc(t[1])
            self.assertEqual(ts, t[0])

        bad_params = [
            ("2012-07-01Y00:00:00.000000001Z", ),
            ("2012-07~01T00:00:00.000000001Z", ),
            ("2012-07-01T00:00:00.0000.0001Z", ),
        ]

        for p in bad_params:
            with self.assertRaises(TsValueError):
                Timestamp.from_iso8601_utc(*p)
Ejemplo n.º 27
0
    def test_addsub(self):
        """This tests addition and subtraction on timestamps."""
        with mock.patch('__builtin__.__import__',
                        side_effect=import_mock("pyipputils.ipptimestamp",
                                                False)):
            reload(nmoscommon.timestamp)
            from nmoscommon.timestamp import Timestamp, TimeOffset, IPP_UTILS, TsValueError
            self.assertFalse(IPP_UTILS)

        tests_ts = [
            (Timestamp(10, 0) + TimeOffset(1, 2), Timestamp(11, 2)),
            (Timestamp(11, 2) - TimeOffset(1, 2), Timestamp(10, 0)),
            (TimeOffset(11, 2) - TimeOffset(1, 2), TimeOffset(10, 0)),
            (Timestamp(10, 0) - TimeOffset(11, 2), Timestamp(0, 0)),
            (TimeOffset(10, 0) - TimeOffset(11, 2), TimeOffset(1, 2, -1)),
            (TimeOffset(10, 0) - Timestamp(11, 2), TimeOffset(1, 2, -1)),
            (Timestamp(10, 0) - Timestamp(11, 2), TimeOffset(1, 2, -1)),
            (Timestamp(11, 2) - Timestamp(10, 0), TimeOffset(1, 2, 1)),
        ]

        for t in tests_ts:
            self.assertEqual(t[0], t[1])
            self.assertEqual(isinstance(t[0], Timestamp),
                             isinstance(t[1], Timestamp))
Ejemplo n.º 28
0
    def test_compare(self):
        """This tests comparison of timestamps."""
        with mock.patch('__builtin__.__import__',
                        side_effect=import_mock("pyipputils.ipptimestamp",
                                                False)):
            reload(nmoscommon.timestamp)
            from nmoscommon.timestamp import Timestamp, TimeOffset, IPP_UTILS, TsValueError
            self.assertFalse(IPP_UTILS)

        tests_ts = [(Timestamp(1, 2) == Timestamp(1, 2), True),
                    (Timestamp(1, 2) != Timestamp(1, 3), True),
                    (Timestamp(1, 0) < Timestamp(1, 2), True),
                    (Timestamp(1, 2) <= Timestamp(1, 2), True),
                    (Timestamp(2, 0) > Timestamp(1, 0), True),
                    (Timestamp(2, 0) >= Timestamp(2, 0), True),
                    (Timestamp(2, 0) < Timestamp(1, 0), False),
                    (Timestamp(2, 0) == Timestamp(3, 0), False),
                    (Timestamp(2, 0) == 2, True), (Timestamp(2, 0) > 1, True),
                    (Timestamp(2, 0) < 3, True), (TimeOffset(2, 0) < 3, True),
                    (TimeOffset(1, 0, 1) < TimeOffset(1, 0, -1), False)]

        for t in tests_ts:
            self.assertEqual(t[0], t[1])