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