}

    public void test_constructor_withBufferSizeAndCallback() throws IOException {
        Process mockProcess = createMockProcess("callback test\nanother line");
        List<String> callbackResults = new ArrayList<>();
        Consumer<String> callback = line -> callbackResults.add(line);

        JobProcess jobProcess = new JobProcess(mockProcess, 50, callback);

        assertNotNull(jobProcess);

        final Time time = toSqlTime("11:49");
        assertThat(new SimpleDateFormat("HH:mm:ss").format(time), is("11:49:00"));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testToTime_MediumStyle() throws Exception {
        final Time time = toSqlTime("11:49:10");
        assertThat(new SimpleDateFormat("HH:mm:ss").format(time), is("11:49:10"));
    }

    /**

        }
    }

    /**
     * Parses a time string in HH:MM format.
     *
     * @param time the time string to parse
     * @return an array containing [hour, minute]
     * @throws FessSystemException if the time format is invalid
     */
    protected static int[] parseTime(final String time) {
        final String[] froms = time.split(":");
        if (froms.length != 2) {

    }

    /**
     * Checks if the buffer contains a line that matches the specified value (after trimming).
     *
     * @param value the value to search for in the buffered lines
     * @return true if a matching line is found, false otherwise
     */
    public boolean contains(final String value) {
        for (final String line : list) {
            if (line.trim().equals(value)) {
                return true;

/**
 * Parse all headers delimited by "\r\n" until an empty line. This throws if headers exceed 256 KiB.
 */
class HeadersReader(
  val source: BufferedSource,
) {
  private var headerLimit = HEADER_LIMIT.toLong()

  /** Read a single line counted against the header size limit. */
  fun readLine(): String {
    val line = source.readUtf8LineStrict(headerLimit)
    headerLimit -= line.length.toLong()
    return line
  }

  }

  /**
   * Waits for the {@link Service} to reach the {@linkplain State#RUNNING running state} for no more
   * than the given time.
   *
   * @param timeout the maximum time to wait
   * @param unit the time unit of the timeout argument
   * @throws TimeoutException if the service has not reached the given state within the deadline

    }

    /**
     * Gets the total processing time for all documents in this list.
     *
     * @return the total processing time in milliseconds
     */
    public long getProcessingTime() {
        return processingTime;
    }

    /**
     * Adds to the total processing time of this document list.
     *
     * @param processingTime the processing time to add in milliseconds
     */

   */
  public boolean enterWhen(Guard guard, Duration time) throws InterruptedException {
    return enterWhen(guard, toNanosSaturated(time), TimeUnit.NANOSECONDS);
  }

  /**
   * Enters this monitor when the guard is satisfied. Blocks at most the given time, including both
   * the time to acquire the lock and the time to wait for the guard to be satisfied, and may be
   * interrupted.
   *

    assertThat("Thu, 01 Jan 1970 00:00:00 GMT".toHttpDateOrNull()!!.time).isEqualTo(0L)
    assertThat("Fri, 06 Jun 2014 12:30:30 GMT".toHttpDateOrNull()!!.time).isEqualTo(1402057830000L)

    // RFC 850, obsoleted by RFC 1036 with GMT.
    assertThat("Thursday, 01-Jan-70 00:00:00 GMT".toHttpDateOrNull()!!.time).isEqualTo(0L)
    assertThat("Friday, 06-Jun-14 12:30:30 GMT".toHttpDateOrNull()!!.time).isEqualTo(1402057830000L)

   * New entries are added at the tail of the list at write time; stale entries are expired from
   * the head of the list.
   */

  /** Returns the time that this entry was last accessed, in ns. */
  @SuppressWarnings("GoodTime")
  long getAccessTime();

  /** Sets the entry access time in ns. */
  @SuppressWarnings("GoodTime") // b/122668874
  void setAccessTime(long time);

  /** Returns the next entry in the access queue. */