/**
 * @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.");
        }

      }
      return bufferedSource;
    }

    private Source source(Source source) {
      return new ForwardingSource(source) {
        long totalBytesRead = 0L;

        @Override public long read(Buffer sink, long byteCount) throws IOException {
          long bytesRead = super.read(sink, byteCount);
          // read() returns the number of bytes read, or -1 if this source is exhausted.

    @Resource
    protected SystemHelper systemHelper;

    @Resource
    protected IndexingHelper indexingHelper;

    protected boolean finishCrawling = false;

    protected long executeTime;

    protected long documentSize;

    protected int maxIndexerErrorCount = 0;

    protected int maxErrorCount = 2;

    protected List<String> finishedSessionIdList = new ArrayList<>();

    //                                                                           =========
    /** endTime */
    protected Long endTime;

    /** jobName */
    protected String jobName;

    /** jobStatus */
    protected String jobStatus;

    /** lastUpdated */
    protected Long lastUpdated;

    /** scriptData */
    protected String scriptData;

    /** scriptResult */

public class FileBothDirectoryInfo implements FileEntry, Decodable {

    private int nextEntryOffset;
    private int fileIndex;
    private long creationTime;
    private long lastAccessTime;
    private long lastWriteTime;
    private long changeTime;
    private long endOfFile;
    private long allocationSize;
    private int extFileAttributes;
    private int eaSize;
    private String shortName;
    private String filename;

        downloads.put(resource, event.getTransferredBytes());

        StringBuilder buffer = new StringBuilder(64);

        for (Map.Entry<TransferResource, Long> entry : downloads.entrySet()) {
            long total = entry.getKey().getContentLength();
            long complete = entry.getValue();

            buffer.append(getStatus(complete, total)).append("  ");
        }

        int pad = lastLength - buffer.length();

    protected final String index;

    protected final long tookMs;

    protected final List<String> words;

    protected final int num;

    protected final long total;

    protected final List<SuggestItem> items;

    public PopularWordsResponse(final String index, final long tookMs, final List<String> words, final long total,
            final List<SuggestItem> items) {
        this.index = index;

  private static final long[] positive = new long[ARRAY_SIZE];
  private static final long[] nonnegative = new long[ARRAY_SIZE];
  private static final long[] longs = new long[ARRAY_SIZE];

  @BeforeExperiment
  void setUp() {
    for (int i = 0; i < ARRAY_SIZE; i++) {
      exponents[i] = randomExponent();
      positive[i] = randomPositiveBigInteger(Long.SIZE - 1).longValue();

        }
    }


    /**
     * @return the number of known usages
     */
    protected long getUsageCount () {
        return this.usageCount.get();
    }


    protected abstract long makeKey ( Request request ) throws IOException;


    protected abstract Long peekKey () throws IOException;


    protected abstract void doSend ( Request request ) throws IOException;

) {
  /** The total number of bytes consumed. */
  var total: Long = 0L
    private set

  /** The total number of bytes acknowledged by outgoing `WINDOW_UPDATE` frames. */
  var acknowledged: Long = 0L
    private set

  val unacknowledged: Long
    @Synchronized get() = total - acknowledged

  @Synchronized
  fun update(
    total: Long = 0,
    acknowledged: Long = 0,
  ) {
    check(total >= 0)