Drop support for go 1.20

[btrtrc.git] / peer_protocol / decoder_test.go

diff --git a/peer_protocol/decoder_test.go b/peer_protocol/decoder_test.go
index 33909cdc321d96f0e6e978891223566d780627c6..39b54c1c848aa193ed64a50bf19e70abf6bda3d7 100644 (file)
--- a/peer_protocol/decoder_test.go
+++ b/peer_protocol/decoder_test.go
@@ -2,42 +2,31 @@ package peer_protocol
 
 import (
        "bufio"
+       "bytes"
        "io"
        "sync"
        "testing"
 
-       "github.com/bradfitz/iter"
+       qt "github.com/frankban/quicktest"
        "github.com/stretchr/testify/assert"
        "github.com/stretchr/testify/require"
 )
 
 func BenchmarkDecodePieces(t *testing.B) {
-       r, w := io.Pipe()
        const pieceLen = 1 << 14
-       msg := Message{
+       inputMsg := Message{
                Type:  Piece,
                Index: 0,
                Begin: 1,
                Piece: make([]byte, pieceLen),
        }
-       b, err := msg.MarshalBinary()
-       require.NoError(t, err)
+       b := inputMsg.MustMarshalBinary()
        t.SetBytes(int64(len(b)))
-       defer r.Close()
-       go func() {
-               defer w.Close()
-               for {
-                       n, err := w.Write(b)
-                       if err == io.ErrClosedPipe {
-                               return
-                       }
-                       require.NoError(t, err)
-                       require.Equal(t, len(b), n)
-               }
-       }()
+       var r bytes.Reader
+       // Try to somewhat emulate what torrent.Client would do. But the goal is to get decoding as fast
+       // as possible and let consumers apply their own adjustments.
        d := Decoder{
-               // Emulate what package torrent's client would do.
-               R:         bufio.NewReader(r),
+               R:         bufio.NewReaderSize(&r, 1<<10),
                MaxLength: 1 << 18,
                Pool: &sync.Pool{
                        New: func() interface{} {
@@ -46,9 +35,20 @@ func BenchmarkDecodePieces(t *testing.B) {
                        },
                },
        }
-       for range iter.N(t.N) {
+       c := qt.New(t)
+       t.ReportAllocs()
+       t.ResetTimer()
+       for i := 0; i < t.N; i += 1 {
+               r.Reset(b)
                var msg Message
-               require.NoError(t, d.Decode(&msg))
+               err := d.Decode(&msg)
+               if err != nil {
+                       t.Fatal(err)
+               }
+               // This is very expensive, and should be discovered in tests rather than a benchmark.
+               if false {
+                       c.Assert(msg, qt.DeepEquals, inputMsg)
+               }
                // WWJD
                d.Pool.Put(&msg.Piece)
        }
@@ -71,7 +71,7 @@ func TestDecodeShortPieceEOF(t *testing.T) {
        var m Message
        require.NoError(t, d.Decode(&m))
        assert.Len(t, m.Piece, 1)
-       assert.Equal(t, io.EOF, d.Decode(&m))
+       assert.ErrorIs(t, d.Decode(&m), io.EOF)
 }
 
 func TestDecodeOverlongPiece(t *testing.T) {