all/mocks: regenerate with mockery v3

1 files changed, 218 insertions, 116 deletions

diff --git a/vm/proxyapp/mocks/ProxyAppInterface.go b/vm/proxyapp/mocks/ProxyAppInterface.go
index a79afbb0e..0255990cc 100644
--- a/vm/proxyapp/mocks/ProxyAppInterface.go
+++ b/vm/proxyapp/mocks/ProxyAppInterface.go
@@ -1,12 +1,28 @@
-// Code generated by mockery v2.52.1. DO NOT EDIT.
+// Code generated by mockery; DO NOT EDIT.
+// github.com/vektra/mockery
+// template: testify
 
 package mocks
 
 import (
-	proxyrpc "github.com/google/syzkaller/vm/proxyapp/proxyrpc"
+	"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
@@ -20,21 +36,20 @@ func (_m *ProxyAppInterface) EXPECT() *ProxyAppInterface_Expecter {
 	return &ProxyAppInterface_Expecter{mock: &_m.Mock}
 }
 
-// Close provides a mock function with given fields: in, out
-func (_m *ProxyAppInterface) Close(in proxyrpc.CloseParams, out *proxyrpc.CloseReply) error {
-	ret := _m.Called(in, out)
+// 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 rf, ok := ret.Get(0).(func(proxyrpc.CloseParams, *proxyrpc.CloseReply) error); ok {
-		r0 = rf(in, out)
+	if returnFunc, ok := ret.Get(0).(func(proxyrpc.CloseParams, *proxyrpc.CloseReply) error); ok {
+		r0 = returnFunc(in, out)
 	} else {
 		r0 = ret.Error(0)
 	}
-
 	return r0
 }
 
@@ -52,36 +67,46 @@ func (_e *ProxyAppInterface_Expecter) Close(in interface{}, out interface{}) *Pr
 
 func (_c *ProxyAppInterface_Close_Call) Run(run func(in proxyrpc.CloseParams, out *proxyrpc.CloseReply)) *ProxyAppInterface_Close_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(proxyrpc.CloseParams), args[1].(*proxyrpc.CloseReply))
+		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(_a0 error) *ProxyAppInterface_Close_Call {
-	_c.Call.Return(_a0)
+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(proxyrpc.CloseParams, *proxyrpc.CloseReply) error) *ProxyAppInterface_Close_Call {
+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 with given fields: in, out
-func (_m *ProxyAppInterface) Copy(in proxyrpc.CopyParams, out *proxyrpc.CopyResult) error {
-	ret := _m.Called(in, out)
+// 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 rf, ok := ret.Get(0).(func(proxyrpc.CopyParams, *proxyrpc.CopyResult) error); ok {
-		r0 = rf(in, out)
+	if returnFunc, ok := ret.Get(0).(func(proxyrpc.CopyParams, *proxyrpc.CopyResult) error); ok {
+		r0 = returnFunc(in, out)
 	} else {
 		r0 = ret.Error(0)
 	}
-
 	return r0
 }
 
@@ -99,36 +124,46 @@ func (_e *ProxyAppInterface_Expecter) Copy(in interface{}, out interface{}) *Pro
 
 func (_c *ProxyAppInterface_Copy_Call) Run(run func(in proxyrpc.CopyParams, out *proxyrpc.CopyResult)) *ProxyAppInterface_Copy_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(proxyrpc.CopyParams), args[1].(*proxyrpc.CopyResult))
+		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(_a0 error) *ProxyAppInterface_Copy_Call {
-	_c.Call.Return(_a0)
+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(proxyrpc.CopyParams, *proxyrpc.CopyResult) error) *ProxyAppInterface_Copy_Call {
+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 with given fields: in, out
-func (_m *ProxyAppInterface) CreateInstance(in proxyrpc.CreateInstanceParams, out *proxyrpc.CreateInstanceResult) error {
-	ret := _m.Called(in, out)
+// 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 rf, ok := ret.Get(0).(func(proxyrpc.CreateInstanceParams, *proxyrpc.CreateInstanceResult) error); ok {
-		r0 = rf(in, out)
+	if returnFunc, ok := ret.Get(0).(func(proxyrpc.CreateInstanceParams, *proxyrpc.CreateInstanceResult) error); ok {
+		r0 = returnFunc(in, out)
 	} else {
 		r0 = ret.Error(0)
 	}
-
 	return r0
 }
 
@@ -146,36 +181,46 @@ func (_e *ProxyAppInterface_Expecter) CreateInstance(in interface{}, out interfa
 
 func (_c *ProxyAppInterface_CreateInstance_Call) Run(run func(in proxyrpc.CreateInstanceParams, out *proxyrpc.CreateInstanceResult)) *ProxyAppInterface_CreateInstance_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(proxyrpc.CreateInstanceParams), args[1].(*proxyrpc.CreateInstanceResult))
+		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(_a0 error) *ProxyAppInterface_CreateInstance_Call {
-	_c.Call.Return(_a0)
+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(proxyrpc.CreateInstanceParams, *proxyrpc.CreateInstanceResult) error) *ProxyAppInterface_CreateInstance_Call {
+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 with given fields: in, out
-func (_m *ProxyAppInterface) CreatePool(in proxyrpc.CreatePoolParams, out *proxyrpc.CreatePoolResult) error {
-	ret := _m.Called(in, out)
+// 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 rf, ok := ret.Get(0).(func(proxyrpc.CreatePoolParams, *proxyrpc.CreatePoolResult) error); ok {
-		r0 = rf(in, out)
+	if returnFunc, ok := ret.Get(0).(func(proxyrpc.CreatePoolParams, *proxyrpc.CreatePoolResult) error); ok {
+		r0 = returnFunc(in, out)
 	} else {
 		r0 = ret.Error(0)
 	}
-
 	return r0
 }
 
@@ -193,36 +238,46 @@ func (_e *ProxyAppInterface_Expecter) CreatePool(in interface{}, out interface{}
 
 func (_c *ProxyAppInterface_CreatePool_Call) Run(run func(in proxyrpc.CreatePoolParams, out *proxyrpc.CreatePoolResult)) *ProxyAppInterface_CreatePool_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(proxyrpc.CreatePoolParams), args[1].(*proxyrpc.CreatePoolResult))
+		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(_a0 error) *ProxyAppInterface_CreatePool_Call {
-	_c.Call.Return(_a0)
+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(proxyrpc.CreatePoolParams, *proxyrpc.CreatePoolResult) error) *ProxyAppInterface_CreatePool_Call {
+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 with given fields: in, out
-func (_m *ProxyAppInterface) Diagnose(in proxyrpc.DiagnoseParams, out *proxyrpc.DiagnoseReply) error {
-	ret := _m.Called(in, out)
+// 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 rf, ok := ret.Get(0).(func(proxyrpc.DiagnoseParams, *proxyrpc.DiagnoseReply) error); ok {
-		r0 = rf(in, out)
+	if returnFunc, ok := ret.Get(0).(func(proxyrpc.DiagnoseParams, *proxyrpc.DiagnoseReply) error); ok {
+		r0 = returnFunc(in, out)
 	} else {
 		r0 = ret.Error(0)
 	}
-
 	return r0
 }
 
@@ -240,36 +295,46 @@ func (_e *ProxyAppInterface_Expecter) Diagnose(in interface{}, out interface{})
 
 func (_c *ProxyAppInterface_Diagnose_Call) Run(run func(in proxyrpc.DiagnoseParams, out *proxyrpc.DiagnoseReply)) *ProxyAppInterface_Diagnose_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(proxyrpc.DiagnoseParams), args[1].(*proxyrpc.DiagnoseReply))
+		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(_a0 error) *ProxyAppInterface_Diagnose_Call {
-	_c.Call.Return(_a0)
+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(proxyrpc.DiagnoseParams, *proxyrpc.DiagnoseReply) error) *ProxyAppInterface_Diagnose_Call {
+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 with given fields: in, out
-func (_m *ProxyAppInterface) Forward(in proxyrpc.ForwardParams, out *proxyrpc.ForwardResult) error {
-	ret := _m.Called(in, out)
+// 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 rf, ok := ret.Get(0).(func(proxyrpc.ForwardParams, *proxyrpc.ForwardResult) error); ok {
-		r0 = rf(in, out)
+	if returnFunc, ok := ret.Get(0).(func(proxyrpc.ForwardParams, *proxyrpc.ForwardResult) error); ok {
+		r0 = returnFunc(in, out)
 	} else {
 		r0 = ret.Error(0)
 	}
-
 	return r0
 }
 
@@ -287,36 +352,46 @@ func (_e *ProxyAppInterface_Expecter) Forward(in interface{}, out interface{}) *
 
 func (_c *ProxyAppInterface_Forward_Call) Run(run func(in proxyrpc.ForwardParams, out *proxyrpc.ForwardResult)) *ProxyAppInterface_Forward_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(proxyrpc.ForwardParams), args[1].(*proxyrpc.ForwardResult))
+		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(_a0 error) *ProxyAppInterface_Forward_Call {
-	_c.Call.Return(_a0)
+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(proxyrpc.ForwardParams, *proxyrpc.ForwardResult) error) *ProxyAppInterface_Forward_Call {
+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 with given fields: in, out
-func (_m *ProxyAppInterface) PoolLogs(in proxyrpc.PoolLogsParam, out *proxyrpc.PoolLogsReply) error {
-	ret := _m.Called(in, out)
+// 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 rf, ok := ret.Get(0).(func(proxyrpc.PoolLogsParam, *proxyrpc.PoolLogsReply) error); ok {
-		r0 = rf(in, out)
+	if returnFunc, ok := ret.Get(0).(func(proxyrpc.PoolLogsParam, *proxyrpc.PoolLogsReply) error); ok {
+		r0 = returnFunc(in, out)
 	} else {
 		r0 = ret.Error(0)
 	}
-
 	return r0
 }
 
@@ -334,36 +409,46 @@ func (_e *ProxyAppInterface_Expecter) PoolLogs(in interface{}, out interface{})
 
 func (_c *ProxyAppInterface_PoolLogs_Call) Run(run func(in proxyrpc.PoolLogsParam, out *proxyrpc.PoolLogsReply)) *ProxyAppInterface_PoolLogs_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(proxyrpc.PoolLogsParam), args[1].(*proxyrpc.PoolLogsReply))
+		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(_a0 error) *ProxyAppInterface_PoolLogs_Call {
-	_c.Call.Return(_a0)
+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(proxyrpc.PoolLogsParam, *proxyrpc.PoolLogsReply) error) *ProxyAppInterface_PoolLogs_Call {
+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 with given fields: in, out
-func (_m *ProxyAppInterface) RunReadProgress(in proxyrpc.RunReadProgressParams, out *proxyrpc.RunReadProgressReply) error {
-	ret := _m.Called(in, out)
+// 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 rf, ok := ret.Get(0).(func(proxyrpc.RunReadProgressParams, *proxyrpc.RunReadProgressReply) error); ok {
-		r0 = rf(in, out)
+	if returnFunc, ok := ret.Get(0).(func(proxyrpc.RunReadProgressParams, *proxyrpc.RunReadProgressReply) error); ok {
+		r0 = returnFunc(in, out)
 	} else {
 		r0 = ret.Error(0)
 	}
-
 	return r0
 }
 
@@ -381,36 +466,46 @@ func (_e *ProxyAppInterface_Expecter) RunReadProgress(in interface{}, out interf
 
 func (_c *ProxyAppInterface_RunReadProgress_Call) Run(run func(in proxyrpc.RunReadProgressParams, out *proxyrpc.RunReadProgressReply)) *ProxyAppInterface_RunReadProgress_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(proxyrpc.RunReadProgressParams), args[1].(*proxyrpc.RunReadProgressReply))
+		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(_a0 error) *ProxyAppInterface_RunReadProgress_Call {
-	_c.Call.Return(_a0)
+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(proxyrpc.RunReadProgressParams, *proxyrpc.RunReadProgressReply) error) *ProxyAppInterface_RunReadProgress_Call {
+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 with given fields: in, out
-func (_m *ProxyAppInterface) RunStart(in proxyrpc.RunStartParams, out *proxyrpc.RunStartReply) error {
-	ret := _m.Called(in, out)
+// 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 rf, ok := ret.Get(0).(func(proxyrpc.RunStartParams, *proxyrpc.RunStartReply) error); ok {
-		r0 = rf(in, out)
+	if returnFunc, ok := ret.Get(0).(func(proxyrpc.RunStartParams, *proxyrpc.RunStartReply) error); ok {
+		r0 = returnFunc(in, out)
 	} else {
 		r0 = ret.Error(0)
 	}
-
 	return r0
 }
 
@@ -428,36 +523,46 @@ func (_e *ProxyAppInterface_Expecter) RunStart(in interface{}, out interface{})
 
 func (_c *ProxyAppInterface_RunStart_Call) Run(run func(in proxyrpc.RunStartParams, out *proxyrpc.RunStartReply)) *ProxyAppInterface_RunStart_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(proxyrpc.RunStartParams), args[1].(*proxyrpc.RunStartReply))
+		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(_a0 error) *ProxyAppInterface_RunStart_Call {
-	_c.Call.Return(_a0)
+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(proxyrpc.RunStartParams, *proxyrpc.RunStartReply) error) *ProxyAppInterface_RunStart_Call {
+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 with given fields: in, out
-func (_m *ProxyAppInterface) RunStop(in proxyrpc.RunStopParams, out *proxyrpc.RunStopReply) error {
-	ret := _m.Called(in, out)
+// 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 rf, ok := ret.Get(0).(func(proxyrpc.RunStopParams, *proxyrpc.RunStopReply) error); ok {
-		r0 = rf(in, out)
+	if returnFunc, ok := ret.Get(0).(func(proxyrpc.RunStopParams, *proxyrpc.RunStopReply) error); ok {
+		r0 = returnFunc(in, out)
 	} else {
 		r0 = ret.Error(0)
 	}
-
 	return r0
 }
 
@@ -475,31 +580,28 @@ func (_e *ProxyAppInterface_Expecter) RunStop(in interface{}, out interface{}) *
 
 func (_c *ProxyAppInterface_RunStop_Call) Run(run func(in proxyrpc.RunStopParams, out *proxyrpc.RunStopReply)) *ProxyAppInterface_RunStop_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(proxyrpc.RunStopParams), args[1].(*proxyrpc.RunStopReply))
+		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(_a0 error) *ProxyAppInterface_RunStop_Call {
-	_c.Call.Return(_a0)
+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(proxyrpc.RunStopParams, *proxyrpc.RunStopReply) error) *ProxyAppInterface_RunStop_Call {
+func (_c *ProxyAppInterface_RunStop_Call) RunAndReturn(run func(in proxyrpc.RunStopParams, out *proxyrpc.RunStopReply) error) *ProxyAppInterface_RunStop_Call {
 	_c.Call.Return(run)
 	return _c
 }
-
-// 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
-}