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

move tests to a sereprated repository

This commit is contained in:
Lunny Xiao 2014-04-11 17:22:21 +08:00
parent 128db9c792
commit f30dadfd02
10 changed files with 0 additions and 5291 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4185
tests/base_test.go
View File

File diff suppressed because it is too large Load Diff

1
tests/benchmark.bat
View File

@ -1 +0,0 @@
go test -v -bench=. -run=XXX

1
tests/benchmark.sh
View File

@ -1 +0,0 @@
go test -v -bench=. -run=XXX

176
tests/benchmark_base_test.go
View File

@ -1,176 +0,0 @@
package tests
import (
"database/sql"
"testing"
"github.com/go-xorm/xorm"
)
type BigStruct struct {
Id int64
Name string
Title string
Age string
Alias string
NickName string
}
func doBenchDriverInsert(db *sql.DB, b *testing.B) {
b.StartTimer()
for i := 0; i < b.N; i++ {
_, err := db.Exec(`insert into big_struct (name, title, age, alias, nick_name)
values ('fafdasf', 'fadfa', 'afadfsaf', 'fadfafdsafd', 'fadfafdsaf')`)
if err != nil {
b.Error(err)
return
}
}
b.StopTimer()
}
func doBenchDriverFind(db *sql.DB, b *testing.B) {
b.StopTimer()
for i := 0; i < 50; i++ {
_, err := db.Exec(`insert into big_struct (name, title, age, alias, nick_name)
values ('fafdasf', 'fadfa', 'afadfsaf', 'fadfafdsafd', 'fadfafdsaf')`)
if err != nil {
b.Error(err)
return
}
}
b.StartTimer()
for i := 0; i < b.N/50; i++ {
rows, err := db.Query("select * from big_struct limit 50")
if err != nil {
b.Error(err)
return
}
for rows.Next() {
s := &BigStruct{}
rows.Scan(&s.Id, &s.Name, &s.Title, &s.Age, &s.Alias, &s.NickName)
}
}
b.StopTimer()
}
func doBenchDriver(newdriver func() (*sql.DB, error), createTableSql,
dropTableSql string, opFunc func(*sql.DB, *testing.B), t *testing.B) {
db, err := newdriver()
if err != nil {
t.Error(err)
return
}
defer db.Close()
_, err = db.Exec(createTableSql)
if err != nil {
t.Error(err)
return
}
opFunc(db, t)
_, err = db.Exec(dropTableSql)
if err != nil {
t.Error(err)
return
}
}
func doBenchInsert(engine *xorm.Engine, b *testing.B) {
b.StopTimer()
bs := &BigStruct{0, "fafdasf", "fadfa", "afadfsaf", "fadfafdsafd", "fadfafdsaf"}
err := engine.CreateTables(bs)
if err != nil {
b.Error(err)
return
}
b.StartTimer()
for i := 0; i < b.N; i++ {
bs.Id = 0
_, err = engine.Insert(bs)
if err != nil {
b.Error(err)
return
}
}
b.StopTimer()
err = engine.DropTables(bs)
if err != nil {
b.Error(err)
return
}
}
func doBenchFind(engine *xorm.Engine, b *testing.B) {
b.StopTimer()
bs := &BigStruct{0, "fafdasf", "fadfa", "afadfsaf", "fadfafdsafd", "fadfafdsaf"}
err := engine.CreateTables(bs)
if err != nil {
b.Error(err)
return
}
for i := 0; i < 100; i++ {
bs.Id = 0
_, err = engine.Insert(bs)
if err != nil {
b.Error(err)
return
}
}
b.StartTimer()
for i := 0; i < b.N/50; i++ {
bss := new([]BigStruct)
err = engine.Limit(50).Find(bss)
if err != nil {
b.Error(err)
return
}
}
b.StopTimer()
err = engine.DropTables(bs)
if err != nil {
b.Error(err)
return
}
}
func doBenchFindPtr(engine *xorm.Engine, b *testing.B) {
b.StopTimer()
bs := &BigStruct{0, "fafdasf", "fadfa", "afadfsaf", "fadfafdsafd", "fadfafdsaf"}
err := engine.CreateTables(bs)
if err != nil {
b.Error(err)
return
}
for i := 0; i < 100; i++ {
bs.Id = 0
_, err = engine.Insert(bs)
if err != nil {
b.Error(err)
return
}
}
b.StartTimer()
for i := 0; i < b.N/50; i++ {
bss := new([]*BigStruct)
err = engine.Limit(50).Find(bss)
if err != nil {
b.Error(err)
return
}
}
b.StopTimer()
err = engine.DropTables(bs)
if err != nil {
b.Error(err)
return
}
}

144
tests/mssql_test.go
View File

@ -1,144 +0,0 @@
package tests
//
// +build windows
import (
"database/sql"
"testing"
"github.com/go-xorm/xorm"
"github.com/go-xorm/xorm/caches"
_ "github.com/lunny/godbc"
)
const mssqlConnStr = "driver={SQL Server};Server=192.168.20.135;Database=xorm_test; uid=sa; pwd=1234;"
func newMssqlEngine() (*xorm.Engine, error) {
return xorm.NewEngine("odbc", mssqlConnStr)
}
func TestMssql(t *testing.T) {
engine, err := newMssqlEngine()
defer engine.Close()
if err != nil {
t.Error(err)
return
}
engine.ShowSQL = showTestSql
engine.ShowErr = showTestSql
engine.ShowWarn = showTestSql
engine.ShowDebug = showTestSql
testAll(engine, t)
testAll2(engine, t)
}
func TestMssqlWithCache(t *testing.T) {
engine, err := newMssqlEngine()
defer engine.Close()
if err != nil {
t.Error(err)
return
}
engine.SetDefaultCacher(xorm.NewLRUCacher(caches.NewMemoryStore(), 1000))
engine.ShowSQL = showTestSql
engine.ShowErr = showTestSql
engine.ShowWarn = showTestSql
engine.ShowDebug = showTestSql
testAll(engine, t)
testAll2(engine, t)
}
func newMssqlDriverDB() (*sql.DB, error) {
return sql.Open("odbc", mssqlConnStr)
}
const (
createTableMssql = `IF NOT EXISTS (SELECT [name] FROM sys.tables WHERE [name] = 'big_struct' ) CREATE TABLE
"big_struct" ("id" BIGINT PRIMARY KEY IDENTITY NOT NULL, "name" VARCHAR(255) NULL, "title" VARCHAR(255) NULL,
"age" VARCHAR(255) NULL, "alias" VARCHAR(255) NULL, "nick_name" VARCHAR(255) NULL);
`
dropTableMssql = "IF EXISTS (SELECT * FROM sysobjects WHERE id = object_id(N'big_struct') and OBJECTPROPERTY(id, N'IsUserTable') = 1) DROP TABLE IF EXISTS `big_struct`;"
)
func BenchmarkMssqlDriverInsert(t *testing.B) {
doBenchDriver(newMssqlDriverDB, createTableMssql, dropTableMssql,
doBenchDriverInsert, t)
}
func BenchmarkMssqlDriverFind(t *testing.B) {
doBenchDriver(newMssqlDriverDB, createTableMssql, dropTableMssql,
doBenchDriverFind, t)
}
func BenchmarkMssqlNoCacheInsert(t *testing.B) {
engine, err := newMssqlEngine()
defer engine.Close()
if err != nil {
t.Error(err)
return
}
//engine.ShowSQL = true
doBenchInsert(engine, t)
}
func BenchmarkMssqlNoCacheFind(t *testing.B) {
engine, err := newMssqlEngine()
defer engine.Close()
if err != nil {
t.Error(err)
return
}
//engine.ShowSQL = true
doBenchFind(engine, t)
}
func BenchmarkMssqlNoCacheFindPtr(t *testing.B) {
engine, err := newMssqlEngine()
defer engine.Close()
if err != nil {
t.Error(err)
return
}
//engine.ShowSQL = true
doBenchFindPtr(engine, t)
}
func BenchmarkMssqlCacheInsert(t *testing.B) {
engine, err := newMssqlEngine()
defer engine.Close()
if err != nil {
t.Error(err)
return
}
engine.SetDefaultCacher(xorm.NewLRUCacher(caches.NewMemoryStore(), 1000))
doBenchInsert(engine, t)
}
func BenchmarkMssqlCacheFind(t *testing.B) {
engine, err := newMssqlEngine()
defer engine.Close()
if err != nil {
t.Error(err)
return
}
engine.SetDefaultCacher(xorm.NewLRUCacher(caches.NewMemoryStore(), 1000))
doBenchFind(engine, t)
}
func BenchmarkMssqlCacheFindPtr(t *testing.B) {
engine, err := newMssqlEngine()
defer engine.Close()
if err != nil {
t.Error(err)
return
}
engine.SetDefaultCacher(xorm.NewLRUCacher(caches.NewMemoryStore(), 1000))
doBenchFindPtr(engine, t)
}

169
tests/mymysql_test.go
View File

@ -1,169 +0,0 @@
package tests
import (
"database/sql"
"testing"
"github.com/go-xorm/xorm"
"github.com/go-xorm/xorm/caches"
_ "github.com/ziutek/mymysql/godrv"
)
/*
CREATE DATABASE IF NOT EXISTS xorm_test CHARACTER SET
utf8 COLLATE utf8_general_ci;
*/
var showTestSql bool = true
func TestMyMysql(t *testing.T) {
err := mymysqlDdlImport()
if err != nil {
t.Error(err)
return
}
engine, err := xorm.NewEngine("mymysql", "xorm_test/root/")
defer engine.Close()
if err != nil {
t.Error(err)
return
}
engine.ShowSQL = showTestSql
engine.ShowErr = showTestSql
engine.ShowWarn = showTestSql
engine.ShowDebug = showTestSql
testAll(engine, t)
testAll2(engine, t)
testAll3(engine, t)
}
func TestMyMysqlWithCache(t *testing.T) {
err := mymysqlDdlImport()
if err != nil {
t.Error(err)
return
}
engine, err := xorm.NewEngine("mymysql", "xorm_test2/root/")
defer engine.Close()
if err != nil {
t.Error(err)
return
}
engine.SetDefaultCacher(xorm.NewLRUCacher(caches.NewMemoryStore(), 1000))
engine.ShowSQL = showTestSql
engine.ShowErr = showTestSql
engine.ShowWarn = showTestSql
engine.ShowDebug = showTestSql
testAll(engine, t)
testAll2(engine, t)
}
func newMyMysqlEngine() (*xorm.Engine, error) {
return xorm.NewEngine("mymysql", "xorm_test2/root/")
}
func newMyMysqlDriverDB() (*sql.DB, error) {
return sql.Open("mymysql", "xorm_test2/root/")
}
func BenchmarkMyMysqlDriverInsert(t *testing.B) {
doBenchDriver(newMyMysqlDriverDB, createTableMySql, dropTableMySql,
doBenchDriverInsert, t)
}
func BenchmarkMyMysqlDriverFind(t *testing.B) {
doBenchDriver(newMyMysqlDriverDB, createTableMySql, dropTableMySql,
doBenchDriverFind, t)
}
func mymysqlDdlImport() error {
engine, err := xorm.NewEngine("mymysql", "/root/")
if err != nil {
return err
}
engine.ShowSQL = showTestSql
engine.ShowErr = showTestSql
engine.ShowWarn = showTestSql
engine.ShowDebug = showTestSql
sqlResults, _ := engine.Import("testdata/mysql_ddl.sql")
engine.LogDebug("sql results: %v", sqlResults)
engine.Close()
return nil
}
func BenchmarkMyMysqlNoCacheInsert(t *testing.B) {
engine, err := newMyMysqlEngine()
if err != nil {
t.Error(err)
return
}
defer engine.Close()
doBenchInsert(engine, t)
}
func BenchmarkMyMysqlNoCacheFind(t *testing.B) {
engine, err := newMyMysqlEngine()
if err != nil {
t.Error(err)
return
}
defer engine.Close()
//engine.ShowSQL = true
doBenchFind(engine, t)
}
func BenchmarkMyMysqlNoCacheFindPtr(t *testing.B) {
engine, err := newMyMysqlEngine()
if err != nil {
t.Error(err)
return
}
defer engine.Close()
//engine.ShowSQL = true
doBenchFindPtr(engine, t)
}
func BenchmarkMyMysqlCacheInsert(t *testing.B) {
engine, err := newMyMysqlEngine()
if err != nil {
t.Error(err)
return
}
defer engine.Close()
engine.SetDefaultCacher(xorm.NewLRUCacher(caches.NewMemoryStore(), 1000))
doBenchInsert(engine, t)
}
func BenchmarkMyMysqlCacheFind(t *testing.B) {
engine, err := newMyMysqlEngine()
if err != nil {
t.Error(err)
return
}
defer engine.Close()
engine.SetDefaultCacher(xorm.NewLRUCacher(caches.NewMemoryStore(), 1000))
doBenchFind(engine, t)
}
func BenchmarkMyMysqlCacheFindPtr(t *testing.B) {
engine, err := newMyMysqlEngine()
if err != nil {
t.Error(err)
return
}
defer engine.Close()
engine.SetDefaultCacher(xorm.NewLRUCacher(caches.NewMemoryStore(), 1000))
doBenchFindPtr(engine, t)
}

222
tests/mysql_test.go
View File

@ -1,222 +0,0 @@
package tests
import (
"database/sql"
"testing"
_ "github.com/go-sql-driver/mysql"
"github.com/go-xorm/core"
"github.com/go-xorm/xorm"
"github.com/go-xorm/xorm/caches"
)
/*
CREATE DATABASE IF NOT EXISTS xorm_test CHARACTER SET
utf8 COLLATE utf8_general_ci;
*/
func TestMysql(t *testing.T) {
err := mysqlDdlImport()
if err != nil {
t.Error(err)
return
}
engine, err := xorm.NewEngine("mysql", "root:@/xorm_test?charset=utf8")
defer engine.Close()
if err != nil {
t.Error(err)
return
}
engine.ShowSQL = showTestSql
engine.ShowErr = showTestSql
engine.ShowWarn = showTestSql
engine.ShowDebug = showTestSql
testAll(engine, t)
testAllSnakeMapper(engine, t)
testAll2(engine, t)
testAll3(engine, t)
}
func TestMysqlSameMapper(t *testing.T) {
err := mysqlDdlImport()
if err != nil {
t.Error(err)
return
}
engine, err := xorm.NewEngine("mysql", "root:@/xorm_test1?charset=utf8")
defer engine.Close()
if err != nil {
t.Error(err)
return
}
engine.ShowSQL = showTestSql
engine.ShowErr = showTestSql
engine.ShowWarn = showTestSql
engine.ShowDebug = showTestSql
engine.SetMapper(core.SameMapper{})
testAll(engine, t)
testAllSameMapper(engine, t)
testAll2(engine, t)
testAll3(engine, t)
}
func TestMysqlWithCache(t *testing.T) {
err := mysqlDdlImport()
if err != nil {
t.Error(err)
return
}
engine, err := xorm.NewEngine("mysql", "root:@/xorm_test2?charset=utf8")
defer engine.Close()
if err != nil {
t.Error(err)
return
}
engine.SetDefaultCacher(xorm.NewLRUCacher(caches.NewMemoryStore(), 1000))
engine.ShowSQL = showTestSql
engine.ShowErr = showTestSql
engine.ShowWarn = showTestSql
engine.ShowDebug = showTestSql
testAll(engine, t)
testAllSnakeMapper(engine, t)
testAll2(engine, t)
}
func TestMysqlWithCacheSameMapper(t *testing.T) {
err := mysqlDdlImport()
if err != nil {
t.Error(err)
return
}
engine, err := xorm.NewEngine("mysql", "root:@/xorm_test3?charset=utf8")
defer engine.Close()
if err != nil {
t.Error(err)
return
}
engine.SetMapper(core.SameMapper{})
engine.SetDefaultCacher(xorm.NewLRUCacher(caches.NewMemoryStore(), 1000))
engine.ShowSQL = showTestSql
engine.ShowErr = showTestSql
engine.ShowWarn = showTestSql
engine.ShowDebug = showTestSql
testAll(engine, t)
testAllSameMapper(engine, t)
testAll2(engine, t)
}
func newMysqlEngine() (*xorm.Engine, error) {
return xorm.NewEngine("mysql", "root:@/xorm_test?charset=utf8")
}
func mysqlDdlImport() error {
engine, err := xorm.NewEngine("mysql", "root:@/?charset=utf8")
if err != nil {
return err
}
engine.ShowSQL = showTestSql
engine.ShowErr = showTestSql
engine.ShowWarn = showTestSql
engine.ShowDebug = showTestSql
sqlResults, _ := engine.Import("testdata/mysql_ddl.sql")
engine.LogDebug("sql results: %v", sqlResults)
engine.Close()
return nil
}
func newMysqlDriverDB() (*sql.DB, error) {
return sql.Open("mysql", "root:@/xorm_test?charset=utf8")
}
const (
createTableMySql = "CREATE TABLE IF NOT EXISTS `big_struct` (`id` BIGINT PRIMARY KEY AUTO_INCREMENT NOT NULL, `name` VARCHAR(255) NULL, `title` VARCHAR(255) NULL, `age` VARCHAR(255) NULL, `alias` VARCHAR(255) NULL, `nick_name` VARCHAR(255) NULL);"
dropTableMySql = "DROP TABLE IF EXISTS `big_struct`;"
)
func BenchmarkMysqlDriverInsert(t *testing.B) {
doBenchDriver(newMysqlDriverDB, createTableMySql, dropTableMySql,
doBenchDriverInsert, t)
}
func BenchmarkMysqlDriverFind(t *testing.B) {
doBenchDriver(newMysqlDriverDB, createTableMySql, dropTableMySql,
doBenchDriverFind, t)
}
func BenchmarkMysqlNoCacheInsert(t *testing.B) {
engine, err := newMysqlEngine()
defer engine.Close()
if err != nil {
t.Error(err)
return
}
//engine.ShowSQL = true
doBenchInsert(engine, t)
}
func BenchmarkMysqlNoCacheFind(t *testing.B) {
engine, err := newMysqlEngine()
defer engine.Close()
if err != nil {
t.Error(err)
return
}
//engine.ShowSQL = true
doBenchFind(engine, t)
}
func BenchmarkMysqlNoCacheFindPtr(t *testing.B) {
engine, err := newMysqlEngine()
defer engine.Close()
if err != nil {
t.Error(err)
return
}
//engine.ShowSQL = true
doBenchFindPtr(engine, t)
}
func BenchmarkMysqlCacheInsert(t *testing.B) {
engine, err := newMysqlEngine()
defer engine.Close()
if err != nil {
t.Error(err)
return
}
engine.SetDefaultCacher(xorm.NewLRUCacher(caches.NewMemoryStore(), 1000))
doBenchInsert(engine, t)
}
func BenchmarkMysqlCacheFind(t *testing.B) {
engine, err := newMysqlEngine()
defer engine.Close()
if err != nil {
t.Error(err)
return
}
engine.SetDefaultCacher(xorm.NewLRUCacher(caches.NewMemoryStore(), 1000))
doBenchFind(engine, t)
}
func BenchmarkMysqlCacheFindPtr(t *testing.B) {
engine, err := newMysqlEngine()
defer engine.Close()
if err != nil {
t.Error(err)
return
}
engine.SetDefaultCacher(xorm.NewLRUCacher(caches.NewMemoryStore(), 1000))
doBenchFindPtr(engine, t)
}

202
tests/postgres_test.go
View File

@ -1,202 +0,0 @@
package tests
import (
"database/sql"
"testing"
"github.com/go-xorm/core"
"github.com/go-xorm/xorm"
"github.com/go-xorm/xorm/caches"
_ "github.com/lib/pq"
)
//var connStr string = "dbname=xorm_test user=lunny password=1234 sslmode=disable"
var connStr string = "dbname=xorm_test sslmode=disable"
func newPostgresEngine() (*xorm.Engine, error) {
orm, err := xorm.NewEngine("postgres", connStr)
if err != nil {
return nil, err
}
tables, err := orm.DBMetas()
if err != nil {
return nil, err
}
for _, table := range tables {
_, err = orm.Exec("drop table \"" + table.Name + "\"")
if err != nil {
return nil, err
}
}
return orm, err
}
func newPostgresDriverDB() (*sql.DB, error) {
return sql.Open("postgres", connStr)
}
func TestPostgres(t *testing.T) {
engine, err := newPostgresEngine()
if err != nil {
t.Error(err)
return
}
defer engine.Close()
engine.ShowSQL = showTestSql
engine.ShowErr = showTestSql
engine.ShowWarn = showTestSql
engine.ShowDebug = showTestSql
testAll(engine, t)
testAllSnakeMapper(engine, t)
testAll2(engine, t)
testAll3(engine, t)
}
func TestPostgresWithCache(t *testing.T) {
engine, err := newPostgresEngine()
if err != nil {
t.Error(err)
return
}
engine.SetDefaultCacher(xorm.NewLRUCacher(caches.NewMemoryStore(), 1000))
defer engine.Close()
engine.ShowSQL = showTestSql
engine.ShowErr = showTestSql
engine.ShowWarn = showTestSql
engine.ShowDebug = showTestSql
testAll(engine, t)
testAllSnakeMapper(engine, t)
testAll2(engine, t)
}
func TestPostgresSameMapper(t *testing.T) {
engine, err := newPostgresEngine()
if err != nil {
t.Error(err)
return
}
defer engine.Close()
engine.SetMapper(core.SameMapper{})
engine.ShowSQL = showTestSql
engine.ShowErr = showTestSql
engine.ShowWarn = showTestSql
engine.ShowDebug = showTestSql
testAll(engine, t)
testAllSameMapper(engine, t)
testAll2(engine, t)
testAll3(engine, t)
}
func TestPostgresWithCacheSameMapper(t *testing.T) {
engine, err := newPostgresEngine()
if err != nil {
t.Error(err)
return
}
engine.SetDefaultCacher(xorm.NewLRUCacher(caches.NewMemoryStore(), 1000))
defer engine.Close()
engine.SetMapper(core.SameMapper{})
engine.ShowSQL = showTestSql
engine.ShowErr = showTestSql
engine.ShowWarn = showTestSql
engine.ShowDebug = showTestSql
testAll(engine, t)
testAllSameMapper(engine, t)
testAll2(engine, t)
}
const (
createTablePostgres = `CREATE TABLE IF NOT EXISTS "big_struct" ("id" SERIAL PRIMARY KEY NOT NULL, "name" VARCHAR(255) NULL, "title" VARCHAR(255) NULL, "age" VARCHAR(255) NULL, "alias" VARCHAR(255) NULL, "nick_name" VARCHAR(255) NULL);`
dropTablePostgres = `DROP TABLE IF EXISTS "big_struct";`
)
func BenchmarkPostgresDriverInsert(t *testing.B) {
doBenchDriver(newPostgresDriverDB, createTablePostgres, dropTablePostgres,
doBenchDriverInsert, t)
}
func BenchmarkPostgresDriverFind(t *testing.B) {
doBenchDriver(newPostgresDriverDB, createTablePostgres, dropTablePostgres,
doBenchDriverFind, t)
}
func BenchmarkPostgresNoCacheInsert(t *testing.B) {
engine, err := newPostgresEngine()
defer engine.Close()
if err != nil {
t.Error(err)
return
}
//engine.ShowSQL = true
doBenchInsert(engine, t)
}
func BenchmarkPostgresNoCacheFind(t *testing.B) {
engine, err := newPostgresEngine()
defer engine.Close()
if err != nil {
t.Error(err)
return
}
//engine.ShowSQL = true
doBenchFind(engine, t)
}
func BenchmarkPostgresNoCacheFindPtr(t *testing.B) {
engine, err := newPostgresEngine()
defer engine.Close()
if err != nil {
t.Error(err)
return
}
//engine.ShowSQL = true
doBenchFindPtr(engine, t)
}
func BenchmarkPostgresCacheInsert(t *testing.B) {
engine, err := newPostgresEngine()
defer engine.Close()
if err != nil {
t.Error(err)
return
}
engine.SetDefaultCacher(xorm.NewLRUCacher(caches.NewMemoryStore(), 1000))
doBenchInsert(engine, t)
}
func BenchmarkPostgresCacheFind(t *testing.B) {
engine, err := newPostgresEngine()
defer engine.Close()
if err != nil {
t.Error(err)
return
}
engine.SetDefaultCacher(xorm.NewLRUCacher(caches.NewMemoryStore(), 1000))
doBenchFind(engine, t)
}
func BenchmarkPostgresCacheFindPtr(t *testing.B) {
engine, err := newPostgresEngine()
defer engine.Close()
if err != nil {
t.Error(err)
return
}
engine.SetDefaultCacher(xorm.NewLRUCacher(caches.NewMemoryStore(), 1000))
doBenchFindPtr(engine, t)
}

183
tests/sqlite3_test.go
View File

@ -1,183 +0,0 @@
package tests
import (
"database/sql"
"os"
"testing"
"github.com/go-xorm/core"
"github.com/go-xorm/xorm"
"github.com/go-xorm/xorm/caches"
_ "github.com/mattn/go-sqlite3"
)
func newSqlite3Engine() (*xorm.Engine, error) {
os.Remove("./test.db")
return xorm.NewEngine("sqlite3", "./test.db")
}
func newSqlite3DriverDB() (*sql.DB, error) {
os.Remove("./test.db")
return sql.Open("sqlite3", "./test.db")
}
func TestSqlite3(t *testing.T) {
engine, err := newSqlite3Engine()
defer engine.Close()
if err != nil {
t.Error(err)
return
}
engine.ShowSQL = showTestSql
engine.ShowErr = showTestSql
engine.ShowWarn = showTestSql
engine.ShowDebug = showTestSql
testAll(engine, t)
testAllSnakeMapper(engine, t)
testAll2(engine, t)
testAll3(engine, t)
}
func TestSqlite3WithCache(t *testing.T) {
engine, err := newSqlite3Engine()
defer engine.Close()
if err != nil {
t.Error(err)
return
}
engine.SetDefaultCacher(xorm.NewLRUCacher(caches.NewMemoryStore(), 1000))
engine.ShowSQL = showTestSql
engine.ShowErr = showTestSql
engine.ShowWarn = showTestSql
engine.ShowDebug = showTestSql
testAll(engine, t)
testAllSnakeMapper(engine, t)
testAll2(engine, t)
}
func TestSqlite3SameMapper(t *testing.T) {
engine, err := newSqlite3Engine()
defer engine.Close()
if err != nil {
t.Error(err)
return
}
engine.SetMapper(core.SameMapper{})
engine.ShowSQL = showTestSql
engine.ShowErr = showTestSql
engine.ShowWarn = showTestSql
engine.ShowDebug = showTestSql
testAll(engine, t)
testAllSameMapper(engine, t)
testAll2(engine, t)
testAll3(engine, t)
}
func TestSqlite3WithCacheSameMapper(t *testing.T) {
engine, err := newSqlite3Engine()
defer engine.Close()
if err != nil {
t.Error(err)
return
}
engine.SetMapper(core.SameMapper{})
engine.SetDefaultCacher(xorm.NewLRUCacher(caches.NewMemoryStore(), 1000))
engine.ShowSQL = showTestSql
engine.ShowErr = showTestSql
engine.ShowWarn = showTestSql
engine.ShowDebug = showTestSql
testAll(engine, t)
testAllSameMapper(engine, t)
testAll2(engine, t)
}
const (
createTableSqlite3 = "CREATE TABLE IF NOT EXISTS `big_struct` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `name` TEXT NULL, `title` TEXT NULL, `age` TEXT NULL, `alias` TEXT NULL, `nick_name` TEXT NULL);"
dropTableSqlite3 = "DROP TABLE IF EXISTS `big_struct`;"
)
func BenchmarkSqlite3DriverInsert(t *testing.B) {
doBenchDriver(newSqlite3DriverDB, createTableSqlite3, dropTableSqlite3,
doBenchDriverInsert, t)
}
func BenchmarkSqlite3DriverFind(t *testing.B) {
doBenchDriver(newSqlite3DriverDB, createTableSqlite3, dropTableSqlite3,
doBenchDriverFind, t)
}
func BenchmarkSqlite3NoCacheInsert(t *testing.B) {
t.StopTimer()
engine, err := newSqlite3Engine()
defer engine.Close()
if err != nil {
t.Error(err)
return
}
//engine.ShowSQL = true
doBenchInsert(engine, t)
}
func BenchmarkSqlite3NoCacheFind(t *testing.B) {
t.StopTimer()
engine, err := newSqlite3Engine()
defer engine.Close()
if err != nil {
t.Error(err)
return
}
//engine.ShowSQL = true
doBenchFind(engine, t)
}
func BenchmarkSqlite3NoCacheFindPtr(t *testing.B) {
t.StopTimer()
engine, err := newSqlite3Engine()
defer engine.Close()
if err != nil {
t.Error(err)
return
}
//engine.ShowSQL = true
doBenchFindPtr(engine, t)
}
func BenchmarkSqlite3CacheInsert(t *testing.B) {
t.StopTimer()
engine, err := newSqlite3Engine()
defer engine.Close()
if err != nil {
t.Error(err)
return
}
engine.SetDefaultCacher(xorm.NewLRUCacher(caches.NewMemoryStore(), 1000))
doBenchInsert(engine, t)
}
func BenchmarkSqlite3CacheFind(t *testing.B) {
t.StopTimer()
engine, err := newSqlite3Engine()
defer engine.Close()
if err != nil {
t.Error(err)
return
}
engine.SetDefaultCacher(xorm.NewLRUCacher(caches.NewMemoryStore(), 1000))
doBenchFind(engine, t)
}
func BenchmarkSqlite3CacheFindPtr(t *testing.B) {
t.StopTimer()
engine, err := newSqlite3Engine()
defer engine.Close()
if err != nil {
t.Error(err)
return
}
engine.SetDefaultCacher(xorm.NewLRUCacher(caches.NewMemoryStore(), 1000))
doBenchFindPtr(engine, t)
}

8
tests/testdata/mysql_ddl.sql vendored
View File

@ -1,8 +0,0 @@
DROP DATABASE xorm_test;
DROP DATABASE xorm_test1;
DROP DATABASE xorm_test2;
DROP DATABASE xorm_test3;
CREATE DATABASE IF NOT EXISTS xorm_test CHARACTER SET utf8 COLLATE utf8_general_ci;
CREATE DATABASE IF NOT EXISTS xorm_test1 CHARACTER SET utf8 COLLATE utf8_general_ci;
CREATE DATABASE IF NOT EXISTS xorm_test2 CHARACTER SET utf8 COLLATE utf8_general_ci;
CREATE DATABASE IF NOT EXISTS xorm_test3 CHARACTER SET utf8 COLLATE utf8_general_ci;