[Python-checkins] python/dist/src/Lib/test test_datetime.py,1.11,1.12

2002年12月26日 16:41:13 -0800

Update of /cvsroot/python/python/dist/src/Lib/test
In directory sc8-pr-cvs1:/tmp/cvs-serv11885/python/Lib/test
Modified Files:
	test_datetime.py 
Log Message:
Make comparison and subtraction of aware objects ignore tzinfo if the
operands have identical tzinfo members (meaning object identity -- "is").
I misunderstood the intent here, reading wrong conclusion into
conflicting clues.
Index: test_datetime.py
===================================================================
RCS file: /cvsroot/python/python/dist/src/Lib/test/test_datetime.py,v
retrieving revision 1.11
retrieving revision 1.12
diff -C2 -d -r1.11 -r1.12
*** test_datetime.py	26 Dec 2002 05:01:19 -0000	1.11
--- test_datetime.py	27 Dec 2002 00:41:11 -0000	1.12
***************
*** 1658,1664 ****
 cls = self.theclass
 
! # Primarily trying to ensure that utcoffset() gets called even if
! # the comparands have the same tzinfo member. timetz comparison
! # didn't used to do so, although datetimetz comparison did.
 class OperandDependentOffset(tzinfo):
 def utcoffset(self, t):
--- 1658,1663 ----
 cls = self.theclass
 
! # Ensure that utcoffset() gets ignored if the comparands have
! # the same tzinfo member.
 class OperandDependentOffset(tzinfo):
 def utcoffset(self, t):
***************
*** 1675,1678 ****
--- 1674,1687 ----
 for y in d0, d1, d2:
 got = cmp(x, y)
+ expected = cmp(x.minute, y.minute)
+ self.assertEqual(got, expected)
+ 
+ # However, if they're different members, uctoffset is not ignored.
+ d0 = base.replace(minute=3, tzinfo=OperandDependentOffset())
+ d1 = base.replace(minute=9, tzinfo=OperandDependentOffset())
+ d2 = base.replace(minute=11, tzinfo=OperandDependentOffset())
+ for x in d0, d1, d2:
+ for y in d0, d1, d2:
+ got = cmp(x, y)
 if (x is d0 or x is d1) and (y is d0 or y is d1):
 expected = 0
***************
*** 1894,1897 ****
--- 1903,1936 ----
 self.assertRaises(ValueError, base.replace, microsecond=1000000)
 
+ def test_mixed_compare(self):
+ t1 = time(1, 2, 3)
+ t2 = timetz(1, 2, 3)
+ self.assertEqual(t1, t2)
+ t2 = t2.replace(tzinfo=None)
+ self.assertEqual(t1, t2)
+ t2 = t2.replace(tzinfo=FixedOffset(None, ""))
+ self.assertEqual(t1, t2)
+ t2 = t2.replace(tzinfo=FixedOffset(0, ""))
+ self.assertRaises(TypeError, lambda: t1 == t2)
+ 
+ # In timetz w/ identical tzinfo objects, utcoffset is ignored.
+ class Varies(tzinfo):
+ def __init__(self):
+ self.offset = 22
+ def utcoffset(self, t):
+ self.offset += 1
+ return self.offset
+ 
+ v = Varies()
+ t1 = t2.replace(tzinfo=v)
+ t2 = t2.replace(tzinfo=v)
+ self.assertEqual(t1.utcoffset(), timedelta(minutes=23))
+ self.assertEqual(t2.utcoffset(), timedelta(minutes=24))
+ self.assertEqual(t1, t2)
+ 
+ # But if they're not identical, it isn't ignored.
+ t2 = t2.replace(tzinfo=Varies())
+ self.failUnless(t1 < t2) # t1's offset counter still going up
+ 
 
 class TestDateTimeTZ(TestDateTime, TZInfoBase):
***************
*** 1972,1976 ****
 t1 = self.theclass(2, 2, 2, tzinfo=Bogus())
 t2 = self.theclass(2, 2, 2, tzinfo=FixedOffset(0, ""))
! self.assertRaises(ValueError, lambda: t1 == t1)
 
 def test_pickling(self):
--- 2011,2015 ----
 t1 = self.theclass(2, 2, 2, tzinfo=Bogus())
 t2 = self.theclass(2, 2, 2, tzinfo=FixedOffset(0, ""))
! self.assertRaises(ValueError, lambda: t1 == t2)
 
 def test_pickling(self):
***************
*** 2390,2397 ****
 cls = self.theclass
 
! # Primarily trying to ensure that utcoffset() gets called even if
! # the operands have the same tzinfo member. Subtraction didn't
! # used to do this, and it makes a difference for DST-aware tzinfo
! # instances.
 class OperandDependentOffset(tzinfo):
 def utcoffset(self, t):
--- 2429,2434 ----
 cls = self.theclass
 
! # Ensure that utcoffset() is ignored when the operands have the
! # same tzinfo member.
 class OperandDependentOffset(tzinfo):
 def utcoffset(self, t):
***************
*** 2408,2411 ****
--- 2445,2460 ----
 for y in d0, d1, d2:
 got = x - y
+ expected = timedelta(minutes=x.minute - y.minute)
+ self.assertEqual(got, expected)
+ 
+ # OTOH, if the tzinfo members are distinct, utcoffsets aren't
+ # ignored.
+ base = cls(8, 9, 10, 11, 12, 13, 14)
+ d0 = base.replace(minute=3, tzinfo=OperandDependentOffset())
+ d1 = base.replace(minute=9, tzinfo=OperandDependentOffset())
+ d2 = base.replace(minute=11, tzinfo=OperandDependentOffset())
+ for x in d0, d1, d2:
+ for y in d0, d1, d2:
+ got = x - y
 if (x is d0 or x is d1) and (y is d0 or y is d1):
 expected = timedelta(0)
***************
*** 2419,2422 ****
--- 2468,2500 ----
 self.assertEqual(got, expected)
 
+ def test_mixed_compare(self):
+ t1 = datetime(1, 2, 3, 4, 5, 6, 7)
+ t2 = datetimetz(1, 2, 3, 4, 5, 6, 7)
+ self.assertEqual(t1, t2)
+ t2 = t2.replace(tzinfo=None)
+ self.assertEqual(t1, t2)
+ t2 = t2.replace(tzinfo=FixedOffset(None, ""))
+ self.assertEqual(t1, t2)
+ t2 = t2.replace(tzinfo=FixedOffset(0, ""))
+ self.assertRaises(TypeError, lambda: t1 == t2)
+ 
+ # In datetimetz w/ identical tzinfo objects, utcoffset is ignored.
+ class Varies(tzinfo):
+ def __init__(self):
+ self.offset = 22
+ def utcoffset(self, t):
+ self.offset += 1
+ return self.offset
+ 
+ v = Varies()
+ t1 = t2.replace(tzinfo=v)
+ t2 = t2.replace(tzinfo=v)
+ self.assertEqual(t1.utcoffset(), timedelta(minutes=23))
+ self.assertEqual(t2.utcoffset(), timedelta(minutes=24))
+ self.assertEqual(t1, t2)
+ 
+ # But if they're not identical, it isn't ignored.
+ t2 = t2.replace(tzinfo=Varies())
+ self.failUnless(t1 < t2) # t1's offset counter still going up
 
 def test_suite():