github.com/enbility/spine-go@v0.7.0/mocks/OperationsInterface.go (about) 1 // Code generated by mockery v2.45.0. DO NOT EDIT. 2 3 package mocks 4 5 import ( 6 model "github.com/enbility/spine-go/model" 7 mock "github.com/stretchr/testify/mock" 8 ) 9 10 // OperationsInterface is an autogenerated mock type for the OperationsInterface type 11 type OperationsInterface struct { 12 mock.Mock 13 } 14 15 type OperationsInterface_Expecter struct { 16 mock *mock.Mock 17 } 18 19 func (_m *OperationsInterface) EXPECT() *OperationsInterface_Expecter { 20 return &OperationsInterface_Expecter{mock: &_m.Mock} 21 } 22 23 // Information provides a mock function with given fields: 24 func (_m *OperationsInterface) Information() *model.PossibleOperationsType { 25 ret := _m.Called() 26 27 if len(ret) == 0 { 28 panic("no return value specified for Information") 29 } 30 31 var r0 *model.PossibleOperationsType 32 if rf, ok := ret.Get(0).(func() *model.PossibleOperationsType); ok { 33 r0 = rf() 34 } else { 35 if ret.Get(0) != nil { 36 r0 = ret.Get(0).(*model.PossibleOperationsType) 37 } 38 } 39 40 return r0 41 } 42 43 // OperationsInterface_Information_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Information' 44 type OperationsInterface_Information_Call struct { 45 *mock.Call 46 } 47 48 // Information is a helper method to define mock.On call 49 func (_e *OperationsInterface_Expecter) Information() *OperationsInterface_Information_Call { 50 return &OperationsInterface_Information_Call{Call: _e.mock.On("Information")} 51 } 52 53 func (_c *OperationsInterface_Information_Call) Run(run func()) *OperationsInterface_Information_Call { 54 _c.Call.Run(func(args mock.Arguments) { 55 run() 56 }) 57 return _c 58 } 59 60 func (_c *OperationsInterface_Information_Call) Return(_a0 *model.PossibleOperationsType) *OperationsInterface_Information_Call { 61 _c.Call.Return(_a0) 62 return _c 63 } 64 65 func (_c *OperationsInterface_Information_Call) RunAndReturn(run func() *model.PossibleOperationsType) *OperationsInterface_Information_Call { 66 _c.Call.Return(run) 67 return _c 68 } 69 70 // Read provides a mock function with given fields: 71 func (_m *OperationsInterface) Read() bool { 72 ret := _m.Called() 73 74 if len(ret) == 0 { 75 panic("no return value specified for Read") 76 } 77 78 var r0 bool 79 if rf, ok := ret.Get(0).(func() bool); ok { 80 r0 = rf() 81 } else { 82 r0 = ret.Get(0).(bool) 83 } 84 85 return r0 86 } 87 88 // OperationsInterface_Read_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Read' 89 type OperationsInterface_Read_Call struct { 90 *mock.Call 91 } 92 93 // Read is a helper method to define mock.On call 94 func (_e *OperationsInterface_Expecter) Read() *OperationsInterface_Read_Call { 95 return &OperationsInterface_Read_Call{Call: _e.mock.On("Read")} 96 } 97 98 func (_c *OperationsInterface_Read_Call) Run(run func()) *OperationsInterface_Read_Call { 99 _c.Call.Run(func(args mock.Arguments) { 100 run() 101 }) 102 return _c 103 } 104 105 func (_c *OperationsInterface_Read_Call) Return(_a0 bool) *OperationsInterface_Read_Call { 106 _c.Call.Return(_a0) 107 return _c 108 } 109 110 func (_c *OperationsInterface_Read_Call) RunAndReturn(run func() bool) *OperationsInterface_Read_Call { 111 _c.Call.Return(run) 112 return _c 113 } 114 115 // ReadPartial provides a mock function with given fields: 116 func (_m *OperationsInterface) ReadPartial() bool { 117 ret := _m.Called() 118 119 if len(ret) == 0 { 120 panic("no return value specified for ReadPartial") 121 } 122 123 var r0 bool 124 if rf, ok := ret.Get(0).(func() bool); ok { 125 r0 = rf() 126 } else { 127 r0 = ret.Get(0).(bool) 128 } 129 130 return r0 131 } 132 133 // OperationsInterface_ReadPartial_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReadPartial' 134 type OperationsInterface_ReadPartial_Call struct { 135 *mock.Call 136 } 137 138 // ReadPartial is a helper method to define mock.On call 139 func (_e *OperationsInterface_Expecter) ReadPartial() *OperationsInterface_ReadPartial_Call { 140 return &OperationsInterface_ReadPartial_Call{Call: _e.mock.On("ReadPartial")} 141 } 142 143 func (_c *OperationsInterface_ReadPartial_Call) Run(run func()) *OperationsInterface_ReadPartial_Call { 144 _c.Call.Run(func(args mock.Arguments) { 145 run() 146 }) 147 return _c 148 } 149 150 func (_c *OperationsInterface_ReadPartial_Call) Return(_a0 bool) *OperationsInterface_ReadPartial_Call { 151 _c.Call.Return(_a0) 152 return _c 153 } 154 155 func (_c *OperationsInterface_ReadPartial_Call) RunAndReturn(run func() bool) *OperationsInterface_ReadPartial_Call { 156 _c.Call.Return(run) 157 return _c 158 } 159 160 // String provides a mock function with given fields: 161 func (_m *OperationsInterface) String() string { 162 ret := _m.Called() 163 164 if len(ret) == 0 { 165 panic("no return value specified for String") 166 } 167 168 var r0 string 169 if rf, ok := ret.Get(0).(func() string); ok { 170 r0 = rf() 171 } else { 172 r0 = ret.Get(0).(string) 173 } 174 175 return r0 176 } 177 178 // OperationsInterface_String_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'String' 179 type OperationsInterface_String_Call struct { 180 *mock.Call 181 } 182 183 // String is a helper method to define mock.On call 184 func (_e *OperationsInterface_Expecter) String() *OperationsInterface_String_Call { 185 return &OperationsInterface_String_Call{Call: _e.mock.On("String")} 186 } 187 188 func (_c *OperationsInterface_String_Call) Run(run func()) *OperationsInterface_String_Call { 189 _c.Call.Run(func(args mock.Arguments) { 190 run() 191 }) 192 return _c 193 } 194 195 func (_c *OperationsInterface_String_Call) Return(_a0 string) *OperationsInterface_String_Call { 196 _c.Call.Return(_a0) 197 return _c 198 } 199 200 func (_c *OperationsInterface_String_Call) RunAndReturn(run func() string) *OperationsInterface_String_Call { 201 _c.Call.Return(run) 202 return _c 203 } 204 205 // Write provides a mock function with given fields: 206 func (_m *OperationsInterface) Write() bool { 207 ret := _m.Called() 208 209 if len(ret) == 0 { 210 panic("no return value specified for Write") 211 } 212 213 var r0 bool 214 if rf, ok := ret.Get(0).(func() bool); ok { 215 r0 = rf() 216 } else { 217 r0 = ret.Get(0).(bool) 218 } 219 220 return r0 221 } 222 223 // OperationsInterface_Write_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Write' 224 type OperationsInterface_Write_Call struct { 225 *mock.Call 226 } 227 228 // Write is a helper method to define mock.On call 229 func (_e *OperationsInterface_Expecter) Write() *OperationsInterface_Write_Call { 230 return &OperationsInterface_Write_Call{Call: _e.mock.On("Write")} 231 } 232 233 func (_c *OperationsInterface_Write_Call) Run(run func()) *OperationsInterface_Write_Call { 234 _c.Call.Run(func(args mock.Arguments) { 235 run() 236 }) 237 return _c 238 } 239 240 func (_c *OperationsInterface_Write_Call) Return(_a0 bool) *OperationsInterface_Write_Call { 241 _c.Call.Return(_a0) 242 return _c 243 } 244 245 func (_c *OperationsInterface_Write_Call) RunAndReturn(run func() bool) *OperationsInterface_Write_Call { 246 _c.Call.Return(run) 247 return _c 248 } 249 250 // WritePartial provides a mock function with given fields: 251 func (_m *OperationsInterface) WritePartial() bool { 252 ret := _m.Called() 253 254 if len(ret) == 0 { 255 panic("no return value specified for WritePartial") 256 } 257 258 var r0 bool 259 if rf, ok := ret.Get(0).(func() bool); ok { 260 r0 = rf() 261 } else { 262 r0 = ret.Get(0).(bool) 263 } 264 265 return r0 266 } 267 268 // OperationsInterface_WritePartial_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WritePartial' 269 type OperationsInterface_WritePartial_Call struct { 270 *mock.Call 271 } 272 273 // WritePartial is a helper method to define mock.On call 274 func (_e *OperationsInterface_Expecter) WritePartial() *OperationsInterface_WritePartial_Call { 275 return &OperationsInterface_WritePartial_Call{Call: _e.mock.On("WritePartial")} 276 } 277 278 func (_c *OperationsInterface_WritePartial_Call) Run(run func()) *OperationsInterface_WritePartial_Call { 279 _c.Call.Run(func(args mock.Arguments) { 280 run() 281 }) 282 return _c 283 } 284 285 func (_c *OperationsInterface_WritePartial_Call) Return(_a0 bool) *OperationsInterface_WritePartial_Call { 286 _c.Call.Return(_a0) 287 return _c 288 } 289 290 func (_c *OperationsInterface_WritePartial_Call) RunAndReturn(run func() bool) *OperationsInterface_WritePartial_Call { 291 _c.Call.Return(run) 292 return _c 293 } 294 295 // NewOperationsInterface creates a new instance of OperationsInterface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. 296 // The first argument is typically a *testing.T value. 297 func NewOperationsInterface(t interface { 298 mock.TestingT 299 Cleanup(func()) 300 }) *OperationsInterface { 301 mock := &OperationsInterface{} 302 mock.Mock.Test(t) 303 304 t.Cleanup(func() { mock.AssertExpectations(t) }) 305 306 return mock 307 }