fun takeAll(): List<String> {
    val list = mutableListOf<String>()
    logs.drainTo(list)
    return list
  }

  fun take(): String {
    return logs.poll(10, TimeUnit.SECONDS)
      ?: throw AssertionError("Timed out waiting for log message.")
  }

		g.e.totalRequests.Inc()
		g.e.activeRequests.Inc()
		defer g.e.activeRequests.Dec()

		// Acquire the group concurrency semaphore.
		if err := g.sem.Acquire(ctx, 1); err != nil {
			return fmt.Errorf("request set timed out: %v", err)
		}
		defer g.sem.Release(1)

		return work()
	})
}

func (g *execGroup) Wait() *multierror.Error {
	return g.g.Wait()
}

func (e *executor) Close() {
	close(e.stopCh)

	writeMessage(t, path, &n)

	select {
	case <-doneCh:
		g.Expect(newN).To(Equal(&n))
		g.Expect(w.Networks()).To(Equal(newN))
		break
	case <-time.After(time.Second * 5):
		t.Fatal("timed out waiting for update")
	}
}

func newNetworksWatcher(t *testing.T, filename string) mesh.NetworksWatcher {
	t.Helper()
	w, err := mesh.NewNetworksWatcher(filewatcher.NewWatcher(), filename)
	if err != nil {

		}

		if errors.Is(err, remote.ErrCommandTimedOut) {
			if utilfeature.DefaultFeatureGate.Enabled(features.ExecProbeTimeout) {
				return probe.Failure, err.Error(), nil
			}

			klog.Warningf("Exec probe timed out but ExecProbeTimeout feature gate was disabled")
		}

		return probe.Unknown, "", err
	}
	return probe.Success, string(data), nil

      throws TimeoutException, ExecutionException {
    SettableFuture<String> future = SettableFuture.create();
    future.set(RESULT);
    /*
     * getUninterruptibly should call the timed get method once with a
     * wait of 0 seconds (and it should succeed, since the result is already
     * available).
     */
    assertEquals(RESULT, getUninterruptibly(future, 0, SECONDS));
  }

	for {
		select {
		case e := <-fx.Events:
			if e.Type == et {
				return &e
			}
			log.Infof("skipping event %q want %q", e.Type, et)
			continue
		case <-delay.C:
			t.Fatalf("timed out waiting for %v", et)
		}
	}
}

// MatchOrFail expects the provided events to arrive, skipping unmatched events
func (fx *Updater) MatchOrFail(t test.Failer, events ...Event) {
	t.Helper()

		svcHandler.lock.Lock()
		defer svcHandler.lock.Unlock()
		if reflect.DeepEqual(svcHandler.state, expectedSvcState) {
			return true, nil
		}
		return false, nil
	})
	if err != nil {
		t.Fatal("Timed out waiting for the completion of handler `OnServiceAdd`")
	}

	err = wait.PollImmediate(time.Millisecond*10, wait.ForeverTestTimeout, func() (bool, error) {
		epsHandler.lock.Lock()
		defer epsHandler.lock.Unlock()

      throws TimeoutException, ExecutionException {
    SettableFuture<String> future = SettableFuture.create();
    future.set(RESULT);
    /*
     * getUninterruptibly should call the timed get method once with a
     * wait of 0 seconds (and it should succeed, since the result is already
     * available).
     */
    assertEquals(RESULT, getUninterruptibly(future, 0, SECONDS));
  }

	defer klog.Infof("Shutting down system namespaces controller")

	klog.Infof("Starting system namespaces controller")

	if !cache.WaitForCacheSync(stopCh, c.namespaceSynced) {
		utilruntime.HandleError(fmt.Errorf("timed out waiting for caches to sync"))
		return
	}

	go wait.Until(c.sync, c.interval, stopCh)

	<-stopCh
}

func (c *Controller) sync() {
	// Loop the system namespace list, and create them if they do not exist

	defer timer.Stop()
	select {
	case p := <-plat:
		return p
	case <-done:
		select {
		case p := <-plat:
			return p
		default:
			return &Unknown{}
		}
	case <-timer.C:
		log.Info("timed out waiting for platform detection, treating it as Unknown")
		return &Unknown{}
	}