} catch (final ChildUrlsException e) {
                connected = true;
                break;
            } catch (final Exception e) {
                logger.info("[{}] {}", i + 1, e.getMessage());
            }
            ThreadUtil.sleep(200L);
        }
        if (!connected) {
            throw new IllegalStateException("Could not connect to the Samba server");
        }
    }

                    assertThrows(SMBProtocolDecodingException.class, () -> response.readBytesWireFormat(buffer, bufferIndex));
            assertEquals("Expected structureSize = 4", exception.getMessage());
        }

        @ParameterizedTest
        @ValueSource(ints = { 0, 1, 2, 3, 5, 6, 100, 255, 65535 })
        @DisplayName("Should throw exception for various invalid structure sizes")

                "Should throw CIFSException for incompatible class");

        assertEquals("Incompatible file information class", exception.getMessage());
    }

    @Test
    @DisplayName("Test writeBytesWireFormat returns 0")
    void testWriteBytesWireFormat() {
        response = new Smb2QueryInfoResponse(mockConfig, (byte) 1, (byte) 2);

                log.warn("Failed to destroy SecretKey: {}", e.getMessage());
            }
        }

        // Remove from KeyStore
        if (keyStore != null) {
            try {
                keyStore.deleteEntry("smb.session." + sessionId);
            } catch (Exception e) {
                log.debug("Failed to remove key from KeyStore: {}", e.getMessage());
            }
        }

            byte[] actualBuffer = (byte[]) outputBufferField.get(response);
            assertSame(outputBuffer, actualBuffer);
        } catch (Exception e) {
            fail("Failed to access outputBuffer field: " + e.getMessage());
        }
    }

    @Test
    void testWriteSetupWireFormat() {
        // Test that writeSetupWireFormat returns 0
        byte[] dst = new byte[100];

        String malformedUrl = "invalid-url";
        CIFSException thrown = assertThrows(CIFSException.class, () -> {
            cifsContextWrapper.get(malformedUrl);
        });
        assertTrue(thrown.getMessage().contains("Invalid URL"));
        assertTrue(thrown.getCause() instanceof MalformedURLException);
    }

    @Test
    void testGetPipe() throws CIFSException, MalformedURLException {

        } catch (IOException e) {
            assertTrue(e.getMessage().contains("endpoint is blank"));
        }

        // Second call should also fail with the same error
        try {
            conn.connect();
            fail("Should throw IOException");
        } catch (IOException e) {
            assertTrue(e.getMessage().contains("endpoint is blank"));
        }
    }

    /**

        try {
            validator.validatePath("\\share\\forbidden\\file.txt");
            fail("Should block blacklisted path");
        } catch (SmbException e) {
            assertTrue(e.getMessage().contains("not allowed"));
        }

        // Should allow other paths
        String allowed = validator.validatePath("\\share\\allowed\\file.txt");
        assertEquals("\\share\\allowed\\file.txt", allowed);

    @Test
    public void testSIndexOutOfBoundsExceptionString() {
        final ClIndexOutOfBoundsException clIndexOutOfBoundsException = new ClIndexOutOfBoundsException("hoge");
        assertThat(clIndexOutOfBoundsException.getMessage(), is("hoge"));
    }

        } catch (RuntimeException e) {
            assertEquals("Simulated processing error", e.getMessage());
            // If InputStream wasn't properly closed, this would leak resources
            // try-with-resources ensures cleanup happens
        } catch (IOException e) {
            fail("Should not throw IOException: " + e.getMessage());
        }
    }

    /**
     * Test resource content integrity.