}).when(mockDcerpcHandle).sendrecv(any(MsrpcLsarClose.class));

        // Close once
        handle.close();

        // Act
        // Try to close again
        handle.close();

        // Assert
        // Verify sendrecv was called once for open and only once for close
        verify(mockDcerpcHandle, times(1)).sendrecv(any(MsrpcLsarOpenPolicy2.class));

    int readDataWireFormat(final byte[] buffer, final int bufferIndex, final int len) {
        return switch (informationLevel) {
        case SMB_INFO_ALLOCATION -> readSmbInfoAllocationWireFormat(buffer, bufferIndex);
        case SMB_QUERY_FS_SIZE_INFO -> readSmbQueryFSSizeInfoWireFormat(buffer, bufferIndex);
        case SMB_FS_FULL_SIZE_INFORMATION -> readFsFullSizeInformationWireFormat(buffer, bufferIndex);
        default -> 0;
        };
    }

    }

    void close(final int f, final long lastWriteTime) throws SmbException {

        if (LogStream.level >= 3) {
            log.println("close: " + f);
        }

        /*
         * Close Request / Response
         */

        send(new SmbComClose(f, lastWriteTime), blank_resp());
    }

    void close(final long lastWriteTime) throws SmbException {

import jcifs.context.BaseContext;
import jcifs.smb.NtlmPasswordAuthentication;

/**
 * Tests for the NtlmHttpURLConnection class.
 * This class uses Mockito to simulate the behavior of HttpURLConnection and other dependencies.
 */
@ExtendWith(MockitoExtension.class)
@MockitoSettings(strictness = Strictness.LENIENT)
class NtlmHttpURLConnectionTest {

    @Mock
    private HttpURLConnection mockConnection;

    private URL mockUrl;

            return emptyMap();
        } else if (map instanceof AbstractImmutableMap) {
            return map;
        } else {
            switch (map.size()) {
                case 0:
                    return emptyMap();
                case 1:
                    Map.Entry<K, V> entry = map.entrySet().iterator().next();
                    return singletonMap(entry.getKey(), entry.getValue());
                default:

import jcifs.smb.SmbTransportInternal;
import jcifs.util.Crypto;
import jcifs.util.Hexdump;

/**
 *
 *
 * <p>This class is intended for internal use.</p>
 */
public class SMB1SigningDigest implements SMBSigningDigest {

    private static final Logger log = LoggerFactory.getLogger(SMB1SigningDigest.class);

    private final MessageDigest digest;
    private byte[] macSigningKey;
    private boolean bypass = false;

 * it easy to get sample values to use in such tests.
 *
 * This class is pretty fast and loose with default values: it attempts to provide values that are
 * well-formed, but doesn't guarantee values are internally consistent. Callers must take care to
 * configure the factory when sample values impact the correctness of the test.
 */
class TestValueFactory : Closeable {

 *
 * Manages multiple network connections for improved performance and redundancy
 * as specified in the SMB 3.x multi-channel feature.
 */
public class MultiChannelManager {

    private static final Logger log = LoggerFactory.getLogger(MultiChannelManager.class);

    // Multi-channel configuration
    private final Configuration config;
    private final int maxChannels;

import static org.codelibs.curl.io.ContentOutputStream.SUFFIX;
import static org.junit.Assert.assertEquals;

public class IOIntegrationTest {

    private static final Logger logger = Logger.getLogger(IOIntegrationTest.class.getName());

    class MockCurlRequest extends CurlRequest {

        MockCurlRequest(Curl.Method method, String url) {
            super(method, url);
        }

  }

  @AfterEach
  @Throws(Exception::class)
  fun tearDown() {
    client.listener.assertExhausted()
    server.listener.assertExhausted()
    server.source.close()
    client.source.close()
    taskFaker.runTasks()
    server.webSocket!!.tearDown()
    client.webSocket!!.tearDown()
    taskFaker.close()
  }

  @Test
  fun close() {
    client.webSocket!!.close(1000, "Hello!")