assertEquals(2048, negotiationWithLargeBuffers.getResponseRaw().length);
    }

    @Test
    @DisplayName("Fields should be immutable after construction")
    void testImmutability() {
        // Get references to the objects
        SmbNegotiationRequest originalRequest = negotiation.getRequest();

  private var lazyCacheControl: CacheControl? = null

  val isHttps: Boolean
    get() = url.isHttps

  /**
   * Constructs a new request.
   *
   * Use [Builder] for more fluent construction, including helper methods for various HTTP methods.
   *
   * @param method defaults to "GET" if [body] is null, and "POST" otherwise.
   */
  constructor(
    url: HttpUrl,
    headers: Headers = headersOf(),

   * is {@code 60}, and the concurrency level is {@code 8}, then eight segments are created, each
   * having a hash table of size eight. Providing a large enough estimate at construction time
   * avoids the need for expensive resizing operations later, but setting this value unnecessarily
   * high wastes memory.
   *
   * @throws IllegalArgumentException if {@code initialCapacity} is negative

        assertEquals("remove", ex.getMessage());
    }

    @Test
    @DisplayName("Null tree handle throws NullPointerException during construction")
    void nullTreeHandle() {
        // Arrange
        SmbTreeHandleImpl nullTree = null;

        // Act + Assert
        assertThrows(NullPointerException.class,

    /**
     * Initializes the protocol helper by loading configured protocols from FessConfig
     * and scanning for available protocol handlers in the classpath.
     * This method is called automatically after bean construction.
     */
    @PostConstruct
    public void init() {
        final FessConfig fessConfig = ComponentUtil.getFessConfig();
        webProtocols = split(fessConfig.getCrawlerWebProtocols(), ",")

     * <p>The online hash flooding detecting in RegularSetBuilderImpl.add can detect e.g. many
     * exactly matching hash codes, which would cause construction to take O(n^2), but can't detect
     * e.g. hash codes adversarially designed to go into ascending table locations, which keeps
     * construction O(n) (as desired) but then can have O(n) queries later.
     *
     * <p>If this returns false, then no query can take more than O(log n).
     *

    }

    @Test
    @DisplayName("getInput/getOutput return cached streams when open; throw when closed")
    void getInputOutput_caching_and_closed() throws Exception {
        // Arrange: minimal stubs so stream construction works
        SmbPipeHandleImpl handle = newHandleWithBasicStubs(0, "\\\\pipe\\\\foo");
        when(pipe.ensureTreeConnected()).thenReturn(tree);
        when(tree.acquire()).thenReturn(tree);

     */
    @Test
    @DisplayName("Test constructor with null file names")
    public void testConstructorWithNullFileNames() {
        // When & Then - should not throw exception during construction
        assertDoesNotThrow(() -> {
            new SmbComRename(config, null, null);
        });
    }

    /**
     * Test with very long file names
     */
    @Test

    public SearchEngineApiManager() {
        super();
        setPathPrefix(ADMIN_SERVER);
    }

    /**
     * Registers this API manager with the web API manager factory.
     * Called automatically after construction via @PostConstruct.
     */
    @PostConstruct
    public void register() {
        if (logger.isInfoEnabled()) {
            logger.info("Load {}", this.getClass().getSimpleName());
        }

        CharMappingItem item = new CharMappingItem(1L, inputs, null);

        assertNull(item.getOutput());
    }

    public void test_constructor_withUnsortedInputs() {
        // Test that inputs are sorted during construction
        String[] inputs = { "z", "a", "m" };
        CharMappingItem item = new CharMappingItem(1L, inputs, "output");

        assertEquals("a", item.getInputs()[0]);
        assertEquals("m", item.getInputs()[1]);