logger_test.go

// Copyright (C) 2019-2023 vdaas.org vald team <vald@vdaas.org>
//
// 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
//
//	https://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.
package mock

import (
	"reflect"
	"testing"

	"github.com/vdaas/vald/internal/errors"
	"github.com/vdaas/vald/internal/test/goleak"
)

func TestLogger_Debug(t *testing.T) {
	type args struct {
		vals []interface{}
	}
	type fields struct {
		DebugFunc func(vals ...interface{})
	}
	type want struct{}
	type test struct {
		name       string
		args       args
		fieldsFunc func(*testing.T) fields
		want       want
		checkFunc  func(want) error
		beforeFunc func(args)
		afterFunc  func(args)
	}
	defaultCheckFunc := func(w want) error {
		return nil
	}
	tests := []test{
		func() test {
			wantVals := []interface{}{
				"Vald",
			}
			var cnt int
			return test{
				name: "Call DebugFunc",
				args: args{
					vals: wantVals,
				},
				fieldsFunc: func(t *testing.T) fields {
					t.Helper()
					return fields{
						DebugFunc: func(vals ...interface{}) {
							if !reflect.DeepEqual(vals, wantVals) {
								t.Errorf("got = %v, want = %v", vals, wantVals)
							}
							cnt++
						},
					}
				},
				checkFunc: func(want) error {
					if cnt != 1 {
						return errors.Errorf("got cnt = %d, want = %d", cnt, 1)
					}
					return nil
				},
			}
		}(),
	}

	for _, tc := range tests {
		test := tc
		t.Run(test.name, func(tt *testing.T) {
			defer goleak.VerifyNone(tt)
			if test.beforeFunc != nil {
				test.beforeFunc(test.args)
			}
			if test.afterFunc != nil {
				defer test.afterFunc(test.args)
			}
			checkFunc := test.checkFunc
			if test.checkFunc == nil {
				checkFunc = defaultCheckFunc
			}
			fields := test.fieldsFunc(tt)
			l := &Logger{
				DebugFunc: fields.DebugFunc,
			}

			l.Debug(test.args.vals...)
			if err := checkFunc(test.want); err != nil {
				tt.Errorf("error = %v", err)
			}
		})
	}
}

func TestLogger_Debugf(t *testing.T) {
	type args struct {
		format string
		vals   []interface{}
	}
	type fields struct {
		DebugfFunc func(format string, vals ...interface{})
	}
	type want struct{}
	type test struct {
		name       string
		args       args
		fieldsFunc func(*testing.T) fields
		want       want
		checkFunc  func(want) error
		beforeFunc func(args)
		afterFunc  func(args)
	}
	defaultCheckFunc := func(w want) error {
		return nil
	}
	tests := []test{
		func() test {
			wantVals := []interface{}{
				"Vald",
			}
			wantFormat := "json"
			var cnt int
			return test{
				name: "Call DebugfFunc",
				args: args{
					vals:   wantVals,
					format: wantFormat,
				},
				fieldsFunc: func(t *testing.T) fields {
					t.Helper()
					return fields{
						DebugfFunc: func(format string, vals ...interface{}) {
							if !reflect.DeepEqual(vals, wantVals) || !reflect.DeepEqual(format, wantFormat) {
								t.Errorf("got = %v, want = %v", vals, wantVals)
							}
							cnt++
						},
					}
				},
				checkFunc: func(want) error {
					if cnt != 1 {
						return errors.Errorf("got cnt = %d, want = %d", cnt, 1)
					}
					return nil
				},
			}
		}(),
	}

	for _, tc := range tests {
		test := tc
		t.Run(test.name, func(tt *testing.T) {
			defer goleak.VerifyNone(tt)
			if test.beforeFunc != nil {
				test.beforeFunc(test.args)
			}
			if test.afterFunc != nil {
				defer test.afterFunc(test.args)
			}
			checkFunc := test.checkFunc
			if test.checkFunc == nil {
				checkFunc = defaultCheckFunc
			}
			fields := test.fieldsFunc(tt)
			l := &Logger{
				DebugfFunc: fields.DebugfFunc,
			}

			l.Debugf(test.args.format, test.args.vals...)
			if err := checkFunc(test.want); err != nil {
				tt.Errorf("error = %v", err)
			}
		})
	}
}

func TestLogger_Info(t *testing.T) {
	type args struct {
		vals []interface{}
	}
	type fields struct {
		InfoFunc func(vals ...interface{})
	}
	type want struct{}
	type test struct {
		name       string
		args       args
		fieldsFunc func(*testing.T) fields
		want       want
		checkFunc  func(want) error
		beforeFunc func(args)
		afterFunc  func(args)
	}
	defaultCheckFunc := func(w want) error {
		return nil
	}
	tests := []test{
		func() test {
			wantVals := []interface{}{
				"Vald",
			}
			var cnt int
			return test{
				name: "Call InfoFunc",
				args: args{
					vals: wantVals,
				},
				fieldsFunc: func(t *testing.T) fields {
					t.Helper()
					return fields{
						InfoFunc: func(vals ...interface{}) {
							if !reflect.DeepEqual(vals, wantVals) {
								t.Errorf("got = %v, want = %v", vals, wantVals)
							}
							cnt++
						},
					}
				},
				checkFunc: func(want) error {
					if cnt != 1 {
						return errors.Errorf("got cnt = %d, want = %d", cnt, 1)
					}
					return nil
				},
			}
		}(),
	}

	for _, tc := range tests {
		test := tc
		t.Run(test.name, func(tt *testing.T) {
			defer goleak.VerifyNone(tt)
			if test.beforeFunc != nil {
				test.beforeFunc(test.args)
			}
			if test.afterFunc != nil {
				defer test.afterFunc(test.args)
			}
			checkFunc := test.checkFunc
			if test.checkFunc == nil {
				checkFunc = defaultCheckFunc
			}
			fields := test.fieldsFunc(tt)
			l := &Logger{
				InfoFunc: fields.InfoFunc,
			}

			l.Info(test.args.vals...)
			if err := checkFunc(test.want); err != nil {
				tt.Errorf("error = %v", err)
			}
		})
	}
}

func TestLogger_Infof(t *testing.T) {
	type args struct {
		format string
		vals   []interface{}
	}
	type fields struct {
		InfofFunc func(format string, vals ...interface{})
	}
	type want struct{}
	type test struct {
		name       string
		args       args
		fieldsFunc func(*testing.T) fields
		want       want
		checkFunc  func(want) error
		beforeFunc func(args)
		afterFunc  func(args)
	}
	defaultCheckFunc := func(w want) error {
		return nil
	}
	tests := []test{
		func() test {
			wantVals := []interface{}{
				"Vald",
			}
			wantFormat := "json"
			var cnt int
			return test{
				name: "Call InfofFunc",
				args: args{
					vals:   wantVals,
					format: wantFormat,
				},
				fieldsFunc: func(t *testing.T) fields {
					t.Helper()
					return fields{
						InfofFunc: func(format string, vals ...interface{}) {
							if !reflect.DeepEqual(vals, wantVals) || !reflect.DeepEqual(format, wantFormat) {
								t.Errorf("got = %v, want = %v", vals, wantVals)
							}
							cnt++
						},
					}
				},
				checkFunc: func(want) error {
					if cnt != 1 {
						return errors.Errorf("got cnt = %d, want = %d", cnt, 1)
					}
					return nil
				},
			}
		}(),
	}

	for _, tc := range tests {
		test := tc
		t.Run(test.name, func(tt *testing.T) {
			defer goleak.VerifyNone(tt)
			if test.beforeFunc != nil {
				test.beforeFunc(test.args)
			}
			if test.afterFunc != nil {
				defer test.afterFunc(test.args)
			}
			checkFunc := test.checkFunc
			if test.checkFunc == nil {
				checkFunc = defaultCheckFunc
			}
			fields := test.fieldsFunc(t)
			l := &Logger{
				InfofFunc: fields.InfofFunc,
			}

			l.Infof(test.args.format, test.args.vals...)
			if err := checkFunc(test.want); err != nil {
				tt.Errorf("error = %v", err)
			}
		})
	}
}

func TestLogger_Warn(t *testing.T) {
	type args struct {
		vals []interface{}
	}
	type fields struct {
		WarnFunc func(vals ...interface{})
	}
	type want struct{}
	type test struct {
		name       string
		args       args
		fieldsFunc func(*testing.T) fields
		want       want
		checkFunc  func(want) error
		beforeFunc func(args)
		afterFunc  func(args)
	}
	defaultCheckFunc := func(w want) error {
		return nil
	}
	tests := []test{
		func() test {
			wantVals := []interface{}{
				"Vald",
			}
			var cnt int
			return test{
				name: "Call WarnFunc",
				args: args{
					vals: wantVals,
				},
				fieldsFunc: func(t *testing.T) fields {
					t.Helper()
					return fields{
						WarnFunc: func(vals ...interface{}) {
							if !reflect.DeepEqual(vals, wantVals) {
								t.Errorf("got = %v, want = %v", vals, wantVals)
							}
							cnt++
						},
					}
				},
				checkFunc: func(want) error {
					if cnt != 1 {
						return errors.Errorf("got cnt = %d, want = %d", cnt, 1)
					}
					return nil
				},
			}
		}(),
	}

	for _, tc := range tests {
		test := tc
		t.Run(test.name, func(tt *testing.T) {
			defer goleak.VerifyNone(tt)
			if test.beforeFunc != nil {
				test.beforeFunc(test.args)
			}
			if test.afterFunc != nil {
				defer test.afterFunc(test.args)
			}
			checkFunc := test.checkFunc
			if test.checkFunc == nil {
				checkFunc = defaultCheckFunc
			}
			fields := test.fieldsFunc(tt)
			l := &Logger{
				WarnFunc: fields.WarnFunc,
			}

			l.Warn(test.args.vals...)
			if err := checkFunc(test.want); err != nil {
				tt.Errorf("error = %v", err)
			}
		})
	}
}

func TestLogger_Warnf(t *testing.T) {
	type args struct {
		format string
		vals   []interface{}
	}
	type fields struct {
		WarnfFunc func(format string, vals ...interface{})
	}
	type want struct{}
	type test struct {
		name       string
		args       args
		fieldsFunc func(*testing.T) fields
		want       want
		checkFunc  func(want) error
		beforeFunc func(args)
		afterFunc  func(args)
	}
	defaultCheckFunc := func(w want) error {
		return nil
	}
	tests := []test{
		func() test {
			wantVals := []interface{}{
				"Vald",
			}
			wantFormat := "json"
			var cnt int
			return test{
				name: "Call WarnfFunc",
				args: args{
					vals:   wantVals,
					format: wantFormat,
				},
				fieldsFunc: func(t *testing.T) fields {
					t.Helper()
					return fields{
						WarnfFunc: func(format string, vals ...interface{}) {
							if !reflect.DeepEqual(vals, wantVals) || !reflect.DeepEqual(format, wantFormat) {
								t.Errorf("got = %v, want = %v", vals, wantVals)
							}
							cnt++
						},
					}
				},
				checkFunc: func(want) error {
					if cnt != 1 {
						return errors.Errorf("got cnt = %d, want = %d", cnt, 1)
					}
					return nil
				},
			}
		}(),
	}

	for _, tc := range tests {
		test := tc
		t.Run(test.name, func(tt *testing.T) {
			defer goleak.VerifyNone(tt)
			if test.beforeFunc != nil {
				test.beforeFunc(test.args)
			}
			if test.afterFunc != nil {
				defer test.afterFunc(test.args)
			}
			checkFunc := test.checkFunc
			if test.checkFunc == nil {
				checkFunc = defaultCheckFunc
			}
			fields := test.fieldsFunc(tt)
			l := &Logger{
				WarnfFunc: fields.WarnfFunc,
			}

			l.Warnf(test.args.format, test.args.vals...)
			if err := checkFunc(test.want); err != nil {
				tt.Errorf("error = %v", err)
			}
		})
	}
}

func TestLogger_Error(t *testing.T) {
	type args struct {
		vals []interface{}
	}
	type fields struct {
		ErrorFunc func(vals ...interface{})
	}
	type want struct{}
	type test struct {
		name       string
		args       args
		fieldsFunc func(*testing.T) fields
		want       want
		checkFunc  func(want) error
		beforeFunc func(args)
		afterFunc  func(args)
	}
	defaultCheckFunc := func(w want) error {
		return nil
	}
	tests := []test{
		func() test {
			wantVals := []interface{}{
				"Vald",
			}
			var cnt int
			return test{
				name: "Call ErrorFunc",
				args: args{
					vals: wantVals,
				},
				fieldsFunc: func(t *testing.T) fields {
					t.Helper()
					return fields{
						ErrorFunc: func(vals ...interface{}) {
							if !reflect.DeepEqual(vals, wantVals) {
								t.Errorf("got = %v, want = %v", vals, wantVals)
							}
							cnt++
						},
					}
				},
				checkFunc: func(want) error {
					if cnt != 1 {
						return errors.Errorf("got cnt = %d, want = %d", cnt, 1)
					}
					return nil
				},
			}
		}(),
	}

	for _, tc := range tests {
		test := tc
		t.Run(test.name, func(tt *testing.T) {
			defer goleak.VerifyNone(tt)
			if test.beforeFunc != nil {
				test.beforeFunc(test.args)
			}
			if test.afterFunc != nil {
				defer test.afterFunc(test.args)
			}
			checkFunc := test.checkFunc
			if test.checkFunc == nil {
				checkFunc = defaultCheckFunc
			}
			fields := test.fieldsFunc(tt)
			l := &Logger{
				ErrorFunc: fields.ErrorFunc,
			}

			l.Error(test.args.vals...)
			if err := checkFunc(test.want); err != nil {
				tt.Errorf("error = %v", err)
			}
		})
	}
}

func TestLogger_Errorf(t *testing.T) {
	type args struct {
		format string
		vals   []interface{}
	}
	type fields struct {
		ErrorfFunc func(format string, vals ...interface{})
	}
	type want struct{}
	type test struct {
		name       string
		args       args
		fieldsFunc func(*testing.T) fields
		want       want
		checkFunc  func(want) error
		beforeFunc func(args)
		afterFunc  func(args)
	}
	defaultCheckFunc := func(w want) error {
		return nil
	}
	tests := []test{
		func() test {
			wantVals := []interface{}{
				"Vald",
			}
			wantFormat := "json"
			var cnt int
			return test{
				name: "Call ErrorfFunc",
				args: args{
					vals:   wantVals,
					format: wantFormat,
				},
				fieldsFunc: func(t *testing.T) fields {
					t.Helper()
					return fields{
						ErrorfFunc: func(format string, vals ...interface{}) {
							if !reflect.DeepEqual(vals, wantVals) || !reflect.DeepEqual(format, wantFormat) {
								t.Errorf("got = %v, want = %v", vals, wantVals)
							}
							cnt++
						},
					}
				},
				checkFunc: func(want) error {
					if cnt != 1 {
						return errors.Errorf("got cnt = %d, want = %d", cnt, 1)
					}
					return nil
				},
			}
		}(),
	}

	for _, tc := range tests {
		test := tc
		t.Run(test.name, func(tt *testing.T) {
			defer goleak.VerifyNone(tt)
			if test.beforeFunc != nil {
				test.beforeFunc(test.args)
			}
			if test.afterFunc != nil {
				defer test.afterFunc(test.args)
			}
			checkFunc := test.checkFunc
			if test.checkFunc == nil {
				checkFunc = defaultCheckFunc
			}
			fields := test.fieldsFunc(tt)
			l := &Logger{
				ErrorfFunc: fields.ErrorfFunc,
			}

			l.Errorf(test.args.format, test.args.vals...)
			if err := checkFunc(test.want); err != nil {
				tt.Errorf("error = %v", err)
			}
		})
	}
}

func TestLogger_Fatal(t *testing.T) {
	type args struct {
		vals []interface{}
	}
	type fields struct {
		FatalFunc func(vals ...interface{})
	}
	type want struct{}
	type test struct {
		name       string
		args       args
		fieldsFunc func(*testing.T) fields
		want       want
		checkFunc  func(want) error
		beforeFunc func(args)
		afterFunc  func(args)
	}
	defaultCheckFunc := func(w want) error {
		return nil
	}
	tests := []test{
		func() test {
			wantVals := []interface{}{
				"Vald",
			}
			var cnt int
			return test{
				name: "Call FatalFunc",
				args: args{
					vals: wantVals,
				},
				fieldsFunc: func(t *testing.T) fields {
					t.Helper()
					return fields{
						FatalFunc: func(vals ...interface{}) {
							if !reflect.DeepEqual(vals, wantVals) {
								t.Errorf("got = %v, want = %v", vals, wantVals)
							}
							cnt++
						},
					}
				},
				checkFunc: func(want) error {
					if cnt != 1 {
						return errors.Errorf("got cnt = %d, want = %d", cnt, 1)
					}
					return nil
				},
			}
		}(),
	}

	for _, tc := range tests {
		test := tc
		t.Run(test.name, func(tt *testing.T) {
			defer goleak.VerifyNone(tt)
			if test.beforeFunc != nil {
				test.beforeFunc(test.args)
			}
			if test.afterFunc != nil {
				defer test.afterFunc(test.args)
			}
			checkFunc := test.checkFunc
			if test.checkFunc == nil {
				checkFunc = defaultCheckFunc
			}
			fields := test.fieldsFunc(tt)
			l := &Logger{
				FatalFunc: fields.FatalFunc,
			}

			l.Fatal(test.args.vals...)
			if err := checkFunc(test.want); err != nil {
				tt.Errorf("error = %v", err)
			}
		})
	}
}

func TestLogger_Fatalf(t *testing.T) {
	type args struct {
		format string
		vals   []interface{}
	}
	type fields struct {
		FatalfFunc func(format string, vals ...interface{})
	}
	type want struct{}
	type test struct {
		name       string
		args       args
		fieldsFunc func(*testing.T) fields
		want       want
		checkFunc  func(want) error
		beforeFunc func(args)
		afterFunc  func(args)
	}
	defaultCheckFunc := func(w want) error {
		return nil
	}
	tests := []test{
		func() test {
			wantVals := []interface{}{
				"Vald",
			}
			wantFormat := "json"
			var cnt int
			return test{
				name: "Call FatalfFunc",
				args: args{
					vals:   wantVals,
					format: wantFormat,
				},
				fieldsFunc: func(t *testing.T) fields {
					t.Helper()
					return fields{
						FatalfFunc: func(format string, vals ...interface{}) {
							if !reflect.DeepEqual(vals, wantVals) || !reflect.DeepEqual(format, wantFormat) {
								t.Errorf("got = %v, want = %v", vals, wantVals)
							}
							cnt++
						},
					}
				},
				checkFunc: func(want) error {
					if cnt != 1 {
						return errors.Errorf("got cnt = %d, want = %d", cnt, 1)
					}
					return nil
				},
			}
		}(),
	}

	for _, tc := range tests {
		test := tc
		t.Run(test.name, func(tt *testing.T) {
			defer goleak.VerifyNone(tt)
			if test.beforeFunc != nil {
				test.beforeFunc(test.args)
			}
			if test.afterFunc != nil {
				defer test.afterFunc(test.args)
			}
			checkFunc := test.checkFunc
			if test.checkFunc == nil {
				checkFunc = defaultCheckFunc
			}
			fields := test.fieldsFunc(tt)
			l := &Logger{
				FatalfFunc: fields.FatalfFunc,
			}

			l.Fatalf(test.args.format, test.args.vals...)
			if err := checkFunc(test.want); err != nil {
				tt.Errorf("error = %v", err)
			}
		})
	}
}

// NOT IMPLEMENTED BELOW
//
// func TestLogger_Debugd(t *testing.T) {
// 	type args struct {
// 		msg     string
// 		details []interface{}
// 	}
// 	type fields struct {
// 		DebugFunc  func(vals ...interface{})
// 		DebugfFunc func(format string, vals ...interface{})
// 		InfoFunc   func(vals ...interface{})
// 		InfofFunc  func(format string, vals ...interface{})
// 		WarnFunc   func(vals ...interface{})
// 		WarnfFunc  func(format string, vals ...interface{})
// 		ErrorFunc  func(vals ...interface{})
// 		ErrorfFunc func(format string, vals ...interface{})
// 		FatalFunc  func(vals ...interface{})
// 		FatalfFunc func(format string, vals ...interface{})
// 	}
// 	type want struct {
// 	}
// 	type test struct {
// 		name       string
// 		args       args
// 		fields     fields
// 		want       want
// 		checkFunc  func(want) error
// 		beforeFunc func(*testing.T, args)
// 		afterFunc  func(*testing.T, args)
// 	}
// 	defaultCheckFunc := func(w want) error {
// 		return nil
// 	}
// 	tests := []test{
// 		// TODO test cases
// 		/*
// 		   {
// 		       name: "test_case_1",
// 		       args: args {
// 		           msg:"",
// 		           details:nil,
// 		       },
// 		       fields: fields {
// 		           DebugFunc:nil,
// 		           DebugfFunc:nil,
// 		           InfoFunc:nil,
// 		           InfofFunc:nil,
// 		           WarnFunc:nil,
// 		           WarnfFunc:nil,
// 		           ErrorFunc:nil,
// 		           ErrorfFunc:nil,
// 		           FatalFunc:nil,
// 		           FatalfFunc:nil,
// 		       },
// 		       want: want{},
// 		       checkFunc: defaultCheckFunc,
// 		       beforeFunc: func(t *testing.T, args args) {
// 		           t.Helper()
// 		       },
// 		       afterFunc: func(t *testing.T, args args) {
// 		           t.Helper()
// 		       },
// 		   },
// 		*/
//
// 		// TODO test cases
// 		/*
// 		   func() test {
// 		       return test {
// 		           name: "test_case_2",
// 		           args: args {
// 		           msg:"",
// 		           details:nil,
// 		           },
// 		           fields: fields {
// 		           DebugFunc:nil,
// 		           DebugfFunc:nil,
// 		           InfoFunc:nil,
// 		           InfofFunc:nil,
// 		           WarnFunc:nil,
// 		           WarnfFunc:nil,
// 		           ErrorFunc:nil,
// 		           ErrorfFunc:nil,
// 		           FatalFunc:nil,
// 		           FatalfFunc:nil,
// 		           },
// 		           want: want{},
// 		           checkFunc: defaultCheckFunc,
// 		           beforeFunc: func(t *testing.T, args args) {
// 		               t.Helper()
// 		           },
// 		           afterFunc: func(t *testing.T, args args) {
// 		               t.Helper()
// 		           },
// 		       }
// 		   }(),
// 		*/
// 	}
//
// 	for _, tc := range tests {
// 		test := tc
// 		t.Run(test.name, func(tt *testing.T) {
// 			tt.Parallel()
// 			defer goleak.VerifyNone(tt, goleak.IgnoreCurrent())
// 			if test.beforeFunc != nil {
// 				test.beforeFunc(tt, test.args)
// 			}
// 			if test.afterFunc != nil {
// 				defer test.afterFunc(tt, test.args)
// 			}
// 			checkFunc := test.checkFunc
// 			if test.checkFunc == nil {
// 				checkFunc = defaultCheckFunc
// 			}
// 			l := &Logger{
// 				DebugFunc:  test.fields.DebugFunc,
// 				DebugfFunc: test.fields.DebugfFunc,
// 				InfoFunc:   test.fields.InfoFunc,
// 				InfofFunc:  test.fields.InfofFunc,
// 				WarnFunc:   test.fields.WarnFunc,
// 				WarnfFunc:  test.fields.WarnfFunc,
// 				ErrorFunc:  test.fields.ErrorFunc,
// 				ErrorfFunc: test.fields.ErrorfFunc,
// 				FatalFunc:  test.fields.FatalFunc,
// 				FatalfFunc: test.fields.FatalfFunc,
// 			}
//
// 			l.Debugd(test.args.msg, test.args.details...)
// 			if err := checkFunc(test.want); err != nil {
// 				tt.Errorf("error = %v", err)
// 			}
// 		})
// 	}
// }
//
// func TestLogger_Infod(t *testing.T) {
// 	type args struct {
// 		msg     string
// 		details []interface{}
// 	}
// 	type fields struct {
// 		DebugFunc  func(vals ...interface{})
// 		DebugfFunc func(format string, vals ...interface{})
// 		InfoFunc   func(vals ...interface{})
// 		InfofFunc  func(format string, vals ...interface{})
// 		WarnFunc   func(vals ...interface{})
// 		WarnfFunc  func(format string, vals ...interface{})
// 		ErrorFunc  func(vals ...interface{})
// 		ErrorfFunc func(format string, vals ...interface{})
// 		FatalFunc  func(vals ...interface{})
// 		FatalfFunc func(format string, vals ...interface{})
// 	}
// 	type want struct {
// 	}
// 	type test struct {
// 		name       string
// 		args       args
// 		fields     fields
// 		want       want
// 		checkFunc  func(want) error
// 		beforeFunc func(*testing.T, args)
// 		afterFunc  func(*testing.T, args)
// 	}
// 	defaultCheckFunc := func(w want) error {
// 		return nil
// 	}
// 	tests := []test{
// 		// TODO test cases
// 		/*
// 		   {
// 		       name: "test_case_1",
// 		       args: args {
// 		           msg:"",
// 		           details:nil,
// 		       },
// 		       fields: fields {
// 		           DebugFunc:nil,
// 		           DebugfFunc:nil,
// 		           InfoFunc:nil,
// 		           InfofFunc:nil,
// 		           WarnFunc:nil,
// 		           WarnfFunc:nil,
// 		           ErrorFunc:nil,
// 		           ErrorfFunc:nil,
// 		           FatalFunc:nil,
// 		           FatalfFunc:nil,
// 		       },
// 		       want: want{},
// 		       checkFunc: defaultCheckFunc,
// 		       beforeFunc: func(t *testing.T, args args) {
// 		           t.Helper()
// 		       },
// 		       afterFunc: func(t *testing.T, args args) {
// 		           t.Helper()
// 		       },
// 		   },
// 		*/
//
// 		// TODO test cases
// 		/*
// 		   func() test {
// 		       return test {
// 		           name: "test_case_2",
// 		           args: args {
// 		           msg:"",
// 		           details:nil,
// 		           },
// 		           fields: fields {
// 		           DebugFunc:nil,
// 		           DebugfFunc:nil,
// 		           InfoFunc:nil,
// 		           InfofFunc:nil,
// 		           WarnFunc:nil,
// 		           WarnfFunc:nil,
// 		           ErrorFunc:nil,
// 		           ErrorfFunc:nil,
// 		           FatalFunc:nil,
// 		           FatalfFunc:nil,
// 		           },
// 		           want: want{},
// 		           checkFunc: defaultCheckFunc,
// 		           beforeFunc: func(t *testing.T, args args) {
// 		               t.Helper()
// 		           },
// 		           afterFunc: func(t *testing.T, args args) {
// 		               t.Helper()
// 		           },
// 		       }
// 		   }(),
// 		*/
// 	}
//
// 	for _, tc := range tests {
// 		test := tc
// 		t.Run(test.name, func(tt *testing.T) {
// 			tt.Parallel()
// 			defer goleak.VerifyNone(tt, goleak.IgnoreCurrent())
// 			if test.beforeFunc != nil {
// 				test.beforeFunc(tt, test.args)
// 			}
// 			if test.afterFunc != nil {
// 				defer test.afterFunc(tt, test.args)
// 			}
// 			checkFunc := test.checkFunc
// 			if test.checkFunc == nil {
// 				checkFunc = defaultCheckFunc
// 			}
// 			l := &Logger{
// 				DebugFunc:  test.fields.DebugFunc,
// 				DebugfFunc: test.fields.DebugfFunc,
// 				InfoFunc:   test.fields.InfoFunc,
// 				InfofFunc:  test.fields.InfofFunc,
// 				WarnFunc:   test.fields.WarnFunc,
// 				WarnfFunc:  test.fields.WarnfFunc,
// 				ErrorFunc:  test.fields.ErrorFunc,
// 				ErrorfFunc: test.fields.ErrorfFunc,
// 				FatalFunc:  test.fields.FatalFunc,
// 				FatalfFunc: test.fields.FatalfFunc,
// 			}
//
// 			l.Infod(test.args.msg, test.args.details...)
// 			if err := checkFunc(test.want); err != nil {
// 				tt.Errorf("error = %v", err)
// 			}
// 		})
// 	}
// }
//
// func TestLogger_Warnd(t *testing.T) {
// 	type args struct {
// 		msg     string
// 		details []interface{}
// 	}
// 	type fields struct {
// 		DebugFunc  func(vals ...interface{})
// 		DebugfFunc func(format string, vals ...interface{})
// 		InfoFunc   func(vals ...interface{})
// 		InfofFunc  func(format string, vals ...interface{})
// 		WarnFunc   func(vals ...interface{})
// 		WarnfFunc  func(format string, vals ...interface{})
// 		ErrorFunc  func(vals ...interface{})
// 		ErrorfFunc func(format string, vals ...interface{})
// 		FatalFunc  func(vals ...interface{})
// 		FatalfFunc func(format string, vals ...interface{})
// 	}
// 	type want struct {
// 	}
// 	type test struct {
// 		name       string
// 		args       args
// 		fields     fields
// 		want       want
// 		checkFunc  func(want) error
// 		beforeFunc func(*testing.T, args)
// 		afterFunc  func(*testing.T, args)
// 	}
// 	defaultCheckFunc := func(w want) error {
// 		return nil
// 	}
// 	tests := []test{
// 		// TODO test cases
// 		/*
// 		   {
// 		       name: "test_case_1",
// 		       args: args {
// 		           msg:"",
// 		           details:nil,
// 		       },
// 		       fields: fields {
// 		           DebugFunc:nil,
// 		           DebugfFunc:nil,
// 		           InfoFunc:nil,
// 		           InfofFunc:nil,
// 		           WarnFunc:nil,
// 		           WarnfFunc:nil,
// 		           ErrorFunc:nil,
// 		           ErrorfFunc:nil,
// 		           FatalFunc:nil,
// 		           FatalfFunc:nil,
// 		       },
// 		       want: want{},
// 		       checkFunc: defaultCheckFunc,
// 		       beforeFunc: func(t *testing.T, args args) {
// 		           t.Helper()
// 		       },
// 		       afterFunc: func(t *testing.T, args args) {
// 		           t.Helper()
// 		       },
// 		   },
// 		*/
//
// 		// TODO test cases
// 		/*
// 		   func() test {
// 		       return test {
// 		           name: "test_case_2",
// 		           args: args {
// 		           msg:"",
// 		           details:nil,
// 		           },
// 		           fields: fields {
// 		           DebugFunc:nil,
// 		           DebugfFunc:nil,
// 		           InfoFunc:nil,
// 		           InfofFunc:nil,
// 		           WarnFunc:nil,
// 		           WarnfFunc:nil,
// 		           ErrorFunc:nil,
// 		           ErrorfFunc:nil,
// 		           FatalFunc:nil,
// 		           FatalfFunc:nil,
// 		           },
// 		           want: want{},
// 		           checkFunc: defaultCheckFunc,
// 		           beforeFunc: func(t *testing.T, args args) {
// 		               t.Helper()
// 		           },
// 		           afterFunc: func(t *testing.T, args args) {
// 		               t.Helper()
// 		           },
// 		       }
// 		   }(),
// 		*/
// 	}
//
// 	for _, tc := range tests {
// 		test := tc
// 		t.Run(test.name, func(tt *testing.T) {
// 			tt.Parallel()
// 			defer goleak.VerifyNone(tt, goleak.IgnoreCurrent())
// 			if test.beforeFunc != nil {
// 				test.beforeFunc(tt, test.args)
// 			}
// 			if test.afterFunc != nil {
// 				defer test.afterFunc(tt, test.args)
// 			}
// 			checkFunc := test.checkFunc
// 			if test.checkFunc == nil {
// 				checkFunc = defaultCheckFunc
// 			}
// 			l := &Logger{
// 				DebugFunc:  test.fields.DebugFunc,
// 				DebugfFunc: test.fields.DebugfFunc,
// 				InfoFunc:   test.fields.InfoFunc,
// 				InfofFunc:  test.fields.InfofFunc,
// 				WarnFunc:   test.fields.WarnFunc,
// 				WarnfFunc:  test.fields.WarnfFunc,
// 				ErrorFunc:  test.fields.ErrorFunc,
// 				ErrorfFunc: test.fields.ErrorfFunc,
// 				FatalFunc:  test.fields.FatalFunc,
// 				FatalfFunc: test.fields.FatalfFunc,
// 			}
//
// 			l.Warnd(test.args.msg, test.args.details...)
// 			if err := checkFunc(test.want); err != nil {
// 				tt.Errorf("error = %v", err)
// 			}
// 		})
// 	}
// }
//
// func TestLogger_Errord(t *testing.T) {
// 	type args struct {
// 		msg     string
// 		details []interface{}
// 	}
// 	type fields struct {
// 		DebugFunc  func(vals ...interface{})
// 		DebugfFunc func(format string, vals ...interface{})
// 		InfoFunc   func(vals ...interface{})
// 		InfofFunc  func(format string, vals ...interface{})
// 		WarnFunc   func(vals ...interface{})
// 		WarnfFunc  func(format string, vals ...interface{})
// 		ErrorFunc  func(vals ...interface{})
// 		ErrorfFunc func(format string, vals ...interface{})
// 		FatalFunc  func(vals ...interface{})
// 		FatalfFunc func(format string, vals ...interface{})
// 	}
// 	type want struct {
// 	}
// 	type test struct {
// 		name       string
// 		args       args
// 		fields     fields
// 		want       want
// 		checkFunc  func(want) error
// 		beforeFunc func(*testing.T, args)
// 		afterFunc  func(*testing.T, args)
// 	}
// 	defaultCheckFunc := func(w want) error {
// 		return nil
// 	}
// 	tests := []test{
// 		// TODO test cases
// 		/*
// 		   {
// 		       name: "test_case_1",
// 		       args: args {
// 		           msg:"",
// 		           details:nil,
// 		       },
// 		       fields: fields {
// 		           DebugFunc:nil,
// 		           DebugfFunc:nil,
// 		           InfoFunc:nil,
// 		           InfofFunc:nil,
// 		           WarnFunc:nil,
// 		           WarnfFunc:nil,
// 		           ErrorFunc:nil,
// 		           ErrorfFunc:nil,
// 		           FatalFunc:nil,
// 		           FatalfFunc:nil,
// 		       },
// 		       want: want{},
// 		       checkFunc: defaultCheckFunc,
// 		       beforeFunc: func(t *testing.T, args args) {
// 		           t.Helper()
// 		       },
// 		       afterFunc: func(t *testing.T, args args) {
// 		           t.Helper()
// 		       },
// 		   },
// 		*/
//
// 		// TODO test cases
// 		/*
// 		   func() test {
// 		       return test {
// 		           name: "test_case_2",
// 		           args: args {
// 		           msg:"",
// 		           details:nil,
// 		           },
// 		           fields: fields {
// 		           DebugFunc:nil,
// 		           DebugfFunc:nil,
// 		           InfoFunc:nil,
// 		           InfofFunc:nil,
// 		           WarnFunc:nil,
// 		           WarnfFunc:nil,
// 		           ErrorFunc:nil,
// 		           ErrorfFunc:nil,
// 		           FatalFunc:nil,
// 		           FatalfFunc:nil,
// 		           },
// 		           want: want{},
// 		           checkFunc: defaultCheckFunc,
// 		           beforeFunc: func(t *testing.T, args args) {
// 		               t.Helper()
// 		           },
// 		           afterFunc: func(t *testing.T, args args) {
// 		               t.Helper()
// 		           },
// 		       }
// 		   }(),
// 		*/
// 	}
//
// 	for _, tc := range tests {
// 		test := tc
// 		t.Run(test.name, func(tt *testing.T) {
// 			tt.Parallel()
// 			defer goleak.VerifyNone(tt, goleak.IgnoreCurrent())
// 			if test.beforeFunc != nil {
// 				test.beforeFunc(tt, test.args)
// 			}
// 			if test.afterFunc != nil {
// 				defer test.afterFunc(tt, test.args)
// 			}
// 			checkFunc := test.checkFunc
// 			if test.checkFunc == nil {
// 				checkFunc = defaultCheckFunc
// 			}
// 			l := &Logger{
// 				DebugFunc:  test.fields.DebugFunc,
// 				DebugfFunc: test.fields.DebugfFunc,
// 				InfoFunc:   test.fields.InfoFunc,
// 				InfofFunc:  test.fields.InfofFunc,
// 				WarnFunc:   test.fields.WarnFunc,
// 				WarnfFunc:  test.fields.WarnfFunc,
// 				ErrorFunc:  test.fields.ErrorFunc,
// 				ErrorfFunc: test.fields.ErrorfFunc,
// 				FatalFunc:  test.fields.FatalFunc,
// 				FatalfFunc: test.fields.FatalfFunc,
// 			}
//
// 			l.Errord(test.args.msg, test.args.details...)
// 			if err := checkFunc(test.want); err != nil {
// 				tt.Errorf("error = %v", err)
// 			}
// 		})
// 	}
// }
//
// func TestLogger_Fatald(t *testing.T) {
// 	type args struct {
// 		msg     string
// 		details []interface{}
// 	}
// 	type fields struct {
// 		DebugFunc  func(vals ...interface{})
// 		DebugfFunc func(format string, vals ...interface{})
// 		InfoFunc   func(vals ...interface{})
// 		InfofFunc  func(format string, vals ...interface{})
// 		WarnFunc   func(vals ...interface{})
// 		WarnfFunc  func(format string, vals ...interface{})
// 		ErrorFunc  func(vals ...interface{})
// 		ErrorfFunc func(format string, vals ...interface{})
// 		FatalFunc  func(vals ...interface{})
// 		FatalfFunc func(format string, vals ...interface{})
// 	}
// 	type want struct {
// 	}
// 	type test struct {
// 		name       string
// 		args       args
// 		fields     fields
// 		want       want
// 		checkFunc  func(want) error
// 		beforeFunc func(*testing.T, args)
// 		afterFunc  func(*testing.T, args)
// 	}
// 	defaultCheckFunc := func(w want) error {
// 		return nil
// 	}
// 	tests := []test{
// 		// TODO test cases
// 		/*
// 		   {
// 		       name: "test_case_1",
// 		       args: args {
// 		           msg:"",
// 		           details:nil,
// 		       },
// 		       fields: fields {
// 		           DebugFunc:nil,
// 		           DebugfFunc:nil,
// 		           InfoFunc:nil,
// 		           InfofFunc:nil,
// 		           WarnFunc:nil,
// 		           WarnfFunc:nil,
// 		           ErrorFunc:nil,
// 		           ErrorfFunc:nil,
// 		           FatalFunc:nil,
// 		           FatalfFunc:nil,
// 		       },
// 		       want: want{},
// 		       checkFunc: defaultCheckFunc,
// 		       beforeFunc: func(t *testing.T, args args) {
// 		           t.Helper()
// 		       },
// 		       afterFunc: func(t *testing.T, args args) {
// 		           t.Helper()
// 		       },
// 		   },
// 		*/
//
// 		// TODO test cases
// 		/*
// 		   func() test {
// 		       return test {
// 		           name: "test_case_2",
// 		           args: args {
// 		           msg:"",
// 		           details:nil,
// 		           },
// 		           fields: fields {
// 		           DebugFunc:nil,
// 		           DebugfFunc:nil,
// 		           InfoFunc:nil,
// 		           InfofFunc:nil,
// 		           WarnFunc:nil,
// 		           WarnfFunc:nil,
// 		           ErrorFunc:nil,
// 		           ErrorfFunc:nil,
// 		           FatalFunc:nil,
// 		           FatalfFunc:nil,
// 		           },
// 		           want: want{},
// 		           checkFunc: defaultCheckFunc,
// 		           beforeFunc: func(t *testing.T, args args) {
// 		               t.Helper()
// 		           },
// 		           afterFunc: func(t *testing.T, args args) {
// 		               t.Helper()
// 		           },
// 		       }
// 		   }(),
// 		*/
// 	}
//
// 	for _, tc := range tests {
// 		test := tc
// 		t.Run(test.name, func(tt *testing.T) {
// 			tt.Parallel()
// 			defer goleak.VerifyNone(tt, goleak.IgnoreCurrent())
// 			if test.beforeFunc != nil {
// 				test.beforeFunc(tt, test.args)
// 			}
// 			if test.afterFunc != nil {
// 				defer test.afterFunc(tt, test.args)
// 			}
// 			checkFunc := test.checkFunc
// 			if test.checkFunc == nil {
// 				checkFunc = defaultCheckFunc
// 			}
// 			l := &Logger{
// 				DebugFunc:  test.fields.DebugFunc,
// 				DebugfFunc: test.fields.DebugfFunc,
// 				InfoFunc:   test.fields.InfoFunc,
// 				InfofFunc:  test.fields.InfofFunc,
// 				WarnFunc:   test.fields.WarnFunc,
// 				WarnfFunc:  test.fields.WarnfFunc,
// 				ErrorFunc:  test.fields.ErrorFunc,
// 				ErrorfFunc: test.fields.ErrorfFunc,
// 				FatalFunc:  test.fields.FatalFunc,
// 				FatalfFunc: test.fields.FatalfFunc,
// 			}
//
// 			l.Fatald(test.args.msg, test.args.details...)
// 			if err := checkFunc(test.want); err != nil {
// 				tt.Errorf("error = %v", err)
// 			}
// 		})
// 	}
// }
//
// func TestLogger_Close(t *testing.T) {
// 	type fields struct {
// 		DebugFunc  func(vals ...interface{})
// 		DebugfFunc func(format string, vals ...interface{})
// 		InfoFunc   func(vals ...interface{})
// 		InfofFunc  func(format string, vals ...interface{})
// 		WarnFunc   func(vals ...interface{})
// 		WarnfFunc  func(format string, vals ...interface{})
// 		ErrorFunc  func(vals ...interface{})
// 		ErrorfFunc func(format string, vals ...interface{})
// 		FatalFunc  func(vals ...interface{})
// 		FatalfFunc func(format string, vals ...interface{})
// 	}
// 	type want struct {
// 		err error
// 	}
// 	type test struct {
// 		name       string
// 		fields     fields
// 		want       want
// 		checkFunc  func(want, error) error
// 		beforeFunc func(*testing.T)
// 		afterFunc  func(*testing.T)
// 	}
// 	defaultCheckFunc := func(w want, err error) error {
// 		if !errors.Is(err, w.err) {
// 			return errors.Errorf("got_error: \"%#v\",\n\t\t\t\twant: \"%#v\"", err, w.err)
// 		}
// 		return nil
// 	}
// 	tests := []test{
// 		// TODO test cases
// 		/*
// 		   {
// 		       name: "test_case_1",
// 		       fields: fields {
// 		           DebugFunc:nil,
// 		           DebugfFunc:nil,
// 		           InfoFunc:nil,
// 		           InfofFunc:nil,
// 		           WarnFunc:nil,
// 		           WarnfFunc:nil,
// 		           ErrorFunc:nil,
// 		           ErrorfFunc:nil,
// 		           FatalFunc:nil,
// 		           FatalfFunc:nil,
// 		       },
// 		       want: want{},
// 		       checkFunc: defaultCheckFunc,
// 		       beforeFunc: func(t *testing.T,) {
// 		           t.Helper()
// 		       },
// 		       afterFunc: func(t *testing.T,) {
// 		           t.Helper()
// 		       },
// 		   },
// 		*/
//
// 		// TODO test cases
// 		/*
// 		   func() test {
// 		       return test {
// 		           name: "test_case_2",
// 		           fields: fields {
// 		           DebugFunc:nil,
// 		           DebugfFunc:nil,
// 		           InfoFunc:nil,
// 		           InfofFunc:nil,
// 		           WarnFunc:nil,
// 		           WarnfFunc:nil,
// 		           ErrorFunc:nil,
// 		           ErrorfFunc:nil,
// 		           FatalFunc:nil,
// 		           FatalfFunc:nil,
// 		           },
// 		           want: want{},
// 		           checkFunc: defaultCheckFunc,
// 		           beforeFunc: func(t *testing.T,) {
// 		               t.Helper()
// 		           },
// 		           afterFunc: func(t *testing.T,) {
// 		               t.Helper()
// 		           },
// 		       }
// 		   }(),
// 		*/
// 	}
//
// 	for _, tc := range tests {
// 		test := tc
// 		t.Run(test.name, func(tt *testing.T) {
// 			tt.Parallel()
// 			defer goleak.VerifyNone(tt, goleak.IgnoreCurrent())
// 			if test.beforeFunc != nil {
// 				test.beforeFunc(tt)
// 			}
// 			if test.afterFunc != nil {
// 				defer test.afterFunc(tt)
// 			}
// 			checkFunc := test.checkFunc
// 			if test.checkFunc == nil {
// 				checkFunc = defaultCheckFunc
// 			}
// 			l := &Logger{
// 				DebugFunc:  test.fields.DebugFunc,
// 				DebugfFunc: test.fields.DebugfFunc,
// 				InfoFunc:   test.fields.InfoFunc,
// 				InfofFunc:  test.fields.InfofFunc,
// 				WarnFunc:   test.fields.WarnFunc,
// 				WarnfFunc:  test.fields.WarnfFunc,
// 				ErrorFunc:  test.fields.ErrorFunc,
// 				ErrorfFunc: test.fields.ErrorfFunc,
// 				FatalFunc:  test.fields.FatalFunc,
// 				FatalfFunc: test.fields.FatalfFunc,
// 			}
//
// 			err := l.Close()
// 			if err := checkFunc(test.want, err); err != nil {
// 				tt.Errorf("error = %v", err)
// 			}
//
// 		})
// 	}
// }