//===- llvm/unittest/ADT/APFloat.cpp - APFloat unit tests ---------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#include "llvm/ADT/APFloat.h"
#include "llvm/ADT/APSInt.h"
#include "llvm/ADT/Hashing.h"
#include "llvm/ADT/SmallString.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/StringExtras.h"
#include "llvm/Support/Error.h"
#include "llvm/Support/FormatVariadic.h"
#include "gtest/gtest.h"
#include <cmath>
#include <limits>
#include <ostream>
#include <string>
#include <tuple>
#include <type_traits>

using namespace llvm;

static std::string convertToErrorFromString(StringRef Str) {
  llvm::APFloat F(0.0);
  auto StatusOrErr =
      F.convertFromString(Str, llvm::APFloat::rmNearestTiesToEven);
  EXPECT_TRUE(!StatusOrErr);
  return toString(StatusOrErr.takeError());
}

static double convertToDoubleFromString(StringRef Str) {
  llvm::APFloat F(0.0);
  auto StatusOrErr =
      F.convertFromString(Str, llvm::APFloat::rmNearestTiesToEven);
  EXPECT_FALSE(!StatusOrErr);
  consumeError(StatusOrErr.takeError());
  return F.convertToDouble();
}

static std::string convertToString(double d, unsigned Prec, unsigned Pad,
                                   bool Tr = true) {
  llvm::SmallVector<char, 100> Buffer;
  llvm::APFloat F(d);
  F.toString(Buffer, Prec, Pad, Tr);
  return std::string(Buffer.data(), Buffer.size());
}

namespace llvm {
namespace detail {
class IEEEFloatUnitTestHelper {
public:
  static void runTest(bool subtract, bool lhsSign,
                      APFloat::ExponentType lhsExponent,
                      APFloat::integerPart lhsSignificand, bool rhsSign,
                      APFloat::ExponentType rhsExponent,
                      APFloat::integerPart rhsSignificand, bool expectedSign,
                      APFloat::ExponentType expectedExponent,
                      APFloat::integerPart expectedSignificand,
                      lostFraction expectedLoss) {
    // `addOrSubtractSignificand` only uses the sign, exponent and significand
    IEEEFloat lhs(1.0);
    lhs.sign = lhsSign;
    lhs.exponent = lhsExponent;
    lhs.significand.part = lhsSignificand;
    IEEEFloat rhs(1.0);
    rhs.sign = rhsSign;
    rhs.exponent = rhsExponent;
    rhs.significand.part = rhsSignificand;
    lostFraction resultLoss = lhs.addOrSubtractSignificand(rhs, subtract);
    EXPECT_EQ(resultLoss, expectedLoss);
    EXPECT_EQ(lhs.sign, expectedSign);
    EXPECT_EQ(lhs.exponent, expectedExponent);
    EXPECT_EQ(lhs.significand.part, expectedSignificand);
  }
};
} // namespace detail
} // namespace llvm

namespace {

TEST(APFloatTest, isSignaling) {
  // We test qNaN, -qNaN, +sNaN, -sNaN with and without payloads. *NOTE* The
  // positive/negative distinction is included only since the getQNaN/getSNaN
  // API provides the option.
  APInt payload = APInt::getOneBitSet(4, 2);
  APFloat QNan = APFloat::getQNaN(APFloat::IEEEsingle(), false);
  EXPECT_FALSE(QNan.isSignaling());
  EXPECT_EQ(fcQNan, QNan.classify());

  EXPECT_FALSE(APFloat::getQNaN(APFloat::IEEEsingle(), true).isSignaling());
  EXPECT_FALSE(APFloat::getQNaN(APFloat::IEEEsingle(), false, &payload).isSignaling());
  EXPECT_FALSE(APFloat::getQNaN(APFloat::IEEEsingle(), true, &payload).isSignaling());

  APFloat SNan = APFloat::getSNaN(APFloat::IEEEsingle(), false);
  EXPECT_TRUE(SNan.isSignaling());
  EXPECT_EQ(fcSNan, SNan.classify());

  EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle(), true).isSignaling());
  EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle(), false, &payload).isSignaling());
  EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle(), true, &payload).isSignaling());
}

TEST(APFloatTest, IsLosslesslyConvertibleToSelf) {
  for (unsigned I = 0; I != APFloat::S_MaxSemantics + 1; ++I) {
    const fltSemantics &Semantics =
        APFloat::EnumToSemantics(static_cast<APFloat::Semantics>(I));
    EXPECT_TRUE(
        APFloatBase::isLosslesslyConvertibleTo(Semantics, Semantics, false))
        << "Semantics = " << I;
    EXPECT_TRUE(
        APFloatBase::isLosslesslyConvertibleTo(Semantics, Semantics, true))
        << "Semantics = " << I;
  }
}

TEST(APFloatTest, IsLosslesslyConvertibleToKnownWiderSemantics) {
  struct TestCase {
    APFloat::Semantics From;
    APFloat::Semantics To;
    bool IgnoreNaNs;
  };
  const TestCase Cases[] = {
      {APFloat::S_IEEEhalf, APFloat::S_IEEEsingle, true},
      {APFloat::S_BFloat, APFloat::S_IEEEsingle, true},
      {APFloat::S_IEEEsingle, APFloat::S_IEEEdouble, true},
      {APFloat::S_IEEEdouble, APFloat::S_IEEEquad, true},
      {APFloat::S_PPCDoubleDoubleLegacy, APFloat::S_IEEEquad, true},
      {APFloat::S_Float8E5M2, APFloat::S_IEEEhalf, true},
      {APFloat::S_Float8E5M2FNUZ, APFloat::S_IEEEsingle, false},
      {APFloat::S_Float8E4M3, APFloat::S_IEEEhalf, true},
      {APFloat::S_Float8E4M3FN, APFloat::S_IEEEhalf, false},
      {APFloat::S_Float8E4M3FNUZ, APFloat::S_IEEEhalf, false},
      {APFloat::S_Float8E4M3B11FNUZ, APFloat::S_IEEEhalf, false},
      {APFloat::S_Float8E3M4, APFloat::S_IEEEhalf, true},
      {APFloat::S_FloatTF32, APFloat::S_IEEEsingle, true},
      {APFloat::S_Float8E8M0FNU, APFloat::S_x87DoubleExtended, false},
      {APFloat::S_Float8E5M3FNU, APFloat::S_IEEEsingle, false},
      {APFloat::S_Float6E3M2FN, APFloat::S_IEEEhalf, false},
      {APFloat::S_Float6E2M3FN, APFloat::S_IEEEhalf, false},
      {APFloat::S_Float4E2M1FN, APFloat::S_IEEEhalf, false},
      {APFloat::S_x87DoubleExtended, APFloat::S_IEEEquad, true},
  };

  for (const TestCase &Case : Cases) {
    const fltSemantics &From = APFloat::EnumToSemantics(Case.From);
    const fltSemantics &To = APFloat::EnumToSemantics(Case.To);
    EXPECT_TRUE(
        APFloatBase::isLosslesslyConvertibleTo(From, To, Case.IgnoreNaNs))
        << "From = " << Case.From << ", To = " << Case.To
        << ", IgnoreNaNs = " << Case.IgnoreNaNs;
  }
}

TEST(APFloatTest, IsLosslesslyConvertibleToRejectsInformationLoss) {
  EXPECT_FALSE(APFloatBase::isLosslesslyConvertibleTo(APFloat::IEEEhalf(),
                                                      APFloat::IEEEsingle()));
  EXPECT_FALSE(APFloatBase::isLosslesslyConvertibleTo(
      APFloat::IEEEsingle(), APFloat::IEEEhalf(), true));
  EXPECT_FALSE(APFloatBase::isLosslesslyConvertibleTo(
      APFloat::Float8E4M3FN(), APFloat::Float8E4M3FNUZ(), true));
  EXPECT_FALSE(APFloatBase::isLosslesslyConvertibleTo(
      APFloat::Float4E2M1FN(), APFloat::Float8E8M0FNU(), true));

  // IgnoreNaNs does not permit a NaN or infinity to change categories. Model
  // possible future wider formats for combinations not currently present in
  // the supported semantics.
  fltSemantics WiderNanOnly = APFloat::IEEEsingle();
  WiderNanOnly.nonFiniteBehavior = fltNonfiniteBehavior::NanOnly;
  WiderNanOnly.nanEncoding = fltNanEncoding::AllOnes;
  EXPECT_FALSE(APFloatBase::isLosslesslyConvertibleTo(APFloat::IEEEhalf(),
                                                      WiderNanOnly, true));

  fltSemantics NarrowNanOnly = APFloat::IEEEhalf();
  NarrowNanOnly.nonFiniteBehavior = fltNonfiniteBehavior::NanOnly;
  NarrowNanOnly.nanEncoding = fltNanEncoding::AllOnes;
  fltSemantics WiderFiniteOnly = APFloat::IEEEsingle();
  WiderFiniteOnly.nonFiniteBehavior = fltNonfiniteBehavior::FiniteOnly;
  EXPECT_FALSE(APFloatBase::isLosslesslyConvertibleTo(NarrowNanOnly,
                                                      WiderFiniteOnly, true));

  // PPC double-double's low component is not described by its fltSemantics
  // exponent and precision fields, so only identity is known to be lossless.
  EXPECT_FALSE(APFloatBase::isLosslesslyConvertibleTo(
      APFloat::PPCDoubleDouble(), APFloat::IEEEquad(), true));
  EXPECT_FALSE(APFloatBase::isLosslesslyConvertibleTo(
      APFloat::IEEEquad(), APFloat::PPCDoubleDouble(), true));
}

TEST(APFloatTest, LosslessConversionsPreserveRepresentativeValues) {
  for (unsigned FromIndex = 0; FromIndex != APFloat::S_MaxSemantics + 1;
       ++FromIndex) {
    const fltSemantics &From =
        APFloat::EnumToSemantics(static_cast<APFloat::Semantics>(FromIndex));
    for (unsigned ToIndex = 0; ToIndex != APFloat::S_MaxSemantics + 1;
         ++ToIndex) {
      const fltSemantics &To =
          APFloat::EnumToSemantics(static_cast<APFloat::Semantics>(ToIndex));
      for (bool IgnoreNaNs : {false, true}) {
        if (!APFloatBase::isLosslesslyConvertibleTo(From, To, IgnoreNaNs))
          continue;

        SCOPED_TRACE("From = " + std::to_string(FromIndex) +
                     ", To = " + std::to_string(ToIndex) +
                     ", IgnoreNaNs = " + std::to_string(IgnoreNaNs));
        auto CheckValue = [&](APFloat Value) {
          APFloat Original = Value;
          bool WasNaN = Value.isNaN();
          bool LosesInfo = false;
          (void)Value.convert(To, APFloat::rmNearestTiesToEven, &LosesInfo);

          if (WasNaN && IgnoreNaNs) {
            EXPECT_TRUE(Value.isNaN());
            return;
          }

          EXPECT_FALSE(LosesInfo);
          bool LosesInfoOnReturn = false;
          (void)Value.convert(From, APFloat::rmNearestTiesToEven,
                              &LosesInfoOnReturn);
          EXPECT_TRUE(Value.bitwiseIsEqual(Original));
        };

        CheckValue(APFloat::getLargest(From));
        CheckValue(APFloat::getSmallest(From));
        CheckValue(APFloat::getSmallestNormalized(From));
        if (From.hasSignedRepr) {
          CheckValue(APFloat::getLargest(From, true));
          CheckValue(APFloat::getSmallest(From, true));
          CheckValue(APFloat::getSmallestNormalized(From, true));
        }
        if (From.hasZero) {
          CheckValue(APFloat::getZero(From));
          if (From.hasSignedRepr)
            CheckValue(APFloat::getZero(From, true));
        }
        if (APFloat::semanticsHasInf(From)) {
          CheckValue(APFloat::getInf(From));
          if (From.hasSignedRepr)
            CheckValue(APFloat::getInf(From, true));
        }
        if (APFloat::semanticsHasNaN(From)) {
          CheckValue(APFloat::getQNaN(From));
          if (From.nonFiniteBehavior == fltNonfiniteBehavior::IEEE754)
            CheckValue(APFloat::getSNaN(From));
        }
      }
    }
  }
}

TEST(APFloatTest, next) {

  APFloat test(APFloat::IEEEquad(), APFloat::uninitialized);
  APFloat expected(APFloat::IEEEquad(), APFloat::uninitialized);

  // 1. Test Special Cases Values.
  //
  // Test all special values for nextUp and nextDown perscribed by IEEE-754R
  // 2008. These are:
  //   1.  +inf
  //   2.  -inf
  //   3.  getLargest()
  //   4.  -getLargest()
  //   5.  getSmallest()
  //   6.  -getSmallest()
  //   7.  qNaN
  //   8.  sNaN
  //   9.  +0
  //   10. -0

  // nextUp(+inf) = +inf.
  test = APFloat::getInf(APFloat::IEEEquad(), false);
  expected = APFloat::getInf(APFloat::IEEEquad(), false);
  EXPECT_EQ(test.next(false), APFloat::opOK);
  EXPECT_TRUE(test.isInfinity());
  EXPECT_TRUE(!test.isNegative());
  EXPECT_TRUE(test.bitwiseIsEqual(expected));

  // nextDown(+inf) = -nextUp(-inf) = -(-getLargest()) = getLargest()
  test = APFloat::getInf(APFloat::IEEEquad(), false);
  expected = APFloat::getLargest(APFloat::IEEEquad(), false);
  EXPECT_EQ(test.next(true), APFloat::opOK);
  EXPECT_TRUE(!test.isNegative());
  EXPECT_TRUE(test.bitwiseIsEqual(expected));

  // nextUp(-inf) = -getLargest()
  test = APFloat::getInf(APFloat::IEEEquad(), true);
  expected = APFloat::getLargest(APFloat::IEEEquad(), true);
  EXPECT_EQ(test.next(false), APFloat::opOK);
  EXPECT_TRUE(test.isNegative());
  EXPECT_TRUE(test.bitwiseIsEqual(expected));

  // nextDown(-inf) = -nextUp(+inf) = -(+inf) = -inf.
  test = APFloat::getInf(APFloat::IEEEquad(), true);
  expected = APFloat::getInf(APFloat::IEEEquad(), true);
  EXPECT_EQ(test.next(true), APFloat::opOK);
  EXPECT_TRUE(test.isInfinity() && test.isNegative());
  EXPECT_TRUE(test.bitwiseIsEqual(expected));

  // nextUp(getLargest()) = +inf
  test = APFloat::getLargest(APFloat::IEEEquad(), false);
  expected = APFloat::getInf(APFloat::IEEEquad(), false);
  EXPECT_EQ(test.next(false), APFloat::opOK);
  EXPECT_TRUE(test.isInfinity() && !test.isNegative());
  EXPECT_TRUE(test.bitwiseIsEqual(expected));

  // nextDown(getLargest()) = -nextUp(-getLargest())
  //                        = -(-getLargest() + inc)
  //                        = getLargest() - inc.
  test = APFloat::getLargest(APFloat::IEEEquad(), false);
  expected = APFloat(APFloat::IEEEquad(),
                     "0x1.fffffffffffffffffffffffffffep+16383");
  EXPECT_EQ(test.next(true), APFloat::opOK);
  EXPECT_TRUE(!test.isInfinity() && !test.isNegative());
  EXPECT_TRUE(test.bitwiseIsEqual(expected));

  // nextUp(-getLargest()) = -getLargest() + inc.
  test = APFloat::getLargest(APFloat::IEEEquad(), true);
  expected = APFloat(APFloat::IEEEquad(),
                     "-0x1.fffffffffffffffffffffffffffep+16383");
  EXPECT_EQ(test.next(false), APFloat::opOK);
  EXPECT_TRUE(test.bitwiseIsEqual(expected));

  // nextDown(-getLargest()) = -nextUp(getLargest()) = -(inf) = -inf.
  test = APFloat::getLargest(APFloat::IEEEquad(), true);
  expected = APFloat::getInf(APFloat::IEEEquad(), true);
  EXPECT_EQ(test.next(true), APFloat::opOK);
  EXPECT_TRUE(test.isInfinity() && test.isNegative());
  EXPECT_TRUE(test.bitwiseIsEqual(expected));

  // nextUp(getSmallest()) = getSmallest() + inc.
  test = APFloat(APFloat::IEEEquad(), "0x0.0000000000000000000000000001p-16382");
  expected = APFloat(APFloat::IEEEquad(),
                     "0x0.0000000000000000000000000002p-16382");
  EXPECT_EQ(test.next(false), APFloat::opOK);
  EXPECT_TRUE(test.bitwiseIsEqual(expected));

  // nextDown(getSmallest()) = -nextUp(-getSmallest()) = -(-0) = +0.
  test = APFloat(APFloat::IEEEquad(), "0x0.0000000000000000000000000001p-16382");
  expected = APFloat::getZero(APFloat::IEEEquad(), false);
  EXPECT_EQ(test.next(true), APFloat::opOK);
  EXPECT_TRUE(test.isPosZero());
  EXPECT_TRUE(test.bitwiseIsEqual(expected));

  // nextUp(-getSmallest()) = -0.
  test = APFloat(APFloat::IEEEquad(), "-0x0.0000000000000000000000000001p-16382");
  expected = APFloat::getZero(APFloat::IEEEquad(), true);
  EXPECT_EQ(test.next(false), APFloat::opOK);
  EXPECT_TRUE(test.isNegZero());
  EXPECT_TRUE(test.bitwiseIsEqual(expected));

  // nextDown(-getSmallest()) = -nextUp(getSmallest()) = -getSmallest() - inc.
  test = APFloat(APFloat::IEEEquad(), "-0x0.0000000000000000000000000001p-16382");
  expected = APFloat(APFloat::IEEEquad(),
                     "-0x0.0000000000000000000000000002p-16382");
  EXPECT_EQ(test.next(true), APFloat::opOK);
  EXPECT_TRUE(test.bitwiseIsEqual(expected));

  // nextUp(qNaN) = qNaN
  test = APFloat::getQNaN(APFloat::IEEEquad(), false);
  expected = APFloat::getQNaN(APFloat::IEEEquad(), false);
  EXPECT_EQ(test.next(false), APFloat::opOK);
  EXPECT_TRUE(test.bitwiseIsEqual(expected));

  // nextDown(qNaN) = qNaN
  test = APFloat::getQNaN(APFloat::IEEEquad(), false);
  expected = APFloat::getQNaN(APFloat::IEEEquad(), false);
  EXPECT_EQ(test.next(true), APFloat::opOK);
  EXPECT_TRUE(test.bitwiseIsEqual(expected));

  // nextUp(sNaN) = qNaN
  test = APFloat::getSNaN(APFloat::IEEEquad(), false);
  expected = APFloat::getQNaN(APFloat::IEEEquad(), false);
  EXPECT_EQ(test.next(false), APFloat::opInvalidOp);
  EXPECT_TRUE(test.bitwiseIsEqual(expected));

  // nextDown(sNaN) = qNaN
  test = APFloat::getSNaN(APFloat::IEEEquad(), false);
  expected = APFloat::getQNaN(APFloat::IEEEquad(), false);
  EXPECT_EQ(test.next(true), APFloat::opInvalidOp);
  EXPECT_TRUE(test.bitwiseIsEqual(expected));

  // nextUp(+0) = +getSmallest()
  test = APFloat::getZero(APFloat::IEEEquad(), false);
  expected = APFloat::getSmallest(APFloat::IEEEquad(), false);
  EXPECT_EQ(test.next(false), APFloat::opOK);
  EXPECT_TRUE(test.bitwiseIsEqual(expected));

  // nextDown(+0) = -nextUp(-0) = -getSmallest()
  test = APFloat::getZero(APFloat::IEEEquad(), false);
  expected = APFloat::getSmallest(APFloat::IEEEquad(), true);
  EXPECT_EQ(test.next(true), APFloat::opOK);
  EXPECT_TRUE(test.bitwiseIsEqual(expected));

  // nextUp(-0) = +getSmallest()
  test = APFloat::getZero(APFloat::IEEEquad(), true);
  expected = APFloat::getSmallest(APFloat::IEEEquad(), false);
  EXPECT_EQ(test.next(false), APFloat::opOK);
  EXPECT_TRUE(test.bitwiseIsEqual(expected));

  // nextDown(-0) = -nextUp(0) = -getSmallest()
  test = APFloat::getZero(APFloat::IEEEquad(), true);
  expected = APFloat::getSmallest(APFloat::IEEEquad(), true);
  EXPECT_EQ(test.next(true), APFloat::opOK);
  EXPECT_TRUE(test.bitwiseIsEqual(expected));

  // 2. Binade Boundary Tests.

  // 2a. Test denormal <-> normal binade boundaries.
  //     * nextUp(+Largest Denormal) -> +Smallest Normal.
  //     * nextDown(-Largest Denormal) -> -Smallest Normal.
  //     * nextUp(-Smallest Normal) -> -Largest Denormal.
  //     * nextDown(+Smallest Normal) -> +Largest Denormal.

  // nextUp(+Largest Denormal) -> +Smallest Normal.
  test = APFloat(APFloat::IEEEquad(), "0x0.ffffffffffffffffffffffffffffp-16382");
  expected = APFloat(APFloat::IEEEquad(),
                     "0x1.0000000000000000000000000000p-16382");
  EXPECT_EQ(test.next(false), APFloat::opOK);
  EXPECT_FALSE(test.isDenormal());
  EXPECT_TRUE(test.bitwiseIsEqual(expected));

  // nextDown(-Largest Denormal) -> -Smallest Normal.
  test = APFloat(APFloat::IEEEquad(),
                 "-0x0.ffffffffffffffffffffffffffffp-16382");
  expected = APFloat(APFloat::IEEEquad(),
                     "-0x1.0000000000000000000000000000p-16382");
  EXPECT_EQ(test.next(true), APFloat::opOK);
  EXPECT_FALSE(test.isDenormal());
  EXPECT_TRUE(test.bitwiseIsEqual(expected));

  // nextUp(-Smallest Normal) -> -LargestDenormal.
  test = APFloat(APFloat::IEEEquad(),
                 "-0x1.0000000000000000000000000000p-16382");
  expected = APFloat(APFloat::IEEEquad(),
                     "-0x0.ffffffffffffffffffffffffffffp-16382");
  EXPECT_EQ(test.next(false), APFloat::opOK);
  EXPECT_TRUE(test.isDenormal());
  EXPECT_TRUE(test.bitwiseIsEqual(expected));

  // nextDown(+Smallest Normal) -> +Largest Denormal.
  test = APFloat(APFloat::IEEEquad(),
                 "+0x1.0000000000000000000000000000p-16382");
  expected = APFloat(APFloat::IEEEquad(),
                     "+0x0.ffffffffffffffffffffffffffffp-16382");
  EXPECT_EQ(test.next(true), APFloat::opOK);
  EXPECT_TRUE(test.isDenormal());
  EXPECT_TRUE(test.bitwiseIsEqual(expected));

  // 2b. Test normal <-> normal binade boundaries.
  //     * nextUp(-Normal Binade Boundary) -> -Normal Binade Boundary + 1.
  //     * nextDown(+Normal Binade Boundary) -> +Normal Binade Boundary - 1.
  //     * nextUp(+Normal Binade Boundary - 1) -> +Normal Binade Boundary.
  //     * nextDown(-Normal Binade Boundary + 1) -> -Normal Binade Boundary.

  // nextUp(-Normal Binade Boundary) -> -Normal Binade Boundary + 1.
  test = APFloat(APFloat::IEEEquad(), "-0x1p+1");
  expected = APFloat(APFloat::IEEEquad(),
                     "-0x1.ffffffffffffffffffffffffffffp+0");
  EXPECT_EQ(test.next(false), APFloat::opOK);
  EXPECT_TRUE(test.bitwiseIsEqual(expected));

  // nextDown(+Normal Binade Boundary) -> +Normal Binade Boundary - 1.
  test = APFloat(APFloat::IEEEquad(), "0x1p+1");
  expected = APFloat(APFloat::IEEEquad(), "0x1.ffffffffffffffffffffffffffffp+0");
  EXPECT_EQ(test.next(true), APFloat::opOK);
  EXPECT_TRUE(test.bitwiseIsEqual(expected));

  // nextUp(+Normal Binade Boundary - 1) -> +Normal Binade Boundary.
  test = APFloat(APFloat::IEEEquad(), "0x1.ffffffffffffffffffffffffffffp+0");
  expected = APFloat(APFloat::IEEEquad(), "0x1p+1");
  EXPECT_EQ(test.next(false), APFloat::opOK);
  EXPECT_TRUE(test.bitwiseIsEqual(expected));

  // nextDown(-Normal Binade Boundary + 1) -> -Normal Binade Boundary.
  test = APFloat(APFloat::IEEEquad(), "-0x1.ffffffffffffffffffffffffffffp+0");
  expected = APFloat(APFloat::IEEEquad(), "-0x1p+1");
  EXPECT_EQ(test.next(true), APFloat::opOK);
  EXPECT_TRUE(test.bitwiseIsEqual(expected));

  // 2c. Test using next at binade boundaries with a direction away from the
  // binade boundary. Away from denormal <-> normal boundaries.
  //
  // This is to make sure that even though we are at a binade boundary, since
  // we are rounding away, we do not trigger the binade boundary code. Thus we
  // test:
  //   * nextUp(-Largest Denormal) -> -Largest Denormal + inc.
  //   * nextDown(+Largest Denormal) -> +Largest Denormal - inc.
  //   * nextUp(+Smallest Normal) -> +Smallest Normal + inc.
  //   * nextDown(-Smallest Normal) -> -Smallest Normal - inc.

  // nextUp(-Largest Denormal) -> -Largest Denormal + inc.
  test = APFloat(APFloat::IEEEquad(), "-0x0.ffffffffffffffffffffffffffffp-16382");
  expected = APFloat(APFloat::IEEEquad(),
                     "-0x0.fffffffffffffffffffffffffffep-16382");
  EXPECT_EQ(test.next(false), APFloat::opOK);
  EXPECT_TRUE(test.isDenormal());
  EXPECT_TRUE(test.isNegative());
  EXPECT_TRUE(test.bitwiseIsEqual(expected));

  // nextDown(+Largest Denormal) -> +Largest Denormal - inc.
  test = APFloat(APFloat::IEEEquad(), "0x0.ffffffffffffffffffffffffffffp-16382");
  expected = APFloat(APFloat::IEEEquad(),
                     "0x0.fffffffffffffffffffffffffffep-16382");
  EXPECT_EQ(test.next(true), APFloat::opOK);
  EXPECT_TRUE(test.isDenormal());
  EXPECT_TRUE(!test.isNegative());
  EXPECT_TRUE(test.bitwiseIsEqual(expected));

  // nextUp(+Smallest Normal) -> +Smallest Normal + inc.
  test = APFloat(APFloat::IEEEquad(), "0x1.0000000000000000000000000000p-16382");
  expected = APFloat(APFloat::IEEEquad(),
                     "0x1.0000000000000000000000000001p-16382");
  EXPECT_EQ(test.next(false), APFloat::opOK);
  EXPECT_TRUE(!test.isDenormal());
  EXPECT_TRUE(!test.isNegative());
  EXPECT_TRUE(test.bitwiseIsEqual(expected));

  // nextDown(-Smallest Normal) -> -Smallest Normal - inc.
  test = APFloat(APFloat::IEEEquad(), "-0x1.0000000000000000000000000000p-16382");
  expected = APFloat(APFloat::IEEEquad(),
                     "-0x1.0000000000000000000000000001p-16382");
  EXPECT_EQ(test.next(true), APFloat::opOK);
  EXPECT_TRUE(!test.isDenormal());
  EXPECT_TRUE(test.isNegative());
  EXPECT_TRUE(test.bitwiseIsEqual(expected));

  // 2d. Test values which cause our exponent to go to min exponent. This
  // is to ensure that guards in the code to check for min exponent
  // trigger properly.
  //     * nextUp(-0x1p-16381) -> -0x1.ffffffffffffffffffffffffffffp-16382
  //     * nextDown(-0x1.ffffffffffffffffffffffffffffp-16382) ->
  //         -0x1p-16381
  //     * nextUp(0x1.ffffffffffffffffffffffffffffp-16382) -> 0x1p-16382
  //     * nextDown(0x1p-16382) -> 0x1.ffffffffffffffffffffffffffffp-16382

  // nextUp(-0x1p-16381) -> -0x1.ffffffffffffffffffffffffffffp-16382
  test = APFloat(APFloat::IEEEquad(), "-0x1p-16381");
  expected = APFloat(APFloat::IEEEquad(),
                     "-0x1.ffffffffffffffffffffffffffffp-16382");
  EXPECT_EQ(test.next(false), APFloat::opOK);
  EXPECT_TRUE(test.bitwiseIsEqual(expected));

  // nextDown(-0x1.ffffffffffffffffffffffffffffp-16382) ->
  //         -0x1p-16381
  test = APFloat(APFloat::IEEEquad(), "-0x1.ffffffffffffffffffffffffffffp-16382");
  expected = APFloat(APFloat::IEEEquad(), "-0x1p-16381");
  EXPECT_EQ(test.next(true), APFloat::opOK);
  EXPECT_TRUE(test.bitwiseIsEqual(expected));

  // nextUp(0x1.ffffffffffffffffffffffffffffp-16382) -> 0x1p-16381
  test = APFloat(APFloat::IEEEquad(), "0x1.ffffffffffffffffffffffffffffp-16382");
  expected = APFloat(APFloat::IEEEquad(), "0x1p-16381");
  EXPECT_EQ(test.next(false), APFloat::opOK);
  EXPECT_TRUE(test.bitwiseIsEqual(expected));

  // nextDown(0x1p-16381) -> 0x1.ffffffffffffffffffffffffffffp-16382
  test = APFloat(APFloat::IEEEquad(), "0x1p-16381");
  expected = APFloat(APFloat::IEEEquad(),
                     "0x1.ffffffffffffffffffffffffffffp-16382");
  EXPECT_EQ(test.next(true), APFloat::opOK);
  EXPECT_TRUE(test.bitwiseIsEqual(expected));

  // 3. Now we test both denormal/normal computation which will not cause us
  // to go across binade boundaries. Specifically we test:
  //   * nextUp(+Denormal) -> +Denormal.
  //   * nextDown(+Denormal) -> +Denormal.
  //   * nextUp(-Denormal) -> -Denormal.
  //   * nextDown(-Denormal) -> -Denormal.
  //   * nextUp(+Normal) -> +Normal.
  //   * nextDown(+Normal) -> +Normal.
  //   * nextUp(-Normal) -> -Normal.
  //   * nextDown(-Normal) -> -Normal.

  // nextUp(+Denormal) -> +Denormal.
  test = APFloat(APFloat::IEEEquad(),
                 "0x0.ffffffffffffffffffffffff000cp-16382");
  expected = APFloat(APFloat::IEEEquad(),
                 "0x0.ffffffffffffffffffffffff000dp-16382");
  EXPECT_EQ(test.next(false), APFloat::opOK);
  EXPECT_TRUE(test.isDenormal());
  EXPECT_TRUE(!test.isNegative());
  EXPECT_TRUE(test.bitwiseIsEqual(expected));

  // nextDown(+Denormal) -> +Denormal.
  test = APFloat(APFloat::IEEEquad(),
                 "0x0.ffffffffffffffffffffffff000cp-16382");
  expected = APFloat(APFloat::IEEEquad(),
                 "0x0.ffffffffffffffffffffffff000bp-16382");
  EXPECT_EQ(test.next(true), APFloat::opOK);
  EXPECT_TRUE(test.isDenormal());
  EXPECT_TRUE(!test.isNegative());
  EXPECT_TRUE(test.bitwiseIsEqual(expected));

  // nextUp(-Denormal) -> -Denormal.
  test = APFloat(APFloat::IEEEquad(),
                 "-0x0.ffffffffffffffffffffffff000cp-16382");
  expected = APFloat(APFloat::IEEEquad(),
                 "-0x0.ffffffffffffffffffffffff000bp-16382");
  EXPECT_EQ(test.next(false), APFloat::opOK);
  EXPECT_TRUE(test.isDenormal());
  EXPECT_TRUE(test.isNegative());
  EXPECT_TRUE(test.bitwiseIsEqual(expected));

  // nextDown(-Denormal) -> -Denormal
  test = APFloat(APFloat::IEEEquad(),
                 "-0x0.ffffffffffffffffffffffff000cp-16382");
  expected = APFloat(APFloat::IEEEquad(),
                 "-0x0.ffffffffffffffffffffffff000dp-16382");
  EXPECT_EQ(test.next(true), APFloat::opOK);
  EXPECT_TRUE(test.isDenormal());
  EXPECT_TRUE(test.isNegative());
  EXPECT_TRUE(test.bitwiseIsEqual(expected));

  // nextUp(+Normal) -> +Normal.
  test = APFloat(APFloat::IEEEquad(),
                 "0x1.ffffffffffffffffffffffff000cp-16000");
  expected = APFloat(APFloat::IEEEquad(),
                 "0x1.ffffffffffffffffffffffff000dp-16000");
  EXPECT_EQ(test.next(false), APFloat::opOK);
  EXPECT_TRUE(!test.isDenormal());
  EXPECT_TRUE(!test.isNegative());
  EXPECT_TRUE(test.bitwiseIsEqual(expected));

  // nextDown(+Normal) -> +Normal.
  test = APFloat(APFloat::IEEEquad(),
                 "0x1.ffffffffffffffffffffffff000cp-16000");
  expected = APFloat(APFloat::IEEEquad(),
                 "0x1.ffffffffffffffffffffffff000bp-16000");
  EXPECT_EQ(test.next(true), APFloat::opOK);
  EXPECT_TRUE(!test.isDenormal());
  EXPECT_TRUE(!test.isNegative());
  EXPECT_TRUE(test.bitwiseIsEqual(expected));

  // nextUp(-Normal) -> -Normal.
  test = APFloat(APFloat::IEEEquad(),
                 "-0x1.ffffffffffffffffffffffff000cp-16000");
  expected = APFloat(APFloat::IEEEquad(),
                 "-0x1.ffffffffffffffffffffffff000bp-16000");
  EXPECT_EQ(test.next(false), APFloat::opOK);
  EXPECT_TRUE(!test.isDenormal());
  EXPECT_TRUE(test.isNegative());
  EXPECT_TRUE(test.bitwiseIsEqual(expected));

  // nextDown(-Normal) -> -Normal.
  test = APFloat(APFloat::IEEEquad(),
                 "-0x1.ffffffffffffffffffffffff000cp-16000");
  expected = APFloat(APFloat::IEEEquad(),
                 "-0x1.ffffffffffffffffffffffff000dp-16000");
  EXPECT_EQ(test.next(true), APFloat::opOK);
  EXPECT_TRUE(!test.isDenormal());
  EXPECT_TRUE(test.isNegative());
  EXPECT_TRUE(test.bitwiseIsEqual(expected));
}

TEST(APFloatTest, FMA) {
  APFloat::roundingMode rdmd = APFloat::rmNearestTiesToEven;

  {
    APFloat f1(14.5f);
    APFloat f2(-14.5f);
    APFloat f3(225.0f);
    f1.fusedMultiplyAdd(f2, f3, APFloat::rmNearestTiesToEven);
    EXPECT_EQ(14.75f, f1.convertToFloat());
  }

  {
    APFloat Val2(2.0f);
    APFloat f1((float)1.17549435e-38F);
    APFloat f2((float)1.17549435e-38F);
    f1.divide(Val2, rdmd);
    f2.divide(Val2, rdmd);
    APFloat f3(12.0f);
    f1.fusedMultiplyAdd(f2, f3, APFloat::rmNearestTiesToEven);
    EXPECT_EQ(12.0f, f1.convertToFloat());
  }

  // Test for correct zero sign when answer is exactly zero.
  // fma(1.0, -1.0, 1.0) -> +ve 0.
  {
    APFloat f1(1.0);
    APFloat f2(-1.0);
    APFloat f3(1.0);
    f1.fusedMultiplyAdd(f2, f3, APFloat::rmNearestTiesToEven);
    EXPECT_TRUE(!f1.isNegative() && f1.isZero());
  }

  // Test for correct zero sign when answer is exactly zero and rounding towards
  // negative.
  // fma(1.0, -1.0, 1.0) -> +ve 0.
  {
    APFloat f1(1.0);
    APFloat f2(-1.0);
    APFloat f3(1.0);
    f1.fusedMultiplyAdd(f2, f3, APFloat::rmTowardNegative);
    EXPECT_TRUE(f1.isNegative() && f1.isZero());
  }

  // Test for correct (in this case -ve) sign when adding like signed zeros.
  // Test fma(0.0, -0.0, -0.0) -> -ve 0.
  {
    APFloat f1(0.0);
    APFloat f2(-0.0);
    APFloat f3(-0.0);
    f1.fusedMultiplyAdd(f2, f3, APFloat::rmNearestTiesToEven);
    EXPECT_TRUE(f1.isNegative() && f1.isZero());
  }

  // Test -ve sign preservation when small negative results underflow.
  {
    APFloat f1(APFloat::IEEEdouble(),  "-0x1p-1074");
    APFloat f2(APFloat::IEEEdouble(), "+0x1p-1074");
    APFloat f3(0.0);
    f1.fusedMultiplyAdd(f2, f3, APFloat::rmNearestTiesToEven);
    EXPECT_TRUE(f1.isNegative() && f1.isZero());
  }

  // Test x87 extended precision case from http://llvm.org/PR20728.
  {
    APFloat M1(APFloat::x87DoubleExtended(), 1);
    APFloat M2(APFloat::x87DoubleExtended(), 1);
    APFloat A(APFloat::x87DoubleExtended(), 3);

    bool losesInfo = false;
    M1.fusedMultiplyAdd(M1, A, APFloat::rmNearestTiesToEven);
    M1.convert(APFloat::IEEEsingle(), APFloat::rmNearestTiesToEven, &losesInfo);
    EXPECT_FALSE(losesInfo);
    EXPECT_EQ(4.0f, M1.convertToFloat());
  }

  // Regression test that failed an assertion.
  {
    APFloat f1(-8.85242279E-41f);
    APFloat f2(2.0f);
    APFloat f3(8.85242279E-41f);
    f1.fusedMultiplyAdd(f2, f3, APFloat::rmNearestTiesToEven);
    EXPECT_EQ(-8.85242279E-41f, f1.convertToFloat());
  }

  // The `addOrSubtractSignificand` can be considered to have 9 possible cases
  // when subtracting: all combinations of {cmpLessThan, cmpGreaterThan,
  // cmpEqual} and {no loss, loss from lhs, loss from rhs}. Test each reachable
  // case here.

  // Regression test for failing the `assert(!carry)` in
  // `addOrSubtractSignificand` and normalizing the exponent even when the
  // significand is zero if there is a lost fraction.
  // This tests cmpEqual, loss from lhs
  {
    APFloat f1(-1.4728589E-38f);
    APFloat f2(3.7105144E-6f);
    APFloat f3(5.5E-44f);
    f1.fusedMultiplyAdd(f2, f3, APFloat::rmNearestTiesToEven);
    EXPECT_EQ(-0.0f, f1.convertToFloat());
  }

  // Test cmpGreaterThan, no loss
  {
    APFloat f1(2.0f);
    APFloat f2(2.0f);
    APFloat f3(-3.5f);
    f1.fusedMultiplyAdd(f2, f3, APFloat::rmNearestTiesToEven);
    EXPECT_EQ(0.5f, f1.convertToFloat());
  }

  // Test cmpLessThan, no loss
  {
    APFloat f1(2.0f);
    APFloat f2(2.0f);
    APFloat f3(-4.5f);
    f1.fusedMultiplyAdd(f2, f3, APFloat::rmNearestTiesToEven);
    EXPECT_EQ(-0.5f, f1.convertToFloat());
  }

  // Test cmpEqual, no loss
  {
    APFloat f1(2.0f);
    APFloat f2(2.0f);
    APFloat f3(-4.0f);
    f1.fusedMultiplyAdd(f2, f3, APFloat::rmNearestTiesToEven);
    EXPECT_EQ(0.0f, f1.convertToFloat());
  }

  // Test cmpLessThan, loss from lhs
  {
    APFloat f1(2.0000002f);
    APFloat f2(2.0000002f);
    APFloat f3(-32.0f);
    f1.fusedMultiplyAdd(f2, f3, APFloat::rmNearestTiesToEven);
    EXPECT_EQ(-27.999998f, f1.convertToFloat());
  }

  // Test cmpGreaterThan, loss from rhs
  {
    APFloat f1(1e10f);
    APFloat f2(1e10f);
    APFloat f3(-2.0000002f);
    f1.fusedMultiplyAdd(f2, f3, APFloat::rmNearestTiesToEven);
    EXPECT_EQ(1e20f, f1.convertToFloat());
  }

  // Test cmpGreaterThan, loss from lhs
  {
    APFloat f1(1e-36f);
    APFloat f2(0.0019531252f);
    APFloat f3(-1e-45f);
    f1.fusedMultiplyAdd(f2, f3, APFloat::rmNearestTiesToEven);
    EXPECT_EQ(1.953124e-39f, f1.convertToFloat());
  }

  // {cmpEqual, cmpLessThan} with loss from rhs can't occur for the usage in
  // `fusedMultiplyAdd` as `multiplySignificand` normalises the MSB of lhs to
  // one bit below the top.

  // Test cases from #104984
  {
    APFloat f1(0.24999998f);
    APFloat f2(2.3509885e-38f);
    APFloat f3(-1e-45f);
    f1.fusedMultiplyAdd(f2, f3, APFloat::rmNearestTiesToEven);
    EXPECT_EQ(5.87747e-39f, f1.convertToFloat());
  }
  {
    APFloat f1(4.4501477170144023e-308);
    APFloat f2(0.24999999999999997);
    APFloat f3(-8.475904604373977e-309);
    f1.fusedMultiplyAdd(f2, f3, APFloat::rmNearestTiesToEven);
    EXPECT_EQ(2.64946468816203e-309, f1.convertToDouble());
  }
  {
    APFloat f1(APFloat::IEEEhalf(), APInt(16, 0x8fffu));
    APFloat f2(APFloat::IEEEhalf(), APInt(16, 0x2bffu));
    APFloat f3(APFloat::IEEEhalf(), APInt(16, 0x0172u));
    f1.fusedMultiplyAdd(f2, f3, APFloat::rmNearestTiesToEven);
    EXPECT_EQ(0x808eu, f1.bitcastToAPInt().getZExtValue());
  }

  // Test using only a single instance of APFloat.
  {
    APFloat F(1.5);

    F.fusedMultiplyAdd(F, F, APFloat::rmNearestTiesToEven);
    EXPECT_EQ(3.75, F.convertToDouble());
  }
}

TEST(APFloatTest, MinNum) {
  APFloat f1(1.0);
  APFloat f2(2.0);
  APFloat nan = APFloat::getNaN(APFloat::IEEEdouble());

  EXPECT_EQ(1.0, minnum(f1, f2).convertToDouble());
  EXPECT_EQ(1.0, minnum(f2, f1).convertToDouble());
  EXPECT_EQ(1.0, minnum(f1, nan).convertToDouble());
  EXPECT_EQ(1.0, minnum(nan, f1).convertToDouble());

  APFloat zp(0.0);
  APFloat zn(-0.0);
  EXPECT_EQ(-0.0, minnum(zp, zn).convertToDouble());

  APInt intPayload_89ab(64, 0x89ab);
  APInt intPayload_cdef(64, 0xcdef);
  APFloat nan_0123[2] = {APFloat::getNaN(APFloat::IEEEdouble(), false, 0x0123),
                         APFloat::getNaN(APFloat::IEEEdouble(), false, 0x0123)};
  APFloat mnan_4567[2] = {APFloat::getNaN(APFloat::IEEEdouble(), true, 0x4567),
                          APFloat::getNaN(APFloat::IEEEdouble(), true, 0x4567)};
  APFloat nan_89ab[2] = {
      APFloat::getSNaN(APFloat::IEEEdouble(), false, &intPayload_89ab),
      APFloat::getNaN(APFloat::IEEEdouble(), false, 0x89ab)};
  APFloat mnan_cdef[2] = {
      APFloat::getSNaN(APFloat::IEEEdouble(), true, &intPayload_cdef),
      APFloat::getNaN(APFloat::IEEEdouble(), true, 0xcdef)};

  for (APFloat n : {nan_0123[0], mnan_4567[0]})
    for (APFloat f : {f1, f2, zn, zp}) {
      APFloat res = minnum(f, n);
      EXPECT_FALSE(res.isNaN());
      EXPECT_TRUE(res.bitwiseIsEqual(f));
      res = minnum(n, f);
      EXPECT_FALSE(res.isNaN());
      EXPECT_TRUE(res.bitwiseIsEqual(f));
    }
  for (auto n : {nan_89ab, mnan_cdef})
    for (APFloat f : {f1, f2, zn, zp}) {
      APFloat res = minnum(f, n[0]);
      EXPECT_TRUE(res.isNaN());
      EXPECT_TRUE(res.bitwiseIsEqual(n[1]));
      res = minnum(n[0], f);
      EXPECT_TRUE(res.isNaN());
      EXPECT_TRUE(res.bitwiseIsEqual(n[1]));
    }

  // When NaN vs NaN, we should keep payload/sign of either one.
  for (auto n1 : {nan_0123, mnan_4567, nan_89ab, mnan_cdef})
    for (auto n2 : {nan_0123, mnan_4567, nan_89ab, mnan_cdef}) {
      APFloat res = minnum(n1[0], n2[0]);
      EXPECT_TRUE(res.bitwiseIsEqual(n1[1]) || res.bitwiseIsEqual(n2[1]));
      EXPECT_FALSE(res.isSignaling());
    }
}

TEST(APFloatTest, MaxNum) {
  APFloat f1(1.0);
  APFloat f2(2.0);
  APFloat nan = APFloat::getNaN(APFloat::IEEEdouble());

  EXPECT_EQ(2.0, maxnum(f1, f2).convertToDouble());
  EXPECT_EQ(2.0, maxnum(f2, f1).convertToDouble());
  EXPECT_EQ(1.0, maxnum(f1, nan).convertToDouble());
  EXPECT_EQ(1.0, maxnum(nan, f1).convertToDouble());

  APFloat zp(0.0);
  APFloat zn(-0.0);
  EXPECT_EQ(0.0, maxnum(zp, zn).convertToDouble());
  EXPECT_EQ(0.0, maxnum(zn, zp).convertToDouble());

  APInt intPayload_89ab(64, 0x89ab);
  APInt intPayload_cdef(64, 0xcdef);
  APFloat nan_0123[2] = {APFloat::getNaN(APFloat::IEEEdouble(), false, 0x0123),
                         APFloat::getNaN(APFloat::IEEEdouble(), false, 0x0123)};
  APFloat mnan_4567[2] = {APFloat::getNaN(APFloat::IEEEdouble(), true, 0x4567),
                          APFloat::getNaN(APFloat::IEEEdouble(), true, 0x4567)};
  APFloat nan_89ab[2] = {
      APFloat::getSNaN(APFloat::IEEEdouble(), false, &intPayload_89ab),
      APFloat::getNaN(APFloat::IEEEdouble(), false, 0x89ab)};
  APFloat mnan_cdef[2] = {
      APFloat::getSNaN(APFloat::IEEEdouble(), true, &intPayload_cdef),
      APFloat::getNaN(APFloat::IEEEdouble(), true, 0xcdef)};

  for (APFloat n : {nan_0123[0], mnan_4567[0]})
    for (APFloat f : {f1, f2, zn, zp}) {
      APFloat res = maxnum(f, n);
      EXPECT_FALSE(res.isNaN());
      EXPECT_TRUE(res.bitwiseIsEqual(f));
      res = maxnum(n, f);
      EXPECT_FALSE(res.isNaN());
      EXPECT_TRUE(res.bitwiseIsEqual(f));
    }
  for (auto n : {nan_89ab, mnan_cdef})
    for (APFloat f : {f1, f2, zn, zp}) {
      APFloat res = maxnum(f, n[0]);
      EXPECT_TRUE(res.isNaN());
      EXPECT_TRUE(res.bitwiseIsEqual(n[1]));
      res = maxnum(n[0], f);
      EXPECT_TRUE(res.isNaN());
      EXPECT_TRUE(res.bitwiseIsEqual(n[1]));
    }

  // When NaN vs NaN, we should keep payload/sign of either one.
  for (auto n1 : {nan_0123, mnan_4567, nan_89ab, mnan_cdef})
    for (auto n2 : {nan_0123, mnan_4567, nan_89ab, mnan_cdef}) {
      APFloat res = maxnum(n1[0], n2[0]);
      EXPECT_TRUE(res.bitwiseIsEqual(n1[1]) || res.bitwiseIsEqual(n2[1]));
      EXPECT_FALSE(res.isSignaling());
    }
}

TEST(APFloatTest, Minimum) {
  APFloat f1(1.0);
  APFloat f2(2.0);
  APFloat zp(0.0);
  APFloat zn(-0.0);
  APFloat nan = APFloat::getNaN(APFloat::IEEEdouble());
  APFloat snan = APFloat::getSNaN(APFloat::IEEEdouble());

  EXPECT_EQ(1.0, minimum(f1, f2).convertToDouble());
  EXPECT_EQ(1.0, minimum(f2, f1).convertToDouble());
  EXPECT_EQ(-0.0, minimum(zp, zn).convertToDouble());
  EXPECT_EQ(-0.0, minimum(zn, zp).convertToDouble());
  EXPECT_TRUE(std::isnan(minimum(f1, nan).convertToDouble()));
  EXPECT_TRUE(std::isnan(minimum(nan, f1).convertToDouble()));
  EXPECT_TRUE(maximum(snan, f1).isNaN());
  EXPECT_TRUE(maximum(f1, snan).isNaN());
  EXPECT_FALSE(maximum(snan, f1).isSignaling());
  EXPECT_FALSE(maximum(f1, snan).isSignaling());
}

TEST(APFloatTest, Maximum) {
  APFloat f1(1.0);
  APFloat f2(2.0);
  APFloat zp(0.0);
  APFloat zn(-0.0);
  APFloat nan = APFloat::getNaN(APFloat::IEEEdouble());
  APFloat snan = APFloat::getSNaN(APFloat::IEEEdouble());

  EXPECT_EQ(2.0, maximum(f1, f2).convertToDouble());
  EXPECT_EQ(2.0, maximum(f2, f1).convertToDouble());
  EXPECT_EQ(0.0, maximum(zp, zn).convertToDouble());
  EXPECT_EQ(0.0, maximum(zn, zp).convertToDouble());
  EXPECT_TRUE(std::isnan(maximum(f1, nan).convertToDouble()));
  EXPECT_TRUE(std::isnan(maximum(nan, f1).convertToDouble()));
  EXPECT_TRUE(maximum(snan, f1).isNaN());
  EXPECT_TRUE(maximum(f1, snan).isNaN());
  EXPECT_FALSE(maximum(snan, f1).isSignaling());
  EXPECT_FALSE(maximum(f1, snan).isSignaling());
}

TEST(APFloatTest, MinimumNumber) {
  APFloat f1(1.0);
  APFloat f2(2.0);
  APFloat zp(0.0);
  APFloat zn(-0.0);
  APInt intPayload_89ab(64, 0x89ab);
  APInt intPayload_cdef(64, 0xcdef);
  APFloat nan_0123[2] = {APFloat::getNaN(APFloat::IEEEdouble(), false, 0x0123),
                         APFloat::getNaN(APFloat::IEEEdouble(), false, 0x0123)};
  APFloat mnan_4567[2] = {APFloat::getNaN(APFloat::IEEEdouble(), true, 0x4567),
                          APFloat::getNaN(APFloat::IEEEdouble(), true, 0x4567)};
  APFloat nan_89ab[2] = {
      APFloat::getSNaN(APFloat::IEEEdouble(), false, &intPayload_89ab),
      APFloat::getNaN(APFloat::IEEEdouble(), false, 0x89ab)};
  APFloat mnan_cdef[2] = {
      APFloat::getSNaN(APFloat::IEEEdouble(), true, &intPayload_cdef),
      APFloat::getNaN(APFloat::IEEEdouble(), true, 0xcdef)};

  EXPECT_TRUE(f1.bitwiseIsEqual(minimumnum(f1, f2)));
  EXPECT_TRUE(f1.bitwiseIsEqual(minimumnum(f2, f1)));
  EXPECT_TRUE(zn.bitwiseIsEqual(minimumnum(zp, zn)));
  EXPECT_TRUE(zn.bitwiseIsEqual(minimumnum(zn, zp)));

  EXPECT_TRUE(minimumnum(zn, zp).isNegative());
  EXPECT_TRUE(minimumnum(zp, zn).isNegative());
  EXPECT_TRUE(minimumnum(zn, zn).isNegative());
  EXPECT_FALSE(minimumnum(zp, zp).isNegative());

  for (APFloat n : {nan_0123[0], mnan_4567[0], nan_89ab[0], mnan_cdef[0]})
    for (APFloat f : {f1, f2, zn, zp}) {
      APFloat res = minimumnum(f, n);
      EXPECT_FALSE(res.isNaN());
      EXPECT_TRUE(res.bitwiseIsEqual(f));
      res = minimumnum(n, f);
      EXPECT_FALSE(res.isNaN());
      EXPECT_TRUE(res.bitwiseIsEqual(f));
    }

  // When NaN vs NaN, we should keep payload/sign of either one.
  for (auto n1 : {nan_0123, mnan_4567, nan_89ab, mnan_cdef})
    for (auto n2 : {nan_0123, mnan_4567, nan_89ab, mnan_cdef}) {
      APFloat res = minimumnum(n1[0], n2[0]);
      EXPECT_TRUE(res.bitwiseIsEqual(n1[1]) || res.bitwiseIsEqual(n2[1]));
      EXPECT_FALSE(res.isSignaling());
    }
}

TEST(APFloatTest, MaximumNumber) {
  APFloat f1(1.0);
  APFloat f2(2.0);
  APFloat zp(0.0);
  APFloat zn(-0.0);
  APInt intPayload_89ab(64, 0x89ab);
  APInt intPayload_cdef(64, 0xcdef);
  APFloat nan_0123[2] = {APFloat::getNaN(APFloat::IEEEdouble(), false, 0x0123),
                         APFloat::getNaN(APFloat::IEEEdouble(), false, 0x0123)};
  APFloat mnan_4567[2] = {APFloat::getNaN(APFloat::IEEEdouble(), true, 0x4567),
                          APFloat::getNaN(APFloat::IEEEdouble(), true, 0x4567)};
  APFloat nan_89ab[2] = {
      APFloat::getSNaN(APFloat::IEEEdouble(), false, &intPayload_89ab),
      APFloat::getNaN(APFloat::IEEEdouble(), false, 0x89ab)};
  APFloat mnan_cdef[2] = {
      APFloat::getSNaN(APFloat::IEEEdouble(), true, &intPayload_cdef),
      APFloat::getNaN(APFloat::IEEEdouble(), true, 0xcdef)};

  EXPECT_TRUE(f2.bitwiseIsEqual(maximumnum(f1, f2)));
  EXPECT_TRUE(f2.bitwiseIsEqual(maximumnum(f2, f1)));
  EXPECT_TRUE(zp.bitwiseIsEqual(maximumnum(zp, zn)));
  EXPECT_TRUE(zp.bitwiseIsEqual(maximumnum(zn, zp)));

  EXPECT_FALSE(maximumnum(zn, zp).isNegative());
  EXPECT_FALSE(maximumnum(zp, zn).isNegative());
  EXPECT_TRUE(maximumnum(zn, zn).isNegative());
  EXPECT_FALSE(maximumnum(zp, zp).isNegative());

  for (APFloat n : {nan_0123[0], mnan_4567[0], nan_89ab[0], mnan_cdef[0]})
    for (APFloat f : {f1, f2, zn, zp}) {
      APFloat res = maximumnum(f, n);
      EXPECT_FALSE(res.isNaN());
      EXPECT_TRUE(res.bitwiseIsEqual(f));
      res = maximumnum(n, f);
      EXPECT_FALSE(res.isNaN());
      EXPECT_TRUE(res.bitwiseIsEqual(f));
    }

  // When NaN vs NaN, we should keep payload/sign of either one.
  for (auto n1 : {nan_0123, mnan_4567, nan_89ab, mnan_cdef})
    for (auto n2 : {nan_0123, mnan_4567, nan_89ab, mnan_cdef}) {
      APFloat res = maximumnum(n1[0], n2[0]);
      EXPECT_TRUE(res.bitwiseIsEqual(n1[1]) || res.bitwiseIsEqual(n2[1]));
      EXPECT_FALSE(res.isSignaling());
    }
}

TEST(APFloatTest, Denormal) {
  APFloat::roundingMode rdmd = APFloat::rmNearestTiesToEven;

  // Test single precision
  {
    const char *MinNormalStr = "1.17549435082228750797e-38";
    EXPECT_FALSE(APFloat(APFloat::IEEEsingle(), MinNormalStr).isDenormal());
    EXPECT_FALSE(APFloat(APFloat::IEEEsingle(), 0).isDenormal());

    APFloat Val2(APFloat::IEEEsingle(), 2);
    APFloat T(APFloat::IEEEsingle(), MinNormalStr);
    T.divide(Val2, rdmd);
    EXPECT_TRUE(T.isDenormal());
    EXPECT_EQ(fcPosSubnormal, T.classify());


    const char *NegMinNormalStr = "-1.17549435082228750797e-38";
    EXPECT_FALSE(APFloat(APFloat::IEEEsingle(), NegMinNormalStr).isDenormal());
    APFloat NegT(APFloat::IEEEsingle(), NegMinNormalStr);
    NegT.divide(Val2, rdmd);
    EXPECT_TRUE(NegT.isDenormal());
    EXPECT_EQ(fcNegSubnormal, NegT.classify());
  }

  // Test double precision
  {
    const char *MinNormalStr = "2.22507385850720138309e-308";
    EXPECT_FALSE(APFloat(APFloat::IEEEdouble(), MinNormalStr).isDenormal());
    EXPECT_FALSE(APFloat(APFloat::IEEEdouble(), 0).isDenormal());

    APFloat Val2(APFloat::IEEEdouble(), 2);
    APFloat T(APFloat::IEEEdouble(), MinNormalStr);
    T.divide(Val2, rdmd);
    EXPECT_TRUE(T.isDenormal());
    EXPECT_EQ(fcPosSubnormal, T.classify());
  }

  // Test Intel double-ext
  {
    const char *MinNormalStr = "3.36210314311209350626e-4932";
    EXPECT_FALSE(APFloat(APFloat::x87DoubleExtended(), MinNormalStr).isDenormal());
    EXPECT_FALSE(APFloat(APFloat::x87DoubleExtended(), 0).isDenormal());

    APFloat Val2(APFloat::x87DoubleExtended(), 2);
    APFloat T(APFloat::x87DoubleExtended(), MinNormalStr);
    T.divide(Val2, rdmd);
    EXPECT_TRUE(T.isDenormal());
    EXPECT_EQ(fcPosSubnormal, T.classify());
  }

  // Test quadruple precision
  {
    const char *MinNormalStr = "3.36210314311209350626267781732175260e-4932";
    EXPECT_FALSE(APFloat(APFloat::IEEEquad(), MinNormalStr).isDenormal());
    EXPECT_FALSE(APFloat(APFloat::IEEEquad(), 0).isDenormal());

    APFloat Val2(APFloat::IEEEquad(), 2);
    APFloat T(APFloat::IEEEquad(), MinNormalStr);
    T.divide(Val2, rdmd);
    EXPECT_TRUE(T.isDenormal());
    EXPECT_EQ(fcPosSubnormal, T.classify());
  }

  // Test TF32
  {
    const char *MinNormalStr = "1.17549435082228750797e-38";
    EXPECT_FALSE(APFloat(APFloat::FloatTF32(), MinNormalStr).isDenormal());
    EXPECT_FALSE(APFloat(APFloat::FloatTF32(), 0).isDenormal());

    APFloat Val2(APFloat::FloatTF32(), 2);
    APFloat T(APFloat::FloatTF32(), MinNormalStr);
    T.divide(Val2, rdmd);
    EXPECT_TRUE(T.isDenormal());
    EXPECT_EQ(fcPosSubnormal, T.classify());

    const char *NegMinNormalStr = "-1.17549435082228750797e-38";
    EXPECT_FALSE(APFloat(APFloat::FloatTF32(), NegMinNormalStr).isDenormal());
    APFloat NegT(APFloat::FloatTF32(), NegMinNormalStr);
    NegT.divide(Val2, rdmd);
    EXPECT_TRUE(NegT.isDenormal());
    EXPECT_EQ(fcNegSubnormal, NegT.classify());
  }

  // Test E8M0
  {
    APInt bits(8, 0);
    APFloat minExp(APFloat::Float8E8M0FNU(), bits);
    EXPECT_FALSE(minExp.isDenormal());
  }
}

TEST(APFloatTest, IsSmallestNormalized) {
  for (unsigned I = 0; I != APFloat::S_MaxSemantics + 1; ++I) {
    const fltSemantics &Semantics =
        APFloat::EnumToSemantics(static_cast<APFloat::Semantics>(I));

    // For Float8E8M0FNU format, the below cases are tested
    // through Float8E8M0FNUSmallest and Float8E8M0FNUNext tests.
    if (I == APFloat::S_Float8E8M0FNU)
      continue;

    EXPECT_FALSE(APFloat::getZero(Semantics, false).isSmallestNormalized());
    if (Semantics.hasSignedRepr)
      EXPECT_FALSE(APFloat::getZero(Semantics, true).isSmallestNormalized());

    if (APFloat::semanticsHasNaN(Semantics)) {
      // Types that do not support Inf will return NaN when asked for Inf.
      // (But only if they support NaN.)
      EXPECT_FALSE(APFloat::getInf(Semantics, false).isSmallestNormalized());
      if (Semantics.hasSignedRepr)
        EXPECT_FALSE(APFloat::getInf(Semantics, true).isSmallestNormalized());

      EXPECT_FALSE(APFloat::getQNaN(Semantics).isSmallestNormalized());
      EXPECT_FALSE(APFloat::getSNaN(Semantics).isSmallestNormalized());
    }

    EXPECT_FALSE(APFloat::getLargest(Semantics).isSmallestNormalized());
    if (Semantics.hasSignedRepr)
      EXPECT_FALSE(APFloat::getLargest(Semantics, true).isSmallestNormalized());

    EXPECT_FALSE(APFloat::getSmallest(Semantics).isSmallestNormalized());
    if (Semantics.hasSignedRepr)
      EXPECT_FALSE(
          APFloat::getSmallest(Semantics, true).isSmallestNormalized());

    EXPECT_FALSE(APFloat::getAllOnesValue(Semantics).isSmallestNormalized());

    APFloat PosSmallestNormalized =
        APFloat::getSmallestNormalized(Semantics, false);
    EXPECT_TRUE(PosSmallestNormalized.isSmallestNormalized());
    EXPECT_EQ(fcPosNormal, PosSmallestNormalized.classify());

    SmallVector<std::optional<APFloat>> Vals = {PosSmallestNormalized};
    std::optional<APFloat> NegSmallestNormalized;
    if (Semantics.hasSignedRepr) {
      NegSmallestNormalized = APFloat::getSmallestNormalized(Semantics, true);
      EXPECT_TRUE(NegSmallestNormalized->isSmallestNormalized());
      EXPECT_EQ(fcNegNormal, NegSmallestNormalized->classify());
      Vals.push_back(NegSmallestNormalized);
    }

    for (auto &Val : Vals) {
      bool OldSign = Val->isNegative();

      // Step down, make sure it's still not smallest normalized.
      EXPECT_EQ(APFloat::opOK, Val->next(false));
      EXPECT_EQ(OldSign, Val->isNegative());
      EXPECT_FALSE(Val->isSmallestNormalized());
      EXPECT_EQ(OldSign, Val->isNegative());

      // Step back up should restore it to being smallest normalized.
      EXPECT_EQ(APFloat::opOK, Val->next(true));
      EXPECT_TRUE(Val->isSmallestNormalized());
      EXPECT_EQ(OldSign, Val->isNegative());

      // Step beyond should no longer smallest normalized.
      EXPECT_EQ(APFloat::opOK, Val->next(true));
      EXPECT_FALSE(Val->isSmallestNormalized());
      EXPECT_EQ(OldSign, Val->isNegative());
    }
  }
}

TEST(APFloatTest, Zero) {
  EXPECT_EQ(0.0f,  APFloat(0.0f).convertToFloat());
  EXPECT_EQ(-0.0f, APFloat(-0.0f).convertToFloat());
  EXPECT_TRUE(APFloat(-0.0f).isNegative());

  EXPECT_EQ(0.0,  APFloat(0.0).convertToDouble());
  EXPECT_EQ(-0.0, APFloat(-0.0).convertToDouble());
  EXPECT_TRUE(APFloat(-0.0).isNegative());

  EXPECT_EQ(fcPosZero, APFloat(0.0).classify());
  EXPECT_EQ(fcNegZero, APFloat(-0.0).classify());
}

TEST(APFloatTest, getOne) {
  EXPECT_EQ(APFloat::getOne(APFloat::IEEEsingle(), false).convertToFloat(),
            1.0f);
  EXPECT_EQ(APFloat::getOne(APFloat::IEEEsingle(), true).convertToFloat(),
            -1.0f);
}

TEST(APFloatTest, DecimalStringsWithoutNullTerminators) {
  // Make sure that we can parse strings without null terminators.
  // rdar://14323230.
  EXPECT_EQ(convertToDoubleFromString(StringRef("0.00", 3)), 0.0);
  EXPECT_EQ(convertToDoubleFromString(StringRef("0.01", 3)), 0.0);
  EXPECT_EQ(convertToDoubleFromString(StringRef("0.09", 3)), 0.0);
  EXPECT_EQ(convertToDoubleFromString(StringRef("0.095", 4)), 0.09);
  EXPECT_EQ(convertToDoubleFromString(StringRef("0.00e+3", 7)), 0.00);
  EXPECT_EQ(convertToDoubleFromString(StringRef("0e+3", 4)), 0.00);
}

TEST(APFloatTest, fromZeroDecimalString) {
  EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(),  "0").convertToDouble());
  EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0").convertToDouble());
  EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0").convertToDouble());

  EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(),  "0.").convertToDouble());
  EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0.").convertToDouble());
  EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0.").convertToDouble());

  EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(),  ".0").convertToDouble());
  EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+.0").convertToDouble());
  EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-.0").convertToDouble());

  EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(),  "0.0").convertToDouble());
  EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0.0").convertToDouble());
  EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0.0").convertToDouble());

  EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(),  "00000.").convertToDouble());
  EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+00000.").convertToDouble());
  EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-00000.").convertToDouble());

  EXPECT_EQ(0.0,  APFloat(APFloat::IEEEdouble(), ".00000").convertToDouble());
  EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+.00000").convertToDouble());
  EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-.00000").convertToDouble());

  EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(),  "0000.00000").convertToDouble());
  EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0000.00000").convertToDouble());
  EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0000.00000").convertToDouble());
}

TEST(APFloatTest, fromZeroDecimalSingleExponentString) {
  EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(),   "0e1").convertToDouble());
  EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(),  "+0e1").convertToDouble());
  EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(),  "-0e1").convertToDouble());

  EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(),  "0e+1").convertToDouble());
  EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0e+1").convertToDouble());
  EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0e+1").convertToDouble());

  EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(),  "0e-1").convertToDouble());
  EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0e-1").convertToDouble());
  EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0e-1").convertToDouble());


  EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(),   "0.e1").convertToDouble());
  EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(),  "+0.e1").convertToDouble());
  EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(),  "-0.e1").convertToDouble());

  EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(),  "0.e+1").convertToDouble());
  EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0.e+1").convertToDouble());
  EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0.e+1").convertToDouble());

  EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(),  "0.e-1").convertToDouble());
  EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0.e-1").convertToDouble());
  EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0.e-1").convertToDouble());

  EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(),   ".0e1").convertToDouble());
  EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(),  "+.0e1").convertToDouble());
  EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(),  "-.0e1").convertToDouble());

  EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(),  ".0e+1").convertToDouble());
  EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+.0e+1").convertToDouble());
  EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-.0e+1").convertToDouble());

  EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(),  ".0e-1").convertToDouble());
  EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+.0e-1").convertToDouble());
  EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-.0e-1").convertToDouble());


  EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(),   "0.0e1").convertToDouble());
  EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(),  "+0.0e1").convertToDouble());
  EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(),  "-0.0e1").convertToDouble());

  EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(),  "0.0e+1").convertToDouble());
  EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0.0e+1").convertToDouble());
  EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0.0e+1").convertToDouble());

  EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(),  "0.0e-1").convertToDouble());
  EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0.0e-1").convertToDouble());
  EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0.0e-1").convertToDouble());


  EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(),  "000.0000e1").convertToDouble());
  EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+000.0000e+1").convertToDouble());
  EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-000.0000e+1").convertToDouble());
}

TEST(APFloatTest, fromZeroDecimalLargeExponentString) {
  EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(),  "0e1234").convertToDouble());
  EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0e1234").convertToDouble());
  EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0e1234").convertToDouble());

  EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(),  "0e+1234").convertToDouble());
  EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0e+1234").convertToDouble());
  EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0e+1234").convertToDouble());

  EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(),  "0e-1234").convertToDouble());
  EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0e-1234").convertToDouble());
  EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0e-1234").convertToDouble());

  EXPECT_EQ(0.0,  APFloat(APFloat::IEEEdouble(), "000.0000e1234").convertToDouble());
  EXPECT_EQ(0.0,  APFloat(APFloat::IEEEdouble(), "000.0000e-1234").convertToDouble());

  EXPECT_EQ(0.0,  APFloat(APFloat::IEEEdouble(), StringRef("0e1234" "\0" "2", 6)).convertToDouble());
}

TEST(APFloatTest, DecimalStringsUseLargePowersOfFive) {
  // These values are just below one, so they cannot take the early obvious
  // underflow path. The number of fractional digits is the power passed to
  // powerOf5(). Together, the cases exercise the high entries and different
  // combinations of the precomputed powers-of-five table.
  struct TestCase {
    const fltSemantics &Sem;
    unsigned FractionalDigits;
  };
  const TestCase Tests[] = {
      {APFloat::IEEEhalf(), 8192},
      {APFloat::IEEEsingle(), 12288},
      {APFloat::IEEEdouble(), 16376},
      {APFloat::IEEEquad(), 16383},
  };

  for (const TestCase &Test : Tests) {
    std::string Input = "0." + std::string(Test.FractionalDigits, '9');
    APFloat Value(Test.Sem);
    auto StatusOr =
        Value.convertFromString(Input, APFloat::rmNearestTiesToEven);
    ASSERT_TRUE(!!StatusOr) << Test.FractionalDigits;
    EXPECT_TRUE(*StatusOr & APFloat::opInexact) << Test.FractionalDigits;
    EXPECT_TRUE(Value.bitwiseIsEqual(APFloat::getOne(Test.Sem, false)))
        << Test.FractionalDigits;
  }
}

TEST(APFloatTest, fromZeroHexadecimalString) {
  EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(),  "0x0p1").convertToDouble());
  EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x0p1").convertToDouble());
  EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x0p1").convertToDouble());

  EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(),  "0x0p+1").convertToDouble());
  EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x0p+1").convertToDouble());
  EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x0p+1").convertToDouble());

  EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(),  "0x0p-1").convertToDouble());
  EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x0p-1").convertToDouble());
  EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x0p-1").convertToDouble());


  EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(),  "0x0.p1").convertToDouble());
  EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x0.p1").convertToDouble());
  EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x0.p1").convertToDouble());

  EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(),  "0x0.p+1").convertToDouble());
  EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x0.p+1").convertToDouble());
  EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x0.p+1").convertToDouble());

  EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(),  "0x0.p-1").convertToDouble());
  EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x0.p-1").convertToDouble());
  EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x0.p-1").convertToDouble());


  EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(),  "0x.0p1").convertToDouble());
  EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x.0p1").convertToDouble());
  EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x.0p1").convertToDouble());

  EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(),  "0x.0p+1").convertToDouble());
  EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x.0p+1").convertToDouble());
  EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x.0p+1").convertToDouble());

  EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(),  "0x.0p-1").convertToDouble());
  EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x.0p-1").convertToDouble());
  EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x.0p-1").convertToDouble());


  EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(),  "0x0.0p1").convertToDouble());
  EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x0.0p1").convertToDouble());
  EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x0.0p1").convertToDouble());

  EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(),  "0x0.0p+1").convertToDouble());
  EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x0.0p+1").convertToDouble());
  EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x0.0p+1").convertToDouble());

  EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(),  "0x0.0p-1").convertToDouble());
  EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x0.0p-1").convertToDouble());
  EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x0.0p-1").convertToDouble());


  EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x00000.p1").convertToDouble());
  EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0000.00000p1").convertToDouble());
  EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x.00000p1").convertToDouble());
  EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0.p1").convertToDouble());
  EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0p1234").convertToDouble());
  EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x0p1234").convertToDouble());
  EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x00000.p1234").convertToDouble());
  EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0000.00000p1234").convertToDouble());
  EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x.00000p1234").convertToDouble());
  EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0.p1234").convertToDouble());
}

TEST(APFloatTest, fromDecimalString) {
  EXPECT_EQ(1.0,      APFloat(APFloat::IEEEdouble(), "1").convertToDouble());
  EXPECT_EQ(2.0,      APFloat(APFloat::IEEEdouble(), "2.").convertToDouble());
  EXPECT_EQ(0.5,      APFloat(APFloat::IEEEdouble(), ".5").convertToDouble());
  EXPECT_EQ(1.0,      APFloat(APFloat::IEEEdouble(), "1.0").convertToDouble());
  EXPECT_EQ(-2.0,     APFloat(APFloat::IEEEdouble(), "-2").convertToDouble());
  EXPECT_EQ(-4.0,     APFloat(APFloat::IEEEdouble(), "-4.").convertToDouble());
  EXPECT_EQ(-0.5,     APFloat(APFloat::IEEEdouble(), "-.5").convertToDouble());
  EXPECT_EQ(-1.5,     APFloat(APFloat::IEEEdouble(), "-1.5").convertToDouble());
  EXPECT_EQ(1.25e12,  APFloat(APFloat::IEEEdouble(), "1.25e12").convertToDouble());
  EXPECT_EQ(1.25e+12, APFloat(APFloat::IEEEdouble(), "1.25e+12").convertToDouble());
  EXPECT_EQ(1.25e-12, APFloat(APFloat::IEEEdouble(), "1.25e-12").convertToDouble());
  EXPECT_EQ(1024.0,   APFloat(APFloat::IEEEdouble(), "1024.").convertToDouble());
  EXPECT_EQ(1024.05,  APFloat(APFloat::IEEEdouble(), "1024.05000").convertToDouble());
  EXPECT_EQ(0.05,     APFloat(APFloat::IEEEdouble(), ".05000").convertToDouble());
  EXPECT_EQ(2.0,      APFloat(APFloat::IEEEdouble(), "2.").convertToDouble());
  EXPECT_EQ(2.0e2,    APFloat(APFloat::IEEEdouble(), "2.e2").convertToDouble());
  EXPECT_EQ(2.0e+2,   APFloat(APFloat::IEEEdouble(), "2.e+2").convertToDouble());
  EXPECT_EQ(2.0e-2,   APFloat(APFloat::IEEEdouble(), "2.e-2").convertToDouble());
  EXPECT_EQ(2.05e2,    APFloat(APFloat::IEEEdouble(), "002.05000e2").convertToDouble());
  EXPECT_EQ(2.05e+2,   APFloat(APFloat::IEEEdouble(), "002.05000e+2").convertToDouble());
  EXPECT_EQ(2.05e-2,   APFloat(APFloat::IEEEdouble(), "002.05000e-2").convertToDouble());
  EXPECT_EQ(2.05e12,   APFloat(APFloat::IEEEdouble(), "002.05000e12").convertToDouble());
  EXPECT_EQ(2.05e+12,  APFloat(APFloat::IEEEdouble(), "002.05000e+12").convertToDouble());
  EXPECT_EQ(2.05e-12,  APFloat(APFloat::IEEEdouble(), "002.05000e-12").convertToDouble());

  EXPECT_EQ(1.0,      APFloat(APFloat::IEEEdouble(), "1e").convertToDouble());
  EXPECT_EQ(1.0,      APFloat(APFloat::IEEEdouble(), "+1e").convertToDouble());
  EXPECT_EQ(-1.0,      APFloat(APFloat::IEEEdouble(), "-1e").convertToDouble());

  EXPECT_EQ(1.0,      APFloat(APFloat::IEEEdouble(), "1.e").convertToDouble());
  EXPECT_EQ(1.0,      APFloat(APFloat::IEEEdouble(), "+1.e").convertToDouble());
  EXPECT_EQ(-1.0,      APFloat(APFloat::IEEEdouble(), "-1.e").convertToDouble());

  EXPECT_EQ(0.1,      APFloat(APFloat::IEEEdouble(), ".1e").convertToDouble());
  EXPECT_EQ(0.1,      APFloat(APFloat::IEEEdouble(), "+.1e").convertToDouble());
  EXPECT_EQ(-0.1,      APFloat(APFloat::IEEEdouble(), "-.1e").convertToDouble());

  EXPECT_EQ(1.1,      APFloat(APFloat::IEEEdouble(), "1.1e").convertToDouble());
  EXPECT_EQ(1.1,      APFloat(APFloat::IEEEdouble(), "+1.1e").convertToDouble());
  EXPECT_EQ(-1.1,      APFloat(APFloat::IEEEdouble(), "-1.1e").convertToDouble());

  EXPECT_EQ(1.0,      APFloat(APFloat::IEEEdouble(), "1e+").convertToDouble());
  EXPECT_EQ(1.0,      APFloat(APFloat::IEEEdouble(), "1e-").convertToDouble());

  EXPECT_EQ(0.1,      APFloat(APFloat::IEEEdouble(), ".1e").convertToDouble());
  EXPECT_EQ(0.1,      APFloat(APFloat::IEEEdouble(), ".1e+").convertToDouble());
  EXPECT_EQ(0.1,      APFloat(APFloat::IEEEdouble(), ".1e-").convertToDouble());

  EXPECT_EQ(1.0,      APFloat(APFloat::IEEEdouble(), "1.0e").convertToDouble());
  EXPECT_EQ(1.0,      APFloat(APFloat::IEEEdouble(), "1.0e+").convertToDouble());
  EXPECT_EQ(1.0,      APFloat(APFloat::IEEEdouble(), "1.0e-").convertToDouble());

  // These are "carefully selected" to overflow the fast log-base
  // calculations in APFloat.cpp
  EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "99e99999").isInfinity());
  EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "-99e99999").isInfinity());
  EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "1e-99999").isPosZero());
  EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "-1e-99999").isNegZero());

  EXPECT_EQ(2.71828, convertToDoubleFromString("2.71828"));
}

TEST(APFloatTest, fromStringSpecials) {
  const fltSemantics &Sem = APFloat::IEEEdouble();
  const unsigned Precision = 53;
  const unsigned PayloadBits = Precision - 2;
  uint64_t PayloadMask = (uint64_t(1) << PayloadBits) - uint64_t(1);

  uint64_t NaNPayloads[] = {
      0,
      1,
      123,
      0xDEADBEEF,
      uint64_t(-2),
      uint64_t(1) << PayloadBits,       // overflow bit
      uint64_t(1) << (PayloadBits - 1), // signaling bit
      uint64_t(1) << (PayloadBits - 2)  // highest possible bit
  };

  // Convert payload integer to decimal string representation.
  std::string NaNPayloadDecStrings[std::size(NaNPayloads)];
  for (size_t I = 0; I < std::size(NaNPayloads); ++I)
    NaNPayloadDecStrings[I] = utostr(NaNPayloads[I]);

  // Convert payload integer to hexadecimal string representation.
  std::string NaNPayloadHexStrings[std::size(NaNPayloads)];
  for (size_t I = 0; I < std::size(NaNPayloads); ++I)
    NaNPayloadHexStrings[I] = "0x" + utohexstr(NaNPayloads[I]);

  // Fix payloads to expected result.
  for (uint64_t &Payload : NaNPayloads)
    Payload &= PayloadMask;

  // Signaling NaN must have a non-zero payload. In case a zero payload is
  // requested, a default arbitrary payload is set instead. Save this payload
  // for testing.
  const uint64_t SNaNDefaultPayload =
      APFloat::getSNaN(Sem).bitcastToAPInt().getZExtValue() & PayloadMask;

  // Negative sign prefix (or none - for positive).
  const char Signs[] = {0, '-'};

  // "Signaling" prefix (or none - for "Quiet").
  const char NaNTypes[] = {0, 's', 'S'};

  const StringRef NaNStrings[] = {"nan", "NaN"};
  for (StringRef NaNStr : NaNStrings)
    for (char TypeChar : NaNTypes) {
      bool Signaling = (TypeChar == 's' || TypeChar == 'S');

      for (size_t J = 0; J < std::size(NaNPayloads); ++J) {
        uint64_t Payload = (Signaling && !NaNPayloads[J]) ? SNaNDefaultPayload
                                                          : NaNPayloads[J];
        std::string &PayloadDec = NaNPayloadDecStrings[J];
        std::string &PayloadHex = NaNPayloadHexStrings[J];

        for (char SignChar : Signs) {
          bool Negative = (SignChar == '-');

          std::string TestStrings[5];
          size_t NumTestStrings = 0;

          std::string Prefix;
          if (SignChar)
            Prefix += SignChar;
          if (TypeChar)
            Prefix += TypeChar;
          Prefix += NaNStr;

          // Test without any paylod.
          if (!Payload)
            TestStrings[NumTestStrings++] = Prefix;

          // Test with the payload as a suffix.
          TestStrings[NumTestStrings++] = Prefix + PayloadDec;
          TestStrings[NumTestStrings++] = Prefix + PayloadHex;

          // Test with the payload inside parentheses.
          TestStrings[NumTestStrings++] = Prefix + '(' + PayloadDec + ')';
          TestStrings[NumTestStrings++] = Prefix + '(' + PayloadHex + ')';

          for (size_t K = 0; K < NumTestStrings; ++K) {
            StringRef TestStr = TestStrings[K];

            APFloat F(Sem);
            bool HasError = !F.convertFromString(
                TestStr, llvm::APFloat::rmNearestTiesToEven);
            EXPECT_FALSE(HasError);
            EXPECT_TRUE(F.isNaN());
            EXPECT_EQ(Signaling, F.isSignaling());
            EXPECT_EQ(Negative, F.isNegative());
            uint64_t PayloadResult =
                F.bitcastToAPInt().getZExtValue() & PayloadMask;
            EXPECT_EQ(Payload, PayloadResult);
          }
        }
      }
    }

  const StringRef InfStrings[] = {"inf",  "INFINITY",  "+Inf",
                                  "-inf", "-INFINITY", "-Inf"};
  for (StringRef InfStr : InfStrings) {
    bool Negative = InfStr.front() == '-';

    APFloat F(Sem);
    bool HasError =
        !F.convertFromString(InfStr, llvm::APFloat::rmNearestTiesToEven);
    EXPECT_FALSE(HasError);
    EXPECT_TRUE(F.isInfinity());
    EXPECT_EQ(Negative, F.isNegative());
    uint64_t PayloadResult = F.bitcastToAPInt().getZExtValue() & PayloadMask;
    EXPECT_EQ(UINT64_C(0), PayloadResult);
  }
}

TEST(APFloatTest, fromToStringSpecials) {
  auto expects = [] (const char *first, const char *second) {
    std::string roundtrip = convertToString(convertToDoubleFromString(second), 0, 3);
    EXPECT_STREQ(first, roundtrip.c_str());
  };
  expects("+Inf", "+Inf");
  expects("+Inf", "INFINITY");
  expects("+Inf", "inf");
  expects("-Inf", "-Inf");
  expects("-Inf", "-INFINITY");
  expects("-Inf", "-inf");
  expects("NaN", "NaN");
  expects("NaN", "nan");
  expects("NaN", "-NaN");
  expects("NaN", "-nan");
}

TEST(APFloatTest, fromHexadecimalString) {
  EXPECT_EQ( 1.0, APFloat(APFloat::IEEEdouble(),  "0x1p0").convertToDouble());
  EXPECT_EQ(+1.0, APFloat(APFloat::IEEEdouble(), "+0x1p0").convertToDouble());
  EXPECT_EQ(-1.0, APFloat(APFloat::IEEEdouble(), "-0x1p0").convertToDouble());

  EXPECT_EQ( 1.0, APFloat(APFloat::IEEEdouble(),  "0x1p+0").convertToDouble());
  EXPECT_EQ(+1.0, APFloat(APFloat::IEEEdouble(), "+0x1p+0").convertToDouble());
  EXPECT_EQ(-1.0, APFloat(APFloat::IEEEdouble(), "-0x1p+0").convertToDouble());

  EXPECT_EQ( 1.0, APFloat(APFloat::IEEEdouble(),  "0x1p-0").convertToDouble());
  EXPECT_EQ(+1.0, APFloat(APFloat::IEEEdouble(), "+0x1p-0").convertToDouble());
  EXPECT_EQ(-1.0, APFloat(APFloat::IEEEdouble(), "-0x1p-0").convertToDouble());


  EXPECT_EQ( 2.0, APFloat(APFloat::IEEEdouble(),  "0x1p1").convertToDouble());
  EXPECT_EQ(+2.0, APFloat(APFloat::IEEEdouble(), "+0x1p1").convertToDouble());
  EXPECT_EQ(-2.0, APFloat(APFloat::IEEEdouble(), "-0x1p1").convertToDouble());

  EXPECT_EQ( 2.0, APFloat(APFloat::IEEEdouble(),  "0x1p+1").convertToDouble());
  EXPECT_EQ(+2.0, APFloat(APFloat::IEEEdouble(), "+0x1p+1").convertToDouble());
  EXPECT_EQ(-2.0, APFloat(APFloat::IEEEdouble(), "-0x1p+1").convertToDouble());

  EXPECT_EQ( 0.5, APFloat(APFloat::IEEEdouble(),  "0x1p-1").convertToDouble());
  EXPECT_EQ(+0.5, APFloat(APFloat::IEEEdouble(), "+0x1p-1").convertToDouble());
  EXPECT_EQ(-0.5, APFloat(APFloat::IEEEdouble(), "-0x1p-1").convertToDouble());


  EXPECT_EQ( 3.0, APFloat(APFloat::IEEEdouble(),  "0x1.8p1").convertToDouble());
  EXPECT_EQ(+3.0, APFloat(APFloat::IEEEdouble(), "+0x1.8p1").convertToDouble());
  EXPECT_EQ(-3.0, APFloat(APFloat::IEEEdouble(), "-0x1.8p1").convertToDouble());

  EXPECT_EQ( 3.0, APFloat(APFloat::IEEEdouble(),  "0x1.8p+1").convertToDouble());
  EXPECT_EQ(+3.0, APFloat(APFloat::IEEEdouble(), "+0x1.8p+1").convertToDouble());
  EXPECT_EQ(-3.0, APFloat(APFloat::IEEEdouble(), "-0x1.8p+1").convertToDouble());

  EXPECT_EQ( 0.75, APFloat(APFloat::IEEEdouble(),  "0x1.8p-1").convertToDouble());
  EXPECT_EQ(+0.75, APFloat(APFloat::IEEEdouble(), "+0x1.8p-1").convertToDouble());
  EXPECT_EQ(-0.75, APFloat(APFloat::IEEEdouble(), "-0x1.8p-1").convertToDouble());


  EXPECT_EQ( 8192.0, APFloat(APFloat::IEEEdouble(),  "0x1000.000p1").convertToDouble());
  EXPECT_EQ(+8192.0, APFloat(APFloat::IEEEdouble(), "+0x1000.000p1").convertToDouble());
  EXPECT_EQ(-8192.0, APFloat(APFloat::IEEEdouble(), "-0x1000.000p1").convertToDouble());

  EXPECT_EQ( 8192.0, APFloat(APFloat::IEEEdouble(),  "0x1000.000p+1").convertToDouble());
  EXPECT_EQ(+8192.0, APFloat(APFloat::IEEEdouble(), "+0x1000.000p+1").convertToDouble());
  EXPECT_EQ(-8192.0, APFloat(APFloat::IEEEdouble(), "-0x1000.000p+1").convertToDouble());

  EXPECT_EQ( 2048.0, APFloat(APFloat::IEEEdouble(),  "0x1000.000p-1").convertToDouble());
  EXPECT_EQ(+2048.0, APFloat(APFloat::IEEEdouble(), "+0x1000.000p-1").convertToDouble());
  EXPECT_EQ(-2048.0, APFloat(APFloat::IEEEdouble(), "-0x1000.000p-1").convertToDouble());


  EXPECT_EQ( 8192.0, APFloat(APFloat::IEEEdouble(),  "0x1000p1").convertToDouble());
  EXPECT_EQ(+8192.0, APFloat(APFloat::IEEEdouble(), "+0x1000p1").convertToDouble());
  EXPECT_EQ(-8192.0, APFloat(APFloat::IEEEdouble(), "-0x1000p1").convertToDouble());

  EXPECT_EQ( 8192.0, APFloat(APFloat::IEEEdouble(),  "0x1000p+1").convertToDouble());
  EXPECT_EQ(+8192.0, APFloat(APFloat::IEEEdouble(), "+0x1000p+1").convertToDouble());
  EXPECT_EQ(-8192.0, APFloat(APFloat::IEEEdouble(), "-0x1000p+1").convertToDouble());

  EXPECT_EQ( 2048.0, APFloat(APFloat::IEEEdouble(),  "0x1000p-1").convertToDouble());
  EXPECT_EQ(+2048.0, APFloat(APFloat::IEEEdouble(), "+0x1000p-1").convertToDouble());
  EXPECT_EQ(-2048.0, APFloat(APFloat::IEEEdouble(), "-0x1000p-1").convertToDouble());


  EXPECT_EQ( 16384.0, APFloat(APFloat::IEEEdouble(),  "0x10p10").convertToDouble());
  EXPECT_EQ(+16384.0, APFloat(APFloat::IEEEdouble(), "+0x10p10").convertToDouble());
  EXPECT_EQ(-16384.0, APFloat(APFloat::IEEEdouble(), "-0x10p10").convertToDouble());

  EXPECT_EQ( 16384.0, APFloat(APFloat::IEEEdouble(),  "0x10p+10").convertToDouble());
  EXPECT_EQ(+16384.0, APFloat(APFloat::IEEEdouble(), "+0x10p+10").convertToDouble());
  EXPECT_EQ(-16384.0, APFloat(APFloat::IEEEdouble(), "-0x10p+10").convertToDouble());

  EXPECT_EQ( 0.015625, APFloat(APFloat::IEEEdouble(),  "0x10p-10").convertToDouble());
  EXPECT_EQ(+0.015625, APFloat(APFloat::IEEEdouble(), "+0x10p-10").convertToDouble());
  EXPECT_EQ(-0.015625, APFloat(APFloat::IEEEdouble(), "-0x10p-10").convertToDouble());

  EXPECT_EQ(1.0625, APFloat(APFloat::IEEEdouble(), "0x1.1p0").convertToDouble());
  EXPECT_EQ(1.0, APFloat(APFloat::IEEEdouble(), "0x1p0").convertToDouble());

  EXPECT_EQ(convertToDoubleFromString("0x1p-150"),
            convertToDoubleFromString("+0x800000000000000001.p-221"));
  EXPECT_EQ(2251799813685248.5,
            convertToDoubleFromString("0x80000000000004000000.010p-28"));
}

TEST(APFloatTest, toString) {
  ASSERT_EQ("10", convertToString(10.0, 6, 3));
  ASSERT_EQ("1.0E+1", convertToString(10.0, 6, 0));
  ASSERT_EQ("10100", convertToString(1.01E+4, 5, 2));
  ASSERT_EQ("1.01E+4", convertToString(1.01E+4, 4, 2));
  ASSERT_EQ("1.01E+4", convertToString(1.01E+4, 5, 1));
  ASSERT_EQ("0.0101", convertToString(1.01E-2, 5, 2));
  ASSERT_EQ("0.0101", convertToString(1.01E-2, 4, 2));
  ASSERT_EQ("1.01E-2", convertToString(1.01E-2, 5, 1));
  ASSERT_EQ("0.78539816339744828", convertToString(0.78539816339744830961, 0, 3));
  ASSERT_EQ("4.9406564584124654E-324", convertToString(4.9406564584124654e-324, 0, 3));
  ASSERT_EQ("873.18340000000001", convertToString(873.1834, 0, 1));
  ASSERT_EQ("8.7318340000000001E+2", convertToString(873.1834, 0, 0));
  ASSERT_EQ("1.7976931348623157E+308", convertToString(1.7976931348623157E+308, 0, 0));
  ASSERT_EQ("10", convertToString(10.0, 6, 3, false));
  ASSERT_EQ("1.000000e+01", convertToString(10.0, 6, 0, false));
  ASSERT_EQ("10100", convertToString(1.01E+4, 5, 2, false));
  ASSERT_EQ("1.0100e+04", convertToString(1.01E+4, 4, 2, false));
  ASSERT_EQ("1.01000e+04", convertToString(1.01E+4, 5, 1, false));
  ASSERT_EQ("0.0101", convertToString(1.01E-2, 5, 2, false));
  ASSERT_EQ("0.0101", convertToString(1.01E-2, 4, 2, false));
  ASSERT_EQ("1.01000e-02", convertToString(1.01E-2, 5, 1, false));
  ASSERT_EQ("0.78539816339744828",
            convertToString(0.78539816339744830961, 0, 3, false));
  ASSERT_EQ("4.94065645841246540e-324",
            convertToString(4.9406564584124654e-324, 0, 3, false));
  ASSERT_EQ("873.18340000000001", convertToString(873.1834, 0, 1, false));
  ASSERT_EQ("8.73183400000000010e+02", convertToString(873.1834, 0, 0, false));
  ASSERT_EQ("1.79769313486231570e+308",
            convertToString(1.7976931348623157E+308, 0, 0, false));

  {
    SmallString<64> Str;
    APFloat UnnormalZero(APFloat::x87DoubleExtended(), APInt(80, {0, 1}));
    UnnormalZero.toString(Str);
    ASSERT_EQ("NaN", Str);
  }
}

TEST(APFloatTest, toInteger) {
  bool isExact = false;
  APSInt result(5, /*isUnsigned=*/true);

  EXPECT_EQ(APFloat::opOK,
            APFloat(APFloat::IEEEdouble(), "10")
            .convertToInteger(result, APFloat::rmTowardZero, &isExact));
  EXPECT_TRUE(isExact);
  EXPECT_EQ(APSInt(APInt(5, 10), true), result);

  EXPECT_EQ(APFloat::opInvalidOp,
            APFloat(APFloat::IEEEdouble(), "-10")
            .convertToInteger(result, APFloat::rmTowardZero, &isExact));
  EXPECT_FALSE(isExact);
  EXPECT_EQ(APSInt::getMinValue(5, true), result);

  EXPECT_EQ(APFloat::opInvalidOp,
            APFloat(APFloat::IEEEdouble(), "32")
            .convertToInteger(result, APFloat::rmTowardZero, &isExact));
  EXPECT_FALSE(isExact);
  EXPECT_EQ(APSInt::getMaxValue(5, true), result);

  EXPECT_EQ(APFloat::opInexact,
            APFloat(APFloat::IEEEdouble(), "7.9")
            .convertToInteger(result, APFloat::rmTowardZero, &isExact));
  EXPECT_FALSE(isExact);
  EXPECT_EQ(APSInt(APInt(5, 7), true), result);

  result.setIsUnsigned(false);
  EXPECT_EQ(APFloat::opOK,
            APFloat(APFloat::IEEEdouble(), "-10")
            .convertToInteger(result, APFloat::rmTowardZero, &isExact));
  EXPECT_TRUE(isExact);
  EXPECT_EQ(APSInt(APInt(5, -10, true), false), result);

  EXPECT_EQ(APFloat::opInvalidOp,
            APFloat(APFloat::IEEEdouble(), "-17")
            .convertToInteger(result, APFloat::rmTowardZero, &isExact));
  EXPECT_FALSE(isExact);
  EXPECT_EQ(APSInt::getMinValue(5, false), result);

  EXPECT_EQ(APFloat::opInvalidOp,
            APFloat(APFloat::IEEEdouble(), "16")
            .convertToInteger(result, APFloat::rmTowardZero, &isExact));
  EXPECT_FALSE(isExact);
  EXPECT_EQ(APSInt::getMaxValue(5, false), result);
}

class APFloatConvertFromAPIntParamTest
    : public ::testing::TestWithParam<const fltSemantics *> {
protected:
  // Helper to run a conversion and compare the integer result directly.
  static void testConversionAndCompareInt(const APInt &InputValue,
                                          const bool IsSigned,
                                          APFloat::roundingMode RM,
                                          const APInt &ExpectedIntValue) {
    const fltSemantics &Sem = *GetParam();
    APFloat F(Sem);
    F.convertFromAPInt(InputValue, /*IsSigned=*/IsSigned, RM);

    APSInt ResultInt(InputValue.getBitWidth(), /*isUnsigned=*/!IsSigned);
    bool IsExact;
    F.convertToInteger(ResultInt, APFloat::rmTowardZero, &IsExact);

    EXPECT_TRUE(IsExact);
    EXPECT_TRUE(ResultInt.eq(ExpectedIntValue))
        << "InputValue: " << InputValue << "\n"
        << ResultInt << " vs " << ExpectedIntValue << "\n";
  }
};

TEST_P(APFloatConvertFromAPIntParamTest, HalfwayRounding) {
  const fltSemantics &Sem = *GetParam();
  const unsigned Precision = APFloat::semanticsPrecision(Sem);

  if (Precision == 0)
    GTEST_SKIP() << "Skipping test for semantics with no significand.";

  for (bool IsSigned : {false, true}) {
    const unsigned BitWidth = Precision + 1 + (IsSigned ? 1 : 0);

    const APInt RoundedDownVal = APInt::getOneBitSet(BitWidth, Precision);
    const APInt HalfwayVal = RoundedDownVal + 1;
    const APInt RoundedUpVal = RoundedDownVal + 2;

    testConversionAndCompareInt(HalfwayVal, IsSigned,
                                APFloat::rmNearestTiesToEven, RoundedDownVal);
    testConversionAndCompareInt(HalfwayVal, IsSigned,
                                APFloat::rmNearestTiesToAway, RoundedUpVal);
    testConversionAndCompareInt(HalfwayVal, IsSigned, APFloat::rmTowardPositive,
                                RoundedUpVal);
    testConversionAndCompareInt(HalfwayVal, IsSigned, APFloat::rmTowardNegative,
                                RoundedDownVal);
    testConversionAndCompareInt(HalfwayVal, IsSigned, APFloat::rmTowardZero,
                                RoundedDownVal);
  }
}

TEST_P(APFloatConvertFromAPIntParamTest, MaxMagnitude) {
  const fltSemantics &Sem = *GetParam();
  const unsigned Precision = APFloat::semanticsPrecision(Sem);

  if (Precision == 0)
    GTEST_SKIP() << "Skipping test for semantics with no significand.";

  const APFloat Largest = APFloat::getLargest(Sem, /*Negative=*/false);
  const int Exp = ilogb(Largest);
  for (bool IsSigned : {false, true}) {
    const unsigned BitWidth = Exp + 1 + (IsSigned ? 1 : 0);

    bool IsExact;
    APSInt LargestAsInt{BitWidth, /*IsUnsigned=*/!IsSigned};
    const APFloat::opStatus ToIntStatus =
        Largest.convertToInteger(LargestAsInt, APFloat::rmTowardZero, &IsExact);
    EXPECT_EQ(ToIntStatus, APFloat::opOK);

    for (const APFloat::roundingMode RM :
         {APFloat::rmNearestTiesToAway, APFloat::rmTowardNegative,
          APFloat::rmTowardPositive, APFloat::rmTowardZero,
          APFloat::rmNearestTiesToEven}) {
      testConversionAndCompareInt(LargestAsInt, IsSigned, RM, LargestAsInt);
    }
  }
}

INSTANTIATE_TEST_SUITE_P(IEEESemantics, APFloatConvertFromAPIntParamTest,
                         ::testing::Values(&APFloat::IEEEhalf(),
                                           &APFloat::BFloat(),
                                           &APFloat::IEEEsingle(),
                                           &APFloat::IEEEdouble(),
                                           &APFloat::IEEEquad()));

static APInt nanbitsFromAPInt(const fltSemantics &Sem, bool SNaN, bool Negative,
                              uint64_t payload) {
  APInt appayload(64, payload);
  if (SNaN)
    return APFloat::getSNaN(Sem, Negative, &appayload).bitcastToAPInt();
  else
    return APFloat::getQNaN(Sem, Negative, &appayload).bitcastToAPInt();
}

TEST(APFloatTest, makeNaN) {
  const struct {
    uint64_t expected;
    const fltSemantics &semantics;
    bool SNaN;
    bool Negative;
    uint64_t payload;
  } tests[] = {
      // clang-format off
    /*             expected              semantics   SNaN    Neg                payload */
    {         0x7fc00000ULL, APFloat::IEEEsingle(), false, false,         0x00000000ULL },
    {         0xffc00000ULL, APFloat::IEEEsingle(), false,  true,         0x00000000ULL },
    {         0x7fc0ae72ULL, APFloat::IEEEsingle(), false, false,         0x0000ae72ULL },
    {         0x7fffae72ULL, APFloat::IEEEsingle(), false, false,         0xffffae72ULL },
    {         0x7fdaae72ULL, APFloat::IEEEsingle(), false, false,         0x00daae72ULL },
    {         0x7fa00000ULL, APFloat::IEEEsingle(),  true, false,         0x00000000ULL },
    {         0xffa00000ULL, APFloat::IEEEsingle(),  true,  true,         0x00000000ULL },
    {         0x7f80ae72ULL, APFloat::IEEEsingle(),  true, false,         0x0000ae72ULL },
    {         0x7fbfae72ULL, APFloat::IEEEsingle(),  true, false,         0xffffae72ULL },
    {         0x7f9aae72ULL, APFloat::IEEEsingle(),  true, false,         0x001aae72ULL },
    { 0x7ff8000000000000ULL, APFloat::IEEEdouble(), false, false, 0x0000000000000000ULL },
    { 0xfff8000000000000ULL, APFloat::IEEEdouble(), false,  true, 0x0000000000000000ULL },
    { 0x7ff800000000ae72ULL, APFloat::IEEEdouble(), false, false, 0x000000000000ae72ULL },
    { 0x7fffffffffffae72ULL, APFloat::IEEEdouble(), false, false, 0xffffffffffffae72ULL },
    { 0x7ffdaaaaaaaaae72ULL, APFloat::IEEEdouble(), false, false, 0x000daaaaaaaaae72ULL },
    { 0x7ff4000000000000ULL, APFloat::IEEEdouble(),  true, false, 0x0000000000000000ULL },
    { 0xfff4000000000000ULL, APFloat::IEEEdouble(),  true,  true, 0x0000000000000000ULL },
    { 0x7ff000000000ae72ULL, APFloat::IEEEdouble(),  true, false, 0x000000000000ae72ULL },
    { 0x7ff7ffffffffae72ULL, APFloat::IEEEdouble(),  true, false, 0xffffffffffffae72ULL },
    { 0x7ff1aaaaaaaaae72ULL, APFloat::IEEEdouble(),  true, false, 0x0001aaaaaaaaae72ULL },
    {               0x80ULL, APFloat::Float8E5M2FNUZ(), false, false,           0xaaULL },
    {               0x80ULL, APFloat::Float8E5M2FNUZ(), false, true,            0xaaULL },
    {               0x80ULL, APFloat::Float8E5M2FNUZ(), true, false,            0xaaULL },
    {               0x80ULL, APFloat::Float8E5M2FNUZ(), true, true,             0xaaULL },
    {               0x80ULL, APFloat::Float8E4M3FNUZ(), false, false,           0xaaULL },
    {               0x80ULL, APFloat::Float8E4M3FNUZ(), false, true,            0xaaULL },
    {               0x80ULL, APFloat::Float8E4M3FNUZ(), true, false,            0xaaULL },
    {               0x80ULL, APFloat::Float8E4M3FNUZ(), true, true,             0xaaULL },
    {               0x80ULL, APFloat::Float8E4M3B11FNUZ(), false, false,        0xaaULL },
    {               0x80ULL, APFloat::Float8E4M3B11FNUZ(), false, true,         0xaaULL },
    {               0x80ULL, APFloat::Float8E4M3B11FNUZ(), true, false,         0xaaULL },
    {               0x80ULL, APFloat::Float8E4M3B11FNUZ(), true, true,          0xaaULL },
    {            0x3fe00ULL, APFloat::FloatTF32(), false, false,          0x00000000ULL },
    {            0x7fe00ULL, APFloat::FloatTF32(), false,  true,          0x00000000ULL },
    {            0x3feaaULL, APFloat::FloatTF32(), false, false,                0xaaULL },
    {            0x3ffaaULL, APFloat::FloatTF32(), false, false,               0xdaaULL },
    {            0x3ffaaULL, APFloat::FloatTF32(), false, false,              0xfdaaULL },
    {            0x3fd00ULL, APFloat::FloatTF32(),  true, false,          0x00000000ULL },
    {            0x7fd00ULL, APFloat::FloatTF32(),  true,  true,          0x00000000ULL },
    {            0x3fcaaULL, APFloat::FloatTF32(),  true, false,                0xaaULL },
    {            0x3fdaaULL, APFloat::FloatTF32(),  true, false,               0xfaaULL },
    {            0x3fdaaULL, APFloat::FloatTF32(),  true, false,               0x1aaULL },
      // clang-format on
  };

  for (const auto &t : tests) {
    ASSERT_EQ(t.expected, nanbitsFromAPInt(t.semantics, t.SNaN, t.Negative, t.payload));
  }
}

#ifdef GTEST_HAS_DEATH_TEST
#ifndef NDEBUG
TEST(APFloatTest, SemanticsDeath) {
  EXPECT_DEATH(APFloat(APFloat::IEEEquad(), 0).convertToDouble(),
               "Float semantics is not representable by IEEEdouble");
  EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), 0).convertToFloat(),
               "Float semantics is not representable by IEEEsingle");
}
#endif
#endif

TEST(APFloatTest, StringDecimalError) {
  EXPECT_EQ("Invalid string length", convertToErrorFromString(""));
  EXPECT_EQ("String has no digits", convertToErrorFromString("+"));
  EXPECT_EQ("String has no digits", convertToErrorFromString("-"));

  EXPECT_EQ("Invalid character in significand", convertToErrorFromString(StringRef("\0", 1)));
  EXPECT_EQ("Invalid character in significand", convertToErrorFromString(StringRef("1\0", 2)));
  EXPECT_EQ("Invalid character in significand", convertToErrorFromString(StringRef("1" "\0" "2", 3)));
  EXPECT_EQ("Invalid character in significand", convertToErrorFromString(StringRef("1" "\0" "2e1", 5)));
  EXPECT_EQ("Invalid character in exponent", convertToErrorFromString(StringRef("1e\0", 3)));
  EXPECT_EQ("Invalid character in exponent", convertToErrorFromString(StringRef("1e1\0", 4)));
  EXPECT_EQ("Invalid character in exponent", convertToErrorFromString(StringRef("1e1" "\0" "2", 5)));

  EXPECT_EQ("Invalid character in significand", convertToErrorFromString("1.0f"));

  EXPECT_EQ("String contains multiple dots", convertToErrorFromString(".."));
  EXPECT_EQ("String contains multiple dots", convertToErrorFromString("..0"));
  EXPECT_EQ("String contains multiple dots", convertToErrorFromString("1.0.0"));
}

TEST(APFloatTest, StringDecimalSignificandError) {
  EXPECT_EQ("Significand has no digits", convertToErrorFromString( "."));
  EXPECT_EQ("Significand has no digits", convertToErrorFromString("+."));
  EXPECT_EQ("Significand has no digits", convertToErrorFromString("-."));


  EXPECT_EQ("Significand has no digits", convertToErrorFromString( "e"));
  EXPECT_EQ("Significand has no digits", convertToErrorFromString("+e"));
  EXPECT_EQ("Significand has no digits", convertToErrorFromString("-e"));

  EXPECT_EQ("Significand has no digits", convertToErrorFromString( "e1"));
  EXPECT_EQ("Significand has no digits", convertToErrorFromString("+e1"));
  EXPECT_EQ("Significand has no digits", convertToErrorFromString("-e1"));

  EXPECT_EQ("Significand has no digits", convertToErrorFromString( ".e1"));
  EXPECT_EQ("Significand has no digits", convertToErrorFromString("+.e1"));
  EXPECT_EQ("Significand has no digits", convertToErrorFromString("-.e1"));


  EXPECT_EQ("Significand has no digits", convertToErrorFromString( ".e"));
  EXPECT_EQ("Significand has no digits", convertToErrorFromString("+.e"));
  EXPECT_EQ("Significand has no digits", convertToErrorFromString("-.e"));
}

TEST(APFloatTest, StringHexadecimalError) {
  EXPECT_EQ("Invalid string", convertToErrorFromString( "0x"));
  EXPECT_EQ("Invalid string", convertToErrorFromString("+0x"));
  EXPECT_EQ("Invalid string", convertToErrorFromString("-0x"));

  EXPECT_EQ("Hex strings require an exponent", convertToErrorFromString( "0x0"));
  EXPECT_EQ("Hex strings require an exponent", convertToErrorFromString("+0x0"));
  EXPECT_EQ("Hex strings require an exponent", convertToErrorFromString("-0x0"));

  EXPECT_EQ("Hex strings require an exponent", convertToErrorFromString( "0x0."));
  EXPECT_EQ("Hex strings require an exponent", convertToErrorFromString("+0x0."));
  EXPECT_EQ("Hex strings require an exponent", convertToErrorFromString("-0x0."));

  EXPECT_EQ("Hex strings require an exponent", convertToErrorFromString( "0x.0"));
  EXPECT_EQ("Hex strings require an exponent", convertToErrorFromString("+0x.0"));
  EXPECT_EQ("Hex strings require an exponent", convertToErrorFromString("-0x.0"));

  EXPECT_EQ("Hex strings require an exponent", convertToErrorFromString( "0x0.0"));
  EXPECT_EQ("Hex strings require an exponent", convertToErrorFromString("+0x0.0"));
  EXPECT_EQ("Hex strings require an exponent", convertToErrorFromString("-0x0.0"));

  EXPECT_EQ("Invalid character in significand", convertToErrorFromString(StringRef("0x\0", 3)));
  EXPECT_EQ("Invalid character in significand", convertToErrorFromString(StringRef("0x1\0", 4)));
  EXPECT_EQ("Invalid character in significand", convertToErrorFromString(StringRef("0x1" "\0" "2", 5)));
  EXPECT_EQ("Invalid character in significand", convertToErrorFromString(StringRef("0x1" "\0" "2p1", 7)));
  EXPECT_EQ("Invalid character in exponent", convertToErrorFromString(StringRef("0x1p\0", 5)));
  EXPECT_EQ("Invalid character in exponent", convertToErrorFromString(StringRef("0x1p1\0", 6)));
  EXPECT_EQ("Invalid character in exponent", convertToErrorFromString(StringRef("0x1p1" "\0" "2", 7)));

  EXPECT_EQ("Invalid character in exponent", convertToErrorFromString("0x1p0f"));

  EXPECT_EQ("String contains multiple dots", convertToErrorFromString("0x..p1"));
  EXPECT_EQ("String contains multiple dots", convertToErrorFromString("0x..0p1"));
  EXPECT_EQ("String contains multiple dots", convertToErrorFromString("0x1.0.0p1"));
}

TEST(APFloatTest, StringHexadecimalSignificandError) {
  EXPECT_EQ("Significand has no digits", convertToErrorFromString( "0x."));
  EXPECT_EQ("Significand has no digits", convertToErrorFromString("+0x."));
  EXPECT_EQ("Significand has no digits", convertToErrorFromString("-0x."));

  EXPECT_EQ("Significand has no digits", convertToErrorFromString( "0xp"));
  EXPECT_EQ("Significand has no digits", convertToErrorFromString("+0xp"));
  EXPECT_EQ("Significand has no digits", convertToErrorFromString("-0xp"));

  EXPECT_EQ("Significand has no digits", convertToErrorFromString( "0xp+"));
  EXPECT_EQ("Significand has no digits", convertToErrorFromString("+0xp+"));
  EXPECT_EQ("Significand has no digits", convertToErrorFromString("-0xp+"));

  EXPECT_EQ("Significand has no digits", convertToErrorFromString( "0xp-"));
  EXPECT_EQ("Significand has no digits", convertToErrorFromString("+0xp-"));
  EXPECT_EQ("Significand has no digits", convertToErrorFromString("-0xp-"));


  EXPECT_EQ("Significand has no digits", convertToErrorFromString( "0x.p"));
  EXPECT_EQ("Significand has no digits", convertToErrorFromString("+0x.p"));
  EXPECT_EQ("Significand has no digits", convertToErrorFromString("-0x.p"));

  EXPECT_EQ("Significand has no digits", convertToErrorFromString( "0x.p+"));
  EXPECT_EQ("Significand has no digits", convertToErrorFromString("+0x.p+"));
  EXPECT_EQ("Significand has no digits", convertToErrorFromString("-0x.p+"));

  EXPECT_EQ("Significand has no digits", convertToErrorFromString( "0x.p-"));
  EXPECT_EQ("Significand has no digits", convertToErrorFromString("+0x.p-"));
  EXPECT_EQ("Significand has no digits", convertToErrorFromString("-0x.p-"));
}

TEST(APFloatTest, StringHexadecimalExponentError) {
  EXPECT_EQ("Exponent has no digits", convertToErrorFromString( "0x1p"));
  EXPECT_EQ("Exponent has no digits", convertToErrorFromString("+0x1p"));
  EXPECT_EQ("Exponent has no digits", convertToErrorFromString("-0x1p"));

  EXPECT_EQ("Exponent has no digits", convertToErrorFromString( "0x1p+"));
  EXPECT_EQ("Exponent has no digits", convertToErrorFromString("+0x1p+"));
  EXPECT_EQ("Exponent has no digits", convertToErrorFromString("-0x1p+"));

  EXPECT_EQ("Exponent has no digits", convertToErrorFromString( "0x1p-"));
  EXPECT_EQ("Exponent has no digits", convertToErrorFromString("+0x1p-"));
  EXPECT_EQ("Exponent has no digits", convertToErrorFromString("-0x1p-"));


  EXPECT_EQ("Exponent has no digits", convertToErrorFromString( "0x1.p"));
  EXPECT_EQ("Exponent has no digits", convertToErrorFromString("+0x1.p"));
  EXPECT_EQ("Exponent has no digits", convertToErrorFromString("-0x1.p"));

  EXPECT_EQ("Exponent has no digits", convertToErrorFromString( "0x1.p+"));
  EXPECT_EQ("Exponent has no digits", convertToErrorFromString("+0x1.p+"));
  EXPECT_EQ("Exponent has no digits", convertToErrorFromString("-0x1.p+"));

  EXPECT_EQ("Exponent has no digits", convertToErrorFromString( "0x1.p-"));
  EXPECT_EQ("Exponent has no digits", convertToErrorFromString("+0x1.p-"));
  EXPECT_EQ("Exponent has no digits", convertToErrorFromString("-0x1.p-"));


  EXPECT_EQ("Exponent has no digits", convertToErrorFromString( "0x.1p"));
  EXPECT_EQ("Exponent has no digits", convertToErrorFromString("+0x.1p"));
  EXPECT_EQ("Exponent has no digits", convertToErrorFromString("-0x.1p"));

  EXPECT_EQ("Exponent has no digits", convertToErrorFromString( "0x.1p+"));
  EXPECT_EQ("Exponent has no digits", convertToErrorFromString("+0x.1p+"));
  EXPECT_EQ("Exponent has no digits", convertToErrorFromString("-0x.1p+"));

  EXPECT_EQ("Exponent has no digits", convertToErrorFromString( "0x.1p-"));
  EXPECT_EQ("Exponent has no digits", convertToErrorFromString("+0x.1p-"));
  EXPECT_EQ("Exponent has no digits", convertToErrorFromString("-0x.1p-"));


  EXPECT_EQ("Exponent has no digits", convertToErrorFromString( "0x1.1p"));
  EXPECT_EQ("Exponent has no digits", convertToErrorFromString("+0x1.1p"));
  EXPECT_EQ("Exponent has no digits", convertToErrorFromString("-0x1.1p"));

  EXPECT_EQ("Exponent has no digits", convertToErrorFromString( "0x1.1p+"));
  EXPECT_EQ("Exponent has no digits", convertToErrorFromString("+0x1.1p+"));
  EXPECT_EQ("Exponent has no digits", convertToErrorFromString("-0x1.1p+"));

  EXPECT_EQ("Exponent has no digits", convertToErrorFromString( "0x1.1p-"));
  EXPECT_EQ("Exponent has no digits", convertToErrorFromString("+0x1.1p-"));
  EXPECT_EQ("Exponent has no digits", convertToErrorFromString("-0x1.1p-"));
}

TEST(APFloatTest, exactInverse) {
  APFloat inv(0.0f);

  // Trivial operation.
  EXPECT_TRUE(APFloat(2.0).getExactInverse(&inv));
  EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(0.5)));
  EXPECT_TRUE(APFloat(2.0f).getExactInverse(&inv));
  EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(0.5f)));
  EXPECT_TRUE(APFloat(APFloat::IEEEquad(), "2.0").getExactInverse(&inv));
  EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(APFloat::IEEEquad(), "0.5")));
  EXPECT_TRUE(APFloat(APFloat::PPCDoubleDouble(), "2.0").getExactInverse(&inv));
  EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(APFloat::PPCDoubleDouble(), "0.5")));
  EXPECT_TRUE(APFloat(APFloat::x87DoubleExtended(), "2.0").getExactInverse(&inv));
  EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(APFloat::x87DoubleExtended(), "0.5")));
  // 0x1p1022 has a normal inverse for IEEE 754 binary64: 0x1p-1022.
  EXPECT_TRUE(APFloat(0x1p1022).getExactInverse(&inv));
  EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(0x1p-1022)));
  // With regards to getExactInverse, IEEEdouble and PPCDoubleDouble should
  // behave the same.
  EXPECT_TRUE(
      APFloat(APFloat::PPCDoubleDouble(), "0x1p1022").getExactInverse(&inv));
  EXPECT_TRUE(
      inv.bitwiseIsEqual(APFloat(APFloat::PPCDoubleDouble(), "0x1p-1022")));

  // FLT_MIN
  EXPECT_TRUE(APFloat(1.17549435e-38f).getExactInverse(&inv));
  EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(8.5070592e+37f)));

  // Large float, inverse is a denormal.
  EXPECT_FALSE(APFloat(1.7014118e38f).getExactInverse(nullptr));
  // Zero
  EXPECT_FALSE(APFloat(0.0).getExactInverse(nullptr));
  // Denormalized float
  EXPECT_FALSE(APFloat(1.40129846e-45f).getExactInverse(nullptr));
  // Largest subnormal
  EXPECT_FALSE(APFloat(0x1p-127f).getExactInverse(nullptr));
}

TEST(APFloatTest, roundToIntegral) {
  APFloat T(-0.5), S(3.14), R(APFloat::getLargest(APFloat::IEEEdouble())), P(0.0);

  P = T;
  P.roundToIntegral(APFloat::rmTowardZero);
  EXPECT_EQ(-0.0, P.convertToDouble());
  P = T;
  P.roundToIntegral(APFloat::rmTowardNegative);
  EXPECT_EQ(-1.0, P.convertToDouble());
  P = T;
  P.roundToIntegral(APFloat::rmTowardPositive);
  EXPECT_EQ(-0.0, P.convertToDouble());
  P = T;
  P.roundToIntegral(APFloat::rmNearestTiesToEven);
  EXPECT_EQ(-0.0, P.convertToDouble());

  P = S;
  P.roundToIntegral(APFloat::rmTowardZero);
  EXPECT_EQ(3.0, P.convertToDouble());
  P = S;
  P.roundToIntegral(APFloat::rmTowardNegative);
  EXPECT_EQ(3.0, P.convertToDouble());
  P = S;
  P.roundToIntegral(APFloat::rmTowardPositive);
  EXPECT_EQ(4.0, P.convertToDouble());
  P = S;
  P.roundToIntegral(APFloat::rmNearestTiesToEven);
  EXPECT_EQ(3.0, P.convertToDouble());

  P = R;
  P.roundToIntegral(APFloat::rmTowardZero);
  EXPECT_EQ(R.convertToDouble(), P.convertToDouble());
  P = R;
  P.roundToIntegral(APFloat::rmTowardNegative);
  EXPECT_EQ(R.convertToDouble(), P.convertToDouble());
  P = R;
  P.roundToIntegral(APFloat::rmTowardPositive);
  EXPECT_EQ(R.convertToDouble(), P.convertToDouble());
  P = R;
  P.roundToIntegral(APFloat::rmNearestTiesToEven);
  EXPECT_EQ(R.convertToDouble(), P.convertToDouble());

  P = APFloat::getZero(APFloat::IEEEdouble());
  P.roundToIntegral(APFloat::rmTowardZero);
  EXPECT_EQ(0.0, P.convertToDouble());
  P = APFloat::getZero(APFloat::IEEEdouble(), true);
  P.roundToIntegral(APFloat::rmTowardZero);
  EXPECT_EQ(-0.0, P.convertToDouble());
  P = APFloat::getNaN(APFloat::IEEEdouble());
  P.roundToIntegral(APFloat::rmTowardZero);
  EXPECT_TRUE(std::isnan(P.convertToDouble()));
  P = APFloat::getInf(APFloat::IEEEdouble());
  P.roundToIntegral(APFloat::rmTowardZero);
  EXPECT_TRUE(std::isinf(P.convertToDouble()) && P.convertToDouble() > 0.0);
  P = APFloat::getInf(APFloat::IEEEdouble(), true);
  P.roundToIntegral(APFloat::rmTowardZero);
  EXPECT_TRUE(std::isinf(P.convertToDouble()) && P.convertToDouble() < 0.0);

  APFloat::opStatus St;

  P = APFloat::getNaN(APFloat::IEEEdouble());
  St = P.roundToIntegral(APFloat::rmTowardZero);
  EXPECT_TRUE(P.isNaN());
  EXPECT_FALSE(P.isNegative());
  EXPECT_EQ(APFloat::opOK, St);

  P = APFloat::getNaN(APFloat::IEEEdouble(), true);
  St = P.roundToIntegral(APFloat::rmTowardZero);
  EXPECT_TRUE(P.isNaN());
  EXPECT_TRUE(P.isNegative());
  EXPECT_EQ(APFloat::opOK, St);

  P = APFloat::getSNaN(APFloat::IEEEdouble());
  St = P.roundToIntegral(APFloat::rmTowardZero);
  EXPECT_TRUE(P.isNaN());
  EXPECT_FALSE(P.isSignaling());
  EXPECT_FALSE(P.isNegative());
  EXPECT_EQ(APFloat::opInvalidOp, St);

  P = APFloat::getSNaN(APFloat::IEEEdouble(), true);
  St = P.roundToIntegral(APFloat::rmTowardZero);
  EXPECT_TRUE(P.isNaN());
  EXPECT_FALSE(P.isSignaling());
  EXPECT_TRUE(P.isNegative());
  EXPECT_EQ(APFloat::opInvalidOp, St);

  P = APFloat::getInf(APFloat::IEEEdouble());
  St = P.roundToIntegral(APFloat::rmTowardZero);
  EXPECT_TRUE(P.isInfinity());
  EXPECT_FALSE(P.isNegative());
  EXPECT_EQ(APFloat::opOK, St);

  P = APFloat::getInf(APFloat::IEEEdouble(), true);
  St = P.roundToIntegral(APFloat::rmTowardZero);
  EXPECT_TRUE(P.isInfinity());
  EXPECT_TRUE(P.isNegative());
  EXPECT_EQ(APFloat::opOK, St);

  P = APFloat::getZero(APFloat::IEEEdouble(), false);
  St = P.roundToIntegral(APFloat::rmTowardZero);
  EXPECT_TRUE(P.isZero());
  EXPECT_FALSE(P.isNegative());
  EXPECT_EQ(APFloat::opOK, St);

  P = APFloat::getZero(APFloat::IEEEdouble(), false);
  St = P.roundToIntegral(APFloat::rmTowardNegative);
  EXPECT_TRUE(P.isZero());
  EXPECT_FALSE(P.isNegative());
  EXPECT_EQ(APFloat::opOK, St);

  P = APFloat::getZero(APFloat::IEEEdouble(), true);
  St = P.roundToIntegral(APFloat::rmTowardZero);
  EXPECT_TRUE(P.isZero());
  EXPECT_TRUE(P.isNegative());
  EXPECT_EQ(APFloat::opOK, St);

  P = APFloat::getZero(APFloat::IEEEdouble(), true);
  St = P.roundToIntegral(APFloat::rmTowardNegative);
  EXPECT_TRUE(P.isZero());
  EXPECT_TRUE(P.isNegative());
  EXPECT_EQ(APFloat::opOK, St);

  P = APFloat(1E-100);
  St = P.roundToIntegral(APFloat::rmTowardNegative);
  EXPECT_TRUE(P.isZero());
  EXPECT_FALSE(P.isNegative());
  EXPECT_EQ(APFloat::opInexact, St);

  P = APFloat(1E-100);
  St = P.roundToIntegral(APFloat::rmTowardPositive);
  EXPECT_EQ(1.0, P.convertToDouble());
  EXPECT_FALSE(P.isNegative());
  EXPECT_EQ(APFloat::opInexact, St);

  P = APFloat(-1E-100);
  St = P.roundToIntegral(APFloat::rmTowardNegative);
  EXPECT_TRUE(P.isNegative());
  EXPECT_EQ(-1.0, P.convertToDouble());
  EXPECT_EQ(APFloat::opInexact, St);

  P = APFloat(-1E-100);
  St = P.roundToIntegral(APFloat::rmTowardPositive);
  EXPECT_TRUE(P.isZero());
  EXPECT_TRUE(P.isNegative());
  EXPECT_EQ(APFloat::opInexact, St);

  P = APFloat(10.0);
  St = P.roundToIntegral(APFloat::rmTowardZero);
  EXPECT_EQ(10.0, P.convertToDouble());
  EXPECT_EQ(APFloat::opOK, St);

  P = APFloat(10.5);
  St = P.roundToIntegral(APFloat::rmTowardZero);
  EXPECT_EQ(10.0, P.convertToDouble());
  EXPECT_EQ(APFloat::opInexact, St);

  P = APFloat(10.5);
  St = P.roundToIntegral(APFloat::rmTowardPositive);
  EXPECT_EQ(11.0, P.convertToDouble());
  EXPECT_EQ(APFloat::opInexact, St);

  P = APFloat(10.5);
  St = P.roundToIntegral(APFloat::rmTowardNegative);
  EXPECT_EQ(10.0, P.convertToDouble());
  EXPECT_EQ(APFloat::opInexact, St);

  P = APFloat(10.5);
  St = P.roundToIntegral(APFloat::rmNearestTiesToAway);
  EXPECT_EQ(11.0, P.convertToDouble());
  EXPECT_EQ(APFloat::opInexact, St);

  P = APFloat(10.5);
  St = P.roundToIntegral(APFloat::rmNearestTiesToEven);
  EXPECT_EQ(10.0, P.convertToDouble());
  EXPECT_EQ(APFloat::opInexact, St);
}

TEST(APFloatTest, isInteger) {
  APFloat T(-0.0);
  EXPECT_TRUE(T.isInteger());
  T = APFloat(3.14159);
  EXPECT_FALSE(T.isInteger());
  T = APFloat::getNaN(APFloat::IEEEdouble());
  EXPECT_FALSE(T.isInteger());
  T = APFloat::getInf(APFloat::IEEEdouble());
  EXPECT_FALSE(T.isInteger());
  T = APFloat::getInf(APFloat::IEEEdouble(), true);
  EXPECT_FALSE(T.isInteger());
  T = APFloat::getLargest(APFloat::IEEEdouble());
  EXPECT_TRUE(T.isInteger());
}

TEST(DoubleAPFloatTest, isInteger) {
  APFloat F1(-0.0);
  APFloat F2(-0.0);
  llvm::detail::DoubleAPFloat T(APFloat::PPCDoubleDouble(), std::move(F1),
                                std::move(F2));
  EXPECT_TRUE(T.isInteger());
  APFloat F3(3.14159);
  APFloat F4(-0.0);
  llvm::detail::DoubleAPFloat T2(APFloat::PPCDoubleDouble(), std::move(F3),
                                std::move(F4));
  EXPECT_FALSE(T2.isInteger());
  APFloat F5(-0.0);
  APFloat F6(3.14159);
  llvm::detail::DoubleAPFloat T3(APFloat::PPCDoubleDouble(), std::move(F5),
                                std::move(F6));
  EXPECT_FALSE(T3.isInteger());
}

// Test to check if the full range of Float8E8M0FNU
// values are being represented correctly.
TEST(APFloatTest, Float8E8M0FNUValues) {
  // High end of the range
  auto test = APFloat(APFloat::Float8E8M0FNU(), "0x1.0p127");
  EXPECT_EQ(0x1.0p127, test.convertToDouble());

  test = APFloat(APFloat::Float8E8M0FNU(), "0x1.0p126");
  EXPECT_EQ(0x1.0p126, test.convertToDouble());

  test = APFloat(APFloat::Float8E8M0FNU(), "0x1.0p125");
  EXPECT_EQ(0x1.0p125, test.convertToDouble());

  // tests the fix in makeLargest()
  test = APFloat::getLargest(APFloat::Float8E8M0FNU());
  EXPECT_EQ(0x1.0p127, test.convertToDouble());

  // tests overflow to nan
  APFloat nan = APFloat(APFloat::Float8E8M0FNU(), "nan");
  test = APFloat(APFloat::Float8E8M0FNU(), "0x1.0p128");
  EXPECT_TRUE(test.bitwiseIsEqual(nan));

  // Mid of the range
  test = APFloat(APFloat::Float8E8M0FNU(), "0x1.0p0");
  EXPECT_EQ(1.0, test.convertToDouble());

  test = APFloat(APFloat::Float8E8M0FNU(), "0x1.0p1");
  EXPECT_EQ(2.0, test.convertToDouble());

  test = APFloat(APFloat::Float8E8M0FNU(), "0x1.0p2");
  EXPECT_EQ(4.0, test.convertToDouble());

  // Low end of the range
  test = APFloat(APFloat::Float8E8M0FNU(), "0x1.0p-125");
  EXPECT_EQ(0x1.0p-125, test.convertToDouble());

  test = APFloat(APFloat::Float8E8M0FNU(), "0x1.0p-126");
  EXPECT_EQ(0x1.0p-126, test.convertToDouble());

  test = APFloat(APFloat::Float8E8M0FNU(), "0x1.0p-127");
  EXPECT_EQ(0x1.0p-127, test.convertToDouble());

  // Smallest value
  test = APFloat::getSmallest(APFloat::Float8E8M0FNU());
  EXPECT_EQ(0x1.0p-127, test.convertToDouble());

  // Value below the smallest, but clamped to the smallest
  test = APFloat(APFloat::Float8E8M0FNU(), "0x1.0p-128");
  EXPECT_EQ(0x1.0p-127, test.convertToDouble());
}

// Test that a Float8E8M0FNU NaN, which has no payload bits, does not
// become an Inf when converted to a format that has infinities.
TEST(APFloatTest, Float8E8M0FNUNaNConvert) {
  APFloat nan = APFloat(APFloat::Float8E8M0FNU(), "nan");
  EXPECT_TRUE(nan.isNaN());
  EXPECT_EQ(APInt(8, 0xff), nan.bitcastToAPInt());

  const std::pair<const fltSemantics *, uint64_t> ToSemantics[] = {
      {&APFloat::IEEEhalf(), 0x7e00},
      {&APFloat::BFloat(), 0x7fc0},
      {&APFloat::IEEEsingle(), 0x7fc00000},
      {&APFloat::IEEEdouble(), 0x7ff8000000000000ULL},
  };

  for (const auto &[Sem, ExpectedBits] : ToSemantics) {
    APFloat test = nan;
    bool losesInfo = true;
    APFloat::opStatus status =
        test.convert(*Sem, APFloat::rmNearestTiesToEven, &losesInfo);
    EXPECT_EQ(status, APFloat::opOK);
    EXPECT_FALSE(losesInfo);
    EXPECT_TRUE(test.isNaN());
    EXPECT_FALSE(test.isInfinity());
    APInt bits = test.bitcastToAPInt();
    EXPECT_EQ(APInt(APFloat::getSizeInBits(*Sem), ExpectedBits), bits);
    // The stored bit pattern, not just the category, has to say NaN.
    EXPECT_TRUE(APFloat(*Sem, bits).isNaN());
  }
}

// Test that converting into a format that cannot represent the sign, or that
// has no encoding for zero, reports the loss. The value that comes out is
// still the one convert computed: the sign bit is carried into a format that
// cannot spell it, and zero is replaced by the smallest normalized value. The
// status is what tells a caller not to keep it.
TEST(APFloatTest, ConvertLosesUnrepresentableSignAndZero) {
  // Neither format has a sign; only Float8E8M0FNU also lacks a zero.
  const fltSemantics *NoSignSemantics[] = {&APFloat::Float8E8M0FNU(),
                                           &APFloat::Float8E5M3FNU()};

  for (const fltSemantics *Sem : NoSignSemantics) {
    // The magnitude converts exactly, so the sign is the whole of the loss.
    APFloat test(-1.0);
    bool losesInfo = false;
    APFloat::opStatus status =
        test.convert(*Sem, APFloat::rmNearestTiesToEven, &losesInfo);
    EXPECT_TRUE(losesInfo);
    EXPECT_EQ(status, APFloat::opInexact);
    EXPECT_TRUE(test.isNegative());
    EXPECT_EQ(-1.0, test.convertToDouble());
    APInt negBits = test.bitcastToAPInt();

    // The same magnitude without the sign has nothing to report.
    test = APFloat(1.0);
    losesInfo = true;
    status = test.convert(*Sem, APFloat::rmNearestTiesToEven, &losesInfo);
    EXPECT_FALSE(losesInfo);
    EXPECT_EQ(status, APFloat::opOK);
    EXPECT_FALSE(test.isNegative());
    EXPECT_EQ(1.0, test.convertToDouble());

    // No sign bit exists, so the bits must match the positive magnitude.
    EXPECT_EQ(test.bitcastToAPInt(), negBits);
  }

  // Float8E8M0FNU has no zero either, and substitutes 2^-127 for one. That
  // substitution is unsigned, so both zeros come out as the same value.
  for (double Zero : {0.0, -0.0}) {
    APFloat test(Zero);
    bool losesInfo = false;
    APFloat::opStatus status = test.convert(
        APFloat::Float8E8M0FNU(), APFloat::rmNearestTiesToEven, &losesInfo);
    EXPECT_TRUE(losesInfo);
    EXPECT_EQ(status, APFloat::opInexact);
    EXPECT_TRUE(test.isSmallestNormalized());
    EXPECT_EQ(0x1.0p-127, test.convertToDouble());
    EXPECT_EQ(APInt(8, 0), test.bitcastToAPInt());
  }

  // Float8E5M3FNU does have one, so a positive zero converts exactly, and a
  // negative one keeps its value and loses only the sign.
  {
    APFloat test(0.0);
    bool losesInfo = true;
    APFloat::opStatus status = test.convert(
        APFloat::Float8E5M3FNU(), APFloat::rmNearestTiesToEven, &losesInfo);
    EXPECT_FALSE(losesInfo);
    EXPECT_EQ(status, APFloat::opOK);
    EXPECT_TRUE(test.isZero());
    EXPECT_FALSE(test.isNegative());

    test = APFloat(-0.0);
    losesInfo = false;
    status = test.convert(APFloat::Float8E5M3FNU(),
                          APFloat::rmNearestTiesToEven, &losesInfo);
    EXPECT_TRUE(losesInfo);
    EXPECT_EQ(status, APFloat::opInexact);
    EXPECT_TRUE(test.isZero());
    EXPECT_TRUE(test.isNegative());
  }
}

TEST(APFloatTest, getLargest) {
  EXPECT_EQ(3.402823466e+38f, APFloat::getLargest(APFloat::IEEEsingle()).convertToFloat());
  EXPECT_EQ(1.7976931348623158e+308, APFloat::getLargest(APFloat::IEEEdouble()).convertToDouble());
  EXPECT_EQ(448, APFloat::getLargest(APFloat::Float8E4M3FN()).convertToDouble());
  EXPECT_EQ(240,
            APFloat::getLargest(APFloat::Float8E4M3FNUZ()).convertToDouble());
  EXPECT_EQ(57344,
            APFloat::getLargest(APFloat::Float8E5M2FNUZ()).convertToDouble());
  EXPECT_EQ(
      30, APFloat::getLargest(APFloat::Float8E4M3B11FNUZ()).convertToDouble());
  EXPECT_EQ(3.40116213421e+38f,
            APFloat::getLargest(APFloat::FloatTF32()).convertToFloat());
  EXPECT_EQ(1.701411834e+38f,
            APFloat::getLargest(APFloat::Float8E8M0FNU()).convertToDouble());
  EXPECT_EQ(0x1.cp016,
            APFloat::getLargest(APFloat::Float8E5M3FNU()).convertToDouble());
  EXPECT_EQ(28, APFloat::getLargest(APFloat::Float6E3M2FN()).convertToDouble());
  EXPECT_EQ(7.5,
            APFloat::getLargest(APFloat::Float6E2M3FN()).convertToDouble());
  EXPECT_EQ(6, APFloat::getLargest(APFloat::Float4E2M1FN()).convertToDouble());
}

TEST(APFloatTest, getSmallest) {
  APFloat test = APFloat::getSmallest(APFloat::IEEEsingle(), false);
  APFloat expected = APFloat(APFloat::IEEEsingle(), "0x0.000002p-126");
  EXPECT_FALSE(test.isNegative());
  EXPECT_TRUE(test.isFiniteNonZero());
  EXPECT_TRUE(test.isDenormal());
  EXPECT_TRUE(test.bitwiseIsEqual(expected));

  test = APFloat::getSmallest(APFloat::IEEEsingle(), true);
  expected = APFloat(APFloat::IEEEsingle(), "-0x0.000002p-126");
  EXPECT_TRUE(test.isNegative());
  EXPECT_TRUE(test.isFiniteNonZero());
  EXPECT_TRUE(test.isDenormal());
  EXPECT_TRUE(test.bitwiseIsEqual(expected));

  test = APFloat::getSmallest(APFloat::IEEEquad(), false);
  expected = APFloat(APFloat::IEEEquad(), "0x0.0000000000000000000000000001p-16382");
  EXPECT_FALSE(test.isNegative());
  EXPECT_TRUE(test.isFiniteNonZero());
  EXPECT_TRUE(test.isDenormal());
  EXPECT_TRUE(test.bitwiseIsEqual(expected));

  test = APFloat::getSmallest(APFloat::IEEEquad(), true);
  expected = APFloat(APFloat::IEEEquad(), "-0x0.0000000000000000000000000001p-16382");
  EXPECT_TRUE(test.isNegative());
  EXPECT_TRUE(test.isFiniteNonZero());
  EXPECT_TRUE(test.isDenormal());
  EXPECT_TRUE(test.bitwiseIsEqual(expected));

  test = APFloat::getSmallest(APFloat::Float8E5M2FNUZ(), false);
  expected = APFloat(APFloat::Float8E5M2FNUZ(), "0x0.4p-15");
  EXPECT_FALSE(test.isNegative());
  EXPECT_TRUE(test.isFiniteNonZero());
  EXPECT_TRUE(test.isDenormal());
  EXPECT_TRUE(test.bitwiseIsEqual(expected));

  test = APFloat::getSmallest(APFloat::Float8E4M3FNUZ(), false);
  expected = APFloat(APFloat::Float8E4M3FNUZ(), "0x0.2p-7");
  EXPECT_FALSE(test.isNegative());
  EXPECT_TRUE(test.isFiniteNonZero());
  EXPECT_TRUE(test.isDenormal());
  EXPECT_TRUE(test.bitwiseIsEqual(expected));

  test = APFloat::getSmallest(APFloat::Float8E4M3B11FNUZ(), false);
  expected = APFloat(APFloat::Float8E4M3B11FNUZ(), "0x0.2p-10");
  EXPECT_FALSE(test.isNegative());
  EXPECT_TRUE(test.isFiniteNonZero());
  EXPECT_TRUE(test.isDenormal());
  EXPECT_TRUE(test.bitwiseIsEqual(expected));

  test = APFloat::getSmallest(APFloat::FloatTF32(), true);
  expected = APFloat(APFloat::FloatTF32(), "-0x0.004p-126");
  EXPECT_TRUE(test.isNegative());
  EXPECT_TRUE(test.isFiniteNonZero());
  EXPECT_TRUE(test.isDenormal());
  EXPECT_TRUE(test.bitwiseIsEqual(expected));

  test = APFloat::getSmallest(APFloat::Float6E3M2FN(), false);
  expected = APFloat(APFloat::Float6E3M2FN(), "0x0.1p0");
  EXPECT_FALSE(test.isNegative());
  EXPECT_TRUE(test.isFiniteNonZero());
  EXPECT_TRUE(test.isDenormal());
  EXPECT_TRUE(test.bitwiseIsEqual(expected));

  test = APFloat::getSmallest(APFloat::Float6E2M3FN(), false);
  expected = APFloat(APFloat::Float6E2M3FN(), "0x0.2p0");
  EXPECT_FALSE(test.isNegative());
  EXPECT_TRUE(test.isFiniteNonZero());
  EXPECT_TRUE(test.isDenormal());
  EXPECT_TRUE(test.bitwiseIsEqual(expected));

  test = APFloat::getSmallest(APFloat::Float4E2M1FN(), false);
  expected = APFloat(APFloat::Float4E2M1FN(), "0x0.8p0");
  EXPECT_FALSE(test.isNegative());
  EXPECT_TRUE(test.isFiniteNonZero());
  EXPECT_TRUE(test.isDenormal());
  EXPECT_TRUE(test.bitwiseIsEqual(expected));

  test = APFloat::getSmallest(APFloat::Float8E8M0FNU());
  expected = APFloat(APFloat::Float8E8M0FNU(), "0x1.0p-127");
  EXPECT_FALSE(test.isNegative());
  EXPECT_TRUE(test.isFiniteNonZero());
  EXPECT_FALSE(test.isDenormal());
  EXPECT_TRUE(test.bitwiseIsEqual(expected));

  test = APFloat::getSmallest(APFloat::Float8E5M3FNU(), false);
  expected = APFloat(APFloat::Float8E5M3FNU(), "0x1.0p-17");
  EXPECT_FALSE(test.isNegative());
  EXPECT_TRUE(test.isFiniteNonZero());
  EXPECT_TRUE(test.isDenormal());
  EXPECT_TRUE(test.bitwiseIsEqual(expected));
}

TEST(APFloatTest, getSmallestNormalized) {
  APFloat test = APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false);
  APFloat expected = APFloat(APFloat::IEEEsingle(), "0x1p-126");
  EXPECT_FALSE(test.isNegative());
  EXPECT_TRUE(test.isFiniteNonZero());
  EXPECT_FALSE(test.isDenormal());
  EXPECT_TRUE(test.bitwiseIsEqual(expected));
  EXPECT_TRUE(test.isSmallestNormalized());

  test = APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true);
  expected = APFloat(APFloat::IEEEsingle(), "-0x1p-126");
  EXPECT_TRUE(test.isNegative());
  EXPECT_TRUE(test.isFiniteNonZero());
  EXPECT_FALSE(test.isDenormal());
  EXPECT_TRUE(test.bitwiseIsEqual(expected));
  EXPECT_TRUE(test.isSmallestNormalized());

  test = APFloat::getSmallestNormalized(APFloat::IEEEdouble(), false);
  expected = APFloat(APFloat::IEEEdouble(), "0x1p-1022");
  EXPECT_FALSE(test.isNegative());
  EXPECT_TRUE(test.isFiniteNonZero());
  EXPECT_FALSE(test.isDenormal());
  EXPECT_TRUE(test.bitwiseIsEqual(expected));
  EXPECT_TRUE(test.isSmallestNormalized());

  test = APFloat::getSmallestNormalized(APFloat::IEEEdouble(), true);
  expected = APFloat(APFloat::IEEEdouble(), "-0x1p-1022");
  EXPECT_TRUE(test.isNegative());
  EXPECT_TRUE(test.isFiniteNonZero());
  EXPECT_FALSE(test.isDenormal());
  EXPECT_TRUE(test.bitwiseIsEqual(expected));
  EXPECT_TRUE(test.isSmallestNormalized());

  test = APFloat::getSmallestNormalized(APFloat::IEEEquad(), false);
  expected = APFloat(APFloat::IEEEquad(), "0x1p-16382");
  EXPECT_FALSE(test.isNegative());
  EXPECT_TRUE(test.isFiniteNonZero());
  EXPECT_FALSE(test.isDenormal());
  EXPECT_TRUE(test.bitwiseIsEqual(expected));
  EXPECT_TRUE(test.isSmallestNormalized());

  test = APFloat::getSmallestNormalized(APFloat::IEEEquad(), true);
  expected = APFloat(APFloat::IEEEquad(), "-0x1p-16382");
  EXPECT_TRUE(test.isNegative());
  EXPECT_TRUE(test.isFiniteNonZero());
  EXPECT_FALSE(test.isDenormal());
  EXPECT_TRUE(test.bitwiseIsEqual(expected));
  EXPECT_TRUE(test.isSmallestNormalized());

  test = APFloat::getSmallestNormalized(APFloat::Float8E5M2FNUZ(), false);
  expected = APFloat(APFloat::Float8E5M2FNUZ(), "0x1.0p-15");
  EXPECT_FALSE(test.isNegative());
  EXPECT_TRUE(test.isFiniteNonZero());
  EXPECT_FALSE(test.isDenormal());
  EXPECT_TRUE(test.bitwiseIsEqual(expected));
  EXPECT_TRUE(test.isSmallestNormalized());

  test = APFloat::getSmallestNormalized(APFloat::Float8E4M3FNUZ(), false);
  expected = APFloat(APFloat::Float8E4M3FNUZ(), "0x1.0p-7");
  EXPECT_FALSE(test.isNegative());
  EXPECT_TRUE(test.isFiniteNonZero());
  EXPECT_FALSE(test.isDenormal());
  EXPECT_TRUE(test.bitwiseIsEqual(expected));
  EXPECT_TRUE(test.isSmallestNormalized());

  test = APFloat::getSmallestNormalized(APFloat::Float8E4M3B11FNUZ(), false);
  expected = APFloat(APFloat::Float8E4M3B11FNUZ(), "0x1.0p-10");
  EXPECT_FALSE(test.isNegative());
  EXPECT_TRUE(test.isFiniteNonZero());
  EXPECT_FALSE(test.isDenormal());
  EXPECT_TRUE(test.bitwiseIsEqual(expected));
  EXPECT_TRUE(test.isSmallestNormalized());

  test = APFloat::getSmallestNormalized(APFloat::FloatTF32(), false);
  expected = APFloat(APFloat::FloatTF32(), "0x1p-126");
  EXPECT_FALSE(test.isNegative());
  EXPECT_TRUE(test.isFiniteNonZero());
  EXPECT_FALSE(test.isDenormal());
  EXPECT_TRUE(test.bitwiseIsEqual(expected));
  EXPECT_TRUE(test.isSmallestNormalized());

  test = APFloat::getSmallestNormalized(APFloat::Float6E3M2FN(), false);
  expected = APFloat(APFloat::Float6E3M2FN(), "0x1p-2");
  EXPECT_FALSE(test.isNegative());
  EXPECT_TRUE(test.isFiniteNonZero());
  EXPECT_FALSE(test.isDenormal());
  EXPECT_TRUE(test.bitwiseIsEqual(expected));
  EXPECT_TRUE(test.isSmallestNormalized());

  test = APFloat::getSmallestNormalized(APFloat::Float4E2M1FN(), false);
  expected = APFloat(APFloat::Float4E2M1FN(), "0x1p0");
  EXPECT_FALSE(test.isNegative());
  EXPECT_TRUE(test.isFiniteNonZero());
  EXPECT_FALSE(test.isDenormal());
  EXPECT_TRUE(test.bitwiseIsEqual(expected));
  EXPECT_TRUE(test.isSmallestNormalized());

  test = APFloat::getSmallestNormalized(APFloat::Float6E2M3FN(), false);
  expected = APFloat(APFloat::Float6E2M3FN(), "0x1p0");
  EXPECT_FALSE(test.isNegative());
  EXPECT_TRUE(test.isFiniteNonZero());
  EXPECT_FALSE(test.isDenormal());
  EXPECT_TRUE(test.bitwiseIsEqual(expected));
  EXPECT_TRUE(test.isSmallestNormalized());

  test = APFloat::getSmallestNormalized(APFloat::Float8E8M0FNU(), false);
  expected = APFloat(APFloat::Float8E8M0FNU(), "0x1.0p-127");
  EXPECT_FALSE(test.isNegative());
  EXPECT_TRUE(test.isFiniteNonZero());
  EXPECT_FALSE(test.isDenormal());
  EXPECT_TRUE(test.bitwiseIsEqual(expected));
  EXPECT_TRUE(test.isSmallestNormalized());

  test = APFloat::getSmallestNormalized(APFloat::Float8E5M3FNU(), false);
  expected = APFloat(APFloat::Float8E5M3FNU(), "0x1.0p-14");
  EXPECT_FALSE(test.isNegative());
  EXPECT_TRUE(test.isFiniteNonZero());
  EXPECT_FALSE(test.isDenormal());
  EXPECT_TRUE(test.bitwiseIsEqual(expected));
  EXPECT_TRUE(test.isSmallestNormalized());
}

TEST(APFloatTest, getZero) {
  struct {
    const fltSemantics *semantics;
    const bool sign;
    const bool signedZero;
    const unsigned long long bitPattern[2];
    const unsigned bitPatternLength;
  } const GetZeroTest[] = {
      {&APFloat::IEEEhalf(), false, true, {0, 0}, 1},
      {&APFloat::IEEEhalf(), true, true, {0x8000ULL, 0}, 1},
      {&APFloat::IEEEsingle(), false, true, {0, 0}, 1},
      {&APFloat::IEEEsingle(), true, true, {0x80000000ULL, 0}, 1},
      {&APFloat::IEEEdouble(), false, true, {0, 0}, 1},
      {&APFloat::IEEEdouble(), true, true, {0x8000000000000000ULL, 0}, 1},
      {&APFloat::IEEEquad(), false, true, {0, 0}, 2},
      {&APFloat::IEEEquad(), true, true, {0, 0x8000000000000000ULL}, 2},
      {&APFloat::PPCDoubleDouble(), false, true, {0, 0}, 2},
      {&APFloat::PPCDoubleDouble(), true, true, {0x8000000000000000ULL, 0}, 2},
      {&APFloat::x87DoubleExtended(), false, true, {0, 0}, 2},
      {&APFloat::x87DoubleExtended(), true, true, {0, 0x8000ULL}, 2},
      {&APFloat::Float8E5M2(), false, true, {0, 0}, 1},
      {&APFloat::Float8E5M2(), true, true, {0x80ULL, 0}, 1},
      {&APFloat::Float8E5M2FNUZ(), false, false, {0, 0}, 1},
      {&APFloat::Float8E5M2FNUZ(), true, false, {0, 0}, 1},
      {&APFloat::Float8E5M3FNU(), false, false, {0, 0}, 1},
      {&APFloat::Float8E4M3(), false, true, {0, 0}, 1},
      {&APFloat::Float8E4M3(), true, true, {0x80ULL, 0}, 1},
      {&APFloat::Float8E4M3FN(), false, true, {0, 0}, 1},
      {&APFloat::Float8E4M3FN(), true, true, {0x80ULL, 0}, 1},
      {&APFloat::Float8E4M3FNUZ(), false, false, {0, 0}, 1},
      {&APFloat::Float8E4M3FNUZ(), true, false, {0, 0}, 1},
      {&APFloat::Float8E4M3B11FNUZ(), false, false, {0, 0}, 1},
      {&APFloat::Float8E4M3B11FNUZ(), true, false, {0, 0}, 1},
      {&APFloat::Float8E3M4(), false, true, {0, 0}, 1},
      {&APFloat::Float8E3M4(), true, true, {0x80ULL, 0}, 1},
      {&APFloat::FloatTF32(), false, true, {0, 0}, 1},
      {&APFloat::FloatTF32(), true, true, {0x40000ULL, 0}, 1},
      {&APFloat::Float6E3M2FN(), false, true, {0, 0}, 1},
      {&APFloat::Float6E3M2FN(), true, true, {0x20ULL, 0}, 1},
      {&APFloat::Float6E2M3FN(), false, true, {0, 0}, 1},
      {&APFloat::Float6E2M3FN(), true, true, {0x20ULL, 0}, 1},
      {&APFloat::Float4E2M1FN(), false, true, {0, 0}, 1},
      {&APFloat::Float4E2M1FN(), true, true, {0x8ULL, 0}, 1}};
  const unsigned NumGetZeroTests = std::size(GetZeroTest);
  for (unsigned i = 0; i < NumGetZeroTests; ++i) {
    APFloat test = APFloat::getZero(*GetZeroTest[i].semantics,
                                    GetZeroTest[i].sign);
    const char *pattern = GetZeroTest[i].sign? "-0x0p+0" : "0x0p+0";
    APFloat expected = APFloat(*GetZeroTest[i].semantics,
                               pattern);
    EXPECT_TRUE(test.isZero());
    if (GetZeroTest[i].signedZero)
      EXPECT_TRUE(GetZeroTest[i].sign ? test.isNegative() : !test.isNegative());
    else
      EXPECT_TRUE(!test.isNegative());
    EXPECT_TRUE(test.bitwiseIsEqual(expected));
    for (unsigned j = 0, je = GetZeroTest[i].bitPatternLength; j < je; ++j) {
      EXPECT_EQ(GetZeroTest[i].bitPattern[j],
                test.bitcastToAPInt().getRawData()[j]);
    }
  }
}

TEST(APFloatTest, copySign) {
  EXPECT_TRUE(APFloat(-42.0).bitwiseIsEqual(
      APFloat::copySign(APFloat(42.0), APFloat(-1.0))));
  EXPECT_TRUE(APFloat(42.0).bitwiseIsEqual(
      APFloat::copySign(APFloat(-42.0), APFloat(1.0))));
  EXPECT_TRUE(APFloat(-42.0).bitwiseIsEqual(
      APFloat::copySign(APFloat(-42.0), APFloat(-1.0))));
  EXPECT_TRUE(APFloat(42.0).bitwiseIsEqual(
      APFloat::copySign(APFloat(42.0), APFloat(1.0))));
  // For floating-point formats with unsigned 0, copySign() to a zero is a noop
  for (APFloat::Semantics S :
       {APFloat::S_Float8E4M3FNUZ, APFloat::S_Float8E4M3B11FNUZ}) {
    const llvm::fltSemantics &Sem = APFloat::EnumToSemantics(S);
    EXPECT_TRUE(APFloat::getZero(Sem).bitwiseIsEqual(
        APFloat::copySign(APFloat::getZero(Sem), APFloat(-1.0))));
    EXPECT_TRUE(APFloat::getNaN(Sem, true).bitwiseIsEqual(
        APFloat::copySign(APFloat::getNaN(Sem, true), APFloat(1.0))));
  }
}

TEST(APFloatTest, convert) {
  bool losesInfo;
  APFloat test(APFloat::IEEEdouble(), "1.0");
  test.convert(APFloat::IEEEsingle(), APFloat::rmNearestTiesToEven, &losesInfo);
  EXPECT_EQ(1.0f, test.convertToFloat());
  EXPECT_FALSE(losesInfo);

  test = APFloat(APFloat::x87DoubleExtended(), "0x1p-53");
  test.add(APFloat(APFloat::x87DoubleExtended(), "1.0"), APFloat::rmNearestTiesToEven);
  test.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven, &losesInfo);
  EXPECT_EQ(1.0, test.convertToDouble());
  EXPECT_TRUE(losesInfo);

  test = APFloat(APFloat::IEEEquad(), "0x1p-53");
  test.add(APFloat(APFloat::IEEEquad(), "1.0"), APFloat::rmNearestTiesToEven);
  test.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven, &losesInfo);
  EXPECT_EQ(1.0, test.convertToDouble());
  EXPECT_TRUE(losesInfo);

  test = APFloat(APFloat::x87DoubleExtended(), "0xf.fffffffp+28");
  test.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven, &losesInfo);
  EXPECT_EQ(4294967295.0, test.convertToDouble());
  EXPECT_FALSE(losesInfo);

  test = APFloat::getSNaN(APFloat::IEEEsingle());
  APFloat::opStatus status = test.convert(APFloat::x87DoubleExtended(), APFloat::rmNearestTiesToEven, &losesInfo);
  // Conversion quiets the SNAN, so now 2 bits of the 64-bit significand should be set.
  APInt topTwoBits(64, 0x6000000000000000);
  EXPECT_TRUE(test.bitwiseIsEqual(APFloat::getQNaN(APFloat::x87DoubleExtended(), false, &topTwoBits)));
  EXPECT_FALSE(losesInfo);
  EXPECT_EQ(status, APFloat::opInvalidOp);

  test = APFloat::getQNaN(APFloat::IEEEsingle());
  APFloat X87QNaN = APFloat::getQNaN(APFloat::x87DoubleExtended());
  test.convert(APFloat::x87DoubleExtended(), APFloat::rmNearestTiesToEven,
               &losesInfo);
  EXPECT_TRUE(test.bitwiseIsEqual(X87QNaN));
  EXPECT_FALSE(losesInfo);

  test = APFloat::getSNaN(APFloat::x87DoubleExtended());
  test.convert(APFloat::x87DoubleExtended(), APFloat::rmNearestTiesToEven,
               &losesInfo);
  APFloat X87SNaN = APFloat::getSNaN(APFloat::x87DoubleExtended());
  EXPECT_TRUE(test.bitwiseIsEqual(X87SNaN));
  EXPECT_FALSE(losesInfo);

  test = APFloat::getQNaN(APFloat::x87DoubleExtended());
  test.convert(APFloat::x87DoubleExtended(), APFloat::rmNearestTiesToEven,
               &losesInfo);
  EXPECT_TRUE(test.bitwiseIsEqual(X87QNaN));
  EXPECT_FALSE(losesInfo);

  // The payload is lost in truncation, but we retain NaN by setting the quiet bit.
  APInt payload(52, 1);
  test = APFloat::getSNaN(APFloat::IEEEdouble(), false, &payload);
  status = test.convert(APFloat::IEEEsingle(), APFloat::rmNearestTiesToEven, &losesInfo);
  EXPECT_EQ(0x7fc00000, test.bitcastToAPInt());
  EXPECT_TRUE(losesInfo);
  EXPECT_EQ(status, APFloat::opInvalidOp);

  // The payload is lost in truncation. QNaN remains QNaN.
  test = APFloat::getQNaN(APFloat::IEEEdouble(), false, &payload);
  status = test.convert(APFloat::IEEEsingle(), APFloat::rmNearestTiesToEven, &losesInfo);
  EXPECT_EQ(0x7fc00000, test.bitcastToAPInt());
  EXPECT_TRUE(losesInfo);
  EXPECT_EQ(status, APFloat::opOK);

  // Test that subnormals are handled correctly in double to float conversion
  test = APFloat(APFloat::IEEEdouble(), "0x0.0000010000000p-1022");
  test.convert(APFloat::IEEEsingle(), APFloat::rmNearestTiesToEven, &losesInfo);
  EXPECT_EQ(0.0f, test.convertToFloat());
  EXPECT_TRUE(losesInfo);

  test = APFloat(APFloat::IEEEdouble(), "0x0.0000010000001p-1022");
  test.convert(APFloat::IEEEsingle(), APFloat::rmNearestTiesToEven, &losesInfo);
  EXPECT_EQ(0.0f, test.convertToFloat());
  EXPECT_TRUE(losesInfo);

  test = APFloat(APFloat::IEEEdouble(), "-0x0.0000010000001p-1022");
  test.convert(APFloat::IEEEsingle(), APFloat::rmNearestTiesToEven, &losesInfo);
  EXPECT_EQ(0.0f, test.convertToFloat());
  EXPECT_TRUE(losesInfo);

  test = APFloat(APFloat::IEEEdouble(), "0x0.0000020000000p-1022");
  test.convert(APFloat::IEEEsingle(), APFloat::rmNearestTiesToEven, &losesInfo);
  EXPECT_EQ(0.0f, test.convertToFloat());
  EXPECT_TRUE(losesInfo);

  test = APFloat(APFloat::IEEEdouble(), "0x0.0000020000001p-1022");
  test.convert(APFloat::IEEEsingle(), APFloat::rmNearestTiesToEven, &losesInfo);
  EXPECT_EQ(0.0f, test.convertToFloat());
  EXPECT_TRUE(losesInfo);

  // Test subnormal conversion to bfloat
  test = APFloat(APFloat::IEEEsingle(), "0x0.01p-126");
  test.convert(APFloat::BFloat(), APFloat::rmNearestTiesToEven, &losesInfo);
  EXPECT_EQ(0.0f, test.convertToFloat());
  EXPECT_TRUE(losesInfo);

  test = APFloat(APFloat::IEEEsingle(), "0x0.02p-126");
  test.convert(APFloat::BFloat(), APFloat::rmNearestTiesToEven, &losesInfo);
  EXPECT_EQ(0x01, test.bitcastToAPInt());
  EXPECT_FALSE(losesInfo);

  test = APFloat(APFloat::IEEEsingle(), "0x0.01p-126");
  test.convert(APFloat::BFloat(), APFloat::rmNearestTiesToAway, &losesInfo);
  EXPECT_EQ(0x01, test.bitcastToAPInt());
  EXPECT_TRUE(losesInfo);
}

TEST(APFloatTest, Float8UZConvert) {
  bool losesInfo = false;
  std::pair<APFloat, APFloat::opStatus> toNaNTests[] = {
      {APFloat::getQNaN(APFloat::IEEEsingle(), false), APFloat::opOK},
      {APFloat::getQNaN(APFloat::IEEEsingle(), true), APFloat::opOK},
      {APFloat::getSNaN(APFloat::IEEEsingle(), false), APFloat::opInvalidOp},
      {APFloat::getSNaN(APFloat::IEEEsingle(), true), APFloat::opInvalidOp},
      {APFloat::getInf(APFloat::IEEEsingle(), false), APFloat::opInexact},
      {APFloat::getInf(APFloat::IEEEsingle(), true), APFloat::opInexact}};
  for (APFloat::Semantics S :
       {APFloat::S_Float8E5M2FNUZ, APFloat::S_Float8E4M3FNUZ,
        APFloat::S_Float8E4M3B11FNUZ}) {
    const llvm::fltSemantics &Sem = APFloat::EnumToSemantics(S);
    SCOPED_TRACE("Semantics = " + std::to_string(S));
    for (auto [toTest, expectedRes] : toNaNTests) {
      llvm::SmallString<16> value;
      toTest.toString(value);
      SCOPED_TRACE("toTest = " + value);
      losesInfo = false;
      APFloat test = toTest;
      EXPECT_EQ(test.convert(Sem, APFloat::rmNearestTiesToAway, &losesInfo),
                expectedRes);
      EXPECT_TRUE(test.isNaN());
      EXPECT_TRUE(test.isNegative());
      EXPECT_FALSE(test.isSignaling());
      EXPECT_FALSE(test.isInfinity());
      EXPECT_EQ(0x80, test.bitcastToAPInt());
      EXPECT_TRUE(losesInfo);
    }

    // Negative zero conversions are information losing.
    losesInfo = false;
    APFloat test = APFloat::getZero(APFloat::IEEEsingle(), true);
    EXPECT_EQ(test.convert(Sem, APFloat::rmNearestTiesToAway, &losesInfo),
              APFloat::opInexact);
    EXPECT_TRUE(test.isZero());
    EXPECT_FALSE(test.isNegative());
    EXPECT_TRUE(losesInfo);
    EXPECT_EQ(0x0, test.bitcastToAPInt());

    losesInfo = true;
    test = APFloat::getZero(APFloat::IEEEsingle(), false);
    EXPECT_EQ(test.convert(Sem, APFloat::rmNearestTiesToAway, &losesInfo),
              APFloat::opOK);
    EXPECT_TRUE(test.isZero());
    EXPECT_FALSE(test.isNegative());
    EXPECT_FALSE(losesInfo);
    EXPECT_EQ(0x0, test.bitcastToAPInt());

    // Except in casts between ourselves.
    losesInfo = true;
    test = APFloat::getZero(Sem);
    EXPECT_EQ(test.convert(Sem, APFloat::rmNearestTiesToAway, &losesInfo),
              APFloat::opOK);
    EXPECT_FALSE(losesInfo);
    EXPECT_EQ(0x0, test.bitcastToAPInt());
  }
}

struct DD {
  double Hi;
  double Lo;
};

template <typename T, typename U>
static APFloat makeDoubleAPFloat(T Hi, U Lo) {
  APFloat HiFloat{APFloat::IEEEdouble(), APFloat::uninitialized};
  if constexpr (std::is_same_v<decltype(Hi), APFloat>) {
    HiFloat = Hi;
  } else if constexpr (std::is_same_v<decltype(Hi), double>) {
    HiFloat = APFloat{Hi};
  } else {
    HiFloat = {APFloat::IEEEdouble(), Hi};
  }

  APFloat LoFloat{APFloat::IEEEdouble(), APFloat::uninitialized};
  if constexpr (std::is_same_v<decltype(Lo), APFloat>) {
    LoFloat = Lo;
  } else if constexpr (std::is_same_v<decltype(Lo), double>) {
    LoFloat = APFloat{Lo};
  } else {
    LoFloat = {APFloat::IEEEdouble(), Lo};
  }

  APInt Bits = LoFloat.bitcastToAPInt().concat(HiFloat.bitcastToAPInt());
  return APFloat(APFloat::PPCDoubleDouble(), Bits);
}

static APFloat makeDoubleAPFloat(DD X) { return makeDoubleAPFloat(X.Hi, X.Lo); }

TEST(APFloatTest, PPCDoubleDouble) {
  APFloat test(APFloat::PPCDoubleDouble(), "1.0");
  EXPECT_EQ(0x3ff0000000000000ull, test.bitcastToAPInt().getRawData()[0]);
  EXPECT_EQ(0x0000000000000000ull, test.bitcastToAPInt().getRawData()[1]);

  // LDBL_MAX
  test = APFloat(APFloat::PPCDoubleDouble(), "1.79769313486231580793728971405301e+308");
  EXPECT_EQ(0x7fefffffffffffffull, test.bitcastToAPInt().getRawData()[0]);
  EXPECT_EQ(0x7c8ffffffffffffeull, test.bitcastToAPInt().getRawData()[1]);

  // LDBL_MIN
  test = APFloat(APFloat::PPCDoubleDouble(), "2.00416836000897277799610805135016e-292");
  EXPECT_EQ(0x0360000000000000ull, test.bitcastToAPInt().getRawData()[0]);
  EXPECT_EQ(0x0000000000000000ull, test.bitcastToAPInt().getRawData()[1]);

  // PR30869
  {
    auto Result = APFloat(APFloat::PPCDoubleDouble(), "1.0") +
                  APFloat(APFloat::PPCDoubleDouble(), "1.0");
    EXPECT_EQ(&APFloat::PPCDoubleDouble(), &Result.getSemantics());

    Result = APFloat(APFloat::PPCDoubleDouble(), "1.0") -
             APFloat(APFloat::PPCDoubleDouble(), "1.0");
    EXPECT_EQ(&APFloat::PPCDoubleDouble(), &Result.getSemantics());

    Result = APFloat(APFloat::PPCDoubleDouble(), "1.0") *
             APFloat(APFloat::PPCDoubleDouble(), "1.0");
    EXPECT_EQ(&APFloat::PPCDoubleDouble(), &Result.getSemantics());

    Result = APFloat(APFloat::PPCDoubleDouble(), "1.0") /
             APFloat(APFloat::PPCDoubleDouble(), "1.0");
    EXPECT_EQ(&APFloat::PPCDoubleDouble(), &Result.getSemantics());

    int Exp;
    Result = frexp(APFloat(APFloat::PPCDoubleDouble(), "1.0"), Exp,
                   APFloat::rmNearestTiesToEven);
    EXPECT_EQ(&APFloat::PPCDoubleDouble(), &Result.getSemantics());

    Result = scalbn(APFloat(APFloat::PPCDoubleDouble(), "1.0"), 1,
                    APFloat::rmNearestTiesToEven);
    EXPECT_EQ(&APFloat::PPCDoubleDouble(), &Result.getSemantics());
  }
}

TEST(APFloatTest, isNegative) {
  APFloat t(APFloat::IEEEsingle(), "0x1p+0");
  EXPECT_FALSE(t.isNegative());
  t = APFloat(APFloat::IEEEsingle(), "-0x1p+0");
  EXPECT_TRUE(t.isNegative());

  EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle(), false).isNegative());
  EXPECT_TRUE(APFloat::getInf(APFloat::IEEEsingle(), true).isNegative());

  EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle(), false).isNegative());
  EXPECT_TRUE(APFloat::getZero(APFloat::IEEEsingle(), true).isNegative());

  EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle(), false).isNegative());
  EXPECT_TRUE(APFloat::getNaN(APFloat::IEEEsingle(), true).isNegative());

  EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle(), false).isNegative());
  EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle(), true).isNegative());
}

TEST(APFloatTest, isNormal) {
  APFloat t(APFloat::IEEEsingle(), "0x1p+0");
  EXPECT_TRUE(t.isNormal());

  EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle(), false).isNormal());
  EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle(), false).isNormal());
  EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle(), false).isNormal());
  EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle(), false).isNormal());
  EXPECT_FALSE(APFloat(APFloat::IEEEsingle(), "0x1p-149").isNormal());
}

TEST(APFloatTest, isFinite) {
  APFloat t(APFloat::IEEEsingle(), "0x1p+0");
  EXPECT_TRUE(t.isFinite());
  EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle(), false).isFinite());
  EXPECT_TRUE(APFloat::getZero(APFloat::IEEEsingle(), false).isFinite());
  EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle(), false).isFinite());
  EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle(), false).isFinite());
  EXPECT_TRUE(APFloat(APFloat::IEEEsingle(), "0x1p-149").isFinite());
}

TEST(APFloatTest, isInfinity) {
  APFloat t(APFloat::IEEEsingle(), "0x1p+0");
  EXPECT_FALSE(t.isInfinity());

  APFloat PosInf = APFloat::getInf(APFloat::IEEEsingle(), false);
  APFloat NegInf = APFloat::getInf(APFloat::IEEEsingle(), true);

  EXPECT_TRUE(PosInf.isInfinity());
  EXPECT_TRUE(PosInf.isPosInfinity());
  EXPECT_FALSE(PosInf.isNegInfinity());
  EXPECT_EQ(fcPosInf, PosInf.classify());

  EXPECT_TRUE(NegInf.isInfinity());
  EXPECT_FALSE(NegInf.isPosInfinity());
  EXPECT_TRUE(NegInf.isNegInfinity());
  EXPECT_EQ(fcNegInf, NegInf.classify());

  EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle(), false).isInfinity());
  EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle(), false).isInfinity());
  EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle(), false).isInfinity());
  EXPECT_FALSE(APFloat(APFloat::IEEEsingle(), "0x1p-149").isInfinity());

  for (unsigned I = 0; I != APFloat::S_MaxSemantics + 1; ++I) {
    const fltSemantics &Semantics =
        APFloat::EnumToSemantics(static_cast<APFloat::Semantics>(I));
    if (APFloat::semanticsHasInf(Semantics)) {
      EXPECT_TRUE(APFloat::getInf(Semantics).isInfinity());
    }
  }
}

TEST(APFloatTest, isNaN) {
  APFloat t(APFloat::IEEEsingle(), "0x1p+0");
  EXPECT_FALSE(t.isNaN());
  EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle(), false).isNaN());
  EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle(), false).isNaN());
  EXPECT_TRUE(APFloat::getNaN(APFloat::IEEEsingle(), false).isNaN());
  EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle(), false).isNaN());
  EXPECT_FALSE(APFloat(APFloat::IEEEsingle(), "0x1p-149").isNaN());

  for (unsigned I = 0; I != APFloat::S_MaxSemantics + 1; ++I) {
    const fltSemantics &Semantics =
        APFloat::EnumToSemantics(static_cast<APFloat::Semantics>(I));
    if (APFloat::semanticsHasNaN(Semantics)) {
      EXPECT_TRUE(APFloat::getNaN(Semantics).isNaN());
    }
  }
}

TEST(APFloatTest, isFiniteNonZero) {
  // Test positive/negative normal value.
  EXPECT_TRUE(APFloat(APFloat::IEEEsingle(), "0x1p+0").isFiniteNonZero());
  EXPECT_TRUE(APFloat(APFloat::IEEEsingle(), "-0x1p+0").isFiniteNonZero());

  // Test positive/negative denormal value.
  EXPECT_TRUE(APFloat(APFloat::IEEEsingle(), "0x1p-149").isFiniteNonZero());
  EXPECT_TRUE(APFloat(APFloat::IEEEsingle(), "-0x1p-149").isFiniteNonZero());

  // Test +/- Infinity.
  EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle(), false).isFiniteNonZero());
  EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle(), true).isFiniteNonZero());

  // Test +/- Zero.
  EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle(), false).isFiniteNonZero());
  EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle(), true).isFiniteNonZero());

  // Test +/- qNaN. +/- dont mean anything with qNaN but paranoia can't hurt in
  // this instance.
  EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle(), false).isFiniteNonZero());
  EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle(), true).isFiniteNonZero());

  // Test +/- sNaN. +/- dont mean anything with sNaN but paranoia can't hurt in
  // this instance.
  EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle(), false).isFiniteNonZero());
  EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle(), true).isFiniteNonZero());
}

TEST(APFloatTest, add) {
  // Test Special Cases against each other and normal values.

  APFloat PInf = APFloat::getInf(APFloat::IEEEsingle(), false);
  APFloat MInf = APFloat::getInf(APFloat::IEEEsingle(), true);
  APFloat PZero = APFloat::getZero(APFloat::IEEEsingle(), false);
  APFloat MZero = APFloat::getZero(APFloat::IEEEsingle(), true);
  APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle(), false);
  APFloat SNaN = APFloat(APFloat::IEEEsingle(), "snan123");
  APFloat PNormalValue = APFloat(APFloat::IEEEsingle(), "0x1p+0");
  APFloat MNormalValue = APFloat(APFloat::IEEEsingle(), "-0x1p+0");
  APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), false);
  APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), true);
  APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), false);
  APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), true);
  APFloat PSmallestNormalized =
    APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false);
  APFloat MSmallestNormalized =
    APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true);

  const int OverflowStatus = APFloat::opOverflow | APFloat::opInexact;

  struct {
    APFloat x;
    APFloat y;
    const char *result;
    int status;
    int category;
  } SpecialCaseTests[] = {
    { PInf, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
    { PInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
    { PInf, PZero, "inf", APFloat::opOK, APFloat::fcInfinity },
    { PInf, MZero, "inf", APFloat::opOK, APFloat::fcInfinity },
    { PInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
    { PInf, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { PInf, PNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
    { PInf, MNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
    { PInf, PLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
    { PInf, MLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
    { PInf, PSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
    { PInf, MSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
    { PInf, PSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
    { PInf, MSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
    { MInf, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
    { MInf, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
    { MInf, PZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
    { MInf, MZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
    { MInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
    { MInf, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { MInf, PNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
    { MInf, MNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
    { MInf, PLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
    { MInf, MLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
    { MInf, PSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
    { MInf, MSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
    { MInf, PSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
    { MInf, MSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
    { PZero, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
    { PZero, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
    { PZero, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PZero, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
    { PZero, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { PZero, PNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
    { PZero, MNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
    { PZero, PLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
    { PZero, MLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
    { PZero, PSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
    { PZero, MSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
    { PZero, PSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
    { PZero, MSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
    { MZero, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
    { MZero, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
    { MZero, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MZero, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
    { MZero, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { MZero, PNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
    { MZero, MNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
    { MZero, PLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
    { MZero, MLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
    { MZero, PSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
    { MZero, MSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
    { MZero, PSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
    { MZero, MSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
    { QNaN, PInf, "nan", APFloat::opOK, APFloat::fcNaN },
    { QNaN, MInf, "nan", APFloat::opOK, APFloat::fcNaN },
    { QNaN, PZero, "nan", APFloat::opOK, APFloat::fcNaN },
    { QNaN, MZero, "nan", APFloat::opOK, APFloat::fcNaN },
    { QNaN, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
    { QNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
    { QNaN, PNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
    { QNaN, MNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
    { QNaN, PLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
    { QNaN, MLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
    { QNaN, PSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
    { QNaN, MSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
    { QNaN, PSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
    { QNaN, MSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
    { SNaN, PInf, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { SNaN, MInf, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { SNaN, PZero, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { SNaN, MZero, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { SNaN, QNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { SNaN, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { SNaN, PNormalValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { SNaN, MNormalValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { SNaN, PLargestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { SNaN, MLargestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { SNaN, PSmallestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { SNaN, MSmallestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { SNaN, PSmallestNormalized, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { SNaN, MSmallestNormalized, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { PNormalValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
    { PNormalValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
    { PNormalValue, PZero, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
    { PNormalValue, MZero, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
    { PNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
    { PNormalValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { PNormalValue, PNormalValue, "0x1p+1", APFloat::opOK, APFloat::fcNormal },
    { PNormalValue, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PNormalValue, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
    { PNormalValue, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
    { PNormalValue, PSmallestValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
    { PNormalValue, MSmallestValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
    { PNormalValue, PSmallestNormalized, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
    { PNormalValue, MSmallestNormalized, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
    { MNormalValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
    { MNormalValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
    { MNormalValue, PZero, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
    { MNormalValue, MZero, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
    { MNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
    { MNormalValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { MNormalValue, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MNormalValue, MNormalValue, "-0x1p+1", APFloat::opOK, APFloat::fcNormal },
    { MNormalValue, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
    { MNormalValue, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
    { MNormalValue, PSmallestValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
    { MNormalValue, MSmallestValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
    { MNormalValue, PSmallestNormalized, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
    { MNormalValue, MSmallestNormalized, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
    { PLargestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
    { PLargestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
    { PLargestValue, PZero, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
    { PLargestValue, MZero, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
    { PLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
    { PLargestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { PLargestValue, PNormalValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
    { PLargestValue, MNormalValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
    { PLargestValue, PLargestValue, "inf", OverflowStatus, APFloat::fcInfinity },
    { PLargestValue, MLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PLargestValue, PSmallestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
    { PLargestValue, MSmallestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
    { PLargestValue, PSmallestNormalized, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
    { PLargestValue, MSmallestNormalized, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
    { MLargestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
    { MLargestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
    { MLargestValue, PZero, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
    { MLargestValue, MZero, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
    { MLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
    { MLargestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { MLargestValue, PNormalValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
    { MLargestValue, MNormalValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
    { MLargestValue, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MLargestValue, MLargestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
    { MLargestValue, PSmallestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
    { MLargestValue, MSmallestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
    { MLargestValue, PSmallestNormalized, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
    { MLargestValue, MSmallestNormalized, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
    { PSmallestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
    { PSmallestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
    { PSmallestValue, PZero, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
    { PSmallestValue, MZero, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
    { PSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
    { PSmallestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { PSmallestValue, PNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
    { PSmallestValue, MNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
    { PSmallestValue, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
    { PSmallestValue, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
    { PSmallestValue, PSmallestValue, "0x1p-148", APFloat::opOK, APFloat::fcNormal },
    { PSmallestValue, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PSmallestValue, PSmallestNormalized, "0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
    { PSmallestValue, MSmallestNormalized, "-0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
    { MSmallestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
    { MSmallestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
    { MSmallestValue, PZero, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
    { MSmallestValue, MZero, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
    { MSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
    { MSmallestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { MSmallestValue, PNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
    { MSmallestValue, MNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
    { MSmallestValue, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
    { MSmallestValue, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
    { MSmallestValue, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MSmallestValue, MSmallestValue, "-0x1p-148", APFloat::opOK, APFloat::fcNormal },
    { MSmallestValue, PSmallestNormalized, "0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
    { MSmallestValue, MSmallestNormalized, "-0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
    { PSmallestNormalized, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
    { PSmallestNormalized, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
    { PSmallestNormalized, PZero, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
    { PSmallestNormalized, MZero, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
    { PSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
    { PSmallestNormalized, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { PSmallestNormalized, PNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
    { PSmallestNormalized, MNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
    { PSmallestNormalized, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
    { PSmallestNormalized, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
    { PSmallestNormalized, PSmallestValue, "0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
    { PSmallestNormalized, MSmallestValue, "0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
    { PSmallestNormalized, PSmallestNormalized, "0x1p-125", APFloat::opOK, APFloat::fcNormal },
    { PSmallestNormalized, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MSmallestNormalized, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
    { MSmallestNormalized, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
    { MSmallestNormalized, PZero, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
    { MSmallestNormalized, MZero, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
    { MSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
    { MSmallestNormalized, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { MSmallestNormalized, PNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
    { MSmallestNormalized, MNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
    { MSmallestNormalized, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
    { MSmallestNormalized, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
    { MSmallestNormalized, PSmallestValue, "-0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
    { MSmallestNormalized, MSmallestValue, "-0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
    { MSmallestNormalized, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MSmallestNormalized, MSmallestNormalized, "-0x1p-125", APFloat::opOK, APFloat::fcNormal }
  };

  for (size_t i = 0; i < std::size(SpecialCaseTests); ++i) {
    APFloat x(SpecialCaseTests[i].x);
    APFloat y(SpecialCaseTests[i].y);
    APFloat::opStatus status = x.add(y, APFloat::rmNearestTiesToEven);

    APFloat result(APFloat::IEEEsingle(), SpecialCaseTests[i].result);

    EXPECT_TRUE(result.bitwiseIsEqual(x));
    EXPECT_EQ(SpecialCaseTests[i].status, (int)status);
    EXPECT_EQ(SpecialCaseTests[i].category, (int)x.getCategory());
  }
}

TEST(APFloatTest, subtract) {
  // Test Special Cases against each other and normal values.

  APFloat PInf = APFloat::getInf(APFloat::IEEEsingle(), false);
  APFloat MInf = APFloat::getInf(APFloat::IEEEsingle(), true);
  APFloat PZero = APFloat::getZero(APFloat::IEEEsingle(), false);
  APFloat MZero = APFloat::getZero(APFloat::IEEEsingle(), true);
  APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle(), false);
  APFloat SNaN = APFloat(APFloat::IEEEsingle(), "snan123");
  APFloat PNormalValue = APFloat(APFloat::IEEEsingle(), "0x1p+0");
  APFloat MNormalValue = APFloat(APFloat::IEEEsingle(), "-0x1p+0");
  APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), false);
  APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), true);
  APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), false);
  APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), true);
  APFloat PSmallestNormalized =
    APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false);
  APFloat MSmallestNormalized =
    APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true);

  const int OverflowStatus = APFloat::opOverflow | APFloat::opInexact;

  struct {
    APFloat x;
    APFloat y;
    const char *result;
    int status;
    int category;
  } SpecialCaseTests[] = {
    { PInf, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
    { PInf, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
    { PInf, PZero, "inf", APFloat::opOK, APFloat::fcInfinity },
    { PInf, MZero, "inf", APFloat::opOK, APFloat::fcInfinity },
    { PInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
    { PInf, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { PInf, PNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
    { PInf, MNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
    { PInf, PLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
    { PInf, MLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
    { PInf, PSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
    { PInf, MSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
    { PInf, PSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
    { PInf, MSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
    { MInf, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
    { MInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
    { MInf, PZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
    { MInf, MZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
    { MInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
    { MInf, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { MInf, PNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
    { MInf, MNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
    { MInf, PLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
    { MInf, MLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
    { MInf, PSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
    { MInf, MSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
    { MInf, PSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
    { MInf, MSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
    { PZero, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
    { PZero, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
    { PZero, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PZero, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
    { PZero, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { PZero, PNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
    { PZero, MNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
    { PZero, PLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
    { PZero, MLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
    { PZero, PSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
    { PZero, MSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
    { PZero, PSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
    { PZero, MSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
    { MZero, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
    { MZero, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
    { MZero, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MZero, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
    { MZero, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { MZero, PNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
    { MZero, MNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
    { MZero, PLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
    { MZero, MLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
    { MZero, PSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
    { MZero, MSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
    { MZero, PSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
    { MZero, MSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
    { QNaN, PInf, "nan", APFloat::opOK, APFloat::fcNaN },
    { QNaN, MInf, "nan", APFloat::opOK, APFloat::fcNaN },
    { QNaN, PZero, "nan", APFloat::opOK, APFloat::fcNaN },
    { QNaN, MZero, "nan", APFloat::opOK, APFloat::fcNaN },
    { QNaN, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
    { QNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
    { QNaN, PNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
    { QNaN, MNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
    { QNaN, PLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
    { QNaN, MLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
    { QNaN, PSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
    { QNaN, MSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
    { QNaN, PSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
    { QNaN, MSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
    { SNaN, PInf, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { SNaN, MInf, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { SNaN, PZero, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { SNaN, MZero, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { SNaN, QNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { SNaN, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { SNaN, PNormalValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { SNaN, MNormalValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { SNaN, PLargestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { SNaN, MLargestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { SNaN, PSmallestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { SNaN, MSmallestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { SNaN, PSmallestNormalized, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { SNaN, MSmallestNormalized, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { PNormalValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
    { PNormalValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
    { PNormalValue, PZero, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
    { PNormalValue, MZero, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
    { PNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
    { PNormalValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { PNormalValue, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PNormalValue, MNormalValue, "0x1p+1", APFloat::opOK, APFloat::fcNormal },
    { PNormalValue, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
    { PNormalValue, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
    { PNormalValue, PSmallestValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
    { PNormalValue, MSmallestValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
    { PNormalValue, PSmallestNormalized, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
    { PNormalValue, MSmallestNormalized, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
    { MNormalValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
    { MNormalValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
    { MNormalValue, PZero, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
    { MNormalValue, MZero, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
    { MNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
    { MNormalValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { MNormalValue, PNormalValue, "-0x1p+1", APFloat::opOK, APFloat::fcNormal },
    { MNormalValue, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MNormalValue, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
    { MNormalValue, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
    { MNormalValue, PSmallestValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
    { MNormalValue, MSmallestValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
    { MNormalValue, PSmallestNormalized, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
    { MNormalValue, MSmallestNormalized, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
    { PLargestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
    { PLargestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
    { PLargestValue, PZero, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
    { PLargestValue, MZero, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
    { PLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
    { PLargestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { PLargestValue, PNormalValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
    { PLargestValue, MNormalValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
    { PLargestValue, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PLargestValue, MLargestValue, "inf", OverflowStatus, APFloat::fcInfinity },
    { PLargestValue, PSmallestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
    { PLargestValue, MSmallestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
    { PLargestValue, PSmallestNormalized, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
    { PLargestValue, MSmallestNormalized, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
    { MLargestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
    { MLargestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
    { MLargestValue, PZero, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
    { MLargestValue, MZero, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
    { MLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
    { MLargestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { MLargestValue, PNormalValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
    { MLargestValue, MNormalValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
    { MLargestValue, PLargestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
    { MLargestValue, MLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MLargestValue, PSmallestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
    { MLargestValue, MSmallestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
    { MLargestValue, PSmallestNormalized, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
    { MLargestValue, MSmallestNormalized, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
    { PSmallestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
    { PSmallestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
    { PSmallestValue, PZero, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
    { PSmallestValue, MZero, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
    { PSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
    { PSmallestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { PSmallestValue, PNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
    { PSmallestValue, MNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
    { PSmallestValue, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
    { PSmallestValue, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
    { PSmallestValue, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PSmallestValue, MSmallestValue, "0x1p-148", APFloat::opOK, APFloat::fcNormal },
    { PSmallestValue, PSmallestNormalized, "-0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
    { PSmallestValue, MSmallestNormalized, "0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
    { MSmallestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
    { MSmallestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
    { MSmallestValue, PZero, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
    { MSmallestValue, MZero, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
    { MSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
    { MSmallestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { MSmallestValue, PNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
    { MSmallestValue, MNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
    { MSmallestValue, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
    { MSmallestValue, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
    { MSmallestValue, PSmallestValue, "-0x1p-148", APFloat::opOK, APFloat::fcNormal },
    { MSmallestValue, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MSmallestValue, PSmallestNormalized, "-0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
    { MSmallestValue, MSmallestNormalized, "0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
    { PSmallestNormalized, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
    { PSmallestNormalized, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
    { PSmallestNormalized, PZero, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
    { PSmallestNormalized, MZero, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
    { PSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
    { PSmallestNormalized, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { PSmallestNormalized, PNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
    { PSmallestNormalized, MNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
    { PSmallestNormalized, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
    { PSmallestNormalized, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
    { PSmallestNormalized, PSmallestValue, "0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
    { PSmallestNormalized, MSmallestValue, "0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
    { PSmallestNormalized, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PSmallestNormalized, MSmallestNormalized, "0x1p-125", APFloat::opOK, APFloat::fcNormal },
    { MSmallestNormalized, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
    { MSmallestNormalized, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
    { MSmallestNormalized, PZero, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
    { MSmallestNormalized, MZero, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
    { MSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
    { MSmallestNormalized, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { MSmallestNormalized, PNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
    { MSmallestNormalized, MNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
    { MSmallestNormalized, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
    { MSmallestNormalized, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
    { MSmallestNormalized, PSmallestValue, "-0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
    { MSmallestNormalized, MSmallestValue, "-0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
    { MSmallestNormalized, PSmallestNormalized, "-0x1p-125", APFloat::opOK, APFloat::fcNormal },
    { MSmallestNormalized, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero }
  };

  for (size_t i = 0; i < std::size(SpecialCaseTests); ++i) {
    APFloat x(SpecialCaseTests[i].x);
    APFloat y(SpecialCaseTests[i].y);
    APFloat::opStatus status = x.subtract(y, APFloat::rmNearestTiesToEven);

    APFloat result(APFloat::IEEEsingle(), SpecialCaseTests[i].result);

    EXPECT_TRUE(result.bitwiseIsEqual(x));
    EXPECT_EQ(SpecialCaseTests[i].status, (int)status);
    EXPECT_EQ(SpecialCaseTests[i].category, (int)x.getCategory());
  }
}

TEST(APFloatTest, multiply) {
  // Test Special Cases against each other and normal values.

  APFloat PInf = APFloat::getInf(APFloat::IEEEsingle(), false);
  APFloat MInf = APFloat::getInf(APFloat::IEEEsingle(), true);
  APFloat PZero = APFloat::getZero(APFloat::IEEEsingle(), false);
  APFloat MZero = APFloat::getZero(APFloat::IEEEsingle(), true);
  APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle(), false);
  APFloat SNaN = APFloat(APFloat::IEEEsingle(), "snan123");
  APFloat PNormalValue = APFloat(APFloat::IEEEsingle(), "0x1p+0");
  APFloat MNormalValue = APFloat(APFloat::IEEEsingle(), "-0x1p+0");
  APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), false);
  APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), true);
  APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), false);
  APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), true);
  APFloat PSmallestNormalized =
      APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false);
  APFloat MSmallestNormalized =
      APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true);

  APFloat MaxQuad(APFloat::IEEEquad(),
                  "0x1.ffffffffffffffffffffffffffffp+16383");
  APFloat MinQuad(APFloat::IEEEquad(),
                  "0x0.0000000000000000000000000001p-16382");
  APFloat NMinQuad(APFloat::IEEEquad(),
                   "-0x0.0000000000000000000000000001p-16382");

  const int OverflowStatus = APFloat::opOverflow | APFloat::opInexact;
  const int UnderflowStatus = APFloat::opUnderflow | APFloat::opInexact;

  struct {
    APFloat x;
    APFloat y;
    const char *result;
    int status;
    int category;
    APFloat::roundingMode roundingMode = APFloat::rmNearestTiesToEven;
  } SpecialCaseTests[] = {
    { PInf, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
    { PInf, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
    { PInf, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
    { PInf, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
    { PInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
    { PInf, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { PInf, PNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
    { PInf, MNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
    { PInf, PLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
    { PInf, MLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
    { PInf, PSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
    { PInf, MSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
    { PInf, PSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
    { PInf, MSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
    { MInf, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
    { MInf, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
    { MInf, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
    { MInf, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
    { MInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
    { MInf, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { MInf, PNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
    { MInf, MNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
    { MInf, PLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
    { MInf, MLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
    { MInf, PSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
    { MInf, MSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
    { MInf, PSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
    { MInf, MSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
    { PZero, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
    { PZero, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
    { PZero, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PZero, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
    { PZero, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { PZero, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PZero, MNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PZero, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PZero, MLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PZero, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PZero, MSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PZero, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PZero, MSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MZero, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
    { MZero, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
    { MZero, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MZero, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
    { MZero, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { MZero, PNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MZero, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MZero, PLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MZero, MLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MZero, PSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MZero, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MZero, PSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MZero, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { QNaN, PInf, "nan", APFloat::opOK, APFloat::fcNaN },
    { QNaN, MInf, "nan", APFloat::opOK, APFloat::fcNaN },
    { QNaN, PZero, "nan", APFloat::opOK, APFloat::fcNaN },
    { QNaN, MZero, "nan", APFloat::opOK, APFloat::fcNaN },
    { QNaN, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
    { QNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
    { QNaN, PNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
    { QNaN, MNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
    { QNaN, PLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
    { QNaN, MLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
    { QNaN, PSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
    { QNaN, MSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
    { QNaN, PSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
    { QNaN, MSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
    { SNaN, PInf, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { SNaN, MInf, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { SNaN, PZero, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { SNaN, MZero, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { SNaN, QNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { SNaN, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { SNaN, PNormalValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { SNaN, MNormalValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { SNaN, PLargestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { SNaN, MLargestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { SNaN, PSmallestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { SNaN, MSmallestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { SNaN, PSmallestNormalized, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { SNaN, MSmallestNormalized, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { PNormalValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
    { PNormalValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
    { PNormalValue, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PNormalValue, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
    { PNormalValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { PNormalValue, PNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
    { PNormalValue, MNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
    { PNormalValue, PLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
    { PNormalValue, MLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
    { PNormalValue, PSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
    { PNormalValue, MSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
    { PNormalValue, PSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
    { PNormalValue, MSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
    { MNormalValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
    { MNormalValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
    { MNormalValue, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MNormalValue, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
    { MNormalValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { MNormalValue, PNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
    { MNormalValue, MNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
    { MNormalValue, PLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
    { MNormalValue, MLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
    { MNormalValue, PSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
    { MNormalValue, MSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
    { MNormalValue, PSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
    { MNormalValue, MSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
    { PLargestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
    { PLargestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
    { PLargestValue, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PLargestValue, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
    { PLargestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { PLargestValue, PNormalValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
    { PLargestValue, MNormalValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
    { PLargestValue, PLargestValue, "inf", OverflowStatus, APFloat::fcInfinity },
    { PLargestValue, MLargestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
    { PLargestValue, PSmallestValue, "0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
    { PLargestValue, MSmallestValue, "-0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
    { PLargestValue, PSmallestNormalized, "0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
    { PLargestValue, MSmallestNormalized, "-0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
    { MLargestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
    { MLargestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
    { MLargestValue, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MLargestValue, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
    { MLargestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { MLargestValue, PNormalValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
    { MLargestValue, MNormalValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
    { MLargestValue, PLargestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
    { MLargestValue, MLargestValue, "inf", OverflowStatus, APFloat::fcInfinity },
    { MLargestValue, PSmallestValue, "-0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
    { MLargestValue, MSmallestValue, "0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
    { MLargestValue, PSmallestNormalized, "-0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
    { MLargestValue, MSmallestNormalized, "0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
    { PSmallestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
    { PSmallestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
    { PSmallestValue, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PSmallestValue, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
    { PSmallestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { PSmallestValue, PNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
    { PSmallestValue, MNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
    { PSmallestValue, PLargestValue, "0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
    { PSmallestValue, MLargestValue, "-0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
    { PSmallestValue, PSmallestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
    { PSmallestValue, MSmallestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
    { PSmallestValue, PSmallestNormalized, "0x0p+0", UnderflowStatus, APFloat::fcZero },
    { PSmallestValue, MSmallestNormalized, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
    { MSmallestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
    { MSmallestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
    { MSmallestValue, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MSmallestValue, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
    { MSmallestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { MSmallestValue, PNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
    { MSmallestValue, MNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
    { MSmallestValue, PLargestValue, "-0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
    { MSmallestValue, MLargestValue, "0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
    { MSmallestValue, PSmallestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
    { MSmallestValue, MSmallestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
    { MSmallestValue, PSmallestNormalized, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
    { MSmallestValue, MSmallestNormalized, "0x0p+0", UnderflowStatus, APFloat::fcZero },
    { PSmallestNormalized, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
    { PSmallestNormalized, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
    { PSmallestNormalized, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PSmallestNormalized, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
    { PSmallestNormalized, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { PSmallestNormalized, PNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
    { PSmallestNormalized, MNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
    { PSmallestNormalized, PLargestValue, "0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
    { PSmallestNormalized, MLargestValue, "-0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
    { PSmallestNormalized, PSmallestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
    { PSmallestNormalized, MSmallestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
    { PSmallestNormalized, PSmallestNormalized, "0x0p+0", UnderflowStatus, APFloat::fcZero },
    { PSmallestNormalized, MSmallestNormalized, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
    { MSmallestNormalized, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
    { MSmallestNormalized, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
    { MSmallestNormalized, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MSmallestNormalized, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
    { MSmallestNormalized, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { MSmallestNormalized, PNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
    { MSmallestNormalized, MNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
    { MSmallestNormalized, PLargestValue, "-0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
    { MSmallestNormalized, MLargestValue, "0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
    { MSmallestNormalized, PSmallestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
    { MSmallestNormalized, MSmallestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
    { MSmallestNormalized, PSmallestNormalized, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
    { MSmallestNormalized, MSmallestNormalized, "0x0p+0", UnderflowStatus, APFloat::fcZero },

    {MaxQuad, MinQuad, "0x1.ffffffffffffffffffffffffffffp-111", APFloat::opOK,
     APFloat::fcNormal, APFloat::rmNearestTiesToEven},
    {MaxQuad, MinQuad, "0x1.ffffffffffffffffffffffffffffp-111", APFloat::opOK,
     APFloat::fcNormal, APFloat::rmTowardPositive},
    {MaxQuad, MinQuad, "0x1.ffffffffffffffffffffffffffffp-111", APFloat::opOK,
     APFloat::fcNormal, APFloat::rmTowardNegative},
    {MaxQuad, MinQuad, "0x1.ffffffffffffffffffffffffffffp-111", APFloat::opOK,
     APFloat::fcNormal, APFloat::rmTowardZero},
    {MaxQuad, MinQuad, "0x1.ffffffffffffffffffffffffffffp-111", APFloat::opOK,
     APFloat::fcNormal, APFloat::rmNearestTiesToAway},

    {MaxQuad, NMinQuad, "-0x1.ffffffffffffffffffffffffffffp-111", APFloat::opOK,
     APFloat::fcNormal, APFloat::rmNearestTiesToEven},
    {MaxQuad, NMinQuad, "-0x1.ffffffffffffffffffffffffffffp-111", APFloat::opOK,
     APFloat::fcNormal, APFloat::rmTowardPositive},
    {MaxQuad, NMinQuad, "-0x1.ffffffffffffffffffffffffffffp-111", APFloat::opOK,
     APFloat::fcNormal, APFloat::rmTowardNegative},
    {MaxQuad, NMinQuad, "-0x1.ffffffffffffffffffffffffffffp-111", APFloat::opOK,
     APFloat::fcNormal, APFloat::rmTowardZero},
    {MaxQuad, NMinQuad, "-0x1.ffffffffffffffffffffffffffffp-111", APFloat::opOK,
     APFloat::fcNormal, APFloat::rmNearestTiesToAway},

    {MaxQuad, MaxQuad, "inf", OverflowStatus, APFloat::fcInfinity,
     APFloat::rmNearestTiesToEven},
    {MaxQuad, MaxQuad, "inf", OverflowStatus, APFloat::fcInfinity,
     APFloat::rmTowardPositive},
    {MaxQuad, MaxQuad, "0x1.ffffffffffffffffffffffffffffp+16383",
     APFloat::opInexact, APFloat::fcNormal, APFloat::rmTowardNegative},
    {MaxQuad, MaxQuad, "0x1.ffffffffffffffffffffffffffffp+16383",
     APFloat::opInexact, APFloat::fcNormal, APFloat::rmTowardZero},
    {MaxQuad, MaxQuad, "inf", OverflowStatus, APFloat::fcInfinity,
     APFloat::rmNearestTiesToAway},

    {MinQuad, MinQuad, "0", UnderflowStatus, APFloat::fcZero,
     APFloat::rmNearestTiesToEven},
    {MinQuad, MinQuad, "0x0.0000000000000000000000000001p-16382",
     UnderflowStatus, APFloat::fcNormal, APFloat::rmTowardPositive},
    {MinQuad, MinQuad, "0", UnderflowStatus, APFloat::fcZero,
     APFloat::rmTowardNegative},
    {MinQuad, MinQuad, "0", UnderflowStatus, APFloat::fcZero,
     APFloat::rmTowardZero},
    {MinQuad, MinQuad, "0", UnderflowStatus, APFloat::fcZero,
     APFloat::rmNearestTiesToAway},

    {MinQuad, NMinQuad, "-0", UnderflowStatus, APFloat::fcZero,
     APFloat::rmNearestTiesToEven},
    {MinQuad, NMinQuad, "-0", UnderflowStatus, APFloat::fcZero,
     APFloat::rmTowardPositive},
    {MinQuad, NMinQuad, "-0x0.0000000000000000000000000001p-16382",
     UnderflowStatus, APFloat::fcNormal, APFloat::rmTowardNegative},
    {MinQuad, NMinQuad, "-0", UnderflowStatus, APFloat::fcZero,
     APFloat::rmTowardZero},
    {MinQuad, NMinQuad, "-0", UnderflowStatus, APFloat::fcZero,
     APFloat::rmNearestTiesToAway},
  };

  for (size_t i = 0; i < std::size(SpecialCaseTests); ++i) {
    APFloat x(SpecialCaseTests[i].x);
    APFloat y(SpecialCaseTests[i].y);
    APFloat::opStatus status = x.multiply(y, SpecialCaseTests[i].roundingMode);

    APFloat result(x.getSemantics(), SpecialCaseTests[i].result);

    EXPECT_TRUE(result.bitwiseIsEqual(x));
    EXPECT_EQ(SpecialCaseTests[i].status, (int)status);
    EXPECT_EQ(SpecialCaseTests[i].category, (int)x.getCategory());
  }
}

TEST(APFloatTest, divide) {
  // Test Special Cases against each other and normal values.

  APFloat PInf = APFloat::getInf(APFloat::IEEEsingle(), false);
  APFloat MInf = APFloat::getInf(APFloat::IEEEsingle(), true);
  APFloat PZero = APFloat::getZero(APFloat::IEEEsingle(), false);
  APFloat MZero = APFloat::getZero(APFloat::IEEEsingle(), true);
  APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle(), false);
  APFloat SNaN = APFloat(APFloat::IEEEsingle(), "snan123");
  APFloat PNormalValue = APFloat(APFloat::IEEEsingle(), "0x1p+0");
  APFloat MNormalValue = APFloat(APFloat::IEEEsingle(), "-0x1p+0");
  APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), false);
  APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), true);
  APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), false);
  APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), true);
  APFloat PSmallestNormalized =
      APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false);
  APFloat MSmallestNormalized =
      APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true);

  APFloat MaxQuad(APFloat::IEEEquad(),
                  "0x1.ffffffffffffffffffffffffffffp+16383");
  APFloat MinQuad(APFloat::IEEEquad(),
                  "0x0.0000000000000000000000000001p-16382");
  APFloat NMinQuad(APFloat::IEEEquad(),
                   "-0x0.0000000000000000000000000001p-16382");

  const int OverflowStatus = APFloat::opOverflow | APFloat::opInexact;
  const int UnderflowStatus = APFloat::opUnderflow | APFloat::opInexact;

  struct {
    APFloat x;
    APFloat y;
    const char *result;
    int status;
    int category;
    APFloat::roundingMode roundingMode = APFloat::rmNearestTiesToEven;
  } SpecialCaseTests[] = {
    { PInf, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
    { PInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
    { PInf, PZero, "inf", APFloat::opOK, APFloat::fcInfinity },
    { PInf, MZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
    { PInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
    { PInf, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { PInf, PNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
    { PInf, MNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
    { PInf, PLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
    { PInf, MLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
    { PInf, PSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
    { PInf, MSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
    { PInf, PSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
    { PInf, MSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
    { MInf, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
    { MInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
    { MInf, PZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
    { MInf, MZero, "inf", APFloat::opOK, APFloat::fcInfinity },
    { MInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
    { MInf, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { MInf, PNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
    { MInf, MNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
    { MInf, PLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
    { MInf, MLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
    { MInf, PSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
    { MInf, MSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
    { MInf, PSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
    { MInf, MSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
    { PZero, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PZero, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PZero, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
    { PZero, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
    { PZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
    { PZero, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { PZero, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PZero, MNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PZero, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PZero, MLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PZero, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PZero, MSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PZero, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PZero, MSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MZero, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MZero, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MZero, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
    { MZero, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
    { MZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
    { MZero, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { MZero, PNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MZero, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MZero, PLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MZero, MLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MZero, PSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MZero, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MZero, PSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MZero, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { QNaN, PInf, "nan", APFloat::opOK, APFloat::fcNaN },
    { QNaN, MInf, "nan", APFloat::opOK, APFloat::fcNaN },
    { QNaN, PZero, "nan", APFloat::opOK, APFloat::fcNaN },
    { QNaN, MZero, "nan", APFloat::opOK, APFloat::fcNaN },
    { QNaN, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
    { QNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
    { QNaN, PNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
    { QNaN, MNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
    { QNaN, PLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
    { QNaN, MLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
    { QNaN, PSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
    { QNaN, MSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
    { QNaN, PSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
    { QNaN, MSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
    { SNaN, PInf, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { SNaN, MInf, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { SNaN, PZero, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { SNaN, MZero, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { SNaN, QNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { SNaN, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { SNaN, PNormalValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { SNaN, MNormalValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { SNaN, PLargestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { SNaN, MLargestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { SNaN, PSmallestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { SNaN, MSmallestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { SNaN, PSmallestNormalized, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { SNaN, MSmallestNormalized, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { PNormalValue, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PNormalValue, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PNormalValue, PZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
    { PNormalValue, MZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
    { PNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
    { PNormalValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { PNormalValue, PNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
    { PNormalValue, MNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
    { PNormalValue, PLargestValue, "0x1p-128", UnderflowStatus, APFloat::fcNormal },
    { PNormalValue, MLargestValue, "-0x1p-128", UnderflowStatus, APFloat::fcNormal },
    { PNormalValue, PSmallestValue, "inf", OverflowStatus, APFloat::fcInfinity },
    { PNormalValue, MSmallestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
    { PNormalValue, PSmallestNormalized, "0x1p+126", APFloat::opOK, APFloat::fcNormal },
    { PNormalValue, MSmallestNormalized, "-0x1p+126", APFloat::opOK, APFloat::fcNormal },
    { MNormalValue, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MNormalValue, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MNormalValue, PZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
    { MNormalValue, MZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
    { MNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
    { MNormalValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { MNormalValue, PNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
    { MNormalValue, MNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
    { MNormalValue, PLargestValue, "-0x1p-128", UnderflowStatus, APFloat::fcNormal },
    { MNormalValue, MLargestValue, "0x1p-128", UnderflowStatus, APFloat::fcNormal },
    { MNormalValue, PSmallestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
    { MNormalValue, MSmallestValue, "inf", OverflowStatus, APFloat::fcInfinity },
    { MNormalValue, PSmallestNormalized, "-0x1p+126", APFloat::opOK, APFloat::fcNormal },
    { MNormalValue, MSmallestNormalized, "0x1p+126", APFloat::opOK, APFloat::fcNormal },
    { PLargestValue, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PLargestValue, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PLargestValue, PZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
    { PLargestValue, MZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
    { PLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
    { PLargestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { PLargestValue, PNormalValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
    { PLargestValue, MNormalValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
    { PLargestValue, PLargestValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
    { PLargestValue, MLargestValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
    { PLargestValue, PSmallestValue, "inf", OverflowStatus, APFloat::fcInfinity },
    { PLargestValue, MSmallestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
    { PLargestValue, PSmallestNormalized, "inf", OverflowStatus, APFloat::fcInfinity },
    { PLargestValue, MSmallestNormalized, "-inf", OverflowStatus, APFloat::fcInfinity },
    { MLargestValue, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MLargestValue, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MLargestValue, PZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
    { MLargestValue, MZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
    { MLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
    { MLargestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { MLargestValue, PNormalValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
    { MLargestValue, MNormalValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
    { MLargestValue, PLargestValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
    { MLargestValue, MLargestValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
    { MLargestValue, PSmallestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
    { MLargestValue, MSmallestValue, "inf", OverflowStatus, APFloat::fcInfinity },
    { MLargestValue, PSmallestNormalized, "-inf", OverflowStatus, APFloat::fcInfinity },
    { MLargestValue, MSmallestNormalized, "inf", OverflowStatus, APFloat::fcInfinity },
    { PSmallestValue, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PSmallestValue, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PSmallestValue, PZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
    { PSmallestValue, MZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
    { PSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
    { PSmallestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { PSmallestValue, PNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
    { PSmallestValue, MNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
    { PSmallestValue, PLargestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
    { PSmallestValue, MLargestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
    { PSmallestValue, PSmallestValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
    { PSmallestValue, MSmallestValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
    { PSmallestValue, PSmallestNormalized, "0x1p-23", APFloat::opOK, APFloat::fcNormal },
    { PSmallestValue, MSmallestNormalized, "-0x1p-23", APFloat::opOK, APFloat::fcNormal },
    { MSmallestValue, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MSmallestValue, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MSmallestValue, PZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
    { MSmallestValue, MZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
    { MSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
    { MSmallestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { MSmallestValue, PNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
    { MSmallestValue, MNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
    { MSmallestValue, PLargestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
    { MSmallestValue, MLargestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
    { MSmallestValue, PSmallestValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
    { MSmallestValue, MSmallestValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
    { MSmallestValue, PSmallestNormalized, "-0x1p-23", APFloat::opOK, APFloat::fcNormal },
    { MSmallestValue, MSmallestNormalized, "0x1p-23", APFloat::opOK, APFloat::fcNormal },
    { PSmallestNormalized, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PSmallestNormalized, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PSmallestNormalized, PZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
    { PSmallestNormalized, MZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
    { PSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
    { PSmallestNormalized, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { PSmallestNormalized, PNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
    { PSmallestNormalized, MNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
    { PSmallestNormalized, PLargestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
    { PSmallestNormalized, MLargestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
    { PSmallestNormalized, PSmallestValue, "0x1p+23", APFloat::opOK, APFloat::fcNormal },
    { PSmallestNormalized, MSmallestValue, "-0x1p+23", APFloat::opOK, APFloat::fcNormal },
    { PSmallestNormalized, PSmallestNormalized, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
    { PSmallestNormalized, MSmallestNormalized, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
    { MSmallestNormalized, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MSmallestNormalized, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MSmallestNormalized, PZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
    { MSmallestNormalized, MZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
    { MSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
    { MSmallestNormalized, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { MSmallestNormalized, PNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
    { MSmallestNormalized, MNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
    { MSmallestNormalized, PLargestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
    { MSmallestNormalized, MLargestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
    { MSmallestNormalized, PSmallestValue, "-0x1p+23", APFloat::opOK, APFloat::fcNormal },
    { MSmallestNormalized, MSmallestValue, "0x1p+23", APFloat::opOK, APFloat::fcNormal },
    { MSmallestNormalized, PSmallestNormalized, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
    { MSmallestNormalized, MSmallestNormalized, "0x1p+0", APFloat::opOK, APFloat::fcNormal },

    {MaxQuad, NMinQuad, "-inf", OverflowStatus, APFloat::fcInfinity,
     APFloat::rmNearestTiesToEven},
    {MaxQuad, NMinQuad, "-0x1.ffffffffffffffffffffffffffffp+16383",
     APFloat::opInexact, APFloat::fcNormal, APFloat::rmTowardPositive},
    {MaxQuad, NMinQuad, "-inf", OverflowStatus, APFloat::fcInfinity,
     APFloat::rmTowardNegative},
    {MaxQuad, NMinQuad, "-0x1.ffffffffffffffffffffffffffffp+16383",
     APFloat::opInexact, APFloat::fcNormal, APFloat::rmTowardZero},
    {MaxQuad, NMinQuad, "-inf", OverflowStatus, APFloat::fcInfinity,
     APFloat::rmNearestTiesToAway},

    {MinQuad, MaxQuad, "0", UnderflowStatus, APFloat::fcZero,
     APFloat::rmNearestTiesToEven},
    {MinQuad, MaxQuad, "0x0.0000000000000000000000000001p-16382",
     UnderflowStatus, APFloat::fcNormal, APFloat::rmTowardPositive},
    {MinQuad, MaxQuad, "0", UnderflowStatus, APFloat::fcZero,
     APFloat::rmTowardNegative},
    {MinQuad, MaxQuad, "0", UnderflowStatus, APFloat::fcZero,
     APFloat::rmTowardZero},
    {MinQuad, MaxQuad, "0", UnderflowStatus, APFloat::fcZero,
     APFloat::rmNearestTiesToAway},

    {NMinQuad, MaxQuad, "-0", UnderflowStatus, APFloat::fcZero,
     APFloat::rmNearestTiesToEven},
    {NMinQuad, MaxQuad, "-0", UnderflowStatus, APFloat::fcZero,
     APFloat::rmTowardPositive},
    {NMinQuad, MaxQuad, "-0x0.0000000000000000000000000001p-16382",
     UnderflowStatus, APFloat::fcNormal, APFloat::rmTowardNegative},
    {NMinQuad, MaxQuad, "-0", UnderflowStatus, APFloat::fcZero,
     APFloat::rmTowardZero},
    {NMinQuad, MaxQuad, "-0", UnderflowStatus, APFloat::fcZero,
     APFloat::rmNearestTiesToAway},
  };

  for (size_t i = 0; i < std::size(SpecialCaseTests); ++i) {
    APFloat x(SpecialCaseTests[i].x);
    APFloat y(SpecialCaseTests[i].y);
    APFloat::opStatus status = x.divide(y, SpecialCaseTests[i].roundingMode);

    APFloat result(x.getSemantics(), SpecialCaseTests[i].result);

    EXPECT_TRUE(result.bitwiseIsEqual(x));
    EXPECT_EQ(SpecialCaseTests[i].status, (int)status);
    EXPECT_EQ(SpecialCaseTests[i].category, (int)x.getCategory());
  }
}

TEST(APFloatTest, operatorOverloads) {
  // This is mostly testing that these operator overloads compile.
  APFloat One = APFloat(APFloat::IEEEsingle(), "0x1p+0");
  APFloat Two = APFloat(APFloat::IEEEsingle(), "0x2p+0");
  EXPECT_TRUE(Two.bitwiseIsEqual(One + One));
  EXPECT_TRUE(One.bitwiseIsEqual(Two - One));
  EXPECT_TRUE(Two.bitwiseIsEqual(One * Two));
  EXPECT_TRUE(One.bitwiseIsEqual(Two / Two));
}

TEST(APFloatTest, Comparisons) {
  enum {MNan, MInf, MBig, MOne, MZer, PZer, POne, PBig, PInf, PNan, NumVals};
  APFloat Vals[NumVals] = {
    APFloat::getNaN(APFloat::IEEEsingle(), true),
    APFloat::getInf(APFloat::IEEEsingle(), true),
    APFloat::getLargest(APFloat::IEEEsingle(), true),
    APFloat(APFloat::IEEEsingle(), "-0x1p+0"),
    APFloat::getZero(APFloat::IEEEsingle(), true),
    APFloat::getZero(APFloat::IEEEsingle(), false),
    APFloat(APFloat::IEEEsingle(), "0x1p+0"),
    APFloat::getLargest(APFloat::IEEEsingle(), false),
    APFloat::getInf(APFloat::IEEEsingle(), false),
    APFloat::getNaN(APFloat::IEEEsingle(), false),
  };
  using Relation = void (*)(const APFloat &, const APFloat &);
  Relation LT = [](const APFloat &LHS, const APFloat &RHS) {
    EXPECT_FALSE(LHS == RHS);
    EXPECT_TRUE(LHS != RHS);
    EXPECT_TRUE(LHS < RHS);
    EXPECT_FALSE(LHS > RHS);
    EXPECT_TRUE(LHS <= RHS);
    EXPECT_FALSE(LHS >= RHS);
  };
  Relation EQ = [](const APFloat &LHS, const APFloat &RHS) {
    EXPECT_TRUE(LHS == RHS);
    EXPECT_FALSE(LHS != RHS);
    EXPECT_FALSE(LHS < RHS);
    EXPECT_FALSE(LHS > RHS);
    EXPECT_TRUE(LHS <= RHS);
    EXPECT_TRUE(LHS >= RHS);
  };
  Relation GT = [](const APFloat &LHS, const APFloat &RHS) {
    EXPECT_FALSE(LHS == RHS);
    EXPECT_TRUE(LHS != RHS);
    EXPECT_FALSE(LHS < RHS);
    EXPECT_TRUE(LHS > RHS);
    EXPECT_FALSE(LHS <= RHS);
    EXPECT_TRUE(LHS >= RHS);
  };
  Relation UN = [](const APFloat &LHS, const APFloat &RHS) {
    EXPECT_FALSE(LHS == RHS);
    EXPECT_TRUE(LHS != RHS);
    EXPECT_FALSE(LHS < RHS);
    EXPECT_FALSE(LHS > RHS);
    EXPECT_FALSE(LHS <= RHS);
    EXPECT_FALSE(LHS >= RHS);
  };
  Relation Relations[NumVals][NumVals] = {
    //          -N  -I  -B  -1  -0  +0  +1  +B  +I  +N
    /* MNan */ {UN, UN, UN, UN, UN, UN, UN, UN, UN, UN},
    /* MInf */ {UN, EQ, LT, LT, LT, LT, LT, LT, LT, UN},
    /* MBig */ {UN, GT, EQ, LT, LT, LT, LT, LT, LT, UN},
    /* MOne */ {UN, GT, GT, EQ, LT, LT, LT, LT, LT, UN},
    /* MZer */ {UN, GT, GT, GT, EQ, EQ, LT, LT, LT, UN},
    /* PZer */ {UN, GT, GT, GT, EQ, EQ, LT, LT, LT, UN},
    /* POne */ {UN, GT, GT, GT, GT, GT, EQ, LT, LT, UN},
    /* PBig */ {UN, GT, GT, GT, GT, GT, GT, EQ, LT, UN},
    /* PInf */ {UN, GT, GT, GT, GT, GT, GT, GT, EQ, UN},
    /* PNan */ {UN, UN, UN, UN, UN, UN, UN, UN, UN, UN},
  };
  for (unsigned I = 0; I < NumVals; ++I)
    for (unsigned J = 0; J < NumVals; ++J)
      Relations[I][J](Vals[I], Vals[J]);
}

TEST(APFloatTest, abs) {
  APFloat PInf = APFloat::getInf(APFloat::IEEEsingle(), false);
  APFloat MInf = APFloat::getInf(APFloat::IEEEsingle(), true);
  APFloat PZero = APFloat::getZero(APFloat::IEEEsingle(), false);
  APFloat MZero = APFloat::getZero(APFloat::IEEEsingle(), true);
  APFloat PQNaN = APFloat::getNaN(APFloat::IEEEsingle(), false);
  APFloat MQNaN = APFloat::getNaN(APFloat::IEEEsingle(), true);
  APFloat PSNaN = APFloat::getSNaN(APFloat::IEEEsingle(), false);
  APFloat MSNaN = APFloat::getSNaN(APFloat::IEEEsingle(), true);
  APFloat PNormalValue = APFloat(APFloat::IEEEsingle(), "0x1p+0");
  APFloat MNormalValue = APFloat(APFloat::IEEEsingle(), "-0x1p+0");
  APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), false);
  APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), true);
  APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), false);
  APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), true);
  APFloat PSmallestNormalized =
    APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false);
  APFloat MSmallestNormalized =
    APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true);

  EXPECT_TRUE(PInf.bitwiseIsEqual(abs(PInf)));
  EXPECT_TRUE(PInf.bitwiseIsEqual(abs(MInf)));
  EXPECT_TRUE(PZero.bitwiseIsEqual(abs(PZero)));
  EXPECT_TRUE(PZero.bitwiseIsEqual(abs(MZero)));
  EXPECT_TRUE(PQNaN.bitwiseIsEqual(abs(PQNaN)));
  EXPECT_TRUE(PQNaN.bitwiseIsEqual(abs(MQNaN)));
  EXPECT_TRUE(PSNaN.bitwiseIsEqual(abs(PSNaN)));
  EXPECT_TRUE(PSNaN.bitwiseIsEqual(abs(MSNaN)));
  EXPECT_TRUE(PNormalValue.bitwiseIsEqual(abs(PNormalValue)));
  EXPECT_TRUE(PNormalValue.bitwiseIsEqual(abs(MNormalValue)));
  EXPECT_TRUE(PLargestValue.bitwiseIsEqual(abs(PLargestValue)));
  EXPECT_TRUE(PLargestValue.bitwiseIsEqual(abs(MLargestValue)));
  EXPECT_TRUE(PSmallestValue.bitwiseIsEqual(abs(PSmallestValue)));
  EXPECT_TRUE(PSmallestValue.bitwiseIsEqual(abs(MSmallestValue)));
  EXPECT_TRUE(PSmallestNormalized.bitwiseIsEqual(abs(PSmallestNormalized)));
  EXPECT_TRUE(PSmallestNormalized.bitwiseIsEqual(abs(MSmallestNormalized)));
}

TEST(APFloatTest, neg) {
  APFloat One = APFloat(APFloat::IEEEsingle(), "1.0");
  APFloat NegOne = APFloat(APFloat::IEEEsingle(), "-1.0");
  APFloat Zero = APFloat::getZero(APFloat::IEEEsingle(), false);
  APFloat NegZero = APFloat::getZero(APFloat::IEEEsingle(), true);
  APFloat Inf = APFloat::getInf(APFloat::IEEEsingle(), false);
  APFloat NegInf = APFloat::getInf(APFloat::IEEEsingle(), true);
  APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle(), false);
  APFloat NegQNaN = APFloat::getNaN(APFloat::IEEEsingle(), true);

  EXPECT_TRUE(NegOne.bitwiseIsEqual(neg(One)));
  EXPECT_TRUE(One.bitwiseIsEqual(neg(NegOne)));
  EXPECT_TRUE(NegZero.bitwiseIsEqual(neg(Zero)));
  EXPECT_TRUE(Zero.bitwiseIsEqual(neg(NegZero)));
  EXPECT_TRUE(NegInf.bitwiseIsEqual(neg(Inf)));
  EXPECT_TRUE(Inf.bitwiseIsEqual(neg(NegInf)));
  EXPECT_TRUE(NegInf.bitwiseIsEqual(neg(Inf)));
  EXPECT_TRUE(Inf.bitwiseIsEqual(neg(NegInf)));
  EXPECT_TRUE(NegQNaN.bitwiseIsEqual(neg(QNaN)));
  EXPECT_TRUE(QNaN.bitwiseIsEqual(neg(NegQNaN)));

  EXPECT_TRUE(NegOne.bitwiseIsEqual(-One));
  EXPECT_TRUE(One.bitwiseIsEqual(-NegOne));
  EXPECT_TRUE(NegZero.bitwiseIsEqual(-Zero));
  EXPECT_TRUE(Zero.bitwiseIsEqual(-NegZero));
  EXPECT_TRUE(NegInf.bitwiseIsEqual(-Inf));
  EXPECT_TRUE(Inf.bitwiseIsEqual(-NegInf));
  EXPECT_TRUE(NegInf.bitwiseIsEqual(-Inf));
  EXPECT_TRUE(Inf.bitwiseIsEqual(-NegInf));
  EXPECT_TRUE(NegQNaN.bitwiseIsEqual(-QNaN));
  EXPECT_TRUE(QNaN.bitwiseIsEqual(-NegQNaN));
}

TEST(APFloatTest, ilogb) {
  EXPECT_EQ(-1074, ilogb(APFloat::getSmallest(APFloat::IEEEdouble(), false)));
  EXPECT_EQ(-1074, ilogb(APFloat::getSmallest(APFloat::IEEEdouble(), true)));
  EXPECT_EQ(-1023, ilogb(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep-1024")));
  EXPECT_EQ(-1023, ilogb(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep-1023")));
  EXPECT_EQ(-1023, ilogb(APFloat(APFloat::IEEEdouble(), "-0x1.ffffffffffffep-1023")));
  EXPECT_EQ(-51, ilogb(APFloat(APFloat::IEEEdouble(), "0x1p-51")));
  EXPECT_EQ(-1023, ilogb(APFloat(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp-1023")));
  EXPECT_EQ(-2, ilogb(APFloat(APFloat::IEEEdouble(), "0x0.ffffp-1")));
  EXPECT_EQ(-1023, ilogb(APFloat(APFloat::IEEEdouble(), "0x1.fffep-1023")));
  EXPECT_EQ(1023, ilogb(APFloat::getLargest(APFloat::IEEEdouble(), false)));
  EXPECT_EQ(1023, ilogb(APFloat::getLargest(APFloat::IEEEdouble(), true)));


  EXPECT_EQ(0, ilogb(APFloat(APFloat::IEEEsingle(), "0x1p+0")));
  EXPECT_EQ(0, ilogb(APFloat(APFloat::IEEEsingle(), "-0x1p+0")));
  EXPECT_EQ(42, ilogb(APFloat(APFloat::IEEEsingle(), "0x1p+42")));
  EXPECT_EQ(-42, ilogb(APFloat(APFloat::IEEEsingle(), "0x1p-42")));

  EXPECT_EQ(APFloat::IEK_Inf,
            ilogb(APFloat::getInf(APFloat::IEEEsingle(), false)));
  EXPECT_EQ(APFloat::IEK_Inf,
            ilogb(APFloat::getInf(APFloat::IEEEsingle(), true)));
  EXPECT_EQ(APFloat::IEK_Zero,
            ilogb(APFloat::getZero(APFloat::IEEEsingle(), false)));
  EXPECT_EQ(APFloat::IEK_Zero,
            ilogb(APFloat::getZero(APFloat::IEEEsingle(), true)));
  EXPECT_EQ(APFloat::IEK_NaN,
            ilogb(APFloat::getNaN(APFloat::IEEEsingle(), false)));
  EXPECT_EQ(APFloat::IEK_NaN,
            ilogb(APFloat::getSNaN(APFloat::IEEEsingle(), false)));

  EXPECT_EQ(127, ilogb(APFloat::getLargest(APFloat::IEEEsingle(), false)));
  EXPECT_EQ(127, ilogb(APFloat::getLargest(APFloat::IEEEsingle(), true)));

  EXPECT_EQ(-149, ilogb(APFloat::getSmallest(APFloat::IEEEsingle(), false)));
  EXPECT_EQ(-149, ilogb(APFloat::getSmallest(APFloat::IEEEsingle(), true)));
  EXPECT_EQ(-126,
            ilogb(APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false)));
  EXPECT_EQ(-126,
            ilogb(APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true)));
}

TEST(APFloatTest, scalbn) {

  const APFloat::roundingMode RM = APFloat::rmNearestTiesToEven;
  EXPECT_TRUE(
      APFloat(APFloat::IEEEsingle(), "0x1p+0")
      .bitwiseIsEqual(scalbn(APFloat(APFloat::IEEEsingle(), "0x1p+0"), 0, RM)));
  EXPECT_TRUE(
      APFloat(APFloat::IEEEsingle(), "0x1p+42")
      .bitwiseIsEqual(scalbn(APFloat(APFloat::IEEEsingle(), "0x1p+0"), 42, RM)));
  EXPECT_TRUE(
      APFloat(APFloat::IEEEsingle(), "0x1p-42")
      .bitwiseIsEqual(scalbn(APFloat(APFloat::IEEEsingle(), "0x1p+0"), -42, RM)));

  APFloat PInf = APFloat::getInf(APFloat::IEEEsingle(), false);
  APFloat MInf = APFloat::getInf(APFloat::IEEEsingle(), true);
  APFloat PZero = APFloat::getZero(APFloat::IEEEsingle(), false);
  APFloat MZero = APFloat::getZero(APFloat::IEEEsingle(), true);
  APFloat QPNaN = APFloat::getNaN(APFloat::IEEEsingle(), false);
  APFloat QMNaN = APFloat::getNaN(APFloat::IEEEsingle(), true);
  APFloat SNaN = APFloat::getSNaN(APFloat::IEEEsingle(), false);

  EXPECT_TRUE(PInf.bitwiseIsEqual(scalbn(PInf, 0, RM)));
  EXPECT_TRUE(MInf.bitwiseIsEqual(scalbn(MInf, 0, RM)));
  EXPECT_TRUE(PZero.bitwiseIsEqual(scalbn(PZero, 0, RM)));
  EXPECT_TRUE(MZero.bitwiseIsEqual(scalbn(MZero, 0, RM)));
  EXPECT_TRUE(QPNaN.bitwiseIsEqual(scalbn(QPNaN, 0, RM)));
  EXPECT_TRUE(QMNaN.bitwiseIsEqual(scalbn(QMNaN, 0, RM)));
  EXPECT_FALSE(scalbn(SNaN, 0, RM).isSignaling());

  APFloat ScalbnSNaN = scalbn(SNaN, 1, RM);
  EXPECT_TRUE(ScalbnSNaN.isNaN() && !ScalbnSNaN.isSignaling());

  // Make sure highest bit of payload is preserved.
  const APInt Payload(64, (UINT64_C(1) << 50) |
                      (UINT64_C(1) << 49) |
                      (UINT64_C(1234) << 32) |
                      1);

  APFloat SNaNWithPayload = APFloat::getSNaN(APFloat::IEEEdouble(), false,
                                             &Payload);
  APFloat QuietPayload = scalbn(SNaNWithPayload, 1, RM);
  EXPECT_TRUE(QuietPayload.isNaN() && !QuietPayload.isSignaling());
  EXPECT_EQ(Payload, QuietPayload.bitcastToAPInt().getLoBits(51));

  EXPECT_TRUE(PInf.bitwiseIsEqual(
                scalbn(APFloat(APFloat::IEEEsingle(), "0x1p+0"), 128, RM)));
  EXPECT_TRUE(MInf.bitwiseIsEqual(
                scalbn(APFloat(APFloat::IEEEsingle(), "-0x1p+0"), 128, RM)));
  EXPECT_TRUE(PInf.bitwiseIsEqual(
                scalbn(APFloat(APFloat::IEEEsingle(), "0x1p+127"), 1, RM)));
  EXPECT_TRUE(PZero.bitwiseIsEqual(
                scalbn(APFloat(APFloat::IEEEsingle(), "0x1p-127"), -127, RM)));
  EXPECT_TRUE(MZero.bitwiseIsEqual(
                scalbn(APFloat(APFloat::IEEEsingle(), "-0x1p-127"), -127, RM)));
  EXPECT_TRUE(APFloat(APFloat::IEEEsingle(), "-0x1p-149").bitwiseIsEqual(
                scalbn(APFloat(APFloat::IEEEsingle(), "-0x1p-127"), -22, RM)));
  EXPECT_TRUE(PZero.bitwiseIsEqual(
                scalbn(APFloat(APFloat::IEEEsingle(), "0x1p-126"), -24, RM)));


  APFloat SmallestF64 = APFloat::getSmallest(APFloat::IEEEdouble(), false);
  APFloat NegSmallestF64 = APFloat::getSmallest(APFloat::IEEEdouble(), true);

  APFloat LargestF64 = APFloat::getLargest(APFloat::IEEEdouble(), false);
  APFloat NegLargestF64 = APFloat::getLargest(APFloat::IEEEdouble(), true);

  APFloat SmallestNormalizedF64
    = APFloat::getSmallestNormalized(APFloat::IEEEdouble(), false);
  APFloat NegSmallestNormalizedF64
    = APFloat::getSmallestNormalized(APFloat::IEEEdouble(), true);

  APFloat LargestDenormalF64(APFloat::IEEEdouble(), "0x1.ffffffffffffep-1023");
  APFloat NegLargestDenormalF64(APFloat::IEEEdouble(), "-0x1.ffffffffffffep-1023");


  EXPECT_TRUE(SmallestF64.bitwiseIsEqual(
                scalbn(APFloat(APFloat::IEEEdouble(), "0x1p-1074"), 0, RM)));
  EXPECT_TRUE(NegSmallestF64.bitwiseIsEqual(
                scalbn(APFloat(APFloat::IEEEdouble(), "-0x1p-1074"), 0, RM)));

  EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1p+1023")
              .bitwiseIsEqual(scalbn(SmallestF64, 2097, RM)));

  EXPECT_TRUE(scalbn(SmallestF64, -2097, RM).isPosZero());
  EXPECT_TRUE(scalbn(SmallestF64, -2098, RM).isPosZero());
  EXPECT_TRUE(scalbn(SmallestF64, -2099, RM).isPosZero());
  EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1p+1022")
              .bitwiseIsEqual(scalbn(SmallestF64, 2096, RM)));
  EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1p+1023")
              .bitwiseIsEqual(scalbn(SmallestF64, 2097, RM)));
  EXPECT_TRUE(scalbn(SmallestF64, 2098, RM).isInfinity());
  EXPECT_TRUE(scalbn(SmallestF64, 2099, RM).isInfinity());

  // Test for integer overflows when adding to exponent.
  EXPECT_TRUE(scalbn(SmallestF64, -INT_MAX, RM).isPosZero());
  EXPECT_TRUE(scalbn(LargestF64, INT_MAX, RM).isInfinity());

  EXPECT_TRUE(LargestDenormalF64
              .bitwiseIsEqual(scalbn(LargestDenormalF64, 0, RM)));
  EXPECT_TRUE(NegLargestDenormalF64
              .bitwiseIsEqual(scalbn(NegLargestDenormalF64, 0, RM)));

  EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep-1022")
              .bitwiseIsEqual(scalbn(LargestDenormalF64, 1, RM)));
  EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "-0x1.ffffffffffffep-1021")
              .bitwiseIsEqual(scalbn(NegLargestDenormalF64, 2, RM)));

  EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep+1")
              .bitwiseIsEqual(scalbn(LargestDenormalF64, 1024, RM)));
  EXPECT_TRUE(scalbn(LargestDenormalF64, -1023, RM).isPosZero());
  EXPECT_TRUE(scalbn(LargestDenormalF64, -1024, RM).isPosZero());
  EXPECT_TRUE(scalbn(LargestDenormalF64, -2048, RM).isPosZero());
  EXPECT_TRUE(scalbn(LargestDenormalF64, 2047, RM).isInfinity());
  EXPECT_TRUE(scalbn(LargestDenormalF64, 2098, RM).isInfinity());
  EXPECT_TRUE(scalbn(LargestDenormalF64, 2099, RM).isInfinity());

  EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep-2")
              .bitwiseIsEqual(scalbn(LargestDenormalF64, 1021, RM)));
  EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep-1")
              .bitwiseIsEqual(scalbn(LargestDenormalF64, 1022, RM)));
  EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep+0")
              .bitwiseIsEqual(scalbn(LargestDenormalF64, 1023, RM)));
  EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep+1023")
              .bitwiseIsEqual(scalbn(LargestDenormalF64, 2046, RM)));
  EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1p+974")
              .bitwiseIsEqual(scalbn(SmallestF64, 2048, RM)));

  APFloat RandomDenormalF64(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp+51");
  EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp-972")
              .bitwiseIsEqual(scalbn(RandomDenormalF64, -1023, RM)));
  EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp-1")
              .bitwiseIsEqual(scalbn(RandomDenormalF64, -52, RM)));
  EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp-2")
              .bitwiseIsEqual(scalbn(RandomDenormalF64, -53, RM)));
  EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp+0")
              .bitwiseIsEqual(scalbn(RandomDenormalF64, -51, RM)));

  EXPECT_TRUE(scalbn(RandomDenormalF64, -2097, RM).isPosZero());
  EXPECT_TRUE(scalbn(RandomDenormalF64, -2090, RM).isPosZero());


  EXPECT_TRUE(
    APFloat(APFloat::IEEEdouble(), "-0x1p-1073")
    .bitwiseIsEqual(scalbn(NegLargestF64, -2097, RM)));

  EXPECT_TRUE(
    APFloat(APFloat::IEEEdouble(), "-0x1p-1024")
    .bitwiseIsEqual(scalbn(NegLargestF64, -2048, RM)));

  EXPECT_TRUE(
    APFloat(APFloat::IEEEdouble(), "0x1p-1073")
    .bitwiseIsEqual(scalbn(LargestF64, -2097, RM)));

  EXPECT_TRUE(
    APFloat(APFloat::IEEEdouble(), "0x1p-1074")
    .bitwiseIsEqual(scalbn(LargestF64, -2098, RM)));
  EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "-0x1p-1074")
              .bitwiseIsEqual(scalbn(NegLargestF64, -2098, RM)));
  EXPECT_TRUE(scalbn(NegLargestF64, -2099, RM).isNegZero());
  EXPECT_TRUE(scalbn(LargestF64, 1, RM).isInfinity());


  EXPECT_TRUE(
    APFloat(APFloat::IEEEdouble(), "0x1p+0")
    .bitwiseIsEqual(scalbn(APFloat(APFloat::IEEEdouble(), "0x1p+52"), -52, RM)));

  EXPECT_TRUE(
    APFloat(APFloat::IEEEdouble(), "0x1p-103")
    .bitwiseIsEqual(scalbn(APFloat(APFloat::IEEEdouble(), "0x1p-51"), -52, RM)));
}

TEST(APFloatTest, frexp) {
  const APFloat::roundingMode RM = APFloat::rmNearestTiesToEven;

  APFloat PZero = APFloat::getZero(APFloat::IEEEdouble(), false);
  APFloat MZero = APFloat::getZero(APFloat::IEEEdouble(), true);
  APFloat One(1.0);
  APFloat MOne(-1.0);
  APFloat Two(2.0);
  APFloat MTwo(-2.0);

  APFloat LargestDenormal(APFloat::IEEEdouble(), "0x1.ffffffffffffep-1023");
  APFloat NegLargestDenormal(APFloat::IEEEdouble(), "-0x1.ffffffffffffep-1023");

  APFloat Smallest = APFloat::getSmallest(APFloat::IEEEdouble(), false);
  APFloat NegSmallest = APFloat::getSmallest(APFloat::IEEEdouble(), true);

  APFloat Largest = APFloat::getLargest(APFloat::IEEEdouble(), false);
  APFloat NegLargest = APFloat::getLargest(APFloat::IEEEdouble(), true);

  APFloat PInf = APFloat::getInf(APFloat::IEEEdouble(), false);
  APFloat MInf = APFloat::getInf(APFloat::IEEEdouble(), true);

  APFloat QPNaN = APFloat::getNaN(APFloat::IEEEdouble(), false);
  APFloat QMNaN = APFloat::getNaN(APFloat::IEEEdouble(), true);
  APFloat SNaN = APFloat::getSNaN(APFloat::IEEEdouble(), false);

  // Make sure highest bit of payload is preserved.
  const APInt Payload(64, (UINT64_C(1) << 50) |
                      (UINT64_C(1) << 49) |
                      (UINT64_C(1234) << 32) |
                      1);

  APFloat SNaNWithPayload = APFloat::getSNaN(APFloat::IEEEdouble(), false,
                                             &Payload);

  APFloat SmallestNormalized
    = APFloat::getSmallestNormalized(APFloat::IEEEdouble(), false);
  APFloat NegSmallestNormalized
    = APFloat::getSmallestNormalized(APFloat::IEEEdouble(), true);

  int Exp;
  APFloat Frac(APFloat::IEEEdouble());


  Frac = frexp(PZero, Exp, RM);
  EXPECT_EQ(0, Exp);
  EXPECT_TRUE(Frac.isPosZero());

  Frac = frexp(MZero, Exp, RM);
  EXPECT_EQ(0, Exp);
  EXPECT_TRUE(Frac.isNegZero());


  Frac = frexp(One, Exp, RM);
  EXPECT_EQ(1, Exp);
  EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1p-1").bitwiseIsEqual(Frac));

  Frac = frexp(MOne, Exp, RM);
  EXPECT_EQ(1, Exp);
  EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "-0x1p-1").bitwiseIsEqual(Frac));

  Frac = frexp(LargestDenormal, Exp, RM);
  EXPECT_EQ(-1022, Exp);
  EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep-1").bitwiseIsEqual(Frac));

  Frac = frexp(NegLargestDenormal, Exp, RM);
  EXPECT_EQ(-1022, Exp);
  EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "-0x1.ffffffffffffep-1").bitwiseIsEqual(Frac));


  Frac = frexp(Smallest, Exp, RM);
  EXPECT_EQ(-1073, Exp);
  EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1p-1").bitwiseIsEqual(Frac));

  Frac = frexp(NegSmallest, Exp, RM);
  EXPECT_EQ(-1073, Exp);
  EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "-0x1p-1").bitwiseIsEqual(Frac));


  Frac = frexp(Largest, Exp, RM);
  EXPECT_EQ(1024, Exp);
  EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.fffffffffffffp-1").bitwiseIsEqual(Frac));

  Frac = frexp(NegLargest, Exp, RM);
  EXPECT_EQ(1024, Exp);
  EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "-0x1.fffffffffffffp-1").bitwiseIsEqual(Frac));


  Frac = frexp(PInf, Exp, RM);
  EXPECT_EQ(INT_MAX, Exp);
  EXPECT_TRUE(Frac.isInfinity() && !Frac.isNegative());

  Frac = frexp(MInf, Exp, RM);
  EXPECT_EQ(INT_MAX, Exp);
  EXPECT_TRUE(Frac.isInfinity() && Frac.isNegative());

  Frac = frexp(QPNaN, Exp, RM);
  EXPECT_EQ(INT_MIN, Exp);
  EXPECT_TRUE(Frac.isNaN());

  Frac = frexp(QMNaN, Exp, RM);
  EXPECT_EQ(INT_MIN, Exp);
  EXPECT_TRUE(Frac.isNaN());

  Frac = frexp(SNaN, Exp, RM);
  EXPECT_EQ(INT_MIN, Exp);
  EXPECT_TRUE(Frac.isNaN() && !Frac.isSignaling());

  Frac = frexp(SNaNWithPayload, Exp, RM);
  EXPECT_EQ(INT_MIN, Exp);
  EXPECT_TRUE(Frac.isNaN() && !Frac.isSignaling());
  EXPECT_EQ(Payload, Frac.bitcastToAPInt().getLoBits(51));

  Frac = frexp(APFloat(APFloat::IEEEdouble(), "0x0.ffffp-1"), Exp, RM);
  EXPECT_EQ(-1, Exp);
  EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.fffep-1").bitwiseIsEqual(Frac));

  Frac = frexp(APFloat(APFloat::IEEEdouble(), "0x1p-51"), Exp, RM);
  EXPECT_EQ(-50, Exp);
  EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1p-1").bitwiseIsEqual(Frac));

  Frac = frexp(APFloat(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp+51"), Exp, RM);
  EXPECT_EQ(52, Exp);
  EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp-1").bitwiseIsEqual(Frac));
}

TEST(APFloatTest, mod) {
  {
    APFloat f1(APFloat::IEEEdouble(), "1.5");
    APFloat f2(APFloat::IEEEdouble(), "1.0");
    APFloat expected(APFloat::IEEEdouble(), "0.5");
    EXPECT_EQ(f1.mod(f2), APFloat::opOK);
    EXPECT_TRUE(f1.bitwiseIsEqual(expected));
  }
  {
    APFloat f1(APFloat::IEEEdouble(), "0.5");
    APFloat f2(APFloat::IEEEdouble(), "1.0");
    APFloat expected(APFloat::IEEEdouble(), "0.5");
    EXPECT_EQ(f1.mod(f2), APFloat::opOK);
    EXPECT_TRUE(f1.bitwiseIsEqual(expected));
  }
  {
    APFloat f1(APFloat::IEEEdouble(), "0x1.3333333333333p-2"); // 0.3
    APFloat f2(APFloat::IEEEdouble(), "0x1.47ae147ae147bp-7"); // 0.01
    APFloat expected(APFloat::IEEEdouble(),
                     "0x1.47ae147ae1471p-7"); // 0.009999999999999983
    EXPECT_EQ(f1.mod(f2), APFloat::opOK);
    EXPECT_TRUE(f1.bitwiseIsEqual(expected));
  }
  {
    APFloat f1(APFloat::IEEEdouble(), "0x1p64"); // 1.8446744073709552e19
    APFloat f2(APFloat::IEEEdouble(), "1.5");
    APFloat expected(APFloat::IEEEdouble(), "1.0");
    EXPECT_EQ(f1.mod(f2), APFloat::opOK);
    EXPECT_TRUE(f1.bitwiseIsEqual(expected));
  }
  {
    APFloat f1(APFloat::IEEEdouble(), "0x1p1000");
    APFloat f2(APFloat::IEEEdouble(), "0x1p-1000");
    APFloat expected(APFloat::IEEEdouble(), "0.0");
    EXPECT_EQ(f1.mod(f2), APFloat::opOK);
    EXPECT_TRUE(f1.bitwiseIsEqual(expected));
  }
  {
    APFloat f1(APFloat::IEEEdouble(), "0.0");
    APFloat f2(APFloat::IEEEdouble(), "1.0");
    APFloat expected(APFloat::IEEEdouble(), "0.0");
    EXPECT_EQ(f1.mod(f2), APFloat::opOK);
    EXPECT_TRUE(f1.bitwiseIsEqual(expected));
  }
  {
    APFloat f1(APFloat::IEEEdouble(), "1.0");
    APFloat f2(APFloat::IEEEdouble(), "0.0");
    EXPECT_EQ(f1.mod(f2), APFloat::opInvalidOp);
    EXPECT_TRUE(f1.isNaN());
  }
  {
    APFloat f1(APFloat::IEEEdouble(), "0.0");
    APFloat f2(APFloat::IEEEdouble(), "0.0");
    EXPECT_EQ(f1.mod(f2), APFloat::opInvalidOp);
    EXPECT_TRUE(f1.isNaN());
  }
  {
    APFloat f1 = APFloat::getInf(APFloat::IEEEdouble(), false);
    APFloat f2(APFloat::IEEEdouble(), "1.0");
    EXPECT_EQ(f1.mod(f2), APFloat::opInvalidOp);
    EXPECT_TRUE(f1.isNaN());
  }
  {
    APFloat f1(APFloat::IEEEdouble(), "-4.0");
    APFloat f2(APFloat::IEEEdouble(), "-2.0");
    APFloat expected(APFloat::IEEEdouble(), "-0.0");
    EXPECT_EQ(f1.mod(f2), APFloat::opOK);
    EXPECT_TRUE(f1.bitwiseIsEqual(expected));
  }
  {
    APFloat f1(APFloat::IEEEdouble(), "-4.0");
    APFloat f2(APFloat::IEEEdouble(), "2.0");
    APFloat expected(APFloat::IEEEdouble(), "-0.0");
    EXPECT_EQ(f1.mod(f2), APFloat::opOK);
    EXPECT_TRUE(f1.bitwiseIsEqual(expected));
  }
  {
    // Test E4M3FN mod where the LHS exponent is maxExponent (8) and the RHS is
    // the max value whose exponent is minExponent (-6). This requires special
    // logic in the mod implementation to prevent overflow to NaN.
    APFloat f1(APFloat::Float8E4M3FN(), "0x1p8");        // 256
    APFloat f2(APFloat::Float8E4M3FN(), "0x1.ep-6");     // 0.029296875
    APFloat expected(APFloat::Float8E4M3FN(), "0x1p-8"); // 0.00390625
    EXPECT_EQ(f1.mod(f2), APFloat::opOK);
    EXPECT_TRUE(f1.bitwiseIsEqual(expected));
  }
}

TEST(APFloatTest, remainder) {
  // Test Special Cases against each other and normal values.

  APFloat PInf = APFloat::getInf(APFloat::IEEEsingle(), false);
  APFloat MInf = APFloat::getInf(APFloat::IEEEsingle(), true);
  APFloat PZero = APFloat::getZero(APFloat::IEEEsingle(), false);
  APFloat MZero = APFloat::getZero(APFloat::IEEEsingle(), true);
  APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle(), false);
  APFloat SNaN = APFloat(APFloat::IEEEsingle(), "snan123");
  APFloat PNormalValue = APFloat(APFloat::IEEEsingle(), "0x1p+0");
  APFloat MNormalValue = APFloat(APFloat::IEEEsingle(), "-0x1p+0");
  APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), false);
  APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), true);
  APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), false);
  APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), true);
  APFloat PSmallestNormalized =
      APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false);
  APFloat MSmallestNormalized =
      APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true);

  APFloat PVal1(APFloat::IEEEsingle(), "0x1.fffffep+126");
  APFloat MVal1(APFloat::IEEEsingle(), "-0x1.fffffep+126");
  APFloat PVal2(APFloat::IEEEsingle(), "0x1.fffffep-126");
  APFloat MVal2(APFloat::IEEEsingle(), "-0x1.fffffep-126");
  APFloat PVal3(APFloat::IEEEsingle(), "0x1p-125");
  APFloat MVal3(APFloat::IEEEsingle(), "-0x1p-125");
  APFloat PVal4(APFloat::IEEEsingle(), "0x1p+127");
  APFloat MVal4(APFloat::IEEEsingle(), "-0x1p+127");
  APFloat PVal5(APFloat::IEEEsingle(), "1.5");
  APFloat MVal5(APFloat::IEEEsingle(), "-1.5");
  APFloat PVal6(APFloat::IEEEsingle(), "1");
  APFloat MVal6(APFloat::IEEEsingle(), "-1");

  struct {
    APFloat x;
    APFloat y;
    const char *result;
    int status;
    int category;
  } SpecialCaseTests[] = {
    { PInf, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
    { PInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
    { PInf, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
    { PInf, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
    { PInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
    { PInf, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { PInf, PNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
    { PInf, MNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
    { PInf, PLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
    { PInf, MLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
    { PInf, PSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
    { PInf, MSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
    { PInf, PSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
    { PInf, MSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
    { MInf, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
    { MInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
    { MInf, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
    { MInf, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
    { MInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
    { MInf, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { MInf, PNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
    { MInf, MNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
    { MInf, PLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
    { MInf, MLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
    { MInf, PSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
    { MInf, MSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
    { MInf, PSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
    { MInf, MSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
    { PZero, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PZero, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PZero, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
    { PZero, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
    { PZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
    { PZero, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { PZero, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PZero, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PZero, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PZero, MLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PZero, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PZero, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PZero, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PZero, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MZero, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MZero, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MZero, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
    { MZero, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
    { MZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
    { MZero, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { MZero, PNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MZero, MNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MZero, PLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MZero, MLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MZero, PSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MZero, MSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MZero, PSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MZero, MSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { QNaN, PInf, "nan", APFloat::opOK, APFloat::fcNaN },
    { QNaN, MInf, "nan", APFloat::opOK, APFloat::fcNaN },
    { QNaN, PZero, "nan", APFloat::opOK, APFloat::fcNaN },
    { QNaN, MZero, "nan", APFloat::opOK, APFloat::fcNaN },
    { QNaN, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
    { QNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
    { QNaN, PNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
    { QNaN, MNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
    { QNaN, PLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
    { QNaN, MLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
    { QNaN, PSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
    { QNaN, MSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
    { QNaN, PSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
    { QNaN, MSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
    { SNaN, PInf, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { SNaN, MInf, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { SNaN, PZero, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { SNaN, MZero, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { SNaN, QNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { SNaN, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { SNaN, PNormalValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { SNaN, MNormalValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { SNaN, PLargestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { SNaN, MLargestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { SNaN, PSmallestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { SNaN, MSmallestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { SNaN, PSmallestNormalized, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { SNaN, MSmallestNormalized, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { PNormalValue, PInf, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
    { PNormalValue, MInf, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
    { PNormalValue, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
    { PNormalValue, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
    { PNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
    { PNormalValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { PNormalValue, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PNormalValue, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PNormalValue, PLargestValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
    { PNormalValue, MLargestValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
    { PNormalValue, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PNormalValue, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PNormalValue, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PNormalValue, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MNormalValue, PInf, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
    { MNormalValue, MInf, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
    { MNormalValue, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
    { MNormalValue, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
    { MNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
    { MNormalValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { MNormalValue, PNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MNormalValue, MNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MNormalValue, PLargestValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
    { MNormalValue, MLargestValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
    { MNormalValue, PSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MNormalValue, MSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MNormalValue, PSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MNormalValue, MSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PLargestValue, PInf, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
    { PLargestValue, MInf, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
    { PLargestValue, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
    { PLargestValue, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
    { PLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
    { PLargestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { PLargestValue, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PLargestValue, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PLargestValue, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PLargestValue, MLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PLargestValue, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PLargestValue, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PLargestValue, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PLargestValue, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MLargestValue, PInf, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
    { MLargestValue, MInf, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
    { MLargestValue, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
    { MLargestValue, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
    { MLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
    { MLargestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { MLargestValue, PNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MLargestValue, MNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MLargestValue, PLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MLargestValue, MLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MLargestValue, PSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MLargestValue, MSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MLargestValue, PSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MLargestValue, MSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PSmallestValue, PInf, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
    { PSmallestValue, MInf, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
    { PSmallestValue, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
    { PSmallestValue, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
    { PSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
    { PSmallestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { PSmallestValue, PNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
    { PSmallestValue, MNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
    { PSmallestValue, PLargestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
    { PSmallestValue, MLargestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
    { PSmallestValue, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PSmallestValue, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PSmallestValue, PSmallestNormalized, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
    { PSmallestValue, MSmallestNormalized, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
    { MSmallestValue, PInf, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
    { MSmallestValue, MInf, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
    { MSmallestValue, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
    { MSmallestValue, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
    { MSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
    { MSmallestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { MSmallestValue, PNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
    { MSmallestValue, MNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
    { MSmallestValue, PLargestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
    { MSmallestValue, MLargestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
    { MSmallestValue, PSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MSmallestValue, MSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MSmallestValue, PSmallestNormalized, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
    { MSmallestValue, MSmallestNormalized, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
    { PSmallestNormalized, PInf, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
    { PSmallestNormalized, MInf, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
    { PSmallestNormalized, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
    { PSmallestNormalized, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
    { PSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
    { PSmallestNormalized, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { PSmallestNormalized, PNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
    { PSmallestNormalized, MNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
    { PSmallestNormalized, PLargestValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
    { PSmallestNormalized, MLargestValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
    { PSmallestNormalized, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PSmallestNormalized, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PSmallestNormalized, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PSmallestNormalized, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MSmallestNormalized, PInf, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
    { MSmallestNormalized, MInf, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
    { MSmallestNormalized, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
    { MSmallestNormalized, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
    { MSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
    { MSmallestNormalized, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
    { MSmallestNormalized, PNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
    { MSmallestNormalized, MNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
    { MSmallestNormalized, PLargestValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
    { MSmallestNormalized, MLargestValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
    { MSmallestNormalized, PSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MSmallestNormalized, MSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MSmallestNormalized, PSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MSmallestNormalized, MSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },

    { PVal1, PVal1, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PVal1, MVal1, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PVal1, PVal2, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PVal1, MVal2, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PVal1, PVal3, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PVal1, MVal3, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PVal1, PVal4, "-0x1p+103", APFloat::opOK, APFloat::fcNormal },
    { PVal1, MVal4, "-0x1p+103", APFloat::opOK, APFloat::fcNormal },
    { PVal1, PVal5, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PVal1, MVal5, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PVal1, PVal6, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PVal1, MVal6, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MVal1, PVal1, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MVal1, MVal1, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MVal1, PVal2, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MVal1, MVal2, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MVal1, PVal3, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MVal1, MVal3, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MVal1, PVal4, "0x1p+103", APFloat::opOK, APFloat::fcNormal },
    { MVal1, MVal4, "0x1p+103", APFloat::opOK, APFloat::fcNormal },
    { MVal1, PVal5, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MVal1, MVal5, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MVal1, PVal6, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MVal1, MVal6, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PVal2, PVal1, "0x1.fffffep-126", APFloat::opOK, APFloat::fcNormal },
    { PVal2, MVal1, "0x1.fffffep-126", APFloat::opOK, APFloat::fcNormal },
    { PVal2, PVal2, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PVal2, MVal2, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PVal2, PVal3, "-0x0.000002p-126", APFloat::opOK, APFloat::fcNormal },
    { PVal2, MVal3, "-0x0.000002p-126", APFloat::opOK, APFloat::fcNormal },
    { PVal2, PVal4, "0x1.fffffep-126", APFloat::opOK, APFloat::fcNormal },
    { PVal2, MVal4, "0x1.fffffep-126", APFloat::opOK, APFloat::fcNormal },
    { PVal2, PVal5, "0x1.fffffep-126", APFloat::opOK, APFloat::fcNormal },
    { PVal2, MVal5, "0x1.fffffep-126", APFloat::opOK, APFloat::fcNormal },
    { PVal2, PVal6, "0x1.fffffep-126", APFloat::opOK, APFloat::fcNormal },
    { PVal2, MVal6, "0x1.fffffep-126", APFloat::opOK, APFloat::fcNormal },
    { MVal2, PVal1, "-0x1.fffffep-126", APFloat::opOK, APFloat::fcNormal },
    { MVal2, MVal1, "-0x1.fffffep-126", APFloat::opOK, APFloat::fcNormal },
    { MVal2, PVal2, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MVal2, MVal2, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MVal2, PVal3, "0x0.000002p-126", APFloat::opOK, APFloat::fcNormal },
    { MVal2, MVal3, "0x0.000002p-126", APFloat::opOK, APFloat::fcNormal },
    { MVal2, PVal4, "-0x1.fffffep-126", APFloat::opOK, APFloat::fcNormal },
    { MVal2, MVal4, "-0x1.fffffep-126", APFloat::opOK, APFloat::fcNormal },
    { MVal2, PVal5, "-0x1.fffffep-126", APFloat::opOK, APFloat::fcNormal },
    { MVal2, MVal5, "-0x1.fffffep-126", APFloat::opOK, APFloat::fcNormal },
    { MVal2, PVal6, "-0x1.fffffep-126", APFloat::opOK, APFloat::fcNormal },
    { MVal2, MVal6, "-0x1.fffffep-126", APFloat::opOK, APFloat::fcNormal },
    { PVal3, PVal1, "0x1p-125", APFloat::opOK, APFloat::fcNormal },
    { PVal3, MVal1, "0x1p-125", APFloat::opOK, APFloat::fcNormal },
    { PVal3, PVal2, "0x0.000002p-126", APFloat::opOK, APFloat::fcNormal },
    { PVal3, MVal2, "0x0.000002p-126", APFloat::opOK, APFloat::fcNormal },
    { PVal3, PVal3, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PVal3, MVal3, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PVal3, PVal4, "0x1p-125", APFloat::opOK, APFloat::fcNormal },
    { PVal3, MVal4, "0x1p-125", APFloat::opOK, APFloat::fcNormal },
    { PVal3, PVal5, "0x1p-125", APFloat::opOK, APFloat::fcNormal },
    { PVal3, MVal5, "0x1p-125", APFloat::opOK, APFloat::fcNormal },
    { PVal3, PVal6, "0x1p-125", APFloat::opOK, APFloat::fcNormal },
    { PVal3, MVal6, "0x1p-125", APFloat::opOK, APFloat::fcNormal },
    { MVal3, PVal1, "-0x1p-125", APFloat::opOK, APFloat::fcNormal },
    { MVal3, MVal1, "-0x1p-125", APFloat::opOK, APFloat::fcNormal },
    { MVal3, PVal2, "-0x0.000002p-126", APFloat::opOK, APFloat::fcNormal },
    { MVal3, MVal2, "-0x0.000002p-126", APFloat::opOK, APFloat::fcNormal },
    { MVal3, PVal3, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MVal3, MVal3, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MVal3, PVal4, "-0x1p-125", APFloat::opOK, APFloat::fcNormal },
    { MVal3, MVal4, "-0x1p-125", APFloat::opOK, APFloat::fcNormal },
    { MVal3, PVal5, "-0x1p-125", APFloat::opOK, APFloat::fcNormal },
    { MVal3, MVal5, "-0x1p-125", APFloat::opOK, APFloat::fcNormal },
    { MVal3, PVal6, "-0x1p-125", APFloat::opOK, APFloat::fcNormal },
    { MVal3, MVal6, "-0x1p-125", APFloat::opOK, APFloat::fcNormal },
    { PVal4, PVal1, "0x1p+103", APFloat::opOK, APFloat::fcNormal },
    { PVal4, MVal1, "0x1p+103", APFloat::opOK, APFloat::fcNormal },
    { PVal4, PVal2, "0x0.002p-126", APFloat::opOK, APFloat::fcNormal },
    { PVal4, MVal2, "0x0.002p-126", APFloat::opOK, APFloat::fcNormal },
    { PVal4, PVal3, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PVal4, MVal3, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PVal4, PVal4, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PVal4, MVal4, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PVal4, PVal5, "0.5", APFloat::opOK, APFloat::fcNormal },
    { PVal4, MVal5, "0.5", APFloat::opOK, APFloat::fcNormal },
    { PVal4, PVal6, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PVal4, MVal6, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MVal4, PVal1, "-0x1p+103", APFloat::opOK, APFloat::fcNormal },
    { MVal4, MVal1, "-0x1p+103", APFloat::opOK, APFloat::fcNormal },
    { MVal4, PVal2, "-0x0.002p-126", APFloat::opOK, APFloat::fcNormal },
    { MVal4, MVal2, "-0x0.002p-126", APFloat::opOK, APFloat::fcNormal },
    { MVal4, PVal3, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MVal4, MVal3, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MVal4, PVal4, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MVal4, MVal4, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MVal4, PVal5, "-0.5", APFloat::opOK, APFloat::fcNormal },
    { MVal4, MVal5, "-0.5", APFloat::opOK, APFloat::fcNormal },
    { MVal4, PVal6, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MVal4, MVal6, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PVal5, PVal1, "1.5", APFloat::opOK, APFloat::fcNormal },
    { PVal5, MVal1, "1.5", APFloat::opOK, APFloat::fcNormal },
    { PVal5, PVal2, "0x0.00006p-126", APFloat::opOK, APFloat::fcNormal },
    { PVal5, MVal2, "0x0.00006p-126", APFloat::opOK, APFloat::fcNormal },
    { PVal5, PVal3, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PVal5, MVal3, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PVal5, PVal4, "1.5", APFloat::opOK, APFloat::fcNormal },
    { PVal5, MVal4, "1.5", APFloat::opOK, APFloat::fcNormal },
    { PVal5, PVal5, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PVal5, MVal5, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PVal5, PVal6, "-0.5", APFloat::opOK, APFloat::fcNormal },
    { PVal5, MVal6, "-0.5", APFloat::opOK, APFloat::fcNormal },
    { MVal5, PVal1, "-1.5", APFloat::opOK, APFloat::fcNormal },
    { MVal5, MVal1, "-1.5", APFloat::opOK, APFloat::fcNormal },
    { MVal5, PVal2, "-0x0.00006p-126", APFloat::opOK, APFloat::fcNormal },
    { MVal5, MVal2, "-0x0.00006p-126", APFloat::opOK, APFloat::fcNormal },
    { MVal5, PVal3, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MVal5, MVal3, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MVal5, PVal4, "-1.5", APFloat::opOK, APFloat::fcNormal },
    { MVal5, MVal4, "-1.5", APFloat::opOK, APFloat::fcNormal },
    { MVal5, PVal5, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MVal5, MVal5, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MVal5, PVal6, "0.5", APFloat::opOK, APFloat::fcNormal },
    { MVal5, MVal6, "0.5", APFloat::opOK, APFloat::fcNormal },
    { PVal6, PVal1, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
    { PVal6, MVal1, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
    { PVal6, PVal2, "0x0.00004p-126", APFloat::opOK, APFloat::fcNormal },
    { PVal6, MVal2, "0x0.00004p-126", APFloat::opOK, APFloat::fcNormal },
    { PVal6, PVal3, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PVal6, MVal3, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PVal6, PVal4, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
    { PVal6, MVal4, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
    { PVal6, PVal5, "-0.5", APFloat::opOK, APFloat::fcNormal },
    { PVal6, MVal5, "-0.5", APFloat::opOK, APFloat::fcNormal },
    { PVal6, PVal6, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { PVal6, MVal6, "0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MVal6, PVal1, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
    { MVal6, MVal1, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
    { MVal6, PVal2, "-0x0.00004p-126", APFloat::opOK, APFloat::fcNormal },
    { MVal6, MVal2, "-0x0.00004p-126", APFloat::opOK, APFloat::fcNormal },
    { MVal6, PVal3, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MVal6, MVal3, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MVal6, PVal4, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
    { MVal6, MVal4, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
    { MVal6, PVal5, "0.5", APFloat::opOK, APFloat::fcNormal },
    { MVal6, MVal5, "0.5", APFloat::opOK, APFloat::fcNormal },
    { MVal6, PVal6, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
    { MVal6, MVal6, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
  };

  for (size_t i = 0; i < std::size(SpecialCaseTests); ++i) {
    APFloat x(SpecialCaseTests[i].x);
    APFloat y(SpecialCaseTests[i].y);
    APFloat::opStatus status = x.remainder(y);

    APFloat result(x.getSemantics(), SpecialCaseTests[i].result);

    EXPECT_TRUE(result.bitwiseIsEqual(x));
    EXPECT_EQ(SpecialCaseTests[i].status, (int)status);
    EXPECT_EQ(SpecialCaseTests[i].category, (int)x.getCategory());
  }

  {
    APFloat f1(APFloat::IEEEdouble(), "0x1.3333333333333p-2"); // 0.3
    APFloat f2(APFloat::IEEEdouble(), "0x1.47ae147ae147bp-7"); // 0.01
    APFloat expected(APFloat::IEEEdouble(), "-0x1.4p-56");
    EXPECT_EQ(APFloat::opOK, f1.remainder(f2));
    EXPECT_TRUE(f1.bitwiseIsEqual(expected));
  }
  {
    APFloat f1(APFloat::IEEEdouble(), "0x1p64"); // 1.8446744073709552e19
    APFloat f2(APFloat::IEEEdouble(), "1.5");
    APFloat expected(APFloat::IEEEdouble(), "-0.5");
    EXPECT_EQ(APFloat::opOK, f1.remainder(f2));
    EXPECT_TRUE(f1.bitwiseIsEqual(expected));
  }
  {
    APFloat f1(APFloat::IEEEdouble(), "0x1p1000");
    APFloat f2(APFloat::IEEEdouble(), "0x1p-1000");
    APFloat expected(APFloat::IEEEdouble(), "0.0");
    EXPECT_EQ(APFloat::opOK, f1.remainder(f2));
    EXPECT_TRUE(f1.bitwiseIsEqual(expected));
  }
  {
    APFloat f1 = APFloat::getInf(APFloat::IEEEdouble(), false);
    APFloat f2(APFloat::IEEEdouble(), "1.0");
    EXPECT_EQ(f1.remainder(f2), APFloat::opInvalidOp);
    EXPECT_TRUE(f1.isNaN());
  }
  {
    APFloat f1(APFloat::IEEEdouble(), "-4.0");
    APFloat f2(APFloat::IEEEdouble(), "-2.0");
    APFloat expected(APFloat::IEEEdouble(), "-0.0");
    EXPECT_EQ(APFloat::opOK, f1.remainder(f2));
    EXPECT_TRUE(f1.bitwiseIsEqual(expected));
  }
  {
    APFloat f1(APFloat::IEEEdouble(), "-4.0");
    APFloat f2(APFloat::IEEEdouble(), "2.0");
    APFloat expected(APFloat::IEEEdouble(), "-0.0");
    EXPECT_EQ(APFloat::opOK, f1.remainder(f2));
    EXPECT_TRUE(f1.bitwiseIsEqual(expected));
  }
}

TEST(APFloatTest, PPCDoubleDoubleAddSpecial) {
  using DataType = std::tuple<uint64_t, uint64_t, uint64_t, uint64_t,
                              APFloat::fltCategory, APFloat::roundingMode>;
  DataType Data[] = {
      // (1 + 0) + (-1 + 0) = fcZero
      std::make_tuple(0x3ff0000000000000ull, 0, 0xbff0000000000000ull, 0,
                      APFloat::fcZero, APFloat::rmNearestTiesToEven),
      // LDBL_MAX + (1.1 >> (1023 - 106) + 0)) = fcInfinity
      std::make_tuple(0x7fefffffffffffffull, 0x7c8ffffffffffffeull,
                      0x7948000000000000ull, 0ull, APFloat::fcInfinity,
                      APFloat::rmNearestTiesToEven),
      // TODO: change the 4th 0x75effffffffffffe to 0x75efffffffffffff when
      // semPPCDoubleDoubleLegacy is gone.
      // LDBL_MAX + (1.011111... >> (1023 - 106) + (1.1111111...0 >> (1023 -
      // 160))) = fcNormal
      std::make_tuple(0x7fefffffffffffffull, 0x7c8ffffffffffffeull,
                      0x7947ffffffffffffull, 0x75effffffffffffeull,
                      APFloat::fcNormal, APFloat::rmNearestTiesToEven),
      // LDBL_MAX + (1.1 >> (1023 - 106) + 0)) = fcInfinity
      std::make_tuple(0x7fefffffffffffffull, 0x7c8ffffffffffffeull,
                      0x7fefffffffffffffull, 0x7c8ffffffffffffeull,
                      APFloat::fcInfinity, APFloat::rmNearestTiesToEven),
      // NaN + (1 + 0) = fcNaN
      std::make_tuple(0x7ff8000000000000ull, 0, 0x3ff0000000000000ull, 0,
                      APFloat::fcNaN, APFloat::rmNearestTiesToEven),
  };

  for (auto Tp : Data) {
    uint64_t Op1[2], Op2[2];
    APFloat::fltCategory Expected;
    APFloat::roundingMode RM;
    std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected, RM) = Tp;

    {
      APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, Op1));
      APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, Op2));
      A1.add(A2, RM);

      EXPECT_EQ(Expected, A1.getCategory())
          << formatv("({0:x} + {1:x}) + ({2:x} + {3:x})", Op1[0], Op1[1],
                     Op2[0], Op2[1])
                 .str();
    }
    {
      APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, Op1));
      APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, Op2));
      A2.add(A1, RM);

      EXPECT_EQ(Expected, A2.getCategory())
          << formatv("({0:x} + {1:x}) + ({2:x} + {3:x})", Op2[0], Op2[1],
                     Op1[0], Op1[1])
                 .str();
    }
  }
}

TEST(APFloatTest, PPCDoubleDoubleAdd) {
  using DataType = std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, uint64_t,
                              uint64_t, APFloat::roundingMode>;
  DataType Data[] = {
      // (1 + 0) + (1e-105 + 0) = (1 + 1e-105)
      std::make_tuple(0x3ff0000000000000ull, 0, 0x3960000000000000ull, 0,
                      0x3ff0000000000000ull, 0x3960000000000000ull,
                      APFloat::rmNearestTiesToEven),
      // (1 + 0) + (1e-106 + 0) = (1 + 1e-106)
      std::make_tuple(0x3ff0000000000000ull, 0, 0x3950000000000000ull, 0,
                      0x3ff0000000000000ull, 0x3950000000000000ull,
                      APFloat::rmNearestTiesToEven),
      // (1 + 1e-106) + (1e-106 + 0) = (1 + 1e-105)
      std::make_tuple(0x3ff0000000000000ull, 0x3950000000000000ull,
                      0x3950000000000000ull, 0, 0x3ff0000000000000ull,
                      0x3960000000000000ull, APFloat::rmNearestTiesToEven),
      // (1 + 0) + (epsilon + 0) = (1 + epsilon)
      std::make_tuple(0x3ff0000000000000ull, 0, 0x0000000000000001ull, 0,
                      0x3ff0000000000000ull, 0x0000000000000001ull,
                      APFloat::rmNearestTiesToEven),
      // TODO: change 0xf950000000000000 to 0xf940000000000000, when
      // semPPCDoubleDoubleLegacy is gone.
      // (DBL_MAX - 1 << (1023 - 105)) + (1 << (1023 - 53) + 0) = DBL_MAX +
      // 1.11111... << (1023 - 52)
      std::make_tuple(0x7fefffffffffffffull, 0xf950000000000000ull,
                      0x7c90000000000000ull, 0, 0x7fefffffffffffffull,
                      0x7c8ffffffffffffeull, APFloat::rmNearestTiesToEven),
      // TODO: change 0xf950000000000000 to 0xf940000000000000, when
      // semPPCDoubleDoubleLegacy is gone.
      // (1 << (1023 - 53) + 0) + (DBL_MAX - 1 << (1023 - 105)) = DBL_MAX +
      // 1.11111... << (1023 - 52)
      std::make_tuple(0x7c90000000000000ull, 0, 0x7fefffffffffffffull,
                      0xf950000000000000ull, 0x7fefffffffffffffull,
                      0x7c8ffffffffffffeull, APFloat::rmNearestTiesToEven),
  };

  for (auto Tp : Data) {
    uint64_t Op1[2], Op2[2], Expected[2];
    APFloat::roundingMode RM;
    std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected[0], Expected[1], RM) = Tp;

    {
      APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, Op1));
      APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, Op2));
      A1.add(A2, RM);

      EXPECT_EQ(Expected[0], A1.bitcastToAPInt().getRawData()[0])
          << formatv("({0:x} + {1:x}) + ({2:x} + {3:x})", Op1[0], Op1[1],
                     Op2[0], Op2[1])
                 .str();
      EXPECT_EQ(Expected[1], A1.bitcastToAPInt().getRawData()[1])
          << formatv("({0:x} + {1:x}) + ({2:x} + {3:x})", Op1[0], Op1[1],
                     Op2[0], Op2[1])
                 .str();
    }
    {
      APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, Op1));
      APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, Op2));
      A2.add(A1, RM);

      EXPECT_EQ(Expected[0], A2.bitcastToAPInt().getRawData()[0])
          << formatv("({0:x} + {1:x}) + ({2:x} + {3:x})", Op2[0], Op2[1],
                     Op1[0], Op1[1])
                 .str();
      EXPECT_EQ(Expected[1], A2.bitcastToAPInt().getRawData()[1])
          << formatv("({0:x} + {1:x}) + ({2:x} + {3:x})", Op2[0], Op2[1],
                     Op1[0], Op1[1])
                 .str();
    }
  }
}

TEST(APFloatTest, PPCDoubleDoubleSubtract) {
  using DataType = std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, uint64_t,
                              uint64_t, APFloat::roundingMode>;
  DataType Data[] = {
      // (1 + 0) - (-1e-105 + 0) = (1 + 1e-105)
      std::make_tuple(0x3ff0000000000000ull, 0, 0xb960000000000000ull, 0,
                      0x3ff0000000000000ull, 0x3960000000000000ull,
                      APFloat::rmNearestTiesToEven),
      // (1 + 0) - (-1e-106 + 0) = (1 + 1e-106)
      std::make_tuple(0x3ff0000000000000ull, 0, 0xb950000000000000ull, 0,
                      0x3ff0000000000000ull, 0x3950000000000000ull,
                      APFloat::rmNearestTiesToEven),
  };

  for (auto Tp : Data) {
    uint64_t Op1[2], Op2[2], Expected[2];
    APFloat::roundingMode RM;
    std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected[0], Expected[1], RM) = Tp;

    APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, Op1));
    APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, Op2));
    A1.subtract(A2, RM);

    EXPECT_EQ(Expected[0], A1.bitcastToAPInt().getRawData()[0])
        << formatv("({0:x} + {1:x}) - ({2:x} + {3:x})", Op1[0], Op1[1], Op2[0],
                   Op2[1])
               .str();
    EXPECT_EQ(Expected[1], A1.bitcastToAPInt().getRawData()[1])
        << formatv("({0:x} + {1:x}) - ({2:x} + {3:x})", Op1[0], Op1[1], Op2[0],
                   Op2[1])
               .str();
  }
}

TEST(APFloatTest, PPCDoubleDoubleMultiplySpecial) {
  using DataType = std::tuple<uint64_t, uint64_t, uint64_t, uint64_t,
                              APFloat::fltCategory, APFloat::roundingMode>;
  DataType Data[] = {
      // fcNaN * fcNaN = fcNaN
      std::make_tuple(0x7ff8000000000000ull, 0, 0x7ff8000000000000ull, 0,
                      APFloat::fcNaN, APFloat::rmNearestTiesToEven),
      // fcNaN * fcZero = fcNaN
      std::make_tuple(0x7ff8000000000000ull, 0, 0, 0, APFloat::fcNaN,
                      APFloat::rmNearestTiesToEven),
      // fcNaN * fcInfinity = fcNaN
      std::make_tuple(0x7ff8000000000000ull, 0, 0x7ff0000000000000ull, 0,
                      APFloat::fcNaN, APFloat::rmNearestTiesToEven),
      // fcNaN * fcNormal = fcNaN
      std::make_tuple(0x7ff8000000000000ull, 0, 0x3ff0000000000000ull, 0,
                      APFloat::fcNaN, APFloat::rmNearestTiesToEven),
      // fcInfinity * fcInfinity = fcInfinity
      std::make_tuple(0x7ff0000000000000ull, 0, 0x7ff0000000000000ull, 0,
                      APFloat::fcInfinity, APFloat::rmNearestTiesToEven),
      // fcInfinity * fcZero = fcNaN
      std::make_tuple(0x7ff0000000000000ull, 0, 0, 0, APFloat::fcNaN,
                      APFloat::rmNearestTiesToEven),
      // fcInfinity * fcNormal = fcInfinity
      std::make_tuple(0x7ff0000000000000ull, 0, 0x3ff0000000000000ull, 0,
                      APFloat::fcInfinity, APFloat::rmNearestTiesToEven),
      // fcZero * fcZero = fcZero
      std::make_tuple(0, 0, 0, 0, APFloat::fcZero,
                      APFloat::rmNearestTiesToEven),
      // fcZero * fcNormal = fcZero
      std::make_tuple(0, 0, 0x3ff0000000000000ull, 0, APFloat::fcZero,
                      APFloat::rmNearestTiesToEven),
  };

  for (auto Tp : Data) {
    uint64_t Op1[2], Op2[2];
    APFloat::fltCategory Expected;
    APFloat::roundingMode RM;
    std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected, RM) = Tp;

    {
      APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, Op1));
      APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, Op2));
      A1.multiply(A2, RM);

      EXPECT_EQ(Expected, A1.getCategory())
          << formatv("({0:x} + {1:x}) * ({2:x} + {3:x})", Op1[0], Op1[1],
                     Op2[0], Op2[1])
                 .str();
    }
    {
      APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, Op1));
      APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, Op2));
      A2.multiply(A1, RM);

      EXPECT_EQ(Expected, A2.getCategory())
          << formatv("({0:x} + {1:x}) * ({2:x} + {3:x})", Op2[0], Op2[1],
                     Op1[0], Op1[1])
                 .str();
    }
  }
}

TEST(APFloatTest, PPCDoubleDoubleMultiply) {
  using DataType = std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, uint64_t,
                              uint64_t, APFloat::roundingMode>;
  DataType Data[] = {
      // 1/3 * 3 = 1.0
      std::make_tuple(0x3fd5555555555555ull, 0x3c75555555555556ull,
                      0x4008000000000000ull, 0, 0x3ff0000000000000ull, 0,
                      APFloat::rmNearestTiesToEven),
      // (1 + epsilon) * (1 + 0) = fcZero
      std::make_tuple(0x3ff0000000000000ull, 0x0000000000000001ull,
                      0x3ff0000000000000ull, 0, 0x3ff0000000000000ull,
                      0x0000000000000001ull, APFloat::rmNearestTiesToEven),
      // (1 + epsilon) * (1 + epsilon) = 1 + 2 * epsilon
      std::make_tuple(0x3ff0000000000000ull, 0x0000000000000001ull,
                      0x3ff0000000000000ull, 0x0000000000000001ull,
                      0x3ff0000000000000ull, 0x0000000000000002ull,
                      APFloat::rmNearestTiesToEven),
      // -(1 + epsilon) * (1 + epsilon) = -1
      std::make_tuple(0xbff0000000000000ull, 0x0000000000000001ull,
                      0x3ff0000000000000ull, 0x0000000000000001ull,
                      0xbff0000000000000ull, 0, APFloat::rmNearestTiesToEven),
      // (0.5 + 0) * (1 + 2 * epsilon) = 0.5 + epsilon
      std::make_tuple(0x3fe0000000000000ull, 0, 0x3ff0000000000000ull,
                      0x0000000000000002ull, 0x3fe0000000000000ull,
                      0x0000000000000001ull, APFloat::rmNearestTiesToEven),
      // (0.5 + 0) * (1 + epsilon) = 0.5
      std::make_tuple(0x3fe0000000000000ull, 0, 0x3ff0000000000000ull,
                      0x0000000000000001ull, 0x3fe0000000000000ull, 0,
                      APFloat::rmNearestTiesToEven),
      // __LDBL_MAX__ * (1 + 1 << 106) = inf
      std::make_tuple(0x7fefffffffffffffull, 0x7c8ffffffffffffeull,
                      0x3ff0000000000000ull, 0x3950000000000000ull,
                      0x7ff0000000000000ull, 0, APFloat::rmNearestTiesToEven),
      // __LDBL_MAX__ * (1 + 1 << 107) > __LDBL_MAX__, but not inf, yes =_=|||
      std::make_tuple(0x7fefffffffffffffull, 0x7c8ffffffffffffeull,
                      0x3ff0000000000000ull, 0x3940000000000000ull,
                      0x7fefffffffffffffull, 0x7c8fffffffffffffull,
                      APFloat::rmNearestTiesToEven),
      // __LDBL_MAX__ * (1 + 1 << 108) = __LDBL_MAX__
      std::make_tuple(0x7fefffffffffffffull, 0x7c8ffffffffffffeull,
                      0x3ff0000000000000ull, 0x3930000000000000ull,
                      0x7fefffffffffffffull, 0x7c8ffffffffffffeull,
                      APFloat::rmNearestTiesToEven),
  };

  for (auto Tp : Data) {
    uint64_t Op1[2], Op2[2], Expected[2];
    APFloat::roundingMode RM;
    std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected[0], Expected[1], RM) = Tp;

    {
      APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, Op1));
      APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, Op2));
      A1.multiply(A2, RM);

      EXPECT_EQ(Expected[0], A1.bitcastToAPInt().getRawData()[0])
          << formatv("({0:x} + {1:x}) * ({2:x} + {3:x})", Op1[0], Op1[1],
                     Op2[0], Op2[1])
                 .str();
      EXPECT_EQ(Expected[1], A1.bitcastToAPInt().getRawData()[1])
          << formatv("({0:x} + {1:x}) * ({2:x} + {3:x})", Op1[0], Op1[1],
                     Op2[0], Op2[1])
                 .str();
    }
    {
      APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, Op1));
      APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, Op2));
      A2.multiply(A1, RM);

      EXPECT_EQ(Expected[0], A2.bitcastToAPInt().getRawData()[0])
          << formatv("({0:x} + {1:x}) * ({2:x} + {3:x})", Op2[0], Op2[1],
                     Op1[0], Op1[1])
                 .str();
      EXPECT_EQ(Expected[1], A2.bitcastToAPInt().getRawData()[1])
          << formatv("({0:x} + {1:x}) * ({2:x} + {3:x})", Op2[0], Op2[1],
                     Op1[0], Op1[1])
                 .str();
    }
  }
}

TEST(APFloatTest, PPCDoubleDoubleDivide) {
  using DataType = std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, uint64_t,
                              uint64_t, APFloat::roundingMode>;
  // TODO: Only a sanity check for now. Add more edge cases when the
  // double-double algorithm is implemented.
  DataType Data[] = {
      // 1 / 3 = 1/3
      std::make_tuple(0x3ff0000000000000ull, 0, 0x4008000000000000ull, 0,
                      0x3fd5555555555555ull, 0x3c75555555555556ull,
                      APFloat::rmNearestTiesToEven),
  };

  for (auto Tp : Data) {
    uint64_t Op1[2], Op2[2], Expected[2];
    APFloat::roundingMode RM;
    std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected[0], Expected[1], RM) = Tp;

    APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, Op1));
    APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, Op2));
    A1.divide(A2, RM);

    EXPECT_EQ(Expected[0], A1.bitcastToAPInt().getRawData()[0])
        << formatv("({0:x} + {1:x}) / ({2:x} + {3:x})", Op1[0], Op1[1], Op2[0],
                   Op2[1])
               .str();
    EXPECT_EQ(Expected[1], A1.bitcastToAPInt().getRawData()[1])
        << formatv("({0:x} + {1:x}) / ({2:x} + {3:x})", Op1[0], Op1[1], Op2[0],
                   Op2[1])
               .str();
  }
}

TEST(APFloatTest, PPCDoubleDoubleRemainder) {
  using DataType =
      std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, uint64_t, uint64_t>;
  DataType Data[] = {
      // remainder(3.0 + 3.0 << 53, 1.25 + 1.25 << 53) = (0.5 + 0.5 << 53)
      std::make_tuple(0x4008000000000000ull, 0x3cb8000000000000ull,
                      0x3ff4000000000000ull, 0x3ca4000000000000ull,
                      0x3fe0000000000000ull, 0x3c90000000000000ull),
      // remainder(3.0 + 3.0 << 53, 1.75 + 1.75 << 53) = (-0.5 - 0.5 << 53)
      std::make_tuple(0x4008000000000000ull, 0x3cb8000000000000ull,
                      0x3ffc000000000000ull, 0x3cac000000000000ull,
                      0xbfe0000000000000ull, 0xbc90000000000000ull),
  };

  for (auto Tp : Data) {
    uint64_t Op1[2], Op2[2], Expected[2];
    std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected[0], Expected[1]) = Tp;

    APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, Op1));
    APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, Op2));
    A1.remainder(A2);

    EXPECT_EQ(Expected[0], A1.bitcastToAPInt().getRawData()[0])
        << formatv("remainder({0:x} + {1:x}), ({2:x} + {3:x}))", Op1[0], Op1[1],
                   Op2[0], Op2[1])
               .str();
    EXPECT_EQ(Expected[1], A1.bitcastToAPInt().getRawData()[1])
        << formatv("remainder(({0:x} + {1:x}), ({2:x} + {3:x}))", Op1[0],
                   Op1[1], Op2[0], Op2[1])
               .str();
  }
}

TEST(APFloatTest, PPCDoubleDoubleMod) {
  using DataType =
      std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, uint64_t, uint64_t>;
  DataType Data[] = {
      // mod(3.0 + 3.0 << 53, 1.25 + 1.25 << 53) = (0.5 + 0.5 << 53)
      std::make_tuple(0x4008000000000000ull, 0x3cb8000000000000ull,
                      0x3ff4000000000000ull, 0x3ca4000000000000ull,
                      0x3fe0000000000000ull, 0x3c90000000000000ull),
      // mod(3.0 + 3.0 << 53, 1.75 + 1.75 << 53) = (1.25 + 1.25 << 53)
      // 0xbc98000000000000 doesn't seem right, but it's what we currently have.
      // TODO: investigate
      std::make_tuple(0x4008000000000000ull, 0x3cb8000000000000ull,
                      0x3ffc000000000000ull, 0x3cac000000000000ull,
                      0x3ff4000000000001ull, 0xbc98000000000000ull),
  };

  for (auto Tp : Data) {
    uint64_t Op1[2], Op2[2], Expected[2];
    std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected[0], Expected[1]) = Tp;

    APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, Op1));
    APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, Op2));
    A1.mod(A2);

    EXPECT_EQ(Expected[0], A1.bitcastToAPInt().getRawData()[0])
        << formatv("fmod(({0:x} + {1:x}),  ({2:x} + {3:x}))", Op1[0], Op1[1],
                   Op2[0], Op2[1])
               .str();
    EXPECT_EQ(Expected[1], A1.bitcastToAPInt().getRawData()[1])
        << formatv("fmod(({0:x} + {1:x}), ({2:x} + {3:x}))", Op1[0], Op1[1],
                   Op2[0], Op2[1])
               .str();
  }
}

TEST(APFloatTest, PPCDoubleDoubleFMA) {
  // Sanity check for now.
  APFloat A(APFloat::PPCDoubleDouble(), "2");
  A.fusedMultiplyAdd(APFloat(APFloat::PPCDoubleDouble(), "3"),
                     APFloat(APFloat::PPCDoubleDouble(), "4"),
                     APFloat::rmNearestTiesToEven);
  EXPECT_EQ(APFloat::cmpEqual,
            APFloat(APFloat::PPCDoubleDouble(), "10").compare(A));
}

struct PPCDoubleDoubleRoundToIntegralTestCase {
  DD Input;
  DD Rounded[5] = {};
  constexpr PPCDoubleDoubleRoundToIntegralTestCase &
  withRounded(DD R, APFloat::roundingMode RM) {
    Rounded[static_cast<std::underlying_type_t<APFloat::roundingMode>>(RM)] = R;
    return *this;
  }
};

auto ppcDoubleDoubleRoundToIntegralTests() {
  constexpr double Eps = std::numeric_limits<double>::epsilon();
  constexpr double HalfEps = Eps / 2.0;
  constexpr double QuarterEps = Eps / 4.0;
  constexpr double SmallestNormal = std::numeric_limits<double>::min();
  constexpr double EvenIntegerThreshold{uint64_t{1}
                                        << std::numeric_limits<double>::digits};
  constexpr double Inf = std::numeric_limits<double>::infinity();
  constexpr double QNaN = std::numeric_limits<double>::quiet_NaN();
  using TestCase = PPCDoubleDoubleRoundToIntegralTestCase;
  static constexpr auto TestCases = std::array{
      // 1. Zeros and Basic Integers
      // Input: Positive Zero (0.0, 0.0)
      TestCase({{0.0, 0.0}})
          .withRounded({0.0, 0.0}, APFloat::rmTowardZero)
          .withRounded({0.0, 0.0}, APFloat::rmTowardNegative)
          .withRounded({0.0, 0.0}, APFloat::rmTowardPositive)
          .withRounded({0.0, 0.0}, APFloat::rmNearestTiesToAway)
          .withRounded({0.0, 0.0}, APFloat::rmNearestTiesToEven),

      // Input: Negative Zero (-0.0, 0.0)
      TestCase({{-0.0, 0.0}})
          .withRounded({-0.0, 0.0}, APFloat::rmTowardZero)
          .withRounded({-0.0, 0.0}, APFloat::rmTowardNegative)
          .withRounded({-0.0, 0.0}, APFloat::rmTowardPositive)
          .withRounded({-0.0, 0.0}, APFloat::rmNearestTiesToAway)
          .withRounded({-0.0, 0.0}, APFloat::rmNearestTiesToEven),

      // Input: Positive Even (2.0, 0.0)
      TestCase({{2.0, 0.0}})
          .withRounded({2.0, 0.0}, APFloat::rmTowardZero)
          .withRounded({2.0, 0.0}, APFloat::rmTowardNegative)
          .withRounded({2.0, 0.0}, APFloat::rmTowardPositive)
          .withRounded({2.0, 0.0}, APFloat::rmNearestTiesToAway)
          .withRounded({2.0, 0.0}, APFloat::rmNearestTiesToEven),

      // Input: Positive Odd (3.0, 0.0)
      TestCase({{3.0, 0.0}})
          .withRounded({3.0, 0.0}, APFloat::rmTowardZero)
          .withRounded({3.0, 0.0}, APFloat::rmTowardNegative)
          .withRounded({3.0, 0.0}, APFloat::rmTowardPositive)
          .withRounded({3.0, 0.0}, APFloat::rmNearestTiesToAway)
          .withRounded({3.0, 0.0}, APFloat::rmNearestTiesToEven),

      // Input: Negative Even (-2.0, 0.0)
      TestCase({{-2.0, 0.0}})
          .withRounded({-2.0, 0.0}, APFloat::rmTowardZero)
          .withRounded({-2.0, 0.0}, APFloat::rmTowardNegative)
          .withRounded({-2.0, 0.0}, APFloat::rmTowardPositive)
          .withRounded({-2.0, 0.0}, APFloat::rmNearestTiesToAway)
          .withRounded({-2.0, 0.0}, APFloat::rmNearestTiesToEven),

      // 2. General Fractions (Non-Ties)
      // Input: 2.3
      TestCase({{2.3, 0.0}})
          .withRounded({2.0, 0.0}, APFloat::rmTowardZero)
          .withRounded({2.0, 0.0}, APFloat::rmTowardNegative)
          .withRounded({3.0, 0.0}, APFloat::rmTowardPositive)
          .withRounded({2.0, 0.0}, APFloat::rmNearestTiesToAway)
          .withRounded({2.0, 0.0}, APFloat::rmNearestTiesToEven),

      // Input: 2.7
      TestCase({{2.7, 0.0}})
          .withRounded({2.0, 0.0}, APFloat::rmTowardZero)
          .withRounded({2.0, 0.0}, APFloat::rmTowardNegative)
          .withRounded({3.0, 0.0}, APFloat::rmTowardPositive)
          .withRounded({3.0, 0.0}, APFloat::rmNearestTiesToAway)
          .withRounded({3.0, 0.0}, APFloat::rmNearestTiesToEven),

      // Input: -2.3
      TestCase({{-2.3, 0.0}})
          .withRounded({-2.0, 0.0}, APFloat::rmTowardZero)
          .withRounded({-3.0, 0.0}, APFloat::rmTowardNegative)
          .withRounded({-2.0, 0.0}, APFloat::rmTowardPositive)
          .withRounded({-2.0, 0.0}, APFloat::rmNearestTiesToAway)
          .withRounded({-2.0, 0.0}, APFloat::rmNearestTiesToEven),

      // Input: -2.7
      TestCase({{-2.7, 0.0}})
          .withRounded({-2.0, 0.0}, APFloat::rmTowardZero)
          .withRounded({-3.0, 0.0}, APFloat::rmTowardNegative)
          .withRounded({-2.0, 0.0}, APFloat::rmTowardPositive)
          .withRounded({-3.0, 0.0}, APFloat::rmNearestTiesToAway)
          .withRounded({-3.0, 0.0}, APFloat::rmNearestTiesToEven),

      // Input: 2.3 + Tiny
      TestCase({{2.3, SmallestNormal}})
          .withRounded({2.0, 0.0}, APFloat::rmTowardZero)
          .withRounded({2.0, 0.0}, APFloat::rmTowardNegative)
          .withRounded({3.0, 0.0}, APFloat::rmTowardPositive)
          .withRounded({2.0, 0.0}, APFloat::rmNearestTiesToAway)
          .withRounded({2.0, 0.0}, APFloat::rmNearestTiesToEven),

      // 3. Exact Midpoints (Ties at N.5)
      // Input: 0.5
      TestCase({{0.5, 0.0}})
          .withRounded({0.0, 0.0}, APFloat::rmTowardZero)
          .withRounded({0.0, 0.0}, APFloat::rmTowardNegative)
          .withRounded({1.0, 0.0}, APFloat::rmTowardPositive)
          .withRounded({1.0, 0.0}, APFloat::rmNearestTiesToAway)
          .withRounded({0.0, 0.0}, APFloat::rmNearestTiesToEven),

      // Input: 1.5 (Odd base)
      TestCase({{1.5, 0.0}})
          .withRounded({1.0, 0.0}, APFloat::rmTowardZero)
          .withRounded({1.0, 0.0}, APFloat::rmTowardNegative)
          .withRounded({2.0, 0.0}, APFloat::rmTowardPositive)
          .withRounded({2.0, 0.0}, APFloat::rmNearestTiesToAway)
          .withRounded({2.0, 0.0}, APFloat::rmNearestTiesToEven),

      // Input: 2.5 (Even base)
      TestCase({{2.5, 0.0}})
          .withRounded({2.0, 0.0}, APFloat::rmTowardZero)
          .withRounded({2.0, 0.0}, APFloat::rmTowardNegative)
          .withRounded({3.0, 0.0}, APFloat::rmTowardPositive)
          .withRounded({3.0, 0.0}, APFloat::rmNearestTiesToAway)
          .withRounded({2.0, 0.0}, APFloat::rmNearestTiesToEven),

      // Input: -0.5
      TestCase({{-0.5, 0.0}})
          .withRounded({-0.0, 0.0}, APFloat::rmTowardZero)
          .withRounded({-1.0, 0.0}, APFloat::rmTowardNegative)
          .withRounded({-0.0, 0.0}, APFloat::rmTowardPositive)
          .withRounded({-1.0, 0.0}, APFloat::rmNearestTiesToAway)
          .withRounded({-0.0, 0.0}, APFloat::rmNearestTiesToEven),

      // Input: -1.5 (Odd base)
      TestCase({{-1.5, 0.0}})
          .withRounded({-1.0, 0.0}, APFloat::rmTowardZero)
          .withRounded({-2.0, 0.0}, APFloat::rmTowardNegative)
          .withRounded({-1.0, 0.0}, APFloat::rmTowardPositive)
          .withRounded({-2.0, 0.0}, APFloat::rmNearestTiesToAway)
          .withRounded({-2.0, 0.0}, APFloat::rmNearestTiesToEven),

      // Input: -2.5 (Even base)
      TestCase({{-2.5, 0.0}})
          .withRounded({-2.0, 0.0}, APFloat::rmTowardZero)
          .withRounded({-3.0, 0.0}, APFloat::rmTowardNegative)
          .withRounded({-2.0, 0.0}, APFloat::rmTowardPositive)
          .withRounded({-3.0, 0.0}, APFloat::rmNearestTiesToAway)
          .withRounded({-2.0, 0.0}, APFloat::rmNearestTiesToEven),

      // 4. Near Midpoints (lo breaks the tie)
      // Input: Slightly > 2.5
      TestCase({{2.5, SmallestNormal}})
          .withRounded({2.0, 0.0}, APFloat::rmTowardZero)
          .withRounded({2.0, 0.0}, APFloat::rmTowardNegative)
          .withRounded({3.0, 0.0}, APFloat::rmTowardPositive)
          .withRounded({3.0, 0.0}, APFloat::rmNearestTiesToAway)
          .withRounded({3.0, 0.0}, APFloat::rmNearestTiesToEven),

      // Input: Slightly < 2.5
      TestCase({{2.5, -SmallestNormal}})
          .withRounded({2.0, 0.0}, APFloat::rmTowardZero)
          .withRounded({2.0, 0.0}, APFloat::rmTowardNegative)
          .withRounded({3.0, 0.0}, APFloat::rmTowardPositive)
          .withRounded({2.0, 0.0}, APFloat::rmNearestTiesToAway)
          .withRounded({2.0, 0.0}, APFloat::rmNearestTiesToEven),

      // Input: Slightly > 1.5
      TestCase({{1.5, SmallestNormal}})
          .withRounded({1.0, 0.0}, APFloat::rmTowardZero)
          .withRounded({1.0, 0.0}, APFloat::rmTowardNegative)
          .withRounded({2.0, 0.0}, APFloat::rmTowardPositive)
          .withRounded({2.0, 0.0}, APFloat::rmNearestTiesToAway)
          .withRounded({2.0, 0.0}, APFloat::rmNearestTiesToEven),

      // Input: Slightly < 1.5
      TestCase({{1.5, -SmallestNormal}})
          .withRounded({1.0, 0.0}, APFloat::rmTowardZero)
          .withRounded({1.0, 0.0}, APFloat::rmTowardNegative)
          .withRounded({2.0, 0.0}, APFloat::rmTowardPositive)
          .withRounded({1.0, 0.0}, APFloat::rmNearestTiesToAway)
          .withRounded({1.0, 0.0}, APFloat::rmNearestTiesToEven),

      // Input: Slightly > -2.5 (closer to 0)
      TestCase({{-2.5, SmallestNormal}})
          .withRounded({-2.0, 0.0}, APFloat::rmTowardZero)
          .withRounded({-3.0, 0.0}, APFloat::rmTowardNegative)
          .withRounded({-2.0, 0.0}, APFloat::rmTowardPositive)
          .withRounded({-2.0, 0.0}, APFloat::rmNearestTiesToAway)
          .withRounded({-2.0, 0.0}, APFloat::rmNearestTiesToEven),

      // Input: Slightly < -2.5 (further from 0)
      TestCase({{-2.5, -SmallestNormal}})
          .withRounded({-2.0, 0.0}, APFloat::rmTowardZero)
          .withRounded({-3.0, 0.0}, APFloat::rmTowardNegative)
          .withRounded({-2.0, 0.0}, APFloat::rmTowardPositive)
          .withRounded({-3.0, 0.0}, APFloat::rmNearestTiesToAway)
          .withRounded({-3.0, 0.0}, APFloat::rmNearestTiesToEven),

      // 5. Near Integers (lo crosses the integer boundary)
      // Input: Slightly > 2.0
      TestCase({{2.0, SmallestNormal}})
          .withRounded({2.0, 0.0}, APFloat::rmTowardZero)
          .withRounded({2.0, 0.0}, APFloat::rmTowardNegative)
          .withRounded({3.0, 0.0}, APFloat::rmTowardPositive)
          .withRounded({2.0, 0.0}, APFloat::rmNearestTiesToAway)
          .withRounded({2.0, 0.0}, APFloat::rmNearestTiesToEven),

      // Input: Slightly < 2.0 (1.99...)
      TestCase({{2.0, -SmallestNormal}})
          .withRounded({1.0, 0.0}, APFloat::rmTowardZero)
          .withRounded({1.0, 0.0}, APFloat::rmTowardNegative)
          .withRounded({2.0, 0.0}, APFloat::rmTowardPositive)
          .withRounded({2.0, 0.0}, APFloat::rmNearestTiesToAway)
          .withRounded({2.0, 0.0}, APFloat::rmNearestTiesToEven),

      // Input: Slightly > -2.0 (-1.99...)
      TestCase({{-2.0, SmallestNormal}})
          .withRounded({-1.0, 0.0}, APFloat::rmTowardZero)
          .withRounded({-2.0, 0.0}, APFloat::rmTowardNegative)
          .withRounded({-1.0, 0.0}, APFloat::rmTowardPositive)
          .withRounded({-2.0, 0.0}, APFloat::rmNearestTiesToAway)
          .withRounded({-2.0, 0.0}, APFloat::rmNearestTiesToEven),

      // Input: Slightly < -2.0
      TestCase({{-2.0, -SmallestNormal}})
          .withRounded({-2.0, 0.0}, APFloat::rmTowardZero)
          .withRounded({-3.0, 0.0}, APFloat::rmTowardNegative)
          .withRounded({-2.0, 0.0}, APFloat::rmTowardPositive)
          .withRounded({-2.0, 0.0}, APFloat::rmNearestTiesToAway)
          .withRounded({-2.0, 0.0}, APFloat::rmNearestTiesToEven),

      // Input: Slightly > 0.0
      TestCase({{SmallestNormal, 0.0}})
          .withRounded({0.0, 0.0}, APFloat::rmTowardZero)
          .withRounded({0.0, 0.0}, APFloat::rmTowardNegative)
          .withRounded({1.0, 0.0}, APFloat::rmTowardPositive)
          .withRounded({0.0, 0.0}, APFloat::rmNearestTiesToAway)
          .withRounded({0.0, 0.0}, APFloat::rmNearestTiesToEven),

      // Input: Slightly < 0.0
      TestCase({{-SmallestNormal, 0.0}})
          .withRounded({-0.0, 0.0}, APFloat::rmTowardZero)
          .withRounded({-1.0, 0.0}, APFloat::rmTowardNegative)
          .withRounded({-0.0, 0.0}, APFloat::rmTowardPositive)
          .withRounded({-0.0, 0.0}, APFloat::rmNearestTiesToAway)
          .withRounded({-0.0, 0.0}, APFloat::rmNearestTiesToEven),

      // 6. Boundary of Canonicalization (Maximum lo)
      // Input: 1.0 + Max lo (1 + 2^-53)
      TestCase({{1.0, HalfEps}})
          .withRounded({1.0, 0.0}, APFloat::rmTowardZero)
          .withRounded({1.0, 0.0}, APFloat::rmTowardNegative)
          .withRounded({2.0, 0.0}, APFloat::rmTowardPositive)
          .withRounded({1.0, 0.0}, APFloat::rmNearestTiesToAway)
          .withRounded({1.0, 0.0}, APFloat::rmNearestTiesToEven),

      // Input: 1.0 - Max lo (1 - 2^-54)
      TestCase({{1.0, -QuarterEps}})
          .withRounded({0.0, 0.0}, APFloat::rmTowardZero)
          .withRounded({0.0, 0.0}, APFloat::rmTowardNegative)
          .withRounded({1.0, 0.0}, APFloat::rmTowardPositive)
          .withRounded({1.0, 0.0}, APFloat::rmNearestTiesToAway)
          .withRounded({1.0, 0.0}, APFloat::rmNearestTiesToEven),

      // 7. Large Magnitudes (Beyond 2^53). N = EvenIntegerThreshold (Even)
      // Input: EvenIntegerThreshold (Exact)
      TestCase({{EvenIntegerThreshold, 0.0}})
          .withRounded({EvenIntegerThreshold, 0.0}, APFloat::rmTowardZero)
          .withRounded({EvenIntegerThreshold, 0.0}, APFloat::rmTowardNegative)
          .withRounded({EvenIntegerThreshold, 0.0}, APFloat::rmTowardPositive)
          .withRounded({EvenIntegerThreshold, 0.0},
                       APFloat::rmNearestTiesToAway)
          .withRounded({EvenIntegerThreshold, 0.0},
                       APFloat::rmNearestTiesToEven),

      // Input: EvenIntegerThreshold+1 (Exact)
      TestCase({{EvenIntegerThreshold, 1.0}})
          .withRounded({EvenIntegerThreshold, 1.0}, APFloat::rmTowardZero)
          .withRounded({EvenIntegerThreshold, 1.0}, APFloat::rmTowardNegative)
          .withRounded({EvenIntegerThreshold, 1.0}, APFloat::rmTowardPositive)
          .withRounded({EvenIntegerThreshold, 1.0},
                       APFloat::rmNearestTiesToAway)
          .withRounded({EvenIntegerThreshold, 1.0},
                       APFloat::rmNearestTiesToEven),

      // Fractions
      // Input: EvenIntegerThreshold+0.25
      TestCase({{EvenIntegerThreshold, 0.25}})
          .withRounded({EvenIntegerThreshold, 0.0}, APFloat::rmTowardZero)
          .withRounded({EvenIntegerThreshold, 0.0}, APFloat::rmTowardNegative)
          .withRounded({EvenIntegerThreshold, 1.0}, APFloat::rmTowardPositive)
          .withRounded({EvenIntegerThreshold, 0.0},
                       APFloat::rmNearestTiesToAway)
          .withRounded({EvenIntegerThreshold, 0.0},
                       APFloat::rmNearestTiesToEven),

      // Input: EvenIntegerThreshold+0.75
      TestCase({{EvenIntegerThreshold, 0.75}})
          .withRounded({EvenIntegerThreshold, 0.0}, APFloat::rmTowardZero)
          .withRounded({EvenIntegerThreshold, 0.0}, APFloat::rmTowardNegative)
          .withRounded({EvenIntegerThreshold, 1.0}, APFloat::rmTowardPositive)
          .withRounded({EvenIntegerThreshold, 1.0},
                       APFloat::rmNearestTiesToAway)
          .withRounded({EvenIntegerThreshold, 1.0},
                       APFloat::rmNearestTiesToEven),

      // Ties (Midpoints)
      // Input: EvenIntegerThreshold-0.5
      TestCase({{EvenIntegerThreshold, -0.5}})
          .withRounded({EvenIntegerThreshold - 1.0, 0.0}, APFloat::rmTowardZero)
          .withRounded({EvenIntegerThreshold - 1.0, 0.0},
                       APFloat::rmTowardNegative)
          .withRounded({EvenIntegerThreshold, 0.0}, APFloat::rmTowardPositive)
          .withRounded({EvenIntegerThreshold, 0.0},
                       APFloat::rmNearestTiesToAway)
          .withRounded({EvenIntegerThreshold, 0.0},
                       APFloat::rmNearestTiesToEven),

      // Input: EvenIntegerThreshold+0.5
      TestCase({{EvenIntegerThreshold, 0.5}})
          .withRounded({EvenIntegerThreshold, 0.0}, APFloat::rmTowardZero)
          .withRounded({EvenIntegerThreshold, 0.0}, APFloat::rmTowardNegative)
          .withRounded({EvenIntegerThreshold, 1.0}, APFloat::rmTowardPositive)
          .withRounded({EvenIntegerThreshold, 1.0},
                       APFloat::rmNearestTiesToAway)
          .withRounded({EvenIntegerThreshold, 0.0},
                       APFloat::rmNearestTiesToEven),

      // Input: EvenIntegerThreshold+1.5
      TestCase({{EvenIntegerThreshold + 2.0, -0.5}})
          .withRounded({EvenIntegerThreshold, 1.0}, APFloat::rmTowardZero)
          .withRounded({EvenIntegerThreshold, 1.0}, APFloat::rmTowardNegative)
          .withRounded({EvenIntegerThreshold + 2.0, 0.0},
                       APFloat::rmTowardPositive)
          .withRounded({EvenIntegerThreshold + 2.0, 0.0},
                       APFloat::rmNearestTiesToAway)
          .withRounded({EvenIntegerThreshold + 2.0, 0.0},
                       APFloat::rmNearestTiesToEven),

      // Input: EvenIntegerThreshold+2.5
      TestCase({{EvenIntegerThreshold + 2.0, 0.5}})
          .withRounded({EvenIntegerThreshold + 2.0, 0.0}, APFloat::rmTowardZero)
          .withRounded({EvenIntegerThreshold + 2.0, 0.0},
                       APFloat::rmTowardNegative)
          .withRounded({EvenIntegerThreshold + 4.0, -1.0},
                       APFloat::rmTowardPositive)
          .withRounded({EvenIntegerThreshold + 4.0, -1.0},
                       APFloat::rmNearestTiesToAway)
          .withRounded({EvenIntegerThreshold + 2.0, 0.0},
                       APFloat::rmNearestTiesToEven),

      // Near Ties
      // Input: EvenIntegerThreshold+0.5+HalfEps
      TestCase({{EvenIntegerThreshold, 0.5 + HalfEps}})
          .withRounded({EvenIntegerThreshold, 0.0}, APFloat::rmTowardZero)
          .withRounded({EvenIntegerThreshold, 0.0}, APFloat::rmTowardNegative)
          .withRounded({EvenIntegerThreshold, 1.0}, APFloat::rmTowardPositive)
          .withRounded({EvenIntegerThreshold, 1.0},
                       APFloat::rmNearestTiesToAway)
          .withRounded({EvenIntegerThreshold, 1.0},
                       APFloat::rmNearestTiesToEven),

      // Input: EvenIntegerThreshold+0.5-QuarterEps
      TestCase({{EvenIntegerThreshold, 0.5 - QuarterEps}})
          .withRounded({EvenIntegerThreshold, 0.0}, APFloat::rmTowardZero)
          .withRounded({EvenIntegerThreshold, 0.0}, APFloat::rmTowardNegative)
          .withRounded({EvenIntegerThreshold, 1.0}, APFloat::rmTowardPositive)
          .withRounded({EvenIntegerThreshold, 0.0},
                       APFloat::rmNearestTiesToAway)
          .withRounded({EvenIntegerThreshold, 0.0},
                       APFloat::rmNearestTiesToEven),

      // Canonical Boundary (Max lo for EvenIntegerThreshold is 1.0)
      // Input: EvenIntegerThreshold+1.0
      TestCase({{EvenIntegerThreshold, 1.0}})
          .withRounded({EvenIntegerThreshold, 1.0}, APFloat::rmTowardZero)
          .withRounded({EvenIntegerThreshold, 1.0}, APFloat::rmTowardNegative)
          .withRounded({EvenIntegerThreshold, 1.0}, APFloat::rmTowardPositive)
          .withRounded({EvenIntegerThreshold, 1.0},
                       APFloat::rmNearestTiesToAway)
          .withRounded({EvenIntegerThreshold, 1.0},
                       APFloat::rmNearestTiesToEven),

      // 8. Special Values
      // Input: +Inf
      TestCase({{Inf, 0.0}})
          .withRounded({Inf, 0.0}, APFloat::rmTowardZero)
          .withRounded({Inf, 0.0}, APFloat::rmTowardNegative)
          .withRounded({Inf, 0.0}, APFloat::rmTowardPositive)
          .withRounded({Inf, 0.0}, APFloat::rmNearestTiesToAway)
          .withRounded({Inf, 0.0}, APFloat::rmNearestTiesToEven),

      // Input: -Inf
      TestCase({{-Inf, 0.0}})
          .withRounded({-Inf, 0.0}, APFloat::rmTowardZero)
          .withRounded({-Inf, 0.0}, APFloat::rmTowardNegative)
          .withRounded({-Inf, 0.0}, APFloat::rmTowardPositive)
          .withRounded({-Inf, 0.0}, APFloat::rmNearestTiesToAway)
          .withRounded({-Inf, 0.0}, APFloat::rmNearestTiesToEven),

      // Input: NaN input hi. Expected output canonical (NaN, 0.0).
      TestCase({{QNaN, 0.0}})
          .withRounded({QNaN, 0.0}, APFloat::rmTowardZero)
          .withRounded({QNaN, 0.0}, APFloat::rmTowardNegative)
          .withRounded({QNaN, 0.0}, APFloat::rmTowardPositive)
          .withRounded({QNaN, 0.0}, APFloat::rmNearestTiesToAway)
          .withRounded({QNaN, 0.0}, APFloat::rmNearestTiesToEven),
  };
  return TestCases;
}

class PPCDoubleDoubleRoundToIntegralValueTest
    : public testing::Test,
      public ::testing::WithParamInterface<
          PPCDoubleDoubleRoundToIntegralTestCase> {};

INSTANTIATE_TEST_SUITE_P(
    PPCDoubleDoubleRoundToIntegralValueParamTests,
    PPCDoubleDoubleRoundToIntegralValueTest,
    ::testing::ValuesIn(ppcDoubleDoubleRoundToIntegralTests()));

TEST_P(PPCDoubleDoubleRoundToIntegralValueTest,
       PPCDoubleDoubleRoundToIntegral) {
  const PPCDoubleDoubleRoundToIntegralTestCase TestCase = GetParam();
  const APFloat Input = makeDoubleAPFloat(TestCase.Input);
  EXPECT_FALSE(Input.isDenormal())
      << TestCase.Input.Hi << " + " << TestCase.Input.Lo;
  for (size_t I = 0, E = std::size(TestCase.Rounded); I != E; ++I) {
    const auto RM = static_cast<APFloat::roundingMode>(I);
    const APFloat Expected = makeDoubleAPFloat(TestCase.Rounded[I]);
    EXPECT_FALSE(Expected.isDenormal())
        << TestCase.Rounded[I].Hi << " + " << TestCase.Input.Lo;
    APFloat Actual = Input;
    Actual.roundToIntegral(RM);
    if (Actual.isNaN())
      EXPECT_TRUE(Actual.isNaN());
    else
      EXPECT_EQ(Actual.compare(Expected), APFloat::cmpEqual)
          << "RM: " << RM << " Input.Hi: " << TestCase.Input.Hi
          << " Input.Lo: " << TestCase.Input.Lo << " Actual: " << Actual
          << " Expected.Hi: " << TestCase.Rounded[I].Hi
          << " Expected.Lo: " << TestCase.Rounded[I].Lo
          << " Expected: " << Expected;
  }
}

namespace PPCDoubleDoubleConvertToIntegerTestDetails {
// Define the rounding modes for easier readability.
static constexpr auto RNE = APFloat::rmNearestTiesToEven;
static constexpr auto RNA = APFloat::rmNearestTiesToAway;
static constexpr auto RTZ = APFloat::rmTowardZero;
static constexpr auto RUP = APFloat::rmTowardPositive;
static constexpr auto RDN = APFloat::rmTowardNegative;

struct TestCase {
  // Structure to hold the expected result of a conversion
  struct ExpectedConversion {
    // The expected integer value represented as a string (decimal).
    // We use a string to easily represent arbitrary precision values in
    // constexpr. The test runner should parse this into an APSInt matching the
    // test configuration.
    const char *ExpectedIntStr;
    APFloat::opStatus Status;
  };

  DD Input;
  unsigned IntegerWidth;
  bool IsSigned;
  // Array indexed by the rounding mode enum value.
  std::array<ExpectedConversion, 5> Rounded = {};

  // Helper to define the expected results for a specific rounding mode.
  constexpr TestCase &with(APFloat::roundingMode RM, const char *ExpectedStr,
                           APFloat::opStatus Status) {
    Rounded[static_cast<std::underlying_type_t<APFloat::roundingMode>>(RM)] = {
        ExpectedStr,
        Status,
    };
    return *this;
  }

  // Helper to define the same result for all rounding modes.
  constexpr TestCase &withAll(const char *ExpectedStr,
                              APFloat::opStatus Status) {
    return with(RNE, ExpectedStr, Status)
        .with(RNA, ExpectedStr, Status)
        .with(RTZ, ExpectedStr, Status)
        .with(RUP, ExpectedStr, Status)
        .with(RDN, ExpectedStr, Status);
  }
};

auto testCases() {
  // Define the status codes.
  constexpr auto OK = llvm::APFloat::opOK;
  constexpr auto Inexact = llvm::APFloat::opInexact;
  // The API specifies opInvalidOp for out-of-range (overflow/underflow) and
  // NaN.
  constexpr auto Invalid = llvm::APFloat::opInvalidOp;

  // Helper constants for constructing specific DD values.
  constexpr double Infinity = std::numeric_limits<double>::infinity();
  constexpr double NaN = std::numeric_limits<double>::quiet_NaN();
  constexpr double DMAX = std::numeric_limits<double>::max();

  // Powers of 2
  constexpr double P53 = 0x1p53;
  constexpr double P63 = 0x1p63;
  constexpr double P64 = 0x1p64;
  // 2^-100 (A very small delta demonstrating extended precision)
  constexpr double PM100 = 0x1p-100;

  static constexpr auto ConvertToIntegerTestCases = std::array{
      // 1. Zeros, NaNs, and Infinities (Target: 64-bit Signed)
      // INT64_MAX = 9223372036854775807
      // INT64_MIN = -9223372036854775808

      // Input: Positive Zero (0.0, 0.0)
      TestCase{{0.0, 0.0}, 64, true}.withAll("0", OK),

      // Input: Negative Zero (-0.0, 0.0)
      TestCase{{-0.0, 0.0}, 64, true}.withAll("0", OK),

      // Input: NaN. Expected behavior: Invalid, deterministic result of 0.
      TestCase{{NaN, 0.0}, 64, true}.withAll("0", Invalid),

      // Input: +Infinity. Expected behavior: Invalid, deterministic result of
      // INT64_MAX.
      TestCase{{Infinity, 0.0}, 64, true}.withAll("9223372036854775807",
                                                  Invalid),

      // Input: -Infinity. Expected behavior: Invalid, deterministic result of
      // INT64_MIN.
      TestCase{{-Infinity, 0.0}, 64, true}.withAll("-9223372036854775808",
                                                   Invalid),

      // 2. Basic Rounding and Tie-Breaking (Target: 32-bit Signed)

      // Input: 2.5 (Tie, preceding integer is Even)
      TestCase{{2.5, 0.0}, 32, true}
          .with(RTZ, "2", Inexact)
          .with(RDN, "2", Inexact)
          .with(RUP, "3", Inexact)
          .with(RNA, "3", Inexact)
          .with(RNE, "2", Inexact),

      // Input: 3.5 (Tie, preceding integer is Odd)
      TestCase{{3.5, 0.0}, 32, true}
          .with(RTZ, "3", Inexact)
          .with(RDN, "3", Inexact)
          .with(RUP, "4", Inexact)
          .with(RNA, "4", Inexact)
          .with(RNE, "4", Inexact),

      // Input: -2.5 (Tie, preceding integer is Even)
      TestCase{{-2.5, 0.0}, 32, true}
          .with(RTZ, "-2", Inexact)
          .with(RDN, "-3", Inexact)
          .with(RUP, "-2", Inexact)
          .with(RNA, "-3", Inexact)
          .with(RNE, "-2", Inexact),

      // 3. Double-Double Precision (The role of 'lo')
      // Testing how extended precision affects rounding decisions.

      // Input: 2.5 + Epsilon (Slightly above tie)
      TestCase{{2.5, PM100}, 32, true}
          .with(RTZ, "2", Inexact)
          .with(RDN, "2", Inexact)
          .with(RUP, "3", Inexact)
          .with(RNA, "3", Inexact)
          .with(RNE, "3", Inexact),

      // Input: 2.5 - Epsilon (Slightly below tie)
      TestCase{{2.5, -PM100}, 32, true}
          .with(RTZ, "2", Inexact)
          .with(RDN, "2", Inexact)
          .with(RUP, "3", Inexact)
          .with(RNA, "2", Inexact)
          .with(RNE, "2", Inexact),

      // Input: 1.0 + Epsilon (Just above 1.0, e.g., 1.00...1)
      TestCase{{1.0, PM100}, 32, true}
          .with(RTZ, "1", Inexact)
          .with(RDN, "1", Inexact)
          .with(RUP, "2", Inexact)
          .with(RNA, "1", Inexact)
          .with(RNE, "1", Inexact),

      // Input: 1.0 - Epsilon (Just below 1.0, e.g. 0.999...)
      TestCase{{1.0, -PM100}, 32, true}
          .with(RTZ, "0", Inexact)
          .with(RDN, "0", Inexact)
          .with(RUP, "1", Inexact)
          .with(RNA, "1", Inexact)
          .with(RNE, "1", Inexact),

      // Input: Large number tie-breaking (Crucial test for DD implementation)
      // Input: 2^53 + 1.5.
      // A standard double(2^53 + 1.5) rounds to 2^53 + 2.0.
      // The DD representation must precisely hold 2^53 + 1.5.
      // The canonical DD representation is {2^53 + 2.0, -0.5}.
      // Value is 9007199254740993.5
      TestCase{{P53 + 2.0, -0.5}, 64, true}
          .with(RTZ, "9007199254740993", Inexact)
          .with(RDN, "9007199254740993", Inexact)
          .with(RUP, "9007199254740994", Inexact)
          .with(RNA, "9007199254740994", Inexact)
          .with(RNE, "9007199254740994", Inexact),

      // 4. Overflow Boundaries (Signed)

      // Input: Exactly INT64_MAX. (2^63 - 1)
      // Represented precisely as (2^63, -1.0)
      TestCase{{P63, -1.0}, 64, true}.withAll("9223372036854775807", OK),

      // Input: INT64_MAX + 0.3.
      // Represented as (2^63, -0.7)
      TestCase{{P63, -0.7}, 64, true}
          .with(RTZ, "9223372036854775807", Inexact)
          .with(RDN, "9223372036854775807", Inexact)
          .with(RNA, "9223372036854775807", Inexact)
          .with(RNE, "9223372036854775807", Inexact)
          .with(RUP, "9223372036854775807", Invalid),

      // Input: INT64_MAX + 0.5 (Tie at the boundary)
      // Represented as (2^63, -0.5). Target integers are MAX (odd) and 2^63
      // (even).
      TestCase{{P63, -0.5}, 64, true}
          .with(RTZ, "9223372036854775807", Inexact)
          .with(RDN, "9223372036854775807", Inexact)
          .with(RUP, "9223372036854775807", Invalid)
          .with(RNA, "9223372036854775807", Invalid)
          .with(RNE, "9223372036854775807", Invalid),

      // Input: 2^55 - 2^1 - 2^-52 to signed integer.
      // Represented as (2^55 - 2^2, 2^1 - 2^-1).
      TestCase{{0x1.fffffffffffffp+54, 0x1.8p0}, 56, true}
          .with(RTZ, "36028797018963965", Inexact)
          .with(RDN, "36028797018963965", Inexact)
          .with(RUP, "36028797018963966", Inexact)
          .with(RNA, "36028797018963966", Inexact)
          .with(RNE, "36028797018963966", Inexact),

      // Input: 2^55 - 2^1 - 2^-52 to signed integer.
      // Represented as (2^55 - 2^2, 2^1 - 2^-52).
      TestCase{{0x1.fffffffffffffp+54, 0x1.fffffffffffffp0}, 56, true}
          .with(RTZ, "36028797018963965", Inexact)
          .with(RDN, "36028797018963965", Inexact)
          .with(RUP, "36028797018963966", Inexact)
          .with(RNA, "36028797018963966", Inexact)
          .with(RNE, "36028797018963966", Inexact),

      // Input: Exactly 2^63 (One past INT64_MAX)
      TestCase{{P63, 0.0}, 64, true}.withAll("9223372036854775807", Invalid),

      // Input: Exactly INT64_MIN (-2^63)
      TestCase{{-P63, 0.0}, 64, true}.withAll("-9223372036854775808", OK),

      // Input: INT64_MIN - 0.5 (Tie at the lower boundary)
      // Target integers are -2^63-1 (odd) and MIN (even).
      TestCase{{-P63, -0.5}, 64, true}
          .with(RTZ, "-9223372036854775808", Inexact)
          .with(RUP, "-9223372036854775808", Inexact)
          // RDN rounds down, causing overflow.
          .with(RDN, "-9223372036854775808", Invalid)
          // RNA rounds away (down), causing overflow.
          .with(RNA, "-9223372036854775808", Invalid)
          // RNE rounds to even (up to -2^63), which is OK.
          .with(RNE, "-9223372036854775808", Inexact),

      // 5. Overflow Boundaries (Unsigned)
      // UINT64_MAX = 18446744073709551615 (2^64 - 1)

      // Input: Exactly UINT64_MAX. (2^64 - 1)
      // Represented precisely as (2^64, -1.0)
      TestCase{{P64, -1.0}, 64, false}.withAll("18446744073709551615", OK),

      // Input: UINT64_MAX + 0.5 (Tie at the boundary)
      // Represented as (2^64, -0.5)
      TestCase{{P64, -0.5}, 64, false}
          .with(RTZ, "18446744073709551615", Inexact)
          .with(RDN, "18446744073709551615", Inexact)
          // RUP rounds up (2^64), causing overflow.
          .with(RUP, "18446744073709551615", Invalid)
          // RNA rounds away (up), causing overflow.
          .with(RNA, "18446744073709551615", Invalid)
          // RNE rounds to even (up to 2^64), causing overflow.
          .with(RNE, "18446744073709551615", Invalid),

      // Input: 2^55 - 2^1 - 2^-52 to unsigned integer.
      // Represented as (2^55 - 2^2, 2^1 - 2^-1).
      TestCase{{0x1.fffffffffffffp+54, 0x1.8p0}, 55, false}
          .with(RTZ, "36028797018963965", Inexact)
          .with(RDN, "36028797018963965", Inexact)
          .with(RUP, "36028797018963966", Inexact)
          .with(RNA, "36028797018963966", Inexact)
          .with(RNE, "36028797018963966", Inexact),

      // Input: 2^55 - 2^1 - 2^-52 to unsigned integer.
      // Represented as (2^55 - 2^2, 2^1 - 2^-52).
      TestCase{{0x1.fffffffffffffp+54, 0x1.fffffffffffffp0}, 55, false}
          .with(RTZ, "36028797018963965", Inexact)
          .with(RDN, "36028797018963965", Inexact)
          .with(RUP, "36028797018963966", Inexact)
          .with(RNA, "36028797018963966", Inexact)
          .with(RNE, "36028797018963966", Inexact),

      // Input: -0.3 (Slightly below zero)
      TestCase{{-0.3, 0.0}, 64, false}
          .with(RTZ, "0", Inexact)
          .with(RUP, "0", Inexact)
          .with(RNA, "0", Inexact)
          .with(RNE, "0", Inexact)
          .with(RDN, "0", Invalid),

      // Input: -0.5 (Tie at zero)
      TestCase{{-0.5, 0.0}, 64, false}
          .with(RTZ, "0", Inexact)
          .with(RUP, "0", Inexact)
          // RNE rounds to even (0).
          .with(RNE, "0", Inexact)
          .with(RDN, "0", Invalid)
          // RNA rounds away (-1), causing overflow.
          .with(RNA, "0", Invalid),

      // Input: -1.0 (Negative integer)
      TestCase{{-1.0, 0.0}, 64, false}.withAll("0", Invalid),

      // 6. High Precision Integers (Target: 128-bit Signed)
      // INT128_MAX = 170141183460469231731687303715884105727

      // Input: 2^100 (Exactly representable in DD)
      // 2^100 = 1267650600228229401496703205376.0
      TestCase{{1267650600228229401496703205376.0, 0.0}, 128, true}.withAll(
          "1267650600228229401496703205376", OK),

      // Input: DMAX. (Approx 1.8e308).
      // This is vastly larger than INT128_MAX (Approx 1.7e38).
      TestCase{{DMAX, 0.0}, 128, true}.withAll(
          "170141183460469231731687303715884105727", Invalid),

      // Input: Largest semPPCDoubleDoubleLegacy
      TestCase{{DMAX, 0x1.ffffffffffffep+969}, 128, true}.withAll(
          "170141183460469231731687303715884105727", Invalid),

      // 7. Round to negative -0
      TestCase{{-PM100, 0.0}, 32, true}
          .with(RTZ, "0", Inexact)
          .with(RUP, "0", Inexact)
          .with(RNA, "0", Inexact)
          .with(RNE, "0", Inexact)
          .with(RDN, "-1", Inexact),
  };
  return ConvertToIntegerTestCases;
}
} // namespace PPCDoubleDoubleConvertToIntegerTestDetails

class PPCDoubleDoubleConvertToIntegerValueTest
    : public testing::Test,
      public ::testing::WithParamInterface<
          PPCDoubleDoubleConvertToIntegerTestDetails::TestCase> {};

INSTANTIATE_TEST_SUITE_P(
    PPCDoubleDoubleConvertToIntegerValueParamTests,
    PPCDoubleDoubleConvertToIntegerValueTest,
    ::testing::ValuesIn(
        PPCDoubleDoubleConvertToIntegerTestDetails::testCases()));

TEST_P(PPCDoubleDoubleConvertToIntegerValueTest,
       PPCDoubleDoubleConvertToInteger) {
  const PPCDoubleDoubleConvertToIntegerTestDetails::TestCase Params =
      GetParam();
  const APFloat Input = makeDoubleAPFloat(Params.Input);
  EXPECT_FALSE(Input.isDenormal())
      << Params.Input.Hi << " + " << Params.Input.Lo;

  for (size_t I = 0, E = std::size(Params.Rounded); I != E; ++I) {
    const auto RM = static_cast<APFloat::roundingMode>(I);
    const auto &Expected = Params.Rounded[I];
    APSInt ActualInteger(Params.IntegerWidth, /*isUnsigned=*/!Params.IsSigned);

    APSInt ExpectedInteger{Expected.ExpectedIntStr};
    EXPECT_LE(ExpectedInteger.getBitWidth(), Params.IntegerWidth);
    ExpectedInteger = ExpectedInteger.extend(Params.IntegerWidth);
    if (ExpectedInteger.isUnsigned() && Params.IsSigned) {
      ExpectedInteger.setIsSigned(Params.IsSigned);
      EXPECT_FALSE(ExpectedInteger.isNegative());
    }

    const bool NegativeUnderflow =
        ExpectedInteger.isZero() && Input.isNegative();
    const bool ExpectedIsExact =
        Expected.Status == APFloat::opOK && !NegativeUnderflow;
    bool ActualIsExact;
    const auto ActualStatus =
        Input.convertToInteger(ActualInteger, RM, &ActualIsExact);
    EXPECT_EQ(ActualStatus, Expected.Status);
    EXPECT_EQ(ActualIsExact, ExpectedIsExact);
    EXPECT_EQ(ActualInteger, ExpectedInteger);
  }
}

TEST(APFloatTest, PPCDoubleDoubleCompare) {
  using DataType =
      std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, APFloat::cmpResult>;

  DataType Data[] = {
      // (1 + 0) = (1 + 0)
      std::make_tuple(0x3ff0000000000000ull, 0, 0x3ff0000000000000ull, 0,
                      APFloat::cmpEqual),
      // (1 + 0) < (1.00...1 + 0)
      std::make_tuple(0x3ff0000000000000ull, 0, 0x3ff0000000000001ull, 0,
                      APFloat::cmpLessThan),
      // (1.00...1 + 0) > (1 + 0)
      std::make_tuple(0x3ff0000000000001ull, 0, 0x3ff0000000000000ull, 0,
                      APFloat::cmpGreaterThan),
      // (1 + 0) < (1 + epsilon)
      std::make_tuple(0x3ff0000000000000ull, 0, 0x3ff0000000000001ull,
                      0x0000000000000001ull, APFloat::cmpLessThan),
      // NaN != NaN
      std::make_tuple(0x7ff8000000000000ull, 0, 0x7ff8000000000000ull, 0,
                      APFloat::cmpUnordered),
      // (1 + 0) != NaN
      std::make_tuple(0x3ff0000000000000ull, 0, 0x7ff8000000000000ull, 0,
                      APFloat::cmpUnordered),
      // Inf = Inf
      std::make_tuple(0x7ff0000000000000ull, 0, 0x7ff0000000000000ull, 0,
                      APFloat::cmpEqual),
  };

  for (auto Tp : Data) {
    uint64_t Op1[2], Op2[2];
    APFloat::cmpResult Expected;
    std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected) = Tp;

    APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, Op1));
    APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, Op2));
    EXPECT_EQ(Expected, A1.compare(A2))
        << formatv("compare(({0:x} + {1:x}), ({2:x} + {3:x}))", Op1[0], Op1[1],
                   Op2[0], Op2[1])
               .str();
  }
}

namespace PPCDoubleDoubleCompareAbsoluteValueTestDetails {
struct TestCase {
  DD LHS;
  DD RHS;
  APFloat::cmpResult Result;
};

auto testCases() {
  static constexpr auto CompareAbsoluteValueTestCases = std::array{
      TestCase{
          {1.0, 0.0},
          {1.0, 0.0},
          APFloat::cmpEqual,
      },
      TestCase{
          {1.0, -0.0},
          {1.0, +0.0},
          APFloat::cmpEqual,
      },
      TestCase{
          {1.0, 0.0},
          {0x1.0000000000001p+0, 0.0},
          APFloat::cmpLessThan,
      },
      TestCase{
          {0x1.0000000000001p+0, 0.0},
          {1.0, 0.0},
          APFloat::cmpGreaterThan,
      },
      TestCase{
          {0x1.0000000000001p+0, +0x1p-1074},
          {1.0, -0x1p-1074},
          APFloat::cmpGreaterThan,
      },
      TestCase{
          {0x1.0000000000001p+0, -0x1p-1074},
          {1.0, +0x1p-1074},
          APFloat::cmpGreaterThan,
      },
      TestCase{
          {1.0, 0.0},
          {1.0, -0x1p-1074},
          APFloat::cmpGreaterThan,
      },
      TestCase{
          {1.0, 0.0},
          {1.0, +0x1p-1074},
          APFloat::cmpLessThan,
      },
      TestCase{
          {1.0, +0x1p-1073},
          {1.0, -0x1p-1074},
          APFloat::cmpGreaterThan,
      },
      TestCase{
          {1.0, +0x1p-1074},
          {1.0, -0x1p-1074},
          APFloat::cmpGreaterThan,
      },
  };
  return CompareAbsoluteValueTestCases;
}
} // namespace PPCDoubleDoubleCompareAbsoluteValueTestDetails

class PPCDoubleDoubleCompareAbsoluteValueValueTest
    : public testing::Test,
      public ::testing::WithParamInterface<
          PPCDoubleDoubleCompareAbsoluteValueTestDetails::TestCase> {};

INSTANTIATE_TEST_SUITE_P(
    PPCDoubleDoubleCompareAbsoluteValueValueParamTests,
    PPCDoubleDoubleCompareAbsoluteValueValueTest,
    ::testing::ValuesIn(
        PPCDoubleDoubleCompareAbsoluteValueTestDetails::testCases()));

TEST_P(PPCDoubleDoubleCompareAbsoluteValueValueTest,
       PPCDoubleDoubleCompareAbsoluteValue) {
  auto Param = GetParam();
  for (bool LHSNegate : {false, true}) {
    auto LHS = llvm::detail::DoubleAPFloat{APFloat::PPCDoubleDouble(),
                                           APFloat{Param.LHS.Hi},
                                           APFloat{Param.LHS.Lo}};
    if (LHSNegate)
      LHS.changeSign();
    for (bool RHSNegate : {false, true}) {
      auto RHS = llvm::detail::DoubleAPFloat{APFloat::PPCDoubleDouble(),
                                             APFloat{Param.RHS.Hi},
                                             APFloat{Param.RHS.Lo}};
      if (RHSNegate)
        RHS.changeSign();

      EXPECT_EQ(LHS.compareAbsoluteValue(RHS), Param.Result);
    }
  }
}

TEST(APFloatTest, PPCDoubleDoubleBitwiseIsEqual) {
  using DataType = std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, bool>;

  DataType Data[] = {
      // (1 + 0) = (1 + 0)
      std::make_tuple(0x3ff0000000000000ull, 0, 0x3ff0000000000000ull, 0, true),
      // (1 + 0) != (1.00...1 + 0)
      std::make_tuple(0x3ff0000000000000ull, 0, 0x3ff0000000000001ull, 0,
                      false),
      // NaN = NaN
      std::make_tuple(0x7ff8000000000000ull, 0, 0x7ff8000000000000ull, 0, true),
      // NaN != NaN with a different bit pattern
      std::make_tuple(0x7ff8000000000000ull, 0, 0x7ff8000000000000ull,
                      0x3ff0000000000000ull, false),
      // Inf = Inf
      std::make_tuple(0x7ff0000000000000ull, 0, 0x7ff0000000000000ull, 0, true),
  };

  for (auto Tp : Data) {
    uint64_t Op1[2], Op2[2];
    bool Expected;
    std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected) = Tp;

    APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, Op1));
    APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, Op2));
    EXPECT_EQ(Expected, A1.bitwiseIsEqual(A2))
        << formatv("({0:x} + {1:x}) = ({2:x} + {3:x})", Op1[0], Op1[1], Op2[0],
                   Op2[1])
               .str();
  }
}

TEST(APFloatTest, PPCDoubleDoubleHashValue) {
  uint64_t Data1[] = {0x3ff0000000000001ull, 0x0000000000000001ull};
  uint64_t Data2[] = {0x3ff0000000000001ull, 0};
  // The hash values are *hopefully* different.
  EXPECT_NE(hash_value(APFloat(APFloat::PPCDoubleDouble(), APInt(128, Data1))),
            hash_value(APFloat(APFloat::PPCDoubleDouble(), APInt(128, Data2))));
}

TEST(APFloatTest, PPCDoubleDoubleChangeSign) {
  uint64_t Data[] = {
      0x400f000000000000ull, 0xbcb0000000000000ull,
  };
  APFloat Float(APFloat::PPCDoubleDouble(), APInt(128, Data));
  {
    APFloat Actual =
        APFloat::copySign(Float, APFloat(APFloat::IEEEdouble(), "1"));
    EXPECT_EQ(0x400f000000000000ull, Actual.bitcastToAPInt().getRawData()[0]);
    EXPECT_EQ(0xbcb0000000000000ull, Actual.bitcastToAPInt().getRawData()[1]);
  }
  {
    APFloat Actual =
        APFloat::copySign(Float, APFloat(APFloat::IEEEdouble(), "-1"));
    EXPECT_EQ(0xc00f000000000000ull, Actual.bitcastToAPInt().getRawData()[0]);
    EXPECT_EQ(0x3cb0000000000000ull, Actual.bitcastToAPInt().getRawData()[1]);
  }
}

TEST(APFloatTest, PPCDoubleDoubleFactories) {
  {
    uint64_t Data[] = {
        0, 0,
    };
    EXPECT_EQ(APInt(128, Data),
              APFloat::getZero(APFloat::PPCDoubleDouble()).bitcastToAPInt());
  }
  {
    uint64_t Data[] = {
        0x7fefffffffffffffull, 0x7c8ffffffffffffeull,
    };
    EXPECT_EQ(APInt(128, Data),
              APFloat::getLargest(APFloat::PPCDoubleDouble()).bitcastToAPInt());
  }
  {
    uint64_t Data[] = {
        0x0000000000000001ull, 0,
    };
    EXPECT_EQ(
        APInt(128, Data),
        APFloat::getSmallest(APFloat::PPCDoubleDouble()).bitcastToAPInt());
  }
  {
    uint64_t Data[] = {0x0360000000000000ull, 0};
    EXPECT_EQ(APInt(128, Data),
              APFloat::getSmallestNormalized(APFloat::PPCDoubleDouble())
                  .bitcastToAPInt());
  }
  {
    uint64_t Data[] = {
        0x8000000000000000ull, 0x0000000000000000ull,
    };
    EXPECT_EQ(
        APInt(128, Data),
        APFloat::getZero(APFloat::PPCDoubleDouble(), true).bitcastToAPInt());
  }
  {
    uint64_t Data[] = {
        0xffefffffffffffffull, 0xfc8ffffffffffffeull,
    };
    EXPECT_EQ(
        APInt(128, Data),
        APFloat::getLargest(APFloat::PPCDoubleDouble(), true).bitcastToAPInt());
  }
  {
    uint64_t Data[] = {
        0x8000000000000001ull, 0x0000000000000000ull,
    };
    EXPECT_EQ(APInt(128, Data),
              APFloat::getSmallest(APFloat::PPCDoubleDouble(), true)
                  .bitcastToAPInt());
  }
  {
    uint64_t Data[] = {
        0x8360000000000000ull, 0x0000000000000000ull,
    };
    EXPECT_EQ(APInt(128, Data),
              APFloat::getSmallestNormalized(APFloat::PPCDoubleDouble(), true)
                  .bitcastToAPInt());
  }
  EXPECT_TRUE(APFloat::getSmallest(APFloat::PPCDoubleDouble()).isSmallest());
  EXPECT_TRUE(APFloat::getLargest(APFloat::PPCDoubleDouble()).isLargest());
}

TEST(APFloatTest, PPCDoubleDoubleIsDenormal) {
  EXPECT_TRUE(APFloat::getSmallest(APFloat::PPCDoubleDouble()).isDenormal());
  EXPECT_FALSE(APFloat::getLargest(APFloat::PPCDoubleDouble()).isDenormal());
  EXPECT_FALSE(
      APFloat::getSmallestNormalized(APFloat::PPCDoubleDouble()).isDenormal());
  {
    // (4 + 3) is not normalized
    uint64_t Data[] = {
        0x4010000000000000ull, 0x4008000000000000ull,
    };
    EXPECT_TRUE(
        APFloat(APFloat::PPCDoubleDouble(), APInt(128, Data)).isDenormal());
  }
}

TEST(APFloatTest, PPCDoubleDoubleScalbn) {
  // 3.0 + 3.0 << 53
  uint64_t Input[] = {
      0x4008000000000000ull, 0x3cb8000000000000ull,
  };
  APFloat Result =
      scalbn(APFloat(APFloat::PPCDoubleDouble(), APInt(128, Input)), 1,
             APFloat::rmNearestTiesToEven);
  // 6.0 + 6.0 << 53
  EXPECT_EQ(0x4018000000000000ull, Result.bitcastToAPInt().getRawData()[0]);
  EXPECT_EQ(0x3cc8000000000000ull, Result.bitcastToAPInt().getRawData()[1]);
}

namespace PPCDoubleDoubleFrexpTestDetails {
// Define the rounding modes for easier readability.
static constexpr auto RNE = APFloat::rmNearestTiesToEven;
static constexpr auto RNA = APFloat::rmNearestTiesToAway;
static constexpr auto RTZ = APFloat::rmTowardZero;
static constexpr auto RUP = APFloat::rmTowardPositive;
static constexpr auto RDN = APFloat::rmTowardNegative;

struct TestCase {
  // Structure to hold the expected result of a conversion
  struct ExpectedFractionExponent {
    DD Fraction;
    int Exponent;
    friend APFloat::cmpResult compare(const ExpectedFractionExponent &Lhs,
                                      const ExpectedFractionExponent &Rhs) {
      const APFloat LhsFraction = makeDoubleAPFloat(Lhs.Fraction);
      const APFloat RhsFraction = makeDoubleAPFloat(Rhs.Fraction);
      const APFloat::cmpResult FractionRelation =
          LhsFraction.compare(RhsFraction);
      if (FractionRelation == APFloat::cmpUnordered)
        return APFloat::cmpUnordered;
      if (LhsFraction.isZero() && RhsFraction.isZero())
        return APFloat::cmpEqual;
      if (!LhsFraction.isNegative() &&
          (RhsFraction.isNegative() || RhsFraction.isZero()))
        return APFloat::cmpGreaterThan;
      if (!RhsFraction.isNegative() &&
          (LhsFraction.isNegative() || LhsFraction.isZero()))
        return APFloat::cmpLessThan;
      if (Lhs.Exponent > Rhs.Exponent)
        return LhsFraction.isNegative() ? APFloat::cmpLessThan
                                        : APFloat::cmpGreaterThan;
      if (Lhs.Exponent < Rhs.Exponent)
        return RhsFraction.isNegative() ? APFloat::cmpGreaterThan
                                        : APFloat::cmpLessThan;
      return FractionRelation;
    }
  };

  DD Input;
  // Array indexed by the rounding mode enum value.
  std::array<ExpectedFractionExponent, 5> Rounded = {};

  // Helper to define the expected results for a specific rounding mode.
  constexpr TestCase &with(APFloat::roundingMode RM, DD ExpectedDD,
                           int ExpectedExponent) {
    Rounded[static_cast<std::underlying_type_t<APFloat::roundingMode>>(RM)] = {
        ExpectedDD,
        ExpectedExponent,
    };
    return *this;
  }

  // Helper to define the same result for all rounding modes.
  constexpr TestCase &withAll(DD ExpectedDD, int ExpectedExponent) {
    return with(RNE, ExpectedDD, ExpectedExponent)
        .with(RNA, ExpectedDD, ExpectedExponent)
        .with(RTZ, ExpectedDD, ExpectedExponent)
        .with(RUP, ExpectedDD, ExpectedExponent)
        .with(RDN, ExpectedDD, ExpectedExponent);
  }
};

auto testCases() {
  static constexpr auto FrexpTestCases = std::array{
      // Input: +infinity
      TestCase{{std::numeric_limits<double>::infinity(), 0.0}}.withAll(
          {std::numeric_limits<double>::infinity(), 0.0}, INT_MAX),

      // Input: -infinity
      TestCase{{-std::numeric_limits<double>::infinity(), 0.0}}.withAll(
          {-std::numeric_limits<double>::infinity(), 0.0}, INT_MAX),

      // Input: NaN
      TestCase{{std::numeric_limits<double>::quiet_NaN(), 0.0}}.withAll(
          {std::numeric_limits<double>::quiet_NaN(), 0.0}, INT_MIN),

      // Input: 2^-1074
      TestCase{{0x1p-1074, 0.0}}.withAll({0x1p-1, 0.0}, -1073),
      TestCase{{-0x1p-1074, 0.0}}.withAll({-0x1p-1, 0.0}, -1073),

      // Input: (2^1, -2^-1073 + -2^-1074)
      TestCase{{0x1p1, -0x1.8p-1073}}
          .withAll({0x1p0, -0x1p-1073}, 1)
          .with(RNA, {0x1p0, -0x1p-1074}, 1)
          .with(RUP, {0x1p0, -0x1p-1074}, 1),
      TestCase{{-0x1p1, 0x1.8p-1073}}
          .withAll({-0x1p0, 0x1p-1073}, 1)
          .with(RNA, {-0x1p0, 0x1p-1074}, 1)
          .with(RDN, {-0x1p0, 0x1p-1074}, 1),

      // Input: (2^1, -2^-1073)
      TestCase{{0x1p1, -0x1p-1073}}.withAll({0x1p0, -0x1p-1074}, 1),

      // Input: (2^1, -2^-1074)
      TestCase{{0x1p1, -0x1p-1074}}
          .withAll({0x1p-1, -0.0}, 2)
          .with(RDN, {0x1p0, -0x1p-1074}, 1)
          .with(RTZ, {0x1p0, -0x1p-1074}, 1),

      // Input: (2^2, -2^-1072 + -2^-1073 + -2^-1074)
      TestCase{{0x1p2, -0x1.cp-1072}}
          .withAll({0x1p0, -0x1p-1073}, 2)
          .with(RUP, {0x1p0, -0x1p-1074}, 2),

      // Input: (2^2, -2^-1072 + -2^-1073)
      TestCase{{0x1p2, -0x1.8p-1072}}
          .withAll({0x1p0, -0x1p-1073}, 2)
          .with(RNA, {0x1p0, -0x1p-1074}, 2)
          .with(RUP, {0x1p0, -0x1p-1074}, 2),
      TestCase{{-0x1p2, 0x1.8p-1072}}
          .withAll({-0x1p0, 0x1p-1073}, 2)
          .with(RNA, {-0x1p0, 0x1p-1074}, 2)
          .with(RDN, {-0x1p0, 0x1p-1074}, 2),

      // Input: (2^2, -2^-1072 + -2^-1074)
      TestCase{{0x1p2, -0x1.4cp-1072}}
          .withAll({0x1p0, -0x1p-1074}, 2)
          .with(RDN, {0x1p0, -0x1p-1073}, 2)
          .with(RTZ, {0x1p0, -0x1p-1073}, 2),

      // Input: (2^2, -2^-1072)
      TestCase{{0x1p2, -0x1p-1072}}.withAll({0x1p0, -0x1p-1074}, 2),

      // Input: (2^2, -2^-1073 + -2^-1074)
      TestCase{{0x1p2, -0x1.8p-1073}}
          .withAll({0x1p0, -0x1p-1074}, 2)
          .with(RUP, {0x1p-1, -0.0}, 3),

      // Input: (2^2, -2^-1073)
      TestCase{{0x1p2, -0x1p-1073}}
          .withAll({0x1p-1, -0.0}, 3)
          .with(RDN, {0x1p0, -0x1p-1074}, 2)
          .with(RTZ, {0x1p0, -0x1p-1074}, 2),

      // Input: (2^2, -2^-1074)
      TestCase{{0x1p2, -0x1p-1074}}
          .withAll({0x1p-1, -0.0}, 3)
          .with(RDN, {0x1p0, -0x1p-1074}, 2)
          .with(RTZ, {0x1p0, -0x1p-1074}, 2),

      // Input: 3+3*2^-53 canonicalized to (3+2^-51, -2^-53)
      // Output: 0.75+0.75*2^-53 canonicalized to (.75+2^-53, -2^-55)
      TestCase{{0x1.8000000000001p1, -0x1p-53}}.withAll(
          {0x1.8000000000001p-1, -0x1p-55}, 2),
      TestCase{{-0x1.8000000000001p1, 0x1p-53}}.withAll(
          {-0x1.8000000000001p-1, 0x1p-55}, 2),

      // Input: (2^1021+2^969, 2^968-2^915)
      TestCase{{0x1.0000000000001p1021, 0x1.fffffffffffffp967}}.withAll(
          {0x1.0000000000001p-1, 0x1.fffffffffffffp-55}, 1022),
      TestCase{{-0x1.0000000000001p1021, -0x1.fffffffffffffp967}}.withAll(
          {-0x1.0000000000001p-1, -0x1.fffffffffffffp-55}, 1022),

      // Input: (2^1023, -2^-1)
      TestCase{{0x1p+1023, -0x1p-1}}.withAll({0x1p0, -0x1p-1024}, 1023),
      TestCase{{-0x1p+1023, 0x1p-1}}.withAll({-0x1p0, 0x1p-1024}, 1023),

      // Input: (2^1023, -2^-51)
      TestCase{{0x1p+1023, -0x1p-51}}.withAll({0x1p0, -0x1p-1074}, 1023),
      TestCase{{-0x1p+1023, 0x1p-51}}.withAll({-0x1p0, 0x1p-1074}, 1023),

      // Input: (2^1023, -2^-52)
      TestCase{{0x1p+1023, -0x1p-52}}
          .withAll({0x1p-1, -0x0p0}, 1024)
          .with(RDN, {0x1p0, -0x1p-1074}, 1023)
          .with(RTZ, {0x1p0, -0x1p-1074}, 1023),
      TestCase{{-0x1p+1023, 0x1p-52}}
          .withAll({-0x1p-1, 0x0p0}, 1024)
          .with(RUP, {-0x1p0, 0x1p-1074}, 1023)
          .with(RTZ, {-0x1p0, 0x1p-1074}, 1023),

      // Input: (2^1023, 2^-1074)
      TestCase{{0x1p+1023, 0x1p-1074}}
          .withAll({0x1p-1, 0x0p+0}, 1024)
          .with(RUP, {0x1p-1, 0x1p-1074}, 1024),
      TestCase{{-0x1p+1023, -0x1p-1074}}
          .withAll({-0x1p-1, -0x0p+0}, 1024)
          .with(RDN, {-0x1p-1, -0x1p-1074}, 1024),

      // Input: (2^1024-2^971, 2^970-2^918)
      TestCase{{0x1.fffffffffffffp+1023, 0x1.ffffffffffffep+969}}.withAll(
          {0x1.fffffffffffffp-1, 0x1.ffffffffffffep-55}, 1024),
      TestCase{{-0x1.fffffffffffffp+1023, -0x1.ffffffffffffep+969}}.withAll(
          {-0x1.fffffffffffffp-1, -0x1.ffffffffffffep-55}, 1024),
  };
  return FrexpTestCases;
}
} // namespace PPCDoubleDoubleFrexpTestDetails

class PPCDoubleDoubleFrexpValueTest
    : public testing::Test,
      public ::testing::WithParamInterface<
          PPCDoubleDoubleFrexpTestDetails::TestCase> {};

INSTANTIATE_TEST_SUITE_P(
    PPCDoubleDoubleFrexpValueParamTests, PPCDoubleDoubleFrexpValueTest,
    ::testing::ValuesIn(PPCDoubleDoubleFrexpTestDetails::testCases()));

TEST_P(PPCDoubleDoubleFrexpValueTest, PPCDoubleDoubleFrexp) {
  const PPCDoubleDoubleFrexpTestDetails::TestCase Params = GetParam();
  const APFloat Input = makeDoubleAPFloat(Params.Input);
  auto RmToIdx = [](APFloat::roundingMode RM) {
    return static_cast<std::underlying_type_t<APFloat::roundingMode>>(RM);
  };
  // First, make sure our expected results are consistent with each other before
  // bothering to test the implementation.
  if (Input.isFinite()) {
    // Make sure the input is canonical.
    EXPECT_EQ(APFloat{Params.Input.Hi},
              APFloat{Params.Input.Hi} + APFloat{Params.Input.Lo})
        << Params.Input.Hi << " + " << Params.Input.Lo;

    const auto Dn = Params.Rounded[RmToIdx(APFloat::rmTowardNegative)];
    const auto Up = Params.Rounded[RmToIdx(APFloat::rmTowardPositive)];
    const auto Tz = Params.Rounded[RmToIdx(APFloat::rmTowardZero)];
    const auto Ne = Params.Rounded[RmToIdx(APFloat::rmNearestTiesToEven)];
    const auto Na = Params.Rounded[RmToIdx(APFloat::rmNearestTiesToAway)];

    // The rdn result must be no larger than the rup result.
    const APFloat::cmpResult DnVsUp = compare(Dn, Up);
    EXPECT_TRUE(DnVsUp == APFloat::cmpLessThan || DnVsUp == APFloat::cmpEqual);

    for (size_t I = 0, E = std::size(Params.Rounded); I != E; ++I) {
      const APFloat RoundedFraction =
          makeDoubleAPFloat(Params.Rounded[I].Fraction);
      // All possible results should be bracketed by [Dn, Up].
      const APFloat::cmpResult VsDn = compare(Params.Rounded[I], Dn);
      EXPECT_TRUE(VsDn == APFloat::cmpGreaterThan || VsDn == APFloat::cmpEqual);
      const APFloat::cmpResult VsUp = compare(Params.Rounded[I], Up);
      EXPECT_TRUE(VsUp == APFloat::cmpLessThan || VsUp == APFloat::cmpEqual);
      // A rounding result is either equal to the rup or rdn result.
      EXPECT_TRUE(VsUp == APFloat::cmpEqual || VsDn == APFloat::cmpEqual);
      // frexp returns a result whose magnitude is in in [.5, 1) so its exponent
      // should be -1.
      if (!RoundedFraction.isZero())
        EXPECT_EQ(ilogb(RoundedFraction), -1)
            << static_cast<APFloat::roundingMode>(I);
      // Decomposition preserves sign.
      EXPECT_EQ(RoundedFraction.isNegative(), Input.isNegative());
      // A rounding result must be canonical.
      EXPECT_EQ(APFloat{Params.Rounded[I].Fraction.Hi},
                APFloat{Params.Rounded[I].Fraction.Hi} +
                    APFloat{Params.Rounded[I].Fraction.Lo})
          << Params.Rounded[I].Fraction.Hi << " + "
          << Params.Rounded[I].Fraction.Lo;
    }

    // The rtz result must be either rup or rdn depending on the sign.
    if (Input.isNegative()) {
      const APFloat::cmpResult TzVsUp = compare(Tz, Up);
      EXPECT_EQ(TzVsUp, APFloat::cmpEqual);
    } else {
      const APFloat::cmpResult TzVsDn = compare(Tz, Dn);
      EXPECT_EQ(TzVsDn, APFloat::cmpEqual);
    }

    // The recomposed up should be at least as big as the input.
    const APFloat RecomposedUp =
        scalbn(makeDoubleAPFloat(Up.Fraction), Up.Exponent,
               APFloat::rmNearestTiesToEven);
    EXPECT_TRUE(RecomposedUp >= Input);
    // The recomposed down can't be larger than the input.
    const APFloat RecomposedDn =
        scalbn(makeDoubleAPFloat(Dn.Fraction), Dn.Exponent,
               APFloat::rmNearestTiesToEven);
    EXPECT_TRUE(RecomposedDn <= Input);
    // The recomposed tz must have a smaller magnitude.
    const APFloat RecomposedTz =
        scalbn(makeDoubleAPFloat(Tz.Fraction), Tz.Exponent,
               APFloat::rmNearestTiesToEven);
    EXPECT_TRUE(abs(RecomposedTz) <= abs(Input));
    // Either both or neither of the recomposed round-to-nearest results are
    // equal to the input.
    const APFloat RecomposedNe =
        scalbn(makeDoubleAPFloat(Ne.Fraction), Ne.Exponent,
               APFloat::rmNearestTiesToEven);
    const APFloat RecomposedNa =
        scalbn(makeDoubleAPFloat(Na.Fraction), Na.Exponent,
               APFloat::rmNearestTiesToEven);
    EXPECT_EQ(RecomposedNe == Input, RecomposedNa == Input);
    // Either the ne result equals the na result or the na result has a bigger
    // magnitude.
    const APFloat::cmpResult NeVsNa =
        abs(RecomposedNe).compare(abs(RecomposedNa));
    EXPECT_TRUE(NeVsNa == APFloat::cmpLessThan || NeVsNa == APFloat::cmpEqual);
    // ne and na may only disagree if they broke a tie differently.
    if (NeVsNa == APFloat::cmpLessThan) {
      // ne's magnitude should be lower than input.
      const APFloat::cmpResult NeVsInput =
          abs(RecomposedNe).compare(abs(Input));
      EXPECT_EQ(NeVsInput, APFloat::cmpLessThan);
      // na's magnitude should be greater than input.
      const APFloat::cmpResult NaVsInput =
          abs(RecomposedNa).compare(abs(Input));
      EXPECT_EQ(NaVsInput, APFloat::cmpGreaterThan);
    }
    // If up or down perfectly reconstructs the input, the round-to-nearest
    // results should too.
    if (RecomposedUp == Input || RecomposedDn == Input) {
      EXPECT_EQ(RecomposedNe, Input);
      EXPECT_EQ(RecomposedNa, Input);
    }
  }

  for (size_t I = 0, E = std::size(Params.Rounded); I != E; ++I) {
    const auto RM = static_cast<APFloat::roundingMode>(I);
    const auto &Expected = Params.Rounded[I];
    const APFloat ExpectedFraction = makeDoubleAPFloat(Expected.Fraction);

    int ActualExponent;
    const APFloat ActualFraction = frexp(Input, ActualExponent, RM);
    if (ExpectedFraction.isNaN())
      EXPECT_TRUE(ActualFraction.isNaN());
    else
      EXPECT_EQ(ActualFraction.compare(ExpectedFraction), APFloat::cmpEqual)
          << ActualFraction << " vs " << ExpectedFraction << " for input "
          << Params.Input.Hi << " + " << Params.Input.Lo << " RM " << RM;
    EXPECT_EQ(ActualExponent, Expected.Exponent)
        << "for input " << Params.Input.Hi << " + " << Params.Input.Lo
        << " RM " << RM;
  }
}

TEST(APFloatTest, PPCDoubleDoubleNext) {
  auto NextUp = [](APFloat X) {
    X.next(/*nextDown=*/false);
    return X;
  };

  auto NextDown = [](APFloat X) {
    X.next(/*nextDown=*/true);
    return X;
  };

  auto Zero = [] { return APFloat::getZero(APFloat::IEEEdouble()); };

  auto One = [] { return APFloat::getOne(APFloat::IEEEdouble()); };

  // 0x1p-1074
  auto MinSubnormal = [] {
    return APFloat::getSmallest(APFloat::IEEEdouble());
  };

  // 2^-52
  auto Eps = [&] {
    const fltSemantics &Sem = APFloat::IEEEdouble();
    return scalbn(One(), 1 - APFloat::semanticsPrecision(Sem),
                  APFloat::rmNearestTiesToEven);
  };

  // 2^-53
  auto EpsNeg = [&] { return scalbn(Eps(), -1, APFloat::rmNearestTiesToEven); };

  APFloat Test(APFloat::PPCDoubleDouble(), APFloat::uninitialized);
  APFloat Expected(APFloat::PPCDoubleDouble(), APFloat::uninitialized);

  // 1. Test Special Cases Values.
  //
  // Test all special values for nextUp and nextDown prescribed by IEEE-754R
  // 2008. These are:
  //   1.  +inf
  //   2.  -inf
  //   3.  getLargest()
  //   4.  -getLargest()
  //   5.  getSmallest()
  //   6.  -getSmallest()
  //   7.  qNaN
  //   8.  sNaN
  //   9.  +0
  //   10. -0

  // nextUp(+inf) = +inf.
  Test = APFloat::getInf(APFloat::PPCDoubleDouble(), false);
  EXPECT_EQ(Test.next(false), APFloat::opOK);
  EXPECT_TRUE(Test.isPosInfinity());
  EXPECT_TRUE(!Test.isNegative());

  // nextDown(+inf) = -nextUp(-inf) = -(-getLargest()) = getLargest()
  Test = APFloat::getInf(APFloat::PPCDoubleDouble(), false);
  EXPECT_EQ(Test.next(true), APFloat::opOK);
  EXPECT_FALSE(Test.isNegative());
  EXPECT_TRUE(Test.isLargest());

  // nextUp(-inf) = -getLargest()
  Test = APFloat::getInf(APFloat::PPCDoubleDouble(), true);
  Expected = APFloat::getLargest(APFloat::PPCDoubleDouble(), true);
  EXPECT_EQ(Test.next(false), APFloat::opOK);
  EXPECT_TRUE(Test.isNegative());
  EXPECT_TRUE(Test.isLargest());
  EXPECT_TRUE(Test.bitwiseIsEqual(Expected));

  // nextDown(-inf) = -nextUp(+inf) = -(+inf) = -inf.
  Test = APFloat::getInf(APFloat::PPCDoubleDouble(), true);
  Expected = APFloat::getInf(APFloat::PPCDoubleDouble(), true);
  EXPECT_EQ(Test.next(true), APFloat::opOK);
  EXPECT_TRUE(Test.isNegInfinity());
  EXPECT_TRUE(Test.bitwiseIsEqual(Expected));

  // nextUp(getLargest()) = +inf
  Test = APFloat::getLargest(APFloat::PPCDoubleDouble(), false);
  Expected = APFloat::getInf(APFloat::PPCDoubleDouble(), false);
  EXPECT_EQ(Test.next(false), APFloat::opOK);
  EXPECT_TRUE(Test.isPosInfinity());
  EXPECT_TRUE(Test.bitwiseIsEqual(Expected));

  // nextUp(-getSmallest()) = -0.
  Test = APFloat::getSmallest(Test.getSemantics(), /*Neg=*/true);
  Expected = APFloat::getZero(APFloat::PPCDoubleDouble(), true);
  EXPECT_EQ(Test.next(false), APFloat::opOK);
  EXPECT_TRUE(Test.isNegZero());
  EXPECT_TRUE(Test.bitwiseIsEqual(Expected));

  // nextDown(getSmallest()) = -nextUp(-getSmallest()) = -(-0) = +0.
  Test = APFloat::getSmallest(Test.getSemantics(), /*Neg=*/false);
  EXPECT_EQ(Test.next(true), APFloat::opOK);
  EXPECT_TRUE(Test.isPosZero());

  // nextDown(-getLargest()) = -nextUp(getLargest()) = -(inf) = -inf.
  Test = APFloat::getLargest(APFloat::PPCDoubleDouble(), true);
  EXPECT_EQ(Test.next(true), APFloat::opOK);
  EXPECT_TRUE(Test.isNegInfinity());

  // nextUp(qNaN) = qNaN
  Test = APFloat::getQNaN(APFloat::PPCDoubleDouble(), false);
  EXPECT_EQ(Test.next(false), APFloat::opOK);
  EXPECT_TRUE(Test.isNaN());
  EXPECT_FALSE(Test.isSignaling());

  // nextDown(qNaN) = qNaN
  Test = APFloat::getQNaN(APFloat::PPCDoubleDouble(), false);
  EXPECT_EQ(Test.next(true), APFloat::opOK);
  EXPECT_TRUE(Test.isNaN());
  EXPECT_FALSE(Test.isSignaling());

  // nextUp(sNaN) = qNaN
  Test = APFloat::getSNaN(APFloat::PPCDoubleDouble(), false);
  EXPECT_EQ(Test.next(false), APFloat::opInvalidOp);
  EXPECT_TRUE(Test.isNaN());
  EXPECT_FALSE(Test.isSignaling());

  // nextDown(sNaN) = qNaN
  Test = APFloat::getSNaN(APFloat::PPCDoubleDouble(), false);
  EXPECT_EQ(Test.next(true), APFloat::opInvalidOp);
  EXPECT_TRUE(Test.isNaN());
  EXPECT_FALSE(Test.isSignaling());

  // nextUp(+0) = +getSmallest()
  Test = APFloat::getZero(APFloat::PPCDoubleDouble(), false);
  EXPECT_EQ(Test.next(false), APFloat::opOK);
  EXPECT_FALSE(Test.isNegative());
  EXPECT_TRUE(Test.isSmallest());

  // nextDown(+0) = -nextUp(-0) = -getSmallest()
  Test = APFloat::getZero(APFloat::PPCDoubleDouble(), false);
  EXPECT_EQ(Test.next(true), APFloat::opOK);
  EXPECT_TRUE(Test.isNegative());
  EXPECT_TRUE(Test.isSmallest());

  // nextUp(-0) = +getSmallest()
  Test = APFloat::getZero(APFloat::PPCDoubleDouble(), true);
  EXPECT_EQ(Test.next(false), APFloat::opOK);
  EXPECT_FALSE(Test.isNegative());
  EXPECT_TRUE(Test.isSmallest());

  // nextDown(-0) = -nextUp(0) = -getSmallest()
  Test = APFloat::getZero(APFloat::PPCDoubleDouble(), true);
  EXPECT_EQ(Test.next(true), APFloat::opOK);
  EXPECT_TRUE(Test.isNegative());
  EXPECT_TRUE(Test.isSmallest());

  // 2. Cases where the lo APFloat is zero.

  // 2a. |hi| < 2*DBL_MIN_NORMAL (DD precision == D precision)
  Test = APFloat(APFloat::PPCDoubleDouble(), "0x1.fffffffffffffp-1022");
  Expected = APFloat(APFloat::PPCDoubleDouble(), "0x1p-1021");
  EXPECT_EQ(Test.next(false), APFloat::opOK);
  EXPECT_EQ(Test.compare(Expected), APFloat::cmpEqual);

  // 2b. |hi| >= 2*DBL_MIN_NORMAL (DD precision > D precision)
  // Test at hi = 1.0, lo = 0.
  Test = makeDoubleAPFloat(One(), Zero());
  Expected = makeDoubleAPFloat(One(), MinSubnormal());
  EXPECT_EQ(Test.next(false), APFloat::opOK);
  EXPECT_TRUE(Test.bitwiseIsEqual(Expected));

  // Test at hi = -1.0. delta = 2^-1074 (positive, moving towards +Inf).
  Test = makeDoubleAPFloat(-One(), Zero());
  Expected = makeDoubleAPFloat(-One(), MinSubnormal());
  EXPECT_EQ(Test.next(false), APFloat::opOK);
  EXPECT_TRUE(Test.bitwiseIsEqual(Expected));

  // Testing the boundary where calculated delta equals DBL_TRUE_MIN.
  // Requires ilogb(hi) = E = -968.
  // delta = 2^(-968 - 106) = 2^-1074 = DBL_TRUE_MIN.
  Test = makeDoubleAPFloat("0x1p-968", Zero());
  Expected = makeDoubleAPFloat("0x1p-968", MinSubnormal());
  EXPECT_EQ(Test.next(false), APFloat::opOK);
  EXPECT_TRUE(Test.bitwiseIsEqual(Expected));

  // Testing below the boundary (E < -968). Delta clamps to DBL_TRUE_MIN.
  Test = makeDoubleAPFloat("0x1p-969", Zero());
  Expected = makeDoubleAPFloat("0x1p-969", MinSubnormal());
  EXPECT_EQ(Test.next(false), APFloat::opOK);
  EXPECT_TRUE(Test.bitwiseIsEqual(Expected));

  // 3. Standard Increment (No rollover)
  // hi=1.0, lo=2^-1074.
  Test = makeDoubleAPFloat(One(), MinSubnormal());
  Expected = makeDoubleAPFloat(One(), NextUp(MinSubnormal()));
  EXPECT_EQ(Test.next(false), APFloat::opOK);
  EXPECT_TRUE(Test.bitwiseIsEqual(Expected));

  // Incrementing negative lo.
  Test = makeDoubleAPFloat(One(), -MinSubnormal());
  Expected = makeDoubleAPFloat(One(), Zero());
  EXPECT_EQ(Test.next(false), APFloat::opOK);
  EXPECT_EQ(Test.compare(Expected), APFloat::cmpEqual);

  // Crossing lo=0.
  Test = makeDoubleAPFloat(One(), -MinSubnormal());
  Expected = makeDoubleAPFloat(One(), Zero());
  EXPECT_EQ(Test.next(false), APFloat::opOK);
  EXPECT_EQ(Test.compare(Expected), APFloat::cmpEqual);

  // 4. Rollover Cases around 1.0 (Positive hi)
  // hi=1.0, lo=nextDown(2^-53).
  Test = makeDoubleAPFloat(One(), NextDown(EpsNeg()));
  EXPECT_FALSE(Test.isDenormal());
  Expected = makeDoubleAPFloat(One(), EpsNeg());
  EXPECT_FALSE(Test.isDenormal());
  EXPECT_EQ(Test.next(false), APFloat::opOK);
  EXPECT_TRUE(Test.bitwiseIsEqual(Expected));

  // Input: (1, ulp(1)/2). nextUp(lo)=next(H). V>Midpoint. Rollover occurs
  // Can't naively increment lo:
  //   RTNE(0x1p+0 + 0x1.0000000000001p-53) == 0x1.0000000000001p+0.
  // Can't naively TwoSum(0x1p+0, nextUp(0x1p-53)):
  //   It gives {nextUp(0x1p+0), nextUp(nextUp(-0x1p-53))} but the next
  //   number should be {nextUp(0x1p+0), nextUp(-0x1p-53)}.
  Test = makeDoubleAPFloat(One(), EpsNeg());
  EXPECT_FALSE(Test.isDenormal());
  Expected = makeDoubleAPFloat(NextUp(One()), NextUp(-EpsNeg()));
  EXPECT_EQ(Test.next(false), APFloat::opOK);
  EXPECT_TRUE(Test.bitwiseIsEqual(Expected));
  EXPECT_FALSE(Test.isDenormal());

  // hi = nextDown(1), lo = nextDown(0x1p-54)
  Test = makeDoubleAPFloat(NextDown(One()), NextDown(APFloat(0x1p-54)));
  EXPECT_FALSE(Test.isDenormal());
  Expected = makeDoubleAPFloat(One(), APFloat(-0x1p-54));
  EXPECT_EQ(Test.next(false), APFloat::opOK);
  EXPECT_TRUE(Test.bitwiseIsEqual(Expected));
  EXPECT_FALSE(Test.isDenormal());

  // 5. Negative Rollover (Moving towards Zero / +Inf)

  // hi = -1, lo = nextDown(0x1p-54)
  Test = makeDoubleAPFloat(APFloat(-1.0), NextDown(APFloat(0x1p-54)));
  EXPECT_FALSE(Test.isDenormal());
  Expected = makeDoubleAPFloat(APFloat(-1.0), APFloat(0x1p-54));
  EXPECT_EQ(Test.next(false), APFloat::opOK);
  EXPECT_TRUE(Test.bitwiseIsEqual(Expected));
  EXPECT_FALSE(Test.isDenormal());

  // hi = -1, lo = 0x1p-54
  Test = makeDoubleAPFloat(APFloat(-1.0), APFloat(0x1p-54));
  EXPECT_FALSE(Test.isDenormal());
  Expected =
      makeDoubleAPFloat(NextUp(APFloat(-1.0)), NextUp(APFloat(-0x1p-54)));
  EXPECT_EQ(Test.next(false), APFloat::opOK);
  EXPECT_TRUE(Test.bitwiseIsEqual(Expected));
  EXPECT_FALSE(Test.isDenormal());

  // 6. Rollover across Power of 2 boundary (Exponent change)
  Test = makeDoubleAPFloat(NextDown(APFloat(2.0)), NextDown(EpsNeg()));
  EXPECT_FALSE(Test.isDenormal());
  Expected = makeDoubleAPFloat(APFloat(2.0), -EpsNeg());
  EXPECT_EQ(Test.next(false), APFloat::opOK);
  EXPECT_TRUE(Test.bitwiseIsEqual(Expected));
  EXPECT_FALSE(Test.isDenormal());
}

TEST(APFloatTest, PPCDoubleDoubleConvertFromAPIntInexact) {
  // Create an integer which would not be exactly representable in
  // PPCDoubleDoubleLegacy.
  for (bool IsSigned : {false, true}) {
    const unsigned BitWidth =
        APFloat::semanticsPrecision(APFloat::IEEEdouble()) * 3 +
        (IsSigned ? 1 : 0);

    for (bool Negative :
         IsSigned ? std::vector{false, true} : std::vector{false}) {
      APInt Huge = APInt{BitWidth, 0};
      // Set the highest bit without making Huge negative..
      Huge.setBit(BitWidth - (IsSigned ? 2 : 1));
      // Set the low bit.
      Huge.setBit(0);
      if (Negative)
        Huge.negate();
      for (const APFloat::roundingMode RM :
           {APFloat::rmNearestTiesToAway, APFloat::rmTowardNegative,
            APFloat::rmTowardPositive, APFloat::rmTowardZero,
            APFloat::rmNearestTiesToEven}) {
        APFloat F{APFloat::PPCDoubleDouble()};
        const APFloat::opStatus ConvertFromStatus =
            F.convertFromAPInt(Huge, /*IsSigned=*/IsSigned, RM);
        EXPECT_EQ(ConvertFromStatus, APFloat::opOK);

        bool IsExact;
        APSInt ResultInt{Huge.getBitWidth(), /*isUnsigned=*/!IsSigned};
        const APFloat::opStatus ConvertToStatus =
            F.convertToInteger(ResultInt, APFloat::rmTowardZero, &IsExact);

        EXPECT_TRUE(IsExact) << "RM: " << RM;
        EXPECT_TRUE(ResultInt.eq(Huge)) << ResultInt << " vs " << Huge << "\n";
        EXPECT_EQ(ConvertToStatus, APFloat::opOK);
      }
    }
  }
}

TEST(APFloatTest, PPCDoubleDoubleConvertFromAPIntBoundary) {
  const unsigned Binary64Precision =
      APFloat::semanticsPrecision(APFloat::IEEEdouble());
  APSInt Boundary =
      APSInt::getMaxValue(Binary64Precision + 1, /*Unsigned=*/true);
  for (const APFloat::roundingMode RM :
       {APFloat::rmNearestTiesToAway, APFloat::rmTowardNegative,
        APFloat::rmTowardPositive, APFloat::rmTowardZero,
        APFloat::rmNearestTiesToEven}) {
    const APFloat Exact = makeDoubleAPFloat(0x1p54, -0x1p0);
    APFloat F{APFloat::PPCDoubleDouble()};
    const APFloat::opStatus ConvertFromStatus =
        F.convertFromAPInt(Boundary, /*IsSigned=*/false, RM);
    EXPECT_EQ(ConvertFromStatus, APFloat::opOK);
    EXPECT_EQ(F, Exact);
  }

  Boundary = APSInt{APInt::getHighBitsSet(/*numBits=*/128,
                                          /*hiBitsSet=*/Binary64Precision + 1),
                    /*isUnsigned=*/true};
  for (const APFloat::roundingMode RM :
       {APFloat::rmNearestTiesToAway, APFloat::rmTowardNegative,
        APFloat::rmTowardPositive, APFloat::rmTowardZero,
        APFloat::rmNearestTiesToEven}) {
    const APFloat Exact = makeDoubleAPFloat(0x1p128, -0x1p74);
    APFloat F{APFloat::PPCDoubleDouble()};
    const APFloat::opStatus ConvertFromStatus =
        F.convertFromAPInt(Boundary, /*IsSigned=*/false, RM);
    EXPECT_EQ(ConvertFromStatus, APFloat::opOK);
    EXPECT_EQ(F, Exact);
  }
}

TEST(APFloatTest, PPCDoubleDoubleConvertFromAPIntEnormous) {
  APFloat Largest = APFloat::getLargest(APFloat::PPCDoubleDouble());
  int Exponent = ilogb(Largest);
  unsigned BitWidth = Exponent + 1;
  APSInt HugeInt{BitWidth, /*isUnsigned=*/true};
  bool IsExact;
  APFloat::opStatus Status =
      Largest.convertToInteger(HugeInt, APFloat::rmTowardPositive, &IsExact);
  ASSERT_EQ(Status, APFloat::opOK);
  ASSERT_TRUE(IsExact);

  for (const APFloat::roundingMode RM :
       {APFloat::rmNearestTiesToAway, APFloat::rmTowardNegative,
        APFloat::rmTowardPositive, APFloat::rmTowardZero,
        APFloat::rmNearestTiesToEven}) {
    APFloat F{APFloat::PPCDoubleDouble()};
    const APFloat::opStatus ConvertFromStatus =
        F.convertFromAPInt(HugeInt, /*IsSigned=*/false, RM);
    EXPECT_EQ(ConvertFromStatus, APFloat::opOK);
    EXPECT_EQ(F, Largest);
  }

  const unsigned MaxExponent =
      APFloat::semanticsMaxExponent(APFloat::IEEEdouble());
  const unsigned Binary64Precision =
      APFloat::semanticsPrecision(APFloat::IEEEdouble());
  const unsigned UlpOfLargest = MaxExponent - (2 * Binary64Precision);
  const unsigned HalfUlpOfLargest = UlpOfLargest - 1;

  // Add just under a half-ulp. This should never overflow for
  // round-ties-to-nearest modes.
  HugeInt.setLowBits(HalfUlpOfLargest);
  for (const APFloat::roundingMode RM :
       {APFloat::rmNearestTiesToAway, APFloat::rmTowardNegative,
        APFloat::rmTowardPositive, APFloat::rmTowardZero,
        APFloat::rmNearestTiesToEven}) {
    APFloat F{APFloat::PPCDoubleDouble()};
    const APFloat::opStatus ConvertFromStatus =
        F.convertFromAPInt(HugeInt, /*IsSigned=*/false, RM);
    if (RM == APFloat::rmTowardPositive) {
      EXPECT_TRUE(F.isPosInfinity()) << F;
      EXPECT_EQ(ConvertFromStatus, APFloat::opInexact | APFloat::opOverflow);
    } else {
      EXPECT_EQ(F, Largest);
      EXPECT_EQ(ConvertFromStatus, APFloat::opInexact);
    }
  }

  // Now test adding a half-ulp. This should cause overflow for ties-to-away.
  // ties-to-even will not overflow if the max finite value has a clear low bit.
  ++HugeInt;
  for (const APFloat::roundingMode RM :
       {APFloat::rmNearestTiesToAway, APFloat::rmTowardNegative,
        APFloat::rmTowardPositive, APFloat::rmTowardZero,
        APFloat::rmNearestTiesToEven}) {
    APFloat F{APFloat::PPCDoubleDouble()};
    const APFloat::opStatus ConvertFromStatus =
        F.convertFromAPInt(HugeInt, /*IsSigned=*/false, RM);
    const bool Overflow =
        RM == APFloat::rmTowardPositive || RM == APFloat::rmNearestTiesToAway ||
        (RM == APFloat::rmNearestTiesToEven && HugeInt[UlpOfLargest]);
    if (Overflow) {
      EXPECT_TRUE(F.isPosInfinity()) << F;
      EXPECT_EQ(ConvertFromStatus, APFloat::opInexact | APFloat::opOverflow);
    } else {
      EXPECT_EQ(F, Largest);
      EXPECT_EQ(ConvertFromStatus, APFloat::opInexact);
    }
  }

  // Now test adding just over a half-ulp. This should break all ties.
  ++HugeInt;
  for (const APFloat::roundingMode RM :
       {APFloat::rmNearestTiesToAway, APFloat::rmTowardNegative,
        APFloat::rmTowardPositive, APFloat::rmTowardZero,
        APFloat::rmNearestTiesToEven}) {
    APFloat F{APFloat::PPCDoubleDouble()};
    const APFloat::opStatus ConvertFromStatus =
        F.convertFromAPInt(HugeInt, /*IsSigned=*/false, RM);
    const bool Overflow = RM == APFloat::rmTowardPositive ||
                          RM == APFloat::rmNearestTiesToAway ||
                          RM == APFloat::rmNearestTiesToEven;
    if (Overflow) {
      EXPECT_TRUE(F.isPosInfinity()) << F;
      EXPECT_EQ(ConvertFromStatus, APFloat::opInexact | APFloat::opOverflow);
    } else {
      EXPECT_EQ(F, Largest);
      EXPECT_EQ(ConvertFromStatus, APFloat::opInexact);
    }
  }

  HugeInt.setAllBits();
  for (const APFloat::roundingMode RM :
       {APFloat::rmNearestTiesToAway, APFloat::rmTowardNegative,
        APFloat::rmTowardPositive, APFloat::rmTowardZero,
        APFloat::rmNearestTiesToEven}) {
    APFloat F{APFloat::PPCDoubleDouble()};
    const APFloat::opStatus ConvertFromStatus =
        F.convertFromAPInt(HugeInt, /*IsSigned=*/false, RM);
    const bool Overflow = RM == APFloat::rmTowardPositive ||
                          RM == APFloat::rmNearestTiesToAway ||
                          RM == APFloat::rmNearestTiesToEven;
    if (Overflow) {
      EXPECT_TRUE(F.isPosInfinity()) << F;
      EXPECT_EQ(ConvertFromStatus, APFloat::opInexact | APFloat::opOverflow);
    } else {
      EXPECT_EQ(F, Largest);
      EXPECT_EQ(ConvertFromStatus, APFloat::opInexact);
    }
  }

  HugeInt.clearAllBits();
  HugeInt.setBit(2 * Binary64Precision + 1);
  HugeInt.setLowBits(Binary64Precision + 1);
  for (const APFloat::roundingMode RM :
       {APFloat::rmNearestTiesToAway, APFloat::rmTowardNegative,
        APFloat::rmTowardPositive, APFloat::rmTowardZero,
        APFloat::rmNearestTiesToEven}) {
    const APFloat RoundUp = makeDoubleAPFloat(0x1p107, 0x1p54);
    const APFloat RoundDown = makeDoubleAPFloat(0x1p107, 0x1.fffffffffffffp53);
    APFloat F{APFloat::PPCDoubleDouble()};
    const APFloat::opStatus ConvertFromStatus =
        F.convertFromAPInt(HugeInt, /*IsSigned=*/false, RM);
    EXPECT_EQ(ConvertFromStatus, APFloat::opInexact);

    if (RM == APFloat::rmNearestTiesToEven ||
        RM == APFloat::rmNearestTiesToAway || RM == APFloat::rmTowardPositive)
      EXPECT_EQ(F, RoundUp);
    else
      EXPECT_EQ(F, RoundDown);
  }

  ++HugeInt;
  // 162259276829213381405976519770112 can be represented exactly.
  for (const APFloat::roundingMode RM :
       {APFloat::rmNearestTiesToAway, APFloat::rmTowardNegative,
        APFloat::rmTowardPositive, APFloat::rmTowardZero,
        APFloat::rmNearestTiesToEven}) {
    const APFloat Exact = makeDoubleAPFloat(0x1p107, 0x1p54);
    APFloat F{APFloat::PPCDoubleDouble()};
    const APFloat::opStatus ConvertFromStatus =
        F.convertFromAPInt(HugeInt, /*IsSigned=*/false, RM);
    EXPECT_EQ(ConvertFromStatus, APFloat::opOK);
    EXPECT_EQ(F, Exact);
  }

  ++HugeInt;
  // 162259276829213381405976519770113 rounds to either:
  // 162259276829213381405976519770112
  // 162259276829213381405976519770114
  for (const APFloat::roundingMode RM :
       {APFloat::rmNearestTiesToAway, APFloat::rmTowardNegative,
        APFloat::rmTowardPositive, APFloat::rmTowardZero,
        APFloat::rmNearestTiesToEven}) {
    const APFloat RoundUp =
        makeDoubleAPFloat(0x1.0000000000001p107, -0x1.fffffffffffffp53);
    const APFloat RoundDown = makeDoubleAPFloat(0x1p107, 0x1p54);
    EXPECT_LT(RoundDown, RoundUp);

    APFloat F{APFloat::PPCDoubleDouble()};
    const APFloat::opStatus ConvertFromStatus =
        F.convertFromAPInt(HugeInt, /*IsSigned=*/false, RM);
    EXPECT_EQ(ConvertFromStatus, APFloat::opInexact);

    if (RM == APFloat::rmNearestTiesToAway || RM == APFloat::rmTowardPositive)
      EXPECT_EQ(F, RoundUp);
    else
      EXPECT_EQ(F, RoundDown);
  }
}

TEST(APFloatTest, x87Largest) {
  APFloat MaxX87Val = APFloat::getLargest(APFloat::x87DoubleExtended());
  EXPECT_TRUE(MaxX87Val.isLargest());
}

TEST(APFloatTest, x87Next) {
  APFloat F(APFloat::x87DoubleExtended(), "-1.0");
  F.next(false);
  EXPECT_TRUE(ilogb(F) == -1);
}

static APInt makeX87Bits(bool sign, int64_t exponent, int integerBit,
                         int64_t significand) {
  return (APInt(80, (sign ? 1 : 0)) << 79) | (APInt(80, exponent) << 64) |
         (APInt(80, integerBit) << 63) | APInt(80, significand);
}

static APFloat makeX87FromBits(bool sign, int64_t exponent, int integerBit,
                               int64_t significand) {
  return APFloat(APFloatBase::x87DoubleExtended(),
                 makeX87Bits(sign, exponent, integerBit, significand));
}

static APFloat makeX87(float value) {
  bool losesInfo = false;
  APFloat apf(value);
  apf.convert(APFloatBase::x87DoubleExtended(),
              llvm::APFloat::rmNearestTiesToEven, &losesInfo);
  return apf;
}

TEST(APFloatTest, x87Bits) {
  constexpr int bias = 16383;
  EXPECT_TRUE(makeX87FromBits(false, 0, 0, 0).bitwiseIsEqual(makeX87(0.0)));
  EXPECT_TRUE(makeX87FromBits(false, bias, 1, 0).bitwiseIsEqual(makeX87(1.0)));

  EXPECT_TRUE(
      makeX87FromBits(false, bias + 1, 1, 0).bitwiseIsEqual(makeX87(2.0)));
  EXPECT_TRUE(
      makeX87FromBits(true, bias + 1, 1, 0).bitwiseIsEqual(makeX87(-2.0)));
  EXPECT_TRUE(
      makeX87FromBits(false, bias + 2, 1, 0).bitwiseIsEqual(makeX87(4.0)));
  EXPECT_TRUE(
      makeX87FromBits(true, bias + 2, 1, 0).bitwiseIsEqual(makeX87(-4.0)));
  EXPECT_TRUE(
      makeX87FromBits(false, bias + 8, 1, 0).bitwiseIsEqual(makeX87(256.0)));
  EXPECT_TRUE(
      makeX87FromBits(true, bias + 8, 1, 0).bitwiseIsEqual(makeX87(-256.0)));

  EXPECT_EQ(makeX87FromBits(false, (1u << 14u) - 1u, 1, 0).bitcastToAPInt(),
            APInt(80, 0x7fff) << 63);
  EXPECT_EQ(
      makeX87FromBits(false, (1ull << 14ull) - 1ull, 1, (1ull << 63ull) - 1ull)
          .bitcastToAPInt(),
      (APInt(80, 1) << 78) - 1);

  const fltSemantics &S = APFloat::x87DoubleExtended();

  // Test valid infinity: exp=0x7fff, int_bit=1, significand=0
  {
    APFloat inf(S, APInt(80, {0x8000000000000000ull, 0x7fffull}));
    EXPECT_TRUE(inf.isInfinity());
    EXPECT_FALSE(inf.isNaN());
    EXPECT_TRUE(inf.bitwiseIsEqual(APFloat::getInf(S, false)));
  }

  // Test valid NaN: exp=0x7fff, int_bit=1, significand!=0
  {
    APFloat nan(S, APInt(80, {0xC000000000000000ull, 0x7fffull}));
    EXPECT_TRUE(nan.isNaN());
    EXPECT_FALSE(nan.isInfinity());
  }

  // Test pseudoinfinity: exp=0x7fff, int_bit=0, significand=0
  // Is treated as NaN in APFloat, see IEEEFloat::initFromF80LongDoubleAPInt
  {
    APFloat pseudoInf(S, APInt(80, {0x0000000000000000ull, 0x7fffull}));
    EXPECT_TRUE(pseudoInf.isNaN());
    EXPECT_TRUE(pseudoInf.isSignaling());
    EXPECT_FALSE(pseudoInf.isInfinity());
  }

  // Test pseudoNaN: exp=0x7fff, int_bit=0, significand!=0
  // Is treated as NaN in APFloat, see IEEEFloat::initFromF80LongDoubleAPInt
  {
    APFloat pseudoNan(S, APInt(80, {0x4000000000000000ull, 0x7fffull}));
    EXPECT_TRUE(pseudoNan.isNaN());
    EXPECT_FALSE(pseudoNan.isInfinity());
  }

  // Test unnormal: exp!=0 and !=0x7fff, int_bit=0
  // Is treated as NaN in APFloat, see IEEEFloat::initFromF80LongDoubleAPInt
  {
    APFloat unnormal(S, APInt(80, {0x4000000000000000ull, 0x4000ull}));
    EXPECT_TRUE(unnormal.isNaN());
    EXPECT_FALSE(unnormal.isSignaling());
  }

  // Test pseudodenormal: exp=0, integer int_bit=1
  {
    APFloat pseudoDenormal(APFloat::x87DoubleExtended(),
                           makeX87Bits(false, 0, 1, 0));
    EXPECT_TRUE(pseudoDenormal.isFinite());
    EXPECT_FALSE(pseudoDenormal.isDenormal());
    APFloat scale(APFloat::x87DoubleExtended(),
                  makeX87Bits(false, bias * 2 - 1, 1, 0));
    EXPECT_TRUE((pseudoDenormal * scale).bitwiseIsEqual(makeX87(1.0)));
  }

  // Test pseudodenormal with non-zero significand
  {
    APFloat pseudoDenormal(S, makeX87Bits(false, 0, 1, 0x7FFF000000000000ull));
    EXPECT_TRUE(pseudoDenormal.isFinite());
    EXPECT_FALSE(pseudoDenormal.isDenormal());
    EXPECT_TRUE(pseudoDenormal.isNormal());

    // Verify the round-trip produces the normalized form
    APInt result = pseudoDenormal.bitcastToAPInt();
    APInt expected(80, {0xFFFF000000000000ull, 0x0001ull});
    EXPECT_EQ(expected, result);
  }
}

static bool isBitcastRoundtripSafe(APFloat value) {
  APInt bits = value.bitcastToAPInt();
  APFloat fromBits = APFloat(value.getSemantics(), bits);
  return (value.isNaN() || value == fromBits) && value.bitwiseIsEqual(fromBits);
}

TEST(APFloatTest, bitcast) {
  // 4, 6, and 8 bit types are handled in Float[468]ExhaustivePair below
  for (APFloat::Semantics Sem : {
           APFloat::S_IEEEhalf,
           APFloat::S_BFloat,
           APFloat::S_IEEEsingle,
           APFloat::S_IEEEdouble,
           APFloat::S_IEEEquad,
           APFloat::S_PPCDoubleDouble,
           APFloat::S_Float8E5M2,
           APFloat::S_Float8E4M3,
           APFloat::S_Float8E3M4,
           APFloat::S_FloatTF32,
           APFloat::S_x87DoubleExtended,
       }) {
    const fltSemantics &S = APFloatBase::EnumToSemantics(Sem);

    EXPECT_TRUE(isBitcastRoundtripSafe(APFloat::getZero(S, false)));
    EXPECT_TRUE(isBitcastRoundtripSafe(APFloat::getZero(S, true)));
    EXPECT_TRUE(isBitcastRoundtripSafe(APFloat::getOne(S, false)));
    EXPECT_TRUE(isBitcastRoundtripSafe(APFloat::getOne(S, true)));
    EXPECT_TRUE(isBitcastRoundtripSafe(APFloat::getLargest(S, false)));
    EXPECT_TRUE(isBitcastRoundtripSafe(APFloat::getLargest(S, true)));
    EXPECT_TRUE(isBitcastRoundtripSafe(APFloat::getSmallest(S, false)));
    EXPECT_TRUE(isBitcastRoundtripSafe(APFloat::getSmallest(S, true)));
    EXPECT_TRUE(
        isBitcastRoundtripSafe(APFloat::getSmallestNormalized(S, false)));
    EXPECT_TRUE(
        isBitcastRoundtripSafe(APFloat::getSmallestNormalized(S, true)));
    EXPECT_TRUE(isBitcastRoundtripSafe(APFloat::getInf(S, false)));
    EXPECT_TRUE(isBitcastRoundtripSafe(APFloat::getInf(S, true)));
    EXPECT_TRUE(isBitcastRoundtripSafe(APFloat::getQNaN(S, false)));
    EXPECT_TRUE(isBitcastRoundtripSafe(APFloat::getQNaN(S, true)));
    EXPECT_TRUE(isBitcastRoundtripSafe(APFloat::getSNaN(S, false)));
    EXPECT_TRUE(isBitcastRoundtripSafe(APFloat::getSNaN(S, true)));
  }

  {
    // PPCDoubleDoubleLegacy format supports most but not all operations
    const fltSemantics &S =
        APFloatBase::EnumToSemantics(APFloat::S_PPCDoubleDoubleLegacy);
    EXPECT_TRUE(isBitcastRoundtripSafe(APFloat::getZero(S, false)));
    EXPECT_TRUE(isBitcastRoundtripSafe(APFloat::getZero(S, true)));
    EXPECT_TRUE(isBitcastRoundtripSafe(APFloat::getOne(S, false)));
    EXPECT_TRUE(isBitcastRoundtripSafe(APFloat::getOne(S, true)));
    EXPECT_TRUE(isBitcastRoundtripSafe(APFloat::getSmallest(S, false)));
    EXPECT_TRUE(isBitcastRoundtripSafe(APFloat::getSmallest(S, true)));
    EXPECT_TRUE(
        isBitcastRoundtripSafe(APFloat::getSmallestNormalized(S, false)));
    EXPECT_TRUE(
        isBitcastRoundtripSafe(APFloat::getSmallestNormalized(S, true)));
    EXPECT_TRUE(isBitcastRoundtripSafe(APFloat::getInf(S, false)));
    EXPECT_TRUE(isBitcastRoundtripSafe(APFloat::getInf(S, true)));
    EXPECT_TRUE(isBitcastRoundtripSafe(APFloat::getQNaN(S, false)));
    EXPECT_TRUE(isBitcastRoundtripSafe(APFloat::getQNaN(S, true)));
  }
}

TEST(APFloatTest, Float8ExhaustivePair) {
  // Test each pair of 8-bit floats with non-standard semantics
  for (APFloat::Semantics Sem :
       {APFloat::S_Float8E4M3FN, APFloat::S_Float8E5M2FNUZ,
        APFloat::S_Float8E4M3FNUZ, APFloat::S_Float8E4M3B11FNUZ}) {
    const llvm::fltSemantics &S = APFloat::EnumToSemantics(Sem);
    for (int i = 0; i < 256; i++) {
      for (int j = 0; j < 256; j++) {
        SCOPED_TRACE("sem=" + std::to_string(Sem) + ",i=" + std::to_string(i) +
                     ",j=" + std::to_string(j));
        APFloat x(S, APInt(8, i));
        APFloat y(S, APInt(8, j));

        bool losesInfo;
        APFloat x16 = x;
        x16.convert(APFloat::IEEEhalf(), APFloat::rmNearestTiesToEven,
                    &losesInfo);
        EXPECT_FALSE(losesInfo);
        APFloat y16 = y;
        y16.convert(APFloat::IEEEhalf(), APFloat::rmNearestTiesToEven,
                    &losesInfo);
        EXPECT_FALSE(losesInfo);

        // Add
        APFloat z = x;
        z.add(y, APFloat::rmNearestTiesToEven);
        APFloat z16 = x16;
        z16.add(y16, APFloat::rmNearestTiesToEven);
        z16.convert(S, APFloat::rmNearestTiesToEven, &losesInfo);
        EXPECT_TRUE(z.bitwiseIsEqual(z16))
            << "sem=" << Sem << ", i=" << i << ", j=" << j;

        // Subtract
        z = x;
        z.subtract(y, APFloat::rmNearestTiesToEven);
        z16 = x16;
        z16.subtract(y16, APFloat::rmNearestTiesToEven);
        z16.convert(S, APFloat::rmNearestTiesToEven, &losesInfo);
        EXPECT_TRUE(z.bitwiseIsEqual(z16))
            << "sem=" << Sem << ", i=" << i << ", j=" << j;

        // Multiply
        z = x;
        z.multiply(y, APFloat::rmNearestTiesToEven);
        z16 = x16;
        z16.multiply(y16, APFloat::rmNearestTiesToEven);
        z16.convert(S, APFloat::rmNearestTiesToEven, &losesInfo);
        EXPECT_TRUE(z.bitwiseIsEqual(z16))
            << "sem=" << Sem << ", i=" << i << ", j=" << j;

        // Divide
        z = x;
        z.divide(y, APFloat::rmNearestTiesToEven);
        z16 = x16;
        z16.divide(y16, APFloat::rmNearestTiesToEven);
        z16.convert(S, APFloat::rmNearestTiesToEven, &losesInfo);
        EXPECT_TRUE(z.bitwiseIsEqual(z16))
            << "sem=" << Sem << ", i=" << i << ", j=" << j;

        // Mod
        z = x;
        z.mod(y);
        z16 = x16;
        z16.mod(y16);
        z16.convert(S, APFloat::rmNearestTiesToEven, &losesInfo);
        EXPECT_TRUE(z.bitwiseIsEqual(z16))
            << "sem=" << Sem << ", i=" << i << ", j=" << j;

        // Remainder
        z = x;
        z.remainder(y);
        z16 = x16;
        z16.remainder(y16);
        z16.convert(S, APFloat::rmNearestTiesToEven, &losesInfo);
        EXPECT_TRUE(z.bitwiseIsEqual(z16))
            << "sem=" << Sem << ", i=" << i << ", j=" << j;
      }
    }
  }
}

TEST(APFloatTest, Float8E8M0FNUExhaustivePair) {
  // Test each pair of 8-bit values for Float8E8M0FNU format
  APFloat::Semantics Sem = APFloat::S_Float8E8M0FNU;
  const llvm::fltSemantics &S = APFloat::EnumToSemantics(Sem);
  for (int i = 0; i < 256; i++) {
    for (int j = 0; j < 256; j++) {
      SCOPED_TRACE("sem=" + std::to_string(Sem) + ",i=" + std::to_string(i) +
                   ",j=" + std::to_string(j));
      APFloat x(S, APInt(8, i));
      APFloat y(S, APInt(8, j));

      bool losesInfo;
      APFloat xd = x;
      xd.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven,
                 &losesInfo);
      EXPECT_FALSE(losesInfo);
      APFloat yd = y;
      yd.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven,
                 &losesInfo);
      EXPECT_FALSE(losesInfo);

      // Add
      APFloat z = x;
      z.add(y, APFloat::rmNearestTiesToEven);
      APFloat zd = xd;
      zd.add(yd, APFloat::rmNearestTiesToEven);
      zd.convert(S, APFloat::rmNearestTiesToEven, &losesInfo);
      EXPECT_TRUE(z.bitwiseIsEqual(zd))
          << "sem=" << Sem << ", i=" << i << ", j=" << j;

      // Subtract
      if (i >= j) {
        z = x;
        z.subtract(y, APFloat::rmNearestTiesToEven);
        zd = xd;
        zd.subtract(yd, APFloat::rmNearestTiesToEven);
        zd.convert(S, APFloat::rmNearestTiesToEven, &losesInfo);
        EXPECT_TRUE(z.bitwiseIsEqual(zd))
            << "sem=" << Sem << ", i=" << i << ", j=" << j;
      }

      // Multiply
      z = x;
      z.multiply(y, APFloat::rmNearestTiesToEven);
      zd = xd;
      zd.multiply(yd, APFloat::rmNearestTiesToEven);
      zd.convert(S, APFloat::rmNearestTiesToEven, &losesInfo);
      EXPECT_TRUE(z.bitwiseIsEqual(zd))
          << "sem=" << Sem << ", i=" << i << ", j=" << j;

      // Divide
      z = x;
      z.divide(y, APFloat::rmNearestTiesToEven);
      zd = xd;
      zd.divide(yd, APFloat::rmNearestTiesToEven);
      zd.convert(S, APFloat::rmNearestTiesToEven, &losesInfo);
      EXPECT_TRUE(z.bitwiseIsEqual(zd))
          << "sem=" << Sem << ", i=" << i << ", j=" << j;

      // Mod
      z = x;
      z.mod(y);
      zd = xd;
      zd.mod(yd);
      zd.convert(S, APFloat::rmNearestTiesToEven, &losesInfo);
      EXPECT_TRUE(z.bitwiseIsEqual(zd))
          << "sem=" << Sem << ", i=" << i << ", j=" << j;
      APFloat mod_cached = z;
      // When one of them is a NaN, the result is a NaN.
      // When i < j, the mod is 'i' since it is the smaller
      // number. Otherwise the mod is always zero since
      // both x and y are powers-of-two in this format.
      // Since this format does not support zero and it is
      // represented as the smallest normalized value, we
      // test for isSmallestNormalized().
      if (i == 255 || j == 255)
        EXPECT_TRUE(z.isNaN());
      else if (i >= j)
        EXPECT_TRUE(z.isSmallestNormalized());
      else
        EXPECT_TRUE(z.bitwiseIsEqual(x));

      // Remainder
      z = x;
      z.remainder(y);
      zd = xd;
      zd.remainder(yd);
      zd.convert(S, APFloat::rmNearestTiesToEven, &losesInfo);
      EXPECT_TRUE(z.bitwiseIsEqual(zd))
          << "sem=" << Sem << ", i=" << i << ", j=" << j;
      // Since this format has only exponents (i.e. no precision)
      // we expect the remainder and mod to provide the same results.
      EXPECT_TRUE(z.bitwiseIsEqual(mod_cached))
          << "sem=" << Sem << ", i=" << i << ", j=" << j;
    }
  }
}

TEST(APFloatTest, Float6ExhaustivePair) {
  // Test each pair of 6-bit floats with non-standard semantics
  for (APFloat::Semantics Sem :
       {APFloat::S_Float6E3M2FN, APFloat::S_Float6E2M3FN}) {
    const llvm::fltSemantics &S = APFloat::EnumToSemantics(Sem);
    for (int i = 1; i < 64; i++) {
      for (int j = 1; j < 64; j++) {
        SCOPED_TRACE("sem=" + std::to_string(Sem) + ",i=" + std::to_string(i) +
                     ",j=" + std::to_string(j));
        APFloat x(S, APInt(6, i));
        APFloat y(S, APInt(6, j));

        bool losesInfo;
        APFloat x16 = x;
        x16.convert(APFloat::IEEEhalf(), APFloat::rmNearestTiesToEven,
                    &losesInfo);
        EXPECT_FALSE(losesInfo);
        APFloat y16 = y;
        y16.convert(APFloat::IEEEhalf(), APFloat::rmNearestTiesToEven,
                    &losesInfo);
        EXPECT_FALSE(losesInfo);

        // Add
        APFloat z = x;
        z.add(y, APFloat::rmNearestTiesToEven);
        APFloat z16 = x16;
        z16.add(y16, APFloat::rmNearestTiesToEven);
        z16.convert(S, APFloat::rmNearestTiesToEven, &losesInfo);
        EXPECT_TRUE(z.bitwiseIsEqual(z16))
            << "sem=" << Sem << ", i=" << i << ", j=" << j;

        // Subtract
        z = x;
        z.subtract(y, APFloat::rmNearestTiesToEven);
        z16 = x16;
        z16.subtract(y16, APFloat::rmNearestTiesToEven);
        z16.convert(S, APFloat::rmNearestTiesToEven, &losesInfo);
        EXPECT_TRUE(z.bitwiseIsEqual(z16))
            << "sem=" << Sem << ", i=" << i << ", j=" << j;

        // Multiply
        z = x;
        z.multiply(y, APFloat::rmNearestTiesToEven);
        z16 = x16;
        z16.multiply(y16, APFloat::rmNearestTiesToEven);
        z16.convert(S, APFloat::rmNearestTiesToEven, &losesInfo);
        EXPECT_TRUE(z.bitwiseIsEqual(z16))
            << "sem=" << Sem << ", i=" << i << ", j=" << j;

        // Skip divide by 0
        if (j == 0 || j == 32)
          continue;

        // Divide
        z = x;
        z.divide(y, APFloat::rmNearestTiesToEven);
        z16 = x16;
        z16.divide(y16, APFloat::rmNearestTiesToEven);
        z16.convert(S, APFloat::rmNearestTiesToEven, &losesInfo);
        EXPECT_TRUE(z.bitwiseIsEqual(z16))
            << "sem=" << Sem << ", i=" << i << ", j=" << j;

        // Mod
        z = x;
        z.mod(y);
        z16 = x16;
        z16.mod(y16);
        z16.convert(S, APFloat::rmNearestTiesToEven, &losesInfo);
        EXPECT_TRUE(z.bitwiseIsEqual(z16))
            << "sem=" << Sem << ", i=" << i << ", j=" << j;

        // Remainder
        z = x;
        z.remainder(y);
        z16 = x16;
        z16.remainder(y16);
        z16.convert(S, APFloat::rmNearestTiesToEven, &losesInfo);
        EXPECT_TRUE(z.bitwiseIsEqual(z16))
            << "sem=" << Sem << ", i=" << i << ", j=" << j;
      }
    }
  }
}

TEST(APFloatTest, Float4ExhaustivePair) {
  // Test each pair of 4-bit floats with non-standard semantics
  for (APFloat::Semantics Sem : {APFloat::S_Float4E2M1FN}) {
    const llvm::fltSemantics &S = APFloat::EnumToSemantics(Sem);
    for (int i = 0; i < 16; i++) {
      for (int j = 0; j < 16; j++) {
        SCOPED_TRACE("sem=" + std::to_string(Sem) + ",i=" + std::to_string(i) +
                     ",j=" + std::to_string(j));
        APFloat x(S, APInt(4, i));
        APFloat y(S, APInt(4, j));

        bool losesInfo;
        APFloat x16 = x;
        x16.convert(APFloat::IEEEhalf(), APFloat::rmNearestTiesToEven,
                    &losesInfo);
        EXPECT_FALSE(losesInfo);
        APFloat y16 = y;
        y16.convert(APFloat::IEEEhalf(), APFloat::rmNearestTiesToEven,
                    &losesInfo);
        EXPECT_FALSE(losesInfo);

        // Add
        APFloat z = x;
        z.add(y, APFloat::rmNearestTiesToEven);
        APFloat z16 = x16;
        z16.add(y16, APFloat::rmNearestTiesToEven);
        z16.convert(S, APFloat::rmNearestTiesToEven, &losesInfo);
        EXPECT_TRUE(z.bitwiseIsEqual(z16))
            << "sem=" << Sem << ", i=" << i << ", j=" << j;

        // Subtract
        z = x;
        z.subtract(y, APFloat::rmNearestTiesToEven);
        z16 = x16;
        z16.subtract(y16, APFloat::rmNearestTiesToEven);
        z16.convert(S, APFloat::rmNearestTiesToEven, &losesInfo);
        EXPECT_TRUE(z.bitwiseIsEqual(z16))
            << "sem=" << Sem << ", i=" << i << ", j=" << j;

        // Multiply
        z = x;
        z.multiply(y, APFloat::rmNearestTiesToEven);
        z16 = x16;
        z16.multiply(y16, APFloat::rmNearestTiesToEven);
        z16.convert(S, APFloat::rmNearestTiesToEven, &losesInfo);
        EXPECT_TRUE(z.bitwiseIsEqual(z16))
            << "sem=" << Sem << ", i=" << i << ", j=" << j;

        // Skip divide by 0
        if (j == 0 || j == 8)
          continue;

        // Divide
        z = x;
        z.divide(y, APFloat::rmNearestTiesToEven);
        z16 = x16;
        z16.divide(y16, APFloat::rmNearestTiesToEven);
        z16.convert(S, APFloat::rmNearestTiesToEven, &losesInfo);
        EXPECT_TRUE(z.bitwiseIsEqual(z16))
            << "sem=" << Sem << ", i=" << i << ", j=" << j;

        // Mod
        z = x;
        z.mod(y);
        z16 = x16;
        z16.mod(y16);
        z16.convert(S, APFloat::rmNearestTiesToEven, &losesInfo);
        EXPECT_TRUE(z.bitwiseIsEqual(z16))
            << "sem=" << Sem << ", i=" << i << ", j=" << j;

        // Remainder
        z = x;
        z.remainder(y);
        z16 = x16;
        z16.remainder(y16);
        z16.convert(S, APFloat::rmNearestTiesToEven, &losesInfo);
        EXPECT_TRUE(z.bitwiseIsEqual(z16))
            << "sem=" << Sem << ", i=" << i << ", j=" << j;
      }
    }
  }
}

TEST(APFloatTest, ConvertE4M3FNToE5M2) {
  bool losesInfo;
  APFloat test(APFloat::Float8E4M3FN(), "1.0");
  APFloat::opStatus status = test.convert(
      APFloat::Float8E5M2(), APFloat::rmNearestTiesToEven, &losesInfo);
  EXPECT_EQ(1.0f, test.convertToFloat());
  EXPECT_FALSE(losesInfo);
  EXPECT_EQ(status, APFloat::opOK);

  test = APFloat(APFloat::Float8E4M3FN(), "0.0");
  status = test.convert(APFloat::Float8E5M2(), APFloat::rmNearestTiesToEven,
                        &losesInfo);
  EXPECT_EQ(0.0f, test.convertToFloat());
  EXPECT_FALSE(losesInfo);
  EXPECT_EQ(status, APFloat::opOK);

  test = APFloat(APFloat::Float8E4M3FN(), "0x1.2p0"); // 1.125
  status = test.convert(APFloat::Float8E5M2(), APFloat::rmNearestTiesToEven,
                        &losesInfo);
  EXPECT_EQ(0x1.0p0 /* 1.0 */, test.convertToFloat());
  EXPECT_TRUE(losesInfo);
  EXPECT_EQ(status, APFloat::opInexact);

  test = APFloat(APFloat::Float8E4M3FN(), "0x1.6p0"); // 1.375
  status = test.convert(APFloat::Float8E5M2(), APFloat::rmNearestTiesToEven,
                        &losesInfo);
  EXPECT_EQ(0x1.8p0 /* 1.5 */, test.convertToFloat());
  EXPECT_TRUE(losesInfo);
  EXPECT_EQ(status, APFloat::opInexact);

  // Convert E4M3FN denormal to E5M2 normal. Should not be truncated, despite
  // the destination format having one fewer significand bit
  test = APFloat(APFloat::Float8E4M3FN(), "0x1.Cp-7");
  status = test.convert(APFloat::Float8E5M2(), APFloat::rmNearestTiesToEven,
                        &losesInfo);
  EXPECT_EQ(0x1.Cp-7, test.convertToFloat());
  EXPECT_FALSE(losesInfo);
  EXPECT_EQ(status, APFloat::opOK);

  // Test convert from NaN
  test = APFloat(APFloat::Float8E4M3FN(), "nan");
  status = test.convert(APFloat::Float8E5M2(), APFloat::rmNearestTiesToEven,
                        &losesInfo);
  EXPECT_TRUE(std::isnan(test.convertToFloat()));
  EXPECT_FALSE(losesInfo);
  EXPECT_EQ(status, APFloat::opOK);
}

TEST(APFloatTest, ConvertE5M2ToE4M3FN) {
  bool losesInfo;
  APFloat test(APFloat::Float8E5M2(), "1.0");
  APFloat::opStatus status = test.convert(
      APFloat::Float8E4M3FN(), APFloat::rmNearestTiesToEven, &losesInfo);
  EXPECT_EQ(1.0f, test.convertToFloat());
  EXPECT_FALSE(losesInfo);
  EXPECT_EQ(status, APFloat::opOK);

  test = APFloat(APFloat::Float8E5M2(), "0.0");
  status = test.convert(APFloat::Float8E4M3FN(), APFloat::rmNearestTiesToEven,
                        &losesInfo);
  EXPECT_EQ(0.0f, test.convertToFloat());
  EXPECT_FALSE(losesInfo);
  EXPECT_EQ(status, APFloat::opOK);

  test = APFloat(APFloat::Float8E5M2(), "0x1.Cp8"); // 448
  status = test.convert(APFloat::Float8E4M3FN(), APFloat::rmNearestTiesToEven,
                        &losesInfo);
  EXPECT_EQ(0x1.Cp8 /* 448 */, test.convertToFloat());
  EXPECT_FALSE(losesInfo);
  EXPECT_EQ(status, APFloat::opOK);

  // Test overflow
  test = APFloat(APFloat::Float8E5M2(), "0x1.0p9"); // 512
  status = test.convert(APFloat::Float8E4M3FN(), APFloat::rmNearestTiesToEven,
                        &losesInfo);
  EXPECT_TRUE(std::isnan(test.convertToFloat()));
  EXPECT_TRUE(losesInfo);
  EXPECT_EQ(status, APFloat::opOverflow | APFloat::opInexact);

  // Test underflow
  test = APFloat(APFloat::Float8E5M2(), "0x1.0p-10");
  status = test.convert(APFloat::Float8E4M3FN(), APFloat::rmNearestTiesToEven,
                        &losesInfo);
  EXPECT_EQ(0., test.convertToFloat());
  EXPECT_TRUE(losesInfo);
  EXPECT_EQ(status, APFloat::opUnderflow | APFloat::opInexact);

  // Test rounding up to smallest denormal number
  test = APFloat(APFloat::Float8E5M2(), "0x1.8p-10");
  status = test.convert(APFloat::Float8E4M3FN(), APFloat::rmNearestTiesToEven,
                        &losesInfo);
  EXPECT_EQ(0x1.0p-9, test.convertToFloat());
  EXPECT_TRUE(losesInfo);
  EXPECT_EQ(status, APFloat::opUnderflow | APFloat::opInexact);

  // Testing inexact rounding to denormal number
  test = APFloat(APFloat::Float8E5M2(), "0x1.8p-9");
  status = test.convert(APFloat::Float8E4M3FN(), APFloat::rmNearestTiesToEven,
                        &losesInfo);
  EXPECT_EQ(0x1.0p-8, test.convertToFloat());
  EXPECT_TRUE(losesInfo);
  EXPECT_EQ(status, APFloat::opUnderflow | APFloat::opInexact);

  APFloat nan = APFloat(APFloat::Float8E4M3FN(), "nan");

  // Testing convert from Inf
  test = APFloat(APFloat::Float8E5M2(), "inf");
  status = test.convert(APFloat::Float8E4M3FN(), APFloat::rmNearestTiesToEven,
                        &losesInfo);
  EXPECT_TRUE(std::isnan(test.convertToFloat()));
  EXPECT_TRUE(losesInfo);
  EXPECT_EQ(status, APFloat::opInexact);
  EXPECT_TRUE(test.bitwiseIsEqual(nan));

  // Testing convert from quiet NaN
  test = APFloat(APFloat::Float8E5M2(), "nan");
  status = test.convert(APFloat::Float8E4M3FN(), APFloat::rmNearestTiesToEven,
                        &losesInfo);
  EXPECT_TRUE(std::isnan(test.convertToFloat()));
  EXPECT_TRUE(losesInfo);
  EXPECT_EQ(status, APFloat::opOK);
  EXPECT_TRUE(test.bitwiseIsEqual(nan));

  // Testing convert from signaling NaN
  test = APFloat(APFloat::Float8E5M2(), "snan");
  status = test.convert(APFloat::Float8E4M3FN(), APFloat::rmNearestTiesToEven,
                        &losesInfo);
  EXPECT_TRUE(std::isnan(test.convertToFloat()));
  EXPECT_TRUE(losesInfo);
  EXPECT_EQ(status, APFloat::opInvalidOp);
  EXPECT_TRUE(test.bitwiseIsEqual(nan));
}

TEST(APFloatTest, Float8E4M3FNGetInf) {
  APFloat t = APFloat::getInf(APFloat::Float8E4M3FN());
  EXPECT_TRUE(t.isNaN());
  EXPECT_FALSE(t.isInfinity());
}

TEST(APFloatTest, Float8E4M3FNFromString) {
  // Exactly representable
  EXPECT_EQ(448, APFloat(APFloat::Float8E4M3FN(), "448").convertToDouble());
  // Round down to maximum value
  EXPECT_EQ(448, APFloat(APFloat::Float8E4M3FN(), "464").convertToDouble());
  // Round up, causing overflow to NaN
  EXPECT_TRUE(APFloat(APFloat::Float8E4M3FN(), "465").isNaN());
  // Overflow without rounding
  EXPECT_TRUE(APFloat(APFloat::Float8E4M3FN(), "480").isNaN());
  // Inf converted to NaN
  EXPECT_TRUE(APFloat(APFloat::Float8E4M3FN(), "inf").isNaN());
  // NaN converted to NaN
  EXPECT_TRUE(APFloat(APFloat::Float8E4M3FN(), "nan").isNaN());
}

TEST(APFloatTest, Float8E4M3FNAdd) {
  APFloat QNaN = APFloat::getNaN(APFloat::Float8E4M3FN(), false);

  auto FromStr = [](StringRef S) {
    return APFloat(APFloat::Float8E4M3FN(), S);
  };

  struct {
    APFloat x;
    APFloat y;
    const char *result;
    int status;
    int category;
    APFloat::roundingMode roundingMode = APFloat::rmNearestTiesToEven;
  } AdditionTests[] = {
      // Test addition operations involving NaN, overflow, and the max E4M3FN
      // value (448) because E4M3FN differs from IEEE-754 types in these regards
      {FromStr("448"), FromStr("16"), "448", APFloat::opInexact,
       APFloat::fcNormal},
      {FromStr("448"), FromStr("18"), "NaN",
       APFloat::opOverflow | APFloat::opInexact, APFloat::fcNaN},
      {FromStr("448"), FromStr("32"), "NaN",
       APFloat::opOverflow | APFloat::opInexact, APFloat::fcNaN},
      {FromStr("-448"), FromStr("-32"), "-NaN",
       APFloat::opOverflow | APFloat::opInexact, APFloat::fcNaN},
      {QNaN, FromStr("-448"), "NaN", APFloat::opOK, APFloat::fcNaN},
      {FromStr("448"), FromStr("-32"), "416", APFloat::opOK, APFloat::fcNormal},
      {FromStr("448"), FromStr("0"), "448", APFloat::opOK, APFloat::fcNormal},
      {FromStr("448"), FromStr("32"), "448", APFloat::opInexact,
       APFloat::fcNormal, APFloat::rmTowardZero},
      {FromStr("448"), FromStr("448"), "448", APFloat::opInexact,
       APFloat::fcNormal, APFloat::rmTowardZero},
  };

  for (size_t i = 0; i < std::size(AdditionTests); ++i) {
    APFloat x(AdditionTests[i].x);
    APFloat y(AdditionTests[i].y);
    APFloat::opStatus status = x.add(y, AdditionTests[i].roundingMode);

    APFloat result(APFloat::Float8E4M3FN(), AdditionTests[i].result);

    EXPECT_TRUE(result.bitwiseIsEqual(x));
    EXPECT_EQ(AdditionTests[i].status, (int)status);
    EXPECT_EQ(AdditionTests[i].category, (int)x.getCategory());
  }
}

TEST(APFloatTest, Float8E4M3FNDivideByZero) {
  APFloat x(APFloat::Float8E4M3FN(), "1");
  APFloat zero(APFloat::Float8E4M3FN(), "0");
  EXPECT_EQ(x.divide(zero, APFloat::rmNearestTiesToEven), APFloat::opDivByZero);
  EXPECT_TRUE(x.isNaN());
}

TEST(APFloatTest, Float8E4M3FNNext) {
  APFloat test(APFloat::Float8E4M3FN(), APFloat::uninitialized);
  APFloat expected(APFloat::Float8E4M3FN(), APFloat::uninitialized);

  // nextUp on positive numbers
  for (int i = 0; i < 127; i++) {
    test = APFloat(APFloat::Float8E4M3FN(), APInt(8, i));
    expected = APFloat(APFloat::Float8E4M3FN(), APInt(8, i + 1));
    EXPECT_EQ(test.next(false), APFloat::opOK);
    EXPECT_TRUE(test.bitwiseIsEqual(expected));
  }

  // nextUp on negative zero
  test = APFloat::getZero(APFloat::Float8E4M3FN(), true);
  expected = APFloat::getSmallest(APFloat::Float8E4M3FN(), false);
  EXPECT_EQ(test.next(false), APFloat::opOK);
  EXPECT_TRUE(test.bitwiseIsEqual(expected));

  // nextUp on negative nonzero numbers
  for (int i = 129; i < 255; i++) {
    test = APFloat(APFloat::Float8E4M3FN(), APInt(8, i));
    expected = APFloat(APFloat::Float8E4M3FN(), APInt(8, i - 1));
    EXPECT_EQ(test.next(false), APFloat::opOK);
    EXPECT_TRUE(test.bitwiseIsEqual(expected));
  }

  // nextUp on NaN
  test = APFloat::getQNaN(APFloat::Float8E4M3FN(), false);
  expected = APFloat::getQNaN(APFloat::Float8E4M3FN(), false);
  EXPECT_EQ(test.next(false), APFloat::opOK);
  EXPECT_TRUE(test.bitwiseIsEqual(expected));

  // nextDown on positive nonzero finite numbers
  for (int i = 1; i < 127; i++) {
    test = APFloat(APFloat::Float8E4M3FN(), APInt(8, i));
    expected = APFloat(APFloat::Float8E4M3FN(), APInt(8, i - 1));
    EXPECT_EQ(test.next(true), APFloat::opOK);
    EXPECT_TRUE(test.bitwiseIsEqual(expected));
  }

  // nextDown on positive zero
  test = APFloat::getZero(APFloat::Float8E4M3FN(), true);
  expected = APFloat::getSmallest(APFloat::Float8E4M3FN(), true);
  EXPECT_EQ(test.next(true), APFloat::opOK);
  EXPECT_TRUE(test.bitwiseIsEqual(expected));

  // nextDown on negative finite numbers
  for (int i = 128; i < 255; i++) {
    test = APFloat(APFloat::Float8E4M3FN(), APInt(8, i));
    expected = APFloat(APFloat::Float8E4M3FN(), APInt(8, i + 1));
    EXPECT_EQ(test.next(true), APFloat::opOK);
    EXPECT_TRUE(test.bitwiseIsEqual(expected));
  }

  // nextDown on NaN
  test = APFloat::getQNaN(APFloat::Float8E4M3FN(), false);
  expected = APFloat::getQNaN(APFloat::Float8E4M3FN(), false);
  EXPECT_EQ(test.next(true), APFloat::opOK);
  EXPECT_TRUE(test.bitwiseIsEqual(expected));
}

TEST(APFloatTest, Float8E4M3FNExhaustive) {
  // Test each of the 256 Float8E4M3FN values.
  for (int i = 0; i < 256; i++) {
    APFloat test(APFloat::Float8E4M3FN(), APInt(8, i));
    SCOPED_TRACE("i=" + std::to_string(i));

    // isLargest
    if (i == 126 || i == 254) {
      EXPECT_TRUE(test.isLargest());
      EXPECT_EQ(abs(test).convertToDouble(), 448.);
    } else {
      EXPECT_FALSE(test.isLargest());
    }

    // isSmallest
    if (i == 1 || i == 129) {
      EXPECT_TRUE(test.isSmallest());
      EXPECT_EQ(abs(test).convertToDouble(), 0x1p-9);
    } else {
      EXPECT_FALSE(test.isSmallest());
    }

    // convert to BFloat
    APFloat test2 = test;
    bool losesInfo;
    APFloat::opStatus status = test2.convert(
        APFloat::BFloat(), APFloat::rmNearestTiesToEven, &losesInfo);
    EXPECT_EQ(status, APFloat::opOK);
    EXPECT_FALSE(losesInfo);
    if (i == 127 || i == 255)
      EXPECT_TRUE(test2.isNaN());
    else
      EXPECT_EQ(test.convertToFloat(), test2.convertToFloat());

    // bitcastToAPInt
    EXPECT_EQ(i, test.bitcastToAPInt());
  }
}

TEST(APFloatTest, Float8E8M0FNUExhaustive) {
  // Test each of the 256 Float8E8M0FNU values.
  for (int i = 0; i < 256; i++) {
    APFloat test(APFloat::Float8E8M0FNU(), APInt(8, i));
    SCOPED_TRACE("i=" + std::to_string(i));

    // bitcastToAPInt
    EXPECT_EQ(i, test.bitcastToAPInt());

    // isLargest
    if (i == 254) {
      EXPECT_TRUE(test.isLargest());
      EXPECT_EQ(abs(test).convertToDouble(), 0x1.0p127);
    } else {
      EXPECT_FALSE(test.isLargest());
    }

    // isSmallest
    if (i == 0) {
      EXPECT_TRUE(test.isSmallest());
      EXPECT_EQ(abs(test).convertToDouble(), 0x1.0p-127);
    } else {
      EXPECT_FALSE(test.isSmallest());
    }

    // convert to Double
    bool losesInfo;
    std::string val = std::to_string(i - 127); // 127 is the bias
    llvm::SmallString<16> str("0x1.0p");
    str += val;
    APFloat test2(APFloat::IEEEdouble(), str);

    APFloat::opStatus status = test.convert(
        APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven, &losesInfo);
    EXPECT_EQ(status, APFloat::opOK);
    EXPECT_FALSE(losesInfo);
    if (i == 255)
      EXPECT_TRUE(test.isNaN());
    else
      EXPECT_EQ(test.convertToDouble(), test2.convertToDouble());
  }
}

TEST(APFloatTest, Float8E5M2FNUZNext) {
  APFloat test(APFloat::Float8E5M2FNUZ(), APFloat::uninitialized);
  APFloat expected(APFloat::Float8E5M2FNUZ(), APFloat::uninitialized);

  // 1. NextUp of largest bit pattern is nan
  test = APFloat::getLargest(APFloat::Float8E5M2FNUZ());
  expected = APFloat::getNaN(APFloat::Float8E5M2FNUZ());
  EXPECT_EQ(test.next(false), APFloat::opOK);
  EXPECT_FALSE(test.isInfinity());
  EXPECT_FALSE(test.isZero());
  EXPECT_TRUE(test.isNaN());
  EXPECT_TRUE(test.bitwiseIsEqual(expected));

  // 2. NextUp of smallest negative denormal is +0
  test = APFloat::getSmallest(APFloat::Float8E5M2FNUZ(), true);
  expected = APFloat::getZero(APFloat::Float8E5M2FNUZ(), false);
  EXPECT_EQ(test.next(false), APFloat::opOK);
  EXPECT_FALSE(test.isNegZero());
  EXPECT_TRUE(test.isPosZero());
  EXPECT_TRUE(test.bitwiseIsEqual(expected));

  // 3. nextDown of negative of largest value is NaN
  test = APFloat::getLargest(APFloat::Float8E5M2FNUZ(), true);
  expected = APFloat::getNaN(APFloat::Float8E5M2FNUZ());
  EXPECT_EQ(test.next(true), APFloat::opOK);
  EXPECT_FALSE(test.isInfinity());
  EXPECT_FALSE(test.isZero());
  EXPECT_TRUE(test.isNaN());
  EXPECT_TRUE(test.bitwiseIsEqual(expected));

  // 4. nextDown of +0 is smallest negative denormal
  test = APFloat::getZero(APFloat::Float8E5M2FNUZ(), false);
  expected = APFloat::getSmallest(APFloat::Float8E5M2FNUZ(), true);
  EXPECT_EQ(test.next(true), APFloat::opOK);
  EXPECT_FALSE(test.isZero());
  EXPECT_TRUE(test.isDenormal());
  EXPECT_TRUE(test.bitwiseIsEqual(expected));

  // 5. nextUp of NaN is NaN
  test = APFloat::getNaN(APFloat::Float8E5M2FNUZ(), false);
  expected = APFloat::getNaN(APFloat::Float8E5M2FNUZ(), true);
  EXPECT_EQ(test.next(false), APFloat::opOK);
  EXPECT_TRUE(test.isNaN());

  // 6. nextDown of NaN is NaN
  test = APFloat::getNaN(APFloat::Float8E5M2FNUZ(), false);
  expected = APFloat::getNaN(APFloat::Float8E5M2FNUZ(), true);
  EXPECT_EQ(test.next(true), APFloat::opOK);
  EXPECT_TRUE(test.isNaN());
}

TEST(APFloatTest, Float8E5M2FNUZChangeSign) {
  APFloat test = APFloat(APFloat::Float8E5M2FNUZ(), "1.0");
  APFloat expected = APFloat(APFloat::Float8E5M2FNUZ(), "-1.0");
  test.changeSign();
  EXPECT_TRUE(test.bitwiseIsEqual(expected));

  test = APFloat::getZero(APFloat::Float8E5M2FNUZ());
  expected = test;
  test.changeSign();
  EXPECT_TRUE(test.bitwiseIsEqual(expected));

  test = APFloat::getNaN(APFloat::Float8E5M2FNUZ());
  expected = test;
  test.changeSign();
  EXPECT_TRUE(test.bitwiseIsEqual(expected));
}

TEST(APFloatTest, Float8E5M2FNUZFromString) {
  // Exactly representable
  EXPECT_EQ(57344,
            APFloat(APFloat::Float8E5M2FNUZ(), "57344").convertToDouble());
  // Round down to maximum value
  EXPECT_EQ(57344,
            APFloat(APFloat::Float8E5M2FNUZ(), "59392").convertToDouble());
  // Round up, causing overflow to NaN
  EXPECT_TRUE(APFloat(APFloat::Float8E5M2FNUZ(), "61440").isNaN());
  // Overflow without rounding
  EXPECT_TRUE(APFloat(APFloat::Float8E5M2FNUZ(), "131072").isNaN());
  // Inf converted to NaN
  EXPECT_TRUE(APFloat(APFloat::Float8E5M2FNUZ(), "inf").isNaN());
  // NaN converted to NaN
  EXPECT_TRUE(APFloat(APFloat::Float8E5M2FNUZ(), "nan").isNaN());
  // Negative zero converted to positive zero
  EXPECT_TRUE(APFloat(APFloat::Float8E5M2FNUZ(), "-0").isPosZero());
}

TEST(APFloatTest, UnsignedZeroArithmeticSpecial) {
  // Float semantics with only unsigned zero (ex. Float8E4M3FNUZ) violate the
  // IEEE rules about signs in arithmetic operations when producing zeros,
  // because they only have one zero. Most of the rest of the complexities of
  // arithmetic on these values are covered by the other Float8 types' test
  // cases and so are not repeated here.

  // The IEEE round towards negative rule doesn't apply
  for (APFloat::Semantics S :
       {APFloat::S_Float8E4M3FNUZ, APFloat::S_Float8E4M3B11FNUZ}) {
    const llvm::fltSemantics &Sem = APFloat::EnumToSemantics(S);
    APFloat test = APFloat::getSmallest(Sem);
    APFloat rhs = test;
    EXPECT_EQ(test.subtract(rhs, APFloat::rmTowardNegative), APFloat::opOK);
    EXPECT_TRUE(test.isZero());
    EXPECT_FALSE(test.isNegative());

    // Multiplication of (small) * (-small) is +0
    test = APFloat::getSmallestNormalized(Sem);
    rhs = -test;
    EXPECT_EQ(test.multiply(rhs, APFloat::rmNearestTiesToAway),
              APFloat::opInexact | APFloat::opUnderflow);
    EXPECT_TRUE(test.isZero());
    EXPECT_FALSE(test.isNegative());

    // Dividing the negatize float_min by anything gives +0
    test = APFloat::getSmallest(Sem, true);
    rhs = APFloat(Sem, "2.0");
    EXPECT_EQ(test.divide(rhs, APFloat::rmNearestTiesToEven),
              APFloat::opInexact | APFloat::opUnderflow);
    EXPECT_TRUE(test.isZero());
    EXPECT_FALSE(test.isNegative());

    // Remainder can't copy sign because there's only one zero
    test = APFloat(Sem, "-4.0");
    rhs = APFloat(Sem, "2.0");
    EXPECT_EQ(test.remainder(rhs), APFloat::opOK);
    EXPECT_TRUE(test.isZero());
    EXPECT_FALSE(test.isNegative());

    // And same for mod
    test = APFloat(Sem, "-4.0");
    rhs = APFloat(Sem, "2.0");
    EXPECT_EQ(test.mod(rhs), APFloat::opOK);
    EXPECT_TRUE(test.isZero());
    EXPECT_FALSE(test.isNegative());

    // FMA correctly handles both the multiply and add parts of all this
    test = APFloat(Sem, "2.0");
    rhs = test;
    APFloat addend = APFloat(Sem, "-4.0");
    EXPECT_EQ(test.fusedMultiplyAdd(rhs, addend, APFloat::rmTowardNegative),
              APFloat::opOK);
    EXPECT_TRUE(test.isZero());
    EXPECT_FALSE(test.isNegative());
  }
}

TEST(APFloatTest, Float8E5M2FNUZAdd) {
  APFloat QNaN = APFloat::getNaN(APFloat::Float8E5M2FNUZ(), false);

  auto FromStr = [](StringRef S) {
    return APFloat(APFloat::Float8E5M2FNUZ(), S);
  };

  struct {
    APFloat x;
    APFloat y;
    const char *result;
    int status;
    int category;
    APFloat::roundingMode roundingMode = APFloat::rmNearestTiesToEven;
  } AdditionTests[] = {
      // Test addition operations involving NaN, overflow, and the max E5M2FNUZ
      // value (57344) because E5M2FNUZ differs from IEEE-754 types in these
      // regards
      {FromStr("57344"), FromStr("2048"), "57344", APFloat::opInexact,
       APFloat::fcNormal},
      {FromStr("57344"), FromStr("4096"), "NaN",
       APFloat::opOverflow | APFloat::opInexact, APFloat::fcNaN},
      {FromStr("-57344"), FromStr("-4096"), "NaN",
       APFloat::opOverflow | APFloat::opInexact, APFloat::fcNaN},
      {QNaN, FromStr("-57344"), "NaN", APFloat::opOK, APFloat::fcNaN},
      {FromStr("57344"), FromStr("-8192"), "49152", APFloat::opOK,
       APFloat::fcNormal},
      {FromStr("57344"), FromStr("0"), "57344", APFloat::opOK,
       APFloat::fcNormal},
      {FromStr("57344"), FromStr("4096"), "57344", APFloat::opInexact,
       APFloat::fcNormal, APFloat::rmTowardZero},
      {FromStr("57344"), FromStr("57344"), "57344", APFloat::opInexact,
       APFloat::fcNormal, APFloat::rmTowardZero},
  };

  for (size_t i = 0; i < std::size(AdditionTests); ++i) {
    APFloat x(AdditionTests[i].x);
    APFloat y(AdditionTests[i].y);
    APFloat::opStatus status = x.add(y, AdditionTests[i].roundingMode);

    APFloat result(APFloat::Float8E5M2FNUZ(), AdditionTests[i].result);

    EXPECT_TRUE(result.bitwiseIsEqual(x));
    EXPECT_EQ(AdditionTests[i].status, (int)status);
    EXPECT_EQ(AdditionTests[i].category, (int)x.getCategory());
  }
}

TEST(APFloatTest, Float8E5M2FNUZDivideByZero) {
  APFloat x(APFloat::Float8E5M2FNUZ(), "1");
  APFloat zero(APFloat::Float8E5M2FNUZ(), "0");
  EXPECT_EQ(x.divide(zero, APFloat::rmNearestTiesToEven), APFloat::opDivByZero);
  EXPECT_TRUE(x.isNaN());
}

TEST(APFloatTest, Float8UnsignedZeroExhaustive) {
  struct {
    const fltSemantics *semantics;
    const double largest;
    const double smallest;
  } const exhaustiveTests[] = {{&APFloat::Float8E5M2FNUZ(), 57344., 0x1.0p-17},
                               {&APFloat::Float8E4M3FNUZ(), 240., 0x1.0p-10},
                               {&APFloat::Float8E4M3B11FNUZ(), 30., 0x1.0p-13}};
  for (const auto &testInfo : exhaustiveTests) {
    const fltSemantics &sem = *testInfo.semantics;
    SCOPED_TRACE("Semantics=" + std::to_string(APFloat::SemanticsToEnum(sem)));
    // Test each of the 256 values.
    for (int i = 0; i < 256; i++) {
      SCOPED_TRACE("i=" + std::to_string(i));
      APFloat test(sem, APInt(8, i));

      // isLargest
      if (i == 127 || i == 255) {
        EXPECT_TRUE(test.isLargest());
        EXPECT_EQ(abs(test).convertToDouble(), testInfo.largest);
      } else {
        EXPECT_FALSE(test.isLargest());
      }

      // isSmallest
      if (i == 1 || i == 129) {
        EXPECT_TRUE(test.isSmallest());
        EXPECT_EQ(abs(test).convertToDouble(), testInfo.smallest);
      } else {
        EXPECT_FALSE(test.isSmallest());
      }

      // convert to BFloat
      APFloat test2 = test;
      bool losesInfo;
      APFloat::opStatus status = test2.convert(
          APFloat::BFloat(), APFloat::rmNearestTiesToEven, &losesInfo);
      EXPECT_EQ(status, APFloat::opOK);
      EXPECT_FALSE(losesInfo);
      if (i == 128)
        EXPECT_TRUE(test2.isNaN());
      else
        EXPECT_EQ(test.convertToFloat(), test2.convertToFloat());

      // bitcastToAPInt
      EXPECT_EQ(i, test.bitcastToAPInt());
    }
  }
}

TEST(APFloatTest, Float8E4M3FNUZNext) {
  for (APFloat::Semantics S :
       {APFloat::S_Float8E4M3FNUZ, APFloat::S_Float8E4M3B11FNUZ}) {
    const llvm::fltSemantics &Sem = APFloat::EnumToSemantics(S);
    APFloat test(Sem, APFloat::uninitialized);
    APFloat expected(Sem, APFloat::uninitialized);

    // 1. NextUp of largest bit pattern is nan
    test = APFloat::getLargest(Sem);
    expected = APFloat::getNaN(Sem);
    EXPECT_EQ(test.next(false), APFloat::opOK);
    EXPECT_FALSE(test.isInfinity());
    EXPECT_FALSE(test.isZero());
    EXPECT_TRUE(test.isNaN());
    EXPECT_TRUE(test.bitwiseIsEqual(expected));

    // 2. NextUp of smallest negative denormal is +0
    test = APFloat::getSmallest(Sem, true);
    expected = APFloat::getZero(Sem, false);
    EXPECT_EQ(test.next(false), APFloat::opOK);
    EXPECT_FALSE(test.isNegZero());
    EXPECT_TRUE(test.isPosZero());
    EXPECT_TRUE(test.bitwiseIsEqual(expected));

    // 3. nextDown of negative of largest value is NaN
    test = APFloat::getLargest(Sem, true);
    expected = APFloat::getNaN(Sem);
    EXPECT_EQ(test.next(true), APFloat::opOK);
    EXPECT_FALSE(test.isInfinity());
    EXPECT_FALSE(test.isZero());
    EXPECT_TRUE(test.isNaN());
    EXPECT_TRUE(test.bitwiseIsEqual(expected));

    // 4. nextDown of +0 is smallest negative denormal
    test = APFloat::getZero(Sem, false);
    expected = APFloat::getSmallest(Sem, true);
    EXPECT_EQ(test.next(true), APFloat::opOK);
    EXPECT_FALSE(test.isZero());
    EXPECT_TRUE(test.isDenormal());
    EXPECT_TRUE(test.bitwiseIsEqual(expected));

    // 5. nextUp of NaN is NaN
    test = APFloat::getNaN(Sem, false);
    expected = APFloat::getNaN(Sem, true);
    EXPECT_EQ(test.next(false), APFloat::opOK);
    EXPECT_TRUE(test.isNaN());

    // 6. nextDown of NaN is NaN
    test = APFloat::getNaN(Sem, false);
    expected = APFloat::getNaN(Sem, true);
    EXPECT_EQ(test.next(true), APFloat::opOK);
    EXPECT_TRUE(test.isNaN());
  }
}

TEST(APFloatTest, Float8E4M3FNUZChangeSign) {
  for (APFloat::Semantics S :
       {APFloat::S_Float8E4M3FNUZ, APFloat::S_Float8E4M3B11FNUZ}) {
    const llvm::fltSemantics &Sem = APFloat::EnumToSemantics(S);
    APFloat test = APFloat(Sem, "1.0");
    APFloat expected = APFloat(Sem, "-1.0");
    test.changeSign();
    EXPECT_TRUE(test.bitwiseIsEqual(expected));

    test = APFloat::getZero(Sem);
    expected = test;
    test.changeSign();
    EXPECT_TRUE(test.bitwiseIsEqual(expected));

    test = APFloat::getNaN(Sem);
    expected = test;
    test.changeSign();
    EXPECT_TRUE(test.bitwiseIsEqual(expected));
  }
}

TEST(APFloatTest, Float8E4M3FNUZFromString) {
  // Exactly representable
  EXPECT_EQ(240, APFloat(APFloat::Float8E4M3FNUZ(), "240").convertToDouble());
  // Round down to maximum value
  EXPECT_EQ(240, APFloat(APFloat::Float8E4M3FNUZ(), "247").convertToDouble());
  // Round up, causing overflow to NaN
  EXPECT_TRUE(APFloat(APFloat::Float8E4M3FNUZ(), "248").isNaN());
  // Overflow without rounding
  EXPECT_TRUE(APFloat(APFloat::Float8E4M3FNUZ(), "480").isNaN());
  // Inf converted to NaN
  EXPECT_TRUE(APFloat(APFloat::Float8E4M3FNUZ(), "inf").isNaN());
  // NaN converted to NaN
  EXPECT_TRUE(APFloat(APFloat::Float8E4M3FNUZ(), "nan").isNaN());
  // Negative zero converted to positive zero
  EXPECT_TRUE(APFloat(APFloat::Float8E4M3FNUZ(), "-0").isPosZero());
}

TEST(APFloatTest, Float8E4M3FNUZAdd) {
  APFloat QNaN = APFloat::getNaN(APFloat::Float8E4M3FNUZ(), false);

  auto FromStr = [](StringRef S) {
    return APFloat(APFloat::Float8E4M3FNUZ(), S);
  };

  struct {
    APFloat x;
    APFloat y;
    const char *result;
    int status;
    int category;
    APFloat::roundingMode roundingMode = APFloat::rmNearestTiesToEven;
  } AdditionTests[] = {
      // Test addition operations involving NaN, overflow, and the max E4M3FNUZ
      // value (240) because E4M3FNUZ differs from IEEE-754 types in these
      // regards
      {FromStr("240"), FromStr("4"), "240", APFloat::opInexact,
       APFloat::fcNormal},
      {FromStr("240"), FromStr("8"), "NaN",
       APFloat::opOverflow | APFloat::opInexact, APFloat::fcNaN},
      {FromStr("240"), FromStr("16"), "NaN",
       APFloat::opOverflow | APFloat::opInexact, APFloat::fcNaN},
      {FromStr("-240"), FromStr("-16"), "NaN",
       APFloat::opOverflow | APFloat::opInexact, APFloat::fcNaN},
      {QNaN, FromStr("-240"), "NaN", APFloat::opOK, APFloat::fcNaN},
      {FromStr("240"), FromStr("-16"), "224", APFloat::opOK, APFloat::fcNormal},
      {FromStr("240"), FromStr("0"), "240", APFloat::opOK, APFloat::fcNormal},
      {FromStr("240"), FromStr("32"), "240", APFloat::opInexact,
       APFloat::fcNormal, APFloat::rmTowardZero},
      {FromStr("240"), FromStr("240"), "240", APFloat::opInexact,
       APFloat::fcNormal, APFloat::rmTowardZero},
  };

  for (size_t i = 0; i < std::size(AdditionTests); ++i) {
    APFloat x(AdditionTests[i].x);
    APFloat y(AdditionTests[i].y);
    APFloat::opStatus status = x.add(y, AdditionTests[i].roundingMode);

    APFloat result(APFloat::Float8E4M3FNUZ(), AdditionTests[i].result);

    EXPECT_TRUE(result.bitwiseIsEqual(x));
    EXPECT_EQ(AdditionTests[i].status, (int)status);
    EXPECT_EQ(AdditionTests[i].category, (int)x.getCategory());
  }
}

TEST(APFloatTest, Float8E4M3FNUZDivideByZero) {
  APFloat x(APFloat::Float8E4M3FNUZ(), "1");
  APFloat zero(APFloat::Float8E4M3FNUZ(), "0");
  EXPECT_EQ(x.divide(zero, APFloat::rmNearestTiesToEven), APFloat::opDivByZero);
  EXPECT_TRUE(x.isNaN());
}

TEST(APFloatTest, ConvertE5M2FNUZToE4M3FNUZ) {
  bool losesInfo;
  APFloat test(APFloat::Float8E5M2FNUZ(), "1.0");
  APFloat::opStatus status = test.convert(
      APFloat::Float8E4M3FNUZ(), APFloat::rmNearestTiesToEven, &losesInfo);
  EXPECT_EQ(1.0f, test.convertToFloat());
  EXPECT_FALSE(losesInfo);
  EXPECT_EQ(status, APFloat::opOK);

  losesInfo = true;
  test = APFloat(APFloat::Float8E5M2FNUZ(), "0.0");
  status = test.convert(APFloat::Float8E4M3FNUZ(), APFloat::rmNearestTiesToEven,
                        &losesInfo);
  EXPECT_EQ(0.0f, test.convertToFloat());
  EXPECT_FALSE(losesInfo);
  EXPECT_EQ(status, APFloat::opOK);

  losesInfo = true;
  test = APFloat(APFloat::Float8E5M2FNUZ(), "0x1.Cp7"); // 224
  status = test.convert(APFloat::Float8E4M3FNUZ(), APFloat::rmNearestTiesToEven,
                        &losesInfo);
  EXPECT_EQ(0x1.Cp7 /* 224 */, test.convertToFloat());
  EXPECT_FALSE(losesInfo);
  EXPECT_EQ(status, APFloat::opOK);

  // Test overflow
  losesInfo = false;
  test = APFloat(APFloat::Float8E5M2FNUZ(), "0x1.0p8"); // 256
  status = test.convert(APFloat::Float8E4M3FNUZ(), APFloat::rmNearestTiesToEven,
                        &losesInfo);
  EXPECT_TRUE(std::isnan(test.convertToFloat()));
  EXPECT_TRUE(losesInfo);
  EXPECT_EQ(status, APFloat::opOverflow | APFloat::opInexact);

  // Test underflow
  test = APFloat(APFloat::Float8E5M2FNUZ(), "0x1.0p-11");
  status = test.convert(APFloat::Float8E4M3FNUZ(), APFloat::rmNearestTiesToEven,
                        &losesInfo);
  EXPECT_EQ(0., test.convertToFloat());
  EXPECT_TRUE(losesInfo);
  EXPECT_EQ(status, APFloat::opUnderflow | APFloat::opInexact);

  // Test rounding up to smallest denormal number
  losesInfo = false;
  test = APFloat(APFloat::Float8E5M2FNUZ(), "0x1.8p-11");
  status = test.convert(APFloat::Float8E4M3FNUZ(), APFloat::rmNearestTiesToEven,
                        &losesInfo);
  EXPECT_EQ(0x1.0p-10, test.convertToFloat());
  EXPECT_TRUE(losesInfo);
  EXPECT_EQ(status, APFloat::opUnderflow | APFloat::opInexact);

  // Testing inexact rounding to denormal number
  losesInfo = false;
  test = APFloat(APFloat::Float8E5M2FNUZ(), "0x1.8p-10");
  status = test.convert(APFloat::Float8E4M3FNUZ(), APFloat::rmNearestTiesToEven,
                        &losesInfo);
  EXPECT_EQ(0x1.0p-9, test.convertToFloat());
  EXPECT_TRUE(losesInfo);
  EXPECT_EQ(status, APFloat::opUnderflow | APFloat::opInexact);
}

TEST(APFloatTest, ConvertE4M3FNUZToE5M2FNUZ) {
  bool losesInfo;
  APFloat test(APFloat::Float8E4M3FNUZ(), "1.0");
  APFloat::opStatus status = test.convert(
      APFloat::Float8E5M2FNUZ(), APFloat::rmNearestTiesToEven, &losesInfo);
  EXPECT_EQ(1.0f, test.convertToFloat());
  EXPECT_FALSE(losesInfo);
  EXPECT_EQ(status, APFloat::opOK);

  losesInfo = true;
  test = APFloat(APFloat::Float8E4M3FNUZ(), "0.0");
  status = test.convert(APFloat::Float8E5M2FNUZ(), APFloat::rmNearestTiesToEven,
                        &losesInfo);
  EXPECT_EQ(0.0f, test.convertToFloat());
  EXPECT_FALSE(losesInfo);
  EXPECT_EQ(status, APFloat::opOK);

  losesInfo = false;
  test = APFloat(APFloat::Float8E4M3FNUZ(), "0x1.2p0"); // 1.125
  status = test.convert(APFloat::Float8E5M2FNUZ(), APFloat::rmNearestTiesToEven,
                        &losesInfo);
  EXPECT_EQ(0x1.0p0 /* 1.0 */, test.convertToFloat());
  EXPECT_TRUE(losesInfo);
  EXPECT_EQ(status, APFloat::opInexact);

  losesInfo = false;
  test = APFloat(APFloat::Float8E4M3FNUZ(), "0x1.6p0"); // 1.375
  status = test.convert(APFloat::Float8E5M2FNUZ(), APFloat::rmNearestTiesToEven,
                        &losesInfo);
  EXPECT_EQ(0x1.8p0 /* 1.5 */, test.convertToFloat());
  EXPECT_TRUE(losesInfo);
  EXPECT_EQ(status, APFloat::opInexact);

  // Convert E4M3FNUZ denormal to E5M2 normal. Should not be truncated, despite
  // the destination format having one fewer significand bit
  losesInfo = true;
  test = APFloat(APFloat::Float8E4M3FNUZ(), "0x1.Cp-8");
  status = test.convert(APFloat::Float8E5M2FNUZ(), APFloat::rmNearestTiesToEven,
                        &losesInfo);
  EXPECT_EQ(0x1.Cp-8, test.convertToFloat());
  EXPECT_FALSE(losesInfo);
  EXPECT_EQ(status, APFloat::opOK);
}

TEST(APFloatTest, F8ToString) {
  for (APFloat::Semantics S :
       {APFloat::S_Float8E5M2, APFloat::S_Float8E4M3FN,
        APFloat::S_Float8E5M2FNUZ, APFloat::S_Float8E4M3FNUZ,
        APFloat::S_Float8E4M3B11FNUZ}) {
    SCOPED_TRACE("Semantics=" + std::to_string(S));
    for (int i = 0; i < 256; i++) {
      SCOPED_TRACE("i=" + std::to_string(i));
      APFloat test(APFloat::EnumToSemantics(S), APInt(8, i));
      llvm::SmallString<128> str;
      test.toString(str);

      if (test.isNaN()) {
        EXPECT_EQ(str, "NaN");
      } else {
        APFloat test2(APFloat::EnumToSemantics(S), str);
        EXPECT_TRUE(test.bitwiseIsEqual(test2));
      }
    }
  }
}

TEST(APFloatTest, BitsToF8ToBits) {
  for (APFloat::Semantics S :
       {APFloat::S_Float8E5M2, APFloat::S_Float8E4M3FN,
        APFloat::S_Float8E5M2FNUZ, APFloat::S_Float8E4M3FNUZ,
        APFloat::S_Float8E4M3B11FNUZ}) {
    SCOPED_TRACE("Semantics=" + std::to_string(S));
    for (int i = 0; i < 256; i++) {
      SCOPED_TRACE("i=" + std::to_string(i));
      APInt bits_in = APInt(8, i);
      APFloat test(APFloat::EnumToSemantics(S), bits_in);
      APInt bits_out = test.bitcastToAPInt();
      EXPECT_EQ(bits_in, bits_out);
    }
  }
}

TEST(APFloatTest, F8ToBitsToF8) {
  for (APFloat::Semantics S :
       {APFloat::S_Float8E5M2, APFloat::S_Float8E4M3FN,
        APFloat::S_Float8E5M2FNUZ, APFloat::S_Float8E4M3FNUZ,
        APFloat::S_Float8E4M3B11FNUZ}) {
    SCOPED_TRACE("Semantics=" + std::to_string(S));
    auto &Sem = APFloat::EnumToSemantics(S);
    for (bool negative : {false, true}) {
      SCOPED_TRACE("negative=" + std::to_string(negative));
      APFloat test = APFloat::getZero(Sem, /*Negative=*/negative);
      for (int i = 0; i < 128; i++, test.next(/*nextDown=*/negative)) {
        SCOPED_TRACE("i=" + std::to_string(i));
        APInt bits = test.bitcastToAPInt();
        APFloat test2 = APFloat(Sem, bits);
        if (test.isNaN()) {
          EXPECT_TRUE(test2.isNaN());
        } else {
          EXPECT_TRUE(test.bitwiseIsEqual(test2));
        }
      }
    }
  }
}

TEST(APFloatTest, IEEEdoubleToDouble) {
  APFloat DPosZero(0.0);
  APFloat DPosZeroToDouble(DPosZero.convertToDouble());
  EXPECT_TRUE(DPosZeroToDouble.isPosZero());
  APFloat DNegZero(-0.0);
  APFloat DNegZeroToDouble(DNegZero.convertToDouble());
  EXPECT_TRUE(DNegZeroToDouble.isNegZero());

  APFloat DOne(1.0);
  EXPECT_EQ(1.0, DOne.convertToDouble());
  APFloat DPosLargest = APFloat::getLargest(APFloat::IEEEdouble(), false);
  EXPECT_EQ(std::numeric_limits<double>::max(), DPosLargest.convertToDouble());
  APFloat DNegLargest = APFloat::getLargest(APFloat::IEEEdouble(), true);
  EXPECT_EQ(-std::numeric_limits<double>::max(), DNegLargest.convertToDouble());
  APFloat DPosSmallest =
      APFloat::getSmallestNormalized(APFloat::IEEEdouble(), false);
  EXPECT_EQ(std::numeric_limits<double>::min(), DPosSmallest.convertToDouble());
  APFloat DNegSmallest =
      APFloat::getSmallestNormalized(APFloat::IEEEdouble(), true);
  EXPECT_EQ(-std::numeric_limits<double>::min(),
            DNegSmallest.convertToDouble());

  APFloat DSmallestDenorm = APFloat::getSmallest(APFloat::IEEEdouble(), false);
  EXPECT_EQ(std::numeric_limits<double>::denorm_min(),
            DSmallestDenorm.convertToDouble());
  APFloat DLargestDenorm(APFloat::IEEEdouble(), "0x0.FFFFFFFFFFFFFp-1022");
  EXPECT_EQ(/*0x0.FFFFFFFFFFFFFp-1022*/ 2.225073858507201e-308,
            DLargestDenorm.convertToDouble());

  APFloat DPosInf = APFloat::getInf(APFloat::IEEEdouble());
  EXPECT_EQ(std::numeric_limits<double>::infinity(), DPosInf.convertToDouble());
  APFloat DNegInf = APFloat::getInf(APFloat::IEEEdouble(), true);
  EXPECT_EQ(-std::numeric_limits<double>::infinity(),
            DNegInf.convertToDouble());
  APFloat DQNaN = APFloat::getQNaN(APFloat::IEEEdouble());
  EXPECT_TRUE(std::isnan(DQNaN.convertToDouble()));
}

TEST(APFloatTest, IEEEsingleToDouble) {
  APFloat FPosZero(0.0F);
  APFloat FPosZeroToDouble(FPosZero.convertToDouble());
  EXPECT_TRUE(FPosZeroToDouble.isPosZero());
  APFloat FNegZero(-0.0F);
  APFloat FNegZeroToDouble(FNegZero.convertToDouble());
  EXPECT_TRUE(FNegZeroToDouble.isNegZero());

  APFloat FOne(1.0F);
  EXPECT_EQ(1.0, FOne.convertToDouble());
  APFloat FPosLargest = APFloat::getLargest(APFloat::IEEEsingle(), false);
  EXPECT_EQ(std::numeric_limits<float>::max(), FPosLargest.convertToDouble());
  APFloat FNegLargest = APFloat::getLargest(APFloat::IEEEsingle(), true);
  EXPECT_EQ(-std::numeric_limits<float>::max(), FNegLargest.convertToDouble());
  APFloat FPosSmallest =
      APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false);
  EXPECT_EQ(std::numeric_limits<float>::min(), FPosSmallest.convertToDouble());
  APFloat FNegSmallest =
      APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true);
  EXPECT_EQ(-std::numeric_limits<float>::min(), FNegSmallest.convertToDouble());

  APFloat FSmallestDenorm = APFloat::getSmallest(APFloat::IEEEsingle(), false);
  EXPECT_EQ(std::numeric_limits<float>::denorm_min(),
            FSmallestDenorm.convertToDouble());
  APFloat FLargestDenorm(APFloat::IEEEdouble(), "0x0.FFFFFEp-126");
  EXPECT_EQ(/*0x0.FFFFFEp-126*/ 1.1754942106924411e-38,
            FLargestDenorm.convertToDouble());

  APFloat FPosInf = APFloat::getInf(APFloat::IEEEsingle());
  EXPECT_EQ(std::numeric_limits<double>::infinity(), FPosInf.convertToDouble());
  APFloat FNegInf = APFloat::getInf(APFloat::IEEEsingle(), true);
  EXPECT_EQ(-std::numeric_limits<double>::infinity(),
            FNegInf.convertToDouble());
  APFloat FQNaN = APFloat::getQNaN(APFloat::IEEEsingle());
  EXPECT_TRUE(std::isnan(FQNaN.convertToDouble()));
}

TEST(APFloatTest, IEEEhalfToDouble) {
  APFloat HPosZero = APFloat::getZero(APFloat::IEEEhalf());
  APFloat HPosZeroToDouble(HPosZero.convertToDouble());
  EXPECT_TRUE(HPosZeroToDouble.isPosZero());
  APFloat HNegZero = APFloat::getZero(APFloat::IEEEhalf(), true);
  APFloat HNegZeroToDouble(HNegZero.convertToDouble());
  EXPECT_TRUE(HNegZeroToDouble.isNegZero());

  APFloat HOne(APFloat::IEEEhalf(), "1.0");
  EXPECT_EQ(1.0, HOne.convertToDouble());
  APFloat HPosLargest = APFloat::getLargest(APFloat::IEEEhalf(), false);
  EXPECT_EQ(65504.0, HPosLargest.convertToDouble());
  APFloat HNegLargest = APFloat::getLargest(APFloat::IEEEhalf(), true);
  EXPECT_EQ(-65504.0, HNegLargest.convertToDouble());
  APFloat HPosSmallest =
      APFloat::getSmallestNormalized(APFloat::IEEEhalf(), false);
  EXPECT_EQ(/*0x1.p-14*/ 6.103515625e-05, HPosSmallest.convertToDouble());
  APFloat HNegSmallest =
      APFloat::getSmallestNormalized(APFloat::IEEEhalf(), true);
  EXPECT_EQ(/*-0x1.p-14*/ -6.103515625e-05, HNegSmallest.convertToDouble());

  APFloat HSmallestDenorm = APFloat::getSmallest(APFloat::IEEEhalf(), false);
  EXPECT_EQ(/*0x1.p-24*/ 5.960464477539063e-08,
            HSmallestDenorm.convertToDouble());
  APFloat HLargestDenorm(APFloat::IEEEhalf(), "0x1.FFCp-14");
  EXPECT_EQ(/*0x1.FFCp-14*/ 0.00012201070785522461,
            HLargestDenorm.convertToDouble());

  APFloat HPosInf = APFloat::getInf(APFloat::IEEEhalf());
  EXPECT_EQ(std::numeric_limits<double>::infinity(), HPosInf.convertToDouble());
  APFloat HNegInf = APFloat::getInf(APFloat::IEEEhalf(), true);
  EXPECT_EQ(-std::numeric_limits<double>::infinity(),
            HNegInf.convertToDouble());
  APFloat HQNaN = APFloat::getQNaN(APFloat::IEEEhalf());
  EXPECT_TRUE(std::isnan(HQNaN.convertToDouble()));

  APFloat BPosZero = APFloat::getZero(APFloat::IEEEhalf());
  APFloat BPosZeroToDouble(BPosZero.convertToDouble());
  EXPECT_TRUE(BPosZeroToDouble.isPosZero());
  APFloat BNegZero = APFloat::getZero(APFloat::IEEEhalf(), true);
  APFloat BNegZeroToDouble(BNegZero.convertToDouble());
  EXPECT_TRUE(BNegZeroToDouble.isNegZero());
}

TEST(APFloatTest, BFloatToDouble) {
  APFloat BOne(APFloat::BFloat(), "1.0");
  EXPECT_EQ(1.0, BOne.convertToDouble());
  APFloat BPosLargest = APFloat::getLargest(APFloat::BFloat(), false);
  EXPECT_EQ(/*0x1.FEp127*/ 3.3895313892515355e+38,
            BPosLargest.convertToDouble());
  APFloat BNegLargest = APFloat::getLargest(APFloat::BFloat(), true);
  EXPECT_EQ(/*-0x1.FEp127*/ -3.3895313892515355e+38,
            BNegLargest.convertToDouble());
  APFloat BPosSmallest =
      APFloat::getSmallestNormalized(APFloat::BFloat(), false);
  EXPECT_EQ(/*0x1.p-126*/ 1.1754943508222875e-38,
            BPosSmallest.convertToDouble());
  APFloat BNegSmallest =
      APFloat::getSmallestNormalized(APFloat::BFloat(), true);
  EXPECT_EQ(/*-0x1.p-126*/ -1.1754943508222875e-38,
            BNegSmallest.convertToDouble());

  APFloat BSmallestDenorm = APFloat::getSmallest(APFloat::BFloat(), false);
  EXPECT_EQ(/*0x1.p-133*/ 9.183549615799121e-41,
            BSmallestDenorm.convertToDouble());
  APFloat BLargestDenorm(APFloat::BFloat(), "0x1.FCp-127");
  EXPECT_EQ(/*0x1.FCp-127*/ 1.1663108012064884e-38,
            BLargestDenorm.convertToDouble());

  APFloat BPosInf = APFloat::getInf(APFloat::BFloat());
  EXPECT_EQ(std::numeric_limits<double>::infinity(), BPosInf.convertToDouble());
  APFloat BNegInf = APFloat::getInf(APFloat::BFloat(), true);
  EXPECT_EQ(-std::numeric_limits<double>::infinity(),
            BNegInf.convertToDouble());
  APFloat BQNaN = APFloat::getQNaN(APFloat::BFloat());
  EXPECT_TRUE(std::isnan(BQNaN.convertToDouble()));
}

TEST(APFloatTest, Float8E5M2ToDouble) {
  APFloat One(APFloat::Float8E5M2(), "1.0");
  EXPECT_EQ(1.0, One.convertToDouble());
  APFloat Two(APFloat::Float8E5M2(), "2.0");
  EXPECT_EQ(2.0, Two.convertToDouble());
  APFloat PosLargest = APFloat::getLargest(APFloat::Float8E5M2(), false);
  EXPECT_EQ(5.734400e+04, PosLargest.convertToDouble());
  APFloat NegLargest = APFloat::getLargest(APFloat::Float8E5M2(), true);
  EXPECT_EQ(-5.734400e+04, NegLargest.convertToDouble());
  APFloat PosSmallest =
      APFloat::getSmallestNormalized(APFloat::Float8E5M2(), false);
  EXPECT_EQ(0x1.p-14, PosSmallest.convertToDouble());
  APFloat NegSmallest =
      APFloat::getSmallestNormalized(APFloat::Float8E5M2(), true);
  EXPECT_EQ(-0x1.p-14, NegSmallest.convertToDouble());

  APFloat SmallestDenorm = APFloat::getSmallest(APFloat::Float8E5M2(), false);
  EXPECT_TRUE(SmallestDenorm.isDenormal());
  EXPECT_EQ(0x1p-16, SmallestDenorm.convertToDouble());

  APFloat PosInf = APFloat::getInf(APFloat::Float8E5M2());
  EXPECT_EQ(std::numeric_limits<double>::infinity(), PosInf.convertToDouble());
  APFloat NegInf = APFloat::getInf(APFloat::Float8E5M2(), true);
  EXPECT_EQ(-std::numeric_limits<double>::infinity(), NegInf.convertToDouble());
  APFloat QNaN = APFloat::getQNaN(APFloat::Float8E5M2());
  EXPECT_TRUE(std::isnan(QNaN.convertToDouble()));
}

TEST(APFloatTest, Float8E4M3ToDouble) {
  APFloat One(APFloat::Float8E4M3(), "1.0");
  EXPECT_EQ(1.0, One.convertToDouble());
  APFloat Two(APFloat::Float8E4M3(), "2.0");
  EXPECT_EQ(2.0, Two.convertToDouble());
  APFloat PosLargest = APFloat::getLargest(APFloat::Float8E4M3(), false);
  EXPECT_EQ(240.0F, PosLargest.convertToDouble());
  APFloat NegLargest = APFloat::getLargest(APFloat::Float8E4M3(), true);
  EXPECT_EQ(-240.0F, NegLargest.convertToDouble());
  APFloat PosSmallest =
      APFloat::getSmallestNormalized(APFloat::Float8E4M3(), false);
  EXPECT_EQ(0x1.p-6, PosSmallest.convertToDouble());
  APFloat NegSmallest =
      APFloat::getSmallestNormalized(APFloat::Float8E4M3(), true);
  EXPECT_EQ(-0x1.p-6, NegSmallest.convertToDouble());

  APFloat SmallestDenorm = APFloat::getSmallest(APFloat::Float8E4M3(), false);
  EXPECT_TRUE(SmallestDenorm.isDenormal());
  EXPECT_EQ(0x1.p-9, SmallestDenorm.convertToDouble());

  APFloat PosInf = APFloat::getInf(APFloat::Float8E4M3());
  EXPECT_EQ(std::numeric_limits<double>::infinity(), PosInf.convertToDouble());
  APFloat NegInf = APFloat::getInf(APFloat::Float8E4M3(), true);
  EXPECT_EQ(-std::numeric_limits<double>::infinity(), NegInf.convertToDouble());
  APFloat QNaN = APFloat::getQNaN(APFloat::Float8E4M3());
  EXPECT_TRUE(std::isnan(QNaN.convertToDouble()));
}

TEST(APFloatTest, Float8E4M3FNToDouble) {
  APFloat One(APFloat::Float8E4M3FN(), "1.0");
  EXPECT_EQ(1.0, One.convertToDouble());
  APFloat Two(APFloat::Float8E4M3FN(), "2.0");
  EXPECT_EQ(2.0, Two.convertToDouble());
  APFloat PosLargest = APFloat::getLargest(APFloat::Float8E4M3FN(), false);
  EXPECT_EQ(448., PosLargest.convertToDouble());
  APFloat NegLargest = APFloat::getLargest(APFloat::Float8E4M3FN(), true);
  EXPECT_EQ(-448., NegLargest.convertToDouble());
  APFloat PosSmallest =
      APFloat::getSmallestNormalized(APFloat::Float8E4M3FN(), false);
  EXPECT_EQ(0x1.p-6, PosSmallest.convertToDouble());
  APFloat NegSmallest =
      APFloat::getSmallestNormalized(APFloat::Float8E4M3FN(), true);
  EXPECT_EQ(-0x1.p-6, NegSmallest.convertToDouble());

  APFloat SmallestDenorm = APFloat::getSmallest(APFloat::Float8E4M3FN(), false);
  EXPECT_TRUE(SmallestDenorm.isDenormal());
  EXPECT_EQ(0x1p-9, SmallestDenorm.convertToDouble());

  APFloat QNaN = APFloat::getQNaN(APFloat::Float8E4M3FN());
  EXPECT_TRUE(std::isnan(QNaN.convertToDouble()));
}

TEST(APFloatTest, Float8E5M2FNUZToDouble) {
  APFloat One(APFloat::Float8E5M2FNUZ(), "1.0");
  EXPECT_EQ(1.0, One.convertToDouble());
  APFloat Two(APFloat::Float8E5M2FNUZ(), "2.0");
  EXPECT_EQ(2.0, Two.convertToDouble());
  APFloat PosLargest = APFloat::getLargest(APFloat::Float8E5M2FNUZ(), false);
  EXPECT_EQ(57344., PosLargest.convertToDouble());
  APFloat NegLargest = APFloat::getLargest(APFloat::Float8E5M2FNUZ(), true);
  EXPECT_EQ(-57344., NegLargest.convertToDouble());
  APFloat PosSmallest =
      APFloat::getSmallestNormalized(APFloat::Float8E5M2FNUZ(), false);
  EXPECT_EQ(0x1.p-15, PosSmallest.convertToDouble());
  APFloat NegSmallest =
      APFloat::getSmallestNormalized(APFloat::Float8E5M2FNUZ(), true);
  EXPECT_EQ(-0x1.p-15, NegSmallest.convertToDouble());

  APFloat SmallestDenorm =
      APFloat::getSmallest(APFloat::Float8E5M2FNUZ(), false);
  EXPECT_TRUE(SmallestDenorm.isDenormal());
  EXPECT_EQ(0x1p-17, SmallestDenorm.convertToDouble());

  APFloat QNaN = APFloat::getQNaN(APFloat::Float8E5M2FNUZ());
  EXPECT_TRUE(std::isnan(QNaN.convertToDouble()));
}

TEST(APFloatTest, Float8E4M3FNUZToDouble) {
  APFloat One(APFloat::Float8E4M3FNUZ(), "1.0");
  EXPECT_EQ(1.0, One.convertToDouble());
  APFloat Two(APFloat::Float8E4M3FNUZ(), "2.0");
  EXPECT_EQ(2.0, Two.convertToDouble());
  APFloat PosLargest = APFloat::getLargest(APFloat::Float8E4M3FNUZ(), false);
  EXPECT_EQ(240., PosLargest.convertToDouble());
  APFloat NegLargest = APFloat::getLargest(APFloat::Float8E4M3FNUZ(), true);
  EXPECT_EQ(-240., NegLargest.convertToDouble());
  APFloat PosSmallest =
      APFloat::getSmallestNormalized(APFloat::Float8E4M3FNUZ(), false);
  EXPECT_EQ(0x1.p-7, PosSmallest.convertToDouble());
  APFloat NegSmallest =
      APFloat::getSmallestNormalized(APFloat::Float8E4M3FNUZ(), true);
  EXPECT_EQ(-0x1.p-7, NegSmallest.convertToDouble());

  APFloat SmallestDenorm =
      APFloat::getSmallest(APFloat::Float8E4M3FNUZ(), false);
  EXPECT_TRUE(SmallestDenorm.isDenormal());
  EXPECT_EQ(0x1p-10, SmallestDenorm.convertToDouble());

  APFloat QNaN = APFloat::getQNaN(APFloat::Float8E4M3FNUZ());
  EXPECT_TRUE(std::isnan(QNaN.convertToDouble()));
}

TEST(APFloatTest, Float8E3M4ToDouble) {
  APFloat PosZero = APFloat::getZero(APFloat::Float8E3M4(), false);
  APFloat PosZeroToDouble(PosZero.convertToDouble());
  EXPECT_TRUE(PosZeroToDouble.isPosZero());
  APFloat NegZero = APFloat::getZero(APFloat::Float8E3M4(), true);
  APFloat NegZeroToDouble(NegZero.convertToDouble());
  EXPECT_TRUE(NegZeroToDouble.isNegZero());

  APFloat One(APFloat::Float8E3M4(), "1.0");
  EXPECT_EQ(1.0, One.convertToDouble());
  APFloat Two(APFloat::Float8E3M4(), "2.0");
  EXPECT_EQ(2.0, Two.convertToDouble());
  APFloat PosLargest = APFloat::getLargest(APFloat::Float8E3M4(), false);
  EXPECT_EQ(15.5F, PosLargest.convertToDouble());
  APFloat NegLargest = APFloat::getLargest(APFloat::Float8E3M4(), true);
  EXPECT_EQ(-15.5F, NegLargest.convertToDouble());
  APFloat PosSmallest =
      APFloat::getSmallestNormalized(APFloat::Float8E3M4(), false);
  EXPECT_EQ(0x1.p-2, PosSmallest.convertToDouble());
  APFloat NegSmallest =
      APFloat::getSmallestNormalized(APFloat::Float8E3M4(), true);
  EXPECT_EQ(-0x1.p-2, NegSmallest.convertToDouble());

  APFloat PosSmallestDenorm =
      APFloat::getSmallest(APFloat::Float8E3M4(), false);
  EXPECT_TRUE(PosSmallestDenorm.isDenormal());
  EXPECT_EQ(0x1.p-6, PosSmallestDenorm.convertToDouble());
  APFloat NegSmallestDenorm = APFloat::getSmallest(APFloat::Float8E3M4(), true);
  EXPECT_TRUE(NegSmallestDenorm.isDenormal());
  EXPECT_EQ(-0x1.p-6, NegSmallestDenorm.convertToDouble());

  APFloat PosInf = APFloat::getInf(APFloat::Float8E3M4());
  EXPECT_EQ(std::numeric_limits<double>::infinity(), PosInf.convertToDouble());
  APFloat NegInf = APFloat::getInf(APFloat::Float8E3M4(), true);
  EXPECT_EQ(-std::numeric_limits<double>::infinity(), NegInf.convertToDouble());
  APFloat QNaN = APFloat::getQNaN(APFloat::Float8E3M4());
  EXPECT_TRUE(std::isnan(QNaN.convertToDouble()));
}

TEST(APFloatTest, FloatTF32ToDouble) {
  APFloat One(APFloat::FloatTF32(), "1.0");
  EXPECT_EQ(1.0, One.convertToDouble());
  APFloat PosLargest = APFloat::getLargest(APFloat::FloatTF32(), false);
  EXPECT_EQ(3.401162134214653489792616e+38, PosLargest.convertToDouble());
  APFloat NegLargest = APFloat::getLargest(APFloat::FloatTF32(), true);
  EXPECT_EQ(-3.401162134214653489792616e+38, NegLargest.convertToDouble());
  APFloat PosSmallest =
      APFloat::getSmallestNormalized(APFloat::FloatTF32(), false);
  EXPECT_EQ(1.1754943508222875079687e-38, PosSmallest.convertToDouble());
  APFloat NegSmallest =
      APFloat::getSmallestNormalized(APFloat::FloatTF32(), true);
  EXPECT_EQ(-1.1754943508222875079687e-38, NegSmallest.convertToDouble());

  APFloat SmallestDenorm = APFloat::getSmallest(APFloat::FloatTF32(), false);
  EXPECT_EQ(1.1479437019748901445007e-41, SmallestDenorm.convertToDouble());
  APFloat LargestDenorm(APFloat::FloatTF32(), "0x1.FF8p-127");
  EXPECT_EQ(/*0x1.FF8p-127*/ 1.1743464071203126178242e-38,
            LargestDenorm.convertToDouble());

  APFloat PosInf = APFloat::getInf(APFloat::FloatTF32());
  EXPECT_EQ(std::numeric_limits<double>::infinity(), PosInf.convertToDouble());
  APFloat NegInf = APFloat::getInf(APFloat::FloatTF32(), true);
  EXPECT_EQ(-std::numeric_limits<double>::infinity(), NegInf.convertToDouble());
  APFloat QNaN = APFloat::getQNaN(APFloat::FloatTF32());
  EXPECT_TRUE(std::isnan(QNaN.convertToDouble()));
}

TEST(APFloatTest, Float8E5M2FNUZToFloat) {
  APFloat PosZero = APFloat::getZero(APFloat::Float8E5M2FNUZ());
  APFloat PosZeroToFloat(PosZero.convertToFloat());
  EXPECT_TRUE(PosZeroToFloat.isPosZero());
  // Negative zero is not supported
  APFloat NegZero = APFloat::getZero(APFloat::Float8E5M2FNUZ(), true);
  APFloat NegZeroToFloat(NegZero.convertToFloat());
  EXPECT_TRUE(NegZeroToFloat.isPosZero());
  APFloat One(APFloat::Float8E5M2FNUZ(), "1.0");
  EXPECT_EQ(1.0F, One.convertToFloat());
  APFloat Two(APFloat::Float8E5M2FNUZ(), "2.0");
  EXPECT_EQ(2.0F, Two.convertToFloat());
  APFloat PosLargest = APFloat::getLargest(APFloat::Float8E5M2FNUZ(), false);
  EXPECT_EQ(57344.F, PosLargest.convertToFloat());
  APFloat NegLargest = APFloat::getLargest(APFloat::Float8E5M2FNUZ(), true);
  EXPECT_EQ(-57344.F, NegLargest.convertToFloat());
  APFloat PosSmallest =
      APFloat::getSmallestNormalized(APFloat::Float8E5M2FNUZ(), false);
  EXPECT_EQ(0x1.p-15F, PosSmallest.convertToFloat());
  APFloat NegSmallest =
      APFloat::getSmallestNormalized(APFloat::Float8E5M2FNUZ(), true);
  EXPECT_EQ(-0x1.p-15F, NegSmallest.convertToFloat());

  APFloat SmallestDenorm =
      APFloat::getSmallest(APFloat::Float8E5M2FNUZ(), false);
  EXPECT_TRUE(SmallestDenorm.isDenormal());
  EXPECT_EQ(0x1p-17F, SmallestDenorm.convertToFloat());

  APFloat QNaN = APFloat::getQNaN(APFloat::Float8E5M2FNUZ());
  EXPECT_TRUE(std::isnan(QNaN.convertToFloat()));
}

TEST(APFloatTest, Float8E4M3FNUZToFloat) {
  APFloat PosZero = APFloat::getZero(APFloat::Float8E4M3FNUZ());
  APFloat PosZeroToFloat(PosZero.convertToFloat());
  EXPECT_TRUE(PosZeroToFloat.isPosZero());
  // Negative zero is not supported
  APFloat NegZero = APFloat::getZero(APFloat::Float8E4M3FNUZ(), true);
  APFloat NegZeroToFloat(NegZero.convertToFloat());
  EXPECT_TRUE(NegZeroToFloat.isPosZero());
  APFloat One(APFloat::Float8E4M3FNUZ(), "1.0");
  EXPECT_EQ(1.0F, One.convertToFloat());
  APFloat Two(APFloat::Float8E4M3FNUZ(), "2.0");
  EXPECT_EQ(2.0F, Two.convertToFloat());
  APFloat PosLargest = APFloat::getLargest(APFloat::Float8E4M3FNUZ(), false);
  EXPECT_EQ(240.F, PosLargest.convertToFloat());
  APFloat NegLargest = APFloat::getLargest(APFloat::Float8E4M3FNUZ(), true);
  EXPECT_EQ(-240.F, NegLargest.convertToFloat());
  APFloat PosSmallest =
      APFloat::getSmallestNormalized(APFloat::Float8E4M3FNUZ(), false);
  EXPECT_EQ(0x1.p-7F, PosSmallest.convertToFloat());
  APFloat NegSmallest =
      APFloat::getSmallestNormalized(APFloat::Float8E4M3FNUZ(), true);
  EXPECT_EQ(-0x1.p-7F, NegSmallest.convertToFloat());

  APFloat SmallestDenorm =
      APFloat::getSmallest(APFloat::Float8E4M3FNUZ(), false);
  EXPECT_TRUE(SmallestDenorm.isDenormal());
  EXPECT_EQ(0x1p-10F, SmallestDenorm.convertToFloat());

  APFloat QNaN = APFloat::getQNaN(APFloat::Float8E4M3FNUZ());
  EXPECT_TRUE(std::isnan(QNaN.convertToFloat()));
}

TEST(APFloatTest, IEEEsingleToFloat) {
  APFloat FPosZero(0.0F);
  APFloat FPosZeroToFloat(FPosZero.convertToFloat());
  EXPECT_TRUE(FPosZeroToFloat.isPosZero());
  APFloat FNegZero(-0.0F);
  APFloat FNegZeroToFloat(FNegZero.convertToFloat());
  EXPECT_TRUE(FNegZeroToFloat.isNegZero());

  APFloat FOne(1.0F);
  EXPECT_EQ(1.0F, FOne.convertToFloat());
  APFloat FPosLargest = APFloat::getLargest(APFloat::IEEEsingle(), false);
  EXPECT_EQ(std::numeric_limits<float>::max(), FPosLargest.convertToFloat());
  APFloat FNegLargest = APFloat::getLargest(APFloat::IEEEsingle(), true);
  EXPECT_EQ(-std::numeric_limits<float>::max(), FNegLargest.convertToFloat());
  APFloat FPosSmallest =
      APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false);
  EXPECT_EQ(std::numeric_limits<float>::min(), FPosSmallest.convertToFloat());
  APFloat FNegSmallest =
      APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true);
  EXPECT_EQ(-std::numeric_limits<float>::min(), FNegSmallest.convertToFloat());

  APFloat FSmallestDenorm = APFloat::getSmallest(APFloat::IEEEsingle(), false);
  EXPECT_EQ(std::numeric_limits<float>::denorm_min(),
            FSmallestDenorm.convertToFloat());
  APFloat FLargestDenorm(APFloat::IEEEsingle(), "0x1.FFFFFEp-126");
  EXPECT_EQ(/*0x1.FFFFFEp-126*/ 2.3509885615147286e-38F,
            FLargestDenorm.convertToFloat());

  APFloat FPosInf = APFloat::getInf(APFloat::IEEEsingle());
  EXPECT_EQ(std::numeric_limits<float>::infinity(), FPosInf.convertToFloat());
  APFloat FNegInf = APFloat::getInf(APFloat::IEEEsingle(), true);
  EXPECT_EQ(-std::numeric_limits<float>::infinity(), FNegInf.convertToFloat());
  APFloat FQNaN = APFloat::getQNaN(APFloat::IEEEsingle());
  EXPECT_TRUE(std::isnan(FQNaN.convertToFloat()));
}

TEST(APFloatTest, IEEEhalfToFloat) {
  APFloat HPosZero = APFloat::getZero(APFloat::IEEEhalf());
  APFloat HPosZeroToFloat(HPosZero.convertToFloat());
  EXPECT_TRUE(HPosZeroToFloat.isPosZero());
  APFloat HNegZero = APFloat::getZero(APFloat::IEEEhalf(), true);
  APFloat HNegZeroToFloat(HNegZero.convertToFloat());
  EXPECT_TRUE(HNegZeroToFloat.isNegZero());

  APFloat HOne(APFloat::IEEEhalf(), "1.0");
  EXPECT_EQ(1.0F, HOne.convertToFloat());
  APFloat HPosLargest = APFloat::getLargest(APFloat::IEEEhalf(), false);
  EXPECT_EQ(/*0x1.FFCp15*/ 65504.0F, HPosLargest.convertToFloat());
  APFloat HNegLargest = APFloat::getLargest(APFloat::IEEEhalf(), true);
  EXPECT_EQ(/*-0x1.FFCp15*/ -65504.0F, HNegLargest.convertToFloat());
  APFloat HPosSmallest =
      APFloat::getSmallestNormalized(APFloat::IEEEhalf(), false);
  EXPECT_EQ(/*0x1.p-14*/ 6.103515625e-05F, HPosSmallest.convertToFloat());
  APFloat HNegSmallest =
      APFloat::getSmallestNormalized(APFloat::IEEEhalf(), true);
  EXPECT_EQ(/*-0x1.p-14*/ -6.103515625e-05F, HNegSmallest.convertToFloat());

  APFloat HSmallestDenorm = APFloat::getSmallest(APFloat::IEEEhalf(), false);
  EXPECT_EQ(/*0x1.p-24*/ 5.960464477539063e-08F,
            HSmallestDenorm.convertToFloat());
  APFloat HLargestDenorm(APFloat::IEEEhalf(), "0x1.FFCp-14");
  EXPECT_EQ(/*0x1.FFCp-14*/ 0.00012201070785522461F,
            HLargestDenorm.convertToFloat());

  APFloat HPosInf = APFloat::getInf(APFloat::IEEEhalf());
  EXPECT_EQ(std::numeric_limits<float>::infinity(), HPosInf.convertToFloat());
  APFloat HNegInf = APFloat::getInf(APFloat::IEEEhalf(), true);
  EXPECT_EQ(-std::numeric_limits<float>::infinity(), HNegInf.convertToFloat());
  APFloat HQNaN = APFloat::getQNaN(APFloat::IEEEhalf());
  EXPECT_TRUE(std::isnan(HQNaN.convertToFloat()));
}

TEST(APFloatTest, BFloatToFloat) {
  APFloat BPosZero = APFloat::getZero(APFloat::BFloat());
  APFloat BPosZeroToDouble(BPosZero.convertToFloat());
  EXPECT_TRUE(BPosZeroToDouble.isPosZero());
  APFloat BNegZero = APFloat::getZero(APFloat::BFloat(), true);
  APFloat BNegZeroToDouble(BNegZero.convertToFloat());
  EXPECT_TRUE(BNegZeroToDouble.isNegZero());

  APFloat BOne(APFloat::BFloat(), "1.0");
  EXPECT_EQ(1.0F, BOne.convertToFloat());
  APFloat BPosLargest = APFloat::getLargest(APFloat::BFloat(), false);
  EXPECT_EQ(/*0x1.FEp127*/ 3.3895313892515355e+38F,
            BPosLargest.convertToFloat());
  APFloat BNegLargest = APFloat::getLargest(APFloat::BFloat(), true);
  EXPECT_EQ(/*-0x1.FEp127*/ -3.3895313892515355e+38F,
            BNegLargest.convertToFloat());
  APFloat BPosSmallest =
      APFloat::getSmallestNormalized(APFloat::BFloat(), false);
  EXPECT_EQ(/*0x1.p-126*/ 1.1754943508222875e-38F,
            BPosSmallest.convertToFloat());
  APFloat BNegSmallest =
      APFloat::getSmallestNormalized(APFloat::BFloat(), true);
  EXPECT_EQ(/*-0x1.p-126*/ -1.1754943508222875e-38F,
            BNegSmallest.convertToFloat());

  APFloat BSmallestDenorm = APFloat::getSmallest(APFloat::BFloat(), false);
  EXPECT_EQ(/*0x1.p-133*/ 9.183549615799121e-41F,
            BSmallestDenorm.convertToFloat());
  APFloat BLargestDenorm(APFloat::BFloat(), "0x1.FCp-127");
  EXPECT_EQ(/*0x1.FCp-127*/ 1.1663108012064884e-38F,
            BLargestDenorm.convertToFloat());

  APFloat BPosInf = APFloat::getInf(APFloat::BFloat());
  EXPECT_EQ(std::numeric_limits<float>::infinity(), BPosInf.convertToFloat());
  APFloat BNegInf = APFloat::getInf(APFloat::BFloat(), true);
  EXPECT_EQ(-std::numeric_limits<float>::infinity(), BNegInf.convertToFloat());
  APFloat BQNaN = APFloat::getQNaN(APFloat::BFloat());
  EXPECT_TRUE(std::isnan(BQNaN.convertToFloat()));
}

TEST(APFloatTest, Float8E5M2ToFloat) {
  APFloat PosZero = APFloat::getZero(APFloat::Float8E5M2());
  APFloat PosZeroToFloat(PosZero.convertToFloat());
  EXPECT_TRUE(PosZeroToFloat.isPosZero());
  APFloat NegZero = APFloat::getZero(APFloat::Float8E5M2(), true);
  APFloat NegZeroToFloat(NegZero.convertToFloat());
  EXPECT_TRUE(NegZeroToFloat.isNegZero());

  APFloat One(APFloat::Float8E5M2(), "1.0");
  EXPECT_EQ(1.0F, One.convertToFloat());
  APFloat Two(APFloat::Float8E5M2(), "2.0");
  EXPECT_EQ(2.0F, Two.convertToFloat());

  APFloat PosLargest = APFloat::getLargest(APFloat::Float8E5M2(), false);
  EXPECT_EQ(5.734400e+04, PosLargest.convertToFloat());
  APFloat NegLargest = APFloat::getLargest(APFloat::Float8E5M2(), true);
  EXPECT_EQ(-5.734400e+04, NegLargest.convertToFloat());
  APFloat PosSmallest =
      APFloat::getSmallestNormalized(APFloat::Float8E5M2(), false);
  EXPECT_EQ(0x1.p-14, PosSmallest.convertToFloat());
  APFloat NegSmallest =
      APFloat::getSmallestNormalized(APFloat::Float8E5M2(), true);
  EXPECT_EQ(-0x1.p-14, NegSmallest.convertToFloat());

  APFloat SmallestDenorm = APFloat::getSmallest(APFloat::Float8E5M2(), false);
  EXPECT_TRUE(SmallestDenorm.isDenormal());
  EXPECT_EQ(0x1.p-16, SmallestDenorm.convertToFloat());

  APFloat PosInf = APFloat::getInf(APFloat::Float8E5M2());
  EXPECT_EQ(std::numeric_limits<float>::infinity(), PosInf.convertToFloat());
  APFloat NegInf = APFloat::getInf(APFloat::Float8E5M2(), true);
  EXPECT_EQ(-std::numeric_limits<float>::infinity(), NegInf.convertToFloat());
  APFloat QNaN = APFloat::getQNaN(APFloat::Float8E5M2());
  EXPECT_TRUE(std::isnan(QNaN.convertToFloat()));
}

TEST(APFloatTest, Float8E4M3ToFloat) {
  APFloat PosZero = APFloat::getZero(APFloat::Float8E4M3());
  APFloat PosZeroToFloat(PosZero.convertToFloat());
  EXPECT_TRUE(PosZeroToFloat.isPosZero());
  APFloat NegZero = APFloat::getZero(APFloat::Float8E4M3(), true);
  APFloat NegZeroToFloat(NegZero.convertToFloat());
  EXPECT_TRUE(NegZeroToFloat.isNegZero());

  APFloat One(APFloat::Float8E4M3(), "1.0");
  EXPECT_EQ(1.0F, One.convertToFloat());
  APFloat Two(APFloat::Float8E4M3(), "2.0");
  EXPECT_EQ(2.0F, Two.convertToFloat());

  APFloat PosLargest = APFloat::getLargest(APFloat::Float8E4M3(), false);
  EXPECT_EQ(240.0F, PosLargest.convertToFloat());
  APFloat NegLargest = APFloat::getLargest(APFloat::Float8E4M3(), true);
  EXPECT_EQ(-240.0F, NegLargest.convertToFloat());
  APFloat PosSmallest =
      APFloat::getSmallestNormalized(APFloat::Float8E4M3(), false);
  EXPECT_EQ(0x1.p-6, PosSmallest.convertToFloat());
  APFloat NegSmallest =
      APFloat::getSmallestNormalized(APFloat::Float8E4M3(), true);
  EXPECT_EQ(-0x1.p-6, NegSmallest.convertToFloat());

  APFloat SmallestDenorm = APFloat::getSmallest(APFloat::Float8E4M3(), false);
  EXPECT_TRUE(SmallestDenorm.isDenormal());
  EXPECT_EQ(0x1.p-9, SmallestDenorm.convertToFloat());

  APFloat PosInf = APFloat::getInf(APFloat::Float8E4M3());
  EXPECT_EQ(std::numeric_limits<float>::infinity(), PosInf.convertToFloat());
  APFloat NegInf = APFloat::getInf(APFloat::Float8E4M3(), true);
  EXPECT_EQ(-std::numeric_limits<float>::infinity(), NegInf.convertToFloat());
  APFloat QNaN = APFloat::getQNaN(APFloat::Float8E4M3());
  EXPECT_TRUE(std::isnan(QNaN.convertToFloat()));
}

TEST(APFloatTest, Float8E4M3FNToFloat) {
  APFloat PosZero = APFloat::getZero(APFloat::Float8E4M3FN());
  APFloat PosZeroToFloat(PosZero.convertToFloat());
  EXPECT_TRUE(PosZeroToFloat.isPosZero());
  APFloat NegZero = APFloat::getZero(APFloat::Float8E4M3FN(), true);
  APFloat NegZeroToFloat(NegZero.convertToFloat());
  EXPECT_TRUE(NegZeroToFloat.isNegZero());

  APFloat One(APFloat::Float8E4M3FN(), "1.0");
  EXPECT_EQ(1.0F, One.convertToFloat());
  APFloat Two(APFloat::Float8E4M3FN(), "2.0");
  EXPECT_EQ(2.0F, Two.convertToFloat());

  APFloat PosLargest = APFloat::getLargest(APFloat::Float8E4M3FN(), false);
  EXPECT_EQ(448., PosLargest.convertToFloat());
  APFloat NegLargest = APFloat::getLargest(APFloat::Float8E4M3FN(), true);
  EXPECT_EQ(-448, NegLargest.convertToFloat());
  APFloat PosSmallest =
      APFloat::getSmallestNormalized(APFloat::Float8E4M3FN(), false);
  EXPECT_EQ(0x1.p-6, PosSmallest.convertToFloat());
  APFloat NegSmallest =
      APFloat::getSmallestNormalized(APFloat::Float8E4M3FN(), true);
  EXPECT_EQ(-0x1.p-6, NegSmallest.convertToFloat());

  APFloat SmallestDenorm = APFloat::getSmallest(APFloat::Float8E4M3FN(), false);
  EXPECT_TRUE(SmallestDenorm.isDenormal());
  EXPECT_EQ(0x1.p-9, SmallestDenorm.convertToFloat());

  APFloat QNaN = APFloat::getQNaN(APFloat::Float8E4M3FN());
  EXPECT_TRUE(std::isnan(QNaN.convertToFloat()));
}

TEST(APFloatTest, Float8E3M4ToFloat) {
  APFloat PosZero = APFloat::getZero(APFloat::Float8E3M4(), false);
  APFloat PosZeroToFloat(PosZero.convertToFloat());
  EXPECT_TRUE(PosZeroToFloat.isPosZero());
  APFloat NegZero = APFloat::getZero(APFloat::Float8E3M4(), true);
  APFloat NegZeroToFloat(NegZero.convertToFloat());
  EXPECT_TRUE(NegZeroToFloat.isNegZero());

  APFloat One(APFloat::Float8E3M4(), "1.0");
  EXPECT_EQ(1.0F, One.convertToFloat());
  APFloat Two(APFloat::Float8E3M4(), "2.0");
  EXPECT_EQ(2.0F, Two.convertToFloat());

  APFloat PosLargest = APFloat::getLargest(APFloat::Float8E3M4(), false);
  EXPECT_EQ(15.5F, PosLargest.convertToFloat());
  APFloat NegLargest = APFloat::getLargest(APFloat::Float8E3M4(), true);
  EXPECT_EQ(-15.5F, NegLargest.convertToFloat());
  APFloat PosSmallest =
      APFloat::getSmallestNormalized(APFloat::Float8E3M4(), false);
  EXPECT_EQ(0x1.p-2, PosSmallest.convertToFloat());
  APFloat NegSmallest =
      APFloat::getSmallestNormalized(APFloat::Float8E3M4(), true);
  EXPECT_EQ(-0x1.p-2, NegSmallest.convertToFloat());

  APFloat PosSmallestDenorm =
      APFloat::getSmallest(APFloat::Float8E3M4(), false);
  EXPECT_TRUE(PosSmallestDenorm.isDenormal());
  EXPECT_EQ(0x1.p-6, PosSmallestDenorm.convertToFloat());
  APFloat NegSmallestDenorm = APFloat::getSmallest(APFloat::Float8E3M4(), true);
  EXPECT_TRUE(NegSmallestDenorm.isDenormal());
  EXPECT_EQ(-0x1.p-6, NegSmallestDenorm.convertToFloat());

  APFloat PosInf = APFloat::getInf(APFloat::Float8E3M4());
  EXPECT_EQ(std::numeric_limits<float>::infinity(), PosInf.convertToFloat());
  APFloat NegInf = APFloat::getInf(APFloat::Float8E3M4(), true);
  EXPECT_EQ(-std::numeric_limits<float>::infinity(), NegInf.convertToFloat());
  APFloat QNaN = APFloat::getQNaN(APFloat::Float8E3M4());
  EXPECT_TRUE(std::isnan(QNaN.convertToFloat()));
}

TEST(APFloatTest, FloatTF32ToFloat) {
  APFloat PosZero = APFloat::getZero(APFloat::FloatTF32());
  APFloat PosZeroToFloat(PosZero.convertToFloat());
  EXPECT_TRUE(PosZeroToFloat.isPosZero());
  APFloat NegZero = APFloat::getZero(APFloat::FloatTF32(), true);
  APFloat NegZeroToFloat(NegZero.convertToFloat());
  EXPECT_TRUE(NegZeroToFloat.isNegZero());

  APFloat One(APFloat::FloatTF32(), "1.0");
  EXPECT_EQ(1.0F, One.convertToFloat());
  APFloat Two(APFloat::FloatTF32(), "2.0");
  EXPECT_EQ(2.0F, Two.convertToFloat());

  APFloat PosLargest = APFloat::getLargest(APFloat::FloatTF32(), false);
  EXPECT_EQ(3.40116213421e+38F, PosLargest.convertToFloat());

  APFloat NegLargest = APFloat::getLargest(APFloat::FloatTF32(), true);
  EXPECT_EQ(-3.40116213421e+38F, NegLargest.convertToFloat());

  APFloat PosSmallest =
      APFloat::getSmallestNormalized(APFloat::FloatTF32(), false);
  EXPECT_EQ(/*0x1.p-126*/ 1.1754943508222875e-38F,
            PosSmallest.convertToFloat());
  APFloat NegSmallest =
      APFloat::getSmallestNormalized(APFloat::FloatTF32(), true);
  EXPECT_EQ(/*-0x1.p-126*/ -1.1754943508222875e-38F,
            NegSmallest.convertToFloat());

  APFloat SmallestDenorm = APFloat::getSmallest(APFloat::FloatTF32(), false);
  EXPECT_TRUE(SmallestDenorm.isDenormal());
  EXPECT_EQ(0x0.004p-126, SmallestDenorm.convertToFloat());

  APFloat QNaN = APFloat::getQNaN(APFloat::FloatTF32());
  EXPECT_TRUE(std::isnan(QNaN.convertToFloat()));
}

TEST(APFloatTest, getExactLog2) {
  for (unsigned I = 0; I != APFloat::S_MaxSemantics + 1; ++I) {
    auto SemEnum = static_cast<APFloat::Semantics>(I);
    const fltSemantics &Semantics = APFloat::EnumToSemantics(SemEnum);

    // For the Float8E8M0FNU format, the below cases along
    // with some more corner cases are tested through
    // Float8E8M0FNUGetExactLog2.
    if (I == APFloat::S_Float8E8M0FNU)
      continue;

    APFloat One(Semantics, "1.0");
    APFloat Smallest = APFloat::getSmallest(Semantics);
    APFloat Largest = APFloat::getLargest(Semantics);

    int MinExp = APFloat::semanticsMinExponent(Semantics);
    int MaxExp = APFloat::semanticsMaxExponent(Semantics);
    int Precision = APFloat::semanticsPrecision(Semantics);

    EXPECT_EQ(0, One.getExactLog2());
    EXPECT_EQ(INT_MIN, APFloat(Semantics, "3.0").getExactLog2());
    EXPECT_EQ(INT_MIN, APFloat(Semantics, "3.0").getExactLog2Abs());
    if (Semantics.hasSignedRepr) {
      EXPECT_EQ(INT_MIN, APFloat(Semantics, "-3.0").getExactLog2());
      EXPECT_EQ(INT_MIN, APFloat(Semantics, "-3.0").getExactLog2Abs());
    }

    if (I == APFloat::S_Float6E2M3FN || I == APFloat::S_Float4E2M1FN) {
      EXPECT_EQ(2, APFloat(Semantics, "4.0").getExactLog2());
      EXPECT_EQ(INT_MIN, APFloat(Semantics, "-4.0").getExactLog2());
      EXPECT_EQ(2, APFloat(Semantics, "4.0").getExactLog2Abs());
      EXPECT_EQ(2, APFloat(Semantics, "-4.0").getExactLog2Abs());
    } else {
      EXPECT_EQ(3, APFloat(Semantics, "8.0").getExactLog2());
      EXPECT_EQ(-2, APFloat(Semantics, "0.25").getExactLog2());
      EXPECT_EQ(-2, APFloat(Semantics, "0.25").getExactLog2Abs());
      if (Semantics.hasSignedRepr) {
        EXPECT_EQ(INT_MIN, APFloat(Semantics, "-8.0").getExactLog2());
        EXPECT_EQ(INT_MIN, APFloat(Semantics, "-0.25").getExactLog2());
        EXPECT_EQ(-2, APFloat(Semantics, "-0.25").getExactLog2Abs());
        EXPECT_EQ(3, APFloat(Semantics, "8.0").getExactLog2Abs());
        EXPECT_EQ(3, APFloat(Semantics, "-8.0").getExactLog2Abs());
      }
    }

    EXPECT_EQ(INT_MIN, APFloat::getZero(Semantics, false).getExactLog2());
    EXPECT_EQ(INT_MIN, APFloat::getZero(Semantics, false).getExactLog2Abs());
    if (Semantics.hasSignedRepr) {
      EXPECT_EQ(INT_MIN, APFloat::getZero(Semantics, true).getExactLog2());
      EXPECT_EQ(INT_MIN, APFloat::getZero(Semantics, true).getExactLog2Abs());
    }

    if (APFloat::semanticsHasNaN(Semantics)) {
      // Types that do not support Inf will return NaN when asked for Inf.
      // (But only if they support NaN.)
      EXPECT_EQ(INT_MIN, APFloat::getInf(Semantics).getExactLog2());
      EXPECT_EQ(INT_MIN, APFloat::getNaN(Semantics, false).getExactLog2());
      if (Semantics.hasSignedRepr) {
        EXPECT_EQ(INT_MIN, APFloat::getInf(Semantics, true).getExactLog2());
        EXPECT_EQ(INT_MIN, APFloat::getNaN(Semantics, true).getExactLog2());
      }

      EXPECT_EQ(INT_MIN, APFloat::getInf(Semantics).getExactLog2Abs());
      EXPECT_EQ(INT_MIN, APFloat::getNaN(Semantics, false).getExactLog2Abs());
      if (Semantics.hasSignedRepr) {
        EXPECT_EQ(INT_MIN, APFloat::getInf(Semantics, true).getExactLog2Abs());
        EXPECT_EQ(INT_MIN, APFloat::getNaN(Semantics, true).getExactLog2Abs());
      }
    }

    EXPECT_EQ(
        INT_MIN,
        scalbn(Smallest, -2, APFloat::rmNearestTiesToEven).getExactLog2());
    EXPECT_EQ(
        INT_MIN,
        scalbn(Smallest, -1, APFloat::rmNearestTiesToEven).getExactLog2());

    EXPECT_EQ(INT_MIN,
              scalbn(Largest, 1, APFloat::rmNearestTiesToEven).getExactLog2());

    for (int i = MinExp - Precision + 1; i <= MaxExp; ++i) {
      EXPECT_EQ(i, scalbn(One, i, APFloat::rmNearestTiesToEven).getExactLog2());
    }
  }
}

TEST(APFloatTest, isPowerOf2) {
  const fltSemantics &Semantics = APFloat::IEEEdouble();

  EXPECT_TRUE(APFloat(Semantics, "1.0").isPowerOf2(0));
  EXPECT_TRUE(APFloat(Semantics, "8.0").isPowerOf2(3));
  EXPECT_TRUE(APFloat(Semantics, "0.25").isPowerOf2(-2));

  EXPECT_FALSE(APFloat(Semantics, "3.0").isPowerOf2(1));
  EXPECT_FALSE(APFloat(Semantics, "-8.0").isPowerOf2(3));
  EXPECT_FALSE(APFloat(Semantics, "-8.0").isPowerOf2(INT_MIN));
  EXPECT_FALSE(APFloat::getZero(Semantics, false).isPowerOf2(0));
  EXPECT_FALSE(APFloat::getInf(Semantics).isPowerOf2(0));
  EXPECT_FALSE(APFloat::getNaN(Semantics, false).isPowerOf2(0));

  EXPECT_TRUE(APFloat(Semantics, "-1.0").isNegPowerOf2(0));
  EXPECT_TRUE(APFloat(Semantics, "-8.0").isNegPowerOf2(3));
  EXPECT_TRUE(APFloat(Semantics, "-0.25").isNegPowerOf2(-2));

  EXPECT_FALSE(APFloat(Semantics, "-3.0").isNegPowerOf2(1));
  EXPECT_FALSE(APFloat(Semantics, "8.0").isNegPowerOf2(3));
  EXPECT_FALSE(APFloat(Semantics, "8.0").isNegPowerOf2(INT_MIN));
  EXPECT_FALSE(APFloat::getZero(Semantics, false).isNegPowerOf2(0));
  EXPECT_FALSE(APFloat::getInf(Semantics).isNegPowerOf2(0));
  EXPECT_FALSE(APFloat::getNaN(Semantics, false).isNegPowerOf2(0));
}

TEST(APFloatTest, Float8E8M0FNUGetZero) {
#ifdef GTEST_HAS_DEATH_TEST
#ifndef NDEBUG
  EXPECT_DEATH(APFloat::getZero(APFloat::Float8E8M0FNU(), false),
               "This floating point format does not support Zero");
  EXPECT_DEATH(APFloat::getZero(APFloat::Float8E8M0FNU(), true),
               "This floating point format does not support Zero");
#endif
#endif
}

TEST(APFloatTest, Float8E8M0FNUGetSignedValues) {
#ifdef GTEST_HAS_DEATH_TEST
#ifndef NDEBUG
  EXPECT_DEATH(APFloat(APFloat::Float8E8M0FNU(), "-64"),
               "This floating point format does not support signed values");
  EXPECT_DEATH(APFloat(APFloat::Float8E8M0FNU(), "-0x1.0p128"),
               "This floating point format does not support signed values");
  EXPECT_DEATH(APFloat(APFloat::Float8E8M0FNU(), "-inf"),
               "This floating point format does not support signed values");
  EXPECT_DEATH(APFloat::getNaN(APFloat::Float8E8M0FNU(), true),
               "This floating point format does not support signed values");
  EXPECT_DEATH(APFloat::getInf(APFloat::Float8E8M0FNU(), true),
               "This floating point format does not support signed values");
  EXPECT_DEATH(APFloat::getSmallest(APFloat::Float8E8M0FNU(), true),
               "This floating point format does not support signed values");
  EXPECT_DEATH(APFloat::getSmallestNormalized(APFloat::Float8E8M0FNU(), true),
               "This floating point format does not support signed values");
  EXPECT_DEATH(APFloat::getLargest(APFloat::Float8E8M0FNU(), true),
               "This floating point format does not support signed values");
  APFloat x = APFloat(APFloat::Float8E8M0FNU(), "4");
  APFloat y = APFloat(APFloat::Float8E8M0FNU(), "8");
  EXPECT_DEATH(x.subtract(y, APFloat::rmNearestTiesToEven),
               "This floating point format does not support signed values");
#endif
#endif
}

TEST(APFloatTest, Float8E8M0FNUGetInf) {
  // The E8M0 format does not support infinity and the
  // all ones representation is treated as NaN.
  APFloat t = APFloat::getInf(APFloat::Float8E8M0FNU());
  EXPECT_TRUE(t.isNaN());
  EXPECT_FALSE(t.isInfinity());
}

TEST(APFloatTest, Float8E8M0FNUFromString) {
  // Exactly representable
  EXPECT_EQ(64, APFloat(APFloat::Float8E8M0FNU(), "64").convertToDouble());
  // Overflow to NaN
  EXPECT_TRUE(APFloat(APFloat::Float8E8M0FNU(), "0x1.0p128").isNaN());
  // Inf converted to NaN
  EXPECT_TRUE(APFloat(APFloat::Float8E8M0FNU(), "inf").isNaN());
  // NaN converted to NaN
  EXPECT_TRUE(APFloat(APFloat::Float8E8M0FNU(), "nan").isNaN());
}

TEST(APFloatTest, Float8E8M0FNUDivideByZero) {
  APFloat x(APFloat::Float8E8M0FNU(), "1");
  APFloat zero(APFloat::Float8E8M0FNU(), "0");
  x.divide(zero, APFloat::rmNearestTiesToEven);

  // Zero is represented as the smallest normalized value
  // in this format i.e 2^-127.
  // This tests the fix in convertFromDecimalString() function.
  EXPECT_EQ(0x1.0p-127, zero.convertToDouble());

  // [1 / (2^-127)] = 2^127
  EXPECT_EQ(0x1.0p127, x.convertToDouble());
}

TEST(APFloatTest, Float8E8M0FNUGetExactLog2) {
  const fltSemantics &Semantics = APFloat::Float8E8M0FNU();
  APFloat One(Semantics, "1.0");
  EXPECT_EQ(0, One.getExactLog2());

  // In the Float8E8M0FNU format, 3 is rounded-up to 4.
  // So, we expect 2 as the result.
  EXPECT_EQ(2, APFloat(Semantics, "3.0").getExactLog2());
  EXPECT_EQ(2, APFloat(Semantics, "3.0").getExactLog2Abs());

  // In the Float8E8M0FNU format, 5 is rounded-down to 4.
  // So, we expect 2 as the result.
  EXPECT_EQ(2, APFloat(Semantics, "5.0").getExactLog2());
  EXPECT_EQ(2, APFloat(Semantics, "5.0").getExactLog2Abs());

  // Exact power-of-two value.
  EXPECT_EQ(3, APFloat(Semantics, "8.0").getExactLog2());
  EXPECT_EQ(3, APFloat(Semantics, "8.0").getExactLog2Abs());

  // Negative exponent value.
  EXPECT_EQ(-2, APFloat(Semantics, "0.25").getExactLog2());
  EXPECT_EQ(-2, APFloat(Semantics, "0.25").getExactLog2Abs());

  int MinExp = APFloat::semanticsMinExponent(Semantics);
  int MaxExp = APFloat::semanticsMaxExponent(Semantics);
  int Precision = APFloat::semanticsPrecision(Semantics);

  // Values below the minExp getting capped to minExp.
  EXPECT_EQ(-127,
            scalbn(One, MinExp - Precision - 1, APFloat::rmNearestTiesToEven)
                .getExactLog2());
  EXPECT_EQ(-127, scalbn(One, MinExp - Precision, APFloat::rmNearestTiesToEven)
                      .getExactLog2());

  // Values above the maxExp overflow to NaN, and getExactLog2() returns
  // INT_MIN for these cases.
  EXPECT_EQ(
      INT_MIN,
      scalbn(One, MaxExp + 1, APFloat::rmNearestTiesToEven).getExactLog2());

  // This format can represent [minExp, maxExp].
  // So, the result is the same as the 'Exp' of the scalbn.
  for (int i = MinExp - Precision + 1; i <= MaxExp; ++i) {
    EXPECT_EQ(i, scalbn(One, i, APFloat::rmNearestTiesToEven).getExactLog2());
  }
}

TEST(APFloatTest, Float8E8M0FNUSmallest) {
  APFloat test(APFloat::getSmallest(APFloat::Float8E8M0FNU()));
  EXPECT_EQ(0x1.0p-127, test.convertToDouble());

  // For E8M0 format, there are no denorms.
  // So, getSmallest is equal to isSmallestNormalized().
  EXPECT_TRUE(test.isSmallestNormalized());
  EXPECT_EQ(fcPosNormal, test.classify());

  test = APFloat::getAllOnesValue(APFloat::Float8E8M0FNU());
  EXPECT_FALSE(test.isSmallestNormalized());
  EXPECT_TRUE(test.isNaN());
}

TEST(APFloatTest, Float8E8M0FNUNext) {
  APFloat test(APFloat::getSmallest(APFloat::Float8E8M0FNU()));
  // Increment of 1 should reach 2^-126
  EXPECT_EQ(APFloat::opOK, test.next(false));
  EXPECT_FALSE(test.isSmallestNormalized());
  EXPECT_EQ(0x1.0p-126, test.convertToDouble());

  // Decrement of 1, again, should reach 2^-127
  // i.e. smallest normalized
  EXPECT_EQ(APFloat::opOK, test.next(true));
  EXPECT_TRUE(test.isSmallestNormalized());

  // Decrement again, but gets capped at the smallest normalized
  EXPECT_EQ(APFloat::opOK, test.next(true));
  EXPECT_TRUE(test.isSmallestNormalized());
}

TEST(APFloatTest, Float8E8M0FNUFMA) {
  APFloat f1(APFloat::Float8E8M0FNU(), "4.0");
  APFloat f2(APFloat::Float8E8M0FNU(), "2.0");
  APFloat f3(APFloat::Float8E8M0FNU(), "8.0");

  // Exact value: 4*2 + 8 = 16.
  f1.fusedMultiplyAdd(f2, f3, APFloat::rmNearestTiesToEven);
  EXPECT_EQ(16.0, f1.convertToDouble());

  // 4*2 + 4 = 12 but it gets rounded-up to 16.
  f1 = APFloat(APFloat::Float8E8M0FNU(), "4.0");
  f1.fusedMultiplyAdd(f2, f1, APFloat::rmNearestTiesToEven);
  EXPECT_EQ(16.0, f1.convertToDouble());

  // 4*2 + 2 = 10 but it gets rounded-down to 8.
  f1 = APFloat(APFloat::Float8E8M0FNU(), "4.0");
  f1.fusedMultiplyAdd(f2, f2, APFloat::rmNearestTiesToEven);
  EXPECT_EQ(8.0, f1.convertToDouble());

  // All of them using the same value.
  f1 = APFloat(APFloat::Float8E8M0FNU(), "1.0");
  f1.fusedMultiplyAdd(f1, f1, APFloat::rmNearestTiesToEven);
  EXPECT_EQ(2.0, f1.convertToDouble());
}

TEST(APFloatTest, ConvertDoubleToE8M0FNU) {
  bool losesInfo;
  APFloat test(APFloat::IEEEdouble(), "1.0");
  APFloat::opStatus status = test.convert(
      APFloat::Float8E8M0FNU(), APFloat::rmNearestTiesToEven, &losesInfo);
  EXPECT_EQ(1.0, test.convertToDouble());
  EXPECT_FALSE(losesInfo);
  EXPECT_EQ(status, APFloat::opOK);

  // For E8M0, zero encoding is represented as the smallest normalized value.
  // That is a different value, so the conversion reports the loss.
  test = APFloat(APFloat::IEEEdouble(), "0.0");
  status = test.convert(APFloat::Float8E8M0FNU(), APFloat::rmNearestTiesToEven,
                        &losesInfo);
  EXPECT_TRUE(test.isSmallestNormalized());
  EXPECT_EQ(0x1.0p-127, test.convertToDouble());
  EXPECT_TRUE(losesInfo);
  EXPECT_EQ(status, APFloat::opInexact);

  // Test that the conversion of a power-of-two value is precise.
  test = APFloat(APFloat::IEEEdouble(), "8.0");
  status = test.convert(APFloat::Float8E8M0FNU(), APFloat::rmNearestTiesToEven,
                        &losesInfo);
  EXPECT_EQ(8.0f, test.convertToDouble());
  EXPECT_FALSE(losesInfo);
  EXPECT_EQ(status, APFloat::opOK);

  // Test to check round-down conversion to power-of-two.
  // The fractional part of 9 is "001" (i.e. 1.125x2^3=9).
  test = APFloat(APFloat::IEEEdouble(), "9.0");
  status = test.convert(APFloat::Float8E8M0FNU(), APFloat::rmNearestTiesToEven,
                        &losesInfo);
  EXPECT_EQ(8.0f, test.convertToDouble());
  EXPECT_TRUE(losesInfo);
  EXPECT_EQ(status, APFloat::opInexact);

  // Test to check round-up conversion to power-of-two.
  // The fractional part of 13 is "101" (i.e. 1.625x2^3=13).
  test = APFloat(APFloat::IEEEdouble(), "13.0");
  status = test.convert(APFloat::Float8E8M0FNU(), APFloat::rmNearestTiesToEven,
                        &losesInfo);
  EXPECT_EQ(16.0f, test.convertToDouble());
  EXPECT_TRUE(losesInfo);
  EXPECT_EQ(status, APFloat::opInexact);

  // Test to check round-up conversion to power-of-two.
  // The fractional part of 12 is "100" (i.e. 1.5x2^3=12).
  test = APFloat(APFloat::IEEEdouble(), "12.0");
  status = test.convert(APFloat::Float8E8M0FNU(), APFloat::rmNearestTiesToEven,
                        &losesInfo);
  EXPECT_EQ(16.0f, test.convertToDouble());
  EXPECT_TRUE(losesInfo);
  EXPECT_EQ(status, APFloat::opInexact);

  // Overflow to NaN.
  test = APFloat(APFloat::IEEEdouble(), "0x1.0p128");
  status = test.convert(APFloat::Float8E8M0FNU(), APFloat::rmNearestTiesToEven,
                        &losesInfo);
  EXPECT_TRUE(test.isNaN());
  EXPECT_TRUE(losesInfo);
  EXPECT_EQ(status, APFloat::opOverflow | APFloat::opInexact);

  // Underflow to smallest normalized value.
  test = APFloat(APFloat::IEEEdouble(), "0x1.0p-128");
  status = test.convert(APFloat::Float8E8M0FNU(), APFloat::rmNearestTiesToEven,
                        &losesInfo);
  EXPECT_TRUE(test.isSmallestNormalized());
  EXPECT_TRUE(losesInfo);
  EXPECT_EQ(status, APFloat::opUnderflow | APFloat::opInexact);
}

TEST(APFloatTest, Float8E5M3FNUValues) {
  // High end of the range
  auto test = APFloat(APFloat::Float8E5M3FNU(), "0x1.c0p16");
  EXPECT_EQ(0x1.c0p16, test.convertToDouble());

  test = APFloat(APFloat::Float8E5M3FNU(), "0x1.c0p15");
  EXPECT_EQ(0x1.cp15, test.convertToDouble());

  test = APFloat(APFloat::Float8E5M3FNU(), "0x1.0p14");
  EXPECT_EQ(0x1.0p14, test.convertToDouble());

  // tests overflow to nan
  APFloat nan = APFloat(APFloat::Float8E5M3FNU(), "nan");
  test = APFloat(APFloat::Float8E5M3FNU(), "0x1.e0p+16");
  EXPECT_TRUE(test.bitwiseIsEqual(nan));

  // Mid of the range
  test = APFloat(APFloat::Float8E5M3FNU(), "0x1.0p0");
  EXPECT_EQ(1.0, test.convertToDouble());

  test = APFloat(APFloat::Float8E5M3FNU(), "0x1.0p1");
  EXPECT_EQ(2.0, test.convertToDouble());

  test = APFloat(APFloat::Float8E5M3FNU(), "0x1.0p2");
  EXPECT_EQ(4.0, test.convertToDouble());

  // Low end of the range
  test = APFloat(APFloat::Float8E5M3FNU(), "0x1.0p-12");
  EXPECT_EQ(0x1.0p-12, test.convertToDouble());

  test = APFloat(APFloat::Float8E5M3FNU(), "0x1.0p-13");
  EXPECT_EQ(0x1.0p-13, test.convertToDouble());

  test = APFloat(APFloat::Float8E5M3FNU(), "0x1.0p-14");
  EXPECT_EQ(0x1.0p-14, test.convertToDouble());
  EXPECT_TRUE(test.isSmallestNormalized());

  // Value below the smallest, but clamped to the smallest
  test = APFloat(APFloat::Float8E5M3FNU(), "0x1.0p-18");
  EXPECT_EQ(0, test.convertToDouble());
}

TEST(APFloatTest, Float8E5M3FNUFromString) {
  // Exactly representable
  EXPECT_EQ(64, APFloat(APFloat::Float8E5M3FNU(), "64").convertToDouble());
  // Overflow to NaN
  EXPECT_TRUE(APFloat(APFloat::Float8E5M3FNU(), "0x1.0p17").isNaN());
  // Inf converted to NaN
  EXPECT_TRUE(APFloat(APFloat::Float8E5M3FNU(), "inf").isNaN());
  // NaN converted to NaN
  EXPECT_TRUE(APFloat(APFloat::Float8E5M3FNU(), "nan").isNaN());
}

TEST(APFloatTest, Float8E5M3FNUDivideByZero) {
  APFloat x(APFloat::Float8E5M3FNU(), "1");
  APFloat zero(APFloat::Float8E5M3FNU(), "0");
  EXPECT_EQ(x.divide(zero, APFloat::rmNearestTiesToEven), APFloat::opDivByZero);
  EXPECT_TRUE(x.isNaN());
}

TEST(APFloatTest, Float8E5M3FNUGetSignedValues) {
#ifdef GTEST_HAS_DEATH_TEST
#ifndef NDEBUG
  EXPECT_DEATH(APFloat(APFloat::Float8E5M3FNU(), "-64"),
               "This floating point format does not support signed values");
  EXPECT_DEATH(APFloat(APFloat::Float8E5M3FNU(), "-0x1.0p17"),
               "This floating point format does not support signed values");
  EXPECT_DEATH(APFloat(APFloat::Float8E5M3FNU(), "-inf"),
               "This floating point format does not support signed values");
  EXPECT_DEATH(APFloat::getNaN(APFloat::Float8E5M3FNU(), true),
               "This floating point format does not support signed values");
  EXPECT_DEATH(APFloat::getInf(APFloat::Float8E5M3FNU(), true),
               "This floating point format does not support signed values");
  EXPECT_DEATH(APFloat::getSmallest(APFloat::Float8E5M3FNU(), true),
               "This floating point format does not support signed values");
  EXPECT_DEATH(APFloat::getSmallestNormalized(APFloat::Float8E5M3FNU(), true),
               "This floating point format does not support signed values");
  EXPECT_DEATH(APFloat::getLargest(APFloat::Float8E5M3FNU(), true),
               "This floating point format does not support signed values");
  APFloat x = APFloat(APFloat::Float8E5M3FNU(), "4");
  APFloat y = APFloat(APFloat::Float8E5M3FNU(), "8");
  EXPECT_DEATH(x.subtract(y, APFloat::rmNearestTiesToEven),
               "This floating point format does not support signed values");
#endif // NDEBUG
#endif // GTEST_HAS_DEATH_TEST
}

TEST(APFloatTest, Float8E5M3FNUGetInf) {
  // The Float8E5M3FNU format does not support infinity and the all ones
  // representation is treated as NaN.
  APFloat t = APFloat::getInf(APFloat::Float8E5M3FNU());
  EXPECT_TRUE(t.isNaN());
  EXPECT_FALSE(t.isInfinity());
}

TEST(APFloatTest, Float8E5M3FNUExhaustivePair) {
  APFloat::Semantics Sem = APFloat::S_Float8E5M3FNU;
  const llvm::fltSemantics &S = APFloat::EnumToSemantics(Sem);
  for (int i = 0; i < 256; ++i) {
    for (int j = 0; j < 256; ++j) {
      SCOPED_TRACE("sem=" + std::to_string(Sem) + ",i=" + std::to_string(i) +
                   ",j=" + std::to_string(j));
      APFloat x(S, APInt(8, i));
      APFloat y(S, APInt(8, j));

      bool losesInfo;
      APFloat xd = x;
      xd.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven,
                 &losesInfo);
      EXPECT_FALSE(losesInfo);
      APFloat yd = y;
      yd.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven,
                 &losesInfo);
      EXPECT_FALSE(losesInfo);

      APFloat z = x;
      z.add(y, APFloat::rmNearestTiesToEven);
      APFloat zd = xd;
      zd.add(yd, APFloat::rmNearestTiesToEven);
      zd.convert(S, APFloat::rmNearestTiesToEven, &losesInfo);
      EXPECT_TRUE(z.bitwiseIsEqual(zd))
          << "sem=" << Sem << ", i=" << i << ", j=" << j;

      if (i >= j) {
        z = x;
        z.subtract(y, APFloat::rmNearestTiesToEven);
        zd = xd;
        zd.subtract(yd, APFloat::rmNearestTiesToEven);
        zd.convert(S, APFloat::rmNearestTiesToEven, &losesInfo);
        EXPECT_TRUE(z.bitwiseIsEqual(zd))
            << "sem=" << Sem << ", i=" << i << ", j=" << j;
      }

      z = x;
      z.multiply(y, APFloat::rmNearestTiesToEven);
      zd = xd;
      zd.multiply(yd, APFloat::rmNearestTiesToEven);
      zd.convert(S, APFloat::rmNearestTiesToEven, &losesInfo);
      EXPECT_TRUE(z.bitwiseIsEqual(zd))
          << "sem=" << Sem << ", i=" << i << ", j=" << j;

      z = x;
      z.divide(y, APFloat::rmNearestTiesToEven);
      zd = xd;
      zd.divide(yd, APFloat::rmNearestTiesToEven);
      zd.convert(S, APFloat::rmNearestTiesToEven, &losesInfo);
      EXPECT_TRUE(z.bitwiseIsEqual(zd))
          << "sem=" << Sem << ", i=" << i << ", j=" << j;

      z = x;
      z.mod(y);
      zd = xd;
      zd.mod(yd);
      zd.convert(S, APFloat::rmNearestTiesToEven, &losesInfo);
      EXPECT_TRUE(z.bitwiseIsEqual(zd))
          << "sem=" << Sem << ", i=" << i << ", j=" << j;

      // Remainder: IEEE remainder can produce negative results, which this
      // unsigned format cannot represent. Only test when the reference
      // result is non-negative.
      zd = xd;
      zd.remainder(yd);
      if (!zd.isNegative()) {
        z = x;
        z.remainder(y);
        zd.convert(S, APFloat::rmNearestTiesToEven, &losesInfo);
        EXPECT_TRUE(z.bitwiseIsEqual(zd))
            << "sem=" << Sem << ", i=" << i << ", j=" << j;
      }
    }
  }
}

TEST(APFloatTest, Float8E5M3FNUExhaustive) {
  for (int i = 0; i < 256; i++) {
    APFloat test(APFloat::Float8E5M3FNU(), APInt(8, i));
    SCOPED_TRACE("i=" + std::to_string(i));

    // bitcastToAPInt
    EXPECT_EQ(i, test.bitcastToAPInt());

    // isLargest
    if (i == 254) {
      EXPECT_TRUE(test.isLargest());
      EXPECT_EQ(test.convertToDouble(), 0x1.cp16);
    } else {
      EXPECT_FALSE(test.isLargest());
    }

    // isSmallest (smallest positive subnormal: bit pattern 0x01 = 2^-17)
    if (i == 1) {
      EXPECT_TRUE(test.isSmallest());
      EXPECT_EQ(test.convertToDouble(), 0x1.0p-17);
    } else {
      EXPECT_FALSE(test.isSmallest());
    }

    // NaN is the all-ones bit pattern.
    if (i == 255) {
      EXPECT_TRUE(test.isNaN());
      continue;
    }

    // convert to Double
    bool losesInfo;
    APFloat::opStatus status = test.convert(
        APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven, &losesInfo);
    EXPECT_EQ(status, APFloat::opOK);
    EXPECT_FALSE(losesInfo);

    // Expected value:
    //   i == 0      -> +0
    //   1..7        -> subnormal: i * 2^-17
    //   8..254      -> normal:    (1 + (i & 7)/8) * 2^((i >> 3) - 15)
    double expected;
    if (i == 0)
      expected = 0.0;
    else if (i < 8)
      expected = std::ldexp(static_cast<double>(i), -17);
    else
      expected = std::ldexp(1.0 + (i & 7) / 8.0, (i >> 3) - 15);
    EXPECT_EQ(test.convertToDouble(), expected);
  }
}

TEST(APFloatTest, Float8E5M3FNUNext) {
  APFloat test(APFloat::getSmallest(APFloat::Float8E5M3FNU()));
  // Smallest positive value is the smallest subnormal: 2^-17.
  EXPECT_EQ(0x1.0p-17, test.convertToDouble());

  // Increment of 1 should reach the next subnormal: 2^-16.
  EXPECT_EQ(APFloat::opOK, test.next(false));
  EXPECT_FALSE(test.isSmallest());
  EXPECT_EQ(0x1.0p-16, test.convertToDouble());

  // Decrement of 1 should return to the smallest subnormal.
  EXPECT_EQ(APFloat::opOK, test.next(true));
  EXPECT_TRUE(test.isSmallest());

  // Decrement again should reach +0.
  EXPECT_EQ(APFloat::opOK, test.next(true));
  EXPECT_TRUE(test.isPosZero());
}

TEST(APFloatTest, Float8E5M3FNUFMA) {
  APFloat f1(APFloat::Float8E5M3FNU(), "4.0");
  APFloat f2(APFloat::Float8E5M3FNU(), "2.0");
  APFloat f3(APFloat::Float8E5M3FNU(), "8.0");

  // Exact value: 4*2 + 8 = 16.
  f1.fusedMultiplyAdd(f2, f3, APFloat::rmNearestTiesToEven);
  EXPECT_EQ(16.0, f1.convertToDouble());

  // 4*2 + 4 = 12 (exactly representable with 3 mantissa bits).
  f1 = APFloat(APFloat::Float8E5M3FNU(), "4.0");
  f1.fusedMultiplyAdd(f2, f1, APFloat::rmNearestTiesToEven);
  EXPECT_EQ(12.0, f1.convertToDouble());

  // 4*8 + 2 = 34. At exponent 5 the step is 4, so 34 ties between 32 and
  // 36 and rounds to 32 under round-to-nearest-even.
  f1 = APFloat(APFloat::Float8E5M3FNU(), "4.0");
  f1.fusedMultiplyAdd(f3, f2, APFloat::rmNearestTiesToEven);
  EXPECT_EQ(32.0, f1.convertToDouble());

  // All of them using the same value: 1*1 + 1 = 2.
  f1 = APFloat(APFloat::Float8E5M3FNU(), "1.0");
  f1.fusedMultiplyAdd(f1, f1, APFloat::rmNearestTiesToEven);
  EXPECT_EQ(2.0, f1.convertToDouble());
}

TEST(APFloatTest, Float6E3M2FNFromString) {
  // Exactly representable
  EXPECT_EQ(28, APFloat(APFloat::Float6E3M2FN(), "28").convertToDouble());
  // Round down to maximum value
  EXPECT_EQ(28, APFloat(APFloat::Float6E3M2FN(), "32").convertToDouble());

#ifdef GTEST_HAS_DEATH_TEST
#ifndef NDEBUG
  EXPECT_DEATH(APFloat(APFloat::Float6E3M2FN(), "inf"),
               "This floating point format does not support Inf");
  EXPECT_DEATH(APFloat(APFloat::Float6E3M2FN(), "nan"),
               "This floating point format does not support NaN");
#endif
#endif

  EXPECT_TRUE(APFloat(APFloat::Float6E3M2FN(), "0").isPosZero());
  EXPECT_TRUE(APFloat(APFloat::Float6E3M2FN(), "-0").isNegZero());
}

TEST(APFloatTest, Float6E2M3FNFromString) {
  // Exactly representable
  EXPECT_EQ(7.5, APFloat(APFloat::Float6E2M3FN(), "7.5").convertToDouble());
  // Round down to maximum value
  EXPECT_EQ(7.5, APFloat(APFloat::Float6E2M3FN(), "32").convertToDouble());

#ifdef GTEST_HAS_DEATH_TEST
#ifndef NDEBUG
  EXPECT_DEATH(APFloat(APFloat::Float6E2M3FN(), "inf"),
               "This floating point format does not support Inf");
  EXPECT_DEATH(APFloat(APFloat::Float6E2M3FN(), "nan"),
               "This floating point format does not support NaN");
#endif
#endif

  EXPECT_TRUE(APFloat(APFloat::Float6E2M3FN(), "0").isPosZero());
  EXPECT_TRUE(APFloat(APFloat::Float6E2M3FN(), "-0").isNegZero());
}

TEST(APFloatTest, Float4E2M1FNFromString) {
  // Exactly representable
  EXPECT_EQ(6, APFloat(APFloat::Float4E2M1FN(), "6").convertToDouble());
  // Round down to maximum value
  EXPECT_EQ(6, APFloat(APFloat::Float4E2M1FN(), "32").convertToDouble());

#ifdef GTEST_HAS_DEATH_TEST
#ifndef NDEBUG
  EXPECT_DEATH(APFloat(APFloat::Float4E2M1FN(), "inf"),
               "This floating point format does not support Inf");
  EXPECT_DEATH(APFloat(APFloat::Float4E2M1FN(), "nan"),
               "This floating point format does not support NaN");
#endif
#endif

  EXPECT_TRUE(APFloat(APFloat::Float4E2M1FN(), "0").isPosZero());
  EXPECT_TRUE(APFloat(APFloat::Float4E2M1FN(), "-0").isNegZero());
}

TEST(APFloatTest, ConvertE3M2FToE2M3F) {
  bool losesInfo;
  APFloat test(APFloat::Float6E3M2FN(), "1.0");
  APFloat::opStatus status = test.convert(
      APFloat::Float6E2M3FN(), APFloat::rmNearestTiesToEven, &losesInfo);
  EXPECT_EQ(1.0f, test.convertToFloat());
  EXPECT_FALSE(losesInfo);
  EXPECT_EQ(status, APFloat::opOK);

  test = APFloat(APFloat::Float6E3M2FN(), "0.0");
  status = test.convert(APFloat::Float6E2M3FN(), APFloat::rmNearestTiesToEven,
                        &losesInfo);
  EXPECT_EQ(0.0f, test.convertToFloat());
  EXPECT_FALSE(losesInfo);
  EXPECT_EQ(status, APFloat::opOK);

  // Test overflow
  test = APFloat(APFloat::Float6E3M2FN(), "28");
  status = test.convert(APFloat::Float6E2M3FN(), APFloat::rmNearestTiesToEven,
                        &losesInfo);
  EXPECT_EQ(7.5f, test.convertToFloat());
  EXPECT_TRUE(losesInfo);
  EXPECT_EQ(status, APFloat::opInexact);

  // Test underflow
  test = APFloat(APFloat::Float6E3M2FN(), ".0625");
  status = test.convert(APFloat::Float6E2M3FN(), APFloat::rmNearestTiesToEven,
                        &losesInfo);
  EXPECT_EQ(0., test.convertToFloat());
  EXPECT_TRUE(losesInfo);
  EXPECT_EQ(status, APFloat::opUnderflow | APFloat::opInexact);

  // Testing inexact rounding to denormal number
  test = APFloat(APFloat::Float6E3M2FN(), "0.1875");
  status = test.convert(APFloat::Float6E2M3FN(), APFloat::rmNearestTiesToEven,
                        &losesInfo);
  EXPECT_EQ(0.25, test.convertToFloat());
  EXPECT_TRUE(losesInfo);
  EXPECT_EQ(status, APFloat::opUnderflow | APFloat::opInexact);
}

TEST(APFloatTest, ConvertE2M3FToE3M2F) {
  bool losesInfo;
  APFloat test(APFloat::Float6E2M3FN(), "1.0");
  APFloat::opStatus status = test.convert(
      APFloat::Float6E3M2FN(), APFloat::rmNearestTiesToEven, &losesInfo);
  EXPECT_EQ(1.0f, test.convertToFloat());
  EXPECT_FALSE(losesInfo);
  EXPECT_EQ(status, APFloat::opOK);

  test = APFloat(APFloat::Float6E2M3FN(), "0.0");
  status = test.convert(APFloat::Float6E3M2FN(), APFloat::rmNearestTiesToEven,
                        &losesInfo);
  EXPECT_EQ(0.0f, test.convertToFloat());
  EXPECT_FALSE(losesInfo);
  EXPECT_EQ(status, APFloat::opOK);

  test = APFloat(APFloat::Float6E2M3FN(), ".125");
  status = test.convert(APFloat::Float6E3M2FN(), APFloat::rmNearestTiesToEven,
                        &losesInfo);
  EXPECT_EQ(.125, test.convertToFloat());
  EXPECT_FALSE(losesInfo);
  EXPECT_EQ(status, APFloat::opOK);

  // Test inexact rounding
  test = APFloat(APFloat::Float6E2M3FN(), "7.5");
  status = test.convert(APFloat::Float6E3M2FN(), APFloat::rmNearestTiesToEven,
                        &losesInfo);
  EXPECT_EQ(8, test.convertToFloat());
  EXPECT_TRUE(losesInfo);
  EXPECT_EQ(status, APFloat::opInexact);
}

TEST(APFloatTest, ConvertDoubleToE2M1F) {
  bool losesInfo;
  APFloat test(APFloat::IEEEdouble(), "1.0");
  APFloat::opStatus status = test.convert(
      APFloat::Float4E2M1FN(), APFloat::rmNearestTiesToEven, &losesInfo);
  EXPECT_EQ(1.0, test.convertToDouble());
  EXPECT_FALSE(losesInfo);
  EXPECT_EQ(status, APFloat::opOK);

  test = APFloat(APFloat::IEEEdouble(), "0.0");
  status = test.convert(APFloat::Float4E2M1FN(), APFloat::rmNearestTiesToEven,
                        &losesInfo);
  EXPECT_EQ(0.0f, test.convertToDouble());
  EXPECT_FALSE(losesInfo);
  EXPECT_EQ(status, APFloat::opOK);

  // Test overflow
  test = APFloat(APFloat::IEEEdouble(), "8");
  status = test.convert(APFloat::Float4E2M1FN(), APFloat::rmNearestTiesToEven,
                        &losesInfo);
  EXPECT_EQ(6, test.convertToDouble());
  EXPECT_TRUE(losesInfo);
  EXPECT_EQ(status, APFloat::opInexact);

  // Test underflow
  test = APFloat(APFloat::IEEEdouble(), "0.25");
  status = test.convert(APFloat::Float4E2M1FN(), APFloat::rmNearestTiesToEven,
                        &losesInfo);
  EXPECT_EQ(0., test.convertToDouble());
  EXPECT_TRUE(losesInfo);
  EXPECT_FALSE(test.isDenormal());
  EXPECT_EQ(status, APFloat::opUnderflow | APFloat::opInexact);
}

TEST(APFloatTest, Float6E3M2FNNext) {
  APFloat test(APFloat::Float6E3M2FN(), APFloat::uninitialized);
  APFloat expected(APFloat::Float6E3M2FN(), APFloat::uninitialized);

  // 1. NextUp of largest bit pattern is the same
  test = APFloat::getLargest(APFloat::Float6E3M2FN());
  expected = APFloat::getLargest(APFloat::Float6E3M2FN());
  EXPECT_EQ(test.next(false), APFloat::opOK);
  EXPECT_FALSE(test.isInfinity());
  EXPECT_FALSE(test.isZero());
  EXPECT_TRUE(test.bitwiseIsEqual(expected));

  // 2. NextUp of smallest negative denormal is -0
  test = APFloat::getSmallest(APFloat::Float6E3M2FN(), true);
  expected = APFloat::getZero(APFloat::Float6E3M2FN(), true);
  EXPECT_EQ(test.next(false), APFloat::opOK);
  EXPECT_TRUE(test.isNegZero());
  EXPECT_FALSE(test.isPosZero());
  EXPECT_TRUE(test.bitwiseIsEqual(expected));

  // 3. nextDown of negative of largest value is the same
  test = APFloat::getLargest(APFloat::Float6E3M2FN(), true);
  expected = test;
  EXPECT_EQ(test.next(true), APFloat::opOK);
  EXPECT_FALSE(test.isInfinity());
  EXPECT_FALSE(test.isZero());
  EXPECT_FALSE(test.isNaN());
  EXPECT_TRUE(test.bitwiseIsEqual(expected));

  // 4. nextDown of +0 is smallest negative denormal
  test = APFloat::getZero(APFloat::Float6E3M2FN(), false);
  expected = APFloat::getSmallest(APFloat::Float6E3M2FN(), true);
  EXPECT_EQ(test.next(true), APFloat::opOK);
  EXPECT_FALSE(test.isZero());
  EXPECT_TRUE(test.isDenormal());
  EXPECT_TRUE(test.bitwiseIsEqual(expected));
}

TEST(APFloatTest, Float6E2M3FNNext) {
  APFloat test(APFloat::Float6E2M3FN(), APFloat::uninitialized);
  APFloat expected(APFloat::Float6E2M3FN(), APFloat::uninitialized);

  // 1. NextUp of largest bit pattern is the same
  test = APFloat::getLargest(APFloat::Float6E2M3FN());
  expected = APFloat::getLargest(APFloat::Float6E2M3FN());
  EXPECT_EQ(test.next(false), APFloat::opOK);
  EXPECT_FALSE(test.isInfinity());
  EXPECT_FALSE(test.isZero());
  EXPECT_TRUE(test.bitwiseIsEqual(expected));

  // 2. NextUp of smallest negative denormal is -0
  test = APFloat::getSmallest(APFloat::Float6E2M3FN(), true);
  expected = APFloat::getZero(APFloat::Float6E2M3FN(), true);
  EXPECT_EQ(test.next(false), APFloat::opOK);
  EXPECT_TRUE(test.isNegZero());
  EXPECT_FALSE(test.isPosZero());
  EXPECT_TRUE(test.bitwiseIsEqual(expected));

  // 3. nextDown of negative of largest value is the same
  test = APFloat::getLargest(APFloat::Float6E2M3FN(), true);
  expected = test;
  EXPECT_EQ(test.next(true), APFloat::opOK);
  EXPECT_FALSE(test.isInfinity());
  EXPECT_FALSE(test.isZero());
  EXPECT_FALSE(test.isNaN());
  EXPECT_TRUE(test.bitwiseIsEqual(expected));

  // 4. nextDown of +0 is smallest negative denormal
  test = APFloat::getZero(APFloat::Float6E2M3FN(), false);
  expected = APFloat::getSmallest(APFloat::Float6E2M3FN(), true);
  EXPECT_EQ(test.next(true), APFloat::opOK);
  EXPECT_FALSE(test.isZero());
  EXPECT_TRUE(test.isDenormal());
  EXPECT_TRUE(test.bitwiseIsEqual(expected));
}

TEST(APFloatTest, Float4E2M1FNNext) {
  APFloat test(APFloat::Float4E2M1FN(), APFloat::uninitialized);
  APFloat expected(APFloat::Float4E2M1FN(), APFloat::uninitialized);

  // 1. NextUp of largest bit pattern is the same
  test = APFloat::getLargest(APFloat::Float4E2M1FN());
  expected = APFloat::getLargest(APFloat::Float4E2M1FN());
  EXPECT_EQ(test.next(false), APFloat::opOK);
  EXPECT_FALSE(test.isInfinity());
  EXPECT_FALSE(test.isZero());
  EXPECT_TRUE(test.bitwiseIsEqual(expected));

  // 2. NextUp of smallest negative denormal is -0
  test = APFloat::getSmallest(APFloat::Float4E2M1FN(), true);
  expected = APFloat::getZero(APFloat::Float4E2M1FN(), true);
  EXPECT_EQ(test.next(false), APFloat::opOK);
  EXPECT_TRUE(test.isNegZero());
  EXPECT_FALSE(test.isPosZero());
  EXPECT_TRUE(test.bitwiseIsEqual(expected));

  // 3. nextDown of negative of largest value is the same
  test = APFloat::getLargest(APFloat::Float4E2M1FN(), true);
  expected = test;
  EXPECT_EQ(test.next(true), APFloat::opOK);
  EXPECT_FALSE(test.isInfinity());
  EXPECT_FALSE(test.isZero());
  EXPECT_FALSE(test.isNaN());
  EXPECT_TRUE(test.bitwiseIsEqual(expected));

  // 4. nextDown of +0 is smallest negative denormal
  test = APFloat::getZero(APFloat::Float4E2M1FN(), false);
  expected = APFloat::getSmallest(APFloat::Float4E2M1FN(), true);
  EXPECT_EQ(test.next(true), APFloat::opOK);
  EXPECT_FALSE(test.isZero());
  EXPECT_TRUE(test.isDenormal());
  EXPECT_TRUE(test.bitwiseIsEqual(expected));
}

#ifdef GTEST_HAS_DEATH_TEST
#ifndef NDEBUG
TEST(APFloatTest, Float6E3M2FNGetInfNaN) {
  EXPECT_DEATH(APFloat::getInf(APFloat::Float6E3M2FN()),
               "This floating point format does not support Inf");
  EXPECT_DEATH(APFloat::getNaN(APFloat::Float6E3M2FN()),
               "This floating point format does not support NaN");
}

TEST(APFloatTest, Float6E2M3FNGetInfNaN) {
  EXPECT_DEATH(APFloat::getInf(APFloat::Float6E2M3FN()),
               "This floating point format does not support Inf");
  EXPECT_DEATH(APFloat::getNaN(APFloat::Float6E2M3FN()),
               "This floating point format does not support NaN");
}

TEST(APFloatTest, Float4E2M1FNGetInfNaN) {
  EXPECT_DEATH(APFloat::getInf(APFloat::Float4E2M1FN()),
               "This floating point format does not support Inf");
  EXPECT_DEATH(APFloat::getNaN(APFloat::Float4E2M1FN()),
               "This floating point format does not support NaN");
}
#endif
#endif

TEST(APFloatTest, Float6E3M2FNToDouble) {
  APFloat One(APFloat::Float6E3M2FN(), "1.0");
  EXPECT_EQ(1.0, One.convertToDouble());
  APFloat Two(APFloat::Float6E3M2FN(), "2.0");
  EXPECT_EQ(2.0, Two.convertToDouble());
  APFloat PosLargest = APFloat::getLargest(APFloat::Float6E3M2FN(), false);
  EXPECT_EQ(28., PosLargest.convertToDouble());
  APFloat NegLargest = APFloat::getLargest(APFloat::Float6E3M2FN(), true);
  EXPECT_EQ(-28., NegLargest.convertToDouble());
  APFloat PosSmallest =
      APFloat::getSmallestNormalized(APFloat::Float6E3M2FN(), false);
  EXPECT_EQ(0x1p-2, PosSmallest.convertToDouble());
  APFloat NegSmallest =
      APFloat::getSmallestNormalized(APFloat::Float6E3M2FN(), true);
  EXPECT_EQ(-0x1p-2, NegSmallest.convertToDouble());

  APFloat SmallestDenorm = APFloat::getSmallest(APFloat::Float6E3M2FN(), false);
  EXPECT_TRUE(SmallestDenorm.isDenormal());
  EXPECT_EQ(0x0.1p0, SmallestDenorm.convertToDouble());
}

TEST(APFloatTest, Float6E2M3FNToDouble) {
  APFloat One(APFloat::Float6E2M3FN(), "1.0");
  EXPECT_EQ(1.0, One.convertToDouble());
  APFloat Two(APFloat::Float6E2M3FN(), "2.0");
  EXPECT_EQ(2.0, Two.convertToDouble());
  APFloat PosLargest = APFloat::getLargest(APFloat::Float6E2M3FN(), false);
  EXPECT_EQ(7.5, PosLargest.convertToDouble());
  APFloat NegLargest = APFloat::getLargest(APFloat::Float6E2M3FN(), true);
  EXPECT_EQ(-7.5, NegLargest.convertToDouble());
  APFloat PosSmallest =
      APFloat::getSmallestNormalized(APFloat::Float6E2M3FN(), false);
  EXPECT_EQ(0x1p0, PosSmallest.convertToDouble());
  APFloat NegSmallest =
      APFloat::getSmallestNormalized(APFloat::Float6E2M3FN(), true);
  EXPECT_EQ(-0x1p0, NegSmallest.convertToDouble());

  APFloat SmallestDenorm = APFloat::getSmallest(APFloat::Float6E2M3FN(), false);
  EXPECT_TRUE(SmallestDenorm.isDenormal());
  EXPECT_EQ(0x0.2p0, SmallestDenorm.convertToDouble());
}

TEST(APFloatTest, Float4E2M1FNToDouble) {
  APFloat One(APFloat::Float4E2M1FN(), "1.0");
  EXPECT_EQ(1.0, One.convertToDouble());
  APFloat Two(APFloat::Float4E2M1FN(), "2.0");
  EXPECT_EQ(2.0, Two.convertToDouble());
  APFloat PosLargest = APFloat::getLargest(APFloat::Float4E2M1FN(), false);
  EXPECT_EQ(6, PosLargest.convertToDouble());
  APFloat NegLargest = APFloat::getLargest(APFloat::Float4E2M1FN(), true);
  EXPECT_EQ(-6, NegLargest.convertToDouble());
  APFloat PosSmallest =
      APFloat::getSmallestNormalized(APFloat::Float4E2M1FN(), false);
  EXPECT_EQ(0x1p0, PosSmallest.convertToDouble());
  APFloat NegSmallest =
      APFloat::getSmallestNormalized(APFloat::Float4E2M1FN(), true);
  EXPECT_EQ(-0x1p0, NegSmallest.convertToDouble());

  APFloat SmallestDenorm = APFloat::getSmallest(APFloat::Float4E2M1FN(), false);
  EXPECT_TRUE(SmallestDenorm.isDenormal());
  EXPECT_EQ(0x0.8p0, SmallestDenorm.convertToDouble());
}

TEST(APFloatTest, Float6E3M2FNToFloat) {
  APFloat PosZero = APFloat::getZero(APFloat::Float6E3M2FN());
  APFloat PosZeroToFloat(PosZero.convertToFloat());
  EXPECT_TRUE(PosZeroToFloat.isPosZero());
  APFloat NegZero = APFloat::getZero(APFloat::Float6E3M2FN(), true);
  APFloat NegZeroToFloat(NegZero.convertToFloat());
  EXPECT_TRUE(NegZeroToFloat.isNegZero());

  APFloat One(APFloat::Float6E3M2FN(), "1.0");
  EXPECT_EQ(1.0F, One.convertToFloat());
  APFloat Two(APFloat::Float6E3M2FN(), "2.0");
  EXPECT_EQ(2.0F, Two.convertToFloat());

  APFloat PosLargest = APFloat::getLargest(APFloat::Float6E3M2FN(), false);
  EXPECT_EQ(28., PosLargest.convertToFloat());
  APFloat NegLargest = APFloat::getLargest(APFloat::Float6E3M2FN(), true);
  EXPECT_EQ(-28, NegLargest.convertToFloat());
  APFloat PosSmallest =
      APFloat::getSmallestNormalized(APFloat::Float6E3M2FN(), false);
  EXPECT_EQ(0x1p-2, PosSmallest.convertToFloat());
  APFloat NegSmallest =
      APFloat::getSmallestNormalized(APFloat::Float6E3M2FN(), true);
  EXPECT_EQ(-0x1p-2, NegSmallest.convertToFloat());

  APFloat SmallestDenorm = APFloat::getSmallest(APFloat::Float6E3M2FN(), false);
  EXPECT_TRUE(SmallestDenorm.isDenormal());
  EXPECT_EQ(0x0.1p0, SmallestDenorm.convertToFloat());
}

TEST(APFloatTest, Float6E2M3FNToFloat) {
  APFloat PosZero = APFloat::getZero(APFloat::Float6E2M3FN());
  APFloat PosZeroToFloat(PosZero.convertToFloat());
  EXPECT_TRUE(PosZeroToFloat.isPosZero());
  APFloat NegZero = APFloat::getZero(APFloat::Float6E2M3FN(), true);
  APFloat NegZeroToFloat(NegZero.convertToFloat());
  EXPECT_TRUE(NegZeroToFloat.isNegZero());

  APFloat One(APFloat::Float6E2M3FN(), "1.0");
  EXPECT_EQ(1.0F, One.convertToFloat());
  APFloat Two(APFloat::Float6E2M3FN(), "2.0");
  EXPECT_EQ(2.0F, Two.convertToFloat());

  APFloat PosLargest = APFloat::getLargest(APFloat::Float6E2M3FN(), false);
  EXPECT_EQ(7.5, PosLargest.convertToFloat());
  APFloat NegLargest = APFloat::getLargest(APFloat::Float6E2M3FN(), true);
  EXPECT_EQ(-7.5, NegLargest.convertToFloat());
  APFloat PosSmallest =
      APFloat::getSmallestNormalized(APFloat::Float6E2M3FN(), false);
  EXPECT_EQ(0x1p0, PosSmallest.convertToFloat());
  APFloat NegSmallest =
      APFloat::getSmallestNormalized(APFloat::Float6E2M3FN(), true);
  EXPECT_EQ(-0x1p0, NegSmallest.convertToFloat());

  APFloat SmallestDenorm = APFloat::getSmallest(APFloat::Float6E2M3FN(), false);
  EXPECT_TRUE(SmallestDenorm.isDenormal());
  EXPECT_EQ(0x0.2p0, SmallestDenorm.convertToFloat());
}

TEST(APFloatTest, Float4E2M1FNToFloat) {
  APFloat PosZero = APFloat::getZero(APFloat::Float4E2M1FN());
  APFloat PosZeroToFloat(PosZero.convertToFloat());
  EXPECT_TRUE(PosZeroToFloat.isPosZero());
  APFloat NegZero = APFloat::getZero(APFloat::Float4E2M1FN(), true);
  APFloat NegZeroToFloat(NegZero.convertToFloat());
  EXPECT_TRUE(NegZeroToFloat.isNegZero());

  APFloat One(APFloat::Float4E2M1FN(), "1.0");
  EXPECT_EQ(1.0F, One.convertToFloat());
  APFloat Two(APFloat::Float4E2M1FN(), "2.0");
  EXPECT_EQ(2.0F, Two.convertToFloat());

  APFloat PosLargest = APFloat::getLargest(APFloat::Float4E2M1FN(), false);
  EXPECT_EQ(6, PosLargest.convertToFloat());
  APFloat NegLargest = APFloat::getLargest(APFloat::Float4E2M1FN(), true);
  EXPECT_EQ(-6, NegLargest.convertToFloat());
  APFloat PosSmallest =
      APFloat::getSmallestNormalized(APFloat::Float4E2M1FN(), false);
  EXPECT_EQ(0x1p0, PosSmallest.convertToFloat());
  APFloat NegSmallest =
      APFloat::getSmallestNormalized(APFloat::Float4E2M1FN(), true);
  EXPECT_EQ(-0x1p0, NegSmallest.convertToFloat());

  APFloat SmallestDenorm = APFloat::getSmallest(APFloat::Float4E2M1FN(), false);
  EXPECT_TRUE(SmallestDenorm.isDenormal());
  EXPECT_EQ(0x0.8p0, SmallestDenorm.convertToFloat());
}

TEST(APFloatTest, AddOrSubtractSignificand) {
  using Helper = detail::IEEEFloatUnitTestHelper;
  // Test cases are all combinations of:
  // {equal exponents, LHS larger exponent, RHS larger exponent}
  // {equal significands, LHS larger significand, RHS larger significand}
  // {no loss, loss}

  // Equal exponents (loss cannot occur as their is no shifting)
  Helper::runTest(true, false, 1, 0x10, false, 1, 0x5, false, 1, 0xb,
                  lfExactlyZero);
  Helper::runTest(false, false, -2, 0x20, true, -2, 0x20, false, -2, 0,
                  lfExactlyZero);
  Helper::runTest(false, true, 3, 0x20, false, 3, 0x30, false, 3, 0x10,
                  lfExactlyZero);

  // LHS larger exponent
  // LHS significand greater after shitfing
  Helper::runTest(true, false, 7, 0x100, false, 3, 0x100, false, 6, 0x1e0,
                  lfExactlyZero);
  Helper::runTest(true, false, 7, 0x100, false, 3, 0x101, false, 6, 0x1df,
                  lfMoreThanHalf);
  // Significands equal after shitfing
  Helper::runTest(true, false, 7, 0x100, false, 3, 0x1000, false, 6, 0,
                  lfExactlyZero);
  Helper::runTest(true, false, 7, 0x100, false, 3, 0x1001, true, 6, 0,
                  lfLessThanHalf);
  // RHS significand greater after shitfing
  Helper::runTest(true, false, 7, 0x100, false, 3, 0x10000, true, 6, 0x1e00,
                  lfExactlyZero);
  Helper::runTest(true, false, 7, 0x100, false, 3, 0x10001, true, 6, 0x1e00,
                  lfLessThanHalf);

  // RHS larger exponent
  // RHS significand greater after shitfing
  Helper::runTest(true, false, 3, 0x100, false, 7, 0x100, true, 6, 0x1e0,
                  lfExactlyZero);
  Helper::runTest(true, false, 3, 0x101, false, 7, 0x100, true, 6, 0x1df,
                  lfMoreThanHalf);
  // Significands equal after shitfing
  Helper::runTest(true, false, 3, 0x1000, false, 7, 0x100, false, 6, 0,
                  lfExactlyZero);
  Helper::runTest(true, false, 3, 0x1001, false, 7, 0x100, false, 6, 0,
                  lfLessThanHalf);
  // LHS significand greater after shitfing
  Helper::runTest(true, false, 3, 0x10000, false, 7, 0x100, false, 6, 0x1e00,
                  lfExactlyZero);
  Helper::runTest(true, false, 3, 0x10001, false, 7, 0x100, false, 6, 0x1e00,
                  lfLessThanHalf);
}

TEST(APFloatTest, hasSignBitInMSB) {
  EXPECT_TRUE(APFloat::hasSignBitInMSB(APFloat::IEEEsingle()));
  EXPECT_TRUE(APFloat::hasSignBitInMSB(APFloat::x87DoubleExtended()));
  EXPECT_TRUE(APFloat::hasSignBitInMSB(APFloat::PPCDoubleDouble()));
  EXPECT_TRUE(APFloat::hasSignBitInMSB(APFloat::IEEEquad()));
  EXPECT_FALSE(APFloat::hasSignBitInMSB(APFloat::Float8E8M0FNU()));
  EXPECT_FALSE(APFloat::hasSignBitInMSB(APFloat::Float8E5M3FNU()));
}

TEST(APFloatTest, FrexpQuietSNaN) {
  APFloat SNaN = APFloat::getSNaN(APFloat::PPCDoubleDouble());
  int Exp;
  APFloat Result = frexp(SNaN, Exp, APFloat::rmNearestTiesToEven);
  EXPECT_FALSE(Result.isSignaling());
}

TEST(APFloatTest, isValidArbitraryFPFormat) {
  // Test all valid format strings.
  EXPECT_TRUE(APFloat::isValidArbitraryFPFormat("Float8E5M2"));
  EXPECT_TRUE(APFloat::isValidArbitraryFPFormat("Float8E5M2FNUZ"));
  EXPECT_TRUE(APFloat::isValidArbitraryFPFormat("Float8E4M3"));
  EXPECT_TRUE(APFloat::isValidArbitraryFPFormat("Float8E4M3FN"));
  EXPECT_TRUE(APFloat::isValidArbitraryFPFormat("Float8E4M3FNUZ"));
  EXPECT_TRUE(APFloat::isValidArbitraryFPFormat("Float8E4M3B11FNUZ"));
  EXPECT_TRUE(APFloat::isValidArbitraryFPFormat("Float8E3M4"));
  EXPECT_TRUE(APFloat::isValidArbitraryFPFormat("Float8E8M0FNU"));
  EXPECT_TRUE(APFloat::isValidArbitraryFPFormat("Float6E3M2FN"));
  EXPECT_TRUE(APFloat::isValidArbitraryFPFormat("Float6E2M3FN"));
  EXPECT_TRUE(APFloat::isValidArbitraryFPFormat("Float4E2M1FN"));
  EXPECT_TRUE(APFloat::isValidArbitraryFPFormat("Float8E5M3FNU"));

  // Test invalid format strings.
  EXPECT_FALSE(APFloat::isValidArbitraryFPFormat(""));
  EXPECT_FALSE(APFloat::isValidArbitraryFPFormat("Float8"));
  EXPECT_FALSE(
      APFloat::isValidArbitraryFPFormat("Float8E5M2FN")); // Should be FNUZ.
  EXPECT_FALSE(APFloat::isValidArbitraryFPFormat("float8e4m3")); // Wrong case.
  EXPECT_FALSE(APFloat::isValidArbitraryFPFormat("Float16E5M10"));
  EXPECT_FALSE(APFloat::isValidArbitraryFPFormat("unknown"));
}

TEST(APFloatTest, getArbitraryFPFormatSizeInBits) {
  // Every valid format reports the bit width of its semantics.
  EXPECT_EQ(8u, APFloat::getArbitraryFPFormatSizeInBits("Float8E5M2"));
  EXPECT_EQ(8u, APFloat::getArbitraryFPFormatSizeInBits("Float8E5M2FNUZ"));
  EXPECT_EQ(8u, APFloat::getArbitraryFPFormatSizeInBits("Float8E4M3"));
  EXPECT_EQ(8u, APFloat::getArbitraryFPFormatSizeInBits("Float8E4M3FN"));
  EXPECT_EQ(8u, APFloat::getArbitraryFPFormatSizeInBits("Float8E4M3FNUZ"));
  EXPECT_EQ(8u, APFloat::getArbitraryFPFormatSizeInBits("Float8E4M3B11FNUZ"));
  EXPECT_EQ(8u, APFloat::getArbitraryFPFormatSizeInBits("Float8E3M4"));
  EXPECT_EQ(8u, APFloat::getArbitraryFPFormatSizeInBits("Float8E8M0FNU"));
  EXPECT_EQ(8u, APFloat::getArbitraryFPFormatSizeInBits("Float8E5M3FNU"));
  EXPECT_EQ(6u, APFloat::getArbitraryFPFormatSizeInBits("Float6E3M2FN"));
  EXPECT_EQ(6u, APFloat::getArbitraryFPFormatSizeInBits("Float6E2M3FN"));
  EXPECT_EQ(4u, APFloat::getArbitraryFPFormatSizeInBits("Float4E2M1FN"));

  // Invalid formats report zero.
  EXPECT_EQ(0u, APFloat::getArbitraryFPFormatSizeInBits(""));
  EXPECT_EQ(0u, APFloat::getArbitraryFPFormatSizeInBits("Float8"));
  EXPECT_EQ(0u, APFloat::getArbitraryFPFormatSizeInBits("float4e2m1fn"));
  EXPECT_EQ(0u, APFloat::getArbitraryFPFormatSizeInBits("unknown"));
}

TEST(APFloatTest, getArbitraryFPSemantics) {
  // Formats that can currently be lowered map to their semantics.
  EXPECT_EQ(&APFloat::Float8E5M2(),
            APFloat::getArbitraryFPSemantics("Float8E5M2"));
  EXPECT_EQ(&APFloat::Float8E4M3FN(),
            APFloat::getArbitraryFPSemantics("Float8E4M3FN"));
  EXPECT_EQ(&APFloat::Float8E5M3FNU(),
            APFloat::getArbitraryFPSemantics("Float8E5M3FNU"));
  EXPECT_EQ(&APFloat::Float6E3M2FN(),
            APFloat::getArbitraryFPSemantics("Float6E3M2FN"));
  EXPECT_EQ(&APFloat::Float6E2M3FN(),
            APFloat::getArbitraryFPSemantics("Float6E2M3FN"));
  EXPECT_EQ(&APFloat::Float4E2M1FN(),
            APFloat::getArbitraryFPSemantics("Float4E2M1FN"));

  // Formats that are valid but cannot be lowered yet report no semantics.
  EXPECT_EQ(nullptr, APFloat::getArbitraryFPSemantics("Float8E5M2FNUZ"));
  EXPECT_EQ(nullptr, APFloat::getArbitraryFPSemantics("Float8E4M3"));
  EXPECT_EQ(nullptr, APFloat::getArbitraryFPSemantics("Float8E4M3FNUZ"));
  EXPECT_EQ(nullptr, APFloat::getArbitraryFPSemantics("Float8E4M3B11FNUZ"));
  EXPECT_EQ(nullptr, APFloat::getArbitraryFPSemantics("Float8E3M4"));
  EXPECT_EQ(nullptr, APFloat::getArbitraryFPSemantics("Float8E8M0FNU"));

  // Invalid formats report no semantics.
  EXPECT_EQ(nullptr, APFloat::getArbitraryFPSemantics(""));
  EXPECT_EQ(nullptr, APFloat::getArbitraryFPSemantics("Float8"));
  EXPECT_EQ(nullptr, APFloat::getArbitraryFPSemantics("float8e5m2"));
  EXPECT_EQ(nullptr, APFloat::getArbitraryFPSemantics("unknown"));
}

// The two arbitrary FP format tables must agree: every format with lowerable
// semantics reports the size of those semantics.
TEST(APFloatTest, ArbitraryFPSemanticsMatchSizeInBits) {
  for (StringRef Format :
       {"Float8E5M2", "Float8E5M2FNUZ", "Float8E4M3", "Float8E4M3FN",
        "Float8E4M3FNUZ", "Float8E4M3B11FNUZ", "Float8E3M4", "Float8E8M0FNU",
        "Float8E5M3FNU", "Float6E3M2FN", "Float6E2M3FN", "Float4E2M1FN"}) {
    ASSERT_TRUE(APFloat::isValidArbitraryFPFormat(Format)) << Format;
    if (const fltSemantics *Sem = APFloat::getArbitraryFPSemantics(Format))
      EXPECT_EQ(APFloat::getSizeInBits(*Sem),
                APFloat::getArbitraryFPFormatSizeInBits(Format))
          << Format;
  }
}

TEST(APFloatTest, DecimalStringPreservesInexactStatus) {
  APFloat F(APFloat::IEEEsingle());

  auto StatusOr = F.convertFromString("10384593717069655257060992658440193.0",
                                      APFloat::rmNearestTiesToEven);
  EXPECT_TRUE(!!StatusOr);

  APFloat::opStatus Status = *StatusOr;

  // The value is 2^113 + 1, not exactly representable in float.
  EXPECT_TRUE(Status & APFloat::opInexact);

  // But it should round to exactly 2^113.
  APFloat Expected(APFloat::IEEEsingle());
  auto ExpectedStatus =
      Expected.convertFromString("0x1p113", APFloat::rmNearestTiesToEven);
  EXPECT_TRUE(!!ExpectedStatus);
  EXPECT_FALSE(*ExpectedStatus & APFloat::opInexact);

  EXPECT_EQ(F.bitcastToAPInt(), Expected.bitcastToAPInt());
}

TEST(APFloatTest, expf) {
  // exp(+-0) = 1.
  EXPECT_EQ(1.0f, llvm::exp(APFloat(0.0f))->convertToFloat());
  EXPECT_EQ(1.0f, llvm::exp(APFloat(-0.0f))->convertToFloat());
  // exp(+Inf) = +Inf.
  EXPECT_EQ(std::numeric_limits<float>::infinity(),
            llvm::exp(APFloat::getInf(APFloat::IEEEsingle(), false))
                ->convertToFloat());
  // exp(-Inf) = 0.
  EXPECT_EQ(0.0f, llvm::exp(APFloat::getInf(APFloat::IEEEsingle(), true))
                      ->convertToFloat());
  // exp(NaN) = NaN.
  EXPECT_TRUE(llvm::exp(APFloat::getNaN(APFloat::IEEEsingle()))->isNaN());
  // exp(1)
  EXPECT_EQ(0x1.5bf0a8p1f, llvm::exp(APFloat(1.0f))->convertToFloat());
  // exp(float max)
  EXPECT_EQ(std::numeric_limits<float>::infinity(),
            llvm::exp(APFloat::getLargest(APFloat::IEEEsingle(), false))
                ->convertToFloat());
  // exp(min_denormal)
  EXPECT_EQ(1.0f, llvm::exp(APFloat::getSmallest(APFloat::IEEEsingle(), false))
                      ->convertToFloat());
  // exp(-1)
  EXPECT_EQ(0x1.78b564p-2f, llvm::exp(APFloat(-1.0f))->convertToFloat());
  // exp(-90)
  EXPECT_EQ(0x1.1d85p-130f, llvm::exp(APFloat(-90.0f))->convertToFloat());
}

TEST(APFloatTest, exp) {
  // exp(+-0) = 1.
  EXPECT_EQ(1.0, llvm::exp(APFloat(0.0))->convertToDouble());
  EXPECT_EQ(1.0, llvm::exp(APFloat(-0.0))->convertToDouble());
  // exp(+Inf) = +Inf.
  EXPECT_EQ(std::numeric_limits<double>::infinity(),
            llvm::exp(APFloat::getInf(APFloat::IEEEdouble(), false))
                ->convertToDouble());
  // exp(-Inf) = 0.
  EXPECT_EQ(0.0, llvm::exp(APFloat::getInf(APFloat::IEEEdouble(), true))
                     ->convertToDouble());
  // exp(NaN) = NaN.
  EXPECT_TRUE(llvm::exp(APFloat::getNaN(APFloat::IEEEdouble()))->isNaN());
  // exp(1)
  EXPECT_EQ(0x1.5bf0a8b145769p1, llvm::exp(APFloat(1.0))->convertToDouble());
  // exp(float max)
  EXPECT_EQ(std::numeric_limits<double>::infinity(),
            llvm::exp(APFloat::getLargest(APFloat::IEEEdouble(), false))
                ->convertToDouble());
  // exp(min_denormal)
  EXPECT_EQ(1.0, llvm::exp(APFloat::getSmallest(APFloat::IEEEdouble(), false))
                     ->convertToDouble());
  // exp(-1)
  EXPECT_EQ(0x1.78b56362cef38p-2, llvm::exp(APFloat(-1.0))->convertToDouble());
  // exp(-710)
  EXPECT_EQ(0x1.9c017e9459e18p-1025,
            llvm::exp(APFloat(-710.0))->convertToDouble());
}

TEST(APFloatTest, exp_exceptions) {
  APFloat::opStatus status;

  // exp(0) should be exact (no inexact, no overflow/underflow -> opOK).
  status = APFloat::opInvalidOp; // initialize to a dummy flag
  auto res1 = llvm::exp(APFloat(0.0f), APFloat::rmNearestTiesToEven, &status);
  EXPECT_TRUE(res1.has_value());
  EXPECT_EQ(APFloat::opOK, status);

  // exp(1) should be inexact (not representing an exact power of 2).
  status = APFloat::opOK;
  auto res2 = llvm::exp(APFloat(1.0f), APFloat::rmNearestTiesToEven, &status);
  EXPECT_TRUE(res2.has_value());
  EXPECT_EQ(APFloat::opInexact, status);

  // exp(float max) should overflow and be inexact.
  status = APFloat::opOK;
  auto res3 = llvm::exp(APFloat::getLargest(APFloat::IEEEsingle(), false),
                        APFloat::rmNearestTiesToEven, &status);
  EXPECT_TRUE(res3.has_value());
  EXPECT_EQ(
      static_cast<APFloat::opStatus>(APFloat::opOverflow | APFloat::opInexact),
      status);

  // exp(-90.0f) should underflow and be inexact.
  status = APFloat::opOK;
  auto res4 = llvm::exp(APFloat(-90.0f), APFloat::rmNearestTiesToEven, &status);
  EXPECT_TRUE(res4.has_value());
  EXPECT_EQ(
      static_cast<APFloat::opStatus>(APFloat::opUnderflow | APFloat::opInexact),
      status);

  // exp(NaN) should be quiet and not raise any exceptions.
  status = APFloat::opInvalidOp;
  auto res5 = llvm::exp(APFloat::getNaN(APFloat::IEEEsingle()),
                        APFloat::rmNearestTiesToEven, &status);
  EXPECT_TRUE(res5.has_value());
  EXPECT_EQ(APFloat::opOK, status);

  // exp(sNaN) should raise an invalid operation exception.
  status = APFloat::opOK;
  auto res6 = llvm::exp(APFloat::getSNaN(APFloat::IEEEsingle()),
                        APFloat::rmNearestTiesToEven, &status);
  EXPECT_TRUE(res6.has_value());
  EXPECT_EQ(APFloat::opInvalidOp, status);

  // exp with unsupported rounding mode or unsupported semantics should
  // return std::nullopt.
  EXPECT_FALSE(llvm::exp(APFloat(1.0f), APFloat::rmTowardPositive).has_value());
  EXPECT_FALSE(llvm::exp(APFloat::getZero(APFloat::IEEEhalf())).has_value());
}

} // namespace