/** Dispatcher is not [Lockable] because we don't want that type in our public API. */
internal fun Dispatcher.assertLockNotHeld() {
  if (assertionsEnabled && Thread.holdsLock(this)) {
    throw AssertionError("Thread ${Thread.currentThread().name} MUST NOT hold lock on $this")
  }
}

/**
 * Returns the string "OkHttp" unless the library has been shaded for inclusion in another library,

        static final ThreadGroup GROUP = new ThreadGroup(THREADGROUP_NAME);

        static final AtomicInteger THREAD_NUMBER = new AtomicInteger(1);

        @Override
        public Thread newThread(Runnable r) {
            Thread newThread = new Thread(GROUP, r, "resolver-" + THREAD_NUMBER.getAndIncrement());
            newThread.setDaemon(true);
            newThread.setContextClassLoader(null);
            return newThread;
        }

    private final AtomicInteger registrationCounter = new AtomicInteger(0);
    private final ConcurrentHashMap<String, MockRegistration> registrations = new ConcurrentHashMap<>();
    private Thread serverThread;

    /**
     * Mock registration data
     */
    private static class MockRegistration {
        final String registrationId;
        final String shareName;
        final String serverAddress;

            int expectedSize = buffer.size();

            // Create multiple threads to call size()
            Thread[] threads = new Thread[10];
            for (int i = 0; i < threads.length; i++) {
                threads[i] = new Thread(() -> {
                    for (int j = 0; j < 1000; j++) {
                        assertEquals(expectedSize, buffer.size());
                    }

        final int THREAD_COUNT = 10;
        Thread[] threads = new Thread[THREAD_COUNT];
        final boolean[] success = new boolean[THREAD_COUNT];

        for (int i = 0; i < THREAD_COUNT; i++) {
            final int index = i;
            threads[i] = new Thread(() -> {
                try {
                    byte[] buffer = new byte[512];

        final int THREAD_COUNT = 10;
        Thread[] threads = new Thread[THREAD_COUNT];
        final boolean[] success = new boolean[THREAD_COUNT];

        for (int i = 0; i < THREAD_COUNT; i++) {
            final int index = i;
            threads[i] = new Thread(() -> {
                try {
                    byte[] buffer = new byte[512];

    var ms = nanos / 1_000_000L
    val ns = nanos - (ms * 1_000_000L)

    while (ms > 100) {
      Thread.sleep(100)
      if (javaNetSocket.isClosed) throw InterruptedIOException("socket closed")
      ms -= 100L
    }

    if (ms > 0L || ns > 0) {
      Thread.sleep(ms, ns.toInt())
    }
  }

  override fun cancel() {
    delegate.cancel()
  }

  override fun close() {

 * are stored in the cache until either evicted or manually invalidated. The common way to build
 * instances is using {@link CacheBuilder}.
 *
 * <p>Implementations of this interface are expected to be thread-safe, and can be safely accessed
 * by multiple concurrent threads.
 *
 * <p>When evaluated as a {@link Function}, a cache yields the same result as invoking {@link
 * #getUnchecked}.
 *

    public void testSwitchIndex_unexpectedUpdateIndicesCount() throws Exception {
        final Suggester suggester = Suggester.builder().build(client, "switch-test");
        suggester.createIndexIfNothing();
        Thread.sleep(50);

        // Create additional update index (making 2 total)
        final String updateAlias = suggester.getIndex() + ".update";
        final String extraIndexName = suggester.getIndex() + ".extra";

    List<Thread> threads = new ArrayList<>(numThreads);
    List<Throwable> exceptions = new ArrayList<>(numThreads);
    for (int i = 0; i < numThreads; i++) {
      Thread thread = new Thread(task);
      thread.setUncaughtExceptionHandler((t, throwable) -> exceptions.add(throwable));
      threads.add(thread);
    }
    for (Thread t : threads) {
      t.start();
    }