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 5package time_test 6 7import ( 8 "bytes" 9 "encoding/gob" 10 "encoding/json" 11 "fmt" 12 "math/big" 13 "math/rand" 14 "os" 15 "runtime" 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. 25func 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. 35type 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 46type TimeTest struct { 47 seconds int64 48 golden parsedTime 49} 50 51var 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 60var 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 65var 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 70var 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 75func 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 96func 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 113func 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 130func 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 147func 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 164func 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 178func 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. 204const unixToZero = -978307200 + 63113904000 205 206// abs returns the absolute time stored in t, as seconds and nanoseconds. 207func 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. 214func 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 228var 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 {Unix(-19012425939, 649146258), 7435029458905025217}, // 5.8*d rounds to 6*d, but .8*d+.8*d < 0 < d 237} 238 239func TestTruncateRound(t *testing.T) { 240 var ( 241 bsec = new(big.Int) 242 bnsec = new(big.Int) 243 bd = new(big.Int) 244 bt = new(big.Int) 245 br = new(big.Int) 246 bq = new(big.Int) 247 b1e9 = new(big.Int) 248 ) 249 250 b1e9.SetInt64(1e9) 251 252 testOne := func(ti, tns, di int64) bool { 253 t0 := Unix(ti, int64(tns)).UTC() 254 d := Duration(di) 255 if d < 0 { 256 d = -d 257 } 258 if d <= 0 { 259 d = 1 260 } 261 262 // Compute bt = absolute nanoseconds. 263 sec, nsec := abs(t0) 264 bsec.SetInt64(sec) 265 bnsec.SetInt64(nsec) 266 bt.Mul(bsec, b1e9) 267 bt.Add(bt, bnsec) 268 269 // Compute quotient and remainder mod d. 270 bd.SetInt64(int64(d)) 271 bq.DivMod(bt, bd, br) 272 273 // To truncate, subtract remainder. 274 // br is < d, so it fits in an int64. 275 r := br.Int64() 276 t1 := t0.Add(-Duration(r)) 277 278 // Check that time.Truncate works. 279 if trunc := t0.Truncate(d); trunc != t1 { 280 t.Errorf("Time.Truncate(%s, %s) = %s, want %s\n"+ 281 "%v trunc %v =\n%v want\n%v", 282 t0.Format(RFC3339Nano), d, trunc, t1.Format(RFC3339Nano), 283 absString(t0), int64(d), absString(trunc), absString(t1)) 284 return false 285 } 286 287 // To round, add d back if remainder r > d/2 or r == exactly d/2. 288 // The commented out code would round half to even instead of up, 289 // but that makes it time-zone dependent, which is a bit strange. 290 if r > int64(d)/2 || r+r == int64(d) /*&& bq.Bit(0) == 1*/ { 291 t1 = t1.Add(Duration(d)) 292 } 293 294 // Check that time.Round works. 295 if rnd := t0.Round(d); rnd != t1 { 296 t.Errorf("Time.Round(%s, %s) = %s, want %s\n"+ 297 "%v round %v =\n%v want\n%v", 298 t0.Format(RFC3339Nano), d, rnd, t1.Format(RFC3339Nano), 299 absString(t0), int64(d), absString(rnd), absString(t1)) 300 return false 301 } 302 return true 303 } 304 305 // manual test cases 306 for _, tt := range truncateRoundTests { 307 testOne(tt.t.Unix(), int64(tt.t.Nanosecond()), int64(tt.d)) 308 } 309 310 // exhaustive near 0 311 for i := 0; i < 100; i++ { 312 for j := 1; j < 100; j++ { 313 testOne(unixToZero, int64(i), int64(j)) 314 testOne(unixToZero, -int64(i), int64(j)) 315 if t.Failed() { 316 return 317 } 318 } 319 } 320 321 if t.Failed() { 322 return 323 } 324 325 // randomly generated test cases 326 cfg := &quick.Config{MaxCount: 100000} 327 if testing.Short() { 328 cfg.MaxCount = 1000 329 } 330 331 // divisors of Second 332 f1 := func(ti int64, tns int32, logdi int32) bool { 333 d := Duration(1) 334 a, b := uint(logdi%9), (logdi>>16)%9 335 d <<= a 336 for i := 0; i < int(b); i++ { 337 d *= 5 338 } 339 return testOne(ti, int64(tns), int64(d)) 340 } 341 quick.Check(f1, cfg) 342 343 // multiples of Second 344 f2 := func(ti int64, tns int32, di int32) bool { 345 d := Duration(di) * Second 346 if d < 0 { 347 d = -d 348 } 349 return testOne(ti, int64(tns), int64(d)) 350 } 351 quick.Check(f2, cfg) 352 353 // halfway cases 354 f3 := func(tns, di int64) bool { 355 di &= 0xfffffffe 356 if di == 0 { 357 di = 2 358 } 359 tns -= tns % di 360 if tns < 0 { 361 tns += di / 2 362 } else { 363 tns -= di / 2 364 } 365 return testOne(0, tns, di) 366 } 367 quick.Check(f3, cfg) 368 369 // full generality 370 f4 := func(ti int64, tns int32, di int64) bool { 371 return testOne(ti, int64(tns), di) 372 } 373 quick.Check(f4, cfg) 374} 375 376type ISOWeekTest struct { 377 year int // year 378 month, day int // month and day 379 yex int // expected year 380 wex int // expected week 381} 382 383var isoWeekTests = []ISOWeekTest{ 384 {1981, 1, 1, 1981, 1}, {1982, 1, 1, 1981, 53}, {1983, 1, 1, 1982, 52}, 385 {1984, 1, 1, 1983, 52}, {1985, 1, 1, 1985, 1}, {1986, 1, 1, 1986, 1}, 386 {1987, 1, 1, 1987, 1}, {1988, 1, 1, 1987, 53}, {1989, 1, 1, 1988, 52}, 387 {1990, 1, 1, 1990, 1}, {1991, 1, 1, 1991, 1}, {1992, 1, 1, 1992, 1}, 388 {1993, 1, 1, 1992, 53}, {1994, 1, 1, 1993, 52}, {1995, 1, 2, 1995, 1}, 389 {1996, 1, 1, 1996, 1}, {1996, 1, 7, 1996, 1}, {1996, 1, 8, 1996, 2}, 390 {1997, 1, 1, 1997, 1}, {1998, 1, 1, 1998, 1}, {1999, 1, 1, 1998, 53}, 391 {2000, 1, 1, 1999, 52}, {2001, 1, 1, 2001, 1}, {2002, 1, 1, 2002, 1}, 392 {2003, 1, 1, 2003, 1}, {2004, 1, 1, 2004, 1}, {2005, 1, 1, 2004, 53}, 393 {2006, 1, 1, 2005, 52}, {2007, 1, 1, 2007, 1}, {2008, 1, 1, 2008, 1}, 394 {2009, 1, 1, 2009, 1}, {2010, 1, 1, 2009, 53}, {2010, 1, 1, 2009, 53}, 395 {2011, 1, 1, 2010, 52}, {2011, 1, 2, 2010, 52}, {2011, 1, 3, 2011, 1}, 396 {2011, 1, 4, 2011, 1}, {2011, 1, 5, 2011, 1}, {2011, 1, 6, 2011, 1}, 397 {2011, 1, 7, 2011, 1}, {2011, 1, 8, 2011, 1}, {2011, 1, 9, 2011, 1}, 398 {2011, 1, 10, 2011, 2}, {2011, 1, 11, 2011, 2}, {2011, 6, 12, 2011, 23}, 399 {2011, 6, 13, 2011, 24}, {2011, 12, 25, 2011, 51}, {2011, 12, 26, 2011, 52}, 400 {2011, 12, 27, 2011, 52}, {2011, 12, 28, 2011, 52}, {2011, 12, 29, 2011, 52}, 401 {2011, 12, 30, 2011, 52}, {2011, 12, 31, 2011, 52}, {1995, 1, 1, 1994, 52}, 402 {2012, 1, 1, 2011, 52}, {2012, 1, 2, 2012, 1}, {2012, 1, 8, 2012, 1}, 403 {2012, 1, 9, 2012, 2}, {2012, 12, 23, 2012, 51}, {2012, 12, 24, 2012, 52}, 404 {2012, 12, 30, 2012, 52}, {2012, 12, 31, 2013, 1}, {2013, 1, 1, 2013, 1}, 405 {2013, 1, 6, 2013, 1}, {2013, 1, 7, 2013, 2}, {2013, 12, 22, 2013, 51}, 406 {2013, 12, 23, 2013, 52}, {2013, 12, 29, 2013, 52}, {2013, 12, 30, 2014, 1}, 407 {2014, 1, 1, 2014, 1}, {2014, 1, 5, 2014, 1}, {2014, 1, 6, 2014, 2}, 408 {2015, 1, 1, 2015, 1}, {2016, 1, 1, 2015, 53}, {2017, 1, 1, 2016, 52}, 409 {2018, 1, 1, 2018, 1}, {2019, 1, 1, 2019, 1}, {2020, 1, 1, 2020, 1}, 410 {2021, 1, 1, 2020, 53}, {2022, 1, 1, 2021, 52}, {2023, 1, 1, 2022, 52}, 411 {2024, 1, 1, 2024, 1}, {2025, 1, 1, 2025, 1}, {2026, 1, 1, 2026, 1}, 412 {2027, 1, 1, 2026, 53}, {2028, 1, 1, 2027, 52}, {2029, 1, 1, 2029, 1}, 413 {2030, 1, 1, 2030, 1}, {2031, 1, 1, 2031, 1}, {2032, 1, 1, 2032, 1}, 414 {2033, 1, 1, 2032, 53}, {2034, 1, 1, 2033, 52}, {2035, 1, 1, 2035, 1}, 415 {2036, 1, 1, 2036, 1}, {2037, 1, 1, 2037, 1}, {2038, 1, 1, 2037, 53}, 416 {2039, 1, 1, 2038, 52}, {2040, 1, 1, 2039, 52}, 417} 418 419func TestISOWeek(t *testing.T) { 420 // Selected dates and corner cases 421 for _, wt := range isoWeekTests { 422 dt := Date(wt.year, Month(wt.month), wt.day, 0, 0, 0, 0, UTC) 423 y, w := dt.ISOWeek() 424 if w != wt.wex || y != wt.yex { 425 t.Errorf("got %d/%d; expected %d/%d for %d-%02d-%02d", 426 y, w, wt.yex, wt.wex, wt.year, wt.month, wt.day) 427 } 428 } 429 430 // The only real invariant: Jan 04 is in week 1 431 for year := 1950; year < 2100; year++ { 432 if y, w := Date(year, January, 4, 0, 0, 0, 0, UTC).ISOWeek(); y != year || w != 1 { 433 t.Errorf("got %d/%d; expected %d/1 for Jan 04", y, w, year) 434 } 435 } 436} 437 438type YearDayTest struct { 439 year, month, day int 440 yday int 441} 442 443// Test YearDay in several different scenarios 444// and corner cases 445var yearDayTests = []YearDayTest{ 446 // Non-leap-year tests 447 {2007, 1, 1, 1}, 448 {2007, 1, 15, 15}, 449 {2007, 2, 1, 32}, 450 {2007, 2, 15, 46}, 451 {2007, 3, 1, 60}, 452 {2007, 3, 15, 74}, 453 {2007, 4, 1, 91}, 454 {2007, 12, 31, 365}, 455 456 // Leap-year tests 457 {2008, 1, 1, 1}, 458 {2008, 1, 15, 15}, 459 {2008, 2, 1, 32}, 460 {2008, 2, 15, 46}, 461 {2008, 3, 1, 61}, 462 {2008, 3, 15, 75}, 463 {2008, 4, 1, 92}, 464 {2008, 12, 31, 366}, 465 466 // Looks like leap-year (but isn't) tests 467 {1900, 1, 1, 1}, 468 {1900, 1, 15, 15}, 469 {1900, 2, 1, 32}, 470 {1900, 2, 15, 46}, 471 {1900, 3, 1, 60}, 472 {1900, 3, 15, 74}, 473 {1900, 4, 1, 91}, 474 {1900, 12, 31, 365}, 475 476 // Year one tests (non-leap) 477 {1, 1, 1, 1}, 478 {1, 1, 15, 15}, 479 {1, 2, 1, 32}, 480 {1, 2, 15, 46}, 481 {1, 3, 1, 60}, 482 {1, 3, 15, 74}, 483 {1, 4, 1, 91}, 484 {1, 12, 31, 365}, 485 486 // Year minus one tests (non-leap) 487 {-1, 1, 1, 1}, 488 {-1, 1, 15, 15}, 489 {-1, 2, 1, 32}, 490 {-1, 2, 15, 46}, 491 {-1, 3, 1, 60}, 492 {-1, 3, 15, 74}, 493 {-1, 4, 1, 91}, 494 {-1, 12, 31, 365}, 495 496 // 400 BC tests (leap-year) 497 {-400, 1, 1, 1}, 498 {-400, 1, 15, 15}, 499 {-400, 2, 1, 32}, 500 {-400, 2, 15, 46}, 501 {-400, 3, 1, 61}, 502 {-400, 3, 15, 75}, 503 {-400, 4, 1, 92}, 504 {-400, 12, 31, 366}, 505 506 // Special Cases 507 508 // Gregorian calendar change (no effect) 509 {1582, 10, 4, 277}, 510 {1582, 10, 15, 288}, 511} 512 513// Check to see if YearDay is location sensitive 514var yearDayLocations = []*Location{ 515 FixedZone("UTC-8", -8*60*60), 516 FixedZone("UTC-4", -4*60*60), 517 UTC, 518 FixedZone("UTC+4", 4*60*60), 519 FixedZone("UTC+8", 8*60*60), 520} 521 522func TestYearDay(t *testing.T) { 523 for _, loc := range yearDayLocations { 524 for _, ydt := range yearDayTests { 525 dt := Date(ydt.year, Month(ydt.month), ydt.day, 0, 0, 0, 0, loc) 526 yday := dt.YearDay() 527 if yday != ydt.yday { 528 t.Errorf("got %d, expected %d for %d-%02d-%02d in %v", 529 yday, ydt.yday, ydt.year, ydt.month, ydt.day, loc) 530 } 531 } 532 } 533} 534 535var durationTests = []struct { 536 str string 537 d Duration 538}{ 539 {"0s", 0}, 540 {"1ns", 1 * Nanosecond}, 541 {"1.1µs", 1100 * Nanosecond}, 542 {"2.2ms", 2200 * Microsecond}, 543 {"3.3s", 3300 * Millisecond}, 544 {"4m5s", 4*Minute + 5*Second}, 545 {"4m5.001s", 4*Minute + 5001*Millisecond}, 546 {"5h6m7.001s", 5*Hour + 6*Minute + 7001*Millisecond}, 547 {"8m0.000000001s", 8*Minute + 1*Nanosecond}, 548 {"2562047h47m16.854775807s", 1<<63 - 1}, 549 {"-2562047h47m16.854775808s", -1 << 63}, 550} 551 552func TestDurationString(t *testing.T) { 553 for _, tt := range durationTests { 554 if str := tt.d.String(); str != tt.str { 555 t.Errorf("Duration(%d).String() = %s, want %s", int64(tt.d), str, tt.str) 556 } 557 if tt.d > 0 { 558 if str := (-tt.d).String(); str != "-"+tt.str { 559 t.Errorf("Duration(%d).String() = %s, want %s", int64(-tt.d), str, "-"+tt.str) 560 } 561 } 562 } 563} 564 565var dateTests = []struct { 566 year, month, day, hour, min, sec, nsec int 567 z *Location 568 unix int64 569}{ 570 {2011, 11, 6, 1, 0, 0, 0, Local, 1320566400}, // 1:00:00 PDT 571 {2011, 11, 6, 1, 59, 59, 0, Local, 1320569999}, // 1:59:59 PDT 572 {2011, 11, 6, 2, 0, 0, 0, Local, 1320573600}, // 2:00:00 PST 573 574 {2011, 3, 13, 1, 0, 0, 0, Local, 1300006800}, // 1:00:00 PST 575 {2011, 3, 13, 1, 59, 59, 0, Local, 1300010399}, // 1:59:59 PST 576 {2011, 3, 13, 3, 0, 0, 0, Local, 1300010400}, // 3:00:00 PDT 577 {2011, 3, 13, 2, 30, 0, 0, Local, 1300008600}, // 2:30:00 PDT ≡ 1:30 PST 578 {2012, 12, 24, 0, 0, 0, 0, Local, 1356336000}, // Leap year 579 580 // Many names for Fri Nov 18 7:56:35 PST 2011 581 {2011, 11, 18, 7, 56, 35, 0, Local, 1321631795}, // Nov 18 7:56:35 582 {2011, 11, 19, -17, 56, 35, 0, Local, 1321631795}, // Nov 19 -17:56:35 583 {2011, 11, 17, 31, 56, 35, 0, Local, 1321631795}, // Nov 17 31:56:35 584 {2011, 11, 18, 6, 116, 35, 0, Local, 1321631795}, // Nov 18 6:116:35 585 {2011, 10, 49, 7, 56, 35, 0, Local, 1321631795}, // Oct 49 7:56:35 586 {2011, 11, 18, 7, 55, 95, 0, Local, 1321631795}, // Nov 18 7:55:95 587 {2011, 11, 18, 7, 56, 34, 1e9, Local, 1321631795}, // Nov 18 7:56:34 + 10⁹ns 588 {2011, 12, -12, 7, 56, 35, 0, Local, 1321631795}, // Dec -21 7:56:35 589 {2012, 1, -43, 7, 56, 35, 0, Local, 1321631795}, // Jan -52 7:56:35 2012 590 {2012, int(January - 2), 18, 7, 56, 35, 0, Local, 1321631795}, // (Jan-2) 18 7:56:35 2012 591 {2010, int(December + 11), 18, 7, 56, 35, 0, Local, 1321631795}, // (Dec+11) 18 7:56:35 2010 592} 593 594func TestDate(t *testing.T) { 595 for _, tt := range dateTests { 596 time := Date(tt.year, Month(tt.month), tt.day, tt.hour, tt.min, tt.sec, tt.nsec, tt.z) 597 want := Unix(tt.unix, 0) 598 if !time.Equal(want) { 599 t.Errorf("Date(%d, %d, %d, %d, %d, %d, %d, %s) = %v, want %v", 600 tt.year, tt.month, tt.day, tt.hour, tt.min, tt.sec, tt.nsec, tt.z, 601 time, want) 602 } 603 } 604} 605 606// Several ways of getting from 607// Fri Nov 18 7:56:35 PST 2011 608// to 609// Thu Mar 19 7:56:35 PST 2016 610var addDateTests = []struct { 611 years, months, days int 612}{ 613 {4, 4, 1}, 614 {3, 16, 1}, 615 {3, 15, 30}, 616 {5, -6, -18 - 30 - 12}, 617} 618 619func TestAddDate(t *testing.T) { 620 t0 := Date(2011, 11, 18, 7, 56, 35, 0, UTC) 621 t1 := Date(2016, 3, 19, 7, 56, 35, 0, UTC) 622 for _, at := range addDateTests { 623 time := t0.AddDate(at.years, at.months, at.days) 624 if !time.Equal(t1) { 625 t.Errorf("AddDate(%d, %d, %d) = %v, want %v", 626 at.years, at.months, at.days, 627 time, t1) 628 } 629 } 630} 631 632var daysInTests = []struct { 633 year, month, di int 634}{ 635 {2011, 1, 31}, // January, first month, 31 days 636 {2011, 2, 28}, // February, non-leap year, 28 days 637 {2012, 2, 29}, // February, leap year, 29 days 638 {2011, 6, 30}, // June, 30 days 639 {2011, 12, 31}, // December, last month, 31 days 640} 641 642func TestDaysIn(t *testing.T) { 643 // The daysIn function is not exported. 644 // Test the daysIn function via the `var DaysIn = daysIn` 645 // statement in the internal_test.go file. 646 for _, tt := range daysInTests { 647 di := DaysIn(Month(tt.month), tt.year) 648 if di != tt.di { 649 t.Errorf("got %d; expected %d for %d-%02d", 650 di, tt.di, tt.year, tt.month) 651 } 652 } 653} 654 655func TestAddToExactSecond(t *testing.T) { 656 // Add an amount to the current time to round it up to the next exact second. 657 // This test checks that the nsec field still lies within the range [0, 999999999]. 658 t1 := Now() 659 t2 := t1.Add(Second - Duration(t1.Nanosecond())) 660 sec := (t1.Second() + 1) % 60 661 if t2.Second() != sec || t2.Nanosecond() != 0 { 662 t.Errorf("sec = %d, nsec = %d, want sec = %d, nsec = 0", t2.Second(), t2.Nanosecond(), sec) 663 } 664} 665 666func equalTimeAndZone(a, b Time) bool { 667 aname, aoffset := a.Zone() 668 bname, boffset := b.Zone() 669 return a.Equal(b) && aoffset == boffset && aname == bname 670} 671 672var gobTests = []Time{ 673 Date(0, 1, 2, 3, 4, 5, 6, UTC), 674 Date(7, 8, 9, 10, 11, 12, 13, FixedZone("", 0)), 675 Unix(81985467080890095, 0x76543210), // Time.sec: 0x0123456789ABCDEF 676 {}, // nil location 677 Date(1, 2, 3, 4, 5, 6, 7, FixedZone("", 32767*60)), 678 Date(1, 2, 3, 4, 5, 6, 7, FixedZone("", -32768*60)), 679} 680 681func TestTimeGob(t *testing.T) { 682 var b bytes.Buffer 683 enc := gob.NewEncoder(&b) 684 dec := gob.NewDecoder(&b) 685 for _, tt := range gobTests { 686 var gobtt Time 687 if err := enc.Encode(&tt); err != nil { 688 t.Errorf("%v gob Encode error = %q, want nil", tt, err) 689 } else if err := dec.Decode(&gobtt); err != nil { 690 t.Errorf("%v gob Decode error = %q, want nil", tt, err) 691 } else if !equalTimeAndZone(gobtt, tt) { 692 t.Errorf("Decoded time = %v, want %v", gobtt, tt) 693 } 694 b.Reset() 695 } 696} 697 698var invalidEncodingTests = []struct { 699 bytes []byte 700 want string 701}{ 702 {[]byte{}, "Time.UnmarshalBinary: no data"}, 703 {[]byte{0, 2, 3}, "Time.UnmarshalBinary: unsupported version"}, 704 {[]byte{1, 2, 3}, "Time.UnmarshalBinary: invalid length"}, 705} 706 707func TestInvalidTimeGob(t *testing.T) { 708 for _, tt := range invalidEncodingTests { 709 var ignored Time 710 err := ignored.GobDecode(tt.bytes) 711 if err == nil || err.Error() != tt.want { 712 t.Errorf("time.GobDecode(%#v) error = %v, want %v", tt.bytes, err, tt.want) 713 } 714 err = ignored.UnmarshalBinary(tt.bytes) 715 if err == nil || err.Error() != tt.want { 716 t.Errorf("time.UnmarshalBinary(%#v) error = %v, want %v", tt.bytes, err, tt.want) 717 } 718 } 719} 720 721var notEncodableTimes = []struct { 722 time Time 723 want string 724}{ 725 {Date(0, 1, 2, 3, 4, 5, 6, FixedZone("", 1)), "Time.MarshalBinary: zone offset has fractional minute"}, 726 {Date(0, 1, 2, 3, 4, 5, 6, FixedZone("", -1*60)), "Time.MarshalBinary: unexpected zone offset"}, 727 {Date(0, 1, 2, 3, 4, 5, 6, FixedZone("", -32769*60)), "Time.MarshalBinary: unexpected zone offset"}, 728 {Date(0, 1, 2, 3, 4, 5, 6, FixedZone("", 32768*60)), "Time.MarshalBinary: unexpected zone offset"}, 729} 730 731func TestNotGobEncodableTime(t *testing.T) { 732 for _, tt := range notEncodableTimes { 733 _, err := tt.time.GobEncode() 734 if err == nil || err.Error() != tt.want { 735 t.Errorf("%v GobEncode error = %v, want %v", tt.time, err, tt.want) 736 } 737 _, err = tt.time.MarshalBinary() 738 if err == nil || err.Error() != tt.want { 739 t.Errorf("%v MarshalBinary error = %v, want %v", tt.time, err, tt.want) 740 } 741 } 742} 743 744var jsonTests = []struct { 745 time Time 746 json string 747}{ 748 {Date(9999, 4, 12, 23, 20, 50, 520*1e6, UTC), `"9999-04-12T23:20:50.52Z"`}, 749 {Date(1996, 12, 19, 16, 39, 57, 0, Local), `"1996-12-19T16:39:57-08:00"`}, 750 {Date(0, 1, 1, 0, 0, 0, 1, FixedZone("", 1*60)), `"0000-01-01T00:00:00.000000001+00:01"`}, 751} 752 753func TestTimeJSON(t *testing.T) { 754 for _, tt := range jsonTests { 755 var jsonTime Time 756 757 if jsonBytes, err := json.Marshal(tt.time); err != nil { 758 t.Errorf("%v json.Marshal error = %v, want nil", tt.time, err) 759 } else if string(jsonBytes) != tt.json { 760 t.Errorf("%v JSON = %#q, want %#q", tt.time, string(jsonBytes), tt.json) 761 } else if err = json.Unmarshal(jsonBytes, &jsonTime); err != nil { 762 t.Errorf("%v json.Unmarshal error = %v, want nil", tt.time, err) 763 } else if !equalTimeAndZone(jsonTime, tt.time) { 764 t.Errorf("Unmarshaled time = %v, want %v", jsonTime, tt.time) 765 } 766 } 767} 768 769func TestInvalidTimeJSON(t *testing.T) { 770 var tt Time 771 err := json.Unmarshal([]byte(`{"now is the time":"buddy"}`), &tt) 772 _, isParseErr := err.(*ParseError) 773 if !isParseErr { 774 t.Errorf("expected *time.ParseError unmarshaling JSON, got %v", err) 775 } 776} 777 778var notJSONEncodableTimes = []struct { 779 time Time 780 want string 781}{ 782 {Date(10000, 1, 1, 0, 0, 0, 0, UTC), "Time.MarshalJSON: year outside of range [0,9999]"}, 783 {Date(-1, 1, 1, 0, 0, 0, 0, UTC), "Time.MarshalJSON: year outside of range [0,9999]"}, 784} 785 786func TestNotJSONEncodableTime(t *testing.T) { 787 for _, tt := range notJSONEncodableTimes { 788 _, err := tt.time.MarshalJSON() 789 if err == nil || err.Error() != tt.want { 790 t.Errorf("%v MarshalJSON error = %v, want %v", tt.time, err, tt.want) 791 } 792 } 793} 794 795var parseDurationTests = []struct { 796 in string 797 ok bool 798 want Duration 799}{ 800 // simple 801 {"0", true, 0}, 802 {"5s", true, 5 * Second}, 803 {"30s", true, 30 * Second}, 804 {"1478s", true, 1478 * Second}, 805 // sign 806 {"-5s", true, -5 * Second}, 807 {"+5s", true, 5 * Second}, 808 {"-0", true, 0}, 809 {"+0", true, 0}, 810 // decimal 811 {"5.0s", true, 5 * Second}, 812 {"5.6s", true, 5*Second + 600*Millisecond}, 813 {"5.s", true, 5 * Second}, 814 {".5s", true, 500 * Millisecond}, 815 {"1.0s", true, 1 * Second}, 816 {"1.00s", true, 1 * Second}, 817 {"1.004s", true, 1*Second + 4*Millisecond}, 818 {"1.0040s", true, 1*Second + 4*Millisecond}, 819 {"100.00100s", true, 100*Second + 1*Millisecond}, 820 // different units 821 {"10ns", true, 10 * Nanosecond}, 822 {"11us", true, 11 * Microsecond}, 823 {"12µs", true, 12 * Microsecond}, // U+00B5 824 {"12μs", true, 12 * Microsecond}, // U+03BC 825 {"13ms", true, 13 * Millisecond}, 826 {"14s", true, 14 * Second}, 827 {"15m", true, 15 * Minute}, 828 {"16h", true, 16 * Hour}, 829 // composite durations 830 {"3h30m", true, 3*Hour + 30*Minute}, 831 {"10.5s4m", true, 4*Minute + 10*Second + 500*Millisecond}, 832 {"-2m3.4s", true, -(2*Minute + 3*Second + 400*Millisecond)}, 833 {"1h2m3s4ms5us6ns", true, 1*Hour + 2*Minute + 3*Second + 4*Millisecond + 5*Microsecond + 6*Nanosecond}, 834 {"39h9m14.425s", true, 39*Hour + 9*Minute + 14*Second + 425*Millisecond}, 835 // large value 836 {"52763797000ns", true, 52763797000 * Nanosecond}, 837 // more than 9 digits after decimal point, see https://golang.org/issue/6617 838 {"0.3333333333333333333h", true, 20 * Minute}, 839 // 9007199254740993 = 1<<53+1 cannot be stored precisely in a float64 840 {"9007199254740993ns", true, (1<<53 + 1) * Nanosecond}, 841 // largest duration that can be represented by int64 in nanoseconds 842 {"9223372036854775807ns", true, (1<<63 - 1) * Nanosecond}, 843 {"9223372036854775.807us", true, (1<<63 - 1) * Nanosecond}, 844 {"9223372036s854ms775us807ns", true, (1<<63 - 1) * Nanosecond}, 845 // large negative value 846 {"-9223372036854775807ns", true, -1<<63 + 1*Nanosecond}, 847 // huge string; issue 15011. 848 {"0.100000000000000000000h", true, 6 * Minute}, 849 // This value tests the first overflow check in leadingFraction. 850 {"0.830103483285477580700h", true, 49*Minute + 48*Second + 372539827*Nanosecond}, 851 852 // errors 853 {"", false, 0}, 854 {"3", false, 0}, 855 {"-", false, 0}, 856 {"s", false, 0}, 857 {".", false, 0}, 858 {"-.", false, 0}, 859 {".s", false, 0}, 860 {"+.s", false, 0}, 861 {"3000000h", false, 0}, // overflow 862 {"9223372036854775808ns", false, 0}, // overflow 863 {"9223372036854775.808us", false, 0}, // overflow 864 {"9223372036854ms775us808ns", false, 0}, // overflow 865 // largest negative value of type int64 in nanoseconds should fail 866 // see https://go-review.googlesource.com/#/c/2461/ 867 {"-9223372036854775808ns", false, 0}, 868} 869 870func TestParseDuration(t *testing.T) { 871 for _, tc := range parseDurationTests { 872 d, err := ParseDuration(tc.in) 873 if tc.ok && (err != nil || d != tc.want) { 874 t.Errorf("ParseDuration(%q) = %v, %v, want %v, nil", tc.in, d, err, tc.want) 875 } else if !tc.ok && err == nil { 876 t.Errorf("ParseDuration(%q) = _, nil, want _, non-nil", tc.in) 877 } 878 } 879} 880 881func TestParseDurationRoundTrip(t *testing.T) { 882 for i := 0; i < 100; i++ { 883 // Resolutions finer than milliseconds will result in 884 // imprecise round-trips. 885 d0 := Duration(rand.Int31()) * Millisecond 886 s := d0.String() 887 d1, err := ParseDuration(s) 888 if err != nil || d0 != d1 { 889 t.Errorf("round-trip failed: %d => %q => %d, %v", d0, s, d1, err) 890 } 891 } 892} 893 894// golang.org/issue/4622 895func TestLocationRace(t *testing.T) { 896 ResetLocalOnceForTest() // reset the Once to trigger the race 897 898 c := make(chan string, 1) 899 go func() { 900 c <- Now().String() 901 }() 902 _ = Now().String() 903 <-c 904 Sleep(100 * Millisecond) 905 906 // Back to Los Angeles for subsequent tests: 907 ForceUSPacificForTesting() 908} 909 910var ( 911 t Time 912 u int64 913) 914 915var mallocTest = []struct { 916 count int 917 desc string 918 fn func() 919}{ 920 {0, `time.Now()`, func() { t = Now() }}, 921 {0, `time.Now().UnixNano()`, func() { u = Now().UnixNano() }}, 922} 923 924func TestCountMallocs(t *testing.T) { 925 if testing.Short() { 926 t.Skip("skipping malloc count in short mode") 927 } 928 if runtime.GOMAXPROCS(0) > 1 { 929 t.Skip("skipping; GOMAXPROCS>1") 930 } 931 for _, mt := range mallocTest { 932 allocs := int(testing.AllocsPerRun(100, mt.fn)) 933 if allocs > mt.count { 934 t.Errorf("%s: %d allocs, want %d", mt.desc, allocs, mt.count) 935 } 936 } 937} 938 939func TestLoadFixed(t *testing.T) { 940 // Issue 4064: handle locations without any zone transitions. 941 loc, err := LoadLocation("Etc/GMT+1") 942 if err != nil { 943 t.Fatal(err) 944 } 945 946 // The tzdata name Etc/GMT+1 uses "east is negative", 947 // but Go and most other systems use "east is positive". 948 // So GMT+1 corresponds to -3600 in the Go zone, not +3600. 949 name, offset := Now().In(loc).Zone() 950 // The zone abbreviation is "-01" since tzdata-2016g, and "GMT+1" 951 // on earlier versions; we accept both. (Issue #17276). 952 if !(name == "GMT+1" || name == "-01") || offset != -1*60*60 { 953 t.Errorf("Now().In(loc).Zone() = %q, %d, want %q or %q, %d", 954 name, offset, "GMT+1", "-01", -1*60*60) 955 } 956} 957 958const ( 959 minDuration Duration = -1 << 63 960 maxDuration Duration = 1<<63 - 1 961) 962 963var subTests = []struct { 964 t Time 965 u Time 966 d Duration 967}{ 968 {Time{}, Time{}, Duration(0)}, 969 {Date(2009, 11, 23, 0, 0, 0, 1, UTC), Date(2009, 11, 23, 0, 0, 0, 0, UTC), Duration(1)}, 970 {Date(2009, 11, 23, 0, 0, 0, 0, UTC), Date(2009, 11, 24, 0, 0, 0, 0, UTC), -24 * Hour}, 971 {Date(2009, 11, 24, 0, 0, 0, 0, UTC), Date(2009, 11, 23, 0, 0, 0, 0, UTC), 24 * Hour}, 972 {Date(-2009, 11, 24, 0, 0, 0, 0, UTC), Date(-2009, 11, 23, 0, 0, 0, 0, UTC), 24 * Hour}, 973 {Time{}, Date(2109, 11, 23, 0, 0, 0, 0, UTC), Duration(minDuration)}, 974 {Date(2109, 11, 23, 0, 0, 0, 0, UTC), Time{}, Duration(maxDuration)}, 975 {Time{}, Date(-2109, 11, 23, 0, 0, 0, 0, UTC), Duration(maxDuration)}, 976 {Date(-2109, 11, 23, 0, 0, 0, 0, UTC), Time{}, Duration(minDuration)}, 977 {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}, 978 {Date(2300, 1, 1, 0, 0, 0, 0, UTC), Date(2000, 1, 1, 0, 0, 0, 0, UTC), Duration(maxDuration)}, 979 {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}, 980 {Date(2000, 1, 1, 0, 0, 0, 0, UTC), Date(2300, 1, 1, 0, 0, 0, 0, UTC), Duration(minDuration)}, 981} 982 983func TestSub(t *testing.T) { 984 for i, st := range subTests { 985 got := st.t.Sub(st.u) 986 if got != st.d { 987 t.Errorf("#%d: Sub(%v, %v): got %v; want %v", i, st.t, st.u, got, st.d) 988 } 989 } 990} 991 992var nsDurationTests = []struct { 993 d Duration 994 want int64 995}{ 996 {Duration(-1000), -1000}, 997 {Duration(-1), -1}, 998 {Duration(1), 1}, 999 {Duration(1000), 1000}, 1000} 1001 1002func TestDurationNanoseconds(t *testing.T) { 1003 for _, tt := range nsDurationTests { 1004 if got := tt.d.Nanoseconds(); got != tt.want { 1005 t.Errorf("d.Nanoseconds() = %d; want: %d", got, tt.want) 1006 } 1007 } 1008} 1009 1010var secDurationTests = []struct { 1011 d Duration 1012 want float64 1013}{ 1014 {Duration(300000000), 0.3}, 1015} 1016 1017func TestDurationSeconds(t *testing.T) { 1018 for _, tt := range secDurationTests { 1019 if got := tt.d.Seconds(); got != tt.want { 1020 t.Errorf("d.Seconds() = %g; want: %g", got, tt.want) 1021 } 1022 } 1023} 1024 1025var minDurationTests = []struct { 1026 d Duration 1027 want float64 1028}{ 1029 {Duration(-60000000000), -1}, 1030 {Duration(-1), -1 / 60e9}, 1031 {Duration(1), 1 / 60e9}, 1032 {Duration(60000000000), 1}, 1033 {Duration(3000), 5e-8}, 1034} 1035 1036func TestDurationMinutes(t *testing.T) { 1037 for _, tt := range minDurationTests { 1038 if got := tt.d.Minutes(); got != tt.want { 1039 t.Errorf("d.Minutes() = %g; want: %g", got, tt.want) 1040 } 1041 } 1042} 1043 1044var hourDurationTests = []struct { 1045 d Duration 1046 want float64 1047}{ 1048 {Duration(-3600000000000), -1}, 1049 {Duration(-1), -1 / 3600e9}, 1050 {Duration(1), 1 / 3600e9}, 1051 {Duration(3600000000000), 1}, 1052 {Duration(36), 1e-11}, 1053} 1054 1055func TestDurationHours(t *testing.T) { 1056 for _, tt := range hourDurationTests { 1057 if got := tt.d.Hours(); got != tt.want { 1058 t.Errorf("d.Hours() = %g; want: %g", got, tt.want) 1059 } 1060 } 1061} 1062 1063var durationTruncateTests = []struct { 1064 d Duration 1065 m Duration 1066 want Duration 1067}{ 1068 {0, Second, 0}, 1069 {Minute, -7 * Second, Minute}, 1070 {Minute, 0, Minute}, 1071 {Minute, 1, Minute}, 1072 {Minute + 10*Second, 10 * Second, Minute + 10*Second}, 1073 {2*Minute + 10*Second, Minute, 2 * Minute}, 1074 {10*Minute + 10*Second, 3 * Minute, 9 * Minute}, 1075 {Minute + 10*Second, Minute + 10*Second + 1, 0}, 1076 {Minute + 10*Second, Hour, 0}, 1077 {-Minute, Second, -Minute}, 1078 {-10 * Minute, 3 * Minute, -9 * Minute}, 1079 {-10 * Minute, Hour, 0}, 1080} 1081 1082func TestDurationTruncate(t *testing.T) { 1083 for _, tt := range durationTruncateTests { 1084 if got := tt.d.Truncate(tt.m); got != tt.want { 1085 t.Errorf("Duration(%s).Truncate(%s) = %s; want: %s", tt.d, tt.m, got, tt.want) 1086 } 1087 } 1088} 1089 1090var durationRoundTests = []struct { 1091 d Duration 1092 m Duration 1093 want Duration 1094}{ 1095 {0, Second, 0}, 1096 {Minute, -11 * Second, Minute}, 1097 {Minute, 0, Minute}, 1098 {Minute, 1, Minute}, 1099 {2 * Minute, Minute, 2 * Minute}, 1100 {2*Minute + 10*Second, Minute, 2 * Minute}, 1101 {2*Minute + 30*Second, Minute, 3 * Minute}, 1102 {2*Minute + 50*Second, Minute, 3 * Minute}, 1103 {-Minute, 1, -Minute}, 1104 {-2 * Minute, Minute, -2 * Minute}, 1105 {-2*Minute - 10*Second, Minute, -2 * Minute}, 1106 {-2*Minute - 30*Second, Minute, -3 * Minute}, 1107 {-2*Minute - 50*Second, Minute, -3 * Minute}, 1108 {8e18, 3e18, 9e18}, 1109 {9e18, 5e18, 1<<63 - 1}, 1110 {-8e18, 3e18, -9e18}, 1111 {-9e18, 5e18, -1 << 63}, 1112 {3<<61 - 1, 3 << 61, 3 << 61}, 1113} 1114 1115func TestDurationRound(t *testing.T) { 1116 for _, tt := range durationRoundTests { 1117 if got := tt.d.Round(tt.m); got != tt.want { 1118 t.Errorf("Duration(%s).Round(%s) = %s; want: %s", tt.d, tt.m, got, tt.want) 1119 } 1120 } 1121} 1122 1123var defaultLocTests = []struct { 1124 name string 1125 f func(t1, t2 Time) bool 1126}{ 1127 {"After", func(t1, t2 Time) bool { return t1.After(t2) == t2.After(t1) }}, 1128 {"Before", func(t1, t2 Time) bool { return t1.Before(t2) == t2.Before(t1) }}, 1129 {"Equal", func(t1, t2 Time) bool { return t1.Equal(t2) == t2.Equal(t1) }}, 1130 1131 {"IsZero", func(t1, t2 Time) bool { return t1.IsZero() == t2.IsZero() }}, 1132 {"Date", func(t1, t2 Time) bool { 1133 a1, b1, c1 := t1.Date() 1134 a2, b2, c2 := t2.Date() 1135 return a1 == a2 && b1 == b2 && c1 == c2 1136 }}, 1137 {"Year", func(t1, t2 Time) bool { return t1.Year() == t2.Year() }}, 1138 {"Month", func(t1, t2 Time) bool { return t1.Month() == t2.Month() }}, 1139 {"Day", func(t1, t2 Time) bool { return t1.Day() == t2.Day() }}, 1140 {"Weekday", func(t1, t2 Time) bool { return t1.Weekday() == t2.Weekday() }}, 1141 {"ISOWeek", func(t1, t2 Time) bool { 1142 a1, b1 := t1.ISOWeek() 1143 a2, b2 := t2.ISOWeek() 1144 return a1 == a2 && b1 == b2 1145 }}, 1146 {"Clock", func(t1, t2 Time) bool { 1147 a1, b1, c1 := t1.Clock() 1148 a2, b2, c2 := t2.Clock() 1149 return a1 == a2 && b1 == b2 && c1 == c2 1150 }}, 1151 {"Hour", func(t1, t2 Time) bool { return t1.Hour() == t2.Hour() }}, 1152 {"Minute", func(t1, t2 Time) bool { return t1.Minute() == t2.Minute() }}, 1153 {"Second", func(t1, t2 Time) bool { return t1.Second() == t2.Second() }}, 1154 {"Nanosecond", func(t1, t2 Time) bool { return t1.Hour() == t2.Hour() }}, 1155 {"YearDay", func(t1, t2 Time) bool { return t1.YearDay() == t2.YearDay() }}, 1156 1157 // Using Equal since Add don't modify loc using "==" will cause a fail 1158 {"Add", func(t1, t2 Time) bool { return t1.Add(Hour).Equal(t2.Add(Hour)) }}, 1159 {"Sub", func(t1, t2 Time) bool { return t1.Sub(t2) == t2.Sub(t1) }}, 1160 1161 //Original caus for this test case bug 15852 1162 {"AddDate", func(t1, t2 Time) bool { return t1.AddDate(1991, 9, 3) == t2.AddDate(1991, 9, 3) }}, 1163 1164 {"UTC", func(t1, t2 Time) bool { return t1.UTC() == t2.UTC() }}, 1165 {"Local", func(t1, t2 Time) bool { return t1.Local() == t2.Local() }}, 1166 {"In", func(t1, t2 Time) bool { return t1.In(UTC) == t2.In(UTC) }}, 1167 1168 {"Local", func(t1, t2 Time) bool { return t1.Local() == t2.Local() }}, 1169 {"Zone", func(t1, t2 Time) bool { 1170 a1, b1 := t1.Zone() 1171 a2, b2 := t2.Zone() 1172 return a1 == a2 && b1 == b2 1173 }}, 1174 1175 {"Unix", func(t1, t2 Time) bool { return t1.Unix() == t2.Unix() }}, 1176 {"UnixNano", func(t1, t2 Time) bool { return t1.UnixNano() == t2.UnixNano() }}, 1177 1178 {"MarshalBinary", func(t1, t2 Time) bool { 1179 a1, b1 := t1.MarshalBinary() 1180 a2, b2 := t2.MarshalBinary() 1181 return bytes.Equal(a1, a2) && b1 == b2 1182 }}, 1183 {"GobEncode", func(t1, t2 Time) bool { 1184 a1, b1 := t1.GobEncode() 1185 a2, b2 := t2.GobEncode() 1186 return bytes.Equal(a1, a2) && b1 == b2 1187 }}, 1188 {"MarshalJSON", func(t1, t2 Time) bool { 1189 a1, b1 := t1.MarshalJSON() 1190 a2, b2 := t2.MarshalJSON() 1191 return bytes.Equal(a1, a2) && b1 == b2 1192 }}, 1193 {"MarshalText", func(t1, t2 Time) bool { 1194 a1, b1 := t1.MarshalText() 1195 a2, b2 := t2.MarshalText() 1196 return bytes.Equal(a1, a2) && b1 == b2 1197 }}, 1198 1199 {"Truncate", func(t1, t2 Time) bool { return t1.Truncate(Hour).Equal(t2.Truncate(Hour)) }}, 1200 {"Round", func(t1, t2 Time) bool { return t1.Round(Hour).Equal(t2.Round(Hour)) }}, 1201 1202 {"== Time{}", func(t1, t2 Time) bool { return (t1 == Time{}) == (t2 == Time{}) }}, 1203} 1204 1205func TestDefaultLoc(t *testing.T) { 1206 // Verify that all of Time's methods behave identically if loc is set to 1207 // nil or UTC. 1208 for _, tt := range defaultLocTests { 1209 t1 := Time{} 1210 t2 := Time{}.UTC() 1211 if !tt.f(t1, t2) { 1212 t.Errorf("Time{} and Time{}.UTC() behave differently for %s", tt.name) 1213 } 1214 } 1215} 1216 1217func BenchmarkNow(b *testing.B) { 1218 for i := 0; i < b.N; i++ { 1219 t = Now() 1220 } 1221} 1222 1223func BenchmarkNowUnixNano(b *testing.B) { 1224 for i := 0; i < b.N; i++ { 1225 u = Now().UnixNano() 1226 } 1227} 1228 1229func BenchmarkFormat(b *testing.B) { 1230 t := Unix(1265346057, 0) 1231 for i := 0; i < b.N; i++ { 1232 t.Format("Mon Jan 2 15:04:05 2006") 1233 } 1234} 1235 1236func BenchmarkFormatNow(b *testing.B) { 1237 // Like BenchmarkFormat, but easier, because the time zone 1238 // lookup cache is optimized for the present. 1239 t := Now() 1240 for i := 0; i < b.N; i++ { 1241 t.Format("Mon Jan 2 15:04:05 2006") 1242 } 1243} 1244 1245func BenchmarkMarshalJSON(b *testing.B) { 1246 t := Now() 1247 for i := 0; i < b.N; i++ { 1248 t.MarshalJSON() 1249 } 1250} 1251 1252func BenchmarkMarshalText(b *testing.B) { 1253 t := Now() 1254 for i := 0; i < b.N; i++ { 1255 t.MarshalText() 1256 } 1257} 1258 1259func BenchmarkParse(b *testing.B) { 1260 for i := 0; i < b.N; i++ { 1261 Parse(ANSIC, "Mon Jan 2 15:04:05 2006") 1262 } 1263} 1264 1265func BenchmarkParseDuration(b *testing.B) { 1266 for i := 0; i < b.N; i++ { 1267 ParseDuration("9007199254.740993ms") 1268 ParseDuration("9007199254740993ns") 1269 } 1270} 1271 1272func BenchmarkHour(b *testing.B) { 1273 t := Now() 1274 for i := 0; i < b.N; i++ { 1275 _ = t.Hour() 1276 } 1277} 1278 1279func BenchmarkSecond(b *testing.B) { 1280 t := Now() 1281 for i := 0; i < b.N; i++ { 1282 _ = t.Second() 1283 } 1284} 1285 1286func BenchmarkYear(b *testing.B) { 1287 t := Now() 1288 for i := 0; i < b.N; i++ { 1289 _ = t.Year() 1290 } 1291} 1292 1293func BenchmarkDay(b *testing.B) { 1294 t := Now() 1295 for i := 0; i < b.N; i++ { 1296 _ = t.Day() 1297 } 1298} 1299 1300func TestMarshalBinaryZeroTime(t *testing.T) { 1301 t0 := Time{} 1302 enc, err := t0.MarshalBinary() 1303 if err != nil { 1304 t.Fatal(err) 1305 } 1306 t1 := Now() // not zero 1307 if err := t1.UnmarshalBinary(enc); err != nil { 1308 t.Fatal(err) 1309 } 1310 if t1 != t0 { 1311 t.Errorf("t0=%#v\nt1=%#v\nwant identical structures", t0, t1) 1312 } 1313} 1314 1315// Issue 17720: Zero value of time.Month fails to print 1316func TestZeroMonthString(t *testing.T) { 1317 if got, want := Month(0).String(), "%!Month(0)"; got != want { 1318 t.Errorf("zero month = %q; want %q", got, want) 1319 } 1320} 1321 1322func TestReadFileLimit(t *testing.T) { 1323 const zero = "/dev/zero" 1324 if _, err := os.Stat(zero); err != nil { 1325 t.Skip("skipping test without a /dev/zero") 1326 } 1327 _, err := ReadFile(zero) 1328 if err == nil || !strings.Contains(err.Error(), "is too large") { 1329 t.Errorf("readFile(%q) error = %v; want error containing 'is too large'", zero, err) 1330 } 1331} 1332