public void registering_multiple_times_the_same_client_is_an_error()
{
ActivityMonitor.AutoConfiguration = null;
IActivityMonitor monitor = new ActivityMonitor();
Assert.That( monitor.Output.Clients.Count, Is.EqualTo( 0 ) );
var counter = new ActivityMonitorErrorCounter();
monitor.Output.RegisterClient( counter );
Assert.That( monitor.Output.Clients.Count, Is.EqualTo( 1 ) );
Assert.Throws<InvalidOperationException>( () => TestHelper.ConsoleMonitor.Output.RegisterClient( counter ), "Counter can be registered in one source at a time." );
var pathCatcher = new ActivityMonitorPathCatcher();
monitor.Output.RegisterClient( pathCatcher );
Assert.That( monitor.Output.Clients.Count, Is.EqualTo( 2 ) );
Assert.Throws<InvalidOperationException>( () => TestHelper.ConsoleMonitor.Output.RegisterClient( pathCatcher ), "PathCatcher can be registered in one source at a time." );
IActivityMonitor other = new ActivityMonitor( applyAutoConfigurations: false );
ActivityMonitorBridge bridgeToConsole;
using( monitor.Output.CreateBridgeTo( TestHelper.ConsoleMonitor.Output.BridgeTarget ) )
{
bridgeToConsole = monitor.Output.FindBridgeTo( TestHelper.ConsoleMonitor.Output.BridgeTarget );
Assert.That( monitor.Output.Clients.Count, Is.EqualTo( 3 ) );
Assert.That( bridgeToConsole.TargetMonitor, Is.SameAs( TestHelper.ConsoleMonitor ) );
Assert.Throws<InvalidOperationException>( () => other.Output.RegisterClient( bridgeToConsole ), "Bridge can be associated to only one source monitor." );
}
Assert.That( monitor.Output.Clients.Count, Is.EqualTo( 2 ) );
Assert.DoesNotThrow( () => other.Output.RegisterClient( bridgeToConsole ), "Now we can." );
Assert.DoesNotThrow( () => monitor.Output.UnregisterClient( bridgeToConsole ), "Already removed." );
monitor.Output.UnregisterClient( counter );
monitor.Output.UnregisterClient( pathCatcher );
Assert.That( monitor.Output.Clients.Count, Is.EqualTo( 0 ) );
}
void Create()
{
{
var m = new ActivityMonitor();
}
{
var m = new ActivityMonitor(applyAutoConfigurations: false);
}
{
IActivityMonitor m = new ActivityMonitor();
var counter = new ActivityMonitorErrorCounter();
m.Output.RegisterClient(counter);
m.Fatal().Send("An horrible error occurred.");
Assert.That(counter.Current.FatalCount == 1);
m.Output.UnregisterClient(counter);
}
{
IActivityMonitor m = new ActivityMonitor();
int errorCount = 0;
using (m.OnError(() => ++ errorCount))
{
m.Fatal().Send("An horrible error occurred.");
}
Assert.That(errorCount == 1);
}
{
IActivityMonitor m = new ActivityMonitor();
m.MinimalFilter = LogFilter.Off;
// ...
m.MinimalFilter = LogFilter.Debug;
}
{
IActivityMonitor m = new ActivityMonitor();
m.MinimalFilter = LogFilter.Terse;
using (m.SetMinimalFilter(LogFilter.Debug))
{
Assert.That(m.ActualFilter == LogFilter.Debug);
}
Assert.That(m.ActualFilter == LogFilter.Terse, "Filter has been restored to previous value.");
}
{
IActivityMonitor m = new ActivityMonitor();
m.MinimalFilter = LogFilter.Off;
// ...
using (m.OpenWarn().Send("Ouch..."))
{
Assert.That(m.ActualFilter == LogFilter.Off);
m.MinimalFilter = LogFilter.Debug;
// ... in debug filter ...
}
Assert.That(m.ActualFilter == LogFilter.Off, "Back to Off.");
var strange = new LogFilter(LogLevelFilter.Fatal, LogLevelFilter.Trace);
}
}
public void ErrorCounterTests()
{
var monitor = new ActivityMonitor( applyAutoConfigurations: false );
using( monitor.Output.CreateBridgeTo( TestHelper.ConsoleMonitor.Output.BridgeTarget ) )
{
// 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 any conclusion arriving after PathCatcher.OnClosing are available.
ActivityMonitorErrorCounter c = new ActivityMonitorErrorCounter();
monitor.Output.RegisterClient( c );
// Registers the PathCatcher now: it will be called BEFORE the ErrorCounter.
ActivityMonitorPathCatcher p = new ActivityMonitorPathCatcher();
monitor.Output.RegisterClient( p );
Assert.That( c.GenerateConclusion, Is.False, "False by default." );
c.GenerateConclusion = true;
Assert.That( c.Root.MaxLogLevel == LogLevel.None );
monitor.Trace().Send( "T1" );
Assert.That( !c.Root.HasWarnOrError && !c.Root.HasError );
Assert.That( c.Root.MaxLogLevel == LogLevel.Trace );
Assert.That( c.Root.ToString(), Is.Null );
monitor.Warn().Send( "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 );
monitor.Error().Send( "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( monitor.OpenTrace().Send( "G1" ) )
{
string errorMessage;
using( monitor.OpenInfo().Send( "G2" ) )
{
monitor.Error().Send( "E1" );
monitor.Fatal().Send( "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( monitor.OpenInfo().Send( "G3" ) )
{
Assert.That( !c.Current.HasWarnOrError && !c.Current.HasError );
Assert.That( c.Current.ErrorCount == 0 && c.Current.FatalCount == 0 && c.Current.WarnCount == 0 );
monitor.Error().Send( "An error..." );
Assert.That( c.Current.HasWarnOrError && c.Current.HasError );
Assert.That( c.Current.ErrorCount == 1 && c.Current.FatalCount == 0 && c.Current.WarnCount == 0 );
errorMessage = String.Join( "|", p.LastErrorPath.Select( e => e.Text + '-' + e.GroupConclusion.ToStringGroupConclusion() ) );
Assert.That( errorMessage, Is.EqualTo( "G1-|G2-|G3-|An error...-" ), "Groups are not closed: no conclusion exist yet." );
}
errorMessage = String.Join( "|", p.LastErrorPath.Select( e => e.Text + '-' + e.GroupConclusion.ToStringGroupConclusion() ) );
Assert.That( errorMessage, Is.EqualTo( "G1-|G2-|G3-1 Error|An error...-" ), "G3 is closed: its conclusion is available." );
}
errorMessage = String.Join( "|", p.LastErrorPath.Select( e => e.Text + '-' + e.GroupConclusion.ToStringGroupConclusion() ) );
Assert.That( errorMessage, Is.EqualTo( "G1-|G2-1 Fatal error, 2 Errors|G3-1 Error|An error...-" ) );
monitor.Error().Send( "E3" );
monitor.Fatal().Send( "F2" );
monitor.Warn().Send( "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-" ) );
}
}
