"box-shadow":
          "0 1px 1px 0px rgba(0, 0, 0, 0.1), 0 3px 2px 0px rgba(82, 168, 236, 0.2)",
        "background-color": "#fff",
        "z-index": "10000"
      },
      listSelectedCssInfo: {
        "background-color": "rgba(82, 168, 236, 0.1)"
      },
      listDeselectedCssInfo: {
        "background-color": "#ffffff"
      },
      minterm: 1,
      adjustWidthVal: 11,
      searchForm: $("#searchForm")

              public Boolean call() {
                return blockingCallable.isRunning();
              }
            },
            directExecutor());

    // Wait for the first task to be started in the background. It will block until we explicitly
    // stop it.
    blockingCallable.waitForStart();

    // Give the second task a chance to (incorrectly) start up while the first task is running.

import java.net.Socket
import okhttp3.Connection
import okhttp3.Handshake
import okhttp3.HttpUrl
import okhttp3.Protocol
import okhttp3.Route

/**
 * A user that is a connection pool creating connections in the background
 * without an intent to immediately use them.
 */
object PoolConnectionUser : ConnectionUser {
  override fun addPlanToCancel(connectPlan: ConnectPlan) {
  }

        final String[] values = form.id.split(":");
        return ComponentUtil.getPluginHelper().getArtifact(values[0], values[1]);
    }

    /**
     * Installs the specified artifact in a background thread.
     * Also removes any previously installed versions of the same plugin.
     *
     * @param artifact the artifact to install
     */
    public static void installArtifact(final Artifact artifact) {

    OkHttpClient
      .Builder()
      .connectionSpecs(listOf(connectionSpec))
      .eventListenerFactory(eventListenerFactory)
      .build()

  fun run() {
    // Launch wireshark in the background
    val process = eventListenerFactory.launchWireShark()

    val fbRequest =
      Request
        .Builder()
        .url("https://graph.facebook.com/robots.txt?s=fb")
        .build()

 *
 * This cache limits the number of bytes that it will store on the filesystem. When the number of
 * stored bytes exceeds the limit, the cache will remove entries in the background until the limit
 * is satisfied. The limit is not strict: the cache may temporarily exceed it while waiting for
 * files to be deleted. The limit does not include filesystem overhead or the cache journal so

   */
  fun sameHostAndPort(url: HttpUrl): Boolean

  /**
   * A plan holds either an immediately-usable connection, or one that must be connected first.
   * These steps are split so callers can call [connectTcp] on a background thread if attempting
   * multiple plans concurrently.
   */
  interface Plan {
    val isReady: Boolean

    fun connectTcp(): ConnectResult

    fun connectTlsEtc(): ConnectResult

    public void finalizeReferent() {
      finalizeReferentCalled = true;
    }
  }

  /**
   * Keeps a weak reference to the underlying reference queue. When this reference is cleared, we
   * know that the background thread has stopped and released its strong reference.
   */
  private WeakReference<ReferenceQueue<Object>> queueReference;

  @Test
  public void testThatFinalizerStops() {
    weaklyReferenceQueue();

    public void finalizeReferent() {
      finalizeReferentCalled = true;
    }
  }

  /**
   * Keeps a weak reference to the underlying reference queue. When this reference is cleared, we
   * know that the background thread has stopped and released its strong reference.
   */
  private WeakReference<ReferenceQueue<Object>> queueReference;

  @Test
  public void testThatFinalizerStops() {
    weaklyReferenceQueue();

        } catch (final IOException e) {
            throw new IORuntimeException(e);
        }
    }

    /**
     * Deletes the specified file in a background thread.
     *
     * @param file
     *            The file to delete.
     */
    public static void deleteInBackground(final File file) {
        if (file != null) {