mock_actorcontext.go

// Code generated by MockGen. DO NOT EDIT.
// Source: vendor/github.com/aergoio/aergo-actor/actor/context.go

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

import (
	reflect "reflect"
	time "time"

	actor "github.com/aergoio/aergo-actor/actor"
	gomock "github.com/golang/mock/gomock"
)

// MockContext is a mock of Context interface
type MockContext struct {
	ctrl     *gomock.Controller
	recorder *MockContextMockRecorder
}

// MockContextMockRecorder is the mock recorder for MockContext
type MockContextMockRecorder struct {
	mock *MockContext
}

// NewMockContext creates a new mock instance
func NewMockContext(ctrl *gomock.Controller) *MockContext {
	mock := &MockContext{ctrl: ctrl}
	mock.recorder = &MockContextMockRecorder{mock}
	return mock
}

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

// Watch mocks base method
func (m *MockContext) Watch(pid *actor.PID) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Watch", pid)
}

// Watch indicates an expected call of Watch
func (mr *MockContextMockRecorder) Watch(pid interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Watch", reflect.TypeOf((*MockContext)(nil).Watch), pid)
}

// Unwatch mocks base method
func (m *MockContext) Unwatch(pid *actor.PID) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Unwatch", pid)
}

// Unwatch indicates an expected call of Unwatch
func (mr *MockContextMockRecorder) Unwatch(pid interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Unwatch", reflect.TypeOf((*MockContext)(nil).Unwatch), pid)
}

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

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

// Sender mocks base method
func (m *MockContext) Sender() *actor.PID {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Sender")
	ret0, _ := ret[0].(*actor.PID)
	return ret0
}

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

// MessageHeader mocks base method
func (m *MockContext) MessageHeader() actor.ReadonlyMessageHeader {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MessageHeader")
	ret0, _ := ret[0].(actor.ReadonlyMessageHeader)
	return ret0
}

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

// Tell mocks base method
func (m *MockContext) Tell(pid *actor.PID, message interface{}) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Tell", pid, message)
}

// Tell indicates an expected call of Tell
func (mr *MockContextMockRecorder) Tell(pid, message interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Tell", reflect.TypeOf((*MockContext)(nil).Tell), pid, message)
}

// Forward mocks base method
func (m *MockContext) Forward(pid *actor.PID) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Forward", pid)
}

// Forward indicates an expected call of Forward
func (mr *MockContextMockRecorder) Forward(pid interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Forward", reflect.TypeOf((*MockContext)(nil).Forward), pid)
}

// Request mocks base method
func (m *MockContext) Request(pid *actor.PID, message interface{}) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Request", pid, message)
}

// Request indicates an expected call of Request
func (mr *MockContextMockRecorder) Request(pid, message interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Request", reflect.TypeOf((*MockContext)(nil).Request), pid, message)
}

// RequestFuture mocks base method
func (m *MockContext) RequestFuture(pid *actor.PID, message interface{}, timeout time.Duration) *actor.Future {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RequestFuture", pid, message, timeout)
	ret0, _ := ret[0].(*actor.Future)
	return ret0
}

// RequestFuture indicates an expected call of RequestFuture
func (mr *MockContextMockRecorder) RequestFuture(pid, message, timeout interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequestFuture", reflect.TypeOf((*MockContext)(nil).RequestFuture), pid, message, timeout)
}

// SetReceiveTimeout mocks base method
func (m *MockContext) SetReceiveTimeout(d time.Duration) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetReceiveTimeout", d)
}

// SetReceiveTimeout indicates an expected call of SetReceiveTimeout
func (mr *MockContextMockRecorder) SetReceiveTimeout(d interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetReceiveTimeout", reflect.TypeOf((*MockContext)(nil).SetReceiveTimeout), d)
}

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

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

// SetBehavior mocks base method
func (m *MockContext) SetBehavior(behavior actor.ActorFunc) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetBehavior", behavior)
}

// SetBehavior indicates an expected call of SetBehavior
func (mr *MockContextMockRecorder) SetBehavior(behavior interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetBehavior", reflect.TypeOf((*MockContext)(nil).SetBehavior), behavior)
}

// PushBehavior mocks base method
func (m *MockContext) PushBehavior(behavior actor.ActorFunc) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "PushBehavior", behavior)
}

// PushBehavior indicates an expected call of PushBehavior
func (mr *MockContextMockRecorder) PushBehavior(behavior interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PushBehavior", reflect.TypeOf((*MockContext)(nil).PushBehavior), behavior)
}

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

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

// Self mocks base method
func (m *MockContext) Self() *actor.PID {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Self")
	ret0, _ := ret[0].(*actor.PID)
	return ret0
}

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

// Parent mocks base method
func (m *MockContext) Parent() *actor.PID {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Parent")
	ret0, _ := ret[0].(*actor.PID)
	return ret0
}

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

// Spawn mocks base method
func (m *MockContext) Spawn(props *actor.Props) *actor.PID {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Spawn", props)
	ret0, _ := ret[0].(*actor.PID)
	return ret0
}

// Spawn indicates an expected call of Spawn
func (mr *MockContextMockRecorder) Spawn(props interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Spawn", reflect.TypeOf((*MockContext)(nil).Spawn), props)
}

// SpawnPrefix mocks base method
func (m *MockContext) SpawnPrefix(props *actor.Props, prefix string) *actor.PID {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SpawnPrefix", props, prefix)
	ret0, _ := ret[0].(*actor.PID)
	return ret0
}

// SpawnPrefix indicates an expected call of SpawnPrefix
func (mr *MockContextMockRecorder) SpawnPrefix(props, prefix interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SpawnPrefix", reflect.TypeOf((*MockContext)(nil).SpawnPrefix), props, prefix)
}

// SpawnNamed mocks base method
func (m *MockContext) SpawnNamed(props *actor.Props, id string) (*actor.PID, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SpawnNamed", props, id)
	ret0, _ := ret[0].(*actor.PID)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SpawnNamed indicates an expected call of SpawnNamed
func (mr *MockContextMockRecorder) SpawnNamed(props, id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SpawnNamed", reflect.TypeOf((*MockContext)(nil).SpawnNamed), props, id)
}

// Children mocks base method
func (m *MockContext) Children() []*actor.PID {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Children")
	ret0, _ := ret[0].([]*actor.PID)
	return ret0
}

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

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

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

// Respond mocks base method
func (m *MockContext) Respond(response interface{}) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Respond", response)
}

// Respond indicates an expected call of Respond
func (mr *MockContextMockRecorder) Respond(response interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Respond", reflect.TypeOf((*MockContext)(nil).Respond), response)
}

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

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

// AwaitFuture mocks base method
func (m *MockContext) AwaitFuture(f *actor.Future, continuation func(interface{}, error)) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AwaitFuture", f, continuation)
}

// AwaitFuture indicates an expected call of AwaitFuture
func (mr *MockContextMockRecorder) AwaitFuture(f, continuation interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AwaitFuture", reflect.TypeOf((*MockContext)(nil).AwaitFuture), f, continuation)
}