1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
|
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
package log_test
import (
"testing"
"time"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"go.opentelemetry.io/otel/log"
)
var y2k = time.Date(2000, time.January, 1, 0, 0, 0, 0, time.UTC)
func TestRecordTimestamp(t *testing.T) {
var r log.Record
r.SetTimestamp(y2k)
assert.Equal(t, y2k, r.Timestamp())
}
func TestRecordObservedTimestamp(t *testing.T) {
var r log.Record
r.SetObservedTimestamp(y2k)
assert.Equal(t, y2k, r.ObservedTimestamp())
}
func TestRecordSeverity(t *testing.T) {
var r log.Record
r.SetSeverity(log.SeverityInfo)
assert.Equal(t, log.SeverityInfo, r.Severity())
}
func TestRecordSeverityText(t *testing.T) {
const text = "testing text"
var r log.Record
r.SetSeverityText(text)
assert.Equal(t, text, r.SeverityText())
}
func TestRecordBody(t *testing.T) {
body := log.StringValue("testing body value")
var r log.Record
r.SetBody(body)
assert.Equal(t, body, r.Body())
}
func TestRecordAttributes(t *testing.T) {
attrs := []log.KeyValue{
log.String("k1", "str"),
log.Float64("k2", 1.0),
log.Int("k3", 2),
log.Bool("k4", true),
log.Bytes("k5", []byte{1}),
log.Slice("k6", log.IntValue(3)),
log.Map("k7", log.Bool("sub1", true)),
log.String("k8", "str"),
log.Float64("k9", 1.0),
log.Int("k10", 2),
log.Bool("k11", true),
log.Bytes("k12", []byte{1}),
log.Slice("k13", log.IntValue(3)),
log.Map("k14", log.Bool("sub1", true)),
{}, // Empty.
}
var r log.Record
r.AddAttributes(attrs...)
require.Equal(t, len(attrs), r.AttributesLen())
t.Run("Correctness", func(t *testing.T) {
var i int
r.WalkAttributes(func(kv log.KeyValue) bool {
assert.Equal(t, attrs[i], kv)
i++
return true
})
})
t.Run("WalkAttributes/Filtering", func(t *testing.T) {
for i := 1; i <= len(attrs); i++ {
var j int
r.WalkAttributes(func(log.KeyValue) bool {
j++
return j < i
})
assert.Equal(t, i, j, "number of attributes walked incorrect")
}
})
}
func TestRecordAllocationLimits(t *testing.T) {
const runs = 5
// Assign testing results to external scope so the compiler doesn't
// optimize away the testing statements.
var (
tStamp time.Time
sev log.Severity
text string
body log.Value
n int
attr log.KeyValue
)
assert.Equal(t, 0.0, testing.AllocsPerRun(runs, func() {
var r log.Record
r.SetTimestamp(y2k)
tStamp = r.Timestamp()
}), "Timestamp")
assert.Equal(t, 0.0, testing.AllocsPerRun(runs, func() {
var r log.Record
r.SetObservedTimestamp(y2k)
tStamp = r.ObservedTimestamp()
}), "ObservedTimestamp")
assert.Equal(t, 0.0, testing.AllocsPerRun(runs, func() {
var r log.Record
r.SetSeverity(log.SeverityDebug)
sev = r.Severity()
}), "Severity")
assert.Equal(t, 0.0, testing.AllocsPerRun(runs, func() {
var r log.Record
r.SetSeverityText("severity text")
text = r.SeverityText()
}), "SeverityText")
bodyVal := log.BoolValue(true)
assert.Equal(t, 0.0, testing.AllocsPerRun(runs, func() {
var r log.Record
r.SetBody(bodyVal)
body = r.Body()
}), "Body")
attrVal := []log.KeyValue{log.Bool("k", true), log.Int("i", 1)}
assert.Equal(t, 0.0, testing.AllocsPerRun(runs, func() {
var r log.Record
r.AddAttributes(attrVal...)
n = r.AttributesLen()
r.WalkAttributes(func(kv log.KeyValue) bool {
attr = kv
return true
})
}), "Attributes")
// Convince the linter these values are used.
_, _, _, _, _, _ = tStamp, sev, text, body, n, attr
}
|
