}

  @Test
  fun selectedProtocolIsNullWhenSslSocketThrowsExceptionForApplicationProtocol() {
    platform.assumeJdk9()
    val applicationProtocolUnsupported =
      object : DelegatingSSLSocket(null) {
        override fun getApplicationProtocol(): String = throw UnsupportedOperationException("Mock exception")
      }
    assertThat(Jdk9Platform().getSelectedProtocol(applicationProtocolUnsupported)).isNull()
  }

    write(out, data, 0, 100, true);
    File file = out.getFile();
    assertEquals(100, file.length());
    assertTrue(file.exists());
    out.close();

    // Make sure that finalize deletes the file
    out = null;

    // times out and throws RuntimeException on failure
    GcFinalization.awaitDone(
        new GcFinalization.FinalizationPredicate() {
          @Override
          public boolean isDone() {

/**
 * ManagedVersionMap
 */
@Deprecated
public class ManagedVersionMap extends HashMap<String, Artifact> {
    public ManagedVersionMap(Map<String, Artifact> map) {
        super();
        if (map != null) {
            putAll(map);
        }
    }

    @Override
    public String toString() {
        StringBuilder buffer = new StringBuilder("ManagedVersionMap (" + size() + " entries)\n");

      if (!dispatching.get()) {
        dispatching.set(true);
        try {
          Event nextEvent;
          while ((nextEvent = queueForThread.poll()) != null) {
            while (nextEvent.subscribers.hasNext()) {
              nextEvent.subscribers.next().dispatchEvent(nextEvent.event);
            }
          }
        } finally {
          dispatching.remove();

                    @Override
                    public List<Pattern> load(final String key) {
                        return getList(OpenSearchUrlFilter.class, key, QueryBuilders.termQuery(FILTER_TYPE, type), null, maxLoadSize, null)
                                .stream()
                                .map(f -> Pattern.compile(f.getUrl()))
                                .collect(Collectors.toList());
                    }

        setCreateTime(System.currentTimeMillis());
        if (responseData != null) {
            BeanUtil.copyBeanToBean(responseData, this);
        }

        final AccessResultData<IDTYPE> accessResultData = new AccessResultDataImpl<>();
        if (resultData != null) {
            BeanUtil.copyBeanToBean(resultData, accessResultData);
        }
        setAccessResultData(accessResultData);

      print("$host: ")
      System.out.flush()
      try {
        val results = dns.lookup(host)
        println(results)
      } catch (uhe: UnknownHostException) {
        var e: Throwable? = uhe
        while (e != null) {
          println(e)
          e = e.cause
        }
      }
    }
    println()
  }
  time = System.currentTimeMillis() - time
  println("Time: ${time.toDouble() / 1000} seconds\n")
}

    }
    for (Thread thread : blockedThreads) {
      AbstractFutureBenchmarks.awaitWaiting(thread);
    }
    switch (state) {
      case NOT_DONE:
        break;
      case FINISHED:
        f.set(null);
        break;
      case CANCELLED:
        f.cancel(false);
        break;
      case FAILED:
        f.setException(new Exception());
        break;
    }
    return f;
  }

  /** Adds the most recently logged record to our list. */
  @Override
  public void publish(@Nullable LogRecord record) {
    synchronized (lock) {
      if (record != null) {
        list.add(record);
      }
    }
  }

  @Override
  public void flush() {}

  @Override
  public void close() {}

  public void clear() {
    synchronized (lock) {

    public RdmaConnection connect(String hostname, int port) throws IOException {
        InetSocketAddress remoteAddress = new InetSocketAddress(hostname, port);
        RdmaConnection connection = createConnection(remoteAddress, null);
        connection.connect();
        return connection;
    }

    @Override
    public RdmaMemoryRegion registerMemory(ByteBuffer buffer, EnumSet<RdmaAccess> access) throws IOException {