// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/Shopify/sarama (interfaces: Consumer)

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

import (
	reflect "reflect"

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

// MockConsumer is a mock of Consumer interface.
type MockConsumer struct {
	ctrl     *gomock.Controller
	recorder *MockConsumerMockRecorder
}

// MockConsumerMockRecorder is the mock recorder for MockConsumer.
type MockConsumerMockRecorder struct {
	mock *MockConsumer
}

// NewMockConsumer creates a new mock instance.
func NewMockConsumer(ctrl *gomock.Controller) *MockConsumer {
	mock := &MockConsumer{ctrl: ctrl}
	mock.recorder = &MockConsumerMockRecorder{mock}
	return mock
}

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

// Close mocks base method.
func (m *MockConsumer) 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 *MockConsumerMockRecorder) Close() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockConsumer)(nil).Close))
}

// ConsumePartition mocks base method.
func (m *MockConsumer) ConsumePartition(arg0 string, arg1 int32, arg2 int64) (sarama.PartitionConsumer, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ConsumePartition", arg0, arg1, arg2)
	ret0, _ := ret[0].(sarama.PartitionConsumer)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// HighWaterMarks mocks base method.
func (m *MockConsumer) HighWaterMarks() map[string]map[int32]int64 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HighWaterMarks")
	ret0, _ := ret[0].(map[string]map[int32]int64)
	return ret0
}

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

// Partitions mocks base method.
func (m *MockConsumer) Partitions(arg0 string) ([]int32, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Partitions", arg0)
	ret0, _ := ret[0].([]int32)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// Pause mocks base method.
func (m *MockConsumer) Pause(arg0 map[string][]int32) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Pause", arg0)
}

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

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

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

// Resume mocks base method.
func (m *MockConsumer) Resume(arg0 map[string][]int32) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Resume", arg0)
}

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

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

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

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

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