HiPoweredDev
/
xorm
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

move test files to tests/ subdir

This commit is contained in:
Lunny Xiao 2014-01-23 11:09:48 +08:00
parent 84ebac71f3
commit 21c08ea09c
11 changed files with 157 additions and 148 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
engine.go
View File

@ -21,8 +21,8 @@ type PK []interface{}
// Engine is the major struct of xorm, it means a database manager. // Engine is the major struct of xorm, it means a database manager.
// Commonly, an application only need one engine // Commonly, an application only need one engine
type Engine struct { type Engine struct {
columnMapper IMapper ColumnMapper IMapper
tableMapper IMapper TableMapper IMapper
TagIdentifier string TagIdentifier string
DriverName string DriverName string
DataSourceName string DataSourceName string
@ -47,11 +47,11 @@ func (engine *Engine) SetMapper(mapper IMapper) {
} }
func (engine *Engine) SetTableMapper(mapper IMapper) { func (engine *Engine) SetTableMapper(mapper IMapper) {
engine.tableMapper = mapper engine.TableMapper = mapper
} }
func (engine *Engine) SetColumnMapper(mapper IMapper) { func (engine *Engine) SetColumnMapper(mapper IMapper) {
engine.columnMapper = mapper engine.ColumnMapper = mapper
} }
// If engine's database support batch insert records like // If engine's database support batch insert records like
@ -406,7 +406,7 @@ func (engine *Engine) autoMap(bean interface{}) *core.Table {
} }
func (engine *Engine) mapType(t reflect.Type) *core.Table { func (engine *Engine) mapType(t reflect.Type) *core.Table {
return mappingTable(t, engine.tableMapper, engine.columnMapper, engine.dialect, engine.TagIdentifier) return mappingTable(t, engine.TableMapper, engine.ColumnMapper, engine.dialect, engine.TagIdentifier)
} }
func mappingTable(t reflect.Type, tableMapper IMapper, colMapper IMapper, dialect core.Dialect, tagId string) *core.Table { func mappingTable(t reflect.Type, tableMapper IMapper, colMapper IMapper, dialect core.Dialect, tagId string) *core.Table {

184
base_test.go → tests/base_test.go
View File

@ -7,6 +7,7 @@ import (
"testing" "testing"
"time" "time"
"github.com/lunny/xorm"
"github.com/lunny/xorm/core" "github.com/lunny/xorm/core"
) )
@ -44,7 +45,7 @@ type Userdetail struct {
Profile string `xorm:"varchar(2000)"` Profile string `xorm:"varchar(2000)"`
} }
func directCreateTable(engine *Engine, t *testing.T) { func directCreateTable(engine *xorm.Engine, t *testing.T) {
err := engine.DropTables(&Userinfo{}, &Userdetail{}) err := engine.DropTables(&Userinfo{}, &Userdetail{})
if err != nil { if err != nil {
t.Error(err) t.Error(err)
@ -94,7 +95,7 @@ func directCreateTable(engine *Engine, t *testing.T) {
} }
} }
func insert(engine *Engine, t *testing.T) { func insert(engine *xorm.Engine, t *testing.T) {
user := Userinfo{0, "xiaolunwen", "dev", "lunny", time.Now(), user := Userinfo{0, "xiaolunwen", "dev", "lunny", time.Now(),
Userdetail{Id: 1}, 1.78, []byte{1, 2, 3}, true} Userdetail{Id: 1}, 1.78, []byte{1, 2, 3}, true}
cnt, err := engine.Insert(&user) cnt, err := engine.Insert(&user)
@ -130,7 +131,7 @@ func insert(engine *Engine, t *testing.T) {
} }
} }
func testQuery(engine *Engine, t *testing.T) { func testQuery(engine *xorm.Engine, t *testing.T) {
sql := "select * from userinfo" sql := "select * from userinfo"
results, err := engine.Query(sql) results, err := engine.Query(sql)
if err != nil { if err != nil {
@ -140,7 +141,7 @@ func testQuery(engine *Engine, t *testing.T) {
fmt.Println(results) fmt.Println(results)
} }
func exec(engine *Engine, t *testing.T) { func exec(engine *xorm.Engine, t *testing.T) {
sql := "update userinfo set username=? where id=?" sql := "update userinfo set username=? where id=?"
res, err := engine.Exec(sql, "xiaolun", 1) res, err := engine.Exec(sql, "xiaolun", 1)
if err != nil { if err != nil {
@ -150,7 +151,7 @@ func exec(engine *Engine, t *testing.T) {
fmt.Println(res) fmt.Println(res)
} }
func testQuerySameMapper(engine *Engine, t *testing.T) { func testQuerySameMapper(engine *xorm.Engine, t *testing.T) {
sql := "select * from `Userinfo`" sql := "select * from `Userinfo`"
results, err := engine.Query(sql) results, err := engine.Query(sql)
if err != nil { if err != nil {
@ -160,7 +161,7 @@ func testQuerySameMapper(engine *Engine, t *testing.T) {
fmt.Println(results) fmt.Println(results)
} }
func execSameMapper(engine *Engine, t *testing.T) { func execSameMapper(engine *xorm.Engine, t *testing.T) {
sql := "update `Userinfo` set `Username`=? where (id)=?" sql := "update `Userinfo` set `Username`=? where (id)=?"
res, err := engine.Exec(sql, "xiaolun", 1) res, err := engine.Exec(sql, "xiaolun", 1)
if err != nil { if err != nil {
@ -170,7 +171,7 @@ func execSameMapper(engine *Engine, t *testing.T) {
fmt.Println(res) fmt.Println(res)
} }
func insertAutoIncr(engine *Engine, t *testing.T) { func insertAutoIncr(engine *xorm.Engine, t *testing.T) {
// auto increment insert // auto increment insert
user := Userinfo{Username: "xiaolunwen2", Departname: "dev", Alias: "lunny", Created: time.Now(), user := Userinfo{Username: "xiaolunwen2", Departname: "dev", Alias: "lunny", Created: time.Now(),
Detail: Userdetail{Id: 1}, Height: 1.78, Avatar: []byte{1, 2, 3}, IsMan: true} Detail: Userdetail{Id: 1}, Height: 1.78, Avatar: []byte{1, 2, 3}, IsMan: true}
@ -194,11 +195,11 @@ func insertAutoIncr(engine *Engine, t *testing.T) {
type BigInsert struct { type BigInsert struct {
} }
func insertDefault(engine *Engine, t *testing.T) { func insertDefault(engine *xorm.Engine, t *testing.T) {
} }
func insertMulti(engine *Engine, t *testing.T) { func insertMulti(engine *xorm.Engine, t *testing.T) {
//engine.InsertMany = true //engine.InsertMany = true
users := []Userinfo{ users := []Userinfo{
{Username: "xlw", Departname: "dev", Alias: "lunny2", Created: time.Now()}, {Username: "xlw", Departname: "dev", Alias: "lunny2", Created: time.Now()},
@ -239,7 +240,7 @@ func insertMulti(engine *Engine, t *testing.T) {
} }
} }
func insertTwoTable(engine *Engine, t *testing.T) { func insertTwoTable(engine *xorm.Engine, t *testing.T) {
userdetail := Userdetail{ /*Id: 1, */ Intro: "I'm a very beautiful women.", Profile: "sfsaf"} userdetail := Userdetail{ /*Id: 1, */ Intro: "I'm a very beautiful women.", Profile: "sfsaf"}
userinfo := Userinfo{Username: "xlw3", Departname: "dev", Alias: "lunny4", Created: time.Now(), Detail: userdetail} userinfo := Userinfo{Username: "xlw3", Departname: "dev", Alias: "lunny4", Created: time.Now(), Detail: userdetail}
@ -281,7 +282,7 @@ type Article struct {
type Condi map[string]interface{} type Condi map[string]interface{}
func update(engine *Engine, t *testing.T) { func update(engine *xorm.Engine, t *testing.T) {
// update by id // update by id
user := Userinfo{Username: "xxx", Height: 1.2} user := Userinfo{Username: "xxx", Height: 1.2}
cnt, err := engine.Id(4).Update(&user) cnt, err := engine.Id(4).Update(&user)
@ -360,7 +361,7 @@ func update(engine *Engine, t *testing.T) {
} }
} }
func updateSameMapper(engine *Engine, t *testing.T) { func updateSameMapper(engine *xorm.Engine, t *testing.T) {
// update by id // update by id
user := Userinfo{Username: "xxx", Height: 1.2} user := Userinfo{Username: "xxx", Height: 1.2}
cnt, err := engine.Id(4).Update(&user) cnt, err := engine.Id(4).Update(&user)
@ -409,7 +410,7 @@ func updateSameMapper(engine *Engine, t *testing.T) {
} }
} }
func testDelete(engine *Engine, t *testing.T) { func testDelete(engine *xorm.Engine, t *testing.T) {
user := Userinfo{Uid: 1} user := Userinfo{Uid: 1}
cnt, err := engine.Delete(&user) cnt, err := engine.Delete(&user)
if err != nil { if err != nil {
@ -452,7 +453,7 @@ type NoIdUser struct {
Total int64 Total int64
} }
func get(engine *Engine, t *testing.T) { func get(engine *xorm.Engine, t *testing.T) {
user := Userinfo{Uid: 2} user := Userinfo{Uid: 2}
has, err := engine.Get(&user) has, err := engine.Get(&user)
@ -472,7 +473,7 @@ func get(engine *Engine, t *testing.T) {
panic(err) panic(err)
} }
userCol := engine.columnMapper.Obj2Table("User") userCol := engine.ColumnMapper.Obj2Table("User")
_, err = engine.Where("`"+userCol+"` = ?", "xlw").Delete(&NoIdUser{}) _, err = engine.Where("`"+userCol+"` = ?", "xlw").Delete(&NoIdUser{})
if err != nil { if err != nil {
@ -507,7 +508,7 @@ func get(engine *Engine, t *testing.T) {
fmt.Println(noIdUser) fmt.Println(noIdUser)
} }
func cascadeGet(engine *Engine, t *testing.T) { func cascadeGet(engine *xorm.Engine, t *testing.T) {
user := Userinfo{Uid: 11} user := Userinfo{Uid: 11}
has, err := engine.Get(&user) has, err := engine.Get(&user)
@ -522,7 +523,7 @@ func cascadeGet(engine *Engine, t *testing.T) {
} }
} }
func find(engine *Engine, t *testing.T) { func find(engine *xorm.Engine, t *testing.T) {
users := make([]Userinfo, 0) users := make([]Userinfo, 0)
err := engine.Find(&users) err := engine.Find(&users)
@ -535,7 +536,7 @@ func find(engine *Engine, t *testing.T) {
} }
users2 := make([]Userinfo, 0) users2 := make([]Userinfo, 0)
userinfo := engine.tableMapper.Obj2Table("Userinfo") userinfo := engine.TableMapper.Obj2Table("Userinfo")
err = engine.Sql("select * from " + engine.Quote(userinfo)).Find(&users2) err = engine.Sql("select * from " + engine.Quote(userinfo)).Find(&users2)
if err != nil { if err != nil {
t.Error(err) t.Error(err)
@ -543,7 +544,7 @@ func find(engine *Engine, t *testing.T) {
} }
} }
func find2(engine *Engine, t *testing.T) { func find2(engine *xorm.Engine, t *testing.T) {
users := make([]*Userinfo, 0) users := make([]*Userinfo, 0)
err := engine.Find(&users) err := engine.Find(&users)
@ -556,7 +557,7 @@ func find2(engine *Engine, t *testing.T) {
} }
} }
func findMap(engine *Engine, t *testing.T) { func findMap(engine *xorm.Engine, t *testing.T) {
users := make(map[int64]Userinfo) users := make(map[int64]Userinfo)
err := engine.Find(&users) err := engine.Find(&users)
@ -569,7 +570,7 @@ func findMap(engine *Engine, t *testing.T) {
} }
} }
func findMap2(engine *Engine, t *testing.T) { func findMap2(engine *xorm.Engine, t *testing.T) {
users := make(map[int64]*Userinfo) users := make(map[int64]*Userinfo)
err := engine.Find(&users) err := engine.Find(&users)
@ -582,7 +583,7 @@ func findMap2(engine *Engine, t *testing.T) {
} }
} }
func count(engine *Engine, t *testing.T) { func count(engine *xorm.Engine, t *testing.T) {
user := Userinfo{Departname: "dev"} user := Userinfo{Departname: "dev"}
total, err := engine.Count(&user) total, err := engine.Count(&user)
if err != nil { if err != nil {
@ -592,7 +593,7 @@ func count(engine *Engine, t *testing.T) {
fmt.Printf("Total %d records!!!\n", total) fmt.Printf("Total %d records!!!\n", total)
} }
func where(engine *Engine, t *testing.T) { func where(engine *xorm.Engine, t *testing.T) {
users := make([]Userinfo, 0) users := make([]Userinfo, 0)
err := engine.Where("(id) > ?", 2).Find(&users) err := engine.Where("(id) > ?", 2).Find(&users)
if err != nil { if err != nil {
@ -609,7 +610,7 @@ func where(engine *Engine, t *testing.T) {
fmt.Println(users) fmt.Println(users)
} }
func in(engine *Engine, t *testing.T) { func in(engine *xorm.Engine, t *testing.T) {
users := make([]Userinfo, 0) users := make([]Userinfo, 0)
err := engine.In("(id)", 1, 2, 3).Find(&users) err := engine.In("(id)", 1, 2, 3).Find(&users)
if err != nil { if err != nil {
@ -626,8 +627,8 @@ func in(engine *Engine, t *testing.T) {
} }
fmt.Println(users) fmt.Println(users)
department := engine.columnMapper.Obj2Table("Departname") department := engine.ColumnMapper.Obj2Table("Departname")
dev := engine.columnMapper.Obj2Table("Dev") dev := engine.ColumnMapper.Obj2Table("Dev")
err = engine.In("(id)", 1).In("(id)", 2).In(department, dev).Find(&users) err = engine.In("(id)", 1).In("(id)", 2).In(department, dev).Find(&users)
if err != nil { if err != nil {
@ -687,7 +688,7 @@ func in(engine *Engine, t *testing.T) {
} }
} }
func limit(engine *Engine, t *testing.T) { func limit(engine *xorm.Engine, t *testing.T) {
users := make([]Userinfo, 0) users := make([]Userinfo, 0)
err := engine.Limit(2, 1).Find(&users) err := engine.Limit(2, 1).Find(&users)
if err != nil { if err != nil {
@ -697,7 +698,7 @@ func limit(engine *Engine, t *testing.T) {
fmt.Println(users) fmt.Println(users)
} }
func order(engine *Engine, t *testing.T) { func order(engine *xorm.Engine, t *testing.T) {
users := make([]Userinfo, 0) users := make([]Userinfo, 0)
err := engine.OrderBy("id desc").Find(&users) err := engine.OrderBy("id desc").Find(&users)
if err != nil { if err != nil {
@ -715,7 +716,7 @@ func order(engine *Engine, t *testing.T) {
fmt.Println(users2) fmt.Println(users2)
} }
func join(engine *Engine, t *testing.T) { func join(engine *xorm.Engine, t *testing.T) {
users := make([]Userinfo, 0) users := make([]Userinfo, 0)
err := engine.Join("LEFT", "userdetail", "userinfo.id=userdetail.id").Find(&users) err := engine.Join("LEFT", "userdetail", "userinfo.id=userdetail.id").Find(&users)
if err != nil { if err != nil {
@ -724,7 +725,7 @@ func join(engine *Engine, t *testing.T) {
} }
} }
func having(engine *Engine, t *testing.T) { func having(engine *xorm.Engine, t *testing.T) {
users := make([]Userinfo, 0) users := make([]Userinfo, 0)
err := engine.GroupBy("username").Having("username='xlw'").Find(&users) err := engine.GroupBy("username").Having("username='xlw'").Find(&users)
if err != nil { if err != nil {
@ -734,7 +735,7 @@ func having(engine *Engine, t *testing.T) {
fmt.Println(users) fmt.Println(users)
} }
func orderSameMapper(engine *Engine, t *testing.T) { func orderSameMapper(engine *xorm.Engine, t *testing.T) {
users := make([]Userinfo, 0) users := make([]Userinfo, 0)
err := engine.OrderBy("(id) desc").Find(&users) err := engine.OrderBy("(id) desc").Find(&users)
if err != nil { if err != nil {
@ -752,7 +753,7 @@ func orderSameMapper(engine *Engine, t *testing.T) {
fmt.Println(users2) fmt.Println(users2)
} }
func joinSameMapper(engine *Engine, t *testing.T) { func joinSameMapper(engine *xorm.Engine, t *testing.T) {
users := make([]Userinfo, 0) users := make([]Userinfo, 0)
err := engine.Join("LEFT", "`Userdetail`", "`Userinfo`.`(id)`=`Userdetail`.`(id)`").Find(&users) err := engine.Join("LEFT", "`Userdetail`", "`Userinfo`.`(id)`=`Userdetail`.`(id)`").Find(&users)
if err != nil { if err != nil {
@ -761,7 +762,7 @@ func joinSameMapper(engine *Engine, t *testing.T) {
} }
} }
func havingSameMapper(engine *Engine, t *testing.T) { func havingSameMapper(engine *xorm.Engine, t *testing.T) {
users := make([]Userinfo, 0) users := make([]Userinfo, 0)
err := engine.GroupBy("Username").Having(`"Username"='xlw'`).Find(&users) err := engine.GroupBy("Username").Having(`"Username"='xlw'`).Find(&users)
if err != nil { if err != nil {
@ -771,7 +772,7 @@ func havingSameMapper(engine *Engine, t *testing.T) {
fmt.Println(users) fmt.Println(users)
} }
func transaction(engine *Engine, t *testing.T) { func transaction(engine *xorm.Engine, t *testing.T) {
counter := func() { counter := func() {
total, err := engine.Count(&Userinfo{}) total, err := engine.Count(&Userinfo{})
if err != nil { if err != nil {
@ -823,7 +824,7 @@ func transaction(engine *Engine, t *testing.T) {
// panic(err) !nashtsai! should remove this // panic(err) !nashtsai! should remove this
} }
func combineTransaction(engine *Engine, t *testing.T) { func combineTransaction(engine *xorm.Engine, t *testing.T) {
counter := func() { counter := func() {
total, err := engine.Count(&Userinfo{}) total, err := engine.Count(&Userinfo{})
if err != nil { if err != nil {
@ -872,7 +873,7 @@ func combineTransaction(engine *Engine, t *testing.T) {
} }
} }
func combineTransactionSameMapper(engine *Engine, t *testing.T) { func combineTransactionSameMapper(engine *xorm.Engine, t *testing.T) {
counter := func() { counter := func() {
total, err := engine.Count(&Userinfo{}) total, err := engine.Count(&Userinfo{})
if err != nil { if err != nil {
@ -921,7 +922,7 @@ func combineTransactionSameMapper(engine *Engine, t *testing.T) {
} }
} }
func table(engine *Engine, t *testing.T) { func table(engine *xorm.Engine, t *testing.T) {
err := engine.DropTables("user_user") err := engine.DropTables("user_user")
if err != nil { if err != nil {
t.Error(err) t.Error(err)
@ -935,7 +936,7 @@ func table(engine *Engine, t *testing.T) {
} }
} }
func createMultiTables(engine *Engine, t *testing.T) { func createMultiTables(engine *xorm.Engine, t *testing.T) {
session := engine.NewSession() session := engine.NewSession()
defer session.Close() defer session.Close()
@ -969,7 +970,7 @@ func createMultiTables(engine *Engine, t *testing.T) {
} }
} }
func tableOp(engine *Engine, t *testing.T) { func tableOp(engine *xorm.Engine, t *testing.T) {
user := Userinfo{Username: "tablexiao", Departname: "dev", Alias: "lunny", Created: time.Now()} user := Userinfo{Username: "tablexiao", Departname: "dev", Alias: "lunny", Created: time.Now()}
tableName := fmt.Sprintf("user_%v", len(user.Username)) tableName := fmt.Sprintf("user_%v", len(user.Username))
cnt, err := engine.Table(tableName).Insert(&user) cnt, err := engine.Table(tableName).Insert(&user)
@ -1017,7 +1018,7 @@ func tableOp(engine *Engine, t *testing.T) {
} }
} }
func testCharst(engine *Engine, t *testing.T) { func testCharst(engine *xorm.Engine, t *testing.T) {
err := engine.DropTables("user_charset") err := engine.DropTables("user_charset")
if err != nil { if err != nil {
t.Error(err) t.Error(err)
@ -1031,7 +1032,7 @@ func testCharst(engine *Engine, t *testing.T) {
} }
} }
func testStoreEngine(engine *Engine, t *testing.T) { func testStoreEngine(engine *xorm.Engine, t *testing.T) {
err := engine.DropTables("user_store_engine") err := engine.DropTables("user_store_engine")
if err != nil { if err != nil {
t.Error(err) t.Error(err)
@ -1050,7 +1051,7 @@ type tempUser struct {
Username string Username string
} }
func testCols(engine *Engine, t *testing.T) { func testCols(engine *xorm.Engine, t *testing.T) {
users := []Userinfo{} users := []Userinfo{}
err := engine.Cols("id, username").Find(&users) err := engine.Cols("id, username").Find(&users)
if err != nil { if err != nil {
@ -1077,7 +1078,7 @@ func testCols(engine *Engine, t *testing.T) {
fmt.Println("===================", user, affected) fmt.Println("===================", user, affected)
} }
func testColsSameMapper(engine *Engine, t *testing.T) { func testColsSameMapper(engine *xorm.Engine, t *testing.T) {
users := []Userinfo{} users := []Userinfo{}
err := engine.Cols("(id), Username").Find(&users) err := engine.Cols("(id), Username").Find(&users)
if err != nil { if err != nil {
@ -1109,7 +1110,7 @@ type tempUser2 struct {
Departname string Departname string
} }
func testExtends(engine *Engine, t *testing.T) { func testExtends(engine *xorm.Engine, t *testing.T) {
err := engine.DropTables(&tempUser2{}) err := engine.DropTables(&tempUser2{})
if err != nil { if err != nil {
t.Error(err) t.Error(err)
@ -1186,7 +1187,7 @@ type allCols struct {
//BigSerial int64 `xorm:"BIGSERIAL"` //BigSerial int64 `xorm:"BIGSERIAL"`
} }
func testColTypes(engine *Engine, t *testing.T) { func testColTypes(engine *xorm.Engine, t *testing.T) {
err := engine.DropTables(&allCols{}) err := engine.DropTables(&allCols{})
if err != nil { if err != nil {
t.Error(err) t.Error(err)
@ -1319,7 +1320,7 @@ type MyStruct struct {
MSS map[string]string MSS map[string]string
} }
func testCustomType(engine *Engine, t *testing.T) { func testCustomType(engine *xorm.Engine, t *testing.T) {
err := engine.DropTables(&MyStruct{}) err := engine.DropTables(&MyStruct{})
if err != nil { if err != nil {
t.Error(err) t.Error(err)
@ -1405,7 +1406,7 @@ type UserCU struct {
Updated time.Time `xorm:"updated"` Updated time.Time `xorm:"updated"`
} }
func testCreatedAndUpdated(engine *Engine, t *testing.T) { func testCreatedAndUpdated(engine *xorm.Engine, t *testing.T) {
u := new(UserCU) u := new(UserCU)
err := engine.DropTables(u) err := engine.DropTables(u)
if err != nil { if err != nil {
@ -1472,7 +1473,7 @@ type IndexOrUnique struct {
UniGroup2 int `xorm:"unique(lll)"` UniGroup2 int `xorm:"unique(lll)"`
} }
func testIndexAndUnique(engine *Engine, t *testing.T) { func testIndexAndUnique(engine *xorm.Engine, t *testing.T) {
err := engine.CreateTables(&IndexOrUnique{}) err := engine.CreateTables(&IndexOrUnique{})
if err != nil { if err != nil {
t.Error(err) t.Error(err)
@ -1534,7 +1535,7 @@ type StringPK struct {
Name string Name string
} }
func testIntId(engine *Engine, t *testing.T) { func testIntId(engine *xorm.Engine, t *testing.T) {
err := engine.DropTables(&IntId{}) err := engine.DropTables(&IntId{})
if err != nil { if err != nil {
t.Error(err) t.Error(err)
@ -1594,7 +1595,7 @@ func testIntId(engine *Engine, t *testing.T) {
} }
} }
func testInt32Id(engine *Engine, t *testing.T) { func testInt32Id(engine *xorm.Engine, t *testing.T) {
err := engine.DropTables(&Int32Id{}) err := engine.DropTables(&Int32Id{})
if err != nil { if err != nil {
t.Error(err) t.Error(err)
@ -1655,7 +1656,7 @@ func testInt32Id(engine *Engine, t *testing.T) {
} }
} }
func testUintId(engine *Engine, t *testing.T) { func testUintId(engine *xorm.Engine, t *testing.T) {
err := engine.DropTables(&UintId{}) err := engine.DropTables(&UintId{})
if err != nil { if err != nil {
t.Error(err) t.Error(err)
@ -1715,7 +1716,7 @@ func testUintId(engine *Engine, t *testing.T) {
} }
} }
func testUint32Id(engine *Engine, t *testing.T) { func testUint32Id(engine *xorm.Engine, t *testing.T) {
err := engine.DropTables(&Uint32Id{}) err := engine.DropTables(&Uint32Id{})
if err != nil { if err != nil {
t.Error(err) t.Error(err)
@ -1776,7 +1777,7 @@ func testUint32Id(engine *Engine, t *testing.T) {
} }
} }
func testUint64Id(engine *Engine, t *testing.T) { func testUint64Id(engine *xorm.Engine, t *testing.T) {
err := engine.DropTables(&Uint64Id{}) err := engine.DropTables(&Uint64Id{})
if err != nil { if err != nil {
t.Error(err) t.Error(err)
@ -1837,7 +1838,7 @@ func testUint64Id(engine *Engine, t *testing.T) {
} }
} }
func testStringPK(engine *Engine, t *testing.T) { func testStringPK(engine *xorm.Engine, t *testing.T) {
err := engine.DropTables(&StringPK{}) err := engine.DropTables(&StringPK{})
if err != nil { if err != nil {
t.Error(err) t.Error(err)
@ -1898,7 +1899,7 @@ func testStringPK(engine *Engine, t *testing.T) {
} }
} }
func testMetaInfo(engine *Engine, t *testing.T) { func testMetaInfo(engine *xorm.Engine, t *testing.T) {
tables, err := engine.DBMetas() tables, err := engine.DBMetas()
if err != nil { if err != nil {
t.Error(err) t.Error(err)
@ -1907,9 +1908,10 @@ func testMetaInfo(engine *Engine, t *testing.T) {
for _, table := range tables { for _, table := range tables {
fmt.Println(table.Name) fmt.Println(table.Name)
for _, col := range table.Columns() { //for _, col := range table.Columns() {
fmt.Println(col.String(engine.dialect)) //TODO: engine.dialect show exported
} //fmt.Println(col.String(engine.dia))
//}
for _, index := range table.Indexes { for _, index := range table.Indexes {
fmt.Println(index.Name, index.Type, strings.Join(index.Cols, ",")) fmt.Println(index.Name, index.Type, strings.Join(index.Cols, ","))
@ -1917,7 +1919,7 @@ func testMetaInfo(engine *Engine, t *testing.T) {
} }
} }
func testIterate(engine *Engine, t *testing.T) { func testIterate(engine *xorm.Engine, t *testing.T) {
err := engine.Omit("is_man").Iterate(new(Userinfo), func(idx int, bean interface{}) error { err := engine.Omit("is_man").Iterate(new(Userinfo), func(idx int, bean interface{}) error {
user := bean.(*Userinfo) user := bean.(*Userinfo)
fmt.Println(idx, "--", user) fmt.Println(idx, "--", user)
@ -1930,7 +1932,7 @@ func testIterate(engine *Engine, t *testing.T) {
} }
} }
func testRows(engine *Engine, t *testing.T) { func testRows(engine *xorm.Engine, t *testing.T) {
rows, err := engine.Omit("is_man").Rows(new(Userinfo)) rows, err := engine.Omit("is_man").Rows(new(Userinfo))
if err != nil { if err != nil {
t.Error(err) t.Error(err)
@ -1956,7 +1958,7 @@ type StrangeName struct {
Name string Name string
} }
func testStrangeName(engine *Engine, t *testing.T) { func testStrangeName(engine *xorm.Engine, t *testing.T) {
err := engine.DropTables(new(StrangeName)) err := engine.DropTables(new(StrangeName))
if err != nil { if err != nil {
t.Error(err) t.Error(err)
@ -1985,7 +1987,7 @@ type VersionS struct {
Ver int `xorm:"version"` Ver int `xorm:"version"`
} }
func testVersion(engine *Engine, t *testing.T) { func testVersion(engine *xorm.Engine, t *testing.T) {
err := engine.DropTables(new(VersionS)) err := engine.DropTables(new(VersionS))
if err != nil { if err != nil {
t.Error(err) t.Error(err)
@ -2058,7 +2060,7 @@ func testVersion(engine *Engine, t *testing.T) {
}*/ }*/
} }
func testDistinct(engine *Engine, t *testing.T) { func testDistinct(engine *xorm.Engine, t *testing.T) {
users := make([]Userinfo, 0) users := make([]Userinfo, 0)
err := engine.Distinct("departname").Find(&users) err := engine.Distinct("departname").Find(&users)
if err != nil { if err != nil {
@ -2089,7 +2091,7 @@ func testDistinct(engine *Engine, t *testing.T) {
fmt.Println(users2) fmt.Println(users2)
} }
func testUseBool(engine *Engine, t *testing.T) { func testUseBool(engine *xorm.Engine, t *testing.T) {
cnt1, err := engine.Count(&Userinfo{}) cnt1, err := engine.Count(&Userinfo{})
if err != nil { if err != nil {
t.Error(err) t.Error(err)
@ -2129,7 +2131,7 @@ func testUseBool(engine *Engine, t *testing.T) {
} }
} }
func testBool(engine *Engine, t *testing.T) { func testBool(engine *xorm.Engine, t *testing.T) {
_, err := engine.UseBool().Update(&Userinfo{IsMan: true}) _, err := engine.UseBool().Update(&Userinfo{IsMan: true})
if err != nil { if err != nil {
t.Error(err) t.Error(err)
@ -2175,7 +2177,7 @@ type TTime struct {
Tz time.Time `xorm:"timestampz"` Tz time.Time `xorm:"timestampz"`
} }
func testTime(engine *Engine, t *testing.T) { func testTime(engine *xorm.Engine, t *testing.T) {
err := engine.Sync(&TTime{}) err := engine.Sync(&TTime{})
if err != nil { if err != nil {
t.Error(err) t.Error(err)
@ -2217,14 +2219,14 @@ func testTime(engine *Engine, t *testing.T) {
fmt.Println("=======\n", tt4s, "=======\n") fmt.Println("=======\n", tt4s, "=======\n")
} }
func testPrefixTableName(engine *Engine, t *testing.T) { func testPrefixTableName(engine *xorm.Engine, t *testing.T) {
tempEngine, err := NewEngine(engine.DriverName, engine.DataSourceName) tempEngine, err := xorm.NewEngine(engine.DriverName, engine.DataSourceName)
if err != nil { if err != nil {
t.Error(err) t.Error(err)
panic(err) panic(err)
} }
tempEngine.ShowSQL = true tempEngine.ShowSQL = true
mapper := NewPrefixMapper(SnakeMapper{}, "xlw_") mapper := xorm.NewPrefixMapper(xorm.SnakeMapper{}, "xlw_")
//tempEngine.SetMapper(mapper) //tempEngine.SetMapper(mapper)
tempEngine.SetTableMapper(mapper) tempEngine.SetTableMapper(mapper)
exist, err := tempEngine.IsTableExist(&Userinfo{}) exist, err := tempEngine.IsTableExist(&Userinfo{})
@ -2255,7 +2257,7 @@ type CreatedUpdated struct {
Updated time.Time `xorm:"updated"` Updated time.Time `xorm:"updated"`
} }
func testCreatedUpdated(engine *Engine, t *testing.T) { func testCreatedUpdated(engine *xorm.Engine, t *testing.T) {
err := engine.Sync(&CreatedUpdated{}) err := engine.Sync(&CreatedUpdated{})
if err != nil { if err != nil {
t.Error(err) t.Error(err)
@ -2330,7 +2332,7 @@ func (p *ProcessorsStruct) AfterDelete() {
p.AfterDeletedFlag = 1 p.AfterDeletedFlag = 1
} }
func testProcessors(engine *Engine, t *testing.T) { func testProcessors(engine *xorm.Engine, t *testing.T) {
// tempEngine, err := NewEngine(engine.DriverName, engine.DataSourceName) // tempEngine, err := NewEngine(engine.DriverName, engine.DataSourceName)
// if err != nil { // if err != nil {
// t.Error(err) // t.Error(err)
@ -2556,7 +2558,7 @@ func testProcessors(engine *Engine, t *testing.T) {
// -- // --
} }
func testProcessorsTx(engine *Engine, t *testing.T) { func testProcessorsTx(engine *xorm.Engine, t *testing.T) {
// tempEngine, err := NewEngine(engine.DriverName, engine.DataSourceName) // tempEngine, err := NewEngine(engine.DriverName, engine.DataSourceName)
// if err != nil { // if err != nil {
// t.Error(err) // t.Error(err)
@ -3062,7 +3064,7 @@ type NullData3 struct {
StringPtr *string StringPtr *string
} }
func testPointerData(engine *Engine, t *testing.T) { func testPointerData(engine *xorm.Engine, t *testing.T) {
err := engine.DropTables(&NullData{}) err := engine.DropTables(&NullData{})
if err != nil { if err != nil {
@ -3232,7 +3234,7 @@ func testPointerData(engine *Engine, t *testing.T) {
// using instance type should just work too // using instance type should just work too
nullData2Get := NullData2{} nullData2Get := NullData2{}
tableName := engine.tableMapper.Obj2Table("NullData") tableName := engine.TableMapper.Obj2Table("NullData")
has, err = engine.Table(tableName).Id(nullData.Id).Get(&nullData2Get) has, err = engine.Table(tableName).Id(nullData.Id).Get(&nullData2Get)
if err != nil { if err != nil {
@ -3324,7 +3326,7 @@ func testPointerData(engine *Engine, t *testing.T) {
// -- // --
} }
func testNullValue(engine *Engine, t *testing.T) { func testNullValue(engine *xorm.Engine, t *testing.T) {
err := engine.DropTables(&NullData{}) err := engine.DropTables(&NullData{})
if err != nil { if err != nil {
@ -3599,7 +3601,7 @@ func testNullValue(engine *Engine, t *testing.T) {
// update to null values // update to null values
nullDataUpdate = NullData{} nullDataUpdate = NullData{}
string_ptr := engine.columnMapper.Obj2Table("StringPtr") string_ptr := engine.ColumnMapper.Obj2Table("StringPtr")
cnt, err = engine.Id(nullData.Id).Cols(string_ptr).Update(&nullDataUpdate) cnt, err = engine.Id(nullData.Id).Cols(string_ptr).Update(&nullDataUpdate)
if err != nil { if err != nil {
@ -3709,7 +3711,7 @@ type CompositeKey struct {
UpdateStr string UpdateStr string
} }
func testCompositeKey(engine *Engine, t *testing.T) { func testCompositeKey(engine *xorm.Engine, t *testing.T) {
err := engine.DropTables(&CompositeKey{}) err := engine.DropTables(&CompositeKey{})
if err != nil { if err != nil {
@ -3736,7 +3738,7 @@ func testCompositeKey(engine *Engine, t *testing.T) {
} }
var compositeKeyVal CompositeKey var compositeKeyVal CompositeKey
has, err := engine.Id(PK{11, 22}).Get(&compositeKeyVal) has, err := engine.Id(xorm.PK{11, 22}).Get(&compositeKeyVal)
if err != nil { if err != nil {
t.Error(err) t.Error(err)
} else if !has { } else if !has {
@ -3744,7 +3746,7 @@ func testCompositeKey(engine *Engine, t *testing.T) {
} }
// test passing PK ptr, this test seem failed withCache // test passing PK ptr, this test seem failed withCache
has, err = engine.Id(&PK{11, 22}).Get(&compositeKeyVal) has, err = engine.Id(&xorm.PK{11, 22}).Get(&compositeKeyVal)
if err != nil { if err != nil {
t.Error(err) t.Error(err)
} else if !has { } else if !has {
@ -3752,14 +3754,14 @@ func testCompositeKey(engine *Engine, t *testing.T) {
} }
compositeKeyVal = CompositeKey{UpdateStr: "test1"} compositeKeyVal = CompositeKey{UpdateStr: "test1"}
cnt, err = engine.Id(PK{11, 22}).Update(&compositeKeyVal) cnt, err = engine.Id(xorm.PK{11, 22}).Update(&compositeKeyVal)
if err != nil { if err != nil {
t.Error(err) t.Error(err)
} else if cnt != 1 { } else if cnt != 1 {
t.Error(errors.New("can't update CompositeKey{11, 22}")) t.Error(errors.New("can't update CompositeKey{11, 22}"))
} }
cnt, err = engine.Id(PK{11, 22}).Delete(&CompositeKey{}) cnt, err = engine.Id(xorm.PK{11, 22}).Delete(&CompositeKey{})
if err != nil { if err != nil {
t.Error(err) t.Error(err)
} else if cnt != 1 { } else if cnt != 1 {
@ -3774,7 +3776,7 @@ type User struct {
Score int32 `xorm:"integer"` Score int32 `xorm:"integer"`
} }
func testCompositeKey2(engine *Engine, t *testing.T) { func testCompositeKey2(engine *xorm.Engine, t *testing.T) {
err := engine.DropTables(&User{}) err := engine.DropTables(&User{})
if err != nil { if err != nil {
@ -3801,7 +3803,7 @@ func testCompositeKey2(engine *Engine, t *testing.T) {
} }
var user User var user User
has, err := engine.Id(PK{"11", 22}).Get(&user) has, err := engine.Id(xorm.PK{"11", 22}).Get(&user)
if err != nil { if err != nil {
t.Error(err) t.Error(err)
} else if !has { } else if !has {
@ -3809,7 +3811,7 @@ func testCompositeKey2(engine *Engine, t *testing.T) {
} }
// test passing PK ptr, this test seem failed withCache // test passing PK ptr, this test seem failed withCache
has, err = engine.Id(&PK{"11", 22}).Get(&user) has, err = engine.Id(&xorm.PK{"11", 22}).Get(&user)
if err != nil { if err != nil {
t.Error(err) t.Error(err)
} else if !has { } else if !has {
@ -3817,14 +3819,14 @@ func testCompositeKey2(engine *Engine, t *testing.T) {
} }
user = User{NickName: "test1"} user = User{NickName: "test1"}
cnt, err = engine.Id(PK{"11", 22}).Update(&user) cnt, err = engine.Id(xorm.PK{"11", 22}).Update(&user)
if err != nil { if err != nil {
t.Error(err) t.Error(err)
} else if cnt != 1 { } else if cnt != 1 {
t.Error(errors.New("can't update User{11, 22}")) t.Error(errors.New("can't update User{11, 22}"))
} }
cnt, err = engine.Id(PK{"11", 22}).Delete(&User{}) cnt, err = engine.Id(xorm.PK{"11", 22}).Delete(&User{})
if err != nil { if err != nil {
t.Error(err) t.Error(err)
} else if cnt != 1 { } else if cnt != 1 {
@ -3832,7 +3834,7 @@ func testCompositeKey2(engine *Engine, t *testing.T) {
} }
} }
func testAll(engine *Engine, t *testing.T) { func testAll(engine *xorm.Engine, t *testing.T) {
fmt.Println("-------------- directCreateTable --------------") fmt.Println("-------------- directCreateTable --------------")
directCreateTable(engine, t) directCreateTable(engine, t)
fmt.Println("-------------- insert --------------") fmt.Println("-------------- insert --------------")
@ -3867,7 +3869,7 @@ func testAll(engine *Engine, t *testing.T) {
limit(engine, t) limit(engine, t)
} }
func testAll2(engine *Engine, t *testing.T) { func testAll2(engine *xorm.Engine, t *testing.T) {
fmt.Println("-------------- combineTransaction --------------") fmt.Println("-------------- combineTransaction --------------")
combineTransaction(engine, t) combineTransaction(engine, t)
fmt.Println("-------------- table --------------") fmt.Println("-------------- table --------------")
@ -3931,7 +3933,7 @@ func testAll2(engine *Engine, t *testing.T) {
} }
// !nash! the 3rd set of the test is intended for non-cache enabled engine // !nash! the 3rd set of the test is intended for non-cache enabled engine
func testAll3(engine *Engine, t *testing.T) { func testAll3(engine *xorm.Engine, t *testing.T) {
fmt.Println("-------------- processors TX --------------") fmt.Println("-------------- processors TX --------------")
testProcessorsTx(engine, t) testProcessorsTx(engine, t)
fmt.Println("-------------- insert pointer data --------------") fmt.Println("-------------- insert pointer data --------------")
@ -3946,7 +3948,7 @@ func testAll3(engine *Engine, t *testing.T) {
testStringPK(engine, t) testStringPK(engine, t)
} }
func testAllSnakeMapper(engine *Engine, t *testing.T) { func testAllSnakeMapper(engine *xorm.Engine, t *testing.T) {
fmt.Println("-------------- query --------------") fmt.Println("-------------- query --------------")
testQuery(engine, t) testQuery(engine, t)
fmt.Println("-------------- exec --------------") fmt.Println("-------------- exec --------------")
@ -3961,7 +3963,7 @@ func testAllSnakeMapper(engine *Engine, t *testing.T) {
having(engine, t) having(engine, t)
} }
func testAllSameMapper(engine *Engine, t *testing.T) { func testAllSameMapper(engine *xorm.Engine, t *testing.T) {
fmt.Println("-------------- query --------------") fmt.Println("-------------- query --------------")
testQuerySameMapper(engine, t) testQuerySameMapper(engine, t)
fmt.Println("-------------- exec --------------") fmt.Println("-------------- exec --------------")

0
benchmark.bat → tests/benchmark.bat
View File

0
benchmark.sh → tests/benchmark.sh
View File

8
benchmark_base_test.go → tests/benchmark_base_test.go
View File

@ -3,6 +3,8 @@ package xorm
import ( import (
"database/sql" "database/sql"
"testing" "testing"
"github.com/lunny/xorm"
) )
type BigStruct struct { type BigStruct struct {
@ -77,7 +79,7 @@ func doBenchDriver(newdriver func() (*sql.DB, error), createTableSql,
} }
} }
func doBenchInsert(engine *Engine, b *testing.B) { func doBenchInsert(engine *xorm.Engine, b *testing.B) {
b.StopTimer() b.StopTimer()
bs := &BigStruct{0, "fafdasf", "fadfa", "afadfsaf", "fadfafdsafd", "fadfafdsaf"} bs := &BigStruct{0, "fafdasf", "fadfa", "afadfsaf", "fadfafdsafd", "fadfafdsaf"}
err := engine.CreateTables(bs) err := engine.CreateTables(bs)
@ -103,7 +105,7 @@ func doBenchInsert(engine *Engine, b *testing.B) {
} }
} }
func doBenchFind(engine *Engine, b *testing.B) { func doBenchFind(engine *xorm.Engine, b *testing.B) {
b.StopTimer() b.StopTimer()
bs := &BigStruct{0, "fafdasf", "fadfa", "afadfsaf", "fadfafdsafd", "fadfafdsaf"} bs := &BigStruct{0, "fafdasf", "fadfa", "afadfsaf", "fadfafdsafd", "fadfafdsaf"}
err := engine.CreateTables(bs) err := engine.CreateTables(bs)
@ -138,7 +140,7 @@ func doBenchFind(engine *Engine, b *testing.B) {
} }
} }
func doBenchFindPtr(engine *Engine, b *testing.B) { func doBenchFindPtr(engine *xorm.Engine, b *testing.B) {
b.StopTimer() b.StopTimer()
bs := &BigStruct{0, "fafdasf", "fadfa", "afadfsaf", "fadfafdsafd", "fadfafdsaf"} bs := &BigStruct{0, "fafdasf", "fadfa", "afadfsaf", "fadfafdsafd", "fadfafdsaf"}
err := engine.CreateTables(bs) err := engine.CreateTables(bs)

13
mssql_test.go → tests/mssql_test.go
View File

@ -8,12 +8,13 @@ import (
"testing" "testing"
_ "github.com/lunny/godbc" _ "github.com/lunny/godbc"
"github.com/lunny/xorm"
) )
const mssqlConnStr = "driver={SQL Server};Server=192.168.20.135;Database=xorm_test; uid=sa; pwd=1234;" const mssqlConnStr = "driver={SQL Server};Server=192.168.20.135;Database=xorm_test; uid=sa; pwd=1234;"
func newMssqlEngine() (*Engine, error) { func newMssqlEngine() (*xorm.Engine, error) {
return NewEngine("odbc", mssqlConnStr) return xorm.NewEngine("odbc", mssqlConnStr)
} }
func TestMssql(t *testing.T) { func TestMssql(t *testing.T) {
@ -39,7 +40,7 @@ func TestMssqlWithCache(t *testing.T) {
t.Error(err) t.Error(err)
return return
} }
engine.SetDefaultCacher(NewLRUCacher(NewMemoryStore(), 1000)) engine.SetDefaultCacher(xorm.NewLRUCacher(xorm.NewMemoryStore(), 1000))
engine.ShowSQL = showTestSql engine.ShowSQL = showTestSql
engine.ShowErr = showTestSql engine.ShowErr = showTestSql
engine.ShowWarn = showTestSql engine.ShowWarn = showTestSql
@ -112,7 +113,7 @@ func BenchmarkMssqlCacheInsert(t *testing.B) {
t.Error(err) t.Error(err)
return return
} }
engine.SetDefaultCacher(NewLRUCacher(NewMemoryStore(), 1000)) engine.SetDefaultCacher(xorm.NewLRUCacher(xorm.NewMemoryStore(), 1000))
doBenchInsert(engine, t) doBenchInsert(engine, t)
} }
@ -124,7 +125,7 @@ func BenchmarkMssqlCacheFind(t *testing.B) {
t.Error(err) t.Error(err)
return return
} }
engine.SetDefaultCacher(NewLRUCacher(NewMemoryStore(), 1000)) engine.SetDefaultCacher(xorm.NewLRUCacher(xorm.NewMemoryStore(), 1000))
doBenchFind(engine, t) doBenchFind(engine, t)
} }
@ -136,7 +137,7 @@ func BenchmarkMssqlCacheFindPtr(t *testing.B) {
t.Error(err) t.Error(err)
return return
} }
engine.SetDefaultCacher(NewLRUCacher(NewMemoryStore(), 1000)) engine.SetDefaultCacher(xorm.NewLRUCacher(xorm.NewMemoryStore(), 1000))
doBenchFindPtr(engine, t) doBenchFindPtr(engine, t)
} }

21
mymysql_test.go → tests/mymysql_test.go
View File

@ -4,6 +4,7 @@ import (
"database/sql" "database/sql"
"testing" "testing"
"github.com/lunny/xorm"
_ "github.com/ziutek/mymysql/godrv" _ "github.com/ziutek/mymysql/godrv"
) )
@ -20,7 +21,7 @@ func TestMyMysql(t *testing.T) {
t.Error(err) t.Error(err)
return return
} }
engine, err := NewEngine("mymysql", "xorm_test/root/") engine, err := xorm.NewEngine("mymysql", "xorm_test/root/")
defer engine.Close() defer engine.Close()
if err != nil { if err != nil {
t.Error(err) t.Error(err)
@ -42,13 +43,13 @@ func TestMyMysqlWithCache(t *testing.T) {
t.Error(err) t.Error(err)
return return
} }
engine, err := NewEngine("mymysql", "xorm_test2/root/") engine, err := xorm.NewEngine("mymysql", "xorm_test2/root/")
defer engine.Close() defer engine.Close()
if err != nil { if err != nil {
t.Error(err) t.Error(err)
return return
} }
engine.SetDefaultCacher(NewLRUCacher(NewMemoryStore(), 1000)) engine.SetDefaultCacher(xorm.NewLRUCacher(xorm.NewMemoryStore(), 1000))
engine.ShowSQL = showTestSql engine.ShowSQL = showTestSql
engine.ShowErr = showTestSql engine.ShowErr = showTestSql
engine.ShowWarn = showTestSql engine.ShowWarn = showTestSql
@ -58,8 +59,8 @@ func TestMyMysqlWithCache(t *testing.T) {
testAll2(engine, t) testAll2(engine, t)
} }
func newMyMysqlEngine() (*Engine, error) { func newMyMysqlEngine() (*xorm.Engine, error) {
return NewEngine("mymysql", "xorm_test2/root/") return xorm.NewEngine("mymysql", "xorm_test2/root/")
} }
func newMyMysqlDriverDB() (*sql.DB, error) { func newMyMysqlDriverDB() (*sql.DB, error) {
@ -77,7 +78,7 @@ func BenchmarkMyMysqlDriverFind(t *testing.B) {
} }
func mymysqlDdlImport() error { func mymysqlDdlImport() error {
engine, err := NewEngine("mymysql", "/root/") engine, err := xorm.NewEngine("mymysql", "/root/")
if err != nil { if err != nil {
return err return err
} }
@ -86,7 +87,7 @@ func mymysqlDdlImport() error {
engine.ShowWarn = showTestSql engine.ShowWarn = showTestSql
engine.ShowDebug = showTestSql engine.ShowDebug = showTestSql
sqlResults, _ := engine.Import("tests/mysql_ddl.sql") sqlResults, _ := engine.Import("testdata/mysql_ddl.sql")
engine.LogDebug("sql results: %v", sqlResults) engine.LogDebug("sql results: %v", sqlResults)
engine.Close() engine.Close()
return nil return nil
@ -135,7 +136,7 @@ func BenchmarkMyMysqlCacheInsert(t *testing.B) {
} }
defer engine.Close() defer engine.Close()
engine.SetDefaultCacher(NewLRUCacher(NewMemoryStore(), 1000)) engine.SetDefaultCacher(xorm.NewLRUCacher(xorm.NewMemoryStore(), 1000))
doBenchInsert(engine, t) doBenchInsert(engine, t)
} }
@ -148,7 +149,7 @@ func BenchmarkMyMysqlCacheFind(t *testing.B) {
} }
defer engine.Close() defer engine.Close()
engine.SetDefaultCacher(NewLRUCacher(NewMemoryStore(), 1000)) engine.SetDefaultCacher(xorm.NewLRUCacher(xorm.NewMemoryStore(), 1000))
doBenchFind(engine, t) doBenchFind(engine, t)
} }
@ -161,7 +162,7 @@ func BenchmarkMyMysqlCacheFindPtr(t *testing.B) {
} }
defer engine.Close() defer engine.Close()
engine.SetDefaultCacher(NewLRUCacher(NewMemoryStore(), 1000)) engine.SetDefaultCacher(xorm.NewLRUCacher(xorm.NewMemoryStore(), 1000))
doBenchFindPtr(engine, t) doBenchFindPtr(engine, t)
} }

31
mysql_test.go → tests/mysql_test.go
View File

@ -5,6 +5,7 @@ import (
"testing" "testing"
_ "github.com/go-sql-driver/mysql" _ "github.com/go-sql-driver/mysql"
"github.com/lunny/xorm"
) )
/* /*
@ -19,7 +20,7 @@ func TestMysql(t *testing.T) {
return return
} }
engine, err := NewEngine("mysql", "root:@/xorm_test?charset=utf8") engine, err := xorm.NewEngine("mysql", "root:@/xorm_test?charset=utf8")
defer engine.Close() defer engine.Close()
if err != nil { if err != nil {
t.Error(err) t.Error(err)
@ -43,7 +44,7 @@ func TestMysqlSameMapper(t *testing.T) {
return return
} }
engine, err := NewEngine("mysql", "root:@/xorm_test1?charset=utf8") engine, err := xorm.NewEngine("mysql", "root:@/xorm_test1?charset=utf8")
defer engine.Close() defer engine.Close()
if err != nil { if err != nil {
t.Error(err) t.Error(err)
@ -53,7 +54,7 @@ func TestMysqlSameMapper(t *testing.T) {
engine.ShowErr = showTestSql engine.ShowErr = showTestSql
engine.ShowWarn = showTestSql engine.ShowWarn = showTestSql
engine.ShowDebug = showTestSql engine.ShowDebug = showTestSql
engine.SetMapper(SameMapper{}) engine.SetMapper(xorm.SameMapper{})
testAll(engine, t) testAll(engine, t)
testAllSameMapper(engine, t) testAllSameMapper(engine, t)
@ -68,13 +69,13 @@ func TestMysqlWithCache(t *testing.T) {
return return
} }
engine, err := NewEngine("mysql", "root:@/xorm_test2?charset=utf8") engine, err := xorm.NewEngine("mysql", "root:@/xorm_test2?charset=utf8")
defer engine.Close() defer engine.Close()
if err != nil { if err != nil {
t.Error(err) t.Error(err)
return return
} }
engine.SetDefaultCacher(NewLRUCacher(NewMemoryStore(), 1000)) engine.SetDefaultCacher(xorm.NewLRUCacher(xorm.NewMemoryStore(), 1000))
engine.ShowSQL = showTestSql engine.ShowSQL = showTestSql
engine.ShowErr = showTestSql engine.ShowErr = showTestSql
engine.ShowWarn = showTestSql engine.ShowWarn = showTestSql
@ -92,14 +93,14 @@ func TestMysqlWithCacheSameMapper(t *testing.T) {
return return
} }
engine, err := NewEngine("mysql", "root:@/xorm_test3?charset=utf8") engine, err := xorm.NewEngine("mysql", "root:@/xorm_test3?charset=utf8")
defer engine.Close() defer engine.Close()
if err != nil { if err != nil {
t.Error(err) t.Error(err)
return return
} }
engine.SetMapper(SameMapper{}) engine.SetMapper(xorm.SameMapper{})
engine.SetDefaultCacher(NewLRUCacher(NewMemoryStore(), 1000)) engine.SetDefaultCacher(xorm.NewLRUCacher(xorm.NewMemoryStore(), 1000))
engine.ShowSQL = showTestSql engine.ShowSQL = showTestSql
engine.ShowErr = showTestSql engine.ShowErr = showTestSql
engine.ShowWarn = showTestSql engine.ShowWarn = showTestSql
@ -110,12 +111,12 @@ func TestMysqlWithCacheSameMapper(t *testing.T) {
testAll2(engine, t) testAll2(engine, t)
} }
func newMysqlEngine() (*Engine, error) { func newMysqlEngine() (*xorm.Engine, error) {
return NewEngine("mysql", "root:@/xorm_test?charset=utf8") return xorm.NewEngine("mysql", "root:@/xorm_test?charset=utf8")
} }
func mysqlDdlImport() error { func mysqlDdlImport() error {
engine, err := NewEngine("mysql", "root:@/?charset=utf8") engine, err := xorm.NewEngine("mysql", "root:@/?charset=utf8")
if err != nil { if err != nil {
return err return err
} }
@ -124,7 +125,7 @@ func mysqlDdlImport() error {
engine.ShowWarn = showTestSql engine.ShowWarn = showTestSql
engine.ShowDebug = showTestSql engine.ShowDebug = showTestSql
sqlResults, _ := engine.Import("tests/mysql_ddl.sql") sqlResults, _ := engine.Import("testdata/mysql_ddl.sql")
engine.LogDebug("sql results: %v", sqlResults) engine.LogDebug("sql results: %v", sqlResults)
engine.Close() engine.Close()
return nil return nil
@ -189,7 +190,7 @@ func BenchmarkMysqlCacheInsert(t *testing.B) {
t.Error(err) t.Error(err)
return return
} }
engine.SetDefaultCacher(NewLRUCacher(NewMemoryStore(), 1000)) engine.SetDefaultCacher(xorm.NewLRUCacher(xorm.NewMemoryStore(), 1000))
doBenchInsert(engine, t) doBenchInsert(engine, t)
} }
@ -201,7 +202,7 @@ func BenchmarkMysqlCacheFind(t *testing.B) {
t.Error(err) t.Error(err)
return return
} }
engine.SetDefaultCacher(NewLRUCacher(NewMemoryStore(), 1000)) engine.SetDefaultCacher(xorm.NewLRUCacher(xorm.NewMemoryStore(), 1000))
doBenchFind(engine, t) doBenchFind(engine, t)
} }
@ -213,7 +214,7 @@ func BenchmarkMysqlCacheFindPtr(t *testing.B) {
t.Error(err) t.Error(err)
return return
} }
engine.SetDefaultCacher(NewLRUCacher(NewMemoryStore(), 1000)) engine.SetDefaultCacher(xorm.NewLRUCacher(xorm.NewMemoryStore(), 1000))
doBenchFindPtr(engine, t) doBenchFindPtr(engine, t)
} }

19
postgres_test.go → tests/postgres_test.go
View File

@ -5,14 +5,15 @@ import (
"testing" "testing"
_ "github.com/lib/pq" _ "github.com/lib/pq"
"github.com/lunny/xorm"
) )
//var connStr string = "dbname=xorm_test user=lunny password=1234 sslmode=disable" //var connStr string = "dbname=xorm_test user=lunny password=1234 sslmode=disable"
var connStr string = "dbname=xorm_test sslmode=disable" var connStr string = "dbname=xorm_test sslmode=disable"
func newPostgresEngine() (*Engine, error) { func newPostgresEngine() (*xorm.Engine, error) {
orm, err := NewEngine("postgres", connStr) orm, err := xorm.NewEngine("postgres", connStr)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -58,7 +59,7 @@ func TestPostgresWithCache(t *testing.T) {
t.Error(err) t.Error(err)
return return
} }
engine.SetDefaultCacher(NewLRUCacher(NewMemoryStore(), 1000)) engine.SetDefaultCacher(xorm.NewLRUCacher(xorm.NewMemoryStore(), 1000))
defer engine.Close() defer engine.Close()
engine.ShowSQL = showTestSql engine.ShowSQL = showTestSql
engine.ShowErr = showTestSql engine.ShowErr = showTestSql
@ -77,7 +78,7 @@ func TestPostgresSameMapper(t *testing.T) {
return return
} }
defer engine.Close() defer engine.Close()
engine.SetMapper(SameMapper{}) engine.SetMapper(xorm.SameMapper{})
engine.ShowSQL = showTestSql engine.ShowSQL = showTestSql
engine.ShowErr = showTestSql engine.ShowErr = showTestSql
engine.ShowWarn = showTestSql engine.ShowWarn = showTestSql
@ -95,9 +96,9 @@ func TestPostgresWithCacheSameMapper(t *testing.T) {
t.Error(err) t.Error(err)
return return
} }
engine.SetDefaultCacher(NewLRUCacher(NewMemoryStore(), 1000)) engine.SetDefaultCacher(xorm.NewLRUCacher(xorm.NewMemoryStore(), 1000))
defer engine.Close() defer engine.Close()
engine.SetMapper(SameMapper{}) engine.SetMapper(xorm.SameMapper{})
engine.ShowSQL = showTestSql engine.ShowSQL = showTestSql
engine.ShowErr = showTestSql engine.ShowErr = showTestSql
engine.ShowWarn = showTestSql engine.ShowWarn = showTestSql
@ -167,7 +168,7 @@ func BenchmarkPostgresCacheInsert(t *testing.B) {
t.Error(err) t.Error(err)
return return
} }
engine.SetDefaultCacher(NewLRUCacher(NewMemoryStore(), 1000)) engine.SetDefaultCacher(xorm.NewLRUCacher(xorm.NewMemoryStore(), 1000))
doBenchInsert(engine, t) doBenchInsert(engine, t)
} }
@ -180,7 +181,7 @@ func BenchmarkPostgresCacheFind(t *testing.B) {
t.Error(err) t.Error(err)
return return
} }
engine.SetDefaultCacher(NewLRUCacher(NewMemoryStore(), 1000)) engine.SetDefaultCacher(xorm.NewLRUCacher(xorm.NewMemoryStore(), 1000))
doBenchFind(engine, t) doBenchFind(engine, t)
} }
@ -193,7 +194,7 @@ func BenchmarkPostgresCacheFindPtr(t *testing.B) {
t.Error(err) t.Error(err)
return return
} }
engine.SetDefaultCacher(NewLRUCacher(NewMemoryStore(), 1000)) engine.SetDefaultCacher(xorm.NewLRUCacher(xorm.NewMemoryStore(), 1000))
doBenchFindPtr(engine, t) doBenchFindPtr(engine, t)
} }

19
sqlite3_test.go → tests/sqlite3_test.go
View File

@ -5,12 +5,13 @@ import (
"os" "os"
"testing" "testing"
"github.com/lunny/xorm"
_ "github.com/mattn/go-sqlite3" _ "github.com/mattn/go-sqlite3"
) )
func newSqlite3Engine() (*Engine, error) { func newSqlite3Engine() (*xorm.Engine, error) {
os.Remove("./test.db") os.Remove("./test.db")
return NewEngine("sqlite3", "./test.db") return xorm.NewEngine("sqlite3", "./test.db")
} }
func newSqlite3DriverDB() (*sql.DB, error) { func newSqlite3DriverDB() (*sql.DB, error) {
@ -43,7 +44,7 @@ func TestSqlite3WithCache(t *testing.T) {
t.Error(err) t.Error(err)
return return
} }
engine.SetDefaultCacher(NewLRUCacher(NewMemoryStore(), 1000)) engine.SetDefaultCacher(xorm.NewLRUCacher(xorm.NewMemoryStore(), 1000))
engine.ShowSQL = showTestSql engine.ShowSQL = showTestSql
engine.ShowErr = showTestSql engine.ShowErr = showTestSql
engine.ShowWarn = showTestSql engine.ShowWarn = showTestSql
@ -61,7 +62,7 @@ func TestSqlite3SameMapper(t *testing.T) {
t.Error(err) t.Error(err)
return return
} }
engine.SetMapper(SameMapper{}) engine.SetMapper(xorm.SameMapper{})
engine.ShowSQL = showTestSql engine.ShowSQL = showTestSql
engine.ShowErr = showTestSql engine.ShowErr = showTestSql
engine.ShowWarn = showTestSql engine.ShowWarn = showTestSql
@ -80,8 +81,8 @@ func TestSqlite3WithCacheSameMapper(t *testing.T) {
t.Error(err) t.Error(err)
return return
} }
engine.SetMapper(SameMapper{}) engine.SetMapper(xorm.SameMapper{})
engine.SetDefaultCacher(NewLRUCacher(NewMemoryStore(), 1000)) engine.SetDefaultCacher(xorm.NewLRUCacher(xorm.NewMemoryStore(), 1000))
engine.ShowSQL = showTestSql engine.ShowSQL = showTestSql
engine.ShowErr = showTestSql engine.ShowErr = showTestSql
engine.ShowWarn = showTestSql engine.ShowWarn = showTestSql
@ -151,7 +152,7 @@ func BenchmarkSqlite3CacheInsert(t *testing.B) {
t.Error(err) t.Error(err)
return return
} }
engine.SetDefaultCacher(NewLRUCacher(NewMemoryStore(), 1000)) engine.SetDefaultCacher(xorm.NewLRUCacher(xorm.NewMemoryStore(), 1000))
doBenchInsert(engine, t) doBenchInsert(engine, t)
} }
@ -163,7 +164,7 @@ func BenchmarkSqlite3CacheFind(t *testing.B) {
t.Error(err) t.Error(err)
return return
} }
engine.SetDefaultCacher(NewLRUCacher(NewMemoryStore(), 1000)) engine.SetDefaultCacher(xorm.NewLRUCacher(xorm.NewMemoryStore(), 1000))
doBenchFind(engine, t) doBenchFind(engine, t)
} }
@ -175,6 +176,6 @@ func BenchmarkSqlite3CacheFindPtr(t *testing.B) {
t.Error(err) t.Error(err)
return return
} }
engine.SetDefaultCacher(NewLRUCacher(NewMemoryStore(), 1000)) engine.SetDefaultCacher(xorm.NewLRUCacher(xorm.NewMemoryStore(), 1000))
doBenchFindPtr(engine, t) doBenchFindPtr(engine, t)
} }

0
tests/mysql_ddl.sql → tests/testdata/mysql_ddl.sql vendored
View File