internal fun Int.fooExt() {}

        internal val String.barExt: String
            get() = "bar"

        internal var Int.bazarExt: String
            get() = "bar"
            set(value) = Unit

    """

    @Language("kotlin")
    private
    val publicMembers = """

        fun foo() {}

        val bar = "bar"

        var bazar = "bazar"

        fun String.fooExt() {}

    }
  }

  /** Interrupts the current thread after sleeping for the specified delay. */
  static void requestInterruptIn(long time, TimeUnit unit) {
    checkNotNull(unit);
    Thread interruptee = Thread.currentThread();
    new Thread(
            () -> {
              try {
                unit.sleep(time);
              } catch (InterruptedException wontHappen) {
                throw new AssertionError(wontHappen);
              }

    arch: Arch = Arch.AMD64,
    extraParameters: String = "",
    timeout: Int = 90,
    maxParallelForks: String = "%maxParallelForks%",
    extraSteps: BuildSteps.() -> Unit = {}, // the steps after runner steps
    preSteps: BuildSteps.() -> Unit = {}, // the steps before runner steps
) {
    buildType.applyDefaultSettings(os, timeout = timeout, buildJvm = buildJvm, arch = arch)

    buildType.steps {
        preSteps()

   *     by subsequent {@code get()} calls
   * @param unit the unit that {@code duration} is expressed in
   * @throws IllegalArgumentException if {@code duration} is not positive
   * @since 2.0
   */
  @SuppressWarnings("GoodTime") // Prefer the Duration overload
  public static <T extends @Nullable Object> Supplier<T> memoizeWithExpiration(
      Supplier<T> delegate, long duration, TimeUnit unit) {
    checkNotNull(delegate);

  @Override
  public void await() throws InterruptedException {
    delegate().await();
  }

  @Override
  public boolean await(long time, TimeUnit unit) throws InterruptedException {
    return delegate().await(time, unit);
  }

  @Override
  public void awaitUninterruptibly() {
    delegate().awaitUninterruptibly();
  }

  @Override

import org.gradle.api.Project;
import org.gradle.api.plugins.JavaBasePlugin;
import org.gradle.api.tasks.testing.Test;

/**
 * Configures the build to compile against Elasticsearch's test framework and
 * run integration and unit tests. Use BuildPlugin if you want to build main
 * code as well as tests.
 */
public class StandaloneTestPlugin implements Plugin<Project> {
    @Override
    public void apply(final Project project) {

    } catch (re: RuntimeException) {
      // Happens with non-robolectric unit tests
      System.err.println("Possibly running android unit test without robolectric")
      re.printStackTrace()
    } catch (ule: UnsatisfiedLinkError) {
      // Happens with Paparazzi - with Android classes on the classpath
      System.err.println("Possibly running android unit test without robolectric")
      ule.printStackTrace()
    }
  }

  @CanIgnoreReturnValue
  @Override
  @ParametricNullness
  public V get(long timeout, TimeUnit unit)
      throws TimeoutException, InterruptedException, ExecutionException {

    long timeoutNanos = unit.toNanos(timeout);
    if (timeoutNanos <= OverflowAvoidingLockSupport.MAX_NANOSECONDS_THRESHOLD) {
      return super.get(timeout, unit);
    }
    // Waiting 68 years should be enough for any program.
    return super.get(

   * @param unit the time unit of the timeout argument
   * @throws TimeoutException if the service has not reached the given state within the deadline
   * @throws IllegalStateException if the service {@linkplain State#FAILED fails}.
   * @since 15.0
   */
  @SuppressWarnings("GoodTime") // should accept a java.time.Duration
  void awaitTerminated(long timeout, TimeUnit unit) throws TimeoutException;

  /**

}

/**
 * Returns a duration in the nearest whole-number units like "999 µs" or "  1 s ". This rounds 0.5
 * units away from 0 and 0.499 towards 0. The smallest unit this returns is "µs"; the largest unit
 * it returns is "s". For values in [-499..499] this returns "  0 µs".
 *
 * The returned string attempts to be column-aligned to 6 characters. For negative and large values
 * the returned string may be longer.