result, err := db.Preload("Company", nil).Preload("Pets", nil).Where("name = ?", u.Name).First(ctx)
	if err != nil {
		t.Fatalf("Preload failed: %v", err)
	}

	if result.Name != u.Name || result.Company.Name != u.Company.Name || len(result.Pets) != len(u.Pets) {
		t.Fatalf("Preload expected %s, got %+v", u.Name, result)
	}

	results, err := db.Preload("Company", func(db gorm.PreloadBuilder) error {

func (c chainG[T]) Order(value interface{}) ChainInterface[T] {
	return c.with(func(db *DB) *DB {
		return db.Order(value)
	})
}

func (c chainG[T]) Preload(association string, query func(db PreloadBuilder) error) ChainInterface[T] {
	return c.with(func(db *DB) *DB {
		return db.Preload(association, func(tx *DB) *DB {
			q := preloadBuilder{db: tx.getInstance()}
			if query != nil {
				if err := query(&q); err != nil {

    }

    // Test reload with InputStream
    public void test_reload_withComments() {
        String content = "# This is a comment\n" + "word1\n" + "\n" + // empty line
                "word2\n" + "# Another comment\n" + "word3\n";

        InputStream is = new ByteArrayInputStream(content.getBytes(StandardCharsets.UTF_8));
        stopwordsFile.reload(null, is);

        // Load data first
        protwordsFile.reload(null);

        // Test with offset out of bounds
        PagingList<ProtwordsItem> list = protwordsFile.selectList(100, 10);
        assertEquals(0, list.size());
        assertTrue(list.isEmpty());
    }

    public void test_selectList_negativeOffset() {
        // Load data first
        protwordsFile.reload(null);

        // Test with negative offset

        assertNotNull("Annotation should be present on field", annotation);
        assertEquals("Payload length should be 2", 2, annotation.payload().length);
        assertEquals("First payload should be TestPayload", TestPayload.class, annotation.payload()[0]);
        assertEquals("Second payload should be AnotherTestPayload", AnotherTestPayload.class, annotation.payload()[1]);
    }

    // Test annotation on method

        assertEquals("Should have 2 payloads", 2, multiAnnotation.payload().length);
        assertEquals("First payload should be TestPayload", TestPayload.class, multiAnnotation.payload()[0]);
        assertEquals("Second payload should be AnotherTestPayload", AnotherTestPayload.class, multiAnnotation.payload()[1]);
    }

    // Additional test interfaces for multiple groups/payloads test

    void testReadSecurityBuffer() {
        byte[] buf = new byte[8 + 4];
        byte[] payload = { 0x11, 0x22, 0x33, 0x44 };
        NtlmMessage.writeSecurityBuffer(buf, 0, 8, payload);
        byte[] extracted = NtlmMessage.readSecurityBuffer(buf, 0);
        assertArrayEquals(payload, extracted, "Payload should match original");
    }

    @Test
    @DisplayName("readSecurityBuffer throws when array is too short")

public interface Message {

    /**
     * Indicate that this message should retain it's raw payload
     */
    void retainPayload();

    /**
     * Determines whether to retain the message payload.
     *
     * @return whether to retain the message payload
     */
    boolean isRetainPayload();

    /**
     * Gets the raw payload of the message.
     *
     * @return the raw response message
     */

}

// LoadUser - reloads a specific user from backend disks or etcd.
func (sys *IAMSys) LoadUser(ctx context.Context, objAPI ObjectLayer, accessKey string, userType IAMUserType) error {
	if !sys.Initialized() {
		return errServerNotInitialized
	}

	return sys.store.UserNotificationHandler(ctx, accessKey, userType)
}

// LoadServiceAccount - reloads a specific service account from backend disks or etcd.

        }
    }

    // Test reload with IOException
    public void test_reload_ioException() throws Exception {
        // This test verifies error handling during reload
        // Since we can't easily mock the IOException, we'll test with invalid data
        writeTestFile("invalid => "); // Invalid format

        try {
            charMappingFile.reload(null);