#!/usr/bin/python

import unittest

def logLinearBuckets(minExp, maxExp):
    """Return a list of Prometheus bucket boundaries that can be used when
       initializing a histogram metric.

       The goal is to simulate HdrHistogram's log-linear accuracy with 2
       significant digits while being careful to only create the buckets
       needed.

       The minExp and maxExp are the exponent range that buckets will be
       generated for.  So 1 x 10^{minExp} ... 9.9 x 10^{maxExp} will be
       created.
    """

    return [ d * 10**(e-1) for e in range(minExp, maxExp+1) for d in range(10, 100) ]

testBuckets = [
        0.1,
        0.11,
        0.12,
        0.13,
        0.14,
        0.15,
        0.16,
        0.17,
        0.18,
        0.19,
        0.2,
        0.21,
        0.22,
        0.23,
        0.24,
        0.25,
        0.26,
        0.27,
        0.28,
        0.29,
        0.3,
        0.31,
        0.32,
        0.33,
        0.34,
        0.35,
        0.36,
        0.37,
        0.38,
        0.39,
        0.4,
        0.41,
        0.42,
        0.43,
        0.44,
        0.45,
        0.46,
        0.47,
        0.48,
        0.49,
        0.5,
        0.51,
        0.52,
	0.53,
        0.54,
        0.55,
	0.56,
	0.5700000000000001,
	0.58,
	0.59,
	0.6,
	0.61,
	0.62,
	0.63,
	0.64,
	0.65,
	0.66,
	0.67,
	0.68,
	0.6900000000000001,
	0.7000000000000001,
	0.71,
	0.72,
	0.73,
	0.74,
	0.75,
	0.76,
	0.77,
	0.78,
	0.79,
	0.8,
	0.81,
	0.8200000000000001,
	0.8300000000000001,
	0.84,
	0.85,
	0.86,
	0.87,
	0.88,
	0.89,
	0.9,
	0.91,
	0.92,
	0.93,
	0.9400000000000001,
	0.9500000000000001,
	0.96,
	0.97,
	0.98,
	0.99,
	1.0,
	1.1,
	1.2000000000000002,
	1.3,
	1.4000000000000001,
	1.5,
	1.6,
	1.7000000000000002,
	1.8,
	1.9000000000000001,
	2.0,
	2.1,
	2.2,
	2.3000000000000003,
	2.4000000000000004,
	2.5,
	2.6,
	2.7,
	2.8000000000000003,
	2.9000000000000004,
	3.0,
	3.1,
	3.2,
	3.3000000000000003,
	3.4000000000000004,
	3.5,
	3.6,
	3.7,
	3.8000000000000003,
	3.9000000000000004,
	4.0,
	4.1000000000000005,
	4.2,
	4.3,
	4.4,
	4.5,
	4.6000000000000005,
	4.7,
	4.800000000000001,
	4.9,
	5.0,
	5.1000000000000005,
	5.2,
	5.300000000000001,
	5.4,
	5.5,
	5.6000000000000005,
	5.7,
	5.800000000000001,
	5.9,
	6.0,
	6.1000000000000005,
	6.2,
	6.300000000000001,
	6.4,
	6.5,
	6.6000000000000005,
	6.7,
	6.800000000000001,
	6.9,
	7.0,
	7.1000000000000005,
	7.2,
	7.300000000000001,
	7.4,
	7.5,
	7.6000000000000005,
	7.7,
	7.800000000000001,
	7.9,
	8.0,
	8.1,
	8.200000000000001,
	8.3,
	8.4,
	8.5,
	8.6,
	8.700000000000001,
	8.8,
	8.9,
	9.0,
	9.1,
	9.200000000000001,
	9.3,
	9.4,
	9.5,
	9.600000000000001,
	9.700000000000001,
	9.8,
	9.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,
	110,
	120,
	130,
	140,
	150,
	160,
	170,
	180,
	190,
	200,
	210,
	220,
	230,
	240,
	250,
	260,
	270,
	280,
	290,
	300,
	310,
	320,
	330,
	340,
	350,
	360,
	370,
	380,
	390,
	400,
	410,
	420,
	430,
	440,
	450,
	460,
	470,
	480,
	490,
	500,
	510,
	520,
	530,
	540,
	550,
	560,
	570,
	580,
	590,
	600,
	610,
	620,
	630,
	640,
	650,
	660,
	670,
	680,
	690,
	700,
	710,
	720,
	730,
	740,
	750,
	760,
	770,
	780,
	790,
	800,
	810,
	820,
	830,
	840,
	850,
	860,
	870,
	880,
	890,
	900,
	910,
	920,
	930,
	940,
	950,
	960,
	970,
	980,
	990
]

class TestLogLinearBuckets(unittest.TestCase):

    def test_equality(self):
        data = logLinearBuckets(-1, 2)
        self.assertTrue(len(data) == len(testBuckets))

        for i in range(len(data)):
            self.assertAlmostEqual(data[i], testBuckets[i])

if __name__ == "__main__":
    unittest.main()