Search code examples
javaloggingerror-handlingexceptionblack-box-testing

The different Exception reporting

I am just thinking about java Exceptions. There are many different types and they all work for their own part. What I am curious about is the handling of them. For example 

try
{
    //Protected code
}catch(ExceptionName e1)
{
    //Catch block
}

In the catch blok there multiple ways to report the Exception. I have found several, but i assume there are more around:

  • System.err.println(e1); for debugging
  • system.println.out(e1); to just view the error for local validation
  • e1.printStackTrace(); to just view the error
  • Logger.getLogger(classname.class.getName()).log(Level.SEVERE, null, e1); where the level can vary in debug, info and error if I am correct.

Why would you choose one over the other? All I can think about is the info it reports? So for short errors you would just print the Exception and whilst looking for actual problems you would use something bigger. And if you know there is going to be an exception, but don't think it's important, can just throw it?

And is Exception handeling a good tool for testing code? Could it be a replacement for Black-Box-testing?

Solution

  • Your question is mainly about logging, and there are several ways to do it based on your requirements and complexity of your application. There are obviously differences between them for example:

    System.out.println() uses the Scanner classes's PrintStream out static object to print the passed argument into console. println() is a method of PrintStream classes. Definitely not a suitable logging solution.

    System.println.out() I do not think such a method exist in the System class, see the documentation.

    System.err.println() do exist and is yet again a static object of PrintStream class. This is the standard error output stream, it is already open and it is waiting to receive data that should be brought to the user's attention.

    If you are using console, you will not be able to see the difference between err.println() and out.println(). You can obviously configure them so that err.println() output all errors in a file.

    Java's Exception class extends Throwable and implements Serializable interface. Exception inherits all the following methods from Throwable class:

    • getCause() - returns Throwable or null if the cause don't exist
    • getMessage() - returns String message of details of this throwable
    • getStackTrace() - returns StackTraceElement[] of the throwable
    • printStackTrace() - has two variations described below

    getStackTrace() gives you programmatic access to the stack trace.

    Returns an array of stack trace elements, each representing one stack frame. The zeroth element of the array (assuming the array's length is non-zero) represents the top of the stack, which is the last method invocation in the sequence. Typically, this is the point at which this throwable was created and thrown. The last element of the array (assuming the array's length is non-zero) represents the bottom of the stack, which is the first method invocation in the sequence.

    printStackTrace() or printStackTrace(PrintStream s) the first one without PrintStream argument prints the stacktrace in the standard error output stream (correct guess! that is err.println()). If we wish to print the stacktrace in a file, we pass the printStackTrace() method PrintStream pointing to a file or other destinations.

    Alright, now back to logging. There are several logging frameworks that allow you to log data in different levels of severity. For example, you have an enterprise application and you would like to log data based on

    • SEVERE (Highest)
    • WARNING
    • INFO
    • OTHER levels

    The logging framework can be used to do a lot, a few are listed below:

    • Logging simple text messages
    • Log levels to filter different log messages
    • Log categories
    • Log file rotations
    • Configuration config file with ability for the configs to be loaded
    • The huge list goes on

    There are a bunch of logging frameworks that you can use based on the requirement of application you are developing:

    1. Log4j
    2. Java Logging API
    3. Apache Commons API
    4. See more in here and here

    There are benchmark results for some of these logging framework, for example see here for comparison of Log4j, Logback and Java Logging API.

    You have a lot of options to choose from depending on the need of your project, its complexity and level of logging you wish to achieve. 

    Exception handling good for testing? No. 
Is logging good for testing? No.

    Exception handling is when you handle an unexpected situations. For example, you are expecting integer input and then you get string instead. The execution breaks if you don't handle such a scenario hence, you write your try and catch blocks to catch such exceptions and then warn the user that s/he should input an integer only. Like this there are many exceptions and exceptions cause the execution of code to be halted. If a user is able to bring halt to execution of your code then that is not a good program hence, you need exception handling to be able to deal with any kind of users, inputed data, etc.

    You cannot use Exception handling for testing but, it does aid you. How? Exception handling can be used with testing frameworks, to help you manually throw different types of exceptions and then handle it using your exception handling piece of code.

    Logging cannot be used to do test but, it can be used with testing. You can use logging framework with testing framework such as JUnit in order to run the tests as well as log all events that happens during execution of the test. You can configure your logging framework to create special set of log files, each time tests are executed.

    If you wish to do logging and wish to be a programmer in the future (you might already be), you definitely need to use Testing frameworks for testing, logging frameworks for logging and exception handling to handle exceptions.