1 // Copyright 2018 The Abseil Authors.
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 // https://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14
15 #include "absl/random/mock_distributions.h"
16
17 #include <cmath>
18 #include <limits>
19
20 #include "gmock/gmock.h"
21 #include "gtest/gtest.h"
22 #include "absl/numeric/int128.h"
23 #include "absl/random/distributions.h"
24 #include "absl/random/mocking_bit_gen.h"
25 #include "absl/random/random.h"
26
27 namespace {
28 using ::testing::Return;
29
TEST(MockDistributions,Examples)30 TEST(MockDistributions, Examples) {
31 absl::MockingBitGen gen;
32
33 EXPECT_NE(absl::Uniform<int>(gen, 1, 1000000), 20);
34 EXPECT_CALL(absl::MockUniform<int>(), Call(gen, 1, 1000000))
35 .WillOnce(Return(20));
36 EXPECT_EQ(absl::Uniform<int>(gen, 1, 1000000), 20);
37
38 EXPECT_NE(absl::Uniform<double>(gen, 0.0, 100.0), 5.0);
39 EXPECT_CALL(absl::MockUniform<double>(), Call(gen, 0.0, 100.0))
40 .WillOnce(Return(5.0));
41 EXPECT_EQ(absl::Uniform<double>(gen, 0.0, 100.0), 5.0);
42
43 EXPECT_NE(absl::Exponential<double>(gen, 1.0), 42);
44 EXPECT_CALL(absl::MockExponential<double>(), Call(gen, 1.0))
45 .WillOnce(Return(42));
46 EXPECT_EQ(absl::Exponential<double>(gen, 1.0), 42);
47
48 EXPECT_NE(absl::Poisson<int>(gen, 1.0), 500);
49 EXPECT_CALL(absl::MockPoisson<int>(), Call(gen, 1.0)).WillOnce(Return(500));
50 EXPECT_EQ(absl::Poisson<int>(gen, 1.0), 500);
51
52 EXPECT_NE(absl::Bernoulli(gen, 0.000001), true);
53 EXPECT_CALL(absl::MockBernoulli(), Call(gen, 0.000001))
54 .WillOnce(Return(true));
55 EXPECT_EQ(absl::Bernoulli(gen, 0.000001), true);
56
57 EXPECT_NE(absl::Beta<double>(gen, 3.0, 2.0), 0.567);
58 EXPECT_CALL(absl::MockBeta<double>(), Call(gen, 3.0, 2.0))
59 .WillOnce(Return(0.567));
60 EXPECT_EQ(absl::Beta<double>(gen, 3.0, 2.0), 0.567);
61
62 EXPECT_NE(absl::Zipf<int>(gen, 1000000, 2.0, 1.0), 1221);
63 EXPECT_CALL(absl::MockZipf<int>(), Call(gen, 1000000, 2.0, 1.0))
64 .WillOnce(Return(1221));
65 EXPECT_EQ(absl::Zipf<int>(gen, 1000000, 2.0, 1.0), 1221);
66
67 EXPECT_NE(absl::Gaussian<double>(gen, 0.0, 1.0), 0.001);
68 EXPECT_CALL(absl::MockGaussian<double>(), Call(gen, 0.0, 1.0))
69 .WillOnce(Return(0.001));
70 EXPECT_EQ(absl::Gaussian<double>(gen, 0.0, 1.0), 0.001);
71
72 EXPECT_NE(absl::LogUniform<int>(gen, 0, 1000000, 2), 2040);
73 EXPECT_CALL(absl::MockLogUniform<int>(), Call(gen, 0, 1000000, 2))
74 .WillOnce(Return(2040));
75 EXPECT_EQ(absl::LogUniform<int>(gen, 0, 1000000, 2), 2040);
76 }
77
TEST(MockDistributions,UniformUInt128BoundariesAreAllowed)78 TEST(MockDistributions, UniformUInt128BoundariesAreAllowed) {
79 absl::MockingBitGen gen;
80
81 EXPECT_CALL(absl::MockUniform<absl::uint128>(), Call(gen))
82 .WillOnce(Return(absl::Uint128Max()));
83 EXPECT_EQ(absl::Uniform<absl::uint128>(gen), absl::Uint128Max());
84 }
85
TEST(MockDistributions,UniformDoubleBoundaryCasesAreAllowed)86 TEST(MockDistributions, UniformDoubleBoundaryCasesAreAllowed) {
87 absl::MockingBitGen gen;
88
89 EXPECT_CALL(absl::MockUniform<double>(), Call(gen, 1.0, 10.0))
90 .WillOnce(Return(
91 std::nextafter(10.0, -std::numeric_limits<double>::infinity())));
92 EXPECT_EQ(absl::Uniform<double>(gen, 1.0, 10.0),
93 std::nextafter(10.0, -std::numeric_limits<double>::infinity()));
94
95 EXPECT_CALL(absl::MockUniform<double>(),
96 Call(absl::IntervalOpen, gen, 1.0, 10.0))
97 .WillOnce(Return(
98 std::nextafter(10.0, -std::numeric_limits<double>::infinity())));
99 EXPECT_EQ(absl::Uniform<double>(absl::IntervalOpen, gen, 1.0, 10.0),
100 std::nextafter(10.0, -std::numeric_limits<double>::infinity()));
101
102 EXPECT_CALL(absl::MockUniform<double>(),
103 Call(absl::IntervalOpen, gen, 1.0, 10.0))
104 .WillOnce(
105 Return(std::nextafter(1.0, std::numeric_limits<double>::infinity())));
106 EXPECT_EQ(absl::Uniform<double>(absl::IntervalOpen, gen, 1.0, 10.0),
107 std::nextafter(1.0, std::numeric_limits<double>::infinity()));
108 }
109
TEST(MockDistributions,UniformDoubleEmptyRangesAllowTheBoundary)110 TEST(MockDistributions, UniformDoubleEmptyRangesAllowTheBoundary) {
111 absl::MockingBitGen gen;
112
113 ON_CALL(absl::MockUniform<double>(), Call(absl::IntervalOpen, gen, 1.0, 1.0))
114 .WillByDefault(Return(1.0));
115 EXPECT_EQ(absl::Uniform<double>(absl::IntervalOpen, gen, 1.0, 1.0), 1.0);
116
117 ON_CALL(absl::MockUniform<double>(),
118 Call(absl::IntervalOpenClosed, gen, 1.0, 1.0))
119 .WillByDefault(Return(1.0));
120 EXPECT_EQ(absl::Uniform<double>(absl::IntervalOpenClosed, gen, 1.0, 1.0),
121 1.0);
122
123 ON_CALL(absl::MockUniform<double>(),
124 Call(absl::IntervalClosedOpen, gen, 1.0, 1.0))
125 .WillByDefault(Return(1.0));
126 EXPECT_EQ(absl::Uniform<double>(absl::IntervalClosedOpen, gen, 1.0, 1.0),
127 1.0);
128 }
129
TEST(MockDistributions,UniformIntEmptyRangeCasesAllowTheBoundary)130 TEST(MockDistributions, UniformIntEmptyRangeCasesAllowTheBoundary) {
131 absl::MockingBitGen gen;
132
133 ON_CALL(absl::MockUniform<int>(), Call(absl::IntervalOpen, gen, 1, 1))
134 .WillByDefault(Return(1));
135 EXPECT_EQ(absl::Uniform<int>(absl::IntervalOpen, gen, 1, 1), 1);
136
137 ON_CALL(absl::MockUniform<int>(), Call(absl::IntervalOpenClosed, gen, 1, 1))
138 .WillByDefault(Return(1));
139 EXPECT_EQ(absl::Uniform<int>(absl::IntervalOpenClosed, gen, 1, 1), 1);
140
141 ON_CALL(absl::MockUniform<int>(), Call(absl::IntervalClosedOpen, gen, 1, 1))
142 .WillByDefault(Return(1));
143 EXPECT_EQ(absl::Uniform<int>(absl::IntervalClosedOpen, gen, 1, 1), 1);
144 }
145
TEST(MockUniformDeathTest,OutOfBoundsValuesAreRejected)146 TEST(MockUniformDeathTest, OutOfBoundsValuesAreRejected) {
147 absl::MockingBitGen gen;
148
149 EXPECT_DEATH_IF_SUPPORTED(
150 {
151 EXPECT_CALL(absl::MockUniform<int>(), Call(gen, 1, 100))
152 .WillOnce(Return(0));
153 absl::Uniform<int>(gen, 1, 100);
154 },
155 " 0 is not in \\[1, 100\\)");
156 EXPECT_DEATH_IF_SUPPORTED(
157 {
158 EXPECT_CALL(absl::MockUniform<int>(), Call(gen, 1, 100))
159 .WillOnce(Return(101));
160 absl::Uniform<int>(gen, 1, 100);
161 },
162 " 101 is not in \\[1, 100\\)");
163 EXPECT_DEATH_IF_SUPPORTED(
164 {
165 EXPECT_CALL(absl::MockUniform<int>(), Call(gen, 1, 100))
166 .WillOnce(Return(100));
167 absl::Uniform<int>(gen, 1, 100);
168 },
169 " 100 is not in \\[1, 100\\)");
170
171 EXPECT_DEATH_IF_SUPPORTED(
172 {
173 EXPECT_CALL(absl::MockUniform<int>(),
174 Call(absl::IntervalOpen, gen, 1, 100))
175 .WillOnce(Return(1));
176 absl::Uniform<int>(absl::IntervalOpen, gen, 1, 100);
177 },
178 " 1 is not in \\(1, 100\\)");
179 EXPECT_DEATH_IF_SUPPORTED(
180 {
181 EXPECT_CALL(absl::MockUniform<int>(),
182 Call(absl::IntervalOpen, gen, 1, 100))
183 .WillOnce(Return(101));
184 absl::Uniform<int>(absl::IntervalOpen, gen, 1, 100);
185 },
186 " 101 is not in \\(1, 100\\)");
187 EXPECT_DEATH_IF_SUPPORTED(
188 {
189 EXPECT_CALL(absl::MockUniform<int>(),
190 Call(absl::IntervalOpen, gen, 1, 100))
191 .WillOnce(Return(100));
192 absl::Uniform<int>(absl::IntervalOpen, gen, 1, 100);
193 },
194 " 100 is not in \\(1, 100\\)");
195
196 EXPECT_DEATH_IF_SUPPORTED(
197 {
198 EXPECT_CALL(absl::MockUniform<int>(),
199 Call(absl::IntervalOpenClosed, gen, 1, 100))
200 .WillOnce(Return(1));
201 absl::Uniform<int>(absl::IntervalOpenClosed, gen, 1, 100);
202 },
203 " 1 is not in \\(1, 100\\]");
204 EXPECT_DEATH_IF_SUPPORTED(
205 {
206 EXPECT_CALL(absl::MockUniform<int>(),
207 Call(absl::IntervalOpenClosed, gen, 1, 100))
208 .WillOnce(Return(101));
209 absl::Uniform<int>(absl::IntervalOpenClosed, gen, 1, 100);
210 },
211 " 101 is not in \\(1, 100\\]");
212
213 EXPECT_DEATH_IF_SUPPORTED(
214 {
215 EXPECT_CALL(absl::MockUniform<int>(),
216 Call(absl::IntervalOpenClosed, gen, 1, 100))
217 .WillOnce(Return(0));
218 absl::Uniform<int>(absl::IntervalOpenClosed, gen, 1, 100);
219 },
220 " 0 is not in \\(1, 100\\]");
221 EXPECT_DEATH_IF_SUPPORTED(
222 {
223 EXPECT_CALL(absl::MockUniform<int>(),
224 Call(absl::IntervalOpenClosed, gen, 1, 100))
225 .WillOnce(Return(101));
226 absl::Uniform<int>(absl::IntervalOpenClosed, gen, 1, 100);
227 },
228 " 101 is not in \\(1, 100\\]");
229
230 EXPECT_DEATH_IF_SUPPORTED(
231 {
232 EXPECT_CALL(absl::MockUniform<int>(),
233 Call(absl::IntervalClosed, gen, 1, 100))
234 .WillOnce(Return(0));
235 absl::Uniform<int>(absl::IntervalClosed, gen, 1, 100);
236 },
237 " 0 is not in \\[1, 100\\]");
238 EXPECT_DEATH_IF_SUPPORTED(
239 {
240 EXPECT_CALL(absl::MockUniform<int>(),
241 Call(absl::IntervalClosed, gen, 1, 100))
242 .WillOnce(Return(101));
243 absl::Uniform<int>(absl::IntervalClosed, gen, 1, 100);
244 },
245 " 101 is not in \\[1, 100\\]");
246 }
247
TEST(MockUniformDeathTest,OutOfBoundsDoublesAreRejected)248 TEST(MockUniformDeathTest, OutOfBoundsDoublesAreRejected) {
249 absl::MockingBitGen gen;
250
251 EXPECT_DEATH_IF_SUPPORTED(
252 {
253 EXPECT_CALL(absl::MockUniform<double>(), Call(gen, 1.0, 10.0))
254 .WillOnce(Return(10.0));
255 EXPECT_EQ(absl::Uniform<double>(gen, 1.0, 10.0), 10.0);
256 },
257 " 10 is not in \\[1, 10\\)");
258
259 EXPECT_DEATH_IF_SUPPORTED(
260 {
261 EXPECT_CALL(absl::MockUniform<double>(),
262 Call(absl::IntervalOpen, gen, 1.0, 10.0))
263 .WillOnce(Return(10.0));
264 EXPECT_EQ(absl::Uniform<double>(absl::IntervalOpen, gen, 1.0, 10.0),
265 10.0);
266 },
267 " 10 is not in \\(1, 10\\)");
268
269 EXPECT_DEATH_IF_SUPPORTED(
270 {
271 EXPECT_CALL(absl::MockUniform<double>(),
272 Call(absl::IntervalOpen, gen, 1.0, 10.0))
273 .WillOnce(Return(1.0));
274 EXPECT_EQ(absl::Uniform<double>(absl::IntervalOpen, gen, 1.0, 10.0),
275 1.0);
276 },
277 " 1 is not in \\(1, 10\\)");
278 }
279
280 } // namespace
281