Element profilesElement = root.child(PROFILES).orElse(null);
        if (profilesElement != null) {
            var profileElements = profilesElement.children(PROFILE).toList();
            for (Element profileElement : profileElements) {
                Element profileModulesElement = profileElement.child(MODULES).orElse(null);
                if (profileModulesElement != null) {
                    profileModulesElement.name(SUBPROJECTS);

    var tcpConnectDelayNanos = 0L
    var tcpConnectThrowable: Throwable? = null
    var yieldBeforeTcpConnectReturns = false
    var connectTcpNextPlan: FakePlan? = null
    var tlsConnectDelayNanos = 0L
    var tlsConnectThrowable: Throwable? = null
    var connectTlsNextPlan: FakePlan? = null

    fun createRetry(): FakePlan {
      check(retry == null)
      return FakePlan(nextPlanId++)
        .also {
          retry = it

    public String toString() {
        return "[" + (md == null ? "no metadata" : md.toString()) + "]";
    }

    // ---------------------------------------------------------------------
    private static int compareStrings(String s1, String s2) {
        if (s1 == null && s2 == null) {
            return 0;
        }

        if (s1 == null /* && s2 != null */) {
            return -1;
        }

        if (

        assertNotNull(indexer.setRoleFieldName("role"));
        assertNotNull(indexer.setReadingConverter(null));
        assertNotNull(indexer.setNormalizer(null));
        assertNotNull(indexer.setAnalyzer(null));
        assertNotNull(indexer.setContentsParser(null));
        assertNotNull(indexer.setSuggestWriter(null));
    }

    @Test
    public void test_indexBadWordItem() throws Exception {

        method.setAccessible(true);

        // Test with null thread
        try {
            method.invoke(crawler, (Thread) null);
        } catch (Exception e) {
            fail("Should not throw exception with null thread");
        }

        // Test with normal thread
        Thread testThread = new Thread(() -> {
            try {

    if ((localInputFuture == null | localExceptionType == null | localFallback == null)
        // This check, unlike all the others, is a volatile read
        || isCancelled()) {
      return;
    }
    inputFuture = null;

    // For an explanation of the cases here, see the comments on AbstractTransformFuture.run.
    V sourceResult = null;
    Throwable throwable = null;
    try {

  /** Initialized in [callStart]. */
  private var callStackTrace: Any? = null

  /** Finds an exchange to send the next request and receive the next response. */
  private var exchangeFinder: ExchangeFinder? = null

  var connection: RealConnection? = null
    private set
  private var timeoutEarlyExit = false

  /**

    protected void assertObjectNotNull(String variableName, Object value) {
        if (variableName == null) {
            String msg = "The value should not be null: variableName=null value=" + value;
            throw new IllegalArgumentException(msg);
        }
        if (value == null) {
            String msg = "The value should not be null: variableName=" + variableName;
            throw new IllegalArgumentException(msg);
        }

    protected void assertObjectNotNull(String variableName, Object value) {
        if (variableName == null) {
            String msg = "The value should not be null: variableName=null value=" + value;
            throw new IllegalArgumentException(msg);
        }
        if (value == null) {
            String msg = "The value should not be null: variableName=" + variableName;
            throw new IllegalArgumentException(msg);
        }

    val sentRequestMillis = System.currentTimeMillis()

    var invokeStartEvent = true
    var responseBuilder: Response.Builder? = null
    var sendRequestException: IOException? = null
    val hasRequestBody = HttpMethod.permitsRequestBody(request.method) && requestBody != null
    val isUpgradeRequest = "upgrade".equals(request.header("Connection"), ignoreCase = true)
    try {
      exchange.writeRequestHeaders(request)