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

package mock

import (
	"github.com/qor5/admin/worker"
	"sync"
)

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

// QorJobInterfaceMock is a mock implementation of worker.QorJobInterface.
//
//	func TestSomethingThatUsesQorJobInterface(t *testing.T) {
//
//		// make and configure a mocked worker.QorJobInterface
//		mockedQorJobInterface := &QorJobInterfaceMock{
//			AddLogFunc: func(s string) error {
//				panic("mock out the AddLog method")
//			},
//			AddLogfFunc: func(format string, a ...interface{}) error {
//				panic("mock out the AddLogf method")
//			},
//			GetJobInfoFunc: func() (*worker.JobInfo, error) {
//				panic("mock out the GetJobInfo method")
//			},
//			SetProgressFunc: func(v uint) error {
//				panic("mock out the SetProgress method")
//			},
//			SetProgressTextFunc: func(s string) error {
//				panic("mock out the SetProgressText method")
//			},
//		}
//
//		// use mockedQorJobInterface in code that requires worker.QorJobInterface
//		// and then make assertions.
//
//	}
type QorJobInterfaceMock struct {
	// AddLogFunc mocks the AddLog method.
	AddLogFunc func(s string) error

	// AddLogfFunc mocks the AddLogf method.
	AddLogfFunc func(format string, a ...interface{}) error

	// GetJobInfoFunc mocks the GetJobInfo method.
	GetJobInfoFunc func() (*worker.JobInfo, error)

	// SetProgressFunc mocks the SetProgress method.
	SetProgressFunc func(v uint) error

	// SetProgressTextFunc mocks the SetProgressText method.
	SetProgressTextFunc func(s string) error

	// calls tracks calls to the methods.
	calls struct {
		// AddLog holds details about calls to the AddLog method.
		AddLog []struct {
			// S is the s argument value.
			S string
		}
		// AddLogf holds details about calls to the AddLogf method.
		AddLogf []struct {
			// Format is the format argument value.
			Format string
			// A is the a argument value.
			A []interface{}
		}
		// GetJobInfo holds details about calls to the GetJobInfo method.
		GetJobInfo []struct {
		}
		// SetProgress holds details about calls to the SetProgress method.
		SetProgress []struct {
			// V is the v argument value.
			V uint
		}
		// SetProgressText holds details about calls to the SetProgressText method.
		SetProgressText []struct {
			// S is the s argument value.
			S string
		}
	}
	lockAddLog          sync.RWMutex
	lockAddLogf         sync.RWMutex
	lockGetJobInfo      sync.RWMutex
	lockSetProgress     sync.RWMutex
	lockSetProgressText sync.RWMutex
}

// AddLog calls AddLogFunc.
func (mock *QorJobInterfaceMock) AddLog(s string) error {
	if mock.AddLogFunc == nil {
		panic("QorJobInterfaceMock.AddLogFunc: method is nil but QorJobInterface.AddLog was just called")
	}
	callInfo := struct {
		S string
	}{
		S: s,
	}
	mock.lockAddLog.Lock()
	mock.calls.AddLog = append(mock.calls.AddLog, callInfo)
	mock.lockAddLog.Unlock()
	return mock.AddLogFunc(s)
}

// AddLogCalls gets all the calls that were made to AddLog.
// Check the length with:
//
//	len(mockedQorJobInterface.AddLogCalls())
func (mock *QorJobInterfaceMock) AddLogCalls() []struct {
	S string
} {
	var calls []struct {
		S string
	}
	mock.lockAddLog.RLock()
	calls = mock.calls.AddLog
	mock.lockAddLog.RUnlock()
	return calls
}

// AddLogf calls AddLogfFunc.
func (mock *QorJobInterfaceMock) AddLogf(format string, a ...interface{}) error {
	if mock.AddLogfFunc == nil {
		panic("QorJobInterfaceMock.AddLogfFunc: method is nil but QorJobInterface.AddLogf was just called")
	}
	callInfo := struct {
		Format string
		A      []interface{}
	}{
		Format: format,
		A:      a,
	}
	mock.lockAddLogf.Lock()
	mock.calls.AddLogf = append(mock.calls.AddLogf, callInfo)
	mock.lockAddLogf.Unlock()
	return mock.AddLogfFunc(format, a...)
}

// AddLogfCalls gets all the calls that were made to AddLogf.
// Check the length with:
//
//	len(mockedQorJobInterface.AddLogfCalls())
func (mock *QorJobInterfaceMock) AddLogfCalls() []struct {
	Format string
	A      []interface{}
} {
	var calls []struct {
		Format string
		A      []interface{}
	}
	mock.lockAddLogf.RLock()
	calls = mock.calls.AddLogf
	mock.lockAddLogf.RUnlock()
	return calls
}

// GetJobInfo calls GetJobInfoFunc.
func (mock *QorJobInterfaceMock) GetJobInfo() (*worker.JobInfo, error) {
	if mock.GetJobInfoFunc == nil {
		panic("QorJobInterfaceMock.GetJobInfoFunc: method is nil but QorJobInterface.GetJobInfo was just called")
	}
	callInfo := struct {
	}{}
	mock.lockGetJobInfo.Lock()
	mock.calls.GetJobInfo = append(mock.calls.GetJobInfo, callInfo)
	mock.lockGetJobInfo.Unlock()
	return mock.GetJobInfoFunc()
}

// GetJobInfoCalls gets all the calls that were made to GetJobInfo.
// Check the length with:
//
//	len(mockedQorJobInterface.GetJobInfoCalls())
func (mock *QorJobInterfaceMock) GetJobInfoCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetJobInfo.RLock()
	calls = mock.calls.GetJobInfo
	mock.lockGetJobInfo.RUnlock()
	return calls
}

// SetProgress calls SetProgressFunc.
func (mock *QorJobInterfaceMock) SetProgress(v uint) error {
	if mock.SetProgressFunc == nil {
		panic("QorJobInterfaceMock.SetProgressFunc: method is nil but QorJobInterface.SetProgress was just called")
	}
	callInfo := struct {
		V uint
	}{
		V: v,
	}
	mock.lockSetProgress.Lock()
	mock.calls.SetProgress = append(mock.calls.SetProgress, callInfo)
	mock.lockSetProgress.Unlock()
	return mock.SetProgressFunc(v)
}

// SetProgressCalls gets all the calls that were made to SetProgress.
// Check the length with:
//
//	len(mockedQorJobInterface.SetProgressCalls())
func (mock *QorJobInterfaceMock) SetProgressCalls() []struct {
	V uint
} {
	var calls []struct {
		V uint
	}
	mock.lockSetProgress.RLock()
	calls = mock.calls.SetProgress
	mock.lockSetProgress.RUnlock()
	return calls
}

// SetProgressText calls SetProgressTextFunc.
func (mock *QorJobInterfaceMock) SetProgressText(s string) error {
	if mock.SetProgressTextFunc == nil {
		panic("QorJobInterfaceMock.SetProgressTextFunc: method is nil but QorJobInterface.SetProgressText was just called")
	}
	callInfo := struct {
		S string
	}{
		S: s,
	}
	mock.lockSetProgressText.Lock()
	mock.calls.SetProgressText = append(mock.calls.SetProgressText, callInfo)
	mock.lockSetProgressText.Unlock()
	return mock.SetProgressTextFunc(s)
}

// SetProgressTextCalls gets all the calls that were made to SetProgressText.
// Check the length with:
//
//	len(mockedQorJobInterface.SetProgressTextCalls())
func (mock *QorJobInterfaceMock) SetProgressTextCalls() []struct {
	S string
} {
	var calls []struct {
		S string
	}
	mock.lockSetProgressText.RLock()
	calls = mock.calls.SetProgressText
	mock.lockSetProgressText.RUnlock()
	return calls
}