How to test that catch (Exception e) { e.printStackTrace();} invoked

I need to reach 95% test coverage (my task). I have problems with following class

    public class Context {

    public static <T> T getObject(Class<T> clazz) {
        Object bean = null;

        try {
            bean = clazz.newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }

        return (T) bean;
    }

    private Context() {
    }
}

to reach 95% I need to check that e.printStackTrace(); invoked when Exception thrown.
I tried different ways but none of them work. I will appreciate any support.

To verify that printStackTrace is called, the easiest way I can think of is a spy/mock Exception object.

Using mockito, you could pass in a mock Class which throws a spy Exception when newInstance is called.

Class<?> mockClass = mock(Class.class);
Exception e = Mockito.spy(new Exception());
Mockito.doThrow(e).when(mockClass).newInstance();

context.getObject(mockClass);

Mockito.verify(e).printStackTrace();

You could also do something with powermock and whenNew if you know where the Exception is going to be thrown (so that you can @PrepareForTest that class).

Exception e = Mockito.spy(new Exception());
PowerMockito.whenNew(Exception.class).thenReturn(e);

context.getObject(SomeService.class);

Mockito.verify(e).printStackTrace();

Note: I have not compiled and tested either of the above (and consistently get the Mockito and PowerMockito class names wrong in various ways).

If you're dead-set on doing this without a library you could do something like:

1. Create a custom Exception type, which explicitly sets some flag when that method is called:
2. Create a custom class which throws the above Exception when the no-arg constructor is called.
3. Pass the .class of this custom class into your method, and verify that the flag has been set.

Something like:

class MyException extends Exception {
    public static boolean printStackTraceCalled = false;

    @Override
    public void printStackTrace() {
        MyException.printStackTraceCalled = true;
        super.printStackTrace();
    }
}

class MyClass {
    MyClass() {
        throw new MyException();
    }
}

@Test
void testThing() {
    context.getObject(MyClass.class);

    Assertions.assertTrue(MyException.printStackTraceCalled);
}

That said, that's just how you would do this... I'm not saying this is a good idea. That's a bad way to handle Exceptions and targeting a specific % code-coverage is more often than not meaningless.

This is how I solved this issue. I refactored code a little bit:

 private static final Logger LOGGER = Logger.getLogger(Context.class.getName());

    public <T> T getObject(Class<T> clazz) {
        T bean = null;

        try {
            bean = clazz.getConstructor().newInstance();
        } catch (Exception e) {
            LOGGER.log(Level.INFO, e, () -> "Exception occurred during Context usage whilst created " + clazz.getName());
        }
        return bean;
    }

and here it is the test:

    @Test
    void getObject_ShouldThrowException() throws Exception {
        Exception mockedException = mock(InstantiationException.class);
        Logger mockedLogger = mock(Logger.class);

        class Dummy {

            public Dummy() throws Exception {
                throw mockedException;
            }
        }

        try {
            Dummy dummy = context.getObject(Dummy.class);
        } catch (Exception e) {
            verify(mockedLogger, times(1)).log(Level.INFO, anyString());
        }
    }