// Copyright 2011 The Go Authors. All rights reserved.// Use of this source code is governed by a BSD-style// license that can be found in the LICENSE file. package sql import (	"database/sql/driver"	"errors"	"fmt"	"math/rand"	"reflect"	"runtime"	"strings"	"sync"	"testing"	"time") func init() {	type dbConn struct {		db *DB		c  *driverConn	}	freedFrom := make(map[dbConn]string)	putConnHook = func(db *DB, c *driverConn) {		idx := -1		for i, v := range db.freeConn {			if v == c {				idx = i				break			}		}		if idx >= 0 {			// print before panic, as panic may get lost due to conflicting panic			// (all goroutines asleep) elsewhere, since we might not unlock			// the mutex in freeConn here.			println("double free of conn. conflicts are:\nA) " + freedFrom[dbConn{db, c}] + "\n\nand\nB) " + stack())			panic("double free of conn.")		}		freedFrom[dbConn{db, c}] = stack()	}} const fakeDBName = "foo" var chrisBirthday = time.Unix(123456789, 0) func newTestDB(t testing.TB, name string) *DB {	db, err := Open("test", fakeDBName)	if err != nil {		t.Fatalf("Open: %v", err)	}	if _, err := db.Exec("WIPE"); err != nil {		t.Fatalf("exec wipe: %v", err)	}	if name == "people" {		exec(t, db, "CREATE|people|name=string,age=int32,photo=blob,dead=bool,bdate=datetime")		exec(t, db, "INSERT|people|name=Alice,age=?,photo=APHOTO", 1)		exec(t, db, "INSERT|people|name=Bob,age=?,photo=BPHOTO", 2)		exec(t, db, "INSERT|people|name=Chris,age=?,photo=CPHOTO,bdate=?", 3, chrisBirthday)	}	if name == "magicquery" {		// Magic table name and column, known by fakedb_test.go.		exec(t, db, "CREATE|magicquery|op=string,millis=int32")		exec(t, db, "INSERT|magicquery|op=sleep,millis=10")	}	return db} func exec(t testing.TB, db *DB, query string, args ...interface{}) {	_, err := db.Exec(query, args...)	if err != nil {		t.Fatalf("Exec of %q: %v", query, err)	}} func closeDB(t testing.TB, db *DB) {	if e := recover(); e != nil {		fmt.Printf("Panic: %v\n", e)		panic(e)	}	defer setHookpostCloseConn(nil)	setHookpostCloseConn(func(_ *fakeConn, err error) {		if err != nil {			t.Errorf("Error closing fakeConn: %v", err)		}	})	for i, dc := range db.freeConn {		if n := len(dc.openStmt); n > 0 {			// Just a sanity check. This is legal in			// general, but if we make the tests clean up			// their statements first, then we can safely			// verify this is always zero here, and any			// other value is a leak.			t.Errorf("while closing db, freeConn %d/%d had %d open stmts; want 0", i, len(db.freeConn), n)		}	}	err := db.Close()	if err != nil {		t.Fatalf("error closing DB: %v", err)	}	db.mu.Lock()	count := db.numOpen	db.mu.Unlock()	if count != 0 {		t.Fatalf("%d connections still open after closing DB", db.numOpen)	}} // numPrepares assumes that db has exactly 1 idle conn and returns// its count of calls to Preparefunc numPrepares(t *testing.T, db *DB) int {	if n := len(db.freeConn); n != 1 {		t.Fatalf("free conns = %d; want 1", n)	}	return db.freeConn[0].ci.(*fakeConn).numPrepare} func (db *DB) numDeps() int {	db.mu.Lock()	defer db.mu.Unlock()	return len(db.dep)} // Dependencies are closed via a goroutine, so this polls waiting for// numDeps to fall to want, waiting up to d.func (db *DB) numDepsPollUntil(want int, d time.Duration) int {	deadline := time.Now().Add(d)	for {		n := db.numDeps()		if n <= want || time.Now().After(deadline) {			return n		}		time.Sleep(50 * time.Millisecond)	}} func (db *DB) numFreeConns() int {	db.mu.Lock()	defer db.mu.Unlock()	return len(db.freeConn)} // clearAllConns closes all connections in db.func (db *DB) clearAllConns(t *testing.T) {	db.SetMaxIdleConns(0) 	if g, w := db.numFreeConns(), 0; g != w {		t.Errorf("free conns = %d; want %d", g, w)	} 	if n := db.numDepsPollUntil(0, time.Second); n > 0 {		t.Errorf("number of dependencies = %d; expected 0", n)		db.dumpDeps(t)	}} func (db *DB) dumpDeps(t *testing.T) {	for fc := range db.dep {		db.dumpDep(t, 0, fc, map[finalCloser]bool{})	}} func (db *DB) dumpDep(t *testing.T, depth int, dep finalCloser, seen map[finalCloser]bool) {	seen[dep] = true	indent := strings.Repeat("  ", depth)	ds := db.dep[dep]	for k := range ds {		t.Logf("%s%T (%p) waiting for -> %T (%p)", indent, dep, dep, k, k)		if fc, ok := k.(finalCloser); ok {			if !seen[fc] {				db.dumpDep(t, depth+1, fc, seen)			}		}	}} func TestQuery(t *testing.T) {	db := newTestDB(t, "people")	defer closeDB(t, db)	prepares0 := numPrepares(t, db)	rows, err := db.Query("SELECT|people|age,name|")	if err != nil {		t.Fatalf("Query: %v", err)	}	type row struct {		age  int		name string	}	got := []row{}	for rows.Next() {		var r row		err = rows.Scan(&r.age, &r.name)		if err != nil {			t.Fatalf("Scan: %v", err)		}		got = append(got, r)	}	err = rows.Err()	if err != nil {		t.Fatalf("Err: %v", err)	}	want := []row{		{age: 1, name: "Alice"},		{age: 2, name: "Bob"},		{age: 3, name: "Chris"},	}	if !reflect.DeepEqual(got, want) {		t.Errorf("mismatch.\n got: %#v\nwant: %#v", got, want)	} 	// And verify that the final rows.Next() call, which hit EOF,	// also closed the rows connection.	if n := db.numFreeConns(); n != 1 {		t.Fatalf("free conns after query hitting EOF = %d; want 1", n)	}	if prepares := numPrepares(t, db) - prepares0; prepares != 1 {		t.Errorf("executed %d Prepare statements; want 1", prepares)	}} func TestByteOwnership(t *testing.T) {	db := newTestDB(t, "people")	defer closeDB(t, db)	rows, err := db.Query("SELECT|people|name,photo|")	if err != nil {		t.Fatalf("Query: %v", err)	}	type row struct {		name  []byte		photo RawBytes	}	got := []row{}	for rows.Next() {		var r row		err = rows.Scan(&r.name, &r.photo)		if err != nil {			t.Fatalf("Scan: %v", err)		}		got = append(got, r)	}	corruptMemory := []byte("\xffPHOTO")	want := []row{		{name: []byte("Alice"), photo: corruptMemory},		{name: []byte("Bob"), photo: corruptMemory},		{name: []byte("Chris"), photo: corruptMemory},	}	if !reflect.DeepEqual(got, want) {		t.Errorf("mismatch.\n got: %#v\nwant: %#v", got, want)	} 	var photo RawBytes	err = db.QueryRow("SELECT|people|photo|name=?", "Alice").Scan(&photo)	if err == nil {		t.Error("want error scanning into RawBytes from QueryRow")	}} func TestRowsColumns(t *testing.T) {	db := newTestDB(t, "people")	defer closeDB(t, db)	rows, err := db.Query("SELECT|people|age,name|")	if err != nil {		t.Fatalf("Query: %v", err)	}	cols, err := rows.Columns()	if err != nil {		t.Fatalf("Columns: %v", err)	}	want := []string{"age", "name"}	if !reflect.DeepEqual(cols, want) {		t.Errorf("got %#v; want %#v", cols, want)	}	if err := rows.Close(); err != nil {		t.Errorf("error closing rows: %s", err)	}} func TestQueryRow(t *testing.T) {	db := newTestDB(t, "people")	defer closeDB(t, db)	var name string	var age int	var birthday time.Time 	err := db.QueryRow("SELECT|people|age,name|age=?", 3).Scan(&age)	if err == nil || !strings.Contains(err.Error(), "expected 2 destination arguments") {		t.Errorf("expected error from wrong number of arguments; actually got: %v", err)	} 	err = db.QueryRow("SELECT|people|bdate|age=?", 3).Scan(&birthday)	if err != nil || !birthday.Equal(chrisBirthday) {		t.Errorf("chris birthday = %v, err = %v; want %v", birthday, err, chrisBirthday)	} 	err = db.QueryRow("SELECT|people|age,name|age=?", 2).Scan(&age, &name)	if err != nil {		t.Fatalf("age QueryRow+Scan: %v", err)	}	if name != "Bob" {		t.Errorf("expected name Bob, got %q", name)	}	if age != 2 {		t.Errorf("expected age 2, got %d", age)	} 	err = db.QueryRow("SELECT|people|age,name|name=?", "Alice").Scan(&age, &name)	if err != nil {		t.Fatalf("name QueryRow+Scan: %v", err)	}	if name != "Alice" {		t.Errorf("expected name Alice, got %q", name)	}	if age != 1 {		t.Errorf("expected age 1, got %d", age)	} 	var photo []byte	err = db.QueryRow("SELECT|people|photo|name=?", "Alice").Scan(&photo)	if err != nil {		t.Fatalf("photo QueryRow+Scan: %v", err)	}	want := []byte("APHOTO")	if !reflect.DeepEqual(photo, want) {		t.Errorf("photo = %q; want %q", photo, want)	}} func TestStatementErrorAfterClose(t *testing.T) {	db := newTestDB(t, "people")	defer closeDB(t, db)	stmt, err := db.Prepare("SELECT|people|age|name=?")	if err != nil {		t.Fatalf("Prepare: %v", err)	}	err = stmt.Close()	if err != nil {		t.Fatalf("Close: %v", err)	}	var name string	err = stmt.QueryRow("foo").Scan(&name)	if err == nil {		t.Errorf("expected error from QueryRow.Scan after Stmt.Close")	}} func TestStatementQueryRow(t *testing.T) {	db := newTestDB(t, "people")	defer closeDB(t, db)	stmt, err := db.Prepare("SELECT|people|age|name=?")	if err != nil {		t.Fatalf("Prepare: %v", err)	}	defer stmt.Close()	var age int	for n, tt := range []struct {		name string		want int	}{		{"Alice", 1},		{"Bob", 2},		{"Chris", 3},	} {		if err := stmt.QueryRow(tt.name).Scan(&age); err != nil {			t.Errorf("%d: on %q, QueryRow/Scan: %v", n, tt.name, err)		} else if age != tt.want {			t.Errorf("%d: age=%d, want %d", n, age, tt.want)		}	}} type stubDriverStmt struct {	err error} func (s stubDriverStmt) Close() error {	return s.err} func (s stubDriverStmt) NumInput() int {	return -1} func (s stubDriverStmt) Exec(args []driver.Value) (driver.Result, error) {	return nil, nil} func (s stubDriverStmt) Query(args []driver.Value) (driver.Rows, error) {	return nil, nil} // golang.org/issue/12798func TestStatementClose(t *testing.T) {	want := errors.New("STMT ERROR") 	tests := []struct {		stmt *Stmt		msg  string	}{		{&Stmt{stickyErr: want}, "stickyErr not propagated"},		{&Stmt{tx: &Tx{}, txsi: &driverStmt{&sync.Mutex{}, stubDriverStmt{want}}}, "driverStmt.Close() error not propagated"},	}	for _, test := range tests {		if err := test.stmt.Close(); err != want {			t.Errorf("%s. Got stmt.Close() = %v, want = %v", test.msg, err, want)		}	}} // golang.org/issue/3734func TestStatementQueryRowConcurrent(t *testing.T) {	db := newTestDB(t, "people")	defer closeDB(t, db)	stmt, err := db.Prepare("SELECT|people|age|name=?")	if err != nil {		t.Fatalf("Prepare: %v", err)	}	defer stmt.Close() 	const n = 10	ch := make(chan error, n)	for i := 0; i < n; i++ {		go func() {			var age int			err := stmt.QueryRow("Alice").Scan(&age)			if err == nil && age != 1 {				err = fmt.Errorf("unexpected age %d", age)			}			ch <- err		}()	}	for i := 0; i < n; i++ {		if err := <-ch; err != nil {			t.Error(err)		}	}} // just a test of fakedb itselffunc TestBogusPreboundParameters(t *testing.T) {	db := newTestDB(t, "foo")	defer closeDB(t, db)	exec(t, db, "CREATE|t1|name=string,age=int32,dead=bool")	_, err := db.Prepare("INSERT|t1|name=?,age=bogusconversion")	if err == nil {		t.Fatalf("expected error")	}	if err.Error() != `fakedb: invalid conversion to int32 from "bogusconversion"` {		t.Errorf("unexpected error: %v", err)	}} func TestExec(t *testing.T) {	db := newTestDB(t, "foo")	defer closeDB(t, db)	exec(t, db, "CREATE|t1|name=string,age=int32,dead=bool")	stmt, err := db.Prepare("INSERT|t1|name=?,age=?")	if err != nil {		t.Errorf("Stmt, err = %v, %v", stmt, err)	}	defer stmt.Close() 	type execTest struct {		args    []interface{}		wantErr string	}	execTests := []execTest{		// Okay:		{[]interface{}{"Brad", 31}, ""},		{[]interface{}{"Brad", int64(31)}, ""},		{[]interface{}{"Bob", "32"}, ""},		{[]interface{}{7, 9}, ""}, 		// Invalid conversions:		{[]interface{}{"Brad", int64(0xFFFFFFFF)}, "sql: converting argument #1's type: sql/driver: value 4294967295 overflows int32"},		{[]interface{}{"Brad", "strconv fail"}, "sql: converting argument #1's type: sql/driver: value \"strconv fail\" can't be converted to int32"}, 		// Wrong number of args:		{[]interface{}{}, "sql: expected 2 arguments, got 0"},		{[]interface{}{1, 2, 3}, "sql: expected 2 arguments, got 3"},	}	for n, et := range execTests {		_, err := stmt.Exec(et.args...)		errStr := ""		if err != nil {			errStr = err.Error()		}		if errStr != et.wantErr {			t.Errorf("stmt.Execute #%d: for %v, got error %q, want error %q",				n, et.args, errStr, et.wantErr)		}	}} func TestTxPrepare(t *testing.T) {	db := newTestDB(t, "")	defer closeDB(t, db)	exec(t, db, "CREATE|t1|name=string,age=int32,dead=bool")	tx, err := db.Begin()

Lines 1–500 of 2350. Load more