}

        @Test
        @DisplayName("Should handle null root cause")
        void testConstructorWithNullRootCause() {
            TransportException exception = new TransportException((Throwable) null);

            assertNotNull(exception);
            assertNull(exception.getRootCause());
        }

        @Test
        @DisplayName("Should handle null message with root cause")

            assertEquals(16, bytesRead);
            assertEquals(2048, response.getCount());
            assertEquals(1024, response.getRemaining());
        }

        @Test
        @DisplayName("Should handle zero count and remaining")
        void testReadZeroValues() throws SMBProtocolDecodingException {
            byte[] buffer = createValidWriteResponse(0, 0);

        @NullAndEmptySource
        @DisplayName("Should handle null and empty FQDN in fixupHost")
        void testFixupHostWithNullAndEmpty(String fqdn) {
            // Test with mock
            doNothing().when(mockReferralData).fixupHost(fqdn);
            assertDoesNotThrow(() -> mockReferralData.fixupHost(fqdn));

            // Test with concrete implementation - fixupHost doesn't handle null fqdn
            if (fqdn == null) {

     * Verifies that the handle, ptype, and flags are correctly initialized.
     */
    @Test
    void testConstructor() {
        // Create an instance of MsrpcLsarClose with the mock handle
        MsrpcLsarClose lsarClose = new MsrpcLsarClose(mockHandle);

        // Verify that the handle passed to the constructor is correctly set in the superclass

    @Test
    @DisplayName("Should handle null domain and workstation")
    void testNullDomainAndWorkstation() {
        // When
        Type1Message type1 = new Type1Message(mockContext, 0, null, null);

        // Then
        assertNull(type1.getSuppliedDomain());
        assertNull(type1.getSuppliedWorkstation());
    }

    @Test
    @DisplayName("Should handle case sensitivity in domain and workstation")

import jcifs.internal.smb2.create.CreateContextRequest;
import jcifs.internal.util.SMBUtil;

/**
 * SMB2 Durable Handle V2 Request Create Context (DH2Q)
 *
 * MS-SMB2 Section 2.2.13.2.4
 */
public class DurableHandleV2Request implements CreateContextRequest {

    /**
     * Context name for durable handle V2 request
     */
    public static final String CONTEXT_NAME = "DH2Q";

		auth = NoAuthMiddleware
	}

	metricsRouter.Handle(prometheusMetricsPathLegacy, auth(metricsHandler()))
	metricsRouter.Handle(prometheusMetricsV2ClusterPath, auth(metricsServerHandler()))
	metricsRouter.Handle(prometheusMetricsV2BucketPath, auth(metricsBucketHandler()))
	metricsRouter.Handle(prometheusMetricsV2NodePath, auth(metricsNodeHandler()))
	metricsRouter.Handle(prometheusMetricsV2ResourcePath, auth(metricsResourceHandler()))

import jcifs.internal.smb2.create.CreateContextResponse;

/**
 * SMB2 Durable Handle Reconnect Response Create Context
 *
 * MS-SMB2 Section 2.2.14.2.5
 */
public class DurableHandleReconnectResponse implements CreateContextResponse {

    /**
     * Context name for durable handle reconnect response
     */
    public static final String CONTEXT_NAME = "DHnC";

            assertEquals(transport, result);
            verify(transportPool).getSmbTransport(context, TEST_HOST, DEFAULT_PORT, false, true);
        }

        @Test
        @DisplayName("Should handle UnknownHostException")
        void testGetSmbTransportUnknownHost() throws UnknownHostException, IOException {
            // Given

            assertArrayEquals(expectedName, actualName);
            verify(response, times(1)).getName();
        }

        @Test
        @DisplayName("getName() should handle null return value")
        void testGetNameWithNull() {
            CreateContextResponse response = mock(CreateContextResponse.class);
            when(response.getName()).thenReturn(null);