resultdb.mock.pb.go

// Code generated by MockGen. DO NOT EDIT.
// Source: resultdb.pb.go

package resultpb

import (
	context "context"
	reflect "reflect"

	gomock "github.com/golang/mock/gomock"
	grpc "google.golang.org/grpc"
)

// MockisGetTestResultHistoryRequest_Range is a mock of isGetTestResultHistoryRequest_Range interface.
type MockisGetTestResultHistoryRequest_Range struct {
	ctrl     *gomock.Controller
	recorder *MockisGetTestResultHistoryRequest_RangeMockRecorder
}

// MockisGetTestResultHistoryRequest_RangeMockRecorder is the mock recorder for MockisGetTestResultHistoryRequest_Range.
type MockisGetTestResultHistoryRequest_RangeMockRecorder struct {
	mock *MockisGetTestResultHistoryRequest_Range
}

// NewMockisGetTestResultHistoryRequest_Range creates a new mock instance.
func NewMockisGetTestResultHistoryRequest_Range(ctrl *gomock.Controller) *MockisGetTestResultHistoryRequest_Range {
	mock := &MockisGetTestResultHistoryRequest_Range{ctrl: ctrl}
	mock.recorder = &MockisGetTestResultHistoryRequest_RangeMockRecorder{mock}
	return mock
}

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

// isGetTestResultHistoryRequest_Range mocks base method.
func (m *MockisGetTestResultHistoryRequest_Range) isGetTestResultHistoryRequest_Range() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "isGetTestResultHistoryRequest_Range")
}

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

// MockResultDBClient is a mock of ResultDBClient interface.
type MockResultDBClient struct {
	ctrl     *gomock.Controller
	recorder *MockResultDBClientMockRecorder
}

// MockResultDBClientMockRecorder is the mock recorder for MockResultDBClient.
type MockResultDBClientMockRecorder struct {
	mock *MockResultDBClient
}

// NewMockResultDBClient creates a new mock instance.
func NewMockResultDBClient(ctrl *gomock.Controller) *MockResultDBClient {
	mock := &MockResultDBClient{ctrl: ctrl}
	mock.recorder = &MockResultDBClientMockRecorder{mock}
	return mock
}

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

// GetInvocation mocks base method.
func (m *MockResultDBClient) GetInvocation(ctx context.Context, in *GetInvocationRequest, opts ...grpc.CallOption) (*Invocation, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetInvocation", varargs...)
	ret0, _ := ret[0].(*Invocation)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetInvocation indicates an expected call of GetInvocation.
func (mr *MockResultDBClientMockRecorder) GetInvocation(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInvocation", reflect.TypeOf((*MockResultDBClient)(nil).GetInvocation), varargs...)
}

// GetTestResult mocks base method.
func (m *MockResultDBClient) GetTestResult(ctx context.Context, in *GetTestResultRequest, opts ...grpc.CallOption) (*TestResult, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetTestResult", varargs...)
	ret0, _ := ret[0].(*TestResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTestResult indicates an expected call of GetTestResult.
func (mr *MockResultDBClientMockRecorder) GetTestResult(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTestResult", reflect.TypeOf((*MockResultDBClient)(nil).GetTestResult), varargs...)
}

// ListTestResults mocks base method.
func (m *MockResultDBClient) ListTestResults(ctx context.Context, in *ListTestResultsRequest, opts ...grpc.CallOption) (*ListTestResultsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListTestResults", varargs...)
	ret0, _ := ret[0].(*ListTestResultsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListTestResults indicates an expected call of ListTestResults.
func (mr *MockResultDBClientMockRecorder) ListTestResults(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTestResults", reflect.TypeOf((*MockResultDBClient)(nil).ListTestResults), varargs...)
}

// GetTestExoneration mocks base method.
func (m *MockResultDBClient) GetTestExoneration(ctx context.Context, in *GetTestExonerationRequest, opts ...grpc.CallOption) (*TestExoneration, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetTestExoneration", varargs...)
	ret0, _ := ret[0].(*TestExoneration)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTestExoneration indicates an expected call of GetTestExoneration.
func (mr *MockResultDBClientMockRecorder) GetTestExoneration(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTestExoneration", reflect.TypeOf((*MockResultDBClient)(nil).GetTestExoneration), varargs...)
}

// ListTestExonerations mocks base method.
func (m *MockResultDBClient) ListTestExonerations(ctx context.Context, in *ListTestExonerationsRequest, opts ...grpc.CallOption) (*ListTestExonerationsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListTestExonerations", varargs...)
	ret0, _ := ret[0].(*ListTestExonerationsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListTestExonerations indicates an expected call of ListTestExonerations.
func (mr *MockResultDBClientMockRecorder) ListTestExonerations(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTestExonerations", reflect.TypeOf((*MockResultDBClient)(nil).ListTestExonerations), varargs...)
}

// QueryTestResults mocks base method.
func (m *MockResultDBClient) QueryTestResults(ctx context.Context, in *QueryTestResultsRequest, opts ...grpc.CallOption) (*QueryTestResultsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "QueryTestResults", varargs...)
	ret0, _ := ret[0].(*QueryTestResultsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// QueryTestResults indicates an expected call of QueryTestResults.
func (mr *MockResultDBClientMockRecorder) QueryTestResults(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryTestResults", reflect.TypeOf((*MockResultDBClient)(nil).QueryTestResults), varargs...)
}

// QueryTestExonerations mocks base method.
func (m *MockResultDBClient) QueryTestExonerations(ctx context.Context, in *QueryTestExonerationsRequest, opts ...grpc.CallOption) (*QueryTestExonerationsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "QueryTestExonerations", varargs...)
	ret0, _ := ret[0].(*QueryTestExonerationsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// QueryTestExonerations indicates an expected call of QueryTestExonerations.
func (mr *MockResultDBClientMockRecorder) QueryTestExonerations(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryTestExonerations", reflect.TypeOf((*MockResultDBClient)(nil).QueryTestExonerations), varargs...)
}

// QueryTestResultStatistics mocks base method.
func (m *MockResultDBClient) QueryTestResultStatistics(ctx context.Context, in *QueryTestResultStatisticsRequest, opts ...grpc.CallOption) (*QueryTestResultStatisticsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "QueryTestResultStatistics", varargs...)
	ret0, _ := ret[0].(*QueryTestResultStatisticsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// QueryTestResultStatistics indicates an expected call of QueryTestResultStatistics.
func (mr *MockResultDBClientMockRecorder) QueryTestResultStatistics(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryTestResultStatistics", reflect.TypeOf((*MockResultDBClient)(nil).QueryTestResultStatistics), varargs...)
}

// GetArtifact mocks base method.
func (m *MockResultDBClient) GetArtifact(ctx context.Context, in *GetArtifactRequest, opts ...grpc.CallOption) (*Artifact, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetArtifact", varargs...)
	ret0, _ := ret[0].(*Artifact)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetArtifact indicates an expected call of GetArtifact.
func (mr *MockResultDBClientMockRecorder) GetArtifact(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetArtifact", reflect.TypeOf((*MockResultDBClient)(nil).GetArtifact), varargs...)
}

// ListArtifacts mocks base method.
func (m *MockResultDBClient) ListArtifacts(ctx context.Context, in *ListArtifactsRequest, opts ...grpc.CallOption) (*ListArtifactsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListArtifacts", varargs...)
	ret0, _ := ret[0].(*ListArtifactsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListArtifacts indicates an expected call of ListArtifacts.
func (mr *MockResultDBClientMockRecorder) ListArtifacts(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListArtifacts", reflect.TypeOf((*MockResultDBClient)(nil).ListArtifacts), varargs...)
}

// QueryArtifacts mocks base method.
func (m *MockResultDBClient) QueryArtifacts(ctx context.Context, in *QueryArtifactsRequest, opts ...grpc.CallOption) (*QueryArtifactsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "QueryArtifacts", varargs...)
	ret0, _ := ret[0].(*QueryArtifactsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// QueryArtifacts indicates an expected call of QueryArtifacts.
func (mr *MockResultDBClientMockRecorder) QueryArtifacts(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryArtifacts", reflect.TypeOf((*MockResultDBClient)(nil).QueryArtifacts), varargs...)
}

// GetTestResultHistory mocks base method.
func (m *MockResultDBClient) GetTestResultHistory(ctx context.Context, in *GetTestResultHistoryRequest, opts ...grpc.CallOption) (*GetTestResultHistoryResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetTestResultHistory", varargs...)
	ret0, _ := ret[0].(*GetTestResultHistoryResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTestResultHistory indicates an expected call of GetTestResultHistory.
func (mr *MockResultDBClientMockRecorder) GetTestResultHistory(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTestResultHistory", reflect.TypeOf((*MockResultDBClient)(nil).GetTestResultHistory), varargs...)
}

// MockResultDBServer is a mock of ResultDBServer interface.
type MockResultDBServer struct {
	ctrl     *gomock.Controller
	recorder *MockResultDBServerMockRecorder
}

// MockResultDBServerMockRecorder is the mock recorder for MockResultDBServer.
type MockResultDBServerMockRecorder struct {
	mock *MockResultDBServer
}

// NewMockResultDBServer creates a new mock instance.
func NewMockResultDBServer(ctrl *gomock.Controller) *MockResultDBServer {
	mock := &MockResultDBServer{ctrl: ctrl}
	mock.recorder = &MockResultDBServerMockRecorder{mock}
	return mock
}

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

// GetInvocation mocks base method.
func (m *MockResultDBServer) GetInvocation(arg0 context.Context, arg1 *GetInvocationRequest) (*Invocation, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetInvocation", arg0, arg1)
	ret0, _ := ret[0].(*Invocation)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetInvocation indicates an expected call of GetInvocation.
func (mr *MockResultDBServerMockRecorder) GetInvocation(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInvocation", reflect.TypeOf((*MockResultDBServer)(nil).GetInvocation), arg0, arg1)
}

// GetTestResult mocks base method.
func (m *MockResultDBServer) GetTestResult(arg0 context.Context, arg1 *GetTestResultRequest) (*TestResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTestResult", arg0, arg1)
	ret0, _ := ret[0].(*TestResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTestResult indicates an expected call of GetTestResult.
func (mr *MockResultDBServerMockRecorder) GetTestResult(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTestResult", reflect.TypeOf((*MockResultDBServer)(nil).GetTestResult), arg0, arg1)
}

// ListTestResults mocks base method.
func (m *MockResultDBServer) ListTestResults(arg0 context.Context, arg1 *ListTestResultsRequest) (*ListTestResultsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTestResults", arg0, arg1)
	ret0, _ := ret[0].(*ListTestResultsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListTestResults indicates an expected call of ListTestResults.
func (mr *MockResultDBServerMockRecorder) ListTestResults(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTestResults", reflect.TypeOf((*MockResultDBServer)(nil).ListTestResults), arg0, arg1)
}

// GetTestExoneration mocks base method.
func (m *MockResultDBServer) GetTestExoneration(arg0 context.Context, arg1 *GetTestExonerationRequest) (*TestExoneration, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTestExoneration", arg0, arg1)
	ret0, _ := ret[0].(*TestExoneration)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTestExoneration indicates an expected call of GetTestExoneration.
func (mr *MockResultDBServerMockRecorder) GetTestExoneration(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTestExoneration", reflect.TypeOf((*MockResultDBServer)(nil).GetTestExoneration), arg0, arg1)
}

// ListTestExonerations mocks base method.
func (m *MockResultDBServer) ListTestExonerations(arg0 context.Context, arg1 *ListTestExonerationsRequest) (*ListTestExonerationsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTestExonerations", arg0, arg1)
	ret0, _ := ret[0].(*ListTestExonerationsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListTestExonerations indicates an expected call of ListTestExonerations.
func (mr *MockResultDBServerMockRecorder) ListTestExonerations(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTestExonerations", reflect.TypeOf((*MockResultDBServer)(nil).ListTestExonerations), arg0, arg1)
}

// QueryTestResults mocks base method.
func (m *MockResultDBServer) QueryTestResults(arg0 context.Context, arg1 *QueryTestResultsRequest) (*QueryTestResultsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "QueryTestResults", arg0, arg1)
	ret0, _ := ret[0].(*QueryTestResultsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// QueryTestResults indicates an expected call of QueryTestResults.
func (mr *MockResultDBServerMockRecorder) QueryTestResults(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryTestResults", reflect.TypeOf((*MockResultDBServer)(nil).QueryTestResults), arg0, arg1)
}

// QueryTestExonerations mocks base method.
func (m *MockResultDBServer) QueryTestExonerations(arg0 context.Context, arg1 *QueryTestExonerationsRequest) (*QueryTestExonerationsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "QueryTestExonerations", arg0, arg1)
	ret0, _ := ret[0].(*QueryTestExonerationsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// QueryTestExonerations indicates an expected call of QueryTestExonerations.
func (mr *MockResultDBServerMockRecorder) QueryTestExonerations(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryTestExonerations", reflect.TypeOf((*MockResultDBServer)(nil).QueryTestExonerations), arg0, arg1)
}

// QueryTestResultStatistics mocks base method.
func (m *MockResultDBServer) QueryTestResultStatistics(arg0 context.Context, arg1 *QueryTestResultStatisticsRequest) (*QueryTestResultStatisticsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "QueryTestResultStatistics", arg0, arg1)
	ret0, _ := ret[0].(*QueryTestResultStatisticsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// QueryTestResultStatistics indicates an expected call of QueryTestResultStatistics.
func (mr *MockResultDBServerMockRecorder) QueryTestResultStatistics(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryTestResultStatistics", reflect.TypeOf((*MockResultDBServer)(nil).QueryTestResultStatistics), arg0, arg1)
}

// GetArtifact mocks base method.
func (m *MockResultDBServer) GetArtifact(arg0 context.Context, arg1 *GetArtifactRequest) (*Artifact, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetArtifact", arg0, arg1)
	ret0, _ := ret[0].(*Artifact)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetArtifact indicates an expected call of GetArtifact.
func (mr *MockResultDBServerMockRecorder) GetArtifact(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetArtifact", reflect.TypeOf((*MockResultDBServer)(nil).GetArtifact), arg0, arg1)
}

// ListArtifacts mocks base method.
func (m *MockResultDBServer) ListArtifacts(arg0 context.Context, arg1 *ListArtifactsRequest) (*ListArtifactsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListArtifacts", arg0, arg1)
	ret0, _ := ret[0].(*ListArtifactsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListArtifacts indicates an expected call of ListArtifacts.
func (mr *MockResultDBServerMockRecorder) ListArtifacts(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListArtifacts", reflect.TypeOf((*MockResultDBServer)(nil).ListArtifacts), arg0, arg1)
}

// QueryArtifacts mocks base method.
func (m *MockResultDBServer) QueryArtifacts(arg0 context.Context, arg1 *QueryArtifactsRequest) (*QueryArtifactsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "QueryArtifacts", arg0, arg1)
	ret0, _ := ret[0].(*QueryArtifactsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// QueryArtifacts indicates an expected call of QueryArtifacts.
func (mr *MockResultDBServerMockRecorder) QueryArtifacts(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryArtifacts", reflect.TypeOf((*MockResultDBServer)(nil).QueryArtifacts), arg0, arg1)
}

// GetTestResultHistory mocks base method.
func (m *MockResultDBServer) GetTestResultHistory(arg0 context.Context, arg1 *GetTestResultHistoryRequest) (*GetTestResultHistoryResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTestResultHistory", arg0, arg1)
	ret0, _ := ret[0].(*GetTestResultHistoryResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTestResultHistory indicates an expected call of GetTestResultHistory.
func (mr *MockResultDBServerMockRecorder) GetTestResultHistory(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTestResultHistory", reflect.TypeOf((*MockResultDBServer)(nil).GetTestResultHistory), arg0, arg1)
}