// Copyright 2018 The Abseil Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include "absl/types/compare.h"
#include "gtest/gtest.h"
#include "absl/base/casts.h"
namespace absl {
ABSL_NAMESPACE_BEGIN
namespace {
// This is necessary to avoid a bunch of lint warnings suggesting that we use
// EXPECT_EQ/etc., which doesn't work in this case because they convert the `0`
// to an int, which can't be converted to the unspecified zero type.
bool Identity(bool b) { return b; }
TEST(Compare, PartialOrdering) {
EXPECT_TRUE(Identity(partial_ordering::less < 0));
EXPECT_TRUE(Identity(0 > partial_ordering::less));
EXPECT_TRUE(Identity(partial_ordering::less <= 0));
EXPECT_TRUE(Identity(0 >= partial_ordering::less));
EXPECT_TRUE(Identity(partial_ordering::equivalent == 0));
EXPECT_TRUE(Identity(0 == partial_ordering::equivalent));
EXPECT_TRUE(Identity(partial_ordering::greater > 0));
EXPECT_TRUE(Identity(0 < partial_ordering::greater));
EXPECT_TRUE(Identity(partial_ordering::greater >= 0));
EXPECT_TRUE(Identity(0 <= partial_ordering::greater));
EXPECT_TRUE(Identity(partial_ordering::unordered != 0));
EXPECT_TRUE(Identity(0 != partial_ordering::unordered));
EXPECT_FALSE(Identity(partial_ordering::unordered < 0));
EXPECT_FALSE(Identity(0 < partial_ordering::unordered));
EXPECT_FALSE(Identity(partial_ordering::unordered <= 0));
EXPECT_FALSE(Identity(0 <= partial_ordering::unordered));
EXPECT_FALSE(Identity(partial_ordering::unordered > 0));
EXPECT_FALSE(Identity(0 > partial_ordering::unordered));
EXPECT_FALSE(Identity(partial_ordering::unordered >= 0));
EXPECT_FALSE(Identity(0 >= partial_ordering::unordered));
const partial_ordering values[] = {
partial_ordering::less, partial_ordering::equivalent,
partial_ordering::greater, partial_ordering::unordered};
for (const auto& lhs : values) {
for (const auto& rhs : values) {
const bool are_equal = &lhs == &rhs;
EXPECT_EQ(lhs == rhs, are_equal);
EXPECT_EQ(lhs != rhs, !are_equal);
}
}
}
TEST(Compare, WeakOrdering) {
EXPECT_TRUE(Identity(weak_ordering::less < 0));
EXPECT_TRUE(Identity(0 > weak_ordering::less));
EXPECT_TRUE(Identity(weak_ordering::less <= 0));
EXPECT_TRUE(Identity(0 >= weak_ordering::less));
EXPECT_TRUE(Identity(weak_ordering::equivalent == 0));
EXPECT_TRUE(Identity(0 == weak_ordering::equivalent));
EXPECT_TRUE(Identity(weak_ordering::greater > 0));
EXPECT_TRUE(Identity(0 < weak_ordering::greater));
EXPECT_TRUE(Identity(weak_ordering::greater >= 0));
EXPECT_TRUE(Identity(0 <= weak_ordering::greater));
const weak_ordering values[] = {
weak_ordering::less, weak_ordering::equivalent, weak_ordering::greater};
for (const auto& lhs : values) {
for (const auto& rhs : values) {
const bool are_equal = &lhs == &rhs;
EXPECT_EQ(lhs == rhs, are_equal);
EXPECT_EQ(lhs != rhs, !are_equal);
}
}
}
TEST(Compare, StrongOrdering) {
EXPECT_TRUE(Identity(strong_ordering::less < 0));
EXPECT_TRUE(Identity(0 > strong_ordering::less));
EXPECT_TRUE(Identity(strong_ordering::less <= 0));
EXPECT_TRUE(Identity(0 >= strong_ordering::less));
EXPECT_TRUE(Identity(strong_ordering::equal == 0));
EXPECT_TRUE(Identity(0 == strong_ordering::equal));
EXPECT_TRUE(Identity(strong_ordering::equivalent == 0));
EXPECT_TRUE(Identity(0 == strong_ordering::equivalent));
EXPECT_TRUE(Identity(strong_ordering::greater > 0));
EXPECT_TRUE(Identity(0 < strong_ordering::greater));
EXPECT_TRUE(Identity(strong_ordering::greater >= 0));
EXPECT_TRUE(Identity(0 <= strong_ordering::greater));
const strong_ordering values[] = {
strong_ordering::less, strong_ordering::equal, strong_ordering::greater};
for (const auto& lhs : values) {
for (const auto& rhs : values) {
const bool are_equal = &lhs == &rhs;
EXPECT_EQ(lhs == rhs, are_equal);
EXPECT_EQ(lhs != rhs, !are_equal);
}
}
EXPECT_TRUE(Identity(strong_ordering::equivalent == strong_ordering::equal));
}
TEST(Compare, Conversions) {
EXPECT_TRUE(
Identity(implicit_cast<partial_ordering>(weak_ordering::less) != 0));
EXPECT_TRUE(
Identity(implicit_cast<partial_ordering>(weak_ordering::less) < 0));
EXPECT_TRUE(
Identity(implicit_cast<partial_ordering>(weak_ordering::less) <= 0));
EXPECT_TRUE(Identity(
implicit_cast<partial_ordering>(weak_ordering::equivalent) == 0));
EXPECT_TRUE(
Identity(implicit_cast<partial_ordering>(weak_ordering::greater) != 0));
EXPECT_TRUE(
Identity(implicit_cast<partial_ordering>(weak_ordering::greater) > 0));
EXPECT_TRUE(
Identity(implicit_cast<partial_ordering>(weak_ordering::greater) >= 0));
EXPECT_TRUE(
Identity(implicit_cast<partial_ordering>(strong_ordering::less) != 0));
EXPECT_TRUE(
Identity(implicit_cast<partial_ordering>(strong_ordering::less) < 0));
EXPECT_TRUE(
Identity(implicit_cast<partial_ordering>(strong_ordering::less) <= 0));
EXPECT_TRUE(
Identity(implicit_cast<partial_ordering>(strong_ordering::equal) == 0));
EXPECT_TRUE(Identity(
implicit_cast<partial_ordering>(strong_ordering::equivalent) == 0));
EXPECT_TRUE(
Identity(implicit_cast<partial_ordering>(strong_ordering::greater) != 0));
EXPECT_TRUE(
Identity(implicit_cast<partial_ordering>(strong_ordering::greater) > 0));
EXPECT_TRUE(
Identity(implicit_cast<partial_ordering>(strong_ordering::greater) >= 0));
EXPECT_TRUE(
Identity(implicit_cast<weak_ordering>(strong_ordering::less) != 0));
EXPECT_TRUE(
Identity(implicit_cast<weak_ordering>(strong_ordering::less) < 0));
EXPECT_TRUE(
Identity(implicit_cast<weak_ordering>(strong_ordering::less) <= 0));
EXPECT_TRUE(
Identity(implicit_cast<weak_ordering>(strong_ordering::equal) == 0));
EXPECT_TRUE(
Identity(implicit_cast<weak_ordering>(strong_ordering::equivalent) == 0));
EXPECT_TRUE(
Identity(implicit_cast<weak_ordering>(strong_ordering::greater) != 0));
EXPECT_TRUE(
Identity(implicit_cast<weak_ordering>(strong_ordering::greater) > 0));
EXPECT_TRUE(
Identity(implicit_cast<weak_ordering>(strong_ordering::greater) >= 0));
}
struct WeakOrderingLess {
template <typename T>
absl::weak_ordering operator()(const T& a, const T& b) const {
return a < b ? absl::weak_ordering::less
: a == b ? absl::weak_ordering::equivalent
: absl::weak_ordering::greater;
}
};
TEST(CompareResultAsLessThan, SanityTest) {
EXPECT_FALSE(absl::compare_internal::compare_result_as_less_than(false));
EXPECT_TRUE(absl::compare_internal::compare_result_as_less_than(true));
EXPECT_TRUE(
absl::compare_internal::compare_result_as_less_than(weak_ordering::less));
EXPECT_FALSE(absl::compare_internal::compare_result_as_less_than(
weak_ordering::equivalent));
EXPECT_FALSE(absl::compare_internal::compare_result_as_less_than(
weak_ordering::greater));
}
TEST(DoLessThanComparison, SanityTest) {
std::less<int> less;
WeakOrderingLess weak;
EXPECT_TRUE(absl::compare_internal::do_less_than_comparison(less, -1, 0));
EXPECT_TRUE(absl::compare_internal::do_less_than_comparison(weak, -1, 0));
EXPECT_FALSE(absl::compare_internal::do_less_than_comparison(less, 10, 10));
EXPECT_FALSE(absl::compare_internal::do_less_than_comparison(weak, 10, 10));
EXPECT_FALSE(absl::compare_internal::do_less_than_comparison(less, 10, 5));
EXPECT_FALSE(absl::compare_internal::do_less_than_comparison(weak, 10, 5));
}
TEST(CompareResultAsOrdering, SanityTest) {
EXPECT_TRUE(
Identity(absl::compare_internal::compare_result_as_ordering(-1) < 0));
EXPECT_FALSE(
Identity(absl::compare_internal::compare_result_as_ordering(-1) == 0));
EXPECT_FALSE(
Identity(absl::compare_internal::compare_result_as_ordering(-1) > 0));
EXPECT_TRUE(Identity(absl::compare_internal::compare_result_as_ordering(
weak_ordering::less) < 0));
EXPECT_FALSE(Identity(absl::compare_internal::compare_result_as_ordering(
weak_ordering::less) == 0));
EXPECT_FALSE(Identity(absl::compare_internal::compare_result_as_ordering(
weak_ordering::less) > 0));
EXPECT_FALSE(
Identity(absl::compare_internal::compare_result_as_ordering(0) < 0));
EXPECT_TRUE(
Identity(absl::compare_internal::compare_result_as_ordering(0) == 0));
EXPECT_FALSE(
Identity(absl::compare_internal::compare_result_as_ordering(0) > 0));
EXPECT_FALSE(Identity(absl::compare_internal::compare_result_as_ordering(
weak_ordering::equivalent) < 0));
EXPECT_TRUE(Identity(absl::compare_internal::compare_result_as_ordering(
weak_ordering::equivalent) == 0));
EXPECT_FALSE(Identity(absl::compare_internal::compare_result_as_ordering(
weak_ordering::equivalent) > 0));
EXPECT_FALSE(
Identity(absl::compare_internal::compare_result_as_ordering(1) < 0));
EXPECT_FALSE(
Identity(absl::compare_internal::compare_result_as_ordering(1) == 0));
EXPECT_TRUE(
Identity(absl::compare_internal::compare_result_as_ordering(1) > 0));
EXPECT_FALSE(Identity(absl::compare_internal::compare_result_as_ordering(
weak_ordering::greater) < 0));
EXPECT_FALSE(Identity(absl::compare_internal::compare_result_as_ordering(
weak_ordering::greater) == 0));
EXPECT_TRUE(Identity(absl::compare_internal::compare_result_as_ordering(
weak_ordering::greater) > 0));
}
TEST(DoThreeWayComparison, SanityTest) {
std::less<int> less;
WeakOrderingLess weak;
EXPECT_TRUE(Identity(
absl::compare_internal::do_three_way_comparison(less, -1, 0) < 0));
EXPECT_FALSE(Identity(
absl::compare_internal::do_three_way_comparison(less, -1, 0) == 0));
EXPECT_FALSE(Identity(
absl::compare_internal::do_three_way_comparison(less, -1, 0) > 0));
EXPECT_TRUE(Identity(
absl::compare_internal::do_three_way_comparison(weak, -1, 0) < 0));
EXPECT_FALSE(Identity(
absl::compare_internal::do_three_way_comparison(weak, -1, 0) == 0));
EXPECT_FALSE(Identity(
absl::compare_internal::do_three_way_comparison(weak, -1, 0) > 0));
EXPECT_FALSE(Identity(
absl::compare_internal::do_three_way_comparison(less, 10, 10) < 0));
EXPECT_TRUE(Identity(
absl::compare_internal::do_three_way_comparison(less, 10, 10) == 0));
EXPECT_FALSE(Identity(
absl::compare_internal::do_three_way_comparison(less, 10, 10) > 0));
EXPECT_FALSE(Identity(
absl::compare_internal::do_three_way_comparison(weak, 10, 10) < 0));
EXPECT_TRUE(Identity(
absl::compare_internal::do_three_way_comparison(weak, 10, 10) == 0));
EXPECT_FALSE(Identity(
absl::compare_internal::do_three_way_comparison(weak, 10, 10) > 0));
EXPECT_FALSE(Identity(
absl::compare_internal::do_three_way_comparison(less, 10, 5) < 0));
EXPECT_FALSE(Identity(
absl::compare_internal::do_three_way_comparison(less, 10, 5) == 0));
EXPECT_TRUE(Identity(
absl::compare_internal::do_three_way_comparison(less, 10, 5) > 0));
EXPECT_FALSE(Identity(
absl::compare_internal::do_three_way_comparison(weak, 10, 5) < 0));
EXPECT_FALSE(Identity(
absl::compare_internal::do_three_way_comparison(weak, 10, 5) == 0));
EXPECT_TRUE(Identity(
absl::compare_internal::do_three_way_comparison(weak, 10, 5) > 0));
}
#ifdef __cpp_inline_variables
TEST(Compare, StaticAsserts) {
static_assert(partial_ordering::less < 0, "");
static_assert(partial_ordering::equivalent == 0, "");
static_assert(partial_ordering::greater > 0, "");
static_assert(partial_ordering::unordered != 0, "");
static_assert(weak_ordering::less < 0, "");
static_assert(weak_ordering::equivalent == 0, "");
static_assert(weak_ordering::greater > 0, "");
static_assert(strong_ordering::less < 0, "");
static_assert(strong_ordering::equal == 0, "");
static_assert(strong_ordering::equivalent == 0, "");
static_assert(strong_ordering::greater > 0, "");
}
#endif // __cpp_inline_variables
} // namespace
ABSL_NAMESPACE_END
} // namespace absl
Codebase Browser
chromium