unittests/Support/ErrorTest.cpp

   1 //===----- unittests/ErrorTest.cpp - Error.h tests ------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "llvm/Support/Error.h"
  10 #include "llvm-c/Error.h"
  11
  12 #include "llvm/ADT/Twine.h"
  13 #include "llvm/Support/Errc.h"
  14 #include "llvm/Support/ErrorHandling.h"
  15 #include "llvm/Support/ManagedStatic.h"
  16 #include "llvm/Testing/Support/Error.h"
  17 #include "gtest/gtest-spi.h"
  18 #include "gtest/gtest.h"
  19 #include <memory>
  20
  21 using namespace llvm;
  22
  23 namespace {
  24
  25 // Custom error class with a default base class and some random 'info' attached.
  26 class CustomError : public ErrorInfo<CustomError> {
  27 public:
  28   // Create an error with some info attached.
  29   CustomError(int Info) : Info(Info) {}
  30
  31   // Get the info attached to this error.
  32   int getInfo() const { return Info; }
  33
  34   // Log this error to a stream.
  35   void log(raw_ostream &OS) const override {
  36     OS << "CustomError {" << getInfo() << "}";
  37   }
  38
  39   std::error_code convertToErrorCode() const override {
  40     llvm_unreachable("CustomError doesn't support ECError conversion");
  41   }
  42
  43   // Used by ErrorInfo::classID.
  44   static char ID;
  45
  46 protected:
  47   // This error is subclassed below, but we can't use inheriting constructors
  48   // yet, so we can't propagate the constructors through ErrorInfo. Instead
  49   // we have to have a default constructor and have the subclass initialize all
  50   // fields.
  51   CustomError() : Info(0) {}
  52
  53   int Info;
  54 };
  55
  56 char CustomError::ID = 0;
  57
  58 // Custom error class with a custom base class and some additional random
  59 // 'info'.
  60 class CustomSubError : public ErrorInfo<CustomSubError, CustomError> {
  61 public:
  62   // Create a sub-error with some info attached.
  63   CustomSubError(int Info, int ExtraInfo) : ExtraInfo(ExtraInfo) {
  64     this->Info = Info;
  65   }
  66
  67   // Get the extra info attached to this error.
  68   int getExtraInfo() const { return ExtraInfo; }
  69
  70   // Log this error to a stream.
  71   void log(raw_ostream &OS) const override {
  72     OS << "CustomSubError { " << getInfo() << ", " << getExtraInfo() << "}";
  73   }
  74
  75   std::error_code convertToErrorCode() const override {
  76     llvm_unreachable("CustomSubError doesn't support ECError conversion");
  77   }
  78
  79   // Used by ErrorInfo::classID.
  80   static char ID;
  81
  82 protected:
  83   int ExtraInfo;
  84 };
  85
  86 char CustomSubError::ID = 0;
  87
  88 static Error handleCustomError(const CustomError &CE) {
  89   return Error::success();
  90 }
  91
  92 static void handleCustomErrorVoid(const CustomError &CE) {}
  93
  94 static Error handleCustomErrorUP(std::unique_ptr<CustomError> CE) {
  95   return Error::success();
  96 }
  97
  98 static void handleCustomErrorUPVoid(std::unique_ptr<CustomError> CE) {}
  99
 100 // Test that success values implicitly convert to false, and don't cause crashes
 101 // once they've been implicitly converted.
 102 TEST(Error, CheckedSuccess) {
 103   Error E = Error::success();
 104   EXPECT_FALSE(E) << "Unexpected error while testing Error 'Success'";
 105 }
 106
 107 // Test that unchecked success values cause an abort.
 108 #if LLVM_ENABLE_ABI_BREAKING_CHECKS
 109 TEST(Error, UncheckedSuccess) {
 110   EXPECT_DEATH({ Error E = Error::success(); },
 111                "Program aborted due to an unhandled Error:")
 112       << "Unchecked Error Succes value did not cause abort()";
 113 }
 114 #endif
 115
 116 // ErrorAsOutParameter tester.
 117 void errAsOutParamHelper(Error &Err) {
 118   ErrorAsOutParameter ErrAsOutParam(&Err);
 119   // Verify that checked flag is raised - assignment should not crash.
 120   Err = Error::success();
 121   // Raise the checked bit manually - caller should still have to test the
 122   // error.
 123   (void)!!Err;
 124 }
 125
 126 // Test that ErrorAsOutParameter sets the checked flag on construction.
 127 TEST(Error, ErrorAsOutParameterChecked) {
 128   Error E = Error::success();
 129   errAsOutParamHelper(E);
 130   (void)!!E;
 131 }
 132
 133 // Test that ErrorAsOutParameter clears the checked flag on destruction.
 134 #if LLVM_ENABLE_ABI_BREAKING_CHECKS
 135 TEST(Error, ErrorAsOutParameterUnchecked) {
 136   EXPECT_DEATH({ Error E = Error::success(); errAsOutParamHelper(E); },
 137                "Program aborted due to an unhandled Error:")
 138       << "ErrorAsOutParameter did not clear the checked flag on destruction.";
 139 }
 140 #endif
 141
 142 // Check that we abort on unhandled failure cases. (Force conversion to bool
 143 // to make sure that we don't accidentally treat checked errors as handled).
 144 // Test runs in debug mode only.
 145 #if LLVM_ENABLE_ABI_BREAKING_CHECKS
 146 TEST(Error, UncheckedError) {
 147   auto DropUnhandledError = []() {
 148     Error E = make_error<CustomError>(42);
 149     (void)!E;
 150   };
 151   EXPECT_DEATH(DropUnhandledError(),
 152                "Program aborted due to an unhandled Error:")
 153       << "Unhandled Error failure value did not cause abort()";
 154 }
 155 #endif
 156
 157 // Check 'Error::isA<T>' method handling.
 158 TEST(Error, IsAHandling) {
 159   // Check 'isA' handling.
 160   Error E = make_error<CustomError>(1);
 161   Error F = make_error<CustomSubError>(1, 2);
 162   Error G = Error::success();
 163
 164   EXPECT_TRUE(E.isA<CustomError>());
 165   EXPECT_FALSE(E.isA<CustomSubError>());
 166   EXPECT_TRUE(F.isA<CustomError>());
 167   EXPECT_TRUE(F.isA<CustomSubError>());
 168   EXPECT_FALSE(G.isA<CustomError>());
 169
 170   consumeError(std::move(E));
 171   consumeError(std::move(F));
 172   consumeError(std::move(G));
 173 }
 174
 175 // Check that we can handle a custom error.
 176 TEST(Error, HandleCustomError) {
 177   int CaughtErrorInfo = 0;
 178   handleAllErrors(make_error<CustomError>(42), [&](const CustomError &CE) {
 179     CaughtErrorInfo = CE.getInfo();
 180   });
 181
 182   EXPECT_TRUE(CaughtErrorInfo == 42) << "Wrong result from CustomError handler";
 183 }
 184
 185 // Check that handler type deduction also works for handlers
 186 // of the following types:
 187 // void (const Err&)
 188 // Error (const Err&) mutable
 189 // void (const Err&) mutable
 190 // Error (Err&)
 191 // void (Err&)
 192 // Error (Err&) mutable
 193 // void (Err&) mutable
 194 // Error (unique_ptr<Err>)
 195 // void (unique_ptr<Err>)
 196 // Error (unique_ptr<Err>) mutable
 197 // void (unique_ptr<Err>) mutable
 198 TEST(Error, HandlerTypeDeduction) {
 199
 200   handleAllErrors(make_error<CustomError>(42), [](const CustomError &CE) {});
 201
 202   handleAllErrors(
 203       make_error<CustomError>(42),
 204       [](const CustomError &CE) mutable  -> Error { return Error::success(); });
 205
 206   handleAllErrors(make_error<CustomError>(42),
 207                   [](const CustomError &CE) mutable {});
 208
 209   handleAllErrors(make_error<CustomError>(42),
 210                   [](CustomError &CE) -> Error { return Error::success(); });
 211
 212   handleAllErrors(make_error<CustomError>(42), [](CustomError &CE) {});
 213
 214   handleAllErrors(make_error<CustomError>(42),
 215                   [](CustomError &CE) mutable -> Error { return Error::success(); });
 216
 217   handleAllErrors(make_error<CustomError>(42), [](CustomError &CE) mutable {});
 218
 219   handleAllErrors(
 220       make_error<CustomError>(42),
 221       [](std::unique_ptr<CustomError> CE) -> Error { return Error::success(); });
 222
 223   handleAllErrors(make_error<CustomError>(42),
 224                   [](std::unique_ptr<CustomError> CE) {});
 225
 226   handleAllErrors(
 227       make_error<CustomError>(42),
 228       [](std::unique_ptr<CustomError> CE) mutable -> Error { return Error::success(); });
 229
 230   handleAllErrors(make_error<CustomError>(42),
 231                   [](std::unique_ptr<CustomError> CE) mutable {});
 232
 233   // Check that named handlers of type 'Error (const Err&)' work.
 234   handleAllErrors(make_error<CustomError>(42), handleCustomError);
 235
 236   // Check that named handlers of type 'void (const Err&)' work.
 237   handleAllErrors(make_error<CustomError>(42), handleCustomErrorVoid);
 238
 239   // Check that named handlers of type 'Error (std::unique_ptr<Err>)' work.
 240   handleAllErrors(make_error<CustomError>(42), handleCustomErrorUP);
 241
 242   // Check that named handlers of type 'Error (std::unique_ptr<Err>)' work.
 243   handleAllErrors(make_error<CustomError>(42), handleCustomErrorUPVoid);
 244 }
 245
 246 // Test that we can handle errors with custom base classes.
 247 TEST(Error, HandleCustomErrorWithCustomBaseClass) {
 248   int CaughtErrorInfo = 0;
 249   int CaughtErrorExtraInfo = 0;
 250   handleAllErrors(make_error<CustomSubError>(42, 7),
 251                   [&](const CustomSubError &SE) {
 252                     CaughtErrorInfo = SE.getInfo();
 253                     CaughtErrorExtraInfo = SE.getExtraInfo();
 254                   });
 255
 256   EXPECT_TRUE(CaughtErrorInfo == 42 && CaughtErrorExtraInfo == 7)
 257       << "Wrong result from CustomSubError handler";
 258 }
 259
 260 // Check that we trigger only the first handler that applies.
 261 TEST(Error, FirstHandlerOnly) {
 262   int DummyInfo = 0;
 263   int CaughtErrorInfo = 0;
 264   int CaughtErrorExtraInfo = 0;
 265
 266   handleAllErrors(make_error<CustomSubError>(42, 7),
 267                   [&](const CustomSubError &SE) {
 268                     CaughtErrorInfo = SE.getInfo();
 269                     CaughtErrorExtraInfo = SE.getExtraInfo();
 270                   },
 271                   [&](const CustomError &CE) { DummyInfo = CE.getInfo(); });
 272
 273   EXPECT_TRUE(CaughtErrorInfo == 42 && CaughtErrorExtraInfo == 7 &&
 274               DummyInfo == 0)
 275       << "Activated the wrong Error handler(s)";
 276 }
 277
 278 // Check that general handlers shadow specific ones.
 279 TEST(Error, HandlerShadowing) {
 280   int CaughtErrorInfo = 0;
 281   int DummyInfo = 0;
 282   int DummyExtraInfo = 0;
 283
 284   handleAllErrors(
 285       make_error<CustomSubError>(42, 7),
 286       [&](const CustomError &CE) { CaughtErrorInfo = CE.getInfo(); },
 287       [&](const CustomSubError &SE) {
 288         DummyInfo = SE.getInfo();
 289         DummyExtraInfo = SE.getExtraInfo();
 290       });
 291
 292   EXPECT_TRUE(CaughtErrorInfo == 42 && DummyInfo == 0 && DummyExtraInfo == 0)
 293       << "General Error handler did not shadow specific handler";
 294 }
 295
 296 // Test joinErrors.
 297 TEST(Error, CheckJoinErrors) {
 298   int CustomErrorInfo1 = 0;
 299   int CustomErrorInfo2 = 0;
 300   int CustomErrorExtraInfo = 0;
 301   Error E =
 302       joinErrors(make_error<CustomError>(7), make_error<CustomSubError>(42, 7));
 303
 304   handleAllErrors(std::move(E),
 305                   [&](const CustomSubError &SE) {
 306                     CustomErrorInfo2 = SE.getInfo();
 307                     CustomErrorExtraInfo = SE.getExtraInfo();
 308                   },
 309                   [&](const CustomError &CE) {
 310                     // Assert that the CustomError instance above is handled
 311                     // before the
 312                     // CustomSubError - joinErrors should preserve error
 313                     // ordering.
 314                     EXPECT_EQ(CustomErrorInfo2, 0)
 315                         << "CustomErrorInfo2 should be 0 here. "
 316                            "joinErrors failed to preserve ordering.\n";
 317                     CustomErrorInfo1 = CE.getInfo();
 318                   });
 319
 320   EXPECT_TRUE(CustomErrorInfo1 == 7 && CustomErrorInfo2 == 42 &&
 321               CustomErrorExtraInfo == 7)
 322       << "Failed handling compound Error.";
 323
 324   // Test appending a single item to a list.
 325   {
 326     int Sum = 0;
 327     handleAllErrors(
 328         joinErrors(
 329             joinErrors(make_error<CustomError>(7),
 330                        make_error<CustomError>(7)),
 331             make_error<CustomError>(7)),
 332         [&](const CustomError &CE) {
 333           Sum += CE.getInfo();
 334         });
 335     EXPECT_EQ(Sum, 21) << "Failed to correctly append error to error list.";
 336   }
 337
 338   // Test prepending a single item to a list.
 339   {
 340     int Sum = 0;
 341     handleAllErrors(
 342         joinErrors(
 343             make_error<CustomError>(7),
 344             joinErrors(make_error<CustomError>(7),
 345                        make_error<CustomError>(7))),
 346         [&](const CustomError &CE) {
 347           Sum += CE.getInfo();
 348         });
 349     EXPECT_EQ(Sum, 21) << "Failed to correctly prepend error to error list.";
 350   }
 351
 352   // Test concatenating two error lists.
 353   {
 354     int Sum = 0;
 355     handleAllErrors(
 356         joinErrors(
 357             joinErrors(
 358                 make_error<CustomError>(7),
 359                 make_error<CustomError>(7)),
 360             joinErrors(
 361                 make_error<CustomError>(7),
 362                 make_error<CustomError>(7))),
 363         [&](const CustomError &CE) {
 364           Sum += CE.getInfo();
 365         });
 366     EXPECT_EQ(Sum, 28) << "Failed to correctly concatenate error lists.";
 367   }
 368 }
 369
 370 // Test that we can consume success values.
 371 TEST(Error, ConsumeSuccess) {
 372   Error E = Error::success();
 373   consumeError(std::move(E));
 374 }
 375
 376 TEST(Error, ConsumeError) {
 377   Error E = make_error<CustomError>(7);
 378   consumeError(std::move(E));
 379 }
 380
 381 // Test that handleAllUnhandledErrors crashes if an error is not caught.
 382 // Test runs in debug mode only.
 383 #if LLVM_ENABLE_ABI_BREAKING_CHECKS
 384 TEST(Error, FailureToHandle) {
 385   auto FailToHandle = []() {
 386     handleAllErrors(make_error<CustomError>(7), [&](const CustomSubError &SE) {
 387       errs() << "This should never be called";
 388       exit(1);
 389     });
 390   };
 391
 392   EXPECT_DEATH(FailToHandle(),
 393                "Failure value returned from cantFail wrapped call")
 394       << "Unhandled Error in handleAllErrors call did not cause an "
 395          "abort()";
 396 }
 397 #endif
 398
 399 // Test that handleAllUnhandledErrors crashes if an error is returned from a
 400 // handler.
 401 // Test runs in debug mode only.
 402 #if LLVM_ENABLE_ABI_BREAKING_CHECKS
 403 TEST(Error, FailureFromHandler) {
 404   auto ReturnErrorFromHandler = []() {
 405     handleAllErrors(make_error<CustomError>(7),
 406                     [&](std::unique_ptr<CustomSubError> SE) {
 407                       return Error(std::move(SE));
 408                     });
 409   };
 410
 411   EXPECT_DEATH(ReturnErrorFromHandler(),
 412                "Failure value returned from cantFail wrapped call")
 413       << " Error returned from handler in handleAllErrors call did not "
 414          "cause abort()";
 415 }
 416 #endif
 417
 418 // Test that we can return values from handleErrors.
 419 TEST(Error, CatchErrorFromHandler) {
 420   int ErrorInfo = 0;
 421
 422   Error E = handleErrors(
 423       make_error<CustomError>(7),
 424       [&](std::unique_ptr<CustomError> CE) { return Error(std::move(CE)); });
 425
 426   handleAllErrors(std::move(E),
 427                   [&](const CustomError &CE) { ErrorInfo = CE.getInfo(); });
 428
 429   EXPECT_EQ(ErrorInfo, 7)
 430       << "Failed to handle Error returned from handleErrors.";
 431 }
 432
 433 TEST(Error, StringError) {
 434   std::string Msg;
 435   raw_string_ostream S(Msg);
 436   logAllUnhandledErrors(
 437       make_error<StringError>("foo" + Twine(42), inconvertibleErrorCode()), S);
 438   EXPECT_EQ(S.str(), "foo42\n") << "Unexpected StringError log result";
 439
 440   auto EC =
 441     errorToErrorCode(make_error<StringError>("", errc::invalid_argument));
 442   EXPECT_EQ(EC, errc::invalid_argument)
 443     << "Failed to convert StringError to error_code.";
 444 }
 445
 446 TEST(Error, createStringError) {
 447   static const char *Bar = "bar";
 448   static const std::error_code EC = errc::invalid_argument;
 449   std::string Msg;
 450   raw_string_ostream S(Msg);
 451   logAllUnhandledErrors(createStringError(EC, "foo%s%d0x%" PRIx8, Bar, 1, 0xff),
 452                         S);
 453   EXPECT_EQ(S.str(), "foobar10xff\n")
 454     << "Unexpected createStringError() log result";
 455
 456   S.flush();
 457   Msg.clear();
 458   logAllUnhandledErrors(createStringError(EC, Bar), S);
 459   EXPECT_EQ(S.str(), "bar\n")
 460     << "Unexpected createStringError() (overloaded) log result";
 461
 462   S.flush();
 463   Msg.clear();
 464   auto Res = errorToErrorCode(createStringError(EC, "foo%s", Bar));
 465   EXPECT_EQ(Res, EC)
 466     << "Failed to convert createStringError() result to error_code.";
 467 }
 468
 469 // Test that the ExitOnError utility works as expected.
 470 TEST(Error, ExitOnError) {
 471   ExitOnError ExitOnErr;
 472   ExitOnErr.setBanner("Error in tool:");
 473   ExitOnErr.setExitCodeMapper([](const Error &E) {
 474     if (E.isA<CustomSubError>())
 475       return 2;
 476     return 1;
 477   });
 478
 479   // Make sure we don't bail on success.
 480   ExitOnErr(Error::success());
 481   EXPECT_EQ(ExitOnErr(Expected<int>(7)), 7)
 482       << "exitOnError returned an invalid value for Expected";
 483
 484   int A = 7;
 485   int &B = ExitOnErr(Expected<int&>(A));
 486   EXPECT_EQ(&A, &B) << "ExitOnError failed to propagate reference";
 487
 488   // Exit tests.
 489   EXPECT_EXIT(ExitOnErr(make_error<CustomError>(7)),
 490               ::testing::ExitedWithCode(1), "Error in tool:")
 491       << "exitOnError returned an unexpected error result";
 492
 493   EXPECT_EXIT(ExitOnErr(Expected<int>(make_error<CustomSubError>(0, 0))),
 494               ::testing::ExitedWithCode(2), "Error in tool:")
 495       << "exitOnError returned an unexpected error result";
 496 }
 497
 498 // Test that the ExitOnError utility works as expected.
 499 TEST(Error, CantFailSuccess) {
 500   cantFail(Error::success());
 501
 502   int X = cantFail(Expected<int>(42));
 503   EXPECT_EQ(X, 42) << "Expected value modified by cantFail";
 504
 505   int Dummy = 42;
 506   int &Y = cantFail(Expected<int&>(Dummy));
 507   EXPECT_EQ(&Dummy, &Y) << "Reference mangled by cantFail";
 508 }
 509
 510 // Test that cantFail results in a crash if you pass it a failure value.
 511 #if LLVM_ENABLE_ABI_BREAKING_CHECKS && !defined(NDEBUG)
 512 TEST(Error, CantFailDeath) {
 513   EXPECT_DEATH(
 514       cantFail(make_error<StringError>("foo", inconvertibleErrorCode()),
 515                "Cantfail call failed"),
 516       "Cantfail call failed")
 517     << "cantFail(Error) did not cause an abort for failure value";
 518
 519   EXPECT_DEATH(
 520       {
 521         auto IEC = inconvertibleErrorCode();
 522         int X = cantFail(Expected<int>(make_error<StringError>("foo", IEC)));
 523         (void)X;
 524       },
 525       "Failure value returned from cantFail wrapped call")
 526     << "cantFail(Expected<int>) did not cause an abort for failure value";
 527 }
 528 #endif
 529
 530
 531 // Test Checked Expected<T> in success mode.
 532 TEST(Error, CheckedExpectedInSuccessMode) {
 533   Expected<int> A = 7;
 534   EXPECT_TRUE(!!A) << "Expected with non-error value doesn't convert to 'true'";
 535   // Access is safe in second test, since we checked the error in the first.
 536   EXPECT_EQ(*A, 7) << "Incorrect Expected non-error value";
 537 }
 538
 539 // Test Expected with reference type.
 540 TEST(Error, ExpectedWithReferenceType) {
 541   int A = 7;
 542   Expected<int&> B = A;
 543   // 'Check' B.
 544   (void)!!B;
 545   int &C = *B;
 546   EXPECT_EQ(&A, &C) << "Expected failed to propagate reference";
 547 }
 548
 549 // Test Unchecked Expected<T> in success mode.
 550 // We expect this to blow up the same way Error would.
 551 // Test runs in debug mode only.
 552 #if LLVM_ENABLE_ABI_BREAKING_CHECKS
 553 TEST(Error, UncheckedExpectedInSuccessModeDestruction) {
 554   EXPECT_DEATH({ Expected<int> A = 7; },
 555                "Expected<T> must be checked before access or destruction.")
 556     << "Unchecekd Expected<T> success value did not cause an abort().";
 557 }
 558 #endif
 559
 560 // Test Unchecked Expected<T> in success mode.
 561 // We expect this to blow up the same way Error would.
 562 // Test runs in debug mode only.
 563 #if LLVM_ENABLE_ABI_BREAKING_CHECKS
 564 TEST(Error, UncheckedExpectedInSuccessModeAccess) {
 565   EXPECT_DEATH({ Expected<int> A = 7; *A; },
 566                "Expected<T> must be checked before access or destruction.")
 567     << "Unchecekd Expected<T> success value did not cause an abort().";
 568 }
 569 #endif
 570
 571 // Test Unchecked Expected<T> in success mode.
 572 // We expect this to blow up the same way Error would.
 573 // Test runs in debug mode only.
 574 #if LLVM_ENABLE_ABI_BREAKING_CHECKS
 575 TEST(Error, UncheckedExpectedInSuccessModeAssignment) {
 576   EXPECT_DEATH({ Expected<int> A = 7; A = 7; },
 577                "Expected<T> must be checked before access or destruction.")
 578     << "Unchecekd Expected<T> success value did not cause an abort().";
 579 }
 580 #endif
 581
 582 // Test Expected<T> in failure mode.
 583 TEST(Error, ExpectedInFailureMode) {
 584   Expected<int> A = make_error<CustomError>(42);
 585   EXPECT_FALSE(!!A) << "Expected with error value doesn't convert to 'false'";
 586   Error E = A.takeError();
 587   EXPECT_TRUE(E.isA<CustomError>()) << "Incorrect Expected error value";
 588   consumeError(std::move(E));
 589 }
 590
 591 // Check that an Expected instance with an error value doesn't allow access to
 592 // operator*.
 593 // Test runs in debug mode only.
 594 #if LLVM_ENABLE_ABI_BREAKING_CHECKS
 595 TEST(Error, AccessExpectedInFailureMode) {
 596   Expected<int> A = make_error<CustomError>(42);
 597   EXPECT_DEATH(*A, "Expected<T> must be checked before access or destruction.")
 598       << "Incorrect Expected error value";
 599   consumeError(A.takeError());
 600 }
 601 #endif
 602
 603 // Check that an Expected instance with an error triggers an abort if
 604 // unhandled.
 605 // Test runs in debug mode only.
 606 #if LLVM_ENABLE_ABI_BREAKING_CHECKS
 607 TEST(Error, UnhandledExpectedInFailureMode) {
 608   EXPECT_DEATH({ Expected<int> A = make_error<CustomError>(42); },
 609                "Expected<T> must be checked before access or destruction.")
 610       << "Unchecked Expected<T> failure value did not cause an abort()";
 611 }
 612 #endif
 613
 614 // Test covariance of Expected.
 615 TEST(Error, ExpectedCovariance) {
 616   class B {};
 617   class D : public B {};
 618
 619   Expected<B *> A1(Expected<D *>(nullptr));
 620   // Check A1 by converting to bool before assigning to it.
 621   (void)!!A1;
 622   A1 = Expected<D *>(nullptr);
 623   // Check A1 again before destruction.
 624   (void)!!A1;
 625
 626   Expected<std::unique_ptr<B>> A2(Expected<std::unique_ptr<D>>(nullptr));
 627   // Check A2 by converting to bool before assigning to it.
 628   (void)!!A2;
 629   A2 = Expected<std::unique_ptr<D>>(nullptr);
 630   // Check A2 again before destruction.
 631   (void)!!A2;
 632 }
 633
 634 // Test that handleExpected just returns success values.
 635 TEST(Error, HandleExpectedSuccess) {
 636   auto ValOrErr =
 637     handleExpected(Expected<int>(42),
 638                    []() { return Expected<int>(43); });
 639   EXPECT_TRUE(!!ValOrErr)
 640     << "handleExpected should have returned a success value here";
 641   EXPECT_EQ(*ValOrErr, 42)
 642     << "handleExpected should have returned the original success value here";
 643 }
 644
 645 enum FooStrategy { Aggressive, Conservative };
 646
 647 static Expected<int> foo(FooStrategy S) {
 648   if (S == Aggressive)
 649     return make_error<CustomError>(7);
 650   return 42;
 651 }
 652
 653 // Test that handleExpected invokes the error path if errors are not handled.
 654 TEST(Error, HandleExpectedUnhandledError) {
 655   // foo(Aggressive) should return a CustomError which should pass through as
 656   // there is no handler for CustomError.
 657   auto ValOrErr =
 658     handleExpected(
 659       foo(Aggressive),
 660       []() { return foo(Conservative); });
 661
 662   EXPECT_FALSE(!!ValOrErr)
 663     << "handleExpected should have returned an error here";
 664   auto Err = ValOrErr.takeError();
 665   EXPECT_TRUE(Err.isA<CustomError>())
 666     << "handleExpected should have returned the CustomError generated by "
 667     "foo(Aggressive) here";
 668   consumeError(std::move(Err));
 669 }
 670
 671 // Test that handleExpected invokes the fallback path if errors are handled.
 672 TEST(Error, HandleExpectedHandledError) {
 673   // foo(Aggressive) should return a CustomError which should handle triggering
 674   // the fallback path.
 675   auto ValOrErr =
 676     handleExpected(
 677       foo(Aggressive),
 678       []() { return foo(Conservative); },
 679       [](const CustomError&) { /* do nothing */ });
 680
 681   EXPECT_TRUE(!!ValOrErr)
 682     << "handleExpected should have returned a success value here";
 683   EXPECT_EQ(*ValOrErr, 42)
 684     << "handleExpected returned the wrong success value";
 685 }
 686
 687 TEST(Error, ErrorCodeConversions) {
 688   // Round-trip a success value to check that it converts correctly.
 689   EXPECT_EQ(errorToErrorCode(errorCodeToError(std::error_code())),
 690             std::error_code())
 691       << "std::error_code() should round-trip via Error conversions";
 692
 693   // Round-trip an error value to check that it converts correctly.
 694   EXPECT_EQ(errorToErrorCode(errorCodeToError(errc::invalid_argument)),
 695             errc::invalid_argument)
 696       << "std::error_code error value should round-trip via Error "
 697          "conversions";
 698
 699   // Round-trip a success value through ErrorOr/Expected to check that it
 700   // converts correctly.
 701   {
 702     auto Orig = ErrorOr<int>(42);
 703     auto RoundTripped =
 704       expectedToErrorOr(errorOrToExpected(ErrorOr<int>(42)));
 705     EXPECT_EQ(*Orig, *RoundTripped)
 706       << "ErrorOr<T> success value should round-trip via Expected<T> "
 707          "conversions.";
 708   }
 709
 710   // Round-trip a failure value through ErrorOr/Expected to check that it
 711   // converts correctly.
 712   {
 713     auto Orig = ErrorOr<int>(errc::invalid_argument);
 714     auto RoundTripped =
 715       expectedToErrorOr(
 716           errorOrToExpected(ErrorOr<int>(errc::invalid_argument)));
 717     EXPECT_EQ(Orig.getError(), RoundTripped.getError())
 718       << "ErrorOr<T> failure value should round-trip via Expected<T> "
 719          "conversions.";
 720   }
 721 }
 722
 723 // Test that error messages work.
 724 TEST(Error, ErrorMessage) {
 725   EXPECT_EQ(toString(Error::success()).compare(""), 0);
 726
 727   Error E1 = make_error<CustomError>(0);
 728   EXPECT_EQ(toString(std::move(E1)).compare("CustomError {0}"), 0);
 729
 730   Error E2 = make_error<CustomError>(0);
 731   handleAllErrors(std::move(E2), [](const CustomError &CE) {
 732     EXPECT_EQ(CE.message().compare("CustomError {0}"), 0);
 733   });
 734
 735   Error E3 = joinErrors(make_error<CustomError>(0), make_error<CustomError>(1));
 736   EXPECT_EQ(toString(std::move(E3))
 737                 .compare("CustomError {0}\n"
 738                          "CustomError {1}"),
 739             0);
 740 }
 741
 742 TEST(Error, Stream) {
 743   {
 744     Error OK = Error::success();
 745     std::string Buf;
 746     llvm::raw_string_ostream S(Buf);
 747     S << OK;
 748     EXPECT_EQ("success", S.str());
 749     consumeError(std::move(OK));
 750   }
 751   {
 752     Error E1 = make_error<CustomError>(0);
 753     std::string Buf;
 754     llvm::raw_string_ostream S(Buf);
 755     S << E1;
 756     EXPECT_EQ("CustomError {0}", S.str());
 757     consumeError(std::move(E1));
 758   }
 759 }
 760
 761 TEST(Error, ErrorMatchers) {
 762   EXPECT_THAT_ERROR(Error::success(), Succeeded());
 763   EXPECT_NONFATAL_FAILURE(
 764       EXPECT_THAT_ERROR(make_error<CustomError>(0), Succeeded()),
 765       "Expected: succeeded\n  Actual: failed  (CustomError {0})");
 766
 767   EXPECT_THAT_ERROR(make_error<CustomError>(0), Failed());
 768   EXPECT_NONFATAL_FAILURE(EXPECT_THAT_ERROR(Error::success(), Failed()),
 769                           "Expected: failed\n  Actual: succeeded");
 770
 771   EXPECT_THAT_ERROR(make_error<CustomError>(0), Failed<CustomError>());
 772   EXPECT_NONFATAL_FAILURE(
 773       EXPECT_THAT_ERROR(Error::success(), Failed<CustomError>()),
 774       "Expected: failed with Error of given type\n  Actual: succeeded");
 775   EXPECT_NONFATAL_FAILURE(
 776       EXPECT_THAT_ERROR(make_error<CustomError>(0), Failed<CustomSubError>()),
 777       "Error was not of given type");
 778   EXPECT_NONFATAL_FAILURE(
 779       EXPECT_THAT_ERROR(
 780           joinErrors(make_error<CustomError>(0), make_error<CustomError>(1)),
 781           Failed<CustomError>()),
 782       "multiple errors");
 783
 784   EXPECT_THAT_ERROR(
 785       make_error<CustomError>(0),
 786       Failed<CustomError>(testing::Property(&CustomError::getInfo, 0)));
 787   EXPECT_NONFATAL_FAILURE(
 788       EXPECT_THAT_ERROR(
 789           make_error<CustomError>(0),
 790           Failed<CustomError>(testing::Property(&CustomError::getInfo, 1))),
 791       "Expected: failed with Error of given type and the error is an object "
 792       "whose given property is equal to 1\n"
 793       "  Actual: failed  (CustomError {0})");
 794   EXPECT_THAT_ERROR(make_error<CustomError>(0), Failed<ErrorInfoBase>());
 795
 796   EXPECT_THAT_EXPECTED(Expected<int>(0), Succeeded());
 797   EXPECT_NONFATAL_FAILURE(
 798       EXPECT_THAT_EXPECTED(Expected<int>(make_error<CustomError>(0)),
 799                            Succeeded()),
 800       "Expected: succeeded\n  Actual: failed  (CustomError {0})");
 801
 802   EXPECT_THAT_EXPECTED(Expected<int>(make_error<CustomError>(0)), Failed());
 803   EXPECT_NONFATAL_FAILURE(
 804       EXPECT_THAT_EXPECTED(Expected<int>(0), Failed()),
 805       "Expected: failed\n  Actual: succeeded with value 0");
 806
 807   EXPECT_THAT_EXPECTED(Expected<int>(0), HasValue(0));
 808   EXPECT_NONFATAL_FAILURE(
 809       EXPECT_THAT_EXPECTED(Expected<int>(make_error<CustomError>(0)),
 810                            HasValue(0)),
 811       "Expected: succeeded with value (is equal to 0)\n"
 812       "  Actual: failed  (CustomError {0})");
 813   EXPECT_NONFATAL_FAILURE(
 814       EXPECT_THAT_EXPECTED(Expected<int>(1), HasValue(0)),
 815       "Expected: succeeded with value (is equal to 0)\n"
 816       "  Actual: succeeded with value 1, (isn't equal to 0)");
 817
 818   EXPECT_THAT_EXPECTED(Expected<int &>(make_error<CustomError>(0)), Failed());
 819   int a = 1;
 820   EXPECT_THAT_EXPECTED(Expected<int &>(a), Succeeded());
 821   EXPECT_THAT_EXPECTED(Expected<int &>(a), HasValue(testing::Eq(1)));
 822
 823   EXPECT_THAT_EXPECTED(Expected<int>(1), HasValue(testing::Gt(0)));
 824   EXPECT_NONFATAL_FAILURE(
 825       EXPECT_THAT_EXPECTED(Expected<int>(0), HasValue(testing::Gt(1))),
 826       "Expected: succeeded with value (is > 1)\n"
 827       "  Actual: succeeded with value 0, (isn't > 1)");
 828   EXPECT_NONFATAL_FAILURE(
 829       EXPECT_THAT_EXPECTED(Expected<int>(make_error<CustomError>(0)),
 830                            HasValue(testing::Gt(1))),
 831       "Expected: succeeded with value (is > 1)\n"
 832       "  Actual: failed  (CustomError {0})");
 833 }
 834
 835 TEST(Error, C_API) {
 836   EXPECT_THAT_ERROR(unwrap(wrap(Error::success())), Succeeded())
 837       << "Failed to round-trip Error success value via C API";
 838   EXPECT_THAT_ERROR(unwrap(wrap(make_error<CustomError>(0))),
 839                     Failed<CustomError>())
 840       << "Failed to round-trip Error failure value via C API";
 841
 842   auto Err =
 843       wrap(make_error<StringError>("test message", inconvertibleErrorCode()));
 844   EXPECT_EQ(LLVMGetErrorTypeId(Err), LLVMGetStringErrorTypeId())
 845       << "Failed to match error type ids via C API";
 846   char *ErrMsg = LLVMGetErrorMessage(Err);
 847   EXPECT_STREQ(ErrMsg, "test message")
 848       << "Failed to roundtrip StringError error message via C API";
 849   LLVMDisposeErrorMessage(ErrMsg);
 850
 851   bool GotCSE = false;
 852   bool GotCE = false;
 853   handleAllErrors(
 854     unwrap(wrap(joinErrors(make_error<CustomSubError>(42, 7),
 855                            make_error<CustomError>(42)))),
 856     [&](CustomSubError &CSE) {
 857       GotCSE = true;
 858     },
 859     [&](CustomError &CE) {
 860       GotCE = true;
 861     });
 862   EXPECT_TRUE(GotCSE) << "Failed to round-trip ErrorList via C API";
 863   EXPECT_TRUE(GotCE) << "Failed to round-trip ErrorList via C API";
 864 }
 865
 866 TEST(Error, FileErrorTest) {
 867 #if !defined(NDEBUG) && GTEST_HAS_DEATH_TEST
 868     EXPECT_DEATH(
 869       {
 870         Error S = Error::success();
 871         consumeError(createFileError("file.bin", std::move(S)));
 872       },
 873       "");
 874 #endif
 875   // Not allowed, would fail at compile-time
 876   //consumeError(createFileError("file.bin", ErrorSuccess()));
 877
 878   Error E1 = make_error<CustomError>(1);
 879   Error FE1 = createFileError("file.bin", std::move(E1));
 880   EXPECT_EQ(toString(std::move(FE1)).compare("'file.bin': CustomError {1}"), 0);
 881
 882   Error E2 = make_error<CustomError>(2);
 883   Error FE2 = createFileError("file.bin", std::move(E2));
 884   handleAllErrors(std::move(FE2), [](const FileError &F) {
 885     EXPECT_EQ(F.message().compare("'file.bin': CustomError {2}"), 0);
 886   });
 887
 888   Error E3 = make_error<CustomError>(3);
 889   Error FE3 = createFileError("file.bin", std::move(E3));
 890   auto E31 = handleErrors(std::move(FE3), [](std::unique_ptr<FileError> F) {
 891     return F->takeError();
 892   });
 893   handleAllErrors(std::move(E31), [](const CustomError &C) {
 894     EXPECT_EQ(C.message().compare("CustomError {3}"), 0);
 895   });
 896
 897   Error FE4 =
 898       joinErrors(createFileError("file.bin", make_error<CustomError>(41)),
 899                  createFileError("file2.bin", make_error<CustomError>(42)));
 900   EXPECT_EQ(toString(std::move(FE4))
 901                 .compare("'file.bin': CustomError {41}\n"
 902                          "'file2.bin': CustomError {42}"),
 903             0);
 904 }
 905
 906 enum class test_error_code {
 907   unspecified = 1,
 908   error_1,
 909   error_2,
 910 };
 911
 912 } // end anon namespace
 913
 914 namespace std {
 915     template <>
 916     struct is_error_code_enum<test_error_code> : std::true_type {};
 917 } // namespace std
 918
 919 namespace {
 920
 921 const std::error_category &TErrorCategory();
 922
 923 inline std::error_code make_error_code(test_error_code E) {
 924     return std::error_code(static_cast<int>(E), TErrorCategory());
 925 }
 926
 927 class TestDebugError : public ErrorInfo<TestDebugError, StringError> {
 928 public:
 929     using ErrorInfo<TestDebugError, StringError >::ErrorInfo; // inherit constructors
 930     TestDebugError(const Twine &S) : ErrorInfo(S, test_error_code::unspecified) {}
 931     static char ID;
 932 };
 933
 934 class TestErrorCategory : public std::error_category {
 935 public:
 936   const char *name() const noexcept override { return "error"; }
 937   std::string message(int Condition) const override {
 938     switch (static_cast<test_error_code>(Condition)) {
 939     case test_error_code::unspecified:
 940       return "An unknown error has occurred.";
 941     case test_error_code::error_1:
 942       return "Error 1.";
 943     case test_error_code::error_2:
 944       return "Error 2.";
 945     }
 946     llvm_unreachable("Unrecognized test_error_code");
 947   }
 948 };
 949
 950 static llvm::ManagedStatic<TestErrorCategory> TestErrCategory;
 951 const std::error_category &TErrorCategory() { return *TestErrCategory; }
 952
 953 char TestDebugError::ID;
 954
 955 TEST(Error, SubtypeStringErrorTest) {
 956   auto E1 = make_error<TestDebugError>(test_error_code::error_1);
 957   EXPECT_EQ(toString(std::move(E1)).compare("Error 1."), 0);
 958
 959   auto E2 = make_error<TestDebugError>(test_error_code::error_1,
 960                                        "Detailed information");
 961   EXPECT_EQ(toString(std::move(E2)).compare("Error 1. Detailed information"),
 962             0);
 963
 964   auto E3 = make_error<TestDebugError>(test_error_code::error_2);
 965   handleAllErrors(std::move(E3), [](const TestDebugError &F) {
 966     EXPECT_EQ(F.message().compare("Error 2."), 0);
 967   });
 968
 969   auto E4 = joinErrors(make_error<TestDebugError>(test_error_code::error_1,
 970                                                   "Detailed information"),
 971                        make_error<TestDebugError>(test_error_code::error_2));
 972   EXPECT_EQ(toString(std::move(E4))
 973                 .compare("Error 1. Detailed information\n"
 974                          "Error 2."),
 975             0);
 976 }
 977
 978 } // namespace