*
     * @param response the response object to populate
     * @throws IOException if an I/O error occurs
     */
    protected abstract void doRecv(Response response) throws IOException;

    /**
     * Skips an unexpected or unrecognized message.
     *
     * @throws IOException if an I/O error occurs
     */
    protected abstract void doSkip() throws IOException;

    /**

            }
        });
        assertEquals("open fail", ex.getMessage());
        verify(tree, times(1)).release(); // closed on constructor failure
    }

    @Test
    @DisplayName("Iteration skips '.' and '..' and returns valid entries")
    void iterationSkipsDotAndDotDot() throws Exception {
        // Arrange
        stubAcquireReturnsSelf();
        FileEntry initial = entry("a");

            Arrays.fill(buffer, (byte) 0xFF);

            lock.encode(buffer, 0);

            // Reserved field bytes are not modified by the encode method
            // The implementation just skips these bytes without writing zeros
            assertEquals(-1, SMBUtil.readInt4(buffer, 20));
        }
    }

    @Nested
    @DisplayName("Flag Constants Tests")
    class FlagConstantsTests {

    }

    @Test
    void testOpenConnection_WithSystemPropertyHandler_SkipsJcifsPackage() throws Exception {
        // This test verifies that the handler resolution mechanism correctly skips the 'jcifs'
        // package when it is listed in the 'java.protocol.handler.pkgs' system property.
        // We use mock handlers since actual system handlers might not be available in test environment.

            // When
            copy.encode(buffer, startIndex);

            // Then
            // The implementation skips 4 reserved bytes without writing zeros
            // This is consistent with the actual implementation behavior
            // The reserved bytes remain as they were in the buffer
            for (int i = 0; i < 4; i++) {
                assertEquals((byte) 0xFF, buffer[startIndex + SOURCE_KEY_SIZE + 4 + i],

        assertEquals(24, SMBUtil.readInt2(buffer, 0));

        // Flags (2 bytes) - should be 0 by default
        assertEquals(0, SMBUtil.readInt2(buffer, 2));

        // Reserved (4 bytes) - The implementation skips writing these bytes,
        // so they will have the initial pattern (0xCCCCCCCC)
        // This is expected behavior as seen in the implementation at line 131
        assertEquals((byte) 0xCC, buffer[4]);

            // ID for domain (used with relative IDs to get SIDs)
            final int domainIdPointer = pacStream.readInt();

            // Skip some reserved fields
            pacStream.skipBytes(8);

            this.userAccountControl = pacStream.readInt();

            // Skip some reserved fields
            pacStream.skipBytes(28);

            // Extra SIDs information

        SocketInputStream sis = new SocketInputStream(in);

        // Try to skip more than available
        // Skip uses read internally, which may throw IOException when it tries to read the next header
        try {
            long skipped = sis.skip(10);
            // If it doesn't throw, it should only skip what's available
            assertEquals(3, skipped);
        } catch (IOException e) {

        byte[] nameBytes = originalFileName.getBytes(StandardCharsets.UTF_16LE);

        byte[] buffer = new byte[100];
        buffer[0] = 1; // replaceIfExists = true
        // Skip 7 reserved bytes (1-7)
        // Skip 8 bytes for RootDirectory (8-15)
        SMBUtil.writeInt4(nameBytes.length, buffer, 16);
        System.arraycopy(nameBytes, 0, buffer, 20, nameBytes.length);

        }

        @Test
        @DisplayName("skip: positive advances; non-positive returns 0")
        void skipBehavior() throws Exception {
            SmbFileInputStream in = newStream();
            assertEquals(0, in.skip(0));
            assertEquals(0, in.skip(-1));
            assertEquals(5, in.skip(5));
        }
    }

    @Nested
    @DisplayName("SMB1 interactions")