func (m *MockNetworkClient) ListTrunk(arg0 trunks.ListOptsBuilder) ([]trunks.Trunk, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTrunk", arg0)
	ret0, _ := ret[0].([]trunks.Trunk)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
ListTrunk mocks base method
package mock_networking
import (
	gomock "github.com/golang/mock/gomock"
	extensions "github.com/gophercloud/gophercloud/openstack/networking/v2/extensions"
	attributestags "github.com/gophercloud/gophercloud/openstack/networking/v2/extensions/attributestags"
	floatingips "github.com/gophercloud/gophercloud/openstack/networking/v2/extensions/layer3/floatingips"
	routers "github.com/gophercloud/gophercloud/openstack/networking/v2/extensions/layer3/routers"
	groups "github.com/gophercloud/gophercloud/openstack/networking/v2/extensions/security/groups"
	rules "github.com/gophercloud/gophercloud/openstack/networking/v2/extensions/security/rules"
	trunks "github.com/gophercloud/gophercloud/openstack/networking/v2/extensions/trunks"
	networks "github.com/gophercloud/gophercloud/openstack/networking/v2/networks"
	ports "github.com/gophercloud/gophercloud/openstack/networking/v2/ports"
	subnets "github.com/gophercloud/gophercloud/openstack/networking/v2/subnets"
	reflect "reflect"
)
type MockNetworkClient struct {
	ctrl     *gomock.Controller
	recorder *MockNetworkClientMockRecorder
}
type MockNetworkClientMockRecorder struct {
	mock *MockNetworkClient
}
func NewMockNetworkClient(ctrl *gomock.Controller) *MockNetworkClient {
	mock := &MockNetworkClient{ctrl: ctrl}
	mock.recorder = &MockNetworkClientMockRecorder{mock}
	return mock
}
func (m *MockNetworkClient) EXPECT() *MockNetworkClientMockRecorder {
	return m.recorder
}
func (m *MockNetworkClient) AddRouterInterface(arg0 string, arg1 routers.AddInterfaceOptsBuilder) (*routers.InterfaceInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddRouterInterface", arg0, arg1)
	ret0, _ := ret[0].(*routers.InterfaceInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockNetworkClientMockRecorder) AddRouterInterface(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddRouterInterface", reflect.TypeOf((*MockNetworkClient)(nil).AddRouterInterface), arg0, arg1)
}
func (m *MockNetworkClient) CreateFloatingIP(arg0 floatingips.CreateOptsBuilder) (*floatingips.FloatingIP, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateFloatingIP", arg0)
	ret0, _ := ret[0].(*floatingips.FloatingIP)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockNetworkClientMockRecorder) CreateFloatingIP(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFloatingIP", reflect.TypeOf((*MockNetworkClient)(nil).CreateFloatingIP), arg0)
}
func (m *MockNetworkClient) CreateNetwork(arg0 networks.CreateOptsBuilder) (*networks.Network, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateNetwork", arg0)
	ret0, _ := ret[0].(*networks.Network)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockNetworkClientMockRecorder) CreateNetwork(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNetwork", reflect.TypeOf((*MockNetworkClient)(nil).CreateNetwork), arg0)
}
func (m *MockNetworkClient) CreatePort(arg0 ports.CreateOptsBuilder) (*ports.Port, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreatePort", arg0)
	ret0, _ := ret[0].(*ports.Port)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockNetworkClientMockRecorder) CreatePort(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePort", reflect.TypeOf((*MockNetworkClient)(nil).CreatePort), arg0)
}
func (m *MockNetworkClient) CreateRouter(arg0 routers.CreateOptsBuilder) (*routers.Router, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateRouter", arg0)
	ret0, _ := ret[0].(*routers.Router)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockNetworkClientMockRecorder) CreateRouter(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRouter", reflect.TypeOf((*MockNetworkClient)(nil).CreateRouter), arg0)
}
func (m *MockNetworkClient) CreateSecGroup(arg0 groups.CreateOptsBuilder) (*groups.SecGroup, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateSecGroup", arg0)
	ret0, _ := ret[0].(*groups.SecGroup)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockNetworkClientMockRecorder) CreateSecGroup(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSecGroup", reflect.TypeOf((*MockNetworkClient)(nil).CreateSecGroup), arg0)
}
func (m *MockNetworkClient) CreateSecGroupRule(arg0 rules.CreateOptsBuilder) (*rules.SecGroupRule, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateSecGroupRule", arg0)
	ret0, _ := ret[0].(*rules.SecGroupRule)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockNetworkClientMockRecorder) CreateSecGroupRule(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSecGroupRule", reflect.TypeOf((*MockNetworkClient)(nil).CreateSecGroupRule), arg0)
}
func (m *MockNetworkClient) CreateSubnet(arg0 subnets.CreateOptsBuilder) (*subnets.Subnet, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateSubnet", arg0)
	ret0, _ := ret[0].(*subnets.Subnet)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockNetworkClientMockRecorder) CreateSubnet(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSubnet", reflect.TypeOf((*MockNetworkClient)(nil).CreateSubnet), arg0)
}
func (m *MockNetworkClient) CreateTrunk(arg0 trunks.CreateOptsBuilder) (*trunks.Trunk, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateTrunk", arg0)
	ret0, _ := ret[0].(*trunks.Trunk)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockNetworkClientMockRecorder) CreateTrunk(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrunk", reflect.TypeOf((*MockNetworkClient)(nil).CreateTrunk), arg0)
}
func (m *MockNetworkClient) DeleteFloatingIP(arg0 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteFloatingIP", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockNetworkClientMockRecorder) DeleteFloatingIP(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteFloatingIP", reflect.TypeOf((*MockNetworkClient)(nil).DeleteFloatingIP), arg0)
}
func (m *MockNetworkClient) DeleteNetwork(arg0 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteNetwork", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockNetworkClientMockRecorder) DeleteNetwork(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetwork", reflect.TypeOf((*MockNetworkClient)(nil).DeleteNetwork), arg0)
}
func (m *MockNetworkClient) DeletePort(arg0 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeletePort", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockNetworkClientMockRecorder) DeletePort(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePort", reflect.TypeOf((*MockNetworkClient)(nil).DeletePort), arg0)
}
func (m *MockNetworkClient) DeleteRouter(arg0 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteRouter", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockNetworkClientMockRecorder) DeleteRouter(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRouter", reflect.TypeOf((*MockNetworkClient)(nil).DeleteRouter), arg0)
}
func (m *MockNetworkClient) DeleteSecGroup(arg0 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteSecGroup", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockNetworkClientMockRecorder) DeleteSecGroup(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSecGroup", reflect.TypeOf((*MockNetworkClient)(nil).DeleteSecGroup), arg0)
}
func (m *MockNetworkClient) DeleteSecGroupRule(arg0 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteSecGroupRule", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockNetworkClientMockRecorder) DeleteSecGroupRule(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSecGroupRule", reflect.TypeOf((*MockNetworkClient)(nil).DeleteSecGroupRule), arg0)
}
func (m *MockNetworkClient) DeleteSubnet(arg0 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteSubnet", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockNetworkClientMockRecorder) DeleteSubnet(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSubnet", reflect.TypeOf((*MockNetworkClient)(nil).DeleteSubnet), arg0)
}
func (m *MockNetworkClient) DeleteTrunk(arg0 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTrunk", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockNetworkClientMockRecorder) DeleteTrunk(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrunk", reflect.TypeOf((*MockNetworkClient)(nil).DeleteTrunk), arg0)
}
func (m *MockNetworkClient) GetFloatingIP(arg0 string) (*floatingips.FloatingIP, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetFloatingIP", arg0)
	ret0, _ := ret[0].(*floatingips.FloatingIP)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockNetworkClientMockRecorder) GetFloatingIP(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFloatingIP", reflect.TypeOf((*MockNetworkClient)(nil).GetFloatingIP), arg0)
}
func (m *MockNetworkClient) GetNetwork(arg0 string) (*networks.Network, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNetwork", arg0)
	ret0, _ := ret[0].(*networks.Network)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockNetworkClientMockRecorder) GetNetwork(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNetwork", reflect.TypeOf((*MockNetworkClient)(nil).GetNetwork), arg0)
}
func (m *MockNetworkClient) GetPort(arg0 string) (*ports.Port, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPort", arg0)
	ret0, _ := ret[0].(*ports.Port)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockNetworkClientMockRecorder) GetPort(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPort", reflect.TypeOf((*MockNetworkClient)(nil).GetPort), arg0)
}
func (m *MockNetworkClient) GetRouter(arg0 string) (*routers.Router, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRouter", arg0)
	ret0, _ := ret[0].(*routers.Router)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockNetworkClientMockRecorder) GetRouter(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRouter", reflect.TypeOf((*MockNetworkClient)(nil).GetRouter), arg0)
}
func (m *MockNetworkClient) GetSecGroup(arg0 string) (*groups.SecGroup, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSecGroup", arg0)
	ret0, _ := ret[0].(*groups.SecGroup)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockNetworkClientMockRecorder) GetSecGroup(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSecGroup", reflect.TypeOf((*MockNetworkClient)(nil).GetSecGroup), arg0)
}
func (m *MockNetworkClient) GetSecGroupRule(arg0 string) (*rules.SecGroupRule, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSecGroupRule", arg0)
	ret0, _ := ret[0].(*rules.SecGroupRule)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockNetworkClientMockRecorder) GetSecGroupRule(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSecGroupRule", reflect.TypeOf((*MockNetworkClient)(nil).GetSecGroupRule), arg0)
}
func (m *MockNetworkClient) GetSubnet(arg0 string) (*subnets.Subnet, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSubnet", arg0)
	ret0, _ := ret[0].(*subnets.Subnet)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockNetworkClientMockRecorder) GetSubnet(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSubnet", reflect.TypeOf((*MockNetworkClient)(nil).GetSubnet), arg0)
}
func (m *MockNetworkClient) ListExtensions() ([]extensions.Extension, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListExtensions")
	ret0, _ := ret[0].([]extensions.Extension)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockNetworkClientMockRecorder) ListExtensions() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListExtensions", reflect.TypeOf((*MockNetworkClient)(nil).ListExtensions))
}
func (m *MockNetworkClient) ListFloatingIP(arg0 floatingips.ListOptsBuilder) ([]floatingips.FloatingIP, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListFloatingIP", arg0)
	ret0, _ := ret[0].([]floatingips.FloatingIP)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockNetworkClientMockRecorder) ListFloatingIP(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListFloatingIP", reflect.TypeOf((*MockNetworkClient)(nil).ListFloatingIP), arg0)
}
func (m *MockNetworkClient) ListNetwork(arg0 networks.ListOptsBuilder) ([]networks.Network, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListNetwork", arg0)
	ret0, _ := ret[0].([]networks.Network)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockNetworkClientMockRecorder) ListNetwork(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListNetwork", reflect.TypeOf((*MockNetworkClient)(nil).ListNetwork), arg0)
}
func (m *MockNetworkClient) ListPort(arg0 ports.ListOptsBuilder) ([]ports.Port, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListPort", arg0)
	ret0, _ := ret[0].([]ports.Port)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockNetworkClientMockRecorder) ListPort(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPort", reflect.TypeOf((*MockNetworkClient)(nil).ListPort), arg0)
}
func (m *MockNetworkClient) ListRouter(arg0 routers.ListOpts) ([]routers.Router, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListRouter", arg0)
	ret0, _ := ret[0].([]routers.Router)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockNetworkClientMockRecorder) ListRouter(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRouter", reflect.TypeOf((*MockNetworkClient)(nil).ListRouter), arg0)
}
func (m *MockNetworkClient) ListSecGroup(arg0 groups.ListOpts) ([]groups.SecGroup, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListSecGroup", arg0)
	ret0, _ := ret[0].([]groups.SecGroup)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockNetworkClientMockRecorder) ListSecGroup(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSecGroup", reflect.TypeOf((*MockNetworkClient)(nil).ListSecGroup), arg0)
}
func (m *MockNetworkClient) ListSecGroupRule(arg0 rules.ListOpts) ([]rules.SecGroupRule, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListSecGroupRule", arg0)
	ret0, _ := ret[0].([]rules.SecGroupRule)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockNetworkClientMockRecorder) ListSecGroupRule(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSecGroupRule", reflect.TypeOf((*MockNetworkClient)(nil).ListSecGroupRule), arg0)
}
func (m *MockNetworkClient) ListSubnet(arg0 subnets.ListOptsBuilder) ([]subnets.Subnet, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListSubnet", arg0)
	ret0, _ := ret[0].([]subnets.Subnet)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockNetworkClientMockRecorder) ListSubnet(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSubnet", reflect.TypeOf((*MockNetworkClient)(nil).ListSubnet), arg0)
}