private final SynchronousQueue<Response> responseQueue = new SynchronousQueue<>();

  private @Nullable Throwable uncaughtThrowable = null;

  public TestThread(L lockLikeObject, String threadName) {
    super(threadName);
    this.lockLikeObject = checkNotNull(lockLikeObject);
    start();
  }

  // Thread.stop() is okay because all threads started by a test are dying at the end of the test,

{
    "properties": {
      "url": {
        "type": "keyword"
      },
      "threadName": {
        "type": "keyword"
      },
      "errorName": {
        "type": "keyword"
      },
      "errorLog": {
        "type": "keyword"
      },
      "errorCount": {
        "type": "integer"
      },
      "lastAccessTime": {
        "type": "long"
      },
      "configId": {
        "type": "keyword"
      }

  @GwtIncompatible // threads
  private static boolean trySetName(String threadName, Thread currentThread) {
    /*
     * setName should usually succeed, but the security manager can prohibit it. Is there a way to
     * see if we have the modifyThread permission without catching an exception?
     */
    try {
      currentThread.setName(threadName);
      return true;
    } catch (SecurityException e) {
      return false;

            "type" : "keyword"
          },
          "errorName" : {
            "type" : "keyword"
          },
          "lastAccessTime" : {
            "type" : "long"
          },
          "threadName" : {
            "type" : "keyword"
          },
          "url" : {
            "type" : "keyword"
          }
        }
      }
    },
    "settings" : {
      "index" : {

            doColumn("errorName");
        }

        public void columnLastAccessTime() {
            doColumn("lastAccessTime");
        }

        public void columnThreadName() {
            doColumn("threadName");
        }

        public void columnUrl() {
            doColumn("url");
        }
    }

                                        <tr>
                                            <th><la:message key="labels.failure_url_thread_name"/></th>
                                            <td>${f:h(threadName)}<la:hidden property="threadName"/></td>
                                        </tr>
                                        <tr>
                                            <th><la:message key="labels.failure_url_error_name"/></th>

        if (current < percent) {
            return true;
        }
        final long startTime = getCurrentTimeAsLong();
        final String threadName = Thread.currentThread().getName();
        try {
            waitingThreadNames.add(threadName);
            while (current >= percent) {
                if (timeoutInMillis > 0 && getCurrentTimeAsLong() - startTime > timeoutInMillis) {

import okhttp3.internal.http.CallServerInterceptor
import okhttp3.internal.http.RealInterceptorChain
import okhttp3.internal.http.RetryAndFollowUpInterceptor
import okhttp3.internal.platform.Platform
import okhttp3.internal.threadName
import okio.AsyncTimeout
import okio.Timeout

/**
 * Bridge between OkHttp's application and network layers. This class exposes high-level application
 * layer primitives: connections, requests, responses, and streams.

  private final SynchronousQueue<Response> responseQueue = new SynchronousQueue<>();

  private @Nullable Throwable uncaughtThrowable = null;

  public TestThread(L lockLikeObject, String threadName) {
    super(threadName);
    this.lockLikeObject = checkNotNull(lockLikeObject);
    start();
  }

  // Thread.stop() is okay because all threads started by a test are dying at the end of the test,

            result.setErrorName(DfTypeUtil.toString(source.get("errorName")));
            result.setLastAccessTime(DfTypeUtil.toLong(source.get("lastAccessTime")));
            result.setThreadName(DfTypeUtil.toString(source.get("threadName")));
            result.setUrl(DfTypeUtil.toString(source.get("url")));
            return updateEntity(source, result);
        } catch (InstantiationException | IllegalAccessException e) {