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(MockUniform,OutOfBoundsIsAllowed)78 TEST(MockUniform, OutOfBoundsIsAllowed) {
79 absl::UnvalidatedMockingBitGen gen;
80
81 EXPECT_CALL(absl::MockUniform<int>(), Call(gen, 1, 100)).WillOnce(Return(0));
82 EXPECT_EQ(absl::Uniform<int>(gen, 1, 100), 0);
83 }
84
TEST(ValidatedMockDistributions,UniformUInt128Works)85 TEST(ValidatedMockDistributions, UniformUInt128Works) {
86 absl::MockingBitGen gen;
87
88 EXPECT_CALL(absl::MockUniform<absl::uint128>(), Call(gen))
89 .WillOnce(Return(absl::Uint128Max()));
90 EXPECT_EQ(absl::Uniform<absl::uint128>(gen), absl::Uint128Max());
91 }
92
TEST(ValidatedMockDistributions,UniformDoubleBoundaryCases)93 TEST(ValidatedMockDistributions, UniformDoubleBoundaryCases) {
94 absl::MockingBitGen gen;
95
96 EXPECT_CALL(absl::MockUniform<double>(), Call(gen, 1.0, 10.0))
97 .WillOnce(Return(
98 std::nextafter(10.0, -std::numeric_limits<double>::infinity())));
99 EXPECT_EQ(absl::Uniform<double>(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(Return(
105 std::nextafter(10.0, -std::numeric_limits<double>::infinity())));
106 EXPECT_EQ(absl::Uniform<double>(absl::IntervalOpen, gen, 1.0, 10.0),
107 std::nextafter(10.0, -std::numeric_limits<double>::infinity()));
108
109 EXPECT_CALL(absl::MockUniform<double>(),
110 Call(absl::IntervalOpen, gen, 1.0, 10.0))
111 .WillOnce(
112 Return(std::nextafter(1.0, std::numeric_limits<double>::infinity())));
113 EXPECT_EQ(absl::Uniform<double>(absl::IntervalOpen, gen, 1.0, 10.0),
114 std::nextafter(1.0, std::numeric_limits<double>::infinity()));
115 }
116
TEST(ValidatedMockDistributions,UniformDoubleEmptyRangeCases)117 TEST(ValidatedMockDistributions, UniformDoubleEmptyRangeCases) {
118 absl::MockingBitGen gen;
119
120 ON_CALL(absl::MockUniform<double>(), Call(absl::IntervalOpen, gen, 1.0, 1.0))
121 .WillByDefault(Return(1.0));
122 EXPECT_EQ(absl::Uniform<double>(absl::IntervalOpen, gen, 1.0, 1.0), 1.0);
123
124 ON_CALL(absl::MockUniform<double>(),
125 Call(absl::IntervalOpenClosed, gen, 1.0, 1.0))
126 .WillByDefault(Return(1.0));
127 EXPECT_EQ(absl::Uniform<double>(absl::IntervalOpenClosed, gen, 1.0, 1.0),
128 1.0);
129
130 ON_CALL(absl::MockUniform<double>(),
131 Call(absl::IntervalClosedOpen, gen, 1.0, 1.0))
132 .WillByDefault(Return(1.0));
133 EXPECT_EQ(absl::Uniform<double>(absl::IntervalClosedOpen, gen, 1.0, 1.0),
134 1.0);
135 }
136
TEST(ValidatedMockDistributions,UniformIntEmptyRangeCases)137 TEST(ValidatedMockDistributions, UniformIntEmptyRangeCases) {
138 absl::MockingBitGen gen;
139
140 ON_CALL(absl::MockUniform<int>(), Call(absl::IntervalOpen, gen, 1, 1))
141 .WillByDefault(Return(1));
142 EXPECT_EQ(absl::Uniform<int>(absl::IntervalOpen, gen, 1, 1), 1);
143
144 ON_CALL(absl::MockUniform<int>(), Call(absl::IntervalOpenClosed, gen, 1, 1))
145 .WillByDefault(Return(1));
146 EXPECT_EQ(absl::Uniform<int>(absl::IntervalOpenClosed, gen, 1, 1), 1);
147
148 ON_CALL(absl::MockUniform<int>(), Call(absl::IntervalClosedOpen, gen, 1, 1))
149 .WillByDefault(Return(1));
150 EXPECT_EQ(absl::Uniform<int>(absl::IntervalClosedOpen, gen, 1, 1), 1);
151 }
152
TEST(ValidatedMockUniformDeathTest,Examples)153 TEST(ValidatedMockUniformDeathTest, Examples) {
154 absl::MockingBitGen gen;
155
156 EXPECT_DEATH_IF_SUPPORTED(
157 {
158 EXPECT_CALL(absl::MockUniform<int>(), Call(gen, 1, 100))
159 .WillOnce(Return(0));
160 absl::Uniform<int>(gen, 1, 100);
161 },
162 " 0 is not in \\[1, 100\\)");
163 EXPECT_DEATH_IF_SUPPORTED(
164 {
165 EXPECT_CALL(absl::MockUniform<int>(), Call(gen, 1, 100))
166 .WillOnce(Return(101));
167 absl::Uniform<int>(gen, 1, 100);
168 },
169 " 101 is not in \\[1, 100\\)");
170 EXPECT_DEATH_IF_SUPPORTED(
171 {
172 EXPECT_CALL(absl::MockUniform<int>(), Call(gen, 1, 100))
173 .WillOnce(Return(100));
174 absl::Uniform<int>(gen, 1, 100);
175 },
176 " 100 is not in \\[1, 100\\)");
177
178 EXPECT_DEATH_IF_SUPPORTED(
179 {
180 EXPECT_CALL(absl::MockUniform<int>(),
181 Call(absl::IntervalOpen, gen, 1, 100))
182 .WillOnce(Return(1));
183 absl::Uniform<int>(absl::IntervalOpen, gen, 1, 100);
184 },
185 " 1 is not in \\(1, 100\\)");
186 EXPECT_DEATH_IF_SUPPORTED(
187 {
188 EXPECT_CALL(absl::MockUniform<int>(),
189 Call(absl::IntervalOpen, gen, 1, 100))
190 .WillOnce(Return(101));
191 absl::Uniform<int>(absl::IntervalOpen, gen, 1, 100);
192 },
193 " 101 is not in \\(1, 100\\)");
194 EXPECT_DEATH_IF_SUPPORTED(
195 {
196 EXPECT_CALL(absl::MockUniform<int>(),
197 Call(absl::IntervalOpen, gen, 1, 100))
198 .WillOnce(Return(100));
199 absl::Uniform<int>(absl::IntervalOpen, gen, 1, 100);
200 },
201 " 100 is not in \\(1, 100\\)");
202
203 EXPECT_DEATH_IF_SUPPORTED(
204 {
205 EXPECT_CALL(absl::MockUniform<int>(),
206 Call(absl::IntervalOpenClosed, gen, 1, 100))
207 .WillOnce(Return(1));
208 absl::Uniform<int>(absl::IntervalOpenClosed, gen, 1, 100);
209 },
210 " 1 is not in \\(1, 100\\]");
211 EXPECT_DEATH_IF_SUPPORTED(
212 {
213 EXPECT_CALL(absl::MockUniform<int>(),
214 Call(absl::IntervalOpenClosed, gen, 1, 100))
215 .WillOnce(Return(101));
216 absl::Uniform<int>(absl::IntervalOpenClosed, gen, 1, 100);
217 },
218 " 101 is not in \\(1, 100\\]");
219
220 EXPECT_DEATH_IF_SUPPORTED(
221 {
222 EXPECT_CALL(absl::MockUniform<int>(),
223 Call(absl::IntervalOpenClosed, gen, 1, 100))
224 .WillOnce(Return(0));
225 absl::Uniform<int>(absl::IntervalOpenClosed, gen, 1, 100);
226 },
227 " 0 is not in \\(1, 100\\]");
228 EXPECT_DEATH_IF_SUPPORTED(
229 {
230 EXPECT_CALL(absl::MockUniform<int>(),
231 Call(absl::IntervalOpenClosed, gen, 1, 100))
232 .WillOnce(Return(101));
233 absl::Uniform<int>(absl::IntervalOpenClosed, gen, 1, 100);
234 },
235 " 101 is not in \\(1, 100\\]");
236
237 EXPECT_DEATH_IF_SUPPORTED(
238 {
239 EXPECT_CALL(absl::MockUniform<int>(),
240 Call(absl::IntervalClosed, gen, 1, 100))
241 .WillOnce(Return(0));
242 absl::Uniform<int>(absl::IntervalClosed, gen, 1, 100);
243 },
244 " 0 is not in \\[1, 100\\]");
245 EXPECT_DEATH_IF_SUPPORTED(
246 {
247 EXPECT_CALL(absl::MockUniform<int>(),
248 Call(absl::IntervalClosed, gen, 1, 100))
249 .WillOnce(Return(101));
250 absl::Uniform<int>(absl::IntervalClosed, gen, 1, 100);
251 },
252 " 101 is not in \\[1, 100\\]");
253 }
254
TEST(ValidatedMockUniformDeathTest,DoubleBoundaryCases)255 TEST(ValidatedMockUniformDeathTest, DoubleBoundaryCases) {
256 absl::MockingBitGen gen;
257
258 EXPECT_DEATH_IF_SUPPORTED(
259 {
260 EXPECT_CALL(absl::MockUniform<double>(), Call(gen, 1.0, 10.0))
261 .WillOnce(Return(10.0));
262 EXPECT_EQ(absl::Uniform<double>(gen, 1.0, 10.0), 10.0);
263 },
264 " 10 is not in \\[1, 10\\)");
265
266 EXPECT_DEATH_IF_SUPPORTED(
267 {
268 EXPECT_CALL(absl::MockUniform<double>(),
269 Call(absl::IntervalOpen, gen, 1.0, 10.0))
270 .WillOnce(Return(10.0));
271 EXPECT_EQ(absl::Uniform<double>(absl::IntervalOpen, gen, 1.0, 10.0),
272 10.0);
273 },
274 " 10 is not in \\(1, 10\\)");
275
276 EXPECT_DEATH_IF_SUPPORTED(
277 {
278 EXPECT_CALL(absl::MockUniform<double>(),
279 Call(absl::IntervalOpen, gen, 1.0, 10.0))
280 .WillOnce(Return(1.0));
281 EXPECT_EQ(absl::Uniform<double>(absl::IntervalOpen, gen, 1.0, 10.0),
282 1.0);
283 },
284 " 1 is not in \\(1, 10\\)");
285 }
286
287 } // namespace
288