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

/**
 * @author shinsuke
 *
 */
public class ContentLengthHelper {

    protected long defaultMaxLength = 10L * 1024L * 1024L;// 10M

    protected Map<String, Long> maxLengthMap = new HashMap<>();

    public void addMaxLength(final String mimeType, final long maxLength) {
        if (StringUtil.isBlank(mimeType)) {
            throw new CrawlerSystemException("MIME type is a blank.");
        }

        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

        private final A request;
        private final B cachedResult;
        private final long ageMillis;
        private long keepForMillis;
        private boolean ruleMatch;
        private boolean mustCheck;

        private AbstractResolutionControl(A request, B cachedResult, long ageMillis, long keepForMillis) {
            this.request = request;
            this.cachedResult = cachedResult;

    public class DocMeta implements Serializable {

        private static final long serialVersionUID = 1L;

        protected String id;

        protected Long version;

        protected Long seqNo;

        protected Long primaryTerm;

        private transient RequestOptionCall<IndexRequestBuilder> indexOption;

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,