user.NamedPet = &Pet{Name: name + "_namepet"}
	}

	return &user
}

func CheckPetUnscoped(t *testing.T, pet Pet, expect Pet) {
	doCheckPet(t, pet, expect, true)
}

func CheckPet(t *testing.T, pet Pet, expect Pet) {
	doCheckPet(t, pet, expect, false)
}

func doCheckPet(t *testing.T, pet Pet, expect Pet, unscoped bool) {
	if pet.ID != 0 {
		var newPet Pet

package clause_test

import (
	"fmt"
	"testing"

	"gorm.io/gorm/clause"
)

func TestGroupBy(t *testing.T) {
	results := []struct {
		Clauses []clause.Interface
		Result  string
		Vars    []interface{}
	}{
		{
			[]clause.Interface{clause.Select{}, clause.From{}, clause.GroupBy{
				Columns: []clause.Column{{Name: "role"}},
				Having:  []clause.Expression{clause.Eq{"role", "admin"}},
			}},

package tests_test

import (
	"context"
	"errors"
	"testing"

	"gorm.io/gorm"
	. "gorm.io/gorm/utils/tests"
)

func TestTransaction(t *testing.T) {
	tx := DB.Begin()
	user := *GetUser("transaction", Config{})

	if err := tx.Save(&user).Error; err != nil {
		t.Fatalf("No error should raise, but got %v", err)
	}

	if err := tx.First(&User{}, "name = ?", "transaction").Error; err != nil {

package tests_test

import (
	"errors"
	"regexp"
	"sort"
	"strings"
	"testing"
	"time"

	"gorm.io/gorm"
	"gorm.io/gorm/clause"
	"gorm.io/gorm/utils"
	. "gorm.io/gorm/utils/tests"
)

func TestUpdate(t *testing.T) {
	var (
		users = []*User{
			GetUser("update-1", Config{}),
			GetUser("update-2", Config{}),
			GetUser("update-3", Config{}),
		}
		user          = users[1]
		lastUpdatedAt time.Time
	)

package clause_test

import (
	"fmt"
	"testing"

	"gorm.io/gorm/clause"
)

func TestFrom(t *testing.T) {
	results := []struct {
		Clauses []clause.Interface
		Result  string
		Vars    []interface{}
	}{
		{
			[]clause.Interface{clause.Select{}, clause.From{}},
			"SELECT * FROM `users`", nil,
		},
		{
			[]clause.Interface{
				clause.Select{}, clause.From{
					Tables: []clause.Table{{Name: "users"}},

package tests_test

import (
	"testing"

	. "gorm.io/gorm/utils/tests"
)

func TestHasOneAssociation(t *testing.T) {
	user := *GetUser("hasone", Config{Account: true})

	if err := DB.Create(&user).Error; err != nil {
		t.Fatalf("errors happened when create: %v", err)
	}

	CheckUser(t, user, user)

	// Find
	var user2 User
	DB.Find(&user2, "id = ?", user.ID)
	DB.Model(&user2).Association("Account").Find(&user2.Account)

package schema_test

import (
	"reflect"
	"sync"
	"testing"

	"gorm.io/gorm"
	"gorm.io/gorm/schema"
)

type UserWithCallback struct{}

func (UserWithCallback) BeforeSave(*gorm.DB) error {
	return nil
}

func (UserWithCallback) AfterCreate(*gorm.DB) error {
	return nil
}

func TestCallback(t *testing.T) {
	user, err := schema.Parse(&UserWithCallback{}, &sync.Map{}, schema.NamingStrategy{})
	if err != nil {

package tests_test

import (
	"testing"

	"gorm.io/gorm"
	. "gorm.io/gorm/utils/tests"
)

func TestUpdateMany2ManyAssociations(t *testing.T) {
	user := *GetUser("update-many2many", Config{})

	if err := DB.Create(&user).Error; err != nil {
		t.Fatalf("errors happened when create: %v", err)
	}

	user.Languages = []Language{{Code: "zh-CN", Name: "Chinese"}, {Code: "en", Name: "English"}}
	for _, lang := range user.Languages {

				{Field: &schema.Field{Name: "FieldH1", Unique: true}},
				{Field: &schema.Field{Name: "FieldH2"}},
			},
		},
	}, indices)
}

func CheckIndices(t *testing.T, expected, actual map[string]schema.Index) {
	for k, ei := range expected {
		t.Run(k, func(t *testing.T) {
			ai, ok := actual[k]
			if !ok {
				t.Errorf("expected index %q but actual missing", k)
				return
			}

import (
	"context"
	"database/sql"
	"database/sql/driver"
	"encoding/json"
	"errors"
	"fmt"
	"reflect"
	"regexp"
	"strconv"
	"testing"
	"time"

	"gorm.io/gorm"
	"gorm.io/gorm/clause"
	. "gorm.io/gorm/utils/tests"
)

func TestScannerValuer(t *testing.T) {
	DB.Migrator().DropTable(&ScannerValuerStruct{})
	if err := DB.Migrator().AutoMigrate(&ScannerValuerStruct{}); err != nil {