// Code generated by moq; DO NOT EDIT.
// github.com/matryer/moq

package nvcdi

import (
	"sync"

	"github.com/NVIDIA/go-nvlib/pkg/nvlib/info"
)

// Ensure, that infoInterfaceMock does implement infoInterface.
// If this is not the case, regenerate this file with moq.
var _ infoInterface = &infoInterfaceMock{}

// infoInterfaceMock is a mock implementation of infoInterface.
//
//	func TestSomethingThatUsesinfoInterface(t *testing.T) {
//
//		// make and configure a mocked infoInterface
//		mockedinfoInterface := &infoInterfaceMock{
//			HasAnIntegratedGPUFunc: func() (bool, string) {
//				panic("mock out the HasAnIntegratedGPU method")
//			},
//			HasDXCoreFunc: func() (bool, string) {
//				panic("mock out the HasDXCore method")
//			},
//			HasNvmlFunc: func() (bool, string) {
//				panic("mock out the HasNvml method")
//			},
//			HasTegraFilesFunc: func() (bool, string) {
//				panic("mock out the HasTegraFiles method")
//			},
//			ResolvePlatformFunc: func() info.Platform {
//				panic("mock out the ResolvePlatform method")
//			},
//		}
//
//		// use mockedinfoInterface in code that requires infoInterface
//		// and then make assertions.
//
//	}
type infoInterfaceMock struct {
	// HasAnIntegratedGPUFunc mocks the HasAnIntegratedGPU method.
	HasAnIntegratedGPUFunc func() (bool, string)

	// HasDXCoreFunc mocks the HasDXCore method.
	HasDXCoreFunc func() (bool, string)

	// HasNvmlFunc mocks the HasNvml method.
	HasNvmlFunc func() (bool, string)

	// HasTegraFilesFunc mocks the HasTegraFiles method.
	HasTegraFilesFunc func() (bool, string)

	// ResolvePlatformFunc mocks the ResolvePlatform method.
	ResolvePlatformFunc func() info.Platform

	// calls tracks calls to the methods.
	calls struct {
		// HasAnIntegratedGPU holds details about calls to the HasAnIntegratedGPU method.
		HasAnIntegratedGPU []struct {
		}
		// HasDXCore holds details about calls to the HasDXCore method.
		HasDXCore []struct {
		}
		// HasNvml holds details about calls to the HasNvml method.
		HasNvml []struct {
		}
		// HasTegraFiles holds details about calls to the HasTegraFiles method.
		HasTegraFiles []struct {
		}
		// ResolvePlatform holds details about calls to the ResolvePlatform method.
		ResolvePlatform []struct {
		}
	}
	lockHasAnIntegratedGPU sync.RWMutex
	lockHasDXCore          sync.RWMutex
	lockHasNvml            sync.RWMutex
	lockHasTegraFiles      sync.RWMutex
	lockResolvePlatform    sync.RWMutex
}

// HasAnIntegratedGPU calls HasAnIntegratedGPUFunc.
func (mock *infoInterfaceMock) HasAnIntegratedGPU() (bool, string) {
	callInfo := struct {
	}{}
	mock.lockHasAnIntegratedGPU.Lock()
	mock.calls.HasAnIntegratedGPU = append(mock.calls.HasAnIntegratedGPU, callInfo)
	mock.lockHasAnIntegratedGPU.Unlock()
	if mock.HasAnIntegratedGPUFunc == nil {
		var (
			bOut bool
			sOut string
		)
		return bOut, sOut
	}
	return mock.HasAnIntegratedGPUFunc()
}

// HasAnIntegratedGPUCalls gets all the calls that were made to HasAnIntegratedGPU.
// Check the length with:
//
//	len(mockedinfoInterface.HasAnIntegratedGPUCalls())
func (mock *infoInterfaceMock) HasAnIntegratedGPUCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockHasAnIntegratedGPU.RLock()
	calls = mock.calls.HasAnIntegratedGPU
	mock.lockHasAnIntegratedGPU.RUnlock()
	return calls
}

// HasDXCore calls HasDXCoreFunc.
func (mock *infoInterfaceMock) HasDXCore() (bool, string) {
	callInfo := struct {
	}{}
	mock.lockHasDXCore.Lock()
	mock.calls.HasDXCore = append(mock.calls.HasDXCore, callInfo)
	mock.lockHasDXCore.Unlock()
	if mock.HasDXCoreFunc == nil {
		var (
			bOut bool
			sOut string
		)
		return bOut, sOut
	}
	return mock.HasDXCoreFunc()
}

// HasDXCoreCalls gets all the calls that were made to HasDXCore.
// Check the length with:
//
//	len(mockedinfoInterface.HasDXCoreCalls())
func (mock *infoInterfaceMock) HasDXCoreCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockHasDXCore.RLock()
	calls = mock.calls.HasDXCore
	mock.lockHasDXCore.RUnlock()
	return calls
}

// HasNvml calls HasNvmlFunc.
func (mock *infoInterfaceMock) HasNvml() (bool, string) {
	callInfo := struct {
	}{}
	mock.lockHasNvml.Lock()
	mock.calls.HasNvml = append(mock.calls.HasNvml, callInfo)
	mock.lockHasNvml.Unlock()
	if mock.HasNvmlFunc == nil {
		var (
			bOut bool
			sOut string
		)
		return bOut, sOut
	}
	return mock.HasNvmlFunc()
}

// HasNvmlCalls gets all the calls that were made to HasNvml.
// Check the length with:
//
//	len(mockedinfoInterface.HasNvmlCalls())
func (mock *infoInterfaceMock) HasNvmlCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockHasNvml.RLock()
	calls = mock.calls.HasNvml
	mock.lockHasNvml.RUnlock()
	return calls
}

// HasTegraFiles calls HasTegraFilesFunc.
func (mock *infoInterfaceMock) HasTegraFiles() (bool, string) {
	callInfo := struct {
	}{}
	mock.lockHasTegraFiles.Lock()
	mock.calls.HasTegraFiles = append(mock.calls.HasTegraFiles, callInfo)
	mock.lockHasTegraFiles.Unlock()
	if mock.HasTegraFilesFunc == nil {
		var (
			bOut bool
			sOut string
		)
		return bOut, sOut
	}
	return mock.HasTegraFilesFunc()
}

// HasTegraFilesCalls gets all the calls that were made to HasTegraFiles.
// Check the length with:
//
//	len(mockedinfoInterface.HasTegraFilesCalls())
func (mock *infoInterfaceMock) HasTegraFilesCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockHasTegraFiles.RLock()
	calls = mock.calls.HasTegraFiles
	mock.lockHasTegraFiles.RUnlock()
	return calls
}

// ResolvePlatform calls ResolvePlatformFunc.
func (mock *infoInterfaceMock) ResolvePlatform() info.Platform {
	callInfo := struct {
	}{}
	mock.lockResolvePlatform.Lock()
	mock.calls.ResolvePlatform = append(mock.calls.ResolvePlatform, callInfo)
	mock.lockResolvePlatform.Unlock()
	if mock.ResolvePlatformFunc == nil {
		var (
			platformOut info.Platform
		)
		return platformOut
	}
	return mock.ResolvePlatformFunc()
}

// ResolvePlatformCalls gets all the calls that were made to ResolvePlatform.
// Check the length with:
//
//	len(mockedinfoInterface.ResolvePlatformCalls())
func (mock *infoInterfaceMock) ResolvePlatformCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockResolvePlatform.RLock()
	calls = mock.calls.ResolvePlatform
	mock.lockResolvePlatform.RUnlock()
	return calls
}
