marshalling_test.cc (39845B)
1 // 2 // Copyright 2019 The Abseil Authors. 3 // 4 // Licensed under the Apache License, Version 2.0 (the "License"); 5 // you may not use this file except in compliance with the License. 6 // You may obtain a copy of the License at 7 // 8 // https://www.apache.org/licenses/LICENSE-2.0 9 // 10 // Unless required by applicable law or agreed to in writing, software 11 // distributed under the License is distributed on an "AS IS" BASIS, 12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 // See the License for the specific language governing permissions and 14 // limitations under the License. 15 16 #include "absl/flags/marshalling.h" 17 18 #include <stdint.h> 19 20 #include <cmath> 21 #include <limits> 22 #include <string> 23 #include <vector> 24 25 #include "gtest/gtest.h" 26 27 namespace { 28 29 TEST(MarshallingTest, TestBoolParsing) { 30 std::string err; 31 bool value; 32 33 // True values. 34 EXPECT_TRUE(absl::ParseFlag("True", &value, &err)); 35 EXPECT_TRUE(value); 36 EXPECT_TRUE(absl::ParseFlag("true", &value, &err)); 37 EXPECT_TRUE(value); 38 EXPECT_TRUE(absl::ParseFlag("TRUE", &value, &err)); 39 EXPECT_TRUE(value); 40 41 EXPECT_TRUE(absl::ParseFlag("Yes", &value, &err)); 42 EXPECT_TRUE(value); 43 EXPECT_TRUE(absl::ParseFlag("yes", &value, &err)); 44 EXPECT_TRUE(value); 45 EXPECT_TRUE(absl::ParseFlag("YES", &value, &err)); 46 EXPECT_TRUE(value); 47 48 EXPECT_TRUE(absl::ParseFlag("t", &value, &err)); 49 EXPECT_TRUE(value); 50 EXPECT_TRUE(absl::ParseFlag("T", &value, &err)); 51 EXPECT_TRUE(value); 52 53 EXPECT_TRUE(absl::ParseFlag("y", &value, &err)); 54 EXPECT_TRUE(value); 55 EXPECT_TRUE(absl::ParseFlag("Y", &value, &err)); 56 EXPECT_TRUE(value); 57 58 EXPECT_TRUE(absl::ParseFlag("1", &value, &err)); 59 EXPECT_TRUE(value); 60 61 // False values. 62 EXPECT_TRUE(absl::ParseFlag("False", &value, &err)); 63 EXPECT_FALSE(value); 64 EXPECT_TRUE(absl::ParseFlag("false", &value, &err)); 65 EXPECT_FALSE(value); 66 EXPECT_TRUE(absl::ParseFlag("FALSE", &value, &err)); 67 EXPECT_FALSE(value); 68 69 EXPECT_TRUE(absl::ParseFlag("No", &value, &err)); 70 EXPECT_FALSE(value); 71 EXPECT_TRUE(absl::ParseFlag("no", &value, &err)); 72 EXPECT_FALSE(value); 73 EXPECT_TRUE(absl::ParseFlag("NO", &value, &err)); 74 EXPECT_FALSE(value); 75 76 EXPECT_TRUE(absl::ParseFlag("f", &value, &err)); 77 EXPECT_FALSE(value); 78 EXPECT_TRUE(absl::ParseFlag("F", &value, &err)); 79 EXPECT_FALSE(value); 80 81 EXPECT_TRUE(absl::ParseFlag("n", &value, &err)); 82 EXPECT_FALSE(value); 83 EXPECT_TRUE(absl::ParseFlag("N", &value, &err)); 84 EXPECT_FALSE(value); 85 86 EXPECT_TRUE(absl::ParseFlag("0", &value, &err)); 87 EXPECT_FALSE(value); 88 89 // Whitespace handling. 90 EXPECT_TRUE(absl::ParseFlag(" true", &value, &err)); 91 EXPECT_TRUE(value); 92 EXPECT_TRUE(absl::ParseFlag("true ", &value, &err)); 93 EXPECT_TRUE(value); 94 EXPECT_TRUE(absl::ParseFlag(" true ", &value, &err)); 95 EXPECT_TRUE(value); 96 97 // Invalid input. 98 EXPECT_FALSE(absl::ParseFlag("", &value, &err)); 99 EXPECT_FALSE(absl::ParseFlag(" ", &value, &err)); 100 EXPECT_FALSE(absl::ParseFlag("\n", &value, &err)); 101 EXPECT_FALSE(absl::ParseFlag("\t", &value, &err)); 102 EXPECT_FALSE(absl::ParseFlag("2", &value, &err)); 103 EXPECT_FALSE(absl::ParseFlag("11", &value, &err)); 104 EXPECT_FALSE(absl::ParseFlag("tt", &value, &err)); 105 } 106 107 // -------------------------------------------------------------------- 108 109 TEST(MarshallingTest, TestInt16Parsing) { 110 std::string err; 111 int16_t value; 112 113 // Decimal values. 114 EXPECT_TRUE(absl::ParseFlag("1", &value, &err)); 115 EXPECT_EQ(value, 1); 116 EXPECT_TRUE(absl::ParseFlag("0", &value, &err)); 117 EXPECT_EQ(value, 0); 118 EXPECT_TRUE(absl::ParseFlag("-1", &value, &err)); 119 EXPECT_EQ(value, -1); 120 EXPECT_TRUE(absl::ParseFlag("123", &value, &err)); 121 EXPECT_EQ(value, 123); 122 EXPECT_TRUE(absl::ParseFlag("-18765", &value, &err)); 123 EXPECT_EQ(value, -18765); 124 EXPECT_TRUE(absl::ParseFlag("+3", &value, &err)); 125 EXPECT_EQ(value, 3); 126 127 // Leading zero values. 128 EXPECT_TRUE(absl::ParseFlag("01", &value, &err)); 129 EXPECT_EQ(value, 1); 130 EXPECT_TRUE(absl::ParseFlag("-001", &value, &err)); 131 EXPECT_EQ(value, -1); 132 EXPECT_TRUE(absl::ParseFlag("0000100", &value, &err)); 133 EXPECT_EQ(value, 100); 134 135 // Hex values. 136 EXPECT_TRUE(absl::ParseFlag("0x10", &value, &err)); 137 EXPECT_EQ(value, 16); 138 EXPECT_TRUE(absl::ParseFlag("0X234", &value, &err)); 139 EXPECT_EQ(value, 564); 140 EXPECT_TRUE(absl::ParseFlag("-0x7FFD", &value, &err)); 141 EXPECT_EQ(value, -32765); 142 EXPECT_TRUE(absl::ParseFlag("+0x31", &value, &err)); 143 EXPECT_EQ(value, 49); 144 145 // Whitespace handling 146 EXPECT_TRUE(absl::ParseFlag("10 ", &value, &err)); 147 EXPECT_EQ(value, 10); 148 EXPECT_TRUE(absl::ParseFlag(" 11", &value, &err)); 149 EXPECT_EQ(value, 11); 150 EXPECT_TRUE(absl::ParseFlag(" 012 ", &value, &err)); 151 EXPECT_EQ(value, 12); 152 EXPECT_TRUE(absl::ParseFlag(" 0x22 ", &value, &err)); 153 EXPECT_EQ(value, 34); 154 155 // Invalid values. 156 EXPECT_FALSE(absl::ParseFlag("", &value, &err)); 157 EXPECT_FALSE(absl::ParseFlag(" ", &value, &err)); 158 EXPECT_FALSE(absl::ParseFlag(" ", &value, &err)); 159 EXPECT_FALSE(absl::ParseFlag("40000", &value, &err)); 160 EXPECT_FALSE(absl::ParseFlag("--1", &value, &err)); 161 EXPECT_FALSE(absl::ParseFlag("\n", &value, &err)); 162 EXPECT_FALSE(absl::ParseFlag("\t", &value, &err)); 163 EXPECT_FALSE(absl::ParseFlag("2U", &value, &err)); 164 EXPECT_FALSE(absl::ParseFlag("FFF", &value, &err)); 165 } 166 167 // -------------------------------------------------------------------- 168 169 TEST(MarshallingTest, TestUint16Parsing) { 170 std::string err; 171 uint16_t value; 172 173 // Decimal values. 174 EXPECT_TRUE(absl::ParseFlag("1", &value, &err)); 175 EXPECT_EQ(value, 1); 176 EXPECT_TRUE(absl::ParseFlag("0", &value, &err)); 177 EXPECT_EQ(value, 0); 178 EXPECT_TRUE(absl::ParseFlag("123", &value, &err)); 179 EXPECT_EQ(value, 123); 180 EXPECT_TRUE(absl::ParseFlag("+3", &value, &err)); 181 EXPECT_EQ(value, 3); 182 183 // Leading zero values. 184 EXPECT_TRUE(absl::ParseFlag("01", &value, &err)); 185 EXPECT_EQ(value, 1); 186 EXPECT_TRUE(absl::ParseFlag("001", &value, &err)); 187 EXPECT_EQ(value, 1); 188 EXPECT_TRUE(absl::ParseFlag("0000100", &value, &err)); 189 EXPECT_EQ(value, 100); 190 191 // Hex values. 192 EXPECT_TRUE(absl::ParseFlag("0x10", &value, &err)); 193 EXPECT_EQ(value, 16); 194 EXPECT_TRUE(absl::ParseFlag("0X234", &value, &err)); 195 EXPECT_EQ(value, 564); 196 EXPECT_TRUE(absl::ParseFlag("+0x31", &value, &err)); 197 EXPECT_EQ(value, 49); 198 199 // Whitespace handling 200 EXPECT_TRUE(absl::ParseFlag("10 ", &value, &err)); 201 EXPECT_EQ(value, 10); 202 EXPECT_TRUE(absl::ParseFlag(" 11", &value, &err)); 203 EXPECT_EQ(value, 11); 204 EXPECT_TRUE(absl::ParseFlag(" 012 ", &value, &err)); 205 EXPECT_EQ(value, 12); 206 EXPECT_TRUE(absl::ParseFlag(" 0x22 ", &value, &err)); 207 EXPECT_EQ(value, 34); 208 209 // Invalid values. 210 EXPECT_FALSE(absl::ParseFlag("", &value, &err)); 211 EXPECT_FALSE(absl::ParseFlag(" ", &value, &err)); 212 EXPECT_FALSE(absl::ParseFlag(" ", &value, &err)); 213 EXPECT_FALSE(absl::ParseFlag("70000", &value, &err)); 214 EXPECT_FALSE(absl::ParseFlag("-1", &value, &err)); 215 EXPECT_FALSE(absl::ParseFlag("--1", &value, &err)); 216 EXPECT_FALSE(absl::ParseFlag("\n", &value, &err)); 217 EXPECT_FALSE(absl::ParseFlag("\t", &value, &err)); 218 EXPECT_FALSE(absl::ParseFlag("2U", &value, &err)); 219 EXPECT_FALSE(absl::ParseFlag("FFF", &value, &err)); 220 } 221 222 // -------------------------------------------------------------------- 223 224 TEST(MarshallingTest, TestInt32Parsing) { 225 std::string err; 226 int32_t value; 227 228 // Decimal values. 229 EXPECT_TRUE(absl::ParseFlag("1", &value, &err)); 230 EXPECT_EQ(value, 1); 231 EXPECT_TRUE(absl::ParseFlag("0", &value, &err)); 232 EXPECT_EQ(value, 0); 233 EXPECT_TRUE(absl::ParseFlag("-1", &value, &err)); 234 EXPECT_EQ(value, -1); 235 EXPECT_TRUE(absl::ParseFlag("123", &value, &err)); 236 EXPECT_EQ(value, 123); 237 EXPECT_TRUE(absl::ParseFlag("-98765", &value, &err)); 238 EXPECT_EQ(value, -98765); 239 EXPECT_TRUE(absl::ParseFlag("+3", &value, &err)); 240 EXPECT_EQ(value, 3); 241 242 // Leading zero values. 243 EXPECT_TRUE(absl::ParseFlag("01", &value, &err)); 244 EXPECT_EQ(value, 1); 245 EXPECT_TRUE(absl::ParseFlag("-001", &value, &err)); 246 EXPECT_EQ(value, -1); 247 EXPECT_TRUE(absl::ParseFlag("0000100", &value, &err)); 248 EXPECT_EQ(value, 100); 249 250 // Hex values. 251 EXPECT_TRUE(absl::ParseFlag("0x10", &value, &err)); 252 EXPECT_EQ(value, 16); 253 EXPECT_TRUE(absl::ParseFlag("0X234", &value, &err)); 254 EXPECT_EQ(value, 564); 255 256 EXPECT_TRUE(absl::ParseFlag("-0x7FFFFFFD", &value, &err)); 257 EXPECT_EQ(value, -2147483645); 258 EXPECT_TRUE(absl::ParseFlag("+0x31", &value, &err)); 259 EXPECT_EQ(value, 49); 260 261 // Whitespace handling 262 EXPECT_TRUE(absl::ParseFlag("10 ", &value, &err)); 263 EXPECT_EQ(value, 10); 264 EXPECT_TRUE(absl::ParseFlag(" 11", &value, &err)); 265 EXPECT_EQ(value, 11); 266 EXPECT_TRUE(absl::ParseFlag(" 012 ", &value, &err)); 267 EXPECT_EQ(value, 12); 268 EXPECT_TRUE(absl::ParseFlag(" 0x22 ", &value, &err)); 269 EXPECT_EQ(value, 34); 270 271 // Invalid values. 272 EXPECT_FALSE(absl::ParseFlag("", &value, &err)); 273 EXPECT_FALSE(absl::ParseFlag(" ", &value, &err)); 274 EXPECT_FALSE(absl::ParseFlag(" ", &value, &err)); 275 EXPECT_FALSE(absl::ParseFlag("70000000000", &value, &err)); 276 EXPECT_FALSE(absl::ParseFlag("--1", &value, &err)); 277 EXPECT_FALSE(absl::ParseFlag("\n", &value, &err)); 278 EXPECT_FALSE(absl::ParseFlag("\t", &value, &err)); 279 EXPECT_FALSE(absl::ParseFlag("2U", &value, &err)); 280 EXPECT_FALSE(absl::ParseFlag("FFF", &value, &err)); 281 } 282 283 // -------------------------------------------------------------------- 284 285 TEST(MarshallingTest, TestUint32Parsing) { 286 std::string err; 287 uint32_t value; 288 289 // Decimal values. 290 EXPECT_TRUE(absl::ParseFlag("1", &value, &err)); 291 EXPECT_EQ(value, 1); 292 EXPECT_TRUE(absl::ParseFlag("0", &value, &err)); 293 EXPECT_EQ(value, 0); 294 EXPECT_TRUE(absl::ParseFlag("123", &value, &err)); 295 EXPECT_EQ(value, 123); 296 EXPECT_TRUE(absl::ParseFlag("+3", &value, &err)); 297 EXPECT_EQ(value, 3); 298 299 // Leading zero values. 300 EXPECT_TRUE(absl::ParseFlag("01", &value, &err)); 301 EXPECT_EQ(value, 1); 302 EXPECT_TRUE(absl::ParseFlag("0000100", &value, &err)); 303 EXPECT_EQ(value, 100); 304 305 // Hex values. 306 EXPECT_TRUE(absl::ParseFlag("0x10", &value, &err)); 307 EXPECT_EQ(value, 16); 308 EXPECT_TRUE(absl::ParseFlag("0X234", &value, &err)); 309 EXPECT_EQ(value, 564); 310 EXPECT_TRUE(absl::ParseFlag("0xFFFFFFFD", &value, &err)); 311 EXPECT_EQ(value, 4294967293); 312 EXPECT_TRUE(absl::ParseFlag("+0x31", &value, &err)); 313 EXPECT_EQ(value, 49); 314 315 // Whitespace handling 316 EXPECT_TRUE(absl::ParseFlag("10 ", &value, &err)); 317 EXPECT_EQ(value, 10); 318 EXPECT_TRUE(absl::ParseFlag(" 11", &value, &err)); 319 EXPECT_EQ(value, 11); 320 EXPECT_TRUE(absl::ParseFlag(" 012 ", &value, &err)); 321 EXPECT_EQ(value, 12); 322 EXPECT_TRUE(absl::ParseFlag(" 0x22 ", &value, &err)); 323 EXPECT_EQ(value, 34); 324 325 // Invalid values. 326 EXPECT_FALSE(absl::ParseFlag("", &value, &err)); 327 EXPECT_FALSE(absl::ParseFlag(" ", &value, &err)); 328 EXPECT_FALSE(absl::ParseFlag(" ", &value, &err)); 329 EXPECT_FALSE(absl::ParseFlag("140000000000", &value, &err)); 330 EXPECT_FALSE(absl::ParseFlag("-1", &value, &err)); 331 EXPECT_FALSE(absl::ParseFlag("--1", &value, &err)); 332 EXPECT_FALSE(absl::ParseFlag("\n", &value, &err)); 333 EXPECT_FALSE(absl::ParseFlag("\t", &value, &err)); 334 EXPECT_FALSE(absl::ParseFlag("2U", &value, &err)); 335 EXPECT_FALSE(absl::ParseFlag("FFF", &value, &err)); 336 } 337 338 // -------------------------------------------------------------------- 339 340 TEST(MarshallingTest, TestInt64Parsing) { 341 std::string err; 342 int64_t value; 343 344 // Decimal values. 345 EXPECT_TRUE(absl::ParseFlag("1", &value, &err)); 346 EXPECT_EQ(value, 1); 347 EXPECT_TRUE(absl::ParseFlag("0", &value, &err)); 348 EXPECT_EQ(value, 0); 349 EXPECT_TRUE(absl::ParseFlag("-1", &value, &err)); 350 EXPECT_EQ(value, -1); 351 EXPECT_TRUE(absl::ParseFlag("123", &value, &err)); 352 EXPECT_EQ(value, 123); 353 EXPECT_TRUE(absl::ParseFlag("-98765", &value, &err)); 354 EXPECT_EQ(value, -98765); 355 EXPECT_TRUE(absl::ParseFlag("+3", &value, &err)); 356 EXPECT_EQ(value, 3); 357 358 // Leading zero values. 359 EXPECT_TRUE(absl::ParseFlag("01", &value, &err)); 360 EXPECT_EQ(value, 1); 361 EXPECT_TRUE(absl::ParseFlag("001", &value, &err)); 362 EXPECT_EQ(value, 1); 363 EXPECT_TRUE(absl::ParseFlag("0000100", &value, &err)); 364 EXPECT_EQ(value, 100); 365 366 // Hex values. 367 EXPECT_TRUE(absl::ParseFlag("0x10", &value, &err)); 368 EXPECT_EQ(value, 16); 369 EXPECT_TRUE(absl::ParseFlag("0XFFFAAABBBCCCDDD", &value, &err)); 370 EXPECT_EQ(value, 1152827684197027293); 371 EXPECT_TRUE(absl::ParseFlag("-0x7FFFFFFFFFFFFFFE", &value, &err)); 372 EXPECT_EQ(value, -9223372036854775806); 373 EXPECT_TRUE(absl::ParseFlag("-0x02", &value, &err)); 374 EXPECT_EQ(value, -2); 375 EXPECT_TRUE(absl::ParseFlag("+0x31", &value, &err)); 376 EXPECT_EQ(value, 49); 377 378 // Whitespace handling 379 EXPECT_TRUE(absl::ParseFlag("10 ", &value, &err)); 380 EXPECT_EQ(value, 10); 381 EXPECT_TRUE(absl::ParseFlag(" 11", &value, &err)); 382 EXPECT_EQ(value, 11); 383 EXPECT_TRUE(absl::ParseFlag(" 012 ", &value, &err)); 384 EXPECT_EQ(value, 12); 385 EXPECT_TRUE(absl::ParseFlag(" 0x7F ", &value, &err)); 386 EXPECT_EQ(value, 127); 387 388 // Invalid values. 389 EXPECT_FALSE(absl::ParseFlag("", &value, &err)); 390 EXPECT_FALSE(absl::ParseFlag(" ", &value, &err)); 391 EXPECT_FALSE(absl::ParseFlag(" ", &value, &err)); 392 EXPECT_FALSE(absl::ParseFlag("0xFFFFFFFFFFFFFFFFFF", &value, &err)); 393 EXPECT_FALSE(absl::ParseFlag("--1", &value, &err)); 394 EXPECT_FALSE(absl::ParseFlag("\n", &value, &err)); 395 EXPECT_FALSE(absl::ParseFlag("\t", &value, &err)); 396 EXPECT_FALSE(absl::ParseFlag("2U", &value, &err)); 397 EXPECT_FALSE(absl::ParseFlag("FFF", &value, &err)); 398 } 399 400 // -------------------------------------------------------------------- 401 402 TEST(MarshallingTest, TestUInt64Parsing) { 403 std::string err; 404 uint64_t value; 405 406 // Decimal values. 407 EXPECT_TRUE(absl::ParseFlag("1", &value, &err)); 408 EXPECT_EQ(value, 1); 409 EXPECT_TRUE(absl::ParseFlag("0", &value, &err)); 410 EXPECT_EQ(value, 0); 411 EXPECT_TRUE(absl::ParseFlag("123", &value, &err)); 412 EXPECT_EQ(value, 123); 413 EXPECT_TRUE(absl::ParseFlag("+13", &value, &err)); 414 EXPECT_EQ(value, 13); 415 416 // Leading zero values. 417 EXPECT_TRUE(absl::ParseFlag("01", &value, &err)); 418 EXPECT_EQ(value, 1); 419 EXPECT_TRUE(absl::ParseFlag("001", &value, &err)); 420 EXPECT_EQ(value, 1); 421 EXPECT_TRUE(absl::ParseFlag("0000300", &value, &err)); 422 EXPECT_EQ(value, 300); 423 424 // Hex values. 425 EXPECT_TRUE(absl::ParseFlag("0x10", &value, &err)); 426 EXPECT_EQ(value, 16); 427 EXPECT_TRUE(absl::ParseFlag("0XFFFF", &value, &err)); 428 EXPECT_EQ(value, 65535); 429 EXPECT_TRUE(absl::ParseFlag("+0x31", &value, &err)); 430 EXPECT_EQ(value, 49); 431 432 // Whitespace handling 433 EXPECT_TRUE(absl::ParseFlag("10 ", &value, &err)); 434 EXPECT_EQ(value, 10); 435 EXPECT_TRUE(absl::ParseFlag(" 11", &value, &err)); 436 EXPECT_EQ(value, 11); 437 EXPECT_TRUE(absl::ParseFlag(" 012 ", &value, &err)); 438 EXPECT_EQ(value, 12); 439 440 // Invalid values. 441 EXPECT_FALSE(absl::ParseFlag("", &value, &err)); 442 EXPECT_FALSE(absl::ParseFlag(" ", &value, &err)); 443 EXPECT_FALSE(absl::ParseFlag(" ", &value, &err)); 444 EXPECT_FALSE(absl::ParseFlag("0xFFFFFFFFFFFFFFFFFF", &value, &err)); 445 EXPECT_FALSE(absl::ParseFlag("-1", &value, &err)); 446 EXPECT_FALSE(absl::ParseFlag("--1", &value, &err)); 447 EXPECT_FALSE(absl::ParseFlag("\n", &value, &err)); 448 EXPECT_FALSE(absl::ParseFlag("\t", &value, &err)); 449 EXPECT_FALSE(absl::ParseFlag("2U", &value, &err)); 450 EXPECT_FALSE(absl::ParseFlag("FFF", &value, &err)); 451 } 452 453 // -------------------------------------------------------------------- 454 455 TEST(MarshallingTest, TestInt128Parsing) { 456 std::string err; 457 absl::int128 value; 458 459 // Decimal values. 460 EXPECT_TRUE(absl::ParseFlag("0", &value, &err)); 461 EXPECT_EQ(value, 0); 462 EXPECT_TRUE(absl::ParseFlag("1", &value, &err)); 463 EXPECT_EQ(value, 1); 464 EXPECT_TRUE(absl::ParseFlag("-1", &value, &err)); 465 EXPECT_EQ(value, -1); 466 EXPECT_TRUE(absl::ParseFlag("123", &value, &err)); 467 EXPECT_EQ(value, 123); 468 EXPECT_TRUE(absl::ParseFlag("-98765", &value, &err)); 469 EXPECT_EQ(value, -98765); 470 EXPECT_TRUE(absl::ParseFlag("+3", &value, &err)); 471 EXPECT_EQ(value, 3); 472 473 // Leading zero values. 474 EXPECT_TRUE(absl::ParseFlag("01", &value, &err)); 475 EXPECT_EQ(value, 1); 476 EXPECT_TRUE(absl::ParseFlag("001", &value, &err)); 477 EXPECT_EQ(value, 1); 478 EXPECT_TRUE(absl::ParseFlag("0000100", &value, &err)); 479 EXPECT_EQ(value, 100); 480 481 // Hex values. 482 EXPECT_TRUE(absl::ParseFlag("0x10", &value, &err)); 483 EXPECT_EQ(value, 16); 484 EXPECT_TRUE(absl::ParseFlag("0xFFFAAABBBCCCDDD", &value, &err)); 485 EXPECT_EQ(value, 1152827684197027293); 486 EXPECT_TRUE(absl::ParseFlag("0xFFF0FFFFFFFFFFFFFFF", &value, &err)); 487 EXPECT_EQ(value, absl::MakeInt128(0x000000000000fff, 0xFFFFFFFFFFFFFFF)); 488 489 EXPECT_TRUE(absl::ParseFlag("-0x10000000000000000", &value, &err)); 490 EXPECT_EQ(value, absl::MakeInt128(-1, 0)); 491 EXPECT_TRUE(absl::ParseFlag("+0x31", &value, &err)); 492 EXPECT_EQ(value, 49); 493 494 // Whitespace handling 495 EXPECT_TRUE(absl::ParseFlag("16 ", &value, &err)); 496 EXPECT_EQ(value, 16); 497 EXPECT_TRUE(absl::ParseFlag(" 16", &value, &err)); 498 EXPECT_EQ(value, 16); 499 EXPECT_TRUE(absl::ParseFlag(" 0100 ", &value, &err)); 500 EXPECT_EQ(value, 100); 501 EXPECT_TRUE(absl::ParseFlag(" 0x7B ", &value, &err)); 502 EXPECT_EQ(value, 123); 503 504 // Invalid values. 505 EXPECT_FALSE(absl::ParseFlag("", &value, &err)); 506 EXPECT_FALSE(absl::ParseFlag(" ", &value, &err)); 507 EXPECT_FALSE(absl::ParseFlag(" ", &value, &err)); 508 EXPECT_FALSE(absl::ParseFlag("--1", &value, &err)); 509 EXPECT_FALSE(absl::ParseFlag("\n", &value, &err)); 510 EXPECT_FALSE(absl::ParseFlag("\t", &value, &err)); 511 EXPECT_FALSE(absl::ParseFlag("2U", &value, &err)); 512 EXPECT_FALSE(absl::ParseFlag("FFF", &value, &err)); 513 } 514 515 // -------------------------------------------------------------------- 516 517 TEST(MarshallingTest, TestUint128Parsing) { 518 std::string err; 519 absl::uint128 value; 520 521 // Decimal values. 522 EXPECT_TRUE(absl::ParseFlag("0", &value, &err)); 523 EXPECT_EQ(value, 0); 524 EXPECT_TRUE(absl::ParseFlag("1", &value, &err)); 525 EXPECT_EQ(value, 1); 526 EXPECT_TRUE(absl::ParseFlag("123", &value, &err)); 527 EXPECT_EQ(value, 123); 528 EXPECT_TRUE(absl::ParseFlag("+3", &value, &err)); 529 EXPECT_EQ(value, 3); 530 531 // Leading zero values. 532 EXPECT_TRUE(absl::ParseFlag("01", &value, &err)); 533 EXPECT_EQ(value, 1); 534 EXPECT_TRUE(absl::ParseFlag("001", &value, &err)); 535 EXPECT_EQ(value, 1); 536 EXPECT_TRUE(absl::ParseFlag("0000100", &value, &err)); 537 EXPECT_EQ(value, 100); 538 539 // Hex values. 540 EXPECT_TRUE(absl::ParseFlag("0x10", &value, &err)); 541 EXPECT_EQ(value, 16); 542 EXPECT_TRUE(absl::ParseFlag("0xFFFAAABBBCCCDDD", &value, &err)); 543 EXPECT_EQ(value, 1152827684197027293); 544 EXPECT_TRUE(absl::ParseFlag("0xFFF0FFFFFFFFFFFFFFF", &value, &err)); 545 EXPECT_EQ(value, absl::MakeInt128(0x000000000000fff, 0xFFFFFFFFFFFFFFF)); 546 EXPECT_TRUE(absl::ParseFlag("+0x31", &value, &err)); 547 EXPECT_EQ(value, 49); 548 549 // Whitespace handling 550 EXPECT_TRUE(absl::ParseFlag("16 ", &value, &err)); 551 EXPECT_EQ(value, 16); 552 EXPECT_TRUE(absl::ParseFlag(" 16", &value, &err)); 553 EXPECT_EQ(value, 16); 554 EXPECT_TRUE(absl::ParseFlag(" 0100 ", &value, &err)); 555 EXPECT_EQ(value, 100); 556 EXPECT_TRUE(absl::ParseFlag(" 0x7B ", &value, &err)); 557 EXPECT_EQ(value, 123); 558 559 // Invalid values. 560 EXPECT_FALSE(absl::ParseFlag("", &value, &err)); 561 EXPECT_FALSE(absl::ParseFlag(" ", &value, &err)); 562 EXPECT_FALSE(absl::ParseFlag(" ", &value, &err)); 563 EXPECT_FALSE(absl::ParseFlag("-1", &value, &err)); 564 EXPECT_FALSE(absl::ParseFlag("--1", &value, &err)); 565 EXPECT_FALSE(absl::ParseFlag("\n", &value, &err)); 566 EXPECT_FALSE(absl::ParseFlag("\t", &value, &err)); 567 EXPECT_FALSE(absl::ParseFlag("2U", &value, &err)); 568 EXPECT_FALSE(absl::ParseFlag("FFF", &value, &err)); 569 EXPECT_FALSE(absl::ParseFlag("-0x10000000000000000", &value, &err)); 570 } 571 572 // -------------------------------------------------------------------- 573 574 TEST(MarshallingTest, TestFloatParsing) { 575 std::string err; 576 float value; 577 578 // Ordinary values. 579 EXPECT_TRUE(absl::ParseFlag("1.3", &value, &err)); 580 EXPECT_FLOAT_EQ(value, 1.3f); 581 EXPECT_TRUE(absl::ParseFlag("-0.1", &value, &err)); 582 EXPECT_DOUBLE_EQ(value, -0.1f); 583 EXPECT_TRUE(absl::ParseFlag("+0.01", &value, &err)); 584 EXPECT_DOUBLE_EQ(value, 0.01f); 585 586 // Scientific values. 587 EXPECT_TRUE(absl::ParseFlag("1.2e3", &value, &err)); 588 EXPECT_DOUBLE_EQ(value, 1.2e3f); 589 EXPECT_TRUE(absl::ParseFlag("9.8765402e-37", &value, &err)); 590 EXPECT_DOUBLE_EQ(value, 9.8765402e-37f); 591 EXPECT_TRUE(absl::ParseFlag("0.11e+3", &value, &err)); 592 EXPECT_DOUBLE_EQ(value, 0.11e+3f); 593 EXPECT_TRUE(absl::ParseFlag("1.e-2300", &value, &err)); 594 EXPECT_DOUBLE_EQ(value, 0.f); 595 EXPECT_TRUE(absl::ParseFlag("1.e+2300", &value, &err)); 596 EXPECT_TRUE(std::isinf(value)); 597 598 // Leading zero values. 599 EXPECT_TRUE(absl::ParseFlag("01.6", &value, &err)); 600 EXPECT_DOUBLE_EQ(value, 1.6f); 601 EXPECT_TRUE(absl::ParseFlag("000.0001", &value, &err)); 602 EXPECT_DOUBLE_EQ(value, 0.0001f); 603 604 // Trailing zero values. 605 EXPECT_TRUE(absl::ParseFlag("-5.1000", &value, &err)); 606 EXPECT_DOUBLE_EQ(value, -5.1f); 607 608 // Exceptional values. 609 EXPECT_TRUE(absl::ParseFlag("NaN", &value, &err)); 610 EXPECT_TRUE(std::isnan(value)); 611 EXPECT_TRUE(absl::ParseFlag("Inf", &value, &err)); 612 EXPECT_TRUE(std::isinf(value)); 613 614 // Hex values 615 EXPECT_TRUE(absl::ParseFlag("0x10.23p12", &value, &err)); 616 EXPECT_DOUBLE_EQ(value, 66096.f); 617 EXPECT_TRUE(absl::ParseFlag("-0xF1.A3p-2", &value, &err)); 618 EXPECT_NEAR(value, -60.4092f, 5e-5f); 619 EXPECT_TRUE(absl::ParseFlag("+0x0.0AAp-12", &value, &err)); 620 EXPECT_NEAR(value, 1.01328e-05f, 5e-11f); 621 EXPECT_TRUE(absl::ParseFlag("0x.01p1", &value, &err)); 622 EXPECT_NEAR(value, 0.0078125f, 5e-8f); 623 624 // Whitespace handling 625 EXPECT_TRUE(absl::ParseFlag("10.1 ", &value, &err)); 626 EXPECT_DOUBLE_EQ(value, 10.1f); 627 EXPECT_TRUE(absl::ParseFlag(" 2.34", &value, &err)); 628 EXPECT_DOUBLE_EQ(value, 2.34f); 629 EXPECT_TRUE(absl::ParseFlag(" 5.7 ", &value, &err)); 630 EXPECT_DOUBLE_EQ(value, 5.7f); 631 EXPECT_TRUE(absl::ParseFlag(" -0xE0.F3p01 ", &value, &err)); 632 EXPECT_NEAR(value, -449.8984375f, 5e-8f); 633 634 // Invalid values. 635 EXPECT_FALSE(absl::ParseFlag("", &value, &err)); 636 EXPECT_FALSE(absl::ParseFlag(" ", &value, &err)); 637 EXPECT_FALSE(absl::ParseFlag(" ", &value, &err)); 638 EXPECT_FALSE(absl::ParseFlag("--1", &value, &err)); 639 EXPECT_FALSE(absl::ParseFlag("\n", &value, &err)); 640 EXPECT_FALSE(absl::ParseFlag("\t", &value, &err)); 641 EXPECT_FALSE(absl::ParseFlag("2.3xxx", &value, &err)); 642 EXPECT_FALSE(absl::ParseFlag("0x0.1pAA", &value, &err)); 643 // TODO(rogeeff): below assertion should fail 644 EXPECT_TRUE(absl::ParseFlag("0x0.1", &value, &err)); 645 } 646 647 // -------------------------------------------------------------------- 648 649 TEST(MarshallingTest, TestDoubleParsing) { 650 std::string err; 651 double value; 652 653 // Ordinary values. 654 EXPECT_TRUE(absl::ParseFlag("1.3", &value, &err)); 655 EXPECT_DOUBLE_EQ(value, 1.3); 656 EXPECT_TRUE(absl::ParseFlag("-0.1", &value, &err)); 657 EXPECT_DOUBLE_EQ(value, -0.1); 658 EXPECT_TRUE(absl::ParseFlag("+0.01", &value, &err)); 659 EXPECT_DOUBLE_EQ(value, 0.01); 660 661 // Scientific values. 662 EXPECT_TRUE(absl::ParseFlag("1.2e3", &value, &err)); 663 EXPECT_DOUBLE_EQ(value, 1.2e3); 664 EXPECT_TRUE(absl::ParseFlag("9.00000002e-123", &value, &err)); 665 EXPECT_DOUBLE_EQ(value, 9.00000002e-123); 666 EXPECT_TRUE(absl::ParseFlag("0.11e+3", &value, &err)); 667 EXPECT_DOUBLE_EQ(value, 0.11e+3); 668 EXPECT_TRUE(absl::ParseFlag("1.e-2300", &value, &err)); 669 EXPECT_DOUBLE_EQ(value, 0); 670 EXPECT_TRUE(absl::ParseFlag("1.e+2300", &value, &err)); 671 EXPECT_TRUE(std::isinf(value)); 672 673 // Leading zero values. 674 EXPECT_TRUE(absl::ParseFlag("01.6", &value, &err)); 675 EXPECT_DOUBLE_EQ(value, 1.6); 676 EXPECT_TRUE(absl::ParseFlag("000.0001", &value, &err)); 677 EXPECT_DOUBLE_EQ(value, 0.0001); 678 679 // Trailing zero values. 680 EXPECT_TRUE(absl::ParseFlag("-5.1000", &value, &err)); 681 EXPECT_DOUBLE_EQ(value, -5.1); 682 683 // Exceptional values. 684 EXPECT_TRUE(absl::ParseFlag("NaN", &value, &err)); 685 EXPECT_TRUE(std::isnan(value)); 686 EXPECT_TRUE(absl::ParseFlag("nan", &value, &err)); 687 EXPECT_TRUE(std::isnan(value)); 688 EXPECT_TRUE(absl::ParseFlag("Inf", &value, &err)); 689 EXPECT_TRUE(std::isinf(value)); 690 EXPECT_TRUE(absl::ParseFlag("inf", &value, &err)); 691 EXPECT_TRUE(std::isinf(value)); 692 693 // Hex values 694 EXPECT_TRUE(absl::ParseFlag("0x10.23p12", &value, &err)); 695 EXPECT_DOUBLE_EQ(value, 66096); 696 EXPECT_TRUE(absl::ParseFlag("-0xF1.A3p-2", &value, &err)); 697 EXPECT_NEAR(value, -60.4092, 5e-5); 698 EXPECT_TRUE(absl::ParseFlag("+0x0.0AAp-12", &value, &err)); 699 EXPECT_NEAR(value, 1.01328e-05, 5e-11); 700 EXPECT_TRUE(absl::ParseFlag("0x.01p1", &value, &err)); 701 EXPECT_NEAR(value, 0.0078125, 5e-8); 702 703 // Whitespace handling 704 EXPECT_TRUE(absl::ParseFlag("10.1 ", &value, &err)); 705 EXPECT_DOUBLE_EQ(value, 10.1); 706 EXPECT_TRUE(absl::ParseFlag(" 2.34", &value, &err)); 707 EXPECT_DOUBLE_EQ(value, 2.34); 708 EXPECT_TRUE(absl::ParseFlag(" 5.7 ", &value, &err)); 709 EXPECT_DOUBLE_EQ(value, 5.7); 710 EXPECT_TRUE(absl::ParseFlag(" -0xE0.F3p01 ", &value, &err)); 711 EXPECT_NEAR(value, -449.8984375, 5e-8); 712 713 // Invalid values. 714 EXPECT_FALSE(absl::ParseFlag("", &value, &err)); 715 EXPECT_FALSE(absl::ParseFlag(" ", &value, &err)); 716 EXPECT_FALSE(absl::ParseFlag(" ", &value, &err)); 717 EXPECT_FALSE(absl::ParseFlag("--1", &value, &err)); 718 EXPECT_FALSE(absl::ParseFlag("\n", &value, &err)); 719 EXPECT_FALSE(absl::ParseFlag("\t", &value, &err)); 720 EXPECT_FALSE(absl::ParseFlag("2.3xxx", &value, &err)); 721 EXPECT_FALSE(absl::ParseFlag("0x0.1pAA", &value, &err)); 722 // TODO(rogeeff): below assertion should fail 723 EXPECT_TRUE(absl::ParseFlag("0x0.1", &value, &err)); 724 } 725 726 // -------------------------------------------------------------------- 727 728 TEST(MarshallingTest, TestStringParsing) { 729 std::string err; 730 std::string value; 731 732 EXPECT_TRUE(absl::ParseFlag("", &value, &err)); 733 EXPECT_EQ(value, ""); 734 EXPECT_TRUE(absl::ParseFlag(" ", &value, &err)); 735 EXPECT_EQ(value, " "); 736 EXPECT_TRUE(absl::ParseFlag(" ", &value, &err)); 737 EXPECT_EQ(value, " "); 738 EXPECT_TRUE(absl::ParseFlag("\n", &value, &err)); 739 EXPECT_EQ(value, "\n"); 740 EXPECT_TRUE(absl::ParseFlag("\t", &value, &err)); 741 EXPECT_EQ(value, "\t"); 742 EXPECT_TRUE(absl::ParseFlag("asdfg", &value, &err)); 743 EXPECT_EQ(value, "asdfg"); 744 EXPECT_TRUE(absl::ParseFlag("asdf ghjk", &value, &err)); 745 EXPECT_EQ(value, "asdf ghjk"); 746 EXPECT_TRUE(absl::ParseFlag("a\nb\nc", &value, &err)); 747 EXPECT_EQ(value, "a\nb\nc"); 748 EXPECT_TRUE(absl::ParseFlag("asd\0fgh", &value, &err)); 749 EXPECT_EQ(value, "asd"); 750 EXPECT_TRUE(absl::ParseFlag("\\\\", &value, &err)); 751 EXPECT_EQ(value, "\\\\"); 752 } 753 754 // -------------------------------------------------------------------- 755 756 TEST(MarshallingTest, TestVectorOfStringParsing) { 757 std::string err; 758 std::vector<std::string> value; 759 760 EXPECT_TRUE(absl::ParseFlag("", &value, &err)); 761 EXPECT_EQ(value, std::vector<std::string>{}); 762 EXPECT_TRUE(absl::ParseFlag("1", &value, &err)); 763 EXPECT_EQ(value, std::vector<std::string>({"1"})); 764 EXPECT_TRUE(absl::ParseFlag("a,b", &value, &err)); 765 EXPECT_EQ(value, std::vector<std::string>({"a", "b"})); 766 EXPECT_TRUE(absl::ParseFlag("a,b,c,", &value, &err)); 767 EXPECT_EQ(value, std::vector<std::string>({"a", "b", "c", ""})); 768 EXPECT_TRUE(absl::ParseFlag("a,,", &value, &err)); 769 EXPECT_EQ(value, std::vector<std::string>({"a", "", ""})); 770 EXPECT_TRUE(absl::ParseFlag(",", &value, &err)); 771 EXPECT_EQ(value, std::vector<std::string>({"", ""})); 772 EXPECT_TRUE(absl::ParseFlag("a, b,c ", &value, &err)); 773 EXPECT_EQ(value, std::vector<std::string>({"a", " b", "c "})); 774 } 775 776 // -------------------------------------------------------------------- 777 778 TEST(MarshallingTest, TestOptionalBoolParsing) { 779 std::string err; 780 absl::optional<bool> value; 781 782 EXPECT_TRUE(absl::ParseFlag("", &value, &err)); 783 EXPECT_FALSE(value.has_value()); 784 785 EXPECT_TRUE(absl::ParseFlag("true", &value, &err)); 786 EXPECT_TRUE(value.has_value()); 787 EXPECT_TRUE(*value); 788 789 EXPECT_TRUE(absl::ParseFlag("false", &value, &err)); 790 EXPECT_TRUE(value.has_value()); 791 EXPECT_FALSE(*value); 792 793 EXPECT_FALSE(absl::ParseFlag("nullopt", &value, &err)); 794 } 795 796 // -------------------------------------------------------------------- 797 798 TEST(MarshallingTest, TestOptionalIntParsing) { 799 std::string err; 800 absl::optional<int> value; 801 802 EXPECT_TRUE(absl::ParseFlag("", &value, &err)); 803 EXPECT_FALSE(value.has_value()); 804 805 EXPECT_TRUE(absl::ParseFlag("10", &value, &err)); 806 EXPECT_TRUE(value.has_value()); 807 EXPECT_EQ(*value, 10); 808 809 EXPECT_TRUE(absl::ParseFlag("0x1F", &value, &err)); 810 EXPECT_TRUE(value.has_value()); 811 EXPECT_EQ(*value, 31); 812 813 EXPECT_FALSE(absl::ParseFlag("nullopt", &value, &err)); 814 } 815 816 // -------------------------------------------------------------------- 817 818 TEST(MarshallingTest, TestOptionalDoubleParsing) { 819 std::string err; 820 absl::optional<double> value; 821 822 EXPECT_TRUE(absl::ParseFlag("", &value, &err)); 823 EXPECT_FALSE(value.has_value()); 824 825 EXPECT_TRUE(absl::ParseFlag("1.11", &value, &err)); 826 EXPECT_TRUE(value.has_value()); 827 EXPECT_EQ(*value, 1.11); 828 829 EXPECT_TRUE(absl::ParseFlag("-0.12", &value, &err)); 830 EXPECT_TRUE(value.has_value()); 831 EXPECT_EQ(*value, -0.12); 832 833 EXPECT_FALSE(absl::ParseFlag("nullopt", &value, &err)); 834 } 835 836 // -------------------------------------------------------------------- 837 838 TEST(MarshallingTest, TestOptionalStringParsing) { 839 std::string err; 840 absl::optional<std::string> value; 841 842 EXPECT_TRUE(absl::ParseFlag("", &value, &err)); 843 EXPECT_FALSE(value.has_value()); 844 845 EXPECT_TRUE(absl::ParseFlag(" ", &value, &err)); 846 EXPECT_TRUE(value.has_value()); 847 EXPECT_EQ(*value, " "); 848 849 EXPECT_TRUE(absl::ParseFlag("aqswde", &value, &err)); 850 EXPECT_TRUE(value.has_value()); 851 EXPECT_EQ(*value, "aqswde"); 852 853 EXPECT_TRUE(absl::ParseFlag("nullopt", &value, &err)); 854 EXPECT_TRUE(value.has_value()); 855 EXPECT_EQ(*value, "nullopt"); 856 } 857 858 // -------------------------------------------------------------------- 859 860 TEST(MarshallingTest, TestBoolUnparsing) { 861 EXPECT_EQ(absl::UnparseFlag(true), "true"); 862 EXPECT_EQ(absl::UnparseFlag(false), "false"); 863 } 864 865 // -------------------------------------------------------------------- 866 867 TEST(MarshallingTest, TestInt16Unparsing) { 868 int16_t value; 869 870 value = 1; 871 EXPECT_EQ(absl::UnparseFlag(value), "1"); 872 value = 0; 873 EXPECT_EQ(absl::UnparseFlag(value), "0"); 874 value = -1; 875 EXPECT_EQ(absl::UnparseFlag(value), "-1"); 876 value = 9876; 877 EXPECT_EQ(absl::UnparseFlag(value), "9876"); 878 value = -987; 879 EXPECT_EQ(absl::UnparseFlag(value), "-987"); 880 } 881 882 // -------------------------------------------------------------------- 883 884 TEST(MarshallingTest, TestUint16Unparsing) { 885 uint16_t value; 886 887 value = 1; 888 EXPECT_EQ(absl::UnparseFlag(value), "1"); 889 value = 0; 890 EXPECT_EQ(absl::UnparseFlag(value), "0"); 891 value = 19876; 892 EXPECT_EQ(absl::UnparseFlag(value), "19876"); 893 } 894 895 // -------------------------------------------------------------------- 896 897 TEST(MarshallingTest, TestInt32Unparsing) { 898 int32_t value; 899 900 value = 1; 901 EXPECT_EQ(absl::UnparseFlag(value), "1"); 902 value = 0; 903 EXPECT_EQ(absl::UnparseFlag(value), "0"); 904 value = -1; 905 EXPECT_EQ(absl::UnparseFlag(value), "-1"); 906 value = 12345; 907 EXPECT_EQ(absl::UnparseFlag(value), "12345"); 908 value = -987; 909 EXPECT_EQ(absl::UnparseFlag(value), "-987"); 910 } 911 912 // -------------------------------------------------------------------- 913 914 TEST(MarshallingTest, TestUint32Unparsing) { 915 uint32_t value; 916 917 value = 1; 918 EXPECT_EQ(absl::UnparseFlag(value), "1"); 919 value = 0; 920 EXPECT_EQ(absl::UnparseFlag(value), "0"); 921 value = 1234500; 922 EXPECT_EQ(absl::UnparseFlag(value), "1234500"); 923 } 924 925 // -------------------------------------------------------------------- 926 927 TEST(MarshallingTest, TestInt64Unparsing) { 928 int64_t value; 929 930 value = 1; 931 EXPECT_EQ(absl::UnparseFlag(value), "1"); 932 value = 0; 933 EXPECT_EQ(absl::UnparseFlag(value), "0"); 934 value = -1; 935 EXPECT_EQ(absl::UnparseFlag(value), "-1"); 936 value = 123456789L; 937 EXPECT_EQ(absl::UnparseFlag(value), "123456789"); 938 value = -987654321L; 939 EXPECT_EQ(absl::UnparseFlag(value), "-987654321"); 940 value = 0x7FFFFFFFFFFFFFFF; 941 EXPECT_EQ(absl::UnparseFlag(value), "9223372036854775807"); 942 value = 0xFFFFFFFFFFFFFFFF; 943 EXPECT_EQ(absl::UnparseFlag(value), "-1"); 944 } 945 946 // -------------------------------------------------------------------- 947 948 TEST(MarshallingTest, TestUint64Unparsing) { 949 uint64_t value; 950 951 value = 1; 952 EXPECT_EQ(absl::UnparseFlag(value), "1"); 953 value = 0; 954 EXPECT_EQ(absl::UnparseFlag(value), "0"); 955 value = 123456789L; 956 EXPECT_EQ(absl::UnparseFlag(value), "123456789"); 957 value = 0xFFFFFFFFFFFFFFFF; 958 EXPECT_EQ(absl::UnparseFlag(value), "18446744073709551615"); 959 } 960 961 // -------------------------------------------------------------------- 962 963 TEST(MarshallingTest, TestInt128Unparsing) { 964 absl::int128 value; 965 966 value = 1; 967 EXPECT_EQ(absl::UnparseFlag(value), "1"); 968 value = 0; 969 EXPECT_EQ(absl::UnparseFlag(value), "0"); 970 value = -1; 971 EXPECT_EQ(absl::UnparseFlag(value), "-1"); 972 value = 123456789L; 973 EXPECT_EQ(absl::UnparseFlag(value), "123456789"); 974 value = -987654321L; 975 EXPECT_EQ(absl::UnparseFlag(value), "-987654321"); 976 value = 0x7FFFFFFFFFFFFFFF; 977 EXPECT_EQ(absl::UnparseFlag(value), "9223372036854775807"); 978 } 979 980 // -------------------------------------------------------------------- 981 982 TEST(MarshallingTest, TestUint128Unparsing) { 983 absl::uint128 value; 984 985 value = 1; 986 EXPECT_EQ(absl::UnparseFlag(value), "1"); 987 value = 0; 988 EXPECT_EQ(absl::UnparseFlag(value), "0"); 989 value = 123456789L; 990 EXPECT_EQ(absl::UnparseFlag(value), "123456789"); 991 value = absl::MakeUint128(0, 0xFFFFFFFFFFFFFFFF); 992 EXPECT_EQ(absl::UnparseFlag(value), "18446744073709551615"); 993 } 994 995 // -------------------------------------------------------------------- 996 997 TEST(MarshallingTest, TestFloatUnparsing) { 998 float value; 999 1000 value = 1.1f; 1001 EXPECT_EQ(absl::UnparseFlag(value), "1.1"); 1002 value = 0.01f; 1003 EXPECT_EQ(absl::UnparseFlag(value), "0.01"); 1004 value = 1.23e-2f; 1005 EXPECT_EQ(absl::UnparseFlag(value), "0.0123"); 1006 value = -0.71f; 1007 EXPECT_EQ(absl::UnparseFlag(value), "-0.71"); 1008 } 1009 1010 // -------------------------------------------------------------------- 1011 1012 TEST(MarshallingTest, TestDoubleUnparsing) { 1013 double value; 1014 1015 value = 1.1; 1016 EXPECT_EQ(absl::UnparseFlag(value), "1.1"); 1017 value = 0.01; 1018 EXPECT_EQ(absl::UnparseFlag(value), "0.01"); 1019 value = 1.23e-2; 1020 EXPECT_EQ(absl::UnparseFlag(value), "0.0123"); 1021 value = -0.71; 1022 EXPECT_EQ(absl::UnparseFlag(value), "-0.71"); 1023 value = -0; 1024 EXPECT_EQ(absl::UnparseFlag(value), "0"); 1025 value = std::nan(""); 1026 EXPECT_EQ(absl::UnparseFlag(value), "nan"); 1027 value = std::numeric_limits<double>::infinity(); 1028 EXPECT_EQ(absl::UnparseFlag(value), "inf"); 1029 } 1030 1031 // -------------------------------------------------------------------- 1032 1033 TEST(MarshallingTest, TestStringUnparsing) { 1034 EXPECT_EQ(absl::UnparseFlag(""), ""); 1035 EXPECT_EQ(absl::UnparseFlag(" "), " "); 1036 EXPECT_EQ(absl::UnparseFlag("qwerty"), "qwerty"); 1037 EXPECT_EQ(absl::UnparseFlag("ASDFGH"), "ASDFGH"); 1038 EXPECT_EQ(absl::UnparseFlag("\n\t "), "\n\t "); 1039 } 1040 1041 // -------------------------------------------------------------------- 1042 1043 TEST(MarshallingTest, TestOptionalBoolUnparsing) { 1044 absl::optional<bool> value; 1045 1046 EXPECT_EQ(absl::UnparseFlag(value), ""); 1047 value = true; 1048 EXPECT_EQ(absl::UnparseFlag(value), "true"); 1049 value = false; 1050 EXPECT_EQ(absl::UnparseFlag(value), "false"); 1051 value = absl::nullopt; 1052 EXPECT_EQ(absl::UnparseFlag(value), ""); 1053 } 1054 1055 // -------------------------------------------------------------------- 1056 1057 TEST(MarshallingTest, TestOptionalIntUnparsing) { 1058 absl::optional<int> value; 1059 1060 EXPECT_EQ(absl::UnparseFlag(value), ""); 1061 value = 0; 1062 EXPECT_EQ(absl::UnparseFlag(value), "0"); 1063 value = -12; 1064 EXPECT_EQ(absl::UnparseFlag(value), "-12"); 1065 value = absl::nullopt; 1066 EXPECT_EQ(absl::UnparseFlag(value), ""); 1067 } 1068 1069 // -------------------------------------------------------------------- 1070 1071 TEST(MarshallingTest, TestOptionalDoubleUnparsing) { 1072 absl::optional<double> value; 1073 1074 EXPECT_EQ(absl::UnparseFlag(value), ""); 1075 value = 1.; 1076 EXPECT_EQ(absl::UnparseFlag(value), "1"); 1077 value = -1.23; 1078 EXPECT_EQ(absl::UnparseFlag(value), "-1.23"); 1079 value = absl::nullopt; 1080 EXPECT_EQ(absl::UnparseFlag(value), ""); 1081 } 1082 1083 // -------------------------------------------------------------------- 1084 1085 TEST(MarshallingTest, TestOptionalStringUnparsing) { 1086 absl::optional<std::string> strvalue; 1087 EXPECT_EQ(absl::UnparseFlag(strvalue), ""); 1088 1089 strvalue = "asdfg"; 1090 EXPECT_EQ(absl::UnparseFlag(strvalue), "asdfg"); 1091 1092 strvalue = " "; 1093 EXPECT_EQ(absl::UnparseFlag(strvalue), " "); 1094 1095 strvalue = ""; // It is UB to set an optional string flag to "" 1096 EXPECT_EQ(absl::UnparseFlag(strvalue), ""); 1097 } 1098 1099 // -------------------------------------------------------------------- 1100 1101 #if defined(ABSL_HAVE_STD_OPTIONAL) && !defined(ABSL_USES_STD_OPTIONAL) 1102 1103 TEST(MarshallingTest, TestStdOptionalUnparsing) { 1104 std::optional<std::string> strvalue; 1105 EXPECT_EQ(absl::UnparseFlag(strvalue), ""); 1106 1107 strvalue = "asdfg"; 1108 EXPECT_EQ(absl::UnparseFlag(strvalue), "asdfg"); 1109 1110 strvalue = " "; 1111 EXPECT_EQ(absl::UnparseFlag(strvalue), " "); 1112 1113 strvalue = ""; // It is UB to set an optional string flag to "" 1114 EXPECT_EQ(absl::UnparseFlag(strvalue), ""); 1115 1116 std::optional<int> intvalue; 1117 EXPECT_EQ(absl::UnparseFlag(intvalue), ""); 1118 1119 intvalue = 10; 1120 EXPECT_EQ(absl::UnparseFlag(intvalue), "10"); 1121 } 1122 1123 // -------------------------------------------------------------------- 1124 1125 #endif 1126 1127 template <typename T> 1128 void TestRoundtrip(T v) { 1129 T new_v; 1130 std::string err; 1131 EXPECT_TRUE(absl::ParseFlag(absl::UnparseFlag(v), &new_v, &err)); 1132 EXPECT_EQ(new_v, v); 1133 } 1134 1135 TEST(MarshallingTest, TestFloatRoundTrip) { 1136 TestRoundtrip(0.1f); 1137 TestRoundtrip(0.12f); 1138 TestRoundtrip(0.123f); 1139 TestRoundtrip(0.1234f); 1140 TestRoundtrip(0.12345f); 1141 TestRoundtrip(0.123456f); 1142 TestRoundtrip(0.1234567f); 1143 TestRoundtrip(0.12345678f); 1144 1145 TestRoundtrip(0.1e20f); 1146 TestRoundtrip(0.12e20f); 1147 TestRoundtrip(0.123e20f); 1148 TestRoundtrip(0.1234e20f); 1149 TestRoundtrip(0.12345e20f); 1150 TestRoundtrip(0.123456e20f); 1151 TestRoundtrip(0.1234567e20f); 1152 TestRoundtrip(0.12345678e20f); 1153 1154 TestRoundtrip(0.1e-20f); 1155 TestRoundtrip(0.12e-20f); 1156 TestRoundtrip(0.123e-20f); 1157 TestRoundtrip(0.1234e-20f); 1158 TestRoundtrip(0.12345e-20f); 1159 TestRoundtrip(0.123456e-20f); 1160 TestRoundtrip(0.1234567e-20f); 1161 TestRoundtrip(0.12345678e-20f); 1162 } 1163 1164 TEST(MarshallingTest, TestDoubleRoundTrip) { 1165 TestRoundtrip(0.1); 1166 TestRoundtrip(0.12); 1167 TestRoundtrip(0.123); 1168 TestRoundtrip(0.1234); 1169 TestRoundtrip(0.12345); 1170 TestRoundtrip(0.123456); 1171 TestRoundtrip(0.1234567); 1172 TestRoundtrip(0.12345678); 1173 TestRoundtrip(0.123456789); 1174 TestRoundtrip(0.1234567891); 1175 TestRoundtrip(0.12345678912); 1176 TestRoundtrip(0.123456789123); 1177 TestRoundtrip(0.1234567891234); 1178 TestRoundtrip(0.12345678912345); 1179 TestRoundtrip(0.123456789123456); 1180 TestRoundtrip(0.1234567891234567); 1181 TestRoundtrip(0.12345678912345678); 1182 1183 TestRoundtrip(0.1e50); 1184 TestRoundtrip(0.12e50); 1185 TestRoundtrip(0.123e50); 1186 TestRoundtrip(0.1234e50); 1187 TestRoundtrip(0.12345e50); 1188 TestRoundtrip(0.123456e50); 1189 TestRoundtrip(0.1234567e50); 1190 TestRoundtrip(0.12345678e50); 1191 TestRoundtrip(0.123456789e50); 1192 TestRoundtrip(0.1234567891e50); 1193 TestRoundtrip(0.12345678912e50); 1194 TestRoundtrip(0.123456789123e50); 1195 TestRoundtrip(0.1234567891234e50); 1196 TestRoundtrip(0.12345678912345e50); 1197 TestRoundtrip(0.123456789123456e50); 1198 TestRoundtrip(0.1234567891234567e50); 1199 TestRoundtrip(0.12345678912345678e50); 1200 1201 TestRoundtrip(0.1e-50); 1202 TestRoundtrip(0.12e-50); 1203 TestRoundtrip(0.123e-50); 1204 TestRoundtrip(0.1234e-50); 1205 TestRoundtrip(0.12345e-50); 1206 TestRoundtrip(0.123456e-50); 1207 TestRoundtrip(0.1234567e-50); 1208 TestRoundtrip(0.12345678e-50); 1209 TestRoundtrip(0.123456789e-50); 1210 TestRoundtrip(0.1234567891e-50); 1211 TestRoundtrip(0.12345678912e-50); 1212 TestRoundtrip(0.123456789123e-50); 1213 TestRoundtrip(0.1234567891234e-50); 1214 TestRoundtrip(0.12345678912345e-50); 1215 TestRoundtrip(0.123456789123456e-50); 1216 TestRoundtrip(0.1234567891234567e-50); 1217 TestRoundtrip(0.12345678912345678e-50); 1218 } 1219 1220 } // namespace