What to do with never happening, useless exceptions?

Question

I have this code:

HttpPut put = new HttpPut(url);
try {
    put.setEntity(new StringEntity(body, "UTF-8"));
} catch (UnsupportedEncodingException e1) {
    // That would really not be good
    e1.printStackTrace();
}

On a platform that is known to support that encoding.

The exception is never going to be raised. I will never do anything about it.

The fact that the code is there still suggests that there is a chance that it may happen, and that the rest of the code could be executed in an unreliable state. But it will never. Or if it does, graceful network connections fallback is the last of my problems.

So I have this ugly useless try catch block. What should I do with it?

(In this specific case, there is not much other choice if I want to use StringEntity. String.getBytes for example has a bunch of methods that would accept a Charset object, for instance, avoiding the need to catch the exception, but not StringEntity)

I'd consider forking `StringEntity`. In the absence of that, I'd do what Jon Skeet suggested. Because, well, Jon Skeet. — CommonsWare, Aug 12 '14 at 20:22
@CommonsWare: I though of that. I don't get why they don't use `String.getBytes(Charset.forName(encoding))`, which throws an `UnsupportedCharsetException`, which is a `RuntimeException`. — njzk2, Aug 12 '14 at 21:17
@LuiggiMendoza: If it does, I don't know now what encoding I will want to fallback on, as the server only accepts UTF-8 for now. — njzk2, Aug 12 '14 at 21:17

score 11 · Accepted Answer · edited Aug 13 '14 at 13:07

I would throw some kind of RuntimeException which indicates that you think this really should never happen. That way:

If it ever does happen, you find out about it rather than swallowing it and continuing
Your expectation that it really can never happen is clearly documented

You could even create your own subclass of RuntimeException for precisely this:

// https://www.youtube.com/watch?v=OHVjs4aobqs
public class InconceivableException extends RuntimeException {
    public InconceivableException(String message) {
        super(message);
    }

    public InconceivableException(String message, Throwable cause) {
        super(message, cause);
    }
}

You might also want to encapsulate the operation into a separate method, so that you don't get such catch blocks populating your code. For example:

public static HttpPut createHttpPutWithBody(String body) {
    HttpPut put = new HttpPut(url);
    try {
        put.setEntity(new StringEntity(body, "UTF-8"));
        return put;
    } catch (UnsupportedEncodingException e) {
        throw new InconceivableException("You keep using that encoding. "
            + "I do not think it means what you think it means.", e);
    }
}

Then you can call createHttpPutWithBody wherever you'd need to, and keep your main code "catch clean".

What to do with never happening, useless exceptions?

1 Answers1