"mode": "percentage",
            "steps": [
              {
                "color": "green",
                "value": null
              }
            ]
          },
          "unit": "dtdurations"
        },
        "overrides": []
      },
      "gridPos": {
        "h": 6,
        "w": 3,
        "x": 0,
        "y": 0
      },
      "id": 1,
      "maxDataPoints": 100,

    parallelizationMethod: ParallelizationMethod = ParallelizationMethod.None,
    subprojects: List<String> = listOf(),
    extraParameters: String = "",
    extraBuildSteps: BuildSteps.() -> Unit = {},
    preBuildSteps: BuildSteps.() -> Unit = {}
) : OsAwareBaseGradleBuildType(os = testCoverage.os, stage = stage, init = {
    this.name = name
    this.description = description
    this.id(id)

rem ---
:convertxm
set value=%~1
rem extract last char (unit)
set unit=%value:~-1%
rem assume the unit is specified
set conv=%value:~0,-1%

if "%unit%" == "k" goto kilo
if "%unit%" == "K" goto kilo
if "%unit%" == "m" goto mega
if "%unit%" == "M" goto mega
if "%unit%" == "g" goto giga
if "%unit%" == "G" goto giga

rem no unit found, must be bytes; consider the whole value
set conv=%value%

  @Override
  protected abstract ExecutorService delegate();

  @CheckReturnValue
  @Override
  public boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException {
    return delegate().awaitTermination(timeout, unit);
  }

  @Override
  public <T extends @Nullable Object> List<Future<T>> invokeAll(
      Collection<? extends Callable<T>> tasks) throws InterruptedException {

      + table.standardOptions.withOverrides([
        // Query name/unit
        override.byName.new('Value #requests')
        + override.byName.withProperty('displayName', 'Requests')
        + override.byName.withProperty('decimals', 2)
        + override.byName.withProperty('unit', 'reqps'),
        override.byName.new('Value #p50')

package dsync

import (
	"math/rand"
	"time"
)

func backoffWait(min, unit, cap time.Duration) func(*rand.Rand, uint) time.Duration {
	if unit > time.Hour {
		// Protect against integer overflow
		panic("unit cannot exceed one hour")
	}
	return func(r *rand.Rand, attempt uint) time.Duration {
		sleep := min
		sleep += unit * time.Duration(attempt)
		if sleep > cap {
			sleep = cap
		}

  static void requestInterruptIn(final long time, final TimeUnit unit) {
    checkNotNull(unit);
    final Thread interruptee = Thread.currentThread();
    new Thread(
            new Runnable() {
              @Override
              public void run() {
                try {
                  unit.sleep(time);
                } catch (InterruptedException wontHappen) {

  @Override
  ListenableScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit);

  /** @since 15.0 (previously returned ScheduledFuture) */
  @Override
  <V extends @Nullable Object> ListenableScheduledFuture<V> schedule(
      Callable<V> callable, long delay, TimeUnit unit);

  /** @since 15.0 (previously returned ScheduledFuture) */
  @Override

    timeout: Int,
    unit: TimeUnit,
  ): Interceptor.Chain {
    check(exchange == null) { "Timeouts can't be adjusted in a network interceptor" }

    return copy(connectTimeoutMillis = checkDuration("connectTimeout", timeout.toLong(), unit))
  }

  override fun readTimeoutMillis(): Int = readTimeoutMillis

  override fun withReadTimeout(
    timeout: Int,
    unit: TimeUnit,
  ): Interceptor.Chain {

- Enabled the `node-local` kubelet podresources API endpoint on windows, alongside unix. ([#115133](https://github.com/kubernetes/kubernetes/pull/115133), [@ffromani](https://github.com/ffromani))