abseil-cpp/absl/random/mocking_bit_gen_test.cc
Go to the documentation of this file.
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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
testing::StrictMock
Definition: bloaty/third_party/googletest/googlemock/include/gmock/gmock-nice-strict.h:148
begin
char * begin
Definition: abseil-cpp/absl/strings/internal/str_format/float_conversion.cc:1007
testing::Return
internal::ReturnAction< R > Return(R value)
Definition: bloaty/third_party/googletest/googlemock/include/gmock/gmock-actions.h:1004
testing::Ne
internal::NeMatcher< Rhs > Ne(Rhs x)
Definition: cares/cares/test/gmock-1.8.0/gmock/gmock.h:8609
absl::MockingBitGen
Definition: abseil-cpp/absl/random/mocking_bit_gen.h:104
elem
Timer elem
Definition: event_engine/iomgr_event_engine/timer_heap_test.cc:109
u
OPENSSL_EXPORT pem_password_cb void * u
Definition: pem.h:351
EXPECT_EQ
#define EXPECT_EQ(a, b)
Definition: iomgr/time_averaged_stats_test.cc:27
testing::NiceMock
Definition: bloaty/third_party/googletest/googlemock/include/gmock/gmock-nice-strict.h:72
end
char * end
Definition: abseil-cpp/absl/strings/internal/str_format/float_conversion.cc:1008
TEST
#define TEST(name, init_size,...)
Definition: arena_test.cc:75
EXPECT_NE
#define EXPECT_NE(val1, val2)
Definition: bloaty/third_party/googletest/googletest/include/gtest/gtest.h:2028
testing::InSequence
Definition: cares/cares/test/gmock-1.8.0/gmock/gmock.h:9838
benchmarks.python.py_benchmark.results
list results
Definition: bloaty/third_party/protobuf/benchmarks/python/py_benchmark.py:145
gmock_output_test._
_
Definition: bloaty/third_party/googletest/googlemock/test/gmock_output_test.py:175
absl::BitGenRef
Definition: abseil-cpp/absl/random/bit_gen_ref.h:87
gen
OPENSSL_EXPORT GENERAL_NAME * gen
Definition: x509v3.h:495
EXPECT_CALL
#define EXPECT_CALL(obj, call)
ON_CALL
#define ON_CALL(obj, call)
testing::NaggyMock
Definition: bloaty/third_party/googletest/googlemock/include/gmock/gmock-nice-strict.h:110
testing::_
const internal::AnythingMatcher _
Definition: cares/cares/test/gmock-1.8.0/gmock/gmock.h:8548
get_value
int get_value(single_dict d[], unsigned size, const char *str)
tests.unit._server_ssl_cert_config_test.Call
Call
Definition: _server_ssl_cert_config_test.py:70
fix_build_deps.r
r
Definition: fix_build_deps.py:491
EXPECT_LT
#define EXPECT_LT(val1, val2)
Definition: bloaty/third_party/googletest/googletest/include/gtest/gtest.h:2032
accumulate
static void accumulate(upb_pb_encoder *e)
Definition: bloaty/third_party/protobuf/php/ext/google/protobuf/upb.c:7694
values
std::array< int64_t, Size > values
Definition: abseil-cpp/absl/container/btree_benchmark.cc:608
absl::random_internal::MockOverloadSet
Definition: abseil-cpp/absl/random/internal/mock_overload_set.h:82
EXPECT_NONFATAL_FAILURE
#define EXPECT_NONFATAL_FAILURE(statement, substr)
i
uint64_t i
Definition: abseil-cpp/absl/container/btree_benchmark.cc:230
absl::Bernoulli
bool Bernoulli(URBG &&urbg, double p)
Definition: abseil-cpp/absl/random/distributions.h:241
absl::Uniform
absl::enable_if_t<!std::is_same< R, void >::value, R > Uniform(TagType tag, URBG &&urbg, R lo, R hi)
Definition: abseil-cpp/absl/random/distributions.h:123

grpc
Author(s):
autogenerated on Fri May 16 2025 02:59:30