From 12f2be058b733ea90bb491a95c632a8f1742e23b Mon Sep 17 00:00:00 2001 From: Marten Seemann Date: Thu, 13 Feb 2025 12:49:54 +0100 Subject: [PATCH] bump go.mod version to Go 1.23, run 1.23 and 1.24 on CI (#4880) --- .clusterfuzzlite/Dockerfile | 2 +- .github/workflows/cross-compile.yml | 2 +- .github/workflows/integration.yml | 10 +- .github/workflows/lint.yml | 4 +- .github/workflows/unit.yml | 2 +- go.mod | 2 +- integrationtests/gomodvendor/go.mod | 4 +- internal/handshake/hkdf.go | 2 - internal/handshake/hkdf_test.go | 51 +++---- .../logging/internal/connection_tracer.go | 141 +++++++++--------- internal/mocks/logging/internal/tracer.go | 20 ++- internal/mocks/quic/early_conn.go | 7 +- internal/mocks/quic/stream.go | 25 ++-- interop/Dockerfile | 2 +- mock_quic_conn_test.go | 13 +- mock_receive_stream_internal_test.go | 18 +-- mock_send_stream_internal_test.go | 17 +-- mock_stream_internal_test.go | 23 ++- 18 files changed, 160 insertions(+), 185 deletions(-) diff --git a/.clusterfuzzlite/Dockerfile b/.clusterfuzzlite/Dockerfile index 147762f0..37c479f0 100644 --- a/.clusterfuzzlite/Dockerfile +++ b/.clusterfuzzlite/Dockerfile @@ -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" && \ diff --git a/.github/workflows/cross-compile.yml b/.github/workflows/cross-compile.yml index 6bbd176f..fb034020 100644 --- a/.github/workflows/cross-compile.yml +++ b/.github/workflows/cross-compile.yml @@ -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 diff --git a/.github/workflows/integration.yml b/.github/workflows/integration.yml index 55c0f3a9..dcfc4eda 100644 --- a/.github/workflows/integration.yml +++ b/.github/workflows/integration.yml @@ -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 diff --git a/.github/workflows/lint.yml b/.github/workflows/lint.yml index b17e06de..6006b36a 100644 --- a/.github/workflows/lint.yml +++ b/.github/workflows/lint.yml @@ -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 }}) diff --git a/.github/workflows/unit.yml b/.github/workflows/unit.yml index c4253247..12bea2e5 100644 --- a/.github/workflows/unit.yml +++ b/.github/workflows/unit.yml @@ -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 diff --git a/go.mod b/go.mod index 93268311..d57589f6 100644 --- a/go.mod +++ b/go.mod @@ -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 diff --git a/integrationtests/gomodvendor/go.mod b/integrationtests/gomodvendor/go.mod index a2cb938b..6c8f0313 100644 --- a/integrationtests/gomodvendor/go.mod +++ b/integrationtests/gomodvendor/go.mod @@ -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 diff --git a/internal/handshake/hkdf.go b/internal/handshake/hkdf.go index 0caf1c8e..3da97cd8 100644 --- a/internal/handshake/hkdf.go +++ b/internal/handshake/hkdf.go @@ -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)) diff --git a/internal/handshake/hkdf_test.go b/internal/handshake/hkdf_test.go index 59b4567d..5179d403 100644 --- a/internal/handshake/hkdf_test.go +++ b/internal/handshake/hkdf_test.go @@ -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()) } } } diff --git a/internal/mocks/logging/internal/connection_tracer.go b/internal/mocks/logging/internal/connection_tracer.go index 2414d236..7380a875 100644 --- a/internal/mocks/logging/internal/connection_tracer.go +++ b/internal/mocks/logging/internal/connection_tracer.go @@ -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 } diff --git a/internal/mocks/logging/internal/tracer.go b/internal/mocks/logging/internal/tracer.go index 544b64b9..121b1e31 100644 --- a/internal/mocks/logging/internal/tracer.go +++ b/internal/mocks/logging/internal/tracer.go @@ -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 } diff --git a/internal/mocks/quic/early_conn.go b/internal/mocks/quic/early_conn.go index 683e156c..cb94d955 100644 --- a/internal/mocks/quic/early_conn.go +++ b/internal/mocks/quic/early_conn.go @@ -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 } diff --git a/internal/mocks/quic/stream.go b/internal/mocks/quic/stream.go index 32c79549..d2c58910 100644 --- a/internal/mocks/quic/stream.go +++ b/internal/mocks/quic/stream.go @@ -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 } diff --git a/interop/Dockerfile b/interop/Dockerfile index 070e597e..652a3c1a 100644 --- a/interop/Dockerfile +++ b/interop/Dockerfile @@ -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" && \ diff --git a/mock_quic_conn_test.go b/mock_quic_conn_test.go index 2f7d296f..0b1a02b4 100644 --- a/mock_quic_conn_test.go +++ b/mock_quic_conn_test.go @@ -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 } diff --git a/mock_receive_stream_internal_test.go b/mock_receive_stream_internal_test.go index 1b59ecda..8455aa30 100644 --- a/mock_receive_stream_internal_test.go +++ b/mock_receive_stream_internal_test.go @@ -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 } diff --git a/mock_send_stream_internal_test.go b/mock_send_stream_internal_test.go index 64eae3ee..d7a0e1ee 100644 --- a/mock_send_stream_internal_test.go +++ b/mock_send_stream_internal_test.go @@ -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 } diff --git a/mock_stream_internal_test.go b/mock_stream_internal_test.go index df85e346..2136bdc3 100644 --- a/mock_stream_internal_test.go +++ b/mock_stream_internal_test.go @@ -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 }