/*
 * Copyright 2022 CloudWeGo Authors
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
*/


// Code generated by MockGen. DO NOT EDIT.
// Source: ../../pkg/klog/log.go

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

import (
	context "context"
	io "io"
	reflect "reflect"

	klog "github.com/cloudwego/kitex/pkg/klog"
	gomock "github.com/golang/mock/gomock"
)

// MockFormatLogger is a mock of FormatLogger interface.
type MockFormatLogger struct {
	ctrl     *gomock.Controller
	recorder *MockFormatLoggerMockRecorder
}

// MockFormatLoggerMockRecorder is the mock recorder for MockFormatLogger.
type MockFormatLoggerMockRecorder struct {
	mock *MockFormatLogger
}

// NewMockFormatLogger creates a new mock instance.
func NewMockFormatLogger(ctrl *gomock.Controller) *MockFormatLogger {
	mock := &MockFormatLogger{ctrl: ctrl}
	mock.recorder = &MockFormatLoggerMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// MockLogger is a mock of Logger interface.
type MockLogger struct {
	ctrl     *gomock.Controller
	recorder *MockLoggerMockRecorder
}

// MockLoggerMockRecorder is the mock recorder for MockLogger.
type MockLoggerMockRecorder struct {
	mock *MockLogger
}

// NewMockLogger creates a new mock instance.
func NewMockLogger(ctrl *gomock.Controller) *MockLogger {
	mock := &MockLogger{ctrl: ctrl}
	mock.recorder = &MockLoggerMockRecorder{mock}
	return mock
}

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

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

// Debug indicates an expected call of Debug.
func (mr *MockLoggerMockRecorder) Debug(v ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Debug", reflect.TypeOf((*MockLogger)(nil).Debug), v...)
}

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

// Error indicates an expected call of Error.
func (mr *MockLoggerMockRecorder) Error(v ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Error", reflect.TypeOf((*MockLogger)(nil).Error), v...)
}

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

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

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

// Info indicates an expected call of Info.
func (mr *MockLoggerMockRecorder) Info(v ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Info", reflect.TypeOf((*MockLogger)(nil).Info), v...)
}

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

// Notice indicates an expected call of Notice.
func (mr *MockLoggerMockRecorder) Notice(v ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Notice", reflect.TypeOf((*MockLogger)(nil).Notice), v...)
}

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

// Trace indicates an expected call of Trace.
func (mr *MockLoggerMockRecorder) Trace(v ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trace", reflect.TypeOf((*MockLogger)(nil).Trace), v...)
}

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

// Warn indicates an expected call of Warn.
func (mr *MockLoggerMockRecorder) Warn(v ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Warn", reflect.TypeOf((*MockLogger)(nil).Warn), v...)
}

// MockCtxLogger is a mock of CtxLogger interface.
type MockCtxLogger struct {
	ctrl     *gomock.Controller
	recorder *MockCtxLoggerMockRecorder
}

// MockCtxLoggerMockRecorder is the mock recorder for MockCtxLogger.
type MockCtxLoggerMockRecorder struct {
	mock *MockCtxLogger
}

// NewMockCtxLogger creates a new mock instance.
func NewMockCtxLogger(ctrl *gomock.Controller) *MockCtxLogger {
	mock := &MockCtxLogger{ctrl: ctrl}
	mock.recorder = &MockCtxLoggerMockRecorder{mock}
	return mock
}

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

// CtxDebugf mocks base method.
func (m *MockCtxLogger) CtxDebugf(ctx context.Context, format string, v ...interface{}) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, format}
	for _, a := range v {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "CtxDebugf", varargs...)
}

// CtxDebugf indicates an expected call of CtxDebugf.
func (mr *MockCtxLoggerMockRecorder) CtxDebugf(ctx, format interface{}, v ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, format}, v...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CtxDebugf", reflect.TypeOf((*MockCtxLogger)(nil).CtxDebugf), varargs...)
}

// CtxErrorf mocks base method.
func (m *MockCtxLogger) CtxErrorf(ctx context.Context, format string, v ...interface{}) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, format}
	for _, a := range v {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "CtxErrorf", varargs...)
}

// CtxErrorf indicates an expected call of CtxErrorf.
func (mr *MockCtxLoggerMockRecorder) CtxErrorf(ctx, format interface{}, v ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, format}, v...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CtxErrorf", reflect.TypeOf((*MockCtxLogger)(nil).CtxErrorf), varargs...)
}

// CtxFatalf mocks base method.
func (m *MockCtxLogger) CtxFatalf(ctx context.Context, format string, v ...interface{}) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, format}
	for _, a := range v {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "CtxFatalf", varargs...)
}

// CtxFatalf indicates an expected call of CtxFatalf.
func (mr *MockCtxLoggerMockRecorder) CtxFatalf(ctx, format interface{}, v ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, format}, v...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CtxFatalf", reflect.TypeOf((*MockCtxLogger)(nil).CtxFatalf), varargs...)
}

// CtxInfof mocks base method.
func (m *MockCtxLogger) CtxInfof(ctx context.Context, format string, v ...interface{}) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, format}
	for _, a := range v {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "CtxInfof", varargs...)
}

// CtxInfof indicates an expected call of CtxInfof.
func (mr *MockCtxLoggerMockRecorder) CtxInfof(ctx, format interface{}, v ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, format}, v...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CtxInfof", reflect.TypeOf((*MockCtxLogger)(nil).CtxInfof), varargs...)
}

// CtxNoticef mocks base method.
func (m *MockCtxLogger) CtxNoticef(ctx context.Context, format string, v ...interface{}) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, format}
	for _, a := range v {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "CtxNoticef", varargs...)
}

// CtxNoticef indicates an expected call of CtxNoticef.
func (mr *MockCtxLoggerMockRecorder) CtxNoticef(ctx, format interface{}, v ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, format}, v...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CtxNoticef", reflect.TypeOf((*MockCtxLogger)(nil).CtxNoticef), varargs...)
}

// CtxTracef mocks base method.
func (m *MockCtxLogger) CtxTracef(ctx context.Context, format string, v ...interface{}) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, format}
	for _, a := range v {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "CtxTracef", varargs...)
}

// CtxTracef indicates an expected call of CtxTracef.
func (mr *MockCtxLoggerMockRecorder) CtxTracef(ctx, format interface{}, v ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, format}, v...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CtxTracef", reflect.TypeOf((*MockCtxLogger)(nil).CtxTracef), varargs...)
}

// CtxWarnf mocks base method.
func (m *MockCtxLogger) CtxWarnf(ctx context.Context, format string, v ...interface{}) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, format}
	for _, a := range v {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "CtxWarnf", varargs...)
}

// CtxWarnf indicates an expected call of CtxWarnf.
func (mr *MockCtxLoggerMockRecorder) CtxWarnf(ctx, format interface{}, v ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, format}, v...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CtxWarnf", reflect.TypeOf((*MockCtxLogger)(nil).CtxWarnf), varargs...)
}

// MockControl is a mock of Control interface.
type MockControl struct {
	ctrl     *gomock.Controller
	recorder *MockControlMockRecorder
}

// MockControlMockRecorder is the mock recorder for MockControl.
type MockControlMockRecorder struct {
	mock *MockControl
}

// NewMockControl creates a new mock instance.
func NewMockControl(ctrl *gomock.Controller) *MockControl {
	mock := &MockControl{ctrl: ctrl}
	mock.recorder = &MockControlMockRecorder{mock}
	return mock
}

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

// SetLevel mocks base method.
func (m *MockControl) SetLevel(arg0 klog.Level) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetLevel", arg0)
}

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

// SetOutput mocks base method.
func (m *MockControl) SetOutput(arg0 io.Writer) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetOutput", arg0)
}

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

// MockFullLogger is a mock of FullLogger interface.
type MockFullLogger struct {
	ctrl     *gomock.Controller
	recorder *MockFullLoggerMockRecorder
}

// MockFullLoggerMockRecorder is the mock recorder for MockFullLogger.
type MockFullLoggerMockRecorder struct {
	mock *MockFullLogger
}

// NewMockFullLogger creates a new mock instance.
func NewMockFullLogger(ctrl *gomock.Controller) *MockFullLogger {
	mock := &MockFullLogger{ctrl: ctrl}
	mock.recorder = &MockFullLoggerMockRecorder{mock}
	return mock
}

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

// CtxDebugf mocks base method.
func (m *MockFullLogger) CtxDebugf(ctx context.Context, format string, v ...interface{}) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, format}
	for _, a := range v {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "CtxDebugf", varargs...)
}

// CtxDebugf indicates an expected call of CtxDebugf.
func (mr *MockFullLoggerMockRecorder) CtxDebugf(ctx, format interface{}, v ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, format}, v...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CtxDebugf", reflect.TypeOf((*MockFullLogger)(nil).CtxDebugf), varargs...)
}

// CtxErrorf mocks base method.
func (m *MockFullLogger) CtxErrorf(ctx context.Context, format string, v ...interface{}) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, format}
	for _, a := range v {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "CtxErrorf", varargs...)
}

// CtxErrorf indicates an expected call of CtxErrorf.
func (mr *MockFullLoggerMockRecorder) CtxErrorf(ctx, format interface{}, v ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, format}, v...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CtxErrorf", reflect.TypeOf((*MockFullLogger)(nil).CtxErrorf), varargs...)
}

// CtxFatalf mocks base method.
func (m *MockFullLogger) CtxFatalf(ctx context.Context, format string, v ...interface{}) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, format}
	for _, a := range v {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "CtxFatalf", varargs...)
}

// CtxFatalf indicates an expected call of CtxFatalf.
func (mr *MockFullLoggerMockRecorder) CtxFatalf(ctx, format interface{}, v ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, format}, v...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CtxFatalf", reflect.TypeOf((*MockFullLogger)(nil).CtxFatalf), varargs...)
}

// CtxInfof mocks base method.
func (m *MockFullLogger) CtxInfof(ctx context.Context, format string, v ...interface{}) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, format}
	for _, a := range v {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "CtxInfof", varargs...)
}

// CtxInfof indicates an expected call of CtxInfof.
func (mr *MockFullLoggerMockRecorder) CtxInfof(ctx, format interface{}, v ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, format}, v...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CtxInfof", reflect.TypeOf((*MockFullLogger)(nil).CtxInfof), varargs...)
}

// CtxNoticef mocks base method.
func (m *MockFullLogger) CtxNoticef(ctx context.Context, format string, v ...interface{}) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, format}
	for _, a := range v {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "CtxNoticef", varargs...)
}

// CtxNoticef indicates an expected call of CtxNoticef.
func (mr *MockFullLoggerMockRecorder) CtxNoticef(ctx, format interface{}, v ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, format}, v...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CtxNoticef", reflect.TypeOf((*MockFullLogger)(nil).CtxNoticef), varargs...)
}

// CtxTracef mocks base method.
func (m *MockFullLogger) CtxTracef(ctx context.Context, format string, v ...interface{}) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, format}
	for _, a := range v {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "CtxTracef", varargs...)
}

// CtxTracef indicates an expected call of CtxTracef.
func (mr *MockFullLoggerMockRecorder) CtxTracef(ctx, format interface{}, v ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, format}, v...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CtxTracef", reflect.TypeOf((*MockFullLogger)(nil).CtxTracef), varargs...)
}

// CtxWarnf mocks base method.
func (m *MockFullLogger) CtxWarnf(ctx context.Context, format string, v ...interface{}) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, format}
	for _, a := range v {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "CtxWarnf", varargs...)
}

// CtxWarnf indicates an expected call of CtxWarnf.
func (mr *MockFullLoggerMockRecorder) CtxWarnf(ctx, format interface{}, v ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, format}, v...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CtxWarnf", reflect.TypeOf((*MockFullLogger)(nil).CtxWarnf), varargs...)
}

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

// Debug indicates an expected call of Debug.
func (mr *MockFullLoggerMockRecorder) Debug(v ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Debug", reflect.TypeOf((*MockFullLogger)(nil).Debug), v...)
}

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

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

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

// Error indicates an expected call of Error.
func (mr *MockFullLoggerMockRecorder) Error(v ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Error", reflect.TypeOf((*MockFullLogger)(nil).Error), v...)
}

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

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

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

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

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

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

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

// Info indicates an expected call of Info.
func (mr *MockFullLoggerMockRecorder) Info(v ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Info", reflect.TypeOf((*MockFullLogger)(nil).Info), v...)
}

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

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

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

// Notice indicates an expected call of Notice.
func (mr *MockFullLoggerMockRecorder) Notice(v ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Notice", reflect.TypeOf((*MockFullLogger)(nil).Notice), v...)
}

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

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

// SetLevel mocks base method.
func (m *MockFullLogger) SetLevel(arg0 klog.Level) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetLevel", arg0)
}

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

// SetOutput mocks base method.
func (m *MockFullLogger) SetOutput(arg0 io.Writer) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetOutput", arg0)
}

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

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

// Trace indicates an expected call of Trace.
func (mr *MockFullLoggerMockRecorder) Trace(v ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trace", reflect.TypeOf((*MockFullLogger)(nil).Trace), v...)
}

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

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

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

// Warn indicates an expected call of Warn.
func (mr *MockFullLoggerMockRecorder) Warn(v ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Warn", reflect.TypeOf((*MockFullLogger)(nil).Warn), v...)
}

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

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