CbC/CbC_llvm: unittests/Support/ErrorTest.cpp comparison

comparison unittests/Support/ErrorTest.cpp @ 121:803732b1fca8

LLVM 5.0

author	kono
date	Fri, 27 Oct 2017 17:07:41 +0900
parents	1172e4bd9c6f
children	3a76565eade5

comparison

equal deleted inserted replaced

-:1172e4bd9c6f
+:803732b1fca8
 Error E = Error::success();
 EXPECT_FALSE(E) << "Unexpected error while testing Error 'Success'";
 }
 // Test that unchecked succes values cause an abort.
-#ifndef NDEBUG
+#if LLVM_ENABLE_ABI_BREAKING_CHECKS
 TEST(Error, UncheckedSuccess) {
 EXPECT_DEATH({ Error E = Error::success(); },
 "Program aborted due to an unhandled Error:")
 << "Unchecked Error Succes value did not cause abort()";
 }
 errAsOutParamHelper(E);
 (void)!!E;
 }
 // Test that ErrorAsOutParameter clears the checked flag on destruction.
-#ifndef NDEBUG
+#if LLVM_ENABLE_ABI_BREAKING_CHECKS
 TEST(Error, ErrorAsOutParameterUnchecked) {
 EXPECT_DEATH({ Error E = Error::success(); errAsOutParamHelper(E); },
 "Program aborted due to an unhandled Error:")
 << "ErrorAsOutParameter did not clear the checked flag on destruction.";
 }
 #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
+#if LLVM_ENABLE_ABI_BREAKING_CHECKS
 TEST(Error, UncheckedError) {
 auto DropUnhandledError = []() {
 Error E = make_error<CustomError>(42);
 (void)!E;
 };
 make_error<CustomError>(7),
 make_error<CustomError>(7))),
 [&](const CustomError &CE) {
 Sum += CE.getInfo();
 });
-EXPECT_EQ(Sum, 28) << "Failed to correctly concatenate erorr lists.";
+EXPECT_EQ(Sum, 28) << "Failed to correctly concatenate error lists.";
 }
 }
 // Test that we can consume success values.
 TEST(Error, ConsumeSuccess) {
 consumeError(std::move(E));
 }
 // Test that handleAllUnhandledErrors crashes if an error is not caught.
 // Test runs in debug mode only.
-#ifndef NDEBUG
+#if LLVM_ENABLE_ABI_BREAKING_CHECKS
 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:")
+EXPECT_DEATH(FailToHandle(),
+"Failure value returned from cantFail wrapped call")
 << "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
+#if LLVM_ENABLE_ABI_BREAKING_CHECKS
 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:")
+"Failure value returned from cantFail wrapped call")
 << " Error returned from handler in handleAllErrors call did not "
 "cause abort()";
 }
 #endif
 EXPECT_EXIT(ExitOnErr(Expected<int>(make_error<CustomSubError>(0, 0))),
 ::testing::ExitedWithCode(2), "Error in tool:")
 << "exitOnError returned an unexpected error result";
 }
+// Test that the ExitOnError utility works as expected.
+TEST(Error, CantFailSuccess) {
+cantFail(Error::success());
+int X = cantFail(Expected<int>(42));
+EXPECT_EQ(X, 42) << "Expected value modified by cantFail";
+int Dummy = 42;
+int &Y = cantFail(Expected<int&>(Dummy));
+EXPECT_EQ(&Dummy, &Y) << "Reference mangled by cantFail";
+}
+// Test that cantFail results in a crash if you pass it a failure value.
+#if LLVM_ENABLE_ABI_BREAKING_CHECKS && !defined(NDEBUG)
+TEST(Error, CantFailDeath) {
+EXPECT_DEATH(
+cantFail(make_error<StringError>("foo", inconvertibleErrorCode()),
+"Cantfail call failed"),
+"Cantfail call failed")
+<< "cantFail(Error) did not cause an abort for failure value";
+EXPECT_DEATH(
+{
+auto IEC = inconvertibleErrorCode();
+int X = cantFail(Expected<int>(make_error<StringError>("foo", IEC)));
+(void)X;
+},
+"Failure value returned from cantFail wrapped call")
+<< "cantFail(Expected<int>) did not cause an abort for failure value";
+}
+#endif
 // Test Checked Expected<T> in success mode.
 TEST(Error, CheckedExpectedInSuccessMode) {
 Expected<int> A = 7;
 EXPECT_TRUE(!!A) << "Expected with non-error value doesn't convert to 'true'";
 // Access is safe in second test, since we checked the error in the first.
 }
 // Test Unchecked Expected<T> in success mode.
 // We expect this to blow up the same way Error would.
 // Test runs in debug mode only.
-#ifndef NDEBUG
+#if LLVM_ENABLE_ABI_BREAKING_CHECKS
 TEST(Error, UncheckedExpectedInSuccessModeDestruction) {
 EXPECT_DEATH({ Expected<int> A = 7; },
 "Expected<T> must be checked before access or destruction.")
 << "Unchecekd Expected<T> success value did not cause an abort().";
 }
 #endif
 // Test Unchecked Expected<T> in success mode.
 // We expect this to blow up the same way Error would.
 // Test runs in debug mode only.
-#ifndef NDEBUG
+#if LLVM_ENABLE_ABI_BREAKING_CHECKS
 TEST(Error, UncheckedExpectedInSuccessModeAccess) {
 EXPECT_DEATH({ Expected<int> A = 7; *A; },
 "Expected<T> must be checked before access or destruction.")
 << "Unchecekd Expected<T> success value did not cause an abort().";
 }
 #endif
 // Test Unchecked Expected<T> in success mode.
 // We expect this to blow up the same way Error would.
 // Test runs in debug mode only.
-#ifndef NDEBUG
+#if LLVM_ENABLE_ABI_BREAKING_CHECKS
 TEST(Error, UncheckedExpectedInSuccessModeAssignment) {
 EXPECT_DEATH({ Expected<int> A = 7; A = 7; },
 "Expected<T> must be checked before access or destruction.")
 << "Unchecekd Expected<T> success value did not cause an abort().";
 }
 }
 // Check that an Expected instance with an error value doesn't allow access to
 // operator*.
 // Test runs in debug mode only.
-#ifndef NDEBUG
+#if LLVM_ENABLE_ABI_BREAKING_CHECKS
 TEST(Error, AccessExpectedInFailureMode) {
 Expected<int> A = make_error<CustomError>(42);
 EXPECT_DEATH(*A, "Expected<T> must be checked before access or destruction.")
 << "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
+#if LLVM_ENABLE_ABI_BREAKING_CHECKS
 TEST(Error, UnhandledExpectedInFailureMode) {
 EXPECT_DEATH({ Expected<int> A = make_error<CustomError>(42); },
 "Expected<T> must be checked before access or destruction.")
 << "Unchecked Expected<T> failure value did not cause an abort()";
 }
 // Check A2 by converting to bool before assigning to it.
 (void)!!A2;
 A2 = Expected<std::unique_ptr<D>>(nullptr);
 // Check A2 again before destruction.
 (void)!!A2;
+}
+// Test that handleExpected just returns success values.
+TEST(Error, HandleExpectedSuccess) {
+auto ValOrErr =
+handleExpected(Expected<int>(42),
+[]() { return Expected<int>(43); });
+EXPECT_TRUE(!!ValOrErr)
+<< "handleExpected should have returned a success value here";
+EXPECT_EQ(*ValOrErr, 42)
+<< "handleExpected should have returned the original success value here";
+}
+enum FooStrategy { Aggressive, Conservative };
+static Expected<int> foo(FooStrategy S) {
+if (S == Aggressive)
+return make_error<CustomError>(7);
+return 42;
+}
+// Test that handleExpected invokes the error path if errors are not handled.
+TEST(Error, HandleExpectedUnhandledError) {
+// foo(Aggressive) should return a CustomError which should pass through as
+// there is no handler for CustomError.
+auto ValOrErr =
+handleExpected(
+foo(Aggressive),
+[]() { return foo(Conservative); });
+EXPECT_FALSE(!!ValOrErr)
+<< "handleExpected should have returned an error here";
+auto Err = ValOrErr.takeError();
+EXPECT_TRUE(Err.isA<CustomError>())
+<< "handleExpected should have returned the CustomError generated by "
+"foo(Aggressive) here";
+consumeError(std::move(Err));
+}
+// Test that handleExpected invokes the fallback path if errors are handled.
+TEST(Error, HandleExpectedHandledError) {
+// foo(Aggressive) should return a CustomError which should handle triggering
+// the fallback path.
+auto ValOrErr =
+handleExpected(
+foo(Aggressive),
+[]() { return foo(Conservative); },
+[](const CustomError&) { /* do nothing */ });
+EXPECT_TRUE(!!ValOrErr)
+<< "handleExpected should have returned a success value here";
+EXPECT_EQ(*ValOrErr, 42)
+<< "handleExpected returned the wrong success value";
 }
 TEST(Error, ErrorCodeConversions) {
 // Round-trip a success value to check that it converts correctly.
 EXPECT_EQ(errorToErrorCode(errorCodeToError(std::error_code())),

Mercurial > hg > CbC > CbC_llvm

comparison unittests/Support/ErrorTest.cpp @ 121:803732b1fca8