@UsedByScanPlugin
public class TestStartEvent {
    private final long startTime;
    private final Object parentId;

    @UsedByScanPlugin("test-distribution")
    public TestStartEvent(long startTime) {
        this(startTime, null);
    }

    @UsedByScanPlugin("test-distribution")
    public TestStartEvent(long startTime, Object parentId) {
        this.startTime = startTime;
        this.parentId = parentId;
    }

public final class OperationStartEvent {
    private final long startTime;

    public OperationStartEvent(long startTime) {
        this.startTime = startTime;
    }

    public long getStartTime() {
        return startTime;
    }

    @Override
    public String toString() {
        return "OperationStartEvent{" +
            "startTime=" + startTime +
            '}';
    }

        LOGGER.debug("Deleting {}", root);
        long startTime = timeProvider.getAsLong();
        Map<String, FileDeletionResult> failedPaths = new LinkedHashMap<String, FileDeletionResult>();
        boolean attemptedToRemoveAnything = deleteRecursively(startTime, root, root, handling, failedPaths);
        if (!failedPaths.isEmpty()) {
            throwWithHelpMessage(startTime, root, handling, failedPaths, false);
        }

class BuildTimestampValueSource extends AbstractValueSource {
    private final Date startTime;
    private final Map<String, String> properties;

    BuildTimestampValueSource(Date startTime, Map<String, String> properties) {
        super(false);
        this.startTime = startTime;
        this.properties = properties;
    }

    @Override
    public Object getValue(String expression) {

		}
	}
	if config.Since != 0 {
		if startTime != "" {
			return fmt.Errorf("only one --start-time or --duration may be set")
		}
		config.StartTime = config.EndTime.Add(-1 * time.Duration(config.Since))
	} else {
		var err error
		if startTime == "" {
			config.StartTime = time.Time{}
		} else {
			config.StartTime, err = time.Parse(time.RFC3339, startTime)
			if err != nil {

        this.buildClientMetaData = buildClientMetaData;
        this.startTime = startTime;
        this.interactive = interactive;
        this.parameters = parameters;
    }

    public long getStartTime() {
        return startTime;
    }

    public boolean isInteractive() {
        return interactive;
    }

    public GradleLauncherMetaData getBuildClientMetaData() {
        return buildClientMetaData;
    }

    ) {
        this.client = client;
        this.startTime = startTime;
        this.interactive = interactive;
        this.cancellationToken = cancellationToken;
        this.eventConsumer = eventConsumer;
    }

    public GradleLauncherMetaData getClient() {
        return client;
    }

    public long getStartTime() {
        return startTime;
    }

    public boolean isInteractive() {

				st.MakePod().Name("p1.2").UID("p1.2").Node("node1").Priority(lowPriority).Req(smallRes).StartTime(epochTime4).Obj(),
				st.MakePod().Name("p1.3").UID("p1.3").Node("node1").Priority(midPriority).Req(mediumRes).StartTime(epochTime3).Obj(),
				st.MakePod().Name("p1.4").UID("p1.4").Node("node1").Priority(highPriority).Req(smallRes).StartTime(epochTime2).Obj(),

    }

    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);
        }
    }

    final GradleLauncherMetaData clientMetaData = Mock()
    final long startTime = 90
    final BuildActionParameters parameters = Mock()
    final ServiceRegistry sharedServices = Mock()
    final Stoppable stoppable = Mock()
    final RunBuildAction action = new RunBuildAction(client, startParameter, clientMetaData, startTime, parameters, sharedServices, stoppable)

    def runsBuildUsingDaemon() {
        when: