want: "/go/work/proj/gorm_alias/",
		},
		{
			file: "/go/work/proj/my.gorm.io/gorm@v1.2.3/utils/utils.go",
			want: "/go/work/proj/my.gorm.io/gorm@v1.2.3/",
		},
	}
	for _, c := range cases {
		s := sourceDir(c.file)
		if s != c.want {
			t.Fatalf("%s: expected %s, got %s", c.file, c.want, s)
		}
	}

			want: `C:/go/work/proj/gorm_alias/`,
		},
		{
			file: `C:/go/work/proj/my.gorm.io/gorm@v1.2.3/utils/utils.go`,
			want: `C:/go/work/proj/my.gorm.io/gorm@v1.2.3/`,
		},
	}
	for _, c := range cases {
		s := sourceDir(c.file)
		if s != c.want {
			t.Fatalf("%s: expected %s, got %s", c.file, c.want, s)
		}
	}

		}

		constraints := user.ParseUniqueConstraints()
		if len(constraints) != 1 {
			t.Fatalf("failed to find unique constraint, got %v", constraints)
		}

		for key := range constraints {
			if len(key) != 63 {
				t.Errorf("failed to find unique constraint, got %v", constraints)
			}
		}
	})

	t.Run("naming strategy", func(t *testing.T) {

	}

	ns := NamingStrategy{}
	for key, value := range maps {
		if ns.toDBName(key) != value {
			t.Errorf("%v toName should equal %v, but got %v", key, value, ns.toDBName(key))
		}
	}

	maps = map[string]string{
		"x":                              "X",

			"SELECT * FROM `users` LIMIT ? OFFSET ?",
			[]interface{}{limit50, 30},
		},
	}

	for idx, result := range results {
		t.Run(fmt.Sprintf("case #%v", idx), func(t *testing.T) {
			checkBuildClauses(t, result.Clauses, result.Result, result.Vars)
		})
	}

	}

	tx.RowsAffected = rowsAffected
	return tx
}

func (db *DB) assignInterfacesToValue(values ...interface{}) {
	for _, value := range values {
		switch v := value.(type) {
		case []clause.Expression:
			for _, expr := range v {
				if eq, ok := expr.(clause.Eq); ok {
					switch column := eq.Column.(type) {
					case string:

				Expression: clause.Join{
					Type:  clause.InnerJoin,
					Table: clause.Table{Name: "user"},
					Using: []string{"id"},
				},
			},
			sql: "INNER JOIN `user` USING (`id`)",
		},
	}
	for _, result := range results {
		t.Run(result.name, func(t *testing.T) {
			user, _ := schema.Parse(&tests.User{}, &sync.Map{}, db.NamingStrategy)
			stmt := &gorm.Statement{DB: db, Table: user.Table, Schema: user, Clauses: map[string]clause.Clause{}}

import (
	"database/sql/driver"
	"fmt"
	"go/ast"
	"reflect"
	"testing"
	"time"

	"gorm.io/gorm/utils"
)

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
		}

		},
	}

	for idx, r := range results {
		if result := logger.ExplainSQL(r.SQL, r.NumericRegexp, `"`, r.Vars...); result != r.Result {
			t.Errorf("Explain SQL #%v expects %v, but got %v", idx, r.Result, result)
		}
	}

	if len(foreignKeys) == 1 {
		for idx, r := range foreignValues {
			queryValues[idx] = r[0]
		}

		return clause.Column{Table: table, Name: foreignKeys[0]}, queryValues
	}

	columns := make([]clause.Column, len(foreignKeys))
	for idx, key := range foreignKeys {
		columns[idx] = clause.Column{Table: table, Name: key}
	}

	for idx, r := range foreignValues {
		queryValues[idx] = r
	}