mocktesting.go

// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/arteev/tag-assert (interfaces: TB)

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

import (
	gomock "github.com/golang/mock/gomock"
	reflect "reflect"
)

// MockTB is a mock of TB interface
type MockTB struct {
	ctrl     *gomock.Controller
	recorder *MockTBMockRecorder
}

// MockTBMockRecorder is the mock recorder for MockTB
type MockTBMockRecorder struct {
	mock *MockTB
}

// NewMockTB creates a new mock instance
func NewMockTB(ctrl *gomock.Controller) *MockTB {
	mock := &MockTB{ctrl: ctrl}
	mock.recorder = &MockTBMockRecorder{mock}
	return mock
}

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

// Error mocks base method
func (m *MockTB) Error(arg0 ...interface{}) {
	varargs := []interface{}{}
	for _, a := range arg0 {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Error", varargs...)
}

// Error indicates an expected call of Error
func (mr *MockTBMockRecorder) Error(arg0 ...interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Error", reflect.TypeOf((*MockTB)(nil).Error), arg0...)
}

// Errorf mocks base method
func (m *MockTB) Errorf(arg0 string, arg1 ...interface{}) {
	varargs := []interface{}{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Errorf", varargs...)
}

// Errorf indicates an expected call of Errorf
func (mr *MockTBMockRecorder) Errorf(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Errorf", reflect.TypeOf((*MockTB)(nil).Errorf), varargs...)
}

// Fail mocks base method
func (m *MockTB) Fail() {
	m.ctrl.Call(m, "Fail")
}

// Fail indicates an expected call of Fail
func (mr *MockTBMockRecorder) Fail() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Fail", reflect.TypeOf((*MockTB)(nil).Fail))
}

// FailNow mocks base method
func (m *MockTB) FailNow() {
	m.ctrl.Call(m, "FailNow")
}

// FailNow indicates an expected call of FailNow
func (mr *MockTBMockRecorder) FailNow() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FailNow", reflect.TypeOf((*MockTB)(nil).FailNow))
}

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

// Failed indicates an expected call of Failed
func (mr *MockTBMockRecorder) Failed() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Failed", reflect.TypeOf((*MockTB)(nil).Failed))
}

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

// Fatal indicates an expected call of Fatal
func (mr *MockTBMockRecorder) Fatal(arg0 ...interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Fatal", reflect.TypeOf((*MockTB)(nil).Fatal), arg0...)
}

// Fatalf mocks base method
func (m *MockTB) Fatalf(arg0 string, arg1 ...interface{}) {
	varargs := []interface{}{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Fatalf", varargs...)
}

// Fatalf indicates an expected call of Fatalf
func (mr *MockTBMockRecorder) Fatalf(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Fatalf", reflect.TypeOf((*MockTB)(nil).Fatalf), varargs...)
}

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

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

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

// Log indicates an expected call of Log
func (mr *MockTBMockRecorder) Log(arg0 ...interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Log", reflect.TypeOf((*MockTB)(nil).Log), arg0...)
}

// Logf mocks base method
func (m *MockTB) Logf(arg0 string, arg1 ...interface{}) {
	varargs := []interface{}{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Logf", varargs...)
}

// Logf indicates an expected call of Logf
func (mr *MockTBMockRecorder) Logf(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Logf", reflect.TypeOf((*MockTB)(nil).Logf), varargs...)
}

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

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

// Skip mocks base method
func (m *MockTB) Skip(arg0 ...interface{}) {
	varargs := []interface{}{}
	for _, a := range arg0 {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Skip", varargs...)
}

// Skip indicates an expected call of Skip
func (mr *MockTBMockRecorder) Skip(arg0 ...interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Skip", reflect.TypeOf((*MockTB)(nil).Skip), arg0...)
}

// SkipNow mocks base method
func (m *MockTB) SkipNow() {
	m.ctrl.Call(m, "SkipNow")
}

// SkipNow indicates an expected call of SkipNow
func (mr *MockTBMockRecorder) SkipNow() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SkipNow", reflect.TypeOf((*MockTB)(nil).SkipNow))
}

// Skipf mocks base method
func (m *MockTB) Skipf(arg0 string, arg1 ...interface{}) {
	varargs := []interface{}{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Skipf", varargs...)
}

// Skipf indicates an expected call of Skipf
func (mr *MockTBMockRecorder) Skipf(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Skipf", reflect.TypeOf((*MockTB)(nil).Skipf), varargs...)
}

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

// Skipped indicates an expected call of Skipped
func (mr *MockTBMockRecorder) Skipped() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Skipped", reflect.TypeOf((*MockTB)(nil).Skipped))
}