val atomicTags = AtomicReference<Tags>(tags)
    val result =
      atomicTags.computeIfAbsent(String::class) {
        // 'Race' by making another computeIfAbsent call. In practice this would be another thread.
        assertThat(atomicTags.computeIfAbsent(Integer::class) { 5 as Integer }).isEqualTo(5)
        "a"
      }
    assertThat(result).isEqualTo("a")
    assertThat(atomicTags.get()[String::class]).isEqualTo("a")

                }
            }).start();
        }

        // Signal all threads to start at once
        startLatch.countDown();

        // Wait for all threads to complete
        assertTrue("Threads did not complete in time", doneLatch.await(5, TimeUnit.SECONDS));

        // All threads should fail with the same IOException (project ID is blank)

        } catch (final UnsupportedEncodingException e) {
            throw new CurlException("Invalid encoding: " + encoding, e);
        }
    }

    /**
     * Sets the thread pool for executing the request.
     *
     * @param threadPool the thread pool
     * @return this CurlRequest instance
     */
    public CurlRequest threadPool(final ForkJoinPool threadPool) {
        this.threadPool = threadPool;

                    fail("Thread failed: " + e.getMessage());
                } finally {
                    doneLatch.countDown();
                }
            });
        }

        // Start all threads at once
        startLatch.countDown();

        // Wait for completion
        assertTrue(doneLatch.await(5, TimeUnit.SECONDS), "Threads did not complete in time");
        executor.shutdown();

    } catch (ExecutionException e) {
      throw new AssertionError(e);
    }
  }

  static void verifyThreadWasNotInterrupted() {
    assertFalse(Thread.currentThread().isInterrupted());
  }

  static void clearInterrupt() {
    Thread.interrupted();
  }

  /**
   * Retrieves the result of a {@code Future} known to be done but uses the {@code get(long,
   * TimeUnit)} overload in order to test that method.

        HcHttpClient client = new HcHttpClient() {
            @Override
            protected ResponseData processHttpMethod(final String url, final HttpUriRequest httpRequest) {
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    throw new CrawlingAccessException(e);
                }
                return null;
            }
        };

                    t.url = args[ai];
                }
            }

            assertEquals(expectedUrl, t.url, "URL should be correctly parsed");
            assertEquals(2, t.numThreads, "Thread count should be parsed");
            assertEquals(5, t.numIter, "Iteration count should be parsed");
            assertEquals(100L, t.delay, "Delay should be parsed");
        }

        @Test

                    builder.directory(shellContext.cwd.get().toFile());
                    Process process = builder.start();
                    Thread out = new Thread(new StreamGobbler(process.getInputStream(), shellContext.writer));
                    Thread err = new Thread(new StreamGobbler(process.getErrorStream(), shellContext.logger::error));
                    out.start();
                    err.start();

    }

    /** The incremental crawling setting. */
    public String incrementalCrawling;

    /** The day for cleanup setting. */
    public String dayForCleanup;

    /** The crawling thread count setting. */
    public String crawlingThreadCount;

    /** The search log setting. */
    public String searchLog;

    /** The user info setting. */
    public String userInfo;

    /**
     * Sets the currently active session. Some legacy components are basically stateful and their API is missing
     * parameters that would be required to delegate to a stateless component. Saving the session (in a thread-local
     * variable) is our best effort to record any state that is required to enable proper delegation.
     *
     * @param session The currently active session, may be {@code null}.
     */