void testNullMaximumVersion() {
        // Given
        when(mockConfig.getMaximumVersion()).thenReturn(null);

        // When/Then - Should throw NPE based on actual implementation
        assertThrows(NullPointerException.class, () -> {
            new Smb2NegotiateRequest(mockConfig, 0);
        });
    }

    @Test
    @DisplayName("Should properly align buffer writes")
    void testBufferAlignment() {

        // Arrange
        SmbBasicFileInfo info = null;

        // Act & Assert: attempting to call any method on null should throw NPE
        Assertions.assertThrows(NullPointerException.class, () -> {
            // Intentionally dereference null to validate exception behavior
            // This checks that callers must handle null references defensively
            info.getSize();
        });

        assertTrue(conn instanceof SmbFile);
    }

    @Test
    @DisplayName("openConnection throws NPE for null URL")
    void testOpenConnectionWithNullUrl() {
        // Act & Assert
        assertThrows(NullPointerException.class, () -> handler.openConnection(null));
    }

    @Test
    @DisplayName("URL created with handler parses SMB URL correctly")
    void testUrlCreationWithHandler() throws Exception {

    void testMethodsWithNullBuffers() {
        netShareEnum = new NetShareEnum(realConfig);

        // Write methods return 0 when buffer is null (no NullPointerException thrown)
        assertEquals(0, netShareEnum.writeSetupWireFormat(null, 0));

        assertThrows(NullPointerException.class, () -> {
            netShareEnum.writeParametersWireFormat(null, 0);
        });

    @BeforeEach
    void setUp() {
        MockitoAnnotations.openMocks(this);
        when(mockConfig.getNetbiosScope()).thenReturn(null);
        // Configure OEM encoding to avoid NullPointerException
        when(mockConfig.getOemEncoding()).thenReturn("UTF-8");
    }

    @Test
    @DisplayName("Constructor with Configuration only should create empty Name instances")
    void testConstructorWithConfigOnly() {

            assertTrue(UniAddress.isDotQuadIP("999.999.999.999"));
        }

        @Test
        void shouldThrowExceptionForNullInput() {
            assertThrows(NullPointerException.class, () -> UniAddress.isDotQuadIP(null));
        }

        @Test
        void shouldThrowExceptionForEmptyInput() {
            assertThrows(StringIndexOutOfBoundsException.class, () -> UniAddress.isDotQuadIP(""));

        // This test verifies that when the system property is null, the handler
        // falls back to using default handlers without throwing NullPointerException.
        System.clearProperty("java.protocol.handler.pkgs");
        setupMockProtocolHandlers();
        URL url = new URL("http://example.com/resource");

    void getters_withoutTree_throwNPE(String name, org.junit.jupiter.api.function.Executable call) {
        // Each call is invalid without a held tree and should throw NPE
        assertThrows(NullPointerException.class, call);
    }

    static java.util.stream.Stream<Arguments> wrapExceptions() {
        CIFSContext ctx = mock(CIFSContext.class);

        // Set up an expired cache entry
        Dfs.CacheEntry expiredEntry = new Dfs.CacheEntry(-1); // Expired
        testDfs._domains = expiredEntry;
        testDfs.setDisabled(true); // Set disabled to avoid NullPointerException

        when(auth.getDomain()).thenReturn("domain.com");

        assertNull(testDfs.getTrustedDomains(auth));
    }

    @Test

        @Test
        @DisplayName("Should handle null buffer in decode")
        void testNullBuffer() {
            FileFsSizeInformation info = new FileFsSizeInformation();

            assertThrows(NullPointerException.class, () -> {
                info.decode(null, 0, 0);
            });
        }

        @Test
        @DisplayName("Should handle insufficient buffer length")