bb.get(encodedPath);
            assertArrayEquals(pathBytes, encodedPath);
        }

        @Test
        @DisplayName("Should encode consistently on multiple calls")
        void testEncodeIdempotency() {
            String path = "\\\\server\\share";
            buffer = new DfsReferralRequestBuffer(path, 3);

            byte[] dst1 = new byte[buffer.size()];

        assertSame(testException, thrownException, "Should propagate exception from delegate");
        verify(mockDelegate).getResponseTimeout();
    }

    @Test
    @DisplayName("Multiple method calls should result in multiple delegate calls")
    void testMultipleDelegateCalls() {
        // Given
        when(mockDelegate.getResponseTimeout()).thenReturn(30000);

        // When

 * quickly, since the row key is provided. However, {@code column(columnKey).size()} takes longer,
 * since an iteration across all row keys occurs.
 *
 * <p>Note that this implementation is not synchronized. If multiple threads access this table
 * concurrently and one of the threads modifies the table, it must be synchronized externally.
 *
 * <p>See the Guava User Guide article on <a href=

 * quickly, since the row key is provided. However, {@code column(columnKey).size()} takes longer,
 * since an iteration across all row keys occurs.
 *
 * <p>Note that this implementation is not synchronized. If multiple threads access this table
 * concurrently and one of the threads modifies the table, it must be synchronized externally.
 *
 * <p>See the Guava User Guide article on <a href=

        mockClient = mock(Client.class);
        fesenClient.client = mockClient;
    }

    /**
     * Test: Thread-safe listener management using CopyOnWriteArrayList
     * Verifies that multiple threads can safely add listeners concurrently
     */
    @Test
    public void testThreadSafeListenerManagement() throws Exception {
        final int numThreads = 10;

        String unicodePath = "文件夹\\文件.txt";
        request = new Smb2CreateRequest(mockConfig, unicodePath);
        assertEquals("\\文件夹\\文件.txt", request.getPath());
    }

    @Test
    @DisplayName("Test multiple path operations")
    void testMultiplePathOperations() {
        request = new Smb2CreateRequest(mockConfig, "initial\\path.txt");
        assertEquals("\\initial\\path.txt", request.getPath());

        assertDoesNotThrow(() -> transaction.writeParameterWordsWireFormat(dst, 0));
    }

    @Test
    @DisplayName("Test multiple setup count handling")
    void testMultipleSetupCount() {
        byte[] dst = new byte[256];

        // Set multiple setup words
        transaction.setSetupCount(3);
        transaction.setSetupWireFormatReturn(6); // 3 * 2 bytes

        // Execute the method

  /**
   * A plan holds either an immediately-usable connection, or one that must be connected first.
   * These steps are split so callers can call [connectTcp] on a background thread if attempting
   * multiple plans concurrently.
   */
  interface Plan {
    val isReady: Boolean

    fun connectTcp(): ConnectResult

    fun connectTlsEtc(): ConnectResult

    fun handleSuccess(): RealConnection

    // KGS!@#$%
    private static final byte[] S8 =
            { (byte) 0x4b, (byte) 0x47, (byte) 0x53, (byte) 0x21, (byte) 0x40, (byte) 0x23, (byte) 0x24, (byte) 0x25 };

    /* Accepts key multiple of 7
     * Returns enc multiple of 8
     * Multiple is the same like: 21 byte key gives 24 byte result
     */
    private static void E(final byte[] key, final byte[] data, final byte[] e) {
        final byte[] key7 = new byte[7];

        TestComponent component = new TestComponent();
        PooledObject<TestComponent> pooled1 = factory.wrap(component);
        assertNotNull(pooled1);

        // Test wrapping same object multiple times
        PooledObject<TestComponent> pooled2 = factory.wrap(component);
        assertNotNull(pooled2);
        assertNotSame(pooled1, pooled2); // Different PooledObject instances