Updating golang dependancies (godep)

8 files changed, 0 insertions, 3977 deletions

diff --git a/Godeps/_workspace/src/github.com/lib/pq/bench_test.go b/Godeps/_workspace/src/github.com/lib/pq/bench_test.go
deleted file mode 100644
index e71f41d06..000000000
--- a/Godeps/_workspace/src/github.com/lib/pq/bench_test.go
+++ /dev/null
@@ -1,435 +0,0 @@
-// +build go1.1
-
-package pq
-
-import (
-	"bufio"
-	"bytes"
-	"database/sql"
-	"database/sql/driver"
-	"io"
-	"math/rand"
-	"net"
-	"runtime"
-	"strconv"
-	"strings"
-	"sync"
-	"testing"
-	"time"
-
-	"github.com/lib/pq/oid"
-)
-
-var (
-	selectStringQuery = "SELECT '" + strings.Repeat("0123456789", 10) + "'"
-	selectSeriesQuery = "SELECT generate_series(1, 100)"
-)
-
-func BenchmarkSelectString(b *testing.B) {
-	var result string
-	benchQuery(b, selectStringQuery, &result)
-}
-
-func BenchmarkSelectSeries(b *testing.B) {
-	var result int
-	benchQuery(b, selectSeriesQuery, &result)
-}
-
-func benchQuery(b *testing.B, query string, result interface{}) {
-	b.StopTimer()
-	db := openTestConn(b)
-	defer db.Close()
-	b.StartTimer()
-
-	for i := 0; i < b.N; i++ {
-		benchQueryLoop(b, db, query, result)
-	}
-}
-
-func benchQueryLoop(b *testing.B, db *sql.DB, query string, result interface{}) {
-	rows, err := db.Query(query)
-	if err != nil {
-		b.Fatal(err)
-	}
-	defer rows.Close()
-	for rows.Next() {
-		err = rows.Scan(result)
-		if err != nil {
-			b.Fatal("failed to scan", err)
-		}
-	}
-}
-
-// reading from circularConn yields content[:prefixLen] once, followed by
-// content[prefixLen:] over and over again. It never returns EOF.
-type circularConn struct {
-	content   string
-	prefixLen int
-	pos       int
-	net.Conn  // for all other net.Conn methods that will never be called
-}
-
-func (r *circularConn) Read(b []byte) (n int, err error) {
-	n = copy(b, r.content[r.pos:])
-	r.pos += n
-	if r.pos >= len(r.content) {
-		r.pos = r.prefixLen
-	}
-	return
-}
-
-func (r *circularConn) Write(b []byte) (n int, err error) { return len(b), nil }
-
-func (r *circularConn) Close() error { return nil }
-
-func fakeConn(content string, prefixLen int) *conn {
-	c := &circularConn{content: content, prefixLen: prefixLen}
-	return &conn{buf: bufio.NewReader(c), c: c}
-}
-
-// This benchmark is meant to be the same as BenchmarkSelectString, but takes
-// out some of the factors this package can't control. The numbers are less noisy,
-// but also the costs of network communication aren't accurately represented.
-func BenchmarkMockSelectString(b *testing.B) {
-	b.StopTimer()
-	// taken from a recorded run of BenchmarkSelectString
-	// See: http://www.postgresql.org/docs/current/static/protocol-message-formats.html
-	const response = "1\x00\x00\x00\x04" +
-		"t\x00\x00\x00\x06\x00\x00" +
-		"T\x00\x00\x00!\x00\x01?column?\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\xc1\xff\xfe\xff\xff\xff\xff\x00\x00" +
-		"Z\x00\x00\x00\x05I" +
-		"2\x00\x00\x00\x04" +
-		"D\x00\x00\x00n\x00\x01\x00\x00\x00d0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789" +
-		"C\x00\x00\x00\rSELECT 1\x00" +
-		"Z\x00\x00\x00\x05I" +
-		"3\x00\x00\x00\x04" +
-		"Z\x00\x00\x00\x05I"
-	c := fakeConn(response, 0)
-	b.StartTimer()
-
-	for i := 0; i < b.N; i++ {
-		benchMockQuery(b, c, selectStringQuery)
-	}
-}
-
-var seriesRowData = func() string {
-	var buf bytes.Buffer
-	for i := 1; i <= 100; i++ {
-		digits := byte(2)
-		if i >= 100 {
-			digits = 3
-		} else if i < 10 {
-			digits = 1
-		}
-		buf.WriteString("D\x00\x00\x00")
-		buf.WriteByte(10 + digits)
-		buf.WriteString("\x00\x01\x00\x00\x00")
-		buf.WriteByte(digits)
-		buf.WriteString(strconv.Itoa(i))
-	}
-	return buf.String()
-}()
-
-func BenchmarkMockSelectSeries(b *testing.B) {
-	b.StopTimer()
-	var response = "1\x00\x00\x00\x04" +
-		"t\x00\x00\x00\x06\x00\x00" +
-		"T\x00\x00\x00!\x00\x01?column?\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\xc1\xff\xfe\xff\xff\xff\xff\x00\x00" +
-		"Z\x00\x00\x00\x05I" +
-		"2\x00\x00\x00\x04" +
-		seriesRowData +
-		"C\x00\x00\x00\x0fSELECT 100\x00" +
-		"Z\x00\x00\x00\x05I" +
-		"3\x00\x00\x00\x04" +
-		"Z\x00\x00\x00\x05I"
-	c := fakeConn(response, 0)
-	b.StartTimer()
-
-	for i := 0; i < b.N; i++ {
-		benchMockQuery(b, c, selectSeriesQuery)
-	}
-}
-
-func benchMockQuery(b *testing.B, c *conn, query string) {
-	stmt, err := c.Prepare(query)
-	if err != nil {
-		b.Fatal(err)
-	}
-	defer stmt.Close()
-	rows, err := stmt.Query(nil)
-	if err != nil {
-		b.Fatal(err)
-	}
-	defer rows.Close()
-	var dest [1]driver.Value
-	for {
-		if err := rows.Next(dest[:]); err != nil {
-			if err == io.EOF {
-				break
-			}
-			b.Fatal(err)
-		}
-	}
-}
-
-func BenchmarkPreparedSelectString(b *testing.B) {
-	var result string
-	benchPreparedQuery(b, selectStringQuery, &result)
-}
-
-func BenchmarkPreparedSelectSeries(b *testing.B) {
-	var result int
-	benchPreparedQuery(b, selectSeriesQuery, &result)
-}
-
-func benchPreparedQuery(b *testing.B, query string, result interface{}) {
-	b.StopTimer()
-	db := openTestConn(b)
-	defer db.Close()
-	stmt, err := db.Prepare(query)
-	if err != nil {
-		b.Fatal(err)
-	}
-	defer stmt.Close()
-	b.StartTimer()
-
-	for i := 0; i < b.N; i++ {
-		benchPreparedQueryLoop(b, db, stmt, result)
-	}
-}
-
-func benchPreparedQueryLoop(b *testing.B, db *sql.DB, stmt *sql.Stmt, result interface{}) {
-	rows, err := stmt.Query()
-	if err != nil {
-		b.Fatal(err)
-	}
-	if !rows.Next() {
-		rows.Close()
-		b.Fatal("no rows")
-	}
-	defer rows.Close()
-	for rows.Next() {
-		err = rows.Scan(&result)
-		if err != nil {
-			b.Fatal("failed to scan")
-		}
-	}
-}
-
-// See the comment for BenchmarkMockSelectString.
-func BenchmarkMockPreparedSelectString(b *testing.B) {
-	b.StopTimer()
-	const parseResponse = "1\x00\x00\x00\x04" +
-		"t\x00\x00\x00\x06\x00\x00" +
-		"T\x00\x00\x00!\x00\x01?column?\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\xc1\xff\xfe\xff\xff\xff\xff\x00\x00" +
-		"Z\x00\x00\x00\x05I"
-	const responses = parseResponse +
-		"2\x00\x00\x00\x04" +
-		"D\x00\x00\x00n\x00\x01\x00\x00\x00d0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789" +
-		"C\x00\x00\x00\rSELECT 1\x00" +
-		"Z\x00\x00\x00\x05I"
-	c := fakeConn(responses, len(parseResponse))
-
-	stmt, err := c.Prepare(selectStringQuery)
-	if err != nil {
-		b.Fatal(err)
-	}
-	b.StartTimer()
-
-	for i := 0; i < b.N; i++ {
-		benchPreparedMockQuery(b, c, stmt)
-	}
-}
-
-func BenchmarkMockPreparedSelectSeries(b *testing.B) {
-	b.StopTimer()
-	const parseResponse = "1\x00\x00\x00\x04" +
-		"t\x00\x00\x00\x06\x00\x00" +
-		"T\x00\x00\x00!\x00\x01?column?\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\xc1\xff\xfe\xff\xff\xff\xff\x00\x00" +
-		"Z\x00\x00\x00\x05I"
-	var responses = parseResponse +
-		"2\x00\x00\x00\x04" +
-		seriesRowData +
-		"C\x00\x00\x00\x0fSELECT 100\x00" +
-		"Z\x00\x00\x00\x05I"
-	c := fakeConn(responses, len(parseResponse))
-
-	stmt, err := c.Prepare(selectSeriesQuery)
-	if err != nil {
-		b.Fatal(err)
-	}
-	b.StartTimer()
-
-	for i := 0; i < b.N; i++ {
-		benchPreparedMockQuery(b, c, stmt)
-	}
-}
-
-func benchPreparedMockQuery(b *testing.B, c *conn, stmt driver.Stmt) {
-	rows, err := stmt.Query(nil)
-	if err != nil {
-		b.Fatal(err)
-	}
-	defer rows.Close()
-	var dest [1]driver.Value
-	for {
-		if err := rows.Next(dest[:]); err != nil {
-			if err == io.EOF {
-				break
-			}
-			b.Fatal(err)
-		}
-	}
-}
-
-func BenchmarkEncodeInt64(b *testing.B) {
-	for i := 0; i < b.N; i++ {
-		encode(&parameterStatus{}, int64(1234), oid.T_int8)
-	}
-}
-
-func BenchmarkEncodeFloat64(b *testing.B) {
-	for i := 0; i < b.N; i++ {
-		encode(&parameterStatus{}, 3.14159, oid.T_float8)
-	}
-}
-
-var testByteString = []byte("abcdefghijklmnopqrstuvwxyz")
-
-func BenchmarkEncodeByteaHex(b *testing.B) {
-	for i := 0; i < b.N; i++ {
-		encode(&parameterStatus{serverVersion: 90000}, testByteString, oid.T_bytea)
-	}
-}
-func BenchmarkEncodeByteaEscape(b *testing.B) {
-	for i := 0; i < b.N; i++ {
-		encode(&parameterStatus{serverVersion: 84000}, testByteString, oid.T_bytea)
-	}
-}
-
-func BenchmarkEncodeBool(b *testing.B) {
-	for i := 0; i < b.N; i++ {
-		encode(&parameterStatus{}, true, oid.T_bool)
-	}
-}
-
-var testTimestamptz = time.Date(2001, time.January, 1, 0, 0, 0, 0, time.Local)
-
-func BenchmarkEncodeTimestamptz(b *testing.B) {
-	for i := 0; i < b.N; i++ {
-		encode(&parameterStatus{}, testTimestamptz, oid.T_timestamptz)
-	}
-}
-
-var testIntBytes = []byte("1234")
-
-func BenchmarkDecodeInt64(b *testing.B) {
-	for i := 0; i < b.N; i++ {
-		decode(&parameterStatus{}, testIntBytes, oid.T_int8, formatText)
-	}
-}
-
-var testFloatBytes = []byte("3.14159")
-
-func BenchmarkDecodeFloat64(b *testing.B) {
-	for i := 0; i < b.N; i++ {
-		decode(&parameterStatus{}, testFloatBytes, oid.T_float8, formatText)
-	}
-}
-
-var testBoolBytes = []byte{'t'}
-
-func BenchmarkDecodeBool(b *testing.B) {
-	for i := 0; i < b.N; i++ {
-		decode(&parameterStatus{}, testBoolBytes, oid.T_bool, formatText)
-	}
-}
-
-func TestDecodeBool(t *testing.T) {
-	db := openTestConn(t)
-	rows, err := db.Query("select true")
-	if err != nil {
-		t.Fatal(err)
-	}
-	rows.Close()
-}
-
-var testTimestamptzBytes = []byte("2013-09-17 22:15:32.360754-07")
-
-func BenchmarkDecodeTimestamptz(b *testing.B) {
-	for i := 0; i < b.N; i++ {
-		decode(&parameterStatus{}, testTimestamptzBytes, oid.T_timestamptz, formatText)
-	}
-}
-
-func BenchmarkDecodeTimestamptzMultiThread(b *testing.B) {
-	oldProcs := runtime.GOMAXPROCS(0)
-	defer runtime.GOMAXPROCS(oldProcs)
-	runtime.GOMAXPROCS(runtime.NumCPU())
-	globalLocationCache = newLocationCache()
-
-	f := func(wg *sync.WaitGroup, loops int) {
-		defer wg.Done()
-		for i := 0; i < loops; i++ {
-			decode(&parameterStatus{}, testTimestamptzBytes, oid.T_timestamptz, formatText)
-		}
-	}
-
-	wg := &sync.WaitGroup{}
-	b.ResetTimer()
-	for j := 0; j < 10; j++ {
-		wg.Add(1)
-		go f(wg, b.N/10)
-	}
-	wg.Wait()
-}
-
-func BenchmarkLocationCache(b *testing.B) {
-	globalLocationCache = newLocationCache()
-	for i := 0; i < b.N; i++ {
-		globalLocationCache.getLocation(rand.Intn(10000))
-	}
-}
-
-func BenchmarkLocationCacheMultiThread(b *testing.B) {
-	oldProcs := runtime.GOMAXPROCS(0)
-	defer runtime.GOMAXPROCS(oldProcs)
-	runtime.GOMAXPROCS(runtime.NumCPU())
-	globalLocationCache = newLocationCache()
-
-	f := func(wg *sync.WaitGroup, loops int) {
-		defer wg.Done()
-		for i := 0; i < loops; i++ {
-			globalLocationCache.getLocation(rand.Intn(10000))
-		}
-	}
-
-	wg := &sync.WaitGroup{}
-	b.ResetTimer()
-	for j := 0; j < 10; j++ {
-		wg.Add(1)
-		go f(wg, b.N/10)
-	}
-	wg.Wait()
-}
-
-// Stress test the performance of parsing results from the wire.
-func BenchmarkResultParsing(b *testing.B) {
-	b.StopTimer()
-
-	db := openTestConn(b)
-	defer db.Close()
-	_, err := db.Exec("BEGIN")
-	if err != nil {
-		b.Fatal(err)
-	}
-
-	b.StartTimer()
-	for i := 0; i < b.N; i++ {
-		res, err := db.Query("SELECT generate_series(1, 50000)")
-		if err != nil {
-			b.Fatal(err)
-		}
-		res.Close()
-	}
-}
diff --git a/Godeps/_workspace/src/github.com/lib/pq/conn_test.go b/Godeps/_workspace/src/github.com/lib/pq/conn_test.go
deleted file mode 100644
index 5cb8095a3..000000000
--- a/Godeps/_workspace/src/github.com/lib/pq/conn_test.go
+++ /dev/null
@@ -1,1359 +0,0 @@
-package pq
-
-import (
-	"database/sql"
-	"database/sql/driver"
-	"fmt"
-	"io"
-	"os"
-	"reflect"
-	"strings"
-	"testing"
-	"time"
-)
-
-type Fatalistic interface {
-	Fatal(args ...interface{})
-}
-
-func forceBinaryParameters() bool {
-	bp := os.Getenv("PQTEST_BINARY_PARAMETERS")
-	if bp == "yes" {
-		return true
-	} else if bp == "" || bp == "no" {
-		return false
-	} else {
-		panic("unexpected value for PQTEST_BINARY_PARAMETERS")
-	}
-}
-
-func openTestConnConninfo(conninfo string) (*sql.DB, error) {
-	defaultTo := func(envvar string, value string) {
-		if os.Getenv(envvar) == "" {
-			os.Setenv(envvar, value)
-		}
-	}
-	defaultTo("PGDATABASE", "pqgotest")
-	defaultTo("PGSSLMODE", "disable")
-	defaultTo("PGCONNECT_TIMEOUT", "20")
-
-	if forceBinaryParameters() &&
-		!strings.HasPrefix(conninfo, "postgres://") &&
-		!strings.HasPrefix(conninfo, "postgresql://") {
-		conninfo = conninfo + " binary_parameters=yes"
-	}
-
-	return sql.Open("postgres", conninfo)
-}
-
-func openTestConn(t Fatalistic) *sql.DB {
-	conn, err := openTestConnConninfo("")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	return conn
-}
-
-func getServerVersion(t *testing.T, db *sql.DB) int {
-	var version int
-	err := db.QueryRow("SHOW server_version_num").Scan(&version)
-	if err != nil {
-		t.Fatal(err)
-	}
-	return version
-}
-
-func TestReconnect(t *testing.T) {
-	db1 := openTestConn(t)
-	defer db1.Close()
-	tx, err := db1.Begin()
-	if err != nil {
-		t.Fatal(err)
-	}
-	var pid1 int
-	err = tx.QueryRow("SELECT pg_backend_pid()").Scan(&pid1)
-	if err != nil {
-		t.Fatal(err)
-	}
-	db2 := openTestConn(t)
-	defer db2.Close()
-	_, err = db2.Exec("SELECT pg_terminate_backend($1)", pid1)
-	if err != nil {
-		t.Fatal(err)
-	}
-	// The rollback will probably "fail" because we just killed
-	// its connection above
-	_ = tx.Rollback()
-
-	const expected int = 42
-	var result int
-	err = db1.QueryRow(fmt.Sprintf("SELECT %d", expected)).Scan(&result)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if result != expected {
-		t.Errorf("got %v; expected %v", result, expected)
-	}
-}
-
-func TestCommitInFailedTransaction(t *testing.T) {
-	db := openTestConn(t)
-	defer db.Close()
-
-	txn, err := db.Begin()
-	if err != nil {
-		t.Fatal(err)
-	}
-	rows, err := txn.Query("SELECT error")
-	if err == nil {
-		rows.Close()
-		t.Fatal("expected failure")
-	}
-	err = txn.Commit()
-	if err != ErrInFailedTransaction {
-		t.Fatalf("expected ErrInFailedTransaction; got %#v", err)
-	}
-}
-
-func TestOpenURL(t *testing.T) {
-	testURL := func(url string) {
-		db, err := openTestConnConninfo(url)
-		if err != nil {
-			t.Fatal(err)
-		}
-		defer db.Close()
-		// database/sql might not call our Open at all unless we do something with
-		// the connection
-		txn, err := db.Begin()
-		if err != nil {
-			t.Fatal(err)
-		}
-		txn.Rollback()
-	}
-	testURL("postgres://")
-	testURL("postgresql://")
-}
-
-func TestExec(t *testing.T) {
-	db := openTestConn(t)
-	defer db.Close()
-
-	_, err := db.Exec("CREATE TEMP TABLE temp (a int)")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	r, err := db.Exec("INSERT INTO temp VALUES (1)")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if n, _ := r.RowsAffected(); n != 1 {
-		t.Fatalf("expected 1 row affected, not %d", n)
-	}
-
-	r, err = db.Exec("INSERT INTO temp VALUES ($1), ($2), ($3)", 1, 2, 3)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if n, _ := r.RowsAffected(); n != 3 {
-		t.Fatalf("expected 3 rows affected, not %d", n)
-	}
-
-	// SELECT doesn't send the number of returned rows in the command tag
-	// before 9.0
-	if getServerVersion(t, db) >= 90000 {
-		r, err = db.Exec("SELECT g FROM generate_series(1, 2) g")
-		if err != nil {
-			t.Fatal(err)
-		}
-		if n, _ := r.RowsAffected(); n != 2 {
-			t.Fatalf("expected 2 rows affected, not %d", n)
-		}
-
-		r, err = db.Exec("SELECT g FROM generate_series(1, $1) g", 3)
-		if err != nil {
-			t.Fatal(err)
-		}
-		if n, _ := r.RowsAffected(); n != 3 {
-			t.Fatalf("expected 3 rows affected, not %d", n)
-		}
-	}
-}
-
-func TestStatment(t *testing.T) {
-	db := openTestConn(t)
-	defer db.Close()
-
-	st, err := db.Prepare("SELECT 1")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	st1, err := db.Prepare("SELECT 2")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	r, err := st.Query()
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer r.Close()
-
-	if !r.Next() {
-		t.Fatal("expected row")
-	}
-
-	var i int
-	err = r.Scan(&i)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if i != 1 {
-		t.Fatalf("expected 1, got %d", i)
-	}
-
-	// st1
-
-	r1, err := st1.Query()
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer r1.Close()
-
-	if !r1.Next() {
-		if r.Err() != nil {
-			t.Fatal(r1.Err())
-		}
-		t.Fatal("expected row")
-	}
-
-	err = r1.Scan(&i)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if i != 2 {
-		t.Fatalf("expected 2, got %d", i)
-	}
-}
-
-func TestRowsCloseBeforeDone(t *testing.T) {
-	db := openTestConn(t)
-	defer db.Close()
-
-	r, err := db.Query("SELECT 1")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	err = r.Close()
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if r.Next() {
-		t.Fatal("unexpected row")
-	}
-
-	if r.Err() != nil {
-		t.Fatal(r.Err())
-	}
-}
-
-func TestParameterCountMismatch(t *testing.T) {
-	db := openTestConn(t)
-	defer db.Close()
-
-	var notused int
-	err := db.QueryRow("SELECT false", 1).Scan(&notused)
-	if err == nil {
-		t.Fatal("expected err")
-	}
-	// make sure we clean up correctly
-	err = db.QueryRow("SELECT 1").Scan(&notused)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	err = db.QueryRow("SELECT $1").Scan(&notused)
-	if err == nil {
-		t.Fatal("expected err")
-	}
-	// make sure we clean up correctly
-	err = db.QueryRow("SELECT 1").Scan(&notused)
-	if err != nil {
-		t.Fatal(err)
-	}
-}
-
-// Test that EmptyQueryResponses are handled correctly.
-func TestEmptyQuery(t *testing.T) {
-	db := openTestConn(t)
-	defer db.Close()
-
-	_, err := db.Exec("")
-	if err != nil {
-		t.Fatal(err)
-	}
-	rows, err := db.Query("")
-	if err != nil {
-		t.Fatal(err)
-	}
-	cols, err := rows.Columns()
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(cols) != 0 {
-		t.Fatalf("unexpected number of columns %d in response to an empty query", len(cols))
-	}
-	if rows.Next() {
-		t.Fatal("unexpected row")
-	}
-	if rows.Err() != nil {
-		t.Fatal(rows.Err())
-	}
-
-	stmt, err := db.Prepare("")
-	if err != nil {
-		t.Fatal(err)
-	}
-	_, err = stmt.Exec()
-	if err != nil {
-		t.Fatal(err)
-	}
-	rows, err = stmt.Query()
-	if err != nil {
-		t.Fatal(err)
-	}
-	cols, err = rows.Columns()
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(cols) != 0 {
-		t.Fatalf("unexpected number of columns %d in response to an empty query", len(cols))
-	}
-	if rows.Next() {
-		t.Fatal("unexpected row")
-	}
-	if rows.Err() != nil {
-		t.Fatal(rows.Err())
-	}
-}
-
-// Test that rows.Columns() is correct even if there are no result rows.
-func TestEmptyResultSetColumns(t *testing.T) {
-	db := openTestConn(t)
-	defer db.Close()
-
-	rows, err := db.Query("SELECT 1 AS a, text 'bar' AS bar WHERE FALSE")
-	if err != nil {
-		t.Fatal(err)
-	}
-	cols, err := rows.Columns()
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(cols) != 2 {
-		t.Fatalf("unexpected number of columns %d in response to an empty query", len(cols))
-	}
-	if rows.Next() {
-		t.Fatal("unexpected row")
-	}
-	if rows.Err() != nil {
-		t.Fatal(rows.Err())
-	}
-	if cols[0] != "a" || cols[1] != "bar" {
-		t.Fatalf("unexpected Columns result %v", cols)
-	}
-
-	stmt, err := db.Prepare("SELECT $1::int AS a, text 'bar' AS bar WHERE FALSE")
-	if err != nil {
-		t.Fatal(err)
-	}
-	rows, err = stmt.Query(1)
-	if err != nil {
-		t.Fatal(err)
-	}
-	cols, err = rows.Columns()
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(cols) != 2 {
-		t.Fatalf("unexpected number of columns %d in response to an empty query", len(cols))
-	}
-	if rows.Next() {
-		t.Fatal("unexpected row")
-	}
-	if rows.Err() != nil {
-		t.Fatal(rows.Err())
-	}
-	if cols[0] != "a" || cols[1] != "bar" {
-		t.Fatalf("unexpected Columns result %v", cols)
-	}
-
-}
-
-func TestEncodeDecode(t *testing.T) {
-	db := openTestConn(t)
-	defer db.Close()
-
-	q := `
-		SELECT
-			E'\\000\\001\\002'::bytea,
-			'foobar'::text,
-			NULL::integer,
-			'2000-1-1 01:02:03.04-7'::timestamptz,
-			0::boolean,
-			123,
-			-321,
-			3.14::float8
-		WHERE
-			    E'\\000\\001\\002'::bytea = $1
-			AND 'foobar'::text = $2
-			AND $3::integer is NULL
-	`
-	// AND '2000-1-1 12:00:00.000000-7'::timestamp = $3
-
-	exp1 := []byte{0, 1, 2}
-	exp2 := "foobar"
-
-	r, err := db.Query(q, exp1, exp2, nil)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer r.Close()
-
-	if !r.Next() {
-		if r.Err() != nil {
-			t.Fatal(r.Err())
-		}
-		t.Fatal("expected row")
-	}
-
-	var got1 []byte
-	var got2 string
-	var got3 = sql.NullInt64{Valid: true}
-	var got4 time.Time
-	var got5, got6, got7, got8 interface{}
-
-	err = r.Scan(&got1, &got2, &got3, &got4, &got5, &got6, &got7, &got8)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if !reflect.DeepEqual(exp1, got1) {
-		t.Errorf("expected %q byte: %q", exp1, got1)
-	}
-
-	if !reflect.DeepEqual(exp2, got2) {
-		t.Errorf("expected %q byte: %q", exp2, got2)
-	}
-
-	if got3.Valid {
-		t.Fatal("expected invalid")
-	}
-
-	if got4.Year() != 2000 {
-		t.Fatal("wrong year")
-	}
-
-	if got5 != false {
-		t.Fatalf("expected false, got %q", got5)
-	}
-
-	if got6 != int64(123) {
-		t.Fatalf("expected 123, got %d", got6)
-	}
-
-	if got7 != int64(-321) {
-		t.Fatalf("expected -321, got %d", got7)
-	}
-
-	if got8 != float64(3.14) {
-		t.Fatalf("expected 3.14, got %f", got8)
-	}
-}
-
-func TestNoData(t *testing.T) {
-	db := openTestConn(t)
-	defer db.Close()
-
-	st, err := db.Prepare("SELECT 1 WHERE true = false")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer st.Close()
-
-	r, err := st.Query()
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer r.Close()
-
-	if r.Next() {
-		if r.Err() != nil {
-			t.Fatal(r.Err())
-		}
-		t.Fatal("unexpected row")
-	}
-
-	_, err = db.Query("SELECT * FROM nonexistenttable WHERE age=$1", 20)
-	if err == nil {
-		t.Fatal("Should have raised an error on non existent table")
-	}
-
-	_, err = db.Query("SELECT * FROM nonexistenttable")
-	if err == nil {
-		t.Fatal("Should have raised an error on non existent table")
-	}
-}
-
-func TestErrorDuringStartup(t *testing.T) {
-	// Don't use the normal connection setup, this is intended to
-	// blow up in the startup packet from a non-existent user.
-	db, err := openTestConnConninfo("user=thisuserreallydoesntexist")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer db.Close()
-
-	_, err = db.Begin()
-	if err == nil {
-		t.Fatal("expected error")
-	}
-
-	e, ok := err.(*Error)
-	if !ok {
-		t.Fatalf("expected Error, got %#v", err)
-	} else if e.Code.Name() != "invalid_authorization_specification" && e.Code.Name() != "invalid_password" {
-		t.Fatalf("expected invalid_authorization_specification or invalid_password, got %s (%+v)", e.Code.Name(), err)
-	}
-}
-
-func TestBadConn(t *testing.T) {
-	var err error
-
-	cn := conn{}
-	func() {
-		defer cn.errRecover(&err)
-		panic(io.EOF)
-	}()
-	if err != driver.ErrBadConn {
-		t.Fatalf("expected driver.ErrBadConn, got: %#v", err)
-	}
-	if !cn.bad {
-		t.Fatalf("expected cn.bad")
-	}
-
-	cn = conn{}
-	func() {
-		defer cn.errRecover(&err)
-		e := &Error{Severity: Efatal}
-		panic(e)
-	}()
-	if err != driver.ErrBadConn {
-		t.Fatalf("expected driver.ErrBadConn, got: %#v", err)
-	}
-	if !cn.bad {
-		t.Fatalf("expected cn.bad")
-	}
-}
-
-func TestErrorOnExec(t *testing.T) {
-	db := openTestConn(t)
-	defer db.Close()
-
-	txn, err := db.Begin()
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer txn.Rollback()
-
-	_, err = txn.Exec("CREATE TEMPORARY TABLE foo(f1 int PRIMARY KEY)")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	_, err = txn.Exec("INSERT INTO foo VALUES (0), (0)")
-	if err == nil {
-		t.Fatal("Should have raised error")
-	}
-
-	e, ok := err.(*Error)
-	if !ok {
-		t.Fatalf("expected Error, got %#v", err)
-	} else if e.Code.Name() != "unique_violation" {
-		t.Fatalf("expected unique_violation, got %s (%+v)", e.Code.Name(), err)
-	}
-}
-
-func TestErrorOnQuery(t *testing.T) {
-	db := openTestConn(t)
-	defer db.Close()
-
-	txn, err := db.Begin()
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer txn.Rollback()
-
-	_, err = txn.Exec("CREATE TEMPORARY TABLE foo(f1 int PRIMARY KEY)")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	_, err = txn.Query("INSERT INTO foo VALUES (0), (0)")
-	if err == nil {
-		t.Fatal("Should have raised error")
-	}
-
-	e, ok := err.(*Error)
-	if !ok {
-		t.Fatalf("expected Error, got %#v", err)
-	} else if e.Code.Name() != "unique_violation" {
-		t.Fatalf("expected unique_violation, got %s (%+v)", e.Code.Name(), err)
-	}
-}
-
-func TestErrorOnQueryRowSimpleQuery(t *testing.T) {
-	db := openTestConn(t)
-	defer db.Close()
-
-	txn, err := db.Begin()
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer txn.Rollback()
-
-	_, err = txn.Exec("CREATE TEMPORARY TABLE foo(f1 int PRIMARY KEY)")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	var v int
-	err = txn.QueryRow("INSERT INTO foo VALUES (0), (0)").Scan(&v)
-	if err == nil {
-		t.Fatal("Should have raised error")
-	}
-
-	e, ok := err.(*Error)
-	if !ok {
-		t.Fatalf("expected Error, got %#v", err)
-	} else if e.Code.Name() != "unique_violation" {
-		t.Fatalf("expected unique_violation, got %s (%+v)", e.Code.Name(), err)
-	}
-}
-
-// Test the QueryRow bug workarounds in stmt.exec() and simpleQuery()
-func TestQueryRowBugWorkaround(t *testing.T) {
-	db := openTestConn(t)
-	defer db.Close()
-
-	// stmt.exec()
-	_, err := db.Exec("CREATE TEMP TABLE notnulltemp (a varchar(10) not null)")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	var a string
-	err = db.QueryRow("INSERT INTO notnulltemp(a) values($1) RETURNING a", nil).Scan(&a)
-	if err == sql.ErrNoRows {
-		t.Fatalf("expected constraint violation error; got: %v", err)
-	}
-	pge, ok := err.(*Error)
-	if !ok {
-		t.Fatalf("expected *Error; got: %#v", err)
-	}
-	if pge.Code.Name() != "not_null_violation" {
-		t.Fatalf("expected not_null_violation; got: %s (%+v)", pge.Code.Name(), err)
-	}
-
-	// Test workaround in simpleQuery()
-	tx, err := db.Begin()
-	if err != nil {
-		t.Fatalf("unexpected error %s in Begin", err)
-	}
-	defer tx.Rollback()
-
-	_, err = tx.Exec("SET LOCAL check_function_bodies TO FALSE")
-	if err != nil {
-		t.Fatalf("could not disable check_function_bodies: %s", err)
-	}
-	_, err = tx.Exec(`
-CREATE OR REPLACE FUNCTION bad_function()
-RETURNS integer
--- hack to prevent the function from being inlined
-SET check_function_bodies TO TRUE
-AS $$
-	SELECT text 'bad'
-$$ LANGUAGE sql`)
-	if err != nil {
-		t.Fatalf("could not create function: %s", err)
-	}
-
-	err = tx.QueryRow("SELECT * FROM bad_function()").Scan(&a)
-	if err == nil {
-		t.Fatalf("expected error")
-	}
-	pge, ok = err.(*Error)
-	if !ok {
-		t.Fatalf("expected *Error; got: %#v", err)
-	}
-	if pge.Code.Name() != "invalid_function_definition" {
-		t.Fatalf("expected invalid_function_definition; got: %s (%+v)", pge.Code.Name(), err)
-	}
-
-	err = tx.Rollback()
-	if err != nil {
-		t.Fatalf("unexpected error %s in Rollback", err)
-	}
-
-	// Also test that simpleQuery()'s workaround works when the query fails
-	// after a row has been received.
-	rows, err := db.Query(`
-select
-	(select generate_series(1, ss.i))
-from (select gs.i
-      from generate_series(1, 2) gs(i)
-      order by gs.i limit 2) ss`)
-	if err != nil {
-		t.Fatalf("query failed: %s", err)
-	}
-	if !rows.Next() {
-		t.Fatalf("expected at least one result row; got %s", rows.Err())
-	}
-	var i int
-	err = rows.Scan(&i)
-	if err != nil {
-		t.Fatalf("rows.Scan() failed: %s", err)
-	}
-	if i != 1 {
-		t.Fatalf("unexpected value for i: %d", i)
-	}
-	if rows.Next() {
-		t.Fatalf("unexpected row")
-	}
-	pge, ok = rows.Err().(*Error)
-	if !ok {
-		t.Fatalf("expected *Error; got: %#v", err)
-	}
-	if pge.Code.Name() != "cardinality_violation" {
-		t.Fatalf("expected cardinality_violation; got: %s (%+v)", pge.Code.Name(), rows.Err())
-	}
-}
-
-func TestSimpleQuery(t *testing.T) {
-	db := openTestConn(t)
-	defer db.Close()
-
-	r, err := db.Query("select 1")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer r.Close()
-
-	if !r.Next() {
-		t.Fatal("expected row")
-	}
-}
-
-func TestBindError(t *testing.T) {
-	db := openTestConn(t)
-	defer db.Close()
-
-	_, err := db.Exec("create temp table test (i integer)")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	_, err = db.Query("select * from test where i=$1", "hhh")
-	if err == nil {
-		t.Fatal("expected an error")
-	}
-
-	// Should not get error here
-	r, err := db.Query("select * from test where i=$1", 1)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer r.Close()
-}
-
-func TestParseErrorInExtendedQuery(t *testing.T) {
-	db := openTestConn(t)
-	defer db.Close()
-
-	rows, err := db.Query("PARSE_ERROR $1", 1)
-	if err == nil {
-		t.Fatal("expected error")
-	}
-
-	rows, err = db.Query("SELECT 1")
-	if err != nil {
-		t.Fatal(err)
-	}
-	rows.Close()
-}
-
-// TestReturning tests that an INSERT query using the RETURNING clause returns a row.
-func TestReturning(t *testing.T) {
-	db := openTestConn(t)
-	defer db.Close()
-
-	_, err := db.Exec("CREATE TEMP TABLE distributors (did integer default 0, dname text)")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	rows, err := db.Query("INSERT INTO distributors (did, dname) VALUES (DEFAULT, 'XYZ Widgets') " +
-		"RETURNING did;")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !rows.Next() {
-		t.Fatal("no rows")
-	}
-	var did int
-	err = rows.Scan(&did)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if did != 0 {
-		t.Fatalf("bad value for did: got %d, want %d", did, 0)
-	}
-
-	if rows.Next() {
-		t.Fatal("unexpected next row")
-	}
-	err = rows.Err()
-	if err != nil {
-		t.Fatal(err)
-	}
-}
-
-func TestIssue186(t *testing.T) {
-	db := openTestConn(t)
-	defer db.Close()
-
-	// Exec() a query which returns results
-	_, err := db.Exec("VALUES (1), (2), (3)")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	_, err = db.Exec("VALUES ($1), ($2), ($3)", 1, 2, 3)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	// Query() a query which doesn't return any results
-	txn, err := db.Begin()
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer txn.Rollback()
-
-	rows, err := txn.Query("CREATE TEMP TABLE foo(f1 int)")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if err = rows.Close(); err != nil {
-		t.Fatal(err)
-	}
-
-	// small trick to get NoData from a parameterized query
-	_, err = txn.Exec("CREATE RULE nodata AS ON INSERT TO foo DO INSTEAD NOTHING")
-	if err != nil {
-		t.Fatal(err)
-	}
-	rows, err = txn.Query("INSERT INTO foo VALUES ($1)", 1)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if err = rows.Close(); err != nil {
-		t.Fatal(err)
-	}
-}
-
-func TestIssue196(t *testing.T) {
-	db := openTestConn(t)
-	defer db.Close()
-
-	row := db.QueryRow("SELECT float4 '0.10000122' = $1, float8 '35.03554004971999' = $2",
-		float32(0.10000122), float64(35.03554004971999))
-
-	var float4match, float8match bool
-	err := row.Scan(&float4match, &float8match)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !float4match {
-		t.Errorf("Expected float4 fidelity to be maintained; got no match")
-	}
-	if !float8match {
-		t.Errorf("Expected float8 fidelity to be maintained; got no match")
-	}
-}
-
-// Test that any CommandComplete messages sent before the query results are
-// ignored.
-func TestIssue282(t *testing.T) {
-	db := openTestConn(t)
-	defer db.Close()
-
-	var search_path string
-	err := db.QueryRow(`
-		SET LOCAL search_path TO pg_catalog;
-		SET LOCAL search_path TO pg_catalog;
-		SHOW search_path`).Scan(&search_path)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if search_path != "pg_catalog" {
-		t.Fatalf("unexpected search_path %s", search_path)
-	}
-}
-
-func TestReadFloatPrecision(t *testing.T) {
-	db := openTestConn(t)
-	defer db.Close()
-
-	row := db.QueryRow("SELECT float4 '0.10000122', float8 '35.03554004971999'")
-	var float4val float32
-	var float8val float64
-	err := row.Scan(&float4val, &float8val)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if float4val != float32(0.10000122) {
-		t.Errorf("Expected float4 fidelity to be maintained; got no match")
-	}
-	if float8val != float64(35.03554004971999) {
-		t.Errorf("Expected float8 fidelity to be maintained; got no match")
-	}
-}
-
-func TestXactMultiStmt(t *testing.T) {
-	// minified test case based on bug reports from
-	// pico303@gmail.com and rangelspam@gmail.com
-	t.Skip("Skipping failing test")
-	db := openTestConn(t)
-	defer db.Close()
-
-	tx, err := db.Begin()
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer tx.Commit()
-
-	rows, err := tx.Query("select 1")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if rows.Next() {
-		var val int32
-		if err = rows.Scan(&val); err != nil {
-			t.Fatal(err)
-		}
-	} else {
-		t.Fatal("Expected at least one row in first query in xact")
-	}
-
-	rows2, err := tx.Query("select 2")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if rows2.Next() {
-		var val2 int32
-		if err := rows2.Scan(&val2); err != nil {
-			t.Fatal(err)
-		}
-	} else {
-		t.Fatal("Expected at least one row in second query in xact")
-	}
-
-	if err = rows.Err(); err != nil {
-		t.Fatal(err)
-	}
-
-	if err = rows2.Err(); err != nil {
-		t.Fatal(err)
-	}
-
-	if err = tx.Commit(); err != nil {
-		t.Fatal(err)
-	}
-}
-
-var envParseTests = []struct {
-	Expected map[string]string
-	Env      []string
-}{
-	{
-		Env:      []string{"PGDATABASE=hello", "PGUSER=goodbye"},
-		Expected: map[string]string{"dbname": "hello", "user": "goodbye"},
-	},
-	{
-		Env:      []string{"PGDATESTYLE=ISO, MDY"},
-		Expected: map[string]string{"datestyle": "ISO, MDY"},
-	},
-	{
-		Env:      []string{"PGCONNECT_TIMEOUT=30"},
-		Expected: map[string]string{"connect_timeout": "30"},
-	},
-}
-
-func TestParseEnviron(t *testing.T) {
-	for i, tt := range envParseTests {
-		results := parseEnviron(tt.Env)
-		if !reflect.DeepEqual(tt.Expected, results) {
-			t.Errorf("%d: Expected: %#v Got: %#v", i, tt.Expected, results)
-		}
-	}
-}
-
-func TestParseComplete(t *testing.T) {
-	tpc := func(commandTag string, command string, affectedRows int64, shouldFail bool) {
-		defer func() {
-			if p := recover(); p != nil {
-				if !shouldFail {
-					t.Error(p)
-				}
-			}
-		}()
-		cn := &conn{}
-		res, c := cn.parseComplete(commandTag)
-		if c != command {
-			t.Errorf("Expected %v, got %v", command, c)
-		}
-		n, err := res.RowsAffected()
-		if err != nil {
-			t.Fatal(err)
-		}
-		if n != affectedRows {
-			t.Errorf("Expected %d, got %d", affectedRows, n)
-		}
-	}
-
-	tpc("ALTER TABLE", "ALTER TABLE", 0, false)
-	tpc("INSERT 0 1", "INSERT", 1, false)
-	tpc("UPDATE 100", "UPDATE", 100, false)
-	tpc("SELECT 100", "SELECT", 100, false)
-	tpc("FETCH 100", "FETCH", 100, false)
-	// allow COPY (and others) without row count
-	tpc("COPY", "COPY", 0, false)
-	// don't fail on command tags we don't recognize
-	tpc("UNKNOWNCOMMANDTAG", "UNKNOWNCOMMANDTAG", 0, false)
-
-	// failure cases
-	tpc("INSERT 1", "", 0, true)   // missing oid
-	tpc("UPDATE 0 1", "", 0, true) // too many numbers
-	tpc("SELECT foo", "", 0, true) // invalid row count
-}
-
-func TestExecerInterface(t *testing.T) {
-	// Gin up a straw man private struct just for the type check
-	cn := &conn{c: nil}
-	var cni interface{} = cn
-
-	_, ok := cni.(driver.Execer)
-	if !ok {
-		t.Fatal("Driver doesn't implement Execer")
-	}
-}
-
-func TestNullAfterNonNull(t *testing.T) {
-	db := openTestConn(t)
-	defer db.Close()
-
-	r, err := db.Query("SELECT 9::integer UNION SELECT NULL::integer")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	var n sql.NullInt64
-
-	if !r.Next() {
-		if r.Err() != nil {
-			t.Fatal(err)
-		}
-		t.Fatal("expected row")
-	}
-
-	if err := r.Scan(&n); err != nil {
-		t.Fatal(err)
-	}
-
-	if n.Int64 != 9 {
-		t.Fatalf("expected 2, not %d", n.Int64)
-	}
-
-	if !r.Next() {
-		if r.Err() != nil {
-			t.Fatal(err)
-		}
-		t.Fatal("expected row")
-	}
-
-	if err := r.Scan(&n); err != nil {
-		t.Fatal(err)
-	}
-
-	if n.Valid {
-		t.Fatal("expected n to be invalid")
-	}
-
-	if n.Int64 != 0 {
-		t.Fatalf("expected n to 2, not %d", n.Int64)
-	}
-}
-
-func Test64BitErrorChecking(t *testing.T) {
-	defer func() {
-		if err := recover(); err != nil {
-			t.Fatal("panic due to 0xFFFFFFFF != -1 " +
-				"when int is 64 bits")
-		}
-	}()
-
-	db := openTestConn(t)
-	defer db.Close()
-
-	r, err := db.Query(`SELECT *
-FROM (VALUES (0::integer, NULL::text), (1, 'test string')) AS t;`)
-
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	defer r.Close()
-
-	for r.Next() {
-	}
-}
-
-func TestCommit(t *testing.T) {
-	db := openTestConn(t)
-	defer db.Close()
-
-	_, err := db.Exec("CREATE TEMP TABLE temp (a int)")
-	if err != nil {
-		t.Fatal(err)
-	}
-	sqlInsert := "INSERT INTO temp VALUES (1)"
-	sqlSelect := "SELECT * FROM temp"
-	tx, err := db.Begin()
-	if err != nil {
-		t.Fatal(err)
-	}
-	_, err = tx.Exec(sqlInsert)
-	if err != nil {
-		t.Fatal(err)
-	}
-	err = tx.Commit()
-	if err != nil {
-		t.Fatal(err)
-	}
-	var i int
-	err = db.QueryRow(sqlSelect).Scan(&i)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if i != 1 {
-		t.Fatalf("expected 1, got %d", i)
-	}
-}
-
-func TestErrorClass(t *testing.T) {
-	db := openTestConn(t)
-	defer db.Close()
-
-	_, err := db.Query("SELECT int 'notint'")
-	if err == nil {
-		t.Fatal("expected error")
-	}
-	pge, ok := err.(*Error)
-	if !ok {
-		t.Fatalf("expected *pq.Error, got %#+v", err)
-	}
-	if pge.Code.Class() != "22" {
-		t.Fatalf("expected class 28, got %v", pge.Code.Class())
-	}
-	if pge.Code.Class().Name() != "data_exception" {
-		t.Fatalf("expected data_exception, got %v", pge.Code.Class().Name())
-	}
-}
-
-func TestParseOpts(t *testing.T) {
-	tests := []struct {
-		in       string
-		expected values
-		valid    bool
-	}{
-		{"dbname=hello user=goodbye", values{"dbname": "hello", "user": "goodbye"}, true},
-		{"dbname=hello user=goodbye  ", values{"dbname": "hello", "user": "goodbye"}, true},
-		{"dbname = hello user=goodbye", values{"dbname": "hello", "user": "goodbye"}, true},
-		{"dbname=hello user =goodbye", values{"dbname": "hello", "user": "goodbye"}, true},
-		{"dbname=hello user= goodbye", values{"dbname": "hello", "user": "goodbye"}, true},
-		{"host=localhost password='correct horse battery staple'", values{"host": "localhost", "password": "correct horse battery staple"}, true},
-		{"dbname=データベース password=パスワード", values{"dbname": "データベース", "password": "パスワード"}, true},
-		{"dbname=hello user=''", values{"dbname": "hello", "user": ""}, true},
-		{"user='' dbname=hello", values{"dbname": "hello", "user": ""}, true},
-		// The last option value is an empty string if there's no non-whitespace after its =
-		{"dbname=hello user=   ", values{"dbname": "hello", "user": ""}, true},
-
-		// The parser ignores spaces after = and interprets the next set of non-whitespace characters as the value.
-		{"user= password=foo", values{"user": "password=foo"}, true},
-
-		// Backslash escapes next char
-		{`user=a\ \'\\b`, values{"user": `a '\b`}, true},
-		{`user='a \'b'`, values{"user": `a 'b`}, true},
-
-		// Incomplete escape
-		{`user=x\`, values{}, false},
-
-		// No '=' after the key
-		{"postgre://marko@internet", values{}, false},
-		{"dbname user=goodbye", values{}, false},
-		{"user=foo blah", values{}, false},
-		{"user=foo blah   ", values{}, false},
-
-		// Unterminated quoted value
-		{"dbname=hello user='unterminated", values{}, false},
-	}
-
-	for _, test := range tests {
-		o := make(values)
-		err := parseOpts(test.in, o)
-
-		switch {
-		case err != nil && test.valid:
-			t.Errorf("%q got unexpected error: %s", test.in, err)
-		case err == nil && test.valid && !reflect.DeepEqual(test.expected, o):
-			t.Errorf("%q got: %#v want: %#v", test.in, o, test.expected)
-		case err == nil && !test.valid:
-			t.Errorf("%q expected an error", test.in)
-		}
-	}
-}
-
-func TestRuntimeParameters(t *testing.T) {
-	type RuntimeTestResult int
-	const (
-		ResultUnknown RuntimeTestResult = iota
-		ResultSuccess
-		ResultError // other error
-	)
-
-	tests := []struct {
-		conninfo        string
-		param           string
-		expected        string
-		expectedOutcome RuntimeTestResult
-	}{
-		// invalid parameter
-		{"DOESNOTEXIST=foo", "", "", ResultError},
-		// we can only work with a specific value for these two
-		{"client_encoding=SQL_ASCII", "", "", ResultError},
-		{"datestyle='ISO, YDM'", "", "", ResultError},
-		// "options" should work exactly as it does in libpq
-		{"options='-c search_path=pqgotest'", "search_path", "pqgotest", ResultSuccess},
-		// pq should override client_encoding in this case
-		{"options='-c client_encoding=SQL_ASCII'", "client_encoding", "UTF8", ResultSuccess},
-		// allow client_encoding to be set explicitly
-		{"client_encoding=UTF8", "client_encoding", "UTF8", ResultSuccess},
-		// test a runtime parameter not supported by libpq
-		{"work_mem='139kB'", "work_mem", "139kB", ResultSuccess},
-		// test fallback_application_name
-		{"application_name=foo fallback_application_name=bar", "application_name", "foo", ResultSuccess},
-		{"application_name='' fallback_application_name=bar", "application_name", "", ResultSuccess},
-		{"fallback_application_name=bar", "application_name", "bar", ResultSuccess},
-	}
-
-	for _, test := range tests {
-		db, err := openTestConnConninfo(test.conninfo)
-		if err != nil {
-			t.Fatal(err)
-		}
-
-		// application_name didn't exist before 9.0
-		if test.param == "application_name" && getServerVersion(t, db) < 90000 {
-			db.Close()
-			continue
-		}
-
-		tryGetParameterValue := func() (value string, outcome RuntimeTestResult) {
-			defer db.Close()
-			row := db.QueryRow("SELECT current_setting($1)", test.param)
-			err = row.Scan(&value)
-			if err != nil {
-				return "", ResultError
-			}
-			return value, ResultSuccess
-		}
-
-		value, outcome := tryGetParameterValue()
-		if outcome != test.expectedOutcome && outcome == ResultError {
-			t.Fatalf("%v: unexpected error: %v", test.conninfo, err)
-		}
-		if outcome != test.expectedOutcome {
-			t.Fatalf("unexpected outcome %v (was expecting %v) for conninfo \"%s\"",
-				outcome, test.expectedOutcome, test.conninfo)
-		}
-		if value != test.expected {
-			t.Fatalf("bad value for %s: got %s, want %s with conninfo \"%s\"",
-				test.param, value, test.expected, test.conninfo)
-		}
-	}
-}
-
-func TestIsUTF8(t *testing.T) {
-	var cases = []struct {
-		name string
-		want bool
-	}{
-		{"unicode", true},
-		{"utf-8", true},
-		{"utf_8", true},
-		{"UTF-8", true},
-		{"UTF8", true},
-		{"utf8", true},
-		{"u n ic_ode", true},
-		{"ut_f%8", true},
-		{"ubf8", false},
-		{"punycode", false},
-	}
-
-	for _, test := range cases {
-		if g := isUTF8(test.name); g != test.want {
-			t.Errorf("isUTF8(%q) = %v want %v", test.name, g, test.want)
-		}
-	}
-}
-
-func TestQuoteIdentifier(t *testing.T) {
-	var cases = []struct {
-		input string
-		want  string
-	}{
-		{`foo`, `"foo"`},
-		{`foo bar baz`, `"foo bar baz"`},
-		{`foo"bar`, `"foo""bar"`},
-		{"foo\x00bar", `"foo"`},
-		{"\x00foo", `""`},
-	}
-
-	for _, test := range cases {
-		got := QuoteIdentifier(test.input)
-		if got != test.want {
-			t.Errorf("QuoteIdentifier(%q) = %v want %v", test.input, got, test.want)
-		}
-	}
-}
diff --git a/Godeps/_workspace/src/github.com/lib/pq/copy_test.go b/Godeps/_workspace/src/github.com/lib/pq/copy_test.go
deleted file mode 100644
index 6af4c9c76..000000000
--- a/Godeps/_workspace/src/github.com/lib/pq/copy_test.go
+++ /dev/null
@@ -1,462 +0,0 @@
-package pq
-
-import (
-	"bytes"
-	"database/sql"
-	"strings"
-	"testing"
-)
-
-func TestCopyInStmt(t *testing.T) {
-	var stmt string
-	stmt = CopyIn("table name")
-	if stmt != `COPY "table name" () FROM STDIN` {
-		t.Fatal(stmt)
-	}
-
-	stmt = CopyIn("table name", "column 1", "column 2")
-	if stmt != `COPY "table name" ("column 1", "column 2") FROM STDIN` {
-		t.Fatal(stmt)
-	}
-
-	stmt = CopyIn(`table " name """`, `co"lumn""`)
-	if stmt != `COPY "table "" name """"""" ("co""lumn""""") FROM STDIN` {
-		t.Fatal(stmt)
-	}
-}
-
-func TestCopyInSchemaStmt(t *testing.T) {
-	var stmt string
-	stmt = CopyInSchema("schema name", "table name")
-	if stmt != `COPY "schema name"."table name" () FROM STDIN` {
-		t.Fatal(stmt)
-	}
-
-	stmt = CopyInSchema("schema name", "table name", "column 1", "column 2")
-	if stmt != `COPY "schema name"."table name" ("column 1", "column 2") FROM STDIN` {
-		t.Fatal(stmt)
-	}
-
-	stmt = CopyInSchema(`schema " name """`, `table " name """`, `co"lumn""`)
-	if stmt != `COPY "schema "" name """"""".`+
-		`"table "" name """"""" ("co""lumn""""") FROM STDIN` {
-		t.Fatal(stmt)
-	}
-}
-
-func TestCopyInMultipleValues(t *testing.T) {
-	db := openTestConn(t)
-	defer db.Close()
-
-	txn, err := db.Begin()
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer txn.Rollback()
-
-	_, err = txn.Exec("CREATE TEMP TABLE temp (a int, b varchar)")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	stmt, err := txn.Prepare(CopyIn("temp", "a", "b"))
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	longString := strings.Repeat("#", 500)
-
-	for i := 0; i < 500; i++ {
-		_, err = stmt.Exec(int64(i), longString)
-		if err != nil {
-			t.Fatal(err)
-		}
-	}
-
-	_, err = stmt.Exec()
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	err = stmt.Close()
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	var num int
-	err = txn.QueryRow("SELECT COUNT(*) FROM temp").Scan(&num)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if num != 500 {
-		t.Fatalf("expected 500 items, not %d", num)
-	}
-}
-
-func TestCopyInRaiseStmtTrigger(t *testing.T) {
-	db := openTestConn(t)
-	defer db.Close()
-
-	if getServerVersion(t, db) < 90000 {
-		var exists int
-		err := db.QueryRow("SELECT 1 FROM pg_language WHERE lanname = 'plpgsql'").Scan(&exists)
-		if err == sql.ErrNoRows {
-			t.Skip("language PL/PgSQL does not exist; skipping TestCopyInRaiseStmtTrigger")
-		} else if err != nil {
-			t.Fatal(err)
-		}
-	}
-
-	txn, err := db.Begin()
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer txn.Rollback()
-
-	_, err = txn.Exec("CREATE TEMP TABLE temp (a int, b varchar)")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	_, err = txn.Exec(`
-			CREATE OR REPLACE FUNCTION pg_temp.temptest()
-			RETURNS trigger AS 
-			$BODY$ begin
-				raise notice 'Hello world';
-				return new;
-			end $BODY$
-			LANGUAGE plpgsql`)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	_, err = txn.Exec(`
-			CREATE TRIGGER temptest_trigger
-			BEFORE INSERT
-			ON temp 
-			FOR EACH ROW
-			EXECUTE PROCEDURE pg_temp.temptest()`)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	stmt, err := txn.Prepare(CopyIn("temp", "a", "b"))
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	longString := strings.Repeat("#", 500)
-
-	_, err = stmt.Exec(int64(1), longString)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	_, err = stmt.Exec()
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	err = stmt.Close()
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	var num int
-	err = txn.QueryRow("SELECT COUNT(*) FROM temp").Scan(&num)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if num != 1 {
-		t.Fatalf("expected 1 items, not %d", num)
-	}
-}
-
-func TestCopyInTypes(t *testing.T) {
-	db := openTestConn(t)
-	defer db.Close()
-
-	txn, err := db.Begin()
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer txn.Rollback()
-
-	_, err = txn.Exec("CREATE TEMP TABLE temp (num INTEGER, text VARCHAR, blob BYTEA, nothing VARCHAR)")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	stmt, err := txn.Prepare(CopyIn("temp", "num", "text", "blob", "nothing"))
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	_, err = stmt.Exec(int64(1234567890), "Héllö\n ☃!\r\t\\", []byte{0, 255, 9, 10, 13}, nil)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	_, err = stmt.Exec()
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	err = stmt.Close()
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	var num int
-	var text string
-	var blob []byte
-	var nothing sql.NullString
-
-	err = txn.QueryRow("SELECT * FROM temp").Scan(&num, &text, &blob, &nothing)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if num != 1234567890 {
-		t.Fatal("unexpected result", num)
-	}
-	if text != "Héllö\n ☃!\r\t\\" {
-		t.Fatal("unexpected result", text)
-	}
-	if bytes.Compare(blob, []byte{0, 255, 9, 10, 13}) != 0 {
-		t.Fatal("unexpected result", blob)
-	}
-	if nothing.Valid {
-		t.Fatal("unexpected result", nothing.String)
-	}
-}
-
-func TestCopyInWrongType(t *testing.T) {
-	db := openTestConn(t)
-	defer db.Close()
-
-	txn, err := db.Begin()
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer txn.Rollback()
-
-	_, err = txn.Exec("CREATE TEMP TABLE temp (num INTEGER)")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	stmt, err := txn.Prepare(CopyIn("temp", "num"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer stmt.Close()
-
-	_, err = stmt.Exec("Héllö\n ☃!\r\t\\")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	_, err = stmt.Exec()
-	if err == nil {
-		t.Fatal("expected error")
-	}
-	if pge := err.(*Error); pge.Code.Name() != "invalid_text_representation" {
-		t.Fatalf("expected 'invalid input syntax for integer' error, got %s (%+v)", pge.Code.Name(), pge)
-	}
-}
-
-func TestCopyOutsideOfTxnError(t *testing.T) {
-	db := openTestConn(t)
-	defer db.Close()
-
-	_, err := db.Prepare(CopyIn("temp", "num"))
-	if err == nil {
-		t.Fatal("COPY outside of transaction did not return an error")
-	}
-	if err != errCopyNotSupportedOutsideTxn {
-		t.Fatalf("expected %s, got %s", err, err.Error())
-	}
-}
-
-func TestCopyInBinaryError(t *testing.T) {
-	db := openTestConn(t)
-	defer db.Close()
-
-	txn, err := db.Begin()
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer txn.Rollback()
-
-	_, err = txn.Exec("CREATE TEMP TABLE temp (num INTEGER)")
-	if err != nil {
-		t.Fatal(err)
-	}
-	_, err = txn.Prepare("COPY temp (num) FROM STDIN WITH binary")
-	if err != errBinaryCopyNotSupported {
-		t.Fatalf("expected %s, got %+v", errBinaryCopyNotSupported, err)
-	}
-	// check that the protocol is in a valid state
-	err = txn.Rollback()
-	if err != nil {
-		t.Fatal(err)
-	}
-}
-
-func TestCopyFromError(t *testing.T) {
-	db := openTestConn(t)
-	defer db.Close()
-
-	txn, err := db.Begin()
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer txn.Rollback()
-
-	_, err = txn.Exec("CREATE TEMP TABLE temp (num INTEGER)")
-	if err != nil {
-		t.Fatal(err)
-	}
-	_, err = txn.Prepare("COPY temp (num) TO STDOUT")
-	if err != errCopyToNotSupported {
-		t.Fatalf("expected %s, got %+v", errCopyToNotSupported, err)
-	}
-	// check that the protocol is in a valid state
-	err = txn.Rollback()
-	if err != nil {
-		t.Fatal(err)
-	}
-}
-
-func TestCopySyntaxError(t *testing.T) {
-	db := openTestConn(t)
-	defer db.Close()
-
-	txn, err := db.Begin()
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer txn.Rollback()
-
-	_, err = txn.Prepare("COPY ")
-	if err == nil {
-		t.Fatal("expected error")
-	}
-	if pge := err.(*Error); pge.Code.Name() != "syntax_error" {
-		t.Fatalf("expected syntax error, got %s (%+v)", pge.Code.Name(), pge)
-	}
-	// check that the protocol is in a valid state
-	err = txn.Rollback()
-	if err != nil {
-		t.Fatal(err)
-	}
-}
-
-// Tests for connection errors in copyin.resploop()
-func TestCopyRespLoopConnectionError(t *testing.T) {
-	db := openTestConn(t)
-	defer db.Close()
-
-	txn, err := db.Begin()
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer txn.Rollback()
-
-	var pid int
-	err = txn.QueryRow("SELECT pg_backend_pid()").Scan(&pid)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	_, err = txn.Exec("CREATE TEMP TABLE temp (a int)")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	stmt, err := txn.Prepare(CopyIn("temp", "a"))
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	_, err = db.Exec("SELECT pg_terminate_backend($1)", pid)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if getServerVersion(t, db) < 90500 {
-		// We have to try and send something over, since postgres before
-		// version 9.5 won't process SIGTERMs while it's waiting for
-		// CopyData/CopyEnd messages; see tcop/postgres.c.
-		_, err = stmt.Exec(1)
-		if err != nil {
-			t.Fatal(err)
-		}
-	}
-	_, err = stmt.Exec()
-	if err == nil {
-		t.Fatalf("expected error")
-	}
-	pge, ok := err.(*Error)
-	if !ok {
-		t.Fatalf("expected *pq.Error, got %+#v", err)
-	} else if pge.Code.Name() != "admin_shutdown" {
-		t.Fatalf("expected admin_shutdown, got %s", pge.Code.Name())
-	}
-
-	err = stmt.Close()
-	if err != nil {
-		t.Fatal(err)
-	}
-}
-
-func BenchmarkCopyIn(b *testing.B) {
-	db := openTestConn(b)
-	defer db.Close()
-
-	txn, err := db.Begin()
-	if err != nil {
-		b.Fatal(err)
-	}
-	defer txn.Rollback()
-
-	_, err = txn.Exec("CREATE TEMP TABLE temp (a int, b varchar)")
-	if err != nil {
-		b.Fatal(err)
-	}
-
-	stmt, err := txn.Prepare(CopyIn("temp", "a", "b"))
-	if err != nil {
-		b.Fatal(err)
-	}
-
-	for i := 0; i < b.N; i++ {
-		_, err = stmt.Exec(int64(i), "hello world!")
-		if err != nil {
-			b.Fatal(err)
-		}
-	}
-
-	_, err = stmt.Exec()
-	if err != nil {
-		b.Fatal(err)
-	}
-
-	err = stmt.Close()
-	if err != nil {
-		b.Fatal(err)
-	}
-
-	var num int
-	err = txn.QueryRow("SELECT COUNT(*) FROM temp").Scan(&num)
-	if err != nil {
-		b.Fatal(err)
-	}
-
-	if num != b.N {
-		b.Fatalf("expected %d items, not %d", b.N, num)
-	}
-}
diff --git a/Godeps/_workspace/src/github.com/lib/pq/encode_test.go b/Godeps/_workspace/src/github.com/lib/pq/encode_test.go
deleted file mode 100644
index 97b663886..000000000
--- a/Godeps/_workspace/src/github.com/lib/pq/encode_test.go
+++ /dev/null
@@ -1,719 +0,0 @@
-package pq
-
-import (
-	"bytes"
-	"database/sql"
-	"fmt"
-	"testing"
-	"time"
-
-	"github.com/lib/pq/oid"
-)
-
-func TestScanTimestamp(t *testing.T) {
-	var nt NullTime
-	tn := time.Now()
-	nt.Scan(tn)
-	if !nt.Valid {
-		t.Errorf("Expected Valid=false")
-	}
-	if nt.Time != tn {
-		t.Errorf("Time value mismatch")
-	}
-}
-
-func TestScanNilTimestamp(t *testing.T) {
-	var nt NullTime
-	nt.Scan(nil)
-	if nt.Valid {
-		t.Errorf("Expected Valid=false")
-	}
-}
-
-var timeTests = []struct {
-	str     string
-	timeval time.Time
-}{
-	{"22001-02-03", time.Date(22001, time.February, 3, 0, 0, 0, 0, time.FixedZone("", 0))},
-	{"2001-02-03", time.Date(2001, time.February, 3, 0, 0, 0, 0, time.FixedZone("", 0))},
-	{"2001-02-03 04:05:06", time.Date(2001, time.February, 3, 4, 5, 6, 0, time.FixedZone("", 0))},
-	{"2001-02-03 04:05:06.000001", time.Date(2001, time.February, 3, 4, 5, 6, 1000, time.FixedZone("", 0))},
-	{"2001-02-03 04:05:06.00001", time.Date(2001, time.February, 3, 4, 5, 6, 10000, time.FixedZone("", 0))},
-	{"2001-02-03 04:05:06.0001", time.Date(2001, time.February, 3, 4, 5, 6, 100000, time.FixedZone("", 0))},
-	{"2001-02-03 04:05:06.001", time.Date(2001, time.February, 3, 4, 5, 6, 1000000, time.FixedZone("", 0))},
-	{"2001-02-03 04:05:06.01", time.Date(2001, time.February, 3, 4, 5, 6, 10000000, time.FixedZone("", 0))},
-	{"2001-02-03 04:05:06.1", time.Date(2001, time.February, 3, 4, 5, 6, 100000000, time.FixedZone("", 0))},
-	{"2001-02-03 04:05:06.12", time.Date(2001, time.February, 3, 4, 5, 6, 120000000, time.FixedZone("", 0))},
-	{"2001-02-03 04:05:06.123", time.Date(2001, time.February, 3, 4, 5, 6, 123000000, time.FixedZone("", 0))},
-	{"2001-02-03 04:05:06.1234", time.Date(2001, time.February, 3, 4, 5, 6, 123400000, time.FixedZone("", 0))},
-	{"2001-02-03 04:05:06.12345", time.Date(2001, time.February, 3, 4, 5, 6, 123450000, time.FixedZone("", 0))},
-	{"2001-02-03 04:05:06.123456", time.Date(2001, time.February, 3, 4, 5, 6, 123456000, time.FixedZone("", 0))},
-	{"2001-02-03 04:05:06.123-07", time.Date(2001, time.February, 3, 4, 5, 6, 123000000,
-		time.FixedZone("", -7*60*60))},
-	{"2001-02-03 04:05:06-07", time.Date(2001, time.February, 3, 4, 5, 6, 0,
-		time.FixedZone("", -7*60*60))},
-	{"2001-02-03 04:05:06-07:42", time.Date(2001, time.February, 3, 4, 5, 6, 0,
-		time.FixedZone("", -(7*60*60+42*60)))},
-	{"2001-02-03 04:05:06-07:30:09", time.Date(2001, time.February, 3, 4, 5, 6, 0,
-		time.FixedZone("", -(7*60*60+30*60+9)))},
-	{"2001-02-03 04:05:06+07", time.Date(2001, time.February, 3, 4, 5, 6, 0,
-		time.FixedZone("", 7*60*60))},
-	{"0011-02-03 04:05:06 BC", time.Date(-10, time.February, 3, 4, 5, 6, 0, time.FixedZone("", 0))},
-	{"0011-02-03 04:05:06.123 BC", time.Date(-10, time.February, 3, 4, 5, 6, 123000000, time.FixedZone("", 0))},
-	{"0011-02-03 04:05:06.123-07 BC", time.Date(-10, time.February, 3, 4, 5, 6, 123000000,
-		time.FixedZone("", -7*60*60))},
-	{"0001-02-03 04:05:06.123", time.Date(1, time.February, 3, 4, 5, 6, 123000000, time.FixedZone("", 0))},
-	{"0001-02-03 04:05:06.123 BC", time.Date(1, time.February, 3, 4, 5, 6, 123000000, time.FixedZone("", 0)).AddDate(-1, 0, 0)},
-	{"0001-02-03 04:05:06.123 BC", time.Date(0, time.February, 3, 4, 5, 6, 123000000, time.FixedZone("", 0))},
-	{"0002-02-03 04:05:06.123 BC", time.Date(0, time.February, 3, 4, 5, 6, 123000000, time.FixedZone("", 0)).AddDate(-1, 0, 0)},
-	{"0002-02-03 04:05:06.123 BC", time.Date(-1, time.February, 3, 4, 5, 6, 123000000, time.FixedZone("", 0))},
-	{"12345-02-03 04:05:06.1", time.Date(12345, time.February, 3, 4, 5, 6, 100000000, time.FixedZone("", 0))},
-	{"123456-02-03 04:05:06.1", time.Date(123456, time.February, 3, 4, 5, 6, 100000000, time.FixedZone("", 0))},
-}
-
-// Helper function for the two tests below
-func tryParse(str string) (t time.Time, err error) {
-	defer func() {
-		if p := recover(); p != nil {
-			err = fmt.Errorf("%v", p)
-			return
-		}
-	}()
-	i := parseTs(nil, str)
-	t, ok := i.(time.Time)
-	if !ok {
-		err = fmt.Errorf("Not a time.Time type, got %#v", i)
-	}
-	return
-}
-
-// Test that parsing the string results in the expected value.
-func TestParseTs(t *testing.T) {
-	for i, tt := range timeTests {
-		val, err := tryParse(tt.str)
-		if err != nil {
-			t.Errorf("%d: got error: %v", i, err)
-		} else if val.String() != tt.timeval.String() {
-			t.Errorf("%d: expected to parse %q into %q; got %q",
-				i, tt.str, tt.timeval, val)
-		}
-	}
-}
-
-// Now test that sending the value into the database and parsing it back
-// returns the same time.Time value.
-func TestEncodeAndParseTs(t *testing.T) {
-	db, err := openTestConnConninfo("timezone='Etc/UTC'")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer db.Close()
-
-	for i, tt := range timeTests {
-		var dbstr string
-		err = db.QueryRow("SELECT ($1::timestamptz)::text", tt.timeval).Scan(&dbstr)
-		if err != nil {
-			t.Errorf("%d: could not send value %q to the database: %s", i, tt.timeval, err)
-			continue
-		}
-
-		val, err := tryParse(dbstr)
-		if err != nil {
-			t.Errorf("%d: could not parse value %q: %s", i, dbstr, err)
-			continue
-		}
-		val = val.In(tt.timeval.Location())
-		if val.String() != tt.timeval.String() {
-			t.Errorf("%d: expected to parse %q into %q; got %q", i, dbstr, tt.timeval, val)
-		}
-	}
-}
-
-var formatTimeTests = []struct {
-	time     time.Time
-	expected string
-}{
-	{time.Time{}, "0001-01-01T00:00:00Z"},
-	{time.Date(2001, time.February, 3, 4, 5, 6, 123456789, time.FixedZone("", 0)), "2001-02-03T04:05:06.123456789Z"},
-	{time.Date(2001, time.February, 3, 4, 5, 6, 123456789, time.FixedZone("", 2*60*60)), "2001-02-03T04:05:06.123456789+02:00"},
-	{time.Date(2001, time.February, 3, 4, 5, 6, 123456789, time.FixedZone("", -6*60*60)), "2001-02-03T04:05:06.123456789-06:00"},
-	{time.Date(2001, time.February, 3, 4, 5, 6, 0, time.FixedZone("", -(7*60*60+30*60+9))), "2001-02-03T04:05:06-07:30:09"},
-
-	{time.Date(1, time.February, 3, 4, 5, 6, 123456789, time.FixedZone("", 0)), "0001-02-03T04:05:06.123456789Z"},
-	{time.Date(1, time.February, 3, 4, 5, 6, 123456789, time.FixedZone("", 2*60*60)), "0001-02-03T04:05:06.123456789+02:00"},
-	{time.Date(1, time.February, 3, 4, 5, 6, 123456789, time.FixedZone("", -6*60*60)), "0001-02-03T04:05:06.123456789-06:00"},
-
-	{time.Date(0, time.February, 3, 4, 5, 6, 123456789, time.FixedZone("", 0)), "0001-02-03T04:05:06.123456789Z BC"},
-	{time.Date(0, time.February, 3, 4, 5, 6, 123456789, time.FixedZone("", 2*60*60)), "0001-02-03T04:05:06.123456789+02:00 BC"},
-	{time.Date(0, time.February, 3, 4, 5, 6, 123456789, time.FixedZone("", -6*60*60)), "0001-02-03T04:05:06.123456789-06:00 BC"},
-
-	{time.Date(1, time.February, 3, 4, 5, 6, 0, time.FixedZone("", -(7*60*60+30*60+9))), "0001-02-03T04:05:06-07:30:09"},
-	{time.Date(0, time.February, 3, 4, 5, 6, 0, time.FixedZone("", -(7*60*60+30*60+9))), "0001-02-03T04:05:06-07:30:09 BC"},
-}
-
-func TestFormatTs(t *testing.T) {
-	for i, tt := range formatTimeTests {
-		val := string(formatTs(tt.time))
-		if val != tt.expected {
-			t.Errorf("%d: incorrect time format %q, want %q", i, val, tt.expected)
-		}
-	}
-}
-
-func TestTimestampWithTimeZone(t *testing.T) {
-	db := openTestConn(t)
-	defer db.Close()
-
-	tx, err := db.Begin()
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer tx.Rollback()
-
-	// try several different locations, all included in Go's zoneinfo.zip
-	for _, locName := range []string{
-		"UTC",
-		"America/Chicago",
-		"America/New_York",
-		"Australia/Darwin",
-		"Australia/Perth",
-	} {
-		loc, err := time.LoadLocation(locName)
-		if err != nil {
-			t.Logf("Could not load time zone %s - skipping", locName)
-			continue
-		}
-
-		// Postgres timestamps have a resolution of 1 microsecond, so don't
-		// use the full range of the Nanosecond argument
-		refTime := time.Date(2012, 11, 6, 10, 23, 42, 123456000, loc)
-
-		for _, pgTimeZone := range []string{"US/Eastern", "Australia/Darwin"} {
-			// Switch Postgres's timezone to test different output timestamp formats
-			_, err = tx.Exec(fmt.Sprintf("set time zone '%s'", pgTimeZone))
-			if err != nil {
-				t.Fatal(err)
-			}
-
-			var gotTime time.Time
-			row := tx.QueryRow("select $1::timestamp with time zone", refTime)
-			err = row.Scan(&gotTime)
-			if err != nil {
-				t.Fatal(err)
-			}
-
-			if !refTime.Equal(gotTime) {
-				t.Errorf("timestamps not equal: %s != %s", refTime, gotTime)
-			}
-
-			// check that the time zone is set correctly based on TimeZone
-			pgLoc, err := time.LoadLocation(pgTimeZone)
-			if err != nil {
-				t.Logf("Could not load time zone %s - skipping", pgLoc)
-				continue
-			}
-			translated := refTime.In(pgLoc)
-			if translated.String() != gotTime.String() {
-				t.Errorf("timestamps not equal: %s != %s", translated, gotTime)
-			}
-		}
-	}
-}
-
-func TestTimestampWithOutTimezone(t *testing.T) {
-	db := openTestConn(t)
-	defer db.Close()
-
-	test := func(ts, pgts string) {
-		r, err := db.Query("SELECT $1::timestamp", pgts)
-		if err != nil {
-			t.Fatalf("Could not run query: %v", err)
-		}
-
-		n := r.Next()
-
-		if n != true {
-			t.Fatal("Expected at least one row")
-		}
-
-		var result time.Time
-		err = r.Scan(&result)
-		if err != nil {
-			t.Fatalf("Did not expect error scanning row: %v", err)
-		}
-
-		expected, err := time.Parse(time.RFC3339, ts)
-		if err != nil {
-			t.Fatalf("Could not parse test time literal: %v", err)
-		}
-
-		if !result.Equal(expected) {
-			t.Fatalf("Expected time to match %v: got mismatch %v",
-				expected, result)
-		}
-
-		n = r.Next()
-		if n != false {
-			t.Fatal("Expected only one row")
-		}
-	}
-
-	test("2000-01-01T00:00:00Z", "2000-01-01T00:00:00")
-
-	// Test higher precision time
-	test("2013-01-04T20:14:58.80033Z", "2013-01-04 20:14:58.80033")
-}
-
-func TestInfinityTimestamp(t *testing.T) {
-	db := openTestConn(t)
-	defer db.Close()
-	var err error
-	var resultT time.Time
-
-	expectedError := fmt.Errorf(`sql: Scan error on column index 0: unsupported driver -> Scan pair: []uint8 -> *time.Time`)
-	type testCases []struct {
-		Query       string
-		Param       string
-		ExpectedErr error
-		ExpectedVal interface{}
-	}
-	tc := testCases{
-		{"SELECT $1::timestamp", "-infinity", expectedError, "-infinity"},
-		{"SELECT $1::timestamptz", "-infinity", expectedError, "-infinity"},
-		{"SELECT $1::timestamp", "infinity", expectedError, "infinity"},
-		{"SELECT $1::timestamptz", "infinity", expectedError, "infinity"},
-	}
-	// try to assert []byte to time.Time
-	for _, q := range tc {
-		err = db.QueryRow(q.Query, q.Param).Scan(&resultT)
-		if err.Error() != q.ExpectedErr.Error() {
-			t.Errorf("Scanning -/+infinity, expected error, %q, got %q", q.ExpectedErr, err)
-		}
-	}
-	// yield []byte
-	for _, q := range tc {
-		var resultI interface{}
-		err = db.QueryRow(q.Query, q.Param).Scan(&resultI)
-		if err != nil {
-			t.Errorf("Scanning -/+infinity, expected no error, got %q", err)
-		}
-		result, ok := resultI.([]byte)
-		if !ok {
-			t.Errorf("Scanning -/+infinity, expected []byte, got %#v", resultI)
-		}
-		if string(result) != q.ExpectedVal {
-			t.Errorf("Scanning -/+infinity, expected %q, got %q", q.ExpectedVal, result)
-		}
-	}
-
-	y1500 := time.Date(1500, time.January, 1, 0, 0, 0, 0, time.UTC)
-	y2500 := time.Date(2500, time.January, 1, 0, 0, 0, 0, time.UTC)
-	EnableInfinityTs(y1500, y2500)
-
-	err = db.QueryRow("SELECT $1::timestamp", "infinity").Scan(&resultT)
-	if err != nil {
-		t.Errorf("Scanning infinity, expected no error, got %q", err)
-	}
-	if !resultT.Equal(y2500) {
-		t.Errorf("Scanning infinity, expected %q, got %q", y2500, resultT)
-	}
-
-	err = db.QueryRow("SELECT $1::timestamptz", "infinity").Scan(&resultT)
-	if err != nil {
-		t.Errorf("Scanning infinity, expected no error, got %q", err)
-	}
-	if !resultT.Equal(y2500) {
-		t.Errorf("Scanning Infinity, expected time %q, got %q", y2500, resultT.String())
-	}
-
-	err = db.QueryRow("SELECT $1::timestamp", "-infinity").Scan(&resultT)
-	if err != nil {
-		t.Errorf("Scanning -infinity, expected no error, got %q", err)
-	}
-	if !resultT.Equal(y1500) {
-		t.Errorf("Scanning -infinity, expected time %q, got %q", y1500, resultT.String())
-	}
-
-	err = db.QueryRow("SELECT $1::timestamptz", "-infinity").Scan(&resultT)
-	if err != nil {
-		t.Errorf("Scanning -infinity, expected no error, got %q", err)
-	}
-	if !resultT.Equal(y1500) {
-		t.Errorf("Scanning -infinity, expected time %q, got %q", y1500, resultT.String())
-	}
-
-	y_1500 := time.Date(-1500, time.January, 1, 0, 0, 0, 0, time.UTC)
-	y11500 := time.Date(11500, time.January, 1, 0, 0, 0, 0, time.UTC)
-	var s string
-	err = db.QueryRow("SELECT $1::timestamp::text", y_1500).Scan(&s)
-	if err != nil {
-		t.Errorf("Encoding -infinity, expected no error, got %q", err)
-	}
-	if s != "-infinity" {
-		t.Errorf("Encoding -infinity, expected %q, got %q", "-infinity", s)
-	}
-	err = db.QueryRow("SELECT $1::timestamptz::text", y_1500).Scan(&s)
-	if err != nil {
-		t.Errorf("Encoding -infinity, expected no error, got %q", err)
-	}
-	if s != "-infinity" {
-		t.Errorf("Encoding -infinity, expected %q, got %q", "-infinity", s)
-	}
-
-	err = db.QueryRow("SELECT $1::timestamp::text", y11500).Scan(&s)
-	if err != nil {
-		t.Errorf("Encoding infinity, expected no error, got %q", err)
-	}
-	if s != "infinity" {
-		t.Errorf("Encoding infinity, expected %q, got %q", "infinity", s)
-	}
-	err = db.QueryRow("SELECT $1::timestamptz::text", y11500).Scan(&s)
-	if err != nil {
-		t.Errorf("Encoding infinity, expected no error, got %q", err)
-	}
-	if s != "infinity" {
-		t.Errorf("Encoding infinity, expected %q, got %q", "infinity", s)
-	}
-
-	disableInfinityTs()
-
-	var panicErrorString string
-	func() {
-		defer func() {
-			panicErrorString, _ = recover().(string)
-		}()
-		EnableInfinityTs(y2500, y1500)
-	}()
-	if panicErrorString != infinityTsNegativeMustBeSmaller {
-		t.Errorf("Expected error, %q, got %q", infinityTsNegativeMustBeSmaller, panicErrorString)
-	}
-}
-
-func TestStringWithNul(t *testing.T) {
-	db := openTestConn(t)
-	defer db.Close()
-
-	hello0world := string("hello\x00world")
-	_, err := db.Query("SELECT $1::text", &hello0world)
-	if err == nil {
-		t.Fatal("Postgres accepts a string with nul in it; " +
-			"injection attacks may be plausible")
-	}
-}
-
-func TestByteSliceToText(t *testing.T) {
-	db := openTestConn(t)
-	defer db.Close()
-
-	b := []byte("hello world")
-	row := db.QueryRow("SELECT $1::text", b)
-
-	var result []byte
-	err := row.Scan(&result)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if string(result) != string(b) {
-		t.Fatalf("expected %v but got %v", b, result)
-	}
-}
-
-func TestStringToBytea(t *testing.T) {
-	db := openTestConn(t)
-	defer db.Close()
-
-	b := "hello world"
-	row := db.QueryRow("SELECT $1::bytea", b)
-
-	var result []byte
-	err := row.Scan(&result)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if !bytes.Equal(result, []byte(b)) {
-		t.Fatalf("expected %v but got %v", b, result)
-	}
-}
-
-func TestTextByteSliceToUUID(t *testing.T) {
-	db := openTestConn(t)
-	defer db.Close()
-
-	b := []byte("a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11")
-	row := db.QueryRow("SELECT $1::uuid", b)
-
-	var result string
-	err := row.Scan(&result)
-	if forceBinaryParameters() {
-		pqErr := err.(*Error)
-		if pqErr == nil {
-			t.Errorf("Expected to get error")
-		} else if pqErr.Code != "22P03" {
-			t.Fatalf("Expected to get invalid binary encoding error (22P03), got %s", pqErr.Code)
-		}
-	} else {
-		if err != nil {
-			t.Fatal(err)
-		}
-
-		if result != string(b) {
-			t.Fatalf("expected %v but got %v", b, result)
-		}
-	}
-}
-
-func TestBinaryByteSlicetoUUID(t *testing.T) {
-	db := openTestConn(t)
-	defer db.Close()
-
-	b := []byte{'\xa0','\xee','\xbc','\x99',
-				'\x9c', '\x0b',
-				'\x4e', '\xf8',
-				'\xbb', '\x00', '\x6b',
-				'\xb9', '\xbd', '\x38', '\x0a', '\x11'}
-	row := db.QueryRow("SELECT $1::uuid", b)
-
-	var result string
-	err := row.Scan(&result)
-	if forceBinaryParameters() {
-		if err != nil {
-			t.Fatal(err)
-		}
-
-		if result != string("a0eebc99-9c0b-4ef8-bb00-6bb9bd380a11") {
-			t.Fatalf("expected %v but got %v", b, result)
-		}
-	} else {
-		pqErr := err.(*Error)
-		if pqErr == nil {
-			t.Errorf("Expected to get error")
-		} else if pqErr.Code != "22021" {
-			t.Fatalf("Expected to get invalid byte sequence for encoding error (22021), got %s", pqErr.Code)
-		}
-	}
-}
-
-func TestStringToUUID(t *testing.T) {
-	db := openTestConn(t)
-	defer db.Close()
-
-	s := "a0eebc99-9c0b-4ef8-bb00-6bb9bd380a11"
-	row := db.QueryRow("SELECT $1::uuid", s)
-
-	var result string
-	err := row.Scan(&result)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if result != s {
-		t.Fatalf("expected %v but got %v", s, result)
-	}
-}
-
-func TestTextByteSliceToInt(t *testing.T) {
-	db := openTestConn(t)
-	defer db.Close()
-
-	expected := 12345678
-	b := []byte(fmt.Sprintf("%d", expected))
-	row := db.QueryRow("SELECT $1::int", b)
-
-	var result int
-	err := row.Scan(&result)
-	if forceBinaryParameters() {
-		pqErr := err.(*Error)
-		if pqErr == nil {
-			t.Errorf("Expected to get error")
-		} else if pqErr.Code != "22P03" {
-			t.Fatalf("Expected to get invalid binary encoding error (22P03), got %s", pqErr.Code)
-		}
-	} else {
-		if err != nil {
-			t.Fatal(err)
-		}
-		if result != expected {
-			t.Fatalf("expected %v but got %v", expected, result)
-		}
-	}
-}
-
-func TestBinaryByteSliceToInt(t *testing.T) {
-	db := openTestConn(t)
-	defer db.Close()
-
-	expected := 12345678
-	b := []byte{'\x00', '\xbc', '\x61', '\x4e'}
-	row := db.QueryRow("SELECT $1::int", b)
-
-	var result int
-	err := row.Scan(&result)
-	if forceBinaryParameters() {
-		if err != nil {
-			t.Fatal(err)
-		}
-		if result != expected {
-			t.Fatalf("expected %v but got %v", expected, result)
-		}
-	} else {
-		pqErr := err.(*Error)
-		if pqErr == nil {
-			t.Errorf("Expected to get error")
-		} else if pqErr.Code != "22021" {
-			t.Fatalf("Expected to get invalid byte sequence for encoding error (22021), got %s", pqErr.Code)
-		}
-	}
-}
-
-func TestByteaOutputFormatEncoding(t *testing.T) {
-	input := []byte("\\x\x00\x01\x02\xFF\xFEabcdefg0123")
-	want := []byte("\\x5c78000102fffe6162636465666730313233")
-	got := encode(&parameterStatus{serverVersion: 90000}, input, oid.T_bytea)
-	if !bytes.Equal(want, got) {
-		t.Errorf("invalid hex bytea output, got %v but expected %v", got, want)
-	}
-
-	want = []byte("\\\\x\\000\\001\\002\\377\\376abcdefg0123")
-	got = encode(&parameterStatus{serverVersion: 84000}, input, oid.T_bytea)
-	if !bytes.Equal(want, got) {
-		t.Errorf("invalid escape bytea output, got %v but expected %v", got, want)
-	}
-}
-
-func TestByteaOutputFormats(t *testing.T) {
-	db := openTestConn(t)
-	defer db.Close()
-
-	if getServerVersion(t, db) < 90000 {
-		// skip
-		return
-	}
-
-	testByteaOutputFormat := func(f string, usePrepared bool) {
-		expectedData := []byte("\x5c\x78\x00\xff\x61\x62\x63\x01\x08")
-		sqlQuery := "SELECT decode('5c7800ff6162630108', 'hex')"
-
-		var data []byte
-
-		// use a txn to avoid relying on getting the same connection
-		txn, err := db.Begin()
-		if err != nil {
-			t.Fatal(err)
-		}
-		defer txn.Rollback()
-
-		_, err = txn.Exec("SET LOCAL bytea_output TO " + f)
-		if err != nil {
-			t.Fatal(err)
-		}
-		var rows *sql.Rows
-		var stmt *sql.Stmt
-		if usePrepared {
-			stmt, err = txn.Prepare(sqlQuery)
-			if err != nil {
-				t.Fatal(err)
-			}
-			rows, err = stmt.Query()
-		} else {
-			// use Query; QueryRow would hide the actual error
-			rows, err = txn.Query(sqlQuery)
-		}
-		if err != nil {
-			t.Fatal(err)
-		}
-		if !rows.Next() {
-			if rows.Err() != nil {
-				t.Fatal(rows.Err())
-			}
-			t.Fatal("shouldn't happen")
-		}
-		err = rows.Scan(&data)
-		if err != nil {
-			t.Fatal(err)
-		}
-		err = rows.Close()
-		if err != nil {
-			t.Fatal(err)
-		}
-		if stmt != nil {
-			err = stmt.Close()
-			if err != nil {
-				t.Fatal(err)
-			}
-		}
-		if !bytes.Equal(data, expectedData) {
-			t.Errorf("unexpected bytea value %v for format %s; expected %v", data, f, expectedData)
-		}
-	}
-
-	testByteaOutputFormat("hex", false)
-	testByteaOutputFormat("escape", false)
-	testByteaOutputFormat("hex", true)
-	testByteaOutputFormat("escape", true)
-}
-
-func TestAppendEncodedText(t *testing.T) {
-	var buf []byte
-
-	buf = appendEncodedText(&parameterStatus{serverVersion: 90000}, buf, int64(10))
-	buf = append(buf, '\t')
-	buf = appendEncodedText(&parameterStatus{serverVersion: 90000}, buf, 42.0000000001)
-	buf = append(buf, '\t')
-	buf = appendEncodedText(&parameterStatus{serverVersion: 90000}, buf, "hello\tworld")
-	buf = append(buf, '\t')
-	buf = appendEncodedText(&parameterStatus{serverVersion: 90000}, buf, []byte{0, 128, 255})
-
-	if string(buf) != "10\t42.0000000001\thello\\tworld\t\\\\x0080ff" {
-		t.Fatal(string(buf))
-	}
-}
-
-func TestAppendEscapedText(t *testing.T) {
-	if esc := appendEscapedText(nil, "hallo\tescape"); string(esc) != "hallo\\tescape" {
-		t.Fatal(string(esc))
-	}
-	if esc := appendEscapedText(nil, "hallo\\tescape\n"); string(esc) != "hallo\\\\tescape\\n" {
-		t.Fatal(string(esc))
-	}
-	if esc := appendEscapedText(nil, "\n\r\t\f"); string(esc) != "\\n\\r\\t\f" {
-		t.Fatal(string(esc))
-	}
-}
-
-func TestAppendEscapedTextExistingBuffer(t *testing.T) {
-	var buf []byte
-	buf = []byte("123\t")
-	if esc := appendEscapedText(buf, "hallo\tescape"); string(esc) != "123\thallo\\tescape" {
-		t.Fatal(string(esc))
-	}
-	buf = []byte("123\t")
-	if esc := appendEscapedText(buf, "hallo\\tescape\n"); string(esc) != "123\thallo\\\\tescape\\n" {
-		t.Fatal(string(esc))
-	}
-	buf = []byte("123\t")
-	if esc := appendEscapedText(buf, "\n\r\t\f"); string(esc) != "123\t\\n\\r\\t\f" {
-		t.Fatal(string(esc))
-	}
-}
-
-func BenchmarkAppendEscapedText(b *testing.B) {
-	longString := ""
-	for i := 0; i < 100; i++ {
-		longString += "123456789\n"
-	}
-	for i := 0; i < b.N; i++ {
-		appendEscapedText(nil, longString)
-	}
-}
-
-func BenchmarkAppendEscapedTextNoEscape(b *testing.B) {
-	longString := ""
-	for i := 0; i < 100; i++ {
-		longString += "1234567890"
-	}
-	for i := 0; i < b.N; i++ {
-		appendEscapedText(nil, longString)
-	}
-}
diff --git a/Godeps/_workspace/src/github.com/lib/pq/hstore/hstore_test.go b/Godeps/_workspace/src/github.com/lib/pq/hstore/hstore_test.go
deleted file mode 100644
index c9c108fc3..000000000
--- a/Godeps/_workspace/src/github.com/lib/pq/hstore/hstore_test.go
+++ /dev/null
@@ -1,148 +0,0 @@
-package hstore
-
-import (
-	"database/sql"
-	"os"
-	"testing"
-
-	_ "github.com/lib/pq"
-)
-
-type Fatalistic interface {
-	Fatal(args ...interface{})
-}
-
-func openTestConn(t Fatalistic) *sql.DB {
-	datname := os.Getenv("PGDATABASE")
-	sslmode := os.Getenv("PGSSLMODE")
-
-	if datname == "" {
-		os.Setenv("PGDATABASE", "pqgotest")
-	}
-
-	if sslmode == "" {
-		os.Setenv("PGSSLMODE", "disable")
-	}
-
-	conn, err := sql.Open("postgres", "")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	return conn
-}
-
-func TestHstore(t *testing.T) {
-	db := openTestConn(t)
-	defer db.Close()
-
-	// quitely create hstore if it doesn't exist
-	_, err := db.Exec("CREATE EXTENSION IF NOT EXISTS hstore")
-	if err != nil {
-		t.Skipf("Skipping hstore tests - hstore extension create failed: %s", err.Error())
-	}
-
-	hs := Hstore{}
-
-	// test for null-valued hstores
-	err = db.QueryRow("SELECT NULL::hstore").Scan(&hs)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if hs.Map != nil {
-		t.Fatalf("expected null map")
-	}
-
-	err = db.QueryRow("SELECT $1::hstore", hs).Scan(&hs)
-	if err != nil {
-		t.Fatalf("re-query null map failed: %s", err.Error())
-	}
-	if hs.Map != nil {
-		t.Fatalf("expected null map")
-	}
-
-	// test for empty hstores
-	err = db.QueryRow("SELECT ''::hstore").Scan(&hs)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if hs.Map == nil {
-		t.Fatalf("expected empty map, got null map")
-	}
-	if len(hs.Map) != 0 {
-		t.Fatalf("expected empty map, got len(map)=%d", len(hs.Map))
-	}
-
-	err = db.QueryRow("SELECT $1::hstore", hs).Scan(&hs)
-	if err != nil {
-		t.Fatalf("re-query empty map failed: %s", err.Error())
-	}
-	if hs.Map == nil {
-		t.Fatalf("expected empty map, got null map")
-	}
-	if len(hs.Map) != 0 {
-		t.Fatalf("expected empty map, got len(map)=%d", len(hs.Map))
-	}
-
-	// a few example maps to test out
-	hsOnePair := Hstore{
-		Map: map[string]sql.NullString{
-			"key1": {"value1", true},
-		},
-	}
-
-	hsThreePairs := Hstore{
-		Map: map[string]sql.NullString{
-			"key1": {"value1", true},
-			"key2": {"value2", true},
-			"key3": {"value3", true},
-		},
-	}
-
-	hsSmorgasbord := Hstore{
-		Map: map[string]sql.NullString{
-			"nullstring":             {"NULL", true},
-			"actuallynull":           {"", false},
-			"NULL":                   {"NULL string key", true},
-			"withbracket":            {"value>42", true},
-			"withequal":              {"value=42", true},
-			`"withquotes1"`:          {`this "should" be fine`, true},
-			`"withquotes"2"`:         {`this "should\" also be fine`, true},
-			"embedded1":              {"value1=>x1", true},
-			"embedded2":              {`"value2"=>x2`, true},
-			"withnewlines":           {"\n\nvalue\t=>2", true},
-			"<<all sorts of crazy>>": {`this, "should,\" also, => be fine`, true},
-		},
-	}
-
-	// test encoding in query params, then decoding during Scan
-	testBidirectional := func(h Hstore) {
-		err = db.QueryRow("SELECT $1::hstore", h).Scan(&hs)
-		if err != nil {
-			t.Fatalf("re-query %d-pair map failed: %s", len(h.Map), err.Error())
-		}
-		if hs.Map == nil {
-			t.Fatalf("expected %d-pair map, got null map", len(h.Map))
-		}
-		if len(hs.Map) != len(h.Map) {
-			t.Fatalf("expected %d-pair map, got len(map)=%d", len(h.Map), len(hs.Map))
-		}
-
-		for key, val := range hs.Map {
-			otherval, found := h.Map[key]
-			if !found {
-				t.Fatalf("  key '%v' not found in %d-pair map", key, len(h.Map))
-			}
-			if otherval.Valid != val.Valid {
-				t.Fatalf("  value %v <> %v in %d-pair map", otherval, val, len(h.Map))
-			}
-			if otherval.String != val.String {
-				t.Fatalf("  value '%v' <> '%v' in %d-pair map", otherval.String, val.String, len(h.Map))
-			}
-		}
-	}
-
-	testBidirectional(hsOnePair)
-	testBidirectional(hsThreePairs)
-	testBidirectional(hsSmorgasbord)
-}
diff --git a/Godeps/_workspace/src/github.com/lib/pq/notify_test.go b/Godeps/_workspace/src/github.com/lib/pq/notify_test.go
deleted file mode 100644
index fe8941a4e..000000000
--- a/Godeps/_workspace/src/github.com/lib/pq/notify_test.go
+++ /dev/null
@@ -1,574 +0,0 @@
-package pq
-
-import (
-	"errors"
-	"fmt"
-	"io"
-	"os"
-	"runtime"
-	"sync"
-	"sync/atomic"
-	"testing"
-	"time"
-)
-
-var errNilNotification = errors.New("nil notification")
-
-func expectNotification(t *testing.T, ch <-chan *Notification, relname string, extra string) error {
-	select {
-	case n := <-ch:
-		if n == nil {
-			return errNilNotification
-		}
-		if n.Channel != relname || n.Extra != extra {
-			return fmt.Errorf("unexpected notification %v", n)
-		}
-		return nil
-	case <-time.After(1500 * time.Millisecond):
-		return fmt.Errorf("timeout")
-	}
-}
-
-func expectNoNotification(t *testing.T, ch <-chan *Notification) error {
-	select {
-	case n := <-ch:
-		return fmt.Errorf("unexpected notification %v", n)
-	case <-time.After(100 * time.Millisecond):
-		return nil
-	}
-}
-
-func expectEvent(t *testing.T, eventch <-chan ListenerEventType, et ListenerEventType) error {
-	select {
-	case e := <-eventch:
-		if e != et {
-			return fmt.Errorf("unexpected event %v", e)
-		}
-		return nil
-	case <-time.After(1500 * time.Millisecond):
-		panic("expectEvent timeout")
-	}
-}
-
-func expectNoEvent(t *testing.T, eventch <-chan ListenerEventType) error {
-	select {
-	case e := <-eventch:
-		return fmt.Errorf("unexpected event %v", e)
-	case <-time.After(100 * time.Millisecond):
-		return nil
-	}
-}
-
-func newTestListenerConn(t *testing.T) (*ListenerConn, <-chan *Notification) {
-	datname := os.Getenv("PGDATABASE")
-	sslmode := os.Getenv("PGSSLMODE")
-
-	if datname == "" {
-		os.Setenv("PGDATABASE", "pqgotest")
-	}
-
-	if sslmode == "" {
-		os.Setenv("PGSSLMODE", "disable")
-	}
-
-	notificationChan := make(chan *Notification)
-	l, err := NewListenerConn("", notificationChan)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	return l, notificationChan
-}
-
-func TestNewListenerConn(t *testing.T) {
-	l, _ := newTestListenerConn(t)
-
-	defer l.Close()
-}
-
-func TestConnListen(t *testing.T) {
-	l, channel := newTestListenerConn(t)
-
-	defer l.Close()
-
-	db := openTestConn(t)
-	defer db.Close()
-
-	ok, err := l.Listen("notify_test")
-	if !ok || err != nil {
-		t.Fatal(err)
-	}
-
-	_, err = db.Exec("NOTIFY notify_test")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	err = expectNotification(t, channel, "notify_test", "")
-	if err != nil {
-		t.Fatal(err)
-	}
-}
-
-func TestConnUnlisten(t *testing.T) {
-	l, channel := newTestListenerConn(t)
-
-	defer l.Close()
-
-	db := openTestConn(t)
-	defer db.Close()
-
-	ok, err := l.Listen("notify_test")
-	if !ok || err != nil {
-		t.Fatal(err)
-	}
-
-	_, err = db.Exec("NOTIFY notify_test")
-
-	err = expectNotification(t, channel, "notify_test", "")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	ok, err = l.Unlisten("notify_test")
-	if !ok || err != nil {
-		t.Fatal(err)
-	}
-
-	_, err = db.Exec("NOTIFY notify_test")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	err = expectNoNotification(t, channel)
-	if err != nil {
-		t.Fatal(err)
-	}
-}
-
-func TestConnUnlistenAll(t *testing.T) {
-	l, channel := newTestListenerConn(t)
-
-	defer l.Close()
-
-	db := openTestConn(t)
-	defer db.Close()
-
-	ok, err := l.Listen("notify_test")
-	if !ok || err != nil {
-		t.Fatal(err)
-	}
-
-	_, err = db.Exec("NOTIFY notify_test")
-
-	err = expectNotification(t, channel, "notify_test", "")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	ok, err = l.UnlistenAll()
-	if !ok || err != nil {
-		t.Fatal(err)
-	}
-
-	_, err = db.Exec("NOTIFY notify_test")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	err = expectNoNotification(t, channel)
-	if err != nil {
-		t.Fatal(err)
-	}
-}
-
-func TestConnClose(t *testing.T) {
-	l, _ := newTestListenerConn(t)
-	defer l.Close()
-
-	err := l.Close()
-	if err != nil {
-		t.Fatal(err)
-	}
-	err = l.Close()
-	if err != errListenerConnClosed {
-		t.Fatalf("expected errListenerConnClosed; got %v", err)
-	}
-}
-
-func TestConnPing(t *testing.T) {
-	l, _ := newTestListenerConn(t)
-	defer l.Close()
-	err := l.Ping()
-	if err != nil {
-		t.Fatal(err)
-	}
-	err = l.Close()
-	if err != nil {
-		t.Fatal(err)
-	}
-	err = l.Ping()
-	if err != errListenerConnClosed {
-		t.Fatalf("expected errListenerConnClosed; got %v", err)
-	}
-}
-
-// Test for deadlock where a query fails while another one is queued
-func TestConnExecDeadlock(t *testing.T) {
-	l, _ := newTestListenerConn(t)
-	defer l.Close()
-
-	var wg sync.WaitGroup
-	wg.Add(2)
-
-	go func() {
-		l.ExecSimpleQuery("SELECT pg_sleep(60)")
-		wg.Done()
-	}()
-	runtime.Gosched()
-	go func() {
-		l.ExecSimpleQuery("SELECT 1")
-		wg.Done()
-	}()
-	// give the two goroutines some time to get into position
-	runtime.Gosched()
-	// calls Close on the net.Conn; equivalent to a network failure
-	l.Close()
-
-	var done int32 = 0
-	go func() {
-		time.Sleep(10 * time.Second)
-		if atomic.LoadInt32(&done) != 1 {
-			panic("timed out")
-		}
-	}()
-	wg.Wait()
-	atomic.StoreInt32(&done, 1)
-}
-
-// Test for ListenerConn being closed while a slow query is executing
-func TestListenerConnCloseWhileQueryIsExecuting(t *testing.T) {
-	l, _ := newTestListenerConn(t)
-	defer l.Close()
-
-	var wg sync.WaitGroup
-	wg.Add(1)
-
-	go func() {
-		sent, err := l.ExecSimpleQuery("SELECT pg_sleep(60)")
-		if sent {
-			panic("expected sent=false")
-		}
-		// could be any of a number of errors
-		if err == nil {
-			panic("expected error")
-		}
-		wg.Done()
-	}()
-	// give the above goroutine some time to get into position
-	runtime.Gosched()
-	err := l.Close()
-	if err != nil {
-		t.Fatal(err)
-	}
-	var done int32 = 0
-	go func() {
-		time.Sleep(10 * time.Second)
-		if atomic.LoadInt32(&done) != 1 {
-			panic("timed out")
-		}
-	}()
-	wg.Wait()
-	atomic.StoreInt32(&done, 1)
-}
-
-func TestNotifyExtra(t *testing.T) {
-	db := openTestConn(t)
-	defer db.Close()
-
-	if getServerVersion(t, db) < 90000 {
-		t.Skip("skipping NOTIFY payload test since the server does not appear to support it")
-	}
-
-	l, channel := newTestListenerConn(t)
-	defer l.Close()
-
-	ok, err := l.Listen("notify_test")
-	if !ok || err != nil {
-		t.Fatal(err)
-	}
-
-	_, err = db.Exec("NOTIFY notify_test, 'something'")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	err = expectNotification(t, channel, "notify_test", "something")
-	if err != nil {
-		t.Fatal(err)
-	}
-}
-
-// create a new test listener and also set the timeouts
-func newTestListenerTimeout(t *testing.T, min time.Duration, max time.Duration) (*Listener, <-chan ListenerEventType) {
-	datname := os.Getenv("PGDATABASE")
-	sslmode := os.Getenv("PGSSLMODE")
-
-	if datname == "" {
-		os.Setenv("PGDATABASE", "pqgotest")
-	}
-
-	if sslmode == "" {
-		os.Setenv("PGSSLMODE", "disable")
-	}
-
-	eventch := make(chan ListenerEventType, 16)
-	l := NewListener("", min, max, func(t ListenerEventType, err error) { eventch <- t })
-	err := expectEvent(t, eventch, ListenerEventConnected)
-	if err != nil {
-		t.Fatal(err)
-	}
-	return l, eventch
-}
-
-func newTestListener(t *testing.T) (*Listener, <-chan ListenerEventType) {
-	return newTestListenerTimeout(t, time.Hour, time.Hour)
-}
-
-func TestListenerListen(t *testing.T) {
-	l, _ := newTestListener(t)
-	defer l.Close()
-
-	db := openTestConn(t)
-	defer db.Close()
-
-	err := l.Listen("notify_listen_test")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	_, err = db.Exec("NOTIFY notify_listen_test")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	err = expectNotification(t, l.Notify, "notify_listen_test", "")
-	if err != nil {
-		t.Fatal(err)
-	}
-}
-
-func TestListenerUnlisten(t *testing.T) {
-	l, _ := newTestListener(t)
-	defer l.Close()
-
-	db := openTestConn(t)
-	defer db.Close()
-
-	err := l.Listen("notify_listen_test")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	_, err = db.Exec("NOTIFY notify_listen_test")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	err = l.Unlisten("notify_listen_test")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	err = expectNotification(t, l.Notify, "notify_listen_test", "")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	_, err = db.Exec("NOTIFY notify_listen_test")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	err = expectNoNotification(t, l.Notify)
-	if err != nil {
-		t.Fatal(err)
-	}
-}
-
-func TestListenerUnlistenAll(t *testing.T) {
-	l, _ := newTestListener(t)
-	defer l.Close()
-
-	db := openTestConn(t)
-	defer db.Close()
-
-	err := l.Listen("notify_listen_test")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	_, err = db.Exec("NOTIFY notify_listen_test")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	err = l.UnlistenAll()
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	err = expectNotification(t, l.Notify, "notify_listen_test", "")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	_, err = db.Exec("NOTIFY notify_listen_test")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	err = expectNoNotification(t, l.Notify)
-	if err != nil {
-		t.Fatal(err)
-	}
-}
-
-func TestListenerFailedQuery(t *testing.T) {
-	l, eventch := newTestListener(t)
-	defer l.Close()
-
-	db := openTestConn(t)
-	defer db.Close()
-
-	err := l.Listen("notify_listen_test")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	_, err = db.Exec("NOTIFY notify_listen_test")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	err = expectNotification(t, l.Notify, "notify_listen_test", "")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	// shouldn't cause a disconnect
-	ok, err := l.cn.ExecSimpleQuery("SELECT error")
-	if !ok {
-		t.Fatalf("could not send query to server: %v", err)
-	}
-	_, ok = err.(PGError)
-	if !ok {
-		t.Fatalf("unexpected error %v", err)
-	}
-	err = expectNoEvent(t, eventch)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	// should still work
-	_, err = db.Exec("NOTIFY notify_listen_test")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	err = expectNotification(t, l.Notify, "notify_listen_test", "")
-	if err != nil {
-		t.Fatal(err)
-	}
-}
-
-func TestListenerReconnect(t *testing.T) {
-	l, eventch := newTestListenerTimeout(t, 20*time.Millisecond, time.Hour)
-	defer l.Close()
-
-	db := openTestConn(t)
-	defer db.Close()
-
-	err := l.Listen("notify_listen_test")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	_, err = db.Exec("NOTIFY notify_listen_test")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	err = expectNotification(t, l.Notify, "notify_listen_test", "")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	// kill the connection and make sure it comes back up
-	ok, err := l.cn.ExecSimpleQuery("SELECT pg_terminate_backend(pg_backend_pid())")
-	if ok {
-		t.Fatalf("could not kill the connection: %v", err)
-	}
-	if err != io.EOF {
-		t.Fatalf("unexpected error %v", err)
-	}
-	err = expectEvent(t, eventch, ListenerEventDisconnected)
-	if err != nil {
-		t.Fatal(err)
-	}
-	err = expectEvent(t, eventch, ListenerEventReconnected)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	// should still work
-	_, err = db.Exec("NOTIFY notify_listen_test")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	// should get nil after Reconnected
-	err = expectNotification(t, l.Notify, "", "")
-	if err != errNilNotification {
-		t.Fatal(err)
-	}
-
-	err = expectNotification(t, l.Notify, "notify_listen_test", "")
-	if err != nil {
-		t.Fatal(err)
-	}
-}
-
-func TestListenerClose(t *testing.T) {
-	l, _ := newTestListenerTimeout(t, 20*time.Millisecond, time.Hour)
-	defer l.Close()
-
-	err := l.Close()
-	if err != nil {
-		t.Fatal(err)
-	}
-	err = l.Close()
-	if err != errListenerClosed {
-		t.Fatalf("expected errListenerClosed; got %v", err)
-	}
-}
-
-func TestListenerPing(t *testing.T) {
-	l, _ := newTestListenerTimeout(t, 20*time.Millisecond, time.Hour)
-	defer l.Close()
-
-	err := l.Ping()
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	err = l.Close()
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	err = l.Ping()
-	if err != errListenerClosed {
-		t.Fatalf("expected errListenerClosed; got %v", err)
-	}
-}
diff --git a/Godeps/_workspace/src/github.com/lib/pq/ssl_test.go b/Godeps/_workspace/src/github.com/lib/pq/ssl_test.go
deleted file mode 100644
index 932b336f5..000000000
--- a/Godeps/_workspace/src/github.com/lib/pq/ssl_test.go
+++ /dev/null
@@ -1,226 +0,0 @@
-package pq
-
-// This file contains SSL tests
-
-import (
-	_ "crypto/sha256"
-	"crypto/x509"
-	"database/sql"
-	"fmt"
-	"os"
-	"path/filepath"
-	"testing"
-)
-
-func maybeSkipSSLTests(t *testing.T) {
-	// Require some special variables for testing certificates
-	if os.Getenv("PQSSLCERTTEST_PATH") == "" {
-		t.Skip("PQSSLCERTTEST_PATH not set, skipping SSL tests")
-	}
-
-	value := os.Getenv("PQGOSSLTESTS")
-	if value == "" || value == "0" {
-		t.Skip("PQGOSSLTESTS not enabled, skipping SSL tests")
-	} else if value != "1" {
-		t.Fatalf("unexpected value %q for PQGOSSLTESTS", value)
-	}
-}
-
-func openSSLConn(t *testing.T, conninfo string) (*sql.DB, error) {
-	db, err := openTestConnConninfo(conninfo)
-	if err != nil {
-		// should never fail
-		t.Fatal(err)
-	}
-	// Do something with the connection to see whether it's working or not.
-	tx, err := db.Begin()
-	if err == nil {
-		return db, tx.Rollback()
-	}
-	_ = db.Close()
-	return nil, err
-}
-
-func checkSSLSetup(t *testing.T, conninfo string) {
-	db, err := openSSLConn(t, conninfo)
-	if err == nil {
-		db.Close()
-		t.Fatalf("expected error with conninfo=%q", conninfo)
-	}
-}
-
-// Connect over SSL and run a simple query to test the basics
-func TestSSLConnection(t *testing.T) {
-	maybeSkipSSLTests(t)
-	// Environment sanity check: should fail without SSL
-	checkSSLSetup(t, "sslmode=disable user=pqgossltest")
-
-	db, err := openSSLConn(t, "sslmode=require user=pqgossltest")
-	if err != nil {
-		t.Fatal(err)
-	}
-	rows, err := db.Query("SELECT 1")
-	if err != nil {
-		t.Fatal(err)
-	}
-	rows.Close()
-}
-
-// Test sslmode=verify-full
-func TestSSLVerifyFull(t *testing.T) {
-	maybeSkipSSLTests(t)
-	// Environment sanity check: should fail without SSL
-	checkSSLSetup(t, "sslmode=disable user=pqgossltest")
-
-	// Not OK according to the system CA
-	_, err := openSSLConn(t, "host=postgres sslmode=verify-full user=pqgossltest")
-	if err == nil {
-		t.Fatal("expected error")
-	}
-	_, ok := err.(x509.UnknownAuthorityError)
-	if !ok {
-		t.Fatalf("expected x509.UnknownAuthorityError, got %#+v", err)
-	}
-
-	rootCertPath := filepath.Join(os.Getenv("PQSSLCERTTEST_PATH"), "root.crt")
-	rootCert := "sslrootcert=" + rootCertPath + " "
-	// No match on Common Name
-	_, err = openSSLConn(t, rootCert+"host=127.0.0.1 sslmode=verify-full user=pqgossltest")
-	if err == nil {
-		t.Fatal("expected error")
-	}
-	_, ok = err.(x509.HostnameError)
-	if !ok {
-		t.Fatalf("expected x509.HostnameError, got %#+v", err)
-	}
-	// OK
-	_, err = openSSLConn(t, rootCert+"host=postgres sslmode=verify-full user=pqgossltest")
-	if err != nil {
-		t.Fatal(err)
-	}
-}
-
-// Test sslmode=verify-ca
-func TestSSLVerifyCA(t *testing.T) {
-	maybeSkipSSLTests(t)
-	// Environment sanity check: should fail without SSL
-	checkSSLSetup(t, "sslmode=disable user=pqgossltest")
-
-	// Not OK according to the system CA
-	_, err := openSSLConn(t, "host=postgres sslmode=verify-ca user=pqgossltest")
-	if err == nil {
-		t.Fatal("expected error")
-	}
-	_, ok := err.(x509.UnknownAuthorityError)
-	if !ok {
-		t.Fatalf("expected x509.UnknownAuthorityError, got %#+v", err)
-	}
-
-	rootCertPath := filepath.Join(os.Getenv("PQSSLCERTTEST_PATH"), "root.crt")
-	rootCert := "sslrootcert=" + rootCertPath + " "
-	// No match on Common Name, but that's OK
-	_, err = openSSLConn(t, rootCert+"host=127.0.0.1 sslmode=verify-ca user=pqgossltest")
-	if err != nil {
-		t.Fatal(err)
-	}
-	// Everything OK
-	_, err = openSSLConn(t, rootCert+"host=postgres sslmode=verify-ca user=pqgossltest")
-	if err != nil {
-		t.Fatal(err)
-	}
-}
-
-func getCertConninfo(t *testing.T, source string) string {
-	var sslkey string
-	var sslcert string
-
-	certpath := os.Getenv("PQSSLCERTTEST_PATH")
-
-	switch source {
-	case "missingkey":
-		sslkey = "/tmp/filedoesnotexist"
-		sslcert = filepath.Join(certpath, "postgresql.crt")
-	case "missingcert":
-		sslkey = filepath.Join(certpath, "postgresql.key")
-		sslcert = "/tmp/filedoesnotexist"
-	case "certtwice":
-		sslkey = filepath.Join(certpath, "postgresql.crt")
-		sslcert = filepath.Join(certpath, "postgresql.crt")
-	case "valid":
-		sslkey = filepath.Join(certpath, "postgresql.key")
-		sslcert = filepath.Join(certpath, "postgresql.crt")
-	default:
-		t.Fatalf("invalid source %q", source)
-	}
-	return fmt.Sprintf("sslmode=require user=pqgosslcert sslkey=%s sslcert=%s", sslkey, sslcert)
-}
-
-// Authenticate over SSL using client certificates
-func TestSSLClientCertificates(t *testing.T) {
-	maybeSkipSSLTests(t)
-	// Environment sanity check: should fail without SSL
-	checkSSLSetup(t, "sslmode=disable user=pqgossltest")
-
-	// Should also fail without a valid certificate
-	db, err := openSSLConn(t, "sslmode=require user=pqgosslcert")
-	if err == nil {
-		db.Close()
-		t.Fatal("expected error")
-	}
-	pge, ok := err.(*Error)
-	if !ok {
-		t.Fatal("expected pq.Error")
-	}
-	if pge.Code.Name() != "invalid_authorization_specification" {
-		t.Fatalf("unexpected error code %q", pge.Code.Name())
-	}
-
-	// Should work
-	db, err = openSSLConn(t, getCertConninfo(t, "valid"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	rows, err := db.Query("SELECT 1")
-	if err != nil {
-		t.Fatal(err)
-	}
-	rows.Close()
-}
-
-// Test errors with ssl certificates
-func TestSSLClientCertificatesMissingFiles(t *testing.T) {
-	maybeSkipSSLTests(t)
-	// Environment sanity check: should fail without SSL
-	checkSSLSetup(t, "sslmode=disable user=pqgossltest")
-
-	// Key missing, should fail
-	_, err := openSSLConn(t, getCertConninfo(t, "missingkey"))
-	if err == nil {
-		t.Fatal("expected error")
-	}
-	// should be a PathError
-	_, ok := err.(*os.PathError)
-	if !ok {
-		t.Fatalf("expected PathError, got %#+v", err)
-	}
-
-	// Cert missing, should fail
-	_, err = openSSLConn(t, getCertConninfo(t, "missingcert"))
-	if err == nil {
-		t.Fatal("expected error")
-	}
-	// should be a PathError
-	_, ok = err.(*os.PathError)
-	if !ok {
-		t.Fatalf("expected PathError, got %#+v", err)
-	}
-
-	// Key has wrong permissions, should fail
-	_, err = openSSLConn(t, getCertConninfo(t, "certtwice"))
-	if err == nil {
-		t.Fatal("expected error")
-	}
-	if err != ErrSSLKeyHasWorldPermissions {
-		t.Fatalf("expected ErrSSLKeyHasWorldPermissions, got %#+v", err)
-	}
-}
diff --git a/Godeps/_workspace/src/github.com/lib/pq/url_test.go b/Godeps/_workspace/src/github.com/lib/pq/url_test.go
deleted file mode 100644
index 29f4a7c75..000000000
--- a/Godeps/_workspace/src/github.com/lib/pq/url_test.go
+++ /dev/null
@@ -1,54 +0,0 @@
-package pq
-
-import (
-	"testing"
-)
-
-func TestSimpleParseURL(t *testing.T) {
-	expected := "host=hostname.remote"
-	str, err := ParseURL("postgres://hostname.remote")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if str != expected {
-		t.Fatalf("unexpected result from ParseURL:\n+ %v\n- %v", str, expected)
-	}
-}
-
-func TestFullParseURL(t *testing.T) {
-	expected := `dbname=database host=hostname.remote password=top\ secret port=1234 user=username`
-	str, err := ParseURL("postgres://username:top%20secret@hostname.remote:1234/database")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if str != expected {
-		t.Fatalf("unexpected result from ParseURL:\n+ %s\n- %s", str, expected)
-	}
-}
-
-func TestInvalidProtocolParseURL(t *testing.T) {
-	_, err := ParseURL("http://hostname.remote")
-	switch err {
-	case nil:
-		t.Fatal("Expected an error from parsing invalid protocol")
-	default:
-		msg := "invalid connection protocol: http"
-		if err.Error() != msg {
-			t.Fatalf("Unexpected error message:\n+ %s\n- %s",
-				err.Error(), msg)
-		}
-	}
-}
-
-func TestMinimalURL(t *testing.T) {
-	cs, err := ParseURL("postgres://")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if cs != "" {
-		t.Fatalf("expected blank connection string, got: %q", cs)
-	}
-}