/** * @file catch_and_store_what_in.h * @author Nat Goodspeed * @date 2012-02-15 * @brief catch_what() template function, CATCH_AND_STORE_WHAT_IN() macro * * $LicenseInfo:firstyear=2012&license=viewerlgpl$ * Copyright (c) 2012, Linden Research, Inc. * $/LicenseInfo$ */ #if ! defined(LL_CATCH_AND_STORE_WHAT_IN_H) #define LL_CATCH_AND_STORE_WHAT_IN_H /** * In the brave new world of lambdas, we can use a nicer C++ idiom for testing * exceptions than CATCH_AND_STORE_WHAT_IN() below, e.g.: * * @code * std::string threw = catch_what<std::runtime_error>( * [](){ throw std::runtime_error("badness"); }); * ensure_equals(threw, "badness"); * @endcode */ template <typename EXCEPTION, typename FUNC> std::string catch_what(FUNC func) { try { func(); return {}; } catch (const EXCEPTION& err) { return err.what(); } } /** * Idiom useful for test programs: catch an expected exception, store its * what() string in a specified std::string variable. From there the caller * can do things like: * @code * ensure("expected exception not thrown", ! string.empty()); * @endcode * or * @code * ensure_contains("exception doesn't mention blah", string, "blah"); * @endcode * etc. * * The trouble is that when linking to a dynamic libllcommon.so on Linux, we * generally fail to catch the specific exception. Oddly, we can catch it as * std::runtime_error and validate its typeid().name(), so we do -- but that's * a lot of boilerplate per test. Encapsulate with this macro. Usage: * * @code * std::string threw; * try * { * some_call_that_should_throw_Foo(); * } * CATCH_AND_STORE_WHAT_IN(threw, Foo) * ensure("some_call_that_should_throw_Foo() didn't throw", ! threw.empty()); * @endcode */ #define CATCH_AND_STORE_WHAT_IN(THREW, EXCEPTION) \ catch (const EXCEPTION& ex) \ { \ (THREW) = ex.what(); \ } \ CATCH_MISSED_LINUX_EXCEPTION(THREW, EXCEPTION) #ifndef LL_LINUX #define CATCH_MISSED_LINUX_EXCEPTION(THREW, EXCEPTION) \ /* only needed on Linux */ #else // LL_LINUX #define CATCH_MISSED_LINUX_EXCEPTION(THREW, EXCEPTION) \ catch (const std::runtime_error& ex) \ { \ /* This clause is needed on Linux, on the viewer side, because */ \ /* the exception isn't caught by catch (const EXCEPTION&). */ \ /* But if the expected exception was thrown, allow the test to */ \ /* succeed anyway. Not sure how else to handle this odd case. */ \ if (std::string(typeid(ex).name()) == typeid(EXCEPTION).name()) \ { \ /* std::cerr << "Caught " << typeid(ex).name() */ \ /* << " with Linux workaround" << std::endl; */ \ (THREW) = ex.what(); \ /*std::cout << ex.what() << std::endl;*/ \ } \ else \ { \ /* We don't even recognize this exception. Let it propagate */ \ /* out to TUT to fail the test. */ \ throw; \ } \ } \ catch (...) \ { \ std::cerr << "Failed to catch expected exception " \ << #EXCEPTION << "!" << std::endl; \ /* This indicates a problem in the test that should be addressed. */ \ throw; \ } #endif // LL_LINUX #endif /* ! defined(LL_CATCH_AND_STORE_WHAT_IN_H) */