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
|
#include "distributions.hpp"
#include "gtest/gtest.h"
#include <numeric>
int main(int argc, char* argv[])
{
testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}
using Bins = std::vector<DistributionPair>;
Bins generateBins(const std::uint32_t min, const std::uint32_t max, const std::uint8_t numberBins)
{
const auto binRange = (max - min) / numberBins;
auto minBin = min;
auto maxBin = min + binRange;
Bins results;
results.reserve(numberBins);
for (auto bin = 0u; bin < numberBins; bin++)
{
results.emplace_back(minBin, maxBin);
minBin = maxBin + 1;
maxBin = minBin + binRange;
}
return results;
}
void checkBins(const Bins& expected, const Bins& actual)
{
ASSERT_EQ(expected.size(), actual.size()) << "Wrong number of bins";
for (auto i = 0u; i < expected.size(); i++)
{
EXPECT_EQ(expected[i].minValue, actual[i].minValue) << "Wrong minimum value for bin " << i;
EXPECT_EQ(expected[i].maxValue, actual[i].maxValue) << "Wrong maximum value for bin " << i;
}
}
void checkTotal(const std::uint32_t expected, const Bins& bins)
{
const auto add_counts = [](const std::uint32_t total, const DistributionPair&
bin)
{
return total + bin.count;
};
const auto actual = std::accumulate(bins.cbegin(), bins.cend(), 0u,
add_counts);
EXPECT_EQ(expected, actual) << "Wrong number of elements across all bins";
}
TEST(UniformDistribution, ReturnsExpectedBins)
{
const auto bins = generateUniformDistribution(0, 0, 79, 40);
checkBins(generateBins(0, 79, 40), bins);
}
TEST(UniformDistribution, HasCorrectTotalAcrossAllBins)
{
const auto bins = generateUniformDistribution(100000, 0, 79, 40);
checkTotal(100000, bins);
}
TEST(NormalDistribution, ReturnsExpectedBins)
{
const auto bins = generateNormalDistribution(0, 50, 5, 40);
checkBins(generateBins(30, 69, 40), bins);
}
TEST(NormalDistribution, HasCorrectTotalAcrossAllBins)
{
const auto bins = generateNormalDistribution(100000, 50, 5, 40);
checkTotal(100000, bins);
}
TEST(PoissonDistribution, ReturnsExpectedBins)
{
const auto bins = generatePoissonDistribution(0, 6, 40);
checkBins(generateBins(0, 39, 40), bins);
}
TEST(PoissonDistribution, HasCorrectTotalAcrossAllBins)
{
const auto bins = generatePoissonDistribution(100000, 6, 40);
checkTotal(100000, bins);
}
|
