@nxtedition/rocksdb 15.2.2 → 15.2.4

package/deps/abseil-cpp/absl/flags/marshalling_test.cc

@@ -1,1220 +0,0 @@
-//
-//  Copyright 2019 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/flags/marshalling.h"
-
-#include <stdint.h>
-
-#include <cmath>
-#include <limits>
-#include <string>
-#include <vector>
-
-#include "gtest/gtest.h"
-
-namespace {
-
-TEST(MarshallingTest, TestBoolParsing) {
-  std::string err;
-  bool value;
-
-  // True values.
-  EXPECT_TRUE(absl::ParseFlag("True", &value, &err));
-  EXPECT_TRUE(value);
-  EXPECT_TRUE(absl::ParseFlag("true", &value, &err));
-  EXPECT_TRUE(value);
-  EXPECT_TRUE(absl::ParseFlag("TRUE", &value, &err));
-  EXPECT_TRUE(value);
-
-  EXPECT_TRUE(absl::ParseFlag("Yes", &value, &err));
-  EXPECT_TRUE(value);
-  EXPECT_TRUE(absl::ParseFlag("yes", &value, &err));
-  EXPECT_TRUE(value);
-  EXPECT_TRUE(absl::ParseFlag("YES", &value, &err));
-  EXPECT_TRUE(value);
-
-  EXPECT_TRUE(absl::ParseFlag("t", &value, &err));
-  EXPECT_TRUE(value);
-  EXPECT_TRUE(absl::ParseFlag("T", &value, &err));
-  EXPECT_TRUE(value);
-
-  EXPECT_TRUE(absl::ParseFlag("y", &value, &err));
-  EXPECT_TRUE(value);
-  EXPECT_TRUE(absl::ParseFlag("Y", &value, &err));
-  EXPECT_TRUE(value);
-
-  EXPECT_TRUE(absl::ParseFlag("1", &value, &err));
-  EXPECT_TRUE(value);
-
-  // False values.
-  EXPECT_TRUE(absl::ParseFlag("False", &value, &err));
-  EXPECT_FALSE(value);
-  EXPECT_TRUE(absl::ParseFlag("false", &value, &err));
-  EXPECT_FALSE(value);
-  EXPECT_TRUE(absl::ParseFlag("FALSE", &value, &err));
-  EXPECT_FALSE(value);
-
-  EXPECT_TRUE(absl::ParseFlag("No", &value, &err));
-  EXPECT_FALSE(value);
-  EXPECT_TRUE(absl::ParseFlag("no", &value, &err));
-  EXPECT_FALSE(value);
-  EXPECT_TRUE(absl::ParseFlag("NO", &value, &err));
-  EXPECT_FALSE(value);
-
-  EXPECT_TRUE(absl::ParseFlag("f", &value, &err));
-  EXPECT_FALSE(value);
-  EXPECT_TRUE(absl::ParseFlag("F", &value, &err));
-  EXPECT_FALSE(value);
-
-  EXPECT_TRUE(absl::ParseFlag("n", &value, &err));
-  EXPECT_FALSE(value);
-  EXPECT_TRUE(absl::ParseFlag("N", &value, &err));
-  EXPECT_FALSE(value);
-
-  EXPECT_TRUE(absl::ParseFlag("0", &value, &err));
-  EXPECT_FALSE(value);
-
-  // Whitespace handling.
-  EXPECT_TRUE(absl::ParseFlag("  true", &value, &err));
-  EXPECT_TRUE(value);
-  EXPECT_TRUE(absl::ParseFlag("true  ", &value, &err));
-  EXPECT_TRUE(value);
-  EXPECT_TRUE(absl::ParseFlag("  true   ", &value, &err));
-  EXPECT_TRUE(value);
-
-  // Invalid input.
-  EXPECT_FALSE(absl::ParseFlag("", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag("  ", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag("\n", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag("\t", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag("2", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag("11", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag("tt", &value, &err));
-}
-
-// --------------------------------------------------------------------
-
-TEST(MarshallingTest, TestInt16Parsing) {
-  std::string err;
-  int16_t value;
-
-  // Decimal values.
-  EXPECT_TRUE(absl::ParseFlag("1", &value, &err));
-  EXPECT_EQ(value, 1);
-  EXPECT_TRUE(absl::ParseFlag("0", &value, &err));
-  EXPECT_EQ(value, 0);
-  EXPECT_TRUE(absl::ParseFlag("-1", &value, &err));
-  EXPECT_EQ(value, -1);
-  EXPECT_TRUE(absl::ParseFlag("123", &value, &err));
-  EXPECT_EQ(value, 123);
-  EXPECT_TRUE(absl::ParseFlag("-18765", &value, &err));
-  EXPECT_EQ(value, -18765);
-  EXPECT_TRUE(absl::ParseFlag("+3", &value, &err));
-  EXPECT_EQ(value, 3);
-
-  // Leading zero values.
-  EXPECT_TRUE(absl::ParseFlag("01", &value, &err));
-  EXPECT_EQ(value, 1);
-  EXPECT_TRUE(absl::ParseFlag("-001", &value, &err));
-  EXPECT_EQ(value, -1);
-  EXPECT_TRUE(absl::ParseFlag("0000100", &value, &err));
-  EXPECT_EQ(value, 100);
-
-  // Hex values.
-  EXPECT_TRUE(absl::ParseFlag("0x10", &value, &err));
-  EXPECT_EQ(value, 16);
-  EXPECT_TRUE(absl::ParseFlag("0X234", &value, &err));
-  EXPECT_EQ(value, 564);
-  EXPECT_TRUE(absl::ParseFlag("-0x7FFD", &value, &err));
-  EXPECT_EQ(value, -32765);
-  EXPECT_TRUE(absl::ParseFlag("+0x31", &value, &err));
-  EXPECT_EQ(value, 49);
-
-  // Whitespace handling
-  EXPECT_TRUE(absl::ParseFlag("10  ", &value, &err));
-  EXPECT_EQ(value, 10);
-  EXPECT_TRUE(absl::ParseFlag("  11", &value, &err));
-  EXPECT_EQ(value, 11);
-  EXPECT_TRUE(absl::ParseFlag("  012  ", &value, &err));
-  EXPECT_EQ(value, 12);
-  EXPECT_TRUE(absl::ParseFlag(" 0x22    ", &value, &err));
-  EXPECT_EQ(value, 34);
-
-  // Invalid values.
-  EXPECT_FALSE(absl::ParseFlag("", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag(" ", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag("  ", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag("40000", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag("--1", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag("\n", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag("\t", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag("2U", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag("FFF", &value, &err));
-}
-
-// --------------------------------------------------------------------
-
-TEST(MarshallingTest, TestUint16Parsing) {
-  std::string err;
-  uint16_t value;
-
-  // Decimal values.
-  EXPECT_TRUE(absl::ParseFlag("1", &value, &err));
-  EXPECT_EQ(value, 1);
-  EXPECT_TRUE(absl::ParseFlag("0", &value, &err));
-  EXPECT_EQ(value, 0);
-  EXPECT_TRUE(absl::ParseFlag("123", &value, &err));
-  EXPECT_EQ(value, 123);
-  EXPECT_TRUE(absl::ParseFlag("+3", &value, &err));
-  EXPECT_EQ(value, 3);
-
-  // Leading zero values.
-  EXPECT_TRUE(absl::ParseFlag("01", &value, &err));
-  EXPECT_EQ(value, 1);
-  EXPECT_TRUE(absl::ParseFlag("001", &value, &err));
-  EXPECT_EQ(value, 1);
-  EXPECT_TRUE(absl::ParseFlag("0000100", &value, &err));
-  EXPECT_EQ(value, 100);
-
-  // Hex values.
-  EXPECT_TRUE(absl::ParseFlag("0x10", &value, &err));
-  EXPECT_EQ(value, 16);
-  EXPECT_TRUE(absl::ParseFlag("0X234", &value, &err));
-  EXPECT_EQ(value, 564);
-  EXPECT_TRUE(absl::ParseFlag("+0x31", &value, &err));
-  EXPECT_EQ(value, 49);
-
-  // Whitespace handling
-  EXPECT_TRUE(absl::ParseFlag("10  ", &value, &err));
-  EXPECT_EQ(value, 10);
-  EXPECT_TRUE(absl::ParseFlag("  11", &value, &err));
-  EXPECT_EQ(value, 11);
-  EXPECT_TRUE(absl::ParseFlag("  012  ", &value, &err));
-  EXPECT_EQ(value, 12);
-  EXPECT_TRUE(absl::ParseFlag(" 0x22    ", &value, &err));
-  EXPECT_EQ(value, 34);
-
-  // Invalid values.
-  EXPECT_FALSE(absl::ParseFlag("", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag(" ", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag("  ", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag("70000", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag("-1", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag("--1", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag("\n", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag("\t", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag("2U", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag("FFF", &value, &err));
-}
-
-// --------------------------------------------------------------------
-
-TEST(MarshallingTest, TestInt32Parsing) {
-  std::string err;
-  int32_t value;
-
-  // Decimal values.
-  EXPECT_TRUE(absl::ParseFlag("1", &value, &err));
-  EXPECT_EQ(value, 1);
-  EXPECT_TRUE(absl::ParseFlag("0", &value, &err));
-  EXPECT_EQ(value, 0);
-  EXPECT_TRUE(absl::ParseFlag("-1", &value, &err));
-  EXPECT_EQ(value, -1);
-  EXPECT_TRUE(absl::ParseFlag("123", &value, &err));
-  EXPECT_EQ(value, 123);
-  EXPECT_TRUE(absl::ParseFlag("-98765", &value, &err));
-  EXPECT_EQ(value, -98765);
-  EXPECT_TRUE(absl::ParseFlag("+3", &value, &err));
-  EXPECT_EQ(value, 3);
-
-  // Leading zero values.
-  EXPECT_TRUE(absl::ParseFlag("01", &value, &err));
-  EXPECT_EQ(value, 1);
-  EXPECT_TRUE(absl::ParseFlag("-001", &value, &err));
-  EXPECT_EQ(value, -1);
-  EXPECT_TRUE(absl::ParseFlag("0000100", &value, &err));
-  EXPECT_EQ(value, 100);
-
-  // Hex values.
-  EXPECT_TRUE(absl::ParseFlag("0x10", &value, &err));
-  EXPECT_EQ(value, 16);
-  EXPECT_TRUE(absl::ParseFlag("0X234", &value, &err));
-  EXPECT_EQ(value, 564);
-
-  EXPECT_TRUE(absl::ParseFlag("-0x7FFFFFFD", &value, &err));
-  EXPECT_EQ(value, -2147483645);
-  EXPECT_TRUE(absl::ParseFlag("+0x31", &value, &err));
-  EXPECT_EQ(value, 49);
-
-  // Whitespace handling
-  EXPECT_TRUE(absl::ParseFlag("10  ", &value, &err));
-  EXPECT_EQ(value, 10);
-  EXPECT_TRUE(absl::ParseFlag("  11", &value, &err));
-  EXPECT_EQ(value, 11);
-  EXPECT_TRUE(absl::ParseFlag("  012  ", &value, &err));
-  EXPECT_EQ(value, 12);
-  EXPECT_TRUE(absl::ParseFlag(" 0x22    ", &value, &err));
-  EXPECT_EQ(value, 34);
-
-  // Invalid values.
-  EXPECT_FALSE(absl::ParseFlag("", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag(" ", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag("  ", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag("70000000000", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag("--1", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag("\n", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag("\t", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag("2U", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag("FFF", &value, &err));
-}
-
-// --------------------------------------------------------------------
-
-TEST(MarshallingTest, TestUint32Parsing) {
-  std::string err;
-  uint32_t value;
-
-  // Decimal values.
-  EXPECT_TRUE(absl::ParseFlag("1", &value, &err));
-  EXPECT_EQ(value, 1);
-  EXPECT_TRUE(absl::ParseFlag("0", &value, &err));
-  EXPECT_EQ(value, 0);
-  EXPECT_TRUE(absl::ParseFlag("123", &value, &err));
-  EXPECT_EQ(value, 123);
-  EXPECT_TRUE(absl::ParseFlag("+3", &value, &err));
-  EXPECT_EQ(value, 3);
-
-  // Leading zero values.
-  EXPECT_TRUE(absl::ParseFlag("01", &value, &err));
-  EXPECT_EQ(value, 1);
-  EXPECT_TRUE(absl::ParseFlag("0000100", &value, &err));
-  EXPECT_EQ(value, 100);
-
-  // Hex values.
-  EXPECT_TRUE(absl::ParseFlag("0x10", &value, &err));
-  EXPECT_EQ(value, 16);
-  EXPECT_TRUE(absl::ParseFlag("0X234", &value, &err));
-  EXPECT_EQ(value, 564);
-  EXPECT_TRUE(absl::ParseFlag("0xFFFFFFFD", &value, &err));
-  EXPECT_EQ(value, 4294967293);
-  EXPECT_TRUE(absl::ParseFlag("+0x31", &value, &err));
-  EXPECT_EQ(value, 49);
-
-  // Whitespace handling
-  EXPECT_TRUE(absl::ParseFlag("10  ", &value, &err));
-  EXPECT_EQ(value, 10);
-  EXPECT_TRUE(absl::ParseFlag("  11", &value, &err));
-  EXPECT_EQ(value, 11);
-  EXPECT_TRUE(absl::ParseFlag("  012  ", &value, &err));
-  EXPECT_EQ(value, 12);
-  EXPECT_TRUE(absl::ParseFlag(" 0x22    ", &value, &err));
-  EXPECT_EQ(value, 34);
-
-  // Invalid values.
-  EXPECT_FALSE(absl::ParseFlag("", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag(" ", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag("  ", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag("140000000000", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag("-1", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag("--1", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag("\n", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag("\t", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag("2U", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag("FFF", &value, &err));
-}
-
-// --------------------------------------------------------------------
-
-TEST(MarshallingTest, TestInt64Parsing) {
-  std::string err;
-  int64_t value;
-
-  // Decimal values.
-  EXPECT_TRUE(absl::ParseFlag("1", &value, &err));
-  EXPECT_EQ(value, 1);
-  EXPECT_TRUE(absl::ParseFlag("0", &value, &err));
-  EXPECT_EQ(value, 0);
-  EXPECT_TRUE(absl::ParseFlag("-1", &value, &err));
-  EXPECT_EQ(value, -1);
-  EXPECT_TRUE(absl::ParseFlag("123", &value, &err));
-  EXPECT_EQ(value, 123);
-  EXPECT_TRUE(absl::ParseFlag("-98765", &value, &err));
-  EXPECT_EQ(value, -98765);
-  EXPECT_TRUE(absl::ParseFlag("+3", &value, &err));
-  EXPECT_EQ(value, 3);
-
-  // Leading zero values.
-  EXPECT_TRUE(absl::ParseFlag("01", &value, &err));
-  EXPECT_EQ(value, 1);
-  EXPECT_TRUE(absl::ParseFlag("001", &value, &err));
-  EXPECT_EQ(value, 1);
-  EXPECT_TRUE(absl::ParseFlag("0000100", &value, &err));
-  EXPECT_EQ(value, 100);
-
-  // Hex values.
-  EXPECT_TRUE(absl::ParseFlag("0x10", &value, &err));
-  EXPECT_EQ(value, 16);
-  EXPECT_TRUE(absl::ParseFlag("0XFFFAAABBBCCCDDD", &value, &err));
-  EXPECT_EQ(value, 1152827684197027293);
-  EXPECT_TRUE(absl::ParseFlag("-0x7FFFFFFFFFFFFFFE", &value, &err));
-  EXPECT_EQ(value, -9223372036854775806);
-  EXPECT_TRUE(absl::ParseFlag("-0x02", &value, &err));
-  EXPECT_EQ(value, -2);
-  EXPECT_TRUE(absl::ParseFlag("+0x31", &value, &err));
-  EXPECT_EQ(value, 49);
-
-  // Whitespace handling
-  EXPECT_TRUE(absl::ParseFlag("10  ", &value, &err));
-  EXPECT_EQ(value, 10);
-  EXPECT_TRUE(absl::ParseFlag("  11", &value, &err));
-  EXPECT_EQ(value, 11);
-  EXPECT_TRUE(absl::ParseFlag("  012  ", &value, &err));
-  EXPECT_EQ(value, 12);
-  EXPECT_TRUE(absl::ParseFlag(" 0x7F    ", &value, &err));
-  EXPECT_EQ(value, 127);
-
-  // Invalid values.
-  EXPECT_FALSE(absl::ParseFlag("", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag(" ", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag("  ", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag("0xFFFFFFFFFFFFFFFFFF", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag("--1", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag("\n", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag("\t", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag("2U", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag("FFF", &value, &err));
-}
-
-// --------------------------------------------------------------------
-
-TEST(MarshallingTest, TestUInt64Parsing) {
-  std::string err;
-  uint64_t value;
-
-  // Decimal values.
-  EXPECT_TRUE(absl::ParseFlag("1", &value, &err));
-  EXPECT_EQ(value, 1);
-  EXPECT_TRUE(absl::ParseFlag("0", &value, &err));
-  EXPECT_EQ(value, 0);
-  EXPECT_TRUE(absl::ParseFlag("123", &value, &err));
-  EXPECT_EQ(value, 123);
-  EXPECT_TRUE(absl::ParseFlag("+13", &value, &err));
-  EXPECT_EQ(value, 13);
-
-  // Leading zero values.
-  EXPECT_TRUE(absl::ParseFlag("01", &value, &err));
-  EXPECT_EQ(value, 1);
-  EXPECT_TRUE(absl::ParseFlag("001", &value, &err));
-  EXPECT_EQ(value, 1);
-  EXPECT_TRUE(absl::ParseFlag("0000300", &value, &err));
-  EXPECT_EQ(value, 300);
-
-  // Hex values.
-  EXPECT_TRUE(absl::ParseFlag("0x10", &value, &err));
-  EXPECT_EQ(value, 16);
-  EXPECT_TRUE(absl::ParseFlag("0XFFFF", &value, &err));
-  EXPECT_EQ(value, 65535);
-  EXPECT_TRUE(absl::ParseFlag("+0x31", &value, &err));
-  EXPECT_EQ(value, 49);
-
-  // Whitespace handling
-  EXPECT_TRUE(absl::ParseFlag("10  ", &value, &err));
-  EXPECT_EQ(value, 10);
-  EXPECT_TRUE(absl::ParseFlag("  11", &value, &err));
-  EXPECT_EQ(value, 11);
-  EXPECT_TRUE(absl::ParseFlag("  012  ", &value, &err));
-  EXPECT_EQ(value, 12);
-
-  // Invalid values.
-  EXPECT_FALSE(absl::ParseFlag("", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag(" ", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag("  ", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag("0xFFFFFFFFFFFFFFFFFF", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag("-1", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag("--1", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag("\n", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag("\t", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag("2U", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag("FFF", &value, &err));
-}
-
-// --------------------------------------------------------------------
-
-TEST(MarshallingTest, TestInt128Parsing) {
-  std::string err;
-  absl::int128 value;
-
-  // Decimal values.
-  EXPECT_TRUE(absl::ParseFlag("0", &value, &err));
-  EXPECT_EQ(value, 0);
-  EXPECT_TRUE(absl::ParseFlag("1", &value, &err));
-  EXPECT_EQ(value, 1);
-  EXPECT_TRUE(absl::ParseFlag("-1", &value, &err));
-  EXPECT_EQ(value, -1);
-  EXPECT_TRUE(absl::ParseFlag("123", &value, &err));
-  EXPECT_EQ(value, 123);
-  EXPECT_TRUE(absl::ParseFlag("-98765", &value, &err));
-  EXPECT_EQ(value, -98765);
-  EXPECT_TRUE(absl::ParseFlag("+3", &value, &err));
-  EXPECT_EQ(value, 3);
-
-  // Leading zero values.
-  EXPECT_TRUE(absl::ParseFlag("01", &value, &err));
-  EXPECT_EQ(value, 1);
-  EXPECT_TRUE(absl::ParseFlag("001", &value, &err));
-  EXPECT_EQ(value, 1);
-  EXPECT_TRUE(absl::ParseFlag("0000100", &value, &err));
-  EXPECT_EQ(value, 100);
-
-  // Hex values.
-  EXPECT_TRUE(absl::ParseFlag("0x10", &value, &err));
-  EXPECT_EQ(value, 16);
-  EXPECT_TRUE(absl::ParseFlag("0xFFFAAABBBCCCDDD", &value, &err));
-  EXPECT_EQ(value, 1152827684197027293);
-  EXPECT_TRUE(absl::ParseFlag("0xFFF0FFFFFFFFFFFFFFF", &value, &err));
-  EXPECT_EQ(value, absl::MakeInt128(0x000000000000fff, 0xFFFFFFFFFFFFFFF));
-
-  EXPECT_TRUE(absl::ParseFlag("-0x10000000000000000", &value, &err));
-  EXPECT_EQ(value, absl::MakeInt128(-1, 0));
-  EXPECT_TRUE(absl::ParseFlag("+0x31", &value, &err));
-  EXPECT_EQ(value, 49);
-
-  // Whitespace handling
-  EXPECT_TRUE(absl::ParseFlag("16  ", &value, &err));
-  EXPECT_EQ(value, 16);
-  EXPECT_TRUE(absl::ParseFlag("  16", &value, &err));
-  EXPECT_EQ(value, 16);
-  EXPECT_TRUE(absl::ParseFlag("  0100  ", &value, &err));
-  EXPECT_EQ(value, 100);
-  EXPECT_TRUE(absl::ParseFlag(" 0x7B    ", &value, &err));
-  EXPECT_EQ(value, 123);
-
-  // Invalid values.
-  EXPECT_FALSE(absl::ParseFlag("", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag(" ", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag("  ", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag("--1", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag("\n", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag("\t", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag("2U", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag("FFF", &value, &err));
-}
-
-// --------------------------------------------------------------------
-
-TEST(MarshallingTest, TestUint128Parsing) {
-  std::string err;
-  absl::uint128 value;
-
-  // Decimal values.
-  EXPECT_TRUE(absl::ParseFlag("0", &value, &err));
-  EXPECT_EQ(value, 0);
-  EXPECT_TRUE(absl::ParseFlag("1", &value, &err));
-  EXPECT_EQ(value, 1);
-  EXPECT_TRUE(absl::ParseFlag("123", &value, &err));
-  EXPECT_EQ(value, 123);
-  EXPECT_TRUE(absl::ParseFlag("+3", &value, &err));
-  EXPECT_EQ(value, 3);
-
-  // Leading zero values.
-  EXPECT_TRUE(absl::ParseFlag("01", &value, &err));
-  EXPECT_EQ(value, 1);
-  EXPECT_TRUE(absl::ParseFlag("001", &value, &err));
-  EXPECT_EQ(value, 1);
-  EXPECT_TRUE(absl::ParseFlag("0000100", &value, &err));
-  EXPECT_EQ(value, 100);
-
-  // Hex values.
-  EXPECT_TRUE(absl::ParseFlag("0x10", &value, &err));
-  EXPECT_EQ(value, 16);
-  EXPECT_TRUE(absl::ParseFlag("0xFFFAAABBBCCCDDD", &value, &err));
-  EXPECT_EQ(value, 1152827684197027293);
-  EXPECT_TRUE(absl::ParseFlag("0xFFF0FFFFFFFFFFFFFFF", &value, &err));
-  EXPECT_EQ(value, absl::MakeInt128(0x000000000000fff, 0xFFFFFFFFFFFFFFF));
-  EXPECT_TRUE(absl::ParseFlag("+0x31", &value, &err));
-  EXPECT_EQ(value, 49);
-
-  // Whitespace handling
-  EXPECT_TRUE(absl::ParseFlag("16  ", &value, &err));
-  EXPECT_EQ(value, 16);
-  EXPECT_TRUE(absl::ParseFlag("  16", &value, &err));
-  EXPECT_EQ(value, 16);
-  EXPECT_TRUE(absl::ParseFlag("  0100  ", &value, &err));
-  EXPECT_EQ(value, 100);
-  EXPECT_TRUE(absl::ParseFlag(" 0x7B    ", &value, &err));
-  EXPECT_EQ(value, 123);
-
-  // Invalid values.
-  EXPECT_FALSE(absl::ParseFlag("", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag(" ", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag("  ", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag("-1", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag("--1", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag("\n", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag("\t", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag("2U", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag("FFF", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag("-0x10000000000000000", &value, &err));
-}
-
-// --------------------------------------------------------------------
-
-TEST(MarshallingTest, TestFloatParsing) {
-  std::string err;
-  float value;
-
-  // Ordinary values.
-  EXPECT_TRUE(absl::ParseFlag("1.3", &value, &err));
-  EXPECT_FLOAT_EQ(value, 1.3f);
-  EXPECT_TRUE(absl::ParseFlag("-0.1", &value, &err));
-  EXPECT_DOUBLE_EQ(value, -0.1f);
-  EXPECT_TRUE(absl::ParseFlag("+0.01", &value, &err));
-  EXPECT_DOUBLE_EQ(value, 0.01f);
-
-  // Scientific values.
-  EXPECT_TRUE(absl::ParseFlag("1.2e3", &value, &err));
-  EXPECT_DOUBLE_EQ(value, 1.2e3f);
-  EXPECT_TRUE(absl::ParseFlag("9.8765402e-37", &value, &err));
-  EXPECT_DOUBLE_EQ(value, 9.8765402e-37f);
-  EXPECT_TRUE(absl::ParseFlag("0.11e+3", &value, &err));
-  EXPECT_DOUBLE_EQ(value, 0.11e+3f);
-  EXPECT_TRUE(absl::ParseFlag("1.e-2300", &value, &err));
-  EXPECT_DOUBLE_EQ(value, 0.f);
-  EXPECT_TRUE(absl::ParseFlag("1.e+2300", &value, &err));
-  EXPECT_TRUE(std::isinf(value));
-
-  // Leading zero values.
-  EXPECT_TRUE(absl::ParseFlag("01.6", &value, &err));
-  EXPECT_DOUBLE_EQ(value, 1.6f);
-  EXPECT_TRUE(absl::ParseFlag("000.0001", &value, &err));
-  EXPECT_DOUBLE_EQ(value, 0.0001f);
-
-  // Trailing zero values.
-  EXPECT_TRUE(absl::ParseFlag("-5.1000", &value, &err));
-  EXPECT_DOUBLE_EQ(value, -5.1f);
-
-  // Exceptional values.
-  EXPECT_TRUE(absl::ParseFlag("NaN", &value, &err));
-  EXPECT_TRUE(std::isnan(value));
-  EXPECT_TRUE(absl::ParseFlag("Inf", &value, &err));
-  EXPECT_TRUE(std::isinf(value));
-
-  // Hex values
-  EXPECT_TRUE(absl::ParseFlag("0x10.23p12", &value, &err));
-  EXPECT_DOUBLE_EQ(value, 66096.f);
-  EXPECT_TRUE(absl::ParseFlag("-0xF1.A3p-2", &value, &err));
-  EXPECT_NEAR(value, -60.4092f, 5e-5f);
-  EXPECT_TRUE(absl::ParseFlag("+0x0.0AAp-12", &value, &err));
-  EXPECT_NEAR(value, 1.01328e-05f, 5e-11f);
-  EXPECT_TRUE(absl::ParseFlag("0x.01p1", &value, &err));
-  EXPECT_NEAR(value, 0.0078125f, 5e-8f);
-
-  // Whitespace handling
-  EXPECT_TRUE(absl::ParseFlag("10.1  ", &value, &err));
-  EXPECT_DOUBLE_EQ(value, 10.1f);
-  EXPECT_TRUE(absl::ParseFlag("  2.34", &value, &err));
-  EXPECT_DOUBLE_EQ(value, 2.34f);
-  EXPECT_TRUE(absl::ParseFlag("  5.7  ", &value, &err));
-  EXPECT_DOUBLE_EQ(value, 5.7f);
-  EXPECT_TRUE(absl::ParseFlag("  -0xE0.F3p01  ", &value, &err));
-  EXPECT_NEAR(value, -449.8984375f, 5e-8f);
-
-  // Invalid values.
-  EXPECT_FALSE(absl::ParseFlag("", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag(" ", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag("  ", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag("--1", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag("\n", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag("\t", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag("2.3xxx", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag("0x0.1pAA", &value, &err));
-  // TODO(rogeeff): below assertion should fail
-  EXPECT_TRUE(absl::ParseFlag("0x0.1", &value, &err));
-}
-
-// --------------------------------------------------------------------
-
-TEST(MarshallingTest, TestDoubleParsing) {
-  std::string err;
-  double value;
-
-  // Ordinary values.
-  EXPECT_TRUE(absl::ParseFlag("1.3", &value, &err));
-  EXPECT_DOUBLE_EQ(value, 1.3);
-  EXPECT_TRUE(absl::ParseFlag("-0.1", &value, &err));
-  EXPECT_DOUBLE_EQ(value, -0.1);
-  EXPECT_TRUE(absl::ParseFlag("+0.01", &value, &err));
-  EXPECT_DOUBLE_EQ(value, 0.01);
-
-  // Scientific values.
-  EXPECT_TRUE(absl::ParseFlag("1.2e3", &value, &err));
-  EXPECT_DOUBLE_EQ(value, 1.2e3);
-  EXPECT_TRUE(absl::ParseFlag("9.00000002e-123", &value, &err));
-  EXPECT_DOUBLE_EQ(value, 9.00000002e-123);
-  EXPECT_TRUE(absl::ParseFlag("0.11e+3", &value, &err));
-  EXPECT_DOUBLE_EQ(value, 0.11e+3);
-  EXPECT_TRUE(absl::ParseFlag("1.e-2300", &value, &err));
-  EXPECT_DOUBLE_EQ(value, 0);
-  EXPECT_TRUE(absl::ParseFlag("1.e+2300", &value, &err));
-  EXPECT_TRUE(std::isinf(value));
-
-  // Leading zero values.
-  EXPECT_TRUE(absl::ParseFlag("01.6", &value, &err));
-  EXPECT_DOUBLE_EQ(value, 1.6);
-  EXPECT_TRUE(absl::ParseFlag("000.0001", &value, &err));
-  EXPECT_DOUBLE_EQ(value, 0.0001);
-
-  // Trailing zero values.
-  EXPECT_TRUE(absl::ParseFlag("-5.1000", &value, &err));
-  EXPECT_DOUBLE_EQ(value, -5.1);
-
-  // Exceptional values.
-  EXPECT_TRUE(absl::ParseFlag("NaN", &value, &err));
-  EXPECT_TRUE(std::isnan(value));
-  EXPECT_TRUE(absl::ParseFlag("nan", &value, &err));
-  EXPECT_TRUE(std::isnan(value));
-  EXPECT_TRUE(absl::ParseFlag("Inf", &value, &err));
-  EXPECT_TRUE(std::isinf(value));
-  EXPECT_TRUE(absl::ParseFlag("inf", &value, &err));
-  EXPECT_TRUE(std::isinf(value));
-
-  // Hex values
-  EXPECT_TRUE(absl::ParseFlag("0x10.23p12", &value, &err));
-  EXPECT_DOUBLE_EQ(value, 66096);
-  EXPECT_TRUE(absl::ParseFlag("-0xF1.A3p-2", &value, &err));
-  EXPECT_NEAR(value, -60.4092, 5e-5);
-  EXPECT_TRUE(absl::ParseFlag("+0x0.0AAp-12", &value, &err));
-  EXPECT_NEAR(value, 1.01328e-05, 5e-11);
-  EXPECT_TRUE(absl::ParseFlag("0x.01p1", &value, &err));
-  EXPECT_NEAR(value, 0.0078125, 5e-8);
-
-  // Whitespace handling
-  EXPECT_TRUE(absl::ParseFlag("10.1  ", &value, &err));
-  EXPECT_DOUBLE_EQ(value, 10.1);
-  EXPECT_TRUE(absl::ParseFlag("  2.34", &value, &err));
-  EXPECT_DOUBLE_EQ(value, 2.34);
-  EXPECT_TRUE(absl::ParseFlag("  5.7  ", &value, &err));
-  EXPECT_DOUBLE_EQ(value, 5.7);
-  EXPECT_TRUE(absl::ParseFlag("  -0xE0.F3p01  ", &value, &err));
-  EXPECT_NEAR(value, -449.8984375, 5e-8);
-
-  // Invalid values.
-  EXPECT_FALSE(absl::ParseFlag("", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag(" ", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag("  ", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag("--1", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag("\n", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag("\t", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag("2.3xxx", &value, &err));
-  EXPECT_FALSE(absl::ParseFlag("0x0.1pAA", &value, &err));
-  // TODO(rogeeff): below assertion should fail
-  EXPECT_TRUE(absl::ParseFlag("0x0.1", &value, &err));
-}
-
-// --------------------------------------------------------------------
-
-TEST(MarshallingTest, TestStringParsing) {
-  std::string err;
-  std::string value;
-
-  EXPECT_TRUE(absl::ParseFlag("", &value, &err));
-  EXPECT_EQ(value, "");
-  EXPECT_TRUE(absl::ParseFlag(" ", &value, &err));
-  EXPECT_EQ(value, " ");
-  EXPECT_TRUE(absl::ParseFlag("   ", &value, &err));
-  EXPECT_EQ(value, "   ");
-  EXPECT_TRUE(absl::ParseFlag("\n", &value, &err));
-  EXPECT_EQ(value, "\n");
-  EXPECT_TRUE(absl::ParseFlag("\t", &value, &err));
-  EXPECT_EQ(value, "\t");
-  EXPECT_TRUE(absl::ParseFlag("asdfg", &value, &err));
-  EXPECT_EQ(value, "asdfg");
-  EXPECT_TRUE(absl::ParseFlag("asdf ghjk", &value, &err));
-  EXPECT_EQ(value, "asdf ghjk");
-  EXPECT_TRUE(absl::ParseFlag("a\nb\nc", &value, &err));
-  EXPECT_EQ(value, "a\nb\nc");
-  EXPECT_TRUE(absl::ParseFlag("asd\0fgh", &value, &err));
-  EXPECT_EQ(value, "asd");
-  EXPECT_TRUE(absl::ParseFlag("\\\\", &value, &err));
-  EXPECT_EQ(value, "\\\\");
-}
-
-// --------------------------------------------------------------------
-
-TEST(MarshallingTest, TestVectorOfStringParsing) {
-  std::string err;
-  std::vector<std::string> value;
-
-  EXPECT_TRUE(absl::ParseFlag("", &value, &err));
-  EXPECT_EQ(value, std::vector<std::string>{});
-  EXPECT_TRUE(absl::ParseFlag("1", &value, &err));
-  EXPECT_EQ(value, std::vector<std::string>({"1"}));
-  EXPECT_TRUE(absl::ParseFlag("a,b", &value, &err));
-  EXPECT_EQ(value, std::vector<std::string>({"a", "b"}));
-  EXPECT_TRUE(absl::ParseFlag("a,b,c,", &value, &err));
-  EXPECT_EQ(value, std::vector<std::string>({"a", "b", "c", ""}));
-  EXPECT_TRUE(absl::ParseFlag("a,,", &value, &err));
-  EXPECT_EQ(value, std::vector<std::string>({"a", "", ""}));
-  EXPECT_TRUE(absl::ParseFlag(",", &value, &err));
-  EXPECT_EQ(value, std::vector<std::string>({"", ""}));
-  EXPECT_TRUE(absl::ParseFlag("a, b,c ", &value, &err));
-  EXPECT_EQ(value, std::vector<std::string>({"a", " b", "c "}));
-}
-
-// --------------------------------------------------------------------
-
-TEST(MarshallingTest, TestOptionalBoolParsing) {
-  std::string err;
-  absl::optional<bool> value;
-
-  EXPECT_TRUE(absl::ParseFlag("", &value, &err));
-  EXPECT_FALSE(value.has_value());
-
-  EXPECT_TRUE(absl::ParseFlag("true", &value, &err));
-  EXPECT_TRUE(value.has_value());
-  EXPECT_TRUE(*value);
-
-  EXPECT_TRUE(absl::ParseFlag("false", &value, &err));
-  EXPECT_TRUE(value.has_value());
-  EXPECT_FALSE(*value);
-
-  EXPECT_FALSE(absl::ParseFlag("nullopt", &value, &err));
-}
-
-// --------------------------------------------------------------------
-
-TEST(MarshallingTest, TestOptionalIntParsing) {
-  std::string err;
-  absl::optional<int> value;
-
-  EXPECT_TRUE(absl::ParseFlag("", &value, &err));
-  EXPECT_FALSE(value.has_value());
-
-  EXPECT_TRUE(absl::ParseFlag("10", &value, &err));
-  EXPECT_TRUE(value.has_value());
-  EXPECT_EQ(*value, 10);
-
-  EXPECT_TRUE(absl::ParseFlag("0x1F", &value, &err));
-  EXPECT_TRUE(value.has_value());
-  EXPECT_EQ(*value, 31);
-
-  EXPECT_FALSE(absl::ParseFlag("nullopt", &value, &err));
-}
-
-// --------------------------------------------------------------------
-
-TEST(MarshallingTest, TestOptionalDoubleParsing) {
-  std::string err;
-  absl::optional<double> value;
-
-  EXPECT_TRUE(absl::ParseFlag("", &value, &err));
-  EXPECT_FALSE(value.has_value());
-
-  EXPECT_TRUE(absl::ParseFlag("1.11", &value, &err));
-  EXPECT_TRUE(value.has_value());
-  EXPECT_EQ(*value, 1.11);
-
-  EXPECT_TRUE(absl::ParseFlag("-0.12", &value, &err));
-  EXPECT_TRUE(value.has_value());
-  EXPECT_EQ(*value, -0.12);
-
-  EXPECT_FALSE(absl::ParseFlag("nullopt", &value, &err));
-}
-
-// --------------------------------------------------------------------
-
-TEST(MarshallingTest, TestOptionalStringParsing) {
-  std::string err;
-  absl::optional<std::string> value;
-
-  EXPECT_TRUE(absl::ParseFlag("", &value, &err));
-  EXPECT_FALSE(value.has_value());
-
-  EXPECT_TRUE(absl::ParseFlag(" ", &value, &err));
-  EXPECT_TRUE(value.has_value());
-  EXPECT_EQ(*value, " ");
-
-  EXPECT_TRUE(absl::ParseFlag("aqswde", &value, &err));
-  EXPECT_TRUE(value.has_value());
-  EXPECT_EQ(*value, "aqswde");
-
-  EXPECT_TRUE(absl::ParseFlag("nullopt", &value, &err));
-  EXPECT_TRUE(value.has_value());
-  EXPECT_EQ(*value, "nullopt");
-}
-
-// --------------------------------------------------------------------
-
-TEST(MarshallingTest, TestBoolUnparsing) {
-  EXPECT_EQ(absl::UnparseFlag(true), "true");
-  EXPECT_EQ(absl::UnparseFlag(false), "false");
-}
-
-// --------------------------------------------------------------------
-
-TEST(MarshallingTest, TestInt16Unparsing) {
-  int16_t value;
-
-  value = 1;
-  EXPECT_EQ(absl::UnparseFlag(value), "1");
-  value = 0;
-  EXPECT_EQ(absl::UnparseFlag(value), "0");
-  value = -1;
-  EXPECT_EQ(absl::UnparseFlag(value), "-1");
-  value = 9876;
-  EXPECT_EQ(absl::UnparseFlag(value), "9876");
-  value = -987;
-  EXPECT_EQ(absl::UnparseFlag(value), "-987");
-}
-
-// --------------------------------------------------------------------
-
-TEST(MarshallingTest, TestUint16Unparsing) {
-  uint16_t value;
-
-  value = 1;
-  EXPECT_EQ(absl::UnparseFlag(value), "1");
-  value = 0;
-  EXPECT_EQ(absl::UnparseFlag(value), "0");
-  value = 19876;
-  EXPECT_EQ(absl::UnparseFlag(value), "19876");
-}
-
-// --------------------------------------------------------------------
-
-TEST(MarshallingTest, TestInt32Unparsing) {
-  int32_t value;
-
-  value = 1;
-  EXPECT_EQ(absl::UnparseFlag(value), "1");
-  value = 0;
-  EXPECT_EQ(absl::UnparseFlag(value), "0");
-  value = -1;
-  EXPECT_EQ(absl::UnparseFlag(value), "-1");
-  value = 12345;
-  EXPECT_EQ(absl::UnparseFlag(value), "12345");
-  value = -987;
-  EXPECT_EQ(absl::UnparseFlag(value), "-987");
-}
-
-// --------------------------------------------------------------------
-
-TEST(MarshallingTest, TestUint32Unparsing) {
-  uint32_t value;
-
-  value = 1;
-  EXPECT_EQ(absl::UnparseFlag(value), "1");
-  value = 0;
-  EXPECT_EQ(absl::UnparseFlag(value), "0");
-  value = 1234500;
-  EXPECT_EQ(absl::UnparseFlag(value), "1234500");
-}
-
-// --------------------------------------------------------------------
-
-TEST(MarshallingTest, TestInt64Unparsing) {
-  int64_t value;
-
-  value = 1;
-  EXPECT_EQ(absl::UnparseFlag(value), "1");
-  value = 0;
-  EXPECT_EQ(absl::UnparseFlag(value), "0");
-  value = -1;
-  EXPECT_EQ(absl::UnparseFlag(value), "-1");
-  value = 123456789L;
-  EXPECT_EQ(absl::UnparseFlag(value), "123456789");
-  value = -987654321L;
-  EXPECT_EQ(absl::UnparseFlag(value), "-987654321");
-  value = 0x7FFFFFFFFFFFFFFF;
-  EXPECT_EQ(absl::UnparseFlag(value), "9223372036854775807");
-  value = 0xFFFFFFFFFFFFFFFF;
-  EXPECT_EQ(absl::UnparseFlag(value), "-1");
-}
-
-// --------------------------------------------------------------------
-
-TEST(MarshallingTest, TestUint64Unparsing) {
-  uint64_t value;
-
-  value = 1;
-  EXPECT_EQ(absl::UnparseFlag(value), "1");
-  value = 0;
-  EXPECT_EQ(absl::UnparseFlag(value), "0");
-  value = 123456789L;
-  EXPECT_EQ(absl::UnparseFlag(value), "123456789");
-  value = 0xFFFFFFFFFFFFFFFF;
-  EXPECT_EQ(absl::UnparseFlag(value), "18446744073709551615");
-}
-
-// --------------------------------------------------------------------
-
-TEST(MarshallingTest, TestInt128Unparsing) {
-  absl::int128 value;
-
-  value = 1;
-  EXPECT_EQ(absl::UnparseFlag(value), "1");
-  value = 0;
-  EXPECT_EQ(absl::UnparseFlag(value), "0");
-  value = -1;
-  EXPECT_EQ(absl::UnparseFlag(value), "-1");
-  value = 123456789L;
-  EXPECT_EQ(absl::UnparseFlag(value), "123456789");
-  value = -987654321L;
-  EXPECT_EQ(absl::UnparseFlag(value), "-987654321");
-  value = 0x7FFFFFFFFFFFFFFF;
-  EXPECT_EQ(absl::UnparseFlag(value), "9223372036854775807");
-}
-
-// --------------------------------------------------------------------
-
-TEST(MarshallingTest, TestUint128Unparsing) {
-  absl::uint128 value;
-
-  value = 1;
-  EXPECT_EQ(absl::UnparseFlag(value), "1");
-  value = 0;
-  EXPECT_EQ(absl::UnparseFlag(value), "0");
-  value = 123456789L;
-  EXPECT_EQ(absl::UnparseFlag(value), "123456789");
-  value = absl::MakeUint128(0, 0xFFFFFFFFFFFFFFFF);
-  EXPECT_EQ(absl::UnparseFlag(value), "18446744073709551615");
-}
-
-// --------------------------------------------------------------------
-
-TEST(MarshallingTest, TestFloatUnparsing) {
-  float value;
-
-  value = 1.1f;
-  EXPECT_EQ(absl::UnparseFlag(value), "1.1");
-  value = 0.01f;
-  EXPECT_EQ(absl::UnparseFlag(value), "0.01");
-  value = 1.23e-2f;
-  EXPECT_EQ(absl::UnparseFlag(value), "0.0123");
-  value = -0.71f;
-  EXPECT_EQ(absl::UnparseFlag(value), "-0.71");
-}
-
-// --------------------------------------------------------------------
-
-TEST(MarshallingTest, TestDoubleUnparsing) {
-  double value;
-
-  value = 1.1;
-  EXPECT_EQ(absl::UnparseFlag(value), "1.1");
-  value = 0.01;
-  EXPECT_EQ(absl::UnparseFlag(value), "0.01");
-  value = 1.23e-2;
-  EXPECT_EQ(absl::UnparseFlag(value), "0.0123");
-  value = -0.71;
-  EXPECT_EQ(absl::UnparseFlag(value), "-0.71");
-  value = -0;
-  EXPECT_EQ(absl::UnparseFlag(value), "0");
-  value = std::nan("");
-  EXPECT_EQ(absl::UnparseFlag(value), "nan");
-  value = std::numeric_limits<double>::infinity();
-  EXPECT_EQ(absl::UnparseFlag(value), "inf");
-}
-
-// --------------------------------------------------------------------
-
-TEST(MarshallingTest, TestStringUnparsing) {
-  EXPECT_EQ(absl::UnparseFlag(""), "");
-  EXPECT_EQ(absl::UnparseFlag(" "), " ");
-  EXPECT_EQ(absl::UnparseFlag("qwerty"), "qwerty");
-  EXPECT_EQ(absl::UnparseFlag("ASDFGH"), "ASDFGH");
-  EXPECT_EQ(absl::UnparseFlag("\n\t  "), "\n\t  ");
-}
-
-// --------------------------------------------------------------------
-
-TEST(MarshallingTest, TestOptionalBoolUnparsing) {
-  absl::optional<bool> value;
-
-  EXPECT_EQ(absl::UnparseFlag(value), "");
-  value = true;
-  EXPECT_EQ(absl::UnparseFlag(value), "true");
-  value = false;
-  EXPECT_EQ(absl::UnparseFlag(value), "false");
-  value = absl::nullopt;
-  EXPECT_EQ(absl::UnparseFlag(value), "");
-}
-
-// --------------------------------------------------------------------
-
-TEST(MarshallingTest, TestOptionalIntUnparsing) {
-  absl::optional<int> value;
-
-  EXPECT_EQ(absl::UnparseFlag(value), "");
-  value = 0;
-  EXPECT_EQ(absl::UnparseFlag(value), "0");
-  value = -12;
-  EXPECT_EQ(absl::UnparseFlag(value), "-12");
-  value = absl::nullopt;
-  EXPECT_EQ(absl::UnparseFlag(value), "");
-}
-
-// --------------------------------------------------------------------
-
-TEST(MarshallingTest, TestOptionalDoubleUnparsing) {
-  absl::optional<double> value;
-
-  EXPECT_EQ(absl::UnparseFlag(value), "");
-  value = 1.;
-  EXPECT_EQ(absl::UnparseFlag(value), "1");
-  value = -1.23;
-  EXPECT_EQ(absl::UnparseFlag(value), "-1.23");
-  value = absl::nullopt;
-  EXPECT_EQ(absl::UnparseFlag(value), "");
-}
-
-// --------------------------------------------------------------------
-
-TEST(MarshallingTest, TestOptionalStringUnparsing) {
-  absl::optional<std::string> strvalue;
-  EXPECT_EQ(absl::UnparseFlag(strvalue), "");
-
-  strvalue = "asdfg";
-  EXPECT_EQ(absl::UnparseFlag(strvalue), "asdfg");
-
-  strvalue = " ";
-  EXPECT_EQ(absl::UnparseFlag(strvalue), " ");
-
-  strvalue = "";  // It is UB to set an optional string flag to ""
-  EXPECT_EQ(absl::UnparseFlag(strvalue), "");
-}
-
-// --------------------------------------------------------------------
-
-#if defined(ABSL_HAVE_STD_OPTIONAL) && !defined(ABSL_USES_STD_OPTIONAL)
-
-TEST(MarshallingTest, TestStdOptionalUnparsing) {
-  std::optional<std::string> strvalue;
-  EXPECT_EQ(absl::UnparseFlag(strvalue), "");
-
-  strvalue = "asdfg";
-  EXPECT_EQ(absl::UnparseFlag(strvalue), "asdfg");
-
-  strvalue = " ";
-  EXPECT_EQ(absl::UnparseFlag(strvalue), " ");
-
-  strvalue = "";  // It is UB to set an optional string flag to ""
-  EXPECT_EQ(absl::UnparseFlag(strvalue), "");
-
-  std::optional<int> intvalue;
-  EXPECT_EQ(absl::UnparseFlag(intvalue), "");
-
-  intvalue = 10;
-  EXPECT_EQ(absl::UnparseFlag(intvalue), "10");
-}
-
-// --------------------------------------------------------------------
-
-#endif
-
-template <typename T>
-void TestRoundtrip(T v) {
-  T new_v;
-  std::string err;
-  EXPECT_TRUE(absl::ParseFlag(absl::UnparseFlag(v), &new_v, &err));
-  EXPECT_EQ(new_v, v);
-}
-
-TEST(MarshallingTest, TestFloatRoundTrip) {
-  TestRoundtrip(0.1f);
-  TestRoundtrip(0.12f);
-  TestRoundtrip(0.123f);
-  TestRoundtrip(0.1234f);
-  TestRoundtrip(0.12345f);
-  TestRoundtrip(0.123456f);
-  TestRoundtrip(0.1234567f);
-  TestRoundtrip(0.12345678f);
-
-  TestRoundtrip(0.1e20f);
-  TestRoundtrip(0.12e20f);
-  TestRoundtrip(0.123e20f);
-  TestRoundtrip(0.1234e20f);
-  TestRoundtrip(0.12345e20f);
-  TestRoundtrip(0.123456e20f);
-  TestRoundtrip(0.1234567e20f);
-  TestRoundtrip(0.12345678e20f);
-
-  TestRoundtrip(0.1e-20f);
-  TestRoundtrip(0.12e-20f);
-  TestRoundtrip(0.123e-20f);
-  TestRoundtrip(0.1234e-20f);
-  TestRoundtrip(0.12345e-20f);
-  TestRoundtrip(0.123456e-20f);
-  TestRoundtrip(0.1234567e-20f);
-  TestRoundtrip(0.12345678e-20f);
-}
-
-TEST(MarshallingTest, TestDoubleRoundTrip) {
-  TestRoundtrip(0.1);
-  TestRoundtrip(0.12);
-  TestRoundtrip(0.123);
-  TestRoundtrip(0.1234);
-  TestRoundtrip(0.12345);
-  TestRoundtrip(0.123456);
-  TestRoundtrip(0.1234567);
-  TestRoundtrip(0.12345678);
-  TestRoundtrip(0.123456789);
-  TestRoundtrip(0.1234567891);
-  TestRoundtrip(0.12345678912);
-  TestRoundtrip(0.123456789123);
-  TestRoundtrip(0.1234567891234);
-  TestRoundtrip(0.12345678912345);
-  TestRoundtrip(0.123456789123456);
-  TestRoundtrip(0.1234567891234567);
-  TestRoundtrip(0.12345678912345678);
-
-  TestRoundtrip(0.1e50);
-  TestRoundtrip(0.12e50);
-  TestRoundtrip(0.123e50);
-  TestRoundtrip(0.1234e50);
-  TestRoundtrip(0.12345e50);
-  TestRoundtrip(0.123456e50);
-  TestRoundtrip(0.1234567e50);
-  TestRoundtrip(0.12345678e50);
-  TestRoundtrip(0.123456789e50);
-  TestRoundtrip(0.1234567891e50);
-  TestRoundtrip(0.12345678912e50);
-  TestRoundtrip(0.123456789123e50);
-  TestRoundtrip(0.1234567891234e50);
-  TestRoundtrip(0.12345678912345e50);
-  TestRoundtrip(0.123456789123456e50);
-  TestRoundtrip(0.1234567891234567e50);
-  TestRoundtrip(0.12345678912345678e50);
-
-  TestRoundtrip(0.1e-50);
-  TestRoundtrip(0.12e-50);
-  TestRoundtrip(0.123e-50);
-  TestRoundtrip(0.1234e-50);
-  TestRoundtrip(0.12345e-50);
-  TestRoundtrip(0.123456e-50);
-  TestRoundtrip(0.1234567e-50);
-  TestRoundtrip(0.12345678e-50);
-  TestRoundtrip(0.123456789e-50);
-  TestRoundtrip(0.1234567891e-50);
-  TestRoundtrip(0.12345678912e-50);
-  TestRoundtrip(0.123456789123e-50);
-  TestRoundtrip(0.1234567891234e-50);
-  TestRoundtrip(0.12345678912345e-50);
-  TestRoundtrip(0.123456789123456e-50);
-  TestRoundtrip(0.1234567891234567e-50);
-  TestRoundtrip(0.12345678912345678e-50);
-}
-
-}  // namespace