1// Code generated by mockery; DO NOT EDIT.
2// github.com/vektra/mockery
3// template: testify
4
5package mocks
6
7import (
8 mock "github.com/stretchr/testify/mock"
9)
10
11// NewMockXDGPaths creates a new instance of MockXDGPaths. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
12// The first argument is typically a *testing.T value.
13func NewMockXDGPaths(t interface {
14 mock.TestingT
15 Cleanup(func())
16}) *MockXDGPaths {
17 mock := &MockXDGPaths{}
18 mock.Mock.Test(t)
19
20 t.Cleanup(func() { mock.AssertExpectations(t) })
21
22 return mock
23}
24
25// MockXDGPaths is an autogenerated mock type for the XDGPaths type
26type MockXDGPaths struct {
27 mock.Mock
28}
29
30type MockXDGPaths_Expecter struct {
31 mock *mock.Mock
32}
33
34func (_m *MockXDGPaths) EXPECT() *MockXDGPaths_Expecter {
35 return &MockXDGPaths_Expecter{mock: &_m.Mock}
36}
37
38// CacheDir provides a mock function for the type MockXDGPaths
39func (_mock *MockXDGPaths) CacheDir() (string, error) {
40 ret := _mock.Called()
41
42 if len(ret) == 0 {
43 panic("no return value specified for CacheDir")
44 }
45
46 var r0 string
47 var r1 error
48 if returnFunc, ok := ret.Get(0).(func() (string, error)); ok {
49 return returnFunc()
50 }
51 if returnFunc, ok := ret.Get(0).(func() string); ok {
52 r0 = returnFunc()
53 } else {
54 r0 = ret.Get(0).(string)
55 }
56 if returnFunc, ok := ret.Get(1).(func() error); ok {
57 r1 = returnFunc()
58 } else {
59 r1 = ret.Error(1)
60 }
61 return r0, r1
62}
63
64// MockXDGPaths_CacheDir_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CacheDir'
65type MockXDGPaths_CacheDir_Call struct {
66 *mock.Call
67}
68
69// CacheDir is a helper method to define mock.On call
70func (_e *MockXDGPaths_Expecter) CacheDir() *MockXDGPaths_CacheDir_Call {
71 return &MockXDGPaths_CacheDir_Call{Call: _e.mock.On("CacheDir")}
72}
73
74func (_c *MockXDGPaths_CacheDir_Call) Run(run func()) *MockXDGPaths_CacheDir_Call {
75 _c.Call.Run(func(args mock.Arguments) {
76 run()
77 })
78 return _c
79}
80
81func (_c *MockXDGPaths_CacheDir_Call) Return(s string, err error) *MockXDGPaths_CacheDir_Call {
82 _c.Call.Return(s, err)
83 return _c
84}
85
86func (_c *MockXDGPaths_CacheDir_Call) RunAndReturn(run func() (string, error)) *MockXDGPaths_CacheDir_Call {
87 _c.Call.Return(run)
88 return _c
89}
90
91// ConfigDir provides a mock function for the type MockXDGPaths
92func (_mock *MockXDGPaths) ConfigDir() (string, error) {
93 ret := _mock.Called()
94
95 if len(ret) == 0 {
96 panic("no return value specified for ConfigDir")
97 }
98
99 var r0 string
100 var r1 error
101 if returnFunc, ok := ret.Get(0).(func() (string, error)); ok {
102 return returnFunc()
103 }
104 if returnFunc, ok := ret.Get(0).(func() string); ok {
105 r0 = returnFunc()
106 } else {
107 r0 = ret.Get(0).(string)
108 }
109 if returnFunc, ok := ret.Get(1).(func() error); ok {
110 r1 = returnFunc()
111 } else {
112 r1 = ret.Error(1)
113 }
114 return r0, r1
115}
116
117// MockXDGPaths_ConfigDir_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ConfigDir'
118type MockXDGPaths_ConfigDir_Call struct {
119 *mock.Call
120}
121
122// ConfigDir is a helper method to define mock.On call
123func (_e *MockXDGPaths_Expecter) ConfigDir() *MockXDGPaths_ConfigDir_Call {
124 return &MockXDGPaths_ConfigDir_Call{Call: _e.mock.On("ConfigDir")}
125}
126
127func (_c *MockXDGPaths_ConfigDir_Call) Run(run func()) *MockXDGPaths_ConfigDir_Call {
128 _c.Call.Run(func(args mock.Arguments) {
129 run()
130 })
131 return _c
132}
133
134func (_c *MockXDGPaths_ConfigDir_Call) Return(s string, err error) *MockXDGPaths_ConfigDir_Call {
135 _c.Call.Return(s, err)
136 return _c
137}
138
139func (_c *MockXDGPaths_ConfigDir_Call) RunAndReturn(run func() (string, error)) *MockXDGPaths_ConfigDir_Call {
140 _c.Call.Return(run)
141 return _c
142}
143
144// DataDir provides a mock function for the type MockXDGPaths
145func (_mock *MockXDGPaths) DataDir() (string, error) {
146 ret := _mock.Called()
147
148 if len(ret) == 0 {
149 panic("no return value specified for DataDir")
150 }
151
152 var r0 string
153 var r1 error
154 if returnFunc, ok := ret.Get(0).(func() (string, error)); ok {
155 return returnFunc()
156 }
157 if returnFunc, ok := ret.Get(0).(func() string); ok {
158 r0 = returnFunc()
159 } else {
160 r0 = ret.Get(0).(string)
161 }
162 if returnFunc, ok := ret.Get(1).(func() error); ok {
163 r1 = returnFunc()
164 } else {
165 r1 = ret.Error(1)
166 }
167 return r0, r1
168}
169
170// MockXDGPaths_DataDir_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DataDir'
171type MockXDGPaths_DataDir_Call struct {
172 *mock.Call
173}
174
175// DataDir is a helper method to define mock.On call
176func (_e *MockXDGPaths_Expecter) DataDir() *MockXDGPaths_DataDir_Call {
177 return &MockXDGPaths_DataDir_Call{Call: _e.mock.On("DataDir")}
178}
179
180func (_c *MockXDGPaths_DataDir_Call) Run(run func()) *MockXDGPaths_DataDir_Call {
181 _c.Call.Run(func(args mock.Arguments) {
182 run()
183 })
184 return _c
185}
186
187func (_c *MockXDGPaths_DataDir_Call) Return(s string, err error) *MockXDGPaths_DataDir_Call {
188 _c.Call.Return(s, err)
189 return _c
190}
191
192func (_c *MockXDGPaths_DataDir_Call) RunAndReturn(run func() (string, error)) *MockXDGPaths_DataDir_Call {
193 _c.Call.Return(run)
194 return _c
195}
196
197// DownloadDir provides a mock function for the type MockXDGPaths
198func (_mock *MockXDGPaths) DownloadDir() (string, error) {
199 ret := _mock.Called()
200
201 if len(ret) == 0 {
202 panic("no return value specified for DownloadDir")
203 }
204
205 var r0 string
206 var r1 error
207 if returnFunc, ok := ret.Get(0).(func() (string, error)); ok {
208 return returnFunc()
209 }
210 if returnFunc, ok := ret.Get(0).(func() string); ok {
211 r0 = returnFunc()
212 } else {
213 r0 = ret.Get(0).(string)
214 }
215 if returnFunc, ok := ret.Get(1).(func() error); ok {
216 r1 = returnFunc()
217 } else {
218 r1 = ret.Error(1)
219 }
220 return r0, r1
221}
222
223// MockXDGPaths_DownloadDir_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DownloadDir'
224type MockXDGPaths_DownloadDir_Call struct {
225 *mock.Call
226}
227
228// DownloadDir is a helper method to define mock.On call
229func (_e *MockXDGPaths_Expecter) DownloadDir() *MockXDGPaths_DownloadDir_Call {
230 return &MockXDGPaths_DownloadDir_Call{Call: _e.mock.On("DownloadDir")}
231}
232
233func (_c *MockXDGPaths_DownloadDir_Call) Run(run func()) *MockXDGPaths_DownloadDir_Call {
234 _c.Call.Run(func(args mock.Arguments) {
235 run()
236 })
237 return _c
238}
239
240func (_c *MockXDGPaths_DownloadDir_Call) Return(s string, err error) *MockXDGPaths_DownloadDir_Call {
241 _c.Call.Return(s, err)
242 return _c
243}
244
245func (_c *MockXDGPaths_DownloadDir_Call) RunAndReturn(run func() (string, error)) *MockXDGPaths_DownloadDir_Call {
246 _c.Call.Return(run)
247 return _c
248}
249
250// FilterCacheDir provides a mock function for the type MockXDGPaths
251func (_mock *MockXDGPaths) FilterCacheDir() (string, error) {
252 ret := _mock.Called()
253
254 if len(ret) == 0 {
255 panic("no return value specified for FilterCacheDir")
256 }
257
258 var r0 string
259 var r1 error
260 if returnFunc, ok := ret.Get(0).(func() (string, error)); ok {
261 return returnFunc()
262 }
263 if returnFunc, ok := ret.Get(0).(func() string); ok {
264 r0 = returnFunc()
265 } else {
266 r0 = ret.Get(0).(string)
267 }
268 if returnFunc, ok := ret.Get(1).(func() error); ok {
269 r1 = returnFunc()
270 } else {
271 r1 = ret.Error(1)
272 }
273 return r0, r1
274}
275
276// MockXDGPaths_FilterCacheDir_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FilterCacheDir'
277type MockXDGPaths_FilterCacheDir_Call struct {
278 *mock.Call
279}
280
281// FilterCacheDir is a helper method to define mock.On call
282func (_e *MockXDGPaths_Expecter) FilterCacheDir() *MockXDGPaths_FilterCacheDir_Call {
283 return &MockXDGPaths_FilterCacheDir_Call{Call: _e.mock.On("FilterCacheDir")}
284}
285
286func (_c *MockXDGPaths_FilterCacheDir_Call) Run(run func()) *MockXDGPaths_FilterCacheDir_Call {
287 _c.Call.Run(func(args mock.Arguments) {
288 run()
289 })
290 return _c
291}
292
293func (_c *MockXDGPaths_FilterCacheDir_Call) Return(s string, err error) *MockXDGPaths_FilterCacheDir_Call {
294 _c.Call.Return(s, err)
295 return _c
296}
297
298func (_c *MockXDGPaths_FilterCacheDir_Call) RunAndReturn(run func() (string, error)) *MockXDGPaths_FilterCacheDir_Call {
299 _c.Call.Return(run)
300 return _c
301}
302
303// FilterJSONDir provides a mock function for the type MockXDGPaths
304func (_mock *MockXDGPaths) FilterJSONDir() (string, error) {
305 ret := _mock.Called()
306
307 if len(ret) == 0 {
308 panic("no return value specified for FilterJSONDir")
309 }
310
311 var r0 string
312 var r1 error
313 if returnFunc, ok := ret.Get(0).(func() (string, error)); ok {
314 return returnFunc()
315 }
316 if returnFunc, ok := ret.Get(0).(func() string); ok {
317 r0 = returnFunc()
318 } else {
319 r0 = ret.Get(0).(string)
320 }
321 if returnFunc, ok := ret.Get(1).(func() error); ok {
322 r1 = returnFunc()
323 } else {
324 r1 = ret.Error(1)
325 }
326 return r0, r1
327}
328
329// MockXDGPaths_FilterJSONDir_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FilterJSONDir'
330type MockXDGPaths_FilterJSONDir_Call struct {
331 *mock.Call
332}
333
334// FilterJSONDir is a helper method to define mock.On call
335func (_e *MockXDGPaths_Expecter) FilterJSONDir() *MockXDGPaths_FilterJSONDir_Call {
336 return &MockXDGPaths_FilterJSONDir_Call{Call: _e.mock.On("FilterJSONDir")}
337}
338
339func (_c *MockXDGPaths_FilterJSONDir_Call) Run(run func()) *MockXDGPaths_FilterJSONDir_Call {
340 _c.Call.Run(func(args mock.Arguments) {
341 run()
342 })
343 return _c
344}
345
346func (_c *MockXDGPaths_FilterJSONDir_Call) Return(s string, err error) *MockXDGPaths_FilterJSONDir_Call {
347 _c.Call.Return(s, err)
348 return _c
349}
350
351func (_c *MockXDGPaths_FilterJSONDir_Call) RunAndReturn(run func() (string, error)) *MockXDGPaths_FilterJSONDir_Call {
352 _c.Call.Return(run)
353 return _c
354}
355
356// FilterStoreDir provides a mock function for the type MockXDGPaths
357func (_mock *MockXDGPaths) FilterStoreDir() (string, error) {
358 ret := _mock.Called()
359
360 if len(ret) == 0 {
361 panic("no return value specified for FilterStoreDir")
362 }
363
364 var r0 string
365 var r1 error
366 if returnFunc, ok := ret.Get(0).(func() (string, error)); ok {
367 return returnFunc()
368 }
369 if returnFunc, ok := ret.Get(0).(func() string); ok {
370 r0 = returnFunc()
371 } else {
372 r0 = ret.Get(0).(string)
373 }
374 if returnFunc, ok := ret.Get(1).(func() error); ok {
375 r1 = returnFunc()
376 } else {
377 r1 = ret.Error(1)
378 }
379 return r0, r1
380}
381
382// MockXDGPaths_FilterStoreDir_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FilterStoreDir'
383type MockXDGPaths_FilterStoreDir_Call struct {
384 *mock.Call
385}
386
387// FilterStoreDir is a helper method to define mock.On call
388func (_e *MockXDGPaths_Expecter) FilterStoreDir() *MockXDGPaths_FilterStoreDir_Call {
389 return &MockXDGPaths_FilterStoreDir_Call{Call: _e.mock.On("FilterStoreDir")}
390}
391
392func (_c *MockXDGPaths_FilterStoreDir_Call) Run(run func()) *MockXDGPaths_FilterStoreDir_Call {
393 _c.Call.Run(func(args mock.Arguments) {
394 run()
395 })
396 return _c
397}
398
399func (_c *MockXDGPaths_FilterStoreDir_Call) Return(s string, err error) *MockXDGPaths_FilterStoreDir_Call {
400 _c.Call.Return(s, err)
401 return _c
402}
403
404func (_c *MockXDGPaths_FilterStoreDir_Call) RunAndReturn(run func() (string, error)) *MockXDGPaths_FilterStoreDir_Call {
405 _c.Call.Return(run)
406 return _c
407}
408
409// ManDir provides a mock function for the type MockXDGPaths
410func (_mock *MockXDGPaths) ManDir() (string, error) {
411 ret := _mock.Called()
412
413 if len(ret) == 0 {
414 panic("no return value specified for ManDir")
415 }
416
417 var r0 string
418 var r1 error
419 if returnFunc, ok := ret.Get(0).(func() (string, error)); ok {
420 return returnFunc()
421 }
422 if returnFunc, ok := ret.Get(0).(func() string); ok {
423 r0 = returnFunc()
424 } else {
425 r0 = ret.Get(0).(string)
426 }
427 if returnFunc, ok := ret.Get(1).(func() error); ok {
428 r1 = returnFunc()
429 } else {
430 r1 = ret.Error(1)
431 }
432 return r0, r1
433}
434
435// MockXDGPaths_ManDir_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ManDir'
436type MockXDGPaths_ManDir_Call struct {
437 *mock.Call
438}
439
440// ManDir is a helper method to define mock.On call
441func (_e *MockXDGPaths_Expecter) ManDir() *MockXDGPaths_ManDir_Call {
442 return &MockXDGPaths_ManDir_Call{Call: _e.mock.On("ManDir")}
443}
444
445func (_c *MockXDGPaths_ManDir_Call) Run(run func()) *MockXDGPaths_ManDir_Call {
446 _c.Call.Run(func(args mock.Arguments) {
447 run()
448 })
449 return _c
450}
451
452func (_c *MockXDGPaths_ManDir_Call) Return(s string, err error) *MockXDGPaths_ManDir_Call {
453 _c.Call.Return(s, err)
454 return _c
455}
456
457func (_c *MockXDGPaths_ManDir_Call) RunAndReturn(run func() (string, error)) *MockXDGPaths_ManDir_Call {
458 _c.Call.Return(run)
459 return _c
460}
461
462// RuntimeDir provides a mock function for the type MockXDGPaths
463func (_mock *MockXDGPaths) RuntimeDir() (string, error) {
464 ret := _mock.Called()
465
466 if len(ret) == 0 {
467 panic("no return value specified for RuntimeDir")
468 }
469
470 var r0 string
471 var r1 error
472 if returnFunc, ok := ret.Get(0).(func() (string, error)); ok {
473 return returnFunc()
474 }
475 if returnFunc, ok := ret.Get(0).(func() string); ok {
476 r0 = returnFunc()
477 } else {
478 r0 = ret.Get(0).(string)
479 }
480 if returnFunc, ok := ret.Get(1).(func() error); ok {
481 r1 = returnFunc()
482 } else {
483 r1 = ret.Error(1)
484 }
485 return r0, r1
486}
487
488// MockXDGPaths_RuntimeDir_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RuntimeDir'
489type MockXDGPaths_RuntimeDir_Call struct {
490 *mock.Call
491}
492
493// RuntimeDir is a helper method to define mock.On call
494func (_e *MockXDGPaths_Expecter) RuntimeDir() *MockXDGPaths_RuntimeDir_Call {
495 return &MockXDGPaths_RuntimeDir_Call{Call: _e.mock.On("RuntimeDir")}
496}
497
498func (_c *MockXDGPaths_RuntimeDir_Call) Run(run func()) *MockXDGPaths_RuntimeDir_Call {
499 _c.Call.Run(func(args mock.Arguments) {
500 run()
501 })
502 return _c
503}
504
505func (_c *MockXDGPaths_RuntimeDir_Call) Return(s string, err error) *MockXDGPaths_RuntimeDir_Call {
506 _c.Call.Return(s, err)
507 return _c
508}
509
510func (_c *MockXDGPaths_RuntimeDir_Call) RunAndReturn(run func() (string, error)) *MockXDGPaths_RuntimeDir_Call {
511 _c.Call.Return(run)
512 return _c
513}
514
515// StateDir provides a mock function for the type MockXDGPaths
516func (_mock *MockXDGPaths) StateDir() (string, error) {
517 ret := _mock.Called()
518
519 if len(ret) == 0 {
520 panic("no return value specified for StateDir")
521 }
522
523 var r0 string
524 var r1 error
525 if returnFunc, ok := ret.Get(0).(func() (string, error)); ok {
526 return returnFunc()
527 }
528 if returnFunc, ok := ret.Get(0).(func() string); ok {
529 r0 = returnFunc()
530 } else {
531 r0 = ret.Get(0).(string)
532 }
533 if returnFunc, ok := ret.Get(1).(func() error); ok {
534 r1 = returnFunc()
535 } else {
536 r1 = ret.Error(1)
537 }
538 return r0, r1
539}
540
541// MockXDGPaths_StateDir_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StateDir'
542type MockXDGPaths_StateDir_Call struct {
543 *mock.Call
544}
545
546// StateDir is a helper method to define mock.On call
547func (_e *MockXDGPaths_Expecter) StateDir() *MockXDGPaths_StateDir_Call {
548 return &MockXDGPaths_StateDir_Call{Call: _e.mock.On("StateDir")}
549}
550
551func (_c *MockXDGPaths_StateDir_Call) Run(run func()) *MockXDGPaths_StateDir_Call {
552 _c.Call.Run(func(args mock.Arguments) {
553 run()
554 })
555 return _c
556}
557
558func (_c *MockXDGPaths_StateDir_Call) Return(s string, err error) *MockXDGPaths_StateDir_Call {
559 _c.Call.Return(s, err)
560 return _c
561}
562
563func (_c *MockXDGPaths_StateDir_Call) RunAndReturn(run func() (string, error)) *MockXDGPaths_StateDir_Call {
564 _c.Call.Return(run)
565 return _c
566}