defaultTimeouts := kubeadmapi.GetActiveTimeouts()
		defaultAPICallTimeout := defaultTimeouts.KubernetesAPICall
		defaultTimeouts.KubernetesAPICall = &metav1.Duration{Duration: time.Microsecond * 500}
		defer func() {
			defaultTimeouts.KubernetesAPICall = defaultAPICallTimeout
		}()

		for _, tc := range tests {
			t.Run(tc.name, func(t *testing.T) {
				client := clientsetfake.NewSimpleClientset()

		defer func(old int) { trace.BandsPerSeries = old }(trace.BandsPerSeries)
		trace.BandsPerSeries = 1
		mmuCurve2 := trace.NewMMUCurve(mu)
		quantiles := []float64{0, 1 - .999, 1 - .99}
		for window := time.Microsecond; window < time.Second; window *= 10 {
			mud1 := mmuCurve.MUD(window, quantiles)
			mud2 := mmuCurve2.MUD(window, quantiles)
			for i := range mud1 {
				if !aeq(mud1[i], mud2[i]) {

			r2 = append(r2, bytes.Repeat([]byte{byte(i)}, 100)...)
			r2 = r2[100:]
		}
	}
	return r1, r2
}

// winch sends a few SIGWINCH signals to the process.
func winch() {
	ticker := time.NewTicker(100 * time.Microsecond)
	defer ticker.Stop()
	pid := syscall.Getpid()
	for n := 10; n > 0; n-- {
		syscall.Kill(pid, syscall.SIGWINCH)
		<-ticker.C
	}
}

// sendSomeSignals triggers a few SIGURG and SIGWINCH signals.

	switch len(logWriters) {
	case 0:
		logWriter = io.Discard
	case 1:
		logWriter = logWriters[0]
	default:
		logWriter = io.MultiWriter(logWriters...)
	}
	logger := log.New(logWriter, "", log.Ltime|log.Lmicroseconds|log.Lshortfile)

	// Fetch the upload config, if it is not provided.
	config, configVersion, err := configstore.Download("latest", rcfg.Env)
	if err != nil {
		return nil, err
	}

package v1

import (
	"encoding/json"
	"time"

	cbor "k8s.io/apimachinery/pkg/runtime/serializer/cbor/direct"
)

const RFC3339Micro = "2006-01-02T15:04:05.000000Z07:00"

// MicroTime is version of Time with microsecond level precision.
//
// +protobuf.options.marshal=false
// +protobuf.as=Timestamp
// +protobuf.options.(gogoproto.goproto_stringer)=false
type MicroTime struct {
	time.Time `protobuf:"-"`
}

			t.Fatalf("Failed to unmarshal log entry: %v", err)
		}
		return e.Time
	}

	t.Run("specified time", func(t *testing.T) {
		yesterday := time.Now().Add(-time.Hour * 24).Truncate(time.Microsecond)

		stdoutLines, _ := captureStdout(func() {
			o := DefaultOptions()
			o.JSONEncoding = true
			_ = Configure(o)
			defaultScope.LogWithTime(InfoLevel, "Hello", yesterday)
		})

				assert.Equal(t, c.cm.PodPidsLimit, got.podPidsLimit)
				assert.Equal(t, c.cm.EnforceCPULimits, got.enforceCPULimits)
				assert.Equal(t, uint64(c.cm.CPUCFSQuotaPeriod/time.Microsecond), got.cpuCFSQuotaPeriod)

			} else {
				assert.IsType(t, &podContainerManagerNoop{}, pcm)
				got := pcm.(*podContainerManagerNoop)
				assert.Equal(t, c.cm.cgroupRoot, got.cgroupRoot)
			}
		})
	}

	// Override the default timeouts to be shorter
	defaultTimeouts := kubeadmapi.GetActiveTimeouts()
	defaultAPICallTimeout := defaultTimeouts.KubernetesAPICall
	defaultTimeouts.KubernetesAPICall = &metav1.Duration{Duration: time.Microsecond * 500}
	defer func() {
		defaultTimeouts.KubernetesAPICall = defaultAPICallTimeout
	}()

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {

		t.Fatal(err)
	}
	return data
}

func sumExecutionTime(data format.Data) (sum time.Duration) {
	for _, e := range data.Events {
		sum += time.Duration(e.Dur) * time.Microsecond
	}
	return
}

func getTestTrace(t *testing.T, testPath string) *parsedTrace {
	t.Helper()

	// First read in the text trace and write it out as bytes.
	f, err := os.Open(testPath)

}

type Timespec struct {
	Sec  int32
	Nsec int32
}

type Timeval struct {
	Sec  int32
	Usec int32
}

func NsecToTimeval(nsec int64) (tv Timeval) {
	nsec += 999 // round up to microsecond
	tv.Usec = int32(nsec % 1e9 / 1e3)
	tv.Sec = int32(nsec / 1e9)
	return
}

func nsec() int64 {
	var scratch int64

	r0, _, _ := Syscall(SYS_NSEC, uintptr(unsafe.Pointer(&scratch)), 0, 0)