@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)

     */
    @Override
    public final long getLastAccessTime () {
        return this.lastAccessTime;
    }


    /**
     * @return the lastWriteTime
     */
    @Override
    public final long getLastWriteTime () {
        return this.lastWriteTime;
    }


    /**
     * @return the allocationSize
     */
    public final long getAllocationSize () {

            threads[ti].start();
        }

        while (t.numComplete < t.numThreads) {
            long delay;

            do {
                delay = 2L;

                synchronized (t) {
                    long expire = t.ltime + t.delay;
                    long ctime = System.currentTimeMillis();

                    if (expire > ctime)
                        delay = expire - ctime;