simplify pool insteadClose and no global testSes

pool.go

@@ -136,17 +136,7 @@ func (p *Pool) Get() (ses *Ses, err error) {
 	defer p.Unlock()
 
 	// Instead of closing the session, put it back to the session pool.
-	Instead := func(ses *Ses) error {
-		if ses == nil {
-			return nil
-		}
-		ses.Lock()
-		ses.insteadClose = nil // one-shot
-		ses.Unlock()
-		// if the session is to be evicted, its srv should go to the srv pool.
-		p.ses.Put(sesSrvPB{Ses: ses, p: p.srv})
-		return nil
-	}
+	Instead := func(ses *Ses) error { p.Put(ses); return nil }
 	// try get session from the ses pool
 	for {
 		x := p.ses.Get()
@@ -194,6 +184,7 @@ func (p *Pool) Get() (ses *Ses, err error) {
 		return nil, err
 	}
 	if ses, err = srv.OpenSes(p.sesCfg); err != nil {
+		srv.Close()
 		return nil, err
 	}
 	ses.insteadClose = Instead
@@ -206,8 +197,11 @@ func (p *Pool) Put(ses *Ses) {
 	if ses == nil || !ses.IsOpen() {
 		return
 	}
+	p.ses.Lock()
+	ses.insteadClose = nil
 	//fmt.Fprintf(os.Stderr, "POOL: put back ses\n")
-	p.ses.Put(sesSrvPB{Ses: ses, p: p.srv})
+	p.ses.putLocked(sesSrvPB{Ses: ses, p: p.srv})
+	p.ses.Unlock()
 }
 
 type sesSrvPB struct {
@@ -222,11 +216,13 @@ func (s sesSrvPB) Close() error {
 		return nil
 	}
 	var srv *Srv
+	s.Ses.Lock()
 	if s.p != nil {
-		s.Ses.RLock()
 		srv = s.Ses.srv
-		s.Ses.RUnlock()
 	}
+	s.Ses.insteadClose = nil
+	s.Ses.Unlock()
+
 	err := s.Ses.Close()
 	if srv != nil { // there's only one ses per srv, so this should be safe
 		s.p.Put(srv)
@@ -523,7 +519,11 @@ func (p *idlePool) Get() io.Closer {
 // This way elements reused uniformly.
 func (p *idlePool) Put(c io.Closer) {
 	p.RLock()
-	defer p.RUnlock()
+	p.putLocked(c)
+	p.RUnlock()
+}
+
+func (p *idlePool) putLocked(c io.Closer) {
 	select {
 	case p.Elems() <- c:
 		return

z_bool_session_test.go

@@ -133,6 +133,9 @@ func TestSelectChar(t *testing.T) {
 	if _, err := testDb.Exec("CREATE TABLE " + tableName + "(c1 CHAR(1), c2 CHAR(4))"); err != nil {
 		t.Fatal(err)
 	}
+	testSes := getSes(t)
+	defer testSes.Close()
+
 	if _, err := testSes.PrepAndExe("INSERT INTO "+tableName+" VALUES (:1, :2)",
 		"A", "ABCD"); err != nil {
 		t.Fatal(err)

z_lob_test.go

@@ -48,6 +48,9 @@ BEGIN
   :4 := cur4;
 END;`
 
+	testSes := getSes(t)
+	defer testSes.Close()
+
 	for _, doNext := range []bool{true, false} {
 		stmt, err := testSes.Prep(qry)
 		if err != nil {
@@ -250,6 +253,9 @@ END test_get_json;`,
 	); err != nil {
 		t.Skipf("create function: %v", err)
 	}
+	testSes := getSes(t)
+	defer testSes.Close()
+
 	//enableLogging(t)
 	stmt, err := testSes.Prep("CALL test_get_json(:1, :2)", ora.OraBin, ora.S)
 	if err != nil {
@@ -327,6 +333,9 @@ Læringsutbyttet defineres i forhold til områder for kunnskap, ferdigheter og h
 
 	qry = "SELECT * FROM " + tbl + " WHERE emnekode = :1"
 
+	testSes := getSes(t)
+	defer testSes.Close()
+
 	enableLogging(t)
 	// LOB
 	{
@@ -641,6 +650,9 @@ Læringsutbyttet defineres i forhold til områder for kunnskap, ferdigheter og h
 		}
 	}
 
+	testSes := getSes(t)
+	defer testSes.Close()
+
 	qry = "SELECT * FROM " + tbl + " WHERE emnekode = :1"
 
 	// string
@@ -779,6 +791,9 @@ Læringsutbyttet defineres i forhold til områder for kunnskap, ferdigheter og h
 
 func TestLobIssue191(t *testing.T) {
 	enableLogging(t)
+	testSes := getSes(t)
+	defer testSes.Close()
+
 	l := &ora.Lob{}
 	stmt, err := testSes.Prep(`begin :1 := null; end;`)
 	if err != nil {

z_numeric_session_test.go

@@ -76,6 +76,9 @@ var _T_numericCols = []string{
 }
 
 func TestBindNumericString(t *testing.T) {
+	testSes := getSes(t)
+	defer testSes.Close()
+
 	tableName, err := createTable(1, numberP38S0, testSes)
 	testErr(err, t)
 	defer dropTable(tableName, testSes, t)

z_oracle_test.go

@@ -6,6 +6,7 @@ package ora_test
 
 import (
 	"bytes"
+	"context"
 	"crypto/rand"
 	"database/sql"
 	"database/sql/driver"
@@ -173,7 +174,6 @@ var testConStr string
 var testDbsessiontimezone *time.Location
 var testTableID uint32
 var testWorkloadColumnCount int
-var testSes *ora.Ses
 var testDb *sql.DB
 var testSesPool *ora.Pool
 
@@ -210,10 +210,11 @@ func init() {
 	}
 
 	testSesPool = testEnv.NewPool(testSrvCfg, testSesCfg, 4)
-	testSes, err = testSesPool.Get()
+	testSes, err := testSesPool.Get()
 	if err != nil {
 		panic(fmt.Sprintf("initError: %v", err))
 	}
+	defer testSes.Close()
 
 	//ora.SetCfg(func() StmtCfg { cfg = ora.Cfg(); cfg.RTrimChar = false; return cfg }())
 
@@ -261,6 +262,26 @@ END;`)
 			fmt.Println(http.ListenAndServe(addr, nil))
 		}()
 	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
+	err = testDb.PingContext(ctx)
+	cancel()
+	if err != nil {
+		panic(err)
+	}
+
+	if err := testSes.Ping(); err != nil {
+		panic(err)
+	}
+}
+
+func getSes(t testing.TB) *ora.Ses {
+	testSes, err := testSesPool.Get()
+	if err == nil {
+		return testSes
+	}
+	t.Fatal(err)
+	return nil
 }
 
 func enableLogging(t *testing.T) {
@@ -289,6 +310,12 @@ func testBindDefine(expected interface{}, oct oracleColumnType, t *testing.T, c
 	}
 	t.Logf("testBindDefine gct (%v, %v)", gct, ora.GctName(gct))
 
+	testSes, err := testSesPool.Get()
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer testSes.Close()
+
 	tableName, err := createTable(1, oct, testSes)
 	testErr(err, t)
 	defer dropTable(tableName, testSes, t)
@@ -297,10 +324,10 @@ func testBindDefine(expected interface{}, oct oracleColumnType, t *testing.T, c
 	qry := fmt.Sprintf("insert into %v (c1) values (:c1)", tableName)
 	insertStmt, err := testSes.Prep(qry)
 	testErr(errors.Wrap(err, qry), t)
+	defer insertStmt.Close()
 	if !c.IsZero() {
 		insertStmt.SetCfg(c)
 	}
-	defer insertStmt.Close()
 	rowsAffected, err := insertStmt.Exe(expected)
 	testErr(errors.Wrapf(err, "%q, %#v", qry, expected), t)
 	expLen := length(expected)
@@ -313,8 +340,8 @@ func testBindDefine(expected interface{}, oct oracleColumnType, t *testing.T, c
 
 	// select
 	selectStmt, err := testSes.Prep(fmt.Sprintf("select c1 from %v", tableName), gct)
-	defer selectStmt.Close()
 	testErr(err, t)
+	defer selectStmt.Close()
 	rset, err := selectStmt.Qry()
 	testErr(err, t)
 	defer rset.Exhaust()
@@ -330,6 +357,7 @@ func testBindDefineDB(expected interface{}, t *testing.T, oct oracleColumnType)
 
 			// insert
 			stmt, err := testDb.Prepare(fmt.Sprintf("insert into %v (c1) values (:c1)", tableName))
+			testErr(err, t)
 			defer stmt.Close()
 			execResult, err := stmt.Exec(expected)
 			testErr(err, t)
@@ -341,6 +369,7 @@ func testBindDefineDB(expected interface{}, t *testing.T, oct oracleColumnType)
 
 			// query
 			rows, err := testDb.Query(fmt.Sprintf("select c1 from %v", tableName))
+			testErr(err, t)
 			defer rows.Close()
 			testErr(err, t)
 			if rows == nil {
@@ -369,6 +398,9 @@ func testBindDefineDB(expected interface{}, t *testing.T, oct oracleColumnType)
 }
 
 func testBindPtr(expected interface{}, oct oracleColumnType, t *testing.T) {
+	testSes := getSes(t)
+	defer testSes.Close()
+
 	t.Logf("expected=%T", expected)
 	for n := 0; n < testIterations(); n++ {
 		tableName, err := createTable(1, oct, testSes)
@@ -424,8 +456,8 @@ func testBindPtr(expected interface{}, oct oracleColumnType, t *testing.T) {
 		// insert
 		qry := "insert into " + tableName + " (c1) values (:1) returning c1 into :2"
 		stmt, err := testSes.Prep(qry)
-		defer stmt.Close()
 		testErr(err, t)
+		defer stmt.Close()
 		t.Logf("%q, [%#v %T]", qry, expected, actual)
 		rowsAffected, err := stmt.Exe(expected, actual)
 		testErr(err, t)
@@ -440,15 +472,18 @@ func testBindPtr(expected interface{}, oct oracleColumnType, t *testing.T) {
 }
 
 func testMultiDefine(expected interface{}, oct oracleColumnType, t *testing.T) {
+	testSes := getSes(t)
+	defer testSes.Close()
+
 	for n := 0; n < testIterations(); n++ {
 		tableName, err := createTable(1, oct, testSes)
 		testErr(err, t)
 		defer dropTable(tableName, testSes, t)
 
 		// insert
 		insertStmt, err := testSes.Prep(fmt.Sprintf("insert into %v (c1) values (:c1)", tableName))
-		defer insertStmt.Close()
 		testErr(err, t)
+		defer insertStmt.Close()
 		rowsAffected, err := insertStmt.Exe(expected)
 		testErr(err, t)
 		if rowsAffected != 1 {
@@ -536,6 +571,9 @@ func testMultiDefine(expected interface{}, oct oracleColumnType, t *testing.T) {
 // Running the insert and query multiple times will ensure reuse of those structs.
 // Slice binding may have fewer columns tested due to OCI memory contraints.
 func testWorkload(oct oracleColumnType, t *testing.T) {
+	testSes := getSes(t)
+	defer testSes.Close()
+
 	for i := 0; i < testIterations(); i++ {
 		currentMultiple := testWorkloadColumnCount
 		for m := 0; m < 3 && currentMultiple > 0; m++ {
@@ -639,6 +677,12 @@ func testWorkload(oct oracleColumnType, t *testing.T) {
 }
 
 func loadDbtimezone() (*time.Location, error) {
+	testSes, err := testSesPool.Get()
+	if err != nil {
+		return nil, err
+	}
+	defer testSes.Close()
+
 	return testSes.Timezone()
 }
 
@@ -794,18 +838,24 @@ func createTable(multiple int, oct oracleColumnType, ses *ora.Ses) (string, erro
 func dropTable(tableName string, ses *ora.Ses, t testing.TB) {
 	qry := fmt.Sprintf("drop table %v", tableName)
 	stmt, err := ses.Prep(qry)
+	if err != nil {
+		t.Log(err)
+		return
+	}
+	//testErr(errors.Wrap(err, qry), t)
 	defer stmt.Close()
-	testErr(errors.Wrap(err, qry), t)
-	_, err = stmt.Exe()
-	testErr(errors.Wrap(err, qry), t)
+	if _, err = stmt.Exe(); err != nil {
+		t.Log(err)
+	}
+	//testErr(errors.Wrap(err, qry), t)
 }
 
 func createTableDB(db *sql.DB, t *testing.T, octs ...oracleColumnType) string {
 	tableName := tableName()
 	qry := createTableSql(tableName, 1, octs...)
 	stmt, err := db.Prepare(qry)
-	defer stmt.Close()
 	testErr(errors.Wrap(err, qry), t)
+	defer stmt.Close()
 	_, err = stmt.Exec()
 	testErr(errors.Wrap(err, qry), t)
 	return tableName
@@ -814,8 +864,8 @@ func createTableDB(db *sql.DB, t *testing.T, octs ...oracleColumnType) string {
 func dropTableDB(db *sql.DB, t *testing.T, tableName string) {
 	qry := fmt.Sprintf("drop table %v", tableName)
 	stmt, err := db.Prepare(qry)
-	defer stmt.Close()
 	testErr(errors.Wrap(err, qry), t)
+	defer stmt.Close()
 	_, err = stmt.Exec()
 	testErr(errors.Wrap(err, qry), t)
 }
@@ -851,7 +901,7 @@ func testErr(err error, t testing.TB, expectedErrs ...error) {
 		}
 	}
 	done := make(chan struct{})
-	msg := fmt.Sprintf("%v: %s", err, getStack(1))
+	msg := fmt.Sprintf("%+v: %s", err, getStack(2))
 	if true {
 		go func() {
 			select {
@@ -3608,6 +3658,9 @@ func TestStringSpaces(t *testing.T) {
 
 func TestPLSErr(t *testing.T) {
 	//enableLogging(t)
+	testSes := getSes(t)
+	defer testSes.Close()
+
 	qry := `DECLARE v_db PLS_INTEGER; BEGIN
 	  SELECT 1 INTO v_db FROM DUAL WHERE 1 = 0;
 	END;`
@@ -3642,6 +3695,9 @@ func TestGetDriverName(t *testing.T) {
 	}
 }
 func TestFloat64Prec(t *testing.T) {
+	testSes := getSes(t)
+	defer testSes.Close()
+
 	var v0 float64 = 123456789.0123456789
 	var v1 float64
 	t.Logf("v0 = %.12f = %g", v0, v0)