unittests/ADT/OptionalTest.cpp

   1 //===- llvm/unittest/ADT/OptionalTest.cpp - Optional unit tests -----------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "llvm/ADT/Optional.h"
  11 #include "gtest/gtest.h"
  12
  13 using namespace llvm;
  14
  15 namespace {
  16
  17 struct NonDefaultConstructible {
  18   static unsigned CopyConstructions;
  19   static unsigned Destructions;
  20   static unsigned CopyAssignments;
  21   explicit NonDefaultConstructible(int) {
  22   }
  23   NonDefaultConstructible(const NonDefaultConstructible&) {
  24     ++CopyConstructions;
  25   }
  26   NonDefaultConstructible &operator=(const NonDefaultConstructible&) {
  27     ++CopyAssignments;
  28     return *this;
  29   }
  30   ~NonDefaultConstructible() {
  31     ++Destructions;
  32   }
  33   static void ResetCounts() {
  34     CopyConstructions = 0;
  35     Destructions = 0;
  36     CopyAssignments = 0;
  37   }
  38 };
  39
  40 unsigned NonDefaultConstructible::CopyConstructions = 0;
  41 unsigned NonDefaultConstructible::Destructions = 0;
  42 unsigned NonDefaultConstructible::CopyAssignments = 0;
  43
  44 // Test fixture
  45 class OptionalTest : public testing::Test {
  46 };
  47
  48 TEST_F(OptionalTest, NonDefaultConstructibleTest) {
  49   Optional<NonDefaultConstructible> O;
  50   EXPECT_FALSE(O);
  51 }
  52
  53 TEST_F(OptionalTest, ResetTest) {
  54   NonDefaultConstructible::ResetCounts();
  55   Optional<NonDefaultConstructible> O(NonDefaultConstructible(3));
  56   EXPECT_EQ(1u, NonDefaultConstructible::CopyConstructions);
  57   EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
  58   EXPECT_EQ(1u, NonDefaultConstructible::Destructions);
  59   NonDefaultConstructible::ResetCounts();
  60   O.reset();
  61   EXPECT_EQ(0u, NonDefaultConstructible::CopyConstructions);
  62   EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
  63   EXPECT_EQ(1u, NonDefaultConstructible::Destructions);
  64 }
  65
  66 TEST_F(OptionalTest, InitializationLeakTest) {
  67   NonDefaultConstructible::ResetCounts();
  68   Optional<NonDefaultConstructible>(NonDefaultConstructible(3));
  69   EXPECT_EQ(1u, NonDefaultConstructible::CopyConstructions);
  70   EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
  71   EXPECT_EQ(2u, NonDefaultConstructible::Destructions);
  72 }
  73
  74 TEST_F(OptionalTest, CopyConstructionTest) {
  75   NonDefaultConstructible::ResetCounts();
  76   {
  77     Optional<NonDefaultConstructible> A(NonDefaultConstructible(3));
  78     EXPECT_EQ(1u, NonDefaultConstructible::CopyConstructions);
  79     EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
  80     EXPECT_EQ(1u, NonDefaultConstructible::Destructions);
  81     NonDefaultConstructible::ResetCounts();
  82     Optional<NonDefaultConstructible> B(A);
  83     EXPECT_EQ(1u, NonDefaultConstructible::CopyConstructions);
  84     EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
  85     EXPECT_EQ(0u, NonDefaultConstructible::Destructions);
  86     NonDefaultConstructible::ResetCounts();
  87   }
  88   EXPECT_EQ(0u, NonDefaultConstructible::CopyConstructions);
  89   EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
  90   EXPECT_EQ(2u, NonDefaultConstructible::Destructions);
  91 }
  92
  93 TEST_F(OptionalTest, ConstructingCopyAssignmentTest) {
  94   NonDefaultConstructible::ResetCounts();
  95   {
  96     Optional<NonDefaultConstructible> A(NonDefaultConstructible(3));
  97     Optional<NonDefaultConstructible> B;
  98     EXPECT_EQ(1u, NonDefaultConstructible::CopyConstructions);
  99     EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
 100     EXPECT_EQ(1u, NonDefaultConstructible::Destructions);
 101     NonDefaultConstructible::ResetCounts();
 102     B = A;
 103     EXPECT_EQ(1u, NonDefaultConstructible::CopyConstructions);
 104     EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
 105     EXPECT_EQ(0u, NonDefaultConstructible::Destructions);
 106     NonDefaultConstructible::ResetCounts();
 107   }
 108   EXPECT_EQ(0u, NonDefaultConstructible::CopyConstructions);
 109   EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
 110   EXPECT_EQ(2u, NonDefaultConstructible::Destructions);
 111 }
 112
 113 TEST_F(OptionalTest, CopyingCopyAssignmentTest) {
 114   NonDefaultConstructible::ResetCounts();
 115   {
 116     Optional<NonDefaultConstructible> A(NonDefaultConstructible(3));
 117     Optional<NonDefaultConstructible> B(NonDefaultConstructible(4));
 118     EXPECT_EQ(2u, NonDefaultConstructible::CopyConstructions);
 119     EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
 120     EXPECT_EQ(2u, NonDefaultConstructible::Destructions);
 121     NonDefaultConstructible::ResetCounts();
 122     B = A;
 123     EXPECT_EQ(0u, NonDefaultConstructible::CopyConstructions);
 124     EXPECT_EQ(1u, NonDefaultConstructible::CopyAssignments);
 125     EXPECT_EQ(0u, NonDefaultConstructible::Destructions);
 126     NonDefaultConstructible::ResetCounts();
 127   }
 128   EXPECT_EQ(0u, NonDefaultConstructible::CopyConstructions);
 129   EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
 130   EXPECT_EQ(2u, NonDefaultConstructible::Destructions);
 131 }
 132
 133 TEST_F(OptionalTest, DeletingCopyAssignmentTest) {
 134   NonDefaultConstructible::ResetCounts();
 135   {
 136     Optional<NonDefaultConstructible> A;
 137     Optional<NonDefaultConstructible> B(NonDefaultConstructible(3));
 138     EXPECT_EQ(1u, NonDefaultConstructible::CopyConstructions);
 139     EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
 140     EXPECT_EQ(1u, NonDefaultConstructible::Destructions);
 141     NonDefaultConstructible::ResetCounts();
 142     B = A;
 143     EXPECT_EQ(0u, NonDefaultConstructible::CopyConstructions);
 144     EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
 145     EXPECT_EQ(1u, NonDefaultConstructible::Destructions);
 146     NonDefaultConstructible::ResetCounts();
 147   }
 148   EXPECT_EQ(0u, NonDefaultConstructible::CopyConstructions);
 149   EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
 150   EXPECT_EQ(0u, NonDefaultConstructible::Destructions);
 151 }
 152
 153 TEST_F(OptionalTest, NullCopyConstructionTest) {
 154   NonDefaultConstructible::ResetCounts();
 155   {
 156     Optional<NonDefaultConstructible> A;
 157     Optional<NonDefaultConstructible> B;
 158     EXPECT_EQ(0u, NonDefaultConstructible::CopyConstructions);
 159     EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
 160     EXPECT_EQ(0u, NonDefaultConstructible::Destructions);
 161     NonDefaultConstructible::ResetCounts();
 162     B = A;
 163     EXPECT_EQ(0u, NonDefaultConstructible::CopyConstructions);
 164     EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
 165     EXPECT_EQ(0u, NonDefaultConstructible::Destructions);
 166     NonDefaultConstructible::ResetCounts();
 167   }
 168   EXPECT_EQ(0u, NonDefaultConstructible::CopyConstructions);
 169   EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
 170   EXPECT_EQ(0u, NonDefaultConstructible::Destructions);
 171 }
 172
 173 TEST_F(OptionalTest, GetValueOr) {
 174   Optional<int> A;
 175   EXPECT_EQ(42, A.getValueOr(42));
 176
 177   A = 5;
 178   EXPECT_EQ(5, A.getValueOr(42));
 179 }
 180
 181 struct MultiArgConstructor {
 182   int x, y;
 183   MultiArgConstructor(int x, int y) : x(x), y(y) {}
 184   explicit MultiArgConstructor(int x, bool positive)
 185     : x(x), y(positive ? x : -x) {}
 186
 187   MultiArgConstructor(const MultiArgConstructor &) = delete;
 188   MultiArgConstructor(MultiArgConstructor &&) = delete;
 189   MultiArgConstructor &operator=(const MultiArgConstructor &) = delete;
 190   MultiArgConstructor &operator=(MultiArgConstructor &&) = delete;
 191
 192   static unsigned Destructions;
 193   ~MultiArgConstructor() {
 194     ++Destructions;
 195   }
 196   static void ResetCounts() {
 197     Destructions = 0;
 198   }
 199 };
 200 unsigned MultiArgConstructor::Destructions = 0;
 201
 202 TEST_F(OptionalTest, Emplace) {
 203   MultiArgConstructor::ResetCounts();
 204   Optional<MultiArgConstructor> A;
 205
 206   A.emplace(1, 2);
 207   EXPECT_TRUE(A.hasValue());
 208   EXPECT_EQ(1, A->x);
 209   EXPECT_EQ(2, A->y);
 210   EXPECT_EQ(0u, MultiArgConstructor::Destructions);
 211
 212   A.emplace(5, false);
 213   EXPECT_TRUE(A.hasValue());
 214   EXPECT_EQ(5, A->x);
 215   EXPECT_EQ(-5, A->y);
 216   EXPECT_EQ(1u, MultiArgConstructor::Destructions);
 217 }
 218
 219 struct MoveOnly {
 220   static unsigned MoveConstructions;
 221   static unsigned Destructions;
 222   static unsigned MoveAssignments;
 223   int val;
 224   explicit MoveOnly(int val) : val(val) {
 225   }
 226   MoveOnly(MoveOnly&& other) {
 227     val = other.val;
 228     ++MoveConstructions;
 229   }
 230   MoveOnly &operator=(MoveOnly&& other) {
 231     val = other.val;
 232     ++MoveAssignments;
 233     return *this;
 234   }
 235   ~MoveOnly() {
 236     ++Destructions;
 237   }
 238   static void ResetCounts() {
 239     MoveConstructions = 0;
 240     Destructions = 0;
 241     MoveAssignments = 0;
 242   }
 243 };
 244
 245 unsigned MoveOnly::MoveConstructions = 0;
 246 unsigned MoveOnly::Destructions = 0;
 247 unsigned MoveOnly::MoveAssignments = 0;
 248
 249 TEST_F(OptionalTest, MoveOnlyNull) {
 250   MoveOnly::ResetCounts();
 251   Optional<MoveOnly> O;
 252   EXPECT_EQ(0u, MoveOnly::MoveConstructions);
 253   EXPECT_EQ(0u, MoveOnly::MoveAssignments);
 254   EXPECT_EQ(0u, MoveOnly::Destructions);
 255 }
 256
 257 TEST_F(OptionalTest, MoveOnlyConstruction) {
 258   MoveOnly::ResetCounts();
 259   Optional<MoveOnly> O(MoveOnly(3));
 260   EXPECT_TRUE((bool)O);
 261   EXPECT_EQ(3, O->val);
 262   EXPECT_EQ(1u, MoveOnly::MoveConstructions);
 263   EXPECT_EQ(0u, MoveOnly::MoveAssignments);
 264   EXPECT_EQ(1u, MoveOnly::Destructions);
 265 }
 266
 267 TEST_F(OptionalTest, MoveOnlyMoveConstruction) {
 268   Optional<MoveOnly> A(MoveOnly(3));
 269   MoveOnly::ResetCounts();
 270   Optional<MoveOnly> B(std::move(A));
 271   EXPECT_TRUE((bool)A);
 272   EXPECT_TRUE((bool)B);
 273   EXPECT_EQ(3, B->val);
 274   EXPECT_EQ(1u, MoveOnly::MoveConstructions);
 275   EXPECT_EQ(0u, MoveOnly::MoveAssignments);
 276   EXPECT_EQ(0u, MoveOnly::Destructions);
 277 }
 278
 279 TEST_F(OptionalTest, MoveOnlyAssignment) {
 280   MoveOnly::ResetCounts();
 281   Optional<MoveOnly> O;
 282   O = MoveOnly(3);
 283   EXPECT_TRUE((bool)O);
 284   EXPECT_EQ(3, O->val);
 285   EXPECT_EQ(1u, MoveOnly::MoveConstructions);
 286   EXPECT_EQ(0u, MoveOnly::MoveAssignments);
 287   EXPECT_EQ(1u, MoveOnly::Destructions);
 288 }
 289
 290 TEST_F(OptionalTest, MoveOnlyInitializingAssignment) {
 291   Optional<MoveOnly> A(MoveOnly(3));
 292   Optional<MoveOnly> B;
 293   MoveOnly::ResetCounts();
 294   B = std::move(A);
 295   EXPECT_TRUE((bool)A);
 296   EXPECT_TRUE((bool)B);
 297   EXPECT_EQ(3, B->val);
 298   EXPECT_EQ(1u, MoveOnly::MoveConstructions);
 299   EXPECT_EQ(0u, MoveOnly::MoveAssignments);
 300   EXPECT_EQ(0u, MoveOnly::Destructions);
 301 }
 302
 303 TEST_F(OptionalTest, MoveOnlyNullingAssignment) {
 304   Optional<MoveOnly> A;
 305   Optional<MoveOnly> B(MoveOnly(3));
 306   MoveOnly::ResetCounts();
 307   B = std::move(A);
 308   EXPECT_FALSE((bool)A);
 309   EXPECT_FALSE((bool)B);
 310   EXPECT_EQ(0u, MoveOnly::MoveConstructions);
 311   EXPECT_EQ(0u, MoveOnly::MoveAssignments);
 312   EXPECT_EQ(1u, MoveOnly::Destructions);
 313 }
 314
 315 TEST_F(OptionalTest, MoveOnlyAssigningAssignment) {
 316   Optional<MoveOnly> A(MoveOnly(3));
 317   Optional<MoveOnly> B(MoveOnly(4));
 318   MoveOnly::ResetCounts();
 319   B = std::move(A);
 320   EXPECT_TRUE((bool)A);
 321   EXPECT_TRUE((bool)B);
 322   EXPECT_EQ(3, B->val);
 323   EXPECT_EQ(0u, MoveOnly::MoveConstructions);
 324   EXPECT_EQ(1u, MoveOnly::MoveAssignments);
 325   EXPECT_EQ(0u, MoveOnly::Destructions);
 326 }
 327
 328 struct Immovable {
 329   static unsigned Constructions;
 330   static unsigned Destructions;
 331   int val;
 332   explicit Immovable(int val) : val(val) {
 333     ++Constructions;
 334   }
 335   ~Immovable() {
 336     ++Destructions;
 337   }
 338   static void ResetCounts() {
 339     Constructions = 0;
 340     Destructions = 0;
 341   }
 342 private:
 343   // This should disable all move/copy operations.
 344   Immovable(Immovable&& other) = delete;
 345 };
 346
 347 unsigned Immovable::Constructions = 0;
 348 unsigned Immovable::Destructions = 0;
 349
 350 TEST_F(OptionalTest, ImmovableEmplace) {
 351   Optional<Immovable> A;
 352   Immovable::ResetCounts();
 353   A.emplace(4);
 354   EXPECT_TRUE((bool)A);
 355   EXPECT_EQ(4, A->val);
 356   EXPECT_EQ(1u, Immovable::Constructions);
 357   EXPECT_EQ(0u, Immovable::Destructions);
 358 }
 359
 360 #if LLVM_HAS_RVALUE_REFERENCE_THIS
 361
 362 TEST_F(OptionalTest, MoveGetValueOr) {
 363   Optional<MoveOnly> A;
 364
 365   MoveOnly::ResetCounts();
 366   EXPECT_EQ(42, std::move(A).getValueOr(MoveOnly(42)).val);
 367   EXPECT_EQ(1u, MoveOnly::MoveConstructions);
 368   EXPECT_EQ(0u, MoveOnly::MoveAssignments);
 369   EXPECT_EQ(2u, MoveOnly::Destructions);
 370
 371   A = MoveOnly(5);
 372   MoveOnly::ResetCounts();
 373   EXPECT_EQ(5, std::move(A).getValueOr(MoveOnly(42)).val);
 374   EXPECT_EQ(1u, MoveOnly::MoveConstructions);
 375   EXPECT_EQ(0u, MoveOnly::MoveAssignments);
 376   EXPECT_EQ(2u, MoveOnly::Destructions);
 377 }
 378
 379 #endif // LLVM_HAS_RVALUE_REFERENCE_THIS
 380
 381 struct EqualTo {
 382   template <typename T, typename U> static bool apply(const T &X, const U &Y) {
 383     return X == Y;
 384   }
 385 };
 386
 387 struct NotEqualTo {
 388   template <typename T, typename U> static bool apply(const T &X, const U &Y) {
 389     return X != Y;
 390   }
 391 };
 392
 393 struct Less {
 394   template <typename T, typename U> static bool apply(const T &X, const U &Y) {
 395     return X < Y;
 396   }
 397 };
 398
 399 struct Greater {
 400   template <typename T, typename U> static bool apply(const T &X, const U &Y) {
 401     return X > Y;
 402   }
 403 };
 404
 405 struct LessEqual {
 406   template <typename T, typename U> static bool apply(const T &X, const U &Y) {
 407     return X <= Y;
 408   }
 409 };
 410
 411 struct GreaterEqual {
 412   template <typename T, typename U> static bool apply(const T &X, const U &Y) {
 413     return X >= Y;
 414   }
 415 };
 416
 417 template <typename OperatorT, typename T>
 418 void CheckRelation(const Optional<T> &Lhs, const Optional<T> &Rhs,
 419                    bool Expected) {
 420   EXPECT_EQ(Expected, OperatorT::apply(Lhs, Rhs));
 421
 422   if (Lhs)
 423     EXPECT_EQ(Expected, OperatorT::apply(*Lhs, Rhs));
 424   else
 425     EXPECT_EQ(Expected, OperatorT::apply(None, Rhs));
 426
 427   if (Rhs)
 428     EXPECT_EQ(Expected, OperatorT::apply(Lhs, *Rhs));
 429   else
 430     EXPECT_EQ(Expected, OperatorT::apply(Lhs, None));
 431 }
 432
 433 struct EqualityMock {};
 434 const Optional<EqualityMock> NoneEq, EqualityLhs((EqualityMock())),
 435     EqualityRhs((EqualityMock()));
 436 bool IsEqual;
 437
 438 bool operator==(const EqualityMock &Lhs, const EqualityMock &Rhs) {
 439   EXPECT_EQ(&*EqualityLhs, &Lhs);
 440   EXPECT_EQ(&*EqualityRhs, &Rhs);
 441   return IsEqual;
 442 }
 443
 444 TEST_F(OptionalTest, OperatorEqual) {
 445   CheckRelation<EqualTo>(NoneEq, NoneEq, true);
 446   CheckRelation<EqualTo>(NoneEq, EqualityRhs, false);
 447   CheckRelation<EqualTo>(EqualityLhs, NoneEq, false);
 448
 449   IsEqual = false;
 450   CheckRelation<EqualTo>(EqualityLhs, EqualityRhs, IsEqual);
 451   IsEqual = true;
 452   CheckRelation<EqualTo>(EqualityLhs, EqualityRhs, IsEqual);
 453 }
 454
 455 TEST_F(OptionalTest, OperatorNotEqual) {
 456   CheckRelation<NotEqualTo>(NoneEq, NoneEq, false);
 457   CheckRelation<NotEqualTo>(NoneEq, EqualityRhs, true);
 458   CheckRelation<NotEqualTo>(EqualityLhs, NoneEq, true);
 459
 460   IsEqual = false;
 461   CheckRelation<NotEqualTo>(EqualityLhs, EqualityRhs, !IsEqual);
 462   IsEqual = true;
 463   CheckRelation<NotEqualTo>(EqualityLhs, EqualityRhs, !IsEqual);
 464 }
 465
 466 struct InequalityMock {};
 467 const Optional<InequalityMock> NoneIneq, InequalityLhs((InequalityMock())),
 468     InequalityRhs((InequalityMock()));
 469 bool IsLess;
 470
 471 bool operator<(const InequalityMock &Lhs, const InequalityMock &Rhs) {
 472   EXPECT_EQ(&*InequalityLhs, &Lhs);
 473   EXPECT_EQ(&*InequalityRhs, &Rhs);
 474   return IsLess;
 475 }
 476
 477 TEST_F(OptionalTest, OperatorLess) {
 478   CheckRelation<Less>(NoneIneq, NoneIneq, false);
 479   CheckRelation<Less>(NoneIneq, InequalityRhs, true);
 480   CheckRelation<Less>(InequalityLhs, NoneIneq, false);
 481
 482   IsLess = false;
 483   CheckRelation<Less>(InequalityLhs, InequalityRhs, IsLess);
 484   IsLess = true;
 485   CheckRelation<Less>(InequalityLhs, InequalityRhs, IsLess);
 486 }
 487
 488 TEST_F(OptionalTest, OperatorGreater) {
 489   CheckRelation<Greater>(NoneIneq, NoneIneq, false);
 490   CheckRelation<Greater>(NoneIneq, InequalityRhs, false);
 491   CheckRelation<Greater>(InequalityLhs, NoneIneq, true);
 492
 493   IsLess = false;
 494   CheckRelation<Greater>(InequalityRhs, InequalityLhs, IsLess);
 495   IsLess = true;
 496   CheckRelation<Greater>(InequalityRhs, InequalityLhs, IsLess);
 497 }
 498
 499 TEST_F(OptionalTest, OperatorLessEqual) {
 500   CheckRelation<LessEqual>(NoneIneq, NoneIneq, true);
 501   CheckRelation<LessEqual>(NoneIneq, InequalityRhs, true);
 502   CheckRelation<LessEqual>(InequalityLhs, NoneIneq, false);
 503
 504   IsLess = false;
 505   CheckRelation<LessEqual>(InequalityRhs, InequalityLhs, !IsLess);
 506   IsLess = true;
 507   CheckRelation<LessEqual>(InequalityRhs, InequalityLhs, !IsLess);
 508 }
 509
 510 TEST_F(OptionalTest, OperatorGreaterEqual) {
 511   CheckRelation<GreaterEqual>(NoneIneq, NoneIneq, true);
 512   CheckRelation<GreaterEqual>(NoneIneq, InequalityRhs, false);
 513   CheckRelation<GreaterEqual>(InequalityLhs, NoneIneq, true);
 514
 515   IsLess = false;
 516   CheckRelation<GreaterEqual>(InequalityLhs, InequalityRhs, !IsLess);
 517   IsLess = true;
 518   CheckRelation<GreaterEqual>(InequalityLhs, InequalityRhs, !IsLess);
 519 }
 520
 521 #if __has_feature(is_trivially_copyable) && defined(_LIBCPP_VERSION)
 522 static_assert(std::is_trivially_copyable<Optional<int>>::value,
 523               "Should be trivially copyable");
 524 static_assert(
 525     !std::is_trivially_copyable<Optional<NonDefaultConstructible>>::value,
 526     "Shouldn't be trivially copyable");
 527 #endif
 528
 529 } // end anonymous namespace
 530