cloudstack/GPUService_mock.go

//
// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License.  You may obtain a copy of the License at
//
//   http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied.  See the License for the
// specific language governing permissions and limitations
// under the License.
//

// Code generated by MockGen. DO NOT EDIT.
// Source: ./cloudstack/GPUService.go
//
// Generated by this command:
//
//	mockgen -destination=./cloudstack/GPUService_mock.go -package=cloudstack -copyright_file=header.txt -source=./cloudstack/GPUService.go
//

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

import (
	reflect "reflect"

	gomock "go.uber.org/mock/gomock"
)

// MockGPUServiceIface is a mock of GPUServiceIface interface.
type MockGPUServiceIface struct {
	ctrl     *gomock.Controller
	recorder *MockGPUServiceIfaceMockRecorder
	isgomock struct{}
}

// MockGPUServiceIfaceMockRecorder is the mock recorder for MockGPUServiceIface.
type MockGPUServiceIfaceMockRecorder struct {
	mock *MockGPUServiceIface
}

// NewMockGPUServiceIface creates a new mock instance.
func NewMockGPUServiceIface(ctrl *gomock.Controller) *MockGPUServiceIface {
	mock := &MockGPUServiceIface{ctrl: ctrl}
	mock.recorder = &MockGPUServiceIfaceMockRecorder{mock}
	return mock
}

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

// CreateGpuCard mocks base method.
func (m *MockGPUServiceIface) CreateGpuCard(p *CreateGpuCardParams) (*CreateGpuCardResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateGpuCard", p)
	ret0, _ := ret[0].(*CreateGpuCardResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateGpuCard indicates an expected call of CreateGpuCard.
func (mr *MockGPUServiceIfaceMockRecorder) CreateGpuCard(p any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateGpuCard", reflect.TypeOf((*MockGPUServiceIface)(nil).CreateGpuCard), p)
}

// CreateGpuDevice mocks base method.
func (m *MockGPUServiceIface) CreateGpuDevice(p *CreateGpuDeviceParams) (*CreateGpuDeviceResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateGpuDevice", p)
	ret0, _ := ret[0].(*CreateGpuDeviceResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateGpuDevice indicates an expected call of CreateGpuDevice.
func (mr *MockGPUServiceIfaceMockRecorder) CreateGpuDevice(p any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateGpuDevice", reflect.TypeOf((*MockGPUServiceIface)(nil).CreateGpuDevice), p)
}

// CreateVgpuProfile mocks base method.
func (m *MockGPUServiceIface) CreateVgpuProfile(p *CreateVgpuProfileParams) (*CreateVgpuProfileResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateVgpuProfile", p)
	ret0, _ := ret[0].(*CreateVgpuProfileResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateVgpuProfile indicates an expected call of CreateVgpuProfile.
func (mr *MockGPUServiceIfaceMockRecorder) CreateVgpuProfile(p any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVgpuProfile", reflect.TypeOf((*MockGPUServiceIface)(nil).CreateVgpuProfile), p)
}

// DeleteGpuCard mocks base method.
func (m *MockGPUServiceIface) DeleteGpuCard(p *DeleteGpuCardParams) (*DeleteGpuCardResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteGpuCard", p)
	ret0, _ := ret[0].(*DeleteGpuCardResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteGpuCard indicates an expected call of DeleteGpuCard.
func (mr *MockGPUServiceIfaceMockRecorder) DeleteGpuCard(p any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteGpuCard", reflect.TypeOf((*MockGPUServiceIface)(nil).DeleteGpuCard), p)
}

// DeleteGpuDevice mocks base method.
func (m *MockGPUServiceIface) DeleteGpuDevice(p *DeleteGpuDeviceParams) (*DeleteGpuDeviceResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteGpuDevice", p)
	ret0, _ := ret[0].(*DeleteGpuDeviceResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteGpuDevice indicates an expected call of DeleteGpuDevice.
func (mr *MockGPUServiceIfaceMockRecorder) DeleteGpuDevice(p any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteGpuDevice", reflect.TypeOf((*MockGPUServiceIface)(nil).DeleteGpuDevice), p)
}

// DeleteVgpuProfile mocks base method.
func (m *MockGPUServiceIface) DeleteVgpuProfile(p *DeleteVgpuProfileParams) (*DeleteVgpuProfileResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteVgpuProfile", p)
	ret0, _ := ret[0].(*DeleteVgpuProfileResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteVgpuProfile indicates an expected call of DeleteVgpuProfile.
func (mr *MockGPUServiceIfaceMockRecorder) DeleteVgpuProfile(p any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVgpuProfile", reflect.TypeOf((*MockGPUServiceIface)(nil).DeleteVgpuProfile), p)
}

// DiscoverGpuDevices mocks base method.
func (m *MockGPUServiceIface) DiscoverGpuDevices(p *DiscoverGpuDevicesParams) (*DiscoverGpuDevicesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DiscoverGpuDevices", p)
	ret0, _ := ret[0].(*DiscoverGpuDevicesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DiscoverGpuDevices indicates an expected call of DiscoverGpuDevices.
func (mr *MockGPUServiceIfaceMockRecorder) DiscoverGpuDevices(p any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DiscoverGpuDevices", reflect.TypeOf((*MockGPUServiceIface)(nil).DiscoverGpuDevices), p)
}

// GetGpuCardByID mocks base method.
func (m *MockGPUServiceIface) GetGpuCardByID(id string, opts ...OptionFunc) (*GpuCard, int, error) {
	m.ctrl.T.Helper()
	varargs := []any{id}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetGpuCardByID", varargs...)
	ret0, _ := ret[0].(*GpuCard)
	ret1, _ := ret[1].(int)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetGpuCardByID indicates an expected call of GetGpuCardByID.
func (mr *MockGPUServiceIfaceMockRecorder) GetGpuCardByID(id any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{id}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGpuCardByID", reflect.TypeOf((*MockGPUServiceIface)(nil).GetGpuCardByID), varargs...)
}

// GetGpuCardByName mocks base method.
func (m *MockGPUServiceIface) GetGpuCardByName(name string, opts ...OptionFunc) (*GpuCard, int, error) {
	m.ctrl.T.Helper()
	varargs := []any{name}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetGpuCardByName", varargs...)
	ret0, _ := ret[0].(*GpuCard)
	ret1, _ := ret[1].(int)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetGpuCardByName indicates an expected call of GetGpuCardByName.
func (mr *MockGPUServiceIfaceMockRecorder) GetGpuCardByName(name any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{name}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGpuCardByName", reflect.TypeOf((*MockGPUServiceIface)(nil).GetGpuCardByName), varargs...)
}

// GetGpuCardID mocks base method.
func (m *MockGPUServiceIface) GetGpuCardID(keyword string, opts ...OptionFunc) (string, int, error) {
	m.ctrl.T.Helper()
	varargs := []any{keyword}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetGpuCardID", varargs...)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(int)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetGpuCardID indicates an expected call of GetGpuCardID.
func (mr *MockGPUServiceIfaceMockRecorder) GetGpuCardID(keyword any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{keyword}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGpuCardID", reflect.TypeOf((*MockGPUServiceIface)(nil).GetGpuCardID), varargs...)
}

// GetGpuDeviceByID mocks base method.
func (m *MockGPUServiceIface) GetGpuDeviceByID(id string, opts ...OptionFunc) (*GpuDevice, int, error) {
	m.ctrl.T.Helper()
	varargs := []any{id}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetGpuDeviceByID", varargs...)
	ret0, _ := ret[0].(*GpuDevice)
	ret1, _ := ret[1].(int)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetGpuDeviceByID indicates an expected call of GetGpuDeviceByID.
func (mr *MockGPUServiceIfaceMockRecorder) GetGpuDeviceByID(id any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{id}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGpuDeviceByID", reflect.TypeOf((*MockGPUServiceIface)(nil).GetGpuDeviceByID), varargs...)
}

// GetVgpuProfileByID mocks base method.
func (m *MockGPUServiceIface) GetVgpuProfileByID(id string, opts ...OptionFunc) (*VgpuProfile, int, error) {
	m.ctrl.T.Helper()
	varargs := []any{id}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetVgpuProfileByID", varargs...)
	ret0, _ := ret[0].(*VgpuProfile)
	ret1, _ := ret[1].(int)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetVgpuProfileByID indicates an expected call of GetVgpuProfileByID.
func (mr *MockGPUServiceIfaceMockRecorder) GetVgpuProfileByID(id any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{id}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVgpuProfileByID", reflect.TypeOf((*MockGPUServiceIface)(nil).GetVgpuProfileByID), varargs...)
}

// GetVgpuProfileByName mocks base method.
func (m *MockGPUServiceIface) GetVgpuProfileByName(name string, opts ...OptionFunc) (*VgpuProfile, int, error) {
	m.ctrl.T.Helper()
	varargs := []any{name}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetVgpuProfileByName", varargs...)
	ret0, _ := ret[0].(*VgpuProfile)
	ret1, _ := ret[1].(int)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetVgpuProfileByName indicates an expected call of GetVgpuProfileByName.
func (mr *MockGPUServiceIfaceMockRecorder) GetVgpuProfileByName(name any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{name}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVgpuProfileByName", reflect.TypeOf((*MockGPUServiceIface)(nil).GetVgpuProfileByName), varargs...)
}

// GetVgpuProfileID mocks base method.
func (m *MockGPUServiceIface) GetVgpuProfileID(name string, opts ...OptionFunc) (string, int, error) {
	m.ctrl.T.Helper()
	varargs := []any{name}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetVgpuProfileID", varargs...)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(int)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetVgpuProfileID indicates an expected call of GetVgpuProfileID.
func (mr *MockGPUServiceIfaceMockRecorder) GetVgpuProfileID(name any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{name}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVgpuProfileID", reflect.TypeOf((*MockGPUServiceIface)(nil).GetVgpuProfileID), varargs...)
}

// ListGpuCards mocks base method.
func (m *MockGPUServiceIface) ListGpuCards(p *ListGpuCardsParams) (*ListGpuCardsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListGpuCards", p)
	ret0, _ := ret[0].(*ListGpuCardsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListGpuCards indicates an expected call of ListGpuCards.
func (mr *MockGPUServiceIfaceMockRecorder) ListGpuCards(p any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListGpuCards", reflect.TypeOf((*MockGPUServiceIface)(nil).ListGpuCards), p)
}

// ListGpuDevices mocks base method.
func (m *MockGPUServiceIface) ListGpuDevices(p *ListGpuDevicesParams) (*ListGpuDevicesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListGpuDevices", p)
	ret0, _ := ret[0].(*ListGpuDevicesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListGpuDevices indicates an expected call of ListGpuDevices.
func (mr *MockGPUServiceIfaceMockRecorder) ListGpuDevices(p any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListGpuDevices", reflect.TypeOf((*MockGPUServiceIface)(nil).ListGpuDevices), p)
}

// ListVgpuProfiles mocks base method.
func (m *MockGPUServiceIface) ListVgpuProfiles(p *ListVgpuProfilesParams) (*ListVgpuProfilesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListVgpuProfiles", p)
	ret0, _ := ret[0].(*ListVgpuProfilesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListVgpuProfiles indicates an expected call of ListVgpuProfiles.
func (mr *MockGPUServiceIfaceMockRecorder) ListVgpuProfiles(p any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListVgpuProfiles", reflect.TypeOf((*MockGPUServiceIface)(nil).ListVgpuProfiles), p)
}

// ManageGpuDevice mocks base method.
func (m *MockGPUServiceIface) ManageGpuDevice(p *ManageGpuDeviceParams) (*ManageGpuDeviceResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ManageGpuDevice", p)
	ret0, _ := ret[0].(*ManageGpuDeviceResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ManageGpuDevice indicates an expected call of ManageGpuDevice.
func (mr *MockGPUServiceIfaceMockRecorder) ManageGpuDevice(p any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ManageGpuDevice", reflect.TypeOf((*MockGPUServiceIface)(nil).ManageGpuDevice), p)
}

// NewCreateGpuCardParams mocks base method.
func (m *MockGPUServiceIface) NewCreateGpuCardParams(deviceid, devicename, name, vendorid, vendorname string) *CreateGpuCardParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewCreateGpuCardParams", deviceid, devicename, name, vendorid, vendorname)
	ret0, _ := ret[0].(*CreateGpuCardParams)
	return ret0
}

// NewCreateGpuCardParams indicates an expected call of NewCreateGpuCardParams.
func (mr *MockGPUServiceIfaceMockRecorder) NewCreateGpuCardParams(deviceid, devicename, name, vendorid, vendorname any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewCreateGpuCardParams", reflect.TypeOf((*MockGPUServiceIface)(nil).NewCreateGpuCardParams), deviceid, devicename, name, vendorid, vendorname)
}

// NewCreateGpuDeviceParams mocks base method.
func (m *MockGPUServiceIface) NewCreateGpuDeviceParams(busaddress, gpucardid, hostid, vgpuprofileid string) *CreateGpuDeviceParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewCreateGpuDeviceParams", busaddress, gpucardid, hostid, vgpuprofileid)
	ret0, _ := ret[0].(*CreateGpuDeviceParams)
	return ret0
}

// NewCreateGpuDeviceParams indicates an expected call of NewCreateGpuDeviceParams.
func (mr *MockGPUServiceIfaceMockRecorder) NewCreateGpuDeviceParams(busaddress, gpucardid, hostid, vgpuprofileid any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewCreateGpuDeviceParams", reflect.TypeOf((*MockGPUServiceIface)(nil).NewCreateGpuDeviceParams), busaddress, gpucardid, hostid, vgpuprofileid)
}

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

// NewCreateVgpuProfileParams indicates an expected call of NewCreateVgpuProfileParams.
func (mr *MockGPUServiceIfaceMockRecorder) NewCreateVgpuProfileParams(gpucardid, name any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewCreateVgpuProfileParams", reflect.TypeOf((*MockGPUServiceIface)(nil).NewCreateVgpuProfileParams), gpucardid, name)
}

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

// NewDeleteGpuCardParams indicates an expected call of NewDeleteGpuCardParams.
func (mr *MockGPUServiceIfaceMockRecorder) NewDeleteGpuCardParams(id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewDeleteGpuCardParams", reflect.TypeOf((*MockGPUServiceIface)(nil).NewDeleteGpuCardParams), id)
}

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

// NewDeleteGpuDeviceParams indicates an expected call of NewDeleteGpuDeviceParams.
func (mr *MockGPUServiceIfaceMockRecorder) NewDeleteGpuDeviceParams(ids any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewDeleteGpuDeviceParams", reflect.TypeOf((*MockGPUServiceIface)(nil).NewDeleteGpuDeviceParams), ids)
}

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

// NewDeleteVgpuProfileParams indicates an expected call of NewDeleteVgpuProfileParams.
func (mr *MockGPUServiceIfaceMockRecorder) NewDeleteVgpuProfileParams(id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewDeleteVgpuProfileParams", reflect.TypeOf((*MockGPUServiceIface)(nil).NewDeleteVgpuProfileParams), id)
}

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

// NewDiscoverGpuDevicesParams indicates an expected call of NewDiscoverGpuDevicesParams.
func (mr *MockGPUServiceIfaceMockRecorder) NewDiscoverGpuDevicesParams(id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewDiscoverGpuDevicesParams", reflect.TypeOf((*MockGPUServiceIface)(nil).NewDiscoverGpuDevicesParams), id)
}

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

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

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

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

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

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

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

// NewManageGpuDeviceParams indicates an expected call of NewManageGpuDeviceParams.
func (mr *MockGPUServiceIfaceMockRecorder) NewManageGpuDeviceParams(ids any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewManageGpuDeviceParams", reflect.TypeOf((*MockGPUServiceIface)(nil).NewManageGpuDeviceParams), ids)
}

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

// NewUnmanageGpuDeviceParams indicates an expected call of NewUnmanageGpuDeviceParams.
func (mr *MockGPUServiceIfaceMockRecorder) NewUnmanageGpuDeviceParams(ids any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewUnmanageGpuDeviceParams", reflect.TypeOf((*MockGPUServiceIface)(nil).NewUnmanageGpuDeviceParams), ids)
}

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

// NewUpdateGpuCardParams indicates an expected call of NewUpdateGpuCardParams.
func (mr *MockGPUServiceIfaceMockRecorder) NewUpdateGpuCardParams(id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewUpdateGpuCardParams", reflect.TypeOf((*MockGPUServiceIface)(nil).NewUpdateGpuCardParams), id)
}

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

// NewUpdateGpuDeviceParams indicates an expected call of NewUpdateGpuDeviceParams.
func (mr *MockGPUServiceIfaceMockRecorder) NewUpdateGpuDeviceParams(id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewUpdateGpuDeviceParams", reflect.TypeOf((*MockGPUServiceIface)(nil).NewUpdateGpuDeviceParams), id)
}

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

// NewUpdateVgpuProfileParams indicates an expected call of NewUpdateVgpuProfileParams.
func (mr *MockGPUServiceIfaceMockRecorder) NewUpdateVgpuProfileParams(id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewUpdateVgpuProfileParams", reflect.TypeOf((*MockGPUServiceIface)(nil).NewUpdateVgpuProfileParams), id)
}

// UnmanageGpuDevice mocks base method.
func (m *MockGPUServiceIface) UnmanageGpuDevice(p *UnmanageGpuDeviceParams) (*UnmanageGpuDeviceResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UnmanageGpuDevice", p)
	ret0, _ := ret[0].(*UnmanageGpuDeviceResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UnmanageGpuDevice indicates an expected call of UnmanageGpuDevice.
func (mr *MockGPUServiceIfaceMockRecorder) UnmanageGpuDevice(p any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnmanageGpuDevice", reflect.TypeOf((*MockGPUServiceIface)(nil).UnmanageGpuDevice), p)
}

// UpdateGpuCard mocks base method.
func (m *MockGPUServiceIface) UpdateGpuCard(p *UpdateGpuCardParams) (*UpdateGpuCardResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateGpuCard", p)
	ret0, _ := ret[0].(*UpdateGpuCardResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateGpuCard indicates an expected call of UpdateGpuCard.
func (mr *MockGPUServiceIfaceMockRecorder) UpdateGpuCard(p any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateGpuCard", reflect.TypeOf((*MockGPUServiceIface)(nil).UpdateGpuCard), p)
}

// UpdateGpuDevice mocks base method.
func (m *MockGPUServiceIface) UpdateGpuDevice(p *UpdateGpuDeviceParams) (*UpdateGpuDeviceResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateGpuDevice", p)
	ret0, _ := ret[0].(*UpdateGpuDeviceResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateGpuDevice indicates an expected call of UpdateGpuDevice.
func (mr *MockGPUServiceIfaceMockRecorder) UpdateGpuDevice(p any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateGpuDevice", reflect.TypeOf((*MockGPUServiceIface)(nil).UpdateGpuDevice), p)
}

// UpdateVgpuProfile mocks base method.
func (m *MockGPUServiceIface) UpdateVgpuProfile(p *UpdateVgpuProfileParams) (*UpdateVgpuProfileResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateVgpuProfile", p)
	ret0, _ := ret[0].(*UpdateVgpuProfileResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateVgpuProfile indicates an expected call of UpdateVgpuProfile.
func (mr *MockGPUServiceIfaceMockRecorder) UpdateVgpuProfile(p any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateVgpuProfile", reflect.TypeOf((*MockGPUServiceIface)(nil).UpdateVgpuProfile), p)
}