):
    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,

)

// DeadlineConn - is a generic stream-oriented network connection supporting buffered reader and read/write timeout.
type DeadlineConn struct {
	net.Conn
	readDeadline  time.Duration // sets the read deadline on a connection.
	writeDeadline time.Duration // sets the write deadline on a connection.
}

// Sets read deadline
func (c *DeadlineConn) setReadDeadline() {
	if c.readDeadline > 0 {

	l.lockNotFound = !refreshed
}

func (l *lockServer) setResponseDelay(responseDelay time.Duration) {
	atomic.StoreInt64(&l.responseDelay, int64(responseDelay))
}

func (l *lockServer) Lock(args *LockArgs) (reply bool, err error) {
	if d := atomic.LoadInt64(&l.responseDelay); d != 0 {
		time.Sleep(time.Duration(d))
	}

	l.mutex.Lock()
	defer l.mutex.Unlock()

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 {

    }
  }

  @SuppressWarnings("Java7ApiChecker") // test of Java 8+ API
  @J2ktIncompatible // Duration
  @GwtIncompatible // Duration
  public void testMemoizeWithExpiration_durationNegative() throws InterruptedException {
    try {
      Supplier<String> unused = Suppliers.memoizeWithExpiration(() -> "", Duration.ZERO);
      fail();
    } catch (IllegalArgumentException expected) {
    }

    try {

    }
  }

  @SuppressWarnings("Java7ApiChecker") // test of Java 8+ API
  @J2ktIncompatible // Duration
  @GwtIncompatible // Duration
  public void testMemoizeWithExpiration_durationNegative() throws InterruptedException {
    try {
      Supplier<String> unused = Suppliers.memoizeWithExpiration(() -> "", Duration.ZERO);
      fail();
    } catch (IllegalArgumentException expected) {
    }

    try {

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)

func (srv *Server) UseShutdownTimeout(d time.Duration) *Server {
	srv.ShutdownTimeout = d
	return srv
}

// UseIdleTimeout configure idle connection timeout
func (srv *Server) UseIdleTimeout(d time.Duration) *Server {
	srv.IdleTimeout = d
	return srv
}

// UseReadHeaderTimeout configure read header timeout
func (srv *Server) UseReadHeaderTimeout(d time.Duration) *Server {
	srv.ReadHeaderTimeout = d
	return srv

	Size  int64
	N     int64
}

// Add a duration to a single element.
func (a *AccElem) add(dur time.Duration) {
	if dur < 0 {
		dur = 0
	}
	a.Total += int64(dur)
	a.N++
}

// Merge b into a.
func (a *AccElem) merge(b AccElem) {
	a.N += b.N
	a.Total += b.Total
	a.Size += b.Size
}

// Avg returns average time spent.
func (a AccElem) avg() time.Duration {
	if a.N >= 1 && a.Total > 0 {