//sysnb	Gettimeofday(tv *Timeval) (err error)

func Time(t *Time_t) (Time_t, error) {
	var tv Timeval
	err := Gettimeofday(&tv)
	if err != nil {
		return 0, err
	}
	if t != nil {
		*t = Time_t(tv.Sec)
	}
	return Time_t(tv.Sec), nil
}

func Utime(path string, buf *Utimbuf) error {
	tv := []Timeval{
		{Sec: buf.Actime},
		{Sec: buf.Modtime},
	}

	}
}

func TestGettimeofday(t *testing.T) {
	if runtime.GOOS == "js" {
		t.Skip("not implemented on " + runtime.GOOS)
	}
	tv := &syscall.Timeval{}
	if err := syscall.Gettimeofday(tv); err != nil {
		t.Fatal(err)
	}
	if tv.Sec == 0 && tv.Usec == 0 {
		t.Fatal("Sec and Usec both zero")
	}

//go:build gccgo && linux && amd64

package unix

import "syscall"

//extern gettimeofday
func realGettimeofday(*Timeval, *byte) int32

func gettimeofday(tv *Timeval) (err syscall.Errno) {
	r := realGettimeofday(tv, nil)
	if r < 0 {
		return syscall.GetErrno()
	}
	return 0

		t.Errorf("bv = %q, want %q", *got, want)
	}
	if got, want := x.BW, bw; got != want {
		t.Errorf("bw = %q, want %q", got, want)
	}

	if got, want := x.TV, tv; got == nil {
		t.Errorf("tv = nil, want %q", want)
	} else if *got != want {
		t.Errorf("tv = %q, want %q", *got, want)
	}
	if got, want := x.TW, tw; got != want {
		t.Errorf("tw = %q, want %q", got, want)
	}
}

// a typeAndValue contains the results of typechecking an expression.
// It is embedded in expression nodes.
type typeAndValue struct {
	tv TypeAndValue
}

func (x *typeAndValue) SetTypeInfo(tv TypeAndValue) {
	x.tv = tv
}
func (x *typeAndValue) GetTypeInfo() TypeAndValue {
	return x.tv

	return int64(ts.Sec), int64(ts.Nsec)
}

func (tv *Timeval) Unix() (sec int64, nsec int64) {
	return int64(tv.Sec), int64(tv.Usec) * 1000
}

func (ts *Timespec) Nano() int64 {
	return int64(ts.Sec)*1e9 + int64(ts.Nsec)
}

func (tv *Timeval) Nano() int64 {
	return int64(tv.Sec)*1e9 + int64(tv.Usec)*1000
}

// use is a no-op, but the compiler cannot see that it is.

	}
	if check.StoreTypesInSyntax {
		tv := TypeAndValue{mode, typ, val}
		stv := syntax.TypeAndValue{Type: typ, Value: val}
		if tv.IsVoid() {
			stv.SetIsVoid()
		}
		if tv.IsType() {
			stv.SetIsType()
		}
		if tv.IsBuiltin() {
			stv.SetIsBuiltin()
		}
		if tv.IsValue() {
			stv.SetIsValue()
		}
		if tv.IsNil() {
			stv.SetIsNil()
		}
		if tv.Addressable() {
			stv.SetAddressable()

// the implementation without pulling in all of the Env dependencies.
static uint64 NowMicros() {
  struct timeval tv;
  gettimeofday(&tv, nullptr);
  return static_cast<uint64>(tv.tv_sec) * 1000000 + tv.tv_usec;
}

void DumpStatsToStdout(const Stats& stats) {
  // Compute stats.
  std::vector<int64_t> sorted_us(stats.per_iter_us);

	b := newDefaultBuilder()
	kv := KustomizeVisitor{
		mapper:  b.mapper,
		dirPath: ".",
		schema:  b.schema,
		fSys:    fSys,
	}
	tv := &testVisitor{}
	if err := kv.Visit(tv.Handle); err != nil {
		t.Fatal(err)
	}
	if len(tv.Infos) != 4 {
		t.Fatal(dump.Pretty(tv.Infos))
	}
	if string(kv.yml) != expectedContent {
		t.Fatalf("expected:\n%s\nbut got:\n%s", expectedContent, string(kv.yml))
	}

	conf := types.Config{
		Importer: importer.Default(),
		Sizes:    &types.StdSizes{WordSize: 8, MaxAlign: 8},
	}
	mustTypecheck(src, &conf, &info)
	for _, tv := range info.Types {
		_ = conf.Sizes.Sizeof(tv.Type)
		_ = conf.Sizes.Alignof(tv.Type)
	}
}

// go.dev/issue/53884.
func TestAtomicAlign(t *testing.T) {