2015-07-06 17:54:22 -07:00
|
|
|
// Copyright 2014 The go-ethereum Authors
|
2015-07-22 09:48:40 -07:00
|
|
|
// This file is part of the go-ethereum library.
|
2015-07-06 17:54:22 -07:00
|
|
|
//
|
|
|
|
// go-ethereum is free software: you can redistribute it and/or modify
|
|
|
|
// it under the terms of the GNU Lesser General Public License as published by
|
|
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
|
|
// (at your option) any later version.
|
|
|
|
//
|
2015-07-22 09:48:40 -07:00
|
|
|
// The go-ethereum library is distributed in the hope that it will be useful,
|
2015-07-06 17:54:22 -07:00
|
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
2015-07-22 09:48:40 -07:00
|
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
2015-07-06 17:54:22 -07:00
|
|
|
// GNU Lesser General Public License for more details.
|
|
|
|
//
|
|
|
|
// You should have received a copy of the GNU Lesser General Public License
|
2015-07-22 09:48:40 -07:00
|
|
|
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
|
2015-07-06 17:54:22 -07:00
|
|
|
|
2014-10-31 04:56:05 -07:00
|
|
|
package logger
|
2014-06-23 04:49:04 -07:00
|
|
|
|
|
|
|
import (
|
2014-06-26 10:45:57 -07:00
|
|
|
"io/ioutil"
|
2014-10-14 05:35:16 -07:00
|
|
|
"math/rand"
|
2014-06-26 10:45:57 -07:00
|
|
|
"os"
|
2014-10-14 10:05:43 -07:00
|
|
|
"sync"
|
2014-06-26 10:45:57 -07:00
|
|
|
"testing"
|
2014-10-14 05:35:16 -07:00
|
|
|
"time"
|
2014-06-23 04:49:04 -07:00
|
|
|
)
|
|
|
|
|
|
|
|
type TestLogSystem struct {
|
2014-10-14 10:05:43 -07:00
|
|
|
mutex sync.Mutex
|
|
|
|
output string
|
2014-06-26 10:45:57 -07:00
|
|
|
level LogLevel
|
2014-06-23 04:49:04 -07:00
|
|
|
}
|
|
|
|
|
2015-03-21 02:20:47 -07:00
|
|
|
func (ls *TestLogSystem) LogPrint(msg LogMsg) {
|
2014-10-14 10:05:43 -07:00
|
|
|
ls.mutex.Lock()
|
2015-03-21 02:20:47 -07:00
|
|
|
if ls.level >= msg.Level() {
|
|
|
|
ls.output += msg.String()
|
|
|
|
}
|
2014-10-14 10:05:43 -07:00
|
|
|
ls.mutex.Unlock()
|
2014-06-23 04:49:04 -07:00
|
|
|
}
|
|
|
|
|
2014-10-14 10:05:43 -07:00
|
|
|
func (ls *TestLogSystem) SetLogLevel(i LogLevel) {
|
|
|
|
ls.mutex.Lock()
|
|
|
|
ls.level = i
|
|
|
|
ls.mutex.Unlock()
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ls *TestLogSystem) GetLogLevel() LogLevel {
|
|
|
|
ls.mutex.Lock()
|
|
|
|
defer ls.mutex.Unlock()
|
|
|
|
return ls.level
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ls *TestLogSystem) CheckOutput(t *testing.T, expected string) {
|
|
|
|
ls.mutex.Lock()
|
|
|
|
output := ls.output
|
|
|
|
ls.mutex.Unlock()
|
|
|
|
if output != expected {
|
|
|
|
t.Errorf("log output mismatch:\n got: %q\n want: %q\n", output, expected)
|
|
|
|
}
|
2014-06-23 04:49:04 -07:00
|
|
|
}
|
|
|
|
|
2014-10-14 10:07:54 -07:00
|
|
|
type blockedLogSystem struct {
|
|
|
|
LogSystem
|
|
|
|
unblock chan struct{}
|
|
|
|
}
|
|
|
|
|
2015-03-21 02:20:47 -07:00
|
|
|
func (ls blockedLogSystem) LogPrint(msg LogMsg) {
|
2014-10-14 10:07:54 -07:00
|
|
|
<-ls.unblock
|
2015-03-21 02:20:47 -07:00
|
|
|
ls.LogSystem.LogPrint(msg)
|
2014-06-23 04:49:04 -07:00
|
|
|
}
|
|
|
|
|
2014-07-14 10:37:01 -07:00
|
|
|
func TestLoggerFlush(t *testing.T) {
|
2014-10-14 05:33:58 -07:00
|
|
|
Reset()
|
|
|
|
|
2014-07-14 10:37:01 -07:00
|
|
|
logger := NewLogger("TEST")
|
2014-10-14 10:07:54 -07:00
|
|
|
ls := blockedLogSystem{&TestLogSystem{level: WarnLevel}, make(chan struct{})}
|
|
|
|
AddLogSystem(ls)
|
2014-07-14 10:37:01 -07:00
|
|
|
for i := 0; i < 5; i++ {
|
2014-10-14 10:07:54 -07:00
|
|
|
// these writes shouldn't hang even though ls is blocked
|
2014-07-14 10:37:01 -07:00
|
|
|
logger.Errorf(".")
|
|
|
|
}
|
2014-10-14 10:07:54 -07:00
|
|
|
|
|
|
|
beforeFlush := time.Now()
|
|
|
|
time.AfterFunc(80*time.Millisecond, func() { close(ls.unblock) })
|
|
|
|
Flush() // this should hang for approx. 80ms
|
|
|
|
if blockd := time.Now().Sub(beforeFlush); blockd < 80*time.Millisecond {
|
|
|
|
t.Errorf("Flush didn't block long enough, blocked for %v, should've been >= 80ms", blockd)
|
2014-07-14 10:37:01 -07:00
|
|
|
}
|
2014-10-14 10:07:54 -07:00
|
|
|
|
|
|
|
ls.LogSystem.(*TestLogSystem).CheckOutput(t, "[TEST] .[TEST] .[TEST] .[TEST] .[TEST] .")
|
2014-07-14 10:37:01 -07:00
|
|
|
}
|
|
|
|
|
2014-06-23 04:49:04 -07:00
|
|
|
func TestLoggerPrintln(t *testing.T) {
|
2014-10-14 05:33:58 -07:00
|
|
|
Reset()
|
|
|
|
|
2014-06-26 10:45:57 -07:00
|
|
|
logger := NewLogger("TEST")
|
|
|
|
testLogSystem := &TestLogSystem{level: WarnLevel}
|
|
|
|
AddLogSystem(testLogSystem)
|
|
|
|
logger.Errorln("error")
|
|
|
|
logger.Warnln("warn")
|
|
|
|
logger.Infoln("info")
|
|
|
|
logger.Debugln("debug")
|
|
|
|
Flush()
|
2014-10-14 10:05:43 -07:00
|
|
|
|
|
|
|
testLogSystem.CheckOutput(t, "[TEST] error\n[TEST] warn\n")
|
2014-06-23 04:49:04 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
func TestLoggerPrintf(t *testing.T) {
|
2014-10-14 05:33:58 -07:00
|
|
|
Reset()
|
|
|
|
|
2014-06-26 10:45:57 -07:00
|
|
|
logger := NewLogger("TEST")
|
|
|
|
testLogSystem := &TestLogSystem{level: WarnLevel}
|
|
|
|
AddLogSystem(testLogSystem)
|
2014-10-14 10:05:43 -07:00
|
|
|
logger.Errorf("error to %v\n", []int{1, 2, 3})
|
2014-10-16 01:48:33 -07:00
|
|
|
logger.Warnf("warn %%d %d", 5)
|
2014-06-26 10:45:57 -07:00
|
|
|
logger.Infof("info")
|
|
|
|
logger.Debugf("debug")
|
|
|
|
Flush()
|
2014-10-16 01:48:33 -07:00
|
|
|
testLogSystem.CheckOutput(t, "[TEST] error to [1 2 3]\n[TEST] warn %d 5")
|
2014-06-23 04:49:04 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
func TestMultipleLogSystems(t *testing.T) {
|
2014-10-14 05:33:58 -07:00
|
|
|
Reset()
|
|
|
|
|
2014-06-26 10:45:57 -07:00
|
|
|
logger := NewLogger("TEST")
|
|
|
|
testLogSystem0 := &TestLogSystem{level: ErrorLevel}
|
|
|
|
testLogSystem1 := &TestLogSystem{level: WarnLevel}
|
|
|
|
AddLogSystem(testLogSystem0)
|
|
|
|
AddLogSystem(testLogSystem1)
|
|
|
|
logger.Errorln("error")
|
|
|
|
logger.Warnln("warn")
|
|
|
|
Flush()
|
2014-10-14 10:05:43 -07:00
|
|
|
|
|
|
|
testLogSystem0.CheckOutput(t, "[TEST] error\n")
|
|
|
|
testLogSystem1.CheckOutput(t, "[TEST] error\n[TEST] warn\n")
|
2014-06-23 04:49:04 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
func TestFileLogSystem(t *testing.T) {
|
2014-10-14 05:33:58 -07:00
|
|
|
Reset()
|
|
|
|
|
2014-06-26 10:45:57 -07:00
|
|
|
logger := NewLogger("TEST")
|
|
|
|
filename := "test.log"
|
|
|
|
file, _ := os.OpenFile(filename, os.O_RDWR|os.O_CREATE, os.ModePerm)
|
|
|
|
testLogSystem := NewStdLogSystem(file, 0, WarnLevel)
|
|
|
|
AddLogSystem(testLogSystem)
|
|
|
|
logger.Errorf("error to %s\n", filename)
|
|
|
|
logger.Warnln("warn")
|
|
|
|
Flush()
|
|
|
|
contents, _ := ioutil.ReadFile(filename)
|
|
|
|
output := string(contents)
|
|
|
|
if output != "[TEST] error to test.log\n[TEST] warn\n" {
|
2014-07-05 10:36:22 -07:00
|
|
|
t.Error("Expected contents of file 'test.log': '[TEST] error to test.log\\n[TEST] warn\\n', got ", output)
|
2014-06-26 10:45:57 -07:00
|
|
|
} else {
|
|
|
|
os.Remove(filename)
|
|
|
|
}
|
2014-06-23 04:49:04 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
func TestNoLogSystem(t *testing.T) {
|
2014-10-14 05:33:58 -07:00
|
|
|
Reset()
|
|
|
|
|
2014-06-26 10:45:57 -07:00
|
|
|
logger := NewLogger("TEST")
|
|
|
|
logger.Warnln("warn")
|
|
|
|
Flush()
|
2014-06-23 04:49:04 -07:00
|
|
|
}
|
2014-10-14 05:35:16 -07:00
|
|
|
|
|
|
|
func TestConcurrentAddSystem(t *testing.T) {
|
|
|
|
rand.Seed(time.Now().Unix())
|
|
|
|
Reset()
|
|
|
|
|
|
|
|
logger := NewLogger("TEST")
|
|
|
|
stop := make(chan struct{})
|
|
|
|
writer := func() {
|
|
|
|
select {
|
|
|
|
case <-stop:
|
|
|
|
return
|
|
|
|
default:
|
2014-10-14 10:05:43 -07:00
|
|
|
logger.Infoln("foo")
|
2014-10-14 05:35:16 -07:00
|
|
|
Flush()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
go writer()
|
|
|
|
go writer()
|
|
|
|
|
|
|
|
stopTime := time.Now().Add(100 * time.Millisecond)
|
|
|
|
for time.Now().Before(stopTime) {
|
|
|
|
time.Sleep(time.Duration(rand.Intn(20)) * time.Millisecond)
|
2014-10-14 10:07:19 -07:00
|
|
|
AddLogSystem(NewStdLogSystem(ioutil.Discard, 0, InfoLevel))
|
2014-10-14 05:35:16 -07:00
|
|
|
}
|
|
|
|
close(stop)
|
|
|
|
}
|