try {
      InetAddress.getByName("www.google.com")
    } catch (uhe: UnknownHostException) {
      throw TestAbortedException(uhe.message, uhe)
    }
  }

  fun OkHttpClient.close() {
    dispatcher.executorService.shutdown()
    connectionPool.evictAll()
  }

    val plexusCipher = "org.sonatype.plexus:plexus-cipher"
    val plexusInterpolation = "org.codehaus.plexus:plexus-interpolation"
    val plexusSecDispatcher = "org.codehaus.plexus:plexus-sec-dispatcher"
    val plexusClassworlds = "org.codehaus.plexus:plexus-classworlds"
    val plexusUtils = "org.codehaus.plexus:plexus-utils"
    val plist = "com.googlecode.plist:dd-plist"

 *  Fix: Don't log response bodies for server-sent events.
 *  Fix: Skip early hints (status code 103) responses.
 *  Fix: Don't log sensitive headers in `Request.toString()`.
 *  Fix: Don't crash when the dispatcher's `ExecutorService` is shutdown with many
    calls still enqueued.
 *  Upgrade: [GraalVM 22][graalvm_22].
 *  Upgrade: [Kotlin 1.7.10][kotlin_1_7_10].


## Version 5.0.0-alpha.10

_2022-06-26_

      if (windowSize != DEFAULT_INITIAL_WINDOW_SIZE) {
        writer.windowUpdate(0, (windowSize - DEFAULT_INITIAL_WINDOW_SIZE).toLong())
      }
    }
    // Thread doesn't use client Dispatcher, since it is scoped potentially across clients via
    // ConnectionPool.
    taskRunner.newQueue().execute(name = connectionName, block = readerRunnable)
  }

  @BeforeEach
  fun setUp(server: MockWebServer) {
    this.server = server
    platform.assumeNotOpenJSSE()
    listener.forbidLock(get(client.connectionPool))
    listener.forbidLock(client.dispatcher)
  }

  @AfterEach
  fun tearDown() {
    if (socksProxy != null) {
      socksProxy!!.shutdown()
    }
    if (cache != null) {
      cache!!.delete()
    }
  }

  @Test

 * #enqueue enqueueing} and then {@linkplain #dispatch dispatching} events.
 *
 * <p>The API of this class is designed to make it easy to achieve the following properties
 *
 * <ul>
 *   <li>Multiple events for the same listener are never dispatched concurrently.
 *   <li>Events for the different listeners are dispatched concurrently.
 *   <li>All events for a given listener dispatch on the provided {@link #executor}.

        "//tensorflow/core/common_runtime/eager:tensor_handle",
        "//tensorflow/core/config:flag_defs",
        "//tensorflow/core/config:flags",
        "//tensorflow/core/data/service:dispatcher_client",
        "//tensorflow/core/data/service:grpc_util",
        "//tensorflow/core/data/service:py_utils",
        "//tensorflow/core/data/service:server_lib",
        "//tensorflow/core/debug",

    register a dataset with the tf.data service, and another process to consume
    data from the dataset.
*   Adds support for dispatcher fault tolerance. To enable fault tolerance,
    configure a `work_dir` when running your dispatcher server and set
    `dispatcher_fault_tolerance=True`. The dispatcher will store its state to
    `work_dir`, so that on restart it can continue from its previous state after
    restart.

        // If caller wants only a classpath, JUnit shall move there.
        dispatched = session.resolveDependencies(coord, PathScope.TEST_COMPILE, Arrays.asList(JavaPathType.CLASSES));
        classes = dispatched.get(JavaPathType.CLASSES);
        modules = dispatched.get(JavaPathType.MODULES);
        unresolved = dispatched.get(PathType.UNRESOLVED);
        assertEquals(2, dispatched.size());
        assertEquals(1, unresolved.size());

            }

            /**
             * Returns correct importable name for implicitly dispatched callable - that is, a callable
             * which has a dispatch receiver, but whose dispatch receiver is present implicitly. The most
             * important case for that is the following:
             *
             * ```kt
             * import MyObject.bar