public void RootCanLogMessage()
{
var o = new SomeOutput();
var f1 = LoggerEx.CreateDefaultFactory();
var root = f1.Root;
root.Severity = Severity.Debug;
root.Log(Severity.Debug, "test");
root.Outputs.Add(o);
root.Log(Severity.Debug, "test");
Assert.Equal("test", o.LastMessage.Get(MessageTokens.Message));
Assert.Equal(Severity.Debug, o.LastMessage.Severity);
root.Severity = Severity.Error;
root.Log(Severity.Info, "test1");
// this should not be logged
Assert.Equal("test", o.LastMessage.Get(MessageTokens.Message));
Assert.Equal(Severity.Debug, o.LastMessage.Severity);
root.Log(Severity.Error, "error");
// but this should
Assert.Equal("error", o.LastMessage.Get(MessageTokens.Message));
Assert.Equal(Severity.Error, o.LastMessage.Severity);
root.Log(Severity.Fatal, "fatal");
// and this should
Assert.Equal("fatal", o.LastMessage.Get(MessageTokens.Message));
Assert.Equal(Severity.Fatal, o.LastMessage.Severity);
}
public void DefaultOutputsOk()
{
var outputs = OutputEx.DefaultOutputs();
Assert.Equal(0, outputs.Count);
Assert.True(outputs.SequenceEqual(Enumerable.Empty <IOutput>()));
var o1 = new SomeOutput();
var message = MessageEx.Default(Severity.Debug);
outputs.Add(o1);
Assert.Equal(1, outputs.Count);
Assert.True(outputs.SequenceEqual(new[] { o1 }));
o1.Throw = true;
outputs.Log(message);
Assert.Equal(0, o1.Logged.Count);
o1.Throw = false;
outputs.Log(message);
Assert.True(o1.Logged.SequenceEqual(new[] { message }));
var o2 = new SomeOutput();
outputs.Add(o2);
Assert.Equal(2, outputs.Count);
Assert.True(new[] { o1, o2 }.All(c => outputs.Contains(c)));
outputs.Log(message);
Assert.True(o1.Logged.SequenceEqual(new[] { message, message }));
Assert.True(o2.Logged.SequenceEqual(new[] { message }));
o1.Throw = true;
outputs.Log(message);
Assert.True(o1.Logged.SequenceEqual(new[] { message, message }));
Assert.True(o2.Logged.SequenceEqual(new[] { message, message }));
o1.Throw = false;
o2.Throw = true;
outputs.Log(message);
Assert.True(o1.Logged.SequenceEqual(new[] { message, message, message }));
Assert.True(o2.Logged.SequenceEqual(new[] { message, message }));
outputs.Remove(o1);
Assert.Equal(1, outputs.Count);
Assert.True(outputs.SequenceEqual(new[] { o2 }));
o2.Throw = false;
outputs.Log(message);
Assert.True(o1.Logged.SequenceEqual(new[] { message, message, message }));
Assert.True(o2.Logged.SequenceEqual(new[] { message, message, message }));
outputs.Dispose();
Assert.False(o1.Disposed);
Assert.True(o2.Disposed);
}
public void OutputSeverityOk()
{
var output = new SomeOutput();
var errorOutput = output.OutputSeverity(Severity.Error);
var debugMsg = MessageEx.Default(Severity.Debug);
var infoMsg = MessageEx.Default(Severity.Info);
var errorMsg = MessageEx.Default(Severity.Error);
var fatalMsg = MessageEx.Default(Severity.Fatal);
var offMsg = MessageEx.Default(Severity.Off);
errorOutput.Log(debugMsg);
errorOutput.Log(infoMsg);
errorOutput.Log(errorMsg);
errorOutput.Log(fatalMsg);
errorOutput.Log(offMsg);
Assert.True(output.Logged.SequenceEqual(new[] { errorMsg, fatalMsg }));
}
public void LogUsesMessageFactory()
{
var f = LoggerEx.CreateDefaultFactory(new FatalMessageFactory());
var root = f.Root;
root.Severity = Severity.Debug;
var rootOutput = new SomeOutput();
root.Outputs.Add(rootOutput);
root.Log(Severity.Warn, "W");
var lastMessage = rootOutput.LastMessage;
Assert.Equal(Severity.Fatal, lastMessage.Severity);
f.Get("test").Log(Severity.Info, "I");
Assert.Equal(Severity.Fatal, rootOutput.LastMessage.Severity);
Assert.NotEqual(lastMessage, rootOutput.LastMessage);
}
public void ChildLogToRootAndSelf()
{
var f = LoggerEx.CreateDefaultFactory();
var root = f.Root;
root.Severity = Severity.Debug;
var child = f.Get("test");
var rootOutput = new SomeOutput();
root.Outputs.Add(rootOutput);
child.Log(Severity.Debug, "d");
Assert.Equal(Severity.Debug, rootOutput.LastMessage.Severity);
var childOutput = new SomeOutput();
child.Outputs.Add(childOutput);
child.Log(Severity.Warn, "W");
Assert.Equal(Severity.Warn, rootOutput.LastMessage.Severity);
Assert.Equal(Severity.Warn, childOutput.LastMessage.Severity);
f.Get("test2").Log(Severity.Info, "I");
Assert.Equal(Severity.Info, rootOutput.LastMessage.Severity);
Assert.Equal(Severity.Warn, childOutput.LastMessage.Severity);
}
