| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2016 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "base/optional.h" | |
| 6 | |
| 7 #include <set> | |
| 8 | |
| 9 #include "testing/gtest/include/gtest/gtest.h" | |
| 10 | |
| 11 namespace base { | |
| 12 | |
| 13 namespace { | |
| 14 | |
| 15 // Object used to test complex object with Optional<T> in addition of the move | |
| 16 // semantics. | |
| 17 class TestObject { | |
| 18 public: | |
| 19 enum class State { | |
| 20 DEFAULT_CONSTRUCTED, | |
| 21 VALUE_CONSTRUCTED, | |
| 22 COPY_CONSTRUCTED, | |
| 23 MOVE_CONSTRUCTED, | |
| 24 MOVED_FROM, | |
| 25 }; | |
| 26 | |
| 27 TestObject() : foo_(0), bar_(0.0), state_(State::DEFAULT_CONSTRUCTED) {} | |
| 28 | |
| 29 TestObject(int foo, double bar) | |
| 30 : foo_(foo), bar_(bar), state_(State::VALUE_CONSTRUCTED) {} | |
| 31 | |
| 32 TestObject(const TestObject& other) | |
| 33 : foo_(other.foo_), bar_(other.bar_), state_(State::COPY_CONSTRUCTED) {} | |
| 34 | |
| 35 TestObject(TestObject&& other) | |
| 36 : foo_(std::move(other.foo_)), | |
| 37 bar_(std::move(other.bar_)), | |
| 38 state_(State::MOVE_CONSTRUCTED) { | |
| 39 other.state_ = State::MOVED_FROM; | |
| 40 } | |
| 41 | |
| 42 TestObject& operator=(const TestObject& other) { | |
| 43 foo_ = other.foo_; | |
| 44 bar_ = other.bar_; | |
| 45 state_ = State::COPY_CONSTRUCTED; | |
| 46 return *this; | |
| 47 } | |
| 48 | |
| 49 bool operator==(const TestObject& other) const { | |
| 50 return foo_ == other.foo_ && bar_ == other.bar_; | |
| 51 } | |
| 52 | |
| 53 int foo() const { return foo_; } | |
| 54 State state() const { return state_; } | |
| 55 | |
| 56 private: | |
| 57 int foo_; | |
| 58 double bar_; | |
| 59 State state_; | |
| 60 }; | |
| 61 | |
| 62 } // anonymous namespace | |
| 63 | |
| 64 TEST(OptionalTest, DefaultConstructor) { | |
| 65 { | |
| 66 Optional<float> o; | |
| 67 EXPECT_FALSE(o); | |
| 68 } | |
| 69 | |
| 70 { | |
| 71 Optional<std::string> o; | |
| 72 EXPECT_FALSE(o); | |
| 73 } | |
| 74 | |
| 75 { | |
| 76 Optional<TestObject> o; | |
| 77 EXPECT_FALSE(o); | |
| 78 } | |
| 79 } | |
| 80 | |
| 81 TEST(OptionalTest, CopyConstructor) { | |
| 82 { | |
| 83 Optional<float> first(0.1f); | |
| 84 Optional<float> other(first); | |
| 85 | |
| 86 EXPECT_TRUE(other); | |
| 87 EXPECT_EQ(other.value(), 0.1f); | |
| 88 EXPECT_EQ(first, other); | |
| 89 } | |
| 90 | |
| 91 { | |
| 92 Optional<std::string> first("foo"); | |
| 93 Optional<std::string> other(first); | |
| 94 | |
| 95 EXPECT_TRUE(other); | |
| 96 EXPECT_EQ(other.value(), "foo"); | |
| 97 EXPECT_EQ(first, other); | |
| 98 } | |
| 99 | |
| 100 { | |
| 101 Optional<TestObject> first(TestObject(3, 0.1)); | |
| 102 Optional<TestObject> other(first); | |
| 103 | |
| 104 EXPECT_TRUE(!!other); | |
| 105 EXPECT_TRUE(other.value() == TestObject(3, 0.1)); | |
| 106 EXPECT_TRUE(first == other); | |
| 107 } | |
| 108 } | |
| 109 | |
| 110 TEST(OptionalTest, ValueConstructor) { | |
| 111 { | |
| 112 Optional<float> o(0.1f); | |
| 113 EXPECT_TRUE(o); | |
| 114 EXPECT_EQ(o.value(), 0.1f); | |
| 115 } | |
| 116 | |
| 117 { | |
| 118 Optional<std::string> o("foo"); | |
| 119 EXPECT_TRUE(o); | |
| 120 EXPECT_EQ(o.value(), "foo"); | |
| 121 } | |
| 122 | |
| 123 { | |
| 124 Optional<TestObject> o(TestObject(3, 0.1)); | |
| 125 EXPECT_TRUE(!!o); | |
| 126 EXPECT_TRUE(o.value() == TestObject(3, 0.1)); | |
| 127 } | |
| 128 } | |
| 129 | |
| 130 TEST(OptionalTest, MoveConstructor) { | |
| 131 { | |
| 132 Optional<float> first(0.1f); | |
| 133 Optional<float> second(std::move(first)); | |
| 134 | |
| 135 EXPECT_TRUE(second); | |
| 136 EXPECT_EQ(second.value(), 0.1f); | |
| 137 | |
| 138 EXPECT_TRUE(first); | |
| 139 } | |
| 140 | |
| 141 { | |
| 142 Optional<std::string> first("foo"); | |
| 143 Optional<std::string> second(std::move(first)); | |
| 144 | |
| 145 EXPECT_TRUE(second); | |
| 146 EXPECT_EQ("foo", second.value()); | |
| 147 | |
| 148 EXPECT_TRUE(first); | |
| 149 } | |
| 150 | |
| 151 { | |
| 152 Optional<TestObject> first(TestObject(3, 0.1)); | |
| 153 Optional<TestObject> second(std::move(first)); | |
| 154 | |
| 155 EXPECT_TRUE(!!second); | |
| 156 EXPECT_EQ(TestObject::State::MOVE_CONSTRUCTED, second->state()); | |
| 157 EXPECT_TRUE(TestObject(3, 0.1) == second.value()); | |
| 158 | |
| 159 EXPECT_TRUE(!!first); | |
| 160 EXPECT_EQ(TestObject::State::MOVED_FROM, first->state()); | |
| 161 } | |
| 162 } | |
| 163 | |
| 164 TEST(OptionalTest, MoveValueConstructor) { | |
| 165 { | |
| 166 Optional<float> first(0.1f); | |
| 167 Optional<float> second(std::move(first.value())); | |
| 168 | |
| 169 EXPECT_TRUE(second); | |
| 170 EXPECT_EQ(second.value(), 0.1f); | |
| 171 | |
| 172 EXPECT_TRUE(first); | |
| 173 } | |
| 174 | |
| 175 { | |
| 176 Optional<std::string> first("foo"); | |
| 177 Optional<std::string> second(std::move(first.value())); | |
| 178 | |
| 179 EXPECT_TRUE(second); | |
| 180 EXPECT_EQ("foo", second.value()); | |
| 181 | |
| 182 EXPECT_TRUE(first); | |
| 183 } | |
| 184 | |
| 185 { | |
| 186 Optional<TestObject> first(TestObject(3, 0.1)); | |
| 187 Optional<TestObject> second(std::move(first.value())); | |
| 188 | |
| 189 EXPECT_TRUE(!!second); | |
| 190 EXPECT_EQ(TestObject::State::MOVE_CONSTRUCTED, second->state()); | |
| 191 EXPECT_TRUE(TestObject(3, 0.1) == second.value()); | |
| 192 | |
| 193 EXPECT_TRUE(!!first); | |
| 194 EXPECT_EQ(TestObject::State::MOVED_FROM, first->state()); | |
| 195 } | |
| 196 } | |
| 197 | |
| 198 TEST(OptionalTest, ConstructorForwardArguments) { | |
| 199 { | |
| 200 Optional<float> a(base::in_place, 0.1f); | |
| 201 EXPECT_TRUE(a); | |
| 202 EXPECT_EQ(0.1f, a.value()); | |
| 203 } | |
| 204 | |
| 205 { | |
| 206 Optional<std::string> a(base::in_place, "foo"); | |
| 207 EXPECT_TRUE(a); | |
| 208 EXPECT_EQ("foo", a.value()); | |
| 209 } | |
| 210 | |
| 211 { | |
| 212 Optional<TestObject> a(base::in_place, 0, 0.1); | |
| 213 EXPECT_TRUE(!!a); | |
| 214 EXPECT_TRUE(TestObject(0, 0.1) == a.value()); | |
| 215 } | |
| 216 } | |
| 217 | |
| 218 TEST(OptionalTest, AssignValue) { | |
| 219 { | |
| 220 Optional<float> a; | |
| 221 EXPECT_FALSE(a); | |
| 222 a = 0.1f; | |
| 223 EXPECT_TRUE(a); | |
| 224 | |
| 225 Optional<float> b(0.1f); | |
| 226 EXPECT_TRUE(a == b); | |
| 227 } | |
| 228 | |
| 229 { | |
| 230 // Using |const char*| because |std::string| can't be assigned string | |
| 231 // literals because of the decay-only perfect forwarding assignment rule. | |
| 232 Optional<const char*> a; | |
| 233 EXPECT_FALSE(a); | |
| 234 a = "foo"; | |
| 235 EXPECT_TRUE(a); | |
| 236 | |
| 237 Optional<const char*> b("foo"); | |
| 238 EXPECT_TRUE(a == b); | |
| 239 } | |
| 240 | |
| 241 { | |
| 242 Optional<TestObject> a; | |
| 243 EXPECT_FALSE(!!a); | |
| 244 a = TestObject(3, 0.1); | |
| 245 EXPECT_TRUE(!!a); | |
| 246 | |
| 247 Optional<TestObject> b(TestObject(3, 0.1)); | |
| 248 EXPECT_TRUE(a == b); | |
| 249 } | |
| 250 } | |
| 251 | |
| 252 TEST(OptionalTest, AssignObject) { | |
| 253 { | |
| 254 Optional<float> a; | |
| 255 Optional<float> b(0.1f); | |
| 256 a = b; | |
| 257 | |
| 258 EXPECT_TRUE(a); | |
| 259 EXPECT_EQ(a.value(), 0.1f); | |
| 260 EXPECT_EQ(a, b); | |
| 261 } | |
| 262 | |
| 263 { | |
| 264 Optional<std::string> a; | |
| 265 Optional<std::string> b("foo"); | |
| 266 a = b; | |
| 267 | |
| 268 EXPECT_TRUE(a); | |
| 269 EXPECT_EQ(a.value(), "foo"); | |
| 270 EXPECT_EQ(a, b); | |
| 271 } | |
| 272 | |
| 273 { | |
| 274 Optional<TestObject> a; | |
| 275 Optional<TestObject> b(TestObject(3, 0.1)); | |
| 276 a = b; | |
| 277 | |
| 278 EXPECT_TRUE(!!a); | |
| 279 EXPECT_TRUE(a.value() == TestObject(3, 0.1)); | |
| 280 EXPECT_TRUE(a == b); | |
| 281 } | |
| 282 } | |
| 283 | |
| 284 TEST(OptionalTest, AssignObject_rvalue) { | |
| 285 { | |
| 286 Optional<float> a; | |
| 287 Optional<float> b(0.1f); | |
| 288 a = std::move(b); | |
| 289 | |
| 290 EXPECT_TRUE(a); | |
| 291 EXPECT_TRUE(b); | |
| 292 EXPECT_EQ(0.1f, a.value()); | |
| 293 } | |
| 294 | |
| 295 { | |
| 296 Optional<std::string> a; | |
| 297 Optional<std::string> b("foo"); | |
| 298 a = std::move(b); | |
| 299 | |
| 300 EXPECT_TRUE(a); | |
| 301 EXPECT_TRUE(b); | |
| 302 EXPECT_EQ("foo", a.value()); | |
| 303 } | |
| 304 | |
| 305 { | |
| 306 Optional<TestObject> a; | |
| 307 Optional<TestObject> b(TestObject(3, 0.1)); | |
| 308 a = std::move(b); | |
| 309 | |
| 310 EXPECT_TRUE(!!a); | |
| 311 EXPECT_TRUE(!!b); | |
| 312 EXPECT_TRUE(TestObject(3, 0.1) == a.value()); | |
| 313 | |
| 314 EXPECT_EQ(TestObject::State::MOVE_CONSTRUCTED, a->state()); | |
| 315 EXPECT_EQ(TestObject::State::MOVED_FROM, b->state()); | |
| 316 } | |
| 317 } | |
| 318 | |
| 319 TEST(OptionalTest, AssignNull) { | |
| 320 { | |
| 321 Optional<float> a(0.1f); | |
| 322 Optional<float> b(0.2f); | |
| 323 a = base::nullopt; | |
| 324 b = base::nullopt; | |
| 325 EXPECT_EQ(a, b); | |
| 326 } | |
| 327 | |
| 328 { | |
| 329 Optional<std::string> a("foo"); | |
| 330 Optional<std::string> b("bar"); | |
| 331 a = base::nullopt; | |
| 332 b = base::nullopt; | |
| 333 EXPECT_EQ(a, b); | |
| 334 } | |
| 335 | |
| 336 { | |
| 337 Optional<TestObject> a(TestObject(3, 0.1)); | |
| 338 Optional<TestObject> b(TestObject(4, 1.0)); | |
| 339 a = base::nullopt; | |
| 340 b = base::nullopt; | |
| 341 EXPECT_TRUE(a == b); | |
| 342 } | |
| 343 } | |
| 344 | |
| 345 TEST(OptionalTest, OperatorStar) { | |
| 346 { | |
| 347 Optional<float> a(0.1f); | |
| 348 EXPECT_EQ(a.value(), *a); | |
| 349 } | |
| 350 | |
| 351 { | |
| 352 Optional<std::string> a("foo"); | |
| 353 EXPECT_EQ(a.value(), *a); | |
| 354 } | |
| 355 | |
| 356 { | |
| 357 Optional<TestObject> a(TestObject(3, 0.1)); | |
| 358 EXPECT_EQ(a.value(), *a); | |
| 359 } | |
| 360 } | |
| 361 | |
| 362 TEST(OptionalTest, OperatorStar_rvalue) { | |
| 363 EXPECT_EQ(0.1f, *Optional<float>(0.1f)); | |
| 364 EXPECT_EQ("foo", *Optional<const char*>("foo")); | |
| 365 EXPECT_TRUE(TestObject(3, 0.1) == *Optional<TestObject>(TestObject(3, 0.1))); | |
| 366 } | |
| 367 | |
| 368 TEST(OptionalTest, OperatorArrow) { | |
| 369 Optional<TestObject> a(TestObject(3, 0.1)); | |
| 370 EXPECT_EQ(a->foo(), 3); | |
| 371 } | |
| 372 | |
| 373 TEST(OptionalTest, Value_rvalue) { | |
| 374 EXPECT_EQ(0.1f, Optional<float>(0.1f).value()); | |
| 375 EXPECT_EQ("foo", Optional<const char*>("foo").value()); | |
| 376 EXPECT_TRUE(TestObject(3, 0.1) == | |
| 377 Optional<TestObject>(TestObject(3, 0.1)).value()); | |
| 378 } | |
| 379 | |
| 380 TEST(OptionalTest, ValueOr) { | |
| 381 { | |
| 382 Optional<float> a; | |
| 383 EXPECT_EQ(0.0f, a.value_or(0.0f)); | |
| 384 | |
| 385 a = 0.1f; | |
| 386 EXPECT_EQ(0.1f, a.value_or(0.0f)); | |
| 387 | |
| 388 a = base::nullopt; | |
| 389 EXPECT_EQ(0.0f, a.value_or(0.0f)); | |
| 390 } | |
| 391 | |
| 392 { | |
| 393 // Using |const char*| because |std::string| can't be assigned string | |
| 394 // literals because of the decay-only perfect forwarding assignment rule. | |
| 395 Optional<const char*> a; | |
| 396 EXPECT_EQ("bar", a.value_or("bar")); | |
| 397 | |
| 398 a = "foo"; | |
| 399 EXPECT_EQ("foo", a.value_or("bar")); | |
| 400 | |
| 401 a = base::nullopt; | |
| 402 EXPECT_EQ("bar", a.value_or("bar")); | |
| 403 } | |
| 404 | |
| 405 { | |
| 406 Optional<TestObject> a; | |
| 407 EXPECT_TRUE(a.value_or(TestObject(1, 0.3)) == TestObject(1, 0.3)); | |
| 408 | |
| 409 a = TestObject(3, 0.1); | |
| 410 EXPECT_TRUE(a.value_or(TestObject(1, 0.3)) == TestObject(3, 0.1)); | |
| 411 | |
| 412 a = base::nullopt; | |
| 413 EXPECT_TRUE(a.value_or(TestObject(1, 0.3)) == TestObject(1, 0.3)); | |
| 414 } | |
| 415 } | |
| 416 | |
| 417 TEST(OptionalTest, Swap_bothNoValue) { | |
| 418 Optional<TestObject> a, b; | |
| 419 a.swap(b); | |
| 420 | |
| 421 EXPECT_FALSE(a); | |
| 422 EXPECT_FALSE(b); | |
| 423 EXPECT_TRUE(TestObject(42, 0.42) == a.value_or(TestObject(42, 0.42))); | |
| 424 EXPECT_TRUE(TestObject(42, 0.42) == b.value_or(TestObject(42, 0.42))); | |
| 425 } | |
| 426 | |
| 427 TEST(OptionalTest, Swap_inHasValue) { | |
| 428 Optional<TestObject> a(TestObject(1, 0.3)); | |
| 429 Optional<TestObject> b; | |
| 430 a.swap(b); | |
| 431 | |
| 432 EXPECT_FALSE(a); | |
| 433 | |
| 434 EXPECT_TRUE(!!b); | |
| 435 EXPECT_TRUE(TestObject(42, 0.42) == a.value_or(TestObject(42, 0.42))); | |
| 436 EXPECT_TRUE(TestObject(1, 0.3) == b.value_or(TestObject(42, 0.42))); | |
| 437 } | |
| 438 | |
| 439 TEST(OptionalTest, Swap_outHasValue) { | |
| 440 Optional<TestObject> a; | |
| 441 Optional<TestObject> b(TestObject(1, 0.3)); | |
| 442 a.swap(b); | |
| 443 | |
| 444 EXPECT_TRUE(!!a); | |
| 445 EXPECT_FALSE(!!b); | |
| 446 EXPECT_TRUE(TestObject(1, 0.3) == a.value_or(TestObject(42, 0.42))); | |
| 447 EXPECT_TRUE(TestObject(42, 0.42) == b.value_or(TestObject(42, 0.42))); | |
| 448 } | |
| 449 | |
| 450 TEST(OptionalTest, Swap_bothValue) { | |
| 451 Optional<TestObject> a(TestObject(0, 0.1)); | |
| 452 Optional<TestObject> b(TestObject(1, 0.3)); | |
| 453 a.swap(b); | |
| 454 | |
| 455 EXPECT_TRUE(!!a); | |
| 456 EXPECT_TRUE(!!b); | |
| 457 EXPECT_TRUE(TestObject(1, 0.3) == a.value_or(TestObject(42, 0.42))); | |
| 458 EXPECT_TRUE(TestObject(0, 0.1) == b.value_or(TestObject(42, 0.42))); | |
| 459 } | |
| 460 | |
| 461 TEST(OptionalTest, Emplace) { | |
| 462 { | |
| 463 Optional<float> a(0.1f); | |
| 464 a.emplace(0.3f); | |
| 465 | |
| 466 EXPECT_TRUE(a); | |
| 467 EXPECT_EQ(0.3f, a.value()); | |
| 468 } | |
| 469 | |
| 470 { | |
| 471 Optional<std::string> a("foo"); | |
| 472 a.emplace("bar"); | |
| 473 | |
| 474 EXPECT_TRUE(a); | |
| 475 EXPECT_EQ("bar", a.value()); | |
| 476 } | |
| 477 | |
| 478 { | |
| 479 Optional<TestObject> a(TestObject(0, 0.1)); | |
| 480 a.emplace(TestObject(1, 0.2)); | |
| 481 | |
| 482 EXPECT_TRUE(!!a); | |
| 483 EXPECT_TRUE(TestObject(1, 0.2) == a.value()); | |
| 484 } | |
| 485 } | |
| 486 | |
| 487 TEST(OptionalTest, Equals_TwoEmpty) { | |
| 488 Optional<int> a; | |
| 489 Optional<int> b; | |
| 490 | |
| 491 EXPECT_TRUE(a == b); | |
| 492 } | |
| 493 | |
| 494 TEST(OptionalTest, Equals_TwoEquals) { | |
| 495 Optional<int> a(1); | |
| 496 Optional<int> b(1); | |
| 497 | |
| 498 EXPECT_TRUE(a == b); | |
| 499 } | |
| 500 | |
| 501 TEST(OptionalTest, Equals_OneEmpty) { | |
| 502 Optional<int> a; | |
| 503 Optional<int> b(1); | |
| 504 | |
| 505 EXPECT_FALSE(a == b); | |
| 506 } | |
| 507 | |
| 508 TEST(OptionalTest, Equals_TwoDifferent) { | |
| 509 Optional<int> a(0); | |
| 510 Optional<int> b(1); | |
| 511 | |
| 512 EXPECT_FALSE(a == b); | |
| 513 } | |
| 514 | |
| 515 TEST(OptionalTest, NotEquals_TwoEmpty) { | |
| 516 Optional<int> a; | |
| 517 Optional<int> b; | |
| 518 | |
| 519 EXPECT_FALSE(a != b); | |
| 520 } | |
| 521 | |
| 522 TEST(OptionalTest, NotEquals_TwoEquals) { | |
| 523 Optional<int> a(1); | |
| 524 Optional<int> b(1); | |
| 525 | |
| 526 EXPECT_FALSE(a != b); | |
| 527 } | |
| 528 | |
| 529 TEST(OptionalTest, NotEquals_OneEmpty) { | |
| 530 Optional<int> a; | |
| 531 Optional<int> b(1); | |
| 532 | |
| 533 EXPECT_TRUE(a != b); | |
| 534 } | |
| 535 | |
| 536 TEST(OptionalTest, NotEquals_TwoDifferent) { | |
| 537 Optional<int> a(0); | |
| 538 Optional<int> b(1); | |
| 539 | |
| 540 EXPECT_TRUE(a != b); | |
| 541 } | |
| 542 | |
| 543 TEST(OptionalTest, Less_LeftEmpty) { | |
| 544 Optional<int> l; | |
| 545 Optional<int> r(1); | |
| 546 | |
| 547 EXPECT_TRUE(l < r); | |
| 548 } | |
| 549 | |
| 550 TEST(OptionalTest, Less_RightEmpty) { | |
| 551 Optional<int> l(1); | |
| 552 Optional<int> r; | |
| 553 | |
| 554 EXPECT_FALSE(l < r); | |
| 555 } | |
| 556 | |
| 557 TEST(OptionalTest, Less_BothEmpty) { | |
| 558 Optional<int> l; | |
| 559 Optional<int> r; | |
| 560 | |
| 561 EXPECT_FALSE(l < r); | |
| 562 } | |
| 563 | |
| 564 TEST(OptionalTest, Less_BothValues) { | |
| 565 { | |
| 566 Optional<int> l(1); | |
| 567 Optional<int> r(2); | |
| 568 | |
| 569 EXPECT_TRUE(l < r); | |
| 570 } | |
| 571 { | |
| 572 Optional<int> l(2); | |
| 573 Optional<int> r(1); | |
| 574 | |
| 575 EXPECT_FALSE(l < r); | |
| 576 } | |
| 577 { | |
| 578 Optional<int> l(1); | |
| 579 Optional<int> r(1); | |
| 580 | |
| 581 EXPECT_FALSE(l < r); | |
| 582 } | |
| 583 } | |
| 584 | |
| 585 TEST(OptionalTest, LessEq_LeftEmpty) { | |
| 586 Optional<int> l; | |
| 587 Optional<int> r(1); | |
| 588 | |
| 589 EXPECT_TRUE(l <= r); | |
| 590 } | |
| 591 | |
| 592 TEST(OptionalTest, LessEq_RightEmpty) { | |
| 593 Optional<int> l(1); | |
| 594 Optional<int> r; | |
| 595 | |
| 596 EXPECT_FALSE(l <= r); | |
| 597 } | |
| 598 | |
| 599 TEST(OptionalTest, LessEq_BothEmpty) { | |
| 600 Optional<int> l; | |
| 601 Optional<int> r; | |
| 602 | |
| 603 EXPECT_TRUE(l <= r); | |
| 604 } | |
| 605 | |
| 606 TEST(OptionalTest, LessEq_BothValues) { | |
| 607 { | |
| 608 Optional<int> l(1); | |
| 609 Optional<int> r(2); | |
| 610 | |
| 611 EXPECT_TRUE(l <= r); | |
| 612 } | |
| 613 { | |
| 614 Optional<int> l(2); | |
| 615 Optional<int> r(1); | |
| 616 | |
| 617 EXPECT_FALSE(l <= r); | |
| 618 } | |
| 619 { | |
| 620 Optional<int> l(1); | |
| 621 Optional<int> r(1); | |
| 622 | |
| 623 EXPECT_TRUE(l <= r); | |
| 624 } | |
| 625 } | |
| 626 | |
| 627 TEST(OptionalTest, Greater_BothEmpty) { | |
| 628 Optional<int> l; | |
| 629 Optional<int> r; | |
| 630 | |
| 631 EXPECT_FALSE(l > r); | |
| 632 } | |
| 633 | |
| 634 TEST(OptionalTest, Greater_LeftEmpty) { | |
| 635 Optional<int> l; | |
| 636 Optional<int> r(1); | |
| 637 | |
| 638 EXPECT_FALSE(l > r); | |
| 639 } | |
| 640 | |
| 641 TEST(OptionalTest, Greater_RightEmpty) { | |
| 642 Optional<int> l(1); | |
| 643 Optional<int> r; | |
| 644 | |
| 645 EXPECT_TRUE(l > r); | |
| 646 } | |
| 647 | |
| 648 TEST(OptionalTest, Greater_BothValue) { | |
| 649 { | |
| 650 Optional<int> l(1); | |
| 651 Optional<int> r(2); | |
| 652 | |
| 653 EXPECT_FALSE(l > r); | |
| 654 } | |
| 655 { | |
| 656 Optional<int> l(2); | |
| 657 Optional<int> r(1); | |
| 658 | |
| 659 EXPECT_TRUE(l > r); | |
| 660 } | |
| 661 { | |
| 662 Optional<int> l(1); | |
| 663 Optional<int> r(1); | |
| 664 | |
| 665 EXPECT_FALSE(l > r); | |
| 666 } | |
| 667 } | |
| 668 | |
| 669 TEST(OptionalTest, GreaterEq_BothEmpty) { | |
| 670 Optional<int> l; | |
| 671 Optional<int> r; | |
| 672 | |
| 673 EXPECT_TRUE(l >= r); | |
| 674 } | |
| 675 | |
| 676 TEST(OptionalTest, GreaterEq_LeftEmpty) { | |
| 677 Optional<int> l; | |
| 678 Optional<int> r(1); | |
| 679 | |
| 680 EXPECT_FALSE(l >= r); | |
| 681 } | |
| 682 | |
| 683 TEST(OptionalTest, GreaterEq_RightEmpty) { | |
| 684 Optional<int> l(1); | |
| 685 Optional<int> r; | |
| 686 | |
| 687 EXPECT_TRUE(l >= r); | |
| 688 } | |
| 689 | |
| 690 TEST(OptionalTest, GreaterEq_BothValue) { | |
| 691 { | |
| 692 Optional<int> l(1); | |
| 693 Optional<int> r(2); | |
| 694 | |
| 695 EXPECT_FALSE(l >= r); | |
| 696 } | |
| 697 { | |
| 698 Optional<int> l(2); | |
| 699 Optional<int> r(1); | |
| 700 | |
| 701 EXPECT_TRUE(l >= r); | |
| 702 } | |
| 703 { | |
| 704 Optional<int> l(1); | |
| 705 Optional<int> r(1); | |
| 706 | |
| 707 EXPECT_TRUE(l >= r); | |
| 708 } | |
| 709 } | |
| 710 | |
| 711 TEST(OptionalTest, OptNullEq) { | |
| 712 { | |
| 713 Optional<int> opt; | |
| 714 EXPECT_TRUE(opt == base::nullopt); | |
| 715 } | |
| 716 { | |
| 717 Optional<int> opt(1); | |
| 718 EXPECT_FALSE(opt == base::nullopt); | |
| 719 } | |
| 720 } | |
| 721 | |
| 722 TEST(OptionalTest, NullOptEq) { | |
| 723 { | |
| 724 Optional<int> opt; | |
| 725 EXPECT_TRUE(base::nullopt == opt); | |
| 726 } | |
| 727 { | |
| 728 Optional<int> opt(1); | |
| 729 EXPECT_FALSE(base::nullopt == opt); | |
| 730 } | |
| 731 } | |
| 732 | |
| 733 TEST(OptionalTest, OptNullNotEq) { | |
| 734 { | |
| 735 Optional<int> opt; | |
| 736 EXPECT_FALSE(opt != base::nullopt); | |
| 737 } | |
| 738 { | |
| 739 Optional<int> opt(1); | |
| 740 EXPECT_TRUE(opt != base::nullopt); | |
| 741 } | |
| 742 } | |
| 743 | |
| 744 TEST(OptionalTest, NullOptNotEq) { | |
| 745 { | |
| 746 Optional<int> opt; | |
| 747 EXPECT_FALSE(base::nullopt != opt); | |
| 748 } | |
| 749 { | |
| 750 Optional<int> opt(1); | |
| 751 EXPECT_TRUE(base::nullopt != opt); | |
| 752 } | |
| 753 } | |
| 754 | |
| 755 TEST(OptionalTest, OptNullLower) { | |
| 756 { | |
| 757 Optional<int> opt; | |
| 758 EXPECT_FALSE(opt < base::nullopt); | |
| 759 } | |
| 760 { | |
| 761 Optional<int> opt(1); | |
| 762 EXPECT_FALSE(opt < base::nullopt); | |
| 763 } | |
| 764 } | |
| 765 | |
| 766 TEST(OptionalTest, NullOptLower) { | |
| 767 { | |
| 768 Optional<int> opt; | |
| 769 EXPECT_FALSE(base::nullopt < opt); | |
| 770 } | |
| 771 { | |
| 772 Optional<int> opt(1); | |
| 773 EXPECT_TRUE(base::nullopt < opt); | |
| 774 } | |
| 775 } | |
| 776 | |
| 777 TEST(OptionalTest, OptNullLowerEq) { | |
| 778 { | |
| 779 Optional<int> opt; | |
| 780 EXPECT_TRUE(opt <= base::nullopt); | |
| 781 } | |
| 782 { | |
| 783 Optional<int> opt(1); | |
| 784 EXPECT_FALSE(opt <= base::nullopt); | |
| 785 } | |
| 786 } | |
| 787 | |
| 788 TEST(OptionalTest, NullOptLowerEq) { | |
| 789 { | |
| 790 Optional<int> opt; | |
| 791 EXPECT_TRUE(base::nullopt <= opt); | |
| 792 } | |
| 793 { | |
| 794 Optional<int> opt(1); | |
| 795 EXPECT_TRUE(base::nullopt <= opt); | |
| 796 } | |
| 797 } | |
| 798 | |
| 799 TEST(OptionalTest, OptNullGreater) { | |
| 800 { | |
| 801 Optional<int> opt; | |
| 802 EXPECT_FALSE(opt > base::nullopt); | |
| 803 } | |
| 804 { | |
| 805 Optional<int> opt(1); | |
| 806 EXPECT_TRUE(opt > base::nullopt); | |
| 807 } | |
| 808 } | |
| 809 | |
| 810 TEST(OptionalTest, NullOptGreater) { | |
| 811 { | |
| 812 Optional<int> opt; | |
| 813 EXPECT_FALSE(base::nullopt > opt); | |
| 814 } | |
| 815 { | |
| 816 Optional<int> opt(1); | |
| 817 EXPECT_FALSE(base::nullopt > opt); | |
| 818 } | |
| 819 } | |
| 820 | |
| 821 TEST(OptionalTest, OptNullGreaterEq) { | |
| 822 { | |
| 823 Optional<int> opt; | |
| 824 EXPECT_TRUE(opt >= base::nullopt); | |
| 825 } | |
| 826 { | |
| 827 Optional<int> opt(1); | |
| 828 EXPECT_TRUE(opt >= base::nullopt); | |
| 829 } | |
| 830 } | |
| 831 | |
| 832 TEST(OptionalTest, NullOptGreaterEq) { | |
| 833 { | |
| 834 Optional<int> opt; | |
| 835 EXPECT_TRUE(base::nullopt >= opt); | |
| 836 } | |
| 837 { | |
| 838 Optional<int> opt(1); | |
| 839 EXPECT_FALSE(base::nullopt >= opt); | |
| 840 } | |
| 841 } | |
| 842 | |
| 843 TEST(OptionalTest, ValueEq_Empty) { | |
| 844 Optional<int> opt; | |
| 845 EXPECT_FALSE(opt == 1); | |
| 846 } | |
| 847 | |
| 848 TEST(OptionalTest, ValueEq_NotEmpty) { | |
| 849 { | |
| 850 Optional<int> opt(0); | |
| 851 EXPECT_FALSE(opt == 1); | |
| 852 } | |
| 853 { | |
| 854 Optional<int> opt(1); | |
| 855 EXPECT_TRUE(opt == 1); | |
| 856 } | |
| 857 } | |
| 858 | |
| 859 TEST(OptionalTest, EqValue_Empty) { | |
| 860 Optional<int> opt; | |
| 861 EXPECT_FALSE(1 == opt); | |
| 862 } | |
| 863 | |
| 864 TEST(OptionalTest, EqValue_NotEmpty) { | |
| 865 { | |
| 866 Optional<int> opt(0); | |
| 867 EXPECT_FALSE(1 == opt); | |
| 868 } | |
| 869 { | |
| 870 Optional<int> opt(1); | |
| 871 EXPECT_TRUE(1 == opt); | |
| 872 } | |
| 873 } | |
| 874 | |
| 875 TEST(OptionalTest, ValueNotEq_Empty) { | |
| 876 Optional<int> opt; | |
| 877 EXPECT_TRUE(opt != 1); | |
| 878 } | |
| 879 | |
| 880 TEST(OptionalTest, ValueNotEq_NotEmpty) { | |
| 881 { | |
| 882 Optional<int> opt(0); | |
| 883 EXPECT_TRUE(opt != 1); | |
| 884 } | |
| 885 { | |
| 886 Optional<int> opt(1); | |
| 887 EXPECT_FALSE(opt != 1); | |
| 888 } | |
| 889 } | |
| 890 | |
| 891 TEST(OptionalTest, NotEqValue_Empty) { | |
| 892 Optional<int> opt; | |
| 893 EXPECT_TRUE(1 != opt); | |
| 894 } | |
| 895 | |
| 896 TEST(OptionalTest, NotEqValue_NotEmpty) { | |
| 897 { | |
| 898 Optional<int> opt(0); | |
| 899 EXPECT_TRUE(1 != opt); | |
| 900 } | |
| 901 { | |
| 902 Optional<int> opt(1); | |
| 903 EXPECT_FALSE(1 != opt); | |
| 904 } | |
| 905 } | |
| 906 | |
| 907 TEST(OptionalTest, ValueLess_Empty) { | |
| 908 Optional<int> opt; | |
| 909 EXPECT_TRUE(opt < 1); | |
| 910 } | |
| 911 | |
| 912 TEST(OptionalTest, ValueLess_NotEmpty) { | |
| 913 { | |
| 914 Optional<int> opt(0); | |
| 915 EXPECT_TRUE(opt < 1); | |
| 916 } | |
| 917 { | |
| 918 Optional<int> opt(1); | |
| 919 EXPECT_FALSE(opt < 1); | |
| 920 } | |
| 921 { | |
| 922 Optional<int> opt(2); | |
| 923 EXPECT_FALSE(opt < 1); | |
| 924 } | |
| 925 } | |
| 926 | |
| 927 TEST(OptionalTest, LessValue_Empty) { | |
| 928 Optional<int> opt; | |
| 929 EXPECT_FALSE(1 < opt); | |
| 930 } | |
| 931 | |
| 932 TEST(OptionalTest, LessValue_NotEmpty) { | |
| 933 { | |
| 934 Optional<int> opt(0); | |
| 935 EXPECT_FALSE(1 < opt); | |
| 936 } | |
| 937 { | |
| 938 Optional<int> opt(1); | |
| 939 EXPECT_FALSE(1 < opt); | |
| 940 } | |
| 941 { | |
| 942 Optional<int> opt(2); | |
| 943 EXPECT_TRUE(1 < opt); | |
| 944 } | |
| 945 } | |
| 946 | |
| 947 TEST(OptionalTest, ValueLessEq_Empty) { | |
| 948 Optional<int> opt; | |
| 949 EXPECT_TRUE(opt <= 1); | |
| 950 } | |
| 951 | |
| 952 TEST(OptionalTest, ValueLessEq_NotEmpty) { | |
| 953 { | |
| 954 Optional<int> opt(0); | |
| 955 EXPECT_TRUE(opt <= 1); | |
| 956 } | |
| 957 { | |
| 958 Optional<int> opt(1); | |
| 959 EXPECT_TRUE(opt <= 1); | |
| 960 } | |
| 961 { | |
| 962 Optional<int> opt(2); | |
| 963 EXPECT_FALSE(opt <= 1); | |
| 964 } | |
| 965 } | |
| 966 | |
| 967 TEST(OptionalTest, LessEqValue_Empty) { | |
| 968 Optional<int> opt; | |
| 969 EXPECT_FALSE(1 <= opt); | |
| 970 } | |
| 971 | |
| 972 TEST(OptionalTest, LessEqValue_NotEmpty) { | |
| 973 { | |
| 974 Optional<int> opt(0); | |
| 975 EXPECT_FALSE(1 <= opt); | |
| 976 } | |
| 977 { | |
| 978 Optional<int> opt(1); | |
| 979 EXPECT_TRUE(1 <= opt); | |
| 980 } | |
| 981 { | |
| 982 Optional<int> opt(2); | |
| 983 EXPECT_TRUE(1 <= opt); | |
| 984 } | |
| 985 } | |
| 986 | |
| 987 TEST(OptionalTest, ValueGreater_Empty) { | |
| 988 Optional<int> opt; | |
| 989 EXPECT_FALSE(opt > 1); | |
| 990 } | |
| 991 | |
| 992 TEST(OptionalTest, ValueGreater_NotEmpty) { | |
| 993 { | |
| 994 Optional<int> opt(0); | |
| 995 EXPECT_FALSE(opt > 1); | |
| 996 } | |
| 997 { | |
| 998 Optional<int> opt(1); | |
| 999 EXPECT_FALSE(opt > 1); | |
| 1000 } | |
| 1001 { | |
| 1002 Optional<int> opt(2); | |
| 1003 EXPECT_TRUE(opt > 1); | |
| 1004 } | |
| 1005 } | |
| 1006 | |
| 1007 TEST(OptionalTest, GreaterValue_Empty) { | |
| 1008 Optional<int> opt; | |
| 1009 EXPECT_TRUE(1 > opt); | |
| 1010 } | |
| 1011 | |
| 1012 TEST(OptionalTest, GreaterValue_NotEmpty) { | |
| 1013 { | |
| 1014 Optional<int> opt(0); | |
| 1015 EXPECT_TRUE(1 > opt); | |
| 1016 } | |
| 1017 { | |
| 1018 Optional<int> opt(1); | |
| 1019 EXPECT_FALSE(1 > opt); | |
| 1020 } | |
| 1021 { | |
| 1022 Optional<int> opt(2); | |
| 1023 EXPECT_FALSE(1 > opt); | |
| 1024 } | |
| 1025 } | |
| 1026 | |
| 1027 TEST(OptionalTest, ValueGreaterEq_Empty) { | |
| 1028 Optional<int> opt; | |
| 1029 EXPECT_FALSE(opt >= 1); | |
| 1030 } | |
| 1031 | |
| 1032 TEST(OptionalTest, ValueGreaterEq_NotEmpty) { | |
| 1033 { | |
| 1034 Optional<int> opt(0); | |
| 1035 EXPECT_FALSE(opt >= 1); | |
| 1036 } | |
| 1037 { | |
| 1038 Optional<int> opt(1); | |
| 1039 EXPECT_TRUE(opt >= 1); | |
| 1040 } | |
| 1041 { | |
| 1042 Optional<int> opt(2); | |
| 1043 EXPECT_TRUE(opt >= 1); | |
| 1044 } | |
| 1045 } | |
| 1046 | |
| 1047 TEST(OptionalTest, GreaterEqValue_Empty) { | |
| 1048 Optional<int> opt; | |
| 1049 EXPECT_TRUE(1 >= opt); | |
| 1050 } | |
| 1051 | |
| 1052 TEST(OptionalTest, GreaterEqValue_NotEmpty) { | |
| 1053 { | |
| 1054 Optional<int> opt(0); | |
| 1055 EXPECT_TRUE(1 >= opt); | |
| 1056 } | |
| 1057 { | |
| 1058 Optional<int> opt(1); | |
| 1059 EXPECT_TRUE(1 >= opt); | |
| 1060 } | |
| 1061 { | |
| 1062 Optional<int> opt(2); | |
| 1063 EXPECT_FALSE(1 >= opt); | |
| 1064 } | |
| 1065 } | |
| 1066 | |
| 1067 TEST(OptionalTest, NotEquals) { | |
| 1068 { | |
| 1069 Optional<float> a(0.1f); | |
| 1070 Optional<float> b(0.2f); | |
| 1071 EXPECT_NE(a, b); | |
| 1072 } | |
| 1073 | |
| 1074 { | |
| 1075 Optional<std::string> a("foo"); | |
| 1076 Optional<std::string> b("bar"); | |
| 1077 EXPECT_NE(a, b); | |
| 1078 } | |
| 1079 | |
| 1080 { | |
| 1081 Optional<TestObject> a(TestObject(3, 0.1)); | |
| 1082 Optional<TestObject> b(TestObject(4, 1.0)); | |
| 1083 EXPECT_TRUE(a != b); | |
| 1084 } | |
| 1085 } | |
| 1086 | |
| 1087 TEST(OptionalTest, NotEqualsNull) { | |
| 1088 { | |
| 1089 Optional<float> a(0.1f); | |
| 1090 Optional<float> b(0.1f); | |
| 1091 b = base::nullopt; | |
| 1092 EXPECT_NE(a, b); | |
| 1093 } | |
| 1094 | |
| 1095 { | |
| 1096 Optional<std::string> a("foo"); | |
| 1097 Optional<std::string> b("foo"); | |
| 1098 b = base::nullopt; | |
| 1099 EXPECT_NE(a, b); | |
| 1100 } | |
| 1101 | |
| 1102 { | |
| 1103 Optional<TestObject> a(TestObject(3, 0.1)); | |
| 1104 Optional<TestObject> b(TestObject(3, 0.1)); | |
| 1105 b = base::nullopt; | |
| 1106 EXPECT_TRUE(a != b); | |
| 1107 } | |
| 1108 } | |
| 1109 | |
| 1110 TEST(OptionalTest, MakeOptional) { | |
| 1111 { | |
| 1112 Optional<float> o = base::make_optional(32.f); | |
| 1113 EXPECT_TRUE(o); | |
| 1114 EXPECT_EQ(32.f, *o); | |
| 1115 | |
| 1116 float value = 3.f; | |
| 1117 o = base::make_optional(std::move(value)); | |
| 1118 EXPECT_TRUE(o); | |
| 1119 EXPECT_EQ(3.f, *o); | |
| 1120 } | |
| 1121 | |
| 1122 { | |
| 1123 Optional<const char*> o = base::make_optional("foo"); | |
| 1124 EXPECT_TRUE(o); | |
| 1125 EXPECT_EQ("foo", *o); | |
| 1126 | |
| 1127 const char* value = "bar"; | |
| 1128 o = base::make_optional(std::move(value)); | |
| 1129 EXPECT_TRUE(o); | |
| 1130 EXPECT_EQ("bar", *o); | |
| 1131 } | |
| 1132 | |
| 1133 { | |
| 1134 Optional<TestObject> o = base::make_optional(TestObject(3, 0.1)); | |
| 1135 EXPECT_TRUE(!!o); | |
| 1136 EXPECT_TRUE(TestObject(3, 0.1) == *o); | |
| 1137 | |
| 1138 TestObject value = TestObject(0, 0.42); | |
| 1139 o = base::make_optional(std::move(value)); | |
| 1140 EXPECT_TRUE(!!o); | |
| 1141 EXPECT_TRUE(TestObject(0, 0.42) == *o); | |
| 1142 EXPECT_EQ(TestObject::State::MOVED_FROM, value.state()); | |
| 1143 EXPECT_EQ(TestObject::State::COPY_CONSTRUCTED, o->state()); | |
| 1144 | |
| 1145 EXPECT_EQ(TestObject::State::MOVE_CONSTRUCTED, | |
| 1146 base::make_optional(std::move(value))->state()); | |
| 1147 } | |
| 1148 } | |
| 1149 | |
| 1150 TEST(OptionalTest, NonMemberSwap_bothNoValue) { | |
| 1151 Optional<TestObject> a, b; | |
| 1152 base::swap(a, b); | |
| 1153 | |
| 1154 EXPECT_FALSE(!!a); | |
| 1155 EXPECT_FALSE(!!b); | |
| 1156 EXPECT_TRUE(TestObject(42, 0.42) == a.value_or(TestObject(42, 0.42))); | |
| 1157 EXPECT_TRUE(TestObject(42, 0.42) == b.value_or(TestObject(42, 0.42))); | |
| 1158 } | |
| 1159 | |
| 1160 TEST(OptionalTest, NonMemberSwap_inHasValue) { | |
| 1161 Optional<TestObject> a(TestObject(1, 0.3)); | |
| 1162 Optional<TestObject> b; | |
| 1163 base::swap(a, b); | |
| 1164 | |
| 1165 EXPECT_FALSE(!!a); | |
| 1166 EXPECT_TRUE(!!b); | |
| 1167 EXPECT_TRUE(TestObject(42, 0.42) == a.value_or(TestObject(42, 0.42))); | |
| 1168 EXPECT_TRUE(TestObject(1, 0.3) == b.value_or(TestObject(42, 0.42))); | |
| 1169 } | |
| 1170 | |
| 1171 TEST(OptionalTest, NonMemberSwap_outHasValue) { | |
| 1172 Optional<TestObject> a; | |
| 1173 Optional<TestObject> b(TestObject(1, 0.3)); | |
| 1174 base::swap(a, b); | |
| 1175 | |
| 1176 EXPECT_TRUE(!!a); | |
| 1177 EXPECT_FALSE(!!b); | |
| 1178 EXPECT_TRUE(TestObject(1, 0.3) == a.value_or(TestObject(42, 0.42))); | |
| 1179 EXPECT_TRUE(TestObject(42, 0.42) == b.value_or(TestObject(42, 0.42))); | |
| 1180 } | |
| 1181 | |
| 1182 TEST(OptionalTest, NonMemberSwap_bothValue) { | |
| 1183 Optional<TestObject> a(TestObject(0, 0.1)); | |
| 1184 Optional<TestObject> b(TestObject(1, 0.3)); | |
| 1185 base::swap(a, b); | |
| 1186 | |
| 1187 EXPECT_TRUE(!!a); | |
| 1188 EXPECT_TRUE(!!b); | |
| 1189 EXPECT_TRUE(TestObject(1, 0.3) == a.value_or(TestObject(42, 0.42))); | |
| 1190 EXPECT_TRUE(TestObject(0, 0.1) == b.value_or(TestObject(42, 0.42))); | |
| 1191 } | |
| 1192 | |
| 1193 TEST(OptionalTest, Hash_OptionalReflectsInternal) { | |
| 1194 { | |
| 1195 std::hash<int> int_hash; | |
| 1196 std::hash<Optional<int>> opt_int_hash; | |
| 1197 | |
| 1198 EXPECT_EQ(int_hash(1), opt_int_hash(Optional<int>(1))); | |
| 1199 } | |
| 1200 | |
| 1201 { | |
| 1202 std::hash<std::string> str_hash; | |
| 1203 std::hash<Optional<std::string>> opt_str_hash; | |
| 1204 | |
| 1205 EXPECT_EQ(str_hash(std::string("foobar")), | |
| 1206 opt_str_hash(Optional<std::string>(std::string("foobar")))); | |
| 1207 } | |
| 1208 } | |
| 1209 | |
| 1210 TEST(OptionalTest, Hash_NullOptEqualsNullOpt) { | |
| 1211 std::hash<Optional<int>> opt_int_hash; | |
| 1212 std::hash<Optional<std::string>> opt_str_hash; | |
| 1213 | |
| 1214 EXPECT_EQ(opt_str_hash(Optional<std::string>()), | |
| 1215 opt_int_hash(Optional<int>())); | |
| 1216 } | |
| 1217 | |
| 1218 TEST(OptionalTest, Hash_UseInSet) { | |
| 1219 std::set<Optional<int>> setOptInt; | |
| 1220 | |
| 1221 EXPECT_EQ(setOptInt.end(), setOptInt.find(42)); | |
| 1222 | |
| 1223 setOptInt.insert(Optional<int>(3)); | |
| 1224 EXPECT_EQ(setOptInt.end(), setOptInt.find(42)); | |
| 1225 EXPECT_NE(setOptInt.end(), setOptInt.find(3)); | |
| 1226 } | |
| 1227 | |
| 1228 } // namespace base | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1902833002:
Revert of Base: add Optional<T>. (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master