Export of internal Abseil changes
-- cf6037b985b629c253b8a87e4408c88a61baf89a by Abseil Team <absl-team@google.com>: Adds an example of using ABSL_DEPRECATED on a template. Without this, it's unclear where to add this annotation (e.g. before template <> or after it). PiperOrigin-RevId: 270057224 -- c53bc14dd683cc1e41c940a337001b42a0270eaf by Andy Getzendanner <durandal@google.com>: Parser and unparser for command-line flags of type absl::LogSeverity. PiperOrigin-RevId: 269939999 -- d91174b02f3b213f0b26701d9d97c79f809e6fea by Abseil Team <absl-team@google.com>: Fix a typo. PiperOrigin-RevId: 269738777 GitOrigin-RevId: cf6037b985b629c253b8a87e4408c88a61baf89a Change-Id: I6cec3101014e4c77f4ff2edb4c91740982dbb459
This commit is contained in:
parent
6ec1362810
commit
ddf8e52a29
9 changed files with 234 additions and 38 deletions
|
@ -575,6 +575,8 @@ cc_test(
|
|||
linkopts = ABSL_DEFAULT_LINKOPTS,
|
||||
deps = [
|
||||
":log_severity",
|
||||
"//absl/flags:marshalling",
|
||||
"//absl/strings",
|
||||
"@com_google_googletest//:gtest_main",
|
||||
],
|
||||
)
|
||||
|
|
|
@ -529,7 +529,9 @@ absl_cc_test(
|
|||
SRCS
|
||||
"log_severity_test.cc"
|
||||
DEPS
|
||||
absl::flags_marshalling
|
||||
absl::log_severity
|
||||
absl::strings
|
||||
gmock
|
||||
gtest_main
|
||||
)
|
||||
|
|
|
@ -25,6 +25,19 @@ namespace absl {
|
|||
// Four severity levels are defined. Logging APIs should terminate the program
|
||||
// when a message is logged at severity `kFatal`; the other levels have no
|
||||
// special semantics.
|
||||
//
|
||||
// Abseil flags may be defined with type `LogSeverity`. Dependency layering
|
||||
// constraints require that the `AbslParseFlag` overload be declared and defined
|
||||
// in the flags module rather than here. The `AbslUnparseFlag` overload is
|
||||
// defined there too for consistency.
|
||||
//
|
||||
// The parser accepts arbitrary integers (as if the type were `int`). It also
|
||||
// accepts each named enumerator, without regard for case, with or without the
|
||||
// leading 'k'. For example: "kInfo", "INFO", and "info" all parse to the value
|
||||
// `absl::LogSeverity::kInfo`.
|
||||
//
|
||||
// Unparsing a flag produces the same result as `absl::LogSeverityName()` for
|
||||
// the standard levels and a base-ten integer otherwise.
|
||||
enum class LogSeverity : int {
|
||||
kInfo = 0,
|
||||
kWarning = 1,
|
||||
|
@ -40,7 +53,7 @@ constexpr std::array<absl::LogSeverity, 4> LogSeverities() {
|
|||
}
|
||||
|
||||
// Returns the all-caps string representation (e.g. "INFO") of the specified
|
||||
// severity level if it is one of the normal levels and "UNKNOWN" otherwise.
|
||||
// severity level if it is one of the standard levels and "UNKNOWN" otherwise.
|
||||
constexpr const char* LogSeverityName(absl::LogSeverity s) {
|
||||
return s == absl::LogSeverity::kInfo
|
||||
? "INFO"
|
||||
|
@ -59,7 +72,7 @@ constexpr absl::LogSeverity NormalizeLogSeverity(absl::LogSeverity s) {
|
|||
: s > absl::LogSeverity::kFatal ? absl::LogSeverity::kError : s;
|
||||
}
|
||||
constexpr absl::LogSeverity NormalizeLogSeverity(int s) {
|
||||
return NormalizeLogSeverity(static_cast<absl::LogSeverity>(s));
|
||||
return absl::NormalizeLogSeverity(static_cast<absl::LogSeverity>(s));
|
||||
}
|
||||
|
||||
// The exact representation of a streamed `absl::LogSeverity` is deliberately
|
||||
|
|
|
@ -14,14 +14,25 @@
|
|||
|
||||
#include "absl/base/log_severity.h"
|
||||
|
||||
#include <cstdint>
|
||||
#include <ios>
|
||||
#include <limits>
|
||||
#include <ostream>
|
||||
#include <sstream>
|
||||
#include <string>
|
||||
#include <tuple>
|
||||
|
||||
#include "gmock/gmock.h"
|
||||
#include "gtest/gtest.h"
|
||||
#include "absl/flags/marshalling.h"
|
||||
#include "absl/strings/str_cat.h"
|
||||
|
||||
namespace {
|
||||
using testing::Eq;
|
||||
using ::testing::Eq;
|
||||
using ::testing::IsFalse;
|
||||
using ::testing::IsTrue;
|
||||
using ::testing::TestWithParam;
|
||||
using ::testing::Values;
|
||||
|
||||
std::string StreamHelper(absl::LogSeverity value) {
|
||||
std::ostringstream stream;
|
||||
|
@ -40,4 +51,149 @@ TEST(StreamTest, Works) {
|
|||
Eq("absl::LogSeverity(4)"));
|
||||
}
|
||||
|
||||
using ParseFlagFromOutOfRangeIntegerTest = TestWithParam<int64_t>;
|
||||
INSTANTIATE_TEST_SUITE_P(
|
||||
Instantiation, ParseFlagFromOutOfRangeIntegerTest,
|
||||
Values(static_cast<int64_t>(std::numeric_limits<int>::min()) - 1,
|
||||
static_cast<int64_t>(std::numeric_limits<int>::max()) + 1));
|
||||
TEST_P(ParseFlagFromOutOfRangeIntegerTest, ReturnsError) {
|
||||
const std::string to_parse = absl::StrCat(GetParam());
|
||||
absl::LogSeverity value;
|
||||
std::string error;
|
||||
EXPECT_THAT(absl::ParseFlag(to_parse, &value, &error), IsFalse()) << value;
|
||||
}
|
||||
|
||||
using ParseFlagFromAlmostOutOfRangeIntegerTest = TestWithParam<int>;
|
||||
INSTANTIATE_TEST_SUITE_P(Instantiation,
|
||||
ParseFlagFromAlmostOutOfRangeIntegerTest,
|
||||
Values(std::numeric_limits<int>::min(),
|
||||
std::numeric_limits<int>::max()));
|
||||
TEST_P(ParseFlagFromAlmostOutOfRangeIntegerTest, YieldsExpectedValue) {
|
||||
const auto expected = static_cast<absl::LogSeverity>(GetParam());
|
||||
const std::string to_parse = absl::StrCat(GetParam());
|
||||
absl::LogSeverity value;
|
||||
std::string error;
|
||||
ASSERT_THAT(absl::ParseFlag(to_parse, &value, &error), IsTrue()) << error;
|
||||
EXPECT_THAT(value, Eq(expected));
|
||||
}
|
||||
|
||||
using ParseFlagFromIntegerMatchingEnumeratorTest =
|
||||
TestWithParam<std::tuple<absl::string_view, absl::LogSeverity>>;
|
||||
INSTANTIATE_TEST_SUITE_P(
|
||||
Instantiation, ParseFlagFromIntegerMatchingEnumeratorTest,
|
||||
Values(std::make_tuple("0", absl::LogSeverity::kInfo),
|
||||
std::make_tuple(" 0", absl::LogSeverity::kInfo),
|
||||
std::make_tuple("-0", absl::LogSeverity::kInfo),
|
||||
std::make_tuple("+0", absl::LogSeverity::kInfo),
|
||||
std::make_tuple("00", absl::LogSeverity::kInfo),
|
||||
std::make_tuple("0 ", absl::LogSeverity::kInfo),
|
||||
std::make_tuple("0x0", absl::LogSeverity::kInfo),
|
||||
std::make_tuple("1", absl::LogSeverity::kWarning),
|
||||
std::make_tuple("+1", absl::LogSeverity::kWarning),
|
||||
std::make_tuple("2", absl::LogSeverity::kError),
|
||||
std::make_tuple("3", absl::LogSeverity::kFatal)));
|
||||
TEST_P(ParseFlagFromIntegerMatchingEnumeratorTest, YieldsExpectedValue) {
|
||||
const absl::string_view to_parse = std::get<0>(GetParam());
|
||||
const absl::LogSeverity expected = std::get<1>(GetParam());
|
||||
absl::LogSeverity value;
|
||||
std::string error;
|
||||
ASSERT_THAT(absl::ParseFlag(to_parse, &value, &error), IsTrue()) << error;
|
||||
EXPECT_THAT(value, Eq(expected));
|
||||
}
|
||||
|
||||
using ParseFlagFromOtherIntegerTest =
|
||||
TestWithParam<std::tuple<absl::string_view, int>>;
|
||||
INSTANTIATE_TEST_SUITE_P(Instantiation, ParseFlagFromOtherIntegerTest,
|
||||
Values(std::make_tuple("-1", -1),
|
||||
std::make_tuple("4", 4),
|
||||
std::make_tuple("010", 10),
|
||||
std::make_tuple("0x10", 16)));
|
||||
TEST_P(ParseFlagFromOtherIntegerTest, YieldsExpectedValue) {
|
||||
const absl::string_view to_parse = std::get<0>(GetParam());
|
||||
const auto expected = static_cast<absl::LogSeverity>(std::get<1>(GetParam()));
|
||||
absl::LogSeverity value;
|
||||
std::string error;
|
||||
ASSERT_THAT(absl::ParseFlag(to_parse, &value, &error), IsTrue()) << error;
|
||||
EXPECT_THAT(value, Eq(expected));
|
||||
}
|
||||
|
||||
using ParseFlagFromEnumeratorTest =
|
||||
TestWithParam<std::tuple<absl::string_view, absl::LogSeverity>>;
|
||||
INSTANTIATE_TEST_SUITE_P(
|
||||
Instantiation, ParseFlagFromEnumeratorTest,
|
||||
Values(std::make_tuple("INFO", absl::LogSeverity::kInfo),
|
||||
std::make_tuple("info", absl::LogSeverity::kInfo),
|
||||
std::make_tuple("kInfo", absl::LogSeverity::kInfo),
|
||||
std::make_tuple("iNfO", absl::LogSeverity::kInfo),
|
||||
std::make_tuple("kInFo", absl::LogSeverity::kInfo),
|
||||
std::make_tuple("WARNING", absl::LogSeverity::kWarning),
|
||||
std::make_tuple("warning", absl::LogSeverity::kWarning),
|
||||
std::make_tuple("kWarning", absl::LogSeverity::kWarning),
|
||||
std::make_tuple("WaRnInG", absl::LogSeverity::kWarning),
|
||||
std::make_tuple("KwArNiNg", absl::LogSeverity::kWarning),
|
||||
std::make_tuple("ERROR", absl::LogSeverity::kError),
|
||||
std::make_tuple("error", absl::LogSeverity::kError),
|
||||
std::make_tuple("kError", absl::LogSeverity::kError),
|
||||
std::make_tuple("eRrOr", absl::LogSeverity::kError),
|
||||
std::make_tuple("kErRoR", absl::LogSeverity::kError),
|
||||
std::make_tuple("FATAL", absl::LogSeverity::kFatal),
|
||||
std::make_tuple("fatal", absl::LogSeverity::kFatal),
|
||||
std::make_tuple("kFatal", absl::LogSeverity::kFatal),
|
||||
std::make_tuple("FaTaL", absl::LogSeverity::kFatal),
|
||||
std::make_tuple("KfAtAl", absl::LogSeverity::kFatal)));
|
||||
TEST_P(ParseFlagFromEnumeratorTest, YieldsExpectedValue) {
|
||||
const absl::string_view to_parse = std::get<0>(GetParam());
|
||||
const absl::LogSeverity expected = std::get<1>(GetParam());
|
||||
absl::LogSeverity value;
|
||||
std::string error;
|
||||
ASSERT_THAT(absl::ParseFlag(to_parse, &value, &error), IsTrue()) << error;
|
||||
EXPECT_THAT(value, Eq(expected));
|
||||
}
|
||||
|
||||
using ParseFlagFromGarbageTest = TestWithParam<absl::string_view>;
|
||||
INSTANTIATE_TEST_SUITE_P(Instantiation, ParseFlagFromGarbageTest,
|
||||
Values("", "\0", " ", "garbage", "kkinfo", "I"));
|
||||
TEST_P(ParseFlagFromGarbageTest, ReturnsError) {
|
||||
const absl::string_view to_parse = GetParam();
|
||||
absl::LogSeverity value;
|
||||
std::string error;
|
||||
EXPECT_THAT(absl::ParseFlag(to_parse, &value, &error), IsFalse()) << value;
|
||||
}
|
||||
|
||||
using UnparseFlagToEnumeratorTest =
|
||||
TestWithParam<std::tuple<absl::LogSeverity, absl::string_view>>;
|
||||
INSTANTIATE_TEST_SUITE_P(
|
||||
Instantiation, UnparseFlagToEnumeratorTest,
|
||||
Values(std::make_tuple(absl::LogSeverity::kInfo, "INFO"),
|
||||
std::make_tuple(absl::LogSeverity::kWarning, "WARNING"),
|
||||
std::make_tuple(absl::LogSeverity::kError, "ERROR"),
|
||||
std::make_tuple(absl::LogSeverity::kFatal, "FATAL")));
|
||||
TEST_P(UnparseFlagToEnumeratorTest, ReturnsExpectedValueAndRoundTrips) {
|
||||
const absl::LogSeverity to_unparse = std::get<0>(GetParam());
|
||||
const absl::string_view expected = std::get<1>(GetParam());
|
||||
const std::string stringified_value = absl::UnparseFlag(to_unparse);
|
||||
EXPECT_THAT(stringified_value, Eq(expected));
|
||||
absl::LogSeverity reparsed_value;
|
||||
std::string error;
|
||||
EXPECT_THAT(absl::ParseFlag(stringified_value, &reparsed_value, &error),
|
||||
IsTrue());
|
||||
EXPECT_THAT(reparsed_value, Eq(to_unparse));
|
||||
}
|
||||
|
||||
using UnparseFlagToOtherIntegerTest = TestWithParam<int>;
|
||||
INSTANTIATE_TEST_SUITE_P(Instantiation, UnparseFlagToOtherIntegerTest,
|
||||
Values(std::numeric_limits<int>::min(), -1, 4,
|
||||
std::numeric_limits<int>::max()));
|
||||
TEST_P(UnparseFlagToOtherIntegerTest, ReturnsExpectedValueAndRoundTrips) {
|
||||
const absl::LogSeverity to_unparse =
|
||||
static_cast<absl::LogSeverity>(GetParam());
|
||||
const std::string expected = absl::StrCat(GetParam());
|
||||
const std::string stringified_value = absl::UnparseFlag(to_unparse);
|
||||
EXPECT_THAT(stringified_value, Eq(expected));
|
||||
absl::LogSeverity reparsed_value;
|
||||
std::string error;
|
||||
EXPECT_THAT(absl::ParseFlag(stringified_value, &reparsed_value, &error),
|
||||
IsTrue());
|
||||
EXPECT_THAT(reparsed_value, Eq(to_unparse));
|
||||
}
|
||||
} // namespace
|
||||
|
|
|
@ -137,10 +137,15 @@ enum LinkerInitialized {
|
|||
// declarations. The macro argument is used as a custom diagnostic message (e.g.
|
||||
// suggestion of a better alternative).
|
||||
//
|
||||
// Example:
|
||||
// Examples:
|
||||
//
|
||||
// class ABSL_DEPRECATED("Use Bar instead") Foo {...};
|
||||
// ABSL_DEPRECATED("Use Baz instead") void Bar() {...}
|
||||
//
|
||||
// ABSL_DEPRECATED("Use Baz() instead") void Bar() {...}
|
||||
//
|
||||
// template <typename T>
|
||||
// ABSL_DEPRECATED("Use DoThat() instead")
|
||||
// void DoThis();
|
||||
//
|
||||
// Every usage of a deprecated entity will trigger a warning when compiled with
|
||||
// clang's `-Wdeprecated-declarations` option. This option is turned off by
|
||||
|
|
|
@ -251,7 +251,7 @@ cc_library(
|
|||
)
|
||||
|
||||
############################################################################
|
||||
# Unit tests in alpahabetical order.
|
||||
# Unit tests in alphabetical order.
|
||||
|
||||
cc_test(
|
||||
name = "commandlineflag_test",
|
||||
|
|
|
@ -16,6 +16,7 @@
|
|||
#include "absl/flags/marshalling.h"
|
||||
|
||||
#include <limits>
|
||||
#include <type_traits>
|
||||
|
||||
#include "absl/base/macros.h"
|
||||
#include "absl/strings/match.h"
|
||||
|
@ -186,4 +187,43 @@ std::string AbslUnparseFlag(const std::vector<std::string>& v) {
|
|||
}
|
||||
|
||||
} // namespace flags_internal
|
||||
|
||||
bool AbslParseFlag(absl::string_view text, absl::LogSeverity* dst,
|
||||
std::string* err) {
|
||||
text = absl::StripAsciiWhitespace(text);
|
||||
if (text.empty()) {
|
||||
*err = "no value provided";
|
||||
return false;
|
||||
}
|
||||
if (text.front() == 'k' || text.front() == 'K') text.remove_prefix(1);
|
||||
if (absl::EqualsIgnoreCase(text, "info")) {
|
||||
*dst = absl::LogSeverity::kInfo;
|
||||
return true;
|
||||
}
|
||||
if (absl::EqualsIgnoreCase(text, "warning")) {
|
||||
*dst = absl::LogSeverity::kWarning;
|
||||
return true;
|
||||
}
|
||||
if (absl::EqualsIgnoreCase(text, "error")) {
|
||||
*dst = absl::LogSeverity::kError;
|
||||
return true;
|
||||
}
|
||||
if (absl::EqualsIgnoreCase(text, "fatal")) {
|
||||
*dst = absl::LogSeverity::kFatal;
|
||||
return true;
|
||||
}
|
||||
std::underlying_type<absl::LogSeverity>::type numeric_value;
|
||||
if (absl::ParseFlag(text, &numeric_value, err)) {
|
||||
*dst = static_cast<absl::LogSeverity>(numeric_value);
|
||||
return true;
|
||||
}
|
||||
*err = "only integers and absl::LogSeverity enumerators are accepted";
|
||||
return false;
|
||||
}
|
||||
|
||||
std::string AbslUnparseFlag(absl::LogSeverity v) {
|
||||
if (v == absl::NormalizeLogSeverity(v)) return absl::LogSeverityName(v);
|
||||
return absl::UnparseFlag(static_cast<int>(v));
|
||||
}
|
||||
|
||||
} // namespace absl
|
||||
|
|
|
@ -33,6 +33,7 @@
|
|||
// * `double`
|
||||
// * `std::string`
|
||||
// * `std::vector<std::string>`
|
||||
// * `absl::LogSeverity` (provided here due to dependency ordering)
|
||||
//
|
||||
// Note that support for integral types is implemented using overloads for
|
||||
// variable-width fundamental types (`short`, `int`, `long`, etc.). However,
|
||||
|
@ -178,8 +179,8 @@ bool AbslParseFlag(absl::string_view, unsigned int*, std::string*); // NOLINT
|
|||
bool AbslParseFlag(absl::string_view, long*, std::string*); // NOLINT
|
||||
bool AbslParseFlag(absl::string_view, unsigned long*, std::string*); // NOLINT
|
||||
bool AbslParseFlag(absl::string_view, long long*, std::string*); // NOLINT
|
||||
bool AbslParseFlag(absl::string_view, unsigned long long*,
|
||||
std::string*); // NOLINT
|
||||
bool AbslParseFlag(absl::string_view, unsigned long long*, // NOLINT
|
||||
std::string*);
|
||||
bool AbslParseFlag(absl::string_view, float*, std::string*);
|
||||
bool AbslParseFlag(absl::string_view, double*, std::string*);
|
||||
bool AbslParseFlag(absl::string_view, std::string*, std::string*);
|
||||
|
@ -248,6 +249,13 @@ inline std::string UnparseFlag(const T& v) {
|
|||
return flags_internal::Unparse(v);
|
||||
}
|
||||
|
||||
// Overloads for `absl::LogSeverity` can't (easily) appear alongside that type's
|
||||
// definition because it is layered below flags. See proper documentation in
|
||||
// base/log_severity.h.
|
||||
enum class LogSeverity : int;
|
||||
bool AbslParseFlag(absl::string_view, absl::LogSeverity*, std::string*);
|
||||
std::string AbslUnparseFlag(absl::LogSeverity);
|
||||
|
||||
} // namespace absl
|
||||
|
||||
#endif // ABSL_FLAGS_MARSHALLING_H_
|
||||
|
|
|
@ -1,30 +0,0 @@
|
|||
// 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 <cstddef>
|
||||
#include <iostream>
|
||||
|
||||
#include "absl/random/random.h"
|
||||
|
||||
// This program is used in integration tests.
|
||||
|
||||
int main() {
|
||||
auto seed_seq = absl::MakeTaggedSeedSeq("TEST_GENERATOR", std::cerr);
|
||||
absl::BitGen rng(seed_seq);
|
||||
constexpr size_t kSequenceLength = 8;
|
||||
for (size_t i = 0; i < kSequenceLength; i++) {
|
||||
std::cout << rng() << "\n";
|
||||
}
|
||||
return 0;
|
||||
}
|
Loading…
Reference in a new issue