}
			// This call can have different handlers, but the default chain rate limits. Call it after the metrics are updated
			// in case the rate limit delays it.  If you outrun the rate for this one timed out requests, something has gone
			// seriously wrong with your server, but generally having a logging signal for timeouts is useful.

			done := make(chan bool)

			go func() {
				select {
				case res := <-outChan:
					assert.Equal(t, tc.shutdownActive, res)
					done <- true
				case <-time.After(5 * time.Second):
					t.Errorf("Timed out waiting for shutdown message")
					done <- true
				}
			}()

			signal := &dbus.Signal{Body: []interface{}{tc.shutdownActive}}
			fakeSystemBus.signalChannel <- signal
			<-done
		})
	}

				return true, nil
			}
			t.Logf("expected %#v, got %#v, will retry", expected, fakePluginHandler.events)
			return false, nil
		},
	)
	if err != nil {
		t.Fatalf("Timed out waiting for plugin to be added to actual state of world cache.")
	}
}

func retryWithExponentialBackOff(initialDuration time.Duration, fn wait.ConditionFunc) error {
	backoff := wait.Backoff{

				r.cmd = etcdCmd
				return nil
			}
		case <-done:
			err = etcdCmd.Process.Kill()
			if err != nil {
				return fmt.Errorf("error killing etcd: %v", err)
			}
			return fmt.Errorf("timed out waiting for etcd on port %d", r.cfg.port)
		}
	}
}

// Stop terminates the etcd server process. If the etcd server process has not been started
// or is not still running, this returns an error.

			w := httptest.NewRecorder()
			w.Code = 0
			handler.ServeHTTP(w, req)
			responseGot := w.Result()

			if test.handlerInvoked != handlerInvokedGot {
				t.Errorf("expected the handler to be invoked: %d timed, but got: %d", test.handlerInvoked, handlerInvokedGot)
			}
			if test.statusCodeExpected != responseGot.StatusCode {
				t.Errorf("expected status code: %d, but got: %d", test.statusCodeExpected, w.Result().StatusCode)
			}

}

func TestSink() {
	c := _Sink[int](context.Background())
	after := time.NewTimer(time.Minute)
	defer after.Stop()
	send := func(v int) {
		select {
		case c <- v:
		case <-after.C:
			panic("timed out sending to _Sink")
		}
	}
	send(1)
	send(2)
	send(3)
	close(c)
}

func TestExclusive() {
	val := 0
	ex := _MakeExclusive(&val)

	var wg sync.WaitGroup
	f := func() {

	Client kube.Client

	kubeConfigSha [sha256.Size]byte

	stop chan struct{}
	// initialSync is marked when RunAndWait completes
	initialSync *atomic.Bool
	// initialSyncTimeout is set when RunAndWait timed out
	initialSyncTimeout *atomic.Bool
}

type ACTION int

const (
	Add ACTION = iota
	Update
)

func (a ACTION) String() string {
	switch a {
	case Add:
		return "Add"
	case Update:

				c++
				tt += responseTimes[id]
			}
		}
		var avgTime time.Duration
		if c > 0 {
			avgTime = tt / time.Duration(c)
		}
		return nil, fmt.Errorf("request set timed out after %v and only %d/%d requests completed (%v avg)",
			cfg.timeout, c, cfg.count, avgTime)
	}

		select {
		case u := <-m.Updates():
			if expected != u {
				t.Errorf("Expected update %v, received %v: %s", expected, u, msg)
			}
		case <-time.After(wait.ForeverTestTimeout):
			t.Errorf("Timed out waiting for update %v: %s", expected, msg)
		}
	}

	expectNoUpdate := func(msg string) {
		// NOTE: Since updates are accumulated asynchronously, this method is not guaranteed to fail

            if (finished != null) {
                LOGGER.debug("Received finished message: {}", finished);
            } else {
                LOGGER.warn(String.format("Timed out waiting for finished message from client %s. Discarding connection.", connection));
            }
        }
    }