public void ExplicitCloseWins()
{
IDefaultActivityLogger l = DefaultActivityLogger.Create();
// Binds the TestHelper.Logger logger to this one.
l.Output.RegisterMuxClient(TestHelper.Logger.Output.ExternalInput);
var log = new StringImpl();
l.Register(log);
// No explicit close conclusion: Success!
using (l.OpenGroup(LogLevel.Trace, () => "Success!", "First"))
{
l.Error("Pouf");
}
Assert.That(log.Writer.ToString(), Is.StringContaining("Pouf"));
Assert.That(log.Writer.ToString(), Is.Not.StringContaining("Failed!"), "Default conclusion wins.");
Assert.That(log.Writer.ToString(), Is.StringContaining("Success!"), "Default conclusion.");
log.Writer.GetStringBuilder().Clear();
Assert.That(log.Writer.ToString(), Is.Empty);
// Explicit conclusion: Failed!
using (l.OpenGroup(LogLevel.Trace, () => "Success!", "First"))
{
l.Error("Pouf");
l.CloseGroup("Failed!");
}
Console.WriteLine(log.Writer.ToString());
Assert.That(log.Writer.ToString(), Is.StringContaining("Pouf"));
Assert.That(log.Writer.ToString(), Is.StringContaining("Failed!"), "Explicit conclusion wins.");
Assert.That(log.Writer.ToString(), Is.Not.StringContaining("Success!"), "Explicit conclusion wins.");
}
public void TestStartsWith()
{
const string stringValue = "SomeRandomStringIsHere";
Assert.AreEqual(stringValue.StartsWith("Some", StringComparison.Ordinal), // overload #1
StringImpl.StartsWith(stringValue, "Some", StringComparison.Ordinal));
Assert.AreEqual(stringValue.StartsWith("", StringComparison.Ordinal),
StringImpl.StartsWith(stringValue, "", StringComparison.Ordinal));
Assert.AreEqual(stringValue.StartsWith("some", StringComparison.Ordinal),
StringImpl.StartsWith(stringValue, "some", StringComparison.Ordinal));
Assert.AreEqual(stringValue.StartsWith("Some"), // overload #2
StringImpl.StartsWith(stringValue, "Some"));
Assert.AreEqual(stringValue.StartsWith(""),
StringImpl.StartsWith(stringValue, ""));
Assert.AreEqual(stringValue.StartsWith("some"),
StringImpl.StartsWith(stringValue, "some"));
Assert.AreEqual(stringValue.StartsWith("Some", false, null), //overload #3
StringImpl.StartsWith(stringValue, "Some", false, null));
Assert.AreEqual(stringValue.StartsWith("", false, null),
StringImpl.StartsWith(stringValue, "", false, null));
Assert.AreEqual(stringValue.StartsWith("some", false, null),
StringImpl.StartsWith(stringValue, "some", false, null));
}
public void MultipleClose()
{
IDefaultActivityLogger logger = DefaultActivityLogger.Create();
// Binds the TestHelper.Logger logger to this one.
logger.Output.RegisterMuxClient(TestHelper.Logger.Output.ExternalInput);
var log1 = new StringImpl();
logger.Register(log1);
Assert.That(logger.RegisteredSinks.Count, Is.EqualTo(1));
using (logger.OpenGroup(LogLevel.Trace, () => "End First", "First"))
{
logger.CloseGroup("Pouf");
using (logger.OpenGroup(LogLevel.Warn, "A group at level 0!"))
{
logger.CloseGroup("Close it.");
logger.CloseGroup("Close it again.");
}
}
Assert.That(log1.Writer.ToString(), Is.Not.StringContaining("End First"), "Close forgets other closes...");
Assert.That(log1.Writer.ToString(), Is.Not.StringContaining("Close it again"), "Close forgets other closes...");
}
public void TestStringSubstring2()
{
var s1 = "Abcd";
var s2 = s1.Substring(2, 2);
var s3 = StringImpl.Substring(s1, 2, 2);
Assert.AreEqual(s2, s3);
}
public void FilterLevel()
{
IDefaultActivityLogger l = DefaultActivityLogger.Create();
// Binds the TestHelper.Logger logger to this one.
l.Output.RegisterMuxClient(TestHelper.Logger.Output.ExternalInput);
var log = new StringImpl();
l.Register(log);
using (l.Filter(LogLevelFilter.Error))
{
l.Trace("NO SHOW");
l.Info("NO SHOW");
l.Warn("NO SHOW");
l.Error("Error n°1");
using (l.Filter(LogLevelFilter.Warn))
{
l.Trace("NO SHOW");
l.Info("NO SHOW");
l.Warn("Warn n°1");
l.Error("Error n°2");
using (l.OpenGroup(LogLevel.Info, "GroupInfo"))
{
Assert.That(l.Filter, Is.EqualTo(LogLevelFilter.Warn), "Groups does not change the current filter level.");
l.Trace("NO SHOW");
l.Info("NO SHOW");
l.Warn("Warn n°2");
l.Error("Error n°3");
// Changing the level inside a Group.
l.Filter = LogLevelFilter.Fatal;
l.Error("NO SHOW");
l.Fatal("Fatal n°1");
}
Assert.That(l.Filter, Is.EqualTo(LogLevelFilter.Warn), "But Groups restores the original filter level when closed.");
l.Trace("NO SHOW");
l.Info("NO SHOW");
l.Warn("Warn n°3");
l.Error("Error n°4");
l.Fatal("Fatal n°2");
}
l.Trace("NO SHOW");
l.Info("NO SHOW");
l.Warn("NO SHOW");
l.Error("Error n°5");
}
Assert.That(log.Writer.ToString(), Is.Not.StringContaining("NO SHOW"));
Assert.That(log.Writer.ToString(), Is.StringContaining("Error n°1")
.And.StringContaining("Error n°2")
.And.StringContaining("Error n°3")
.And.StringContaining("Error n°4")
.And.StringContaining("Error n°5"));
Assert.That(log.Writer.ToString(), Is.StringContaining("Warn n°1")
.And.StringContaining("Warn n°2")
.And.StringContaining("Warn n°3"));
Assert.That(log.Writer.ToString(), Is.StringContaining("Fatal n°1")
.And.StringContaining("Fatal n°2"));
}
public void TestIndexOf()
{
const string stringValue = "Some longer string, and some other data.";
Assert.AreEqual(stringValue.IndexOf("om", 4, 3, StringComparison.Ordinal), // overload #1
StringImpl.IndexOf(stringValue, "om", 4, 3, StringComparison.Ordinal));
Assert.AreEqual(stringValue.IndexOf("om", 0, stringValue.Length, StringComparison.Ordinal),
StringImpl.IndexOf(stringValue, "om", 0, stringValue.Length, StringComparison.Ordinal));
Assert.AreEqual(stringValue.IndexOf("om", 3, stringValue.Length - 3, StringComparison.Ordinal),
StringImpl.IndexOf(stringValue, "om", 3, stringValue.Length - 3, StringComparison.Ordinal));
Assert.AreEqual(stringValue.IndexOf("some", 0, stringValue.Length, StringComparison.Ordinal),
StringImpl.IndexOf(stringValue, "some", 0, stringValue.Length, StringComparison.Ordinal));
Assert.AreEqual(stringValue.IndexOf("Some", 0, stringValue.Length, StringComparison.Ordinal),
StringImpl.IndexOf(stringValue, "Some", 0, stringValue.Length, StringComparison.Ordinal));
// overloaded versions
Assert.AreEqual(stringValue.IndexOf("a", 0, stringValue.Length), // overload #2
StringImpl.IndexOf(stringValue, "a", 0, stringValue.Length));
Assert.AreEqual(stringValue.IndexOf("a", 30), // overload #3
StringImpl.IndexOf(stringValue, "a", 30));
Assert.AreEqual(stringValue.IndexOf("a", 30, StringComparison.Ordinal), // overload #4
StringImpl.IndexOf(stringValue, "a", 30, StringComparison.Ordinal));
Assert.AreEqual(stringValue.IndexOf("a"), // overload #5
StringImpl.IndexOf(stringValue, "a"));
Assert.AreEqual(stringValue.IndexOf("a", StringComparison.Ordinal), // overload #6
StringImpl.IndexOf(stringValue, "a", StringComparison.Ordinal));
// character overload versions of IndexOf
Assert.AreEqual(stringValue.IndexOf('a', 30, stringValue.Length - 30), // overload #7
StringImpl.IndexOf(stringValue, 'a', 30, stringValue.Length - 30));
Assert.AreEqual(stringValue.IndexOf('a', 30), // overload #8
StringImpl.IndexOf(stringValue, 'a', 30));
Assert.AreEqual(stringValue.IndexOf('a'), // overload #9
StringImpl.IndexOf(stringValue, 'a'));
}
public void TestStringTrim()
{
const string stringValue = " \t\n Abcd \n\t ";
Assert.AreEqual(stringValue.Trim(),
StringImpl.Trim(stringValue),
"Default trim should remove '\\n', '\\t' and ' '");
Assert.AreEqual(stringValue.Trim('\n', ' '),
StringImpl.Trim(stringValue, '\n', ' '),
"Custom trims should remove only some characters.");
Assert.AreEqual(stringValue.Trim('\n', '\t', ' ', 'A', 'b', 'c', 'd'),
StringImpl.Trim(stringValue, '\n', '\t', ' ', 'A', 'b', 'c', 'd'),
"Trims should be able to make strings empty.");
Assert.AreEqual("".Trim(),
StringImpl.Trim(""),
"Trims on empty strings should be allowed.");
}
public void CloseMismatch()
{
IDefaultActivityLogger l = DefaultActivityLogger.Create();
var log = new StringImpl();
l.Register(log);
{
IDisposable g0 = l.OpenGroup(LogLevel.Trace, "First");
IDisposable g1 = l.OpenGroup(LogLevel.Trace, "Second");
IDisposable g2 = l.OpenGroup(LogLevel.Trace, "Third");
g1.Dispose();
l.Trace("Inside First");
g0.Dispose();
l.Trace("At root");
var end = "Trace: Inside First" + Environment.NewLine + "-" + Environment.NewLine + "Trace: At root";
Assert.That(log.Writer.ToString(), Is.StringEnding(end));
}
{
// g2 is closed after g1.
IDisposable g0 = l.OpenGroup(LogLevel.Trace, "First");
IDisposable g1 = l.OpenGroup(LogLevel.Trace, "Second");
IDisposable g2 = l.OpenGroup(LogLevel.Trace, "Third");
log.Writer.GetStringBuilder().Clear();
g1.Dispose();
// g2 has already been disposed by g1.
// Nothing changed.
g2.Dispose();
l.Trace("Inside First");
g0.Dispose();
l.Trace("At root");
var end = "Trace: Inside First" + Environment.NewLine + "-" + Environment.NewLine + "Trace: At root";
Assert.That(log.Writer.ToString(), Is.StringEnding(end));
}
}
public void CloseMismatch()
{
IDefaultActivityLogger l = DefaultActivityLogger.Create();
var log = new StringImpl();
l.Register( log );
{
IDisposable g0 = l.OpenGroup( LogLevel.Trace, "First" );
IDisposable g1 = l.OpenGroup( LogLevel.Trace, "Second" );
IDisposable g2 = l.OpenGroup( LogLevel.Trace, "Third" );
g1.Dispose();
l.Trace( "Inside First" );
g0.Dispose();
l.Trace( "At root" );
var end = "Trace: Inside First" + Environment.NewLine + "-" + Environment.NewLine + "Trace: At root";
Assert.That( log.Writer.ToString(), Is.StringEnding( end ) );
}
{
// g2 is closed after g1.
IDisposable g0 = l.OpenGroup( LogLevel.Trace, "First" );
IDisposable g1 = l.OpenGroup( LogLevel.Trace, "Second" );
IDisposable g2 = l.OpenGroup( LogLevel.Trace, "Third" );
log.Writer.GetStringBuilder().Clear();
g1.Dispose();
// g2 has already been disposed by g1.
// Nothing changed.
g2.Dispose();
l.Trace( "Inside First" );
g0.Dispose();
l.Trace( "At root" );
var end = "Trace: Inside First" + Environment.NewLine + "-" + Environment.NewLine + "Trace: At root";
Assert.That( log.Writer.ToString(), Is.StringEnding( end ) );
}
}
public void MultipleClose()
{
IDefaultActivityLogger logger = DefaultActivityLogger.Create();
// Binds the TestHelper.Logger logger to this one.
logger.Output.RegisterMuxClient( TestHelper.Logger.Output.ExternalInput );
var log1 = new StringImpl();
logger.Register( log1 );
Assert.That( logger.RegisteredSinks.Count, Is.EqualTo( 1 ) );
using( logger.OpenGroup( LogLevel.Trace, () => "End First", "First" ) )
{
logger.CloseGroup( "Pouf" );
using( logger.OpenGroup( LogLevel.Warn, "A group at level 0!" ) )
{
logger.CloseGroup( "Close it." );
logger.CloseGroup( "Close it again." );
}
}
Assert.That( log1.Writer.ToString(), Is.Not.StringContaining( "End First" ), "Close forgets other closes..." );
Assert.That( log1.Writer.ToString(), Is.Not.StringContaining( "Close it again" ), "Close forgets other closes..." );
}
public void FilterLevel()
{
IDefaultActivityLogger l = DefaultActivityLogger.Create();
// Binds the TestHelper.Logger logger to this one.
l.Output.RegisterMuxClient( TestHelper.Logger.Output.ExternalInput );
var log = new StringImpl();
l.Register( log );
using( l.Filter( LogLevelFilter.Error ) )
{
l.Trace( "NO SHOW" );
l.Info( "NO SHOW" );
l.Warn( "NO SHOW" );
l.Error( "Error n°1" );
using( l.Filter( LogLevelFilter.Warn ) )
{
l.Trace( "NO SHOW" );
l.Info( "NO SHOW" );
l.Warn( "Warn n°1" );
l.Error( "Error n°2" );
using( l.OpenGroup( LogLevel.Info, "GroupInfo" ) )
{
Assert.That( l.Filter, Is.EqualTo( LogLevelFilter.Warn ), "Groups does not change the current filter level." );
l.Trace( "NO SHOW" );
l.Info( "NO SHOW" );
l.Warn( "Warn n°2" );
l.Error( "Error n°3" );
// Changing the level inside a Group.
l.Filter = LogLevelFilter.Fatal;
l.Error( "NO SHOW" );
l.Fatal( "Fatal n°1" );
}
Assert.That( l.Filter, Is.EqualTo( LogLevelFilter.Warn ), "But Groups restores the original filter level when closed." );
l.Trace( "NO SHOW" );
l.Info( "NO SHOW" );
l.Warn( "Warn n°3" );
l.Error( "Error n°4" );
l.Fatal( "Fatal n°2" );
}
l.Trace( "NO SHOW" );
l.Info( "NO SHOW" );
l.Warn( "NO SHOW" );
l.Error( "Error n°5" );
}
Assert.That( log.Writer.ToString(), Is.Not.StringContaining( "NO SHOW" ) );
Assert.That( log.Writer.ToString(), Is.StringContaining( "Error n°1" )
.And.StringContaining( "Error n°2" )
.And.StringContaining( "Error n°3" )
.And.StringContaining( "Error n°4" )
.And.StringContaining( "Error n°5" ) );
Assert.That( log.Writer.ToString(), Is.StringContaining( "Warn n°1" )
.And.StringContaining( "Warn n°2" )
.And.StringContaining( "Warn n°3" ) );
Assert.That( log.Writer.ToString(), Is.StringContaining( "Fatal n°1" )
.And.StringContaining( "Fatal n°2" ) );
}
public void ExplicitCloseWins()
{
IDefaultActivityLogger l = DefaultActivityLogger.Create();
// Binds the TestHelper.Logger logger to this one.
l.Output.RegisterMuxClient( TestHelper.Logger.Output.ExternalInput );
var log = new StringImpl();
l.Register( log );
// No explicit close conclusion: Success!
using( l.OpenGroup( LogLevel.Trace, () => "Success!", "First" ) )
{
l.Error( "Pouf" );
}
Assert.That( log.Writer.ToString(), Is.StringContaining( "Pouf" ) );
Assert.That( log.Writer.ToString(), Is.Not.StringContaining( "Failed!" ), "Default conclusion wins." );
Assert.That( log.Writer.ToString(), Is.StringContaining( "Success!" ), "Default conclusion." );
log.Writer.GetStringBuilder().Clear();
Assert.That( log.Writer.ToString(), Is.Empty );
// Explicit conclusion: Failed!
using( l.OpenGroup( LogLevel.Trace, () => "Success!", "First" ) )
{
l.Error( "Pouf" );
l.CloseGroup( "Failed!" );
}
Console.WriteLine( log.Writer.ToString() );
Assert.That( log.Writer.ToString(), Is.StringContaining( "Pouf" ) );
Assert.That( log.Writer.ToString(), Is.StringContaining( "Failed!" ), "Explicit conclusion wins." );
Assert.That( log.Writer.ToString(), Is.Not.StringContaining( "Success!" ), "Explicit conclusion wins." );
}
