provider/lxd/package_mock_test.go

// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/juju/juju/provider/lxd (interfaces: Server,ServerFactory,InterfaceAddress,CertificateReadWriter,CertificateGenerator,NetLookup,LXCConfigReader)

// Package lxd is a generated GoMock package.
package lxd

import (
	net "net"
	reflect "reflect"

	gomock "github.com/golang/mock/gomock"
	lxd "github.com/juju/juju/container/lxd"
	network "github.com/juju/juju/core/network"
	environs "github.com/juju/juju/environs"
	cloudspec "github.com/juju/juju/environs/cloudspec"
	client "github.com/lxc/lxd/client"
	api "github.com/lxc/lxd/shared/api"
)

// MockServer is a mock of Server interface.
type MockServer struct {
	ctrl     *gomock.Controller
	recorder *MockServerMockRecorder
}

// MockServerMockRecorder is the mock recorder for MockServer.
type MockServerMockRecorder struct {
	mock *MockServer
}

// NewMockServer creates a new mock instance.
func NewMockServer(ctrl *gomock.Controller) *MockServer {
	mock := &MockServer{ctrl: ctrl}
	mock.recorder = &MockServerMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockServer) EXPECT() *MockServerMockRecorder {
	return m.recorder
}

// AliveContainers mocks base method.
func (m *MockServer) AliveContainers(arg0 string) ([]lxd.Container, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AliveContainers", arg0)
	ret0, _ := ret[0].([]lxd.Container)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AliveContainers indicates an expected call of AliveContainers.
func (mr *MockServerMockRecorder) AliveContainers(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AliveContainers", reflect.TypeOf((*MockServer)(nil).AliveContainers), arg0)
}

// ContainerAddresses mocks base method.
func (m *MockServer) ContainerAddresses(arg0 string) ([]network.ProviderAddress, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ContainerAddresses", arg0)
	ret0, _ := ret[0].([]network.ProviderAddress)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ContainerAddresses indicates an expected call of ContainerAddresses.
func (mr *MockServerMockRecorder) ContainerAddresses(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerAddresses", reflect.TypeOf((*MockServer)(nil).ContainerAddresses), arg0)
}

// CreateCertificate mocks base method.
func (m *MockServer) CreateCertificate(arg0 api.CertificatesPost) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateCertificate", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateCertificate indicates an expected call of CreateCertificate.
func (mr *MockServerMockRecorder) CreateCertificate(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCertificate", reflect.TypeOf((*MockServer)(nil).CreateCertificate), arg0)
}

// CreateClientCertificate mocks base method.
func (m *MockServer) CreateClientCertificate(arg0 *lxd.Certificate) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateClientCertificate", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateClientCertificate indicates an expected call of CreateClientCertificate.
func (mr *MockServerMockRecorder) CreateClientCertificate(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateClientCertificate", reflect.TypeOf((*MockServer)(nil).CreateClientCertificate), arg0)
}

// CreateContainerFromSpec mocks base method.
func (m *MockServer) CreateContainerFromSpec(arg0 lxd.ContainerSpec) (*lxd.Container, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateContainerFromSpec", arg0)
	ret0, _ := ret[0].(*lxd.Container)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateContainerFromSpec indicates an expected call of CreateContainerFromSpec.
func (mr *MockServerMockRecorder) CreateContainerFromSpec(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateContainerFromSpec", reflect.TypeOf((*MockServer)(nil).CreateContainerFromSpec), arg0)
}

// CreatePool mocks base method.
func (m *MockServer) CreatePool(arg0, arg1 string, arg2 map[string]string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreatePool", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreatePool indicates an expected call of CreatePool.
func (mr *MockServerMockRecorder) CreatePool(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePool", reflect.TypeOf((*MockServer)(nil).CreatePool), arg0, arg1, arg2)
}

// CreateProfile mocks base method.
func (m *MockServer) CreateProfile(arg0 api.ProfilesPost) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateProfile", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateProfile indicates an expected call of CreateProfile.
func (mr *MockServerMockRecorder) CreateProfile(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateProfile", reflect.TypeOf((*MockServer)(nil).CreateProfile), arg0)
}

// CreateProfileWithConfig mocks base method.
func (m *MockServer) CreateProfileWithConfig(arg0 string, arg1 map[string]string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateProfileWithConfig", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateProfileWithConfig indicates an expected call of CreateProfileWithConfig.
func (mr *MockServerMockRecorder) CreateProfileWithConfig(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateProfileWithConfig", reflect.TypeOf((*MockServer)(nil).CreateProfileWithConfig), arg0, arg1)
}

// CreateVolume mocks base method.
func (m *MockServer) CreateVolume(arg0, arg1 string, arg2 map[string]string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateVolume", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateVolume indicates an expected call of CreateVolume.
func (mr *MockServerMockRecorder) CreateVolume(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVolume", reflect.TypeOf((*MockServer)(nil).CreateVolume), arg0, arg1, arg2)
}

// DeleteCertificate mocks base method.
func (m *MockServer) DeleteCertificate(arg0 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteCertificate", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteCertificate indicates an expected call of DeleteCertificate.
func (mr *MockServerMockRecorder) DeleteCertificate(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCertificate", reflect.TypeOf((*MockServer)(nil).DeleteCertificate), arg0)
}

// DeleteProfile mocks base method.
func (m *MockServer) DeleteProfile(arg0 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteProfile", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteProfile indicates an expected call of DeleteProfile.
func (mr *MockServerMockRecorder) DeleteProfile(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteProfile", reflect.TypeOf((*MockServer)(nil).DeleteProfile), arg0)
}

// DeleteStoragePoolVolume mocks base method.
func (m *MockServer) DeleteStoragePoolVolume(arg0, arg1, arg2 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteStoragePoolVolume", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteStoragePoolVolume indicates an expected call of DeleteStoragePoolVolume.
func (mr *MockServerMockRecorder) DeleteStoragePoolVolume(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteStoragePoolVolume", reflect.TypeOf((*MockServer)(nil).DeleteStoragePoolVolume), arg0, arg1, arg2)
}

// EnableHTTPSListener mocks base method.
func (m *MockServer) EnableHTTPSListener() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnableHTTPSListener")
	ret0, _ := ret[0].(error)
	return ret0
}

// EnableHTTPSListener indicates an expected call of EnableHTTPSListener.
func (mr *MockServerMockRecorder) EnableHTTPSListener() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableHTTPSListener", reflect.TypeOf((*MockServer)(nil).EnableHTTPSListener))
}

// EnsureDefaultStorage mocks base method.
func (m *MockServer) EnsureDefaultStorage(arg0 *api.Profile, arg1 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnsureDefaultStorage", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// EnsureDefaultStorage indicates an expected call of EnsureDefaultStorage.
func (mr *MockServerMockRecorder) EnsureDefaultStorage(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnsureDefaultStorage", reflect.TypeOf((*MockServer)(nil).EnsureDefaultStorage), arg0, arg1)
}

// FilterContainers mocks base method.
func (m *MockServer) FilterContainers(arg0 string, arg1 ...string) ([]lxd.Container, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "FilterContainers", varargs...)
	ret0, _ := ret[0].([]lxd.Container)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FilterContainers indicates an expected call of FilterContainers.
func (mr *MockServerMockRecorder) FilterContainers(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FilterContainers", reflect.TypeOf((*MockServer)(nil).FilterContainers), varargs...)
}

// FindImage mocks base method.
func (m *MockServer) FindImage(arg0, arg1 string, arg2 []lxd.ServerSpec, arg3 bool, arg4 environs.StatusCallbackFunc) (lxd.SourcedImage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FindImage", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].(lxd.SourcedImage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FindImage indicates an expected call of FindImage.
func (mr *MockServerMockRecorder) FindImage(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindImage", reflect.TypeOf((*MockServer)(nil).FindImage), arg0, arg1, arg2, arg3, arg4)
}

// GetCertificate mocks base method.
func (m *MockServer) GetCertificate(arg0 string) (*api.Certificate, string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCertificate", arg0)
	ret0, _ := ret[0].(*api.Certificate)
	ret1, _ := ret[1].(string)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetCertificate indicates an expected call of GetCertificate.
func (mr *MockServerMockRecorder) GetCertificate(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCertificate", reflect.TypeOf((*MockServer)(nil).GetCertificate), arg0)
}

// GetClusterMembers mocks base method.
func (m *MockServer) GetClusterMembers() ([]api.ClusterMember, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetClusterMembers")
	ret0, _ := ret[0].([]api.ClusterMember)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetClusterMembers indicates an expected call of GetClusterMembers.
func (mr *MockServerMockRecorder) GetClusterMembers() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClusterMembers", reflect.TypeOf((*MockServer)(nil).GetClusterMembers))
}

// GetConnectionInfo mocks base method.
func (m *MockServer) GetConnectionInfo() (*client.ConnectionInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetConnectionInfo")
	ret0, _ := ret[0].(*client.ConnectionInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetConnectionInfo indicates an expected call of GetConnectionInfo.
func (mr *MockServerMockRecorder) GetConnectionInfo() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConnectionInfo", reflect.TypeOf((*MockServer)(nil).GetConnectionInfo))
}

// GetContainer mocks base method.
func (m *MockServer) GetContainer(arg0 string) (*api.Container, string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetContainer", arg0)
	ret0, _ := ret[0].(*api.Container)
	ret1, _ := ret[1].(string)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetContainer indicates an expected call of GetContainer.
func (mr *MockServerMockRecorder) GetContainer(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContainer", reflect.TypeOf((*MockServer)(nil).GetContainer), arg0)
}

// GetContainerProfiles mocks base method.
func (m *MockServer) GetContainerProfiles(arg0 string) ([]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetContainerProfiles", arg0)
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetContainerProfiles indicates an expected call of GetContainerProfiles.
func (mr *MockServerMockRecorder) GetContainerProfiles(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContainerProfiles", reflect.TypeOf((*MockServer)(nil).GetContainerProfiles), arg0)
}

// GetContainerState mocks base method.
func (m *MockServer) GetContainerState(arg0 string) (*api.ContainerState, string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetContainerState", arg0)
	ret0, _ := ret[0].(*api.ContainerState)
	ret1, _ := ret[1].(string)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetContainerState indicates an expected call of GetContainerState.
func (mr *MockServerMockRecorder) GetContainerState(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContainerState", reflect.TypeOf((*MockServer)(nil).GetContainerState), arg0)
}

// GetNICsFromProfile mocks base method.
func (m *MockServer) GetNICsFromProfile(arg0 string) (map[string]map[string]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNICsFromProfile", arg0)
	ret0, _ := ret[0].(map[string]map[string]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetNICsFromProfile indicates an expected call of GetNICsFromProfile.
func (mr *MockServerMockRecorder) GetNICsFromProfile(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNICsFromProfile", reflect.TypeOf((*MockServer)(nil).GetNICsFromProfile), arg0)
}

// GetNetwork mocks base method.
func (m *MockServer) GetNetwork(arg0 string) (*api.Network, string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNetwork", arg0)
	ret0, _ := ret[0].(*api.Network)
	ret1, _ := ret[1].(string)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetNetwork indicates an expected call of GetNetwork.
func (mr *MockServerMockRecorder) GetNetwork(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNetwork", reflect.TypeOf((*MockServer)(nil).GetNetwork), arg0)
}

// GetNetworkNames mocks base method.
func (m *MockServer) GetNetworkNames() ([]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNetworkNames")
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetNetworkNames indicates an expected call of GetNetworkNames.
func (mr *MockServerMockRecorder) GetNetworkNames() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNetworkNames", reflect.TypeOf((*MockServer)(nil).GetNetworkNames))
}

// GetNetworkState mocks base method.
func (m *MockServer) GetNetworkState(arg0 string) (*api.NetworkState, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNetworkState", arg0)
	ret0, _ := ret[0].(*api.NetworkState)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetNetworkState indicates an expected call of GetNetworkState.
func (mr *MockServerMockRecorder) GetNetworkState(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNetworkState", reflect.TypeOf((*MockServer)(nil).GetNetworkState), arg0)
}

// GetProfile mocks base method.
func (m *MockServer) GetProfile(arg0 string) (*api.Profile, string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetProfile", arg0)
	ret0, _ := ret[0].(*api.Profile)
	ret1, _ := ret[1].(string)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetProfile indicates an expected call of GetProfile.
func (mr *MockServerMockRecorder) GetProfile(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetProfile", reflect.TypeOf((*MockServer)(nil).GetProfile), arg0)
}

// GetServer mocks base method.
func (m *MockServer) GetServer() (*api.Server, string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetServer")
	ret0, _ := ret[0].(*api.Server)
	ret1, _ := ret[1].(string)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetServer indicates an expected call of GetServer.
func (mr *MockServerMockRecorder) GetServer() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetServer", reflect.TypeOf((*MockServer)(nil).GetServer))
}

// GetStoragePool mocks base method.
func (m *MockServer) GetStoragePool(arg0 string) (*api.StoragePool, string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetStoragePool", arg0)
	ret0, _ := ret[0].(*api.StoragePool)
	ret1, _ := ret[1].(string)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetStoragePool indicates an expected call of GetStoragePool.
func (mr *MockServerMockRecorder) GetStoragePool(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStoragePool", reflect.TypeOf((*MockServer)(nil).GetStoragePool), arg0)
}

// GetStoragePoolVolume mocks base method.
func (m *MockServer) GetStoragePoolVolume(arg0, arg1, arg2 string) (*api.StorageVolume, string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetStoragePoolVolume", arg0, arg1, arg2)
	ret0, _ := ret[0].(*api.StorageVolume)
	ret1, _ := ret[1].(string)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetStoragePoolVolume indicates an expected call of GetStoragePoolVolume.
func (mr *MockServerMockRecorder) GetStoragePoolVolume(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStoragePoolVolume", reflect.TypeOf((*MockServer)(nil).GetStoragePoolVolume), arg0, arg1, arg2)
}

// GetStoragePoolVolumes mocks base method.
func (m *MockServer) GetStoragePoolVolumes(arg0 string) ([]api.StorageVolume, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetStoragePoolVolumes", arg0)
	ret0, _ := ret[0].([]api.StorageVolume)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetStoragePoolVolumes indicates an expected call of GetStoragePoolVolumes.
func (mr *MockServerMockRecorder) GetStoragePoolVolumes(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStoragePoolVolumes", reflect.TypeOf((*MockServer)(nil).GetStoragePoolVolumes), arg0)
}

// GetStoragePools mocks base method.
func (m *MockServer) GetStoragePools() ([]api.StoragePool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetStoragePools")
	ret0, _ := ret[0].([]api.StoragePool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetStoragePools indicates an expected call of GetStoragePools.
func (mr *MockServerMockRecorder) GetStoragePools() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStoragePools", reflect.TypeOf((*MockServer)(nil).GetStoragePools))
}

// HasProfile mocks base method.
func (m *MockServer) HasProfile(arg0 string) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HasProfile", arg0)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// HasProfile indicates an expected call of HasProfile.
func (mr *MockServerMockRecorder) HasProfile(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasProfile", reflect.TypeOf((*MockServer)(nil).HasProfile), arg0)
}

// HostArch mocks base method.
func (m *MockServer) HostArch() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HostArch")
	ret0, _ := ret[0].(string)
	return ret0
}

// HostArch indicates an expected call of HostArch.
func (mr *MockServerMockRecorder) HostArch() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HostArch", reflect.TypeOf((*MockServer)(nil).HostArch))
}

// IsClustered mocks base method.
func (m *MockServer) IsClustered() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsClustered")
	ret0, _ := ret[0].(bool)
	return ret0
}

// IsClustered indicates an expected call of IsClustered.
func (mr *MockServerMockRecorder) IsClustered() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsClustered", reflect.TypeOf((*MockServer)(nil).IsClustered))
}

// LocalBridgeName mocks base method.
func (m *MockServer) LocalBridgeName() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LocalBridgeName")
	ret0, _ := ret[0].(string)
	return ret0
}

// LocalBridgeName indicates an expected call of LocalBridgeName.
func (mr *MockServerMockRecorder) LocalBridgeName() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LocalBridgeName", reflect.TypeOf((*MockServer)(nil).LocalBridgeName))
}

// Name mocks base method.
func (m *MockServer) Name() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Name")
	ret0, _ := ret[0].(string)
	return ret0
}

// Name indicates an expected call of Name.
func (mr *MockServerMockRecorder) Name() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockServer)(nil).Name))
}

// RemoveContainer mocks base method.
func (m *MockServer) RemoveContainer(arg0 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemoveContainer", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// RemoveContainer indicates an expected call of RemoveContainer.
func (mr *MockServerMockRecorder) RemoveContainer(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveContainer", reflect.TypeOf((*MockServer)(nil).RemoveContainer), arg0)
}

// RemoveContainers mocks base method.
func (m *MockServer) RemoveContainers(arg0 []string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemoveContainers", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// RemoveContainers indicates an expected call of RemoveContainers.
func (mr *MockServerMockRecorder) RemoveContainers(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveContainers", reflect.TypeOf((*MockServer)(nil).RemoveContainers), arg0)
}

// ReplaceOrAddContainerProfile mocks base method.
func (m *MockServer) ReplaceOrAddContainerProfile(arg0, arg1, arg2 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReplaceOrAddContainerProfile", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// ReplaceOrAddContainerProfile indicates an expected call of ReplaceOrAddContainerProfile.
func (mr *MockServerMockRecorder) ReplaceOrAddContainerProfile(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceOrAddContainerProfile", reflect.TypeOf((*MockServer)(nil).ReplaceOrAddContainerProfile), arg0, arg1, arg2)
}

// ServerCertificate mocks base method.
func (m *MockServer) ServerCertificate() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ServerCertificate")
	ret0, _ := ret[0].(string)
	return ret0
}

// ServerCertificate indicates an expected call of ServerCertificate.
func (mr *MockServerMockRecorder) ServerCertificate() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ServerCertificate", reflect.TypeOf((*MockServer)(nil).ServerCertificate))
}

// ServerVersion mocks base method.
func (m *MockServer) ServerVersion() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ServerVersion")
	ret0, _ := ret[0].(string)
	return ret0
}

// ServerVersion indicates an expected call of ServerVersion.
func (mr *MockServerMockRecorder) ServerVersion() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ServerVersion", reflect.TypeOf((*MockServer)(nil).ServerVersion))
}

// StorageSupported mocks base method.
func (m *MockServer) StorageSupported() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StorageSupported")
	ret0, _ := ret[0].(bool)
	return ret0
}

// StorageSupported indicates an expected call of StorageSupported.
func (mr *MockServerMockRecorder) StorageSupported() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StorageSupported", reflect.TypeOf((*MockServer)(nil).StorageSupported))
}

// SupportedArches mocks base method.
func (m *MockServer) SupportedArches() []string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SupportedArches")
	ret0, _ := ret[0].([]string)
	return ret0
}

// SupportedArches indicates an expected call of SupportedArches.
func (mr *MockServerMockRecorder) SupportedArches() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SupportedArches", reflect.TypeOf((*MockServer)(nil).SupportedArches))
}

// UpdateContainerConfig mocks base method.
func (m *MockServer) UpdateContainerConfig(arg0 string, arg1 map[string]string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateContainerConfig", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateContainerConfig indicates an expected call of UpdateContainerConfig.
func (mr *MockServerMockRecorder) UpdateContainerConfig(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateContainerConfig", reflect.TypeOf((*MockServer)(nil).UpdateContainerConfig), arg0, arg1)
}

// UpdateContainerProfiles mocks base method.
func (m *MockServer) UpdateContainerProfiles(arg0 string, arg1 []string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateContainerProfiles", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateContainerProfiles indicates an expected call of UpdateContainerProfiles.
func (mr *MockServerMockRecorder) UpdateContainerProfiles(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateContainerProfiles", reflect.TypeOf((*MockServer)(nil).UpdateContainerProfiles), arg0, arg1)
}

// UpdateServerConfig mocks base method.
func (m *MockServer) UpdateServerConfig(arg0 map[string]string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateServerConfig", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateServerConfig indicates an expected call of UpdateServerConfig.
func (mr *MockServerMockRecorder) UpdateServerConfig(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateServerConfig", reflect.TypeOf((*MockServer)(nil).UpdateServerConfig), arg0)
}

// UpdateStoragePoolVolume mocks base method.
func (m *MockServer) UpdateStoragePoolVolume(arg0, arg1, arg2 string, arg3 api.StorageVolumePut, arg4 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateStoragePoolVolume", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateStoragePoolVolume indicates an expected call of UpdateStoragePoolVolume.
func (mr *MockServerMockRecorder) UpdateStoragePoolVolume(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateStoragePoolVolume", reflect.TypeOf((*MockServer)(nil).UpdateStoragePoolVolume), arg0, arg1, arg2, arg3, arg4)
}

// UseProject mocks base method.
func (m *MockServer) UseProject(arg0 string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "UseProject", arg0)
}

// UseProject indicates an expected call of UseProject.
func (mr *MockServerMockRecorder) UseProject(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UseProject", reflect.TypeOf((*MockServer)(nil).UseProject), arg0)
}

// UseTargetServer mocks base method.
func (m *MockServer) UseTargetServer(arg0 string) (*lxd.Server, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UseTargetServer", arg0)
	ret0, _ := ret[0].(*lxd.Server)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UseTargetServer indicates an expected call of UseTargetServer.
func (mr *MockServerMockRecorder) UseTargetServer(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UseTargetServer", reflect.TypeOf((*MockServer)(nil).UseTargetServer), arg0)
}

// VerifyNetworkDevice mocks base method.
func (m *MockServer) VerifyNetworkDevice(arg0 *api.Profile, arg1 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "VerifyNetworkDevice", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// VerifyNetworkDevice indicates an expected call of VerifyNetworkDevice.
func (mr *MockServerMockRecorder) VerifyNetworkDevice(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifyNetworkDevice", reflect.TypeOf((*MockServer)(nil).VerifyNetworkDevice), arg0, arg1)
}

// WriteContainer mocks base method.
func (m *MockServer) WriteContainer(arg0 *lxd.Container) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WriteContainer", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// WriteContainer indicates an expected call of WriteContainer.
func (mr *MockServerMockRecorder) WriteContainer(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteContainer", reflect.TypeOf((*MockServer)(nil).WriteContainer), arg0)
}

// MockServerFactory is a mock of ServerFactory interface.
type MockServerFactory struct {
	ctrl     *gomock.Controller
	recorder *MockServerFactoryMockRecorder
}

// MockServerFactoryMockRecorder is the mock recorder for MockServerFactory.
type MockServerFactoryMockRecorder struct {
	mock *MockServerFactory
}

// NewMockServerFactory creates a new mock instance.
func NewMockServerFactory(ctrl *gomock.Controller) *MockServerFactory {
	mock := &MockServerFactory{ctrl: ctrl}
	mock.recorder = &MockServerFactoryMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockServerFactory) EXPECT() *MockServerFactoryMockRecorder {
	return m.recorder
}

// InsecureRemoteServer mocks base method.
func (m *MockServerFactory) InsecureRemoteServer(arg0 cloudspec.CloudSpec) (Server, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsecureRemoteServer", arg0)
	ret0, _ := ret[0].(Server)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsecureRemoteServer indicates an expected call of InsecureRemoteServer.
func (mr *MockServerFactoryMockRecorder) InsecureRemoteServer(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsecureRemoteServer", reflect.TypeOf((*MockServerFactory)(nil).InsecureRemoteServer), arg0)
}

// LocalServer mocks base method.
func (m *MockServerFactory) LocalServer() (Server, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LocalServer")
	ret0, _ := ret[0].(Server)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// LocalServer indicates an expected call of LocalServer.
func (mr *MockServerFactoryMockRecorder) LocalServer() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LocalServer", reflect.TypeOf((*MockServerFactory)(nil).LocalServer))
}

// LocalServerAddress mocks base method.
func (m *MockServerFactory) LocalServerAddress() (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LocalServerAddress")
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// LocalServerAddress indicates an expected call of LocalServerAddress.
func (mr *MockServerFactoryMockRecorder) LocalServerAddress() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LocalServerAddress", reflect.TypeOf((*MockServerFactory)(nil).LocalServerAddress))
}

// RemoteServer mocks base method.
func (m *MockServerFactory) RemoteServer(arg0 cloudspec.CloudSpec) (Server, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemoteServer", arg0)
	ret0, _ := ret[0].(Server)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RemoteServer indicates an expected call of RemoteServer.
func (mr *MockServerFactoryMockRecorder) RemoteServer(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoteServer", reflect.TypeOf((*MockServerFactory)(nil).RemoteServer), arg0)
}

// MockInterfaceAddress is a mock of InterfaceAddress interface.
type MockInterfaceAddress struct {
	ctrl     *gomock.Controller
	recorder *MockInterfaceAddressMockRecorder
}

// MockInterfaceAddressMockRecorder is the mock recorder for MockInterfaceAddress.
type MockInterfaceAddressMockRecorder struct {
	mock *MockInterfaceAddress
}

// NewMockInterfaceAddress creates a new mock instance.
func NewMockInterfaceAddress(ctrl *gomock.Controller) *MockInterfaceAddress {
	mock := &MockInterfaceAddress{ctrl: ctrl}
	mock.recorder = &MockInterfaceAddressMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockInterfaceAddress) EXPECT() *MockInterfaceAddressMockRecorder {
	return m.recorder
}

// InterfaceAddress mocks base method.
func (m *MockInterfaceAddress) InterfaceAddress(arg0 string) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InterfaceAddress", arg0)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InterfaceAddress indicates an expected call of InterfaceAddress.
func (mr *MockInterfaceAddressMockRecorder) InterfaceAddress(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InterfaceAddress", reflect.TypeOf((*MockInterfaceAddress)(nil).InterfaceAddress), arg0)
}

// MockCertificateReadWriter is a mock of CertificateReadWriter interface.
type MockCertificateReadWriter struct {
	ctrl     *gomock.Controller
	recorder *MockCertificateReadWriterMockRecorder
}

// MockCertificateReadWriterMockRecorder is the mock recorder for MockCertificateReadWriter.
type MockCertificateReadWriterMockRecorder struct {
	mock *MockCertificateReadWriter
}

// NewMockCertificateReadWriter creates a new mock instance.
func NewMockCertificateReadWriter(ctrl *gomock.Controller) *MockCertificateReadWriter {
	mock := &MockCertificateReadWriter{ctrl: ctrl}
	mock.recorder = &MockCertificateReadWriterMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockCertificateReadWriter) EXPECT() *MockCertificateReadWriterMockRecorder {
	return m.recorder
}

// Read mocks base method.
func (m *MockCertificateReadWriter) Read(arg0 string) ([]byte, []byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Read", arg0)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].([]byte)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Read indicates an expected call of Read.
func (mr *MockCertificateReadWriterMockRecorder) Read(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Read", reflect.TypeOf((*MockCertificateReadWriter)(nil).Read), arg0)
}

// Write mocks base method.
func (m *MockCertificateReadWriter) Write(arg0 string, arg1, arg2 []byte) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Write", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// Write indicates an expected call of Write.
func (mr *MockCertificateReadWriterMockRecorder) Write(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Write", reflect.TypeOf((*MockCertificateReadWriter)(nil).Write), arg0, arg1, arg2)
}

// MockCertificateGenerator is a mock of CertificateGenerator interface.
type MockCertificateGenerator struct {
	ctrl     *gomock.Controller
	recorder *MockCertificateGeneratorMockRecorder
}

// MockCertificateGeneratorMockRecorder is the mock recorder for MockCertificateGenerator.
type MockCertificateGeneratorMockRecorder struct {
	mock *MockCertificateGenerator
}

// NewMockCertificateGenerator creates a new mock instance.
func NewMockCertificateGenerator(ctrl *gomock.Controller) *MockCertificateGenerator {
	mock := &MockCertificateGenerator{ctrl: ctrl}
	mock.recorder = &MockCertificateGeneratorMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockCertificateGenerator) EXPECT() *MockCertificateGeneratorMockRecorder {
	return m.recorder
}

// Generate mocks base method.
func (m *MockCertificateGenerator) Generate(arg0, arg1 bool) ([]byte, []byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Generate", arg0, arg1)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].([]byte)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Generate indicates an expected call of Generate.
func (mr *MockCertificateGeneratorMockRecorder) Generate(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Generate", reflect.TypeOf((*MockCertificateGenerator)(nil).Generate), arg0, arg1)
}

// MockNetLookup is a mock of NetLookup interface.
type MockNetLookup struct {
	ctrl     *gomock.Controller
	recorder *MockNetLookupMockRecorder
}

// MockNetLookupMockRecorder is the mock recorder for MockNetLookup.
type MockNetLookupMockRecorder struct {
	mock *MockNetLookup
}

// NewMockNetLookup creates a new mock instance.
func NewMockNetLookup(ctrl *gomock.Controller) *MockNetLookup {
	mock := &MockNetLookup{ctrl: ctrl}
	mock.recorder = &MockNetLookupMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockNetLookup) EXPECT() *MockNetLookupMockRecorder {
	return m.recorder
}

// InterfaceAddrs mocks base method.
func (m *MockNetLookup) InterfaceAddrs() ([]net.Addr, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InterfaceAddrs")
	ret0, _ := ret[0].([]net.Addr)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InterfaceAddrs indicates an expected call of InterfaceAddrs.
func (mr *MockNetLookupMockRecorder) InterfaceAddrs() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InterfaceAddrs", reflect.TypeOf((*MockNetLookup)(nil).InterfaceAddrs))
}

// LookupHost mocks base method.
func (m *MockNetLookup) LookupHost(arg0 string) ([]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LookupHost", arg0)
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// LookupHost indicates an expected call of LookupHost.
func (mr *MockNetLookupMockRecorder) LookupHost(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LookupHost", reflect.TypeOf((*MockNetLookup)(nil).LookupHost), arg0)
}

// MockLXCConfigReader is a mock of LXCConfigReader interface.
type MockLXCConfigReader struct {
	ctrl     *gomock.Controller
	recorder *MockLXCConfigReaderMockRecorder
}

// MockLXCConfigReaderMockRecorder is the mock recorder for MockLXCConfigReader.
type MockLXCConfigReaderMockRecorder struct {
	mock *MockLXCConfigReader
}

// NewMockLXCConfigReader creates a new mock instance.
func NewMockLXCConfigReader(ctrl *gomock.Controller) *MockLXCConfigReader {
	mock := &MockLXCConfigReader{ctrl: ctrl}
	mock.recorder = &MockLXCConfigReaderMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockLXCConfigReader) EXPECT() *MockLXCConfigReaderMockRecorder {
	return m.recorder
}

// ReadCert mocks base method.
func (m *MockLXCConfigReader) ReadCert(arg0 string) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadCert", arg0)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReadCert indicates an expected call of ReadCert.
func (mr *MockLXCConfigReaderMockRecorder) ReadCert(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadCert", reflect.TypeOf((*MockLXCConfigReader)(nil).ReadCert), arg0)
}

// ReadConfig mocks base method.
func (m *MockLXCConfigReader) ReadConfig(arg0 string) (LXCConfig, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadConfig", arg0)
	ret0, _ := ret[0].(LXCConfig)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReadConfig indicates an expected call of ReadConfig.
func (mr *MockLXCConfigReaderMockRecorder) ReadConfig(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadConfig", reflect.TypeOf((*MockLXCConfigReader)(nil).ReadConfig), arg0)
}