|
From: <rom...@us...> - 2006-05-17 19:07:42
|
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] |
