Add 'third_party/abseil_cpp/' from commit '768eb2ca28'
git-subtree-dir: third_party/abseil_cpp git-subtree-mainline:ffb2ae54begit-subtree-split:768eb2ca28
This commit is contained in:
Vincent Ambo
commit
fc8dc48020
1276 changed files with 208196 additions and 0 deletions
261
third_party/abseil_cpp/absl/random/mock_distributions.h
vendored
Normal file
261
third_party/abseil_cpp/absl/random/mock_distributions.h
vendored
Normal file
|
|
@ -0,0 +1,261 @@
|
|||
// Copyright 2018 The Abseil Authors.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// https://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
//
|
||||
// -----------------------------------------------------------------------------
|
||||
// File: mock_distributions.h
|
||||
// -----------------------------------------------------------------------------
|
||||
//
|
||||
// This file contains mock distribution functions for use alongside an
|
||||
// `absl::MockingBitGen` object within the Googletest testing framework. Such
|
||||
// mocks are useful to provide deterministic values as return values within
|
||||
// (otherwise random) Abseil distribution functions.
|
||||
//
|
||||
// The return type of each function is a mock expectation object which
|
||||
// is used to set the match result.
|
||||
//
|
||||
// More information about the Googletest testing framework is available at
|
||||
// https://github.com/google/googletest
|
||||
//
|
||||
// Example:
|
||||
//
|
||||
// absl::MockingBitGen mock;
|
||||
// EXPECT_CALL(absl::MockUniform<int>(), Call(mock, 1, 1000))
|
||||
// .WillRepeatedly(testing::ReturnRoundRobin({20, 40}));
|
||||
//
|
||||
// EXPECT_EQ(absl::Uniform<int>(gen, 1, 1000), 20);
|
||||
// EXPECT_EQ(absl::Uniform<int>(gen, 1, 1000), 40);
|
||||
// EXPECT_EQ(absl::Uniform<int>(gen, 1, 1000), 20);
|
||||
// EXPECT_EQ(absl::Uniform<int>(gen, 1, 1000), 40);
|
||||
|
||||
#ifndef ABSL_RANDOM_MOCK_DISTRIBUTIONS_H_
|
||||
#define ABSL_RANDOM_MOCK_DISTRIBUTIONS_H_
|
||||
|
||||
#include <limits>
|
||||
#include <type_traits>
|
||||
#include <utility>
|
||||
|
||||
#include "gmock/gmock.h"
|
||||
#include "gtest/gtest.h"
|
||||
#include "absl/meta/type_traits.h"
|
||||
#include "absl/random/distributions.h"
|
||||
#include "absl/random/internal/mock_overload_set.h"
|
||||
#include "absl/random/mocking_bit_gen.h"
|
||||
|
||||
namespace absl {
|
||||
ABSL_NAMESPACE_BEGIN
|
||||
|
||||
// -----------------------------------------------------------------------------
|
||||
// absl::MockUniform
|
||||
// -----------------------------------------------------------------------------
|
||||
//
|
||||
// Matches calls to absl::Uniform.
|
||||
//
|
||||
// `absl::MockUniform` is a class template used in conjunction with Googletest's
|
||||
// `ON_CALL()` and `EXPECT_CALL()` macros. To use it, default-construct an
|
||||
// instance of it inside `ON_CALL()` or `EXPECT_CALL()`, and use `Call(...)` the
|
||||
// same way one would define mocks on a Googletest `MockFunction()`.
|
||||
//
|
||||
// Example:
|
||||
//
|
||||
// absl::MockingBitGen mock;
|
||||
// EXPECT_CALL(absl::MockUniform<uint32_t>(), Call(mock))
|
||||
// .WillOnce(Return(123456));
|
||||
// auto x = absl::Uniform<uint32_t>(mock);
|
||||
// assert(x == 123456)
|
||||
//
|
||||
template <typename R>
|
||||
using MockUniform = random_internal::MockOverloadSet<
|
||||
random_internal::UniformDistributionWrapper<R>,
|
||||
R(IntervalClosedOpenTag, MockingBitGen&, R, R),
|
||||
R(IntervalClosedClosedTag, MockingBitGen&, R, R),
|
||||
R(IntervalOpenOpenTag, MockingBitGen&, R, R),
|
||||
R(IntervalOpenClosedTag, MockingBitGen&, R, R), R(MockingBitGen&, R, R),
|
||||
R(MockingBitGen&)>;
|
||||
|
||||
// -----------------------------------------------------------------------------
|
||||
// absl::MockBernoulli
|
||||
// -----------------------------------------------------------------------------
|
||||
//
|
||||
// Matches calls to absl::Bernoulli.
|
||||
//
|
||||
// `absl::MockBernoulli` is a class used in conjunction with Googletest's
|
||||
// `ON_CALL()` and `EXPECT_CALL()` macros. To use it, default-construct an
|
||||
// instance of it inside `ON_CALL()` or `EXPECT_CALL()`, and use `Call(...)` the
|
||||
// same way one would define mocks on a Googletest `MockFunction()`.
|
||||
//
|
||||
// Example:
|
||||
//
|
||||
// absl::MockingBitGen mock;
|
||||
// EXPECT_CALL(absl::MockBernoulli(), Call(mock, testing::_))
|
||||
// .WillOnce(Return(false));
|
||||
// assert(absl::Bernoulli(mock, 0.5) == false);
|
||||
//
|
||||
using MockBernoulli =
|
||||
random_internal::MockOverloadSet<absl::bernoulli_distribution,
|
||||
bool(MockingBitGen&, double)>;
|
||||
|
||||
// -----------------------------------------------------------------------------
|
||||
// absl::MockBeta
|
||||
// -----------------------------------------------------------------------------
|
||||
//
|
||||
// Matches calls to absl::Beta.
|
||||
//
|
||||
// `absl::MockBeta` is a class used in conjunction with Googletest's `ON_CALL()`
|
||||
// and `EXPECT_CALL()` macros. To use it, default-construct an instance of it
|
||||
// inside `ON_CALL()` or `EXPECT_CALL()`, and use `Call(...)` the same way one
|
||||
// would define mocks on a Googletest `MockFunction()`.
|
||||
//
|
||||
// Example:
|
||||
//
|
||||
// absl::MockingBitGen mock;
|
||||
// EXPECT_CALL(absl::MockBeta(), Call(mock, 3.0, 2.0))
|
||||
// .WillOnce(Return(0.567));
|
||||
// auto x = absl::Beta<double>(mock, 3.0, 2.0);
|
||||
// assert(x == 0.567);
|
||||
//
|
||||
template <typename RealType>
|
||||
using MockBeta =
|
||||
random_internal::MockOverloadSet<absl::beta_distribution<RealType>,
|
||||
RealType(MockingBitGen&, RealType,
|
||||
RealType)>;
|
||||
|
||||
// -----------------------------------------------------------------------------
|
||||
// absl::MockExponential
|
||||
// -----------------------------------------------------------------------------
|
||||
//
|
||||
// Matches calls to absl::Exponential.
|
||||
//
|
||||
// `absl::MockExponential` is a class template used in conjunction with
|
||||
// Googletest's `ON_CALL()` and `EXPECT_CALL()` macros. To use it,
|
||||
// default-construct an instance of it inside `ON_CALL()` or `EXPECT_CALL()`,
|
||||
// and use `Call(...)` the same way one would define mocks on a
|
||||
// Googletest `MockFunction()`.
|
||||
//
|
||||
// Example:
|
||||
//
|
||||
// absl::MockingBitGen mock;
|
||||
// EXPECT_CALL(absl::MockExponential<double>(), Call(mock, 0.5))
|
||||
// .WillOnce(Return(12.3456789));
|
||||
// auto x = absl::Exponential<double>(mock, 0.5);
|
||||
// assert(x == 12.3456789)
|
||||
//
|
||||
template <typename RealType>
|
||||
using MockExponential =
|
||||
random_internal::MockOverloadSet<absl::exponential_distribution<RealType>,
|
||||
RealType(MockingBitGen&, RealType)>;
|
||||
|
||||
// -----------------------------------------------------------------------------
|
||||
// absl::MockGaussian
|
||||
// -----------------------------------------------------------------------------
|
||||
//
|
||||
// Matches calls to absl::Gaussian.
|
||||
//
|
||||
// `absl::MockGaussian` is a class template used in conjunction with
|
||||
// Googletest's `ON_CALL()` and `EXPECT_CALL()` macros. To use it,
|
||||
// default-construct an instance of it inside `ON_CALL()` or `EXPECT_CALL()`,
|
||||
// and use `Call(...)` the same way one would define mocks on a
|
||||
// Googletest `MockFunction()`.
|
||||
//
|
||||
// Example:
|
||||
//
|
||||
// absl::MockingBitGen mock;
|
||||
// EXPECT_CALL(absl::MockGaussian<double>(), Call(mock, 16.3, 3.3))
|
||||
// .WillOnce(Return(12.3456789));
|
||||
// auto x = absl::Gaussian<double>(mock, 16.3, 3.3);
|
||||
// assert(x == 12.3456789)
|
||||
//
|
||||
template <typename RealType>
|
||||
using MockGaussian =
|
||||
random_internal::MockOverloadSet<absl::gaussian_distribution<RealType>,
|
||||
RealType(MockingBitGen&, RealType,
|
||||
RealType)>;
|
||||
|
||||
// -----------------------------------------------------------------------------
|
||||
// absl::MockLogUniform
|
||||
// -----------------------------------------------------------------------------
|
||||
//
|
||||
// Matches calls to absl::LogUniform.
|
||||
//
|
||||
// `absl::MockLogUniform` is a class template used in conjunction with
|
||||
// Googletest's `ON_CALL()` and `EXPECT_CALL()` macros. To use it,
|
||||
// default-construct an instance of it inside `ON_CALL()` or `EXPECT_CALL()`,
|
||||
// and use `Call(...)` the same way one would define mocks on a
|
||||
// Googletest `MockFunction()`.
|
||||
//
|
||||
// Example:
|
||||
//
|
||||
// absl::MockingBitGen mock;
|
||||
// EXPECT_CALL(absl::MockLogUniform<int>(), Call(mock, 10, 10000, 10))
|
||||
// .WillOnce(Return(1221));
|
||||
// auto x = absl::LogUniform<int>(mock, 10, 10000, 10);
|
||||
// assert(x == 1221)
|
||||
//
|
||||
template <typename IntType>
|
||||
using MockLogUniform = random_internal::MockOverloadSet<
|
||||
absl::log_uniform_int_distribution<IntType>,
|
||||
IntType(MockingBitGen&, IntType, IntType, IntType)>;
|
||||
|
||||
// -----------------------------------------------------------------------------
|
||||
// absl::MockPoisson
|
||||
// -----------------------------------------------------------------------------
|
||||
//
|
||||
// Matches calls to absl::Poisson.
|
||||
//
|
||||
// `absl::MockPoisson` is a class template used in conjunction with Googletest's
|
||||
// `ON_CALL()` and `EXPECT_CALL()` macros. To use it, default-construct an
|
||||
// instance of it inside `ON_CALL()` or `EXPECT_CALL()`, and use `Call(...)` the
|
||||
// same way one would define mocks on a Googletest `MockFunction()`.
|
||||
//
|
||||
// Example:
|
||||
//
|
||||
// absl::MockingBitGen mock;
|
||||
// EXPECT_CALL(absl::MockPoisson<int>(), Call(mock, 2.0))
|
||||
// .WillOnce(Return(1221));
|
||||
// auto x = absl::Poisson<int>(mock, 2.0);
|
||||
// assert(x == 1221)
|
||||
//
|
||||
template <typename IntType>
|
||||
using MockPoisson =
|
||||
random_internal::MockOverloadSet<absl::poisson_distribution<IntType>,
|
||||
IntType(MockingBitGen&, double)>;
|
||||
|
||||
// -----------------------------------------------------------------------------
|
||||
// absl::MockZipf
|
||||
// -----------------------------------------------------------------------------
|
||||
//
|
||||
// Matches calls to absl::Zipf.
|
||||
//
|
||||
// `absl::MockZipf` is a class template used in conjunction with Googletest's
|
||||
// `ON_CALL()` and `EXPECT_CALL()` macros. To use it, default-construct an
|
||||
// instance of it inside `ON_CALL()` or `EXPECT_CALL()`, and use `Call(...)` the
|
||||
// same way one would define mocks on a Googletest `MockFunction()`.
|
||||
//
|
||||
// Example:
|
||||
//
|
||||
// absl::MockingBitGen mock;
|
||||
// EXPECT_CALL(absl::MockZipf<int>(), Call(mock, 1000000, 2.0, 1.0))
|
||||
// .WillOnce(Return(1221));
|
||||
// auto x = absl::Zipf<int>(mock, 1000000, 2.0, 1.0);
|
||||
// assert(x == 1221)
|
||||
//
|
||||
template <typename IntType>
|
||||
using MockZipf =
|
||||
random_internal::MockOverloadSet<absl::zipf_distribution<IntType>,
|
||||
IntType(MockingBitGen&, IntType, double,
|
||||
double)>;
|
||||
|
||||
ABSL_NAMESPACE_END
|
||||
} // namespace absl
|
||||
|
||||
#endif // ABSL_RANDOM_MOCK_DISTRIBUTIONS_H_
|
||||
Loading…
Add table
Add a link
Reference in a new issue