PageRenderTime 53ms CodeModel.GetById 17ms RepoModel.GetById 1ms app.codeStats 0ms

/projects/jruby-1.7.3/test/externals/ruby1.9/test_time.rb

https://gitlab.com/essere.lab.public/qualitas.class-corpus
Ruby | 407 lines | 363 code | 34 blank | 10 comment | 6 complexity | 6d789617379f92fefcb69f9250f5c1c3 MD5 | raw file
    

  1. require 'time'
    2. 

  2. require 'test/unit'
    3. 

  3. require_relative 'ruby/envutil.rb'
    4. 

  4. 

  5. class TestTimeExtension < Test::Unit::TestCase # :nodoc:
    6. 

  6.   def test_rfc822
    7. 

  7.     assert_equal(Time.utc(1976, 8, 26, 14, 30) + 4 * 3600,
    8. 

  8.                  Time.rfc2822("26 Aug 76 14:30 EDT"))
    9. 

  9.     assert_equal(Time.utc(1976, 8, 27, 9, 32) + 7 * 3600,
    10. 

  10.                  Time.rfc2822("27 Aug 76 09:32 PDT"))
    11. 

  11.   end
    12. 

  12. 

  13.   def test_rfc2822
    14. 

  14.     assert_equal(Time.utc(1997, 11, 21, 9, 55, 6) + 6 * 3600,
    15. 

  15.                  Time.rfc2822("Fri, 21 Nov 1997 09:55:06 -0600"))
    16. 

  16.     assert_equal(Time.utc(2003, 7, 1, 10, 52, 37) - 2 * 3600,
    17. 

  17.                  Time.rfc2822("Tue, 1 Jul 2003 10:52:37 +0200"))
    18. 

  18.     assert_equal(Time.utc(1997, 11, 21, 10, 1, 10) + 6 * 3600,
    19. 

  19.                  Time.rfc2822("Fri, 21 Nov 1997 10:01:10 -0600"))
    20. 

  20.     assert_equal(Time.utc(1997, 11, 21, 11, 0, 0) + 6 * 3600,
    21. 

  21.                  Time.rfc2822("Fri, 21 Nov 1997 11:00:00 -0600"))
    22. 

  22.     assert_equal(Time.utc(1997, 11, 24, 14, 22, 1) + 8 * 3600,
    23. 

  23.                  Time.rfc2822("Mon, 24 Nov 1997 14:22:01 -0800"))
    24. 

  24.     begin
    25. 

  25.       Time.at(-1)
    26. 

  26.     rescue ArgumentError
    27. 

  27.       # ignore
    28. 

  28.     else
    29. 

  29.       assert_equal(Time.utc(1969, 2, 13, 23, 32, 54) + 3 * 3600 + 30 * 60,
    30. 

  30.                    Time.rfc2822("Thu, 13 Feb 1969 23:32:54 -0330"))
    31. 

  31.       assert_equal(Time.utc(1969, 2, 13, 23, 32, 0) + 3 * 3600 + 30 * 60,
    32. 

  32.                    Time.rfc2822(" Thu,
    33. 

  33.       13
    34. 

  34.         Feb
    35. 

  35.           1969
    36. 

  36.       23:32
    37. 

  37.                -0330 (Newfoundland Time)"))
    38. 

  38.     end
    39. 

  39.     assert_equal(Time.utc(1997, 11, 21, 9, 55, 6),
    40. 

  40.                  Time.rfc2822("21 Nov 97 09:55:06 GMT"))
    41. 

  41.     assert_equal(Time.utc(1997, 11, 21, 9, 55, 6) + 6 * 3600,
    42. 

  42.                  Time.rfc2822("Fri, 21 Nov 1997 09 :   55  :  06 -0600"))
    43. 

  43.     assert_raise(ArgumentError) {
    44. 

  44.       # inner comment is not supported.
    45. 

  45.       Time.rfc2822("Fri, 21 Nov 1997 09(comment):   55  :  06 -0600")
    46. 

  46.     }
    47. 

  47.   end
    48. 

  48. 

  49.   def test_encode_rfc2822
    50. 

  50.     t = Time.utc(1)
    51. 

  51.     assert_equal("Mon, 01 Jan 0001 00:00:00 -0000", t.rfc2822)
    52. 

  52.   end
    53. 

  53. 

  54.   def test_rfc2616
    55. 

  55.     t = Time.utc(1994, 11, 6, 8, 49, 37)
    56. 

  56.     assert_equal(t, Time.httpdate("Sun, 06 Nov 1994 08:49:37 GMT"))
    57. 

  57.     assert_equal(t, Time.httpdate("Sunday, 06-Nov-94 08:49:37 GMT"))
    58. 

  58.     assert_equal(t, Time.httpdate("Sun Nov  6 08:49:37 1994"))
    59. 

  59.     assert_equal(Time.utc(1995, 11, 15, 6, 25, 24),
    60. 

  60.                  Time.httpdate("Wed, 15 Nov 1995 06:25:24 GMT"))
    61. 

  61.     assert_equal(Time.utc(1995, 11, 15, 4, 58, 8),
    62. 

  62.                  Time.httpdate("Wed, 15 Nov 1995 04:58:08 GMT"))
    63. 

  63.     assert_equal(Time.utc(1994, 11, 15, 8, 12, 31),
    64. 

  64.                  Time.httpdate("Tue, 15 Nov 1994 08:12:31 GMT"))
    65. 

  65.     assert_equal(Time.utc(1994, 12, 1, 16, 0, 0),
    66. 

  66.                  Time.httpdate("Thu, 01 Dec 1994 16:00:00 GMT"))
    67. 

  67.     assert_equal(Time.utc(1994, 10, 29, 19, 43, 31),
    68. 

  68.                  Time.httpdate("Sat, 29 Oct 1994 19:43:31 GMT"))
    69. 

  69.     assert_equal(Time.utc(1994, 11, 15, 12, 45, 26),
    70. 

  70.                  Time.httpdate("Tue, 15 Nov 1994 12:45:26 GMT"))
    71. 

  71.     assert_equal(Time.utc(1999, 12, 31, 23, 59, 59),
    72. 

  72.                  Time.httpdate("Fri, 31 Dec 1999 23:59:59 GMT"))
    73. 

  73. 

  74.     assert_equal(Time.utc(2007, 12, 23, 11, 22, 33),
    75. 

  75.                  Time.httpdate('Sunday, 23-Dec-07 11:22:33 GMT'))
    76. 

  76.   end
    77. 

  77. 

  78.   def test_encode_httpdate
    79. 

  79.     t = Time.utc(1)
    80. 

  80.     assert_equal("Mon, 01 Jan 0001 00:00:00 GMT", t.httpdate)
    81. 

  81.   end
    82. 

  82. 

  83.   def test_rfc3339
    84. 

  84.     t = Time.utc(1985, 4, 12, 23, 20, 50, 520000)
    85. 

  85.     s = "1985-04-12T23:20:50.52Z"
    86. 

  86.     assert_equal(t, Time.iso8601(s))
    87. 

  87.     assert_equal(s, t.iso8601(2))
    88. 

  88. 

  89.     t = Time.utc(1996, 12, 20, 0, 39, 57)
    90. 

  90.     s = "1996-12-19T16:39:57-08:00"
    91. 

  91.     assert_equal(t, Time.iso8601(s))
    92. 

  92.     # There is no way to generate time string with arbitrary timezone.
    93. 

  93.     s = "1996-12-20T00:39:57Z"
    94. 

  94.     assert_equal(t, Time.iso8601(s))
    95. 

  95.     assert_equal(s, t.iso8601)
    96. 

  96. 

  97.     t = Time.utc(1990, 12, 31, 23, 59, 60)
    98. 

  98.     s = "1990-12-31T23:59:60Z"
    99. 

  99.     assert_equal(t, Time.iso8601(s))
    100. 

  100.     # leap second is representable only if timezone file has it.
    101. 

  101.     s = "1990-12-31T15:59:60-08:00"
    102. 

  102.     assert_equal(t, Time.iso8601(s))
    103. 

  103. 

  104.     begin
    105. 

  105.       Time.at(-1)
    106. 

  106.     rescue ArgumentError
    107. 

  107.       # ignore
    108. 

  108.     else
    109. 

  109.       t = Time.utc(1937, 1, 1, 11, 40, 27, 870000)
    110. 

  110.       s = "1937-01-01T12:00:27.87+00:20"
    111. 

  111.       assert_equal(t, Time.iso8601(s))
    112. 

  112.     end
    113. 

  113.   end
    114. 

  114. 

  115.   # http://www.w3.org/TR/xmlschema-2/
    116. 

  116.   def test_xmlschema
    117. 

  117.     assert_equal(Time.utc(1999, 5, 31, 13, 20, 0) + 5 * 3600,
    118. 

  118.                  Time.xmlschema("1999-05-31T13:20:00-05:00"))
    119. 

  119.     assert_equal(Time.local(2000, 1, 20, 12, 0, 0),
    120. 

  120.                  Time.xmlschema("2000-01-20T12:00:00"))
    121. 

  121.     assert_equal(Time.utc(2000, 1, 20, 12, 0, 0),
    122. 

  122.                  Time.xmlschema("2000-01-20T12:00:00Z"))
    123. 

  123.     assert_equal(Time.utc(2000, 1, 20, 12, 0, 0) - 12 * 3600,
    124. 

  124.                  Time.xmlschema("2000-01-20T12:00:00+12:00"))
    125. 

  125.     assert_equal(Time.utc(2000, 1, 20, 12, 0, 0) + 13 * 3600,
    126. 

  126.                  Time.xmlschema("2000-01-20T12:00:00-13:00"))
    127. 

  127.     assert_equal(Time.utc(2000, 3, 4, 23, 0, 0) - 3 * 3600,
    128. 

  128.                  Time.xmlschema("2000-03-04T23:00:00+03:00"))
    129. 

  129.     assert_equal(Time.utc(2000, 3, 4, 20, 0, 0),
    130. 

  130.                  Time.xmlschema("2000-03-04T20:00:00Z"))
    131. 

  131.     assert_equal(Time.local(2000, 1, 15, 0, 0, 0),
    132. 

  132.                  Time.xmlschema("2000-01-15T00:00:00"))
    133. 

  133.     assert_equal(Time.local(2000, 2, 15, 0, 0, 0),
    134. 

  134.                  Time.xmlschema("2000-02-15T00:00:00"))
    135. 

  135.     assert_equal(Time.local(2000, 1, 15, 12, 0, 0),
    136. 

  136.                  Time.xmlschema("2000-01-15T12:00:00"))
    137. 

  137.     assert_equal(Time.utc(2000, 1, 16, 12, 0, 0),
    138. 

  138.                  Time.xmlschema("2000-01-16T12:00:00Z"))
    139. 

  139.     assert_equal(Time.local(2000, 1, 1, 12, 0, 0),
    140. 

  140.                  Time.xmlschema("2000-01-01T12:00:00"))
    141. 

  141.     assert_equal(Time.utc(1999, 12, 31, 23, 0, 0),
    142. 

  142.                  Time.xmlschema("1999-12-31T23:00:00Z"))
    143. 

  143.     assert_equal(Time.local(2000, 1, 16, 12, 0, 0),
    144. 

  144.                  Time.xmlschema("2000-01-16T12:00:00"))
    145. 

  145.     assert_equal(Time.local(2000, 1, 16, 0, 0, 0),
    146. 

  146.                  Time.xmlschema("2000-01-16T00:00:00"))
    147. 

  147.     assert_equal(Time.utc(2000, 1, 12, 12, 13, 14),
    148. 

  148.                  Time.xmlschema("2000-01-12T12:13:14Z"))
    149. 

  149.     assert_equal(Time.utc(2001, 4, 17, 19, 23, 17, 300000),
    150. 

  150.                  Time.xmlschema("2001-04-17T19:23:17.3Z"))
    151. 

  151.     assert_equal(Time.utc(2000, 1, 2, 0, 0, 0),
    152. 

  152.                  Time.xmlschema("2000-01-01T24:00:00Z"))
    153. 

  153.     assert_raise(ArgumentError) { Time.xmlschema("2000-01-01T00:00:00.+00:00") }
    154. 

  154.   end
    155. 

  155. 

  156.   def test_encode_xmlschema
    157. 

  157.     t = Time.utc(2001, 4, 17, 19, 23, 17, 300000)
    158. 

  158.     assert_equal("2001-04-17T19:23:17Z", t.xmlschema)
    159. 

  159.     assert_equal("2001-04-17T19:23:17.3Z", t.xmlschema(1))
    160. 

  160.     assert_equal("2001-04-17T19:23:17.300000Z", t.xmlschema(6))
    161. 

  161.     assert_equal("2001-04-17T19:23:17.3000000Z", t.xmlschema(7))
    162. 

  162. 

  163.     t = Time.utc(2001, 4, 17, 19, 23, 17, 123456)
    164. 

  164.     assert_equal("2001-04-17T19:23:17.1234560Z", t.xmlschema(7))
    165. 

  165.     assert_equal("2001-04-17T19:23:17.123456Z", t.xmlschema(6))
    166. 

  166.     assert_equal("2001-04-17T19:23:17.12345Z", t.xmlschema(5))
    167. 

  167.     assert_equal("2001-04-17T19:23:17.1Z", t.xmlschema(1))
    168. 

  168. 

  169.     t = Time.at(2.quo(3)).getlocal("+09:00")
    170. 

  170.     assert_equal("1970-01-01T09:00:00.666+09:00", t.xmlschema(3))
    171. 

  171.     assert_equal("1970-01-01T09:00:00.6666666666+09:00", t.xmlschema(10))
    172. 

  172.     assert_equal("1970-01-01T09:00:00.66666666666666666666+09:00", t.xmlschema(20))
    173. 

  173. 

  174.     t = Time.at(123456789.quo(9999999999)).getlocal("+09:00")
    175. 

  175.     assert_equal("1970-01-01T09:00:00.012+09:00", t.xmlschema(3))
    176. 

  176.     assert_equal("1970-01-01T09:00:00.012345678+09:00", t.xmlschema(9))
    177. 

  177.     assert_equal("1970-01-01T09:00:00.0123456789+09:00", t.xmlschema(10))
    178. 

  178.     assert_equal("1970-01-01T09:00:00.0123456789012345678+09:00", t.xmlschema(19))
    179. 

  179.     assert_equal("1970-01-01T09:00:00.01234567890123456789+09:00", t.xmlschema(20))
    180. 

  180. 

  181.     t = Time.utc(1)
    182. 

  182.     assert_equal("0001-01-01T00:00:00Z", t.xmlschema)
    183. 

  183. 

  184.     begin
    185. 

  185.       Time.at(-1)
    186. 

  186.     rescue ArgumentError
    187. 

  187.       # ignore
    188. 

  188.     else
    189. 

  189.       t = Time.utc(1960, 12, 31, 23, 0, 0, 123456)
    190. 

  190.       assert_equal("1960-12-31T23:00:00.123456Z", t.xmlschema(6))
    191. 

  191.     end
    192. 

  192. 

  193.     assert_equal(249, Time.xmlschema("2008-06-05T23:49:23.000249+09:00").usec)
    194. 

  194. 

  195.     assert_equal("10000-01-01T00:00:00Z", Time.utc(10000).xmlschema)
    196. 

  196.     assert_equal("9999-01-01T00:00:00Z", Time.utc(9999).xmlschema)
    197. 

  197.     assert_equal("0001-01-01T00:00:00Z", Time.utc(1).xmlschema) # 1 AD
    198. 

  198.     assert_equal("0000-01-01T00:00:00Z", Time.utc(0).xmlschema) # 1 BC
    199. 

  199.     assert_equal("-0001-01-01T00:00:00Z", Time.utc(-1).xmlschema) # 2 BC
    200. 

  200.     assert_equal("-0004-01-01T00:00:00Z", Time.utc(-4).xmlschema) # 5 BC
    201. 

  201.     assert_equal("-9999-01-01T00:00:00Z", Time.utc(-9999).xmlschema)
    202. 

  202.     assert_equal("-10000-01-01T00:00:00Z", Time.utc(-10000).xmlschema)
    203. 

  203.   end
    204. 

  204. 

  205.   def test_completion
    206. 

  206.     now = Time.local(2001,11,29,21,26,35)
    207. 

  207.     assert_equal(Time.local( 2001,11,29,21,12),
    208. 

  208.                  Time.parse("2001/11/29 21:12", now))
    209. 

  209.     assert_equal(Time.local( 2001,11,29),
    210. 

  210.                  Time.parse("2001/11/29", now))
    211. 

  211.     assert_equal(Time.local( 2001,11,29),
    212. 

  212.                  Time.parse(     "11/29", now))
    213. 

  213.     #assert_equal(Time.local(2001,11,1), Time.parse("Nov", now))
    214. 

  214.     assert_equal(Time.local( 2001,11,29,10,22),
    215. 

  215.                  Time.parse(           "10:22", now))
    216. 

  216.     assert_raise(ArgumentError) { Time.parse("foo", now) }
    217. 

  217.   end
    218. 

  218. 

  219.   def test_invalid
    220. 

  220.     # They were actually used in some web sites.
    221. 

  221.     assert_raise(ArgumentError) { Time.httpdate("1 Dec 2001 10:23:57 GMT") }
    222. 

  222.     assert_raise(ArgumentError) { Time.httpdate("Sat, 1 Dec 2001 10:25:42 GMT") }
    223. 

  223.     assert_raise(ArgumentError) { Time.httpdate("Sat,  1-Dec-2001 10:53:55 GMT") }
    224. 

  224.     assert_raise(ArgumentError) { Time.httpdate("Saturday, 01-Dec-2001 10:15:34 GMT") }
    225. 

  225.     assert_raise(ArgumentError) { Time.httpdate("Saturday, 01-Dec-101 11:10:07 GMT") }
    226. 

  226.     assert_raise(ArgumentError) { Time.httpdate("Fri, 30 Nov 2001 21:30:00 JST") }
    227. 

  227. 

  228.     # They were actually used in some mails.
    229. 

  229.     assert_raise(ArgumentError) { Time.rfc2822("01-5-20") }
    230. 

  230.     assert_raise(ArgumentError) { Time.rfc2822("7/21/00") }
    231. 

  231.     assert_raise(ArgumentError) { Time.rfc2822("2001-8-28") }
    232. 

  232.     assert_raise(ArgumentError) { Time.rfc2822("00-5-6 1:13:06") }
    233. 

  233.     assert_raise(ArgumentError) { Time.rfc2822("2001-9-27 9:36:49") }
    234. 

  234.     assert_raise(ArgumentError) { Time.rfc2822("2000-12-13 11:01:11") }
    235. 

  235.     assert_raise(ArgumentError) { Time.rfc2822("2001/10/17 04:29:55") }
    236. 

  236.     assert_raise(ArgumentError) { Time.rfc2822("9/4/2001 9:23:19 PM") }
    237. 

  237.     assert_raise(ArgumentError) { Time.rfc2822("01 Nov 2001 09:04:31") }
    238. 

  238.     assert_raise(ArgumentError) { Time.rfc2822("13 Feb 2001 16:4 GMT") }
    239. 

  239.     assert_raise(ArgumentError) { Time.rfc2822("01 Oct 00 5:41:19 PM") }
    240. 

  240.     assert_raise(ArgumentError) { Time.rfc2822("2 Jul 00 00:51:37 JST") }
    241. 

  241.     assert_raise(ArgumentError) { Time.rfc2822("01 11 2001 06:55:57 -0500") }
    242. 

  242.     assert_raise(ArgumentError) { Time.rfc2822("18 \343\366\356\341\370 2000") }
    243. 

  243.     assert_raise(ArgumentError) { Time.rfc2822("Fri, Oct 2001  18:53:32") }
    244. 

  244.     assert_raise(ArgumentError) { Time.rfc2822("Fri, 2 Nov 2001 03:47:54") }
    245. 

  245.     assert_raise(ArgumentError) { Time.rfc2822("Fri, 27 Jul 2001 11.14.14 +0200") }
    246. 

  246.     assert_raise(ArgumentError) { Time.rfc2822("Thu, 2 Nov 2000 04:13:53 -600") }
    247. 

  247.     assert_raise(ArgumentError) { Time.rfc2822("Wed, 5 Apr 2000 22:57:09 JST") }
    248. 

  248.     assert_raise(ArgumentError) { Time.rfc2822("Mon, 11 Sep 2000 19:47:33 00000") }
    249. 

  249.     assert_raise(ArgumentError) { Time.rfc2822("Fri, 28 Apr 2000 20:40:47 +-900") }
    250. 

  250.     assert_raise(ArgumentError) { Time.rfc2822("Fri, 19 Jan 2001 8:15:36 AM -0500") }
    251. 

  251.     assert_raise(ArgumentError) { Time.rfc2822("Thursday, Sep 27 2001 7:42:35 AM EST") }
    252. 

  252.     assert_raise(ArgumentError) { Time.rfc2822("3/11/2001 1:31:57 PM Pacific Daylight Time") }
    253. 

  253.     assert_raise(ArgumentError) { Time.rfc2822("Mi, 28 Mrz 2001 11:51:36") }
    254. 

  254.     assert_raise(ArgumentError) { Time.rfc2822("P, 30 sept 2001 23:03:14") }
    255. 

  255.     assert_raise(ArgumentError) { Time.rfc2822("fr, 11 aug 2000 18:39:22") }
    256. 

  256.     assert_raise(ArgumentError) { Time.rfc2822("Fr, 21 Sep 2001 17:44:03 -1000") }
    257. 

  257.     assert_raise(ArgumentError) { Time.rfc2822("Mo, 18 Jun 2001 19:21:40 -1000") }
    258. 

  258.     assert_raise(ArgumentError) { Time.rfc2822("l\366, 12 aug 2000 18:53:20") }
    259. 

  259.     assert_raise(ArgumentError) { Time.rfc2822("l\366, 26 maj 2001 00:15:58") }
    260. 

  260.     assert_raise(ArgumentError) { Time.rfc2822("Dom, 30 Sep 2001 17:36:30") }
    261. 

  261.     assert_raise(ArgumentError) { Time.rfc2822("%&, 31 %2/ 2000 15:44:47 -0500") }
    262. 

  262.     assert_raise(ArgumentError) { Time.rfc2822("dom, 26 ago 2001 03:57:07 -0300") }
    263. 

  263.     assert_raise(ArgumentError) { Time.rfc2822("ter, 04 set 2001 16:27:58 -0300") }
    264. 

  264.     assert_raise(ArgumentError) { Time.rfc2822("Wen, 3 oct 2001 23:17:49 -0400") }
    265. 

  265.     assert_raise(ArgumentError) { Time.rfc2822("Wen, 3 oct 2001 23:17:49 -0400") }
    266. 

  266.     assert_raise(ArgumentError) { Time.rfc2822("ele, 11 h: 2000 12:42:15 -0500") }
    267. 

  267.     assert_raise(ArgumentError) { Time.rfc2822("Tue, 14 Aug 2001 3:55:3 +0200") }
    268. 

  268.     assert_raise(ArgumentError) { Time.rfc2822("Fri, 25 Aug 2000 9:3:48 +0800") }
    269. 

  269.     assert_raise(ArgumentError) { Time.rfc2822("Fri, 1 Dec 2000 0:57:50 EST") }
    270. 

  270.     assert_raise(ArgumentError) { Time.rfc2822("Mon, 7 May 2001 9:39:51 +0200") }
    271. 

  271.     assert_raise(ArgumentError) { Time.rfc2822("Wed, 1 Aug 2001 16:9:15 +0200") }
    272. 

  272.     assert_raise(ArgumentError) { Time.rfc2822("Wed, 23 Aug 2000 9:17:36 +0800") }
    273. 

  273.     assert_raise(ArgumentError) { Time.rfc2822("Fri, 11 Aug 2000 10:4:42 +0800") }
    274. 

  274.     assert_raise(ArgumentError) { Time.rfc2822("Sat, 15 Sep 2001 13:22:2 +0300") }
    275. 

  275.     assert_raise(ArgumentError) { Time.rfc2822("Wed,16 \276\305\324\302 2001 20:06:25 +0800") }
    276. 

  276.     assert_raise(ArgumentError) { Time.rfc2822("Wed,7 \312\256\322\273\324\302 2001 23:47:22 +0800") }
    277. 

  277.     assert_raise(ArgumentError) { Time.rfc2822("=?iso-8859-1?Q?(=C5=DA),?= 10   2 2001 23:32:26 +0900 (JST)") }
    278. 

  278.     assert_raise(ArgumentError) { Time.rfc2822("\307\341\314\343\332\311, 30 \344\346\335\343\310\321 2001 10:01:06") }
    279. 

  279.     assert_raise(ArgumentError) { Time.rfc2822("=?iso-8859-1?Q?(=BF=E5),?= 12  =?iso-8859-1?Q?9=B7=EE?= 2001 14:52:41\n+0900 (JST)") }
    280. 

  280.   end
    281. 

  281. 

  282.   def test_zone_0000
    283. 

  283.     assert_equal(true, Time.parse("2000-01-01T00:00:00Z").utc?)
    284. 

  284.     assert_equal(true, Time.parse("2000-01-01T00:00:00-00:00").utc?)
    285. 

  285.     assert_equal(false, Time.parse("2000-01-01T00:00:00+00:00").utc?)
    286. 

  286.     assert_equal(false, Time.parse("Sat, 01 Jan 2000 00:00:00 GMT").utc?)
    287. 

  287.     assert_equal(true, Time.parse("Sat, 01 Jan 2000 00:00:00 -0000").utc?)
    288. 

  288.     assert_equal(false, Time.parse("Sat, 01 Jan 2000 00:00:00 +0000").utc?)
    289. 

  289.     assert_equal(false, Time.rfc2822("Sat, 01 Jan 2000 00:00:00 GMT").utc?)
    290. 

  290.     assert_equal(true, Time.rfc2822("Sat, 01 Jan 2000 00:00:00 -0000").utc?)
    291. 

  291.     assert_equal(false, Time.rfc2822("Sat, 01 Jan 2000 00:00:00 +0000").utc?)
    292. 

  292.     assert_equal(true, Time.rfc2822("Sat, 01 Jan 2000 00:00:00 UTC").utc?)
    293. 

  293.   end
    294. 

  294. 

  295.   def test_rfc2822_utc_roundtrip_winter
    296. 

  296.     t1 = Time.local(2008,12,1)
    297. 

  297.     t2 = Time.rfc2822(t1.rfc2822)
    298. 

  298.     assert_equal(t1.utc?, t2.utc?, "[ruby-dev:37126]")
    299. 

  299.   end
    300. 

  300. 

  301.   def test_rfc2822_utc_roundtrip_summer
    302. 

  302.     t1 = Time.local(2008,8,1)
    303. 

  303.     t2 = Time.rfc2822(t1.rfc2822)
    304. 

  304.     assert_equal(t1.utc?, t2.utc?)
    305. 

  305.   end
    306. 

  306. 

  307.   def test_parse_leap_second
    308. 

  308.     t = Time.utc(1998,12,31,23,59,59)
    309. 

  309.     assert_equal(t, Time.parse("Thu Dec 31 23:59:59 UTC 1998"))
    310. 

  310.     assert_equal(t, Time.parse("Fri Dec 31 23:59:59 -0000 1998"));t.localtime
    311. 

  311.     assert_equal(t, Time.parse("Fri Jan  1 08:59:59 +0900 1999"))
    312. 

  312.     assert_equal(t, Time.parse("Fri Jan  1 00:59:59 +0100 1999"))
    313. 

  313.     assert_equal(t, Time.parse("Fri Dec 31 23:59:59 +0000 1998"))
    314. 

  314.     assert_equal(t, Time.parse("Fri Dec 31 22:59:59 -0100 1998"));t.utc
    315. 

  315.     t += 1
    316. 

  316.     assert_equal(t, Time.parse("Thu Dec 31 23:59:60 UTC 1998"))
    317. 

  317.     assert_equal(t, Time.parse("Fri Dec 31 23:59:60 -0000 1998"));t.localtime
    318. 

  318.     assert_equal(t, Time.parse("Fri Jan  1 08:59:60 +0900 1999"))
    319. 

  319.     assert_equal(t, Time.parse("Fri Jan  1 00:59:60 +0100 1999"))
    320. 

  320.     assert_equal(t, Time.parse("Fri Dec 31 23:59:60 +0000 1998"))
    321. 

  321.     assert_equal(t, Time.parse("Fri Dec 31 22:59:60 -0100 1998"));t.utc
    322. 

  322.     t += 1 if t.sec == 60
    323. 

  323.     assert_equal(t, Time.parse("Thu Jan  1 00:00:00 UTC 1999"))
    324. 

  324.     assert_equal(t, Time.parse("Fri Jan  1 00:00:00 -0000 1999"));t.localtime
    325. 

  325.     assert_equal(t, Time.parse("Fri Jan  1 09:00:00 +0900 1999"))
    326. 

  326.     assert_equal(t, Time.parse("Fri Jan  1 01:00:00 +0100 1999"))
    327. 

  327.     assert_equal(t, Time.parse("Fri Jan  1 00:00:00 +0000 1999"))
    328. 

  328.     assert_equal(t, Time.parse("Fri Dec 31 23:00:00 -0100 1998"))
    329. 

  329.   end
    330. 

  330. 

  331.   def test_rfc2822_leap_second
    332. 

  332.     t = Time.utc(1998,12,31,23,59,59)
    333. 

  333.     assert_equal(t, Time.rfc2822("Thu, 31 Dec 1998 23:59:59 UTC"))
    334. 

  334.     assert_equal(t, Time.rfc2822("Fri, 31 Dec 1998 23:59:59 -0000"));t.localtime
    335. 

  335.     assert_equal(t, Time.rfc2822("Fri,  1 Jan 1999 08:59:59 +0900"))
    336. 

  336.     assert_equal(t, Time.rfc2822("Fri,  1 Jan 1999 00:59:59 +0100"))
    337. 

  337.     assert_equal(t, Time.rfc2822("Fri, 31 Dec 1998 23:59:59 +0000"))
    338. 

  338.     assert_equal(t, Time.rfc2822("Fri, 31 Dec 1998 22:59:59 -0100"));t.utc
    339. 

  339.     t += 1
    340. 

  340.     assert_equal(t, Time.rfc2822("Thu, 31 Dec 1998 23:59:60 UTC"))
    341. 

  341.     assert_equal(t, Time.rfc2822("Fri, 31 Dec 1998 23:59:60 -0000"));t.localtime
    342. 

  342.     assert_equal(t, Time.rfc2822("Fri,  1 Jan 1999 08:59:60 +0900"))
    343. 

  343.     assert_equal(t, Time.rfc2822("Fri,  1 Jan 1999 00:59:60 +0100"))
    344. 

  344.     assert_equal(t, Time.rfc2822("Fri, 31 Dec 1998 23:59:60 +0000"))
    345. 

  345.     assert_equal(t, Time.rfc2822("Fri, 31 Dec 1998 22:59:60 -0100"));t.utc
    346. 

  346.     t += 1 if t.sec == 60
    347. 

  347.     assert_equal(t, Time.rfc2822("Thu,  1 Jan 1999 00:00:00 UTC"))
    348. 

  348.     assert_equal(t, Time.rfc2822("Fri,  1 Jan 1999 00:00:00 -0000"));t.localtime
    349. 

  349.     assert_equal(t, Time.rfc2822("Fri,  1 Jan 1999 09:00:00 +0900"))
    350. 

  350.     assert_equal(t, Time.rfc2822("Fri,  1 Jan 1999 01:00:00 +0100"))
    351. 

  351.     assert_equal(t, Time.rfc2822("Fri,  1 Jan 1999 00:00:00 +0000"))
    352. 

  352.     assert_equal(t, Time.rfc2822("Fri, 31 Dec 1998 23:00:00 -0100"))
    353. 

  353.   end
    354. 

  354. 

  355.   def test_xmlschema_leap_second
    356. 

  356.     t = Time.utc(1998,12,31,23,59,59)
    357. 

  357.     assert_equal(t, Time.xmlschema("1998-12-31T23:59:59Z"))
    358. 

  358.     assert_equal(t, Time.xmlschema("1998-12-31T23:59:59-00:00"));t.localtime
    359. 

  359.     assert_equal(t, Time.xmlschema("1999-01-01T08:59:59+09:00"))
    360. 

  360.     assert_equal(t, Time.xmlschema("1999-01-01T00:59:59+01:00"))
    361. 

  361.     assert_equal(t, Time.xmlschema("1998-12-31T23:59:59+00:00"))
    362. 

  362.     assert_equal(t, Time.xmlschema("1998-12-31T22:59:59-01:00"));t.utc
    363. 

  363.     t += 1
    364. 

  364.     assert_equal(t, Time.xmlschema("1998-12-31T23:59:60Z"))
    365. 

  365.     assert_equal(t, Time.xmlschema("1998-12-31T23:59:60-00:00"));t.localtime
    366. 

  366.     assert_equal(t, Time.xmlschema("1999-01-01T08:59:60+09:00"))
    367. 

  367.     assert_equal(t, Time.xmlschema("1999-01-01T00:59:60+01:00"))
    368. 

  368.     assert_equal(t, Time.xmlschema("1998-12-31T23:59:60+00:00"))
    369. 

  369.     assert_equal(t, Time.xmlschema("1998-12-31T22:59:60-01:00"));t.utc
    370. 

  370.     t += 1 if t.sec == 60
    371. 

  371.     assert_equal(t, Time.xmlschema("1999-01-01T00:00:00Z"))
    372. 

  372.     assert_equal(t, Time.xmlschema("1999-01-01T00:00:00-00:00"));t.localtime
    373. 

  373.     assert_equal(t, Time.xmlschema("1999-01-01T09:00:00+09:00"))
    374. 

  374.     assert_equal(t, Time.xmlschema("1999-01-01T01:00:00+01:00"))
    375. 

  375.     assert_equal(t, Time.xmlschema("1999-01-01T00:00:00+00:00"))
    376. 

  376.     assert_equal(t, Time.xmlschema("1998-12-31T23:00:00-01:00"))
    377. 

  377.   end
    378. 

  378. 

  379.   def test_xmlschema_fraction
    380. 

  380.     assert_equal(500000, Time.xmlschema("2000-01-01T00:00:00.5+00:00").tv_usec)
    381. 

  381.   end
    382. 

  382. 

  383.   def test_ruby_talk_152866
    384. 

  384.     t = Time::xmlschema('2005-08-30T22:48:00-07:00')
    385. 

  385.     assert_equal(31, t.day)
    386. 

  386.     assert_equal(8, t.mon)
    387. 

  387.   end
    388. 

  388. 

  389.   def test_parse_fraction
    390. 

  390.     assert_equal(500000, Time.parse("2000-01-01T00:00:00.5+00:00").tv_usec)
    391. 

  391.   end
    392. 

  392. 

  393.   def test_strptime
    394. 

  394.     assert_equal(Time.utc(2005, 8, 28, 06, 54, 20), Time.strptime("28/Aug/2005:06:54:20 +0000", "%d/%b/%Y:%T %z"))
    395. 

  395.     assert_equal(Time.at(1).localtime, Time.strptime("1", "%s"))
    396. 

  396.   end
    397. 

  397. 

  398.   def test_nsec
    399. 

  399.     assert_equal(123456789, Time.xmlschema("2000-01-01T00:00:00.123456789+00:00").tv_nsec)
    400. 

  400.     assert_equal(123456789, Time.parse("2000-01-01T00:00:00.123456789+00:00").tv_nsec)
    401. 

  401.   end
    402. 

  402. 

  403.   def test_huge_precision
    404. 

  404.     bug4456 = '[ruby-dev:43284]'
    405. 

  405.     assert_normal_exit %q{ Time.now.strftime("%1000000000F") }, bug4456
    406. 

  406.   end
    407. 

  407. end
    408. 

  408.