LBCLASSIC-133  We don't need to unit test test. A standalone app, is just as good if not simpler to run.

  appropriate

runnable[0]: counter=1002
runnable[1]: counter=0
runnable[2]: counter=0
runnable[3]: counter=0
runnable[4]: counter=0 

on the context name. This fits nicely the requirements expressed in LBCLASSIC-117

data in the form of StackTraceElement[] instead of CallerData[].
CallerData class now only extracts caller data. It has no instance
variables.

- The standard corpus now includes caller data.

- code dependent on this behavior was adapted consequently

had become an empty shell around StackTraceElementProxy.

ThrowableProxy now implements the IThrowableProxy interface as shown below:

public interface IThrowableProxy {
  public String getClassName();
  public String getMessage();
  public ThrowableDataPoint[] getThrowableDataPointArray();
  public int getCommonFrames();
  public IThrowableProxy getCause();  <-- Joern smiles
}

Instead of being a flat structure, ThrowableProxy now contains nested
exceptions (cause) as a nested ThrowableProxy references. This was
requested by Joern Huxhorn on several occasions.

Classes printing threads had to be modified as a result of this
refactoring. 

The ILoggerEvent interface has also been slightly refactored. The
LoggerRemoteView class is no longer referenced. Instead the
LoggerContextVO class is used. As a result, serialized events are
larger by a few bytes, but the code is hopefully much clearer.

In response to comments from the dev mailing list, the LoggingEventSDO
class has been renamed as LoggingEventVO.

When the class name contains 13 or more segments (12 dots), the
abbreviation algorithm would bomb out with an exception. This was
reported by Lukas Zapletal in LBCLASSIC-110 and on the logback mailing
list.

The critical change is
    int[] lengthArray = new int[ClassicConstants.MAX_DOTS];
instead of
    int[] lengthArray = new int[ClassicConstants.MAX_DOTS+1];

The current MAX_DOTS limit has been increased from 12 to 16. However,
the with aforementioned "critical" change, the code can deal with any
number of dots as attested by the accompanying test case.

 SDOAware interface has been removed.
 ILoggerEvent interface no longer extends SDOAware.
 
 Appenders which rely on serialization invoke the appropriate PreSerializationTransformer
 to obtain a serializable representation of the event they are processing. 

This fairly extensive commit in terms of the number of affected
classes but relatively small conceptually. It is a refactoring of the
LoggingEvent class. The LoggingEvent class now implements the
ILoggingEvent interface which essentially contains getter methods with
no setters.  LoggingEvent is no longer serializable because the
relavant serialization code has been moved into LoggingEventSDO. A
LoggingEvent object now requires transformation into LoggingEventSDO
object before serializaiton. LoggingEventSDO class implements the
ILoggingEvent interface. SDO stands for Serialable Data Object.

All logback-classic components, including appenders, layouts,
converters now operate on ILoggingEvent instances. In other words,
logback-classic module is now a specialized processing chain for
ILoggingEvent objects, instead of LoggerEvent objects previously.

The getStartTime method which was previously part of LoggingEvent has
migrated to the Context interface. This change is a nice fit from a
conceptual point of view.

All tests pass. Performance is has not been degraded. 

In the future commits, the LoggerRemoteView may be renamed as
LoggerSDO, and similarly, LoggerContextRemoteView as LoggerContextSDO.