func ShortHumanDuration(d time.Duration) string {
	// Allow deviation no more than 2 seconds(excluded) to tolerate machine time
	// inconsistence, it can be considered as almost now.
	if seconds := int(d.Seconds()); seconds < -1 {
		return "<invalid>"
	} else if seconds < 0 {
		return "0s"
	} else if seconds < 60 {
		return fmt.Sprintf("%ds", seconds)
	} else if minutes := int(d.Minutes()); minutes < 60 {
		return fmt.Sprintf("%dm", minutes)

		}

		wants := `
		# HELP kubelet_node_startup_duration_seconds [ALPHA] Duration in seconds of node startup in total.
        # TYPE kubelet_node_startup_duration_seconds gauge
        kubelet_node_startup_duration_seconds 0
        # HELP kubelet_node_startup_post_registration_duration_seconds [ALPHA] Duration in seconds of node startup after registration.
        # TYPE kubelet_node_startup_post_registration_duration_seconds gauge

func (m *CelMetrics) ObserveCompilation(elapsed time.Duration) {
	seconds := elapsed.Seconds()
	m.compilationTime.Observe(seconds)
}

// ObserveEvaluation records a CEL evaluation with the time the evaluation took.
func (m *CelMetrics) ObserveEvaluation(elapsed time.Duration) {
	seconds := elapsed.Seconds()
	m.evaluationTime.Observe(seconds)

            instant.started3
        }

        when:
        def executor = factory.createScheduled('test', 2)
        executor.schedule(action1, 0, TimeUnit.SECONDS)
        executor.schedule(action2, 0, TimeUnit.SECONDS)
        executor.schedule(action3, 0, TimeUnit.SECONDS)
        thread.blockUntil.started3

        then:
        instant.started3 > instant.completed1
        instant.started3 > instant.started2
    }

    }

    public static Amount<Duration> millis(BigDecimal millis) {
        return Amount.valueOf(millis, MILLI_SECONDS);
    }

    public static Amount<Duration> seconds(BigDecimal seconds) {
        return Amount.valueOf(seconds, SECONDS);
    }

    public static Amount<Duration> minutes(BigDecimal minutes) {
        return Amount.valueOf(minutes, MINUTES);
    }

// that matches Time. Do not use in Go structs.
type Timestamp struct {
	// Represents seconds of UTC time since Unix epoch
	// 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to
	// 9999-12-31T23:59:59Z inclusive.
	Seconds int64 `json:"seconds" protobuf:"varint,1,opt,name=seconds"`
	// Non-negative fractions of a second at nanosecond resolution. Negative

          }
        },
        "refresh_delay": {
          "seconds": 30,
          "nanos": 0
        }
      }
    },
    "cds_config": {
      "api_config_source": {
        "api_type": "GRPC",
        "grpc_services": {
          "envoy_grpc": {
            "cluster_name": "xds-grpc"
          }
        },
        "refresh_delay": {
          "seconds": 30,
          "nanos": 0
        }
      }
    },

		},
	)
	// PodWorkerDuration is a Histogram that tracks the duration (in seconds) in takes to sync a single pod.
	// Broken down by the operation type.
	PodWorkerDuration = metrics.NewHistogramVec(
		&metrics.HistogramOpts{
			Subsystem:      KubeletSubsystem,
			Name:           PodWorkerDurationKey,
			Help:           "Duration in seconds to sync a single pod. Broken down by operation type: create, update, or sync",

        "None"              | "1 second"          | seconds(0.421345)                   | "421ms"
        "1 second"          | "10 seconds"        | seconds(4.21345)                    | "4s"
        "10 seconds"        | "1 minute"          | seconds(42.1234)                    | "42s"
        "10 seconds"        | "1 minute"          | seconds(60)                         | "1m"

        "foo", getChecked(immediateFuture("foo"), TwoArgConstructorException.class, 0, SECONDS));
  }

  public void testGetCheckedTimed_interrupted() {
    SettableFuture<String> future = SettableFuture.create();
    Thread.currentThread().interrupt();
    try {
      getChecked(future, TwoArgConstructorException.class, 0, SECONDS);
      fail();
    } catch (TwoArgConstructorException expected) {