Beispiel #1
0
 def testPTPTimeCheck(self):
     t = ptptime.ptptime(1970,1,1,0,0,0,0,0)
     if not t.ptp == 0x0000000000000000:
             assert False, "Incorrect PTP value: '0x{0:016x}'".format(t.ptp)
     t = ptptime.ptptime(1970,1,1,0,0,1,0,0)
     if not t.ptp == 0x0000000100000000:
             assert False, "Incorrect PTP value: '0x{0:016x}'".format(t.ptp)
     t = ptptime.ptptime(1970,1,1,0,1,0,0,0)
     if not t.ptp == 0x0000003c00000000:
             assert False, "Incorrect PTP value: '0x{0:016x}'".format(t.ptp)
     t = ptptime.ptptime(1970,1,1,1,0,0,0,0)
     if not t.ptp == 0x00000e1000000000:
             assert False, "Incorrect PTP value: '0x{0:016x}'".format(t.ptp)
     t = ptptime.ptptime(1970,1,2,0,0,0,0,0)
     if not t.ptp == 0x0001518000000000:
             assert False, "Incorrect PTP value: '0x{0:016x}'".format(t.ptp)
     t = ptptime.ptptime(1970,2,1,0,0,0,0,0)
     if not t.ptp == 0x0028de8000000000:
             assert False, "Incorrect PTP value: '0x{0:016x}'".format(t.ptp)
     t = ptptime.ptptime(1971,1,1,0,0,0,0,0)
     if not t.ptp == 0x01e1338000000000:
             assert False, "Incorrect PTP value: '0x{0:016x}'".format(t.ptp)
     t = ptptime.ptptime(2000,1,1,0,0,0,0,0)
     expected = 0x386d438000000000
     if not t.ptp == expected:
             assert False, "Incorrect PTP value: 0x{0:016x}, expected 0x{1:016x}".format(t.ptp, expected)
Beispiel #2
0
    def testFromPtp(self):
        t = ptptime.timefromptp(0x0000000000000000)
        if not isinstance(t, ptptime.ptptime):
            assert False, "Incorrect Instance type: '{0}'".format(str(t))
        d = {'year': 1970, 'month': 1 , 'day': 1, 'hour': 0, 'minute': 0, 'second': 0, 'microsecond': 0, 'nanosecond': 0, 'leapyear': 0}
        checkAttributes(t, d)
        
        t = ptptime.timefromptp(0x386d438000000000)
        if not isinstance(t, ptptime.ptptime):
            assert False, "Incorrect Instance type: '{0}'".format(str(t))
        d = {'year': 2000, 'month': 1 , 'day': 1, 'hour': 0, 'minute': 0, 'second': 0, 'microsecond': 0, 'nanosecond': 0, 'leapyear': 0}
        checkAttributes(t, d)

        t = ptptime.timefromptp(0x386d43A000000000, leapyear=-1)
        if not isinstance(t, ptptime.ptptime):
            assert False, "Incorrect Instance type: '{0}'".format(str(t))
        d = {'year': 2000, 'month': 1 , 'day': 1, 'hour': 0, 'minute': 0, 'second': 0, 'microsecond': 0, 'nanosecond': 0, 'leapyear': -1}
        checkAttributes(t, d)

        t = ptptime.timefromptp(0x386d438100000000, leapyear=1)
        if not isinstance(t, ptptime.ptptime):
            assert False, "Incorrect Instance type: '{0}'".format(str(t))
        d = {'year': 2000, 'month': 1 , 'day': 1, 'hour': 0, 'minute': 0, 'second': 0, 'microsecond': 0, 'nanosecond': 0, 'leapyear': 1}
        checkAttributes(t, d)

        t = ptptime.timefromptp(0x14b0823f3b9ac618)
        if not isinstance(t, ptptime.ptptime):
            assert False, "Incorrect Instance type: '{0}'".format(str(t))
        d = {'year': 1980, 'month': 12 , 'day': 31, 'hour': 11, 'minute': 59, 'second': 59, 'microsecond': 999999, 'nanosecond': 0, 'leapyear': 0}
        checkAttributes(t, d)

        t = ptptime.timefromptp(0x14b12aff3b9ac618)
        if not isinstance(t, ptptime.ptptime):
            assert False, "Incorrect Instance type: '{0}'".format(str(t))
        d = {'year': 1980, 'month': 12 , 'day': 31, 'hour': 23, 'minute': 59, 'second': 59, 'microsecond': 999999, 'nanosecond': 0, 'leapyear': 0}
        checkAttributes(t, d)

        d = {'year': 1981, 'month': 1 , 'day': 1, 'hour': 0, 'minute': 0, 'second': 0, 'microsecond': 0, 'nanosecond': 0, 'leapyear': False}
        t = ptptime.ptptime(d['year'],d['month'],d['day'],d['hour'],d['minute'],d['second'],d['microsecond'],d['nanosecond'])
        checkAttributes(t, d)

        t = t - ptptime.timedelta(microseconds=1)
        d = {'year': 1980, 'month': 12 , 'day': 31, 'hour': 23, 'minute': 59, 'second': 59, 'microsecond': 999999, 'nanosecond': 0, 'leapyear': 0}
        checkAttributes(t, d)
        expected = 0x14b12aff3b9ac618
        if not t.ptp == expected:
                assert False, "Incorrect PTP value: 0x{0:016x}, expected 0x{1:016x}".format(t.ptp, expected)
        
        t = t - ptptime.timedelta(hours=12)
        d = {'year': 1980, 'month': 12 , 'day': 31, 'hour': 11, 'minute': 59, 'second': 59, 'microsecond': 999999, 'nanosecond': 0, 'leapyear': 0}
        checkAttributes(t, d)
        expected = 0x14b0823f3b9ac618
        if not t.ptp == expected:
                assert False, "Incorrect PTP value: 0x{0:016x}, expected 0x{1:016x}".format(t.ptp, expected)
Beispiel #3
0
    def testPTPdateTime(self):
        d = {'year': 1972, 'month': 11 , 'day': 12, 'hour': 16, 'minute': 24, 'second': 34, 'microsecond': 123456, 'nanosecond': 0, 'leapyear': False}
        t = ptptime.ptptime(d['year'],d['month'],d['day'],d['hour'],d['minute'],d['second'],d['microsecond'])
        checkAttributes(t, d)
        tn = t + datetime.timedelta(days=1)
        d['day'] = 13
        checkAttributes(tn, d)
        if not str(tn) == "1972-11-13 16:24:34.123456:000":
                assert False, "Incorrect Time Formatting: '{0}'".format(str(tn))

        tn = t - datetime.timedelta(days=1)
        d['day'] = 11
        checkAttributes(tn, d)
        if not str(tn) == "1972-11-11 16:24:34.123456:000":
                assert False, "Incorrect Time Formatting: '{0}'".format(str(tn))
Beispiel #4
0
    def testPTPError(self):
        d = {'year': 1972, 'month': 11 , 'day': 12, 'hour': 16, 'minute': 24, 'second': 34, 'microsecond': 123456, 'nanosecond': 0, 'leapyear': False}
        t = ptptime.ptptime(d['year'],d['month'],d['day'],d['hour'],d['minute'],d['second'],d['microsecond'])
        checkAttributes(t, d)
        
        d['nanosecond'] = 1
        t = t.replace(nanosecond=1)
        checkAttributes(t, d)
        d['microsecond'] = 1
        t = t.replace(microsecond=1)
        checkAttributes(t, d)
        d['second'] = 1
        t = t.replace(second=1)
        checkAttributes(t, d)
        d['minute'] = 1
        t = t.replace(minute=1)
        checkAttributes(t, d)
        d['hour'] = 1
        t = t.replace(hour=1)
        checkAttributes(t, d)
        d['day'] = 1
        t = t.replace(day=1)
        checkAttributes(t, d)
        d['month'] = 1
        t = t.replace(month=1)
        checkAttributes(t, d)
        d['year'] = 1970
        t = t.replace(year=1970)
        checkAttributes(t, d)
        
        self.assertRaises(NameError, t.replace, tree=1)
        self.assertRaises(NameError, t.replace, nanoseconds=1)
        
        self.assertRaises(ValueError, t.replace, microsecond=10000000)
        self.assertRaises(ValueError, t.replace, second=61)
        self.assertRaises(ValueError, t.replace, minute=61)
        self.assertRaises(ValueError, t.replace, hour=24)
        self.assertRaises(ValueError, t.replace, day=32)
        self.assertRaises(ValueError, t.replace, month=13)

        self.assertRaises(TypeError, t.__sub__, 1)
        self.assertRaises(TypeError, t.__add__, 1)
        self.assertRaises(TypeError, t.__add__, t)
        self.assertRaises(TypeError, t.__add__, datetime.datetime.now())

        t = t.replace(nanosecond=999)
        self.assertRaises(ValueError, t.replace, nanosecond=1000)
        self.assertRaises(ValueError, t.replace, nanosecond=1001)
Beispiel #5
0
    def testPTPAddition(self):
        d = {'year': 1972, 'month': 11 , 'day': 12, 'hour': 16, 'minute': 24, 'second': 34, 'microsecond': 123456, 'nanosecond': 0, 'leapyear': False}
        t = ptptime.ptptime(d['year'],d['month'],d['day'],d['hour'],d['minute'],d['second'],d['microsecond'])
        checkAttributes(t, d)
        tn = t + ptptime.timedelta(days=1)
        d['day'] = 13
        checkAttributes(tn, d)
        if not str(tn) == "1972-11-13 16:24:34.123456:000":
                assert False, "Incorrect Time Formatting: '{0}'".format(str(tn))

        d = {'year': 1972, 'month': 11 , 'day': 12, 'hour': 16, 'minute': 24, 'second': 34, 'microsecond': 123456, 'nanosecond': 0, 'leapyear': False}
        t = ptptime.ptptime(d['year'],d['month'],d['day'],d['hour'],d['minute'],d['second'],d['microsecond'])
        checkAttributes(t, d)
        tn = t + ptptime.timedelta(hours=1)
        d['hour'] = 17
        checkAttributes(tn, d)
        if not str(tn) == "1972-11-12 17:24:34.123456:000":
                assert False, "Incorrect Time Formatting: '{0}'".format(str(tn))

        d = {'year': 1972, 'month': 11 , 'day': 12, 'hour': 16, 'minute': 24, 'second': 34, 'microsecond': 123456, 'nanosecond': 0, 'leapyear': False}
        t = ptptime.ptptime(d['year'],d['month'],d['day'],d['hour'],d['minute'],d['second'],d['microsecond'])
        checkAttributes(t, d)
        tn = t + ptptime.timedelta(minutes=1)
        d['minute'] = 25
        checkAttributes(tn, d)
        if not str(tn) == "1972-11-12 16:25:34.123456:000":
                assert False, "Incorrect Time Formatting: '{0}'".format(str(tn))

        d = {'year': 1972, 'month': 11 , 'day': 12, 'hour': 16, 'minute': 24, 'second': 34, 'microsecond': 123456, 'nanosecond': 0, 'leapyear': False}
        t = ptptime.ptptime(d['year'],d['month'],d['day'],d['hour'],d['minute'],d['second'],d['microsecond'])
        checkAttributes(t, d)
        tn = t + ptptime.timedelta(seconds=1)
        d['second'] = 35
        checkAttributes(tn, d)
        if not str(tn) == "1972-11-12 16:24:35.123456:000":
                assert False, "Incorrect Time Formatting: '{0}'".format(str(tn))


        d = {'year': 1972, 'month': 11 , 'day': 12, 'hour': 16, 'minute': 24, 'second': 34, 'microsecond': 123456, 'nanosecond': 0, 'leapyear': False}
        t = ptptime.ptptime(d['year'],d['month'],d['day'],d['hour'],d['minute'],d['second'],d['microsecond'])
        checkAttributes(t, d)
        tn = t + ptptime.timedelta(microseconds=1)
        d['microsecond'] = 123457
        checkAttributes(tn, d)
        if not str(tn) == "1972-11-12 16:24:34.123457:000":
                assert False, "Incorrect Time Formatting: '{0}'".format(str(tn))


        d = {'year': 1972, 'month': 11 , 'day': 12, 'hour': 16, 'minute': 24, 'second': 34, 'microsecond': 123456, 'nanosecond': 0, 'leapyear': False}
        t = ptptime.ptptime(d['year'],d['month'],d['day'],d['hour'],d['minute'],d['second'],d['microsecond'])
        checkAttributes(t, d)
        tn = t + ptptime.timedelta(nanoseconds=1)
        d['nanosecond'] = 1
        checkAttributes(tn, d)
        if not str(tn) == "1972-11-12 16:24:34.123456:001":
                assert False, "Incorrect Time Formatting: '{0}'".format(str(tn))

        d = {'year': 1972, 'month': 11 , 'day': 12, 'hour': 16, 'minute': 24, 'second': 34, 'microsecond': 123456, 'nanosecond': 0, 'leapyear': False}
        t = ptptime.ptptime(d['year'],d['month'],d['day'],d['hour'],d['minute'],d['second'],d['microsecond'])
        checkAttributes(t, d)
        tn = t + ptptime.timedelta(nanoseconds=999)
        d['nanosecond'] = 999
        checkAttributes(tn, d)
        if not str(tn) == "1972-11-12 16:24:34.123456:999":
                assert False, "Incorrect Time Formatting: '{0}'".format(str(tn))

        d = {'year': 1972, 'month': 11 , 'day': 12, 'hour': 16, 'minute': 24, 'second': 34, 'microsecond': 123456, 'nanosecond': 0, 'leapyear': False}
        t = ptptime.ptptime(d['year'],d['month'],d['day'],d['hour'],d['minute'],d['second'],d['microsecond'])
        checkAttributes(t, d)
        tn = t + ptptime.timedelta(nanoseconds=1000)
        d['nanosecond'] = 0
        d['microsecond'] = 123457
        checkAttributes(tn, d)
        if not str(tn) == "1972-11-12 16:24:34.123457:000":
                assert False, "Incorrect Time Formatting: '{0}'".format(str(tn))

        d = {'year': 1972, 'month': 11 , 'day': 12, 'hour': 16, 'minute': 24, 'second': 34, 'microsecond': 123456, 'nanosecond': 0, 'leapyear': False}
        t = ptptime.ptptime(d['year'],d['month'],d['day'],d['hour'],d['minute'],d['second'],d['microsecond'])
        checkAttributes(t, d)
        tn = t + ptptime.timedelta(nanoseconds=1001)
        d['nanosecond'] = 1
        d['microsecond'] = 123457
        checkAttributes(tn, d)
        if not str(tn) == "1972-11-12 16:24:34.123457:001":
                assert False, "Incorrect Time Formatting: '{0}'".format(str(tn))

        d = {'year': 1972, 'month': 11 , 'day': 12, 'hour': 16, 'minute': 24, 'second': 34, 'microsecond': 999999, 'nanosecond': 0, 'leapyear': False}
        t = ptptime.ptptime(d['year'],d['month'],d['day'],d['hour'],d['minute'],d['second'],d['microsecond'])
        checkAttributes(t, d)
        tn = t + ptptime.timedelta(nanoseconds=1001)
        d['nanosecond'] = 1
        d['microsecond'] = 0
        d['second'] = 35
        checkAttributes(tn, d)
        if not str(tn) == "1972-11-12 16:24:35.000000:001":
                assert False, "Incorrect Time Formatting: '{0}'".format(str(tn))

        d = {'year': 1972, 'month': 11 , 'day': 12, 'hour': 16, 'minute': 24, 'second': 34, 'microsecond': 123456, 'nanosecond': 1, 'leapyear': False}
        t = ptptime.ptptime(d['year'],d['month'],d['day'],d['hour'],d['minute'],d['second'],d['microsecond'], d['nanosecond'])
        checkAttributes(t, d)
        tn = t + ptptime.timedelta(nanoseconds=1)
        d['nanosecond'] = 2
        checkAttributes(tn, d)
        if not str(tn) == "1972-11-12 16:24:34.123456:002":
                assert False, "Incorrect Time Formatting: '{0}'".format(str(tn))

        d = {'year': 1972, 'month': 11 , 'day': 12, 'hour': 16, 'minute': 24, 'second': 34, 'microsecond': 123456, 'nanosecond': 501, 'leapyear': False}
        t = ptptime.ptptime(d['year'],d['month'],d['day'],d['hour'],d['minute'],d['second'],d['microsecond'], d['nanosecond'])
        checkAttributes(t, d)
        tn = t + ptptime.timedelta(nanoseconds=501)
        d['nanosecond'] = 2
        d['microsecond'] = 123457
        checkAttributes(tn, d)
        if not str(tn) == "1972-11-12 16:24:34.123457:002":
                assert False, "Incorrect Time Formatting: '{0}'".format(str(tn))

        d = {'year': 1972, 'month': 11 , 'day': 12, 'hour': 16, 'minute': 24, 'second': 34, 'microsecond': 123456, 'nanosecond': 1, 'leapyear': False}
        t = ptptime.ptptime(d['year'],d['month'],d['day'],d['hour'],d['minute'],d['second'],d['microsecond'], nanosecond=d['nanosecond'])
        checkAttributes(t, d)
        tn = t + ptptime.timedelta(nanoseconds=1)
        d['nanosecond'] = 2
        checkAttributes(tn, d)
        if not str(tn) == "1972-11-12 16:24:34.123456:002":
                assert False, "Incorrect Time Formatting: '{0}'".format(str(tn))

        d = {'year': 1972, 'month': 11 , 'day': 12, 'hour': 16, 'minute': 24, 'second': 34, 'microsecond': 123456, 'nanosecond': 501, 'leapyear': False}
        t = ptptime.ptptime(d['year'],d['month'],d['day'],d['hour'],d['minute'],d['second'],d['microsecond'], nanosecond=d['nanosecond'])
        checkAttributes(t, d)
        tn = t + ptptime.timedelta(nanoseconds=501)
        d['nanosecond'] = 2
        d['microsecond'] = 123457
        checkAttributes(tn, d)
        if not str(tn) == "1972-11-12 16:24:34.123457:002":
                assert False, "Incorrect Time Formatting: '{0}'".format(str(tn))
Beispiel #6
0
    def testPTPCreation(self):
        
        d = {'year': 2000, 'month': 1 , 'day': 1, 'hour': 0, 'minute': 0, 'second': 0, 'microsecond': 0, 'nanosecond': 0, 'leapyear': False}
        
        t = ptptime.ptptime(d['year'],d['month'],d['day'],d['hour'],d['minute'],d['second'],d['microsecond'])
        checkAttributes(t, d)
        
        if not str(t) == "2000-1-1 00:00:00.000000:000":
                assert False, "Incorrect Time Formatting: '{0}'".format(str(t))

        if not t.ptp == 0x386d438000000000:
                assert False, "Incorrect PTP value: '0x{0:016x}'".format(t.ptp)
        d = {'year': 1972, 'month': 11 , 'day': 12, 'hour': 16, 'minute': 24, 'second': 34, 'microsecond': 123456, 'nanosecond': 0, 'leapyear': False}
        
        t = ptptime.ptptime(d['year'],d['month'],d['day'],d['hour'],d['minute'],d['second'],d['microsecond'])
        checkAttributes(t, d)
        
        if not str(t) == "1972-11-12 16:24:34.123456:000":
                assert False, "Incorrect Time Formatting: '{0}'".format(str(t))

        if not t.ptp == 0x0563e7c2075bca00:
                assert False, "Incorrect PTP value: '0x{0:016x}'".format(t.ptp)
        if not t.sbi == 0x04160317cb2434123456:
                assert False, "Incorrect SBI value: '0x{0:020x}'".format(t.sbi)
        if not t.iena == 0x18e296f216c0:
                assert False, "Incorrect IENA value: '0x{0:012x}'".format(t.iena)

#         x = t.printPTP()
#         if not x == "0x0563e7c2075bca00":
#                 assert False, "Incorrect printPTP: '0x{0:016x}'".format(t.ptp)
#         
        d['nanosecond'] = 235
        t = ptptime.ptptime(d['year'],d['month'],d['day'],d['hour'],d['minute'],d['second'],d['microsecond'],d['nanosecond'])
        checkAttributes(t, d)

        if not str(t) == "1972-11-12 16:24:34.123456:235":
                assert False, "Incorrect Time Formatting: '{0}'".format(str(t))

        if not t.ptp == 0x0563e7c2075bcaeb:
                assert False, "Incorrect PTP value: '0x{0:016x}'".format(t.ptp)
        if not t.sbi == 0x04160317cb2434123456:
                assert False, "Incorrect SBI value: '0x{0:020x}'".format(t.sbi)
        if not t.iena == 0x18e296f216c0:
                assert False, "Incorrect IENA value: '0x{0:012x}'".format(t.iena)
        
        d['nanosecond'] = 123
        t = ptptime.ptptime(d['year'],d['month'],d['day'],d['hour'],d['minute'],d['second'],d['microsecond'],nanosecond=d['nanosecond'])
        checkAttributes(t, d)

        if not str(t) == "1972-11-12 16:24:34.123456:123":
                assert False, "Incorrect Time Formatting: '{0}'".format(str(t))

        if not t.ptp == 0x0563e7c2075bca7b:
                assert False, "Incorrect PTP value: '0x{0:016x}'".format(t.ptp)
        if not t.sbi == 0x04160317cb2434123456:
                assert False, "Incorrect SBI value: '0x{0:020x}'".format(t.sbi)
        if not t.iena == 0x18e296f216c0:
                assert False, "Incorrect IENA value: '0x{0:012x}'".format(t.iena)
        

        d['year'] = 2008
        d['leapyear'] = True
        d['nanosecond'] = 0
        t = ptptime.ptptime(d['year'],d['month'],d['day'],d['hour'],d['minute'],d['second'],d['microsecond'], leapyear=d['leapyear'])
        checkAttributes(t, d)
        
        if not str(t) == "2008-11-12 16:24:34.123456:000":
                assert False, "Incorrect Time Formatting: '{0}'".format(str(t))
        
        if not t.ptp == 0x491b0343075bca00:
                assert False, "Incorrect PTP value: '0x{0:016x}'".format(t.ptp)
        if not t.sbi == 0x377303174b2434123456:
                assert False, "Incorrect SBI value: '0x{0:020x}'".format(t.sbi)
        if not t.iena == 0x18e297015900:
                assert False, "Incorrect IENA value: '0x{0:012x}'".format(t.iena)

        d['nanosecond'] = 235
        t = ptptime.ptptime(d['year'],d['month'],d['day'],d['hour'],d['minute'],d['second'],d['microsecond'],d['nanosecond'], leapyear=d['leapyear'])
        checkAttributes(t, d)

        if not str(t) == "2008-11-12 16:24:34.123456:235":
                assert False, "Incorrect Time Formatting: '{0}'".format(str(t))

        if not t.ptp == 0x491b0343075bcaeb:
                assert False, "Incorrect PTP value: '0x{0:016x}'".format(t.ptp)
        if not t.sbi == 0x377303174b2434123456:
                assert False, "Incorrect SBI value: '0x{0:020x}'".format(t.sbi)
        if not t.iena == 0x18e297015900:
                assert False, "Incorrect IENA value: '0x{0:012x}'".format(t.iena)
        
        d['nanosecond'] = 123
        t = ptptime.ptptime(d['year'],d['month'],d['day'],d['hour'],d['minute'],d['second'],d['microsecond'],nanosecond=d['nanosecond'], leapyear=d['leapyear'])
        checkAttributes(t, d)

        if not str(t) == "2008-11-12 16:24:34.123456:123":
                assert False, "Incorrect Time Formatting: '{0}'".format(str(t))

        if not t.ptp == 0x491b0343075bca7b:
                assert False, "Incorrect PTP value: '0x{0:016x}'".format(t.ptp)
        if not t.sbi == 0x377303174b2434123456:
                assert False, "Incorrect SBI value: '0x{0:020x}'".format(t.sbi)
        if not t.iena == 0x18e297015900:
                assert False, "Incorrect IENA value: '0x{0:012x}'".format(t.iena)
Beispiel #7
0
    def testPTPutcfromtimestamp(self):
        x0 = ptptime.ptptime(1970,1,1,0,0,0,0,0)
        x1 = ptptime.ptptime.utcfromtimestamp(0)
        x2 = x0 - x1

        if not isinstance(x0, ptptime.ptptime):
            assert False, "Incorrect Instance type: '{0}'".format(str(x0))
        if not isinstance(x1, ptptime.ptptime):
            assert False, "Incorrect Instance type: '{0}'".format(str(x1))
        if not isinstance(x2, ptptime.timedelta):
            assert False, "Incorrect Instance type: '{0}'".format(str(x2))

        d = {'year': 1970, 'month': 1 , 'day': 1, 'hour': 0, 'minute': 0, 'second': 0, 'microsecond': 0, 'nanosecond': 0, 'leapyear': False}
        checkAttributes(x1, d)

        d = {'days': 0, 'seconds': 0, 'microseconds': 0, 'nanoseconds': 0}
        checkAttributes(x2, d)
        expected = 0
        if not expected == x0.total_seconds:
            assert False, "Incorrect Total Seconds: '{0}' expected '{1}'".format(x0.total_seconds, expected)
        

        x0 = ptptime.ptptime(1970,1,1,0,1,0,0,0)
        x1 = ptptime.ptptime.utcfromtimestamp(0)
        x2 = x0 - x1        
        
        x0 = ptptime.ptptime(1970,1,1,0,0,1,0,0)
        x1 = ptptime.ptptime.utcfromtimestamp(0)
        x2 = x0 - x1

        if not isinstance(x0, ptptime.ptptime):
            assert False, "Incorrect Instance type: '{0}'".format(str(x0))
        if not isinstance(x1, ptptime.ptptime):
            assert False, "Incorrect Instance type: '{0}'".format(str(x1))
        if not isinstance(x2, ptptime.timedelta):
            assert False, "Incorrect Instance type: '{0}'".format(str(x2))

        d = {'year': 1970, 'month': 1 , 'day': 1, 'hour': 0, 'minute': 0, 'second': 0, 'microsecond': 0, 'nanosecond': 0, 'leapyear': False}
        checkAttributes(x1, d)

        d = {'days': 0, 'seconds': 1, 'microseconds': 0, 'nanoseconds': 0}
        checkAttributes(x2, d)
        
        expected = 1
        if not expected == x0.total_seconds:
            assert False, "Incorrect Total Seconds: '{0}' expected '{1}'".format(x0.total_seconds, expected)

        x0 = ptptime.ptptime(1970,1,1,0,1,0,0,0)
        x1 = ptptime.ptptime.utcfromtimestamp(0)
        x2 = x0 - x1        

        if not isinstance(x0, ptptime.ptptime):
            assert False, "Incorrect Instance type: '{0}'".format(str(x0))
        if not isinstance(x1, ptptime.ptptime):
            assert False, "Incorrect Instance type: '{0}'".format(str(x1))
        if not isinstance(x2, ptptime.timedelta):
            assert False, "Incorrect Instance type: '{0}'".format(str(x2))

        d = {'days': 0, 'seconds': 60, 'microseconds': 0, 'nanoseconds': 0}
        checkAttributes(x2, d)
        
        expected = 60
        if not expected == x0.total_seconds:
            assert False, "Incorrect Total Seconds: '{0}' expected '{1}'".format(x0.total_seconds, expected)

        x0 = ptptime.ptptime(1970,1,1,1,0,0,0,0)
        x1 = ptptime.ptptime.utcfromtimestamp(0)
        x2 = x0 - x1

        if not isinstance(x0, ptptime.ptptime):
            assert False, "Incorrect Instance type: '{0}'".format(str(x0))
        if not isinstance(x1, ptptime.ptptime):
            assert False, "Incorrect Instance type: '{0}'".format(str(x1))
        if not isinstance(x2, ptptime.timedelta):
            assert False, "Incorrect Instance type: '{0}'".format(str(x2))

        d = {'days': 0, 'seconds': 3600, 'microseconds': 0, 'nanoseconds': 0}
        checkAttributes(x2, d)

        expected = 3600
        if not expected == x0.total_seconds:
            assert False, "Incorrect Total Seconds: '{0}' expected '{1}'".format(x0.total_seconds, expected)

        x0 = ptptime.ptptime(1970,1,2,0,0,0,0,0)
        x1 = ptptime.ptptime.utcfromtimestamp(0)
        x2 = x0 - x1

        if not isinstance(x0, ptptime.ptptime):
            assert False, "Incorrect Instance type: '{0}'".format(str(x0))
        if not isinstance(x1, ptptime.ptptime):
            assert False, "Incorrect Instance type: '{0}'".format(str(x1))
        if not isinstance(x2, ptptime.timedelta):
            assert False, "Incorrect Instance type: '{0}'".format(str(x2))

        d = {'days': 1, 'seconds': 0, 'microseconds': 0, 'nanoseconds': 0}
        checkAttributes(x2, d)

        expected = 86400
        if not expected == x0.total_seconds:
            assert False, "Incorrect Total Seconds: '{0}' expected '{1}'".format(x0.total_seconds, expected)

        x0 = ptptime.ptptime(1970,2,1,0,0,0,0,0)
        x1 = ptptime.ptptime.utcfromtimestamp(0)
        x2 = x0 - x1

        if not isinstance(x0, ptptime.ptptime):
            assert False, "Incorrect Instance type: '{0}'".format(str(x0))
        if not isinstance(x1, ptptime.ptptime):
            assert False, "Incorrect Instance type: '{0}'".format(str(x1))
        if not isinstance(x2, ptptime.timedelta):
            assert False, "Incorrect Instance type: '{0}'".format(str(x2))

        d = {'days': 31, 'seconds': 0, 'microseconds': 0, 'nanoseconds': 0}
        checkAttributes(x2, d)

        expected = 2678400
        if not expected == x0.total_seconds:
            assert False, "Incorrect Total Seconds: '{0}' expected '{1}'".format(x0.total_seconds, expected)

        x0 = ptptime.ptptime(1971,1,1,0,0,0,0,0)
        x1 = ptptime.ptptime.utcfromtimestamp(0)
        x2 = x0 - x1

        if not isinstance(x0, ptptime.ptptime):
            assert False, "Incorrect Instance type: '{0}'".format(str(x0))
        if not isinstance(x1, ptptime.ptptime):
            assert False, "Incorrect Instance type: '{0}'".format(str(x1))
        if not isinstance(x2, ptptime.timedelta):
            assert False, "Incorrect Instance type: '{0}'".format(str(x2))

        d = {'days': 365, 'seconds': 0, 'microseconds': 0, 'nanoseconds': 0}
        checkAttributes(x2, d)

        expected = 31536000
        if not expected == x0.total_seconds:
            assert False, "Incorrect Total Seconds: '{0}' expected '{1}'".format(x0.total_seconds, expected)

        x0 = ptptime.ptptime(1971,2,2,1,1,1,1,1)
        x1 = ptptime.ptptime.utcfromtimestamp(0)
        x2 = x0 - x1

        if not isinstance(x0, ptptime.ptptime):
            assert False, "Incorrect Instance type: '{0}'".format(str(x0))
        if not isinstance(x1, ptptime.ptptime):
            assert False, "Incorrect Instance type: '{0}'".format(str(x1))
        if not isinstance(x2, ptptime.timedelta):
            assert False, "Incorrect Instance type: '{0}'".format(str(x2))

        d = {'year': 1970, 'month': 1 , 'day': 1, 'hour': 0, 'minute': 0, 'second': 0, 'microsecond': 0, 'nanosecond': 0, 'leapyear': False}
        checkAttributes(x1, d)

        d = {'days': 397, 'seconds': 3661, 'microseconds': 1, 'nanoseconds': 1}
        checkAttributes(x2, d)
        x0 = ptptime.ptptime(1971,2,2,1,1,1,1,1001)
        x1 = ptptime.ptptime.utcfromtimestamp(0)
        x2 = x0 - x1

        if not isinstance(x0, ptptime.ptptime):
            assert False, "Incorrect Instance type: '{0}'".format(str(x0))
        if not isinstance(x1, ptptime.ptptime):
            assert False, "Incorrect Instance type: '{0}'".format(str(x1))
        if not isinstance(x2, ptptime.timedelta):
            assert False, "Incorrect Instance type: '{0}'".format(str(x2))

        d = {'year': 1970, 'month': 1 , 'day': 1, 'hour': 0, 'minute': 0, 'second': 0, 'microsecond': 0, 'nanosecond': 0, 'leapyear': False}
        checkAttributes(x1, d)

        d = {'days': 397, 'seconds': 3661, 'microseconds': 2, 'nanoseconds': 1}
        checkAttributes(x2, d)

        x0 = ptptime.ptptime(1971,2,2,1,1,1,999999,1001)
        x1 = ptptime.ptptime.utcfromtimestamp(0)
        x2 = x0 - x1

        if not isinstance(x0, ptptime.ptptime):
            assert False, "Incorrect Instance type: '{0}'".format(str(x0))
        if not isinstance(x1, ptptime.ptptime):
            assert False, "Incorrect Instance type: '{0}'".format(str(x1))
        if not isinstance(x2, ptptime.timedelta):
            assert False, "Incorrect Instance type: '{0}'".format(str(x2))

        d = {'year': 1970, 'month': 1 , 'day': 1, 'hour': 0, 'minute': 0, 'second': 0, 'microsecond': 0, 'nanosecond': 0, 'leapyear': False}
        checkAttributes(x1, d)

        d = {'days': 397, 'seconds': 3662, 'microseconds': 0, 'nanoseconds': 1}
        checkAttributes(x2, d)
Beispiel #8
0
    def testPTPSubtraction(self):
        d = {'year': 1972, 'month': 11 , 'day': 12, 'hour': 16, 'minute': 24, 'second': 34, 'microsecond': 123456, 'nanosecond': 0, 'leapyear': False}
        t = ptptime.ptptime(d['year'],d['month'],d['day'],d['hour'],d['minute'],d['second'],d['microsecond'])
        checkAttributes(t, d)
        tn = t - ptptime.timedelta(days=1)
        d['day'] = 11
        checkAttributes(tn, d)
        if not str(tn) == "1972-11-11 16:24:34.123456:000":
                assert False, "Incorrect Time Formatting: '{0}'".format(str(tn))

        d = {'year': 1972, 'month': 11 , 'day': 12, 'hour': 16, 'minute': 24, 'second': 34, 'microsecond': 123456, 'nanosecond': 0, 'leapyear': False}
        t = ptptime.ptptime(d['year'],d['month'],d['day'],d['hour'],d['minute'],d['second'],d['microsecond'])
        checkAttributes(t, d)
        tn = t - ptptime.timedelta(hours=1)
        d['hour'] = 15
        checkAttributes(tn, d)
        if not str(tn) == "1972-11-12 15:24:34.123456:000":
                assert False, "Incorrect Time Formatting: '{0}'".format(str(tn))

        d = {'year': 1972, 'month': 11 , 'day': 12, 'hour': 16, 'minute': 24, 'second': 34, 'microsecond': 123456, 'nanosecond': 0, 'leapyear': False}
        t = ptptime.ptptime(d['year'],d['month'],d['day'],d['hour'],d['minute'],d['second'],d['microsecond'])
        checkAttributes(t, d)
        tn = t - ptptime.timedelta(minutes=1)
        d['minute'] = 23
        checkAttributes(tn, d)
        if not str(tn) == "1972-11-12 16:23:34.123456:000":
                assert False, "Incorrect Time Formatting: '{0}'".format(str(tn))

        d = {'year': 1972, 'month': 11 , 'day': 12, 'hour': 16, 'minute': 24, 'second': 34, 'microsecond': 123456, 'nanosecond': 0, 'leapyear': False}
        t = ptptime.ptptime(d['year'],d['month'],d['day'],d['hour'],d['minute'],d['second'],d['microsecond'])
        checkAttributes(t, d)
        tn = t - ptptime.timedelta(seconds=1)
        d['second'] = 33
        checkAttributes(tn, d)
        if not str(tn) == "1972-11-12 16:24:33.123456:000":
                assert False, "Incorrect Time Formatting: '{0}'".format(str(tn))


        d = {'year': 1972, 'month': 11 , 'day': 12, 'hour': 16, 'minute': 24, 'second': 34, 'microsecond': 123456, 'nanosecond': 0, 'leapyear': False}
        t = ptptime.ptptime(d['year'],d['month'],d['day'],d['hour'],d['minute'],d['second'],d['microsecond'])
        checkAttributes(t, d)
        tn = t - ptptime.timedelta(microseconds=1)
        d['microsecond'] = 123455
        checkAttributes(tn, d)
        if not str(tn) == "1972-11-12 16:24:34.123455:000":
                assert False, "Incorrect Time Formatting: '{0}'".format(str(tn))


        d = {'year': 1972, 'month': 11 , 'day': 12, 'hour': 16, 'minute': 24, 'second': 34, 'microsecond': 123456, 'nanosecond': 54, 'leapyear': False}
        t = ptptime.ptptime(d['year'],d['month'],d['day'],d['hour'],d['minute'],d['second'],d['microsecond'],d['nanosecond'])
        checkAttributes(t, d)
        tn = t - ptptime.timedelta(nanoseconds=1)
        d['nanosecond'] = 53
        checkAttributes(tn, d)
        if not str(tn) == "1972-11-12 16:24:34.123456:053":
                assert False, "Incorrect Time Formatting: '{0}'".format(str(tn))

        d = {'year': 1972, 'month': 11 , 'day': 12, 'hour': 16, 'minute': 24, 'second': 34, 'microsecond': 123456, 'nanosecond': 0, 'leapyear': False}
        t = ptptime.ptptime(d['year'],d['month'],d['day'],d['hour'],d['minute'],d['second'],d['microsecond'],d['nanosecond'])
        checkAttributes(t, d)
        tn = t - ptptime.timedelta(nanoseconds=1)
        d['nanosecond'] = 999
        d['microsecond'] = 123455
        checkAttributes(tn, d)
        if not str(tn) == "1972-11-12 16:24:34.123455:999":
                assert False, "Incorrect Time Formatting: '{0}'".format(str(tn))

        d = {'year': 1972, 'month': 11 , 'day': 12, 'hour': 16, 'minute': 24, 'second': 34, 'microsecond': 0, 'nanosecond': 0, 'leapyear': False}
        t = ptptime.ptptime(d['year'],d['month'],d['day'],d['hour'],d['minute'],d['second'],d['microsecond'],d['nanosecond'])
        checkAttributes(t, d)
        tn = t - ptptime.timedelta(nanoseconds=1)
        d['nanosecond'] = 999
        d['microsecond'] = 999999
        d['second'] = 33
        checkAttributes(tn, d)
        if not str(tn) == "1972-11-12 16:24:33.999999:999":
                assert False, "Incorrect Time Formatting: '{0}'".format(str(tn))

        d = {'year': 1972, 'month': 11 , 'day': 12, 'hour': 16, 'minute': 24, 'second': 0, 'microsecond': 0, 'nanosecond': 0, 'leapyear': False}
        t = ptptime.ptptime(d['year'],d['month'],d['day'],d['hour'],d['minute'],d['second'],d['microsecond'],d['nanosecond'])
        checkAttributes(t, d)
        tn = t - ptptime.timedelta(nanoseconds=1)
        d['nanosecond'] = 999
        d['microsecond'] = 999999
        d['second'] = 59
        d['minute'] = 23
        checkAttributes(tn, d)
        if not str(tn) == "1972-11-12 16:23:59.999999:999":
                assert False, "Incorrect Time Formatting: '{0}'".format(str(tn))

        d = {'year': 1972, 'month': 11 , 'day': 12, 'hour': 16, 'minute': 0, 'second': 0, 'microsecond': 0, 'nanosecond': 0, 'leapyear': False}
        t = ptptime.ptptime(d['year'],d['month'],d['day'],d['hour'],d['minute'],d['second'],d['microsecond'],d['nanosecond'])
        checkAttributes(t, d)
        tn = t - ptptime.timedelta(nanoseconds=1)
        d['nanosecond'] = 999
        d['microsecond'] = 999999
        d['second'] = 59
        d['minute'] = 59
        d['hour'] = 15
        checkAttributes(tn, d)
        if not str(tn) == "1972-11-12 15:59:59.999999:999":
                assert False, "Incorrect Time Formatting: '{0}'".format(str(tn))

        d = {'year': 1972, 'month': 11 , 'day': 12, 'hour': 0, 'minute': 0, 'second': 0, 'microsecond': 0, 'nanosecond': 0, 'leapyear': False}
        t = ptptime.ptptime(d['year'],d['month'],d['day'],d['hour'],d['minute'],d['second'],d['microsecond'],d['nanosecond'])
        checkAttributes(t, d)
        tn = t - ptptime.timedelta(nanoseconds=1)
        d['nanosecond'] = 999
        d['microsecond'] = 999999
        d['second'] = 59
        d['minute'] = 59
        d['hour'] = 23
        d['day'] = 11
        checkAttributes(tn, d)
        if not str(tn) == "1972-11-11 23:59:59.999999:999":
                assert False, "Incorrect Time Formatting: '{0}'".format(str(tn))

        d = {'year': 1972, 'month': 11 , 'day': 1, 'hour': 0, 'minute': 0, 'second': 0, 'microsecond': 0, 'nanosecond': 0, 'leapyear': False}
        t = ptptime.ptptime(d['year'],d['month'],d['day'],d['hour'],d['minute'],d['second'],d['microsecond'],d['nanosecond'])
        checkAttributes(t, d)
        tn = t - ptptime.timedelta(nanoseconds=1)
        d['nanosecond'] = 999
        d['microsecond'] = 999999
        d['second'] = 59
        d['minute'] = 59
        d['hour'] = 23
        d['day'] = 31
        d['month'] = 10
        checkAttributes(tn, d)
        if not str(tn) == "1972-10-31 23:59:59.999999:999":
                assert False, "Incorrect Time Formatting: '{0}'".format(str(tn))

        d = {'year': 1972, 'month': 1 , 'day': 1, 'hour': 0, 'minute': 0, 'second': 0, 'microsecond': 0, 'nanosecond': 0, 'leapyear': False}
        t = ptptime.ptptime(d['year'],d['month'],d['day'],d['hour'],d['minute'],d['second'],d['microsecond'],d['nanosecond'])
        checkAttributes(t, d)
        tn = t - ptptime.timedelta(nanoseconds=1)
        d['nanosecond'] = 999
        d['microsecond'] = 999999
        d['second'] = 59
        d['minute'] = 59
        d['hour'] = 23
        d['day'] = 31
        d['month'] = 12
        d['year'] = 1971
        checkAttributes(tn, d)
        if not str(tn) == "1971-12-31 23:59:59.999999:999":
                assert False, "Incorrect Time Formatting: '{0}'".format(str(tn))

        d = {'year': 1970, 'month': 1 , 'day': 1, 'hour': 0, 'minute': 0, 'second': 0, 'microsecond': 0, 'nanosecond': 0, 'leapyear': False}
        t = ptptime.ptptime(d['year'],d['month'],d['day'],d['hour'],d['minute'],d['second'],d['microsecond'],d['nanosecond'])
        checkAttributes(t, d)
        tn = t - ptptime.timedelta(nanoseconds=1)
        d['nanosecond'] = 999
        d['microsecond'] = 999999
        d['second'] = 59
        d['minute'] = 59
        d['hour'] = 23
        d['day'] = 31
        d['month'] = 12
        d['year'] = 1969
        checkAttributes(tn, d)
        if not str(tn) == "1969-12-31 23:59:59.999999:999":
                assert False, "Incorrect Time Formatting: '{0}'".format(str(tn))

        d = {'year': 1972, 'month': 1 , 'day': 1, 'hour': 0, 'minute': 0, 'second': 0, 'microsecond': 0, 'nanosecond': 0, 'leapyear': False}
        t = ptptime.ptptime(d['year'],d['month'],d['day'],d['hour'],d['minute'],d['second'],d['microsecond'],d['nanosecond'])
        checkAttributes(t, d)
        tn = t - ptptime.timedelta(nanoseconds=1001)
        d['nanosecond'] = 999
        d['microsecond'] = 999998
        d['second'] = 59
        d['minute'] = 59
        d['hour'] = 23
        d['day'] = 31
        d['month'] = 12
        d['year'] = 1971
        checkAttributes(tn, d)
        if not str(tn) == "1971-12-31 23:59:59.999998:999":
                assert False, "Incorrect Time Formatting: '{0}'".format(str(tn))

        d = {'year': 1972, 'month': 1 , 'day': 1, 'hour': 0, 'minute': 0, 'second': 0, 'microsecond': 0, 'nanosecond': 501, 'leapyear': False}
        t = ptptime.ptptime(d['year'],d['month'],d['day'],d['hour'],d['minute'],d['second'],d['microsecond'],d['nanosecond'])
        checkAttributes(t, d)
        tn = t - ptptime.timedelta(nanoseconds=1002)
        d['nanosecond'] = 499
        d['microsecond'] = 999999
        d['second'] = 59
        d['minute'] = 59
        d['hour'] = 23
        d['day'] = 31
        d['month'] = 12
        d['year'] = 1971
        checkAttributes(tn, d)
        if not str(tn) == "1971-12-31 23:59:59.999999:499":
                assert False, "Incorrect Time Formatting: '{0}'".format(str(tn))