user          = tests.User{
			Model: gorm.Model{
				ID:        10,
				CreatedAt: time.Now(),
				UpdatedAt: time.Now(),
				DeletedAt: gorm.DeletedAt{Time: time.Now(), Valid: true},
			},
			Name:     "valuer_and_setter",
			Age:      18,
			Birthday: tests.Now(),
			Active:   true,
		}
		reflectValue = reflect.ValueOf(&user)
	)

	// test valuer
	values := map[string]interface{}{

    def "finds files to delete when files are old"() {
        given:
        long now = System.currentTimeMillis()
        long fiveDaysAgo = now - TimeUnit.DAYS.toMillis(5)
        def cacheEntries = [
            createCacheEntry(now),
            createCacheEntry(now),
            createCacheEntry(now),
            createCacheEntry(fiveDaysAgo),
        ]

        when:

func TestDeadlineWithinMinute(t *testing.T) {
	now := time.Now()
	d, ok := t.Deadline()
	if !ok || d.IsZero() {
		t.Fatalf("t.Deadline() = %v, %v; want nonzero deadline", d, ok)
	}
	if !d.After(now) {
		t.Fatalf("t.Deadline() = %v; want after start of test (%v)", d, now)
	}
	if d.Sub(now) > time.Minute {
		t.Fatalf("t.Deadline() = %v; want within one minute of start of test (%v)", d, now)
	}
}

	if err != nil {
		t.Fatal(err)
	}
	defer os.RemoveAll(dir)

	c, err := Open(dir)
	if err != nil {
		t.Fatalf("Open: %v", err)
	}
	const start = 1000000000
	now := int64(start)
	c.now = func() time.Time { return time.Unix(now, 0) }

	checkTime := func(name string, mtime int64) {
		t.Helper()
		file := filepath.Join(c.dir, name[:2], name)
		info, err := os.Stat(file)
		if err != nil {
			t.Fatal(err)

# Check errors2.test mtime is updated
exec $GOBIN/now
cp stdout start_time.txt
go test -x -c -o errors2.test errors
! stderr '[\\/]link|gccgo' # make sure up-to-date test binary is not relinked
exec $GOBIN/mtime errors2.test
cp stdout errors2_mod_time.txt
exec $GOBIN/before start_time.txt errors2_mod_time.txt

-- go.mod --
module m

go 1.16
-- now/now.go --
// Writes time.Now() to a file
package main

import (

}

func TestAssertEqual(t *testing.T) {
	now := time.Now()
	assertEqualTests := []struct {
		name     string
		src, dst interface{}
		out      bool
	}{
		{"error equal", errors.New("1"), errors.New("1"), true},
		{"error not equal", errors.New("1"), errors.New("2"), false},
		{"driver.Valuer equal", ModifyAt{Time: now, Valid: true}, ModifyAt{Time: now, Valid: true}, true},

          ReferenceEntry<K, V> e = getEntry(key, hash);
          if (e != null) {
            long now = map.ticker.read();
            V value = getLiveValue(e, now);
            if (value != null) {
              recordRead(e, now);
              statsCounter.recordHits(1);
              return scheduleRefresh(e, key, hash, value, now, loader);
            }
            ValueReference<K, V> valueReference = e.getValueReference();

        final long now = System.currentTimeMillis();
        assertTrue(now + ">=" + current + " : " + (now - current), now >= current);
        assertTrue(now - 1000 + "<" + current + " : " + (current - now + 1000), now - 1000 < current);
    }

    public void test_getLogFilePath() {

		Name:     "groupby",
		Age:      10,
		Birthday: Now(),
		Active:   true,
	}, {
		Name:     "groupby",
		Age:      20,
		Birthday: Now(),
	}, {
		Name:     "groupby",
		Age:      30,
		Birthday: Now(),
		Active:   true,
	}, {
		Name:     "groupby1",
		Age:      110,
		Birthday: Now(),
	}, {
		Name:     "groupby1",
		Age:      220,
		Birthday: Now(),
		Active:   true,
	}, {
		Name:     "groupby1",

The [DNSError] type now wraps errors caused by timeouts or cancellation.
For example, `errors.Is(someDNSErr, context.DeadlineExceedeed)`