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>
StreamHelper(T value)39 std::string StreamHelper(T value) {
40 std::ostringstream stream;
41 stream << value;
42 return stream.str();
43 }
44
TEST(StreamTest,Works)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));
TEST_P(ParseFlagFromOutOfRangeIntegerTest,ReturnsError)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()));
TEST_P(ParseFlagFromAlmostOutOfRangeIntegerTest,YieldsExpectedValue)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)));
TEST_P(ParseFlagFromIntegerMatchingEnumeratorTest,YieldsExpectedValue)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)));
TEST_P(ParseFlagFromOtherIntegerTest,YieldsExpectedValue)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)));
TEST_P(ParseFlagFromEnumeratorTest,YieldsExpectedValue)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"));
TEST_P(ParseFlagFromGarbageTest,ReturnsError)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")));
TEST_P(UnparseFlagToEnumeratorTest,ReturnsExpectedValueAndRoundTrips)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()));
TEST_P(UnparseFlagToOtherIntegerTest,ReturnsExpectedValueAndRoundTrips)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
TEST(LogThresholdTest,LogSeverityAtLeastTest)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
TEST(LogThresholdTest,LogSeverityAtMostTest)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
TEST(LogThresholdTest,Extremes)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
TEST(LogThresholdTest,Output)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
252