}
}

func TestStreamWatcherRace(t *testing.T) {
	fd := fakeDecoder{err: fmt.Errorf("test error")}
	fr := &fakeReporter{}
	sw := NewStreamWatcher(fd, fr)
	time.Sleep(10 * time.Millisecond)
	sw.Stop()
	time.Sleep(10 * time.Millisecond)
	_, ok := <-sw.ResultChan()
	if ok {
		t.Fatalf("unexpected pending send")
	}

		c, _ := aes.NewCipher(ft.key)

		cbcAsm := cipher.NewCBCEncrypter(c, commonIV)
		cbcGeneric := cipher.NewCBCGenericEncrypter(c, commonIV)

		if testing.Short() {
			timeout = time.NewTimer(10 * time.Millisecond)
		} else {
			timeout = time.NewTimer(2 * time.Second)
		}

		indata := make([]byte, datalen)
		outgeneric := make([]byte, datalen)
		outdata := make([]byte, datalen)

	fuzzencrypt:
		for {

				{
					// endpoints.Run needs ~100 ms to start processing updates.
					delay:   200 * time.Millisecond,
					podName: "pod0",
					podIP:   "10.0.0.0",
				},
				{
					delay:   100 * time.Millisecond,
					podName: "pod1",
					podIP:   "10.0.0.1",
				},
				{
					delay:   100 * time.Millisecond,
					podName: "pod2",
					podIP:   "10.0.0.2",
				},
			},

limitations under the License.
*/

package cacher

import (
	"sync"
	"time"

	"k8s.io/utils/clock"
)

const (
	refreshPerSecond = 50 * time.Millisecond
	maxBudget        = 100 * time.Millisecond
)

// timeBudget implements a budget of time that you can use and is
// periodically being refreshed. The pattern to use it is:
//
//	budget := newTimeBudget(...)
//	...

	}

	// causes mutexHog2 call stacks to appear in the mutex profile.
	done := make(chan bool)
	go func() {
		for {
			mutexHog(20*time.Millisecond, mutexHog2)
			select {
			case <-done:
				done <- true
				return
			default:
				time.Sleep(10 * time.Millisecond)
			}
		}
	}()
	defer func() { // cleanup the above goroutine.
		done <- true
		<-done // wait for the goroutine to exit.
	}()

			c.Write([]byte(data))
			c.Close()
		}
	}()
	t.Cleanup(func() {
		n.Close()
	})
	return n.Addr().String()
}

func TestDialerError(t *testing.T) {
	timeout := 500 * time.Millisecond
	d := NewDialer(Config{
		ProxyAddress: "127.0.0.10:1", // Random address that should fail to dial
		Headers: map[string][]string{
			"some-addition-metadata": {"test-value"},
		},

func TestTimeBudget(t *testing.T) {
	fakeClock := testingclock.NewFakeClock(time.Now())

	budget := &timeBudgetImpl{
		clock:     fakeClock,
		budget:    time.Duration(0),
		maxBudget: 200 * time.Millisecond,
		refresh:   50 * time.Millisecond,
		last:      fakeClock.Now(),
	}
	if res := budget.takeAvailable(); res != time.Duration(0) {
		t.Errorf("Expected: %v, got: %v", time.Duration(0), res)
	}

exists $WORK/cpu_profile_twice.out


-- x/x_test.go --
package x_test
import (
    "testing"
    "time"
)
func TestSleep(t *testing.T) {
    time.Sleep(10 * time.Millisecond)

		if secret == nil || secret.Name != "name" || secret.Namespace != "ns" {
			return false, fmt.Errorf("unexpected secret: %v", secret)
		}
		return true, nil
	}
	if err := wait.PollImmediate(10*time.Millisecond, time.Second, getFn); err != nil {
		t.Errorf("unexpected error: %v", err)
	}

	// Eventually we should observer secret deletion.
	fakeWatch.Delete(secret)
	getFn = func() (bool, error) {

			stillActive:                true,
			jobCreationTime:            topOfTheHour().Add(time.Millisecond * 100),
			now:                        justAfterTheHour().Add(time.Millisecond * 100),
			expectActive:               1,
			expectRequeueAfter:         true,
			expectedRequeueDuration:    1*time.Hour - 1*time.Minute - time.Millisecond*100 + nextScheduleDelta,
			jobStillNotFoundInLister:   true,
			jobPresentInCJActiveStatus: true,