Repository navigation
Expand file tree
/
Copy pathtraversal_test.go
More file actions
97 lines (84 loc) · 2.04 KB
/
Copy pathtraversal_test.go
File metadata and controls
97 lines (84 loc) · 2.04 KB
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
package btf
import (
"fmt"
"testing"
qt "github.com/frankban/quicktest"
)
func TestPostorderTraversal(t *testing.T) {
ptr := newCyclicalType(2).(*Pointer)
cst := ptr.Target.(*Const)
str := cst.Type.(*Struct)
t.Logf("%3v", ptr)
pending := []Type{str, cst, ptr}
iter := postorderTraversal(ptr, nil)
for iter.Next() {
qt.Assert(t, iter.Type, qt.Equals, pending[0])
pending = pending[1:]
}
qt.Assert(t, pending, qt.HasLen, 0)
i := &Int{Name: "foo"}
// i appears twice at the same nesting depth.
arr := &Array{Index: i, Type: i}
seen := make(map[Type]bool)
iter = postorderTraversal(arr, nil)
for iter.Next() {
qt.Assert(t, seen[iter.Type], qt.IsFalse)
seen[iter.Type] = true
}
qt.Assert(t, seen[arr], qt.IsTrue)
qt.Assert(t, seen[i], qt.IsTrue)
}
func TestPostorderTraversalVmlinux(t *testing.T) {
spec := vmlinuxTestdataSpec(t)
typ, err := spec.AnyTypeByName("gov_update_cpu_data")
if err != nil {
t.Fatal(err)
}
for _, typ := range []Type{typ} {
t.Run(fmt.Sprintf("%s", typ), func(t *testing.T) {
seen := make(map[Type]bool)
var last Type
iter := postorderTraversal(typ, nil)
for iter.Next() {
if seen[iter.Type] {
t.Fatalf("%s visited twice", iter.Type)
}
seen[iter.Type] = true
last = iter.Type
}
if last != typ {
t.Fatalf("Expected %s got %s as last type", typ, last)
}
walkType(typ, func(child *Type) {
qt.Check(t, seen[*child], qt.IsTrue, qt.Commentf("missing child %s", *child))
})
})
}
}
func BenchmarkPostorderTraversal(b *testing.B) {
spec := vmlinuxTestdataSpec(b)
var fn *Func
err := spec.TypeByName("gov_update_cpu_data", &fn)
if err != nil {
b.Fatal(err)
}
for _, test := range []struct {
name string
typ Type
}{
{"single type", &Int{}},
{"cycle(1)", newCyclicalType(1)},
{"cycle(10)", newCyclicalType(10)},
{"gov_update_cpu_data", fn},
} {
b.Logf("%10v", test.typ)
b.Run(test.name, func(b *testing.B) {
b.ReportAllocs()
for i := 0; i < b.N; i++ {
iter := postorderTraversal(test.typ, nil)
for iter.Next() {
}
}
})
}
}