void setMimeType(String mimeType);

    Long getCreateTime();

    void setCreateTime(Long createTime);

    Integer getExecutionTime();

    void setExecutionTime(Integer executionTime);

    AccessResultData<IDTYPE> getAccessResultData();

    void setAccessResultData(AccessResultData<IDTYPE> accessResultData);

    Long getContentLength();

    void setContentLength(Long contentLength);

    Long getLastModified();

import org.gradle.internal.operations.BuildOperationContext;

public class DefaultCleanupProgressMonitor implements CleanupProgressMonitor {

    private final BuildOperationContext buildOperationContext;
    private long deleted;
    private long skipped;

    public DefaultCleanupProgressMonitor(BuildOperationContext buildOperationContext) {
        this.buildOperationContext = buildOperationContext;
    }

    @Override

        start(description: description)
    }

    ProgressStartEvent start(Long id) {
        start(id: id)
    }

    ProgressStartEvent start(Long id, String status) {
        start(id: id, status: status)
    }

    ProgressStartEvent start(Map args) {
        Long parentId = args.containsKey("parentId") ? args.parentId : null

public class GarbageCollectionEvent {
    private final long timestamp;
    private final MemoryUsage usage;
    private final long count;

    public GarbageCollectionEvent(long timestamp, MemoryUsage usage, long count) {
        this.timestamp = timestamp;
        this.usage = usage;
        this.count = count;
    }

    public long getTimestamp() {
        return timestamp;
    }

public class JvmMemoryStatusSnapshot implements JvmMemoryStatus {
    private final long maximumMemory;
    private final long committedMemory;

    public JvmMemoryStatusSnapshot(long maximumMemory, long commitedMemory) {
        this.maximumMemory = maximumMemory;
        this.committedMemory = commitedMemory;
    }

    @Override
    public long getMaxMemory() {
        return maximumMemory;
    }

    @Override

        ruleValidator.validate(Stub(RuleAction) {
            getInputTypes() >> { [ Long ] }
        })

        then:
        def failure = thrown(RuleActionValidationException)
        failure.message == "Rule may not have an input parameter of type: java.lang.Long. Second parameter must be of type: java.lang.Integer."
    }

    def "rejects invalid type when no type configured" () {

  }

  data class ConnectionClosed(
    override val timestampNs: Long,
    override val connection: Connection,
  ) : ConnectionEvent()

  data class ConnectionAcquired(
    override val timestampNs: Long,
    override val connection: Connection,
    val call: Call,
  ) : ConnectionEvent()

  data class ConnectionReleased(
    override val timestampNs: Long,
    override val connection: Connection,
    val call: Call,

    private final Long selected;
    private final ComponentSelectionReason reason;
    private final ModuleVersionResolveException failure;
    private final boolean constraint;
    private final Long fromVariant;
    private final Long targetVariant;

    public DetachedResolvedGraphDependency(ComponentSelector requested,
                                           Long selected,

            }
        });
        return hasOutput[0];
    }

    @Override
    public boolean hasOutput(long classId, long testId, TestOutputEvent.Destination destination) {
        return false;
    }

    @Override
    public void writeAllOutput(final long classId, final TestOutputEvent.Destination destination, final Writer writer) {
        withReader(new Action<TestOutputStore.Reader>() {

    private final long startTime;
    private final long endTime;
    private final String skipMessage;

    public DefaultTaskSkippedResult(long startTime, long endTime, String skipMessage) {
        this.startTime = startTime;
        this.endTime = endTime;
        this.skipMessage = skipMessage;
    }

    @Override
    public long getStartTime() {
        return startTime;
    }