nested-exceptions

I am writing some JUnit tests that verify that an exception of type MyCustomException is thrown. However, this exception is wrapped in other exceptions a number of times, e.g. in an InvocationTargetException, which in turn is wrapped in a RuntimeException. What's the best way to determine whether MyCustomException somehow caused the exception that I actually catch? I would like to do something like this (see underlined): try { doSomethingPotentiallyExceptional(); fail("Expected an exception."); } catch (RuntimeException e) { if (!e. wasCausedBy (MyCustomException.class) fail("Expected a

This question already has an answer here: Proper/elegant way of implementing C++ exception chaining? 4 answers How to simulate inner exception in C++ 6 answers I just finished work on a C++-program where I've implemented my own exceptions (although derived from std::exception). The practice I've applied when one exception causes a chain reaction, propagating the error upwards and giving rise to other exceptions, is to concatenate the error message at each appropriate step across the modules (read classes). I.e. the old exception itself is dropped and a new exception is created, but with a

I want to catch an exception, that is nested into another exception. I'm doing it currently this way: } catch (RemoteAccessException e) { if (e != null && e.getCause() != null && e.getCause().getCause() != null) { MyException etrp = (MyException) e.getCause().getCause(); ... } else { throw new IllegalStateException("Error at calling service 'service'"); } } Is there a way to do this more efficient and elegant? There is no more elegant way of selectively "catching" nested exceptions. I suppose if you did this kind of nested exception catching a lot, you could possibly refactor the code into a

The main problem with throwing exceptions from destructor is that in the moment when destructor is called another exception may be "in flight" ( std::uncaught_exception() == true ) and so it is not obvious what to do in that case. "Overwriting" the old exception with the new one would be the one of the possible ways to handle this situation. But it was decided that std::terminate (or another std::terminate_handler ) must be called in such cases. C++11 introduced nested exceptions feature via std::nested_exception class. This feature could be used to solve the problem described above. The old