deprecate quicvarint.Write in favor of quicvarint.Append (#3690)

quicvarint/io_test.go

@@ -80,10 +80,7 @@ var _ = Describe("Varint I/O", func() {
 			})
 
 			It("correctly handles io.EOF", func() {
-				buf := &bytes.Buffer{}
-				Write(buf, 1337)
-
-				r := NewReader(&eofReader{Data: buf.Bytes()})
+				r := NewReader(&eofReader{Data: Append(nil, 1337)})
 				n, err := Read(r)
 				Expect(err).ToNot(HaveOccurred())
 				Expect(n).To(BeEquivalentTo(1337))

quicvarint/varint.go

@@ -71,6 +71,7 @@ func Read(r io.ByteReader) (uint64, error) {
 }
 
 // Write writes i in the QUIC varint format to w.
+// Deprecated: use Append instead.
 func Write(w Writer, i uint64) {
 	if i <= maxVarInt1 {
 		w.WriteByte(uint8(i))
@@ -88,6 +89,7 @@ func Write(w Writer, i uint64) {
 	}
 }
 
+// Append appends i in the QUIC varint format.
 func Append(b []byte, i uint64) []byte {
 	if i <= maxVarInt1 {
 		return append(b, uint8(i))

quicvarint/varint_test.go

@@ -2,7 +2,6 @@ package quicvarint
 
 import (
 	"bytes"
-	"math/rand"
 
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
@@ -64,79 +63,59 @@ var _ = Describe("Varint encoding / decoding", func() {
 	Context("encoding", func() {
 		Context("with minimal length", func() {
 			It("writes a 1 byte number", func() {
-				b := &bytes.Buffer{}
-				Write(b, 37)
-				Expect(b.Bytes()).To(Equal([]byte{0x25}))
+				Expect(Append(nil, 37)).To(Equal([]byte{0x25}))
 			})
 
 			It("writes the maximum 1 byte number in 1 byte", func() {
-				b := &bytes.Buffer{}
-				Write(b, maxVarInt1)
-				Expect(b.Bytes()).To(Equal([]byte{0b00111111}))
+				Expect(Append(nil, maxVarInt1)).To(Equal([]byte{0b00111111}))
 			})
 
 			It("writes the minimum 2 byte number in 2 bytes", func() {
-				b := &bytes.Buffer{}
-				Write(b, maxVarInt1+1)
-				Expect(b.Bytes()).To(Equal([]byte{0x40, maxVarInt1 + 1}))
+				Expect(Append(nil, maxVarInt1+1)).To(Equal([]byte{0x40, maxVarInt1 + 1}))
 			})
 
 			It("writes a 2 byte number", func() {
-				b := &bytes.Buffer{}
-				Write(b, 15293)
-				Expect(b.Bytes()).To(Equal([]byte{0b01000000 ^ 0x3b, 0xbd}))
+				Expect(Append(nil, 15293)).To(Equal([]byte{0b01000000 ^ 0x3b, 0xbd}))
 			})
 
 			It("writes the maximum 2 byte number in 2 bytes", func() {
-				b := &bytes.Buffer{}
-				Write(b, maxVarInt2)
-				Expect(b.Bytes()).To(Equal([]byte{0b01111111, 0xff}))
+				Expect(Append(nil, maxVarInt2)).To(Equal([]byte{0b01111111, 0xff}))
 			})
 
 			It("writes the minimum 4 byte number in 4 bytes", func() {
-				b := &bytes.Buffer{}
-				Write(b, maxVarInt2+1)
-				Expect(b.Len()).To(Equal(4))
-				num, err := Read(b)
+				b := Append(nil, maxVarInt2+1)
+				Expect(b).To(HaveLen(4))
+				num, err := Read(bytes.NewReader(b))
 				Expect(err).ToNot(HaveOccurred())
 				Expect(num).To(Equal(uint64(maxVarInt2 + 1)))
 			})
 
 			It("writes a 4 byte number", func() {
-				b := &bytes.Buffer{}
-				Write(b, 494878333)
-				Expect(b.Bytes()).To(Equal([]byte{0b10000000 ^ 0x1d, 0x7f, 0x3e, 0x7d}))
+				Expect(Append(nil, 494878333)).To(Equal([]byte{0b10000000 ^ 0x1d, 0x7f, 0x3e, 0x7d}))
 			})
 
 			It("writes the maximum 4 byte number in 4 bytes", func() {
-				b := &bytes.Buffer{}
-				Write(b, maxVarInt4)
-				Expect(b.Bytes()).To(Equal([]byte{0b10111111, 0xff, 0xff, 0xff}))
+				Expect(Append(nil, maxVarInt4)).To(Equal([]byte{0b10111111, 0xff, 0xff, 0xff}))
 			})
 
 			It("writes the minimum 8 byte number in 8 bytes", func() {
-				b := &bytes.Buffer{}
-				Write(b, maxVarInt4+1)
-				Expect(b.Len()).To(Equal(8))
-				num, err := Read(b)
+				b := Append(nil, maxVarInt4+1)
+				Expect(b).To(HaveLen(8))
+				num, err := Read(bytes.NewReader(b))
 				Expect(err).ToNot(HaveOccurred())
 				Expect(num).To(Equal(uint64(maxVarInt4 + 1)))
 			})
 
 			It("writes an 8 byte number", func() {
-				b := &bytes.Buffer{}
-				Write(b, 151288809941952652)
-				Expect(b.Bytes()).To(Equal([]byte{0xc2, 0x19, 0x7c, 0x5e, 0xff, 0x14, 0xe8, 0x8c}))
+				Expect(Append(nil, 151288809941952652)).To(Equal([]byte{0xc2, 0x19, 0x7c, 0x5e, 0xff, 0x14, 0xe8, 0x8c}))
 			})
 
 			It("writes the maximum 8 byte number in 8 bytes", func() {
-				b := &bytes.Buffer{}
-				Write(b, maxVarInt8)
-				Expect(b.Bytes()).To(Equal([]byte{0xff /* 11111111 */, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}))
+				Expect(Append(nil, maxVarInt8)).To(Equal([]byte{0xff /* 11111111 */, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}))
 			})
 
 			It("panics when given a too large number (> 62 bit)", func() {
-				Expect(func() { Write(&bytes.Buffer{}, maxVarInt8+1) }).Should(Panic())
+				Expect(func() { Append(nil, maxVarInt8+1) }).Should(Panic())
 			})
 		})
 
@@ -185,34 +164,6 @@ var _ = Describe("Varint encoding / decoding", func() {
 				Expect(Read(bytes.NewReader(b))).To(BeEquivalentTo(494878333))
 			})
 		})
-
-		Context("appending", func() {
-			It("panics when given a too large number (> 62 bit)", func() {
-				Expect(func() { Append(nil, maxVarInt8+1) }).Should(Panic())
-			})
-
-			It("appends", func() {
-				for i := 0; i < 10000; i++ {
-					var limit int64
-					switch rand.Int() % 4 {
-					case 0:
-						limit = maxVarInt1
-					case 1:
-						limit = maxVarInt2
-					case 2:
-						limit = maxVarInt4
-					case 3:
-						limit = maxVarInt8
-					}
-
-					n := uint64(rand.Int63n(limit))
-					b := Append(nil, n)
-					buf := &bytes.Buffer{}
-					Write(buf, n)
-					Expect(b).To(Equal(buf.Bytes()))
-				}
-			})
-		})
 	})
 
 	Context("determining the length needed for encoding", func() {