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