// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/lucas-clemente/quic-go/ackhandler (interfaces: SentPacketHandler)

package mocks

import (
	reflect "reflect"
	time "time"

	gomock "github.com/golang/mock/gomock"
	ackhandler "github.com/lucas-clemente/quic-go/ackhandler"
	protocol "github.com/lucas-clemente/quic-go/internal/protocol"
	wire "github.com/lucas-clemente/quic-go/internal/wire"
)

// MockSentPacketHandler is a mock of SentPacketHandler interface
type MockSentPacketHandler struct {
	ctrl     *gomock.Controller
	recorder *MockSentPacketHandlerMockRecorder
}

// MockSentPacketHandlerMockRecorder is the mock recorder for MockSentPacketHandler
type MockSentPacketHandlerMockRecorder struct {
	mock *MockSentPacketHandler
}

// NewMockSentPacketHandler creates a new mock instance
func NewMockSentPacketHandler(ctrl *gomock.Controller) *MockSentPacketHandler {
	mock := &MockSentPacketHandler{ctrl: ctrl}
	mock.recorder = &MockSentPacketHandlerMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use
func (_m *MockSentPacketHandler) EXPECT() *MockSentPacketHandlerMockRecorder {
	return _m.recorder
}

// DequeuePacketForRetransmission mocks base method
func (_m *MockSentPacketHandler) DequeuePacketForRetransmission() *ackhandler.Packet {
	ret := _m.ctrl.Call(_m, "DequeuePacketForRetransmission")
	ret0, _ := ret[0].(*ackhandler.Packet)
	return ret0
}

// DequeuePacketForRetransmission indicates an expected call of DequeuePacketForRetransmission
func (_mr *MockSentPacketHandlerMockRecorder) DequeuePacketForRetransmission() *gomock.Call {
	return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "DequeuePacketForRetransmission", reflect.TypeOf((*MockSentPacketHandler)(nil).DequeuePacketForRetransmission))
}

// GetAlarmTimeout mocks base method
func (_m *MockSentPacketHandler) GetAlarmTimeout() time.Time {
	ret := _m.ctrl.Call(_m, "GetAlarmTimeout")
	ret0, _ := ret[0].(time.Time)
	return ret0
}

// GetAlarmTimeout indicates an expected call of GetAlarmTimeout
func (_mr *MockSentPacketHandlerMockRecorder) GetAlarmTimeout() *gomock.Call {
	return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "GetAlarmTimeout", reflect.TypeOf((*MockSentPacketHandler)(nil).GetAlarmTimeout))
}

// GetLeastUnacked mocks base method
func (_m *MockSentPacketHandler) GetLeastUnacked() protocol.PacketNumber {
	ret := _m.ctrl.Call(_m, "GetLeastUnacked")
	ret0, _ := ret[0].(protocol.PacketNumber)
	return ret0
}

// GetLeastUnacked indicates an expected call of GetLeastUnacked
func (_mr *MockSentPacketHandlerMockRecorder) GetLeastUnacked() *gomock.Call {
	return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "GetLeastUnacked", reflect.TypeOf((*MockSentPacketHandler)(nil).GetLeastUnacked))
}

// GetLowestPacketNotConfirmedAcked mocks base method
func (_m *MockSentPacketHandler) GetLowestPacketNotConfirmedAcked() protocol.PacketNumber {
	ret := _m.ctrl.Call(_m, "GetLowestPacketNotConfirmedAcked")
	ret0, _ := ret[0].(protocol.PacketNumber)
	return ret0
}

// GetLowestPacketNotConfirmedAcked indicates an expected call of GetLowestPacketNotConfirmedAcked
func (_mr *MockSentPacketHandlerMockRecorder) GetLowestPacketNotConfirmedAcked() *gomock.Call {
	return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "GetLowestPacketNotConfirmedAcked", reflect.TypeOf((*MockSentPacketHandler)(nil).GetLowestPacketNotConfirmedAcked))
}

// GetStopWaitingFrame mocks base method
func (_m *MockSentPacketHandler) GetStopWaitingFrame(_param0 bool) *wire.StopWaitingFrame {
	ret := _m.ctrl.Call(_m, "GetStopWaitingFrame", _param0)
	ret0, _ := ret[0].(*wire.StopWaitingFrame)
	return ret0
}

// GetStopWaitingFrame indicates an expected call of GetStopWaitingFrame
func (_mr *MockSentPacketHandlerMockRecorder) GetStopWaitingFrame(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "GetStopWaitingFrame", reflect.TypeOf((*MockSentPacketHandler)(nil).GetStopWaitingFrame), arg0)
}

// OnAlarm mocks base method
func (_m *MockSentPacketHandler) OnAlarm() {
	_m.ctrl.Call(_m, "OnAlarm")
}

// OnAlarm indicates an expected call of OnAlarm
func (_mr *MockSentPacketHandlerMockRecorder) OnAlarm() *gomock.Call {
	return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "OnAlarm", reflect.TypeOf((*MockSentPacketHandler)(nil).OnAlarm))
}

// ReceivedAck mocks base method
func (_m *MockSentPacketHandler) ReceivedAck(_param0 *wire.AckFrame, _param1 protocol.PacketNumber, _param2 protocol.EncryptionLevel, _param3 time.Time) error {
	ret := _m.ctrl.Call(_m, "ReceivedAck", _param0, _param1, _param2, _param3)
	ret0, _ := ret[0].(error)
	return ret0
}

// ReceivedAck indicates an expected call of ReceivedAck
func (_mr *MockSentPacketHandlerMockRecorder) ReceivedAck(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "ReceivedAck", reflect.TypeOf((*MockSentPacketHandler)(nil).ReceivedAck), arg0, arg1, arg2, arg3)
}

// SendingAllowed mocks base method
func (_m *MockSentPacketHandler) SendingAllowed() bool {
	ret := _m.ctrl.Call(_m, "SendingAllowed")
	ret0, _ := ret[0].(bool)
	return ret0
}

// SendingAllowed indicates an expected call of SendingAllowed
func (_mr *MockSentPacketHandlerMockRecorder) SendingAllowed() *gomock.Call {
	return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "SendingAllowed", reflect.TypeOf((*MockSentPacketHandler)(nil).SendingAllowed))
}

// SentPacket mocks base method
func (_m *MockSentPacketHandler) SentPacket(_param0 *ackhandler.Packet) error {
	ret := _m.ctrl.Call(_m, "SentPacket", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

// SentPacket indicates an expected call of SentPacket
func (_mr *MockSentPacketHandlerMockRecorder) SentPacket(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "SentPacket", reflect.TypeOf((*MockSentPacketHandler)(nil).SentPacket), arg0)
}

// SetHandshakeComplete mocks base method
func (_m *MockSentPacketHandler) SetHandshakeComplete() {
	_m.ctrl.Call(_m, "SetHandshakeComplete")
}

// SetHandshakeComplete indicates an expected call of SetHandshakeComplete
func (_mr *MockSentPacketHandlerMockRecorder) SetHandshakeComplete() *gomock.Call {
	return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "SetHandshakeComplete", reflect.TypeOf((*MockSentPacketHandler)(nil).SetHandshakeComplete))
}

// ShouldSendRetransmittablePacket mocks base method
func (_m *MockSentPacketHandler) ShouldSendRetransmittablePacket() bool {
	ret := _m.ctrl.Call(_m, "ShouldSendRetransmittablePacket")
	ret0, _ := ret[0].(bool)
	return ret0
}

// ShouldSendRetransmittablePacket indicates an expected call of ShouldSendRetransmittablePacket
func (_mr *MockSentPacketHandlerMockRecorder) ShouldSendRetransmittablePacket() *gomock.Call {
	return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "ShouldSendRetransmittablePacket", reflect.TypeOf((*MockSentPacketHandler)(nil).ShouldSendRetransmittablePacket))
}