Revision: 126
Author: roman_yakovenko
Date: 2006-05-17 12:07:20 -0700 (Wed, 17 May 2006)
ViewCVS: http://svn.sourceforge.net/pygccxml/?rev=126&view=rev
Log Message:
-----------
Added Paths:
-----------
pyplusplus_dev/examples/pyboost_dev/unittestst/
pyplusplus_dev/examples/pyboost_dev/unittestst/boost_random/
pyplusplus_dev/examples/pyboost_dev/unittestst/boost_random/test_all.py
pyplusplus_dev/examples/pyboost_dev/unittestst/crc/
pyplusplus_dev/examples/pyboost_dev/unittestst/crc/test_all.py
pyplusplus_dev/examples/pyboost_dev/unittestst/date_time/
pyplusplus_dev/examples/pyboost_dev/unittestst/date_time/examples.py
pyplusplus_dev/examples/pyboost_dev/unittestst/date_time/gregorian_tester.py
pyplusplus_dev/examples/pyboost_dev/unittestst/date_time/local_time_tester.py
pyplusplus_dev/examples/pyboost_dev/unittestst/date_time/posix_time_tester.py
pyplusplus_dev/examples/pyboost_dev/unittestst/date_time/test_all.py
pyplusplus_dev/examples/pyboost_dev/unittestst/rational/
pyplusplus_dev/examples/pyboost_dev/unittestst/rational/test_all.py
Added: pyplusplus_dev/examples/pyboost_dev/unittestst/boost_random/test_all.py
===================================================================
--- pyplusplus_dev/examples/pyboost_dev/unittestst/boost_random/test_all.py (rev 0)
+++ pyplusplus_dev/examples/pyboost_dev/unittestst/boost_random/test_all.py 2006-05-17 19:07:20 UTC (rev 126)
@@ -0,0 +1,77 @@
+#! /usr/bin/python
+# Copyright 2004 Roman Yakovenko.
+# Distributed under the Boost Software License, Version 1.0. (See
+# accompanying file LICENSE_1_0.txt or copy at
+# http://www.boost.org/LICENSE_1_0.txt)
+
+import sys
+sys.path.append( '../..' )
+
+import boost_random
+import unittest
+
+class tester_t( unittest.TestCase ):
+ def __init__( self, *args ):
+ unittest.TestCase.__init__( self, *args )
+
+ def randomness_tester( self, generator, count=1000 ):
+ generated = set()
+ for i in range( count ):
+ value = generator()
+ generated.add( value )
+ self.failUnless( len( generated ) >= count * 0.9 )
+
+ def generator_tester( self, gclass, *args ):
+ gen = gclass()
+ self.randomness_tester( gen )
+ print '\nname : ', gen.__class__.__name__
+ print ' max: ', gen.max()
+ print ' min: ', gen.min()
+ gen = gclass( *args )
+ self.randomness_tester( gen )
+ gen.seed()
+ self.randomness_tester( gen )
+
+ def test_generators(self):
+ for gclass in boost_random.generators:
+ self.generator_tester(gclass)
+
+ def instantiate_dist( self, urng, dist ):
+ if not boost_random.variate_generator_exists( urng, dist ):
+ return
+
+ gen1 = boost_random.variate_generator( urng, dist)
+ gen2 = boost_random.variate_generator( urng, dist)
+ self.randomness_tester( gen1 )
+ self.randomness_tester( gen2 )
+ self.failUnless( abs( gen1() - gen2() ) < 1e-6 )
+ gen1.engine()
+ gen1.distribution().reset()
+ gen2.engine()
+ gen2.distribution().reset()
+
+ def instantiate_real_dist( self, urng ):
+ self.instantiate_dist(urng, boost_random.uniform_real(0, 2.1) )
+ self.instantiate_dist(urng, boost_random.triangle_distribution(1, 1.5, 7) )
+ self.instantiate_dist(urng, boost_random.exponential_distribution(5) )
+ self.instantiate_dist(urng, boost_random.normal_distribution(0,1) )
+ #self.instantiate_dist(urng, boost_random.normal_distribution() )
+ self.instantiate_dist(urng, boost_random.lognormal_distribution(1, 1) )
+ self.instantiate_dist(urng, boost_random.cauchy_distribution(1, 1) )
+ self.instantiate_dist(urng, boost_random.gamma_distribution(1) )
+
+ def test_distributions( self ):
+ for gclass in boost_random.generators:
+ self.instantiate_real_dist( gclass() )
+
+
+def create_suite():
+ suite = unittest.TestSuite()
+ suite.addTest( unittest.makeSuite(tester_t) )
+ return suite
+
+def run_suite():
+ unittest.TextTestRunner(verbosity=2).run( create_suite() )
+
+if __name__ == "__main__":
+ run_suite()
Added: pyplusplus_dev/examples/pyboost_dev/unittestst/crc/test_all.py
===================================================================
--- pyplusplus_dev/examples/pyboost_dev/unittestst/crc/test_all.py (rev 0)
+++ pyplusplus_dev/examples/pyboost_dev/unittestst/crc/test_all.py 2006-05-17 19:07:20 UTC (rev 126)
@@ -0,0 +1,233 @@
+#! /usr/bin/python
+# Copyright 2004 Roman Yakovenko.
+# Distributed under the Boost Software License, Version 1.0. (See
+# accompanying file LICENSE_1_0.txt or copy at
+# http://www.boost.org/LICENSE_1_0.txt)
+
+import sys
+sys.path.append( '../..' )
+
+import crc
+import random
+import unittest
+
+class consts:
+ data = [ 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39 ]
+ crc_ccitt_result = 0x29B1
+ crc_16_result = 0xBB3D
+ crc_32_result = 0xCBF43926
+
+class tester_t( unittest.TestCase ):
+ def __init__( self, *args ):
+ unittest.TestCase.__init__( self, *args )
+
+ def fundamental_test( self, cls, data, expected ):
+ inst = cls()
+ inst.process_bytes( data )
+ #self.failUnless( inst.checksum() == expected )
+
+ def compute_test( self, fast_crc, slow_crc, expected ):
+ fast_crc.process_bytes( consts.data, len(consts.data) )
+ slow_crc.process_bytes( consts.data, len(consts.data) )
+
+ def test( self ):
+ self.fundamental_test( crc.crc_ccitt_type, consts.data, consts.crc_ccitt_result )
+ self.fundamental_test( crc.crc_16_type, consts.data, consts.crc_16_result )
+ self.fundamental_test( crc.crc_32_type, consts.data, consts.crc_32_result )
+
+ def test_crc_basic_1( self ):
+ crc1 = crc.crc_basic_1( 1 )
+ crc1.process_bytes( consts.data )
+ self.failUnless( crc1.checksum() == 1 )
+
+ def test_crc_basic_3( self ):
+ #The CRC standard is a SDH/SONET Low Order LCAS control word with CRC-3
+ #taken from ITU-T G.707 (12/03) XIII.2.
+
+ #Four samples, each four bytes should all have a CRC of zero
+ samples = \
+ [
+ [ 0x3A, 0xC4, 0x08, 0x06 ],
+ [ 0x42, 0xC5, 0x0A, 0x41 ],
+ [ 0x4A, 0xC5, 0x08, 0x22 ],
+ [ 0x52, 0xC4, 0x08, 0x05 ]
+ ]
+
+ # Basic computer
+ tester1 = crc.basic[3]( 0x03 ) #same as crc.crc_basic_3
+
+ tester1.process_bytes( samples[0] )
+ self.failUnless( tester1.checksum() == 0 )
+
+ tester1.reset()
+ tester1.process_bytes( samples[1] )
+ self.failUnless( tester1.checksum() == 0 )
+
+ tester1.reset()
+ tester1.process_bytes( samples[2] )
+ self.failUnless( tester1.checksum() == 0 )
+
+ tester1.reset()
+ tester1.process_bytes( samples[3] )
+ self.failUnless( tester1.checksum() == 0 )
+
+ # Optimal computer
+ #define PRIVATE_CRC_FUNC boost::crc<3, 0x03, 0, 0, false, false>
+ #define PRIVATE_ACRC_FUNC boost::augmented_crc<3, 0x03>
+
+ #self.failUnless( 0 == PRIVATE_CRC_FUNC(samples[0], 4) )
+ #self.failUnless( 0 == PRIVATE_CRC_FUNC(samples[1], 4) )
+ #self.failUnless( 0 == PRIVATE_CRC_FUNC(samples[2], 4) )
+ #self.failUnless( 0 == PRIVATE_CRC_FUNC(samples[3], 4) )
+
+ # maybe the fix to CRC functions needs to be applied to augmented CRCs?
+
+ #undef PRIVATE_ACRC_FUNC
+ #undef PRIVATE_CRC_FUNC
+
+ def test_crc_basic_7( self ):
+ #"Doing short-CRC (7-bit augmented) message tests."
+
+ # The CRC standard is a SDH/SONET J0/J1/J2/N1/N2/TR TTI (trace message)
+ # with CRC-7, o.a. ITU-T G.707 Annex B, G.832 Annex A.
+
+ # Two samples, each sixteen bytes
+ # Sample 1 is '\x80' + ASCII("123456789ABCDEF")
+ # Sample 2 is '\x80' + ASCII("TTI UNAVAILABLE")
+ samples = [ [ 0x80, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
+ 0x38, 0x39, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46 ]
+ , [ 0x80, 0x54, 0x54, 0x49, 0x20, 0x55, 0x4E, 0x41,
+ 0x56, 0x41, 0x49, 0x4C, 0x41, 0x42, 0x4C, 0x45 ] ]
+ results = [ 0x62, 0x23 ]
+
+ # Basic computer
+ tester1 = crc.crc_basic_7( 0x09 )
+
+ tester1.process_bytes( samples[0] )
+ self.failUnless( tester1.checksum() == results[0] )
+
+ tester1.reset()
+ tester1.process_bytes( samples[1] )
+ self.failUnless( tester1.checksum() == results[1] )
+
+ # Optimal computer
+ #define PRIVATE_CRC_FUNC boost::crc<7, 0x09, 0, 0, false, false>
+ #define PRIVATE_ACRC_FUNC boost::augmented_crc<7, 0x09>
+
+ #self.failUnless( results[0] == PRIVATE_CRC_FUNC(samples[0], 16) )
+ #self.failUnless( results[1] == PRIVATE_CRC_FUNC(samples[1], 16) )
+
+ # maybe the fix to CRC functions needs to be applied to augmented CRCs?
+
+ #undef PRIVATE_ACRC_FUNC
+ #undef PRIVATE_CRC_FUNC
+
+ def compute_test( self, optimal_cls, basic_cls, data, expected ):
+ fast_crc = optimal_cls()
+ slow_crc = basic_cls( fast_crc.truncated_polynominal
+ , fast_crc.initial_remainder
+ , fast_crc.final_xor_value
+ , fast_crc.reflect_input
+ , fast_crc.reflect_remainder )
+
+ fast_crc.process_bytes( data )
+ slow_crc.process_bytes( data )
+ self.failUnless( fast_crc.checksum() == expected )
+ self.failUnless( slow_crc.checksum() == expected )
+ #self.failUnless( func_result == expected );
+
+ def interrupt_test( self, optimal_cls, basic_cls, data, expected ):
+ fast_crc1 = optimal_cls()
+ slow_crc1 = basic_cls( fast_crc1.truncated_polynominal
+ , fast_crc1.initial_remainder
+ , fast_crc1.final_xor_value
+ , fast_crc1.reflect_input
+ , fast_crc1.reflect_remainder )
+ self.failUnless( fast_crc1.get_interim_remainder() == slow_crc1.get_initial_remainder() )
+ first_half = data[:len( data )/2]
+ second_half = data[len( data )/2:]
+
+ fast_crc1.process_bytes( first_half );
+ slow_crc1.process_bytes( first_half );
+ self.failUnless( fast_crc1.checksum() == slow_crc1.checksum() )
+
+ #Process the second half of the data (also test accessors)
+ fast_crc2 = optimal_cls( fast_crc1.get_interim_remainder() )
+ slow_crc2 = basic_cls( slow_crc1.get_truncated_polynominal()
+ , slow_crc1.get_interim_remainder()
+ , slow_crc1.get_final_xor_value()
+ , slow_crc1.get_reflect_input()
+ , slow_crc1.get_reflect_remainder() )
+
+ fast_crc2.process_block( second_half )
+ slow_crc2.process_block( second_half )
+
+ self.failUnless( fast_crc2.checksum() == slow_crc2.checksum() )
+ self.failUnless( fast_crc2.checksum() == expected )
+ self.failUnless( slow_crc2.checksum() == expected )
+
+ def error_test( self, optimal_cls, basic_cls ):
+ # Create a random block of data
+ ran_data = map( lambda unused: random.randint(0, 255), [0] * 256 )
+
+ # Create computers and compute the checksum of the data
+ fast_tester = optimal_cls()
+ slow_tester = basic_cls( fast_tester.truncated_polynominal
+ , fast_tester.initial_remainder
+ , fast_tester.final_xor_value
+ , fast_tester.reflect_input
+ , fast_tester.reflect_remainder )
+
+ fast_tester.process_bytes( ran_data )
+ slow_tester.process_bytes( ran_data )
+
+ fast_checksum = fast_tester.checksum()
+ slow_checksum = slow_tester.checksum()
+
+ self.failUnless( fast_checksum == slow_checksum )
+
+ # Do the checksum again (and test resetting ability)
+ fast_tester.reset();
+ slow_tester.reset( fast_tester.initial_remainder );
+ fast_tester.process_bytes( ran_data )
+ slow_tester.process_bytes( ran_data )
+ self.failUnless( fast_tester.checksum() == slow_tester.checksum() )
+ self.failUnless( fast_tester.checksum() == fast_checksum )
+ self.failUnless( slow_tester.checksum() == slow_checksum )
+
+ # Produce a single-bit error
+ ran_data[ ran_data[0] % 255 ] = ( ran_data[ ran_data[0] % 255 ] ^ ( 1 << (ran_data[1] % 32) ) ) % 255
+
+ # Compute the checksum of the errorenous data
+ # (and continue testing resetting ability)
+ fast_tester.reset( fast_tester.initial_remainder )
+ slow_tester.reset()
+ fast_tester.process_bytes( ran_data )
+ slow_tester.process_bytes( ran_data )
+ self.failUnless( fast_tester.checksum() == slow_tester.checksum() )
+ self.failUnless( fast_tester.checksum() != fast_checksum )
+ self.failUnless( slow_tester.checksum() != slow_checksum )
+
+ def test_crc_ccitt( self ):
+ self.compute_test( crc.crc_ccitt_type, crc.crc_basic_16, consts.data, consts.crc_ccitt_result )
+ self.interrupt_test( crc.crc_ccitt_type, crc.crc_basic_16, consts.data, consts.crc_ccitt_result )
+ self.error_test( crc.crc_ccitt_type, crc.crc_basic_16 )
+
+ def test_crc_16( self ):
+ self.compute_test( crc.crc_16_type, crc.crc_basic_16, consts.data, consts.crc_16_result)
+ self.interrupt_test( crc.crc_16_type, crc.crc_basic_16, consts.data, consts.crc_16_result)
+
+ def test_crc_32( self ):
+ self.compute_test( crc.crc_32_type, crc.crc_basic_32, consts.data, consts.crc_32_result)
+ self.interrupt_test( crc.crc_32_type, crc.crc_basic_32, consts.data, consts.crc_32_result)
+
+def create_suite():
+ suite = unittest.TestSuite()
+ suite.addTest( unittest.makeSuite(tester_t) )
+ return suite
+
+def run_suite():
+ unittest.TextTestRunner(verbosity=2).run( create_suite() )
+
+if __name__ == "__main__":
+ run_suite()
Added: pyplusplus_dev/examples/pyboost_dev/unittestst/date_time/examples.py
===================================================================
--- pyplusplus_dev/examples/pyboost_dev/unittestst/date_time/examples.py (rev 0)
+++ pyplusplus_dev/examples/pyboost_dev/unittestst/date_time/examples.py 2006-05-17 19:07:20 UTC (rev 126)
@@ -0,0 +1,33 @@
+#! /usr/bin/python
+# Copyright 2004 Roman Yakovenko.
+# Distributed under the Boost Software License, Version 1.0. (See
+# accompanying file LICENSE_1_0.txt or copy at
+# http://www.boost.org/LICENSE_1_0.txt)
+
+import unittest
+import date_time
+from date_time import gregorian
+from date_time import posix_time
+from date_time import local_time
+from date_time import to_iso_string
+
+class examples_t( unittest.TestCase ):
+ def __init__( self, *args ):
+ unittest.TestCase.__init__( self, *args )
+
+ def test_days_alive(self):
+ birthday = gregorian.date( 1900, date_time.Mar, 18 )
+ today = gregorian.day_clock.local_day()
+ alive = today - birthday
+ print str(alive)
+
+def create_suite():
+ suite = unittest.TestSuite()
+ suite.addTest( unittest.makeSuite(examples_t))
+ return suite
+
+def run_suite():
+ unittest.TextTestRunner(verbosity=2).run( create_suite() )
+
+if __name__ == "__main__":
+ run_suite()
Added: pyplusplus_dev/examples/pyboost_dev/unittestst/date_time/gregorian_tester.py
===================================================================
--- pyplusplus_dev/examples/pyboost_dev/unittestst/date_time/gregorian_tester.py (rev 0)
+++ pyplusplus_dev/examples/pyboost_dev/unittestst/date_time/gregorian_tester.py 2006-05-17 19:07:20 UTC (rev 126)
@@ -0,0 +1,556 @@
+#! /usr/bin/python
+# Copyright 2004 Roman Yakovenko.
+# Distributed under the Boost Software License, Version 1.0. (See
+# accompanying file LICENSE_1_0.txt or copy at
+# http://www.boost.org/LICENSE_1_0.txt)
+
+import date_time
+from date_time import gregorian
+from date_time import posix_time
+from date_time import to_iso_string
+from date_time import to_simple_string
+import unittest
+
+class tester_t( unittest.TestCase ):
+ def __init__( self, *args ):
+ unittest.TestCase.__init__( self, *args )
+
+ def test_current_day(self):
+ d1 = gregorian.day_clock.local_day()
+ print to_iso_string( d1 )
+
+ ymd = gregorian.day_clock.local_day_ymd()
+
+ print '%i-%s-%i' % ( ymd.year.as_number()
+ , ymd.month.as_long_string()
+ , ymd.day.as_number() )
+
+ d2 = gregorian.day_clock.universal_day()
+ print to_iso_string( d2 )
+
+ ymd2 = gregorian.day_clock.universal_day_ymd()
+ print '%i-%s-%i' % ( ymd2.year.as_number()
+ , ymd2.month.as_long_string()
+ , ymd2.day.as_number() )
+
+ def test_date(self):
+ self.failUnless( gregorian.date() == gregorian.date( date_time.not_a_date_time ) )
+ d1 = gregorian.date( 1900, 1, 1 )
+ d2 = gregorian.date( 2000, 1, 1 )
+ d3 = gregorian.date( 1900, 1, 1 )
+ d4 = gregorian.date( 2000, 12, 31 )
+ d4a = gregorian.date( 2000, date_time.Dec, 31 )
+ self.failUnless( d4 == d4a )
+ self.failUnless( d1.day().as_number() == 1 )
+ self.failUnless( d1.month().as_number() == 1 )
+ self.failUnless( d1.year().as_number() == 1900 )
+ self.failUnless( d4a.month().as_number() == 12 )
+ self.failUnless( d1 < d2 )
+ self.failUnless( not ( d1 < d1 ) )
+ self.failUnless( d1 <= d1 )
+ self.failUnless( d2 > d1 )
+ self.failUnless( not ( d1 > d1 ) )
+ self.failUnless( d1 >= d1 )
+ self.failUnless( d2 != d1 )
+ self.failUnless( d1 == d3 )
+ ymd = d1.year_month_day()
+ self.failUnless( ymd.year.as_number() == 1900 )
+ self.failUnless( ymd.month.as_number() == 1 )
+ self.failUnless( ymd.day.as_number() == 1 )
+
+ answers = [ gregorian.date( 1900, date_time.Jan, 1 )
+ , gregorian.date( 1900, date_time.Jan, 4 )
+ , gregorian.date( 1900, date_time.Jan, 7 )
+ , gregorian.date( 1900, date_time.Jan, 10 )
+ , gregorian.date( 1900, date_time.Jan, 13 )
+ ]
+ off = gregorian.date_duration( 3 )
+ d5 = gregorian.date( 1900, 1, 1 )
+ for i in range(5):
+ self.failUnless( d5 == answers[i] )
+ d5 = d5 + off
+
+ answers1 = [ gregorian.date(2000, 2 ,26)
+ , gregorian.date(2000, 2 ,28)
+ , gregorian.date(2000, date_time.Mar ,1 )]
+ d8 = gregorian.date(2000, date_time.Feb, 26)
+ for i in range(3):
+ self.failUnless( d8 == answers1[i] )
+ d8 += gregorian.days(2)
+
+ d6 = gregorian.date(2000,2,28)
+ d7 = gregorian.date(2000,3,1)
+ twoDays = gregorian.date_duration(2)
+ negtwoDays = gregorian.date_duration(-2)
+ zeroDays = gregorian.date_duration(0)
+ self.failUnless( twoDays == d7 - d6 )
+ self.failUnless( negtwoDays == d6 - d7 )
+ self.failUnless( zeroDays == d6 - d6 )
+ self.failUnless( d6 + twoDays == d7 )
+ self.failUnless( d7 - twoDays == d6 )
+ self.failUnless( gregorian.date(1999,1,1) + gregorian.date_duration(365)
+ == gregorian.date(2000,1,1) )
+ self.failUnless( gregorian.date(1999,1,1) + zeroDays == gregorian.date(1999,1,1) )
+
+ d = gregorian.date(2003, date_time.Oct, 31)
+ dd = gregorian.date_duration(55)
+ d += dd
+ self.failUnless( d == gregorian.date(2003, date_time.Dec,25) )
+ d -= dd;
+ self.failUnless( d == gregorian.date(2003, date_time.Oct,31) )
+
+ d = gregorian.date(2003,date_time.Oct, 31)
+ dd1 = gregorian.date_duration( date_time.pos_infin)
+ dd2 = gregorian.date_duration( date_time.neg_infin)
+ dd3 = gregorian.date_duration( date_time.not_a_date_time)
+
+ self.failUnless( d + dd1 == gregorian.date(date_time.pos_infin))
+ self.failUnless( d + dd2 == gregorian.date(date_time.neg_infin))
+ self.failUnless( d + dd3 == gregorian.date(date_time.not_a_date_time))
+ self.failUnless( d - dd1 == gregorian.date(date_time.neg_infin))
+ self.failUnless( d - dd2 == gregorian.date(date_time.pos_infin))
+ self.failUnless( d - dd3 == gregorian.date(date_time.not_a_date_time))
+ self.failUnless( gregorian.date(date_time.pos_infin) + dd1
+ == gregorian.date(date_time.pos_infin))
+ self.failUnless( gregorian.date(date_time.pos_infin) - dd1
+ == gregorian.date(date_time.not_a_date_time))
+ self.failUnless( gregorian.date(date_time.neg_infin) + dd1
+ == gregorian.date(date_time.not_a_date_time))
+ self.failUnless( gregorian.date(date_time.neg_infin) - dd1
+ == gregorian.date(date_time.neg_infin))
+
+ self.failUnlessRaises( Exception, lambda: gregorian.date( 2000, 1, 32 ) )
+ self.failUnlessRaises( Exception, lambda: gregorian.date( 2000, 1, 0 ) )
+ self.failUnlessRaises( Exception, lambda: gregorian.date( 2000, 2, 31 ) )
+
+ d15 = gregorian.date(1400,1,1)
+ self.failUnless( d15.julian_day() == 2232400)
+ self.failUnless( d15.modjulian_day() == -167601)
+
+ d16 = gregorian.date(2004,2,29)
+ self.failUnless( d16.julian_day() == 2453065)
+ self.failUnless( d16.modjulian_day() == 53064)
+
+ d31 = gregorian.date(2000, date_time.Jun, 1)
+ self.failUnless( d31.week_number() == 22)
+
+ d38 = gregorian.date(2001, 1, 1)
+ self.failUnless( d38.day_of_year().as_number() == 1)
+
+ def test_date_duration(self):
+ threeDays = gregorian.date_duration(3)
+ twoDays = gregorian.date_duration(2)
+ self.failUnless( threeDays == threeDays )
+ self.failUnless( threeDays == gregorian.date_duration(3) )
+ self.failUnless( threeDays != twoDays )
+ self.failUnless( twoDays < threeDays )
+ self.failUnless( not ( threeDays < twoDays ) )
+ self.failUnless( not ( threeDays < threeDays ) )
+ self.failUnless( not ( threeDays > threeDays ) )
+ self.failUnless( threeDays >= threeDays )
+ self.failUnless( not ( twoDays >= threeDays ) )
+ self.failUnless( twoDays + threeDays == gregorian.date_duration(5) )
+ fiveDays = gregorian.date_duration(3)
+ fiveDays += twoDays
+ self.failUnless( fiveDays == gregorian.date_duration(5) )
+ derivedOneDay = threeDays - twoDays
+ self.failUnless( twoDays - threeDays == gregorian.date_duration(-1) )
+ oneDay = gregorian.date_duration(1)
+ self.failUnless( oneDay == derivedOneDay )
+ fiveDaysDerived = gregorian.date_duration( 10 )
+ fiveDaysDerived -= fiveDays
+ self.failUnless( fiveDaysDerived == fiveDays)
+
+ oneDay = twoDays / 2
+ self.failUnless( oneDay.days() == 1 )
+ hundred = gregorian.date_duration(100)
+ hundred /= -10
+ self.failUnless( hundred.days() == -10 and hundred.is_negative())
+ self.failUnless( gregorian.date_duration( -gregorian.date_duration( 123 ).days() ).days() == -123 )
+ pos_dur = gregorian.date_duration(123)
+ neg_dur = -pos_dur
+ self.failUnless( neg_dur.days() == -123)
+
+ pi_dur = gregorian.date_duration(date_time.pos_infin)
+ ni_dur = gregorian.date_duration(date_time.neg_infin)
+ nd_dur = gregorian.date_duration(date_time.not_a_date_time)
+ self.failUnless( pi_dur + ni_dur == nd_dur)
+ self.failUnless( ni_dur / 3 == ni_dur)
+ self.failUnless( pi_dur + hundred == pi_dur)
+ self.failUnless( -pi_dur == ni_dur)
+
+
+ def test_generators(self):
+ pd1 =gregorian.partial_date(1, date_time.Jan)
+ d = pd1.get_date(2000)
+ self.failUnless( pd1.to_string() == "0" )
+ self.failUnless( gregorian.date(2000,1,1) == d)
+
+ pd2 = gregorian.partial_date(1, date_time.Feb)
+
+ self.failUnless( pd1 == pd1)
+ self.failUnless( not(pd1 == pd2) )
+ self.failUnless( not(pd2 == pd1) )
+ self.failUnless( not(pd1 < pd1) )
+ self.failUnless( pd1 < pd2)
+ self.failUnless( not(pd2 < pd1) )
+
+ lastkday = gregorian.last_day_of_the_week_in_month
+ lsif = lastkday( date_time.Sunday, date_time.Feb)
+ self.failUnless( gregorian.date(2002, date_time.Feb,24)
+ == lsif.get_date(2002))
+ self.failUnless( lsif.to_string() == "M2.5.0" )
+
+ firstkday = gregorian.first_day_of_the_week_in_month
+ fsif = firstkday(date_time.Sunday, date_time.Feb)
+ self.failUnless( gregorian.date(2002, date_time.Feb,3)
+ == fsif.get_date(2002))
+ self.failUnless( fsif.to_string() == "M2.1.0" )
+
+ firstkdayafter = gregorian.first_day_of_the_week_after
+ fkaf = firstkdayafter(date_time.Monday)
+ self.failUnless( gregorian.date(2002, date_time.Feb,4)
+ == fkaf.get_date( gregorian.date(2002,date_time.Feb,1)))
+ self.failUnless( '2002-Feb-04' == to_simple_string( fkaf.get_date( gregorian.date(2002,date_time.Feb,1))))
+
+ firstkdaybefore = gregorian.first_day_of_the_week_before
+ fkbf = firstkdaybefore(date_time.Monday)
+ self.failUnless( '2002-Feb-11' == to_simple_string(fkaf.get_date(gregorian.date(2002,date_time.Feb,10))))
+ self.failUnless( gregorian.date(2002,date_time.Feb,4)
+ == fkbf.get_date(gregorian.date(2002,date_time.Feb,10)))
+
+ nthkdayofmonth = gregorian.nth_day_of_the_week_in_month;
+ nkd1 = nthkdayofmonth(nthkdayofmonth.third, date_time.Sunday, date_time.Jul)
+
+ self.failUnless( gregorian.date(1969, date_time.Jul, 20) == nkd1.get_date(1969))
+ self.failUnless( nkd1.to_string() == "M7.3.0" )
+
+ saturday = gregorian.date(2003,date_time.Feb,8)
+ sund = gregorian.greg_weekday(date_time.Sunday)
+ self.failUnless( gregorian.days_until_weekday(saturday, sund) == gregorian.days(1))
+ self.failUnless( gregorian.days_before_weekday(saturday, sund) == gregorian.days(6))
+ self.failUnless( gregorian.next_weekday(saturday, sund)== gregorian.date(2003,date_time.Feb,9))
+ self.failUnless( gregorian.previous_weekday(saturday, sund)== gregorian.date(2003,date_time.Feb,2))
+
+ def test_greg_day(self):
+ self.failUnless( gregorian.greg_day(1).as_number() == 1 )
+ self.failUnlessRaises( Exception, lambda: gregorian.greg_day(0) )
+ self.failUnless( gregorian.greg_day.min() == 1 )
+ self.failUnless( gregorian.greg_day.max() == 31 )
+ sunday = gregorian.greg_weekday(0)
+ monday = gregorian.greg_weekday(1)
+ self.failUnless( sunday.as_short_string() == "Sun" )
+ self.failUnlessRaises( Exception, lambda: gregorian.greg_day_of_year_rep(367) )
+
+ def test_greg_year(self):
+ self.failUnless( gregorian.greg_year(1400).as_number() == 1400 )
+ self.failUnlessRaises( Exception, lambda: gregorian.greg_year(0) )
+ self.failUnless( gregorian.greg_year.min() == 1400 )
+ self.failUnless( gregorian.greg_year.max() == 10000 )
+
+ def test_greg_month(self):
+ m1 = gregorian.greg_month(date_time.Jan)
+ self.failUnless( m1.as_number() == 1)
+ self.failUnless( m1.as_short_string() == "Jan")
+ self.failUnless( m1.as_long_string() == "January")
+ sm1 = gregorian.greg_month(1)
+ self.failUnless( sm1.as_number() == 1)
+ self.failUnless( gregorian.greg_month.min() == 1 )
+ self.failUnless( gregorian.greg_month.max() == 12 )
+
+ def test_greg_cal(self):
+ self.failUnless( gregorian.calendar.day_of_week(gregorian.ymd_type(2000,9,24))==0 )
+ self.failUnless( gregorian.calendar.is_leap_year(1404) )
+ jday1 = gregorian.calendar.day_number( gregorian.ymd_type(2000,1,1))
+ jday2 = gregorian.calendar.day_number( gregorian.ymd_type(2001,1,1))
+ self.failUnless( jday1 == 2451545 )
+ self.failUnless( jday2 == 2451911 )
+ ymd = gregorian.calendar.from_day_number(jday1)
+ self.failUnless( ymd.year.as_number() == 2000
+ and ymd.month.as_number() == 1
+ and ymd.day.as_number() == 1 )
+ self.failUnless( gregorian.calendar.end_of_month_day(2000,1) == 31)
+
+ def test_greg_durations(self):
+ m1 = gregorian.months(5)
+ m2 = gregorian.months(3)
+ m3 = gregorian.months(1)
+ self.failUnless( gregorian.months(8) == m1 + m2)
+ m1 += m2
+ self.failUnless( gregorian.months(8) == m1)
+ self.failUnless( gregorian.months(-5) == m2 - m1)
+ m2 -= m1;
+ self.failUnless( gregorian.months(-5) == m2)
+
+ d1 = gregorian.date(2005, date_time.Jan, 1)
+
+ self.failUnless( d1 + gregorian.months(-1)
+ == gregorian.date(2004, date_time.Dec, 1) )
+ d3 = gregorian.date(2005, date_time.Dec, 1);
+ self.failUnless( d3 - gregorian.months(-1)
+ == gregorian.date(2006,date_time.Jan,1))
+ m1 = gregorian.months(5)
+ m2 = gregorian.months(3)
+ m3 = gregorian.months(10)
+ self.failUnless( gregorian.months(15) == m1 * 3)
+ m1 *= 3
+ self.failUnless( gregorian.months(15) == m1)
+ self.failUnless( gregorian.months(12) == m2 * 4)
+ self.failUnless( gregorian.months(3) == m3 / 3)
+ m3 /= 3
+ self.failUnless( gregorian.months(3) == m3)
+
+ m = gregorian.months(-5)
+ m_pos = gregorian.months(date_time.pos_infin)
+ m_neg = gregorian.months(date_time.neg_infin)
+ m_nadt = gregorian.months(date_time.not_a_date_time)
+ self.failUnless( m + m_pos == m_pos)
+ self.failUnless( m + m_neg == m_neg)
+ self.failUnless( m_pos + m_neg == m_nadt)
+ self.failUnless( m_neg + m_neg == m_neg)
+ self.failUnless( m - m_pos == m_neg)
+ self.failUnless( m - m_neg == m_pos)
+ self.failUnless( m_pos - m_neg == m_pos)
+ self.failUnless( m_pos * -1 == m_neg)
+ self.failUnless( m_pos * 0 == m_nadt)
+ self.failUnless( m_neg / 3 == m_neg)
+
+ y1 = gregorian.years(2)
+ y2 = gregorian.years(4)
+ self.failUnless( gregorian.months(27) == m3 + y1)
+ m3 += y1
+ self.failUnless( gregorian.months(27) == m3)
+ self.failUnless( gregorian.months(-21) == m3 - y2)
+ m3 -= y2
+ self.failUnless( gregorian.months(-21) == m3)
+
+ d = gregorian.date(2001, date_time.Oct, 31);
+ self.failUnless( gregorian.date(2002, date_time.Feb, 28)
+ == d + gregorian.months(4))
+ d += gregorian.months(4)
+ self.failUnless( gregorian.date(2002, date_time.Feb, 28) == d);
+ d = gregorian.date(2001, date_time.Oct, 31);
+ self.failUnless( gregorian.date(2001, date_time.Apr, 30)
+ == d - gregorian.months(6));
+ d -= gregorian.months(6);
+ self.failUnless( gregorian.date(2001, date_time.Apr, 30) == d);
+
+ y1 = gregorian.years(2)
+ y2 = gregorian.years(4)
+ y3 = gregorian.years(1)
+ self.failUnless( gregorian.years(3) == y3 + y1)
+ y3 += y1
+ self.failUnless( gregorian.years(3) == y3)
+ self.failUnless( gregorian.years(-1) == y3 - y2)
+ y3 -= y2
+ self.failUnless( gregorian.years(-1) == y3)
+
+ y1 = gregorian.years(5)
+ y2 = gregorian.years(3)
+ y3 = gregorian.years(10)
+
+ self.failUnless( gregorian.years(15) == y1 * 3)
+ y1 *= 3
+ self.failUnless( gregorian.years(15) == y1)
+
+ self.failUnless( gregorian.years(3) == y3 / 3)
+ y3 /= 3
+ self.failUnless( gregorian.years(3) == y3)
+
+ m = gregorian.years(15)
+ y_pos = gregorian.years(date_time.pos_infin)
+ y_neg = gregorian.years(date_time.neg_infin)
+ y_nadt = gregorian.years(date_time.not_a_date_time)
+ self.failUnless( m + y_pos == y_pos)
+ self.failUnless( m + y_neg == y_neg)
+ self.failUnless( y_pos + y_neg == y_nadt)
+ self.failUnless( y_neg + y_neg == y_neg)
+ self.failUnless( m - y_pos == y_neg)
+ self.failUnless( m - y_neg == y_pos)
+ self.failUnless( y_pos - y_neg == y_pos)
+ self.failUnless( y_pos * -1 == y_neg)
+ self.failUnless( y_pos * 0 == y_nadt)
+ self.failUnless( y_neg / 3 == y_neg)
+
+ m1 = gregorian.months(5)
+ m2 = gregorian.months(3)
+ self.failUnless( gregorian.months(39) == y2 + m2)
+ self.failUnless( gregorian.months(31) == y2 - m1)
+
+ d = gregorian.date(2001, date_time.Feb, 28)
+ self.failUnless( gregorian.date(2004, date_time.Feb, 29) == d + gregorian.years(3))
+ d += gregorian.years(3)
+ self.failUnless( gregorian.date(2004, date_time.Feb, 29) == d)
+
+ d = gregorian.date(2000, date_time.Feb, 29)
+ self.failUnless( gregorian.date(1994, date_time.Feb, 28) == d - gregorian.years(6))
+ d -= gregorian.years(6)
+ self.failUnless( gregorian.date(1994, date_time.Feb, 28) == d)
+
+ w1 = gregorian.weeks(2)
+ w2 = gregorian.weeks(4)
+ w3 = gregorian.weeks(1)
+ pi = gregorian.weeks(date_time.pos_infin)
+ self.failUnless( gregorian.weeks(date_time.pos_infin) == w1 + pi)
+ self.failUnless( gregorian.weeks(3) == w3 + w1)
+ w3 += w1
+ self.failUnless( gregorian.weeks(3) == w3)
+ self.failUnless( gregorian.weeks(-1) == w3 - w2)
+ w3 -= w2
+ self.failUnless( gregorian.weeks(-1) == w3)
+
+ d = gregorian.days(10)
+ self.failUnless( gregorian.days(31) == d + gregorian.weeks(3))
+ d += gregorian.weeks(3);
+ self.failUnless( gregorian.days(31) == d)
+
+ d = gregorian.days(10)
+ self.failUnless( gregorian.days(-32) == d - gregorian.weeks(6))
+ d -= gregorian.weeks(6)
+ self.failUnless( gregorian.days(-32) == d)
+
+ d = gregorian.date(2001, date_time.Feb, 28)
+ self.failUnless( gregorian.date(2001, date_time.Mar, 21) == d + gregorian.weeks(3))
+ d += gregorian.weeks(3)
+ self.failUnless( gregorian.date(2001, date_time.Mar, 21) == d)
+
+ d = gregorian.date(2001, date_time.Feb, 28);
+ self.failUnless( gregorian.date(2001, date_time.Jan, 17) == d - gregorian.weeks(6))
+ d -= gregorian.weeks(6)
+ self.failUnless( gregorian.date(2001, date_time.Jan, 17) == d)
+
+ d = gregorian.date(2000, date_time.Oct, 31)
+ d2 = d + gregorian.months(4) + gregorian.years(2)
+ d3 = d + gregorian.years(2) + gregorian.months(4)
+ self.failUnless( gregorian.date(2003, date_time.Feb,28) == d2)
+ self.failUnless( gregorian.date(2003,date_time.Feb,28) == d3)
+ m = gregorian.years(2) + gregorian.months(4) - gregorian.months(4) - gregorian.years(2)
+ self.failUnless( m.number_of_months() == 0)
+
+ def test_period(self):
+ d1 = gregorian.date(2000,date_time.Jan,1)
+ d2 = gregorian.date(2000,date_time.Jan,4)
+ p1 = gregorian.date_period(d1,d2)
+ p2 = gregorian.date_period(d1,gregorian.date_duration(3) )
+ self.failUnless( p1 == p2)
+ self.failUnless( p1.begin() == d1)
+ self.failUnless( p1.last() == d2-gregorian.date_duration(1) )
+ self.failUnless( p1.end() == d2)
+ self.failUnless( p2.length() == gregorian.date_duration(3) )
+ self.failUnless( p1.contains(d1) )
+ self.failUnless( not p1.contains(d2) )
+ p3 = gregorian.date_period( gregorian.date(2000,date_time.Jan,4)
+ , gregorian.date(2000,date_time.Feb,1) )
+ self.failUnless( not (p1 == p3) )
+ self.failUnless( p1 < p3)
+ self.failUnless( p3 > p1)
+ self.failUnless( p3 != p1)
+ self.failUnless( p1.intersects(p1) )
+ self.failUnless( not p1.intersects(p3) )
+ self.failUnless( not p3.intersects(p1) )
+ p4 = gregorian.date_period(gregorian.date(1999,date_time.Dec,1), d2)
+ self.failUnless( p1.intersects(p4) )
+ self.failUnless( p4.intersects(p1) )
+ p5 = gregorian.date_period(gregorian.date(1999,date_time.Dec,1)
+ , gregorian.date(2000,date_time.Dec,31) )
+ self.failUnless( p1.intersects(p5) )
+ self.failUnless( p5.intersects(p1) )
+ p6 = gregorian.date_period(gregorian.date(2000,date_time.Jan,1)
+ ,gregorian.date(2000,date_time.Dec,31) )
+ self.failUnless( p5.contains(p6) )
+ self.failUnless( p6.contains(p6) )
+ self.failUnless( not p6.contains(p5) )
+
+ fourDays = gregorian.date_duration(4)
+ p1.shift(fourDays)
+ shifted = gregorian.date_period(gregorian.date(2000,date_time.Jan,5)
+ , gregorian.date(2000,date_time.Jan,8) )
+ self.failUnless( p1 == shifted)
+
+ i1 = gregorian.date_period(gregorian.date(2000,date_time.Jan,5)
+ , gregorian.date(2000,date_time.Jan,10) )
+ i2 = gregorian.date_period(gregorian.date(2000,date_time.Jan,1)
+ , gregorian.date(2000,date_time.Jan,7) )
+ r1 = gregorian.date_period(gregorian.date(2000,date_time.Jan,5)
+ , gregorian.date(2000,date_time.Jan,7) )
+ self.failUnless( i1.intersection(i2) == r1)
+ self.failUnless( i2.intersection(i1) == r1)
+
+ i3 = gregorian.date_period(gregorian.date(2000,date_time.Jan,1)
+ , gregorian.date(2000,date_time.Jan,15) )
+ self.failUnless( i1.intersection(i3) == i1)
+ self.failUnless( i3.intersection(i1) == i1)
+
+ i4 = gregorian.date_period(gregorian.date(2000,date_time.Jan,7), gregorian.date(2000,date_time.Jan,10) )
+ i5 = gregorian.date_period(gregorian.date(2000,date_time.Jan,6)
+ , gregorian.date(2000,date_time.Jan,9) )
+ self.failUnless( i1.intersection(i5) == i5)
+ self.failUnless( i5.intersection(i1) == i5)
+ self.failUnless( i2.intersection(i4).is_null() )
+
+ r3 = gregorian.date_period(gregorian.date(2000,date_time.Jan,1), gregorian.date(2000,date_time.Jan,10) )
+
+ self.failUnless( i1.merge(i2) == r3)
+ self.failUnless( i2.merge(i4).is_null() )
+ r4 = gregorian.date_period(gregorian.date(2000,date_time.Jan,5), gregorian.date(2000,date_time.Jan,10) )
+ self.failUnless( i1.merge(i5) == r4)
+
+ self.failUnless( i1.span(i2) == r3)
+ self.failUnless( i2.span(i4) == r3)
+ self.failUnless( i4.span(i2) == r3)
+ self.failUnless( i3.span(i2) == i3)
+
+ i6 = gregorian.date_period(gregorian.date(2000,date_time.Jan,1), gregorian.date(2000,date_time.Jan,2) )
+ self.failUnless( i6.span(i4) == r3)
+ self.failUnless( i4.span(i6) == r3)
+
+ bf_start = gregorian.date(2000,date_time.Jan,5)
+ bf_end = gregorian.date(2000,date_time.Jan,10)
+ bf_before = gregorian.date(2000,date_time.Jan,4)
+ bf_after = gregorian.date(2000,date_time.Jan,11)
+ bf_during = gregorian.date(2000, date_time.Jan, 7)
+ bfp1 = gregorian.date_period(bf_start, bf_end)
+
+ self.failUnless( not bfp1.is_before(bf_start) )
+ self.failUnless( bfp1.is_before(bf_end) )
+ self.failUnless( not bfp1.is_before(bfp1.last() ))
+ self.failUnless( not bfp1.is_before(bf_before) )
+ self.failUnless( not bfp1.is_before(bf_during) )
+ self.failUnless( bfp1.is_before(bf_after) )
+
+ self.failUnless( not bfp1.is_after(bf_start) )
+ self.failUnless( not bfp1.is_after(bf_end) )
+ self.failUnless( not bfp1.is_after(bfp1.last() ))
+ self.failUnless( bfp1.is_after(bf_before) )
+ self.failUnless( not bfp1.is_after(bf_during) )
+ self.failUnless( not bfp1.is_after(bf_after) )
+
+ adj1 = gregorian.date_period( gregorian.date(2000,date_time.Jan,5)
+ , gregorian.date(2000,date_time.Jan,10) )
+ adj2 = gregorian.date_period (gregorian.date(2000,date_time.Jan,1), gregorian.date(2000,date_time.Jan,5) )
+ adj3 = gregorian.date_period(gregorian.date(2000,date_time.Jan,7), gregorian.date(2000,date_time.Jan,12) )
+ adj4 = gregorian.date_period(gregorian.date(2000,date_time.Jan,12), gregorian.date(2000,date_time.Jan,15) )
+ adj5 = gregorian.date_period(gregorian.date(2000,date_time.Jan,1), gregorian.date(2000,date_time.Jan,3) )
+ adj6 = gregorian.date_period(gregorian.date(2000,date_time.Jan,7), gregorian.date(2000,date_time.Jan,9) )
+
+ self.failUnless( adj1.is_adjacent(adj2) )
+ self.failUnless( adj2.is_adjacent(adj1) )
+ self.failUnless( not adj1.is_adjacent(adj3) )
+ self.failUnless( not adj3.is_adjacent(adj1) )
+ self.failUnless( not adj1.is_adjacent(adj4) )
+ self.failUnless( not adj4.is_adjacent(adj1) )
+ self.failUnless( not adj1.is_adjacent(adj5) )
+ self.failUnless( not adj5.is_adjacent(adj1) )
+ self.failUnless( not adj1.is_adjacent(adj6) )
+ self.failUnless( not adj6.is_adjacent(adj1) )
+
+def create_suite():
+ suite = unittest.TestSuite()
+ suite.addTest( unittest.makeSuite(tester_t))
+ return suite
+
+def run_suite():
+ unittest.TextTestRunner(verbosity=2).run( create_suite() )
+
+if __name__ == "__main__":
+ run_suite()
Added: pyplusplus_dev/examples/pyboost_dev/unittestst/date_time/local_time_tester.py
===================================================================
--- pyplusplus_dev/examples/pyboost_dev/unittestst/date_time/local_time_tester.py (rev 0)
+++ pyplusplus_dev/examples/pyboost_dev/unittestst/date_time/local_time_tester.py 2006-05-17 19:07:20 UTC (rev 126)
@@ -0,0 +1,605 @@
+#! /usr/bin/python
+# Copyright 2004 Roman Yakovenko.
+# Distributed under the Boost Software License, Version 1.0. (See
+# accompanying file LICENSE_1_0.txt or copy at
+# http://www.boost.org/LICENSE_1_0.txt)
+
+import os
+import date_time
+from date_time import gregorian
+from date_time import posix_time
+from date_time import local_time
+from date_time import to_iso_string
+from date_time import to_simple_string
+import unittest
+
+class tester_t( unittest.TestCase ):
+ def __init__( self, *args ):
+ unittest.TestCase.__init__( self, *args )
+
+ def test_clocks( self ):
+ az_tz = local_time.posix_time_zone("MST-07")
+ ny_tz = local_time.posix_time_zone("EST-05EDT,M4.1.0,M10.5.0")
+ print to_simple_string( posix_time.second_clock.local_time() )
+ print local_time.local_sec_clock.local_time(az_tz).to_string()
+ print local_time.local_sec_clock.local_time(ny_tz).to_string()
+
+ print to_simple_string( posix_time.microsec_clock.local_time() )
+ print local_time.local_microsec_clock.local_time(az_tz).to_string()
+ print local_time.local_microsec_clock.local_time(ny_tz).to_string()
+
+ def test_dst_transition_day_rule(self):
+ rule1 = local_time.partial_date_dst_rule(
+ gregorian.partial_date(30, date_time.Apr)
+ , gregorian.partial_date(30, date_time.Oct))
+ self.failUnless( rule1.start_day(2001) == gregorian.date(2001, date_time.Apr, 30))
+ self.failUnless( rule1.end_day(2001) == gregorian.date(2001, date_time.Oct, 30))
+
+ rule2 = local_time.first_last_dst_rule(
+ local_time.first_last_dst_rule.start_rule(date_time.Sunday, date_time.Apr)
+ , local_time.first_last_dst_rule.end_rule(date_time.Sunday, date_time.Oct))
+
+ self.failUnless( rule2.start_day(2001) == gregorian.date(2001, date_time.Apr, 1))
+ self.failUnless( rule2.end_day(2001) == gregorian.date(2001, date_time.Oct, 28))
+
+ rule3 = local_time.last_last_dst_rule(
+ local_time.last_last_dst_rule.start_rule(date_time.Sunday, date_time.Mar)
+ , local_time.last_last_dst_rule.end_rule(date_time.Sunday, date_time.Oct))
+
+ self.failUnless( rule3.start_day(2001) == gregorian.date(2001, date_time.Mar, 25))
+ self.failUnless( rule3.end_day(2001) == gregorian.date(2001, date_time.Oct, 28) )
+
+ nkday = gregorian.nth_kday_of_month
+ rule4 = local_time.nth_last_dst_rule(
+ local_time.nth_last_dst_rule.start_rule(nkday.first, date_time.Sunday, date_time.Mar)
+ , local_time.nth_last_dst_rule.end_rule(date_time.Sunday, date_time.Oct))
+
+ self.failUnless( rule4.start_day(2001) == gregorian.date(2001, date_time.Mar, 4))
+ self.failUnless( rule4.end_day(2001) == gregorian.date(2001, date_time.Oct, 28))
+
+ rule5 = local_time.nth_kday_dst_rule(
+ local_time.nth_kday_dst_rule.start_rule(nkday.first, date_time.Sunday, date_time.Mar)
+ , local_time.nth_kday_dst_rule.end_rule(nkday.fourth, date_time.Sunday, date_time.Oct))
+
+ self.failUnless( rule5.start_day(2001) == gregorian.date(2001, date_time.Mar, 4))
+ self.failUnless( rule5.end_day(2001) == gregorian.date(2001, date_time.Oct, 28))
+
+ def test_custom_time_zone( self ):
+ rule1 = local_time.partial_date_dst_rule(
+ gregorian.partial_date(30, date_time.Apr)
+ , gregorian.partial_date(30, date_time.Oct))
+
+ rule2 = local_time.first_last_dst_rule(
+ local_time.first_last_dst_rule.start_rule( date_time.Sunday, date_time.Apr)
+ , local_time.first_last_dst_rule.end_rule( date_time.Sunday, date_time.Oct))
+
+ rule3 = local_time.last_last_dst_rule(
+ local_time.last_last_dst_rule.start_rule(date_time.Sunday, date_time.Mar)
+ , local_time.last_last_dst_rule.end_rule(date_time.Sunday, date_time.Oct))
+
+ rule4 = None
+
+ pst = local_time.time_zone_names( "Pacific Standard Time"
+ , "PST"
+ , "Pacific Daylight Time"
+ , "PDT" )
+
+ mst = local_time.time_zone_names( "Mountain Standard Time"
+ , "MST"
+ , ""
+ , "" )
+
+ of = local_time.dst_adjustment_offsets( posix_time.hours(1)
+ , posix_time.hours(2)
+ , posix_time.hours(2))
+ of2 = local_time.dst_adjustment_offsets( posix_time.hours(0)
+ , posix_time.hours(0)
+ , posix_time.hours(0))
+
+ tz1 = local_time.custom_time_zone(pst, posix_time.hours(-8), of, rule1)
+ tz2 = local_time.custom_time_zone(pst, posix_time.hours(-8), of, rule2)
+ tz3 = local_time.custom_time_zone(pst, posix_time.hours(-8), of, rule3)
+ tz4 = local_time.custom_time_zone(mst, posix_time.hours(-7), of2, rule4)
+
+
+ self.failUnless( tz1.dst_zone_abbrev() == "PDT" )
+ self.failUnless( tz1.std_zone_abbrev() == "PST" )
+ self.failUnless( tz1.std_zone_name() == "Pacific Standard Time" )
+ self.failUnless( tz1.dst_zone_name() == "Pacific Daylight Time" )
+
+ self.failUnless( tz1.dst_offset() == posix_time.hours(1) )
+ self.failUnless( tz1.base_utc_offset() == posix_time.hours(-8) )
+ self.failUnless( tz1.has_dst() )
+
+ self.failUnless( tz1.dst_local_start_time(2003)
+ == posix_time.ptime( gregorian.date(2003, date_time.Apr,30)
+ , posix_time.hours(2) ) )
+
+ self.failUnless( tz1.dst_local_end_time(2003)
+ == posix_time.ptime( gregorian.date(2003, date_time.Oct,30)
+ , posix_time.hours(2) ) )
+
+
+ self.failUnless( tz1.to_posix_string() == "PST-08PDT+01,120/02:00,303/02:00")
+ self.failUnless( tz2.to_posix_string() == "PST-08PDT+01,M4.1.0/02:00,M10.5.0/02:00")
+ self.failUnless( tz3.to_posix_string() == "PST-08PDT+01,M3.5.0/02:00,M10.5.0/02:00")
+ self.failUnless( tz4.to_posix_string() == "MST-07")
+
+ self.failUnless( not tz4.has_dst() )
+
+ self.failUnless( tz4.dst_local_start_time(2005)
+ == posix_time.ptime( date_time.not_a_date_time ) )
+
+ self.failUnless( tz4.dst_local_end_time(2005)
+ == posix_time.ptime( date_time.not_a_date_time ) )
+
+ def test_local_time_period( self ):
+ d1 = gregorian.date(2001, date_time.Jan, 1)
+ az_tz = local_time.posix_time_zone("MST-07")
+
+ t1 = local_time.local_date_time( d1, posix_time.hours(2), az_tz, False)
+ t2 = local_time.local_date_time( d1, posix_time.hours(3), az_tz, False)
+ p1 = local_time.local_time_period( t1, t2 )
+ p2 = local_time.local_time_period( t1, t2 )
+ self.failUnless( p1 == p2 )
+
+ p4 = local_time.local_time_period( t1, posix_time.hours(1) )
+ self.failUnless( p4.length() == posix_time.hours(1) )
+ self.failUnless( p1 == p4 )
+ self.failUnless( p1.begin() == t1 )
+ self.failUnless( p1.end() == t2 )
+ self.failUnless( p1.last() == t2 - posix_time.time_duration.unit() )
+ self.failUnless( p1.contains( t1 ) )
+ self.failUnless( not p1.contains( t2 ) )
+ self.failUnless( p1.contains( t2 - posix_time.seconds(1) ) )
+
+ t3 = local_time.local_date_time( gregorian.date(2001, date_time.Jan,1)
+ , posix_time.hours(4)
+ , az_tz
+ , False )
+ p5 = local_time.local_time_period( t2, t3 )
+ self.failUnless( not p1.contains( p5.begin() ) )
+ self.failUnless( not p5.contains( p1.begin() ) )
+ self.failUnless( not( p1 == p5 ) )
+ self.failUnless( p1 < p5 )
+ self.failUnless( p5 > p1 )
+ self.failUnless( p5 != p1 )
+ self.failUnless( p1.intersects(p1) )
+ self.failUnless( not p1.intersects(p5) )
+ self.failUnless( not p5.intersects(p1) )
+
+ p6 = local_time.local_time_period( t2, t3 )
+ p6.shift( posix_time.minutes(30) )
+ self.failUnless( p5.intersects(p6) )
+ self.failUnless( p6.intersects(p5) )
+ self.failUnless( p5.contains( p6.begin() ) )
+ p6.shift( posix_time.minutes(30) )
+ self.failUnless( not p5.intersects(p6) )
+ self.failUnless( not p6.intersects(p5) )
+ p6.shift( posix_time.minutes(-30) )
+
+ p7 = p5.intersection(p6)
+
+ self.failUnless( p7 == local_time.local_time_period(
+ local_time.local_date_time( d1
+ , posix_time.time_duration(3,30,0)
+ , az_tz, False)
+ , local_time.local_date_time( d1
+ , posix_time.time_duration(4,0,0)
+ , az_tz
+ , False) ) )
+
+ def test_time_zone(self):
+ rule1 = local_time.partial_date_dst_rule(
+ gregorian.partial_date(30, date_time.Apr)
+ , gregorian.partial_date(30, date_time.Oct) )
+
+ rule2 = local_time.first_last_dst_rule(
+ local_time.first_last_dst_rule.start_rule( date_time.Sunday, date_time.Apr)
+ , local_time.first_last_dst_rule.end_rule( date_time.Sunday, date_time.Oct))
+
+ rule3 = local_time.last_last_dst_rule(
+ local_time.last_last_dst_rule.start_rule( date_time.Sunday, date_time.Mar)
+ , local_time.last_last_dst_rule.end_rule( date_time.Sunday, date_time.Oct))
+ rule4 = None
+
+ pst = local_time.time_zone_names( "Pacific Standard Time"
+ , "PST"
+ , "Pacific Daylight Time"
+ , "PDT")
+ mst = local_time.time_zone_names("Mountain Standard Time", "MST", "" , "")
+
+ of = local_time.dst_adjustment_offsets(
+ posix_time.hours(1)
+ , posix_time.hours(2)
+ , posix_time.hours(2) )
+
+ of2 = local_time.dst_adjustment_offsets(
+ posix_time.hours(0)
+ , posix_time.hours(0)
+ , posix_time.hours(0) )
+
+ tz1 = local_time.time_zone(pst, posix_time.hours(-8), of, rule1)
+ tz2 = local_time.time_zone(pst, posix_time.hours(-8), of, rule2)
+ tz3 = local_time.time_zone(pst, posix_time.hours(-8), of, rule3)
+ tz4 = local_time.time_zone(mst, posix_time.hours(-7), of2, rule4)
+
+ self.failUnless( tz1.dst_zone_abbrev() == "PDT")
+ self.failUnless( tz1.std_zone_abbrev() == "PST")
+ self.failUnless( tz1.std_zone_name() == "Pacific Standard Time")
+ self.failUnless( tz1.dst_zone_name() == "Pacific Daylight Time")
+
+ self.failUnless( tz1.dst_offset() == posix_time.hours(1) )
+ self.failUnless( tz1.base_utc_offset() == posix_time.hours(-8) )
+ self.failUnless( tz1.has_dst() )
+
+ self.failUnless( tz1.dst_local_start_time(2003)
+ == posix_time.ptime( gregorian.date(2003, date_time.Apr,30)
+ , posix_time.hours(2) ) )
+
+ self.failUnless( tz1.dst_local_end_time(2003)
+ == posix_time.ptime( gregorian.date(2003, date_time.Oct,30)
+ ,posix_time.hours(2) ) )
+
+ self.failUnless( tz1.to_posix_string() == "PST-08PDT+01,120/02:00,303/02:00" )
+ self.failUnless( tz2.to_posix_string() == "PST-08PDT+01,M4.1.0/02:00,M10.5.0/02:00")
+ self.failUnless( tz3.to_posix_string() == "PST-08PDT+01,M3.5.0/02:00,M10.5.0/02:00")
+ self.failUnless( tz4.to_posix_string() == "MST-07")
+
+ self.failUnless( not tz4.has_dst() )
+ self.failUnless( tz4.dst_local_start_time(2005)
+ == posix_time.ptime( date_time.not_a_date_time ) )
+ self.failUnless( tz4.dst_local_end_time(2005)
+ == posix_time.ptime( date_time.not_a_date_time ) )
+
+ def test_tz_database(self):
+ tz_db = local_time.time_zone_database()
+ tz_db.load_from_file( os.path.join( os.path.split( date_time.__file__ )[0]
+ , 'date_time_zonespec.csv' ) )
+
+
+ self.failUnless( not tz_db.time_zone_from_region("Invalid/name") )
+
+ nyc_test = tz_db.time_zone_from_region("America/New_York")
+ self.failUnless( nyc_test )
+ self.failUnless( nyc_test.std_zone_abbrev() == "EST" )
+ self.failUnless( nyc_test.std_zone_name() == "Eastern Standard Time" )
+ self.failUnless( nyc_test.dst_zone_abbrev() == "EDT" )
+ self.failUnless( nyc_test.dst_zone_name() == "Eastern Daylight Time" )
+ self.failUnless( nyc_test.base_utc_offset() == posix_time.hours(-5) )
+ self.failUnless( nyc_test.dst_offset() == posix_time.hours(1) )
+ self.failUnless( nyc_test.dst_local_start_time(2004)
+ == posix_time.ptime( gregorian.date(2004, date_time.Apr, 4)
+ , posix_time.hours(2) ) )
+ self.failUnless( nyc_test.dst_local_end_time(2004)
+ == posix_time.ptime( gregorian.date(2004, date_time.Oct, 31)
+ , posix_time.hours(2) ) )
+ self.failUnless( nyc_test.has_dst() )
+
+ phx_test = tz_db.time_zone_from_region("America/Phoenix")
+ self.failUnless( phx_test )
+ self.failUnless( phx_test.std_zone_abbrev() == "MST" )
+ self.failUnless( phx_test.std_zone_name() == "Mountain Standard Time" )
+ self.failUnless( phx_test.dst_zone_abbrev() == "" )
+ self.failUnless( phx_test.dst_zone_name() == "" )
+ self.failUnless( phx_test.base_utc_offset() == posix_time.hours(-7) )
+ self.failUnless( phx_test.dst_offset() == posix_time.hours(0) )
+ self.failUnless( phx_test.has_dst() == False)
+
+
+ eastern = local_time.posix_time_zone("EST-05:00:00EDT+01:00:00,M4.1.0/02:00:00,M10.5.0/02:00:00")
+ tz_db.add_record("United States/Eastern", eastern)
+ eastern_test = tz_db.time_zone_from_region("United States/Eastern" )
+ self.failUnless( eastern_test )
+ self.failUnless( eastern_test.std_zone_abbrev() == "EST" )
+ self.failUnless( eastern_test.std_zone_name() == "EST" )
+ self.failUnless( eastern_test.dst_zone_abbrev() == "EDT" )
+ self.failUnless( eastern_test.dst_zone_name() == "EDT" )
+ self.failUnless( eastern_test.base_utc_offset() == posix_time.hours(-5) )
+ self.failUnless( eastern_test.dst_local_start_time(2004)
+ == posix_time.ptime( gregorian.date(2004, date_time.Apr, 4)
+ , posix_time.hours(2) ) )
+ self.failUnless( eastern_test.dst_local_end_time(2004)
+ == posix_time.ptime( gregorian.date(2004, date_time.Oct, 31)
+ , posix_time.hours(2) ) )
+ self.failUnless( eastern_test.has_dst() )
+
+ def test_posix_time_zone(self):
+ specs = [ "MST-07"
+ , "MST-07:00:00"
+ , "EST-05EDT,M4.1.0,M10.5.0"
+ , "EST-05:00:00EDT+01:00:00,M4.1.0/02:00:00,M10.5.0/02:00:00"
+ , "PST-08PDT,J46/1:30,J310"
+ , "PST-08PDT,45,310/0:30:00" ]
+
+ nyc1 = local_time.posix_time_zone( specs[2] )
+ nyc2 = local_time.posix_time_zone( specs[3] )
+
+ td = posix_time.hours(-5)
+ self.failUnless( nyc1.has_dst() and nyc2.has_dst() )
+ self.failUnless( nyc1.base_utc_offset() == td )
+ self.failUnless( nyc1.base_utc_offset() == nyc2.base_utc_offset() )
+ self.failUnless( nyc1.std_zone_abbrev() == "EST" )
+ self.failUnless( nyc2.std_zone_abbrev() == "EST" )
+ self.failUnless( nyc1.dst_zone_abbrev() == "EDT" )
+ self.failUnless( nyc2.dst_zone_abbrev() == "EDT" )
+ self.failUnless( nyc1.std_zone_name() == "EST" )
+ self.failUnless( nyc2.std_zone_name() == "EST" )
+ self.failUnless( nyc1.dst_zone_name() == "EDT" )
+ self.failUnless( nyc2.dst_zone_name() == "EDT...
[truncated message content] |