@Test
    public void test_process_withJobLogId_setsIdOnJobLog() {
        final ScheduledJob scheduledJob = createTestScheduledJob("proc-1", true);
        final AtomicReference<JobLog> storedJobLog = new AtomicReference<>();

        registerComponents(scheduledJob, storedJobLog);

        // Create runtime with JOB_LOG_ID parameter
        final Map<String, Object> params = new HashMap<>();

        final AtomicBoolean storeCalled = new AtomicBoolean(false);
        final AtomicReference<DataConfig> capturedConfig = new AtomicReference<>();
        final AtomicReference<IndexUpdateCallback> capturedCallback = new AtomicReference<>();
        final AtomicReference<DataStoreParams> capturedParams = new AtomicReference<>();

        dataStore = new DataStore() {
            @Override

    @Test
    public void test_OnConnect_ReceivesBothRequestAndConnection() throws Exception {
        // ## Arrange ##
        AtomicReference<CurlRequest> receivedRequest = new AtomicReference<>();
        AtomicReference<HttpURLConnection> receivedConnection = new AtomicReference<>();
        CurlRequest req = new OpenOverrideCurlRequest(Curl.Method.GET, "http://dummy",

            @Override
            public void close() {
            }
        };

        CountDownLatch latch = new CountDownLatch(1);
        AtomicReference<SuggestIndexResponse> responseRef = new AtomicReference<>();
        AtomicReference<Throwable> errorRef = new AtomicReference<>();

        Deferred<SuggestIndexResponse>.Promise promise = suggester.indexer().indexFromQueryLog(emptyReader, 10, 0);

        final Deferred<SuggestResponse> deferred = new Deferred<>();
        final AtomicInteger callbackCount = new AtomicInteger(0);
        final AtomicReference<String> receivedIndex = new AtomicReference<>();

        deferred.promise().then(response -> {
            callbackCount.incrementAndGet();
            receivedIndex.set(response.getIndex());
        });

    //                                                                    ================

    @Test
    public void test_startWithParams_passesParamsToLaunchNow() {
        final AtomicReference<LaunchNowOption> capturedOption = new AtomicReference<>();
        final AtomicBoolean launchNowCalled = new AtomicBoolean(false);

        final LaScheduledJob mockLaJob = createMockLaScheduledJob(opCall -> {

            keyMap.bind(new Reference("tailtip-toggle"), KeyMap.alt("s"));

            // start the shell and process input until the user quits with Ctrl-D
            AtomicReference<Exception> failure = new AtomicReference<>();
            while (true) {
                try {
                    failure.set(null);
                    systemRegistry.cleanUp();

import java.io.InterruptedIOException
import java.net.HttpURLConnection
import java.time.Duration
import java.util.concurrent.CountDownLatch
import java.util.concurrent.TimeUnit
import java.util.concurrent.atomic.AtomicReference
import kotlin.test.assertFailsWith
import mockwebserver3.MockResponse
import mockwebserver3.MockWebServer
import mockwebserver3.junit5.StartStop
import okhttp3.MediaType.Companion.toMediaTypeOrNull

// Since this class only needs CAS on one field, we can avoid this bug by extending AtomicReference
// instead of using an AtomicReferenceFieldUpdater. This reference stores Thread instances
// and DONE/INTERRUPTED - they have a common ancestor of Runnable.
abstract class InterruptibleTask<T extends @Nullable Object>
    extends AtomicReference<@Nullable Runnable> implements Runnable {
  static {

    assertThat(segment.recencyQueue.isEmpty()).isFalse();
  }

  public void testRecursiveComputation() throws InterruptedException {
    AtomicReference<LoadingCache<Integer, String>> cacheRef = new AtomicReference<>();
    CacheLoader<Integer, String> recursiveLoader =
        new CacheLoader<Integer, String>() {
          @Override
          public String load(Integer key) {