func (m *MockSession) OpenUniStreamSync() (quic_go.SendStream, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OpenUniStreamSync")
	ret0, _ := ret[0].(quic_go.SendStream)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
OpenUniStreamSync mocks base method
package mocks
import (
	"context"
	"github.com/golang/mock/gomock"
	quic_go "github.com/lucas-clemente/quic-go"
	"net"
	"reflect"
)
type MockSession struct {
	ctrl     *gomock.Controller
	recorder *MockSessionMockRecorder
}
type MockSessionMockRecorder struct {
	mock *MockSession
}
func NewMockSession(ctrl *gomock.Controller) *MockSession {
	mock := &MockSession{ctrl: ctrl}
	mock.recorder = &MockSessionMockRecorder{mock}
	return mock
}
func (m *MockSession) EXPECT() *MockSessionMockRecorder {
	return m.recorder
}
func (m *MockSession) AcceptStream() (quic_go.Stream, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AcceptStream")
	ret0, _ := ret[0].(quic_go.Stream)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockSessionMockRecorder) AcceptStream() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptStream", reflect.TypeOf((*MockSession)(nil).AcceptStream))
}
func (m *MockSession) AcceptUniStream() (quic_go.ReceiveStream, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AcceptUniStream")
	ret0, _ := ret[0].(quic_go.ReceiveStream)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockSessionMockRecorder) AcceptUniStream() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptUniStream", reflect.TypeOf((*MockSession)(nil).AcceptUniStream))
}
func (m *MockSession) Close() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Close")
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockSessionMockRecorder) Close() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockSession)(nil).Close))
}
func (m *MockSession) CloseWithError(arg0 quic_go.ErrorCode, arg1 error) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CloseWithError", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockSessionMockRecorder) CloseWithError(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseWithError", reflect.TypeOf((*MockSession)(nil).CloseWithError), arg0, arg1)
}
func (m *MockSession) ConnectionState() quic_go.ConnectionState {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ConnectionState")
	ret0, _ := ret[0].(quic_go.ConnectionState)
	return ret0
}
func (mr *MockSessionMockRecorder) ConnectionState() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConnectionState", reflect.TypeOf((*MockSession)(nil).ConnectionState))
}
func (m *MockSession) Context() context.Context {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Context")
	ret0, _ := ret[0].(context.Context)
	return ret0
}
func (mr *MockSessionMockRecorder) Context() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockSession)(nil).Context))
}
func (m *MockSession) LocalAddr() net.Addr {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LocalAddr")
	ret0, _ := ret[0].(net.Addr)
	return ret0
}
func (mr *MockSessionMockRecorder) LocalAddr() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LocalAddr", reflect.TypeOf((*MockSession)(nil).LocalAddr))
}
func (m *MockSession) OpenStream() (quic_go.Stream, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OpenStream")
	ret0, _ := ret[0].(quic_go.Stream)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockSessionMockRecorder) OpenStream() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OpenStream", reflect.TypeOf((*MockSession)(nil).OpenStream))
}
func (m *MockSession) OpenStreamSync() (quic_go.Stream, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OpenStreamSync")
	ret0, _ := ret[0].(quic_go.Stream)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockSessionMockRecorder) OpenStreamSync() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OpenStreamSync", reflect.TypeOf((*MockSession)(nil).OpenStreamSync))
}
func (m *MockSession) OpenUniStream() (quic_go.SendStream, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OpenUniStream")
	ret0, _ := ret[0].(quic_go.SendStream)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockSessionMockRecorder) OpenUniStream() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OpenUniStream", reflect.TypeOf((*MockSession)(nil).OpenUniStream))
}