diff options
Diffstat (limited to 'raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/github.com')
9 files changed, 10476 insertions, 0 deletions
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 +} |