1 files changed, 58 insertions, 25 deletions

diff --git a/modules/log/logger_test.go b/modules/log/logger_test.go
index 0de14eb411..a74139dc51 100644
--- a/modules/log/logger_test.go
+++ b/modules/log/logger_test.go
@@ -4,7 +4,7 @@
 package log
 
 import (
-	"context"
+	"regexp"
 	"sync"
 	"testing"
 	"time"
@@ -35,11 +35,11 @@ func (d *dummyWriter) Close() error {
 	return nil
 }
 
-func (d *dummyWriter) GetLogs() []string {
+func (d *dummyWriter) FetchLogs() []string {
 	d.mu.Lock()
 	defer d.mu.Unlock()
-	logs := make([]string, len(d.logs))
-	copy(logs, d.logs)
+	logs := d.logs
+	d.logs = nil
 	return logs
 }
 
@@ -53,20 +53,20 @@ func newDummyWriter(name string, level Level, delay time.Duration) *dummyWriter
 }
 
 func TestLogger(t *testing.T) {
-	logger := NewLoggerWithWriters(context.Background(), "test")
+	logger := NewLoggerWithWriters(t.Context(), "test")
 
 	dump := logger.DumpWriters()
 	assert.Empty(t, dump)
-	assert.EqualValues(t, NONE, logger.GetLevel())
+	assert.Equal(t, NONE, logger.GetLevel())
 	assert.False(t, logger.IsEnabled())
 
 	w1 := newDummyWriter("dummy-1", DEBUG, 0)
 	logger.AddWriters(w1)
-	assert.EqualValues(t, DEBUG, logger.GetLevel())
+	assert.Equal(t, DEBUG, logger.GetLevel())
 
 	w2 := newDummyWriter("dummy-2", WARN, 200*time.Millisecond)
 	logger.AddWriters(w2)
-	assert.EqualValues(t, DEBUG, logger.GetLevel())
+	assert.Equal(t, DEBUG, logger.GetLevel())
 
 	dump = logger.DumpWriters()
 	assert.Len(t, dump, 2)
@@ -77,18 +77,18 @@ func TestLogger(t *testing.T) {
 
 	// w2 is slow, so only w1 has logs
 	time.Sleep(100 * time.Millisecond)
-	assert.Equal(t, []string{"debug-level\n", "error-level\n"}, w1.GetLogs())
-	assert.Equal(t, []string{}, w2.GetLogs())
+	assert.Equal(t, []string{"debug-level\n", "error-level\n"}, w1.FetchLogs())
+	assert.Empty(t, w2.FetchLogs())
 
 	logger.Close()
 
 	// after Close, all logs are flushed
-	assert.Equal(t, []string{"debug-level\n", "error-level\n"}, w1.GetLogs())
-	assert.Equal(t, []string{"error-level\n"}, w2.GetLogs())
+	assert.Empty(t, w1.FetchLogs())
+	assert.Equal(t, []string{"error-level\n"}, w2.FetchLogs())
 }
 
 func TestLoggerPause(t *testing.T) {
-	logger := NewLoggerWithWriters(context.Background(), "test")
+	logger := NewLoggerWithWriters(t.Context(), "test")
 
 	w1 := newDummyWriter("dummy-1", DEBUG, 0)
 	logger.AddWriters(w1)
@@ -98,12 +98,12 @@ func TestLoggerPause(t *testing.T) {
 
 	logger.Info("info-level")
 	time.Sleep(100 * time.Millisecond)
-	assert.Equal(t, []string{}, w1.GetLogs())
+	assert.Empty(t, w1.FetchLogs())
 
 	GetManager().ResumeAll()
 
 	time.Sleep(100 * time.Millisecond)
-	assert.Equal(t, []string{"info-level\n"}, w1.GetLogs())
+	assert.Equal(t, []string{"info-level\n"}, w1.FetchLogs())
 
 	logger.Close()
 }
@@ -116,21 +116,54 @@ func (t testLogString) LogString() string {
 	return "log-string"
 }
 
-func TestLoggerLogString(t *testing.T) {
-	logger := NewLoggerWithWriters(context.Background(), "test")
+type testLogStringPtrReceiver struct {
+	Field string
+}
 
-	w1 := newDummyWriter("dummy-1", DEBUG, 0)
-	w1.Mode.Colorize = true
-	logger.AddWriters(w1)
+func (t *testLogStringPtrReceiver) LogString() string {
+	return "log-string-ptr-receiver"
+}
 
-	logger.Info("%s %s %#v %v", testLogString{}, &testLogString{}, testLogString{Field: "detail"}, NewColoredValue(testLogString{}, FgRed))
-	logger.Close()
+func genericFunc[T any](logger Logger, v T) {
+	logger.Info("from genericFunc: %v", v)
+}
 
-	assert.Equal(t, []string{"log-string log-string log.testLogString{Field:\"detail\"} \x1b[31mlog-string\x1b[0m\n"}, w1.GetLogs())
+func TestLoggerOutput(t *testing.T) {
+	t.Run("LogString", func(t *testing.T) {
+		logger := NewLoggerWithWriters(t.Context(), "test")
+		w1 := newDummyWriter("dummy-1", DEBUG, 0)
+		w1.Mode.Colorize = true
+		logger.AddWriters(w1)
+		logger.Info("%s %s %#v %v", testLogString{}, &testLogString{}, testLogString{Field: "detail"}, NewColoredValue(testLogString{}, FgRed))
+		logger.Info("%s %s %#v %v", testLogStringPtrReceiver{}, &testLogStringPtrReceiver{}, testLogStringPtrReceiver{Field: "detail"}, NewColoredValue(testLogStringPtrReceiver{}, FgRed))
+		logger.Close()
+
+		assert.Equal(t, []string{
+			"log-string log-string log.testLogString{Field:\"detail\"} \x1b[31mlog-string\x1b[0m\n",
+			"log-string-ptr-receiver log-string-ptr-receiver &log.testLogStringPtrReceiver{Field:\"detail\"} \x1b[31mlog-string-ptr-receiver\x1b[0m\n",
+		}, w1.FetchLogs())
+	})
+
+	t.Run("Caller", func(t *testing.T) {
+		logger := NewLoggerWithWriters(t.Context(), "test")
+		w1 := newDummyWriter("dummy-1", DEBUG, 0)
+		w1.EventWriterBaseImpl.Mode.Flags.flags = Lmedfile | Lshortfuncname
+		logger.AddWriters(w1)
+		anonymousFunc := func(logger Logger) {
+			logger.Info("from anonymousFunc")
+		}
+		genericFunc(logger, "123")
+		anonymousFunc(logger)
+		logger.Close()
+		logs := w1.FetchLogs()
+		assert.Len(t, logs, 2)
+		assert.Regexp(t, `modules/log/logger_test.go:\w+:`+regexp.QuoteMeta(`genericFunc() from genericFunc: 123`), logs[0])
+		assert.Regexp(t, `modules/log/logger_test.go:\w+:`+regexp.QuoteMeta(`TestLoggerOutput.2.1() from anonymousFunc`), logs[1])
+	})
 }
 
 func TestLoggerExpressionFilter(t *testing.T) {
-	logger := NewLoggerWithWriters(context.Background(), "test")
+	logger := NewLoggerWithWriters(t.Context(), "test")
 
 	w1 := newDummyWriter("dummy-1", DEBUG, 0)
 	w1.Mode.Expression = "foo.*"
@@ -142,5 +175,5 @@ func TestLoggerExpressionFilter(t *testing.T) {
 	logger.SendLogEvent(&Event{Level: INFO, Filename: "foo.go", MsgSimpleText: "by filename"})
 	logger.Close()
 
-	assert.Equal(t, []string{"foo\n", "foo bar\n", "by filename\n"}, w1.GetLogs())
+	assert.Equal(t, []string{"foo\n", "foo bar\n", "by filename\n"}, w1.FetchLogs())
 }