assertEquals(method, lastMethodCalled);
    }

    void assertMethodWithTimeout(String method, long timeout, TimeUnit unit) {
      assertLastMethodCalled(method + "Timeout");
      assertEquals(unit.toMillis(timeout), lastTimeoutInMillis);
    }

    @Override
    public boolean awaitTermination(long timeout, TimeUnit unit) {
      lastMethodCalled = "awaitTermination";
      return false;
    }

    @Override

    delegate().putLast(e);
  }

  @Override
  public boolean offerFirst(E e, long timeout, TimeUnit unit) throws InterruptedException {
    return delegate().offerFirst(e, timeout, unit);
  }

  @Override
  public boolean offerLast(E e, long timeout, TimeUnit unit) throws InterruptedException {
    return delegate().offerLast(e, timeout, unit);
  }

  @Override
  public E takeFirst() throws InterruptedException {

        override fun read(
          sink: Buffer,
          byteCount: Long,
        ): Long {
          check(!closed)
          return data.read(sink, byteCount)
        }

        override fun timeout(): Timeout = Timeout.NONE
      }
    return source.buffer().asResponseBody(null, -1)
  }

  private fun newResponse(
    responseBody: ResponseBody,
    code: Int = 200,
    fn: Response.Builder.() -> Unit = {},

        return this;
    }

    /**
     * Sets the timeout for this job execution.
     *
     * @param timeout the timeout in seconds (-1 for no timeout)
     * @return this ExecJob instance for method chaining
     */
    public ExecJob timeout(final int timeout) {
        this.timeout = timeout;
        return this;
    }

    /**
     * Sets whether to use local Fesen instance.

    }

    /**
     * Sets the timeout value in seconds.
     *
     * @param timeout the timeout value
     */
    public void setTimeout(int timeout) {
        this.timeout = timeout;
    }

    /**
     * Gets the timeout value.
     *
     * @return the timeout value
     */
    public int getTimeout() {
        return timeout;
    }

    /**

index.admin.required.fields=url,title,role,boost

# timeout

# Timeout for index search operations.
index.search.timeout=3m
# Timeout for scroll search operations.
index.scroll.search.timeout=3m
# Timeout for index operations.
index.index.timeout=3m
# Timeout for bulk index operations.
index.bulk.timeout=3m
# Timeout for delete operations in the index.
index.delete.timeout=3m
# Timeout for index health checks.

 * It is used to interrupt a running thread when a timeout occurs.
 * The class provides methods to interrupt the thread and stop the timeout target.
 *
 * <p>
 * The class uses a logger to log debug messages.
 * It also uses an AtomicBoolean to track whether the thread is running.
 * </p>
 *
 * <p>
 * The expired method is called when a timeout occurs.
 * It interrupts the running thread up to a maximum number of times.

        }

        this.timeout100Ns = SMBUtil.readInt4(buffer, bufferIndex) & 0xFFFFFFFFL; // Timeout (4 bytes, 100-ns intervals, unsigned)
        this.flags = SMBUtil.readInt4(buffer, bufferIndex + 4); // Flags (4 bytes)
        return 8;
    }

    /**
     * Get the timeout value in 100-nanosecond intervals (raw wire format)
     * @return the timeout in 100-nanosecond intervals
     */
    public long getTimeout100Ns() {

        }
    }

    /**
     * Validates timeout value
     *
     * @param timeout timeout in milliseconds
     * @param fieldName the field name for error reporting
     * @throws IllegalArgumentException if timeout is invalid
     */
    public static void validateTimeout(long timeout, String fieldName) {
        if (timeout < 0) {

    public static final String NAME = "DH2Q";  // Durable Handle V2 Request
    
    private long timeout;
    private int flags;
    private HandleGuid createGuid;
    
    public DurableHandleV2Request(long timeout, boolean persistent) {
        super(NAME);
        this.timeout = timeout;
        this.flags = persistent ? Smb2HandleCapabilities.SMB2_DHANDLE_FLAG_PERSISTENT : 0;