optional_unittest.cc 51 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189219021912192219321942195219621972198219922002201220222032204220522062207220822092210221122122213221422152216221722182219222022212222222322242225222622272228222922302231223222332234223522362237223822392240224122422243224422452246224722482249225022512252225322542255225622572258225922602261226222632264
  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. #include <memory>
  5. #include <set>
  6. #include <string>
  7. #include <type_traits>
  8. #include <vector>
  9. #include "base/template_util.h"
  10. #include "base/test/gtest_util.h"
  11. #include "testing/gmock/include/gmock/gmock.h"
  12. #include "testing/gtest/include/gtest/gtest.h"
  13. #include "third_party/abseil-cpp/absl/types/optional.h"
  14. #include "third_party/abseil-cpp/absl/utility/utility.h"
  15. using ::testing::ElementsAre;
  16. namespace base {
  17. namespace {
  18. // Object used to test complex object with absl::optional<T> in addition of the
  19. // move semantics.
  20. class TestObject {
  21. public:
  22. enum class State {
  23. DEFAULT_CONSTRUCTED,
  24. VALUE_CONSTRUCTED,
  25. COPY_CONSTRUCTED,
  26. MOVE_CONSTRUCTED,
  27. MOVED_FROM,
  28. COPY_ASSIGNED,
  29. MOVE_ASSIGNED,
  30. SWAPPED,
  31. };
  32. TestObject() : foo_(0), bar_(0.0), state_(State::DEFAULT_CONSTRUCTED) {}
  33. TestObject(int foo, double bar)
  34. : foo_(foo), bar_(bar), state_(State::VALUE_CONSTRUCTED) {}
  35. TestObject(const TestObject& other)
  36. : foo_(other.foo_),
  37. bar_(other.bar_),
  38. state_(State::COPY_CONSTRUCTED),
  39. move_ctors_count_(other.move_ctors_count_) {}
  40. TestObject(TestObject&& other)
  41. : foo_(std::move(other.foo_)),
  42. bar_(std::move(other.bar_)),
  43. state_(State::MOVE_CONSTRUCTED),
  44. move_ctors_count_(other.move_ctors_count_ + 1) {
  45. other.state_ = State::MOVED_FROM;
  46. }
  47. TestObject& operator=(const TestObject& other) {
  48. foo_ = other.foo_;
  49. bar_ = other.bar_;
  50. state_ = State::COPY_ASSIGNED;
  51. move_ctors_count_ = other.move_ctors_count_;
  52. return *this;
  53. }
  54. TestObject& operator=(TestObject&& other) {
  55. foo_ = other.foo_;
  56. bar_ = other.bar_;
  57. state_ = State::MOVE_ASSIGNED;
  58. move_ctors_count_ = other.move_ctors_count_;
  59. other.state_ = State::MOVED_FROM;
  60. return *this;
  61. }
  62. void Swap(TestObject* other) {
  63. using std::swap;
  64. swap(foo_, other->foo_);
  65. swap(bar_, other->bar_);
  66. swap(move_ctors_count_, other->move_ctors_count_);
  67. state_ = State::SWAPPED;
  68. other->state_ = State::SWAPPED;
  69. }
  70. bool operator==(const TestObject& other) const {
  71. return std::tie(foo_, bar_) == std::tie(other.foo_, other.bar_);
  72. }
  73. bool operator!=(const TestObject& other) const { return !(*this == other); }
  74. int foo() const { return foo_; }
  75. State state() const { return state_; }
  76. int move_ctors_count() const { return move_ctors_count_; }
  77. private:
  78. int foo_;
  79. double bar_;
  80. State state_;
  81. int move_ctors_count_ = 0;
  82. };
  83. // Implementing Swappable concept.
  84. void swap(TestObject& lhs, TestObject& rhs) {
  85. lhs.Swap(&rhs);
  86. }
  87. class NonTriviallyDestructible {
  88. public:
  89. ~NonTriviallyDestructible() {}
  90. };
  91. class DeletedDefaultConstructor {
  92. public:
  93. DeletedDefaultConstructor() = delete;
  94. DeletedDefaultConstructor(int foo) : foo_(foo) {}
  95. int foo() const { return foo_; }
  96. private:
  97. int foo_;
  98. };
  99. class DeletedCopy {
  100. public:
  101. explicit DeletedCopy(int foo) : foo_(foo) {}
  102. DeletedCopy(const DeletedCopy&) = delete;
  103. DeletedCopy(DeletedCopy&&) = default;
  104. DeletedCopy& operator=(const DeletedCopy&) = delete;
  105. DeletedCopy& operator=(DeletedCopy&&) = default;
  106. int foo() const { return foo_; }
  107. private:
  108. int foo_;
  109. };
  110. class DeletedMove {
  111. public:
  112. explicit DeletedMove(int foo) : foo_(foo) {}
  113. DeletedMove(const DeletedMove&) = default;
  114. DeletedMove(DeletedMove&&) = delete;
  115. DeletedMove& operator=(const DeletedMove&) = default;
  116. DeletedMove& operator=(DeletedMove&&) = delete;
  117. int foo() const { return foo_; }
  118. private:
  119. int foo_;
  120. };
  121. class NonTriviallyDestructibleDeletedCopyConstructor {
  122. public:
  123. explicit NonTriviallyDestructibleDeletedCopyConstructor(int foo)
  124. : foo_(foo) {}
  125. NonTriviallyDestructibleDeletedCopyConstructor(
  126. const NonTriviallyDestructibleDeletedCopyConstructor&) = delete;
  127. NonTriviallyDestructibleDeletedCopyConstructor(
  128. NonTriviallyDestructibleDeletedCopyConstructor&&) = default;
  129. ~NonTriviallyDestructibleDeletedCopyConstructor() {}
  130. int foo() const { return foo_; }
  131. private:
  132. int foo_;
  133. };
  134. class DeleteNewOperators {
  135. public:
  136. void* operator new(size_t) = delete;
  137. void* operator new(size_t, void*) = delete;
  138. void* operator new[](size_t) = delete;
  139. void* operator new[](size_t, void*) = delete;
  140. };
  141. class TriviallyDestructibleOverloadAddressOf {
  142. public:
  143. // Unfortunately, since this can be called as part of placement-new (if it
  144. // forgets to call std::addressof), we're uninitialized. So, about the best
  145. // we can do is signal a test failure here if either operator& is called.
  146. TriviallyDestructibleOverloadAddressOf* operator&() {
  147. EXPECT_TRUE(false);
  148. return this;
  149. }
  150. // So we can test the const version of operator->.
  151. const TriviallyDestructibleOverloadAddressOf* operator&() const {
  152. EXPECT_TRUE(false);
  153. return this;
  154. }
  155. void const_method() const {}
  156. void nonconst_method() {}
  157. };
  158. class NonTriviallyDestructibleOverloadAddressOf {
  159. public:
  160. ~NonTriviallyDestructibleOverloadAddressOf() {}
  161. NonTriviallyDestructibleOverloadAddressOf* operator&() {
  162. EXPECT_TRUE(false);
  163. return this;
  164. }
  165. };
  166. } // anonymous namespace
  167. static_assert(std::is_trivially_destructible<absl::optional<int>>::value,
  168. "OptionalIsTriviallyDestructible");
  169. static_assert(!std::is_trivially_destructible<
  170. absl::optional<NonTriviallyDestructible>>::value,
  171. "OptionalIsTriviallyDestructible");
  172. TEST(OptionalTest, DefaultConstructor) {
  173. {
  174. constexpr absl::optional<float> o;
  175. EXPECT_FALSE(o);
  176. }
  177. {
  178. absl::optional<std::string> o;
  179. EXPECT_FALSE(o);
  180. }
  181. {
  182. absl::optional<TestObject> o;
  183. EXPECT_FALSE(o);
  184. }
  185. }
  186. TEST(OptionalTest, CopyConstructor) {
  187. {
  188. constexpr absl::optional<float> first(0.1f);
  189. constexpr absl::optional<float> other(first);
  190. EXPECT_TRUE(other);
  191. EXPECT_EQ(other.value(), 0.1f);
  192. EXPECT_EQ(first, other);
  193. }
  194. {
  195. absl::optional<std::string> first("foo");
  196. absl::optional<std::string> other(first);
  197. EXPECT_TRUE(other);
  198. EXPECT_EQ(other.value(), "foo");
  199. EXPECT_EQ(first, other);
  200. }
  201. {
  202. const absl::optional<std::string> first("foo");
  203. absl::optional<std::string> other(first);
  204. EXPECT_TRUE(other);
  205. EXPECT_EQ(other.value(), "foo");
  206. EXPECT_EQ(first, other);
  207. }
  208. {
  209. absl::optional<TestObject> first(TestObject(3, 0.1));
  210. absl::optional<TestObject> other(first);
  211. EXPECT_TRUE(!!other);
  212. EXPECT_TRUE(other.value() == TestObject(3, 0.1));
  213. EXPECT_TRUE(first == other);
  214. }
  215. }
  216. TEST(OptionalTest, ValueConstructor) {
  217. {
  218. constexpr float value = 0.1f;
  219. constexpr absl::optional<float> o(value);
  220. EXPECT_TRUE(o);
  221. EXPECT_EQ(value, o.value());
  222. }
  223. {
  224. std::string value("foo");
  225. absl::optional<std::string> o(value);
  226. EXPECT_TRUE(o);
  227. EXPECT_EQ(value, o.value());
  228. }
  229. {
  230. TestObject value(3, 0.1);
  231. absl::optional<TestObject> o(value);
  232. EXPECT_TRUE(o);
  233. EXPECT_EQ(TestObject::State::COPY_CONSTRUCTED, o->state());
  234. EXPECT_EQ(value, o.value());
  235. }
  236. }
  237. TEST(OptionalTest, MoveConstructor) {
  238. {
  239. constexpr absl::optional<float> first(0.1f);
  240. constexpr absl::optional<float> second(std::move(first));
  241. EXPECT_TRUE(second.has_value());
  242. EXPECT_EQ(second.value(), 0.1f);
  243. EXPECT_TRUE(first.has_value());
  244. }
  245. {
  246. absl::optional<std::string> first("foo");
  247. absl::optional<std::string> second(std::move(first));
  248. EXPECT_TRUE(second.has_value());
  249. EXPECT_EQ("foo", second.value());
  250. EXPECT_TRUE(first.has_value());
  251. }
  252. {
  253. absl::optional<TestObject> first(TestObject(3, 0.1));
  254. absl::optional<TestObject> second(std::move(first));
  255. EXPECT_TRUE(second.has_value());
  256. EXPECT_EQ(TestObject::State::MOVE_CONSTRUCTED, second->state());
  257. EXPECT_TRUE(TestObject(3, 0.1) == second.value());
  258. EXPECT_TRUE(first.has_value());
  259. EXPECT_EQ(TestObject::State::MOVED_FROM, first->state());
  260. }
  261. // Even if copy constructor is deleted, move constructor needs to work.
  262. // Note that it couldn't be constexpr.
  263. {
  264. absl::optional<DeletedCopy> first(absl::in_place, 42);
  265. absl::optional<DeletedCopy> second(std::move(first));
  266. EXPECT_TRUE(second.has_value());
  267. EXPECT_EQ(42, second->foo());
  268. EXPECT_TRUE(first.has_value());
  269. }
  270. {
  271. absl::optional<DeletedMove> first(absl::in_place, 42);
  272. absl::optional<DeletedMove> second(std::move(first));
  273. EXPECT_TRUE(second.has_value());
  274. EXPECT_EQ(42, second->foo());
  275. EXPECT_TRUE(first.has_value());
  276. }
  277. {
  278. absl::optional<NonTriviallyDestructibleDeletedCopyConstructor> first(
  279. absl::in_place, 42);
  280. absl::optional<NonTriviallyDestructibleDeletedCopyConstructor> second(
  281. std::move(first));
  282. EXPECT_TRUE(second.has_value());
  283. EXPECT_EQ(42, second->foo());
  284. EXPECT_TRUE(first.has_value());
  285. }
  286. }
  287. TEST(OptionalTest, MoveValueConstructor) {
  288. {
  289. constexpr float value = 0.1f;
  290. constexpr absl::optional<float> o(std::move(value));
  291. EXPECT_TRUE(o);
  292. EXPECT_EQ(0.1f, o.value());
  293. }
  294. {
  295. float value = 0.1f;
  296. absl::optional<float> o(std::move(value));
  297. EXPECT_TRUE(o);
  298. EXPECT_EQ(0.1f, o.value());
  299. }
  300. {
  301. std::string value("foo");
  302. absl::optional<std::string> o(std::move(value));
  303. EXPECT_TRUE(o);
  304. EXPECT_EQ("foo", o.value());
  305. }
  306. {
  307. TestObject value(3, 0.1);
  308. absl::optional<TestObject> o(std::move(value));
  309. EXPECT_TRUE(o);
  310. EXPECT_EQ(TestObject::State::MOVE_CONSTRUCTED, o->state());
  311. EXPECT_EQ(TestObject(3, 0.1), o.value());
  312. }
  313. }
  314. TEST(OptionalTest, ConvertingCopyConstructor) {
  315. {
  316. absl::optional<int> first(1);
  317. absl::optional<double> second(first);
  318. EXPECT_TRUE(second.has_value());
  319. EXPECT_EQ(1.0, second.value());
  320. }
  321. // Make sure explicit is not marked for convertible case.
  322. {
  323. [[maybe_unused]] absl::optional<int> o(1);
  324. }
  325. }
  326. TEST(OptionalTest, ConvertingMoveConstructor) {
  327. {
  328. absl::optional<int> first(1);
  329. absl::optional<double> second(std::move(first));
  330. EXPECT_TRUE(second.has_value());
  331. EXPECT_EQ(1.0, second.value());
  332. }
  333. // Make sure explicit is not marked for convertible case.
  334. {
  335. [[maybe_unused]] absl::optional<int> o(1);
  336. }
  337. {
  338. class Test1 {
  339. public:
  340. explicit Test1(int foo) : foo_(foo) {}
  341. int foo() const { return foo_; }
  342. private:
  343. int foo_;
  344. };
  345. // Not copyable but convertible from Test1.
  346. class Test2 {
  347. public:
  348. Test2(const Test2&) = delete;
  349. explicit Test2(Test1&& other) : bar_(other.foo()) {}
  350. double bar() const { return bar_; }
  351. private:
  352. double bar_;
  353. };
  354. absl::optional<Test1> first(absl::in_place, 42);
  355. absl::optional<Test2> second(std::move(first));
  356. EXPECT_TRUE(second.has_value());
  357. EXPECT_EQ(42.0, second->bar());
  358. }
  359. }
  360. TEST(OptionalTest, ConstructorForwardArguments) {
  361. {
  362. constexpr absl::optional<float> a(absl::in_place, 0.1f);
  363. EXPECT_TRUE(a);
  364. EXPECT_EQ(0.1f, a.value());
  365. }
  366. {
  367. absl::optional<float> a(absl::in_place, 0.1f);
  368. EXPECT_TRUE(a);
  369. EXPECT_EQ(0.1f, a.value());
  370. }
  371. {
  372. absl::optional<std::string> a(absl::in_place, "foo");
  373. EXPECT_TRUE(a);
  374. EXPECT_EQ("foo", a.value());
  375. }
  376. {
  377. absl::optional<TestObject> a(absl::in_place, 0, 0.1);
  378. EXPECT_TRUE(!!a);
  379. EXPECT_TRUE(TestObject(0, 0.1) == a.value());
  380. }
  381. }
  382. TEST(OptionalTest, ConstructorForwardInitListAndArguments) {
  383. {
  384. absl::optional<std::vector<int>> opt(absl::in_place, {3, 1});
  385. EXPECT_TRUE(opt);
  386. EXPECT_THAT(*opt, ElementsAre(3, 1));
  387. EXPECT_EQ(2u, opt->size());
  388. }
  389. {
  390. absl::optional<std::vector<int>> opt(absl::in_place, {3, 1},
  391. std::allocator<int>());
  392. EXPECT_TRUE(opt);
  393. EXPECT_THAT(*opt, ElementsAre(3, 1));
  394. EXPECT_EQ(2u, opt->size());
  395. }
  396. }
  397. TEST(OptionalTest, ForwardConstructor) {
  398. {
  399. absl::optional<double> a(1);
  400. EXPECT_TRUE(a.has_value());
  401. EXPECT_EQ(1.0, a.value());
  402. }
  403. // Test that default type of 'U' is value_type.
  404. {
  405. struct TestData {
  406. int a;
  407. double b;
  408. bool c;
  409. };
  410. absl::optional<TestData> a({1, 2.0, true});
  411. EXPECT_TRUE(a.has_value());
  412. EXPECT_EQ(1, a->a);
  413. EXPECT_EQ(2.0, a->b);
  414. EXPECT_TRUE(a->c);
  415. }
  416. // If T has a constructor with a param absl::optional<U>, and another ctor
  417. // with a param U, then T(absl::optional<U>) should be used for
  418. // absl::optional<T>(absl::optional<U>) constructor.
  419. {
  420. enum class ParamType {
  421. DEFAULT_CONSTRUCTED,
  422. COPY_CONSTRUCTED,
  423. MOVE_CONSTRUCTED,
  424. INT,
  425. IN_PLACE,
  426. OPTIONAL_INT,
  427. };
  428. struct Test {
  429. Test() : param_type(ParamType::DEFAULT_CONSTRUCTED) {}
  430. Test(const Test& param) : param_type(ParamType::COPY_CONSTRUCTED) {}
  431. Test(Test&& param) : param_type(ParamType::MOVE_CONSTRUCTED) {}
  432. explicit Test(int param) : param_type(ParamType::INT) {}
  433. explicit Test(absl::in_place_t param) : param_type(ParamType::IN_PLACE) {}
  434. explicit Test(absl::optional<int> param)
  435. : param_type(ParamType::OPTIONAL_INT) {}
  436. ParamType param_type;
  437. };
  438. // Overload resolution with copy-conversion constructor.
  439. {
  440. const absl::optional<int> arg(absl::in_place, 1);
  441. absl::optional<Test> testee(arg);
  442. EXPECT_EQ(ParamType::OPTIONAL_INT, testee->param_type);
  443. }
  444. // Overload resolution with move conversion constructor.
  445. {
  446. absl::optional<Test> testee(absl::optional<int>(absl::in_place, 1));
  447. EXPECT_EQ(ParamType::OPTIONAL_INT, testee->param_type);
  448. }
  449. // Default constructor should be used.
  450. {
  451. absl::optional<Test> testee(absl::in_place);
  452. EXPECT_EQ(ParamType::DEFAULT_CONSTRUCTED, testee->param_type);
  453. }
  454. }
  455. {
  456. struct Test {
  457. Test(int a) {} // NOLINT(runtime/explicit)
  458. };
  459. // If T is convertible from U, it is not marked as explicit.
  460. static_assert(std::is_convertible<int, Test>::value,
  461. "Int should be convertible to Test.");
  462. ([](absl::optional<Test> param) {})(1);
  463. }
  464. }
  465. TEST(OptionalTest, NulloptConstructor) {
  466. constexpr absl::optional<int> a(absl::nullopt);
  467. EXPECT_FALSE(a);
  468. }
  469. TEST(OptionalTest, AssignValue) {
  470. {
  471. absl::optional<float> a;
  472. EXPECT_FALSE(a);
  473. a = 0.1f;
  474. EXPECT_TRUE(a);
  475. absl::optional<float> b(0.1f);
  476. EXPECT_TRUE(a == b);
  477. }
  478. {
  479. absl::optional<std::string> a;
  480. EXPECT_FALSE(a);
  481. a = std::string("foo");
  482. EXPECT_TRUE(a);
  483. absl::optional<std::string> b(std::string("foo"));
  484. EXPECT_EQ(a, b);
  485. }
  486. {
  487. absl::optional<TestObject> a;
  488. EXPECT_FALSE(!!a);
  489. a = TestObject(3, 0.1);
  490. EXPECT_TRUE(!!a);
  491. absl::optional<TestObject> b(TestObject(3, 0.1));
  492. EXPECT_TRUE(a == b);
  493. }
  494. {
  495. absl::optional<TestObject> a = TestObject(4, 1.0);
  496. EXPECT_TRUE(!!a);
  497. a = TestObject(3, 0.1);
  498. EXPECT_TRUE(!!a);
  499. absl::optional<TestObject> b(TestObject(3, 0.1));
  500. EXPECT_TRUE(a == b);
  501. }
  502. }
  503. TEST(OptionalTest, AssignObject) {
  504. {
  505. absl::optional<float> a;
  506. absl::optional<float> b(0.1f);
  507. a = b;
  508. EXPECT_TRUE(a);
  509. EXPECT_EQ(a.value(), 0.1f);
  510. EXPECT_EQ(a, b);
  511. }
  512. {
  513. absl::optional<std::string> a;
  514. absl::optional<std::string> b("foo");
  515. a = b;
  516. EXPECT_TRUE(a);
  517. EXPECT_EQ(a.value(), "foo");
  518. EXPECT_EQ(a, b);
  519. }
  520. {
  521. absl::optional<TestObject> a;
  522. absl::optional<TestObject> b(TestObject(3, 0.1));
  523. a = b;
  524. EXPECT_TRUE(!!a);
  525. EXPECT_TRUE(a.value() == TestObject(3, 0.1));
  526. EXPECT_TRUE(a == b);
  527. }
  528. {
  529. absl::optional<TestObject> a(TestObject(4, 1.0));
  530. absl::optional<TestObject> b(TestObject(3, 0.1));
  531. a = b;
  532. EXPECT_TRUE(!!a);
  533. EXPECT_TRUE(a.value() == TestObject(3, 0.1));
  534. EXPECT_TRUE(a == b);
  535. }
  536. {
  537. absl::optional<DeletedMove> a(absl::in_place, 42);
  538. absl::optional<DeletedMove> b;
  539. b = a;
  540. EXPECT_TRUE(!!a);
  541. EXPECT_TRUE(!!b);
  542. EXPECT_EQ(a->foo(), b->foo());
  543. }
  544. {
  545. absl::optional<DeletedMove> a(absl::in_place, 42);
  546. absl::optional<DeletedMove> b(absl::in_place, 1);
  547. b = a;
  548. EXPECT_TRUE(!!a);
  549. EXPECT_TRUE(!!b);
  550. EXPECT_EQ(a->foo(), b->foo());
  551. }
  552. // Converting assignment.
  553. {
  554. absl::optional<int> a(absl::in_place, 1);
  555. absl::optional<double> b;
  556. b = a;
  557. EXPECT_TRUE(!!a);
  558. EXPECT_TRUE(!!b);
  559. EXPECT_EQ(1, a.value());
  560. EXPECT_EQ(1.0, b.value());
  561. }
  562. {
  563. absl::optional<int> a(absl::in_place, 42);
  564. absl::optional<double> b(absl::in_place, 1);
  565. b = a;
  566. EXPECT_TRUE(!!a);
  567. EXPECT_TRUE(!!b);
  568. EXPECT_EQ(42, a.value());
  569. EXPECT_EQ(42.0, b.value());
  570. }
  571. {
  572. absl::optional<int> a;
  573. absl::optional<double> b(absl::in_place, 1);
  574. b = a;
  575. EXPECT_FALSE(!!a);
  576. EXPECT_FALSE(!!b);
  577. }
  578. }
  579. TEST(OptionalTest, AssignObject_rvalue) {
  580. {
  581. absl::optional<float> a;
  582. absl::optional<float> b(0.1f);
  583. a = std::move(b);
  584. EXPECT_TRUE(a);
  585. EXPECT_TRUE(b);
  586. EXPECT_EQ(0.1f, a.value());
  587. }
  588. {
  589. absl::optional<std::string> a;
  590. absl::optional<std::string> b("foo");
  591. a = std::move(b);
  592. EXPECT_TRUE(a);
  593. EXPECT_TRUE(b);
  594. EXPECT_EQ("foo", a.value());
  595. }
  596. {
  597. absl::optional<TestObject> a;
  598. absl::optional<TestObject> b(TestObject(3, 0.1));
  599. a = std::move(b);
  600. EXPECT_TRUE(!!a);
  601. EXPECT_TRUE(!!b);
  602. EXPECT_TRUE(TestObject(3, 0.1) == a.value());
  603. EXPECT_EQ(TestObject::State::MOVE_CONSTRUCTED, a->state());
  604. EXPECT_EQ(TestObject::State::MOVED_FROM, b->state());
  605. }
  606. {
  607. absl::optional<TestObject> a(TestObject(4, 1.0));
  608. absl::optional<TestObject> b(TestObject(3, 0.1));
  609. a = std::move(b);
  610. EXPECT_TRUE(!!a);
  611. EXPECT_TRUE(!!b);
  612. EXPECT_TRUE(TestObject(3, 0.1) == a.value());
  613. EXPECT_EQ(TestObject::State::MOVE_ASSIGNED, a->state());
  614. EXPECT_EQ(TestObject::State::MOVED_FROM, b->state());
  615. }
  616. {
  617. absl::optional<DeletedMove> a(absl::in_place, 42);
  618. absl::optional<DeletedMove> b;
  619. b = std::move(a);
  620. EXPECT_TRUE(!!a);
  621. EXPECT_TRUE(!!b);
  622. EXPECT_EQ(42, b->foo());
  623. }
  624. {
  625. absl::optional<DeletedMove> a(absl::in_place, 42);
  626. absl::optional<DeletedMove> b(absl::in_place, 1);
  627. b = std::move(a);
  628. EXPECT_TRUE(!!a);
  629. EXPECT_TRUE(!!b);
  630. EXPECT_EQ(42, b->foo());
  631. }
  632. // Converting assignment.
  633. {
  634. absl::optional<int> a(absl::in_place, 1);
  635. absl::optional<double> b;
  636. b = std::move(a);
  637. EXPECT_TRUE(!!a);
  638. EXPECT_TRUE(!!b);
  639. EXPECT_EQ(1.0, b.value());
  640. }
  641. {
  642. absl::optional<int> a(absl::in_place, 42);
  643. absl::optional<double> b(absl::in_place, 1);
  644. b = std::move(a);
  645. EXPECT_TRUE(!!a);
  646. EXPECT_TRUE(!!b);
  647. EXPECT_EQ(42.0, b.value());
  648. }
  649. {
  650. absl::optional<int> a;
  651. absl::optional<double> b(absl::in_place, 1);
  652. b = std::move(a);
  653. EXPECT_FALSE(!!a);
  654. EXPECT_FALSE(!!b);
  655. }
  656. }
  657. TEST(OptionalTest, AssignNull) {
  658. {
  659. absl::optional<float> a(0.1f);
  660. absl::optional<float> b(0.2f);
  661. a = absl::nullopt;
  662. b = absl::nullopt;
  663. EXPECT_EQ(a, b);
  664. }
  665. {
  666. absl::optional<std::string> a("foo");
  667. absl::optional<std::string> b("bar");
  668. a = absl::nullopt;
  669. b = absl::nullopt;
  670. EXPECT_EQ(a, b);
  671. }
  672. {
  673. absl::optional<TestObject> a(TestObject(3, 0.1));
  674. absl::optional<TestObject> b(TestObject(4, 1.0));
  675. a = absl::nullopt;
  676. b = absl::nullopt;
  677. EXPECT_TRUE(a == b);
  678. }
  679. }
  680. TEST(OptionalTest, AssignOverload) {
  681. struct Test1 {
  682. enum class State {
  683. CONSTRUCTED,
  684. MOVED,
  685. };
  686. State state = State::CONSTRUCTED;
  687. };
  688. // Here, absl::optional<Test2> can be assigned from absl::optional<Test1>. In
  689. // case of move, marks MOVED to Test1 instance.
  690. struct Test2 {
  691. enum class State {
  692. DEFAULT_CONSTRUCTED,
  693. COPY_CONSTRUCTED_FROM_TEST1,
  694. MOVE_CONSTRUCTED_FROM_TEST1,
  695. COPY_ASSIGNED_FROM_TEST1,
  696. MOVE_ASSIGNED_FROM_TEST1,
  697. };
  698. Test2() = default;
  699. explicit Test2(const Test1& test1)
  700. : state(State::COPY_CONSTRUCTED_FROM_TEST1) {}
  701. explicit Test2(Test1&& test1) : state(State::MOVE_CONSTRUCTED_FROM_TEST1) {
  702. test1.state = Test1::State::MOVED;
  703. }
  704. Test2& operator=(const Test1& test1) {
  705. state = State::COPY_ASSIGNED_FROM_TEST1;
  706. return *this;
  707. }
  708. Test2& operator=(Test1&& test1) {
  709. state = State::MOVE_ASSIGNED_FROM_TEST1;
  710. test1.state = Test1::State::MOVED;
  711. return *this;
  712. }
  713. State state = State::DEFAULT_CONSTRUCTED;
  714. };
  715. {
  716. absl::optional<Test1> a(absl::in_place);
  717. absl::optional<Test2> b;
  718. b = a;
  719. EXPECT_TRUE(!!a);
  720. EXPECT_TRUE(!!b);
  721. EXPECT_EQ(Test1::State::CONSTRUCTED, a->state);
  722. EXPECT_EQ(Test2::State::COPY_CONSTRUCTED_FROM_TEST1, b->state);
  723. }
  724. {
  725. absl::optional<Test1> a(absl::in_place);
  726. absl::optional<Test2> b(absl::in_place);
  727. b = a;
  728. EXPECT_TRUE(!!a);
  729. EXPECT_TRUE(!!b);
  730. EXPECT_EQ(Test1::State::CONSTRUCTED, a->state);
  731. EXPECT_EQ(Test2::State::COPY_ASSIGNED_FROM_TEST1, b->state);
  732. }
  733. {
  734. absl::optional<Test1> a(absl::in_place);
  735. absl::optional<Test2> b;
  736. b = std::move(a);
  737. EXPECT_TRUE(!!a);
  738. EXPECT_TRUE(!!b);
  739. EXPECT_EQ(Test1::State::MOVED, a->state);
  740. EXPECT_EQ(Test2::State::MOVE_CONSTRUCTED_FROM_TEST1, b->state);
  741. }
  742. {
  743. absl::optional<Test1> a(absl::in_place);
  744. absl::optional<Test2> b(absl::in_place);
  745. b = std::move(a);
  746. EXPECT_TRUE(!!a);
  747. EXPECT_TRUE(!!b);
  748. EXPECT_EQ(Test1::State::MOVED, a->state);
  749. EXPECT_EQ(Test2::State::MOVE_ASSIGNED_FROM_TEST1, b->state);
  750. }
  751. // Similar to Test2, but Test3 also has copy/move ctor and assign operators
  752. // from absl::optional<Test1>, too. In this case, for a = b where a is
  753. // absl::optional<Test3> and b is absl::optional<Test1>,
  754. // absl::optional<T>::operator=(U&&) where U is absl::optional<Test1> should
  755. // be used rather than absl::optional<T>::operator=(absl::optional<U>&&) where
  756. // U is Test1.
  757. struct Test3 {
  758. enum class State {
  759. DEFAULT_CONSTRUCTED,
  760. COPY_CONSTRUCTED_FROM_TEST1,
  761. MOVE_CONSTRUCTED_FROM_TEST1,
  762. COPY_CONSTRUCTED_FROM_OPTIONAL_TEST1,
  763. MOVE_CONSTRUCTED_FROM_OPTIONAL_TEST1,
  764. COPY_ASSIGNED_FROM_TEST1,
  765. MOVE_ASSIGNED_FROM_TEST1,
  766. COPY_ASSIGNED_FROM_OPTIONAL_TEST1,
  767. MOVE_ASSIGNED_FROM_OPTIONAL_TEST1,
  768. };
  769. Test3() = default;
  770. explicit Test3(const Test1& test1)
  771. : state(State::COPY_CONSTRUCTED_FROM_TEST1) {}
  772. explicit Test3(Test1&& test1) : state(State::MOVE_CONSTRUCTED_FROM_TEST1) {
  773. test1.state = Test1::State::MOVED;
  774. }
  775. explicit Test3(const absl::optional<Test1>& test1)
  776. : state(State::COPY_CONSTRUCTED_FROM_OPTIONAL_TEST1) {}
  777. explicit Test3(absl::optional<Test1>&& test1)
  778. : state(State::MOVE_CONSTRUCTED_FROM_OPTIONAL_TEST1) {
  779. // In the following senarios, given |test1| should always have value.
  780. DCHECK(test1.has_value());
  781. test1->state = Test1::State::MOVED;
  782. }
  783. Test3& operator=(const Test1& test1) {
  784. state = State::COPY_ASSIGNED_FROM_TEST1;
  785. return *this;
  786. }
  787. Test3& operator=(Test1&& test1) {
  788. state = State::MOVE_ASSIGNED_FROM_TEST1;
  789. test1.state = Test1::State::MOVED;
  790. return *this;
  791. }
  792. Test3& operator=(const absl::optional<Test1>& test1) {
  793. state = State::COPY_ASSIGNED_FROM_OPTIONAL_TEST1;
  794. return *this;
  795. }
  796. Test3& operator=(absl::optional<Test1>&& test1) {
  797. state = State::MOVE_ASSIGNED_FROM_OPTIONAL_TEST1;
  798. // In the following senarios, given |test1| should always have value.
  799. DCHECK(test1.has_value());
  800. test1->state = Test1::State::MOVED;
  801. return *this;
  802. }
  803. State state = State::DEFAULT_CONSTRUCTED;
  804. };
  805. {
  806. absl::optional<Test1> a(absl::in_place);
  807. absl::optional<Test3> b;
  808. b = a;
  809. EXPECT_TRUE(!!a);
  810. EXPECT_TRUE(!!b);
  811. EXPECT_EQ(Test1::State::CONSTRUCTED, a->state);
  812. EXPECT_EQ(Test3::State::COPY_CONSTRUCTED_FROM_OPTIONAL_TEST1, b->state);
  813. }
  814. {
  815. absl::optional<Test1> a(absl::in_place);
  816. absl::optional<Test3> b(absl::in_place);
  817. b = a;
  818. EXPECT_TRUE(!!a);
  819. EXPECT_TRUE(!!b);
  820. EXPECT_EQ(Test1::State::CONSTRUCTED, a->state);
  821. EXPECT_EQ(Test3::State::COPY_ASSIGNED_FROM_OPTIONAL_TEST1, b->state);
  822. }
  823. {
  824. absl::optional<Test1> a(absl::in_place);
  825. absl::optional<Test3> b;
  826. b = std::move(a);
  827. EXPECT_TRUE(!!a);
  828. EXPECT_TRUE(!!b);
  829. EXPECT_EQ(Test1::State::MOVED, a->state);
  830. EXPECT_EQ(Test3::State::MOVE_CONSTRUCTED_FROM_OPTIONAL_TEST1, b->state);
  831. }
  832. {
  833. absl::optional<Test1> a(absl::in_place);
  834. absl::optional<Test3> b(absl::in_place);
  835. b = std::move(a);
  836. EXPECT_TRUE(!!a);
  837. EXPECT_TRUE(!!b);
  838. EXPECT_EQ(Test1::State::MOVED, a->state);
  839. EXPECT_EQ(Test3::State::MOVE_ASSIGNED_FROM_OPTIONAL_TEST1, b->state);
  840. }
  841. }
  842. TEST(OptionalTest, OperatorStar) {
  843. {
  844. absl::optional<float> a(0.1f);
  845. EXPECT_EQ(a.value(), *a);
  846. }
  847. {
  848. absl::optional<std::string> a("foo");
  849. EXPECT_EQ(a.value(), *a);
  850. }
  851. {
  852. absl::optional<TestObject> a(TestObject(3, 0.1));
  853. EXPECT_EQ(a.value(), *a);
  854. }
  855. }
  856. TEST(OptionalTest, OperatorStar_rvalue) {
  857. EXPECT_EQ(0.1f, *absl::optional<float>(0.1f));
  858. EXPECT_EQ(std::string("foo"), *absl::optional<std::string>("foo"));
  859. EXPECT_TRUE(TestObject(3, 0.1) ==
  860. *absl::optional<TestObject>(TestObject(3, 0.1)));
  861. }
  862. TEST(OptionalTest, OperatorArrow) {
  863. absl::optional<TestObject> a(TestObject(3, 0.1));
  864. EXPECT_EQ(a->foo(), 3);
  865. }
  866. TEST(OptionalTest, Value_rvalue) {
  867. EXPECT_EQ(0.1f, absl::optional<float>(0.1f).value());
  868. EXPECT_EQ(std::string("foo"), absl::optional<std::string>("foo").value());
  869. EXPECT_TRUE(TestObject(3, 0.1) ==
  870. absl::optional<TestObject>(TestObject(3, 0.1)).value());
  871. }
  872. TEST(OptionalTest, ValueOr) {
  873. {
  874. absl::optional<float> a;
  875. EXPECT_EQ(0.0f, a.value_or(0.0f));
  876. a = 0.1f;
  877. EXPECT_EQ(0.1f, a.value_or(0.0f));
  878. a = absl::nullopt;
  879. EXPECT_EQ(0.0f, a.value_or(0.0f));
  880. }
  881. // value_or() can be constexpr.
  882. {
  883. constexpr absl::optional<int> a(absl::in_place, 1);
  884. constexpr int value = a.value_or(10);
  885. EXPECT_EQ(1, value);
  886. }
  887. {
  888. constexpr absl::optional<int> a;
  889. constexpr int value = a.value_or(10);
  890. EXPECT_EQ(10, value);
  891. }
  892. {
  893. absl::optional<std::string> a;
  894. EXPECT_EQ("bar", a.value_or("bar"));
  895. a = std::string("foo");
  896. EXPECT_EQ(std::string("foo"), a.value_or("bar"));
  897. a = absl::nullopt;
  898. EXPECT_EQ(std::string("bar"), a.value_or("bar"));
  899. }
  900. {
  901. absl::optional<TestObject> a;
  902. EXPECT_TRUE(a.value_or(TestObject(1, 0.3)) == TestObject(1, 0.3));
  903. a = TestObject(3, 0.1);
  904. EXPECT_TRUE(a.value_or(TestObject(1, 0.3)) == TestObject(3, 0.1));
  905. a = absl::nullopt;
  906. EXPECT_TRUE(a.value_or(TestObject(1, 0.3)) == TestObject(1, 0.3));
  907. }
  908. }
  909. TEST(OptionalTest, Swap_bothNoValue) {
  910. absl::optional<TestObject> a, b;
  911. a.swap(b);
  912. EXPECT_FALSE(a);
  913. EXPECT_FALSE(b);
  914. EXPECT_TRUE(TestObject(42, 0.42) == a.value_or(TestObject(42, 0.42)));
  915. EXPECT_TRUE(TestObject(42, 0.42) == b.value_or(TestObject(42, 0.42)));
  916. }
  917. TEST(OptionalTest, Swap_inHasValue) {
  918. absl::optional<TestObject> a(TestObject(1, 0.3));
  919. absl::optional<TestObject> b;
  920. a.swap(b);
  921. EXPECT_FALSE(a);
  922. EXPECT_TRUE(!!b);
  923. EXPECT_TRUE(TestObject(42, 0.42) == a.value_or(TestObject(42, 0.42)));
  924. EXPECT_TRUE(TestObject(1, 0.3) == b.value_or(TestObject(42, 0.42)));
  925. }
  926. TEST(OptionalTest, Swap_outHasValue) {
  927. absl::optional<TestObject> a;
  928. absl::optional<TestObject> b(TestObject(1, 0.3));
  929. a.swap(b);
  930. EXPECT_TRUE(!!a);
  931. EXPECT_FALSE(!!b);
  932. EXPECT_TRUE(TestObject(1, 0.3) == a.value_or(TestObject(42, 0.42)));
  933. EXPECT_TRUE(TestObject(42, 0.42) == b.value_or(TestObject(42, 0.42)));
  934. }
  935. TEST(OptionalTest, Swap_bothValue) {
  936. absl::optional<TestObject> a(TestObject(0, 0.1));
  937. absl::optional<TestObject> b(TestObject(1, 0.3));
  938. a.swap(b);
  939. EXPECT_TRUE(!!a);
  940. EXPECT_TRUE(!!b);
  941. EXPECT_TRUE(TestObject(1, 0.3) == a.value_or(TestObject(42, 0.42)));
  942. EXPECT_TRUE(TestObject(0, 0.1) == b.value_or(TestObject(42, 0.42)));
  943. EXPECT_EQ(TestObject::State::SWAPPED, a->state());
  944. EXPECT_EQ(TestObject::State::SWAPPED, b->state());
  945. }
  946. TEST(OptionalTest, Emplace) {
  947. {
  948. absl::optional<float> a(0.1f);
  949. EXPECT_EQ(0.3f, a.emplace(0.3f));
  950. EXPECT_TRUE(a);
  951. EXPECT_EQ(0.3f, a.value());
  952. }
  953. {
  954. absl::optional<std::string> a("foo");
  955. EXPECT_EQ("bar", a.emplace("bar"));
  956. EXPECT_TRUE(a);
  957. EXPECT_EQ("bar", a.value());
  958. }
  959. {
  960. absl::optional<TestObject> a(TestObject(0, 0.1));
  961. EXPECT_EQ(TestObject(1, 0.2), a.emplace(TestObject(1, 0.2)));
  962. EXPECT_TRUE(!!a);
  963. EXPECT_TRUE(TestObject(1, 0.2) == a.value());
  964. }
  965. {
  966. absl::optional<std::vector<int>> a;
  967. auto& ref = a.emplace({2, 3});
  968. static_assert(std::is_same<std::vector<int>&, decltype(ref)>::value, "");
  969. EXPECT_TRUE(a);
  970. EXPECT_THAT(*a, ElementsAre(2, 3));
  971. EXPECT_EQ(&ref, &*a);
  972. }
  973. {
  974. absl::optional<std::vector<int>> a;
  975. auto& ref = a.emplace({4, 5}, std::allocator<int>());
  976. static_assert(std::is_same<std::vector<int>&, decltype(ref)>::value, "");
  977. EXPECT_TRUE(a);
  978. EXPECT_THAT(*a, ElementsAre(4, 5));
  979. EXPECT_EQ(&ref, &*a);
  980. }
  981. }
  982. TEST(OptionalTest, Equals_TwoEmpty) {
  983. absl::optional<int> a;
  984. absl::optional<int> b;
  985. EXPECT_TRUE(a == b);
  986. }
  987. TEST(OptionalTest, Equals_TwoEquals) {
  988. absl::optional<int> a(1);
  989. absl::optional<int> b(1);
  990. EXPECT_TRUE(a == b);
  991. }
  992. TEST(OptionalTest, Equals_OneEmpty) {
  993. absl::optional<int> a;
  994. absl::optional<int> b(1);
  995. EXPECT_FALSE(a == b);
  996. }
  997. TEST(OptionalTest, Equals_TwoDifferent) {
  998. absl::optional<int> a(0);
  999. absl::optional<int> b(1);
  1000. EXPECT_FALSE(a == b);
  1001. }
  1002. TEST(OptionalTest, Equals_DifferentType) {
  1003. absl::optional<int> a(0);
  1004. absl::optional<double> b(0);
  1005. EXPECT_TRUE(a == b);
  1006. }
  1007. TEST(OptionalTest, NotEquals_TwoEmpty) {
  1008. absl::optional<int> a;
  1009. absl::optional<int> b;
  1010. EXPECT_FALSE(a != b);
  1011. }
  1012. TEST(OptionalTest, NotEquals_TwoEquals) {
  1013. absl::optional<int> a(1);
  1014. absl::optional<int> b(1);
  1015. EXPECT_FALSE(a != b);
  1016. }
  1017. TEST(OptionalTest, NotEquals_OneEmpty) {
  1018. absl::optional<int> a;
  1019. absl::optional<int> b(1);
  1020. EXPECT_TRUE(a != b);
  1021. }
  1022. TEST(OptionalTest, NotEquals_TwoDifferent) {
  1023. absl::optional<int> a(0);
  1024. absl::optional<int> b(1);
  1025. EXPECT_TRUE(a != b);
  1026. }
  1027. TEST(OptionalTest, NotEquals_DifferentType) {
  1028. absl::optional<int> a(0);
  1029. absl::optional<double> b(0.0);
  1030. EXPECT_FALSE(a != b);
  1031. }
  1032. TEST(OptionalTest, Less_LeftEmpty) {
  1033. absl::optional<int> l;
  1034. absl::optional<int> r(1);
  1035. EXPECT_TRUE(l < r);
  1036. }
  1037. TEST(OptionalTest, Less_RightEmpty) {
  1038. absl::optional<int> l(1);
  1039. absl::optional<int> r;
  1040. EXPECT_FALSE(l < r);
  1041. }
  1042. TEST(OptionalTest, Less_BothEmpty) {
  1043. absl::optional<int> l;
  1044. absl::optional<int> r;
  1045. EXPECT_FALSE(l < r);
  1046. }
  1047. TEST(OptionalTest, Less_BothValues) {
  1048. {
  1049. absl::optional<int> l(1);
  1050. absl::optional<int> r(2);
  1051. EXPECT_TRUE(l < r);
  1052. }
  1053. {
  1054. absl::optional<int> l(2);
  1055. absl::optional<int> r(1);
  1056. EXPECT_FALSE(l < r);
  1057. }
  1058. {
  1059. absl::optional<int> l(1);
  1060. absl::optional<int> r(1);
  1061. EXPECT_FALSE(l < r);
  1062. }
  1063. }
  1064. TEST(OptionalTest, Less_DifferentType) {
  1065. absl::optional<int> l(1);
  1066. absl::optional<double> r(2.0);
  1067. EXPECT_TRUE(l < r);
  1068. }
  1069. TEST(OptionalTest, LessEq_LeftEmpty) {
  1070. absl::optional<int> l;
  1071. absl::optional<int> r(1);
  1072. EXPECT_TRUE(l <= r);
  1073. }
  1074. TEST(OptionalTest, LessEq_RightEmpty) {
  1075. absl::optional<int> l(1);
  1076. absl::optional<int> r;
  1077. EXPECT_FALSE(l <= r);
  1078. }
  1079. TEST(OptionalTest, LessEq_BothEmpty) {
  1080. absl::optional<int> l;
  1081. absl::optional<int> r;
  1082. EXPECT_TRUE(l <= r);
  1083. }
  1084. TEST(OptionalTest, LessEq_BothValues) {
  1085. {
  1086. absl::optional<int> l(1);
  1087. absl::optional<int> r(2);
  1088. EXPECT_TRUE(l <= r);
  1089. }
  1090. {
  1091. absl::optional<int> l(2);
  1092. absl::optional<int> r(1);
  1093. EXPECT_FALSE(l <= r);
  1094. }
  1095. {
  1096. absl::optional<int> l(1);
  1097. absl::optional<int> r(1);
  1098. EXPECT_TRUE(l <= r);
  1099. }
  1100. }
  1101. TEST(OptionalTest, LessEq_DifferentType) {
  1102. absl::optional<int> l(1);
  1103. absl::optional<double> r(2.0);
  1104. EXPECT_TRUE(l <= r);
  1105. }
  1106. TEST(OptionalTest, Greater_BothEmpty) {
  1107. absl::optional<int> l;
  1108. absl::optional<int> r;
  1109. EXPECT_FALSE(l > r);
  1110. }
  1111. TEST(OptionalTest, Greater_LeftEmpty) {
  1112. absl::optional<int> l;
  1113. absl::optional<int> r(1);
  1114. EXPECT_FALSE(l > r);
  1115. }
  1116. TEST(OptionalTest, Greater_RightEmpty) {
  1117. absl::optional<int> l(1);
  1118. absl::optional<int> r;
  1119. EXPECT_TRUE(l > r);
  1120. }
  1121. TEST(OptionalTest, Greater_BothValue) {
  1122. {
  1123. absl::optional<int> l(1);
  1124. absl::optional<int> r(2);
  1125. EXPECT_FALSE(l > r);
  1126. }
  1127. {
  1128. absl::optional<int> l(2);
  1129. absl::optional<int> r(1);
  1130. EXPECT_TRUE(l > r);
  1131. }
  1132. {
  1133. absl::optional<int> l(1);
  1134. absl::optional<int> r(1);
  1135. EXPECT_FALSE(l > r);
  1136. }
  1137. }
  1138. TEST(OptionalTest, Greater_DifferentType) {
  1139. absl::optional<int> l(1);
  1140. absl::optional<double> r(2.0);
  1141. EXPECT_FALSE(l > r);
  1142. }
  1143. TEST(OptionalTest, GreaterEq_BothEmpty) {
  1144. absl::optional<int> l;
  1145. absl::optional<int> r;
  1146. EXPECT_TRUE(l >= r);
  1147. }
  1148. TEST(OptionalTest, GreaterEq_LeftEmpty) {
  1149. absl::optional<int> l;
  1150. absl::optional<int> r(1);
  1151. EXPECT_FALSE(l >= r);
  1152. }
  1153. TEST(OptionalTest, GreaterEq_RightEmpty) {
  1154. absl::optional<int> l(1);
  1155. absl::optional<int> r;
  1156. EXPECT_TRUE(l >= r);
  1157. }
  1158. TEST(OptionalTest, GreaterEq_BothValue) {
  1159. {
  1160. absl::optional<int> l(1);
  1161. absl::optional<int> r(2);
  1162. EXPECT_FALSE(l >= r);
  1163. }
  1164. {
  1165. absl::optional<int> l(2);
  1166. absl::optional<int> r(1);
  1167. EXPECT_TRUE(l >= r);
  1168. }
  1169. {
  1170. absl::optional<int> l(1);
  1171. absl::optional<int> r(1);
  1172. EXPECT_TRUE(l >= r);
  1173. }
  1174. }
  1175. TEST(OptionalTest, GreaterEq_DifferentType) {
  1176. absl::optional<int> l(1);
  1177. absl::optional<double> r(2.0);
  1178. EXPECT_FALSE(l >= r);
  1179. }
  1180. TEST(OptionalTest, OptNullEq) {
  1181. {
  1182. absl::optional<int> opt;
  1183. EXPECT_TRUE(opt == absl::nullopt);
  1184. }
  1185. {
  1186. absl::optional<int> opt(1);
  1187. EXPECT_FALSE(opt == absl::nullopt);
  1188. }
  1189. }
  1190. TEST(OptionalTest, NullOptEq) {
  1191. {
  1192. absl::optional<int> opt;
  1193. EXPECT_TRUE(absl::nullopt == opt);
  1194. }
  1195. {
  1196. absl::optional<int> opt(1);
  1197. EXPECT_FALSE(absl::nullopt == opt);
  1198. }
  1199. }
  1200. TEST(OptionalTest, OptNullNotEq) {
  1201. {
  1202. absl::optional<int> opt;
  1203. EXPECT_FALSE(opt != absl::nullopt);
  1204. }
  1205. {
  1206. absl::optional<int> opt(1);
  1207. EXPECT_TRUE(opt != absl::nullopt);
  1208. }
  1209. }
  1210. TEST(OptionalTest, NullOptNotEq) {
  1211. {
  1212. absl::optional<int> opt;
  1213. EXPECT_FALSE(absl::nullopt != opt);
  1214. }
  1215. {
  1216. absl::optional<int> opt(1);
  1217. EXPECT_TRUE(absl::nullopt != opt);
  1218. }
  1219. }
  1220. TEST(OptionalTest, OptNullLower) {
  1221. {
  1222. absl::optional<int> opt;
  1223. EXPECT_FALSE(opt < absl::nullopt);
  1224. }
  1225. {
  1226. absl::optional<int> opt(1);
  1227. EXPECT_FALSE(opt < absl::nullopt);
  1228. }
  1229. }
  1230. TEST(OptionalTest, NullOptLower) {
  1231. {
  1232. absl::optional<int> opt;
  1233. EXPECT_FALSE(absl::nullopt < opt);
  1234. }
  1235. {
  1236. absl::optional<int> opt(1);
  1237. EXPECT_TRUE(absl::nullopt < opt);
  1238. }
  1239. }
  1240. TEST(OptionalTest, OptNullLowerEq) {
  1241. {
  1242. absl::optional<int> opt;
  1243. EXPECT_TRUE(opt <= absl::nullopt);
  1244. }
  1245. {
  1246. absl::optional<int> opt(1);
  1247. EXPECT_FALSE(opt <= absl::nullopt);
  1248. }
  1249. }
  1250. TEST(OptionalTest, NullOptLowerEq) {
  1251. {
  1252. absl::optional<int> opt;
  1253. EXPECT_TRUE(absl::nullopt <= opt);
  1254. }
  1255. {
  1256. absl::optional<int> opt(1);
  1257. EXPECT_TRUE(absl::nullopt <= opt);
  1258. }
  1259. }
  1260. TEST(OptionalTest, OptNullGreater) {
  1261. {
  1262. absl::optional<int> opt;
  1263. EXPECT_FALSE(opt > absl::nullopt);
  1264. }
  1265. {
  1266. absl::optional<int> opt(1);
  1267. EXPECT_TRUE(opt > absl::nullopt);
  1268. }
  1269. }
  1270. TEST(OptionalTest, NullOptGreater) {
  1271. {
  1272. absl::optional<int> opt;
  1273. EXPECT_FALSE(absl::nullopt > opt);
  1274. }
  1275. {
  1276. absl::optional<int> opt(1);
  1277. EXPECT_FALSE(absl::nullopt > opt);
  1278. }
  1279. }
  1280. TEST(OptionalTest, OptNullGreaterEq) {
  1281. {
  1282. absl::optional<int> opt;
  1283. EXPECT_TRUE(opt >= absl::nullopt);
  1284. }
  1285. {
  1286. absl::optional<int> opt(1);
  1287. EXPECT_TRUE(opt >= absl::nullopt);
  1288. }
  1289. }
  1290. TEST(OptionalTest, NullOptGreaterEq) {
  1291. {
  1292. absl::optional<int> opt;
  1293. EXPECT_TRUE(absl::nullopt >= opt);
  1294. }
  1295. {
  1296. absl::optional<int> opt(1);
  1297. EXPECT_FALSE(absl::nullopt >= opt);
  1298. }
  1299. }
  1300. TEST(OptionalTest, ValueEq_Empty) {
  1301. absl::optional<int> opt;
  1302. EXPECT_FALSE(opt == 1);
  1303. }
  1304. TEST(OptionalTest, ValueEq_NotEmpty) {
  1305. {
  1306. absl::optional<int> opt(0);
  1307. EXPECT_FALSE(opt == 1);
  1308. }
  1309. {
  1310. absl::optional<int> opt(1);
  1311. EXPECT_TRUE(opt == 1);
  1312. }
  1313. }
  1314. TEST(OptionalTest, ValueEq_DifferentType) {
  1315. absl::optional<int> opt(0);
  1316. EXPECT_TRUE(opt == 0.0);
  1317. }
  1318. TEST(OptionalTest, EqValue_Empty) {
  1319. absl::optional<int> opt;
  1320. EXPECT_FALSE(1 == opt);
  1321. }
  1322. TEST(OptionalTest, EqValue_NotEmpty) {
  1323. {
  1324. absl::optional<int> opt(0);
  1325. EXPECT_FALSE(1 == opt);
  1326. }
  1327. {
  1328. absl::optional<int> opt(1);
  1329. EXPECT_TRUE(1 == opt);
  1330. }
  1331. }
  1332. TEST(OptionalTest, EqValue_DifferentType) {
  1333. absl::optional<int> opt(0);
  1334. EXPECT_TRUE(0.0 == opt);
  1335. }
  1336. TEST(OptionalTest, ValueNotEq_Empty) {
  1337. absl::optional<int> opt;
  1338. EXPECT_TRUE(opt != 1);
  1339. }
  1340. TEST(OptionalTest, ValueNotEq_NotEmpty) {
  1341. {
  1342. absl::optional<int> opt(0);
  1343. EXPECT_TRUE(opt != 1);
  1344. }
  1345. {
  1346. absl::optional<int> opt(1);
  1347. EXPECT_FALSE(opt != 1);
  1348. }
  1349. }
  1350. TEST(OptionalTest, ValueNotEq_DifferentType) {
  1351. absl::optional<int> opt(0);
  1352. EXPECT_FALSE(opt != 0.0);
  1353. }
  1354. TEST(OptionalTest, NotEqValue_Empty) {
  1355. absl::optional<int> opt;
  1356. EXPECT_TRUE(1 != opt);
  1357. }
  1358. TEST(OptionalTest, NotEqValue_NotEmpty) {
  1359. {
  1360. absl::optional<int> opt(0);
  1361. EXPECT_TRUE(1 != opt);
  1362. }
  1363. {
  1364. absl::optional<int> opt(1);
  1365. EXPECT_FALSE(1 != opt);
  1366. }
  1367. }
  1368. TEST(OptionalTest, NotEqValue_DifferentType) {
  1369. absl::optional<int> opt(0);
  1370. EXPECT_FALSE(0.0 != opt);
  1371. }
  1372. TEST(OptionalTest, ValueLess_Empty) {
  1373. absl::optional<int> opt;
  1374. EXPECT_TRUE(opt < 1);
  1375. }
  1376. TEST(OptionalTest, ValueLess_NotEmpty) {
  1377. {
  1378. absl::optional<int> opt(0);
  1379. EXPECT_TRUE(opt < 1);
  1380. }
  1381. {
  1382. absl::optional<int> opt(1);
  1383. EXPECT_FALSE(opt < 1);
  1384. }
  1385. {
  1386. absl::optional<int> opt(2);
  1387. EXPECT_FALSE(opt < 1);
  1388. }
  1389. }
  1390. TEST(OptionalTest, ValueLess_DifferentType) {
  1391. absl::optional<int> opt(0);
  1392. EXPECT_TRUE(opt < 1.0);
  1393. }
  1394. TEST(OptionalTest, LessValue_Empty) {
  1395. absl::optional<int> opt;
  1396. EXPECT_FALSE(1 < opt);
  1397. }
  1398. TEST(OptionalTest, LessValue_NotEmpty) {
  1399. {
  1400. absl::optional<int> opt(0);
  1401. EXPECT_FALSE(1 < opt);
  1402. }
  1403. {
  1404. absl::optional<int> opt(1);
  1405. EXPECT_FALSE(1 < opt);
  1406. }
  1407. {
  1408. absl::optional<int> opt(2);
  1409. EXPECT_TRUE(1 < opt);
  1410. }
  1411. }
  1412. TEST(OptionalTest, LessValue_DifferentType) {
  1413. absl::optional<int> opt(0);
  1414. EXPECT_FALSE(0.0 < opt);
  1415. }
  1416. TEST(OptionalTest, ValueLessEq_Empty) {
  1417. absl::optional<int> opt;
  1418. EXPECT_TRUE(opt <= 1);
  1419. }
  1420. TEST(OptionalTest, ValueLessEq_NotEmpty) {
  1421. {
  1422. absl::optional<int> opt(0);
  1423. EXPECT_TRUE(opt <= 1);
  1424. }
  1425. {
  1426. absl::optional<int> opt(1);
  1427. EXPECT_TRUE(opt <= 1);
  1428. }
  1429. {
  1430. absl::optional<int> opt(2);
  1431. EXPECT_FALSE(opt <= 1);
  1432. }
  1433. }
  1434. TEST(OptionalTest, ValueLessEq_DifferentType) {
  1435. absl::optional<int> opt(0);
  1436. EXPECT_TRUE(opt <= 0.0);
  1437. }
  1438. TEST(OptionalTest, LessEqValue_Empty) {
  1439. absl::optional<int> opt;
  1440. EXPECT_FALSE(1 <= opt);
  1441. }
  1442. TEST(OptionalTest, LessEqValue_NotEmpty) {
  1443. {
  1444. absl::optional<int> opt(0);
  1445. EXPECT_FALSE(1 <= opt);
  1446. }
  1447. {
  1448. absl::optional<int> opt(1);
  1449. EXPECT_TRUE(1 <= opt);
  1450. }
  1451. {
  1452. absl::optional<int> opt(2);
  1453. EXPECT_TRUE(1 <= opt);
  1454. }
  1455. }
  1456. TEST(OptionalTest, LessEqValue_DifferentType) {
  1457. absl::optional<int> opt(0);
  1458. EXPECT_TRUE(0.0 <= opt);
  1459. }
  1460. TEST(OptionalTest, ValueGreater_Empty) {
  1461. absl::optional<int> opt;
  1462. EXPECT_FALSE(opt > 1);
  1463. }
  1464. TEST(OptionalTest, ValueGreater_NotEmpty) {
  1465. {
  1466. absl::optional<int> opt(0);
  1467. EXPECT_FALSE(opt > 1);
  1468. }
  1469. {
  1470. absl::optional<int> opt(1);
  1471. EXPECT_FALSE(opt > 1);
  1472. }
  1473. {
  1474. absl::optional<int> opt(2);
  1475. EXPECT_TRUE(opt > 1);
  1476. }
  1477. }
  1478. TEST(OptionalTest, ValueGreater_DifferentType) {
  1479. absl::optional<int> opt(0);
  1480. EXPECT_FALSE(opt > 0.0);
  1481. }
  1482. TEST(OptionalTest, GreaterValue_Empty) {
  1483. absl::optional<int> opt;
  1484. EXPECT_TRUE(1 > opt);
  1485. }
  1486. TEST(OptionalTest, GreaterValue_NotEmpty) {
  1487. {
  1488. absl::optional<int> opt(0);
  1489. EXPECT_TRUE(1 > opt);
  1490. }
  1491. {
  1492. absl::optional<int> opt(1);
  1493. EXPECT_FALSE(1 > opt);
  1494. }
  1495. {
  1496. absl::optional<int> opt(2);
  1497. EXPECT_FALSE(1 > opt);
  1498. }
  1499. }
  1500. TEST(OptionalTest, GreaterValue_DifferentType) {
  1501. absl::optional<int> opt(0);
  1502. EXPECT_FALSE(0.0 > opt);
  1503. }
  1504. TEST(OptionalTest, ValueGreaterEq_Empty) {
  1505. absl::optional<int> opt;
  1506. EXPECT_FALSE(opt >= 1);
  1507. }
  1508. TEST(OptionalTest, ValueGreaterEq_NotEmpty) {
  1509. {
  1510. absl::optional<int> opt(0);
  1511. EXPECT_FALSE(opt >= 1);
  1512. }
  1513. {
  1514. absl::optional<int> opt(1);
  1515. EXPECT_TRUE(opt >= 1);
  1516. }
  1517. {
  1518. absl::optional<int> opt(2);
  1519. EXPECT_TRUE(opt >= 1);
  1520. }
  1521. }
  1522. TEST(OptionalTest, ValueGreaterEq_DifferentType) {
  1523. absl::optional<int> opt(0);
  1524. EXPECT_TRUE(opt <= 0.0);
  1525. }
  1526. TEST(OptionalTest, GreaterEqValue_Empty) {
  1527. absl::optional<int> opt;
  1528. EXPECT_TRUE(1 >= opt);
  1529. }
  1530. TEST(OptionalTest, GreaterEqValue_NotEmpty) {
  1531. {
  1532. absl::optional<int> opt(0);
  1533. EXPECT_TRUE(1 >= opt);
  1534. }
  1535. {
  1536. absl::optional<int> opt(1);
  1537. EXPECT_TRUE(1 >= opt);
  1538. }
  1539. {
  1540. absl::optional<int> opt(2);
  1541. EXPECT_FALSE(1 >= opt);
  1542. }
  1543. }
  1544. TEST(OptionalTest, GreaterEqValue_DifferentType) {
  1545. absl::optional<int> opt(0);
  1546. EXPECT_TRUE(0.0 >= opt);
  1547. }
  1548. TEST(OptionalTest, NotEquals) {
  1549. {
  1550. absl::optional<float> a(0.1f);
  1551. absl::optional<float> b(0.2f);
  1552. EXPECT_NE(a, b);
  1553. }
  1554. {
  1555. absl::optional<std::string> a("foo");
  1556. absl::optional<std::string> b("bar");
  1557. EXPECT_NE(a, b);
  1558. }
  1559. {
  1560. absl::optional<int> a(1);
  1561. absl::optional<double> b(2);
  1562. EXPECT_NE(a, b);
  1563. }
  1564. {
  1565. absl::optional<TestObject> a(TestObject(3, 0.1));
  1566. absl::optional<TestObject> b(TestObject(4, 1.0));
  1567. EXPECT_TRUE(a != b);
  1568. }
  1569. }
  1570. TEST(OptionalTest, NotEqualsNull) {
  1571. {
  1572. absl::optional<float> a(0.1f);
  1573. absl::optional<float> b(0.1f);
  1574. b = absl::nullopt;
  1575. EXPECT_NE(a, b);
  1576. }
  1577. {
  1578. absl::optional<std::string> a("foo");
  1579. absl::optional<std::string> b("foo");
  1580. b = absl::nullopt;
  1581. EXPECT_NE(a, b);
  1582. }
  1583. {
  1584. absl::optional<TestObject> a(TestObject(3, 0.1));
  1585. absl::optional<TestObject> b(TestObject(3, 0.1));
  1586. b = absl::nullopt;
  1587. EXPECT_TRUE(a != b);
  1588. }
  1589. }
  1590. TEST(OptionalTest, MakeOptional) {
  1591. {
  1592. absl::optional<float> o = absl::make_optional(32.f);
  1593. EXPECT_TRUE(o);
  1594. EXPECT_EQ(32.f, *o);
  1595. float value = 3.f;
  1596. o = absl::make_optional(std::move(value));
  1597. EXPECT_TRUE(o);
  1598. EXPECT_EQ(3.f, *o);
  1599. }
  1600. {
  1601. absl::optional<std::string> o = absl::make_optional(std::string("foo"));
  1602. EXPECT_TRUE(o);
  1603. EXPECT_EQ("foo", *o);
  1604. std::string value = "bar";
  1605. o = absl::make_optional(std::move(value));
  1606. EXPECT_TRUE(o);
  1607. EXPECT_EQ(std::string("bar"), *o);
  1608. }
  1609. {
  1610. absl::optional<TestObject> o = absl::make_optional(TestObject(3, 0.1));
  1611. EXPECT_TRUE(!!o);
  1612. EXPECT_TRUE(TestObject(3, 0.1) == *o);
  1613. TestObject value = TestObject(0, 0.42);
  1614. o = absl::make_optional(std::move(value));
  1615. EXPECT_TRUE(!!o);
  1616. EXPECT_TRUE(TestObject(0, 0.42) == *o);
  1617. EXPECT_EQ(TestObject::State::MOVED_FROM, value.state());
  1618. EXPECT_EQ(TestObject::State::MOVE_ASSIGNED, o->state());
  1619. EXPECT_EQ(TestObject::State::MOVE_CONSTRUCTED,
  1620. absl::make_optional(std::move(value))->state());
  1621. }
  1622. {
  1623. struct Test {
  1624. Test(int a, double b, bool c) : a(a), b(b), c(c) {}
  1625. int a;
  1626. double b;
  1627. bool c;
  1628. };
  1629. absl::optional<Test> o = absl::make_optional<Test>(1, 2.0, true);
  1630. EXPECT_TRUE(!!o);
  1631. EXPECT_EQ(1, o->a);
  1632. EXPECT_EQ(2.0, o->b);
  1633. EXPECT_TRUE(o->c);
  1634. }
  1635. {
  1636. auto str1 = absl::make_optional<std::string>({'1', '2', '3'});
  1637. EXPECT_EQ("123", *str1);
  1638. auto str2 = absl::make_optional<std::string>({'a', 'b', 'c'},
  1639. std::allocator<char>());
  1640. EXPECT_EQ("abc", *str2);
  1641. }
  1642. }
  1643. TEST(OptionalTest, NonMemberSwap_bothNoValue) {
  1644. absl::optional<TestObject> a, b;
  1645. absl::swap(a, b);
  1646. EXPECT_FALSE(!!a);
  1647. EXPECT_FALSE(!!b);
  1648. EXPECT_TRUE(TestObject(42, 0.42) == a.value_or(TestObject(42, 0.42)));
  1649. EXPECT_TRUE(TestObject(42, 0.42) == b.value_or(TestObject(42, 0.42)));
  1650. }
  1651. TEST(OptionalTest, NonMemberSwap_inHasValue) {
  1652. absl::optional<TestObject> a(TestObject(1, 0.3));
  1653. absl::optional<TestObject> b;
  1654. absl::swap(a, b);
  1655. EXPECT_FALSE(!!a);
  1656. EXPECT_TRUE(!!b);
  1657. EXPECT_TRUE(TestObject(42, 0.42) == a.value_or(TestObject(42, 0.42)));
  1658. EXPECT_TRUE(TestObject(1, 0.3) == b.value_or(TestObject(42, 0.42)));
  1659. }
  1660. TEST(OptionalTest, NonMemberSwap_outHasValue) {
  1661. absl::optional<TestObject> a;
  1662. absl::optional<TestObject> b(TestObject(1, 0.3));
  1663. absl::swap(a, b);
  1664. EXPECT_TRUE(!!a);
  1665. EXPECT_FALSE(!!b);
  1666. EXPECT_TRUE(TestObject(1, 0.3) == a.value_or(TestObject(42, 0.42)));
  1667. EXPECT_TRUE(TestObject(42, 0.42) == b.value_or(TestObject(42, 0.42)));
  1668. }
  1669. TEST(OptionalTest, NonMemberSwap_bothValue) {
  1670. absl::optional<TestObject> a(TestObject(0, 0.1));
  1671. absl::optional<TestObject> b(TestObject(1, 0.3));
  1672. absl::swap(a, b);
  1673. EXPECT_TRUE(!!a);
  1674. EXPECT_TRUE(!!b);
  1675. EXPECT_TRUE(TestObject(1, 0.3) == a.value_or(TestObject(42, 0.42)));
  1676. EXPECT_TRUE(TestObject(0, 0.1) == b.value_or(TestObject(42, 0.42)));
  1677. EXPECT_EQ(TestObject::State::SWAPPED, a->state());
  1678. EXPECT_EQ(TestObject::State::SWAPPED, b->state());
  1679. }
  1680. TEST(OptionalTest, Hash_OptionalReflectsInternal) {
  1681. {
  1682. std::hash<int> int_hash;
  1683. std::hash<absl::optional<int>> opt_int_hash;
  1684. EXPECT_EQ(int_hash(1), opt_int_hash(absl::optional<int>(1)));
  1685. }
  1686. {
  1687. std::hash<std::string> str_hash;
  1688. std::hash<absl::optional<std::string>> opt_str_hash;
  1689. EXPECT_EQ(str_hash(std::string("foobar")),
  1690. opt_str_hash(absl::optional<std::string>(std::string("foobar"))));
  1691. }
  1692. }
  1693. TEST(OptionalTest, Hash_NullOptEqualsNullOpt) {
  1694. std::hash<absl::optional<int>> opt_int_hash;
  1695. std::hash<absl::optional<std::string>> opt_str_hash;
  1696. EXPECT_EQ(opt_str_hash(absl::optional<std::string>()),
  1697. opt_int_hash(absl::optional<int>()));
  1698. }
  1699. TEST(OptionalTest, Hash_UseInSet) {
  1700. std::set<absl::optional<int>> setOptInt;
  1701. EXPECT_EQ(setOptInt.end(), setOptInt.find(42));
  1702. setOptInt.insert(absl::optional<int>(3));
  1703. EXPECT_EQ(setOptInt.end(), setOptInt.find(42));
  1704. EXPECT_NE(setOptInt.end(), setOptInt.find(3));
  1705. }
  1706. TEST(OptionalTest, HasValue) {
  1707. absl::optional<int> a;
  1708. EXPECT_FALSE(a.has_value());
  1709. a = 42;
  1710. EXPECT_TRUE(a.has_value());
  1711. a = absl::nullopt;
  1712. EXPECT_FALSE(a.has_value());
  1713. a = 0;
  1714. EXPECT_TRUE(a.has_value());
  1715. a = absl::optional<int>();
  1716. EXPECT_FALSE(a.has_value());
  1717. }
  1718. TEST(OptionalTest, Reset_int) {
  1719. absl::optional<int> a(0);
  1720. EXPECT_TRUE(a.has_value());
  1721. EXPECT_EQ(0, a.value());
  1722. a.reset();
  1723. EXPECT_FALSE(a.has_value());
  1724. EXPECT_EQ(-1, a.value_or(-1));
  1725. }
  1726. TEST(OptionalTest, Reset_Object) {
  1727. absl::optional<TestObject> a(TestObject(0, 0.1));
  1728. EXPECT_TRUE(a.has_value());
  1729. EXPECT_EQ(TestObject(0, 0.1), a.value());
  1730. a.reset();
  1731. EXPECT_FALSE(a.has_value());
  1732. EXPECT_EQ(TestObject(42, 0.0), a.value_or(TestObject(42, 0.0)));
  1733. }
  1734. TEST(OptionalTest, Reset_NoOp) {
  1735. absl::optional<int> a;
  1736. EXPECT_FALSE(a.has_value());
  1737. a.reset();
  1738. EXPECT_FALSE(a.has_value());
  1739. }
  1740. TEST(OptionalTest, AssignFromRValue) {
  1741. absl::optional<TestObject> a;
  1742. EXPECT_FALSE(a.has_value());
  1743. TestObject obj;
  1744. a = std::move(obj);
  1745. EXPECT_TRUE(a.has_value());
  1746. EXPECT_EQ(1, a->move_ctors_count());
  1747. }
  1748. TEST(OptionalTest, DontCallDefaultCtor) {
  1749. absl::optional<DeletedDefaultConstructor> a;
  1750. EXPECT_FALSE(a.has_value());
  1751. a = absl::make_optional<DeletedDefaultConstructor>(42);
  1752. EXPECT_TRUE(a.has_value());
  1753. EXPECT_EQ(42, a->foo());
  1754. }
  1755. TEST(OptionalTest, DontCallNewMemberFunction) {
  1756. absl::optional<DeleteNewOperators> a;
  1757. EXPECT_FALSE(a.has_value());
  1758. a = DeleteNewOperators();
  1759. EXPECT_TRUE(a.has_value());
  1760. }
  1761. TEST(OptionalTest, DereferencingNoValueCrashes) {
  1762. class C {
  1763. public:
  1764. void Method() const {}
  1765. };
  1766. {
  1767. const absl::optional<C> const_optional;
  1768. EXPECT_DEATH_IF_SUPPORTED(const_optional.value(), "");
  1769. EXPECT_DEATH_IF_SUPPORTED(const_optional->Method(), "");
  1770. EXPECT_DEATH_IF_SUPPORTED(*const_optional, "");
  1771. EXPECT_DEATH_IF_SUPPORTED(*std::move(const_optional), "");
  1772. }
  1773. {
  1774. absl::optional<C> non_const_optional;
  1775. EXPECT_DEATH_IF_SUPPORTED(non_const_optional.value(), "");
  1776. EXPECT_DEATH_IF_SUPPORTED(non_const_optional->Method(), "");
  1777. EXPECT_DEATH_IF_SUPPORTED(*non_const_optional, "");
  1778. EXPECT_DEATH_IF_SUPPORTED(*std::move(non_const_optional), "");
  1779. }
  1780. }
  1781. TEST(OptionalTest, Noexcept) {
  1782. // Trivial copy ctor, non-trivial move ctor, nothrow move assign.
  1783. struct Test1 {
  1784. Test1(const Test1&) = default;
  1785. Test1(Test1&&) {}
  1786. Test1& operator=(Test1&&) = default;
  1787. };
  1788. // Non-trivial copy ctor, trivial move ctor, throw move assign.
  1789. struct Test2 {
  1790. Test2(const Test2&) {}
  1791. Test2(Test2&&) = default;
  1792. Test2& operator=(Test2&&) { return *this; }
  1793. };
  1794. // Trivial copy ctor, non-trivial nothrow move ctor.
  1795. struct Test3 {
  1796. Test3(const Test3&) = default;
  1797. Test3(Test3&&) noexcept {}
  1798. };
  1799. // Non-trivial copy ctor, non-trivial nothrow move ctor.
  1800. struct Test4 {
  1801. Test4(const Test4&) {}
  1802. Test4(Test4&&) noexcept {}
  1803. };
  1804. // Non-trivial copy ctor, non-trivial move ctor.
  1805. struct Test5 {
  1806. Test5(const Test5&) {}
  1807. Test5(Test5&&) {}
  1808. };
  1809. static_assert(
  1810. noexcept(absl::optional<int>(std::declval<absl::optional<int>>())),
  1811. "move constructor for noexcept move-constructible T must be noexcept "
  1812. "(trivial copy, trivial move)");
  1813. static_assert(
  1814. !noexcept(absl::optional<Test1>(std::declval<absl::optional<Test1>>())),
  1815. "move constructor for non-noexcept move-constructible T must not be "
  1816. "noexcept (trivial copy)");
  1817. static_assert(
  1818. noexcept(absl::optional<Test2>(std::declval<absl::optional<Test2>>())),
  1819. "move constructor for noexcept move-constructible T must be noexcept "
  1820. "(non-trivial copy, trivial move)");
  1821. static_assert(
  1822. noexcept(absl::optional<Test3>(std::declval<absl::optional<Test3>>())),
  1823. "move constructor for noexcept move-constructible T must be noexcept "
  1824. "(trivial copy, non-trivial move)");
  1825. static_assert(
  1826. noexcept(absl::optional<Test4>(std::declval<absl::optional<Test4>>())),
  1827. "move constructor for noexcept move-constructible T must be noexcept "
  1828. "(non-trivial copy, non-trivial move)");
  1829. static_assert(
  1830. !noexcept(absl::optional<Test5>(std::declval<absl::optional<Test5>>())),
  1831. "move constructor for non-noexcept move-constructible T must not be "
  1832. "noexcept (non-trivial copy)");
  1833. static_assert(noexcept(std::declval<absl::optional<int>>() =
  1834. std::declval<absl::optional<int>>()),
  1835. "move assign for noexcept move-constructible/move-assignable T "
  1836. "must be noexcept");
  1837. static_assert(
  1838. !noexcept(std::declval<absl::optional<Test1>>() =
  1839. std::declval<absl::optional<Test1>>()),
  1840. "move assign for non-noexcept move-constructible T must not be noexcept");
  1841. static_assert(
  1842. !noexcept(std::declval<absl::optional<Test2>>() =
  1843. std::declval<absl::optional<Test2>>()),
  1844. "move assign for non-noexcept move-assignable T must not be noexcept");
  1845. }
  1846. TEST(OptionalTest, OverrideAddressOf) {
  1847. // Objects with an overloaded address-of should not trigger the overload for
  1848. // arrow or copy assignment.
  1849. static_assert(std::is_trivially_destructible<
  1850. TriviallyDestructibleOverloadAddressOf>::value,
  1851. "Trivially...AddressOf must be trivially destructible.");
  1852. absl::optional<TriviallyDestructibleOverloadAddressOf> optional;
  1853. TriviallyDestructibleOverloadAddressOf n;
  1854. optional = n;
  1855. // operator->() should not call address-of either, for either const or non-
  1856. // const calls. It's not strictly necessary that we call a nonconst method
  1857. // to test the non-const operator->(), but it makes it very clear that the
  1858. // compiler can't chose the const operator->().
  1859. optional->nonconst_method();
  1860. const auto& const_optional = optional;
  1861. const_optional->const_method();
  1862. static_assert(!std::is_trivially_destructible<
  1863. NonTriviallyDestructibleOverloadAddressOf>::value,
  1864. "NotTrivially...AddressOf must not be trivially destructible.");
  1865. absl::optional<NonTriviallyDestructibleOverloadAddressOf> nontrivial_optional;
  1866. NonTriviallyDestructibleOverloadAddressOf n1;
  1867. nontrivial_optional = n1;
  1868. }
  1869. } // namespace base