mocking_bit_gen_test.cc (13646B)
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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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