metric/exponential_test.go at master · csigo/metric · GitHub

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
package metric

import (
	"fmt"
	"math"
	"testing"

	"github.com/stretchr/testify/suite"
)

// SuiteExponential is test suite for histogram percentile
type SuiteExponential struct {
	suite.Suite
}

// TestRunSuiteExponential run SuiteExponential
func TestRunSuiteExponential(t *testing.T) {
	suite.Run(t, new(SuiteExponential))
}

func (s *SuiteExponential) TestMinMax() {
	exp := &exponential{}

	minV, maxV := exp.ValueRange()
	minBin, maxBin := exp.BinRange()
	s.Equal(minV, float64(-maxValue))
	s.Equal(maxV, float64(maxValue))
	s.Equal(minBin, -maxBin)
	s.Equal(maxBin, maxBin)
}

func (s *SuiteExponential) TestRange() {
	exp := &exponential{}
	// min & max
	s.Equal(exp.Bin(0), 0)
	s.Equal(exp.Bin(10*maxValue), maxBin)
	s.Equal(exp.Bin(-10*maxValue), -maxBin)

	for v := float64(1000); v > minFloatValue/10.0; v /= 3.0 {
		idx := exp.Bin(v)
		// check always in buckets
		l, u := exp.Bound(idx)
		s.True(v > l, fmt.Sprintf("%f > %f", v, l))
		s.True(v <= u, fmt.Sprintf("%f <= %f", v, u))
	}

	for v := float64(1); v < 5000; v += 0.5 {
		idx := exp.Bin(v)
		// check always in buckets
		l, u := exp.Bound(idx)
		s.True(v > l, fmt.Sprintf("%f > %f", v, l))
		s.True(v <= u, fmt.Sprintf("%f <= %f", v, u))
	}

	for v := float64(-1000); v < -minFloatValue/10.0; v /= 3.0 {
		idx := exp.Bin(v)
		// check always in buckets
		l, u := exp.Bound(idx)
		s.True(v >= l, fmt.Sprintf("%f >= %f", v, l))
		s.True(v < u, fmt.Sprintf("%f < %f", v, u))
	}

	for v := float64(-1); v > -5000; v -= 0.5 {
		idx := exp.Bin(v)
		// check always in buckets
		l, u := exp.Bound(idx)
		s.True(v >= l, fmt.Sprintf("%f >= %f", v, l))
		s.True(v < u, fmt.Sprintf("%f < %f", v, u))
	}

}

func (s *SuiteExponential) TestBound() {
	exp := &exponential{}
	r := math.Pow(10, 0.1)

	s.Panics(func() {
		exp.Bound(-maxBin - 1)
	})
	s.Panics(func() {
		exp.Bound(maxBin + 1)
	})

	// first bin
	l, u := exp.Bound(0)
	assertNearEqual(s.T(), l, 0)
	assertNearEqual(s.T(), u, 0)

	l, u = exp.Bound(1)
	assertNearEqual(s.T(), l, 0)
	assertNearEqual(s.T(), u, minFloatValue)

	l, u = exp.Bound(-1)
	assertNearEqual(s.T(), l, -minFloatValue)
	assertNearEqual(s.T(), u, 0)

	l, u = exp.Bound(2)
	assertNearEqual(s.T(), l, minFloatValue)
	assertNearEqual(s.T(), u, minFloatValue*r)

	l, u = exp.Bound(-2)
	assertNearEqual(s.T(), l, -minFloatValue*r)
	assertNearEqual(s.T(), u, -minFloatValue)

	// max value bin
	l, u = exp.Bound(maxBin - 1)
	assertNearEqual(s.T(), l, maxValue/r)
	assertNearEqual(s.T(), u, maxValue)

	l, u = exp.Bound(-maxBin + 1)
	assertNearEqual(s.T(), l, -maxValue)
	assertNearEqual(s.T(), u, -maxValue/r)

	// last bin
	l, u = exp.Bound(maxBin)
	assertNearEqual(s.T(), l, maxValue)
	assertNearEqual(s.T(), u, math.MaxFloat64)

	l, u = exp.Bound(-maxBin)
	assertNearEqual(s.T(), l, -math.MaxFloat64)
	assertNearEqual(s.T(), u, -maxValue)
}