event
    }

    private InternalSuccessResult buildSuccess(long startTime, long endTime) {
        InternalSuccessResult result = Mock(InternalSuccessResult)
        result.startTime >> startTime
        result.endTime >> endTime

        result
    }

    private InternalFailureResult buildFailure(long startTime, long endTime, InternalFailure failure) {
        InternalFailureResult result = Mock(InternalFailureResult)

        args("--max-workers=4")
        succeeds(":workTask", ":slowTask")
        assert !endTime(":workTask").isBefore(endTime(":slowTask"))
    }

    def endTime(String taskPath) {
        def timeMs = buildOperations.only("Task " + taskPath).endTime
        return Instant.ofEpochMilli(timeMs)
    }

    String getMultipleActionTaskType() {
        return """

    }

    public void setEndTime_Avg(ConditionOptionCall<AvgAggregationBuilder> opLambda) {
        setEndTime_Avg("endTime", opLambda);
    }

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

        long startTime = finishEvent.getStartTime();
        long endTime = finishEvent.getEndTime();
        if (finishEvent.getFailure() != null) {
            return new DefaultFailureResult(startTime, endTime, Collections.singletonList(DefaultFailure.fromThrowable(finishEvent.getFailure())));
        } else {
            return new DefaultSuccessResult(startTime, endTime);
        }
    }

import org.gradle.util.GradleVersion;
import org.junit.platform.engine.ConfigurationParameters;
import org.junit.platform.engine.DiscoveryFilter;
import org.junit.platform.engine.DiscoverySelector;
import org.junit.platform.engine.EngineDiscoveryListener;
import org.junit.platform.engine.EngineDiscoveryRequest;
import org.junit.platform.engine.ExecutionRequest;
import org.junit.platform.engine.TestDescriptor;
import org.junit.platform.engine.TestEngine;

func (m *bucketMeasurement) updateExponentialMovingAverage(endTime time.Time) {
	// 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)

        //         at org.junit.jupiter.engine.execution.MethodInvocation.proceed(MethodInvocation.java:60)
        //         at org.junit.jupiter.engine.execution.InvocationInterceptorChain$ValidatingInvocation.proceed(InvocationInterceptorChain.java:125)
        //         at org.junit.jupiter.engine.extension.TimeoutExtension.intercept(TimeoutExtension.java:132)

        long startTime = finishEvent.getStartTime();
        long endTime = finishEvent.getEndTime();
        ExecuteTaskBuildOperationType.Result result = (ExecuteTaskBuildOperationType.Result) finishEvent.getResult();
        boolean incremental = result != null && result.isIncremental();

        if (state.getUpToDate()) {

public class DefaultWorkItemSuccessResult extends DefaultOperationSuccessResult implements WorkItemSuccessResult {

    public DefaultWorkItemSuccessResult(long startTime, long endTime) {
        super(startTime, endTime);
    }

	"reflect"
	"testing"
	"time"
)

const (
	oneMiB uint64 = 1024 * 1024
)

func TestMonitor_GetReport(t *testing.T) {
	type fields struct {
		activeBuckets map[BucketOptions]*bucketMeasurement
		endTime       time.Time
		update2       uint64
		endTime2      time.Time
	}
	start := time.Now()
	m0 := newBucketMeasurement(start)
	m0.incrementBytes(0)
	m1MiBPS := newBucketMeasurement(start)