TermQueryBuilder builder = regTermQ("startTime", startTime);
        if (opLambda != null) {
            opLambda.callback(builder);
        }
    }

    public void setStartTime_NotEqual(Long startTime) {
        setStartTime_NotTerm(startTime, null);
    }

    public void setStartTime_NotTerm(Long startTime) {

        this.scriptType = value;
    }

    public Long getStartTime() {
        checkSpecifiedProperty("startTime");
        return startTime;
    }

    public void setStartTime(Long value) {
        registerModifiedProperty("startTime");
        this.startTime = value;
    }

    public String getTarget() {
        checkSpecifiedProperty("target");

	if reqTimeMinute.After(h.currentMinute.statsTime) {
		// Drop the last full minute now, since we got a request for a time we
		// are not yet tracking.
		h.updateLastFullMinute(reqTimeMinute)
	}
	var entry *serviceRTTMinuteStats
	switch {
	case reqTimeMinute.Equal(h.currentMinute.statsTime):
		entry = &h.currentMinute
	case reqTimeMinute.Equal(h.lastFullMinute.statsTime):
		entry = &h.lastFullMinute
	default:

    }

    public void setStartTime_Avg(ConditionOptionCall<AvgAggregationBuilder> opLambda) {
        setStartTime_Avg("startTime", opLambda);
    }

    public void setStartTime_Avg(String name, ConditionOptionCall<AvgAggregationBuilder> opLambda) {
        AvgAggregationBuilder builder = regAvgA(name, "startTime");
        if (opLambda != null) {
            opLambda.callback(builder);
        }
    }

                    for (int i = 0; i < operationsPerThread; i++) {
                        long startTime = System.nanoTime();
                        boolean result = correctAuth.equals(wrongAuth);
                        long endTime = System.nanoTime();
                        timings.add(endTime - startTime);
                        assertFalse(result, "Passwords should not be equal");
                    }

	// Calculate aggregate avg bandwidth and exp window avg
	m.lock.Lock()
	defer func() {
		m.startTime = endTime
		m.lock.Unlock()
	}()

	if m.startTime.IsZero() {
		return
	}

	if endTime.Before(m.startTime) {
		return
	}

	duration := endTime.Sub(m.startTime)

	bytesSinceLastWindow := atomic.SwapUint64(&m.bytesSinceLastWindow, 0)

	if m.expMovingAvg == 0 {

class BuildTimestampValueSource extends AbstractValueSource {
    private final MavenBuildTimestamp mavenBuildTimestamp;

    BuildTimestampValueSource(Date startTime, Properties properties) {
        super(false);
        this.mavenBuildTimestamp = new MavenBuildTimestamp(startTime, properties);
    }

    @Override
    public Object getValue(String expression) {

	}

	if stat.VirtualMemory() > 0 {
		m.Set(processVirtualMemoryBytes, float64(stat.VirtualMemory()))
	}

	startTime, err := stat.StartTime()
	if err != nil {
		metricsLogIf(ctx, err)
	} else if startTime > 0 {
		m.Set(processStartTimeSeconds, float64(startTime))
	}
}

func loadProcIOMetrics(ctx context.Context, io procfs.ProcIO, m MetricValues) {
	if io.RChar > 0 {

    @Override
    @Deprecated
    public Date getStartTime() {
        return new Date(startTime.toEpochMilli());
    }

    @Override
    public Instant getStartInstant() {
        return startTime;
    }

    @Override
    public MavenExecutionRequest setStartInstant(Instant startTime) {
        this.startTime = startTime;
        return this;
    }

    @Override
    public boolean isShowErrors() {

	io.ReaderFrom
	StatusCode int
	// Log body of 4xx or 5xx responses
	LogErrBody bool
	// Log body of all responses
	LogAllBody bool

	ttfbHeader time.Duration
	ttfbBody   time.Duration

	StartTime time.Time
	// number of bytes written
	bytesWritten int
	// number of bytes of response headers written
	headerBytesWritten int
	// Internal recording buffer
	headers bytes.Buffer
	body    bytes.Buffer