String pipeName = "TestPipe";
        FsctlPipeWaitRequest request = new FsctlPipeWaitRequest(pipeName);

        // Verify size calculation
        int expectedSize = 14 + pipeName.getBytes(StandardCharsets.UTF_16LE).length;
        assertEquals(expectedSize, request.size());
    }

    @Test
    @DisplayName("Test constructor with name and timeout sets correct fields")
    void testConstructorWithNameAndTimeout() {

    }

    /**
     * Get maximum receive size
     *
     * @return maximum receive size in bytes
     */
    public int getMaxReceiveSize() {
        return maxReceiveSize;
    }

    /**
     * Set maximum receive size
     *
     * @param maxReceiveSize maximum receive size in bytes
     */
    public void setMaxReceiveSize(int maxReceiveSize) {

        }
        if (size > maxSize) {
            throw new IllegalArgumentException(fieldName + " size exceeds maximum (" + maxSize + "): " + size);
        }
    }

    /**
     * Validates buffer size for SMB2/3
     *
     * @param size the buffer size to validate
     * @param fieldName the field name for error reporting
     * @throws IllegalArgumentException if size is invalid
     */

     */
    @Size(max = 10)
    public String resetDictionaries;

    /**
     * The number of shards for doc.
     */
    @Size(max = 10)
    public String numberOfShardsForDoc = ComponentUtil.getFessConfig().getIndexNumberOfShards();

    /**
     * The auto expand replicas for doc.
     */
    @Size(max = 10)
    public String autoExpandReplicasForDoc = ComponentUtil.getFessConfig().getIndexAutoExpandReplicas();

        when(mockFileInfo.size()).thenReturn(8);

        // Test encode
        int encoded = mockFileInfo.encode(dst, 0);
        assertEquals(8, encoded);

        // Test size
        int size = mockFileInfo.size();
        assertEquals(8, size);

        // Verify interactions
        verify(mockFileInfo).encode(dst, 0);
        verify(mockFileInfo).size();
    }

    /**

    public void test1() throws Exception {
        DisposableUtil.add(new TestDisposable("a"));
        assertThat(DisposableUtil.disposables.size(), is(1));
        DisposableUtil.dispose();
        assertThat(count, is(1));
        assertThat(names, is("a"));
        assertThat(DisposableUtil.disposables.size(), is(0));
    }

    /**
     * @throws Exception
     */
    @Test
    public void test2() throws Exception {

    @DisplayName("Test getSendBufferSize returns standard size")
    void testGetSendBufferSizeStandard() {
        // Arrange
        int expectedSize = 65536;
        when(negotiationResponse.getSendBufferSize()).thenReturn(expectedSize);

        // Act
        int size = negotiationResponse.getSendBufferSize();

        // Assert
        assertEquals(expectedSize, size);
        verify(negotiationResponse).getSendBufferSize();

        queue.clear();
    }

    /**
     * Sets the scroll size.
     * @param scrollSize The scroll size.
     */
    public void setScrollSize(final int scrollSize) {
        this.scrollSize = scrollSize;
    }

    /**
     * Sets the limit of document size.
     * @param limitOfDocumentSize The limit of document size.
     */
    public void setLimitOfDocumentSize(final long limitOfDocumentSize) {

    }

    /**
     * Get the preferred size for send operations
     *
     * @return preferred send size in bytes
     */
    public int getPreferredSendSize() {
        return preferredSendSize;
    }

    /**
     * Set the preferred size for send operations
     *
     * @param preferredSendSize preferred send size in bytes
     */

            assertEquals(2 + (count * 2), encoded);
            // Note: size() returns 4 + count*2, but encode returns 2 + count*2
            // This is an implementation inconsistency in the original code
            assertNotEquals(context.size(), encoded);
            assertEquals(4 + (count * 2), context.size());
        }

        @Test
        @DisplayName("Should encode and decode correctly")