// Assert
        assertNotNull(entries, "Entries array should not be null");
        assertEquals(1, entries.length, "Exactly one entry is expected");
        AppConfigurationEntry e = entries[0];
        assertNotNull(e, "Entry should not be null");
        assertEquals(EXPECTED_LOGIN_MODULE, e.getLoginModuleName(), "Login module should be Kerberos");

		t.Fatalf("Should find 1 tags after Delete")
	}

	if DB.Model(&blog).Association("Tags").Count() != 1 {
		t.Fatalf("Blog should has three tags after Delete")
	}

	DB.Model(&blog).Association("Tags").Delete(tag3)
	var tags4 []Tag
	DB.Model(&blog).Association("Tags").Find(&tags4)
	if !compareTags(tags4, []string{"tag6"}) {
		t.Fatalf("Tag should not be deleted when Delete with a unrelated tag")

    }

    @Test
    @DisplayName("Should handle retry policy correctly")
    void testRetryPolicy() {
        // Given
        SmbOperationException.RetryPolicy policy = new SmbOperationException.RetryPolicy(3, 1000, 10000, 2.0, true);

        exception = new SmbOperationException(SmbOperationException.ErrorCode.CONNECTION_TIMEOUT, "Timeout occurred", null, policy, null);

        // When/Then - Should retry for attempts 1 and 2

                assertEquals((byte) 0xFF, buffer[startIndex + SOURCE_KEY_SIZE + 4 + i],
                        "Reserved byte at position " + i + " should remain unchanged");
            }
        }

        @Test
        @DisplayName("Should encode single chunk data correctly")
        void testEncodeSingleChunk() {
            // Given
            SrvCopychunk chunk = new SrvCopychunk(1024, 2048, 4096);

/**
 * Test class for StringUtil utility methods
 */
class StringUtilTest {

    @Test
    @DisplayName("Should join single element without delimiter")
    void testJoinSingleElement() {
        String result = StringUtil.join(",", "hello");
        assertEquals("hello", result);
    }

    @Test
    @DisplayName("Should join two elements with delimiter")
    void testJoinTwoElements() {

        }

        @Test
        @DisplayName("Should initialize with SMB2_WRITE command")
        void testCommandInitialization() {
            Smb2WriteRequest writeRequest = new Smb2WriteRequest(mockConfig, testFileId);
            // Command is set in parent constructor
            assertNotNull(writeRequest);
        }

        @Test
        @DisplayName("Should accept null file ID in constructor")

            cancel = constructor.newInstance(mockConfig, 1);
        }

        @Test
        @DisplayName("isCancel should return true")
        void testIsCancelReturnsTrue() {
            assertTrue(cancel.isCancel());
        }

        @Test
        @DisplayName("writeParameterWordsWireFormat should return 0")
        void testWriteParameterWordsReturnsZero() throws Exception {
            // Given

		t.Errorf("name should be groupby, but got %v, total should be 60, but got %v", name, total)
	}

	if err := DB.Model(&User{}).Select("name, sum(age) as total").Where("name LIKE ?", "groupby%").Group("name").Having("name = ?", "groupby1").Row().Scan(&name, &total); err != nil {
		t.Errorf("no error should happen, but got %v", err)
	}

	if name != "groupby1" || total != 660 {

        assertTrue(exception instanceof RuntimeCIFSException, "Should extend RuntimeCIFSException");
        assertTrue(exception instanceof RuntimeException, "Should be a RuntimeException");
    }

    @Test
    @DisplayName("Message constructor should create exception with specified message")
    void testMessageConstructor() {
        // Given & When

        assertNotNull(avFlags, "AvFlags object should not be null");
        assertEquals(0x04030201, avFlags.getFlags(), "Flags should match the raw bytes (little-endian)");

        // Test with zero
        byte[] zeroBytes = new byte[] { 0x00, 0x00, 0x00, 0x00 };
        AvFlags zeroAvFlags = new AvFlags(zeroBytes);
        assertNotNull(zeroAvFlags, "AvFlags object should not be null for zero bytes");