)

func TestLocking(t *testing.T) {
	results := []struct {
		Clauses []clause.Interface
		Result  string
		Vars    []interface{}
	}{
		{
			[]clause.Interface{clause.Select{}, clause.From{}, clause.Locking{Strength: clause.LockingStrengthUpdate}},
			"SELECT * FROM `users` FOR UPDATE", nil,
		},
		{

package callbacks

import (
	"reflect"

	"gorm.io/gorm"
)

func callMethod(db *gorm.DB, fc func(value interface{}, tx *gorm.DB) bool) {
	tx := db.Session(&gorm.Session{NewDB: true})
	if called := fc(db.Statement.ReflectValue.Interface(), tx); !called {
		switch db.Statement.ReflectValue.Kind() {
		case reflect.Slice, reflect.Array:
			db.Statement.CurDestIndex = 0
			for i := 0; i < db.Statement.ReflectValue.Len(); i++ {

		switch values := db.Statement.Dest.(type) {
		case map[string]interface{}:
			values[pkFieldName] = insertID
		case *map[string]interface{}:
			(*values)[pkFieldName] = insertID
		case []map[string]interface{}, *[]map[string]interface{}:
			mapValues, ok := values.([]map[string]interface{})
			if !ok {
				if v, ok := values.(*[]map[string]interface{}); ok {
					if *v != nil {
						mapValues = *v
					}
				}

	)
	cases := []struct {
		str string
		res []interface{}
	}{
		{"s.title", []interface{}{"Murder on the Orient Express", "The Robots of Dawn", "Pigs Have Wings"}},
		{"s.authorInfo.yearRange", []interface{}{[]interface{}{1890.0, 1976.0}, []interface{}{1920.0, 1992.0}, []interface{}{1881.0, 1975.0}}},
		{"s.authorInfo.name", []interface{}{"Agatha Christie", "Isaac Asimov", "P. G. Wodehouse"}},

    @Incubating
    interface IncubatingInterface {}

    interface InternalInterface {}

    interface StablePublicInterface {}

    CtClass oldBase
    CtClass newBase
    CtClass newSuper
    CtClass newIncubatingBase
    CtClass internalInterface
    CtClass incubatingInterface
    CtClass stablePublicInterface

    Map interfaces

    def setup() {

		Unscope:      true,
	}
}

func (association *Association) Find(out interface{}, conds ...interface{}) error {
	if association.Error == nil {
		association.Error = association.buildCondition().Find(out, conds...).Error
	}
	return association.Error
}

func (association *Association) Append(values ...interface{}) error {
	if association.Error == nil {
		switch association.Relationship.Type {

)

func AssertObjEqual(t *testing.T, r, e interface{}, names ...string) {
	for _, name := range names {
		rv := reflect.Indirect(reflect.ValueOf(r))
		ev := reflect.Indirect(reflect.ValueOf(e))
		if rv.IsValid() != ev.IsValid() {
			t.Errorf("%v: expect: %+v, got %+v", utils.FileWithLineNum(), r, e)
			return
		}
		got := rv.FieldByName(name).Interface()
		expect := ev.FieldByName(name).Interface()
		t.Run(name, func(t *testing.T) {

pkg runtime/pprof, type LabelSet struct
pkg sync, method (*Map) Delete(interface{})
pkg sync, method (*Map) Load(interface{}) (interface{}, bool)
pkg sync, method (*Map) LoadOrStore(interface{}, interface{}) (interface{}, bool)
pkg sync, method (*Map) Range(func(interface{}, interface{}) bool)
pkg sync, method (*Map) Store(interface{}, interface{})
pkg sync, type Map struct

//
// [docs]: https://gorm.io/docs/sql_builder.html#Clauses
func (db *DB) Clauses(conds ...clause.Expression) (tx *DB) {
	tx = db.getInstance()
	var whereConds []interface{}

	for _, cond := range conds {
		if c, ok := cond.(clause.Interface); ok {
			tx.Statement.AddClause(c)
		} else if optimizer, ok := cond.(StatementModifier); ok {
			optimizer.ModifyStatement(tx.Statement)
		} else {

	"testing"

	"gorm.io/gorm/clause"
)

func TestSelect(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{
				Columns: []clause.Column{clause.PrimaryColumn},
			}, clause.From{}},