Debian Codegraph @

attribute/iterator_test.go

raw
1 // Copyright The OpenTelemetry Authors
2 // SPDX-License-Identifier: Apache-2.0
3
4 package attribute_test
5
6 import (
7 "fmt"
8 "testing"
9
10 "github.com/stretchr/testify/require"
11
12 "go.opentelemetry.io/otel/attribute"
13 )
14
15 func TestIterator(t *testing.T) {
16 one := attribute.String("one", "1")
17 two := attribute.Int("two", 2)
18 lbl := attribute.NewSet(one, two)
19 iter := lbl.Iter()
20 require.Equal(t, 2, iter.Len())
21
22 require.True(t, iter.Next())
23 require.Equal(t, one, iter.Attribute())
24 idx, attr := iter.IndexedAttribute()
25 require.Equal(t, 0, idx)
26 require.Equal(t, one, attr)
27 require.Equal(t, 2, iter.Len())
28
29 require.True(t, iter.Next())
30 require.Equal(t, two, iter.Attribute())
31 idx, attr = iter.IndexedAttribute()
32 require.Equal(t, 1, idx)
33 require.Equal(t, two, attr)
34 require.Equal(t, 2, iter.Len())
35
36 require.False(t, iter.Next())
37 require.Equal(t, 2, iter.Len())
38 }
39
40 func TestEmptyIterator(t *testing.T) {
41 lbl := attribute.NewSet()
42 iter := lbl.Iter()
43 require.Equal(t, 0, iter.Len())
44 require.False(t, iter.Next())
45 }
46
47 func TestMergedIterator(t *testing.T) {
48 type inputs struct {
49 name string
50 keys1 []string
51 keys2 []string
52 expect []string
53 }
54
55 makeAttributes := func(keys []string, num int) (result []attribute.KeyValue) {
56 for _, k := range keys {
57 result = append(result, attribute.Int(k, num))
58 }
59 return result
60 }
61
62 for _, input := range []inputs{
63 {
64 name: "one overlap",
65 keys1: []string{"A", "B"},
66 keys2: []string{"B", "C"},
67 expect: []string{"A/1", "B/1", "C/2"},
68 },
69 {
70 name: "reversed one overlap",
71 keys1: []string{"B", "A"},
72 keys2: []string{"C", "B"},
73 expect: []string{"A/1", "B/1", "C/2"},
74 },
75 {
76 name: "one empty",
77 keys1: nil,
78 keys2: []string{"C", "B"},
79 expect: []string{"B/2", "C/2"},
80 },
81 {
82 name: "two empty",
83 keys1: []string{"C", "B"},
84 keys2: nil,
85 expect: []string{"B/1", "C/1"},
86 },
87 {
88 name: "no overlap both",
89 keys1: []string{"C"},
90 keys2: []string{"B"},
91 expect: []string{"B/2", "C/1"},
92 },
93 {
94 name: "one empty single two",
95 keys1: nil,
96 keys2: []string{"B"},
97 expect: []string{"B/2"},
98 },
99 {
100 name: "two empty single one",
101 keys1: []string{"A"},
102 keys2: nil,
103 expect: []string{"A/1"},
104 },
105 {
106 name: "all empty",
107 keys1: nil,
108 keys2: nil,
109 expect: nil,
110 },
111 {
112 name: "full overlap",
113 keys1: []string{"A", "B", "C", "D"},
114 keys2: []string{"A", "B", "C", "D"},
115 expect: []string{"A/1", "B/1", "C/1", "D/1"},
116 },
117 } {
118 t.Run(input.name, func(t *testing.T) {
119 attr1 := makeAttributes(input.keys1, 1)
120 attr2 := makeAttributes(input.keys2, 2)
121
122 set1 := attribute.NewSet(attr1...)
123 set2 := attribute.NewSet(attr2...)
124
125 merge := attribute.NewMergeIterator(&set1, &set2)
126
127 var result []string
128
129 for merge.Next() {
130 attr := merge.Attribute()
131 result = append(result, fmt.Sprint(attr.Key, "/", attr.Value.Emit()))
132 }
133
134 require.Equal(t, input.expect, result)
135 })
136 }
137 }