path: root/vm/proxyapp/mocks/ProxyAppInterface.go

// Code generated by mockery; DO NOT EDIT.
// github.com/vektra/mockery
// template: testify

package mocks

import (
	"github.com/google/syzkaller/vm/proxyapp/proxyrpc"
	mock "github.com/stretchr/testify/mock"
)

// NewProxyAppInterface creates a new instance of ProxyAppInterface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func NewProxyAppInterface(t interface {
	mock.TestingT
	Cleanup(func())
}) *ProxyAppInterface {
	mock := &ProxyAppInterface{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}

// ProxyAppInterface is an autogenerated mock type for the ProxyAppInterface type
type ProxyAppInterface struct {
	mock.Mock
}

type ProxyAppInterface_Expecter struct {
	mock *mock.Mock
}

func (_m *ProxyAppInterface) EXPECT() *ProxyAppInterface_Expecter {
	return &ProxyAppInterface_Expecter{mock: &_m.Mock}
}

// Close provides a mock function for the type ProxyAppInterface
func (_mock *ProxyAppInterface) Close(in proxyrpc.CloseParams, out *proxyrpc.CloseReply) error {
	ret := _mock.Called(in, out)

	if len(ret) == 0 {
		panic("no return value specified for Close")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(proxyrpc.CloseParams, *proxyrpc.CloseReply) error); ok {
		r0 = returnFunc(in, out)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// ProxyAppInterface_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
type ProxyAppInterface_Close_Call struct {
	*mock.Call
}

// Close is a helper method to define mock.On call
//   - in proxyrpc.CloseParams
//   - out *proxyrpc.CloseReply
func (_e *ProxyAppInterface_Expecter) Close(in interface{}, out interface{}) *ProxyAppInterface_Close_Call {
	return &ProxyAppInterface_Close_Call{Call: _e.mock.On("Close", in, out)}
}

func (_c *ProxyAppInterface_Close_Call) Run(run func(in proxyrpc.CloseParams, out *proxyrpc.CloseReply)) *ProxyAppInterface_Close_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 proxyrpc.CloseParams
		if args[0] != nil {
			arg0 = args[0].(proxyrpc.CloseParams)
		}
		var arg1 *proxyrpc.CloseReply
		if args[1] != nil {
			arg1 = args[1].(*proxyrpc.CloseReply)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *ProxyAppInterface_Close_Call) Return(err error) *ProxyAppInterface_Close_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *ProxyAppInterface_Close_Call) RunAndReturn(run func(in proxyrpc.CloseParams, out *proxyrpc.CloseReply) error) *ProxyAppInterface_Close_Call {
	_c.Call.Return(run)
	return _c
}

// Copy provides a mock function for the type ProxyAppInterface
func (_mock *ProxyAppInterface) Copy(in proxyrpc.CopyParams, out *proxyrpc.CopyResult) error {
	ret := _mock.Called(in, out)

	if len(ret) == 0 {
		panic("no return value specified for Copy")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(proxyrpc.CopyParams, *proxyrpc.CopyResult) error); ok {
		r0 = returnFunc(in, out)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// ProxyAppInterface_Copy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Copy'
type ProxyAppInterface_Copy_Call struct {
	*mock.Call
}

// Copy is a helper method to define mock.On call
//   - in proxyrpc.CopyParams
//   - out *proxyrpc.CopyResult
func (_e *ProxyAppInterface_Expecter) Copy(in interface{}, out interface{}) *ProxyAppInterface_Copy_Call {
	return &ProxyAppInterface_Copy_Call{Call: _e.mock.On("Copy", in, out)}
}

func (_c *ProxyAppInterface_Copy_Call) Run(run func(in proxyrpc.CopyParams, out *proxyrpc.CopyResult)) *ProxyAppInterface_Copy_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 proxyrpc.CopyParams
		if args[0] != nil {
			arg0 = args[0].(proxyrpc.CopyParams)
		}
		var arg1 *proxyrpc.CopyResult
		if args[1] != nil {
			arg1 = args[1].(*proxyrpc.CopyResult)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *ProxyAppInterface_Copy_Call) Return(err error) *ProxyAppInterface_Copy_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *ProxyAppInterface_Copy_Call) RunAndReturn(run func(in proxyrpc.CopyParams, out *proxyrpc.CopyResult) error) *ProxyAppInterface_Copy_Call {
	_c.Call.Return(run)
	return _c
}

// CreateInstance provides a mock function for the type ProxyAppInterface
func (_mock *ProxyAppInterface) CreateInstance(in proxyrpc.CreateInstanceParams, out *proxyrpc.CreateInstanceResult) error {
	ret := _mock.Called(in, out)

	if len(ret) == 0 {
		panic("no return value specified for CreateInstance")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(proxyrpc.CreateInstanceParams, *proxyrpc.CreateInstanceResult) error); ok {
		r0 = returnFunc(in, out)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// ProxyAppInterface_CreateInstance_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateInstance'
type ProxyAppInterface_CreateInstance_Call struct {
	*mock.Call
}

// CreateInstance is a helper method to define mock.On call
//   - in proxyrpc.CreateInstanceParams
//   - out *proxyrpc.CreateInstanceResult
func (_e *ProxyAppInterface_Expecter) CreateInstance(in interface{}, out interface{}) *ProxyAppInterface_CreateInstance_Call {
	return &ProxyAppInterface_CreateInstance_Call{Call: _e.mock.On("CreateInstance", in, out)}
}

func (_c *ProxyAppInterface_CreateInstance_Call) Run(run func(in proxyrpc.CreateInstanceParams, out *proxyrpc.CreateInstanceResult)) *ProxyAppInterface_CreateInstance_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 proxyrpc.CreateInstanceParams
		if args[0] != nil {
			arg0 = args[0].(proxyrpc.CreateInstanceParams)
		}
		var arg1 *proxyrpc.CreateInstanceResult
		if args[1] != nil {
			arg1 = args[1].(*proxyrpc.CreateInstanceResult)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *ProxyAppInterface_CreateInstance_Call) Return(err error) *ProxyAppInterface_CreateInstance_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *ProxyAppInterface_CreateInstance_Call) RunAndReturn(run func(in proxyrpc.CreateInstanceParams, out *proxyrpc.CreateInstanceResult) error) *ProxyAppInterface_CreateInstance_Call {
	_c.Call.Return(run)
	return _c
}

// CreatePool provides a mock function for the type ProxyAppInterface
func (_mock *ProxyAppInterface) CreatePool(in proxyrpc.CreatePoolParams, out *proxyrpc.CreatePoolResult) error {
	ret := _mock.Called(in, out)

	if len(ret) == 0 {
		panic("no return value specified for CreatePool")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(proxyrpc.CreatePoolParams, *proxyrpc.CreatePoolResult) error); ok {
		r0 = returnFunc(in, out)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// ProxyAppInterface_CreatePool_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreatePool'
type ProxyAppInterface_CreatePool_Call struct {
	*mock.Call
}

// CreatePool is a helper method to define mock.On call
//   - in proxyrpc.CreatePoolParams
//   - out *proxyrpc.CreatePoolResult
func (_e *ProxyAppInterface_Expecter) CreatePool(in interface{}, out interface{}) *ProxyAppInterface_CreatePool_Call {
	return &ProxyAppInterface_CreatePool_Call{Call: _e.mock.On("CreatePool", in, out)}
}

func (_c *ProxyAppInterface_CreatePool_Call) Run(run func(in proxyrpc.CreatePoolParams, out *proxyrpc.CreatePoolResult)) *ProxyAppInterface_CreatePool_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 proxyrpc.CreatePoolParams
		if args[0] != nil {
			arg0 = args[0].(proxyrpc.CreatePoolParams)
		}
		var arg1 *proxyrpc.CreatePoolResult
		if args[1] != nil {
			arg1 = args[1].(*proxyrpc.CreatePoolResult)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *ProxyAppInterface_CreatePool_Call) Return(err error) *ProxyAppInterface_CreatePool_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *ProxyAppInterface_CreatePool_Call) RunAndReturn(run func(in proxyrpc.CreatePoolParams, out *proxyrpc.CreatePoolResult) error) *ProxyAppInterface_CreatePool_Call {
	_c.Call.Return(run)
	return _c
}

// Diagnose provides a mock function for the type ProxyAppInterface
func (_mock *ProxyAppInterface) Diagnose(in proxyrpc.DiagnoseParams, out *proxyrpc.DiagnoseReply) error {
	ret := _mock.Called(in, out)

	if len(ret) == 0 {
		panic("no return value specified for Diagnose")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(proxyrpc.DiagnoseParams, *proxyrpc.DiagnoseReply) error); ok {
		r0 = returnFunc(in, out)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// ProxyAppInterface_Diagnose_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Diagnose'
type ProxyAppInterface_Diagnose_Call struct {
	*mock.Call
}

// Diagnose is a helper method to define mock.On call
//   - in proxyrpc.DiagnoseParams
//   - out *proxyrpc.DiagnoseReply
func (_e *ProxyAppInterface_Expecter) Diagnose(in interface{}, out interface{}) *ProxyAppInterface_Diagnose_Call {
	return &ProxyAppInterface_Diagnose_Call{Call: _e.mock.On("Diagnose", in, out)}
}

func (_c *ProxyAppInterface_Diagnose_Call) Run(run func(in proxyrpc.DiagnoseParams, out *proxyrpc.DiagnoseReply)) *ProxyAppInterface_Diagnose_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 proxyrpc.DiagnoseParams
		if args[0] != nil {
			arg0 = args[0].(proxyrpc.DiagnoseParams)
		}
		var arg1 *proxyrpc.DiagnoseReply
		if args[1] != nil {
			arg1 = args[1].(*proxyrpc.DiagnoseReply)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *ProxyAppInterface_Diagnose_Call) Return(err error) *ProxyAppInterface_Diagnose_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *ProxyAppInterface_Diagnose_Call) RunAndReturn(run func(in proxyrpc.DiagnoseParams, out *proxyrpc.DiagnoseReply) error) *ProxyAppInterface_Diagnose_Call {
	_c.Call.Return(run)
	return _c
}

// Forward provides a mock function for the type ProxyAppInterface
func (_mock *ProxyAppInterface) Forward(in proxyrpc.ForwardParams, out *proxyrpc.ForwardResult) error {
	ret := _mock.Called(in, out)

	if len(ret) == 0 {
		panic("no return value specified for Forward")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(proxyrpc.ForwardParams, *proxyrpc.ForwardResult) error); ok {
		r0 = returnFunc(in, out)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// ProxyAppInterface_Forward_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Forward'
type ProxyAppInterface_Forward_Call struct {
	*mock.Call
}

// Forward is a helper method to define mock.On call
//   - in proxyrpc.ForwardParams
//   - out *proxyrpc.ForwardResult
func (_e *ProxyAppInterface_Expecter) Forward(in interface{}, out interface{}) *ProxyAppInterface_Forward_Call {
	return &ProxyAppInterface_Forward_Call{Call: _e.mock.On("Forward", in, out)}
}

func (_c *ProxyAppInterface_Forward_Call) Run(run func(in proxyrpc.ForwardParams, out *proxyrpc.ForwardResult)) *ProxyAppInterface_Forward_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 proxyrpc.ForwardParams
		if args[0] != nil {
			arg0 = args[0].(proxyrpc.ForwardParams)
		}
		var arg1 *proxyrpc.ForwardResult
		if args[1] != nil {
			arg1 = args[1].(*proxyrpc.ForwardResult)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *ProxyAppInterface_Forward_Call) Return(err error) *ProxyAppInterface_Forward_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *ProxyAppInterface_Forward_Call) RunAndReturn(run func(in proxyrpc.ForwardParams, out *proxyrpc.ForwardResult) error) *ProxyAppInterface_Forward_Call {
	_c.Call.Return(run)
	return _c
}

// PoolLogs provides a mock function for the type ProxyAppInterface
func (_mock *ProxyAppInterface) PoolLogs(in proxyrpc.PoolLogsParam, out *proxyrpc.PoolLogsReply) error {
	ret := _mock.Called(in, out)

	if len(ret) == 0 {
		panic("no return value specified for PoolLogs")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(proxyrpc.PoolLogsParam, *proxyrpc.PoolLogsReply) error); ok {
		r0 = returnFunc(in, out)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// ProxyAppInterface_PoolLogs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PoolLogs'
type ProxyAppInterface_PoolLogs_Call struct {
	*mock.Call
}

// PoolLogs is a helper method to define mock.On call
//   - in proxyrpc.PoolLogsParam
//   - out *proxyrpc.PoolLogsReply
func (_e *ProxyAppInterface_Expecter) PoolLogs(in interface{}, out interface{}) *ProxyAppInterface_PoolLogs_Call {
	return &ProxyAppInterface_PoolLogs_Call{Call: _e.mock.On("PoolLogs", in, out)}
}

func (_c *ProxyAppInterface_PoolLogs_Call) Run(run func(in proxyrpc.PoolLogsParam, out *proxyrpc.PoolLogsReply)) *ProxyAppInterface_PoolLogs_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 proxyrpc.PoolLogsParam
		if args[0] != nil {
			arg0 = args[0].(proxyrpc.PoolLogsParam)
		}
		var arg1 *proxyrpc.PoolLogsReply
		if args[1] != nil {
			arg1 = args[1].(*proxyrpc.PoolLogsReply)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *ProxyAppInterface_PoolLogs_Call) Return(err error) *ProxyAppInterface_PoolLogs_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *ProxyAppInterface_PoolLogs_Call) RunAndReturn(run func(in proxyrpc.PoolLogsParam, out *proxyrpc.PoolLogsReply) error) *ProxyAppInterface_PoolLogs_Call {
	_c.Call.Return(run)
	return _c
}

// RunReadProgress provides a mock function for the type ProxyAppInterface
func (_mock *ProxyAppInterface) RunReadProgress(in proxyrpc.RunReadProgressParams, out *proxyrpc.RunReadProgressReply) error {
	ret := _mock.Called(in, out)

	if len(ret) == 0 {
		panic("no return value specified for RunReadProgress")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(proxyrpc.RunReadProgressParams, *proxyrpc.RunReadProgressReply) error); ok {
		r0 = returnFunc(in, out)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// ProxyAppInterface_RunReadProgress_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RunReadProgress'
type ProxyAppInterface_RunReadProgress_Call struct {
	*mock.Call
}

// RunReadProgress is a helper method to define mock.On call
//   - in proxyrpc.RunReadProgressParams
//   - out *proxyrpc.RunReadProgressReply
func (_e *ProxyAppInterface_Expecter) RunReadProgress(in interface{}, out interface{}) *ProxyAppInterface_RunReadProgress_Call {
	return &ProxyAppInterface_RunReadProgress_Call{Call: _e.mock.On("RunReadProgress", in, out)}
}

func (_c *ProxyAppInterface_RunReadProgress_Call) Run(run func(in proxyrpc.RunReadProgressParams, out *proxyrpc.RunReadProgressReply)) *ProxyAppInterface_RunReadProgress_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 proxyrpc.RunReadProgressParams
		if args[0] != nil {
			arg0 = args[0].(proxyrpc.RunReadProgressParams)
		}
		var arg1 *proxyrpc.RunReadProgressReply
		if args[1] != nil {
			arg1 = args[1].(*proxyrpc.RunReadProgressReply)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *ProxyAppInterface_RunReadProgress_Call) Return(err error) *ProxyAppInterface_RunReadProgress_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *ProxyAppInterface_RunReadProgress_Call) RunAndReturn(run func(in proxyrpc.RunReadProgressParams, out *proxyrpc.RunReadProgressReply) error) *ProxyAppInterface_RunReadProgress_Call {
	_c.Call.Return(run)
	return _c
}

// RunStart provides a mock function for the type ProxyAppInterface
func (_mock *ProxyAppInterface) RunStart(in proxyrpc.RunStartParams, out *proxyrpc.RunStartReply) error {
	ret := _mock.Called(in, out)

	if len(ret) == 0 {
		panic("no return value specified for RunStart")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(proxyrpc.RunStartParams, *proxyrpc.RunStartReply) error); ok {
		r0 = returnFunc(in, out)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// ProxyAppInterface_RunStart_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RunStart'
type ProxyAppInterface_RunStart_Call struct {
	*mock.Call
}

// RunStart is a helper method to define mock.On call
//   - in proxyrpc.RunStartParams
//   - out *proxyrpc.RunStartReply
func (_e *ProxyAppInterface_Expecter) RunStart(in interface{}, out interface{}) *ProxyAppInterface_RunStart_Call {
	return &ProxyAppInterface_RunStart_Call{Call: _e.mock.On("RunStart", in, out)}
}

func (_c *ProxyAppInterface_RunStart_Call) Run(run func(in proxyrpc.RunStartParams, out *proxyrpc.RunStartReply)) *ProxyAppInterface_RunStart_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 proxyrpc.RunStartParams
		if args[0] != nil {
			arg0 = args[0].(proxyrpc.RunStartParams)
		}
		var arg1 *proxyrpc.RunStartReply
		if args[1] != nil {
			arg1 = args[1].(*proxyrpc.RunStartReply)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *ProxyAppInterface_RunStart_Call) Return(err error) *ProxyAppInterface_RunStart_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *ProxyAppInterface_RunStart_Call) RunAndReturn(run func(in proxyrpc.RunStartParams, out *proxyrpc.RunStartReply) error) *ProxyAppInterface_RunStart_Call {
	_c.Call.Return(run)
	return _c
}

// RunStop provides a mock function for the type ProxyAppInterface
func (_mock *ProxyAppInterface) RunStop(in proxyrpc.RunStopParams, out *proxyrpc.RunStopReply) error {
	ret := _mock.Called(in, out)

	if len(ret) == 0 {
		panic("no return value specified for RunStop")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(proxyrpc.RunStopParams, *proxyrpc.RunStopReply) error); ok {
		r0 = returnFunc(in, out)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// ProxyAppInterface_RunStop_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RunStop'
type ProxyAppInterface_RunStop_Call struct {
	*mock.Call
}

// RunStop is a helper method to define mock.On call
//   - in proxyrpc.RunStopParams
//   - out *proxyrpc.RunStopReply
func (_e *ProxyAppInterface_Expecter) RunStop(in interface{}, out interface{}) *ProxyAppInterface_RunStop_Call {
	return &ProxyAppInterface_RunStop_Call{Call: _e.mock.On("RunStop", in, out)}
}

func (_c *ProxyAppInterface_RunStop_Call) Run(run func(in proxyrpc.RunStopParams, out *proxyrpc.RunStopReply)) *ProxyAppInterface_RunStop_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 proxyrpc.RunStopParams
		if args[0] != nil {
			arg0 = args[0].(proxyrpc.RunStopParams)
		}
		var arg1 *proxyrpc.RunStopReply
		if args[1] != nil {
			arg1 = args[1].(*proxyrpc.RunStopReply)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *ProxyAppInterface_RunStop_Call) Return(err error) *ProxyAppInterface_RunStop_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *ProxyAppInterface_RunStop_Call) RunAndReturn(run func(in proxyrpc.RunStopParams, out *proxyrpc.RunStopReply) error) *ProxyAppInterface_RunStop_Call {
	_c.Call.Return(run)
	return _c
}