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