go-golden/golden_mock_test.go

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

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

import (
	reflect "reflect"

	gomock "github.com/golang/mock/gomock"
)

// MockTestingT is a mock of TestingT interface.
type MockTestingT struct {
	ctrl     *gomock.Controller
	recorder *MockTestingTMockRecorder
}

// MockTestingTMockRecorder is the mock recorder for MockTestingT.
type MockTestingTMockRecorder struct {
	mock *MockTestingT
}

// NewMockTestingT creates a new mock instance.
func NewMockTestingT(ctrl *gomock.Controller) *MockTestingT {
	mock := &MockTestingT{ctrl: ctrl}
	mock.recorder = &MockTestingTMockRecorder{mock}
	return mock
}

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

// Fatal mocks base method.
func (m *MockTestingT) Fatal(args ...interface{}) {
	m.ctrl.T.Helper()
	varargs := []interface{}{}
	for _, a := range args {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Fatal", varargs...)
}

// Fatal indicates an expected call of Fatal.
func (mr *MockTestingTMockRecorder) Fatal(args ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Fatal", reflect.TypeOf((*MockTestingT)(nil).Fatal), args...)
}

// Fatalf mocks base method.
func (m *MockTestingT) Fatalf(format string, args ...interface{}) {
	m.ctrl.T.Helper()
	varargs := []interface{}{format}
	for _, a := range args {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Fatalf", varargs...)
}

// Fatalf indicates an expected call of Fatalf.
func (mr *MockTestingTMockRecorder) Fatalf(format interface{}, args ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{format}, args...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Fatalf", reflect.TypeOf((*MockTestingT)(nil).Fatalf), varargs...)
}

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

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

// Log mocks base method.
func (m *MockTestingT) Log(args ...interface{}) {
	m.ctrl.T.Helper()
	varargs := []interface{}{}
	for _, a := range args {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Log", varargs...)
}

// Log indicates an expected call of Log.
func (mr *MockTestingTMockRecorder) Log(args ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Log", reflect.TypeOf((*MockTestingT)(nil).Log), args...)
}

// Logf mocks base method.
func (m *MockTestingT) Logf(format string, args ...interface{}) {
	m.ctrl.T.Helper()
	varargs := []interface{}{format}
	for _, a := range args {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Logf", varargs...)
}

// Logf indicates an expected call of Logf.
func (mr *MockTestingTMockRecorder) Logf(format interface{}, args ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{format}, args...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Logf", reflect.TypeOf((*MockTestingT)(nil).Logf), varargs...)
}

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

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

// MockGolden is a mock of Golden interface.
type MockGolden struct {
	ctrl     *gomock.Controller
	recorder *MockGoldenMockRecorder
}

// MockGoldenMockRecorder is the mock recorder for MockGolden.
type MockGoldenMockRecorder struct {
	mock *MockGolden
}

// NewMockGolden creates a new mock instance.
func NewMockGolden(ctrl *gomock.Controller) *MockGolden {
	mock := &MockGolden{ctrl: ctrl}
	mock.recorder = &MockGoldenMockRecorder{mock}
	return mock
}

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

// Do mocks base method.
func (m *MockGolden) Do(t TestingT, data []byte) []byte {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Do", t, data)
	ret0, _ := ret[0].([]byte)
	return ret0
}

// Do indicates an expected call of Do.
func (mr *MockGoldenMockRecorder) Do(t, data interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Do", reflect.TypeOf((*MockGolden)(nil).Do), t, data)
}

// DoP mocks base method.
func (m *MockGolden) DoP(t TestingT, name string, data []byte) []byte {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DoP", t, name, data)
	ret0, _ := ret[0].([]byte)
	return ret0
}

// DoP indicates an expected call of DoP.
func (mr *MockGoldenMockRecorder) DoP(t, name, data interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DoP", reflect.TypeOf((*MockGolden)(nil).DoP), t, name, data)
}

// File mocks base method.
func (m *MockGolden) File(t TestingT) string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "File", t)
	ret0, _ := ret[0].(string)
	return ret0
}

// File indicates an expected call of File.
func (mr *MockGoldenMockRecorder) File(t interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "File", reflect.TypeOf((*MockGolden)(nil).File), t)
}

// FileP mocks base method.
func (m *MockGolden) FileP(t TestingT, name string) string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FileP", t, name)
	ret0, _ := ret[0].(string)
	return ret0
}

// FileP indicates an expected call of FileP.
func (mr *MockGoldenMockRecorder) FileP(t, name interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FileP", reflect.TypeOf((*MockGolden)(nil).FileP), t, name)
}

// Get mocks base method.
func (m *MockGolden) Get(t TestingT) []byte {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", t)
	ret0, _ := ret[0].([]byte)
	return ret0
}

// Get indicates an expected call of Get.
func (mr *MockGoldenMockRecorder) Get(t interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockGolden)(nil).Get), t)
}

// GetP mocks base method.
func (m *MockGolden) GetP(t TestingT, name string) []byte {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetP", t, name)
	ret0, _ := ret[0].([]byte)
	return ret0
}

// GetP indicates an expected call of GetP.
func (mr *MockGoldenMockRecorder) GetP(t, name interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetP", reflect.TypeOf((*MockGolden)(nil).GetP), t, name)
}

// Set mocks base method.
func (m *MockGolden) Set(t TestingT, data []byte) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Set", t, data)
}

// Set indicates an expected call of Set.
func (mr *MockGoldenMockRecorder) Set(t, data interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Set", reflect.TypeOf((*MockGolden)(nil).Set), t, data)
}

// SetP mocks base method.
func (m *MockGolden) SetP(t TestingT, name string, data []byte) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetP", t, name, data)
}

// SetP indicates an expected call of SetP.
func (mr *MockGoldenMockRecorder) SetP(t, name, data interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetP", reflect.TypeOf((*MockGolden)(nil).SetP), t, name, data)
}

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

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

// MockOption is a mock of Option interface.
type MockOption struct {
	ctrl     *gomock.Controller
	recorder *MockOptionMockRecorder
}

// MockOptionMockRecorder is the mock recorder for MockOption.
type MockOptionMockRecorder struct {
	mock *MockOption
}

// NewMockOption creates a new mock instance.
func NewMockOption(ctrl *gomock.Controller) *MockOption {
	mock := &MockOption{ctrl: ctrl}
	mock.recorder = &MockOptionMockRecorder{mock}
	return mock
}

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

// apply mocks base method.
func (m *MockOption) apply(arg0 *golden) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "apply", arg0)
}

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