func TestMicroTimeUnmarshalJSONAndProtoEqual(t *testing.T) {
	cases := []struct {
		name   string
		input  MicroTime
		result bool
	}{
		{"nanosecond level precision", UnixMicro(123, 123123123), true},
		{"microsecond level precision", UnixMicro(123, 123123000), true},
	}

	for _, c := range cases {
		t.Run(c.name, func(t *testing.T) {
			jsonData, err := c.input.MarshalJSON()
			if err != nil {

	if t == nil && u == nil {
		return true
	}
	if t != nil && u != nil {
		return t.Time.Equal(u.Time)
	}
	return false
}

// UnixMicro returns the local time corresponding to the given Unix time
// by wrapping time.Unix.
func UnixMicro(sec int64, nsec int64) MicroTime {
	return MicroTime{time.Unix(sec, nsec)}
}

// UnmarshalJSON implements the json.Unmarshaller interface.

	{"UnixNano", func(t1, t2 Time) bool { return t1.UnixNano() == t2.UnixNano() }},
	{"UnixMilli", func(t1, t2 Time) bool { return t1.UnixMilli() == t2.UnixMilli() }},
	{"UnixMicro", func(t1, t2 Time) bool { return t1.UnixMicro() == t2.UnixMicro() }},

	{"MarshalBinary", func(t1, t2 Time) bool {
		a1, b1 := t1.MarshalBinary()
		a2, b2 := t2.MarshalBinary()
		return bytes.Equal(a1, a2) && b1 == b2
	}},

	// Output:
	// 1257894000
	// 2009-11-10 23:00:00 +0000 UTC
}

func ExampleUnixMicro() {
	umt := time.Date(2009, time.November, 10, 23, 0, 0, 0, time.UTC)
	fmt.Println(umt.UnixMicro())
	t := time.UnixMicro(umt.UnixMicro()).UTC()
	fmt.Println(t)

	// Output:
	// 1257894000000000
	// 2009-11-10 23:00:00 +0000 UTC
}

func ExampleUnixMilli() {

pkg time, const Layout = "01/02 03:04:05PM '06 -0700"
pkg time, const Layout ideal-string
pkg time, func UnixMicro(int64) Time
pkg time, func UnixMilli(int64) Time
pkg time, method (Time) GoString() string
pkg time, method (Time) IsDST() bool
pkg time, method (Time) UnixMicro() int64

}

// UnixMicro returns t as a Unix time, the number of microseconds elapsed since
// January 1, 1970 UTC. The result is undefined if the Unix time in
// microseconds cannot be represented by an int64 (a date before year -290307 or
// after year 294246). The result does not depend on the location associated
// with t.
func (t Time) UnixMicro() int64 {
	return t.unixSec()*1e6 + int64(t.nsec())/1e3

		{"(Time).Second", Method, 0},
		{"(Time).String", Method, 0},
		{"(Time).Sub", Method, 0},
		{"(Time).Truncate", Method, 1},
		{"(Time).UTC", Method, 0},
		{"(Time).Unix", Method, 0},
		{"(Time).UnixMicro", Method, 17},
		{"(Time).UnixMilli", Method, 17},
		{"(Time).UnixNano", Method, 0},
		{"(Time).Weekday", Method, 0},
		{"(Time).Year", Method, 0},
		{"(Time).YearDay", Method, 1},