?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Daily bump.
[official-gcc.git] / libgo / go / time / time_test.go
blob53ae97ea0afd280524b201f0c11df0ff87a482cc
1 // Copyright 2009 The Go Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style
3 // license that can be found in the LICENSE file.
4
5 package time_test
6
7 import (
8 "bytes"
9 "encoding/gob"
10 "encoding/json"
11 "fmt"
12 "math/big"
13 "math/rand"
14 "runtime"
15 "strconv"
16 "strings"
17 "testing"
18 "testing/quick"
19 . "time"
20 )
21
22 // We should be in PST/PDT, but if the time zone files are missing we
23 // won't be. The purpose of this test is to at least explain why some of
24 // the subsequent tests fail.
25 func TestZoneData(t *testing.T) {
26 lt := Now()
27 // PST is 8 hours west, PDT is 7 hours west. We could use the name but it's not unique.
28 if name, off := lt.Zone(); off != -8*60*60 && off != -7*60*60 {
29 t.Errorf("Unable to find US Pacific time zone data for testing; time zone is %q offset %d", name, off)
30 t.Error("Likely problem: the time zone files have not been installed.")
31 }
32 }
33
34 // parsedTime is the struct representing a parsed time value.
35 type parsedTime struct {
36 Year int
37 Month Month
38 Day int
39 Hour, Minute, Second int // 15:04:05 is 15, 4, 5.
40 Nanosecond int // Fractional second.
41 Weekday Weekday
42 ZoneOffset int // seconds east of UTC, e.g. -7*60*60 for -0700
43 Zone string // e.g., "MST"
44 }
45
46 type TimeTest struct {
47 seconds int64
48 golden parsedTime
49 }
50
51 var utctests = []TimeTest{
52 {0, parsedTime{1970, January, 1, 0, 0, 0, 0, Thursday, 0, "UTC"}},
53 {1221681866, parsedTime{2008, September, 17, 20, 4, 26, 0, Wednesday, 0, "UTC"}},
54 {-1221681866, parsedTime{1931, April, 16, 3, 55, 34, 0, Thursday, 0, "UTC"}},
55 {-11644473600, parsedTime{1601, January, 1, 0, 0, 0, 0, Monday, 0, "UTC"}},
56 {599529660, parsedTime{1988, December, 31, 0, 1, 0, 0, Saturday, 0, "UTC"}},
57 {978220860, parsedTime{2000, December, 31, 0, 1, 0, 0, Sunday, 0, "UTC"}},
58 }
59
60 var nanoutctests = []TimeTest{
61 {0, parsedTime{1970, January, 1, 0, 0, 0, 1e8, Thursday, 0, "UTC"}},
62 {1221681866, parsedTime{2008, September, 17, 20, 4, 26, 2e8, Wednesday, 0, "UTC"}},
63 }
64
65 var localtests = []TimeTest{
66 {0, parsedTime{1969, December, 31, 16, 0, 0, 0, Wednesday, -8 * 60 * 60, "PST"}},
67 {1221681866, parsedTime{2008, September, 17, 13, 4, 26, 0, Wednesday, -7 * 60 * 60, "PDT"}},
68 }
69
70 var nanolocaltests = []TimeTest{
71 {0, parsedTime{1969, December, 31, 16, 0, 0, 1e8, Wednesday, -8 * 60 * 60, "PST"}},
72 {1221681866, parsedTime{2008, September, 17, 13, 4, 26, 3e8, Wednesday, -7 * 60 * 60, "PDT"}},
73 }
74
75 func same(t Time, u *parsedTime) bool {
76 // Check aggregates.
77 year, month, day := t.Date()
78 hour, min, sec := t.Clock()
79 name, offset := t.Zone()
80 if year != u.Year || month != u.Month || day != u.Day ||
81 hour != u.Hour || min != u.Minute || sec != u.Second ||
82 name != u.Zone || offset != u.ZoneOffset {
83 return false
84 }
85 // Check individual entries.
86 return t.Year() == u.Year &&
87 t.Month() == u.Month &&
88 t.Day() == u.Day &&
89 t.Hour() == u.Hour &&
90 t.Minute() == u.Minute &&
91 t.Second() == u.Second &&
92 t.Nanosecond() == u.Nanosecond &&
93 t.Weekday() == u.Weekday
94 }
95
96 func TestSecondsToUTC(t *testing.T) {
97 for _, test := range utctests {
98 sec := test.seconds
99 golden := &test.golden
100 tm := Unix(sec, 0).UTC()
101 newsec := tm.Unix()
102 if newsec != sec {
103 t.Errorf("SecondsToUTC(%d).Seconds() = %d", sec, newsec)
104 }
105 if !same(tm, golden) {
106 t.Errorf("SecondsToUTC(%d): // %#v", sec, tm)
107 t.Errorf(" want=%+v", *golden)
108 t.Errorf(" have=%v", tm.Format(RFC3339+" MST"))
109 }
110 }
111 }
112
113 func TestNanosecondsToUTC(t *testing.T) {
114 for _, test := range nanoutctests {
115 golden := &test.golden
116 nsec := test.seconds*1e9 + int64(golden.Nanosecond)
117 tm := Unix(0, nsec).UTC()
118 newnsec := tm.Unix()*1e9 + int64(tm.Nanosecond())
119 if newnsec != nsec {
120 t.Errorf("NanosecondsToUTC(%d).Nanoseconds() = %d", nsec, newnsec)
121 }
122 if !same(tm, golden) {
123 t.Errorf("NanosecondsToUTC(%d):", nsec)
124 t.Errorf(" want=%+v", *golden)
125 t.Errorf(" have=%+v", tm.Format(RFC3339+" MST"))
126 }
127 }
128 }
129
130 func TestSecondsToLocalTime(t *testing.T) {
131 for _, test := range localtests {
132 sec := test.seconds
133 golden := &test.golden
134 tm := Unix(sec, 0)
135 newsec := tm.Unix()
136 if newsec != sec {
137 t.Errorf("SecondsToLocalTime(%d).Seconds() = %d", sec, newsec)
138 }
139 if !same(tm, golden) {
140 t.Errorf("SecondsToLocalTime(%d):", sec)
141 t.Errorf(" want=%+v", *golden)
142 t.Errorf(" have=%+v", tm.Format(RFC3339+" MST"))
143 }
144 }
145 }
146
147 func TestNanosecondsToLocalTime(t *testing.T) {
148 for _, test := range nanolocaltests {
149 golden := &test.golden
150 nsec := test.seconds*1e9 + int64(golden.Nanosecond)
151 tm := Unix(0, nsec)
152 newnsec := tm.Unix()*1e9 + int64(tm.Nanosecond())
153 if newnsec != nsec {
154 t.Errorf("NanosecondsToLocalTime(%d).Seconds() = %d", nsec, newnsec)
155 }
156 if !same(tm, golden) {
157 t.Errorf("NanosecondsToLocalTime(%d):", nsec)
158 t.Errorf(" want=%+v", *golden)
159 t.Errorf(" have=%+v", tm.Format(RFC3339+" MST"))
160 }
161 }
162 }
163
164 func TestSecondsToUTCAndBack(t *testing.T) {
165 f := func(sec int64) bool { return Unix(sec, 0).UTC().Unix() == sec }
166 f32 := func(sec int32) bool { return f(int64(sec)) }
167 cfg := &quick.Config{MaxCount: 10000}
168
169 // Try a reasonable date first, then the huge ones.
170 if err := quick.Check(f32, cfg); err != nil {
171 t.Fatal(err)
172 }
173 if err := quick.Check(f, cfg); err != nil {
174 t.Fatal(err)
175 }
176 }
177
178 func TestNanosecondsToUTCAndBack(t *testing.T) {
179 f := func(nsec int64) bool {
180 t := Unix(0, nsec).UTC()
181 ns := t.Unix()*1e9 + int64(t.Nanosecond())
182 return ns == nsec
183 }
184 f32 := func(nsec int32) bool { return f(int64(nsec)) }
185 cfg := &quick.Config{MaxCount: 10000}
186
187 // Try a small date first, then the large ones. (The span is only a few hundred years
188 // for nanoseconds in an int64.)
189 if err := quick.Check(f32, cfg); err != nil {
190 t.Fatal(err)
191 }
192 if err := quick.Check(f, cfg); err != nil {
193 t.Fatal(err)
194 }
195 }
196
197 // The time routines provide no way to get absolute time
198 // (seconds since zero), but we need it to compute the right
199 // answer for bizarre roundings like "to the nearest 3 ns".
200 // Compute as t - year1 = (t - 1970) + (1970 - 2001) + (2001 - 1).
201 // t - 1970 is returned by Unix and Nanosecond.
202 // 1970 - 2001 is -(31*365+8)*86400 = -978307200 seconds.
203 // 2001 - 1 is 2000*365.2425*86400 = 63113904000 seconds.
204 const unixToZero = -978307200 + 63113904000
205
206 // abs returns the absolute time stored in t, as seconds and nanoseconds.
207 func abs(t Time) (sec, nsec int64) {
208 unix := t.Unix()
209 nano := t.Nanosecond()
210 return unix + unixToZero, int64(nano)
211 }
212
213 // absString returns abs as a decimal string.
214 func absString(t Time) string {
215 sec, nsec := abs(t)
216 if sec < 0 {
217 sec = -sec
218 nsec = -nsec
219 if nsec < 0 {
220 nsec += 1e9
221 sec--
222 }
223 return fmt.Sprintf("-%d%09d", sec, nsec)
224 }
225 return fmt.Sprintf("%d%09d", sec, nsec)
226 }
227
228 var truncateRoundTests = []struct {
229 t Time
230 d Duration
231 }{
232 {Date(-1, January, 1, 12, 15, 30, 5e8, UTC), 3},
233 {Date(-1, January, 1, 12, 15, 31, 5e8, UTC), 3},
234 {Date(2012, January, 1, 12, 15, 30, 5e8, UTC), Second},
235 {Date(2012, January, 1, 12, 15, 31, 5e8, UTC), Second},
236 }
237
238 func TestTruncateRound(t *testing.T) {
239 var (
240 bsec = new(big.Int)
241 bnsec = new(big.Int)
242 bd = new(big.Int)
243 bt = new(big.Int)
244 br = new(big.Int)
245 bq = new(big.Int)
246 b1e9 = new(big.Int)
247 )
248
249 b1e9.SetInt64(1e9)
250
251 testOne := func(ti, tns, di int64) bool {
252 t0 := Unix(ti, int64(tns)).UTC()
253 d := Duration(di)
254 if d < 0 {
255 d = -d
256 }
257 if d <= 0 {
258 d = 1
259 }
260
261 // Compute bt = absolute nanoseconds.
262 sec, nsec := abs(t0)
263 bsec.SetInt64(sec)
264 bnsec.SetInt64(nsec)
265 bt.Mul(bsec, b1e9)
266 bt.Add(bt, bnsec)
267
268 // Compute quotient and remainder mod d.
269 bd.SetInt64(int64(d))
270 bq.DivMod(bt, bd, br)
271
272 // To truncate, subtract remainder.
273 // br is < d, so it fits in an int64.
274 r := br.Int64()
275 t1 := t0.Add(-Duration(r))
276
277 // Check that time.Truncate works.
278 if trunc := t0.Truncate(d); trunc != t1 {
279 t.Errorf("Time.Truncate(%s, %s) = %s, want %s\n"+
280 "%v trunc %v =\n%v want\n%v",
281 t0.Format(RFC3339Nano), d, trunc, t1.Format(RFC3339Nano),
282 absString(t0), int64(d), absString(trunc), absString(t1))
283 return false
284 }
285
286 // To round, add d back if remainder r > d/2 or r == exactly d/2.
287 // The commented out code would round half to even instead of up,
288 // but that makes it time-zone dependent, which is a bit strange.
289 if r > int64(d)/2 || r+r == int64(d) /*&& bq.Bit(0) == 1*/ {
290 t1 = t1.Add(Duration(d))
291 }
292
293 // Check that time.Round works.
294 if rnd := t0.Round(d); rnd != t1 {
295 t.Errorf("Time.Round(%s, %s) = %s, want %s\n"+
296 "%v round %v =\n%v want\n%v",
297 t0.Format(RFC3339Nano), d, rnd, t1.Format(RFC3339Nano),
298 absString(t0), int64(d), absString(rnd), absString(t1))
299 return false
300 }
301 return true
302 }
303
304 // manual test cases
305 for _, tt := range truncateRoundTests {
306 testOne(tt.t.Unix(), int64(tt.t.Nanosecond()), int64(tt.d))
307 }
308
309 // exhaustive near 0
310 for i := 0; i < 100; i++ {
311 for j := 1; j < 100; j++ {
312 testOne(unixToZero, int64(i), int64(j))
313 testOne(unixToZero, -int64(i), int64(j))
314 if t.Failed() {
315 return
316 }
317 }
318 }
319
320 if t.Failed() {
321 return
322 }
323
324 // randomly generated test cases
325 cfg := &quick.Config{MaxCount: 100000}
326 if testing.Short() {
327 cfg.MaxCount = 1000
328 }
329
330 // divisors of Second
331 f1 := func(ti int64, tns int32, logdi int32) bool {
332 d := Duration(1)
333 a, b := uint(logdi%9), (logdi>>16)%9
334 d <<= a
335 for i := 0; i < int(b); i++ {
336 d *= 5
337 }
338 return testOne(ti, int64(tns), int64(d))
339 }
340 quick.Check(f1, cfg)
341
342 // multiples of Second
343 f2 := func(ti int64, tns int32, di int32) bool {
344 d := Duration(di) * Second
345 if d < 0 {
346 d = -d
347 }
348 return testOne(ti, int64(tns), int64(d))
349 }
350 quick.Check(f2, cfg)
351
352 // halfway cases
353 f3 := func(tns, di int64) bool {
354 di &= 0xfffffffe
355 if di == 0 {
356 di = 2
357 }
358 tns -= tns % di
359 if tns < 0 {
360 tns += di / 2
361 } else {
362 tns -= di / 2
363 }
364 return testOne(0, tns, di)
365 }
366 quick.Check(f3, cfg)
367
368 // full generality
369 f4 := func(ti int64, tns int32, di int64) bool {
370 return testOne(ti, int64(tns), di)
371 }
372 quick.Check(f4, cfg)
373 }
374
375 type TimeFormatTest struct {
376 time Time
377 formattedValue string
378 }
379
380 var rfc3339Formats = []TimeFormatTest{
381 {Date(2008, 9, 17, 20, 4, 26, 0, UTC), "2008-09-17T20:04:26Z"},
382 {Date(1994, 9, 17, 20, 4, 26, 0, FixedZone("EST", -18000)), "1994-09-17T20:04:26-05:00"},
383 {Date(2000, 12, 26, 1, 15, 6, 0, FixedZone("OTO", 15600)), "2000-12-26T01:15:06+04:20"},
384 }
385
386 func TestRFC3339Conversion(t *testing.T) {
387 for _, f := range rfc3339Formats {
388 if f.time.Format(RFC3339) != f.formattedValue {
389 t.Error("RFC3339:")
390 t.Errorf(" want=%+v", f.formattedValue)
391 t.Errorf(" have=%+v", f.time.Format(RFC3339))
392 }
393 }
394 }
395
396 type FormatTest struct {
397 name string
398 format string
399 result string
400 }
401
402 var formatTests = []FormatTest{
403 {"ANSIC", ANSIC, "Wed Feb 4 21:00:57 2009"},
404 {"UnixDate", UnixDate, "Wed Feb 4 21:00:57 PST 2009"},
405 {"RubyDate", RubyDate, "Wed Feb 04 21:00:57 -0800 2009"},
406 {"RFC822", RFC822, "04 Feb 09 21:00 PST"},
407 {"RFC850", RFC850, "Wednesday, 04-Feb-09 21:00:57 PST"},
408 {"RFC1123", RFC1123, "Wed, 04 Feb 2009 21:00:57 PST"},
409 {"RFC1123Z", RFC1123Z, "Wed, 04 Feb 2009 21:00:57 -0800"},
410 {"RFC3339", RFC3339, "2009-02-04T21:00:57-08:00"},
411 {"RFC3339Nano", RFC3339Nano, "2009-02-04T21:00:57.0123456-08:00"},
412 {"Kitchen", Kitchen, "9:00PM"},
413 {"am/pm", "3pm", "9pm"},
414 {"AM/PM", "3PM", "9PM"},
415 {"two-digit year", "06 01 02", "09 02 04"},
416 // Three-letter months and days must not be followed by lower-case letter.
417 {"Janet", "Hi Janet, the Month is January", "Hi Janet, the Month is February"},
418 // Time stamps, Fractional seconds.
419 {"Stamp", Stamp, "Feb 4 21:00:57"},
420 {"StampMilli", StampMilli, "Feb 4 21:00:57.012"},
421 {"StampMicro", StampMicro, "Feb 4 21:00:57.012345"},
422 {"StampNano", StampNano, "Feb 4 21:00:57.012345600"},
423 }
424
425 func TestFormat(t *testing.T) {
426 // The numeric time represents Thu Feb 4 21:00:57.012345600 PST 2010
427 time := Unix(0, 1233810057012345600)
428 for _, test := range formatTests {
429 result := time.Format(test.format)
430 if result != test.result {
431 t.Errorf("%s expected %q got %q", test.name, test.result, result)
432 }
433 }
434 }
435
436 func TestFormatShortYear(t *testing.T) {
437 years := []int{
438 -100001, -100000, -99999,
439 -10001, -10000, -9999,
440 -1001, -1000, -999,
441 -101, -100, -99,
442 -11, -10, -9,
443 -1, 0, 1,
444 9, 10, 11,
445 99, 100, 101,
446 999, 1000, 1001,
447 9999, 10000, 10001,
448 99999, 100000, 100001,
449 }
450
451 for _, y := range years {
452 time := Date(y, January, 1, 0, 0, 0, 0, UTC)
453 result := time.Format("2006.01.02")
454 var want string
455 if y < 0 {
456 // The 4 in %04d counts the - sign, so print -y instead
457 // and introduce our own - sign.
458 want = fmt.Sprintf("-%04d.%02d.%02d", -y, 1, 1)
459 } else {
460 want = fmt.Sprintf("%04d.%02d.%02d", y, 1, 1)
461 }
462 if result != want {
463 t.Errorf("(jan 1 %d).Format(\"2006.01.02\") = %q, want %q", y, result, want)
464 }
465 }
466 }
467
468 type ParseTest struct {
469 name string
470 format string
471 value string
472 hasTZ bool // contains a time zone
473 hasWD bool // contains a weekday
474 yearSign int // sign of year, -1 indicates the year is not present in the format
475 fracDigits int // number of digits of fractional second
476 }
477
478 var parseTests = []ParseTest{
479 {"ANSIC", ANSIC, "Thu Feb 4 21:00:57 2010", false, true, 1, 0},
480 {"UnixDate", UnixDate, "Thu Feb 4 21:00:57 PST 2010", true, true, 1, 0},
481 {"RubyDate", RubyDate, "Thu Feb 04 21:00:57 -0800 2010", true, true, 1, 0},
482 {"RFC850", RFC850, "Thursday, 04-Feb-10 21:00:57 PST", true, true, 1, 0},
483 {"RFC1123", RFC1123, "Thu, 04 Feb 2010 21:00:57 PST", true, true, 1, 0},
484 {"RFC1123", RFC1123, "Thu, 04 Feb 2010 22:00:57 PDT", true, true, 1, 0},
485 {"RFC1123Z", RFC1123Z, "Thu, 04 Feb 2010 21:00:57 -0800", true, true, 1, 0},
486 {"RFC3339", RFC3339, "2010-02-04T21:00:57-08:00", true, false, 1, 0},
487 {"custom: \"2006-01-02 15:04:05-07\"", "2006-01-02 15:04:05-07", "2010-02-04 21:00:57-08", true, false, 1, 0},
488 // Optional fractional seconds.
489 {"ANSIC", ANSIC, "Thu Feb 4 21:00:57.0 2010", false, true, 1, 1},
490 {"UnixDate", UnixDate, "Thu Feb 4 21:00:57.01 PST 2010", true, true, 1, 2},
491 {"RubyDate", RubyDate, "Thu Feb 04 21:00:57.012 -0800 2010", true, true, 1, 3},
492 {"RFC850", RFC850, "Thursday, 04-Feb-10 21:00:57.0123 PST", true, true, 1, 4},
493 {"RFC1123", RFC1123, "Thu, 04 Feb 2010 21:00:57.01234 PST", true, true, 1, 5},
494 {"RFC1123Z", RFC1123Z, "Thu, 04 Feb 2010 21:00:57.01234 -0800", true, true, 1, 5},
495 {"RFC3339", RFC3339, "2010-02-04T21:00:57.012345678-08:00", true, false, 1, 9},
496 {"custom: \"2006-01-02 15:04:05\"", "2006-01-02 15:04:05", "2010-02-04 21:00:57.0", false, false, 1, 0},
497 // Amount of white space should not matter.
498 {"ANSIC", ANSIC, "Thu Feb 4 21:00:57 2010", false, true, 1, 0},
499 {"ANSIC", ANSIC, "Thu Feb 4 21:00:57 2010", false, true, 1, 0},
500 // Case should not matter
501 {"ANSIC", ANSIC, "THU FEB 4 21:00:57 2010", false, true, 1, 0},
502 {"ANSIC", ANSIC, "thu feb 4 21:00:57 2010", false, true, 1, 0},
503 // Fractional seconds.
504 {"millisecond", "Mon Jan _2 15:04:05.000 2006", "Thu Feb 4 21:00:57.012 2010", false, true, 1, 3},
505 {"microsecond", "Mon Jan _2 15:04:05.000000 2006", "Thu Feb 4 21:00:57.012345 2010", false, true, 1, 6},
506 {"nanosecond", "Mon Jan _2 15:04:05.000000000 2006", "Thu Feb 4 21:00:57.012345678 2010", false, true, 1, 9},
507 // Leading zeros in other places should not be taken as fractional seconds.
508 {"zero1", "2006.01.02.15.04.05.0", "2010.02.04.21.00.57.0", false, false, 1, 1},
509 {"zero2", "2006.01.02.15.04.05.00", "2010.02.04.21.00.57.01", false, false, 1, 2},
510 // Month and day names only match when not followed by a lower-case letter.
511 {"Janet", "Hi Janet, the Month is January: Jan _2 15:04:05 2006", "Hi Janet, the Month is February: Feb 4 21:00:57 2010", false, true, 1, 0},
512
513 // GMT with offset.
514 {"GMT-8", UnixDate, "Fri Feb 5 05:00:57 GMT-8 2010", true, true, 1, 0},
515
516 // Accept any number of fractional second digits (including none) for .999...
517 // In Go 1, .999... was completely ignored in the format, meaning the first two
518 // cases would succeed, but the next four would not. Go 1.1 accepts all six.
519 {"", "2006-01-02 15:04:05.9999 -0700 MST", "2010-02-04 21:00:57 -0800 PST", true, false, 1, 0},
520 {"", "2006-01-02 15:04:05.999999999 -0700 MST", "2010-02-04 21:00:57 -0800 PST", true, false, 1, 0},
521 {"", "2006-01-02 15:04:05.9999 -0700 MST", "2010-02-04 21:00:57.0123 -0800 PST", true, false, 1, 4},
522 {"", "2006-01-02 15:04:05.999999999 -0700 MST", "2010-02-04 21:00:57.0123 -0800 PST", true, false, 1, 4},
523 {"", "2006-01-02 15:04:05.9999 -0700 MST", "2010-02-04 21:00:57.012345678 -0800 PST", true, false, 1, 9},
524 {"", "2006-01-02 15:04:05.999999999 -0700 MST", "2010-02-04 21:00:57.012345678 -0800 PST", true, false, 1, 9},
525
526 // issue 4502.
527 {"", StampNano, "Feb 4 21:00:57.012345678", false, false, -1, 9},
528 {"", "Jan _2 15:04:05.999", "Feb 4 21:00:57.012300000", false, false, -1, 4},
529 {"", "Jan _2 15:04:05.999", "Feb 4 21:00:57.012345678", false, false, -1, 9},
530 {"", "Jan _2 15:04:05.999999999", "Feb 4 21:00:57.0123", false, false, -1, 4},
531 {"", "Jan _2 15:04:05.999999999", "Feb 4 21:00:57.012345678", false, false, -1, 9},
532 }
533
534 func TestParse(t *testing.T) {
535 for _, test := range parseTests {
536 time, err := Parse(test.format, test.value)
537 if err != nil {
538 t.Errorf("%s error: %v", test.name, err)
539 } else {
540 checkTime(time, &test, t)
541 }
542 }
543 }
544
545 func TestParseInSydney(t *testing.T) {
546 loc, err := LoadLocation("Australia/Sydney")
547 if err != nil {
548 t.Fatal(err)
549 }
550
551 // Check that Parse (and ParseInLocation) understand
552 // that Feb EST and Aug EST are different time zones in Sydney
553 // even though both are called EST.
554 t1, err := ParseInLocation("Jan 02 2006 MST", "Feb 01 2013 EST", loc)
555 if err != nil {
556 t.Fatal(err)
557 }
558 t2 := Date(2013, February, 1, 00, 00, 00, 0, loc)
559 if t1 != t2 {
560 t.Fatalf("ParseInLocation(Feb 01 2013 EST, Sydney) = %v, want %v", t1, t2)
561 }
562 _, offset := t1.Zone()
563 if offset != 11*60*60 {
564 t.Fatalf("ParseInLocation(Feb 01 2013 EST, Sydney).Zone = _, %d, want _, %d", offset, 11*60*60)
565 }
566
567 t1, err = ParseInLocation("Jan 02 2006 MST", "Aug 01 2013 EST", loc)
568 if err != nil {
569 t.Fatal(err)
570 }
571 t2 = Date(2013, August, 1, 00, 00, 00, 0, loc)
572 if t1 != t2 {
573 t.Fatalf("ParseInLocation(Aug 01 2013 EST, Sydney) = %v, want %v", t1, t2)
574 }
575 _, offset = t1.Zone()
576 if offset != 10*60*60 {
577 t.Fatalf("ParseInLocation(Aug 01 2013 EST, Sydney).Zone = _, %d, want _, %d", offset, 10*60*60)
578 }
579 }
580
581 func TestLoadLocationZipFile(t *testing.T) {
582 t.Skip("gccgo does not use the zip file")
583
584 ForceZipFileForTesting(true)
585 defer ForceZipFileForTesting(false)
586
587 _, err := LoadLocation("Australia/Sydney")
588 if err != nil {
589 t.Fatal(err)
590 }
591 }
592
593 var rubyTests = []ParseTest{
594 {"RubyDate", RubyDate, "Thu Feb 04 21:00:57 -0800 2010", true, true, 1, 0},
595 // Ignore the time zone in the test. If it parses, it'll be OK.
596 {"RubyDate", RubyDate, "Thu Feb 04 21:00:57 -0000 2010", false, true, 1, 0},
597 {"RubyDate", RubyDate, "Thu Feb 04 21:00:57 +0000 2010", false, true, 1, 0},
598 {"RubyDate", RubyDate, "Thu Feb 04 21:00:57 +1130 2010", false, true, 1, 0},
599 }
600
601 // Problematic time zone format needs special tests.
602 func TestRubyParse(t *testing.T) {
603 for _, test := range rubyTests {
604 time, err := Parse(test.format, test.value)
605 if err != nil {
606 t.Errorf("%s error: %v", test.name, err)
607 } else {
608 checkTime(time, &test, t)
609 }
610 }
611 }
612
613 func checkTime(time Time, test *ParseTest, t *testing.T) {
614 // The time should be Thu Feb 4 21:00:57 PST 2010
615 if test.yearSign >= 0 && test.yearSign*time.Year() != 2010 {
616 t.Errorf("%s: bad year: %d not %d", test.name, time.Year(), 2010)
617 }
618 if time.Month() != February {
619 t.Errorf("%s: bad month: %s not %s", test.name, time.Month(), February)
620 }
621 if time.Day() != 4 {
622 t.Errorf("%s: bad day: %d not %d", test.name, time.Day(), 4)
623 }
624 if time.Hour() != 21 {
625 t.Errorf("%s: bad hour: %d not %d", test.name, time.Hour(), 21)
626 }
627 if time.Minute() != 0 {
628 t.Errorf("%s: bad minute: %d not %d", test.name, time.Minute(), 0)
629 }
630 if time.Second() != 57 {
631 t.Errorf("%s: bad second: %d not %d", test.name, time.Second(), 57)
632 }
633 // Nanoseconds must be checked against the precision of the input.
634 nanosec, err := strconv.ParseUint("012345678"[:test.fracDigits]+"000000000"[:9-test.fracDigits], 10, 0)
635 if err != nil {
636 panic(err)
637 }
638 if time.Nanosecond() != int(nanosec) {
639 t.Errorf("%s: bad nanosecond: %d not %d", test.name, time.Nanosecond(), nanosec)
640 }
641 name, offset := time.Zone()
642 if test.hasTZ && offset != -28800 {
643 t.Errorf("%s: bad tz offset: %s %d not %d", test.name, name, offset, -28800)
644 }
645 if test.hasWD && time.Weekday() != Thursday {
646 t.Errorf("%s: bad weekday: %s not %s", test.name, time.Weekday(), Thursday)
647 }
648 }
649
650 func TestFormatAndParse(t *testing.T) {
651 const fmt = "Mon MST " + RFC3339 // all fields
652 f := func(sec int64) bool {
653 t1 := Unix(sec, 0)
654 if t1.Year() < 1000 || t1.Year() > 9999 {
655 // not required to work
656 return true
657 }
658 t2, err := Parse(fmt, t1.Format(fmt))
659 if err != nil {
660 t.Errorf("error: %s", err)
661 return false
662 }
663 if t1.Unix() != t2.Unix() || t1.Nanosecond() != t2.Nanosecond() {
664 t.Errorf("FormatAndParse %d: %q(%d) %q(%d)", sec, t1, t1.Unix(), t2, t2.Unix())
665 return false
666 }
667 return true
668 }
669 f32 := func(sec int32) bool { return f(int64(sec)) }
670 cfg := &quick.Config{MaxCount: 10000}
671
672 // Try a reasonable date first, then the huge ones.
673 if err := quick.Check(f32, cfg); err != nil {
674 t.Fatal(err)
675 }
676 if err := quick.Check(f, cfg); err != nil {
677 t.Fatal(err)
678 }
679 }
680
681 type ParseTimeZoneTest struct {
682 value string
683 length int
684 ok bool
685 }
686
687 var parseTimeZoneTests = []ParseTimeZoneTest{
688 {"gmt hi there", 0, false},
689 {"GMT hi there", 3, true},
690 {"GMT+12 hi there", 6, true},
691 {"GMT+00 hi there", 3, true}, // 0 or 00 is not a legal offset.
692 {"GMT-5 hi there", 5, true},
693 {"GMT-51 hi there", 3, true},
694 {"ChST hi there", 4, true},
695 {"MSDx", 3, true},
696 {"MSDY", 0, false}, // four letters must end in T.
697 {"ESAST hi", 5, true},
698 {"ESASTT hi", 0, false}, // run of upper-case letters too long.
699 {"ESATY hi", 0, false}, // five letters must end in T.
700 }
701
702 func TestParseTimeZone(t *testing.T) {
703 for _, test := range parseTimeZoneTests {
704 length, ok := ParseTimeZone(test.value)
705 if ok != test.ok {
706 t.Errorf("expected %t for %q got %t", test.ok, test.value, ok)
707 } else if length != test.length {
708 t.Errorf("expected %d for %q got %d", test.length, test.value, length)
709 }
710 }
711 }
712
713 type ParseErrorTest struct {
714 format string
715 value string
716 expect string // must appear within the error
717 }
718
719 var parseErrorTests = []ParseErrorTest{
720 {ANSIC, "Feb 4 21:00:60 2010", "cannot parse"}, // cannot parse Feb as Mon
721 {ANSIC, "Thu Feb 4 21:00:57 @2010", "cannot parse"},
722 {ANSIC, "Thu Feb 4 21:00:60 2010", "second out of range"},
723 {ANSIC, "Thu Feb 4 21:61:57 2010", "minute out of range"},
724 {ANSIC, "Thu Feb 4 24:00:60 2010", "hour out of range"},
725 {"Mon Jan _2 15:04:05.000 2006", "Thu Feb 4 23:00:59x01 2010", "cannot parse"},
726 {"Mon Jan _2 15:04:05.000 2006", "Thu Feb 4 23:00:59.xxx 2010", "cannot parse"},
727 {"Mon Jan _2 15:04:05.000 2006", "Thu Feb 4 23:00:59.-123 2010", "fractional second out of range"},
728 // issue 4502. StampNano requires exactly 9 digits of precision.
729 {StampNano, "Dec 7 11:22:01.000000", `cannot parse ".000000" as ".000000000"`},
730 {StampNano, "Dec 7 11:22:01.0000000000", "extra text: 0"},
731 // issue 4493. Helpful errors.
732 {RFC3339, "2006-01-02T15:04:05Z07:00", `parsing time "2006-01-02T15:04:05Z07:00": extra text: 07:00`},
733 {RFC3339, "2006-01-02T15:04_abc", `parsing time "2006-01-02T15:04_abc" as "2006-01-02T15:04:05Z07:00": cannot parse "_abc" as ":"`},
734 {RFC3339, "2006-01-02T15:04:05_abc", `parsing time "2006-01-02T15:04:05_abc" as "2006-01-02T15:04:05Z07:00": cannot parse "_abc" as "Z07:00"`},
735 {RFC3339, "2006-01-02T15:04:05Z_abc", `parsing time "2006-01-02T15:04:05Z_abc": extra text: _abc`},
736 }
737
738 func TestParseErrors(t *testing.T) {
739 for _, test := range parseErrorTests {
740 _, err := Parse(test.format, test.value)
741 if err == nil {
742 t.Errorf("expected error for %q %q", test.format, test.value)
743 } else if strings.Index(err.Error(), test.expect) < 0 {
744 t.Errorf("expected error with %q for %q %q; got %s", test.expect, test.format, test.value, err)
745 }
746 }
747 }
748
749 func TestNoonIs12PM(t *testing.T) {
750 noon := Date(0, January, 1, 12, 0, 0, 0, UTC)
751 const expect = "12:00PM"
752 got := noon.Format("3:04PM")
753 if got != expect {
754 t.Errorf("got %q; expect %q", got, expect)
755 }
756 got = noon.Format("03:04PM")
757 if got != expect {
758 t.Errorf("got %q; expect %q", got, expect)
759 }
760 }
761
762 func TestMidnightIs12AM(t *testing.T) {
763 midnight := Date(0, January, 1, 0, 0, 0, 0, UTC)
764 expect := "12:00AM"
765 got := midnight.Format("3:04PM")
766 if got != expect {
767 t.Errorf("got %q; expect %q", got, expect)
768 }
769 got = midnight.Format("03:04PM")
770 if got != expect {
771 t.Errorf("got %q; expect %q", got, expect)
772 }
773 }
774
775 func Test12PMIsNoon(t *testing.T) {
776 noon, err := Parse("3:04PM", "12:00PM")
777 if err != nil {
778 t.Fatal("error parsing date:", err)
779 }
780 if noon.Hour() != 12 {
781 t.Errorf("got %d; expect 12", noon.Hour())
782 }
783 noon, err = Parse("03:04PM", "12:00PM")
784 if err != nil {
785 t.Fatal("error parsing date:", err)
786 }
787 if noon.Hour() != 12 {
788 t.Errorf("got %d; expect 12", noon.Hour())
789 }
790 }
791
792 func Test12AMIsMidnight(t *testing.T) {
793 midnight, err := Parse("3:04PM", "12:00AM")
794 if err != nil {
795 t.Fatal("error parsing date:", err)
796 }
797 if midnight.Hour() != 0 {
798 t.Errorf("got %d; expect 0", midnight.Hour())
799 }
800 midnight, err = Parse("03:04PM", "12:00AM")
801 if err != nil {
802 t.Fatal("error parsing date:", err)
803 }
804 if midnight.Hour() != 0 {
805 t.Errorf("got %d; expect 0", midnight.Hour())
806 }
807 }
808
809 // Check that a time without a Zone still produces a (numeric) time zone
810 // when formatted with MST as a requested zone.
811 func TestMissingZone(t *testing.T) {
812 time, err := Parse(RubyDate, "Thu Feb 02 16:10:03 -0500 2006")
813 if err != nil {
814 t.Fatal("error parsing date:", err)
815 }
816 expect := "Thu Feb 2 16:10:03 -0500 2006" // -0500 not EST
817 str := time.Format(UnixDate) // uses MST as its time zone
818 if str != expect {
819 t.Errorf("got %s; expect %s", str, expect)
820 }
821 }
822
823 func TestMinutesInTimeZone(t *testing.T) {
824 time, err := Parse(RubyDate, "Mon Jan 02 15:04:05 +0123 2006")
825 if err != nil {
826 t.Fatal("error parsing date:", err)
827 }
828 expected := (1*60 + 23) * 60
829 _, offset := time.Zone()
830 if offset != expected {
831 t.Errorf("ZoneOffset = %d, want %d", offset, expected)
832 }
833 }
834
835 type SecondsTimeZoneOffsetTest struct {
836 format string
837 value string
838 expectedoffset int
839 }
840
841 var secondsTimeZoneOffsetTests = []SecondsTimeZoneOffsetTest{
842 {"2006-01-02T15:04:05-070000", "1871-01-01T05:33:02-003408", -(34*60 + 8)},
843 {"2006-01-02T15:04:05-07:00:00", "1871-01-01T05:33:02-00:34:08", -(34*60 + 8)},
844 {"2006-01-02T15:04:05-070000", "1871-01-01T05:33:02+003408", 34*60 + 8},
845 {"2006-01-02T15:04:05-07:00:00", "1871-01-01T05:33:02+00:34:08", 34*60 + 8},
846 {"2006-01-02T15:04:05Z070000", "1871-01-01T05:33:02-003408", -(34*60 + 8)},
847 {"2006-01-02T15:04:05Z07:00:00", "1871-01-01T05:33:02+00:34:08", 34*60 + 8},
848 }
849
850 func TestParseSecondsInTimeZone(t *testing.T) {
851 // should accept timezone offsets with seconds like: Zone America/New_York -4:56:02 - LMT 1883 Nov 18 12:03:58
852 for _, test := range secondsTimeZoneOffsetTests {
853 time, err := Parse(test.format, test.value)
854 if err != nil {
855 t.Fatal("error parsing date:", err)
856 }
857 _, offset := time.Zone()
858 if offset != test.expectedoffset {
859 t.Errorf("ZoneOffset = %d, want %d", offset, test.expectedoffset)
860 }
861 }
862 }
863
864 func TestFormatSecondsInTimeZone(t *testing.T) {
865 d := Date(1871, 9, 17, 20, 4, 26, 0, FixedZone("LMT", -(34*60+8)))
866 timestr := d.Format("2006-01-02T15:04:05Z070000")
867 expected := "1871-09-17T20:04:26-003408"
868 if timestr != expected {
869 t.Errorf("Got %s, want %s", timestr, expected)
870 }
871 }
872
873 type ISOWeekTest struct {
874 year int // year
875 month, day int // month and day
876 yex int // expected year
877 wex int // expected week
878 }
879
880 var isoWeekTests = []ISOWeekTest{
881 {1981, 1, 1, 1981, 1}, {1982, 1, 1, 1981, 53}, {1983, 1, 1, 1982, 52},
882 {1984, 1, 1, 1983, 52}, {1985, 1, 1, 1985, 1}, {1986, 1, 1, 1986, 1},
883 {1987, 1, 1, 1987, 1}, {1988, 1, 1, 1987, 53}, {1989, 1, 1, 1988, 52},
884 {1990, 1, 1, 1990, 1}, {1991, 1, 1, 1991, 1}, {1992, 1, 1, 1992, 1},
885 {1993, 1, 1, 1992, 53}, {1994, 1, 1, 1993, 52}, {1995, 1, 2, 1995, 1},
886 {1996, 1, 1, 1996, 1}, {1996, 1, 7, 1996, 1}, {1996, 1, 8, 1996, 2},
887 {1997, 1, 1, 1997, 1}, {1998, 1, 1, 1998, 1}, {1999, 1, 1, 1998, 53},
888 {2000, 1, 1, 1999, 52}, {2001, 1, 1, 2001, 1}, {2002, 1, 1, 2002, 1},
889 {2003, 1, 1, 2003, 1}, {2004, 1, 1, 2004, 1}, {2005, 1, 1, 2004, 53},
890 {2006, 1, 1, 2005, 52}, {2007, 1, 1, 2007, 1}, {2008, 1, 1, 2008, 1},
891 {2009, 1, 1, 2009, 1}, {2010, 1, 1, 2009, 53}, {2010, 1, 1, 2009, 53},
892 {2011, 1, 1, 2010, 52}, {2011, 1, 2, 2010, 52}, {2011, 1, 3, 2011, 1},
893 {2011, 1, 4, 2011, 1}, {2011, 1, 5, 2011, 1}, {2011, 1, 6, 2011, 1},
894 {2011, 1, 7, 2011, 1}, {2011, 1, 8, 2011, 1}, {2011, 1, 9, 2011, 1},
895 {2011, 1, 10, 2011, 2}, {2011, 1, 11, 2011, 2}, {2011, 6, 12, 2011, 23},
896 {2011, 6, 13, 2011, 24}, {2011, 12, 25, 2011, 51}, {2011, 12, 26, 2011, 52},
897 {2011, 12, 27, 2011, 52}, {2011, 12, 28, 2011, 52}, {2011, 12, 29, 2011, 52},
898 {2011, 12, 30, 2011, 52}, {2011, 12, 31, 2011, 52}, {1995, 1, 1, 1994, 52},
899 {2012, 1, 1, 2011, 52}, {2012, 1, 2, 2012, 1}, {2012, 1, 8, 2012, 1},
900 {2012, 1, 9, 2012, 2}, {2012, 12, 23, 2012, 51}, {2012, 12, 24, 2012, 52},
901 {2012, 12, 30, 2012, 52}, {2012, 12, 31, 2013, 1}, {2013, 1, 1, 2013, 1},
902 {2013, 1, 6, 2013, 1}, {2013, 1, 7, 2013, 2}, {2013, 12, 22, 2013, 51},
903 {2013, 12, 23, 2013, 52}, {2013, 12, 29, 2013, 52}, {2013, 12, 30, 2014, 1},
904 {2014, 1, 1, 2014, 1}, {2014, 1, 5, 2014, 1}, {2014, 1, 6, 2014, 2},
905 {2015, 1, 1, 2015, 1}, {2016, 1, 1, 2015, 53}, {2017, 1, 1, 2016, 52},
906 {2018, 1, 1, 2018, 1}, {2019, 1, 1, 2019, 1}, {2020, 1, 1, 2020, 1},
907 {2021, 1, 1, 2020, 53}, {2022, 1, 1, 2021, 52}, {2023, 1, 1, 2022, 52},
908 {2024, 1, 1, 2024, 1}, {2025, 1, 1, 2025, 1}, {2026, 1, 1, 2026, 1},
909 {2027, 1, 1, 2026, 53}, {2028, 1, 1, 2027, 52}, {2029, 1, 1, 2029, 1},
910 {2030, 1, 1, 2030, 1}, {2031, 1, 1, 2031, 1}, {2032, 1, 1, 2032, 1},
911 {2033, 1, 1, 2032, 53}, {2034, 1, 1, 2033, 52}, {2035, 1, 1, 2035, 1},
912 {2036, 1, 1, 2036, 1}, {2037, 1, 1, 2037, 1}, {2038, 1, 1, 2037, 53},
913 {2039, 1, 1, 2038, 52}, {2040, 1, 1, 2039, 52},
914 }
915
916 func TestISOWeek(t *testing.T) {
917 // Selected dates and corner cases
918 for _, wt := range isoWeekTests {
919 dt := Date(wt.year, Month(wt.month), wt.day, 0, 0, 0, 0, UTC)
920 y, w := dt.ISOWeek()
921 if w != wt.wex || y != wt.yex {
922 t.Errorf("got %d/%d; expected %d/%d for %d-%02d-%02d",
923 y, w, wt.yex, wt.wex, wt.year, wt.month, wt.day)
924 }
925 }
926
927 // The only real invariant: Jan 04 is in week 1
928 for year := 1950; year < 2100; year++ {
929 if y, w := Date(year, January, 4, 0, 0, 0, 0, UTC).ISOWeek(); y != year || w != 1 {
930 t.Errorf("got %d/%d; expected %d/1 for Jan 04", y, w, year)
931 }
932 }
933 }
934
935 type YearDayTest struct {
936 year, month, day int
937 yday int
938 }
939
940 // Test YearDay in several different scenarios
941 // and corner cases
942 var yearDayTests = []YearDayTest{
943 // Non-leap-year tests
944 {2007, 1, 1, 1},
945 {2007, 1, 15, 15},
946 {2007, 2, 1, 32},
947 {2007, 2, 15, 46},
948 {2007, 3, 1, 60},
949 {2007, 3, 15, 74},
950 {2007, 4, 1, 91},
951 {2007, 12, 31, 365},
952
953 // Leap-year tests
954 {2008, 1, 1, 1},
955 {2008, 1, 15, 15},
956 {2008, 2, 1, 32},
957 {2008, 2, 15, 46},
958 {2008, 3, 1, 61},
959 {2008, 3, 15, 75},
960 {2008, 4, 1, 92},
961 {2008, 12, 31, 366},
962
963 // Looks like leap-year (but isn't) tests
964 {1900, 1, 1, 1},
965 {1900, 1, 15, 15},
966 {1900, 2, 1, 32},
967 {1900, 2, 15, 46},
968 {1900, 3, 1, 60},
969 {1900, 3, 15, 74},
970 {1900, 4, 1, 91},
971 {1900, 12, 31, 365},
972
973 // Year one tests (non-leap)
974 {1, 1, 1, 1},
975 {1, 1, 15, 15},
976 {1, 2, 1, 32},
977 {1, 2, 15, 46},
978 {1, 3, 1, 60},
979 {1, 3, 15, 74},
980 {1, 4, 1, 91},
981 {1, 12, 31, 365},
982
983 // Year minus one tests (non-leap)
984 {-1, 1, 1, 1},
985 {-1, 1, 15, 15},
986 {-1, 2, 1, 32},
987 {-1, 2, 15, 46},
988 {-1, 3, 1, 60},
989 {-1, 3, 15, 74},
990 {-1, 4, 1, 91},
991 {-1, 12, 31, 365},
992
993 // 400 BC tests (leap-year)
994 {-400, 1, 1, 1},
995 {-400, 1, 15, 15},
996 {-400, 2, 1, 32},
997 {-400, 2, 15, 46},
998 {-400, 3, 1, 61},
999 {-400, 3, 15, 75},
1000 {-400, 4, 1, 92},
1001 {-400, 12, 31, 366},
1002
1003 // Special Cases
1004
1005 // Gregorian calendar change (no effect)
1006 {1582, 10, 4, 277},
1007 {1582, 10, 15, 288},
1008 }
1009
1010 // Check to see if YearDay is location sensitive
1011 var yearDayLocations = []*Location{
1012 FixedZone("UTC-8", -8*60*60),
1013 FixedZone("UTC-4", -4*60*60),
1014 UTC,
1015 FixedZone("UTC+4", 4*60*60),
1016 FixedZone("UTC+8", 8*60*60),
1017 }
1018
1019 func TestYearDay(t *testing.T) {
1020 for _, loc := range yearDayLocations {
1021 for _, ydt := range yearDayTests {
1022 dt := Date(ydt.year, Month(ydt.month), ydt.day, 0, 0, 0, 0, loc)
1023 yday := dt.YearDay()
1024 if yday != ydt.yday {
1025 t.Errorf("got %d, expected %d for %d-%02d-%02d in %v",
1026 yday, ydt.yday, ydt.year, ydt.month, ydt.day, loc)
1027 }
1028 }
1029 }
1030 }
1031
1032 var durationTests = []struct {
1033 str string
1034 d Duration
1035 }{
1036 {"0", 0},
1037 {"1ns", 1 * Nanosecond},
1038 {"1.1us", 1100 * Nanosecond},
1039 {"2.2ms", 2200 * Microsecond},
1040 {"3.3s", 3300 * Millisecond},
1041 {"4m5s", 4*Minute + 5*Second},
1042 {"4m5.001s", 4*Minute + 5001*Millisecond},
1043 {"5h6m7.001s", 5*Hour + 6*Minute + 7001*Millisecond},
1044 {"8m0.000000001s", 8*Minute + 1*Nanosecond},
1045 {"2562047h47m16.854775807s", 1<<63 - 1},
1046 {"-2562047h47m16.854775808s", -1 << 63},
1047 }
1048
1049 func TestDurationString(t *testing.T) {
1050 for _, tt := range durationTests {
1051 if str := tt.d.String(); str != tt.str {
1052 t.Errorf("Duration(%d).String() = %s, want %s", int64(tt.d), str, tt.str)
1053 }
1054 if tt.d > 0 {
1055 if str := (-tt.d).String(); str != "-"+tt.str {
1056 t.Errorf("Duration(%d).String() = %s, want %s", int64(-tt.d), str, "-"+tt.str)
1057 }
1058 }
1059 }
1060 }
1061
1062 var dateTests = []struct {
1063 year, month, day, hour, min, sec, nsec int
1064 z *Location
1065 unix int64
1066 }{
1067 {2011, 11, 6, 1, 0, 0, 0, Local, 1320566400}, // 1:00:00 PDT
1068 {2011, 11, 6, 1, 59, 59, 0, Local, 1320569999}, // 1:59:59 PDT
1069 {2011, 11, 6, 2, 0, 0, 0, Local, 1320573600}, // 2:00:00 PST
1070
1071 {2011, 3, 13, 1, 0, 0, 0, Local, 1300006800}, // 1:00:00 PST
1072 {2011, 3, 13, 1, 59, 59, 0, Local, 1300010399}, // 1:59:59 PST
1073 {2011, 3, 13, 3, 0, 0, 0, Local, 1300010400}, // 3:00:00 PDT
1074 {2011, 3, 13, 2, 30, 0, 0, Local, 1300008600}, // 2:30:00 PDT ≡ 1:30 PST
1075
1076 // Many names for Fri Nov 18 7:56:35 PST 2011
1077 {2011, 11, 18, 7, 56, 35, 0, Local, 1321631795}, // Nov 18 7:56:35
1078 {2011, 11, 19, -17, 56, 35, 0, Local, 1321631795}, // Nov 19 -17:56:35
1079 {2011, 11, 17, 31, 56, 35, 0, Local, 1321631795}, // Nov 17 31:56:35
1080 {2011, 11, 18, 6, 116, 35, 0, Local, 1321631795}, // Nov 18 6:116:35
1081 {2011, 10, 49, 7, 56, 35, 0, Local, 1321631795}, // Oct 49 7:56:35
1082 {2011, 11, 18, 7, 55, 95, 0, Local, 1321631795}, // Nov 18 7:55:95
1083 {2011, 11, 18, 7, 56, 34, 1e9, Local, 1321631795}, // Nov 18 7:56:34 + 10⁹ns
1084 {2011, 12, -12, 7, 56, 35, 0, Local, 1321631795}, // Dec -21 7:56:35
1085 {2012, 1, -43, 7, 56, 35, 0, Local, 1321631795}, // Jan -52 7:56:35 2012
1086 {2012, int(January - 2), 18, 7, 56, 35, 0, Local, 1321631795}, // (Jan-2) 18 7:56:35 2012
1087 {2010, int(December + 11), 18, 7, 56, 35, 0, Local, 1321631795}, // (Dec+11) 18 7:56:35 2010
1088 }
1089
1090 func TestDate(t *testing.T) {
1091 for _, tt := range dateTests {
1092 time := Date(tt.year, Month(tt.month), tt.day, tt.hour, tt.min, tt.sec, tt.nsec, tt.z)
1093 want := Unix(tt.unix, 0)
1094 if !time.Equal(want) {
1095 t.Errorf("Date(%d, %d, %d, %d, %d, %d, %d, %s) = %v, want %v",
1096 tt.year, tt.month, tt.day, tt.hour, tt.min, tt.sec, tt.nsec, tt.z,
1097 time, want)
1098 }
1099 }
1100 }
1101
1102 // Several ways of getting from
1103 // Fri Nov 18 7:56:35 PST 2011
1104 // to
1105 // Thu Mar 19 7:56:35 PST 2016
1106 var addDateTests = []struct {
1107 years, months, days int
1108 }{
1109 {4, 4, 1},
1110 {3, 16, 1},
1111 {3, 15, 30},
1112 {5, -6, -18 - 30 - 12},
1113 }
1114
1115 func TestAddDate(t *testing.T) {
1116 t0 := Date(2011, 11, 18, 7, 56, 35, 0, UTC)
1117 t1 := Date(2016, 3, 19, 7, 56, 35, 0, UTC)
1118 for _, at := range addDateTests {
1119 time := t0.AddDate(at.years, at.months, at.days)
1120 if !time.Equal(t1) {
1121 t.Errorf("AddDate(%d, %d, %d) = %v, want %v",
1122 at.years, at.months, at.days,
1123 time, t1)
1124 }
1125 }
1126 }
1127
1128 var daysInTests = []struct {
1129 year, month, di int
1130 }{
1131 {2011, 1, 31}, // January, first month, 31 days
1132 {2011, 2, 28}, // February, non-leap year, 28 days
1133 {2012, 2, 29}, // February, leap year, 29 days
1134 {2011, 6, 30}, // June, 30 days
1135 {2011, 12, 31}, // December, last month, 31 days
1136 }
1137
1138 func TestDaysIn(t *testing.T) {
1139 // The daysIn function is not exported.
1140 // Test the daysIn function via the `var DaysIn = daysIn`
1141 // statement in the internal_test.go file.
1142 for _, tt := range daysInTests {
1143 di := DaysIn(Month(tt.month), tt.year)
1144 if di != tt.di {
1145 t.Errorf("got %d; expected %d for %d-%02d",
1146 di, tt.di, tt.year, tt.month)
1147 }
1148 }
1149 }
1150
1151 func TestAddToExactSecond(t *testing.T) {
1152 // Add an amount to the current time to round it up to the next exact second.
1153 // This test checks that the nsec field still lies within the range [0, 999999999].
1154 t1 := Now()
1155 t2 := t1.Add(Second - Duration(t1.Nanosecond()))
1156 sec := (t1.Second() + 1) % 60
1157 if t2.Second() != sec || t2.Nanosecond() != 0 {
1158 t.Errorf("sec = %d, nsec = %d, want sec = %d, nsec = 0", t2.Second(), t2.Nanosecond(), sec)
1159 }
1160 }
1161
1162 func equalTimeAndZone(a, b Time) bool {
1163 aname, aoffset := a.Zone()
1164 bname, boffset := b.Zone()
1165 return a.Equal(b) && aoffset == boffset && aname == bname
1166 }
1167
1168 var gobTests = []Time{
1169 Date(0, 1, 2, 3, 4, 5, 6, UTC),
1170 Date(7, 8, 9, 10, 11, 12, 13, FixedZone("", 0)),
1171 Unix(81985467080890095, 0x76543210), // Time.sec: 0x0123456789ABCDEF
1172 {}, // nil location
1173 Date(1, 2, 3, 4, 5, 6, 7, FixedZone("", 32767*60)),
1174 Date(1, 2, 3, 4, 5, 6, 7, FixedZone("", -32768*60)),
1175 }
1176
1177 func TestTimeGob(t *testing.T) {
1178 var b bytes.Buffer
1179 enc := gob.NewEncoder(&b)
1180 dec := gob.NewDecoder(&b)
1181 for _, tt := range gobTests {
1182 var gobtt Time
1183 if err := enc.Encode(&tt); err != nil {
1184 t.Errorf("%v gob Encode error = %q, want nil", tt, err)
1185 } else if err := dec.Decode(&gobtt); err != nil {
1186 t.Errorf("%v gob Decode error = %q, want nil", tt, err)
1187 } else if !equalTimeAndZone(gobtt, tt) {
1188 t.Errorf("Decoded time = %v, want %v", gobtt, tt)
1189 }
1190 b.Reset()
1191 }
1192 }
1193
1194 var invalidEncodingTests = []struct {
1195 bytes []byte
1196 want string
1197 }{
1198 {[]byte{}, "Time.UnmarshalBinary: no data"},
1199 {[]byte{0, 2, 3}, "Time.UnmarshalBinary: unsupported version"},
1200 {[]byte{1, 2, 3}, "Time.UnmarshalBinary: invalid length"},
1201 }
1202
1203 func TestInvalidTimeGob(t *testing.T) {
1204 for _, tt := range invalidEncodingTests {
1205 var ignored Time
1206 err := ignored.GobDecode(tt.bytes)
1207 if err == nil || err.Error() != tt.want {
1208 t.Errorf("time.GobDecode(%#v) error = %v, want %v", tt.bytes, err, tt.want)
1209 }
1210 err = ignored.UnmarshalBinary(tt.bytes)
1211 if err == nil || err.Error() != tt.want {
1212 t.Errorf("time.UnmarshalBinary(%#v) error = %v, want %v", tt.bytes, err, tt.want)
1213 }
1214 }
1215 }
1216
1217 var notEncodableTimes = []struct {
1218 time Time
1219 want string
1220 }{
1221 {Date(0, 1, 2, 3, 4, 5, 6, FixedZone("", 1)), "Time.MarshalBinary: zone offset has fractional minute"},
1222 {Date(0, 1, 2, 3, 4, 5, 6, FixedZone("", -1*60)), "Time.MarshalBinary: unexpected zone offset"},
1223 {Date(0, 1, 2, 3, 4, 5, 6, FixedZone("", -32769*60)), "Time.MarshalBinary: unexpected zone offset"},
1224 {Date(0, 1, 2, 3, 4, 5, 6, FixedZone("", 32768*60)), "Time.MarshalBinary: unexpected zone offset"},
1225 }
1226
1227 func TestNotGobEncodableTime(t *testing.T) {
1228 for _, tt := range notEncodableTimes {
1229 _, err := tt.time.GobEncode()
1230 if err == nil || err.Error() != tt.want {
1231 t.Errorf("%v GobEncode error = %v, want %v", tt.time, err, tt.want)
1232 }
1233 _, err = tt.time.MarshalBinary()
1234 if err == nil || err.Error() != tt.want {
1235 t.Errorf("%v MarshalBinary error = %v, want %v", tt.time, err, tt.want)
1236 }
1237 }
1238 }
1239
1240 var jsonTests = []struct {
1241 time Time
1242 json string
1243 }{
1244 {Date(9999, 4, 12, 23, 20, 50, 520*1e6, UTC), `"9999-04-12T23:20:50.52Z"`},
1245 {Date(1996, 12, 19, 16, 39, 57, 0, Local), `"1996-12-19T16:39:57-08:00"`},
1246 {Date(0, 1, 1, 0, 0, 0, 1, FixedZone("", 1*60)), `"0000-01-01T00:00:00.000000001+00:01"`},
1247 }
1248
1249 func TestTimeJSON(t *testing.T) {
1250 for _, tt := range jsonTests {
1251 var jsonTime Time
1252
1253 if jsonBytes, err := json.Marshal(tt.time); err != nil {
1254 t.Errorf("%v json.Marshal error = %v, want nil", tt.time, err)
1255 } else if string(jsonBytes) != tt.json {
1256 t.Errorf("%v JSON = %#q, want %#q", tt.time, string(jsonBytes), tt.json)
1257 } else if err = json.Unmarshal(jsonBytes, &jsonTime); err != nil {
1258 t.Errorf("%v json.Unmarshal error = %v, want nil", tt.time, err)
1259 } else if !equalTimeAndZone(jsonTime, tt.time) {
1260 t.Errorf("Unmarshaled time = %v, want %v", jsonTime, tt.time)
1261 }
1262 }
1263 }
1264
1265 func TestInvalidTimeJSON(t *testing.T) {
1266 var tt Time
1267 err := json.Unmarshal([]byte(`{"now is the time":"buddy"}`), &tt)
1268 _, isParseErr := err.(*ParseError)
1269 if !isParseErr {
1270 t.Errorf("expected *time.ParseError unmarshaling JSON, got %v", err)
1271 }
1272 }
1273
1274 var notJSONEncodableTimes = []struct {
1275 time Time
1276 want string
1277 }{
1278 {Date(10000, 1, 1, 0, 0, 0, 0, UTC), "Time.MarshalJSON: year outside of range [0,9999]"},
1279 {Date(-1, 1, 1, 0, 0, 0, 0, UTC), "Time.MarshalJSON: year outside of range [0,9999]"},
1280 }
1281
1282 func TestNotJSONEncodableTime(t *testing.T) {
1283 for _, tt := range notJSONEncodableTimes {
1284 _, err := tt.time.MarshalJSON()
1285 if err == nil || err.Error() != tt.want {
1286 t.Errorf("%v MarshalJSON error = %v, want %v", tt.time, err, tt.want)
1287 }
1288 }
1289 }
1290
1291 var parseDurationTests = []struct {
1292 in string
1293 ok bool
1294 want Duration
1295 }{
1296 // simple
1297 {"0", true, 0},
1298 {"5s", true, 5 * Second},
1299 {"30s", true, 30 * Second},
1300 {"1478s", true, 1478 * Second},
1301 // sign
1302 {"-5s", true, -5 * Second},
1303 {"+5s", true, 5 * Second},
1304 {"-0", true, 0},
1305 {"+0", true, 0},
1306 // decimal
1307 {"5.0s", true, 5 * Second},
1308 {"5.6s", true, 5*Second + 600*Millisecond},
1309 {"5.s", true, 5 * Second},
1310 {".5s", true, 500 * Millisecond},
1311 {"1.0s", true, 1 * Second},
1312 {"1.00s", true, 1 * Second},
1313 {"1.004s", true, 1*Second + 4*Millisecond},
1314 {"1.0040s", true, 1*Second + 4*Millisecond},
1315 {"100.00100s", true, 100*Second + 1*Millisecond},
1316 // different units
1317 {"10ns", true, 10 * Nanosecond},
1318 {"11us", true, 11 * Microsecond},
1319 {"12µs", true, 12 * Microsecond}, // U+00B5
1320 {"12μs", true, 12 * Microsecond}, // U+03BC
1321 {"13ms", true, 13 * Millisecond},
1322 {"14s", true, 14 * Second},
1323 {"15m", true, 15 * Minute},
1324 {"16h", true, 16 * Hour},
1325 // composite durations
1326 {"3h30m", true, 3*Hour + 30*Minute},
1327 {"10.5s4m", true, 4*Minute + 10*Second + 500*Millisecond},
1328 {"-2m3.4s", true, -(2*Minute + 3*Second + 400*Millisecond)},
1329 {"1h2m3s4ms5us6ns", true, 1*Hour + 2*Minute + 3*Second + 4*Millisecond + 5*Microsecond + 6*Nanosecond},
1330 {"39h9m14.425s", true, 39*Hour + 9*Minute + 14*Second + 425*Millisecond},
1331 // large value
1332 {"52763797000ns", true, 52763797000 * Nanosecond},
1333 // more than 9 digits after decimal point, see http://golang.org/issue/6617
1334 {"0.3333333333333333333h", true, 20 * Minute},
1335
1336 // errors
1337 {"", false, 0},
1338 {"3", false, 0},
1339 {"-", false, 0},
1340 {"s", false, 0},
1341 {".", false, 0},
1342 {"-.", false, 0},
1343 {".s", false, 0},
1344 {"+.s", false, 0},
1345 }
1346
1347 func TestParseDuration(t *testing.T) {
1348 for _, tc := range parseDurationTests {
1349 d, err := ParseDuration(tc.in)
1350 if tc.ok && (err != nil || d != tc.want) {
1351 t.Errorf("ParseDuration(%q) = %v, %v, want %v, nil", tc.in, d, err, tc.want)
1352 } else if !tc.ok && err == nil {
1353 t.Errorf("ParseDuration(%q) = _, nil, want _, non-nil", tc.in)
1354 }
1355 }
1356 }
1357
1358 func TestParseDurationRoundTrip(t *testing.T) {
1359 for i := 0; i < 100; i++ {
1360 // Resolutions finer than milliseconds will result in
1361 // imprecise round-trips.
1362 d0 := Duration(rand.Int31()) * Millisecond
1363 s := d0.String()
1364 d1, err := ParseDuration(s)
1365 if err != nil || d0 != d1 {
1366 t.Errorf("round-trip failed: %d => %q => %d, %v", d0, s, d1, err)
1367 }
1368 }
1369 }
1370
1371 // golang.org/issue/4622
1372 func TestLocationRace(t *testing.T) {
1373 ResetLocalOnceForTest() // reset the Once to trigger the race
1374
1375 c := make(chan string, 1)
1376 go func() {
1377 c <- Now().String()
1378 }()
1379 Now().String()
1380 <-c
1381 Sleep(100 * Millisecond)
1382
1383 // Back to Los Angeles for subsequent tests:
1384 ForceUSPacificForTesting()
1385 }
1386
1387 var (
1388 t Time
1389 u int64
1390 )
1391
1392 var mallocTest = []struct {
1393 count int
1394 desc string
1395 fn func()
1396 }{
1397 {0, `time.Now()`, func() { t = Now() }},
1398 {0, `time.Now().UnixNano()`, func() { u = Now().UnixNano() }},
1399 }
1400
1401 func TestCountMallocs(t *testing.T) {
1402 if testing.Short() {
1403 t.Skip("skipping malloc count in short mode")
1404 }
1405 if runtime.GOMAXPROCS(0) > 1 {
1406 t.Skip("skipping; GOMAXPROCS>1")
1407 }
1408 for _, mt := range mallocTest {
1409 allocs := int(testing.AllocsPerRun(100, mt.fn))
1410 if allocs > mt.count {
1411 t.Errorf("%s: %d allocs, want %d", mt.desc, allocs, mt.count)
1412 }
1413 }
1414 }
1415
1416 func TestLoadFixed(t *testing.T) {
1417 // Issue 4064: handle locations without any zone transitions.
1418 loc, err := LoadLocation("Etc/GMT+1")
1419 if err != nil {
1420 t.Fatal(err)
1421 }
1422
1423 // The tzdata name Etc/GMT+1 uses "east is negative",
1424 // but Go and most other systems use "east is positive".
1425 // So GMT+1 corresponds to -3600 in the Go zone, not +3600.
1426 name, offset := Now().In(loc).Zone()
1427 if name != "GMT+1" || offset != -1*60*60 {
1428 t.Errorf("Now().In(loc).Zone() = %q, %d, want %q, %d", name, offset, "GMT+1", -1*60*60)
1429 }
1430 }
1431
1432 const (
1433 minDuration Duration = -1 << 63
1434 maxDuration Duration = 1<<63 - 1
1435 )
1436
1437 var subTests = []struct {
1438 t Time
1439 u Time
1440 d Duration
1441 }{
1442 {Time{}, Time{}, Duration(0)},
1443 {Date(2009, 11, 23, 0, 0, 0, 1, UTC), Date(2009, 11, 23, 0, 0, 0, 0, UTC), Duration(1)},
1444 {Date(2009, 11, 23, 0, 0, 0, 0, UTC), Date(2009, 11, 24, 0, 0, 0, 0, UTC), -24 * Hour},
1445 {Date(2009, 11, 24, 0, 0, 0, 0, UTC), Date(2009, 11, 23, 0, 0, 0, 0, UTC), 24 * Hour},
1446 {Date(-2009, 11, 24, 0, 0, 0, 0, UTC), Date(-2009, 11, 23, 0, 0, 0, 0, UTC), 24 * Hour},
1447 {Time{}, Date(2109, 11, 23, 0, 0, 0, 0, UTC), Duration(minDuration)},
1448 {Date(2109, 11, 23, 0, 0, 0, 0, UTC), Time{}, Duration(maxDuration)},
1449 {Time{}, Date(-2109, 11, 23, 0, 0, 0, 0, UTC), Duration(maxDuration)},
1450 {Date(-2109, 11, 23, 0, 0, 0, 0, UTC), Time{}, Duration(minDuration)},
1451 {Date(2290, 1, 1, 0, 0, 0, 0, UTC), Date(2000, 1, 1, 0, 0, 0, 0, UTC), 290*365*24*Hour + 71*24*Hour},
1452 {Date(2300, 1, 1, 0, 0, 0, 0, UTC), Date(2000, 1, 1, 0, 0, 0, 0, UTC), Duration(maxDuration)},
1453 {Date(2000, 1, 1, 0, 0, 0, 0, UTC), Date(2290, 1, 1, 0, 0, 0, 0, UTC), -290*365*24*Hour - 71*24*Hour},
1454 {Date(2000, 1, 1, 0, 0, 0, 0, UTC), Date(2300, 1, 1, 0, 0, 0, 0, UTC), Duration(minDuration)},
1455 }
1456
1457 func TestSub(t *testing.T) {
1458 for i, st := range subTests {
1459 got := st.t.Sub(st.u)
1460 if got != st.d {
1461 t.Errorf("#%d: Sub(%v, %v): got %v; want %v", i, st.t, st.u, got, st.d)
1462 }
1463 }
1464 }
1465
1466 func BenchmarkNow(b *testing.B) {
1467 for i := 0; i < b.N; i++ {
1468 t = Now()
1469 }
1470 }
1471
1472 func BenchmarkNowUnixNano(b *testing.B) {
1473 for i := 0; i < b.N; i++ {
1474 u = Now().UnixNano()
1475 }
1476 }
1477
1478 func BenchmarkFormat(b *testing.B) {
1479 t := Unix(1265346057, 0)
1480 for i := 0; i < b.N; i++ {
1481 t.Format("Mon Jan 2 15:04:05 2006")
1482 }
1483 }
1484
1485 func BenchmarkFormatNow(b *testing.B) {
1486 // Like BenchmarkFormat, but easier, because the time zone
1487 // lookup cache is optimized for the present.
1488 t := Now()
1489 for i := 0; i < b.N; i++ {
1490 t.Format("Mon Jan 2 15:04:05 2006")
1491 }
1492 }
1493
1494 func BenchmarkParse(b *testing.B) {
1495 for i := 0; i < b.N; i++ {
1496 Parse(ANSIC, "Mon Jan 2 15:04:05 2006")
1497 }
1498 }
1499
1500 func BenchmarkHour(b *testing.B) {
1501 t := Now()
1502 for i := 0; i < b.N; i++ {
1503 _ = t.Hour()
1504 }
1505 }
1506
1507 func BenchmarkSecond(b *testing.B) {
1508 t := Now()
1509 for i := 0; i < b.N; i++ {
1510 _ = t.Second()
1511 }
1512 }
1513
1514 func BenchmarkYear(b *testing.B) {
1515 t := Now()
1516 for i := 0; i < b.N; i++ {
1517 _ = t.Year()
1518 }
1519 }
1520
1521 func BenchmarkDay(b *testing.B) {
1522 t := Now()
1523 for i := 0; i < b.N; i++ {
1524 _ = t.Day()
1525 }
1526 }
Mirror of the offical gcc git repository hosted at gcc.gnu.org