// token will receive heal status records from the running heal
// sequence.
//
// If no client token is provided, and a heal sequence is in progress
// an error is returned with information about the running heal
// sequence. However, if the force-start flag is provided, the server
// aborts the running heal sequence and starts a new one.

* The process can be **terminated** (or "killed") by you, or by the operating system. At that point, it stops running/being executed, and it can **no longer do things**.
* Each application that you have running on your computer has some process behind it, each running program, each window, etc. And there are normally many processes running **at the same time** while a computer is on.

And the **container** itself (in contrast to the **container image**) is the actual running instance of the image, comparable to a **process**. In fact, a container is running only when it has a **process running** (and normally it's only a single process). The container stops when there's no process running in it.

## Container Images { #container-images }

    String result;
    if (state == DONE) {
      result = "running=[DONE]";
    } else if (state instanceof Blocker) {
      result = "running=[INTERRUPTED]";
    } else if (state instanceof Thread) {
      // getName is final on Thread, no need to worry about exceptions
      result = "running=[RUNNING ON " + ((Thread) state).getName() + "]";
    } else {
      result = "running=[NOT STARTED YET]";
    }

         * Executes the crawling thread.
         * Sets the running flag, processes the data store, and ensures
         * proper cleanup regardless of success or failure.
         */
        @Override
        public void run() {
            running = true;
            try {
                process();
            } finally {
                running = false;
                finished = true;
            }
        }

        }
        super.tearDown();
    }

    public void test_getStatus_returnsCorrectValue() {
        // Since we cannot easily create a real ClusterHealthResponse without a running cluster,
        // we'll test the class behavior through unit tests that verify the logic
        // The actual integration with ClusterHealthResponse is tested in integration tests

    private final CountDownLatch stopLatch = new CountDownLatch(1);

    private volatile boolean running = false;

    @Override
    public @Nullable Void call() throws InterruptedException {
      running = true;
      startLatch.countDown();
      stopLatch.await();
      running = false;
      return null;
    }

    void waitForStart() throws InterruptedException {

 */
public class MockWitnessService implements AutoCloseable {
    private static final Logger log = LoggerFactory.getLogger(MockWitnessService.class);

    private ServerSocket serverSocket;
    private final AtomicBoolean running = new AtomicBoolean(false);
    private final AtomicInteger registrationCounter = new AtomicInteger(0);
    private final ConcurrentHashMap<String, MockRegistration> registrations = new ConcurrentHashMap<>();

We don't break binary compatibility with non-alpha APIs.


## Version 5.0.0-alpha.16

_2025-05-29_

 *  Fix: The previous release would crash when running on Robolectric. We didn't anticipate
    running our Android artifact on the JVM platform!


## Version 5.0.0-alpha.15

_2025-05-28_

    }

    /**
     * Checks if the crawler is currently running.
     *
     * @return true if the crawler is running, false otherwise
     */
    public boolean isCrawlerRunning() {
        return crawlerRunning;
    }

    /**
     * Sets the crawler running status.
     *
     * @param crawlerRunning true to indicate the crawler is running, false otherwise
     */