From 70ca3fef77ee8bdc6e3ac28589a6fa08c024cc69 Mon Sep 17 00:00:00 2001 From: AlexanderCurl Date: Sat, 18 Apr 2026 17:46:06 +0100 Subject: Replaced file structures for themes in the correct format --- .../mocks/cups/mock_CUPSClientInterface.go | 1246 ++++++++++++++++++++ 1 file changed, 1246 insertions(+) create mode 100644 raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/cups/mock_CUPSClientInterface.go (limited to 'raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/cups') diff --git a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/cups/mock_CUPSClientInterface.go b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/cups/mock_CUPSClientInterface.go new file mode 100644 index 0000000..3c98074 --- /dev/null +++ b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/cups/mock_CUPSClientInterface.go @@ -0,0 +1,1246 @@ +// 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} +} + +// AcceptJobs provides a mock function with given fields: printer +func (_m *MockCUPSClientInterface) AcceptJobs(printer string) error { + ret := _m.Called(printer) + + if len(ret) == 0 { + panic("no return value specified for AcceptJobs") + } + + var r0 error + if rf, ok := ret.Get(0).(func(string) error); ok { + r0 = rf(printer) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockCUPSClientInterface_AcceptJobs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AcceptJobs' +type MockCUPSClientInterface_AcceptJobs_Call struct { + *mock.Call +} + +// AcceptJobs is a helper method to define mock.On call +// - printer string +func (_e *MockCUPSClientInterface_Expecter) AcceptJobs(printer interface{}) *MockCUPSClientInterface_AcceptJobs_Call { + return &MockCUPSClientInterface_AcceptJobs_Call{Call: _e.mock.On("AcceptJobs", printer)} +} + +func (_c *MockCUPSClientInterface_AcceptJobs_Call) Run(run func(printer string)) *MockCUPSClientInterface_AcceptJobs_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *MockCUPSClientInterface_AcceptJobs_Call) Return(_a0 error) *MockCUPSClientInterface_AcceptJobs_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCUPSClientInterface_AcceptJobs_Call) RunAndReturn(run func(string) error) *MockCUPSClientInterface_AcceptJobs_Call { + _c.Call.Return(run) + return _c +} + +// AddPrinterToClass provides a mock function with given fields: class, printer +func (_m *MockCUPSClientInterface) AddPrinterToClass(class string, printer string) error { + ret := _m.Called(class, printer) + + if len(ret) == 0 { + panic("no return value specified for AddPrinterToClass") + } + + var r0 error + if rf, ok := ret.Get(0).(func(string, string) error); ok { + r0 = rf(class, printer) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockCUPSClientInterface_AddPrinterToClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddPrinterToClass' +type MockCUPSClientInterface_AddPrinterToClass_Call struct { + *mock.Call +} + +// AddPrinterToClass is a helper method to define mock.On call +// - class string +// - printer string +func (_e *MockCUPSClientInterface_Expecter) AddPrinterToClass(class interface{}, printer interface{}) *MockCUPSClientInterface_AddPrinterToClass_Call { + return &MockCUPSClientInterface_AddPrinterToClass_Call{Call: _e.mock.On("AddPrinterToClass", class, printer)} +} + +func (_c *MockCUPSClientInterface_AddPrinterToClass_Call) Run(run func(class string, printer string)) *MockCUPSClientInterface_AddPrinterToClass_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string)) + }) + return _c +} + +func (_c *MockCUPSClientInterface_AddPrinterToClass_Call) Return(_a0 error) *MockCUPSClientInterface_AddPrinterToClass_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCUPSClientInterface_AddPrinterToClass_Call) RunAndReturn(run func(string, string) error) *MockCUPSClientInterface_AddPrinterToClass_Call { + _c.Call.Return(run) + return _c +} + +// 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 +} + +// CreatePrinter provides a mock function with given fields: name, deviceURI, ppd, shared, errorPolicy, information, location +func (_m *MockCUPSClientInterface) CreatePrinter(name string, deviceURI string, ppd string, shared bool, errorPolicy string, information string, location string) error { + ret := _m.Called(name, deviceURI, ppd, shared, errorPolicy, information, location) + + if len(ret) == 0 { + panic("no return value specified for CreatePrinter") + } + + var r0 error + if rf, ok := ret.Get(0).(func(string, string, string, bool, string, string, string) error); ok { + r0 = rf(name, deviceURI, ppd, shared, errorPolicy, information, location) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockCUPSClientInterface_CreatePrinter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreatePrinter' +type MockCUPSClientInterface_CreatePrinter_Call struct { + *mock.Call +} + +// CreatePrinter is a helper method to define mock.On call +// - name string +// - deviceURI string +// - ppd string +// - shared bool +// - errorPolicy string +// - information string +// - location string +func (_e *MockCUPSClientInterface_Expecter) CreatePrinter(name interface{}, deviceURI interface{}, ppd interface{}, shared interface{}, errorPolicy interface{}, information interface{}, location interface{}) *MockCUPSClientInterface_CreatePrinter_Call { + return &MockCUPSClientInterface_CreatePrinter_Call{Call: _e.mock.On("CreatePrinter", name, deviceURI, ppd, shared, errorPolicy, information, location)} +} + +func (_c *MockCUPSClientInterface_CreatePrinter_Call) Run(run func(name string, deviceURI string, ppd string, shared bool, errorPolicy string, information string, location string)) *MockCUPSClientInterface_CreatePrinter_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string), args[3].(bool), args[4].(string), args[5].(string), args[6].(string)) + }) + return _c +} + +func (_c *MockCUPSClientInterface_CreatePrinter_Call) Return(_a0 error) *MockCUPSClientInterface_CreatePrinter_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCUPSClientInterface_CreatePrinter_Call) RunAndReturn(run func(string, string, string, bool, string, string, string) error) *MockCUPSClientInterface_CreatePrinter_Call { + _c.Call.Return(run) + return _c +} + +// DeleteClass provides a mock function with given fields: class +func (_m *MockCUPSClientInterface) DeleteClass(class string) error { + ret := _m.Called(class) + + if len(ret) == 0 { + panic("no return value specified for DeleteClass") + } + + var r0 error + if rf, ok := ret.Get(0).(func(string) error); ok { + r0 = rf(class) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockCUPSClientInterface_DeleteClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteClass' +type MockCUPSClientInterface_DeleteClass_Call struct { + *mock.Call +} + +// DeleteClass is a helper method to define mock.On call +// - class string +func (_e *MockCUPSClientInterface_Expecter) DeleteClass(class interface{}) *MockCUPSClientInterface_DeleteClass_Call { + return &MockCUPSClientInterface_DeleteClass_Call{Call: _e.mock.On("DeleteClass", class)} +} + +func (_c *MockCUPSClientInterface_DeleteClass_Call) Run(run func(class string)) *MockCUPSClientInterface_DeleteClass_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *MockCUPSClientInterface_DeleteClass_Call) Return(_a0 error) *MockCUPSClientInterface_DeleteClass_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCUPSClientInterface_DeleteClass_Call) RunAndReturn(run func(string) error) *MockCUPSClientInterface_DeleteClass_Call { + _c.Call.Return(run) + return _c +} + +// DeletePrinter provides a mock function with given fields: printer +func (_m *MockCUPSClientInterface) DeletePrinter(printer string) error { + ret := _m.Called(printer) + + if len(ret) == 0 { + panic("no return value specified for DeletePrinter") + } + + var r0 error + if rf, ok := ret.Get(0).(func(string) error); ok { + r0 = rf(printer) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockCUPSClientInterface_DeletePrinter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeletePrinter' +type MockCUPSClientInterface_DeletePrinter_Call struct { + *mock.Call +} + +// DeletePrinter is a helper method to define mock.On call +// - printer string +func (_e *MockCUPSClientInterface_Expecter) DeletePrinter(printer interface{}) *MockCUPSClientInterface_DeletePrinter_Call { + return &MockCUPSClientInterface_DeletePrinter_Call{Call: _e.mock.On("DeletePrinter", printer)} +} + +func (_c *MockCUPSClientInterface_DeletePrinter_Call) Run(run func(printer string)) *MockCUPSClientInterface_DeletePrinter_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *MockCUPSClientInterface_DeletePrinter_Call) Return(_a0 error) *MockCUPSClientInterface_DeletePrinter_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCUPSClientInterface_DeletePrinter_Call) RunAndReturn(run func(string) error) *MockCUPSClientInterface_DeletePrinter_Call { + _c.Call.Return(run) + return _c +} + +// DeletePrinterFromClass provides a mock function with given fields: class, printer +func (_m *MockCUPSClientInterface) DeletePrinterFromClass(class string, printer string) error { + ret := _m.Called(class, printer) + + if len(ret) == 0 { + panic("no return value specified for DeletePrinterFromClass") + } + + var r0 error + if rf, ok := ret.Get(0).(func(string, string) error); ok { + r0 = rf(class, printer) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockCUPSClientInterface_DeletePrinterFromClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeletePrinterFromClass' +type MockCUPSClientInterface_DeletePrinterFromClass_Call struct { + *mock.Call +} + +// DeletePrinterFromClass is a helper method to define mock.On call +// - class string +// - printer string +func (_e *MockCUPSClientInterface_Expecter) DeletePrinterFromClass(class interface{}, printer interface{}) *MockCUPSClientInterface_DeletePrinterFromClass_Call { + return &MockCUPSClientInterface_DeletePrinterFromClass_Call{Call: _e.mock.On("DeletePrinterFromClass", class, printer)} +} + +func (_c *MockCUPSClientInterface_DeletePrinterFromClass_Call) Run(run func(class string, printer string)) *MockCUPSClientInterface_DeletePrinterFromClass_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string)) + }) + return _c +} + +func (_c *MockCUPSClientInterface_DeletePrinterFromClass_Call) Return(_a0 error) *MockCUPSClientInterface_DeletePrinterFromClass_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCUPSClientInterface_DeletePrinterFromClass_Call) RunAndReturn(run func(string, string) error) *MockCUPSClientInterface_DeletePrinterFromClass_Call { + _c.Call.Return(run) + return _c +} + +// GetClasses provides a mock function with given fields: attributes +func (_m *MockCUPSClientInterface) GetClasses(attributes []string) (map[string]ipp.Attributes, error) { + ret := _m.Called(attributes) + + if len(ret) == 0 { + panic("no return value specified for GetClasses") + } + + 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_GetClasses_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetClasses' +type MockCUPSClientInterface_GetClasses_Call struct { + *mock.Call +} + +// GetClasses is a helper method to define mock.On call +// - attributes []string +func (_e *MockCUPSClientInterface_Expecter) GetClasses(attributes interface{}) *MockCUPSClientInterface_GetClasses_Call { + return &MockCUPSClientInterface_GetClasses_Call{Call: _e.mock.On("GetClasses", attributes)} +} + +func (_c *MockCUPSClientInterface_GetClasses_Call) Run(run func(attributes []string)) *MockCUPSClientInterface_GetClasses_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].([]string)) + }) + return _c +} + +func (_c *MockCUPSClientInterface_GetClasses_Call) Return(_a0 map[string]ipp.Attributes, _a1 error) *MockCUPSClientInterface_GetClasses_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockCUPSClientInterface_GetClasses_Call) RunAndReturn(run func([]string) (map[string]ipp.Attributes, error)) *MockCUPSClientInterface_GetClasses_Call { + _c.Call.Return(run) + return _c +} + +// GetDevices provides a mock function with no fields +func (_m *MockCUPSClientInterface) GetDevices() (map[string]ipp.Attributes, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetDevices") + } + + var r0 map[string]ipp.Attributes + var r1 error + if rf, ok := ret.Get(0).(func() (map[string]ipp.Attributes, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() map[string]ipp.Attributes); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(map[string]ipp.Attributes) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockCUPSClientInterface_GetDevices_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDevices' +type MockCUPSClientInterface_GetDevices_Call struct { + *mock.Call +} + +// GetDevices is a helper method to define mock.On call +func (_e *MockCUPSClientInterface_Expecter) GetDevices() *MockCUPSClientInterface_GetDevices_Call { + return &MockCUPSClientInterface_GetDevices_Call{Call: _e.mock.On("GetDevices")} +} + +func (_c *MockCUPSClientInterface_GetDevices_Call) Run(run func()) *MockCUPSClientInterface_GetDevices_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockCUPSClientInterface_GetDevices_Call) Return(_a0 map[string]ipp.Attributes, _a1 error) *MockCUPSClientInterface_GetDevices_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockCUPSClientInterface_GetDevices_Call) RunAndReturn(run func() (map[string]ipp.Attributes, error)) *MockCUPSClientInterface_GetDevices_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 +} + +// GetPPDs provides a mock function with no fields +func (_m *MockCUPSClientInterface) GetPPDs() (map[string]ipp.Attributes, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPPDs") + } + + var r0 map[string]ipp.Attributes + var r1 error + if rf, ok := ret.Get(0).(func() (map[string]ipp.Attributes, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() map[string]ipp.Attributes); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(map[string]ipp.Attributes) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockCUPSClientInterface_GetPPDs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPPDs' +type MockCUPSClientInterface_GetPPDs_Call struct { + *mock.Call +} + +// GetPPDs is a helper method to define mock.On call +func (_e *MockCUPSClientInterface_Expecter) GetPPDs() *MockCUPSClientInterface_GetPPDs_Call { + return &MockCUPSClientInterface_GetPPDs_Call{Call: _e.mock.On("GetPPDs")} +} + +func (_c *MockCUPSClientInterface_GetPPDs_Call) Run(run func()) *MockCUPSClientInterface_GetPPDs_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockCUPSClientInterface_GetPPDs_Call) Return(_a0 map[string]ipp.Attributes, _a1 error) *MockCUPSClientInterface_GetPPDs_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockCUPSClientInterface_GetPPDs_Call) RunAndReturn(run func() (map[string]ipp.Attributes, error)) *MockCUPSClientInterface_GetPPDs_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 +} + +// HoldJobUntil provides a mock function with given fields: jobID, holdUntil +func (_m *MockCUPSClientInterface) HoldJobUntil(jobID int, holdUntil string) error { + ret := _m.Called(jobID, holdUntil) + + if len(ret) == 0 { + panic("no return value specified for HoldJobUntil") + } + + var r0 error + if rf, ok := ret.Get(0).(func(int, string) error); ok { + r0 = rf(jobID, holdUntil) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockCUPSClientInterface_HoldJobUntil_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HoldJobUntil' +type MockCUPSClientInterface_HoldJobUntil_Call struct { + *mock.Call +} + +// HoldJobUntil is a helper method to define mock.On call +// - jobID int +// - holdUntil string +func (_e *MockCUPSClientInterface_Expecter) HoldJobUntil(jobID interface{}, holdUntil interface{}) *MockCUPSClientInterface_HoldJobUntil_Call { + return &MockCUPSClientInterface_HoldJobUntil_Call{Call: _e.mock.On("HoldJobUntil", jobID, holdUntil)} +} + +func (_c *MockCUPSClientInterface_HoldJobUntil_Call) Run(run func(jobID int, holdUntil string)) *MockCUPSClientInterface_HoldJobUntil_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(int), args[1].(string)) + }) + return _c +} + +func (_c *MockCUPSClientInterface_HoldJobUntil_Call) Return(_a0 error) *MockCUPSClientInterface_HoldJobUntil_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCUPSClientInterface_HoldJobUntil_Call) RunAndReturn(run func(int, string) error) *MockCUPSClientInterface_HoldJobUntil_Call { + _c.Call.Return(run) + return _c +} + +// MoveJob provides a mock function with given fields: jobID, destPrinter +func (_m *MockCUPSClientInterface) MoveJob(jobID int, destPrinter string) error { + ret := _m.Called(jobID, destPrinter) + + if len(ret) == 0 { + panic("no return value specified for MoveJob") + } + + var r0 error + if rf, ok := ret.Get(0).(func(int, string) error); ok { + r0 = rf(jobID, destPrinter) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockCUPSClientInterface_MoveJob_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MoveJob' +type MockCUPSClientInterface_MoveJob_Call struct { + *mock.Call +} + +// MoveJob is a helper method to define mock.On call +// - jobID int +// - destPrinter string +func (_e *MockCUPSClientInterface_Expecter) MoveJob(jobID interface{}, destPrinter interface{}) *MockCUPSClientInterface_MoveJob_Call { + return &MockCUPSClientInterface_MoveJob_Call{Call: _e.mock.On("MoveJob", jobID, destPrinter)} +} + +func (_c *MockCUPSClientInterface_MoveJob_Call) Run(run func(jobID int, destPrinter string)) *MockCUPSClientInterface_MoveJob_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(int), args[1].(string)) + }) + return _c +} + +func (_c *MockCUPSClientInterface_MoveJob_Call) Return(_a0 error) *MockCUPSClientInterface_MoveJob_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCUPSClientInterface_MoveJob_Call) RunAndReturn(run func(int, string) error) *MockCUPSClientInterface_MoveJob_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 +} + +// PrintTestPage provides a mock function with given fields: printer, testPageData, size +func (_m *MockCUPSClientInterface) PrintTestPage(printer string, testPageData io.Reader, size int) (int, error) { + ret := _m.Called(printer, testPageData, size) + + if len(ret) == 0 { + panic("no return value specified for PrintTestPage") + } + + var r0 int + var r1 error + if rf, ok := ret.Get(0).(func(string, io.Reader, int) (int, error)); ok { + return rf(printer, testPageData, size) + } + if rf, ok := ret.Get(0).(func(string, io.Reader, int) int); ok { + r0 = rf(printer, testPageData, size) + } else { + r0 = ret.Get(0).(int) + } + + if rf, ok := ret.Get(1).(func(string, io.Reader, int) error); ok { + r1 = rf(printer, testPageData, size) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockCUPSClientInterface_PrintTestPage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PrintTestPage' +type MockCUPSClientInterface_PrintTestPage_Call struct { + *mock.Call +} + +// PrintTestPage is a helper method to define mock.On call +// - printer string +// - testPageData io.Reader +// - size int +func (_e *MockCUPSClientInterface_Expecter) PrintTestPage(printer interface{}, testPageData interface{}, size interface{}) *MockCUPSClientInterface_PrintTestPage_Call { + return &MockCUPSClientInterface_PrintTestPage_Call{Call: _e.mock.On("PrintTestPage", printer, testPageData, size)} +} + +func (_c *MockCUPSClientInterface_PrintTestPage_Call) Run(run func(printer string, testPageData io.Reader, size int)) *MockCUPSClientInterface_PrintTestPage_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(io.Reader), args[2].(int)) + }) + return _c +} + +func (_c *MockCUPSClientInterface_PrintTestPage_Call) Return(_a0 int, _a1 error) *MockCUPSClientInterface_PrintTestPage_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockCUPSClientInterface_PrintTestPage_Call) RunAndReturn(run func(string, io.Reader, int) (int, error)) *MockCUPSClientInterface_PrintTestPage_Call { + _c.Call.Return(run) + return _c +} + +// RejectJobs provides a mock function with given fields: printer +func (_m *MockCUPSClientInterface) RejectJobs(printer string) error { + ret := _m.Called(printer) + + if len(ret) == 0 { + panic("no return value specified for RejectJobs") + } + + var r0 error + if rf, ok := ret.Get(0).(func(string) error); ok { + r0 = rf(printer) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockCUPSClientInterface_RejectJobs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RejectJobs' +type MockCUPSClientInterface_RejectJobs_Call struct { + *mock.Call +} + +// RejectJobs is a helper method to define mock.On call +// - printer string +func (_e *MockCUPSClientInterface_Expecter) RejectJobs(printer interface{}) *MockCUPSClientInterface_RejectJobs_Call { + return &MockCUPSClientInterface_RejectJobs_Call{Call: _e.mock.On("RejectJobs", printer)} +} + +func (_c *MockCUPSClientInterface_RejectJobs_Call) Run(run func(printer string)) *MockCUPSClientInterface_RejectJobs_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *MockCUPSClientInterface_RejectJobs_Call) Return(_a0 error) *MockCUPSClientInterface_RejectJobs_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCUPSClientInterface_RejectJobs_Call) RunAndReturn(run func(string) error) *MockCUPSClientInterface_RejectJobs_Call { + _c.Call.Return(run) + return _c +} + +// RestartJob provides a mock function with given fields: jobID +func (_m *MockCUPSClientInterface) RestartJob(jobID int) error { + ret := _m.Called(jobID) + + if len(ret) == 0 { + panic("no return value specified for RestartJob") + } + + var r0 error + if rf, ok := ret.Get(0).(func(int) error); ok { + r0 = rf(jobID) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockCUPSClientInterface_RestartJob_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RestartJob' +type MockCUPSClientInterface_RestartJob_Call struct { + *mock.Call +} + +// RestartJob is a helper method to define mock.On call +// - jobID int +func (_e *MockCUPSClientInterface_Expecter) RestartJob(jobID interface{}) *MockCUPSClientInterface_RestartJob_Call { + return &MockCUPSClientInterface_RestartJob_Call{Call: _e.mock.On("RestartJob", jobID)} +} + +func (_c *MockCUPSClientInterface_RestartJob_Call) Run(run func(jobID int)) *MockCUPSClientInterface_RestartJob_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(int)) + }) + return _c +} + +func (_c *MockCUPSClientInterface_RestartJob_Call) Return(_a0 error) *MockCUPSClientInterface_RestartJob_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCUPSClientInterface_RestartJob_Call) RunAndReturn(run func(int) error) *MockCUPSClientInterface_RestartJob_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 +} + +// SetPrinterInformation provides a mock function with given fields: printer, information +func (_m *MockCUPSClientInterface) SetPrinterInformation(printer string, information string) error { + ret := _m.Called(printer, information) + + if len(ret) == 0 { + panic("no return value specified for SetPrinterInformation") + } + + var r0 error + if rf, ok := ret.Get(0).(func(string, string) error); ok { + r0 = rf(printer, information) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockCUPSClientInterface_SetPrinterInformation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetPrinterInformation' +type MockCUPSClientInterface_SetPrinterInformation_Call struct { + *mock.Call +} + +// SetPrinterInformation is a helper method to define mock.On call +// - printer string +// - information string +func (_e *MockCUPSClientInterface_Expecter) SetPrinterInformation(printer interface{}, information interface{}) *MockCUPSClientInterface_SetPrinterInformation_Call { + return &MockCUPSClientInterface_SetPrinterInformation_Call{Call: _e.mock.On("SetPrinterInformation", printer, information)} +} + +func (_c *MockCUPSClientInterface_SetPrinterInformation_Call) Run(run func(printer string, information string)) *MockCUPSClientInterface_SetPrinterInformation_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string)) + }) + return _c +} + +func (_c *MockCUPSClientInterface_SetPrinterInformation_Call) Return(_a0 error) *MockCUPSClientInterface_SetPrinterInformation_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCUPSClientInterface_SetPrinterInformation_Call) RunAndReturn(run func(string, string) error) *MockCUPSClientInterface_SetPrinterInformation_Call { + _c.Call.Return(run) + return _c +} + +// SetPrinterIsShared provides a mock function with given fields: printer, shared +func (_m *MockCUPSClientInterface) SetPrinterIsShared(printer string, shared bool) error { + ret := _m.Called(printer, shared) + + if len(ret) == 0 { + panic("no return value specified for SetPrinterIsShared") + } + + var r0 error + if rf, ok := ret.Get(0).(func(string, bool) error); ok { + r0 = rf(printer, shared) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockCUPSClientInterface_SetPrinterIsShared_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetPrinterIsShared' +type MockCUPSClientInterface_SetPrinterIsShared_Call struct { + *mock.Call +} + +// SetPrinterIsShared is a helper method to define mock.On call +// - printer string +// - shared bool +func (_e *MockCUPSClientInterface_Expecter) SetPrinterIsShared(printer interface{}, shared interface{}) *MockCUPSClientInterface_SetPrinterIsShared_Call { + return &MockCUPSClientInterface_SetPrinterIsShared_Call{Call: _e.mock.On("SetPrinterIsShared", printer, shared)} +} + +func (_c *MockCUPSClientInterface_SetPrinterIsShared_Call) Run(run func(printer string, shared bool)) *MockCUPSClientInterface_SetPrinterIsShared_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(bool)) + }) + return _c +} + +func (_c *MockCUPSClientInterface_SetPrinterIsShared_Call) Return(_a0 error) *MockCUPSClientInterface_SetPrinterIsShared_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCUPSClientInterface_SetPrinterIsShared_Call) RunAndReturn(run func(string, bool) error) *MockCUPSClientInterface_SetPrinterIsShared_Call { + _c.Call.Return(run) + return _c +} + +// SetPrinterLocation provides a mock function with given fields: printer, location +func (_m *MockCUPSClientInterface) SetPrinterLocation(printer string, location string) error { + ret := _m.Called(printer, location) + + if len(ret) == 0 { + panic("no return value specified for SetPrinterLocation") + } + + var r0 error + if rf, ok := ret.Get(0).(func(string, string) error); ok { + r0 = rf(printer, location) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockCUPSClientInterface_SetPrinterLocation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetPrinterLocation' +type MockCUPSClientInterface_SetPrinterLocation_Call struct { + *mock.Call +} + +// SetPrinterLocation is a helper method to define mock.On call +// - printer string +// - location string +func (_e *MockCUPSClientInterface_Expecter) SetPrinterLocation(printer interface{}, location interface{}) *MockCUPSClientInterface_SetPrinterLocation_Call { + return &MockCUPSClientInterface_SetPrinterLocation_Call{Call: _e.mock.On("SetPrinterLocation", printer, location)} +} + +func (_c *MockCUPSClientInterface_SetPrinterLocation_Call) Run(run func(printer string, location string)) *MockCUPSClientInterface_SetPrinterLocation_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string)) + }) + return _c +} + +func (_c *MockCUPSClientInterface_SetPrinterLocation_Call) Return(_a0 error) *MockCUPSClientInterface_SetPrinterLocation_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCUPSClientInterface_SetPrinterLocation_Call) RunAndReturn(run func(string, string) error) *MockCUPSClientInterface_SetPrinterLocation_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 +} -- cgit v1.3