jdks {
    provisioned_runtime {
        vendor = VersionProperties.bundledJdkVendor
        version = VersionProperties.bundledJdkVersion
        platform = OS.current().name().toLowerCase()
        architecture = Architecture.current().name().toLowerCase()
    }
}

configure(allprojects) {
    project.tasks.withType(Test).configureEach { Test test ->
        if (BuildParams.getIsRuntimeJavaHomeSet()) {

      Iterator<Class<?>> iterator = interfaceClasses.iterator();
      boolean addToSet = true;
      while (iterator.hasNext()) {
        Class<?> current = iterator.next();
        if (current == itf || itf.isAssignableFrom(current)) {
          // Skip any super interface of the ones that are already included.
          addToSet = false;
          break;
        }
      }
      if (addToSet) {

# FastAPI doesn't currently support non-scalar Path parameters...

     */
    boolean isDisconnected();

    /**
     * Disconnects the transport from the remote server.
     *
     * @param hard if true, force immediate disconnection
     * @param inuse whether the connection is currently in use
     * @return whether the connection was in use
     * @throws IOException if an I/O error occurs during disconnection
     */
    boolean disconnect(boolean hard, boolean inuse) throws IOException;

    /**

        final long current =
                1000 * systemHelper.getCurrentTimeAsLocalDateTime().atZone(ZoneId.systemDefault()).toInstant().getEpochSecond();
        final long now = System.currentTimeMillis();
        assertTrue(now + ">=" + current + " : " + (now - current), now >= current);
        assertTrue(now - 1000 + "<" + current + " : " + (current - now + 1000), now - 1000 < current);
    }

    @Test

import okhttp3.internal.okHttpName
import okhttp3.internal.threadFactory

/**
 * A set of worker threads that are shared among a set of task queues.
 *
 * Use [INSTANCE] for a task runner that uses daemon threads. There is not currently a shared
 * instance for non-daemon threads.
 *
 * The task runner is also responsible for releasing held threads when the library is unloaded.
 * This is for the benefit of container environments that implement code unloading.

  internal fun finished(call: RealCall) {
    promoteAndExecute(finishedCall = call)
  }

  /** Returns a snapshot of the calls currently awaiting execution. */
  @Synchronized
  fun queuedCalls(): List<Call> = readyAsyncCalls.map { it.call }.unmodifiable()

  /** Returns a snapshot of the calls currently being executed. */
  @Synchronized
  fun runningCalls(): List<Call> = (runningSyncCalls + runningAsyncCalls.map { it.call }).unmodifiable()

    protected HttpServletRequest request;

    /** Current form reference for rendering extra fields on the edit page. */
    private CreateForm currentForm;

    /** List of document items returned from search */
    public List<Map<String, Object>> documentItems;

    /** Number of results per page */
    public String pageSize;

    /** Current page number for pagination */
    public String currentPageNumber;

    /**
     * Replaces the host with the given FQDN if it is currently unqualified
     *
     * @param fqdn the fully qualified domain name to use
     */
    void fixupHost(String fqdn);

    /**
     * Possibly appends the given domain name to the host name if it is currently unqualified
     *
     * @param domain the domain name to append
     */

        Method currentMethod = processHandleClass.getMethod("current");
        Method infoMethod = processHandleClass.getMethod("info");
        Method userMethod = processHandleInfoClass.getMethod("user");
        Method orElseMethod = optionalClass.getMethod("orElse", Object.class);

        Object current = currentMethod.invoke(null);
        Object info = infoMethod.invoke(current);
        Object user = userMethod.invoke(info);