package tests_test

import (
	"errors"
	"fmt"
	"regexp"
	"testing"
	"time"

	"github.com/jinzhu/now"
	"gorm.io/gorm"
	"gorm.io/gorm/clause"
	. "gorm.io/gorm/utils/tests"
)

func TestCreate(t *testing.T) {
	user := *GetUser("create", Config{})

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

package tests_test

import (
	"testing"
	"time"

	"github.com/google/uuid"
	"github.com/lib/pq"
	"gorm.io/gorm"
	"gorm.io/gorm/clause"
	. "gorm.io/gorm/utils/tests"
)

func TestPostgresReturningIDWhichHasStringType(t *testing.T) {
	if DB.Dialector.Name() != "postgres" {
		t.Skip()
	}

	type Yasuo struct {
		ID        string `gorm:"default:gen_random_uuid()"`
		Name      string

		}

		if len(data.err) > 0 && err == nil {
			t.Errorf("callbacks tests #%v should got error %v, but not", idx+1, data.err)
		} else if len(data.err) == 0 && err != nil {
			t.Errorf("callbacks tests #%v should not got error, but got %v", idx+1, err)
		}

		if ok, msg := assertCallbacks(callbacks.Create(), data.results); !ok {
			t.Errorf("callbacks tests #%v failed, got %v", idx+1, msg)
		}
	}
}

package clause_test

import (
	"sync"
	"testing"

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

func BenchmarkSelect(b *testing.B) {
	user, _ := schema.Parse(&tests.User{}, &sync.Map{}, db.NamingStrategy)

	for i := 0; i < b.N; i++ {
		stmt := gorm.Statement{DB: db, Table: user.Table, Schema: user, Clauses: map[string]clause.Clause{}}

package tests_test

import (
	"context"
	"testing"

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

func NameIn1And2(d *gorm.DB) *gorm.DB {
	return d.Where("name in (?)", []string{"ScopeUser1", "ScopeUser2"})
}

func NameIn2And3(d *gorm.DB) *gorm.DB {
	return d.Where("name in (?)", []string{"ScopeUser2", "ScopeUser3"})
}

func NameIn(names []string) func(d *gorm.DB) *gorm.DB {
	return func(d *gorm.DB) *gorm.DB {

package schema_test

import (
	"context"
	"fmt"
	"reflect"
	"strings"
	"testing"

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

func checkSchema(t *testing.T, s *schema.Schema, v schema.Schema, primaryFields []string) {
	t.Run("CheckSchema/"+s.Name, func(t *testing.T) {
		tests.AssertObjEqual(t, s, v, "Name", "Table")

		for idx, field := range primaryFields {
			var found bool
			for _, f := range s.PrimaryFields {

package tests_test

import (
	"regexp"
	"testing"

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

func TestDistinct(t *testing.T) {
	users := []User{
		*GetUser("distinct", Config{}),
		*GetUser("distinct", Config{}),
		*GetUser("distinct", Config{}),
		*GetUser("distinct-2", Config{}),
		*GetUser("distinct-3", Config{}),
	}
	users[0].Age = 20

	if err := DB.Create(&users).Error; err != nil {

package tests_test

import (
	"context"
	"time"

	"gorm.io/gorm/logger"
)

type Tracer struct {
	Logger logger.Interface
	Test   func(ctx context.Context, begin time.Time, fc func() (sql string, rowsAffected int64), err error)
}

func (S Tracer) LogMode(level logger.LogLevel) logger.Interface {
	return S.Logger.LogMode(level)
}

func (S Tracer) Info(ctx context.Context, s string, i ...interface{}) {

package tests

import (
	"database/sql"
	"time"

	"gorm.io/gorm"
)

// User has one `Account` (has one), many `Pets` (has many) and `Toys` (has many - polymorphic)
// He works in a Company (belongs to), he has a Manager (belongs to - single-table), and also managed a Team (has many - single-table)
// He speaks many languages (many to many) and has many friends (many to many - single-table)
// His pet also has one Toy (has one - polymorphic)

package tests_test

import (
	"regexp"
	"testing"
	"time"

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

func TestUpsert(t *testing.T) {
	lang := Language{Code: "upsert", Name: "Upsert"}
	if err := DB.Clauses(clause.OnConflict{DoNothing: true}).Create(&lang).Error; err != nil {
		t.Fatalf("failed to upsert, got %v", err)
	}

	lang2 := Language{Code: "upsert", Name: "Upsert"}