assertFalse(message.getFlag(0b0001), "Flag 0b0001 should not be set.");

        message.setFlags(0); // No flags set
        assertFalse(message.getFlag(0b1000), "No flags should be set.");
    }

    @Test
    void testSetFlag() {
        // Test setting a flag
        message.setFlags(0);
        message.setFlag(0b0001, true);
        assertEquals(0b0001, message.getFlags(), "Flag 0b0001 should be set.");

    }

    @Test
    @DisplayName("Should get local host name")
    void testGetLocalName() {
        // When
        NetbiosName localName = nameServiceClient.getLocalName();

        // Then
        assertNotNull(localName, "Local name should not be null");
        assertTrue(localName.getName().length() > 0, "Local name should not be empty");
    }

    @Test
    @DisplayName("Should get unknown name")

        verify(mockContext).getPipe(url, pipeType);
    }

    @Test
    @DisplayName("Should close context")
    void testClose() throws CIFSException {
        // When
        mockContext.close();

        // Then
        verify(mockContext).close();
    }

    @Test
    @DisplayName("Should get Configuration")
    void testGetConfig() {
        // Given

    @DisplayName("Should handle various NetBIOS name types")
    void testVariousNameTypes(int nameType) {
        // Given
        when(mockNetbiosName.getNameType()).thenReturn(nameType);

        // When
        int result = mockNetbiosName.getNameType();

        // Then
        assertEquals(nameType, result);
    }

    @Test
    @DisplayName("Should handle null name")
    void testNullName() {

        assertTrue(session.isInUse(), "Session should be in use initially");
        try (SmbSessionImpl autoSession = session) {
            // Session is already in use due to transport acquisition
            assertTrue(autoSession.isInUse(), "Session should be in use");
        }

        // Session should be automatically released
        assertFalse(session.isInUse(), "Session should be released after try-with-resources");
    }

		t.Fatalf("value differs from expected")
	}
	if !ok {
		t.Fatalf("should be true")
	}

	if !lc.Contains("key1") {
		t.Fatalf("should contain key1")
	}
	if lc.Contains("key2") {
		t.Fatalf("should not contain key2")
	}

	v, ok = lc.Peek("key2")
	if v != "" {
		t.Fatalf("should be empty")
	}
	if ok {
		t.Fatalf("should be false")
	}

	if !reflect.DeepEqual(lc.Keys(), []string{"key1"}) {

                            null, "incomplete-project", null, "Should return null for missing groupId and version"),
                    Arguments.of("com.example", null, "1.0.0", "Should return null for missing artifactId"),
                    Arguments.of(null, null, "1.0.0", "Should return null for missing groupId and artifactId"),
                    Arguments.of("com.example", "test-project", null, "Should return null for missing version"),

    @Nested
    @DisplayName("Edge cases and special scenarios")
    class EdgeCases {

        @Test
        @DisplayName("Should handle multiple extensions for same mime type")
        void testMultipleExtensionsForSameMimeType() throws IOException {
            // Both jpg and jpeg should map to image/jpeg
            String jpgMime = mimeMap.getMimeType("jpg");
            String jpegMime = mimeMap.getMimeType("jpeg");

        }

        @Test
        @DisplayName("Should align size to 8-byte boundary")
        void testSizeAlignment() {
            int size = request.size();
            assertEquals(0, size % 8, "Size should be aligned to 8-byte boundary");
        }

        @ParameterizedTest
        @DisplayName("Should calculate size for various lock counts")

            assertEquals(0x00000008, ACE.FILE_READ_EA, "FILE_READ_EA should be 0x00000008");
            assertEquals(0x00000010, ACE.FILE_WRITE_EA, "FILE_WRITE_EA should be 0x00000010");
            assertEquals(0x00000020, ACE.FILE_EXECUTE, "FILE_EXECUTE should be 0x00000020");
            assertEquals(0x00000040, ACE.FILE_DELETE, "FILE_DELETE should be 0x00000040");