Add native ABSL_FLAG support for std::vector of numeric types. C++ ADL rules prevent callers outside Abseil from defining `AbslParseFlag` or `AbslUnparseFlag` overloads for `std::vector<T>`, forcing callers who need comma-separated numeric list flags to use `std::vector<std::string>` or `std::string` with manual post-parse conversion or custom wrapper types that bypass eager validation during `absl::ParseCommandLine()`. Add `AbslParseFlag` and `AbslUnparseFlag` overloads in `absl::flags_internal` for `std::vector<T>` across the 10 integral types (`short`, `unsigned short`, `int`, `unsigned int`, `long`, `unsigned long`, `long long`, `unsigned long long`, `absl::int128`, `absl::uint128`, covering `int16_t` through `uint64_t` and `size_t`) and 2 floating-point types (`float`, `double`) already supported as scalar Abseil flags. Unconstrained `std::vector<T>`, `std::vector<bool>`, and 8-bit character types (`char`, `int8_t`, `uint8_t`) remain unsupported. Empty input (`""`) parses as an empty vector, while non-empty input splits on `','` and delegates each token to scalar `absl::ParseFlag()`, allowing surrounding ASCII whitespace on elements while rejecting whitespace-only strings, empty tokens, and trailing commas. Repeated flags overwrite previous values. PiperOrigin-RevId: 1022881182
diff --git a/absl/flags/config.h b/absl/flags/config.h index 14c4235..b5d6a95 100644 --- a/absl/flags/config.h +++ b/absl/flags/config.h
@@ -13,6 +13,8 @@ // See the License for the specific language governing permissions and // limitations under the License. +// SKIP_ABSL_INLINE_NAMESPACE_CHECK + #ifndef ABSL_FLAGS_CONFIG_H_ #define ABSL_FLAGS_CONFIG_H_ @@ -60,9 +62,22 @@ A(double, double) \ A(float, float) -#define ABSL_FLAGS_INTERNAL_SUPPORTED_TYPES(A) \ - ABSL_FLAGS_INTERNAL_BUILTIN_TYPES(A) \ - A(std::string, std_string) \ +#define ABSL_FLAGS_INTERNAL_SUPPORTED_TYPES(A) \ + ABSL_FLAGS_INTERNAL_BUILTIN_TYPES(A) \ + A(std::string, std_string) \ + A(std::vector<short>, std_vector_of_short) /* NOLINT */ \ + A(std::vector<unsigned short>, /* NOLINT */ \ + std_vector_of_unsigned_short) \ + A(std::vector<int>, std_vector_of_int) \ + A(std::vector<unsigned int>, std_vector_of_unsigned_int) \ + A(std::vector<long>, std_vector_of_long) /* NOLINT */ \ + A(std::vector<unsigned long>, /* NOLINT */ \ + std_vector_of_unsigned_long) \ + A(std::vector<long long>, std_vector_of_long_long) /* NOLINT */ \ + A(std::vector<unsigned long long>, /* NOLINT */ \ + std_vector_of_unsigned_long_long) \ + A(std::vector<float>, std_vector_of_float) \ + A(std::vector<double>, std_vector_of_double) \ A(std::vector<std::string>, std_vector_of_string) #endif // ABSL_FLAGS_CONFIG_H_
diff --git a/absl/flags/flag_test.cc b/absl/flags/flag_test.cc index 199577e..666b86d 100644 --- a/absl/flags/flag_test.cc +++ b/absl/flags/flag_test.cc
@@ -132,6 +132,10 @@ flags::FlagValueStorageKind::kHeapAllocated); EXPECT_EQ(flags::StorageKind<std::vector<std::string>>(), flags::FlagValueStorageKind::kHeapAllocated); + EXPECT_EQ(flags::StorageKind<std::vector<int>>(), + flags::FlagValueStorageKind::kHeapAllocated); + EXPECT_EQ(flags::StorageKind<std::vector<double>>(), + flags::FlagValueStorageKind::kHeapAllocated); EXPECT_EQ(flags::StorageKind<absl::int128>(), flags::FlagValueStorageKind::kSequenceLocked); @@ -1465,3 +1469,68 @@ } } // namespace + +ABSL_FLAG(std::vector<int32_t>, numeric_vec_empty, {}, "empty int32 vector"); +ABSL_FLAG(std::vector<int64_t>, numeric_vec_int64, + std::vector<int64_t>({1, 2, 3}), "int64 vector"); +ABSL_FLAG(std::vector<size_t>, numeric_vec_size_t, + std::vector<size_t>({10, 20}), "size_t vector"); +ABSL_FLAG(std::vector<absl::int128>, numeric_vec_int128, + std::vector<absl::int128>({-1, 2}), "int128 vector"); +ABSL_FLAG(std::vector<double>, numeric_vec_double, + std::vector<double>({0.5, -1.5}), "double vector"); + +namespace { + +TEST_F(FlagTest, TestNumericVectorFlags) { + EXPECT_EQ(absl::GetFlag(FLAGS_numeric_vec_empty), std::vector<int32_t>{}); + EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_numeric_vec_empty) + .DefaultValue(), + ""); + + EXPECT_EQ(absl::GetFlag(FLAGS_numeric_vec_int64), + (std::vector<int64_t>{1, 2, 3})); + EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_numeric_vec_int64) + .DefaultValue(), + "1,2,3"); + EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_numeric_vec_int64) + .CurrentValue(), + "1,2,3"); + + EXPECT_EQ(absl::GetFlag(FLAGS_numeric_vec_size_t), + (std::vector<size_t>{10, 20})); + EXPECT_EQ(absl::GetFlag(FLAGS_numeric_vec_int128), + (std::vector<absl::int128>{-1, 2})); + EXPECT_EQ(absl::GetFlag(FLAGS_numeric_vec_double), + (std::vector<double>{0.5, -1.5})); + + { + absl::FlagSaver saver; + absl::SetFlag(&FLAGS_numeric_vec_int64, std::vector<int64_t>{4, 5}); + EXPECT_EQ(absl::GetFlag(FLAGS_numeric_vec_int64), + (std::vector<int64_t>{4, 5})); + EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_numeric_vec_int64) + .CurrentValue(), + "4,5"); + } + EXPECT_EQ(absl::GetFlag(FLAGS_numeric_vec_int64), + (std::vector<int64_t>{1, 2, 3})); + + if constexpr (!kStrippedFlagNames) { + absl::CommandLineFlag* handle = + absl::FindCommandLineFlag("numeric_vec_int64"); + ASSERT_NE(handle, nullptr); + EXPECT_EQ(*handle->TryGet<std::vector<int64_t>>(), + (std::vector<int64_t>{1, 2, 3})); + + std::string err; + EXPECT_TRUE(handle->ParseFrom("10, 20", &err)); + EXPECT_EQ(absl::GetFlag(FLAGS_numeric_vec_int64), + (std::vector<int64_t>{10, 20})); + + EXPECT_TRUE(handle->ParseFrom("", &err)); + EXPECT_EQ(absl::GetFlag(FLAGS_numeric_vec_int64), std::vector<int64_t>{}); + } +} + +} // namespace
diff --git a/absl/flags/internal/flag.h b/absl/flags/internal/flag.h index b565aaf..fd23687 100644 --- a/absl/flags/internal/flag.h +++ b/absl/flags/internal/flag.h
@@ -28,6 +28,7 @@ #include <type_traits> #include <typeinfo> #include <utility> +#include <vector> #include "absl/base/attributes.h" #include "absl/base/call_once.h"
diff --git a/absl/flags/marshalling.cc b/absl/flags/marshalling.cc index cb829a4..d64448a 100644 --- a/absl/flags/marshalling.cc +++ b/absl/flags/marshalling.cc
@@ -157,7 +157,7 @@ } // -------------------------------------------------------------------- -// AbslParseFlag for vector of strings. +// AbslParseFlag for vector of strings and numeric types. bool AbslParseFlag(absl::string_view text, std::vector<std::string>* dst, std::string*) { @@ -171,6 +171,84 @@ return true; } +namespace { + +template <typename T> +bool ParseFlagVectorImpl(absl::string_view text, std::vector<T>* dst, + std::string* err) { + dst->clear(); + if (text.empty()) return true; + for (const absl::string_view element : + absl::StrSplit(text, ',', absl::AllowEmpty())) { + T value; + if (!absl::ParseFlag(element, &value, err)) return false; + dst->push_back(value); + } + return true; +} + +template <typename T> +std::string UnparseFlagVectorImpl(const std::vector<T>& val) { + return absl::StrJoin(val, ",", [](std::string* out, T v) { + absl::StrAppend(out, absl::UnparseFlag(v)); + }); +} + +} // namespace + +bool AbslParseFlag(absl::string_view text, std::vector<short>* dst, // NOLINT + std::string* err) { + return ParseFlagVectorImpl(text, dst, err); +} +bool AbslParseFlag(absl::string_view text, + std::vector<unsigned short>* dst, // NOLINT + std::string* err) { + return ParseFlagVectorImpl(text, dst, err); +} +bool AbslParseFlag(absl::string_view text, std::vector<int>* dst, + std::string* err) { + return ParseFlagVectorImpl(text, dst, err); +} +bool AbslParseFlag(absl::string_view text, std::vector<unsigned int>* dst, + std::string* err) { + return ParseFlagVectorImpl(text, dst, err); +} +bool AbslParseFlag(absl::string_view text, std::vector<long>* dst, // NOLINT + std::string* err) { + return ParseFlagVectorImpl(text, dst, err); +} +bool AbslParseFlag(absl::string_view text, + std::vector<unsigned long>* dst, // NOLINT + std::string* err) { + return ParseFlagVectorImpl(text, dst, err); +} +bool AbslParseFlag(absl::string_view text, + std::vector<long long>* dst, // NOLINT + std::string* err) { + return ParseFlagVectorImpl(text, dst, err); +} +bool AbslParseFlag(absl::string_view text, + std::vector<unsigned long long>* dst, // NOLINT + std::string* err) { + return ParseFlagVectorImpl(text, dst, err); +} +bool AbslParseFlag(absl::string_view text, std::vector<absl::int128>* dst, + std::string* err) { + return ParseFlagVectorImpl(text, dst, err); +} +bool AbslParseFlag(absl::string_view text, std::vector<absl::uint128>* dst, + std::string* err) { + return ParseFlagVectorImpl(text, dst, err); +} +bool AbslParseFlag(absl::string_view text, std::vector<float>* dst, + std::string* err) { + return ParseFlagVectorImpl(text, dst, err); +} +bool AbslParseFlag(absl::string_view text, std::vector<double>* dst, + std::string* err) { + return ParseFlagVectorImpl(text, dst, err); +} + // -------------------------------------------------------------------- // AbslUnparseFlag specializations for various builtin flag types. @@ -200,6 +278,43 @@ std::string AbslUnparseFlag(const std::vector<std::string>& v) { return absl::StrJoin(v, ","); } +std::string AbslUnparseFlag(const std::vector<short>& v) { // NOLINT + return UnparseFlagVectorImpl(v); +} +std::string AbslUnparseFlag(const std::vector<unsigned short>& v) { // NOLINT + return UnparseFlagVectorImpl(v); +} +std::string AbslUnparseFlag(const std::vector<int>& v) { // NOLINT + return UnparseFlagVectorImpl(v); +} +std::string AbslUnparseFlag(const std::vector<unsigned int>& v) { // NOLINT + return UnparseFlagVectorImpl(v); +} +std::string AbslUnparseFlag(const std::vector<long>& v) { // NOLINT + return UnparseFlagVectorImpl(v); +} +std::string AbslUnparseFlag(const std::vector<unsigned long>& v) { // NOLINT + return UnparseFlagVectorImpl(v); +} +std::string AbslUnparseFlag(const std::vector<long long>& v) { // NOLINT + return UnparseFlagVectorImpl(v); +} +std::string AbslUnparseFlag( // NOLINT + const std::vector<unsigned long long>& v) { // NOLINT + return UnparseFlagVectorImpl(v); +} +std::string AbslUnparseFlag(const std::vector<absl::int128>& v) { // NOLINT + return UnparseFlagVectorImpl(v); +} +std::string AbslUnparseFlag(const std::vector<absl::uint128>& v) { // NOLINT + return UnparseFlagVectorImpl(v); +} +std::string AbslUnparseFlag(const std::vector<float>& v) { // NOLINT + return UnparseFlagVectorImpl(v); +} +std::string AbslUnparseFlag(const std::vector<double>& v) { // NOLINT + return UnparseFlagVectorImpl(v); +} } // namespace flags_internal
diff --git a/absl/flags/marshalling.h b/absl/flags/marshalling.h index 5e04d6a..4e6424b 100644 --- a/absl/flags/marshalling.h +++ b/absl/flags/marshalling.h
@@ -29,17 +29,30 @@ // * `uint32_t` // * `int64_t` // * `uint64_t` +// * `absl::int128` +// * `absl::uint128` // * `float` // * `double` // * `std::string` +// * `std::vector<int16_t>` +// * `std::vector<uint16_t>` +// * `std::vector<int32_t>` +// * `std::vector<uint32_t>` +// * `std::vector<int64_t>` +// * `std::vector<uint64_t>` +// * `std::vector<absl::int128>` +// * `std::vector<absl::uint128>` +// * `std::vector<float>` +// * `std::vector<double>` // * `std::vector<std::string>` // * `std::optional<T>` // * `absl::LogSeverity` (provided natively for layering reasons) // -// Note that support for integral types is implemented using overloads for -// variable-width fundamental types (`short`, `int`, `long`, etc.). However, -// you should prefer the fixed-width integral types (`int32_t`, `uint64_t`, -// etc.) we've noted above within flag definitions. +// Note that support for integral types (and vectors of integral types) is +// implemented using overloads for variable-width fundamental types (`short`, +// `int`, `long`, etc.). However, you should prefer the fixed-width integral +// types (`int32_t`, `uint64_t`, etc.) we've noted above within flag +// definitions. // // In addition, several Abseil libraries provide their own custom support for // Abseil flags. Documentation for these formats is provided in the type's @@ -66,6 +79,16 @@ // below.) // // ----------------------------------------------------------------------------- +// Vector Flags +// ----------------------------------------------------------------------------- +// +// Supported `std::vector` flag types parse comma-separated lists of elements +// (e.g. `--my_ints=1,2,3`), delegating each element to `absl::ParseFlag()`. +// Passing an empty string (`--my_ints=` or `--my_ints=""`) produces an empty +// vector. Specifying a vector flag multiple times on the command line +// overwrites previous values rather than appending to them. +// +// ----------------------------------------------------------------------------- // Optional Flags // ----------------------------------------------------------------------------- // @@ -236,6 +259,28 @@ 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*); +bool AbslParseFlag(absl::string_view, std::vector<short>*, // NOLINT + std::string*); +bool AbslParseFlag(absl::string_view, std::vector<unsigned short>*, // NOLINT + std::string*); +bool AbslParseFlag(absl::string_view, std::vector<int>*, std::string*); +bool AbslParseFlag(absl::string_view, std::vector<unsigned int>*, + std::string*); +bool AbslParseFlag(absl::string_view, std::vector<long>*, // NOLINT + std::string*); +bool AbslParseFlag(absl::string_view, std::vector<unsigned long>*, // NOLINT + std::string*); +bool AbslParseFlag(absl::string_view, std::vector<long long>*, // NOLINT + std::string*); +bool AbslParseFlag(absl::string_view, + std::vector<unsigned long long>*, // NOLINT + std::string*); +bool AbslParseFlag(absl::string_view, std::vector<absl::int128>*, + std::string*); +bool AbslParseFlag(absl::string_view, std::vector<absl::uint128>*, + std::string*); +bool AbslParseFlag(absl::string_view, std::vector<float>*, std::string*); +bool AbslParseFlag(absl::string_view, std::vector<double>*, std::string*); bool AbslParseFlag(absl::string_view, std::vector<std::string>*, std::string*); template <typename T> @@ -263,6 +308,18 @@ // considerations as fundamental types. Naming these 'AbslUnparseFlag' means we // can avoid the need for additional specializations of Unparse (below). std::string AbslUnparseFlag(absl::string_view v); +std::string AbslUnparseFlag(const std::vector<short>&); // NOLINT +std::string AbslUnparseFlag(const std::vector<unsigned short>&); // NOLINT +std::string AbslUnparseFlag(const std::vector<int>&); // NOLINT +std::string AbslUnparseFlag(const std::vector<unsigned int>&); // NOLINT +std::string AbslUnparseFlag(const std::vector<long>&); // NOLINT +std::string AbslUnparseFlag(const std::vector<unsigned long>&); // NOLINT +std::string AbslUnparseFlag(const std::vector<long long>&); // NOLINT +std::string AbslUnparseFlag(const std::vector<unsigned long long>&); // NOLINT +std::string AbslUnparseFlag(const std::vector<absl::int128>&); // NOLINT +std::string AbslUnparseFlag(const std::vector<absl::uint128>&); // NOLINT +std::string AbslUnparseFlag(const std::vector<float>&); // NOLINT +std::string AbslUnparseFlag(const std::vector<double>&); // NOLINT std::string AbslUnparseFlag(const std::vector<std::string>&); template <typename T>
diff --git a/absl/flags/marshalling_test.cc b/absl/flags/marshalling_test.cc index 6870920..77dd37a 100644 --- a/absl/flags/marshalling_test.cc +++ b/absl/flags/marshalling_test.cc
@@ -15,6 +15,7 @@ #include "absl/flags/marshalling.h" +#include <stddef.h> #include <stdint.h> #include <cmath> @@ -777,6 +778,178 @@ // -------------------------------------------------------------------- +template <typename IntType> +void TestIntegralVectorParsingCommon() { + std::string err; + std::vector<IntType> value = {IntType{99}, IntType{100}}; + + // Empty string clears pre-populated vector. + EXPECT_TRUE(absl::ParseFlag("", &value, &err)); + EXPECT_EQ(value, std::vector<IntType>{}); + + // Single and multiple values overwrite existing contents. + value = {IntType{99}}; + EXPECT_TRUE(absl::ParseFlag("42", &value, &err)); + EXPECT_EQ(value, std::vector<IntType>({IntType{42}})); + + EXPECT_TRUE(absl::ParseFlag("1,0,+3,123", &value, &err)); + EXPECT_EQ(value, (std::vector<IntType>{IntType{1}, IntType{0}, IntType{3}, + IntType{123}})); + + // Leading zeros are decimal (base 10), not octal; 0x/0X is hexadecimal. + EXPECT_TRUE(absl::ParseFlag("010,000100,0x10,0X20,+0x31", &value, &err)); + EXPECT_EQ(value, (std::vector<IntType>{IntType{10}, IntType{100}, IntType{16}, + IntType{32}, IntType{49}})); + + // Surrounding ASCII whitespace around elements is stripped. + EXPECT_TRUE(absl::ParseFlag(" 10 , 20,30 ,\t0x22\n", &value, &err)); + EXPECT_EQ(value, (std::vector<IntType>{IntType{10}, IntType{20}, IntType{30}, + IntType{34}})); + + // Whitespace-only non-empty strings, empty tokens, internal whitespace, and + // malformed tokens are rejected. + EXPECT_FALSE(absl::ParseFlag(" ", &value, &err)); + EXPECT_FALSE(absl::ParseFlag(" ", &value, &err)); + EXPECT_FALSE(absl::ParseFlag("\t", &value, &err)); + EXPECT_FALSE(absl::ParseFlag("\n", &value, &err)); + EXPECT_FALSE(absl::ParseFlag("\r", &value, &err)); + EXPECT_FALSE(absl::ParseFlag(",", &value, &err)); + EXPECT_FALSE(absl::ParseFlag(",,", &value, &err)); + EXPECT_FALSE(absl::ParseFlag("1,,2", &value, &err)); + EXPECT_FALSE(absl::ParseFlag("1, ,2", &value, &err)); + EXPECT_FALSE(absl::ParseFlag(",1", &value, &err)); + EXPECT_FALSE(absl::ParseFlag("1,2,", &value, &err)); + EXPECT_FALSE(absl::ParseFlag("1 2,3", &value, &err)); + EXPECT_FALSE(absl::ParseFlag("1,typo,3", &value, &err)); + EXPECT_FALSE(absl::ParseFlag("1,2U,3", &value, &err)); + EXPECT_FALSE(absl::ParseFlag("1,FFF,3", &value, &err)); + EXPECT_FALSE(absl::ParseFlag("1,--2,3", &value, &err)); +} + +template <typename SignedIntType> +void TestSignedIntegralVectorParsing() { + TestIntegralVectorParsingCommon<SignedIntType>(); + + std::string err; + std::vector<SignedIntType> value; + EXPECT_TRUE(absl::ParseFlag("-1,-010,-0x10", &value, &err)); + EXPECT_EQ(value, (std::vector<SignedIntType>{ + SignedIntType{-1}, SignedIntType{-10}, + SignedIntType{-16}})); +} + +template <typename UnsignedIntType> +void TestUnsignedIntegralVectorParsing() { + TestIntegralVectorParsingCommon<UnsignedIntType>(); + + std::string err; + std::vector<UnsignedIntType> value; + EXPECT_FALSE(absl::ParseFlag("-1", &value, &err)); + EXPECT_FALSE(absl::ParseFlag("1,-2,3", &value, &err)); +} + +TEST(MarshallingTest, TestVectorOfIntegralTypesParsing) { + // Fundamental integral types. + TestSignedIntegralVectorParsing<short>(); // NOLINT + TestUnsignedIntegralVectorParsing<unsigned short>(); // NOLINT + TestSignedIntegralVectorParsing<int>(); + TestUnsignedIntegralVectorParsing<unsigned int>(); + TestSignedIntegralVectorParsing<long>(); // NOLINT + TestUnsignedIntegralVectorParsing<unsigned long>(); // NOLINT + TestSignedIntegralVectorParsing<long long>(); // NOLINT + TestUnsignedIntegralVectorParsing<unsigned long long>(); // NOLINT + TestSignedIntegralVectorParsing<absl::int128>(); + TestUnsignedIntegralVectorParsing<absl::uint128>(); + + // Fixed-width and platform typedefs. + TestSignedIntegralVectorParsing<int16_t>(); + TestUnsignedIntegralVectorParsing<uint16_t>(); + TestSignedIntegralVectorParsing<int32_t>(); + TestUnsignedIntegralVectorParsing<uint32_t>(); + TestSignedIntegralVectorParsing<int64_t>(); + TestUnsignedIntegralVectorParsing<uint64_t>(); + TestUnsignedIntegralVectorParsing<size_t>(); + + // Range bounds checks. + std::string err; + std::vector<int16_t> i16; + EXPECT_TRUE(absl::ParseFlag("-32768,32767", &i16, &err)); + EXPECT_EQ(i16, (std::vector<int16_t>{-32768, 32767})); + EXPECT_FALSE(absl::ParseFlag("1,40000", &i16, &err)); + EXPECT_FALSE(absl::ParseFlag("-40000,1", &i16, &err)); + + std::vector<uint16_t> u16; + EXPECT_TRUE(absl::ParseFlag("0,65535", &u16, &err)); + EXPECT_EQ(u16, (std::vector<uint16_t>{0, 65535})); + EXPECT_FALSE(absl::ParseFlag("1,70000", &u16, &err)); + + std::vector<int64_t> i64; + EXPECT_FALSE(absl::ParseFlag("0xFFFFFFFFFFFFFFFFFF", &i64, &err)); + + std::vector<uint64_t> u64; + EXPECT_FALSE(absl::ParseFlag("0xFFFFFFFFFFFFFFFFFF", &u64, &err)); + + std::vector<absl::int128> i128; + EXPECT_TRUE(absl::ParseFlag( + "-0x10000000000000000,0xFFF0FFFFFFFFFFFFFFF", &i128, &err)); + EXPECT_EQ( + i128, + (std::vector<absl::int128>{ + absl::MakeInt128(-1, 0), + absl::MakeInt128(0x000000000000fff, 0xFFFFFFFFFFFFFFF)})); + + std::vector<absl::uint128> u128; + EXPECT_TRUE(absl::ParseFlag("0,0xFFF0FFFFFFFFFFFFFFF", &u128, &err)); + EXPECT_EQ( + u128, + (std::vector<absl::uint128>{ + 0, absl::MakeUint128(0x000000000000fff, 0xFFFFFFFFFFFFFFF)})); +} + +// -------------------------------------------------------------------- + +template <typename FloatType> +void TestFloatingPointVectorParsing() { + std::string err; + std::vector<FloatType> value = {FloatType{99}}; + + EXPECT_TRUE(absl::ParseFlag("", &value, &err)); + EXPECT_EQ(value, std::vector<FloatType>{}); + + value = {FloatType{99}}; + EXPECT_TRUE(absl::ParseFlag("0.5, -1.25e-2, +0.25, 0x10p1", &value, &err)); + ASSERT_EQ(value.size(), 4u); + EXPECT_EQ(value[0], static_cast<FloatType>(0.5)); + EXPECT_EQ(value[1], static_cast<FloatType>(-0.0125)); + EXPECT_EQ(value[2], static_cast<FloatType>(0.25)); + EXPECT_EQ(value[3], static_cast<FloatType>(32.0)); + + EXPECT_TRUE(absl::ParseFlag("inf, -inf, NaN", &value, &err)); + ASSERT_EQ(value.size(), 3u); + EXPECT_TRUE(std::isinf(value[0]) && value[0] > 0); + EXPECT_TRUE(std::isinf(value[1]) && value[1] < 0); + EXPECT_TRUE(std::isnan(value[2])); + + EXPECT_FALSE(absl::ParseFlag(" ", &value, &err)); + EXPECT_FALSE(absl::ParseFlag(" ", &value, &err)); + EXPECT_FALSE(absl::ParseFlag("\t", &value, &err)); + EXPECT_FALSE(absl::ParseFlag("\n", &value, &err)); + EXPECT_FALSE(absl::ParseFlag(",", &value, &err)); + EXPECT_FALSE(absl::ParseFlag("1.0,,2.0", &value, &err)); + EXPECT_FALSE(absl::ParseFlag("1.0, ,2.0", &value, &err)); + EXPECT_FALSE(absl::ParseFlag(",1.0", &value, &err)); + EXPECT_FALSE(absl::ParseFlag("1.0,2.0,", &value, &err)); + EXPECT_FALSE(absl::ParseFlag("1.0 2.0", &value, &err)); + EXPECT_FALSE(absl::ParseFlag("1.0,bad,2.0", &value, &err)); +} + +TEST(MarshallingTest, TestVectorOfFloatingPointTypesParsing) { + TestFloatingPointVectorParsing<float>(); + TestFloatingPointVectorParsing<double>(); +} + +// -------------------------------------------------------------------- + TEST(MarshallingTest, TestOptionalBoolParsing) { std::string err; std::optional<bool> value; @@ -1060,6 +1233,61 @@ // -------------------------------------------------------------------- +TEST(MarshallingTest, TestVectorUnparsing) { + EXPECT_EQ(absl::UnparseFlag(std::vector<std::string>{}), ""); + EXPECT_EQ(absl::UnparseFlag(std::vector<std::string>{"a", "b", "c"}), + "a,b,c"); + + EXPECT_EQ(absl::UnparseFlag(std::vector<short>{}), ""); // NOLINT + EXPECT_EQ(absl::UnparseFlag(std::vector<short>{-1, 0, 2}), // NOLINT + "-1,0,2"); + EXPECT_EQ(absl::UnparseFlag(std::vector<unsigned short>{}), ""); // NOLINT + EXPECT_EQ(absl::UnparseFlag(std::vector<unsigned short>{0, 1, 2}), // NOLINT + "0,1,2"); + EXPECT_EQ(absl::UnparseFlag(std::vector<int>{}), ""); + EXPECT_EQ(absl::UnparseFlag(std::vector<int>{-10, 0, 20}), "-10,0,20"); + EXPECT_EQ(absl::UnparseFlag(std::vector<unsigned int>{}), ""); + EXPECT_EQ(absl::UnparseFlag(std::vector<unsigned int>{10, 20}), "10,20"); + EXPECT_EQ(absl::UnparseFlag(std::vector<long>{}), ""); // NOLINT + EXPECT_EQ(absl::UnparseFlag(std::vector<long>{-100, 200}), // NOLINT + "-100,200"); + EXPECT_EQ(absl::UnparseFlag(std::vector<unsigned long>{}), ""); // NOLINT + EXPECT_EQ(absl::UnparseFlag(std::vector<unsigned long>{100, 200}), // NOLINT + "100,200"); + EXPECT_EQ(absl::UnparseFlag(std::vector<long long>{}), ""); // NOLINT + EXPECT_EQ(absl::UnparseFlag(std::vector<long long>{-1000, 2000}), // NOLINT + "-1000,2000"); + EXPECT_EQ( + absl::UnparseFlag(std::vector<unsigned long long>{}), // NOLINT + ""); + EXPECT_EQ( + absl::UnparseFlag(std::vector<unsigned long long>{1000, 2000}), // NOLINT + "1000,2000"); + EXPECT_EQ(absl::UnparseFlag(std::vector<absl::int128>{}), ""); + EXPECT_EQ( + absl::UnparseFlag( + std::vector<absl::int128>{-1, absl::MakeInt128(-1, 0)}), + "-1,-18446744073709551616"); + EXPECT_EQ(absl::UnparseFlag(std::vector<absl::uint128>{}), ""); + EXPECT_EQ(absl::UnparseFlag(std::vector<absl::uint128>{ + 0, absl::MakeUint128(0, 0xFFFFFFFFFFFFFFFF)}), + "0,18446744073709551615"); + + EXPECT_EQ(absl::UnparseFlag(std::vector<float>{}), ""); + EXPECT_EQ(absl::UnparseFlag(std::vector<float>{ + 1.1f, -0.0f, std::numeric_limits<float>::infinity(), + -std::numeric_limits<float>::infinity(), std::nanf("")}), + "1.1,-0,inf,-inf,nan"); + + EXPECT_EQ(absl::UnparseFlag(std::vector<double>{}), ""); + EXPECT_EQ(absl::UnparseFlag(std::vector<double>{ + 1.1, -0.0, std::numeric_limits<double>::infinity(), + -std::numeric_limits<double>::infinity(), std::nan("")}), + "1.1,-0,inf,-inf,nan"); +} + +// -------------------------------------------------------------------- + TEST(MarshallingTest, TestOptionalBoolUnparsing) { std::optional<bool> value; @@ -1247,4 +1475,23 @@ TestRoundtrip(std::numeric_limits<double>::denorm_min()); } +TEST(MarshallingTest, TestVectorNumericRoundTrip) { + TestRoundtrip(std::vector<int64_t>{}); + TestRoundtrip(std::vector<int64_t>{ + std::numeric_limits<int64_t>::min(), -1, 0, 1, + std::numeric_limits<int64_t>::max()}); + TestRoundtrip(std::vector<float>{}); + TestRoundtrip(std::vector<float>{ + 0.12345678f, 0.12345678e20f, 0.12345678e-20f, + std::numeric_limits<float>::min(), std::numeric_limits<float>::max(), + std::numeric_limits<float>::lowest(), + std::numeric_limits<float>::denorm_min()}); + TestRoundtrip(std::vector<double>{}); + TestRoundtrip(std::vector<double>{ + 0.12345678912345678, 0.12345678912345678e50, 0.12345678912345678e-50, + std::numeric_limits<double>::min(), std::numeric_limits<double>::max(), + std::numeric_limits<double>::lowest(), + std::numeric_limits<double>::denorm_min()}); +} + } // namespace
diff --git a/absl/flags/parse_test.cc b/absl/flags/parse_test.cc index 9687950..a135c8c 100644 --- a/absl/flags/parse_test.cc +++ b/absl/flags/parse_test.cc
@@ -15,8 +15,10 @@ #include "absl/flags/parse.h" +#include <stdint.h> #include <stdlib.h> +#include <cmath> #include <fstream> #include <iostream> #include <string> @@ -229,6 +231,10 @@ ABSL_FLAG(double, double_flag, 1.1, ""); ABSL_FLAG(std::string, string_flag, "a", ""); ABSL_FLAG(bool, bool_flag, false, ""); +ABSL_FLAG(std::vector<int64_t>, int64_vec_flag, + std::vector<int64_t>({1, 2}), ""); +ABSL_FLAG(std::vector<double>, double_vec_flag, + std::vector<double>({0.5, 1.5}), ""); ABSL_FLAG(UDT, udt_flag, -1, ""); ABSL_RETIRED_FLAG(int, legacy_int, 1, ""); ABSL_RETIRED_FLAG(bool, legacy_bool, false, ""); @@ -1213,4 +1219,98 @@ testing::ExitedWithCode(0), ""); } +// -------------------------------------------------------------------- + +TEST_F(ParseTest, TestValidNumericVectorArg) { + EXPECT_EQ(absl::GetFlag(FLAGS_int64_vec_flag), + (std::vector<int64_t>{1, 2})); + EXPECT_EQ(absl::GetFlag(FLAGS_double_vec_flag), + (std::vector<double>{0.5, 1.5})); + + // Overwrites non-empty default, honors hex and leading-zero decimal. + const char* in_args1[] = { + "testbin", + "--int64_vec_flag=10,-20,0x10,010", + "--double_vec_flag=0.25, -1.25e-2, inf", + }; + InvokeParse(in_args1); + EXPECT_EQ(absl::GetFlag(FLAGS_int64_vec_flag), + (std::vector<int64_t>{10, -20, 16, 10})); + const std::vector<double> dvec = absl::GetFlag(FLAGS_double_vec_flag); + ASSERT_EQ(dvec.size(), 3u); + EXPECT_DOUBLE_EQ(dvec[0], 0.25); + EXPECT_DOUBLE_EQ(dvec[1], -0.0125); + EXPECT_TRUE(std::isinf(dvec[2]) && dvec[2] > 0); + + // Empty value clears vector to {}. + const char* in_args2[] = { + "testbin", + "--int64_vec_flag=", + "--double_vec_flag", + "", + }; + InvokeParse(in_args2); + EXPECT_EQ(absl::GetFlag(FLAGS_int64_vec_flag), std::vector<int64_t>{}); + EXPECT_EQ(absl::GetFlag(FLAGS_double_vec_flag), std::vector<double>{}); + + // Repeated flags overwrite previous values rather than appending. + const char* in_args3[] = { + "testbin", + "--int64_vec_flag=1, 2", + "--int64_vec_flag=3", + }; + InvokeParse(in_args3); + EXPECT_EQ(absl::GetFlag(FLAGS_int64_vec_flag), std::vector<int64_t>{3}); + + // Flagfile with surrounding whitespace and CRLF line endings. + std::string flagfile_flag; + constexpr const char* const vec_ff_data[] = { + " --int64_vec_flag=7, 8, 9 ", + }; + const char* in_args4[] = { + "testbin", + GetFlagfileFlag( + {{"parse_test.vec_ff", absl::MakeConstSpan(vec_ff_data)}}, + flagfile_flag, "\r\n"), + }; + InvokeParse(in_args4); + EXPECT_EQ(absl::GetFlag(FLAGS_int64_vec_flag), + (std::vector<int64_t>{7, 8, 9})); +} + +TEST_F(ParseDeathTest, TestInvalidNumericVectorArg) { + const char* in_args1[] = {"testbin", "--int64_vec_flag= "}; + EXPECT_DEATH_IF_SUPPORTED( + InvokeParse(in_args1), + "Illegal value ' ' specified for flag 'int64_vec_flag'"); + + const char* in_args2[] = {"testbin", "--int64_vec_flag=1,,2"}; + EXPECT_DEATH_IF_SUPPORTED( + InvokeParse(in_args2), + "Illegal value '1,,2' specified for flag 'int64_vec_flag'"); + + const char* in_args3[] = {"testbin", "--int64_vec_flag=1,2,"}; + EXPECT_DEATH_IF_SUPPORTED( + InvokeParse(in_args3), + "Illegal value '1,2,' specified for flag 'int64_vec_flag'"); + + const char* in_args4[] = {"testbin", "--int64_vec_flag=1, ,2"}; + EXPECT_DEATH_IF_SUPPORTED( + InvokeParse(in_args4), + "Illegal value '1, ,2' specified for flag 'int64_vec_flag'"); + + const char* in_args5[] = {"testbin", "--int64_vec_flag=1,typo,3"}; + EXPECT_DEATH_IF_SUPPORTED( + InvokeParse(in_args5), + "Illegal value '1,typo,3' specified for flag 'int64_vec_flag'"); + + const char* in_args_check_ok[] = {"testbin", "--only_check_args", + "--int64_vec_flag=1,2,3"}; + EXPECT_EXIT(InvokeParse(in_args_check_ok), testing::ExitedWithCode(0), ""); + + const char* in_args_check_bad[] = {"testbin", "--only_check_args", + "--int64_vec_flag=1,typo,3"}; + EXPECT_EXIT(InvokeParse(in_args_check_bad), testing::ExitedWithCode(1), ""); +} + } // namespace