func (m *MicroTime) ProtoMicroTime() *Timestamp {
	if m == nil {
		return &Timestamp{}
	}

	// truncate precision to microseconds to match JSON marshaling/unmarshaling
	truncatedNanoseconds := time.Duration(m.Time.Nanosecond()).Truncate(time.Microsecond)
	return &Timestamp{
		Seconds: m.Time.Unix(),
		Nanos:   int32(truncatedNanoseconds),
	}
}

// Size implements the protobuf marshalling interface.

	"time"

	"go.uber.org/atomic"

	"istio.io/istio/pkg/test/util/assert"
	"istio.io/istio/pkg/test/util/retry"
)

func TestOrdering(t *testing.T) {
	numValues := 1000

	q := NewQueue(1 * time.Microsecond)
	stop := make(chan struct{})
	defer close(stop)

	wg := sync.WaitGroup{}
	wg.Add(numValues)
	mu := sync.Mutex{}
	out := make([]int, 0)
	for i := 0; i < numValues; i++ {
		i := i

    class ModelWithDatetimeField(BaseModel):
        dt_field: datetime

        @field_serializer("dt_field")
        def serialize_datetime(self, dt_field: datetime):
            return dt_field.replace(microsecond=0, tzinfo=timezone.utc).isoformat()

    app = FastAPI()
    model = ModelWithDatetimeField(dt_field=datetime(2019, 1, 1, 8))

    @app.get("/model", response_model=ModelWithDatetimeField)
    def get_model():

		ID:       id,
		Time:     float64(from.end.UnixNano()) / float64(time.Microsecond),
		Phase:    phaseFlowStart,
		TID:      from.tid,
	})
	tc.t.writeEvent(&format.Event{
		Name:      from.name + " -> " + to.name,
		Category:  "flow", // TODO(matloob): Add Category to Flow?
		ID:        id,
		Time:      float64(to.start.UnixNano()) / float64(time.Microsecond),
		Phase:     phaseFlowEnd,
		TID:       to.tid,

}

// MicrosToDuration converts the given microseconds to a time.Duration.
func MicrosToDuration(micros int64) time.Duration {
	return time.Duration(micros) * time.Microsecond
}

// DurationToMicros converts the given duration to microseconds.
func DurationToMicros(d time.Duration) int64 {
	return int64(d / time.Microsecond)

import (
	"sync"
	"testing"
	"time"

	"istio.io/istio/pilot/pkg/features"
)

func BenchmarkMetricsQueue(b *testing.B) {
	features.EnableControllerQueueMetrics = true
	q := NewQueue(1 * time.Microsecond)
	s := make(chan struct{})
	go q.Run(s)
	for n := 0; n < b.N; n++ {
		wg := sync.WaitGroup{}
		wg.Add(1)
		q.Push(func() error {
			wg.Done()
			return nil
		})
		wg.Wait()

	}
	close(s)

	ch := make(chan bool, 2)
	go func() {
		x = 1
		mu.Lock()
		written = true
		mu.Unlock()
		ch <- true
	}()
	go func() {
		time.Sleep(100 * time.Microsecond)
		mu.Lock()
		for !written {
			mu.Unlock()
			time.Sleep(100 * time.Microsecond)
			mu.Lock()
		}
		mu.Unlock()
		x = 1
		ch <- true
	}()
	<-ch
	<-ch
}

func TestNoRaceMutexSemaphore(t *testing.T) {
	var mu sync.Mutex

	allErrs = append(allErrs, ValidateImmutableField(newEvent.Type, oldEvent.Type, field.NewPath("type"))...)

	// Disallow changes to eventTime greater than microsecond-level precision.
	// Tolerating sub-microsecond changes is required to tolerate updates
	// from clients that correctly truncate to microsecond-precision when serializing,
	// or from clients built with incorrect nanosecond-precision protobuf serialization.

	}
	if result {
		t.Fatal("CheckEtcdServers should not have succeeded")
	}
}

func TestPollCheckServer(t *testing.T) {
	err := utilwait.PollImmediate(1*time.Microsecond,
		2*time.Microsecond,
		EtcdConnection{ServerList: []string{""}}.CheckEtcdServers)
	if err == nil {
		t.Fatal("expected check to time out")
	}

	start time.Time
}

func (c *TestClock) Now() time.Time {
	t := c.start.Add(c.i)
	c.i += time.Second
	return t
}

func TestRetry(t *testing.T) {
	o := DefaultOption()
	o.InitialInterval = 1 * time.Microsecond
	ebf := NewExponentialBackOff(o)

	// Run a task that fails the first time and retries.
	wg := sync.WaitGroup{}
	wg.Add(2)
	failed := false
	err := ebf.RetryWithContext(context.TODO(), func() error {