}

    eventListener.canceled(this)
  }

  override fun isCanceled(): Boolean = canceled

  override fun execute(): Response {
    check(executed.compareAndSet(false, true)) { "Already Executed" }

    timeout.enter()
    callStart()
    try {
      client.dispatcher.executed(this)
      return getResponseWithInterceptorChain()
    } finally {
      client.dispatcher.finished(this)
    }
  }

                    logger.debug("Process {} is already executed.", p);
                }
            }
        }

        /**
         * Checks if the destroyer has been executed.
         * @return True if executed, false otherwise.
         */
        public boolean isExecuted() {
            return executed.get();
        }
    }

    /**

import org.jspecify.annotations.Nullable;

/**
 * Executor ensuring that all Runnables submitted are executed in order, using the provided
 * Executor, and sequentially such that no two will ever be running at the same time.
 *
 * <p>Tasks submitted to {@link #execute(Runnable)} are executed in FIFO order.
 *
 * <p>The execution of tasks is done by one thread as long as there are tasks left in the queue.

    }

    /**
     * Sets the time taken to execute the search query in milliseconds.
     *
     * @param queryTime The query execution time in milliseconds
     */
    public void setQueryTime(final long queryTime) {
        this.queryTime = queryTime;
    }

    /**
     * Sets the actual search query executed against the search engine.
     *

     *
     * @return the execution type (e.g., "crawler", "suggest", etc.)
     */
    protected abstract String getExecuteType();

    /**
     * Executes the job with the specified job executor.
     * This method sets the job executor and then calls the abstract execute method.
     *
     * @param jobExecutor the job executor to use for execution
     * @return the execution result message or summary
     */

      if (executeImmediate) {
        new RunnableExecutorPair(runnable, executor).execute();
      }
    }

    void execute() {
      synchronized (runnables) {
        if (executed) {
          return;
        }
        executed = true;
      }

      while (!runnables.isEmpty()) {
        runnables.poll().execute();
      }
    }

    private static class RunnableExecutorPair {

 *
 * This class ensures that at most one thread is running at a time. This is initially the JUnit test
 * thread, which yields its execution privilege while calling [runTasks], [runNextTask], or
 * [advanceUntil]. These functions don't return until the task threads are all idle.
 *
 * Task threads release their execution privilege in these ways:
 *
 *  * By yielding in [TaskRunner.Backend.coordinatorWait].
 *  * By yielding in [BlockingQueue.poll].

 * This class coordinates the execution of data store crawling processes,
 * managing multiple concurrent crawling threads and handling the indexing
 * of crawled documents into the search engine.
 *
 * <p>The DataIndexHelper supports:</p>
 * <ul>
 *   <li>Concurrent crawling of multiple data configurations</li>
 *   <li>Thread pool management for crawler execution</li>

        scoreUpdater.addScoreBooster(booster2);
        scoreUpdater.addScoreBooster(booster3);

        // Clear execution order before test
        PriorityTrackingBooster.clearExecutionOrder();

        scoreUpdater.execute();

        // Due to integer overflow in comparator, execution order is affected for extreme values
        // The comparator b2 - b1 with MAX_VALUE and MIN_VALUE causes overflow

   * one of the listener's callbacks will execute at once. However, multiple listeners' callbacks
   * may execute concurrently, and listeners may execute in an order different from the one in which
   * they were registered.
   *
   * <p>RuntimeExceptions thrown by a listener will be caught and logged. Any exception thrown
   * during {@code Executor.execute} (e.g., a {@code RejectedExecutionException}) will be caught and