time: fix quickcheck test to avoid wraparounds

When we call time.Unix(s, ns), the internal representation is
s + 62135596800,  where 62135596800 is the number of
seconds from Jan 1 1 to Jan 1 1970.

If quickcheck generates numbers too close to 2^63,
the addition can wraparound to make a very negative
internal 64-bit value. Wraparounds are not guarded
against, since they would not arise in any reasonable program,
so just avoid testing near them.

Fixes #52409.

Change-Id: Id466c8a34a49055ab26f2687a6b2b657cb64bed6
Reviewed-on: https://go-review.googlesource.com/c/go/+/402177
Run-TryBot: Russ Cox <rsc@golang.org>
Reviewed-by: Bryan Mills <bcmills@google.com>
Auto-Submit: Russ Cox <rsc@golang.org>
TryBot-Result: Gopher Robot <gobot@golang.org>

diff --git a/src/time/time_test.go b/src/time/time_test.go
index 1701401ab4ba893231430f29bff0865681055284..695d48b1b573174d8c6df06d9d7e6edc4f855951 100644 (file)
--- a/src/time/time_test.go
+++ b/src/time/time_test.go
@@ -281,6 +281,8 @@ func TestTruncateRound(t *testing.T) {
        b1e9.SetInt64(1e9)
 
        testOne := func(ti, tns, di int64) bool {
+               t.Helper()
+
                t0 := Unix(ti, int64(tns)).UTC()
                d := Duration(di)
                if d < 0 {
@@ -367,6 +369,13 @@ func TestTruncateRound(t *testing.T) {
                for i := 0; i < int(b); i++ {
                        d *= 5
                }
+
+               // Make room for unix ↔ internal conversion.
+               // We don't care about behavior too close to ± 2^63 Unix seconds.
+               // It is full of wraparounds but will never happen in a reasonable program.
+               // (Or maybe not? See go.dev/issue/20678. In any event, they're not handled today.)
+               ti >>= 1
+
                return testOne(ti, int64(tns), int64(d))
        }
        quick.Check(f1, cfg)
@@ -377,6 +386,7 @@ func TestTruncateRound(t *testing.T) {
                if d < 0 {
                        d = -d
                }
+               ti >>= 1 // see comment in f1
                return testOne(ti, int64(tns), int64(d))
        }
        quick.Check(f2, cfg)
@@ -399,6 +409,7 @@ func TestTruncateRound(t *testing.T) {
 
        // full generality
        f4 := func(ti int64, tns int32, di int64) bool {
+               ti >>= 1 // see comment in f1
                return testOne(ti, int64(tns), di)
        }
        quick.Check(f4, cfg)