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

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

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

// MockLoggerInt is a mock of LoggerInt interface
type MockLoggerInt struct {
	ctrl     *gomock.Controller
	recorder *MockLoggerIntMockRecorder
}

// MockLoggerIntMockRecorder is the mock recorder for MockLoggerInt
type MockLoggerIntMockRecorder struct {
	mock *MockLoggerInt
}

// NewMockLoggerInt creates a new mock instance
func NewMockLoggerInt(ctrl *gomock.Controller) *MockLoggerInt {
	mock := &MockLoggerInt{ctrl: ctrl}
	mock.recorder = &MockLoggerIntMockRecorder{mock}
	return mock
}

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

// Always mocks base method
func (m *MockLoggerInt) Always(message string) {
	m.ctrl.Call(m, "Always", message)
}

// Always indicates an expected call of Always
func (mr *MockLoggerIntMockRecorder) Always(message interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Always", reflect.TypeOf((*MockLoggerInt)(nil).Always), message)
}

// Warning mocks base method
func (m *MockLoggerInt) Warning(warning string) {
	m.ctrl.Call(m, "Warning", warning)
}

// Warning indicates an expected call of Warning
func (mr *MockLoggerIntMockRecorder) Warning(warning interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Warning", reflect.TypeOf((*MockLoggerInt)(nil).Warning), warning)
}

// Error mocks base method
func (m *MockLoggerInt) Error(err string) {
	m.ctrl.Call(m, "Error", err)
}

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

// Info mocks base method
func (m *MockLoggerInt) Info(info string) {
	m.ctrl.Call(m, "Info", info)
}

// Info indicates an expected call of Info
func (mr *MockLoggerIntMockRecorder) Info(info interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Info", reflect.TypeOf((*MockLoggerInt)(nil).Info), info)
}

// Debug mocks base method
func (m *MockLoggerInt) Debug(debug string) {
	m.ctrl.Call(m, "Debug", debug)
}

// Debug indicates an expected call of Debug
func (mr *MockLoggerIntMockRecorder) Debug(debug interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Debug", reflect.TypeOf((*MockLoggerInt)(nil).Debug), debug)
}

// Trace mocks base method
func (m *MockLoggerInt) Trace(trace string) {
	m.ctrl.Call(m, "Trace", trace)
}

// Trace indicates an expected call of Trace
func (mr *MockLoggerIntMockRecorder) Trace(trace interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trace", reflect.TypeOf((*MockLoggerInt)(nil).Trace), trace)
}

// GetInput mocks base method
func (m *MockLoggerInt) GetInput(message string, v ...interface{}) error {
	varargs := []interface{}{message}
	for _, a := range v {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetInput", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// GetInput indicates an expected call of GetInput
func (mr *MockLoggerIntMockRecorder) GetInput(message interface{}, v ...interface{}) *gomock.Call {
	varargs := append([]interface{}{message}, v...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInput", reflect.TypeOf((*MockLoggerInt)(nil).GetInput), varargs...)
}

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

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

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

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

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

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

// AddResourceForValidation mocks base method
func (m *MockLoggerInt) AddResourceForValidation(resourceName string) *logger.ResourceValidation {
	ret := m.ctrl.Call(m, "AddResourceForValidation", resourceName)
	ret0, _ := ret[0].(*logger.ResourceValidation)
	return ret0
}

// AddResourceForValidation indicates an expected call of AddResourceForValidation
func (mr *MockLoggerIntMockRecorder) AddResourceForValidation(resourceName interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddResourceForValidation", reflect.TypeOf((*MockLoggerInt)(nil).AddResourceForValidation), resourceName)
}

// SetVerbosity mocks base method
func (m *MockLoggerInt) SetVerbosity(verbosity string) {
	m.ctrl.Call(m, "SetVerbosity", verbosity)
}

// SetVerbosity indicates an expected call of SetVerbosity
func (mr *MockLoggerIntMockRecorder) SetVerbosity(verbosity interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetVerbosity", reflect.TypeOf((*MockLoggerInt)(nil).SetVerbosity), verbosity)
}
