* @since 28.0 (but only since 33.4.0 in the Android flavor)
   */
  @CanIgnoreReturnValue
  @J2ktIncompatible
  @GwtIncompatible // java.time.Duration
  @ParametricNullness
  public static <V extends @Nullable Object> V getUninterruptibly(
      Future<V> future, Duration timeout) throws ExecutionException, TimeoutException {
    return getUninterruptibly(future, toNanosSaturated(timeout), TimeUnit.NANOSECONDS);
  }

  /**

func (o *osMetrics) time(s osMetric) func() {
	startTime := time.Now()
	return func() {
		duration := time.Since(startTime)

		atomic.AddUint64(&o.operations[s], 1)
		o.latency[s].add(duration)
	}
}

// incTime will increment time on metric s with a specific duration.
func (o *osMetrics) incTime(s osMetric, d time.Duration) {
	atomic.AddUint64(&o.operations[s], 1)
	o.latency[s].add(d)
}

internal fun checkDuration(
  name: String,
  duration: Long,
  unit: TimeUnit,
): Int {
  check(duration >= 0L) { "$name < 0" }
  val millis = unit.toMillis(duration)
  require(millis <= Integer.MAX_VALUE) { "$name too large" }
  require(millis != 0L || duration <= 0L) { "$name too small" }
  return millis.toInt()
}

internal fun checkDuration(
  name: String,
  duration: Duration,
): Int {

   */
  @CanIgnoreReturnValue
  @J2ktIncompatible
  @GwtIncompatible // java.time.Duration
  @ParametricNullness
  @SuppressWarnings("Java7ApiChecker")
  @IgnoreJRERequirement // Users will use this only if they're already using Duration.
  public static <V extends @Nullable Object> V getUninterruptibly(
      Future<V> future, Duration timeout) throws ExecutionException, TimeoutException {

	for i := 0; i < dynamicTimeoutLogSize; i++ {

		rnd := f()
		duration := time.Duration(float64(successTimeout) * rnd)

		if duration < 100*time.Millisecond {
			duration = 100 * time.Millisecond
		}
		if duration >= time.Minute {
			timeout.LogFailure()
		} else {
			timeout.LogSuccess(duration)
		}
	}
}

func TestDynamicTimeoutAdjustExponential(t *testing.T) {

import com.google.errorprone.annotations.CanIgnoreReturnValue;
import com.google.j2objc.annotations.J2ObjCIncompatible;
import java.time.Duration;
import java.util.concurrent.TimeUnit;

/**
 * An object that accurately measures <i>elapsed time</i>: the measured duration between two
 * successive readings of "now" in the same process.
 *
 * <p>In contrast, <i>wall time</i> is a reading of "now" as given by a method like

	return func(sz int) {
		duration := time.Since(startTime)

		atomic.AddUint64(&p.operations[s], 1)
		if s < scannerMetricLastRealtime {
			p.latency[s].addSize(duration, int64(sz))
		}
	}
}

// incTime will increment time on metric s with a specific duration.
// Use for s < scannerMetricLastRealtime
func (p *scannerMetrics) incTime(s scannerMetric, d time.Duration) {
	atomic.AddUint64(&p.operations[s], 1)

    assertThrows(IllegalStateException.class, () -> builder2.softValues());
    assertThrows(IllegalStateException.class, () -> builder2.weakValues());
  }

  @GwtIncompatible // Duration
  public void testLargeDurationsAreOk() {
    Duration threeHundredYears = Duration.ofDays(365 * 300);
    CacheBuilder<Object, Object> unused =
        CacheBuilder.newBuilder()
            .expireAfterWrite(threeHundredYears)

	MaxTimeout time.Duration `json:"maxTimeout"`
}

// Update - updates the config with latest values
func (c *Config) Update(new Config) error {
	configLk.Lock()
	defer configLk.Unlock()
	c.MaxTimeout = getMaxTimeout(new.MaxTimeout)
	return nil
}

// GetMaxTimeout - returns the per call drive operation timeout
func (c *Config) GetMaxTimeout() time.Duration {
	return c.GetOPTimeout()
}

):
    start_process = start_datetime + process_after
    duration = end_datetime - start_process
    return {
        "item_id": item_id,
        "start_datetime": start_datetime,
        "end_datetime": end_datetime,
        "process_after": process_after,
        "repeat_at": repeat_at,
        "start_process": start_process,
        "duration": duration,