@nxtedition/rocksdb 15.2.2 → 15.2.4

package/deps/abseil-cpp/absl/strings/internal/charconv_bigint.h

@@ -1,433 +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_STRINGS_INTERNAL_CHARCONV_BIGINT_H_
-#define ABSL_STRINGS_INTERNAL_CHARCONV_BIGINT_H_
-
-#include <algorithm>
-#include <cstdint>
-#include <ostream>
-#include <string>
-
-#include "absl/base/config.h"
-#include "absl/strings/ascii.h"
-#include "absl/strings/internal/charconv_parse.h"
-#include "absl/strings/string_view.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace strings_internal {
-
-// The largest power that 5 that can be raised to, and still fit in a uint32_t.
-constexpr int kMaxSmallPowerOfFive = 13;
-// The largest power that 10 that can be raised to, and still fit in a uint32_t.
-constexpr int kMaxSmallPowerOfTen = 9;
-
-ABSL_DLL extern const uint32_t
-    kFiveToNth[kMaxSmallPowerOfFive + 1];
-ABSL_DLL extern const uint32_t kTenToNth[kMaxSmallPowerOfTen + 1];
-
-// Large, fixed-width unsigned integer.
-//
-// Exact rounding for decimal-to-binary floating point conversion requires very
-// large integer math, but a design goal of absl::from_chars is to avoid
-// allocating memory.  The integer precision needed for decimal-to-binary
-// conversions is large but bounded, so a huge fixed-width integer class
-// suffices.
-//
-// This is an intentionally limited big integer class.  Only needed operations
-// are implemented.  All storage lives in an array data member, and all
-// arithmetic is done in-place, to avoid requiring separate storage for operand
-// and result.
-//
-// This is an internal class.  Some methods live in the .cc file, and are
-// instantiated only for the values of max_words we need.
-template <int max_words>
-class BigUnsigned {
- public:
-  static_assert(max_words == 4 || max_words == 84,
-                "unsupported max_words value");
-
-  BigUnsigned() : size_(0), words_{} {}
-  explicit constexpr BigUnsigned(uint64_t v)
-      : size_((v >> 32) ? 2 : v ? 1 : 0),
-        words_{static_cast<uint32_t>(v & 0xffffffffu),
-               static_cast<uint32_t>(v >> 32)} {}
-
-  // Constructs a BigUnsigned from the given string_view containing a decimal
-  // value.  If the input string is not a decimal integer, constructs a 0
-  // instead.
-  explicit BigUnsigned(absl::string_view sv) : size_(0), words_{} {
-    // Check for valid input, returning a 0 otherwise.  This is reasonable
-    // behavior only because this constructor is for unit tests.
-    if (std::find_if_not(sv.begin(), sv.end(), ascii_isdigit) != sv.end() ||
-        sv.empty()) {
-      return;
-    }
-    int exponent_adjust =
-        ReadDigits(sv.data(), sv.data() + sv.size(), Digits10() + 1);
-    if (exponent_adjust > 0) {
-      MultiplyByTenToTheNth(exponent_adjust);
-    }
-  }
-
-  // Loads the mantissa value of a previously-parsed float.
-  //
-  // Returns the associated decimal exponent.  The value of the parsed float is
-  // exactly *this * 10**exponent.
-  int ReadFloatMantissa(const ParsedFloat& fp, int significant_digits);
-
-  // Returns the number of decimal digits of precision this type provides.  All
-  // numbers with this many decimal digits or fewer are representable by this
-  // type.
-  //
-  // Analogous to std::numeric_limits<BigUnsigned>::digits10.
-  static constexpr int Digits10() {
-    // 9975007/1035508 is very slightly less than log10(2**32).
-    return static_cast<uint64_t>(max_words) * 9975007 / 1035508;
-  }
-
-  // Shifts left by the given number of bits.
-  void ShiftLeft(int count) {
-    if (count > 0) {
-      const int word_shift = count / 32;
-      if (word_shift >= max_words) {
-        SetToZero();
-        return;
-      }
-      size_ = (std::min)(size_ + word_shift, max_words);
-      count %= 32;
-      if (count == 0) {
-// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=warray-bounds
-// shows a lot of bogus -Warray-bounds warnings under GCC.
-// This is not the only one in Abseil.
-#if ABSL_INTERNAL_HAVE_MIN_GNUC_VERSION(14, 0)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Warray-bounds"
-#endif
-        std::copy_backward(words_, words_ + size_ - word_shift, words_ + size_);
-#if ABSL_INTERNAL_HAVE_MIN_GNUC_VERSION(14, 0)
-#pragma GCC diagnostic pop
-#endif
-      } else {
-        for (int i = (std::min)(size_, max_words - 1); i > word_shift; --i) {
-          words_[i] = (words_[i - word_shift] << count) |
-                      (words_[i - word_shift - 1] >> (32 - count));
-        }
-        words_[word_shift] = words_[0] << count;
-        // Grow size_ if necessary.
-        if (size_ < max_words && words_[size_]) {
-          ++size_;
-        }
-      }
-      std::fill_n(words_, word_shift, 0u);
-    }
-  }
-
-
-  // Multiplies by v in-place.
-  void MultiplyBy(uint32_t v) {
-    if (size_ == 0 || v == 1) {
-      return;
-    }
-    if (v == 0) {
-      SetToZero();
-      return;
-    }
-    const uint64_t factor = v;
-    uint64_t window = 0;
-    for (int i = 0; i < size_; ++i) {
-      window += factor * words_[i];
-      words_[i] = window & 0xffffffff;
-      window >>= 32;
-    }
-    // If carry bits remain and there's space for them, grow size_.
-    if (window && size_ < max_words) {
-      words_[size_] = window & 0xffffffff;
-      ++size_;
-    }
-  }
-
-  void MultiplyBy(uint64_t v) {
-    uint32_t words[2];
-    words[0] = static_cast<uint32_t>(v);
-    words[1] = static_cast<uint32_t>(v >> 32);
-    if (words[1] == 0) {
-      MultiplyBy(words[0]);
-    } else {
-      MultiplyBy(2, words);
-    }
-  }
-
-  // Multiplies in place by 5 to the power of n.  n must be non-negative.
-  void MultiplyByFiveToTheNth(int n) {
-    while (n >= kMaxSmallPowerOfFive) {
-      MultiplyBy(kFiveToNth[kMaxSmallPowerOfFive]);
-      n -= kMaxSmallPowerOfFive;
-    }
-    if (n > 0) {
-      MultiplyBy(kFiveToNth[n]);
-    }
-  }
-
-  // Multiplies in place by 10 to the power of n.  n must be non-negative.
-  void MultiplyByTenToTheNth(int n) {
-    if (n > kMaxSmallPowerOfTen) {
-      // For large n, raise to a power of 5, then shift left by the same amount.
-      // (10**n == 5**n * 2**n.)  This requires fewer multiplications overall.
-      MultiplyByFiveToTheNth(n);
-      ShiftLeft(n);
-    } else if (n > 0) {
-      // We can do this more quickly for very small N by using a single
-      // multiplication.
-      MultiplyBy(kTenToNth[n]);
-    }
-  }
-
-  // Returns the value of 5**n, for non-negative n.  This implementation uses
-  // a lookup table, and is faster then seeding a BigUnsigned with 1 and calling
-  // MultiplyByFiveToTheNth().
-  static BigUnsigned FiveToTheNth(int n);
-
-  // Multiplies by another BigUnsigned, in-place.
-  template <int M>
-  void MultiplyBy(const BigUnsigned<M>& other) {
-    MultiplyBy(other.size(), other.words());
-  }
-
-  void SetToZero() {
-    std::fill_n(words_, size_, 0u);
-    size_ = 0;
-  }
-
-  // Returns the value of the nth word of this BigUnsigned.  This is
-  // range-checked, and returns 0 on out-of-bounds accesses.
-  uint32_t GetWord(int index) const {
-    if (index < 0 || index >= size_) {
-      return 0;
-    }
-    return words_[index];
-  }
-
-  // Returns this integer as a decimal string.  This is not used in the decimal-
-  // to-binary conversion; it is intended to aid in testing.
-  std::string ToString() const;
-
-  int size() const { return size_; }
-  const uint32_t* words() const { return words_; }
-
- private:
-  // Reads the number between [begin, end), possibly containing a decimal point,
-  // into this BigUnsigned.
-  //
-  // Callers are required to ensure [begin, end) contains a valid number, with
-  // one or more decimal digits and at most one decimal point.  This routine
-  // will behave unpredictably if these preconditions are not met.
-  //
-  // Only the first `significant_digits` digits are read.  Digits beyond this
-  // limit are "sticky": If the final significant digit is 0 or 5, and if any
-  // dropped digit is nonzero, then that final significant digit is adjusted up
-  // to 1 or 6.  This adjustment allows for precise rounding.
-  //
-  // Returns `exponent_adjustment`, a power-of-ten exponent adjustment to
-  // account for the decimal point and for dropped significant digits.  After
-  // this function returns,
-  //   actual_value_of_parsed_string ~= *this * 10**exponent_adjustment.
-  int ReadDigits(const char* begin, const char* end, int significant_digits);
-
-  // Performs a step of big integer multiplication.  This computes the full
-  // (64-bit-wide) values that should be added at the given index (step), and
-  // adds to that location in-place.
-  //
-  // Because our math all occurs in place, we must multiply starting from the
-  // highest word working downward.  (This is a bit more expensive due to the
-  // extra carries involved.)
-  //
-  // This must be called in steps, for each word to be calculated, starting from
-  // the high end and working down to 0.  The first value of `step` should be
-  //   `std::min(original_size + other.size_ - 2, max_words - 1)`.
-  // The reason for this expression is that multiplying the i'th word from one
-  // multiplicand and the j'th word of another multiplicand creates a
-  // two-word-wide value to be stored at the (i+j)'th element.  The highest
-  // word indices we will access are `original_size - 1` from this object, and
-  // `other.size_ - 1` from our operand.  Therefore,
-  // `original_size + other.size_ - 2` is the first step we should calculate,
-  // but limited on an upper bound by max_words.
-
-  // Working from high-to-low ensures that we do not overwrite the portions of
-  // the initial value of *this which are still needed for later steps.
-  //
-  // Once called with step == 0, *this contains the result of the
-  // multiplication.
-  //
-  // `original_size` is the size_ of *this before the first call to
-  // MultiplyStep().  `other_words` and `other_size` are the contents of our
-  // operand.  `step` is the step to perform, as described above.
-  void MultiplyStep(int original_size, const uint32_t* other_words,
-                    int other_size, int step);
-
-  void MultiplyBy(int other_size, const uint32_t* other_words) {
-    const int original_size = size_;
-    const int first_step =
-        (std::min)(original_size + other_size - 2, max_words - 1);
-    for (int step = first_step; step >= 0; --step) {
-      MultiplyStep(original_size, other_words, other_size, step);
-    }
-  }
-
-  // Adds a 32-bit value to the index'th word, with carry.
-  void AddWithCarry(int index, uint32_t value) {
-    if (value) {
-      while (index < max_words && value > 0) {
-        words_[index] += value;
-        // carry if we overflowed in this word:
-        if (value > words_[index]) {
-          value = 1;
-          ++index;
-        } else {
-          value = 0;
-        }
-      }
-      size_ = (std::min)(max_words, (std::max)(index + 1, size_));
-    }
-  }
-
-  void AddWithCarry(int index, uint64_t value) {
-    if (value && index < max_words) {
-      uint32_t high = value >> 32;
-      uint32_t low = value & 0xffffffff;
-      words_[index] += low;
-      if (words_[index] < low) {
-        ++high;
-        if (high == 0) {
-          // Carry from the low word caused our high word to overflow.
-          // Short circuit here to do the right thing.
-          AddWithCarry(index + 2, static_cast<uint32_t>(1));
-          return;
-        }
-      }
-      if (high > 0) {
-        AddWithCarry(index + 1, high);
-      } else {
-        // Normally 32-bit AddWithCarry() sets size_, but since we don't call
-        // it when `high` is 0, do it ourselves here.
-        size_ = (std::min)(max_words, (std::max)(index + 1, size_));
-      }
-    }
-  }
-
-  // Divide this in place by a constant divisor.  Returns the remainder of the
-  // division.
-  template <uint32_t divisor>
-  uint32_t DivMod() {
-    uint64_t accumulator = 0;
-    for (int i = size_ - 1; i >= 0; --i) {
-      accumulator <<= 32;
-      accumulator += words_[i];
-      // accumulator / divisor will never overflow an int32_t in this loop
-      words_[i] = static_cast<uint32_t>(accumulator / divisor);
-      accumulator = accumulator % divisor;
-    }
-    while (size_ > 0 && words_[size_ - 1] == 0) {
-      --size_;
-    }
-    return static_cast<uint32_t>(accumulator);
-  }
-
-  // The number of elements in words_ that may carry significant values.
-  // All elements beyond this point are 0.
-  //
-  // When size_ is 0, this BigUnsigned stores the value 0.
-  // When size_ is nonzero, is *not* guaranteed that words_[size_ - 1] is
-  // nonzero.  This can occur due to overflow truncation.
-  // In particular, x.size_ != y.size_ does *not* imply x != y.
-  int size_;
-  uint32_t words_[max_words];
-};
-
-// Compares two big integer instances.
-//
-// Returns -1 if lhs < rhs, 0 if lhs == rhs, and 1 if lhs > rhs.
-template <int N, int M>
-int Compare(const BigUnsigned<N>& lhs, const BigUnsigned<M>& rhs) {
-  int limit = (std::max)(lhs.size(), rhs.size());
-  for (int i = limit - 1; i >= 0; --i) {
-    const uint32_t lhs_word = lhs.GetWord(i);
-    const uint32_t rhs_word = rhs.GetWord(i);
-    if (lhs_word < rhs_word) {
-      return -1;
-    } else if (lhs_word > rhs_word) {
-      return 1;
-    }
-  }
-  return 0;
-}
-
-template <int N, int M>
-bool operator==(const BigUnsigned<N>& lhs, const BigUnsigned<M>& rhs) {
-  int limit = (std::max)(lhs.size(), rhs.size());
-  for (int i = 0; i < limit; ++i) {
-    if (lhs.GetWord(i) != rhs.GetWord(i)) {
-      return false;
-    }
-  }
-  return true;
-}
-
-template <int N, int M>
-bool operator!=(const BigUnsigned<N>& lhs, const BigUnsigned<M>& rhs) {
-  return !(lhs == rhs);
-}
-
-template <int N, int M>
-bool operator<(const BigUnsigned<N>& lhs, const BigUnsigned<M>& rhs) {
-  return Compare(lhs, rhs) == -1;
-}
-
-template <int N, int M>
-bool operator>(const BigUnsigned<N>& lhs, const BigUnsigned<M>& rhs) {
-  return rhs < lhs;
-}
-template <int N, int M>
-bool operator<=(const BigUnsigned<N>& lhs, const BigUnsigned<M>& rhs) {
-  return !(rhs < lhs);
-}
-template <int N, int M>
-bool operator>=(const BigUnsigned<N>& lhs, const BigUnsigned<M>& rhs) {
-  return !(lhs < rhs);
-}
-
-// Output operator for BigUnsigned, for testing purposes only.
-template <int N>
-std::ostream& operator<<(std::ostream& os, const BigUnsigned<N>& num) {
-  return os << num.ToString();
-}
-
-// Explicit instantiation declarations for the sizes of BigUnsigned that we
-// are using.
-//
-// For now, the choices of 4 and 84 are arbitrary; 4 is a small value that is
-// still bigger than an int128, and 84 is a large value we will want to use
-// in the from_chars implementation.
-//
-// Comments justifying the use of 84 belong in the from_chars implementation,
-// and will be added in a follow-up CL.
-extern template class BigUnsigned<4>;
-extern template class BigUnsigned<84>;
-
-}  // namespace strings_internal
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#endif  // ABSL_STRINGS_INTERNAL_CHARCONV_BIGINT_H_

package/deps/abseil-cpp/absl/strings/internal/charconv_bigint_test.cc

@@ -1,260 +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.
-
-#include "absl/strings/internal/charconv_bigint.h"
-
-#include <string>
-
-#include "gtest/gtest.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace strings_internal {
-
-TEST(BigUnsigned, ShiftLeft) {
-  {
-    // Check that 3 * 2**100 is calculated correctly
-    BigUnsigned<4> num(3u);
-    num.ShiftLeft(100);
-    EXPECT_EQ(num, BigUnsigned<4>("3802951800684688204490109616128"));
-  }
-  {
-    // Test that overflow is truncated properly.
-    // 15 is 4 bits long, and BigUnsigned<4> is a 128-bit bigint.
-    // Shifting left by 125 bits should truncate off the high bit, so that
-    //   15 << 125 == 7 << 125
-    // after truncation.
-    BigUnsigned<4> a(15u);
-    BigUnsigned<4> b(7u);
-    BigUnsigned<4> c(3u);
-    a.ShiftLeft(125);
-    b.ShiftLeft(125);
-    c.ShiftLeft(125);
-    EXPECT_EQ(a, b);
-    EXPECT_NE(a, c);
-  }
-  {
-    // Same test, larger bigint:
-    BigUnsigned<84> a(15u);
-    BigUnsigned<84> b(7u);
-    BigUnsigned<84> c(3u);
-    a.ShiftLeft(84 * 32 - 3);
-    b.ShiftLeft(84 * 32 - 3);
-    c.ShiftLeft(84 * 32 - 3);
-    EXPECT_EQ(a, b);
-    EXPECT_NE(a, c);
-  }
-  {
-    // Check that incrementally shifting has the same result as doing it all at
-    // once (attempting to capture corner cases.)
-    const std::string seed = "1234567890123456789012345678901234567890";
-    BigUnsigned<84> a(seed);
-    for (int i = 1; i <= 84 * 32; ++i) {
-      a.ShiftLeft(1);
-      BigUnsigned<84> b(seed);
-      b.ShiftLeft(i);
-      EXPECT_EQ(a, b);
-    }
-    // And we should have fully rotated all bits off by now:
-    EXPECT_EQ(a, BigUnsigned<84>(0u));
-  }
-  {
-    // Bit shifting large and small numbers by large and small offsets.
-    // Intended to exercise bounds-checking corner on ShiftLeft() (directly
-    // and under asan).
-
-    // 2**(32*84)-1
-    const BigUnsigned<84> all_bits_one(
-        "1474444211396924248063325089479706787923460402125687709454567433186613"
-        "6228083464060749874845919674257665016359189106695900028098437021384227"
-        "3285029708032466536084583113729486015826557532750465299832071590813090"
-        "2011853039837649252477307070509704043541368002938784757296893793903797"
-        "8180292336310543540677175225040919704702800559606097685920595947397024"
-        "8303316808753252115729411497720357971050627997031988036134171378490368"
-        "6008000778741115399296162550786288457245180872759047016734959330367829"
-        "5235612397427686310674725251378116268607113017720538636924549612987647"
-        "5767411074510311386444547332882472126067840027882117834454260409440463"
-        "9345147252664893456053258463203120637089916304618696601333953616715125"
-        "2115882482473279040772264257431663818610405673876655957323083702713344"
-        "4201105427930770976052393421467136557055");
-    const BigUnsigned<84> zero(0u);
-    const BigUnsigned<84> one(1u);
-    // in bounds shifts
-    for (int i = 1; i < 84*32; ++i) {
-      // shifting all_bits_one to the left should result in a smaller number,
-      // since the high bits rotate off and the low bits are replaced with
-      // zeroes.
-      BigUnsigned<84> big_shifted = all_bits_one;
-      big_shifted.ShiftLeft(i);
-      EXPECT_GT(all_bits_one, big_shifted);
-      // Shifting 1 to the left should instead result in a larger number.
-      BigUnsigned<84> small_shifted = one;
-      small_shifted.ShiftLeft(i);
-      EXPECT_LT(one, small_shifted);
-    }
-    // Shifting by zero or a negative number has no effect
-    for (int no_op_shift : {0, -1, -84 * 32, std::numeric_limits<int>::min()}) {
-      BigUnsigned<84> big_shifted = all_bits_one;
-      big_shifted.ShiftLeft(no_op_shift);
-      EXPECT_EQ(all_bits_one, big_shifted);
-      BigUnsigned<84> small_shifted = one;
-      big_shifted.ShiftLeft(no_op_shift);
-      EXPECT_EQ(one, small_shifted);
-    }
-    // Shifting by an amount greater than the number of bits should result in
-    // zero.
-    for (int out_of_bounds_shift :
-         {84 * 32, 84 * 32 + 1, std::numeric_limits<int>::max()}) {
-      BigUnsigned<84> big_shifted = all_bits_one;
-      big_shifted.ShiftLeft(out_of_bounds_shift);
-      EXPECT_EQ(zero, big_shifted);
-      BigUnsigned<84> small_shifted = one;
-      small_shifted.ShiftLeft(out_of_bounds_shift);
-      EXPECT_EQ(zero, small_shifted);
-    }
-  }
-}
-
-TEST(BigUnsigned, MultiplyByUint32) {
-  const BigUnsigned<84> factorial_100(
-      "933262154439441526816992388562667004907159682643816214685929638952175999"
-      "932299156089414639761565182862536979208272237582511852109168640000000000"
-      "00000000000000");
-  BigUnsigned<84> a(1u);
-  for (uint32_t i = 1; i <= 100; ++i) {
-    a.MultiplyBy(i);
-  }
-  EXPECT_EQ(a, BigUnsigned<84>(factorial_100));
-}
-
-TEST(BigUnsigned, MultiplyByBigUnsigned) {
-  {
-    // Put the terms of factorial_200 into two bigints, and multiply them
-    // together.
-    const BigUnsigned<84> factorial_200(
-        "7886578673647905035523632139321850622951359776871732632947425332443594"
-        "4996340334292030428401198462390417721213891963883025764279024263710506"
-        "1926624952829931113462857270763317237396988943922445621451664240254033"
-        "2918641312274282948532775242424075739032403212574055795686602260319041"
-        "7032406235170085879617892222278962370389737472000000000000000000000000"
-        "0000000000000000000000000");
-    BigUnsigned<84> evens(1u);
-    BigUnsigned<84> odds(1u);
-    for (uint32_t i = 1; i < 200; i += 2) {
-      odds.MultiplyBy(i);
-      evens.MultiplyBy(i + 1);
-    }
-    evens.MultiplyBy(odds);
-    EXPECT_EQ(evens, factorial_200);
-  }
-  {
-    // Multiply various powers of 10 together.
-    for (int a = 0 ; a < 700; a += 25) {
-      SCOPED_TRACE(a);
-      BigUnsigned<84> a_value("3" + std::string(a, '0'));
-      for (int b = 0; b < (700 - a); b += 25) {
-        SCOPED_TRACE(b);
-        BigUnsigned<84> b_value("2" + std::string(b, '0'));
-        BigUnsigned<84> expected_product("6" + std::string(a + b, '0'));
-        b_value.MultiplyBy(a_value);
-        EXPECT_EQ(b_value, expected_product);
-      }
-    }
-  }
-}
-
-TEST(BigUnsigned, MultiplyByOverflow) {
-  {
-    // Check that multiplication overflow predictably truncates.
-
-    // A big int with all bits on.
-    BigUnsigned<4> all_bits_on("340282366920938463463374607431768211455");
-    // Modulo 2**128, this is equal to -1.  Therefore the square of this,
-    // modulo 2**128, should be 1.
-    all_bits_on.MultiplyBy(all_bits_on);
-    EXPECT_EQ(all_bits_on, BigUnsigned<4>(1u));
-  }
-  {
-    // Try multiplying a large bigint by 2**50, and compare the result to
-    // shifting.
-    BigUnsigned<4> value_1("12345678901234567890123456789012345678");
-    BigUnsigned<4> value_2("12345678901234567890123456789012345678");
-    BigUnsigned<4> two_to_fiftieth(1u);
-    two_to_fiftieth.ShiftLeft(50);
-
-    value_1.ShiftLeft(50);
-    value_2.MultiplyBy(two_to_fiftieth);
-    EXPECT_EQ(value_1, value_2);
-  }
-}
-
-TEST(BigUnsigned, FiveToTheNth) {
-  {
-    // Sanity check that MultiplyByFiveToTheNth gives consistent answers, up to
-    // and including overflow.
-    for (int i = 0; i < 1160; ++i) {
-      SCOPED_TRACE(i);
-      BigUnsigned<84> value_1(123u);
-      BigUnsigned<84> value_2(123u);
-      value_1.MultiplyByFiveToTheNth(i);
-      for (int j = 0; j < i; j++) {
-        value_2.MultiplyBy(5u);
-      }
-      EXPECT_EQ(value_1, value_2);
-    }
-  }
-  {
-    // Check that the faster, table-lookup-based static method returns the same
-    // result that multiplying in-place would return, up to and including
-    // overflow.
-    for (int i = 0; i < 1160; ++i) {
-      SCOPED_TRACE(i);
-      BigUnsigned<84> value_1(1u);
-      value_1.MultiplyByFiveToTheNth(i);
-      BigUnsigned<84> value_2 = BigUnsigned<84>::FiveToTheNth(i);
-      EXPECT_EQ(value_1, value_2);
-    }
-  }
-}
-
-TEST(BigUnsigned, TenToTheNth) {
-  {
-    // Sanity check MultiplyByTenToTheNth.
-    for (int i = 0; i < 800; ++i) {
-      SCOPED_TRACE(i);
-      BigUnsigned<84> value_1(123u);
-      BigUnsigned<84> value_2(123u);
-      value_1.MultiplyByTenToTheNth(i);
-      for (int j = 0; j < i; j++) {
-        value_2.MultiplyBy(10u);
-      }
-      EXPECT_EQ(value_1, value_2);
-    }
-  }
-  {
-    // Alternate testing approach, taking advantage of the decimal parser.
-    for (int i = 0; i < 200; ++i) {
-      SCOPED_TRACE(i);
-      BigUnsigned<84> value_1(135u);
-      value_1.MultiplyByTenToTheNth(i);
-      BigUnsigned<84> value_2("135" + std::string(i, '0'));
-      EXPECT_EQ(value_1, value_2);
-    }
-  }
-}
-
-
-}  // namespace strings_internal
-ABSL_NAMESPACE_END
-}  // namespace absl