mirror of
https://github.com/AvengeMedia/DankMaterialShell.git
synced 2025-12-05 21:15:38 -05:00
406 lines
14 KiB
Go
406 lines
14 KiB
Go
// Code generated by mockery v2.53.5. DO NOT EDIT.
|
|
|
|
package mocks_cups
|
|
|
|
import (
|
|
io "io"
|
|
|
|
ipp "github.com/AvengeMedia/DankMaterialShell/core/pkg/ipp"
|
|
mock "github.com/stretchr/testify/mock"
|
|
)
|
|
|
|
// MockCUPSClientInterface is an autogenerated mock type for the CUPSClientInterface type
|
|
type MockCUPSClientInterface struct {
|
|
mock.Mock
|
|
}
|
|
|
|
type MockCUPSClientInterface_Expecter struct {
|
|
mock *mock.Mock
|
|
}
|
|
|
|
func (_m *MockCUPSClientInterface) EXPECT() *MockCUPSClientInterface_Expecter {
|
|
return &MockCUPSClientInterface_Expecter{mock: &_m.Mock}
|
|
}
|
|
|
|
// CancelAllJob provides a mock function with given fields: printer, purge
|
|
func (_m *MockCUPSClientInterface) CancelAllJob(printer string, purge bool) error {
|
|
ret := _m.Called(printer, purge)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for CancelAllJob")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(string, bool) error); ok {
|
|
r0 = rf(printer, purge)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockCUPSClientInterface_CancelAllJob_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CancelAllJob'
|
|
type MockCUPSClientInterface_CancelAllJob_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// CancelAllJob is a helper method to define mock.On call
|
|
// - printer string
|
|
// - purge bool
|
|
func (_e *MockCUPSClientInterface_Expecter) CancelAllJob(printer interface{}, purge interface{}) *MockCUPSClientInterface_CancelAllJob_Call {
|
|
return &MockCUPSClientInterface_CancelAllJob_Call{Call: _e.mock.On("CancelAllJob", printer, purge)}
|
|
}
|
|
|
|
func (_c *MockCUPSClientInterface_CancelAllJob_Call) Run(run func(printer string, purge bool)) *MockCUPSClientInterface_CancelAllJob_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(string), args[1].(bool))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockCUPSClientInterface_CancelAllJob_Call) Return(_a0 error) *MockCUPSClientInterface_CancelAllJob_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockCUPSClientInterface_CancelAllJob_Call) RunAndReturn(run func(string, bool) error) *MockCUPSClientInterface_CancelAllJob_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// CancelJob provides a mock function with given fields: jobID, purge
|
|
func (_m *MockCUPSClientInterface) CancelJob(jobID int, purge bool) error {
|
|
ret := _m.Called(jobID, purge)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for CancelJob")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(int, bool) error); ok {
|
|
r0 = rf(jobID, purge)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockCUPSClientInterface_CancelJob_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CancelJob'
|
|
type MockCUPSClientInterface_CancelJob_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// CancelJob is a helper method to define mock.On call
|
|
// - jobID int
|
|
// - purge bool
|
|
func (_e *MockCUPSClientInterface_Expecter) CancelJob(jobID interface{}, purge interface{}) *MockCUPSClientInterface_CancelJob_Call {
|
|
return &MockCUPSClientInterface_CancelJob_Call{Call: _e.mock.On("CancelJob", jobID, purge)}
|
|
}
|
|
|
|
func (_c *MockCUPSClientInterface_CancelJob_Call) Run(run func(jobID int, purge bool)) *MockCUPSClientInterface_CancelJob_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(int), args[1].(bool))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockCUPSClientInterface_CancelJob_Call) Return(_a0 error) *MockCUPSClientInterface_CancelJob_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockCUPSClientInterface_CancelJob_Call) RunAndReturn(run func(int, bool) error) *MockCUPSClientInterface_CancelJob_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetJobs provides a mock function with given fields: printer, class, whichJobs, myJobs, firstJobId, limit, attributes
|
|
func (_m *MockCUPSClientInterface) GetJobs(printer string, class string, whichJobs string, myJobs bool, firstJobId int, limit int, attributes []string) (map[int]ipp.Attributes, error) {
|
|
ret := _m.Called(printer, class, whichJobs, myJobs, firstJobId, limit, attributes)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetJobs")
|
|
}
|
|
|
|
var r0 map[int]ipp.Attributes
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(string, string, string, bool, int, int, []string) (map[int]ipp.Attributes, error)); ok {
|
|
return rf(printer, class, whichJobs, myJobs, firstJobId, limit, attributes)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(string, string, string, bool, int, int, []string) map[int]ipp.Attributes); ok {
|
|
r0 = rf(printer, class, whichJobs, myJobs, firstJobId, limit, attributes)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(map[int]ipp.Attributes)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(string, string, string, bool, int, int, []string) error); ok {
|
|
r1 = rf(printer, class, whichJobs, myJobs, firstJobId, limit, attributes)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockCUPSClientInterface_GetJobs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetJobs'
|
|
type MockCUPSClientInterface_GetJobs_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetJobs is a helper method to define mock.On call
|
|
// - printer string
|
|
// - class string
|
|
// - whichJobs string
|
|
// - myJobs bool
|
|
// - firstJobId int
|
|
// - limit int
|
|
// - attributes []string
|
|
func (_e *MockCUPSClientInterface_Expecter) GetJobs(printer interface{}, class interface{}, whichJobs interface{}, myJobs interface{}, firstJobId interface{}, limit interface{}, attributes interface{}) *MockCUPSClientInterface_GetJobs_Call {
|
|
return &MockCUPSClientInterface_GetJobs_Call{Call: _e.mock.On("GetJobs", printer, class, whichJobs, myJobs, firstJobId, limit, attributes)}
|
|
}
|
|
|
|
func (_c *MockCUPSClientInterface_GetJobs_Call) Run(run func(printer string, class string, whichJobs string, myJobs bool, firstJobId int, limit int, attributes []string)) *MockCUPSClientInterface_GetJobs_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(string), args[1].(string), args[2].(string), args[3].(bool), args[4].(int), args[5].(int), args[6].([]string))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockCUPSClientInterface_GetJobs_Call) Return(_a0 map[int]ipp.Attributes, _a1 error) *MockCUPSClientInterface_GetJobs_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockCUPSClientInterface_GetJobs_Call) RunAndReturn(run func(string, string, string, bool, int, int, []string) (map[int]ipp.Attributes, error)) *MockCUPSClientInterface_GetJobs_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetPrinters provides a mock function with given fields: attributes
|
|
func (_m *MockCUPSClientInterface) GetPrinters(attributes []string) (map[string]ipp.Attributes, error) {
|
|
ret := _m.Called(attributes)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetPrinters")
|
|
}
|
|
|
|
var r0 map[string]ipp.Attributes
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func([]string) (map[string]ipp.Attributes, error)); ok {
|
|
return rf(attributes)
|
|
}
|
|
if rf, ok := ret.Get(0).(func([]string) map[string]ipp.Attributes); ok {
|
|
r0 = rf(attributes)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(map[string]ipp.Attributes)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func([]string) error); ok {
|
|
r1 = rf(attributes)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockCUPSClientInterface_GetPrinters_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPrinters'
|
|
type MockCUPSClientInterface_GetPrinters_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetPrinters is a helper method to define mock.On call
|
|
// - attributes []string
|
|
func (_e *MockCUPSClientInterface_Expecter) GetPrinters(attributes interface{}) *MockCUPSClientInterface_GetPrinters_Call {
|
|
return &MockCUPSClientInterface_GetPrinters_Call{Call: _e.mock.On("GetPrinters", attributes)}
|
|
}
|
|
|
|
func (_c *MockCUPSClientInterface_GetPrinters_Call) Run(run func(attributes []string)) *MockCUPSClientInterface_GetPrinters_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].([]string))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockCUPSClientInterface_GetPrinters_Call) Return(_a0 map[string]ipp.Attributes, _a1 error) *MockCUPSClientInterface_GetPrinters_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockCUPSClientInterface_GetPrinters_Call) RunAndReturn(run func([]string) (map[string]ipp.Attributes, error)) *MockCUPSClientInterface_GetPrinters_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// PausePrinter provides a mock function with given fields: printer
|
|
func (_m *MockCUPSClientInterface) PausePrinter(printer string) error {
|
|
ret := _m.Called(printer)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for PausePrinter")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(string) error); ok {
|
|
r0 = rf(printer)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockCUPSClientInterface_PausePrinter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PausePrinter'
|
|
type MockCUPSClientInterface_PausePrinter_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// PausePrinter is a helper method to define mock.On call
|
|
// - printer string
|
|
func (_e *MockCUPSClientInterface_Expecter) PausePrinter(printer interface{}) *MockCUPSClientInterface_PausePrinter_Call {
|
|
return &MockCUPSClientInterface_PausePrinter_Call{Call: _e.mock.On("PausePrinter", printer)}
|
|
}
|
|
|
|
func (_c *MockCUPSClientInterface_PausePrinter_Call) Run(run func(printer string)) *MockCUPSClientInterface_PausePrinter_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(string))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockCUPSClientInterface_PausePrinter_Call) Return(_a0 error) *MockCUPSClientInterface_PausePrinter_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockCUPSClientInterface_PausePrinter_Call) RunAndReturn(run func(string) error) *MockCUPSClientInterface_PausePrinter_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// ResumePrinter provides a mock function with given fields: printer
|
|
func (_m *MockCUPSClientInterface) ResumePrinter(printer string) error {
|
|
ret := _m.Called(printer)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ResumePrinter")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(string) error); ok {
|
|
r0 = rf(printer)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockCUPSClientInterface_ResumePrinter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResumePrinter'
|
|
type MockCUPSClientInterface_ResumePrinter_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ResumePrinter is a helper method to define mock.On call
|
|
// - printer string
|
|
func (_e *MockCUPSClientInterface_Expecter) ResumePrinter(printer interface{}) *MockCUPSClientInterface_ResumePrinter_Call {
|
|
return &MockCUPSClientInterface_ResumePrinter_Call{Call: _e.mock.On("ResumePrinter", printer)}
|
|
}
|
|
|
|
func (_c *MockCUPSClientInterface_ResumePrinter_Call) Run(run func(printer string)) *MockCUPSClientInterface_ResumePrinter_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(string))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockCUPSClientInterface_ResumePrinter_Call) Return(_a0 error) *MockCUPSClientInterface_ResumePrinter_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockCUPSClientInterface_ResumePrinter_Call) RunAndReturn(run func(string) error) *MockCUPSClientInterface_ResumePrinter_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// SendRequest provides a mock function with given fields: url, req, additionalResponseData
|
|
func (_m *MockCUPSClientInterface) SendRequest(url string, req *ipp.Request, additionalResponseData io.Writer) (*ipp.Response, error) {
|
|
ret := _m.Called(url, req, additionalResponseData)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for SendRequest")
|
|
}
|
|
|
|
var r0 *ipp.Response
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(string, *ipp.Request, io.Writer) (*ipp.Response, error)); ok {
|
|
return rf(url, req, additionalResponseData)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(string, *ipp.Request, io.Writer) *ipp.Response); ok {
|
|
r0 = rf(url, req, additionalResponseData)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*ipp.Response)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(string, *ipp.Request, io.Writer) error); ok {
|
|
r1 = rf(url, req, additionalResponseData)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockCUPSClientInterface_SendRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendRequest'
|
|
type MockCUPSClientInterface_SendRequest_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// SendRequest is a helper method to define mock.On call
|
|
// - url string
|
|
// - req *ipp.Request
|
|
// - additionalResponseData io.Writer
|
|
func (_e *MockCUPSClientInterface_Expecter) SendRequest(url interface{}, req interface{}, additionalResponseData interface{}) *MockCUPSClientInterface_SendRequest_Call {
|
|
return &MockCUPSClientInterface_SendRequest_Call{Call: _e.mock.On("SendRequest", url, req, additionalResponseData)}
|
|
}
|
|
|
|
func (_c *MockCUPSClientInterface_SendRequest_Call) Run(run func(url string, req *ipp.Request, additionalResponseData io.Writer)) *MockCUPSClientInterface_SendRequest_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(string), args[1].(*ipp.Request), args[2].(io.Writer))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockCUPSClientInterface_SendRequest_Call) Return(_a0 *ipp.Response, _a1 error) *MockCUPSClientInterface_SendRequest_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockCUPSClientInterface_SendRequest_Call) RunAndReturn(run func(string, *ipp.Request, io.Writer) (*ipp.Response, error)) *MockCUPSClientInterface_SendRequest_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// NewMockCUPSClientInterface creates a new instance of MockCUPSClientInterface. 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 NewMockCUPSClientInterface(t interface {
|
|
mock.TestingT
|
|
Cleanup(func())
|
|
}) *MockCUPSClientInterface {
|
|
mock := &MockCUPSClientInterface{}
|
|
mock.Mock.Test(t)
|
|
|
|
t.Cleanup(func() { mock.AssertExpectations(t) })
|
|
|
|
return mock
|
|
}
|