1 //
2 // Copyright 2018 The Abseil Authors.
3 //
4 // Licensed under the Apache License, Version 2.0 (the "License");
5 // you may not use this file except in compliance with the License.
6 // You may obtain a copy of the License at
7 //
8 // https://www.apache.org/licenses/LICENSE-2.0
9 //
10 // Unless required by applicable law or agreed to in writing, software
11 // distributed under the License is distributed on an "AS IS" BASIS,
12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 // See the License for the specific language governing permissions and
14 // limitations under the License.
15 //
16 #include "absl/random/mocking_bit_gen.h"
17
18 #include <cmath>
19 #include <numeric>
20 #include <random>
21
22 #include "gmock/gmock.h"
23 #include "gtest/gtest-spi.h"
24 #include "gtest/gtest.h"
25 #include "absl/random/bit_gen_ref.h"
26 #include "absl/random/mock_distributions.h"
27 #include "absl/random/random.h"
28
29 namespace {
30
31 using ::testing::_;
32 using ::testing::Ne;
33 using ::testing::Return;
34
TEST(BasicMocking,AllDistributionsAreOverridable)35 TEST(BasicMocking, AllDistributionsAreOverridable) {
36 absl::MockingBitGen gen;
37
38 EXPECT_NE(absl::Uniform<int>(gen, 1, 1000000), 20);
39 EXPECT_CALL(absl::MockUniform<int>(), Call(gen, 1, 1000000))
40 .WillOnce(Return(20));
41 EXPECT_EQ(absl::Uniform<int>(gen, 1, 1000000), 20);
42
43 EXPECT_NE(absl::Uniform<double>(gen, 0.0, 100.0), 5.0);
44 EXPECT_CALL(absl::MockUniform<double>(), Call(gen, 0.0, 100.0))
45 .WillOnce(Return(5.0));
46 EXPECT_EQ(absl::Uniform<double>(gen, 0.0, 100.0), 5.0);
47
48 EXPECT_NE(absl::Exponential<double>(gen, 1.0), 42);
49 EXPECT_CALL(absl::MockExponential<double>(), Call(gen, 1.0))
50 .WillOnce(Return(42));
51 EXPECT_EQ(absl::Exponential<double>(gen, 1.0), 42);
52
53 EXPECT_NE(absl::Poisson<int>(gen, 1.0), 500);
54 EXPECT_CALL(absl::MockPoisson<int>(), Call(gen, 1.0)).WillOnce(Return(500));
55 EXPECT_EQ(absl::Poisson<int>(gen, 1.0), 500);
56
57 EXPECT_NE(absl::Bernoulli(gen, 0.000001), true);
58 EXPECT_CALL(absl::MockBernoulli(), Call(gen, 0.000001))
59 .WillOnce(Return(true));
60 EXPECT_EQ(absl::Bernoulli(gen, 0.000001), true);
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), 500000);
73 EXPECT_CALL(absl::MockLogUniform<int>(), Call(gen, 0, 1000000, 2))
74 .WillOnce(Return(500000));
75 EXPECT_EQ(absl::LogUniform<int>(gen, 0, 1000000, 2), 500000);
76 }
77
TEST(BasicMocking,OnDistribution)78 TEST(BasicMocking, OnDistribution) {
79 absl::MockingBitGen gen;
80
81 EXPECT_NE(absl::Uniform<int>(gen, 1, 1000000), 20);
82 ON_CALL(absl::MockUniform<int>(), Call(gen, 1, 1000000))
83 .WillByDefault(Return(20));
84 EXPECT_EQ(absl::Uniform<int>(gen, 1, 1000000), 20);
85
86 EXPECT_NE(absl::Uniform<double>(gen, 0.0, 100.0), 5.0);
87 ON_CALL(absl::MockUniform<double>(), Call(gen, 0.0, 100.0))
88 .WillByDefault(Return(5.0));
89 EXPECT_EQ(absl::Uniform<double>(gen, 0.0, 100.0), 5.0);
90
91 EXPECT_NE(absl::Exponential<double>(gen, 1.0), 42);
92 ON_CALL(absl::MockExponential<double>(), Call(gen, 1.0))
93 .WillByDefault(Return(42));
94 EXPECT_EQ(absl::Exponential<double>(gen, 1.0), 42);
95
96 EXPECT_NE(absl::Poisson<int>(gen, 1.0), 500);
97 ON_CALL(absl::MockPoisson<int>(), Call(gen, 1.0)).WillByDefault(Return(500));
98 EXPECT_EQ(absl::Poisson<int>(gen, 1.0), 500);
99
100 EXPECT_NE(absl::Bernoulli(gen, 0.000001), true);
101 ON_CALL(absl::MockBernoulli(), Call(gen, 0.000001))
102 .WillByDefault(Return(true));
103 EXPECT_EQ(absl::Bernoulli(gen, 0.000001), true);
104
105 EXPECT_NE(absl::Zipf<int>(gen, 1000000, 2.0, 1.0), 1221);
106 ON_CALL(absl::MockZipf<int>(), Call(gen, 1000000, 2.0, 1.0))
107 .WillByDefault(Return(1221));
108 EXPECT_EQ(absl::Zipf<int>(gen, 1000000, 2.0, 1.0), 1221);
109
110 EXPECT_NE(absl::Gaussian<double>(gen, 0.0, 1.0), 0.001);
111 ON_CALL(absl::MockGaussian<double>(), Call(gen, 0.0, 1.0))
112 .WillByDefault(Return(0.001));
113 EXPECT_EQ(absl::Gaussian<double>(gen, 0.0, 1.0), 0.001);
114
115 EXPECT_NE(absl::LogUniform<int>(gen, 0, 1000000, 2), 2040);
116 ON_CALL(absl::MockLogUniform<int>(), Call(gen, 0, 1000000, 2))
117 .WillByDefault(Return(2040));
118 EXPECT_EQ(absl::LogUniform<int>(gen, 0, 1000000, 2), 2040);
119 }
120
TEST(BasicMocking,GMockMatchers)121 TEST(BasicMocking, GMockMatchers) {
122 absl::MockingBitGen gen;
123
124 EXPECT_NE(absl::Zipf<int>(gen, 1000000, 2.0, 1.0), 1221);
125 ON_CALL(absl::MockZipf<int>(), Call(gen, 1000000, 2.0, 1.0))
126 .WillByDefault(Return(1221));
127 EXPECT_EQ(absl::Zipf<int>(gen, 1000000, 2.0, 1.0), 1221);
128 }
129
TEST(BasicMocking,OverridesWithMultipleGMockExpectations)130 TEST(BasicMocking, OverridesWithMultipleGMockExpectations) {
131 absl::MockingBitGen gen;
132
133 EXPECT_CALL(absl::MockUniform<int>(), Call(gen, 1, 10000))
134 .WillOnce(Return(20))
135 .WillOnce(Return(40))
136 .WillOnce(Return(60));
137 EXPECT_EQ(absl::Uniform(gen, 1, 10000), 20);
138 EXPECT_EQ(absl::Uniform(gen, 1, 10000), 40);
139 EXPECT_EQ(absl::Uniform(gen, 1, 10000), 60);
140 }
141
TEST(BasicMocking,DefaultArgument)142 TEST(BasicMocking, DefaultArgument) {
143 absl::MockingBitGen gen;
144
145 ON_CALL(absl::MockExponential<double>(), Call(gen, 1.0))
146 .WillByDefault(Return(200));
147
148 EXPECT_EQ(absl::Exponential<double>(gen), 200);
149 EXPECT_EQ(absl::Exponential<double>(gen, 1.0), 200);
150 }
151
TEST(BasicMocking,MultipleGenerators)152 TEST(BasicMocking, MultipleGenerators) {
153 auto get_value = [](absl::BitGenRef gen_ref) {
154 return absl::Uniform(gen_ref, 1, 1000000);
155 };
156 absl::MockingBitGen unmocked_generator;
157 absl::MockingBitGen mocked_with_3;
158 absl::MockingBitGen mocked_with_11;
159
160 EXPECT_CALL(absl::MockUniform<int>(), Call(mocked_with_3, 1, 1000000))
161 .WillOnce(Return(3))
162 .WillRepeatedly(Return(17));
163 EXPECT_CALL(absl::MockUniform<int>(), Call(mocked_with_11, 1, 1000000))
164 .WillOnce(Return(11))
165 .WillRepeatedly(Return(17));
166
167 // Ensure that unmocked generator generates neither value.
168 int unmocked_value = get_value(unmocked_generator);
169 EXPECT_NE(unmocked_value, 3);
170 EXPECT_NE(unmocked_value, 11);
171 // Mocked generators should generate their mocked values.
172 EXPECT_EQ(get_value(mocked_with_3), 3);
173 EXPECT_EQ(get_value(mocked_with_11), 11);
174 // Ensure that the mocks have expired.
175 EXPECT_NE(get_value(mocked_with_3), 3);
176 EXPECT_NE(get_value(mocked_with_11), 11);
177 }
178
TEST(BasicMocking,MocksNotTrigeredForIncorrectTypes)179 TEST(BasicMocking, MocksNotTrigeredForIncorrectTypes) {
180 absl::MockingBitGen gen;
181 EXPECT_CALL(absl::MockUniform<uint32_t>(), Call(gen)).WillOnce(Return(42));
182
183 EXPECT_NE(absl::Uniform<uint16_t>(gen), 42); // Not mocked
184 EXPECT_EQ(absl::Uniform<uint32_t>(gen), 42); // Mock triggered
185 }
186
TEST(BasicMocking,FailsOnUnsatisfiedMocks)187 TEST(BasicMocking, FailsOnUnsatisfiedMocks) {
188 EXPECT_NONFATAL_FAILURE(
189 []() {
190 absl::MockingBitGen gen;
191 EXPECT_CALL(absl::MockExponential<double>(), Call(gen, 1.0))
192 .WillOnce(Return(3.0));
193 // Does not call absl::Exponential().
194 }(),
195 "unsatisfied and active");
196 }
197
TEST(OnUniform,RespectsUniformIntervalSemantics)198 TEST(OnUniform, RespectsUniformIntervalSemantics) {
199 absl::MockingBitGen gen;
200
201 EXPECT_CALL(absl::MockUniform<int>(),
202 Call(absl::IntervalClosed, gen, 1, 1000000))
203 .WillOnce(Return(301));
204 EXPECT_NE(absl::Uniform(gen, 1, 1000000), 301); // Not mocked
205 EXPECT_EQ(absl::Uniform(absl::IntervalClosed, gen, 1, 1000000), 301);
206 }
207
TEST(OnUniform,RespectsNoArgUnsignedShorthand)208 TEST(OnUniform, RespectsNoArgUnsignedShorthand) {
209 absl::MockingBitGen gen;
210 EXPECT_CALL(absl::MockUniform<uint32_t>(), Call(gen)).WillOnce(Return(42));
211 EXPECT_EQ(absl::Uniform<uint32_t>(gen), 42);
212 }
213
TEST(RepeatedlyModifier,ForceSnakeEyesForManyDice)214 TEST(RepeatedlyModifier, ForceSnakeEyesForManyDice) {
215 auto roll_some_dice = [](absl::BitGenRef gen_ref) {
216 std::vector<int> results(16);
217 for (auto& r : results) {
218 r = absl::Uniform(absl::IntervalClosed, gen_ref, 1, 6);
219 }
220 return results;
221 };
222 std::vector<int> results;
223 absl::MockingBitGen gen;
224
225 // Without any mocked calls, not all dice roll a "6".
226 results = roll_some_dice(gen);
227 EXPECT_LT(std::accumulate(std::begin(results), std::end(results), 0),
228 results.size() * 6);
229
230 // Verify that we can force all "6"-rolls, with mocking.
231 ON_CALL(absl::MockUniform<int>(), Call(absl::IntervalClosed, gen, 1, 6))
232 .WillByDefault(Return(6));
233 results = roll_some_dice(gen);
234 EXPECT_EQ(std::accumulate(std::begin(results), std::end(results), 0),
235 results.size() * 6);
236 }
237
TEST(WillOnce,DistinctCounters)238 TEST(WillOnce, DistinctCounters) {
239 absl::MockingBitGen gen;
240 EXPECT_CALL(absl::MockUniform<int>(), Call(gen, 1, 1000000))
241 .Times(3)
242 .WillRepeatedly(Return(0));
243 EXPECT_CALL(absl::MockUniform<int>(), Call(gen, 1000001, 2000000))
244 .Times(3)
245 .WillRepeatedly(Return(1));
246 EXPECT_EQ(absl::Uniform(gen, 1000001, 2000000), 1);
247 EXPECT_EQ(absl::Uniform(gen, 1, 1000000), 0);
248 EXPECT_EQ(absl::Uniform(gen, 1000001, 2000000), 1);
249 EXPECT_EQ(absl::Uniform(gen, 1, 1000000), 0);
250 EXPECT_EQ(absl::Uniform(gen, 1000001, 2000000), 1);
251 EXPECT_EQ(absl::Uniform(gen, 1, 1000000), 0);
252 }
253
TEST(TimesModifier,ModifierSaturatesAndExpires)254 TEST(TimesModifier, ModifierSaturatesAndExpires) {
255 EXPECT_NONFATAL_FAILURE(
256 []() {
257 absl::MockingBitGen gen;
258 EXPECT_CALL(absl::MockUniform<int>(), Call(gen, 1, 1000000))
259 .Times(3)
260 .WillRepeatedly(Return(15))
261 .RetiresOnSaturation();
262
263 EXPECT_EQ(absl::Uniform(gen, 1, 1000000), 15);
264 EXPECT_EQ(absl::Uniform(gen, 1, 1000000), 15);
265 EXPECT_EQ(absl::Uniform(gen, 1, 1000000), 15);
266 // Times(3) has expired - Should get a different value now.
267
268 EXPECT_NE(absl::Uniform(gen, 1, 1000000), 15);
269 }(),
270 "");
271 }
272
TEST(TimesModifier,Times0)273 TEST(TimesModifier, Times0) {
274 absl::MockingBitGen gen;
275 EXPECT_CALL(absl::MockBernoulli(), Call(gen, 0.0)).Times(0);
276 EXPECT_CALL(absl::MockPoisson<int>(), Call(gen, 1.0)).Times(0);
277 }
278
TEST(AnythingMatcher,MatchesAnyArgument)279 TEST(AnythingMatcher, MatchesAnyArgument) {
280 using testing::_;
281
282 {
283 absl::MockingBitGen gen;
284 ON_CALL(absl::MockUniform<int>(), Call(absl::IntervalClosed, gen, _, 1000))
285 .WillByDefault(Return(11));
286 ON_CALL(absl::MockUniform<int>(),
287 Call(absl::IntervalClosed, gen, _, Ne(1000)))
288 .WillByDefault(Return(99));
289
290 EXPECT_EQ(absl::Uniform(absl::IntervalClosed, gen, 10, 1000000), 99);
291 EXPECT_EQ(absl::Uniform(absl::IntervalClosed, gen, 10, 1000), 11);
292 }
293
294 {
295 absl::MockingBitGen gen;
296 ON_CALL(absl::MockUniform<int>(), Call(gen, 1, _))
297 .WillByDefault(Return(25));
298 ON_CALL(absl::MockUniform<int>(), Call(gen, Ne(1), _))
299 .WillByDefault(Return(99));
300 EXPECT_EQ(absl::Uniform(gen, 3, 1000000), 99);
301 EXPECT_EQ(absl::Uniform(gen, 1, 1000000), 25);
302 }
303
304 {
305 absl::MockingBitGen gen;
306 ON_CALL(absl::MockUniform<int>(), Call(gen, _, _))
307 .WillByDefault(Return(145));
308 EXPECT_EQ(absl::Uniform(gen, 1, 1000), 145);
309 EXPECT_EQ(absl::Uniform(gen, 10, 1000), 145);
310 EXPECT_EQ(absl::Uniform(gen, 100, 1000), 145);
311 }
312 }
313
TEST(AnythingMatcher,WithWillByDefault)314 TEST(AnythingMatcher, WithWillByDefault) {
315 using testing::_;
316 absl::MockingBitGen gen;
317 std::vector<int> values = {11, 22, 33, 44, 55, 66, 77, 88, 99, 1010};
318
319 ON_CALL(absl::MockUniform<size_t>(), Call(gen, 0, _))
320 .WillByDefault(Return(0));
321 for (int i = 0; i < 100; i++) {
322 auto& elem = values[absl::Uniform(gen, 0u, values.size())];
323 EXPECT_EQ(elem, 11);
324 }
325 }
326
TEST(BasicMocking,WillByDefaultWithArgs)327 TEST(BasicMocking, WillByDefaultWithArgs) {
328 using testing::_;
329
330 absl::MockingBitGen gen;
331 ON_CALL(absl::MockPoisson<int>(), Call(gen, _))
332 .WillByDefault([](double lambda) {
333 return static_cast<int>(std::rint(lambda * 10));
334 });
335 EXPECT_EQ(absl::Poisson<int>(gen, 1.7), 17);
336 EXPECT_EQ(absl::Poisson<int>(gen, 0.03), 0);
337 }
338
TEST(MockingBitGen,InSequenceSucceedsInOrder)339 TEST(MockingBitGen, InSequenceSucceedsInOrder) {
340 absl::MockingBitGen gen;
341
342 testing::InSequence seq;
343
344 EXPECT_CALL(absl::MockPoisson<int>(), Call(gen, 1.0)).WillOnce(Return(3));
345 EXPECT_CALL(absl::MockPoisson<int>(), Call(gen, 2.0)).WillOnce(Return(4));
346
347 EXPECT_EQ(absl::Poisson<int>(gen, 1.0), 3);
348 EXPECT_EQ(absl::Poisson<int>(gen, 2.0), 4);
349 }
350
TEST(MockingBitGen,NiceMock)351 TEST(MockingBitGen, NiceMock) {
352 ::testing::NiceMock<absl::MockingBitGen> gen;
353 ON_CALL(absl::MockUniform<int>(), Call(gen, _, _)).WillByDefault(Return(145));
354
355 ON_CALL(absl::MockPoisson<int>(), Call(gen, _)).WillByDefault(Return(3));
356
357 EXPECT_EQ(absl::Uniform(gen, 1, 1000), 145);
358 EXPECT_EQ(absl::Uniform(gen, 10, 1000), 145);
359 EXPECT_EQ(absl::Uniform(gen, 100, 1000), 145);
360 }
361
TEST(MockingBitGen,NaggyMock)362 TEST(MockingBitGen, NaggyMock) {
363 // This is difficult to test, as only the output matters, so just verify
364 // that ON_CALL can be installed. Anything else requires log inspection.
365 ::testing::NaggyMock<absl::MockingBitGen> gen;
366
367 ON_CALL(absl::MockUniform<int>(), Call(gen, _, _)).WillByDefault(Return(145));
368 ON_CALL(absl::MockPoisson<int>(), Call(gen, _)).WillByDefault(Return(3));
369
370 EXPECT_EQ(absl::Uniform(gen, 1, 1000), 145);
371 }
372
TEST(MockingBitGen,StrictMock_NotEnough)373 TEST(MockingBitGen, StrictMock_NotEnough) {
374 EXPECT_NONFATAL_FAILURE(
375 []() {
376 ::testing::StrictMock<absl::MockingBitGen> gen;
377 EXPECT_CALL(absl::MockUniform<int>(), Call(gen, _, _))
378 .WillOnce(Return(145));
379 }(),
380 "unsatisfied and active");
381 }
382
TEST(MockingBitGen,StrictMock_TooMany)383 TEST(MockingBitGen, StrictMock_TooMany) {
384 ::testing::StrictMock<absl::MockingBitGen> gen;
385
386 EXPECT_CALL(absl::MockUniform<int>(), Call(gen, _, _)).WillOnce(Return(145));
387 EXPECT_EQ(absl::Uniform(gen, 1, 1000), 145);
388
389 EXPECT_NONFATAL_FAILURE(
390 [&]() { EXPECT_EQ(absl::Uniform(gen, 10, 1000), 0); }(),
391 "over-saturated and active");
392 }
393
394 } // namespace
395