DefaultActivityLogger()
{
_tap = new ActivityLoggerTap();
_errorCounter = new ActivityLoggerErrorCounter();
_pathCatcher = new ActivityLoggerPathCatcher();
// Order does not really matter matters here thankd to Closing/Closed pattern, but
// we order them in the "logical" sense.
//
// Registered as a Multiplexed client: will be the last one as beeing called: it is the final sink.
Output.RegisterMuxClient( _tap );
// Registered as a normal client: they will not receive
// external outputs.
// Will be called AFTER the ErrorCounter.
Output.RegisterClient( _pathCatcher );
// Will be called first.
Output.RegisterClient( _errorCounter );
Output.NonRemoveableClients.AddRangeArray( _tap, _pathCatcher, _errorCounter );
}
DefaultActivityLogger()
{
_tap = new ActivityLoggerTap();
_errorCounter = new ActivityLoggerErrorCounter();
_pathCatcher = new ActivityLoggerPathCatcher();
// Order does not really matter matters here thankd to Closing/Closed pattern, but
// we order them in the "logical" sense.
//
// Registered as a Multiplexed client: will be the last one as beeing called: it is the final sink.
Output.RegisterMuxClient(_tap);
// Registered as a normal client: they will not receive
// external outputs.
// Will be called AFTER the ErrorCounter.
Output.RegisterClient(_pathCatcher);
// Will be called first.
Output.RegisterClient(_errorCounter);
Output.NonRemoveableClients.AddRangeArray(_tap, _pathCatcher, _errorCounter);
}
public void PathCatcherTests()
{
var logger = DefaultActivityLogger.Create();
// Binds the TestHelper.Logger logger to this one.
logger.Output.RegisterMuxClient( TestHelper.Logger.Output.ExternalInput );
ActivityLoggerPathCatcher p = new ActivityLoggerPathCatcher();
logger.Output.RegisterMuxClient( p );
logger.Trace( "Trace n°1" );
Assert.That( p.DynamicPath.Select( e => e.Level.ToString() + '|' + e.Text ).Single(), Is.EqualTo( "Trace|Trace n°1" ) );
Assert.That( p.LastErrorPath, Is.Null );
Assert.That( p.LastWarnOrErrorPath, Is.Null );
logger.Trace( "Trace n°2" );
Assert.That( p.DynamicPath.Select( e => e.Level.ToString() + '|' + e.Text ).Single(), Is.EqualTo( "Trace|Trace n°2" ) );
Assert.That( p.LastErrorPath, Is.Null );
Assert.That( p.LastWarnOrErrorPath, Is.Null );
logger.Warn( "W1" );
Assert.That( p.DynamicPath.Select( e => e.Level.ToString() + '|' + e.Text ).Single(), Is.EqualTo( "Warn|W1" ) );
Assert.That( p.LastErrorPath, Is.Null );
Assert.That( p.LastWarnOrErrorPath.Select( e => e.Level.ToString() + '|' + e.Text ).Single(), Is.EqualTo( "Warn|W1" ) );
logger.Error( "E2" );
logger.Warn( "W1bis" );
Assert.That( p.DynamicPath.Select( e => e.Level.ToString() + '|' + e.Text ).Single(), Is.EqualTo( "Warn|W1bis" ) );
Assert.That( p.LastErrorPath.Select( e => e.Level.ToString() + '|' + e.Text ).Single(), Is.EqualTo( "Error|E2" ) );
Assert.That( p.LastWarnOrErrorPath.Select( e => e.Level.ToString() + '|' + e.Text ).Single(), Is.EqualTo( "Warn|W1bis" ) );
p.ClearLastWarnPath();
Assert.That( p.LastErrorPath, Is.Not.Null );
Assert.That( p.LastWarnOrErrorPath, Is.Null );
p.ClearLastErrorPath();
Assert.That( p.LastErrorPath, Is.Null );
using( logger.OpenGroup( LogLevel.Trace, "G1" ) )
{
using( logger.OpenGroup( LogLevel.Info, "G2" ) )
{
Assert.That( String.Join( ">", p.DynamicPath.Select( e => e.Text ) ), Is.EqualTo( "G1>G2" ) );
Assert.That( p.LastErrorPath, Is.Null );
using( logger.OpenGroup( LogLevel.Trace, "G3" ) )
{
using( logger.OpenGroup( LogLevel.Info, "G4" ) )
{
logger.Warn( "W1" );
Assert.That( String.Join( ">", p.DynamicPath.Select( e => e.Text ) ), Is.EqualTo( "G1>G2>G3>G4>W1" ) );
logger.Info(
new Exception( "An exception logged as an Info.",
new Exception( "With an inner exception. Since these exceptions have not been thrown, there is no stack trace." ) ),
"Test With an exception: a Group is created. Since the text of the log is given, the Exception.Message must be displayed explicitely." );
Assert.That( String.Join( ">", p.DynamicPath.Select( e => e.Text ) ), Is.EqualTo( "G1>G2>G3>G4>Test With an exception: a Group is created. Since the text of the log is given, the Exception.Message must be displayed explicitely." ) );
try
{
try
{
try
{
try
{
throw new Exception( "Deepest excpetion." );
}
catch( Exception ex )
{
throw new Exception( "Yet another inner with inner Exception.", ex );
}
}
catch( Exception ex )
{
throw new Exception( "Exception with inner Exception.", ex );
}
}
catch( Exception ex )
{
throw new Exception( "Log without log text: the text of the entry is the Exception.Message.", ex );
}
}
catch( Exception ex )
{
logger.Trace( ex );
}
Assert.That( p.LastErrorPath, Is.Null );
Assert.That( String.Join( ">", p.LastWarnOrErrorPath.Select( e => e.Level.ToString() + '|' + e.Text ) ), Is.EqualTo( "Trace|G1>Info|G2>Trace|G3>Info|G4>Warn|W1" ) );
}
Assert.That( String.Join( ">", p.DynamicPath.Select( e => e.Text ) ), Is.EqualTo( "G1>G2>G3>G4" ) );
Assert.That( p.LastErrorPath, Is.Null );
Assert.That( String.Join( ">", p.LastWarnOrErrorPath.Select( e => e.Level.ToString() + '|' + e.Text ) ), Is.EqualTo( "Trace|G1>Info|G2>Trace|G3>Info|G4>Warn|W1" ) );
logger.Error( "E1" );
Assert.That( String.Join( ">", p.DynamicPath.Select( e => e.Text ) ), Is.EqualTo( "G1>G2>G3>E1" ) );
Assert.That( String.Join( ">", p.LastErrorPath.Select( e => e.Level.ToString() + '|' + e.Text ) ), Is.EqualTo( "Trace|G1>Info|G2>Trace|G3>Error|E1" ) );
Assert.That( String.Join( ">", p.LastWarnOrErrorPath.Select( e => e.Level.ToString() + '|' + e.Text ) ), Is.EqualTo( "Trace|G1>Info|G2>Trace|G3>Error|E1" ) );
}
Assert.That( String.Join( ">", p.DynamicPath.Select( e => e.Text ) ), Is.EqualTo( "G1>G2>G3" ) );
Assert.That( String.Join( ">", p.LastErrorPath.Select( e => e.Level.ToString() + '|' + e.Text ) ), Is.EqualTo( "Trace|G1>Info|G2>Trace|G3>Error|E1" ) );
Assert.That( String.Join( ">", p.LastWarnOrErrorPath.Select( e => e.Level.ToString() + '|' + e.Text ) ), Is.EqualTo( "Trace|G1>Info|G2>Trace|G3>Error|E1" ) );
}
Assert.That( String.Join( ">", p.DynamicPath.Select( e => e.Text ) ), Is.EqualTo( "G1>G2" ) );
using( logger.OpenGroup( LogLevel.Trace, "G2Bis" ) )
{
Assert.That( String.Join( ">", p.DynamicPath.Select( e => e.Text ) ), Is.EqualTo( "G1>G2Bis" ) );
Assert.That( String.Join( ">", p.LastErrorPath.Select( e => e.Level.ToString() + '|' + e.Text ) ), Is.EqualTo( "Trace|G1>Info|G2>Trace|G3>Error|E1" ) );
Assert.That( String.Join( ">", p.LastWarnOrErrorPath.Select( e => e.Level.ToString() + '|' + e.Text ) ), Is.EqualTo( "Trace|G1>Info|G2>Trace|G3>Error|E1" ) );
logger.Warn( "W2" );
Assert.That( String.Join( ">", p.DynamicPath.Select( e => e.Text ) ), Is.EqualTo( "G1>G2Bis>W2" ) );
Assert.That( String.Join( ">", p.LastWarnOrErrorPath.Select( e => e.Level.ToString() + '|' + e.Text ) ), Is.EqualTo( "Trace|G1>Trace|G2Bis>Warn|W2" ) );
Assert.That( String.Join( ">", p.LastErrorPath.Select( e => e.Level.ToString() + '|' + e.Text ) ), Is.EqualTo( "Trace|G1>Info|G2>Trace|G3>Error|E1" ) );
}
logger.Fatal( "F1" );
Assert.That( String.Join( ">", p.DynamicPath.Select( e => e.Text ) ), Is.EqualTo( "G1>F1" ) );
Assert.That( String.Join( ">", p.LastWarnOrErrorPath.Select( e => e.Level.ToString() + '|' + e.Text ) ), Is.EqualTo( "Trace|G1>Fatal|F1" ) );
Assert.That( String.Join( ">", p.LastErrorPath.Select( e => e.Level.ToString() + '|' + e.Text ) ), Is.EqualTo( "Trace|G1>Fatal|F1" ) );
}
// Extraneous closing are ignored.
logger.CloseGroup( null );
logger.Warn( "W3" );
Assert.That( String.Join( ">", p.DynamicPath.Select( e => e.Text ) ), Is.EqualTo( "W3" ) );
Assert.That( String.Join( ">", p.LastWarnOrErrorPath.Select( e => e.Level.ToString() + '|' + e.Text ) ), Is.EqualTo( "Warn|W3" ) );
Assert.That( String.Join( ">", p.LastErrorPath.Select( e => e.Level.ToString() + '|' + e.Text ) ), Is.EqualTo( "Trace|G1>Fatal|F1" ) );
// Extraneous closing are ignored.
logger.CloseGroup( null );
logger.Warn( "W4" );
Assert.That( String.Join( ">", p.DynamicPath.Select( e => e.Text ) ), Is.EqualTo( "W4" ) );
Assert.That( String.Join( ">", p.LastWarnOrErrorPath.Select( e => e.Level.ToString() + '|' + e.Text ) ), Is.EqualTo( "Warn|W4" ) );
Assert.That( String.Join( ">", p.LastErrorPath.Select( e => e.Level.ToString() + '|' + e.Text ) ), Is.EqualTo( "Trace|G1>Fatal|F1" ) );
p.ClearLastWarnPath( true );
Assert.That( p.LastErrorPath, Is.Null );
Assert.That( p.LastWarnOrErrorPath, Is.Null );
}
public void ErrorCounterTests()
{
var logger = new ActivityLogger();
// Binds the TestHelper.Logger logger to this one.
logger.Output.RegisterMuxClient( TestHelper.Logger.Output.ExternalInput );
// Registers the ErrorCounter first: it will be the last one to be called, but
// this does not prevent the PathCatcher to work: the path elements reference the group
// so that aany conclusion arriving after PathCatcher.OnClosing are available.
ActivityLoggerErrorCounter c = new ActivityLoggerErrorCounter();
logger.Output.RegisterMuxClient( c );
// Registers the PathCatcher now: it will be called BEFORE the ErrorCounter.
ActivityLoggerPathCatcher p = new ActivityLoggerPathCatcher();
logger.Output.RegisterClient( p );
Assert.That( c.GenerateConclusion, Is.True, "Must be the default." );
Assert.That( c.Root.MaxLogLevel == LogLevel.None );
logger.Trace( "T1" );
Assert.That( !c.Root.HasWarnOrError && !c.Root.HasError );
Assert.That( c.Root.MaxLogLevel == LogLevel.Trace );
Assert.That( c.Root.ToString(), Is.Null );
logger.Warn( "W1" );
Assert.That( c.Root.HasWarnOrError && !c.Root.HasError );
Assert.That( c.Root.MaxLogLevel == LogLevel.Warn );
Assert.That( c.Root.ToString(), Is.Not.Null.And.Not.Empty );
logger.Error( "E2" );
Assert.That( c.Root.HasWarnOrError && c.Root.HasError );
Assert.That( c.Root.ErrorCount == 1 );
Assert.That( c.Root.MaxLogLevel == LogLevel.Error );
Assert.That( c.Root.ToString(), Is.Not.Null.And.Not.Empty );
c.Root.ClearError();
Assert.That( c.Root.HasWarnOrError && !c.Root.HasError );
Assert.That( c.Root.ErrorCount == 0 );
Assert.That( c.Root.MaxLogLevel == LogLevel.Warn );
Assert.That( c.Root.ToString(), Is.Not.Null );
c.Root.ClearWarn();
Assert.That( !c.Root.HasWarnOrError && !c.Root.HasError );
Assert.That( c.Root.MaxLogLevel == LogLevel.Info );
Assert.That( c.Root.ToString(), Is.Null );
using( logger.OpenGroup( LogLevel.Trace, "G1" ) )
{
using( logger.OpenGroup( LogLevel.Info, "G2" ) )
{
logger.Error( "E1" );
logger.Fatal( "F1" );
Assert.That( c.Root.HasWarnOrError && c.Root.HasError );
Assert.That( c.Root.ErrorCount == 1 && c.Root.FatalCount == 1 );
Assert.That( c.Root.WarnCount == 0 );
using( logger.OpenGroup( LogLevel.Info, "G3" ) )
{
Assert.That( !c.Current.HasWarnOrError && !c.Current.HasError );
Assert.That( c.Current.ErrorCount == 0 && c.Current.FatalCount == 0 && c.Current.WarnCount == 0 );
logger.Error( "E2" );
Assert.That( c.Current.HasWarnOrError && c.Current.HasError );
Assert.That( c.Current.ErrorCount == 1 && c.Current.FatalCount == 0 && c.Current.WarnCount == 0 );
}
}
Assert.That( String.Join( ">", p.LastErrorPath.Select( e => e.Text + '-' + e.GroupConclusion.ToStringGroupConclusion() ) ), Is.EqualTo( "G1->G2-1 Fatal error, 2 Errors>G3-1 Error>E2-" ) );
logger.Error( "E3" );
logger.Fatal( "F2" );
logger.Warn( "W2" );
Assert.That( c.Root.HasWarnOrError && c.Root.HasError );
Assert.That( c.Root.FatalCount == 2 );
Assert.That( c.Root.ErrorCount == 3 );
Assert.That( c.Root.MaxLogLevel == LogLevel.Fatal );
}
Assert.That( String.Join( ">", p.LastErrorPath.Select( e => e.Text + '-' + e.GroupConclusion.ToStringGroupConclusion() ) ), Is.EqualTo( "G1-2 Fatal errors, 3 Errors, 1 Warning>F2-" ) );
Assert.That( String.Join( ">", p.LastWarnOrErrorPath.Select( e => e.Text + '-' + e.GroupConclusion.ToStringGroupConclusion() ) ), Is.EqualTo( "G1-2 Fatal errors, 3 Errors, 1 Warning>W2-" ) );
}
