networkmanager

package
v0.0.0-...-77ac5d6 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Nov 28, 2023 License: GPL-3.0 Imports: 8 Imported by: 3

Documentation

Overview

SPDX-FileCopyrightText: 2018 - 2023 UnionTech Software Technology Co., Ltd.

SPDX-License-Identifier: GPL-3.0-or-later

SPDX-FileCopyrightText: 2018 - 2023 UnionTech Software Technology Co., Ltd.

SPDX-License-Identifier: GPL-3.0-or-later

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AccessPoint 

type AccessPoint interface {
	proxy.Object
	// contains filtered or unexported methods
}

func NewAccessPoint 

func NewAccessPoint(conn *dbus.Conn, path dbus.ObjectPath) (AccessPoint, error)

type ActiveConnection 

type ActiveConnection interface {
	proxy.Object
	// contains filtered or unexported methods
}

func NewActiveConnection 

func NewActiveConnection(conn *dbus.Conn, path dbus.ObjectPath) (ActiveConnection, error)

type AgentManager 

type AgentManager interface {
	proxy.Object
	// contains filtered or unexported methods
}

func NewAgentManager 

func NewAgentManager(conn *dbus.Conn) AgentManager

type Checkpoint 

type Checkpoint interface {
	proxy.Object
	// contains filtered or unexported methods
}

func NewCheckpoint 

func NewCheckpoint(conn *dbus.Conn, path dbus.ObjectPath) (Checkpoint, error)

type ConnectionSettings 

type ConnectionSettings interface {
	proxy.Object
	// contains filtered or unexported methods
}

func NewConnectionSettings 

func NewConnectionSettings(conn *dbus.Conn, path dbus.ObjectPath) (ConnectionSettings, error)

type Device 

type Device interface {
	Device() device               // interface org.freedesktop.NetworkManager.Device
	Adsl() deviceAdsl             // interface org.freedesktop.NetworkManager.Device.Adsl
	Bluetooth() deviceBluetooth   // interface org.freedesktop.NetworkManager.Device.Bluetooth
	Bond() deviceBond             // interface org.freedesktop.NetworkManager.Device.Bond
	Bridge() deviceBridge         // interface org.freedesktop.NetworkManager.Device.Bridge
	Generic() deviceGeneric       // interface org.freedesktop.NetworkManager.Device.Generic
	Infiniband() deviceInfiniband // interface org.freedesktop.NetworkManager.Device.Infiniband
	IPTunnel() deviceIPTunnel     // interface org.freedesktop.NetworkManager.Device.IPTunnel
	Macsec() deviceMacsec         // interface org.freedesktop.NetworkManager.Device.Macsec
	Macvlan() deviceMacvlan       // interface org.freedesktop.NetworkManager.Device.Macvlan
	Modem() deviceModem           // interface org.freedesktop.NetworkManager.Device.Modem
	OlpcMesh() deviceOlpcMesh     // interface org.freedesktop.NetworkManager.Device.OlpcMesh
	Statistics() deviceStatistics // interface org.freedesktop.NetworkManager.Device.Statistics
	Team() deviceTeam             // interface org.freedesktop.NetworkManager.Device.Team
	Tun() deviceTun               // interface org.freedesktop.NetworkManager.Device.Tun
	Veth() deviceVeth             // interface org.freedesktop.NetworkManager.Device.Veth
	Vlan() deviceVlan             // interface org.freedesktop.NetworkManager.Device.Vlan
	Vxlan() deviceVxlan           // interface org.freedesktop.NetworkManager.Device.Vxlan
	WiMax() deviceWiMax           // interface org.freedesktop.NetworkManager.Device.WiMax
	Wired() deviceWired           // interface org.freedesktop.NetworkManager.Device.Wired
	Wireless() deviceWireless     // interface org.freedesktop.NetworkManager.Device.Wireless
	proxy.Object
}

func NewDevice 

func NewDevice(conn *dbus.Conn, path dbus.ObjectPath) (Device, error)

type DeviceStateReason 

type DeviceStateReason struct {
	State  uint32
	Reason uint32
}

type Dhcp4Config 

type Dhcp4Config interface {
	proxy.Object
	// contains filtered or unexported methods
}

func NewDhcp4Config 

func NewDhcp4Config(conn *dbus.Conn, path dbus.ObjectPath) (Dhcp4Config, error)

type Dhcp6Config 

type Dhcp6Config interface {
	proxy.Object
	// contains filtered or unexported methods
}

func NewDhcp6Config 

func NewDhcp6Config(conn *dbus.Conn, path dbus.ObjectPath) (Dhcp6Config, error)

type DnsManager 

type DnsManager interface {
	proxy.Object
	// contains filtered or unexported methods
}

func NewDnsManager 

func NewDnsManager(conn *dbus.Conn) DnsManager

type IP4Config 

type IP4Config interface {
	proxy.Object
	// contains filtered or unexported methods
}

func NewIP4Config 

func NewIP4Config(conn *dbus.Conn, path dbus.ObjectPath) (IP4Config, error)

type IP6Address 

type IP6Address struct {
	Address []byte
	Prefix  uint32
	Gateway []byte
}

type IP6Config 

type IP6Config interface {
	proxy.Object
	// contains filtered or unexported methods
}

func NewIP6Config 

func NewIP6Config(conn *dbus.Conn, path dbus.ObjectPath) (IP6Config, error)

type IP6Route 

type IP6Route struct {
	Route   []byte
	Prefix  uint32
	NextHop []byte
	Metric  uint32
}

type Manager 

type Manager interface {
	proxy.Object
	// contains filtered or unexported methods
}

func NewManager 

func NewManager(conn *dbus.Conn) Manager

type MockAccessPoint 

type MockAccessPoint struct {
	MockInterfaceAccessPoint // interface org.freedesktop.NetworkManager.AccessPoint
	proxy.MockObject
}

type MockActiveConnection 

type MockActiveConnection struct {
	MockInterfaceActiveConnection // interface org.freedesktop.NetworkManager.Connection.Active
	proxy.MockObject
}

type MockAgentManager 

type MockAgentManager struct {
	MockInterfaceAgentManager // interface org.freedesktop.NetworkManager.AgentManager
	proxy.MockObject
}

type MockCheckpoint 

type MockCheckpoint struct {
	MockInterfaceCheckpoint // interface org.freedesktop.NetworkManager.Checkpoint
	proxy.MockObject
}

type MockConnectionSettings 

type MockConnectionSettings struct {
	MockInterfaceConnectionSettings // interface org.freedesktop.NetworkManager.Settings.Connection
	proxy.MockObject
}

type MockDevice 

type MockDevice struct {
	MockInterfaceDevice           // interface org.freedesktop.NetworkManager.Device
	MockInterfaceDeviceAdsl       // interface org.freedesktop.NetworkManager.Device.Adsl
	MockInterfaceDeviceBluetooth  // interface org.freedesktop.NetworkManager.Device.Bluetooth
	MockInterfaceDeviceBond       // interface org.freedesktop.NetworkManager.Device.Bond
	MockInterfaceDeviceBridge     // interface org.freedesktop.NetworkManager.Device.Bridge
	MockInterfaceDeviceGeneric    // interface org.freedesktop.NetworkManager.Device.Generic
	MockInterfaceDeviceInfiniband // interface org.freedesktop.NetworkManager.Device.Infiniband
	MockInterfaceDeviceIPTunnel   // interface org.freedesktop.NetworkManager.Device.IPTunnel
	MockInterfaceDeviceMacsec     // interface org.freedesktop.NetworkManager.Device.Macsec
	MockInterfaceDeviceMacvlan    // interface org.freedesktop.NetworkManager.Device.Macvlan
	MockInterfaceDeviceModem      // interface org.freedesktop.NetworkManager.Device.Modem
	MockInterfaceDeviceOlpcMesh   // interface org.freedesktop.NetworkManager.Device.OlpcMesh
	MockInterfaceDeviceStatistics // interface org.freedesktop.NetworkManager.Device.Statistics
	MockInterfaceDeviceTeam       // interface org.freedesktop.NetworkManager.Device.Team
	MockInterfaceDeviceTun        // interface org.freedesktop.NetworkManager.Device.Tun
	MockInterfaceDeviceVeth       // interface org.freedesktop.NetworkManager.Device.Veth
	MockInterfaceDeviceVlan       // interface org.freedesktop.NetworkManager.Device.Vlan
	MockInterfaceDeviceVxlan      // interface org.freedesktop.NetworkManager.Device.Vxlan
	MockInterfaceDeviceWiMax      // interface org.freedesktop.NetworkManager.Device.WiMax
	MockInterfaceDeviceWired      // interface org.freedesktop.NetworkManager.Device.Wired
	MockInterfaceDeviceWireless   // interface org.freedesktop.NetworkManager.Device.Wireless
	proxy.MockObject
}

type MockDhcp4Config 

type MockDhcp4Config struct {
	MockInterfaceDhcp4Config // interface org.freedesktop.NetworkManager.DHCP4Config
	proxy.MockObject
}

type MockDhcp6Config 

type MockDhcp6Config struct {
	MockInterfaceDhcp6Config // interface org.freedesktop.NetworkManager.DHCP6Config
	proxy.MockObject
}

type MockDnsManager 

type MockDnsManager struct {
	MockInterfaceDnsManager // interface org.freedesktop.NetworkManager.DnsManager
	proxy.MockObject
}

type MockIP4Config 

type MockIP4Config struct {
	MockInterfaceIp4Config // interface org.freedesktop.NetworkManager.IP4Config
	proxy.MockObject
}

type MockIP6Config 

type MockIP6Config struct {
	MockInterfaceIp6Config // interface org.freedesktop.NetworkManager.IP6Config
	proxy.MockObject
}

type MockInterfaceAccessPoint 

type MockInterfaceAccessPoint struct {
	mock.Mock
}

func (*MockInterfaceAccessPoint) ConnectSignalPropertiesChanged 

func (v *MockInterfaceAccessPoint) ConnectSignalPropertiesChanged(cb func(properties map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error)

func (*MockInterfaceAccessPoint) Flags 

func (v *MockInterfaceAccessPoint) Flags() proxy.PropUint32

func (*MockInterfaceAccessPoint) Frequency 

func (v *MockInterfaceAccessPoint) Frequency() proxy.PropUint32

func (*MockInterfaceAccessPoint) HwAddress 

func (v *MockInterfaceAccessPoint) HwAddress() proxy.PropString

func (*MockInterfaceAccessPoint) LastSeen 

func (v *MockInterfaceAccessPoint) LastSeen() proxy.PropInt32

func (*MockInterfaceAccessPoint) MaxBitrate 

func (v *MockInterfaceAccessPoint) MaxBitrate() proxy.PropUint32

func (*MockInterfaceAccessPoint) Mode 

func (v *MockInterfaceAccessPoint) Mode() proxy.PropUint32

func (*MockInterfaceAccessPoint) RsnFlags 

func (v *MockInterfaceAccessPoint) RsnFlags() proxy.PropUint32

func (*MockInterfaceAccessPoint) Ssid 

func (v *MockInterfaceAccessPoint) Ssid() proxy.PropByteArray

func (*MockInterfaceAccessPoint) Strength 

func (v *MockInterfaceAccessPoint) Strength() proxy.PropByte

func (*MockInterfaceAccessPoint) WpaFlags 

func (v *MockInterfaceAccessPoint) WpaFlags() proxy.PropUint32

type MockInterfaceActiveConnection 

type MockInterfaceActiveConnection struct {
	mock.Mock
}

func (*MockInterfaceActiveConnection) ConnectSignalPropertiesChanged 

func (v *MockInterfaceActiveConnection) ConnectSignalPropertiesChanged(cb func(properties map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error)

func (*MockInterfaceActiveConnection) ConnectStateChanged 

func (v *MockInterfaceActiveConnection) ConnectStateChanged(cb func(state uint32, reason uint32)) (dbusutil.SignalHandlerId, error)

func (*MockInterfaceActiveConnection) Connection 

func (v *MockInterfaceActiveConnection) Connection() proxy.PropObjectPath

func (*MockInterfaceActiveConnection) Default 

func (v *MockInterfaceActiveConnection) Default() proxy.PropBool

func (*MockInterfaceActiveConnection) Default6 

func (v *MockInterfaceActiveConnection) Default6() proxy.PropBool

func (*MockInterfaceActiveConnection) Devices 

func (v *MockInterfaceActiveConnection) Devices() proxy.PropObjectPathArray

func (*MockInterfaceActiveConnection) Dhcp4Config 

func (v *MockInterfaceActiveConnection) Dhcp4Config() proxy.PropObjectPath

func (*MockInterfaceActiveConnection) Dhcp6Config 

func (v *MockInterfaceActiveConnection) Dhcp6Config() proxy.PropObjectPath

func (*MockInterfaceActiveConnection) Id 

func (v *MockInterfaceActiveConnection) Id() proxy.PropString

func (*MockInterfaceActiveConnection) Ip4Config 

func (v *MockInterfaceActiveConnection) Ip4Config() proxy.PropObjectPath

func (*MockInterfaceActiveConnection) Ip6Config 

func (v *MockInterfaceActiveConnection) Ip6Config() proxy.PropObjectPath

func (*MockInterfaceActiveConnection) Master 

func (v *MockInterfaceActiveConnection) Master() proxy.PropObjectPath

func (*MockInterfaceActiveConnection) SpecificObject 

func (v *MockInterfaceActiveConnection) SpecificObject() proxy.PropObjectPath

func (*MockInterfaceActiveConnection) State 

func (v *MockInterfaceActiveConnection) State() proxy.PropUint32

func (*MockInterfaceActiveConnection) Type 

func (v *MockInterfaceActiveConnection) Type() proxy.PropString

func (*MockInterfaceActiveConnection) Uuid 

func (v *MockInterfaceActiveConnection) Uuid() proxy.PropString

func (*MockInterfaceActiveConnection) Vpn 

func (v *MockInterfaceActiveConnection) Vpn() proxy.PropBool

type MockInterfaceAgentManager 

type MockInterfaceAgentManager struct {
	mock.Mock
}

func (*MockInterfaceAgentManager) GoRegister 

func (v *MockInterfaceAgentManager) GoRegister(flags dbus.Flags, ch chan *dbus.Call, identifier string) *dbus.Call

func (*MockInterfaceAgentManager) GoRegisterWithCapabilities 

func (v *MockInterfaceAgentManager) GoRegisterWithCapabilities(flags dbus.Flags, ch chan *dbus.Call, identifier string, capabilities uint32) *dbus.Call

func (*MockInterfaceAgentManager) GoUnregister 

func (v *MockInterfaceAgentManager) GoUnregister(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call

func (*MockInterfaceAgentManager) Register 

func (v *MockInterfaceAgentManager) Register(flags dbus.Flags, identifier string) error

func (*MockInterfaceAgentManager) RegisterWithCapabilities 

func (v *MockInterfaceAgentManager) RegisterWithCapabilities(flags dbus.Flags, identifier string, capabilities uint32) error

func (*MockInterfaceAgentManager) Unregister 

func (v *MockInterfaceAgentManager) Unregister(flags dbus.Flags) error

type MockInterfaceCheckpoint 

type MockInterfaceCheckpoint struct {
	mock.Mock
}

func (*MockInterfaceCheckpoint) ConnectSignalPropertiesChanged 

func (v *MockInterfaceCheckpoint) ConnectSignalPropertiesChanged(cb func(properties map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error)

func (*MockInterfaceCheckpoint) Created 

func (v *MockInterfaceCheckpoint) Created() proxy.PropInt64

func (*MockInterfaceCheckpoint) Devices 

func (v *MockInterfaceCheckpoint) Devices() proxy.PropObjectPathArray

func (*MockInterfaceCheckpoint) RollbackTimeout 

func (v *MockInterfaceCheckpoint) RollbackTimeout() proxy.PropUint32

type MockInterfaceConnectionSettings 

type MockInterfaceConnectionSettings struct {
	mock.Mock
}

func (*MockInterfaceConnectionSettings) ClearSecrets 

func (v *MockInterfaceConnectionSettings) ClearSecrets(flags dbus.Flags) error

func (*MockInterfaceConnectionSettings) ConnectRemoved 

func (v *MockInterfaceConnectionSettings) ConnectRemoved(cb func()) (dbusutil.SignalHandlerId, error)

func (*MockInterfaceConnectionSettings) ConnectSignalPropertiesChanged 

func (v *MockInterfaceConnectionSettings) ConnectSignalPropertiesChanged(cb func(properties map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error)

func (*MockInterfaceConnectionSettings) ConnectUpdated 

func (v *MockInterfaceConnectionSettings) ConnectUpdated(cb func()) (dbusutil.SignalHandlerId, error)

func (*MockInterfaceConnectionSettings) Delete 

func (v *MockInterfaceConnectionSettings) Delete(flags dbus.Flags) error

func (*MockInterfaceConnectionSettings) GetSecrets 

func (v *MockInterfaceConnectionSettings) GetSecrets(flags dbus.Flags, setting_name string) (map[string]map[string]dbus.Variant, error)

func (*MockInterfaceConnectionSettings) GetSettings 

func (v *MockInterfaceConnectionSettings) GetSettings(flags dbus.Flags) (map[string]map[string]dbus.Variant, error)

func (*MockInterfaceConnectionSettings) GoClearSecrets 

func (v *MockInterfaceConnectionSettings) GoClearSecrets(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call

func (*MockInterfaceConnectionSettings) GoDelete 

func (v *MockInterfaceConnectionSettings) GoDelete(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call

func (*MockInterfaceConnectionSettings) GoGetSecrets 

func (v *MockInterfaceConnectionSettings) GoGetSecrets(flags dbus.Flags, ch chan *dbus.Call, setting_name string) *dbus.Call

func (*MockInterfaceConnectionSettings) GoGetSettings 

func (v *MockInterfaceConnectionSettings) GoGetSettings(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call

func (*MockInterfaceConnectionSettings) GoSave 

func (v *MockInterfaceConnectionSettings) GoSave(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call

func (*MockInterfaceConnectionSettings) GoUpdate 

func (v *MockInterfaceConnectionSettings) GoUpdate(flags dbus.Flags, ch chan *dbus.Call, properties map[string]map[string]dbus.Variant) *dbus.Call

func (*MockInterfaceConnectionSettings) GoUpdateUnsaved 

func (v *MockInterfaceConnectionSettings) GoUpdateUnsaved(flags dbus.Flags, ch chan *dbus.Call, properties map[string]map[string]dbus.Variant) *dbus.Call

func (*MockInterfaceConnectionSettings) Save 

func (v *MockInterfaceConnectionSettings) Save(flags dbus.Flags) error

func (*MockInterfaceConnectionSettings) Unsaved 

func (v *MockInterfaceConnectionSettings) Unsaved() proxy.PropBool

func (*MockInterfaceConnectionSettings) Update 

func (v *MockInterfaceConnectionSettings) Update(flags dbus.Flags, properties map[string]map[string]dbus.Variant) error

func (*MockInterfaceConnectionSettings) UpdateUnsaved 

func (v *MockInterfaceConnectionSettings) UpdateUnsaved(flags dbus.Flags, properties map[string]map[string]dbus.Variant) error

type MockInterfaceDevice 

type MockInterfaceDevice struct {
	mock.Mock
}

func (*MockInterfaceDevice) ActiveConnection 

func (v *MockInterfaceDevice) ActiveConnection() proxy.PropObjectPath

func (*MockInterfaceDevice) Autoconnect 

func (v *MockInterfaceDevice) Autoconnect() proxy.PropBool

func (*MockInterfaceDevice) AvailableConnections 

func (v *MockInterfaceDevice) AvailableConnections() proxy.PropObjectPathArray

func (*MockInterfaceDevice) Capabilities 

func (v *MockInterfaceDevice) Capabilities() proxy.PropUint32

func (*MockInterfaceDevice) ConnectStateChanged 

func (v *MockInterfaceDevice) ConnectStateChanged(cb func(new_state uint32, old_state uint32, reason uint32)) (dbusutil.SignalHandlerId, error)

func (*MockInterfaceDevice) Delete 

func (v *MockInterfaceDevice) Delete(flags dbus.Flags) error

func (*MockInterfaceDevice) DeviceType 

func (v *MockInterfaceDevice) DeviceType() proxy.PropUint32

func (*MockInterfaceDevice) Dhcp4Config 

func (v *MockInterfaceDevice) Dhcp4Config() proxy.PropObjectPath

func (*MockInterfaceDevice) Dhcp6Config 

func (v *MockInterfaceDevice) Dhcp6Config() proxy.PropObjectPath

func (*MockInterfaceDevice) Disconnect 

func (v *MockInterfaceDevice) Disconnect(flags dbus.Flags) error

func (*MockInterfaceDevice) Driver 

func (v *MockInterfaceDevice) Driver() proxy.PropString

func (*MockInterfaceDevice) DriverVersion 

func (v *MockInterfaceDevice) DriverVersion() proxy.PropString

func (*MockInterfaceDevice) FirmwareMissing 

func (v *MockInterfaceDevice) FirmwareMissing() proxy.PropBool

func (*MockInterfaceDevice) FirmwareVersion 

func (v *MockInterfaceDevice) FirmwareVersion() proxy.PropString

func (*MockInterfaceDevice) GetAppliedConnection 

func (v *MockInterfaceDevice) GetAppliedConnection(flags dbus.Flags, flags0 uint32) (map[string]map[string]dbus.Variant, uint64, error)

func (*MockInterfaceDevice) GoDelete 

func (v *MockInterfaceDevice) GoDelete(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call

func (*MockInterfaceDevice) GoDisconnect 

func (v *MockInterfaceDevice) GoDisconnect(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call

func (*MockInterfaceDevice) GoGetAppliedConnection 

func (v *MockInterfaceDevice) GoGetAppliedConnection(flags dbus.Flags, ch chan *dbus.Call, flags0 uint32) *dbus.Call

func (*MockInterfaceDevice) GoReapply 

func (v *MockInterfaceDevice) GoReapply(flags dbus.Flags, ch chan *dbus.Call, connection map[string]map[string]dbus.Variant, version_id uint64, flags0 uint32) *dbus.Call

func (*MockInterfaceDevice) Interface 

func (v *MockInterfaceDevice) Interface() proxy.PropString

func (*MockInterfaceDevice) InterfaceFlags 

func (v *MockInterfaceDevice) InterfaceFlags() proxy.PropUint32

func (*MockInterfaceDevice) Ip4Address 

func (v *MockInterfaceDevice) Ip4Address() proxy.PropUint32

func (*MockInterfaceDevice) Ip4Config 

func (v *MockInterfaceDevice) Ip4Config() proxy.PropObjectPath

func (*MockInterfaceDevice) Ip6Config 

func (v *MockInterfaceDevice) Ip6Config() proxy.PropObjectPath

func (*MockInterfaceDevice) IpInterface 

func (v *MockInterfaceDevice) IpInterface() proxy.PropString

func (*MockInterfaceDevice) LldpNeighbors 

func (v *MockInterfaceDevice) LldpNeighbors() PropMapSVSlice

func (*MockInterfaceDevice) Managed 

func (v *MockInterfaceDevice) Managed() proxy.PropBool

func (*MockInterfaceDevice) Metered 

func (v *MockInterfaceDevice) Metered() proxy.PropUint32

func (*MockInterfaceDevice) Mtu 

func (v *MockInterfaceDevice) Mtu() proxy.PropUint32

func (*MockInterfaceDevice) NmPluginMissing 

func (v *MockInterfaceDevice) NmPluginMissing() proxy.PropBool

func (*MockInterfaceDevice) PhysicalPortId 

func (v *MockInterfaceDevice) PhysicalPortId() proxy.PropString

func (*MockInterfaceDevice) Real 

func (v *MockInterfaceDevice) Real() proxy.PropBool

func (*MockInterfaceDevice) Reapply 

func (v *MockInterfaceDevice) Reapply(flags dbus.Flags, connection map[string]map[string]dbus.Variant, version_id uint64, flags0 uint32) error

func (*MockInterfaceDevice) State 

func (v *MockInterfaceDevice) State() proxy.PropUint32

func (*MockInterfaceDevice) StateReason 

func (v *MockInterfaceDevice) StateReason() PropDeviceStateReason

func (*MockInterfaceDevice) Udi 

func (v *MockInterfaceDevice) Udi() proxy.PropString

type MockInterfaceDeviceAdsl 

type MockInterfaceDeviceAdsl struct {
	mock.Mock
}

func (*MockInterfaceDeviceAdsl) Carrier 

func (v *MockInterfaceDeviceAdsl) Carrier() proxy.PropBool

func (*MockInterfaceDeviceAdsl) ConnectSignalPropertiesChanged 

func (v *MockInterfaceDeviceAdsl) ConnectSignalPropertiesChanged(cb func(properties map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error)

type MockInterfaceDeviceBluetooth 

type MockInterfaceDeviceBluetooth struct {
	mock.Mock
}

func (*MockInterfaceDeviceBluetooth) BtCapabilities 

func (v *MockInterfaceDeviceBluetooth) BtCapabilities() proxy.PropUint32

func (*MockInterfaceDeviceBluetooth) ConnectSignalPropertiesChanged 

func (v *MockInterfaceDeviceBluetooth) ConnectSignalPropertiesChanged(cb func(properties map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error)

func (*MockInterfaceDeviceBluetooth) HwAddress 

func (v *MockInterfaceDeviceBluetooth) HwAddress() proxy.PropString

func (*MockInterfaceDeviceBluetooth) Name 

func (v *MockInterfaceDeviceBluetooth) Name() proxy.PropString

type MockInterfaceDeviceBond 

type MockInterfaceDeviceBond struct {
	mock.Mock
}

func (*MockInterfaceDeviceBond) Carrier 

func (v *MockInterfaceDeviceBond) Carrier() proxy.PropBool

func (*MockInterfaceDeviceBond) ConnectSignalPropertiesChanged 

func (v *MockInterfaceDeviceBond) ConnectSignalPropertiesChanged(cb func(properties map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error)

func (*MockInterfaceDeviceBond) HwAddress 

func (v *MockInterfaceDeviceBond) HwAddress() proxy.PropString

func (*MockInterfaceDeviceBond) Slaves 

func (v *MockInterfaceDeviceBond) Slaves() proxy.PropObjectPathArray

type MockInterfaceDeviceBridge 

type MockInterfaceDeviceBridge struct {
	mock.Mock
}

func (*MockInterfaceDeviceBridge) Carrier 

func (v *MockInterfaceDeviceBridge) Carrier() proxy.PropBool

func (*MockInterfaceDeviceBridge) ConnectSignalPropertiesChanged 

func (v *MockInterfaceDeviceBridge) ConnectSignalPropertiesChanged(cb func(properties map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error)

func (*MockInterfaceDeviceBridge) HwAddress 

func (v *MockInterfaceDeviceBridge) HwAddress() proxy.PropString

func (*MockInterfaceDeviceBridge) Slaves 

func (v *MockInterfaceDeviceBridge) Slaves() proxy.PropObjectPathArray

type MockInterfaceDeviceGeneric 

type MockInterfaceDeviceGeneric struct {
	mock.Mock
}

func (*MockInterfaceDeviceGeneric) ConnectSignalPropertiesChanged 

func (v *MockInterfaceDeviceGeneric) ConnectSignalPropertiesChanged(cb func(properties map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error)

func (*MockInterfaceDeviceGeneric) HwAddress 

func (v *MockInterfaceDeviceGeneric) HwAddress() proxy.PropString

func (*MockInterfaceDeviceGeneric) TypeDescription 

func (v *MockInterfaceDeviceGeneric) TypeDescription() proxy.PropString

type MockInterfaceDeviceIPTunnel 

type MockInterfaceDeviceIPTunnel struct {
	mock.Mock
}

func (*MockInterfaceDeviceIPTunnel) ConnectSignalPropertiesChanged 

func (v *MockInterfaceDeviceIPTunnel) ConnectSignalPropertiesChanged(cb func(properties map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error)

func (*MockInterfaceDeviceIPTunnel) EncapsulationLimit 

func (v *MockInterfaceDeviceIPTunnel) EncapsulationLimit() proxy.PropByte

func (*MockInterfaceDeviceIPTunnel) FlowLabel 

func (v *MockInterfaceDeviceIPTunnel) FlowLabel() proxy.PropUint32

func (*MockInterfaceDeviceIPTunnel) InputKey 

func (v *MockInterfaceDeviceIPTunnel) InputKey() proxy.PropString

func (*MockInterfaceDeviceIPTunnel) Local 

func (v *MockInterfaceDeviceIPTunnel) Local() proxy.PropString

func (*MockInterfaceDeviceIPTunnel) Mode 

func (v *MockInterfaceDeviceIPTunnel) Mode() proxy.PropUint32

func (*MockInterfaceDeviceIPTunnel) OutputKey 

func (v *MockInterfaceDeviceIPTunnel) OutputKey() proxy.PropString

func (*MockInterfaceDeviceIPTunnel) Parent 

func (v *MockInterfaceDeviceIPTunnel) Parent() proxy.PropObjectPath

func (*MockInterfaceDeviceIPTunnel) PathMtuDiscovery 

func (v *MockInterfaceDeviceIPTunnel) PathMtuDiscovery() proxy.PropBool

func (*MockInterfaceDeviceIPTunnel) Remote 

func (v *MockInterfaceDeviceIPTunnel) Remote() proxy.PropString

func (*MockInterfaceDeviceIPTunnel) Tos 

func (v *MockInterfaceDeviceIPTunnel) Tos() proxy.PropByte

func (*MockInterfaceDeviceIPTunnel) Ttl 

func (v *MockInterfaceDeviceIPTunnel) Ttl() proxy.PropByte

type MockInterfaceDeviceInfiniband 

type MockInterfaceDeviceInfiniband struct {
	mock.Mock
}

func (*MockInterfaceDeviceInfiniband) Carrier 

func (v *MockInterfaceDeviceInfiniband) Carrier() proxy.PropBool

func (*MockInterfaceDeviceInfiniband) ConnectSignalPropertiesChanged 

func (v *MockInterfaceDeviceInfiniband) ConnectSignalPropertiesChanged(cb func(properties map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error)

func (*MockInterfaceDeviceInfiniband) HwAddress 

func (v *MockInterfaceDeviceInfiniband) HwAddress() proxy.PropString

type MockInterfaceDeviceMacsec 

type MockInterfaceDeviceMacsec struct {
	mock.Mock
}

func (*MockInterfaceDeviceMacsec) CipherSuite 

func (v *MockInterfaceDeviceMacsec) CipherSuite() proxy.PropUint64

func (*MockInterfaceDeviceMacsec) ConnectSignalPropertiesChanged 

func (v *MockInterfaceDeviceMacsec) ConnectSignalPropertiesChanged(cb func(properties map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error)

func (*MockInterfaceDeviceMacsec) EncodingSa 

func (v *MockInterfaceDeviceMacsec) EncodingSa() proxy.PropByte

func (*MockInterfaceDeviceMacsec) Encrypt 

func (v *MockInterfaceDeviceMacsec) Encrypt() proxy.PropBool

func (*MockInterfaceDeviceMacsec) Es 

func (v *MockInterfaceDeviceMacsec) Es() proxy.PropBool

func (*MockInterfaceDeviceMacsec) IcvLength 

func (v *MockInterfaceDeviceMacsec) IcvLength() proxy.PropByte

func (*MockInterfaceDeviceMacsec) IncludeSci 

func (v *MockInterfaceDeviceMacsec) IncludeSci() proxy.PropBool

func (*MockInterfaceDeviceMacsec) Parent 

func (v *MockInterfaceDeviceMacsec) Parent() proxy.PropObjectPath

func (*MockInterfaceDeviceMacsec) Protect 

func (v *MockInterfaceDeviceMacsec) Protect() proxy.PropBool

func (*MockInterfaceDeviceMacsec) ReplayProtect 

func (v *MockInterfaceDeviceMacsec) ReplayProtect() proxy.PropBool

func (*MockInterfaceDeviceMacsec) Scb 

func (v *MockInterfaceDeviceMacsec) Scb() proxy.PropBool

func (*MockInterfaceDeviceMacsec) Sci 

func (v *MockInterfaceDeviceMacsec) Sci() proxy.PropUint64

func (*MockInterfaceDeviceMacsec) Validation 

func (v *MockInterfaceDeviceMacsec) Validation() proxy.PropString

func (*MockInterfaceDeviceMacsec) Window 

func (v *MockInterfaceDeviceMacsec) Window() proxy.PropUint32

type MockInterfaceDeviceMacvlan 

type MockInterfaceDeviceMacvlan struct {
	mock.Mock
}

func (*MockInterfaceDeviceMacvlan) ConnectSignalPropertiesChanged 

func (v *MockInterfaceDeviceMacvlan) ConnectSignalPropertiesChanged(cb func(properties map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error)

func (*MockInterfaceDeviceMacvlan) Mode 

func (v *MockInterfaceDeviceMacvlan) Mode() proxy.PropString

func (*MockInterfaceDeviceMacvlan) NoPromisc 

func (v *MockInterfaceDeviceMacvlan) NoPromisc() proxy.PropBool

func (*MockInterfaceDeviceMacvlan) Parent 

func (v *MockInterfaceDeviceMacvlan) Parent() proxy.PropObjectPath

func (*MockInterfaceDeviceMacvlan) Tap 

func (v *MockInterfaceDeviceMacvlan) Tap() proxy.PropBool

type MockInterfaceDeviceModem 

type MockInterfaceDeviceModem struct {
	mock.Mock
}

func (*MockInterfaceDeviceModem) ConnectSignalPropertiesChanged 

func (v *MockInterfaceDeviceModem) ConnectSignalPropertiesChanged(cb func(properties map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error)

func (*MockInterfaceDeviceModem) CurrentCapabilities 

func (v *MockInterfaceDeviceModem) CurrentCapabilities() proxy.PropUint32

func (*MockInterfaceDeviceModem) ModemCapabilities 

func (v *MockInterfaceDeviceModem) ModemCapabilities() proxy.PropUint32

type MockInterfaceDeviceOlpcMesh 

type MockInterfaceDeviceOlpcMesh struct {
	mock.Mock
}

func (*MockInterfaceDeviceOlpcMesh) ActiveChannel 

func (v *MockInterfaceDeviceOlpcMesh) ActiveChannel() proxy.PropUint32

func (*MockInterfaceDeviceOlpcMesh) Companion 

func (v *MockInterfaceDeviceOlpcMesh) Companion() proxy.PropObjectPath

func (*MockInterfaceDeviceOlpcMesh) ConnectSignalPropertiesChanged 

func (v *MockInterfaceDeviceOlpcMesh) ConnectSignalPropertiesChanged(cb func(properties map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error)

func (*MockInterfaceDeviceOlpcMesh) HwAddress 

func (v *MockInterfaceDeviceOlpcMesh) HwAddress() proxy.PropString

type MockInterfaceDeviceStatistics 

type MockInterfaceDeviceStatistics struct {
	mock.Mock
}

func (*MockInterfaceDeviceStatistics) ConnectSignalPropertiesChanged 

func (v *MockInterfaceDeviceStatistics) ConnectSignalPropertiesChanged(cb func(properties map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error)

func (*MockInterfaceDeviceStatistics) RefreshRateMs 

func (v *MockInterfaceDeviceStatistics) RefreshRateMs() proxy.PropUint32

func (*MockInterfaceDeviceStatistics) RxBytes 

func (v *MockInterfaceDeviceStatistics) RxBytes() proxy.PropUint64

func (*MockInterfaceDeviceStatistics) TxBytes 

func (v *MockInterfaceDeviceStatistics) TxBytes() proxy.PropUint64

type MockInterfaceDeviceTeam 

type MockInterfaceDeviceTeam struct {
	mock.Mock
}

func (*MockInterfaceDeviceTeam) Carrier 

func (v *MockInterfaceDeviceTeam) Carrier() proxy.PropBool

func (*MockInterfaceDeviceTeam) Config 

func (v *MockInterfaceDeviceTeam) Config() proxy.PropString

func (*MockInterfaceDeviceTeam) ConnectSignalPropertiesChanged 

func (v *MockInterfaceDeviceTeam) ConnectSignalPropertiesChanged(cb func(properties map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error)

func (*MockInterfaceDeviceTeam) HwAddress 

func (v *MockInterfaceDeviceTeam) HwAddress() proxy.PropString

func (*MockInterfaceDeviceTeam) Slaves 

func (v *MockInterfaceDeviceTeam) Slaves() proxy.PropObjectPathArray

type MockInterfaceDeviceTun 

type MockInterfaceDeviceTun struct {
	mock.Mock
}

func (*MockInterfaceDeviceTun) ConnectSignalPropertiesChanged 

func (v *MockInterfaceDeviceTun) ConnectSignalPropertiesChanged(cb func(properties map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error)

func (*MockInterfaceDeviceTun) Group 

func (v *MockInterfaceDeviceTun) Group() proxy.PropInt64

func (*MockInterfaceDeviceTun) HwAddress 

func (v *MockInterfaceDeviceTun) HwAddress() proxy.PropString

func (*MockInterfaceDeviceTun) Mode 

func (v *MockInterfaceDeviceTun) Mode() proxy.PropString

func (*MockInterfaceDeviceTun) MultiQueue 

func (v *MockInterfaceDeviceTun) MultiQueue() proxy.PropBool

func (*MockInterfaceDeviceTun) NoPi 

func (v *MockInterfaceDeviceTun) NoPi() proxy.PropBool

func (*MockInterfaceDeviceTun) Owner 

func (v *MockInterfaceDeviceTun) Owner() proxy.PropInt64

func (*MockInterfaceDeviceTun) VnetHdr 

func (v *MockInterfaceDeviceTun) VnetHdr() proxy.PropBool

type MockInterfaceDeviceVeth 

type MockInterfaceDeviceVeth struct {
	mock.Mock
}

func (*MockInterfaceDeviceVeth) ConnectSignalPropertiesChanged 

func (v *MockInterfaceDeviceVeth) ConnectSignalPropertiesChanged(cb func(properties map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error)

func (*MockInterfaceDeviceVeth) Peer 

func (v *MockInterfaceDeviceVeth) Peer() proxy.PropObjectPath

type MockInterfaceDeviceVlan 

type MockInterfaceDeviceVlan struct {
	mock.Mock
}

func (*MockInterfaceDeviceVlan) Carrier 

func (v *MockInterfaceDeviceVlan) Carrier() proxy.PropBool

func (*MockInterfaceDeviceVlan) ConnectSignalPropertiesChanged 

func (v *MockInterfaceDeviceVlan) ConnectSignalPropertiesChanged(cb func(properties map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error)

func (*MockInterfaceDeviceVlan) HwAddress 

func (v *MockInterfaceDeviceVlan) HwAddress() proxy.PropString

func (*MockInterfaceDeviceVlan) Parent 

func (v *MockInterfaceDeviceVlan) Parent() proxy.PropObjectPath

func (*MockInterfaceDeviceVlan) VlanId 

func (v *MockInterfaceDeviceVlan) VlanId() proxy.PropUint32

type MockInterfaceDeviceVxlan 

type MockInterfaceDeviceVxlan struct {
	mock.Mock
}

func (*MockInterfaceDeviceVxlan) Ageing 

func (v *MockInterfaceDeviceVxlan) Ageing() proxy.PropUint32

func (*MockInterfaceDeviceVxlan) ConnectSignalPropertiesChanged 

func (v *MockInterfaceDeviceVxlan) ConnectSignalPropertiesChanged(cb func(properties map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error)

func (*MockInterfaceDeviceVxlan) DstPort 

func (v *MockInterfaceDeviceVxlan) DstPort() proxy.PropUint16

func (*MockInterfaceDeviceVxlan) Group 

func (v *MockInterfaceDeviceVxlan) Group() proxy.PropString

func (*MockInterfaceDeviceVxlan) HwAddress 

func (v *MockInterfaceDeviceVxlan) HwAddress() proxy.PropString

func (*MockInterfaceDeviceVxlan) Id 

func (v *MockInterfaceDeviceVxlan) Id() proxy.PropUint32

func (*MockInterfaceDeviceVxlan) L2miss 

func (v *MockInterfaceDeviceVxlan) L2miss() proxy.PropBool

func (*MockInterfaceDeviceVxlan) L3miss 

func (v *MockInterfaceDeviceVxlan) L3miss() proxy.PropBool

func (*MockInterfaceDeviceVxlan) Learning 

func (v *MockInterfaceDeviceVxlan) Learning() proxy.PropBool

func (*MockInterfaceDeviceVxlan) Limit 

func (v *MockInterfaceDeviceVxlan) Limit() proxy.PropUint32

func (*MockInterfaceDeviceVxlan) Local 

func (v *MockInterfaceDeviceVxlan) Local() proxy.PropString

func (*MockInterfaceDeviceVxlan) Parent 

func (v *MockInterfaceDeviceVxlan) Parent() proxy.PropObjectPath

func (*MockInterfaceDeviceVxlan) Proxy 

func (v *MockInterfaceDeviceVxlan) Proxy() proxy.PropBool

func (*MockInterfaceDeviceVxlan) Rsc 

func (v *MockInterfaceDeviceVxlan) Rsc() proxy.PropBool

func (*MockInterfaceDeviceVxlan) SrcPortMax 

func (v *MockInterfaceDeviceVxlan) SrcPortMax() proxy.PropUint16

func (*MockInterfaceDeviceVxlan) SrcPortMin 

func (v *MockInterfaceDeviceVxlan) SrcPortMin() proxy.PropUint16

func (*MockInterfaceDeviceVxlan) Tos 

func (v *MockInterfaceDeviceVxlan) Tos() proxy.PropByte

func (*MockInterfaceDeviceVxlan) Ttl 

func (v *MockInterfaceDeviceVxlan) Ttl() proxy.PropByte

type MockInterfaceDeviceWiMax 

type MockInterfaceDeviceWiMax struct {
	mock.Mock
}

func (*MockInterfaceDeviceWiMax) ActiveNsp 

func (v *MockInterfaceDeviceWiMax) ActiveNsp() proxy.PropObjectPath

func (*MockInterfaceDeviceWiMax) Bsid 

func (v *MockInterfaceDeviceWiMax) Bsid() proxy.PropString

func (*MockInterfaceDeviceWiMax) CenterFrequency 

func (v *MockInterfaceDeviceWiMax) CenterFrequency() proxy.PropUint32

func (*MockInterfaceDeviceWiMax) Cinr 

func (v *MockInterfaceDeviceWiMax) Cinr() proxy.PropInt32

func (*MockInterfaceDeviceWiMax) ConnectNspAdded 

func (v *MockInterfaceDeviceWiMax) ConnectNspAdded(cb func(nsp dbus.ObjectPath)) (dbusutil.SignalHandlerId, error)

func (*MockInterfaceDeviceWiMax) ConnectNspRemoved 

func (v *MockInterfaceDeviceWiMax) ConnectNspRemoved(cb func(nsp dbus.ObjectPath)) (dbusutil.SignalHandlerId, error)

func (*MockInterfaceDeviceWiMax) ConnectSignalPropertiesChanged 

func (v *MockInterfaceDeviceWiMax) ConnectSignalPropertiesChanged(cb func(properties map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error)

func (*MockInterfaceDeviceWiMax) GetNspList 

func (v *MockInterfaceDeviceWiMax) GetNspList(flags dbus.Flags) ([]dbus.ObjectPath, error)

func (*MockInterfaceDeviceWiMax) GoGetNspList 

func (v *MockInterfaceDeviceWiMax) GoGetNspList(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call

func (*MockInterfaceDeviceWiMax) HwAddress 

func (v *MockInterfaceDeviceWiMax) HwAddress() proxy.PropString

func (*MockInterfaceDeviceWiMax) Nsps 

func (v *MockInterfaceDeviceWiMax) Nsps() proxy.PropObjectPathArray

func (*MockInterfaceDeviceWiMax) Rssi 

func (v *MockInterfaceDeviceWiMax) Rssi() proxy.PropInt32

func (*MockInterfaceDeviceWiMax) TxPower 

func (v *MockInterfaceDeviceWiMax) TxPower() proxy.PropInt32

type MockInterfaceDeviceWired 

type MockInterfaceDeviceWired struct {
	mock.Mock
}

func (*MockInterfaceDeviceWired) Carrier 

func (v *MockInterfaceDeviceWired) Carrier() proxy.PropBool

func (*MockInterfaceDeviceWired) ConnectSignalPropertiesChanged 

func (v *MockInterfaceDeviceWired) ConnectSignalPropertiesChanged(cb func(properties map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error)

func (*MockInterfaceDeviceWired) HwAddress 

func (v *MockInterfaceDeviceWired) HwAddress() proxy.PropString

func (*MockInterfaceDeviceWired) PermHwAddress 

func (v *MockInterfaceDeviceWired) PermHwAddress() proxy.PropString

func (*MockInterfaceDeviceWired) S390Subchannels 

func (v *MockInterfaceDeviceWired) S390Subchannels() proxy.PropStringArray

func (*MockInterfaceDeviceWired) Speed 

func (v *MockInterfaceDeviceWired) Speed() proxy.PropUint32

type MockInterfaceDeviceWireless 

type MockInterfaceDeviceWireless struct {
	mock.Mock
}

func (*MockInterfaceDeviceWireless) AccessPoints 

func (v *MockInterfaceDeviceWireless) AccessPoints() proxy.PropObjectPathArray

func (*MockInterfaceDeviceWireless) ActiveAccessPoint 

func (v *MockInterfaceDeviceWireless) ActiveAccessPoint() proxy.PropObjectPath

func (*MockInterfaceDeviceWireless) Bitrate 

func (v *MockInterfaceDeviceWireless) Bitrate() proxy.PropUint32

func (*MockInterfaceDeviceWireless) ConnectAccessPointAdded 

func (v *MockInterfaceDeviceWireless) ConnectAccessPointAdded(cb func(access_point dbus.ObjectPath)) (dbusutil.SignalHandlerId, error)

func (*MockInterfaceDeviceWireless) ConnectAccessPointRemoved 

func (v *MockInterfaceDeviceWireless) ConnectAccessPointRemoved(cb func(access_point dbus.ObjectPath)) (dbusutil.SignalHandlerId, error)

func (*MockInterfaceDeviceWireless) ConnectSignalPropertiesChanged 

func (v *MockInterfaceDeviceWireless) ConnectSignalPropertiesChanged(cb func(properties map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error)

func (*MockInterfaceDeviceWireless) GetAccessPoints 

func (v *MockInterfaceDeviceWireless) GetAccessPoints(flags dbus.Flags) ([]dbus.ObjectPath, error)

func (*MockInterfaceDeviceWireless) GetAllAccessPoints 

func (v *MockInterfaceDeviceWireless) GetAllAccessPoints(flags dbus.Flags) ([]dbus.ObjectPath, error)

func (*MockInterfaceDeviceWireless) GoGetAccessPoints 

func (v *MockInterfaceDeviceWireless) GoGetAccessPoints(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call

func (*MockInterfaceDeviceWireless) GoGetAllAccessPoints 

func (v *MockInterfaceDeviceWireless) GoGetAllAccessPoints(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call

func (*MockInterfaceDeviceWireless) GoRequestScan 

func (v *MockInterfaceDeviceWireless) GoRequestScan(flags dbus.Flags, ch chan *dbus.Call, options map[string]dbus.Variant) *dbus.Call

func (*MockInterfaceDeviceWireless) HwAddress 

func (v *MockInterfaceDeviceWireless) HwAddress() proxy.PropString

func (*MockInterfaceDeviceWireless) LastScan 

func (v *MockInterfaceDeviceWireless) LastScan() proxy.PropInt64

func (*MockInterfaceDeviceWireless) Mode 

func (v *MockInterfaceDeviceWireless) Mode() proxy.PropUint32

func (*MockInterfaceDeviceWireless) PermHwAddress 

func (v *MockInterfaceDeviceWireless) PermHwAddress() proxy.PropString

func (*MockInterfaceDeviceWireless) RequestScan 

func (v *MockInterfaceDeviceWireless) RequestScan(flags dbus.Flags, options map[string]dbus.Variant) error

func (*MockInterfaceDeviceWireless) WirelessCapabilities 

func (v *MockInterfaceDeviceWireless) WirelessCapabilities() proxy.PropUint32

type MockInterfaceDhcp4Config 

type MockInterfaceDhcp4Config struct {
	mock.Mock
}

func (*MockInterfaceDhcp4Config) ConnectSignalPropertiesChanged 

func (v *MockInterfaceDhcp4Config) ConnectSignalPropertiesChanged(cb func(properties map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error)

func (*MockInterfaceDhcp4Config) Options 

func (v *MockInterfaceDhcp4Config) Options() PropMapStringVariant

type MockInterfaceDhcp6Config 

type MockInterfaceDhcp6Config struct {
	mock.Mock
}

func (*MockInterfaceDhcp6Config) ConnectSignalPropertiesChanged 

func (v *MockInterfaceDhcp6Config) ConnectSignalPropertiesChanged(cb func(properties map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error)

func (*MockInterfaceDhcp6Config) Options 

func (v *MockInterfaceDhcp6Config) Options() PropMapStringVariant

type MockInterfaceDnsManager 

type MockInterfaceDnsManager struct {
	mock.Mock
}

func (*MockInterfaceDnsManager) Configuration 

func (v *MockInterfaceDnsManager) Configuration() PropMapSVSlice

func (*MockInterfaceDnsManager) Mode 

func (v *MockInterfaceDnsManager) Mode() proxy.PropString

func (*MockInterfaceDnsManager) RcManager 

func (v *MockInterfaceDnsManager) RcManager() proxy.PropString

type MockInterfaceIp4Config 

type MockInterfaceIp4Config struct {
	mock.Mock
}

func (*MockInterfaceIp4Config) AddressData 

func (v *MockInterfaceIp4Config) AddressData() PropMapSVSlice

func (*MockInterfaceIp4Config) Addresses 

func (v *MockInterfaceIp4Config) Addresses() PropUint32SliceSlice

func (*MockInterfaceIp4Config) ConnectSignalPropertiesChanged 

func (v *MockInterfaceIp4Config) ConnectSignalPropertiesChanged(cb func(properties map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error)

func (*MockInterfaceIp4Config) DnsOptions 

func (v *MockInterfaceIp4Config) DnsOptions() proxy.PropStringArray

func (*MockInterfaceIp4Config) DnsPriority 

func (v *MockInterfaceIp4Config) DnsPriority() proxy.PropInt32

func (*MockInterfaceIp4Config) Domains 

func (v *MockInterfaceIp4Config) Domains() proxy.PropStringArray

func (*MockInterfaceIp4Config) Gateway 

func (v *MockInterfaceIp4Config) Gateway() proxy.PropString

func (*MockInterfaceIp4Config) Nameservers 

func (v *MockInterfaceIp4Config) Nameservers() proxy.PropUint32Array

func (*MockInterfaceIp4Config) RouteData 

func (v *MockInterfaceIp4Config) RouteData() PropMapSVSlice

func (*MockInterfaceIp4Config) Routes 

func (v *MockInterfaceIp4Config) Routes() PropUint32SliceSlice

func (*MockInterfaceIp4Config) Searches 

func (v *MockInterfaceIp4Config) Searches() proxy.PropStringArray

func (*MockInterfaceIp4Config) WinsServers 

func (v *MockInterfaceIp4Config) WinsServers() proxy.PropUint32Array

type MockInterfaceIp6Config 

type MockInterfaceIp6Config struct {
	mock.Mock
}

func (*MockInterfaceIp6Config) AddressData 

func (v *MockInterfaceIp6Config) AddressData() PropMapSVSlice

func (*MockInterfaceIp6Config) Addresses 

func (v *MockInterfaceIp6Config) Addresses() PropIP6ConfigAddresses

func (*MockInterfaceIp6Config) ConnectSignalPropertiesChanged 

func (v *MockInterfaceIp6Config) ConnectSignalPropertiesChanged(cb func(properties map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error)

func (*MockInterfaceIp6Config) DnsOptions 

func (v *MockInterfaceIp6Config) DnsOptions() proxy.PropStringArray

func (*MockInterfaceIp6Config) DnsPriority 

func (v *MockInterfaceIp6Config) DnsPriority() proxy.PropInt32

func (*MockInterfaceIp6Config) Domains 

func (v *MockInterfaceIp6Config) Domains() proxy.PropStringArray

func (*MockInterfaceIp6Config) Gateway 

func (v *MockInterfaceIp6Config) Gateway() proxy.PropString

func (*MockInterfaceIp6Config) Nameservers 

func (v *MockInterfaceIp6Config) Nameservers() PropIP6NameServers

func (*MockInterfaceIp6Config) RouteData 

func (v *MockInterfaceIp6Config) RouteData() PropMapSVSlice

func (*MockInterfaceIp6Config) Routes 

func (v *MockInterfaceIp6Config) Routes() PropIP6ConfigRoutes

func (*MockInterfaceIp6Config) Searches 

func (v *MockInterfaceIp6Config) Searches() proxy.PropStringArray

type MockInterfaceManager 

type MockInterfaceManager struct {
	mock.Mock
}

func (*MockInterfaceManager) ActivateConnection 

func (v *MockInterfaceManager) ActivateConnection(flags dbus.Flags, connection dbus.ObjectPath, device dbus.ObjectPath, specific_object dbus.ObjectPath) (dbus.ObjectPath, error)

func (*MockInterfaceManager) ActivatingConnection 

func (v *MockInterfaceManager) ActivatingConnection() proxy.PropObjectPath

func (*MockInterfaceManager) ActiveConnections 

func (v *MockInterfaceManager) ActiveConnections() proxy.PropObjectPathArray

func (*MockInterfaceManager) AddAndActivateConnection 

func (v *MockInterfaceManager) AddAndActivateConnection(flags dbus.Flags, connection map[string]map[string]dbus.Variant, device dbus.ObjectPath, specific_object dbus.ObjectPath) (dbus.ObjectPath, dbus.ObjectPath, error)

func (*MockInterfaceManager) AllDevices 

func (v *MockInterfaceManager) AllDevices() proxy.PropObjectPathArray

func (*MockInterfaceManager) Capabilities 

func (v *MockInterfaceManager) Capabilities() proxy.PropUint32Array

func (*MockInterfaceManager) CheckConnectivity 

func (v *MockInterfaceManager) CheckConnectivity(flags dbus.Flags) (uint32, error)

func (*MockInterfaceManager) CheckpointCreate 

func (v *MockInterfaceManager) CheckpointCreate(flags dbus.Flags, devices []dbus.ObjectPath, rollback_timeout uint32, flags0 uint32) (dbus.ObjectPath, error)

func (*MockInterfaceManager) CheckpointDestroy 

func (v *MockInterfaceManager) CheckpointDestroy(flags dbus.Flags, checkpoint dbus.ObjectPath) error

func (*MockInterfaceManager) CheckpointRollback 

func (v *MockInterfaceManager) CheckpointRollback(flags dbus.Flags, checkpoint dbus.ObjectPath) (map[string]uint32, error)

func (*MockInterfaceManager) ConnectCheckPermissions 

func (v *MockInterfaceManager) ConnectCheckPermissions(cb func()) (dbusutil.SignalHandlerId, error)

func (*MockInterfaceManager) ConnectDeviceAdded 

func (v *MockInterfaceManager) ConnectDeviceAdded(cb func(device_path dbus.ObjectPath)) (dbusutil.SignalHandlerId, error)

func (*MockInterfaceManager) ConnectDeviceRemoved 

func (v *MockInterfaceManager) ConnectDeviceRemoved(cb func(device_path dbus.ObjectPath)) (dbusutil.SignalHandlerId, error)

func (*MockInterfaceManager) ConnectSignalPropertiesChanged 

func (v *MockInterfaceManager) ConnectSignalPropertiesChanged(cb func(properties map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error)

func (*MockInterfaceManager) ConnectStateChanged 

func (v *MockInterfaceManager) ConnectStateChanged(cb func(state uint32)) (dbusutil.SignalHandlerId, error)

func (*MockInterfaceManager) Connectivity 

func (v *MockInterfaceManager) Connectivity() proxy.PropUint32

func (*MockInterfaceManager) DeactivateConnection 

func (v *MockInterfaceManager) DeactivateConnection(flags dbus.Flags, active_connection dbus.ObjectPath) error

func (*MockInterfaceManager) Devices 

func (v *MockInterfaceManager) Devices() proxy.PropObjectPathArray

func (*MockInterfaceManager) Enable 

func (v *MockInterfaceManager) Enable(flags dbus.Flags, enable bool) error

func (*MockInterfaceManager) GetAllDevices 

func (v *MockInterfaceManager) GetAllDevices(flags dbus.Flags) ([]dbus.ObjectPath, error)

func (*MockInterfaceManager) GetDeviceByIpIface 

func (v *MockInterfaceManager) GetDeviceByIpIface(flags dbus.Flags, iface string) (dbus.ObjectPath, error)

func (*MockInterfaceManager) GetDevices 

func (v *MockInterfaceManager) GetDevices(flags dbus.Flags) ([]dbus.ObjectPath, error)

func (*MockInterfaceManager) GetLogging 

func (v *MockInterfaceManager) GetLogging(flags dbus.Flags) (string, string, error)

func (*MockInterfaceManager) GetPermissions 

func (v *MockInterfaceManager) GetPermissions(flags dbus.Flags) (map[string]string, error)

func (*MockInterfaceManager) GlobalDnsConfiguration 

func (v *MockInterfaceManager) GlobalDnsConfiguration() PropMapStringVariant

func (*MockInterfaceManager) GoActivateConnection 

func (v *MockInterfaceManager) GoActivateConnection(flags dbus.Flags, ch chan *dbus.Call, connection dbus.ObjectPath, device dbus.ObjectPath, specific_object dbus.ObjectPath) *dbus.Call

func (*MockInterfaceManager) GoAddAndActivateConnection 

func (v *MockInterfaceManager) GoAddAndActivateConnection(flags dbus.Flags, ch chan *dbus.Call, connection map[string]map[string]dbus.Variant, device dbus.ObjectPath, specific_object dbus.ObjectPath) *dbus.Call

func (*MockInterfaceManager) GoCheckConnectivity 

func (v *MockInterfaceManager) GoCheckConnectivity(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call

func (*MockInterfaceManager) GoCheckpointCreate 

func (v *MockInterfaceManager) GoCheckpointCreate(flags dbus.Flags, ch chan *dbus.Call, devices []dbus.ObjectPath, rollback_timeout uint32, flags0 uint32) *dbus.Call

func (*MockInterfaceManager) GoCheckpointDestroy 

func (v *MockInterfaceManager) GoCheckpointDestroy(flags dbus.Flags, ch chan *dbus.Call, checkpoint dbus.ObjectPath) *dbus.Call

func (*MockInterfaceManager) GoCheckpointRollback 

func (v *MockInterfaceManager) GoCheckpointRollback(flags dbus.Flags, ch chan *dbus.Call, checkpoint dbus.ObjectPath) *dbus.Call

func (*MockInterfaceManager) GoDeactivateConnection 

func (v *MockInterfaceManager) GoDeactivateConnection(flags dbus.Flags, ch chan *dbus.Call, active_connection dbus.ObjectPath) *dbus.Call

func (*MockInterfaceManager) GoEnable 

func (v *MockInterfaceManager) GoEnable(flags dbus.Flags, ch chan *dbus.Call, enable bool) *dbus.Call

func (*MockInterfaceManager) GoGetAllDevices 

func (v *MockInterfaceManager) GoGetAllDevices(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call

func (*MockInterfaceManager) GoGetDeviceByIpIface 

func (v *MockInterfaceManager) GoGetDeviceByIpIface(flags dbus.Flags, ch chan *dbus.Call, iface string) *dbus.Call

func (*MockInterfaceManager) GoGetDevices 

func (v *MockInterfaceManager) GoGetDevices(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call

func (*MockInterfaceManager) GoGetLogging 

func (v *MockInterfaceManager) GoGetLogging(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call

func (*MockInterfaceManager) GoGetPermissions 

func (v *MockInterfaceManager) GoGetPermissions(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call

func (*MockInterfaceManager) GoReload 

func (v *MockInterfaceManager) GoReload(flags dbus.Flags, ch chan *dbus.Call, flags0 uint32) *dbus.Call

func (*MockInterfaceManager) GoSetLogging 

func (v *MockInterfaceManager) GoSetLogging(flags dbus.Flags, ch chan *dbus.Call, level string, domains string) *dbus.Call

func (*MockInterfaceManager) GoSleep 

func (v *MockInterfaceManager) GoSleep(flags dbus.Flags, ch chan *dbus.Call, sleep bool) *dbus.Call

func (*MockInterfaceManager) GoState 

func (v *MockInterfaceManager) GoState(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call

func (*MockInterfaceManager) Metered 

func (v *MockInterfaceManager) Metered() proxy.PropUint32

func (*MockInterfaceManager) NetworkingEnabled 

func (v *MockInterfaceManager) NetworkingEnabled() proxy.PropBool

func (*MockInterfaceManager) PrimaryConnection 

func (v *MockInterfaceManager) PrimaryConnection() proxy.PropObjectPath

func (*MockInterfaceManager) PrimaryConnectionType 

func (v *MockInterfaceManager) PrimaryConnectionType() proxy.PropString

func (*MockInterfaceManager) PropState 

func (v *MockInterfaceManager) PropState() proxy.PropUint32

func (*MockInterfaceManager) Reload 

func (v *MockInterfaceManager) Reload(flags dbus.Flags, flags0 uint32) error

func (*MockInterfaceManager) SetLogging 

func (v *MockInterfaceManager) SetLogging(flags dbus.Flags, level string, domains string) error

func (*MockInterfaceManager) Sleep 

func (v *MockInterfaceManager) Sleep(flags dbus.Flags, sleep bool) error

func (*MockInterfaceManager) Startup 

func (v *MockInterfaceManager) Startup() proxy.PropBool

func (*MockInterfaceManager) State 

func (v *MockInterfaceManager) State(flags dbus.Flags) (uint32, error)

func (*MockInterfaceManager) Version 

func (v *MockInterfaceManager) Version() proxy.PropString

func (*MockInterfaceManager) WimaxEnabled 

func (v *MockInterfaceManager) WimaxEnabled() proxy.PropBool

func (*MockInterfaceManager) WimaxHardwareEnabled 

func (v *MockInterfaceManager) WimaxHardwareEnabled() proxy.PropBool

func (*MockInterfaceManager) WirelessEnabled 

func (v *MockInterfaceManager) WirelessEnabled() proxy.PropBool

func (*MockInterfaceManager) WirelessHardwareEnabled 

func (v *MockInterfaceManager) WirelessHardwareEnabled() proxy.PropBool

func (*MockInterfaceManager) WwanEnabled 

func (v *MockInterfaceManager) WwanEnabled() proxy.PropBool

func (*MockInterfaceManager) WwanHardwareEnabled 

func (v *MockInterfaceManager) WwanHardwareEnabled() proxy.PropBool

type MockInterfacePpp 

type MockInterfacePpp struct {
	mock.Mock
}

func (*MockInterfacePpp) GoNeedSecrets 

func (v *MockInterfacePpp) GoNeedSecrets(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call

func (*MockInterfacePpp) GoSetIp4Config 

func (v *MockInterfacePpp) GoSetIp4Config(flags dbus.Flags, ch chan *dbus.Call, config map[string]dbus.Variant) *dbus.Call

func (*MockInterfacePpp) GoSetIp6Config 

func (v *MockInterfacePpp) GoSetIp6Config(flags dbus.Flags, ch chan *dbus.Call, config map[string]dbus.Variant) *dbus.Call

func (*MockInterfacePpp) GoSetState 

func (v *MockInterfacePpp) GoSetState(flags dbus.Flags, ch chan *dbus.Call, state uint32) *dbus.Call

func (*MockInterfacePpp) NeedSecrets 

func (v *MockInterfacePpp) NeedSecrets(flags dbus.Flags) (string, string, error)

func (*MockInterfacePpp) SetIp4Config 

func (v *MockInterfacePpp) SetIp4Config(flags dbus.Flags, config map[string]dbus.Variant) error

func (*MockInterfacePpp) SetIp6Config 

func (v *MockInterfacePpp) SetIp6Config(flags dbus.Flags, config map[string]dbus.Variant) error

func (*MockInterfacePpp) SetState 

func (v *MockInterfacePpp) SetState(flags dbus.Flags, state uint32) error

type MockInterfaceSecretAgent 

type MockInterfaceSecretAgent struct {
	mock.Mock
}

func (*MockInterfaceSecretAgent) CancelGetSecrets 

func (v *MockInterfaceSecretAgent) CancelGetSecrets(flags dbus.Flags, connection_path dbus.ObjectPath, setting_name string) error

func (*MockInterfaceSecretAgent) DeleteSecrets 

func (v *MockInterfaceSecretAgent) DeleteSecrets(flags dbus.Flags, connection map[string]map[string]dbus.Variant, connection_path dbus.ObjectPath) error

func (*MockInterfaceSecretAgent) GetSecrets 

func (v *MockInterfaceSecretAgent) GetSecrets(flags dbus.Flags, connection map[string]map[string]dbus.Variant, connection_path dbus.ObjectPath, setting_name string, hints []string, flags0 uint32) (map[string]map[string]dbus.Variant, error)

func (*MockInterfaceSecretAgent) GoCancelGetSecrets 

func (v *MockInterfaceSecretAgent) GoCancelGetSecrets(flags dbus.Flags, ch chan *dbus.Call, connection_path dbus.ObjectPath, setting_name string) *dbus.Call

func (*MockInterfaceSecretAgent) GoDeleteSecrets 

func (v *MockInterfaceSecretAgent) GoDeleteSecrets(flags dbus.Flags, ch chan *dbus.Call, connection map[string]map[string]dbus.Variant, connection_path dbus.ObjectPath) *dbus.Call

func (*MockInterfaceSecretAgent) GoGetSecrets 

func (v *MockInterfaceSecretAgent) GoGetSecrets(flags dbus.Flags, ch chan *dbus.Call, connection map[string]map[string]dbus.Variant, connection_path dbus.ObjectPath, setting_name string, hints []string, flags0 uint32) *dbus.Call

func (*MockInterfaceSecretAgent) GoSaveSecrets 

func (v *MockInterfaceSecretAgent) GoSaveSecrets(flags dbus.Flags, ch chan *dbus.Call, connection map[string]map[string]dbus.Variant, connection_path dbus.ObjectPath) *dbus.Call

func (*MockInterfaceSecretAgent) SaveSecrets 

func (v *MockInterfaceSecretAgent) SaveSecrets(flags dbus.Flags, connection map[string]map[string]dbus.Variant, connection_path dbus.ObjectPath) error

type MockInterfaceSettings 

type MockInterfaceSettings struct {
	mock.Mock
}

func (*MockInterfaceSettings) AddConnection 

func (v *MockInterfaceSettings) AddConnection(flags dbus.Flags, connection map[string]map[string]dbus.Variant) (dbus.ObjectPath, error)

func (*MockInterfaceSettings) AddConnectionUnsaved 

func (v *MockInterfaceSettings) AddConnectionUnsaved(flags dbus.Flags, connection map[string]map[string]dbus.Variant) (dbus.ObjectPath, error)

func (*MockInterfaceSettings) CanModify 

func (v *MockInterfaceSettings) CanModify() proxy.PropBool

func (*MockInterfaceSettings) ConnectConnectionRemoved 

func (v *MockInterfaceSettings) ConnectConnectionRemoved(cb func(connection dbus.ObjectPath)) (dbusutil.SignalHandlerId, error)

func (*MockInterfaceSettings) ConnectNewConnection 

func (v *MockInterfaceSettings) ConnectNewConnection(cb func(connection dbus.ObjectPath)) (dbusutil.SignalHandlerId, error)

func (*MockInterfaceSettings) ConnectSignalPropertiesChanged 

func (v *MockInterfaceSettings) ConnectSignalPropertiesChanged(cb func(properties map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error)

func (*MockInterfaceSettings) Connections 

func (v *MockInterfaceSettings) Connections() proxy.PropObjectPathArray

func (*MockInterfaceSettings) GetConnectionByUuid 

func (v *MockInterfaceSettings) GetConnectionByUuid(flags dbus.Flags, uuid string) (dbus.ObjectPath, error)

func (*MockInterfaceSettings) GoAddConnection 

func (v *MockInterfaceSettings) GoAddConnection(flags dbus.Flags, ch chan *dbus.Call, connection map[string]map[string]dbus.Variant) *dbus.Call

func (*MockInterfaceSettings) GoAddConnectionUnsaved 

func (v *MockInterfaceSettings) GoAddConnectionUnsaved(flags dbus.Flags, ch chan *dbus.Call, connection map[string]map[string]dbus.Variant) *dbus.Call

func (*MockInterfaceSettings) GoGetConnectionByUuid 

func (v *MockInterfaceSettings) GoGetConnectionByUuid(flags dbus.Flags, ch chan *dbus.Call, uuid string) *dbus.Call

func (*MockInterfaceSettings) GoListConnections 

func (v *MockInterfaceSettings) GoListConnections(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call

func (*MockInterfaceSettings) GoLoadConnections 

func (v *MockInterfaceSettings) GoLoadConnections(flags dbus.Flags, ch chan *dbus.Call, filenames []string) *dbus.Call

func (*MockInterfaceSettings) GoReloadConnections 

func (v *MockInterfaceSettings) GoReloadConnections(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call

func (*MockInterfaceSettings) GoSaveHostname 

func (v *MockInterfaceSettings) GoSaveHostname(flags dbus.Flags, ch chan *dbus.Call, hostname string) *dbus.Call

func (*MockInterfaceSettings) Hostname 

func (v *MockInterfaceSettings) Hostname() proxy.PropString

func (*MockInterfaceSettings) ListConnections 

func (v *MockInterfaceSettings) ListConnections(flags dbus.Flags) ([]dbus.ObjectPath, error)

func (*MockInterfaceSettings) LoadConnections 

func (v *MockInterfaceSettings) LoadConnections(flags dbus.Flags, filenames []string) (bool, []string, error)

func (*MockInterfaceSettings) ReloadConnections 

func (v *MockInterfaceSettings) ReloadConnections(flags dbus.Flags) (bool, error)

func (*MockInterfaceSettings) SaveHostname 

func (v *MockInterfaceSettings) SaveHostname(flags dbus.Flags, hostname string) error

type MockInterfaceVpnConnection 

type MockInterfaceVpnConnection struct {
	mock.Mock
}

func (*MockInterfaceVpnConnection) Banner 

func (v *MockInterfaceVpnConnection) Banner() proxy.PropString

func (*MockInterfaceVpnConnection) ConnectSignalPropertiesChanged 

func (v *MockInterfaceVpnConnection) ConnectSignalPropertiesChanged(cb func(properties map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error)

func (*MockInterfaceVpnConnection) ConnectVpnStateChanged 

func (v *MockInterfaceVpnConnection) ConnectVpnStateChanged(cb func(state uint32, reason uint32)) (dbusutil.SignalHandlerId, error)

func (*MockInterfaceVpnConnection) VpnState 

func (v *MockInterfaceVpnConnection) VpnState() proxy.PropUint32

type MockInterfaceVpnPlugin 

type MockInterfaceVpnPlugin struct {
	mock.Mock
}

func (*MockInterfaceVpnPlugin) Connect 

func (v *MockInterfaceVpnPlugin) Connect(flags dbus.Flags, connection map[string]map[string]dbus.Variant) error

func (*MockInterfaceVpnPlugin) ConnectConfig 

func (v *MockInterfaceVpnPlugin) ConnectConfig(cb func(config map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error)

func (*MockInterfaceVpnPlugin) ConnectFailure 

func (v *MockInterfaceVpnPlugin) ConnectFailure(cb func(reason uint32)) (dbusutil.SignalHandlerId, error)

func (*MockInterfaceVpnPlugin) ConnectInteractive 

func (v *MockInterfaceVpnPlugin) ConnectInteractive(flags dbus.Flags, connection map[string]map[string]dbus.Variant, details map[string]dbus.Variant) error

func (*MockInterfaceVpnPlugin) ConnectIp4Config 

func (v *MockInterfaceVpnPlugin) ConnectIp4Config(cb func(ip4config map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error)

func (*MockInterfaceVpnPlugin) ConnectIp6Config 

func (v *MockInterfaceVpnPlugin) ConnectIp6Config(cb func(ip6config map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error)

func (*MockInterfaceVpnPlugin) ConnectLoginBanner 

func (v *MockInterfaceVpnPlugin) ConnectLoginBanner(cb func(banner string)) (dbusutil.SignalHandlerId, error)

func (*MockInterfaceVpnPlugin) ConnectSecretsRequired 

func (v *MockInterfaceVpnPlugin) ConnectSecretsRequired(cb func(message string, secrets []string)) (dbusutil.SignalHandlerId, error)

func (*MockInterfaceVpnPlugin) ConnectStateChanged 

func (v *MockInterfaceVpnPlugin) ConnectStateChanged(cb func(state uint32)) (dbusutil.SignalHandlerId, error)

func (*MockInterfaceVpnPlugin) Disconnect 

func (v *MockInterfaceVpnPlugin) Disconnect(flags dbus.Flags) error

func (*MockInterfaceVpnPlugin) GoConnect 

func (v *MockInterfaceVpnPlugin) GoConnect(flags dbus.Flags, ch chan *dbus.Call, connection map[string]map[string]dbus.Variant) *dbus.Call

func (*MockInterfaceVpnPlugin) GoConnectInteractive 

func (v *MockInterfaceVpnPlugin) GoConnectInteractive(flags dbus.Flags, ch chan *dbus.Call, connection map[string]map[string]dbus.Variant, details map[string]dbus.Variant) *dbus.Call

func (*MockInterfaceVpnPlugin) GoDisconnect 

func (v *MockInterfaceVpnPlugin) GoDisconnect(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call

func (*MockInterfaceVpnPlugin) GoNeedSecrets 

func (v *MockInterfaceVpnPlugin) GoNeedSecrets(flags dbus.Flags, ch chan *dbus.Call, settings map[string]map[string]dbus.Variant) *dbus.Call

func (*MockInterfaceVpnPlugin) GoNewSecrets 

func (v *MockInterfaceVpnPlugin) GoNewSecrets(flags dbus.Flags, ch chan *dbus.Call, connection map[string]map[string]dbus.Variant) *dbus.Call

func (*MockInterfaceVpnPlugin) GoSetConfig 

func (v *MockInterfaceVpnPlugin) GoSetConfig(flags dbus.Flags, ch chan *dbus.Call, config map[string]dbus.Variant) *dbus.Call

func (*MockInterfaceVpnPlugin) GoSetFailure 

func (v *MockInterfaceVpnPlugin) GoSetFailure(flags dbus.Flags, ch chan *dbus.Call, reason string) *dbus.Call

func (*MockInterfaceVpnPlugin) GoSetIp4Config 

func (v *MockInterfaceVpnPlugin) GoSetIp4Config(flags dbus.Flags, ch chan *dbus.Call, config map[string]dbus.Variant) *dbus.Call

func (*MockInterfaceVpnPlugin) GoSetIp6Config 

func (v *MockInterfaceVpnPlugin) GoSetIp6Config(flags dbus.Flags, ch chan *dbus.Call, config map[string]dbus.Variant) *dbus.Call

func (*MockInterfaceVpnPlugin) NeedSecrets 

func (v *MockInterfaceVpnPlugin) NeedSecrets(flags dbus.Flags, settings map[string]map[string]dbus.Variant) (string, error)

func (*MockInterfaceVpnPlugin) NewSecrets 

func (v *MockInterfaceVpnPlugin) NewSecrets(flags dbus.Flags, connection map[string]map[string]dbus.Variant) error

func (*MockInterfaceVpnPlugin) SetConfig 

func (v *MockInterfaceVpnPlugin) SetConfig(flags dbus.Flags, config map[string]dbus.Variant) error

func (*MockInterfaceVpnPlugin) SetFailure 

func (v *MockInterfaceVpnPlugin) SetFailure(flags dbus.Flags, reason string) error

func (*MockInterfaceVpnPlugin) SetIp4Config 

func (v *MockInterfaceVpnPlugin) SetIp4Config(flags dbus.Flags, config map[string]dbus.Variant) error

func (*MockInterfaceVpnPlugin) SetIp6Config 

func (v *MockInterfaceVpnPlugin) SetIp6Config(flags dbus.Flags, config map[string]dbus.Variant) error

func (*MockInterfaceVpnPlugin) State 

func (v *MockInterfaceVpnPlugin) State() proxy.PropUint32

type MockInterfaceWiMaxNsp 

type MockInterfaceWiMaxNsp struct {
	mock.Mock
}

func (*MockInterfaceWiMaxNsp) ConnectSignalPropertiesChanged 

func (v *MockInterfaceWiMaxNsp) ConnectSignalPropertiesChanged(cb func(properties map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error)

func (*MockInterfaceWiMaxNsp) Name 

func (v *MockInterfaceWiMaxNsp) Name() proxy.PropString

func (*MockInterfaceWiMaxNsp) NetworkType 

func (v *MockInterfaceWiMaxNsp) NetworkType() proxy.PropUint32

func (*MockInterfaceWiMaxNsp) SignalQuality 

func (v *MockInterfaceWiMaxNsp) SignalQuality() proxy.PropUint32

type MockManager 

type MockManager struct {
	MockInterfaceManager // interface org.freedesktop.NetworkManager
	proxy.MockObject
}

type MockObjectManager 

type MockObjectManager struct {
	object_manager.MockInterfaceObjectManager // interface org.freedesktop.DBus.ObjectManager
	proxy.MockObject
}

type MockPPP 

type MockPPP struct {
	MockInterfacePpp // interface org.freedesktop.NetworkManager.PPP
	proxy.MockObject
}

type MockPropDeviceStateReason 

type MockPropDeviceStateReason struct {
	mock.Mock
}

func (MockPropDeviceStateReason) ConnectChanged 

func (p MockPropDeviceStateReason) ConnectChanged(cb func(hasValue bool, value DeviceStateReason)) error

func (MockPropDeviceStateReason) Get 

func (p MockPropDeviceStateReason) Get(flags dbus.Flags) (value DeviceStateReason, err error)

func (MockPropDeviceStateReason) Set 

func (p MockPropDeviceStateReason) Set(flags dbus.Flags, value DeviceStateReason) error

type MockPropIP6ConfigAddresses 

type MockPropIP6ConfigAddresses struct {
	mock.Mock
}

func (MockPropIP6ConfigAddresses) ConnectChanged 

func (p MockPropIP6ConfigAddresses) ConnectChanged(cb func(hasValue bool, value []IP6Address)) error

func (MockPropIP6ConfigAddresses) Get 

func (p MockPropIP6ConfigAddresses) Get(flags dbus.Flags) (value []IP6Address, err error)

func (MockPropIP6ConfigAddresses) Set 

func (p MockPropIP6ConfigAddresses) Set(flags dbus.Flags, value []IP6Address) error

type MockPropIP6ConfigRoutes 

type MockPropIP6ConfigRoutes struct {
	mock.Mock
}

func (MockPropIP6ConfigRoutes) ConnectChanged 

func (p MockPropIP6ConfigRoutes) ConnectChanged(cb func(hasValue bool, value []IP6Route)) error

func (MockPropIP6ConfigRoutes) Get 

func (p MockPropIP6ConfigRoutes) Get(flags dbus.Flags) (value []IP6Route, err error)

func (MockPropIP6ConfigRoutes) Set 

func (p MockPropIP6ConfigRoutes) Set(flags dbus.Flags, value []IP6Route) error

type MockPropIP6NameServers 

type MockPropIP6NameServers struct {
	mock.Mock
}

func (MockPropIP6NameServers) ConnectChanged 

func (p MockPropIP6NameServers) ConnectChanged(cb func(hasValue bool, value [][]byte)) error

func (MockPropIP6NameServers) Get 

func (p MockPropIP6NameServers) Get(flags dbus.Flags) (value [][]byte, err error)

func (MockPropIP6NameServers) Set 

func (p MockPropIP6NameServers) Set(flags dbus.Flags, value [][]byte) error

type MockPropMapSVSlice 

type MockPropMapSVSlice struct {
	mock.Mock
}

func (MockPropMapSVSlice) ConnectChanged 

func (p MockPropMapSVSlice) ConnectChanged(cb func(hasValue bool, value []map[string]dbus.Variant)) error

func (MockPropMapSVSlice) Get 

func (p MockPropMapSVSlice) Get(flags dbus.Flags) (value []map[string]dbus.Variant, err error)

func (MockPropMapSVSlice) Set 

func (p MockPropMapSVSlice) Set(flags dbus.Flags, value []map[string]dbus.Variant) error

type MockPropMapStringVariant 

type MockPropMapStringVariant struct {
	mock.Mock
}

func (MockPropMapStringVariant) ConnectChanged 

func (p MockPropMapStringVariant) ConnectChanged(cb func(hasValue bool, value map[string]dbus.Variant)) error

func (MockPropMapStringVariant) Get 

func (p MockPropMapStringVariant) Get(flags dbus.Flags) (value map[string]dbus.Variant, err error)

func (MockPropMapStringVariant) Set 

func (p MockPropMapStringVariant) Set(flags dbus.Flags, value map[string]dbus.Variant) error

type MockPropUint32SliceSlice 

type MockPropUint32SliceSlice struct {
	mock.Mock
}

func (MockPropUint32SliceSlice) ConnectChanged 

func (p MockPropUint32SliceSlice) ConnectChanged(cb func(hasValue bool, value [][]uint32)) error

func (MockPropUint32SliceSlice) Get 

func (p MockPropUint32SliceSlice) Get(flags dbus.Flags) (value [][]uint32, err error)

func (MockPropUint32SliceSlice) Set 

func (p MockPropUint32SliceSlice) Set(flags dbus.Flags, value [][]uint32) error

type MockSecretAgent 

type MockSecretAgent struct {
	MockInterfaceSecretAgent // interface org.freedesktop.NetworkManager.SecretAgent
	proxy.MockObject
}

type MockSettings 

type MockSettings struct {
	MockInterfaceSettings // interface org.freedesktop.NetworkManager.Settings
	proxy.MockObject
}

type MockVpnConnection 

type MockVpnConnection struct {
	MockInterfaceVpnConnection // interface org.freedesktop.NetworkManager.VPN.Connection
	proxy.MockObject
}

type MockVpnPlugin 

type MockVpnPlugin struct {
	MockInterfaceVpnPlugin // interface org.freedesktop.NetworkManager.VPN.Plugin
	proxy.MockObject
}

type MockWiMaxNsp 

type MockWiMaxNsp struct {
	MockInterfaceWiMaxNsp // interface org.freedesktop.NetworkManager.WiMax.Nsp
	proxy.MockObject
}

type ObjectManager 

type ObjectManager interface {
	object_manager.ObjectManager // interface org.freedesktop.DBus.ObjectManager
	proxy.Object
}

func NewObjectManager 

func NewObjectManager(conn *dbus.Conn) ObjectManager

type PPP 

type PPP interface {
	proxy.Object
	// contains filtered or unexported methods
}

func NewPPP 

func NewPPP(conn *dbus.Conn, path dbus.ObjectPath) (PPP, error)

type PropDeviceStateReason 

type PropDeviceStateReason interface {
	Get(flags dbus.Flags) (value DeviceStateReason, err error)
	Set(flags dbus.Flags, value DeviceStateReason) error
	ConnectChanged(cb func(hasValue bool, value DeviceStateReason)) error
}

type PropIP6ConfigAddresses 

type PropIP6ConfigAddresses interface {
	Get(flags dbus.Flags) (value []IP6Address, err error)
	Set(flags dbus.Flags, value []IP6Address) error
	ConnectChanged(cb func(hasValue bool, value []IP6Address)) error
}

type PropIP6ConfigRoutes 

type PropIP6ConfigRoutes interface {
	Get(flags dbus.Flags) (value []IP6Route, err error)
	Set(flags dbus.Flags, value []IP6Route) error
	ConnectChanged(cb func(hasValue bool, value []IP6Route)) error
}

type PropIP6NameServers 

type PropIP6NameServers interface {
	Get(flags dbus.Flags) (value [][]byte, err error)
	Set(flags dbus.Flags, value [][]byte) error
	ConnectChanged(cb func(hasValue bool, value [][]byte)) error
}

type PropMapSVSlice 

type PropMapSVSlice interface {
	Get(flags dbus.Flags) (value []map[string]dbus.Variant, err error)
	Set(flags dbus.Flags, value []map[string]dbus.Variant) error
	ConnectChanged(cb func(hasValue bool, value []map[string]dbus.Variant)) error
}

type PropMapStringVariant 

type PropMapStringVariant interface {
	Get(flags dbus.Flags) (value map[string]dbus.Variant, err error)
	Set(flags dbus.Flags, value map[string]dbus.Variant) error
	ConnectChanged(cb func(hasValue bool, value map[string]dbus.Variant)) error
}

type PropUint32SliceSlice 

type PropUint32SliceSlice interface {
	Get(flags dbus.Flags) (value [][]uint32, err error)
	Set(flags dbus.Flags, value [][]uint32) error
	ConnectChanged(cb func(hasValue bool, value [][]uint32)) error
}

type SecretAgent 

type SecretAgent interface {
	proxy.Object
	// contains filtered or unexported methods
}

func NewSecretAgent 

func NewSecretAgent(conn *dbus.Conn, path dbus.ObjectPath) (SecretAgent, error)

type Settings 

type Settings interface {
	proxy.Object
	// contains filtered or unexported methods
}

func NewSettings 

func NewSettings(conn *dbus.Conn) Settings

type VpnConnection 

type VpnConnection interface {
	proxy.Object
	// contains filtered or unexported methods
}

func NewVpnConnection 

func NewVpnConnection(conn *dbus.Conn, path dbus.ObjectPath) (VpnConnection, error)

type VpnPlugin 

type VpnPlugin interface {
	proxy.Object
	// contains filtered or unexported methods
}

func NewVpnPlugin 

func NewVpnPlugin(conn *dbus.Conn, path dbus.ObjectPath) (VpnPlugin, error)

type WiMaxNsp 

type WiMaxNsp interface {
	proxy.Object
	// contains filtered or unexported methods
}

func NewWiMaxNsp 

func NewWiMaxNsp(conn *dbus.Conn, path dbus.ObjectPath) (WiMaxNsp, error)

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.