rs-zerolog/internal/cbor/time_test.go

package cbor

import (
	"bytes"
	"encoding/hex"
	"fmt"
	"math"
	"testing"
	"time"

	"github.com/rs/zerolog/internal"
)

func TestAppendTimeNow(t *testing.T) {
	tm := time.Now()
	s := enc.AppendTime([]byte{}, tm, "unused")
	got := string(s)

	tm1 := float64(tm.Unix()) + float64(tm.Nanosecond())*1e-9
	tm2 := math.Float64bits(tm1)
	var tm3 [8]byte
	for i := uint(0); i < 8; i++ {
		tm3[i] = byte(tm2 >> ((8 - i - 1) * 8))
	}
	want := append([]byte{0xc1, 0xfb}, tm3[:]...)
	if got != string(want) {
		t.Errorf("Appendtime(%s)=0x%s, want: 0x%s",
			"time.Now()", hex.EncodeToString(s),
			hex.EncodeToString(want))
	}
}

func TestAppendTimePastPresentInteger(t *testing.T) {
	for _, tt := range internal.TimeIntegerTestcases {
		tin, err := time.Parse(time.RFC3339, tt.Txt)
		if err != nil {
			fmt.Println("Cannot parse input", tt.Txt, ".. Skipping!", err)
			continue
		}
		b := enc.AppendTime([]byte{}, tin, "unused")
		if got, want := string(b), tt.Binary; got != want {
			t.Errorf("appendString(%s) = 0x%s, want 0x%s", tt.Txt,
				hex.EncodeToString(b),
				hex.EncodeToString([]byte(want)))
		}
	}
}

func TestAppendTimePastPresentFloat(t *testing.T) {
	const timeFloatFmt = "2006-01-02T15:04:05.999999-07:00"
	for _, tt := range internal.TimeFloatTestcases {
		tin, err := time.Parse(timeFloatFmt, tt.RfcStr)
		if err != nil {
			fmt.Println("Cannot parse input", tt.RfcStr, ".. Skipping!")
			continue
		}
		b := enc.AppendTime([]byte{}, tin, "unused")
		if got, want := string(b), tt.Out; got != want {
			t.Errorf("appendString(%s) = 0x%s, want 0x%s", tt.RfcStr,
				hex.EncodeToString(b),
				hex.EncodeToString([]byte(want)))
		}
	}
}
func TestAppendTimes(t *testing.T) {
	const timeFloatFmt = "2006-01-02T15:04:05.999999-07:00"
	array := make([]time.Time, len(internal.TimeFloatTestcases))
	want := make([]byte, 0)
	want = append(want, 0x82) // start small array
	for i, tt := range internal.TimeFloatTestcases {
		array[i], _ = time.Parse(timeFloatFmt, tt.RfcStr)
		want = append(want, []byte(tt.Out)...)
	}

	got := enc.AppendTimes([]byte{}, array, "unused")
	if !bytes.Equal(got, want) {
		t.Errorf("AppendTimes(%v)\ngot:  0x%s\nwant: 0x%s",
			array, hex.EncodeToString(got),
			hex.EncodeToString(want))
	}

	// now empty array case
	array = make([]time.Time, 0)
	want = make([]byte, 0)
	want = append(want, 0x9f) // start and end array
	want = append(want, 0xff) // for empty array
	got = enc.AppendTimes([]byte{}, array, "unused")
	if !bytes.Equal(got, want) {
		t.Errorf("AppendTimes(%v)\ngot:  0x%s\nwant: 0x%s",
			array, hex.EncodeToString(got),
			hex.EncodeToString(want))
	}

	// now large array case
	testtime, _ := time.Parse(timeFloatFmt, internal.TimeFloatTestcases[0].RfcStr)
	outbytes := internal.TimeFloatTestcases[0].Out
	array = make([]time.Time, 24)
	want = make([]byte, 0)
	want = append(want, 0x98) // start a large array
	want = append(want, 0x18) // of length 24
	for i := 0; i < len(array); i++ {
		array[i] = testtime
		want = append(want, []byte(outbytes)...)
	}
	got = enc.AppendTimes([]byte{}, array, "unused")
	if !bytes.Equal(got, want) {
		t.Errorf("AppendTimes(%v)\ngot:  0x%s\nwant: 0x%s",
			array,
			hex.EncodeToString(got),
			hex.EncodeToString(want))
	}
}

func TestAppendDurationFloat(t *testing.T) {
	for _, tt := range internal.DurTestcases {
		dur := tt.Duration
		want := []byte{}
		want = append(want, []byte(tt.FloatOut)...)
		got := enc.AppendDuration([]byte{}, dur, time.Microsecond, false, -1)
		if !bytes.Equal(got, want) {
			t.Errorf("AppendDuration(%v)=\ngot:  0x%s\nwant: 0x%s",
				dur,
				hex.EncodeToString(got),
				hex.EncodeToString(want))
		}
	}
}
func TestAppendDurationInteger(t *testing.T) {
	for _, tt := range internal.DurTestcases {
		dur := tt.Duration
		want := []byte{}
		want = append(want, []byte(tt.IntegerOut)...)
		got := enc.AppendDuration([]byte{}, dur, time.Microsecond, true, -1)
		if !bytes.Equal(got, want) {
			t.Errorf("AppendDuration(%v)=\ngot:  0x%s\nwant: 0x%s",
				dur,
				hex.EncodeToString(got),
				hex.EncodeToString(want))
		}
	}
}
func TestAppendDurations(t *testing.T) {
	array := make([]time.Duration, len(internal.DurTestcases))
	want := make([]byte, 0)
	want = append(want, 0x83) // start 3 element array
	for i, tt := range internal.DurTestcases {
		array[i] = tt.Duration
		want = append(want, []byte(tt.FloatOut)...)
	}

	got := enc.AppendDurations([]byte{}, array, time.Microsecond, false, -1)
	if !bytes.Equal(got, want) {
		t.Errorf("AppendDurations(%v)\ngot:  0x%s\nwant: 0x%s",
			array, hex.EncodeToString(got),
			hex.EncodeToString(want))
	}

	// now empty array case
	array = make([]time.Duration, 0)
	want = make([]byte, 0)
	want = append(want, 0x9f) // start and end array
	want = append(want, 0xff) // for empty array
	got = enc.AppendDurations([]byte{}, array, time.Microsecond, false, -1)
	if !bytes.Equal(got, want) {
		t.Errorf("AppendDurations(%v)\ngot:  0x%s\nwant: 0x%s",
			array, hex.EncodeToString(got),
			hex.EncodeToString(want))
	}

	// now large array case
	testtime := internal.DurTestcases[0].Duration
	outbytes := internal.DurTestcases[0].FloatOut
	array = make([]time.Duration, 24)
	want = make([]byte, 0)
	want = append(want, 0x98) // start a large array
	want = append(want, 0x18) // of length 24
	for i := 0; i < len(array); i++ {
		array[i] = testtime
		want = append(want, []byte(outbytes)...)
	}
	got = enc.AppendDurations([]byte{}, array, time.Microsecond, false, -1)
	if !bytes.Equal(got, want) {
		t.Errorf("AppendDurations(%v)\ngot:  0x%s\nwant: 0x%s",
			array,
			hex.EncodeToString(got),
			hex.EncodeToString(want))
	}
}

func BenchmarkAppendTime(b *testing.B) {
	tests := map[string]string{
		"Integer": "Feb 3, 2013 at 7:54pm (PST)",
		"Float":   "2006-01-02T15:04:05.999999-08:00",
	}
	const timeFloatFmt = "2006-01-02T15:04:05.999999-07:00"

	for name, str := range tests {
		t, err := time.Parse(time.RFC3339, str)
		if err != nil {
			t, _ = time.Parse(timeFloatFmt, str)
		}
		b.Run(name, func(b *testing.B) {
			buf := make([]byte, 0, 100)
			for i := 0; i < b.N; i++ {
				_ = enc.AppendTime(buf, t, "unused")
			}
		})
	}
}