// Code generated by MockGen. DO NOT EDIT.
// Source: controller/pkg/remoteenforcer/internal/statscollector/interfaces.go

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

import (
	reflect "reflect"

	gomock "github.com/golang/mock/gomock"
	collector "go.aporeto.io/enforcerd/trireme-lib/collector"
	statscollector "go.aporeto.io/enforcerd/trireme-lib/controller/pkg/remoteenforcer/internal/statscollector"
)

// MockCollectorReader is a mock of CollectorReader interface
// nolint
type MockCollectorReader struct {
	ctrl     *gomock.Controller
	recorder *MockCollectorReaderMockRecorder
}

// MockCollectorReaderMockRecorder is the mock recorder for MockCollectorReader
// nolint
type MockCollectorReaderMockRecorder struct {
	mock *MockCollectorReader
}

// NewMockCollectorReader creates a new mock instance
// nolint
func NewMockCollectorReader(ctrl *gomock.Controller) *MockCollectorReader {
	mock := &MockCollectorReader{ctrl: ctrl}
	mock.recorder = &MockCollectorReaderMockRecorder{mock}
	return mock
}

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

// Count mocks base method
// nolint
func (m *MockCollectorReader) Count() int {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Count")
	ret0, _ := ret[0].(int)
	return ret0
}

// Count indicates an expected call of Count
// nolint
func (mr *MockCollectorReaderMockRecorder) Count() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Count", reflect.TypeOf((*MockCollectorReader)(nil).Count))
}

// FlushUserCache mocks base method
// nolint
func (m *MockCollectorReader) FlushUserCache() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "FlushUserCache")
}

// FlushUserCache indicates an expected call of FlushUserCache
// nolint
func (mr *MockCollectorReaderMockRecorder) FlushUserCache() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FlushUserCache", reflect.TypeOf((*MockCollectorReader)(nil).FlushUserCache))
}

// GetFlowRecords mocks base method
// nolint
func (m *MockCollectorReader) GetFlowRecords() map[uint64]*collector.FlowRecord {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetFlowRecords")
	ret0, _ := ret[0].(map[uint64]*collector.FlowRecord)
	return ret0
}

// GetFlowRecords indicates an expected call of GetFlowRecords
// nolint
func (mr *MockCollectorReaderMockRecorder) GetFlowRecords() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFlowRecords", reflect.TypeOf((*MockCollectorReader)(nil).GetFlowRecords))
}

// GetUserRecords mocks base method
// nolint
func (m *MockCollectorReader) GetUserRecords() map[string]*collector.UserRecord {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUserRecords")
	ret0, _ := ret[0].(map[string]*collector.UserRecord)
	return ret0
}

// GetUserRecords indicates an expected call of GetUserRecords
// nolint
func (mr *MockCollectorReaderMockRecorder) GetUserRecords() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserRecords", reflect.TypeOf((*MockCollectorReader)(nil).GetUserRecords))
}

// GetReports mocks base method
// nolint
func (m *MockCollectorReader) GetReports() chan *statscollector.Report {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetReports")
	ret0, _ := ret[0].(chan *statscollector.Report)
	return ret0
}

// GetReports indicates an expected call of GetReports
// nolint
func (mr *MockCollectorReaderMockRecorder) GetReports() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetReports", reflect.TypeOf((*MockCollectorReader)(nil).GetReports))
}

// MockCollector is a mock of Collector interface
// nolint
type MockCollector struct {
	ctrl     *gomock.Controller
	recorder *MockCollectorMockRecorder
}

// MockCollectorMockRecorder is the mock recorder for MockCollector
// nolint
type MockCollectorMockRecorder struct {
	mock *MockCollector
}

// NewMockCollector creates a new mock instance
// nolint
func NewMockCollector(ctrl *gomock.Controller) *MockCollector {
	mock := &MockCollector{ctrl: ctrl}
	mock.recorder = &MockCollectorMockRecorder{mock}
	return mock
}

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

// Count mocks base method
// nolint
func (m *MockCollector) Count() int {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Count")
	ret0, _ := ret[0].(int)
	return ret0
}

// Count indicates an expected call of Count
// nolint
func (mr *MockCollectorMockRecorder) Count() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Count", reflect.TypeOf((*MockCollector)(nil).Count))
}

// FlushUserCache mocks base method
// nolint
func (m *MockCollector) FlushUserCache() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "FlushUserCache")
}

// FlushUserCache indicates an expected call of FlushUserCache
// nolint
func (mr *MockCollectorMockRecorder) FlushUserCache() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FlushUserCache", reflect.TypeOf((*MockCollector)(nil).FlushUserCache))
}

// GetFlowRecords mocks base method
// nolint
func (m *MockCollector) GetFlowRecords() map[uint64]*collector.FlowRecord {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetFlowRecords")
	ret0, _ := ret[0].(map[uint64]*collector.FlowRecord)
	return ret0
}

// GetFlowRecords indicates an expected call of GetFlowRecords
// nolint
func (mr *MockCollectorMockRecorder) GetFlowRecords() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFlowRecords", reflect.TypeOf((*MockCollector)(nil).GetFlowRecords))
}

// GetUserRecords mocks base method
// nolint
func (m *MockCollector) GetUserRecords() map[string]*collector.UserRecord {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUserRecords")
	ret0, _ := ret[0].(map[string]*collector.UserRecord)
	return ret0
}

// GetUserRecords indicates an expected call of GetUserRecords
// nolint
func (mr *MockCollectorMockRecorder) GetUserRecords() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserRecords", reflect.TypeOf((*MockCollector)(nil).GetUserRecords))
}

// GetReports mocks base method
// nolint
func (m *MockCollector) GetReports() chan *statscollector.Report {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetReports")
	ret0, _ := ret[0].(chan *statscollector.Report)
	return ret0
}

// GetReports indicates an expected call of GetReports
// nolint
func (mr *MockCollectorMockRecorder) GetReports() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetReports", reflect.TypeOf((*MockCollector)(nil).GetReports))
}

// CollectFlowEvent mocks base method
// nolint
func (m *MockCollector) CollectFlowEvent(record *collector.FlowRecord) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "CollectFlowEvent", record)
}

// CollectFlowEvent indicates an expected call of CollectFlowEvent
// nolint
func (mr *MockCollectorMockRecorder) CollectFlowEvent(record interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CollectFlowEvent", reflect.TypeOf((*MockCollector)(nil).CollectFlowEvent), record)
}

// CollectContainerEvent mocks base method
// nolint
func (m *MockCollector) CollectContainerEvent(record *collector.ContainerRecord) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "CollectContainerEvent", record)
}

// CollectContainerEvent indicates an expected call of CollectContainerEvent
// nolint
func (mr *MockCollectorMockRecorder) CollectContainerEvent(record interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CollectContainerEvent", reflect.TypeOf((*MockCollector)(nil).CollectContainerEvent), record)
}

// CollectUserEvent mocks base method
// nolint
func (m *MockCollector) CollectUserEvent(record *collector.UserRecord) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "CollectUserEvent", record)
}

// CollectUserEvent indicates an expected call of CollectUserEvent
// nolint
func (mr *MockCollectorMockRecorder) CollectUserEvent(record interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CollectUserEvent", reflect.TypeOf((*MockCollector)(nil).CollectUserEvent), record)
}

// CollectTraceEvent mocks base method
// nolint
func (m *MockCollector) CollectTraceEvent(records []string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "CollectTraceEvent", records)
}

// CollectTraceEvent indicates an expected call of CollectTraceEvent
// nolint
func (mr *MockCollectorMockRecorder) CollectTraceEvent(records interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CollectTraceEvent", reflect.TypeOf((*MockCollector)(nil).CollectTraceEvent), records)
}

// CollectPacketEvent mocks base method
// nolint
func (m *MockCollector) CollectPacketEvent(report *collector.PacketReport) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "CollectPacketEvent", report)
}

// CollectPacketEvent indicates an expected call of CollectPacketEvent
// nolint
func (mr *MockCollectorMockRecorder) CollectPacketEvent(report interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CollectPacketEvent", reflect.TypeOf((*MockCollector)(nil).CollectPacketEvent), report)
}

// CollectCounterEvent mocks base method
// nolint
func (m *MockCollector) CollectCounterEvent(counterReport *collector.CounterReport) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "CollectCounterEvent", counterReport)
}

// CollectCounterEvent indicates an expected call of CollectCounterEvent
// nolint
func (mr *MockCollectorMockRecorder) CollectCounterEvent(counterReport interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CollectCounterEvent", reflect.TypeOf((*MockCollector)(nil).CollectCounterEvent), counterReport)
}

// CollectDNSRequests mocks base method
// nolint
func (m *MockCollector) CollectDNSRequests(request *collector.DNSRequestReport) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "CollectDNSRequests", request)
}

// CollectDNSRequests indicates an expected call of CollectDNSRequests
// nolint
func (mr *MockCollectorMockRecorder) CollectDNSRequests(request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CollectDNSRequests", reflect.TypeOf((*MockCollector)(nil).CollectDNSRequests), request)
}

// CollectPingEvent mocks base method
// nolint
func (m *MockCollector) CollectPingEvent(report *collector.PingReport) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "CollectPingEvent", report)
}

// CollectPingEvent indicates an expected call of CollectPingEvent
// nolint
func (mr *MockCollectorMockRecorder) CollectPingEvent(report interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CollectPingEvent", reflect.TypeOf((*MockCollector)(nil).CollectPingEvent), report)
}

// CollectConnectionExceptionReport mocks base method
// nolint
func (m *MockCollector) CollectConnectionExceptionReport(report *collector.ConnectionExceptionReport) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "CollectConnectionExceptionReport", report)
}

// CollectConnectionExceptionReport indicates an expected call of CollectConnectionExceptionReport
// nolint
func (mr *MockCollectorMockRecorder) CollectConnectionExceptionReport(report interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CollectConnectionExceptionReport", reflect.TypeOf((*MockCollector)(nil).CollectConnectionExceptionReport), report)
}
