| 1 | // SPDX-License-Identifier: GPL-3.0-or-later |
| 2 | |
| 3 | package oldmetrix |
| 4 | |
| 5 | import ( |
| 6 | "testing" |
| 7 | |
| 8 | "github.com/stretchr/testify/assert" |
| 9 | ) |
| 10 | |
| 11 | func TestLinearBuckets(t *testing.T) { |
| 12 | buckets := LinearBuckets(0, 1, 10) |
| 13 | assert.Len(t, buckets, 10) |
| 14 | assert.EqualValues(t, 0, buckets[0]) |
| 15 | assert.EqualValues(t, 5.0, buckets[5]) |
| 16 | assert.EqualValues(t, 9.0, buckets[9]) |
| 17 | |
| 18 | assert.Panics(t, func() { |
| 19 | LinearBuckets(0, 1, 0) |
| 20 | }) |
| 21 | } |
| 22 | |
| 23 | func TestExponentialBuckets(t *testing.T) { |
| 24 | buckets := ExponentialBuckets(1, 2, 10) |
| 25 | assert.Len(t, buckets, 10) |
| 26 | assert.EqualValues(t, 1, buckets[0]) |
| 27 | assert.EqualValues(t, 32.0, buckets[5]) |
| 28 | assert.EqualValues(t, 512.0, buckets[9]) |
| 29 | |
| 30 | assert.Panics(t, func() { |
| 31 | ExponentialBuckets(1, 2, 0) |
| 32 | }) |
| 33 | assert.Panics(t, func() { |
| 34 | ExponentialBuckets(0, 2, 2) |
| 35 | }) |
| 36 | |
| 37 | assert.Panics(t, func() { |
| 38 | ExponentialBuckets(1, 1, 2) |
| 39 | }) |
| 40 | } |
| 41 | |
| 42 | func TestNewHistogram(t *testing.T) { |
| 43 | h := NewHistogram(nil).(*histogram) |
| 44 | assert.EqualValues(t, 0, h.count) |
| 45 | assert.EqualValues(t, 0.0, h.sum) |
| 46 | assert.Equal(t, DefBuckets, h.upperBounds) |
| 47 | |
| 48 | h = NewHistogram([]float64{1, 10, 5}).(*histogram) |
| 49 | assert.Equal(t, []float64{1, 5, 10}, h.upperBounds) |
| 50 | assert.Len(t, h.buckets, 3) |
| 51 | } |
| 52 | |
| 53 | func TestHistogram_WriteTo(t *testing.T) { |
| 54 | h := NewHistogram([]float64{1, 2, 3}) |
| 55 | m := map[string]int64{} |
| 56 | h.WriteTo(m, "pi", 100, 1) |
| 57 | assert.Len(t, m, 5) |
| 58 | assert.EqualValues(t, 0, m["pi_count"]) |
| 59 | assert.EqualValues(t, 0, m["pi_sum"]) |
| 60 | assert.EqualValues(t, 0, m["pi_bucket_1"]) |
| 61 | assert.EqualValues(t, 0, m["pi_bucket_2"]) |
| 62 | assert.EqualValues(t, 0, m["pi_bucket_3"]) |
| 63 | |
| 64 | h.Observe(0) |
| 65 | h.Observe(1.5) |
| 66 | h.Observe(3.5) |
| 67 | h.WriteTo(m, "pi", 100, 1) |
| 68 | assert.Len(t, m, 5) |
| 69 | assert.EqualValues(t, 3, m["pi_count"]) |
| 70 | assert.EqualValues(t, 500, m["pi_sum"]) |
| 71 | assert.EqualValues(t, 1, m["pi_bucket_1"]) |
| 72 | assert.EqualValues(t, 2, m["pi_bucket_2"]) |
| 73 | assert.EqualValues(t, 2, m["pi_bucket_3"]) |
| 74 | } |
| 75 | |
| 76 | func TestHistogram_searchBucketIndex(t *testing.T) { |
| 77 | h := NewHistogram(LinearBuckets(1, 1, 5)).(*histogram) // [1, 2, ..., 5] |
| 78 | assert.Equal(t, 0, h.searchBucketIndex(0.1)) |
| 79 | assert.Equal(t, 1, h.searchBucketIndex(1.1)) |
| 80 | assert.Equal(t, 5, h.searchBucketIndex(8.1)) |
| 81 | |
| 82 | h = NewHistogram(LinearBuckets(1, 1, 40)).(*histogram) // [1, 2, ..., 5] |
| 83 | assert.Equal(t, 0, h.searchBucketIndex(0.1)) |
| 84 | assert.Equal(t, 1, h.searchBucketIndex(1.1)) |
| 85 | assert.Equal(t, 5, h.searchBucketIndex(5.1)) |
| 86 | assert.Equal(t, 7, h.searchBucketIndex(8)) |
| 87 | assert.Equal(t, 39, h.searchBucketIndex(39.5)) |
| 88 | assert.Equal(t, 40, h.searchBucketIndex(40.5)) |
| 89 | } |
| 90 | |
| 91 | func BenchmarkHistogram_Observe(b *testing.B) { |
| 92 | benchmarks := []struct { |
| 93 | name string |
| 94 | buckets []float64 |
| 95 | }{ |
| 96 | {"default", nil}, |
| 97 | {"len_10", LinearBuckets(0, 0.1, 10)}, |
| 98 | {"len_20", LinearBuckets(0, 0.1, 20)}, |
| 99 | {"len_30", LinearBuckets(0, 0.1, 30)}, |
| 100 | {"len_40", LinearBuckets(0, 0.1, 40)}, |
| 101 | } |
| 102 | for _, bm := range benchmarks { |
| 103 | b.Run(bm.name, func(b *testing.B) { |
| 104 | h := NewHistogram(bm.buckets) |
| 105 | for i := 0; i < b.N; i++ { |
| 106 | h.Observe(2.5) |
| 107 | } |
| 108 | }) |
| 109 | } |
| 110 | } |
| 111 | |
| 112 | func BenchmarkHistogram_WriteTo(b *testing.B) { |
| 113 | benchmarks := []struct { |
| 114 | name string |
| 115 | buckets []float64 |
| 116 | }{ |
| 117 | {"default", nil}, |
| 118 | {"len_10", LinearBuckets(0, 0.1, 10)}, |
| 119 | {"len_20", LinearBuckets(0, 0.1, 20)}, |
| 120 | {"len_30", LinearBuckets(0, 0.1, 30)}, |
| 121 | {"len_40", LinearBuckets(0, 0.1, 40)}, |
| 122 | } |
| 123 | for _, bm := range benchmarks { |
| 124 | b.Run(bm.name, func(b *testing.B) { |
| 125 | h := NewHistogram(bm.buckets) |
| 126 | h.Observe(0.1) |
| 127 | h.Observe(0.01) |
| 128 | h.Observe(0.5) |
| 129 | h.Observe(10) |
| 130 | m := map[string]int64{} |
| 131 | for i := 0; i < b.N; i++ { |
| 132 | h.WriteTo(m, "pi", 100, 1) |
| 133 | } |
| 134 | }) |
| 135 | } |
| 136 | } |