github.com/jenkins-x/jx/v2@v2.1.155/pkg/cmd/clients/mocks/jenkins_client.go

// Code generated by pegomock. DO NOT EDIT.
// Source: github.com/jenkins-x/golang-jenkins (interfaces: JenkinsClient)

package clients_test

import (
	io "io"
	http "net/http"
	url "net/url"
	"reflect"
	"time"

	golang_jenkins "github.com/jenkins-x/golang-jenkins"
	pegomock "github.com/petergtz/pegomock"
)

type MockJenkinsClient struct {
	fail func(message string, callerSkip ...int)
}

func NewMockJenkinsClient(options ...pegomock.Option) *MockJenkinsClient {
	mock := &MockJenkinsClient{}
	for _, option := range options {
		option.Apply(mock)
	}
	return mock
}

func (mock *MockJenkinsClient) SetFailHandler(fh pegomock.FailHandler) { mock.fail = fh }
func (mock *MockJenkinsClient) FailHandler() pegomock.FailHandler      { return mock.fail }

func (mock *MockJenkinsClient) AddJobToView(_param0 string, _param1 golang_jenkins.Job) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockJenkinsClient().")
	}
	params := []pegomock.Param{_param0, _param1}
	result := pegomock.GetGenericMockFrom(mock).Invoke("AddJobToView", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockJenkinsClient) BaseURL() string {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockJenkinsClient().")
	}
	params := []pegomock.Param{}
	result := pegomock.GetGenericMockFrom(mock).Invoke("BaseURL", params, []reflect.Type{reflect.TypeOf((*string)(nil)).Elem()})
	var ret0 string
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(string)
		}
	}
	return ret0
}

func (mock *MockJenkinsClient) Build(_param0 golang_jenkins.Job, _param1 url.Values) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockJenkinsClient().")
	}
	params := []pegomock.Param{_param0, _param1}
	result := pegomock.GetGenericMockFrom(mock).Invoke("Build", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockJenkinsClient) CreateCredential(_param0 string, _param1 string, _param2 string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockJenkinsClient().")
	}
	params := []pegomock.Param{_param0, _param1, _param2}
	result := pegomock.GetGenericMockFrom(mock).Invoke("CreateCredential", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockJenkinsClient) CreateFolderJobWithXML(_param0 string, _param1 string, _param2 string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockJenkinsClient().")
	}
	params := []pegomock.Param{_param0, _param1, _param2}
	result := pegomock.GetGenericMockFrom(mock).Invoke("CreateFolderJobWithXML", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockJenkinsClient) CreateJob(_param0 golang_jenkins.JobItem, _param1 string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockJenkinsClient().")
	}
	params := []pegomock.Param{_param0, _param1}
	result := pegomock.GetGenericMockFrom(mock).Invoke("CreateJob", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockJenkinsClient) CreateJobWithXML(_param0 string, _param1 string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockJenkinsClient().")
	}
	params := []pegomock.Param{_param0, _param1}
	result := pegomock.GetGenericMockFrom(mock).Invoke("CreateJobWithXML", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockJenkinsClient) CreateView(_param0 golang_jenkins.ListView) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockJenkinsClient().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("CreateView", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockJenkinsClient) DeleteJob(_param0 golang_jenkins.Job) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockJenkinsClient().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("DeleteJob", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockJenkinsClient) GetArtifact(_param0 golang_jenkins.Build, _param1 golang_jenkins.Artifact) ([]byte, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockJenkinsClient().")
	}
	params := []pegomock.Param{_param0, _param1}
	result := pegomock.GetGenericMockFrom(mock).Invoke("GetArtifact", params, []reflect.Type{reflect.TypeOf((*[]byte)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 []byte
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].([]byte)
		}
		if result[1] != nil {
			ret1 = result[1].(error)
		}
	}
	return ret0, ret1
}

func (mock *MockJenkinsClient) GetBuild(_param0 golang_jenkins.Job, _param1 int) (golang_jenkins.Build, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockJenkinsClient().")
	}
	params := []pegomock.Param{_param0, _param1}
	result := pegomock.GetGenericMockFrom(mock).Invoke("GetBuild", params, []reflect.Type{reflect.TypeOf((*golang_jenkins.Build)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 golang_jenkins.Build
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(golang_jenkins.Build)
		}
		if result[1] != nil {
			ret1 = result[1].(error)
		}
	}
	return ret0, ret1
}

func (mock *MockJenkinsClient) GetBuildConsoleOutput(_param0 golang_jenkins.Build) ([]byte, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockJenkinsClient().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("GetBuildConsoleOutput", params, []reflect.Type{reflect.TypeOf((*[]byte)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 []byte
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].([]byte)
		}
		if result[1] != nil {
			ret1 = result[1].(error)
		}
	}
	return ret0, ret1
}

func (mock *MockJenkinsClient) GetBuildURL(_param0 golang_jenkins.Job, _param1 int) string {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockJenkinsClient().")
	}
	params := []pegomock.Param{_param0, _param1}
	result := pegomock.GetGenericMockFrom(mock).Invoke("GetBuildURL", params, []reflect.Type{reflect.TypeOf((*string)(nil)).Elem()})
	var ret0 string
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(string)
		}
	}
	return ret0
}

func (mock *MockJenkinsClient) GetComputer(_param0 string) (golang_jenkins.Computer, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockJenkinsClient().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("GetComputer", params, []reflect.Type{reflect.TypeOf((*golang_jenkins.Computer)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 golang_jenkins.Computer
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(golang_jenkins.Computer)
		}
		if result[1] != nil {
			ret1 = result[1].(error)
		}
	}
	return ret0, ret1
}

func (mock *MockJenkinsClient) GetComputerObject() (golang_jenkins.ComputerObject, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockJenkinsClient().")
	}
	params := []pegomock.Param{}
	result := pegomock.GetGenericMockFrom(mock).Invoke("GetComputerObject", params, []reflect.Type{reflect.TypeOf((*golang_jenkins.ComputerObject)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 golang_jenkins.ComputerObject
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(golang_jenkins.ComputerObject)
		}
		if result[1] != nil {
			ret1 = result[1].(error)
		}
	}
	return ret0, ret1
}

func (mock *MockJenkinsClient) GetComputers() ([]golang_jenkins.Computer, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockJenkinsClient().")
	}
	params := []pegomock.Param{}
	result := pegomock.GetGenericMockFrom(mock).Invoke("GetComputers", params, []reflect.Type{reflect.TypeOf((*[]golang_jenkins.Computer)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 []golang_jenkins.Computer
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].([]golang_jenkins.Computer)
		}
		if result[1] != nil {
			ret1 = result[1].(error)
		}
	}
	return ret0, ret1
}

func (mock *MockJenkinsClient) GetCredential(_param0 string) (*golang_jenkins.Credentials, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockJenkinsClient().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("GetCredential", params, []reflect.Type{reflect.TypeOf((**golang_jenkins.Credentials)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 *golang_jenkins.Credentials
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(*golang_jenkins.Credentials)
		}
		if result[1] != nil {
			ret1 = result[1].(error)
		}
	}
	return ret0, ret1
}

func (mock *MockJenkinsClient) GetJob(_param0 string) (golang_jenkins.Job, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockJenkinsClient().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("GetJob", params, []reflect.Type{reflect.TypeOf((*golang_jenkins.Job)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 golang_jenkins.Job
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(golang_jenkins.Job)
		}
		if result[1] != nil {
			ret1 = result[1].(error)
		}
	}
	return ret0, ret1
}

func (mock *MockJenkinsClient) GetJobByPath(_param0 ...string) (golang_jenkins.Job, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockJenkinsClient().")
	}
	params := []pegomock.Param{}
	for _, param := range _param0 {
		params = append(params, param)
	}
	result := pegomock.GetGenericMockFrom(mock).Invoke("GetJobByPath", params, []reflect.Type{reflect.TypeOf((*golang_jenkins.Job)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 golang_jenkins.Job
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(golang_jenkins.Job)
		}
		if result[1] != nil {
			ret1 = result[1].(error)
		}
	}
	return ret0, ret1
}

func (mock *MockJenkinsClient) GetJobConfig(_param0 string) (golang_jenkins.JobItem, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockJenkinsClient().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("GetJobConfig", params, []reflect.Type{reflect.TypeOf((*golang_jenkins.JobItem)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 golang_jenkins.JobItem
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(golang_jenkins.JobItem)
		}
		if result[1] != nil {
			ret1 = result[1].(error)
		}
	}
	return ret0, ret1
}

func (mock *MockJenkinsClient) GetJobURLPath(_param0 string) string {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockJenkinsClient().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("GetJobURLPath", params, []reflect.Type{reflect.TypeOf((*string)(nil)).Elem()})
	var ret0 string
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(string)
		}
	}
	return ret0
}

func (mock *MockJenkinsClient) GetJobs() ([]golang_jenkins.Job, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockJenkinsClient().")
	}
	params := []pegomock.Param{}
	result := pegomock.GetGenericMockFrom(mock).Invoke("GetJobs", params, []reflect.Type{reflect.TypeOf((*[]golang_jenkins.Job)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 []golang_jenkins.Job
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].([]golang_jenkins.Job)
		}
		if result[1] != nil {
			ret1 = result[1].(error)
		}
	}
	return ret0, ret1
}

func (mock *MockJenkinsClient) GetLastBuild(_param0 golang_jenkins.Job) (golang_jenkins.Build, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockJenkinsClient().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("GetLastBuild", params, []reflect.Type{reflect.TypeOf((*golang_jenkins.Build)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 golang_jenkins.Build
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(golang_jenkins.Build)
		}
		if result[1] != nil {
			ret1 = result[1].(error)
		}
	}
	return ret0, ret1
}

func (mock *MockJenkinsClient) GetLogFromURL(_param0 string, _param1 int64, _param2 *golang_jenkins.LogData) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockJenkinsClient().")
	}
	params := []pegomock.Param{_param0, _param1, _param2}
	result := pegomock.GetGenericMockFrom(mock).Invoke("GetLogFromURL", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockJenkinsClient) GetMultiBranchJob(_param0 string, _param1 string, _param2 string) (golang_jenkins.Job, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockJenkinsClient().")
	}
	params := []pegomock.Param{_param0, _param1, _param2}
	result := pegomock.GetGenericMockFrom(mock).Invoke("GetMultiBranchJob", params, []reflect.Type{reflect.TypeOf((*golang_jenkins.Job)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 golang_jenkins.Job
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(golang_jenkins.Job)
		}
		if result[1] != nil {
			ret1 = result[1].(error)
		}
	}
	return ret0, ret1
}

func (mock *MockJenkinsClient) GetOrganizationScanResult(_param0 int, _param1 golang_jenkins.Job) (string, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockJenkinsClient().")
	}
	params := []pegomock.Param{_param0, _param1}
	result := pegomock.GetGenericMockFrom(mock).Invoke("GetOrganizationScanResult", params, []reflect.Type{reflect.TypeOf((*string)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 string
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(string)
		}
		if result[1] != nil {
			ret1 = result[1].(error)
		}
	}
	return ret0, ret1
}

func (mock *MockJenkinsClient) GetQueue() (golang_jenkins.Queue, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockJenkinsClient().")
	}
	params := []pegomock.Param{}
	result := pegomock.GetGenericMockFrom(mock).Invoke("GetQueue", params, []reflect.Type{reflect.TypeOf((*golang_jenkins.Queue)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 golang_jenkins.Queue
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(golang_jenkins.Queue)
		}
		if result[1] != nil {
			ret1 = result[1].(error)
		}
	}
	return ret0, ret1
}

func (mock *MockJenkinsClient) IsErrNotFound(_param0 error) bool {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockJenkinsClient().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("IsErrNotFound", params, []reflect.Type{reflect.TypeOf((*bool)(nil)).Elem()})
	var ret0 bool
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(bool)
		}
	}
	return ret0
}

func (mock *MockJenkinsClient) NewLogPoller(_param0 string, _param1 io.Writer) *golang_jenkins.LogPoller {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockJenkinsClient().")
	}
	params := []pegomock.Param{_param0, _param1}
	result := pegomock.GetGenericMockFrom(mock).Invoke("NewLogPoller", params, []reflect.Type{reflect.TypeOf((**golang_jenkins.LogPoller)(nil)).Elem()})
	var ret0 *golang_jenkins.LogPoller
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(*golang_jenkins.LogPoller)
		}
	}
	return ret0
}

func (mock *MockJenkinsClient) Post(_param0 string, _param1 url.Values, _param2 interface{}) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockJenkinsClient().")
	}
	params := []pegomock.Param{_param0, _param1, _param2}
	result := pegomock.GetGenericMockFrom(mock).Invoke("Post", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockJenkinsClient) QuietDown() error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockJenkinsClient().")
	}
	params := []pegomock.Param{}
	result := pegomock.GetGenericMockFrom(mock).Invoke("QuietDown", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockJenkinsClient) Reload() error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockJenkinsClient().")
	}
	params := []pegomock.Param{}
	result := pegomock.GetGenericMockFrom(mock).Invoke("Reload", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockJenkinsClient) RemoveJob(_param0 string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockJenkinsClient().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("RemoveJob", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockJenkinsClient) Restart() error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockJenkinsClient().")
	}
	params := []pegomock.Param{}
	result := pegomock.GetGenericMockFrom(mock).Invoke("Restart", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockJenkinsClient) SafeRestart() error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockJenkinsClient().")
	}
	params := []pegomock.Param{}
	result := pegomock.GetGenericMockFrom(mock).Invoke("SafeRestart", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockJenkinsClient) SetBuildDescription(_param0 golang_jenkins.Build, _param1 string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockJenkinsClient().")
	}
	params := []pegomock.Param{_param0, _param1}
	result := pegomock.GetGenericMockFrom(mock).Invoke("SetBuildDescription", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockJenkinsClient) SetHTTPClient(_param0 *http.Client) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockJenkinsClient().")
	}
	params := []pegomock.Param{_param0}
	pegomock.GetGenericMockFrom(mock).Invoke("SetHTTPClient", params, []reflect.Type{})
}

func (mock *MockJenkinsClient) StopBuild(_param0 golang_jenkins.Job, _param1 int) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockJenkinsClient().")
	}
	params := []pegomock.Param{_param0, _param1}
	result := pegomock.GetGenericMockFrom(mock).Invoke("StopBuild", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockJenkinsClient) TailLog(_param0 string, _param1 io.Writer, _param2 time.Duration, _param3 time.Duration) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockJenkinsClient().")
	}
	params := []pegomock.Param{_param0, _param1, _param2, _param3}
	result := pegomock.GetGenericMockFrom(mock).Invoke("TailLog", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockJenkinsClient) TailLogFunc(_param0 string, _param1 io.Writer) golang_jenkins.ConditionFunc {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockJenkinsClient().")
	}
	params := []pegomock.Param{_param0, _param1}
	result := pegomock.GetGenericMockFrom(mock).Invoke("TailLogFunc", params, []reflect.Type{reflect.TypeOf((*golang_jenkins.ConditionFunc)(nil)).Elem()})
	var ret0 golang_jenkins.ConditionFunc
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(golang_jenkins.ConditionFunc)
		}
	}
	return ret0
}

func (mock *MockJenkinsClient) UpdateJob(_param0 golang_jenkins.JobItem, _param1 string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockJenkinsClient().")
	}
	params := []pegomock.Param{_param0, _param1}
	result := pegomock.GetGenericMockFrom(mock).Invoke("UpdateJob", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockJenkinsClient) VerifyWasCalledOnce() *VerifierMockJenkinsClient {
	return &VerifierMockJenkinsClient{
		mock:                   mock,
		invocationCountMatcher: pegomock.Times(1),
	}
}

func (mock *MockJenkinsClient) VerifyWasCalled(invocationCountMatcher pegomock.Matcher) *VerifierMockJenkinsClient {
	return &VerifierMockJenkinsClient{
		mock:                   mock,
		invocationCountMatcher: invocationCountMatcher,
	}
}

func (mock *MockJenkinsClient) VerifyWasCalledInOrder(invocationCountMatcher pegomock.Matcher, inOrderContext *pegomock.InOrderContext) *VerifierMockJenkinsClient {
	return &VerifierMockJenkinsClient{
		mock:                   mock,
		invocationCountMatcher: invocationCountMatcher,
		inOrderContext:         inOrderContext,
	}
}

func (mock *MockJenkinsClient) VerifyWasCalledEventually(invocationCountMatcher pegomock.Matcher, timeout time.Duration) *VerifierMockJenkinsClient {
	return &VerifierMockJenkinsClient{
		mock:                   mock,
		invocationCountMatcher: invocationCountMatcher,
		timeout:                timeout,
	}
}

type VerifierMockJenkinsClient struct {
	mock                   *MockJenkinsClient
	invocationCountMatcher pegomock.Matcher
	inOrderContext         *pegomock.InOrderContext
	timeout                time.Duration
}

func (verifier *VerifierMockJenkinsClient) AddJobToView(_param0 string, _param1 golang_jenkins.Job) *MockJenkinsClient_AddJobToView_OngoingVerification {
	params := []pegomock.Param{_param0, _param1}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "AddJobToView", params, verifier.timeout)
	return &MockJenkinsClient_AddJobToView_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockJenkinsClient_AddJobToView_OngoingVerification struct {
	mock              *MockJenkinsClient
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockJenkinsClient_AddJobToView_OngoingVerification) GetCapturedArguments() (string, golang_jenkins.Job) {
	_param0, _param1 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1]
}

func (c *MockJenkinsClient_AddJobToView_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []golang_jenkins.Job) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(params[0]))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]golang_jenkins.Job, len(params[1]))
		for u, param := range params[1] {
			_param1[u] = param.(golang_jenkins.Job)
		}
	}
	return
}

func (verifier *VerifierMockJenkinsClient) BaseURL() *MockJenkinsClient_BaseURL_OngoingVerification {
	params := []pegomock.Param{}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "BaseURL", params, verifier.timeout)
	return &MockJenkinsClient_BaseURL_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockJenkinsClient_BaseURL_OngoingVerification struct {
	mock              *MockJenkinsClient
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockJenkinsClient_BaseURL_OngoingVerification) GetCapturedArguments() {
}

func (c *MockJenkinsClient_BaseURL_OngoingVerification) GetAllCapturedArguments() {
}

func (verifier *VerifierMockJenkinsClient) Build(_param0 golang_jenkins.Job, _param1 url.Values) *MockJenkinsClient_Build_OngoingVerification {
	params := []pegomock.Param{_param0, _param1}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "Build", params, verifier.timeout)
	return &MockJenkinsClient_Build_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockJenkinsClient_Build_OngoingVerification struct {
	mock              *MockJenkinsClient
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockJenkinsClient_Build_OngoingVerification) GetCapturedArguments() (golang_jenkins.Job, url.Values) {
	_param0, _param1 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1]
}

func (c *MockJenkinsClient_Build_OngoingVerification) GetAllCapturedArguments() (_param0 []golang_jenkins.Job, _param1 []url.Values) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]golang_jenkins.Job, len(params[0]))
		for u, param := range params[0] {
			_param0[u] = param.(golang_jenkins.Job)
		}
		_param1 = make([]url.Values, len(params[1]))
		for u, param := range params[1] {
			_param1[u] = param.(url.Values)
		}
	}
	return
}

func (verifier *VerifierMockJenkinsClient) CreateCredential(_param0 string, _param1 string, _param2 string) *MockJenkinsClient_CreateCredential_OngoingVerification {
	params := []pegomock.Param{_param0, _param1, _param2}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "CreateCredential", params, verifier.timeout)
	return &MockJenkinsClient_CreateCredential_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockJenkinsClient_CreateCredential_OngoingVerification struct {
	mock              *MockJenkinsClient
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockJenkinsClient_CreateCredential_OngoingVerification) GetCapturedArguments() (string, string, string) {
	_param0, _param1, _param2 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1], _param2[len(_param2)-1]
}

func (c *MockJenkinsClient_CreateCredential_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string, _param2 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(params[0]))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]string, len(params[1]))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
		_param2 = make([]string, len(params[2]))
		for u, param := range params[2] {
			_param2[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockJenkinsClient) CreateFolderJobWithXML(_param0 string, _param1 string, _param2 string) *MockJenkinsClient_CreateFolderJobWithXML_OngoingVerification {
	params := []pegomock.Param{_param0, _param1, _param2}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "CreateFolderJobWithXML", params, verifier.timeout)
	return &MockJenkinsClient_CreateFolderJobWithXML_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockJenkinsClient_CreateFolderJobWithXML_OngoingVerification struct {
	mock              *MockJenkinsClient
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockJenkinsClient_CreateFolderJobWithXML_OngoingVerification) GetCapturedArguments() (string, string, string) {
	_param0, _param1, _param2 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1], _param2[len(_param2)-1]
}

func (c *MockJenkinsClient_CreateFolderJobWithXML_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string, _param2 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(params[0]))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]string, len(params[1]))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
		_param2 = make([]string, len(params[2]))
		for u, param := range params[2] {
			_param2[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockJenkinsClient) CreateJob(_param0 golang_jenkins.JobItem, _param1 string) *MockJenkinsClient_CreateJob_OngoingVerification {
	params := []pegomock.Param{_param0, _param1}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "CreateJob", params, verifier.timeout)
	return &MockJenkinsClient_CreateJob_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockJenkinsClient_CreateJob_OngoingVerification struct {
	mock              *MockJenkinsClient
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockJenkinsClient_CreateJob_OngoingVerification) GetCapturedArguments() (golang_jenkins.JobItem, string) {
	_param0, _param1 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1]
}

func (c *MockJenkinsClient_CreateJob_OngoingVerification) GetAllCapturedArguments() (_param0 []golang_jenkins.JobItem, _param1 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]golang_jenkins.JobItem, len(params[0]))
		for u, param := range params[0] {
			_param0[u] = param.(golang_jenkins.JobItem)
		}
		_param1 = make([]string, len(params[1]))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockJenkinsClient) CreateJobWithXML(_param0 string, _param1 string) *MockJenkinsClient_CreateJobWithXML_OngoingVerification {
	params := []pegomock.Param{_param0, _param1}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "CreateJobWithXML", params, verifier.timeout)
	return &MockJenkinsClient_CreateJobWithXML_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockJenkinsClient_CreateJobWithXML_OngoingVerification struct {
	mock              *MockJenkinsClient
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockJenkinsClient_CreateJobWithXML_OngoingVerification) GetCapturedArguments() (string, string) {
	_param0, _param1 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1]
}

func (c *MockJenkinsClient_CreateJobWithXML_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(params[0]))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]string, len(params[1]))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockJenkinsClient) CreateView(_param0 golang_jenkins.ListView) *MockJenkinsClient_CreateView_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "CreateView", params, verifier.timeout)
	return &MockJenkinsClient_CreateView_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockJenkinsClient_CreateView_OngoingVerification struct {
	mock              *MockJenkinsClient
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockJenkinsClient_CreateView_OngoingVerification) GetCapturedArguments() golang_jenkins.ListView {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

func (c *MockJenkinsClient_CreateView_OngoingVerification) GetAllCapturedArguments() (_param0 []golang_jenkins.ListView) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]golang_jenkins.ListView, len(params[0]))
		for u, param := range params[0] {
			_param0[u] = param.(golang_jenkins.ListView)
		}
	}
	return
}

func (verifier *VerifierMockJenkinsClient) DeleteJob(_param0 golang_jenkins.Job) *MockJenkinsClient_DeleteJob_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "DeleteJob", params, verifier.timeout)
	return &MockJenkinsClient_DeleteJob_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockJenkinsClient_DeleteJob_OngoingVerification struct {
	mock              *MockJenkinsClient
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockJenkinsClient_DeleteJob_OngoingVerification) GetCapturedArguments() golang_jenkins.Job {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

func (c *MockJenkinsClient_DeleteJob_OngoingVerification) GetAllCapturedArguments() (_param0 []golang_jenkins.Job) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]golang_jenkins.Job, len(params[0]))
		for u, param := range params[0] {
			_param0[u] = param.(golang_jenkins.Job)
		}
	}
	return
}

func (verifier *VerifierMockJenkinsClient) GetArtifact(_param0 golang_jenkins.Build, _param1 golang_jenkins.Artifact) *MockJenkinsClient_GetArtifact_OngoingVerification {
	params := []pegomock.Param{_param0, _param1}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "GetArtifact", params, verifier.timeout)
	return &MockJenkinsClient_GetArtifact_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockJenkinsClient_GetArtifact_OngoingVerification struct {
	mock              *MockJenkinsClient
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockJenkinsClient_GetArtifact_OngoingVerification) GetCapturedArguments() (golang_jenkins.Build, golang_jenkins.Artifact) {
	_param0, _param1 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1]
}

func (c *MockJenkinsClient_GetArtifact_OngoingVerification) GetAllCapturedArguments() (_param0 []golang_jenkins.Build, _param1 []golang_jenkins.Artifact) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]golang_jenkins.Build, len(params[0]))
		for u, param := range params[0] {
			_param0[u] = param.(golang_jenkins.Build)
		}
		_param1 = make([]golang_jenkins.Artifact, len(params[1]))
		for u, param := range params[1] {
			_param1[u] = param.(golang_jenkins.Artifact)
		}
	}
	return
}

func (verifier *VerifierMockJenkinsClient) GetBuild(_param0 golang_jenkins.Job, _param1 int) *MockJenkinsClient_GetBuild_OngoingVerification {
	params := []pegomock.Param{_param0, _param1}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "GetBuild", params, verifier.timeout)
	return &MockJenkinsClient_GetBuild_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockJenkinsClient_GetBuild_OngoingVerification struct {
	mock              *MockJenkinsClient
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockJenkinsClient_GetBuild_OngoingVerification) GetCapturedArguments() (golang_jenkins.Job, int) {
	_param0, _param1 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1]
}

func (c *MockJenkinsClient_GetBuild_OngoingVerification) GetAllCapturedArguments() (_param0 []golang_jenkins.Job, _param1 []int) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]golang_jenkins.Job, len(params[0]))
		for u, param := range params[0] {
			_param0[u] = param.(golang_jenkins.Job)
		}
		_param1 = make([]int, len(params[1]))
		for u, param := range params[1] {
			_param1[u] = param.(int)
		}
	}
	return
}

func (verifier *VerifierMockJenkinsClient) GetBuildConsoleOutput(_param0 golang_jenkins.Build) *MockJenkinsClient_GetBuildConsoleOutput_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "GetBuildConsoleOutput", params, verifier.timeout)
	return &MockJenkinsClient_GetBuildConsoleOutput_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockJenkinsClient_GetBuildConsoleOutput_OngoingVerification struct {
	mock              *MockJenkinsClient
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockJenkinsClient_GetBuildConsoleOutput_OngoingVerification) GetCapturedArguments() golang_jenkins.Build {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

func (c *MockJenkinsClient_GetBuildConsoleOutput_OngoingVerification) GetAllCapturedArguments() (_param0 []golang_jenkins.Build) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]golang_jenkins.Build, len(params[0]))
		for u, param := range params[0] {
			_param0[u] = param.(golang_jenkins.Build)
		}
	}
	return
}

func (verifier *VerifierMockJenkinsClient) GetBuildURL(_param0 golang_jenkins.Job, _param1 int) *MockJenkinsClient_GetBuildURL_OngoingVerification {
	params := []pegomock.Param{_param0, _param1}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "GetBuildURL", params, verifier.timeout)
	return &MockJenkinsClient_GetBuildURL_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockJenkinsClient_GetBuildURL_OngoingVerification struct {
	mock              *MockJenkinsClient
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockJenkinsClient_GetBuildURL_OngoingVerification) GetCapturedArguments() (golang_jenkins.Job, int) {
	_param0, _param1 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1]
}

func (c *MockJenkinsClient_GetBuildURL_OngoingVerification) GetAllCapturedArguments() (_param0 []golang_jenkins.Job, _param1 []int) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]golang_jenkins.Job, len(params[0]))
		for u, param := range params[0] {
			_param0[u] = param.(golang_jenkins.Job)
		}
		_param1 = make([]int, len(params[1]))
		for u, param := range params[1] {
			_param1[u] = param.(int)
		}
	}
	return
}

func (verifier *VerifierMockJenkinsClient) GetComputer(_param0 string) *MockJenkinsClient_GetComputer_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "GetComputer", params, verifier.timeout)
	return &MockJenkinsClient_GetComputer_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockJenkinsClient_GetComputer_OngoingVerification struct {
	mock              *MockJenkinsClient
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockJenkinsClient_GetComputer_OngoingVerification) GetCapturedArguments() string {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

func (c *MockJenkinsClient_GetComputer_OngoingVerification) GetAllCapturedArguments() (_param0 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(params[0]))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockJenkinsClient) GetComputerObject() *MockJenkinsClient_GetComputerObject_OngoingVerification {
	params := []pegomock.Param{}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "GetComputerObject", params, verifier.timeout)
	return &MockJenkinsClient_GetComputerObject_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockJenkinsClient_GetComputerObject_OngoingVerification struct {
	mock              *MockJenkinsClient
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockJenkinsClient_GetComputerObject_OngoingVerification) GetCapturedArguments() {
}

func (c *MockJenkinsClient_GetComputerObject_OngoingVerification) GetAllCapturedArguments() {
}

func (verifier *VerifierMockJenkinsClient) GetComputers() *MockJenkinsClient_GetComputers_OngoingVerification {
	params := []pegomock.Param{}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "GetComputers", params, verifier.timeout)
	return &MockJenkinsClient_GetComputers_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockJenkinsClient_GetComputers_OngoingVerification struct {
	mock              *MockJenkinsClient
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockJenkinsClient_GetComputers_OngoingVerification) GetCapturedArguments() {
}

func (c *MockJenkinsClient_GetComputers_OngoingVerification) GetAllCapturedArguments() {
}

func (verifier *VerifierMockJenkinsClient) GetCredential(_param0 string) *MockJenkinsClient_GetCredential_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "GetCredential", params, verifier.timeout)
	return &MockJenkinsClient_GetCredential_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockJenkinsClient_GetCredential_OngoingVerification struct {
	mock              *MockJenkinsClient
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockJenkinsClient_GetCredential_OngoingVerification) GetCapturedArguments() string {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

func (c *MockJenkinsClient_GetCredential_OngoingVerification) GetAllCapturedArguments() (_param0 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(params[0]))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockJenkinsClient) GetJob(_param0 string) *MockJenkinsClient_GetJob_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "GetJob", params, verifier.timeout)
	return &MockJenkinsClient_GetJob_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockJenkinsClient_GetJob_OngoingVerification struct {
	mock              *MockJenkinsClient
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockJenkinsClient_GetJob_OngoingVerification) GetCapturedArguments() string {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

func (c *MockJenkinsClient_GetJob_OngoingVerification) GetAllCapturedArguments() (_param0 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(params[0]))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockJenkinsClient) GetJobByPath(_param0 ...string) *MockJenkinsClient_GetJobByPath_OngoingVerification {
	params := []pegomock.Param{}
	for _, param := range _param0 {
		params = append(params, param)
	}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "GetJobByPath", params, verifier.timeout)
	return &MockJenkinsClient_GetJobByPath_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockJenkinsClient_GetJobByPath_OngoingVerification struct {
	mock              *MockJenkinsClient
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockJenkinsClient_GetJobByPath_OngoingVerification) GetCapturedArguments() []string {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

func (c *MockJenkinsClient_GetJobByPath_OngoingVerification) GetAllCapturedArguments() (_param0 [][]string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([][]string, len(params[0]))
		for u := range params[0] {
			_param0[u] = make([]string, len(params)-0)
			for x := 0; x < len(params); x++ {
				if params[x][u] != nil {
					_param0[u][x-0] = params[x][u].(string)
				}
			}
		}
	}
	return
}

func (verifier *VerifierMockJenkinsClient) GetJobConfig(_param0 string) *MockJenkinsClient_GetJobConfig_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "GetJobConfig", params, verifier.timeout)
	return &MockJenkinsClient_GetJobConfig_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockJenkinsClient_GetJobConfig_OngoingVerification struct {
	mock              *MockJenkinsClient
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockJenkinsClient_GetJobConfig_OngoingVerification) GetCapturedArguments() string {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

func (c *MockJenkinsClient_GetJobConfig_OngoingVerification) GetAllCapturedArguments() (_param0 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(params[0]))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockJenkinsClient) GetJobURLPath(_param0 string) *MockJenkinsClient_GetJobURLPath_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "GetJobURLPath", params, verifier.timeout)
	return &MockJenkinsClient_GetJobURLPath_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockJenkinsClient_GetJobURLPath_OngoingVerification struct {
	mock              *MockJenkinsClient
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockJenkinsClient_GetJobURLPath_OngoingVerification) GetCapturedArguments() string {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

func (c *MockJenkinsClient_GetJobURLPath_OngoingVerification) GetAllCapturedArguments() (_param0 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(params[0]))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockJenkinsClient) GetJobs() *MockJenkinsClient_GetJobs_OngoingVerification {
	params := []pegomock.Param{}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "GetJobs", params, verifier.timeout)
	return &MockJenkinsClient_GetJobs_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockJenkinsClient_GetJobs_OngoingVerification struct {
	mock              *MockJenkinsClient
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockJenkinsClient_GetJobs_OngoingVerification) GetCapturedArguments() {
}

func (c *MockJenkinsClient_GetJobs_OngoingVerification) GetAllCapturedArguments() {
}

func (verifier *VerifierMockJenkinsClient) GetLastBuild(_param0 golang_jenkins.Job) *MockJenkinsClient_GetLastBuild_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "GetLastBuild", params, verifier.timeout)
	return &MockJenkinsClient_GetLastBuild_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockJenkinsClient_GetLastBuild_OngoingVerification struct {
	mock              *MockJenkinsClient
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockJenkinsClient_GetLastBuild_OngoingVerification) GetCapturedArguments() golang_jenkins.Job {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

func (c *MockJenkinsClient_GetLastBuild_OngoingVerification) GetAllCapturedArguments() (_param0 []golang_jenkins.Job) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]golang_jenkins.Job, len(params[0]))
		for u, param := range params[0] {
			_param0[u] = param.(golang_jenkins.Job)
		}
	}
	return
}

func (verifier *VerifierMockJenkinsClient) GetLogFromURL(_param0 string, _param1 int64, _param2 *golang_jenkins.LogData) *MockJenkinsClient_GetLogFromURL_OngoingVerification {
	params := []pegomock.Param{_param0, _param1, _param2}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "GetLogFromURL", params, verifier.timeout)
	return &MockJenkinsClient_GetLogFromURL_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockJenkinsClient_GetLogFromURL_OngoingVerification struct {
	mock              *MockJenkinsClient
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockJenkinsClient_GetLogFromURL_OngoingVerification) GetCapturedArguments() (string, int64, *golang_jenkins.LogData) {
	_param0, _param1, _param2 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1], _param2[len(_param2)-1]
}

func (c *MockJenkinsClient_GetLogFromURL_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []int64, _param2 []*golang_jenkins.LogData) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(params[0]))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]int64, len(params[1]))
		for u, param := range params[1] {
			_param1[u] = param.(int64)
		}
		_param2 = make([]*golang_jenkins.LogData, len(params[2]))
		for u, param := range params[2] {
			_param2[u] = param.(*golang_jenkins.LogData)
		}
	}
	return
}

func (verifier *VerifierMockJenkinsClient) GetMultiBranchJob(_param0 string, _param1 string, _param2 string) *MockJenkinsClient_GetMultiBranchJob_OngoingVerification {
	params := []pegomock.Param{_param0, _param1, _param2}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "GetMultiBranchJob", params, verifier.timeout)
	return &MockJenkinsClient_GetMultiBranchJob_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockJenkinsClient_GetMultiBranchJob_OngoingVerification struct {
	mock              *MockJenkinsClient
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockJenkinsClient_GetMultiBranchJob_OngoingVerification) GetCapturedArguments() (string, string, string) {
	_param0, _param1, _param2 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1], _param2[len(_param2)-1]
}

func (c *MockJenkinsClient_GetMultiBranchJob_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string, _param2 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(params[0]))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]string, len(params[1]))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
		_param2 = make([]string, len(params[2]))
		for u, param := range params[2] {
			_param2[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockJenkinsClient) GetOrganizationScanResult(_param0 int, _param1 golang_jenkins.Job) *MockJenkinsClient_GetOrganizationScanResult_OngoingVerification {
	params := []pegomock.Param{_param0, _param1}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "GetOrganizationScanResult", params, verifier.timeout)
	return &MockJenkinsClient_GetOrganizationScanResult_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockJenkinsClient_GetOrganizationScanResult_OngoingVerification struct {
	mock              *MockJenkinsClient
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockJenkinsClient_GetOrganizationScanResult_OngoingVerification) GetCapturedArguments() (int, golang_jenkins.Job) {
	_param0, _param1 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1]
}

func (c *MockJenkinsClient_GetOrganizationScanResult_OngoingVerification) GetAllCapturedArguments() (_param0 []int, _param1 []golang_jenkins.Job) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]int, len(params[0]))
		for u, param := range params[0] {
			_param0[u] = param.(int)
		}
		_param1 = make([]golang_jenkins.Job, len(params[1]))
		for u, param := range params[1] {
			_param1[u] = param.(golang_jenkins.Job)
		}
	}
	return
}

func (verifier *VerifierMockJenkinsClient) GetQueue() *MockJenkinsClient_GetQueue_OngoingVerification {
	params := []pegomock.Param{}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "GetQueue", params, verifier.timeout)
	return &MockJenkinsClient_GetQueue_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockJenkinsClient_GetQueue_OngoingVerification struct {
	mock              *MockJenkinsClient
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockJenkinsClient_GetQueue_OngoingVerification) GetCapturedArguments() {
}

func (c *MockJenkinsClient_GetQueue_OngoingVerification) GetAllCapturedArguments() {
}

func (verifier *VerifierMockJenkinsClient) IsErrNotFound(_param0 error) *MockJenkinsClient_IsErrNotFound_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "IsErrNotFound", params, verifier.timeout)
	return &MockJenkinsClient_IsErrNotFound_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockJenkinsClient_IsErrNotFound_OngoingVerification struct {
	mock              *MockJenkinsClient
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockJenkinsClient_IsErrNotFound_OngoingVerification) GetCapturedArguments() error {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

func (c *MockJenkinsClient_IsErrNotFound_OngoingVerification) GetAllCapturedArguments() (_param0 []error) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]error, len(params[0]))
		for u, param := range params[0] {
			_param0[u] = param.(error)
		}
	}
	return
}

func (verifier *VerifierMockJenkinsClient) NewLogPoller(_param0 string, _param1 io.Writer) *MockJenkinsClient_NewLogPoller_OngoingVerification {
	params := []pegomock.Param{_param0, _param1}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "NewLogPoller", params, verifier.timeout)
	return &MockJenkinsClient_NewLogPoller_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockJenkinsClient_NewLogPoller_OngoingVerification struct {
	mock              *MockJenkinsClient
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockJenkinsClient_NewLogPoller_OngoingVerification) GetCapturedArguments() (string, io.Writer) {
	_param0, _param1 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1]
}

func (c *MockJenkinsClient_NewLogPoller_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []io.Writer) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(params[0]))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]io.Writer, len(params[1]))
		for u, param := range params[1] {
			_param1[u] = param.(io.Writer)
		}
	}
	return
}

func (verifier *VerifierMockJenkinsClient) Post(_param0 string, _param1 url.Values, _param2 interface{}) *MockJenkinsClient_Post_OngoingVerification {
	params := []pegomock.Param{_param0, _param1, _param2}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "Post", params, verifier.timeout)
	return &MockJenkinsClient_Post_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockJenkinsClient_Post_OngoingVerification struct {
	mock              *MockJenkinsClient
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockJenkinsClient_Post_OngoingVerification) GetCapturedArguments() (string, url.Values, interface{}) {
	_param0, _param1, _param2 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1], _param2[len(_param2)-1]
}

func (c *MockJenkinsClient_Post_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []url.Values, _param2 []interface{}) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(params[0]))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]url.Values, len(params[1]))
		for u, param := range params[1] {
			_param1[u] = param.(url.Values)
		}
		_param2 = make([]interface{}, len(params[2]))
		for u, param := range params[2] {
			_param2[u] = param.(interface{})
		}
	}
	return
}

func (verifier *VerifierMockJenkinsClient) QuietDown() *MockJenkinsClient_QuietDown_OngoingVerification {
	params := []pegomock.Param{}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "QuietDown", params, verifier.timeout)
	return &MockJenkinsClient_QuietDown_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockJenkinsClient_QuietDown_OngoingVerification struct {
	mock              *MockJenkinsClient
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockJenkinsClient_QuietDown_OngoingVerification) GetCapturedArguments() {
}

func (c *MockJenkinsClient_QuietDown_OngoingVerification) GetAllCapturedArguments() {
}

func (verifier *VerifierMockJenkinsClient) Reload() *MockJenkinsClient_Reload_OngoingVerification {
	params := []pegomock.Param{}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "Reload", params, verifier.timeout)
	return &MockJenkinsClient_Reload_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockJenkinsClient_Reload_OngoingVerification struct {
	mock              *MockJenkinsClient
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockJenkinsClient_Reload_OngoingVerification) GetCapturedArguments() {
}

func (c *MockJenkinsClient_Reload_OngoingVerification) GetAllCapturedArguments() {
}

func (verifier *VerifierMockJenkinsClient) RemoveJob(_param0 string) *MockJenkinsClient_RemoveJob_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "RemoveJob", params, verifier.timeout)
	return &MockJenkinsClient_RemoveJob_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockJenkinsClient_RemoveJob_OngoingVerification struct {
	mock              *MockJenkinsClient
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockJenkinsClient_RemoveJob_OngoingVerification) GetCapturedArguments() string {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

func (c *MockJenkinsClient_RemoveJob_OngoingVerification) GetAllCapturedArguments() (_param0 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(params[0]))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockJenkinsClient) Restart() *MockJenkinsClient_Restart_OngoingVerification {
	params := []pegomock.Param{}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "Restart", params, verifier.timeout)
	return &MockJenkinsClient_Restart_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockJenkinsClient_Restart_OngoingVerification struct {
	mock              *MockJenkinsClient
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockJenkinsClient_Restart_OngoingVerification) GetCapturedArguments() {
}

func (c *MockJenkinsClient_Restart_OngoingVerification) GetAllCapturedArguments() {
}

func (verifier *VerifierMockJenkinsClient) SafeRestart() *MockJenkinsClient_SafeRestart_OngoingVerification {
	params := []pegomock.Param{}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "SafeRestart", params, verifier.timeout)
	return &MockJenkinsClient_SafeRestart_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockJenkinsClient_SafeRestart_OngoingVerification struct {
	mock              *MockJenkinsClient
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockJenkinsClient_SafeRestart_OngoingVerification) GetCapturedArguments() {
}

func (c *MockJenkinsClient_SafeRestart_OngoingVerification) GetAllCapturedArguments() {
}

func (verifier *VerifierMockJenkinsClient) SetBuildDescription(_param0 golang_jenkins.Build, _param1 string) *MockJenkinsClient_SetBuildDescription_OngoingVerification {
	params := []pegomock.Param{_param0, _param1}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "SetBuildDescription", params, verifier.timeout)
	return &MockJenkinsClient_SetBuildDescription_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockJenkinsClient_SetBuildDescription_OngoingVerification struct {
	mock              *MockJenkinsClient
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockJenkinsClient_SetBuildDescription_OngoingVerification) GetCapturedArguments() (golang_jenkins.Build, string) {
	_param0, _param1 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1]
}

func (c *MockJenkinsClient_SetBuildDescription_OngoingVerification) GetAllCapturedArguments() (_param0 []golang_jenkins.Build, _param1 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]golang_jenkins.Build, len(params[0]))
		for u, param := range params[0] {
			_param0[u] = param.(golang_jenkins.Build)
		}
		_param1 = make([]string, len(params[1]))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockJenkinsClient) SetHTTPClient(_param0 *http.Client) *MockJenkinsClient_SetHTTPClient_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "SetHTTPClient", params, verifier.timeout)
	return &MockJenkinsClient_SetHTTPClient_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockJenkinsClient_SetHTTPClient_OngoingVerification struct {
	mock              *MockJenkinsClient
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockJenkinsClient_SetHTTPClient_OngoingVerification) GetCapturedArguments() *http.Client {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

func (c *MockJenkinsClient_SetHTTPClient_OngoingVerification) GetAllCapturedArguments() (_param0 []*http.Client) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]*http.Client, len(params[0]))
		for u, param := range params[0] {
			_param0[u] = param.(*http.Client)
		}
	}
	return
}

func (verifier *VerifierMockJenkinsClient) StopBuild(_param0 golang_jenkins.Job, _param1 int) *MockJenkinsClient_StopBuild_OngoingVerification {
	params := []pegomock.Param{_param0, _param1}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "StopBuild", params, verifier.timeout)
	return &MockJenkinsClient_StopBuild_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockJenkinsClient_StopBuild_OngoingVerification struct {
	mock              *MockJenkinsClient
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockJenkinsClient_StopBuild_OngoingVerification) GetCapturedArguments() (golang_jenkins.Job, int) {
	_param0, _param1 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1]
}

func (c *MockJenkinsClient_StopBuild_OngoingVerification) GetAllCapturedArguments() (_param0 []golang_jenkins.Job, _param1 []int) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]golang_jenkins.Job, len(params[0]))
		for u, param := range params[0] {
			_param0[u] = param.(golang_jenkins.Job)
		}
		_param1 = make([]int, len(params[1]))
		for u, param := range params[1] {
			_param1[u] = param.(int)
		}
	}
	return
}

func (verifier *VerifierMockJenkinsClient) TailLog(_param0 string, _param1 io.Writer, _param2 time.Duration, _param3 time.Duration) *MockJenkinsClient_TailLog_OngoingVerification {
	params := []pegomock.Param{_param0, _param1, _param2, _param3}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "TailLog", params, verifier.timeout)
	return &MockJenkinsClient_TailLog_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockJenkinsClient_TailLog_OngoingVerification struct {
	mock              *MockJenkinsClient
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockJenkinsClient_TailLog_OngoingVerification) GetCapturedArguments() (string, io.Writer, time.Duration, time.Duration) {
	_param0, _param1, _param2, _param3 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1], _param2[len(_param2)-1], _param3[len(_param3)-1]
}

func (c *MockJenkinsClient_TailLog_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []io.Writer, _param2 []time.Duration, _param3 []time.Duration) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(params[0]))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]io.Writer, len(params[1]))
		for u, param := range params[1] {
			_param1[u] = param.(io.Writer)
		}
		_param2 = make([]time.Duration, len(params[2]))
		for u, param := range params[2] {
			_param2[u] = param.(time.Duration)
		}
		_param3 = make([]time.Duration, len(params[3]))
		for u, param := range params[3] {
			_param3[u] = param.(time.Duration)
		}
	}
	return
}

func (verifier *VerifierMockJenkinsClient) TailLogFunc(_param0 string, _param1 io.Writer) *MockJenkinsClient_TailLogFunc_OngoingVerification {
	params := []pegomock.Param{_param0, _param1}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "TailLogFunc", params, verifier.timeout)
	return &MockJenkinsClient_TailLogFunc_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockJenkinsClient_TailLogFunc_OngoingVerification struct {
	mock              *MockJenkinsClient
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockJenkinsClient_TailLogFunc_OngoingVerification) GetCapturedArguments() (string, io.Writer) {
	_param0, _param1 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1]
}

func (c *MockJenkinsClient_TailLogFunc_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []io.Writer) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(params[0]))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]io.Writer, len(params[1]))
		for u, param := range params[1] {
			_param1[u] = param.(io.Writer)
		}
	}
	return
}

func (verifier *VerifierMockJenkinsClient) UpdateJob(_param0 golang_jenkins.JobItem, _param1 string) *MockJenkinsClient_UpdateJob_OngoingVerification {
	params := []pegomock.Param{_param0, _param1}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "UpdateJob", params, verifier.timeout)
	return &MockJenkinsClient_UpdateJob_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockJenkinsClient_UpdateJob_OngoingVerification struct {
	mock              *MockJenkinsClient
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockJenkinsClient_UpdateJob_OngoingVerification) GetCapturedArguments() (golang_jenkins.JobItem, string) {
	_param0, _param1 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1]
}

func (c *MockJenkinsClient_UpdateJob_OngoingVerification) GetAllCapturedArguments() (_param0 []golang_jenkins.JobItem, _param1 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]golang_jenkins.JobItem, len(params[0]))
		for u, param := range params[0] {
			_param0[u] = param.(golang_jenkins.JobItem)
		}
		_param1 = make([]string, len(params[1]))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
	}
	return
}