}

	DB.First(&result, user.ID)
	if result.Name != "new company name" {
		t.Errorf("name should be %v, but got %v", user.Company.Name, result.Name)
	}
}

func TestIdempotentSave(t *testing.T) {
	create := Company{
		Name: "company_idempotent",
	}
	DB.Create(&create)

	var company Company
	if err := DB.Find(&company, "id = ?", create.ID).Error; err != nil {

		{Name: "TestMany2ManyDuplicateBelongsToAssociation-friend-1", Company: Company{
			ID:   1,
			Name: "Test-company-1",
		}},
	}}

	user2 := User{Name: "TestMany2ManyDuplicateBelongsToAssociation-2", Friends: []*User{
		{Name: "TestMany2ManyDuplicateBelongsToAssociation-friend-2", Company: Company{
			ID:   1,
			Name: "Test-company-1",
		}},
	}}
	users := []*User{&user1, &user2}
	var err error

			References:  []Reference{{"ID", "User", "OwnerID", "Toy", "", true}, {"", "", "OwnerType", "Toy", "users", false}},
		},
		{
			Name: "Company", Type: schema.BelongsTo, Schema: "User", FieldSchema: "Company",
			References: []Reference{{"ID", "Company", "CompanyID", "User", "", false}},
		},
		{
			Name: "Manager", Type: schema.BelongsTo, Schema: "User", FieldSchema: "User",

	user := *GetUser("TestAssociationError", Config{Pets: 2, Company: true, Account: true, Languages: 2})
	DB.Create(&user)

	var user1 User
	DB.Preload("Company").Preload("Pets").Preload("Account").Preload("Languages").First(&user1)

	var emptyUser User
	var err error
	// belongs to
	err = DB.Model(&emptyUser).Association("Company").Delete(&user1.Company)
	AssertEqual(t, err, gorm.ErrPrimaryKeyRequired)
	// has many

			host:     "foo.svc.mesh.company.net.",
			expected: a("foo.svc.mesh.company.net.", []netip.Addr{netip.MustParseAddr("10.1.2.3")}),
		},
		{
			name:     "success: wild card with namespace with domain returns A record correctly",
			host:     "foo.foons.svc.mesh.company.net.",
			expected: a("foo.foons.svc.mesh.company.net.", []netip.Addr{netip.MustParseAddr("10.1.2.3")}),
		},
		{

        def companyModuleInEmptyRepo = emptyRepo.module('company', 'original', '1.1')

        def thirdPartyIvyRepo = server.getRemoteIvyRepo(false, "third-party/[organisation]/[module]/[revision]")
        def thirdPartyModule = thirdPartyIvyRepo.module('other', '3rdParty', '1.2')
        thirdPartyModule.publish()
        def companyModuleInThirdPartyRepo = thirdPartyIvyRepo.module('company', 'original', '1.1')

        and:

            }
        """

        plugin.file('src/main/resources/META-INF/gradle-plugins/com.company.composite.properties') << """
            implementation-class=org.gradle.test.CompositePlugin
        """

        plugin.build()

        buildFile << """
            plugins {
                id "com.company.composite"
            }
        """

        when:
        def result = runner('helloWorld1')

        buildFile << """
            jacocoTestCoverageVerification {
                violationRules {
                    rule {
                        element = 'CLASS'
                        includes = ['com.company.*', 'org.gradle.*']
                        $Insufficient.LINE_METRIC_COVERED_RATIO
                    }
                }
            }
        """

        when:

	}

	sa := service.ServiceAccounts
	if sa == nil || len(sa) != 4 {
		t.Fatalf("number of service accounts is incorrect")
	}
	expected := []string{
		saC, saD,
		"spiffe://company.com/ns/default/sa/" + saA,
		"spiffe://company.com/ns/default/sa/" + saB,
	}
	if !reflect.DeepEqual(sa, expected) {
		t.Fatalf("Unexpected service accounts %v (expecting %v)", sa, expected)
	}
}

        def libA = mavenHttpRepo.module("com.company","libs-a").publish()
        def libB = mavenHttpRepo.module("com.companylibs","libs-b").publish()
        settingsKotlinFile << """
            dependencyResolutionManagement {
                versionCatalogs {
                    create("libs") {
                        library("com-company-libs-a", "com.company:libs-a:1.0")
                    }