chore(3p/abseil_cpp): unvendor abseil_cpp r/3786

we weren't actually using these sources anymore, okay?

Change-Id: If701571d9716de308d3512e1eb22c35db0877a66
Reviewed-on: https://cl.tvl.fyi/c/depot/+/5248
Tested-by: BuildkiteCI
Reviewed-by: grfn <grfn@gws.fyi>
Autosubmit: tazjin <tazjin@tvl.su>

1 files changed, 0 insertions, 455 deletions

diff --git a/third_party/abseil_cpp/absl/random/distributions_test.cc b/third_party/abseil_cpp/absl/random/distributions_test.cc
deleted file mode 100644
index 5866a07257e5..000000000000
--- a/third_party/abseil_cpp/absl/random/distributions_test.cc
+++ /dev/null
@@ -1,455 +0,0 @@
-// Copyright 2017 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.
-
-#include "absl/random/distributions.h"
-
-#include <cmath>
-#include <cstdint>
-#include <random>
-#include <vector>
-
-#include "gtest/gtest.h"
-#include "absl/random/internal/distribution_test_util.h"
-#include "absl/random/random.h"
-
-namespace {
-
-constexpr int kSize = 400000;
-
-class RandomDistributionsTest : public testing::Test {};
-
-
-struct Invalid {};
-
-template <typename A, typename B>
-auto InferredUniformReturnT(int)
-    -> decltype(absl::Uniform(std::declval<absl::InsecureBitGen&>(),
-                              std::declval<A>(), std::declval<B>()));
-
-template <typename, typename>
-Invalid InferredUniformReturnT(...);
-
-template <typename TagType, typename A, typename B>
-auto InferredTaggedUniformReturnT(int)
-    -> decltype(absl::Uniform(std::declval<TagType>(),
-                              std::declval<absl::InsecureBitGen&>(),
-                              std::declval<A>(), std::declval<B>()));
-
-template <typename, typename, typename>
-Invalid InferredTaggedUniformReturnT(...);
-
-// Given types <A, B, Expect>, CheckArgsInferType() verifies that
-//
-//   absl::Uniform(gen, A{}, B{})
-//
-// returns the type "Expect".
-//
-// This interface can also be used to assert that a given absl::Uniform()
-// overload does not exist / will not compile. Given types <A, B>, the
-// expression
-//
-//   decltype(absl::Uniform(..., std::declval<A>(), std::declval<B>()))
-//
-// will not compile, leaving the definition of InferredUniformReturnT<A, B> to
-// resolve (via SFINAE) to the overload which returns type "Invalid". This
-// allows tests to assert that an invocation such as
-//
-//   absl::Uniform(gen, 1.23f, std::numeric_limits<int>::max() - 1)
-//
-// should not compile, since neither type, float nor int, can precisely
-// represent both endpoint-values. Writing:
-//
-//   CheckArgsInferType<float, int, Invalid>()
-//
-// will assert that this overload does not exist.
-template <typename A, typename B, typename Expect>
-void CheckArgsInferType() {
-  static_assert(
-      absl::conjunction<
-          std::is_same<Expect, decltype(InferredUniformReturnT<A, B>(0))>,
-          std::is_same<Expect,
-                       decltype(InferredUniformReturnT<B, A>(0))>>::value,
-      "");
-  static_assert(
-      absl::conjunction<
-          std::is_same<Expect, decltype(InferredTaggedUniformReturnT<
-                                        absl::IntervalOpenOpenTag, A, B>(0))>,
-          std::is_same<Expect,
-                       decltype(InferredTaggedUniformReturnT<
-                                absl::IntervalOpenOpenTag, B, A>(0))>>::value,
-      "");
-}
-
-template <typename A, typename B, typename ExplicitRet>
-auto ExplicitUniformReturnT(int) -> decltype(
-    absl::Uniform<ExplicitRet>(*std::declval<absl::InsecureBitGen*>(),
-                               std::declval<A>(), std::declval<B>()));
-
-template <typename, typename, typename ExplicitRet>
-Invalid ExplicitUniformReturnT(...);
-
-template <typename TagType, typename A, typename B, typename ExplicitRet>
-auto ExplicitTaggedUniformReturnT(int) -> decltype(absl::Uniform<ExplicitRet>(
-    std::declval<TagType>(), *std::declval<absl::InsecureBitGen*>(),
-    std::declval<A>(), std::declval<B>()));
-
-template <typename, typename, typename, typename ExplicitRet>
-Invalid ExplicitTaggedUniformReturnT(...);
-
-// Given types <A, B, Expect>, CheckArgsReturnExpectedType() verifies that
-//
-//   absl::Uniform<Expect>(gen, A{}, B{})
-//
-// returns the type "Expect", and that the function-overload has the signature
-//
-//   Expect(URBG&, Expect, Expect)
-template <typename A, typename B, typename Expect>
-void CheckArgsReturnExpectedType() {
-  static_assert(
-      absl::conjunction<
-          std::is_same<Expect,
-                       decltype(ExplicitUniformReturnT<A, B, Expect>(0))>,
-          std::is_same<Expect, decltype(ExplicitUniformReturnT<B, A, Expect>(
-                                   0))>>::value,
-      "");
-  static_assert(
-      absl::conjunction<
-          std::is_same<Expect,
-                       decltype(ExplicitTaggedUniformReturnT<
-                                absl::IntervalOpenOpenTag, A, B, Expect>(0))>,
-          std::is_same<Expect, decltype(ExplicitTaggedUniformReturnT<
-                                        absl::IntervalOpenOpenTag, B, A,
-                                        Expect>(0))>>::value,
-      "");
-}
-
-TEST_F(RandomDistributionsTest, UniformTypeInference) {
-  // Infers common types.
-  CheckArgsInferType<uint16_t, uint16_t, uint16_t>();
-  CheckArgsInferType<uint32_t, uint32_t, uint32_t>();
-  CheckArgsInferType<uint64_t, uint64_t, uint64_t>();
-  CheckArgsInferType<int16_t, int16_t, int16_t>();
-  CheckArgsInferType<int32_t, int32_t, int32_t>();
-  CheckArgsInferType<int64_t, int64_t, int64_t>();
-  CheckArgsInferType<float, float, float>();
-  CheckArgsInferType<double, double, double>();
-
-  // Explicitly-specified return-values override inferences.
-  CheckArgsReturnExpectedType<int16_t, int16_t, int32_t>();
-  CheckArgsReturnExpectedType<uint16_t, uint16_t, int32_t>();
-  CheckArgsReturnExpectedType<int16_t, int16_t, int64_t>();
-  CheckArgsReturnExpectedType<int16_t, int32_t, int64_t>();
-  CheckArgsReturnExpectedType<int16_t, int32_t, double>();
-  CheckArgsReturnExpectedType<float, float, double>();
-  CheckArgsReturnExpectedType<int, int, int16_t>();
-
-  // Properly promotes uint16_t.
-  CheckArgsInferType<uint16_t, uint32_t, uint32_t>();
-  CheckArgsInferType<uint16_t, uint64_t, uint64_t>();
-  CheckArgsInferType<uint16_t, int32_t, int32_t>();
-  CheckArgsInferType<uint16_t, int64_t, int64_t>();
-  CheckArgsInferType<uint16_t, float, float>();
-  CheckArgsInferType<uint16_t, double, double>();
-
-  // Properly promotes int16_t.
-  CheckArgsInferType<int16_t, int32_t, int32_t>();
-  CheckArgsInferType<int16_t, int64_t, int64_t>();
-  CheckArgsInferType<int16_t, float, float>();
-  CheckArgsInferType<int16_t, double, double>();
-
-  // Invalid (u)int16_t-pairings do not compile.
-  // See "CheckArgsInferType" comments above, for how this is achieved.
-  CheckArgsInferType<uint16_t, int16_t, Invalid>();
-  CheckArgsInferType<int16_t, uint32_t, Invalid>();
-  CheckArgsInferType<int16_t, uint64_t, Invalid>();
-
-  // Properly promotes uint32_t.
-  CheckArgsInferType<uint32_t, uint64_t, uint64_t>();
-  CheckArgsInferType<uint32_t, int64_t, int64_t>();
-  CheckArgsInferType<uint32_t, double, double>();
-
-  // Properly promotes int32_t.
-  CheckArgsInferType<int32_t, int64_t, int64_t>();
-  CheckArgsInferType<int32_t, double, double>();
-
-  // Invalid (u)int32_t-pairings do not compile.
-  CheckArgsInferType<uint32_t, int32_t, Invalid>();
-  CheckArgsInferType<int32_t, uint64_t, Invalid>();
-  CheckArgsInferType<int32_t, float, Invalid>();
-  CheckArgsInferType<uint32_t, float, Invalid>();
-
-  // Invalid (u)int64_t-pairings do not compile.
-  CheckArgsInferType<uint64_t, int64_t, Invalid>();
-  CheckArgsInferType<int64_t, float, Invalid>();
-  CheckArgsInferType<int64_t, double, Invalid>();
-
-  // Properly promotes float.
-  CheckArgsInferType<float, double, double>();
-}
-
-TEST_F(RandomDistributionsTest, UniformExamples) {
-  // Examples.
-  absl::InsecureBitGen gen;
-  EXPECT_NE(1, absl::Uniform(gen, static_cast<uint16_t>(0), 1.0f));
-  EXPECT_NE(1, absl::Uniform(gen, 0, 1.0));
-  EXPECT_NE(1, absl::Uniform(absl::IntervalOpenOpen, gen,
-                             static_cast<uint16_t>(0), 1.0f));
-  EXPECT_NE(1, absl::Uniform(absl::IntervalOpenOpen, gen, 0, 1.0));
-  EXPECT_NE(1, absl::Uniform(absl::IntervalOpenOpen, gen, -1, 1.0));
-  EXPECT_NE(1, absl::Uniform<double>(absl::IntervalOpenOpen, gen, -1, 1));
-  EXPECT_NE(1, absl::Uniform<float>(absl::IntervalOpenOpen, gen, 0, 1));
-  EXPECT_NE(1, absl::Uniform<float>(gen, 0, 1));
-}
-
-TEST_F(RandomDistributionsTest, UniformNoBounds) {
-  absl::InsecureBitGen gen;
-
-  absl::Uniform<uint8_t>(gen);
-  absl::Uniform<uint16_t>(gen);
-  absl::Uniform<uint32_t>(gen);
-  absl::Uniform<uint64_t>(gen);
-}
-
-TEST_F(RandomDistributionsTest, UniformNonsenseRanges) {
-  // The ranges used in this test are undefined behavior.
-  // The results are arbitrary and subject to future changes.
-  absl::InsecureBitGen gen;
-
-  // <uint>
-  EXPECT_EQ(0, absl::Uniform<uint64_t>(gen, 0, 0));
-  EXPECT_EQ(1, absl::Uniform<uint64_t>(gen, 1, 0));
-  EXPECT_EQ(0, absl::Uniform<uint64_t>(absl::IntervalOpenOpen, gen, 0, 0));
-  EXPECT_EQ(1, absl::Uniform<uint64_t>(absl::IntervalOpenOpen, gen, 1, 0));
-
-  constexpr auto m = (std::numeric_limits<uint64_t>::max)();
-
-  EXPECT_EQ(m, absl::Uniform(gen, m, m));
-  EXPECT_EQ(m, absl::Uniform(gen, m, m - 1));
-  EXPECT_EQ(m - 1, absl::Uniform(gen, m - 1, m));
-  EXPECT_EQ(m, absl::Uniform(absl::IntervalOpenOpen, gen, m, m));
-  EXPECT_EQ(m, absl::Uniform(absl::IntervalOpenOpen, gen, m, m - 1));
-  EXPECT_EQ(m - 1, absl::Uniform(absl::IntervalOpenOpen, gen, m - 1, m));
-
-  // <int>
-  EXPECT_EQ(0, absl::Uniform<int64_t>(gen, 0, 0));
-  EXPECT_EQ(1, absl::Uniform<int64_t>(gen, 1, 0));
-  EXPECT_EQ(0, absl::Uniform<int64_t>(absl::IntervalOpenOpen, gen, 0, 0));
-  EXPECT_EQ(1, absl::Uniform<int64_t>(absl::IntervalOpenOpen, gen, 1, 0));
-
-  constexpr auto l = (std::numeric_limits<int64_t>::min)();
-  constexpr auto r = (std::numeric_limits<int64_t>::max)();
-
-  EXPECT_EQ(l, absl::Uniform(gen, l, l));
-  EXPECT_EQ(r, absl::Uniform(gen, r, r));
-  EXPECT_EQ(r, absl::Uniform(gen, r, r - 1));
-  EXPECT_EQ(r - 1, absl::Uniform(gen, r - 1, r));
-  EXPECT_EQ(l, absl::Uniform(absl::IntervalOpenOpen, gen, l, l));
-  EXPECT_EQ(r, absl::Uniform(absl::IntervalOpenOpen, gen, r, r));
-  EXPECT_EQ(r, absl::Uniform(absl::IntervalOpenOpen, gen, r, r - 1));
-  EXPECT_EQ(r - 1, absl::Uniform(absl::IntervalOpenOpen, gen, r - 1, r));
-
-  // <double>
-  const double e = std::nextafter(1.0, 2.0);  // 1 + epsilon
-  const double f = std::nextafter(1.0, 0.0);  // 1 - epsilon
-  const double g = std::numeric_limits<double>::denorm_min();
-
-  EXPECT_EQ(1.0, absl::Uniform(gen, 1.0, e));
-  EXPECT_EQ(1.0, absl::Uniform(gen, 1.0, f));
-  EXPECT_EQ(0.0, absl::Uniform(gen, 0.0, g));
-
-  EXPECT_EQ(e, absl::Uniform(absl::IntervalOpenOpen, gen, 1.0, e));
-  EXPECT_EQ(f, absl::Uniform(absl::IntervalOpenOpen, gen, 1.0, f));
-  EXPECT_EQ(g, absl::Uniform(absl::IntervalOpenOpen, gen, 0.0, g));
-}
-
-// TODO(lar): Validate properties of non-default interval-semantics.
-TEST_F(RandomDistributionsTest, UniformReal) {
-  std::vector<double> values(kSize);
-
-  absl::InsecureBitGen gen;
-  for (int i = 0; i < kSize; i++) {
-    values[i] = absl::Uniform(gen, 0, 1.0);
-  }
-
-  const auto moments =
-      absl::random_internal::ComputeDistributionMoments(values);
-  EXPECT_NEAR(0.5, moments.mean, 0.02);
-  EXPECT_NEAR(1 / 12.0, moments.variance, 0.02);
-  EXPECT_NEAR(0.0, moments.skewness, 0.02);
-  EXPECT_NEAR(9 / 5.0, moments.kurtosis, 0.02);
-}
-
-TEST_F(RandomDistributionsTest, UniformInt) {
-  std::vector<double> values(kSize);
-
-  absl::InsecureBitGen gen;
-  for (int i = 0; i < kSize; i++) {
-    const int64_t kMax = 1000000000000ll;
-    int64_t j = absl::Uniform(absl::IntervalClosedClosed, gen, 0, kMax);
-    // convert to double.
-    values[i] = static_cast<double>(j) / static_cast<double>(kMax);
-  }
-
-  const auto moments =
-      absl::random_internal::ComputeDistributionMoments(values);
-  EXPECT_NEAR(0.5, moments.mean, 0.02);
-  EXPECT_NEAR(1 / 12.0, moments.variance, 0.02);
-  EXPECT_NEAR(0.0, moments.skewness, 0.02);
-  EXPECT_NEAR(9 / 5.0, moments.kurtosis, 0.02);
-
-  /*
-  // NOTE: These are not supported by absl::Uniform, which is specialized
-  // on integer and real valued types.
-
-  enum E { E0, E1 };    // enum
-  enum S : int { S0, S1 };    // signed enum
-  enum U : unsigned int { U0, U1 };  // unsigned enum
-
-  absl::Uniform(gen, E0, E1);
-  absl::Uniform(gen, S0, S1);
-  absl::Uniform(gen, U0, U1);
-  */
-}
-
-TEST_F(RandomDistributionsTest, Exponential) {
-  std::vector<double> values(kSize);
-
-  absl::InsecureBitGen gen;
-  for (int i = 0; i < kSize; i++) {
-    values[i] = absl::Exponential<double>(gen);
-  }
-
-  const auto moments =
-      absl::random_internal::ComputeDistributionMoments(values);
-  EXPECT_NEAR(1.0, moments.mean, 0.02);
-  EXPECT_NEAR(1.0, moments.variance, 0.025);
-  EXPECT_NEAR(2.0, moments.skewness, 0.1);
-  EXPECT_LT(5.0, moments.kurtosis);
-}
-
-TEST_F(RandomDistributionsTest, PoissonDefault) {
-  std::vector<double> values(kSize);
-
-  absl::InsecureBitGen gen;
-  for (int i = 0; i < kSize; i++) {
-    values[i] = absl::Poisson<int64_t>(gen);
-  }
-
-  const auto moments =
-      absl::random_internal::ComputeDistributionMoments(values);
-  EXPECT_NEAR(1.0, moments.mean, 0.02);
-  EXPECT_NEAR(1.0, moments.variance, 0.02);
-  EXPECT_NEAR(1.0, moments.skewness, 0.025);
-  EXPECT_LT(2.0, moments.kurtosis);
-}
-
-TEST_F(RandomDistributionsTest, PoissonLarge) {
-  constexpr double kMean = 100000000.0;
-  std::vector<double> values(kSize);
-
-  absl::InsecureBitGen gen;
-  for (int i = 0; i < kSize; i++) {
-    values[i] = absl::Poisson<int64_t>(gen, kMean);
-  }
-
-  const auto moments =
-      absl::random_internal::ComputeDistributionMoments(values);
-  EXPECT_NEAR(kMean, moments.mean, kMean * 0.015);
-  EXPECT_NEAR(kMean, moments.variance, kMean * 0.015);
-  EXPECT_NEAR(std::sqrt(kMean), moments.skewness, kMean * 0.02);
-  EXPECT_LT(2.0, moments.kurtosis);
-}
-
-TEST_F(RandomDistributionsTest, Bernoulli) {
-  constexpr double kP = 0.5151515151;
-  std::vector<double> values(kSize);
-
-  absl::InsecureBitGen gen;
-  for (int i = 0; i < kSize; i++) {
-    values[i] = absl::Bernoulli(gen, kP);
-  }
-
-  const auto moments =
-      absl::random_internal::ComputeDistributionMoments(values);
-  EXPECT_NEAR(kP, moments.mean, 0.01);
-}
-
-TEST_F(RandomDistributionsTest, Beta) {
-  constexpr double kAlpha = 2.0;
-  constexpr double kBeta = 3.0;
-  std::vector<double> values(kSize);
-
-  absl::InsecureBitGen gen;
-  for (int i = 0; i < kSize; i++) {
-    values[i] = absl::Beta(gen, kAlpha, kBeta);
-  }
-
-  const auto moments =
-      absl::random_internal::ComputeDistributionMoments(values);
-  EXPECT_NEAR(0.4, moments.mean, 0.01);
-}
-
-TEST_F(RandomDistributionsTest, Zipf) {
-  std::vector<double> values(kSize);
-
-  absl::InsecureBitGen gen;
-  for (int i = 0; i < kSize; i++) {
-    values[i] = absl::Zipf<int64_t>(gen, 100);
-  }
-
-  // The mean of a zipf distribution is: H(N, s-1) / H(N,s).
-  // Given the parameter v = 1, this gives the following function:
-  // (Hn(100, 1) - Hn(1,1)) / (Hn(100,2) - Hn(1,2)) = 6.5944
-  const auto moments =
-      absl::random_internal::ComputeDistributionMoments(values);
-  EXPECT_NEAR(6.5944, moments.mean, 2000) << moments;
-}
-
-TEST_F(RandomDistributionsTest, Gaussian) {
-  std::vector<double> values(kSize);
-
-  absl::InsecureBitGen gen;
-  for (int i = 0; i < kSize; i++) {
-    values[i] = absl::Gaussian<double>(gen);
-  }
-
-  const auto moments =
-      absl::random_internal::ComputeDistributionMoments(values);
-  EXPECT_NEAR(0.0, moments.mean, 0.02);
-  EXPECT_NEAR(1.0, moments.variance, 0.04);
-  EXPECT_NEAR(0, moments.skewness, 0.2);
-  EXPECT_NEAR(3.0, moments.kurtosis, 0.5);
-}
-
-TEST_F(RandomDistributionsTest, LogUniform) {
-  std::vector<double> values(kSize);
-
-  absl::InsecureBitGen gen;
-  for (int i = 0; i < kSize; i++) {
-    values[i] = absl::LogUniform<int64_t>(gen, 0, (1 << 10) - 1);
-  }
-
-  // The mean is the sum of the fractional means of the uniform distributions:
-  // [0..0][1..1][2..3][4..7][8..15][16..31][32..63]
-  // [64..127][128..255][256..511][512..1023]
-  const double mean = (0 + 1 + 1 + 2 + 3 + 4 + 7 + 8 + 15 + 16 + 31 + 32 + 63 +
-                       64 + 127 + 128 + 255 + 256 + 511 + 512 + 1023) /
-                      (2.0 * 11.0);
-
-  const auto moments =
-      absl::random_internal::ComputeDistributionMoments(values);
-  EXPECT_NEAR(mean, moments.mean, 2) << moments;
-}
-
-}  // namespace