threadUnexpectedException(t);
    }
  }

  //     /**
  //      * Spin-waits up to LONG_DELAY_MS until flag becomes true.
  //      */
  //     public void await(AtomicBoolean flag) {
  //         await(flag, LONG_DELAY_MS);
  //     }

  //     /**
  //      * Spin-waits up to the specified timeout until flag becomes true.
  //      */

// defined in package runtime

// Semacquire waits until *s > 0 and then atomically decrements it.
// It is intended as a simple sleep primitive for use by the synchronization
// library and should not be used directly.
func runtime_Semacquire(s *uint32)

// Semacquire(RW)Mutex(R) is like Semacquire, but for profiling contended
// Mutexes and RWMutexes.
// If lifo is true, queue waiter at the head of wait queue.

    ExecHandleState getState();

    /**
     * Aborts the process, blocking until the process has exited. Does nothing if the process has already completed.
     */
    void abort();

    /**
     * Waits for the process to finish. Returns immediately if the process has already completed.
     *
     * @return result
     */
    ExecResult waitForFinish();

    /**

// Depending upon object type, waits afterward until the object is synced
// by the policy source
func (p *PolicyTestContext[P, B, E]) update(wait bool, objects ...runtime.Object) error {
	for _, object := range objects {
		if err := p.updateOne(object); err != nil {
			return err
		}
	}

	if wait {
		timeoutCtx, timeoutCancel := context.WithTimeout(p, 3*time.Second)

 *
 * <p>Provides some fixtures for testing:</p>
 *
 * <ul>
 * <li>An action starts another action asynchronously without waiting for the result.</li>
 * <li>An action starts another action asynchronously and waits for the result.</li>
 * </ul>
 */
class ConcurrentTestUtil extends ExternalResource {
    private static final Logger LOG = LoggerFactory.getLogger(ConcurrentTestUtil.class)

    private Lock lock = new ReentrantLock()

		t.Fatalf("failed to start KMS plugin: err: %v", err)
	}
	return result
}

// waitForBase64PluginToBeUp waits until the plugin is ready to serve requests.
func waitForBase64PluginToBeUp(plugin *Base64Plugin) error {
	var gRPCErr error
	var resp *kmsapi.StatusResponse
	pollErr := wait.PollImmediate(1*time.Second, wait.ForeverTestTimeout, func() (bool, error) {
		resp, gRPCErr = plugin.Status(context.Background(), &kmsapi.StatusRequest{})

// when f will run, in which case Reset returns true, or schedules f
// to run again, in which case it returns false.
// When Reset returns false, Reset neither waits for the prior f to
// complete before returning nor does it guarantee that the subsequent
// goroutine running f does not run concurrently with the prior
// one. If the caller needs to know whether the prior execution of

  virtual StatusOr<std::unique_ptr<ExecutableType>> LoadExecutable(
      const XlaCompiler::Options& options,
      const XlaCompiler::CompilationResult& result,
      const std::string& serialized_executable) = 0;

  // Waits for the underlying `ClientType` backend's programs to finish
  // executing before returning.
  virtual void WaitForProgramsToFinish() = 0;

  virtual ClientType* client() const = 0;

 private:

     */
    void add(T operation);

    /**
     * Cancels all queued operations in this queue.  Any operations that have started will be allowed to complete.
     */
    void cancel();

    /**
     * Waits for all previously added operations to complete.
     * <p>
     * On failure, some effort is made to cancel any operations that have not started.
     *

	return fake.NewSimpleClientset(
		NewRuntimeClass(EmptyRuntimeClass, ""),
		NewRuntimeClass(SandboxRuntimeClass, SandboxRuntimeHandler),
	)
}

// StartManagerSync starts the manager, and waits for the informer cache to sync.
// Returns a function to stop the manager, which should be called with a defer:
//
//	defer StartManagerSync(t, m)()
func StartManagerSync(m *runtimeclass.Manager) func() {