mdebray/tvl-depot
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Export of internal Abseil changes

Browse source 
--
d3a10a071226497cd34be0f41cb55449193b7172 by Andy Soffer <asoffer@google.com>:

Removing formatting traits that were only used internally. ON_CALL/EXPECT_CALL do a sufficient job here.

PiperOrigin-RevId: 288342973

--
df8180038ea36a0876a84fdc163d1319a611f9db by Greg Falcon <gfalcon@google.com>:

Add CI testing for alternate options.h settings.

PiperOrigin-RevId: 288323951
GitOrigin-RevId: d3a10a071226497cd34be0f41cb55449193b7172
Change-Id: I26c75a1ededd52dd2c5a4c50e220d0b8a52d5c7c
This commit is contained in:
Abseil Team 2020-01-06 11:41:27 -08:00 committed by Derek Mauro
parent 1de0166368
commit a048203a88
15 changed files with 72 additions and 385 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
absl/random/BUILD.bazel
View file

@ -53,7 +53,6 @@ cc_library(
"bernoulli_distribution.h",
"beta_distribution.h",
"discrete_distribution.h",
"distribution_format_traits.h",
"distributions.h",
"exponential_distribution.h",
"gaussian_distribution.h",

2
absl/random/CMakeLists.txt
View file

@ -78,7 +78,6 @@ absl_cc_library(
${ABSL_DEFAULT_LINKOPTS}
DEPS
absl::random_random
absl::strings
)
# Internal-only target, do not depend on directly.
@ -168,7 +167,6 @@ absl_cc_library(
"bernoulli_distribution.h"
"beta_distribution.h"
"discrete_distribution.h"
"distribution_format_traits.h"
"distributions.h"
"exponential_distribution.h"
"gaussian_distribution.h"

5
absl/random/bit_gen_ref.h
View file

@ -132,7 +132,7 @@ namespace random_internal {
template <>
struct DistributionCaller<absl::BitGenRef> {
template <typename DistrT, typename FormatT, typename... Args>
template <typename DistrT, typename... Args>
static typename DistrT::result_type Call(absl::BitGenRef* gen_ref,
Args&&... args) {
auto* mock_ptr = gen_ref->mocked_gen_ptr_;
@ -140,8 +140,7 @@ struct DistributionCaller<absl::BitGenRef> {
DistrT dist(std::forward<Args>(args)...);
return dist(*gen_ref);
} else {
return mock_ptr->template Call<DistrT, FormatT>(
std::forward<Args>(args)...);
return mock_ptr->template Call<DistrT>(std::forward<Args>(args)...);
}
}
};

278
absl/random/distribution_format_traits.h
View file

@ -1,278 +0,0 @@
//
// 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.
//
#ifndef ABSL_RANDOM_DISTRIBUTION_FORMAT_TRAITS_H_
#define ABSL_RANDOM_DISTRIBUTION_FORMAT_TRAITS_H_
#include <string>
#include <tuple>
#include <typeinfo>
#include "absl/meta/type_traits.h"
#include "absl/random/bernoulli_distribution.h"
#include "absl/random/beta_distribution.h"
#include "absl/random/exponential_distribution.h"
#include "absl/random/gaussian_distribution.h"
#include "absl/random/log_uniform_int_distribution.h"
#include "absl/random/poisson_distribution.h"
#include "absl/random/uniform_int_distribution.h"
#include "absl/random/uniform_real_distribution.h"
#include "absl/random/zipf_distribution.h"
#include "absl/strings/str_cat.h"
#include "absl/strings/str_join.h"
#include "absl/strings/string_view.h"
#include "absl/types/span.h"
namespace absl {
ABSL_NAMESPACE_BEGIN
struct IntervalClosedClosedTag;
struct IntervalClosedOpenTag;
struct IntervalOpenClosedTag;
struct IntervalOpenOpenTag;
namespace random_internal {
// ScalarTypeName defines a preferred hierarchy of preferred type names for
// scalars, and is evaluated at compile time for the specific type
// specialization.
template <typename T>
constexpr const char* ScalarTypeName() {
static_assert(std::is_integral<T>() || std::is_floating_point<T>(), "");
// clang-format off
return
std::is_same<T, float>::value ? "float" :
std::is_same<T, double>::value ? "double" :
std::is_same<T, long double>::value ? "long double" :
std::is_same<T, bool>::value ? "bool" :
std::is_signed<T>::value && sizeof(T) == 1 ? "int8_t" :
std::is_signed<T>::value && sizeof(T) == 2 ? "int16_t" :
std::is_signed<T>::value && sizeof(T) == 4 ? "int32_t" :
std::is_signed<T>::value && sizeof(T) == 8 ? "int64_t" :
std::is_unsigned<T>::value && sizeof(T) == 1 ? "uint8_t" :
std::is_unsigned<T>::value && sizeof(T) == 2 ? "uint16_t" :
std::is_unsigned<T>::value && sizeof(T) == 4 ? "uint32_t" :
std::is_unsigned<T>::value && sizeof(T) == 8 ? "uint64_t" :
"undefined";
// clang-format on
// NOTE: It would be nice to use typeid(T).name(), but that's an
// implementation-defined attribute which does not necessarily
// correspond to a name. We could potentially demangle it
// using, e.g. abi::__cxa_demangle.
}
// Distribution traits used by DistributionCaller and internal implementation
// details of the mocking framework.
/*
struct DistributionFormatTraits {
// Returns the parameterized name of the distribution function.
static constexpr const char* FunctionName()
// Format DistrT parameters.
static std::string FormatArgs(DistrT& dist);
// Format DistrT::result_type results.
static std::string FormatResults(DistrT& dist);
};
*/
template <typename DistrT>
struct DistributionFormatTraits;
template <typename R>
struct DistributionFormatTraits<absl::uniform_int_distribution<R>> {
using distribution_t = absl::uniform_int_distribution<R>;
using result_t = typename distribution_t::result_type;
static constexpr const char* Name() { return "Uniform"; }
static std::string FunctionName() {
return absl::StrCat(Name(), "<", ScalarTypeName<R>(), ">");
}
static std::string FormatArgs(const distribution_t& d) {
return absl::StrCat("absl::IntervalClosedClosed, ", (d.min)(), ", ",
(d.max)());
}
static std::string FormatResults(absl::Span<const result_t> results) {
return absl::StrJoin(results, ", ");
}
};
template <typename R>
struct DistributionFormatTraits<absl::uniform_real_distribution<R>> {
using distribution_t = absl::uniform_real_distribution<R>;
using result_t = typename distribution_t::result_type;
static constexpr const char* Name() { return "Uniform"; }
static std::string FunctionName() {
return absl::StrCat(Name(), "<", ScalarTypeName<R>(), ">");
}
static std::string FormatArgs(const distribution_t& d) {
return absl::StrCat((d.min)(), ", ", (d.max)());
}
static std::string FormatResults(absl::Span<const result_t> results) {
return absl::StrJoin(results, ", ");
}
};
template <typename R>
struct DistributionFormatTraits<absl::exponential_distribution<R>> {
using distribution_t = absl::exponential_distribution<R>;
using result_t = typename distribution_t::result_type;
static constexpr const char* Name() { return "Exponential"; }
static std::string FunctionName() {
return absl::StrCat(Name(), "<", ScalarTypeName<R>(), ">");
}
static std::string FormatArgs(const distribution_t& d) {
return absl::StrCat(d.lambda());
}
static std::string FormatResults(absl::Span<const result_t> results) {
return absl::StrJoin(results, ", ");
}
};
template <typename R>
struct DistributionFormatTraits<absl::poisson_distribution<R>> {
using distribution_t = absl::poisson_distribution<R>;
using result_t = typename distribution_t::result_type;
static constexpr const char* Name() { return "Poisson"; }
static std::string FunctionName() {
return absl::StrCat(Name(), "<", ScalarTypeName<R>(), ">");
}
static std::string FormatArgs(const distribution_t& d) {
return absl::StrCat(d.mean());
}
static std::string FormatResults(absl::Span<const result_t> results) {
return absl::StrJoin(results, ", ");
}
};
template <>
struct DistributionFormatTraits<absl::bernoulli_distribution> {
using distribution_t = absl::bernoulli_distribution;
using result_t = typename distribution_t::result_type;
static constexpr const char* Name() { return "Bernoulli"; }
static constexpr const char* FunctionName() { return Name(); }
static std::string FormatArgs(const distribution_t& d) {
return absl::StrCat(d.p());
}
static std::string FormatResults(absl::Span<const result_t> results) {
return absl::StrJoin(results, ", ");
}
};
template <typename R>
struct DistributionFormatTraits<absl::beta_distribution<R>> {
using distribution_t = absl::beta_distribution<R>;
using result_t = typename distribution_t::result_type;
static constexpr const char* Name() { return "Beta"; }
static std::string FunctionName() {
return absl::StrCat(Name(), "<", ScalarTypeName<R>(), ">");
}
static std::string FormatArgs(const distribution_t& d) {
return absl::StrCat(d.alpha(), ", ", d.beta());
}
static std::string FormatResults(absl::Span<const result_t> results) {
return absl::StrJoin(results, ", ");
}
};
template <typename R>
struct DistributionFormatTraits<absl::zipf_distribution<R>> {
using distribution_t = absl::zipf_distribution<R>;
using result_t = typename distribution_t::result_type;
static constexpr const char* Name() { return "Zipf"; }
static std::string FunctionName() {
return absl::StrCat(Name(), "<", ScalarTypeName<R>(), ">");
}
static std::string FormatArgs(const distribution_t& d) {
return absl::StrCat(d.k(), ", ", d.v(), ", ", d.q());
}
static std::string FormatResults(absl::Span<const result_t> results) {
return absl::StrJoin(results, ", ");
}
};
template <typename R>
struct DistributionFormatTraits<absl::gaussian_distribution<R>> {
using distribution_t = absl::gaussian_distribution<R>;
using result_t = typename distribution_t::result_type;
static constexpr const char* Name() { return "Gaussian"; }
static std::string FunctionName() {
return absl::StrCat(Name(), "<", ScalarTypeName<R>(), ">");
}
static std::string FormatArgs(const distribution_t& d) {
return absl::StrJoin(std::make_tuple(d.mean(), d.stddev()), ", ");
}
static std::string FormatResults(absl::Span<const result_t> results) {
return absl::StrJoin(results, ", ");
}
};
template <typename R>
struct DistributionFormatTraits<absl::log_uniform_int_distribution<R>> {
using distribution_t = absl::log_uniform_int_distribution<R>;
using result_t = typename distribution_t::result_type;
static constexpr const char* Name() { return "LogUniform"; }
static std::string FunctionName() {
return absl::StrCat(Name(), "<", ScalarTypeName<R>(), ">");
}
static std::string FormatArgs(const distribution_t& d) {
return absl::StrJoin(std::make_tuple((d.min)(), (d.max)(), d.base()), ", ");
}
static std::string FormatResults(absl::Span<const result_t> results) {
return absl::StrJoin(results, ", ");
}
};
template <typename NumType>
struct UniformDistributionWrapper;
template <typename NumType>
struct DistributionFormatTraits<UniformDistributionWrapper<NumType>> {
using distribution_t = UniformDistributionWrapper<NumType>;
using result_t = NumType;
static constexpr const char* Name() { return "Uniform"; }
static std::string FunctionName() {
return absl::StrCat(Name(), "<", ScalarTypeName<NumType>(), ">");
}
static std::string FormatArgs(const distribution_t& d) {
return absl::StrCat((d.min)(), ", ", (d.max)());
}
static std::string FormatResults(absl::Span<const result_t> results) {
return absl::StrJoin(results, ", ");
}
};
} // namespace random_internal
ABSL_NAMESPACE_END
} // namespace absl
#endif // ABSL_RANDOM_DISTRIBUTION_FORMAT_TRAITS_H_

41
absl/random/distributions.h
View file

@ -55,7 +55,6 @@
#include "absl/base/internal/inline_variable.h"
#include "absl/random/bernoulli_distribution.h"
#include "absl/random/beta_distribution.h"
#include "absl/random/distribution_format_traits.h"
#include "absl/random/exponential_distribution.h"
#include "absl/random/gaussian_distribution.h"
#include "absl/random/internal/distributions.h" // IWYU pragma: export
@ -126,14 +125,13 @@ Uniform(TagType tag,
R lo, R hi) {
using gen_t = absl::decay_t<URBG>;
using distribution_t = random_internal::UniformDistributionWrapper<R>;
using format_t = random_internal::DistributionFormatTraits<distribution_t>;
auto a = random_internal::uniform_lower_bound(tag, lo, hi);
auto b = random_internal::uniform_upper_bound(tag, lo, hi);
if (a > b) return a;
return random_internal::DistributionCaller<gen_t>::template Call<
distribution_t, format_t>(&urbg, tag, lo, hi);
distribution_t>(&urbg, tag, lo, hi);
}
// absl::Uniform<T>(bitgen, lo, hi)
@ -146,7 +144,6 @@ Uniform(URBG&& urbg, // NOLINT(runtime/references)
R lo, R hi) {
using gen_t = absl::decay_t<URBG>;
using distribution_t = random_internal::UniformDistributionWrapper<R>;
using format_t = random_internal::DistributionFormatTraits<distribution_t>;
constexpr auto tag = absl::IntervalClosedOpen;
auto a = random_internal::uniform_lower_bound(tag, lo, hi);
@ -154,7 +151,7 @@ Uniform(URBG&& urbg, // NOLINT(runtime/references)
if (a > b) return a;
return random_internal::DistributionCaller<gen_t>::template Call<
distribution_t, format_t>(&urbg, lo, hi);
distribution_t>(&urbg, lo, hi);
}
// absl::Uniform(tag, bitgen, lo, hi)
@ -172,15 +169,14 @@ Uniform(TagType tag,
using gen_t = absl::decay_t<URBG>;
using return_t = typename random_internal::uniform_inferred_return_t<A, B>;
using distribution_t = random_internal::UniformDistributionWrapper<return_t>;
using format_t = random_internal::DistributionFormatTraits<distribution_t>;
auto a = random_internal::uniform_lower_bound<return_t>(tag, lo, hi);
auto b = random_internal::uniform_upper_bound<return_t>(tag, lo, hi);
if (a > b) return a;
return random_internal::DistributionCaller<gen_t>::template Call<
distribution_t, format_t>(&urbg, tag, static_cast<return_t>(lo),
static_cast<return_t>(hi));
distribution_t>(&urbg, tag, static_cast<return_t>(lo),
static_cast<return_t>(hi));
}
// absl::Uniform(bitgen, lo, hi)
@ -196,7 +192,6 @@ Uniform(URBG&& urbg, // NOLINT(runtime/references)
using gen_t = absl::decay_t<URBG>;
using return_t = typename random_internal::uniform_inferred_return_t<A, B>;
using distribution_t = random_internal::UniformDistributionWrapper<return_t>;
using format_t = random_internal::DistributionFormatTraits<distribution_t>;
constexpr auto tag = absl::IntervalClosedOpen;
auto a = random_internal::uniform_lower_bound<return_t>(tag, lo, hi);
@ -204,8 +199,8 @@ Uniform(URBG&& urbg, // NOLINT(runtime/references)
if (a > b) return a;
return random_internal::DistributionCaller<gen_t>::template Call<
distribution_t, format_t>(&urbg, static_cast<return_t>(lo),
static_cast<return_t>(hi));
distribution_t>(&urbg, static_cast<return_t>(lo),
static_cast<return_t>(hi));
}
// absl::Uniform<unsigned T>(bitgen)
@ -217,10 +212,9 @@ typename absl::enable_if_t<!std::is_signed<R>::value, R> //
Uniform(URBG&& urbg) { // NOLINT(runtime/references)
using gen_t = absl::decay_t<URBG>;
using distribution_t = random_internal::UniformDistributionWrapper<R>;
using format_t = random_internal::DistributionFormatTraits<distribution_t>;
return random_internal::DistributionCaller<gen_t>::template Call<
distribution_t, format_t>(&urbg);
distribution_t>(&urbg);
}
// -----------------------------------------------------------------------------
@ -248,10 +242,9 @@ bool Bernoulli(URBG&& urbg, // NOLINT(runtime/references)
double p) {
using gen_t = absl::decay_t<URBG>;
using distribution_t = absl::bernoulli_distribution;
using format_t = random_internal::DistributionFormatTraits<distribution_t>;
return random_internal::DistributionCaller<gen_t>::template Call<
distribution_t, format_t>(&urbg, p);
distribution_t>(&urbg, p);
}
// -----------------------------------------------------------------------------
@ -281,10 +274,9 @@ RealType Beta(URBG&& urbg, // NOLINT(runtime/references)
using gen_t = absl::decay_t<URBG>;
using distribution_t = typename absl::beta_distribution<RealType>;
using format_t = random_internal::DistributionFormatTraits<distribution_t>;
return random_internal::DistributionCaller<gen_t>::template Call<
distribution_t, format_t>(&urbg, alpha, beta);
distribution_t>(&urbg, alpha, beta);
}
// -----------------------------------------------------------------------------
@ -314,10 +306,9 @@ RealType Exponential(URBG&& urbg, // NOLINT(runtime/references)
using gen_t = absl::decay_t<URBG>;
using distribution_t = typename absl::exponential_distribution<RealType>;
using format_t = random_internal::DistributionFormatTraits<distribution_t>;
return random_internal::DistributionCaller<gen_t>::template Call<
distribution_t, format_t>(&urbg, lambda);
distribution_t>(&urbg, lambda);
}
// -----------------------------------------------------------------------------
@ -346,10 +337,9 @@ RealType Gaussian(URBG&& urbg, // NOLINT(runtime/references)
using gen_t = absl::decay_t<URBG>;
using distribution_t = typename absl::gaussian_distribution<RealType>;
using format_t = random_internal::DistributionFormatTraits<distribution_t>;
return random_internal::DistributionCaller<gen_t>::template Call<
distribution_t, format_t>(&urbg, mean, stddev);
distribution_t>(&urbg, mean, stddev);
}
// -----------------------------------------------------------------------------
@ -389,10 +379,9 @@ IntType LogUniform(URBG&& urbg, // NOLINT(runtime/references)
using gen_t = absl::decay_t<URBG>;
using distribution_t = typename absl::log_uniform_int_distribution<IntType>;
using format_t = random_internal::DistributionFormatTraits<distribution_t>;
return random_internal::DistributionCaller<gen_t>::template Call<
distribution_t, format_t>(&urbg, lo, hi, base);
distribution_t>(&urbg, lo, hi, base);
}
// -----------------------------------------------------------------------------
@ -420,10 +409,9 @@ IntType Poisson(URBG&& urbg, // NOLINT(runtime/references)
using gen_t = absl::decay_t<URBG>;
using distribution_t = typename absl::poisson_distribution<IntType>;
using format_t = random_internal::DistributionFormatTraits<distribution_t>;
return random_internal::DistributionCaller<gen_t>::template Call<
distribution_t, format_t>(&urbg, mean);
distribution_t>(&urbg, mean);
}
// -----------------------------------------------------------------------------
@ -453,10 +441,9 @@ IntType Zipf(URBG&& urbg, // NOLINT(runtime/references)
using gen_t = absl::decay_t<URBG>;
using distribution_t = typename absl::zipf_distribution<IntType>;
using format_t = random_internal::DistributionFormatTraits<distribution_t>;
return random_internal::DistributionCaller<gen_t>::template Call<
distribution_t, format_t>(&urbg, hi, q, v);
distribution_t>(&urbg, hi, q, v);
}
ABSL_NAMESPACE_END

1
absl/random/internal/BUILD.bazel
View file

@ -509,7 +509,6 @@ cc_library(
linkopts = ABSL_DEFAULT_LINKOPTS,
deps = [
"//absl/random",
"//absl/strings",
],
)

18
absl/random/internal/distribution_caller.h
View file

@ -31,22 +31,8 @@ namespace random_internal {
template <typename URBG>
struct DistributionCaller {
// Call the provided distribution type. The parameters are expected
// to be explicitly specified.
// DistrT is the distribution type.
// FormatT is the formatter type:
//
// struct FormatT {
// using result_type = distribution_t::result_type;
// static std::string FormatCall(
// const distribution_t& distr,
// absl::Span<const result_type>);
//
// static std::string FormatExpectation(
// absl::string_view match_args,
// absl::Span<const result_t> results);
// }
//
template <typename DistrT, typename FormatT, typename... Args>
// to be explicitly specified. DistrT is the distribution type.
template <typename DistrT, typename... Args>
static typename DistrT::result_type Call(URBG* urbg, Args&&... args) {
DistrT dist(std::forward<Args>(args)...);
return dist(*urbg);

42
absl/random/internal/mocking_bit_gen_base.h
View file

@ -16,39 +16,14 @@
#ifndef ABSL_RANDOM_INTERNAL_MOCKING_BIT_GEN_BASE_H_
#define ABSL_RANDOM_INTERNAL_MOCKING_BIT_GEN_BASE_H_
#include <atomic>
#include <deque>
#include <string>
#include <typeinfo>
#include "absl/random/random.h"
#include "absl/strings/str_cat.h"
namespace absl {
ABSL_NAMESPACE_BEGIN
namespace random_internal {
// MockingBitGenExpectationFormatter is invoked to format unsatisfied mocks
// and remaining results into a description string.
template <typename DistrT, typename FormatT>
struct MockingBitGenExpectationFormatter {
std::string operator()(absl::string_view args) {
return absl::StrCat(FormatT::FunctionName(), "(", args, ")");
}
};
// MockingBitGenCallFormatter is invoked to format each distribution call
// into a description string for the mock log.
template <typename DistrT, typename FormatT>
struct MockingBitGenCallFormatter {
std::string operator()(const DistrT& dist,
const typename DistrT::result_type& result) {
return absl::StrCat(
FormatT::FunctionName(), "(", FormatT::FormatArgs(dist), ") => {",
FormatT::FormatResults(absl::MakeSpan(&result, 1)), "}");
}
};
class MockingBitGenBase {
template <typename>
friend struct DistributionCaller;
@ -61,14 +36,9 @@ class MockingBitGenBase {
static constexpr result_type(max)() { return (generator_type::max)(); }
result_type operator()() { return gen_(); }
MockingBitGenBase() : gen_(), observed_call_log_() {}
virtual ~MockingBitGenBase() = default;
protected:
const std::deque<std::string>& observed_call_log() {
return observed_call_log_;
}
// CallImpl is the type-erased virtual dispatch.
// The type of dist is always distribution<T>,
// The type of result is always distribution<T>::result_type.
@ -81,10 +51,9 @@ class MockingBitGenBase {
}
// Call the generating distribution function.
// Invoked by DistributionCaller<>::Call<DistT, FormatT>.
// Invoked by DistributionCaller<>::Call<DistT>.
// DistT is the distribution type.
// FormatT is the distribution formatter traits type.
template <typename DistrT, typename FormatT, typename... Args>
template <typename DistrT, typename... Args>
typename DistrT::result_type Call(Args&&... args) {
using distr_result_type = typename DistrT::result_type;
using ArgTupleT = std::tuple<absl::decay_t<Args>...>;
@ -99,18 +68,11 @@ class MockingBitGenBase {
if (!found_match) {
result = dist(gen_);
}
// TODO(asoffer): Forwarding the args through means we no longer need to
// extract them from the from the distribution in formatter traits. We can
// just StrJoin them.
observed_call_log_.push_back(
MockingBitGenCallFormatter<DistrT, FormatT>{}(dist, result));
return result;
}
private:
generator_type gen_;
std::deque<std::string> observed_call_log_;
}; // namespace random_internal
} // namespace random_internal

1
absl/random/mocking_bit_gen.cc
View file

@ -20,7 +20,6 @@
namespace absl {
ABSL_NAMESPACE_BEGIN
MockingBitGen::~MockingBitGen() {
for (const auto& del : deleters_) {
del();
}

6
absl/random/mocking_bit_gen.h
View file

@ -109,7 +109,7 @@ class MockingBitGen : public absl::random_internal::MockingBitGenBase {
// MockingBitGen::Register
//
// Register<DistrT, FormatT, ArgTupleT> is the main extension point for
// Register<DistrT, ArgTupleT> is the main extension point for
// extending the MockingBitGen framework. It provides a mechanism to install a
// mock expectation for the distribution `distr_t` onto the MockingBitGen
// context.
@ -182,10 +182,10 @@ namespace random_internal {
template <>
struct DistributionCaller<absl::MockingBitGen> {
template <typename DistrT, typename FormatT, typename... Args>
template <typename DistrT, typename... Args>
static typename DistrT::result_type Call(absl::MockingBitGen* gen,
Args&&... args) {
return gen->template Call<DistrT, FormatT>(std::forward<Args>(args)...);
return gen->template Call<DistrT>(std::forward<Args>(args)...);
}
};

1
absl/strings/BUILD.bazel
View file

@ -412,6 +412,7 @@ cc_test(
copts = ABSL_TEST_COPTS,
visibility = ["//visibility:private"],
deps = [
":internal",
":pow10_helper",
":strings",
"//absl/base:config",

1
absl/strings/CMakeLists.txt
View file

@ -275,6 +275,7 @@ absl_cc_test(
${ABSL_TEST_COPTS}
DEPS
absl::strings
absl::strings_internal
absl::core_headers
absl::pow10_helper
absl::config

1
absl/strings/numbers_test.cc
View file

@ -40,6 +40,7 @@
#include "absl/random/distributions.h"
#include "absl/random/random.h"
#include "absl/strings/internal/numbers_test_common.h"
#include "absl/strings/internal/ostringstream.h"
#include "absl/strings/internal/pow10_helper.h"
#include "absl/strings/str_cat.h"

27
ci/absl_types_options.h Normal file
View file

@ -0,0 +1,27 @@
#ifndef ABSL_BASE_OPTIONS_H_
#define ABSL_BASE_OPTIONS_H_
// Copyright 2019 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.
// Alternate options.h file, requesting to always use Abseil implementations
// of the workalike types, regardless of language version.
#define ABSL_OPTION_USE_STD_ANY 0
#define ABSL_OPTION_USE_STD_OPTIONAL 0
#define ABSL_OPTION_USE_STD_STRING_VIEW 0
#define ABSL_OPTION_USE_STD_VARIANT 0
#endif // ABSL_BASE_OPTIONS_H_

32
ci/linux_clang-latest_libcxx_bazel.sh
View file

@ -55,7 +55,8 @@ for std in ${STD}; do
for exceptions_mode in ${EXCEPTIONS_MODE}; do
echo "--------------------------------------------------------------------"
time docker run \
--volume="${ABSEIL_ROOT}:/abseil-cpp:ro" \
--volume="${ABSEIL_ROOT}:/abseil-cpp-ro:ro" \
--tmpfs=/abseil-cpp \
--workdir=/abseil-cpp \
--cap-add=SYS_PTRACE \
--rm \
@ -66,18 +67,23 @@ for std in ${STD}; do
-e CPLUS_INCLUDE_PATH="/opt/llvm/libcxx/include/c++/v1" \
${DOCKER_EXTRA_ARGS:-} \
${DOCKER_CONTAINER} \
/usr/local/bin/bazel test ... \
--compilation_mode="${compilation_mode}" \
--copt="${exceptions_mode}" \
--copt=-Werror \
--define="absl=1" \
--keep_going \
--show_timestamps \
--test_env="GTEST_INSTALL_FAILURE_SIGNAL_HANDLER=1" \
--test_env="TZDIR=/abseil-cpp/absl/time/internal/cctz/testdata/zoneinfo" \
--test_output=errors \
--test_tag_filters=-benchmark \
${BAZEL_EXTRA_ARGS:-}
/bin/sh -c "
cp -r /abseil-cpp-ro/* /abseil-cpp/
if [ -n \"${ALTERNATE_OPTIONS:-}\" ]; then
cp ${ALTERNATE_OPTIONS:-} absl/base/options.h || exit 1
fi
/usr/local/bin/bazel test ... \
--compilation_mode=\"${compilation_mode}\" \
--copt=\"${exceptions_mode}\" \
--copt=-Werror \
--define=\"absl=1\" \
--keep_going \
--show_timestamps \
--test_env=\"GTEST_INSTALL_FAILURE_SIGNAL_HANDLER=1\" \
--test_env=\"TZDIR=/abseil-cpp/absl/time/internal/cctz/testdata/zoneinfo\" \
--test_output=errors \
--test_tag_filters=-benchmark \
${BAZEL_EXTRA_ARGS:-}"
done
done
done