| # The MIT License |
| # |
| # Copyright (C) 2009 Erick Tryzelaar |
| # |
| # Copyright (C) 2009 Floris Bruynooghe |
| # |
| # |
| # Permission is hereby granted, free of charge, to any person |
| # obtaining a copy of this software and associated documentation files |
| # (the "Software"), to deal in the Software without restriction, |
| # including without limitation the rights to use, copy, modify, merge, |
| # publish, distribute, sublicense, and/or sell copies of the Software, |
| # and to permit persons to whom the Software is furnished to do so, |
| # subject to the following conditions: |
| # |
| # The above copyright notice and this permission notice shall be |
| # included in all copies or substantial portions of the Software. |
| # |
| # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, |
| # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
| # MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND |
| # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS |
| # BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
| # ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN |
| # CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
| # SOFTWARE. |
| |
| |
| import sys |
| import time |
| import unittest |
| |
| import psi |
| |
| try: |
| import datetime |
| except ImportError: |
| HAVE_DATETIME = False |
| else: |
| HAVE_DATETIME = True |
| |
| |
| class TimeSpecTests(unittest.TestCase): |
| def setUp(self): |
| self.tv = psi.TimeSpec(5, 10) |
| |
| def test_type(self): |
| self.assert_(isinstance(self.tv, psi.TimeSpec)) |
| |
| def test_init(self): |
| tv = psi.TimeSpec(5, 10) |
| self.assertEqual(tv.tv_sec, 5) |
| self.assertEqual(tv.tv_nsec, 10) |
| tv = psi.TimeSpec(tv_sec=6, tv_nsec=11) |
| self.assertEqual(tv.tv_sec, 6) |
| self.assertEqual(tv.tv_nsec, 11) |
| |
| def test_init_normalise(self): |
| t = psi.TimeSpec(0, 1000000001) |
| self.assertEqual(t.tv_sec, 1) |
| self.assertEqual(t.tv_nsec, 1) |
| t = psi.TimeSpec(-1, -1000000001) |
| self.assertEqual(t.tv_sec, -1) |
| self.assertEqual(t.tv_nsec, -999999999) |
| t = psi.TimeSpec(0, -2000000000) |
| self.assertEqual(t.tv_sec, -2) |
| self.assertEqual(t.tv_nsec, 0) |
| t = psi.TimeSpec(-1, 500000000) |
| self.assertEqual(t.tv_sec, 0) |
| self.assertEqual(t.tv_nsec, -500000000) |
| t = psi.TimeSpec(1, -500000000) |
| self.assertEqual(t.tv_sec, 0) |
| self.assertEqual(t.tv_nsec, 500000000) |
| |
| def test_tuple(self): |
| self.assertEqual(self.tv[0], 5) |
| self.assertEqual(self.tv[1], 10) |
| self.assertRaises(IndexError, self.tv.__getitem__, -1) |
| self.assertRaises(IndexError, self.tv.__getitem__, 2) |
| |
| def test_hash(self): |
| self.assertEqual(hash(self.tv), hash(psi.TimeSpec(5, 10))) |
| |
| def test_eq(self): |
| self.assertEqual(self.tv, psi.TimeSpec(5, 10)) |
| |
| def test_ne(self): |
| self.assertNotEqual(self.tv, psi.TimeSpec(5, 11)) |
| self.assertNotEqual(self.tv, psi.TimeSpec(4, 10)) |
| self.assertNotEqual(self.tv, psi.TimeSpec(4, 11)) |
| |
| def test_lt(self): |
| self.assert_(self.tv < psi.TimeSpec(5, 11)) |
| self.assert_(self.tv < psi.TimeSpec(6, 10)) |
| self.assert_(not self.tv < psi.TimeSpec(5, 9)) |
| self.assert_(not self.tv < psi.TimeSpec(5, 10)) |
| |
| def test_lt_distorted(self): |
| self.assert_(self.tv < psi.TimeSpec(4, 1000000015)) |
| |
| def test_le(self): |
| self.assert_(self.tv <= psi.TimeSpec(5, 11)) |
| self.assert_(self.tv <= psi.TimeSpec(5, 10)) |
| self.assert_(not self.tv <= psi.TimeSpec(5, 9)) |
| |
| def test_gt(self): |
| self.assert_(self.tv > psi.TimeSpec(5, 9)) |
| self.assert_(not self.tv > psi.TimeSpec(5, 10)) |
| |
| def test_gt_distorted(self): |
| self.assert_(psi.TimeSpec(4, 1000000015) > self.tv) |
| |
| def test_ge(self): |
| self.assert_(self.tv >= psi.TimeSpec(5, 10)) |
| self.assert_(self.tv >= psi.TimeSpec(5, 9)) |
| self.assert_(not self.tv >= psi.TimeSpec(5, 11)) |
| |
| def test_compare_tuple(self): |
| self.assert_(self.tv > (5, 9)) |
| self.assert_(self.tv >= (5, 9)) |
| self.assert_(self.tv == (5, 10)) |
| self.assert_((5, 10) == self.tv) |
| self.assert_(self.tv <= (5, 11)) |
| self.assert_(self.tv < (5, 11)) |
| |
| def test_compare_int(self): |
| self.assert_(self.tv > 5) |
| self.assert_(self.tv != 5) |
| self.assert_(self.tv < 6) |
| |
| def test_compare_float(self): |
| self.assert_(self.tv > 5.0) |
| self.assert_(self.tv != 5.0) |
| self.assert_(self.tv < 5.1) |
| |
| if sys.version_info[0] < 3: |
| def test_compare_tuple_long(self): |
| self.assert_(self.tv == (long(5), long(10))) |
| |
| def test_add(self): |
| self.assertEqual(self.tv + psi.TimeSpec(5, 10), psi.TimeSpec(10, 20)) |
| |
| def test_add_rollover(self): |
| sum = self.tv + psi.TimeSpec(0, 999999995) |
| self.assertEqual(sum, psi.TimeSpec(6, 5)) |
| |
| def test_add_tuple(self): |
| self.assertEqual(self.tv + (5, 10), psi.TimeSpec(10, 20)) |
| |
| def test_add_tuple_bad(self): |
| self.assertEqual(self.tv.__add__((5, 10, 0)), NotImplemented) |
| |
| def test_add_int(self): |
| self.assertEqual(self.tv + 5, psi.TimeSpec(10, 10)) |
| |
| def test_add_float(self): |
| self.assertEqual(self.tv + 5.5, psi.TimeSpec(10, 500000010)) |
| |
| def test_sub(self): |
| self.assertEqual(self.tv - psi.TimeSpec(1, 5), psi.TimeSpec(4, 5)) |
| |
| def test_sub_rollover(self): |
| self.assertEqual(self.tv - psi.TimeSpec(0, 15), |
| psi.TimeSpec(4, 999999995)) |
| |
| def test_sub_tuple(self): |
| self.assertEqual(self.tv - (1, 5), psi.TimeSpec(4, 5)) |
| |
| def test_sub_tuple_bad(self): |
| self.assertEqual(self.tv.__sub__((1, 5, 0)), NotImplemented) |
| |
| def test_sub_int(self): |
| self.assertEqual(self.tv - 1, psi.TimeSpec(4, 10)) |
| |
| def test_sub_float(self): |
| self.assertEqual(self.tv - 1.5, psi.TimeSpec(3, 500000010)) |
| |
| def test_bool(self): |
| self.assertEqual(bool(self.tv), True) |
| self.assertEqual(bool(psi.TimeSpec(0, 0)), False) |
| self.assertEqual(bool(psi.TimeSpec(-1, -1)), True) |
| |
| |
| class TimeSpecMethodsTests(unittest.TestCase): |
| def setUp(self): |
| self.tv = psi.TimeSpec(5, 500000000) |
| |
| def test_timestamp(self): |
| self.assertEqual(self.tv.timestamp(), 5.5) |
| |
| def test_float(self): |
| self.assertEqual(self.tv.float(), 5.5) |
| |
| def test_mktime(self): |
| if time.daylight: |
| t = 5.5 + time.timezone + time.altzone |
| else: |
| t = 5.5 + time.timezone |
| self.assertEqual(self.tv.mktime(), t) |
| |
| def test_timetuple(self): |
| self.assertEqual(self.tv.timetuple(), time.gmtime(5.5)) |
| |
| def test_gmtime(self): |
| self.assertEqual(self.tv.gmtime(), time.gmtime(5.5)) |
| |
| def test_localtime(self): |
| self.assertEqual(self.tv.localtime(), time.localtime(5.5)) |
| |
| def test_utcdatetime(self): |
| if HAVE_DATETIME: |
| self.assertEqual(self.tv.utcdatetime(), |
| datetime.datetime.utcfromtimestamp(5.5)) |
| else: |
| self.assert_(not hasattr(self.tv, 'utcdatetime')) |
| |
| def test_datetime(self): |
| if HAVE_DATETIME: |
| self.assertEqual(self.tv.datetime(), |
| datetime.datetime.fromtimestamp(5.5)) |
| else: |
| self.assert_(not hasattr(self.tv, 'datetime')) |
| |
| def test_timedelta(self): |
| if HAVE_DATETIME: |
| self.assertEqual(self.tv.timedelta(), |
| datetime.timedelta(seconds=5, microseconds=500000)) |
| else: |
| self.assert_(not hasattr(self.tv, 'timedelta')) |
| |
| |
| if __name__ == '__main__': |
| unittest.main() |
