Convert XML date, time & datetime classes (XDate, XTime & XDateTime) to use the sax.date.py module classes.

1 files changed, 485 insertions, 280 deletions

diff --git a/tests/builtin.py b/tests/builtin.py
index 2929477..ce96f92 100644
--- a/tests/builtin.py
+++ b/tests/builtin.py
@@ -14,299 +14,504 @@
 # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 # written by: Jeff Ortel ( jortel@redhat.com )
 
-def assertEquals(one, two):
-    if one != two:
-        raise Exception('Assertion Exception!  %s does not equal %s' % (one, two))
 
+from suds.sax.date import Timezone as Tz
 from suds.xsd.sxbuiltin import *
-import unittest
-import time
-    
-class DateTest(unittest.TestCase):
-    def setUp(self):
-        self.tz = time.timezone/60/60
-        
-    def getTestersTimezoneString(self):
-
-        offset = str(self.tz)
-        if int(offset) >= 0:
-            if len(offset) == 2:
-                offset = "+%s:00" % offset
-            else:
-                offset = "+0%s:00" % offset
-        else:
-            if len(offset) == 2:
-                offset = "-%s:00" % offset
-            else:
-                offset = "-0%s:00" % offset
-                
-        return offset
-                
-    def getDay(self, day, hour, current_tz):
-        if (current_tz - self.tz + hour) > 24:
-            return day + 1
-        elif (current_tz - self.tz + hour) < 0:
-            return day - 1
-        else:
-            return day
-            
-    def getHour(self, hour, current_tz):
-        new_hour = (current_tz - self.tz + hour)
-        if new_hour > 23:
-            return new_hour - 24
-        elif new_hour < 0:
-            return 24 - (new_hour*-1)
-        else:
-            return new_hour
-            
-    def getHourString(self, hour, current_tz):
-        hour = self.getHour(hour, current_tz)
-        
-        if len(str(hour)) > 1:
-            return "%s" % hour
-        else:
-            return "0%s" % hour
-            
-class TestXDate(DateTest):
-    """
-    examples
-    2002-09-24
-    2002-09-24Z
-    2002-09-24-06:00
-    2002-09-24+06:00
-    """
-    #fake it out a bit so I can just test what matters
-    def fake_init(self):
-        pass
-    XDate.__init__ = fake_init
-    
-    def test_should_return_correct_date_object_given_simple_date(self):
-        date = XDate().translate("2006-10-10")
-        self.assertEqual(date.day, 10)
-        self.assertEqual(date.month, 10)
-        self.assertEqual(date.year, 2006)
-        self.assertEqual(date.minute, 0)
-        self.assertEqual(date.second, 0)
-        self.assertEqual(date.hour, 0)
-        
-    def test_should_return_correct_string_from_date_object_given_simple_date(self):
-        date = XDate().translate(XDate().translate("2006-10-10"), False)
-        
-        self.assertEquals("2006-10-10", date)
-        
-    def test_should_return_correct_date_object_given_date_with_timezone(self):
-        date = XDate().translate("1945-08-20+06:00")
-        self.assertEqual(date.day, self.getDay(20, 0, 6))
-        self.assertEqual(date.month, 8)
-        self.assertEqual(date.year, 1945)
-        self.assertEqual(date.minute, 0)
-        self.assertEqual(date.second, 0)
-        self.assertEqual(date.hour, self.getHour(0, 6))
-        
-    def test_should_return_correct_string_from_date_object_given_date_with_timezone(self):
-        date = XDate().translate(XDate().translate("1945-08-20+06:00"), False)
-        
-        self.assertEquals("1945-08-%s%s" % (str(self.getDay(20, 0, 6)), self.getTestersTimezoneString()), date)
-
-    def test_should_return_correct_date_object_given_date_with_different_timezone(self):
-        date = XDate().translate("1945-08-20+03:00")
-        self.assertEqual(date.day, self.getDay(20, 0, 3))
-        self.assertEqual(date.month, 8)
-        self.assertEqual(date.year, 1945)
-        self.assertEqual(date.minute, 0)
-        self.assertEqual(date.second, 0)
-        self.assertEqual(date.hour, self.getHour(0, 3))
-
-    def test_should_return_correct_string_from_date_object_given_date_with_timezone(self):
-        date = XDate().translate(XDate().translate("1945-08-20+03:00"), False)
-
-        self.assertEquals("1945-08-%s%s" % (str(self.getDay(20, 0, 3)), self.getTestersTimezoneString()), date)
+from unittest import TestCase
 
-    def test_should_return_correct_date_object_given_date_with_different_utc(self):
-        #from where I am, this is 6 hours off and would become a different day
-        date = XDate().translate("1945-08-20Z")
-        self.assertEqual(date.day, self.getDay(20, 0, 0))
-        self.assertEqual(date.month, 8)
-        self.assertEqual(date.year, 1945)
-        self.assertEqual(date.minute, 0)
-        self.assertEqual(date.second, 0)
-        self.assertEqual(date.hour, self.getHour(0, 0))
 
-    def test_should_return_correct_string_from_date_object_given_date_with_utc(self):
-        date = XDate().translate(XDate().translate("1945-08-20Z"), False)
-
-        self.assertEquals("1945-08-%s%s" % (str(self.getDay(20, 0, 0)), self.getTestersTimezoneString()), date)
-        
-    def test_null_does_not_throw_exception(self):
-        self.assertEquals("", XDate().translate(None, False))
-      
-class TestXTime(DateTest):
-    """
-    09:00:00
-    09:30:10.5
-    09:30:10Z
-    09:30:10-06:00
-    09:30:10+06:00
-    """
-    #fake it out a bit so I can just test what matters
-    def fake_init(self):
+class Date(XDate):
+    def __init__(self):
         pass
-    XTime.__init__ = fake_init
-
-    def test_should_return_correct_time_object_given_simple_time(self):
-        date = XTime().translate("09:00:00")
-        self.assertEqual(date.minute, 0)
-        self.assertEqual(date.second, 0)
-        self.assertEqual(date.hour, 9)
-
-    def test_should_return_correct_string_from_time_object_given_simple_time(self):
-        date = XTime().translate(XTime().translate("09:00:00"), False)
-
-        self.assertEquals("09:00:00", date)
-        
-    def test_should_return_correct_time_object_given_time_with_microseconds(self):
-        time = XTime().translate("09:30:10.5")
-        self.assertEqual(time.minute, 30)
-        self.assertEqual(time.second, 10)
-        self.assertEqual(time.hour, 9)
-        self.assertEqual(time.microsecond, 500000)
-
-    def test_should_return_correct_string_from_time_object_given_time_with_microseconds(self):
-        date = XTime().translate(XTime().translate("09:30:10.5"), False)
-
-        self.assertEquals("09:30:10.5", date)
-
-    def test_should_return_correct_time_object_given_time_with_utc(self):
-        time = XTime().translate("09:30:10Z")
-        self.assertEqual(time.minute, 30)
-        self.assertEqual(time.second, 10)
-        self.assertEqual(time.hour, self.getHour(9, 0))
-        self.assertEqual(time.microsecond, 0)
-
-    def test_should_return_correct_string_from_time_object_given_time_with_utc(self):
-        date = XTime().translate(XTime().translate("09:30:10Z"), False)
-
-        self.assertEquals("%s:30:10%s" % (self.getHourString(9, 0), self.getTestersTimezoneString()), date)
-                
-    def test_should_return_correct_time_object_given_complex_time(self):
-        time = XTime().translate("09:30:10.525+09:00")
-        self.assertEqual(time.minute, 30)
-        self.assertEqual(time.second, 10)
-        self.assertEqual(time.hour, self.getHour(9, 9))
-        self.assertEqual(time.microsecond, 525000)
-
-    def test_should_return_correct_string_from_time_object_given_complex_time(self):
-        date = XTime().translate(XTime().translate("09:30:10.525+09:00"), False)
-
-        self.assertEquals("%s:30:10.525%s" % (self.getHourString(9, 9), self.getTestersTimezoneString()), date)
-        
-    def test_should_wrap_time_correctly(self):
-        time = XTime().translate("23:30:10.525+09:00")
-        self.assertEqual(time.minute, 30)
-        self.assertEqual(time.second, 10)
-        self.assertEqual(time.hour, self.getHour(23, 9))
-        self.assertEqual(time.microsecond, 525000)
-        
-        time = XTime().translate("00:30:10.525-03:00")
-        self.assertEqual(time.minute, 30)
-        self.assertEqual(time.second, 10)
-        self.assertEqual(time.hour, self.getHour(0, -3))
-        self.assertEqual(time.microsecond, 525000)
-        
-        time = XTime().translate("05:30:10.525+03:00")
-        self.assertEqual(time.minute, 30)
-        self.assertEqual(time.second, 10)
-        self.assertEqual(time.hour, self.getHour(5, 3))
-        self.assertEqual(time.microsecond, 525000)
-        
-        time = XTime().translate("05:30:10.525-03:00")
-        self.assertEqual(time.minute, 30)
-        self.assertEqual(time.second, 10)
-        self.assertEqual(time.hour, self.getHour(5, -3))
-        self.assertEqual(time.microsecond, 525000)
-
-    def test_null_does_not_throw_exception(self):
-        self.assertEquals("", XTime().translate(None, False))
-        
-class TestXDateTime(DateTest):
-    """
-    2002-05-30T09:00:00
-    2002-05-30T09:30:10.5
-    """
-    #fake it out a bit so I can just test what matters
-    def fake_init(self):
+class Time(XTime):
+    def __init__(self):
         pass
-    XDateTime.__init__ = fake_init
-
-    def test_should_return_correct_time_object_given_simple_time(self):
-        date = XDateTime().translate("2002-05-30T09:00:00")
-        self.assertEqual(date.minute, 0)
-        self.assertEqual(date.second, 0)
-        self.assertEqual(date.microsecond, 0)
-        self.assertEqual(date.hour, 9)
-        self.assertEqual(date.day, 30)
-        self.assertEqual(date.year, 2002)
-        self.assertEqual(date.month, 5)
+class DateTime(XDateTime):
+    def __init__(self):
+        pass
+    
+class DateTest(TestCase):
+    
+    def testSimple(self):
+        ref = dt.date(1941, 12, 7)
+        s = '%.4d-%.2d-%.2d' % (ref.year, ref.month, ref.day)
+        xdate = Date()
+        d = xdate.translate(s)
+        self.assertEqual(d, ref)
+        
+    def testNegativeTimezone(self):
+        self.equalsTimezone(-6)
+        
+    def testPositiveTimezone(self):
+        self.equalsTimezone(6)
+        
+    def testUtcTimezone(self):
+        Timezone.local = 0
+        ref = dt.date(1941, 12, 7)
+        s = '%.4d-%.2d-%.2dZ' % (ref.year, ref.month, ref.day)
+        xdate = Date()
+        d = xdate.translate(s)
+        self.assertEqual(d, ref)
+        
+    def equalsTimezone(self, tz):
+        Timezone.local = tz
+        ref = dt.date(1941, 12, 7)
+        s = '%.4d-%.2d-%.2d%+.2d:00' % (ref.year, ref.month, ref.day, tz)
+        xdate = Date()
+        d = xdate.translate(s)
+        self.assertEqual(d, ref)
 
-    def test_should_return_correct_string_from_time_object_given_simple_time(self):
-        date = XDateTime().translate(XDateTime().translate("2002-05-30T09:00:00"), False)
 
-        self.assertEquals("2002-05-30T09:00:00", date)
-        
-    def test_should_return_correct_time_object_given_simple_time(self):
-        date = XDateTime().translate("2002-05-30T09:30:10.5")
-        self.assertEqual(date.minute, 30)
-        self.assertEqual(date.second, 10)
-        self.assertEqual(date.microsecond, 500000)
-        self.assertEqual(date.hour, 9)
-        self.assertEqual(date.day, 30)
-        self.assertEqual(date.year, 2002)
-        self.assertEqual(date.month, 5)
+  
+class TimeTest(TestCase):
 
-    def test_should_return_correct_string_from_time_object_given_simple_time(self):
-        date = XDateTime().translate(XDateTime().translate("2002-05-30T09:30:10.5"), False)
+    def testSimple(self):
+        ref = dt.time(10, 30, 22)
+        s = '%.2d:%.2d:%.2d' % (ref.hour, ref.minute, ref.second)
+        xtime = Time()
+        t = xtime.translate(s)
+        self.assertEqual(t, ref)
+        
+    def testSimpleWithMicrosecond(self):
+        ref = dt.time(10, 30, 22, 454)
+        s = '%.2d:%.2d:%.2d.%4.d' % (ref.hour, ref.minute, ref.second, ref.microsecond)
+        xtime = Time()
+        t = xtime.translate(s)
+        self.assertEqual(t, ref)
+        
+    def testPositiveTimezone(self):
+        self.equalsTimezone(6)
+        
+    def testNegativeTimezone(self):
+        self.equalsTimezone(-6)
+        
+    def testUtcTimezone(self):
+        Timezone.local = 0
+        ref = dt.time(10, 30, 22)
+        s = '%.2d:%.2d:%.2dZ' % (ref.hour, ref.minute, ref.second)
+        xtime = Time()
+        t = xtime.translate(s)
+        self.assertEqual(t, ref)
+        
+    def equalsTimezone(self, tz):
+        Timezone.local = tz
+        ref = dt.time(10, 30, 22)
+        s = self.strTime(ref.hour, ref.minute, ref.second, tz)
+        xtime = Time()
+        t = xtime.translate(s)
+        self.assertEqual(t, ref)
+        
+    def testConvertNegativeToGreaterNegative(self):
+        Timezone.local = -6
+        ref = dt.time(10, 30, 22)
+        s = self.strTime(ref.hour, ref.minute, ref.second, -5)
+        xtime = Time()
+        t = xtime.translate(s)
+        self.assertEqual(ref.hour-1, t.hour)
+        self.assertEqual(ref.minute, t.minute)
+        self.assertEqual(ref.second, t.second)
+        
+    def testConvertNegativeToLesserNegative(self):
+        Timezone.local = -5
+        ref = dt.time(10, 30, 22)
+        s = self.strTime(ref.hour, ref.minute, ref.second, -6)
+        xtime = Time()
+        t = xtime.translate(s)
+        self.assertEqual(ref.hour+1, t.hour)
+        self.assertEqual(ref.minute, t.minute)
+        self.assertEqual(ref.second, t.second)
+        
+    def testConvertPositiveToGreaterPositive(self):
+        Timezone.local = 3
+        ref = dt.time(10, 30, 22)
+        s = self.strTime(ref.hour, ref.minute, ref.second, 2)
+        xtime = Time()
+        t = xtime.translate(s)
+        self.assertEqual(ref.hour+1, t.hour)
+        self.assertEqual(ref.minute, t.minute)
+        self.assertEqual(ref.second, t.second)
+        
+    def testConvertPositiveToLesserPositive(self):
+        Timezone.local = 2
+        ref = dt.time(10, 30, 22)
+        s = self.strTime(ref.hour, ref.minute, ref.second, 3)
+        xtime = Time()
+        t = xtime.translate(s)
+        self.assertEqual(ref.hour-1, t.hour)
+        self.assertEqual(ref.minute, t.minute)
+        self.assertEqual(ref.second, t.second)
+        
+    def testConvertPositiveToNegative(self):
+        Timezone.local = -6
+        ref = dt.time(10, 30, 22)
+        s = self.strTime(ref.hour, ref.minute, ref.second, 3)
+        xtime = Time()
+        t = xtime.translate(s)
+        self.assertEqual(ref.hour-9, t.hour)
+        self.assertEqual(ref.minute, t.minute)
+        self.assertEqual(ref.second, t.second)
+        
+    def testConvertNegativeToPositive(self):
+        Timezone.local = 3
+        ref = dt.time(10, 30, 22)
+        s = self.strTime(ref.hour, ref.minute, ref.second, -6)
+        xtime = Time()
+        t = xtime.translate(s)
+        self.assertEqual(ref.hour+9, t.hour)
+        self.assertEqual(ref.minute, t.minute)
+        self.assertEqual(ref.second, t.second)
+        
+    def testConvertNegativeToUtc(self):
+        Timezone.local = 0
+        ref = dt.time(10, 30, 22)
+        s = self.strTime(ref.hour, ref.minute, ref.second, -6)
+        xtime = Time()
+        t = xtime.translate(s)
+        self.assertEqual(ref.hour+6, t.hour)
+        self.assertEqual(ref.minute, t.minute)
+        self.assertEqual(ref.second, t.second)
+        
+    def testConvertPositiveToUtc(self):
+        Timezone.local = 0
+        ref = dt.time(10, 30, 22)
+        s = self.strTime(ref.hour, ref.minute, ref.second, 3)
+        xtime = Time()
+        t = xtime.translate(s)
+        self.assertEqual(ref.hour-3, t.hour)
+        self.assertEqual(ref.minute, t.minute)
+        self.assertEqual(ref.second, t.second)
+        
+    def testConvertUtcToPositive(self):
+        Timezone.local = 3
+        ref = dt.time(10, 30, 22)
+        s = '%.2d:%.2d:%.2dZ' % (ref.hour, ref.minute, ref.second)
+        xtime = Time()
+        t = xtime.translate(s)
+        self.assertEqual(ref.hour+3, t.hour)
+        self.assertEqual(ref.minute, t.minute)
+        self.assertEqual(ref.second, t.second)
+        
+    def testConvertUtcToNegative(self):
+        Timezone.local = -6
+        ref = dt.time(10, 30, 22)
+        s = '%.2d:%.2d:%.2dZ' % (ref.hour, ref.minute, ref.second)
+        xtime = Time()
+        t = xtime.translate(s)
+        self.assertEqual(ref.hour-6, t.hour)
+        self.assertEqual(ref.minute, t.minute)
+        self.assertEqual(ref.second, t.second)
+        
+    def strTime(self, h, m, s, offset):
+        return '%.2d:%.2d:%.2d%+.2d:00' % (h, m, s, offset)
 
-        self.assertEquals("2002-05-30T09:30:10.5", date)
-        
-    def test_should_wrap_time_correctly(self):
-        date = XDateTime().translate("2002-05-30T23:30:10.525+09:00")
-        self.assertEqual(date.minute, 30)
-        self.assertEqual(date.second, 10)
-        self.assertEqual(date.hour, self.getHour(23, 9))
-        self.assertEqual(date.microsecond, 525000)
-        self.assertEqual(date.day, self.getDay(30, 23, 9))
-        self.assertEqual(date.year, 2002)
-        self.assertEqual(date.month, 5)
 
-        date = XDateTime().translate("2002-05-30T00:30:10.525-03:00")
-        self.assertEqual(date.minute, 30)
-        self.assertEqual(date.second, 10)
-        self.assertEqual(date.hour, self.getHour(0, -3))
-        self.assertEqual(date.microsecond, 525000)
-        self.assertEqual(date.day, self.getDay(30, 0, -3))
-        self.assertEqual(date.year, 2002)
-        self.assertEqual(date.month, 5)
+class DateTimeTest(TestCase):
 
-        date = XDateTime().translate("2002-05-30T05:30:10.525+03:00")
-        self.assertEqual(date.minute, 30)
-        self.assertEqual(date.second, 10)
-        self.assertEqual(date.hour, self.getHour(5, 3))
-        self.assertEqual(date.microsecond, 525000)
-        self.assertEqual(date.day, self.getDay(30, 5, 3))
-        self.assertEqual(date.year, 2002)
-        self.assertEqual(date.month, 5)
+    def testSimple(self):
+        ref = dt.datetime(1941, 12, 7, 10, 30, 22)
+        s = '%.4d-%.2d-%.2dT%.2d:%.2d:%.2d' \
+            % (ref.year,
+               ref.month, 
+               ref.day, 
+               ref.hour, 
+               ref.minute, 
+               ref.second)
+        xdt = DateTime()
+        t = xdt.translate(s)
+        self.assertEqual(t, ref)
+        
+    def testSimpleWithMicrosecond(self):
+        ref = dt.datetime(1941, 12, 7, 10, 30, 22, 454)
+        s = '%.4d-%.2d-%.2dT%.2d:%.2d:%.2d.%.4d' \
+            % (ref.year, 
+               ref.month, 
+               ref.day, 
+               ref.hour, 
+               ref.minute, 
+               ref.second, 
+               ref.microsecond)
+        xdt = DateTime()
+        t = xdt.translate(s)
+        self.assertEqual(t, ref)
+        
+    def testPositiveTimezone(self):
+        self.equalsTimezone(6)
+        
+    def testNegativeTimezone(self):
+        self.equalsTimezone(-6)
+        
+    def testUtcTimezone(self):
+        Timezone.local = 0
+        ref = dt.datetime(1941, 12, 7, 10, 30, 22)
+        s = '%.4d-%.2d-%.2dT%.2d:%.2d:%.2d' \
+            % (ref.year,
+               ref.month, 
+               ref.day, 
+               ref.hour, 
+               ref.minute, 
+               ref.second)
+        xdt = DateTime()
+        t = xdt.translate(s)
+        self.assertEqual(t, ref)
+        
+    def equalsTimezone(self, tz):
+        Timezone.local = tz
+        ref = dt.datetime(1941, 12, 7, 10, 30, 22)
+        s = self.strDateTime(
+                ref.year,
+                ref.month,
+                ref.day,
+                ref.hour,
+                ref.minute,
+                ref.second,
+                tz)
+        xdt = DateTime()
+        t = xdt.translate(s)
+        self.assertEqual(t, ref)
+        
+    def testConvertNegativeToGreaterNegative(self):
+        Timezone.local = -6
+        ref = dt.datetime(1941, 12, 7, 10, 30, 22)
+        s = self.strDateTime(
+                ref.year,
+                ref.month,
+                ref.day,
+                ref.hour,
+                ref.minute,
+                ref.second,
+                -5)
+        xdt = DateTime()
+        t = xdt.translate(s)
+        self.assertEqual(ref.year, t.year)
+        self.assertEqual(ref.month, t.month)
+        self.assertEqual(ref.day, t.day)
+        self.assertEqual(ref.hour-1, t.hour)
+        self.assertEqual(ref.minute, t.minute)
+        self.assertEqual(ref.second, t.second)
+        
+    def testConvertNegativeToLesserNegative(self):
+        Timezone.local = -5
+        ref = dt.datetime(1941, 12, 7, 10, 30, 22)
+        s = self.strDateTime(
+                ref.year,
+                ref.month,
+                ref.day,
+                ref.hour,
+                ref.minute,
+                ref.second,
+                -6)
+        xdt = DateTime()
+        t = xdt.translate(s)
+        self.assertEqual(ref.year, t.year)
+        self.assertEqual(ref.month, t.month)
+        self.assertEqual(ref.day, t.day)
+        self.assertEqual(ref.hour+1, t.hour)
+        self.assertEqual(ref.minute, t.minute)
+        self.assertEqual(ref.second, t.second)
+        
+    def testConvertPositiveToGreaterPositive(self):
+        Timezone.local = 3
+        ref = dt.datetime(1941, 12, 7, 10, 30, 22)
+        s = self.strDateTime(
+                ref.year,
+                ref.month,
+                ref.day,
+                ref.hour,
+                ref.minute,
+                ref.second,
+                2)
+        xdt = DateTime()
+        t = xdt.translate(s)
+        self.assertEqual(ref.year, t.year)
+        self.assertEqual(ref.month, t.month)
+        self.assertEqual(ref.day, t.day)
+        self.assertEqual(ref.hour+1, t.hour)
+        self.assertEqual(ref.minute, t.minute)
+        self.assertEqual(ref.second, t.second)
+        
+    def testConvertPositiveToLesserPositive(self):
+        Timezone.local = 2
+        ref = dt.datetime(1941, 12, 7, 10, 30, 22)
+        s = self.strDateTime(
+                ref.year,
+                ref.month,
+                ref.day,
+                ref.hour,
+                ref.minute,
+                ref.second,
+                3)
+        xdt = DateTime()
+        t = xdt.translate(s)
+        self.assertEqual(ref.year, t.year)
+        self.assertEqual(ref.month, t.month)
+        self.assertEqual(ref.day, t.day)
+        self.assertEqual(ref.hour-1, t.hour)
+        self.assertEqual(ref.minute, t.minute)
+        self.assertEqual(ref.second, t.second)
+        
+    def testConvertPositiveToNegative(self):
+        Timezone.local = -6
+        ref = dt.datetime(1941, 12, 7, 10, 30, 22)
+        s = self.strDateTime(
+                ref.year,
+                ref.month,
+                ref.day,
+                ref.hour,
+                ref.minute,
+                ref.second,
+                3)
+        xdt = DateTime()
+        t = xdt.translate(s)
+        self.assertEqual(ref.year, t.year)
+        self.assertEqual(ref.month, t.month)
+        self.assertEqual(ref.day, t.day)
+        self.assertEqual(ref.hour-9, t.hour)
+        self.assertEqual(ref.minute, t.minute)
+        self.assertEqual(ref.second, t.second)
+        
+    def testConvertNegativeToPositive(self):
+        Timezone.local = 3
+        ref = dt.datetime(1941, 12, 7, 10, 30, 22)
+        s = self.strDateTime(
+                ref.year,
+                ref.month,
+                ref.day,
+                ref.hour,
+                ref.minute,
+                ref.second,
+                -6)
+        xdt = DateTime()
+        t = xdt.translate(s)
+        self.assertEqual(ref.year, t.year)
+        self.assertEqual(ref.month, t.month)
+        self.assertEqual(ref.day, t.day)
+        self.assertEqual(ref.hour+9, t.hour)
+        self.assertEqual(ref.minute, t.minute)
+        self.assertEqual(ref.second, t.second)
+        
+    def testConvertNegativeToUtc(self):
+        Timezone.local = 0
+        ref = dt.datetime(1941, 12, 7, 10, 30, 22)
+        s = self.strDateTime(
+                ref.year,
+                ref.month,
+                ref.day,
+                ref.hour,
+                ref.minute,
+                ref.second,
+                -6)
+        xdt = DateTime()
+        t = xdt.translate(s)
+        self.assertEqual(ref.year, t.year)
+        self.assertEqual(ref.month, t.month)
+        self.assertEqual(ref.day, t.day)
+        self.assertEqual(ref.hour+6, t.hour)
+        self.assertEqual(ref.minute, t.minute)
+        self.assertEqual(ref.second, t.second)
+        
+    def testConvertPositiveToUtc(self):
+        Timezone.local = 0
+        ref = dt.datetime(1941, 12, 7, 10, 30, 22)
+        s = self.strDateTime(
+                ref.year,
+                ref.month,
+                ref.day,
+                ref.hour,
+                ref.minute,
+                ref.second,
+                3)
+        xdt = DateTime()
+        t = xdt.translate(s)
+        self.assertEqual(ref.year, t.year)
+        self.assertEqual(ref.month, t.month)
+        self.assertEqual(ref.day, t.day)
+        self.assertEqual(ref.hour-3, t.hour)
+        self.assertEqual(ref.minute, t.minute)
+        self.assertEqual(ref.second, t.second)
+        
+    def testConvertUtcToPositive(self):
+        Timezone.local = 3
+        ref = dt.datetime(1941, 12, 7, 10, 30, 22)
+        s = '%.4d-%.2d-%.2dT%.2d:%.2d:%.2dZ' \
+            % (ref.year,
+               ref.month, 
+               ref.day, 
+               ref.hour, 
+               ref.minute, 
+               ref.second)
+        xdt = DateTime()
+        t = xdt.translate(s)
+        self.assertEqual(ref.year, t.year)
+        self.assertEqual(ref.month, t.month)
+        self.assertEqual(ref.day, t.day)
+        self.assertEqual(ref.hour+3, t.hour)
+        self.assertEqual(ref.minute, t.minute)
+        self.assertEqual(ref.second, t.second)
+        
+    def testConvertUtcToNegative(self):
+        Timezone.local = -6
+        ref = dt.datetime(1941, 12, 7, 10, 30, 22)
+        s = '%.4d-%.2d-%.2dT%.2d:%.2d:%.2dZ' \
+            % (ref.year,
+               ref.month, 
+               ref.day, 
+               ref.hour, 
+               ref.minute, 
+               ref.second)
+        xdt = DateTime()
+        t = xdt.translate(s)
+        self.assertEqual(ref.year, t.year)
+        self.assertEqual(ref.month, t.month)
+        self.assertEqual(ref.day, t.day)
+        self.assertEqual(ref.hour-6, t.hour)
+        self.assertEqual(ref.minute, t.minute)
+        self.assertEqual(ref.second, t.second)
+        
+    def testConvertNegativeToGreaterNegativeAndPreviousDay(self):
+        Timezone.local = -6
+        ref = dt.datetime(1941, 12, 7, 0, 30, 22)
+        s = self.strDateTime(
+                ref.year,
+                ref.month,
+                ref.day,
+                ref.hour,
+                ref.minute,
+                ref.second,
+                -5)
+        xdt = DateTime()
+        t = xdt.translate(s)
+        self.assertEqual(ref.year, t.year)
+        self.assertEqual(ref.month, t.month)
+        self.assertEqual(6, t.day)
+        self.assertEqual(23, t.hour)
+        self.assertEqual(ref.minute, t.minute)
+        self.assertEqual(ref.second, t.second)
+        
+    def testConvertNegativeToLesserNegativeAndNextDay(self):
+        Timezone.local = -5
+        ref = dt.datetime(1941, 12, 7, 23, 30, 22)
+        s = self.strDateTime(
+                ref.year,
+                ref.month,
+                ref.day,
+                ref.hour,
+                ref.minute,
+                ref.second,
+                -6)
+        xdt = DateTime()
+        t = xdt.translate(s)
+        self.assertEqual(ref.year, t.year)
+        self.assertEqual(ref.month, t.month)
+        self.assertEqual(8, t.day)
+        self.assertEqual(0, t.hour)
+        self.assertEqual(ref.minute, t.minute)
+        self.assertEqual(ref.second, t.second)
+        
+    def strDateTime(self, Y, M, D, h, m, s, offset):
+        s = '%.4d-%.2d-%.2dT%.2d:%.2d:%.2d%+.2d:00' \
+            % (Y, M, D, h, m, s, offset)
+        return s
 
-        date = XDateTime().translate("2002-05-30T05:30:10.525-03:00")
-        self.assertEqual(date.minute, 30)
-        self.assertEqual(date.second, 10)
-        self.assertEqual(date.hour, self.getHour(5, -3))
-        self.assertEqual(date.microsecond, 525000)
-        self.assertEqual(date.day, self.getDay(30, 5, -3))
-        self.assertEqual(date.year, 2002)
-        self.assertEqual(date.month, 5)
-        
-    def test_null_does_not_throw_exception(self):
-        self.assertEquals("", XDateTime().translate(None, False))
         
 if __name__ == '__main__':
     unittest.main()