mirrors/uquic
1
0
Fork 0
mirror of https://github.com/refraction-networking/uquic.git synced 2025-04-03 20:27:35 +03:00
Code Issues Projects Releases Packages Wiki Activity

bump go.mod version to Go 1.23, run 1.23 and 1.24 on CI (#4880)

Browse source
This commit is contained in:
Marten Seemann 2025-02-13 12:49:54 +01:00 • committed by GitHub
parent 5af39164b9
commit 12f2be058b
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
18 changed files with 160 additions and 185 deletions
Download patch file Download diff file Expand all files Collapse all files

2
.clusterfuzzlite/Dockerfile
View file

@ -3,7 +3,7 @@ FROM gcr.io/oss-fuzz-base/base-builder-go:v1
ARG TARGETPLATFORM
RUN echo "TARGETPLATFORM: ${TARGETPLATFORM}"
ENV GOVERSION=1.23.0
ENV GOVERSION=1.24.0
RUN platform=$(echo ${TARGETPLATFORM} | tr '/' '-') && \
filename="go${GOVERSION}.${platform}.tar.gz" && \

2
.github/workflows/cross-compile.yml vendored
View file

@ -4,7 +4,7 @@ jobs:
strategy:
fail-fast: false
matrix:
go: [ "1.22.x", "1.23.x" ]
go: [ "1.23.x", "1.24.x" ]
runs-on: ${{ fromJSON(vars['CROSS_COMPILE_RUNNER_UBUNTU'] || '"ubuntu-latest"') }}
name: "Cross Compilation (Go ${{matrix.go}})"
timeout-minutes: 30

10
.github/workflows/integration.yml vendored
View file

@ -6,21 +6,21 @@ jobs:
fail-fast: false
matrix:
os: [ "ubuntu" ]
go: [ "1.22.x", "1.23.x" ]
go: [ "1.23.x", "1.24.x" ]
race: [ false ]
use32bit: [ false ]
include:
- os: "ubuntu"
go: "1.23.x"
go: "1.24.x"
race: true
- os: "ubuntu"
go: "1.23.x"
go: "1.24.x"
use32bit: true
- os: "windows"
go: "1.23.x"
go: "1.24.x"
race: false
- os: "macos"
go: "1.23.x"
go: "1.24.x"
race: false
runs-on: ${{ fromJSON(vars[format('INTEGRATION_RUNNER_{0}', matrix.os)] || format('"{0}-latest"', matrix.os)) }}
timeout-minutes: 30

4
.github/workflows/lint.yml vendored
View file

@ -8,7 +8,7 @@ jobs:
- uses: actions/checkout@v4
- uses: actions/setup-go@v5
with:
go-version: "1.23.x"
go-version: "1.24.x"
- name: Check that no non-test files import Ginkgo or Gomega
run: .github/workflows/no_ginkgo.sh
- name: Check for //go:build ignore in .go files
@ -39,7 +39,7 @@ jobs:
strategy:
fail-fast: false
matrix:
go: [ "1.22.x", "1.23.x" ]
go: [ "1.23.x", "1.24.x" ]
env:
GOLANGCI_LINT_VERSION: v1.64.4
name: golangci-lint (Go ${{ matrix.go }})

2
.github/workflows/unit.yml vendored
View file

@ -7,7 +7,7 @@ jobs:
fail-fast: false
matrix:
os: [ "ubuntu", "windows", "macos" ]
go: [ "1.22.x", "1.23.x" ]
go: [ "1.23.x", "1.24.x" ]
runs-on: ${{ fromJSON(vars[format('UNIT_RUNNER_{0}', matrix.os)] || format('"{0}-latest"', matrix.os)) }}
name: Unit tests (${{ matrix.os}}, Go ${{ matrix.go }})
timeout-minutes: 30

2
go.mod
View file

@ -1,6 +1,6 @@
module github.com/quic-go/quic-go
go 1.22
go 1.23
require (
github.com/francoispqt/gojay v1.2.13

4
integrationtests/gomodvendor/go.mod
View file

@ -1,8 +1,8 @@
module test
go 1.22
go 1.23
toolchain go1.22.4
toolchain go1.23.4
// The version doesn't matter here, as we're replacing it with the currently checked out code anyway.
require github.com/quic-go/quic-go v0.21.0

2
internal/handshake/hkdf.go
View file

@ -8,8 +8,6 @@ import (
)
// hkdfExpandLabel HKDF expands a label as defined in RFC 8446, section 7.1.
// Since this implementation avoids using a cryptobyte.Builder, it is about 15% faster than the
// hkdfExpandLabel in the standard library.
func hkdfExpandLabel(hash crypto.Hash, secret, context []byte, label string, length int) []byte {
b := make([]byte, 3, 3+6+len(label)+1+len(context))
binary.BigEndian.PutUint16(b, uint16(length))

51
internal/handshake/hkdf_test.go
View file

@ -3,15 +3,16 @@ package handshake
import (
"crypto"
"crypto/cipher"
"crypto/rand"
"crypto/tls"
"testing"
"unsafe"
"golang.org/x/exp/rand"
"github.com/stretchr/testify/require"
)
var tls13CipherSuites = []uint16{tls.TLS_AES_128_GCM_SHA256, tls.TLS_AES_256_GCM_SHA384, tls.TLS_CHACHA20_POLY1305_SHA256}
type cipherSuiteTLS13 struct {
ID uint16
KeyLen int
@ -32,43 +33,31 @@ func cipherSuiteTLS13ByID(id uint16) *cipherSuiteTLS13 {
return nil
}
//go:linkname expandLabel crypto/tls.(*cipherSuiteTLS13).expandLabel
func expandLabel(cs *cipherSuiteTLS13, secret []byte, label string, context []byte, length int) []byte
//go:linkname nextTrafficSecret crypto/tls.(*cipherSuiteTLS13).nextTrafficSecret
func nextTrafficSecret(cs *cipherSuiteTLS13, trafficSecret []byte) []byte
func TestHKDF(t *testing.T) {
testCases := []struct {
name string
cipherSuite uint16
secret []byte
context []byte
label string
length int
}{
{"TLS_AES_128_GCM_SHA256", tls.TLS_AES_128_GCM_SHA256, []byte("secret"), []byte("context"), "label", 42},
{"TLS_AES_256_GCM_SHA384", tls.TLS_AES_256_GCM_SHA384, []byte("secret"), []byte("context"), "label", 100},
{"TLS_CHACHA20_POLY1305_SHA256", tls.TLS_CHACHA20_POLY1305_SHA256, []byte("secret"), []byte("context"), "label", 77},
}
for _, tc := range testCases {
t.Run(tc.name, func(t *testing.T) {
cs := cipherSuiteTLS13ByID(tc.cipherSuite)
expected := expandLabel(cs, tc.secret, tc.label, tc.context, tc.length)
expanded := hkdfExpandLabel(cs.Hash, tc.secret, tc.context, tc.label, tc.length)
for _, id := range tls13CipherSuites {
t.Run(tls.CipherSuiteName(id), func(t *testing.T) {
cs := cipherSuiteTLS13ByID(id)
expected := nextTrafficSecret(cs, []byte("foobar"))
expanded := hkdfExpandLabel(cs.Hash, []byte("foobar"), nil, "traffic upd", cs.Hash.Size())
require.Equal(t, expected, expanded)
})
}
}
// As of Go 1.24, the standard library and our implementation of hkdfExpandLabel should provide the same performance.
func BenchmarkHKDFExpandLabelStandardLibrary(b *testing.B) {
b.Run("TLS_AES_128_GCM_SHA256", func(b *testing.B) { benchmarkHKDFExpandLabel(b, tls.TLS_AES_128_GCM_SHA256, true) })
b.Run("TLS_AES_256_GCM_SHA384", func(b *testing.B) { benchmarkHKDFExpandLabel(b, tls.TLS_AES_256_GCM_SHA384, true) })
b.Run("TLS_CHACHA20_POLY1305_SHA256", func(b *testing.B) { benchmarkHKDFExpandLabel(b, tls.TLS_CHACHA20_POLY1305_SHA256, true) })
for _, id := range tls13CipherSuites {
b.Run(tls.CipherSuiteName(id), func(b *testing.B) { benchmarkHKDFExpandLabel(b, id, true) })
}
}
func BenchmarkHKDFExpandLabelOptimized(b *testing.B) {
b.Run("TLS_AES_128_GCM_SHA256", func(b *testing.B) { benchmarkHKDFExpandLabel(b, tls.TLS_AES_128_GCM_SHA256, false) })
b.Run("TLS_AES_256_GCM_SHA384", func(b *testing.B) { benchmarkHKDFExpandLabel(b, tls.TLS_AES_256_GCM_SHA384, false) })
b.Run("TLS_CHACHA20_POLY1305_SHA256", func(b *testing.B) { benchmarkHKDFExpandLabel(b, tls.TLS_CHACHA20_POLY1305_SHA256, false) })
func BenchmarkHKDFExpandLabelOurs(b *testing.B) {
for _, id := range tls13CipherSuites {
b.Run(tls.CipherSuiteName(id), func(b *testing.B) { benchmarkHKDFExpandLabel(b, id, false) })
}
}
func benchmarkHKDFExpandLabel(b *testing.B, cipherSuite uint16, useStdLib bool) {
@ -79,9 +68,9 @@ func benchmarkHKDFExpandLabel(b *testing.B, cipherSuite uint16, useStdLib bool)
b.ResetTimer()
for i := 0; i < b.N; i++ {
if useStdLib {
expandLabel(cs, secret, "label", []byte("context"), 42)
nextTrafficSecret(cs, secret)
} else {
hkdfExpandLabel(cs.Hash, secret, []byte("context"), "label", 42)
hkdfExpandLabel(cs.Hash, secret, nil, "traffic upd", cs.Hash.Size())
}
}
}

141
internal/mocks/logging/internal/connection_tracer.go
View file

@ -14,9 +14,6 @@ import (
reflect "reflect"
time "time"
protocol "github.com/quic-go/quic-go/internal/protocol"
utils "github.com/quic-go/quic-go/internal/utils"
wire "github.com/quic-go/quic-go/internal/wire"
logging "github.com/quic-go/quic-go/logging"
gomock "go.uber.org/mock/gomock"
)
@ -46,7 +43,7 @@ func (m *MockConnectionTracer) EXPECT() *MockConnectionTracerMockRecorder {
}
// AcknowledgedPacket mocks base method.
func (m *MockConnectionTracer) AcknowledgedPacket(arg0 protocol.EncryptionLevel, arg1 protocol.PacketNumber) {
func (m *MockConnectionTracer) AcknowledgedPacket(arg0 logging.EncryptionLevel, arg1 logging.PacketNumber) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "AcknowledgedPacket", arg0, arg1)
}
@ -70,19 +67,19 @@ func (c *MockConnectionTracerAcknowledgedPacketCall) Return() *MockConnectionTra
}
// Do rewrite *gomock.Call.Do
func (c *MockConnectionTracerAcknowledgedPacketCall) Do(f func(protocol.EncryptionLevel, protocol.PacketNumber)) *MockConnectionTracerAcknowledgedPacketCall {
func (c *MockConnectionTracerAcknowledgedPacketCall) Do(f func(logging.EncryptionLevel, logging.PacketNumber)) *MockConnectionTracerAcknowledgedPacketCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockConnectionTracerAcknowledgedPacketCall) DoAndReturn(f func(protocol.EncryptionLevel, protocol.PacketNumber)) *MockConnectionTracerAcknowledgedPacketCall {
func (c *MockConnectionTracerAcknowledgedPacketCall) DoAndReturn(f func(logging.EncryptionLevel, logging.PacketNumber)) *MockConnectionTracerAcknowledgedPacketCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// BufferedPacket mocks base method.
func (m *MockConnectionTracer) BufferedPacket(arg0 logging.PacketType, arg1 protocol.ByteCount) {
func (m *MockConnectionTracer) BufferedPacket(arg0 logging.PacketType, arg1 logging.ByteCount) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "BufferedPacket", arg0, arg1)
}
@ -106,13 +103,13 @@ func (c *MockConnectionTracerBufferedPacketCall) Return() *MockConnectionTracerB
}
// Do rewrite *gomock.Call.Do
func (c *MockConnectionTracerBufferedPacketCall) Do(f func(logging.PacketType, protocol.ByteCount)) *MockConnectionTracerBufferedPacketCall {
func (c *MockConnectionTracerBufferedPacketCall) Do(f func(logging.PacketType, logging.ByteCount)) *MockConnectionTracerBufferedPacketCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockConnectionTracerBufferedPacketCall) DoAndReturn(f func(logging.PacketType, protocol.ByteCount)) *MockConnectionTracerBufferedPacketCall {
func (c *MockConnectionTracerBufferedPacketCall) DoAndReturn(f func(logging.PacketType, logging.ByteCount)) *MockConnectionTracerBufferedPacketCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
@ -262,7 +259,7 @@ func (c *MockConnectionTracerDebugCall) DoAndReturn(f func(string, string)) *Moc
}
// DroppedEncryptionLevel mocks base method.
func (m *MockConnectionTracer) DroppedEncryptionLevel(arg0 protocol.EncryptionLevel) {
func (m *MockConnectionTracer) DroppedEncryptionLevel(arg0 logging.EncryptionLevel) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "DroppedEncryptionLevel", arg0)
}
@ -286,19 +283,19 @@ func (c *MockConnectionTracerDroppedEncryptionLevelCall) Return() *MockConnectio
}
// Do rewrite *gomock.Call.Do
func (c *MockConnectionTracerDroppedEncryptionLevelCall) Do(f func(protocol.EncryptionLevel)) *MockConnectionTracerDroppedEncryptionLevelCall {
func (c *MockConnectionTracerDroppedEncryptionLevelCall) Do(f func(logging.EncryptionLevel)) *MockConnectionTracerDroppedEncryptionLevelCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockConnectionTracerDroppedEncryptionLevelCall) DoAndReturn(f func(protocol.EncryptionLevel)) *MockConnectionTracerDroppedEncryptionLevelCall {
func (c *MockConnectionTracerDroppedEncryptionLevelCall) DoAndReturn(f func(logging.EncryptionLevel)) *MockConnectionTracerDroppedEncryptionLevelCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// DroppedKey mocks base method.
func (m *MockConnectionTracer) DroppedKey(generation protocol.KeyPhase) {
func (m *MockConnectionTracer) DroppedKey(generation logging.KeyPhase) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "DroppedKey", generation)
}
@ -322,19 +319,19 @@ func (c *MockConnectionTracerDroppedKeyCall) Return() *MockConnectionTracerDropp
}
// Do rewrite *gomock.Call.Do
func (c *MockConnectionTracerDroppedKeyCall) Do(f func(protocol.KeyPhase)) *MockConnectionTracerDroppedKeyCall {
func (c *MockConnectionTracerDroppedKeyCall) Do(f func(logging.KeyPhase)) *MockConnectionTracerDroppedKeyCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockConnectionTracerDroppedKeyCall) DoAndReturn(f func(protocol.KeyPhase)) *MockConnectionTracerDroppedKeyCall {
func (c *MockConnectionTracerDroppedKeyCall) DoAndReturn(f func(logging.KeyPhase)) *MockConnectionTracerDroppedKeyCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// DroppedPacket mocks base method.
func (m *MockConnectionTracer) DroppedPacket(arg0 logging.PacketType, arg1 protocol.PacketNumber, arg2 protocol.ByteCount, arg3 logging.PacketDropReason) {
func (m *MockConnectionTracer) DroppedPacket(arg0 logging.PacketType, arg1 logging.PacketNumber, arg2 logging.ByteCount, arg3 logging.PacketDropReason) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "DroppedPacket", arg0, arg1, arg2, arg3)
}
@ -358,13 +355,13 @@ func (c *MockConnectionTracerDroppedPacketCall) Return() *MockConnectionTracerDr
}
// Do rewrite *gomock.Call.Do
func (c *MockConnectionTracerDroppedPacketCall) Do(f func(logging.PacketType, protocol.PacketNumber, protocol.ByteCount, logging.PacketDropReason)) *MockConnectionTracerDroppedPacketCall {
func (c *MockConnectionTracerDroppedPacketCall) Do(f func(logging.PacketType, logging.PacketNumber, logging.ByteCount, logging.PacketDropReason)) *MockConnectionTracerDroppedPacketCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockConnectionTracerDroppedPacketCall) DoAndReturn(f func(logging.PacketType, protocol.PacketNumber, protocol.ByteCount, logging.PacketDropReason)) *MockConnectionTracerDroppedPacketCall {
func (c *MockConnectionTracerDroppedPacketCall) DoAndReturn(f func(logging.PacketType, logging.PacketNumber, logging.ByteCount, logging.PacketDropReason)) *MockConnectionTracerDroppedPacketCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
@ -442,7 +439,7 @@ func (c *MockConnectionTracerLossTimerCanceledCall) DoAndReturn(f func()) *MockC
}
// LossTimerExpired mocks base method.
func (m *MockConnectionTracer) LossTimerExpired(arg0 logging.TimerType, arg1 protocol.EncryptionLevel) {
func (m *MockConnectionTracer) LossTimerExpired(arg0 logging.TimerType, arg1 logging.EncryptionLevel) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "LossTimerExpired", arg0, arg1)
}
@ -466,19 +463,19 @@ func (c *MockConnectionTracerLossTimerExpiredCall) Return() *MockConnectionTrace
}
// Do rewrite *gomock.Call.Do
func (c *MockConnectionTracerLossTimerExpiredCall) Do(f func(logging.TimerType, protocol.EncryptionLevel)) *MockConnectionTracerLossTimerExpiredCall {
func (c *MockConnectionTracerLossTimerExpiredCall) Do(f func(logging.TimerType, logging.EncryptionLevel)) *MockConnectionTracerLossTimerExpiredCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockConnectionTracerLossTimerExpiredCall) DoAndReturn(f func(logging.TimerType, protocol.EncryptionLevel)) *MockConnectionTracerLossTimerExpiredCall {
func (c *MockConnectionTracerLossTimerExpiredCall) DoAndReturn(f func(logging.TimerType, logging.EncryptionLevel)) *MockConnectionTracerLossTimerExpiredCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// LostPacket mocks base method.
func (m *MockConnectionTracer) LostPacket(arg0 protocol.EncryptionLevel, arg1 protocol.PacketNumber, arg2 logging.PacketLossReason) {
func (m *MockConnectionTracer) LostPacket(arg0 logging.EncryptionLevel, arg1 logging.PacketNumber, arg2 logging.PacketLossReason) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "LostPacket", arg0, arg1, arg2)
}
@ -502,19 +499,19 @@ func (c *MockConnectionTracerLostPacketCall) Return() *MockConnectionTracerLostP
}
// Do rewrite *gomock.Call.Do
func (c *MockConnectionTracerLostPacketCall) Do(f func(protocol.EncryptionLevel, protocol.PacketNumber, logging.PacketLossReason)) *MockConnectionTracerLostPacketCall {
func (c *MockConnectionTracerLostPacketCall) Do(f func(logging.EncryptionLevel, logging.PacketNumber, logging.PacketLossReason)) *MockConnectionTracerLostPacketCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockConnectionTracerLostPacketCall) DoAndReturn(f func(protocol.EncryptionLevel, protocol.PacketNumber, logging.PacketLossReason)) *MockConnectionTracerLostPacketCall {
func (c *MockConnectionTracerLostPacketCall) DoAndReturn(f func(logging.EncryptionLevel, logging.PacketNumber, logging.PacketLossReason)) *MockConnectionTracerLostPacketCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// NegotiatedVersion mocks base method.
func (m *MockConnectionTracer) NegotiatedVersion(chosen protocol.Version, clientVersions, serverVersions []protocol.Version) {
func (m *MockConnectionTracer) NegotiatedVersion(chosen logging.Version, clientVersions, serverVersions []logging.Version) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "NegotiatedVersion", chosen, clientVersions, serverVersions)
}
@ -538,19 +535,19 @@ func (c *MockConnectionTracerNegotiatedVersionCall) Return() *MockConnectionTrac
}
// Do rewrite *gomock.Call.Do
func (c *MockConnectionTracerNegotiatedVersionCall) Do(f func(protocol.Version, []protocol.Version, []protocol.Version)) *MockConnectionTracerNegotiatedVersionCall {
func (c *MockConnectionTracerNegotiatedVersionCall) Do(f func(logging.Version, []logging.Version, []logging.Version)) *MockConnectionTracerNegotiatedVersionCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockConnectionTracerNegotiatedVersionCall) DoAndReturn(f func(protocol.Version, []protocol.Version, []protocol.Version)) *MockConnectionTracerNegotiatedVersionCall {
func (c *MockConnectionTracerNegotiatedVersionCall) DoAndReturn(f func(logging.Version, []logging.Version, []logging.Version)) *MockConnectionTracerNegotiatedVersionCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// ReceivedLongHeaderPacket mocks base method.
func (m *MockConnectionTracer) ReceivedLongHeaderPacket(arg0 *wire.ExtendedHeader, arg1 protocol.ByteCount, arg2 protocol.ECN, arg3 []logging.Frame) {
func (m *MockConnectionTracer) ReceivedLongHeaderPacket(arg0 *logging.ExtendedHeader, arg1 logging.ByteCount, arg2 logging.ECN, arg3 []logging.Frame) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "ReceivedLongHeaderPacket", arg0, arg1, arg2, arg3)
}
@ -574,19 +571,19 @@ func (c *MockConnectionTracerReceivedLongHeaderPacketCall) Return() *MockConnect
}
// Do rewrite *gomock.Call.Do
func (c *MockConnectionTracerReceivedLongHeaderPacketCall) Do(f func(*wire.ExtendedHeader, protocol.ByteCount, protocol.ECN, []logging.Frame)) *MockConnectionTracerReceivedLongHeaderPacketCall {
func (c *MockConnectionTracerReceivedLongHeaderPacketCall) Do(f func(*logging.ExtendedHeader, logging.ByteCount, logging.ECN, []logging.Frame)) *MockConnectionTracerReceivedLongHeaderPacketCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockConnectionTracerReceivedLongHeaderPacketCall) DoAndReturn(f func(*wire.ExtendedHeader, protocol.ByteCount, protocol.ECN, []logging.Frame)) *MockConnectionTracerReceivedLongHeaderPacketCall {
func (c *MockConnectionTracerReceivedLongHeaderPacketCall) DoAndReturn(f func(*logging.ExtendedHeader, logging.ByteCount, logging.ECN, []logging.Frame)) *MockConnectionTracerReceivedLongHeaderPacketCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// ReceivedRetry mocks base method.
func (m *MockConnectionTracer) ReceivedRetry(arg0 *wire.Header) {
func (m *MockConnectionTracer) ReceivedRetry(arg0 *logging.Header) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "ReceivedRetry", arg0)
}
@ -610,19 +607,19 @@ func (c *MockConnectionTracerReceivedRetryCall) Return() *MockConnectionTracerRe
}
// Do rewrite *gomock.Call.Do
func (c *MockConnectionTracerReceivedRetryCall) Do(f func(*wire.Header)) *MockConnectionTracerReceivedRetryCall {
func (c *MockConnectionTracerReceivedRetryCall) Do(f func(*logging.Header)) *MockConnectionTracerReceivedRetryCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockConnectionTracerReceivedRetryCall) DoAndReturn(f func(*wire.Header)) *MockConnectionTracerReceivedRetryCall {
func (c *MockConnectionTracerReceivedRetryCall) DoAndReturn(f func(*logging.Header)) *MockConnectionTracerReceivedRetryCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// ReceivedShortHeaderPacket mocks base method.
func (m *MockConnectionTracer) ReceivedShortHeaderPacket(arg0 *logging.ShortHeader, arg1 protocol.ByteCount, arg2 protocol.ECN, arg3 []logging.Frame) {
func (m *MockConnectionTracer) ReceivedShortHeaderPacket(arg0 *logging.ShortHeader, arg1 logging.ByteCount, arg2 logging.ECN, arg3 []logging.Frame) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "ReceivedShortHeaderPacket", arg0, arg1, arg2, arg3)
}
@ -646,19 +643,19 @@ func (c *MockConnectionTracerReceivedShortHeaderPacketCall) Return() *MockConnec
}
// Do rewrite *gomock.Call.Do
func (c *MockConnectionTracerReceivedShortHeaderPacketCall) Do(f func(*logging.ShortHeader, protocol.ByteCount, protocol.ECN, []logging.Frame)) *MockConnectionTracerReceivedShortHeaderPacketCall {
func (c *MockConnectionTracerReceivedShortHeaderPacketCall) Do(f func(*logging.ShortHeader, logging.ByteCount, logging.ECN, []logging.Frame)) *MockConnectionTracerReceivedShortHeaderPacketCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockConnectionTracerReceivedShortHeaderPacketCall) DoAndReturn(f func(*logging.ShortHeader, protocol.ByteCount, protocol.ECN, []logging.Frame)) *MockConnectionTracerReceivedShortHeaderPacketCall {
func (c *MockConnectionTracerReceivedShortHeaderPacketCall) DoAndReturn(f func(*logging.ShortHeader, logging.ByteCount, logging.ECN, []logging.Frame)) *MockConnectionTracerReceivedShortHeaderPacketCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// ReceivedTransportParameters mocks base method.
func (m *MockConnectionTracer) ReceivedTransportParameters(arg0 *wire.TransportParameters) {
func (m *MockConnectionTracer) ReceivedTransportParameters(arg0 *logging.TransportParameters) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "ReceivedTransportParameters", arg0)
}
@ -682,19 +679,19 @@ func (c *MockConnectionTracerReceivedTransportParametersCall) Return() *MockConn
}
// Do rewrite *gomock.Call.Do
func (c *MockConnectionTracerReceivedTransportParametersCall) Do(f func(*wire.TransportParameters)) *MockConnectionTracerReceivedTransportParametersCall {
func (c *MockConnectionTracerReceivedTransportParametersCall) Do(f func(*logging.TransportParameters)) *MockConnectionTracerReceivedTransportParametersCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockConnectionTracerReceivedTransportParametersCall) DoAndReturn(f func(*wire.TransportParameters)) *MockConnectionTracerReceivedTransportParametersCall {
func (c *MockConnectionTracerReceivedTransportParametersCall) DoAndReturn(f func(*logging.TransportParameters)) *MockConnectionTracerReceivedTransportParametersCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// ReceivedVersionNegotiationPacket mocks base method.
func (m *MockConnectionTracer) ReceivedVersionNegotiationPacket(dest, src protocol.ArbitraryLenConnectionID, arg2 []protocol.Version) {
func (m *MockConnectionTracer) ReceivedVersionNegotiationPacket(dest, src logging.ArbitraryLenConnectionID, arg2 []logging.Version) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "ReceivedVersionNegotiationPacket", dest, src, arg2)
}
@ -718,19 +715,19 @@ func (c *MockConnectionTracerReceivedVersionNegotiationPacketCall) Return() *Moc
}
// Do rewrite *gomock.Call.Do
func (c *MockConnectionTracerReceivedVersionNegotiationPacketCall) Do(f func(protocol.ArbitraryLenConnectionID, protocol.ArbitraryLenConnectionID, []protocol.Version)) *MockConnectionTracerReceivedVersionNegotiationPacketCall {
func (c *MockConnectionTracerReceivedVersionNegotiationPacketCall) Do(f func(logging.ArbitraryLenConnectionID, logging.ArbitraryLenConnectionID, []logging.Version)) *MockConnectionTracerReceivedVersionNegotiationPacketCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockConnectionTracerReceivedVersionNegotiationPacketCall) DoAndReturn(f func(protocol.ArbitraryLenConnectionID, protocol.ArbitraryLenConnectionID, []protocol.Version)) *MockConnectionTracerReceivedVersionNegotiationPacketCall {
func (c *MockConnectionTracerReceivedVersionNegotiationPacketCall) DoAndReturn(f func(logging.ArbitraryLenConnectionID, logging.ArbitraryLenConnectionID, []logging.Version)) *MockConnectionTracerReceivedVersionNegotiationPacketCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// RestoredTransportParameters mocks base method.
func (m *MockConnectionTracer) RestoredTransportParameters(parameters *wire.TransportParameters) {
func (m *MockConnectionTracer) RestoredTransportParameters(parameters *logging.TransportParameters) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "RestoredTransportParameters", parameters)
}
@ -754,19 +751,19 @@ func (c *MockConnectionTracerRestoredTransportParametersCall) Return() *MockConn
}
// Do rewrite *gomock.Call.Do
func (c *MockConnectionTracerRestoredTransportParametersCall) Do(f func(*wire.TransportParameters)) *MockConnectionTracerRestoredTransportParametersCall {
func (c *MockConnectionTracerRestoredTransportParametersCall) Do(f func(*logging.TransportParameters)) *MockConnectionTracerRestoredTransportParametersCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockConnectionTracerRestoredTransportParametersCall) DoAndReturn(f func(*wire.TransportParameters)) *MockConnectionTracerRestoredTransportParametersCall {
func (c *MockConnectionTracerRestoredTransportParametersCall) DoAndReturn(f func(*logging.TransportParameters)) *MockConnectionTracerRestoredTransportParametersCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// SentLongHeaderPacket mocks base method.
func (m *MockConnectionTracer) SentLongHeaderPacket(arg0 *wire.ExtendedHeader, arg1 protocol.ByteCount, arg2 protocol.ECN, arg3 *wire.AckFrame, arg4 []logging.Frame) {
func (m *MockConnectionTracer) SentLongHeaderPacket(arg0 *logging.ExtendedHeader, arg1 logging.ByteCount, arg2 logging.ECN, arg3 *logging.AckFrame, arg4 []logging.Frame) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "SentLongHeaderPacket", arg0, arg1, arg2, arg3, arg4)
}
@ -790,19 +787,19 @@ func (c *MockConnectionTracerSentLongHeaderPacketCall) Return() *MockConnectionT
}
// Do rewrite *gomock.Call.Do
func (c *MockConnectionTracerSentLongHeaderPacketCall) Do(f func(*wire.ExtendedHeader, protocol.ByteCount, protocol.ECN, *wire.AckFrame, []logging.Frame)) *MockConnectionTracerSentLongHeaderPacketCall {
func (c *MockConnectionTracerSentLongHeaderPacketCall) Do(f func(*logging.ExtendedHeader, logging.ByteCount, logging.ECN, *logging.AckFrame, []logging.Frame)) *MockConnectionTracerSentLongHeaderPacketCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockConnectionTracerSentLongHeaderPacketCall) DoAndReturn(f func(*wire.ExtendedHeader, protocol.ByteCount, protocol.ECN, *wire.AckFrame, []logging.Frame)) *MockConnectionTracerSentLongHeaderPacketCall {
func (c *MockConnectionTracerSentLongHeaderPacketCall) DoAndReturn(f func(*logging.ExtendedHeader, logging.ByteCount, logging.ECN, *logging.AckFrame, []logging.Frame)) *MockConnectionTracerSentLongHeaderPacketCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// SentShortHeaderPacket mocks base method.
func (m *MockConnectionTracer) SentShortHeaderPacket(arg0 *logging.ShortHeader, arg1 protocol.ByteCount, arg2 protocol.ECN, arg3 *wire.AckFrame, arg4 []logging.Frame) {
func (m *MockConnectionTracer) SentShortHeaderPacket(arg0 *logging.ShortHeader, arg1 logging.ByteCount, arg2 logging.ECN, arg3 *logging.AckFrame, arg4 []logging.Frame) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "SentShortHeaderPacket", arg0, arg1, arg2, arg3, arg4)
}
@ -826,19 +823,19 @@ func (c *MockConnectionTracerSentShortHeaderPacketCall) Return() *MockConnection
}
// Do rewrite *gomock.Call.Do
func (c *MockConnectionTracerSentShortHeaderPacketCall) Do(f func(*logging.ShortHeader, protocol.ByteCount, protocol.ECN, *wire.AckFrame, []logging.Frame)) *MockConnectionTracerSentShortHeaderPacketCall {
func (c *MockConnectionTracerSentShortHeaderPacketCall) Do(f func(*logging.ShortHeader, logging.ByteCount, logging.ECN, *logging.AckFrame, []logging.Frame)) *MockConnectionTracerSentShortHeaderPacketCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockConnectionTracerSentShortHeaderPacketCall) DoAndReturn(f func(*logging.ShortHeader, protocol.ByteCount, protocol.ECN, *wire.AckFrame, []logging.Frame)) *MockConnectionTracerSentShortHeaderPacketCall {
func (c *MockConnectionTracerSentShortHeaderPacketCall) DoAndReturn(f func(*logging.ShortHeader, logging.ByteCount, logging.ECN, *logging.AckFrame, []logging.Frame)) *MockConnectionTracerSentShortHeaderPacketCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// SentTransportParameters mocks base method.
func (m *MockConnectionTracer) SentTransportParameters(arg0 *wire.TransportParameters) {
func (m *MockConnectionTracer) SentTransportParameters(arg0 *logging.TransportParameters) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "SentTransportParameters", arg0)
}
@ -862,19 +859,19 @@ func (c *MockConnectionTracerSentTransportParametersCall) Return() *MockConnecti
}
// Do rewrite *gomock.Call.Do
func (c *MockConnectionTracerSentTransportParametersCall) Do(f func(*wire.TransportParameters)) *MockConnectionTracerSentTransportParametersCall {
func (c *MockConnectionTracerSentTransportParametersCall) Do(f func(*logging.TransportParameters)) *MockConnectionTracerSentTransportParametersCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockConnectionTracerSentTransportParametersCall) DoAndReturn(f func(*wire.TransportParameters)) *MockConnectionTracerSentTransportParametersCall {
func (c *MockConnectionTracerSentTransportParametersCall) DoAndReturn(f func(*logging.TransportParameters)) *MockConnectionTracerSentTransportParametersCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// SetLossTimer mocks base method.
func (m *MockConnectionTracer) SetLossTimer(arg0 logging.TimerType, arg1 protocol.EncryptionLevel, arg2 time.Time) {
func (m *MockConnectionTracer) SetLossTimer(arg0 logging.TimerType, arg1 logging.EncryptionLevel, arg2 time.Time) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "SetLossTimer", arg0, arg1, arg2)
}
@ -898,19 +895,19 @@ func (c *MockConnectionTracerSetLossTimerCall) Return() *MockConnectionTracerSet
}
// Do rewrite *gomock.Call.Do
func (c *MockConnectionTracerSetLossTimerCall) Do(f func(logging.TimerType, protocol.EncryptionLevel, time.Time)) *MockConnectionTracerSetLossTimerCall {
func (c *MockConnectionTracerSetLossTimerCall) Do(f func(logging.TimerType, logging.EncryptionLevel, time.Time)) *MockConnectionTracerSetLossTimerCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockConnectionTracerSetLossTimerCall) DoAndReturn(f func(logging.TimerType, protocol.EncryptionLevel, time.Time)) *MockConnectionTracerSetLossTimerCall {
func (c *MockConnectionTracerSetLossTimerCall) DoAndReturn(f func(logging.TimerType, logging.EncryptionLevel, time.Time)) *MockConnectionTracerSetLossTimerCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// StartedConnection mocks base method.
func (m *MockConnectionTracer) StartedConnection(local, remote net.Addr, srcConnID, destConnID protocol.ConnectionID) {
func (m *MockConnectionTracer) StartedConnection(local, remote net.Addr, srcConnID, destConnID logging.ConnectionID) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "StartedConnection", local, remote, srcConnID, destConnID)
}
@ -934,13 +931,13 @@ func (c *MockConnectionTracerStartedConnectionCall) Return() *MockConnectionTrac
}
// Do rewrite *gomock.Call.Do
func (c *MockConnectionTracerStartedConnectionCall) Do(f func(net.Addr, net.Addr, protocol.ConnectionID, protocol.ConnectionID)) *MockConnectionTracerStartedConnectionCall {
func (c *MockConnectionTracerStartedConnectionCall) Do(f func(net.Addr, net.Addr, logging.ConnectionID, logging.ConnectionID)) *MockConnectionTracerStartedConnectionCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockConnectionTracerStartedConnectionCall) DoAndReturn(f func(net.Addr, net.Addr, protocol.ConnectionID, protocol.ConnectionID)) *MockConnectionTracerStartedConnectionCall {
func (c *MockConnectionTracerStartedConnectionCall) DoAndReturn(f func(net.Addr, net.Addr, logging.ConnectionID, logging.ConnectionID)) *MockConnectionTracerStartedConnectionCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
@ -982,7 +979,7 @@ func (c *MockConnectionTracerUpdatedCongestionStateCall) DoAndReturn(f func(logg
}
// UpdatedKey mocks base method.
func (m *MockConnectionTracer) UpdatedKey(generation protocol.KeyPhase, remote bool) {
func (m *MockConnectionTracer) UpdatedKey(generation logging.KeyPhase, remote bool) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "UpdatedKey", generation, remote)
}
@ -1006,19 +1003,19 @@ func (c *MockConnectionTracerUpdatedKeyCall) Return() *MockConnectionTracerUpdat
}
// Do rewrite *gomock.Call.Do
func (c *MockConnectionTracerUpdatedKeyCall) Do(f func(protocol.KeyPhase, bool)) *MockConnectionTracerUpdatedKeyCall {
func (c *MockConnectionTracerUpdatedKeyCall) Do(f func(logging.KeyPhase, bool)) *MockConnectionTracerUpdatedKeyCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockConnectionTracerUpdatedKeyCall) DoAndReturn(f func(protocol.KeyPhase, bool)) *MockConnectionTracerUpdatedKeyCall {
func (c *MockConnectionTracerUpdatedKeyCall) DoAndReturn(f func(logging.KeyPhase, bool)) *MockConnectionTracerUpdatedKeyCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// UpdatedKeyFromTLS mocks base method.
func (m *MockConnectionTracer) UpdatedKeyFromTLS(arg0 protocol.EncryptionLevel, arg1 protocol.Perspective) {
func (m *MockConnectionTracer) UpdatedKeyFromTLS(arg0 logging.EncryptionLevel, arg1 logging.Perspective) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "UpdatedKeyFromTLS", arg0, arg1)
}
@ -1042,19 +1039,19 @@ func (c *MockConnectionTracerUpdatedKeyFromTLSCall) Return() *MockConnectionTrac
}
// Do rewrite *gomock.Call.Do
func (c *MockConnectionTracerUpdatedKeyFromTLSCall) Do(f func(protocol.EncryptionLevel, protocol.Perspective)) *MockConnectionTracerUpdatedKeyFromTLSCall {
func (c *MockConnectionTracerUpdatedKeyFromTLSCall) Do(f func(logging.EncryptionLevel, logging.Perspective)) *MockConnectionTracerUpdatedKeyFromTLSCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockConnectionTracerUpdatedKeyFromTLSCall) DoAndReturn(f func(protocol.EncryptionLevel, protocol.Perspective)) *MockConnectionTracerUpdatedKeyFromTLSCall {
func (c *MockConnectionTracerUpdatedKeyFromTLSCall) DoAndReturn(f func(logging.EncryptionLevel, logging.Perspective)) *MockConnectionTracerUpdatedKeyFromTLSCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// UpdatedMTU mocks base method.
func (m *MockConnectionTracer) UpdatedMTU(mtu protocol.ByteCount, done bool) {
func (m *MockConnectionTracer) UpdatedMTU(mtu logging.ByteCount, done bool) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "UpdatedMTU", mtu, done)
}
@ -1078,19 +1075,19 @@ func (c *MockConnectionTracerUpdatedMTUCall) Return() *MockConnectionTracerUpdat
}
// Do rewrite *gomock.Call.Do
func (c *MockConnectionTracerUpdatedMTUCall) Do(f func(protocol.ByteCount, bool)) *MockConnectionTracerUpdatedMTUCall {
func (c *MockConnectionTracerUpdatedMTUCall) Do(f func(logging.ByteCount, bool)) *MockConnectionTracerUpdatedMTUCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockConnectionTracerUpdatedMTUCall) DoAndReturn(f func(protocol.ByteCount, bool)) *MockConnectionTracerUpdatedMTUCall {
func (c *MockConnectionTracerUpdatedMTUCall) DoAndReturn(f func(logging.ByteCount, bool)) *MockConnectionTracerUpdatedMTUCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// UpdatedMetrics mocks base method.
func (m *MockConnectionTracer) UpdatedMetrics(rttStats *utils.RTTStats, cwnd, bytesInFlight protocol.ByteCount, packetsInFlight int) {
func (m *MockConnectionTracer) UpdatedMetrics(rttStats *logging.RTTStats, cwnd, bytesInFlight logging.ByteCount, packetsInFlight int) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "UpdatedMetrics", rttStats, cwnd, bytesInFlight, packetsInFlight)
}
@ -1114,13 +1111,13 @@ func (c *MockConnectionTracerUpdatedMetricsCall) Return() *MockConnectionTracerU
}
// Do rewrite *gomock.Call.Do
func (c *MockConnectionTracerUpdatedMetricsCall) Do(f func(*utils.RTTStats, protocol.ByteCount, protocol.ByteCount, int)) *MockConnectionTracerUpdatedMetricsCall {
func (c *MockConnectionTracerUpdatedMetricsCall) Do(f func(*logging.RTTStats, logging.ByteCount, logging.ByteCount, int)) *MockConnectionTracerUpdatedMetricsCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockConnectionTracerUpdatedMetricsCall) DoAndReturn(f func(*utils.RTTStats, protocol.ByteCount, protocol.ByteCount, int)) *MockConnectionTracerUpdatedMetricsCall {
func (c *MockConnectionTracerUpdatedMetricsCall) DoAndReturn(f func(*logging.RTTStats, logging.ByteCount, logging.ByteCount, int)) *MockConnectionTracerUpdatedMetricsCall {
c.Call = c.Call.DoAndReturn(f)
return c
}

20
internal/mocks/logging/internal/tracer.go
View file

@ -13,8 +13,6 @@ import (
net "net"
reflect "reflect"
protocol "github.com/quic-go/quic-go/internal/protocol"
wire "github.com/quic-go/quic-go/internal/wire"
logging "github.com/quic-go/quic-go/logging"
gomock "go.uber.org/mock/gomock"
)
@ -116,7 +114,7 @@ func (c *MockTracerDebugCall) DoAndReturn(f func(string, string)) *MockTracerDeb
}
// DroppedPacket mocks base method.
func (m *MockTracer) DroppedPacket(arg0 net.Addr, arg1 logging.PacketType, arg2 protocol.ByteCount, arg3 logging.PacketDropReason) {
func (m *MockTracer) DroppedPacket(arg0 net.Addr, arg1 logging.PacketType, arg2 logging.ByteCount, arg3 logging.PacketDropReason) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "DroppedPacket", arg0, arg1, arg2, arg3)
}
@ -140,19 +138,19 @@ func (c *MockTracerDroppedPacketCall) Return() *MockTracerDroppedPacketCall {
}
// Do rewrite *gomock.Call.Do
func (c *MockTracerDroppedPacketCall) Do(f func(net.Addr, logging.PacketType, protocol.ByteCount, logging.PacketDropReason)) *MockTracerDroppedPacketCall {
func (c *MockTracerDroppedPacketCall) Do(f func(net.Addr, logging.PacketType, logging.ByteCount, logging.PacketDropReason)) *MockTracerDroppedPacketCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockTracerDroppedPacketCall) DoAndReturn(f func(net.Addr, logging.PacketType, protocol.ByteCount, logging.PacketDropReason)) *MockTracerDroppedPacketCall {
func (c *MockTracerDroppedPacketCall) DoAndReturn(f func(net.Addr, logging.PacketType, logging.ByteCount, logging.PacketDropReason)) *MockTracerDroppedPacketCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// SentPacket mocks base method.
func (m *MockTracer) SentPacket(arg0 net.Addr, arg1 *wire.Header, arg2 protocol.ByteCount, arg3 []logging.Frame) {
func (m *MockTracer) SentPacket(arg0 net.Addr, arg1 *logging.Header, arg2 logging.ByteCount, arg3 []logging.Frame) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "SentPacket", arg0, arg1, arg2, arg3)
}
@ -176,19 +174,19 @@ func (c *MockTracerSentPacketCall) Return() *MockTracerSentPacketCall {
}
// Do rewrite *gomock.Call.Do
func (c *MockTracerSentPacketCall) Do(f func(net.Addr, *wire.Header, protocol.ByteCount, []logging.Frame)) *MockTracerSentPacketCall {
func (c *MockTracerSentPacketCall) Do(f func(net.Addr, *logging.Header, logging.ByteCount, []logging.Frame)) *MockTracerSentPacketCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockTracerSentPacketCall) DoAndReturn(f func(net.Addr, *wire.Header, protocol.ByteCount, []logging.Frame)) *MockTracerSentPacketCall {
func (c *MockTracerSentPacketCall) DoAndReturn(f func(net.Addr, *logging.Header, logging.ByteCount, []logging.Frame)) *MockTracerSentPacketCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// SentVersionNegotiationPacket mocks base method.
func (m *MockTracer) SentVersionNegotiationPacket(arg0 net.Addr, dest, src protocol.ArbitraryLenConnectionID, arg3 []protocol.Version) {
func (m *MockTracer) SentVersionNegotiationPacket(arg0 net.Addr, dest, src logging.ArbitraryLenConnectionID, arg3 []logging.Version) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "SentVersionNegotiationPacket", arg0, dest, src, arg3)
}
@ -212,13 +210,13 @@ func (c *MockTracerSentVersionNegotiationPacketCall) Return() *MockTracerSentVer
}
// Do rewrite *gomock.Call.Do
func (c *MockTracerSentVersionNegotiationPacketCall) Do(f func(net.Addr, protocol.ArbitraryLenConnectionID, protocol.ArbitraryLenConnectionID, []protocol.Version)) *MockTracerSentVersionNegotiationPacketCall {
func (c *MockTracerSentVersionNegotiationPacketCall) Do(f func(net.Addr, logging.ArbitraryLenConnectionID, logging.ArbitraryLenConnectionID, []logging.Version)) *MockTracerSentVersionNegotiationPacketCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockTracerSentVersionNegotiationPacketCall) DoAndReturn(f func(net.Addr, protocol.ArbitraryLenConnectionID, protocol.ArbitraryLenConnectionID, []protocol.Version)) *MockTracerSentVersionNegotiationPacketCall {
func (c *MockTracerSentVersionNegotiationPacketCall) DoAndReturn(f func(net.Addr, logging.ArbitraryLenConnectionID, logging.ArbitraryLenConnectionID, []logging.Version)) *MockTracerSentVersionNegotiationPacketCall {
c.Call = c.Call.DoAndReturn(f)
return c
}

7
internal/mocks/quic/early_conn.go
View file

@ -15,7 +15,6 @@ import (
reflect "reflect"
quic "github.com/quic-go/quic-go"
qerr "github.com/quic-go/quic-go/internal/qerr"
gomock "go.uber.org/mock/gomock"
)
@ -122,7 +121,7 @@ func (c *MockEarlyConnectionAcceptUniStreamCall) DoAndReturn(f func(context.Cont
}
// CloseWithError mocks base method.
func (m *MockEarlyConnection) CloseWithError(arg0 qerr.ApplicationErrorCode, arg1 string) error {
func (m *MockEarlyConnection) CloseWithError(arg0 quic.ApplicationErrorCode, arg1 string) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "CloseWithError", arg0, arg1)
ret0, _ := ret[0].(error)
@ -148,13 +147,13 @@ func (c *MockEarlyConnectionCloseWithErrorCall) Return(arg0 error) *MockEarlyCon
}
// Do rewrite *gomock.Call.Do
func (c *MockEarlyConnectionCloseWithErrorCall) Do(f func(qerr.ApplicationErrorCode, string) error) *MockEarlyConnectionCloseWithErrorCall {
func (c *MockEarlyConnectionCloseWithErrorCall) Do(f func(quic.ApplicationErrorCode, string) error) *MockEarlyConnectionCloseWithErrorCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockEarlyConnectionCloseWithErrorCall) DoAndReturn(f func(qerr.ApplicationErrorCode, string) error) *MockEarlyConnectionCloseWithErrorCall {
func (c *MockEarlyConnectionCloseWithErrorCall) DoAndReturn(f func(quic.ApplicationErrorCode, string) error) *MockEarlyConnectionCloseWithErrorCall {
c.Call = c.Call.DoAndReturn(f)
return c
}

25
internal/mocks/quic/stream.go
View file

@ -14,8 +14,7 @@ import (
reflect "reflect"
time "time"
protocol "github.com/quic-go/quic-go/internal/protocol"
qerr "github.com/quic-go/quic-go/internal/qerr"
quic "github.com/quic-go/quic-go"
gomock "go.uber.org/mock/gomock"
)
@ -44,7 +43,7 @@ func (m *MockStream) EXPECT() *MockStreamMockRecorder {
}
// CancelRead mocks base method.
func (m *MockStream) CancelRead(arg0 qerr.StreamErrorCode) {
func (m *MockStream) CancelRead(arg0 quic.StreamErrorCode) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "CancelRead", arg0)
}
@ -68,19 +67,19 @@ func (c *MockStreamCancelReadCall) Return() *MockStreamCancelReadCall {
}
// Do rewrite *gomock.Call.Do
func (c *MockStreamCancelReadCall) Do(f func(qerr.StreamErrorCode)) *MockStreamCancelReadCall {
func (c *MockStreamCancelReadCall) Do(f func(quic.StreamErrorCode)) *MockStreamCancelReadCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockStreamCancelReadCall) DoAndReturn(f func(qerr.StreamErrorCode)) *MockStreamCancelReadCall {
func (c *MockStreamCancelReadCall) DoAndReturn(f func(quic.StreamErrorCode)) *MockStreamCancelReadCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// CancelWrite mocks base method.
func (m *MockStream) CancelWrite(arg0 qerr.StreamErrorCode) {
func (m *MockStream) CancelWrite(arg0 quic.StreamErrorCode) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "CancelWrite", arg0)
}
@ -104,13 +103,13 @@ func (c *MockStreamCancelWriteCall) Return() *MockStreamCancelWriteCall {
}
// Do rewrite *gomock.Call.Do
func (c *MockStreamCancelWriteCall) Do(f func(qerr.StreamErrorCode)) *MockStreamCancelWriteCall {
func (c *MockStreamCancelWriteCall) Do(f func(quic.StreamErrorCode)) *MockStreamCancelWriteCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockStreamCancelWriteCall) DoAndReturn(f func(qerr.StreamErrorCode)) *MockStreamCancelWriteCall {
func (c *MockStreamCancelWriteCall) DoAndReturn(f func(quic.StreamErrorCode)) *MockStreamCancelWriteCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
@ -345,10 +344,10 @@ func (c *MockStreamSetWriteDeadlineCall) DoAndReturn(f func(time.Time) error) *M
}
// StreamID mocks base method.
func (m *MockStream) StreamID() protocol.StreamID {
func (m *MockStream) StreamID() quic.StreamID {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "StreamID")
ret0, _ := ret[0].(protocol.StreamID)
ret0, _ := ret[0].(quic.StreamID)
return ret0
}
@ -365,19 +364,19 @@ type MockStreamStreamIDCall struct {
}
// Return rewrite *gomock.Call.Return
func (c *MockStreamStreamIDCall) Return(arg0 protocol.StreamID) *MockStreamStreamIDCall {
func (c *MockStreamStreamIDCall) Return(arg0 quic.StreamID) *MockStreamStreamIDCall {
c.Call = c.Call.Return(arg0)
return c
}
// Do rewrite *gomock.Call.Do
func (c *MockStreamStreamIDCall) Do(f func() protocol.StreamID) *MockStreamStreamIDCall {
func (c *MockStreamStreamIDCall) Do(f func() quic.StreamID) *MockStreamStreamIDCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockStreamStreamIDCall) DoAndReturn(f func() protocol.StreamID) *MockStreamStreamIDCall {
func (c *MockStreamStreamIDCall) DoAndReturn(f func() quic.StreamID) *MockStreamStreamIDCall {
c.Call = c.Call.DoAndReturn(f)
return c
}

2
interop/Dockerfile
View file

@ -5,7 +5,7 @@ RUN echo "TARGETPLATFORM: ${TARGETPLATFORM}"
RUN apt-get update && apt-get install -y wget tar git
ENV GOVERSION=1.23.0
ENV GOVERSION=1.24.0
RUN platform=$(echo ${TARGETPLATFORM} | tr '/' '-') && \
filename="go${GOVERSION}.${platform}.tar.gz" && \

13
mock_quic_conn_test.go
View file

@ -14,7 +14,6 @@ import (
net "net"
reflect "reflect"
qerr "github.com/quic-go/quic-go/internal/qerr"
gomock "go.uber.org/mock/gomock"
)
@ -121,7 +120,7 @@ func (c *MockQUICConnAcceptUniStreamCall) DoAndReturn(f func(context.Context) (R
}
// CloseWithError mocks base method.
func (m *MockQUICConn) CloseWithError(arg0 qerr.ApplicationErrorCode, arg1 string) error {
func (m *MockQUICConn) CloseWithError(arg0 ApplicationErrorCode, arg1 string) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "CloseWithError", arg0, arg1)
ret0, _ := ret[0].(error)
@ -147,13 +146,13 @@ func (c *MockQUICConnCloseWithErrorCall) Return(arg0 error) *MockQUICConnCloseWi
}
// Do rewrite *gomock.Call.Do
func (c *MockQUICConnCloseWithErrorCall) Do(f func(qerr.ApplicationErrorCode, string) error) *MockQUICConnCloseWithErrorCall {
func (c *MockQUICConnCloseWithErrorCall) Do(f func(ApplicationErrorCode, string) error) *MockQUICConnCloseWithErrorCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockQUICConnCloseWithErrorCall) DoAndReturn(f func(qerr.ApplicationErrorCode, string) error) *MockQUICConnCloseWithErrorCall {
func (c *MockQUICConnCloseWithErrorCall) DoAndReturn(f func(ApplicationErrorCode, string) error) *MockQUICConnCloseWithErrorCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
@ -621,7 +620,7 @@ func (c *MockQUICConnSendDatagramCall) DoAndReturn(f func([]byte) error) *MockQU
}
// closeWithTransportError mocks base method.
func (m *MockQUICConn) closeWithTransportError(arg0 qerr.TransportErrorCode) {
func (m *MockQUICConn) closeWithTransportError(arg0 TransportErrorCode) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "closeWithTransportError", arg0)
}
@ -645,13 +644,13 @@ func (c *MockQUICConncloseWithTransportErrorCall) Return() *MockQUICConncloseWit
}
// Do rewrite *gomock.Call.Do
func (c *MockQUICConncloseWithTransportErrorCall) Do(f func(qerr.TransportErrorCode)) *MockQUICConncloseWithTransportErrorCall {
func (c *MockQUICConncloseWithTransportErrorCall) Do(f func(TransportErrorCode)) *MockQUICConncloseWithTransportErrorCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockQUICConncloseWithTransportErrorCall) DoAndReturn(f func(qerr.TransportErrorCode)) *MockQUICConncloseWithTransportErrorCall {
func (c *MockQUICConncloseWithTransportErrorCall) DoAndReturn(f func(TransportErrorCode)) *MockQUICConncloseWithTransportErrorCall {
c.Call = c.Call.DoAndReturn(f)
return c
}

18
mock_receive_stream_internal_test.go
View file

@ -13,8 +13,6 @@ import (
reflect "reflect"
time "time"
protocol "github.com/quic-go/quic-go/internal/protocol"
qerr "github.com/quic-go/quic-go/internal/qerr"
wire "github.com/quic-go/quic-go/internal/wire"
gomock "go.uber.org/mock/gomock"
)
@ -44,7 +42,7 @@ func (m *MockReceiveStreamI) EXPECT() *MockReceiveStreamIMockRecorder {
}
// CancelRead mocks base method.
func (m *MockReceiveStreamI) CancelRead(arg0 qerr.StreamErrorCode) {
func (m *MockReceiveStreamI) CancelRead(arg0 StreamErrorCode) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "CancelRead", arg0)
}
@ -68,13 +66,13 @@ func (c *MockReceiveStreamICancelReadCall) Return() *MockReceiveStreamICancelRea
}
// Do rewrite *gomock.Call.Do
func (c *MockReceiveStreamICancelReadCall) Do(f func(qerr.StreamErrorCode)) *MockReceiveStreamICancelReadCall {
func (c *MockReceiveStreamICancelReadCall) Do(f func(StreamErrorCode)) *MockReceiveStreamICancelReadCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockReceiveStreamICancelReadCall) DoAndReturn(f func(qerr.StreamErrorCode)) *MockReceiveStreamICancelReadCall {
func (c *MockReceiveStreamICancelReadCall) DoAndReturn(f func(StreamErrorCode)) *MockReceiveStreamICancelReadCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
@ -157,10 +155,10 @@ func (c *MockReceiveStreamISetReadDeadlineCall) DoAndReturn(f func(time.Time) er
}
// StreamID mocks base method.
func (m *MockReceiveStreamI) StreamID() protocol.StreamID {
func (m *MockReceiveStreamI) StreamID() StreamID {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "StreamID")
ret0, _ := ret[0].(protocol.StreamID)
ret0, _ := ret[0].(StreamID)
return ret0
}
@ -177,19 +175,19 @@ type MockReceiveStreamIStreamIDCall struct {
}
// Return rewrite *gomock.Call.Return
func (c *MockReceiveStreamIStreamIDCall) Return(arg0 protocol.StreamID) *MockReceiveStreamIStreamIDCall {
func (c *MockReceiveStreamIStreamIDCall) Return(arg0 StreamID) *MockReceiveStreamIStreamIDCall {
c.Call = c.Call.Return(arg0)
return c
}
// Do rewrite *gomock.Call.Do
func (c *MockReceiveStreamIStreamIDCall) Do(f func() protocol.StreamID) *MockReceiveStreamIStreamIDCall {
func (c *MockReceiveStreamIStreamIDCall) Do(f func() StreamID) *MockReceiveStreamIStreamIDCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockReceiveStreamIStreamIDCall) DoAndReturn(f func() protocol.StreamID) *MockReceiveStreamIStreamIDCall {
func (c *MockReceiveStreamIStreamIDCall) DoAndReturn(f func() StreamID) *MockReceiveStreamIStreamIDCall {
c.Call = c.Call.DoAndReturn(f)
return c
}

17
mock_send_stream_internal_test.go
View file

@ -16,7 +16,6 @@ import (
ackhandler "github.com/quic-go/quic-go/internal/ackhandler"
protocol "github.com/quic-go/quic-go/internal/protocol"
qerr "github.com/quic-go/quic-go/internal/qerr"
wire "github.com/quic-go/quic-go/internal/wire"
gomock "go.uber.org/mock/gomock"
)
@ -46,7 +45,7 @@ func (m *MockSendStreamI) EXPECT() *MockSendStreamIMockRecorder {
}
// CancelWrite mocks base method.
func (m *MockSendStreamI) CancelWrite(arg0 qerr.StreamErrorCode) {
func (m *MockSendStreamI) CancelWrite(arg0 StreamErrorCode) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "CancelWrite", arg0)
}
@ -70,13 +69,13 @@ func (c *MockSendStreamICancelWriteCall) Return() *MockSendStreamICancelWriteCal
}
// Do rewrite *gomock.Call.Do
func (c *MockSendStreamICancelWriteCall) Do(f func(qerr.StreamErrorCode)) *MockSendStreamICancelWriteCall {
func (c *MockSendStreamICancelWriteCall) Do(f func(StreamErrorCode)) *MockSendStreamICancelWriteCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSendStreamICancelWriteCall) DoAndReturn(f func(qerr.StreamErrorCode)) *MockSendStreamICancelWriteCall {
func (c *MockSendStreamICancelWriteCall) DoAndReturn(f func(StreamErrorCode)) *MockSendStreamICancelWriteCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
@ -196,10 +195,10 @@ func (c *MockSendStreamISetWriteDeadlineCall) DoAndReturn(f func(time.Time) erro
}
// StreamID mocks base method.
func (m *MockSendStreamI) StreamID() protocol.StreamID {
func (m *MockSendStreamI) StreamID() StreamID {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "StreamID")
ret0, _ := ret[0].(protocol.StreamID)
ret0, _ := ret[0].(StreamID)
return ret0
}
@ -216,19 +215,19 @@ type MockSendStreamIStreamIDCall struct {
}
// Return rewrite *gomock.Call.Return
func (c *MockSendStreamIStreamIDCall) Return(arg0 protocol.StreamID) *MockSendStreamIStreamIDCall {
func (c *MockSendStreamIStreamIDCall) Return(arg0 StreamID) *MockSendStreamIStreamIDCall {
c.Call = c.Call.Return(arg0)
return c
}
// Do rewrite *gomock.Call.Do
func (c *MockSendStreamIStreamIDCall) Do(f func() protocol.StreamID) *MockSendStreamIStreamIDCall {
func (c *MockSendStreamIStreamIDCall) Do(f func() StreamID) *MockSendStreamIStreamIDCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSendStreamIStreamIDCall) DoAndReturn(f func() protocol.StreamID) *MockSendStreamIStreamIDCall {
func (c *MockSendStreamIStreamIDCall) DoAndReturn(f func() StreamID) *MockSendStreamIStreamIDCall {
c.Call = c.Call.DoAndReturn(f)
return c
}

23
mock_stream_internal_test.go
View file

@ -16,7 +16,6 @@ import (
ackhandler "github.com/quic-go/quic-go/internal/ackhandler"
protocol "github.com/quic-go/quic-go/internal/protocol"
qerr "github.com/quic-go/quic-go/internal/qerr"
wire "github.com/quic-go/quic-go/internal/wire"
gomock "go.uber.org/mock/gomock"
)
@ -46,7 +45,7 @@ func (m *MockStreamI) EXPECT() *MockStreamIMockRecorder {
}
// CancelRead mocks base method.
func (m *MockStreamI) CancelRead(arg0 qerr.StreamErrorCode) {
func (m *MockStreamI) CancelRead(arg0 StreamErrorCode) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "CancelRead", arg0)
}
@ -70,19 +69,19 @@ func (c *MockStreamICancelReadCall) Return() *MockStreamICancelReadCall {
}
// Do rewrite *gomock.Call.Do
func (c *MockStreamICancelReadCall) Do(f func(qerr.StreamErrorCode)) *MockStreamICancelReadCall {
func (c *MockStreamICancelReadCall) Do(f func(StreamErrorCode)) *MockStreamICancelReadCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockStreamICancelReadCall) DoAndReturn(f func(qerr.StreamErrorCode)) *MockStreamICancelReadCall {
func (c *MockStreamICancelReadCall) DoAndReturn(f func(StreamErrorCode)) *MockStreamICancelReadCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// CancelWrite mocks base method.
func (m *MockStreamI) CancelWrite(arg0 qerr.StreamErrorCode) {
func (m *MockStreamI) CancelWrite(arg0 StreamErrorCode) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "CancelWrite", arg0)
}
@ -106,13 +105,13 @@ func (c *MockStreamICancelWriteCall) Return() *MockStreamICancelWriteCall {
}
// Do rewrite *gomock.Call.Do
func (c *MockStreamICancelWriteCall) Do(f func(qerr.StreamErrorCode)) *MockStreamICancelWriteCall {
func (c *MockStreamICancelWriteCall) Do(f func(StreamErrorCode)) *MockStreamICancelWriteCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockStreamICancelWriteCall) DoAndReturn(f func(qerr.StreamErrorCode)) *MockStreamICancelWriteCall {
func (c *MockStreamICancelWriteCall) DoAndReturn(f func(StreamErrorCode)) *MockStreamICancelWriteCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
@ -347,10 +346,10 @@ func (c *MockStreamISetWriteDeadlineCall) DoAndReturn(f func(time.Time) error) *
}
// StreamID mocks base method.
func (m *MockStreamI) StreamID() protocol.StreamID {
func (m *MockStreamI) StreamID() StreamID {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "StreamID")
ret0, _ := ret[0].(protocol.StreamID)
ret0, _ := ret[0].(StreamID)
return ret0
}
@ -367,19 +366,19 @@ type MockStreamIStreamIDCall struct {
}
// Return rewrite *gomock.Call.Return
func (c *MockStreamIStreamIDCall) Return(arg0 protocol.StreamID) *MockStreamIStreamIDCall {
func (c *MockStreamIStreamIDCall) Return(arg0 StreamID) *MockStreamIStreamIDCall {
c.Call = c.Call.Return(arg0)
return c
}
// Do rewrite *gomock.Call.Do
func (c *MockStreamIStreamIDCall) Do(f func() protocol.StreamID) *MockStreamIStreamIDCall {
func (c *MockStreamIStreamIDCall) Do(f func() StreamID) *MockStreamIStreamIDCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockStreamIStreamIDCall) DoAndReturn(f func() protocol.StreamID) *MockStreamIStreamIDCall {
func (c *MockStreamIStreamIDCall) DoAndReturn(f func() StreamID) *MockStreamIStreamIDCall {
c.Call = c.Call.DoAndReturn(f)
return c
}