* @param config the configuration context
     * @param fid the file identifier to monitor
     * @param completionFilter bitmask specifying the types of changes to monitor
     * @param watchTree true to monitor the entire directory tree, false for directory only
     */
    public NtTransNotifyChange(final Configuration config, final int fid, final int completionFilter, final boolean watchTree) {
        super(config, NT_TRANSACT_NOTIFY_CHANGE);

      .build()
  }

  internal fun lookupDecompressor(encoding: String): DecompressionAlgorithm? =
    algorithms.find {
      it.encoding.equals(encoding, ignoreCase = true)
    }

  /**
   * A decompression algorithm such as Gzip. Must provide the Accept-Encoding value and decompress a Source.
   */
  interface DecompressionAlgorithm {
    val encoding: String

      client.newCall(
        Request
          .Builder()
          .url(server.url("/"))
          .build(),
      )
    call1.execute().use { response -> response.body.string() }

    listener.shouldClose = true
    // Large headers are a likely reason the servers would cut off the connection before it completes sending
    // request headers.
    // 431 "Request Header Fields Too Large"
    val largeHeaders =
      Headers

  }

  @Override
  public void forEach(Consumer<? super K> action) {
    checkNotNull(action);
    map.forEach((k, v) -> action.accept(k));
  }

  @Override
  boolean isPartialView() {
    return true;
  }

  // redeclare to help optimizers with b/310253115
  @SuppressWarnings("RedundantOverride")
  @Override
  @J2ktIncompatible
  @GwtIncompatible
    Object writeReplace() {
    return super.writeReplace();

    return ordering.<@NonNull S>nullsLast();
  }

  @Override
  public boolean equals(@Nullable Object object) {
    if (object == this) {
      return true;
    }
    if (object instanceof NullsFirstOrdering) {
      NullsFirstOrdering<?> that = (NullsFirstOrdering<?>) object;
      return this.ordering.equals(that.ordering);
    }
    return false;
  }

        assertContains(message, "manyReason");
    }

    private void assertContains(final String s, final String contained) {
        assertThat(s, s.indexOf(contained) > -1, is(true));
    }

class ImmediateExecutionDistributedManager {
 public:
  virtual ~ImmediateExecutionDistributedManager() {}

  // Set up distributed execution environment on local and remote tasks.
  // When `reset_context` is true, initialize new cluster context state based
  // on cluster configurations provided in `server_def`; otherwise, update
  // existing context state with the provided `server_def`. Contexts created

                break;
            default:
                throw new IllegalArgumentException("Unknown source [" + source + "]");
        }
        fetchContext = new FetchSourceContext(
            true,
            Strings.splitStringByCommaToArray(includes),
            Strings.splitStringByCommaToArray(excludes)
        );
        includesSet = Set.of(fetchContext.includes());

    @Test
    @DisplayName("Should handle retry policy correctly")
    void testRetryPolicy() {
        // Given
        SmbOperationException.RetryPolicy policy = new SmbOperationException.RetryPolicy(3, 1000, 10000, 2.0, true);

        exception = new SmbOperationException(SmbOperationException.ErrorCode.CONNECTION_TIMEOUT, "Timeout occurred", null, policy, null);

        // When/Then - Should retry for attempts 1 and 2

    /** String constant representing boolean true value. */
    public static final String TRUE = "true";

    /** String constant representing boolean false value. */
    public static final String FALSE = "false";

    /** Boolean constant representing true value. */
    public static final Boolean T = true;

    /** Boolean constant representing false value. */