//===- llvm/unittest/ADT/FloatingPointMode.cpp ----------------------------===//
//
// 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/FloatingPointMode.h"
#include "gtest/gtest.h"

using namespace llvm;

namespace {

static constexpr FPClassTest OrderedLessThanZeroMask =
    fcNegSubnormal | fcNegNormal | fcNegInf;
static constexpr FPClassTest OrderedGreaterThanZeroMask =
    fcPosSubnormal | fcPosNormal | fcPosInf;

TEST(FloatingPointModeTest, ParseDenormalFPAttributeComponent) {
  EXPECT_EQ(DenormalMode::IEEE, parseDenormalFPAttributeComponent("ieee"));
  EXPECT_EQ(DenormalMode::IEEE, parseDenormalFPAttributeComponent(""));
  EXPECT_EQ(DenormalMode::PreserveSign,
            parseDenormalFPAttributeComponent("preserve-sign"));
  EXPECT_EQ(DenormalMode::PositiveZero,
            parseDenormalFPAttributeComponent("positive-zero"));
  EXPECT_EQ(DenormalMode::PreserveSign,
            parseDenormalFPAttributeComponent("preservesign"));
  EXPECT_EQ(DenormalMode::PositiveZero,
            parseDenormalFPAttributeComponent("positivezero"));
  EXPECT_EQ(DenormalMode::Dynamic,
            parseDenormalFPAttributeComponent("dynamic"));
  EXPECT_EQ(DenormalMode::Invalid, parseDenormalFPAttributeComponent("foo"));
}

TEST(FloatingPointModeTest, DenormalAttributeName) {
  EXPECT_EQ("ieee", denormalModeKindName(DenormalMode::IEEE));
  EXPECT_EQ("preserve-sign", denormalModeKindName(DenormalMode::PreserveSign));
  EXPECT_EQ("positive-zero", denormalModeKindName(DenormalMode::PositiveZero));
  EXPECT_EQ("dynamic", denormalModeKindName(DenormalMode::Dynamic));
  EXPECT_EQ("", denormalModeKindName(DenormalMode::Invalid));
}

TEST(FloatingPointModeTest, ParseDenormalFPAttribute) {
  EXPECT_EQ(DenormalMode(DenormalMode::IEEE, DenormalMode::IEEE),
            parseDenormalFPAttribute("ieee"));
  EXPECT_EQ(DenormalMode(DenormalMode::IEEE, DenormalMode::IEEE),
            parseDenormalFPAttribute("ieee,ieee"));
  EXPECT_EQ(DenormalMode(DenormalMode::IEEE, DenormalMode::IEEE),
            parseDenormalFPAttribute("ieee,"));
  EXPECT_EQ(DenormalMode(DenormalMode::IEEE, DenormalMode::IEEE),
            parseDenormalFPAttribute(""));
  EXPECT_EQ(DenormalMode(DenormalMode::IEEE, DenormalMode::IEEE),
            parseDenormalFPAttribute(","));

  EXPECT_EQ(DenormalMode(DenormalMode::PreserveSign, DenormalMode::PreserveSign),
            parseDenormalFPAttribute("preserve-sign"));
  EXPECT_EQ(DenormalMode(DenormalMode::PreserveSign, DenormalMode::PreserveSign),
            parseDenormalFPAttribute("preserve-sign,"));
  EXPECT_EQ(DenormalMode(DenormalMode::PreserveSign, DenormalMode::PreserveSign),
            parseDenormalFPAttribute("preserve-sign,preserve-sign"));

  EXPECT_EQ(DenormalMode(DenormalMode::PositiveZero, DenormalMode::PositiveZero),
            parseDenormalFPAttribute("positive-zero"));
  EXPECT_EQ(DenormalMode(DenormalMode::PositiveZero, DenormalMode::PositiveZero),
            parseDenormalFPAttribute("positive-zero,positive-zero"));

  EXPECT_EQ(DenormalMode(DenormalMode::Dynamic, DenormalMode::Dynamic),
            parseDenormalFPAttribute("dynamic"));
  EXPECT_EQ(DenormalMode(DenormalMode::Dynamic, DenormalMode::Dynamic),
            parseDenormalFPAttribute("dynamic,dynamic"));

  EXPECT_EQ(DenormalMode(DenormalMode::IEEE, DenormalMode::PositiveZero),
            parseDenormalFPAttribute("ieee,positive-zero"));
  EXPECT_EQ(DenormalMode(DenormalMode::PositiveZero, DenormalMode::IEEE),
            parseDenormalFPAttribute("positive-zero,ieee"));

  EXPECT_EQ(DenormalMode(DenormalMode::PreserveSign, DenormalMode::IEEE),
            parseDenormalFPAttribute("preserve-sign,ieee"));
  EXPECT_EQ(DenormalMode(DenormalMode::IEEE, DenormalMode::PreserveSign),
            parseDenormalFPAttribute("ieee,preserve-sign"));

  EXPECT_EQ(DenormalMode(DenormalMode::Dynamic, DenormalMode::PreserveSign),
            parseDenormalFPAttribute("dynamic,preserve-sign"));
  EXPECT_EQ(DenormalMode(DenormalMode::PreserveSign, DenormalMode::Dynamic),
            parseDenormalFPAttribute("preserve-sign,dynamic"));

  EXPECT_EQ(DenormalMode(DenormalMode::Invalid, DenormalMode::Invalid),
            parseDenormalFPAttribute("foo"));
  EXPECT_EQ(DenormalMode(DenormalMode::Invalid, DenormalMode::Invalid),
            parseDenormalFPAttribute("foo,foo"));
  EXPECT_EQ(DenormalMode(DenormalMode::Invalid, DenormalMode::Invalid),
            parseDenormalFPAttribute("foo,bar"));
}

TEST(FloatingPointModeTest, RenderDenormalFPAttribute) {
  EXPECT_EQ(DenormalMode(DenormalMode::Invalid, DenormalMode::Invalid),
            parseDenormalFPAttribute("foo"));

  EXPECT_EQ("ieee,ieee",
            DenormalMode(DenormalMode::IEEE, DenormalMode::IEEE).str());
  EXPECT_EQ(",",
            DenormalMode(DenormalMode::Invalid, DenormalMode::Invalid).str());

  EXPECT_EQ(
    "preserve-sign,preserve-sign",
    DenormalMode(DenormalMode::PreserveSign, DenormalMode::PreserveSign).str());
  EXPECT_EQ("preserve-sign,preserve-sign",
            DenormalMode(DenormalMode::PreserveSign, DenormalMode::PreserveSign)
                .str());

  EXPECT_EQ(
    "positive-zero,positive-zero",
    DenormalMode(DenormalMode::PositiveZero, DenormalMode::PositiveZero).str());
  EXPECT_EQ("positive-zero,positive-zero",
            DenormalMode(DenormalMode::PositiveZero, DenormalMode::PositiveZero)
                .str());

  EXPECT_EQ(
    "ieee,preserve-sign",
    DenormalMode(DenormalMode::IEEE, DenormalMode::PreserveSign).str());

  EXPECT_EQ(
    "preserve-sign,ieee",
    DenormalMode(DenormalMode::PreserveSign, DenormalMode::IEEE).str());

  EXPECT_EQ(
    "preserve-sign,positive-zero",
    DenormalMode(DenormalMode::PreserveSign, DenormalMode::PositiveZero).str());

  EXPECT_EQ("dynamic,dynamic",
            DenormalMode(DenormalMode::Dynamic, DenormalMode::Dynamic).str());
  EXPECT_EQ("ieee,dynamic",
            DenormalMode(DenormalMode::IEEE, DenormalMode::Dynamic).str());
  EXPECT_EQ("dynamic,ieee",
            DenormalMode(DenormalMode::Dynamic, DenormalMode::IEEE).str());
}

TEST(FloatingPointModeTest, DenormalModeIsSimple) {
  EXPECT_TRUE(DenormalMode(DenormalMode::IEEE, DenormalMode::IEEE).isSimple());
  EXPECT_FALSE(DenormalMode(DenormalMode::IEEE,
                            DenormalMode::Invalid).isSimple());
  EXPECT_FALSE(DenormalMode(DenormalMode::PreserveSign,
                            DenormalMode::PositiveZero).isSimple());
  EXPECT_FALSE(DenormalMode(DenormalMode::PreserveSign, DenormalMode::Dynamic)
                   .isSimple());
  EXPECT_FALSE(DenormalMode(DenormalMode::Dynamic, DenormalMode::PreserveSign)
                   .isSimple());
}

TEST(FloatingPointModeTest, DenormalModeIsValid) {
  EXPECT_TRUE(DenormalMode(DenormalMode::IEEE, DenormalMode::IEEE).isValid());
  EXPECT_FALSE(DenormalMode(DenormalMode::IEEE, DenormalMode::Invalid).isValid());
  EXPECT_FALSE(DenormalMode(DenormalMode::Invalid, DenormalMode::IEEE).isValid());
  EXPECT_FALSE(DenormalMode(DenormalMode::Invalid,
                            DenormalMode::Invalid).isValid());
}

TEST(FloatingPointModeTest, DenormalModeConstructor) {
  EXPECT_EQ(DenormalMode(DenormalMode::Invalid, DenormalMode::Invalid),
            DenormalMode::getInvalid());
  EXPECT_EQ(DenormalMode(DenormalMode::IEEE, DenormalMode::IEEE),
            DenormalMode::getIEEE());
  EXPECT_EQ(DenormalMode::getIEEE(), DenormalMode::getDefault());
  EXPECT_EQ(DenormalMode(DenormalMode::Dynamic, DenormalMode::Dynamic),
            DenormalMode::getDynamic());
  EXPECT_EQ(DenormalMode(DenormalMode::PreserveSign, DenormalMode::PreserveSign),
            DenormalMode::getPreserveSign());
  EXPECT_EQ(DenormalMode(DenormalMode::PositiveZero, DenormalMode::PositiveZero),
            DenormalMode::getPositiveZero());
}

TEST(FloatingPointModeTest, DenormalModeMerge) {
  EXPECT_EQ(
      DenormalMode::getInvalid(),
      DenormalMode::getInvalid().mergeCalleeMode(DenormalMode::getInvalid()));
  EXPECT_EQ(DenormalMode::getIEEE(), DenormalMode::getInvalid().mergeCalleeMode(
                                         DenormalMode::getIEEE()));
  EXPECT_EQ(DenormalMode::getInvalid(), DenormalMode::getIEEE().mergeCalleeMode(
                                            DenormalMode::getInvalid()));

  EXPECT_EQ(DenormalMode::getIEEE(), DenormalMode::getIEEE().mergeCalleeMode(
                                         DenormalMode::getDynamic()));
  EXPECT_EQ(DenormalMode::getPreserveSign(),
            DenormalMode::getPreserveSign().mergeCalleeMode(
                DenormalMode::getDynamic()));
  EXPECT_EQ(DenormalMode::getPositiveZero(),
            DenormalMode::getPositiveZero().mergeCalleeMode(
                DenormalMode::getDynamic()));
  EXPECT_EQ(
      DenormalMode::getDynamic(),
      DenormalMode::getDynamic().mergeCalleeMode(DenormalMode::getDynamic()));

  EXPECT_EQ(DenormalMode(DenormalMode::IEEE, DenormalMode::PreserveSign),
            DenormalMode(DenormalMode::IEEE, DenormalMode::PreserveSign)
                .mergeCalleeMode(
                    DenormalMode(DenormalMode::IEEE, DenormalMode::Dynamic)));

  EXPECT_EQ(DenormalMode(DenormalMode::PreserveSign, DenormalMode::IEEE),
            DenormalMode(DenormalMode::PreserveSign, DenormalMode::IEEE)
                .mergeCalleeMode(
                    DenormalMode(DenormalMode::Dynamic, DenormalMode::IEEE)));

  EXPECT_EQ(
      DenormalMode(DenormalMode::PositiveZero, DenormalMode::PreserveSign),
      DenormalMode(DenormalMode::PositiveZero, DenormalMode::PreserveSign)
          .mergeCalleeMode(
              DenormalMode(DenormalMode::Dynamic, DenormalMode::Dynamic)));

  EXPECT_EQ(
      DenormalMode(DenormalMode::PositiveZero, DenormalMode::PreserveSign),
      DenormalMode(DenormalMode::PositiveZero, DenormalMode::PreserveSign)
          .mergeCalleeMode(
              DenormalMode(DenormalMode::PositiveZero, DenormalMode::Dynamic)));

  EXPECT_EQ(
      DenormalMode(DenormalMode::PositiveZero, DenormalMode::PreserveSign),
      DenormalMode(DenormalMode::PositiveZero, DenormalMode::PreserveSign)
          .mergeCalleeMode(
              DenormalMode(DenormalMode::Dynamic, DenormalMode::PreserveSign)));

  // Test some invalid / undefined behavior cases
  EXPECT_EQ(
      DenormalMode::getPreserveSign(),
      DenormalMode::getIEEE().mergeCalleeMode(DenormalMode::getPreserveSign()));
  EXPECT_EQ(
      DenormalMode::getPreserveSign(),
      DenormalMode::getIEEE().mergeCalleeMode(DenormalMode::getPreserveSign()));
  EXPECT_EQ(
      DenormalMode::getIEEE(),
      DenormalMode::getPreserveSign().mergeCalleeMode(DenormalMode::getIEEE()));
  EXPECT_EQ(
      DenormalMode::getIEEE(),
      DenormalMode::getPreserveSign().mergeCalleeMode(DenormalMode::getIEEE()));
}

TEST(FloatingPointModeTest, DenormalModePredicates) {
  EXPECT_TRUE(DenormalMode::getPreserveSign().inputsAreZero());
  EXPECT_TRUE(DenormalMode::getPositiveZero().inputsAreZero());
  EXPECT_FALSE(DenormalMode::getIEEE().inputsAreZero());
  EXPECT_FALSE(DenormalMode::getDynamic().inputsAreZero());
}

#define TEST_ORDERED_LT(a, b)                                                  \
  EXPECT_TRUE(cannotOrderStrictlyGreater(a, b));                               \
  EXPECT_FALSE(cannotOrderStrictlyGreater(b, a));

TEST(FloatingPointModeTest, cannotOrderStrictlyGreater) {
  EXPECT_TRUE(cannotOrderStrictlyGreater(fcNone, fcNone));
  EXPECT_FALSE(cannotOrderStrictlyGreater(fcAllFlags, fcAllFlags));

  EXPECT_TRUE(cannotOrderStrictlyGreater(fcNan, fcNan));
  EXPECT_TRUE(cannotOrderStrictlyGreater(fcQNan, fcQNan));
  EXPECT_TRUE(cannotOrderStrictlyGreater(fcSNan, fcSNan));
  EXPECT_TRUE(cannotOrderStrictlyGreater(fcSNan, fcQNan));
  EXPECT_TRUE(cannotOrderStrictlyGreater(fcQNan, fcSNan));
  EXPECT_TRUE(cannotOrderStrictlyGreater(fcQNan, fcNan));
  EXPECT_TRUE(cannotOrderStrictlyGreater(fcSNan, fcNan));

  EXPECT_TRUE(cannotOrderStrictlyGreater(fcNegInf, fcSNan));
  EXPECT_TRUE(cannotOrderStrictlyGreater(fcNegInf, fcQNan));
  EXPECT_TRUE(cannotOrderStrictlyGreater(fcNegInf, fcNan));
  EXPECT_TRUE(cannotOrderStrictlyGreater(fcSNan, fcNegInf));
  EXPECT_TRUE(cannotOrderStrictlyGreater(fcQNan, fcNegInf));
  EXPECT_TRUE(cannotOrderStrictlyGreater(fcNan, fcNegInf));
  EXPECT_TRUE(cannotOrderStrictlyGreater(fcNegInf, fcNegInf));
  EXPECT_TRUE(cannotOrderStrictlyGreater(fcNegZero, fcPosZero));
  EXPECT_TRUE(cannotOrderStrictlyGreater(fcNegZero, fcPosZero, true));
  EXPECT_TRUE(cannotOrderStrictlyGreater(fcPosZero, fcNegZero));
  EXPECT_FALSE(cannotOrderStrictlyGreater(fcPosZero, fcNegZero, true));

  EXPECT_TRUE(cannotOrderStrictlyGreater(fcPosZero, fcPosZero));
  EXPECT_TRUE(cannotOrderStrictlyGreater(fcPosZero, fcPosZero, true));

  EXPECT_TRUE(cannotOrderStrictlyGreater(fcNegZero, fcNegZero));
  EXPECT_TRUE(cannotOrderStrictlyGreater(fcNegZero, fcNegZero, true));

  EXPECT_TRUE(cannotOrderStrictlyGreater(fcNegSubnormal, fcNegZero));
  EXPECT_FALSE(cannotOrderStrictlyGreater(fcNegZero, fcNegSubnormal));

  EXPECT_TRUE(cannotOrderStrictlyGreater(fcNegZero, fcPosSubnormal));
  EXPECT_FALSE(cannotOrderStrictlyGreater(fcPosSubnormal, fcNegZero));

  EXPECT_FALSE(cannotOrderStrictlyGreater(fcNegZero, fcSubnormal));
  EXPECT_FALSE(cannotOrderStrictlyGreater(fcSubnormal, fcNegZero));

  EXPECT_TRUE(cannotOrderStrictlyGreater(fcPosZero, fcPosSubnormal));
  EXPECT_FALSE(cannotOrderStrictlyGreater(fcPosSubnormal, fcPosZero));

  EXPECT_FALSE(cannotOrderStrictlyGreater(fcPosZero, fcNegSubnormal));
  EXPECT_FALSE(cannotOrderStrictlyGreater(fcPosZero, fcNegSubnormal, true));
  EXPECT_FALSE(cannotOrderStrictlyGreater(fcZero, fcSubnormal));
  EXPECT_FALSE(cannotOrderStrictlyGreater(fcZero, fcSubnormal, true));
  EXPECT_FALSE(cannotOrderStrictlyGreater(fcZero, fcNegSubnormal));

  EXPECT_TRUE(cannotOrderStrictlyGreater(fcZero, fcPosSubnormal));
  EXPECT_FALSE(cannotOrderStrictlyGreater(fcPosSubnormal, fcZero));

  TEST_ORDERED_LT(fcNegInf, fcNegNormal);
  TEST_ORDERED_LT(fcNegInf, fcNegSubnormal);
  TEST_ORDERED_LT(fcNegInf, fcNegZero);
  TEST_ORDERED_LT(fcNegInf, fcPosZero);
  TEST_ORDERED_LT(fcNegInf, fcPosSubnormal);
  TEST_ORDERED_LT(fcNegInf, fcPosNormal);
  TEST_ORDERED_LT(fcNegInf, fcPosInf);

  TEST_ORDERED_LT(fcNegNormal, fcPosNormal);
  TEST_ORDERED_LT(fcNegNormal, fcPositive);
  TEST_ORDERED_LT(fcNegNormal, fcPositive | fcNan);
  TEST_ORDERED_LT(fcNegNormal | fcNan, fcPositive | fcNan);

  EXPECT_TRUE(cannotOrderStrictlyGreater(fcNegNormal, fcPosNormal | fcNan));
  EXPECT_FALSE(cannotOrderStrictlyGreater(fcPosNormal | fcNan, fcNegNormal));
  EXPECT_FALSE(
      cannotOrderStrictlyGreater(fcPosNormal | fcNan, fcNegNormal | fcNan));
  EXPECT_FALSE(cannotOrderStrictlyGreater(fcNegNormal | fcNan, fcNegNormal));
  EXPECT_FALSE(
      cannotOrderStrictlyGreater(fcNegNormal | fcNan, fcNegNormal | fcNan));

  EXPECT_TRUE(cannotOrderStrictlyGreater(fcNegInf, ~fcNegInf));
  EXPECT_FALSE(cannotOrderStrictlyGreater(~fcNegInf, fcNegInf));

  TEST_ORDERED_LT(fcNegInf, ~(fcNegInf | fcNan));
  TEST_ORDERED_LT(fcNegative, fcPositive);
  TEST_ORDERED_LT(fcNegFinite, fcPosFinite);
  TEST_ORDERED_LT(fcNegZero, fcPosInf);
  TEST_ORDERED_LT(fcPosZero, fcPosInf);
  TEST_ORDERED_LT(fcZero, fcPosInf);

  EXPECT_FALSE(cannotOrderStrictlyGreater(fcNegZero, fcNegInf));
  EXPECT_TRUE(cannotOrderStrictlyGreater(fcNegInf, fcNegZero));

  EXPECT_FALSE(cannotOrderStrictlyGreater(fcZero, fcInf));
  EXPECT_FALSE(cannotOrderStrictlyGreater(fcInf, fcZero));

  EXPECT_FALSE(cannotOrderStrictlyGreater(fcZero, fcInf | fcNan));
  EXPECT_FALSE(cannotOrderStrictlyGreater(fcInf | fcNan, fcZero));

  EXPECT_TRUE(cannotOrderStrictlyGreater(fcNegInf | fcNan, fcZero));
  EXPECT_FALSE(cannotOrderStrictlyGreater(fcPosInf | fcNan, fcZero));

  EXPECT_FALSE(cannotOrderStrictlyGreater(fcZero | fcNan, fcInf));
  EXPECT_FALSE(cannotOrderStrictlyGreater(fcInf, fcZero | fcNan));

  TEST_ORDERED_LT(OrderedLessThanZeroMask, OrderedGreaterThanZeroMask);
  TEST_ORDERED_LT(OrderedLessThanZeroMask, OrderedGreaterThanZeroMask | fcNan);

  TEST_ORDERED_LT(OrderedLessThanZeroMask | fcNegZero,
                  OrderedGreaterThanZeroMask);
  TEST_ORDERED_LT(OrderedLessThanZeroMask | fcPosZero,
                  OrderedGreaterThanZeroMask);
  TEST_ORDERED_LT(OrderedLessThanZeroMask | fcZero, OrderedGreaterThanZeroMask);

  EXPECT_TRUE(cannotOrderStrictlyGreater(fcNegZero, fcPosZero));
  EXPECT_TRUE(cannotOrderStrictlyGreater(fcNegZero, fcPosZero, true));
  EXPECT_TRUE(cannotOrderStrictlyGreater(fcPosZero, fcNegZero));
  EXPECT_FALSE(cannotOrderStrictlyGreater(fcPosZero, fcNegZero, true));

  TEST_ORDERED_LT(fcNegZero, fcPosSubnormal);
  TEST_ORDERED_LT(fcNegZero, fcPosZero | fcPosSubnormal);
  TEST_ORDERED_LT(fcNegZero, OrderedGreaterThanZeroMask);

  EXPECT_FALSE(cannotOrderStrictlyGreater(OrderedLessThanZeroMask,
                                          OrderedLessThanZeroMask | fcNan));
  EXPECT_FALSE(cannotOrderStrictlyGreater(OrderedLessThanZeroMask | fcNan,
                                          OrderedLessThanZeroMask | fcNan));

  TEST_ORDERED_LT(fcZero, fcPosInf);
  TEST_ORDERED_LT(fcZero, fcPosInf | fcNan);

  EXPECT_TRUE(cannotOrderStrictlyGreater(fcZero | fcNan, fcPosInf));

  TEST_ORDERED_LT(fcPosNormal, fcPosInf);
  TEST_ORDERED_LT(fcPosNormal, fcPosInf | fcNan);

  TEST_ORDERED_LT(fcNegInf, fcPosInf);
  TEST_ORDERED_LT(fcNegInf | fcNegZero, fcPosInf);

  EXPECT_TRUE(
      cannotOrderStrictlyGreater(fcNegInf | fcNegZero, fcZero | fcPosInf));
  EXPECT_FALSE(
      cannotOrderStrictlyGreater(fcZero | fcPosInf, fcNegInf | fcNegZero));

  EXPECT_TRUE(cannotOrderStrictlyGreater(fcNegInf | fcNegZero,
                                         fcZero | fcPosInf, true));
  EXPECT_FALSE(cannotOrderStrictlyGreater(fcZero | fcPosInf,
                                          fcNegInf | fcNegZero, true));

  EXPECT_TRUE(cannotOrderStrictlyGreater(fcNegInf | fcNegZero,
                                         fcZero | fcPosInf | fcNan));
  EXPECT_TRUE(cannotOrderStrictlyGreater(fcNegInf | fcNegZero,
                                         fcPosZero | fcPosInf | fcNan));

  EXPECT_TRUE(cannotOrderStrictlyGreater(fcPosInf, fcPosInf));
  EXPECT_TRUE(cannotOrderStrictlyGreater(fcNegInf, fcNegInf));
  EXPECT_TRUE(cannotOrderStrictlyGreater(fcPosZero, fcPosZero));
  EXPECT_TRUE(cannotOrderStrictlyGreater(fcNegZero, fcNegZero));
  EXPECT_FALSE(cannotOrderStrictlyGreater(fcNegSubnormal, fcNegSubnormal));
  EXPECT_FALSE(cannotOrderStrictlyGreater(fcPosSubnormal, fcPosSubnormal));
  EXPECT_FALSE(cannotOrderStrictlyGreater(fcNegNormal, fcNegNormal));
  EXPECT_FALSE(cannotOrderStrictlyGreater(fcPosNormal, fcPosNormal));

  EXPECT_FALSE(cannotOrderStrictlyGreater(fcFinite, fcFinite));

  EXPECT_FALSE(cannotOrderStrictlyGreater(fcFinite, fcInf));
  EXPECT_FALSE(cannotOrderStrictlyGreater(fcInf, fcInf));

  EXPECT_FALSE(cannotOrderStrictlyGreater(fcPosInf, ~fcPosInf));
  EXPECT_TRUE(cannotOrderStrictlyGreater(~fcPosInf, fcPosInf));

  EXPECT_TRUE(cannotOrderStrictlyGreater(fcNegInf, ~fcNegInf));
  EXPECT_FALSE(cannotOrderStrictlyGreater(~fcNegInf, fcNegInf));
}

TEST(FloatingPointModeTest, cannotOrderStrictlyGreaterEq) {
  EXPECT_TRUE(cannotOrderStrictlyGreaterEq(fcNone, fcNone));
  EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcAllFlags, fcAllFlags));

  EXPECT_TRUE(cannotOrderStrictlyGreaterEq(fcNan, fcNan));
  EXPECT_TRUE(cannotOrderStrictlyGreaterEq(fcQNan, fcQNan));
  EXPECT_TRUE(cannotOrderStrictlyGreaterEq(fcSNan, fcSNan));
  EXPECT_TRUE(cannotOrderStrictlyGreaterEq(fcSNan, fcQNan));
  EXPECT_TRUE(cannotOrderStrictlyGreaterEq(fcQNan, fcSNan));
  EXPECT_TRUE(cannotOrderStrictlyGreaterEq(fcQNan, fcNan));
  EXPECT_TRUE(cannotOrderStrictlyGreaterEq(fcSNan, fcNan));

  EXPECT_TRUE(cannotOrderStrictlyGreaterEq(fcNegInf, fcSNan));
  EXPECT_TRUE(cannotOrderStrictlyGreaterEq(fcNegInf, fcQNan));
  EXPECT_TRUE(cannotOrderStrictlyGreaterEq(fcNegInf, fcNan));
  EXPECT_TRUE(cannotOrderStrictlyGreaterEq(fcSNan, fcNegInf));
  EXPECT_TRUE(cannotOrderStrictlyGreaterEq(fcQNan, fcNegInf));
  EXPECT_TRUE(cannotOrderStrictlyGreaterEq(fcNan, fcNegInf));
  EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcNegInf, fcNegInf));
  EXPECT_TRUE(cannotOrderStrictlyGreaterEq(fcNegZero, fcPosZero,
                                           /*OrderedZeroSign=*/true));
  EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcNegZero, fcPosZero));
  EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcPosZero, fcNegZero));
  EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcPosZero, fcNegZero,
                                            /*OrderedZeroSign=*/true));

  EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcPosZero, fcPosZero));
  EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcPosZero, fcPosZero,
                                            /*OrderedZeroSign=*/true));
  EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcNegZero, fcNegZero));
  EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcNegZero, fcNegZero,
                                            /*OrderedZeroSign=*/true));

  EXPECT_FALSE(cannotOrderStrictlyGreaterEq(OrderedLessThanZeroMask,
                                            OrderedLessThanZeroMask));
  EXPECT_FALSE(cannotOrderStrictlyGreaterEq(OrderedLessThanZeroMask,
                                            OrderedLessThanZeroMask | fcNan));

  EXPECT_TRUE(cannotOrderStrictlyGreaterEq(OrderedLessThanZeroMask,
                                           OrderedGreaterThanZeroMask));
  EXPECT_TRUE(cannotOrderStrictlyGreaterEq(OrderedLessThanZeroMask,
                                           OrderedGreaterThanZeroMask | fcNan));

  EXPECT_TRUE(cannotOrderStrictlyGreaterEq(OrderedLessThanZeroMask | fcNan,
                                           OrderedGreaterThanZeroMask));

  EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcNegZero, fcNegZero | fcNan));
  EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcNegZero | fcNan, fcNegZero));

  EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcNegZero, fcPosZero));
  EXPECT_TRUE(cannotOrderStrictlyGreaterEq(fcNegZero, fcPosZero,
                                           /*OrderedZeroSign=*/true));
  EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcPosZero, fcNegZero));
  EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcNegZero | fcNan, fcPosZero));
  EXPECT_TRUE(cannotOrderStrictlyGreaterEq(fcNegZero | fcNan, fcPosZero,
                                           /*OrderedZeroSign=*/true));

  EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcPosZero | fcNan, fcNegZero));
  EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcNegZero, fcPosZero | fcNan));
  EXPECT_TRUE(cannotOrderStrictlyGreaterEq(fcNegZero, fcPosZero | fcNan,
                                           /*OrderedZeroSign=*/true));
  EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcPosZero, fcNegZero | fcNan));

  EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcNegZero, fcZero));
  EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcZero, fcNegZero,
                                            /*OrderedZeroSign=*/true));

  EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcZero, fcPosZero));
  EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcZero, fcPosZero,
                                            /*OrderedZeroSign=*/true));

  EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcPosInf, fcPosInf));
  EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcPosInf, fcPosInf | fcNan));
  EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcPosInf | fcNan, fcPosInf));
  EXPECT_FALSE(
      cannotOrderStrictlyGreaterEq(fcPosInf | fcNan, fcPosInf | fcNan));

  EXPECT_TRUE(cannotOrderStrictlyGreaterEq(fcNegSubnormal, fcPosZero));
  EXPECT_TRUE(cannotOrderStrictlyGreaterEq(fcNegSubnormal, fcNegZero));
  EXPECT_FALSE(
      cannotOrderStrictlyGreaterEq(fcNegSubnormal | fcNegZero, fcNegZero));

  EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcPosSubnormal, fcZero));
  EXPECT_TRUE(cannotOrderStrictlyGreaterEq(fcNegSubnormal, fcZero));
  EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcSubnormal, fcZero));

  EXPECT_TRUE(cannotOrderStrictlyGreaterEq(fcZero, fcPosInf));
  EXPECT_TRUE(cannotOrderStrictlyGreaterEq(fcZero, fcPosInf | fcNan));
  EXPECT_TRUE(cannotOrderStrictlyGreaterEq(fcZero | fcNan, fcPosInf));

  EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcPosNormal, fcPosNormal));
  EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcPosSubnormal, fcPosSubnormal));
  EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcNegNormal, fcNegNormal));
  EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcNegSubnormal, fcNegSubnormal));

  EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcPosNormal | fcPosSubnormal,
                                            fcPosNormal | fcPosSubnormal));
  EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcNegNormal | fcNegSubnormal,
                                            fcNegNormal | fcNegSubnormal));
  EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcNormal, fcNormal));
  EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcSubnormal, fcSubnormal));
  EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcSubnormal | fcNormal,
                                            fcSubnormal | fcNormal));

  EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcNegInf, fcNegInf | fcNan));
  EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcNegInf | fcNan, fcNegInf));

  EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcNegSubnormal, fcNegNormal));
  EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcPosSubnormal, fcNegNormal));

  EXPECT_TRUE(cannotOrderStrictlyGreaterEq(fcPosSubnormal, fcPosNormal));
  EXPECT_TRUE(cannotOrderStrictlyGreaterEq(fcNegSubnormal, fcPosNormal));

  EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcNegSubnormal, fcNegInf));

  EXPECT_FALSE(
      cannotOrderStrictlyGreaterEq(fcNegInf | fcNegZero, fcZero | fcPosInf));
  EXPECT_FALSE(
      cannotOrderStrictlyGreaterEq(fcZero | fcPosInf, fcNegInf | fcNegZero));

  EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcNegInf | fcNegZero,
                                            fcZero | fcPosInf | fcNan));
  EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcNegInf | fcNegZero,
                                            fcPosZero | fcPosInf | fcNan));
  EXPECT_TRUE(cannotOrderStrictlyGreaterEq(fcNegInf | fcNegZero,
                                           fcPosZero | fcPosInf | fcNan,
                                           /*OrderedZeroSign=*/true));

  EXPECT_FALSE(
      cannotOrderStrictlyGreaterEq(fcPosInf | fcPosNormal, fcPosNormal));
  EXPECT_FALSE(
      cannotOrderStrictlyGreaterEq(fcPosNormal, fcPosInf | fcPosNormal));
  EXPECT_FALSE(cannotOrderStrictlyGreaterEq(
      fcPosInf | fcPosNormal | fcSubnormal, fcPosNormal));
  EXPECT_FALSE(cannotOrderStrictlyGreaterEq(
      fcPosNormal, fcPosInf | fcPosNormal | fcSubnormal));

  EXPECT_FALSE(
      cannotOrderStrictlyGreaterEq(fcPosSubnormal | fcPosZero, fcPosZero));
  EXPECT_FALSE(
      cannotOrderStrictlyGreaterEq(fcPosZero, fcPosSubnormal | fcPosZero));

  EXPECT_FALSE(
      cannotOrderStrictlyGreaterEq(fcSubnormal | fcPosZero, fcPosZero));
  EXPECT_FALSE(
      cannotOrderStrictlyGreaterEq(fcPosZero, fcSubnormal | fcPosZero));

  EXPECT_FALSE(
      cannotOrderStrictlyGreaterEq(fcSubnormal | fcPosZero, fcNegZero));
  EXPECT_FALSE(
      cannotOrderStrictlyGreaterEq(fcNegZero, fcSubnormal | fcPosZero));

  EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcNegative, fcPositive));
  EXPECT_TRUE(cannotOrderStrictlyGreaterEq(fcNegative, fcPositive,
                                           /*OrderedZeroSign=*/true));
  EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcPositive, fcNegative));

  EXPECT_FALSE(
      cannotOrderStrictlyGreaterEq(fcNegative | fcNan, fcPositive | fcNan));
  EXPECT_TRUE(cannotOrderStrictlyGreaterEq(
      fcNegative | fcNan, fcPositive | fcNan, /*OrderedZeroSign=*/true));
  EXPECT_FALSE(
      cannotOrderStrictlyGreaterEq(fcPositive | fcNan, fcNegative | fcNan));

  EXPECT_TRUE(cannotOrderStrictlyGreaterEq(fcZero, fcNan));
  EXPECT_TRUE(cannotOrderStrictlyGreaterEq(fcNan, fcZero));

  EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcZero, fcSubnormal));
  EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcSubnormal, fcZero));

  EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcFinite, fcFinite));

  EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcFinite, fcInf));
  EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcInf, fcInf));

  EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcNegFinite, fcPosFinite));
  EXPECT_TRUE(cannotOrderStrictlyGreaterEq(fcNegFinite, fcPosFinite,
                                           /*OrderedZeroSign=*/true));
  EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcPosFinite, fcNegFinite));

  EXPECT_FALSE(
      cannotOrderStrictlyGreaterEq(fcNegFinite, fcPosFinite | fcNegZero));
  EXPECT_FALSE(
      cannotOrderStrictlyGreaterEq(fcPosFinite | fcNegZero, fcNegFinite));

  EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcZero | fcInf, fcZero | fcInf));
  EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcZero, fcZero | fcInf));
  EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcZero | fcInf, fcZero));
  EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcZero | fcInf | fcNormal, fcZero));

  EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcPosInf, ~fcPosInf));
  EXPECT_TRUE(cannotOrderStrictlyGreaterEq(~fcPosInf, fcPosInf));

  EXPECT_TRUE(cannotOrderStrictlyGreaterEq(fcNegInf, ~fcNegInf));
  EXPECT_FALSE(cannotOrderStrictlyGreaterEq(~fcNegInf, fcNegInf));
}

TEST(FloatingPointModeTest, cannotOrderStrictlyLess) {
  EXPECT_TRUE(cannotOrderStrictlyLess(fcNone, fcNone));
  EXPECT_FALSE(cannotOrderStrictlyLess(fcAllFlags, fcAllFlags));

  EXPECT_FALSE(cannotOrderStrictlyLess(OrderedLessThanZeroMask,
                                       OrderedLessThanZeroMask));
  EXPECT_FALSE(cannotOrderStrictlyLess(OrderedLessThanZeroMask,
                                       OrderedGreaterThanZeroMask));

  EXPECT_TRUE(cannotOrderStrictlyLess(OrderedGreaterThanZeroMask,
                                      OrderedLessThanZeroMask));

  EXPECT_TRUE(cannotOrderStrictlyLess(fcPositive, fcNegative));
  EXPECT_TRUE(cannotOrderStrictlyLess(fcPositive, fcNegative,
                                      /*OrderedZeroSign=*/true));

  EXPECT_FALSE(cannotOrderStrictlyLess(fcNegative, fcPositive));
  EXPECT_FALSE(cannotOrderStrictlyLess(fcNegative, fcPositive,
                                       /*OrderedZeroSign=*/true));

  EXPECT_TRUE(cannotOrderStrictlyLess(fcPositive | fcNan, fcNegative));
  EXPECT_TRUE(cannotOrderStrictlyLess(fcPositive | fcNan, fcNegative,
                                      /*OrderedZeroSign=*/true));

  EXPECT_TRUE(cannotOrderStrictlyLess(fcPositive, fcNegative | fcNan));
  EXPECT_TRUE(cannotOrderStrictlyLess(fcPositive, fcNegative | fcNan,
                                      /*OrderedZeroSign=*/true));

  EXPECT_TRUE(cannotOrderStrictlyLess(OrderedGreaterThanZeroMask | fcNan,
                                      OrderedLessThanZeroMask));
  EXPECT_TRUE(cannotOrderStrictlyLess(OrderedGreaterThanZeroMask,
                                      OrderedLessThanZeroMask | fcNan));
  EXPECT_TRUE(cannotOrderStrictlyLess(OrderedGreaterThanZeroMask | fcNan,
                                      OrderedLessThanZeroMask | fcNan));

  EXPECT_TRUE(cannotOrderStrictlyLess(fcNan, fcNan));
  EXPECT_TRUE(cannotOrderStrictlyLess(fcQNan, fcQNan));
  EXPECT_TRUE(cannotOrderStrictlyLess(fcSNan, fcSNan));
  EXPECT_TRUE(cannotOrderStrictlyLess(fcSNan, fcQNan));
  EXPECT_TRUE(cannotOrderStrictlyLess(fcQNan, fcSNan));
  EXPECT_TRUE(cannotOrderStrictlyLess(fcQNan, fcNan));
  EXPECT_TRUE(cannotOrderStrictlyLess(fcSNan, fcNan));

  EXPECT_TRUE(cannotOrderStrictlyLess(fcNegInf, fcSNan));
  EXPECT_TRUE(cannotOrderStrictlyLess(fcNegInf, fcQNan));
  EXPECT_TRUE(cannotOrderStrictlyLess(fcNegInf, fcNan));
  EXPECT_TRUE(cannotOrderStrictlyLess(fcSNan, fcNegInf));
  EXPECT_TRUE(cannotOrderStrictlyLess(fcQNan, fcNegInf));
  EXPECT_TRUE(cannotOrderStrictlyLess(fcNan, fcNegInf));
  EXPECT_TRUE(cannotOrderStrictlyLess(fcNegInf, fcNegInf));
  EXPECT_TRUE(cannotOrderStrictlyLess(fcNegZero, fcPosZero));
  EXPECT_TRUE(cannotOrderStrictlyLess(fcPosZero, fcNegZero));
  EXPECT_TRUE(cannotOrderStrictlyLess(fcPosZero, fcPosZero));
  EXPECT_FALSE(cannotOrderStrictlyLessEq(fcPosZero, fcPosZero));

  EXPECT_TRUE(
      cannotOrderStrictlyLess(fcPosZero, fcNegZero, /*OrderedZeroSign=*/true));

  EXPECT_TRUE(cannotOrderStrictlyLess(fcZero, fcPosZero));
  EXPECT_FALSE(cannotOrderStrictlyLess(fcZero, fcPosZero, true));
  EXPECT_TRUE(cannotOrderStrictlyLess(fcPosZero, fcZero));
  EXPECT_TRUE(cannotOrderStrictlyLess(fcPosZero, fcZero, true));
  EXPECT_TRUE(cannotOrderStrictlyLess(fcZero, fcNegZero));
  EXPECT_TRUE(cannotOrderStrictlyLess(fcZero, fcNegZero, true));
  EXPECT_TRUE(cannotOrderStrictlyLess(fcNegZero, fcZero));
  EXPECT_FALSE(cannotOrderStrictlyLess(fcNegZero, fcZero, true));
  EXPECT_TRUE(cannotOrderStrictlyLess(fcZero, fcZero));
  EXPECT_FALSE(cannotOrderStrictlyLess(fcZero, fcZero, true));

  EXPECT_TRUE(cannotOrderStrictlyLess(fcInf, fcNan));
  EXPECT_TRUE(cannotOrderStrictlyLess(fcNan, fcInf));

  EXPECT_TRUE(
      cannotOrderStrictlyLess(fcPosInf | fcPosZero, fcNegZero | fcNegInf));
  EXPECT_TRUE(cannotOrderStrictlyLess(
      fcPosInf | fcPosZero, fcNegZero | fcNegInf, /*OrderedZeroSign=*/true));

  EXPECT_TRUE(cannotOrderStrictlyLess(fcPosInf | fcPosZero, fcZero | fcNegInf));
  EXPECT_TRUE(cannotOrderStrictlyLess(fcPosInf | fcPosZero, fcZero | fcNegInf,
                                      /*OrderedZeroSign=*/true));

  EXPECT_FALSE(
      cannotOrderStrictlyLess(fcZero | fcNegInf, fcPosInf | fcPosZero));

  EXPECT_FALSE(
      cannotOrderStrictlyLess(fcNegInf | fcNegZero, fcZero | fcPosInf));
  EXPECT_FALSE(
      cannotOrderStrictlyLess(fcNegInf | fcNegZero, fcZero | fcPosInf, true));

  EXPECT_TRUE(cannotOrderStrictlyLess(fcZero | fcPosInf, fcNegInf | fcNegZero));
  EXPECT_TRUE(
      cannotOrderStrictlyLess(fcZero | fcPosInf, fcNegInf | fcNegZero, true));

  EXPECT_TRUE(cannotOrderStrictlyLess(fcPosInf, ~fcPosInf));
  EXPECT_FALSE(cannotOrderStrictlyLess(~fcPosInf, fcPosInf));

  EXPECT_FALSE(cannotOrderStrictlyLess(fcNegInf, ~fcNegInf));
  EXPECT_TRUE(cannotOrderStrictlyLess(~fcNegInf, fcNegInf));
}

TEST(FloatingPointModeTest, cannotOrderStrictlyLessEq) {
  EXPECT_TRUE(cannotOrderStrictlyLessEq(fcNone, fcNone));
  EXPECT_FALSE(cannotOrderStrictlyLessEq(fcAllFlags, fcAllFlags));

  EXPECT_FALSE(cannotOrderStrictlyLessEq(OrderedLessThanZeroMask,
                                         OrderedLessThanZeroMask));
  EXPECT_FALSE(cannotOrderStrictlyLessEq(OrderedLessThanZeroMask,
                                         OrderedGreaterThanZeroMask));

  EXPECT_TRUE(cannotOrderStrictlyLessEq(OrderedGreaterThanZeroMask,
                                        OrderedLessThanZeroMask));

  EXPECT_FALSE(cannotOrderStrictlyLessEq(fcPositive, fcNegative));
  EXPECT_TRUE(cannotOrderStrictlyLessEq(fcPositive, fcNegative,
                                        /*OrderedZeroSign=*/true));

  EXPECT_FALSE(cannotOrderStrictlyLessEq(fcNegative, fcPositive));
  EXPECT_FALSE(cannotOrderStrictlyLessEq(fcNegative, fcPositive,
                                         /*OrderedZeroSign=*/true));

  EXPECT_FALSE(cannotOrderStrictlyLessEq(fcPositive | fcNan, fcNegative));
  EXPECT_TRUE(cannotOrderStrictlyLessEq(fcPositive | fcNan, fcNegative,
                                        /*OrderedZeroSign=*/true));

  EXPECT_FALSE(cannotOrderStrictlyLessEq(fcPositive, fcNegative | fcNan));
  EXPECT_TRUE(cannotOrderStrictlyLessEq(fcPositive, fcNegative | fcNan,
                                        /*OrderedZeroSign=*/true));

  EXPECT_TRUE(cannotOrderStrictlyLessEq(OrderedGreaterThanZeroMask | fcNan,
                                        OrderedLessThanZeroMask));
  EXPECT_TRUE(cannotOrderStrictlyLessEq(OrderedGreaterThanZeroMask,
                                        OrderedLessThanZeroMask | fcNan));
  EXPECT_TRUE(cannotOrderStrictlyLessEq(OrderedGreaterThanZeroMask | fcNan,
                                        OrderedLessThanZeroMask | fcNan));

  EXPECT_TRUE(cannotOrderStrictlyLessEq(fcNan, fcNan));
  EXPECT_TRUE(cannotOrderStrictlyLessEq(fcQNan, fcQNan));
  EXPECT_TRUE(cannotOrderStrictlyLessEq(fcSNan, fcSNan));
  EXPECT_TRUE(cannotOrderStrictlyLessEq(fcSNan, fcQNan));
  EXPECT_TRUE(cannotOrderStrictlyLessEq(fcQNan, fcSNan));
  EXPECT_TRUE(cannotOrderStrictlyLessEq(fcQNan, fcNan));
  EXPECT_TRUE(cannotOrderStrictlyLessEq(fcSNan, fcNan));

  EXPECT_TRUE(cannotOrderStrictlyLessEq(fcNegInf, fcSNan));
  EXPECT_TRUE(cannotOrderStrictlyLessEq(fcNegInf, fcQNan));
  EXPECT_TRUE(cannotOrderStrictlyLessEq(fcNegInf, fcNan));
  EXPECT_TRUE(cannotOrderStrictlyLessEq(fcSNan, fcNegInf));
  EXPECT_TRUE(cannotOrderStrictlyLessEq(fcQNan, fcNegInf));
  EXPECT_TRUE(cannotOrderStrictlyLessEq(fcNan, fcNegInf));
  EXPECT_FALSE(cannotOrderStrictlyLessEq(fcNegInf, fcNegInf));
  EXPECT_FALSE(cannotOrderStrictlyLessEq(fcNegZero, fcPosZero));
  EXPECT_FALSE(cannotOrderStrictlyLessEq(fcPosZero, fcNegZero));
  EXPECT_TRUE(cannotOrderStrictlyLessEq(fcPosZero, fcNegZero,
                                        /*OrderedZeroSign=*/true));

  EXPECT_FALSE(cannotOrderStrictlyLessEq(fcZero, fcPosZero));
  EXPECT_FALSE(cannotOrderStrictlyLessEq(fcPosZero, fcZero));
  EXPECT_FALSE(cannotOrderStrictlyLessEq(fcZero, fcNegZero));
  EXPECT_FALSE(cannotOrderStrictlyLessEq(fcNegZero, fcZero));
  EXPECT_FALSE(cannotOrderStrictlyLessEq(fcZero, fcZero));

  EXPECT_TRUE(cannotOrderStrictlyLessEq(fcInf, fcNan));
  EXPECT_TRUE(cannotOrderStrictlyLessEq(fcNan, fcInf));

  EXPECT_FALSE(
      cannotOrderStrictlyLessEq(fcPosInf | fcPosZero, fcNegZero | fcNegInf));
  EXPECT_TRUE(cannotOrderStrictlyLessEq(
      fcPosInf | fcPosZero, fcNegZero | fcNegInf, /*OrderedZeroSign=*/true));

  EXPECT_FALSE(
      cannotOrderStrictlyLessEq(fcPosInf | fcPosZero, fcZero | fcNegInf));

  EXPECT_FALSE(
      cannotOrderStrictlyLessEq(fcZero | fcNegInf, fcPosInf | fcPosZero));

  EXPECT_FALSE(
      cannotOrderStrictlyLessEq(fcNegInf | fcNegZero, fcZero | fcPosInf));
  EXPECT_FALSE(
      cannotOrderStrictlyLessEq(fcZero | fcPosInf, fcNegInf | fcNegZero));

  EXPECT_TRUE(cannotOrderStrictlyLessEq(fcPosInf, ~fcPosInf));
  EXPECT_FALSE(cannotOrderStrictlyLessEq(~fcPosInf, fcPosInf));

  EXPECT_FALSE(cannotOrderStrictlyLessEq(fcNegInf, ~fcNegInf));
  EXPECT_TRUE(cannotOrderStrictlyLessEq(~fcNegInf, fcNegInf));
}
}