vdlroot/time/time_test.go - release.go.v23 - Git at Google

 // Copyright 2015 The Vanadium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.

 package time

 import (
 	"fmt"
 	"math/rand"
 	"reflect"
 	"strings"
 	"testing"
 	gotime "time"

 	"v.io/v23/vdl"
 )

 func TestTimeToFromNative(t *testing.T) {
 	goTime0 := gotime.Time{}
 	goTime0 = goTime0.UTC()
 	tests := []struct {
 		Wire   Time
 		Native gotime.Time
 	}{
 		{Time{}, goTime0},
 		// func Date(year int, month Month, day, hour, min, sec, nsec int, loc *Location) Time
 		{Time{0, 1}, gotime.Date(1, 1, 1, 0, 0, 0, 1, gotime.UTC)},
 		{Time{0, -1}, gotime.Date(1, 1, 1, 0, 0, 0, -1, gotime.UTC)},
 		{Time{1, 0}, gotime.Date(1, 1, 1, 0, 0, 1, 0, gotime.UTC)},
 		{Time{-1, 0}, gotime.Date(1, 1, 1, 0, 0, -1, 0, gotime.UTC)},
 		{Time{1, 1}, gotime.Date(1, 1, 1, 0, 0, 1, 1, gotime.UTC)},
 		{Time{1, -1}, gotime.Date(1, 1, 1, 0, 0, 1, -1, gotime.UTC)},
 		{Time{-1, 1}, gotime.Date(1, 1, 1, 0, 0, -1, 1, gotime.UTC)},
 		// Ensure normalization is as expected
 		{Time{0, nanosPerSecond}, gotime.Date(1, 1, 1, 0, 0, 1, 0, gotime.UTC)},
 		{Time{0, -nanosPerSecond}, gotime.Date(1, 1, 1, 0, 0, -1, 0, gotime.UTC)},
 		{Time{0, nanosPerSecond + 1}, gotime.Date(1, 1, 1, 0, 0, 1, 1, gotime.UTC)},
 		{Time{0, -nanosPerSecond - 1}, gotime.Date(1, 1, 1, 0, 0, -1, -1, gotime.UTC)},
 		{Time{1, nanosPerSecond + 1}, gotime.Date(1, 1, 1, 0, 0, 2, 1, gotime.UTC)},
 		{Time{1, -nanosPerSecond - 1}, gotime.Date(1, 1, 1, 0, 0, 0, -1, gotime.UTC)},
 		{Time{-1, nanosPerSecond + 1}, gotime.Date(1, 1, 1, 0, 0, 0, 1, gotime.UTC)},
 		{Time{-1, -nanosPerSecond - 1}, gotime.Date(1, 1, 1, 0, 0, -2, -1, gotime.UTC)},
 		{Time{0, 2 * nanosPerSecond}, gotime.Date(1, 1, 1, 0, 0, 2, 0, gotime.UTC)},
 		{Time{0, -2 * nanosPerSecond}, gotime.Date(1, 1, 1, 0, 0, -2, 0, gotime.UTC)},
 		{Time{0, 2*nanosPerSecond + 1}, gotime.Date(1, 1, 1, 0, 0, 2, 1, gotime.UTC)},
 		{Time{0, -2*nanosPerSecond - 1}, gotime.Date(1, 1, 1, 0, 0, -2, -1, gotime.UTC)},
 	}
 	for _, test := range tests {
 		native := gotime.Now() // Start with an arbitrary value.
 		if err := TimeToNative(test.Wire, &native); err != nil {
 			t.Errorf("%v TimeToNative failed: %v", test.Wire, err)
 		}
 		if got, want := native, test.Native; got != want {
 			t.Errorf("%v TimeFromNative got %v, want %v", test.Wire, got, want)
 		}
 		wire := Now() // Start with an arbitrary value.
 		if err := TimeFromNative(&wire, test.Native); err != nil {
 			t.Errorf("%v TimeFromNative failed: %v", test.Wire, err)
 		}
 		if got, want := wire, test.Wire.Normalize(); got != want {
 			t.Errorf("%v TimeFromNative got %v, want %v", test.Wire, got, want)
 		}
 	}
 }

 func TestDurationToFromNative(t *testing.T) {
 	tests := []struct {
 		Wire   Duration
 		Native gotime.Duration
 	}{
 		{Duration{}, gotime.Duration(0)},
 		{Duration{0, 1}, gotime.Duration(1)},
 		{Duration{0, -1}, gotime.Duration(-1)},
 		{Duration{1, 0}, gotime.Duration(nanosPerSecond)},
 		{Duration{-1, 0}, gotime.Duration(-nanosPerSecond)},
 		{Duration{1, 1}, gotime.Duration(nanosPerSecond + 1)},
 		{Duration{-1, -1}, gotime.Duration(-(nanosPerSecond + 1))},
 		{Duration{1, -1}, gotime.Duration(nanosPerSecond - 1)},
 		{Duration{-1, 1}, gotime.Duration(-(nanosPerSecond - 1))},
 		{Duration{minGoDurationSec, 0}, gotime.Duration(minGoDurationSec * nanosPerSecond)},
 		{Duration{maxGoDurationSec, 0}, gotime.Duration(maxGoDurationSec * nanosPerSecond)},
 		// Ensure normalization is as expected
 		{Duration{0, nanosPerSecond}, gotime.Duration(nanosPerSecond)},
 		{Duration{0, -nanosPerSecond}, gotime.Duration(-nanosPerSecond)},
 		{Duration{0, nanosPerSecond + 1}, gotime.Duration(nanosPerSecond + 1)},
 		{Duration{0, -nanosPerSecond - 1}, gotime.Duration(-nanosPerSecond - 1)},
 		{Duration{1, nanosPerSecond + 1}, gotime.Duration(2*nanosPerSecond + 1)},
 		{Duration{1, -nanosPerSecond - 1}, gotime.Duration(-1)},
 		{Duration{-1, nanosPerSecond + 1}, gotime.Duration(1)},
 		{Duration{-1, -nanosPerSecond - 1}, gotime.Duration(-2*nanosPerSecond - 1)},
 		{Duration{0, 2 * nanosPerSecond}, gotime.Duration(2 * nanosPerSecond)},
 		{Duration{0, -2 * nanosPerSecond}, gotime.Duration(-2 * nanosPerSecond)},
 		{Duration{0, 2*nanosPerSecond + 1}, gotime.Duration(2*nanosPerSecond + 1)},
 		{Duration{0, -2*nanosPerSecond - 1}, gotime.Duration(-2*nanosPerSecond - 1)},
 	}
 	for _, test := range tests {
 		native := randGoDuration() // Start with an arbitrary value.
 		if err := DurationToNative(test.Wire, &native); err != nil {
 			t.Errorf("%v DurationToNative failed: %v", test.Wire, err)
 		}
 		if got, want := native, test.Native; got != want {
 			t.Errorf("%v DurationToNative got %v, want %v", test.Wire, got, want)
 		}
 		wire := randomDuration() // Start with an arbitrary value.
 		if err := DurationFromNative(&wire, test.Native); err != nil {
 			t.Errorf("%v DurationFromNative failed: %v", test.Wire, err)
 		}
 		if got, want := wire, test.Wire.Normalize(); got != want {
 			t.Errorf("%v DurationFromNative got %v, want %v", test.Wire, got, want)
 		}
 	}
 }

 func randGoDuration() gotime.Duration {
 	return gotime.Duration(rand.Int63())
 }

 func randomDuration() Duration {
 	return Duration{rand.Int63(), int32(rand.Intn(nanosPerSecond))}
 }

 func TestDurationToNativeError(t *testing.T) {
 	tests := []struct {
 		Wire Duration
 		Err  string
 	}{
 		{Duration{minGoDurationSec, -999999999}, "out of range"},
 		{Duration{minGoDurationSec - 1, 0}, "out of range"},
 		{Duration{maxGoDurationSec + 1, 0}, "out of range"},
 		{Duration{maxGoDurationSec, 999999999}, "out of range"},
 	}
 	for _, test := range tests {
 		native := randGoDuration() // Start with an arbitrary value.
 		err := DurationToNative(test.Wire, &native)
 		if got, want := fmt.Sprint(err), test.Err; !strings.Contains(got, want) {
 			t.Errorf("%v DurationToNative got error %q, want substr %q", test.Wire, got, want)
 		}
 		if got, want := native, gotime.Duration(0); got != want {
 			t.Errorf("%v DurationToNative got %v, want %v", test.Wire, got, want)
 		}
 	}
 }

 func TestTimeDurationNativeConversion(t *testing.T) {
 	tests := []interface{}{
 		// Test various times.
 		gotime.Time{}.UTC(),
 		gotime.Unix(0, 0).UTC(),
 		gotime.Unix(0, +1).UTC(),
 		gotime.Unix(0, -1).UTC(),
 		gotime.Unix(1, 0).UTC(),
 		gotime.Unix(1, +1).UTC(),
 		gotime.Unix(1, -1).UTC(),
 		gotime.Unix(-1, 0).UTC(),
 		gotime.Unix(-1, +1).UTC(),
 		gotime.Unix(-1, -1).UTC(),
 		gotime.Now().UTC(),
 		// Test various durations.
 		gotime.Duration(0),
 		gotime.Duration(+1),
 		gotime.Duration(-1),
 		gotime.Now().Sub(gotime.Time{}),
 		gotime.Now().Sub(gotime.Unix(0, 0)),
 	}
 	for _, test := range tests {
 		// Try converting to a value of the actual native type.
 		rv := reflect.New(reflect.TypeOf(test))
 		if err := vdl.Convert(rv.Interface(), test); err != nil {
 			t.Errorf("%v Convert(%v) failed: %q", test, rv.Elem().Type(), err)
 		}
 		if got, want := rv.Elem().Interface(), test; !reflect.DeepEqual(got, want) {
 			t.Errorf("%v Convert(%v) got %v, want %v", test, rv.Elem().Type(), got, want)
 		}
 		// Try converting to an empty interface.
 		var any interface{}
 		if err := vdl.Convert(&any, test); err != nil {
 			t.Errorf("%v Convert(interface) failed: %q", test, err)
 		}
 		if got, want := any, test; !reflect.DeepEqual(got, want) {
 			t.Errorf("%v Convert(interface) got %v, want %v", test, got, want)
 		}
 	}
 }

 func TestDeadline(t *testing.T) {
 	// The deadline wire<->native conversions involve computations against
 	// time.Now(), and there's no guarantee that that time.Now() is strictly
 	// increasing, or very accurate.  So we define a fudge factor offset for our
 	// comparisons.
 	const off = 10 * gotime.Second
 	tests := []gotime.Duration{
 		30 * gotime.Second,
 		gotime.Minute,
 		gotime.Hour,
 		12 * gotime.Hour,
 		24 * gotime.Hour,
 	}
 	for _, test := range tests {
 		now := gotime.Now()
 		loD, hiD := test-off, test+off
 		loT, hiT := now.Add(loD), now.Add(hiD)
 		// Test conversion from wire to native.
 		var native Deadline
 		if err := WireDeadlineToNative(WireDeadline{FromNow: test}, &native); err != nil {
 			t.Errorf("%v WireDeadlineToNative failed: %v", test, err)
 		}
 		if got := native; got.Before(loT) || got.After(hiT) {
 			t.Errorf("%v WireDeadlineToNative got %v, want range [%v, %v]", test, got, loT, hiT)
 		}
 		// Test conversion from native to wire.
 		var wire WireDeadline
 		if err := WireDeadlineFromNative(&wire, Deadline{now.Add(test)}); err != nil {
 			t.Errorf("%v WireDeadlineFromNative failed: %v", test, err)
 		}
 		if got := wire.FromNow; got < loD || got > hiD {
 			t.Errorf("%v WireDeadlineFromNative got %v, want range [%v, %v]", test, got, loD, hiD)
 		}
 		// Test vdl.Convert from native to native type.
 		if err := vdl.Convert(&native, Deadline{now.Add(test)}); err != nil {
 			t.Errorf("%v Convert failed: %v", test, err)
 		}
 		if got := native; got.Before(loT) || got.After(hiT) {
 			t.Errorf("%v Convert got %v, want range [%v, %v]", test, got, loT, hiT)
 		}
 		// Test vdl.Convert from native to interface type.
 		var any interface{}
 		if err := vdl.Convert(&any, Deadline{now.Add(test)}); err != nil {
 			t.Errorf("%v Convert(interface) failed: %v", test, err)
 		}
 		if got, ok := any.(Deadline); !ok || got.Before(loT) || got.After(hiT) {
 			t.Errorf("%v Convert(interface) got %T %v, want range [%v, %v]", test, any, any, loT, hiT)
 		}
 		// Test vdl.Convert from wire to interface type.  This ensures that the
 		// conversion routines are really registered, and automatically applied.
 		any = nil
 		if err := vdl.Convert(&any, WireDeadline{FromNow: test}); err != nil {
 			t.Errorf("%v Convert(interface) failed: %v", test, err)
 		}
 		if got, ok := any.(Deadline); !ok || got.Before(loT) || got.After(hiT) {
 			t.Errorf("%v Convert(interface) got %T %v, want range [%v, %v]", test, any, any, loT, hiT)
 		}
 	}
 }

 func TestNoDeadline(t *testing.T) {
 	// Make sure conversions between the wire and native formats respect the
 	// special sentries for "no deadline".

 	// Test conversion from wire to native.
 	var native Deadline
 	if err := WireDeadlineToNative(WireDeadline{}, &native); err != nil {
 		t.Errorf("WireDeadlineToNative failed: %v", err)
 	}
 	if got := native; !got.IsZero() {
 		t.Errorf("WireDeadlineToNative got %v, want zero", got)
 	}
 	// Test conversion from native to wire.
 	var wire WireDeadline
 	if err := WireDeadlineFromNative(&wire, Deadline{}); err != nil {
 		t.Errorf("WireDeadlineFromNative failed: %v", err)
 	}
 	if got, want := wire, (WireDeadline{}); got != want {
 		t.Errorf("WireDeadlineFromNative got %v, want %v", got, want)
 	}
 }

 func TestZeroDeadlineFixup(t *testing.T) {
 	// A non-zero native deadline should never result in a zero wire deadline; the
 	// code changes the 0 to a 1.  Since the conversion uses time.Now(), we can't
 	// ensure the test hits this case.  So we just run it a few times and log when
 	// we think the 0-to-1 fixup has occured.  We add an offset on each iteration
 	// to increase the odds that we see the fixup in action.
 	var wire WireDeadline
 	for offset := gotime.Duration(0); offset < 100; offset += 10 {
 		if err := WireDeadlineFromNative(&wire, Deadline{gotime.Now().Add(offset)}); err != nil {
 			t.Errorf("WireDeadlineFromNative failed: %v", err)
 		}
 		if wire.FromNow == 1 {
 			t.Logf("WireDeadlineFromNative 0-to-1 fixup probably occurred")
 		} else {
 			t.Logf("WireDeadlineFromNative %v", wire)
 		}
 	}
 }
	// Copyright 2015 The Vanadium Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style
	// license that can be found in the LICENSE file.

	package time

	import (
	"fmt"
	"math/rand"
	"reflect"
	"strings"
	"testing"
	gotime "time"

	"v.io/v23/vdl"
	)

	func TestTimeToFromNative(t *testing.T) {
	goTime0 := gotime.Time{}
	goTime0 = goTime0.UTC()
	tests := []struct {
	Wire Time
	Native gotime.Time
	}{
	{Time{}, goTime0},
	// func Date(year int, month Month, day, hour, min, sec, nsec int, loc *Location) Time
	{Time{0, 1}, gotime.Date(1, 1, 1, 0, 0, 0, 1, gotime.UTC)},
	{Time{0, -1}, gotime.Date(1, 1, 1, 0, 0, 0, -1, gotime.UTC)},
	{Time{1, 0}, gotime.Date(1, 1, 1, 0, 0, 1, 0, gotime.UTC)},
	{Time{-1, 0}, gotime.Date(1, 1, 1, 0, 0, -1, 0, gotime.UTC)},
	{Time{1, 1}, gotime.Date(1, 1, 1, 0, 0, 1, 1, gotime.UTC)},
	{Time{1, -1}, gotime.Date(1, 1, 1, 0, 0, 1, -1, gotime.UTC)},
	{Time{-1, 1}, gotime.Date(1, 1, 1, 0, 0, -1, 1, gotime.UTC)},
	// Ensure normalization is as expected
	{Time{0, nanosPerSecond}, gotime.Date(1, 1, 1, 0, 0, 1, 0, gotime.UTC)},
	{Time{0, -nanosPerSecond}, gotime.Date(1, 1, 1, 0, 0, -1, 0, gotime.UTC)},
	{Time{0, nanosPerSecond + 1}, gotime.Date(1, 1, 1, 0, 0, 1, 1, gotime.UTC)},
	{Time{0, -nanosPerSecond - 1}, gotime.Date(1, 1, 1, 0, 0, -1, -1, gotime.UTC)},
	{Time{1, nanosPerSecond + 1}, gotime.Date(1, 1, 1, 0, 0, 2, 1, gotime.UTC)},
	{Time{1, -nanosPerSecond - 1}, gotime.Date(1, 1, 1, 0, 0, 0, -1, gotime.UTC)},
	{Time{-1, nanosPerSecond + 1}, gotime.Date(1, 1, 1, 0, 0, 0, 1, gotime.UTC)},
	{Time{-1, -nanosPerSecond - 1}, gotime.Date(1, 1, 1, 0, 0, -2, -1, gotime.UTC)},
	{Time{0, 2 * nanosPerSecond}, gotime.Date(1, 1, 1, 0, 0, 2, 0, gotime.UTC)},
	{Time{0, -2 * nanosPerSecond}, gotime.Date(1, 1, 1, 0, 0, -2, 0, gotime.UTC)},
	{Time{0, 2*nanosPerSecond + 1}, gotime.Date(1, 1, 1, 0, 0, 2, 1, gotime.UTC)},
	{Time{0, -2*nanosPerSecond - 1}, gotime.Date(1, 1, 1, 0, 0, -2, -1, gotime.UTC)},
	}
	for _, test := range tests {
	native := gotime.Now() // Start with an arbitrary value.
	if err := TimeToNative(test.Wire, &native); err != nil {
	t.Errorf("%v TimeToNative failed: %v", test.Wire, err)
	}
	if got, want := native, test.Native; got != want {
	t.Errorf("%v TimeFromNative got %v, want %v", test.Wire, got, want)
	}
	wire := Now() // Start with an arbitrary value.
	if err := TimeFromNative(&wire, test.Native); err != nil {
	t.Errorf("%v TimeFromNative failed: %v", test.Wire, err)
	}
	if got, want := wire, test.Wire.Normalize(); got != want {
	t.Errorf("%v TimeFromNative got %v, want %v", test.Wire, got, want)
	}
	}
	}

	func TestDurationToFromNative(t *testing.T) {
	tests := []struct {
	Wire Duration
	Native gotime.Duration
	}{
	{Duration{}, gotime.Duration(0)},
	{Duration{0, 1}, gotime.Duration(1)},
	{Duration{0, -1}, gotime.Duration(-1)},
	{Duration{1, 0}, gotime.Duration(nanosPerSecond)},
	{Duration{-1, 0}, gotime.Duration(-nanosPerSecond)},
	{Duration{1, 1}, gotime.Duration(nanosPerSecond + 1)},
	{Duration{-1, -1}, gotime.Duration(-(nanosPerSecond + 1))},
	{Duration{1, -1}, gotime.Duration(nanosPerSecond - 1)},
	{Duration{-1, 1}, gotime.Duration(-(nanosPerSecond - 1))},
	{Duration{minGoDurationSec, 0}, gotime.Duration(minGoDurationSec * nanosPerSecond)},
	{Duration{maxGoDurationSec, 0}, gotime.Duration(maxGoDurationSec * nanosPerSecond)},
	// Ensure normalization is as expected
	{Duration{0, nanosPerSecond}, gotime.Duration(nanosPerSecond)},
	{Duration{0, -nanosPerSecond}, gotime.Duration(-nanosPerSecond)},
	{Duration{0, nanosPerSecond + 1}, gotime.Duration(nanosPerSecond + 1)},
	{Duration{0, -nanosPerSecond - 1}, gotime.Duration(-nanosPerSecond - 1)},
	{Duration{1, nanosPerSecond + 1}, gotime.Duration(2*nanosPerSecond + 1)},
	{Duration{1, -nanosPerSecond - 1}, gotime.Duration(-1)},
	{Duration{-1, nanosPerSecond + 1}, gotime.Duration(1)},
	{Duration{-1, -nanosPerSecond - 1}, gotime.Duration(-2*nanosPerSecond - 1)},
	{Duration{0, 2 * nanosPerSecond}, gotime.Duration(2 * nanosPerSecond)},
	{Duration{0, -2 * nanosPerSecond}, gotime.Duration(-2 * nanosPerSecond)},
	{Duration{0, 2nanosPerSecond + 1}, gotime.Duration(2nanosPerSecond + 1)},
	{Duration{0, -2nanosPerSecond - 1}, gotime.Duration(-2nanosPerSecond - 1)},
	}
	for _, test := range tests {
	native := randGoDuration() // Start with an arbitrary value.
	if err := DurationToNative(test.Wire, &native); err != nil {
	t.Errorf("%v DurationToNative failed: %v", test.Wire, err)
	}
	if got, want := native, test.Native; got != want {
	t.Errorf("%v DurationToNative got %v, want %v", test.Wire, got, want)
	}
	wire := randomDuration() // Start with an arbitrary value.
	if err := DurationFromNative(&wire, test.Native); err != nil {
	t.Errorf("%v DurationFromNative failed: %v", test.Wire, err)
	}
	if got, want := wire, test.Wire.Normalize(); got != want {
	t.Errorf("%v DurationFromNative got %v, want %v", test.Wire, got, want)
	}
	}
	}

	func randGoDuration() gotime.Duration {
	return gotime.Duration(rand.Int63())
	}

	func randomDuration() Duration {
	return Duration{rand.Int63(), int32(rand.Intn(nanosPerSecond))}
	}

	func TestDurationToNativeError(t *testing.T) {
	tests := []struct {
	Wire Duration
	Err string
	}{
	{Duration{minGoDurationSec, -999999999}, "out of range"},
	{Duration{minGoDurationSec - 1, 0}, "out of range"},
	{Duration{maxGoDurationSec + 1, 0}, "out of range"},
	{Duration{maxGoDurationSec, 999999999}, "out of range"},
	}
	for _, test := range tests {
	native := randGoDuration() // Start with an arbitrary value.
	err := DurationToNative(test.Wire, &native)
	if got, want := fmt.Sprint(err), test.Err; !strings.Contains(got, want) {
	t.Errorf("%v DurationToNative got error %q, want substr %q", test.Wire, got, want)
	}
	if got, want := native, gotime.Duration(0); got != want {
	t.Errorf("%v DurationToNative got %v, want %v", test.Wire, got, want)
	}
	}
	}

	func TestTimeDurationNativeConversion(t *testing.T) {
	tests := []interface{}{
	// Test various times.
	gotime.Time{}.UTC(),
	gotime.Unix(0, 0).UTC(),
	gotime.Unix(0, +1).UTC(),
	gotime.Unix(0, -1).UTC(),
	gotime.Unix(1, 0).UTC(),
	gotime.Unix(1, +1).UTC(),
	gotime.Unix(1, -1).UTC(),
	gotime.Unix(-1, 0).UTC(),
	gotime.Unix(-1, +1).UTC(),
	gotime.Unix(-1, -1).UTC(),
	gotime.Now().UTC(),
	// Test various durations.
	gotime.Duration(0),
	gotime.Duration(+1),
	gotime.Duration(-1),
	gotime.Now().Sub(gotime.Time{}),
	gotime.Now().Sub(gotime.Unix(0, 0)),
	}
	for _, test := range tests {
	// Try converting to a value of the actual native type.
	rv := reflect.New(reflect.TypeOf(test))
	if err := vdl.Convert(rv.Interface(), test); err != nil {
	t.Errorf("%v Convert(%v) failed: %q", test, rv.Elem().Type(), err)
	}
	if got, want := rv.Elem().Interface(), test; !reflect.DeepEqual(got, want) {
	t.Errorf("%v Convert(%v) got %v, want %v", test, rv.Elem().Type(), got, want)
	}
	// Try converting to an empty interface.
	var any interface{}
	if err := vdl.Convert(&any, test); err != nil {
	t.Errorf("%v Convert(interface) failed: %q", test, err)
	}
	if got, want := any, test; !reflect.DeepEqual(got, want) {
	t.Errorf("%v Convert(interface) got %v, want %v", test, got, want)
	}
	}
	}

	func TestDeadline(t *testing.T) {
	// The deadline wire<->native conversions involve computations against
	// time.Now(), and there's no guarantee that that time.Now() is strictly
	// increasing, or very accurate. So we define a fudge factor offset for our
	// comparisons.
	const off = 10 * gotime.Second
	tests := []gotime.Duration{
	30 * gotime.Second,
	gotime.Minute,
	gotime.Hour,
	12 * gotime.Hour,
	24 * gotime.Hour,
	}
	for _, test := range tests {
	now := gotime.Now()
	loD, hiD := test-off, test+off
	loT, hiT := now.Add(loD), now.Add(hiD)
	// Test conversion from wire to native.
	var native Deadline
	if err := WireDeadlineToNative(WireDeadline{FromNow: test}, &native); err != nil {
	t.Errorf("%v WireDeadlineToNative failed: %v", test, err)
	}
	if got := native; got.Before(loT) \|\| got.After(hiT) {
	t.Errorf("%v WireDeadlineToNative got %v, want range [%v, %v]", test, got, loT, hiT)
	}
	// Test conversion from native to wire.
	var wire WireDeadline
	if err := WireDeadlineFromNative(&wire, Deadline{now.Add(test)}); err != nil {
	t.Errorf("%v WireDeadlineFromNative failed: %v", test, err)
	}
	if got := wire.FromNow; got < loD \|\| got > hiD {
	t.Errorf("%v WireDeadlineFromNative got %v, want range [%v, %v]", test, got, loD, hiD)
	}
	// Test vdl.Convert from native to native type.
	if err := vdl.Convert(&native, Deadline{now.Add(test)}); err != nil {
	t.Errorf("%v Convert failed: %v", test, err)
	}
	if got := native; got.Before(loT) \|\| got.After(hiT) {
	t.Errorf("%v Convert got %v, want range [%v, %v]", test, got, loT, hiT)
	}
	// Test vdl.Convert from native to interface type.
	var any interface{}
	if err := vdl.Convert(&any, Deadline{now.Add(test)}); err != nil {
	t.Errorf("%v Convert(interface) failed: %v", test, err)
	}
	if got, ok := any.(Deadline); !ok \|\| got.Before(loT) \|\| got.After(hiT) {
	t.Errorf("%v Convert(interface) got %T %v, want range [%v, %v]", test, any, any, loT, hiT)
	}
	// Test vdl.Convert from wire to interface type. This ensures that the
	// conversion routines are really registered, and automatically applied.
	any = nil
	if err := vdl.Convert(&any, WireDeadline{FromNow: test}); err != nil {
	t.Errorf("%v Convert(interface) failed: %v", test, err)
	}
	if got, ok := any.(Deadline); !ok \|\| got.Before(loT) \|\| got.After(hiT) {
	t.Errorf("%v Convert(interface) got %T %v, want range [%v, %v]", test, any, any, loT, hiT)
	}
	}
	}

	func TestNoDeadline(t *testing.T) {
	// Make sure conversions between the wire and native formats respect the
	// special sentries for "no deadline".

	// Test conversion from wire to native.
	var native Deadline
	if err := WireDeadlineToNative(WireDeadline{}, &native); err != nil {
	t.Errorf("WireDeadlineToNative failed: %v", err)
	}
	if got := native; !got.IsZero() {
	t.Errorf("WireDeadlineToNative got %v, want zero", got)
	}
	// Test conversion from native to wire.
	var wire WireDeadline
	if err := WireDeadlineFromNative(&wire, Deadline{}); err != nil {
	t.Errorf("WireDeadlineFromNative failed: %v", err)
	}
	if got, want := wire, (WireDeadline{}); got != want {
	t.Errorf("WireDeadlineFromNative got %v, want %v", got, want)
	}
	}

	func TestZeroDeadlineFixup(t *testing.T) {
	// A non-zero native deadline should never result in a zero wire deadline; the
	// code changes the 0 to a 1. Since the conversion uses time.Now(), we can't
	// ensure the test hits this case. So we just run it a few times and log when
	// we think the 0-to-1 fixup has occured. We add an offset on each iteration
	// to increase the odds that we see the fixup in action.
	var wire WireDeadline
	for offset := gotime.Duration(0); offset < 100; offset += 10 {
	if err := WireDeadlineFromNative(&wire, Deadline{gotime.Now().Add(offset)}); err != nil {
	t.Errorf("WireDeadlineFromNative failed: %v", err)
	}
	if wire.FromNow == 1 {
	t.Logf("WireDeadlineFromNative 0-to-1 fixup probably occurred")
	} else {
	t.Logf("WireDeadlineFromNative %v", wire)
	}
	}
	}