vært
være
båe
begge
siden
dykk
dykkar
dei
deira
deires
deim
di
då
eg
ein
eit
eitt
elles
honom
hjå
ho
hoe
henne
hennar
hennes
hoss
hossen
ikkje
ingi
inkje
korleis
korso
kva
kvar
kvarhelst
kven
kvi
kvifor
me
medan
mi
mine
mykje
no
nokon
noka
nokor
noko
nokre

	result.Languages = append(user.Languages, result.Languages...)
	result.Toys = append(user.Toys, result.Toys...)

	sort.Slice(result.Languages, func(i, j int) bool {
		return strings.Compare(result.Languages[i].Code, result.Languages[j].Code) > 0
	})

	sort.Slice(result.Toys, func(i, j int) bool {
		return result.Toys[i].ID < result.Toys[j].ID
	})

	sort.Slice(result2.Languages, func(i, j int) bool {

		*GetUser("delete_slice_with_associations1", Config{Account: true, Pets: 4, Toys: 1, Company: true, Manager: true, Team: 1, Languages: 1, Friends: 4}),
		*GetUser("delete_slice_with_associations2", Config{Account: true, Pets: 3, Toys: 2, Company: true, Manager: true, Team: 2, Languages: 2, Friends: 3}),
		*GetUser("delete_slice_with_associations3", Config{Account: true, Pets: 2, Toys: 3, Company: true, Manager: true, Team: 3, Languages: 3, Friends: 2}),

		*GetUser("bulk_5", Config{Account: false, Pets: 0, Toys: 3, Company: true, Manager: false, Team: 1, Languages: 3, Friends: 1}),
		*GetUser("bulk_6", Config{Account: true, Pets: 4, Toys: 3, Company: false, Manager: true, Team: 1, Languages: 3, Friends: 0}),
		*GetUser("bulk_7", Config{Account: true, Pets: 1, Toys: 3, Company: true, Manager: true, Team: 4, Languages: 3, Friends: 1}),

		*GetUser("slice-hasmany-2", Config{Toys: 0, Tools: 2}),
		*GetUser("slice-hasmany-3", Config{Toys: 4}),
	}

	DB.Create(&users)

	// Count
	AssertAssociationCount(t, users, "Toys", 6, "")
	AssertAssociationCount(t, users, "Tools", 2, "")

	// Find
	var toys []Toy
	if DB.Model(&users).Association("Toys").Find(&toys); len(toys) != 6 {
		t.Errorf("toys count should be %v, but got %v", 6, len(toys))
	}

		ID  int
		Cat struct {
			Name string
			Toy  Toy   `gorm:"polymorphic:Owner;"`
			Toys []Toy `gorm:"polymorphic:Owner;"`
		} `gorm:"embedded;embeddedPrefix:cat_"`
		Dog struct {
			ID     int
			Name   string
			UserID int
			Toy    Toy   `gorm:"polymorphic:Owner;"`
			Toys   []Toy `gorm:"polymorphic:Owner;"`
		}
		Toys []Toy `gorm:"polymorphic:Owner;"`
	}

			}
		}
	})

	t.Run("Toys", func(t *testing.T) {
		if len(user.Toys) != len(expect.Toys) {
			t.Fatalf("toys should equal, expect: %v, got %v", len(expect.Toys), len(user.Toys))
		}

		sort.Slice(user.Toys, func(i, j int) bool {
			return user.Toys[i].ID > user.Toys[j].ID
		})

		sort.Slice(expect.Toys, func(i, j int) bool {
			return expect.Toys[i].ID > expect.Toys[j].ID
		})

Ainsi, j'ai pu trouver les meilleurs moyens de réduire autant que possible la duplication du code, d'avoir la complétion partout, les contrôles de type et d'erreur, etc.

Le tout de manière à offrir la meilleure expérience de développement à tous les développeurs.

## Exigences

	m.Set(replicationMaxActiveWorkers, float64(qa.Max))

	if len(qs.XferStats) > 0 {
		tots := qs.XferStats[Total]
		m.Set(replicationAverageDataTransferRate, tots.Avg)
		m.Set(replicationCurrentDataTransferRate, tots.Curr)
		m.Set(replicationMaxDataTransferRate, tots.Peak)
	}
	m.Set(replicationRecentBacklogCount, float64(qs.MRFStats.LastFailedCount))

	return nil

	}

	DB.Create(&pets)

	// Count
	AssertAssociationCount(t, pets, "Toy", 2, "")

	// Find
	var toys []Toy
	if DB.Model(&pets).Association("Toy").Find(&toys); len(toys) != 2 {
		t.Errorf("toys count should be %v, but got %v", 3, len(toys))
	}

	// Append
	DB.Model(&pets).Association("Toy").Append(
		&Toy{Name: "toy-slice-append-1"},
		&Toy{Name: "toy-slice-append-2"},