// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/ava-labs/avalanchego/snow/engine/snowman/block (interfaces: FullVM)
//
// Generated by this command:
//
//	mockgen -package=blockmock -destination=blockmock/full_vm.go -mock_names=FullVM=FullVM . FullVM
//

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

import (
	context "context"
	http "net/http"
	reflect "reflect"
	time "time"

	database "github.com/ava-labs/avalanchego/database"
	ids "github.com/ava-labs/avalanchego/ids"
	snow "github.com/ava-labs/avalanchego/snow"
	snowman "github.com/ava-labs/avalanchego/snow/consensus/snowman"
	common "github.com/ava-labs/avalanchego/snow/engine/common"
	block "github.com/ava-labs/avalanchego/snow/engine/snowman/block"
	version "github.com/ava-labs/avalanchego/version"
	gomock "go.uber.org/mock/gomock"
)

// FullVM is a mock of FullVM interface.
type FullVM struct {
	ctrl     *gomock.Controller
	recorder *FullVMMockRecorder
	isgomock struct{}
}

// FullVMMockRecorder is the mock recorder for FullVM.
type FullVMMockRecorder struct {
	mock *FullVM
}

// NewFullVM creates a new mock instance.
func NewFullVM(ctrl *gomock.Controller) *FullVM {
	mock := &FullVM{ctrl: ctrl}
	mock.recorder = &FullVMMockRecorder{mock}
	return mock
}

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

// AppGossip mocks base method.
func (m *FullVM) AppGossip(ctx context.Context, nodeID ids.NodeID, msg []byte) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AppGossip", ctx, nodeID, msg)
	ret0, _ := ret[0].(error)
	return ret0
}

// AppGossip indicates an expected call of AppGossip.
func (mr *FullVMMockRecorder) AppGossip(ctx, nodeID, msg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppGossip", reflect.TypeOf((*FullVM)(nil).AppGossip), ctx, nodeID, msg)
}

// AppRequest mocks base method.
func (m *FullVM) AppRequest(ctx context.Context, nodeID ids.NodeID, requestID uint32, deadline time.Time, request []byte) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AppRequest", ctx, nodeID, requestID, deadline, request)
	ret0, _ := ret[0].(error)
	return ret0
}

// AppRequest indicates an expected call of AppRequest.
func (mr *FullVMMockRecorder) AppRequest(ctx, nodeID, requestID, deadline, request any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppRequest", reflect.TypeOf((*FullVM)(nil).AppRequest), ctx, nodeID, requestID, deadline, request)
}

// AppRequestFailed mocks base method.
func (m *FullVM) AppRequestFailed(ctx context.Context, nodeID ids.NodeID, requestID uint32, appErr *common.AppError) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AppRequestFailed", ctx, nodeID, requestID, appErr)
	ret0, _ := ret[0].(error)
	return ret0
}

// AppRequestFailed indicates an expected call of AppRequestFailed.
func (mr *FullVMMockRecorder) AppRequestFailed(ctx, nodeID, requestID, appErr any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppRequestFailed", reflect.TypeOf((*FullVM)(nil).AppRequestFailed), ctx, nodeID, requestID, appErr)
}

// AppResponse mocks base method.
func (m *FullVM) AppResponse(ctx context.Context, nodeID ids.NodeID, requestID uint32, response []byte) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AppResponse", ctx, nodeID, requestID, response)
	ret0, _ := ret[0].(error)
	return ret0
}

// AppResponse indicates an expected call of AppResponse.
func (mr *FullVMMockRecorder) AppResponse(ctx, nodeID, requestID, response any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppResponse", reflect.TypeOf((*FullVM)(nil).AppResponse), ctx, nodeID, requestID, response)
}

// BatchedParseBlock mocks base method.
func (m *FullVM) BatchedParseBlock(ctx context.Context, blks [][]byte) ([]snowman.Block, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BatchedParseBlock", ctx, blks)
	ret0, _ := ret[0].([]snowman.Block)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BatchedParseBlock indicates an expected call of BatchedParseBlock.
func (mr *FullVMMockRecorder) BatchedParseBlock(ctx, blks any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchedParseBlock", reflect.TypeOf((*FullVM)(nil).BatchedParseBlock), ctx, blks)
}

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

// BuildBlock indicates an expected call of BuildBlock.
func (mr *FullVMMockRecorder) BuildBlock(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BuildBlock", reflect.TypeOf((*FullVM)(nil).BuildBlock), arg0)
}

// Connected mocks base method.
func (m *FullVM) Connected(ctx context.Context, nodeID ids.NodeID, nodeVersion *version.Application) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Connected", ctx, nodeID, nodeVersion)
	ret0, _ := ret[0].(error)
	return ret0
}

// Connected indicates an expected call of Connected.
func (mr *FullVMMockRecorder) Connected(ctx, nodeID, nodeVersion any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Connected", reflect.TypeOf((*FullVM)(nil).Connected), ctx, nodeID, nodeVersion)
}

// CreateHandlers mocks base method.
func (m *FullVM) CreateHandlers(arg0 context.Context) (map[string]http.Handler, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateHandlers", arg0)
	ret0, _ := ret[0].(map[string]http.Handler)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateHandlers indicates an expected call of CreateHandlers.
func (mr *FullVMMockRecorder) CreateHandlers(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateHandlers", reflect.TypeOf((*FullVM)(nil).CreateHandlers), arg0)
}

// Disconnected mocks base method.
func (m *FullVM) Disconnected(ctx context.Context, nodeID ids.NodeID) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Disconnected", ctx, nodeID)
	ret0, _ := ret[0].(error)
	return ret0
}

// Disconnected indicates an expected call of Disconnected.
func (mr *FullVMMockRecorder) Disconnected(ctx, nodeID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Disconnected", reflect.TypeOf((*FullVM)(nil).Disconnected), ctx, nodeID)
}

// GetAncestors mocks base method.
func (m *FullVM) GetAncestors(ctx context.Context, blkID ids.ID, maxBlocksNum, maxBlocksSize int, maxBlocksRetrivalTime time.Duration) ([][]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAncestors", ctx, blkID, maxBlocksNum, maxBlocksSize, maxBlocksRetrivalTime)
	ret0, _ := ret[0].([][]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAncestors indicates an expected call of GetAncestors.
func (mr *FullVMMockRecorder) GetAncestors(ctx, blkID, maxBlocksNum, maxBlocksSize, maxBlocksRetrivalTime any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAncestors", reflect.TypeOf((*FullVM)(nil).GetAncestors), ctx, blkID, maxBlocksNum, maxBlocksSize, maxBlocksRetrivalTime)
}

// GetBlock mocks base method.
func (m *FullVM) GetBlock(ctx context.Context, blkID ids.ID) (snowman.Block, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBlock", ctx, blkID)
	ret0, _ := ret[0].(snowman.Block)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBlock indicates an expected call of GetBlock.
func (mr *FullVMMockRecorder) GetBlock(ctx, blkID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBlock", reflect.TypeOf((*FullVM)(nil).GetBlock), ctx, blkID)
}

// GetBlockIDAtHeight mocks base method.
func (m *FullVM) GetBlockIDAtHeight(ctx context.Context, height uint64) (ids.ID, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBlockIDAtHeight", ctx, height)
	ret0, _ := ret[0].(ids.ID)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBlockIDAtHeight indicates an expected call of GetBlockIDAtHeight.
func (mr *FullVMMockRecorder) GetBlockIDAtHeight(ctx, height any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBlockIDAtHeight", reflect.TypeOf((*FullVM)(nil).GetBlockIDAtHeight), ctx, height)
}

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

// GetLastStateSummary indicates an expected call of GetLastStateSummary.
func (mr *FullVMMockRecorder) GetLastStateSummary(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLastStateSummary", reflect.TypeOf((*FullVM)(nil).GetLastStateSummary), arg0)
}

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

// GetOngoingSyncStateSummary indicates an expected call of GetOngoingSyncStateSummary.
func (mr *FullVMMockRecorder) GetOngoingSyncStateSummary(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOngoingSyncStateSummary", reflect.TypeOf((*FullVM)(nil).GetOngoingSyncStateSummary), arg0)
}

// GetStateSummary mocks base method.
func (m *FullVM) GetStateSummary(ctx context.Context, summaryHeight uint64) (block.StateSummary, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetStateSummary", ctx, summaryHeight)
	ret0, _ := ret[0].(block.StateSummary)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetStateSummary indicates an expected call of GetStateSummary.
func (mr *FullVMMockRecorder) GetStateSummary(ctx, summaryHeight any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStateSummary", reflect.TypeOf((*FullVM)(nil).GetStateSummary), ctx, summaryHeight)
}

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

// HealthCheck indicates an expected call of HealthCheck.
func (mr *FullVMMockRecorder) HealthCheck(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HealthCheck", reflect.TypeOf((*FullVM)(nil).HealthCheck), arg0)
}

// Initialize mocks base method.
func (m *FullVM) Initialize(ctx context.Context, chainCtx *snow.Context, db database.Database, genesisBytes, upgradeBytes, configBytes []byte, fxs []*common.Fx, appSender common.AppSender) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Initialize", ctx, chainCtx, db, genesisBytes, upgradeBytes, configBytes, fxs, appSender)
	ret0, _ := ret[0].(error)
	return ret0
}

// Initialize indicates an expected call of Initialize.
func (mr *FullVMMockRecorder) Initialize(ctx, chainCtx, db, genesisBytes, upgradeBytes, configBytes, fxs, appSender any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Initialize", reflect.TypeOf((*FullVM)(nil).Initialize), ctx, chainCtx, db, genesisBytes, upgradeBytes, configBytes, fxs, appSender)
}

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

// LastAccepted indicates an expected call of LastAccepted.
func (mr *FullVMMockRecorder) LastAccepted(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LastAccepted", reflect.TypeOf((*FullVM)(nil).LastAccepted), arg0)
}

// NewHTTPHandler mocks base method.
func (m *FullVM) NewHTTPHandler(ctx context.Context) (http.Handler, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewHTTPHandler", ctx)
	ret0, _ := ret[0].(http.Handler)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NewHTTPHandler indicates an expected call of NewHTTPHandler.
func (mr *FullVMMockRecorder) NewHTTPHandler(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewHTTPHandler", reflect.TypeOf((*FullVM)(nil).NewHTTPHandler), ctx)
}

// ParseBlock mocks base method.
func (m *FullVM) ParseBlock(ctx context.Context, blockBytes []byte) (snowman.Block, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ParseBlock", ctx, blockBytes)
	ret0, _ := ret[0].(snowman.Block)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ParseBlock indicates an expected call of ParseBlock.
func (mr *FullVMMockRecorder) ParseBlock(ctx, blockBytes any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ParseBlock", reflect.TypeOf((*FullVM)(nil).ParseBlock), ctx, blockBytes)
}

// ParseStateSummary mocks base method.
func (m *FullVM) ParseStateSummary(ctx context.Context, summaryBytes []byte) (block.StateSummary, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ParseStateSummary", ctx, summaryBytes)
	ret0, _ := ret[0].(block.StateSummary)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ParseStateSummary indicates an expected call of ParseStateSummary.
func (mr *FullVMMockRecorder) ParseStateSummary(ctx, summaryBytes any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ParseStateSummary", reflect.TypeOf((*FullVM)(nil).ParseStateSummary), ctx, summaryBytes)
}

// SetPreference mocks base method.
func (m *FullVM) SetPreference(ctx context.Context, blkID ids.ID) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetPreference", ctx, blkID)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetPreference indicates an expected call of SetPreference.
func (mr *FullVMMockRecorder) SetPreference(ctx, blkID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPreference", reflect.TypeOf((*FullVM)(nil).SetPreference), ctx, blkID)
}

// SetState mocks base method.
func (m *FullVM) SetState(ctx context.Context, state snow.State) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetState", ctx, state)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetState indicates an expected call of SetState.
func (mr *FullVMMockRecorder) SetState(ctx, state any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetState", reflect.TypeOf((*FullVM)(nil).SetState), ctx, state)
}

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

// Shutdown indicates an expected call of Shutdown.
func (mr *FullVMMockRecorder) Shutdown(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Shutdown", reflect.TypeOf((*FullVM)(nil).Shutdown), arg0)
}

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

// StateSyncEnabled indicates an expected call of StateSyncEnabled.
func (mr *FullVMMockRecorder) StateSyncEnabled(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateSyncEnabled", reflect.TypeOf((*FullVM)(nil).StateSyncEnabled), arg0)
}

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

// Version indicates an expected call of Version.
func (mr *FullVMMockRecorder) Version(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Version", reflect.TypeOf((*FullVM)(nil).Version), arg0)
}

// WaitForEvent mocks base method.
func (m *FullVM) WaitForEvent(ctx context.Context) (common.Message, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitForEvent", ctx)
	ret0, _ := ret[0].(common.Message)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// WaitForEvent indicates an expected call of WaitForEvent.
func (mr *FullVMMockRecorder) WaitForEvent(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitForEvent", reflect.TypeOf((*FullVM)(nil).WaitForEvent), ctx)
}
