From 3d4af7513cf4b8c6958d918685ad5f98d12569b7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=88=98=E6=B4=AA=E5=AE=9D?= Date: Fri, 19 Oct 2018 14:42:31 +0800 Subject: [PATCH] =?UTF-8?q?=E6=97=A5=E5=BF=97=E7=B1=BB?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .gitignore | 3 + connector.go | 70 +++-- connector_test.go | 120 ++++++++ example/main.go | 30 ++ log.go | 83 +++++- log_test.go | 691 +++++++++++++++++++++++++++++++++++++++++++++- 6 files changed, 960 insertions(+), 37 deletions(-) create mode 100644 connector_test.go create mode 100644 example/main.go diff --git a/.gitignore b/.gitignore index 4c36e38..f9daefe 100644 --- a/.gitignore +++ b/.gitignore @@ -1,2 +1,5 @@ .idea/ vendor/ +bingo.log +example/bingo.log +size_coverage.out \ No newline at end of file diff --git a/connector.go b/connector.go index 77b3b11..ced5b02 100644 --- a/connector.go +++ b/connector.go @@ -13,10 +13,10 @@ type Connector interface { Error(message string) Warning(message string) Debug(message string) - Info(message string) // 打印 - Output(message string) // 将信息输出到文件中 - GetMessage(message string) string // 将输入的信息添加抬头（例如添加打印时间等） - GetFile(configs []string) *os.File // 当前日志要输出到的文件位置,传入一个数组代表配置 + Info(message string) // 打印 + Output(message string) // 将信息输出到文件中 + GetMessage(message string) string // 将输入的信息添加抬头（例如添加打印时间等） + GetFile(config map[string]string) *os.File // 当前日志要输出到的文件位置,传入一个map 代表配置 } // 分为5种日志级别 @@ -29,43 +29,77 @@ type Connector interface { // 基类连接器，实现简单的输出方法 type BaseConnector struct{} -func (b *BaseConnector) Fatal(message string) { +func (b BaseConnector) Fatal(message string) { // 红色输出 message = "[FATAL] " + b.GetMessage(message) - fmt.Println(clcolor.Red(message)) + fmt.Print(clcolor.Red(message)) + b.Output(message) } -func (b *BaseConnector) Error(message string) { +func (b BaseConnector) Error(message string) { // 紫色输出 message = "[ERROR] " + b.GetMessage(message) - fmt.Println(clcolor.Magenta(message)) + fmt.Print(clcolor.Magenta(message)) + b.Output(message) } -func (b *BaseConnector) Warning(message string) { +func (b BaseConnector) Warning(message string) { // 黄色输出 message = "[WARNING] " + b.GetMessage(message) - fmt.Println(clcolor.Yellow(message)) + fmt.Print(clcolor.Yellow(message)) + b.Output(message) } -func (b *BaseConnector) Debug(message string) { +func (b BaseConnector) Debug(message string) { // 蓝色输出 message = "[DEBUG] " + b.GetMessage(message) - fmt.Println(clcolor.Blue(message)) + fmt.Print(clcolor.Blue(message)) + b.Output(message) } -func (b *BaseConnector) Info(message string) { +func (b BaseConnector) Info(message string) { // 绿色输出在控制台 message = "[INFO] " + b.GetMessage(message) - fmt.Println(clcolor.Green(message)) + fmt.Print(clcolor.Green(message)) // 输出在文件中 + b.Output(message) } -func (b *BaseConnector) GetMessage(message string) string { +func (b BaseConnector) GetMessage(message string) string { // 将传入的信息扩展一下 // 默认添加当前时间 - return "[" + time.Now().Format("2006-01-02 15:04:05") + "] " + message + return "[" + time.Now().Format("2006-01-02 15:04:05") + "] " + message + "\n" } -func (b *BaseConnector) Output(message string) { +func (b BaseConnector) Output(message string) { // 获取到要输出的文件路径 + file := b.GetFile(make(map[string]string)) + defer file.Close() + n, _ := file.Seek(0, os.SEEK_END) + // 写入数据 + file.WriteAt([]byte(message), n) } -func (b *BaseConnector) GetFile() *os.File { +// 返回一个文件句柄，用来写入数据 +func (b BaseConnector) GetFile(config map[string]string) *os.File { + // 默认情况下，输出到当前路径下的bingo.log文件中 + dir, err := os.Getwd() + if err != nil { + panic(err) + } + path := dir + "/bingo.log" // 真实要保存的文件位置 + // 判断文件是否存在 + if _, err := os.Stat(path); err != nil { + // 文件不存在,创建 + f, err := os.Create(path) + //defer f.Close() // 关闭操作要放在调用位置 + if err != nil { + panic(err) + } + return f + } + // 打开该文件，追加模式 + f, err := os.OpenFile(path, os.O_WRONLY, os.ModeAppend) + if err != nil { + panic(err) + } + + return f } diff --git a/connector_test.go b/connector_test.go new file mode 100644 index 0000000..a6dfcd8 --- /dev/null +++ b/connector_test.go @@ -0,0 +1,120 @@ +package bingo_log + +import ( + "testing" +) + +func TestBaseConnector_Fatal(t *testing.T) { + type args struct { + message string + } + tests := []struct { + name string + b BaseConnector + args args + }{ + { + name: "case", + b: BaseConnector{}, + args: struct{ message string }{message: "fatal testing"}, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + b := BaseConnector{} + b.Fatal(tt.args.message) + }) + } +} + +func TestBaseConnector_Error(t *testing.T) { + type args struct { + message string + } + tests := []struct { + name string + b BaseConnector + args args + }{ + { + name: "case", + b: BaseConnector{}, + args: struct{ message string }{message: "Error testing"}, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + b := BaseConnector{} + b.Error(tt.args.message) + }) + } +} + +func TestBaseConnector_Warning(t *testing.T) { + type args struct { + message string + } + tests := []struct { + name string + b BaseConnector + args args + }{ + { + name: "case", + b: BaseConnector{}, + args: struct{ message string }{message: "Warning testing"}, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + b := BaseConnector{} + b.Warning(tt.args.message) + }) + } +} + +func TestBaseConnector_Debug(t *testing.T) { + type args struct { + message string + } + tests := []struct { + name string + b BaseConnector + args args + }{ + { + name: "case", + b: BaseConnector{}, + args: struct{ message string }{message: "Debug testing"}, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + b := BaseConnector{} + b.Debug(tt.args.message) + }) + } +} + +func TestBaseConnector_Info(t *testing.T) { + type args struct { + message string + } + tests := []struct { + name string + b BaseConnector + args args + }{ + { + name: "case", + b: BaseConnector{}, + args: struct{ message string }{message: "Info testing"}, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + b := BaseConnector{} + b.Info(tt.args.message) + }) + } +} diff --git a/example/main.go b/example/main.go new file mode 100644 index 0000000..9dd5666 --- /dev/null +++ b/example/main.go @@ -0,0 +1,30 @@ +package main + +import ( + "github.com/silsuer/bingo-log" + "strconv" + "fmt" +) + +func main() { + //fmt.Println(os.Getwd()) + //c:= bingo_log.NewLog(bingo_log.LogSyncMode) + //b := new(bingo_log.BaseConnector) + //c.LoadConnector(b) // 加载连接器 + //c.Warning("ddd") + //c := bingo_log.NewLog(bingo_log.LogPoolMode) + c:= bingo_log.NewLog(bingo_log.LogSyncMode) + c.SetPoolExpiredTime(100) + c.SetPoolWorkerNum(100) + + b := new(bingo_log.BaseConnector) + c.LoadConnector(b) + + //s := sync.WaitGroup{} + + for i := 0; i < 1000; i++ { + //s.Add() + c.Debug("这是第" + strconv.Itoa(i) + "次输入") + } + fmt.Println("Done!") +} diff --git a/log.go b/log.go index 0a0f15f..e9c8453 100644 --- a/log.go +++ b/log.go @@ -1,7 +1,6 @@ package bingo_log import ( - "log" "github.com/ivpusic/grpool" ) @@ -20,25 +19,40 @@ const ( var Logger Log // 全局log type Log struct { - log.Logger + //conn *Connector // 连接器，其中定义了绝大部分功能 + Connector initialized bool // 该日志对象是否初始化 mode int // 日志记录模式 0 同步记录 2 协程池记录 pool *grpool.Pool // 协程池 - poolExpiredTime int // 协程池模式下，每个空闲协程的存活时间 + poolExpiredTime int // 协程池模式下，每个空闲协程的存活时间(秒) poolWorkerNum int // 协程池模式下，允许的最高协程数 } // 初始化结构体,如果已经初始化过会再次初始化 func (l *Log) initialize() { + // 已初始化直接返回 + if l.initialized == true { + return + } if l.mode == LogPoolMode { // 创建协程池 - l.pool = grpool.NewPool(l.getPoolWorkerNum(), l.getPoolWorkerNum()) + l.pool = grpool.NewPool(l.GetPoolWorkerNum(), l.GetPoolExpiredTime()) } l.initialized = true } +// 设置协程数量 +func (l *Log) SetPoolWorkerNum(num int) { + l.poolWorkerNum = num +} + +// 设置协程存活时间 +func (l *Log) SetPoolExpiredTime(t int) { + l.poolExpiredTime = t +} + // 获取协程池中允许的协程数量 -func (l *Log) getPoolWorkerNum() int { +func (l *Log) GetPoolWorkerNum() int { if l.poolWorkerNum == 0 { l.poolWorkerNum = 100 } @@ -46,26 +60,77 @@ func (l *Log) getPoolWorkerNum() int { } // 获取协程池中空闲协程的存活时间(秒) -func (l *Log) getPoolExpiredTime() int { +func (l *Log) GetPoolExpiredTime() int { if l.poolExpiredTime == 0 { l.poolExpiredTime = 50 } return l.poolExpiredTime } +func NewLog(mode int) *Log { + l := &Log{} + l.SetMode(mode) + l.initialize() + return l +} + // 判断该结构体是否被初始化 -func (l *Log) isInitialized() bool { +func (l *Log) IsInitialized() bool { return l.initialized } // 设置模式 func (l *Log) SetMode(m int) { l.mode = m - l.initialize() + //l.initialize() } -func (l *Log) set() { +// 加载连接器 +func (l *Log) LoadConnector(conn Connector) { + l.Connector = conn +} +// 重写5种日志级别的打印函数 +func (l *Log) Fatal(message string) { + // 根据模式 + l.exec(l.Connector.Fatal, message) } +func (l *Log) Error(message string) { + l.exec(l.Connector.Error, message) +} +func (l *Log) Warning(message string) { + l.exec(l.Connector.Warning, message) +} + +func (l *Log) Debug(message string) { + l.exec(l.Connector.Debug, message) +} + +func (l *Log) Info(message string) { + l.exec(l.Connector.Info, message) +} + +func (l *Log) exec(f func(message string), message string) { + // 同步模式 + if l.mode == LogSyncMode { + f(message) + } else if l.mode == LogPoolMode { // 协程池异步模式 + l.initialize() // 先初始化 + l.AddWaitCount(1) + l.pool.JobQueue <- func() { + f(message) + defer l.pool.JobDone() + } + } +} + +// 等待所有job执行完毕 +func (l *Log) WaitAll() { + l.pool.WaitAll() +} + +func (l *Log) AddWaitCount(count int) { + l.pool.WaitCount(count) +} diff --git a/log_test.go b/log_test.go index 19b1de4..8c2814a 100644 --- a/log_test.go +++ b/log_test.go @@ -1,17 +1,688 @@ package bingo_log -import "testing" +import ( + "testing" + "github.com/ivpusic/grpool" + "reflect" + "fmt" +) -// 要完成的功能： -// 传入字符串， 根据不同的方法， 将打印在控制台中 -// 并放在 +func TestLog_initialize(t *testing.T) { + type fields struct { + Connector Connector + initialized bool + mode int + pool *grpool.Pool + poolExpiredTime int + poolWorkerNum int + } + tests := []struct { + name string + fields fields + }{ + { + name: "case1", + fields: struct { + Connector Connector + initialized bool + mode int + pool *grpool.Pool + poolExpiredTime int + poolWorkerNum int + }{Connector: BaseConnector{}, initialized: false, mode: LogSyncMode, pool: grpool.NewPool(100, 50), poolExpiredTime: 100, poolWorkerNum: 50}, + }, + { + name: "case2", + fields: struct { + Connector Connector + initialized bool + mode int + pool *grpool.Pool + poolExpiredTime int + poolWorkerNum int + }{Connector: BaseConnector{}, initialized: true, mode: LogSyncMode, pool: grpool.NewPool(100, 50), poolExpiredTime: 100, poolWorkerNum: 50}, + }, + { + name: "case3", + fields: struct { + Connector Connector + initialized bool + mode int + pool *grpool.Pool + poolExpiredTime int + poolWorkerNum int + }{Connector: BaseConnector{}, initialized: false, mode: LogPoolMode, pool: grpool.NewPool(100, 50), poolExpiredTime: 100, poolWorkerNum: 50}, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + l := &Log{ + Connector: tt.fields.Connector, + initialized: tt.fields.initialized, + mode: tt.fields.mode, + pool: tt.fields.pool, + poolExpiredTime: tt.fields.poolExpiredTime, + poolWorkerNum: tt.fields.poolWorkerNum, + } + l.initialize() + }) + } +} + +func TestLog_SetPoolWorkerNum(t *testing.T) { + type fields struct { + Connector Connector + initialized bool + mode int + pool *grpool.Pool + poolExpiredTime int + poolWorkerNum int + } + type args struct { + num int + } + tests := []struct { + name string + fields fields + args args + }{ + { + name: "case", + fields: struct { + Connector Connector + initialized bool + mode int + pool *grpool.Pool + poolExpiredTime int + poolWorkerNum int + }{Connector: BaseConnector{}, initialized: false, mode: LogPoolMode, pool: grpool.NewPool(100, 50), poolExpiredTime: 100, poolWorkerNum: 50}, + args: struct{ num int }{num: 100}, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + l := &Log{ + Connector: tt.fields.Connector, + initialized: tt.fields.initialized, + mode: tt.fields.mode, + pool: tt.fields.pool, + poolExpiredTime: tt.fields.poolExpiredTime, + poolWorkerNum: tt.fields.poolWorkerNum, + } + l.SetPoolWorkerNum(tt.args.num) + }) + } +} +func TestLog_SetPoolExpiredTime(t *testing.T) { + type fields struct { + Connector Connector + initialized bool + mode int + pool *grpool.Pool + poolExpiredTime int + poolWorkerNum int + } + type args struct { + t int + } + tests := []struct { + name string + fields fields + args args + }{ + { + name: "case", + fields: struct { + Connector Connector + initialized bool + mode int + pool *grpool.Pool + poolExpiredTime int + poolWorkerNum int + }{Connector: BaseConnector{}, initialized: false, mode: LogPoolMode, pool: grpool.NewPool(100, 50), poolExpiredTime: 100, poolWorkerNum: 50}, + args: struct{ t int }{t: 100}, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + l := &Log{ + Connector: tt.fields.Connector, + initialized: tt.fields.initialized, + mode: tt.fields.mode, + pool: tt.fields.pool, + poolExpiredTime: tt.fields.poolExpiredTime, + poolWorkerNum: tt.fields.poolWorkerNum, + } + l.SetPoolExpiredTime(tt.args.t) + }) + } +} + +func TestLog_GetPoolWorkerNum(t *testing.T) { + type fields struct { + Connector Connector + initialized bool + mode int + pool *grpool.Pool + poolExpiredTime int + poolWorkerNum int + } + tests := []struct { + name string + fields fields + want int + }{ + { + name: "case", + fields: struct { + Connector Connector + initialized bool + mode int + pool *grpool.Pool + poolExpiredTime int + poolWorkerNum int + }{Connector: BaseConnector{}, initialized: false, mode: LogPoolMode, pool: grpool.NewPool(100, 50), poolExpiredTime: 50, poolWorkerNum: 100}, + want: 100, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + l := &Log{ + Connector: tt.fields.Connector, + initialized: tt.fields.initialized, + mode: tt.fields.mode, + pool: tt.fields.pool, + poolExpiredTime: tt.fields.poolExpiredTime, + poolWorkerNum: tt.fields.poolWorkerNum, + } + if got := l.GetPoolWorkerNum(); got != tt.want { + t.Errorf("Log.GetPoolWorkerNum() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestLog_GetPoolExpiredTime(t *testing.T) { + type fields struct { + Connector Connector + initialized bool + mode int + pool *grpool.Pool + poolExpiredTime int + poolWorkerNum int + } + tests := []struct { + name string + fields fields + want int + }{ + { + name: "case", + fields: struct { + Connector Connector + initialized bool + mode int + pool *grpool.Pool + poolExpiredTime int + poolWorkerNum int + }{Connector: BaseConnector{}, initialized: false, mode: LogPoolMode, pool: grpool.NewPool(100, 50), poolExpiredTime: 50, poolWorkerNum: 100}, + want: 50, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + l := &Log{ + Connector: tt.fields.Connector, + initialized: tt.fields.initialized, + mode: tt.fields.mode, + pool: tt.fields.pool, + poolExpiredTime: tt.fields.poolExpiredTime, + poolWorkerNum: tt.fields.poolWorkerNum, + } + if got := l.GetPoolExpiredTime(); got != tt.want { + t.Errorf("Log.GetPoolExpiredTime() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestNewLog(t *testing.T) { + type args struct { + mode int + } + tests := []struct { + name string + args args + want *Log + }{ + { + name: "case", + args: struct{ mode int }{mode: LogSyncMode}, + want: &Log{mode: LogSyncMode, initialized: true}, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if got := NewLog(tt.args.mode); !reflect.DeepEqual(got, tt.want) { + t.Errorf("NewLog() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestLog_IsInitialized(t *testing.T) { + type fields struct { + Connector Connector + initialized bool + mode int + pool *grpool.Pool + poolExpiredTime int + poolWorkerNum int + } + tests := []struct { + name string + fields fields + want bool + }{ + { + name: "case", + fields: struct { + Connector Connector + initialized bool + mode int + pool *grpool.Pool + poolExpiredTime int + poolWorkerNum int + }{Connector: BaseConnector{}, initialized: false, mode: LogPoolMode, pool: grpool.NewPool(100, 50), poolExpiredTime: 50, poolWorkerNum: 100}, + want: false, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + l := &Log{ + Connector: tt.fields.Connector, + initialized: tt.fields.initialized, + mode: tt.fields.mode, + pool: tt.fields.pool, + poolExpiredTime: tt.fields.poolExpiredTime, + poolWorkerNum: tt.fields.poolWorkerNum, + } + if got := l.IsInitialized(); got != tt.want { + t.Errorf("Log.IsInitialized() = %v, want %v", got, tt.want) + } + }) + } +} -// 测试 func TestLog_SetMode(t *testing.T) { - // 创建一个对象 - // 设置日志等级 - // 设置对象模式 - // 传入该模式下对应配置 - // 传入日志配置器，用来切割文件等数据 + type fields struct { + Connector Connector + initialized bool + mode int + pool *grpool.Pool + poolExpiredTime int + poolWorkerNum int + } + type args struct { + m int + } + tests := []struct { + name string + fields fields + args args + }{ + { + name: "case", + fields: struct { + Connector Connector + initialized bool + mode int + pool *grpool.Pool + poolExpiredTime int + poolWorkerNum int + }{Connector: BaseConnector{}, initialized: false, mode: LogPoolMode, pool: grpool.NewPool(100, 50), poolExpiredTime: 50, poolWorkerNum: 100}, + args: struct{ m int }{m: LogPoolMode}, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + l := &Log{ + Connector: tt.fields.Connector, + initialized: tt.fields.initialized, + mode: tt.fields.mode, + pool: tt.fields.pool, + poolExpiredTime: tt.fields.poolExpiredTime, + poolWorkerNum: tt.fields.poolWorkerNum, + } + l.SetMode(tt.args.m) + }) + } +} + +func TestLog_LoadConnector(t *testing.T) { + type fields struct { + Connector Connector + initialized bool + mode int + pool *grpool.Pool + poolExpiredTime int + poolWorkerNum int + } + type args struct { + conn Connector + } + tests := []struct { + name string + fields fields + args args + }{ + { + name: "case", + fields: struct { + Connector Connector + initialized bool + mode int + pool *grpool.Pool + poolExpiredTime int + poolWorkerNum int + }{Connector: BaseConnector{}, initialized: false, mode: LogPoolMode, pool: grpool.NewPool(100, 50), poolExpiredTime: 50, poolWorkerNum: 100}, + args: struct{ conn Connector }{conn: BaseConnector{}}, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + l := &Log{ + Connector: tt.fields.Connector, + initialized: tt.fields.initialized, + mode: tt.fields.mode, + pool: tt.fields.pool, + poolExpiredTime: tt.fields.poolExpiredTime, + poolWorkerNum: tt.fields.poolWorkerNum, + } + l.LoadConnector(tt.args.conn) + }) + } +} + +func TestLog_Fatal(t *testing.T) { + type fields struct { + Connector Connector + initialized bool + mode int + pool *grpool.Pool + poolExpiredTime int + poolWorkerNum int + } + type args struct { + message string + } + tests := []struct { + name string + fields fields + args args + }{ + { + name: "case", + fields: struct { + Connector Connector + initialized bool + mode int + pool *grpool.Pool + poolExpiredTime int + poolWorkerNum int + }{Connector: BaseConnector{}, initialized: true, mode: LogSyncMode, pool: grpool.NewPool(100, 50), poolExpiredTime: 50, poolWorkerNum: 100}, + args: struct{ message string }{message: "Fatal testing"}, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + l := &Log{ + Connector: tt.fields.Connector, + initialized: tt.fields.initialized, + mode: tt.fields.mode, + pool: tt.fields.pool, + poolExpiredTime: tt.fields.poolExpiredTime, + poolWorkerNum: tt.fields.poolWorkerNum, + } + l.Fatal(tt.args.message) + }) + } +} + +func TestLog_Error(t *testing.T) { + type fields struct { + Connector Connector + initialized bool + mode int + pool *grpool.Pool + poolExpiredTime int + poolWorkerNum int + } + type args struct { + message string + } + tests := []struct { + name string + fields fields + args args + }{ + { + name: "case", + fields: struct { + Connector Connector + initialized bool + mode int + pool *grpool.Pool + poolExpiredTime int + poolWorkerNum int + }{Connector: BaseConnector{}, initialized: true, mode: LogPoolMode, pool: grpool.NewPool(100, 50), poolExpiredTime: 50, poolWorkerNum: 100}, + args: struct{ message string }{message: "Error testing"}, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + l := &Log{ + Connector: tt.fields.Connector, + initialized: tt.fields.initialized, + mode: tt.fields.mode, + pool: tt.fields.pool, + poolExpiredTime: tt.fields.poolExpiredTime, + poolWorkerNum: tt.fields.poolWorkerNum, + } + l.Error(tt.args.message) + l.pool.WaitAll() + }) + } +} + +func TestLog_Warning(t *testing.T) { + type fields struct { + Connector Connector + initialized bool + mode int + pool *grpool.Pool + poolExpiredTime int + poolWorkerNum int + } + type args struct { + message string + } + tests := []struct { + name string + fields fields + args args + }{ + { + name: "case", + fields: struct { + Connector Connector + initialized bool + mode int + pool *grpool.Pool + poolExpiredTime int + poolWorkerNum int + }{Connector: BaseConnector{}, initialized: false, mode: LogPoolMode, pool: grpool.NewPool(100, 50), poolExpiredTime: 0, poolWorkerNum: 0}, + args: struct{ message string }{message: "Warning testing"}, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + l := &Log{ + Connector: tt.fields.Connector, + initialized: tt.fields.initialized, + mode: tt.fields.mode, + pool: tt.fields.pool, + poolExpiredTime: tt.fields.poolExpiredTime, + poolWorkerNum: tt.fields.poolWorkerNum, + } + l.Warning(tt.args.message) + //l.WaitAll() + l.WaitAll() + }) + } +} + +func TestLog_Debug(t *testing.T) { + type fields struct { + Connector Connector + initialized bool + mode int + pool *grpool.Pool + poolExpiredTime int + poolWorkerNum int + } + type args struct { + message string + } + tests := []struct { + name string + fields fields + args args + }{ + { + name: "case", + fields: struct { + Connector Connector + initialized bool + mode int + pool *grpool.Pool + poolExpiredTime int + poolWorkerNum int + }{Connector: BaseConnector{}, initialized: false, mode: LogPoolMode, pool: grpool.NewPool(100, 50), poolExpiredTime: 50, poolWorkerNum: 100}, + args: struct{ message string }{message: "Debug testing"}, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + l := &Log{ + Connector: tt.fields.Connector, + initialized: tt.fields.initialized, + mode: tt.fields.mode, + pool: tt.fields.pool, + poolExpiredTime: tt.fields.poolExpiredTime, + poolWorkerNum: tt.fields.poolWorkerNum, + } + l.Debug(tt.args.message) + l.WaitAll() + }) + } +} + +func TestLog_Info(t *testing.T) { + type fields struct { + Connector Connector + initialized bool + mode int + pool *grpool.Pool + poolExpiredTime int + poolWorkerNum int + } + type args struct { + message string + } + tests := []struct { + name string + fields fields + args args + }{ + { + name: "case", + fields: struct { + Connector Connector + initialized bool + mode int + pool *grpool.Pool + poolExpiredTime int + poolWorkerNum int + }{Connector: BaseConnector{}, initialized: false, mode: LogPoolMode, pool: grpool.NewPool(100, 50), poolExpiredTime: 50, poolWorkerNum: 100}, + args: struct{ message string }{message: "Info testing"}, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + l := &Log{ + Connector: tt.fields.Connector, + initialized: tt.fields.initialized, + mode: tt.fields.mode, + pool: tt.fields.pool, + poolExpiredTime: tt.fields.poolExpiredTime, + poolWorkerNum: tt.fields.poolWorkerNum, + } + l.Info(tt.args.message) + l.WaitAll() + }) + } +} + +func TestLog_exec(t *testing.T) { + type fields struct { + Connector Connector + initialized bool + mode int + pool *grpool.Pool + poolExpiredTime int + poolWorkerNum int + } + type args struct { + f func(message string) + message string + } + tests := []struct { + name string + fields fields + args args + }{ + { + name: "case", + fields: struct { + Connector Connector + initialized bool + mode int + pool *grpool.Pool + poolExpiredTime int + poolWorkerNum int + }{Connector: BaseConnector{}, initialized: false, mode: LogPoolMode, pool: grpool.NewPool(100, 50), poolExpiredTime: 50, poolWorkerNum: 100}, + args: struct { + f func(message string) + message string + }{f: func(message string) { + fmt.Println(message) + }, message: "Exec testing"}, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + l := &Log{ + Connector: tt.fields.Connector, + initialized: tt.fields.initialized, + mode: tt.fields.mode, + pool: tt.fields.pool, + poolExpiredTime: tt.fields.poolExpiredTime, + poolWorkerNum: tt.fields.poolWorkerNum, + } + l.exec(tt.args.f, tt.args.message) + l.pool.WaitAll() + }) + } }