From 98f6e2fbe7275b26eca627c1dba6bfcf3685ba09 Mon Sep 17 00:00:00 2001
From: Liang Ding <dl88250@gmail.com>
Date: Sun, 21 Dec 2014 11:06:10 +0800
Subject: [PATCH] test coverage

---
 log/logs.go      | 35 +++++++++++----------
 log/logs_test.go | 79 ++++++++++++++++++++++++++++++++++++++++++++++--
 2 files changed, 96 insertions(+), 18 deletions(-)

diff --git a/log/logs.go b/log/logs.go
index eceef59..8097795 100755
--- a/log/logs.go
+++ b/log/logs.go
@@ -35,7 +35,8 @@ import (
 
 // Logging level.
 const (
-	Trace = iota
+	Off = iota
+	Trace
 	Debug
 	Info
 	Warn
@@ -78,6 +79,8 @@ func getLevel(level string) int {
 	level = strings.ToLower(level)
 
 	switch level {
+	case "off":
+		return Off
 	case "trace":
 		return Trace
 	case "debug":
@@ -98,6 +101,21 @@ func (l *Logger) SetLevel(level string) {
 	l.level = getLevel(level)
 }
 
+// IsTraceEnabled determines whether the trace level is enabled.
+func (l *Logger) IsTraceEnabled() bool {
+	return l.level <= Trace
+}
+
+// IsDebugEnabled determines whether the debug level is enabled.
+func (l *Logger) IsDebugEnabled() bool {
+	return l.level <= Debug
+}
+
+// IsWarnEnabled determines whether the debug level is enabled.
+func (l *Logger) IsWarnEnabled() bool {
+	return l.level <= Warn
+}
+
 // Trace prints trace level message.
 func (l *Logger) Trace(v ...interface{}) {
 	if Trace < l.level {
@@ -118,21 +136,6 @@ func (l *Logger) Tracef(format string, v ...interface{}) {
 	l.logger.Output(2, fmt.Sprintf(format, v...))
 }
 
-// IsTraceEnabled determines whether the trace level is enabled.
-func (l *Logger) IsTraceEnabled() bool {
-	return l.level <= Trace
-}
-
-// IsDebugEnabled determines whether the debug level is enabled.
-func (l *Logger) IsDebugEnabled() bool {
-	return l.level <= Debug
-}
-
-// IsWarnEnabled determines whether the debug level is enabled.
-func (l *Logger) IsWarnEnabled() bool {
-	return l.level <= Warn
-}
-
 // Debug prints debug level message.
 func (l *Logger) Debug(v ...interface{}) {
 	if Debug < l.level {
diff --git a/log/logs_test.go b/log/logs_test.go
index bc4823e..63bb3cc 100644
--- a/log/logs_test.go
+++ b/log/logs_test.go
@@ -26,40 +26,105 @@ func TestSetLevel(t *testing.T) {
 }
 
 func TestTrace(t *testing.T) {
+	logger.SetLevel("trace")
+	logger.Trace("trace")
+	logger.SetLevel("off")
 	logger.Trace("trace")
 }
 
 func TestTracef(t *testing.T) {
+	logger.SetLevel("trace")
+	logger.Tracef("tracef")
+	logger.SetLevel("off")
 	logger.Tracef("tracef")
 }
 
+func TestDebug(t *testing.T) {
+	logger.SetLevel("debug")
+	logger.Debug("debug")
+	logger.SetLevel("off")
+	logger.Debug("debug")
+}
+
+func TestDebugf(t *testing.T) {
+	logger.SetLevel("debug")
+	logger.Debugf("debugf")
+	logger.SetLevel("off")
+	logger.Debug("debug")
+}
+
 func TestInfo(t *testing.T) {
+	logger.SetLevel("info")
+	logger.Info("info")
+	logger.SetLevel("off")
 	logger.Info("info")
 }
 
 func TestInfof(t *testing.T) {
+	logger.SetLevel("info")
+	logger.Infof("infof")
+	logger.SetLevel("off")
 	logger.Infof("infof")
 }
 
 func TestWarn(t *testing.T) {
+	logger.SetLevel("warn")
+	logger.Warn("warn")
+	logger.SetLevel("off")
 	logger.Warn("warn")
 }
 
 func TestWarnf(t *testing.T) {
+	logger.SetLevel("warn")
+	logger.Warnf("warnf")
+	logger.SetLevel("off")
 	logger.Warnf("warnf")
 }
 
 func TestError(t *testing.T) {
+	logger.SetLevel("error")
+	logger.Error("error")
+	logger.SetLevel("off")
 	logger.Error("error")
 }
 
 func TestErrorf(t *testing.T) {
+	logger.SetLevel("error")
+	logger.Errorf("errorf")
+	logger.SetLevel("off")
 	logger.Errorf("errorf")
 }
 
 func TestGetLevel(t *testing.T) {
-	l := getLevel("info")
-	logger.Info(l)
+	if getLevel("trace") != Trace {
+		t.FailNow()
+
+		return
+	}
+
+	if getLevel("debug") != Debug {
+		t.FailNow()
+
+		return
+	}
+
+	if getLevel("info") != Info {
+		t.FailNow()
+
+		return
+	}
+
+	if getLevel("warn") != Warn {
+		t.FailNow()
+
+		return
+	}
+
+	if getLevel("error") != Error {
+		t.FailNow()
+
+		return
+	}
 }
 
 func TestLoggerSetLevel(t *testing.T) {
@@ -97,3 +162,13 @@ func TestIsDebugEnabled(t *testing.T) {
 		return
 	}
 }
+
+func TestIsWarnEnabled(t *testing.T) {
+	logger.SetLevel("warn")
+
+	if !logger.IsWarnEnabled() {
+		t.FailNow()
+
+		return
+	}
+}