92 lines
2.7 KiB
Go
92 lines
2.7 KiB
Go
package main
|
|
|
|
import (
|
|
"fmt"
|
|
"sort"
|
|
"testing"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
)
|
|
|
|
func TestNode_WeighingTreeAllAlgo(t *testing.T) {
|
|
for name,tt := range map[string]TestTree{
|
|
"Ordinary VFS tree": getTestTree(3, 3, nil),
|
|
"VFS in the form of a pathological tree":getTestTree(1, 7, nil),
|
|
}{
|
|
t.Run(name,func(t *testing.T) {
|
|
t.Run("WeightingTreeWithRecursion", func(t *testing.T) {
|
|
weightTreeWithRecursion := tt.Tree.WeightingTreeWithRecursion(nil)
|
|
printExpectations(tt.Weights, weightTreeWithRecursion)
|
|
assert.EqualValues(t, tt.Weights, weightTreeWithRecursion)
|
|
})
|
|
t.Run("WeightingTreeWithStack", func(t *testing.T) {
|
|
weightTreeWithStack := tt.Tree.WeightingTreeWithStack(nil)
|
|
printExpectations(tt.Weights, weightTreeWithStack)
|
|
assert.EqualValues(t, tt.Weights, weightTreeWithStack)
|
|
})
|
|
t.Run("WeightingTreeWithDLL", func(t *testing.T) {
|
|
weightTreeWithDLL := tt.Tree.WeightingTreeWithDLL(nil)
|
|
printExpectations(tt.Weights, weightTreeWithDLL)
|
|
assert.EqualValues(t, tt.Weights, weightTreeWithDLL)
|
|
})
|
|
})
|
|
}
|
|
}
|
|
|
|
func Benchmark(b *testing.B) {
|
|
b.StopTimer()
|
|
b.ResetTimer()
|
|
for name,tt := range map[string]struct{
|
|
branches int
|
|
depth int
|
|
}{
|
|
"Small tree (85 nodes)":{4, 4}, // 85 nodes,
|
|
"Wide tree (265K nodes)": {515, 3}, // 265'741 nodes,
|
|
"Deep tree (265K nodes)": {3, 12}, // 265'720 nodes,
|
|
"Huge tree (2,44M nodes)": {5, 10}, // 2'441'406 nodes,
|
|
"Pathological tree (10K nodes)": {1, 10000}, // 10'000 nodes,
|
|
}{
|
|
b.Run(name, func(b *testing.B) {
|
|
tree := getTestTree(tt.branches, tt.depth, nil)
|
|
b.Cleanup(func() {
|
|
tree = TestTree{nil, nil}
|
|
})
|
|
b.Run("Weighing with recursion", func(b *testing.B) {
|
|
for i := 0; i < b.N; i++ {
|
|
b.StartTimer()
|
|
assert.EqualValues(b, tree.Weights, tree.Tree.WeightingTreeWithRecursion(nil))
|
|
b.StopTimer()
|
|
}
|
|
})
|
|
b.Run("Weighting with stack", func(b *testing.B) {
|
|
for i := 0; i < b.N; i++ {
|
|
b.StartTimer()
|
|
assert.EqualValues(b, tree.Weights, tree.Tree.WeightingTreeWithStack(nil))
|
|
b.StopTimer()
|
|
}
|
|
})
|
|
b.Run("Weighting with DLL", func(b *testing.B) {
|
|
for i := 0; i < b.N; i++ {
|
|
b.StartTimer()
|
|
assert.EqualValues(b, tree.Weights, tree.Tree.WeightingTreeWithDLL(nil))
|
|
b.StopTimer()
|
|
}
|
|
})
|
|
})
|
|
|
|
}
|
|
}
|
|
|
|
func printExpectations(expected, actual map[string]*WeightedNode) {
|
|
var expectedSlice, actualSlice []int
|
|
for _,v := range expected {
|
|
expectedSlice = append(expectedSlice, int(v.weight))
|
|
}
|
|
sort.Sort(sort.Reverse(sort.IntSlice(expectedSlice)))
|
|
for _,v := range actual {
|
|
actualSlice = append(actualSlice, int(v.weight))
|
|
}
|
|
sort.Sort(sort.Reverse(sort.IntSlice(actualSlice)))
|
|
fmt.Printf("expected: %+v\n", expectedSlice)
|
|
fmt.Printf("actual : %+v\n", actualSlice)
|
|
} |