github.com/enbility/spine-go@v0.7.0/mocks/HeartbeatManagerInterface.go (about)

     1  // Code generated by mockery v2.45.0. DO NOT EDIT.
     2  
     3  package mocks
     4  
     5  import (
     6  	api "github.com/enbility/spine-go/api"
     7  	mock "github.com/stretchr/testify/mock"
     8  )
     9  
    10  // HeartbeatManagerInterface is an autogenerated mock type for the HeartbeatManagerInterface type
    11  type HeartbeatManagerInterface struct {
    12  	mock.Mock
    13  }
    14  
    15  type HeartbeatManagerInterface_Expecter struct {
    16  	mock *mock.Mock
    17  }
    18  
    19  func (_m *HeartbeatManagerInterface) EXPECT() *HeartbeatManagerInterface_Expecter {
    20  	return &HeartbeatManagerInterface_Expecter{mock: &_m.Mock}
    21  }
    22  
    23  // IsHeartbeatRunning provides a mock function with given fields:
    24  func (_m *HeartbeatManagerInterface) IsHeartbeatRunning() bool {
    25  	ret := _m.Called()
    26  
    27  	if len(ret) == 0 {
    28  		panic("no return value specified for IsHeartbeatRunning")
    29  	}
    30  
    31  	var r0 bool
    32  	if rf, ok := ret.Get(0).(func() bool); ok {
    33  		r0 = rf()
    34  	} else {
    35  		r0 = ret.Get(0).(bool)
    36  	}
    37  
    38  	return r0
    39  }
    40  
    41  // HeartbeatManagerInterface_IsHeartbeatRunning_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsHeartbeatRunning'
    42  type HeartbeatManagerInterface_IsHeartbeatRunning_Call struct {
    43  	*mock.Call
    44  }
    45  
    46  // IsHeartbeatRunning is a helper method to define mock.On call
    47  func (_e *HeartbeatManagerInterface_Expecter) IsHeartbeatRunning() *HeartbeatManagerInterface_IsHeartbeatRunning_Call {
    48  	return &HeartbeatManagerInterface_IsHeartbeatRunning_Call{Call: _e.mock.On("IsHeartbeatRunning")}
    49  }
    50  
    51  func (_c *HeartbeatManagerInterface_IsHeartbeatRunning_Call) Run(run func()) *HeartbeatManagerInterface_IsHeartbeatRunning_Call {
    52  	_c.Call.Run(func(args mock.Arguments) {
    53  		run()
    54  	})
    55  	return _c
    56  }
    57  
    58  func (_c *HeartbeatManagerInterface_IsHeartbeatRunning_Call) Return(_a0 bool) *HeartbeatManagerInterface_IsHeartbeatRunning_Call {
    59  	_c.Call.Return(_a0)
    60  	return _c
    61  }
    62  
    63  func (_c *HeartbeatManagerInterface_IsHeartbeatRunning_Call) RunAndReturn(run func() bool) *HeartbeatManagerInterface_IsHeartbeatRunning_Call {
    64  	_c.Call.Return(run)
    65  	return _c
    66  }
    67  
    68  // SetLocalFeature provides a mock function with given fields: entity, feature
    69  func (_m *HeartbeatManagerInterface) SetLocalFeature(entity api.EntityLocalInterface, feature api.FeatureLocalInterface) {
    70  	_m.Called(entity, feature)
    71  }
    72  
    73  // HeartbeatManagerInterface_SetLocalFeature_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetLocalFeature'
    74  type HeartbeatManagerInterface_SetLocalFeature_Call struct {
    75  	*mock.Call
    76  }
    77  
    78  // SetLocalFeature is a helper method to define mock.On call
    79  //   - entity api.EntityLocalInterface
    80  //   - feature api.FeatureLocalInterface
    81  func (_e *HeartbeatManagerInterface_Expecter) SetLocalFeature(entity interface{}, feature interface{}) *HeartbeatManagerInterface_SetLocalFeature_Call {
    82  	return &HeartbeatManagerInterface_SetLocalFeature_Call{Call: _e.mock.On("SetLocalFeature", entity, feature)}
    83  }
    84  
    85  func (_c *HeartbeatManagerInterface_SetLocalFeature_Call) Run(run func(entity api.EntityLocalInterface, feature api.FeatureLocalInterface)) *HeartbeatManagerInterface_SetLocalFeature_Call {
    86  	_c.Call.Run(func(args mock.Arguments) {
    87  		run(args[0].(api.EntityLocalInterface), args[1].(api.FeatureLocalInterface))
    88  	})
    89  	return _c
    90  }
    91  
    92  func (_c *HeartbeatManagerInterface_SetLocalFeature_Call) Return() *HeartbeatManagerInterface_SetLocalFeature_Call {
    93  	_c.Call.Return()
    94  	return _c
    95  }
    96  
    97  func (_c *HeartbeatManagerInterface_SetLocalFeature_Call) RunAndReturn(run func(api.EntityLocalInterface, api.FeatureLocalInterface)) *HeartbeatManagerInterface_SetLocalFeature_Call {
    98  	_c.Call.Return(run)
    99  	return _c
   100  }
   101  
   102  // StartHeartbeat provides a mock function with given fields:
   103  func (_m *HeartbeatManagerInterface) StartHeartbeat() error {
   104  	ret := _m.Called()
   105  
   106  	if len(ret) == 0 {
   107  		panic("no return value specified for StartHeartbeat")
   108  	}
   109  
   110  	var r0 error
   111  	if rf, ok := ret.Get(0).(func() error); ok {
   112  		r0 = rf()
   113  	} else {
   114  		r0 = ret.Error(0)
   115  	}
   116  
   117  	return r0
   118  }
   119  
   120  // HeartbeatManagerInterface_StartHeartbeat_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StartHeartbeat'
   121  type HeartbeatManagerInterface_StartHeartbeat_Call struct {
   122  	*mock.Call
   123  }
   124  
   125  // StartHeartbeat is a helper method to define mock.On call
   126  func (_e *HeartbeatManagerInterface_Expecter) StartHeartbeat() *HeartbeatManagerInterface_StartHeartbeat_Call {
   127  	return &HeartbeatManagerInterface_StartHeartbeat_Call{Call: _e.mock.On("StartHeartbeat")}
   128  }
   129  
   130  func (_c *HeartbeatManagerInterface_StartHeartbeat_Call) Run(run func()) *HeartbeatManagerInterface_StartHeartbeat_Call {
   131  	_c.Call.Run(func(args mock.Arguments) {
   132  		run()
   133  	})
   134  	return _c
   135  }
   136  
   137  func (_c *HeartbeatManagerInterface_StartHeartbeat_Call) Return(_a0 error) *HeartbeatManagerInterface_StartHeartbeat_Call {
   138  	_c.Call.Return(_a0)
   139  	return _c
   140  }
   141  
   142  func (_c *HeartbeatManagerInterface_StartHeartbeat_Call) RunAndReturn(run func() error) *HeartbeatManagerInterface_StartHeartbeat_Call {
   143  	_c.Call.Return(run)
   144  	return _c
   145  }
   146  
   147  // StopHeartbeat provides a mock function with given fields:
   148  func (_m *HeartbeatManagerInterface) StopHeartbeat() {
   149  	_m.Called()
   150  }
   151  
   152  // HeartbeatManagerInterface_StopHeartbeat_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StopHeartbeat'
   153  type HeartbeatManagerInterface_StopHeartbeat_Call struct {
   154  	*mock.Call
   155  }
   156  
   157  // StopHeartbeat is a helper method to define mock.On call
   158  func (_e *HeartbeatManagerInterface_Expecter) StopHeartbeat() *HeartbeatManagerInterface_StopHeartbeat_Call {
   159  	return &HeartbeatManagerInterface_StopHeartbeat_Call{Call: _e.mock.On("StopHeartbeat")}
   160  }
   161  
   162  func (_c *HeartbeatManagerInterface_StopHeartbeat_Call) Run(run func()) *HeartbeatManagerInterface_StopHeartbeat_Call {
   163  	_c.Call.Run(func(args mock.Arguments) {
   164  		run()
   165  	})
   166  	return _c
   167  }
   168  
   169  func (_c *HeartbeatManagerInterface_StopHeartbeat_Call) Return() *HeartbeatManagerInterface_StopHeartbeat_Call {
   170  	_c.Call.Return()
   171  	return _c
   172  }
   173  
   174  func (_c *HeartbeatManagerInterface_StopHeartbeat_Call) RunAndReturn(run func()) *HeartbeatManagerInterface_StopHeartbeat_Call {
   175  	_c.Call.Return(run)
   176  	return _c
   177  }
   178  
   179  // NewHeartbeatManagerInterface creates a new instance of HeartbeatManagerInterface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
   180  // The first argument is typically a *testing.T value.
   181  func NewHeartbeatManagerInterface(t interface {
   182  	mock.TestingT
   183  	Cleanup(func())
   184  }) *HeartbeatManagerInterface {
   185  	mock := &HeartbeatManagerInterface{}
   186  	mock.Mock.Test(t)
   187  
   188  	t.Cleanup(func() { mock.AssertExpectations(t) })
   189  
   190  	return mock
   191  }