rs-zerolog/log_test.go

package zerolog

import (
	"bytes"
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"math"
	"net"
	"reflect"
	"runtime"
	"strconv"
	"strings"
	"testing"
	"time"
)

func TestLog(t *testing.T) {
	t.Run("empty", func(t *testing.T) {
		out := &bytes.Buffer{}
		log := New(out)
		log.Log().Msg("")
		if got, want := decodeIfBinaryToString(out.Bytes()), "{}\n"; got != want {
			t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
		}
	})

	t.Run("one-field", func(t *testing.T) {
		out := &bytes.Buffer{}
		log := New(out)
		log.Log().Str("foo", "bar").Msg("")
		if got, want := decodeIfBinaryToString(out.Bytes()), `{"foo":"bar"}`+"\n"; got != want {
			t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
		}
	})

	t.Run("two-field", func(t *testing.T) {
		out := &bytes.Buffer{}
		log := New(out)
		log.Log().
			Str("foo", "bar").
			Int("n", 123).
			Msg("")
		if got, want := decodeIfBinaryToString(out.Bytes()), `{"foo":"bar","n":123}`+"\n"; got != want {
			t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
		}
	})
}

func TestInfo(t *testing.T) {
	t.Run("empty", func(t *testing.T) {
		out := &bytes.Buffer{}
		log := New(out)
		log.Info().Msg("")
		if got, want := decodeIfBinaryToString(out.Bytes()), `{"level":"info"}`+"\n"; got != want {
			t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
		}
	})

	t.Run("one-field", func(t *testing.T) {
		out := &bytes.Buffer{}
		log := New(out)
		log.Info().Str("foo", "bar").Msg("")
		if got, want := decodeIfBinaryToString(out.Bytes()), `{"level":"info","foo":"bar"}`+"\n"; got != want {
			t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
		}
	})

	t.Run("two-field", func(t *testing.T) {
		out := &bytes.Buffer{}
		log := New(out)
		log.Info().
			Str("foo", "bar").
			Int("n", 123).
			Msg("")
		if got, want := decodeIfBinaryToString(out.Bytes()), `{"level":"info","foo":"bar","n":123}`+"\n"; got != want {
			t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
		}
	})
}

func TestEmptyLevelFieldName(t *testing.T) {
	fieldName := LevelFieldName
	LevelFieldName = ""

	t.Run("empty setting", func(t *testing.T) {
		out := &bytes.Buffer{}
		log := New(out)
		log.Info().
			Str("foo", "bar").
			Int("n", 123).
			Msg("")
		if got, want := decodeIfBinaryToString(out.Bytes()), `{"foo":"bar","n":123}`+"\n"; got != want {
			t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
		}
	})
	LevelFieldName = fieldName
}

func TestWith(t *testing.T) {
	out := &bytes.Buffer{}
	ctx := New(out).With().
		Str("string", "foo").
		Stringer("stringer", net.IP{127, 0, 0, 1}).
		Stringer("stringer_nil", nil).
		Bytes("bytes", []byte("bar")).
		Hex("hex", []byte{0x12, 0xef}).
		RawJSON("json", []byte(`{"some":"json"}`)).
		AnErr("some_err", nil).
		Err(errors.New("some error")).
		Bool("bool", true).
		Int("int", 1).
		Int8("int8", 2).
		Int16("int16", 3).
		Int32("int32", 4).
		Int64("int64", 5).
		Uint("uint", 6).
		Uint8("uint8", 7).
		Uint16("uint16", 8).
		Uint32("uint32", 9).
		Uint64("uint64", 10).
		Float32("float32", 11.101).
		Float64("float64", 12.30303).
		Time("time", time.Time{}).
		Dur("dur", 3).
		Ctx(context.Background()).
		Any("any", "test").
		Interface("interface", struct {
			Pub string
			Tag string `json:"tag"`
		}{"a", "b"}).
		Type("type", math.Phi)
	_, file, line, _ := runtime.Caller(0)
	caller := fmt.Sprintf("%s:%d", file, line+3)
	log := ctx.Caller().Logger()
	log.Log().Msg("")
	if got, want := decodeIfBinaryToString(out.Bytes()),
		`{"string":"foo","stringer":"127.0.0.1","stringer_nil":null,"bytes":"bar","hex":"12ef","json":{"some":"json"},"error":"some error","bool":true,"int":1,"int8":2,"int16":3,"int32":4,"int64":5,"uint":6,"uint8":7,"uint16":8,"uint32":9,"uint64":10,"float32":11.101,"float64":12.30303,"time":"0001-01-01T00:00:00Z","dur":0.000003,"any":"test","interface":{"Pub":"a","tag":"b"},"type":"float64","caller":"`+caller+`"}`+"\n"; got != want {
		t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
	}

	// Validate CallerWithSkipFrameCount.
	out.Reset()
	ctx = New(out).With()
	_, file, line, _ = runtime.Caller(0)
	caller = fmt.Sprintf("%s:%d", file, line+5)
	log = ctx.CallerWithSkipFrameCount(3).Logger()
	func() {
		log.Log().Msg("")
	}()
	// The above line is a little contrived, but the line above should be the line due
	// to the extra frame skip.
	if got, want := decodeIfBinaryToString(out.Bytes()), `{"caller":"`+caller+`"}`+"\n"; got != want {
		t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
	}
}

func TestStackedWiths(t *testing.T) {
	out := &bytes.Buffer{}
	ctx := New(out).With().
		Bool("bool", true)
	ctx = ctx.Logger().With().
		Int("int", 1)
	log := ctx.Logger()
	log.Log().Msg("")
	if got, want := decodeIfBinaryToString(out.Bytes()),
		`{"bool":true,"int":1}`+"\n"; got != want {
		t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
	}
}

func TestWithPlurals(t *testing.T) {
	out := &bytes.Buffer{}
	ctx := New(out).
		With().
		Objects("objs", []LogObjectMarshaler{fixtureObj{"a", "z", 1}}).
		Objects("objs_nil", nil).
		ObjectsV("objs_v", fixtureObj{"A", "Z", 2}).
		ObjectsV("objs_v_empty").
		Strs("strs", []string{"foo", "bar"}).
		Strs("strs_nil", nil).
		StrsV("strs_v", "baz", "fizz").
		StrsV("strs_v_empty").
		Stringers("stringers", []fmt.Stringer{net.IP{127, 0, 0, 1}, time.Time{}.AddDate(0, 1, 2), 1 * time.Second, nil}).
		Stringers("stringers_nil", nil).
		StringersV("stringers_v", net.IP{127, 0, 0, 1}, time.Time{}.AddDate(0, 1, 2), 1*time.Second, nil).
		StringersV("stringers_v_empty").
		Errs("errs", []error{errors.New("some error"), errors.New("some other error"), nil, loggableError{fmt.Errorf("oops")}, nonLoggableError{fmt.Errorf("whoops"), 401}}).
		Errs("errs_nil", nil).
		Bools("bool", []bool{true, false}).
		Ints("int", []int{1, 2}).
		Ints8("int8", []int8{2, 3}).
		Ints16("int16", []int16{3, 4}).
		Ints32("int32", []int32{4, 5}).
		Ints64("int64", []int64{5, 6}).
		Uints("uint", []uint{6, 7}).
		Uints8("uint8", []uint8{7, 8}).
		Uints16("uint16", []uint16{8, 9}).
		Uints32("uint32", []uint32{9, 10}).
		Uints64("uint64", []uint64{10, 11}).
		Floats32("float32", []float32{1.1, 2.2}).
		Floats64("float64", []float64{2.2, 3.3}).
		Times("time", []time.Time{time.Time{}.AddDate(0, 1, 2), time.Time{}.AddDate(4, 5, 6)}).
		Durs("dur", []time.Duration{1 * time.Second, 2 * time.Second})
	log := ctx.Logger()
	log.Log().Msg("")
	if got, want := decodeIfBinaryToString(out.Bytes()),
		`{"objs":[{"Pub":"a","Tag":"z","priv":1}],"objs_nil":[],"objs_v":[{"Pub":"A","Tag":"Z","priv":2}],"objs_v_empty":[],"strs":["foo","bar"],"strs_nil":[],"strs_v":["baz","fizz"],"strs_v_empty":[],"stringers":["127.0.0.1","0001-02-03 00:00:00 +0000 UTC","1s",null],"stringers_nil":[],"stringers_v":["127.0.0.1","0001-02-03 00:00:00 +0000 UTC","1s",null],"stringers_v_empty":[],"errs":["some error","some other error",null,{"l":"OOPS"},"whoops"],"errs_nil":[],"bool":[true,false],"int":[1,2],"int8":[2,3],"int16":[3,4],"int32":[4,5],"int64":[5,6],"uint":[6,7],"uint8":[7,8],"uint16":[8,9],"uint32":[9,10],"uint64":[10,11],"float32":[1.1,2.2],"float64":[2.2,3.3],"time":["0001-02-03T00:00:00Z","0005-06-07T00:00:00Z"],"dur":[1000,2000]}`+"\n"; got != want {
		t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
	}
}

func TestWithReset(t *testing.T) {
	out := &bytes.Buffer{}
	ctx := New(out).With().
		Str("string", "foo").
		Stringer("stringer", net.IP{127, 0, 0, 1}).
		Stringer("stringer_nil", nil).
		Reset().
		Bytes("bytes", []byte("bar")).
		Hex("hex", []byte{0x12, 0xef}).
		Uint64("uint64", 10).
		Float64("float64", 12.30303).
		Stack().
		Ctx(context.Background())
	log := ctx.Logger()
	log.Log().Msg("")
	if got, want := decodeIfBinaryToString(out.Bytes()), `{"bytes":"bar","hex":"12ef","uint64":10,"float64":12.30303}`+"\n"; got != want {
		t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
	}
}

func TestFieldsMap(t *testing.T) {
	out := &bytes.Buffer{}
	log := New(out)
	log.Log().Fields(map[string]interface{}{
		"nil":     nil,
		"string":  "foo",
		"bytes":   []byte("bar"),
		"error":   errors.New("some error"),
		"bool":    true,
		"int":     int(1),
		"int8":    int8(2),
		"int16":   int16(3),
		"int32":   int32(4),
		"int64":   int64(5),
		"uint":    uint(6),
		"uint8":   uint8(7),
		"uint16":  uint16(8),
		"uint32":  uint32(9),
		"uint64":  uint64(10),
		"float32": float32(11),
		"float64": float64(12),
		"ipv6":    net.IP{0x20, 0x01, 0x0d, 0xb8, 0x85, 0xa3, 0x00, 0x00, 0x00, 0x00, 0x8a, 0x2e, 0x03, 0x70, 0x73, 0x34},
		"ipnet":   net.IPNet{IP: net.IP{0x20, 0x01, 0x0d, 0xb8, 0x85, 0xa3, 0x00, 0x00, 0x00, 0x00, 0x8a, 0x2e, 0x03, 0x70, 0x73, 0x34}, Mask: net.CIDRMask(64, 128)},
		"macaddr": net.HardwareAddr{0x00, 0x1A, 0x2B, 0x3C, 0x4D, 0x5E},
		"dur":     1 * time.Second,
		"time":    time.Time{},
		"obj":     fixtureObj{"a", "b", 1},
		"objs":    []LogObjectMarshaler{fixtureObj{"a", "b", 1}, fixtureObj{"c", "d", 2}},
		"any":     struct{ A string }{"test"},
		"raw":     json.RawMessage(`{"some":"json"}`),
	}).Msg("")
	if got, want := decodeIfBinaryToString(out.Bytes()), `{"any":{"A":"test"},"bool":true,"bytes":"bar","dur":1000,"error":"some error","float32":11,"float64":12,"int":1,"int16":3,"int32":4,"int64":5,"int8":2,"ipnet":"2001:db8:85a3::8a2e:370:7334/64","ipv6":"2001:db8:85a3::8a2e:370:7334","macaddr":"00:1a:2b:3c:4d:5e","nil":null,"obj":{"Pub":"a","Tag":"b","priv":1},"objs":[{"Pub":"a","Tag":"b","priv":1},{"Pub":"c","Tag":"d","priv":2}],"raw":{"some":"json"},"string":"foo","time":"0001-01-01T00:00:00Z","uint":6,"uint16":8,"uint32":9,"uint64":10,"uint8":7}`+"\n"; got != want {
		t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
	}
}
func TestFieldsMap_Arrays(t *testing.T) {
	out := &bytes.Buffer{}
	log := New(out)
	log.Log().Fields(map[string]interface{}{
		"strings":  []string{"foo"},
		"bools":    []bool{true},
		"errors":   []error{errors.New("some error")},
		"ints":     []int{1},
		"ints8":    []int8{1},
		"ints16":   []int16{3},
		"ints32":   []int32{4},
		"ints64":   []int64{5},
		"uints":    []uint{6},
		"uint8s":   []uint8{44},
		"uints16":  []uint16{8},
		"uints32":  []uint32{9},
		"uints64":  []uint64{10},
		"floats32": []float32{11},
		"floats64": []float64{12},
		"ipv6s":    []net.IP{{0x20, 0x01, 0x0d, 0xb8, 0x85, 0xa3, 0x00, 0x00, 0x00, 0x00, 0x8a, 0x2e, 0x03, 0x70, 0x73, 0x34}},
		"ipnets":   []net.IPNet{{IP: net.IP{0x20, 0x01, 0x0d, 0xb8, 0x85, 0xa3, 0x00, 0x00, 0x00, 0x00, 0x8a, 0x2e, 0x03, 0x70, 0x73, 0x34}, Mask: net.CIDRMask(64, 128)}},
		"macaddrs": []net.HardwareAddr{{0x00, 0x1A, 0x2B, 0x3C, 0x4D, 0x5E}},
		"durs":     []time.Duration{1 * time.Second},
		"times":    []time.Time{{}},
		"objs":     []fixtureObj{{"a", "b", 1}},
	}).Msg("")
	// special case: []uint8 are logged as base64 string so we use "," for 44
	if got, want := decodeIfBinaryToString(out.Bytes()), `{"bools":[true],"durs":[1000],"errors":["some error"],"floats32":[11],"floats64":[12],"ints":[1],"ints16":[3],"ints32":[4],"ints64":[5],"ints8":[1],"ipnets":["2001:db8:85a3::8a2e:370:7334/64"],"ipv6s":["2001:db8:85a3::8a2e:370:7334"],"macaddrs":["ABorPE1e"],"objs":[{"Pub":"a","tag":"b"}],"strings":["foo"],"times":["0001-01-01T00:00:00Z"],"uint8s":",","uints":[6],"uints16":[8],"uints32":[9],"uints64":[10]}`+"\n"; got != want {
		t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
	}
}

func TestWithErr(t *testing.T) {
	var err error = nil
	out := &bytes.Buffer{}
	ctx := New(out).With().
		Fields(map[string]interface{}{
			"nil":          nil,
			"nilerror":     err,
			"error":        errors.New("some error"),
			"loggable":     loggableError{errors.New("loggable")},
			"non-loggable": nonLoggableError{fmt.Errorf("oops"), 401},
		})
	log := ctx.Logger()
	log.Log().Msg("")
	if got, want := decodeIfBinaryToString(out.Bytes()), `{"error":"some error","loggable":{"l":"LOGGABLE"},"nil":null,"nilerror":null,"non-loggable":"oops"}`+"\n"; got != want {
		t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
	}
}

func TestFieldsErr(t *testing.T) {
	var err error = nil
	out := &bytes.Buffer{}
	log := New(out)
	log.Log().Fields(map[string]interface{}{
		"nil":          nil,
		"nilerror":     err,
		"error":        errors.New("some error"),
		"loggable":     loggableError{errors.New("loggable")},
		"non-loggable": nonLoggableError{fmt.Errorf("oops"), 401},
	}).Msg("")
	if got, want := decodeIfBinaryToString(out.Bytes()), `{"error":"some error","loggable":{"l":"LOGGABLE"},"nil":null,"nilerror":null,"non-loggable":"oops"}`+"\n"; got != want {
		t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
	}
}
func TestFieldsErrs(t *testing.T) {
	var err error = nil
	out := &bytes.Buffer{}
	log := New(out)
	log.Log().Fields(map[string]interface{}{
		"errors": []error{errors.New("some error"), nil, err, loggableError{errors.New("loggable")}, nonLoggableError{fmt.Errorf("oops"), 404}},
	}).Msg("")
	if got, want := decodeIfBinaryToString(out.Bytes()), `{"errors":["some error",null,null,{"l":"LOGGABLE"},"oops"]}`+"\n"; got != want {
		t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
	}
}

func TestFieldsMapPnt(t *testing.T) {
	out := &bytes.Buffer{}
	log := New(out)
	log.Log().Fields(map[string]interface{}{
		"string":  new(string),
		"bool":    new(bool),
		"int":     new(int),
		"int8":    new(int8),
		"int16":   new(int16),
		"int32":   new(int32),
		"int64":   new(int64),
		"uint":    new(uint),
		"uint8":   new(uint8),
		"uint16":  new(uint16),
		"uint32":  new(uint32),
		"uint64":  new(uint64),
		"float32": new(float32),
		"float64": new(float64),
		"dur":     new(time.Duration),
		"time":    new(time.Time),
	}).Msg("")
	if got, want := decodeIfBinaryToString(out.Bytes()), `{"bool":false,"dur":0,"float32":0,"float64":0,"int":0,"int16":0,"int32":0,"int64":0,"int8":0,"string":"","time":"0001-01-01T00:00:00Z","uint":0,"uint16":0,"uint32":0,"uint64":0,"uint8":0}`+"\n"; got != want {
		t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
	}
}

func TestFieldsMapNilPnt(t *testing.T) {
	var (
		stringPnt  *string
		boolPnt    *bool
		intPnt     *int
		int8Pnt    *int8
		int16Pnt   *int16
		int32Pnt   *int32
		int64Pnt   *int64
		uintPnt    *uint
		uint8Pnt   *uint8
		uint16Pnt  *uint16
		uint32Pnt  *uint32
		uint64Pnt  *uint64
		float32Pnt *float32
		float64Pnt *float64
		durPnt     *time.Duration
		timePnt    *time.Time
	)
	out := &bytes.Buffer{}
	log := New(out)
	fields := map[string]interface{}{
		"string":  stringPnt,
		"bool":    boolPnt,
		"int":     intPnt,
		"int8":    int8Pnt,
		"int16":   int16Pnt,
		"int32":   int32Pnt,
		"int64":   int64Pnt,
		"uint":    uintPnt,
		"uint8":   uint8Pnt,
		"uint16":  uint16Pnt,
		"uint32":  uint32Pnt,
		"uint64":  uint64Pnt,
		"float32": float32Pnt,
		"float64": float64Pnt,
		"dur":     durPnt,
		"time":    timePnt,
	}

	log.Log().Fields(fields).Msg("")
	if got, want := decodeIfBinaryToString(out.Bytes()), `{"bool":null,"dur":null,"float32":null,"float64":null,"int":null,"int16":null,"int32":null,"int64":null,"int8":null,"string":null,"time":null,"uint":null,"uint16":null,"uint32":null,"uint64":null,"uint8":null}`+"\n"; got != want {
		t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
	}
}

func TestFieldsSlice(t *testing.T) {
	out := &bytes.Buffer{}
	log := New(out)
	log.Log().Fields([]interface{}{
		"nil", nil,
		"string", "foo",
		"bytes", []byte("bar"),
		"error", errors.New("some error"),
		"bool", true,
		"int", int(1),
		"int8", int8(2),
		"int16", int16(3),
		"int32", int32(4),
		"int64", int64(5),
		"uint", uint(6),
		"uint8", uint8(7),
		"uint16", uint16(8),
		"uint32", uint32(9),
		"uint64", uint64(10),
		"float32", float32(11),
		"float64", float64(12),
		"ipv6", net.IP{0x20, 0x01, 0x0d, 0xb8, 0x85, 0xa3, 0x00, 0x00, 0x00, 0x00, 0x8a, 0x2e, 0x03, 0x70, 0x73, 0x34},
		"dur", 1 * time.Second,
		"time", time.Time{},
		"obj", fixtureObj{"a", "b", 1},
	}).Msg("")
	if got, want := decodeIfBinaryToString(out.Bytes()), `{"nil":null,"string":"foo","bytes":"bar","error":"some error","bool":true,"int":1,"int8":2,"int16":3,"int32":4,"int64":5,"uint":6,"uint8":7,"uint16":8,"uint32":9,"uint64":10,"float32":11,"float64":12,"ipv6":"2001:db8:85a3::8a2e:370:7334","dur":1000,"time":"0001-01-01T00:00:00Z","obj":{"Pub":"a","Tag":"b","priv":1}}`+"\n"; got != want {
		t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
	}
}

func TestFieldsSliceExtraneous(t *testing.T) {
	out := &bytes.Buffer{}
	log := New(out)
	log.Log().Fields([]interface{}{
		"string", "foo",
		"error", errors.New("some error"),
		32, "valueForNonStringKey",
		"bool", true,
		"int", int(1),
		"keyWithoutValue",
	}).Msg("")
	if got, want := decodeIfBinaryToString(out.Bytes()), `{"string":"foo","error":"some error","bool":true,"int":1}`+"\n"; got != want {
		t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
	}
}

func TestFieldsNotMapSlice(t *testing.T) {
	out := &bytes.Buffer{}
	log := New(out)
	log.Log().
		Fields(fixtureObj{"a", "b", 1}).
		Fields("string").
		Fields(1).
		Msg("")
	if got, want := decodeIfBinaryToString(out.Bytes()), `{}`+"\n"; got != want {
		t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
	}
}

func TestFields(t *testing.T) {
	out := &bytes.Buffer{}
	log := New(out)
	now := time.Now()
	_, file, line, _ := runtime.Caller(0)
	caller := fmt.Sprintf("%s:%d", file, line+3)
	log.Log().
		Caller().
		Object("obj", fixtureObj{"a", "z", 1}).
		Str("string", "foo").
		Stringer("stringer", net.IP{127, 0, 0, 1}).
		Bytes("bytes", []byte("bar")).
		Hex("hex", []byte{0x12, 0xef}).
		RawJSON("json", []byte(`{"some":"json"}`)).
		RawCBOR("cbor", []byte{0x83, 0x01, 0x82, 0x02, 0x03, 0x82, 0x04, 0x05}).
		Func(func(e *Event) { e.Str("func", "func_output") }).
		AnErr("some_err", nil).
		Err(errors.New("some error")).
		Bool("bool", true).
		Int("int", 1).
		Int8("int8", 2).
		Int16("int16", 3).
		Int32("int32", 4).
		Int64("int64", 5).
		Uint("uint", 6).
		Uint8("uint8", 7).
		Uint16("uint16", 8).
		Uint32("uint32", 9).
		Uint64("uint64", 10).
		IPAddr("ipv4", net.IP{192, 168, 0, 100}).
		IPAddr("ipv6", net.IP{0x20, 0x01, 0x0d, 0xb8, 0x85, 0xa3, 0x00, 0x00, 0x00, 0x00, 0x8a, 0x2e, 0x03, 0x70, 0x73, 0x34}).
		MACAddr("mac", net.HardwareAddr{0x00, 0x14, 0x22, 0x01, 0x23, 0x45}).
		IPPrefix("pfxv4", net.IPNet{IP: net.IP{192, 168, 0, 100}, Mask: net.CIDRMask(24, 32)}).
		IPPrefix("pfxv6", net.IPNet{IP: net.IP{0x20, 0x01, 0x0d, 0xb8, 0x85, 0xa3, 0x00, 0x00, 0x00, 0x00, 0x8a, 0x2e, 0x03, 0x70, 0x73, 0x34}, Mask: net.CIDRMask(64, 128)}).
		Float32("float32", 11.1234).
		Float64("float64", 12.321321321).
		Dur("dur", 1*time.Second).
		Time("time", time.Time{}).
		TimeDiff("diff", now, now.Add(-10*time.Second)).
		Ctx(context.Background()).
		Type("type", "hello").
		Any("any", struct{ A string }{"test"}).
		Any("logobject", fixtureObj{"a", "z", 1}).
		Stack().
		Msg("")
	if got, want := decodeIfBinaryToString(out.Bytes()), `{"caller":"`+caller+`","obj":{"Pub":"a","Tag":"z","priv":1},"string":"foo","stringer":"127.0.0.1","bytes":"bar","hex":"12ef","json":{"some":"json"},"cbor":"data:application/cbor;base64,gwGCAgOCBAU=","func":"func_output","error":"some error","bool":true,"int":1,"int8":2,"int16":3,"int32":4,"int64":5,"uint":6,"uint8":7,"uint16":8,"uint32":9,"uint64":10,"ipv4":"192.168.0.100","ipv6":"2001:db8:85a3::8a2e:370:7334","mac":"00:14:22:01:23:45","pfxv4":"192.168.0.100/24","pfxv6":"2001:db8:85a3::8a2e:370:7334/64","float32":11.1234,"float64":12.321321321,"dur":1000,"time":"0001-01-01T00:00:00Z","diff":10000,"type":"string","any":{"A":"test"},"logobject":{"Pub":"a","Tag":"z","priv":1}}`+"\n"; got != want {
		t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
	}
}

func TestFieldsArrayNil(t *testing.T) {
	out := &bytes.Buffer{}
	log := New(out)
	log.Log().
		Objects("objs", nil).
		ObjectsV("objs_v").
		Strs("strs", nil).
		StrsV("strs_v").
		Stringers("stringers", nil).
		StringersV("stringers_v").
		Errs("err", nil).
		Bools("bool", nil).
		Ints("int", nil).
		Ints8("int8", nil).
		Ints16("int16", nil).
		Ints32("int32", nil).
		Ints64("int64", nil).
		Uints("uint", nil).
		Uints8("uint8", nil).
		Uints16("uint16", nil).
		Uints32("uint32", nil).
		Uints64("uint64", nil).
		Floats32("float32", nil).
		Floats64("float64", nil).
		Durs("dur", nil).
		Times("time", nil).
		IPAddrs("ip", nil).
		IPPrefixes("pfx", nil).
		Msg("")
	if got, want := decodeIfBinaryToString(out.Bytes()), `{"objs":[],"objs_v":[],"strs":[],"strs_v":[],"stringers":[],"stringers_v":[],"err":[],"bool":[],"int":[],"int8":[],"int16":[],"int32":[],"int64":[],"uint":[],"uint8":[],"uint16":[],"uint32":[],"uint64":[],"float32":[],"float64":[],"dur":[],"time":[],"ip":[],"pfx":[]}`+"\n"; got != want {
		t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
	}
}

func TestFieldsArrayEmpty(t *testing.T) {
	out := &bytes.Buffer{}
	log := New(out)
	log.Log().
		Objects("objs", []LogObjectMarshaler{}).
		ObjectsV("objs_v").
		Strs("strs", []string{}).
		StrsV("strs_v").
		Stringers("stringers", []fmt.Stringer{}).
		StringersV("stringers_v").
		Errs("err", []error{}).
		Bools("bool", []bool{}).
		Ints("int", []int{}).
		Ints8("int8", []int8{}).
		Ints16("int16", []int16{}).
		Ints32("int32", []int32{}).
		Ints64("int64", []int64{}).
		Uints("uint", []uint{}).
		Uints8("uint8", []uint8{}).
		Uints16("uint16", []uint16{}).
		Uints32("uint32", []uint32{}).
		Uints64("uint64", []uint64{}).
		Floats32("float32", []float32{}).
		Floats64("float64", []float64{}).
		Durs("dur", []time.Duration{}).
		Times("time", []time.Time{}).
		IPAddrs("ip", []net.IP{}).
		IPPrefixes("pfx", []net.IPNet{}).
		Msg("")
	if got, want := decodeIfBinaryToString(out.Bytes()), `{"objs":[],"objs_v":[],"strs":[],"strs_v":[],"stringers":[],"stringers_v":[],"err":[],"bool":[],"int":[],"int8":[],"int16":[],"int32":[],"int64":[],"uint":[],"uint8":[],"uint16":[],"uint32":[],"uint64":[],"float32":[],"float64":[],"dur":[],"time":[],"ip":[],"pfx":[]}`+"\n"; got != want {
		t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
	}
}

func TestFieldsArraySingleElement(t *testing.T) {
	out := &bytes.Buffer{}
	log := New(out)
	log.Log().
		Objects("obj", []LogObjectMarshaler{fixtureObj{"a", "z", 1}}).
		ObjectsV("obj_v", fixtureObj{"A", "Z", 2}).
		Strs("str", []string{"foo"}).
		StrsV("str_v", "baz").
		Stringers("stringer", []fmt.Stringer{net.IP{127, 0, 0, 1}}).
		StringersV("stringer_v", net.IPv6loopback).
		Errs("err", []error{errors.New("some error")}).
		Bools("bool", []bool{true}).
		Ints("int", []int{1}).
		Ints8("int8", []int8{2}).
		Ints16("int16", []int16{3}).
		Ints32("int32", []int32{4}).
		Ints64("int64", []int64{5}).
		Uints("uint", []uint{6}).
		Uints8("uint8", []uint8{7}).
		Uints16("uint16", []uint16{8}).
		Uints32("uint32", []uint32{9}).
		Uints64("uint64", []uint64{10}).
		Floats32("float32", []float32{11}).
		Floats64("float64", []float64{12}).
		Durs("dur", []time.Duration{1 * time.Second}).
		Times("time", []time.Time{{}}).
		IPAddrs("ip", []net.IP{{192, 168, 0, 100}}).
		IPPrefixes("pfx", []net.IPNet{{IP: net.IP{192, 168, 0, 100}, Mask: net.CIDRMask(24, 32)}}).
		Msg("")
	if got, want := decodeIfBinaryToString(out.Bytes()), `{"obj":[{"Pub":"a","Tag":"z","priv":1}],"obj_v":[{"Pub":"A","Tag":"Z","priv":2}],"str":["foo"],"str_v":["baz"],"stringer":["127.0.0.1"],"stringer_v":["::1"],"err":["some error"],"bool":[true],"int":[1],"int8":[2],"int16":[3],"int32":[4],"int64":[5],"uint":[6],"uint8":[7],"uint16":[8],"uint32":[9],"uint64":[10],"float32":[11],"float64":[12],"dur":[1000],"time":["0001-01-01T00:00:00Z"],"ip":["192.168.0.100"],"pfx":["192.168.0.100/24"]}`+"\n"; got != want {
		t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
	}
}

func TestFieldsArrayMultipleElement(t *testing.T) {
	out := &bytes.Buffer{}
	log := New(out)
	log.Log().
		Objects("objs", []LogObjectMarshaler{fixtureObj{"a", "z", 1}, fixtureObj{"b", "y", 2}}).
		ObjectsV("objs_v", fixtureObj{"A", "Z", 3}, fixtureObj{"B", "Y", 4}).
		Strs("strs", []string{"foo", "bar"}).
		StrsV("strs_v", "baz", "fizz").
		Stringers("stringers", []fmt.Stringer{nil, net.IP{127, 0, 0, 1}}).
		StringersV("stringers_v", net.IPv4bcast, net.IPv6loopback).
		Errs("err", []error{errors.New("some error"), nil}).
		Bools("bool", []bool{true, false}).
		Ints("int", []int{1, 0}).
		Ints8("int8", []int8{2, 0}).
		Ints16("int16", []int16{3, 0}).
		Ints32("int32", []int32{4, 0}).
		Ints64("int64", []int64{5, 0}).
		Uints("uint", []uint{6, 0}).
		Uints8("uint8", []uint8{7, 0}).
		Uints16("uint16", []uint16{8, 0}).
		Uints32("uint32", []uint32{9, 0}).
		Uints64("uint64", []uint64{10, 0}).
		Floats32("float32", []float32{11, 0}).
		Floats64("float64", []float64{12, 0}).
		Durs("dur", []time.Duration{1 * time.Second, 0}).
		Times("time", []time.Time{{}, {}}).
		IPAddrs("ip", []net.IP{{192, 168, 0, 100}, {0x20, 0x01, 0x0d, 0xb8, 0x85, 0xa3, 0x00, 0x00, 0x00, 0x00, 0x8a, 0x2e, 0x03, 0x70, 0x73, 0x34}}).
		IPPrefixes("pfx", []net.IPNet{{IP: net.IP{192, 168, 0, 100}, Mask: net.CIDRMask(24, 32)}, {IP: net.IP{0x20, 0x01, 0x0d, 0xb8, 0x85, 0xa3, 0x00, 0x00, 0x00, 0x00, 0x8a, 0x2e, 0x03, 0x70, 0x73, 0x34}, Mask: net.CIDRMask(64, 128)}}).
		Msg("")
	if got, want := decodeIfBinaryToString(out.Bytes()), `{"objs":[{"Pub":"a","Tag":"z","priv":1},{"Pub":"b","Tag":"y","priv":2}],"objs_v":[{"Pub":"A","Tag":"Z","priv":3},{"Pub":"B","Tag":"Y","priv":4}],"strs":["foo","bar"],"strs_v":["baz","fizz"],"stringers":[null,"127.0.0.1"],"stringers_v":["255.255.255.255","::1"],"err":["some error",null],"bool":[true,false],"int":[1,0],"int8":[2,0],"int16":[3,0],"int32":[4,0],"int64":[5,0],"uint":[6,0],"uint8":[7,0],"uint16":[8,0],"uint32":[9,0],"uint64":[10,0],"float32":[11,0],"float64":[12,0],"dur":[1000,0],"time":["0001-01-01T00:00:00Z","0001-01-01T00:00:00Z"],"ip":["192.168.0.100","2001:db8:85a3::8a2e:370:7334"],"pfx":["192.168.0.100/24","2001:db8:85a3::8a2e:370:7334/64"]}`+"\n"; got != want {
		t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
	}
}

func TestFieldsDisabled(t *testing.T) {
	out := &bytes.Buffer{}
	log := New(out).Level(InfoLevel)
	now := time.Now()
	log.Debug().
		Objects("obj", []LogObjectMarshaler{fixtureObj{"a", "z", 1}}).
		ObjectsV("obj_v", fixtureObj{"A", "Z", 2}).
		Str("string", "foo").
		Strs("strs", []string{"foo"}).
		StrsV("strs_v", "baz").
		Stringer("stringer", net.IP{127, 0, 0, 1}).
		Stringers("stringers", []fmt.Stringer{net.IP{127, 0, 0, 1}}).
		StringersV("stringers_v", net.IPv6loopback).
		Bytes("bytes", []byte("bar")).
		Hex("hex", []byte{0x12, 0xef}).
		AnErr("some_err", nil).
		Err(errors.New("some error")).
		Func(func(e *Event) { e.Str("func", "func_output") }).
		Bool("bool", true).
		Int("int", 1).
		Int8("int8", 2).
		Int16("int16", 3).
		Int32("int32", 4).
		Int64("int64", 5).
		Uint("uint", 6).
		Uint8("uint8", 7).
		Uint16("uint16", 8).
		Uint32("uint32", 9).
		Uint64("uint64", 10).
		Float32("float32", 11).
		Float64("float64", 12).
		Dur("dur", 1*time.Second).
		Time("time", time.Time{}).
		TimeDiff("diff", now, now.Add(-10*time.Second)).
		IPAddr("ip", net.IP{127, 0, 0, 1}).
		IPPrefix("ip", net.IPNet{IP: net.IP{127, 0, 0, 1}, Mask: net.CIDRMask(24, 32)}).
		MACAddr("mac", net.HardwareAddr{0x00, 0x14, 0x22, 0x01, 0x23, 0x45}).
		Ctx(context.Background()).
		Any("any", struct{ A string }{"test"}).
		Interface("interface", fixtureObj{"a", "z", 1}).
		Err(errors.New("some error")).
		Msg("")
	if got, want := decodeIfBinaryToString(out.Bytes()), ""; got != want {
		t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
	}
}

func TestMsgf(t *testing.T) {
	out := &bytes.Buffer{}
	log := New(out)
	log.Log().Msgf("one %s %.1f %d %v", "two", 3.4, 5, errors.New("six"))
	if got, want := decodeIfBinaryToString(out.Bytes()), `{"message":"one two 3.4 5 six"}`+"\n"; got != want {
		t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
	}
}

func TestWithAndFieldsCombined(t *testing.T) {
	out := &bytes.Buffer{}
	log := New(out).With().Str("f1", "val").Str("f2", "val").Logger()
	log.Log().Str("f3", "val").Msg("")
	if got, want := decodeIfBinaryToString(out.Bytes()), `{"f1":"val","f2":"val","f3":"val"}`+"\n"; got != want {
		t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
	}
}

func TestLevel(t *testing.T) {
	t.Run("Disabled", func(t *testing.T) {
		out := &bytes.Buffer{}
		log := New(out).Level(Disabled)
		log.Info().Msg("test")
		if got, want := decodeIfBinaryToString(out.Bytes()), ""; got != want {
			t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
		}
	})

	t.Run("NoLevel/Disabled", func(t *testing.T) {
		out := &bytes.Buffer{}
		log := New(out).Level(Disabled)
		log.Log().Msg("test")
		if got, want := decodeIfBinaryToString(out.Bytes()), ""; got != want {
			t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
		}
	})

	t.Run("NoLevel/Info", func(t *testing.T) {
		out := &bytes.Buffer{}
		log := New(out).Level(InfoLevel)
		log.Log().Msg("test")
		if got, want := decodeIfBinaryToString(out.Bytes()), `{"message":"test"}`+"\n"; got != want {
			t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
		}
	})

	t.Run("NoLevel/Panic", func(t *testing.T) {
		out := &bytes.Buffer{}
		log := New(out).Level(PanicLevel)
		log.Log().Msg("test")
		if got, want := decodeIfBinaryToString(out.Bytes()), `{"message":"test"}`+"\n"; got != want {
			t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
		}
	})

	t.Run("NoLevel/WithLevel", func(t *testing.T) {
		out := &bytes.Buffer{}
		log := New(out).Level(InfoLevel)
		log.WithLevel(NoLevel).Msg("test")
		if got, want := decodeIfBinaryToString(out.Bytes()), `{"message":"test"}`+"\n"; got != want {
			t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
		}
	})

	t.Run("Info", func(t *testing.T) {
		out := &bytes.Buffer{}
		log := New(out).Level(InfoLevel)
		log.Info().Msg("test")
		if got, want := decodeIfBinaryToString(out.Bytes()), `{"level":"info","message":"test"}`+"\n"; got != want {
			t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
		}
	})
}

func TestGetLevel(t *testing.T) {
	levels := []Level{
		DebugLevel,
		InfoLevel,
		WarnLevel,
		ErrorLevel,
		FatalLevel,
		PanicLevel,
		NoLevel,
		Disabled,
	}
	for _, level := range levels {
		if got, want := New(nil).Level(level).GetLevel(), level; got != want {
			t.Errorf("GetLevel() = %v, want: %v", got, want)
		}
	}
}

func TestSampling(t *testing.T) {
	out := &bytes.Buffer{}
	log := New(out).Sample(&BasicSampler{N: 2})
	log.Log().Int("i", 1).Msg("")
	log.Log().Int("i", 2).Msg("")
	log.Log().Int("i", 3).Msg("")
	log.Log().Int("i", 4).Msg("")
	if got, want := decodeIfBinaryToString(out.Bytes()), "{\"i\":1}\n{\"i\":3}\n"; got != want {
		t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
	}
}

func TestDisableSampling(t *testing.T) {
	// Save original state
	original := samplingDisabled()
	defer DisableSampling(original)

	out := &bytes.Buffer{}
	log := New(out).Sample(&BasicSampler{N: 2})

	// Enable sampling disable
	DisableSampling(true)

	log.Log().Int("i", 1).Msg("")
	log.Log().Int("i", 2).Msg("")
	log.Log().Int("i", 3).Msg("")
	log.Log().Int("i", 4).Msg("")

	// All messages should be logged since sampling is disabled
	if got, want := decodeIfBinaryToString(out.Bytes()), "{\"i\":1}\n{\"i\":2}\n{\"i\":3}\n{\"i\":4}\n"; got != want {
		t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
	}
}

func TestDiscard(t *testing.T) {
	out := &bytes.Buffer{}
	log := New(out)
	log.Log().Discard().Str("a", "b").Msgf("one %s %.1f %d %v", "two", 3.4, 5, errors.New("six"))
	if got, want := decodeIfBinaryToString(out.Bytes()), ""; got != want {
		t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
	}

	// Double call
	log.Log().Discard().Discard().Str("a", "b").Msgf("one %s %.1f %d %v", "two", 3.4, 5, errors.New("six"))
	if got, want := decodeIfBinaryToString(out.Bytes()), ""; got != want {
		t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
	}
}

type levelWriter struct {
	ops []struct {
		l Level
		p string
	}
}

func (lw *levelWriter) Write(p []byte) (int, error) {
	return len(p), nil
}

func (lw *levelWriter) WriteLevel(lvl Level, p []byte) (int, error) {
	p = decodeIfBinaryToBytes(p)
	lw.ops = append(lw.ops, struct {
		l Level
		p string
	}{lvl, string(p)})
	return len(p), nil
}

func (lw *levelWriter) Close() error {
	return nil
}

func TestLevelWriter(t *testing.T) {
	lw := &levelWriter{
		ops: []struct {
			l Level
			p string
		}{},
	}

	// Allow extra-verbose logs.
	SetGlobalLevel(TraceLevel - 1)
	log := New(lw).Level(TraceLevel - 1)

	log.Trace().Msg("0")
	log.Debug().Msg("1")
	log.Info().Msg("2")
	log.Warn().Msg("3")
	log.Error().Msg("4")
	log.Log().Msg("nolevel-1")
	log.WithLevel(TraceLevel).Msg("5")
	log.WithLevel(DebugLevel).Msg("6")
	log.WithLevel(InfoLevel).Msg("7")
	log.WithLevel(WarnLevel).Msg("8")
	log.WithLevel(ErrorLevel).Msg("9")
	log.WithLevel(FatalLevel).Msg("10")
	log.WithLevel(PanicLevel).Msg("11")
	log.WithLevel(NoLevel).Msg("nolevel-2")
	log.WithLevel(-1).Msg("-1")                  // Same as TraceLevel
	log.WithLevel(-2).Msg("-2")                  // Will log
	log.WithLevel(-3).Msg("-3")                  // Will not log
	log.WithLevel(Disabled).Msg("Disabled")      // Will not log
	log.Err(nil).Msg("e-1")                      // Will log at InfoLevel
	log.Err(errors.New("some error")).Msg("e-2") // Will log at ErrorLevel

	want := []struct {
		l Level
		p string
	}{
		{TraceLevel, `{"level":"trace","message":"0"}` + "\n"},
		{DebugLevel, `{"level":"debug","message":"1"}` + "\n"},
		{InfoLevel, `{"level":"info","message":"2"}` + "\n"},
		{WarnLevel, `{"level":"warn","message":"3"}` + "\n"},
		{ErrorLevel, `{"level":"error","message":"4"}` + "\n"},
		{NoLevel, `{"message":"nolevel-1"}` + "\n"},
		{TraceLevel, `{"level":"trace","message":"5"}` + "\n"},
		{DebugLevel, `{"level":"debug","message":"6"}` + "\n"},
		{InfoLevel, `{"level":"info","message":"7"}` + "\n"},
		{WarnLevel, `{"level":"warn","message":"8"}` + "\n"},
		{ErrorLevel, `{"level":"error","message":"9"}` + "\n"},
		{FatalLevel, `{"level":"fatal","message":"10"}` + "\n"},
		{PanicLevel, `{"level":"panic","message":"11"}` + "\n"},
		{NoLevel, `{"message":"nolevel-2"}` + "\n"},
		{Level(-1), `{"level":"trace","message":"-1"}` + "\n"},
		{Level(-2), `{"level":"-2","message":"-2"}` + "\n"},
		{InfoLevel, `{"level":"info","message":"e-1"}` + "\n"},
		{ErrorLevel, `{"level":"error","error":"some error","message":"e-2"}` + "\n"},
	}
	if got := lw.ops; !reflect.DeepEqual(got, want) {
		t.Errorf("invalid ops:\ngot:\n%v\nwant:\n%v", got, want)
	}
}

func TestDisabledLevel(t *testing.T) {
	lw := &levelWriter{
		ops: []struct {
			l Level
			p string
		}{},
	}

	// Allow extra-verbose logs.
	SetGlobalLevel(TraceLevel - 1)
	log := New(lw).Level(Disabled)
	log.Error().Msg("0")                    // will not log
	log.Log().Msg("nolevel-1")              // will not log
	log.WithLevel(ErrorLevel).Msg("3")      // will not log
	log.WithLevel(NoLevel).Msg("nolevel-2") // will not log
	log.WithLevel(Disabled).Msg("Disabled") // will not log

	want := []struct {
		l Level
		p string
	}{}
	if got := lw.ops; !reflect.DeepEqual(got, want) {
		t.Errorf("invalid ops:\ngot:\n%v\nwant:\n%v", got, want)
	}
}

func TestPanicLevel(t *testing.T) {
	lw := &levelWriter{
		ops: []struct {
			l Level
			p string
		}{},
	}

	// Allow extra-verbose logs.
	SetGlobalLevel(TraceLevel - 1)
	log := New(lw).Level(TraceLevel - 1)

	// Catch the panic from log.Panic().Msg("1")
	defer func() {
		if r := recover(); r == nil {
			t.Error("expected panic from log.Panic()")
		}
	}()
	log.Panic().Msg("1")
	log.WithLevel(PanicLevel).Msg("2")

	want := []struct {
		l Level
		p string
	}{
		{PanicLevel, `{"level":"panic","message":"1"}` + "\n"},
		{PanicLevel, `{"level":"panic","message":"2"}` + "\n"},
	}
	if got := lw.ops; !reflect.DeepEqual(got, want) {
		t.Errorf("invalid ops:\ngot:\n%v\nwant:\n%v", got, want)
	}
}

func TestFatalLevel(t *testing.T) {
	lw := &levelWriter{
		ops: []struct {
			l Level
			p string
		}{},
	}

	// Allow extra-verbose logs.
	SetGlobalLevel(TraceLevel - 1)
	log := New(lw).Level(TraceLevel - 1)

	// Set FatalExitFunc to panic so we can catch it
	oldFatalExitFunc := FatalExitFunc
	FatalExitFunc = func() { panic("fatal exit") }
	defer func() { FatalExitFunc = oldFatalExitFunc }()

	// Catch the panic from log.Fatal().Msg("1")
	defer func() {
		if r := recover(); r == nil || r != "fatal exit" {
			t.Errorf("expected panic 'fatal exit' from log.Fatal(), got %v", r)
		}
	}()
	log.Fatal().Msg("1")
	log.WithLevel(FatalLevel).Msg("2")

	want := []struct {
		l Level
		p string
	}{
		{FatalLevel, `{"level":"fatal","message":"1"}` + "\n"},
		{FatalLevel, `{"level":"fatal","message":"2"}` + "\n"},
	}
	if got := lw.ops; !reflect.DeepEqual(got, want) {
		t.Errorf("invalid ops:\ngot:\n%v\nwant:\n%v", got, want)
	}
}

func TestFatalDisabled(t *testing.T) {
	out := &bytes.Buffer{}
	log := New(out).Level(PanicLevel) // Disable FatalLevel

	// Set FatalExitFunc to set a flag
	var fatalCalled bool
	oldFatalExitFunc := FatalExitFunc
	FatalExitFunc = func() { fatalCalled = true }
	defer func() { FatalExitFunc = oldFatalExitFunc }()

	// Call Fatal, which should be disabled, call done, and return nil
	e := log.Fatal()
	if e != nil {
		t.Error("Expected nil event when Fatal is disabled")
	}
	if !fatalCalled {
		t.Error("Expected FatalExitFunc to be called when Fatal is disabled")
	}
	if out.Len() > 0 {
		t.Errorf("Expected no output when Fatal is disabled, got: %s", out.String())
	}
}

func TestPanicDisabled(t *testing.T) {
	out := &bytes.Buffer{}
	log := New(out).Level(Disabled) // Disable all levels

	// Call Panic, which should be disabled, call done, and panic with ""
	defer func() {
		if r := recover(); r == nil || r != "" {
			t.Errorf("Expected panic with empty string when Panic is disabled, got %v", r)
		}
	}()
	e := log.Panic()
	if e != nil {
		t.Error("Expected nil event when Panic is disabled")
	}
	if out.Len() > 0 {
		t.Errorf("Expected no output when Panic is disabled, got: %s", out.String())
	}
}

func TestLoggerShouldWithNilWriter(t *testing.T) {
	// Create a logger with nil writer to test the should method's nil check
	log := Logger{w: nil, level: TraceLevel}

	e := log.Info()
	if e != nil {
		t.Error("Expected nil event when writer is nil")
	}
}

func TestContextTimestamp(t *testing.T) {
	TimestampFunc = func() time.Time {
		return time.Date(2001, time.February, 3, 4, 5, 6, 7, time.UTC)
	}
	defer func() {
		TimestampFunc = time.Now
	}()
	out := &bytes.Buffer{}
	log := New(out).With().Timestamp().Str("foo", "bar").Logger()
	log.Log().Msg("hello world")

	if got, want := decodeIfBinaryToString(out.Bytes()), `{"foo":"bar","time":"2001-02-03T04:05:06Z","message":"hello world"}`+"\n"; got != want {
		t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
	}
}

func TestEventTimestamp(t *testing.T) {
	TimestampFunc = func() time.Time {
		return time.Date(2001, time.February, 3, 4, 5, 6, 7, time.UTC)
	}
	defer func() {
		TimestampFunc = time.Now
	}()
	out := &bytes.Buffer{}
	log := New(out).With().Str("foo", "bar").Logger()
	log.Log().Timestamp().Msg("hello world")

	if got, want := decodeIfBinaryToString(out.Bytes()), `{"foo":"bar","time":"2001-02-03T04:05:06Z","message":"hello world"}`+"\n"; got != want {
		t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
	}
}

func TestOutputWithoutTimestamp(t *testing.T) {
	ignoredOut := &bytes.Buffer{}
	out := &bytes.Buffer{}
	log := New(ignoredOut).Output(out).With().Str("foo", "bar").Logger()
	log.Log().Msg("hello world")

	if got, want := decodeIfBinaryToString(out.Bytes()), `{"foo":"bar","message":"hello world"}`+"\n"; got != want {
		t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
	}
}

func TestOutputWithTimestamp(t *testing.T) {
	TimestampFunc = func() time.Time {
		return time.Date(2001, time.February, 3, 4, 5, 6, 7, time.UTC)
	}
	defer func() {
		TimestampFunc = time.Now
	}()
	ignoredOut := &bytes.Buffer{}
	out := &bytes.Buffer{}
	log := New(ignoredOut).Output(out).With().Timestamp().Str("foo", "bar").Logger()
	log.Log().Msg("hello world")

	if got, want := decodeIfBinaryToString(out.Bytes()), `{"foo":"bar","time":"2001-02-03T04:05:06Z","message":"hello world"}`+"\n"; got != want {
		t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
	}
}

func TestOutputWithContext(t *testing.T) {
	ignoredOut := &bytes.Buffer{}
	out := &bytes.Buffer{}
	log := New(ignoredOut).With().Str("foo", "bar").Logger().Output(out)
	log.Log().Msg("hello world")

	if got, want := decodeIfBinaryToString(out.Bytes()), `{"foo":"bar","message":"hello world"}`+"\n"; got != want {
		t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
	}
}

func TestCallerMarshalFunc(t *testing.T) {
	out := &bytes.Buffer{}
	log := New(out)

	var pc uintptr
	var file string
	var line int
	// test default behaviour this is really brittle due to the line numbers
	// actually mattering for validation
	pc, file, line, _ = runtime.Caller(0)
	caller := fmt.Sprintf("%s:%d", file, line+2)
	log.Log().Caller().Msg("msg")
	if got, want := decodeIfBinaryToString(out.Bytes()), `{"caller":"`+caller+`","message":"msg"}`+"\n"; got != want {
		t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
	}
	out.Reset()

	// test custom behavior. In this case we'll take just the last directory
	origCallerMarshalFunc := CallerMarshalFunc
	defer func() { CallerMarshalFunc = origCallerMarshalFunc }()
	CallerMarshalFunc = func(pc uintptr, file string, line int) string {
		parts := strings.Split(file, "/")
		if len(parts) > 1 {
			return strings.Join(parts[len(parts)-2:], "/") + ":" + strconv.Itoa(line)
		}

		return runtime.FuncForPC(pc).Name() + ":" + file + ":" + strconv.Itoa(line)
	}
	pc, file, line, _ = runtime.Caller(0)
	caller = CallerMarshalFunc(pc, file, line+2)
	log.Log().Caller().Msg("msg")
	if got, want := decodeIfBinaryToString(out.Bytes()), `{"caller":"`+caller+`","message":"msg"}`+"\n"; got != want {
		t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
	}
}

func TestLevelFieldMarshalFunc(t *testing.T) {
	origLevelFieldMarshalFunc := LevelFieldMarshalFunc
	LevelFieldMarshalFunc = func(l Level) string {
		return strings.ToUpper(l.String())
	}
	defer func() {
		LevelFieldMarshalFunc = origLevelFieldMarshalFunc
	}()
	out := &bytes.Buffer{}
	log := New(out)

	log.Debug().Msg("test")
	if got, want := decodeIfBinaryToString(out.Bytes()), `{"level":"DEBUG","message":"test"}`+"\n"; got != want {
		t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
	}
	out.Reset()

	log.Info().Msg("test")
	if got, want := decodeIfBinaryToString(out.Bytes()), `{"level":"INFO","message":"test"}`+"\n"; got != want {
		t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
	}
	out.Reset()

	log.Warn().Msg("test")
	if got, want := decodeIfBinaryToString(out.Bytes()), `{"level":"WARN","message":"test"}`+"\n"; got != want {
		t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
	}
	out.Reset()

	log.Error().Msg("test")
	if got, want := decodeIfBinaryToString(out.Bytes()), `{"level":"ERROR","message":"test"}`+"\n"; got != want {
		t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
	}
	out.Reset()
}

type errWriter struct {
	error
}

func (w errWriter) Write(p []byte) (n int, err error) {
	return 0, w.error
}

func TestErrorHandler(t *testing.T) {
	var got error
	want := errors.New("write error")
	ErrorHandler = func(err error) {
		got = err
	}
	log := New(errWriter{want})
	log.Log().Msg("test")
	if got != want {
		t.Errorf("ErrorHandler err = %#v, want %#v", got, want)
	}
}

func TestUpdateEmptyContext(t *testing.T) {
	var buf bytes.Buffer
	log := New(&buf)

	log.UpdateContext(func(c Context) Context {
		return c.Str("foo", "bar")
	})
	log.Info().Msg("no panic")

	want := `{"level":"info","foo":"bar","message":"no panic"}` + "\n"

	if got := decodeIfBinaryToString(buf.Bytes()); got != want {
		t.Errorf("invalid log output:\ngot:  %q\nwant: %q", got, want)
	}
}

func TestUpdateContextOnDisabledLogger(t *testing.T) {
	var buf bytes.Buffer
	log := disabledLogger

	log.UpdateContext(func(c Context) Context {
		return c.Str("foo", "bar")
	})
	log.Info().Msg("no panic")

	want := ""

	if got := decodeIfBinaryToString(buf.Bytes()); got != want {
		t.Errorf("invalid log output:\ngot:  %q\nwant: %q", got, want)
	}
}

func TestUpdateContextOnNopLogger(t *testing.T) {
	// Nop() creates a new disabled logger that is a different pointer than
	// the package-level disabledLogger. UpdateContext should still treat it
	// as disabled and skip the update function. See issue #643.
	log := Nop()

	called := false
	log.UpdateContext(func(c Context) Context {
		called = true
		return c.Str("foo", "bar")
	})

	if called {
		t.Error("UpdateContext should not call update func on a Nop logger")
	}
}

func TestUpdateContextOnZeroValueLogger(t *testing.T) {
	// A zero-value Logger has a nil writer and should be treated as
	// disabled by UpdateContext. See issue #643.
	var log Logger

	called := false
	log.UpdateContext(func(c Context) Context {
		called = true
		return c.Str("foo", "bar")
	})

	if called {
		t.Error("UpdateContext should not call update func on a zero-value logger")
	}
}

func TestLevel_String(t *testing.T) {
	tests := []struct {
		name string
		l    Level
		want string
	}{
		{"trace", TraceLevel, "trace"},
		{"debug", DebugLevel, "debug"},
		{"info", InfoLevel, "info"},
		{"warn", WarnLevel, "warn"},
		{"error", ErrorLevel, "error"},
		{"fatal", FatalLevel, "fatal"},
		{"panic", PanicLevel, "panic"},
		{"disabled", Disabled, "disabled"},
		{"nolevel", NoLevel, ""},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := tt.l.String(); got != tt.want {
				t.Errorf("String() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestLevel_MarshalText(t *testing.T) {
	tests := []struct {
		name string
		l    Level
		want string
	}{
		{"trace", TraceLevel, "trace"},
		{"debug", DebugLevel, "debug"},
		{"info", InfoLevel, "info"},
		{"warn", WarnLevel, "warn"},
		{"error", ErrorLevel, "error"},
		{"fatal", FatalLevel, "fatal"},
		{"panic", PanicLevel, "panic"},
		{"disabled", Disabled, "disabled"},
		{"nolevel", NoLevel, ""},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got, err := tt.l.MarshalText(); err != nil {
				t.Errorf("MarshalText couldn't marshal: %v", tt.l)
			} else if string(got) != tt.want {
				t.Errorf("String() = %v, want %v", string(got), tt.want)
			}
		})
	}
}

func TestParseLevel(t *testing.T) {
	type args struct {
		levelStr string
	}
	tests := []struct {
		name    string
		args    args
		want    Level
		wantErr bool
	}{
		{"trace", args{"trace"}, TraceLevel, false},
		{"debug", args{"debug"}, DebugLevel, false},
		{"info", args{"info"}, InfoLevel, false},
		{"warn", args{"warn"}, WarnLevel, false},
		{"error", args{"error"}, ErrorLevel, false},
		{"fatal", args{"fatal"}, FatalLevel, false},
		{"panic", args{"panic"}, PanicLevel, false},
		{"disabled", args{"disabled"}, Disabled, false},
		{"nolevel", args{""}, NoLevel, false},
		{"-1", args{"-1"}, TraceLevel, false},
		{"-2", args{"-2"}, Level(-2), false},
		{"-3", args{"-3"}, Level(-3), false},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, err := ParseLevel(tt.args.levelStr)
			if (err != nil) != tt.wantErr {
				t.Errorf("ParseLevel() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if got != tt.want {
				t.Errorf("ParseLevel() got = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestUnmarshalTextLevel(t *testing.T) {
	type args struct {
		levelStr string
	}
	tests := []struct {
		name    string
		args    args
		want    Level
		wantErr bool
	}{
		{"trace", args{"trace"}, TraceLevel, false},
		{"debug", args{"debug"}, DebugLevel, false},
		{"info", args{"info"}, InfoLevel, false},
		{"warn", args{"warn"}, WarnLevel, false},
		{"error", args{"error"}, ErrorLevel, false},
		{"fatal", args{"fatal"}, FatalLevel, false},
		{"panic", args{"panic"}, PanicLevel, false},
		{"disabled", args{"disabled"}, Disabled, false},
		{"nolevel", args{""}, NoLevel, false},
		{"-1", args{"-1"}, TraceLevel, false},
		{"-2", args{"-2"}, Level(-2), false},
		{"-3", args{"-3"}, Level(-3), false},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			var l Level
			err := l.UnmarshalText([]byte(tt.args.levelStr))
			if (err != nil) != tt.wantErr {
				t.Errorf("UnmarshalText() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if l != tt.want {
				t.Errorf("UnmarshalText() got = %v, want %v", l, tt.want)
			}
		})
	}
}

func TestUnmarshalTextLevelNil(t *testing.T) {
	var l *Level
	err := l.UnmarshalText([]byte("info"))
	if err == nil || err.Error() != "can't unmarshal a nil *Level" {
		t.Errorf("UnmarshalText() on nil *Level error = %v, want 'can't unmarshal a nil *Level'", err)
	}
}

func TestHTMLNoEscaping(t *testing.T) {
	out := &bytes.Buffer{}
	log := New(out)
	log.Log().Interface("head", "<test>").Send()
	if got, want := decodeIfBinaryToString(out.Bytes()), `{"head":"<test>"}`+"\n"; got != want {
		t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
	}
}