a fake `HostnameVerifier` or `X509TrustManager`.

Certificate Authorities
-----------------------

The above example uses a self-signed certificate. This is convenient for testing but not
representative of real-world HTTPS deployment. To get closer to that we can use `HeldCertificate`
to generate a trusted root certificate, an intermediate certificate, and a server certificate.

///

## Separando testes

Em uma aplicação real, você provavelmente teria seus testes em um arquivo diferente.

E seu aplicativo **FastAPI** também pode ser composto de vários arquivos/módulos, etc.

### Arquivo do aplicativo **FastAPI**

    @Test
    void testSend() throws SmbException {
        SmbTree tree = new SmbTree(session, "testShare", "A:");
        tree.connectionState = 2; // Connected state
        tree.tid = 123;

        // Create real request and response objects since they're not interfaces
        ServerMessageBlock request = new SmbComOpenAndX("testfile.txt", 0x01, 0, null);
        ServerMessageBlock response = new SmbComOpenAndXResponse();

tener **un programa/servidor HTTP** ejecutándose en el servidor (la máquina, host, etc.) y **gestionando todas las partes de HTTPS**: recibiendo los **requests HTTPS encriptados**, enviando los **requests HTTP desencriptados** a la aplicación HTTP real que se ejecuta en el mismo servidor (la aplicación **FastAPI**, en este caso), tomando el **response HTTP** de la aplicación, **encriptándolo** usando el **certificado HTTPS** adecuado y enviándolo de vuelta al cliente usando **HTTPS**. Este servidor...

 *
 * Unfortunately Java's networking APIs don't offer a good health check, so we go on our own by
 * attempting to read with a short timeout. If the fails immediately we know the socket is
 * unhealthy.
 *
 * @param source the source used to read bytes from the socket.
 */
internal fun Socket.isHealthy(source: BufferedSource): Boolean =
  try {
    val readTimeout = soTimeout
    try {

import jcifs.smb.SmbSessionInternal;
import jcifs.smb.SmbTransportInternal;

/**
 * Unit tests for SMB3 Multi-Channel functionality
 *
 * These tests verify the multi-channel implementation without requiring a real SMB server.
 */
@ExtendWith(MockitoExtension.class)
@MockitoSettings(strictness = Strictness.LENIENT)
class MultiChannelIntegrationTest {

    @Mock
    private SmbTransportInternal mockTransport;

    @Mock

            fail("Failed to access servername field: " + e.getMessage());
        }
    }

    @Test
    void testGetEntriesWithMultipleShares() throws Exception {
        // Create real ShareInfo1 objects instead of mocks
        srvsvc.ShareInfo1 shareInfo1 = new srvsvc.ShareInfo1();
        shareInfo1.netname = "Share1";
        shareInfo1.type = 0;
        shareInfo1.remark = "Remark for Share1";

     */
    @Test
    @DisplayName("Test FileInformation implementation with spy")
    void testFileInformationWithSpy() throws SMBProtocolDecodingException {
        // Create spy on real object
        FileEndOfFileInformation realObject = new FileEndOfFileInformation(4096L);
        FileEndOfFileInformation spy = Mockito.spy(realObject);

        // Call methods

        verify(watchHandle, times(1)).call();
    }

    /**
     * Test call() method as Callable in executor service
     */
    @Test
    void testCallAsCallable() throws Exception {
        // Create a real implementation for testing Callable behavior
        SmbWatchHandle realHandle = new SmbWatchHandle() {
            private int callCount = 0;

            @Override

import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;

/**
 * JUnit 5 tests for {@link TestLocking}.
 * Tests command line argument parsing and basic field initialization.
 * Does not require a real SMB server - focuses on application logic.
 */
@ExtendWith(MockitoExtension.class)
class TestLockingTest {

    private PrintStream originalOut;
    private PrintStream originalErr;