mirror of
https://github.com/RPCS3/llvm.git
synced 2025-02-13 14:46:15 +00:00
[Support] Refactor Error unit tests to avoid duplicating work.
Suggested by Dave Blaikie in review for r263749. Thanks Dave! git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@263768 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Lang Hames
parent
d615f87316
commit
ec1cb3a98d
@ -16,43 +16,6 @@ using namespace llvm;
|
||||
|
||||
namespace {
|
||||
|
||||
// Test:
|
||||
//
|
||||
// Constructing success.
|
||||
// - Silent acceptance of tested success.
|
||||
// - Programmatic error on untested success.
|
||||
//
|
||||
// Custom error class.
|
||||
// - Creation of a custom error class with a default base class.
|
||||
// - Handling of a custom error class with a default base class.
|
||||
// - Handler type deduction.
|
||||
// - Failure to handle a custom error class.
|
||||
// - Isa testing of a custom error class.
|
||||
//
|
||||
// - Creation of a custom error class with a custom base class.
|
||||
// - Handling of a custom error class with a default base class.
|
||||
// - Correct shadowing of handlers.
|
||||
//
|
||||
// Utility functions:
|
||||
// - join_errors to defer errors.
|
||||
// - consume_error to consume a "safe" error without any output.
|
||||
// - handleAllUnhandledErrors to assert that all errors are handled.
|
||||
// - logAllUnhandledErrors to log errors to a stream.
|
||||
// - ExitOnError tests.
|
||||
//
|
||||
// Expected tests:
|
||||
// - Expected<T> with T.
|
||||
// - Expected<T> with Error.
|
||||
// - Failure to handle an Expected<T> in failure mode.
|
||||
// - Error extraction (Expected -> Error).
|
||||
//
|
||||
// std::error_code:
|
||||
// - std::error_code to Error in success mode.
|
||||
// - std::error_code to Error (ECError) in failure mode.
|
||||
// - Error to std::error_code in success mode.
|
||||
// - Error (ECError) to std::error_code in failure mode.
|
||||
//
|
||||
|
||||
// Custom error class with a default base class and some random 'info' attached.
|
||||
class CustomError : public ErrorInfo<CustomError> {
|
||||
public:
|
||||
@ -98,28 +61,6 @@ protected:
|
||||
int ExtraInfo;
|
||||
};
|
||||
|
||||
// Verify that success values that are checked (i.e. cast to 'bool') are
|
||||
// destructed without error, and that unchecked success values cause an
|
||||
// abort.
|
||||
TEST(Error, CheckSuccess) {
|
||||
// Test checked success.
|
||||
{
|
||||
Error E;
|
||||
EXPECT_FALSE(E) << "Unexpected error while testing Error 'Success'";
|
||||
}
|
||||
|
||||
// Test unchecked success.
|
||||
// Test runs in debug mode only.
|
||||
#ifndef NDEBUG
|
||||
{
|
||||
auto DropUncheckedSuccess = []() { Error E; };
|
||||
EXPECT_DEATH(DropUncheckedSuccess(),
|
||||
"Program aborted due to an unhandled Error:")
|
||||
<< "Unchecked Error Succes value did not cause abort()";
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
static Error handleCustomError(const CustomError &CE) { return Error(); }
|
||||
|
||||
static void handleCustomErrorVoid(const CustomError &CE) {}
|
||||
@ -130,64 +71,78 @@ static Error handleCustomErrorUP(std::unique_ptr<CustomError> CE) {
|
||||
|
||||
static void handleCustomErrorUPVoid(std::unique_ptr<CustomError> CE) {}
|
||||
|
||||
// Verify creation and handling of custom error classes.
|
||||
TEST(Error, CheckCustomErrors) {
|
||||
// Test that success values implicitly convert to false, and don't cause crashes
|
||||
// once they've been implicitly converted.
|
||||
TEST(Error, CheckedSuccess) {
|
||||
Error E;
|
||||
EXPECT_FALSE(E) << "Unexpected error while testing Error 'Success'";
|
||||
}
|
||||
|
||||
// Test that unchecked succes values cause an abort.
|
||||
#ifndef NDEBUG
|
||||
TEST(Error, UncheckedSuccess) {
|
||||
EXPECT_DEATH({ Error E; }, "Program aborted due to an unhandled Error:")
|
||||
<< "Unchecked Error Succes value did not cause abort()";
|
||||
}
|
||||
#endif
|
||||
|
||||
// Check that we abort on unhandled failure cases. (Force conversion to bool
|
||||
// to make sure that we don't accidentally treat checked errors as handled).
|
||||
// Test runs in debug mode only.
|
||||
#ifndef NDEBUG
|
||||
{
|
||||
auto DropUnhandledError = []() {
|
||||
Error E = make_error<CustomError>(42);
|
||||
(void)!E;
|
||||
};
|
||||
EXPECT_DEATH(DropUnhandledError(),
|
||||
"Program aborted due to an unhandled Error:")
|
||||
<< "Unhandled Error failure value did not cause abort()";
|
||||
}
|
||||
TEST(Error, UncheckedError) {
|
||||
auto DropUnhandledError = []() {
|
||||
Error E = make_error<CustomError>(42);
|
||||
(void)!E;
|
||||
};
|
||||
EXPECT_DEATH(DropUnhandledError(),
|
||||
"Program aborted due to an unhandled Error:")
|
||||
<< "Unhandled Error failure value did not cause abort()";
|
||||
}
|
||||
#endif
|
||||
|
||||
// Check 'Error::isA<T>' method handling.
|
||||
TEST(Error, IsAHandling) {
|
||||
// Check 'isA' handling.
|
||||
{
|
||||
Error E = make_error<CustomError>(1);
|
||||
Error F = make_error<CustomSubError>(1, 2);
|
||||
Error G = Error::success();
|
||||
Error E = make_error<CustomError>(1);
|
||||
Error F = make_error<CustomSubError>(1, 2);
|
||||
Error G = Error::success();
|
||||
|
||||
EXPECT_TRUE(E.isA<CustomError>());
|
||||
EXPECT_FALSE(E.isA<CustomSubError>());
|
||||
EXPECT_TRUE(F.isA<CustomError>());
|
||||
EXPECT_TRUE(F.isA<CustomSubError>());
|
||||
EXPECT_FALSE(G.isA<CustomError>());
|
||||
EXPECT_TRUE(E.isA<CustomError>());
|
||||
EXPECT_FALSE(E.isA<CustomSubError>());
|
||||
EXPECT_TRUE(F.isA<CustomError>());
|
||||
EXPECT_TRUE(F.isA<CustomSubError>());
|
||||
EXPECT_FALSE(G.isA<CustomError>());
|
||||
|
||||
consumeError(std::move(E));
|
||||
consumeError(std::move(F));
|
||||
consumeError(std::move(G));
|
||||
}
|
||||
consumeError(std::move(E));
|
||||
consumeError(std::move(F));
|
||||
consumeError(std::move(G));
|
||||
}
|
||||
|
||||
// Check that we can handle a custom error.
|
||||
{
|
||||
int CaughtErrorInfo = 0;
|
||||
handleAllErrors(make_error<CustomError>(42), [&](const CustomError &CE) {
|
||||
CaughtErrorInfo = CE.getInfo();
|
||||
});
|
||||
// Check that we can handle a custom error.
|
||||
TEST(Error, HandleCustomError) {
|
||||
int CaughtErrorInfo = 0;
|
||||
handleAllErrors(make_error<CustomError>(42), [&](const CustomError &CE) {
|
||||
CaughtErrorInfo = CE.getInfo();
|
||||
});
|
||||
|
||||
EXPECT_TRUE(CaughtErrorInfo == 42)
|
||||
<< "Wrong result from CustomError handler";
|
||||
}
|
||||
EXPECT_TRUE(CaughtErrorInfo == 42) << "Wrong result from CustomError handler";
|
||||
}
|
||||
|
||||
// Check that handler type deduction also works for handlers
|
||||
// of the following types:
|
||||
// void (const Err&)
|
||||
// Error (const Err&) mutable
|
||||
// void (const Err&) mutable
|
||||
// Error (Err&)
|
||||
// void (Err&)
|
||||
// Error (Err&) mutable
|
||||
// void (Err&) mutable
|
||||
// Error (unique_ptr<Err>)
|
||||
// void (unique_ptr<Err>)
|
||||
// Error (unique_ptr<Err>) mutable
|
||||
// void (unique_ptr<Err>) mutable
|
||||
// Check that handler type deduction also works for handlers
|
||||
// of the following types:
|
||||
// void (const Err&)
|
||||
// Error (const Err&) mutable
|
||||
// void (const Err&) mutable
|
||||
// Error (Err&)
|
||||
// void (Err&)
|
||||
// Error (Err&) mutable
|
||||
// void (Err&) mutable
|
||||
// Error (unique_ptr<Err>)
|
||||
// void (unique_ptr<Err>)
|
||||
// Error (unique_ptr<Err>) mutable
|
||||
// void (unique_ptr<Err>) mutable
|
||||
TEST(Error, HandlerTypeDeduction) {
|
||||
|
||||
handleAllErrors(make_error<CustomError>(42), [](const CustomError &CE) {});
|
||||
|
||||
@ -233,246 +188,226 @@ TEST(Error, CheckCustomErrors) {
|
||||
|
||||
// Check that named handlers of type 'Error (std::unique_ptr<Err>)' work.
|
||||
handleAllErrors(make_error<CustomError>(42), handleCustomErrorUPVoid);
|
||||
|
||||
// Check that we can handle a custom error with a custom base class.
|
||||
{
|
||||
int CaughtErrorInfo = 0;
|
||||
int CaughtErrorExtraInfo = 0;
|
||||
handleAllErrors(make_error<CustomSubError>(42, 7),
|
||||
[&](const CustomSubError &SE) {
|
||||
CaughtErrorInfo = SE.getInfo();
|
||||
CaughtErrorExtraInfo = SE.getExtraInfo();
|
||||
});
|
||||
|
||||
EXPECT_TRUE(CaughtErrorInfo == 42 && CaughtErrorExtraInfo == 7)
|
||||
<< "Wrong result from CustomSubError handler";
|
||||
}
|
||||
|
||||
// Check that we trigger only the first handler that applies.
|
||||
{
|
||||
int DummyInfo = 0;
|
||||
int CaughtErrorInfo = 0;
|
||||
int CaughtErrorExtraInfo = 0;
|
||||
|
||||
handleAllErrors(make_error<CustomSubError>(42, 7),
|
||||
[&](const CustomSubError &SE) {
|
||||
CaughtErrorInfo = SE.getInfo();
|
||||
CaughtErrorExtraInfo = SE.getExtraInfo();
|
||||
},
|
||||
[&](const CustomError &CE) { DummyInfo = CE.getInfo(); });
|
||||
|
||||
EXPECT_TRUE(CaughtErrorInfo == 42 && CaughtErrorExtraInfo == 7 &&
|
||||
DummyInfo == 0)
|
||||
<< "Activated the wrong Error handler(s)";
|
||||
}
|
||||
|
||||
// Check that general handlers shadow specific ones.
|
||||
{
|
||||
int CaughtErrorInfo = 0;
|
||||
int DummyInfo = 0;
|
||||
int DummyExtraInfo = 0;
|
||||
|
||||
handleAllErrors(
|
||||
make_error<CustomSubError>(42, 7),
|
||||
[&](const CustomError &CE) { CaughtErrorInfo = CE.getInfo(); },
|
||||
[&](const CustomSubError &SE) {
|
||||
DummyInfo = SE.getInfo();
|
||||
DummyExtraInfo = SE.getExtraInfo();
|
||||
});
|
||||
|
||||
EXPECT_TRUE(CaughtErrorInfo = 42 && DummyInfo == 0 && DummyExtraInfo == 0)
|
||||
<< "General Error handler did not shadow specific handler";
|
||||
}
|
||||
}
|
||||
|
||||
// Test utility functions.
|
||||
TEST(Error, CheckErrorUtilities) {
|
||||
// Test that we can handle errors with custom base classes.
|
||||
TEST(Error, HandleCustomErrorWithCustomBaseClass) {
|
||||
int CaughtErrorInfo = 0;
|
||||
int CaughtErrorExtraInfo = 0;
|
||||
handleAllErrors(make_error<CustomSubError>(42, 7),
|
||||
[&](const CustomSubError &SE) {
|
||||
CaughtErrorInfo = SE.getInfo();
|
||||
CaughtErrorExtraInfo = SE.getExtraInfo();
|
||||
});
|
||||
|
||||
// Test joinErrors
|
||||
{
|
||||
int CustomErrorInfo1 = 0;
|
||||
int CustomErrorInfo2 = 0;
|
||||
int CustomErrorExtraInfo = 0;
|
||||
Error E = joinErrors(make_error<CustomError>(7),
|
||||
make_error<CustomSubError>(42, 7));
|
||||
EXPECT_TRUE(CaughtErrorInfo == 42 && CaughtErrorExtraInfo == 7)
|
||||
<< "Wrong result from CustomSubError handler";
|
||||
}
|
||||
|
||||
handleAllErrors(std::move(E),
|
||||
[&](const CustomSubError &SE) {
|
||||
CustomErrorInfo2 = SE.getInfo();
|
||||
CustomErrorExtraInfo = SE.getExtraInfo();
|
||||
},
|
||||
[&](const CustomError &CE) {
|
||||
// Assert that the CustomError instance above is handled
|
||||
// before the
|
||||
// CustomSubError - joinErrors should preserve error
|
||||
// ordering.
|
||||
EXPECT_EQ(CustomErrorInfo2, 0)
|
||||
<< "CustomErrorInfo2 should be 0 here. "
|
||||
"joinErrors failed to preserve ordering.\n";
|
||||
CustomErrorInfo1 = CE.getInfo();
|
||||
});
|
||||
// Check that we trigger only the first handler that applies.
|
||||
TEST(Error, FirstHandlerOnly) {
|
||||
int DummyInfo = 0;
|
||||
int CaughtErrorInfo = 0;
|
||||
int CaughtErrorExtraInfo = 0;
|
||||
|
||||
EXPECT_TRUE(CustomErrorInfo1 == 7 && CustomErrorInfo2 == 42 &&
|
||||
CustomErrorExtraInfo == 7)
|
||||
<< "Failed handling compound Error.";
|
||||
}
|
||||
handleAllErrors(make_error<CustomSubError>(42, 7),
|
||||
[&](const CustomSubError &SE) {
|
||||
CaughtErrorInfo = SE.getInfo();
|
||||
CaughtErrorExtraInfo = SE.getExtraInfo();
|
||||
},
|
||||
[&](const CustomError &CE) { DummyInfo = CE.getInfo(); });
|
||||
|
||||
// Test consumeError for both success and error cases.
|
||||
{
|
||||
Error E;
|
||||
consumeError(std::move(E));
|
||||
}
|
||||
{
|
||||
Error E = make_error<CustomError>(7);
|
||||
consumeError(std::move(E));
|
||||
}
|
||||
EXPECT_TRUE(CaughtErrorInfo == 42 && CaughtErrorExtraInfo == 7 &&
|
||||
DummyInfo == 0)
|
||||
<< "Activated the wrong Error handler(s)";
|
||||
}
|
||||
|
||||
// Check that general handlers shadow specific ones.
|
||||
TEST(Error, HandlerShadowing) {
|
||||
int CaughtErrorInfo = 0;
|
||||
int DummyInfo = 0;
|
||||
int DummyExtraInfo = 0;
|
||||
|
||||
handleAllErrors(
|
||||
make_error<CustomSubError>(42, 7),
|
||||
[&](const CustomError &CE) { CaughtErrorInfo = CE.getInfo(); },
|
||||
[&](const CustomSubError &SE) {
|
||||
DummyInfo = SE.getInfo();
|
||||
DummyExtraInfo = SE.getExtraInfo();
|
||||
});
|
||||
|
||||
EXPECT_TRUE(CaughtErrorInfo = 42 && DummyInfo == 0 && DummyExtraInfo == 0)
|
||||
<< "General Error handler did not shadow specific handler";
|
||||
}
|
||||
|
||||
// Test joinErrors.
|
||||
TEST(Error, CheckJoinErrors) {
|
||||
int CustomErrorInfo1 = 0;
|
||||
int CustomErrorInfo2 = 0;
|
||||
int CustomErrorExtraInfo = 0;
|
||||
Error E =
|
||||
joinErrors(make_error<CustomError>(7), make_error<CustomSubError>(42, 7));
|
||||
|
||||
handleAllErrors(std::move(E),
|
||||
[&](const CustomSubError &SE) {
|
||||
CustomErrorInfo2 = SE.getInfo();
|
||||
CustomErrorExtraInfo = SE.getExtraInfo();
|
||||
},
|
||||
[&](const CustomError &CE) {
|
||||
// Assert that the CustomError instance above is handled
|
||||
// before the
|
||||
// CustomSubError - joinErrors should preserve error
|
||||
// ordering.
|
||||
EXPECT_EQ(CustomErrorInfo2, 0)
|
||||
<< "CustomErrorInfo2 should be 0 here. "
|
||||
"joinErrors failed to preserve ordering.\n";
|
||||
CustomErrorInfo1 = CE.getInfo();
|
||||
});
|
||||
|
||||
EXPECT_TRUE(CustomErrorInfo1 == 7 && CustomErrorInfo2 == 42 &&
|
||||
CustomErrorExtraInfo == 7)
|
||||
<< "Failed handling compound Error.";
|
||||
}
|
||||
|
||||
// Test that we can consume success values.
|
||||
TEST(Error, ConsumeSuccess) {
|
||||
Error E;
|
||||
consumeError(std::move(E));
|
||||
}
|
||||
|
||||
TEST(Error, ConsumeError) {
|
||||
Error E = make_error<CustomError>(7);
|
||||
consumeError(std::move(E));
|
||||
}
|
||||
|
||||
// Test that handleAllUnhandledErrors crashes if an error is not caught.
|
||||
// Test runs in debug mode only.
|
||||
#ifndef NDEBUG
|
||||
{
|
||||
auto FailToHandle = []() {
|
||||
handleAllErrors(make_error<CustomError>(7),
|
||||
[&](const CustomSubError &SE) {
|
||||
errs() << "This should never be called";
|
||||
exit(1);
|
||||
});
|
||||
};
|
||||
TEST(Error, FailureToHandle) {
|
||||
auto FailToHandle = []() {
|
||||
handleAllErrors(make_error<CustomError>(7), [&](const CustomSubError &SE) {
|
||||
errs() << "This should never be called";
|
||||
exit(1);
|
||||
});
|
||||
};
|
||||
|
||||
EXPECT_DEATH(FailToHandle(), "Program aborted due to an unhandled Error:")
|
||||
<< "Unhandled Error in handleAllErrors call did not cause an "
|
||||
"abort()";
|
||||
}
|
||||
EXPECT_DEATH(FailToHandle(), "Program aborted due to an unhandled Error:")
|
||||
<< "Unhandled Error in handleAllErrors call did not cause an "
|
||||
"abort()";
|
||||
}
|
||||
#endif
|
||||
|
||||
// Test that handleAllUnhandledErrors crashes if an error is returned from a
|
||||
// handler.
|
||||
// Test runs in debug mode only.
|
||||
#ifndef NDEBUG
|
||||
{
|
||||
auto ReturnErrorFromHandler = []() {
|
||||
handleAllErrors(make_error<CustomError>(7),
|
||||
[&](std::unique_ptr<CustomSubError> SE) {
|
||||
return Error(std::move(SE));
|
||||
});
|
||||
};
|
||||
TEST(Error, FailureFromHandler) {
|
||||
auto ReturnErrorFromHandler = []() {
|
||||
handleAllErrors(make_error<CustomError>(7),
|
||||
[&](std::unique_ptr<CustomSubError> SE) {
|
||||
return Error(std::move(SE));
|
||||
});
|
||||
};
|
||||
|
||||
EXPECT_DEATH(ReturnErrorFromHandler(),
|
||||
"Program aborted due to an unhandled Error:")
|
||||
<< " Error returned from handler in handleAllErrors call did not "
|
||||
"cause abort()";
|
||||
}
|
||||
EXPECT_DEATH(ReturnErrorFromHandler(),
|
||||
"Program aborted due to an unhandled Error:")
|
||||
<< " Error returned from handler in handleAllErrors call did not "
|
||||
"cause abort()";
|
||||
}
|
||||
#endif
|
||||
|
||||
// Test that we can return values from handleErrors.
|
||||
{
|
||||
int ErrorInfo = 0;
|
||||
// Test that we can return values from handleErrors.
|
||||
TEST(Error, CatchErrorFromHandler) {
|
||||
int ErrorInfo = 0;
|
||||
|
||||
Error E = handleErrors(
|
||||
make_error<CustomError>(7),
|
||||
[&](std::unique_ptr<CustomError> CE) { return Error(std::move(CE)); });
|
||||
Error E = handleErrors(
|
||||
make_error<CustomError>(7),
|
||||
[&](std::unique_ptr<CustomError> CE) { return Error(std::move(CE)); });
|
||||
|
||||
handleAllErrors(std::move(E),
|
||||
[&](const CustomError &CE) { ErrorInfo = CE.getInfo(); });
|
||||
handleAllErrors(std::move(E),
|
||||
[&](const CustomError &CE) { ErrorInfo = CE.getInfo(); });
|
||||
|
||||
EXPECT_EQ(ErrorInfo, 7)
|
||||
<< "Failed to handle Error returned from handleErrors.";
|
||||
}
|
||||
|
||||
// Test ExitOnError
|
||||
{
|
||||
ExitOnError ExitOnErr;
|
||||
ExitOnErr.setBanner("Error in tool:");
|
||||
ExitOnErr.setExitCodeMapper(
|
||||
[](const Error &E) {
|
||||
if (E.isA<CustomSubError>())
|
||||
return 2;
|
||||
return 1;
|
||||
});
|
||||
|
||||
// Make sure we don't bail on success.
|
||||
ExitOnErr(Error::success());
|
||||
EXPECT_EQ(ExitOnErr(Expected<int>(7)), 7)
|
||||
<< "exitOnError returned an invalid value for Expected";
|
||||
|
||||
// Exit tests.
|
||||
EXPECT_EXIT(ExitOnErr(make_error<CustomError>(7)),
|
||||
::testing::ExitedWithCode(1), "Error in tool:")
|
||||
<< "exitOnError returned an unexpected error result";
|
||||
|
||||
EXPECT_EXIT(ExitOnErr(Expected<int>(make_error<CustomSubError>(0, 0))),
|
||||
::testing::ExitedWithCode(2), "Error in tool:")
|
||||
<< "exitOnError returned an unexpected error result";
|
||||
}
|
||||
EXPECT_EQ(ErrorInfo, 7)
|
||||
<< "Failed to handle Error returned from handleErrors.";
|
||||
}
|
||||
|
||||
// Test Expected behavior.
|
||||
TEST(Error, CheckExpected) {
|
||||
// Test that the ExitOnError utility works as expected.
|
||||
TEST(Error, ExitOnError) {
|
||||
ExitOnError ExitOnErr;
|
||||
ExitOnErr.setBanner("Error in tool:");
|
||||
ExitOnErr.setExitCodeMapper([](const Error &E) {
|
||||
if (E.isA<CustomSubError>())
|
||||
return 2;
|
||||
return 1;
|
||||
});
|
||||
|
||||
// Check that non-errors convert to 'true'.
|
||||
{
|
||||
Expected<int> A = 7;
|
||||
EXPECT_TRUE(!!A)
|
||||
<< "Expected with non-error value doesn't convert to 'true'";
|
||||
}
|
||||
// Make sure we don't bail on success.
|
||||
ExitOnErr(Error::success());
|
||||
EXPECT_EQ(ExitOnErr(Expected<int>(7)), 7)
|
||||
<< "exitOnError returned an invalid value for Expected";
|
||||
|
||||
// Check that non-error values are accessible via operator*.
|
||||
{
|
||||
Expected<int> A = 7;
|
||||
EXPECT_EQ(*A, 7) << "Incorrect Expected non-error value";
|
||||
}
|
||||
// Exit tests.
|
||||
EXPECT_EXIT(ExitOnErr(make_error<CustomError>(7)),
|
||||
::testing::ExitedWithCode(1), "Error in tool:")
|
||||
<< "exitOnError returned an unexpected error result";
|
||||
|
||||
// Check that errors convert to 'false'.
|
||||
{
|
||||
Expected<int> A = make_error<CustomError>(42);
|
||||
EXPECT_FALSE(!!A) << "Expected with error value doesn't convert to 'false'";
|
||||
consumeError(A.takeError());
|
||||
}
|
||||
EXPECT_EXIT(ExitOnErr(Expected<int>(make_error<CustomSubError>(0, 0))),
|
||||
::testing::ExitedWithCode(2), "Error in tool:")
|
||||
<< "exitOnError returned an unexpected error result";
|
||||
}
|
||||
|
||||
// Check that error values are accessible via takeError().
|
||||
{
|
||||
Expected<int> A = make_error<CustomError>(42);
|
||||
Error E = A.takeError();
|
||||
EXPECT_TRUE(E.isA<CustomError>()) << "Incorrect Expected error value";
|
||||
consumeError(std::move(E));
|
||||
}
|
||||
// Test Expected<T> in success mode.
|
||||
TEST(Error, ExpectedInSuccessMode) {
|
||||
Expected<int> A = 7;
|
||||
EXPECT_TRUE(!!A) << "Expected with non-error value doesn't convert to 'true'";
|
||||
EXPECT_EQ(*A, 7) << "Incorrect Expected non-error value";
|
||||
}
|
||||
|
||||
// Test Expected<T> in failure mode.
|
||||
TEST(Error, ExpectedInFailureMode) {
|
||||
Expected<int> A = make_error<CustomError>(42);
|
||||
EXPECT_FALSE(!!A) << "Expected with error value doesn't convert to 'false'";
|
||||
Error E = A.takeError();
|
||||
EXPECT_TRUE(E.isA<CustomError>()) << "Incorrect Expected error value";
|
||||
consumeError(std::move(E));
|
||||
}
|
||||
|
||||
// Check that an Expected instance with an error value doesn't allow access to
|
||||
// operator*.
|
||||
// Test runs in debug mode only.
|
||||
#ifndef NDEBUG
|
||||
{
|
||||
Expected<int> A = make_error<CustomError>(42);
|
||||
EXPECT_DEATH(*A, "!HasError && \"Cannot get value when an error exists!\"")
|
||||
<< "Incorrect Expected error value";
|
||||
consumeError(A.takeError());
|
||||
}
|
||||
TEST(Error, AccessExpectedInFailureMode) {
|
||||
Expected<int> A = make_error<CustomError>(42);
|
||||
EXPECT_DEATH(*A, "!HasError && \"Cannot get value when an error exists!\"")
|
||||
<< "Incorrect Expected error value";
|
||||
consumeError(A.takeError());
|
||||
}
|
||||
#endif
|
||||
|
||||
// Check that an Expected instance with an error triggers an abort if
|
||||
// unhandled.
|
||||
// Test runs in debug mode only.
|
||||
#ifndef NDEBUG
|
||||
TEST(Error, UnhandledExpectedInFailureMode) {
|
||||
EXPECT_DEATH({ Expected<int> A = make_error<CustomError>(42); },
|
||||
"Program aborted due to an unhandled Error:")
|
||||
<< "Unchecked Expected<T> failure value did not cause an abort()";
|
||||
}
|
||||
#endif
|
||||
|
||||
// Test covariance of Expected.
|
||||
{
|
||||
class B {};
|
||||
class D : public B {};
|
||||
// Test covariance of Expected.
|
||||
TEST(Error, ExpectedCovariance) {
|
||||
class B {};
|
||||
class D : public B {};
|
||||
|
||||
Expected<B *> A1(Expected<D *>(nullptr));
|
||||
A1 = Expected<D *>(nullptr);
|
||||
Expected<B *> A1(Expected<D *>(nullptr));
|
||||
A1 = Expected<D *>(nullptr);
|
||||
|
||||
Expected<std::unique_ptr<B>> A2(Expected<std::unique_ptr<D>>(nullptr));
|
||||
A2 = Expected<std::unique_ptr<D>>(nullptr);
|
||||
}
|
||||
Expected<std::unique_ptr<B>> A2(Expected<std::unique_ptr<D>>(nullptr));
|
||||
A2 = Expected<std::unique_ptr<D>>(nullptr);
|
||||
}
|
||||
|
||||
TEST(Error, ECError) {
|
||||
|
||||
// Round-trip a success value to check that it converts correctly.
|
||||
EXPECT_EQ(errorToErrorCode(errorCodeToError(std::error_code())),
|
||||
std::error_code())
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user