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
123
124
125
126
127
128
|
//
// Copyright (C) 2023 The Android Open Source Project
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
#include "Histogram.h"
#include <gtest/gtest.h>
namespace android {
namespace expresslog {
#ifdef __ANDROID__
TEST(UniformOptions, getBinsCount) {
const std::shared_ptr<Histogram::UniformOptions> options1(
Histogram::UniformOptions::create(1, 100, 1000));
ASSERT_EQ(3, options1->getBinsCount());
const std::shared_ptr<Histogram::UniformOptions> options10(
Histogram::UniformOptions::create(10, 100, 1000));
ASSERT_EQ(12, options10->getBinsCount());
}
TEST(UniformOptions, constructZeroBinsCount) {
const std::shared_ptr<Histogram::UniformOptions> options(
Histogram::UniformOptions::create(0, 100, 1000));
ASSERT_EQ(nullptr, options);
}
TEST(UniformOptions, constructNegativeBinsCount) {
const std::shared_ptr<Histogram::UniformOptions> options(
Histogram::UniformOptions::create(-1, 100, 1000));
ASSERT_EQ(nullptr, options);
}
TEST(UniformOptions, constructMaxValueLessThanMinValue) {
const std::shared_ptr<Histogram::UniformOptions> options(
Histogram::UniformOptions::create(10, 1000, 100));
ASSERT_EQ(nullptr, options);
}
TEST(UniformOptions, testBinIndexForRangeEqual1) {
const std::shared_ptr<Histogram::UniformOptions> options(
Histogram::UniformOptions::create(10, 1, 11));
for (int i = 0, bins = options->getBinsCount(); i < bins; i++) {
ASSERT_EQ(i, options->getBinForSample(i));
}
}
TEST(UniformOptions, testBinIndexForRangeEqual2) {
const std::shared_ptr<Histogram::UniformOptions> options(
Histogram::UniformOptions::create(10, 1, 21));
for (int i = 0, bins = options->getBinsCount(); i < bins; i++) {
ASSERT_EQ(i, options->getBinForSample(i * 2));
ASSERT_EQ(i, options->getBinForSample(i * 2 - 1));
}
}
TEST(UniformOptions, testBinIndexForRangeEqual5) {
const std::shared_ptr<Histogram::UniformOptions> options(
Histogram::UniformOptions::create(2, 0, 10));
ASSERT_EQ(4, options->getBinsCount());
for (int i = 0; i < 2; i++) {
for (int sample = 0; sample < 5; sample++) {
ASSERT_EQ(i + 1, options->getBinForSample(i * 5 + sample));
}
}
}
TEST(UniformOptions, testBinIndexForRangeEqual10) {
const std::shared_ptr<Histogram::UniformOptions> options(
Histogram::UniformOptions::create(10, 1, 101));
ASSERT_EQ(0, options->getBinForSample(0));
ASSERT_EQ(options->getBinsCount() - 2, options->getBinForSample(100));
ASSERT_EQ(options->getBinsCount() - 1, options->getBinForSample(101));
const float binSize = (101 - 1) / 10.f;
for (int i = 1, bins = options->getBinsCount() - 1; i < bins; i++) {
ASSERT_EQ(i, options->getBinForSample(i * binSize));
}
}
TEST(UniformOptions, testBinIndexForRangeEqual90) {
const int binCount = 10;
const int minValue = 100;
const int maxValue = 100000;
const std::shared_ptr<Histogram::UniformOptions> options(
Histogram::UniformOptions::create(binCount, minValue, maxValue));
// logging underflow sample
ASSERT_EQ(0, options->getBinForSample(minValue - 1));
// logging overflow sample
ASSERT_EQ(binCount + 1, options->getBinForSample(maxValue));
ASSERT_EQ(binCount + 1, options->getBinForSample(maxValue + 1));
// logging min edge sample
ASSERT_EQ(1, options->getBinForSample(minValue));
// logging max edge sample
ASSERT_EQ(binCount, options->getBinForSample(maxValue - 1));
// logging single valid sample per bin
const int binSize = (maxValue - minValue) / binCount;
for (int i = 0; i < binCount; i++) {
ASSERT_EQ(i + 1, options->getBinForSample(minValue + binSize * i));
}
}
#else
GTEST_LOG_(INFO) << "This test does nothing.\n";
#endif
} // namespace expresslog
} // namespace android
|
