// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/Haylen-Z/godis (interfaces: Protocol,Connection,ConnectionPool)

// Package godis is a generated GoMock package.
package godis

import (
	context "context"
	reflect "reflect"
	time "time"

	gomock "github.com/golang/mock/gomock"
)

// MockProtocol is a mock of Protocol interface.
type MockProtocol struct {
	ctrl     *gomock.Controller
	recorder *MockProtocolMockRecorder
}

// MockProtocolMockRecorder is the mock recorder for MockProtocol.
type MockProtocolMockRecorder struct {
	mock *MockProtocol
}

// NewMockProtocol creates a new mock instance.
func NewMockProtocol(ctrl *gomock.Controller) *MockProtocol {
	mock := &MockProtocol{ctrl: ctrl}
	mock.recorder = &MockProtocolMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockProtocol) EXPECT() *MockProtocolMockRecorder {
	return m.recorder
}

// GetNextMsgType mocks base method.
func (m *MockProtocol) GetNextMsgType(arg0 context.Context) (MsgType, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNextMsgType", arg0)
	ret0, _ := ret[0].(MsgType)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetNextMsgType indicates an expected call of GetNextMsgType.
func (mr *MockProtocolMockRecorder) GetNextMsgType(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNextMsgType", reflect.TypeOf((*MockProtocol)(nil).GetNextMsgType), arg0)
}

// ReadArray mocks base method.
func (m *MockProtocol) ReadArray(arg0 context.Context) ([]interface{}, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadArray", arg0)
	ret0, _ := ret[0].([]interface{})
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReadArray indicates an expected call of ReadArray.
func (mr *MockProtocolMockRecorder) ReadArray(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadArray", reflect.TypeOf((*MockProtocol)(nil).ReadArray), arg0)
}

// ReadBulkString mocks base method.
func (m *MockProtocol) ReadBulkString(arg0 context.Context) (*[]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadBulkString", arg0)
	ret0, _ := ret[0].(*[]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReadBulkString indicates an expected call of ReadBulkString.
func (mr *MockProtocolMockRecorder) ReadBulkString(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadBulkString", reflect.TypeOf((*MockProtocol)(nil).ReadBulkString), arg0)
}

// ReadError mocks base method.
func (m *MockProtocol) ReadError(arg0 context.Context) (Error, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadError", arg0)
	ret0, _ := ret[0].(Error)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReadError indicates an expected call of ReadError.
func (mr *MockProtocolMockRecorder) ReadError(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadError", reflect.TypeOf((*MockProtocol)(nil).ReadError), arg0)
}

// ReadInteger mocks base method.
func (m *MockProtocol) ReadInteger(arg0 context.Context) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadInteger", arg0)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReadInteger indicates an expected call of ReadInteger.
func (mr *MockProtocolMockRecorder) ReadInteger(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadInteger", reflect.TypeOf((*MockProtocol)(nil).ReadInteger), arg0)
}

// ReadMap mocks base method.
func (m *MockProtocol) ReadMap(arg0 context.Context) ([]interface{}, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadMap", arg0)
	ret0, _ := ret[0].([]interface{})
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReadMap indicates an expected call of ReadMap.
func (mr *MockProtocolMockRecorder) ReadMap(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadMap", reflect.TypeOf((*MockProtocol)(nil).ReadMap), arg0)
}

// ReadNull mocks base method.
func (m *MockProtocol) ReadNull(arg0 context.Context) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadNull", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// ReadNull indicates an expected call of ReadNull.
func (mr *MockProtocolMockRecorder) ReadNull(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadNull", reflect.TypeOf((*MockProtocol)(nil).ReadNull), arg0)
}

// ReadSimpleString mocks base method.
func (m *MockProtocol) ReadSimpleString(arg0 context.Context) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadSimpleString", arg0)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReadSimpleString indicates an expected call of ReadSimpleString.
func (mr *MockProtocolMockRecorder) ReadSimpleString(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadSimpleString", reflect.TypeOf((*MockProtocol)(nil).ReadSimpleString), arg0)
}

// WriteBulkString mocks base method.
func (m *MockProtocol) WriteBulkString(arg0 context.Context, arg1 []byte) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WriteBulkString", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// WriteBulkString indicates an expected call of WriteBulkString.
func (mr *MockProtocolMockRecorder) WriteBulkString(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteBulkString", reflect.TypeOf((*MockProtocol)(nil).WriteBulkString), arg0, arg1)
}

// WriteBulkStringArray mocks base method.
func (m *MockProtocol) WriteBulkStringArray(arg0 context.Context, arg1 [][]byte) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WriteBulkStringArray", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// WriteBulkStringArray indicates an expected call of WriteBulkStringArray.
func (mr *MockProtocolMockRecorder) WriteBulkStringArray(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteBulkStringArray", reflect.TypeOf((*MockProtocol)(nil).WriteBulkStringArray), arg0, arg1)
}

// MockConnection is a mock of Connection interface.
type MockConnection struct {
	ctrl     *gomock.Controller
	recorder *MockConnectionMockRecorder
}

// MockConnectionMockRecorder is the mock recorder for MockConnection.
type MockConnectionMockRecorder struct {
	mock *MockConnection
}

// NewMockConnection creates a new mock instance.
func NewMockConnection(ctrl *gomock.Controller) *MockConnection {
	mock := &MockConnection{ctrl: ctrl}
	mock.recorder = &MockConnectionMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockConnection) EXPECT() *MockConnectionMockRecorder {
	return m.recorder
}

// Close mocks base method.
func (m *MockConnection) Close() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Close")
	ret0, _ := ret[0].(error)
	return ret0
}

// Close indicates an expected call of Close.
func (mr *MockConnectionMockRecorder) Close() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockConnection)(nil).Close))
}

// Connect mocks base method.
func (m *MockConnection) Connect() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Connect")
	ret0, _ := ret[0].(error)
	return ret0
}

// Connect indicates an expected call of Connect.
func (mr *MockConnectionMockRecorder) Connect() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Connect", reflect.TypeOf((*MockConnection)(nil).Connect))
}

// GetLastUsedAt mocks base method.
func (m *MockConnection) GetLastUsedAt() time.Time {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLastUsedAt")
	ret0, _ := ret[0].(time.Time)
	return ret0
}

// GetLastUsedAt indicates an expected call of GetLastUsedAt.
func (mr *MockConnectionMockRecorder) GetLastUsedAt() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLastUsedAt", reflect.TypeOf((*MockConnection)(nil).GetLastUsedAt))
}

// IsBroken mocks base method.
func (m *MockConnection) IsBroken() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsBroken")
	ret0, _ := ret[0].(bool)
	return ret0
}

// IsBroken indicates an expected call of IsBroken.
func (mr *MockConnectionMockRecorder) IsBroken() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsBroken", reflect.TypeOf((*MockConnection)(nil).IsBroken))
}

// Read mocks base method.
func (m *MockConnection) Read(arg0 context.Context, arg1 []byte) (int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Read", arg0, arg1)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Read indicates an expected call of Read.
func (mr *MockConnectionMockRecorder) Read(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Read", reflect.TypeOf((*MockConnection)(nil).Read), arg0, arg1)
}

// SetBroken mocks base method.
func (m *MockConnection) SetBroken() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetBroken")
}

// SetBroken indicates an expected call of SetBroken.
func (mr *MockConnectionMockRecorder) SetBroken() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetBroken", reflect.TypeOf((*MockConnection)(nil).SetBroken))
}

// Write mocks base method.
func (m *MockConnection) Write(arg0 context.Context, arg1 []byte) (int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Write", arg0, arg1)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Write indicates an expected call of Write.
func (mr *MockConnectionMockRecorder) Write(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Write", reflect.TypeOf((*MockConnection)(nil).Write), arg0, arg1)
}

// MockConnectionPool is a mock of ConnectionPool interface.
type MockConnectionPool struct {
	ctrl     *gomock.Controller
	recorder *MockConnectionPoolMockRecorder
}

// MockConnectionPoolMockRecorder is the mock recorder for MockConnectionPool.
type MockConnectionPoolMockRecorder struct {
	mock *MockConnectionPool
}

// NewMockConnectionPool creates a new mock instance.
func NewMockConnectionPool(ctrl *gomock.Controller) *MockConnectionPool {
	mock := &MockConnectionPool{ctrl: ctrl}
	mock.recorder = &MockConnectionPoolMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockConnectionPool) EXPECT() *MockConnectionPoolMockRecorder {
	return m.recorder
}

// Close mocks base method.
func (m *MockConnectionPool) Close() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Close")
	ret0, _ := ret[0].(error)
	return ret0
}

// Close indicates an expected call of Close.
func (mr *MockConnectionPoolMockRecorder) Close() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockConnectionPool)(nil).Close))
}

// GetConnection mocks base method.
func (m *MockConnectionPool) GetConnection() (Connection, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetConnection")
	ret0, _ := ret[0].(Connection)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetConnection indicates an expected call of GetConnection.
func (mr *MockConnectionPoolMockRecorder) GetConnection() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConnection", reflect.TypeOf((*MockConnectionPool)(nil).GetConnection))
}

// Release mocks base method.
func (m *MockConnectionPool) Release(arg0 Connection) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Release", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// Release indicates an expected call of Release.
func (mr *MockConnectionPoolMockRecorder) Release(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Release", reflect.TypeOf((*MockConnectionPool)(nil).Release), arg0)
}
