MetadataGraphVertex entry = cleanGraph.getEntry();
                // entry point
                v.visit(entry);
            }

            return cpc;
        } catch (GraphConflictResolutionException e) {
            throw new MetadataGraphTransformationException(e);
        }
    }

    // ===================================================================================================

            ToolchainPrivate[] toolchains = toolchainManagerPrivate.getToolchainsForType(type, s);
            return new MappedList<>(Arrays.asList(toolchains), this::toToolchain);
        } catch (MisconfiguredToolchainException e) {
            throw new ToolchainManagerException("Unable to get toochains for type " + type, e);
        }
    }

    @Override

    this.body = body
    this.sequenceNumber = sequenceNumber
    this.failure = failure

    if (socket is SSLSocket) {
      try {
        this.handshake = socket.session.handshake()
      } catch (e: IOException) {
        throw IllegalArgumentException(e)
      }
    } else {
      this.handshake = null
    }

    if (requestLine.isNotEmpty()) {
      val methodEnd = requestLine.indexOf(' ')

                if (num.intValue() > fessConfig.getPagingSearchPageMaxSizeAsInteger().intValue() || num.intValue() <= 0) {
                    num = fessConfig.getPagingSearchPageMaxSizeAsInteger();
                }
            } catch (final NumberFormatException e) {
                num = fessConfig.getPagingSearchPageSizeAsInteger();
            }
        }
        return num;
    }

    @Override
    public String getQuery() {

      while (responseBody.read(buffer) != -1) {
      }
    }
    responseBody.close()
  }

  private fun sleep(delayMillis: Int) {
    try {
      Thread.sleep(delayMillis.toLong())
    } catch (e: InterruptedException) {
      Thread.currentThread().interrupt()
    }
  }

  private fun interruptLater(delayMillis: Int) {
    val toInterrupt = Thread.currentThread()
    val interruptingCow =

      throws IOException {
    try {
      Closeables.close(closeable, swallowException);
      if (expectThrown) {
        fail("Didn't throw exception.");
      }
    } catch (IOException e) {
      if (!expectThrown) {
        fail("Threw exception");
      }
    }
    verify(closeable).close();
  }

      cache.edit(key)
    }.also { expected ->
      assertThat(expected.message).isEqualTo("keys must match regex [a-z0-9_-]{1,120}: \"$key\"")
    }
    assertFailsWith<IllegalArgumentException> {
      key = "has_CR\r"
      cache.edit(key)
    }.also { expected ->
      assertThat(expected.message).isEqualTo("keys must match regex [a-z0-9_-]{1,120}: \"$key\"")
    }
    assertFailsWith<IllegalArgumentException> {

                sslContext.init(null, trustManagerFactory.getTrustManagers(), null);
                sslSocketFactory = sslContext.getSocketFactory();
            } catch (final Exception e) {
                logger.warn("Failed to load {}", authorities, e);
            }
        }

        final String[] hosts = split(ResourceUtil.getFesenHttpUrl(), ",")

    private fun bodyAsString(body: RequestBody?): String {
      return try {
        val buffer = Buffer()
        body!!.writeTo(buffer)
        buffer.readString(body.contentType()!!.charset()!!)
      } catch (e: IOException) {
        throw RuntimeException(e)
      }
    }
  }

      return
    }

    try {
      testHttpUrl(testData)
      if (KNOWN_FAILURES.contains(testData.toString())) {
        System.err.println("Expected failure but was success: $testData")
      }
    } catch (e: Throwable) {
      if (KNOWN_FAILURES.contains(testData.toString())) {
        System.err.println("Ignoring known failure: $testData")
        e.printStackTrace()
      } else {
        throw e
      }
    }