log_severity_test.cc (11355B)
1 // Copyright 2018 The Abseil Authors. 2 // 3 // Licensed under the Apache License, Version 2.0 (the "License"); 4 // you may not use this file except in compliance with the License. 5 // You may obtain a copy of the License at 6 // 7 // https://www.apache.org/licenses/LICENSE-2.0 8 // 9 // Unless required by applicable law or agreed to in writing, software 10 // distributed under the License is distributed on an "AS IS" BASIS, 11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 // See the License for the specific language governing permissions and 13 // limitations under the License. 14 15 #include "absl/base/log_severity.h" 16 17 #include <cstdint> 18 #include <ios> 19 #include <limits> 20 #include <ostream> 21 #include <sstream> 22 #include <string> 23 #include <tuple> 24 25 #include "gmock/gmock.h" 26 #include "gtest/gtest.h" 27 #include "absl/flags/internal/flag.h" 28 #include "absl/flags/marshalling.h" 29 #include "absl/strings/str_cat.h" 30 31 namespace { 32 using ::testing::Eq; 33 using ::testing::IsFalse; 34 using ::testing::IsTrue; 35 using ::testing::TestWithParam; 36 using ::testing::Values; 37 38 template <typename T> 39 std::string StreamHelper(T value) { 40 std::ostringstream stream; 41 stream << value; 42 return stream.str(); 43 } 44 45 TEST(StreamTest, Works) { 46 EXPECT_THAT(StreamHelper(static_cast<absl::LogSeverity>(-100)), 47 Eq("absl::LogSeverity(-100)")); 48 EXPECT_THAT(StreamHelper(absl::LogSeverity::kInfo), Eq("INFO")); 49 EXPECT_THAT(StreamHelper(absl::LogSeverity::kWarning), Eq("WARNING")); 50 EXPECT_THAT(StreamHelper(absl::LogSeverity::kError), Eq("ERROR")); 51 EXPECT_THAT(StreamHelper(absl::LogSeverity::kFatal), Eq("FATAL")); 52 EXPECT_THAT(StreamHelper(static_cast<absl::LogSeverity>(4)), 53 Eq("absl::LogSeverity(4)")); 54 } 55 56 static_assert(absl::flags_internal::FlagUseValueAndInitBitStorage< 57 absl::LogSeverity>::value, 58 "Flags of type absl::LogSeverity ought to be lock-free."); 59 60 using ParseFlagFromOutOfRangeIntegerTest = TestWithParam<int64_t>; 61 INSTANTIATE_TEST_SUITE_P( 62 Instantiation, ParseFlagFromOutOfRangeIntegerTest, 63 Values(static_cast<int64_t>(std::numeric_limits<int>::min()) - 1, 64 static_cast<int64_t>(std::numeric_limits<int>::max()) + 1)); 65 TEST_P(ParseFlagFromOutOfRangeIntegerTest, ReturnsError) { 66 const std::string to_parse = absl::StrCat(GetParam()); 67 absl::LogSeverity value; 68 std::string error; 69 EXPECT_THAT(absl::ParseFlag(to_parse, &value, &error), IsFalse()) << value; 70 } 71 72 using ParseFlagFromAlmostOutOfRangeIntegerTest = TestWithParam<int>; 73 INSTANTIATE_TEST_SUITE_P(Instantiation, 74 ParseFlagFromAlmostOutOfRangeIntegerTest, 75 Values(std::numeric_limits<int>::min(), 76 std::numeric_limits<int>::max())); 77 TEST_P(ParseFlagFromAlmostOutOfRangeIntegerTest, YieldsExpectedValue) { 78 const auto expected = static_cast<absl::LogSeverity>(GetParam()); 79 const std::string to_parse = absl::StrCat(GetParam()); 80 absl::LogSeverity value; 81 std::string error; 82 ASSERT_THAT(absl::ParseFlag(to_parse, &value, &error), IsTrue()) << error; 83 EXPECT_THAT(value, Eq(expected)); 84 } 85 86 using ParseFlagFromIntegerMatchingEnumeratorTest = 87 TestWithParam<std::tuple<absl::string_view, absl::LogSeverity>>; 88 INSTANTIATE_TEST_SUITE_P( 89 Instantiation, ParseFlagFromIntegerMatchingEnumeratorTest, 90 Values(std::make_tuple("0", absl::LogSeverity::kInfo), 91 std::make_tuple(" 0", absl::LogSeverity::kInfo), 92 std::make_tuple("-0", absl::LogSeverity::kInfo), 93 std::make_tuple("+0", absl::LogSeverity::kInfo), 94 std::make_tuple("00", absl::LogSeverity::kInfo), 95 std::make_tuple("0 ", absl::LogSeverity::kInfo), 96 std::make_tuple("0x0", absl::LogSeverity::kInfo), 97 std::make_tuple("1", absl::LogSeverity::kWarning), 98 std::make_tuple("+1", absl::LogSeverity::kWarning), 99 std::make_tuple("2", absl::LogSeverity::kError), 100 std::make_tuple("3", absl::LogSeverity::kFatal))); 101 TEST_P(ParseFlagFromIntegerMatchingEnumeratorTest, YieldsExpectedValue) { 102 const absl::string_view to_parse = std::get<0>(GetParam()); 103 const absl::LogSeverity expected = std::get<1>(GetParam()); 104 absl::LogSeverity value; 105 std::string error; 106 ASSERT_THAT(absl::ParseFlag(to_parse, &value, &error), IsTrue()) << error; 107 EXPECT_THAT(value, Eq(expected)); 108 } 109 110 using ParseFlagFromOtherIntegerTest = 111 TestWithParam<std::tuple<absl::string_view, int>>; 112 INSTANTIATE_TEST_SUITE_P(Instantiation, ParseFlagFromOtherIntegerTest, 113 Values(std::make_tuple("-1", -1), 114 std::make_tuple("4", 4), 115 std::make_tuple("010", 10), 116 std::make_tuple("0x10", 16))); 117 TEST_P(ParseFlagFromOtherIntegerTest, YieldsExpectedValue) { 118 const absl::string_view to_parse = std::get<0>(GetParam()); 119 const auto expected = static_cast<absl::LogSeverity>(std::get<1>(GetParam())); 120 absl::LogSeverity value; 121 std::string error; 122 ASSERT_THAT(absl::ParseFlag(to_parse, &value, &error), IsTrue()) << error; 123 EXPECT_THAT(value, Eq(expected)); 124 } 125 126 using ParseFlagFromEnumeratorTest = 127 TestWithParam<std::tuple<absl::string_view, absl::LogSeverity>>; 128 INSTANTIATE_TEST_SUITE_P( 129 Instantiation, ParseFlagFromEnumeratorTest, 130 Values(std::make_tuple("INFO", absl::LogSeverity::kInfo), 131 std::make_tuple("info", absl::LogSeverity::kInfo), 132 std::make_tuple("kInfo", absl::LogSeverity::kInfo), 133 std::make_tuple("iNfO", absl::LogSeverity::kInfo), 134 std::make_tuple("kInFo", absl::LogSeverity::kInfo), 135 std::make_tuple("WARNING", absl::LogSeverity::kWarning), 136 std::make_tuple("warning", absl::LogSeverity::kWarning), 137 std::make_tuple("kWarning", absl::LogSeverity::kWarning), 138 std::make_tuple("WaRnInG", absl::LogSeverity::kWarning), 139 std::make_tuple("KwArNiNg", absl::LogSeverity::kWarning), 140 std::make_tuple("ERROR", absl::LogSeverity::kError), 141 std::make_tuple("error", absl::LogSeverity::kError), 142 std::make_tuple("kError", absl::LogSeverity::kError), 143 std::make_tuple("eRrOr", absl::LogSeverity::kError), 144 std::make_tuple("kErRoR", absl::LogSeverity::kError), 145 std::make_tuple("FATAL", absl::LogSeverity::kFatal), 146 std::make_tuple("fatal", absl::LogSeverity::kFatal), 147 std::make_tuple("kFatal", absl::LogSeverity::kFatal), 148 std::make_tuple("FaTaL", absl::LogSeverity::kFatal), 149 std::make_tuple("KfAtAl", absl::LogSeverity::kFatal), 150 std::make_tuple("DFATAL", absl::kLogDebugFatal), 151 std::make_tuple("dfatal", absl::kLogDebugFatal), 152 std::make_tuple("kLogDebugFatal", absl::kLogDebugFatal), 153 std::make_tuple("dFaTaL", absl::kLogDebugFatal), 154 std::make_tuple("kLoGdEbUgFaTaL", absl::kLogDebugFatal))); 155 TEST_P(ParseFlagFromEnumeratorTest, YieldsExpectedValue) { 156 const absl::string_view to_parse = std::get<0>(GetParam()); 157 const absl::LogSeverity expected = std::get<1>(GetParam()); 158 absl::LogSeverity value; 159 std::string error; 160 ASSERT_THAT(absl::ParseFlag(to_parse, &value, &error), IsTrue()) << error; 161 EXPECT_THAT(value, Eq(expected)); 162 } 163 164 using ParseFlagFromGarbageTest = TestWithParam<absl::string_view>; 165 INSTANTIATE_TEST_SUITE_P(Instantiation, ParseFlagFromGarbageTest, 166 Values("", "\0", " ", "garbage", "kkinfo", "I", 167 "kDFATAL", "LogDebugFatal", "lOgDeBuGfAtAl")); 168 TEST_P(ParseFlagFromGarbageTest, ReturnsError) { 169 const absl::string_view to_parse = GetParam(); 170 absl::LogSeverity value; 171 std::string error; 172 EXPECT_THAT(absl::ParseFlag(to_parse, &value, &error), IsFalse()) << value; 173 } 174 175 using UnparseFlagToEnumeratorTest = 176 TestWithParam<std::tuple<absl::LogSeverity, absl::string_view>>; 177 INSTANTIATE_TEST_SUITE_P( 178 Instantiation, UnparseFlagToEnumeratorTest, 179 Values(std::make_tuple(absl::LogSeverity::kInfo, "INFO"), 180 std::make_tuple(absl::LogSeverity::kWarning, "WARNING"), 181 std::make_tuple(absl::LogSeverity::kError, "ERROR"), 182 std::make_tuple(absl::LogSeverity::kFatal, "FATAL"))); 183 TEST_P(UnparseFlagToEnumeratorTest, ReturnsExpectedValueAndRoundTrips) { 184 const absl::LogSeverity to_unparse = std::get<0>(GetParam()); 185 const absl::string_view expected = std::get<1>(GetParam()); 186 const std::string stringified_value = absl::UnparseFlag(to_unparse); 187 EXPECT_THAT(stringified_value, Eq(expected)); 188 absl::LogSeverity reparsed_value; 189 std::string error; 190 EXPECT_THAT(absl::ParseFlag(stringified_value, &reparsed_value, &error), 191 IsTrue()); 192 EXPECT_THAT(reparsed_value, Eq(to_unparse)); 193 } 194 195 using UnparseFlagToOtherIntegerTest = TestWithParam<int>; 196 INSTANTIATE_TEST_SUITE_P(Instantiation, UnparseFlagToOtherIntegerTest, 197 Values(std::numeric_limits<int>::min(), -1, 4, 198 std::numeric_limits<int>::max())); 199 TEST_P(UnparseFlagToOtherIntegerTest, ReturnsExpectedValueAndRoundTrips) { 200 const absl::LogSeverity to_unparse = 201 static_cast<absl::LogSeverity>(GetParam()); 202 const std::string expected = absl::StrCat(GetParam()); 203 const std::string stringified_value = absl::UnparseFlag(to_unparse); 204 EXPECT_THAT(stringified_value, Eq(expected)); 205 absl::LogSeverity reparsed_value; 206 std::string error; 207 EXPECT_THAT(absl::ParseFlag(stringified_value, &reparsed_value, &error), 208 IsTrue()); 209 EXPECT_THAT(reparsed_value, Eq(to_unparse)); 210 } 211 212 TEST(LogThresholdTest, LogSeverityAtLeastTest) { 213 EXPECT_LT(absl::LogSeverity::kError, absl::LogSeverityAtLeast::kFatal); 214 EXPECT_GT(absl::LogSeverityAtLeast::kError, absl::LogSeverity::kInfo); 215 216 EXPECT_LE(absl::LogSeverityAtLeast::kInfo, absl::LogSeverity::kError); 217 EXPECT_GE(absl::LogSeverity::kError, absl::LogSeverityAtLeast::kInfo); 218 } 219 220 TEST(LogThresholdTest, LogSeverityAtMostTest) { 221 EXPECT_GT(absl::LogSeverity::kError, absl::LogSeverityAtMost::kWarning); 222 EXPECT_LT(absl::LogSeverityAtMost::kError, absl::LogSeverity::kFatal); 223 224 EXPECT_GE(absl::LogSeverityAtMost::kFatal, absl::LogSeverity::kError); 225 EXPECT_LE(absl::LogSeverity::kWarning, absl::LogSeverityAtMost::kError); 226 } 227 228 TEST(LogThresholdTest, Extremes) { 229 EXPECT_LT(absl::LogSeverity::kFatal, absl::LogSeverityAtLeast::kInfinity); 230 EXPECT_GT(absl::LogSeverity::kInfo, 231 absl::LogSeverityAtMost::kNegativeInfinity); 232 } 233 234 TEST(LogThresholdTest, Output) { 235 EXPECT_THAT(StreamHelper(absl::LogSeverityAtLeast::kInfo), Eq(">=INFO")); 236 EXPECT_THAT(StreamHelper(absl::LogSeverityAtLeast::kWarning), 237 Eq(">=WARNING")); 238 EXPECT_THAT(StreamHelper(absl::LogSeverityAtLeast::kError), Eq(">=ERROR")); 239 EXPECT_THAT(StreamHelper(absl::LogSeverityAtLeast::kFatal), Eq(">=FATAL")); 240 EXPECT_THAT(StreamHelper(absl::LogSeverityAtLeast::kInfinity), 241 Eq("INFINITY")); 242 243 EXPECT_THAT(StreamHelper(absl::LogSeverityAtMost::kInfo), Eq("<=INFO")); 244 EXPECT_THAT(StreamHelper(absl::LogSeverityAtMost::kWarning), Eq("<=WARNING")); 245 EXPECT_THAT(StreamHelper(absl::LogSeverityAtMost::kError), Eq("<=ERROR")); 246 EXPECT_THAT(StreamHelper(absl::LogSeverityAtMost::kFatal), Eq("<=FATAL")); 247 EXPECT_THAT(StreamHelper(absl::LogSeverityAtMost::kNegativeInfinity), 248 Eq("NEGATIVE_INFINITY")); 249 } 250 251 } // namespace