gosnmp_mock.go

// Automatically generated by MockGen. DO NOT EDIT!
// Source: interface.go

package gosnmp

import (
	gomock "github.com/golang/mock/gomock"
	time "time"
)

// Mock of Handler interface
type MockHandler struct {
	ctrl     *gomock.Controller
	recorder *_MockHandlerRecorder
}

// Recorder for MockHandler (not exported)
type _MockHandlerRecorder struct {
	mock *MockHandler
}

func NewMockHandler(ctrl *gomock.Controller) *MockHandler {
	mock := &MockHandler{ctrl: ctrl}
	mock.recorder = &_MockHandlerRecorder{mock}
	return mock
}

func (_m *MockHandler) EXPECT() *_MockHandlerRecorder {
	return _m.recorder
}

func (_m *MockHandler) Connect() error {
	ret := _m.ctrl.Call(_m, "Connect")
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockHandlerRecorder) Connect() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "Connect")
}

func (_m *MockHandler) ConnectIPv4() error {
	ret := _m.ctrl.Call(_m, "ConnectIPv4")
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockHandlerRecorder) ConnectIPv4() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ConnectIPv4")
}

func (_m *MockHandler) ConnectIPv6() error {
	ret := _m.ctrl.Call(_m, "ConnectIPv6")
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockHandlerRecorder) ConnectIPv6() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ConnectIPv6")
}

func (_m *MockHandler) Get(oids []string) (*SnmpPacket, error) {
	ret := _m.ctrl.Call(_m, "Get", oids)
	ret0, _ := ret[0].(*SnmpPacket)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockHandlerRecorder) Get(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "Get", arg0)
}

func (_m *MockHandler) GetBulk(oids []string, nonRepeaters uint8, maxRepetitions uint8) (*SnmpPacket, error) {
	ret := _m.ctrl.Call(_m, "GetBulk", oids, nonRepeaters, maxRepetitions)
	ret0, _ := ret[0].(*SnmpPacket)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockHandlerRecorder) GetBulk(arg0, arg1, arg2 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetBulk", arg0, arg1, arg2)
}

func (_m *MockHandler) GetNext(oids []string) (*SnmpPacket, error) {
	ret := _m.ctrl.Call(_m, "GetNext", oids)
	ret0, _ := ret[0].(*SnmpPacket)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockHandlerRecorder) GetNext(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetNext", arg0)
}

func (_m *MockHandler) Walk(rootOid string, walkFn WalkFunc) error {
	ret := _m.ctrl.Call(_m, "Walk", rootOid, walkFn)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockHandlerRecorder) Walk(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "Walk", arg0, arg1)
}

func (_m *MockHandler) WalkAll(rootOid string) ([]SnmpPDU, error) {
	ret := _m.ctrl.Call(_m, "WalkAll", rootOid)
	ret0, _ := ret[0].([]SnmpPDU)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockHandlerRecorder) WalkAll(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "WalkAll", arg0)
}

func (_m *MockHandler) BulkWalk(rootOid string, walkFn WalkFunc) error {
	ret := _m.ctrl.Call(_m, "BulkWalk", rootOid, walkFn)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockHandlerRecorder) BulkWalk(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "BulkWalk", arg0, arg1)
}

func (_m *MockHandler) BulkWalkAll(rootOid string) ([]SnmpPDU, error) {
	ret := _m.ctrl.Call(_m, "BulkWalkAll", rootOid)
	ret0, _ := ret[0].([]SnmpPDU)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockHandlerRecorder) BulkWalkAll(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "BulkWalkAll", arg0)
}

func (_m *MockHandler) SendTrap(trap SnmpTrap) (*SnmpPacket, error) {
	ret := _m.ctrl.Call(_m, "SendTrap", trap)
	ret0, _ := ret[0].(*SnmpPacket)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockHandlerRecorder) SendTrap(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "SendTrap", arg0)
}

func (_m *MockHandler) UnmarshalTrap(trap []byte) *SnmpPacket {
	ret := _m.ctrl.Call(_m, "UnmarshalTrap", trap)
	ret0, _ := ret[0].(*SnmpPacket)
	return ret0
}

func (_mr *_MockHandlerRecorder) UnmarshalTrap(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UnmarshalTrap", arg0)
}

func (_m *MockHandler) Set(pdus []SnmpPDU) (*SnmpPacket, error) {
	ret := _m.ctrl.Call(_m, "Set", pdus)
	ret0, _ := ret[0].(*SnmpPacket)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockHandlerRecorder) Set(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "Set", arg0)
}

func (_m *MockHandler) Check(err error) {
	_m.ctrl.Call(_m, "Check", err)
}

func (_mr *_MockHandlerRecorder) Check(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "Check", arg0)
}

func (_m *MockHandler) Close() error {
	ret := _m.ctrl.Call(_m, "Close")
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockHandlerRecorder) Close() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "Close")
}

func (_m *MockHandler) Target() string {
	ret := _m.ctrl.Call(_m, "Target")
	ret0, _ := ret[0].(string)
	return ret0
}

func (_mr *_MockHandlerRecorder) Target() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "Target")
}

func (_m *MockHandler) SetTarget(target string) {
	_m.ctrl.Call(_m, "SetTarget", target)
}

func (_mr *_MockHandlerRecorder) SetTarget(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "SetTarget", arg0)
}

func (_m *MockHandler) Port() uint16 {
	ret := _m.ctrl.Call(_m, "Port")
	ret0, _ := ret[0].(uint16)
	return ret0
}

func (_mr *_MockHandlerRecorder) Port() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "Port")
}

func (_m *MockHandler) SetPort(port uint16) {
	_m.ctrl.Call(_m, "SetPort", port)
}

func (_mr *_MockHandlerRecorder) SetPort(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "SetPort", arg0)
}

func (_m *MockHandler) Community() string {
	ret := _m.ctrl.Call(_m, "Community")
	ret0, _ := ret[0].(string)
	return ret0
}

func (_mr *_MockHandlerRecorder) Community() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "Community")
}

func (_m *MockHandler) SetCommunity(community string) {
	_m.ctrl.Call(_m, "SetCommunity", community)
}

func (_mr *_MockHandlerRecorder) SetCommunity(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "SetCommunity", arg0)
}

func (_m *MockHandler) Version() SnmpVersion {
	ret := _m.ctrl.Call(_m, "Version")
	ret0, _ := ret[0].(SnmpVersion)
	return ret0
}

func (_mr *_MockHandlerRecorder) Version() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "Version")
}

func (_m *MockHandler) SetVersion(version SnmpVersion) {
	_m.ctrl.Call(_m, "SetVersion", version)
}

func (_mr *_MockHandlerRecorder) SetVersion(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "SetVersion", arg0)
}

func (_m *MockHandler) Timeout() time.Duration {
	ret := _m.ctrl.Call(_m, "Timeout")
	ret0, _ := ret[0].(time.Duration)
	return ret0
}

func (_mr *_MockHandlerRecorder) Timeout() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "Timeout")
}

func (_m *MockHandler) SetTimeout(timeout time.Duration) {
	_m.ctrl.Call(_m, "SetTimeout", timeout)
}

func (_mr *_MockHandlerRecorder) SetTimeout(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "SetTimeout", arg0)
}

func (_m *MockHandler) Retries() int {
	ret := _m.ctrl.Call(_m, "Retries")
	ret0, _ := ret[0].(int)
	return ret0
}

func (_mr *_MockHandlerRecorder) Retries() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "Retries")
}

func (_m *MockHandler) SetRetries(retries int) {
	_m.ctrl.Call(_m, "SetRetries", retries)
}

func (_mr *_MockHandlerRecorder) SetRetries(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "SetRetries", arg0)
}

func (_m *MockHandler) Logger() Logger {
	ret := _m.ctrl.Call(_m, "Logger")
	ret0, _ := ret[0].(Logger)
	return ret0
}

func (_mr *_MockHandlerRecorder) Logger() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "Logger")
}

func (_m *MockHandler) SetLogger(logger Logger) {
	_m.ctrl.Call(_m, "SetLogger", logger)
}

func (_mr *_MockHandlerRecorder) SetLogger(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "SetLogger", arg0)
}

func (_m *MockHandler) MaxOids() int {
	ret := _m.ctrl.Call(_m, "MaxOids")
	ret0, _ := ret[0].(int)
	return ret0
}

func (_mr *_MockHandlerRecorder) MaxOids() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "MaxOids")
}

func (_m *MockHandler) SetMaxOids(maxOids int) {
	_m.ctrl.Call(_m, "SetMaxOids", maxOids)
}

func (_mr *_MockHandlerRecorder) SetMaxOids(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "SetMaxOids", arg0)
}

func (_m *MockHandler) MaxRepetitions() uint8 {
	ret := _m.ctrl.Call(_m, "MaxRepetitions")
	ret0, _ := ret[0].(uint8)
	return ret0
}

func (_mr *_MockHandlerRecorder) MaxRepetitions() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "MaxRepetitions")
}

func (_m *MockHandler) SetMaxRepetitions(maxRepetitions uint8) {
	_m.ctrl.Call(_m, "SetMaxRepetitions", maxRepetitions)
}

func (_mr *_MockHandlerRecorder) SetMaxRepetitions(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "SetMaxRepetitions", arg0)
}

func (_m *MockHandler) NonRepeaters() int {
	ret := _m.ctrl.Call(_m, "NonRepeaters")
	ret0, _ := ret[0].(int)
	return ret0
}

func (_mr *_MockHandlerRecorder) NonRepeaters() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "NonRepeaters")
}

func (_m *MockHandler) SetNonRepeaters(nonRepeaters int) {
	_m.ctrl.Call(_m, "SetNonRepeaters", nonRepeaters)
}

func (_mr *_MockHandlerRecorder) SetNonRepeaters(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "SetNonRepeaters", arg0)
}

func (_m *MockHandler) MsgFlags() SnmpV3MsgFlags {
	ret := _m.ctrl.Call(_m, "MsgFlags")
	ret0, _ := ret[0].(SnmpV3MsgFlags)
	return ret0
}

func (_mr *_MockHandlerRecorder) MsgFlags() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "MsgFlags")
}

func (_m *MockHandler) SetMsgFlags(msgFlags SnmpV3MsgFlags) {
	_m.ctrl.Call(_m, "SetMsgFlags", msgFlags)
}

func (_mr *_MockHandlerRecorder) SetMsgFlags(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "SetMsgFlags", arg0)
}

func (_m *MockHandler) SecurityModel() SnmpV3SecurityModel {
	ret := _m.ctrl.Call(_m, "SecurityModel")
	ret0, _ := ret[0].(SnmpV3SecurityModel)
	return ret0
}

func (_mr *_MockHandlerRecorder) SecurityModel() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "SecurityModel")
}

func (_m *MockHandler) SetSecurityModel(securityModel SnmpV3SecurityModel) {
	_m.ctrl.Call(_m, "SetSecurityModel", securityModel)
}

func (_mr *_MockHandlerRecorder) SetSecurityModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "SetSecurityModel", arg0)
}

func (_m *MockHandler) SecurityParameters() SnmpV3SecurityParameters {
	ret := _m.ctrl.Call(_m, "SecurityParameters")
	ret0, _ := ret[0].(SnmpV3SecurityParameters)
	return ret0
}

func (_mr *_MockHandlerRecorder) SecurityParameters() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "SecurityParameters")
}

func (_m *MockHandler) SetSecurityParameters(securityParameters SnmpV3SecurityParameters) {
	_m.ctrl.Call(_m, "SetSecurityParameters", securityParameters)
}

func (_mr *_MockHandlerRecorder) SetSecurityParameters(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "SetSecurityParameters", arg0)
}

func (_m *MockHandler) ContextEngineID() string {
	ret := _m.ctrl.Call(_m, "ContextEngineID")
	ret0, _ := ret[0].(string)
	return ret0
}

func (_mr *_MockHandlerRecorder) ContextEngineID() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ContextEngineID")
}

func (_m *MockHandler) SetContextEngineID(contextEngineID string) {
	_m.ctrl.Call(_m, "SetContextEngineID", contextEngineID)
}

func (_mr *_MockHandlerRecorder) SetContextEngineID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "SetContextEngineID", arg0)
}

func (_m *MockHandler) ContextName() string {
	ret := _m.ctrl.Call(_m, "ContextName")
	ret0, _ := ret[0].(string)
	return ret0
}

func (_mr *_MockHandlerRecorder) ContextName() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ContextName")
}

func (_m *MockHandler) SetContextName(contextName string) {
	_m.ctrl.Call(_m, "SetContextName", contextName)
}

func (_mr *_MockHandlerRecorder) SetContextName(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "SetContextName", arg0)
}