Migrate from math/rand to math/rand/v2

pgconn/internal/bgreader/bgreader_test.go

@@ -4,7 +4,7 @@ import (
 	"bytes"
 	"errors"
 	"io"
-	"math/rand"
+	"math/rand/v2"
 	"testing"
 	"time"
 
@@ -100,7 +100,7 @@ type numberReader struct {
 }
 
 func (nr *numberReader) Read(p []byte) (int, error) {
-	n := nr.rng.Intn(len(p))
+	n := nr.rng.IntN(len(p))
 	for i := range n {
 		p[i] = nr.v
 		nr.v++
@@ -112,16 +112,16 @@ func (nr *numberReader) Read(p []byte) (int, error) {
 // TestBGReaderStress stress tests BGReader by reading a lot of bytes in random sizes while randomly starting and
 // stopping the background worker from other goroutines.
 func TestBGReaderStress(t *testing.T) {
-	nr := &numberReader{rng: rand.New(rand.NewSource(0))}
+	nr := &numberReader{rng: rand.New(rand.NewPCG(0, 0))}
 	bgr := bgreader.New(nr)
 
 	bytesRead := 0
 	var expected uint8
 	buf := make([]byte, 10_000)
-	rng := rand.New(rand.NewSource(0))
+	rng := rand.New(rand.NewPCG(0, 0))
 
 	for bytesRead < 1_000_000 {
-		randomNumber := rng.Intn(100)
+		randomNumber := rng.IntN(100)
 		switch {
 		case randomNumber < 10:
 			go bgr.Start()

pgconn/pgconn_stress_test.go

@@ -2,7 +2,7 @@ package pgconn_test
 
 import (
 	"context"
-	"math/rand"
+	"math/rand/v2"
 	"os"
 	"runtime"
 	"strconv"
@@ -37,7 +37,7 @@ func TestConnStress(t *testing.T) {
 	}
 
 	for i := 0; i < actionCount; i++ {
-		action := actions[rand.Intn(len(actions))]
+		action := actions[rand.IntN(len(actions))]
 		err := action.fn(pgConn)
 		require.Nilf(t, err, "%d: %s", i, action.name)
 	}

pgproto3/chunkreader_test.go

@@ -2,7 +2,7 @@ package pgproto3
 
 import (
 	"bytes"
-	"math/rand"
+	"math/rand/v2"
 	"testing"
 )
 
@@ -52,18 +52,21 @@ type randomReader struct {
 
 // Read reads a random number of random bytes.
 func (r *randomReader) Read(p []byte) (n int, err error) {
-	n = r.rnd.Intn(len(p) + 1)
-	return r.rnd.Read(p[:n])
+	n = r.rnd.IntN(len(p) + 1)
+	for i := 0; i < n; i++ {
+		p[i] = byte(r.rnd.Uint64())
+	}
+	return n, nil
 }
 
 func TestChunkReaderNextFuzz(t *testing.T) {
-	rr := &randomReader{rnd: rand.New(rand.NewSource(1))}
+	rr := &randomReader{rnd: rand.New(rand.NewPCG(1, 0))}
 	r := newChunkReader(rr, 8192)
 
-	randomSizes := rand.New(rand.NewSource(0))
+	randomSizes := rand.New(rand.NewPCG(0, 0))
 
 	for range 100000 {
-		size := randomSizes.Intn(16384) + 1
+		size := randomSizes.IntN(16384) + 1
 		buf, err := r.Next(size)
 		if err != nil {
 			t.Fatal(err)

pgtype/numeric_test.go

@@ -5,7 +5,7 @@ import (
 	"encoding/json"
 	"math"
 	"math/big"
-	"math/rand"
+	"math/rand/v2"
 	"reflect"
 	"strconv"
 	"strings"
@@ -174,14 +174,24 @@ func TestNumericFloat64Valuer(t *testing.T) {
 func TestNumericCodecFuzz(t *testing.T) {
 	skipCockroachDB(t, "server formats numeric text format differently")
 
-	r := rand.New(rand.NewSource(0))
+	r := rand.New(rand.NewPCG(0, 0))
 	max := &big.Int{}
 	max.SetString("9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999", 10)
 
 	tests := make([]pgxtest.ValueRoundTripTest, 0, 2000)
 	for range 10 {
 		for j := -50; j < 50; j++ {
-			num := (&big.Int{}).Rand(r, max)
+			byteLen := (max.BitLen() + 7) / 8
+			bytes := make([]byte, byteLen)
+			for k := 0; k < byteLen; {
+				val := r.Uint64()
+				for b := 0; b < 8 && k < byteLen; b++ {
+					bytes[k] = byte(val >> (b * 8))
+					k++
+				}
+			}
+			num := new(big.Int).SetBytes(bytes)
+			num.Mod(num, max)
 
 			n := pgtype.Numeric{Int: num, Exp: int32(j), Valid: true}
 			tests = append(tests, pgxtest.ValueRoundTripTest{n, new(pgtype.Numeric), isExpectedEqNumeric(n)})

pgxpool/pool.go

@@ -3,7 +3,7 @@ package pgxpool
 import (
 	"context"
 	"errors"
-	"math/rand"
+	"math/rand/v2"
 	"runtime"
 	"strconv"
 	"sync"

stdlib/sql.go

@@ -85,7 +85,7 @@ import (
 	"fmt"
 	"io"
 	"math"
-	"math/rand"
+	"math/rand/v2"
 	"reflect"
 	"slices"
 	"strconv"