}

    public TestMethodResult(long id, String name, TestResult.ResultType resultType, long duration, long endTime) {
        this(id, name, name, resultType, duration, endTime);
    }

    public TestMethodResult(long id, String name, String displayName, TestResult.ResultType resultType, long duration, long endTime) {
        if (id < 1) {
            throw new IllegalArgumentException("id must be > 0");
        }

            return firstApplicationId;
        }

        void increment(long duration) {
            this.duration.addAndGet(duration);
        }

        InternalPluginApplicationResult toInternalPluginApplicationResult() {
            return new DefaultPluginApplicationResult(plugin, Duration.ofMillis(duration.get()));
        }
    }

    def changes = Mock(ExecutionStateChanges)
    def delegateResult = Stub(AfterExecutionResult)
    def delegateOriginMetadata = Stub(OriginMetadata) {
        getExecutionTime() >> Duration.ofSeconds(1)
    }

    def setup() {
        delegateResult.duration >> Duration.ofSeconds(1)
    }

    def "skips when outputs are up to date"() {
        when:
        def result = step.execute(work, context)

        then:

	registerMetrics.Do(func() {
		legacyregistry.MustRegister(jwtAuthenticatorLatencyMetric)
	})
}

func recordAuthenticationLatency(result, jwtIssuerHash string, duration time.Duration) {
	jwtAuthenticatorLatencyMetric.WithLabelValues(result, jwtIssuerHash).Observe(duration.Seconds())
}

func getHash(data string) string {
	if len(data) > 0 {
		return fmt.Sprintf("sha256:%x", sha256.Sum256([]byte(data)))
	}
	return ""
}

		f float64
		b bool
		s string
		x any
		p = &i
		d time.Duration
	)
	a := int(testing.AllocsPerRun(5, func() {
		i = Int64("key", 1).Value.Int64()
		u = Uint64("key", 1).Value.Uint64()
		f = Float64("key", 1).Value.Float64()
		b = Bool("key", true).Value.Bool()
		s = String("key", "foo").Value.String()
		d = Duration("key", d).Value.Duration()
		x = Any("key", p).Value.Any()
	}))
	if a != 0 {

import java.time.Duration;

public class DefaultPluginApplicationResult implements PluginApplicationResult {

    private final PluginIdentifier plugin;
    private final Duration totalConfigurationTime;

    public DefaultPluginApplicationResult(PluginIdentifier plugin, Duration totalConfigurationTime) {
        this.plugin = plugin;

    private final long duration;
    final ClassTestResults classResults;
    final List<TestFailure> failures = new ArrayList<TestFailure>();
    final String name;
    final String displayName;
    boolean ignored;

    public TestResult(String name, long duration, ClassTestResults classResults) {
        this(name, name, duration, classResults);
    }

			obj.Conntrack.MaxPerCore = ptr.To(c.Int31())
			obj.Conntrack.Min = ptr.To(c.Int31())
			obj.Conntrack.TCPCloseWaitTimeout = &metav1.Duration{Duration: time.Duration(c.Int63()) * time.Hour}
			obj.Conntrack.TCPEstablishedTimeout = &metav1.Duration{Duration: time.Duration(c.Int63()) * time.Hour}
			obj.FeatureGates = map[string]bool{c.RandString(): true}

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

		t.Fatal(err)
	}
}

func TestDefaultExpiryDuration(t *testing.T) {
	testCases := []struct {
		reqURL    string
		duration  time.Duration
		expectErr bool
	}{
		{
			reqURL:   "http://127.0.0.1:8443/?Token=xxxxx",
			duration: time.Duration(60) * time.Minute,
		},
		{
			reqURL:    "http://127.0.0.1:8443/?DurationSeconds=9s",
			expectErr: true,
		},
		{