diff options
Diffstat (limited to 'raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks')
21 files changed, 16482 insertions, 0 deletions
diff --git a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/brightness/mock_DBusConn.go b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/brightness/mock_DBusConn.go new file mode 100644 index 0000000..ce9472d --- /dev/null +++ b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/brightness/mock_DBusConn.go @@ -0,0 +1,130 @@ +// Code generated by mockery v2.53.5. DO NOT EDIT. + +package mocks_brightness + +import ( + dbus "github.com/godbus/dbus/v5" + mock "github.com/stretchr/testify/mock" +) + +// MockDBusConn is an autogenerated mock type for the DBusConn type +type MockDBusConn struct { + mock.Mock +} + +type MockDBusConn_Expecter struct { + mock *mock.Mock +} + +func (_m *MockDBusConn) EXPECT() *MockDBusConn_Expecter { + return &MockDBusConn_Expecter{mock: &_m.Mock} +} + +// Close provides a mock function with no fields +func (_m *MockDBusConn) Close() error { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Close") + } + + var r0 error + if rf, ok := ret.Get(0).(func() error); ok { + r0 = rf() + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockDBusConn_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close' +type MockDBusConn_Close_Call struct { + *mock.Call +} + +// Close is a helper method to define mock.On call +func (_e *MockDBusConn_Expecter) Close() *MockDBusConn_Close_Call { + return &MockDBusConn_Close_Call{Call: _e.mock.On("Close")} +} + +func (_c *MockDBusConn_Close_Call) Run(run func()) *MockDBusConn_Close_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockDBusConn_Close_Call) Return(_a0 error) *MockDBusConn_Close_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockDBusConn_Close_Call) RunAndReturn(run func() error) *MockDBusConn_Close_Call { + _c.Call.Return(run) + return _c +} + +// Object provides a mock function with given fields: dest, path +func (_m *MockDBusConn) Object(dest string, path dbus.ObjectPath) dbus.BusObject { + ret := _m.Called(dest, path) + + if len(ret) == 0 { + panic("no return value specified for Object") + } + + var r0 dbus.BusObject + if rf, ok := ret.Get(0).(func(string, dbus.ObjectPath) dbus.BusObject); ok { + r0 = rf(dest, path) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(dbus.BusObject) + } + } + + return r0 +} + +// MockDBusConn_Object_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Object' +type MockDBusConn_Object_Call struct { + *mock.Call +} + +// Object is a helper method to define mock.On call +// - dest string +// - path dbus.ObjectPath +func (_e *MockDBusConn_Expecter) Object(dest any, path any) *MockDBusConn_Object_Call { + return &MockDBusConn_Object_Call{Call: _e.mock.On("Object", dest, path)} +} + +func (_c *MockDBusConn_Object_Call) Run(run func(dest string, path dbus.ObjectPath)) *MockDBusConn_Object_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(dbus.ObjectPath)) + }) + return _c +} + +func (_c *MockDBusConn_Object_Call) Return(_a0 dbus.BusObject) *MockDBusConn_Object_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockDBusConn_Object_Call) RunAndReturn(run func(string, dbus.ObjectPath) dbus.BusObject) *MockDBusConn_Object_Call { + _c.Call.Return(run) + return _c +} + +// NewMockDBusConn creates a new instance of MockDBusConn. 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 NewMockDBusConn(t interface { + mock.TestingT + Cleanup(func()) +}, +) *MockDBusConn { + mock := &MockDBusConn{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} 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 +} diff --git a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/cups_pkhelper/mock_PkHelper.go b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/cups_pkhelper/mock_PkHelper.go new file mode 100644 index 0000000..cad5bfc --- /dev/null +++ b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/cups_pkhelper/mock_PkHelper.go @@ -0,0 +1,708 @@ +// Code generated by mockery v2.53.5. DO NOT EDIT. + +package mocks_cups_pkhelper + +import ( + cups "github.com/AvengeMedia/DankMaterialShell/core/internal/server/cups" + mock "github.com/stretchr/testify/mock" +) + +// MockPkHelper is an autogenerated mock type for the PkHelper type +type MockPkHelper struct { + mock.Mock +} + +type MockPkHelper_Expecter struct { + mock *mock.Mock +} + +func (_m *MockPkHelper) EXPECT() *MockPkHelper_Expecter { + return &MockPkHelper_Expecter{mock: &_m.Mock} +} + +// ClassAddPrinter provides a mock function with given fields: className, printerName +func (_m *MockPkHelper) ClassAddPrinter(className string, printerName string) error { + ret := _m.Called(className, printerName) + + if len(ret) == 0 { + panic("no return value specified for ClassAddPrinter") + } + + var r0 error + if rf, ok := ret.Get(0).(func(string, string) error); ok { + r0 = rf(className, printerName) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockPkHelper_ClassAddPrinter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClassAddPrinter' +type MockPkHelper_ClassAddPrinter_Call struct { + *mock.Call +} + +// ClassAddPrinter is a helper method to define mock.On call +// - className string +// - printerName string +func (_e *MockPkHelper_Expecter) ClassAddPrinter(className interface{}, printerName interface{}) *MockPkHelper_ClassAddPrinter_Call { + return &MockPkHelper_ClassAddPrinter_Call{Call: _e.mock.On("ClassAddPrinter", className, printerName)} +} + +func (_c *MockPkHelper_ClassAddPrinter_Call) Run(run func(className string, printerName string)) *MockPkHelper_ClassAddPrinter_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string)) + }) + return _c +} + +func (_c *MockPkHelper_ClassAddPrinter_Call) Return(_a0 error) *MockPkHelper_ClassAddPrinter_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockPkHelper_ClassAddPrinter_Call) RunAndReturn(run func(string, string) error) *MockPkHelper_ClassAddPrinter_Call { + _c.Call.Return(run) + return _c +} + +// ClassDelete provides a mock function with given fields: className +func (_m *MockPkHelper) ClassDelete(className string) error { + ret := _m.Called(className) + + if len(ret) == 0 { + panic("no return value specified for ClassDelete") + } + + var r0 error + if rf, ok := ret.Get(0).(func(string) error); ok { + r0 = rf(className) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockPkHelper_ClassDelete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClassDelete' +type MockPkHelper_ClassDelete_Call struct { + *mock.Call +} + +// ClassDelete is a helper method to define mock.On call +// - className string +func (_e *MockPkHelper_Expecter) ClassDelete(className interface{}) *MockPkHelper_ClassDelete_Call { + return &MockPkHelper_ClassDelete_Call{Call: _e.mock.On("ClassDelete", className)} +} + +func (_c *MockPkHelper_ClassDelete_Call) Run(run func(className string)) *MockPkHelper_ClassDelete_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *MockPkHelper_ClassDelete_Call) Return(_a0 error) *MockPkHelper_ClassDelete_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockPkHelper_ClassDelete_Call) RunAndReturn(run func(string) error) *MockPkHelper_ClassDelete_Call { + _c.Call.Return(run) + return _c +} + +// ClassDeletePrinter provides a mock function with given fields: className, printerName +func (_m *MockPkHelper) ClassDeletePrinter(className string, printerName string) error { + ret := _m.Called(className, printerName) + + if len(ret) == 0 { + panic("no return value specified for ClassDeletePrinter") + } + + var r0 error + if rf, ok := ret.Get(0).(func(string, string) error); ok { + r0 = rf(className, printerName) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockPkHelper_ClassDeletePrinter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClassDeletePrinter' +type MockPkHelper_ClassDeletePrinter_Call struct { + *mock.Call +} + +// ClassDeletePrinter is a helper method to define mock.On call +// - className string +// - printerName string +func (_e *MockPkHelper_Expecter) ClassDeletePrinter(className interface{}, printerName interface{}) *MockPkHelper_ClassDeletePrinter_Call { + return &MockPkHelper_ClassDeletePrinter_Call{Call: _e.mock.On("ClassDeletePrinter", className, printerName)} +} + +func (_c *MockPkHelper_ClassDeletePrinter_Call) Run(run func(className string, printerName string)) *MockPkHelper_ClassDeletePrinter_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string)) + }) + return _c +} + +func (_c *MockPkHelper_ClassDeletePrinter_Call) Return(_a0 error) *MockPkHelper_ClassDeletePrinter_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockPkHelper_ClassDeletePrinter_Call) RunAndReturn(run func(string, string) error) *MockPkHelper_ClassDeletePrinter_Call { + _c.Call.Return(run) + return _c +} + +// DevicesGet provides a mock function with given fields: timeout, limit, includeSchemes, excludeSchemes +func (_m *MockPkHelper) DevicesGet(timeout int, limit int, includeSchemes []string, excludeSchemes []string) ([]cups.Device, error) { + ret := _m.Called(timeout, limit, includeSchemes, excludeSchemes) + + if len(ret) == 0 { + panic("no return value specified for DevicesGet") + } + + var r0 []cups.Device + var r1 error + if rf, ok := ret.Get(0).(func(int, int, []string, []string) ([]cups.Device, error)); ok { + return rf(timeout, limit, includeSchemes, excludeSchemes) + } + if rf, ok := ret.Get(0).(func(int, int, []string, []string) []cups.Device); ok { + r0 = rf(timeout, limit, includeSchemes, excludeSchemes) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]cups.Device) + } + } + + if rf, ok := ret.Get(1).(func(int, int, []string, []string) error); ok { + r1 = rf(timeout, limit, includeSchemes, excludeSchemes) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockPkHelper_DevicesGet_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DevicesGet' +type MockPkHelper_DevicesGet_Call struct { + *mock.Call +} + +// DevicesGet is a helper method to define mock.On call +// - timeout int +// - limit int +// - includeSchemes []string +// - excludeSchemes []string +func (_e *MockPkHelper_Expecter) DevicesGet(timeout interface{}, limit interface{}, includeSchemes interface{}, excludeSchemes interface{}) *MockPkHelper_DevicesGet_Call { + return &MockPkHelper_DevicesGet_Call{Call: _e.mock.On("DevicesGet", timeout, limit, includeSchemes, excludeSchemes)} +} + +func (_c *MockPkHelper_DevicesGet_Call) Run(run func(timeout int, limit int, includeSchemes []string, excludeSchemes []string)) *MockPkHelper_DevicesGet_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(int), args[1].(int), args[2].([]string), args[3].([]string)) + }) + return _c +} + +func (_c *MockPkHelper_DevicesGet_Call) Return(_a0 []cups.Device, _a1 error) *MockPkHelper_DevicesGet_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockPkHelper_DevicesGet_Call) RunAndReturn(run func(int, int, []string, []string) ([]cups.Device, error)) *MockPkHelper_DevicesGet_Call { + _c.Call.Return(run) + return _c +} + +// JobCancelPurge provides a mock function with given fields: jobID, purge +func (_m *MockPkHelper) JobCancelPurge(jobID int, purge bool) error { + ret := _m.Called(jobID, purge) + + if len(ret) == 0 { + panic("no return value specified for JobCancelPurge") + } + + 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 +} + +// MockPkHelper_JobCancelPurge_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'JobCancelPurge' +type MockPkHelper_JobCancelPurge_Call struct { + *mock.Call +} + +// JobCancelPurge is a helper method to define mock.On call +// - jobID int +// - purge bool +func (_e *MockPkHelper_Expecter) JobCancelPurge(jobID interface{}, purge interface{}) *MockPkHelper_JobCancelPurge_Call { + return &MockPkHelper_JobCancelPurge_Call{Call: _e.mock.On("JobCancelPurge", jobID, purge)} +} + +func (_c *MockPkHelper_JobCancelPurge_Call) Run(run func(jobID int, purge bool)) *MockPkHelper_JobCancelPurge_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(int), args[1].(bool)) + }) + return _c +} + +func (_c *MockPkHelper_JobCancelPurge_Call) Return(_a0 error) *MockPkHelper_JobCancelPurge_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockPkHelper_JobCancelPurge_Call) RunAndReturn(run func(int, bool) error) *MockPkHelper_JobCancelPurge_Call { + _c.Call.Return(run) + return _c +} + +// JobRestart provides a mock function with given fields: jobID +func (_m *MockPkHelper) JobRestart(jobID int) error { + ret := _m.Called(jobID) + + if len(ret) == 0 { + panic("no return value specified for JobRestart") + } + + var r0 error + if rf, ok := ret.Get(0).(func(int) error); ok { + r0 = rf(jobID) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockPkHelper_JobRestart_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'JobRestart' +type MockPkHelper_JobRestart_Call struct { + *mock.Call +} + +// JobRestart is a helper method to define mock.On call +// - jobID int +func (_e *MockPkHelper_Expecter) JobRestart(jobID interface{}) *MockPkHelper_JobRestart_Call { + return &MockPkHelper_JobRestart_Call{Call: _e.mock.On("JobRestart", jobID)} +} + +func (_c *MockPkHelper_JobRestart_Call) Run(run func(jobID int)) *MockPkHelper_JobRestart_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(int)) + }) + return _c +} + +func (_c *MockPkHelper_JobRestart_Call) Return(_a0 error) *MockPkHelper_JobRestart_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockPkHelper_JobRestart_Call) RunAndReturn(run func(int) error) *MockPkHelper_JobRestart_Call { + _c.Call.Return(run) + return _c +} + +// JobSetHoldUntil provides a mock function with given fields: jobID, holdUntil +func (_m *MockPkHelper) JobSetHoldUntil(jobID int, holdUntil string) error { + ret := _m.Called(jobID, holdUntil) + + if len(ret) == 0 { + panic("no return value specified for JobSetHoldUntil") + } + + 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 +} + +// MockPkHelper_JobSetHoldUntil_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'JobSetHoldUntil' +type MockPkHelper_JobSetHoldUntil_Call struct { + *mock.Call +} + +// JobSetHoldUntil is a helper method to define mock.On call +// - jobID int +// - holdUntil string +func (_e *MockPkHelper_Expecter) JobSetHoldUntil(jobID interface{}, holdUntil interface{}) *MockPkHelper_JobSetHoldUntil_Call { + return &MockPkHelper_JobSetHoldUntil_Call{Call: _e.mock.On("JobSetHoldUntil", jobID, holdUntil)} +} + +func (_c *MockPkHelper_JobSetHoldUntil_Call) Run(run func(jobID int, holdUntil string)) *MockPkHelper_JobSetHoldUntil_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(int), args[1].(string)) + }) + return _c +} + +func (_c *MockPkHelper_JobSetHoldUntil_Call) Return(_a0 error) *MockPkHelper_JobSetHoldUntil_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockPkHelper_JobSetHoldUntil_Call) RunAndReturn(run func(int, string) error) *MockPkHelper_JobSetHoldUntil_Call { + _c.Call.Return(run) + return _c +} + +// PrinterAdd provides a mock function with given fields: name, uri, ppd, info, location +func (_m *MockPkHelper) PrinterAdd(name string, uri string, ppd string, info string, location string) error { + ret := _m.Called(name, uri, ppd, info, location) + + if len(ret) == 0 { + panic("no return value specified for PrinterAdd") + } + + var r0 error + if rf, ok := ret.Get(0).(func(string, string, string, string, string) error); ok { + r0 = rf(name, uri, ppd, info, location) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockPkHelper_PrinterAdd_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PrinterAdd' +type MockPkHelper_PrinterAdd_Call struct { + *mock.Call +} + +// PrinterAdd is a helper method to define mock.On call +// - name string +// - uri string +// - ppd string +// - info string +// - location string +func (_e *MockPkHelper_Expecter) PrinterAdd(name interface{}, uri interface{}, ppd interface{}, info interface{}, location interface{}) *MockPkHelper_PrinterAdd_Call { + return &MockPkHelper_PrinterAdd_Call{Call: _e.mock.On("PrinterAdd", name, uri, ppd, info, location)} +} + +func (_c *MockPkHelper_PrinterAdd_Call) Run(run func(name string, uri string, ppd string, info string, location string)) *MockPkHelper_PrinterAdd_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string), args[3].(string), args[4].(string)) + }) + return _c +} + +func (_c *MockPkHelper_PrinterAdd_Call) Return(_a0 error) *MockPkHelper_PrinterAdd_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockPkHelper_PrinterAdd_Call) RunAndReturn(run func(string, string, string, string, string) error) *MockPkHelper_PrinterAdd_Call { + _c.Call.Return(run) + return _c +} + +// PrinterDelete provides a mock function with given fields: name +func (_m *MockPkHelper) PrinterDelete(name string) error { + ret := _m.Called(name) + + if len(ret) == 0 { + panic("no return value specified for PrinterDelete") + } + + var r0 error + if rf, ok := ret.Get(0).(func(string) error); ok { + r0 = rf(name) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockPkHelper_PrinterDelete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PrinterDelete' +type MockPkHelper_PrinterDelete_Call struct { + *mock.Call +} + +// PrinterDelete is a helper method to define mock.On call +// - name string +func (_e *MockPkHelper_Expecter) PrinterDelete(name interface{}) *MockPkHelper_PrinterDelete_Call { + return &MockPkHelper_PrinterDelete_Call{Call: _e.mock.On("PrinterDelete", name)} +} + +func (_c *MockPkHelper_PrinterDelete_Call) Run(run func(name string)) *MockPkHelper_PrinterDelete_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *MockPkHelper_PrinterDelete_Call) Return(_a0 error) *MockPkHelper_PrinterDelete_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockPkHelper_PrinterDelete_Call) RunAndReturn(run func(string) error) *MockPkHelper_PrinterDelete_Call { + _c.Call.Return(run) + return _c +} + +// PrinterSetAcceptJobs provides a mock function with given fields: name, enabled, reason +func (_m *MockPkHelper) PrinterSetAcceptJobs(name string, enabled bool, reason string) error { + ret := _m.Called(name, enabled, reason) + + if len(ret) == 0 { + panic("no return value specified for PrinterSetAcceptJobs") + } + + var r0 error + if rf, ok := ret.Get(0).(func(string, bool, string) error); ok { + r0 = rf(name, enabled, reason) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockPkHelper_PrinterSetAcceptJobs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PrinterSetAcceptJobs' +type MockPkHelper_PrinterSetAcceptJobs_Call struct { + *mock.Call +} + +// PrinterSetAcceptJobs is a helper method to define mock.On call +// - name string +// - enabled bool +// - reason string +func (_e *MockPkHelper_Expecter) PrinterSetAcceptJobs(name interface{}, enabled interface{}, reason interface{}) *MockPkHelper_PrinterSetAcceptJobs_Call { + return &MockPkHelper_PrinterSetAcceptJobs_Call{Call: _e.mock.On("PrinterSetAcceptJobs", name, enabled, reason)} +} + +func (_c *MockPkHelper_PrinterSetAcceptJobs_Call) Run(run func(name string, enabled bool, reason string)) *MockPkHelper_PrinterSetAcceptJobs_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(bool), args[2].(string)) + }) + return _c +} + +func (_c *MockPkHelper_PrinterSetAcceptJobs_Call) Return(_a0 error) *MockPkHelper_PrinterSetAcceptJobs_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockPkHelper_PrinterSetAcceptJobs_Call) RunAndReturn(run func(string, bool, string) error) *MockPkHelper_PrinterSetAcceptJobs_Call { + _c.Call.Return(run) + return _c +} + +// PrinterSetEnabled provides a mock function with given fields: name, enabled +func (_m *MockPkHelper) PrinterSetEnabled(name string, enabled bool) error { + ret := _m.Called(name, enabled) + + if len(ret) == 0 { + panic("no return value specified for PrinterSetEnabled") + } + + var r0 error + if rf, ok := ret.Get(0).(func(string, bool) error); ok { + r0 = rf(name, enabled) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockPkHelper_PrinterSetEnabled_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PrinterSetEnabled' +type MockPkHelper_PrinterSetEnabled_Call struct { + *mock.Call +} + +// PrinterSetEnabled is a helper method to define mock.On call +// - name string +// - enabled bool +func (_e *MockPkHelper_Expecter) PrinterSetEnabled(name interface{}, enabled interface{}) *MockPkHelper_PrinterSetEnabled_Call { + return &MockPkHelper_PrinterSetEnabled_Call{Call: _e.mock.On("PrinterSetEnabled", name, enabled)} +} + +func (_c *MockPkHelper_PrinterSetEnabled_Call) Run(run func(name string, enabled bool)) *MockPkHelper_PrinterSetEnabled_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(bool)) + }) + return _c +} + +func (_c *MockPkHelper_PrinterSetEnabled_Call) Return(_a0 error) *MockPkHelper_PrinterSetEnabled_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockPkHelper_PrinterSetEnabled_Call) RunAndReturn(run func(string, bool) error) *MockPkHelper_PrinterSetEnabled_Call { + _c.Call.Return(run) + return _c +} + +// PrinterSetInfo provides a mock function with given fields: name, info +func (_m *MockPkHelper) PrinterSetInfo(name string, info string) error { + ret := _m.Called(name, info) + + if len(ret) == 0 { + panic("no return value specified for PrinterSetInfo") + } + + var r0 error + if rf, ok := ret.Get(0).(func(string, string) error); ok { + r0 = rf(name, info) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockPkHelper_PrinterSetInfo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PrinterSetInfo' +type MockPkHelper_PrinterSetInfo_Call struct { + *mock.Call +} + +// PrinterSetInfo is a helper method to define mock.On call +// - name string +// - info string +func (_e *MockPkHelper_Expecter) PrinterSetInfo(name interface{}, info interface{}) *MockPkHelper_PrinterSetInfo_Call { + return &MockPkHelper_PrinterSetInfo_Call{Call: _e.mock.On("PrinterSetInfo", name, info)} +} + +func (_c *MockPkHelper_PrinterSetInfo_Call) Run(run func(name string, info string)) *MockPkHelper_PrinterSetInfo_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string)) + }) + return _c +} + +func (_c *MockPkHelper_PrinterSetInfo_Call) Return(_a0 error) *MockPkHelper_PrinterSetInfo_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockPkHelper_PrinterSetInfo_Call) RunAndReturn(run func(string, string) error) *MockPkHelper_PrinterSetInfo_Call { + _c.Call.Return(run) + return _c +} + +// PrinterSetLocation provides a mock function with given fields: name, location +func (_m *MockPkHelper) PrinterSetLocation(name string, location string) error { + ret := _m.Called(name, location) + + if len(ret) == 0 { + panic("no return value specified for PrinterSetLocation") + } + + var r0 error + if rf, ok := ret.Get(0).(func(string, string) error); ok { + r0 = rf(name, location) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockPkHelper_PrinterSetLocation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PrinterSetLocation' +type MockPkHelper_PrinterSetLocation_Call struct { + *mock.Call +} + +// PrinterSetLocation is a helper method to define mock.On call +// - name string +// - location string +func (_e *MockPkHelper_Expecter) PrinterSetLocation(name interface{}, location interface{}) *MockPkHelper_PrinterSetLocation_Call { + return &MockPkHelper_PrinterSetLocation_Call{Call: _e.mock.On("PrinterSetLocation", name, location)} +} + +func (_c *MockPkHelper_PrinterSetLocation_Call) Run(run func(name string, location string)) *MockPkHelper_PrinterSetLocation_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string)) + }) + return _c +} + +func (_c *MockPkHelper_PrinterSetLocation_Call) Return(_a0 error) *MockPkHelper_PrinterSetLocation_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockPkHelper_PrinterSetLocation_Call) RunAndReturn(run func(string, string) error) *MockPkHelper_PrinterSetLocation_Call { + _c.Call.Return(run) + return _c +} + +// PrinterSetShared provides a mock function with given fields: name, shared +func (_m *MockPkHelper) PrinterSetShared(name string, shared bool) error { + ret := _m.Called(name, shared) + + if len(ret) == 0 { + panic("no return value specified for PrinterSetShared") + } + + var r0 error + if rf, ok := ret.Get(0).(func(string, bool) error); ok { + r0 = rf(name, shared) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockPkHelper_PrinterSetShared_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PrinterSetShared' +type MockPkHelper_PrinterSetShared_Call struct { + *mock.Call +} + +// PrinterSetShared is a helper method to define mock.On call +// - name string +// - shared bool +func (_e *MockPkHelper_Expecter) PrinterSetShared(name interface{}, shared interface{}) *MockPkHelper_PrinterSetShared_Call { + return &MockPkHelper_PrinterSetShared_Call{Call: _e.mock.On("PrinterSetShared", name, shared)} +} + +func (_c *MockPkHelper_PrinterSetShared_Call) Run(run func(name string, shared bool)) *MockPkHelper_PrinterSetShared_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(bool)) + }) + return _c +} + +func (_c *MockPkHelper_PrinterSetShared_Call) Return(_a0 error) *MockPkHelper_PrinterSetShared_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockPkHelper_PrinterSetShared_Call) RunAndReturn(run func(string, bool) error) *MockPkHelper_PrinterSetShared_Call { + _c.Call.Return(run) + return _c +} + +// NewMockPkHelper creates a new instance of MockPkHelper. 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 NewMockPkHelper(t interface { + mock.TestingT + Cleanup(func()) +}) *MockPkHelper { + mock := &MockPkHelper{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/evdev/mock_EvdevDevice.go b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/evdev/mock_EvdevDevice.go new file mode 100644 index 0000000..4d54e3e --- /dev/null +++ b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/evdev/mock_EvdevDevice.go @@ -0,0 +1,295 @@ +// Code generated by mockery v2.53.5. DO NOT EDIT. + +package mocks_evdev + +import ( + go_evdev "github.com/holoplot/go-evdev" + mock "github.com/stretchr/testify/mock" +) + +// MockEvdevDevice is an autogenerated mock type for the EvdevDevice type +type MockEvdevDevice struct { + mock.Mock +} + +type MockEvdevDevice_Expecter struct { + mock *mock.Mock +} + +func (_m *MockEvdevDevice) EXPECT() *MockEvdevDevice_Expecter { + return &MockEvdevDevice_Expecter{mock: &_m.Mock} +} + +// Close provides a mock function with no fields +func (_m *MockEvdevDevice) Close() error { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Close") + } + + var r0 error + if rf, ok := ret.Get(0).(func() error); ok { + r0 = rf() + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockEvdevDevice_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close' +type MockEvdevDevice_Close_Call struct { + *mock.Call +} + +// Close is a helper method to define mock.On call +func (_e *MockEvdevDevice_Expecter) Close() *MockEvdevDevice_Close_Call { + return &MockEvdevDevice_Close_Call{Call: _e.mock.On("Close")} +} + +func (_c *MockEvdevDevice_Close_Call) Run(run func()) *MockEvdevDevice_Close_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockEvdevDevice_Close_Call) Return(_a0 error) *MockEvdevDevice_Close_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockEvdevDevice_Close_Call) RunAndReturn(run func() error) *MockEvdevDevice_Close_Call { + _c.Call.Return(run) + return _c +} + +// Name provides a mock function with no fields +func (_m *MockEvdevDevice) Name() (string, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Name") + } + + var r0 string + var r1 error + if rf, ok := ret.Get(0).(func() (string, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockEvdevDevice_Name_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Name' +type MockEvdevDevice_Name_Call struct { + *mock.Call +} + +// Name is a helper method to define mock.On call +func (_e *MockEvdevDevice_Expecter) Name() *MockEvdevDevice_Name_Call { + return &MockEvdevDevice_Name_Call{Call: _e.mock.On("Name")} +} + +func (_c *MockEvdevDevice_Name_Call) Run(run func()) *MockEvdevDevice_Name_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockEvdevDevice_Name_Call) Return(_a0 string, _a1 error) *MockEvdevDevice_Name_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockEvdevDevice_Name_Call) RunAndReturn(run func() (string, error)) *MockEvdevDevice_Name_Call { + _c.Call.Return(run) + return _c +} + +// Path provides a mock function with no fields +func (_m *MockEvdevDevice) Path() string { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Path") + } + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +// MockEvdevDevice_Path_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Path' +type MockEvdevDevice_Path_Call struct { + *mock.Call +} + +// Path is a helper method to define mock.On call +func (_e *MockEvdevDevice_Expecter) Path() *MockEvdevDevice_Path_Call { + return &MockEvdevDevice_Path_Call{Call: _e.mock.On("Path")} +} + +func (_c *MockEvdevDevice_Path_Call) Run(run func()) *MockEvdevDevice_Path_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockEvdevDevice_Path_Call) Return(_a0 string) *MockEvdevDevice_Path_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockEvdevDevice_Path_Call) RunAndReturn(run func() string) *MockEvdevDevice_Path_Call { + _c.Call.Return(run) + return _c +} + +// ReadOne provides a mock function with no fields +func (_m *MockEvdevDevice) ReadOne() (*go_evdev.InputEvent, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for ReadOne") + } + + var r0 *go_evdev.InputEvent + var r1 error + if rf, ok := ret.Get(0).(func() (*go_evdev.InputEvent, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() *go_evdev.InputEvent); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*go_evdev.InputEvent) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockEvdevDevice_ReadOne_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReadOne' +type MockEvdevDevice_ReadOne_Call struct { + *mock.Call +} + +// ReadOne is a helper method to define mock.On call +func (_e *MockEvdevDevice_Expecter) ReadOne() *MockEvdevDevice_ReadOne_Call { + return &MockEvdevDevice_ReadOne_Call{Call: _e.mock.On("ReadOne")} +} + +func (_c *MockEvdevDevice_ReadOne_Call) Run(run func()) *MockEvdevDevice_ReadOne_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockEvdevDevice_ReadOne_Call) Return(_a0 *go_evdev.InputEvent, _a1 error) *MockEvdevDevice_ReadOne_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockEvdevDevice_ReadOne_Call) RunAndReturn(run func() (*go_evdev.InputEvent, error)) *MockEvdevDevice_ReadOne_Call { + _c.Call.Return(run) + return _c +} + +// State provides a mock function with given fields: t +func (_m *MockEvdevDevice) State(t go_evdev.EvType) (go_evdev.StateMap, error) { + ret := _m.Called(t) + + if len(ret) == 0 { + panic("no return value specified for State") + } + + var r0 go_evdev.StateMap + var r1 error + if rf, ok := ret.Get(0).(func(go_evdev.EvType) (go_evdev.StateMap, error)); ok { + return rf(t) + } + if rf, ok := ret.Get(0).(func(go_evdev.EvType) go_evdev.StateMap); ok { + r0 = rf(t) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(go_evdev.StateMap) + } + } + + if rf, ok := ret.Get(1).(func(go_evdev.EvType) error); ok { + r1 = rf(t) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockEvdevDevice_State_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'State' +type MockEvdevDevice_State_Call struct { + *mock.Call +} + +// State is a helper method to define mock.On call +// - t go_evdev.EvType +func (_e *MockEvdevDevice_Expecter) State(t interface{}) *MockEvdevDevice_State_Call { + return &MockEvdevDevice_State_Call{Call: _e.mock.On("State", t)} +} + +func (_c *MockEvdevDevice_State_Call) Run(run func(t go_evdev.EvType)) *MockEvdevDevice_State_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(go_evdev.EvType)) + }) + return _c +} + +func (_c *MockEvdevDevice_State_Call) Return(_a0 go_evdev.StateMap, _a1 error) *MockEvdevDevice_State_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockEvdevDevice_State_Call) RunAndReturn(run func(go_evdev.EvType) (go_evdev.StateMap, error)) *MockEvdevDevice_State_Call { + _c.Call.Return(run) + return _c +} + +// NewMockEvdevDevice creates a new instance of MockEvdevDevice. 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 NewMockEvdevDevice(t interface { + mock.TestingT + Cleanup(func()) +}) *MockEvdevDevice { + mock := &MockEvdevDevice{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/geolocation/mock_Client.go b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/geolocation/mock_Client.go new file mode 100644 index 0000000..bf097cb --- /dev/null +++ b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/geolocation/mock_Client.go @@ -0,0 +1,203 @@ +// Code generated by mockery v2.53.5. DO NOT EDIT. + +package mocks_geolocation + +import ( + geolocation "github.com/AvengeMedia/DankMaterialShell/core/internal/geolocation" + mock "github.com/stretchr/testify/mock" +) + +// MockClient is an autogenerated mock type for the Client type +type MockClient struct { + mock.Mock +} + +type MockClient_Expecter struct { + mock *mock.Mock +} + +func (_m *MockClient) EXPECT() *MockClient_Expecter { + return &MockClient_Expecter{mock: &_m.Mock} +} + +// Close provides a mock function with no fields +func (_m *MockClient) Close() { + _m.Called() +} + +// MockClient_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close' +type MockClient_Close_Call struct { + *mock.Call +} + +// Close is a helper method to define mock.On call +func (_e *MockClient_Expecter) Close() *MockClient_Close_Call { + return &MockClient_Close_Call{Call: _e.mock.On("Close")} +} + +func (_c *MockClient_Close_Call) Run(run func()) *MockClient_Close_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockClient_Close_Call) Return() *MockClient_Close_Call { + _c.Call.Return() + return _c +} + +func (_c *MockClient_Close_Call) RunAndReturn(run func()) *MockClient_Close_Call { + _c.Run(run) + return _c +} + +// GetLocation provides a mock function with no fields +func (_m *MockClient) GetLocation() (geolocation.Location, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetLocation") + } + + var r0 geolocation.Location + var r1 error + if rf, ok := ret.Get(0).(func() (geolocation.Location, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() geolocation.Location); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(geolocation.Location) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_GetLocation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetLocation' +type MockClient_GetLocation_Call struct { + *mock.Call +} + +// GetLocation is a helper method to define mock.On call +func (_e *MockClient_Expecter) GetLocation() *MockClient_GetLocation_Call { + return &MockClient_GetLocation_Call{Call: _e.mock.On("GetLocation")} +} + +func (_c *MockClient_GetLocation_Call) Run(run func()) *MockClient_GetLocation_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockClient_GetLocation_Call) Return(_a0 geolocation.Location, _a1 error) *MockClient_GetLocation_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_GetLocation_Call) RunAndReturn(run func() (geolocation.Location, error)) *MockClient_GetLocation_Call { + _c.Call.Return(run) + return _c +} + +// Subscribe provides a mock function with given fields: id +func (_m *MockClient) Subscribe(id string) chan geolocation.Location { + ret := _m.Called(id) + + if len(ret) == 0 { + panic("no return value specified for Subscribe") + } + + var r0 chan geolocation.Location + if rf, ok := ret.Get(0).(func(string) chan geolocation.Location); ok { + r0 = rf(id) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(chan geolocation.Location) + } + } + + return r0 +} + +// MockClient_Subscribe_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Subscribe' +type MockClient_Subscribe_Call struct { + *mock.Call +} + +// Subscribe is a helper method to define mock.On call +// - id string +func (_e *MockClient_Expecter) Subscribe(id interface{}) *MockClient_Subscribe_Call { + return &MockClient_Subscribe_Call{Call: _e.mock.On("Subscribe", id)} +} + +func (_c *MockClient_Subscribe_Call) Run(run func(id string)) *MockClient_Subscribe_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *MockClient_Subscribe_Call) Return(_a0 chan geolocation.Location) *MockClient_Subscribe_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockClient_Subscribe_Call) RunAndReturn(run func(string) chan geolocation.Location) *MockClient_Subscribe_Call { + _c.Call.Return(run) + return _c +} + +// Unsubscribe provides a mock function with given fields: id +func (_m *MockClient) Unsubscribe(id string) { + _m.Called(id) +} + +// MockClient_Unsubscribe_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Unsubscribe' +type MockClient_Unsubscribe_Call struct { + *mock.Call +} + +// Unsubscribe is a helper method to define mock.On call +// - id string +func (_e *MockClient_Expecter) Unsubscribe(id interface{}) *MockClient_Unsubscribe_Call { + return &MockClient_Unsubscribe_Call{Call: _e.mock.On("Unsubscribe", id)} +} + +func (_c *MockClient_Unsubscribe_Call) Run(run func(id string)) *MockClient_Unsubscribe_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *MockClient_Unsubscribe_Call) Return() *MockClient_Unsubscribe_Call { + _c.Call.Return() + return _c +} + +func (_c *MockClient_Unsubscribe_Call) RunAndReturn(run func(string)) *MockClient_Unsubscribe_Call { + _c.Run(run) + return _c +} + +// NewMockClient creates a new instance of MockClient. 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 NewMockClient(t interface { + mock.TestingT + Cleanup(func()) +}) *MockClient { + mock := &MockClient{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/github.com/Wifx/gonetworkmanager/v2/mock_AccessPoint.go b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/github.com/Wifx/gonetworkmanager/v2/mock_AccessPoint.go new file mode 100644 index 0000000..ae5124d --- /dev/null +++ b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/github.com/Wifx/gonetworkmanager/v2/mock_AccessPoint.go @@ -0,0 +1,689 @@ +// Code generated by mockery v2.53.5. DO NOT EDIT. + +package gonetworkmanager + +import ( + gonetworkmanager "github.com/Wifx/gonetworkmanager/v2" + dbus "github.com/godbus/dbus/v5" + + mock "github.com/stretchr/testify/mock" +) + +// MockAccessPoint is an autogenerated mock type for the AccessPoint type +type MockAccessPoint struct { + mock.Mock +} + +type MockAccessPoint_Expecter struct { + mock *mock.Mock +} + +func (_m *MockAccessPoint) EXPECT() *MockAccessPoint_Expecter { + return &MockAccessPoint_Expecter{mock: &_m.Mock} +} + +// GetPath provides a mock function with no fields +func (_m *MockAccessPoint) GetPath() dbus.ObjectPath { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPath") + } + + var r0 dbus.ObjectPath + if rf, ok := ret.Get(0).(func() dbus.ObjectPath); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(dbus.ObjectPath) + } + + return r0 +} + +// MockAccessPoint_GetPath_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPath' +type MockAccessPoint_GetPath_Call struct { + *mock.Call +} + +// GetPath is a helper method to define mock.On call +func (_e *MockAccessPoint_Expecter) GetPath() *MockAccessPoint_GetPath_Call { + return &MockAccessPoint_GetPath_Call{Call: _e.mock.On("GetPath")} +} + +func (_c *MockAccessPoint_GetPath_Call) Run(run func()) *MockAccessPoint_GetPath_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockAccessPoint_GetPath_Call) Return(_a0 dbus.ObjectPath) *MockAccessPoint_GetPath_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockAccessPoint_GetPath_Call) RunAndReturn(run func() dbus.ObjectPath) *MockAccessPoint_GetPath_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyFlags provides a mock function with no fields +func (_m *MockAccessPoint) GetPropertyFlags() (uint32, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyFlags") + } + + var r0 uint32 + var r1 error + if rf, ok := ret.Get(0).(func() (uint32, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() uint32); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(uint32) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockAccessPoint_GetPropertyFlags_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyFlags' +type MockAccessPoint_GetPropertyFlags_Call struct { + *mock.Call +} + +// GetPropertyFlags is a helper method to define mock.On call +func (_e *MockAccessPoint_Expecter) GetPropertyFlags() *MockAccessPoint_GetPropertyFlags_Call { + return &MockAccessPoint_GetPropertyFlags_Call{Call: _e.mock.On("GetPropertyFlags")} +} + +func (_c *MockAccessPoint_GetPropertyFlags_Call) Run(run func()) *MockAccessPoint_GetPropertyFlags_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockAccessPoint_GetPropertyFlags_Call) Return(_a0 uint32, _a1 error) *MockAccessPoint_GetPropertyFlags_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockAccessPoint_GetPropertyFlags_Call) RunAndReturn(run func() (uint32, error)) *MockAccessPoint_GetPropertyFlags_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyFrequency provides a mock function with no fields +func (_m *MockAccessPoint) GetPropertyFrequency() (uint32, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyFrequency") + } + + var r0 uint32 + var r1 error + if rf, ok := ret.Get(0).(func() (uint32, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() uint32); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(uint32) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockAccessPoint_GetPropertyFrequency_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyFrequency' +type MockAccessPoint_GetPropertyFrequency_Call struct { + *mock.Call +} + +// GetPropertyFrequency is a helper method to define mock.On call +func (_e *MockAccessPoint_Expecter) GetPropertyFrequency() *MockAccessPoint_GetPropertyFrequency_Call { + return &MockAccessPoint_GetPropertyFrequency_Call{Call: _e.mock.On("GetPropertyFrequency")} +} + +func (_c *MockAccessPoint_GetPropertyFrequency_Call) Run(run func()) *MockAccessPoint_GetPropertyFrequency_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockAccessPoint_GetPropertyFrequency_Call) Return(_a0 uint32, _a1 error) *MockAccessPoint_GetPropertyFrequency_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockAccessPoint_GetPropertyFrequency_Call) RunAndReturn(run func() (uint32, error)) *MockAccessPoint_GetPropertyFrequency_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyHWAddress provides a mock function with no fields +func (_m *MockAccessPoint) GetPropertyHWAddress() (string, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyHWAddress") + } + + var r0 string + var r1 error + if rf, ok := ret.Get(0).(func() (string, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockAccessPoint_GetPropertyHWAddress_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyHWAddress' +type MockAccessPoint_GetPropertyHWAddress_Call struct { + *mock.Call +} + +// GetPropertyHWAddress is a helper method to define mock.On call +func (_e *MockAccessPoint_Expecter) GetPropertyHWAddress() *MockAccessPoint_GetPropertyHWAddress_Call { + return &MockAccessPoint_GetPropertyHWAddress_Call{Call: _e.mock.On("GetPropertyHWAddress")} +} + +func (_c *MockAccessPoint_GetPropertyHWAddress_Call) Run(run func()) *MockAccessPoint_GetPropertyHWAddress_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockAccessPoint_GetPropertyHWAddress_Call) Return(_a0 string, _a1 error) *MockAccessPoint_GetPropertyHWAddress_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockAccessPoint_GetPropertyHWAddress_Call) RunAndReturn(run func() (string, error)) *MockAccessPoint_GetPropertyHWAddress_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyLastSeen provides a mock function with no fields +func (_m *MockAccessPoint) GetPropertyLastSeen() (int32, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyLastSeen") + } + + var r0 int32 + var r1 error + if rf, ok := ret.Get(0).(func() (int32, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() int32); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(int32) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockAccessPoint_GetPropertyLastSeen_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyLastSeen' +type MockAccessPoint_GetPropertyLastSeen_Call struct { + *mock.Call +} + +// GetPropertyLastSeen is a helper method to define mock.On call +func (_e *MockAccessPoint_Expecter) GetPropertyLastSeen() *MockAccessPoint_GetPropertyLastSeen_Call { + return &MockAccessPoint_GetPropertyLastSeen_Call{Call: _e.mock.On("GetPropertyLastSeen")} +} + +func (_c *MockAccessPoint_GetPropertyLastSeen_Call) Run(run func()) *MockAccessPoint_GetPropertyLastSeen_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockAccessPoint_GetPropertyLastSeen_Call) Return(_a0 int32, _a1 error) *MockAccessPoint_GetPropertyLastSeen_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockAccessPoint_GetPropertyLastSeen_Call) RunAndReturn(run func() (int32, error)) *MockAccessPoint_GetPropertyLastSeen_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyMaxBitrate provides a mock function with no fields +func (_m *MockAccessPoint) GetPropertyMaxBitrate() (uint32, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyMaxBitrate") + } + + var r0 uint32 + var r1 error + if rf, ok := ret.Get(0).(func() (uint32, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() uint32); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(uint32) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockAccessPoint_GetPropertyMaxBitrate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyMaxBitrate' +type MockAccessPoint_GetPropertyMaxBitrate_Call struct { + *mock.Call +} + +// GetPropertyMaxBitrate is a helper method to define mock.On call +func (_e *MockAccessPoint_Expecter) GetPropertyMaxBitrate() *MockAccessPoint_GetPropertyMaxBitrate_Call { + return &MockAccessPoint_GetPropertyMaxBitrate_Call{Call: _e.mock.On("GetPropertyMaxBitrate")} +} + +func (_c *MockAccessPoint_GetPropertyMaxBitrate_Call) Run(run func()) *MockAccessPoint_GetPropertyMaxBitrate_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockAccessPoint_GetPropertyMaxBitrate_Call) Return(_a0 uint32, _a1 error) *MockAccessPoint_GetPropertyMaxBitrate_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockAccessPoint_GetPropertyMaxBitrate_Call) RunAndReturn(run func() (uint32, error)) *MockAccessPoint_GetPropertyMaxBitrate_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyMode provides a mock function with no fields +func (_m *MockAccessPoint) GetPropertyMode() (gonetworkmanager.Nm80211Mode, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyMode") + } + + var r0 gonetworkmanager.Nm80211Mode + var r1 error + if rf, ok := ret.Get(0).(func() (gonetworkmanager.Nm80211Mode, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() gonetworkmanager.Nm80211Mode); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(gonetworkmanager.Nm80211Mode) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockAccessPoint_GetPropertyMode_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyMode' +type MockAccessPoint_GetPropertyMode_Call struct { + *mock.Call +} + +// GetPropertyMode is a helper method to define mock.On call +func (_e *MockAccessPoint_Expecter) GetPropertyMode() *MockAccessPoint_GetPropertyMode_Call { + return &MockAccessPoint_GetPropertyMode_Call{Call: _e.mock.On("GetPropertyMode")} +} + +func (_c *MockAccessPoint_GetPropertyMode_Call) Run(run func()) *MockAccessPoint_GetPropertyMode_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockAccessPoint_GetPropertyMode_Call) Return(_a0 gonetworkmanager.Nm80211Mode, _a1 error) *MockAccessPoint_GetPropertyMode_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockAccessPoint_GetPropertyMode_Call) RunAndReturn(run func() (gonetworkmanager.Nm80211Mode, error)) *MockAccessPoint_GetPropertyMode_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyRSNFlags provides a mock function with no fields +func (_m *MockAccessPoint) GetPropertyRSNFlags() (uint32, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyRSNFlags") + } + + var r0 uint32 + var r1 error + if rf, ok := ret.Get(0).(func() (uint32, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() uint32); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(uint32) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockAccessPoint_GetPropertyRSNFlags_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyRSNFlags' +type MockAccessPoint_GetPropertyRSNFlags_Call struct { + *mock.Call +} + +// GetPropertyRSNFlags is a helper method to define mock.On call +func (_e *MockAccessPoint_Expecter) GetPropertyRSNFlags() *MockAccessPoint_GetPropertyRSNFlags_Call { + return &MockAccessPoint_GetPropertyRSNFlags_Call{Call: _e.mock.On("GetPropertyRSNFlags")} +} + +func (_c *MockAccessPoint_GetPropertyRSNFlags_Call) Run(run func()) *MockAccessPoint_GetPropertyRSNFlags_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockAccessPoint_GetPropertyRSNFlags_Call) Return(_a0 uint32, _a1 error) *MockAccessPoint_GetPropertyRSNFlags_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockAccessPoint_GetPropertyRSNFlags_Call) RunAndReturn(run func() (uint32, error)) *MockAccessPoint_GetPropertyRSNFlags_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertySSID provides a mock function with no fields +func (_m *MockAccessPoint) GetPropertySSID() (string, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertySSID") + } + + var r0 string + var r1 error + if rf, ok := ret.Get(0).(func() (string, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockAccessPoint_GetPropertySSID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertySSID' +type MockAccessPoint_GetPropertySSID_Call struct { + *mock.Call +} + +// GetPropertySSID is a helper method to define mock.On call +func (_e *MockAccessPoint_Expecter) GetPropertySSID() *MockAccessPoint_GetPropertySSID_Call { + return &MockAccessPoint_GetPropertySSID_Call{Call: _e.mock.On("GetPropertySSID")} +} + +func (_c *MockAccessPoint_GetPropertySSID_Call) Run(run func()) *MockAccessPoint_GetPropertySSID_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockAccessPoint_GetPropertySSID_Call) Return(_a0 string, _a1 error) *MockAccessPoint_GetPropertySSID_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockAccessPoint_GetPropertySSID_Call) RunAndReturn(run func() (string, error)) *MockAccessPoint_GetPropertySSID_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyStrength provides a mock function with no fields +func (_m *MockAccessPoint) GetPropertyStrength() (uint8, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyStrength") + } + + var r0 uint8 + var r1 error + if rf, ok := ret.Get(0).(func() (uint8, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() uint8); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(uint8) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockAccessPoint_GetPropertyStrength_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyStrength' +type MockAccessPoint_GetPropertyStrength_Call struct { + *mock.Call +} + +// GetPropertyStrength is a helper method to define mock.On call +func (_e *MockAccessPoint_Expecter) GetPropertyStrength() *MockAccessPoint_GetPropertyStrength_Call { + return &MockAccessPoint_GetPropertyStrength_Call{Call: _e.mock.On("GetPropertyStrength")} +} + +func (_c *MockAccessPoint_GetPropertyStrength_Call) Run(run func()) *MockAccessPoint_GetPropertyStrength_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockAccessPoint_GetPropertyStrength_Call) Return(_a0 uint8, _a1 error) *MockAccessPoint_GetPropertyStrength_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockAccessPoint_GetPropertyStrength_Call) RunAndReturn(run func() (uint8, error)) *MockAccessPoint_GetPropertyStrength_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyWPAFlags provides a mock function with no fields +func (_m *MockAccessPoint) GetPropertyWPAFlags() (uint32, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyWPAFlags") + } + + var r0 uint32 + var r1 error + if rf, ok := ret.Get(0).(func() (uint32, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() uint32); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(uint32) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockAccessPoint_GetPropertyWPAFlags_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyWPAFlags' +type MockAccessPoint_GetPropertyWPAFlags_Call struct { + *mock.Call +} + +// GetPropertyWPAFlags is a helper method to define mock.On call +func (_e *MockAccessPoint_Expecter) GetPropertyWPAFlags() *MockAccessPoint_GetPropertyWPAFlags_Call { + return &MockAccessPoint_GetPropertyWPAFlags_Call{Call: _e.mock.On("GetPropertyWPAFlags")} +} + +func (_c *MockAccessPoint_GetPropertyWPAFlags_Call) Run(run func()) *MockAccessPoint_GetPropertyWPAFlags_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockAccessPoint_GetPropertyWPAFlags_Call) Return(_a0 uint32, _a1 error) *MockAccessPoint_GetPropertyWPAFlags_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockAccessPoint_GetPropertyWPAFlags_Call) RunAndReturn(run func() (uint32, error)) *MockAccessPoint_GetPropertyWPAFlags_Call { + _c.Call.Return(run) + return _c +} + +// MarshalJSON provides a mock function with no fields +func (_m *MockAccessPoint) MarshalJSON() ([]byte, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for MarshalJSON") + } + + var r0 []byte + var r1 error + if rf, ok := ret.Get(0).(func() ([]byte, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() []byte); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]byte) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockAccessPoint_MarshalJSON_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MarshalJSON' +type MockAccessPoint_MarshalJSON_Call struct { + *mock.Call +} + +// MarshalJSON is a helper method to define mock.On call +func (_e *MockAccessPoint_Expecter) MarshalJSON() *MockAccessPoint_MarshalJSON_Call { + return &MockAccessPoint_MarshalJSON_Call{Call: _e.mock.On("MarshalJSON")} +} + +func (_c *MockAccessPoint_MarshalJSON_Call) Run(run func()) *MockAccessPoint_MarshalJSON_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockAccessPoint_MarshalJSON_Call) Return(_a0 []byte, _a1 error) *MockAccessPoint_MarshalJSON_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockAccessPoint_MarshalJSON_Call) RunAndReturn(run func() ([]byte, error)) *MockAccessPoint_MarshalJSON_Call { + _c.Call.Return(run) + return _c +} + +// NewMockAccessPoint creates a new instance of MockAccessPoint. 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 NewMockAccessPoint(t interface { + mock.TestingT + Cleanup(func()) +}) *MockAccessPoint { + mock := &MockAccessPoint{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/github.com/Wifx/gonetworkmanager/v2/mock_ActiveConnection.go b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/github.com/Wifx/gonetworkmanager/v2/mock_ActiveConnection.go new file mode 100644 index 0000000..a4e3344 --- /dev/null +++ b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/github.com/Wifx/gonetworkmanager/v2/mock_ActiveConnection.go @@ -0,0 +1,1025 @@ +// Code generated by mockery v2.53.5. DO NOT EDIT. + +package gonetworkmanager + +import ( + gonetworkmanager "github.com/Wifx/gonetworkmanager/v2" + dbus "github.com/godbus/dbus/v5" + + mock "github.com/stretchr/testify/mock" +) + +// MockActiveConnection is an autogenerated mock type for the ActiveConnection type +type MockActiveConnection struct { + mock.Mock +} + +type MockActiveConnection_Expecter struct { + mock *mock.Mock +} + +func (_m *MockActiveConnection) EXPECT() *MockActiveConnection_Expecter { + return &MockActiveConnection_Expecter{mock: &_m.Mock} +} + +// GetPath provides a mock function with no fields +func (_m *MockActiveConnection) GetPath() dbus.ObjectPath { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPath") + } + + var r0 dbus.ObjectPath + if rf, ok := ret.Get(0).(func() dbus.ObjectPath); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(dbus.ObjectPath) + } + + return r0 +} + +// MockActiveConnection_GetPath_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPath' +type MockActiveConnection_GetPath_Call struct { + *mock.Call +} + +// GetPath is a helper method to define mock.On call +func (_e *MockActiveConnection_Expecter) GetPath() *MockActiveConnection_GetPath_Call { + return &MockActiveConnection_GetPath_Call{Call: _e.mock.On("GetPath")} +} + +func (_c *MockActiveConnection_GetPath_Call) Run(run func()) *MockActiveConnection_GetPath_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockActiveConnection_GetPath_Call) Return(_a0 dbus.ObjectPath) *MockActiveConnection_GetPath_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockActiveConnection_GetPath_Call) RunAndReturn(run func() dbus.ObjectPath) *MockActiveConnection_GetPath_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyConnection provides a mock function with no fields +func (_m *MockActiveConnection) GetPropertyConnection() (gonetworkmanager.Connection, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyConnection") + } + + var r0 gonetworkmanager.Connection + var r1 error + if rf, ok := ret.Get(0).(func() (gonetworkmanager.Connection, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() gonetworkmanager.Connection); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(gonetworkmanager.Connection) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockActiveConnection_GetPropertyConnection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyConnection' +type MockActiveConnection_GetPropertyConnection_Call struct { + *mock.Call +} + +// GetPropertyConnection is a helper method to define mock.On call +func (_e *MockActiveConnection_Expecter) GetPropertyConnection() *MockActiveConnection_GetPropertyConnection_Call { + return &MockActiveConnection_GetPropertyConnection_Call{Call: _e.mock.On("GetPropertyConnection")} +} + +func (_c *MockActiveConnection_GetPropertyConnection_Call) Run(run func()) *MockActiveConnection_GetPropertyConnection_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockActiveConnection_GetPropertyConnection_Call) Return(_a0 gonetworkmanager.Connection, _a1 error) *MockActiveConnection_GetPropertyConnection_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockActiveConnection_GetPropertyConnection_Call) RunAndReturn(run func() (gonetworkmanager.Connection, error)) *MockActiveConnection_GetPropertyConnection_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyDHCP4Config provides a mock function with no fields +func (_m *MockActiveConnection) GetPropertyDHCP4Config() (gonetworkmanager.DHCP4Config, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyDHCP4Config") + } + + var r0 gonetworkmanager.DHCP4Config + var r1 error + if rf, ok := ret.Get(0).(func() (gonetworkmanager.DHCP4Config, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() gonetworkmanager.DHCP4Config); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(gonetworkmanager.DHCP4Config) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockActiveConnection_GetPropertyDHCP4Config_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyDHCP4Config' +type MockActiveConnection_GetPropertyDHCP4Config_Call struct { + *mock.Call +} + +// GetPropertyDHCP4Config is a helper method to define mock.On call +func (_e *MockActiveConnection_Expecter) GetPropertyDHCP4Config() *MockActiveConnection_GetPropertyDHCP4Config_Call { + return &MockActiveConnection_GetPropertyDHCP4Config_Call{Call: _e.mock.On("GetPropertyDHCP4Config")} +} + +func (_c *MockActiveConnection_GetPropertyDHCP4Config_Call) Run(run func()) *MockActiveConnection_GetPropertyDHCP4Config_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockActiveConnection_GetPropertyDHCP4Config_Call) Return(_a0 gonetworkmanager.DHCP4Config, _a1 error) *MockActiveConnection_GetPropertyDHCP4Config_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockActiveConnection_GetPropertyDHCP4Config_Call) RunAndReturn(run func() (gonetworkmanager.DHCP4Config, error)) *MockActiveConnection_GetPropertyDHCP4Config_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyDHCP6Config provides a mock function with no fields +func (_m *MockActiveConnection) GetPropertyDHCP6Config() (gonetworkmanager.DHCP6Config, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyDHCP6Config") + } + + var r0 gonetworkmanager.DHCP6Config + var r1 error + if rf, ok := ret.Get(0).(func() (gonetworkmanager.DHCP6Config, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() gonetworkmanager.DHCP6Config); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(gonetworkmanager.DHCP6Config) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockActiveConnection_GetPropertyDHCP6Config_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyDHCP6Config' +type MockActiveConnection_GetPropertyDHCP6Config_Call struct { + *mock.Call +} + +// GetPropertyDHCP6Config is a helper method to define mock.On call +func (_e *MockActiveConnection_Expecter) GetPropertyDHCP6Config() *MockActiveConnection_GetPropertyDHCP6Config_Call { + return &MockActiveConnection_GetPropertyDHCP6Config_Call{Call: _e.mock.On("GetPropertyDHCP6Config")} +} + +func (_c *MockActiveConnection_GetPropertyDHCP6Config_Call) Run(run func()) *MockActiveConnection_GetPropertyDHCP6Config_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockActiveConnection_GetPropertyDHCP6Config_Call) Return(_a0 gonetworkmanager.DHCP6Config, _a1 error) *MockActiveConnection_GetPropertyDHCP6Config_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockActiveConnection_GetPropertyDHCP6Config_Call) RunAndReturn(run func() (gonetworkmanager.DHCP6Config, error)) *MockActiveConnection_GetPropertyDHCP6Config_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyDefault provides a mock function with no fields +func (_m *MockActiveConnection) GetPropertyDefault() (bool, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyDefault") + } + + var r0 bool + var r1 error + if rf, ok := ret.Get(0).(func() (bool, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() bool); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(bool) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockActiveConnection_GetPropertyDefault_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyDefault' +type MockActiveConnection_GetPropertyDefault_Call struct { + *mock.Call +} + +// GetPropertyDefault is a helper method to define mock.On call +func (_e *MockActiveConnection_Expecter) GetPropertyDefault() *MockActiveConnection_GetPropertyDefault_Call { + return &MockActiveConnection_GetPropertyDefault_Call{Call: _e.mock.On("GetPropertyDefault")} +} + +func (_c *MockActiveConnection_GetPropertyDefault_Call) Run(run func()) *MockActiveConnection_GetPropertyDefault_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockActiveConnection_GetPropertyDefault_Call) Return(_a0 bool, _a1 error) *MockActiveConnection_GetPropertyDefault_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockActiveConnection_GetPropertyDefault_Call) RunAndReturn(run func() (bool, error)) *MockActiveConnection_GetPropertyDefault_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyDefault6 provides a mock function with no fields +func (_m *MockActiveConnection) GetPropertyDefault6() (bool, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyDefault6") + } + + var r0 bool + var r1 error + if rf, ok := ret.Get(0).(func() (bool, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() bool); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(bool) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockActiveConnection_GetPropertyDefault6_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyDefault6' +type MockActiveConnection_GetPropertyDefault6_Call struct { + *mock.Call +} + +// GetPropertyDefault6 is a helper method to define mock.On call +func (_e *MockActiveConnection_Expecter) GetPropertyDefault6() *MockActiveConnection_GetPropertyDefault6_Call { + return &MockActiveConnection_GetPropertyDefault6_Call{Call: _e.mock.On("GetPropertyDefault6")} +} + +func (_c *MockActiveConnection_GetPropertyDefault6_Call) Run(run func()) *MockActiveConnection_GetPropertyDefault6_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockActiveConnection_GetPropertyDefault6_Call) Return(_a0 bool, _a1 error) *MockActiveConnection_GetPropertyDefault6_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockActiveConnection_GetPropertyDefault6_Call) RunAndReturn(run func() (bool, error)) *MockActiveConnection_GetPropertyDefault6_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyDevices provides a mock function with no fields +func (_m *MockActiveConnection) GetPropertyDevices() ([]gonetworkmanager.Device, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyDevices") + } + + var r0 []gonetworkmanager.Device + var r1 error + if rf, ok := ret.Get(0).(func() ([]gonetworkmanager.Device, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() []gonetworkmanager.Device); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]gonetworkmanager.Device) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockActiveConnection_GetPropertyDevices_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyDevices' +type MockActiveConnection_GetPropertyDevices_Call struct { + *mock.Call +} + +// GetPropertyDevices is a helper method to define mock.On call +func (_e *MockActiveConnection_Expecter) GetPropertyDevices() *MockActiveConnection_GetPropertyDevices_Call { + return &MockActiveConnection_GetPropertyDevices_Call{Call: _e.mock.On("GetPropertyDevices")} +} + +func (_c *MockActiveConnection_GetPropertyDevices_Call) Run(run func()) *MockActiveConnection_GetPropertyDevices_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockActiveConnection_GetPropertyDevices_Call) Return(_a0 []gonetworkmanager.Device, _a1 error) *MockActiveConnection_GetPropertyDevices_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockActiveConnection_GetPropertyDevices_Call) RunAndReturn(run func() ([]gonetworkmanager.Device, error)) *MockActiveConnection_GetPropertyDevices_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyID provides a mock function with no fields +func (_m *MockActiveConnection) GetPropertyID() (string, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyID") + } + + var r0 string + var r1 error + if rf, ok := ret.Get(0).(func() (string, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockActiveConnection_GetPropertyID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyID' +type MockActiveConnection_GetPropertyID_Call struct { + *mock.Call +} + +// GetPropertyID is a helper method to define mock.On call +func (_e *MockActiveConnection_Expecter) GetPropertyID() *MockActiveConnection_GetPropertyID_Call { + return &MockActiveConnection_GetPropertyID_Call{Call: _e.mock.On("GetPropertyID")} +} + +func (_c *MockActiveConnection_GetPropertyID_Call) Run(run func()) *MockActiveConnection_GetPropertyID_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockActiveConnection_GetPropertyID_Call) Return(_a0 string, _a1 error) *MockActiveConnection_GetPropertyID_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockActiveConnection_GetPropertyID_Call) RunAndReturn(run func() (string, error)) *MockActiveConnection_GetPropertyID_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyIP4Config provides a mock function with no fields +func (_m *MockActiveConnection) GetPropertyIP4Config() (gonetworkmanager.IP4Config, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyIP4Config") + } + + var r0 gonetworkmanager.IP4Config + var r1 error + if rf, ok := ret.Get(0).(func() (gonetworkmanager.IP4Config, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() gonetworkmanager.IP4Config); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(gonetworkmanager.IP4Config) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockActiveConnection_GetPropertyIP4Config_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyIP4Config' +type MockActiveConnection_GetPropertyIP4Config_Call struct { + *mock.Call +} + +// GetPropertyIP4Config is a helper method to define mock.On call +func (_e *MockActiveConnection_Expecter) GetPropertyIP4Config() *MockActiveConnection_GetPropertyIP4Config_Call { + return &MockActiveConnection_GetPropertyIP4Config_Call{Call: _e.mock.On("GetPropertyIP4Config")} +} + +func (_c *MockActiveConnection_GetPropertyIP4Config_Call) Run(run func()) *MockActiveConnection_GetPropertyIP4Config_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockActiveConnection_GetPropertyIP4Config_Call) Return(_a0 gonetworkmanager.IP4Config, _a1 error) *MockActiveConnection_GetPropertyIP4Config_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockActiveConnection_GetPropertyIP4Config_Call) RunAndReturn(run func() (gonetworkmanager.IP4Config, error)) *MockActiveConnection_GetPropertyIP4Config_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyIP6Config provides a mock function with no fields +func (_m *MockActiveConnection) GetPropertyIP6Config() (gonetworkmanager.IP6Config, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyIP6Config") + } + + var r0 gonetworkmanager.IP6Config + var r1 error + if rf, ok := ret.Get(0).(func() (gonetworkmanager.IP6Config, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() gonetworkmanager.IP6Config); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(gonetworkmanager.IP6Config) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockActiveConnection_GetPropertyIP6Config_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyIP6Config' +type MockActiveConnection_GetPropertyIP6Config_Call struct { + *mock.Call +} + +// GetPropertyIP6Config is a helper method to define mock.On call +func (_e *MockActiveConnection_Expecter) GetPropertyIP6Config() *MockActiveConnection_GetPropertyIP6Config_Call { + return &MockActiveConnection_GetPropertyIP6Config_Call{Call: _e.mock.On("GetPropertyIP6Config")} +} + +func (_c *MockActiveConnection_GetPropertyIP6Config_Call) Run(run func()) *MockActiveConnection_GetPropertyIP6Config_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockActiveConnection_GetPropertyIP6Config_Call) Return(_a0 gonetworkmanager.IP6Config, _a1 error) *MockActiveConnection_GetPropertyIP6Config_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockActiveConnection_GetPropertyIP6Config_Call) RunAndReturn(run func() (gonetworkmanager.IP6Config, error)) *MockActiveConnection_GetPropertyIP6Config_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyMaster provides a mock function with no fields +func (_m *MockActiveConnection) GetPropertyMaster() (gonetworkmanager.Device, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyMaster") + } + + var r0 gonetworkmanager.Device + var r1 error + if rf, ok := ret.Get(0).(func() (gonetworkmanager.Device, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() gonetworkmanager.Device); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(gonetworkmanager.Device) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockActiveConnection_GetPropertyMaster_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyMaster' +type MockActiveConnection_GetPropertyMaster_Call struct { + *mock.Call +} + +// GetPropertyMaster is a helper method to define mock.On call +func (_e *MockActiveConnection_Expecter) GetPropertyMaster() *MockActiveConnection_GetPropertyMaster_Call { + return &MockActiveConnection_GetPropertyMaster_Call{Call: _e.mock.On("GetPropertyMaster")} +} + +func (_c *MockActiveConnection_GetPropertyMaster_Call) Run(run func()) *MockActiveConnection_GetPropertyMaster_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockActiveConnection_GetPropertyMaster_Call) Return(_a0 gonetworkmanager.Device, _a1 error) *MockActiveConnection_GetPropertyMaster_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockActiveConnection_GetPropertyMaster_Call) RunAndReturn(run func() (gonetworkmanager.Device, error)) *MockActiveConnection_GetPropertyMaster_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertySpecificObject provides a mock function with no fields +func (_m *MockActiveConnection) GetPropertySpecificObject() (gonetworkmanager.AccessPoint, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertySpecificObject") + } + + var r0 gonetworkmanager.AccessPoint + var r1 error + if rf, ok := ret.Get(0).(func() (gonetworkmanager.AccessPoint, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() gonetworkmanager.AccessPoint); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(gonetworkmanager.AccessPoint) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockActiveConnection_GetPropertySpecificObject_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertySpecificObject' +type MockActiveConnection_GetPropertySpecificObject_Call struct { + *mock.Call +} + +// GetPropertySpecificObject is a helper method to define mock.On call +func (_e *MockActiveConnection_Expecter) GetPropertySpecificObject() *MockActiveConnection_GetPropertySpecificObject_Call { + return &MockActiveConnection_GetPropertySpecificObject_Call{Call: _e.mock.On("GetPropertySpecificObject")} +} + +func (_c *MockActiveConnection_GetPropertySpecificObject_Call) Run(run func()) *MockActiveConnection_GetPropertySpecificObject_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockActiveConnection_GetPropertySpecificObject_Call) Return(_a0 gonetworkmanager.AccessPoint, _a1 error) *MockActiveConnection_GetPropertySpecificObject_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockActiveConnection_GetPropertySpecificObject_Call) RunAndReturn(run func() (gonetworkmanager.AccessPoint, error)) *MockActiveConnection_GetPropertySpecificObject_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyState provides a mock function with no fields +func (_m *MockActiveConnection) GetPropertyState() (gonetworkmanager.NmActiveConnectionState, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyState") + } + + var r0 gonetworkmanager.NmActiveConnectionState + var r1 error + if rf, ok := ret.Get(0).(func() (gonetworkmanager.NmActiveConnectionState, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() gonetworkmanager.NmActiveConnectionState); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(gonetworkmanager.NmActiveConnectionState) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockActiveConnection_GetPropertyState_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyState' +type MockActiveConnection_GetPropertyState_Call struct { + *mock.Call +} + +// GetPropertyState is a helper method to define mock.On call +func (_e *MockActiveConnection_Expecter) GetPropertyState() *MockActiveConnection_GetPropertyState_Call { + return &MockActiveConnection_GetPropertyState_Call{Call: _e.mock.On("GetPropertyState")} +} + +func (_c *MockActiveConnection_GetPropertyState_Call) Run(run func()) *MockActiveConnection_GetPropertyState_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockActiveConnection_GetPropertyState_Call) Return(_a0 gonetworkmanager.NmActiveConnectionState, _a1 error) *MockActiveConnection_GetPropertyState_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockActiveConnection_GetPropertyState_Call) RunAndReturn(run func() (gonetworkmanager.NmActiveConnectionState, error)) *MockActiveConnection_GetPropertyState_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyStateFlags provides a mock function with no fields +func (_m *MockActiveConnection) GetPropertyStateFlags() (uint32, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyStateFlags") + } + + var r0 uint32 + var r1 error + if rf, ok := ret.Get(0).(func() (uint32, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() uint32); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(uint32) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockActiveConnection_GetPropertyStateFlags_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyStateFlags' +type MockActiveConnection_GetPropertyStateFlags_Call struct { + *mock.Call +} + +// GetPropertyStateFlags is a helper method to define mock.On call +func (_e *MockActiveConnection_Expecter) GetPropertyStateFlags() *MockActiveConnection_GetPropertyStateFlags_Call { + return &MockActiveConnection_GetPropertyStateFlags_Call{Call: _e.mock.On("GetPropertyStateFlags")} +} + +func (_c *MockActiveConnection_GetPropertyStateFlags_Call) Run(run func()) *MockActiveConnection_GetPropertyStateFlags_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockActiveConnection_GetPropertyStateFlags_Call) Return(_a0 uint32, _a1 error) *MockActiveConnection_GetPropertyStateFlags_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockActiveConnection_GetPropertyStateFlags_Call) RunAndReturn(run func() (uint32, error)) *MockActiveConnection_GetPropertyStateFlags_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyType provides a mock function with no fields +func (_m *MockActiveConnection) GetPropertyType() (string, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyType") + } + + var r0 string + var r1 error + if rf, ok := ret.Get(0).(func() (string, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockActiveConnection_GetPropertyType_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyType' +type MockActiveConnection_GetPropertyType_Call struct { + *mock.Call +} + +// GetPropertyType is a helper method to define mock.On call +func (_e *MockActiveConnection_Expecter) GetPropertyType() *MockActiveConnection_GetPropertyType_Call { + return &MockActiveConnection_GetPropertyType_Call{Call: _e.mock.On("GetPropertyType")} +} + +func (_c *MockActiveConnection_GetPropertyType_Call) Run(run func()) *MockActiveConnection_GetPropertyType_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockActiveConnection_GetPropertyType_Call) Return(_a0 string, _a1 error) *MockActiveConnection_GetPropertyType_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockActiveConnection_GetPropertyType_Call) RunAndReturn(run func() (string, error)) *MockActiveConnection_GetPropertyType_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyUUID provides a mock function with no fields +func (_m *MockActiveConnection) GetPropertyUUID() (string, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyUUID") + } + + var r0 string + var r1 error + if rf, ok := ret.Get(0).(func() (string, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockActiveConnection_GetPropertyUUID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyUUID' +type MockActiveConnection_GetPropertyUUID_Call struct { + *mock.Call +} + +// GetPropertyUUID is a helper method to define mock.On call +func (_e *MockActiveConnection_Expecter) GetPropertyUUID() *MockActiveConnection_GetPropertyUUID_Call { + return &MockActiveConnection_GetPropertyUUID_Call{Call: _e.mock.On("GetPropertyUUID")} +} + +func (_c *MockActiveConnection_GetPropertyUUID_Call) Run(run func()) *MockActiveConnection_GetPropertyUUID_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockActiveConnection_GetPropertyUUID_Call) Return(_a0 string, _a1 error) *MockActiveConnection_GetPropertyUUID_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockActiveConnection_GetPropertyUUID_Call) RunAndReturn(run func() (string, error)) *MockActiveConnection_GetPropertyUUID_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyVPN provides a mock function with no fields +func (_m *MockActiveConnection) GetPropertyVPN() (bool, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyVPN") + } + + var r0 bool + var r1 error + if rf, ok := ret.Get(0).(func() (bool, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() bool); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(bool) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockActiveConnection_GetPropertyVPN_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyVPN' +type MockActiveConnection_GetPropertyVPN_Call struct { + *mock.Call +} + +// GetPropertyVPN is a helper method to define mock.On call +func (_e *MockActiveConnection_Expecter) GetPropertyVPN() *MockActiveConnection_GetPropertyVPN_Call { + return &MockActiveConnection_GetPropertyVPN_Call{Call: _e.mock.On("GetPropertyVPN")} +} + +func (_c *MockActiveConnection_GetPropertyVPN_Call) Run(run func()) *MockActiveConnection_GetPropertyVPN_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockActiveConnection_GetPropertyVPN_Call) Return(_a0 bool, _a1 error) *MockActiveConnection_GetPropertyVPN_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockActiveConnection_GetPropertyVPN_Call) RunAndReturn(run func() (bool, error)) *MockActiveConnection_GetPropertyVPN_Call { + _c.Call.Return(run) + return _c +} + +// SubscribeState provides a mock function with given fields: receiver, exit +func (_m *MockActiveConnection) SubscribeState(receiver chan gonetworkmanager.StateChange, exit chan struct{}) error { + ret := _m.Called(receiver, exit) + + if len(ret) == 0 { + panic("no return value specified for SubscribeState") + } + + var r0 error + if rf, ok := ret.Get(0).(func(chan gonetworkmanager.StateChange, chan struct{}) error); ok { + r0 = rf(receiver, exit) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockActiveConnection_SubscribeState_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SubscribeState' +type MockActiveConnection_SubscribeState_Call struct { + *mock.Call +} + +// SubscribeState is a helper method to define mock.On call +// - receiver chan gonetworkmanager.StateChange +// - exit chan struct{} +func (_e *MockActiveConnection_Expecter) SubscribeState(receiver interface{}, exit interface{}) *MockActiveConnection_SubscribeState_Call { + return &MockActiveConnection_SubscribeState_Call{Call: _e.mock.On("SubscribeState", receiver, exit)} +} + +func (_c *MockActiveConnection_SubscribeState_Call) Run(run func(receiver chan gonetworkmanager.StateChange, exit chan struct{})) *MockActiveConnection_SubscribeState_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(chan gonetworkmanager.StateChange), args[1].(chan struct{})) + }) + return _c +} + +func (_c *MockActiveConnection_SubscribeState_Call) Return(err error) *MockActiveConnection_SubscribeState_Call { + _c.Call.Return(err) + return _c +} + +func (_c *MockActiveConnection_SubscribeState_Call) RunAndReturn(run func(chan gonetworkmanager.StateChange, chan struct{}) error) *MockActiveConnection_SubscribeState_Call { + _c.Call.Return(run) + return _c +} + +// NewMockActiveConnection creates a new instance of MockActiveConnection. 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 NewMockActiveConnection(t interface { + mock.TestingT + Cleanup(func()) +}) *MockActiveConnection { + mock := &MockActiveConnection{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/github.com/Wifx/gonetworkmanager/v2/mock_Connection.go b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/github.com/Wifx/gonetworkmanager/v2/mock_Connection.go new file mode 100644 index 0000000..84f59e1 --- /dev/null +++ b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/github.com/Wifx/gonetworkmanager/v2/mock_Connection.go @@ -0,0 +1,646 @@ +// Code generated by mockery v2.53.5. DO NOT EDIT. + +package gonetworkmanager + +import ( + gonetworkmanager "github.com/Wifx/gonetworkmanager/v2" + dbus "github.com/godbus/dbus/v5" + + mock "github.com/stretchr/testify/mock" +) + +// MockConnection is an autogenerated mock type for the Connection type +type MockConnection struct { + mock.Mock +} + +type MockConnection_Expecter struct { + mock *mock.Mock +} + +func (_m *MockConnection) EXPECT() *MockConnection_Expecter { + return &MockConnection_Expecter{mock: &_m.Mock} +} + +// ClearSecrets provides a mock function with no fields +func (_m *MockConnection) ClearSecrets() error { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for ClearSecrets") + } + + var r0 error + if rf, ok := ret.Get(0).(func() error); ok { + r0 = rf() + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockConnection_ClearSecrets_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClearSecrets' +type MockConnection_ClearSecrets_Call struct { + *mock.Call +} + +// ClearSecrets is a helper method to define mock.On call +func (_e *MockConnection_Expecter) ClearSecrets() *MockConnection_ClearSecrets_Call { + return &MockConnection_ClearSecrets_Call{Call: _e.mock.On("ClearSecrets")} +} + +func (_c *MockConnection_ClearSecrets_Call) Run(run func()) *MockConnection_ClearSecrets_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockConnection_ClearSecrets_Call) Return(_a0 error) *MockConnection_ClearSecrets_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockConnection_ClearSecrets_Call) RunAndReturn(run func() error) *MockConnection_ClearSecrets_Call { + _c.Call.Return(run) + return _c +} + +// Delete provides a mock function with no fields +func (_m *MockConnection) Delete() error { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Delete") + } + + var r0 error + if rf, ok := ret.Get(0).(func() error); ok { + r0 = rf() + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockConnection_Delete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Delete' +type MockConnection_Delete_Call struct { + *mock.Call +} + +// Delete is a helper method to define mock.On call +func (_e *MockConnection_Expecter) Delete() *MockConnection_Delete_Call { + return &MockConnection_Delete_Call{Call: _e.mock.On("Delete")} +} + +func (_c *MockConnection_Delete_Call) Run(run func()) *MockConnection_Delete_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockConnection_Delete_Call) Return(_a0 error) *MockConnection_Delete_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockConnection_Delete_Call) RunAndReturn(run func() error) *MockConnection_Delete_Call { + _c.Call.Return(run) + return _c +} + +// GetPath provides a mock function with no fields +func (_m *MockConnection) GetPath() dbus.ObjectPath { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPath") + } + + var r0 dbus.ObjectPath + if rf, ok := ret.Get(0).(func() dbus.ObjectPath); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(dbus.ObjectPath) + } + + return r0 +} + +// MockConnection_GetPath_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPath' +type MockConnection_GetPath_Call struct { + *mock.Call +} + +// GetPath is a helper method to define mock.On call +func (_e *MockConnection_Expecter) GetPath() *MockConnection_GetPath_Call { + return &MockConnection_GetPath_Call{Call: _e.mock.On("GetPath")} +} + +func (_c *MockConnection_GetPath_Call) Run(run func()) *MockConnection_GetPath_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockConnection_GetPath_Call) Return(_a0 dbus.ObjectPath) *MockConnection_GetPath_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockConnection_GetPath_Call) RunAndReturn(run func() dbus.ObjectPath) *MockConnection_GetPath_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyFilename provides a mock function with no fields +func (_m *MockConnection) GetPropertyFilename() (string, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyFilename") + } + + var r0 string + var r1 error + if rf, ok := ret.Get(0).(func() (string, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockConnection_GetPropertyFilename_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyFilename' +type MockConnection_GetPropertyFilename_Call struct { + *mock.Call +} + +// GetPropertyFilename is a helper method to define mock.On call +func (_e *MockConnection_Expecter) GetPropertyFilename() *MockConnection_GetPropertyFilename_Call { + return &MockConnection_GetPropertyFilename_Call{Call: _e.mock.On("GetPropertyFilename")} +} + +func (_c *MockConnection_GetPropertyFilename_Call) Run(run func()) *MockConnection_GetPropertyFilename_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockConnection_GetPropertyFilename_Call) Return(_a0 string, _a1 error) *MockConnection_GetPropertyFilename_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockConnection_GetPropertyFilename_Call) RunAndReturn(run func() (string, error)) *MockConnection_GetPropertyFilename_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyFlags provides a mock function with no fields +func (_m *MockConnection) GetPropertyFlags() (uint32, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyFlags") + } + + var r0 uint32 + var r1 error + if rf, ok := ret.Get(0).(func() (uint32, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() uint32); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(uint32) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockConnection_GetPropertyFlags_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyFlags' +type MockConnection_GetPropertyFlags_Call struct { + *mock.Call +} + +// GetPropertyFlags is a helper method to define mock.On call +func (_e *MockConnection_Expecter) GetPropertyFlags() *MockConnection_GetPropertyFlags_Call { + return &MockConnection_GetPropertyFlags_Call{Call: _e.mock.On("GetPropertyFlags")} +} + +func (_c *MockConnection_GetPropertyFlags_Call) Run(run func()) *MockConnection_GetPropertyFlags_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockConnection_GetPropertyFlags_Call) Return(_a0 uint32, _a1 error) *MockConnection_GetPropertyFlags_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockConnection_GetPropertyFlags_Call) RunAndReturn(run func() (uint32, error)) *MockConnection_GetPropertyFlags_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyUnsaved provides a mock function with no fields +func (_m *MockConnection) GetPropertyUnsaved() (bool, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyUnsaved") + } + + var r0 bool + var r1 error + if rf, ok := ret.Get(0).(func() (bool, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() bool); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(bool) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockConnection_GetPropertyUnsaved_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyUnsaved' +type MockConnection_GetPropertyUnsaved_Call struct { + *mock.Call +} + +// GetPropertyUnsaved is a helper method to define mock.On call +func (_e *MockConnection_Expecter) GetPropertyUnsaved() *MockConnection_GetPropertyUnsaved_Call { + return &MockConnection_GetPropertyUnsaved_Call{Call: _e.mock.On("GetPropertyUnsaved")} +} + +func (_c *MockConnection_GetPropertyUnsaved_Call) Run(run func()) *MockConnection_GetPropertyUnsaved_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockConnection_GetPropertyUnsaved_Call) Return(_a0 bool, _a1 error) *MockConnection_GetPropertyUnsaved_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockConnection_GetPropertyUnsaved_Call) RunAndReturn(run func() (bool, error)) *MockConnection_GetPropertyUnsaved_Call { + _c.Call.Return(run) + return _c +} + +// GetSecrets provides a mock function with given fields: settingName +func (_m *MockConnection) GetSecrets(settingName string) (gonetworkmanager.ConnectionSettings, error) { + ret := _m.Called(settingName) + + if len(ret) == 0 { + panic("no return value specified for GetSecrets") + } + + var r0 gonetworkmanager.ConnectionSettings + var r1 error + if rf, ok := ret.Get(0).(func(string) (gonetworkmanager.ConnectionSettings, error)); ok { + return rf(settingName) + } + if rf, ok := ret.Get(0).(func(string) gonetworkmanager.ConnectionSettings); ok { + r0 = rf(settingName) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(gonetworkmanager.ConnectionSettings) + } + } + + if rf, ok := ret.Get(1).(func(string) error); ok { + r1 = rf(settingName) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockConnection_GetSecrets_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSecrets' +type MockConnection_GetSecrets_Call struct { + *mock.Call +} + +// GetSecrets is a helper method to define mock.On call +// - settingName string +func (_e *MockConnection_Expecter) GetSecrets(settingName interface{}) *MockConnection_GetSecrets_Call { + return &MockConnection_GetSecrets_Call{Call: _e.mock.On("GetSecrets", settingName)} +} + +func (_c *MockConnection_GetSecrets_Call) Run(run func(settingName string)) *MockConnection_GetSecrets_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *MockConnection_GetSecrets_Call) Return(_a0 gonetworkmanager.ConnectionSettings, _a1 error) *MockConnection_GetSecrets_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockConnection_GetSecrets_Call) RunAndReturn(run func(string) (gonetworkmanager.ConnectionSettings, error)) *MockConnection_GetSecrets_Call { + _c.Call.Return(run) + return _c +} + +// GetSettings provides a mock function with no fields +func (_m *MockConnection) GetSettings() (gonetworkmanager.ConnectionSettings, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetSettings") + } + + var r0 gonetworkmanager.ConnectionSettings + var r1 error + if rf, ok := ret.Get(0).(func() (gonetworkmanager.ConnectionSettings, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() gonetworkmanager.ConnectionSettings); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(gonetworkmanager.ConnectionSettings) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockConnection_GetSettings_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSettings' +type MockConnection_GetSettings_Call struct { + *mock.Call +} + +// GetSettings is a helper method to define mock.On call +func (_e *MockConnection_Expecter) GetSettings() *MockConnection_GetSettings_Call { + return &MockConnection_GetSettings_Call{Call: _e.mock.On("GetSettings")} +} + +func (_c *MockConnection_GetSettings_Call) Run(run func()) *MockConnection_GetSettings_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockConnection_GetSettings_Call) Return(_a0 gonetworkmanager.ConnectionSettings, _a1 error) *MockConnection_GetSettings_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockConnection_GetSettings_Call) RunAndReturn(run func() (gonetworkmanager.ConnectionSettings, error)) *MockConnection_GetSettings_Call { + _c.Call.Return(run) + return _c +} + +// MarshalJSON provides a mock function with no fields +func (_m *MockConnection) MarshalJSON() ([]byte, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for MarshalJSON") + } + + var r0 []byte + var r1 error + if rf, ok := ret.Get(0).(func() ([]byte, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() []byte); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]byte) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockConnection_MarshalJSON_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MarshalJSON' +type MockConnection_MarshalJSON_Call struct { + *mock.Call +} + +// MarshalJSON is a helper method to define mock.On call +func (_e *MockConnection_Expecter) MarshalJSON() *MockConnection_MarshalJSON_Call { + return &MockConnection_MarshalJSON_Call{Call: _e.mock.On("MarshalJSON")} +} + +func (_c *MockConnection_MarshalJSON_Call) Run(run func()) *MockConnection_MarshalJSON_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockConnection_MarshalJSON_Call) Return(_a0 []byte, _a1 error) *MockConnection_MarshalJSON_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockConnection_MarshalJSON_Call) RunAndReturn(run func() ([]byte, error)) *MockConnection_MarshalJSON_Call { + _c.Call.Return(run) + return _c +} + +// Save provides a mock function with no fields +func (_m *MockConnection) Save() error { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Save") + } + + var r0 error + if rf, ok := ret.Get(0).(func() error); ok { + r0 = rf() + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockConnection_Save_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Save' +type MockConnection_Save_Call struct { + *mock.Call +} + +// Save is a helper method to define mock.On call +func (_e *MockConnection_Expecter) Save() *MockConnection_Save_Call { + return &MockConnection_Save_Call{Call: _e.mock.On("Save")} +} + +func (_c *MockConnection_Save_Call) Run(run func()) *MockConnection_Save_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockConnection_Save_Call) Return(_a0 error) *MockConnection_Save_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockConnection_Save_Call) RunAndReturn(run func() error) *MockConnection_Save_Call { + _c.Call.Return(run) + return _c +} + +// Update provides a mock function with given fields: settings +func (_m *MockConnection) Update(settings gonetworkmanager.ConnectionSettings) error { + ret := _m.Called(settings) + + if len(ret) == 0 { + panic("no return value specified for Update") + } + + var r0 error + if rf, ok := ret.Get(0).(func(gonetworkmanager.ConnectionSettings) error); ok { + r0 = rf(settings) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockConnection_Update_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Update' +type MockConnection_Update_Call struct { + *mock.Call +} + +// Update is a helper method to define mock.On call +// - settings gonetworkmanager.ConnectionSettings +func (_e *MockConnection_Expecter) Update(settings interface{}) *MockConnection_Update_Call { + return &MockConnection_Update_Call{Call: _e.mock.On("Update", settings)} +} + +func (_c *MockConnection_Update_Call) Run(run func(settings gonetworkmanager.ConnectionSettings)) *MockConnection_Update_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(gonetworkmanager.ConnectionSettings)) + }) + return _c +} + +func (_c *MockConnection_Update_Call) Return(_a0 error) *MockConnection_Update_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockConnection_Update_Call) RunAndReturn(run func(gonetworkmanager.ConnectionSettings) error) *MockConnection_Update_Call { + _c.Call.Return(run) + return _c +} + +// UpdateUnsaved provides a mock function with given fields: settings +func (_m *MockConnection) UpdateUnsaved(settings gonetworkmanager.ConnectionSettings) error { + ret := _m.Called(settings) + + if len(ret) == 0 { + panic("no return value specified for UpdateUnsaved") + } + + var r0 error + if rf, ok := ret.Get(0).(func(gonetworkmanager.ConnectionSettings) error); ok { + r0 = rf(settings) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockConnection_UpdateUnsaved_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateUnsaved' +type MockConnection_UpdateUnsaved_Call struct { + *mock.Call +} + +// UpdateUnsaved is a helper method to define mock.On call +// - settings gonetworkmanager.ConnectionSettings +func (_e *MockConnection_Expecter) UpdateUnsaved(settings interface{}) *MockConnection_UpdateUnsaved_Call { + return &MockConnection_UpdateUnsaved_Call{Call: _e.mock.On("UpdateUnsaved", settings)} +} + +func (_c *MockConnection_UpdateUnsaved_Call) Run(run func(settings gonetworkmanager.ConnectionSettings)) *MockConnection_UpdateUnsaved_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(gonetworkmanager.ConnectionSettings)) + }) + return _c +} + +func (_c *MockConnection_UpdateUnsaved_Call) Return(_a0 error) *MockConnection_UpdateUnsaved_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockConnection_UpdateUnsaved_Call) RunAndReturn(run func(gonetworkmanager.ConnectionSettings) error) *MockConnection_UpdateUnsaved_Call { + _c.Call.Return(run) + return _c +} + +// NewMockConnection creates a new instance of MockConnection. 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 NewMockConnection(t interface { + mock.TestingT + Cleanup(func()) +}) *MockConnection { + mock := &MockConnection{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/github.com/Wifx/gonetworkmanager/v2/mock_Device.go b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/github.com/Wifx/gonetworkmanager/v2/mock_Device.go new file mode 100644 index 0000000..b2fc0b5 --- /dev/null +++ b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/github.com/Wifx/gonetworkmanager/v2/mock_Device.go @@ -0,0 +1,1638 @@ +// Code generated by mockery v2.53.5. DO NOT EDIT. + +package gonetworkmanager + +import ( + gonetworkmanager "github.com/Wifx/gonetworkmanager/v2" + dbus "github.com/godbus/dbus/v5" + + mock "github.com/stretchr/testify/mock" +) + +// MockDevice is an autogenerated mock type for the Device type +type MockDevice struct { + mock.Mock +} + +type MockDevice_Expecter struct { + mock *mock.Mock +} + +func (_m *MockDevice) EXPECT() *MockDevice_Expecter { + return &MockDevice_Expecter{mock: &_m.Mock} +} + +// Delete provides a mock function with no fields +func (_m *MockDevice) Delete() error { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Delete") + } + + var r0 error + if rf, ok := ret.Get(0).(func() error); ok { + r0 = rf() + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockDevice_Delete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Delete' +type MockDevice_Delete_Call struct { + *mock.Call +} + +// Delete is a helper method to define mock.On call +func (_e *MockDevice_Expecter) Delete() *MockDevice_Delete_Call { + return &MockDevice_Delete_Call{Call: _e.mock.On("Delete")} +} + +func (_c *MockDevice_Delete_Call) Run(run func()) *MockDevice_Delete_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockDevice_Delete_Call) Return(_a0 error) *MockDevice_Delete_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockDevice_Delete_Call) RunAndReturn(run func() error) *MockDevice_Delete_Call { + _c.Call.Return(run) + return _c +} + +// Disconnect provides a mock function with no fields +func (_m *MockDevice) Disconnect() error { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Disconnect") + } + + var r0 error + if rf, ok := ret.Get(0).(func() error); ok { + r0 = rf() + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockDevice_Disconnect_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Disconnect' +type MockDevice_Disconnect_Call struct { + *mock.Call +} + +// Disconnect is a helper method to define mock.On call +func (_e *MockDevice_Expecter) Disconnect() *MockDevice_Disconnect_Call { + return &MockDevice_Disconnect_Call{Call: _e.mock.On("Disconnect")} +} + +func (_c *MockDevice_Disconnect_Call) Run(run func()) *MockDevice_Disconnect_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockDevice_Disconnect_Call) Return(_a0 error) *MockDevice_Disconnect_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockDevice_Disconnect_Call) RunAndReturn(run func() error) *MockDevice_Disconnect_Call { + _c.Call.Return(run) + return _c +} + +// GetPath provides a mock function with no fields +func (_m *MockDevice) GetPath() dbus.ObjectPath { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPath") + } + + var r0 dbus.ObjectPath + if rf, ok := ret.Get(0).(func() dbus.ObjectPath); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(dbus.ObjectPath) + } + + return r0 +} + +// MockDevice_GetPath_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPath' +type MockDevice_GetPath_Call struct { + *mock.Call +} + +// GetPath is a helper method to define mock.On call +func (_e *MockDevice_Expecter) GetPath() *MockDevice_GetPath_Call { + return &MockDevice_GetPath_Call{Call: _e.mock.On("GetPath")} +} + +func (_c *MockDevice_GetPath_Call) Run(run func()) *MockDevice_GetPath_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockDevice_GetPath_Call) Return(_a0 dbus.ObjectPath) *MockDevice_GetPath_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockDevice_GetPath_Call) RunAndReturn(run func() dbus.ObjectPath) *MockDevice_GetPath_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyActiveConnection provides a mock function with no fields +func (_m *MockDevice) GetPropertyActiveConnection() (gonetworkmanager.ActiveConnection, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyActiveConnection") + } + + var r0 gonetworkmanager.ActiveConnection + var r1 error + if rf, ok := ret.Get(0).(func() (gonetworkmanager.ActiveConnection, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() gonetworkmanager.ActiveConnection); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(gonetworkmanager.ActiveConnection) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDevice_GetPropertyActiveConnection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyActiveConnection' +type MockDevice_GetPropertyActiveConnection_Call struct { + *mock.Call +} + +// GetPropertyActiveConnection is a helper method to define mock.On call +func (_e *MockDevice_Expecter) GetPropertyActiveConnection() *MockDevice_GetPropertyActiveConnection_Call { + return &MockDevice_GetPropertyActiveConnection_Call{Call: _e.mock.On("GetPropertyActiveConnection")} +} + +func (_c *MockDevice_GetPropertyActiveConnection_Call) Run(run func()) *MockDevice_GetPropertyActiveConnection_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockDevice_GetPropertyActiveConnection_Call) Return(_a0 gonetworkmanager.ActiveConnection, _a1 error) *MockDevice_GetPropertyActiveConnection_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDevice_GetPropertyActiveConnection_Call) RunAndReturn(run func() (gonetworkmanager.ActiveConnection, error)) *MockDevice_GetPropertyActiveConnection_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyAutoConnect provides a mock function with no fields +func (_m *MockDevice) GetPropertyAutoConnect() (bool, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyAutoConnect") + } + + var r0 bool + var r1 error + if rf, ok := ret.Get(0).(func() (bool, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() bool); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(bool) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDevice_GetPropertyAutoConnect_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyAutoConnect' +type MockDevice_GetPropertyAutoConnect_Call struct { + *mock.Call +} + +// GetPropertyAutoConnect is a helper method to define mock.On call +func (_e *MockDevice_Expecter) GetPropertyAutoConnect() *MockDevice_GetPropertyAutoConnect_Call { + return &MockDevice_GetPropertyAutoConnect_Call{Call: _e.mock.On("GetPropertyAutoConnect")} +} + +func (_c *MockDevice_GetPropertyAutoConnect_Call) Run(run func()) *MockDevice_GetPropertyAutoConnect_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockDevice_GetPropertyAutoConnect_Call) Return(_a0 bool, _a1 error) *MockDevice_GetPropertyAutoConnect_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDevice_GetPropertyAutoConnect_Call) RunAndReturn(run func() (bool, error)) *MockDevice_GetPropertyAutoConnect_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyAvailableConnections provides a mock function with no fields +func (_m *MockDevice) GetPropertyAvailableConnections() ([]gonetworkmanager.Connection, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyAvailableConnections") + } + + var r0 []gonetworkmanager.Connection + var r1 error + if rf, ok := ret.Get(0).(func() ([]gonetworkmanager.Connection, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() []gonetworkmanager.Connection); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]gonetworkmanager.Connection) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDevice_GetPropertyAvailableConnections_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyAvailableConnections' +type MockDevice_GetPropertyAvailableConnections_Call struct { + *mock.Call +} + +// GetPropertyAvailableConnections is a helper method to define mock.On call +func (_e *MockDevice_Expecter) GetPropertyAvailableConnections() *MockDevice_GetPropertyAvailableConnections_Call { + return &MockDevice_GetPropertyAvailableConnections_Call{Call: _e.mock.On("GetPropertyAvailableConnections")} +} + +func (_c *MockDevice_GetPropertyAvailableConnections_Call) Run(run func()) *MockDevice_GetPropertyAvailableConnections_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockDevice_GetPropertyAvailableConnections_Call) Return(_a0 []gonetworkmanager.Connection, _a1 error) *MockDevice_GetPropertyAvailableConnections_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDevice_GetPropertyAvailableConnections_Call) RunAndReturn(run func() ([]gonetworkmanager.Connection, error)) *MockDevice_GetPropertyAvailableConnections_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyDHCP4Config provides a mock function with no fields +func (_m *MockDevice) GetPropertyDHCP4Config() (gonetworkmanager.DHCP4Config, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyDHCP4Config") + } + + var r0 gonetworkmanager.DHCP4Config + var r1 error + if rf, ok := ret.Get(0).(func() (gonetworkmanager.DHCP4Config, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() gonetworkmanager.DHCP4Config); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(gonetworkmanager.DHCP4Config) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDevice_GetPropertyDHCP4Config_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyDHCP4Config' +type MockDevice_GetPropertyDHCP4Config_Call struct { + *mock.Call +} + +// GetPropertyDHCP4Config is a helper method to define mock.On call +func (_e *MockDevice_Expecter) GetPropertyDHCP4Config() *MockDevice_GetPropertyDHCP4Config_Call { + return &MockDevice_GetPropertyDHCP4Config_Call{Call: _e.mock.On("GetPropertyDHCP4Config")} +} + +func (_c *MockDevice_GetPropertyDHCP4Config_Call) Run(run func()) *MockDevice_GetPropertyDHCP4Config_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockDevice_GetPropertyDHCP4Config_Call) Return(_a0 gonetworkmanager.DHCP4Config, _a1 error) *MockDevice_GetPropertyDHCP4Config_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDevice_GetPropertyDHCP4Config_Call) RunAndReturn(run func() (gonetworkmanager.DHCP4Config, error)) *MockDevice_GetPropertyDHCP4Config_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyDHCP6Config provides a mock function with no fields +func (_m *MockDevice) GetPropertyDHCP6Config() (gonetworkmanager.DHCP6Config, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyDHCP6Config") + } + + var r0 gonetworkmanager.DHCP6Config + var r1 error + if rf, ok := ret.Get(0).(func() (gonetworkmanager.DHCP6Config, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() gonetworkmanager.DHCP6Config); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(gonetworkmanager.DHCP6Config) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDevice_GetPropertyDHCP6Config_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyDHCP6Config' +type MockDevice_GetPropertyDHCP6Config_Call struct { + *mock.Call +} + +// GetPropertyDHCP6Config is a helper method to define mock.On call +func (_e *MockDevice_Expecter) GetPropertyDHCP6Config() *MockDevice_GetPropertyDHCP6Config_Call { + return &MockDevice_GetPropertyDHCP6Config_Call{Call: _e.mock.On("GetPropertyDHCP6Config")} +} + +func (_c *MockDevice_GetPropertyDHCP6Config_Call) Run(run func()) *MockDevice_GetPropertyDHCP6Config_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockDevice_GetPropertyDHCP6Config_Call) Return(_a0 gonetworkmanager.DHCP6Config, _a1 error) *MockDevice_GetPropertyDHCP6Config_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDevice_GetPropertyDHCP6Config_Call) RunAndReturn(run func() (gonetworkmanager.DHCP6Config, error)) *MockDevice_GetPropertyDHCP6Config_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyDeviceType provides a mock function with no fields +func (_m *MockDevice) GetPropertyDeviceType() (gonetworkmanager.NmDeviceType, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyDeviceType") + } + + var r0 gonetworkmanager.NmDeviceType + var r1 error + if rf, ok := ret.Get(0).(func() (gonetworkmanager.NmDeviceType, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() gonetworkmanager.NmDeviceType); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(gonetworkmanager.NmDeviceType) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDevice_GetPropertyDeviceType_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyDeviceType' +type MockDevice_GetPropertyDeviceType_Call struct { + *mock.Call +} + +// GetPropertyDeviceType is a helper method to define mock.On call +func (_e *MockDevice_Expecter) GetPropertyDeviceType() *MockDevice_GetPropertyDeviceType_Call { + return &MockDevice_GetPropertyDeviceType_Call{Call: _e.mock.On("GetPropertyDeviceType")} +} + +func (_c *MockDevice_GetPropertyDeviceType_Call) Run(run func()) *MockDevice_GetPropertyDeviceType_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockDevice_GetPropertyDeviceType_Call) Return(_a0 gonetworkmanager.NmDeviceType, _a1 error) *MockDevice_GetPropertyDeviceType_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDevice_GetPropertyDeviceType_Call) RunAndReturn(run func() (gonetworkmanager.NmDeviceType, error)) *MockDevice_GetPropertyDeviceType_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyDriver provides a mock function with no fields +func (_m *MockDevice) GetPropertyDriver() (string, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyDriver") + } + + var r0 string + var r1 error + if rf, ok := ret.Get(0).(func() (string, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDevice_GetPropertyDriver_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyDriver' +type MockDevice_GetPropertyDriver_Call struct { + *mock.Call +} + +// GetPropertyDriver is a helper method to define mock.On call +func (_e *MockDevice_Expecter) GetPropertyDriver() *MockDevice_GetPropertyDriver_Call { + return &MockDevice_GetPropertyDriver_Call{Call: _e.mock.On("GetPropertyDriver")} +} + +func (_c *MockDevice_GetPropertyDriver_Call) Run(run func()) *MockDevice_GetPropertyDriver_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockDevice_GetPropertyDriver_Call) Return(_a0 string, _a1 error) *MockDevice_GetPropertyDriver_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDevice_GetPropertyDriver_Call) RunAndReturn(run func() (string, error)) *MockDevice_GetPropertyDriver_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyDriverVersion provides a mock function with no fields +func (_m *MockDevice) GetPropertyDriverVersion() (string, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyDriverVersion") + } + + var r0 string + var r1 error + if rf, ok := ret.Get(0).(func() (string, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDevice_GetPropertyDriverVersion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyDriverVersion' +type MockDevice_GetPropertyDriverVersion_Call struct { + *mock.Call +} + +// GetPropertyDriverVersion is a helper method to define mock.On call +func (_e *MockDevice_Expecter) GetPropertyDriverVersion() *MockDevice_GetPropertyDriverVersion_Call { + return &MockDevice_GetPropertyDriverVersion_Call{Call: _e.mock.On("GetPropertyDriverVersion")} +} + +func (_c *MockDevice_GetPropertyDriverVersion_Call) Run(run func()) *MockDevice_GetPropertyDriverVersion_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockDevice_GetPropertyDriverVersion_Call) Return(_a0 string, _a1 error) *MockDevice_GetPropertyDriverVersion_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDevice_GetPropertyDriverVersion_Call) RunAndReturn(run func() (string, error)) *MockDevice_GetPropertyDriverVersion_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyFirmwareMissing provides a mock function with no fields +func (_m *MockDevice) GetPropertyFirmwareMissing() (bool, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyFirmwareMissing") + } + + var r0 bool + var r1 error + if rf, ok := ret.Get(0).(func() (bool, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() bool); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(bool) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDevice_GetPropertyFirmwareMissing_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyFirmwareMissing' +type MockDevice_GetPropertyFirmwareMissing_Call struct { + *mock.Call +} + +// GetPropertyFirmwareMissing is a helper method to define mock.On call +func (_e *MockDevice_Expecter) GetPropertyFirmwareMissing() *MockDevice_GetPropertyFirmwareMissing_Call { + return &MockDevice_GetPropertyFirmwareMissing_Call{Call: _e.mock.On("GetPropertyFirmwareMissing")} +} + +func (_c *MockDevice_GetPropertyFirmwareMissing_Call) Run(run func()) *MockDevice_GetPropertyFirmwareMissing_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockDevice_GetPropertyFirmwareMissing_Call) Return(_a0 bool, _a1 error) *MockDevice_GetPropertyFirmwareMissing_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDevice_GetPropertyFirmwareMissing_Call) RunAndReturn(run func() (bool, error)) *MockDevice_GetPropertyFirmwareMissing_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyFirmwareVersion provides a mock function with no fields +func (_m *MockDevice) GetPropertyFirmwareVersion() (string, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyFirmwareVersion") + } + + var r0 string + var r1 error + if rf, ok := ret.Get(0).(func() (string, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDevice_GetPropertyFirmwareVersion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyFirmwareVersion' +type MockDevice_GetPropertyFirmwareVersion_Call struct { + *mock.Call +} + +// GetPropertyFirmwareVersion is a helper method to define mock.On call +func (_e *MockDevice_Expecter) GetPropertyFirmwareVersion() *MockDevice_GetPropertyFirmwareVersion_Call { + return &MockDevice_GetPropertyFirmwareVersion_Call{Call: _e.mock.On("GetPropertyFirmwareVersion")} +} + +func (_c *MockDevice_GetPropertyFirmwareVersion_Call) Run(run func()) *MockDevice_GetPropertyFirmwareVersion_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockDevice_GetPropertyFirmwareVersion_Call) Return(_a0 string, _a1 error) *MockDevice_GetPropertyFirmwareVersion_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDevice_GetPropertyFirmwareVersion_Call) RunAndReturn(run func() (string, error)) *MockDevice_GetPropertyFirmwareVersion_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyIP4Config provides a mock function with no fields +func (_m *MockDevice) GetPropertyIP4Config() (gonetworkmanager.IP4Config, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyIP4Config") + } + + var r0 gonetworkmanager.IP4Config + var r1 error + if rf, ok := ret.Get(0).(func() (gonetworkmanager.IP4Config, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() gonetworkmanager.IP4Config); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(gonetworkmanager.IP4Config) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDevice_GetPropertyIP4Config_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyIP4Config' +type MockDevice_GetPropertyIP4Config_Call struct { + *mock.Call +} + +// GetPropertyIP4Config is a helper method to define mock.On call +func (_e *MockDevice_Expecter) GetPropertyIP4Config() *MockDevice_GetPropertyIP4Config_Call { + return &MockDevice_GetPropertyIP4Config_Call{Call: _e.mock.On("GetPropertyIP4Config")} +} + +func (_c *MockDevice_GetPropertyIP4Config_Call) Run(run func()) *MockDevice_GetPropertyIP4Config_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockDevice_GetPropertyIP4Config_Call) Return(_a0 gonetworkmanager.IP4Config, _a1 error) *MockDevice_GetPropertyIP4Config_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDevice_GetPropertyIP4Config_Call) RunAndReturn(run func() (gonetworkmanager.IP4Config, error)) *MockDevice_GetPropertyIP4Config_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyIP6Config provides a mock function with no fields +func (_m *MockDevice) GetPropertyIP6Config() (gonetworkmanager.IP6Config, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyIP6Config") + } + + var r0 gonetworkmanager.IP6Config + var r1 error + if rf, ok := ret.Get(0).(func() (gonetworkmanager.IP6Config, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() gonetworkmanager.IP6Config); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(gonetworkmanager.IP6Config) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDevice_GetPropertyIP6Config_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyIP6Config' +type MockDevice_GetPropertyIP6Config_Call struct { + *mock.Call +} + +// GetPropertyIP6Config is a helper method to define mock.On call +func (_e *MockDevice_Expecter) GetPropertyIP6Config() *MockDevice_GetPropertyIP6Config_Call { + return &MockDevice_GetPropertyIP6Config_Call{Call: _e.mock.On("GetPropertyIP6Config")} +} + +func (_c *MockDevice_GetPropertyIP6Config_Call) Run(run func()) *MockDevice_GetPropertyIP6Config_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockDevice_GetPropertyIP6Config_Call) Return(_a0 gonetworkmanager.IP6Config, _a1 error) *MockDevice_GetPropertyIP6Config_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDevice_GetPropertyIP6Config_Call) RunAndReturn(run func() (gonetworkmanager.IP6Config, error)) *MockDevice_GetPropertyIP6Config_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyInterface provides a mock function with no fields +func (_m *MockDevice) GetPropertyInterface() (string, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyInterface") + } + + var r0 string + var r1 error + if rf, ok := ret.Get(0).(func() (string, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDevice_GetPropertyInterface_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyInterface' +type MockDevice_GetPropertyInterface_Call struct { + *mock.Call +} + +// GetPropertyInterface is a helper method to define mock.On call +func (_e *MockDevice_Expecter) GetPropertyInterface() *MockDevice_GetPropertyInterface_Call { + return &MockDevice_GetPropertyInterface_Call{Call: _e.mock.On("GetPropertyInterface")} +} + +func (_c *MockDevice_GetPropertyInterface_Call) Run(run func()) *MockDevice_GetPropertyInterface_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockDevice_GetPropertyInterface_Call) Return(_a0 string, _a1 error) *MockDevice_GetPropertyInterface_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDevice_GetPropertyInterface_Call) RunAndReturn(run func() (string, error)) *MockDevice_GetPropertyInterface_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyIp4Connectivity provides a mock function with no fields +func (_m *MockDevice) GetPropertyIp4Connectivity() (gonetworkmanager.NmConnectivity, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyIp4Connectivity") + } + + var r0 gonetworkmanager.NmConnectivity + var r1 error + if rf, ok := ret.Get(0).(func() (gonetworkmanager.NmConnectivity, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() gonetworkmanager.NmConnectivity); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(gonetworkmanager.NmConnectivity) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDevice_GetPropertyIp4Connectivity_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyIp4Connectivity' +type MockDevice_GetPropertyIp4Connectivity_Call struct { + *mock.Call +} + +// GetPropertyIp4Connectivity is a helper method to define mock.On call +func (_e *MockDevice_Expecter) GetPropertyIp4Connectivity() *MockDevice_GetPropertyIp4Connectivity_Call { + return &MockDevice_GetPropertyIp4Connectivity_Call{Call: _e.mock.On("GetPropertyIp4Connectivity")} +} + +func (_c *MockDevice_GetPropertyIp4Connectivity_Call) Run(run func()) *MockDevice_GetPropertyIp4Connectivity_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockDevice_GetPropertyIp4Connectivity_Call) Return(_a0 gonetworkmanager.NmConnectivity, _a1 error) *MockDevice_GetPropertyIp4Connectivity_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDevice_GetPropertyIp4Connectivity_Call) RunAndReturn(run func() (gonetworkmanager.NmConnectivity, error)) *MockDevice_GetPropertyIp4Connectivity_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyIpInterface provides a mock function with no fields +func (_m *MockDevice) GetPropertyIpInterface() (string, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyIpInterface") + } + + var r0 string + var r1 error + if rf, ok := ret.Get(0).(func() (string, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDevice_GetPropertyIpInterface_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyIpInterface' +type MockDevice_GetPropertyIpInterface_Call struct { + *mock.Call +} + +// GetPropertyIpInterface is a helper method to define mock.On call +func (_e *MockDevice_Expecter) GetPropertyIpInterface() *MockDevice_GetPropertyIpInterface_Call { + return &MockDevice_GetPropertyIpInterface_Call{Call: _e.mock.On("GetPropertyIpInterface")} +} + +func (_c *MockDevice_GetPropertyIpInterface_Call) Run(run func()) *MockDevice_GetPropertyIpInterface_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockDevice_GetPropertyIpInterface_Call) Return(_a0 string, _a1 error) *MockDevice_GetPropertyIpInterface_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDevice_GetPropertyIpInterface_Call) RunAndReturn(run func() (string, error)) *MockDevice_GetPropertyIpInterface_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyManaged provides a mock function with no fields +func (_m *MockDevice) GetPropertyManaged() (bool, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyManaged") + } + + var r0 bool + var r1 error + if rf, ok := ret.Get(0).(func() (bool, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() bool); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(bool) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDevice_GetPropertyManaged_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyManaged' +type MockDevice_GetPropertyManaged_Call struct { + *mock.Call +} + +// GetPropertyManaged is a helper method to define mock.On call +func (_e *MockDevice_Expecter) GetPropertyManaged() *MockDevice_GetPropertyManaged_Call { + return &MockDevice_GetPropertyManaged_Call{Call: _e.mock.On("GetPropertyManaged")} +} + +func (_c *MockDevice_GetPropertyManaged_Call) Run(run func()) *MockDevice_GetPropertyManaged_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockDevice_GetPropertyManaged_Call) Return(_a0 bool, _a1 error) *MockDevice_GetPropertyManaged_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDevice_GetPropertyManaged_Call) RunAndReturn(run func() (bool, error)) *MockDevice_GetPropertyManaged_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyMtu provides a mock function with no fields +func (_m *MockDevice) GetPropertyMtu() (uint32, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyMtu") + } + + var r0 uint32 + var r1 error + if rf, ok := ret.Get(0).(func() (uint32, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() uint32); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(uint32) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDevice_GetPropertyMtu_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyMtu' +type MockDevice_GetPropertyMtu_Call struct { + *mock.Call +} + +// GetPropertyMtu is a helper method to define mock.On call +func (_e *MockDevice_Expecter) GetPropertyMtu() *MockDevice_GetPropertyMtu_Call { + return &MockDevice_GetPropertyMtu_Call{Call: _e.mock.On("GetPropertyMtu")} +} + +func (_c *MockDevice_GetPropertyMtu_Call) Run(run func()) *MockDevice_GetPropertyMtu_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockDevice_GetPropertyMtu_Call) Return(_a0 uint32, _a1 error) *MockDevice_GetPropertyMtu_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDevice_GetPropertyMtu_Call) RunAndReturn(run func() (uint32, error)) *MockDevice_GetPropertyMtu_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyNmPluginMissing provides a mock function with no fields +func (_m *MockDevice) GetPropertyNmPluginMissing() (bool, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyNmPluginMissing") + } + + var r0 bool + var r1 error + if rf, ok := ret.Get(0).(func() (bool, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() bool); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(bool) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDevice_GetPropertyNmPluginMissing_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyNmPluginMissing' +type MockDevice_GetPropertyNmPluginMissing_Call struct { + *mock.Call +} + +// GetPropertyNmPluginMissing is a helper method to define mock.On call +func (_e *MockDevice_Expecter) GetPropertyNmPluginMissing() *MockDevice_GetPropertyNmPluginMissing_Call { + return &MockDevice_GetPropertyNmPluginMissing_Call{Call: _e.mock.On("GetPropertyNmPluginMissing")} +} + +func (_c *MockDevice_GetPropertyNmPluginMissing_Call) Run(run func()) *MockDevice_GetPropertyNmPluginMissing_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockDevice_GetPropertyNmPluginMissing_Call) Return(_a0 bool, _a1 error) *MockDevice_GetPropertyNmPluginMissing_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDevice_GetPropertyNmPluginMissing_Call) RunAndReturn(run func() (bool, error)) *MockDevice_GetPropertyNmPluginMissing_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyPhysicalPortId provides a mock function with no fields +func (_m *MockDevice) GetPropertyPhysicalPortId() (string, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyPhysicalPortId") + } + + var r0 string + var r1 error + if rf, ok := ret.Get(0).(func() (string, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDevice_GetPropertyPhysicalPortId_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyPhysicalPortId' +type MockDevice_GetPropertyPhysicalPortId_Call struct { + *mock.Call +} + +// GetPropertyPhysicalPortId is a helper method to define mock.On call +func (_e *MockDevice_Expecter) GetPropertyPhysicalPortId() *MockDevice_GetPropertyPhysicalPortId_Call { + return &MockDevice_GetPropertyPhysicalPortId_Call{Call: _e.mock.On("GetPropertyPhysicalPortId")} +} + +func (_c *MockDevice_GetPropertyPhysicalPortId_Call) Run(run func()) *MockDevice_GetPropertyPhysicalPortId_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockDevice_GetPropertyPhysicalPortId_Call) Return(_a0 string, _a1 error) *MockDevice_GetPropertyPhysicalPortId_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDevice_GetPropertyPhysicalPortId_Call) RunAndReturn(run func() (string, error)) *MockDevice_GetPropertyPhysicalPortId_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyReal provides a mock function with no fields +func (_m *MockDevice) GetPropertyReal() (bool, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyReal") + } + + var r0 bool + var r1 error + if rf, ok := ret.Get(0).(func() (bool, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() bool); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(bool) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDevice_GetPropertyReal_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyReal' +type MockDevice_GetPropertyReal_Call struct { + *mock.Call +} + +// GetPropertyReal is a helper method to define mock.On call +func (_e *MockDevice_Expecter) GetPropertyReal() *MockDevice_GetPropertyReal_Call { + return &MockDevice_GetPropertyReal_Call{Call: _e.mock.On("GetPropertyReal")} +} + +func (_c *MockDevice_GetPropertyReal_Call) Run(run func()) *MockDevice_GetPropertyReal_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockDevice_GetPropertyReal_Call) Return(_a0 bool, _a1 error) *MockDevice_GetPropertyReal_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDevice_GetPropertyReal_Call) RunAndReturn(run func() (bool, error)) *MockDevice_GetPropertyReal_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyState provides a mock function with no fields +func (_m *MockDevice) GetPropertyState() (gonetworkmanager.NmDeviceState, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyState") + } + + var r0 gonetworkmanager.NmDeviceState + var r1 error + if rf, ok := ret.Get(0).(func() (gonetworkmanager.NmDeviceState, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() gonetworkmanager.NmDeviceState); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(gonetworkmanager.NmDeviceState) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDevice_GetPropertyState_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyState' +type MockDevice_GetPropertyState_Call struct { + *mock.Call +} + +// GetPropertyState is a helper method to define mock.On call +func (_e *MockDevice_Expecter) GetPropertyState() *MockDevice_GetPropertyState_Call { + return &MockDevice_GetPropertyState_Call{Call: _e.mock.On("GetPropertyState")} +} + +func (_c *MockDevice_GetPropertyState_Call) Run(run func()) *MockDevice_GetPropertyState_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockDevice_GetPropertyState_Call) Return(_a0 gonetworkmanager.NmDeviceState, _a1 error) *MockDevice_GetPropertyState_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDevice_GetPropertyState_Call) RunAndReturn(run func() (gonetworkmanager.NmDeviceState, error)) *MockDevice_GetPropertyState_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyUdi provides a mock function with no fields +func (_m *MockDevice) GetPropertyUdi() (string, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyUdi") + } + + var r0 string + var r1 error + if rf, ok := ret.Get(0).(func() (string, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDevice_GetPropertyUdi_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyUdi' +type MockDevice_GetPropertyUdi_Call struct { + *mock.Call +} + +// GetPropertyUdi is a helper method to define mock.On call +func (_e *MockDevice_Expecter) GetPropertyUdi() *MockDevice_GetPropertyUdi_Call { + return &MockDevice_GetPropertyUdi_Call{Call: _e.mock.On("GetPropertyUdi")} +} + +func (_c *MockDevice_GetPropertyUdi_Call) Run(run func()) *MockDevice_GetPropertyUdi_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockDevice_GetPropertyUdi_Call) Return(_a0 string, _a1 error) *MockDevice_GetPropertyUdi_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDevice_GetPropertyUdi_Call) RunAndReturn(run func() (string, error)) *MockDevice_GetPropertyUdi_Call { + _c.Call.Return(run) + return _c +} + +// MarshalJSON provides a mock function with no fields +func (_m *MockDevice) MarshalJSON() ([]byte, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for MarshalJSON") + } + + var r0 []byte + var r1 error + if rf, ok := ret.Get(0).(func() ([]byte, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() []byte); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]byte) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDevice_MarshalJSON_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MarshalJSON' +type MockDevice_MarshalJSON_Call struct { + *mock.Call +} + +// MarshalJSON is a helper method to define mock.On call +func (_e *MockDevice_Expecter) MarshalJSON() *MockDevice_MarshalJSON_Call { + return &MockDevice_MarshalJSON_Call{Call: _e.mock.On("MarshalJSON")} +} + +func (_c *MockDevice_MarshalJSON_Call) Run(run func()) *MockDevice_MarshalJSON_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockDevice_MarshalJSON_Call) Return(_a0 []byte, _a1 error) *MockDevice_MarshalJSON_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDevice_MarshalJSON_Call) RunAndReturn(run func() ([]byte, error)) *MockDevice_MarshalJSON_Call { + _c.Call.Return(run) + return _c +} + +// Reapply provides a mock function with given fields: connection, versionId, flags +func (_m *MockDevice) Reapply(connection gonetworkmanager.Connection, versionId uint64, flags uint32) error { + ret := _m.Called(connection, versionId, flags) + + if len(ret) == 0 { + panic("no return value specified for Reapply") + } + + var r0 error + if rf, ok := ret.Get(0).(func(gonetworkmanager.Connection, uint64, uint32) error); ok { + r0 = rf(connection, versionId, flags) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockDevice_Reapply_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Reapply' +type MockDevice_Reapply_Call struct { + *mock.Call +} + +// Reapply is a helper method to define mock.On call +// - connection gonetworkmanager.Connection +// - versionId uint64 +// - flags uint32 +func (_e *MockDevice_Expecter) Reapply(connection interface{}, versionId interface{}, flags interface{}) *MockDevice_Reapply_Call { + return &MockDevice_Reapply_Call{Call: _e.mock.On("Reapply", connection, versionId, flags)} +} + +func (_c *MockDevice_Reapply_Call) Run(run func(connection gonetworkmanager.Connection, versionId uint64, flags uint32)) *MockDevice_Reapply_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(gonetworkmanager.Connection), args[1].(uint64), args[2].(uint32)) + }) + return _c +} + +func (_c *MockDevice_Reapply_Call) Return(_a0 error) *MockDevice_Reapply_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockDevice_Reapply_Call) RunAndReturn(run func(gonetworkmanager.Connection, uint64, uint32) error) *MockDevice_Reapply_Call { + _c.Call.Return(run) + return _c +} + +// SetPropertyAutoConnect provides a mock function with given fields: _a0 +func (_m *MockDevice) SetPropertyAutoConnect(_a0 bool) error { + ret := _m.Called(_a0) + + if len(ret) == 0 { + panic("no return value specified for SetPropertyAutoConnect") + } + + var r0 error + if rf, ok := ret.Get(0).(func(bool) error); ok { + r0 = rf(_a0) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockDevice_SetPropertyAutoConnect_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetPropertyAutoConnect' +type MockDevice_SetPropertyAutoConnect_Call struct { + *mock.Call +} + +// SetPropertyAutoConnect is a helper method to define mock.On call +// - _a0 bool +func (_e *MockDevice_Expecter) SetPropertyAutoConnect(_a0 interface{}) *MockDevice_SetPropertyAutoConnect_Call { + return &MockDevice_SetPropertyAutoConnect_Call{Call: _e.mock.On("SetPropertyAutoConnect", _a0)} +} + +func (_c *MockDevice_SetPropertyAutoConnect_Call) Run(run func(_a0 bool)) *MockDevice_SetPropertyAutoConnect_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(bool)) + }) + return _c +} + +func (_c *MockDevice_SetPropertyAutoConnect_Call) Return(_a0 error) *MockDevice_SetPropertyAutoConnect_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockDevice_SetPropertyAutoConnect_Call) RunAndReturn(run func(bool) error) *MockDevice_SetPropertyAutoConnect_Call { + _c.Call.Return(run) + return _c +} + +// SetPropertyManaged provides a mock function with given fields: _a0 +func (_m *MockDevice) SetPropertyManaged(_a0 bool) error { + ret := _m.Called(_a0) + + if len(ret) == 0 { + panic("no return value specified for SetPropertyManaged") + } + + var r0 error + if rf, ok := ret.Get(0).(func(bool) error); ok { + r0 = rf(_a0) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockDevice_SetPropertyManaged_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetPropertyManaged' +type MockDevice_SetPropertyManaged_Call struct { + *mock.Call +} + +// SetPropertyManaged is a helper method to define mock.On call +// - _a0 bool +func (_e *MockDevice_Expecter) SetPropertyManaged(_a0 interface{}) *MockDevice_SetPropertyManaged_Call { + return &MockDevice_SetPropertyManaged_Call{Call: _e.mock.On("SetPropertyManaged", _a0)} +} + +func (_c *MockDevice_SetPropertyManaged_Call) Run(run func(_a0 bool)) *MockDevice_SetPropertyManaged_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(bool)) + }) + return _c +} + +func (_c *MockDevice_SetPropertyManaged_Call) Return(_a0 error) *MockDevice_SetPropertyManaged_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockDevice_SetPropertyManaged_Call) RunAndReturn(run func(bool) error) *MockDevice_SetPropertyManaged_Call { + _c.Call.Return(run) + return _c +} + +// SubscribeState provides a mock function with given fields: receiver, exit +func (_m *MockDevice) SubscribeState(receiver chan gonetworkmanager.DeviceStateChange, exit chan struct{}) error { + ret := _m.Called(receiver, exit) + + if len(ret) == 0 { + panic("no return value specified for SubscribeState") + } + + var r0 error + if rf, ok := ret.Get(0).(func(chan gonetworkmanager.DeviceStateChange, chan struct{}) error); ok { + r0 = rf(receiver, exit) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockDevice_SubscribeState_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SubscribeState' +type MockDevice_SubscribeState_Call struct { + *mock.Call +} + +// SubscribeState is a helper method to define mock.On call +// - receiver chan gonetworkmanager.DeviceStateChange +// - exit chan struct{} +func (_e *MockDevice_Expecter) SubscribeState(receiver interface{}, exit interface{}) *MockDevice_SubscribeState_Call { + return &MockDevice_SubscribeState_Call{Call: _e.mock.On("SubscribeState", receiver, exit)} +} + +func (_c *MockDevice_SubscribeState_Call) Run(run func(receiver chan gonetworkmanager.DeviceStateChange, exit chan struct{})) *MockDevice_SubscribeState_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(chan gonetworkmanager.DeviceStateChange), args[1].(chan struct{})) + }) + return _c +} + +func (_c *MockDevice_SubscribeState_Call) Return(err error) *MockDevice_SubscribeState_Call { + _c.Call.Return(err) + return _c +} + +func (_c *MockDevice_SubscribeState_Call) RunAndReturn(run func(chan gonetworkmanager.DeviceStateChange, chan struct{}) error) *MockDevice_SubscribeState_Call { + _c.Call.Return(run) + return _c +} + +// NewMockDevice creates a new instance of MockDevice. 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 NewMockDevice(t interface { + mock.TestingT + Cleanup(func()) +}) *MockDevice { + mock := &MockDevice{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/github.com/Wifx/gonetworkmanager/v2/mock_DeviceWireless.go b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/github.com/Wifx/gonetworkmanager/v2/mock_DeviceWireless.go new file mode 100644 index 0000000..d2d3f2d --- /dev/null +++ b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/github.com/Wifx/gonetworkmanager/v2/mock_DeviceWireless.go @@ -0,0 +1,2241 @@ +// Code generated by mockery v2.53.5. DO NOT EDIT. + +package gonetworkmanager + +import ( + gonetworkmanager "github.com/Wifx/gonetworkmanager/v2" + dbus "github.com/godbus/dbus/v5" + + mock "github.com/stretchr/testify/mock" +) + +// MockDeviceWireless is an autogenerated mock type for the DeviceWireless type +type MockDeviceWireless struct { + mock.Mock +} + +type MockDeviceWireless_Expecter struct { + mock *mock.Mock +} + +func (_m *MockDeviceWireless) EXPECT() *MockDeviceWireless_Expecter { + return &MockDeviceWireless_Expecter{mock: &_m.Mock} +} + +// Delete provides a mock function with no fields +func (_m *MockDeviceWireless) Delete() error { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Delete") + } + + var r0 error + if rf, ok := ret.Get(0).(func() error); ok { + r0 = rf() + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockDeviceWireless_Delete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Delete' +type MockDeviceWireless_Delete_Call struct { + *mock.Call +} + +// Delete is a helper method to define mock.On call +func (_e *MockDeviceWireless_Expecter) Delete() *MockDeviceWireless_Delete_Call { + return &MockDeviceWireless_Delete_Call{Call: _e.mock.On("Delete")} +} + +func (_c *MockDeviceWireless_Delete_Call) Run(run func()) *MockDeviceWireless_Delete_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockDeviceWireless_Delete_Call) Return(_a0 error) *MockDeviceWireless_Delete_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockDeviceWireless_Delete_Call) RunAndReturn(run func() error) *MockDeviceWireless_Delete_Call { + _c.Call.Return(run) + return _c +} + +// Disconnect provides a mock function with no fields +func (_m *MockDeviceWireless) Disconnect() error { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Disconnect") + } + + var r0 error + if rf, ok := ret.Get(0).(func() error); ok { + r0 = rf() + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockDeviceWireless_Disconnect_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Disconnect' +type MockDeviceWireless_Disconnect_Call struct { + *mock.Call +} + +// Disconnect is a helper method to define mock.On call +func (_e *MockDeviceWireless_Expecter) Disconnect() *MockDeviceWireless_Disconnect_Call { + return &MockDeviceWireless_Disconnect_Call{Call: _e.mock.On("Disconnect")} +} + +func (_c *MockDeviceWireless_Disconnect_Call) Run(run func()) *MockDeviceWireless_Disconnect_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockDeviceWireless_Disconnect_Call) Return(_a0 error) *MockDeviceWireless_Disconnect_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockDeviceWireless_Disconnect_Call) RunAndReturn(run func() error) *MockDeviceWireless_Disconnect_Call { + _c.Call.Return(run) + return _c +} + +// GetAccessPoints provides a mock function with no fields +func (_m *MockDeviceWireless) GetAccessPoints() ([]gonetworkmanager.AccessPoint, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetAccessPoints") + } + + var r0 []gonetworkmanager.AccessPoint + var r1 error + if rf, ok := ret.Get(0).(func() ([]gonetworkmanager.AccessPoint, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() []gonetworkmanager.AccessPoint); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]gonetworkmanager.AccessPoint) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDeviceWireless_GetAccessPoints_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAccessPoints' +type MockDeviceWireless_GetAccessPoints_Call struct { + *mock.Call +} + +// GetAccessPoints is a helper method to define mock.On call +func (_e *MockDeviceWireless_Expecter) GetAccessPoints() *MockDeviceWireless_GetAccessPoints_Call { + return &MockDeviceWireless_GetAccessPoints_Call{Call: _e.mock.On("GetAccessPoints")} +} + +func (_c *MockDeviceWireless_GetAccessPoints_Call) Run(run func()) *MockDeviceWireless_GetAccessPoints_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockDeviceWireless_GetAccessPoints_Call) Return(_a0 []gonetworkmanager.AccessPoint, _a1 error) *MockDeviceWireless_GetAccessPoints_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDeviceWireless_GetAccessPoints_Call) RunAndReturn(run func() ([]gonetworkmanager.AccessPoint, error)) *MockDeviceWireless_GetAccessPoints_Call { + _c.Call.Return(run) + return _c +} + +// GetAllAccessPoints provides a mock function with no fields +func (_m *MockDeviceWireless) GetAllAccessPoints() ([]gonetworkmanager.AccessPoint, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetAllAccessPoints") + } + + var r0 []gonetworkmanager.AccessPoint + var r1 error + if rf, ok := ret.Get(0).(func() ([]gonetworkmanager.AccessPoint, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() []gonetworkmanager.AccessPoint); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]gonetworkmanager.AccessPoint) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDeviceWireless_GetAllAccessPoints_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllAccessPoints' +type MockDeviceWireless_GetAllAccessPoints_Call struct { + *mock.Call +} + +// GetAllAccessPoints is a helper method to define mock.On call +func (_e *MockDeviceWireless_Expecter) GetAllAccessPoints() *MockDeviceWireless_GetAllAccessPoints_Call { + return &MockDeviceWireless_GetAllAccessPoints_Call{Call: _e.mock.On("GetAllAccessPoints")} +} + +func (_c *MockDeviceWireless_GetAllAccessPoints_Call) Run(run func()) *MockDeviceWireless_GetAllAccessPoints_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockDeviceWireless_GetAllAccessPoints_Call) Return(_a0 []gonetworkmanager.AccessPoint, _a1 error) *MockDeviceWireless_GetAllAccessPoints_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDeviceWireless_GetAllAccessPoints_Call) RunAndReturn(run func() ([]gonetworkmanager.AccessPoint, error)) *MockDeviceWireless_GetAllAccessPoints_Call { + _c.Call.Return(run) + return _c +} + +// GetPath provides a mock function with no fields +func (_m *MockDeviceWireless) GetPath() dbus.ObjectPath { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPath") + } + + var r0 dbus.ObjectPath + if rf, ok := ret.Get(0).(func() dbus.ObjectPath); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(dbus.ObjectPath) + } + + return r0 +} + +// MockDeviceWireless_GetPath_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPath' +type MockDeviceWireless_GetPath_Call struct { + *mock.Call +} + +// GetPath is a helper method to define mock.On call +func (_e *MockDeviceWireless_Expecter) GetPath() *MockDeviceWireless_GetPath_Call { + return &MockDeviceWireless_GetPath_Call{Call: _e.mock.On("GetPath")} +} + +func (_c *MockDeviceWireless_GetPath_Call) Run(run func()) *MockDeviceWireless_GetPath_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockDeviceWireless_GetPath_Call) Return(_a0 dbus.ObjectPath) *MockDeviceWireless_GetPath_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockDeviceWireless_GetPath_Call) RunAndReturn(run func() dbus.ObjectPath) *MockDeviceWireless_GetPath_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyAccessPoints provides a mock function with no fields +func (_m *MockDeviceWireless) GetPropertyAccessPoints() ([]gonetworkmanager.AccessPoint, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyAccessPoints") + } + + var r0 []gonetworkmanager.AccessPoint + var r1 error + if rf, ok := ret.Get(0).(func() ([]gonetworkmanager.AccessPoint, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() []gonetworkmanager.AccessPoint); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]gonetworkmanager.AccessPoint) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDeviceWireless_GetPropertyAccessPoints_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyAccessPoints' +type MockDeviceWireless_GetPropertyAccessPoints_Call struct { + *mock.Call +} + +// GetPropertyAccessPoints is a helper method to define mock.On call +func (_e *MockDeviceWireless_Expecter) GetPropertyAccessPoints() *MockDeviceWireless_GetPropertyAccessPoints_Call { + return &MockDeviceWireless_GetPropertyAccessPoints_Call{Call: _e.mock.On("GetPropertyAccessPoints")} +} + +func (_c *MockDeviceWireless_GetPropertyAccessPoints_Call) Run(run func()) *MockDeviceWireless_GetPropertyAccessPoints_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockDeviceWireless_GetPropertyAccessPoints_Call) Return(_a0 []gonetworkmanager.AccessPoint, _a1 error) *MockDeviceWireless_GetPropertyAccessPoints_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDeviceWireless_GetPropertyAccessPoints_Call) RunAndReturn(run func() ([]gonetworkmanager.AccessPoint, error)) *MockDeviceWireless_GetPropertyAccessPoints_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyActiveAccessPoint provides a mock function with no fields +func (_m *MockDeviceWireless) GetPropertyActiveAccessPoint() (gonetworkmanager.AccessPoint, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyActiveAccessPoint") + } + + var r0 gonetworkmanager.AccessPoint + var r1 error + if rf, ok := ret.Get(0).(func() (gonetworkmanager.AccessPoint, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() gonetworkmanager.AccessPoint); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(gonetworkmanager.AccessPoint) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDeviceWireless_GetPropertyActiveAccessPoint_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyActiveAccessPoint' +type MockDeviceWireless_GetPropertyActiveAccessPoint_Call struct { + *mock.Call +} + +// GetPropertyActiveAccessPoint is a helper method to define mock.On call +func (_e *MockDeviceWireless_Expecter) GetPropertyActiveAccessPoint() *MockDeviceWireless_GetPropertyActiveAccessPoint_Call { + return &MockDeviceWireless_GetPropertyActiveAccessPoint_Call{Call: _e.mock.On("GetPropertyActiveAccessPoint")} +} + +func (_c *MockDeviceWireless_GetPropertyActiveAccessPoint_Call) Run(run func()) *MockDeviceWireless_GetPropertyActiveAccessPoint_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockDeviceWireless_GetPropertyActiveAccessPoint_Call) Return(_a0 gonetworkmanager.AccessPoint, _a1 error) *MockDeviceWireless_GetPropertyActiveAccessPoint_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDeviceWireless_GetPropertyActiveAccessPoint_Call) RunAndReturn(run func() (gonetworkmanager.AccessPoint, error)) *MockDeviceWireless_GetPropertyActiveAccessPoint_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyActiveConnection provides a mock function with no fields +func (_m *MockDeviceWireless) GetPropertyActiveConnection() (gonetworkmanager.ActiveConnection, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyActiveConnection") + } + + var r0 gonetworkmanager.ActiveConnection + var r1 error + if rf, ok := ret.Get(0).(func() (gonetworkmanager.ActiveConnection, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() gonetworkmanager.ActiveConnection); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(gonetworkmanager.ActiveConnection) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDeviceWireless_GetPropertyActiveConnection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyActiveConnection' +type MockDeviceWireless_GetPropertyActiveConnection_Call struct { + *mock.Call +} + +// GetPropertyActiveConnection is a helper method to define mock.On call +func (_e *MockDeviceWireless_Expecter) GetPropertyActiveConnection() *MockDeviceWireless_GetPropertyActiveConnection_Call { + return &MockDeviceWireless_GetPropertyActiveConnection_Call{Call: _e.mock.On("GetPropertyActiveConnection")} +} + +func (_c *MockDeviceWireless_GetPropertyActiveConnection_Call) Run(run func()) *MockDeviceWireless_GetPropertyActiveConnection_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockDeviceWireless_GetPropertyActiveConnection_Call) Return(_a0 gonetworkmanager.ActiveConnection, _a1 error) *MockDeviceWireless_GetPropertyActiveConnection_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDeviceWireless_GetPropertyActiveConnection_Call) RunAndReturn(run func() (gonetworkmanager.ActiveConnection, error)) *MockDeviceWireless_GetPropertyActiveConnection_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyAutoConnect provides a mock function with no fields +func (_m *MockDeviceWireless) GetPropertyAutoConnect() (bool, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyAutoConnect") + } + + var r0 bool + var r1 error + if rf, ok := ret.Get(0).(func() (bool, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() bool); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(bool) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDeviceWireless_GetPropertyAutoConnect_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyAutoConnect' +type MockDeviceWireless_GetPropertyAutoConnect_Call struct { + *mock.Call +} + +// GetPropertyAutoConnect is a helper method to define mock.On call +func (_e *MockDeviceWireless_Expecter) GetPropertyAutoConnect() *MockDeviceWireless_GetPropertyAutoConnect_Call { + return &MockDeviceWireless_GetPropertyAutoConnect_Call{Call: _e.mock.On("GetPropertyAutoConnect")} +} + +func (_c *MockDeviceWireless_GetPropertyAutoConnect_Call) Run(run func()) *MockDeviceWireless_GetPropertyAutoConnect_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockDeviceWireless_GetPropertyAutoConnect_Call) Return(_a0 bool, _a1 error) *MockDeviceWireless_GetPropertyAutoConnect_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDeviceWireless_GetPropertyAutoConnect_Call) RunAndReturn(run func() (bool, error)) *MockDeviceWireless_GetPropertyAutoConnect_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyAvailableConnections provides a mock function with no fields +func (_m *MockDeviceWireless) GetPropertyAvailableConnections() ([]gonetworkmanager.Connection, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyAvailableConnections") + } + + var r0 []gonetworkmanager.Connection + var r1 error + if rf, ok := ret.Get(0).(func() ([]gonetworkmanager.Connection, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() []gonetworkmanager.Connection); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]gonetworkmanager.Connection) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDeviceWireless_GetPropertyAvailableConnections_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyAvailableConnections' +type MockDeviceWireless_GetPropertyAvailableConnections_Call struct { + *mock.Call +} + +// GetPropertyAvailableConnections is a helper method to define mock.On call +func (_e *MockDeviceWireless_Expecter) GetPropertyAvailableConnections() *MockDeviceWireless_GetPropertyAvailableConnections_Call { + return &MockDeviceWireless_GetPropertyAvailableConnections_Call{Call: _e.mock.On("GetPropertyAvailableConnections")} +} + +func (_c *MockDeviceWireless_GetPropertyAvailableConnections_Call) Run(run func()) *MockDeviceWireless_GetPropertyAvailableConnections_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockDeviceWireless_GetPropertyAvailableConnections_Call) Return(_a0 []gonetworkmanager.Connection, _a1 error) *MockDeviceWireless_GetPropertyAvailableConnections_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDeviceWireless_GetPropertyAvailableConnections_Call) RunAndReturn(run func() ([]gonetworkmanager.Connection, error)) *MockDeviceWireless_GetPropertyAvailableConnections_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyBitrate provides a mock function with no fields +func (_m *MockDeviceWireless) GetPropertyBitrate() (uint32, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyBitrate") + } + + var r0 uint32 + var r1 error + if rf, ok := ret.Get(0).(func() (uint32, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() uint32); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(uint32) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDeviceWireless_GetPropertyBitrate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyBitrate' +type MockDeviceWireless_GetPropertyBitrate_Call struct { + *mock.Call +} + +// GetPropertyBitrate is a helper method to define mock.On call +func (_e *MockDeviceWireless_Expecter) GetPropertyBitrate() *MockDeviceWireless_GetPropertyBitrate_Call { + return &MockDeviceWireless_GetPropertyBitrate_Call{Call: _e.mock.On("GetPropertyBitrate")} +} + +func (_c *MockDeviceWireless_GetPropertyBitrate_Call) Run(run func()) *MockDeviceWireless_GetPropertyBitrate_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockDeviceWireless_GetPropertyBitrate_Call) Return(_a0 uint32, _a1 error) *MockDeviceWireless_GetPropertyBitrate_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDeviceWireless_GetPropertyBitrate_Call) RunAndReturn(run func() (uint32, error)) *MockDeviceWireless_GetPropertyBitrate_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyDHCP4Config provides a mock function with no fields +func (_m *MockDeviceWireless) GetPropertyDHCP4Config() (gonetworkmanager.DHCP4Config, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyDHCP4Config") + } + + var r0 gonetworkmanager.DHCP4Config + var r1 error + if rf, ok := ret.Get(0).(func() (gonetworkmanager.DHCP4Config, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() gonetworkmanager.DHCP4Config); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(gonetworkmanager.DHCP4Config) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDeviceWireless_GetPropertyDHCP4Config_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyDHCP4Config' +type MockDeviceWireless_GetPropertyDHCP4Config_Call struct { + *mock.Call +} + +// GetPropertyDHCP4Config is a helper method to define mock.On call +func (_e *MockDeviceWireless_Expecter) GetPropertyDHCP4Config() *MockDeviceWireless_GetPropertyDHCP4Config_Call { + return &MockDeviceWireless_GetPropertyDHCP4Config_Call{Call: _e.mock.On("GetPropertyDHCP4Config")} +} + +func (_c *MockDeviceWireless_GetPropertyDHCP4Config_Call) Run(run func()) *MockDeviceWireless_GetPropertyDHCP4Config_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockDeviceWireless_GetPropertyDHCP4Config_Call) Return(_a0 gonetworkmanager.DHCP4Config, _a1 error) *MockDeviceWireless_GetPropertyDHCP4Config_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDeviceWireless_GetPropertyDHCP4Config_Call) RunAndReturn(run func() (gonetworkmanager.DHCP4Config, error)) *MockDeviceWireless_GetPropertyDHCP4Config_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyDHCP6Config provides a mock function with no fields +func (_m *MockDeviceWireless) GetPropertyDHCP6Config() (gonetworkmanager.DHCP6Config, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyDHCP6Config") + } + + var r0 gonetworkmanager.DHCP6Config + var r1 error + if rf, ok := ret.Get(0).(func() (gonetworkmanager.DHCP6Config, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() gonetworkmanager.DHCP6Config); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(gonetworkmanager.DHCP6Config) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDeviceWireless_GetPropertyDHCP6Config_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyDHCP6Config' +type MockDeviceWireless_GetPropertyDHCP6Config_Call struct { + *mock.Call +} + +// GetPropertyDHCP6Config is a helper method to define mock.On call +func (_e *MockDeviceWireless_Expecter) GetPropertyDHCP6Config() *MockDeviceWireless_GetPropertyDHCP6Config_Call { + return &MockDeviceWireless_GetPropertyDHCP6Config_Call{Call: _e.mock.On("GetPropertyDHCP6Config")} +} + +func (_c *MockDeviceWireless_GetPropertyDHCP6Config_Call) Run(run func()) *MockDeviceWireless_GetPropertyDHCP6Config_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockDeviceWireless_GetPropertyDHCP6Config_Call) Return(_a0 gonetworkmanager.DHCP6Config, _a1 error) *MockDeviceWireless_GetPropertyDHCP6Config_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDeviceWireless_GetPropertyDHCP6Config_Call) RunAndReturn(run func() (gonetworkmanager.DHCP6Config, error)) *MockDeviceWireless_GetPropertyDHCP6Config_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyDeviceType provides a mock function with no fields +func (_m *MockDeviceWireless) GetPropertyDeviceType() (gonetworkmanager.NmDeviceType, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyDeviceType") + } + + var r0 gonetworkmanager.NmDeviceType + var r1 error + if rf, ok := ret.Get(0).(func() (gonetworkmanager.NmDeviceType, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() gonetworkmanager.NmDeviceType); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(gonetworkmanager.NmDeviceType) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDeviceWireless_GetPropertyDeviceType_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyDeviceType' +type MockDeviceWireless_GetPropertyDeviceType_Call struct { + *mock.Call +} + +// GetPropertyDeviceType is a helper method to define mock.On call +func (_e *MockDeviceWireless_Expecter) GetPropertyDeviceType() *MockDeviceWireless_GetPropertyDeviceType_Call { + return &MockDeviceWireless_GetPropertyDeviceType_Call{Call: _e.mock.On("GetPropertyDeviceType")} +} + +func (_c *MockDeviceWireless_GetPropertyDeviceType_Call) Run(run func()) *MockDeviceWireless_GetPropertyDeviceType_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockDeviceWireless_GetPropertyDeviceType_Call) Return(_a0 gonetworkmanager.NmDeviceType, _a1 error) *MockDeviceWireless_GetPropertyDeviceType_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDeviceWireless_GetPropertyDeviceType_Call) RunAndReturn(run func() (gonetworkmanager.NmDeviceType, error)) *MockDeviceWireless_GetPropertyDeviceType_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyDriver provides a mock function with no fields +func (_m *MockDeviceWireless) GetPropertyDriver() (string, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyDriver") + } + + var r0 string + var r1 error + if rf, ok := ret.Get(0).(func() (string, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDeviceWireless_GetPropertyDriver_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyDriver' +type MockDeviceWireless_GetPropertyDriver_Call struct { + *mock.Call +} + +// GetPropertyDriver is a helper method to define mock.On call +func (_e *MockDeviceWireless_Expecter) GetPropertyDriver() *MockDeviceWireless_GetPropertyDriver_Call { + return &MockDeviceWireless_GetPropertyDriver_Call{Call: _e.mock.On("GetPropertyDriver")} +} + +func (_c *MockDeviceWireless_GetPropertyDriver_Call) Run(run func()) *MockDeviceWireless_GetPropertyDriver_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockDeviceWireless_GetPropertyDriver_Call) Return(_a0 string, _a1 error) *MockDeviceWireless_GetPropertyDriver_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDeviceWireless_GetPropertyDriver_Call) RunAndReturn(run func() (string, error)) *MockDeviceWireless_GetPropertyDriver_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyDriverVersion provides a mock function with no fields +func (_m *MockDeviceWireless) GetPropertyDriverVersion() (string, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyDriverVersion") + } + + var r0 string + var r1 error + if rf, ok := ret.Get(0).(func() (string, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDeviceWireless_GetPropertyDriverVersion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyDriverVersion' +type MockDeviceWireless_GetPropertyDriverVersion_Call struct { + *mock.Call +} + +// GetPropertyDriverVersion is a helper method to define mock.On call +func (_e *MockDeviceWireless_Expecter) GetPropertyDriverVersion() *MockDeviceWireless_GetPropertyDriverVersion_Call { + return &MockDeviceWireless_GetPropertyDriverVersion_Call{Call: _e.mock.On("GetPropertyDriverVersion")} +} + +func (_c *MockDeviceWireless_GetPropertyDriverVersion_Call) Run(run func()) *MockDeviceWireless_GetPropertyDriverVersion_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockDeviceWireless_GetPropertyDriverVersion_Call) Return(_a0 string, _a1 error) *MockDeviceWireless_GetPropertyDriverVersion_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDeviceWireless_GetPropertyDriverVersion_Call) RunAndReturn(run func() (string, error)) *MockDeviceWireless_GetPropertyDriverVersion_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyFirmwareMissing provides a mock function with no fields +func (_m *MockDeviceWireless) GetPropertyFirmwareMissing() (bool, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyFirmwareMissing") + } + + var r0 bool + var r1 error + if rf, ok := ret.Get(0).(func() (bool, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() bool); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(bool) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDeviceWireless_GetPropertyFirmwareMissing_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyFirmwareMissing' +type MockDeviceWireless_GetPropertyFirmwareMissing_Call struct { + *mock.Call +} + +// GetPropertyFirmwareMissing is a helper method to define mock.On call +func (_e *MockDeviceWireless_Expecter) GetPropertyFirmwareMissing() *MockDeviceWireless_GetPropertyFirmwareMissing_Call { + return &MockDeviceWireless_GetPropertyFirmwareMissing_Call{Call: _e.mock.On("GetPropertyFirmwareMissing")} +} + +func (_c *MockDeviceWireless_GetPropertyFirmwareMissing_Call) Run(run func()) *MockDeviceWireless_GetPropertyFirmwareMissing_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockDeviceWireless_GetPropertyFirmwareMissing_Call) Return(_a0 bool, _a1 error) *MockDeviceWireless_GetPropertyFirmwareMissing_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDeviceWireless_GetPropertyFirmwareMissing_Call) RunAndReturn(run func() (bool, error)) *MockDeviceWireless_GetPropertyFirmwareMissing_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyFirmwareVersion provides a mock function with no fields +func (_m *MockDeviceWireless) GetPropertyFirmwareVersion() (string, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyFirmwareVersion") + } + + var r0 string + var r1 error + if rf, ok := ret.Get(0).(func() (string, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDeviceWireless_GetPropertyFirmwareVersion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyFirmwareVersion' +type MockDeviceWireless_GetPropertyFirmwareVersion_Call struct { + *mock.Call +} + +// GetPropertyFirmwareVersion is a helper method to define mock.On call +func (_e *MockDeviceWireless_Expecter) GetPropertyFirmwareVersion() *MockDeviceWireless_GetPropertyFirmwareVersion_Call { + return &MockDeviceWireless_GetPropertyFirmwareVersion_Call{Call: _e.mock.On("GetPropertyFirmwareVersion")} +} + +func (_c *MockDeviceWireless_GetPropertyFirmwareVersion_Call) Run(run func()) *MockDeviceWireless_GetPropertyFirmwareVersion_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockDeviceWireless_GetPropertyFirmwareVersion_Call) Return(_a0 string, _a1 error) *MockDeviceWireless_GetPropertyFirmwareVersion_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDeviceWireless_GetPropertyFirmwareVersion_Call) RunAndReturn(run func() (string, error)) *MockDeviceWireless_GetPropertyFirmwareVersion_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyHwAddress provides a mock function with no fields +func (_m *MockDeviceWireless) GetPropertyHwAddress() (string, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyHwAddress") + } + + var r0 string + var r1 error + if rf, ok := ret.Get(0).(func() (string, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDeviceWireless_GetPropertyHwAddress_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyHwAddress' +type MockDeviceWireless_GetPropertyHwAddress_Call struct { + *mock.Call +} + +// GetPropertyHwAddress is a helper method to define mock.On call +func (_e *MockDeviceWireless_Expecter) GetPropertyHwAddress() *MockDeviceWireless_GetPropertyHwAddress_Call { + return &MockDeviceWireless_GetPropertyHwAddress_Call{Call: _e.mock.On("GetPropertyHwAddress")} +} + +func (_c *MockDeviceWireless_GetPropertyHwAddress_Call) Run(run func()) *MockDeviceWireless_GetPropertyHwAddress_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockDeviceWireless_GetPropertyHwAddress_Call) Return(_a0 string, _a1 error) *MockDeviceWireless_GetPropertyHwAddress_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDeviceWireless_GetPropertyHwAddress_Call) RunAndReturn(run func() (string, error)) *MockDeviceWireless_GetPropertyHwAddress_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyIP4Config provides a mock function with no fields +func (_m *MockDeviceWireless) GetPropertyIP4Config() (gonetworkmanager.IP4Config, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyIP4Config") + } + + var r0 gonetworkmanager.IP4Config + var r1 error + if rf, ok := ret.Get(0).(func() (gonetworkmanager.IP4Config, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() gonetworkmanager.IP4Config); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(gonetworkmanager.IP4Config) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDeviceWireless_GetPropertyIP4Config_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyIP4Config' +type MockDeviceWireless_GetPropertyIP4Config_Call struct { + *mock.Call +} + +// GetPropertyIP4Config is a helper method to define mock.On call +func (_e *MockDeviceWireless_Expecter) GetPropertyIP4Config() *MockDeviceWireless_GetPropertyIP4Config_Call { + return &MockDeviceWireless_GetPropertyIP4Config_Call{Call: _e.mock.On("GetPropertyIP4Config")} +} + +func (_c *MockDeviceWireless_GetPropertyIP4Config_Call) Run(run func()) *MockDeviceWireless_GetPropertyIP4Config_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockDeviceWireless_GetPropertyIP4Config_Call) Return(_a0 gonetworkmanager.IP4Config, _a1 error) *MockDeviceWireless_GetPropertyIP4Config_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDeviceWireless_GetPropertyIP4Config_Call) RunAndReturn(run func() (gonetworkmanager.IP4Config, error)) *MockDeviceWireless_GetPropertyIP4Config_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyIP6Config provides a mock function with no fields +func (_m *MockDeviceWireless) GetPropertyIP6Config() (gonetworkmanager.IP6Config, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyIP6Config") + } + + var r0 gonetworkmanager.IP6Config + var r1 error + if rf, ok := ret.Get(0).(func() (gonetworkmanager.IP6Config, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() gonetworkmanager.IP6Config); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(gonetworkmanager.IP6Config) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDeviceWireless_GetPropertyIP6Config_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyIP6Config' +type MockDeviceWireless_GetPropertyIP6Config_Call struct { + *mock.Call +} + +// GetPropertyIP6Config is a helper method to define mock.On call +func (_e *MockDeviceWireless_Expecter) GetPropertyIP6Config() *MockDeviceWireless_GetPropertyIP6Config_Call { + return &MockDeviceWireless_GetPropertyIP6Config_Call{Call: _e.mock.On("GetPropertyIP6Config")} +} + +func (_c *MockDeviceWireless_GetPropertyIP6Config_Call) Run(run func()) *MockDeviceWireless_GetPropertyIP6Config_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockDeviceWireless_GetPropertyIP6Config_Call) Return(_a0 gonetworkmanager.IP6Config, _a1 error) *MockDeviceWireless_GetPropertyIP6Config_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDeviceWireless_GetPropertyIP6Config_Call) RunAndReturn(run func() (gonetworkmanager.IP6Config, error)) *MockDeviceWireless_GetPropertyIP6Config_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyInterface provides a mock function with no fields +func (_m *MockDeviceWireless) GetPropertyInterface() (string, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyInterface") + } + + var r0 string + var r1 error + if rf, ok := ret.Get(0).(func() (string, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDeviceWireless_GetPropertyInterface_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyInterface' +type MockDeviceWireless_GetPropertyInterface_Call struct { + *mock.Call +} + +// GetPropertyInterface is a helper method to define mock.On call +func (_e *MockDeviceWireless_Expecter) GetPropertyInterface() *MockDeviceWireless_GetPropertyInterface_Call { + return &MockDeviceWireless_GetPropertyInterface_Call{Call: _e.mock.On("GetPropertyInterface")} +} + +func (_c *MockDeviceWireless_GetPropertyInterface_Call) Run(run func()) *MockDeviceWireless_GetPropertyInterface_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockDeviceWireless_GetPropertyInterface_Call) Return(_a0 string, _a1 error) *MockDeviceWireless_GetPropertyInterface_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDeviceWireless_GetPropertyInterface_Call) RunAndReturn(run func() (string, error)) *MockDeviceWireless_GetPropertyInterface_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyIp4Connectivity provides a mock function with no fields +func (_m *MockDeviceWireless) GetPropertyIp4Connectivity() (gonetworkmanager.NmConnectivity, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyIp4Connectivity") + } + + var r0 gonetworkmanager.NmConnectivity + var r1 error + if rf, ok := ret.Get(0).(func() (gonetworkmanager.NmConnectivity, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() gonetworkmanager.NmConnectivity); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(gonetworkmanager.NmConnectivity) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDeviceWireless_GetPropertyIp4Connectivity_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyIp4Connectivity' +type MockDeviceWireless_GetPropertyIp4Connectivity_Call struct { + *mock.Call +} + +// GetPropertyIp4Connectivity is a helper method to define mock.On call +func (_e *MockDeviceWireless_Expecter) GetPropertyIp4Connectivity() *MockDeviceWireless_GetPropertyIp4Connectivity_Call { + return &MockDeviceWireless_GetPropertyIp4Connectivity_Call{Call: _e.mock.On("GetPropertyIp4Connectivity")} +} + +func (_c *MockDeviceWireless_GetPropertyIp4Connectivity_Call) Run(run func()) *MockDeviceWireless_GetPropertyIp4Connectivity_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockDeviceWireless_GetPropertyIp4Connectivity_Call) Return(_a0 gonetworkmanager.NmConnectivity, _a1 error) *MockDeviceWireless_GetPropertyIp4Connectivity_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDeviceWireless_GetPropertyIp4Connectivity_Call) RunAndReturn(run func() (gonetworkmanager.NmConnectivity, error)) *MockDeviceWireless_GetPropertyIp4Connectivity_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyIpInterface provides a mock function with no fields +func (_m *MockDeviceWireless) GetPropertyIpInterface() (string, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyIpInterface") + } + + var r0 string + var r1 error + if rf, ok := ret.Get(0).(func() (string, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDeviceWireless_GetPropertyIpInterface_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyIpInterface' +type MockDeviceWireless_GetPropertyIpInterface_Call struct { + *mock.Call +} + +// GetPropertyIpInterface is a helper method to define mock.On call +func (_e *MockDeviceWireless_Expecter) GetPropertyIpInterface() *MockDeviceWireless_GetPropertyIpInterface_Call { + return &MockDeviceWireless_GetPropertyIpInterface_Call{Call: _e.mock.On("GetPropertyIpInterface")} +} + +func (_c *MockDeviceWireless_GetPropertyIpInterface_Call) Run(run func()) *MockDeviceWireless_GetPropertyIpInterface_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockDeviceWireless_GetPropertyIpInterface_Call) Return(_a0 string, _a1 error) *MockDeviceWireless_GetPropertyIpInterface_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDeviceWireless_GetPropertyIpInterface_Call) RunAndReturn(run func() (string, error)) *MockDeviceWireless_GetPropertyIpInterface_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyLastScan provides a mock function with no fields +func (_m *MockDeviceWireless) GetPropertyLastScan() (int64, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyLastScan") + } + + var r0 int64 + var r1 error + if rf, ok := ret.Get(0).(func() (int64, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() int64); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(int64) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDeviceWireless_GetPropertyLastScan_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyLastScan' +type MockDeviceWireless_GetPropertyLastScan_Call struct { + *mock.Call +} + +// GetPropertyLastScan is a helper method to define mock.On call +func (_e *MockDeviceWireless_Expecter) GetPropertyLastScan() *MockDeviceWireless_GetPropertyLastScan_Call { + return &MockDeviceWireless_GetPropertyLastScan_Call{Call: _e.mock.On("GetPropertyLastScan")} +} + +func (_c *MockDeviceWireless_GetPropertyLastScan_Call) Run(run func()) *MockDeviceWireless_GetPropertyLastScan_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockDeviceWireless_GetPropertyLastScan_Call) Return(_a0 int64, _a1 error) *MockDeviceWireless_GetPropertyLastScan_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDeviceWireless_GetPropertyLastScan_Call) RunAndReturn(run func() (int64, error)) *MockDeviceWireless_GetPropertyLastScan_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyManaged provides a mock function with no fields +func (_m *MockDeviceWireless) GetPropertyManaged() (bool, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyManaged") + } + + var r0 bool + var r1 error + if rf, ok := ret.Get(0).(func() (bool, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() bool); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(bool) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDeviceWireless_GetPropertyManaged_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyManaged' +type MockDeviceWireless_GetPropertyManaged_Call struct { + *mock.Call +} + +// GetPropertyManaged is a helper method to define mock.On call +func (_e *MockDeviceWireless_Expecter) GetPropertyManaged() *MockDeviceWireless_GetPropertyManaged_Call { + return &MockDeviceWireless_GetPropertyManaged_Call{Call: _e.mock.On("GetPropertyManaged")} +} + +func (_c *MockDeviceWireless_GetPropertyManaged_Call) Run(run func()) *MockDeviceWireless_GetPropertyManaged_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockDeviceWireless_GetPropertyManaged_Call) Return(_a0 bool, _a1 error) *MockDeviceWireless_GetPropertyManaged_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDeviceWireless_GetPropertyManaged_Call) RunAndReturn(run func() (bool, error)) *MockDeviceWireless_GetPropertyManaged_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyMode provides a mock function with no fields +func (_m *MockDeviceWireless) GetPropertyMode() (gonetworkmanager.Nm80211Mode, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyMode") + } + + var r0 gonetworkmanager.Nm80211Mode + var r1 error + if rf, ok := ret.Get(0).(func() (gonetworkmanager.Nm80211Mode, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() gonetworkmanager.Nm80211Mode); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(gonetworkmanager.Nm80211Mode) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDeviceWireless_GetPropertyMode_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyMode' +type MockDeviceWireless_GetPropertyMode_Call struct { + *mock.Call +} + +// GetPropertyMode is a helper method to define mock.On call +func (_e *MockDeviceWireless_Expecter) GetPropertyMode() *MockDeviceWireless_GetPropertyMode_Call { + return &MockDeviceWireless_GetPropertyMode_Call{Call: _e.mock.On("GetPropertyMode")} +} + +func (_c *MockDeviceWireless_GetPropertyMode_Call) Run(run func()) *MockDeviceWireless_GetPropertyMode_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockDeviceWireless_GetPropertyMode_Call) Return(_a0 gonetworkmanager.Nm80211Mode, _a1 error) *MockDeviceWireless_GetPropertyMode_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDeviceWireless_GetPropertyMode_Call) RunAndReturn(run func() (gonetworkmanager.Nm80211Mode, error)) *MockDeviceWireless_GetPropertyMode_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyMtu provides a mock function with no fields +func (_m *MockDeviceWireless) GetPropertyMtu() (uint32, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyMtu") + } + + var r0 uint32 + var r1 error + if rf, ok := ret.Get(0).(func() (uint32, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() uint32); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(uint32) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDeviceWireless_GetPropertyMtu_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyMtu' +type MockDeviceWireless_GetPropertyMtu_Call struct { + *mock.Call +} + +// GetPropertyMtu is a helper method to define mock.On call +func (_e *MockDeviceWireless_Expecter) GetPropertyMtu() *MockDeviceWireless_GetPropertyMtu_Call { + return &MockDeviceWireless_GetPropertyMtu_Call{Call: _e.mock.On("GetPropertyMtu")} +} + +func (_c *MockDeviceWireless_GetPropertyMtu_Call) Run(run func()) *MockDeviceWireless_GetPropertyMtu_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockDeviceWireless_GetPropertyMtu_Call) Return(_a0 uint32, _a1 error) *MockDeviceWireless_GetPropertyMtu_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDeviceWireless_GetPropertyMtu_Call) RunAndReturn(run func() (uint32, error)) *MockDeviceWireless_GetPropertyMtu_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyNmPluginMissing provides a mock function with no fields +func (_m *MockDeviceWireless) GetPropertyNmPluginMissing() (bool, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyNmPluginMissing") + } + + var r0 bool + var r1 error + if rf, ok := ret.Get(0).(func() (bool, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() bool); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(bool) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDeviceWireless_GetPropertyNmPluginMissing_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyNmPluginMissing' +type MockDeviceWireless_GetPropertyNmPluginMissing_Call struct { + *mock.Call +} + +// GetPropertyNmPluginMissing is a helper method to define mock.On call +func (_e *MockDeviceWireless_Expecter) GetPropertyNmPluginMissing() *MockDeviceWireless_GetPropertyNmPluginMissing_Call { + return &MockDeviceWireless_GetPropertyNmPluginMissing_Call{Call: _e.mock.On("GetPropertyNmPluginMissing")} +} + +func (_c *MockDeviceWireless_GetPropertyNmPluginMissing_Call) Run(run func()) *MockDeviceWireless_GetPropertyNmPluginMissing_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockDeviceWireless_GetPropertyNmPluginMissing_Call) Return(_a0 bool, _a1 error) *MockDeviceWireless_GetPropertyNmPluginMissing_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDeviceWireless_GetPropertyNmPluginMissing_Call) RunAndReturn(run func() (bool, error)) *MockDeviceWireless_GetPropertyNmPluginMissing_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyPermHwAddress provides a mock function with no fields +func (_m *MockDeviceWireless) GetPropertyPermHwAddress() (string, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyPermHwAddress") + } + + var r0 string + var r1 error + if rf, ok := ret.Get(0).(func() (string, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDeviceWireless_GetPropertyPermHwAddress_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyPermHwAddress' +type MockDeviceWireless_GetPropertyPermHwAddress_Call struct { + *mock.Call +} + +// GetPropertyPermHwAddress is a helper method to define mock.On call +func (_e *MockDeviceWireless_Expecter) GetPropertyPermHwAddress() *MockDeviceWireless_GetPropertyPermHwAddress_Call { + return &MockDeviceWireless_GetPropertyPermHwAddress_Call{Call: _e.mock.On("GetPropertyPermHwAddress")} +} + +func (_c *MockDeviceWireless_GetPropertyPermHwAddress_Call) Run(run func()) *MockDeviceWireless_GetPropertyPermHwAddress_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockDeviceWireless_GetPropertyPermHwAddress_Call) Return(_a0 string, _a1 error) *MockDeviceWireless_GetPropertyPermHwAddress_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDeviceWireless_GetPropertyPermHwAddress_Call) RunAndReturn(run func() (string, error)) *MockDeviceWireless_GetPropertyPermHwAddress_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyPhysicalPortId provides a mock function with no fields +func (_m *MockDeviceWireless) GetPropertyPhysicalPortId() (string, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyPhysicalPortId") + } + + var r0 string + var r1 error + if rf, ok := ret.Get(0).(func() (string, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDeviceWireless_GetPropertyPhysicalPortId_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyPhysicalPortId' +type MockDeviceWireless_GetPropertyPhysicalPortId_Call struct { + *mock.Call +} + +// GetPropertyPhysicalPortId is a helper method to define mock.On call +func (_e *MockDeviceWireless_Expecter) GetPropertyPhysicalPortId() *MockDeviceWireless_GetPropertyPhysicalPortId_Call { + return &MockDeviceWireless_GetPropertyPhysicalPortId_Call{Call: _e.mock.On("GetPropertyPhysicalPortId")} +} + +func (_c *MockDeviceWireless_GetPropertyPhysicalPortId_Call) Run(run func()) *MockDeviceWireless_GetPropertyPhysicalPortId_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockDeviceWireless_GetPropertyPhysicalPortId_Call) Return(_a0 string, _a1 error) *MockDeviceWireless_GetPropertyPhysicalPortId_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDeviceWireless_GetPropertyPhysicalPortId_Call) RunAndReturn(run func() (string, error)) *MockDeviceWireless_GetPropertyPhysicalPortId_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyReal provides a mock function with no fields +func (_m *MockDeviceWireless) GetPropertyReal() (bool, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyReal") + } + + var r0 bool + var r1 error + if rf, ok := ret.Get(0).(func() (bool, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() bool); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(bool) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDeviceWireless_GetPropertyReal_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyReal' +type MockDeviceWireless_GetPropertyReal_Call struct { + *mock.Call +} + +// GetPropertyReal is a helper method to define mock.On call +func (_e *MockDeviceWireless_Expecter) GetPropertyReal() *MockDeviceWireless_GetPropertyReal_Call { + return &MockDeviceWireless_GetPropertyReal_Call{Call: _e.mock.On("GetPropertyReal")} +} + +func (_c *MockDeviceWireless_GetPropertyReal_Call) Run(run func()) *MockDeviceWireless_GetPropertyReal_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockDeviceWireless_GetPropertyReal_Call) Return(_a0 bool, _a1 error) *MockDeviceWireless_GetPropertyReal_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDeviceWireless_GetPropertyReal_Call) RunAndReturn(run func() (bool, error)) *MockDeviceWireless_GetPropertyReal_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyState provides a mock function with no fields +func (_m *MockDeviceWireless) GetPropertyState() (gonetworkmanager.NmDeviceState, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyState") + } + + var r0 gonetworkmanager.NmDeviceState + var r1 error + if rf, ok := ret.Get(0).(func() (gonetworkmanager.NmDeviceState, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() gonetworkmanager.NmDeviceState); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(gonetworkmanager.NmDeviceState) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDeviceWireless_GetPropertyState_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyState' +type MockDeviceWireless_GetPropertyState_Call struct { + *mock.Call +} + +// GetPropertyState is a helper method to define mock.On call +func (_e *MockDeviceWireless_Expecter) GetPropertyState() *MockDeviceWireless_GetPropertyState_Call { + return &MockDeviceWireless_GetPropertyState_Call{Call: _e.mock.On("GetPropertyState")} +} + +func (_c *MockDeviceWireless_GetPropertyState_Call) Run(run func()) *MockDeviceWireless_GetPropertyState_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockDeviceWireless_GetPropertyState_Call) Return(_a0 gonetworkmanager.NmDeviceState, _a1 error) *MockDeviceWireless_GetPropertyState_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDeviceWireless_GetPropertyState_Call) RunAndReturn(run func() (gonetworkmanager.NmDeviceState, error)) *MockDeviceWireless_GetPropertyState_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyUdi provides a mock function with no fields +func (_m *MockDeviceWireless) GetPropertyUdi() (string, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyUdi") + } + + var r0 string + var r1 error + if rf, ok := ret.Get(0).(func() (string, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDeviceWireless_GetPropertyUdi_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyUdi' +type MockDeviceWireless_GetPropertyUdi_Call struct { + *mock.Call +} + +// GetPropertyUdi is a helper method to define mock.On call +func (_e *MockDeviceWireless_Expecter) GetPropertyUdi() *MockDeviceWireless_GetPropertyUdi_Call { + return &MockDeviceWireless_GetPropertyUdi_Call{Call: _e.mock.On("GetPropertyUdi")} +} + +func (_c *MockDeviceWireless_GetPropertyUdi_Call) Run(run func()) *MockDeviceWireless_GetPropertyUdi_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockDeviceWireless_GetPropertyUdi_Call) Return(_a0 string, _a1 error) *MockDeviceWireless_GetPropertyUdi_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDeviceWireless_GetPropertyUdi_Call) RunAndReturn(run func() (string, error)) *MockDeviceWireless_GetPropertyUdi_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyWirelessCapabilities provides a mock function with no fields +func (_m *MockDeviceWireless) GetPropertyWirelessCapabilities() (uint32, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyWirelessCapabilities") + } + + var r0 uint32 + var r1 error + if rf, ok := ret.Get(0).(func() (uint32, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() uint32); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(uint32) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDeviceWireless_GetPropertyWirelessCapabilities_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyWirelessCapabilities' +type MockDeviceWireless_GetPropertyWirelessCapabilities_Call struct { + *mock.Call +} + +// GetPropertyWirelessCapabilities is a helper method to define mock.On call +func (_e *MockDeviceWireless_Expecter) GetPropertyWirelessCapabilities() *MockDeviceWireless_GetPropertyWirelessCapabilities_Call { + return &MockDeviceWireless_GetPropertyWirelessCapabilities_Call{Call: _e.mock.On("GetPropertyWirelessCapabilities")} +} + +func (_c *MockDeviceWireless_GetPropertyWirelessCapabilities_Call) Run(run func()) *MockDeviceWireless_GetPropertyWirelessCapabilities_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockDeviceWireless_GetPropertyWirelessCapabilities_Call) Return(_a0 uint32, _a1 error) *MockDeviceWireless_GetPropertyWirelessCapabilities_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDeviceWireless_GetPropertyWirelessCapabilities_Call) RunAndReturn(run func() (uint32, error)) *MockDeviceWireless_GetPropertyWirelessCapabilities_Call { + _c.Call.Return(run) + return _c +} + +// MarshalJSON provides a mock function with no fields +func (_m *MockDeviceWireless) MarshalJSON() ([]byte, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for MarshalJSON") + } + + var r0 []byte + var r1 error + if rf, ok := ret.Get(0).(func() ([]byte, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() []byte); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]byte) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDeviceWireless_MarshalJSON_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MarshalJSON' +type MockDeviceWireless_MarshalJSON_Call struct { + *mock.Call +} + +// MarshalJSON is a helper method to define mock.On call +func (_e *MockDeviceWireless_Expecter) MarshalJSON() *MockDeviceWireless_MarshalJSON_Call { + return &MockDeviceWireless_MarshalJSON_Call{Call: _e.mock.On("MarshalJSON")} +} + +func (_c *MockDeviceWireless_MarshalJSON_Call) Run(run func()) *MockDeviceWireless_MarshalJSON_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockDeviceWireless_MarshalJSON_Call) Return(_a0 []byte, _a1 error) *MockDeviceWireless_MarshalJSON_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDeviceWireless_MarshalJSON_Call) RunAndReturn(run func() ([]byte, error)) *MockDeviceWireless_MarshalJSON_Call { + _c.Call.Return(run) + return _c +} + +// Reapply provides a mock function with given fields: connection, versionId, flags +func (_m *MockDeviceWireless) Reapply(connection gonetworkmanager.Connection, versionId uint64, flags uint32) error { + ret := _m.Called(connection, versionId, flags) + + if len(ret) == 0 { + panic("no return value specified for Reapply") + } + + var r0 error + if rf, ok := ret.Get(0).(func(gonetworkmanager.Connection, uint64, uint32) error); ok { + r0 = rf(connection, versionId, flags) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockDeviceWireless_Reapply_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Reapply' +type MockDeviceWireless_Reapply_Call struct { + *mock.Call +} + +// Reapply is a helper method to define mock.On call +// - connection gonetworkmanager.Connection +// - versionId uint64 +// - flags uint32 +func (_e *MockDeviceWireless_Expecter) Reapply(connection interface{}, versionId interface{}, flags interface{}) *MockDeviceWireless_Reapply_Call { + return &MockDeviceWireless_Reapply_Call{Call: _e.mock.On("Reapply", connection, versionId, flags)} +} + +func (_c *MockDeviceWireless_Reapply_Call) Run(run func(connection gonetworkmanager.Connection, versionId uint64, flags uint32)) *MockDeviceWireless_Reapply_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(gonetworkmanager.Connection), args[1].(uint64), args[2].(uint32)) + }) + return _c +} + +func (_c *MockDeviceWireless_Reapply_Call) Return(_a0 error) *MockDeviceWireless_Reapply_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockDeviceWireless_Reapply_Call) RunAndReturn(run func(gonetworkmanager.Connection, uint64, uint32) error) *MockDeviceWireless_Reapply_Call { + _c.Call.Return(run) + return _c +} + +// RequestScan provides a mock function with no fields +func (_m *MockDeviceWireless) RequestScan() error { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for RequestScan") + } + + var r0 error + if rf, ok := ret.Get(0).(func() error); ok { + r0 = rf() + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockDeviceWireless_RequestScan_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RequestScan' +type MockDeviceWireless_RequestScan_Call struct { + *mock.Call +} + +// RequestScan is a helper method to define mock.On call +func (_e *MockDeviceWireless_Expecter) RequestScan() *MockDeviceWireless_RequestScan_Call { + return &MockDeviceWireless_RequestScan_Call{Call: _e.mock.On("RequestScan")} +} + +func (_c *MockDeviceWireless_RequestScan_Call) Run(run func()) *MockDeviceWireless_RequestScan_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockDeviceWireless_RequestScan_Call) Return(_a0 error) *MockDeviceWireless_RequestScan_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockDeviceWireless_RequestScan_Call) RunAndReturn(run func() error) *MockDeviceWireless_RequestScan_Call { + _c.Call.Return(run) + return _c +} + +// SetPropertyAutoConnect provides a mock function with given fields: _a0 +func (_m *MockDeviceWireless) SetPropertyAutoConnect(_a0 bool) error { + ret := _m.Called(_a0) + + if len(ret) == 0 { + panic("no return value specified for SetPropertyAutoConnect") + } + + var r0 error + if rf, ok := ret.Get(0).(func(bool) error); ok { + r0 = rf(_a0) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockDeviceWireless_SetPropertyAutoConnect_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetPropertyAutoConnect' +type MockDeviceWireless_SetPropertyAutoConnect_Call struct { + *mock.Call +} + +// SetPropertyAutoConnect is a helper method to define mock.On call +// - _a0 bool +func (_e *MockDeviceWireless_Expecter) SetPropertyAutoConnect(_a0 interface{}) *MockDeviceWireless_SetPropertyAutoConnect_Call { + return &MockDeviceWireless_SetPropertyAutoConnect_Call{Call: _e.mock.On("SetPropertyAutoConnect", _a0)} +} + +func (_c *MockDeviceWireless_SetPropertyAutoConnect_Call) Run(run func(_a0 bool)) *MockDeviceWireless_SetPropertyAutoConnect_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(bool)) + }) + return _c +} + +func (_c *MockDeviceWireless_SetPropertyAutoConnect_Call) Return(_a0 error) *MockDeviceWireless_SetPropertyAutoConnect_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockDeviceWireless_SetPropertyAutoConnect_Call) RunAndReturn(run func(bool) error) *MockDeviceWireless_SetPropertyAutoConnect_Call { + _c.Call.Return(run) + return _c +} + +// SetPropertyManaged provides a mock function with given fields: _a0 +func (_m *MockDeviceWireless) SetPropertyManaged(_a0 bool) error { + ret := _m.Called(_a0) + + if len(ret) == 0 { + panic("no return value specified for SetPropertyManaged") + } + + var r0 error + if rf, ok := ret.Get(0).(func(bool) error); ok { + r0 = rf(_a0) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockDeviceWireless_SetPropertyManaged_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetPropertyManaged' +type MockDeviceWireless_SetPropertyManaged_Call struct { + *mock.Call +} + +// SetPropertyManaged is a helper method to define mock.On call +// - _a0 bool +func (_e *MockDeviceWireless_Expecter) SetPropertyManaged(_a0 interface{}) *MockDeviceWireless_SetPropertyManaged_Call { + return &MockDeviceWireless_SetPropertyManaged_Call{Call: _e.mock.On("SetPropertyManaged", _a0)} +} + +func (_c *MockDeviceWireless_SetPropertyManaged_Call) Run(run func(_a0 bool)) *MockDeviceWireless_SetPropertyManaged_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(bool)) + }) + return _c +} + +func (_c *MockDeviceWireless_SetPropertyManaged_Call) Return(_a0 error) *MockDeviceWireless_SetPropertyManaged_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockDeviceWireless_SetPropertyManaged_Call) RunAndReturn(run func(bool) error) *MockDeviceWireless_SetPropertyManaged_Call { + _c.Call.Return(run) + return _c +} + +// SubscribeState provides a mock function with given fields: receiver, exit +func (_m *MockDeviceWireless) SubscribeState(receiver chan gonetworkmanager.DeviceStateChange, exit chan struct{}) error { + ret := _m.Called(receiver, exit) + + if len(ret) == 0 { + panic("no return value specified for SubscribeState") + } + + var r0 error + if rf, ok := ret.Get(0).(func(chan gonetworkmanager.DeviceStateChange, chan struct{}) error); ok { + r0 = rf(receiver, exit) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockDeviceWireless_SubscribeState_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SubscribeState' +type MockDeviceWireless_SubscribeState_Call struct { + *mock.Call +} + +// SubscribeState is a helper method to define mock.On call +// - receiver chan gonetworkmanager.DeviceStateChange +// - exit chan struct{} +func (_e *MockDeviceWireless_Expecter) SubscribeState(receiver interface{}, exit interface{}) *MockDeviceWireless_SubscribeState_Call { + return &MockDeviceWireless_SubscribeState_Call{Call: _e.mock.On("SubscribeState", receiver, exit)} +} + +func (_c *MockDeviceWireless_SubscribeState_Call) Run(run func(receiver chan gonetworkmanager.DeviceStateChange, exit chan struct{})) *MockDeviceWireless_SubscribeState_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(chan gonetworkmanager.DeviceStateChange), args[1].(chan struct{})) + }) + return _c +} + +func (_c *MockDeviceWireless_SubscribeState_Call) Return(err error) *MockDeviceWireless_SubscribeState_Call { + _c.Call.Return(err) + return _c +} + +func (_c *MockDeviceWireless_SubscribeState_Call) RunAndReturn(run func(chan gonetworkmanager.DeviceStateChange, chan struct{}) error) *MockDeviceWireless_SubscribeState_Call { + _c.Call.Return(run) + return _c +} + +// NewMockDeviceWireless creates a new instance of MockDeviceWireless. 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 NewMockDeviceWireless(t interface { + mock.TestingT + Cleanup(func()) +}) *MockDeviceWireless { + mock := &MockDeviceWireless{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/github.com/Wifx/gonetworkmanager/v2/mock_IP4Config.go b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/github.com/Wifx/gonetworkmanager/v2/mock_IP4Config.go new file mode 100644 index 0000000..235be86 --- /dev/null +++ b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/github.com/Wifx/gonetworkmanager/v2/mock_IP4Config.go @@ -0,0 +1,772 @@ +// Code generated by mockery v2.53.5. DO NOT EDIT. + +package gonetworkmanager + +import ( + gonetworkmanager "github.com/Wifx/gonetworkmanager/v2" + mock "github.com/stretchr/testify/mock" +) + +// MockIP4Config is an autogenerated mock type for the IP4Config type +type MockIP4Config struct { + mock.Mock +} + +type MockIP4Config_Expecter struct { + mock *mock.Mock +} + +func (_m *MockIP4Config) EXPECT() *MockIP4Config_Expecter { + return &MockIP4Config_Expecter{mock: &_m.Mock} +} + +// GetPropertyAddressData provides a mock function with no fields +func (_m *MockIP4Config) GetPropertyAddressData() ([]gonetworkmanager.IP4AddressData, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyAddressData") + } + + var r0 []gonetworkmanager.IP4AddressData + var r1 error + if rf, ok := ret.Get(0).(func() ([]gonetworkmanager.IP4AddressData, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() []gonetworkmanager.IP4AddressData); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]gonetworkmanager.IP4AddressData) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockIP4Config_GetPropertyAddressData_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyAddressData' +type MockIP4Config_GetPropertyAddressData_Call struct { + *mock.Call +} + +// GetPropertyAddressData is a helper method to define mock.On call +func (_e *MockIP4Config_Expecter) GetPropertyAddressData() *MockIP4Config_GetPropertyAddressData_Call { + return &MockIP4Config_GetPropertyAddressData_Call{Call: _e.mock.On("GetPropertyAddressData")} +} + +func (_c *MockIP4Config_GetPropertyAddressData_Call) Run(run func()) *MockIP4Config_GetPropertyAddressData_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockIP4Config_GetPropertyAddressData_Call) Return(_a0 []gonetworkmanager.IP4AddressData, _a1 error) *MockIP4Config_GetPropertyAddressData_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockIP4Config_GetPropertyAddressData_Call) RunAndReturn(run func() ([]gonetworkmanager.IP4AddressData, error)) *MockIP4Config_GetPropertyAddressData_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyAddresses provides a mock function with no fields +func (_m *MockIP4Config) GetPropertyAddresses() ([]gonetworkmanager.IP4Address, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyAddresses") + } + + var r0 []gonetworkmanager.IP4Address + var r1 error + if rf, ok := ret.Get(0).(func() ([]gonetworkmanager.IP4Address, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() []gonetworkmanager.IP4Address); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]gonetworkmanager.IP4Address) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockIP4Config_GetPropertyAddresses_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyAddresses' +type MockIP4Config_GetPropertyAddresses_Call struct { + *mock.Call +} + +// GetPropertyAddresses is a helper method to define mock.On call +func (_e *MockIP4Config_Expecter) GetPropertyAddresses() *MockIP4Config_GetPropertyAddresses_Call { + return &MockIP4Config_GetPropertyAddresses_Call{Call: _e.mock.On("GetPropertyAddresses")} +} + +func (_c *MockIP4Config_GetPropertyAddresses_Call) Run(run func()) *MockIP4Config_GetPropertyAddresses_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockIP4Config_GetPropertyAddresses_Call) Return(_a0 []gonetworkmanager.IP4Address, _a1 error) *MockIP4Config_GetPropertyAddresses_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockIP4Config_GetPropertyAddresses_Call) RunAndReturn(run func() ([]gonetworkmanager.IP4Address, error)) *MockIP4Config_GetPropertyAddresses_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyDnsOptions provides a mock function with no fields +func (_m *MockIP4Config) GetPropertyDnsOptions() ([]string, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyDnsOptions") + } + + var r0 []string + var r1 error + if rf, ok := ret.Get(0).(func() ([]string, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() []string); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]string) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockIP4Config_GetPropertyDnsOptions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyDnsOptions' +type MockIP4Config_GetPropertyDnsOptions_Call struct { + *mock.Call +} + +// GetPropertyDnsOptions is a helper method to define mock.On call +func (_e *MockIP4Config_Expecter) GetPropertyDnsOptions() *MockIP4Config_GetPropertyDnsOptions_Call { + return &MockIP4Config_GetPropertyDnsOptions_Call{Call: _e.mock.On("GetPropertyDnsOptions")} +} + +func (_c *MockIP4Config_GetPropertyDnsOptions_Call) Run(run func()) *MockIP4Config_GetPropertyDnsOptions_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockIP4Config_GetPropertyDnsOptions_Call) Return(_a0 []string, _a1 error) *MockIP4Config_GetPropertyDnsOptions_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockIP4Config_GetPropertyDnsOptions_Call) RunAndReturn(run func() ([]string, error)) *MockIP4Config_GetPropertyDnsOptions_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyDnsPriority provides a mock function with no fields +func (_m *MockIP4Config) GetPropertyDnsPriority() (uint32, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyDnsPriority") + } + + var r0 uint32 + var r1 error + if rf, ok := ret.Get(0).(func() (uint32, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() uint32); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(uint32) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockIP4Config_GetPropertyDnsPriority_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyDnsPriority' +type MockIP4Config_GetPropertyDnsPriority_Call struct { + *mock.Call +} + +// GetPropertyDnsPriority is a helper method to define mock.On call +func (_e *MockIP4Config_Expecter) GetPropertyDnsPriority() *MockIP4Config_GetPropertyDnsPriority_Call { + return &MockIP4Config_GetPropertyDnsPriority_Call{Call: _e.mock.On("GetPropertyDnsPriority")} +} + +func (_c *MockIP4Config_GetPropertyDnsPriority_Call) Run(run func()) *MockIP4Config_GetPropertyDnsPriority_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockIP4Config_GetPropertyDnsPriority_Call) Return(_a0 uint32, _a1 error) *MockIP4Config_GetPropertyDnsPriority_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockIP4Config_GetPropertyDnsPriority_Call) RunAndReturn(run func() (uint32, error)) *MockIP4Config_GetPropertyDnsPriority_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyDomains provides a mock function with no fields +func (_m *MockIP4Config) GetPropertyDomains() ([]string, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyDomains") + } + + var r0 []string + var r1 error + if rf, ok := ret.Get(0).(func() ([]string, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() []string); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]string) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockIP4Config_GetPropertyDomains_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyDomains' +type MockIP4Config_GetPropertyDomains_Call struct { + *mock.Call +} + +// GetPropertyDomains is a helper method to define mock.On call +func (_e *MockIP4Config_Expecter) GetPropertyDomains() *MockIP4Config_GetPropertyDomains_Call { + return &MockIP4Config_GetPropertyDomains_Call{Call: _e.mock.On("GetPropertyDomains")} +} + +func (_c *MockIP4Config_GetPropertyDomains_Call) Run(run func()) *MockIP4Config_GetPropertyDomains_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockIP4Config_GetPropertyDomains_Call) Return(_a0 []string, _a1 error) *MockIP4Config_GetPropertyDomains_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockIP4Config_GetPropertyDomains_Call) RunAndReturn(run func() ([]string, error)) *MockIP4Config_GetPropertyDomains_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyGateway provides a mock function with no fields +func (_m *MockIP4Config) GetPropertyGateway() (string, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyGateway") + } + + var r0 string + var r1 error + if rf, ok := ret.Get(0).(func() (string, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockIP4Config_GetPropertyGateway_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyGateway' +type MockIP4Config_GetPropertyGateway_Call struct { + *mock.Call +} + +// GetPropertyGateway is a helper method to define mock.On call +func (_e *MockIP4Config_Expecter) GetPropertyGateway() *MockIP4Config_GetPropertyGateway_Call { + return &MockIP4Config_GetPropertyGateway_Call{Call: _e.mock.On("GetPropertyGateway")} +} + +func (_c *MockIP4Config_GetPropertyGateway_Call) Run(run func()) *MockIP4Config_GetPropertyGateway_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockIP4Config_GetPropertyGateway_Call) Return(_a0 string, _a1 error) *MockIP4Config_GetPropertyGateway_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockIP4Config_GetPropertyGateway_Call) RunAndReturn(run func() (string, error)) *MockIP4Config_GetPropertyGateway_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyNameserverData provides a mock function with no fields +func (_m *MockIP4Config) GetPropertyNameserverData() ([]gonetworkmanager.IP4NameserverData, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyNameserverData") + } + + var r0 []gonetworkmanager.IP4NameserverData + var r1 error + if rf, ok := ret.Get(0).(func() ([]gonetworkmanager.IP4NameserverData, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() []gonetworkmanager.IP4NameserverData); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]gonetworkmanager.IP4NameserverData) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockIP4Config_GetPropertyNameserverData_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyNameserverData' +type MockIP4Config_GetPropertyNameserverData_Call struct { + *mock.Call +} + +// GetPropertyNameserverData is a helper method to define mock.On call +func (_e *MockIP4Config_Expecter) GetPropertyNameserverData() *MockIP4Config_GetPropertyNameserverData_Call { + return &MockIP4Config_GetPropertyNameserverData_Call{Call: _e.mock.On("GetPropertyNameserverData")} +} + +func (_c *MockIP4Config_GetPropertyNameserverData_Call) Run(run func()) *MockIP4Config_GetPropertyNameserverData_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockIP4Config_GetPropertyNameserverData_Call) Return(_a0 []gonetworkmanager.IP4NameserverData, _a1 error) *MockIP4Config_GetPropertyNameserverData_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockIP4Config_GetPropertyNameserverData_Call) RunAndReturn(run func() ([]gonetworkmanager.IP4NameserverData, error)) *MockIP4Config_GetPropertyNameserverData_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyNameservers provides a mock function with no fields +func (_m *MockIP4Config) GetPropertyNameservers() ([]string, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyNameservers") + } + + var r0 []string + var r1 error + if rf, ok := ret.Get(0).(func() ([]string, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() []string); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]string) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockIP4Config_GetPropertyNameservers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyNameservers' +type MockIP4Config_GetPropertyNameservers_Call struct { + *mock.Call +} + +// GetPropertyNameservers is a helper method to define mock.On call +func (_e *MockIP4Config_Expecter) GetPropertyNameservers() *MockIP4Config_GetPropertyNameservers_Call { + return &MockIP4Config_GetPropertyNameservers_Call{Call: _e.mock.On("GetPropertyNameservers")} +} + +func (_c *MockIP4Config_GetPropertyNameservers_Call) Run(run func()) *MockIP4Config_GetPropertyNameservers_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockIP4Config_GetPropertyNameservers_Call) Return(_a0 []string, _a1 error) *MockIP4Config_GetPropertyNameservers_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockIP4Config_GetPropertyNameservers_Call) RunAndReturn(run func() ([]string, error)) *MockIP4Config_GetPropertyNameservers_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyRouteData provides a mock function with no fields +func (_m *MockIP4Config) GetPropertyRouteData() ([]gonetworkmanager.IP4RouteData, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyRouteData") + } + + var r0 []gonetworkmanager.IP4RouteData + var r1 error + if rf, ok := ret.Get(0).(func() ([]gonetworkmanager.IP4RouteData, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() []gonetworkmanager.IP4RouteData); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]gonetworkmanager.IP4RouteData) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockIP4Config_GetPropertyRouteData_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyRouteData' +type MockIP4Config_GetPropertyRouteData_Call struct { + *mock.Call +} + +// GetPropertyRouteData is a helper method to define mock.On call +func (_e *MockIP4Config_Expecter) GetPropertyRouteData() *MockIP4Config_GetPropertyRouteData_Call { + return &MockIP4Config_GetPropertyRouteData_Call{Call: _e.mock.On("GetPropertyRouteData")} +} + +func (_c *MockIP4Config_GetPropertyRouteData_Call) Run(run func()) *MockIP4Config_GetPropertyRouteData_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockIP4Config_GetPropertyRouteData_Call) Return(_a0 []gonetworkmanager.IP4RouteData, _a1 error) *MockIP4Config_GetPropertyRouteData_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockIP4Config_GetPropertyRouteData_Call) RunAndReturn(run func() ([]gonetworkmanager.IP4RouteData, error)) *MockIP4Config_GetPropertyRouteData_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyRoutes provides a mock function with no fields +func (_m *MockIP4Config) GetPropertyRoutes() ([]gonetworkmanager.IP4Route, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyRoutes") + } + + var r0 []gonetworkmanager.IP4Route + var r1 error + if rf, ok := ret.Get(0).(func() ([]gonetworkmanager.IP4Route, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() []gonetworkmanager.IP4Route); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]gonetworkmanager.IP4Route) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockIP4Config_GetPropertyRoutes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyRoutes' +type MockIP4Config_GetPropertyRoutes_Call struct { + *mock.Call +} + +// GetPropertyRoutes is a helper method to define mock.On call +func (_e *MockIP4Config_Expecter) GetPropertyRoutes() *MockIP4Config_GetPropertyRoutes_Call { + return &MockIP4Config_GetPropertyRoutes_Call{Call: _e.mock.On("GetPropertyRoutes")} +} + +func (_c *MockIP4Config_GetPropertyRoutes_Call) Run(run func()) *MockIP4Config_GetPropertyRoutes_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockIP4Config_GetPropertyRoutes_Call) Return(_a0 []gonetworkmanager.IP4Route, _a1 error) *MockIP4Config_GetPropertyRoutes_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockIP4Config_GetPropertyRoutes_Call) RunAndReturn(run func() ([]gonetworkmanager.IP4Route, error)) *MockIP4Config_GetPropertyRoutes_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertySearches provides a mock function with no fields +func (_m *MockIP4Config) GetPropertySearches() ([]string, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertySearches") + } + + var r0 []string + var r1 error + if rf, ok := ret.Get(0).(func() ([]string, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() []string); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]string) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockIP4Config_GetPropertySearches_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertySearches' +type MockIP4Config_GetPropertySearches_Call struct { + *mock.Call +} + +// GetPropertySearches is a helper method to define mock.On call +func (_e *MockIP4Config_Expecter) GetPropertySearches() *MockIP4Config_GetPropertySearches_Call { + return &MockIP4Config_GetPropertySearches_Call{Call: _e.mock.On("GetPropertySearches")} +} + +func (_c *MockIP4Config_GetPropertySearches_Call) Run(run func()) *MockIP4Config_GetPropertySearches_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockIP4Config_GetPropertySearches_Call) Return(_a0 []string, _a1 error) *MockIP4Config_GetPropertySearches_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockIP4Config_GetPropertySearches_Call) RunAndReturn(run func() ([]string, error)) *MockIP4Config_GetPropertySearches_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyWinsServerData provides a mock function with no fields +func (_m *MockIP4Config) GetPropertyWinsServerData() ([]string, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyWinsServerData") + } + + var r0 []string + var r1 error + if rf, ok := ret.Get(0).(func() ([]string, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() []string); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]string) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockIP4Config_GetPropertyWinsServerData_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyWinsServerData' +type MockIP4Config_GetPropertyWinsServerData_Call struct { + *mock.Call +} + +// GetPropertyWinsServerData is a helper method to define mock.On call +func (_e *MockIP4Config_Expecter) GetPropertyWinsServerData() *MockIP4Config_GetPropertyWinsServerData_Call { + return &MockIP4Config_GetPropertyWinsServerData_Call{Call: _e.mock.On("GetPropertyWinsServerData")} +} + +func (_c *MockIP4Config_GetPropertyWinsServerData_Call) Run(run func()) *MockIP4Config_GetPropertyWinsServerData_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockIP4Config_GetPropertyWinsServerData_Call) Return(_a0 []string, _a1 error) *MockIP4Config_GetPropertyWinsServerData_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockIP4Config_GetPropertyWinsServerData_Call) RunAndReturn(run func() ([]string, error)) *MockIP4Config_GetPropertyWinsServerData_Call { + _c.Call.Return(run) + return _c +} + +// MarshalJSON provides a mock function with no fields +func (_m *MockIP4Config) MarshalJSON() ([]byte, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for MarshalJSON") + } + + var r0 []byte + var r1 error + if rf, ok := ret.Get(0).(func() ([]byte, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() []byte); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]byte) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockIP4Config_MarshalJSON_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MarshalJSON' +type MockIP4Config_MarshalJSON_Call struct { + *mock.Call +} + +// MarshalJSON is a helper method to define mock.On call +func (_e *MockIP4Config_Expecter) MarshalJSON() *MockIP4Config_MarshalJSON_Call { + return &MockIP4Config_MarshalJSON_Call{Call: _e.mock.On("MarshalJSON")} +} + +func (_c *MockIP4Config_MarshalJSON_Call) Run(run func()) *MockIP4Config_MarshalJSON_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockIP4Config_MarshalJSON_Call) Return(_a0 []byte, _a1 error) *MockIP4Config_MarshalJSON_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockIP4Config_MarshalJSON_Call) RunAndReturn(run func() ([]byte, error)) *MockIP4Config_MarshalJSON_Call { + _c.Call.Return(run) + return _c +} + +// NewMockIP4Config creates a new instance of MockIP4Config. 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 NewMockIP4Config(t interface { + mock.TestingT + Cleanup(func()) +}) *MockIP4Config { + mock := &MockIP4Config{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/github.com/Wifx/gonetworkmanager/v2/mock_NetworkManager.go b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/github.com/Wifx/gonetworkmanager/v2/mock_NetworkManager.go new file mode 100644 index 0000000..e74ffb0 --- /dev/null +++ b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/github.com/Wifx/gonetworkmanager/v2/mock_NetworkManager.go @@ -0,0 +1,2349 @@ +// Code generated by mockery v2.53.5. DO NOT EDIT. + +package gonetworkmanager + +import ( + gonetworkmanager "github.com/Wifx/gonetworkmanager/v2" + dbus "github.com/godbus/dbus/v5" + + mock "github.com/stretchr/testify/mock" +) + +// MockNetworkManager is an autogenerated mock type for the NetworkManager type +type MockNetworkManager struct { + mock.Mock +} + +type MockNetworkManager_Expecter struct { + mock *mock.Mock +} + +func (_m *MockNetworkManager) EXPECT() *MockNetworkManager_Expecter { + return &MockNetworkManager_Expecter{mock: &_m.Mock} +} + +// ActivateConnection provides a mock function with given fields: connection, device, specificObject +func (_m *MockNetworkManager) ActivateConnection(connection gonetworkmanager.Connection, device gonetworkmanager.Device, specificObject *dbus.Object) (gonetworkmanager.ActiveConnection, error) { + ret := _m.Called(connection, device, specificObject) + + if len(ret) == 0 { + panic("no return value specified for ActivateConnection") + } + + var r0 gonetworkmanager.ActiveConnection + var r1 error + if rf, ok := ret.Get(0).(func(gonetworkmanager.Connection, gonetworkmanager.Device, *dbus.Object) (gonetworkmanager.ActiveConnection, error)); ok { + return rf(connection, device, specificObject) + } + if rf, ok := ret.Get(0).(func(gonetworkmanager.Connection, gonetworkmanager.Device, *dbus.Object) gonetworkmanager.ActiveConnection); ok { + r0 = rf(connection, device, specificObject) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(gonetworkmanager.ActiveConnection) + } + } + + if rf, ok := ret.Get(1).(func(gonetworkmanager.Connection, gonetworkmanager.Device, *dbus.Object) error); ok { + r1 = rf(connection, device, specificObject) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockNetworkManager_ActivateConnection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ActivateConnection' +type MockNetworkManager_ActivateConnection_Call struct { + *mock.Call +} + +// ActivateConnection is a helper method to define mock.On call +// - connection gonetworkmanager.Connection +// - device gonetworkmanager.Device +// - specificObject *dbus.Object +func (_e *MockNetworkManager_Expecter) ActivateConnection(connection interface{}, device interface{}, specificObject interface{}) *MockNetworkManager_ActivateConnection_Call { + return &MockNetworkManager_ActivateConnection_Call{Call: _e.mock.On("ActivateConnection", connection, device, specificObject)} +} + +func (_c *MockNetworkManager_ActivateConnection_Call) Run(run func(connection gonetworkmanager.Connection, device gonetworkmanager.Device, specificObject *dbus.Object)) *MockNetworkManager_ActivateConnection_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(gonetworkmanager.Connection), args[1].(gonetworkmanager.Device), args[2].(*dbus.Object)) + }) + return _c +} + +func (_c *MockNetworkManager_ActivateConnection_Call) Return(_a0 gonetworkmanager.ActiveConnection, _a1 error) *MockNetworkManager_ActivateConnection_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockNetworkManager_ActivateConnection_Call) RunAndReturn(run func(gonetworkmanager.Connection, gonetworkmanager.Device, *dbus.Object) (gonetworkmanager.ActiveConnection, error)) *MockNetworkManager_ActivateConnection_Call { + _c.Call.Return(run) + return _c +} + +// ActivateWirelessConnection provides a mock function with given fields: connection, device, accessPoint +func (_m *MockNetworkManager) ActivateWirelessConnection(connection gonetworkmanager.Connection, device gonetworkmanager.Device, accessPoint gonetworkmanager.AccessPoint) (gonetworkmanager.ActiveConnection, error) { + ret := _m.Called(connection, device, accessPoint) + + if len(ret) == 0 { + panic("no return value specified for ActivateWirelessConnection") + } + + var r0 gonetworkmanager.ActiveConnection + var r1 error + if rf, ok := ret.Get(0).(func(gonetworkmanager.Connection, gonetworkmanager.Device, gonetworkmanager.AccessPoint) (gonetworkmanager.ActiveConnection, error)); ok { + return rf(connection, device, accessPoint) + } + if rf, ok := ret.Get(0).(func(gonetworkmanager.Connection, gonetworkmanager.Device, gonetworkmanager.AccessPoint) gonetworkmanager.ActiveConnection); ok { + r0 = rf(connection, device, accessPoint) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(gonetworkmanager.ActiveConnection) + } + } + + if rf, ok := ret.Get(1).(func(gonetworkmanager.Connection, gonetworkmanager.Device, gonetworkmanager.AccessPoint) error); ok { + r1 = rf(connection, device, accessPoint) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockNetworkManager_ActivateWirelessConnection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ActivateWirelessConnection' +type MockNetworkManager_ActivateWirelessConnection_Call struct { + *mock.Call +} + +// ActivateWirelessConnection is a helper method to define mock.On call +// - connection gonetworkmanager.Connection +// - device gonetworkmanager.Device +// - accessPoint gonetworkmanager.AccessPoint +func (_e *MockNetworkManager_Expecter) ActivateWirelessConnection(connection interface{}, device interface{}, accessPoint interface{}) *MockNetworkManager_ActivateWirelessConnection_Call { + return &MockNetworkManager_ActivateWirelessConnection_Call{Call: _e.mock.On("ActivateWirelessConnection", connection, device, accessPoint)} +} + +func (_c *MockNetworkManager_ActivateWirelessConnection_Call) Run(run func(connection gonetworkmanager.Connection, device gonetworkmanager.Device, accessPoint gonetworkmanager.AccessPoint)) *MockNetworkManager_ActivateWirelessConnection_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(gonetworkmanager.Connection), args[1].(gonetworkmanager.Device), args[2].(gonetworkmanager.AccessPoint)) + }) + return _c +} + +func (_c *MockNetworkManager_ActivateWirelessConnection_Call) Return(_a0 gonetworkmanager.ActiveConnection, _a1 error) *MockNetworkManager_ActivateWirelessConnection_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockNetworkManager_ActivateWirelessConnection_Call) RunAndReturn(run func(gonetworkmanager.Connection, gonetworkmanager.Device, gonetworkmanager.AccessPoint) (gonetworkmanager.ActiveConnection, error)) *MockNetworkManager_ActivateWirelessConnection_Call { + _c.Call.Return(run) + return _c +} + +// AddAndActivateConnection provides a mock function with given fields: connection, device +func (_m *MockNetworkManager) AddAndActivateConnection(connection map[string]map[string]interface{}, device gonetworkmanager.Device) (gonetworkmanager.ActiveConnection, error) { + ret := _m.Called(connection, device) + + if len(ret) == 0 { + panic("no return value specified for AddAndActivateConnection") + } + + var r0 gonetworkmanager.ActiveConnection + var r1 error + if rf, ok := ret.Get(0).(func(map[string]map[string]interface{}, gonetworkmanager.Device) (gonetworkmanager.ActiveConnection, error)); ok { + return rf(connection, device) + } + if rf, ok := ret.Get(0).(func(map[string]map[string]interface{}, gonetworkmanager.Device) gonetworkmanager.ActiveConnection); ok { + r0 = rf(connection, device) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(gonetworkmanager.ActiveConnection) + } + } + + if rf, ok := ret.Get(1).(func(map[string]map[string]interface{}, gonetworkmanager.Device) error); ok { + r1 = rf(connection, device) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockNetworkManager_AddAndActivateConnection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddAndActivateConnection' +type MockNetworkManager_AddAndActivateConnection_Call struct { + *mock.Call +} + +// AddAndActivateConnection is a helper method to define mock.On call +// - connection map[string]map[string]interface{} +// - device gonetworkmanager.Device +func (_e *MockNetworkManager_Expecter) AddAndActivateConnection(connection interface{}, device interface{}) *MockNetworkManager_AddAndActivateConnection_Call { + return &MockNetworkManager_AddAndActivateConnection_Call{Call: _e.mock.On("AddAndActivateConnection", connection, device)} +} + +func (_c *MockNetworkManager_AddAndActivateConnection_Call) Run(run func(connection map[string]map[string]interface{}, device gonetworkmanager.Device)) *MockNetworkManager_AddAndActivateConnection_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(map[string]map[string]interface{}), args[1].(gonetworkmanager.Device)) + }) + return _c +} + +func (_c *MockNetworkManager_AddAndActivateConnection_Call) Return(_a0 gonetworkmanager.ActiveConnection, _a1 error) *MockNetworkManager_AddAndActivateConnection_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockNetworkManager_AddAndActivateConnection_Call) RunAndReturn(run func(map[string]map[string]interface{}, gonetworkmanager.Device) (gonetworkmanager.ActiveConnection, error)) *MockNetworkManager_AddAndActivateConnection_Call { + _c.Call.Return(run) + return _c +} + +// AddAndActivateWirelessConnection provides a mock function with given fields: connection, device, accessPoint +func (_m *MockNetworkManager) AddAndActivateWirelessConnection(connection map[string]map[string]interface{}, device gonetworkmanager.Device, accessPoint gonetworkmanager.AccessPoint) (gonetworkmanager.ActiveConnection, error) { + ret := _m.Called(connection, device, accessPoint) + + if len(ret) == 0 { + panic("no return value specified for AddAndActivateWirelessConnection") + } + + var r0 gonetworkmanager.ActiveConnection + var r1 error + if rf, ok := ret.Get(0).(func(map[string]map[string]interface{}, gonetworkmanager.Device, gonetworkmanager.AccessPoint) (gonetworkmanager.ActiveConnection, error)); ok { + return rf(connection, device, accessPoint) + } + if rf, ok := ret.Get(0).(func(map[string]map[string]interface{}, gonetworkmanager.Device, gonetworkmanager.AccessPoint) gonetworkmanager.ActiveConnection); ok { + r0 = rf(connection, device, accessPoint) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(gonetworkmanager.ActiveConnection) + } + } + + if rf, ok := ret.Get(1).(func(map[string]map[string]interface{}, gonetworkmanager.Device, gonetworkmanager.AccessPoint) error); ok { + r1 = rf(connection, device, accessPoint) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockNetworkManager_AddAndActivateWirelessConnection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddAndActivateWirelessConnection' +type MockNetworkManager_AddAndActivateWirelessConnection_Call struct { + *mock.Call +} + +// AddAndActivateWirelessConnection is a helper method to define mock.On call +// - connection map[string]map[string]interface{} +// - device gonetworkmanager.Device +// - accessPoint gonetworkmanager.AccessPoint +func (_e *MockNetworkManager_Expecter) AddAndActivateWirelessConnection(connection interface{}, device interface{}, accessPoint interface{}) *MockNetworkManager_AddAndActivateWirelessConnection_Call { + return &MockNetworkManager_AddAndActivateWirelessConnection_Call{Call: _e.mock.On("AddAndActivateWirelessConnection", connection, device, accessPoint)} +} + +func (_c *MockNetworkManager_AddAndActivateWirelessConnection_Call) Run(run func(connection map[string]map[string]interface{}, device gonetworkmanager.Device, accessPoint gonetworkmanager.AccessPoint)) *MockNetworkManager_AddAndActivateWirelessConnection_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(map[string]map[string]interface{}), args[1].(gonetworkmanager.Device), args[2].(gonetworkmanager.AccessPoint)) + }) + return _c +} + +func (_c *MockNetworkManager_AddAndActivateWirelessConnection_Call) Return(_a0 gonetworkmanager.ActiveConnection, _a1 error) *MockNetworkManager_AddAndActivateWirelessConnection_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockNetworkManager_AddAndActivateWirelessConnection_Call) RunAndReturn(run func(map[string]map[string]interface{}, gonetworkmanager.Device, gonetworkmanager.AccessPoint) (gonetworkmanager.ActiveConnection, error)) *MockNetworkManager_AddAndActivateWirelessConnection_Call { + _c.Call.Return(run) + return _c +} + +// CheckConnectivity provides a mock function with no fields +func (_m *MockNetworkManager) CheckConnectivity() error { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for CheckConnectivity") + } + + var r0 error + if rf, ok := ret.Get(0).(func() error); ok { + r0 = rf() + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockNetworkManager_CheckConnectivity_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CheckConnectivity' +type MockNetworkManager_CheckConnectivity_Call struct { + *mock.Call +} + +// CheckConnectivity is a helper method to define mock.On call +func (_e *MockNetworkManager_Expecter) CheckConnectivity() *MockNetworkManager_CheckConnectivity_Call { + return &MockNetworkManager_CheckConnectivity_Call{Call: _e.mock.On("CheckConnectivity")} +} + +func (_c *MockNetworkManager_CheckConnectivity_Call) Run(run func()) *MockNetworkManager_CheckConnectivity_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockNetworkManager_CheckConnectivity_Call) Return(_a0 error) *MockNetworkManager_CheckConnectivity_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockNetworkManager_CheckConnectivity_Call) RunAndReturn(run func() error) *MockNetworkManager_CheckConnectivity_Call { + _c.Call.Return(run) + return _c +} + +// CheckpointAdjustRollbackTimeout provides a mock function with given fields: checkpoint, addTimeout +func (_m *MockNetworkManager) CheckpointAdjustRollbackTimeout(checkpoint gonetworkmanager.Checkpoint, addTimeout uint32) error { + ret := _m.Called(checkpoint, addTimeout) + + if len(ret) == 0 { + panic("no return value specified for CheckpointAdjustRollbackTimeout") + } + + var r0 error + if rf, ok := ret.Get(0).(func(gonetworkmanager.Checkpoint, uint32) error); ok { + r0 = rf(checkpoint, addTimeout) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockNetworkManager_CheckpointAdjustRollbackTimeout_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CheckpointAdjustRollbackTimeout' +type MockNetworkManager_CheckpointAdjustRollbackTimeout_Call struct { + *mock.Call +} + +// CheckpointAdjustRollbackTimeout is a helper method to define mock.On call +// - checkpoint gonetworkmanager.Checkpoint +// - addTimeout uint32 +func (_e *MockNetworkManager_Expecter) CheckpointAdjustRollbackTimeout(checkpoint interface{}, addTimeout interface{}) *MockNetworkManager_CheckpointAdjustRollbackTimeout_Call { + return &MockNetworkManager_CheckpointAdjustRollbackTimeout_Call{Call: _e.mock.On("CheckpointAdjustRollbackTimeout", checkpoint, addTimeout)} +} + +func (_c *MockNetworkManager_CheckpointAdjustRollbackTimeout_Call) Run(run func(checkpoint gonetworkmanager.Checkpoint, addTimeout uint32)) *MockNetworkManager_CheckpointAdjustRollbackTimeout_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(gonetworkmanager.Checkpoint), args[1].(uint32)) + }) + return _c +} + +func (_c *MockNetworkManager_CheckpointAdjustRollbackTimeout_Call) Return(_a0 error) *MockNetworkManager_CheckpointAdjustRollbackTimeout_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockNetworkManager_CheckpointAdjustRollbackTimeout_Call) RunAndReturn(run func(gonetworkmanager.Checkpoint, uint32) error) *MockNetworkManager_CheckpointAdjustRollbackTimeout_Call { + _c.Call.Return(run) + return _c +} + +// CheckpointCreate provides a mock function with given fields: devices, rollbackTimeout, flags +func (_m *MockNetworkManager) CheckpointCreate(devices []gonetworkmanager.Device, rollbackTimeout uint32, flags uint32) (gonetworkmanager.Checkpoint, error) { + ret := _m.Called(devices, rollbackTimeout, flags) + + if len(ret) == 0 { + panic("no return value specified for CheckpointCreate") + } + + var r0 gonetworkmanager.Checkpoint + var r1 error + if rf, ok := ret.Get(0).(func([]gonetworkmanager.Device, uint32, uint32) (gonetworkmanager.Checkpoint, error)); ok { + return rf(devices, rollbackTimeout, flags) + } + if rf, ok := ret.Get(0).(func([]gonetworkmanager.Device, uint32, uint32) gonetworkmanager.Checkpoint); ok { + r0 = rf(devices, rollbackTimeout, flags) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(gonetworkmanager.Checkpoint) + } + } + + if rf, ok := ret.Get(1).(func([]gonetworkmanager.Device, uint32, uint32) error); ok { + r1 = rf(devices, rollbackTimeout, flags) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockNetworkManager_CheckpointCreate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CheckpointCreate' +type MockNetworkManager_CheckpointCreate_Call struct { + *mock.Call +} + +// CheckpointCreate is a helper method to define mock.On call +// - devices []gonetworkmanager.Device +// - rollbackTimeout uint32 +// - flags uint32 +func (_e *MockNetworkManager_Expecter) CheckpointCreate(devices interface{}, rollbackTimeout interface{}, flags interface{}) *MockNetworkManager_CheckpointCreate_Call { + return &MockNetworkManager_CheckpointCreate_Call{Call: _e.mock.On("CheckpointCreate", devices, rollbackTimeout, flags)} +} + +func (_c *MockNetworkManager_CheckpointCreate_Call) Run(run func(devices []gonetworkmanager.Device, rollbackTimeout uint32, flags uint32)) *MockNetworkManager_CheckpointCreate_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].([]gonetworkmanager.Device), args[1].(uint32), args[2].(uint32)) + }) + return _c +} + +func (_c *MockNetworkManager_CheckpointCreate_Call) Return(_a0 gonetworkmanager.Checkpoint, _a1 error) *MockNetworkManager_CheckpointCreate_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockNetworkManager_CheckpointCreate_Call) RunAndReturn(run func([]gonetworkmanager.Device, uint32, uint32) (gonetworkmanager.Checkpoint, error)) *MockNetworkManager_CheckpointCreate_Call { + _c.Call.Return(run) + return _c +} + +// CheckpointDestroy provides a mock function with given fields: checkpoint +func (_m *MockNetworkManager) CheckpointDestroy(checkpoint gonetworkmanager.Checkpoint) error { + ret := _m.Called(checkpoint) + + if len(ret) == 0 { + panic("no return value specified for CheckpointDestroy") + } + + var r0 error + if rf, ok := ret.Get(0).(func(gonetworkmanager.Checkpoint) error); ok { + r0 = rf(checkpoint) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockNetworkManager_CheckpointDestroy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CheckpointDestroy' +type MockNetworkManager_CheckpointDestroy_Call struct { + *mock.Call +} + +// CheckpointDestroy is a helper method to define mock.On call +// - checkpoint gonetworkmanager.Checkpoint +func (_e *MockNetworkManager_Expecter) CheckpointDestroy(checkpoint interface{}) *MockNetworkManager_CheckpointDestroy_Call { + return &MockNetworkManager_CheckpointDestroy_Call{Call: _e.mock.On("CheckpointDestroy", checkpoint)} +} + +func (_c *MockNetworkManager_CheckpointDestroy_Call) Run(run func(checkpoint gonetworkmanager.Checkpoint)) *MockNetworkManager_CheckpointDestroy_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(gonetworkmanager.Checkpoint)) + }) + return _c +} + +func (_c *MockNetworkManager_CheckpointDestroy_Call) Return(_a0 error) *MockNetworkManager_CheckpointDestroy_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockNetworkManager_CheckpointDestroy_Call) RunAndReturn(run func(gonetworkmanager.Checkpoint) error) *MockNetworkManager_CheckpointDestroy_Call { + _c.Call.Return(run) + return _c +} + +// CheckpointRollback provides a mock function with given fields: checkpoint +func (_m *MockNetworkManager) CheckpointRollback(checkpoint gonetworkmanager.Checkpoint) (map[dbus.ObjectPath]gonetworkmanager.NmRollbackResult, error) { + ret := _m.Called(checkpoint) + + if len(ret) == 0 { + panic("no return value specified for CheckpointRollback") + } + + var r0 map[dbus.ObjectPath]gonetworkmanager.NmRollbackResult + var r1 error + if rf, ok := ret.Get(0).(func(gonetworkmanager.Checkpoint) (map[dbus.ObjectPath]gonetworkmanager.NmRollbackResult, error)); ok { + return rf(checkpoint) + } + if rf, ok := ret.Get(0).(func(gonetworkmanager.Checkpoint) map[dbus.ObjectPath]gonetworkmanager.NmRollbackResult); ok { + r0 = rf(checkpoint) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(map[dbus.ObjectPath]gonetworkmanager.NmRollbackResult) + } + } + + if rf, ok := ret.Get(1).(func(gonetworkmanager.Checkpoint) error); ok { + r1 = rf(checkpoint) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockNetworkManager_CheckpointRollback_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CheckpointRollback' +type MockNetworkManager_CheckpointRollback_Call struct { + *mock.Call +} + +// CheckpointRollback is a helper method to define mock.On call +// - checkpoint gonetworkmanager.Checkpoint +func (_e *MockNetworkManager_Expecter) CheckpointRollback(checkpoint interface{}) *MockNetworkManager_CheckpointRollback_Call { + return &MockNetworkManager_CheckpointRollback_Call{Call: _e.mock.On("CheckpointRollback", checkpoint)} +} + +func (_c *MockNetworkManager_CheckpointRollback_Call) Run(run func(checkpoint gonetworkmanager.Checkpoint)) *MockNetworkManager_CheckpointRollback_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(gonetworkmanager.Checkpoint)) + }) + return _c +} + +func (_c *MockNetworkManager_CheckpointRollback_Call) Return(result map[dbus.ObjectPath]gonetworkmanager.NmRollbackResult, err error) *MockNetworkManager_CheckpointRollback_Call { + _c.Call.Return(result, err) + return _c +} + +func (_c *MockNetworkManager_CheckpointRollback_Call) RunAndReturn(run func(gonetworkmanager.Checkpoint) (map[dbus.ObjectPath]gonetworkmanager.NmRollbackResult, error)) *MockNetworkManager_CheckpointRollback_Call { + _c.Call.Return(run) + return _c +} + +// DeactivateConnection provides a mock function with given fields: connection +func (_m *MockNetworkManager) DeactivateConnection(connection gonetworkmanager.ActiveConnection) error { + ret := _m.Called(connection) + + if len(ret) == 0 { + panic("no return value specified for DeactivateConnection") + } + + var r0 error + if rf, ok := ret.Get(0).(func(gonetworkmanager.ActiveConnection) error); ok { + r0 = rf(connection) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockNetworkManager_DeactivateConnection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeactivateConnection' +type MockNetworkManager_DeactivateConnection_Call struct { + *mock.Call +} + +// DeactivateConnection is a helper method to define mock.On call +// - connection gonetworkmanager.ActiveConnection +func (_e *MockNetworkManager_Expecter) DeactivateConnection(connection interface{}) *MockNetworkManager_DeactivateConnection_Call { + return &MockNetworkManager_DeactivateConnection_Call{Call: _e.mock.On("DeactivateConnection", connection)} +} + +func (_c *MockNetworkManager_DeactivateConnection_Call) Run(run func(connection gonetworkmanager.ActiveConnection)) *MockNetworkManager_DeactivateConnection_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(gonetworkmanager.ActiveConnection)) + }) + return _c +} + +func (_c *MockNetworkManager_DeactivateConnection_Call) Return(_a0 error) *MockNetworkManager_DeactivateConnection_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockNetworkManager_DeactivateConnection_Call) RunAndReturn(run func(gonetworkmanager.ActiveConnection) error) *MockNetworkManager_DeactivateConnection_Call { + _c.Call.Return(run) + return _c +} + +// Enable provides a mock function with given fields: enableNDisable +func (_m *MockNetworkManager) Enable(enableNDisable bool) error { + ret := _m.Called(enableNDisable) + + if len(ret) == 0 { + panic("no return value specified for Enable") + } + + var r0 error + if rf, ok := ret.Get(0).(func(bool) error); ok { + r0 = rf(enableNDisable) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockNetworkManager_Enable_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Enable' +type MockNetworkManager_Enable_Call struct { + *mock.Call +} + +// Enable is a helper method to define mock.On call +// - enableNDisable bool +func (_e *MockNetworkManager_Expecter) Enable(enableNDisable interface{}) *MockNetworkManager_Enable_Call { + return &MockNetworkManager_Enable_Call{Call: _e.mock.On("Enable", enableNDisable)} +} + +func (_c *MockNetworkManager_Enable_Call) Run(run func(enableNDisable bool)) *MockNetworkManager_Enable_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(bool)) + }) + return _c +} + +func (_c *MockNetworkManager_Enable_Call) Return(_a0 error) *MockNetworkManager_Enable_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockNetworkManager_Enable_Call) RunAndReturn(run func(bool) error) *MockNetworkManager_Enable_Call { + _c.Call.Return(run) + return _c +} + +// GetAllDevices provides a mock function with no fields +func (_m *MockNetworkManager) GetAllDevices() ([]gonetworkmanager.Device, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetAllDevices") + } + + var r0 []gonetworkmanager.Device + var r1 error + if rf, ok := ret.Get(0).(func() ([]gonetworkmanager.Device, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() []gonetworkmanager.Device); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]gonetworkmanager.Device) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockNetworkManager_GetAllDevices_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllDevices' +type MockNetworkManager_GetAllDevices_Call struct { + *mock.Call +} + +// GetAllDevices is a helper method to define mock.On call +func (_e *MockNetworkManager_Expecter) GetAllDevices() *MockNetworkManager_GetAllDevices_Call { + return &MockNetworkManager_GetAllDevices_Call{Call: _e.mock.On("GetAllDevices")} +} + +func (_c *MockNetworkManager_GetAllDevices_Call) Run(run func()) *MockNetworkManager_GetAllDevices_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockNetworkManager_GetAllDevices_Call) Return(_a0 []gonetworkmanager.Device, _a1 error) *MockNetworkManager_GetAllDevices_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockNetworkManager_GetAllDevices_Call) RunAndReturn(run func() ([]gonetworkmanager.Device, error)) *MockNetworkManager_GetAllDevices_Call { + _c.Call.Return(run) + return _c +} + +// GetDeviceByIpIface provides a mock function with given fields: interfaceId +func (_m *MockNetworkManager) GetDeviceByIpIface(interfaceId string) (gonetworkmanager.Device, error) { + ret := _m.Called(interfaceId) + + if len(ret) == 0 { + panic("no return value specified for GetDeviceByIpIface") + } + + var r0 gonetworkmanager.Device + var r1 error + if rf, ok := ret.Get(0).(func(string) (gonetworkmanager.Device, error)); ok { + return rf(interfaceId) + } + if rf, ok := ret.Get(0).(func(string) gonetworkmanager.Device); ok { + r0 = rf(interfaceId) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(gonetworkmanager.Device) + } + } + + if rf, ok := ret.Get(1).(func(string) error); ok { + r1 = rf(interfaceId) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockNetworkManager_GetDeviceByIpIface_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDeviceByIpIface' +type MockNetworkManager_GetDeviceByIpIface_Call struct { + *mock.Call +} + +// GetDeviceByIpIface is a helper method to define mock.On call +// - interfaceId string +func (_e *MockNetworkManager_Expecter) GetDeviceByIpIface(interfaceId interface{}) *MockNetworkManager_GetDeviceByIpIface_Call { + return &MockNetworkManager_GetDeviceByIpIface_Call{Call: _e.mock.On("GetDeviceByIpIface", interfaceId)} +} + +func (_c *MockNetworkManager_GetDeviceByIpIface_Call) Run(run func(interfaceId string)) *MockNetworkManager_GetDeviceByIpIface_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *MockNetworkManager_GetDeviceByIpIface_Call) Return(_a0 gonetworkmanager.Device, _a1 error) *MockNetworkManager_GetDeviceByIpIface_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockNetworkManager_GetDeviceByIpIface_Call) RunAndReturn(run func(string) (gonetworkmanager.Device, error)) *MockNetworkManager_GetDeviceByIpIface_Call { + _c.Call.Return(run) + return _c +} + +// GetDevices provides a mock function with no fields +func (_m *MockNetworkManager) GetDevices() ([]gonetworkmanager.Device, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetDevices") + } + + var r0 []gonetworkmanager.Device + var r1 error + if rf, ok := ret.Get(0).(func() ([]gonetworkmanager.Device, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() []gonetworkmanager.Device); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]gonetworkmanager.Device) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockNetworkManager_GetDevices_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDevices' +type MockNetworkManager_GetDevices_Call struct { + *mock.Call +} + +// GetDevices is a helper method to define mock.On call +func (_e *MockNetworkManager_Expecter) GetDevices() *MockNetworkManager_GetDevices_Call { + return &MockNetworkManager_GetDevices_Call{Call: _e.mock.On("GetDevices")} +} + +func (_c *MockNetworkManager_GetDevices_Call) Run(run func()) *MockNetworkManager_GetDevices_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockNetworkManager_GetDevices_Call) Return(_a0 []gonetworkmanager.Device, _a1 error) *MockNetworkManager_GetDevices_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockNetworkManager_GetDevices_Call) RunAndReturn(run func() ([]gonetworkmanager.Device, error)) *MockNetworkManager_GetDevices_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyActivatingConnection provides a mock function with no fields +func (_m *MockNetworkManager) GetPropertyActivatingConnection() (gonetworkmanager.ActiveConnection, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyActivatingConnection") + } + + var r0 gonetworkmanager.ActiveConnection + var r1 error + if rf, ok := ret.Get(0).(func() (gonetworkmanager.ActiveConnection, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() gonetworkmanager.ActiveConnection); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(gonetworkmanager.ActiveConnection) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockNetworkManager_GetPropertyActivatingConnection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyActivatingConnection' +type MockNetworkManager_GetPropertyActivatingConnection_Call struct { + *mock.Call +} + +// GetPropertyActivatingConnection is a helper method to define mock.On call +func (_e *MockNetworkManager_Expecter) GetPropertyActivatingConnection() *MockNetworkManager_GetPropertyActivatingConnection_Call { + return &MockNetworkManager_GetPropertyActivatingConnection_Call{Call: _e.mock.On("GetPropertyActivatingConnection")} +} + +func (_c *MockNetworkManager_GetPropertyActivatingConnection_Call) Run(run func()) *MockNetworkManager_GetPropertyActivatingConnection_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockNetworkManager_GetPropertyActivatingConnection_Call) Return(_a0 gonetworkmanager.ActiveConnection, _a1 error) *MockNetworkManager_GetPropertyActivatingConnection_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockNetworkManager_GetPropertyActivatingConnection_Call) RunAndReturn(run func() (gonetworkmanager.ActiveConnection, error)) *MockNetworkManager_GetPropertyActivatingConnection_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyActiveConnections provides a mock function with no fields +func (_m *MockNetworkManager) GetPropertyActiveConnections() ([]gonetworkmanager.ActiveConnection, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyActiveConnections") + } + + var r0 []gonetworkmanager.ActiveConnection + var r1 error + if rf, ok := ret.Get(0).(func() ([]gonetworkmanager.ActiveConnection, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() []gonetworkmanager.ActiveConnection); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]gonetworkmanager.ActiveConnection) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockNetworkManager_GetPropertyActiveConnections_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyActiveConnections' +type MockNetworkManager_GetPropertyActiveConnections_Call struct { + *mock.Call +} + +// GetPropertyActiveConnections is a helper method to define mock.On call +func (_e *MockNetworkManager_Expecter) GetPropertyActiveConnections() *MockNetworkManager_GetPropertyActiveConnections_Call { + return &MockNetworkManager_GetPropertyActiveConnections_Call{Call: _e.mock.On("GetPropertyActiveConnections")} +} + +func (_c *MockNetworkManager_GetPropertyActiveConnections_Call) Run(run func()) *MockNetworkManager_GetPropertyActiveConnections_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockNetworkManager_GetPropertyActiveConnections_Call) Return(_a0 []gonetworkmanager.ActiveConnection, _a1 error) *MockNetworkManager_GetPropertyActiveConnections_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockNetworkManager_GetPropertyActiveConnections_Call) RunAndReturn(run func() ([]gonetworkmanager.ActiveConnection, error)) *MockNetworkManager_GetPropertyActiveConnections_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyAllDevices provides a mock function with no fields +func (_m *MockNetworkManager) GetPropertyAllDevices() ([]gonetworkmanager.Device, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyAllDevices") + } + + var r0 []gonetworkmanager.Device + var r1 error + if rf, ok := ret.Get(0).(func() ([]gonetworkmanager.Device, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() []gonetworkmanager.Device); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]gonetworkmanager.Device) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockNetworkManager_GetPropertyAllDevices_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyAllDevices' +type MockNetworkManager_GetPropertyAllDevices_Call struct { + *mock.Call +} + +// GetPropertyAllDevices is a helper method to define mock.On call +func (_e *MockNetworkManager_Expecter) GetPropertyAllDevices() *MockNetworkManager_GetPropertyAllDevices_Call { + return &MockNetworkManager_GetPropertyAllDevices_Call{Call: _e.mock.On("GetPropertyAllDevices")} +} + +func (_c *MockNetworkManager_GetPropertyAllDevices_Call) Run(run func()) *MockNetworkManager_GetPropertyAllDevices_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockNetworkManager_GetPropertyAllDevices_Call) Return(_a0 []gonetworkmanager.Device, _a1 error) *MockNetworkManager_GetPropertyAllDevices_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockNetworkManager_GetPropertyAllDevices_Call) RunAndReturn(run func() ([]gonetworkmanager.Device, error)) *MockNetworkManager_GetPropertyAllDevices_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyCapabilities provides a mock function with no fields +func (_m *MockNetworkManager) GetPropertyCapabilities() ([]gonetworkmanager.NmCapability, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyCapabilities") + } + + var r0 []gonetworkmanager.NmCapability + var r1 error + if rf, ok := ret.Get(0).(func() ([]gonetworkmanager.NmCapability, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() []gonetworkmanager.NmCapability); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]gonetworkmanager.NmCapability) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockNetworkManager_GetPropertyCapabilities_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyCapabilities' +type MockNetworkManager_GetPropertyCapabilities_Call struct { + *mock.Call +} + +// GetPropertyCapabilities is a helper method to define mock.On call +func (_e *MockNetworkManager_Expecter) GetPropertyCapabilities() *MockNetworkManager_GetPropertyCapabilities_Call { + return &MockNetworkManager_GetPropertyCapabilities_Call{Call: _e.mock.On("GetPropertyCapabilities")} +} + +func (_c *MockNetworkManager_GetPropertyCapabilities_Call) Run(run func()) *MockNetworkManager_GetPropertyCapabilities_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockNetworkManager_GetPropertyCapabilities_Call) Return(_a0 []gonetworkmanager.NmCapability, _a1 error) *MockNetworkManager_GetPropertyCapabilities_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockNetworkManager_GetPropertyCapabilities_Call) RunAndReturn(run func() ([]gonetworkmanager.NmCapability, error)) *MockNetworkManager_GetPropertyCapabilities_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyCheckpoints provides a mock function with no fields +func (_m *MockNetworkManager) GetPropertyCheckpoints() ([]gonetworkmanager.Checkpoint, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyCheckpoints") + } + + var r0 []gonetworkmanager.Checkpoint + var r1 error + if rf, ok := ret.Get(0).(func() ([]gonetworkmanager.Checkpoint, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() []gonetworkmanager.Checkpoint); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]gonetworkmanager.Checkpoint) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockNetworkManager_GetPropertyCheckpoints_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyCheckpoints' +type MockNetworkManager_GetPropertyCheckpoints_Call struct { + *mock.Call +} + +// GetPropertyCheckpoints is a helper method to define mock.On call +func (_e *MockNetworkManager_Expecter) GetPropertyCheckpoints() *MockNetworkManager_GetPropertyCheckpoints_Call { + return &MockNetworkManager_GetPropertyCheckpoints_Call{Call: _e.mock.On("GetPropertyCheckpoints")} +} + +func (_c *MockNetworkManager_GetPropertyCheckpoints_Call) Run(run func()) *MockNetworkManager_GetPropertyCheckpoints_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockNetworkManager_GetPropertyCheckpoints_Call) Return(_a0 []gonetworkmanager.Checkpoint, _a1 error) *MockNetworkManager_GetPropertyCheckpoints_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockNetworkManager_GetPropertyCheckpoints_Call) RunAndReturn(run func() ([]gonetworkmanager.Checkpoint, error)) *MockNetworkManager_GetPropertyCheckpoints_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyConnectivity provides a mock function with no fields +func (_m *MockNetworkManager) GetPropertyConnectivity() (gonetworkmanager.NmConnectivity, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyConnectivity") + } + + var r0 gonetworkmanager.NmConnectivity + var r1 error + if rf, ok := ret.Get(0).(func() (gonetworkmanager.NmConnectivity, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() gonetworkmanager.NmConnectivity); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(gonetworkmanager.NmConnectivity) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockNetworkManager_GetPropertyConnectivity_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyConnectivity' +type MockNetworkManager_GetPropertyConnectivity_Call struct { + *mock.Call +} + +// GetPropertyConnectivity is a helper method to define mock.On call +func (_e *MockNetworkManager_Expecter) GetPropertyConnectivity() *MockNetworkManager_GetPropertyConnectivity_Call { + return &MockNetworkManager_GetPropertyConnectivity_Call{Call: _e.mock.On("GetPropertyConnectivity")} +} + +func (_c *MockNetworkManager_GetPropertyConnectivity_Call) Run(run func()) *MockNetworkManager_GetPropertyConnectivity_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockNetworkManager_GetPropertyConnectivity_Call) Return(_a0 gonetworkmanager.NmConnectivity, _a1 error) *MockNetworkManager_GetPropertyConnectivity_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockNetworkManager_GetPropertyConnectivity_Call) RunAndReturn(run func() (gonetworkmanager.NmConnectivity, error)) *MockNetworkManager_GetPropertyConnectivity_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyConnectivityCheckAvailable provides a mock function with no fields +func (_m *MockNetworkManager) GetPropertyConnectivityCheckAvailable() (bool, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyConnectivityCheckAvailable") + } + + var r0 bool + var r1 error + if rf, ok := ret.Get(0).(func() (bool, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() bool); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(bool) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockNetworkManager_GetPropertyConnectivityCheckAvailable_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyConnectivityCheckAvailable' +type MockNetworkManager_GetPropertyConnectivityCheckAvailable_Call struct { + *mock.Call +} + +// GetPropertyConnectivityCheckAvailable is a helper method to define mock.On call +func (_e *MockNetworkManager_Expecter) GetPropertyConnectivityCheckAvailable() *MockNetworkManager_GetPropertyConnectivityCheckAvailable_Call { + return &MockNetworkManager_GetPropertyConnectivityCheckAvailable_Call{Call: _e.mock.On("GetPropertyConnectivityCheckAvailable")} +} + +func (_c *MockNetworkManager_GetPropertyConnectivityCheckAvailable_Call) Run(run func()) *MockNetworkManager_GetPropertyConnectivityCheckAvailable_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockNetworkManager_GetPropertyConnectivityCheckAvailable_Call) Return(_a0 bool, _a1 error) *MockNetworkManager_GetPropertyConnectivityCheckAvailable_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockNetworkManager_GetPropertyConnectivityCheckAvailable_Call) RunAndReturn(run func() (bool, error)) *MockNetworkManager_GetPropertyConnectivityCheckAvailable_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyConnectivityCheckEnabled provides a mock function with no fields +func (_m *MockNetworkManager) GetPropertyConnectivityCheckEnabled() (bool, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyConnectivityCheckEnabled") + } + + var r0 bool + var r1 error + if rf, ok := ret.Get(0).(func() (bool, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() bool); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(bool) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockNetworkManager_GetPropertyConnectivityCheckEnabled_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyConnectivityCheckEnabled' +type MockNetworkManager_GetPropertyConnectivityCheckEnabled_Call struct { + *mock.Call +} + +// GetPropertyConnectivityCheckEnabled is a helper method to define mock.On call +func (_e *MockNetworkManager_Expecter) GetPropertyConnectivityCheckEnabled() *MockNetworkManager_GetPropertyConnectivityCheckEnabled_Call { + return &MockNetworkManager_GetPropertyConnectivityCheckEnabled_Call{Call: _e.mock.On("GetPropertyConnectivityCheckEnabled")} +} + +func (_c *MockNetworkManager_GetPropertyConnectivityCheckEnabled_Call) Run(run func()) *MockNetworkManager_GetPropertyConnectivityCheckEnabled_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockNetworkManager_GetPropertyConnectivityCheckEnabled_Call) Return(_a0 bool, _a1 error) *MockNetworkManager_GetPropertyConnectivityCheckEnabled_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockNetworkManager_GetPropertyConnectivityCheckEnabled_Call) RunAndReturn(run func() (bool, error)) *MockNetworkManager_GetPropertyConnectivityCheckEnabled_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyDevices provides a mock function with no fields +func (_m *MockNetworkManager) GetPropertyDevices() ([]gonetworkmanager.Device, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyDevices") + } + + var r0 []gonetworkmanager.Device + var r1 error + if rf, ok := ret.Get(0).(func() ([]gonetworkmanager.Device, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() []gonetworkmanager.Device); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]gonetworkmanager.Device) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockNetworkManager_GetPropertyDevices_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyDevices' +type MockNetworkManager_GetPropertyDevices_Call struct { + *mock.Call +} + +// GetPropertyDevices is a helper method to define mock.On call +func (_e *MockNetworkManager_Expecter) GetPropertyDevices() *MockNetworkManager_GetPropertyDevices_Call { + return &MockNetworkManager_GetPropertyDevices_Call{Call: _e.mock.On("GetPropertyDevices")} +} + +func (_c *MockNetworkManager_GetPropertyDevices_Call) Run(run func()) *MockNetworkManager_GetPropertyDevices_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockNetworkManager_GetPropertyDevices_Call) Return(_a0 []gonetworkmanager.Device, _a1 error) *MockNetworkManager_GetPropertyDevices_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockNetworkManager_GetPropertyDevices_Call) RunAndReturn(run func() ([]gonetworkmanager.Device, error)) *MockNetworkManager_GetPropertyDevices_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyMetered provides a mock function with no fields +func (_m *MockNetworkManager) GetPropertyMetered() (gonetworkmanager.NmMetered, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyMetered") + } + + var r0 gonetworkmanager.NmMetered + var r1 error + if rf, ok := ret.Get(0).(func() (gonetworkmanager.NmMetered, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() gonetworkmanager.NmMetered); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(gonetworkmanager.NmMetered) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockNetworkManager_GetPropertyMetered_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyMetered' +type MockNetworkManager_GetPropertyMetered_Call struct { + *mock.Call +} + +// GetPropertyMetered is a helper method to define mock.On call +func (_e *MockNetworkManager_Expecter) GetPropertyMetered() *MockNetworkManager_GetPropertyMetered_Call { + return &MockNetworkManager_GetPropertyMetered_Call{Call: _e.mock.On("GetPropertyMetered")} +} + +func (_c *MockNetworkManager_GetPropertyMetered_Call) Run(run func()) *MockNetworkManager_GetPropertyMetered_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockNetworkManager_GetPropertyMetered_Call) Return(_a0 gonetworkmanager.NmMetered, _a1 error) *MockNetworkManager_GetPropertyMetered_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockNetworkManager_GetPropertyMetered_Call) RunAndReturn(run func() (gonetworkmanager.NmMetered, error)) *MockNetworkManager_GetPropertyMetered_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyNetworkingEnabled provides a mock function with no fields +func (_m *MockNetworkManager) GetPropertyNetworkingEnabled() (bool, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyNetworkingEnabled") + } + + var r0 bool + var r1 error + if rf, ok := ret.Get(0).(func() (bool, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() bool); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(bool) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockNetworkManager_GetPropertyNetworkingEnabled_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyNetworkingEnabled' +type MockNetworkManager_GetPropertyNetworkingEnabled_Call struct { + *mock.Call +} + +// GetPropertyNetworkingEnabled is a helper method to define mock.On call +func (_e *MockNetworkManager_Expecter) GetPropertyNetworkingEnabled() *MockNetworkManager_GetPropertyNetworkingEnabled_Call { + return &MockNetworkManager_GetPropertyNetworkingEnabled_Call{Call: _e.mock.On("GetPropertyNetworkingEnabled")} +} + +func (_c *MockNetworkManager_GetPropertyNetworkingEnabled_Call) Run(run func()) *MockNetworkManager_GetPropertyNetworkingEnabled_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockNetworkManager_GetPropertyNetworkingEnabled_Call) Return(_a0 bool, _a1 error) *MockNetworkManager_GetPropertyNetworkingEnabled_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockNetworkManager_GetPropertyNetworkingEnabled_Call) RunAndReturn(run func() (bool, error)) *MockNetworkManager_GetPropertyNetworkingEnabled_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyPrimaryConnection provides a mock function with no fields +func (_m *MockNetworkManager) GetPropertyPrimaryConnection() (gonetworkmanager.ActiveConnection, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyPrimaryConnection") + } + + var r0 gonetworkmanager.ActiveConnection + var r1 error + if rf, ok := ret.Get(0).(func() (gonetworkmanager.ActiveConnection, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() gonetworkmanager.ActiveConnection); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(gonetworkmanager.ActiveConnection) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockNetworkManager_GetPropertyPrimaryConnection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyPrimaryConnection' +type MockNetworkManager_GetPropertyPrimaryConnection_Call struct { + *mock.Call +} + +// GetPropertyPrimaryConnection is a helper method to define mock.On call +func (_e *MockNetworkManager_Expecter) GetPropertyPrimaryConnection() *MockNetworkManager_GetPropertyPrimaryConnection_Call { + return &MockNetworkManager_GetPropertyPrimaryConnection_Call{Call: _e.mock.On("GetPropertyPrimaryConnection")} +} + +func (_c *MockNetworkManager_GetPropertyPrimaryConnection_Call) Run(run func()) *MockNetworkManager_GetPropertyPrimaryConnection_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockNetworkManager_GetPropertyPrimaryConnection_Call) Return(_a0 gonetworkmanager.ActiveConnection, _a1 error) *MockNetworkManager_GetPropertyPrimaryConnection_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockNetworkManager_GetPropertyPrimaryConnection_Call) RunAndReturn(run func() (gonetworkmanager.ActiveConnection, error)) *MockNetworkManager_GetPropertyPrimaryConnection_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyPrimaryConnectionType provides a mock function with no fields +func (_m *MockNetworkManager) GetPropertyPrimaryConnectionType() (string, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyPrimaryConnectionType") + } + + var r0 string + var r1 error + if rf, ok := ret.Get(0).(func() (string, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockNetworkManager_GetPropertyPrimaryConnectionType_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyPrimaryConnectionType' +type MockNetworkManager_GetPropertyPrimaryConnectionType_Call struct { + *mock.Call +} + +// GetPropertyPrimaryConnectionType is a helper method to define mock.On call +func (_e *MockNetworkManager_Expecter) GetPropertyPrimaryConnectionType() *MockNetworkManager_GetPropertyPrimaryConnectionType_Call { + return &MockNetworkManager_GetPropertyPrimaryConnectionType_Call{Call: _e.mock.On("GetPropertyPrimaryConnectionType")} +} + +func (_c *MockNetworkManager_GetPropertyPrimaryConnectionType_Call) Run(run func()) *MockNetworkManager_GetPropertyPrimaryConnectionType_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockNetworkManager_GetPropertyPrimaryConnectionType_Call) Return(_a0 string, _a1 error) *MockNetworkManager_GetPropertyPrimaryConnectionType_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockNetworkManager_GetPropertyPrimaryConnectionType_Call) RunAndReturn(run func() (string, error)) *MockNetworkManager_GetPropertyPrimaryConnectionType_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyStartup provides a mock function with no fields +func (_m *MockNetworkManager) GetPropertyStartup() (bool, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyStartup") + } + + var r0 bool + var r1 error + if rf, ok := ret.Get(0).(func() (bool, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() bool); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(bool) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockNetworkManager_GetPropertyStartup_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyStartup' +type MockNetworkManager_GetPropertyStartup_Call struct { + *mock.Call +} + +// GetPropertyStartup is a helper method to define mock.On call +func (_e *MockNetworkManager_Expecter) GetPropertyStartup() *MockNetworkManager_GetPropertyStartup_Call { + return &MockNetworkManager_GetPropertyStartup_Call{Call: _e.mock.On("GetPropertyStartup")} +} + +func (_c *MockNetworkManager_GetPropertyStartup_Call) Run(run func()) *MockNetworkManager_GetPropertyStartup_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockNetworkManager_GetPropertyStartup_Call) Return(_a0 bool, _a1 error) *MockNetworkManager_GetPropertyStartup_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockNetworkManager_GetPropertyStartup_Call) RunAndReturn(run func() (bool, error)) *MockNetworkManager_GetPropertyStartup_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyState provides a mock function with no fields +func (_m *MockNetworkManager) GetPropertyState() (gonetworkmanager.NmState, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyState") + } + + var r0 gonetworkmanager.NmState + var r1 error + if rf, ok := ret.Get(0).(func() (gonetworkmanager.NmState, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() gonetworkmanager.NmState); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(gonetworkmanager.NmState) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockNetworkManager_GetPropertyState_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyState' +type MockNetworkManager_GetPropertyState_Call struct { + *mock.Call +} + +// GetPropertyState is a helper method to define mock.On call +func (_e *MockNetworkManager_Expecter) GetPropertyState() *MockNetworkManager_GetPropertyState_Call { + return &MockNetworkManager_GetPropertyState_Call{Call: _e.mock.On("GetPropertyState")} +} + +func (_c *MockNetworkManager_GetPropertyState_Call) Run(run func()) *MockNetworkManager_GetPropertyState_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockNetworkManager_GetPropertyState_Call) Return(_a0 gonetworkmanager.NmState, _a1 error) *MockNetworkManager_GetPropertyState_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockNetworkManager_GetPropertyState_Call) RunAndReturn(run func() (gonetworkmanager.NmState, error)) *MockNetworkManager_GetPropertyState_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyVersion provides a mock function with no fields +func (_m *MockNetworkManager) GetPropertyVersion() (string, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyVersion") + } + + var r0 string + var r1 error + if rf, ok := ret.Get(0).(func() (string, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockNetworkManager_GetPropertyVersion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyVersion' +type MockNetworkManager_GetPropertyVersion_Call struct { + *mock.Call +} + +// GetPropertyVersion is a helper method to define mock.On call +func (_e *MockNetworkManager_Expecter) GetPropertyVersion() *MockNetworkManager_GetPropertyVersion_Call { + return &MockNetworkManager_GetPropertyVersion_Call{Call: _e.mock.On("GetPropertyVersion")} +} + +func (_c *MockNetworkManager_GetPropertyVersion_Call) Run(run func()) *MockNetworkManager_GetPropertyVersion_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockNetworkManager_GetPropertyVersion_Call) Return(_a0 string, _a1 error) *MockNetworkManager_GetPropertyVersion_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockNetworkManager_GetPropertyVersion_Call) RunAndReturn(run func() (string, error)) *MockNetworkManager_GetPropertyVersion_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyWimaxEnabled provides a mock function with no fields +func (_m *MockNetworkManager) GetPropertyWimaxEnabled() (bool, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyWimaxEnabled") + } + + var r0 bool + var r1 error + if rf, ok := ret.Get(0).(func() (bool, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() bool); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(bool) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockNetworkManager_GetPropertyWimaxEnabled_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyWimaxEnabled' +type MockNetworkManager_GetPropertyWimaxEnabled_Call struct { + *mock.Call +} + +// GetPropertyWimaxEnabled is a helper method to define mock.On call +func (_e *MockNetworkManager_Expecter) GetPropertyWimaxEnabled() *MockNetworkManager_GetPropertyWimaxEnabled_Call { + return &MockNetworkManager_GetPropertyWimaxEnabled_Call{Call: _e.mock.On("GetPropertyWimaxEnabled")} +} + +func (_c *MockNetworkManager_GetPropertyWimaxEnabled_Call) Run(run func()) *MockNetworkManager_GetPropertyWimaxEnabled_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockNetworkManager_GetPropertyWimaxEnabled_Call) Return(_a0 bool, _a1 error) *MockNetworkManager_GetPropertyWimaxEnabled_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockNetworkManager_GetPropertyWimaxEnabled_Call) RunAndReturn(run func() (bool, error)) *MockNetworkManager_GetPropertyWimaxEnabled_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyWimaxHardwareEnabled provides a mock function with no fields +func (_m *MockNetworkManager) GetPropertyWimaxHardwareEnabled() (bool, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyWimaxHardwareEnabled") + } + + var r0 bool + var r1 error + if rf, ok := ret.Get(0).(func() (bool, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() bool); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(bool) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockNetworkManager_GetPropertyWimaxHardwareEnabled_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyWimaxHardwareEnabled' +type MockNetworkManager_GetPropertyWimaxHardwareEnabled_Call struct { + *mock.Call +} + +// GetPropertyWimaxHardwareEnabled is a helper method to define mock.On call +func (_e *MockNetworkManager_Expecter) GetPropertyWimaxHardwareEnabled() *MockNetworkManager_GetPropertyWimaxHardwareEnabled_Call { + return &MockNetworkManager_GetPropertyWimaxHardwareEnabled_Call{Call: _e.mock.On("GetPropertyWimaxHardwareEnabled")} +} + +func (_c *MockNetworkManager_GetPropertyWimaxHardwareEnabled_Call) Run(run func()) *MockNetworkManager_GetPropertyWimaxHardwareEnabled_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockNetworkManager_GetPropertyWimaxHardwareEnabled_Call) Return(_a0 bool, _a1 error) *MockNetworkManager_GetPropertyWimaxHardwareEnabled_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockNetworkManager_GetPropertyWimaxHardwareEnabled_Call) RunAndReturn(run func() (bool, error)) *MockNetworkManager_GetPropertyWimaxHardwareEnabled_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyWirelessEnabled provides a mock function with no fields +func (_m *MockNetworkManager) GetPropertyWirelessEnabled() (bool, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyWirelessEnabled") + } + + var r0 bool + var r1 error + if rf, ok := ret.Get(0).(func() (bool, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() bool); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(bool) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockNetworkManager_GetPropertyWirelessEnabled_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyWirelessEnabled' +type MockNetworkManager_GetPropertyWirelessEnabled_Call struct { + *mock.Call +} + +// GetPropertyWirelessEnabled is a helper method to define mock.On call +func (_e *MockNetworkManager_Expecter) GetPropertyWirelessEnabled() *MockNetworkManager_GetPropertyWirelessEnabled_Call { + return &MockNetworkManager_GetPropertyWirelessEnabled_Call{Call: _e.mock.On("GetPropertyWirelessEnabled")} +} + +func (_c *MockNetworkManager_GetPropertyWirelessEnabled_Call) Run(run func()) *MockNetworkManager_GetPropertyWirelessEnabled_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockNetworkManager_GetPropertyWirelessEnabled_Call) Return(_a0 bool, _a1 error) *MockNetworkManager_GetPropertyWirelessEnabled_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockNetworkManager_GetPropertyWirelessEnabled_Call) RunAndReturn(run func() (bool, error)) *MockNetworkManager_GetPropertyWirelessEnabled_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyWirelessHardwareEnabled provides a mock function with no fields +func (_m *MockNetworkManager) GetPropertyWirelessHardwareEnabled() (bool, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyWirelessHardwareEnabled") + } + + var r0 bool + var r1 error + if rf, ok := ret.Get(0).(func() (bool, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() bool); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(bool) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockNetworkManager_GetPropertyWirelessHardwareEnabled_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyWirelessHardwareEnabled' +type MockNetworkManager_GetPropertyWirelessHardwareEnabled_Call struct { + *mock.Call +} + +// GetPropertyWirelessHardwareEnabled is a helper method to define mock.On call +func (_e *MockNetworkManager_Expecter) GetPropertyWirelessHardwareEnabled() *MockNetworkManager_GetPropertyWirelessHardwareEnabled_Call { + return &MockNetworkManager_GetPropertyWirelessHardwareEnabled_Call{Call: _e.mock.On("GetPropertyWirelessHardwareEnabled")} +} + +func (_c *MockNetworkManager_GetPropertyWirelessHardwareEnabled_Call) Run(run func()) *MockNetworkManager_GetPropertyWirelessHardwareEnabled_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockNetworkManager_GetPropertyWirelessHardwareEnabled_Call) Return(_a0 bool, _a1 error) *MockNetworkManager_GetPropertyWirelessHardwareEnabled_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockNetworkManager_GetPropertyWirelessHardwareEnabled_Call) RunAndReturn(run func() (bool, error)) *MockNetworkManager_GetPropertyWirelessHardwareEnabled_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyWwanEnabled provides a mock function with no fields +func (_m *MockNetworkManager) GetPropertyWwanEnabled() (bool, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyWwanEnabled") + } + + var r0 bool + var r1 error + if rf, ok := ret.Get(0).(func() (bool, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() bool); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(bool) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockNetworkManager_GetPropertyWwanEnabled_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyWwanEnabled' +type MockNetworkManager_GetPropertyWwanEnabled_Call struct { + *mock.Call +} + +// GetPropertyWwanEnabled is a helper method to define mock.On call +func (_e *MockNetworkManager_Expecter) GetPropertyWwanEnabled() *MockNetworkManager_GetPropertyWwanEnabled_Call { + return &MockNetworkManager_GetPropertyWwanEnabled_Call{Call: _e.mock.On("GetPropertyWwanEnabled")} +} + +func (_c *MockNetworkManager_GetPropertyWwanEnabled_Call) Run(run func()) *MockNetworkManager_GetPropertyWwanEnabled_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockNetworkManager_GetPropertyWwanEnabled_Call) Return(_a0 bool, _a1 error) *MockNetworkManager_GetPropertyWwanEnabled_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockNetworkManager_GetPropertyWwanEnabled_Call) RunAndReturn(run func() (bool, error)) *MockNetworkManager_GetPropertyWwanEnabled_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyWwanHardwareEnabled provides a mock function with no fields +func (_m *MockNetworkManager) GetPropertyWwanHardwareEnabled() (bool, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyWwanHardwareEnabled") + } + + var r0 bool + var r1 error + if rf, ok := ret.Get(0).(func() (bool, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() bool); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(bool) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockNetworkManager_GetPropertyWwanHardwareEnabled_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyWwanHardwareEnabled' +type MockNetworkManager_GetPropertyWwanHardwareEnabled_Call struct { + *mock.Call +} + +// GetPropertyWwanHardwareEnabled is a helper method to define mock.On call +func (_e *MockNetworkManager_Expecter) GetPropertyWwanHardwareEnabled() *MockNetworkManager_GetPropertyWwanHardwareEnabled_Call { + return &MockNetworkManager_GetPropertyWwanHardwareEnabled_Call{Call: _e.mock.On("GetPropertyWwanHardwareEnabled")} +} + +func (_c *MockNetworkManager_GetPropertyWwanHardwareEnabled_Call) Run(run func()) *MockNetworkManager_GetPropertyWwanHardwareEnabled_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockNetworkManager_GetPropertyWwanHardwareEnabled_Call) Return(_a0 bool, _a1 error) *MockNetworkManager_GetPropertyWwanHardwareEnabled_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockNetworkManager_GetPropertyWwanHardwareEnabled_Call) RunAndReturn(run func() (bool, error)) *MockNetworkManager_GetPropertyWwanHardwareEnabled_Call { + _c.Call.Return(run) + return _c +} + +// MarshalJSON provides a mock function with no fields +func (_m *MockNetworkManager) MarshalJSON() ([]byte, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for MarshalJSON") + } + + var r0 []byte + var r1 error + if rf, ok := ret.Get(0).(func() ([]byte, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() []byte); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]byte) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockNetworkManager_MarshalJSON_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MarshalJSON' +type MockNetworkManager_MarshalJSON_Call struct { + *mock.Call +} + +// MarshalJSON is a helper method to define mock.On call +func (_e *MockNetworkManager_Expecter) MarshalJSON() *MockNetworkManager_MarshalJSON_Call { + return &MockNetworkManager_MarshalJSON_Call{Call: _e.mock.On("MarshalJSON")} +} + +func (_c *MockNetworkManager_MarshalJSON_Call) Run(run func()) *MockNetworkManager_MarshalJSON_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockNetworkManager_MarshalJSON_Call) Return(_a0 []byte, _a1 error) *MockNetworkManager_MarshalJSON_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockNetworkManager_MarshalJSON_Call) RunAndReturn(run func() ([]byte, error)) *MockNetworkManager_MarshalJSON_Call { + _c.Call.Return(run) + return _c +} + +// Reload provides a mock function with given fields: flags +func (_m *MockNetworkManager) Reload(flags uint32) error { + ret := _m.Called(flags) + + if len(ret) == 0 { + panic("no return value specified for Reload") + } + + var r0 error + if rf, ok := ret.Get(0).(func(uint32) error); ok { + r0 = rf(flags) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockNetworkManager_Reload_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Reload' +type MockNetworkManager_Reload_Call struct { + *mock.Call +} + +// Reload is a helper method to define mock.On call +// - flags uint32 +func (_e *MockNetworkManager_Expecter) Reload(flags interface{}) *MockNetworkManager_Reload_Call { + return &MockNetworkManager_Reload_Call{Call: _e.mock.On("Reload", flags)} +} + +func (_c *MockNetworkManager_Reload_Call) Run(run func(flags uint32)) *MockNetworkManager_Reload_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(uint32)) + }) + return _c +} + +func (_c *MockNetworkManager_Reload_Call) Return(_a0 error) *MockNetworkManager_Reload_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockNetworkManager_Reload_Call) RunAndReturn(run func(uint32) error) *MockNetworkManager_Reload_Call { + _c.Call.Return(run) + return _c +} + +// SetPropertyWirelessEnabled provides a mock function with given fields: _a0 +func (_m *MockNetworkManager) SetPropertyWirelessEnabled(_a0 bool) error { + ret := _m.Called(_a0) + + if len(ret) == 0 { + panic("no return value specified for SetPropertyWirelessEnabled") + } + + var r0 error + if rf, ok := ret.Get(0).(func(bool) error); ok { + r0 = rf(_a0) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockNetworkManager_SetPropertyWirelessEnabled_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetPropertyWirelessEnabled' +type MockNetworkManager_SetPropertyWirelessEnabled_Call struct { + *mock.Call +} + +// SetPropertyWirelessEnabled is a helper method to define mock.On call +// - _a0 bool +func (_e *MockNetworkManager_Expecter) SetPropertyWirelessEnabled(_a0 interface{}) *MockNetworkManager_SetPropertyWirelessEnabled_Call { + return &MockNetworkManager_SetPropertyWirelessEnabled_Call{Call: _e.mock.On("SetPropertyWirelessEnabled", _a0)} +} + +func (_c *MockNetworkManager_SetPropertyWirelessEnabled_Call) Run(run func(_a0 bool)) *MockNetworkManager_SetPropertyWirelessEnabled_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(bool)) + }) + return _c +} + +func (_c *MockNetworkManager_SetPropertyWirelessEnabled_Call) Return(_a0 error) *MockNetworkManager_SetPropertyWirelessEnabled_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockNetworkManager_SetPropertyWirelessEnabled_Call) RunAndReturn(run func(bool) error) *MockNetworkManager_SetPropertyWirelessEnabled_Call { + _c.Call.Return(run) + return _c +} + +// Sleep provides a mock function with given fields: sleepNWake +func (_m *MockNetworkManager) Sleep(sleepNWake bool) error { + ret := _m.Called(sleepNWake) + + if len(ret) == 0 { + panic("no return value specified for Sleep") + } + + var r0 error + if rf, ok := ret.Get(0).(func(bool) error); ok { + r0 = rf(sleepNWake) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockNetworkManager_Sleep_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Sleep' +type MockNetworkManager_Sleep_Call struct { + *mock.Call +} + +// Sleep is a helper method to define mock.On call +// - sleepNWake bool +func (_e *MockNetworkManager_Expecter) Sleep(sleepNWake interface{}) *MockNetworkManager_Sleep_Call { + return &MockNetworkManager_Sleep_Call{Call: _e.mock.On("Sleep", sleepNWake)} +} + +func (_c *MockNetworkManager_Sleep_Call) Run(run func(sleepNWake bool)) *MockNetworkManager_Sleep_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(bool)) + }) + return _c +} + +func (_c *MockNetworkManager_Sleep_Call) Return(_a0 error) *MockNetworkManager_Sleep_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockNetworkManager_Sleep_Call) RunAndReturn(run func(bool) error) *MockNetworkManager_Sleep_Call { + _c.Call.Return(run) + return _c +} + +// State provides a mock function with no fields +func (_m *MockNetworkManager) State() (gonetworkmanager.NmState, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for State") + } + + var r0 gonetworkmanager.NmState + var r1 error + if rf, ok := ret.Get(0).(func() (gonetworkmanager.NmState, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() gonetworkmanager.NmState); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(gonetworkmanager.NmState) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockNetworkManager_State_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'State' +type MockNetworkManager_State_Call struct { + *mock.Call +} + +// State is a helper method to define mock.On call +func (_e *MockNetworkManager_Expecter) State() *MockNetworkManager_State_Call { + return &MockNetworkManager_State_Call{Call: _e.mock.On("State")} +} + +func (_c *MockNetworkManager_State_Call) Run(run func()) *MockNetworkManager_State_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockNetworkManager_State_Call) Return(_a0 gonetworkmanager.NmState, _a1 error) *MockNetworkManager_State_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockNetworkManager_State_Call) RunAndReturn(run func() (gonetworkmanager.NmState, error)) *MockNetworkManager_State_Call { + _c.Call.Return(run) + return _c +} + +// Subscribe provides a mock function with no fields +func (_m *MockNetworkManager) Subscribe() <-chan *dbus.Signal { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Subscribe") + } + + var r0 <-chan *dbus.Signal + if rf, ok := ret.Get(0).(func() <-chan *dbus.Signal); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(<-chan *dbus.Signal) + } + } + + return r0 +} + +// MockNetworkManager_Subscribe_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Subscribe' +type MockNetworkManager_Subscribe_Call struct { + *mock.Call +} + +// Subscribe is a helper method to define mock.On call +func (_e *MockNetworkManager_Expecter) Subscribe() *MockNetworkManager_Subscribe_Call { + return &MockNetworkManager_Subscribe_Call{Call: _e.mock.On("Subscribe")} +} + +func (_c *MockNetworkManager_Subscribe_Call) Run(run func()) *MockNetworkManager_Subscribe_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockNetworkManager_Subscribe_Call) Return(_a0 <-chan *dbus.Signal) *MockNetworkManager_Subscribe_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockNetworkManager_Subscribe_Call) RunAndReturn(run func() <-chan *dbus.Signal) *MockNetworkManager_Subscribe_Call { + _c.Call.Return(run) + return _c +} + +// Unsubscribe provides a mock function with no fields +func (_m *MockNetworkManager) Unsubscribe() { + _m.Called() +} + +// MockNetworkManager_Unsubscribe_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Unsubscribe' +type MockNetworkManager_Unsubscribe_Call struct { + *mock.Call +} + +// Unsubscribe is a helper method to define mock.On call +func (_e *MockNetworkManager_Expecter) Unsubscribe() *MockNetworkManager_Unsubscribe_Call { + return &MockNetworkManager_Unsubscribe_Call{Call: _e.mock.On("Unsubscribe")} +} + +func (_c *MockNetworkManager_Unsubscribe_Call) Run(run func()) *MockNetworkManager_Unsubscribe_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockNetworkManager_Unsubscribe_Call) Return() *MockNetworkManager_Unsubscribe_Call { + _c.Call.Return() + return _c +} + +func (_c *MockNetworkManager_Unsubscribe_Call) RunAndReturn(run func()) *MockNetworkManager_Unsubscribe_Call { + _c.Run(run) + return _c +} + +// NewMockNetworkManager creates a new instance of MockNetworkManager. 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 NewMockNetworkManager(t interface { + mock.TestingT + Cleanup(func()) +}) *MockNetworkManager { + mock := &MockNetworkManager{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/github.com/Wifx/gonetworkmanager/v2/mock_Settings.go b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/github.com/Wifx/gonetworkmanager/v2/mock_Settings.go new file mode 100644 index 0000000..20f488e --- /dev/null +++ b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/github.com/Wifx/gonetworkmanager/v2/mock_Settings.go @@ -0,0 +1,467 @@ +// Code generated by mockery v2.53.5. DO NOT EDIT. + +package gonetworkmanager + +import ( + gonetworkmanager "github.com/Wifx/gonetworkmanager/v2" + mock "github.com/stretchr/testify/mock" +) + +// MockSettings is an autogenerated mock type for the Settings type +type MockSettings struct { + mock.Mock +} + +type MockSettings_Expecter struct { + mock *mock.Mock +} + +func (_m *MockSettings) EXPECT() *MockSettings_Expecter { + return &MockSettings_Expecter{mock: &_m.Mock} +} + +// AddConnection provides a mock function with given fields: settings +func (_m *MockSettings) AddConnection(settings gonetworkmanager.ConnectionSettings) (gonetworkmanager.Connection, error) { + ret := _m.Called(settings) + + if len(ret) == 0 { + panic("no return value specified for AddConnection") + } + + var r0 gonetworkmanager.Connection + var r1 error + if rf, ok := ret.Get(0).(func(gonetworkmanager.ConnectionSettings) (gonetworkmanager.Connection, error)); ok { + return rf(settings) + } + if rf, ok := ret.Get(0).(func(gonetworkmanager.ConnectionSettings) gonetworkmanager.Connection); ok { + r0 = rf(settings) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(gonetworkmanager.Connection) + } + } + + if rf, ok := ret.Get(1).(func(gonetworkmanager.ConnectionSettings) error); ok { + r1 = rf(settings) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockSettings_AddConnection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddConnection' +type MockSettings_AddConnection_Call struct { + *mock.Call +} + +// AddConnection is a helper method to define mock.On call +// - settings gonetworkmanager.ConnectionSettings +func (_e *MockSettings_Expecter) AddConnection(settings interface{}) *MockSettings_AddConnection_Call { + return &MockSettings_AddConnection_Call{Call: _e.mock.On("AddConnection", settings)} +} + +func (_c *MockSettings_AddConnection_Call) Run(run func(settings gonetworkmanager.ConnectionSettings)) *MockSettings_AddConnection_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(gonetworkmanager.ConnectionSettings)) + }) + return _c +} + +func (_c *MockSettings_AddConnection_Call) Return(_a0 gonetworkmanager.Connection, _a1 error) *MockSettings_AddConnection_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockSettings_AddConnection_Call) RunAndReturn(run func(gonetworkmanager.ConnectionSettings) (gonetworkmanager.Connection, error)) *MockSettings_AddConnection_Call { + _c.Call.Return(run) + return _c +} + +// AddConnectionUnsaved provides a mock function with given fields: settings +func (_m *MockSettings) AddConnectionUnsaved(settings gonetworkmanager.ConnectionSettings) (gonetworkmanager.Connection, error) { + ret := _m.Called(settings) + + if len(ret) == 0 { + panic("no return value specified for AddConnectionUnsaved") + } + + var r0 gonetworkmanager.Connection + var r1 error + if rf, ok := ret.Get(0).(func(gonetworkmanager.ConnectionSettings) (gonetworkmanager.Connection, error)); ok { + return rf(settings) + } + if rf, ok := ret.Get(0).(func(gonetworkmanager.ConnectionSettings) gonetworkmanager.Connection); ok { + r0 = rf(settings) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(gonetworkmanager.Connection) + } + } + + if rf, ok := ret.Get(1).(func(gonetworkmanager.ConnectionSettings) error); ok { + r1 = rf(settings) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockSettings_AddConnectionUnsaved_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddConnectionUnsaved' +type MockSettings_AddConnectionUnsaved_Call struct { + *mock.Call +} + +// AddConnectionUnsaved is a helper method to define mock.On call +// - settings gonetworkmanager.ConnectionSettings +func (_e *MockSettings_Expecter) AddConnectionUnsaved(settings interface{}) *MockSettings_AddConnectionUnsaved_Call { + return &MockSettings_AddConnectionUnsaved_Call{Call: _e.mock.On("AddConnectionUnsaved", settings)} +} + +func (_c *MockSettings_AddConnectionUnsaved_Call) Run(run func(settings gonetworkmanager.ConnectionSettings)) *MockSettings_AddConnectionUnsaved_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(gonetworkmanager.ConnectionSettings)) + }) + return _c +} + +func (_c *MockSettings_AddConnectionUnsaved_Call) Return(_a0 gonetworkmanager.Connection, _a1 error) *MockSettings_AddConnectionUnsaved_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockSettings_AddConnectionUnsaved_Call) RunAndReturn(run func(gonetworkmanager.ConnectionSettings) (gonetworkmanager.Connection, error)) *MockSettings_AddConnectionUnsaved_Call { + _c.Call.Return(run) + return _c +} + +// GetConnectionByUUID provides a mock function with given fields: uuid +func (_m *MockSettings) GetConnectionByUUID(uuid string) (gonetworkmanager.Connection, error) { + ret := _m.Called(uuid) + + if len(ret) == 0 { + panic("no return value specified for GetConnectionByUUID") + } + + var r0 gonetworkmanager.Connection + var r1 error + if rf, ok := ret.Get(0).(func(string) (gonetworkmanager.Connection, error)); ok { + return rf(uuid) + } + if rf, ok := ret.Get(0).(func(string) gonetworkmanager.Connection); ok { + r0 = rf(uuid) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(gonetworkmanager.Connection) + } + } + + if rf, ok := ret.Get(1).(func(string) error); ok { + r1 = rf(uuid) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockSettings_GetConnectionByUUID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetConnectionByUUID' +type MockSettings_GetConnectionByUUID_Call struct { + *mock.Call +} + +// GetConnectionByUUID is a helper method to define mock.On call +// - uuid string +func (_e *MockSettings_Expecter) GetConnectionByUUID(uuid interface{}) *MockSettings_GetConnectionByUUID_Call { + return &MockSettings_GetConnectionByUUID_Call{Call: _e.mock.On("GetConnectionByUUID", uuid)} +} + +func (_c *MockSettings_GetConnectionByUUID_Call) Run(run func(uuid string)) *MockSettings_GetConnectionByUUID_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *MockSettings_GetConnectionByUUID_Call) Return(_a0 gonetworkmanager.Connection, _a1 error) *MockSettings_GetConnectionByUUID_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockSettings_GetConnectionByUUID_Call) RunAndReturn(run func(string) (gonetworkmanager.Connection, error)) *MockSettings_GetConnectionByUUID_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyCanModify provides a mock function with no fields +func (_m *MockSettings) GetPropertyCanModify() (bool, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyCanModify") + } + + var r0 bool + var r1 error + if rf, ok := ret.Get(0).(func() (bool, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() bool); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(bool) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockSettings_GetPropertyCanModify_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyCanModify' +type MockSettings_GetPropertyCanModify_Call struct { + *mock.Call +} + +// GetPropertyCanModify is a helper method to define mock.On call +func (_e *MockSettings_Expecter) GetPropertyCanModify() *MockSettings_GetPropertyCanModify_Call { + return &MockSettings_GetPropertyCanModify_Call{Call: _e.mock.On("GetPropertyCanModify")} +} + +func (_c *MockSettings_GetPropertyCanModify_Call) Run(run func()) *MockSettings_GetPropertyCanModify_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockSettings_GetPropertyCanModify_Call) Return(_a0 bool, _a1 error) *MockSettings_GetPropertyCanModify_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockSettings_GetPropertyCanModify_Call) RunAndReturn(run func() (bool, error)) *MockSettings_GetPropertyCanModify_Call { + _c.Call.Return(run) + return _c +} + +// GetPropertyHostname provides a mock function with no fields +func (_m *MockSettings) GetPropertyHostname() (string, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPropertyHostname") + } + + var r0 string + var r1 error + if rf, ok := ret.Get(0).(func() (string, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockSettings_GetPropertyHostname_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyHostname' +type MockSettings_GetPropertyHostname_Call struct { + *mock.Call +} + +// GetPropertyHostname is a helper method to define mock.On call +func (_e *MockSettings_Expecter) GetPropertyHostname() *MockSettings_GetPropertyHostname_Call { + return &MockSettings_GetPropertyHostname_Call{Call: _e.mock.On("GetPropertyHostname")} +} + +func (_c *MockSettings_GetPropertyHostname_Call) Run(run func()) *MockSettings_GetPropertyHostname_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockSettings_GetPropertyHostname_Call) Return(_a0 string, _a1 error) *MockSettings_GetPropertyHostname_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockSettings_GetPropertyHostname_Call) RunAndReturn(run func() (string, error)) *MockSettings_GetPropertyHostname_Call { + _c.Call.Return(run) + return _c +} + +// ListConnections provides a mock function with no fields +func (_m *MockSettings) ListConnections() ([]gonetworkmanager.Connection, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for ListConnections") + } + + var r0 []gonetworkmanager.Connection + var r1 error + if rf, ok := ret.Get(0).(func() ([]gonetworkmanager.Connection, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() []gonetworkmanager.Connection); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]gonetworkmanager.Connection) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockSettings_ListConnections_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListConnections' +type MockSettings_ListConnections_Call struct { + *mock.Call +} + +// ListConnections is a helper method to define mock.On call +func (_e *MockSettings_Expecter) ListConnections() *MockSettings_ListConnections_Call { + return &MockSettings_ListConnections_Call{Call: _e.mock.On("ListConnections")} +} + +func (_c *MockSettings_ListConnections_Call) Run(run func()) *MockSettings_ListConnections_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockSettings_ListConnections_Call) Return(_a0 []gonetworkmanager.Connection, _a1 error) *MockSettings_ListConnections_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockSettings_ListConnections_Call) RunAndReturn(run func() ([]gonetworkmanager.Connection, error)) *MockSettings_ListConnections_Call { + _c.Call.Return(run) + return _c +} + +// ReloadConnections provides a mock function with no fields +func (_m *MockSettings) ReloadConnections() error { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for ReloadConnections") + } + + var r0 error + if rf, ok := ret.Get(0).(func() error); ok { + r0 = rf() + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockSettings_ReloadConnections_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReloadConnections' +type MockSettings_ReloadConnections_Call struct { + *mock.Call +} + +// ReloadConnections is a helper method to define mock.On call +func (_e *MockSettings_Expecter) ReloadConnections() *MockSettings_ReloadConnections_Call { + return &MockSettings_ReloadConnections_Call{Call: _e.mock.On("ReloadConnections")} +} + +func (_c *MockSettings_ReloadConnections_Call) Run(run func()) *MockSettings_ReloadConnections_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockSettings_ReloadConnections_Call) Return(_a0 error) *MockSettings_ReloadConnections_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockSettings_ReloadConnections_Call) RunAndReturn(run func() error) *MockSettings_ReloadConnections_Call { + _c.Call.Return(run) + return _c +} + +// SaveHostname provides a mock function with given fields: hostname +func (_m *MockSettings) SaveHostname(hostname string) error { + ret := _m.Called(hostname) + + if len(ret) == 0 { + panic("no return value specified for SaveHostname") + } + + var r0 error + if rf, ok := ret.Get(0).(func(string) error); ok { + r0 = rf(hostname) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockSettings_SaveHostname_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SaveHostname' +type MockSettings_SaveHostname_Call struct { + *mock.Call +} + +// SaveHostname is a helper method to define mock.On call +// - hostname string +func (_e *MockSettings_Expecter) SaveHostname(hostname interface{}) *MockSettings_SaveHostname_Call { + return &MockSettings_SaveHostname_Call{Call: _e.mock.On("SaveHostname", hostname)} +} + +func (_c *MockSettings_SaveHostname_Call) Run(run func(hostname string)) *MockSettings_SaveHostname_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *MockSettings_SaveHostname_Call) Return(_a0 error) *MockSettings_SaveHostname_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockSettings_SaveHostname_Call) RunAndReturn(run func(string) error) *MockSettings_SaveHostname_Call { + _c.Call.Return(run) + return _c +} + +// NewMockSettings creates a new instance of MockSettings. 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 NewMockSettings(t interface { + mock.TestingT + Cleanup(func()) +}) *MockSettings { + mock := &MockSettings{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/github.com/godbus/dbus/v5/mock_BusObject.go b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/github.com/godbus/dbus/v5/mock_BusObject.go new file mode 100644 index 0000000..c0d1a3f --- /dev/null +++ b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/github.com/godbus/dbus/v5/mock_BusObject.go @@ -0,0 +1,649 @@ +// Code generated by mockery v2.53.5. DO NOT EDIT. + +package dbus + +import ( + context "context" + + dbus "github.com/godbus/dbus/v5" + mock "github.com/stretchr/testify/mock" +) + +// MockBusObject is an autogenerated mock type for the BusObject type +type MockBusObject struct { + mock.Mock +} + +type MockBusObject_Expecter struct { + mock *mock.Mock +} + +func (_m *MockBusObject) EXPECT() *MockBusObject_Expecter { + return &MockBusObject_Expecter{mock: &_m.Mock} +} + +// AddMatchSignal provides a mock function with given fields: iface, member, options +func (_m *MockBusObject) AddMatchSignal(iface string, member string, options ...dbus.MatchOption) *dbus.Call { + _va := make([]interface{}, len(options)) + for _i := range options { + _va[_i] = options[_i] + } + var _ca []interface{} + _ca = append(_ca, iface, member) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for AddMatchSignal") + } + + var r0 *dbus.Call + if rf, ok := ret.Get(0).(func(string, string, ...dbus.MatchOption) *dbus.Call); ok { + r0 = rf(iface, member, options...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*dbus.Call) + } + } + + return r0 +} + +// MockBusObject_AddMatchSignal_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddMatchSignal' +type MockBusObject_AddMatchSignal_Call struct { + *mock.Call +} + +// AddMatchSignal is a helper method to define mock.On call +// - iface string +// - member string +// - options ...dbus.MatchOption +func (_e *MockBusObject_Expecter) AddMatchSignal(iface interface{}, member interface{}, options ...interface{}) *MockBusObject_AddMatchSignal_Call { + return &MockBusObject_AddMatchSignal_Call{Call: _e.mock.On("AddMatchSignal", + append([]interface{}{iface, member}, options...)...)} +} + +func (_c *MockBusObject_AddMatchSignal_Call) Run(run func(iface string, member string, options ...dbus.MatchOption)) *MockBusObject_AddMatchSignal_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]dbus.MatchOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(dbus.MatchOption) + } + } + run(args[0].(string), args[1].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockBusObject_AddMatchSignal_Call) Return(_a0 *dbus.Call) *MockBusObject_AddMatchSignal_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockBusObject_AddMatchSignal_Call) RunAndReturn(run func(string, string, ...dbus.MatchOption) *dbus.Call) *MockBusObject_AddMatchSignal_Call { + _c.Call.Return(run) + return _c +} + +// Call provides a mock function with given fields: method, flags, args +func (_m *MockBusObject) Call(method string, flags dbus.Flags, args ...interface{}) *dbus.Call { + var _ca []interface{} + _ca = append(_ca, method, flags) + _ca = append(_ca, args...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for Call") + } + + var r0 *dbus.Call + if rf, ok := ret.Get(0).(func(string, dbus.Flags, ...interface{}) *dbus.Call); ok { + r0 = rf(method, flags, args...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*dbus.Call) + } + } + + return r0 +} + +// MockBusObject_Call_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Call' +type MockBusObject_Call_Call struct { + *mock.Call +} + +// Call is a helper method to define mock.On call +// - method string +// - flags dbus.Flags +// - args ...interface{} +func (_e *MockBusObject_Expecter) Call(method interface{}, flags interface{}, args ...interface{}) *MockBusObject_Call_Call { + return &MockBusObject_Call_Call{Call: _e.mock.On("Call", + append([]interface{}{method, flags}, args...)...)} +} + +func (_c *MockBusObject_Call_Call) Run(run func(method string, flags dbus.Flags, args ...interface{})) *MockBusObject_Call_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]interface{}, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(interface{}) + } + } + run(args[0].(string), args[1].(dbus.Flags), variadicArgs...) + }) + return _c +} + +func (_c *MockBusObject_Call_Call) Return(_a0 *dbus.Call) *MockBusObject_Call_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockBusObject_Call_Call) RunAndReturn(run func(string, dbus.Flags, ...interface{}) *dbus.Call) *MockBusObject_Call_Call { + _c.Call.Return(run) + return _c +} + +// CallWithContext provides a mock function with given fields: ctx, method, flags, args +func (_m *MockBusObject) CallWithContext(ctx context.Context, method string, flags dbus.Flags, args ...interface{}) *dbus.Call { + var _ca []interface{} + _ca = append(_ca, ctx, method, flags) + _ca = append(_ca, args...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for CallWithContext") + } + + var r0 *dbus.Call + if rf, ok := ret.Get(0).(func(context.Context, string, dbus.Flags, ...interface{}) *dbus.Call); ok { + r0 = rf(ctx, method, flags, args...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*dbus.Call) + } + } + + return r0 +} + +// MockBusObject_CallWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CallWithContext' +type MockBusObject_CallWithContext_Call struct { + *mock.Call +} + +// CallWithContext is a helper method to define mock.On call +// - ctx context.Context +// - method string +// - flags dbus.Flags +// - args ...interface{} +func (_e *MockBusObject_Expecter) CallWithContext(ctx interface{}, method interface{}, flags interface{}, args ...interface{}) *MockBusObject_CallWithContext_Call { + return &MockBusObject_CallWithContext_Call{Call: _e.mock.On("CallWithContext", + append([]interface{}{ctx, method, flags}, args...)...)} +} + +func (_c *MockBusObject_CallWithContext_Call) Run(run func(ctx context.Context, method string, flags dbus.Flags, args ...interface{})) *MockBusObject_CallWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]interface{}, len(args)-3) + for i, a := range args[3:] { + if a != nil { + variadicArgs[i] = a.(interface{}) + } + } + run(args[0].(context.Context), args[1].(string), args[2].(dbus.Flags), variadicArgs...) + }) + return _c +} + +func (_c *MockBusObject_CallWithContext_Call) Return(_a0 *dbus.Call) *MockBusObject_CallWithContext_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockBusObject_CallWithContext_Call) RunAndReturn(run func(context.Context, string, dbus.Flags, ...interface{}) *dbus.Call) *MockBusObject_CallWithContext_Call { + _c.Call.Return(run) + return _c +} + +// Destination provides a mock function with no fields +func (_m *MockBusObject) Destination() string { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Destination") + } + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +// MockBusObject_Destination_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Destination' +type MockBusObject_Destination_Call struct { + *mock.Call +} + +// Destination is a helper method to define mock.On call +func (_e *MockBusObject_Expecter) Destination() *MockBusObject_Destination_Call { + return &MockBusObject_Destination_Call{Call: _e.mock.On("Destination")} +} + +func (_c *MockBusObject_Destination_Call) Run(run func()) *MockBusObject_Destination_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockBusObject_Destination_Call) Return(_a0 string) *MockBusObject_Destination_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockBusObject_Destination_Call) RunAndReturn(run func() string) *MockBusObject_Destination_Call { + _c.Call.Return(run) + return _c +} + +// GetProperty provides a mock function with given fields: p +func (_m *MockBusObject) GetProperty(p string) (dbus.Variant, error) { + ret := _m.Called(p) + + if len(ret) == 0 { + panic("no return value specified for GetProperty") + } + + var r0 dbus.Variant + var r1 error + if rf, ok := ret.Get(0).(func(string) (dbus.Variant, error)); ok { + return rf(p) + } + if rf, ok := ret.Get(0).(func(string) dbus.Variant); ok { + r0 = rf(p) + } else { + r0 = ret.Get(0).(dbus.Variant) + } + + if rf, ok := ret.Get(1).(func(string) error); ok { + r1 = rf(p) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockBusObject_GetProperty_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetProperty' +type MockBusObject_GetProperty_Call struct { + *mock.Call +} + +// GetProperty is a helper method to define mock.On call +// - p string +func (_e *MockBusObject_Expecter) GetProperty(p interface{}) *MockBusObject_GetProperty_Call { + return &MockBusObject_GetProperty_Call{Call: _e.mock.On("GetProperty", p)} +} + +func (_c *MockBusObject_GetProperty_Call) Run(run func(p string)) *MockBusObject_GetProperty_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *MockBusObject_GetProperty_Call) Return(_a0 dbus.Variant, _a1 error) *MockBusObject_GetProperty_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockBusObject_GetProperty_Call) RunAndReturn(run func(string) (dbus.Variant, error)) *MockBusObject_GetProperty_Call { + _c.Call.Return(run) + return _c +} + +// Go provides a mock function with given fields: method, flags, ch, args +func (_m *MockBusObject) Go(method string, flags dbus.Flags, ch chan *dbus.Call, args ...interface{}) *dbus.Call { + var _ca []interface{} + _ca = append(_ca, method, flags, ch) + _ca = append(_ca, args...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for Go") + } + + var r0 *dbus.Call + if rf, ok := ret.Get(0).(func(string, dbus.Flags, chan *dbus.Call, ...interface{}) *dbus.Call); ok { + r0 = rf(method, flags, ch, args...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*dbus.Call) + } + } + + return r0 +} + +// MockBusObject_Go_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Go' +type MockBusObject_Go_Call struct { + *mock.Call +} + +// Go is a helper method to define mock.On call +// - method string +// - flags dbus.Flags +// - ch chan *dbus.Call +// - args ...interface{} +func (_e *MockBusObject_Expecter) Go(method interface{}, flags interface{}, ch interface{}, args ...interface{}) *MockBusObject_Go_Call { + return &MockBusObject_Go_Call{Call: _e.mock.On("Go", + append([]interface{}{method, flags, ch}, args...)...)} +} + +func (_c *MockBusObject_Go_Call) Run(run func(method string, flags dbus.Flags, ch chan *dbus.Call, args ...interface{})) *MockBusObject_Go_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]interface{}, len(args)-3) + for i, a := range args[3:] { + if a != nil { + variadicArgs[i] = a.(interface{}) + } + } + run(args[0].(string), args[1].(dbus.Flags), args[2].(chan *dbus.Call), variadicArgs...) + }) + return _c +} + +func (_c *MockBusObject_Go_Call) Return(_a0 *dbus.Call) *MockBusObject_Go_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockBusObject_Go_Call) RunAndReturn(run func(string, dbus.Flags, chan *dbus.Call, ...interface{}) *dbus.Call) *MockBusObject_Go_Call { + _c.Call.Return(run) + return _c +} + +// GoWithContext provides a mock function with given fields: ctx, method, flags, ch, args +func (_m *MockBusObject) GoWithContext(ctx context.Context, method string, flags dbus.Flags, ch chan *dbus.Call, args ...interface{}) *dbus.Call { + var _ca []interface{} + _ca = append(_ca, ctx, method, flags, ch) + _ca = append(_ca, args...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for GoWithContext") + } + + var r0 *dbus.Call + if rf, ok := ret.Get(0).(func(context.Context, string, dbus.Flags, chan *dbus.Call, ...interface{}) *dbus.Call); ok { + r0 = rf(ctx, method, flags, ch, args...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*dbus.Call) + } + } + + return r0 +} + +// MockBusObject_GoWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GoWithContext' +type MockBusObject_GoWithContext_Call struct { + *mock.Call +} + +// GoWithContext is a helper method to define mock.On call +// - ctx context.Context +// - method string +// - flags dbus.Flags +// - ch chan *dbus.Call +// - args ...interface{} +func (_e *MockBusObject_Expecter) GoWithContext(ctx interface{}, method interface{}, flags interface{}, ch interface{}, args ...interface{}) *MockBusObject_GoWithContext_Call { + return &MockBusObject_GoWithContext_Call{Call: _e.mock.On("GoWithContext", + append([]interface{}{ctx, method, flags, ch}, args...)...)} +} + +func (_c *MockBusObject_GoWithContext_Call) Run(run func(ctx context.Context, method string, flags dbus.Flags, ch chan *dbus.Call, args ...interface{})) *MockBusObject_GoWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]interface{}, len(args)-4) + for i, a := range args[4:] { + if a != nil { + variadicArgs[i] = a.(interface{}) + } + } + run(args[0].(context.Context), args[1].(string), args[2].(dbus.Flags), args[3].(chan *dbus.Call), variadicArgs...) + }) + return _c +} + +func (_c *MockBusObject_GoWithContext_Call) Return(_a0 *dbus.Call) *MockBusObject_GoWithContext_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockBusObject_GoWithContext_Call) RunAndReturn(run func(context.Context, string, dbus.Flags, chan *dbus.Call, ...interface{}) *dbus.Call) *MockBusObject_GoWithContext_Call { + _c.Call.Return(run) + return _c +} + +// Path provides a mock function with no fields +func (_m *MockBusObject) Path() dbus.ObjectPath { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Path") + } + + var r0 dbus.ObjectPath + if rf, ok := ret.Get(0).(func() dbus.ObjectPath); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(dbus.ObjectPath) + } + + return r0 +} + +// MockBusObject_Path_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Path' +type MockBusObject_Path_Call struct { + *mock.Call +} + +// Path is a helper method to define mock.On call +func (_e *MockBusObject_Expecter) Path() *MockBusObject_Path_Call { + return &MockBusObject_Path_Call{Call: _e.mock.On("Path")} +} + +func (_c *MockBusObject_Path_Call) Run(run func()) *MockBusObject_Path_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockBusObject_Path_Call) Return(_a0 dbus.ObjectPath) *MockBusObject_Path_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockBusObject_Path_Call) RunAndReturn(run func() dbus.ObjectPath) *MockBusObject_Path_Call { + _c.Call.Return(run) + return _c +} + +// RemoveMatchSignal provides a mock function with given fields: iface, member, options +func (_m *MockBusObject) RemoveMatchSignal(iface string, member string, options ...dbus.MatchOption) *dbus.Call { + _va := make([]interface{}, len(options)) + for _i := range options { + _va[_i] = options[_i] + } + var _ca []interface{} + _ca = append(_ca, iface, member) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for RemoveMatchSignal") + } + + var r0 *dbus.Call + if rf, ok := ret.Get(0).(func(string, string, ...dbus.MatchOption) *dbus.Call); ok { + r0 = rf(iface, member, options...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*dbus.Call) + } + } + + return r0 +} + +// MockBusObject_RemoveMatchSignal_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveMatchSignal' +type MockBusObject_RemoveMatchSignal_Call struct { + *mock.Call +} + +// RemoveMatchSignal is a helper method to define mock.On call +// - iface string +// - member string +// - options ...dbus.MatchOption +func (_e *MockBusObject_Expecter) RemoveMatchSignal(iface interface{}, member interface{}, options ...interface{}) *MockBusObject_RemoveMatchSignal_Call { + return &MockBusObject_RemoveMatchSignal_Call{Call: _e.mock.On("RemoveMatchSignal", + append([]interface{}{iface, member}, options...)...)} +} + +func (_c *MockBusObject_RemoveMatchSignal_Call) Run(run func(iface string, member string, options ...dbus.MatchOption)) *MockBusObject_RemoveMatchSignal_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]dbus.MatchOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(dbus.MatchOption) + } + } + run(args[0].(string), args[1].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockBusObject_RemoveMatchSignal_Call) Return(_a0 *dbus.Call) *MockBusObject_RemoveMatchSignal_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockBusObject_RemoveMatchSignal_Call) RunAndReturn(run func(string, string, ...dbus.MatchOption) *dbus.Call) *MockBusObject_RemoveMatchSignal_Call { + _c.Call.Return(run) + return _c +} + +// SetProperty provides a mock function with given fields: p, v +func (_m *MockBusObject) SetProperty(p string, v interface{}) error { + ret := _m.Called(p, v) + + if len(ret) == 0 { + panic("no return value specified for SetProperty") + } + + var r0 error + if rf, ok := ret.Get(0).(func(string, interface{}) error); ok { + r0 = rf(p, v) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockBusObject_SetProperty_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetProperty' +type MockBusObject_SetProperty_Call struct { + *mock.Call +} + +// SetProperty is a helper method to define mock.On call +// - p string +// - v interface{} +func (_e *MockBusObject_Expecter) SetProperty(p interface{}, v interface{}) *MockBusObject_SetProperty_Call { + return &MockBusObject_SetProperty_Call{Call: _e.mock.On("SetProperty", p, v)} +} + +func (_c *MockBusObject_SetProperty_Call) Run(run func(p string, v interface{})) *MockBusObject_SetProperty_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(interface{})) + }) + return _c +} + +func (_c *MockBusObject_SetProperty_Call) Return(_a0 error) *MockBusObject_SetProperty_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockBusObject_SetProperty_Call) RunAndReturn(run func(string, interface{}) error) *MockBusObject_SetProperty_Call { + _c.Call.Return(run) + return _c +} + +// StoreProperty provides a mock function with given fields: p, value +func (_m *MockBusObject) StoreProperty(p string, value interface{}) error { + ret := _m.Called(p, value) + + if len(ret) == 0 { + panic("no return value specified for StoreProperty") + } + + var r0 error + if rf, ok := ret.Get(0).(func(string, interface{}) error); ok { + r0 = rf(p, value) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockBusObject_StoreProperty_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StoreProperty' +type MockBusObject_StoreProperty_Call struct { + *mock.Call +} + +// StoreProperty is a helper method to define mock.On call +// - p string +// - value interface{} +func (_e *MockBusObject_Expecter) StoreProperty(p interface{}, value interface{}) *MockBusObject_StoreProperty_Call { + return &MockBusObject_StoreProperty_Call{Call: _e.mock.On("StoreProperty", p, value)} +} + +func (_c *MockBusObject_StoreProperty_Call) Run(run func(p string, value interface{})) *MockBusObject_StoreProperty_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(interface{})) + }) + return _c +} + +func (_c *MockBusObject_StoreProperty_Call) Return(_a0 error) *MockBusObject_StoreProperty_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockBusObject_StoreProperty_Call) RunAndReturn(run func(string, interface{}) error) *MockBusObject_StoreProperty_Call { + _c.Call.Return(run) + return _c +} + +// NewMockBusObject creates a new instance of MockBusObject. 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 NewMockBusObject(t interface { + mock.TestingT + Cleanup(func()) +}) *MockBusObject { + mock := &MockBusObject{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/internal/plugins/mock_GitClient.go b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/internal/plugins/mock_GitClient.go new file mode 100644 index 0000000..23e34f3 --- /dev/null +++ b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/internal/plugins/mock_GitClient.go @@ -0,0 +1,181 @@ +// Code generated by mockery v2.53.5. DO NOT EDIT. + +package plugins + +import mock "github.com/stretchr/testify/mock" + +// MockGitClient is an autogenerated mock type for the GitClient type +type MockGitClient struct { + mock.Mock +} + +type MockGitClient_Expecter struct { + mock *mock.Mock +} + +func (_m *MockGitClient) EXPECT() *MockGitClient_Expecter { + return &MockGitClient_Expecter{mock: &_m.Mock} +} + +// HasUpdates provides a mock function with given fields: path +func (_m *MockGitClient) HasUpdates(path string) (bool, error) { + ret := _m.Called(path) + + if len(ret) == 0 { + panic("no return value specified for HasUpdates") + } + + var r0 bool + var r1 error + if rf, ok := ret.Get(0).(func(string) (bool, error)); ok { + return rf(path) + } + if rf, ok := ret.Get(0).(func(string) bool); ok { + r0 = rf(path) + } else { + r0 = ret.Get(0).(bool) + } + + if rf, ok := ret.Get(1).(func(string) error); ok { + r1 = rf(path) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockGitClient_HasUpdates_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasUpdates' +type MockGitClient_HasUpdates_Call struct { + *mock.Call +} + +// HasUpdates is a helper method to define mock.On call +// - path string +func (_e *MockGitClient_Expecter) HasUpdates(path any) *MockGitClient_HasUpdates_Call { + return &MockGitClient_HasUpdates_Call{Call: _e.mock.On("HasUpdates", path)} +} + +func (_c *MockGitClient_HasUpdates_Call) Run(run func(path string)) *MockGitClient_HasUpdates_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *MockGitClient_HasUpdates_Call) Return(_a0 bool, _a1 error) *MockGitClient_HasUpdates_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGitClient_HasUpdates_Call) RunAndReturn(run func(string) (bool, error)) *MockGitClient_HasUpdates_Call { + _c.Call.Return(run) + return _c +} + +// PlainClone provides a mock function with given fields: path, url +func (_m *MockGitClient) PlainClone(path string, url string) error { + ret := _m.Called(path, url) + + if len(ret) == 0 { + panic("no return value specified for PlainClone") + } + + var r0 error + if rf, ok := ret.Get(0).(func(string, string) error); ok { + r0 = rf(path, url) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockGitClient_PlainClone_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PlainClone' +type MockGitClient_PlainClone_Call struct { + *mock.Call +} + +// PlainClone is a helper method to define mock.On call +// - path string +// - url string +func (_e *MockGitClient_Expecter) PlainClone(path any, url any) *MockGitClient_PlainClone_Call { + return &MockGitClient_PlainClone_Call{Call: _e.mock.On("PlainClone", path, url)} +} + +func (_c *MockGitClient_PlainClone_Call) Run(run func(path string, url string)) *MockGitClient_PlainClone_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string)) + }) + return _c +} + +func (_c *MockGitClient_PlainClone_Call) Return(_a0 error) *MockGitClient_PlainClone_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockGitClient_PlainClone_Call) RunAndReturn(run func(string, string) error) *MockGitClient_PlainClone_Call { + _c.Call.Return(run) + return _c +} + +// Pull provides a mock function with given fields: path +func (_m *MockGitClient) Pull(path string) error { + ret := _m.Called(path) + + if len(ret) == 0 { + panic("no return value specified for Pull") + } + + var r0 error + if rf, ok := ret.Get(0).(func(string) error); ok { + r0 = rf(path) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockGitClient_Pull_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Pull' +type MockGitClient_Pull_Call struct { + *mock.Call +} + +// Pull is a helper method to define mock.On call +// - path string +func (_e *MockGitClient_Expecter) Pull(path any) *MockGitClient_Pull_Call { + return &MockGitClient_Pull_Call{Call: _e.mock.On("Pull", path)} +} + +func (_c *MockGitClient_Pull_Call) Run(run func(path string)) *MockGitClient_Pull_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *MockGitClient_Pull_Call) Return(_a0 error) *MockGitClient_Pull_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockGitClient_Pull_Call) RunAndReturn(run func(string) error) *MockGitClient_Pull_Call { + _c.Call.Return(run) + return _c +} + +// NewMockGitClient creates a new instance of MockGitClient. 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 NewMockGitClient(t interface { + mock.TestingT + Cleanup(func()) +}) *MockGitClient { + mock := &MockGitClient{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/net/mock_Conn.go b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/net/mock_Conn.go new file mode 100644 index 0000000..248a0d8 --- /dev/null +++ b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/net/mock_Conn.go @@ -0,0 +1,427 @@ +// Code generated by mockery v2.53.5. DO NOT EDIT. + +package net + +import ( + net "net" + + mock "github.com/stretchr/testify/mock" + + time "time" +) + +// MockConn is an autogenerated mock type for the Conn type +type MockConn struct { + mock.Mock +} + +type MockConn_Expecter struct { + mock *mock.Mock +} + +func (_m *MockConn) EXPECT() *MockConn_Expecter { + return &MockConn_Expecter{mock: &_m.Mock} +} + +// Close provides a mock function with no fields +func (_m *MockConn) Close() error { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Close") + } + + var r0 error + if rf, ok := ret.Get(0).(func() error); ok { + r0 = rf() + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockConn_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close' +type MockConn_Close_Call struct { + *mock.Call +} + +// Close is a helper method to define mock.On call +func (_e *MockConn_Expecter) Close() *MockConn_Close_Call { + return &MockConn_Close_Call{Call: _e.mock.On("Close")} +} + +func (_c *MockConn_Close_Call) Run(run func()) *MockConn_Close_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockConn_Close_Call) Return(_a0 error) *MockConn_Close_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockConn_Close_Call) RunAndReturn(run func() error) *MockConn_Close_Call { + _c.Call.Return(run) + return _c +} + +// LocalAddr provides a mock function with no fields +func (_m *MockConn) LocalAddr() net.Addr { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for LocalAddr") + } + + var r0 net.Addr + if rf, ok := ret.Get(0).(func() net.Addr); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(net.Addr) + } + } + + return r0 +} + +// MockConn_LocalAddr_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LocalAddr' +type MockConn_LocalAddr_Call struct { + *mock.Call +} + +// LocalAddr is a helper method to define mock.On call +func (_e *MockConn_Expecter) LocalAddr() *MockConn_LocalAddr_Call { + return &MockConn_LocalAddr_Call{Call: _e.mock.On("LocalAddr")} +} + +func (_c *MockConn_LocalAddr_Call) Run(run func()) *MockConn_LocalAddr_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockConn_LocalAddr_Call) Return(_a0 net.Addr) *MockConn_LocalAddr_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockConn_LocalAddr_Call) RunAndReturn(run func() net.Addr) *MockConn_LocalAddr_Call { + _c.Call.Return(run) + return _c +} + +// Read provides a mock function with given fields: b +func (_m *MockConn) Read(b []byte) (int, error) { + ret := _m.Called(b) + + if len(ret) == 0 { + panic("no return value specified for Read") + } + + var r0 int + var r1 error + if rf, ok := ret.Get(0).(func([]byte) (int, error)); ok { + return rf(b) + } + if rf, ok := ret.Get(0).(func([]byte) int); ok { + r0 = rf(b) + } else { + r0 = ret.Get(0).(int) + } + + if rf, ok := ret.Get(1).(func([]byte) error); ok { + r1 = rf(b) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockConn_Read_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Read' +type MockConn_Read_Call struct { + *mock.Call +} + +// Read is a helper method to define mock.On call +// - b []byte +func (_e *MockConn_Expecter) Read(b interface{}) *MockConn_Read_Call { + return &MockConn_Read_Call{Call: _e.mock.On("Read", b)} +} + +func (_c *MockConn_Read_Call) Run(run func(b []byte)) *MockConn_Read_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].([]byte)) + }) + return _c +} + +func (_c *MockConn_Read_Call) Return(n int, err error) *MockConn_Read_Call { + _c.Call.Return(n, err) + return _c +} + +func (_c *MockConn_Read_Call) RunAndReturn(run func([]byte) (int, error)) *MockConn_Read_Call { + _c.Call.Return(run) + return _c +} + +// RemoteAddr provides a mock function with no fields +func (_m *MockConn) RemoteAddr() net.Addr { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for RemoteAddr") + } + + var r0 net.Addr + if rf, ok := ret.Get(0).(func() net.Addr); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(net.Addr) + } + } + + return r0 +} + +// MockConn_RemoteAddr_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoteAddr' +type MockConn_RemoteAddr_Call struct { + *mock.Call +} + +// RemoteAddr is a helper method to define mock.On call +func (_e *MockConn_Expecter) RemoteAddr() *MockConn_RemoteAddr_Call { + return &MockConn_RemoteAddr_Call{Call: _e.mock.On("RemoteAddr")} +} + +func (_c *MockConn_RemoteAddr_Call) Run(run func()) *MockConn_RemoteAddr_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockConn_RemoteAddr_Call) Return(_a0 net.Addr) *MockConn_RemoteAddr_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockConn_RemoteAddr_Call) RunAndReturn(run func() net.Addr) *MockConn_RemoteAddr_Call { + _c.Call.Return(run) + return _c +} + +// SetDeadline provides a mock function with given fields: t +func (_m *MockConn) SetDeadline(t time.Time) error { + ret := _m.Called(t) + + if len(ret) == 0 { + panic("no return value specified for SetDeadline") + } + + var r0 error + if rf, ok := ret.Get(0).(func(time.Time) error); ok { + r0 = rf(t) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockConn_SetDeadline_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetDeadline' +type MockConn_SetDeadline_Call struct { + *mock.Call +} + +// SetDeadline is a helper method to define mock.On call +// - t time.Time +func (_e *MockConn_Expecter) SetDeadline(t interface{}) *MockConn_SetDeadline_Call { + return &MockConn_SetDeadline_Call{Call: _e.mock.On("SetDeadline", t)} +} + +func (_c *MockConn_SetDeadline_Call) Run(run func(t time.Time)) *MockConn_SetDeadline_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(time.Time)) + }) + return _c +} + +func (_c *MockConn_SetDeadline_Call) Return(_a0 error) *MockConn_SetDeadline_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockConn_SetDeadline_Call) RunAndReturn(run func(time.Time) error) *MockConn_SetDeadline_Call { + _c.Call.Return(run) + return _c +} + +// SetReadDeadline provides a mock function with given fields: t +func (_m *MockConn) SetReadDeadline(t time.Time) error { + ret := _m.Called(t) + + if len(ret) == 0 { + panic("no return value specified for SetReadDeadline") + } + + var r0 error + if rf, ok := ret.Get(0).(func(time.Time) error); ok { + r0 = rf(t) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockConn_SetReadDeadline_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetReadDeadline' +type MockConn_SetReadDeadline_Call struct { + *mock.Call +} + +// SetReadDeadline is a helper method to define mock.On call +// - t time.Time +func (_e *MockConn_Expecter) SetReadDeadline(t interface{}) *MockConn_SetReadDeadline_Call { + return &MockConn_SetReadDeadline_Call{Call: _e.mock.On("SetReadDeadline", t)} +} + +func (_c *MockConn_SetReadDeadline_Call) Run(run func(t time.Time)) *MockConn_SetReadDeadline_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(time.Time)) + }) + return _c +} + +func (_c *MockConn_SetReadDeadline_Call) Return(_a0 error) *MockConn_SetReadDeadline_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockConn_SetReadDeadline_Call) RunAndReturn(run func(time.Time) error) *MockConn_SetReadDeadline_Call { + _c.Call.Return(run) + return _c +} + +// SetWriteDeadline provides a mock function with given fields: t +func (_m *MockConn) SetWriteDeadline(t time.Time) error { + ret := _m.Called(t) + + if len(ret) == 0 { + panic("no return value specified for SetWriteDeadline") + } + + var r0 error + if rf, ok := ret.Get(0).(func(time.Time) error); ok { + r0 = rf(t) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockConn_SetWriteDeadline_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetWriteDeadline' +type MockConn_SetWriteDeadline_Call struct { + *mock.Call +} + +// SetWriteDeadline is a helper method to define mock.On call +// - t time.Time +func (_e *MockConn_Expecter) SetWriteDeadline(t interface{}) *MockConn_SetWriteDeadline_Call { + return &MockConn_SetWriteDeadline_Call{Call: _e.mock.On("SetWriteDeadline", t)} +} + +func (_c *MockConn_SetWriteDeadline_Call) Run(run func(t time.Time)) *MockConn_SetWriteDeadline_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(time.Time)) + }) + return _c +} + +func (_c *MockConn_SetWriteDeadline_Call) Return(_a0 error) *MockConn_SetWriteDeadline_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockConn_SetWriteDeadline_Call) RunAndReturn(run func(time.Time) error) *MockConn_SetWriteDeadline_Call { + _c.Call.Return(run) + return _c +} + +// Write provides a mock function with given fields: b +func (_m *MockConn) Write(b []byte) (int, error) { + ret := _m.Called(b) + + if len(ret) == 0 { + panic("no return value specified for Write") + } + + var r0 int + var r1 error + if rf, ok := ret.Get(0).(func([]byte) (int, error)); ok { + return rf(b) + } + if rf, ok := ret.Get(0).(func([]byte) int); ok { + r0 = rf(b) + } else { + r0 = ret.Get(0).(int) + } + + if rf, ok := ret.Get(1).(func([]byte) error); ok { + r1 = rf(b) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockConn_Write_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Write' +type MockConn_Write_Call struct { + *mock.Call +} + +// Write is a helper method to define mock.On call +// - b []byte +func (_e *MockConn_Expecter) Write(b interface{}) *MockConn_Write_Call { + return &MockConn_Write_Call{Call: _e.mock.On("Write", b)} +} + +func (_c *MockConn_Write_Call) Run(run func(b []byte)) *MockConn_Write_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].([]byte)) + }) + return _c +} + +func (_c *MockConn_Write_Call) Return(n int, err error) *MockConn_Write_Call { + _c.Call.Return(n, err) + return _c +} + +func (_c *MockConn_Write_Call) RunAndReturn(run func([]byte) (int, error)) *MockConn_Write_Call { + _c.Call.Return(run) + return _c +} + +// NewMockConn creates a new instance of MockConn. 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 NewMockConn(t interface { + mock.TestingT + Cleanup(func()) +}) *MockConn { + mock := &MockConn{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/network/mock_Backend.go b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/network/mock_Backend.go new file mode 100644 index 0000000..d7eb2df --- /dev/null +++ b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/network/mock_Backend.go @@ -0,0 +1,1975 @@ +// Code generated by mockery v2.53.5. DO NOT EDIT. + +package mocks_network + +import ( + network "github.com/AvengeMedia/DankMaterialShell/core/internal/server/network" + mock "github.com/stretchr/testify/mock" +) + +// MockBackend is an autogenerated mock type for the Backend type +type MockBackend struct { + mock.Mock +} + +type MockBackend_Expecter struct { + mock *mock.Mock +} + +func (_m *MockBackend) EXPECT() *MockBackend_Expecter { + return &MockBackend_Expecter{mock: &_m.Mock} +} + +// ActivateWiredConnection provides a mock function with given fields: uuid +func (_m *MockBackend) ActivateWiredConnection(uuid string) error { + ret := _m.Called(uuid) + + if len(ret) == 0 { + panic("no return value specified for ActivateWiredConnection") + } + + var r0 error + if rf, ok := ret.Get(0).(func(string) error); ok { + r0 = rf(uuid) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockBackend_ActivateWiredConnection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ActivateWiredConnection' +type MockBackend_ActivateWiredConnection_Call struct { + *mock.Call +} + +// ActivateWiredConnection is a helper method to define mock.On call +// - uuid string +func (_e *MockBackend_Expecter) ActivateWiredConnection(uuid interface{}) *MockBackend_ActivateWiredConnection_Call { + return &MockBackend_ActivateWiredConnection_Call{Call: _e.mock.On("ActivateWiredConnection", uuid)} +} + +func (_c *MockBackend_ActivateWiredConnection_Call) Run(run func(uuid string)) *MockBackend_ActivateWiredConnection_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *MockBackend_ActivateWiredConnection_Call) Return(_a0 error) *MockBackend_ActivateWiredConnection_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockBackend_ActivateWiredConnection_Call) RunAndReturn(run func(string) error) *MockBackend_ActivateWiredConnection_Call { + _c.Call.Return(run) + return _c +} + +// CancelCredentials provides a mock function with given fields: token +func (_m *MockBackend) CancelCredentials(token string) error { + ret := _m.Called(token) + + if len(ret) == 0 { + panic("no return value specified for CancelCredentials") + } + + var r0 error + if rf, ok := ret.Get(0).(func(string) error); ok { + r0 = rf(token) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockBackend_CancelCredentials_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CancelCredentials' +type MockBackend_CancelCredentials_Call struct { + *mock.Call +} + +// CancelCredentials is a helper method to define mock.On call +// - token string +func (_e *MockBackend_Expecter) CancelCredentials(token interface{}) *MockBackend_CancelCredentials_Call { + return &MockBackend_CancelCredentials_Call{Call: _e.mock.On("CancelCredentials", token)} +} + +func (_c *MockBackend_CancelCredentials_Call) Run(run func(token string)) *MockBackend_CancelCredentials_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *MockBackend_CancelCredentials_Call) Return(_a0 error) *MockBackend_CancelCredentials_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockBackend_CancelCredentials_Call) RunAndReturn(run func(string) error) *MockBackend_CancelCredentials_Call { + _c.Call.Return(run) + return _c +} + +// ClearVPNCredentials provides a mock function with given fields: uuidOrName +func (_m *MockBackend) ClearVPNCredentials(uuidOrName string) error { + ret := _m.Called(uuidOrName) + + if len(ret) == 0 { + panic("no return value specified for ClearVPNCredentials") + } + + var r0 error + if rf, ok := ret.Get(0).(func(string) error); ok { + r0 = rf(uuidOrName) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockBackend_ClearVPNCredentials_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClearVPNCredentials' +type MockBackend_ClearVPNCredentials_Call struct { + *mock.Call +} + +// ClearVPNCredentials is a helper method to define mock.On call +// - uuidOrName string +func (_e *MockBackend_Expecter) ClearVPNCredentials(uuidOrName interface{}) *MockBackend_ClearVPNCredentials_Call { + return &MockBackend_ClearVPNCredentials_Call{Call: _e.mock.On("ClearVPNCredentials", uuidOrName)} +} + +func (_c *MockBackend_ClearVPNCredentials_Call) Run(run func(uuidOrName string)) *MockBackend_ClearVPNCredentials_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *MockBackend_ClearVPNCredentials_Call) Return(_a0 error) *MockBackend_ClearVPNCredentials_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockBackend_ClearVPNCredentials_Call) RunAndReturn(run func(string) error) *MockBackend_ClearVPNCredentials_Call { + _c.Call.Return(run) + return _c +} + +// Close provides a mock function with no fields +func (_m *MockBackend) Close() { + _m.Called() +} + +// MockBackend_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close' +type MockBackend_Close_Call struct { + *mock.Call +} + +// Close is a helper method to define mock.On call +func (_e *MockBackend_Expecter) Close() *MockBackend_Close_Call { + return &MockBackend_Close_Call{Call: _e.mock.On("Close")} +} + +func (_c *MockBackend_Close_Call) Run(run func()) *MockBackend_Close_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockBackend_Close_Call) Return() *MockBackend_Close_Call { + _c.Call.Return() + return _c +} + +func (_c *MockBackend_Close_Call) RunAndReturn(run func()) *MockBackend_Close_Call { + _c.Run(run) + return _c +} + +// ConnectEthernet provides a mock function with no fields +func (_m *MockBackend) ConnectEthernet() error { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for ConnectEthernet") + } + + var r0 error + if rf, ok := ret.Get(0).(func() error); ok { + r0 = rf() + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockBackend_ConnectEthernet_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ConnectEthernet' +type MockBackend_ConnectEthernet_Call struct { + *mock.Call +} + +// ConnectEthernet is a helper method to define mock.On call +func (_e *MockBackend_Expecter) ConnectEthernet() *MockBackend_ConnectEthernet_Call { + return &MockBackend_ConnectEthernet_Call{Call: _e.mock.On("ConnectEthernet")} +} + +func (_c *MockBackend_ConnectEthernet_Call) Run(run func()) *MockBackend_ConnectEthernet_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockBackend_ConnectEthernet_Call) Return(_a0 error) *MockBackend_ConnectEthernet_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockBackend_ConnectEthernet_Call) RunAndReturn(run func() error) *MockBackend_ConnectEthernet_Call { + _c.Call.Return(run) + return _c +} + +// ConnectVPN provides a mock function with given fields: uuidOrName, singleActive +func (_m *MockBackend) ConnectVPN(uuidOrName string, singleActive bool) error { + ret := _m.Called(uuidOrName, singleActive) + + if len(ret) == 0 { + panic("no return value specified for ConnectVPN") + } + + var r0 error + if rf, ok := ret.Get(0).(func(string, bool) error); ok { + r0 = rf(uuidOrName, singleActive) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockBackend_ConnectVPN_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ConnectVPN' +type MockBackend_ConnectVPN_Call struct { + *mock.Call +} + +// ConnectVPN is a helper method to define mock.On call +// - uuidOrName string +// - singleActive bool +func (_e *MockBackend_Expecter) ConnectVPN(uuidOrName interface{}, singleActive interface{}) *MockBackend_ConnectVPN_Call { + return &MockBackend_ConnectVPN_Call{Call: _e.mock.On("ConnectVPN", uuidOrName, singleActive)} +} + +func (_c *MockBackend_ConnectVPN_Call) Run(run func(uuidOrName string, singleActive bool)) *MockBackend_ConnectVPN_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(bool)) + }) + return _c +} + +func (_c *MockBackend_ConnectVPN_Call) Return(_a0 error) *MockBackend_ConnectVPN_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockBackend_ConnectVPN_Call) RunAndReturn(run func(string, bool) error) *MockBackend_ConnectVPN_Call { + _c.Call.Return(run) + return _c +} + +// ConnectWiFi provides a mock function with given fields: req +func (_m *MockBackend) ConnectWiFi(req network.ConnectionRequest) error { + ret := _m.Called(req) + + if len(ret) == 0 { + panic("no return value specified for ConnectWiFi") + } + + var r0 error + if rf, ok := ret.Get(0).(func(network.ConnectionRequest) error); ok { + r0 = rf(req) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockBackend_ConnectWiFi_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ConnectWiFi' +type MockBackend_ConnectWiFi_Call struct { + *mock.Call +} + +// ConnectWiFi is a helper method to define mock.On call +// - req network.ConnectionRequest +func (_e *MockBackend_Expecter) ConnectWiFi(req interface{}) *MockBackend_ConnectWiFi_Call { + return &MockBackend_ConnectWiFi_Call{Call: _e.mock.On("ConnectWiFi", req)} +} + +func (_c *MockBackend_ConnectWiFi_Call) Run(run func(req network.ConnectionRequest)) *MockBackend_ConnectWiFi_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(network.ConnectionRequest)) + }) + return _c +} + +func (_c *MockBackend_ConnectWiFi_Call) Return(_a0 error) *MockBackend_ConnectWiFi_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockBackend_ConnectWiFi_Call) RunAndReturn(run func(network.ConnectionRequest) error) *MockBackend_ConnectWiFi_Call { + _c.Call.Return(run) + return _c +} + +// DeleteVPN provides a mock function with given fields: uuidOrName +func (_m *MockBackend) DeleteVPN(uuidOrName string) error { + ret := _m.Called(uuidOrName) + + if len(ret) == 0 { + panic("no return value specified for DeleteVPN") + } + + var r0 error + if rf, ok := ret.Get(0).(func(string) error); ok { + r0 = rf(uuidOrName) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockBackend_DeleteVPN_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteVPN' +type MockBackend_DeleteVPN_Call struct { + *mock.Call +} + +// DeleteVPN is a helper method to define mock.On call +// - uuidOrName string +func (_e *MockBackend_Expecter) DeleteVPN(uuidOrName interface{}) *MockBackend_DeleteVPN_Call { + return &MockBackend_DeleteVPN_Call{Call: _e.mock.On("DeleteVPN", uuidOrName)} +} + +func (_c *MockBackend_DeleteVPN_Call) Run(run func(uuidOrName string)) *MockBackend_DeleteVPN_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *MockBackend_DeleteVPN_Call) Return(_a0 error) *MockBackend_DeleteVPN_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockBackend_DeleteVPN_Call) RunAndReturn(run func(string) error) *MockBackend_DeleteVPN_Call { + _c.Call.Return(run) + return _c +} + +// DisconnectAllVPN provides a mock function with no fields +func (_m *MockBackend) DisconnectAllVPN() error { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for DisconnectAllVPN") + } + + var r0 error + if rf, ok := ret.Get(0).(func() error); ok { + r0 = rf() + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockBackend_DisconnectAllVPN_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisconnectAllVPN' +type MockBackend_DisconnectAllVPN_Call struct { + *mock.Call +} + +// DisconnectAllVPN is a helper method to define mock.On call +func (_e *MockBackend_Expecter) DisconnectAllVPN() *MockBackend_DisconnectAllVPN_Call { + return &MockBackend_DisconnectAllVPN_Call{Call: _e.mock.On("DisconnectAllVPN")} +} + +func (_c *MockBackend_DisconnectAllVPN_Call) Run(run func()) *MockBackend_DisconnectAllVPN_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockBackend_DisconnectAllVPN_Call) Return(_a0 error) *MockBackend_DisconnectAllVPN_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockBackend_DisconnectAllVPN_Call) RunAndReturn(run func() error) *MockBackend_DisconnectAllVPN_Call { + _c.Call.Return(run) + return _c +} + +// DisconnectEthernet provides a mock function with no fields +func (_m *MockBackend) DisconnectEthernet() error { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for DisconnectEthernet") + } + + var r0 error + if rf, ok := ret.Get(0).(func() error); ok { + r0 = rf() + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockBackend_DisconnectEthernet_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisconnectEthernet' +type MockBackend_DisconnectEthernet_Call struct { + *mock.Call +} + +// DisconnectEthernet is a helper method to define mock.On call +func (_e *MockBackend_Expecter) DisconnectEthernet() *MockBackend_DisconnectEthernet_Call { + return &MockBackend_DisconnectEthernet_Call{Call: _e.mock.On("DisconnectEthernet")} +} + +func (_c *MockBackend_DisconnectEthernet_Call) Run(run func()) *MockBackend_DisconnectEthernet_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockBackend_DisconnectEthernet_Call) Return(_a0 error) *MockBackend_DisconnectEthernet_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockBackend_DisconnectEthernet_Call) RunAndReturn(run func() error) *MockBackend_DisconnectEthernet_Call { + _c.Call.Return(run) + return _c +} + +// DisconnectEthernetDevice provides a mock function with given fields: device +func (_m *MockBackend) DisconnectEthernetDevice(device string) error { + ret := _m.Called(device) + + if len(ret) == 0 { + panic("no return value specified for DisconnectEthernetDevice") + } + + var r0 error + if rf, ok := ret.Get(0).(func(string) error); ok { + r0 = rf(device) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockBackend_DisconnectEthernetDevice_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisconnectEthernetDevice' +type MockBackend_DisconnectEthernetDevice_Call struct { + *mock.Call +} + +// DisconnectEthernetDevice is a helper method to define mock.On call +// - device string +func (_e *MockBackend_Expecter) DisconnectEthernetDevice(device interface{}) *MockBackend_DisconnectEthernetDevice_Call { + return &MockBackend_DisconnectEthernetDevice_Call{Call: _e.mock.On("DisconnectEthernetDevice", device)} +} + +func (_c *MockBackend_DisconnectEthernetDevice_Call) Run(run func(device string)) *MockBackend_DisconnectEthernetDevice_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *MockBackend_DisconnectEthernetDevice_Call) Return(_a0 error) *MockBackend_DisconnectEthernetDevice_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockBackend_DisconnectEthernetDevice_Call) RunAndReturn(run func(string) error) *MockBackend_DisconnectEthernetDevice_Call { + _c.Call.Return(run) + return _c +} + +// DisconnectVPN provides a mock function with given fields: uuidOrName +func (_m *MockBackend) DisconnectVPN(uuidOrName string) error { + ret := _m.Called(uuidOrName) + + if len(ret) == 0 { + panic("no return value specified for DisconnectVPN") + } + + var r0 error + if rf, ok := ret.Get(0).(func(string) error); ok { + r0 = rf(uuidOrName) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockBackend_DisconnectVPN_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisconnectVPN' +type MockBackend_DisconnectVPN_Call struct { + *mock.Call +} + +// DisconnectVPN is a helper method to define mock.On call +// - uuidOrName string +func (_e *MockBackend_Expecter) DisconnectVPN(uuidOrName interface{}) *MockBackend_DisconnectVPN_Call { + return &MockBackend_DisconnectVPN_Call{Call: _e.mock.On("DisconnectVPN", uuidOrName)} +} + +func (_c *MockBackend_DisconnectVPN_Call) Run(run func(uuidOrName string)) *MockBackend_DisconnectVPN_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *MockBackend_DisconnectVPN_Call) Return(_a0 error) *MockBackend_DisconnectVPN_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockBackend_DisconnectVPN_Call) RunAndReturn(run func(string) error) *MockBackend_DisconnectVPN_Call { + _c.Call.Return(run) + return _c +} + +// DisconnectWiFi provides a mock function with no fields +func (_m *MockBackend) DisconnectWiFi() error { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for DisconnectWiFi") + } + + var r0 error + if rf, ok := ret.Get(0).(func() error); ok { + r0 = rf() + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockBackend_DisconnectWiFi_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisconnectWiFi' +type MockBackend_DisconnectWiFi_Call struct { + *mock.Call +} + +// DisconnectWiFi is a helper method to define mock.On call +func (_e *MockBackend_Expecter) DisconnectWiFi() *MockBackend_DisconnectWiFi_Call { + return &MockBackend_DisconnectWiFi_Call{Call: _e.mock.On("DisconnectWiFi")} +} + +func (_c *MockBackend_DisconnectWiFi_Call) Run(run func()) *MockBackend_DisconnectWiFi_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockBackend_DisconnectWiFi_Call) Return(_a0 error) *MockBackend_DisconnectWiFi_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockBackend_DisconnectWiFi_Call) RunAndReturn(run func() error) *MockBackend_DisconnectWiFi_Call { + _c.Call.Return(run) + return _c +} + +// DisconnectWiFiDevice provides a mock function with given fields: device +func (_m *MockBackend) DisconnectWiFiDevice(device string) error { + ret := _m.Called(device) + + if len(ret) == 0 { + panic("no return value specified for DisconnectWiFiDevice") + } + + var r0 error + if rf, ok := ret.Get(0).(func(string) error); ok { + r0 = rf(device) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockBackend_DisconnectWiFiDevice_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisconnectWiFiDevice' +type MockBackend_DisconnectWiFiDevice_Call struct { + *mock.Call +} + +// DisconnectWiFiDevice is a helper method to define mock.On call +// - device string +func (_e *MockBackend_Expecter) DisconnectWiFiDevice(device interface{}) *MockBackend_DisconnectWiFiDevice_Call { + return &MockBackend_DisconnectWiFiDevice_Call{Call: _e.mock.On("DisconnectWiFiDevice", device)} +} + +func (_c *MockBackend_DisconnectWiFiDevice_Call) Run(run func(device string)) *MockBackend_DisconnectWiFiDevice_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *MockBackend_DisconnectWiFiDevice_Call) Return(_a0 error) *MockBackend_DisconnectWiFiDevice_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockBackend_DisconnectWiFiDevice_Call) RunAndReturn(run func(string) error) *MockBackend_DisconnectWiFiDevice_Call { + _c.Call.Return(run) + return _c +} + +// ForgetWiFiNetwork provides a mock function with given fields: ssid +func (_m *MockBackend) ForgetWiFiNetwork(ssid string) error { + ret := _m.Called(ssid) + + if len(ret) == 0 { + panic("no return value specified for ForgetWiFiNetwork") + } + + var r0 error + if rf, ok := ret.Get(0).(func(string) error); ok { + r0 = rf(ssid) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockBackend_ForgetWiFiNetwork_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ForgetWiFiNetwork' +type MockBackend_ForgetWiFiNetwork_Call struct { + *mock.Call +} + +// ForgetWiFiNetwork is a helper method to define mock.On call +// - ssid string +func (_e *MockBackend_Expecter) ForgetWiFiNetwork(ssid interface{}) *MockBackend_ForgetWiFiNetwork_Call { + return &MockBackend_ForgetWiFiNetwork_Call{Call: _e.mock.On("ForgetWiFiNetwork", ssid)} +} + +func (_c *MockBackend_ForgetWiFiNetwork_Call) Run(run func(ssid string)) *MockBackend_ForgetWiFiNetwork_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *MockBackend_ForgetWiFiNetwork_Call) Return(_a0 error) *MockBackend_ForgetWiFiNetwork_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockBackend_ForgetWiFiNetwork_Call) RunAndReturn(run func(string) error) *MockBackend_ForgetWiFiNetwork_Call { + _c.Call.Return(run) + return _c +} + +// GetCurrentState provides a mock function with no fields +func (_m *MockBackend) GetCurrentState() (*network.BackendState, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetCurrentState") + } + + var r0 *network.BackendState + var r1 error + if rf, ok := ret.Get(0).(func() (*network.BackendState, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() *network.BackendState); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*network.BackendState) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockBackend_GetCurrentState_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetCurrentState' +type MockBackend_GetCurrentState_Call struct { + *mock.Call +} + +// GetCurrentState is a helper method to define mock.On call +func (_e *MockBackend_Expecter) GetCurrentState() *MockBackend_GetCurrentState_Call { + return &MockBackend_GetCurrentState_Call{Call: _e.mock.On("GetCurrentState")} +} + +func (_c *MockBackend_GetCurrentState_Call) Run(run func()) *MockBackend_GetCurrentState_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockBackend_GetCurrentState_Call) Return(_a0 *network.BackendState, _a1 error) *MockBackend_GetCurrentState_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockBackend_GetCurrentState_Call) RunAndReturn(run func() (*network.BackendState, error)) *MockBackend_GetCurrentState_Call { + _c.Call.Return(run) + return _c +} + +// GetEthernetDevices provides a mock function with no fields +func (_m *MockBackend) GetEthernetDevices() []network.EthernetDevice { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetEthernetDevices") + } + + var r0 []network.EthernetDevice + if rf, ok := ret.Get(0).(func() []network.EthernetDevice); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]network.EthernetDevice) + } + } + + return r0 +} + +// MockBackend_GetEthernetDevices_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetEthernetDevices' +type MockBackend_GetEthernetDevices_Call struct { + *mock.Call +} + +// GetEthernetDevices is a helper method to define mock.On call +func (_e *MockBackend_Expecter) GetEthernetDevices() *MockBackend_GetEthernetDevices_Call { + return &MockBackend_GetEthernetDevices_Call{Call: _e.mock.On("GetEthernetDevices")} +} + +func (_c *MockBackend_GetEthernetDevices_Call) Run(run func()) *MockBackend_GetEthernetDevices_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockBackend_GetEthernetDevices_Call) Return(_a0 []network.EthernetDevice) *MockBackend_GetEthernetDevices_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockBackend_GetEthernetDevices_Call) RunAndReturn(run func() []network.EthernetDevice) *MockBackend_GetEthernetDevices_Call { + _c.Call.Return(run) + return _c +} + +// GetPromptBroker provides a mock function with no fields +func (_m *MockBackend) GetPromptBroker() network.PromptBroker { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPromptBroker") + } + + var r0 network.PromptBroker + if rf, ok := ret.Get(0).(func() network.PromptBroker); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(network.PromptBroker) + } + } + + return r0 +} + +// MockBackend_GetPromptBroker_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPromptBroker' +type MockBackend_GetPromptBroker_Call struct { + *mock.Call +} + +// GetPromptBroker is a helper method to define mock.On call +func (_e *MockBackend_Expecter) GetPromptBroker() *MockBackend_GetPromptBroker_Call { + return &MockBackend_GetPromptBroker_Call{Call: _e.mock.On("GetPromptBroker")} +} + +func (_c *MockBackend_GetPromptBroker_Call) Run(run func()) *MockBackend_GetPromptBroker_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockBackend_GetPromptBroker_Call) Return(_a0 network.PromptBroker) *MockBackend_GetPromptBroker_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockBackend_GetPromptBroker_Call) RunAndReturn(run func() network.PromptBroker) *MockBackend_GetPromptBroker_Call { + _c.Call.Return(run) + return _c +} + +// GetVPNConfig provides a mock function with given fields: uuidOrName +func (_m *MockBackend) GetVPNConfig(uuidOrName string) (*network.VPNConfig, error) { + ret := _m.Called(uuidOrName) + + if len(ret) == 0 { + panic("no return value specified for GetVPNConfig") + } + + var r0 *network.VPNConfig + var r1 error + if rf, ok := ret.Get(0).(func(string) (*network.VPNConfig, error)); ok { + return rf(uuidOrName) + } + if rf, ok := ret.Get(0).(func(string) *network.VPNConfig); ok { + r0 = rf(uuidOrName) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*network.VPNConfig) + } + } + + if rf, ok := ret.Get(1).(func(string) error); ok { + r1 = rf(uuidOrName) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockBackend_GetVPNConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetVPNConfig' +type MockBackend_GetVPNConfig_Call struct { + *mock.Call +} + +// GetVPNConfig is a helper method to define mock.On call +// - uuidOrName string +func (_e *MockBackend_Expecter) GetVPNConfig(uuidOrName interface{}) *MockBackend_GetVPNConfig_Call { + return &MockBackend_GetVPNConfig_Call{Call: _e.mock.On("GetVPNConfig", uuidOrName)} +} + +func (_c *MockBackend_GetVPNConfig_Call) Run(run func(uuidOrName string)) *MockBackend_GetVPNConfig_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *MockBackend_GetVPNConfig_Call) Return(_a0 *network.VPNConfig, _a1 error) *MockBackend_GetVPNConfig_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockBackend_GetVPNConfig_Call) RunAndReturn(run func(string) (*network.VPNConfig, error)) *MockBackend_GetVPNConfig_Call { + _c.Call.Return(run) + return _c +} + +// GetWiFiDevices provides a mock function with no fields +func (_m *MockBackend) GetWiFiDevices() []network.WiFiDevice { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetWiFiDevices") + } + + var r0 []network.WiFiDevice + if rf, ok := ret.Get(0).(func() []network.WiFiDevice); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]network.WiFiDevice) + } + } + + return r0 +} + +// MockBackend_GetWiFiDevices_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetWiFiDevices' +type MockBackend_GetWiFiDevices_Call struct { + *mock.Call +} + +// GetWiFiDevices is a helper method to define mock.On call +func (_e *MockBackend_Expecter) GetWiFiDevices() *MockBackend_GetWiFiDevices_Call { + return &MockBackend_GetWiFiDevices_Call{Call: _e.mock.On("GetWiFiDevices")} +} + +func (_c *MockBackend_GetWiFiDevices_Call) Run(run func()) *MockBackend_GetWiFiDevices_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockBackend_GetWiFiDevices_Call) Return(_a0 []network.WiFiDevice) *MockBackend_GetWiFiDevices_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockBackend_GetWiFiDevices_Call) RunAndReturn(run func() []network.WiFiDevice) *MockBackend_GetWiFiDevices_Call { + _c.Call.Return(run) + return _c +} + +// GetWiFiEnabled provides a mock function with no fields +func (_m *MockBackend) GetWiFiEnabled() (bool, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetWiFiEnabled") + } + + var r0 bool + var r1 error + if rf, ok := ret.Get(0).(func() (bool, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() bool); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(bool) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockBackend_GetWiFiEnabled_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetWiFiEnabled' +type MockBackend_GetWiFiEnabled_Call struct { + *mock.Call +} + +// GetWiFiEnabled is a helper method to define mock.On call +func (_e *MockBackend_Expecter) GetWiFiEnabled() *MockBackend_GetWiFiEnabled_Call { + return &MockBackend_GetWiFiEnabled_Call{Call: _e.mock.On("GetWiFiEnabled")} +} + +func (_c *MockBackend_GetWiFiEnabled_Call) Run(run func()) *MockBackend_GetWiFiEnabled_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockBackend_GetWiFiEnabled_Call) Return(_a0 bool, _a1 error) *MockBackend_GetWiFiEnabled_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockBackend_GetWiFiEnabled_Call) RunAndReturn(run func() (bool, error)) *MockBackend_GetWiFiEnabled_Call { + _c.Call.Return(run) + return _c +} + +// GetWiFiNetworkDetails provides a mock function with given fields: ssid +func (_m *MockBackend) GetWiFiNetworkDetails(ssid string) (*network.NetworkInfoResponse, error) { + ret := _m.Called(ssid) + + if len(ret) == 0 { + panic("no return value specified for GetWiFiNetworkDetails") + } + + var r0 *network.NetworkInfoResponse + var r1 error + if rf, ok := ret.Get(0).(func(string) (*network.NetworkInfoResponse, error)); ok { + return rf(ssid) + } + if rf, ok := ret.Get(0).(func(string) *network.NetworkInfoResponse); ok { + r0 = rf(ssid) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*network.NetworkInfoResponse) + } + } + + if rf, ok := ret.Get(1).(func(string) error); ok { + r1 = rf(ssid) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockBackend_GetWiFiNetworkDetails_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetWiFiNetworkDetails' +type MockBackend_GetWiFiNetworkDetails_Call struct { + *mock.Call +} + +// GetWiFiNetworkDetails is a helper method to define mock.On call +// - ssid string +func (_e *MockBackend_Expecter) GetWiFiNetworkDetails(ssid interface{}) *MockBackend_GetWiFiNetworkDetails_Call { + return &MockBackend_GetWiFiNetworkDetails_Call{Call: _e.mock.On("GetWiFiNetworkDetails", ssid)} +} + +func (_c *MockBackend_GetWiFiNetworkDetails_Call) Run(run func(ssid string)) *MockBackend_GetWiFiNetworkDetails_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *MockBackend_GetWiFiNetworkDetails_Call) Return(_a0 *network.NetworkInfoResponse, _a1 error) *MockBackend_GetWiFiNetworkDetails_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockBackend_GetWiFiNetworkDetails_Call) RunAndReturn(run func(string) (*network.NetworkInfoResponse, error)) *MockBackend_GetWiFiNetworkDetails_Call { + _c.Call.Return(run) + return _c +} + +// GetWiFiQRCodeContent provides a mock function with given fields: ssid +func (_m *MockBackend) GetWiFiQRCodeContent(ssid string) (string, error) { + ret := _m.Called(ssid) + + if len(ret) == 0 { + panic("no return value specified for GetWiFiQRCodeContent") + } + + var r0 string + var r1 error + if rf, ok := ret.Get(0).(func(string) (string, error)); ok { + return rf(ssid) + } + if rf, ok := ret.Get(0).(func(string) string); ok { + r0 = rf(ssid) + } else { + r0 = ret.Get(0).(string) + } + + if rf, ok := ret.Get(1).(func(string) error); ok { + r1 = rf(ssid) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockBackend_GetWiFiQRCodeContent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetWiFiQRCodeContent' +type MockBackend_GetWiFiQRCodeContent_Call struct { + *mock.Call +} + +// GetWiFiQRCodeContent is a helper method to define mock.On call +// - ssid string +func (_e *MockBackend_Expecter) GetWiFiQRCodeContent(ssid interface{}) *MockBackend_GetWiFiQRCodeContent_Call { + return &MockBackend_GetWiFiQRCodeContent_Call{Call: _e.mock.On("GetWiFiQRCodeContent", ssid)} +} + +func (_c *MockBackend_GetWiFiQRCodeContent_Call) Run(run func(ssid string)) *MockBackend_GetWiFiQRCodeContent_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *MockBackend_GetWiFiQRCodeContent_Call) Return(_a0 string, _a1 error) *MockBackend_GetWiFiQRCodeContent_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockBackend_GetWiFiQRCodeContent_Call) RunAndReturn(run func(string) (string, error)) *MockBackend_GetWiFiQRCodeContent_Call { + _c.Call.Return(run) + return _c +} + +// GetWiredConnections provides a mock function with no fields +func (_m *MockBackend) GetWiredConnections() ([]network.WiredConnection, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetWiredConnections") + } + + var r0 []network.WiredConnection + var r1 error + if rf, ok := ret.Get(0).(func() ([]network.WiredConnection, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() []network.WiredConnection); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]network.WiredConnection) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockBackend_GetWiredConnections_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetWiredConnections' +type MockBackend_GetWiredConnections_Call struct { + *mock.Call +} + +// GetWiredConnections is a helper method to define mock.On call +func (_e *MockBackend_Expecter) GetWiredConnections() *MockBackend_GetWiredConnections_Call { + return &MockBackend_GetWiredConnections_Call{Call: _e.mock.On("GetWiredConnections")} +} + +func (_c *MockBackend_GetWiredConnections_Call) Run(run func()) *MockBackend_GetWiredConnections_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockBackend_GetWiredConnections_Call) Return(_a0 []network.WiredConnection, _a1 error) *MockBackend_GetWiredConnections_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockBackend_GetWiredConnections_Call) RunAndReturn(run func() ([]network.WiredConnection, error)) *MockBackend_GetWiredConnections_Call { + _c.Call.Return(run) + return _c +} + +// GetWiredNetworkDetails provides a mock function with given fields: uuid +func (_m *MockBackend) GetWiredNetworkDetails(uuid string) (*network.WiredNetworkInfoResponse, error) { + ret := _m.Called(uuid) + + if len(ret) == 0 { + panic("no return value specified for GetWiredNetworkDetails") + } + + var r0 *network.WiredNetworkInfoResponse + var r1 error + if rf, ok := ret.Get(0).(func(string) (*network.WiredNetworkInfoResponse, error)); ok { + return rf(uuid) + } + if rf, ok := ret.Get(0).(func(string) *network.WiredNetworkInfoResponse); ok { + r0 = rf(uuid) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*network.WiredNetworkInfoResponse) + } + } + + if rf, ok := ret.Get(1).(func(string) error); ok { + r1 = rf(uuid) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockBackend_GetWiredNetworkDetails_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetWiredNetworkDetails' +type MockBackend_GetWiredNetworkDetails_Call struct { + *mock.Call +} + +// GetWiredNetworkDetails is a helper method to define mock.On call +// - uuid string +func (_e *MockBackend_Expecter) GetWiredNetworkDetails(uuid interface{}) *MockBackend_GetWiredNetworkDetails_Call { + return &MockBackend_GetWiredNetworkDetails_Call{Call: _e.mock.On("GetWiredNetworkDetails", uuid)} +} + +func (_c *MockBackend_GetWiredNetworkDetails_Call) Run(run func(uuid string)) *MockBackend_GetWiredNetworkDetails_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *MockBackend_GetWiredNetworkDetails_Call) Return(_a0 *network.WiredNetworkInfoResponse, _a1 error) *MockBackend_GetWiredNetworkDetails_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockBackend_GetWiredNetworkDetails_Call) RunAndReturn(run func(string) (*network.WiredNetworkInfoResponse, error)) *MockBackend_GetWiredNetworkDetails_Call { + _c.Call.Return(run) + return _c +} + +// ImportVPN provides a mock function with given fields: filePath, name +func (_m *MockBackend) ImportVPN(filePath string, name string) (*network.VPNImportResult, error) { + ret := _m.Called(filePath, name) + + if len(ret) == 0 { + panic("no return value specified for ImportVPN") + } + + var r0 *network.VPNImportResult + var r1 error + if rf, ok := ret.Get(0).(func(string, string) (*network.VPNImportResult, error)); ok { + return rf(filePath, name) + } + if rf, ok := ret.Get(0).(func(string, string) *network.VPNImportResult); ok { + r0 = rf(filePath, name) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*network.VPNImportResult) + } + } + + if rf, ok := ret.Get(1).(func(string, string) error); ok { + r1 = rf(filePath, name) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockBackend_ImportVPN_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ImportVPN' +type MockBackend_ImportVPN_Call struct { + *mock.Call +} + +// ImportVPN is a helper method to define mock.On call +// - filePath string +// - name string +func (_e *MockBackend_Expecter) ImportVPN(filePath interface{}, name interface{}) *MockBackend_ImportVPN_Call { + return &MockBackend_ImportVPN_Call{Call: _e.mock.On("ImportVPN", filePath, name)} +} + +func (_c *MockBackend_ImportVPN_Call) Run(run func(filePath string, name string)) *MockBackend_ImportVPN_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string)) + }) + return _c +} + +func (_c *MockBackend_ImportVPN_Call) Return(_a0 *network.VPNImportResult, _a1 error) *MockBackend_ImportVPN_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockBackend_ImportVPN_Call) RunAndReturn(run func(string, string) (*network.VPNImportResult, error)) *MockBackend_ImportVPN_Call { + _c.Call.Return(run) + return _c +} + +// Initialize provides a mock function with no fields +func (_m *MockBackend) Initialize() error { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Initialize") + } + + var r0 error + if rf, ok := ret.Get(0).(func() error); ok { + r0 = rf() + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockBackend_Initialize_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Initialize' +type MockBackend_Initialize_Call struct { + *mock.Call +} + +// Initialize is a helper method to define mock.On call +func (_e *MockBackend_Expecter) Initialize() *MockBackend_Initialize_Call { + return &MockBackend_Initialize_Call{Call: _e.mock.On("Initialize")} +} + +func (_c *MockBackend_Initialize_Call) Run(run func()) *MockBackend_Initialize_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockBackend_Initialize_Call) Return(_a0 error) *MockBackend_Initialize_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockBackend_Initialize_Call) RunAndReturn(run func() error) *MockBackend_Initialize_Call { + _c.Call.Return(run) + return _c +} + +// ListActiveVPN provides a mock function with no fields +func (_m *MockBackend) ListActiveVPN() ([]network.VPNActive, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for ListActiveVPN") + } + + var r0 []network.VPNActive + var r1 error + if rf, ok := ret.Get(0).(func() ([]network.VPNActive, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() []network.VPNActive); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]network.VPNActive) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockBackend_ListActiveVPN_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListActiveVPN' +type MockBackend_ListActiveVPN_Call struct { + *mock.Call +} + +// ListActiveVPN is a helper method to define mock.On call +func (_e *MockBackend_Expecter) ListActiveVPN() *MockBackend_ListActiveVPN_Call { + return &MockBackend_ListActiveVPN_Call{Call: _e.mock.On("ListActiveVPN")} +} + +func (_c *MockBackend_ListActiveVPN_Call) Run(run func()) *MockBackend_ListActiveVPN_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockBackend_ListActiveVPN_Call) Return(_a0 []network.VPNActive, _a1 error) *MockBackend_ListActiveVPN_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockBackend_ListActiveVPN_Call) RunAndReturn(run func() ([]network.VPNActive, error)) *MockBackend_ListActiveVPN_Call { + _c.Call.Return(run) + return _c +} + +// ListVPNPlugins provides a mock function with no fields +func (_m *MockBackend) ListVPNPlugins() ([]network.VPNPlugin, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for ListVPNPlugins") + } + + var r0 []network.VPNPlugin + var r1 error + if rf, ok := ret.Get(0).(func() ([]network.VPNPlugin, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() []network.VPNPlugin); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]network.VPNPlugin) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockBackend_ListVPNPlugins_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListVPNPlugins' +type MockBackend_ListVPNPlugins_Call struct { + *mock.Call +} + +// ListVPNPlugins is a helper method to define mock.On call +func (_e *MockBackend_Expecter) ListVPNPlugins() *MockBackend_ListVPNPlugins_Call { + return &MockBackend_ListVPNPlugins_Call{Call: _e.mock.On("ListVPNPlugins")} +} + +func (_c *MockBackend_ListVPNPlugins_Call) Run(run func()) *MockBackend_ListVPNPlugins_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockBackend_ListVPNPlugins_Call) Return(_a0 []network.VPNPlugin, _a1 error) *MockBackend_ListVPNPlugins_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockBackend_ListVPNPlugins_Call) RunAndReturn(run func() ([]network.VPNPlugin, error)) *MockBackend_ListVPNPlugins_Call { + _c.Call.Return(run) + return _c +} + +// ListVPNProfiles provides a mock function with no fields +func (_m *MockBackend) ListVPNProfiles() ([]network.VPNProfile, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for ListVPNProfiles") + } + + var r0 []network.VPNProfile + var r1 error + if rf, ok := ret.Get(0).(func() ([]network.VPNProfile, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() []network.VPNProfile); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]network.VPNProfile) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockBackend_ListVPNProfiles_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListVPNProfiles' +type MockBackend_ListVPNProfiles_Call struct { + *mock.Call +} + +// ListVPNProfiles is a helper method to define mock.On call +func (_e *MockBackend_Expecter) ListVPNProfiles() *MockBackend_ListVPNProfiles_Call { + return &MockBackend_ListVPNProfiles_Call{Call: _e.mock.On("ListVPNProfiles")} +} + +func (_c *MockBackend_ListVPNProfiles_Call) Run(run func()) *MockBackend_ListVPNProfiles_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockBackend_ListVPNProfiles_Call) Return(_a0 []network.VPNProfile, _a1 error) *MockBackend_ListVPNProfiles_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockBackend_ListVPNProfiles_Call) RunAndReturn(run func() ([]network.VPNProfile, error)) *MockBackend_ListVPNProfiles_Call { + _c.Call.Return(run) + return _c +} + +// ScanWiFi provides a mock function with no fields +func (_m *MockBackend) ScanWiFi() error { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for ScanWiFi") + } + + var r0 error + if rf, ok := ret.Get(0).(func() error); ok { + r0 = rf() + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockBackend_ScanWiFi_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ScanWiFi' +type MockBackend_ScanWiFi_Call struct { + *mock.Call +} + +// ScanWiFi is a helper method to define mock.On call +func (_e *MockBackend_Expecter) ScanWiFi() *MockBackend_ScanWiFi_Call { + return &MockBackend_ScanWiFi_Call{Call: _e.mock.On("ScanWiFi")} +} + +func (_c *MockBackend_ScanWiFi_Call) Run(run func()) *MockBackend_ScanWiFi_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockBackend_ScanWiFi_Call) Return(_a0 error) *MockBackend_ScanWiFi_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockBackend_ScanWiFi_Call) RunAndReturn(run func() error) *MockBackend_ScanWiFi_Call { + _c.Call.Return(run) + return _c +} + +// ScanWiFiDevice provides a mock function with given fields: device +func (_m *MockBackend) ScanWiFiDevice(device string) error { + ret := _m.Called(device) + + if len(ret) == 0 { + panic("no return value specified for ScanWiFiDevice") + } + + var r0 error + if rf, ok := ret.Get(0).(func(string) error); ok { + r0 = rf(device) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockBackend_ScanWiFiDevice_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ScanWiFiDevice' +type MockBackend_ScanWiFiDevice_Call struct { + *mock.Call +} + +// ScanWiFiDevice is a helper method to define mock.On call +// - device string +func (_e *MockBackend_Expecter) ScanWiFiDevice(device interface{}) *MockBackend_ScanWiFiDevice_Call { + return &MockBackend_ScanWiFiDevice_Call{Call: _e.mock.On("ScanWiFiDevice", device)} +} + +func (_c *MockBackend_ScanWiFiDevice_Call) Run(run func(device string)) *MockBackend_ScanWiFiDevice_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *MockBackend_ScanWiFiDevice_Call) Return(_a0 error) *MockBackend_ScanWiFiDevice_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockBackend_ScanWiFiDevice_Call) RunAndReturn(run func(string) error) *MockBackend_ScanWiFiDevice_Call { + _c.Call.Return(run) + return _c +} + +// SetPromptBroker provides a mock function with given fields: broker +func (_m *MockBackend) SetPromptBroker(broker network.PromptBroker) error { + ret := _m.Called(broker) + + if len(ret) == 0 { + panic("no return value specified for SetPromptBroker") + } + + var r0 error + if rf, ok := ret.Get(0).(func(network.PromptBroker) error); ok { + r0 = rf(broker) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockBackend_SetPromptBroker_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetPromptBroker' +type MockBackend_SetPromptBroker_Call struct { + *mock.Call +} + +// SetPromptBroker is a helper method to define mock.On call +// - broker network.PromptBroker +func (_e *MockBackend_Expecter) SetPromptBroker(broker interface{}) *MockBackend_SetPromptBroker_Call { + return &MockBackend_SetPromptBroker_Call{Call: _e.mock.On("SetPromptBroker", broker)} +} + +func (_c *MockBackend_SetPromptBroker_Call) Run(run func(broker network.PromptBroker)) *MockBackend_SetPromptBroker_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(network.PromptBroker)) + }) + return _c +} + +func (_c *MockBackend_SetPromptBroker_Call) Return(_a0 error) *MockBackend_SetPromptBroker_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockBackend_SetPromptBroker_Call) RunAndReturn(run func(network.PromptBroker) error) *MockBackend_SetPromptBroker_Call { + _c.Call.Return(run) + return _c +} + +// SetVPNCredentials provides a mock function with given fields: uuid, username, password, save +func (_m *MockBackend) SetVPNCredentials(uuid string, username string, password string, save bool) error { + ret := _m.Called(uuid, username, password, save) + + if len(ret) == 0 { + panic("no return value specified for SetVPNCredentials") + } + + var r0 error + if rf, ok := ret.Get(0).(func(string, string, string, bool) error); ok { + r0 = rf(uuid, username, password, save) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockBackend_SetVPNCredentials_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetVPNCredentials' +type MockBackend_SetVPNCredentials_Call struct { + *mock.Call +} + +// SetVPNCredentials is a helper method to define mock.On call +// - uuid string +// - username string +// - password string +// - save bool +func (_e *MockBackend_Expecter) SetVPNCredentials(uuid interface{}, username interface{}, password interface{}, save interface{}) *MockBackend_SetVPNCredentials_Call { + return &MockBackend_SetVPNCredentials_Call{Call: _e.mock.On("SetVPNCredentials", uuid, username, password, save)} +} + +func (_c *MockBackend_SetVPNCredentials_Call) Run(run func(uuid string, username string, password string, save bool)) *MockBackend_SetVPNCredentials_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string), args[3].(bool)) + }) + return _c +} + +func (_c *MockBackend_SetVPNCredentials_Call) Return(_a0 error) *MockBackend_SetVPNCredentials_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockBackend_SetVPNCredentials_Call) RunAndReturn(run func(string, string, string, bool) error) *MockBackend_SetVPNCredentials_Call { + _c.Call.Return(run) + return _c +} + +// SetWiFiAutoconnect provides a mock function with given fields: ssid, autoconnect +func (_m *MockBackend) SetWiFiAutoconnect(ssid string, autoconnect bool) error { + ret := _m.Called(ssid, autoconnect) + + if len(ret) == 0 { + panic("no return value specified for SetWiFiAutoconnect") + } + + var r0 error + if rf, ok := ret.Get(0).(func(string, bool) error); ok { + r0 = rf(ssid, autoconnect) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockBackend_SetWiFiAutoconnect_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetWiFiAutoconnect' +type MockBackend_SetWiFiAutoconnect_Call struct { + *mock.Call +} + +// SetWiFiAutoconnect is a helper method to define mock.On call +// - ssid string +// - autoconnect bool +func (_e *MockBackend_Expecter) SetWiFiAutoconnect(ssid interface{}, autoconnect interface{}) *MockBackend_SetWiFiAutoconnect_Call { + return &MockBackend_SetWiFiAutoconnect_Call{Call: _e.mock.On("SetWiFiAutoconnect", ssid, autoconnect)} +} + +func (_c *MockBackend_SetWiFiAutoconnect_Call) Run(run func(ssid string, autoconnect bool)) *MockBackend_SetWiFiAutoconnect_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(bool)) + }) + return _c +} + +func (_c *MockBackend_SetWiFiAutoconnect_Call) Return(_a0 error) *MockBackend_SetWiFiAutoconnect_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockBackend_SetWiFiAutoconnect_Call) RunAndReturn(run func(string, bool) error) *MockBackend_SetWiFiAutoconnect_Call { + _c.Call.Return(run) + return _c +} + +// SetWiFiEnabled provides a mock function with given fields: enabled +func (_m *MockBackend) SetWiFiEnabled(enabled bool) error { + ret := _m.Called(enabled) + + if len(ret) == 0 { + panic("no return value specified for SetWiFiEnabled") + } + + var r0 error + if rf, ok := ret.Get(0).(func(bool) error); ok { + r0 = rf(enabled) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockBackend_SetWiFiEnabled_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetWiFiEnabled' +type MockBackend_SetWiFiEnabled_Call struct { + *mock.Call +} + +// SetWiFiEnabled is a helper method to define mock.On call +// - enabled bool +func (_e *MockBackend_Expecter) SetWiFiEnabled(enabled interface{}) *MockBackend_SetWiFiEnabled_Call { + return &MockBackend_SetWiFiEnabled_Call{Call: _e.mock.On("SetWiFiEnabled", enabled)} +} + +func (_c *MockBackend_SetWiFiEnabled_Call) Run(run func(enabled bool)) *MockBackend_SetWiFiEnabled_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(bool)) + }) + return _c +} + +func (_c *MockBackend_SetWiFiEnabled_Call) Return(_a0 error) *MockBackend_SetWiFiEnabled_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockBackend_SetWiFiEnabled_Call) RunAndReturn(run func(bool) error) *MockBackend_SetWiFiEnabled_Call { + _c.Call.Return(run) + return _c +} + +// StartMonitoring provides a mock function with given fields: onStateChange +func (_m *MockBackend) StartMonitoring(onStateChange func()) error { + ret := _m.Called(onStateChange) + + if len(ret) == 0 { + panic("no return value specified for StartMonitoring") + } + + var r0 error + if rf, ok := ret.Get(0).(func(func()) error); ok { + r0 = rf(onStateChange) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockBackend_StartMonitoring_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StartMonitoring' +type MockBackend_StartMonitoring_Call struct { + *mock.Call +} + +// StartMonitoring is a helper method to define mock.On call +// - onStateChange func() +func (_e *MockBackend_Expecter) StartMonitoring(onStateChange interface{}) *MockBackend_StartMonitoring_Call { + return &MockBackend_StartMonitoring_Call{Call: _e.mock.On("StartMonitoring", onStateChange)} +} + +func (_c *MockBackend_StartMonitoring_Call) Run(run func(onStateChange func())) *MockBackend_StartMonitoring_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func())) + }) + return _c +} + +func (_c *MockBackend_StartMonitoring_Call) Return(_a0 error) *MockBackend_StartMonitoring_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockBackend_StartMonitoring_Call) RunAndReturn(run func(func()) error) *MockBackend_StartMonitoring_Call { + _c.Call.Return(run) + return _c +} + +// StopMonitoring provides a mock function with no fields +func (_m *MockBackend) StopMonitoring() { + _m.Called() +} + +// MockBackend_StopMonitoring_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StopMonitoring' +type MockBackend_StopMonitoring_Call struct { + *mock.Call +} + +// StopMonitoring is a helper method to define mock.On call +func (_e *MockBackend_Expecter) StopMonitoring() *MockBackend_StopMonitoring_Call { + return &MockBackend_StopMonitoring_Call{Call: _e.mock.On("StopMonitoring")} +} + +func (_c *MockBackend_StopMonitoring_Call) Run(run func()) *MockBackend_StopMonitoring_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockBackend_StopMonitoring_Call) Return() *MockBackend_StopMonitoring_Call { + _c.Call.Return() + return _c +} + +func (_c *MockBackend_StopMonitoring_Call) RunAndReturn(run func()) *MockBackend_StopMonitoring_Call { + _c.Run(run) + return _c +} + +// SubmitCredentials provides a mock function with given fields: token, secrets, save +func (_m *MockBackend) SubmitCredentials(token string, secrets map[string]string, save bool) error { + ret := _m.Called(token, secrets, save) + + if len(ret) == 0 { + panic("no return value specified for SubmitCredentials") + } + + var r0 error + if rf, ok := ret.Get(0).(func(string, map[string]string, bool) error); ok { + r0 = rf(token, secrets, save) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockBackend_SubmitCredentials_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SubmitCredentials' +type MockBackend_SubmitCredentials_Call struct { + *mock.Call +} + +// SubmitCredentials is a helper method to define mock.On call +// - token string +// - secrets map[string]string +// - save bool +func (_e *MockBackend_Expecter) SubmitCredentials(token interface{}, secrets interface{}, save interface{}) *MockBackend_SubmitCredentials_Call { + return &MockBackend_SubmitCredentials_Call{Call: _e.mock.On("SubmitCredentials", token, secrets, save)} +} + +func (_c *MockBackend_SubmitCredentials_Call) Run(run func(token string, secrets map[string]string, save bool)) *MockBackend_SubmitCredentials_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(map[string]string), args[2].(bool)) + }) + return _c +} + +func (_c *MockBackend_SubmitCredentials_Call) Return(_a0 error) *MockBackend_SubmitCredentials_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockBackend_SubmitCredentials_Call) RunAndReturn(run func(string, map[string]string, bool) error) *MockBackend_SubmitCredentials_Call { + _c.Call.Return(run) + return _c +} + +// UpdateVPNConfig provides a mock function with given fields: uuid, updates +func (_m *MockBackend) UpdateVPNConfig(uuid string, updates map[string]interface{}) error { + ret := _m.Called(uuid, updates) + + if len(ret) == 0 { + panic("no return value specified for UpdateVPNConfig") + } + + var r0 error + if rf, ok := ret.Get(0).(func(string, map[string]interface{}) error); ok { + r0 = rf(uuid, updates) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockBackend_UpdateVPNConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateVPNConfig' +type MockBackend_UpdateVPNConfig_Call struct { + *mock.Call +} + +// UpdateVPNConfig is a helper method to define mock.On call +// - uuid string +// - updates map[string]interface{} +func (_e *MockBackend_Expecter) UpdateVPNConfig(uuid interface{}, updates interface{}) *MockBackend_UpdateVPNConfig_Call { + return &MockBackend_UpdateVPNConfig_Call{Call: _e.mock.On("UpdateVPNConfig", uuid, updates)} +} + +func (_c *MockBackend_UpdateVPNConfig_Call) Run(run func(uuid string, updates map[string]interface{})) *MockBackend_UpdateVPNConfig_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(map[string]interface{})) + }) + return _c +} + +func (_c *MockBackend_UpdateVPNConfig_Call) Return(_a0 error) *MockBackend_UpdateVPNConfig_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockBackend_UpdateVPNConfig_Call) RunAndReturn(run func(string, map[string]interface{}) error) *MockBackend_UpdateVPNConfig_Call { + _c.Call.Return(run) + return _c +} + +// NewMockBackend creates a new instance of MockBackend. 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 NewMockBackend(t interface { + mock.TestingT + Cleanup(func()) +}) *MockBackend { + mock := &MockBackend{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/utils/mock_AppChecker.go b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/utils/mock_AppChecker.go new file mode 100644 index 0000000..be220c4 --- /dev/null +++ b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/utils/mock_AppChecker.go @@ -0,0 +1,242 @@ +// Code generated by mockery v2.53.5. DO NOT EDIT. + +package mocks_utils + +import mock "github.com/stretchr/testify/mock" + +// MockAppChecker is an autogenerated mock type for the AppChecker type +type MockAppChecker struct { + mock.Mock +} + +type MockAppChecker_Expecter struct { + mock *mock.Mock +} + +func (_m *MockAppChecker) EXPECT() *MockAppChecker_Expecter { + return &MockAppChecker_Expecter{mock: &_m.Mock} +} + +// AnyCommandExists provides a mock function with given fields: cmds +func (_m *MockAppChecker) AnyCommandExists(cmds ...string) bool { + _va := make([]interface{}, len(cmds)) + for _i := range cmds { + _va[_i] = cmds[_i] + } + var _ca []interface{} + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for AnyCommandExists") + } + + var r0 bool + if rf, ok := ret.Get(0).(func(...string) bool); ok { + r0 = rf(cmds...) + } else { + r0 = ret.Get(0).(bool) + } + + return r0 +} + +// MockAppChecker_AnyCommandExists_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AnyCommandExists' +type MockAppChecker_AnyCommandExists_Call struct { + *mock.Call +} + +// AnyCommandExists is a helper method to define mock.On call +// - cmds ...string +func (_e *MockAppChecker_Expecter) AnyCommandExists(cmds ...interface{}) *MockAppChecker_AnyCommandExists_Call { + return &MockAppChecker_AnyCommandExists_Call{Call: _e.mock.On("AnyCommandExists", + append([]interface{}{}, cmds...)...)} +} + +func (_c *MockAppChecker_AnyCommandExists_Call) Run(run func(cmds ...string)) *MockAppChecker_AnyCommandExists_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]string, len(args)-0) + for i, a := range args[0:] { + if a != nil { + variadicArgs[i] = a.(string) + } + } + run(variadicArgs...) + }) + return _c +} + +func (_c *MockAppChecker_AnyCommandExists_Call) Return(_a0 bool) *MockAppChecker_AnyCommandExists_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockAppChecker_AnyCommandExists_Call) RunAndReturn(run func(...string) bool) *MockAppChecker_AnyCommandExists_Call { + _c.Call.Return(run) + return _c +} + +// AnyFlatpakExists provides a mock function with given fields: flatpaks +func (_m *MockAppChecker) AnyFlatpakExists(flatpaks ...string) bool { + _va := make([]interface{}, len(flatpaks)) + for _i := range flatpaks { + _va[_i] = flatpaks[_i] + } + var _ca []interface{} + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for AnyFlatpakExists") + } + + var r0 bool + if rf, ok := ret.Get(0).(func(...string) bool); ok { + r0 = rf(flatpaks...) + } else { + r0 = ret.Get(0).(bool) + } + + return r0 +} + +// MockAppChecker_AnyFlatpakExists_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AnyFlatpakExists' +type MockAppChecker_AnyFlatpakExists_Call struct { + *mock.Call +} + +// AnyFlatpakExists is a helper method to define mock.On call +// - flatpaks ...string +func (_e *MockAppChecker_Expecter) AnyFlatpakExists(flatpaks ...interface{}) *MockAppChecker_AnyFlatpakExists_Call { + return &MockAppChecker_AnyFlatpakExists_Call{Call: _e.mock.On("AnyFlatpakExists", + append([]interface{}{}, flatpaks...)...)} +} + +func (_c *MockAppChecker_AnyFlatpakExists_Call) Run(run func(flatpaks ...string)) *MockAppChecker_AnyFlatpakExists_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]string, len(args)-0) + for i, a := range args[0:] { + if a != nil { + variadicArgs[i] = a.(string) + } + } + run(variadicArgs...) + }) + return _c +} + +func (_c *MockAppChecker_AnyFlatpakExists_Call) Return(_a0 bool) *MockAppChecker_AnyFlatpakExists_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockAppChecker_AnyFlatpakExists_Call) RunAndReturn(run func(...string) bool) *MockAppChecker_AnyFlatpakExists_Call { + _c.Call.Return(run) + return _c +} + +// CommandExists provides a mock function with given fields: cmd +func (_m *MockAppChecker) CommandExists(cmd string) bool { + ret := _m.Called(cmd) + + if len(ret) == 0 { + panic("no return value specified for CommandExists") + } + + var r0 bool + if rf, ok := ret.Get(0).(func(string) bool); ok { + r0 = rf(cmd) + } else { + r0 = ret.Get(0).(bool) + } + + return r0 +} + +// MockAppChecker_CommandExists_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CommandExists' +type MockAppChecker_CommandExists_Call struct { + *mock.Call +} + +// CommandExists is a helper method to define mock.On call +// - cmd string +func (_e *MockAppChecker_Expecter) CommandExists(cmd interface{}) *MockAppChecker_CommandExists_Call { + return &MockAppChecker_CommandExists_Call{Call: _e.mock.On("CommandExists", cmd)} +} + +func (_c *MockAppChecker_CommandExists_Call) Run(run func(cmd string)) *MockAppChecker_CommandExists_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *MockAppChecker_CommandExists_Call) Return(_a0 bool) *MockAppChecker_CommandExists_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockAppChecker_CommandExists_Call) RunAndReturn(run func(string) bool) *MockAppChecker_CommandExists_Call { + _c.Call.Return(run) + return _c +} + +// FlatpakExists provides a mock function with given fields: name +func (_m *MockAppChecker) FlatpakExists(name string) bool { + ret := _m.Called(name) + + if len(ret) == 0 { + panic("no return value specified for FlatpakExists") + } + + var r0 bool + if rf, ok := ret.Get(0).(func(string) bool); ok { + r0 = rf(name) + } else { + r0 = ret.Get(0).(bool) + } + + return r0 +} + +// MockAppChecker_FlatpakExists_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FlatpakExists' +type MockAppChecker_FlatpakExists_Call struct { + *mock.Call +} + +// FlatpakExists is a helper method to define mock.On call +// - name string +func (_e *MockAppChecker_Expecter) FlatpakExists(name interface{}) *MockAppChecker_FlatpakExists_Call { + return &MockAppChecker_FlatpakExists_Call{Call: _e.mock.On("FlatpakExists", name)} +} + +func (_c *MockAppChecker_FlatpakExists_Call) Run(run func(name string)) *MockAppChecker_FlatpakExists_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *MockAppChecker_FlatpakExists_Call) Return(_a0 bool) *MockAppChecker_FlatpakExists_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockAppChecker_FlatpakExists_Call) RunAndReturn(run func(string) bool) *MockAppChecker_FlatpakExists_Call { + _c.Call.Return(run) + return _c +} + +// NewMockAppChecker creates a new instance of MockAppChecker. 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 NewMockAppChecker(t interface { + mock.TestingT + Cleanup(func()) +}) *MockAppChecker { + mock := &MockAppChecker{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/version/mock_VersionFetcher.go b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/version/mock_VersionFetcher.go new file mode 100644 index 0000000..a6fa27c --- /dev/null +++ b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/version/mock_VersionFetcher.go @@ -0,0 +1,144 @@ +// Code generated by mockery v2.53.5. DO NOT EDIT. + +package mocks_version + +import mock "github.com/stretchr/testify/mock" + +// MockVersionFetcher is an autogenerated mock type for the VersionFetcher type +type MockVersionFetcher struct { + mock.Mock +} + +type MockVersionFetcher_Expecter struct { + mock *mock.Mock +} + +func (_m *MockVersionFetcher) EXPECT() *MockVersionFetcher_Expecter { + return &MockVersionFetcher_Expecter{mock: &_m.Mock} +} + +// GetCurrentVersion provides a mock function with given fields: dmsPath +func (_m *MockVersionFetcher) GetCurrentVersion(dmsPath string) (string, error) { + ret := _m.Called(dmsPath) + + if len(ret) == 0 { + panic("no return value specified for GetCurrentVersion") + } + + var r0 string + var r1 error + if rf, ok := ret.Get(0).(func(string) (string, error)); ok { + return rf(dmsPath) + } + if rf, ok := ret.Get(0).(func(string) string); ok { + r0 = rf(dmsPath) + } else { + r0 = ret.Get(0).(string) + } + + if rf, ok := ret.Get(1).(func(string) error); ok { + r1 = rf(dmsPath) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockVersionFetcher_GetCurrentVersion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetCurrentVersion' +type MockVersionFetcher_GetCurrentVersion_Call struct { + *mock.Call +} + +// GetCurrentVersion is a helper method to define mock.On call +// - dmsPath string +func (_e *MockVersionFetcher_Expecter) GetCurrentVersion(dmsPath interface{}) *MockVersionFetcher_GetCurrentVersion_Call { + return &MockVersionFetcher_GetCurrentVersion_Call{Call: _e.mock.On("GetCurrentVersion", dmsPath)} +} + +func (_c *MockVersionFetcher_GetCurrentVersion_Call) Run(run func(dmsPath string)) *MockVersionFetcher_GetCurrentVersion_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *MockVersionFetcher_GetCurrentVersion_Call) Return(_a0 string, _a1 error) *MockVersionFetcher_GetCurrentVersion_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockVersionFetcher_GetCurrentVersion_Call) RunAndReturn(run func(string) (string, error)) *MockVersionFetcher_GetCurrentVersion_Call { + _c.Call.Return(run) + return _c +} + +// GetLatestVersion provides a mock function with given fields: dmsPath +func (_m *MockVersionFetcher) GetLatestVersion(dmsPath string) (string, error) { + ret := _m.Called(dmsPath) + + if len(ret) == 0 { + panic("no return value specified for GetLatestVersion") + } + + var r0 string + var r1 error + if rf, ok := ret.Get(0).(func(string) (string, error)); ok { + return rf(dmsPath) + } + if rf, ok := ret.Get(0).(func(string) string); ok { + r0 = rf(dmsPath) + } else { + r0 = ret.Get(0).(string) + } + + if rf, ok := ret.Get(1).(func(string) error); ok { + r1 = rf(dmsPath) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockVersionFetcher_GetLatestVersion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetLatestVersion' +type MockVersionFetcher_GetLatestVersion_Call struct { + *mock.Call +} + +// GetLatestVersion is a helper method to define mock.On call +// - dmsPath string +func (_e *MockVersionFetcher_Expecter) GetLatestVersion(dmsPath interface{}) *MockVersionFetcher_GetLatestVersion_Call { + return &MockVersionFetcher_GetLatestVersion_Call{Call: _e.mock.On("GetLatestVersion", dmsPath)} +} + +func (_c *MockVersionFetcher_GetLatestVersion_Call) Run(run func(dmsPath string)) *MockVersionFetcher_GetLatestVersion_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *MockVersionFetcher_GetLatestVersion_Call) Return(_a0 string, _a1 error) *MockVersionFetcher_GetLatestVersion_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockVersionFetcher_GetLatestVersion_Call) RunAndReturn(run func(string) (string, error)) *MockVersionFetcher_GetLatestVersion_Call { + _c.Call.Return(run) + return _c +} + +// NewMockVersionFetcher creates a new instance of MockVersionFetcher. 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 NewMockVersionFetcher(t interface { + mock.TestingT + Cleanup(func()) +}) *MockVersionFetcher { + mock := &MockVersionFetcher{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/wlclient/mock_WaylandDisplay.go b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/wlclient/mock_WaylandDisplay.go new file mode 100644 index 0000000..45d944b --- /dev/null +++ b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/wlclient/mock_WaylandDisplay.go @@ -0,0 +1,229 @@ +// Code generated by mockery v2.53.5. DO NOT EDIT. + +package mocks_wlclient + +import ( + client "github.com/AvengeMedia/DankMaterialShell/core/pkg/go-wayland/wayland/client" + mock "github.com/stretchr/testify/mock" +) + +// MockWaylandDisplay is an autogenerated mock type for the WaylandDisplay type +type MockWaylandDisplay struct { + mock.Mock +} + +type MockWaylandDisplay_Expecter struct { + mock *mock.Mock +} + +func (_m *MockWaylandDisplay) EXPECT() *MockWaylandDisplay_Expecter { + return &MockWaylandDisplay_Expecter{mock: &_m.Mock} +} + +// Context provides a mock function with no fields +func (_m *MockWaylandDisplay) Context() *client.Context { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Context") + } + + var r0 *client.Context + if rf, ok := ret.Get(0).(func() *client.Context); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*client.Context) + } + } + + return r0 +} + +// MockWaylandDisplay_Context_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Context' +type MockWaylandDisplay_Context_Call struct { + *mock.Call +} + +// Context is a helper method to define mock.On call +func (_e *MockWaylandDisplay_Expecter) Context() *MockWaylandDisplay_Context_Call { + return &MockWaylandDisplay_Context_Call{Call: _e.mock.On("Context")} +} + +func (_c *MockWaylandDisplay_Context_Call) Run(run func()) *MockWaylandDisplay_Context_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockWaylandDisplay_Context_Call) Return(_a0 *client.Context) *MockWaylandDisplay_Context_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockWaylandDisplay_Context_Call) RunAndReturn(run func() *client.Context) *MockWaylandDisplay_Context_Call { + _c.Call.Return(run) + return _c +} + +// Destroy provides a mock function with no fields +func (_m *MockWaylandDisplay) Destroy() error { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Destroy") + } + + var r0 error + if rf, ok := ret.Get(0).(func() error); ok { + r0 = rf() + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockWaylandDisplay_Destroy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Destroy' +type MockWaylandDisplay_Destroy_Call struct { + *mock.Call +} + +// Destroy is a helper method to define mock.On call +func (_e *MockWaylandDisplay_Expecter) Destroy() *MockWaylandDisplay_Destroy_Call { + return &MockWaylandDisplay_Destroy_Call{Call: _e.mock.On("Destroy")} +} + +func (_c *MockWaylandDisplay_Destroy_Call) Run(run func()) *MockWaylandDisplay_Destroy_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockWaylandDisplay_Destroy_Call) Return(_a0 error) *MockWaylandDisplay_Destroy_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockWaylandDisplay_Destroy_Call) RunAndReturn(run func() error) *MockWaylandDisplay_Destroy_Call { + _c.Call.Return(run) + return _c +} + +// GetRegistry provides a mock function with no fields +func (_m *MockWaylandDisplay) GetRegistry() (*client.Registry, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetRegistry") + } + + var r0 *client.Registry + var r1 error + if rf, ok := ret.Get(0).(func() (*client.Registry, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() *client.Registry); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*client.Registry) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockWaylandDisplay_GetRegistry_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRegistry' +type MockWaylandDisplay_GetRegistry_Call struct { + *mock.Call +} + +// GetRegistry is a helper method to define mock.On call +func (_e *MockWaylandDisplay_Expecter) GetRegistry() *MockWaylandDisplay_GetRegistry_Call { + return &MockWaylandDisplay_GetRegistry_Call{Call: _e.mock.On("GetRegistry")} +} + +func (_c *MockWaylandDisplay_GetRegistry_Call) Run(run func()) *MockWaylandDisplay_GetRegistry_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockWaylandDisplay_GetRegistry_Call) Return(_a0 *client.Registry, _a1 error) *MockWaylandDisplay_GetRegistry_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockWaylandDisplay_GetRegistry_Call) RunAndReturn(run func() (*client.Registry, error)) *MockWaylandDisplay_GetRegistry_Call { + _c.Call.Return(run) + return _c +} + +// Roundtrip provides a mock function with no fields +func (_m *MockWaylandDisplay) Roundtrip() error { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Roundtrip") + } + + var r0 error + if rf, ok := ret.Get(0).(func() error); ok { + r0 = rf() + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockWaylandDisplay_Roundtrip_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Roundtrip' +type MockWaylandDisplay_Roundtrip_Call struct { + *mock.Call +} + +// Roundtrip is a helper method to define mock.On call +func (_e *MockWaylandDisplay_Expecter) Roundtrip() *MockWaylandDisplay_Roundtrip_Call { + return &MockWaylandDisplay_Roundtrip_Call{Call: _e.mock.On("Roundtrip")} +} + +func (_c *MockWaylandDisplay_Roundtrip_Call) Run(run func()) *MockWaylandDisplay_Roundtrip_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockWaylandDisplay_Roundtrip_Call) Return(_a0 error) *MockWaylandDisplay_Roundtrip_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockWaylandDisplay_Roundtrip_Call) RunAndReturn(run func() error) *MockWaylandDisplay_Roundtrip_Call { + _c.Call.Return(run) + return _c +} + +// NewMockWaylandDisplay creates a new instance of MockWaylandDisplay. 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 NewMockWaylandDisplay(t interface { + mock.TestingT + Cleanup(func()) +}) *MockWaylandDisplay { + mock := &MockWaylandDisplay{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/wlcontext/mock_WaylandContext.go b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/wlcontext/mock_WaylandContext.go new file mode 100644 index 0000000..f5b0c35 --- /dev/null +++ b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/wlcontext/mock_WaylandContext.go @@ -0,0 +1,226 @@ +// Code generated by mockery v2.53.5. DO NOT EDIT. + +package mocks_wlcontext + +import ( + client "github.com/AvengeMedia/DankMaterialShell/core/pkg/go-wayland/wayland/client" + mock "github.com/stretchr/testify/mock" +) + +// MockWaylandContext is an autogenerated mock type for the WaylandContext type +type MockWaylandContext struct { + mock.Mock +} + +type MockWaylandContext_Expecter struct { + mock *mock.Mock +} + +func (_m *MockWaylandContext) EXPECT() *MockWaylandContext_Expecter { + return &MockWaylandContext_Expecter{mock: &_m.Mock} +} + +// Close provides a mock function with no fields +func (_m *MockWaylandContext) Close() { + _m.Called() +} + +// MockWaylandContext_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close' +type MockWaylandContext_Close_Call struct { + *mock.Call +} + +// Close is a helper method to define mock.On call +func (_e *MockWaylandContext_Expecter) Close() *MockWaylandContext_Close_Call { + return &MockWaylandContext_Close_Call{Call: _e.mock.On("Close")} +} + +func (_c *MockWaylandContext_Close_Call) Run(run func()) *MockWaylandContext_Close_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockWaylandContext_Close_Call) Return() *MockWaylandContext_Close_Call { + _c.Call.Return() + return _c +} + +func (_c *MockWaylandContext_Close_Call) RunAndReturn(run func()) *MockWaylandContext_Close_Call { + _c.Run(run) + return _c +} + +// Display provides a mock function with no fields +func (_m *MockWaylandContext) Display() *client.Display { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Display") + } + + var r0 *client.Display + if rf, ok := ret.Get(0).(func() *client.Display); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*client.Display) + } + } + + return r0 +} + +// MockWaylandContext_Display_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Display' +type MockWaylandContext_Display_Call struct { + *mock.Call +} + +// Display is a helper method to define mock.On call +func (_e *MockWaylandContext_Expecter) Display() *MockWaylandContext_Display_Call { + return &MockWaylandContext_Display_Call{Call: _e.mock.On("Display")} +} + +func (_c *MockWaylandContext_Display_Call) Run(run func()) *MockWaylandContext_Display_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockWaylandContext_Display_Call) Return(_a0 *client.Display) *MockWaylandContext_Display_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockWaylandContext_Display_Call) RunAndReturn(run func() *client.Display) *MockWaylandContext_Display_Call { + _c.Call.Return(run) + return _c +} + +// FatalError provides a mock function with no fields +func (_m *MockWaylandContext) FatalError() <-chan error { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for FatalError") + } + + var r0 <-chan error + if rf, ok := ret.Get(0).(func() <-chan error); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(<-chan error) + } + } + + return r0 +} + +// MockWaylandContext_FatalError_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FatalError' +type MockWaylandContext_FatalError_Call struct { + *mock.Call +} + +// FatalError is a helper method to define mock.On call +func (_e *MockWaylandContext_Expecter) FatalError() *MockWaylandContext_FatalError_Call { + return &MockWaylandContext_FatalError_Call{Call: _e.mock.On("FatalError")} +} + +func (_c *MockWaylandContext_FatalError_Call) Run(run func()) *MockWaylandContext_FatalError_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockWaylandContext_FatalError_Call) Return(_a0 <-chan error) *MockWaylandContext_FatalError_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockWaylandContext_FatalError_Call) RunAndReturn(run func() <-chan error) *MockWaylandContext_FatalError_Call { + _c.Call.Return(run) + return _c +} + +// Post provides a mock function with given fields: fn +func (_m *MockWaylandContext) Post(fn func()) { + _m.Called(fn) +} + +// MockWaylandContext_Post_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Post' +type MockWaylandContext_Post_Call struct { + *mock.Call +} + +// Post is a helper method to define mock.On call +// - fn func() +func (_e *MockWaylandContext_Expecter) Post(fn interface{}) *MockWaylandContext_Post_Call { + return &MockWaylandContext_Post_Call{Call: _e.mock.On("Post", fn)} +} + +func (_c *MockWaylandContext_Post_Call) Run(run func(fn func())) *MockWaylandContext_Post_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func())) + }) + return _c +} + +func (_c *MockWaylandContext_Post_Call) Return() *MockWaylandContext_Post_Call { + _c.Call.Return() + return _c +} + +func (_c *MockWaylandContext_Post_Call) RunAndReturn(run func(func())) *MockWaylandContext_Post_Call { + _c.Run(run) + return _c +} + +// Start provides a mock function with no fields +func (_m *MockWaylandContext) Start() { + _m.Called() +} + +// MockWaylandContext_Start_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Start' +type MockWaylandContext_Start_Call struct { + *mock.Call +} + +// Start is a helper method to define mock.On call +func (_e *MockWaylandContext_Expecter) Start() *MockWaylandContext_Start_Call { + return &MockWaylandContext_Start_Call{Call: _e.mock.On("Start")} +} + +func (_c *MockWaylandContext_Start_Call) Run(run func()) *MockWaylandContext_Start_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockWaylandContext_Start_Call) Return() *MockWaylandContext_Start_Call { + _c.Call.Return() + return _c +} + +func (_c *MockWaylandContext_Start_Call) RunAndReturn(run func()) *MockWaylandContext_Start_Call { + _c.Run(run) + return _c +} + +// NewMockWaylandContext creates a new instance of MockWaylandContext. 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 NewMockWaylandContext(t interface { + mock.TestingT + Cleanup(func()) +}) *MockWaylandContext { + mock := &MockWaylandContext{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} |