* such as file creation, modification, deletion, and attribute changes.
 */
public class NtTransNotifyChange extends SmbComNtTransaction {

    int fid;
    private final int completionFilter;
    private final boolean watchTree;

    /**
     * Constructs an NT transaction for change notification monitoring.
     * @param config the configuration context
     * @param fid the file identifier to monitor

interface ExchangeCodec {
  /** The connection or CONNECT tunnel that owns this codec. */
  val carrier: Carrier

  /** Returns true if the response body and (possibly empty) trailers have been received. */
  val isResponseComplete: Boolean

  /** The socket that carries this exchange. */
  val socket: Socket

  /** Returns an output stream where the request body can be streamed. */
  @Throws(IOException::class)
  fun createRequestBody(

   * constructed.
   */
  @Override
  public boolean contains(@Nullable Object rowKey, @Nullable Object columnKey) {
    return containsRow(rowKey) && containsColumn(columnKey);
  }

  /**
   * Returns {@code true} if the provided column key is among the column keys provided when the
   * table was constructed.
   */
  @Override
  public boolean containsColumn(@Nullable Object columnKey) {

    private final boolean largeFile;
    private int pid;
    private long byteOffset;
    private long lengthInBytes;

    /**
     * Constructs a LockingAndXRange with large file support.
     *
     * @param largeFile whether to use large file support (64-bit offsets)
     */
    public LockingAndXRange(final boolean largeFile) {
        this.largeFile = largeFile;
    }

   *
   * [rfc_2817]: http://www.ietf.org/rfc/rfc2817.txt
   */
  fun requiresTunnel(): Boolean {
    if (proxy.type() != Proxy.Type.HTTP) return false
    return (address.sslSocketFactory != null) ||
      (Protocol.H2_PRIOR_KNOWLEDGE in address.protocols)
  }

  override fun equals(other: Any?): Boolean =
    other is Route &&
      other.address == address &&
      other.proxy == proxy &&

   *       predicate.apply(b))}.
   * </ul>
   *
   * @throws NullPointerException if {@code input} is null and this predicate does not accept null
   *     arguments
   */
  boolean apply(@ParametricNullness T input);

  /**
   * Indicates whether another object is equal to this predicate.
   *
   * <p><b>Warning: do not depend</b> on the behavior of this method.
   *

  public void testRoundIntegralDoubleToInt() {
    for (double d : INTEGRAL_DOUBLE_CANDIDATES) {
      for (RoundingMode mode : ALL_SAFE_ROUNDING_MODES) {
        BigDecimal expected = new BigDecimal(d).setScale(0, mode);
        boolean isInBounds =
            expected.compareTo(MAX_INT_AS_BIG_DECIMAL) <= 0
                & expected.compareTo(MIN_INT_AS_BIG_DECIMAL) >= 0;

        try {

        // Test that accessTimeoutTask null check prevents NPE
        S3Client client = new S3Client() {
            @Override
            protected ResponseData processRequest(final String uri, final boolean includeContent) {
                // Skip init() and directly test timeout handling
                org.codelibs.fess.crawler.client.AccessTimeoutTarget accessTimeoutTarget = null;

        }

        public void decrementConnections() {
            activeConnections.decrementAndGet();
        }

        public boolean isHealthy() {
            return isHealthy;
        }

        public void setHealthy(boolean healthy) {
            this.isHealthy = healthy;
            this.lastHealthCheck = System.currentTimeMillis();
        }

/**
 * @param {?string} str
 * @return {boolean} Whether the given string is null or is the empty string.
 * @public
 */
Platform.stringIsNullOrEmpty = function(str) {
  return !str;
};


/**
 * @param {?string} str
 * @return {string} Original str, if it is non-null. Otherwise empty string.
 */
Platform.nullToEmpty = function(str) {
  return str || "";
};


/**
 * @param {?string} str