diff --git a/extended_query_builder.go b/extended_query_builder.go
index 36447c99..34662eb1 100644
--- a/extended_query_builder.go
+++ b/extended_query_builder.go
@@ -71,40 +71,12 @@ func (eqb *extendedQueryBuilder) encodeExtendedParamValue(ci *pgtype.ConnInfo, o
 		eqb.paramValueBytes = make([]byte, 0, 128)
 	}
 
-	var err error
-	var buf []byte
 	pos := len(eqb.paramValueBytes)
 
 	if arg, ok := arg.(string); ok {
 		return []byte(arg), nil
 	}
 
-	if formatCode == TextFormatCode {
-		if arg, ok := arg.(pgtype.TextEncoder); ok {
-			buf, err = arg.EncodeText(ci, eqb.paramValueBytes)
-			if err != nil {
-				return nil, err
-			}
-			if buf == nil {
-				return nil, nil
-			}
-			eqb.paramValueBytes = buf
-			return eqb.paramValueBytes[pos:], nil
-		}
-	} else if formatCode == BinaryFormatCode {
-		if arg, ok := arg.(pgtype.BinaryEncoder); ok {
-			buf, err = arg.EncodeBinary(ci, eqb.paramValueBytes)
-			if err != nil {
-				return nil, err
-			}
-			if buf == nil {
-				return nil, nil
-			}
-			eqb.paramValueBytes = buf
-			return eqb.paramValueBytes[pos:], nil
-		}
-	}
-
 	if argIsPtr {
 		// We have already checked that arg is not pointing to nil,
 		// so it is safe to dereference here.
@@ -143,28 +115,6 @@ func (eqb *extendedQueryBuilder) encodeExtendedParamValue(ci *pgtype.ConnInfo, o
 		}
 	}
 
-	// There is no data type registered for the destination OID, but maybe there is data type registered for the arg
-	// type. If so use it's text encoder (if available).
-	if dt, ok := ci.DataTypeForValue(arg); ok {
-		value := dt.Value
-		if textEncoder, ok := value.(pgtype.TextEncoder); ok {
-			err := value.Set(arg)
-			if err != nil {
-				return nil, err
-			}
-
-			buf, err = textEncoder.EncodeText(ci, eqb.paramValueBytes)
-			if err != nil {
-				return nil, err
-			}
-			if buf == nil {
-				return nil, nil
-			}
-			eqb.paramValueBytes = buf
-			return eqb.paramValueBytes[pos:], nil
-		}
-	}
-
 	if strippedArg, ok := stripNamedType(&refVal); ok {
 		return eqb.encodeExtendedParamValue(ci, oid, formatCode, strippedArg)
 	}
diff --git a/messages.go b/messages.go
index 87c0aa22..01ece44e 100644
--- a/messages.go
+++ b/messages.go
@@ -2,15 +2,11 @@ package pgx
 
 import (
 	"database/sql/driver"
-
-	"github.com/jackc/pgx/v5/pgtype"
 )
 
 func convertDriverValuers(args []interface{}) ([]interface{}, error) {
 	for i, arg := range args {
 		switch arg := arg.(type) {
-		case pgtype.BinaryEncoder:
-		case pgtype.TextEncoder:
 		case driver.Valuer:
 			v, err := callValuerValue(arg)
 			if err != nil {
diff --git a/pgtype/bits_test.go b/pgtype/bits_test.go
index a585ef8b..5a82743c 100644
--- a/pgtype/bits_test.go
+++ b/pgtype/bits_test.go
@@ -17,7 +17,7 @@ func isExpectedEqBits(a interface{}) func(interface{}) bool {
 }
 
 func TestBitsCodecBit(t *testing.T) {
-	testPgxCodec(t, "bit(40)", []PgxTranscodeTestCase{
+	testutil.RunTranscodeTests(t, "bit(40)", []testutil.TranscodeTestCase{
 		{
 			pgtype.Bits{Bytes: []byte{0, 0, 0, 0, 0}, Len: 40, Valid: true},
 			new(pgtype.Bits),
@@ -34,7 +34,7 @@ func TestBitsCodecBit(t *testing.T) {
 }
 
 func TestBitsCodecVarbit(t *testing.T) {
-	testPgxCodec(t, "varbit", []PgxTranscodeTestCase{
+	testutil.RunTranscodeTests(t, "varbit", []testutil.TranscodeTestCase{
 		{
 			pgtype.Bits{Bytes: []byte{}, Len: 0, Valid: true},
 			new(pgtype.Bits),
@@ -54,12 +54,3 @@ func TestBitsCodecVarbit(t *testing.T) {
 		{nil, new(pgtype.Bits), isExpectedEqBits(pgtype.Bits{})},
 	})
 }
-
-func TestBitsNormalize(t *testing.T) {
-	testutil.TestSuccessfulNormalize(t, []testutil.NormalizeTest{
-		{
-			SQL:   "select B'111111111'",
-			Value: &pgtype.Bits{Bytes: []byte{255, 128}, Len: 9, Valid: true},
-		},
-	})
-}
diff --git a/pgtype/bool_test.go b/pgtype/bool_test.go
index ec8c31d9..57094144 100644
--- a/pgtype/bool_test.go
+++ b/pgtype/bool_test.go
@@ -4,10 +4,11 @@ import (
 	"testing"
 
 	"github.com/jackc/pgx/v5/pgtype"
+	"github.com/jackc/pgx/v5/pgtype/testutil"
 )
 
 func TestBoolCodec(t *testing.T) {
-	testPgxCodec(t, "bool", []PgxTranscodeTestCase{
+	testutil.RunTranscodeTests(t, "bool", []testutil.TranscodeTestCase{
 		{true, new(bool), isExpectedEq(true)},
 		{false, new(bool), isExpectedEq(false)},
 		{true, new(pgtype.Bool), isExpectedEq(pgtype.Bool{Bool: true, Valid: true})},
diff --git a/pgtype/box_test.go b/pgtype/box_test.go
index 8056e819..72e37b76 100644
--- a/pgtype/box_test.go
+++ b/pgtype/box_test.go
@@ -8,7 +8,7 @@ import (
 )
 
 func TestBoxCodec(t *testing.T) {
-	testPgxCodec(t, "box", []PgxTranscodeTestCase{
+	testutil.RunTranscodeTests(t, "box", []testutil.TranscodeTestCase{
 		{
 			pgtype.Box{
 				P:     [2]pgtype.Vec2{{7.1, 5.2345678}, {3.14, 1.678}},
@@ -35,15 +35,3 @@ func TestBoxCodec(t *testing.T) {
 		{nil, new(pgtype.Box), isExpectedEq(pgtype.Box{})},
 	})
 }
-
-func TestBoxNormalize(t *testing.T) {
-	testutil.TestSuccessfulNormalize(t, []testutil.NormalizeTest{
-		{
-			SQL: "select '3.14, 1.678, 7.1, 5.234'::box",
-			Value: &pgtype.Box{
-				P:     [2]pgtype.Vec2{{7.1, 5.234}, {3.14, 1.678}},
-				Valid: true,
-			},
-		},
-	})
-}
diff --git a/pgtype/bytea_test.go b/pgtype/bytea_test.go
index d99d28b6..41c3482e 100644
--- a/pgtype/bytea_test.go
+++ b/pgtype/bytea_test.go
@@ -28,7 +28,7 @@ func isExpectedEqBytes(a interface{}) func(interface{}) bool {
 }
 
 func TestByteaCodec(t *testing.T) {
-	testPgxCodec(t, "bytea", []PgxTranscodeTestCase{
+	testutil.RunTranscodeTests(t, "bytea", []testutil.TranscodeTestCase{
 		{[]byte{1, 2, 3}, new([]byte), isExpectedEqBytes([]byte{1, 2, 3})},
 		{[]byte{}, new([]byte), isExpectedEqBytes([]byte{})},
 		{[]byte(nil), new([]byte), isExpectedEqBytes([]byte(nil))},
diff --git a/pgtype/circle_test.go b/pgtype/circle_test.go
index 6fbf4c31..f38d8194 100644
--- a/pgtype/circle_test.go
+++ b/pgtype/circle_test.go
@@ -4,10 +4,11 @@ import (
 	"testing"
 
 	"github.com/jackc/pgx/v5/pgtype"
+	"github.com/jackc/pgx/v5/pgtype/testutil"
 )
 
 func TestCircleTranscode(t *testing.T) {
-	testPgxCodec(t, "circle", []PgxTranscodeTestCase{
+	testutil.RunTranscodeTests(t, "circle", []testutil.TranscodeTestCase{
 		{
 			pgtype.Circle{P: pgtype.Vec2{1.234, 5.67890123}, R: 3.5, Valid: true},
 			new(pgtype.Circle),
diff --git a/pgtype/date_test.go b/pgtype/date_test.go
index 268759c1..d57b9115 100644
--- a/pgtype/date_test.go
+++ b/pgtype/date_test.go
@@ -5,6 +5,7 @@ import (
 	"time"
 
 	"github.com/jackc/pgx/v5/pgtype"
+	"github.com/jackc/pgx/v5/pgtype/testutil"
 )
 
 func isExpectedEqTime(a interface{}) func(interface{}) bool {
@@ -17,7 +18,7 @@ func isExpectedEqTime(a interface{}) func(interface{}) bool {
 }
 
 func TestDateCodec(t *testing.T) {
-	testPgxCodec(t, "date", []PgxTranscodeTestCase{
+	testutil.RunTranscodeTests(t, "date", []testutil.TranscodeTestCase{
 		{time.Date(1900, 1, 1, 0, 0, 0, 0, time.UTC), new(time.Time), isExpectedEqTime(time.Date(1900, 1, 1, 0, 0, 0, 0, time.UTC))},
 		{time.Date(1970, 1, 1, 0, 0, 0, 0, time.UTC), new(time.Time), isExpectedEqTime(time.Date(1970, 1, 1, 0, 0, 0, 0, time.UTC))},
 		{time.Date(1999, 12, 31, 0, 0, 0, 0, time.UTC), new(time.Time), isExpectedEqTime(time.Date(1999, 12, 31, 0, 0, 0, 0, time.UTC))},
diff --git a/pgtype/float4_test.go b/pgtype/float4_test.go
index 85b3b21d..a0069836 100644
--- a/pgtype/float4_test.go
+++ b/pgtype/float4_test.go
@@ -4,10 +4,11 @@ import (
 	"testing"
 
 	"github.com/jackc/pgx/v5/pgtype"
+	"github.com/jackc/pgx/v5/pgtype/testutil"
 )
 
 func TestFloat4Codec(t *testing.T) {
-	testPgxCodec(t, "float4", []PgxTranscodeTestCase{
+	testutil.RunTranscodeTests(t, "float4", []testutil.TranscodeTestCase{
 		{pgtype.Float4{Float: -1, Valid: true}, new(pgtype.Float4), isExpectedEq(pgtype.Float4{Float: -1, Valid: true})},
 		{pgtype.Float4{Float: 0, Valid: true}, new(pgtype.Float4), isExpectedEq(pgtype.Float4{Float: 0, Valid: true})},
 		{pgtype.Float4{Float: 1, Valid: true}, new(pgtype.Float4), isExpectedEq(pgtype.Float4{Float: 1, Valid: true})},
diff --git a/pgtype/float8_test.go b/pgtype/float8_test.go
index 3c7660b8..e69174eb 100644
--- a/pgtype/float8_test.go
+++ b/pgtype/float8_test.go
@@ -4,10 +4,11 @@ import (
 	"testing"
 
 	"github.com/jackc/pgx/v5/pgtype"
+	"github.com/jackc/pgx/v5/pgtype/testutil"
 )
 
 func TestFloat8Codec(t *testing.T) {
-	testPgxCodec(t, "float8", []PgxTranscodeTestCase{
+	testutil.RunTranscodeTests(t, "float8", []testutil.TranscodeTestCase{
 		{pgtype.Float8{Float: -1, Valid: true}, new(pgtype.Float8), isExpectedEq(pgtype.Float8{Float: -1, Valid: true})},
 		{pgtype.Float8{Float: 0, Valid: true}, new(pgtype.Float8), isExpectedEq(pgtype.Float8{Float: 0, Valid: true})},
 		{pgtype.Float8{Float: 1, Valid: true}, new(pgtype.Float8), isExpectedEq(pgtype.Float8{Float: 1, Valid: true})},
diff --git a/pgtype/hstore_test.go b/pgtype/hstore_test.go
index edd94db7..8d2b6971 100644
--- a/pgtype/hstore_test.go
+++ b/pgtype/hstore_test.go
@@ -75,7 +75,7 @@ func TestHstoreCodec(t *testing.T) {
 		return &s
 	}
 
-	tests := []PgxTranscodeTestCase{
+	tests := []testutil.TranscodeTestCase{
 		{
 			map[string]string{},
 			new(map[string]string),
@@ -134,25 +134,25 @@ func TestHstoreCodec(t *testing.T) {
 		// Special key values
 
 		// at beginning
-		tests = append(tests, PgxTranscodeTestCase{
+		tests = append(tests, testutil.TranscodeTestCase{
 			map[string]string{s + "foo": "bar"},
 			new(map[string]string),
 			isExpectedEqMapStringString(map[string]string{s + "foo": "bar"}),
 		})
 		// in middle
-		tests = append(tests, PgxTranscodeTestCase{
+		tests = append(tests, testutil.TranscodeTestCase{
 			map[string]string{"foo" + s + "bar": "bar"},
 			new(map[string]string),
 			isExpectedEqMapStringString(map[string]string{"foo" + s + "bar": "bar"}),
 		})
 		// at end
-		tests = append(tests, PgxTranscodeTestCase{
+		tests = append(tests, testutil.TranscodeTestCase{
 			map[string]string{"foo" + s: "bar"},
 			new(map[string]string),
 			isExpectedEqMapStringString(map[string]string{"foo" + s: "bar"}),
 		})
 		// is key
-		tests = append(tests, PgxTranscodeTestCase{
+		tests = append(tests, testutil.TranscodeTestCase{
 			map[string]string{s: "bar"},
 			new(map[string]string),
 			isExpectedEqMapStringString(map[string]string{s: "bar"}),
@@ -161,25 +161,25 @@ func TestHstoreCodec(t *testing.T) {
 		// Special value values
 
 		// at beginning
-		tests = append(tests, PgxTranscodeTestCase{
+		tests = append(tests, testutil.TranscodeTestCase{
 			map[string]string{"foo": s + "bar"},
 			new(map[string]string),
 			isExpectedEqMapStringString(map[string]string{"foo": s + "bar"}),
 		})
 		// in middle
-		tests = append(tests, PgxTranscodeTestCase{
+		tests = append(tests, testutil.TranscodeTestCase{
 			map[string]string{"foo": "foo" + s + "bar"},
 			new(map[string]string),
 			isExpectedEqMapStringString(map[string]string{"foo": "foo" + s + "bar"}),
 		})
 		// at end
-		tests = append(tests, PgxTranscodeTestCase{
+		tests = append(tests, testutil.TranscodeTestCase{
 			map[string]string{"foo": "foo" + s},
 			new(map[string]string),
 			isExpectedEqMapStringString(map[string]string{"foo": "foo" + s}),
 		})
 		// is key
-		tests = append(tests, PgxTranscodeTestCase{
+		tests = append(tests, testutil.TranscodeTestCase{
 			map[string]string{"foo": s},
 			new(map[string]string),
 			isExpectedEqMapStringString(map[string]string{"foo": s}),
@@ -187,6 +187,6 @@ func TestHstoreCodec(t *testing.T) {
 	}
 
 	for _, format := range formats {
-		testPgxCodecFormat(t, "hstore", tests, conn, format.name, format.code)
+		testutil.RunTranscodeTestsFormat(t, "hstore", tests, conn, format.name, format.code)
 	}
 }
diff --git a/pgtype/inet_test.go b/pgtype/inet_test.go
index 4ead4672..c3f66755 100644
--- a/pgtype/inet_test.go
+++ b/pgtype/inet_test.go
@@ -5,6 +5,7 @@ import (
 	"testing"
 
 	"github.com/jackc/pgx/v5/pgtype"
+	"github.com/jackc/pgx/v5/pgtype/testutil"
 )
 
 func isExpectedEqIPNet(a interface{}) func(interface{}) bool {
@@ -17,7 +18,7 @@ func isExpectedEqIPNet(a interface{}) func(interface{}) bool {
 }
 
 func TestInetTranscode(t *testing.T) {
-	testPgxCodec(t, "inet", []PgxTranscodeTestCase{
+	testutil.RunTranscodeTests(t, "inet", []testutil.TranscodeTestCase{
 		{mustParseInet(t, "0.0.0.0/32"), new(net.IPNet), isExpectedEqIPNet(mustParseInet(t, "0.0.0.0/32"))},
 		{mustParseInet(t, "127.0.0.1/8"), new(net.IPNet), isExpectedEqIPNet(mustParseInet(t, "127.0.0.1/8"))},
 		{mustParseInet(t, "12.34.56.65/32"), new(net.IPNet), isExpectedEqIPNet(mustParseInet(t, "12.34.56.65/32"))},
@@ -34,7 +35,7 @@ func TestInetTranscode(t *testing.T) {
 }
 
 func TestCidrTranscode(t *testing.T) {
-	testPgxCodec(t, "cidr", []PgxTranscodeTestCase{
+	testutil.RunTranscodeTests(t, "cidr", []testutil.TranscodeTestCase{
 		{mustParseInet(t, "0.0.0.0/32"), new(net.IPNet), isExpectedEqIPNet(mustParseInet(t, "0.0.0.0/32"))},
 		{mustParseInet(t, "127.0.0.1/32"), new(net.IPNet), isExpectedEqIPNet(mustParseInet(t, "127.0.0.1/32"))},
 		{mustParseInet(t, "12.34.56.0/32"), new(net.IPNet), isExpectedEqIPNet(mustParseInet(t, "12.34.56.0/32"))},
diff --git a/pgtype/int_test.go b/pgtype/int_test.go
index 77aa0589..1dbf32d5 100644
--- a/pgtype/int_test.go
+++ b/pgtype/int_test.go
@@ -6,10 +6,11 @@ import (
 	"testing"
 
 	"github.com/jackc/pgx/v5/pgtype"
+	"github.com/jackc/pgx/v5/pgtype/testutil"
 )
 
 func TestInt2Codec(t *testing.T) {
-	testPgxCodec(t, "int2", []PgxTranscodeTestCase{
+	testutil.RunTranscodeTests(t, "int2", []testutil.TranscodeTestCase{
 		{int8(1), new(int16), isExpectedEq(int16(1))},
 		{int16(1), new(int16), isExpectedEq(int16(1))},
 		{int32(1), new(int16), isExpectedEq(int16(1))},
@@ -89,7 +90,7 @@ func TestInt2UnmarshalJSON(t *testing.T) {
 }
 
 func TestInt4Codec(t *testing.T) {
-	testPgxCodec(t, "int4", []PgxTranscodeTestCase{
+	testutil.RunTranscodeTests(t, "int4", []testutil.TranscodeTestCase{
 		{int8(1), new(int32), isExpectedEq(int32(1))},
 		{int16(1), new(int32), isExpectedEq(int32(1))},
 		{int32(1), new(int32), isExpectedEq(int32(1))},
@@ -169,7 +170,7 @@ func TestInt4UnmarshalJSON(t *testing.T) {
 }
 
 func TestInt8Codec(t *testing.T) {
-	testPgxCodec(t, "int8", []PgxTranscodeTestCase{
+	testutil.RunTranscodeTests(t, "int8", []testutil.TranscodeTestCase{
 		{int8(1), new(int64), isExpectedEq(int64(1))},
 		{int16(1), new(int64), isExpectedEq(int64(1))},
 		{int32(1), new(int64), isExpectedEq(int64(1))},
diff --git a/pgtype/int_test.go.erb b/pgtype/int_test.go.erb
index afcc8b9c..c98f6488 100644
--- a/pgtype/int_test.go.erb
+++ b/pgtype/int_test.go.erb
@@ -10,7 +10,7 @@ import (
 <% [2, 4, 8].each do |pg_byte_size| %>
 <% pg_bit_size = pg_byte_size * 8 %>
 func TestInt<%= pg_byte_size %>Codec(t *testing.T) {
-	testPgxCodec(t, "int<%= pg_byte_size %>", []PgxTranscodeTestCase{
+	testPgxCodec(t, "int<%= pg_byte_size %>", []testutil.TranscodeTestCase{
 		{int8(1), new(int<%= pg_bit_size %>), isExpectedEq(int<%= pg_bit_size %>(1))},
 		{int16(1), new(int<%= pg_bit_size %>), isExpectedEq(int<%= pg_bit_size %>(1))},
 		{int32(1), new(int<%= pg_bit_size %>), isExpectedEq(int<%= pg_bit_size %>(1))},
diff --git a/pgtype/interval_test.go b/pgtype/interval_test.go
index 75733ff1..310ea6bc 100644
--- a/pgtype/interval_test.go
+++ b/pgtype/interval_test.go
@@ -5,10 +5,11 @@ import (
 	"time"
 
 	"github.com/jackc/pgx/v5/pgtype"
+	"github.com/jackc/pgx/v5/pgtype/testutil"
 )
 
 func TestIntervalCodec(t *testing.T) {
-	testPgxCodec(t, "interval", []PgxTranscodeTestCase{
+	testutil.RunTranscodeTests(t, "interval", []testutil.TranscodeTestCase{
 		{
 			pgtype.Interval{Microseconds: 1, Valid: true},
 			new(pgtype.Interval),
diff --git a/pgtype/json_test.go b/pgtype/json_test.go
index 156217ac..a255c45a 100644
--- a/pgtype/json_test.go
+++ b/pgtype/json_test.go
@@ -2,6 +2,8 @@ package pgtype_test
 
 import (
 	"testing"
+
+	"github.com/jackc/pgx/v5/pgtype/testutil"
 )
 
 func isExpectedEqMap(a interface{}) func(interface{}) bool {
@@ -37,7 +39,7 @@ func TestJSONCodec(t *testing.T) {
 		Age  int    `json:"age"`
 	}
 
-	testPgxCodec(t, "json", []PgxTranscodeTestCase{
+	testutil.RunTranscodeTests(t, "json", []testutil.TranscodeTestCase{
 		{[]byte("{}"), new([]byte), isExpectedEqBytes([]byte("{}"))},
 		{[]byte("null"), new([]byte), isExpectedEqBytes([]byte("null"))},
 		{[]byte("42"), new([]byte), isExpectedEqBytes([]byte("42"))},
diff --git a/pgtype/jsonb_test.go b/pgtype/jsonb_test.go
index 282caeb1..981ec28e 100644
--- a/pgtype/jsonb_test.go
+++ b/pgtype/jsonb_test.go
@@ -2,6 +2,8 @@ package pgtype_test
 
 import (
 	"testing"
+
+	"github.com/jackc/pgx/v5/pgtype/testutil"
 )
 
 func TestJSONBTranscode(t *testing.T) {
@@ -10,7 +12,7 @@ func TestJSONBTranscode(t *testing.T) {
 		Age  int    `json:"age"`
 	}
 
-	testPgxCodec(t, "jsonb", []PgxTranscodeTestCase{
+	testutil.RunTranscodeTests(t, "jsonb", []testutil.TranscodeTestCase{
 		{[]byte("{}"), new([]byte), isExpectedEqBytes([]byte("{}"))},
 		{[]byte("null"), new([]byte), isExpectedEqBytes([]byte("null"))},
 		{[]byte("42"), new([]byte), isExpectedEqBytes([]byte("42"))},
diff --git a/pgtype/line_test.go b/pgtype/line_test.go
index 669d9b8d..b7c82e35 100644
--- a/pgtype/line_test.go
+++ b/pgtype/line_test.go
@@ -25,7 +25,7 @@ func TestLineTranscode(t *testing.T) {
 		t.Skip("Skipping due to unimplemented line type in PG 9.3")
 	}
 
-	testPgxCodec(t, "line", []PgxTranscodeTestCase{
+	testutil.RunTranscodeTests(t, "line", []testutil.TranscodeTestCase{
 		{
 			pgtype.Line{
 				A: 1.23, B: 4.56, C: 7.89012345,
diff --git a/pgtype/lseg_test.go b/pgtype/lseg_test.go
index 1866439f..51fe2adb 100644
--- a/pgtype/lseg_test.go
+++ b/pgtype/lseg_test.go
@@ -4,10 +4,11 @@ import (
 	"testing"
 
 	"github.com/jackc/pgx/v5/pgtype"
+	"github.com/jackc/pgx/v5/pgtype/testutil"
 )
 
 func TestLsegTranscode(t *testing.T) {
-	testPgxCodec(t, "lseg", []PgxTranscodeTestCase{
+	testutil.RunTranscodeTests(t, "lseg", []testutil.TranscodeTestCase{
 		{
 			pgtype.Lseg{
 				P:     [2]pgtype.Vec2{{3.14, 1.678}, {7.1, 5.2345678901}},
diff --git a/pgtype/macaddr_test.go b/pgtype/macaddr_test.go
index 3e59c580..2ce7b007 100644
--- a/pgtype/macaddr_test.go
+++ b/pgtype/macaddr_test.go
@@ -4,6 +4,8 @@ import (
 	"bytes"
 	"net"
 	"testing"
+
+	"github.com/jackc/pgx/v5/pgtype/testutil"
 )
 
 func isExpectedEqHardwareAddr(a interface{}) func(interface{}) bool {
@@ -24,7 +26,7 @@ func isExpectedEqHardwareAddr(a interface{}) func(interface{}) bool {
 }
 
 func TestMacaddrCodec(t *testing.T) {
-	testPgxCodec(t, "macaddr", []PgxTranscodeTestCase{
+	testutil.RunTranscodeTests(t, "macaddr", []testutil.TranscodeTestCase{
 		{
 			mustParseMacaddr(t, "01:23:45:67:89:ab"),
 			new(net.HardwareAddr),
diff --git a/pgtype/numeric_test.go b/pgtype/numeric_test.go
index 06d81ffe..0d89dc2d 100644
--- a/pgtype/numeric_test.go
+++ b/pgtype/numeric_test.go
@@ -74,7 +74,7 @@ func TestNumericCodec(t *testing.T) {
 	max.Add(max, big.NewInt(1))
 	longestNumeric := pgtype.Numeric{Int: max, Exp: -16383, Valid: true}
 
-	testPgxCodec(t, "numeric", []PgxTranscodeTestCase{
+	testutil.RunTranscodeTests(t, "numeric", []testutil.TranscodeTestCase{
 		{mustParseNumeric(t, "1"), new(pgtype.Numeric), isExpectedEqNumeric(mustParseNumeric(t, "1"))},
 		{mustParseNumeric(t, "3.14159"), new(pgtype.Numeric), isExpectedEqNumeric(mustParseNumeric(t, "3.14159"))},
 		{mustParseNumeric(t, "100010001"), new(pgtype.Numeric), isExpectedEqNumeric(mustParseNumeric(t, "100010001"))},
@@ -122,22 +122,22 @@ func TestNumericCodecFuzz(t *testing.T) {
 	max := &big.Int{}
 	max.SetString("9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999", 10)
 
-	tests := make([]PgxTranscodeTestCase, 0, 2000)
+	tests := make([]testutil.TranscodeTestCase, 0, 2000)
 	for i := 0; i < 10; i++ {
 		for j := -50; j < 50; j++ {
 			num := (&big.Int{}).Rand(r, max)
 
 			n := pgtype.Numeric{Int: num, Exp: int32(j), Valid: true}
-			tests = append(tests, PgxTranscodeTestCase{n, new(pgtype.Numeric), isExpectedEqNumeric(n)})
+			tests = append(tests, testutil.TranscodeTestCase{n, new(pgtype.Numeric), isExpectedEqNumeric(n)})
 
 			negNum := &big.Int{}
 			negNum.Neg(num)
 			n = pgtype.Numeric{Int: negNum, Exp: int32(j), Valid: true}
-			tests = append(tests, PgxTranscodeTestCase{n, new(pgtype.Numeric), isExpectedEqNumeric(n)})
+			tests = append(tests, testutil.TranscodeTestCase{n, new(pgtype.Numeric), isExpectedEqNumeric(n)})
 		}
 	}
 
-	testPgxCodec(t, "numeric", tests)
+	testutil.RunTranscodeTests(t, "numeric", tests)
 }
 
 func TestNumericMarshalJSON(t *testing.T) {
diff --git a/pgtype/path_test.go b/pgtype/path_test.go
index 291fa9d4..546f4d36 100644
--- a/pgtype/path_test.go
+++ b/pgtype/path_test.go
@@ -4,6 +4,7 @@ import (
 	"testing"
 
 	"github.com/jackc/pgx/v5/pgtype"
+	"github.com/jackc/pgx/v5/pgtype/testutil"
 )
 
 func isExpectedEqPath(a interface{}) func(interface{}) bool {
@@ -26,7 +27,7 @@ func isExpectedEqPath(a interface{}) func(interface{}) bool {
 }
 
 func TestPathTranscode(t *testing.T) {
-	testPgxCodec(t, "path", []PgxTranscodeTestCase{
+	testutil.RunTranscodeTests(t, "path", []testutil.TranscodeTestCase{
 		{
 			pgtype.Path{
 				P:      []pgtype.Vec2{{3.14, 1.678901234}, {7.1, 5.234}},
diff --git a/pgtype/pgtype.go b/pgtype/pgtype.go
index ee2730ee..5c818ec7 100644
--- a/pgtype/pgtype.go
+++ b/pgtype/pgtype.go
@@ -186,26 +186,6 @@ type TextDecoder interface {
 	DecodeText(ci *ConnInfo, src []byte) error
 }
 
-// BinaryEncoder is implemented by types that can encode themselves into the
-// PostgreSQL binary wire format.
-type BinaryEncoder interface {
-	// EncodeBinary should append the binary format of self to buf. If self is the
-	// SQL value NULL then append nothing and return (nil, nil). The caller of
-	// EncodeBinary is responsible for writing the correct NULL value or the
-	// length of the data written.
-	EncodeBinary(ci *ConnInfo, buf []byte) (newBuf []byte, err error)
-}
-
-// TextEncoder is implemented by types that can encode themselves into the
-// PostgreSQL text wire format.
-type TextEncoder interface {
-	// EncodeText should append the text format of self to buf. If self is the
-	// SQL value NULL then append nothing and return (nil, nil). The caller of
-	// EncodeText is responsible for writing the correct NULL value or the
-	// length of the data written.
-	EncodeText(ci *ConnInfo, buf []byte) (newBuf []byte, err error)
-}
-
 type nullAssignmentError struct {
 	dst interface{}
 }
@@ -400,8 +380,6 @@ func (ci *ConnInfo) RegisterDataType(t DataType) {
 		var formatCode int16
 		if t.Codec != nil {
 			formatCode = t.Codec.PreferredFormat()
-		} else if _, ok := t.Value.(BinaryEncoder); ok {
-			formatCode = BinaryFormatCode
 		}
 		ci.oidToFormatCode[t.OID] = formatCode
 	}
diff --git a/pgtype/pgtype_test.go b/pgtype/pgtype_test.go
index 703e1843..3c6b138a 100644
--- a/pgtype/pgtype_test.go
+++ b/pgtype/pgtype_test.go
@@ -2,17 +2,13 @@ package pgtype_test
 
 import (
 	"bytes"
-	"context"
 	"database/sql"
 	"errors"
-	"fmt"
 	"net"
-	"reflect"
 	"testing"
 
 	"github.com/jackc/pgx/v5"
 	"github.com/jackc/pgx/v5/pgtype"
-	"github.com/jackc/pgx/v5/pgtype/testutil"
 	_ "github.com/jackc/pgx/v5/stdlib"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -292,54 +288,8 @@ func BenchmarkScanPlanScanInt4IntoGoInt32(b *testing.B) {
 	}
 }
 
-type PgxTranscodeTestCase struct {
-	src  interface{}
-	dst  interface{}
-	test func(interface{}) bool
-}
-
 func isExpectedEq(a interface{}) func(interface{}) bool {
 	return func(v interface{}) bool {
 		return a == v
 	}
 }
-
-func testPgxCodec(t testing.TB, pgTypeName string, tests []PgxTranscodeTestCase) {
-	conn := testutil.MustConnectPgx(t)
-	defer testutil.MustCloseContext(t, conn)
-
-	formats := []struct {
-		name string
-		code int16
-	}{
-		{name: "TextFormat", code: pgx.TextFormatCode},
-		{name: "BinaryFormat", code: pgx.BinaryFormatCode},
-	}
-
-	for _, format := range formats {
-		testPgxCodecFormat(t, pgTypeName, tests, conn, format.name, format.code)
-	}
-}
-
-func testPgxCodecFormat(t testing.TB, pgTypeName string, tests []PgxTranscodeTestCase, conn *pgx.Conn, formatName string, formatCode int16) {
-	_, err := conn.Prepare(context.Background(), "test", fmt.Sprintf("select $1::%s", pgTypeName))
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	for i, tt := range tests {
-		err := conn.QueryRow(context.Background(), "test", pgx.QueryResultFormats{formatCode}, tt.src).Scan(tt.dst)
-		if err != nil {
-			t.Errorf("%s %d: %v", formatName, i, err)
-		}
-
-		dst := reflect.ValueOf(tt.dst)
-		if dst.Kind() == reflect.Ptr {
-			dst = dst.Elem()
-		}
-
-		if !tt.test(dst.Interface()) {
-			t.Errorf("%s %d: unexpected result for %v: %v", formatName, i, tt.src, dst.Interface())
-		}
-	}
-}
diff --git a/pgtype/point_test.go b/pgtype/point_test.go
index 8046da92..03d948b7 100644
--- a/pgtype/point_test.go
+++ b/pgtype/point_test.go
@@ -5,11 +5,12 @@ import (
 	"testing"
 
 	"github.com/jackc/pgx/v5/pgtype"
+	"github.com/jackc/pgx/v5/pgtype/testutil"
 	"github.com/stretchr/testify/require"
 )
 
 func TestPointCodec(t *testing.T) {
-	testPgxCodec(t, "point", []PgxTranscodeTestCase{
+	testutil.RunTranscodeTests(t, "point", []testutil.TranscodeTestCase{
 		{
 			pgtype.Point{P: pgtype.Vec2{1.234, 5.6789012345}, Valid: true},
 			new(pgtype.Point),
diff --git a/pgtype/polygon_test.go b/pgtype/polygon_test.go
index c0912b31..9c7c0182 100644
--- a/pgtype/polygon_test.go
+++ b/pgtype/polygon_test.go
@@ -4,6 +4,7 @@ import (
 	"testing"
 
 	"github.com/jackc/pgx/v5/pgtype"
+	"github.com/jackc/pgx/v5/pgtype/testutil"
 )
 
 func isExpectedEqPolygon(a interface{}) func(interface{}) bool {
@@ -26,7 +27,7 @@ func isExpectedEqPolygon(a interface{}) func(interface{}) bool {
 }
 
 func TestPolygonTranscode(t *testing.T) {
-	testPgxCodec(t, "polygon", []PgxTranscodeTestCase{
+	testutil.RunTranscodeTests(t, "polygon", []testutil.TranscodeTestCase{
 		{
 			pgtype.Polygon{
 				P:     []pgtype.Vec2{{3.14, 1.678901234}, {7.1, 5.234}, {5.0, 3.234}},
diff --git a/pgtype/qchar_test.go b/pgtype/qchar_test.go
index ec555eb2..36742f75 100644
--- a/pgtype/qchar_test.go
+++ b/pgtype/qchar_test.go
@@ -3,16 +3,18 @@ package pgtype_test
 import (
 	"math"
 	"testing"
+
+	"github.com/jackc/pgx/v5/pgtype/testutil"
 )
 
 func TestQcharTranscode(t *testing.T) {
-	var tests []PgxTranscodeTestCase
+	var tests []testutil.TranscodeTestCase
 	for i := 0; i <= math.MaxUint8; i++ {
-		tests = append(tests, PgxTranscodeTestCase{rune(i), new(rune), isExpectedEq(rune(i))})
-		tests = append(tests, PgxTranscodeTestCase{byte(i), new(byte), isExpectedEq(byte(i))})
+		tests = append(tests, testutil.TranscodeTestCase{rune(i), new(rune), isExpectedEq(rune(i))})
+		tests = append(tests, testutil.TranscodeTestCase{byte(i), new(byte), isExpectedEq(byte(i))})
 	}
-	tests = append(tests, PgxTranscodeTestCase{nil, new(*rune), isExpectedEq((*rune)(nil))})
-	tests = append(tests, PgxTranscodeTestCase{nil, new(*byte), isExpectedEq((*byte)(nil))})
+	tests = append(tests, testutil.TranscodeTestCase{nil, new(*rune), isExpectedEq((*rune)(nil))})
+	tests = append(tests, testutil.TranscodeTestCase{nil, new(*byte), isExpectedEq((*byte)(nil))})
 
-	testPgxCodec(t, `"char"`, tests)
+	testutil.RunTranscodeTests(t, `"char"`, tests)
 }
diff --git a/pgtype/testutil/testutil.go b/pgtype/testutil/testutil.go
index bfe9b01f..19ed4412 100644
--- a/pgtype/testutil/testutil.go
+++ b/pgtype/testutil/testutil.go
@@ -2,34 +2,15 @@ package testutil
 
 import (
 	"context"
-	"database/sql"
 	"fmt"
 	"os"
 	"reflect"
 	"testing"
 
 	"github.com/jackc/pgx/v5"
-	"github.com/jackc/pgx/v5/pgtype"
 	_ "github.com/jackc/pgx/v5/stdlib"
 )
 
-func MustConnectDatabaseSQL(t testing.TB, driverName string) *sql.DB {
-	var sqlDriverName string
-	switch driverName {
-	case "github.com/jackc/pgx/stdlib":
-		sqlDriverName = "pgx"
-	default:
-		t.Fatalf("Unknown driver %v", driverName)
-	}
-
-	db, err := sql.Open(sqlDriverName, os.Getenv("PGX_TEST_DATABASE"))
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	return db
-}
-
 func MustConnectPgx(t testing.TB) *pgx.Conn {
 	conn, err := pgx.Connect(context.Background(), os.Getenv("PGX_TEST_DATABASE"))
 	if err != nil {
@@ -57,369 +38,48 @@ func MustCloseContext(t testing.TB, conn interface {
 	}
 }
 
-type forceTextEncoder struct {
-	e pgtype.TextEncoder
+type TranscodeTestCase struct {
+	Src  interface{}
+	Dst  interface{}
+	Test func(interface{}) bool
 }
 
-func (f forceTextEncoder) EncodeText(ci *pgtype.ConnInfo, buf []byte) ([]byte, error) {
-	return f.e.EncodeText(ci, buf)
-}
-
-type forceBinaryEncoder struct {
-	e pgtype.BinaryEncoder
-}
-
-func (f forceBinaryEncoder) EncodeBinary(ci *pgtype.ConnInfo, buf []byte) ([]byte, error) {
-	return f.e.EncodeBinary(ci, buf)
-}
-
-func ForceEncoder(e interface{}, formatCode int16) interface{} {
-	switch formatCode {
-	case pgx.TextFormatCode:
-		if e, ok := e.(pgtype.TextEncoder); ok {
-			return forceTextEncoder{e: e}
-		}
-	case pgx.BinaryFormatCode:
-		if e, ok := e.(pgtype.BinaryEncoder); ok {
-			return forceBinaryEncoder{e: e.(pgtype.BinaryEncoder)}
-		}
-	}
-	return nil
-}
-
-func TestSuccessfulTranscode(t testing.TB, pgTypeName string, values []interface{}) {
-	TestSuccessfulTranscodeEqFunc(t, pgTypeName, values, func(a, b interface{}) bool {
-		return reflect.DeepEqual(a, b)
-	})
-}
-
-func TestSuccessfulTranscodeEqFunc(t testing.TB, pgTypeName string, values []interface{}, eqFunc func(a, b interface{}) bool) {
-	TestPgxSuccessfulTranscodeEqFunc(t, pgTypeName, values, eqFunc)
-	TestDatabaseSQLSuccessfulTranscodeEqFunc(t, "github.com/jackc/pgx/stdlib", pgTypeName, values, eqFunc)
-}
-
-func TestPgxSuccessfulTranscodeEqFunc(t testing.TB, pgTypeName string, values []interface{}, eqFunc func(a, b interface{}) bool) {
+func RunTranscodeTests(t testing.TB, pgTypeName string, tests []TranscodeTestCase) {
 	conn := MustConnectPgx(t)
 	defer MustCloseContext(t, conn)
 
+	formats := []struct {
+		name string
+		code int16
+	}{
+		{name: "TextFormat", code: pgx.TextFormatCode},
+		{name: "BinaryFormat", code: pgx.BinaryFormatCode},
+	}
+
+	for _, format := range formats {
+		RunTranscodeTestsFormat(t, pgTypeName, tests, conn, format.name, format.code)
+	}
+}
+
+func RunTranscodeTestsFormat(t testing.TB, pgTypeName string, tests []TranscodeTestCase, conn *pgx.Conn, formatName string, formatCode int16) {
 	_, err := conn.Prepare(context.Background(), "test", fmt.Sprintf("select $1::%s", pgTypeName))
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	formats := []struct {
-		name       string
-		formatCode int16
-	}{
-		{name: "TextFormat", formatCode: pgx.TextFormatCode},
-		{name: "BinaryFormat", formatCode: pgx.BinaryFormatCode},
-	}
-
-	for i, v := range values {
-		for _, paramFormat := range formats {
-			for _, resultFormat := range formats {
-				vEncoder := ForceEncoder(v, paramFormat.formatCode)
-				if vEncoder == nil {
-					t.Logf("Skipping Param %s Result %s: %#v does not implement %v for encoding", paramFormat.name, resultFormat.name, v, paramFormat.name)
-					continue
-				}
-				switch resultFormat.formatCode {
-				case pgx.TextFormatCode:
-					if _, ok := v.(pgtype.TextEncoder); !ok {
-						t.Logf("Skipping Param %s Result %s: %#v does not implement %v for decoding", paramFormat.name, resultFormat.name, v, resultFormat.name)
-						continue
-					}
-				case pgx.BinaryFormatCode:
-					if _, ok := v.(pgtype.BinaryEncoder); !ok {
-						t.Logf("Skipping Param %s Result %s: %#v does not implement %v for decoding", paramFormat.name, resultFormat.name, v, resultFormat.name)
-						continue
-					}
-				}
-
-				// Derefence value if it is a pointer
-				derefV := v
-				refVal := reflect.ValueOf(v)
-				if refVal.Kind() == reflect.Ptr {
-					derefV = refVal.Elem().Interface()
-				}
-
-				result := reflect.New(reflect.TypeOf(derefV))
-
-				err := conn.QueryRow(context.Background(), "test", pgx.QueryResultFormats{resultFormat.formatCode}, vEncoder).Scan(result.Interface())
-				if err != nil {
-					t.Errorf("Param %s Result %s %d: %v", paramFormat.name, resultFormat.name, i, err)
-				}
-
-				if !eqFunc(result.Elem().Interface(), derefV) {
-					t.Errorf("Param %s Result %s %d: expected %v, got %v", paramFormat.name, resultFormat.name, i, derefV, result.Elem().Interface())
-				}
-			}
-		}
-	}
-}
-
-func TestDatabaseSQLSuccessfulTranscodeEqFunc(t testing.TB, driverName, pgTypeName string, values []interface{}, eqFunc func(a, b interface{}) bool) {
-	conn := MustConnectDatabaseSQL(t, driverName)
-	defer MustClose(t, conn)
-
-	ps, err := conn.Prepare(fmt.Sprintf("select $1::%s", pgTypeName))
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	for i, v := range values {
-		// Derefence value if it is a pointer
-		derefV := v
-		refVal := reflect.ValueOf(v)
-		if refVal.Kind() == reflect.Ptr {
-			derefV = refVal.Elem().Interface()
-		}
-
-		result := reflect.New(reflect.TypeOf(derefV))
-		err := ps.QueryRow(v).Scan(result.Interface())
-		if err != nil {
-			t.Errorf("%v %d: %v", driverName, i, err)
-		}
-
-		if !eqFunc(result.Elem().Interface(), derefV) {
-			t.Errorf("%v %d: expected %v, got %v", driverName, i, derefV, result.Elem().Interface())
-		}
-	}
-}
-
-type NormalizeTest struct {
-	SQL   string
-	Value interface{}
-}
-
-func TestSuccessfulNormalize(t testing.TB, tests []NormalizeTest) {
-	TestSuccessfulNormalizeEqFunc(t, tests, func(a, b interface{}) bool {
-		return reflect.DeepEqual(a, b)
-	})
-}
-
-func TestSuccessfulNormalizeEqFunc(t testing.TB, tests []NormalizeTest, eqFunc func(a, b interface{}) bool) {
-	TestPgxSuccessfulNormalizeEqFunc(t, tests, eqFunc)
-	TestDatabaseSQLSuccessfulNormalizeEqFunc(t, "github.com/jackc/pgx/stdlib", tests, eqFunc)
-}
-
-func TestPgxSuccessfulNormalizeEqFunc(t testing.TB, tests []NormalizeTest, eqFunc func(a, b interface{}) bool) {
-	conn := MustConnectPgx(t)
-	defer MustCloseContext(t, conn)
-
-	formats := []struct {
-		name       string
-		formatCode int16
-	}{
-		{name: "TextFormat", formatCode: pgx.TextFormatCode},
-		{name: "BinaryFormat", formatCode: pgx.BinaryFormatCode},
-	}
-
 	for i, tt := range tests {
-		for _, fc := range formats {
-			psName := fmt.Sprintf("test%d", i)
-			_, err := conn.Prepare(context.Background(), psName, tt.SQL)
-			if err != nil {
-				t.Fatal(err)
-			}
-
-			queryResultFormats := pgx.QueryResultFormats{fc.formatCode}
-			if ForceEncoder(tt.Value, fc.formatCode) == nil {
-				t.Logf("Skipping: %#v does not implement %v", tt.Value, fc.name)
-				continue
-			}
-			// Derefence value if it is a pointer
-			derefV := tt.Value
-			refVal := reflect.ValueOf(tt.Value)
-			if refVal.Kind() == reflect.Ptr {
-				derefV = refVal.Elem().Interface()
-			}
-
-			result := reflect.New(reflect.TypeOf(derefV))
-			err = conn.QueryRow(context.Background(), psName, queryResultFormats).Scan(result.Interface())
-			if err != nil {
-				t.Errorf("%v %d: %v", fc.name, i, err)
-			}
-
-			if !eqFunc(result.Elem().Interface(), derefV) {
-				t.Errorf("%v %d: expected %v, got %v", fc.name, i, derefV, result.Elem().Interface())
-			}
-		}
-	}
-}
-
-func TestDatabaseSQLSuccessfulNormalizeEqFunc(t testing.TB, driverName string, tests []NormalizeTest, eqFunc func(a, b interface{}) bool) {
-	conn := MustConnectDatabaseSQL(t, driverName)
-	defer MustClose(t, conn)
-
-	for i, tt := range tests {
-		ps, err := conn.Prepare(tt.SQL)
+		err := conn.QueryRow(context.Background(), "test", pgx.QueryResultFormats{formatCode}, tt.Src).Scan(tt.Dst)
 		if err != nil {
-			t.Errorf("%d. %v", i, err)
-			continue
+			t.Errorf("%s %d: %v", formatName, i, err)
 		}
 
-		// Derefence value if it is a pointer
-		derefV := tt.Value
-		refVal := reflect.ValueOf(tt.Value)
-		if refVal.Kind() == reflect.Ptr {
-			derefV = refVal.Elem().Interface()
+		dst := reflect.ValueOf(tt.Dst)
+		if dst.Kind() == reflect.Ptr {
+			dst = dst.Elem()
 		}
 
-		result := reflect.New(reflect.TypeOf(derefV))
-		err = ps.QueryRow().Scan(result.Interface())
-		if err != nil {
-			t.Errorf("%v %d: %v", driverName, i, err)
-		}
-
-		if !eqFunc(result.Elem().Interface(), derefV) {
-			t.Errorf("%v %d: expected %v, got %v", driverName, i, derefV, result.Elem().Interface())
+		if !tt.Test(dst.Interface()) {
+			t.Errorf("%s %d: unexpected result for %v: %v", formatName, i, tt.Src, dst.Interface())
 		}
 	}
 }
-
-func TestGoZeroToNullConversion(t testing.TB, pgTypeName string, zero interface{}) {
-	TestPgxGoZeroToNullConversion(t, pgTypeName, zero)
-	TestDatabaseSQLGoZeroToNullConversion(t, "github.com/jackc/pgx/stdlib", pgTypeName, zero)
-}
-
-func TestNullToGoZeroConversion(t testing.TB, pgTypeName string, zero interface{}) {
-	TestPgxNullToGoZeroConversion(t, pgTypeName, zero)
-	TestDatabaseSQLNullToGoZeroConversion(t, "github.com/jackc/pgx/stdlib", pgTypeName, zero)
-}
-
-func TestPgxGoZeroToNullConversion(t testing.TB, pgTypeName string, zero interface{}) {
-	conn := MustConnectPgx(t)
-	defer MustCloseContext(t, conn)
-
-	_, err := conn.Prepare(context.Background(), "test", fmt.Sprintf("select $1::%s is null", pgTypeName))
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	formats := []struct {
-		name       string
-		formatCode int16
-	}{
-		{name: "TextFormat", formatCode: pgx.TextFormatCode},
-		{name: "BinaryFormat", formatCode: pgx.BinaryFormatCode},
-	}
-
-	for _, paramFormat := range formats {
-		vEncoder := ForceEncoder(zero, paramFormat.formatCode)
-		if vEncoder == nil {
-			t.Logf("Skipping Param %s: %#v does not implement %v for encoding", paramFormat.name, zero, paramFormat.name)
-			continue
-		}
-
-		var result bool
-		err := conn.QueryRow(context.Background(), "test", vEncoder).Scan(&result)
-		if err != nil {
-			t.Errorf("Param %s: %v", paramFormat.name, err)
-		}
-
-		if !result {
-			t.Errorf("Param %s: did not convert zero to null", paramFormat.name)
-		}
-	}
-}
-
-func TestPgxNullToGoZeroConversion(t testing.TB, pgTypeName string, zero interface{}) {
-	conn := MustConnectPgx(t)
-	defer MustCloseContext(t, conn)
-
-	_, err := conn.Prepare(context.Background(), "test", fmt.Sprintf("select null::%s", pgTypeName))
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	formats := []struct {
-		name       string
-		formatCode int16
-	}{
-		{name: "TextFormat", formatCode: pgx.TextFormatCode},
-		{name: "BinaryFormat", formatCode: pgx.BinaryFormatCode},
-	}
-
-	for _, resultFormat := range formats {
-
-		switch resultFormat.formatCode {
-		case pgx.TextFormatCode:
-			if _, ok := zero.(pgtype.TextEncoder); !ok {
-				t.Logf("Skipping Result %s: %#v does not implement %v for decoding", resultFormat.name, zero, resultFormat.name)
-				continue
-			}
-		case pgx.BinaryFormatCode:
-			if _, ok := zero.(pgtype.BinaryEncoder); !ok {
-				t.Logf("Skipping Result %s: %#v does not implement %v for decoding", resultFormat.name, zero, resultFormat.name)
-				continue
-			}
-		}
-
-		// Derefence value if it is a pointer
-		derefZero := zero
-		refVal := reflect.ValueOf(zero)
-		if refVal.Kind() == reflect.Ptr {
-			derefZero = refVal.Elem().Interface()
-		}
-
-		result := reflect.New(reflect.TypeOf(derefZero))
-
-		err := conn.QueryRow(context.Background(), "test").Scan(result.Interface())
-		if err != nil {
-			t.Errorf("Result %s: %v", resultFormat.name, err)
-		}
-
-		if !reflect.DeepEqual(result.Elem().Interface(), derefZero) {
-			t.Errorf("Result %s: did not convert null to zero", resultFormat.name)
-		}
-	}
-}
-
-func TestDatabaseSQLGoZeroToNullConversion(t testing.TB, driverName, pgTypeName string, zero interface{}) {
-	conn := MustConnectDatabaseSQL(t, driverName)
-	defer MustClose(t, conn)
-
-	ps, err := conn.Prepare(fmt.Sprintf("select $1::%s is null", pgTypeName))
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	var result bool
-	err = ps.QueryRow(zero).Scan(&result)
-	if err != nil {
-		t.Errorf("%v %v", driverName, err)
-	}
-
-	if !result {
-		t.Errorf("%v: did not convert zero to null", driverName)
-	}
-}
-
-func TestDatabaseSQLNullToGoZeroConversion(t testing.TB, driverName, pgTypeName string, zero interface{}) {
-	conn := MustConnectDatabaseSQL(t, driverName)
-	defer MustClose(t, conn)
-
-	ps, err := conn.Prepare(fmt.Sprintf("select null::%s", pgTypeName))
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	// Derefence value if it is a pointer
-	derefZero := zero
-	refVal := reflect.ValueOf(zero)
-	if refVal.Kind() == reflect.Ptr {
-		derefZero = refVal.Elem().Interface()
-	}
-
-	result := reflect.New(reflect.TypeOf(derefZero))
-
-	err = ps.QueryRow().Scan(result.Interface())
-	if err != nil {
-		t.Errorf("%v %v", driverName, err)
-	}
-
-	if !reflect.DeepEqual(result.Elem().Interface(), derefZero) {
-		t.Errorf("%s: did not convert null to zero", driverName)
-	}
-}
diff --git a/pgtype/text_test.go b/pgtype/text_test.go
index f45978a7..7a188a67 100644
--- a/pgtype/text_test.go
+++ b/pgtype/text_test.go
@@ -17,7 +17,7 @@ func (someFmtStringer) String() string {
 
 func TestTextCodec(t *testing.T) {
 	for _, pgTypeName := range []string{"text", "varchar"} {
-		testPgxCodec(t, pgTypeName, []PgxTranscodeTestCase{
+		testutil.RunTranscodeTests(t, pgTypeName, []testutil.TranscodeTestCase{
 			{
 				pgtype.Text{String: "", Valid: true},
 				new(pgtype.Text),
@@ -47,7 +47,7 @@ func TestTextCodec(t *testing.T) {
 //
 // So this is simply a smoke test of the name type.
 func TestTextCodecName(t *testing.T) {
-	testPgxCodec(t, "name", []PgxTranscodeTestCase{
+	testutil.RunTranscodeTests(t, "name", []testutil.TranscodeTestCase{
 		{
 			pgtype.Text{String: "", Valid: true},
 			new(pgtype.Text),
@@ -65,7 +65,7 @@ func TestTextCodecName(t *testing.T) {
 
 // Test fixed length char types like char(3)
 func TestTextCodecBPChar(t *testing.T) {
-	testPgxCodec(t, "char(3)", []PgxTranscodeTestCase{
+	testutil.RunTranscodeTests(t, "char(3)", []testutil.TranscodeTestCase{
 		{
 			pgtype.Text{String: "a  ", Valid: true},
 			new(pgtype.Text),
@@ -95,7 +95,7 @@ func TestTextCodecACLItem(t *testing.T) {
 	conn := testutil.MustConnectPgx(t)
 	defer testutil.MustCloseContext(t, conn)
 
-	testPgxCodecFormat(t, "aclitem", []PgxTranscodeTestCase{
+	testutil.RunTranscodeTestsFormat(t, "aclitem", []testutil.TranscodeTestCase{
 		{
 			pgtype.Text{String: "postgres=arwdDxt/postgres", Valid: true},
 			new(pgtype.Text),
@@ -123,7 +123,7 @@ func TestTextCodecACLItemRoleWithSpecialCharacters(t *testing.T) {
 		t.Skipf("Role with special characters does not exist.")
 	}
 
-	testPgxCodecFormat(t, "aclitem", []PgxTranscodeTestCase{
+	testutil.RunTranscodeTestsFormat(t, "aclitem", []testutil.TranscodeTestCase{
 		{
 			pgtype.Text{String: `postgres=arwdDxt/" tricky, ' } "" \ test user "`, Valid: true},
 			new(pgtype.Text),
diff --git a/pgtype/tid_test.go b/pgtype/tid_test.go
index 0d3afe5e..4ff53151 100644
--- a/pgtype/tid_test.go
+++ b/pgtype/tid_test.go
@@ -4,10 +4,11 @@ import (
 	"testing"
 
 	"github.com/jackc/pgx/v5/pgtype"
+	"github.com/jackc/pgx/v5/pgtype/testutil"
 )
 
 func TestTIDCodec(t *testing.T) {
-	testPgxCodec(t, "tid", []PgxTranscodeTestCase{
+	testutil.RunTranscodeTests(t, "tid", []testutil.TranscodeTestCase{
 		{
 			pgtype.TID{BlockNumber: 42, OffsetNumber: 43, Valid: true},
 			new(pgtype.TID),
diff --git a/pgtype/time_test.go b/pgtype/time_test.go
index 8394a951..61f9ef0e 100644
--- a/pgtype/time_test.go
+++ b/pgtype/time_test.go
@@ -5,10 +5,11 @@ import (
 	"time"
 
 	"github.com/jackc/pgx/v5/pgtype"
+	"github.com/jackc/pgx/v5/pgtype/testutil"
 )
 
 func TestTimeCodec(t *testing.T) {
-	testPgxCodec(t, "time", []PgxTranscodeTestCase{
+	testutil.RunTranscodeTests(t, "time", []testutil.TranscodeTestCase{
 		{
 			pgtype.Time{Microseconds: 0, Valid: true},
 			new(pgtype.Time),
diff --git a/pgtype/timestamp_test.go b/pgtype/timestamp_test.go
index 1caca58b..1bbceaf5 100644
--- a/pgtype/timestamp_test.go
+++ b/pgtype/timestamp_test.go
@@ -11,7 +11,7 @@ import (
 )
 
 func TestTimestampCodec(t *testing.T) {
-	testPgxCodec(t, "timestamp", []PgxTranscodeTestCase{
+	testutil.RunTranscodeTests(t, "timestamp", []testutil.TranscodeTestCase{
 		{time.Date(1900, 1, 1, 0, 0, 0, 0, time.UTC), new(time.Time), isExpectedEqTime(time.Date(1900, 1, 1, 0, 0, 0, 0, time.UTC))},
 		{time.Date(1970, 1, 1, 0, 0, 0, 0, time.UTC), new(time.Time), isExpectedEqTime(time.Date(1970, 1, 1, 0, 0, 0, 0, time.UTC))},
 		{time.Date(1999, 12, 31, 0, 0, 0, 0, time.UTC), new(time.Time), isExpectedEqTime(time.Date(1999, 12, 31, 0, 0, 0, 0, time.UTC))},
diff --git a/pgtype/timestamptz_test.go b/pgtype/timestamptz_test.go
index 2a45d2cb..42439b7b 100644
--- a/pgtype/timestamptz_test.go
+++ b/pgtype/timestamptz_test.go
@@ -11,7 +11,7 @@ import (
 )
 
 func TestTimestamptzCodec(t *testing.T) {
-	testPgxCodec(t, "timestamptz", []PgxTranscodeTestCase{
+	testutil.RunTranscodeTests(t, "timestamptz", []testutil.TranscodeTestCase{
 		{time.Date(1900, 1, 1, 0, 0, 0, 0, time.Local), new(time.Time), isExpectedEqTime(time.Date(1900, 1, 1, 0, 0, 0, 0, time.Local))},
 		{time.Date(1970, 1, 1, 0, 0, 0, 0, time.Local), new(time.Time), isExpectedEqTime(time.Date(1970, 1, 1, 0, 0, 0, 0, time.Local))},
 		{time.Date(1999, 12, 31, 0, 0, 0, 0, time.Local), new(time.Time), isExpectedEqTime(time.Date(1999, 12, 31, 0, 0, 0, 0, time.Local))},
diff --git a/pgtype/uint32_test.go b/pgtype/uint32_test.go
index 8e58605d..98adbee4 100644
--- a/pgtype/uint32_test.go
+++ b/pgtype/uint32_test.go
@@ -4,10 +4,11 @@ import (
 	"testing"
 
 	"github.com/jackc/pgx/v5/pgtype"
+	"github.com/jackc/pgx/v5/pgtype/testutil"
 )
 
 func TestUint32Codec(t *testing.T) {
-	testPgxCodec(t, "oid", []PgxTranscodeTestCase{
+	testutil.RunTranscodeTests(t, "oid", []testutil.TranscodeTestCase{
 		{
 			pgtype.Uint32{Uint: pgtype.TextOID, Valid: true},
 			new(pgtype.Uint32),
diff --git a/pgtype/uuid_test.go b/pgtype/uuid_test.go
index 71de8d67..870e7ae1 100644
--- a/pgtype/uuid_test.go
+++ b/pgtype/uuid_test.go
@@ -5,11 +5,12 @@ import (
 	"testing"
 
 	"github.com/jackc/pgx/v5/pgtype"
+	"github.com/jackc/pgx/v5/pgtype/testutil"
 	"github.com/stretchr/testify/require"
 )
 
 func TestUUIDCodec(t *testing.T) {
-	testPgxCodec(t, "uuid", []PgxTranscodeTestCase{
+	testutil.RunTranscodeTests(t, "uuid", []testutil.TranscodeTestCase{
 		{
 			pgtype.UUID{Bytes: [16]byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}, Valid: true},
 			new(pgtype.UUID),
diff --git a/pgtype/zeronull/float8.go b/pgtype/zeronull/float8.go
index 1c29d331..d1c053c5 100644
--- a/pgtype/zeronull/float8.go
+++ b/pgtype/zeronull/float8.go
@@ -8,6 +8,8 @@ import (
 
 type Float8 float64
 
+func (Float8) SkipUnderlyingTypePlan() {}
+
 // ScanFloat64 implements the Float64Scanner interface.
 func (f *Float8) ScanFloat64(n pgtype.Float8) error {
 	if !n.Valid {
diff --git a/pgtype/zeronull/float8_test.go b/pgtype/zeronull/float8_test.go
index b0331faa..fd683657 100644
--- a/pgtype/zeronull/float8_test.go
+++ b/pgtype/zeronull/float8_test.go
@@ -7,17 +7,28 @@ import (
 	"github.com/jackc/pgx/v5/pgtype/zeronull"
 )
 
+func isExpectedEq(a interface{}) func(interface{}) bool {
+	return func(v interface{}) bool {
+		return a == v
+	}
+}
+
 func TestFloat8Transcode(t *testing.T) {
-	testutil.TestSuccessfulTranscode(t, "float8", []interface{}{
-		(zeronull.Float8)(1),
-		(zeronull.Float8)(0),
+	testutil.RunTranscodeTests(t, "float8", []testutil.TranscodeTestCase{
+		{
+			(zeronull.Float8)(1),
+			new(zeronull.Float8),
+			isExpectedEq((zeronull.Float8)(1)),
+		},
+		{
+			nil,
+			new(zeronull.Float8),
+			isExpectedEq((zeronull.Float8)(0)),
+		},
+		{
+			(zeronull.Float8)(0),
+			new(interface{}),
+			isExpectedEq(nil),
+		},
 	})
 }
-
-func TestFloat8ConvertsGoZeroToNull(t *testing.T) {
-	testutil.TestGoZeroToNullConversion(t, "float8", (zeronull.Float8)(0))
-}
-
-func TestFloat8ConvertsNullToGoZero(t *testing.T) {
-	testutil.TestNullToGoZeroConversion(t, "float8", (zeronull.Float8)(0))
-}
diff --git a/pgtype/zeronull/int.go b/pgtype/zeronull/int.go
index 0149834b..1d479307 100644
--- a/pgtype/zeronull/int.go
+++ b/pgtype/zeronull/int.go
@@ -11,6 +11,8 @@ import (
 
 type Int2 int16
 
+func (Int2) SkipUnderlyingTypePlan() {}
+
 // ScanInt64 implements the Int64Scanner interface.
 func (dst *Int2) ScanInt64(n int64, valid bool) error {
 	if !valid {
@@ -57,6 +59,8 @@ func (src Int2) Value() (driver.Value, error) {
 
 type Int4 int32
 
+func (Int4) SkipUnderlyingTypePlan() {}
+
 // ScanInt64 implements the Int64Scanner interface.
 func (dst *Int4) ScanInt64(n int64, valid bool) error {
 	if !valid {
@@ -103,6 +107,8 @@ func (src Int4) Value() (driver.Value, error) {
 
 type Int8 int64
 
+func (Int8) SkipUnderlyingTypePlan() {}
+
 // ScanInt64 implements the Int64Scanner interface.
 func (dst *Int8) ScanInt64(n int64, valid bool) error {
 	if !valid {
diff --git a/pgtype/zeronull/int.go.erb b/pgtype/zeronull/int.go.erb
index 935b56a9..9e3b5ef0 100644
--- a/pgtype/zeronull/int.go.erb
+++ b/pgtype/zeronull/int.go.erb
@@ -12,6 +12,8 @@ import (
 <% pg_bit_size = pg_byte_size * 8 %>
 type Int<%= pg_byte_size %> int<%= pg_bit_size %>
 
+func (Int<%= pg_byte_size %>) SkipUnderlyingTypePlan() {}
+
 // ScanInt64 implements the Int64Scanner interface.
 func (dst *Int<%= pg_byte_size %>) ScanInt64(n int64, valid bool) error {
 	if !valid {
diff --git a/pgtype/zeronull/int_test.go b/pgtype/zeronull/int_test.go
index bd2ef0b2..d687a733 100644
--- a/pgtype/zeronull/int_test.go
+++ b/pgtype/zeronull/int_test.go
@@ -9,46 +9,61 @@ import (
 )
 
 func TestInt2Transcode(t *testing.T) {
-	testutil.TestSuccessfulTranscode(t, "int2", []interface{}{
-		(zeronull.Int2)(1),
-		(zeronull.Int2)(0),
+	testutil.RunTranscodeTests(t, "int2", []testutil.TranscodeTestCase{
+		{
+			(zeronull.Int2)(1),
+			new(zeronull.Int2),
+			isExpectedEq((zeronull.Int2)(1)),
+		},
+		{
+			nil,
+			new(zeronull.Int2),
+			isExpectedEq((zeronull.Int2)(0)),
+		},
+		{
+			(zeronull.Int2)(0),
+			new(interface{}),
+			isExpectedEq(nil),
+		},
 	})
 }
 
-func TestInt2ConvertsGoZeroToNull(t *testing.T) {
-	testutil.TestGoZeroToNullConversion(t, "int2", (zeronull.Int2)(0))
-}
-
-func TestInt2ConvertsNullToGoZero(t *testing.T) {
-	testutil.TestNullToGoZeroConversion(t, "int2", (zeronull.Int2)(0))
-}
-
 func TestInt4Transcode(t *testing.T) {
-	testutil.TestSuccessfulTranscode(t, "int4", []interface{}{
-		(zeronull.Int4)(1),
-		(zeronull.Int4)(0),
+	testutil.RunTranscodeTests(t, "int4", []testutil.TranscodeTestCase{
+		{
+			(zeronull.Int4)(1),
+			new(zeronull.Int4),
+			isExpectedEq((zeronull.Int4)(1)),
+		},
+		{
+			nil,
+			new(zeronull.Int4),
+			isExpectedEq((zeronull.Int4)(0)),
+		},
+		{
+			(zeronull.Int4)(0),
+			new(interface{}),
+			isExpectedEq(nil),
+		},
 	})
 }
 
-func TestInt4ConvertsGoZeroToNull(t *testing.T) {
-	testutil.TestGoZeroToNullConversion(t, "int4", (zeronull.Int4)(0))
-}
-
-func TestInt4ConvertsNullToGoZero(t *testing.T) {
-	testutil.TestNullToGoZeroConversion(t, "int4", (zeronull.Int4)(0))
-}
-
 func TestInt8Transcode(t *testing.T) {
-	testutil.TestSuccessfulTranscode(t, "int8", []interface{}{
-		(zeronull.Int8)(1),
-		(zeronull.Int8)(0),
+	testutil.RunTranscodeTests(t, "int8", []testutil.TranscodeTestCase{
+		{
+			(zeronull.Int8)(1),
+			new(zeronull.Int8),
+			isExpectedEq((zeronull.Int8)(1)),
+		},
+		{
+			nil,
+			new(zeronull.Int8),
+			isExpectedEq((zeronull.Int8)(0)),
+		},
+		{
+			(zeronull.Int8)(0),
+			new(interface{}),
+			isExpectedEq(nil),
+		},
 	})
 }
-
-func TestInt8ConvertsGoZeroToNull(t *testing.T) {
-	testutil.TestGoZeroToNullConversion(t, "int8", (zeronull.Int8)(0))
-}
-
-func TestInt8ConvertsNullToGoZero(t *testing.T) {
-	testutil.TestNullToGoZeroConversion(t, "int8", (zeronull.Int8)(0))
-}
diff --git a/pgtype/zeronull/int_test.go.erb b/pgtype/zeronull/int_test.go.erb
index 51273710..b33cfa4a 100644
--- a/pgtype/zeronull/int_test.go.erb
+++ b/pgtype/zeronull/int_test.go.erb
@@ -10,17 +10,22 @@ import (
 <% [2, 4, 8].each do |pg_byte_size| %>
 <% pg_bit_size = pg_byte_size * 8 %>
 func TestInt<%= pg_byte_size %>Transcode(t *testing.T) {
-	testutil.TestSuccessfulTranscode(t, "int<%= pg_byte_size %>", []interface{}{
-		(zeronull.Int<%= pg_byte_size %>)(1),
-		(zeronull.Int<%= pg_byte_size %>)(0),
+	testutil.RunTranscodeTests(t, "int<%= pg_byte_size %>", []testutil.TranscodeTestCase{
+		{
+			(zeronull.Int<%= pg_byte_size %>)(1),
+			new(zeronull.Int<%= pg_byte_size %>),
+			isExpectedEq((zeronull.Int<%= pg_byte_size %>)(1)),
+		},
+		{
+			nil,
+			new(zeronull.Int<%= pg_byte_size %>),
+			isExpectedEq((zeronull.Int<%= pg_byte_size %>)(0)),
+		},
+		{
+			(zeronull.Int<%= pg_byte_size %>)(0),
+			new(interface{}),
+			isExpectedEq(nil),
+		},
 	})
 }
-
-func TestInt<%= pg_byte_size %>ConvertsGoZeroToNull(t *testing.T) {
-	testutil.TestGoZeroToNullConversion(t, "int<%= pg_byte_size %>", (zeronull.Int<%= pg_byte_size %>)(0))
-}
-
-func TestInt<%= pg_byte_size %>ConvertsNullToGoZero(t *testing.T) {
-	testutil.TestNullToGoZeroConversion(t, "int<%= pg_byte_size %>", (zeronull.Int<%= pg_byte_size %>)(0))
-}
 <% end %>
diff --git a/pgtype/zeronull/text.go b/pgtype/zeronull/text.go
index fcbc16d7..b768e308 100644
--- a/pgtype/zeronull/text.go
+++ b/pgtype/zeronull/text.go
@@ -8,6 +8,8 @@ import (
 
 type Text string
 
+func (Text) SkipUnderlyingTypePlan() {}
+
 // ScanText implements the TextScanner interface.
 func (dst *Text) ScanText(v pgtype.Text) error {
 	if !v.Valid {
diff --git a/pgtype/zeronull/text_test.go b/pgtype/zeronull/text_test.go
index e4293024..e20ab868 100644
--- a/pgtype/zeronull/text_test.go
+++ b/pgtype/zeronull/text_test.go
@@ -8,16 +8,21 @@ import (
 )
 
 func TestTextTranscode(t *testing.T) {
-	testutil.TestSuccessfulTranscode(t, "text", []interface{}{
-		(zeronull.Text)("foo"),
-		(zeronull.Text)(""),
+	testutil.RunTranscodeTests(t, "text", []testutil.TranscodeTestCase{
+		{
+			(zeronull.Text)("foo"),
+			new(zeronull.Text),
+			isExpectedEq((zeronull.Text)("foo")),
+		},
+		{
+			nil,
+			new(zeronull.Text),
+			isExpectedEq((zeronull.Text)("")),
+		},
+		{
+			(zeronull.Text)(""),
+			new(interface{}),
+			isExpectedEq(nil),
+		},
 	})
 }
-
-func TestTextConvertsGoZeroToNull(t *testing.T) {
-	testutil.TestGoZeroToNullConversion(t, "text", (zeronull.Text)(""))
-}
-
-func TestTextConvertsNullToGoZero(t *testing.T) {
-	testutil.TestNullToGoZeroConversion(t, "text", (zeronull.Text)(""))
-}
diff --git a/pgtype/zeronull/timestamp.go b/pgtype/zeronull/timestamp.go
index 1c2a1a63..6e2c3d1e 100644
--- a/pgtype/zeronull/timestamp.go
+++ b/pgtype/zeronull/timestamp.go
@@ -10,6 +10,8 @@ import (
 
 type Timestamp time.Time
 
+func (Timestamp) SkipUnderlyingTypePlan() {}
+
 func (ts *Timestamp) ScanTimestamp(v pgtype.Timestamp) error {
 	if !v.Valid {
 		*ts = Timestamp{}
diff --git a/pgtype/zeronull/timestamp_test.go b/pgtype/zeronull/timestamp_test.go
index 2eb072c6..9d8ee7ae 100644
--- a/pgtype/zeronull/timestamp_test.go
+++ b/pgtype/zeronull/timestamp_test.go
@@ -8,22 +8,31 @@ import (
 	"github.com/jackc/pgx/v5/pgtype/zeronull"
 )
 
-func TestTimestampTranscode(t *testing.T) {
-	testutil.TestSuccessfulTranscodeEqFunc(t, "timestamp", []interface{}{
-		(zeronull.Timestamp)(time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC)),
-		(zeronull.Timestamp)(time.Time{}),
-	}, func(a, b interface{}) bool {
-		at := a.(zeronull.Timestamp)
-		bt := b.(zeronull.Timestamp)
+func isExpectedEqTimestamp(a interface{}) func(interface{}) bool {
+	return func(v interface{}) bool {
+		at := time.Time(a.(zeronull.Timestamp))
+		vt := time.Time(v.(zeronull.Timestamp))
 
-		return time.Time(at).Equal(time.Time(bt))
+		return at.Equal(vt)
+	}
+}
+
+func TestTimestampTranscode(t *testing.T) {
+	testutil.RunTranscodeTests(t, "timestamp", []testutil.TranscodeTestCase{
+		{
+			(zeronull.Timestamp)(time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC)),
+			new(zeronull.Timestamp),
+			isExpectedEqTimestamp((zeronull.Timestamp)(time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC))),
+		},
+		{
+			nil,
+			new(zeronull.Timestamp),
+			isExpectedEqTimestamp((zeronull.Timestamp)(time.Time{})),
+		},
+		{
+			(zeronull.Timestamp)(time.Time{}),
+			new(interface{}),
+			isExpectedEq(nil),
+		},
 	})
 }
-
-func TestTimestampConvertsGoZeroToNull(t *testing.T) {
-	testutil.TestGoZeroToNullConversion(t, "timestamp", (zeronull.Timestamp)(time.Time{}))
-}
-
-func TestTimestampConvertsNullToGoZero(t *testing.T) {
-	testutil.TestNullToGoZeroConversion(t, "timestamp", (zeronull.Timestamp)(time.Time{}))
-}
diff --git a/pgtype/zeronull/timestamptz.go b/pgtype/zeronull/timestamptz.go
index c5378059..79fcb563 100644
--- a/pgtype/zeronull/timestamptz.go
+++ b/pgtype/zeronull/timestamptz.go
@@ -10,6 +10,8 @@ import (
 
 type Timestamptz time.Time
 
+func (Timestamptz) SkipUnderlyingTypePlan() {}
+
 func (ts *Timestamptz) ScanTimestamptz(v pgtype.Timestamptz) error {
 	if !v.Valid {
 		*ts = Timestamptz{}
diff --git a/pgtype/zeronull/timestamptz_test.go b/pgtype/zeronull/timestamptz_test.go
index e288b9e8..15ac66da 100644
--- a/pgtype/zeronull/timestamptz_test.go
+++ b/pgtype/zeronull/timestamptz_test.go
@@ -8,22 +8,31 @@ import (
 	"github.com/jackc/pgx/v5/pgtype/zeronull"
 )
 
-func TestTimestamptzTranscode(t *testing.T) {
-	testutil.TestSuccessfulTranscodeEqFunc(t, "timestamptz", []interface{}{
-		(zeronull.Timestamptz)(time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC)),
-		(zeronull.Timestamptz)(time.Time{}),
-	}, func(a, b interface{}) bool {
-		at := a.(zeronull.Timestamptz)
-		bt := b.(zeronull.Timestamptz)
+func isExpectedEqTimestamptz(a interface{}) func(interface{}) bool {
+	return func(v interface{}) bool {
+		at := time.Time(a.(zeronull.Timestamptz))
+		vt := time.Time(v.(zeronull.Timestamptz))
 
-		return time.Time(at).Equal(time.Time(bt))
+		return at.Equal(vt)
+	}
+}
+
+func TestTimestamptzTranscode(t *testing.T) {
+	testutil.RunTranscodeTests(t, "timestamptz", []testutil.TranscodeTestCase{
+		{
+			(zeronull.Timestamptz)(time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC)),
+			new(zeronull.Timestamptz),
+			isExpectedEqTimestamptz((zeronull.Timestamptz)(time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC))),
+		},
+		{
+			nil,
+			new(zeronull.Timestamptz),
+			isExpectedEqTimestamptz((zeronull.Timestamptz)(time.Time{})),
+		},
+		{
+			(zeronull.Timestamptz)(time.Time{}),
+			new(interface{}),
+			isExpectedEq(nil),
+		},
 	})
 }
-
-func TestTimestamptzConvertsGoZeroToNull(t *testing.T) {
-	testutil.TestGoZeroToNullConversion(t, "timestamptz", (zeronull.Timestamptz)(time.Time{}))
-}
-
-func TestTimestamptzConvertsNullToGoZero(t *testing.T) {
-	testutil.TestNullToGoZeroConversion(t, "timestamptz", (zeronull.Timestamptz)(time.Time{}))
-}
diff --git a/pgtype/zeronull/uuid.go b/pgtype/zeronull/uuid.go
index a87003e1..abe5049e 100644
--- a/pgtype/zeronull/uuid.go
+++ b/pgtype/zeronull/uuid.go
@@ -8,6 +8,8 @@ import (
 
 type UUID [16]byte
 
+func (UUID) SkipUnderlyingTypePlan() {}
+
 // ScanUUID implements the UUIDScanner interface.
 func (u *UUID) ScanUUID(v pgtype.UUID) error {
 	if !v.Valid {
diff --git a/pgtype/zeronull/uuid_test.go b/pgtype/zeronull/uuid_test.go
index 913698d9..5be1d22e 100644
--- a/pgtype/zeronull/uuid_test.go
+++ b/pgtype/zeronull/uuid_test.go
@@ -8,16 +8,21 @@ import (
 )
 
 func TestUUIDTranscode(t *testing.T) {
-	testutil.TestSuccessfulTranscode(t, "uuid", []interface{}{
-		(*zeronull.UUID)(&[16]byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}),
-		(*zeronull.UUID)(&[16]byte{}),
+	testutil.RunTranscodeTests(t, "uuid", []testutil.TranscodeTestCase{
+		{
+			(zeronull.UUID)([16]byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}),
+			new(zeronull.UUID),
+			isExpectedEq((zeronull.UUID)([16]byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15})),
+		},
+		{
+			nil,
+			new(zeronull.UUID),
+			isExpectedEq((zeronull.UUID)([16]byte{})),
+		},
+		{
+			(zeronull.UUID)([16]byte{}),
+			new(interface{}),
+			isExpectedEq(nil),
+		},
 	})
 }
-
-func TestUUIDConvertsGoZeroToNull(t *testing.T) {
-	testutil.TestGoZeroToNullConversion(t, "uuid", (*zeronull.UUID)(&[16]byte{}))
-}
-
-func TestUUIDConvertsNullToGoZero(t *testing.T) {
-	testutil.TestNullToGoZeroConversion(t, "uuid", (*zeronull.UUID)(&[16]byte{}))
-}
diff --git a/values.go b/values.go
index b5ce4f7c..3cb27bbf 100644
--- a/values.go
+++ b/values.go
@@ -37,15 +37,6 @@ func convertSimpleArgument(ci *pgtype.ConnInfo, arg interface{}) (interface{}, e
 	switch arg := arg.(type) {
 	case driver.Valuer:
 		return callValuerValue(arg)
-	case pgtype.TextEncoder:
-		buf, err := arg.EncodeText(ci, nil)
-		if err != nil {
-			return nil, err
-		}
-		if buf == nil {
-			return nil, nil
-		}
-		return string(buf), nil
 	case float32:
 		return float64(arg), nil
 	case float64:
@@ -89,21 +80,7 @@ func convertSimpleArgument(ci *pgtype.ConnInfo, arg interface{}) (interface{}, e
 	}
 
 	if dt, found := ci.DataTypeForValue(arg); found {
-		if dt.Value != nil {
-			v := dt.Value
-			err := v.Set(arg)
-			if err != nil {
-				return nil, err
-			}
-			buf, err := v.(pgtype.TextEncoder).EncodeText(ci, nil)
-			if err != nil {
-				return nil, err
-			}
-			if buf == nil {
-				return nil, nil
-			}
-			return string(buf), nil
-		} else if dt.Codec != nil {
+		if dt.Codec != nil {
 			buf, err := ci.Encode(0, TextFormatCode, arg, nil)
 			if err != nil {
 				return nil, err
@@ -132,30 +109,6 @@ func encodePreparedStatementArgument(ci *pgtype.ConnInfo, buf []byte, oid uint32
 	}
 
 	switch arg := arg.(type) {
-	case pgtype.BinaryEncoder:
-		sp := len(buf)
-		buf = pgio.AppendInt32(buf, -1)
-		argBuf, err := arg.EncodeBinary(ci, buf)
-		if err != nil {
-			return nil, err
-		}
-		if argBuf != nil {
-			buf = argBuf
-			pgio.SetInt32(buf[sp:], int32(len(buf[sp:])-4))
-		}
-		return buf, nil
-	case pgtype.TextEncoder:
-		sp := len(buf)
-		buf = pgio.AppendInt32(buf, -1)
-		argBuf, err := arg.EncodeText(ci, buf)
-		if err != nil {
-			return nil, err
-		}
-		if argBuf != nil {
-			buf = argBuf
-			pgio.SetInt32(buf[sp:], int32(len(buf[sp:])-4))
-		}
-		return buf, nil
 	case string:
 		buf = pgio.AppendInt32(buf, int32(len(arg)))
 		buf = append(buf, arg...)
@@ -173,35 +126,7 @@ func encodePreparedStatementArgument(ci *pgtype.ConnInfo, buf []byte, oid uint32
 	}
 
 	if dt, ok := ci.DataTypeForOID(oid); ok {
-		if dt.Value != nil {
-			value := dt.Value
-			err := value.Set(arg)
-			if err != nil {
-				{
-					if arg, ok := arg.(driver.Valuer); ok {
-						v, err := callValuerValue(arg)
-						if err != nil {
-							return nil, err
-						}
-						return encodePreparedStatementArgument(ci, buf, oid, v)
-					}
-				}
-
-				return nil, err
-			}
-
-			sp := len(buf)
-			buf = pgio.AppendInt32(buf, -1)
-			argBuf, err := value.(pgtype.BinaryEncoder).EncodeBinary(ci, buf)
-			if err != nil {
-				return nil, err
-			}
-			if argBuf != nil {
-				buf = argBuf
-				pgio.SetInt32(buf[sp:], int32(len(buf[sp:])-4))
-			}
-			return buf, nil
-		} else if dt.Codec != nil {
+		if dt.Codec != nil {
 			sp := len(buf)
 			buf = pgio.AppendInt32(buf, -1)
 			argBuf, err := ci.Encode(oid, BinaryFormatCode, arg, buf)
@@ -227,9 +152,7 @@ func encodePreparedStatementArgument(ci *pgtype.ConnInfo, buf []byte, oid uint32
 // determination can be made.
 func chooseParameterFormatCode(ci *pgtype.ConnInfo, oid uint32, arg interface{}) int16 {
 	switch arg.(type) {
-	case pgtype.BinaryEncoder:
-		return BinaryFormatCode
-	case string, *string, pgtype.TextEncoder:
+	case string, *string:
 		return TextFormatCode
 	}