tabs to spaces (test project)
diff --git a/src/log4net.Tests/Appender/AppenderCollectionTest.cs b/src/log4net.Tests/Appender/AppenderCollectionTest.cs
index e22c364..cf135f6 100644
--- a/src/log4net.Tests/Appender/AppenderCollectionTest.cs
+++ b/src/log4net.Tests/Appender/AppenderCollectionTest.cs
@@ -22,44 +22,44 @@
namespace log4net.Tests.Appender
{
- /// <summary>
- /// Used for internal unit testing the <see cref="AppenderCollection"/> class.
- /// </summary>
- /// <remarks>
- /// Used for internal unit testing the <see cref="AppenderCollection"/> class.
- /// </remarks>
- /// <author>Carlos Muñoz</author>
- [TestFixture]
- public class AppenderCollectionTest
- {
- /// <summary>
- /// Verifies that ToArray returns the elements of the <see cref="AppenderCollection"/>
- /// </summary>
- [Test]
- public void ToArrayTest()
- {
- AppenderCollection appenderCollection = new AppenderCollection();
- IAppender appender = new MemoryAppender();
- appenderCollection.Add(appender);
+ /// <summary>
+ /// Used for internal unit testing the <see cref="AppenderCollection"/> class.
+ /// </summary>
+ /// <remarks>
+ /// Used for internal unit testing the <see cref="AppenderCollection"/> class.
+ /// </remarks>
+ /// <author>Carlos Muñoz</author>
+ [TestFixture]
+ public class AppenderCollectionTest
+ {
+ /// <summary>
+ /// Verifies that ToArray returns the elements of the <see cref="AppenderCollection"/>
+ /// </summary>
+ [Test]
+ public void ToArrayTest()
+ {
+ AppenderCollection appenderCollection = new AppenderCollection();
+ IAppender appender = new MemoryAppender();
+ appenderCollection.Add(appender);
- IAppender[] appenderArray = appenderCollection.ToArray();
+ IAppender[] appenderArray = appenderCollection.ToArray();
- Assert.AreEqual(1, appenderArray.Length);
- Assert.AreEqual(appender, appenderArray[0]);
- }
+ Assert.AreEqual(1, appenderArray.Length);
+ Assert.AreEqual(appender, appenderArray[0]);
+ }
- [Test]
- public void ReadOnlyToArrayTest()
- {
- AppenderCollection appenderCollection = new AppenderCollection();
- IAppender appender = new MemoryAppender();
- appenderCollection.Add(appender);
- AppenderCollection readonlyAppenderCollection = AppenderCollection.ReadOnly(appenderCollection);
+ [Test]
+ public void ReadOnlyToArrayTest()
+ {
+ AppenderCollection appenderCollection = new AppenderCollection();
+ IAppender appender = new MemoryAppender();
+ appenderCollection.Add(appender);
+ AppenderCollection readonlyAppenderCollection = AppenderCollection.ReadOnly(appenderCollection);
- IAppender[] appenderArray = readonlyAppenderCollection.ToArray();
+ IAppender[] appenderArray = readonlyAppenderCollection.ToArray();
- Assert.AreEqual(1, appenderArray.Length);
- Assert.AreEqual(appender, appenderArray[0]);
- }
- }
+ Assert.AreEqual(1, appenderArray.Length);
+ Assert.AreEqual(appender, appenderArray[0]);
+ }
+ }
}
\ No newline at end of file
diff --git a/src/log4net.Tests/Appender/BufferingAppenderTest.cs b/src/log4net.Tests/Appender/BufferingAppenderTest.cs
index ca65663..638ad69 100644
--- a/src/log4net.Tests/Appender/BufferingAppenderTest.cs
+++ b/src/log4net.Tests/Appender/BufferingAppenderTest.cs
@@ -25,88 +25,88 @@
namespace log4net.Tests.Appender
{
- /// <summary>
- /// Used for internal unit testing the <see cref="BufferingAppenderSkeleton"/> class.
- /// </summary>
- /// <remarks>
- /// Used for internal unit testing the <see cref="BufferingAppenderSkeleton"/> class.
- /// </remarks>
- [TestFixture]
- public class BufferingAppenderTest
- {
- private BufferingForwardingAppender m_bufferingForwardingAppender;
- private CountingAppender m_countingAppender;
- private Repository.Hierarchy.Hierarchy m_hierarchy;
+ /// <summary>
+ /// Used for internal unit testing the <see cref="BufferingAppenderSkeleton"/> class.
+ /// </summary>
+ /// <remarks>
+ /// Used for internal unit testing the <see cref="BufferingAppenderSkeleton"/> class.
+ /// </remarks>
+ [TestFixture]
+ public class BufferingAppenderTest
+ {
+ private BufferingForwardingAppender m_bufferingForwardingAppender;
+ private CountingAppender m_countingAppender;
+ private Repository.Hierarchy.Hierarchy m_hierarchy;
- private void SetupRepository()
- {
- m_hierarchy = new Repository.Hierarchy.Hierarchy();
+ private void SetupRepository()
+ {
+ m_hierarchy = new Repository.Hierarchy.Hierarchy();
- m_countingAppender = new CountingAppender();
- m_countingAppender.ActivateOptions();
+ m_countingAppender = new CountingAppender();
+ m_countingAppender.ActivateOptions();
- m_bufferingForwardingAppender = new BufferingForwardingAppender();
- m_bufferingForwardingAppender.AddAppender(m_countingAppender);
+ m_bufferingForwardingAppender = new BufferingForwardingAppender();
+ m_bufferingForwardingAppender.AddAppender(m_countingAppender);
- m_bufferingForwardingAppender.BufferSize = 0;
- m_bufferingForwardingAppender.ClearFilters();
- m_bufferingForwardingAppender.Evaluator = null;
- m_bufferingForwardingAppender.Fix = FixFlags.Partial;
- m_bufferingForwardingAppender.Lossy = false;
- m_bufferingForwardingAppender.LossyEvaluator = null;
- m_bufferingForwardingAppender.Threshold = Level.All;
+ m_bufferingForwardingAppender.BufferSize = 0;
+ m_bufferingForwardingAppender.ClearFilters();
+ m_bufferingForwardingAppender.Evaluator = null;
+ m_bufferingForwardingAppender.Fix = FixFlags.Partial;
+ m_bufferingForwardingAppender.Lossy = false;
+ m_bufferingForwardingAppender.LossyEvaluator = null;
+ m_bufferingForwardingAppender.Threshold = Level.All;
- m_bufferingForwardingAppender.ActivateOptions();
+ m_bufferingForwardingAppender.ActivateOptions();
- BasicConfigurator.Configure(m_hierarchy, m_bufferingForwardingAppender);
- }
+ BasicConfigurator.Configure(m_hierarchy, m_bufferingForwardingAppender);
+ }
- /// <summary>
- /// </summary>
- [Test]
- public void TestSetupAppender()
- {
- SetupRepository();
+ /// <summary>
+ /// </summary>
+ [Test]
+ public void TestSetupAppender()
+ {
+ SetupRepository();
- Assert.AreEqual(0, m_countingAppender.Counter, "Test empty appender");
+ Assert.AreEqual(0, m_countingAppender.Counter, "Test empty appender");
- ILogger logger = m_hierarchy.GetLogger("test");
- logger.Log(typeof(BufferingAppenderTest), Level.Warn, "Message logged", null);
+ ILogger logger = m_hierarchy.GetLogger("test");
+ logger.Log(typeof(BufferingAppenderTest), Level.Warn, "Message logged", null);
- Assert.AreEqual(1, m_countingAppender.Counter, "Test 1 event logged");
- }
+ Assert.AreEqual(1, m_countingAppender.Counter, "Test 1 event logged");
+ }
- /// <summary>
- /// </summary>
- [Test]
- public void TestBufferSize5()
- {
- SetupRepository();
+ /// <summary>
+ /// </summary>
+ [Test]
+ public void TestBufferSize5()
+ {
+ SetupRepository();
- m_bufferingForwardingAppender.BufferSize = 5;
- m_bufferingForwardingAppender.ActivateOptions();
+ m_bufferingForwardingAppender.BufferSize = 5;
+ m_bufferingForwardingAppender.ActivateOptions();
- Assert.AreEqual(m_countingAppender.Counter, 0);
+ Assert.AreEqual(m_countingAppender.Counter, 0);
- ILogger logger = m_hierarchy.GetLogger("test");
+ ILogger logger = m_hierarchy.GetLogger("test");
- logger.Log(typeof(BufferingAppenderTest), Level.Warn, "Message 1", null);
- Assert.AreEqual(0, m_countingAppender.Counter, "Test 1 event in buffer");
- logger.Log(typeof(BufferingAppenderTest), Level.Warn, "Message 2", null);
- Assert.AreEqual(0, m_countingAppender.Counter, "Test 2 event in buffer");
- logger.Log(typeof(BufferingAppenderTest), Level.Warn, "Message 3", null);
- Assert.AreEqual(0, m_countingAppender.Counter, "Test 3 event in buffer");
- logger.Log(typeof(BufferingAppenderTest), Level.Warn, "Message 4", null);
- Assert.AreEqual(0, m_countingAppender.Counter, "Test 4 event in buffer");
- logger.Log(typeof(BufferingAppenderTest), Level.Warn, "Message 5", null);
- Assert.AreEqual(0, m_countingAppender.Counter, "Test 5 event in buffer");
- logger.Log(typeof(BufferingAppenderTest), Level.Warn, "Message 6", null);
- Assert.AreEqual(6, m_countingAppender.Counter, "Test 0 event in buffer. 6 event sent");
- logger.Log(typeof(BufferingAppenderTest), Level.Warn, "Message 7", null);
- Assert.AreEqual(6, m_countingAppender.Counter, "Test 1 event in buffer. 6 event sent");
- logger.Log(typeof(BufferingAppenderTest), Level.Warn, "Message 8", null);
- Assert.AreEqual(6, m_countingAppender.Counter, "Test 2 event in buffer. 6 event sent");
- }
- }
+ logger.Log(typeof(BufferingAppenderTest), Level.Warn, "Message 1", null);
+ Assert.AreEqual(0, m_countingAppender.Counter, "Test 1 event in buffer");
+ logger.Log(typeof(BufferingAppenderTest), Level.Warn, "Message 2", null);
+ Assert.AreEqual(0, m_countingAppender.Counter, "Test 2 event in buffer");
+ logger.Log(typeof(BufferingAppenderTest), Level.Warn, "Message 3", null);
+ Assert.AreEqual(0, m_countingAppender.Counter, "Test 3 event in buffer");
+ logger.Log(typeof(BufferingAppenderTest), Level.Warn, "Message 4", null);
+ Assert.AreEqual(0, m_countingAppender.Counter, "Test 4 event in buffer");
+ logger.Log(typeof(BufferingAppenderTest), Level.Warn, "Message 5", null);
+ Assert.AreEqual(0, m_countingAppender.Counter, "Test 5 event in buffer");
+ logger.Log(typeof(BufferingAppenderTest), Level.Warn, "Message 6", null);
+ Assert.AreEqual(6, m_countingAppender.Counter, "Test 0 event in buffer. 6 event sent");
+ logger.Log(typeof(BufferingAppenderTest), Level.Warn, "Message 7", null);
+ Assert.AreEqual(6, m_countingAppender.Counter, "Test 1 event in buffer. 6 event sent");
+ logger.Log(typeof(BufferingAppenderTest), Level.Warn, "Message 8", null);
+ Assert.AreEqual(6, m_countingAppender.Counter, "Test 2 event in buffer. 6 event sent");
+ }
+ }
}
\ No newline at end of file
diff --git a/src/log4net.Tests/Appender/CountingAppender.cs b/src/log4net.Tests/Appender/CountingAppender.cs
index 0e0aa15..e39754a 100644
--- a/src/log4net.Tests/Appender/CountingAppender.cs
+++ b/src/log4net.Tests/Appender/CountingAppender.cs
@@ -22,64 +22,64 @@
namespace log4net.Tests.Appender
{
- /// <summary>
- /// Implements an Appender for test purposes that counts the
- /// number of output calls to <see cref="Append" />.
- /// </summary>
- /// <remarks>
- /// This appender is used in the unit tests.
- /// </remarks>
- /// <author>Nicko Cadell</author>
- /// <author>Gert Driesen</author>
- public class CountingAppender : AppenderSkeleton
- {
- #region Public Instance Constructors
- /// <summary>
- /// Initializes a new instance of the <see cref="CountingAppender" /> class.
- /// </summary>
- public CountingAppender()
- {
- m_counter = 0;
- }
- #endregion Public Instance Constructors
+ /// <summary>
+ /// Implements an Appender for test purposes that counts the
+ /// number of output calls to <see cref="Append" />.
+ /// </summary>
+ /// <remarks>
+ /// This appender is used in the unit tests.
+ /// </remarks>
+ /// <author>Nicko Cadell</author>
+ /// <author>Gert Driesen</author>
+ public class CountingAppender : AppenderSkeleton
+ {
+ #region Public Instance Constructors
+ /// <summary>
+ /// Initializes a new instance of the <see cref="CountingAppender" /> class.
+ /// </summary>
+ public CountingAppender()
+ {
+ m_counter = 0;
+ }
+ #endregion Public Instance Constructors
- #region Public Instance Properties
- /// <summary>
- /// Returns the number of times <see cref="Append" /> has been called.
- /// </summary>
- /// <value>
- /// The number of times <see cref="Append" /> has been called.
- /// </value>
- public int Counter
- {
- get { return m_counter; }
- }
- #endregion Public Instance Properties
+ #region Public Instance Properties
+ /// <summary>
+ /// Returns the number of times <see cref="Append" /> has been called.
+ /// </summary>
+ /// <value>
+ /// The number of times <see cref="Append" /> has been called.
+ /// </value>
+ public int Counter
+ {
+ get { return m_counter; }
+ }
+ #endregion Public Instance Properties
- /// <summary>
- /// Reset the counter to zero
- /// </summary>
- public void ResetCounter()
- {
- m_counter = 0;
- }
+ /// <summary>
+ /// Reset the counter to zero
+ /// </summary>
+ public void ResetCounter()
+ {
+ m_counter = 0;
+ }
- #region Override implementation of AppenderSkeleton
- /// <summary>
- /// Registers how many times the method has been called.
- /// </summary>
- /// <param name="logEvent">The logging event.</param>
- protected override void Append(LoggingEvent logEvent)
- {
- m_counter++;
- }
- #endregion Override implementation of AppenderSkeleton
+ #region Override implementation of AppenderSkeleton
+ /// <summary>
+ /// Registers how many times the method has been called.
+ /// </summary>
+ /// <param name="logEvent">The logging event.</param>
+ protected override void Append(LoggingEvent logEvent)
+ {
+ m_counter++;
+ }
+ #endregion Override implementation of AppenderSkeleton
- #region Private Instance Fields
- /// <summary>
- /// The number of times <see cref="Append" /> has been called.
- /// </summary>
- private int m_counter;
- #endregion Private Instance Fields
- }
+ #region Private Instance Fields
+ /// <summary>
+ /// The number of times <see cref="Append" /> has been called.
+ /// </summary>
+ private int m_counter;
+ #endregion Private Instance Fields
+ }
}
\ No newline at end of file
diff --git a/src/log4net.Tests/Appender/EventLogAppenderTest.cs b/src/log4net.Tests/Appender/EventLogAppenderTest.cs
index e055f2f..7e2a5cc 100644
--- a/src/log4net.Tests/Appender/EventLogAppenderTest.cs
+++ b/src/log4net.Tests/Appender/EventLogAppenderTest.cs
@@ -29,60 +29,60 @@
namespace log4net.Tests.Appender
{
- /// <summary>
- /// Used for internal unit testing the <see cref="EventLogAppender"/> class.
- /// </summary>
- /// <remarks>
- /// Used for internal unit testing the <see cref="EventLogAppender"/> class.
- /// </remarks>
- [TestFixture]
- public class EventLogAppenderTest
- {
- /// <summary>
- /// Verifies that for each event log level, the correct system
- /// event log enumeration is returned
- /// </summary>
- [Test]
- public void TestGetEntryTypeForExistingApplicationName()
- {
- EventLogAppender eventAppender = new EventLogAppender();
+ /// <summary>
+ /// Used for internal unit testing the <see cref="EventLogAppender"/> class.
+ /// </summary>
+ /// <remarks>
+ /// Used for internal unit testing the <see cref="EventLogAppender"/> class.
+ /// </remarks>
+ [TestFixture]
+ public class EventLogAppenderTest
+ {
+ /// <summary>
+ /// Verifies that for each event log level, the correct system
+ /// event log enumeration is returned
+ /// </summary>
+ [Test]
+ public void TestGetEntryTypeForExistingApplicationName()
+ {
+ EventLogAppender eventAppender = new EventLogAppender();
eventAppender.ApplicationName = "Winlogon";
- eventAppender.ActivateOptions();
+ eventAppender.ActivateOptions();
- Assert.AreEqual(
- EventLogEntryType.Information,
- GetEntryType(eventAppender, Level.All));
+ Assert.AreEqual(
+ EventLogEntryType.Information,
+ GetEntryType(eventAppender, Level.All));
- Assert.AreEqual(
- EventLogEntryType.Information,
- GetEntryType(eventAppender, Level.Debug));
+ Assert.AreEqual(
+ EventLogEntryType.Information,
+ GetEntryType(eventAppender, Level.Debug));
- Assert.AreEqual(
- EventLogEntryType.Information,
- GetEntryType(eventAppender, Level.Info));
+ Assert.AreEqual(
+ EventLogEntryType.Information,
+ GetEntryType(eventAppender, Level.Info));
- Assert.AreEqual(
- EventLogEntryType.Warning,
- GetEntryType(eventAppender, Level.Warn));
+ Assert.AreEqual(
+ EventLogEntryType.Warning,
+ GetEntryType(eventAppender, Level.Warn));
- Assert.AreEqual(
- EventLogEntryType.Error,
- GetEntryType(eventAppender, Level.Error));
+ Assert.AreEqual(
+ EventLogEntryType.Error,
+ GetEntryType(eventAppender, Level.Error));
- Assert.AreEqual(
- EventLogEntryType.Error,
- GetEntryType(eventAppender, Level.Fatal));
+ Assert.AreEqual(
+ EventLogEntryType.Error,
+ GetEntryType(eventAppender, Level.Fatal));
- Assert.AreEqual(
- EventLogEntryType.Error,
- GetEntryType(eventAppender, Level.Off));
- }
+ Assert.AreEqual(
+ EventLogEntryType.Error,
+ GetEntryType(eventAppender, Level.Off));
+ }
/// <summary>
/// ActivateOption tries to create an event source if it doesn't exist but this is going to fail on more modern Windows versions unless the code is run with local administrator privileges.
/// </summary>
[Test]
- [Ignore("seems to require administrator privileges or a specific environent when run")]
+ [Ignore("seems to require administrator privileges or a specific environent when run")]
public void ActivateOptionsDisablesAppenderIfSourceDoesntExist()
{
EventLogAppender eventAppender = new EventLogAppender();
@@ -90,16 +90,16 @@
Assert.AreEqual(Level.Off, eventAppender.Threshold);
}
- //
- // Helper functions to dig into the appender
- //
+ //
+ // Helper functions to dig into the appender
+ //
- private static EventLogEntryType GetEntryType(EventLogAppender appender, Level level)
- {
- return (EventLogEntryType)Utils.InvokeMethod(appender, "GetEntryType", level);
- }
+ private static EventLogEntryType GetEntryType(EventLogAppender appender, Level level)
+ {
+ return (EventLogEntryType)Utils.InvokeMethod(appender, "GetEntryType", level);
+ }
- }
+ }
}
#endif // NET_2_0
diff --git a/src/log4net.Tests/Appender/MemoryAppenderTest.cs b/src/log4net.Tests/Appender/MemoryAppenderTest.cs
index 9b4e7a0..ceb3bb0 100644
--- a/src/log4net.Tests/Appender/MemoryAppenderTest.cs
+++ b/src/log4net.Tests/Appender/MemoryAppenderTest.cs
@@ -70,21 +70,21 @@
{
thread.Join();
}
- cEventsRead += memoryAppender.PopAllEvents().Length;
+ cEventsRead += memoryAppender.PopAllEvents().Length;
Assert.AreEqual(cEventsExpected, cEventsRead, "Log events were lost.");
}
private static ThreadStart LogMessages(string repository)
{
- return () => {
- var logger = LogManager.GetLogger(repository, "LoggerThread");
- for (var i = 0; i < cLogEntriesPerThread; i++)
- {
- logger.InfoFormat("Logging message {0}", i);
- }
- Interlocked.Decrement(ref cThreadsRunning);
- };
- }
+ return () => {
+ var logger = LogManager.GetLogger(repository, "LoggerThread");
+ for (var i = 0; i < cLogEntriesPerThread; i++)
+ {
+ logger.InfoFormat("Logging message {0}", i);
+ }
+ Interlocked.Decrement(ref cThreadsRunning);
+ };
+ }
}
}
#endif
\ No newline at end of file
diff --git a/src/log4net.Tests/Appender/RemotingAppenderTest.cs b/src/log4net.Tests/Appender/RemotingAppenderTest.cs
index a4de297..56cc1c3 100644
--- a/src/log4net.Tests/Appender/RemotingAppenderTest.cs
+++ b/src/log4net.Tests/Appender/RemotingAppenderTest.cs
@@ -38,250 +38,250 @@
namespace log4net.Tests.Appender
{
- /// <summary>
- /// Used for internal unit testing the <see cref="RemotingAppender"/> class.
- /// </summary>
- /// <remarks>
- /// Used for internal unit testing the <see cref="RemotingAppender"/> class.
- /// </remarks>
- [TestFixture]
- public class RemotingAppenderTest
- {
- private IChannel m_remotingChannel = null;
+ /// <summary>
+ /// Used for internal unit testing the <see cref="RemotingAppender"/> class.
+ /// </summary>
+ /// <remarks>
+ /// Used for internal unit testing the <see cref="RemotingAppender"/> class.
+ /// </remarks>
+ [TestFixture]
+ public class RemotingAppenderTest
+ {
+ private IChannel m_remotingChannel = null;
- /// <summary>
- /// Test that the Message property is correctly remoted
- /// </summary>
- [Test]
- public void TestRemotedMessage()
- {
- // Setup the remoting appender
- ConfigureRootAppender(FixFlags.Partial);
+ /// <summary>
+ /// Test that the Message property is correctly remoted
+ /// </summary>
+ [Test]
+ public void TestRemotedMessage()
+ {
+ // Setup the remoting appender
+ ConfigureRootAppender(FixFlags.Partial);
- RemoteLoggingSinkImpl.Instance.Reset();
+ RemoteLoggingSinkImpl.Instance.Reset();
- Logger root;
- root = ((Repository.Hierarchy.Hierarchy)LogManager.GetRepository()).Root;
+ Logger root;
+ root = ((Repository.Hierarchy.Hierarchy)LogManager.GetRepository()).Root;
- string testMessage = string.Format("test message [ {0} ]", (new Random()).Next());
+ string testMessage = string.Format("test message [ {0} ]", (new Random()).Next());
- // Log a message that will be remoted
- root.Log(Level.Debug, testMessage, null);
+ // Log a message that will be remoted
+ root.Log(Level.Debug, testMessage, null);
- // Wait for the remoted object to be delivered
- Thread.Sleep(2000);
+ // Wait for the remoted object to be delivered
+ Thread.Sleep(2000);
- LoggingEvent[] events = RemoteLoggingSinkImpl.Instance.Events;
- Assert.AreEqual(1, events.Length, "Expect to receive 1 remoted event");
+ LoggingEvent[] events = RemoteLoggingSinkImpl.Instance.Events;
+ Assert.AreEqual(1, events.Length, "Expect to receive 1 remoted event");
- Assert.AreEqual(testMessage, events[0].RenderedMessage, "Expect Message match after remoting event");
- }
+ Assert.AreEqual(testMessage, events[0].RenderedMessage, "Expect Message match after remoting event");
+ }
- /// <summary>
- /// Test that the LocationInfo property is not remoted when doing a Fix.Partial
- /// </summary>
- [Test]
- public void TestPartialFix()
- {
- // Setup the remoting appender
- ConfigureRootAppender(FixFlags.Partial);
+ /// <summary>
+ /// Test that the LocationInfo property is not remoted when doing a Fix.Partial
+ /// </summary>
+ [Test]
+ public void TestPartialFix()
+ {
+ // Setup the remoting appender
+ ConfigureRootAppender(FixFlags.Partial);
- RemoteLoggingSinkImpl.Instance.Reset();
+ RemoteLoggingSinkImpl.Instance.Reset();
- Logger root;
- root = ((Repository.Hierarchy.Hierarchy)LogManager.GetRepository()).Root;
+ Logger root;
+ root = ((Repository.Hierarchy.Hierarchy)LogManager.GetRepository()).Root;
- // Log a message that will be remoted
- root.Log(Level.Debug, "test message", null);
+ // Log a message that will be remoted
+ root.Log(Level.Debug, "test message", null);
- // Wait for the remoted object to be delivered
- Thread.Sleep(2000);
+ // Wait for the remoted object to be delivered
+ Thread.Sleep(2000);
- LoggingEvent[] events = RemoteLoggingSinkImpl.Instance.Events;
- Assert.AreEqual(1, events.Length, "Expect to receive 1 remoted event");
+ LoggingEvent[] events = RemoteLoggingSinkImpl.Instance.Events;
+ Assert.AreEqual(1, events.Length, "Expect to receive 1 remoted event");
- // Grab the event data
- LoggingEventData eventData = GetLoggingEventData(events[0]);
+ // Grab the event data
+ LoggingEventData eventData = GetLoggingEventData(events[0]);
- Assert.IsNull(eventData.LocationInfo, "Expect LocationInfo to be null because only doing a partial fix");
- }
+ Assert.IsNull(eventData.LocationInfo, "Expect LocationInfo to be null because only doing a partial fix");
+ }
- /// <summary>
- /// Test that the LocationInfo property is remoted when doing a Fix.All
- /// </summary>
- [Test]
- public void TestFullFix()
- {
- // Setup the remoting appender
- ConfigureRootAppender(FixFlags.All);
+ /// <summary>
+ /// Test that the LocationInfo property is remoted when doing a Fix.All
+ /// </summary>
+ [Test]
+ public void TestFullFix()
+ {
+ // Setup the remoting appender
+ ConfigureRootAppender(FixFlags.All);
- RemoteLoggingSinkImpl.Instance.Reset();
+ RemoteLoggingSinkImpl.Instance.Reset();
- Logger root;
- root = ((Repository.Hierarchy.Hierarchy)LogManager.GetRepository()).Root;
+ Logger root;
+ root = ((Repository.Hierarchy.Hierarchy)LogManager.GetRepository()).Root;
- // Log a message that will be remoted
- root.Log(Level.Debug, "test message", null);
+ // Log a message that will be remoted
+ root.Log(Level.Debug, "test message", null);
- // Wait for the remoted object to be delivered
- Thread.Sleep(5000);
+ // Wait for the remoted object to be delivered
+ Thread.Sleep(5000);
- WaitFor("Remote instance should have received a remoting event", () => RemoteLoggingSinkImpl.Instance.Events.Length > 0);
- LoggingEvent[] events = RemoteLoggingSinkImpl.Instance.Events;
- Assert.AreEqual(1, events.Length, "Expect to receive 1 remoted event");
+ WaitFor("Remote instance should have received a remoting event", () => RemoteLoggingSinkImpl.Instance.Events.Length > 0);
+ LoggingEvent[] events = RemoteLoggingSinkImpl.Instance.Events;
+ Assert.AreEqual(1, events.Length, "Expect to receive 1 remoted event");
- // Grab the event data
- LoggingEventData eventData = GetLoggingEventData(events[0]);
+ // Grab the event data
+ LoggingEventData eventData = GetLoggingEventData(events[0]);
- Assert.IsNotNull(eventData.LocationInfo, "Expect LocationInfo to not be null because doing a full fix");
- }
+ Assert.IsNotNull(eventData.LocationInfo, "Expect LocationInfo to not be null because doing a full fix");
+ }
- private void WaitFor(
- string failMessage,
- Func<bool> condition,
- int maxWaitMilliseconds = 5000)
- {
- var start = DateTime.Now;
- do
- {
- if (condition())
- {
- return;
- }
- Thread.Sleep(100);
- } while ((DateTime.Now - start).TotalMilliseconds < maxWaitMilliseconds);
- throw new TimeoutException($"Condition not achieved within {maxWaitMilliseconds}ms: {failMessage}");
- }
+ private void WaitFor(
+ string failMessage,
+ Func<bool> condition,
+ int maxWaitMilliseconds = 5000)
+ {
+ var start = DateTime.Now;
+ do
+ {
+ if (condition())
+ {
+ return;
+ }
+ Thread.Sleep(100);
+ } while ((DateTime.Now - start).TotalMilliseconds < maxWaitMilliseconds);
+ throw new TimeoutException($"Condition not achieved within {maxWaitMilliseconds}ms: {failMessage}");
+ }
- /// <summary>
- /// Test that the Message property is correctly remoted
- /// </summary>
- [Test]
- public void TestRemotedMessageNdcPushPop()
- {
- // Setup the remoting appender
- ConfigureRootAppender(FixFlags.Partial);
+ /// <summary>
+ /// Test that the Message property is correctly remoted
+ /// </summary>
+ [Test]
+ public void TestRemotedMessageNdcPushPop()
+ {
+ // Setup the remoting appender
+ ConfigureRootAppender(FixFlags.Partial);
- RemoteLoggingSinkImpl.Instance.Reset();
+ RemoteLoggingSinkImpl.Instance.Reset();
- Logger root;
- root = ((Repository.Hierarchy.Hierarchy)LogManager.GetRepository()).Root;
+ Logger root;
+ root = ((Repository.Hierarchy.Hierarchy)LogManager.GetRepository()).Root;
- string testMessage = string.Format("test message [ {0} ]", (new Random()).Next());
+ string testMessage = string.Format("test message [ {0} ]", (new Random()).Next());
- using(NDC.Push("value"))
- {
- }
+ using(NDC.Push("value"))
+ {
+ }
- // Log a message that will be remoted
- root.Log(Level.Debug, testMessage, null);
+ // Log a message that will be remoted
+ root.Log(Level.Debug, testMessage, null);
- // Wait for the remoted object to be delivered
- Thread.Sleep(2000);
+ // Wait for the remoted object to be delivered
+ Thread.Sleep(2000);
- LoggingEvent[] events = RemoteLoggingSinkImpl.Instance.Events;
- Assert.AreEqual(1, events.Length, "Expect to receive 1 remoted event");
+ LoggingEvent[] events = RemoteLoggingSinkImpl.Instance.Events;
+ Assert.AreEqual(1, events.Length, "Expect to receive 1 remoted event");
- Assert.AreEqual(testMessage, events[0].RenderedMessage, "Expect Message match after remoting event");
- }
+ Assert.AreEqual(testMessage, events[0].RenderedMessage, "Expect Message match after remoting event");
+ }
- [Test]
- public void TestNestedNdc()
- {
- // This test can suffer from timing and ordering issues as the RemotingAppender does dispatch events asynchronously
+ [Test]
+ public void TestNestedNdc()
+ {
+ // This test can suffer from timing and ordering issues as the RemotingAppender does dispatch events asynchronously
- // Setup the remoting appender
- ConfigureRootAppender(FixFlags.Partial);
+ // Setup the remoting appender
+ ConfigureRootAppender(FixFlags.Partial);
- RemoteLoggingSinkImpl.Instance.Reset();
+ RemoteLoggingSinkImpl.Instance.Reset();
- TestService t;
- t = new TestService();
- t.Test();
+ TestService t;
+ t = new TestService();
+ t.Test();
- // Wait for the remoted objects to be delivered
- Thread.Sleep(3000);
+ // Wait for the remoted objects to be delivered
+ Thread.Sleep(3000);
- LoggingEvent[] events = RemoteLoggingSinkImpl.Instance.Events;
- Assert.AreEqual(5, events.Length, "Expect to receive 5 remoted event");
+ LoggingEvent[] events = RemoteLoggingSinkImpl.Instance.Events;
+ Assert.AreEqual(5, events.Length, "Expect to receive 5 remoted event");
- Assert.AreEqual("begin test", events[0].RenderedMessage, "Verify event 1 RenderedMessage");
- Assert.AreEqual("feature", events[1].RenderedMessage, "Verify event 2 RenderedMessage");
- Assert.AreEqual("return", events[2].RenderedMessage, "Verify event 3 RenderedMessage");
- Assert.AreEqual("return", events[3].RenderedMessage, "Verify event 4 RenderedMessage");
- Assert.AreEqual("end test", events[4].RenderedMessage, "Verify event 5 RenderedMessage");
+ Assert.AreEqual("begin test", events[0].RenderedMessage, "Verify event 1 RenderedMessage");
+ Assert.AreEqual("feature", events[1].RenderedMessage, "Verify event 2 RenderedMessage");
+ Assert.AreEqual("return", events[2].RenderedMessage, "Verify event 3 RenderedMessage");
+ Assert.AreEqual("return", events[3].RenderedMessage, "Verify event 4 RenderedMessage");
+ Assert.AreEqual("end test", events[4].RenderedMessage, "Verify event 5 RenderedMessage");
- Assert.IsNull(events[0].Properties["NDC"], "Verify event 1 Properties");
- Assert.AreEqual("test1", events[1].Properties["NDC"], "Verify event 2 Properties");
- Assert.AreEqual("test1 test2", events[2].Properties["NDC"], "Verify event 3 Properties");
- Assert.AreEqual("test1", events[3].Properties["NDC"], "Verify event 4 Properties");
- Assert.IsNull(events[4].Properties["NDC"], "Verify event 5 Properties");
- }
+ Assert.IsNull(events[0].Properties["NDC"], "Verify event 1 Properties");
+ Assert.AreEqual("test1", events[1].Properties["NDC"], "Verify event 2 Properties");
+ Assert.AreEqual("test1 test2", events[2].Properties["NDC"], "Verify event 3 Properties");
+ Assert.AreEqual("test1", events[3].Properties["NDC"], "Verify event 4 Properties");
+ Assert.IsNull(events[4].Properties["NDC"], "Verify event 5 Properties");
+ }
- private void RegisterRemotingServerChannel()
- {
- if (m_remotingChannel == null)
- {
- BinaryClientFormatterSinkProvider clientSinkProvider = new BinaryClientFormatterSinkProvider();
+ private void RegisterRemotingServerChannel()
+ {
+ if (m_remotingChannel == null)
+ {
+ BinaryClientFormatterSinkProvider clientSinkProvider = new BinaryClientFormatterSinkProvider();
- BinaryServerFormatterSinkProvider serverSinkProvider = new BinaryServerFormatterSinkProvider();
- serverSinkProvider.TypeFilterLevel = System.Runtime.Serialization.Formatters.TypeFilterLevel.Full;
+ BinaryServerFormatterSinkProvider serverSinkProvider = new BinaryServerFormatterSinkProvider();
+ serverSinkProvider.TypeFilterLevel = System.Runtime.Serialization.Formatters.TypeFilterLevel.Full;
- Hashtable channelProperties = new Hashtable();
- channelProperties["port"] = 8085;
+ Hashtable channelProperties = new Hashtable();
+ channelProperties["port"] = 8085;
- m_remotingChannel = new TcpChannel(channelProperties, clientSinkProvider, serverSinkProvider);
- // Setup remoting server
- try
- {
+ m_remotingChannel = new TcpChannel(channelProperties, clientSinkProvider, serverSinkProvider);
+ // Setup remoting server
+ try
+ {
#if NET_2_0 || MONO_2_0 || MONO_3_5 || MONO_4_0
- ChannelServices.RegisterChannel(m_remotingChannel, false);
+ ChannelServices.RegisterChannel(m_remotingChannel, false);
#else
- ChannelServices.RegisterChannel(m_remotingChannel);
+ ChannelServices.RegisterChannel(m_remotingChannel);
#endif
- }
- catch(Exception ex)
- {
- Assert.Fail("Failed to set up LoggingSink: {0}", ex);
- }
+ }
+ catch(Exception ex)
+ {
+ Assert.Fail("Failed to set up LoggingSink: {0}", ex);
+ }
- // Marshal the sink object
- RemotingServices.Marshal(RemoteLoggingSinkImpl.Instance, "LoggingSink", typeof(RemotingAppender.IRemoteLoggingSink));
- }
- }
+ // Marshal the sink object
+ RemotingServices.Marshal(RemoteLoggingSinkImpl.Instance, "LoggingSink", typeof(RemotingAppender.IRemoteLoggingSink));
+ }
+ }
/// <summary>
- /// Shuts down any loggers in the hierarchy, along
- /// with all appenders.
- /// </summary>
- private static void ResetRepository()
- {
- // Regular users should not use the clear method lightly!
- LogManager.GetRepository().ResetConfiguration();
- LogManager.GetRepository().Shutdown();
- ((Repository.Hierarchy.Hierarchy)LogManager.GetRepository()).Clear();
- }
+ /// Shuts down any loggers in the hierarchy, along
+ /// with all appenders.
+ /// </summary>
+ private static void ResetRepository()
+ {
+ // Regular users should not use the clear method lightly!
+ LogManager.GetRepository().ResetConfiguration();
+ LogManager.GetRepository().Shutdown();
+ ((Repository.Hierarchy.Hierarchy)LogManager.GetRepository()).Clear();
+ }
- /// <summary>
- /// Any initialization that happens before each test can
- /// go here
- /// </summary>
- [SetUp]
- public void SetUp()
- {
- ResetRepository();
- RegisterRemotingServerChannel();
- }
+ /// <summary>
+ /// Any initialization that happens before each test can
+ /// go here
+ /// </summary>
+ [SetUp]
+ public void SetUp()
+ {
+ ResetRepository();
+ RegisterRemotingServerChannel();
+ }
- /// <summary>
- /// Any steps that happen after each test go here
- /// </summary>
- [TearDown]
- public void TearDown()
- {
- ResetRepository();
- }
+ /// <summary>
+ /// Any steps that happen after each test go here
+ /// </summary>
+ [TearDown]
+ public void TearDown()
+ {
+ ResetRepository();
+ }
/// <summary>
/// Close down remoting infrastructure
@@ -299,158 +299,158 @@
}
}
- /// <summary>
- /// Configures the root appender for counting and rolling
- /// </summary>
- private static void ConfigureRootAppender(FixFlags fixFlags)
- {
- Logger root;
- root = ((Repository.Hierarchy.Hierarchy)LogManager.GetRepository()).Root;
- root.Level = Level.Debug;
- root.AddAppender(CreateAppender(fixFlags));
- root.Repository.Configured = true;
- }
+ /// <summary>
+ /// Configures the root appender for counting and rolling
+ /// </summary>
+ private static void ConfigureRootAppender(FixFlags fixFlags)
+ {
+ Logger root;
+ root = ((Repository.Hierarchy.Hierarchy)LogManager.GetRepository()).Root;
+ root.Level = Level.Debug;
+ root.AddAppender(CreateAppender(fixFlags));
+ root.Repository.Configured = true;
+ }
- private static RemotingAppender CreateAppender(FixFlags fixFlags)
- {
- RemotingAppender appender = new RemotingAppender();
- appender.Sink = "tcp://localhost:8085/LoggingSink";
- appender.Lossy = false;
- appender.BufferSize = 1;
- appender.Fix = fixFlags;
+ private static RemotingAppender CreateAppender(FixFlags fixFlags)
+ {
+ RemotingAppender appender = new RemotingAppender();
+ appender.Sink = "tcp://localhost:8085/LoggingSink";
+ appender.Lossy = false;
+ appender.BufferSize = 1;
+ appender.Fix = fixFlags;
- appender.ActivateOptions();
+ appender.ActivateOptions();
- return appender;
- }
+ return appender;
+ }
- public class RemoteLoggingSinkImpl : MarshalByRefObject, RemotingAppender.IRemoteLoggingSink
- {
- public static readonly RemoteLoggingSinkImpl Instance = new RemoteLoggingSinkImpl();
+ public class RemoteLoggingSinkImpl : MarshalByRefObject, RemotingAppender.IRemoteLoggingSink
+ {
+ public static readonly RemoteLoggingSinkImpl Instance = new RemoteLoggingSinkImpl();
- private ArrayList m_events = new ArrayList();
+ private ArrayList m_events = new ArrayList();
- #region Public Instance Constructors
- private RemoteLoggingSinkImpl()
- {
- }
- #endregion Public Instance Constructors
+ #region Public Instance Constructors
+ private RemoteLoggingSinkImpl()
+ {
+ }
+ #endregion Public Instance Constructors
- #region Implementation of IRemoteLoggingSink
- /// <summary>
- /// Logs the events to to an internal buffer
- /// </summary>
- /// <param name="events">The events to log.</param>
- /// <remarks>
- /// Logs the events to to an internal buffer. The logged events can
- /// be retrieved via the <see cref="Events"/> property. To clear
- /// the buffer call the <see cref="Reset"/> method.
- /// </remarks>
- public void LogEvents(LoggingEvent[] events)
- {
- m_events.AddRange(events);
- }
- #endregion Implementation of IRemoteLoggingSink
+ #region Implementation of IRemoteLoggingSink
+ /// <summary>
+ /// Logs the events to to an internal buffer
+ /// </summary>
+ /// <param name="events">The events to log.</param>
+ /// <remarks>
+ /// Logs the events to to an internal buffer. The logged events can
+ /// be retrieved via the <see cref="Events"/> property. To clear
+ /// the buffer call the <see cref="Reset"/> method.
+ /// </remarks>
+ public void LogEvents(LoggingEvent[] events)
+ {
+ m_events.AddRange(events);
+ }
+ #endregion Implementation of IRemoteLoggingSink
- #region Override implementation of MarshalByRefObject
- /// <summary>
- /// Obtains a lifetime service object to control the lifetime
- /// policy for this instance.
- /// </summary>
- /// <returns>
- /// <c>null</c> to indicate that this instance should live
- /// forever.
- /// </returns>
- public override object InitializeLifetimeService()
- {
- return null;
- }
- #endregion Override implementation of MarshalByRefObject
+ #region Override implementation of MarshalByRefObject
+ /// <summary>
+ /// Obtains a lifetime service object to control the lifetime
+ /// policy for this instance.
+ /// </summary>
+ /// <returns>
+ /// <c>null</c> to indicate that this instance should live
+ /// forever.
+ /// </returns>
+ public override object InitializeLifetimeService()
+ {
+ return null;
+ }
+ #endregion Override implementation of MarshalByRefObject
- public void Reset()
- {
- m_events.Clear();
- }
+ public void Reset()
+ {
+ m_events.Clear();
+ }
- public LoggingEvent[] Events
- {
- get { return (LoggingEvent[])m_events.ToArray(typeof(LoggingEvent)); }
- }
- }
+ public LoggingEvent[] Events
+ {
+ get { return (LoggingEvent[])m_events.ToArray(typeof(LoggingEvent)); }
+ }
+ }
- //
- // Helper functions to dig into the appender
- //
+ //
+ // Helper functions to dig into the appender
+ //
- private static LoggingEventData GetLoggingEventData(LoggingEvent loggingEvent)
- {
- return (LoggingEventData)Utils.GetField(loggingEvent, "m_data");
- }
- }
+ private static LoggingEventData GetLoggingEventData(LoggingEvent loggingEvent)
+ {
+ return (LoggingEventData)Utils.GetField(loggingEvent, "m_data");
+ }
+ }
}
// helper for TestNestedNdc
namespace log4net.Tests.Appender.Remoting.UserInterfaces
{
- public class TestService
- {
- private static ILog log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+ public class TestService
+ {
+ private static ILog log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
- public void Test()
- {
- log.Info("begin test");
- Thread.Sleep(100);
+ public void Test()
+ {
+ log.Info("begin test");
+ Thread.Sleep(100);
- Feature f = new Feature();
- f.Test();
- log.Info("end test");
- Thread.Sleep(100);
- }
- }
+ Feature f = new Feature();
+ f.Test();
+ log.Info("end test");
+ Thread.Sleep(100);
+ }
+ }
}
// helper for TestNestedNdc
namespace log4net.Tests.Appender.Remoting
{
- public class Feature
- {
- private static ILog log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+ public class Feature
+ {
+ private static ILog log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
- public void Test()
- {
- using(NDC.Push("test1"))
- {
- log.Info("feature");
- Thread.Sleep(100);
+ public void Test()
+ {
+ using(NDC.Push("test1"))
+ {
+ log.Info("feature");
+ Thread.Sleep(100);
- Dal d = new Dal();
- d.Test();
- log.Info("return");
- Thread.Sleep(100);
- }
- }
- }
+ Dal d = new Dal();
+ d.Test();
+ log.Info("return");
+ Thread.Sleep(100);
+ }
+ }
+ }
}
// helper for TestNestedNdc
namespace log4net.Tests.Appender.Remoting.Data
{
- public class Dal
- {
- private static ILog log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+ public class Dal
+ {
+ private static ILog log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
- public void Test()
- {
- using(NDC.Push("test2"))
- {
- log.Info("return");
- Thread.Sleep(100);
- }
- }
- }
+ public void Test()
+ {
+ using(NDC.Push("test2"))
+ {
+ log.Info("return");
+ Thread.Sleep(100);
+ }
+ }
+ }
}
#endif // NET_2_0
\ No newline at end of file
diff --git a/src/log4net.Tests/Appender/RollingFileAppenderTest.cs b/src/log4net.Tests/Appender/RollingFileAppenderTest.cs
index d6cee4b..883a9c0 100644
--- a/src/log4net.Tests/Appender/RollingFileAppenderTest.cs
+++ b/src/log4net.Tests/Appender/RollingFileAppenderTest.cs
@@ -463,7 +463,7 @@
ArrayList alExisting = GetExistingFiles(sBaseFileName);
if (null != fileEntries)
{
- // AssertEquals( "File count mismatch", alExisting.Count, fileEntries.Length );
+ // AssertEquals( "File count mismatch", alExisting.Count, fileEntries.Length );
foreach (RollFileEntry rollFile in fileEntries)
{
string sFileName = rollFile.FileName;
@@ -552,7 +552,7 @@
// {
// DumpFileEntry( file );
// }
- // // System.Diagnostics.Debug.WriteLine("");
+ // // System.Diagnostics.Debug.WriteLine("");
//}
/// <summary>
@@ -569,15 +569,15 @@
{
RollConditions entry = entries[i];
- // System.Diagnostics.Debug.WriteLine( i + ": Entry " + i + " pre/post conditions");
- // DumpTableEntry( entry );
- // System.Diagnostics.Debug.WriteLine( i + ": Testing entry pre-conditions");
+ // System.Diagnostics.Debug.WriteLine( i + ": Entry " + i + " pre/post conditions");
+ // DumpTableEntry( entry );
+ // System.Diagnostics.Debug.WriteLine( i + ": Testing entry pre-conditions");
VerifyPreConditions(sBaseFileName, entry);
- // System.Diagnostics.Debug.WriteLine( i + ": Logging message");
+ // System.Diagnostics.Debug.WriteLine( i + ": Logging message");
LogMessage(entry, sMessageToLog);
- // System.Diagnostics.Debug.WriteLine( i + ": Testing entry post-conditions");
+ // System.Diagnostics.Debug.WriteLine( i + ": Testing entry post-conditions");
VerifyPostConditions(sBaseFileName, entry);
- // System.Diagnostics.Debug.WriteLine( i + ": Finished validating entry\n");
+ // System.Diagnostics.Debug.WriteLine( i + ": Finished validating entry\n");
}
}
@@ -678,7 +678,7 @@
//{
// if (0 == stats.NumberOfFileRolls )
// {
- // return null; // first round has no previous backups
+ // return null; // first round has no previous backups
// }
// string sGroup;
// if (0 == stats.MessagesThisFile )
@@ -1651,7 +1651,7 @@
catch (IOException e1)
{
#if MONO
- Assert.AreEqual("Sharing violation on path ", e1.Message.Substring(0, 26), "Unexpected exception");
+ Assert.AreEqual("Sharing violation on path ", e1.Message.Substring(0, 26), "Unexpected exception");
#else
Assert.AreEqual("The process cannot access the file ", e1.Message.Substring(0, 35),
"Unexpected exception");
@@ -1977,7 +1977,7 @@
SetFieldCurSizeRollBackups(rfa, 0);
InitializeRollBackups(rfa, sBaseFile, arrFiles);
- // iBackups / Meaning
+ // iBackups / Meaning
// 0 = none
// 1 = file.log
// 2 = file.log.1
diff --git a/src/log4net.Tests/Appender/SmtpPickupDirAppenderTest.cs b/src/log4net.Tests/Appender/SmtpPickupDirAppenderTest.cs
index 6fbb082..6cd5a9e 100644
--- a/src/log4net.Tests/Appender/SmtpPickupDirAppenderTest.cs
+++ b/src/log4net.Tests/Appender/SmtpPickupDirAppenderTest.cs
@@ -31,219 +31,219 @@
namespace log4net.Tests.Appender
{
- /// <summary>
- /// Used for internal unit testing the <see cref="SmtpPickupDirAppender"/> class.
- /// </summary>
- [TestFixture]
- public class SmtpPickupDirAppenderTest
- {
- private readonly string _testPickupDir;
+ /// <summary>
+ /// Used for internal unit testing the <see cref="SmtpPickupDirAppender"/> class.
+ /// </summary>
+ [TestFixture]
+ public class SmtpPickupDirAppenderTest
+ {
+ private readonly string _testPickupDir;
- private class SilentErrorHandler : IErrorHandler
- {
- private StringBuilder m_buffer = new StringBuilder();
+ private class SilentErrorHandler : IErrorHandler
+ {
+ private StringBuilder m_buffer = new StringBuilder();
- public string Message
- {
- get { return m_buffer.ToString(); }
- }
+ public string Message
+ {
+ get { return m_buffer.ToString(); }
+ }
- public void Error(string message)
- {
- m_buffer.Append(message + "\n");
- }
+ public void Error(string message)
+ {
+ m_buffer.Append(message + "\n");
+ }
- public void Error(string message, Exception e)
- {
- m_buffer.Append(message + "\n" + e.Message + "\n");
- }
+ public void Error(string message, Exception e)
+ {
+ m_buffer.Append(message + "\n" + e.Message + "\n");
+ }
- public void Error(string message, Exception e, ErrorCode errorCode)
- {
- m_buffer.Append(message + "\n" + e.Message + "\n");
- }
- }
+ public void Error(string message, Exception e, ErrorCode errorCode)
+ {
+ m_buffer.Append(message + "\n" + e.Message + "\n");
+ }
+ }
- public SmtpPickupDirAppenderTest()
- {
- _testPickupDir = Path.Combine(Directory.GetCurrentDirectory(), "SmtpPickupDirAppenderTest_PickupDir");
- }
- /// <summary>
- /// Sets up variables used for the tests
- /// </summary>
- private void InitializePickupDir()
- {
- Directory.CreateDirectory(_testPickupDir);
- }
+ public SmtpPickupDirAppenderTest()
+ {
+ _testPickupDir = Path.Combine(Directory.GetCurrentDirectory(), "SmtpPickupDirAppenderTest_PickupDir");
+ }
+ /// <summary>
+ /// Sets up variables used for the tests
+ /// </summary>
+ private void InitializePickupDir()
+ {
+ Directory.CreateDirectory(_testPickupDir);
+ }
- /// <summary>
- /// Shuts down any loggers in the hierarchy, along
- /// with all appenders, and deletes any test files used
- /// for logging.
- /// </summary>
- private void ResetLogger()
- {
- // Regular users should not use the clear method lightly!
- Utils.GetRepository().ResetConfiguration();
- Utils.GetRepository().Shutdown();
- ((Repository.Hierarchy.Hierarchy)Utils.GetRepository()).Clear();
- }
+ /// <summary>
+ /// Shuts down any loggers in the hierarchy, along
+ /// with all appenders, and deletes any test files used
+ /// for logging.
+ /// </summary>
+ private void ResetLogger()
+ {
+ // Regular users should not use the clear method lightly!
+ Utils.GetRepository().ResetConfiguration();
+ Utils.GetRepository().Shutdown();
+ ((Repository.Hierarchy.Hierarchy)Utils.GetRepository()).Clear();
+ }
- /// <summary>
- /// Any initialization that happens before each test can
- /// go here
- /// </summary>
- [SetUp]
- public void SetUp()
- {
- ResetLogger();
- DeleteTestFiles();
- InitializePickupDir();
- }
+ /// <summary>
+ /// Any initialization that happens before each test can
+ /// go here
+ /// </summary>
+ [SetUp]
+ public void SetUp()
+ {
+ ResetLogger();
+ DeleteTestFiles();
+ InitializePickupDir();
+ }
- /// <summary>
- /// Any steps that happen after each test go here
- /// </summary>
- [TearDown]
- public void TearDown()
- {
- ResetLogger();
- DeleteTestFiles();
- }
+ /// <summary>
+ /// Any steps that happen after each test go here
+ /// </summary>
+ [TearDown]
+ public void TearDown()
+ {
+ ResetLogger();
+ DeleteTestFiles();
+ }
- /// <summary>
- /// Removes all test files that exist
- /// </summary>
- private void DeleteTestFiles()
- {
- if (Directory.Exists(_testPickupDir))
- {
- Directory.Delete(_testPickupDir, true);
- }
- }
+ /// <summary>
+ /// Removes all test files that exist
+ /// </summary>
+ private void DeleteTestFiles()
+ {
+ if (Directory.Exists(_testPickupDir))
+ {
+ Directory.Delete(_testPickupDir, true);
+ }
+ }
- /// <summary>
- /// Creates a logger hierarchy, configures a SMTP pickup dir appender and returns an ILogger
- /// </summary>
- /// <param name="appender">The appender to use</param>
- /// <returns>A configured ILogger</returns>
- private ILogger CreateLogger(SmtpPickupDirAppender appender)
- {
- Repository.Hierarchy.Hierarchy h = (Repository.Hierarchy.Hierarchy)LogManager.CreateRepository("TestRepository");
+ /// <summary>
+ /// Creates a logger hierarchy, configures a SMTP pickup dir appender and returns an ILogger
+ /// </summary>
+ /// <param name="appender">The appender to use</param>
+ /// <returns>A configured ILogger</returns>
+ private ILogger CreateLogger(SmtpPickupDirAppender appender)
+ {
+ Repository.Hierarchy.Hierarchy h = (Repository.Hierarchy.Hierarchy)LogManager.CreateRepository("TestRepository");
- PatternLayout layout = new PatternLayout();
- layout.ConversionPattern = "%m%n";
- layout.ActivateOptions();
+ PatternLayout layout = new PatternLayout();
+ layout.ConversionPattern = "%m%n";
+ layout.ActivateOptions();
- appender.Layout = layout;
- appender.ActivateOptions();
+ appender.Layout = layout;
+ appender.ActivateOptions();
- h.Root.AddAppender(appender);
- h.Configured = true;
+ h.Root.AddAppender(appender);
+ h.Configured = true;
- ILogger log = h.GetLogger("Logger");
- return log;
- }
+ ILogger log = h.GetLogger("Logger");
+ return log;
+ }
- /// <summary>
- /// Create an appender to use for the logger
- /// </summary>
- /// <param name="handler">The error handler to use.</param>
- /// <returns></returns>
- private SmtpPickupDirAppender CreateSmtpPickupDirAppender(IErrorHandler handler)
- {
- SmtpPickupDirAppender appender = new SmtpPickupDirAppender();
- appender.PickupDir = _testPickupDir;
- appender.ErrorHandler = handler;
- return appender;
- }
+ /// <summary>
+ /// Create an appender to use for the logger
+ /// </summary>
+ /// <param name="handler">The error handler to use.</param>
+ /// <returns></returns>
+ private SmtpPickupDirAppender CreateSmtpPickupDirAppender(IErrorHandler handler)
+ {
+ SmtpPickupDirAppender appender = new SmtpPickupDirAppender();
+ appender.PickupDir = _testPickupDir;
+ appender.ErrorHandler = handler;
+ return appender;
+ }
- /// <summary>
- /// Destroys the logger hierarchy created by <see cref="SmtpPickupDirAppenderTest.CreateLogger"/>
- /// </summary>
- private static void DestroyLogger()
- {
- Repository.Hierarchy.Hierarchy h = (Repository.Hierarchy.Hierarchy)LogManager.GetRepository("TestRepository");
- h.ResetConfiguration();
- //Replace the repository selector so that we can recreate the hierarchy with the same name if necessary
- LoggerManager.RepositorySelector = new DefaultRepositorySelector(typeof(log4net.Repository.Hierarchy.Hierarchy));
- }
+ /// <summary>
+ /// Destroys the logger hierarchy created by <see cref="SmtpPickupDirAppenderTest.CreateLogger"/>
+ /// </summary>
+ private static void DestroyLogger()
+ {
+ Repository.Hierarchy.Hierarchy h = (Repository.Hierarchy.Hierarchy)LogManager.GetRepository("TestRepository");
+ h.ResetConfiguration();
+ //Replace the repository selector so that we can recreate the hierarchy with the same name if necessary
+ LoggerManager.RepositorySelector = new DefaultRepositorySelector(typeof(log4net.Repository.Hierarchy.Hierarchy));
+ }
- /// <summary>
- /// Tests if the sent message contained the date header.
- /// </summary>
- [Test]
- public void TestOutputContainsSentDate()
- {
- SilentErrorHandler sh = new SilentErrorHandler();
- SmtpPickupDirAppender appender = CreateSmtpPickupDirAppender(sh);
- ILogger log = CreateLogger(appender);
- log.Log(GetType(), Level.Info, "This is a message", null);
- log.Log(GetType(), Level.Info, "This is a message 2", null);
- DestroyLogger();
+ /// <summary>
+ /// Tests if the sent message contained the date header.
+ /// </summary>
+ [Test]
+ public void TestOutputContainsSentDate()
+ {
+ SilentErrorHandler sh = new SilentErrorHandler();
+ SmtpPickupDirAppender appender = CreateSmtpPickupDirAppender(sh);
+ ILogger log = CreateLogger(appender);
+ log.Log(GetType(), Level.Info, "This is a message", null);
+ log.Log(GetType(), Level.Info, "This is a message 2", null);
+ DestroyLogger();
- Assert.AreEqual(1, Directory.GetFiles(_testPickupDir).Length);
- string[] fileContent = File.ReadAllLines((Directory.GetFiles(_testPickupDir)[0]));
- bool hasDateHeader = false;
- const string dateHeaderStart = "Date: ";
- foreach (string line in fileContent)
- {
- if(line.StartsWith(dateHeaderStart))
- {
- string datePart = line.Substring(dateHeaderStart.Length);
- DateTime date = DateTime.ParseExact(datePart, "r", System.Globalization.CultureInfo.InvariantCulture);
- double diff = Math.Abs( (DateTime.UtcNow - date).TotalMilliseconds);
- Assert.LessOrEqual(diff, 1000, "Times should be equal, allowing a diff of one second to make test robust");
- hasDateHeader = true;
- }
- }
- Assert.IsTrue(hasDateHeader, "Output must contains a date header");
+ Assert.AreEqual(1, Directory.GetFiles(_testPickupDir).Length);
+ string[] fileContent = File.ReadAllLines((Directory.GetFiles(_testPickupDir)[0]));
+ bool hasDateHeader = false;
+ const string dateHeaderStart = "Date: ";
+ foreach (string line in fileContent)
+ {
+ if(line.StartsWith(dateHeaderStart))
+ {
+ string datePart = line.Substring(dateHeaderStart.Length);
+ DateTime date = DateTime.ParseExact(datePart, "r", System.Globalization.CultureInfo.InvariantCulture);
+ double diff = Math.Abs( (DateTime.UtcNow - date).TotalMilliseconds);
+ Assert.LessOrEqual(diff, 1000, "Times should be equal, allowing a diff of one second to make test robust");
+ hasDateHeader = true;
+ }
+ }
+ Assert.IsTrue(hasDateHeader, "Output must contains a date header");
- Assert.AreEqual("", sh.Message, "Unexpected error message");
- }
+ Assert.AreEqual("", sh.Message, "Unexpected error message");
+ }
- /// <summary>
- /// Verifies that file extension is applied to output file name.
- /// </summary>
- [Test]
- public void TestConfigurableFileExtension()
- {
- const string fileExtension = "eml";
- SilentErrorHandler sh = new SilentErrorHandler();
- SmtpPickupDirAppender appender = CreateSmtpPickupDirAppender(sh);
- appender.FileExtension = fileExtension;
- ILogger log = CreateLogger(appender);
- log.Log(GetType(), Level.Info, "This is a message", null);
- log.Log(GetType(), Level.Info, "This is a message 2", null);
- DestroyLogger();
+ /// <summary>
+ /// Verifies that file extension is applied to output file name.
+ /// </summary>
+ [Test]
+ public void TestConfigurableFileExtension()
+ {
+ const string fileExtension = "eml";
+ SilentErrorHandler sh = new SilentErrorHandler();
+ SmtpPickupDirAppender appender = CreateSmtpPickupDirAppender(sh);
+ appender.FileExtension = fileExtension;
+ ILogger log = CreateLogger(appender);
+ log.Log(GetType(), Level.Info, "This is a message", null);
+ log.Log(GetType(), Level.Info, "This is a message 2", null);
+ DestroyLogger();
- Assert.AreEqual(1, Directory.GetFiles(_testPickupDir).Length);
- FileInfo fileInfo = new FileInfo(Directory.GetFiles(_testPickupDir)[0]);
- Assert.AreEqual("." + fileExtension, fileInfo.Extension);
- Assert.DoesNotThrow(delegate { new Guid(fileInfo.Name.Substring(0, fileInfo.Name.Length - fileInfo.Extension.Length)); }); // Assert that filename before extension is a guid
+ Assert.AreEqual(1, Directory.GetFiles(_testPickupDir).Length);
+ FileInfo fileInfo = new FileInfo(Directory.GetFiles(_testPickupDir)[0]);
+ Assert.AreEqual("." + fileExtension, fileInfo.Extension);
+ Assert.DoesNotThrow(delegate { new Guid(fileInfo.Name.Substring(0, fileInfo.Name.Length - fileInfo.Extension.Length)); }); // Assert that filename before extension is a guid
- Assert.AreEqual("", sh.Message, "Unexpected error message");
- }
+ Assert.AreEqual("", sh.Message, "Unexpected error message");
+ }
- /// <summary>
- /// Verifies that logging a message actually produces output
- /// </summary>
- [Test]
- public void TestDefaultFileNameIsAGuid()
- {
- SilentErrorHandler sh = new SilentErrorHandler();
- SmtpPickupDirAppender appender = CreateSmtpPickupDirAppender(sh);
- ILogger log = CreateLogger(appender);
- log.Log(GetType(), Level.Info, "This is a message", null);
- log.Log(GetType(), Level.Info, "This is a message 2", null);
- DestroyLogger();
+ /// <summary>
+ /// Verifies that logging a message actually produces output
+ /// </summary>
+ [Test]
+ public void TestDefaultFileNameIsAGuid()
+ {
+ SilentErrorHandler sh = new SilentErrorHandler();
+ SmtpPickupDirAppender appender = CreateSmtpPickupDirAppender(sh);
+ ILogger log = CreateLogger(appender);
+ log.Log(GetType(), Level.Info, "This is a message", null);
+ log.Log(GetType(), Level.Info, "This is a message 2", null);
+ DestroyLogger();
- Assert.AreEqual(1, Directory.GetFiles(_testPickupDir).Length);
- FileInfo fileInfo = new FileInfo(Directory.GetFiles(_testPickupDir)[0]);
- Assert.IsEmpty(fileInfo.Extension);
- Assert.DoesNotThrow(delegate { new Guid(fileInfo.Name); }); // Assert that filename is a guid
+ Assert.AreEqual(1, Directory.GetFiles(_testPickupDir).Length);
+ FileInfo fileInfo = new FileInfo(Directory.GetFiles(_testPickupDir)[0]);
+ Assert.IsEmpty(fileInfo.Extension);
+ Assert.DoesNotThrow(delegate { new Guid(fileInfo.Name); }); // Assert that filename is a guid
- Assert.AreEqual("", sh.Message, "Unexpected error message");
- }
- }
+ Assert.AreEqual("", sh.Message, "Unexpected error message");
+ }
+ }
}
\ No newline at end of file
diff --git a/src/log4net.Tests/Appender/StringAppender.cs b/src/log4net.Tests/Appender/StringAppender.cs
index 977099c..83602f8 100644
--- a/src/log4net.Tests/Appender/StringAppender.cs
+++ b/src/log4net.Tests/Appender/StringAppender.cs
@@ -24,53 +24,53 @@
namespace log4net.Tests.Appender
{
- /// <summary>
- /// Write events to a string
- /// </summary>
- /// <author>Nicko Cadell</author>
- public class StringAppender : AppenderSkeleton
- {
- private StringBuilder m_buf = new StringBuilder();
+ /// <summary>
+ /// Write events to a string
+ /// </summary>
+ /// <author>Nicko Cadell</author>
+ public class StringAppender : AppenderSkeleton
+ {
+ private StringBuilder m_buf = new StringBuilder();
- /// <summary>
- /// Initializes a new instance of the <see cref="StringAppender" /> class.
- /// </summary>
- public StringAppender()
- {
- }
+ /// <summary>
+ /// Initializes a new instance of the <see cref="StringAppender" /> class.
+ /// </summary>
+ public StringAppender()
+ {
+ }
- /// <summary>
- /// Get the string logged so far
- /// </summary>
- /// <returns></returns>
- public string GetString()
- {
- return m_buf.ToString();
- }
+ /// <summary>
+ /// Get the string logged so far
+ /// </summary>
+ /// <returns></returns>
+ public string GetString()
+ {
+ return m_buf.ToString();
+ }
- /// <summary>
- /// Reset the string
- /// </summary>
- public void Reset()
- {
- m_buf.Length = 0;
- }
+ /// <summary>
+ /// Reset the string
+ /// </summary>
+ public void Reset()
+ {
+ m_buf.Length = 0;
+ }
- /// <summary>
- /// </summary>
- /// <param name="loggingEvent">the event to log</param>
- protected override void Append(LoggingEvent loggingEvent)
- {
- m_buf.Append(RenderLoggingEvent(loggingEvent));
- }
+ /// <summary>
+ /// </summary>
+ /// <param name="loggingEvent">the event to log</param>
+ protected override void Append(LoggingEvent loggingEvent)
+ {
+ m_buf.Append(RenderLoggingEvent(loggingEvent));
+ }
- /// <summary>
- /// This appender requires a <see cref="Layout"/> to be set.
- /// </summary>
- /// <value><c>true</c></value>
- protected override bool RequiresLayout
- {
- get { return true; }
- }
- }
+ /// <summary>
+ /// This appender requires a <see cref="Layout"/> to be set.
+ /// </summary>
+ /// <value><c>true</c></value>
+ protected override bool RequiresLayout
+ {
+ get { return true; }
+ }
+ }
}
\ No newline at end of file
diff --git a/src/log4net.Tests/Context/LogicalThreadContextTest.cs b/src/log4net.Tests/Context/LogicalThreadContextTest.cs
index 103e00b..ca8a7c1 100644
--- a/src/log4net.Tests/Context/LogicalThreadContextTest.cs
+++ b/src/log4net.Tests/Context/LogicalThreadContextTest.cs
@@ -32,313 +32,313 @@
namespace log4net.Tests.Context
{
- /// <summary>
- /// Used for internal unit testing the <see cref="LogicalThreadContext"/> class.
- /// </summary>
- /// <remarks>
- /// Used for internal unit testing the <see cref="LogicalThreadContext"/> class.
- /// </remarks>
- [TestFixture]
- public class LogicalThreadContextTest
- {
- [TearDown]
- public void TearDown()
- {
- Utils.RemovePropertyFromAllContexts();
- }
+ /// <summary>
+ /// Used for internal unit testing the <see cref="LogicalThreadContext"/> class.
+ /// </summary>
+ /// <remarks>
+ /// Used for internal unit testing the <see cref="LogicalThreadContext"/> class.
+ /// </remarks>
+ [TestFixture]
+ public class LogicalThreadContextTest
+ {
+ [TearDown]
+ public void TearDown()
+ {
+ Utils.RemovePropertyFromAllContexts();
+ }
- [Test]
- public void TestLogicalThreadPropertiesPatternBasicGetSet()
- {
- StringAppender stringAppender = new StringAppender();
- stringAppender.Layout = new PatternLayout("%property{" + Utils.PROPERTY_KEY + "}");
+ [Test]
+ public void TestLogicalThreadPropertiesPatternBasicGetSet()
+ {
+ StringAppender stringAppender = new StringAppender();
+ stringAppender.Layout = new PatternLayout("%property{" + Utils.PROPERTY_KEY + "}");
- ILoggerRepository rep = LogManager.CreateRepository(Guid.NewGuid().ToString());
- BasicConfigurator.Configure(rep, stringAppender);
+ ILoggerRepository rep = LogManager.CreateRepository(Guid.NewGuid().ToString());
+ BasicConfigurator.Configure(rep, stringAppender);
- ILog log1 = LogManager.GetLogger(rep.Name, "TestLogicalThreadPropertiesPattern");
+ ILog log1 = LogManager.GetLogger(rep.Name, "TestLogicalThreadPropertiesPattern");
- log1.Info("TestMessage");
- Assert.AreEqual(SystemInfo.NullText, stringAppender.GetString(), "Test no logical thread properties value set");
- stringAppender.Reset();
+ log1.Info("TestMessage");
+ Assert.AreEqual(SystemInfo.NullText, stringAppender.GetString(), "Test no logical thread properties value set");
+ stringAppender.Reset();
- LogicalThreadContext.Properties[Utils.PROPERTY_KEY] = "val1";
+ LogicalThreadContext.Properties[Utils.PROPERTY_KEY] = "val1";
- log1.Info("TestMessage");
- Assert.AreEqual("val1", stringAppender.GetString(), "Test logical thread properties value set");
- stringAppender.Reset();
+ log1.Info("TestMessage");
+ Assert.AreEqual("val1", stringAppender.GetString(), "Test logical thread properties value set");
+ stringAppender.Reset();
- LogicalThreadContext.Properties.Remove(Utils.PROPERTY_KEY);
+ LogicalThreadContext.Properties.Remove(Utils.PROPERTY_KEY);
- log1.Info("TestMessage");
- Assert.AreEqual(SystemInfo.NullText, stringAppender.GetString(), "Test logical thread properties value removed");
- stringAppender.Reset();
- }
+ log1.Info("TestMessage");
+ Assert.AreEqual(SystemInfo.NullText, stringAppender.GetString(), "Test logical thread properties value removed");
+ stringAppender.Reset();
+ }
- [Test]
- public async Task TestLogicalThreadPropertiesPatternAsyncAwait()
- {
- StringAppender stringAppender = new StringAppender();
- stringAppender.Layout = new PatternLayout("%property{" + Utils.PROPERTY_KEY + "}");
+ [Test]
+ public async Task TestLogicalThreadPropertiesPatternAsyncAwait()
+ {
+ StringAppender stringAppender = new StringAppender();
+ stringAppender.Layout = new PatternLayout("%property{" + Utils.PROPERTY_KEY + "}");
- ILoggerRepository rep = LogManager.CreateRepository(Guid.NewGuid().ToString());
- BasicConfigurator.Configure(rep, stringAppender);
+ ILoggerRepository rep = LogManager.CreateRepository(Guid.NewGuid().ToString());
+ BasicConfigurator.Configure(rep, stringAppender);
- ILog log1 = LogManager.GetLogger(rep.Name, "TestLogicalThreadPropertiesPattern");
+ ILog log1 = LogManager.GetLogger(rep.Name, "TestLogicalThreadPropertiesPattern");
- log1.Info("TestMessage");
- Assert.AreEqual(SystemInfo.NullText, stringAppender.GetString(), "Test no logical thread stack value set");
- stringAppender.Reset();
+ log1.Info("TestMessage");
+ Assert.AreEqual(SystemInfo.NullText, stringAppender.GetString(), "Test no logical thread stack value set");
+ stringAppender.Reset();
- string testValueForCurrentContext = "Outer";
- LogicalThreadContext.Properties[Utils.PROPERTY_KEY] = testValueForCurrentContext;
+ string testValueForCurrentContext = "Outer";
+ LogicalThreadContext.Properties[Utils.PROPERTY_KEY] = testValueForCurrentContext;
- log1.Info("TestMessage");
- Assert.AreEqual(testValueForCurrentContext, stringAppender.GetString(), "Test logical thread properties value set");
- stringAppender.Reset();
+ log1.Info("TestMessage");
+ Assert.AreEqual(testValueForCurrentContext, stringAppender.GetString(), "Test logical thread properties value set");
+ stringAppender.Reset();
- var strings = await Task.WhenAll(Enumerable.Range(0, 10).Select(x => SomeWorkProperties(x.ToString())));
+ var strings = await Task.WhenAll(Enumerable.Range(0, 10).Select(x => SomeWorkProperties(x.ToString())));
- // strings should be ["00AA0BB0", "01AA1BB1", "02AA2BB2", ...]
- for (int i = 0; i < strings.Length; i++)
- {
- Assert.AreEqual(string.Format("{0}{1}AA{1}BB{1}", testValueForCurrentContext, i), strings[i], "Test logical thread properties expected sequence");
- }
+ // strings should be ["00AA0BB0", "01AA1BB1", "02AA2BB2", ...]
+ for (int i = 0; i < strings.Length; i++)
+ {
+ Assert.AreEqual(string.Format("{0}{1}AA{1}BB{1}", testValueForCurrentContext, i), strings[i], "Test logical thread properties expected sequence");
+ }
- log1.Info("TestMessage");
- Assert.AreEqual(testValueForCurrentContext, stringAppender.GetString(), "Test logical thread properties value set");
- stringAppender.Reset();
+ log1.Info("TestMessage");
+ Assert.AreEqual(testValueForCurrentContext, stringAppender.GetString(), "Test logical thread properties value set");
+ stringAppender.Reset();
- LogicalThreadContext.Properties.Remove(Utils.PROPERTY_KEY);
+ LogicalThreadContext.Properties.Remove(Utils.PROPERTY_KEY);
- log1.Info("TestMessage");
- Assert.AreEqual(SystemInfo.NullText, stringAppender.GetString(), "Test logical thread properties value removed");
- stringAppender.Reset();
- }
+ log1.Info("TestMessage");
+ Assert.AreEqual(SystemInfo.NullText, stringAppender.GetString(), "Test logical thread properties value removed");
+ stringAppender.Reset();
+ }
- [Test]
- public void TestLogicalThreadStackPattern()
- {
- StringAppender stringAppender = new StringAppender();
- stringAppender.Layout = new PatternLayout("%property{" + Utils.PROPERTY_KEY + "}");
+ [Test]
+ public void TestLogicalThreadStackPattern()
+ {
+ StringAppender stringAppender = new StringAppender();
+ stringAppender.Layout = new PatternLayout("%property{" + Utils.PROPERTY_KEY + "}");
- ILoggerRepository rep = LogManager.CreateRepository(Guid.NewGuid().ToString());
- BasicConfigurator.Configure(rep, stringAppender);
+ ILoggerRepository rep = LogManager.CreateRepository(Guid.NewGuid().ToString());
+ BasicConfigurator.Configure(rep, stringAppender);
- ILog log1 = LogManager.GetLogger(rep.Name, "TestThreadStackPattern");
+ ILog log1 = LogManager.GetLogger(rep.Name, "TestThreadStackPattern");
- log1.Info("TestMessage");
- Assert.AreEqual(SystemInfo.NullText, stringAppender.GetString(), "Test no logical thread stack value set");
- stringAppender.Reset();
+ log1.Info("TestMessage");
+ Assert.AreEqual(SystemInfo.NullText, stringAppender.GetString(), "Test no logical thread stack value set");
+ stringAppender.Reset();
- using (LogicalThreadContext.Stacks[Utils.PROPERTY_KEY].Push("val1"))
- {
- log1.Info("TestMessage");
- Assert.AreEqual("val1", stringAppender.GetString(), "Test logical thread stack value set");
- stringAppender.Reset();
- }
+ using (LogicalThreadContext.Stacks[Utils.PROPERTY_KEY].Push("val1"))
+ {
+ log1.Info("TestMessage");
+ Assert.AreEqual("val1", stringAppender.GetString(), "Test logical thread stack value set");
+ stringAppender.Reset();
+ }
- log1.Info("TestMessage");
- Assert.AreEqual(SystemInfo.NullText, stringAppender.GetString(), "Test logical thread stack value removed");
- stringAppender.Reset();
- }
+ log1.Info("TestMessage");
+ Assert.AreEqual(SystemInfo.NullText, stringAppender.GetString(), "Test logical thread stack value removed");
+ stringAppender.Reset();
+ }
- [Test]
- public void TestLogicalThreadStackPattern2()
- {
- StringAppender stringAppender = new StringAppender();
- stringAppender.Layout = new PatternLayout("%property{" + Utils.PROPERTY_KEY + "}");
+ [Test]
+ public void TestLogicalThreadStackPattern2()
+ {
+ StringAppender stringAppender = new StringAppender();
+ stringAppender.Layout = new PatternLayout("%property{" + Utils.PROPERTY_KEY + "}");
- ILoggerRepository rep = LogManager.CreateRepository(Guid.NewGuid().ToString());
- BasicConfigurator.Configure(rep, stringAppender);
+ ILoggerRepository rep = LogManager.CreateRepository(Guid.NewGuid().ToString());
+ BasicConfigurator.Configure(rep, stringAppender);
- ILog log1 = LogManager.GetLogger(rep.Name, "TestThreadStackPattern");
+ ILog log1 = LogManager.GetLogger(rep.Name, "TestThreadStackPattern");
- log1.Info("TestMessage");
- Assert.AreEqual(SystemInfo.NullText, stringAppender.GetString(), "Test no logical thread stack value set");
- stringAppender.Reset();
+ log1.Info("TestMessage");
+ Assert.AreEqual(SystemInfo.NullText, stringAppender.GetString(), "Test no logical thread stack value set");
+ stringAppender.Reset();
- using (LogicalThreadContext.Stacks[Utils.PROPERTY_KEY].Push("val1"))
- {
- log1.Info("TestMessage");
- Assert.AreEqual("val1", stringAppender.GetString(), "Test logical thread stack value set");
- stringAppender.Reset();
+ using (LogicalThreadContext.Stacks[Utils.PROPERTY_KEY].Push("val1"))
+ {
+ log1.Info("TestMessage");
+ Assert.AreEqual("val1", stringAppender.GetString(), "Test logical thread stack value set");
+ stringAppender.Reset();
- using (LogicalThreadContext.Stacks[Utils.PROPERTY_KEY].Push("val2"))
- {
- log1.Info("TestMessage");
- Assert.AreEqual("val1 val2", stringAppender.GetString(), "Test logical thread stack value pushed 2nd val");
- stringAppender.Reset();
- }
- }
+ using (LogicalThreadContext.Stacks[Utils.PROPERTY_KEY].Push("val2"))
+ {
+ log1.Info("TestMessage");
+ Assert.AreEqual("val1 val2", stringAppender.GetString(), "Test logical thread stack value pushed 2nd val");
+ stringAppender.Reset();
+ }
+ }
- log1.Info("TestMessage");
- Assert.AreEqual(SystemInfo.NullText, stringAppender.GetString(), "Test logical thread stack value removed");
- stringAppender.Reset();
- }
+ log1.Info("TestMessage");
+ Assert.AreEqual(SystemInfo.NullText, stringAppender.GetString(), "Test logical thread stack value removed");
+ stringAppender.Reset();
+ }
- [Test]
- public void TestLogicalThreadStackPatternNullVal()
- {
- StringAppender stringAppender = new StringAppender();
- stringAppender.Layout = new PatternLayout("%property{" + Utils.PROPERTY_KEY + "}");
+ [Test]
+ public void TestLogicalThreadStackPatternNullVal()
+ {
+ StringAppender stringAppender = new StringAppender();
+ stringAppender.Layout = new PatternLayout("%property{" + Utils.PROPERTY_KEY + "}");
- ILoggerRepository rep = LogManager.CreateRepository(Guid.NewGuid().ToString());
- BasicConfigurator.Configure(rep, stringAppender);
+ ILoggerRepository rep = LogManager.CreateRepository(Guid.NewGuid().ToString());
+ BasicConfigurator.Configure(rep, stringAppender);
- ILog log1 = LogManager.GetLogger(rep.Name, "TestThreadStackPattern");
+ ILog log1 = LogManager.GetLogger(rep.Name, "TestThreadStackPattern");
- log1.Info("TestMessage");
- Assert.AreEqual(SystemInfo.NullText, stringAppender.GetString(), "Test no logical thread stack value set");
- stringAppender.Reset();
+ log1.Info("TestMessage");
+ Assert.AreEqual(SystemInfo.NullText, stringAppender.GetString(), "Test no logical thread stack value set");
+ stringAppender.Reset();
- using (LogicalThreadContext.Stacks[Utils.PROPERTY_KEY].Push(null))
- {
- log1.Info("TestMessage");
- Assert.AreEqual(SystemInfo.NullText, stringAppender.GetString(), "Test logical thread stack value set");
- stringAppender.Reset();
- }
+ using (LogicalThreadContext.Stacks[Utils.PROPERTY_KEY].Push(null))
+ {
+ log1.Info("TestMessage");
+ Assert.AreEqual(SystemInfo.NullText, stringAppender.GetString(), "Test logical thread stack value set");
+ stringAppender.Reset();
+ }
- log1.Info("TestMessage");
- Assert.AreEqual(SystemInfo.NullText, stringAppender.GetString(), "Test logical thread stack value removed");
- stringAppender.Reset();
- }
+ log1.Info("TestMessage");
+ Assert.AreEqual(SystemInfo.NullText, stringAppender.GetString(), "Test logical thread stack value removed");
+ stringAppender.Reset();
+ }
- [Test]
- public void TestLogicalThreadStackPatternNullVal2()
- {
- StringAppender stringAppender = new StringAppender();
- stringAppender.Layout = new PatternLayout("%property{" + Utils.PROPERTY_KEY + "}");
+ [Test]
+ public void TestLogicalThreadStackPatternNullVal2()
+ {
+ StringAppender stringAppender = new StringAppender();
+ stringAppender.Layout = new PatternLayout("%property{" + Utils.PROPERTY_KEY + "}");
- ILoggerRepository rep = LogManager.CreateRepository(Guid.NewGuid().ToString());
- BasicConfigurator.Configure(rep, stringAppender);
+ ILoggerRepository rep = LogManager.CreateRepository(Guid.NewGuid().ToString());
+ BasicConfigurator.Configure(rep, stringAppender);
- ILog log1 = LogManager.GetLogger(rep.Name, "TestThreadStackPattern");
+ ILog log1 = LogManager.GetLogger(rep.Name, "TestThreadStackPattern");
- log1.Info("TestMessage");
- Assert.AreEqual(SystemInfo.NullText, stringAppender.GetString(), "Test no logical thread stack value set");
- stringAppender.Reset();
+ log1.Info("TestMessage");
+ Assert.AreEqual(SystemInfo.NullText, stringAppender.GetString(), "Test no logical thread stack value set");
+ stringAppender.Reset();
- using (LogicalThreadContext.Stacks[Utils.PROPERTY_KEY].Push("val1"))
- {
- log1.Info("TestMessage");
- Assert.AreEqual("val1", stringAppender.GetString(), "Test logical thread stack value set");
- stringAppender.Reset();
+ using (LogicalThreadContext.Stacks[Utils.PROPERTY_KEY].Push("val1"))
+ {
+ log1.Info("TestMessage");
+ Assert.AreEqual("val1", stringAppender.GetString(), "Test logical thread stack value set");
+ stringAppender.Reset();
- using (LogicalThreadContext.Stacks[Utils.PROPERTY_KEY].Push(null))
- {
- log1.Info("TestMessage");
- Assert.AreEqual("val1 ", stringAppender.GetString(), "Test logical thread stack value pushed null");
- stringAppender.Reset();
- }
- }
+ using (LogicalThreadContext.Stacks[Utils.PROPERTY_KEY].Push(null))
+ {
+ log1.Info("TestMessage");
+ Assert.AreEqual("val1 ", stringAppender.GetString(), "Test logical thread stack value pushed null");
+ stringAppender.Reset();
+ }
+ }
- log1.Info("TestMessage");
- Assert.AreEqual(SystemInfo.NullText, stringAppender.GetString(), "Test logical thread stack value removed");
- stringAppender.Reset();
- }
+ log1.Info("TestMessage");
+ Assert.AreEqual(SystemInfo.NullText, stringAppender.GetString(), "Test logical thread stack value removed");
+ stringAppender.Reset();
+ }
- [Test]
- public async Task TestLogicalThreadStackPatternAsyncAwait()
- {
- StringAppender stringAppender = new StringAppender();
- stringAppender.Layout = new PatternLayout("%property{" + Utils.PROPERTY_KEY + "}");
+ [Test]
+ public async Task TestLogicalThreadStackPatternAsyncAwait()
+ {
+ StringAppender stringAppender = new StringAppender();
+ stringAppender.Layout = new PatternLayout("%property{" + Utils.PROPERTY_KEY + "}");
- ILoggerRepository rep = LogManager.CreateRepository(Guid.NewGuid().ToString());
- BasicConfigurator.Configure(rep, stringAppender);
+ ILoggerRepository rep = LogManager.CreateRepository(Guid.NewGuid().ToString());
+ BasicConfigurator.Configure(rep, stringAppender);
- ILog log1 = LogManager.GetLogger(rep.Name, "TestLogicalThreadStackPattern");
+ ILog log1 = LogManager.GetLogger(rep.Name, "TestLogicalThreadStackPattern");
- log1.Info("TestMessage");
- Assert.AreEqual(SystemInfo.NullText, stringAppender.GetString(), "Test no logical thread stack value set");
- stringAppender.Reset();
+ log1.Info("TestMessage");
+ Assert.AreEqual(SystemInfo.NullText, stringAppender.GetString(), "Test no logical thread stack value set");
+ stringAppender.Reset();
- string testValueForCurrentContext = "Outer";
- string[] strings = null;
- using (LogicalThreadContext.Stacks[Utils.PROPERTY_KEY].Push(testValueForCurrentContext))
- {
- log1.Info("TestMessage");
- Assert.AreEqual(testValueForCurrentContext, stringAppender.GetString(), "Test logical thread stack value set");
- stringAppender.Reset();
+ string testValueForCurrentContext = "Outer";
+ string[] strings = null;
+ using (LogicalThreadContext.Stacks[Utils.PROPERTY_KEY].Push(testValueForCurrentContext))
+ {
+ log1.Info("TestMessage");
+ Assert.AreEqual(testValueForCurrentContext, stringAppender.GetString(), "Test logical thread stack value set");
+ stringAppender.Reset();
- strings = await Task.WhenAll(Enumerable.Range(0, 10).Select(x => SomeWorkStack(x.ToString())));
- }
+ strings = await Task.WhenAll(Enumerable.Range(0, 10).Select(x => SomeWorkStack(x.ToString())));
+ }
- // strings should be ["Outer 0 AOuter 0 AOuter 0Outer 0 BOuter 0 B Outer 0", ...]
- for (int i = 0; i < strings.Length; i++)
- {
- Assert.AreEqual(string.Format("{0} {1} A{0} {1} A{0} {1}{0} {1} B{0} {1} B{0} {1}", testValueForCurrentContext, i), strings[i], "Test logical thread properties expected sequence");
- }
+ // strings should be ["Outer 0 AOuter 0 AOuter 0Outer 0 BOuter 0 B Outer 0", ...]
+ for (int i = 0; i < strings.Length; i++)
+ {
+ Assert.AreEqual(string.Format("{0} {1} A{0} {1} A{0} {1}{0} {1} B{0} {1} B{0} {1}", testValueForCurrentContext, i), strings[i], "Test logical thread properties expected sequence");
+ }
- log1.Info("TestMessage");
- Assert.AreEqual(SystemInfo.NullText, stringAppender.GetString(), "Test logical thread properties value removed");
- stringAppender.Reset();
- }
+ log1.Info("TestMessage");
+ Assert.AreEqual(SystemInfo.NullText, stringAppender.GetString(), "Test logical thread properties value removed");
+ stringAppender.Reset();
+ }
- static async Task<string> SomeWorkProperties(string propertyName)
- {
- StringAppender stringAppender = new StringAppender();
- stringAppender.Layout = new PatternLayout("%property{" + Utils.PROPERTY_KEY + "}");
+ static async Task<string> SomeWorkProperties(string propertyName)
+ {
+ StringAppender stringAppender = new StringAppender();
+ stringAppender.Layout = new PatternLayout("%property{" + Utils.PROPERTY_KEY + "}");
- ILoggerRepository rep = LogManager.CreateRepository(Guid.NewGuid().ToString());
- BasicConfigurator.Configure(rep, stringAppender);
+ ILoggerRepository rep = LogManager.CreateRepository(Guid.NewGuid().ToString());
+ BasicConfigurator.Configure(rep, stringAppender);
- ILog log = LogManager.GetLogger(rep.Name, "TestLogicalThreadStackPattern");
- log.Info("TestMessage");
+ ILog log = LogManager.GetLogger(rep.Name, "TestLogicalThreadStackPattern");
+ log.Info("TestMessage");
- // set a new one
- LogicalThreadContext.Properties[Utils.PROPERTY_KEY] = propertyName;
- log.Info("TestMessage");
+ // set a new one
+ LogicalThreadContext.Properties[Utils.PROPERTY_KEY] = propertyName;
+ log.Info("TestMessage");
- await MoreWorkProperties(log, "A");
- log.Info("TestMessage");
- await MoreWorkProperties(log, "B");
- log.Info("TestMessage");
- return stringAppender.GetString();
- }
+ await MoreWorkProperties(log, "A");
+ log.Info("TestMessage");
+ await MoreWorkProperties(log, "B");
+ log.Info("TestMessage");
+ return stringAppender.GetString();
+ }
- static async Task MoreWorkProperties(ILog log, string propertyName)
- {
- LogicalThreadContext.Properties[Utils.PROPERTY_KEY] = propertyName;
- log.Info("TestMessage");
- await Task.Delay(1);
- log.Info("TestMessage");
- }
+ static async Task MoreWorkProperties(ILog log, string propertyName)
+ {
+ LogicalThreadContext.Properties[Utils.PROPERTY_KEY] = propertyName;
+ log.Info("TestMessage");
+ await Task.Delay(1);
+ log.Info("TestMessage");
+ }
- static async Task<string> SomeWorkStack(string stackName)
- {
- StringAppender stringAppender = new StringAppender();
- stringAppender.Layout = new PatternLayout("%property{" + Utils.PROPERTY_KEY + "}");
+ static async Task<string> SomeWorkStack(string stackName)
+ {
+ StringAppender stringAppender = new StringAppender();
+ stringAppender.Layout = new PatternLayout("%property{" + Utils.PROPERTY_KEY + "}");
- ILoggerRepository rep = LogManager.CreateRepository(Guid.NewGuid().ToString());
- BasicConfigurator.Configure(rep, stringAppender);
+ ILoggerRepository rep = LogManager.CreateRepository(Guid.NewGuid().ToString());
+ BasicConfigurator.Configure(rep, stringAppender);
- ILog log = LogManager.GetLogger(rep.Name, "TestLogicalThreadStackPattern");
+ ILog log = LogManager.GetLogger(rep.Name, "TestLogicalThreadStackPattern");
- using (LogicalThreadContext.Stacks[Utils.PROPERTY_KEY].Push(stackName))
- {
- log.Info("TestMessage");
- Assert.AreEqual(string.Format("Outer {0}", stackName), stringAppender.GetString(), "Test logical thread stack value set");
- stringAppender.Reset();
+ using (LogicalThreadContext.Stacks[Utils.PROPERTY_KEY].Push(stackName))
+ {
+ log.Info("TestMessage");
+ Assert.AreEqual(string.Format("Outer {0}", stackName), stringAppender.GetString(), "Test logical thread stack value set");
+ stringAppender.Reset();
- await MoreWorkStack(log, "A");
- log.Info("TestMessage");
- await MoreWorkStack(log, "B");
- log.Info("TestMessage");
- }
+ await MoreWorkStack(log, "A");
+ log.Info("TestMessage");
+ await MoreWorkStack(log, "B");
+ log.Info("TestMessage");
+ }
- return stringAppender.GetString();
- }
+ return stringAppender.GetString();
+ }
- static async Task MoreWorkStack(ILog log, string stackName)
- {
- using (LogicalThreadContext.Stacks[Utils.PROPERTY_KEY].Push(stackName))
- {
- log.Info("TestMessage");
- await Task.Delay(1);
- log.Info("TestMessage");
- }
- }
- }
+ static async Task MoreWorkStack(ILog log, string stackName)
+ {
+ using (LogicalThreadContext.Stacks[Utils.PROPERTY_KEY].Push(stackName))
+ {
+ log.Info("TestMessage");
+ await Task.Delay(1);
+ log.Info("TestMessage");
+ }
+ }
+ }
}
#endif
diff --git a/src/log4net.Tests/Core/EvaluatorTest.cs b/src/log4net.Tests/Core/EvaluatorTest.cs
index 0dbc5dc..30a31de 100644
--- a/src/log4net.Tests/Core/EvaluatorTest.cs
+++ b/src/log4net.Tests/Core/EvaluatorTest.cs
@@ -27,118 +27,118 @@
namespace log4net.Tests.Core
{
- [TestFixture]
- public class EvaluatorTest
- {
- private BufferingForwardingAppender m_bufferingForwardingAppender;
- private CountingAppender m_countingAppender;
- private Repository.Hierarchy.Hierarchy m_hierarchy;
+ [TestFixture]
+ public class EvaluatorTest
+ {
+ private BufferingForwardingAppender m_bufferingForwardingAppender;
+ private CountingAppender m_countingAppender;
+ private Repository.Hierarchy.Hierarchy m_hierarchy;
- [SetUp]
- public void SetupRepository()
- {
- m_hierarchy = new Repository.Hierarchy.Hierarchy();
+ [SetUp]
+ public void SetupRepository()
+ {
+ m_hierarchy = new Repository.Hierarchy.Hierarchy();
- m_countingAppender = new CountingAppender();
- m_countingAppender.ActivateOptions();
+ m_countingAppender = new CountingAppender();
+ m_countingAppender.ActivateOptions();
- m_bufferingForwardingAppender = new BufferingForwardingAppender();
- m_bufferingForwardingAppender.AddAppender(m_countingAppender);
+ m_bufferingForwardingAppender = new BufferingForwardingAppender();
+ m_bufferingForwardingAppender.AddAppender(m_countingAppender);
- m_bufferingForwardingAppender.BufferSize = 5;
- m_bufferingForwardingAppender.ClearFilters();
- m_bufferingForwardingAppender.Fix = FixFlags.Partial;
- m_bufferingForwardingAppender.Lossy = false;
- m_bufferingForwardingAppender.LossyEvaluator = null;
- m_bufferingForwardingAppender.Threshold = Level.All;
- }
+ m_bufferingForwardingAppender.BufferSize = 5;
+ m_bufferingForwardingAppender.ClearFilters();
+ m_bufferingForwardingAppender.Fix = FixFlags.Partial;
+ m_bufferingForwardingAppender.Lossy = false;
+ m_bufferingForwardingAppender.LossyEvaluator = null;
+ m_bufferingForwardingAppender.Threshold = Level.All;
+ }
- [Test]
- public void TestLevelEvaluator()
- {
- m_bufferingForwardingAppender.Evaluator = new LevelEvaluator(Level.Info);
- m_bufferingForwardingAppender.ActivateOptions();
- log4net.Config.BasicConfigurator.Configure(m_hierarchy, m_bufferingForwardingAppender);
+ [Test]
+ public void TestLevelEvaluator()
+ {
+ m_bufferingForwardingAppender.Evaluator = new LevelEvaluator(Level.Info);
+ m_bufferingForwardingAppender.ActivateOptions();
+ log4net.Config.BasicConfigurator.Configure(m_hierarchy, m_bufferingForwardingAppender);
- ILogger logger = m_hierarchy.GetLogger("TestLevelEvaluator");
+ ILogger logger = m_hierarchy.GetLogger("TestLevelEvaluator");
- logger.Log(typeof(EvaluatorTest), Level.Debug, "Debug message logged", null);
- logger.Log(typeof(EvaluatorTest), Level.Debug, "Debug message logged", null);
- Assert.AreEqual(0, m_countingAppender.Counter, "Test 2 events buffered");
+ logger.Log(typeof(EvaluatorTest), Level.Debug, "Debug message logged", null);
+ logger.Log(typeof(EvaluatorTest), Level.Debug, "Debug message logged", null);
+ Assert.AreEqual(0, m_countingAppender.Counter, "Test 2 events buffered");
- logger.Log(typeof(EvaluatorTest), Level.Info, "Info message logged", null);
- Assert.AreEqual(3, m_countingAppender.Counter, "Test 3 events flushed on Info message.");
- }
+ logger.Log(typeof(EvaluatorTest), Level.Info, "Info message logged", null);
+ Assert.AreEqual(3, m_countingAppender.Counter, "Test 3 events flushed on Info message.");
+ }
#if !NETSTANDARD1_3
- [Test]
- public void TestExceptionEvaluator()
- {
- m_bufferingForwardingAppender.Evaluator = new ExceptionEvaluator(typeof(ApplicationException), true);
- m_bufferingForwardingAppender.ActivateOptions();
- log4net.Config.BasicConfigurator.Configure(m_hierarchy, m_bufferingForwardingAppender);
+ [Test]
+ public void TestExceptionEvaluator()
+ {
+ m_bufferingForwardingAppender.Evaluator = new ExceptionEvaluator(typeof(ApplicationException), true);
+ m_bufferingForwardingAppender.ActivateOptions();
+ log4net.Config.BasicConfigurator.Configure(m_hierarchy, m_bufferingForwardingAppender);
- ILogger logger = m_hierarchy.GetLogger("TestExceptionEvaluator");
+ ILogger logger = m_hierarchy.GetLogger("TestExceptionEvaluator");
- logger.Log(typeof(EvaluatorTest), Level.Warn, "Warn message logged", null);
- logger.Log(typeof(EvaluatorTest), Level.Warn, "Warn message logged", null);
- Assert.AreEqual(0, m_countingAppender.Counter, "Test 2 events buffered");
+ logger.Log(typeof(EvaluatorTest), Level.Warn, "Warn message logged", null);
+ logger.Log(typeof(EvaluatorTest), Level.Warn, "Warn message logged", null);
+ Assert.AreEqual(0, m_countingAppender.Counter, "Test 2 events buffered");
- logger.Log(typeof(EvaluatorTest), Level.Warn, "Warn message logged", new ApplicationException());
- Assert.AreEqual(3, m_countingAppender.Counter, "Test 3 events flushed on ApplicationException message.");
- }
+ logger.Log(typeof(EvaluatorTest), Level.Warn, "Warn message logged", new ApplicationException());
+ Assert.AreEqual(3, m_countingAppender.Counter, "Test 3 events flushed on ApplicationException message.");
+ }
- [Test]
- public void TestExceptionEvaluatorTriggerOnSubClass()
- {
- m_bufferingForwardingAppender.Evaluator = new ExceptionEvaluator(typeof(Exception), true);
- m_bufferingForwardingAppender.ActivateOptions();
- log4net.Config.BasicConfigurator.Configure(m_hierarchy, m_bufferingForwardingAppender);
+ [Test]
+ public void TestExceptionEvaluatorTriggerOnSubClass()
+ {
+ m_bufferingForwardingAppender.Evaluator = new ExceptionEvaluator(typeof(Exception), true);
+ m_bufferingForwardingAppender.ActivateOptions();
+ log4net.Config.BasicConfigurator.Configure(m_hierarchy, m_bufferingForwardingAppender);
- ILogger logger = m_hierarchy.GetLogger("TestExceptionEvaluatorTriggerOnSubClass");
+ ILogger logger = m_hierarchy.GetLogger("TestExceptionEvaluatorTriggerOnSubClass");
- logger.Log(typeof(EvaluatorTest), Level.Warn, "Warn message logged", null);
- logger.Log(typeof(EvaluatorTest), Level.Warn, "Warn message logged", null);
- Assert.AreEqual(0, m_countingAppender.Counter, "Test 2 events buffered");
+ logger.Log(typeof(EvaluatorTest), Level.Warn, "Warn message logged", null);
+ logger.Log(typeof(EvaluatorTest), Level.Warn, "Warn message logged", null);
+ Assert.AreEqual(0, m_countingAppender.Counter, "Test 2 events buffered");
- logger.Log(typeof(EvaluatorTest), Level.Warn, "Warn message logged", new ApplicationException());
- Assert.AreEqual(3, m_countingAppender.Counter, "Test 3 events flushed on ApplicationException message.");
- }
+ logger.Log(typeof(EvaluatorTest), Level.Warn, "Warn message logged", new ApplicationException());
+ Assert.AreEqual(3, m_countingAppender.Counter, "Test 3 events flushed on ApplicationException message.");
+ }
- [Test]
- public void TestExceptionEvaluatorNoTriggerOnSubClass()
- {
- m_bufferingForwardingAppender.Evaluator = new ExceptionEvaluator(typeof(Exception), false);
- m_bufferingForwardingAppender.ActivateOptions();
- log4net.Config.BasicConfigurator.Configure(m_hierarchy, m_bufferingForwardingAppender);
+ [Test]
+ public void TestExceptionEvaluatorNoTriggerOnSubClass()
+ {
+ m_bufferingForwardingAppender.Evaluator = new ExceptionEvaluator(typeof(Exception), false);
+ m_bufferingForwardingAppender.ActivateOptions();
+ log4net.Config.BasicConfigurator.Configure(m_hierarchy, m_bufferingForwardingAppender);
- ILogger logger = m_hierarchy.GetLogger("TestExceptionEvaluatorNoTriggerOnSubClass");
+ ILogger logger = m_hierarchy.GetLogger("TestExceptionEvaluatorNoTriggerOnSubClass");
- logger.Log(typeof(EvaluatorTest), Level.Warn, "Warn message logged", null);
- logger.Log(typeof(EvaluatorTest), Level.Warn, "Warn message logged", null);
- Assert.AreEqual(0, m_countingAppender.Counter, "Test 2 events buffered");
+ logger.Log(typeof(EvaluatorTest), Level.Warn, "Warn message logged", null);
+ logger.Log(typeof(EvaluatorTest), Level.Warn, "Warn message logged", null);
+ Assert.AreEqual(0, m_countingAppender.Counter, "Test 2 events buffered");
- logger.Log(typeof(EvaluatorTest), Level.Warn, "Warn message logged", new ApplicationException());
- Assert.AreEqual(0, m_countingAppender.Counter, "Test 3 events buffered");
- }
+ logger.Log(typeof(EvaluatorTest), Level.Warn, "Warn message logged", new ApplicationException());
+ Assert.AreEqual(0, m_countingAppender.Counter, "Test 3 events buffered");
+ }
- [Test]
- public void TestInvalidExceptionEvaluator()
- {
- // warning: String is not a subclass of Exception
- m_bufferingForwardingAppender.Evaluator = new ExceptionEvaluator(typeof(String), false);
- m_bufferingForwardingAppender.ActivateOptions();
- log4net.Config.BasicConfigurator.Configure(m_hierarchy, m_bufferingForwardingAppender);
+ [Test]
+ public void TestInvalidExceptionEvaluator()
+ {
+ // warning: String is not a subclass of Exception
+ m_bufferingForwardingAppender.Evaluator = new ExceptionEvaluator(typeof(String), false);
+ m_bufferingForwardingAppender.ActivateOptions();
+ log4net.Config.BasicConfigurator.Configure(m_hierarchy, m_bufferingForwardingAppender);
- ILogger logger = m_hierarchy.GetLogger("TestExceptionEvaluatorNoTriggerOnSubClass");
+ ILogger logger = m_hierarchy.GetLogger("TestExceptionEvaluatorNoTriggerOnSubClass");
- logger.Log(typeof(EvaluatorTest), Level.Warn, "Warn message logged", null);
- logger.Log(typeof(EvaluatorTest), Level.Warn, "Warn message logged", null);
- Assert.AreEqual(0, m_countingAppender.Counter, "Test 2 events buffered");
+ logger.Log(typeof(EvaluatorTest), Level.Warn, "Warn message logged", null);
+ logger.Log(typeof(EvaluatorTest), Level.Warn, "Warn message logged", null);
+ Assert.AreEqual(0, m_countingAppender.Counter, "Test 2 events buffered");
- logger.Log(typeof(EvaluatorTest), Level.Warn, "Warn message logged", new ApplicationException());
- Assert.AreEqual(0, m_countingAppender.Counter, "Test 3 events buffered");
- }
+ logger.Log(typeof(EvaluatorTest), Level.Warn, "Warn message logged", new ApplicationException());
+ Assert.AreEqual(0, m_countingAppender.Counter, "Test 3 events buffered");
+ }
#endif
- }
+ }
}
diff --git a/src/log4net.Tests/Core/FixingTest.cs b/src/log4net.Tests/Core/FixingTest.cs
index d122344..6c5dbb8 100644
--- a/src/log4net.Tests/Core/FixingTest.cs
+++ b/src/log4net.Tests/Core/FixingTest.cs
@@ -29,16 +29,16 @@
namespace log4net.Tests.Core
{
- /// <summary>
- /// </<summary>
- [TestFixture]
- public class FixingTest
- {
+ /// <summary>
+ /// </<summary>
+ [TestFixture]
+ public class FixingTest
+ {
const string TEST_REPOSITORY = "Test Repository";
[OneTimeSetUp]
- public void CreateRepository()
- {
+ public void CreateRepository()
+ {
bool exists = false;
Repository.ILoggerRepository[] repositories = LogManager.GetAllRepositories();
if (repositories != null) {
@@ -53,121 +53,121 @@
LogManager.CreateRepository(TEST_REPOSITORY);
}
- // write-once
- if (Thread.CurrentThread.Name == null)
- {
- Thread.CurrentThread.Name = "Log4Net Test thread";
- }
- }
+ // write-once
+ if (Thread.CurrentThread.Name == null)
+ {
+ Thread.CurrentThread.Name = "Log4Net Test thread";
+ }
+ }
- [Test]
- public void All_ShouldContainAllFlags()
- {
- // Arrange
- // Act
- var allFlags = Enum.GetValues(typeof(FixFlags)).Cast<FixFlags>()
- .Except(new[] { FixFlags.None })
- .ToArray();
- // Assert
- foreach (var flag in allFlags)
- {
- Expect(FixFlags.All & flag)
- .To.Equal(flag, () => $"FixFlags.All does not contain {flag}");
- }
- }
+ [Test]
+ public void All_ShouldContainAllFlags()
+ {
+ // Arrange
+ // Act
+ var allFlags = Enum.GetValues(typeof(FixFlags)).Cast<FixFlags>()
+ .Except(new[] { FixFlags.None })
+ .ToArray();
+ // Assert
+ foreach (var flag in allFlags)
+ {
+ Expect(FixFlags.All & flag)
+ .To.Equal(flag, () => $"FixFlags.All does not contain {flag}");
+ }
+ }
- [Test]
- public void TestUnfixedValues()
- {
- LoggingEventData loggingEventData = BuildStandardEventData();
+ [Test]
+ public void TestUnfixedValues()
+ {
+ LoggingEventData loggingEventData = BuildStandardEventData();
- // LoggingEvents occur at distinct points in time
- LoggingEvent loggingEvent = new LoggingEvent(
- loggingEventData.LocationInfo.GetType(),
- LogManager.GetRepository(TEST_REPOSITORY),
- loggingEventData.LoggerName,
- loggingEventData.Level,
- loggingEventData.Message,
- new Exception("This is the exception"));
+ // LoggingEvents occur at distinct points in time
+ LoggingEvent loggingEvent = new LoggingEvent(
+ loggingEventData.LocationInfo.GetType(),
+ LogManager.GetRepository(TEST_REPOSITORY),
+ loggingEventData.LoggerName,
+ loggingEventData.Level,
+ loggingEventData.Message,
+ new Exception("This is the exception"));
- AssertExpectedLoggingEvent(loggingEvent, loggingEventData);
+ AssertExpectedLoggingEvent(loggingEvent, loggingEventData);
- Assert.AreEqual(FixFlags.None, loggingEvent.Fix, "Fixed Fields is incorrect");
- }
+ Assert.AreEqual(FixFlags.None, loggingEvent.Fix, "Fixed Fields is incorrect");
+ }
- [Test]
- public void TestAllFixedValues()
- {
- LoggingEventData loggingEventData = BuildStandardEventData();
+ [Test]
+ public void TestAllFixedValues()
+ {
+ LoggingEventData loggingEventData = BuildStandardEventData();
- // LoggingEvents occur at distinct points in time
- LoggingEvent loggingEvent = new LoggingEvent(
- loggingEventData.LocationInfo.GetType(),
- LogManager.GetRepository(TEST_REPOSITORY),
- loggingEventData.LoggerName,
- loggingEventData.Level,
- loggingEventData.Message,
- new Exception("This is the exception"));
+ // LoggingEvents occur at distinct points in time
+ LoggingEvent loggingEvent = new LoggingEvent(
+ loggingEventData.LocationInfo.GetType(),
+ LogManager.GetRepository(TEST_REPOSITORY),
+ loggingEventData.LoggerName,
+ loggingEventData.Level,
+ loggingEventData.Message,
+ new Exception("This is the exception"));
- AssertExpectedLoggingEvent(loggingEvent, loggingEventData);
+ AssertExpectedLoggingEvent(loggingEvent, loggingEventData);
- loggingEvent.Fix = FixFlags.All;
+ loggingEvent.Fix = FixFlags.All;
- Assert.AreEqual(FixFlags.LocationInfo | FixFlags.UserName | FixFlags.Identity | FixFlags.Partial | FixFlags.Message | FixFlags.ThreadName | FixFlags.Exception | FixFlags.Domain | FixFlags.Properties, loggingEvent.Fix, "Fixed Fields is incorrect");
- }
+ Assert.AreEqual(FixFlags.LocationInfo | FixFlags.UserName | FixFlags.Identity | FixFlags.Partial | FixFlags.Message | FixFlags.ThreadName | FixFlags.Exception | FixFlags.Domain | FixFlags.Properties, loggingEvent.Fix, "Fixed Fields is incorrect");
+ }
- [Test]
- public void TestNoFixedValues()
- {
- LoggingEventData loggingEventData = BuildStandardEventData();
+ [Test]
+ public void TestNoFixedValues()
+ {
+ LoggingEventData loggingEventData = BuildStandardEventData();
- // LoggingEvents occur at distinct points in time
- LoggingEvent loggingEvent = new LoggingEvent(
- loggingEventData.LocationInfo.GetType(),
- LogManager.GetRepository(TEST_REPOSITORY),
- loggingEventData.LoggerName,
- loggingEventData.Level,
- loggingEventData.Message,
- new Exception("This is the exception"));
+ // LoggingEvents occur at distinct points in time
+ LoggingEvent loggingEvent = new LoggingEvent(
+ loggingEventData.LocationInfo.GetType(),
+ LogManager.GetRepository(TEST_REPOSITORY),
+ loggingEventData.LoggerName,
+ loggingEventData.Level,
+ loggingEventData.Message,
+ new Exception("This is the exception"));
- AssertExpectedLoggingEvent(loggingEvent, loggingEventData);
+ AssertExpectedLoggingEvent(loggingEvent, loggingEventData);
- loggingEvent.Fix = FixFlags.None;
+ loggingEvent.Fix = FixFlags.None;
- Assert.AreEqual(FixFlags.None, loggingEvent.Fix, "Fixed Fields is incorrect");
- }
+ Assert.AreEqual(FixFlags.None, loggingEvent.Fix, "Fixed Fields is incorrect");
+ }
- private static LoggingEventData BuildStandardEventData()
- {
- LoggingEventData loggingEventData = new LoggingEventData();
- loggingEventData.LoggerName = typeof(FixingTest).FullName;
- loggingEventData.Level = Level.Warn;
- loggingEventData.Message = "Logging event works";
- loggingEventData.Domain = "ReallySimpleApp";
- loggingEventData.LocationInfo = new LocationInfo(typeof(FixingTest).Name, "Main", "Class1.cs", "29"); //Completely arbitary
- loggingEventData.ThreadName = Thread.CurrentThread.Name;
- loggingEventData.TimeStampUtc = DateTime.UtcNow.Date;
- loggingEventData.ExceptionString = "Exception occured here";
- loggingEventData.UserName = "TestUser";
- return loggingEventData;
- }
+ private static LoggingEventData BuildStandardEventData()
+ {
+ LoggingEventData loggingEventData = new LoggingEventData();
+ loggingEventData.LoggerName = typeof(FixingTest).FullName;
+ loggingEventData.Level = Level.Warn;
+ loggingEventData.Message = "Logging event works";
+ loggingEventData.Domain = "ReallySimpleApp";
+ loggingEventData.LocationInfo = new LocationInfo(typeof(FixingTest).Name, "Main", "Class1.cs", "29"); //Completely arbitary
+ loggingEventData.ThreadName = Thread.CurrentThread.Name;
+ loggingEventData.TimeStampUtc = DateTime.UtcNow.Date;
+ loggingEventData.ExceptionString = "Exception occured here";
+ loggingEventData.UserName = "TestUser";
+ return loggingEventData;
+ }
- private static void AssertExpectedLoggingEvent(LoggingEvent loggingEvent, LoggingEventData loggingEventData)
- {
- Assert.AreEqual("ReallySimpleApp", loggingEventData.Domain, "Domain is incorrect");
- Assert.AreEqual("System.Exception: This is the exception", loggingEvent.GetExceptionString(), "Exception is incorrect");
- Assert.AreEqual(null, loggingEventData.Identity, "Identity is incorrect");
- Assert.AreEqual(Level.Warn, loggingEventData.Level, "Level is incorrect");
+ private static void AssertExpectedLoggingEvent(LoggingEvent loggingEvent, LoggingEventData loggingEventData)
+ {
+ Assert.AreEqual("ReallySimpleApp", loggingEventData.Domain, "Domain is incorrect");
+ Assert.AreEqual("System.Exception: This is the exception", loggingEvent.GetExceptionString(), "Exception is incorrect");
+ Assert.AreEqual(null, loggingEventData.Identity, "Identity is incorrect");
+ Assert.AreEqual(Level.Warn, loggingEventData.Level, "Level is incorrect");
#if !NETSTANDARD1_3 // NETSTANDARD1_3: LocationInfo can't get method names
- Assert.AreEqual("get_LocationInformation", loggingEvent.LocationInformation.MethodName, "Location Info is incorrect");
+ Assert.AreEqual("get_LocationInformation", loggingEvent.LocationInformation.MethodName, "Location Info is incorrect");
#endif
- Assert.AreEqual("log4net.Tests.Core.FixingTest", loggingEventData.LoggerName, "LoggerName is incorrect");
- Assert.AreEqual(LogManager.GetRepository(TEST_REPOSITORY), loggingEvent.Repository, "Repository is incorrect");
- Assert.AreEqual(Thread.CurrentThread.Name, loggingEventData.ThreadName, "ThreadName is incorrect");
+ Assert.AreEqual("log4net.Tests.Core.FixingTest", loggingEventData.LoggerName, "LoggerName is incorrect");
+ Assert.AreEqual(LogManager.GetRepository(TEST_REPOSITORY), loggingEvent.Repository, "Repository is incorrect");
+ Assert.AreEqual(Thread.CurrentThread.Name, loggingEventData.ThreadName, "ThreadName is incorrect");
// This test is redundant as loggingEventData.TimeStamp is a value type and cannot be null
// Assert.IsNotNull(loggingEventData.TimeStampUtc, "TimeStamp is incorrect");
- Assert.AreEqual("TestUser", loggingEventData.UserName, "UserName is incorrect");
- Assert.AreEqual("Logging event works", loggingEvent.RenderedMessage, "Message is incorrect");
- }
- }
+ Assert.AreEqual("TestUser", loggingEventData.UserName, "UserName is incorrect");
+ Assert.AreEqual("Logging event works", loggingEvent.RenderedMessage, "Message is incorrect");
+ }
+ }
}
\ No newline at end of file
diff --git a/src/log4net.Tests/Core/ShutdownTest.cs b/src/log4net.Tests/Core/ShutdownTest.cs
index 720a321..075a469 100644
--- a/src/log4net.Tests/Core/ShutdownTest.cs
+++ b/src/log4net.Tests/Core/ShutdownTest.cs
@@ -28,46 +28,46 @@
namespace log4net.Tests.Core
{
- /// <summary>
- /// </remarks>
- [TestFixture]
- public class ShutdownTest
- {
- /// <summary>
- /// Test that a repository can be shutdown and reconfigured
- /// </summary>
- [Test]
- public void TestShutdownAndReconfigure()
- {
- // Create unique repository
- ILoggerRepository rep = LogManager.CreateRepository(Guid.NewGuid().ToString());
+ /// <summary>
+ /// </remarks>
+ [TestFixture]
+ public class ShutdownTest
+ {
+ /// <summary>
+ /// Test that a repository can be shutdown and reconfigured
+ /// </summary>
+ [Test]
+ public void TestShutdownAndReconfigure()
+ {
+ // Create unique repository
+ ILoggerRepository rep = LogManager.CreateRepository(Guid.NewGuid().ToString());
- // Create appender and configure repos
- StringAppender stringAppender = new StringAppender();
- stringAppender.Layout = new PatternLayout("%m");
- BasicConfigurator.Configure(rep, stringAppender);
+ // Create appender and configure repos
+ StringAppender stringAppender = new StringAppender();
+ stringAppender.Layout = new PatternLayout("%m");
+ BasicConfigurator.Configure(rep, stringAppender);
- // Get logger from repos
- ILog log1 = LogManager.GetLogger(rep.Name, "logger1");
+ // Get logger from repos
+ ILog log1 = LogManager.GetLogger(rep.Name, "logger1");
- log1.Info("TestMessage1");
- Assert.AreEqual("TestMessage1", stringAppender.GetString(), "Test logging configured");
- stringAppender.Reset();
+ log1.Info("TestMessage1");
+ Assert.AreEqual("TestMessage1", stringAppender.GetString(), "Test logging configured");
+ stringAppender.Reset();
- rep.Shutdown();
+ rep.Shutdown();
- log1.Info("TestMessage2");
- Assert.AreEqual("", stringAppender.GetString(), "Test not logging while shutdown");
- stringAppender.Reset();
+ log1.Info("TestMessage2");
+ Assert.AreEqual("", stringAppender.GetString(), "Test not logging while shutdown");
+ stringAppender.Reset();
- // Create new appender and configure
- stringAppender = new StringAppender();
- stringAppender.Layout = new PatternLayout("%m");
- BasicConfigurator.Configure(rep, stringAppender);
+ // Create new appender and configure
+ stringAppender = new StringAppender();
+ stringAppender.Layout = new PatternLayout("%m");
+ BasicConfigurator.Configure(rep, stringAppender);
- log1.Info("TestMessage3");
- Assert.AreEqual("TestMessage3", stringAppender.GetString(), "Test logging re-configured");
- stringAppender.Reset();
- }
- }
+ log1.Info("TestMessage3");
+ Assert.AreEqual("TestMessage3", stringAppender.GetString(), "Test logging re-configured");
+ stringAppender.Reset();
+ }
+ }
}
\ No newline at end of file
diff --git a/src/log4net.Tests/Core/StringFormatTest.cs b/src/log4net.Tests/Core/StringFormatTest.cs
index 16c7b5a..7aaf9b1 100644
--- a/src/log4net.Tests/Core/StringFormatTest.cs
+++ b/src/log4net.Tests/Core/StringFormatTest.cs
@@ -31,681 +31,681 @@
namespace log4net.Tests.Core
{
- /// <summary>
- /// Used for internal unit testing the <see cref="PatternLayoutTest"/> class.
- /// </summary>
- /// <remarks>
- /// Used for internal unit testing the <see cref="PatternLayoutTest"/> class.
- /// </remarks>
- [TestFixture]
- public class StringFormatTest
- {
+ /// <summary>
+ /// Used for internal unit testing the <see cref="PatternLayoutTest"/> class.
+ /// </summary>
+ /// <remarks>
+ /// Used for internal unit testing the <see cref="PatternLayoutTest"/> class.
+ /// </remarks>
+ [TestFixture]
+ public class StringFormatTest
+ {
#if !NETSTANDARD1_3
- private CultureInfo _currentCulture;
- private CultureInfo _currentUICulture;
+ private CultureInfo _currentCulture;
+ private CultureInfo _currentUICulture;
- [SetUp]
- public void SetUp()
- {
- // set correct thread culture
- _currentCulture = System.Threading.Thread.CurrentThread.CurrentCulture;
- _currentUICulture = System.Threading.Thread.CurrentThread.CurrentUICulture;
- System.Threading.Thread.CurrentThread.CurrentCulture = System.Threading.Thread.CurrentThread.CurrentUICulture = System.Globalization.CultureInfo.InvariantCulture;
- }
+ [SetUp]
+ public void SetUp()
+ {
+ // set correct thread culture
+ _currentCulture = System.Threading.Thread.CurrentThread.CurrentCulture;
+ _currentUICulture = System.Threading.Thread.CurrentThread.CurrentUICulture;
+ System.Threading.Thread.CurrentThread.CurrentCulture = System.Threading.Thread.CurrentThread.CurrentUICulture = System.Globalization.CultureInfo.InvariantCulture;
+ }
- [TearDown]
- public void TearDown()
- {
- // restore previous culture
- System.Threading.Thread.CurrentThread.CurrentCulture = _currentCulture;
- System.Threading.Thread.CurrentThread.CurrentUICulture = _currentUICulture;
- }
+ [TearDown]
+ public void TearDown()
+ {
+ // restore previous culture
+ System.Threading.Thread.CurrentThread.CurrentCulture = _currentCulture;
+ System.Threading.Thread.CurrentThread.CurrentUICulture = _currentUICulture;
+ }
#endif
- [Test]
- public void TestFormatString()
- {
- StringAppender stringAppender = new StringAppender();
- stringAppender.Layout = new PatternLayout("%message");
+ [Test]
+ public void TestFormatString()
+ {
+ StringAppender stringAppender = new StringAppender();
+ stringAppender.Layout = new PatternLayout("%message");
- ILoggerRepository rep = LogManager.CreateRepository(Guid.NewGuid().ToString());
- BasicConfigurator.Configure(rep, stringAppender);
+ ILoggerRepository rep = LogManager.CreateRepository(Guid.NewGuid().ToString());
+ BasicConfigurator.Configure(rep, stringAppender);
- ILog log1 = LogManager.GetLogger(rep.Name, "TestFormatString");
+ ILog log1 = LogManager.GetLogger(rep.Name, "TestFormatString");
- // ***
- log1.Info("TestMessage");
- Assert.AreEqual("TestMessage", stringAppender.GetString(), "Test simple INFO event");
- stringAppender.Reset();
+ // ***
+ log1.Info("TestMessage");
+ Assert.AreEqual("TestMessage", stringAppender.GetString(), "Test simple INFO event");
+ stringAppender.Reset();
- // ***
- log1.DebugFormat("Before {0} After", "Middle");
- Assert.AreEqual("Before Middle After", stringAppender.GetString(), "Test simple formatted DEBUG event");
- stringAppender.Reset();
+ // ***
+ log1.DebugFormat("Before {0} After", "Middle");
+ Assert.AreEqual("Before Middle After", stringAppender.GetString(), "Test simple formatted DEBUG event");
+ stringAppender.Reset();
- // ***
- log1.InfoFormat("Before {0} After", "Middle");
- Assert.AreEqual("Before Middle After", stringAppender.GetString(), "Test simple formatted INFO event");
- stringAppender.Reset();
+ // ***
+ log1.InfoFormat("Before {0} After", "Middle");
+ Assert.AreEqual("Before Middle After", stringAppender.GetString(), "Test simple formatted INFO event");
+ stringAppender.Reset();
- // ***
- log1.WarnFormat("Before {0} After", "Middle");
- Assert.AreEqual("Before Middle After", stringAppender.GetString(), "Test simple formatted WARN event");
- stringAppender.Reset();
+ // ***
+ log1.WarnFormat("Before {0} After", "Middle");
+ Assert.AreEqual("Before Middle After", stringAppender.GetString(), "Test simple formatted WARN event");
+ stringAppender.Reset();
- // ***
- log1.ErrorFormat("Before {0} After", "Middle");
- Assert.AreEqual("Before Middle After", stringAppender.GetString(), "Test simple formatted ERROR event");
- stringAppender.Reset();
+ // ***
+ log1.ErrorFormat("Before {0} After", "Middle");
+ Assert.AreEqual("Before Middle After", stringAppender.GetString(), "Test simple formatted ERROR event");
+ stringAppender.Reset();
- // ***
- log1.FatalFormat("Before {0} After", "Middle");
- Assert.AreEqual("Before Middle After", stringAppender.GetString(), "Test simple formatted FATAL event");
- stringAppender.Reset();
+ // ***
+ log1.FatalFormat("Before {0} After", "Middle");
+ Assert.AreEqual("Before Middle After", stringAppender.GetString(), "Test simple formatted FATAL event");
+ stringAppender.Reset();
- // ***
- log1.InfoFormat("Before {0} After {1}", "Middle", "End");
- Assert.AreEqual("Before Middle After End", stringAppender.GetString(), "Test simple formatted INFO event 2");
- stringAppender.Reset();
+ // ***
+ log1.InfoFormat("Before {0} After {1}", "Middle", "End");
+ Assert.AreEqual("Before Middle After End", stringAppender.GetString(), "Test simple formatted INFO event 2");
+ stringAppender.Reset();
- // ***
- log1.InfoFormat("IGNORE THIS WARNING - EXCEPTION EXPECTED Before {0} After {1} {2}", "Middle", "End");
- Assert.AreEqual(STRING_FORMAT_ERROR, stringAppender.GetString(), "Test formatting error");
- stringAppender.Reset();
- }
+ // ***
+ log1.InfoFormat("IGNORE THIS WARNING - EXCEPTION EXPECTED Before {0} After {1} {2}", "Middle", "End");
+ Assert.AreEqual(STRING_FORMAT_ERROR, stringAppender.GetString(), "Test formatting error");
+ stringAppender.Reset();
+ }
- private const string STRING_FORMAT_ERROR = "<log4net.Error>Exception during StringFormat: Index (zero based) must be greater than or equal to zero and less than the size of the argument list. <format>IGNORE THIS WARNING - EXCEPTION EXPECTED Before {0} After {1} {2}</format><args>{Middle, End}</args></log4net.Error>";
+ private const string STRING_FORMAT_ERROR = "<log4net.Error>Exception during StringFormat: Index (zero based) must be greater than or equal to zero and less than the size of the argument list. <format>IGNORE THIS WARNING - EXCEPTION EXPECTED Before {0} After {1} {2}</format><args>{Middle, End}</args></log4net.Error>";
- [Test]
- public void TestLogFormatApi_Debug()
- {
- StringAppender stringAppender = new StringAppender();
- stringAppender.Layout = new PatternLayout("%level:%message");
+ [Test]
+ public void TestLogFormatApi_Debug()
+ {
+ StringAppender stringAppender = new StringAppender();
+ stringAppender.Layout = new PatternLayout("%level:%message");
- ILoggerRepository rep = LogManager.CreateRepository(Guid.NewGuid().ToString());
- BasicConfigurator.Configure(rep, stringAppender);
+ ILoggerRepository rep = LogManager.CreateRepository(Guid.NewGuid().ToString());
+ BasicConfigurator.Configure(rep, stringAppender);
- ILog log1 = LogManager.GetLogger(rep.Name, "TestLogFormatApi_Debug");
+ ILog log1 = LogManager.GetLogger(rep.Name, "TestLogFormatApi_Debug");
- // ***
- log1.Debug("TestMessage");
- Assert.AreEqual("DEBUG:TestMessage", stringAppender.GetString(), "Test simple DEBUG event 1");
- stringAppender.Reset();
+ // ***
+ log1.Debug("TestMessage");
+ Assert.AreEqual("DEBUG:TestMessage", stringAppender.GetString(), "Test simple DEBUG event 1");
+ stringAppender.Reset();
- // ***
- log1.Debug("TestMessage", null);
- Assert.AreEqual("DEBUG:TestMessage", stringAppender.GetString(), "Test simple DEBUG event 2");
- stringAppender.Reset();
+ // ***
+ log1.Debug("TestMessage", null);
+ Assert.AreEqual("DEBUG:TestMessage", stringAppender.GetString(), "Test simple DEBUG event 2");
+ stringAppender.Reset();
- // ***
- log1.Debug("TestMessage", new Exception("Exception message"));
- Assert.AreEqual("DEBUG:TestMessageSystem.Exception: Exception message" + Environment.NewLine, stringAppender.GetString(), "Test simple DEBUG event 3");
- stringAppender.Reset();
+ // ***
+ log1.Debug("TestMessage", new Exception("Exception message"));
+ Assert.AreEqual("DEBUG:TestMessageSystem.Exception: Exception message" + Environment.NewLine, stringAppender.GetString(), "Test simple DEBUG event 3");
+ stringAppender.Reset();
- // ***
- log1.DebugFormat("a{0}", "1");
- Assert.AreEqual("DEBUG:a1", stringAppender.GetString(), "Test formatted DEBUG event with 1 parm");
- stringAppender.Reset();
+ // ***
+ log1.DebugFormat("a{0}", "1");
+ Assert.AreEqual("DEBUG:a1", stringAppender.GetString(), "Test formatted DEBUG event with 1 parm");
+ stringAppender.Reset();
- // ***
- log1.DebugFormat("a{0}b{1}", "1", "2");
- Assert.AreEqual("DEBUG:a1b2", stringAppender.GetString(), "Test formatted DEBUG event with 2 parm");
- stringAppender.Reset();
+ // ***
+ log1.DebugFormat("a{0}b{1}", "1", "2");
+ Assert.AreEqual("DEBUG:a1b2", stringAppender.GetString(), "Test formatted DEBUG event with 2 parm");
+ stringAppender.Reset();
- // ***
- log1.DebugFormat("a{0}b{1}c{2}", "1", "2", "3");
- Assert.AreEqual("DEBUG:a1b2c3", stringAppender.GetString(), "Test formatted DEBUG event with 3 parm");
- stringAppender.Reset();
+ // ***
+ log1.DebugFormat("a{0}b{1}c{2}", "1", "2", "3");
+ Assert.AreEqual("DEBUG:a1b2c3", stringAppender.GetString(), "Test formatted DEBUG event with 3 parm");
+ stringAppender.Reset();
- // ***
- log1.DebugFormat("a{0}b{1}c{2}d{3}e{4}f", "Q", "W", "E", "R", "T", "Y");
- Assert.AreEqual("DEBUG:aQbWcEdReTf", stringAppender.GetString(), "Test formatted DEBUG event with 5 parms (only 4 used)");
- stringAppender.Reset();
+ // ***
+ log1.DebugFormat("a{0}b{1}c{2}d{3}e{4}f", "Q", "W", "E", "R", "T", "Y");
+ Assert.AreEqual("DEBUG:aQbWcEdReTf", stringAppender.GetString(), "Test formatted DEBUG event with 5 parms (only 4 used)");
+ stringAppender.Reset();
- // ***
- log1.DebugFormat(null, "Before {0} After {1}", "Middle", "End");
- Assert.AreEqual("DEBUG:Before Middle After End", stringAppender.GetString(), "Test formatting with null provider");
- stringAppender.Reset();
+ // ***
+ log1.DebugFormat(null, "Before {0} After {1}", "Middle", "End");
+ Assert.AreEqual("DEBUG:Before Middle After End", stringAppender.GetString(), "Test formatting with null provider");
+ stringAppender.Reset();
- // ***
- log1.DebugFormat(new CultureInfo("en"), "Before {0} After {1}", "Middle", "End");
- Assert.AreEqual("DEBUG:Before Middle After End", stringAppender.GetString(), "Test formatting with 'en' provider");
- stringAppender.Reset();
- }
+ // ***
+ log1.DebugFormat(new CultureInfo("en"), "Before {0} After {1}", "Middle", "End");
+ Assert.AreEqual("DEBUG:Before Middle After End", stringAppender.GetString(), "Test formatting with 'en' provider");
+ stringAppender.Reset();
+ }
- [Test]
- public void TestLogFormatApi_NoDebug()
- {
- StringAppender stringAppender = new StringAppender();
- stringAppender.Threshold = Level.Info;
- stringAppender.Layout = new PatternLayout("%level:%message");
+ [Test]
+ public void TestLogFormatApi_NoDebug()
+ {
+ StringAppender stringAppender = new StringAppender();
+ stringAppender.Threshold = Level.Info;
+ stringAppender.Layout = new PatternLayout("%level:%message");
- ILoggerRepository rep = LogManager.CreateRepository(Guid.NewGuid().ToString());
- BasicConfigurator.Configure(rep, stringAppender);
+ ILoggerRepository rep = LogManager.CreateRepository(Guid.NewGuid().ToString());
+ BasicConfigurator.Configure(rep, stringAppender);
- ILog log1 = LogManager.GetLogger(rep.Name, "TestLogFormatApi_Debug");
+ ILog log1 = LogManager.GetLogger(rep.Name, "TestLogFormatApi_Debug");
- // ***
- log1.Debug("TestMessage");
- Assert.AreEqual("", stringAppender.GetString(), "Test simple DEBUG event 1");
- stringAppender.Reset();
+ // ***
+ log1.Debug("TestMessage");
+ Assert.AreEqual("", stringAppender.GetString(), "Test simple DEBUG event 1");
+ stringAppender.Reset();
- // ***
- log1.Debug("TestMessage", null);
- Assert.AreEqual("", stringAppender.GetString(), "Test simple DEBUG event 2");
- stringAppender.Reset();
+ // ***
+ log1.Debug("TestMessage", null);
+ Assert.AreEqual("", stringAppender.GetString(), "Test simple DEBUG event 2");
+ stringAppender.Reset();
- // ***
- log1.Debug("TestMessage", new Exception("Exception message"));
- Assert.AreEqual("", stringAppender.GetString(), "Test simple DEBUG event 3");
- stringAppender.Reset();
+ // ***
+ log1.Debug("TestMessage", new Exception("Exception message"));
+ Assert.AreEqual("", stringAppender.GetString(), "Test simple DEBUG event 3");
+ stringAppender.Reset();
- // ***
- log1.DebugFormat("a{0}", "1");
- Assert.AreEqual("", stringAppender.GetString(), "Test formatted DEBUG event with 1 parm");
- stringAppender.Reset();
+ // ***
+ log1.DebugFormat("a{0}", "1");
+ Assert.AreEqual("", stringAppender.GetString(), "Test formatted DEBUG event with 1 parm");
+ stringAppender.Reset();
- // ***
- log1.DebugFormat("a{0}b{1}", "1", "2");
- Assert.AreEqual("", stringAppender.GetString(), "Test formatted DEBUG event with 2 parm");
- stringAppender.Reset();
+ // ***
+ log1.DebugFormat("a{0}b{1}", "1", "2");
+ Assert.AreEqual("", stringAppender.GetString(), "Test formatted DEBUG event with 2 parm");
+ stringAppender.Reset();
- // ***
- log1.DebugFormat("a{0}b{1}c{2}", "1", "2", "3");
- Assert.AreEqual("", stringAppender.GetString(), "Test formatted DEBUG event with 3 parm");
- stringAppender.Reset();
+ // ***
+ log1.DebugFormat("a{0}b{1}c{2}", "1", "2", "3");
+ Assert.AreEqual("", stringAppender.GetString(), "Test formatted DEBUG event with 3 parm");
+ stringAppender.Reset();
- // ***
- log1.DebugFormat("a{0}b{1}c{2}d{3}e{4}f", "Q", "W", "E", "R", "T", "Y");
- Assert.AreEqual("", stringAppender.GetString(), "Test formatted DEBUG event with 5 parms (only 4 used)");
- stringAppender.Reset();
+ // ***
+ log1.DebugFormat("a{0}b{1}c{2}d{3}e{4}f", "Q", "W", "E", "R", "T", "Y");
+ Assert.AreEqual("", stringAppender.GetString(), "Test formatted DEBUG event with 5 parms (only 4 used)");
+ stringAppender.Reset();
- // ***
- log1.DebugFormat(null, "Before {0} After {1}", "Middle", "End");
- Assert.AreEqual("", stringAppender.GetString(), "Test formatting with null provider");
- stringAppender.Reset();
+ // ***
+ log1.DebugFormat(null, "Before {0} After {1}", "Middle", "End");
+ Assert.AreEqual("", stringAppender.GetString(), "Test formatting with null provider");
+ stringAppender.Reset();
- // ***
- log1.DebugFormat(new CultureInfo("en"), "Before {0} After {1}", "Middle", "End");
- Assert.AreEqual("", stringAppender.GetString(), "Test formatting with 'en' provider");
- stringAppender.Reset();
- }
+ // ***
+ log1.DebugFormat(new CultureInfo("en"), "Before {0} After {1}", "Middle", "End");
+ Assert.AreEqual("", stringAppender.GetString(), "Test formatting with 'en' provider");
+ stringAppender.Reset();
+ }
- [Test]
- public void TestLogFormatApi_Info()
- {
- StringAppender stringAppender = new StringAppender();
- stringAppender.Layout = new PatternLayout("%level:%message");
+ [Test]
+ public void TestLogFormatApi_Info()
+ {
+ StringAppender stringAppender = new StringAppender();
+ stringAppender.Layout = new PatternLayout("%level:%message");
- ILoggerRepository rep = LogManager.CreateRepository(Guid.NewGuid().ToString());
- BasicConfigurator.Configure(rep, stringAppender);
+ ILoggerRepository rep = LogManager.CreateRepository(Guid.NewGuid().ToString());
+ BasicConfigurator.Configure(rep, stringAppender);
- ILog log1 = LogManager.GetLogger(rep.Name, "TestLogFormatApi_Info");
+ ILog log1 = LogManager.GetLogger(rep.Name, "TestLogFormatApi_Info");
- // ***
- log1.Info("TestMessage");
- Assert.AreEqual("INFO:TestMessage", stringAppender.GetString(), "Test simple INFO event 1");
- stringAppender.Reset();
+ // ***
+ log1.Info("TestMessage");
+ Assert.AreEqual("INFO:TestMessage", stringAppender.GetString(), "Test simple INFO event 1");
+ stringAppender.Reset();
- // ***
- log1.Info("TestMessage", null);
- Assert.AreEqual("INFO:TestMessage", stringAppender.GetString(), "Test simple INFO event 2");
- stringAppender.Reset();
+ // ***
+ log1.Info("TestMessage", null);
+ Assert.AreEqual("INFO:TestMessage", stringAppender.GetString(), "Test simple INFO event 2");
+ stringAppender.Reset();
- // ***
- log1.Info("TestMessage", new Exception("Exception message"));
- Assert.AreEqual("INFO:TestMessageSystem.Exception: Exception message" + Environment.NewLine, stringAppender.GetString(), "Test simple INFO event 3");
- stringAppender.Reset();
+ // ***
+ log1.Info("TestMessage", new Exception("Exception message"));
+ Assert.AreEqual("INFO:TestMessageSystem.Exception: Exception message" + Environment.NewLine, stringAppender.GetString(), "Test simple INFO event 3");
+ stringAppender.Reset();
- // ***
- log1.InfoFormat("a{0}", "1");
- Assert.AreEqual("INFO:a1", stringAppender.GetString(), "Test formatted INFO event with 1 parm");
- stringAppender.Reset();
+ // ***
+ log1.InfoFormat("a{0}", "1");
+ Assert.AreEqual("INFO:a1", stringAppender.GetString(), "Test formatted INFO event with 1 parm");
+ stringAppender.Reset();
- // ***
- log1.InfoFormat("a{0}b{1}", "1", "2");
- Assert.AreEqual("INFO:a1b2", stringAppender.GetString(), "Test formatted INFO event with 2 parm");
- stringAppender.Reset();
+ // ***
+ log1.InfoFormat("a{0}b{1}", "1", "2");
+ Assert.AreEqual("INFO:a1b2", stringAppender.GetString(), "Test formatted INFO event with 2 parm");
+ stringAppender.Reset();
- // ***
- log1.InfoFormat("a{0}b{1}c{2}", "1", "2", "3");
- Assert.AreEqual("INFO:a1b2c3", stringAppender.GetString(), "Test formatted INFO event with 3 parm");
- stringAppender.Reset();
+ // ***
+ log1.InfoFormat("a{0}b{1}c{2}", "1", "2", "3");
+ Assert.AreEqual("INFO:a1b2c3", stringAppender.GetString(), "Test formatted INFO event with 3 parm");
+ stringAppender.Reset();
- // ***
- log1.InfoFormat("a{0}b{1}c{2}d{3}e{4}f", "Q", "W", "E", "R", "T", "Y");
- Assert.AreEqual("INFO:aQbWcEdReTf", stringAppender.GetString(), "Test formatted INFO event with 5 parms (only 4 used)");
- stringAppender.Reset();
+ // ***
+ log1.InfoFormat("a{0}b{1}c{2}d{3}e{4}f", "Q", "W", "E", "R", "T", "Y");
+ Assert.AreEqual("INFO:aQbWcEdReTf", stringAppender.GetString(), "Test formatted INFO event with 5 parms (only 4 used)");
+ stringAppender.Reset();
- // ***
- log1.InfoFormat(null, "Before {0} After {1}", "Middle", "End");
- Assert.AreEqual("INFO:Before Middle After End", stringAppender.GetString(), "Test formatting with null provider");
- stringAppender.Reset();
+ // ***
+ log1.InfoFormat(null, "Before {0} After {1}", "Middle", "End");
+ Assert.AreEqual("INFO:Before Middle After End", stringAppender.GetString(), "Test formatting with null provider");
+ stringAppender.Reset();
- // ***
- log1.InfoFormat(new CultureInfo("en"), "Before {0} After {1}", "Middle", "End");
- Assert.AreEqual("INFO:Before Middle After End", stringAppender.GetString(), "Test formatting with 'en' provider");
- stringAppender.Reset();
- }
+ // ***
+ log1.InfoFormat(new CultureInfo("en"), "Before {0} After {1}", "Middle", "End");
+ Assert.AreEqual("INFO:Before Middle After End", stringAppender.GetString(), "Test formatting with 'en' provider");
+ stringAppender.Reset();
+ }
- [Test]
- public void TestLogFormatApi_NoInfo()
- {
- StringAppender stringAppender = new StringAppender();
- stringAppender.Threshold = Level.Warn;
- stringAppender.Layout = new PatternLayout("%level:%message");
+ [Test]
+ public void TestLogFormatApi_NoInfo()
+ {
+ StringAppender stringAppender = new StringAppender();
+ stringAppender.Threshold = Level.Warn;
+ stringAppender.Layout = new PatternLayout("%level:%message");
- ILoggerRepository rep = LogManager.CreateRepository(Guid.NewGuid().ToString());
- BasicConfigurator.Configure(rep, stringAppender);
+ ILoggerRepository rep = LogManager.CreateRepository(Guid.NewGuid().ToString());
+ BasicConfigurator.Configure(rep, stringAppender);
- ILog log1 = LogManager.GetLogger(rep.Name, "TestLogFormatApi_Info");
+ ILog log1 = LogManager.GetLogger(rep.Name, "TestLogFormatApi_Info");
- // ***
- log1.Info("TestMessage");
- Assert.AreEqual("", stringAppender.GetString(), "Test simple INFO event 1");
- stringAppender.Reset();
+ // ***
+ log1.Info("TestMessage");
+ Assert.AreEqual("", stringAppender.GetString(), "Test simple INFO event 1");
+ stringAppender.Reset();
- // ***
- log1.Info("TestMessage", null);
- Assert.AreEqual("", stringAppender.GetString(), "Test simple INFO event 2");
- stringAppender.Reset();
+ // ***
+ log1.Info("TestMessage", null);
+ Assert.AreEqual("", stringAppender.GetString(), "Test simple INFO event 2");
+ stringAppender.Reset();
- // ***
- log1.Info("TestMessage", new Exception("Exception message"));
- Assert.AreEqual("", stringAppender.GetString(), "Test simple INFO event 3");
- stringAppender.Reset();
+ // ***
+ log1.Info("TestMessage", new Exception("Exception message"));
+ Assert.AreEqual("", stringAppender.GetString(), "Test simple INFO event 3");
+ stringAppender.Reset();
- // ***
- log1.InfoFormat("a{0}", "1");
- Assert.AreEqual("", stringAppender.GetString(), "Test formatted INFO event with 1 parm");
- stringAppender.Reset();
+ // ***
+ log1.InfoFormat("a{0}", "1");
+ Assert.AreEqual("", stringAppender.GetString(), "Test formatted INFO event with 1 parm");
+ stringAppender.Reset();
- // ***
- log1.InfoFormat("a{0}b{1}", "1", "2");
- Assert.AreEqual("", stringAppender.GetString(), "Test formatted INFO event with 2 parm");
- stringAppender.Reset();
+ // ***
+ log1.InfoFormat("a{0}b{1}", "1", "2");
+ Assert.AreEqual("", stringAppender.GetString(), "Test formatted INFO event with 2 parm");
+ stringAppender.Reset();
- // ***
- log1.InfoFormat("a{0}b{1}c{2}", "1", "2", "3");
- Assert.AreEqual("", stringAppender.GetString(), "Test formatted INFO event with 3 parm");
- stringAppender.Reset();
+ // ***
+ log1.InfoFormat("a{0}b{1}c{2}", "1", "2", "3");
+ Assert.AreEqual("", stringAppender.GetString(), "Test formatted INFO event with 3 parm");
+ stringAppender.Reset();
- // ***
- log1.InfoFormat("a{0}b{1}c{2}d{3}e{4}f", "Q", "W", "E", "R", "T", "Y");
- Assert.AreEqual("", stringAppender.GetString(), "Test formatted INFO event with 5 parms (only 4 used)");
- stringAppender.Reset();
+ // ***
+ log1.InfoFormat("a{0}b{1}c{2}d{3}e{4}f", "Q", "W", "E", "R", "T", "Y");
+ Assert.AreEqual("", stringAppender.GetString(), "Test formatted INFO event with 5 parms (only 4 used)");
+ stringAppender.Reset();
- // ***
- log1.InfoFormat(null, "Before {0} After {1}", "Middle", "End");
- Assert.AreEqual("", stringAppender.GetString(), "Test formatting with null provider");
- stringAppender.Reset();
+ // ***
+ log1.InfoFormat(null, "Before {0} After {1}", "Middle", "End");
+ Assert.AreEqual("", stringAppender.GetString(), "Test formatting with null provider");
+ stringAppender.Reset();
- // ***
- log1.InfoFormat(new CultureInfo("en"), "Before {0} After {1}", "Middle", "End");
- Assert.AreEqual("", stringAppender.GetString(), "Test formatting with 'en' provider");
- stringAppender.Reset();
- }
+ // ***
+ log1.InfoFormat(new CultureInfo("en"), "Before {0} After {1}", "Middle", "End");
+ Assert.AreEqual("", stringAppender.GetString(), "Test formatting with 'en' provider");
+ stringAppender.Reset();
+ }
- [Test]
- public void TestLogFormatApi_Warn()
- {
- StringAppender stringAppender = new StringAppender();
- stringAppender.Layout = new PatternLayout("%level:%message");
+ [Test]
+ public void TestLogFormatApi_Warn()
+ {
+ StringAppender stringAppender = new StringAppender();
+ stringAppender.Layout = new PatternLayout("%level:%message");
- ILoggerRepository rep = LogManager.CreateRepository(Guid.NewGuid().ToString());
- BasicConfigurator.Configure(rep, stringAppender);
+ ILoggerRepository rep = LogManager.CreateRepository(Guid.NewGuid().ToString());
+ BasicConfigurator.Configure(rep, stringAppender);
- ILog log1 = LogManager.GetLogger(rep.Name, "TestLogFormatApi_Warn");
+ ILog log1 = LogManager.GetLogger(rep.Name, "TestLogFormatApi_Warn");
- // ***
- log1.Warn("TestMessage");
- Assert.AreEqual("WARN:TestMessage", stringAppender.GetString(), "Test simple WARN event 1");
- stringAppender.Reset();
+ // ***
+ log1.Warn("TestMessage");
+ Assert.AreEqual("WARN:TestMessage", stringAppender.GetString(), "Test simple WARN event 1");
+ stringAppender.Reset();
- // ***
- log1.Warn("TestMessage", null);
- Assert.AreEqual("WARN:TestMessage", stringAppender.GetString(), "Test simple WARN event 2");
- stringAppender.Reset();
+ // ***
+ log1.Warn("TestMessage", null);
+ Assert.AreEqual("WARN:TestMessage", stringAppender.GetString(), "Test simple WARN event 2");
+ stringAppender.Reset();
- // ***
- log1.Warn("TestMessage", new Exception("Exception message"));
- Assert.AreEqual("WARN:TestMessageSystem.Exception: Exception message" + Environment.NewLine, stringAppender.GetString(), "Test simple WARN event 3");
- stringAppender.Reset();
+ // ***
+ log1.Warn("TestMessage", new Exception("Exception message"));
+ Assert.AreEqual("WARN:TestMessageSystem.Exception: Exception message" + Environment.NewLine, stringAppender.GetString(), "Test simple WARN event 3");
+ stringAppender.Reset();
- // ***
- log1.WarnFormat("a{0}", "1");
- Assert.AreEqual("WARN:a1", stringAppender.GetString(), "Test formatted WARN event with 1 parm");
- stringAppender.Reset();
+ // ***
+ log1.WarnFormat("a{0}", "1");
+ Assert.AreEqual("WARN:a1", stringAppender.GetString(), "Test formatted WARN event with 1 parm");
+ stringAppender.Reset();
- // ***
- log1.WarnFormat("a{0}b{1}", "1", "2");
- Assert.AreEqual("WARN:a1b2", stringAppender.GetString(), "Test formatted WARN event with 2 parm");
- stringAppender.Reset();
+ // ***
+ log1.WarnFormat("a{0}b{1}", "1", "2");
+ Assert.AreEqual("WARN:a1b2", stringAppender.GetString(), "Test formatted WARN event with 2 parm");
+ stringAppender.Reset();
- // ***
- log1.WarnFormat("a{0}b{1}c{2}", "1", "2", "3");
- Assert.AreEqual("WARN:a1b2c3", stringAppender.GetString(), "Test formatted WARN event with 3 parm");
- stringAppender.Reset();
+ // ***
+ log1.WarnFormat("a{0}b{1}c{2}", "1", "2", "3");
+ Assert.AreEqual("WARN:a1b2c3", stringAppender.GetString(), "Test formatted WARN event with 3 parm");
+ stringAppender.Reset();
- // ***
- log1.WarnFormat("a{0}b{1}c{2}d{3}e{4}f", "Q", "W", "E", "R", "T", "Y");
- Assert.AreEqual("WARN:aQbWcEdReTf", stringAppender.GetString(), "Test formatted WARN event with 5 parms (only 4 used)");
- stringAppender.Reset();
+ // ***
+ log1.WarnFormat("a{0}b{1}c{2}d{3}e{4}f", "Q", "W", "E", "R", "T", "Y");
+ Assert.AreEqual("WARN:aQbWcEdReTf", stringAppender.GetString(), "Test formatted WARN event with 5 parms (only 4 used)");
+ stringAppender.Reset();
- // ***
- log1.WarnFormat(null, "Before {0} After {1}", "Middle", "End");
- Assert.AreEqual("WARN:Before Middle After End", stringAppender.GetString(), "Test formatting with null provider");
- stringAppender.Reset();
+ // ***
+ log1.WarnFormat(null, "Before {0} After {1}", "Middle", "End");
+ Assert.AreEqual("WARN:Before Middle After End", stringAppender.GetString(), "Test formatting with null provider");
+ stringAppender.Reset();
- // ***
- log1.WarnFormat(new CultureInfo("en"), "Before {0} After {1}", "Middle", "End");
- Assert.AreEqual("WARN:Before Middle After End", stringAppender.GetString(), "Test formatting with 'en' provider");
- stringAppender.Reset();
- }
+ // ***
+ log1.WarnFormat(new CultureInfo("en"), "Before {0} After {1}", "Middle", "End");
+ Assert.AreEqual("WARN:Before Middle After End", stringAppender.GetString(), "Test formatting with 'en' provider");
+ stringAppender.Reset();
+ }
- [Test]
- public void TestLogFormatApi_NoWarn()
- {
- StringAppender stringAppender = new StringAppender();
- stringAppender.Threshold = Level.Error;
- stringAppender.Layout = new PatternLayout("%level:%message");
+ [Test]
+ public void TestLogFormatApi_NoWarn()
+ {
+ StringAppender stringAppender = new StringAppender();
+ stringAppender.Threshold = Level.Error;
+ stringAppender.Layout = new PatternLayout("%level:%message");
- ILoggerRepository rep = LogManager.CreateRepository(Guid.NewGuid().ToString());
- BasicConfigurator.Configure(rep, stringAppender);
+ ILoggerRepository rep = LogManager.CreateRepository(Guid.NewGuid().ToString());
+ BasicConfigurator.Configure(rep, stringAppender);
- ILog log1 = LogManager.GetLogger(rep.Name, "TestLogFormatApi_Warn");
+ ILog log1 = LogManager.GetLogger(rep.Name, "TestLogFormatApi_Warn");
- // ***
- log1.Warn("TestMessage");
- Assert.AreEqual("", stringAppender.GetString(), "Test simple WARN event 1");
- stringAppender.Reset();
+ // ***
+ log1.Warn("TestMessage");
+ Assert.AreEqual("", stringAppender.GetString(), "Test simple WARN event 1");
+ stringAppender.Reset();
- // ***
- log1.Warn("TestMessage", null);
- Assert.AreEqual("", stringAppender.GetString(), "Test simple WARN event 2");
- stringAppender.Reset();
+ // ***
+ log1.Warn("TestMessage", null);
+ Assert.AreEqual("", stringAppender.GetString(), "Test simple WARN event 2");
+ stringAppender.Reset();
- // ***
- log1.Warn("TestMessage", new Exception("Exception message"));
- Assert.AreEqual("", stringAppender.GetString(), "Test simple WARN event 3");
- stringAppender.Reset();
+ // ***
+ log1.Warn("TestMessage", new Exception("Exception message"));
+ Assert.AreEqual("", stringAppender.GetString(), "Test simple WARN event 3");
+ stringAppender.Reset();
- // ***
- log1.WarnFormat("a{0}", "1");
- Assert.AreEqual("", stringAppender.GetString(), "Test formatted WARN event with 1 parm");
- stringAppender.Reset();
+ // ***
+ log1.WarnFormat("a{0}", "1");
+ Assert.AreEqual("", stringAppender.GetString(), "Test formatted WARN event with 1 parm");
+ stringAppender.Reset();
- // ***
- log1.WarnFormat("a{0}b{1}", "1", "2");
- Assert.AreEqual("", stringAppender.GetString(), "Test formatted WARN event with 2 parm");
- stringAppender.Reset();
+ // ***
+ log1.WarnFormat("a{0}b{1}", "1", "2");
+ Assert.AreEqual("", stringAppender.GetString(), "Test formatted WARN event with 2 parm");
+ stringAppender.Reset();
- // ***
- log1.WarnFormat("a{0}b{1}c{2}", "1", "2", "3");
- Assert.AreEqual("", stringAppender.GetString(), "Test formatted WARN event with 3 parm");
- stringAppender.Reset();
+ // ***
+ log1.WarnFormat("a{0}b{1}c{2}", "1", "2", "3");
+ Assert.AreEqual("", stringAppender.GetString(), "Test formatted WARN event with 3 parm");
+ stringAppender.Reset();
- // ***
- log1.WarnFormat("a{0}b{1}c{2}d{3}e{4}f", "Q", "W", "E", "R", "T", "Y");
- Assert.AreEqual("", stringAppender.GetString(), "Test formatted WARN event with 5 parms (only 4 used)");
- stringAppender.Reset();
+ // ***
+ log1.WarnFormat("a{0}b{1}c{2}d{3}e{4}f", "Q", "W", "E", "R", "T", "Y");
+ Assert.AreEqual("", stringAppender.GetString(), "Test formatted WARN event with 5 parms (only 4 used)");
+ stringAppender.Reset();
- // ***
- log1.WarnFormat(null, "Before {0} After {1}", "Middle", "End");
- Assert.AreEqual("", stringAppender.GetString(), "Test formatting with null provider");
- stringAppender.Reset();
+ // ***
+ log1.WarnFormat(null, "Before {0} After {1}", "Middle", "End");
+ Assert.AreEqual("", stringAppender.GetString(), "Test formatting with null provider");
+ stringAppender.Reset();
- // ***
- log1.WarnFormat(new CultureInfo("en"), "Before {0} After {1}", "Middle", "End");
- Assert.AreEqual("", stringAppender.GetString(), "Test formatting with 'en' provider");
- stringAppender.Reset();
- }
+ // ***
+ log1.WarnFormat(new CultureInfo("en"), "Before {0} After {1}", "Middle", "End");
+ Assert.AreEqual("", stringAppender.GetString(), "Test formatting with 'en' provider");
+ stringAppender.Reset();
+ }
- [Test]
- public void TestLogFormatApi_Error()
- {
- StringAppender stringAppender = new StringAppender();
- stringAppender.Layout = new PatternLayout("%level:%message");
+ [Test]
+ public void TestLogFormatApi_Error()
+ {
+ StringAppender stringAppender = new StringAppender();
+ stringAppender.Layout = new PatternLayout("%level:%message");
- ILoggerRepository rep = LogManager.CreateRepository(Guid.NewGuid().ToString());
- BasicConfigurator.Configure(rep, stringAppender);
+ ILoggerRepository rep = LogManager.CreateRepository(Guid.NewGuid().ToString());
+ BasicConfigurator.Configure(rep, stringAppender);
- ILog log1 = LogManager.GetLogger(rep.Name, "TestLogFormatApi_Error");
+ ILog log1 = LogManager.GetLogger(rep.Name, "TestLogFormatApi_Error");
- // ***
- log1.Error("TestMessage");
- Assert.AreEqual("ERROR:TestMessage", stringAppender.GetString(), "Test simple ERROR event 1");
- stringAppender.Reset();
+ // ***
+ log1.Error("TestMessage");
+ Assert.AreEqual("ERROR:TestMessage", stringAppender.GetString(), "Test simple ERROR event 1");
+ stringAppender.Reset();
- // ***
- log1.Error("TestMessage", null);
- Assert.AreEqual("ERROR:TestMessage", stringAppender.GetString(), "Test simple ERROR event 2");
- stringAppender.Reset();
+ // ***
+ log1.Error("TestMessage", null);
+ Assert.AreEqual("ERROR:TestMessage", stringAppender.GetString(), "Test simple ERROR event 2");
+ stringAppender.Reset();
- // ***
- log1.Error("TestMessage", new Exception("Exception message"));
- Assert.AreEqual("ERROR:TestMessageSystem.Exception: Exception message" + Environment.NewLine, stringAppender.GetString(), "Test simple ERROR event 3");
- stringAppender.Reset();
+ // ***
+ log1.Error("TestMessage", new Exception("Exception message"));
+ Assert.AreEqual("ERROR:TestMessageSystem.Exception: Exception message" + Environment.NewLine, stringAppender.GetString(), "Test simple ERROR event 3");
+ stringAppender.Reset();
- // ***
- log1.ErrorFormat("a{0}", "1");
- Assert.AreEqual("ERROR:a1", stringAppender.GetString(), "Test formatted ERROR event with 1 parm");
- stringAppender.Reset();
+ // ***
+ log1.ErrorFormat("a{0}", "1");
+ Assert.AreEqual("ERROR:a1", stringAppender.GetString(), "Test formatted ERROR event with 1 parm");
+ stringAppender.Reset();
- // ***
- log1.ErrorFormat("a{0}b{1}", "1", "2");
- Assert.AreEqual("ERROR:a1b2", stringAppender.GetString(), "Test formatted ERROR event with 2 parm");
- stringAppender.Reset();
+ // ***
+ log1.ErrorFormat("a{0}b{1}", "1", "2");
+ Assert.AreEqual("ERROR:a1b2", stringAppender.GetString(), "Test formatted ERROR event with 2 parm");
+ stringAppender.Reset();
- // ***
- log1.ErrorFormat("a{0}b{1}c{2}", "1", "2", "3");
- Assert.AreEqual("ERROR:a1b2c3", stringAppender.GetString(), "Test formatted ERROR event with 3 parm");
- stringAppender.Reset();
+ // ***
+ log1.ErrorFormat("a{0}b{1}c{2}", "1", "2", "3");
+ Assert.AreEqual("ERROR:a1b2c3", stringAppender.GetString(), "Test formatted ERROR event with 3 parm");
+ stringAppender.Reset();
- // ***
- log1.ErrorFormat("a{0}b{1}c{2}d{3}e{4}f", "Q", "W", "E", "R", "T", "Y");
- Assert.AreEqual("ERROR:aQbWcEdReTf", stringAppender.GetString(), "Test formatted ERROR event with 5 parms (only 4 used)");
- stringAppender.Reset();
+ // ***
+ log1.ErrorFormat("a{0}b{1}c{2}d{3}e{4}f", "Q", "W", "E", "R", "T", "Y");
+ Assert.AreEqual("ERROR:aQbWcEdReTf", stringAppender.GetString(), "Test formatted ERROR event with 5 parms (only 4 used)");
+ stringAppender.Reset();
- // ***
- log1.ErrorFormat(null, "Before {0} After {1}", "Middle", "End");
- Assert.AreEqual("ERROR:Before Middle After End", stringAppender.GetString(), "Test formatting with null provider");
- stringAppender.Reset();
+ // ***
+ log1.ErrorFormat(null, "Before {0} After {1}", "Middle", "End");
+ Assert.AreEqual("ERROR:Before Middle After End", stringAppender.GetString(), "Test formatting with null provider");
+ stringAppender.Reset();
- // ***
- log1.ErrorFormat(new CultureInfo("en"), "Before {0} After {1}", "Middle", "End");
- Assert.AreEqual("ERROR:Before Middle After End", stringAppender.GetString(), "Test formatting with 'en' provider");
- stringAppender.Reset();
- }
+ // ***
+ log1.ErrorFormat(new CultureInfo("en"), "Before {0} After {1}", "Middle", "End");
+ Assert.AreEqual("ERROR:Before Middle After End", stringAppender.GetString(), "Test formatting with 'en' provider");
+ stringAppender.Reset();
+ }
- [Test]
- public void TestLogFormatApi_NoError()
- {
- StringAppender stringAppender = new StringAppender();
- stringAppender.Threshold = Level.Fatal;
- stringAppender.Layout = new PatternLayout("%level:%message");
+ [Test]
+ public void TestLogFormatApi_NoError()
+ {
+ StringAppender stringAppender = new StringAppender();
+ stringAppender.Threshold = Level.Fatal;
+ stringAppender.Layout = new PatternLayout("%level:%message");
- ILoggerRepository rep = LogManager.CreateRepository(Guid.NewGuid().ToString());
- BasicConfigurator.Configure(rep, stringAppender);
+ ILoggerRepository rep = LogManager.CreateRepository(Guid.NewGuid().ToString());
+ BasicConfigurator.Configure(rep, stringAppender);
- ILog log1 = LogManager.GetLogger(rep.Name, "TestLogFormatApi_Error");
+ ILog log1 = LogManager.GetLogger(rep.Name, "TestLogFormatApi_Error");
- // ***
- log1.Error("TestMessage");
- Assert.AreEqual("", stringAppender.GetString(), "Test simple ERROR event 1");
- stringAppender.Reset();
+ // ***
+ log1.Error("TestMessage");
+ Assert.AreEqual("", stringAppender.GetString(), "Test simple ERROR event 1");
+ stringAppender.Reset();
- // ***
- log1.Error("TestMessage", null);
- Assert.AreEqual("", stringAppender.GetString(), "Test simple ERROR event 2");
- stringAppender.Reset();
+ // ***
+ log1.Error("TestMessage", null);
+ Assert.AreEqual("", stringAppender.GetString(), "Test simple ERROR event 2");
+ stringAppender.Reset();
- // ***
- log1.Error("TestMessage", new Exception("Exception message"));
- Assert.AreEqual("", stringAppender.GetString(), "Test simple ERROR event 3");
- stringAppender.Reset();
+ // ***
+ log1.Error("TestMessage", new Exception("Exception message"));
+ Assert.AreEqual("", stringAppender.GetString(), "Test simple ERROR event 3");
+ stringAppender.Reset();
- // ***
- log1.ErrorFormat("a{0}", "1");
- Assert.AreEqual("", stringAppender.GetString(), "Test formatted ERROR event with 1 parm");
- stringAppender.Reset();
+ // ***
+ log1.ErrorFormat("a{0}", "1");
+ Assert.AreEqual("", stringAppender.GetString(), "Test formatted ERROR event with 1 parm");
+ stringAppender.Reset();
- // ***
- log1.ErrorFormat("a{0}b{1}", "1", "2");
- Assert.AreEqual("", stringAppender.GetString(), "Test formatted ERROR event with 2 parm");
- stringAppender.Reset();
+ // ***
+ log1.ErrorFormat("a{0}b{1}", "1", "2");
+ Assert.AreEqual("", stringAppender.GetString(), "Test formatted ERROR event with 2 parm");
+ stringAppender.Reset();
- // ***
- log1.ErrorFormat("a{0}b{1}c{2}", "1", "2", "3");
- Assert.AreEqual("", stringAppender.GetString(), "Test formatted ERROR event with 3 parm");
- stringAppender.Reset();
+ // ***
+ log1.ErrorFormat("a{0}b{1}c{2}", "1", "2", "3");
+ Assert.AreEqual("", stringAppender.GetString(), "Test formatted ERROR event with 3 parm");
+ stringAppender.Reset();
- // ***
- log1.ErrorFormat("a{0}b{1}c{2}d{3}e{4}f", "Q", "W", "E", "R", "T", "Y");
- Assert.AreEqual("", stringAppender.GetString(), "Test formatted ERROR event with 5 parms (only 4 used)");
- stringAppender.Reset();
+ // ***
+ log1.ErrorFormat("a{0}b{1}c{2}d{3}e{4}f", "Q", "W", "E", "R", "T", "Y");
+ Assert.AreEqual("", stringAppender.GetString(), "Test formatted ERROR event with 5 parms (only 4 used)");
+ stringAppender.Reset();
- // ***
- log1.ErrorFormat(null, "Before {0} After {1}", "Middle", "End");
- Assert.AreEqual("", stringAppender.GetString(), "Test formatting with null provider");
- stringAppender.Reset();
+ // ***
+ log1.ErrorFormat(null, "Before {0} After {1}", "Middle", "End");
+ Assert.AreEqual("", stringAppender.GetString(), "Test formatting with null provider");
+ stringAppender.Reset();
- // ***
- log1.ErrorFormat(new CultureInfo("en"), "Before {0} After {1}", "Middle", "End");
- Assert.AreEqual("", stringAppender.GetString(), "Test formatting with 'en' provider");
- stringAppender.Reset();
- }
+ // ***
+ log1.ErrorFormat(new CultureInfo("en"), "Before {0} After {1}", "Middle", "End");
+ Assert.AreEqual("", stringAppender.GetString(), "Test formatting with 'en' provider");
+ stringAppender.Reset();
+ }
- [Test]
- public void TestLogFormatApi_Fatal()
- {
- StringAppender stringAppender = new StringAppender();
- stringAppender.Layout = new PatternLayout("%level:%message");
+ [Test]
+ public void TestLogFormatApi_Fatal()
+ {
+ StringAppender stringAppender = new StringAppender();
+ stringAppender.Layout = new PatternLayout("%level:%message");
- ILoggerRepository rep = LogManager.CreateRepository(Guid.NewGuid().ToString());
- BasicConfigurator.Configure(rep, stringAppender);
+ ILoggerRepository rep = LogManager.CreateRepository(Guid.NewGuid().ToString());
+ BasicConfigurator.Configure(rep, stringAppender);
- ILog log1 = LogManager.GetLogger(rep.Name, "TestLogFormatApi_Fatal");
+ ILog log1 = LogManager.GetLogger(rep.Name, "TestLogFormatApi_Fatal");
- // ***
- log1.Fatal("TestMessage");
- Assert.AreEqual("FATAL:TestMessage", stringAppender.GetString(), "Test simple FATAL event 1");
- stringAppender.Reset();
+ // ***
+ log1.Fatal("TestMessage");
+ Assert.AreEqual("FATAL:TestMessage", stringAppender.GetString(), "Test simple FATAL event 1");
+ stringAppender.Reset();
- // ***
- log1.Fatal("TestMessage", null);
- Assert.AreEqual("FATAL:TestMessage", stringAppender.GetString(), "Test simple FATAL event 2");
- stringAppender.Reset();
+ // ***
+ log1.Fatal("TestMessage", null);
+ Assert.AreEqual("FATAL:TestMessage", stringAppender.GetString(), "Test simple FATAL event 2");
+ stringAppender.Reset();
- // ***
- log1.Fatal("TestMessage", new Exception("Exception message"));
- Assert.AreEqual("FATAL:TestMessageSystem.Exception: Exception message" + Environment.NewLine, stringAppender.GetString(), "Test simple FATAL event 3");
- stringAppender.Reset();
+ // ***
+ log1.Fatal("TestMessage", new Exception("Exception message"));
+ Assert.AreEqual("FATAL:TestMessageSystem.Exception: Exception message" + Environment.NewLine, stringAppender.GetString(), "Test simple FATAL event 3");
+ stringAppender.Reset();
- // ***
- log1.FatalFormat("a{0}", "1");
- Assert.AreEqual("FATAL:a1", stringAppender.GetString(), "Test formatted FATAL event with 1 parm");
- stringAppender.Reset();
+ // ***
+ log1.FatalFormat("a{0}", "1");
+ Assert.AreEqual("FATAL:a1", stringAppender.GetString(), "Test formatted FATAL event with 1 parm");
+ stringAppender.Reset();
- // ***
- log1.FatalFormat("a{0}b{1}", "1", "2");
- Assert.AreEqual("FATAL:a1b2", stringAppender.GetString(), "Test formatted FATAL event with 2 parm");
- stringAppender.Reset();
+ // ***
+ log1.FatalFormat("a{0}b{1}", "1", "2");
+ Assert.AreEqual("FATAL:a1b2", stringAppender.GetString(), "Test formatted FATAL event with 2 parm");
+ stringAppender.Reset();
- // ***
- log1.FatalFormat("a{0}b{1}c{2}", "1", "2", "3");
- Assert.AreEqual("FATAL:a1b2c3", stringAppender.GetString(), "Test formatted FATAL event with 3 parm");
- stringAppender.Reset();
+ // ***
+ log1.FatalFormat("a{0}b{1}c{2}", "1", "2", "3");
+ Assert.AreEqual("FATAL:a1b2c3", stringAppender.GetString(), "Test formatted FATAL event with 3 parm");
+ stringAppender.Reset();
- // ***
- log1.FatalFormat("a{0}b{1}c{2}d{3}e{4}f", "Q", "W", "E", "R", "T", "Y");
- Assert.AreEqual("FATAL:aQbWcEdReTf", stringAppender.GetString(), "Test formatted FATAL event with 5 parms (only 4 used)");
- stringAppender.Reset();
+ // ***
+ log1.FatalFormat("a{0}b{1}c{2}d{3}e{4}f", "Q", "W", "E", "R", "T", "Y");
+ Assert.AreEqual("FATAL:aQbWcEdReTf", stringAppender.GetString(), "Test formatted FATAL event with 5 parms (only 4 used)");
+ stringAppender.Reset();
- // ***
- log1.FatalFormat(null, "Before {0} After {1}", "Middle", "End");
- Assert.AreEqual("FATAL:Before Middle After End", stringAppender.GetString(), "Test formatting with null provider");
- stringAppender.Reset();
+ // ***
+ log1.FatalFormat(null, "Before {0} After {1}", "Middle", "End");
+ Assert.AreEqual("FATAL:Before Middle After End", stringAppender.GetString(), "Test formatting with null provider");
+ stringAppender.Reset();
- // ***
- log1.FatalFormat(new CultureInfo("en"), "Before {0} After {1}", "Middle", "End");
- Assert.AreEqual("FATAL:Before Middle After End", stringAppender.GetString(), "Test formatting with 'en' provider");
- stringAppender.Reset();
- }
+ // ***
+ log1.FatalFormat(new CultureInfo("en"), "Before {0} After {1}", "Middle", "End");
+ Assert.AreEqual("FATAL:Before Middle After End", stringAppender.GetString(), "Test formatting with 'en' provider");
+ stringAppender.Reset();
+ }
- [Test]
- public void TestLogFormatApi_NoFatal()
- {
- StringAppender stringAppender = new StringAppender();
- stringAppender.Threshold = Level.Off;
- stringAppender.Layout = new PatternLayout("%level:%message");
+ [Test]
+ public void TestLogFormatApi_NoFatal()
+ {
+ StringAppender stringAppender = new StringAppender();
+ stringAppender.Threshold = Level.Off;
+ stringAppender.Layout = new PatternLayout("%level:%message");
- ILoggerRepository rep = LogManager.CreateRepository(Guid.NewGuid().ToString());
- BasicConfigurator.Configure(rep, stringAppender);
+ ILoggerRepository rep = LogManager.CreateRepository(Guid.NewGuid().ToString());
+ BasicConfigurator.Configure(rep, stringAppender);
- ILog log1 = LogManager.GetLogger(rep.Name, "TestLogFormatApi_Fatal");
+ ILog log1 = LogManager.GetLogger(rep.Name, "TestLogFormatApi_Fatal");
- // ***
- log1.Fatal("TestMessage");
- Assert.AreEqual("", stringAppender.GetString(), "Test simple FATAL event 1");
- stringAppender.Reset();
+ // ***
+ log1.Fatal("TestMessage");
+ Assert.AreEqual("", stringAppender.GetString(), "Test simple FATAL event 1");
+ stringAppender.Reset();
- // ***
- log1.Fatal("TestMessage", null);
- Assert.AreEqual("", stringAppender.GetString(), "Test simple FATAL event 2");
- stringAppender.Reset();
+ // ***
+ log1.Fatal("TestMessage", null);
+ Assert.AreEqual("", stringAppender.GetString(), "Test simple FATAL event 2");
+ stringAppender.Reset();
- // ***
- log1.Fatal("TestMessage", new Exception("Exception message"));
- Assert.AreEqual("", stringAppender.GetString(), "Test simple FATAL event 3");
- stringAppender.Reset();
+ // ***
+ log1.Fatal("TestMessage", new Exception("Exception message"));
+ Assert.AreEqual("", stringAppender.GetString(), "Test simple FATAL event 3");
+ stringAppender.Reset();
- // ***
- log1.FatalFormat("a{0}", "1");
- Assert.AreEqual("", stringAppender.GetString(), "Test formatted FATAL event with 1 parm");
- stringAppender.Reset();
+ // ***
+ log1.FatalFormat("a{0}", "1");
+ Assert.AreEqual("", stringAppender.GetString(), "Test formatted FATAL event with 1 parm");
+ stringAppender.Reset();
- // ***
- log1.FatalFormat("a{0}b{1}", "1", "2");
- Assert.AreEqual("", stringAppender.GetString(), "Test formatted FATAL event with 2 parm");
- stringAppender.Reset();
+ // ***
+ log1.FatalFormat("a{0}b{1}", "1", "2");
+ Assert.AreEqual("", stringAppender.GetString(), "Test formatted FATAL event with 2 parm");
+ stringAppender.Reset();
- // ***
- log1.FatalFormat("a{0}b{1}c{2}", "1", "2", "3");
- Assert.AreEqual("", stringAppender.GetString(), "Test formatted FATAL event with 3 parm");
- stringAppender.Reset();
+ // ***
+ log1.FatalFormat("a{0}b{1}c{2}", "1", "2", "3");
+ Assert.AreEqual("", stringAppender.GetString(), "Test formatted FATAL event with 3 parm");
+ stringAppender.Reset();
- // ***
- log1.FatalFormat("a{0}b{1}c{2}d{3}e{4}f", "Q", "W", "E", "R", "T", "Y");
- Assert.AreEqual("", stringAppender.GetString(), "Test formatted FATAL event with 5 parms (only 4 used)");
- stringAppender.Reset();
+ // ***
+ log1.FatalFormat("a{0}b{1}c{2}d{3}e{4}f", "Q", "W", "E", "R", "T", "Y");
+ Assert.AreEqual("", stringAppender.GetString(), "Test formatted FATAL event with 5 parms (only 4 used)");
+ stringAppender.Reset();
- // ***
- log1.FatalFormat(null, "Before {0} After {1}", "Middle", "End");
- Assert.AreEqual("", stringAppender.GetString(), "Test formatting with null provider");
- stringAppender.Reset();
+ // ***
+ log1.FatalFormat(null, "Before {0} After {1}", "Middle", "End");
+ Assert.AreEqual("", stringAppender.GetString(), "Test formatting with null provider");
+ stringAppender.Reset();
- // ***
- log1.FatalFormat(new CultureInfo("en"), "Before {0} After {1}", "Middle", "End");
- Assert.AreEqual("", stringAppender.GetString(), "Test formatting with 'en' provider");
- stringAppender.Reset();
- }
- }
+ // ***
+ log1.FatalFormat(new CultureInfo("en"), "Before {0} After {1}", "Middle", "End");
+ Assert.AreEqual("", stringAppender.GetString(), "Test formatting with 'en' provider");
+ stringAppender.Reset();
+ }
+ }
}
\ No newline at end of file
diff --git a/src/log4net.Tests/Hierarchy/Hierarchy.cs b/src/log4net.Tests/Hierarchy/Hierarchy.cs
index 3755d7b..7daa95e 100644
--- a/src/log4net.Tests/Hierarchy/Hierarchy.cs
+++ b/src/log4net.Tests/Hierarchy/Hierarchy.cs
@@ -100,7 +100,7 @@
}
[Test]
- // LOG4NET-343
+ // LOG4NET-343
public void LoggerNameCanConsistOfASingleDot()
{
XmlDocument log4netConfig = new XmlDocument();
diff --git a/src/log4net.Tests/Hierarchy/Logger.cs b/src/log4net.Tests/Hierarchy/Logger.cs
index aa51d89..3d383f7 100644
--- a/src/log4net.Tests/Hierarchy/Logger.cs
+++ b/src/log4net.Tests/Hierarchy/Logger.cs
@@ -30,291 +30,291 @@
namespace log4net.Tests.Hierarchy
{
- /// <summary>
- /// Used for internal unit testing the <see cref="Logger"/> class.
- /// </summary>
- /// <remarks>
- /// Internal unit test. Uses the NUnit test harness.
- /// </remarks>
- [TestFixture]
- public class LoggerTest
- {
- private Logger log;
+ /// <summary>
+ /// Used for internal unit testing the <see cref="Logger"/> class.
+ /// </summary>
+ /// <remarks>
+ /// Internal unit test. Uses the NUnit test harness.
+ /// </remarks>
+ [TestFixture]
+ public class LoggerTest
+ {
+ private Logger log;
- // A short message.
- private static string MSG = "M";
+ // A short message.
+ private static string MSG = "M";
- /// <summary>
- /// Any initialization that happens before each test can
- /// go here
- /// </summary>
- [SetUp]
- public void SetUp()
- {
- }
+ /// <summary>
+ /// Any initialization that happens before each test can
+ /// go here
+ /// </summary>
+ [SetUp]
+ public void SetUp()
+ {
+ }
- /// <summary>
- /// Any steps that happen after each test go here
- /// </summary>
- [TearDown]
- public void TearDown()
- {
- // Regular users should not use the clear method lightly!
- Utils.GetRepository().ResetConfiguration();
- Utils.GetRepository().Shutdown();
- ((Repository.Hierarchy.Hierarchy)Utils.GetRepository()).Clear();
- }
+ /// <summary>
+ /// Any steps that happen after each test go here
+ /// </summary>
+ [TearDown]
+ public void TearDown()
+ {
+ // Regular users should not use the clear method lightly!
+ Utils.GetRepository().ResetConfiguration();
+ Utils.GetRepository().Shutdown();
+ ((Repository.Hierarchy.Hierarchy)Utils.GetRepository()).Clear();
+ }
- /// <summary>
- /// Add an appender and see if it can be retrieved.
- /// </summary>
- [Test]
- public void TestAppender1()
- {
- log = (Logger)Utils.GetLogger("test").Logger;
- CountingAppender a1 = new CountingAppender();
- a1.Name = "testAppender1";
- log.AddAppender(a1);
+ /// <summary>
+ /// Add an appender and see if it can be retrieved.
+ /// </summary>
+ [Test]
+ public void TestAppender1()
+ {
+ log = (Logger)Utils.GetLogger("test").Logger;
+ CountingAppender a1 = new CountingAppender();
+ a1.Name = "testAppender1";
+ log.AddAppender(a1);
- IEnumerator enumAppenders = ((IEnumerable)log.Appenders).GetEnumerator();
- Assert.IsTrue(enumAppenders.MoveNext());
- CountingAppender aHat = (CountingAppender)enumAppenders.Current;
- Assert.AreEqual(a1, aHat);
- }
+ IEnumerator enumAppenders = ((IEnumerable)log.Appenders).GetEnumerator();
+ Assert.IsTrue(enumAppenders.MoveNext());
+ CountingAppender aHat = (CountingAppender)enumAppenders.Current;
+ Assert.AreEqual(a1, aHat);
+ }
- /// <summary>
- /// Add an appender X, Y, remove X and check if Y is the only
- /// remaining appender.
- /// </summary>
- [Test]
- public void TestAppender2()
- {
- CountingAppender a1 = new CountingAppender();
- a1.Name = "testAppender2.1";
- CountingAppender a2 = new CountingAppender();
- a2.Name = "testAppender2.2";
+ /// <summary>
+ /// Add an appender X, Y, remove X and check if Y is the only
+ /// remaining appender.
+ /// </summary>
+ [Test]
+ public void TestAppender2()
+ {
+ CountingAppender a1 = new CountingAppender();
+ a1.Name = "testAppender2.1";
+ CountingAppender a2 = new CountingAppender();
+ a2.Name = "testAppender2.2";
- log = (Logger)Utils.GetLogger("test").Logger;
- log.AddAppender(a1);
- log.AddAppender(a2);
+ log = (Logger)Utils.GetLogger("test").Logger;
+ log.AddAppender(a1);
+ log.AddAppender(a2);
- CountingAppender aHat = (CountingAppender)log.GetAppender(a1.Name);
- Assert.AreEqual(a1, aHat);
+ CountingAppender aHat = (CountingAppender)log.GetAppender(a1.Name);
+ Assert.AreEqual(a1, aHat);
- aHat = (CountingAppender)log.GetAppender(a2.Name);
- Assert.AreEqual(a2, aHat);
+ aHat = (CountingAppender)log.GetAppender(a2.Name);
+ Assert.AreEqual(a2, aHat);
- log.RemoveAppender("testAppender2.1");
+ log.RemoveAppender("testAppender2.1");
- IEnumerator enumAppenders = ((IEnumerable)log.Appenders).GetEnumerator();
- Assert.IsTrue(enumAppenders.MoveNext());
- aHat = (CountingAppender)enumAppenders.Current;
- Assert.AreEqual(a2, aHat);
- Assert.IsTrue(!enumAppenders.MoveNext());
+ IEnumerator enumAppenders = ((IEnumerable)log.Appenders).GetEnumerator();
+ Assert.IsTrue(enumAppenders.MoveNext());
+ aHat = (CountingAppender)enumAppenders.Current;
+ Assert.AreEqual(a2, aHat);
+ Assert.IsTrue(!enumAppenders.MoveNext());
- aHat = (CountingAppender)log.GetAppender(a2.Name);
- Assert.AreEqual(a2, aHat);
- }
+ aHat = (CountingAppender)log.GetAppender(a2.Name);
+ Assert.AreEqual(a2, aHat);
+ }
- /// <summary>
- /// Test if logger a.b inherits its appender from a.
- /// </summary>
- [Test]
- public void TestAdditivity1()
- {
- Logger a = (Logger)Utils.GetLogger("a").Logger;
- Logger ab = (Logger)Utils.GetLogger("a.b").Logger;
- CountingAppender ca = new CountingAppender();
+ /// <summary>
+ /// Test if logger a.b inherits its appender from a.
+ /// </summary>
+ [Test]
+ public void TestAdditivity1()
+ {
+ Logger a = (Logger)Utils.GetLogger("a").Logger;
+ Logger ab = (Logger)Utils.GetLogger("a.b").Logger;
+ CountingAppender ca = new CountingAppender();
- a.AddAppender(ca);
- a.Repository.Configured = true;
+ a.AddAppender(ca);
+ a.Repository.Configured = true;
- Assert.AreEqual(ca.Counter, 0);
- ab.Log(Level.Debug, MSG, null);
- Assert.AreEqual(ca.Counter, 1);
- ab.Log(Level.Info, MSG, null);
- Assert.AreEqual(ca.Counter, 2);
- ab.Log(Level.Warn, MSG, null);
- Assert.AreEqual(ca.Counter, 3);
- ab.Log(Level.Error, MSG, null);
- Assert.AreEqual(ca.Counter, 4);
- }
+ Assert.AreEqual(ca.Counter, 0);
+ ab.Log(Level.Debug, MSG, null);
+ Assert.AreEqual(ca.Counter, 1);
+ ab.Log(Level.Info, MSG, null);
+ Assert.AreEqual(ca.Counter, 2);
+ ab.Log(Level.Warn, MSG, null);
+ Assert.AreEqual(ca.Counter, 3);
+ ab.Log(Level.Error, MSG, null);
+ Assert.AreEqual(ca.Counter, 4);
+ }
- /// <summary>
- /// Test multiple additivity.
- /// </summary>
- [Test]
- public void TestAdditivity2()
- {
- Logger a = (Logger)Utils.GetLogger("a").Logger;
- Logger ab = (Logger)Utils.GetLogger("a.b").Logger;
- Logger abc = (Logger)Utils.GetLogger("a.b.c").Logger;
- Logger x = (Logger)Utils.GetLogger("x").Logger;
+ /// <summary>
+ /// Test multiple additivity.
+ /// </summary>
+ [Test]
+ public void TestAdditivity2()
+ {
+ Logger a = (Logger)Utils.GetLogger("a").Logger;
+ Logger ab = (Logger)Utils.GetLogger("a.b").Logger;
+ Logger abc = (Logger)Utils.GetLogger("a.b.c").Logger;
+ Logger x = (Logger)Utils.GetLogger("x").Logger;
- CountingAppender ca1 = new CountingAppender();
- CountingAppender ca2 = new CountingAppender();
+ CountingAppender ca1 = new CountingAppender();
+ CountingAppender ca2 = new CountingAppender();
- a.AddAppender(ca1);
- abc.AddAppender(ca2);
- a.Repository.Configured = true;
+ a.AddAppender(ca1);
+ abc.AddAppender(ca2);
+ a.Repository.Configured = true;
- Assert.AreEqual(ca1.Counter, 0);
- Assert.AreEqual(ca2.Counter, 0);
+ Assert.AreEqual(ca1.Counter, 0);
+ Assert.AreEqual(ca2.Counter, 0);
- ab.Log(Level.Debug, MSG, null);
- Assert.AreEqual(ca1.Counter, 1);
- Assert.AreEqual(ca2.Counter, 0);
+ ab.Log(Level.Debug, MSG, null);
+ Assert.AreEqual(ca1.Counter, 1);
+ Assert.AreEqual(ca2.Counter, 0);
- abc.Log(Level.Debug, MSG, null);
- Assert.AreEqual(ca1.Counter, 2);
- Assert.AreEqual(ca2.Counter, 1);
+ abc.Log(Level.Debug, MSG, null);
+ Assert.AreEqual(ca1.Counter, 2);
+ Assert.AreEqual(ca2.Counter, 1);
- x.Log(Level.Debug, MSG, null);
- Assert.AreEqual(ca1.Counter, 2);
- Assert.AreEqual(ca2.Counter, 1);
- }
+ x.Log(Level.Debug, MSG, null);
+ Assert.AreEqual(ca1.Counter, 2);
+ Assert.AreEqual(ca2.Counter, 1);
+ }
- /// <summary>
- /// Test additivity flag.
- /// </summary>
- [Test]
- public void TestAdditivity3()
- {
- Logger root = ((Repository.Hierarchy.Hierarchy)Utils.GetRepository()).Root;
- Logger a = (Logger)Utils.GetLogger("a").Logger;
- Logger ab = (Logger)Utils.GetLogger("a.b").Logger;
- Logger abc = (Logger)Utils.GetLogger("a.b.c").Logger;
+ /// <summary>
+ /// Test additivity flag.
+ /// </summary>
+ [Test]
+ public void TestAdditivity3()
+ {
+ Logger root = ((Repository.Hierarchy.Hierarchy)Utils.GetRepository()).Root;
+ Logger a = (Logger)Utils.GetLogger("a").Logger;
+ Logger ab = (Logger)Utils.GetLogger("a.b").Logger;
+ Logger abc = (Logger)Utils.GetLogger("a.b.c").Logger;
- CountingAppender caRoot = new CountingAppender();
- CountingAppender caA = new CountingAppender();
- CountingAppender caABC = new CountingAppender();
+ CountingAppender caRoot = new CountingAppender();
+ CountingAppender caA = new CountingAppender();
+ CountingAppender caABC = new CountingAppender();
- root.AddAppender(caRoot);
- a.AddAppender(caA);
- abc.AddAppender(caABC);
- a.Repository.Configured = true;
+ root.AddAppender(caRoot);
+ a.AddAppender(caA);
+ abc.AddAppender(caABC);
+ a.Repository.Configured = true;
- Assert.AreEqual(caRoot.Counter, 0);
- Assert.AreEqual(caA.Counter, 0);
- Assert.AreEqual(caABC.Counter, 0);
+ Assert.AreEqual(caRoot.Counter, 0);
+ Assert.AreEqual(caA.Counter, 0);
+ Assert.AreEqual(caABC.Counter, 0);
- ab.Additivity = false;
+ ab.Additivity = false;
- a.Log(Level.Debug, MSG, null);
- Assert.AreEqual(caRoot.Counter, 1);
- Assert.AreEqual(caA.Counter, 1);
- Assert.AreEqual(caABC.Counter, 0);
+ a.Log(Level.Debug, MSG, null);
+ Assert.AreEqual(caRoot.Counter, 1);
+ Assert.AreEqual(caA.Counter, 1);
+ Assert.AreEqual(caABC.Counter, 0);
- ab.Log(Level.Debug, MSG, null);
- Assert.AreEqual(caRoot.Counter, 1);
- Assert.AreEqual(caA.Counter, 1);
- Assert.AreEqual(caABC.Counter, 0);
+ ab.Log(Level.Debug, MSG, null);
+ Assert.AreEqual(caRoot.Counter, 1);
+ Assert.AreEqual(caA.Counter, 1);
+ Assert.AreEqual(caABC.Counter, 0);
- abc.Log(Level.Debug, MSG, null);
- Assert.AreEqual(caRoot.Counter, 1);
- Assert.AreEqual(caA.Counter, 1);
- Assert.AreEqual(caABC.Counter, 1);
- }
+ abc.Log(Level.Debug, MSG, null);
+ Assert.AreEqual(caRoot.Counter, 1);
+ Assert.AreEqual(caA.Counter, 1);
+ Assert.AreEqual(caABC.Counter, 1);
+ }
- /// <summary>
- /// Test the ability to disable a level of message
- /// </summary>
- [Test]
- public void TestDisable1()
- {
- CountingAppender caRoot = new CountingAppender();
- Logger root = ((Repository.Hierarchy.Hierarchy)Utils.GetRepository()).Root;
- root.AddAppender(caRoot);
+ /// <summary>
+ /// Test the ability to disable a level of message
+ /// </summary>
+ [Test]
+ public void TestDisable1()
+ {
+ CountingAppender caRoot = new CountingAppender();
+ Logger root = ((Repository.Hierarchy.Hierarchy)Utils.GetRepository()).Root;
+ root.AddAppender(caRoot);
- Repository.Hierarchy.Hierarchy h = ((Repository.Hierarchy.Hierarchy)Utils.GetRepository());
- h.Threshold = Level.Info;
- h.Configured = true;
+ Repository.Hierarchy.Hierarchy h = ((Repository.Hierarchy.Hierarchy)Utils.GetRepository());
+ h.Threshold = Level.Info;
+ h.Configured = true;
- Assert.AreEqual(caRoot.Counter, 0);
+ Assert.AreEqual(caRoot.Counter, 0);
- root.Log(Level.Debug, MSG, null);
- Assert.AreEqual(caRoot.Counter, 0);
- root.Log(Level.Info, MSG, null);
- Assert.AreEqual(caRoot.Counter, 1);
- root.Log(Level.Warn, MSG, null);
- Assert.AreEqual(caRoot.Counter, 2);
- root.Log(Level.Warn, MSG, null);
- Assert.AreEqual(caRoot.Counter, 3);
+ root.Log(Level.Debug, MSG, null);
+ Assert.AreEqual(caRoot.Counter, 0);
+ root.Log(Level.Info, MSG, null);
+ Assert.AreEqual(caRoot.Counter, 1);
+ root.Log(Level.Warn, MSG, null);
+ Assert.AreEqual(caRoot.Counter, 2);
+ root.Log(Level.Warn, MSG, null);
+ Assert.AreEqual(caRoot.Counter, 3);
- h.Threshold = Level.Warn;
- root.Log(Level.Debug, MSG, null);
- Assert.AreEqual(caRoot.Counter, 3);
- root.Log(Level.Info, MSG, null);
- Assert.AreEqual(caRoot.Counter, 3);
- root.Log(Level.Warn, MSG, null);
- Assert.AreEqual(caRoot.Counter, 4);
- root.Log(Level.Error, MSG, null);
- Assert.AreEqual(caRoot.Counter, 5);
- root.Log(Level.Error, MSG, null);
- Assert.AreEqual(caRoot.Counter, 6);
+ h.Threshold = Level.Warn;
+ root.Log(Level.Debug, MSG, null);
+ Assert.AreEqual(caRoot.Counter, 3);
+ root.Log(Level.Info, MSG, null);
+ Assert.AreEqual(caRoot.Counter, 3);
+ root.Log(Level.Warn, MSG, null);
+ Assert.AreEqual(caRoot.Counter, 4);
+ root.Log(Level.Error, MSG, null);
+ Assert.AreEqual(caRoot.Counter, 5);
+ root.Log(Level.Error, MSG, null);
+ Assert.AreEqual(caRoot.Counter, 6);
- h.Threshold = Level.Off;
- root.Log(Level.Debug, MSG, null);
- Assert.AreEqual(caRoot.Counter, 6);
- root.Log(Level.Info, MSG, null);
- Assert.AreEqual(caRoot.Counter, 6);
- root.Log(Level.Warn, MSG, null);
- Assert.AreEqual(caRoot.Counter, 6);
- root.Log(Level.Error, MSG, null);
- Assert.AreEqual(caRoot.Counter, 6);
- root.Log(Level.Fatal, MSG, null);
- Assert.AreEqual(caRoot.Counter, 6);
- root.Log(Level.Fatal, MSG, null);
- Assert.AreEqual(caRoot.Counter, 6);
- }
+ h.Threshold = Level.Off;
+ root.Log(Level.Debug, MSG, null);
+ Assert.AreEqual(caRoot.Counter, 6);
+ root.Log(Level.Info, MSG, null);
+ Assert.AreEqual(caRoot.Counter, 6);
+ root.Log(Level.Warn, MSG, null);
+ Assert.AreEqual(caRoot.Counter, 6);
+ root.Log(Level.Error, MSG, null);
+ Assert.AreEqual(caRoot.Counter, 6);
+ root.Log(Level.Fatal, MSG, null);
+ Assert.AreEqual(caRoot.Counter, 6);
+ root.Log(Level.Fatal, MSG, null);
+ Assert.AreEqual(caRoot.Counter, 6);
+ }
- /// <summary>
- /// Tests the Exists method of the Logger class
- /// </summary>
- [Test]
- public void TestExists()
- {
- object a = Utils.GetLogger("a");
- object a_b = Utils.GetLogger("a.b");
- object a_b_c = Utils.GetLogger("a.b.c");
+ /// <summary>
+ /// Tests the Exists method of the Logger class
+ /// </summary>
+ [Test]
+ public void TestExists()
+ {
+ object a = Utils.GetLogger("a");
+ object a_b = Utils.GetLogger("a.b");
+ object a_b_c = Utils.GetLogger("a.b.c");
- object t;
+ object t;
#if NETSTANDARD1_3
- Assert.IsNull(LogManager.Exists(GetType().GetTypeInfo().Assembly, "xx"));
- t = LogManager.Exists(GetType().GetTypeInfo().Assembly, "a");
- Assert.AreSame(a, t);
- t = LogManager.Exists(GetType().GetTypeInfo().Assembly, "a.b");
- Assert.AreSame(a_b, t);
- t = LogManager.Exists(GetType().GetTypeInfo().Assembly, "a.b.c");
- Assert.AreSame(a_b_c, t);
+ Assert.IsNull(LogManager.Exists(GetType().GetTypeInfo().Assembly, "xx"));
+ t = LogManager.Exists(GetType().GetTypeInfo().Assembly, "a");
+ Assert.AreSame(a, t);
+ t = LogManager.Exists(GetType().GetTypeInfo().Assembly, "a.b");
+ Assert.AreSame(a_b, t);
+ t = LogManager.Exists(GetType().GetTypeInfo().Assembly, "a.b.c");
+ Assert.AreSame(a_b_c, t);
#else
- t = LogManager.Exists("xx");
- Assert.IsNull(t);
- t = LogManager.Exists("a");
- Assert.AreSame(a, t);
- t = LogManager.Exists("a.b");
- Assert.AreSame(a_b, t);
- t = LogManager.Exists("a.b.c");
- Assert.AreSame(a_b_c, t);
+ t = LogManager.Exists("xx");
+ Assert.IsNull(t);
+ t = LogManager.Exists("a");
+ Assert.AreSame(a, t);
+ t = LogManager.Exists("a.b");
+ Assert.AreSame(a_b, t);
+ t = LogManager.Exists("a.b.c");
+ Assert.AreSame(a_b_c, t);
#endif
- }
+ }
- /// <summary>
- /// Tests the chained level for a hierarchy
- /// </summary>
- [Test]
- public void TestHierarchy1()
- {
- Repository.Hierarchy.Hierarchy h = new Repository.Hierarchy.Hierarchy();
- h.Root.Level = Level.Error;
+ /// <summary>
+ /// Tests the chained level for a hierarchy
+ /// </summary>
+ [Test]
+ public void TestHierarchy1()
+ {
+ Repository.Hierarchy.Hierarchy h = new Repository.Hierarchy.Hierarchy();
+ h.Root.Level = Level.Error;
- Logger a0 = (Logger)h.GetLogger("a");
- Assert.AreEqual("a", a0.Name);
- Assert.IsNull(a0.Level);
- Assert.AreSame(Level.Error, a0.EffectiveLevel);
+ Logger a0 = (Logger)h.GetLogger("a");
+ Assert.AreEqual("a", a0.Name);
+ Assert.IsNull(a0.Level);
+ Assert.AreSame(Level.Error, a0.EffectiveLevel);
- Logger a1 = (Logger)h.GetLogger("a");
- Assert.AreSame(a0, a1);
- }
- }
+ Logger a1 = (Logger)h.GetLogger("a");
+ Assert.AreSame(a0, a1);
+ }
+ }
}
\ No newline at end of file
diff --git a/src/log4net.Tests/Layout/PatternLayoutTest.cs b/src/log4net.Tests/Layout/PatternLayoutTest.cs
index 9c768ca..d2937d5 100644
--- a/src/log4net.Tests/Layout/PatternLayoutTest.cs
+++ b/src/log4net.Tests/Layout/PatternLayoutTest.cs
@@ -35,35 +35,35 @@
namespace log4net.Tests.Layout
{
- /// <summary>
- /// Used for internal unit testing the <see cref="PatternLayout"/> class.
- /// </summary>
- /// <remarks>
- /// Used for internal unit testing the <see cref="PatternLayout"/> class.
- /// </remarks>
- [TestFixture]
- public class PatternLayoutTest
- {
+ /// <summary>
+ /// Used for internal unit testing the <see cref="PatternLayout"/> class.
+ /// </summary>
+ /// <remarks>
+ /// Used for internal unit testing the <see cref="PatternLayout"/> class.
+ /// </remarks>
+ [TestFixture]
+ public class PatternLayoutTest
+ {
#if !NETSTANDARD1_3
- private CultureInfo _currentCulture;
- private CultureInfo _currentUICulture;
+ private CultureInfo _currentCulture;
+ private CultureInfo _currentUICulture;
- [SetUp]
- public void SetUp()
- {
- // set correct thread culture
- _currentCulture = System.Threading.Thread.CurrentThread.CurrentCulture;
- _currentUICulture = System.Threading.Thread.CurrentThread.CurrentUICulture;
- System.Threading.Thread.CurrentThread.CurrentCulture = System.Threading.Thread.CurrentThread.CurrentUICulture = System.Globalization.CultureInfo.InvariantCulture;
- }
+ [SetUp]
+ public void SetUp()
+ {
+ // set correct thread culture
+ _currentCulture = System.Threading.Thread.CurrentThread.CurrentCulture;
+ _currentUICulture = System.Threading.Thread.CurrentThread.CurrentUICulture;
+ System.Threading.Thread.CurrentThread.CurrentCulture = System.Threading.Thread.CurrentThread.CurrentUICulture = System.Globalization.CultureInfo.InvariantCulture;
+ }
[TearDown]
public void TearDown() {
- Utils.RemovePropertyFromAllContexts();
- // restore previous culture
- System.Threading.Thread.CurrentThread.CurrentCulture = _currentCulture;
- System.Threading.Thread.CurrentThread.CurrentUICulture = _currentUICulture;
+ Utils.RemovePropertyFromAllContexts();
+ // restore previous culture
+ System.Threading.Thread.CurrentThread.CurrentCulture = _currentCulture;
+ System.Threading.Thread.CurrentThread.CurrentUICulture = _currentUICulture;
}
#endif
@@ -76,32 +76,32 @@
}
[Test]
- public void TestThreadPropertiesPattern()
- {
- StringAppender stringAppender = new StringAppender();
+ public void TestThreadPropertiesPattern()
+ {
+ StringAppender stringAppender = new StringAppender();
stringAppender.Layout = NewPatternLayout("%property{" + Utils.PROPERTY_KEY + "}");
- ILoggerRepository rep = LogManager.CreateRepository(Guid.NewGuid().ToString());
- BasicConfigurator.Configure(rep, stringAppender);
+ ILoggerRepository rep = LogManager.CreateRepository(Guid.NewGuid().ToString());
+ BasicConfigurator.Configure(rep, stringAppender);
- ILog log1 = LogManager.GetLogger(rep.Name, "TestThreadProperiesPattern");
+ ILog log1 = LogManager.GetLogger(rep.Name, "TestThreadProperiesPattern");
- log1.Info("TestMessage");
- Assert.AreEqual(SystemInfo.NullText, stringAppender.GetString(), "Test no thread properties value set");
- stringAppender.Reset();
+ log1.Info("TestMessage");
+ Assert.AreEqual(SystemInfo.NullText, stringAppender.GetString(), "Test no thread properties value set");
+ stringAppender.Reset();
- ThreadContext.Properties[Utils.PROPERTY_KEY] = "val1";
+ ThreadContext.Properties[Utils.PROPERTY_KEY] = "val1";
- log1.Info("TestMessage");
- Assert.AreEqual("val1", stringAppender.GetString(), "Test thread properties value set");
- stringAppender.Reset();
+ log1.Info("TestMessage");
+ Assert.AreEqual("val1", stringAppender.GetString(), "Test thread properties value set");
+ stringAppender.Reset();
- ThreadContext.Properties.Remove(Utils.PROPERTY_KEY);
+ ThreadContext.Properties.Remove(Utils.PROPERTY_KEY);
- log1.Info("TestMessage");
- Assert.AreEqual(SystemInfo.NullText, stringAppender.GetString(), "Test thread properties value removed");
- stringAppender.Reset();
- }
+ log1.Info("TestMessage");
+ Assert.AreEqual(SystemInfo.NullText, stringAppender.GetString(), "Test thread properties value removed");
+ stringAppender.Reset();
+ }
#if !NETSTANDARD1_3
[Test]
@@ -121,55 +121,55 @@
}
#endif
- [Test]
- public void TestGlobalPropertiesPattern()
- {
- StringAppender stringAppender = new StringAppender();
+ [Test]
+ public void TestGlobalPropertiesPattern()
+ {
+ StringAppender stringAppender = new StringAppender();
stringAppender.Layout = NewPatternLayout("%property{" + Utils.PROPERTY_KEY + "}");
- ILoggerRepository rep = LogManager.CreateRepository(Guid.NewGuid().ToString());
- BasicConfigurator.Configure(rep, stringAppender);
+ ILoggerRepository rep = LogManager.CreateRepository(Guid.NewGuid().ToString());
+ BasicConfigurator.Configure(rep, stringAppender);
- ILog log1 = LogManager.GetLogger(rep.Name, "TestGlobalProperiesPattern");
+ ILog log1 = LogManager.GetLogger(rep.Name, "TestGlobalProperiesPattern");
- log1.Info("TestMessage");
- Assert.AreEqual(SystemInfo.NullText, stringAppender.GetString(), "Test no global properties value set");
- stringAppender.Reset();
+ log1.Info("TestMessage");
+ Assert.AreEqual(SystemInfo.NullText, stringAppender.GetString(), "Test no global properties value set");
+ stringAppender.Reset();
- GlobalContext.Properties[Utils.PROPERTY_KEY] = "val1";
+ GlobalContext.Properties[Utils.PROPERTY_KEY] = "val1";
- log1.Info("TestMessage");
- Assert.AreEqual("val1", stringAppender.GetString(), "Test global properties value set");
- stringAppender.Reset();
+ log1.Info("TestMessage");
+ Assert.AreEqual("val1", stringAppender.GetString(), "Test global properties value set");
+ stringAppender.Reset();
- GlobalContext.Properties.Remove(Utils.PROPERTY_KEY);
+ GlobalContext.Properties.Remove(Utils.PROPERTY_KEY);
- log1.Info("TestMessage");
- Assert.AreEqual(SystemInfo.NullText, stringAppender.GetString(), "Test global properties value removed");
- stringAppender.Reset();
- }
+ log1.Info("TestMessage");
+ Assert.AreEqual(SystemInfo.NullText, stringAppender.GetString(), "Test global properties value removed");
+ stringAppender.Reset();
+ }
- [Test]
- public void TestAddingCustomPattern()
- {
- StringAppender stringAppender = new StringAppender();
- PatternLayout layout = NewPatternLayout();
+ [Test]
+ public void TestAddingCustomPattern()
+ {
+ StringAppender stringAppender = new StringAppender();
+ PatternLayout layout = NewPatternLayout();
- layout.AddConverter("TestAddingCustomPattern", typeof(TestMessagePatternConverter));
- layout.ConversionPattern = "%TestAddingCustomPattern";
- layout.ActivateOptions();
+ layout.AddConverter("TestAddingCustomPattern", typeof(TestMessagePatternConverter));
+ layout.ConversionPattern = "%TestAddingCustomPattern";
+ layout.ActivateOptions();
- stringAppender.Layout = layout;
+ stringAppender.Layout = layout;
- ILoggerRepository rep = LogManager.CreateRepository(Guid.NewGuid().ToString());
- BasicConfigurator.Configure(rep, stringAppender);
+ ILoggerRepository rep = LogManager.CreateRepository(Guid.NewGuid().ToString());
+ BasicConfigurator.Configure(rep, stringAppender);
- ILog log1 = LogManager.GetLogger(rep.Name, "TestAddingCustomPattern");
+ ILog log1 = LogManager.GetLogger(rep.Name, "TestAddingCustomPattern");
- log1.Info("TestMessage");
- Assert.AreEqual("TestMessage", stringAppender.GetString(), "%TestAddingCustomPattern not registered");
- stringAppender.Reset();
- }
+ log1.Info("TestMessage");
+ Assert.AreEqual("TestMessage", stringAppender.GetString(), "%TestAddingCustomPattern not registered");
+ stringAppender.Reset();
+ }
[Test]
public void NamedPatternConverterWithoutPrecisionShouldReturnFullName()
@@ -312,41 +312,41 @@
}
/// <summary>
- /// Converter to include event message
- /// </summary>
- private class TestMessagePatternConverter : PatternLayoutConverter
- {
- /// <summary>
- /// Convert the pattern to the rendered message
- /// </summary>
- /// <param name="writer"><see cref="TextWriter" /> that will receive the formatted result.</param>
- /// <param name="loggingEvent">the event being logged</param>
- /// <returns>the relevant location information</returns>
- protected override void Convert(TextWriter writer, LoggingEvent loggingEvent)
- {
- loggingEvent.WriteRenderedMessage(writer);
- }
- }
+ /// Converter to include event message
+ /// </summary>
+ private class TestMessagePatternConverter : PatternLayoutConverter
+ {
+ /// <summary>
+ /// Convert the pattern to the rendered message
+ /// </summary>
+ /// <param name="writer"><see cref="TextWriter" /> that will receive the formatted result.</param>
+ /// <param name="loggingEvent">the event being logged</param>
+ /// <returns>the relevant location information</returns>
+ protected override void Convert(TextWriter writer, LoggingEvent loggingEvent)
+ {
+ loggingEvent.WriteRenderedMessage(writer);
+ }
+ }
- [Test]
- public void TestExceptionPattern()
- {
- StringAppender stringAppender = new StringAppender();
- PatternLayout layout = NewPatternLayout("%exception{stacktrace}");
- stringAppender.Layout = layout;
+ [Test]
+ public void TestExceptionPattern()
+ {
+ StringAppender stringAppender = new StringAppender();
+ PatternLayout layout = NewPatternLayout("%exception{stacktrace}");
+ stringAppender.Layout = layout;
- ILoggerRepository rep = LogManager.CreateRepository(Guid.NewGuid().ToString());
- BasicConfigurator.Configure(rep, stringAppender);
+ ILoggerRepository rep = LogManager.CreateRepository(Guid.NewGuid().ToString());
+ BasicConfigurator.Configure(rep, stringAppender);
- ILog log1 = LogManager.GetLogger(rep.Name, "TestExceptionPattern");
+ ILog log1 = LogManager.GetLogger(rep.Name, "TestExceptionPattern");
- Exception exception = new Exception("Oh no!");
- log1.Info("TestMessage", exception);
+ Exception exception = new Exception("Oh no!");
+ log1.Info("TestMessage", exception);
- Assert.AreEqual(SystemInfo.NullText, stringAppender.GetString());
+ Assert.AreEqual(SystemInfo.NullText, stringAppender.GetString());
- stringAppender.Reset();
- }
+ stringAppender.Reset();
+ }
private class MessageAsNamePatternConverter : NamedPatternConverter
{
diff --git a/src/log4net.Tests/Layout/XmlLayoutTest.cs b/src/log4net.Tests/Layout/XmlLayoutTest.cs
index 39ca33d..17cd67e 100644
--- a/src/log4net.Tests/Layout/XmlLayoutTest.cs
+++ b/src/log4net.Tests/Layout/XmlLayoutTest.cs
@@ -33,277 +33,277 @@
namespace log4net.Tests.Layout
{
- [TestFixture]
- public class XmlLayoutTest
- {
+ [TestFixture]
+ public class XmlLayoutTest
+ {
#if !NETSTANDARD1_3
- private CultureInfo _currentCulture;
- private CultureInfo _currentUICulture;
+ private CultureInfo _currentCulture;
+ private CultureInfo _currentUICulture;
- [SetUp]
- public void SetUp()
- {
- // set correct thread culture
- _currentCulture = System.Threading.Thread.CurrentThread.CurrentCulture;
- _currentUICulture = System.Threading.Thread.CurrentThread.CurrentUICulture;
- System.Threading.Thread.CurrentThread.CurrentCulture = System.Threading.Thread.CurrentThread.CurrentUICulture = System.Globalization.CultureInfo.InvariantCulture;
- }
+ [SetUp]
+ public void SetUp()
+ {
+ // set correct thread culture
+ _currentCulture = System.Threading.Thread.CurrentThread.CurrentCulture;
+ _currentUICulture = System.Threading.Thread.CurrentThread.CurrentUICulture;
+ System.Threading.Thread.CurrentThread.CurrentCulture = System.Threading.Thread.CurrentThread.CurrentUICulture = System.Globalization.CultureInfo.InvariantCulture;
+ }
- [TearDown]
- public void TearDown()
- {
- // restore previous culture
- System.Threading.Thread.CurrentThread.CurrentCulture = _currentCulture;
- System.Threading.Thread.CurrentThread.CurrentUICulture = _currentUICulture;
- }
+ [TearDown]
+ public void TearDown()
+ {
+ // restore previous culture
+ System.Threading.Thread.CurrentThread.CurrentCulture = _currentCulture;
+ System.Threading.Thread.CurrentThread.CurrentUICulture = _currentUICulture;
+ }
#endif
- /// <summary>
- /// Build a basic <see cref="LoggingEventData"/> object with some default values.
- /// </summary>
- /// <returns>A useful LoggingEventData object</returns>
- private LoggingEventData CreateBaseEvent()
- {
- LoggingEventData ed = new LoggingEventData();
- ed.Domain = "Tests";
- ed.ExceptionString = "";
- ed.Identity = "TestRunner";
- ed.Level = Level.Info;
- ed.LocationInfo = new LocationInfo(GetType());
- ed.LoggerName = "TestLogger";
- ed.Message = "Test message";
- ed.ThreadName = "TestThread";
- ed.TimeStampUtc = DateTime.Today.ToUniversalTime();
- ed.UserName = "TestRunner";
- ed.Properties = new PropertiesDictionary();
+ /// <summary>
+ /// Build a basic <see cref="LoggingEventData"/> object with some default values.
+ /// </summary>
+ /// <returns>A useful LoggingEventData object</returns>
+ private LoggingEventData CreateBaseEvent()
+ {
+ LoggingEventData ed = new LoggingEventData();
+ ed.Domain = "Tests";
+ ed.ExceptionString = "";
+ ed.Identity = "TestRunner";
+ ed.Level = Level.Info;
+ ed.LocationInfo = new LocationInfo(GetType());
+ ed.LoggerName = "TestLogger";
+ ed.Message = "Test message";
+ ed.ThreadName = "TestThread";
+ ed.TimeStampUtc = DateTime.Today.ToUniversalTime();
+ ed.UserName = "TestRunner";
+ ed.Properties = new PropertiesDictionary();
- return ed;
- }
+ return ed;
+ }
- private static string CreateEventNode(string message)
- {
- return String.Format("<event logger=\"TestLogger\" timestamp=\"{0}\" level=\"INFO\" thread=\"TestThread\" domain=\"Tests\" identity=\"TestRunner\" username=\"TestRunner\"><message>{1}</message></event>" + Environment.NewLine,
+ private static string CreateEventNode(string message)
+ {
+ return String.Format("<event logger=\"TestLogger\" timestamp=\"{0}\" level=\"INFO\" thread=\"TestThread\" domain=\"Tests\" identity=\"TestRunner\" username=\"TestRunner\"><message>{1}</message></event>" + Environment.NewLine,
#if NET_2_0 || MONO_2_0 || MONO_3_5 || MONO_4_0 || NETSTANDARD
- XmlConvert.ToString(DateTime.Today, XmlDateTimeSerializationMode.Local),
+ XmlConvert.ToString(DateTime.Today, XmlDateTimeSerializationMode.Local),
#else
- XmlConvert.ToString(DateTime.Today),
+ XmlConvert.ToString(DateTime.Today),
#endif
- message);
- }
+ message);
+ }
- private static string CreateEventNode(string key, string value)
- {
- return String.Format("<event logger=\"TestLogger\" timestamp=\"{0}\" level=\"INFO\" thread=\"TestThread\" domain=\"Tests\" identity=\"TestRunner\" username=\"TestRunner\"><message>Test message</message><properties><data name=\"{1}\" value=\"{2}\" /></properties></event>" + Environment.NewLine,
+ private static string CreateEventNode(string key, string value)
+ {
+ return String.Format("<event logger=\"TestLogger\" timestamp=\"{0}\" level=\"INFO\" thread=\"TestThread\" domain=\"Tests\" identity=\"TestRunner\" username=\"TestRunner\"><message>Test message</message><properties><data name=\"{1}\" value=\"{2}\" /></properties></event>" + Environment.NewLine,
#if NET_2_0 || MONO_2_0 || MONO_3_5 || MONO_4_0 || NETSTANDARD
- XmlConvert.ToString(DateTime.Today, XmlDateTimeSerializationMode.Local),
+ XmlConvert.ToString(DateTime.Today, XmlDateTimeSerializationMode.Local),
#else
- XmlConvert.ToString(DateTime.Today),
+ XmlConvert.ToString(DateTime.Today),
#endif
- key,
- value);
- }
+ key,
+ value);
+ }
- [Test]
- public void TestBasicEventLogging()
- {
- TextWriter writer = new StringWriter();
- XmlLayout layout = new XmlLayout();
- LoggingEventData evt = CreateBaseEvent();
+ [Test]
+ public void TestBasicEventLogging()
+ {
+ TextWriter writer = new StringWriter();
+ XmlLayout layout = new XmlLayout();
+ LoggingEventData evt = CreateBaseEvent();
- layout.Format(writer, new LoggingEvent(evt));
+ layout.Format(writer, new LoggingEvent(evt));
- string expected = CreateEventNode("Test message");
+ string expected = CreateEventNode("Test message");
- Assert.AreEqual(expected, writer.ToString());
- }
+ Assert.AreEqual(expected, writer.ToString());
+ }
- [Test]
- public void TestIllegalCharacterMasking()
- {
- TextWriter writer = new StringWriter();
- XmlLayout layout = new XmlLayout();
- LoggingEventData evt = CreateBaseEvent();
+ [Test]
+ public void TestIllegalCharacterMasking()
+ {
+ TextWriter writer = new StringWriter();
+ XmlLayout layout = new XmlLayout();
+ LoggingEventData evt = CreateBaseEvent();
- evt.Message = "This is a masked char->\uFFFF";
+ evt.Message = "This is a masked char->\uFFFF";
- layout.Format(writer, new LoggingEvent(evt));
+ layout.Format(writer, new LoggingEvent(evt));
- string expected = CreateEventNode("This is a masked char->?");
+ string expected = CreateEventNode("This is a masked char->?");
- Assert.AreEqual(expected, writer.ToString());
- }
+ Assert.AreEqual(expected, writer.ToString());
+ }
- [Test]
- public void TestCDATAEscaping1()
- {
- TextWriter writer = new StringWriter();
- XmlLayout layout = new XmlLayout();
- LoggingEventData evt = CreateBaseEvent();
+ [Test]
+ public void TestCDATAEscaping1()
+ {
+ TextWriter writer = new StringWriter();
+ XmlLayout layout = new XmlLayout();
+ LoggingEventData evt = CreateBaseEvent();
- //The &'s trigger the use of a cdata block
- evt.Message = "&&&&&&&Escape this ]]>. End here.";
+ //The &'s trigger the use of a cdata block
+ evt.Message = "&&&&&&&Escape this ]]>. End here.";
- layout.Format(writer, new LoggingEvent(evt));
+ layout.Format(writer, new LoggingEvent(evt));
- string expected = CreateEventNode("<![CDATA[&&&&&&&Escape this ]]>]]<![CDATA[>. End here.]]>");
+ string expected = CreateEventNode("<![CDATA[&&&&&&&Escape this ]]>]]<![CDATA[>. End here.]]>");
- Assert.AreEqual(expected, writer.ToString());
- }
+ Assert.AreEqual(expected, writer.ToString());
+ }
- [Test]
- public void TestCDATAEscaping2()
- {
- TextWriter writer = new StringWriter();
- XmlLayout layout = new XmlLayout();
- LoggingEventData evt = CreateBaseEvent();
+ [Test]
+ public void TestCDATAEscaping2()
+ {
+ TextWriter writer = new StringWriter();
+ XmlLayout layout = new XmlLayout();
+ LoggingEventData evt = CreateBaseEvent();
- //The &'s trigger the use of a cdata block
- evt.Message = "&&&&&&&Escape the end ]]>";
+ //The &'s trigger the use of a cdata block
+ evt.Message = "&&&&&&&Escape the end ]]>";
- layout.Format(writer, new LoggingEvent(evt));
+ layout.Format(writer, new LoggingEvent(evt));
- string expected = CreateEventNode("<![CDATA[&&&&&&&Escape the end ]]>]]>");
+ string expected = CreateEventNode("<![CDATA[&&&&&&&Escape the end ]]>]]>");
- Assert.AreEqual(expected, writer.ToString());
- }
+ Assert.AreEqual(expected, writer.ToString());
+ }
- [Test]
- public void TestCDATAEscaping3()
- {
- TextWriter writer = new StringWriter();
- XmlLayout layout = new XmlLayout();
- LoggingEventData evt = CreateBaseEvent();
+ [Test]
+ public void TestCDATAEscaping3()
+ {
+ TextWriter writer = new StringWriter();
+ XmlLayout layout = new XmlLayout();
+ LoggingEventData evt = CreateBaseEvent();
- //The &'s trigger the use of a cdata block
- evt.Message = "]]>&&&&&&&Escape the begining";
+ //The &'s trigger the use of a cdata block
+ evt.Message = "]]>&&&&&&&Escape the begining";
- layout.Format(writer, new LoggingEvent(evt));
+ layout.Format(writer, new LoggingEvent(evt));
- string expected = CreateEventNode("<![CDATA[]]>]]<![CDATA[>&&&&&&&Escape the begining]]>");
+ string expected = CreateEventNode("<![CDATA[]]>]]<![CDATA[>&&&&&&&Escape the begining]]>");
- Assert.AreEqual(expected, writer.ToString());
- }
+ Assert.AreEqual(expected, writer.ToString());
+ }
- [Test]
- public void TestBase64EventLogging()
- {
- TextWriter writer = new StringWriter();
- XmlLayout layout = new XmlLayout();
- LoggingEventData evt = CreateBaseEvent();
+ [Test]
+ public void TestBase64EventLogging()
+ {
+ TextWriter writer = new StringWriter();
+ XmlLayout layout = new XmlLayout();
+ LoggingEventData evt = CreateBaseEvent();
- layout.Base64EncodeMessage = true;
- layout.Format(writer, new LoggingEvent(evt));
+ layout.Base64EncodeMessage = true;
+ layout.Format(writer, new LoggingEvent(evt));
- string expected = CreateEventNode("VGVzdCBtZXNzYWdl");
+ string expected = CreateEventNode("VGVzdCBtZXNzYWdl");
- Assert.AreEqual(expected, writer.ToString());
- }
+ Assert.AreEqual(expected, writer.ToString());
+ }
- [Test]
- public void TestPropertyEventLogging()
- {
- LoggingEventData evt = CreateBaseEvent();
- evt.Properties["Property1"] = "prop1";
+ [Test]
+ public void TestPropertyEventLogging()
+ {
+ LoggingEventData evt = CreateBaseEvent();
+ evt.Properties["Property1"] = "prop1";
- XmlLayout layout = new XmlLayout();
- StringAppender stringAppender = new StringAppender();
- stringAppender.Layout = layout;
+ XmlLayout layout = new XmlLayout();
+ StringAppender stringAppender = new StringAppender();
+ stringAppender.Layout = layout;
- ILoggerRepository rep = LogManager.CreateRepository(Guid.NewGuid().ToString());
- BasicConfigurator.Configure(rep, stringAppender);
- ILog log1 = LogManager.GetLogger(rep.Name, "TestThreadProperiesPattern");
+ ILoggerRepository rep = LogManager.CreateRepository(Guid.NewGuid().ToString());
+ BasicConfigurator.Configure(rep, stringAppender);
+ ILog log1 = LogManager.GetLogger(rep.Name, "TestThreadProperiesPattern");
- log1.Logger.Log(new LoggingEvent(evt));
+ log1.Logger.Log(new LoggingEvent(evt));
- string expected = CreateEventNode("Property1", "prop1");
+ string expected = CreateEventNode("Property1", "prop1");
- Assert.AreEqual(expected, stringAppender.GetString());
- }
+ Assert.AreEqual(expected, stringAppender.GetString());
+ }
- [Test]
- public void TestBase64PropertyEventLogging()
- {
- LoggingEventData evt = CreateBaseEvent();
- evt.Properties["Property1"] = "prop1";
+ [Test]
+ public void TestBase64PropertyEventLogging()
+ {
+ LoggingEventData evt = CreateBaseEvent();
+ evt.Properties["Property1"] = "prop1";
- XmlLayout layout = new XmlLayout();
- layout.Base64EncodeProperties = true;
- StringAppender stringAppender = new StringAppender();
- stringAppender.Layout = layout;
+ XmlLayout layout = new XmlLayout();
+ layout.Base64EncodeProperties = true;
+ StringAppender stringAppender = new StringAppender();
+ stringAppender.Layout = layout;
- ILoggerRepository rep = LogManager.CreateRepository(Guid.NewGuid().ToString());
- BasicConfigurator.Configure(rep, stringAppender);
- ILog log1 = LogManager.GetLogger(rep.Name, "TestThreadProperiesPattern");
+ ILoggerRepository rep = LogManager.CreateRepository(Guid.NewGuid().ToString());
+ BasicConfigurator.Configure(rep, stringAppender);
+ ILog log1 = LogManager.GetLogger(rep.Name, "TestThreadProperiesPattern");
- log1.Logger.Log(new LoggingEvent(evt));
+ log1.Logger.Log(new LoggingEvent(evt));
- string expected = CreateEventNode("Property1", "cHJvcDE=");
+ string expected = CreateEventNode("Property1", "cHJvcDE=");
- Assert.AreEqual(expected, stringAppender.GetString());
- }
+ Assert.AreEqual(expected, stringAppender.GetString());
+ }
- [Test]
- public void TestPropertyCharacterEscaping()
- {
- LoggingEventData evt = CreateBaseEvent();
- evt.Properties["Property1"] = "prop1 \"quoted\"";
+ [Test]
+ public void TestPropertyCharacterEscaping()
+ {
+ LoggingEventData evt = CreateBaseEvent();
+ evt.Properties["Property1"] = "prop1 \"quoted\"";
- XmlLayout layout = new XmlLayout();
- StringAppender stringAppender = new StringAppender();
- stringAppender.Layout = layout;
+ XmlLayout layout = new XmlLayout();
+ StringAppender stringAppender = new StringAppender();
+ stringAppender.Layout = layout;
- ILoggerRepository rep = LogManager.CreateRepository(Guid.NewGuid().ToString());
- BasicConfigurator.Configure(rep, stringAppender);
- ILog log1 = LogManager.GetLogger(rep.Name, "TestThreadProperiesPattern");
+ ILoggerRepository rep = LogManager.CreateRepository(Guid.NewGuid().ToString());
+ BasicConfigurator.Configure(rep, stringAppender);
+ ILog log1 = LogManager.GetLogger(rep.Name, "TestThreadProperiesPattern");
- log1.Logger.Log(new LoggingEvent(evt));
+ log1.Logger.Log(new LoggingEvent(evt));
- string expected = CreateEventNode("Property1", "prop1 "quoted"");
+ string expected = CreateEventNode("Property1", "prop1 "quoted"");
- Assert.AreEqual(expected, stringAppender.GetString());
- }
+ Assert.AreEqual(expected, stringAppender.GetString());
+ }
- [Test]
- public void TestPropertyIllegalCharacterMasking()
- {
- LoggingEventData evt = CreateBaseEvent();
- evt.Properties["Property1"] = "mask this ->\uFFFF";
+ [Test]
+ public void TestPropertyIllegalCharacterMasking()
+ {
+ LoggingEventData evt = CreateBaseEvent();
+ evt.Properties["Property1"] = "mask this ->\uFFFF";
- XmlLayout layout = new XmlLayout();
- StringAppender stringAppender = new StringAppender();
- stringAppender.Layout = layout;
+ XmlLayout layout = new XmlLayout();
+ StringAppender stringAppender = new StringAppender();
+ stringAppender.Layout = layout;
- ILoggerRepository rep = LogManager.CreateRepository(Guid.NewGuid().ToString());
- BasicConfigurator.Configure(rep, stringAppender);
- ILog log1 = LogManager.GetLogger(rep.Name, "TestThreadProperiesPattern");
+ ILoggerRepository rep = LogManager.CreateRepository(Guid.NewGuid().ToString());
+ BasicConfigurator.Configure(rep, stringAppender);
+ ILog log1 = LogManager.GetLogger(rep.Name, "TestThreadProperiesPattern");
- log1.Logger.Log(new LoggingEvent(evt));
+ log1.Logger.Log(new LoggingEvent(evt));
- string expected = CreateEventNode("Property1", "mask this ->?");
+ string expected = CreateEventNode("Property1", "mask this ->?");
- Assert.AreEqual(expected, stringAppender.GetString());
- }
+ Assert.AreEqual(expected, stringAppender.GetString());
+ }
- [Test]
- public void TestPropertyIllegalCharacterMaskingInName()
- {
- LoggingEventData evt = CreateBaseEvent();
- evt.Properties["Property\uFFFF"] = "mask this ->\uFFFF";
+ [Test]
+ public void TestPropertyIllegalCharacterMaskingInName()
+ {
+ LoggingEventData evt = CreateBaseEvent();
+ evt.Properties["Property\uFFFF"] = "mask this ->\uFFFF";
- XmlLayout layout = new XmlLayout();
- StringAppender stringAppender = new StringAppender();
- stringAppender.Layout = layout;
+ XmlLayout layout = new XmlLayout();
+ StringAppender stringAppender = new StringAppender();
+ stringAppender.Layout = layout;
- ILoggerRepository rep = LogManager.CreateRepository(Guid.NewGuid().ToString());
- BasicConfigurator.Configure(rep, stringAppender);
- ILog log1 = LogManager.GetLogger(rep.Name, "TestThreadProperiesPattern");
+ ILoggerRepository rep = LogManager.CreateRepository(Guid.NewGuid().ToString());
+ BasicConfigurator.Configure(rep, stringAppender);
+ ILog log1 = LogManager.GetLogger(rep.Name, "TestThreadProperiesPattern");
- log1.Logger.Log(new LoggingEvent(evt));
+ log1.Logger.Log(new LoggingEvent(evt));
- string expected = CreateEventNode("Property?", "mask this ->?");
+ string expected = CreateEventNode("Property?", "mask this ->?");
- Assert.AreEqual(expected, stringAppender.GetString());
- }
+ Assert.AreEqual(expected, stringAppender.GetString());
+ }
#if NET_4_0 || MONO_4_0 || NETSTANDARD
[Test]
@@ -368,5 +368,5 @@
}
}
#endif
- }
+ }
}
\ No newline at end of file
diff --git a/src/log4net.Tests/Util/CyclicBufferTest.cs b/src/log4net.Tests/Util/CyclicBufferTest.cs
index 3ea7932..0d81c48 100644
--- a/src/log4net.Tests/Util/CyclicBufferTest.cs
+++ b/src/log4net.Tests/Util/CyclicBufferTest.cs
@@ -26,84 +26,84 @@
namespace log4net.Tests.Util
{
- /// <summary>
- /// Used for internal unit testing the <see cref="PropertiesDictionary"/> class.
- /// </summary>
- /// <remarks>
- /// Used for internal unit testing the <see cref="PropertiesDictionary"/> class.
- /// </remarks>
- [TestFixture]
- public class CyclicBufferTest
- {
- [Test]
- public void TestConstructorSize0()
- {
- Assert.Throws<ArgumentOutOfRangeException>(() => new CyclicBuffer(0));
- }
+ /// <summary>
+ /// Used for internal unit testing the <see cref="PropertiesDictionary"/> class.
+ /// </summary>
+ /// <remarks>
+ /// Used for internal unit testing the <see cref="PropertiesDictionary"/> class.
+ /// </remarks>
+ [TestFixture]
+ public class CyclicBufferTest
+ {
+ [Test]
+ public void TestConstructorSize0()
+ {
+ Assert.Throws<ArgumentOutOfRangeException>(() => new CyclicBuffer(0));
+ }
- [Test]
- public void TestSize1()
- {
- CyclicBuffer cb = new CyclicBuffer(1);
+ [Test]
+ public void TestSize1()
+ {
+ CyclicBuffer cb = new CyclicBuffer(1);
- Assert.AreEqual(0, cb.Length, "Empty Buffer should have length 0");
- Assert.AreEqual(1, cb.MaxSize, "Buffer should have max size 1");
+ Assert.AreEqual(0, cb.Length, "Empty Buffer should have length 0");
+ Assert.AreEqual(1, cb.MaxSize, "Buffer should have max size 1");
- LoggingEvent event1 = new LoggingEvent(null, null, null, null, null, null);
- LoggingEvent event2 = new LoggingEvent(null, null, null, null, null, null);
+ LoggingEvent event1 = new LoggingEvent(null, null, null, null, null, null);
+ LoggingEvent event2 = new LoggingEvent(null, null, null, null, null, null);
- LoggingEvent discardedEvent = cb.Append(event1);
+ LoggingEvent discardedEvent = cb.Append(event1);
- Assert.IsNull(discardedEvent, "No event should be discarded untill the buffer is full");
- Assert.AreEqual(1, cb.Length, "Buffer should have length 1");
- Assert.AreEqual(1, cb.MaxSize, "Buffer should still have max size 1");
+ Assert.IsNull(discardedEvent, "No event should be discarded untill the buffer is full");
+ Assert.AreEqual(1, cb.Length, "Buffer should have length 1");
+ Assert.AreEqual(1, cb.MaxSize, "Buffer should still have max size 1");
- discardedEvent = cb.Append(event2);
+ discardedEvent = cb.Append(event2);
- Assert.AreSame(event1, discardedEvent, "Expect event1 to now be discarded");
- Assert.AreEqual(1, cb.Length, "Buffer should still have length 1");
- Assert.AreEqual(1, cb.MaxSize, "Buffer should really still have max size 1");
+ Assert.AreSame(event1, discardedEvent, "Expect event1 to now be discarded");
+ Assert.AreEqual(1, cb.Length, "Buffer should still have length 1");
+ Assert.AreEqual(1, cb.MaxSize, "Buffer should really still have max size 1");
- LoggingEvent[] discardedEvents = cb.PopAll();
+ LoggingEvent[] discardedEvents = cb.PopAll();
- Assert.AreEqual(1, discardedEvents.Length, "Poped events length should be 1");
- Assert.AreSame(event2, discardedEvents[0], "Expect event2 to now be popped");
- Assert.AreEqual(0, cb.Length, "Buffer should be back to length 0");
- Assert.AreEqual(1, cb.MaxSize, "Buffer should really really still have max size 1");
- }
+ Assert.AreEqual(1, discardedEvents.Length, "Poped events length should be 1");
+ Assert.AreSame(event2, discardedEvents[0], "Expect event2 to now be popped");
+ Assert.AreEqual(0, cb.Length, "Buffer should be back to length 0");
+ Assert.AreEqual(1, cb.MaxSize, "Buffer should really really still have max size 1");
+ }
- [Test]
- public void TestSize2()
- {
- CyclicBuffer cb = new CyclicBuffer(2);
+ [Test]
+ public void TestSize2()
+ {
+ CyclicBuffer cb = new CyclicBuffer(2);
- Assert.AreEqual(0, cb.Length, "Empty Buffer should have length 0");
- Assert.AreEqual(2, cb.MaxSize, "Buffer should have max size 2");
+ Assert.AreEqual(0, cb.Length, "Empty Buffer should have length 0");
+ Assert.AreEqual(2, cb.MaxSize, "Buffer should have max size 2");
- LoggingEvent event1 = new LoggingEvent(null, null, null, null, null, null);
- LoggingEvent event2 = new LoggingEvent(null, null, null, null, null, null);
- LoggingEvent event3 = new LoggingEvent(null, null, null, null, null, null);
+ LoggingEvent event1 = new LoggingEvent(null, null, null, null, null, null);
+ LoggingEvent event2 = new LoggingEvent(null, null, null, null, null, null);
+ LoggingEvent event3 = new LoggingEvent(null, null, null, null, null, null);
- LoggingEvent discardedEvent;
+ LoggingEvent discardedEvent;
- discardedEvent = cb.Append(event1);
- Assert.IsNull(discardedEvent, "No event should be discarded after append 1");
- discardedEvent = cb.Append(event2);
- Assert.IsNull(discardedEvent, "No event should be discarded after append 2");
+ discardedEvent = cb.Append(event1);
+ Assert.IsNull(discardedEvent, "No event should be discarded after append 1");
+ discardedEvent = cb.Append(event2);
+ Assert.IsNull(discardedEvent, "No event should be discarded after append 2");
- discardedEvent = cb.Append(event3);
- Assert.AreSame(event1, discardedEvent, "Expect event1 to now be discarded");
+ discardedEvent = cb.Append(event3);
+ Assert.AreSame(event1, discardedEvent, "Expect event1 to now be discarded");
- discardedEvent = cb.PopOldest();
- Assert.AreSame(event2, discardedEvent, "Expect event2 to now be discarded");
+ discardedEvent = cb.PopOldest();
+ Assert.AreSame(event2, discardedEvent, "Expect event2 to now be discarded");
- LoggingEvent[] discardedEvents = cb.PopAll();
+ LoggingEvent[] discardedEvents = cb.PopAll();
- Assert.AreEqual(1, discardedEvents.Length, "Poped events length should be 1");
- Assert.AreSame(event3, discardedEvents[0], "Expect event3 to now be popped");
- Assert.AreEqual(0, cb.Length, "Buffer should be back to length 0");
- Assert.AreEqual(2, cb.MaxSize, "Buffer should really really still have max size 2");
- }
- }
+ Assert.AreEqual(1, discardedEvents.Length, "Poped events length should be 1");
+ Assert.AreSame(event3, discardedEvents[0], "Expect event3 to now be popped");
+ Assert.AreEqual(0, cb.Length, "Buffer should be back to length 0");
+ Assert.AreEqual(2, cb.MaxSize, "Buffer should really really still have max size 2");
+ }
+ }
}
\ No newline at end of file
diff --git a/src/log4net.Tests/Util/EnvironmentPatternConverterTest.cs b/src/log4net.Tests/Util/EnvironmentPatternConverterTest.cs
index cced28c..e475ae5 100644
--- a/src/log4net.Tests/Util/EnvironmentPatternConverterTest.cs
+++ b/src/log4net.Tests/Util/EnvironmentPatternConverterTest.cs
@@ -50,8 +50,8 @@
converter.Option = ENVIRONMENT_VARIABLE_NAME;
- StringWriter sw = new StringWriter();
- converter.Convert(sw, null);
+ StringWriter sw = new StringWriter();
+ converter.Convert(sw, null);
Assert.AreEqual(SYSTEM_LEVEL_VALUE, sw.ToString(), "System level environment variable not expended correctly.");
diff --git a/src/log4net.Tests/Util/PropertiesDictionaryTest.cs b/src/log4net.Tests/Util/PropertiesDictionaryTest.cs
index e44f4a8..04d66c8 100644
--- a/src/log4net.Tests/Util/PropertiesDictionaryTest.cs
+++ b/src/log4net.Tests/Util/PropertiesDictionaryTest.cs
@@ -28,44 +28,44 @@
namespace log4net.Tests.Util
{
- /// <summary>
- /// Used for internal unit testing the <see cref="PropertiesDictionary"/> class.
- /// </summary>
- /// <remarks>
- /// Used for internal unit testing the <see cref="PropertiesDictionary"/> class.
- /// </remarks>
- [TestFixture]
- public class PropertiesDictionaryTest
- {
- [Test]
- public void TestSerialization()
- {
- PropertiesDictionary pd = new PropertiesDictionary();
+ /// <summary>
+ /// Used for internal unit testing the <see cref="PropertiesDictionary"/> class.
+ /// </summary>
+ /// <remarks>
+ /// Used for internal unit testing the <see cref="PropertiesDictionary"/> class.
+ /// </remarks>
+ [TestFixture]
+ public class PropertiesDictionaryTest
+ {
+ [Test]
+ public void TestSerialization()
+ {
+ PropertiesDictionary pd = new PropertiesDictionary();
- for(int i = 0; i < 10; i++)
- {
- pd[i.ToString()] = i;
- }
+ for(int i = 0; i < 10; i++)
+ {
+ pd[i.ToString()] = i;
+ }
- Assert.AreEqual(10, pd.Count, "Dictionary should have 10 items");
+ Assert.AreEqual(10, pd.Count, "Dictionary should have 10 items");
- // Serialize the properties into a memory stream
- BinaryFormatter formatter = new BinaryFormatter();
- MemoryStream memory = new MemoryStream();
- formatter.Serialize(memory, pd);
+ // Serialize the properties into a memory stream
+ BinaryFormatter formatter = new BinaryFormatter();
+ MemoryStream memory = new MemoryStream();
+ formatter.Serialize(memory, pd);
- // Deserialize the stream into a new properties dictionary
- memory.Position = 0;
- PropertiesDictionary pd2 = (PropertiesDictionary)formatter.Deserialize(memory);
+ // Deserialize the stream into a new properties dictionary
+ memory.Position = 0;
+ PropertiesDictionary pd2 = (PropertiesDictionary)formatter.Deserialize(memory);
- Assert.AreEqual(10, pd2.Count, "Deserialized Dictionary should have 10 items");
+ Assert.AreEqual(10, pd2.Count, "Deserialized Dictionary should have 10 items");
- foreach(string key in pd.GetKeys())
- {
- Assert.AreEqual(pd[key], pd2[key], "Check Value Persisted for key [{0}]", key);
- }
- }
- }
+ foreach(string key in pd.GetKeys())
+ {
+ Assert.AreEqual(pd[key], pd2[key], "Check Value Persisted for key [{0}]", key);
+ }
+ }
+ }
}
#endif
diff --git a/src/log4net.Tests/Util/RandomStringPatternConverterTest.cs b/src/log4net.Tests/Util/RandomStringPatternConverterTest.cs
index e586a9d..adb3e40 100644
--- a/src/log4net.Tests/Util/RandomStringPatternConverterTest.cs
+++ b/src/log4net.Tests/Util/RandomStringPatternConverterTest.cs
@@ -23,68 +23,68 @@
namespace log4net.Tests.Util
{
- /// <summary>
- /// Used for internal unit testing the <see cref="RandomStringPatternConverter"/> class.
- /// </summary>
- /// <remarks>
- /// Used for internal unit testing the <see cref="RandomStringPatternConverter"/> class.
- /// </remarks>
- [TestFixture]
- public class RandomStringPatternConverterTest
- {
- [Test]
- public void TestConvert()
- {
- RandomStringPatternConverter converter = new RandomStringPatternConverter();
+ /// <summary>
+ /// Used for internal unit testing the <see cref="RandomStringPatternConverter"/> class.
+ /// </summary>
+ /// <remarks>
+ /// Used for internal unit testing the <see cref="RandomStringPatternConverter"/> class.
+ /// </remarks>
+ [TestFixture]
+ public class RandomStringPatternConverterTest
+ {
+ [Test]
+ public void TestConvert()
+ {
+ RandomStringPatternConverter converter = new RandomStringPatternConverter();
- // Check default string length
- StringWriter sw = new StringWriter();
- converter.Convert(sw, null);
+ // Check default string length
+ StringWriter sw = new StringWriter();
+ converter.Convert(sw, null);
- Assert.AreEqual(4, sw.ToString().Length, "Default string length should be 4");
+ Assert.AreEqual(4, sw.ToString().Length, "Default string length should be 4");
- // Set string length to 7
- converter.Option = "7";
- converter.ActivateOptions();
+ // Set string length to 7
+ converter.Option = "7";
+ converter.ActivateOptions();
- sw = new StringWriter();
- converter.Convert(sw, null);
+ sw = new StringWriter();
+ converter.Convert(sw, null);
- string string1 = sw.ToString();
- Assert.AreEqual(7, string1.Length, "string length should be 7");
+ string string1 = sw.ToString();
+ Assert.AreEqual(7, string1.Length, "string length should be 7");
- // Check for duplicate result
- sw = new StringWriter();
- converter.Convert(sw, null);
+ // Check for duplicate result
+ sw = new StringWriter();
+ converter.Convert(sw, null);
- string string2 = sw.ToString();
- Assert.IsTrue(string1 != string2, "strings should be different");
- }
+ string string2 = sw.ToString();
+ Assert.IsTrue(string1 != string2, "strings should be different");
+ }
- private class RandomStringPatternConverter
- {
- private object target = null;
+ private class RandomStringPatternConverter
+ {
+ private object target = null;
- public RandomStringPatternConverter()
- {
- target = Utils.CreateInstance("log4net.Util.PatternStringConverters.RandomStringPatternConverter,log4net");
- }
+ public RandomStringPatternConverter()
+ {
+ target = Utils.CreateInstance("log4net.Util.PatternStringConverters.RandomStringPatternConverter,log4net");
+ }
- public string Option
- {
- get { return Utils.GetProperty(target, "Option") as string; }
- set { Utils.SetProperty(target, "Option", value); }
- }
+ public string Option
+ {
+ get { return Utils.GetProperty(target, "Option") as string; }
+ set { Utils.SetProperty(target, "Option", value); }
+ }
- public void Convert(TextWriter writer, object state)
- {
- Utils.InvokeMethod(target, "Convert", writer, state);
- }
+ public void Convert(TextWriter writer, object state)
+ {
+ Utils.InvokeMethod(target, "Convert", writer, state);
+ }
- public void ActivateOptions()
- {
- Utils.InvokeMethod(target, "ActivateOptions");
- }
- }
- }
+ public void ActivateOptions()
+ {
+ Utils.InvokeMethod(target, "ActivateOptions");
+ }
+ }
+ }
}
\ No newline at end of file
diff --git a/src/log4net.Tests/Util/SystemInfoTest.cs b/src/log4net.Tests/Util/SystemInfoTest.cs
index ee2b518..b943e09 100644
--- a/src/log4net.Tests/Util/SystemInfoTest.cs
+++ b/src/log4net.Tests/Util/SystemInfoTest.cs
@@ -30,145 +30,145 @@
namespace log4net.Tests.Util
{
- /// <summary>
- /// Used for internal unit testing the <see cref="SystemInfo"/> class.
- /// </summary>
- [TestFixture]
- public class SystemInfoTest
- {
+ /// <summary>
+ /// Used for internal unit testing the <see cref="SystemInfo"/> class.
+ /// </summary>
+ [TestFixture]
+ public class SystemInfoTest
+ {
#if NET_4_0 || MONO_4_0 || NETSTANDARD
- /// <summary>
- /// It's "does not throw not supported exception" NOT
- /// "returns 'Dynamic Assembly' string for dynamic assemblies" by purpose.
- /// <see cref="Assembly.GetCallingAssembly"/> can be JITted and inlined in different release configurations,
- /// thus we cannot determine what the exact result of this test will be.
- /// In 'Debug' GetCallingAssembly should return dynamic assembly named: 'Anonymously Hosted DynamicMethods Assembly'
- /// whereas in 'Release' this will be inlined and the result will be something like 'X:\Y\Z\log4net.Tests.dll'.
- /// Therefore simple check against dynamic assembly
- /// in <see cref="SystemInfo.AssemblyLocationInfo"/> to avoid <see cref="NotSupportedException"/> 'Debug' release.
- /// </summary>
- [Test]
- public void TestAssemblyLocationInfoDoesNotThrowNotSupportedExceptionForDynamicAssembly()
- {
- var systemInfoAssemblyLocationMethod = GetAssemblyLocationInfoMethodCall();
+ /// <summary>
+ /// It's "does not throw not supported exception" NOT
+ /// "returns 'Dynamic Assembly' string for dynamic assemblies" by purpose.
+ /// <see cref="Assembly.GetCallingAssembly"/> can be JITted and inlined in different release configurations,
+ /// thus we cannot determine what the exact result of this test will be.
+ /// In 'Debug' GetCallingAssembly should return dynamic assembly named: 'Anonymously Hosted DynamicMethods Assembly'
+ /// whereas in 'Release' this will be inlined and the result will be something like 'X:\Y\Z\log4net.Tests.dll'.
+ /// Therefore simple check against dynamic assembly
+ /// in <see cref="SystemInfo.AssemblyLocationInfo"/> to avoid <see cref="NotSupportedException"/> 'Debug' release.
+ /// </summary>
+ [Test]
+ public void TestAssemblyLocationInfoDoesNotThrowNotSupportedExceptionForDynamicAssembly()
+ {
+ var systemInfoAssemblyLocationMethod = GetAssemblyLocationInfoMethodCall();
- Assert.DoesNotThrow(() => systemInfoAssemblyLocationMethod());
- }
+ Assert.DoesNotThrow(() => systemInfoAssemblyLocationMethod());
+ }
- private static Func<string> GetAssemblyLocationInfoMethodCall()
- {
- var method = typeof(SystemInfoTest).GetMethod("TestAssemblyLocationInfoMethod", new Type[0]);
- var methodCall = Expression.Call(null, method, new Expression[0]);
- return Expression.Lambda<Func<string>>(methodCall, new ParameterExpression[0]).Compile();
- }
+ private static Func<string> GetAssemblyLocationInfoMethodCall()
+ {
+ var method = typeof(SystemInfoTest).GetMethod("TestAssemblyLocationInfoMethod", new Type[0]);
+ var methodCall = Expression.Call(null, method, new Expression[0]);
+ return Expression.Lambda<Func<string>>(methodCall, new ParameterExpression[0]).Compile();
+ }
- public static string TestAssemblyLocationInfoMethod()
- {
+ public static string TestAssemblyLocationInfoMethod()
+ {
#if NETSTANDARD1_3
- return SystemInfo.AssemblyLocationInfo(typeof(SystemInfoTest).GetTypeInfo().Assembly);
+ return SystemInfo.AssemblyLocationInfo(typeof(SystemInfoTest).GetTypeInfo().Assembly);
#else
- return SystemInfo.AssemblyLocationInfo(Assembly.GetCallingAssembly());
+ return SystemInfo.AssemblyLocationInfo(Assembly.GetCallingAssembly());
#endif
- }
+ }
#endif
- [Test]
- public void TestGetTypeFromStringFullyQualified()
- {
- Type t;
+ [Test]
+ public void TestGetTypeFromStringFullyQualified()
+ {
+ Type t;
- t = GetTypeFromString("log4net.Tests.Util.SystemInfoTest,log4net.Tests", false, false);
- Assert.AreSame(typeof(SystemInfoTest), t, "Test explicit case sensitive type load");
+ t = GetTypeFromString("log4net.Tests.Util.SystemInfoTest,log4net.Tests", false, false);
+ Assert.AreSame(typeof(SystemInfoTest), t, "Test explicit case sensitive type load");
- t = GetTypeFromString("LOG4NET.TESTS.UTIL.SYSTEMINFOTEST,log4net.Tests", false, true);
- Assert.AreSame(typeof(SystemInfoTest), t, "Test explicit case in-sensitive type load caps");
+ t = GetTypeFromString("LOG4NET.TESTS.UTIL.SYSTEMINFOTEST,log4net.Tests", false, true);
+ Assert.AreSame(typeof(SystemInfoTest), t, "Test explicit case in-sensitive type load caps");
- t = GetTypeFromString("log4net.tests.util.systeminfotest,log4net.Tests", false, true);
- Assert.AreSame(typeof(SystemInfoTest), t, "Test explicit case in-sensitive type load lower");
- }
+ t = GetTypeFromString("log4net.tests.util.systeminfotest,log4net.Tests", false, true);
+ Assert.AreSame(typeof(SystemInfoTest), t, "Test explicit case in-sensitive type load lower");
+ }
#if !NETSTANDARD1_3
- [Test][Platform(Include="Win")]
- public void TestGetTypeFromStringCaseInsensitiveOnAssemblyName()
- {
- Type t;
+ [Test][Platform(Include="Win")]
+ public void TestGetTypeFromStringCaseInsensitiveOnAssemblyName()
+ {
+ Type t;
- t = GetTypeFromString("LOG4NET.TESTS.UTIL.SYSTEMINFOTEST,LOG4NET.TESTS", false, true);
- Assert.AreSame(typeof(SystemInfoTest), t, "Test explicit case in-sensitive type load caps");
+ t = GetTypeFromString("LOG4NET.TESTS.UTIL.SYSTEMINFOTEST,LOG4NET.TESTS", false, true);
+ Assert.AreSame(typeof(SystemInfoTest), t, "Test explicit case in-sensitive type load caps");
- t = GetTypeFromString("log4net.tests.util.systeminfotest,log4net.tests", false, true);
- Assert.AreSame(typeof(SystemInfoTest), t, "Test explicit case in-sensitive type load lower");
- }
+ t = GetTypeFromString("log4net.tests.util.systeminfotest,log4net.tests", false, true);
+ Assert.AreSame(typeof(SystemInfoTest), t, "Test explicit case in-sensitive type load lower");
+ }
#endif
- [Test]
- public void TestGetTypeFromStringRelative()
- {
- Type t;
+ [Test]
+ public void TestGetTypeFromStringRelative()
+ {
+ Type t;
- t = GetTypeFromString("log4net.Tests.Util.SystemInfoTest", false, false);
- Assert.AreSame(typeof(SystemInfoTest), t, "Test explicit case sensitive type load");
+ t = GetTypeFromString("log4net.Tests.Util.SystemInfoTest", false, false);
+ Assert.AreSame(typeof(SystemInfoTest), t, "Test explicit case sensitive type load");
- t = GetTypeFromString("LOG4NET.TESTS.UTIL.SYSTEMINFOTEST", false, true);
- Assert.AreSame(typeof(SystemInfoTest), t, "Test explicit case in-sensitive type load caps");
+ t = GetTypeFromString("LOG4NET.TESTS.UTIL.SYSTEMINFOTEST", false, true);
+ Assert.AreSame(typeof(SystemInfoTest), t, "Test explicit case in-sensitive type load caps");
- t = GetTypeFromString("log4net.tests.util.systeminfotest", false, true);
- Assert.AreSame(typeof(SystemInfoTest), t, "Test explicit case in-sensitive type load lower");
- }
+ t = GetTypeFromString("log4net.tests.util.systeminfotest", false, true);
+ Assert.AreSame(typeof(SystemInfoTest), t, "Test explicit case in-sensitive type load lower");
+ }
#if !NETSTANDARD1_3
- [Test]
- public void TestGetTypeFromStringSearch()
- {
- Type t;
+ [Test]
+ public void TestGetTypeFromStringSearch()
+ {
+ Type t;
- t = GetTypeFromString("log4net.Util.SystemInfo", false, false);
- Assert.AreSame(typeof(SystemInfo), t,
+ t = GetTypeFromString("log4net.Util.SystemInfo", false, false);
+ Assert.AreSame(typeof(SystemInfo), t,
string.Format("Test explicit case sensitive type load found {0} rather than {1}",
t.AssemblyQualifiedName, typeof(SystemInfo).AssemblyQualifiedName));
- t = GetTypeFromString("LOG4NET.UTIL.SYSTEMINFO", false, true);
- Assert.AreSame(typeof(SystemInfo), t, "Test explicit case in-sensitive type load caps");
+ t = GetTypeFromString("LOG4NET.UTIL.SYSTEMINFO", false, true);
+ Assert.AreSame(typeof(SystemInfo), t, "Test explicit case in-sensitive type load caps");
- t = GetTypeFromString("log4net.util.systeminfo", false, true);
- Assert.AreSame(typeof(SystemInfo), t, "Test explicit case in-sensitive type load lower");
- }
+ t = GetTypeFromString("log4net.util.systeminfo", false, true);
+ Assert.AreSame(typeof(SystemInfo), t, "Test explicit case in-sensitive type load lower");
+ }
#endif
- [Test]
- public void TestGetTypeFromStringFails1()
- {
- Type t;
+ [Test]
+ public void TestGetTypeFromStringFails1()
+ {
+ Type t;
- t = GetTypeFromString("LOG4NET.TESTS.UTIL.SYSTEMINFOTEST,LOG4NET.TESTS", false, false);
- Assert.AreSame(null, t, "Test explicit case sensitive fails type load");
+ t = GetTypeFromString("LOG4NET.TESTS.UTIL.SYSTEMINFOTEST,LOG4NET.TESTS", false, false);
+ Assert.AreSame(null, t, "Test explicit case sensitive fails type load");
- Assert.Throws<TypeLoadException>(() => GetTypeFromString("LOG4NET.TESTS.UTIL.SYSTEMINFOTEST,LOG4NET.TESTS", true, false));
- }
+ Assert.Throws<TypeLoadException>(() => GetTypeFromString("LOG4NET.TESTS.UTIL.SYSTEMINFOTEST,LOG4NET.TESTS", true, false));
+ }
- [Test]
- public void TestGetTypeFromStringFails2()
- {
- Type t;
+ [Test]
+ public void TestGetTypeFromStringFails2()
+ {
+ Type t;
- t = GetTypeFromString("LOG4NET.TESTS.UTIL.SYSTEMINFOTEST", false, false);
- Assert.AreSame(null, t, "Test explicit case sensitive fails type load");
+ t = GetTypeFromString("LOG4NET.TESTS.UTIL.SYSTEMINFOTEST", false, false);
+ Assert.AreSame(null, t, "Test explicit case sensitive fails type load");
Assert.Throws<TypeLoadException>(() => GetTypeFromString("LOG4NET.TESTS.UTIL.SYSTEMINFOTEST", true, false));
- }
+ }
- // Wraps SystemInfo.GetTypeFromString because the method relies on GetCallingAssembly, which is
- // unavailable in CoreFX. As a workaround, only overloads which explicitly take a Type or Assembly
- // are exposed for NETSTANDARD1_3.
- private Type GetTypeFromString(string typeName, bool throwOnError, bool ignoreCase)
- {
+ // Wraps SystemInfo.GetTypeFromString because the method relies on GetCallingAssembly, which is
+ // unavailable in CoreFX. As a workaround, only overloads which explicitly take a Type or Assembly
+ // are exposed for NETSTANDARD1_3.
+ private Type GetTypeFromString(string typeName, bool throwOnError, bool ignoreCase)
+ {
#if NETSTANDARD1_3
- return SystemInfo.GetTypeFromString(GetType().GetTypeInfo().Assembly, typeName, throwOnError, ignoreCase);
+ return SystemInfo.GetTypeFromString(GetType().GetTypeInfo().Assembly, typeName, throwOnError, ignoreCase);
#else
- return SystemInfo.GetTypeFromString(typeName, throwOnError, ignoreCase);
+ return SystemInfo.GetTypeFromString(typeName, throwOnError, ignoreCase);
#endif
- }
+ }
[Test]
public void EqualsIgnoringCase_BothNull_true()
@@ -205,5 +205,5 @@
{
Assert.False(SystemInfo.EqualsIgnoringCase("foo", "foobar"));
}
- }
+ }
}
diff --git a/src/log4net.Tests/Utils.cs b/src/log4net.Tests/Utils.cs
index ea1bc82..d4ad631 100644
--- a/src/log4net.Tests/Utils.cs
+++ b/src/log4net.Tests/Utils.cs
@@ -23,96 +23,96 @@
namespace log4net.Tests
{
- /// <summary>
- /// Summary description for Class1.
- /// </summary>
- public class Utils
- {
- private Utils()
- {
- }
+ /// <summary>
+ /// Summary description for Class1.
+ /// </summary>
+ public class Utils
+ {
+ private Utils()
+ {
+ }
- public static object CreateInstance(string targetType)
- {
- return CreateInstance(Type.GetType(targetType, true, true));
- }
+ public static object CreateInstance(string targetType)
+ {
+ return CreateInstance(Type.GetType(targetType, true, true));
+ }
- public static object CreateInstance(Type targetType)
- {
+ public static object CreateInstance(Type targetType)
+ {
#if NETSTANDARD1_3
- return targetType.GetConstructor(new Type[0]).Invoke(null);
+ return targetType.GetConstructor(new Type[0]).Invoke(null);
#else
- return targetType.GetConstructor(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance, null, new Type[0], null).Invoke(null);
+ return targetType.GetConstructor(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance, null, new Type[0], null).Invoke(null);
#endif
- }
+ }
- public static object InvokeMethod(object target, string name, params object[] args)
- {
+ public static object InvokeMethod(object target, string name, params object[] args)
+ {
#if NETSTANDARD1_3
- return target.GetType().GetTypeInfo().GetDeclaredMethod(name).Invoke(target, args);
+ return target.GetType().GetTypeInfo().GetDeclaredMethod(name).Invoke(target, args);
#else
- return target.GetType().GetMethod(name, BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance, null, GetTypesArray(args), null).Invoke(target, args);
+ return target.GetType().GetMethod(name, BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance, null, GetTypesArray(args), null).Invoke(target, args);
#endif
- }
+ }
- public static object InvokeMethod(Type target, string name, params object[] args)
- {
+ public static object InvokeMethod(Type target, string name, params object[] args)
+ {
#if NETSTANDARD1_3
- return target.GetTypeInfo().GetDeclaredMethod(name).Invoke(null, args);
+ return target.GetTypeInfo().GetDeclaredMethod(name).Invoke(null, args);
#else
- return target.GetMethod(name, BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static, null, GetTypesArray(args), null).Invoke(null, args);
+ return target.GetMethod(name, BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static, null, GetTypesArray(args), null).Invoke(null, args);
#endif
- }
+ }
- public static object GetField(object target, string name)
- {
- return target.GetType().GetField(name, BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance).GetValue(target);
- }
+ public static object GetField(object target, string name)
+ {
+ return target.GetType().GetField(name, BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance).GetValue(target);
+ }
- public static void SetField(object target, string name, object val)
- {
- target.GetType().GetField(name, BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance).SetValue(target, val);
- }
+ public static void SetField(object target, string name, object val)
+ {
+ target.GetType().GetField(name, BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance).SetValue(target, val);
+ }
- public static object GetProperty(object target, string name)
- {
- return target.GetType().GetProperty(name, BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance).GetValue(target, null);
- }
+ public static object GetProperty(object target, string name)
+ {
+ return target.GetType().GetProperty(name, BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance).GetValue(target, null);
+ }
- public static void SetProperty(object target, string name, object val)
- {
- target.GetType().GetProperty(name, BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance).SetValue(target, val, null);
- }
+ public static void SetProperty(object target, string name, object val)
+ {
+ target.GetType().GetProperty(name, BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance).SetValue(target, val, null);
+ }
- public static object GetProperty(object target, string name, params object[] index)
- {
- return target.GetType().GetProperty(name, BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance).GetValue(target, index);
- }
+ public static object GetProperty(object target, string name, params object[] index)
+ {
+ return target.GetType().GetProperty(name, BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance).GetValue(target, index);
+ }
- public static void SetProperty(object target, string name, object val, params object[] index)
- {
- target.GetType().GetProperty(name, BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance).SetValue(target, val, index);
- }
+ public static void SetProperty(object target, string name, object val, params object[] index)
+ {
+ target.GetType().GetProperty(name, BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance).SetValue(target, val, index);
+ }
- private static Type[] GetTypesArray(object[] args)
- {
- Type[] types = new Type[args.Length];
+ private static Type[] GetTypesArray(object[] args)
+ {
+ Type[] types = new Type[args.Length];
- for(int i = 0; i < args.Length; i++)
- {
- if (args[i] == null)
- {
- types[i] = typeof(object);
- }
- else
- {
- types[i] = args[i].GetType();
- }
- }
+ for(int i = 0; i < args.Length; i++)
+ {
+ if (args[i] == null)
+ {
+ types[i] = typeof(object);
+ }
+ else
+ {
+ types[i] = args[i].GetType();
+ }
+ }
- return types;
- }
+ return types;
+ }
internal const string PROPERTY_KEY = "prop1";
