From f3828ea6885be4b1a6816d52d6d858dc8def5296 Mon Sep 17 00:00:00 2001
From: Furkan VAROL <furkanvarol@hotmail.com>
Date: Tue, 10 Mar 2015 23:07:20 +0200
Subject: [PATCH 1/9] Logger interfaces has been implemented also Diagnostics
 loggers have been implemented (no unit test yet)

---
 AltBeacon.Library/AltBeacon.Library.csproj    |  10 +
 .../Logging/BaseDiagnosticsLogger.cs          | 348 ++++++++++++++++++
 .../src/AltBeacon/Logging/EmptyLogger.cs      | 286 ++++++++++++++
 .../AltBeacon/Logging/EmptyLoggerFactory.cs   |  45 +++
 .../src/AltBeacon/Logging/ILogger.cs          | 251 +++++++++++++
 .../src/AltBeacon/Logging/ILoggerFactory.cs   |  43 +++
 .../src/AltBeacon/Logging/LogManager.cs       | 128 +++++++
 .../Logging/VerboseDiagnosticsLogger.cs       | 308 ++++++++++++++++
 .../VerboseDiagnosticsLoggerFactory.cs        |  46 +++
 .../Logging/WarningDiagnosticsLogger.cs       | 284 ++++++++++++++
 .../WarningDiagnosticsLoggerFactory.cs        |  46 +++
 11 files changed, 1795 insertions(+)
 create mode 100644 AltBeacon.Library/src/AltBeacon/Logging/BaseDiagnosticsLogger.cs
 create mode 100644 AltBeacon.Library/src/AltBeacon/Logging/EmptyLogger.cs
 create mode 100644 AltBeacon.Library/src/AltBeacon/Logging/EmptyLoggerFactory.cs
 create mode 100644 AltBeacon.Library/src/AltBeacon/Logging/ILogger.cs
 create mode 100644 AltBeacon.Library/src/AltBeacon/Logging/ILoggerFactory.cs
 create mode 100644 AltBeacon.Library/src/AltBeacon/Logging/LogManager.cs
 create mode 100644 AltBeacon.Library/src/AltBeacon/Logging/VerboseDiagnosticsLogger.cs
 create mode 100644 AltBeacon.Library/src/AltBeacon/Logging/VerboseDiagnosticsLoggerFactory.cs
 create mode 100644 AltBeacon.Library/src/AltBeacon/Logging/WarningDiagnosticsLogger.cs
 create mode 100644 AltBeacon.Library/src/AltBeacon/Logging/WarningDiagnosticsLoggerFactory.cs

diff --git a/AltBeacon.Library/AltBeacon.Library.csproj b/AltBeacon.Library/AltBeacon.Library.csproj
index 5e2b9eb..f846335 100644
--- a/AltBeacon.Library/AltBeacon.Library.csproj
+++ b/AltBeacon.Library/AltBeacon.Library.csproj
@@ -44,6 +44,16 @@
     </Compile>
     <Compile Include="src\AltBeacon\Beacon\Identifier.cs" />
     <Compile Include="src\AltBeacon\Bluetooth\BluetoothDevice.cs" />
+    <Compile Include="src\AltBeacon\Logging\BaseDiagnosticsLogger.cs" />
+    <Compile Include="src\AltBeacon\Logging\EmptyLogger.cs" />
+    <Compile Include="src\AltBeacon\Logging\EmptyLoggerFactory.cs" />
+    <Compile Include="src\AltBeacon\Logging\ILogger.cs" />
+    <Compile Include="src\AltBeacon\Logging\ILoggerFactory.cs" />
+    <Compile Include="src\AltBeacon\Logging\LogManager.cs" />
+    <Compile Include="src\AltBeacon\Logging\VerboseDiagnosticsLogger.cs" />
+    <Compile Include="src\AltBeacon\Logging\VerboseDiagnosticsLoggerFactory.cs" />
+    <Compile Include="src\AltBeacon\Logging\WarningDiagnosticsLogger.cs" />
+    <Compile Include="src\AltBeacon\Logging\WarningDiagnosticsLoggerFactory.cs" />
   </ItemGroup>
   <Import Project="$(MSBuildExtensionsPath32)\Microsoft\Portable\$(TargetFrameworkVersion)\Microsoft.Portable.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
diff --git a/AltBeacon.Library/src/AltBeacon/Logging/BaseDiagnosticsLogger.cs b/AltBeacon.Library/src/AltBeacon/Logging/BaseDiagnosticsLogger.cs
new file mode 100644
index 0000000..e70ca0b
--- /dev/null
+++ b/AltBeacon.Library/src/AltBeacon/Logging/BaseDiagnosticsLogger.cs
@@ -0,0 +1,348 @@
+// <copyright file="BaseDiagnosticsLogger.cs" company="Radius Networks, Inc.">
+//     Copyright (c) Radius Networks, Inc.
+//     http://www.radiusnetworks.com
+// </copyright>
+// 
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements. See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership. The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License. You may obtain a copy of the License at
+// 
+// http://www.apache.org/licenses/LICENSE-2.0
+// 
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations
+// under the License.
+namespace AltBeacon.Logging
+{
+    using System;
+    using System.Text;
+
+    /// <summary>
+    /// Base class for Diagnostics Loggers which uses
+    /// <see cref="System.Diagnostics.Debug"/>
+    /// </summary>
+    public abstract class BaseDiagnosticsLogger : ILogger
+    {
+        #region Fields
+        /// <summary>
+        /// Date Format for log messages
+        /// </summary>
+        public const string DateFormat = "yyyy-MM-dd HH:mm:ss.fff";
+
+        /// <summary>
+        /// <see cref="Name"/>
+        /// </summary>
+        private string name;
+        #endregion Fields
+
+        #region Constructor
+        /// <summary>
+        /// Initializes a new instance of the <see cref="BaseDiagnosticsLogger"/> class.
+        /// </summary>
+        /// <param name="name">
+        /// Identifier of the source of a log message. It usually
+        /// identifies the class or activity where the log call occurs.
+        /// </param>
+        public BaseDiagnosticsLogger(string name)
+        {
+            this.name = name;
+        }
+        #endregion Constructor
+
+        #region Name
+        /// <summary>
+        /// Gets identifier of the source of a log message. It usually
+        /// identifies the class or activity where the log call occurs.
+        /// </summary>
+        public string Name
+        {
+            get
+            {
+                return this.name;
+            }
+        }
+        #endregion Error
+
+        #region Trace
+        /// <summary>
+        /// Logs a trace message (same level as verbose - NLog Trace).
+        /// </summary>
+        /// <param name="message">
+        /// The message you would like logged. This message may contain
+        /// string formatting which will be replaced with values from args.
+        /// </param>
+        /// <param name="args">
+        /// Arguments for string formatting.
+        /// </param>
+        /// <seealso cref="Verbose(String, Object[])"/>
+        public abstract void Trace(string message, params object[] args);
+
+        /// <summary>
+        /// Logs a trace message (same level as verbose - NLog Trace).
+        /// </summary>
+        /// <param name="exception">
+        /// An exception to log.
+        /// </param>
+        /// <param name="message">
+        /// The message you would like logged. This message may contain
+        /// string formatting which will be replaced with values from args.
+        /// </param>
+        /// <param name="args">
+        /// Arguments for string formatting.
+        /// </param>
+        /// <seealso cref="Verbose(Exception, String, Object[])"/>
+        public abstract void Trace(Exception exception, string message, params object[] args);
+        #endregion Trace
+
+        #region Verbose
+        /// <summary>
+        /// Logs a verbose message (same level as trace also to support Android based coders).
+        /// </summary>
+        /// <param name="message">
+        /// The message you would like logged. This message may contain
+        /// string formatting which will be replaced with values from args.
+        /// </param>
+        /// <param name="args">
+        /// Arguments for string formatting.
+        /// </param>
+        /// <seealso cref="Trace(String, Object[])"/>
+        public abstract void Verbose(string message, params object[] args);
+
+        /// <summary>
+        /// Logs a verbose message (same level as trace also to support Android based coders).
+        /// </summary>
+        /// <param name="exception">
+        /// An exception to log.
+        /// </param>
+        /// <param name="message">
+        /// The message you would like logged. This message may contain
+        /// string formatting which will be replaced with values from args.
+        /// </param>
+        /// <param name="args">
+        /// Arguments for string formatting.
+        /// </param>
+        /// <seealso cref="Trace(Exception, String, Object[])"/>
+        public abstract void Verbose(Exception exception, string message, params object[] args);
+        #endregion Verbose
+
+        #region Debug
+        /// <summary>
+        /// Logs a debug message.
+        /// </summary>
+        /// <param name="message">
+        /// The message you would like logged. This message may contain
+        /// string formatting which will be replaced with values from args.
+        /// </param>
+        /// <param name="args">
+        /// Arguments for string formatting.
+        /// </param>
+        public abstract void Debug(string message, params object[] args);
+
+        /// <summary>
+        /// Logs a debug message.
+        /// </summary>
+        /// <param name="exception">
+        /// An exception to log.
+        /// </param>
+        /// <param name="message">
+        /// The message you would like logged. This message may contain
+        /// string formatting which will be replaced with values from args.
+        /// </param>
+        /// <param name="args">
+        /// Arguments for string formatting.
+        /// </param>
+        public abstract void Debug(Exception exception, string message, params object[] args);
+        #endregion Debug
+
+        #region Info
+        /// <summary>
+        /// Logs a info message.
+        /// </summary>
+        /// <param name="message">
+        /// The message you would like logged. This message may contain
+        /// string formatting which will be replaced with values from args.
+        /// </param>
+        /// <param name="args">
+        /// Arguments for string formatting.
+        /// </param>
+        public abstract void Info(string message, params object[] args);
+
+        /// <summary>
+        /// Logs a info message.
+        /// </summary>
+        /// <param name="exception">
+        /// An exception to log.
+        /// </param>
+        /// <param name="message">
+        /// The message you would like logged. This message may contain
+        /// string formatting which will be replaced with values from args.
+        /// </param>
+        /// <param name="args">
+        /// Arguments for string formatting.
+        /// </param>
+        public abstract void Info(Exception exception, string message, params object[] args);
+        #endregion Info
+
+        #region Warn
+        /// <summary>
+        /// Logs a warning message.
+        /// </summary>
+        /// <param name="message">
+        /// The message you would like logged. This message may contain
+        /// string formatting which will be replaced with values from args.
+        /// </param>
+        /// <param name="args">
+        /// Arguments for string formatting.
+        /// </param>
+        public abstract void Warn(string message, params object[] args);
+
+        /// <summary>
+        /// Logs a warning message.
+        /// </summary>
+        /// <param name="exception">
+        /// An exception to log.
+        /// </param>
+        /// <param name="message">
+        /// The message you would like logged. This message may contain
+        /// string formatting which will be replaced with values from args.
+        /// </param>
+        /// <param name="args">
+        /// Arguments for string formatting.
+        /// </param>
+        public abstract void Warn(Exception exception, string message, params object[] args);
+        #endregion Warn
+
+        #region Error
+        /// <summary>
+        /// Logs a error message.
+        /// </summary>
+        /// <param name="message">
+        /// The message you would like logged. This message may contain
+        /// string formatting which will be replaced with values from args.
+        /// </param>
+        /// <param name="args">
+        /// Arguments for string formatting.
+        /// </param>
+        public abstract void Error(string message, params object[] args);
+
+        /// <summary>
+        /// Logs a error message.
+        /// </summary>
+        /// <param name="exception">
+        /// An exception to log.
+        /// </param>
+        /// <param name="message">
+        /// The message you would like logged. This message may contain
+        /// string formatting which will be replaced with values from args.
+        /// </param>
+        /// <param name="args">
+        /// Arguments for string formatting.
+        /// </param>
+        public abstract void Error(Exception exception, string message, params object[] args);
+        #endregion Error
+
+        #region Fatal
+        /// <summary>
+        /// Logs a fatal message (for NLog fatal).
+        /// </summary>
+        /// <param name="message">
+        /// The message you would like logged. This message may contain
+        /// string formatting which will be replaced with values from args.
+        /// </param>
+        /// <param name="args">
+        /// Arguments for string formatting.
+        /// </param>
+        /// <seealso cref="Error(String, Object[])"/>
+        public abstract void Fatal(string message, params object[] args);
+
+        /// <summary>
+        /// Logs a fatal message (for NLog fatal).
+        /// </summary>
+        /// <param name="exception">
+        /// An exception to log.
+        /// </param>
+        /// <param name="message">
+        /// The message you would like logged. This message may contain
+        /// string formatting which will be replaced with values from args.
+        /// </param>
+        /// <param name="args">
+        /// Arguments for string formatting.
+        /// </param>
+        /// <seealso cref="Error(Exception, String, Object[])"/>
+        public abstract void Fatal(Exception exception, string message, params object[] args);
+        #endregion Fatal
+
+        #region WriteLine
+        /// <summary>
+        /// Logs a message.
+        /// </summary>
+        /// <param name="type">
+        /// Log type (level).
+        /// </param>
+        /// <param name="message">
+        /// The message you would like logged. This message may contain
+        /// string formatting which will be replaced with values from args.
+        /// </param>
+        /// <param name="args">
+        /// Arguments for string formatting.
+        /// </param>
+        /// <seealso cref="Verbose(string, params object[])"/>
+        protected void WriteLine(string type, string message, params object[] args)
+        {
+            string mes = new StringBuilder()
+                .Append(DateTime.Now.ToString(DateFormat))
+                .Append("\t")
+                .Append(type)
+                .Append("-")
+                .Append(this.Name)
+                .Append("\t")
+                .Append(message)
+                .ToString();
+
+            System.Diagnostics.Debug.WriteLine(mes, args);
+        }
+
+        /// <summary>
+        /// Logs a message.
+        /// </summary>
+        /// <param name="type">
+        /// Log type (level).
+        /// </param>
+        /// <param name="exception">
+        /// An exception to log.
+        /// </param>
+        /// <param name="message">
+        /// The message you would like logged. This message may contain
+        /// string formatting which will be replaced with values from args.
+        /// </param>
+        /// <param name="args">
+        /// Arguments for string formatting.
+        /// </param>
+        /// <seealso cref="Verbose(string, params object[])"/>
+        protected void WriteLine(string type, Exception exception, string message, params object[] args)
+        {
+            string mes = new StringBuilder()
+                .Append(DateTime.Now.ToString(DateFormat))
+                .Append("\t")
+                .Append(type)
+                .Append("-")
+                .Append(this.Name)
+                .Append("\t")
+                .Append(message)
+                .Append("\t")
+                .Append("Exception:\n")
+                .Append(exception)
+                .ToString();
+
+            System.Diagnostics.Debug.WriteLine(mes, args);
+        }
+        #endregion WriteLine
+    }
+}
diff --git a/AltBeacon.Library/src/AltBeacon/Logging/EmptyLogger.cs b/AltBeacon.Library/src/AltBeacon/Logging/EmptyLogger.cs
new file mode 100644
index 0000000..aca6f1a
--- /dev/null
+++ b/AltBeacon.Library/src/AltBeacon/Logging/EmptyLogger.cs
@@ -0,0 +1,286 @@
+// <copyright file="EmptyLogger.cs" company="Radius Networks, Inc.">
+//     Copyright (c) Radius Networks, Inc.
+//     http://www.radiusnetworks.com
+// </copyright>
+// 
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements. See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership. The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License. You may obtain a copy of the License at
+// 
+// http://www.apache.org/licenses/LICENSE-2.0
+// 
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations
+// under the License.
+namespace AltBeacon.Logging
+{
+    using System;
+
+    /// <summary>
+    /// A logger that doesn't do anything.
+    /// This class can not be inherited.
+    /// </summary>
+    public sealed class EmptyLogger : ILogger
+    {
+        /// <summary>
+        /// <see cref="Name"/>
+        /// </summary>
+        private string name;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="EmptyLogger"/> class.
+        /// </summary>
+        /// <param name="name">
+        /// Identifier of the source of a log message. It usually
+        /// identifies the class or activity where the log call occurs.
+        /// </param>
+        public EmptyLogger(string name)
+        {
+            this.name = name;
+        }
+
+        #region Name
+        /// <summary>
+        /// Gets identifier of the source of a log message. It usually
+        /// identifies the class or activity where the log call occurs.
+        /// </summary>
+        public string Name
+        { 
+            get
+            {
+                return this.name;
+            }
+        }
+        #endregion Error
+
+        #region Trace
+        /// <summary>
+        /// Does nothing.
+        /// </summary>
+        /// <param name="message">
+        /// The parameter is not used.
+        /// </param>
+        /// <param name="args">
+        /// The parameter is not used.
+        /// </param>
+        /// <seealso cref="Verbose(String, Object[])"/>
+        public void Trace(string message, params object[] args)
+        {
+        }
+
+        /// <summary>
+        /// Does nothing.
+        /// </summary>
+        /// <param name="exception">
+        /// The parameter is not used.
+        /// </param>
+        /// <param name="message">
+        /// The parameter is not used.
+        /// </param>
+        /// <param name="args">
+        /// The parameter is not used.
+        /// </param>
+        /// <seealso cref="Verbose(Exception, String, Object[])"/>
+        public void Trace(Exception exception, string message, params object[] args)
+        {
+        }
+        #endregion Trace
+
+        #region Verbose
+        /// <summary>
+        /// Does nothing.
+        /// </summary>
+        /// <param name="message">
+        /// The parameter is not used.
+        /// </param>
+        /// <param name="args">
+        /// The parameter is not used.
+        /// </param>
+        /// <seealso cref="Trace(String, Object[])"/>
+        public void Verbose(string message, params object[] args)
+        {
+        }
+
+        /// <summary>
+        /// Does nothing.
+        /// </summary>
+        /// <param name="exception">
+        /// The parameter is not used.
+        /// </param>
+        /// <param name="message">
+        /// The parameter is not used.
+        /// </param>
+        /// <param name="args">
+        /// The parameter is not used.
+        /// </param>
+        /// <seealso cref="Trace(Exception, String, Object[])"/>
+        public void Verbose(Exception exception, string message, params object[] args)
+        {
+        }
+        #endregion Verbose
+
+        #region Debug
+        /// <summary>
+        /// Does nothing.
+        /// </summary>
+        /// <param name="message">
+        /// The parameter is not used.
+        /// </param>
+        /// <param name="args">
+        /// The parameter is not used.
+        /// </param>
+        public void Debug(string message, params object[] args)
+        {
+        }
+
+        /// <summary>
+        /// Does nothing.
+        /// </summary>
+        /// <param name="exception">
+        /// The parameter is not used.
+        /// </param>
+        /// <param name="message">
+        /// The parameter is not used.
+        /// </param>
+        /// <param name="args">
+        /// The parameter is not used.
+        /// </param>
+        public void Debug(Exception exception, string message, params object[] args)
+        {
+        }
+        #endregion Debug
+
+        #region Info
+        /// <summary>
+        /// Does nothing.
+        /// </summary>
+        /// <param name="message">
+        /// The parameter is not used.
+        /// </param>
+        /// <param name="args">
+        /// The parameter is not used.
+        /// </param>
+        public void Info(string message, params object[] args)
+        {
+        }
+
+        /// <summary>
+        /// Does nothing.
+        /// </summary>
+        /// <param name="exception">
+        /// The parameter is not used.
+        /// </param>
+        /// <param name="message">
+        /// The parameter is not used.
+        /// </param>
+        /// <param name="args">
+        /// The parameter is not used.
+        /// </param>
+        public void Info(Exception exception, string message, params object[] args)
+        {
+        }
+        #endregion Info
+
+        #region Warn
+        /// <summary>
+        /// Does nothing.
+        /// </summary>
+        /// <param name="message">
+        /// The parameter is not used.
+        /// </param>
+        /// <param name="args">
+        /// The parameter is not used.
+        /// </param>
+        public void Warn(string message, params object[] args)
+        {
+        }
+
+        /// <summary>
+        /// Does nothing.
+        /// </summary>
+        /// <param name="exception">
+        /// The parameter is not used.
+        /// </param>
+        /// <param name="message">
+        /// The parameter is not used.
+        /// </param>
+        /// <param name="args">
+        /// The parameter is not used.
+        /// </param>
+        public void Warn(Exception exception, string message, params object[] args)
+        {
+        }
+        #endregion Warn
+
+        #region Error
+        /// <summary>
+        /// Does nothing.
+        /// </summary>
+        /// <param name="message">
+        /// The parameter is not used.
+        /// </param>
+        /// <param name="args">
+        /// The parameter is not used.
+        /// </param>
+        public void Error(string message, params object[] args)
+        {
+        }
+
+        /// <summary>
+        /// Does nothing.
+        /// </summary>
+        /// <param name="exception">
+        /// The parameter is not used.
+        /// </param>
+        /// <param name="message">
+        /// The parameter is not used.
+        /// </param>
+        /// <param name="args">
+        /// The parameter is not used.
+        /// </param>
+        public void Error(Exception exception, string message, params object[] args)
+        {
+        }
+        #endregion Error
+
+        #region Fatal
+        /// <summary>
+        /// Does nothing.
+        /// </summary>
+        /// <param name="message">
+        /// The parameter is not used.
+        /// </param>
+        /// <param name="args">
+        /// The parameter is not used.
+        /// </param>
+        /// <seealso cref="Error(String, Object[])"/>
+        public void Fatal(string message, params object[] args)
+        {
+        }
+
+        /// <summary>
+        /// Does nothing.
+        /// </summary>
+        /// <param name="exception">
+        /// The parameter is not used.
+        /// </param>
+        /// <param name="message">
+        /// The parameter is not used.
+        /// </param>
+        /// <param name="args">
+        /// The parameter is not used.
+        /// </param>
+        /// <seealso cref="Error(Exception, String, Object[])"/>
+        public void Fatal(Exception exception, string message, params object[] args)
+        {
+        }
+        #endregion Fatal
+    }
+}
diff --git a/AltBeacon.Library/src/AltBeacon/Logging/EmptyLoggerFactory.cs b/AltBeacon.Library/src/AltBeacon/Logging/EmptyLoggerFactory.cs
new file mode 100644
index 0000000..feaeed6
--- /dev/null
+++ b/AltBeacon.Library/src/AltBeacon/Logging/EmptyLoggerFactory.cs
@@ -0,0 +1,45 @@
+// <copyright file="EmptyLoggerFactory.cs" company="Radius Networks, Inc.">
+//     Copyright (c) Radius Networks, Inc.
+//     http://www.radiusnetworks.com
+// </copyright>
+// 
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements. See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership. The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License. You may obtain a copy of the License at
+// 
+// http://www.apache.org/licenses/LICENSE-2.0
+// 
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations
+// under the License.
+namespace AltBeacon.Logging
+{  
+    /// <summary>
+    /// Creates logging interfaces which doesn't do anything.
+    /// This class can not be inherited.
+    /// </summary>
+    public sealed class EmptyLoggerFactory : ILoggerFactory
+    {
+        /// <summary>
+        /// Gets the specified named logger.
+        /// </summary>
+        /// <param name="name">
+        /// Name of the logger.
+        /// </param>
+        /// <returns>
+        /// The logger reference. Multiple calls to <code>GetLogger</code> with 
+        /// the same argument aren't guaranteed to return the same logger reference.
+        /// </returns>
+        public ILogger GetLogger(string name)
+        {
+            return new EmptyLogger(name);
+        }
+    }
+}
diff --git a/AltBeacon.Library/src/AltBeacon/Logging/ILogger.cs b/AltBeacon.Library/src/AltBeacon/Logging/ILogger.cs
new file mode 100644
index 0000000..f4da82b
--- /dev/null
+++ b/AltBeacon.Library/src/AltBeacon/Logging/ILogger.cs
@@ -0,0 +1,251 @@
+// <copyright file="ILogger.cs" company="Radius Networks, Inc.">
+//     Copyright (c) Radius Networks, Inc.
+//     http://www.radiusnetworks.com
+// </copyright>
+// 
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements. See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership. The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License. You may obtain a copy of the License at
+// 
+// http://www.apache.org/licenses/LICENSE-2.0
+// 
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations
+// under the License.
+namespace AltBeacon.Logging
+{
+    using System;
+
+    /// <summary>
+    /// Logging interface for logging messages in the AltBeacon Library.
+    /// To set a custom logger, implement <see cref="AltBeacon.Logging.ILoggerFactory"/>
+    /// interface and set it with 
+    /// <see cref="AltBeacon.Logging.LogManager#SetLoggerFactory(ILoggerFactory)"/>
+    /// </summary>
+    public interface ILogger
+    {
+        #region Name
+        /// <summary>
+        /// Gets identifier of the source of a log message. It usually
+        /// identifies the class or activity where the log call occurs.
+        /// </summary>
+        string Name { get; }
+        #endregion Error
+
+        #region Trace
+        /// <summary>
+        /// Logs a trace message (same level as verbose - NLog Trace).
+        /// </summary>
+        /// <param name="message">
+        /// The message you would like logged. This message may contain
+        /// string formatting which will be replaced with values from args.
+        /// </param>
+        /// <param name="args">
+        /// Arguments for string formatting.
+        /// </param>
+        /// <seealso cref="Verbose(String, Object[])"/>
+        void Trace(string message, params object[] args);
+
+        /// <summary>
+        /// Logs a trace message (same level as verbose - NLog Trace).
+        /// </summary>
+        /// <param name="exception">
+        /// An exception to log.
+        /// </param>
+        /// <param name="message">
+        /// The message you would like logged. This message may contain
+        /// string formatting which will be replaced with values from args.
+        /// </param>
+        /// <param name="args">
+        /// Arguments for string formatting.
+        /// </param>
+        /// <seealso cref="Verbose(Exception, String, Object[])"/>
+        void Trace(Exception exception, string message, params object[] args);
+        #endregion Trace
+
+        #region Verbose
+        /// <summary>
+        /// Logs a verbose message (same level as trace also to support Android based coders).
+        /// </summary>
+        /// <param name="message">
+        /// The message you would like logged. This message may contain
+        /// string formatting which will be replaced with values from args.
+        /// </param>
+        /// <param name="args">
+        /// Arguments for string formatting.
+        /// </param>
+        /// <seealso cref="Trace(String, Object[])"/>
+        void Verbose(string message, params object[] args);
+
+        /// <summary>
+        /// Logs a verbose message (same level as trace also to support Android based coders).
+        /// </summary>
+        /// <param name="exception">
+        /// An exception to log.
+        /// </param>
+        /// <param name="message">
+        /// The message you would like logged. This message may contain
+        /// string formatting which will be replaced with values from args.
+        /// </param>
+        /// <param name="args">
+        /// Arguments for string formatting.
+        /// </param>
+        /// <seealso cref="Trace(Exception, String, Object[])"/>
+        void Verbose(Exception exception, string message, params object[] args);
+        #endregion Verbose
+
+        #region Debug
+        /// <summary>
+        /// Logs a debug message.
+        /// </summary>
+        /// <param name="message">
+        /// The message you would like logged. This message may contain
+        /// string formatting which will be replaced with values from args.
+        /// </param>
+        /// <param name="args">
+        /// Arguments for string formatting.
+        /// </param>
+        void Debug(string message, params object[] args);
+        
+        /// <summary>
+        /// Logs a debug message.
+        /// </summary>
+        /// <param name="exception">
+        /// An exception to log.
+        /// </param>
+        /// <param name="message">
+        /// The message you would like logged. This message may contain
+        /// string formatting which will be replaced with values from args.
+        /// </param>
+        /// <param name="args">
+        /// Arguments for string formatting.
+        /// </param>
+        void Debug(Exception exception, string message, params object[] args);
+        #endregion Debug
+        
+        #region Info
+        /// <summary>
+        /// Logs a info message.
+        /// </summary>
+        /// <param name="message">
+        /// The message you would like logged. This message may contain
+        /// string formatting which will be replaced with values from args.
+        /// </param>
+        /// <param name="args">
+        /// Arguments for string formatting.
+        /// </param>
+        void Info(string message, params object[] args);
+
+        /// <summary>
+        /// Logs a info message.
+        /// </summary>
+        /// <param name="exception">
+        /// An exception to log.
+        /// </param>
+        /// <param name="message">
+        /// The message you would like logged. This message may contain
+        /// string formatting which will be replaced with values from args.
+        /// </param>
+        /// <param name="args">
+        /// Arguments for string formatting.
+        /// </param>
+        void Info(Exception exception, string message, params object[] args);
+        #endregion Info
+
+        #region Warn
+        /// <summary>
+        /// Logs a warning message.
+        /// </summary>
+        /// <param name="message">
+        /// The message you would like logged. This message may contain
+        /// string formatting which will be replaced with values from args.
+        /// </param>
+        /// <param name="args">
+        /// Arguments for string formatting.
+        /// </param>
+        void Warn(string message, params object[] args);
+
+        /// <summary>
+        /// Logs a warning message.
+        /// </summary>
+        /// <param name="exception">
+        /// An exception to log.
+        /// </param>
+        /// <param name="message">
+        /// The message you would like logged. This message may contain
+        /// string formatting which will be replaced with values from args.
+        /// </param>
+        /// <param name="args">
+        /// Arguments for string formatting.
+        /// </param>
+        void Warn(Exception exception, string message, params object[] args);
+        #endregion Warn
+        
+        #region Error
+        /// <summary>
+        /// Logs a error message.
+        /// </summary>
+        /// <param name="message">
+        /// The message you would like logged. This message may contain
+        /// string formatting which will be replaced with values from args.
+        /// </param>
+        /// <param name="args">
+        /// Arguments for string formatting.
+        /// </param>
+        void Error(string message, params object[] args);
+
+        /// <summary>
+        /// Logs a error message.
+        /// </summary>
+        /// <param name="exception">
+        /// An exception to log.
+        /// </param>
+        /// <param name="message">
+        /// The message you would like logged. This message may contain
+        /// string formatting which will be replaced with values from args.
+        /// </param>
+        /// <param name="args">
+        /// Arguments for string formatting.
+        /// </param>
+        void Error(Exception exception, string message, params object[] args);
+        #endregion Error
+
+        #region Fatal
+        /// <summary>
+        /// Logs a fatal message (for NLog fatal).
+        /// </summary>
+        /// <param name="message">
+        /// The message you would like logged. This message may contain
+        /// string formatting which will be replaced with values from args.
+        /// </param>
+        /// <param name="args">
+        /// Arguments for string formatting.
+        /// </param>
+        /// <seealso cref="Error(String, Object[])"/>
+        void Fatal(string message, params object[] args);
+
+        /// <summary>
+        /// Logs a fatal message (for NLog fatal).
+        /// </summary>
+        /// <param name="exception">
+        /// An exception to log.
+        /// </param>
+        /// <param name="message">
+        /// The message you would like logged. This message may contain
+        /// string formatting which will be replaced with values from args.
+        /// </param>
+        /// <param name="args">
+        /// Arguments for string formatting.
+        /// </param>
+        /// <seealso cref="Error(Exception, String, Object[])"/>
+        void Fatal(Exception exception, string message, params object[] args);
+        #endregion Fatal
+    }
+}
\ No newline at end of file
diff --git a/AltBeacon.Library/src/AltBeacon/Logging/ILoggerFactory.cs b/AltBeacon.Library/src/AltBeacon/Logging/ILoggerFactory.cs
new file mode 100644
index 0000000..1758b26
--- /dev/null
+++ b/AltBeacon.Library/src/AltBeacon/Logging/ILoggerFactory.cs
@@ -0,0 +1,43 @@
+// <copyright file="ILoggerFactory.cs" company="Radius Networks, Inc.">
+//     Copyright (c) Radius Networks, Inc.
+//     http://www.radiusnetworks.com
+// </copyright>
+// 
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements. See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership. The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License. You may obtain a copy of the License at
+// 
+// http://www.apache.org/licenses/LICENSE-2.0
+// 
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations
+// under the License.
+namespace AltBeacon.Logging
+{
+    /// <summary>
+    /// Creates logging interfaces for logging messages in the AltBeacon Library.
+    /// To set a custom logger implement this interface and set it with
+    /// <see cref="AltBeacon.Logging.LogManager#SetLoggerFactory(ILoggerFactory)"/>
+    /// </summary>
+    public interface ILoggerFactory
+    {
+        /// <summary>
+        /// Gets the specified named logger.
+        /// </summary>
+        /// <param name="name">
+        /// Name of the logger.
+        /// </param>
+        /// <returns>
+        /// The logger reference. Multiple calls to <code>GetLogger</code> with 
+        /// the same argument aren't guaranteed to return the same logger reference.
+        /// </returns>
+        ILogger GetLogger(string name);
+    }
+}
diff --git a/AltBeacon.Library/src/AltBeacon/Logging/LogManager.cs b/AltBeacon.Library/src/AltBeacon/Logging/LogManager.cs
new file mode 100644
index 0000000..177e3a6
--- /dev/null
+++ b/AltBeacon.Library/src/AltBeacon/Logging/LogManager.cs
@@ -0,0 +1,128 @@
+// <copyright file="LogManager.cs" company="Radius Networks, Inc.">
+//     Copyright (c) Radius Networks, Inc.
+//     http://www.radiusnetworks.com
+// </copyright>
+// 
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements. See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership. The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License. You may obtain a copy of the License at
+// 
+// http://www.apache.org/licenses/LICENSE-2.0
+// 
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations
+// under the License.
+namespace AltBeacon.Logging
+{
+    using System;
+
+    /// <summary>
+    /// Manager for logging in the AltBeacon Library.
+    /// The default is <see cref="WarningDiagnosticsLoggerFactory"/>
+    /// This class can not be inherited nor initialized.
+    /// </summary>
+    public static class LogManager
+    {
+        #region Factory Fields
+        /// <summary>
+        /// Predefined Empty Logger Factory
+        /// <see cref="AltBeacon.Logging.EmptyLoggerFactory"/>
+        /// </summary>
+        public static readonly EmptyLoggerFactory EmptyLoggerFactory = new EmptyLoggerFactory();
+
+        /// <summary>
+        /// Predefined Verbose(Trace) or higher level Logger Factory
+        /// <see cref="AltBeacon.Logging.VerboseDiagnosticsLoggerFactory"/>
+        /// </summary>
+        public static readonly VerboseDiagnosticsLoggerFactory VerboseDiagnosticsLoggerFactory =
+            new VerboseDiagnosticsLoggerFactory();
+
+        /// <summary>
+        /// Predefined Warning or higher level Logger Factory
+        /// <see cref="AltBeacon.Logging.WarningDiagnosticsLoggerFactory"/>
+        /// </summary>
+        public static readonly WarningDiagnosticsLoggerFactory WarningDiagnosticsLoggerFactory =
+            new WarningDiagnosticsLoggerFactory();
+        #endregion Factory Fields
+
+        #region Private Fields
+        /// <summary>
+        /// <see cref="LoggerFactory"/>
+        /// </summary>
+        private static ILoggerFactory loggerFactory = WarningDiagnosticsLoggerFactory;
+
+        /// <summary>
+        /// <see cref="VerboseLoggingEnabled"/>
+        /// </summary>
+        private static bool verboseLoggingEnabled = false;
+        #endregion Private Fields
+
+        #region Properties
+        /// <summary>
+        /// Gets or sets logger factory which will create loggers
+        /// that the AltBeacon Library will use to send it's log messages to.
+        /// </summary>
+        /// <exception cref="NullReferenceException">
+        /// When null is given.
+        /// </exception>
+        public static ILoggerFactory LoggerFactory
+        {
+            get
+            {
+                return loggerFactory;
+            }
+
+            set
+            {
+                if (value == null)
+                {
+                    throw new NullReferenceException("LoggerFactory can not be null!");
+                }
+
+                loggerFactory = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether verbose logging is enabled.
+        /// If not, expensive calculations to create log strings should be avoided.
+        /// </summary>
+        public static bool VerboseLoggingEnabled
+        {
+            get
+            {
+                return verboseLoggingEnabled;
+            }
+
+            set
+            {
+                verboseLoggingEnabled = value;
+            }
+        }
+        #endregion Properties
+
+        #region Methods
+        /// <summary>
+        /// Gets the specified named logger.
+        /// </summary>
+        /// <param name="name">
+        /// Name of the logger.
+        /// </param>
+        /// <returns>
+        /// The logger reference. Multiple calls to <code>GetLogger</code> with 
+        /// the same argument aren't guaranteed to return the same logger reference.
+        /// </returns>
+        public static ILogger GetLogger(string name)
+        {
+            return loggerFactory.GetLogger(name);
+        }
+        #endregion Methods
+    }
+}
diff --git a/AltBeacon.Library/src/AltBeacon/Logging/VerboseDiagnosticsLogger.cs b/AltBeacon.Library/src/AltBeacon/Logging/VerboseDiagnosticsLogger.cs
new file mode 100644
index 0000000..9b00e03
--- /dev/null
+++ b/AltBeacon.Library/src/AltBeacon/Logging/VerboseDiagnosticsLogger.cs
@@ -0,0 +1,308 @@
+// <copyright file="VerboseDiagnosticsLogger.cs" company="Radius Networks, Inc.">
+//     Copyright (c) Radius Networks, Inc.
+//     http://www.radiusnetworks.com
+// </copyright>
+// 
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements. See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership. The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License. You may obtain a copy of the License at
+// 
+// http://www.apache.org/licenses/LICENSE-2.0
+// 
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations
+// under the License.
+namespace AltBeacon.Logging
+{
+    using System;
+    using System.Diagnostics;
+    using System.Text;
+
+    /// <summary>
+    /// A logger that uses <see cref="System.Diagnostics.Debug"/>
+    /// class for logs Verbose (Trace) or higher level.
+    /// This class can not be inherited.
+    /// </summary>
+    public sealed class VerboseDiagnosticsLogger : BaseDiagnosticsLogger
+    {
+        #region Constructor
+        /// <summary>
+        /// Initializes a new instance of the <see cref="VerboseDiagnosticsLogger"/> class.
+        /// </summary>
+        /// <param name="name">
+        /// Identifier of the source of a log message. It usually
+        /// identifies the class or activity where the log call occurs.
+        /// </param>
+        public VerboseDiagnosticsLogger(string name)
+            : base(name)
+        {
+        }
+        #endregion Constructor
+
+        #region Trace
+        /// <summary>
+        /// Logs a trace message (same level as verbose - NLog Trace).
+        /// </summary>
+        /// <param name="message">
+        /// The message you would like logged. This message may contain
+        /// string formatting which will be replaced with values from args.
+        /// </param>
+        /// <param name="args">
+        /// Arguments for string formatting.
+        /// </param>
+        /// <seealso cref="Verbose(string, params object[])"/>
+        public override void Trace(string message, params object[] args)
+        {
+            this.WriteLine("Trace", message, args);
+        }
+
+        /// <summary>
+        /// Logs a trace message (same level as verbose - NLog Trace).
+        /// </summary>
+        /// <param name="exception">
+        /// An exception to log.
+        /// </param>
+        /// <param name="message">
+        /// The message you would like logged. This message may contain
+        /// string formatting which will be replaced with values from args.
+        /// </param>
+        /// <param name="args">
+        /// Arguments for string formatting.
+        /// </param>
+        /// <seealso cref="Verbose(string, params object[])"/>
+        public override void Trace(Exception exception, string message, params object[] args)
+        {
+            this.WriteLine("Trace", exception, message, args);
+        }
+        #endregion Trace
+
+        #region Verbose
+        /// <summary>
+        /// Logs a verbose message (same level as trace also to support Android based coders).
+        /// </summary>
+        /// <param name="message">
+        /// The message you would like logged. This message may contain
+        /// string formatting which will be replaced with values from args.
+        /// </param>
+        /// <param name="args">
+        /// Arguments for string formatting.
+        /// </param>
+        /// <seealso cref="Verbose(string, params object[])"/>
+        public override void Verbose(string message, params object[] args)
+        {
+            this.WriteLine("Verbose", message, args);
+        }
+
+        /// <summary>
+        /// Logs a verbose message (same level as trace also to support Android based coders).
+        /// </summary>
+        /// <param name="exception">
+        /// An exception to log.
+        /// </param>
+        /// <param name="message">
+        /// The message you would like logged. This message may contain
+        /// string formatting which will be replaced with values from args.
+        /// </param>
+        /// <param name="args">
+        /// Arguments for string formatting.
+        /// </param>
+        /// <seealso cref="Verbose(string, params object[])"/>
+        public override void Verbose(Exception exception, string message, params object[] args)
+        {
+            this.WriteLine("Verbose", exception, message, args);
+        }
+        #endregion Verbose
+
+        #region Debug
+        /// <summary>
+        /// Logs a debug message.
+        /// </summary>
+        /// <param name="message">
+        /// The message you would like logged. This message may contain
+        /// string formatting which will be replaced with values from args.
+        /// </param>
+        /// <param name="args">
+        /// Arguments for string formatting.
+        /// </param>
+        /// <seealso cref="Verbose(string, params object[])"/>
+        public override void Debug(string message, params object[] args)
+        {
+            this.WriteLine("Debug", message, args);
+        }
+
+        /// <summary>
+        /// Logs a debug message.
+        /// </summary>
+        /// <param name="exception">
+        /// An exception to log.
+        /// </param>
+        /// <param name="message">
+        /// The message you would like logged. This message may contain
+        /// string formatting which will be replaced with values from args.
+        /// </param>
+        /// <param name="args">
+        /// Arguments for string formatting.
+        /// </param>
+        /// <seealso cref="Verbose(string, params object[])"/>
+        public override void Debug(Exception exception, string message, params object[] args)
+        {
+            this.WriteLine("Debug", exception, message, args);
+        }
+        #endregion Debug
+
+        #region Info
+        /// <summary>
+        /// Logs a info message.
+        /// </summary>
+        /// <param name="message">
+        /// The message you would like logged. This message may contain
+        /// string formatting which will be replaced with values from args.
+        /// </param>
+        /// <param name="args">
+        /// Arguments for string formatting.
+        /// </param>
+        /// <seealso cref="Verbose(string, params object[])"/>
+        public override void Info(string message, params object[] args)
+        {
+            this.WriteLine("Info", message, args);
+        }
+
+        /// <summary>
+        /// Logs a info message.
+        /// </summary>
+        /// <param name="exception">
+        /// An exception to log.
+        /// </param>
+        /// <param name="message">
+        /// The message you would like logged. This message may contain
+        /// string formatting which will be replaced with values from args.
+        /// </param>
+        /// <param name="args">
+        /// Arguments for string formatting.
+        /// </param>
+        /// <seealso cref="Verbose(string, params object[])"/>
+        public override void Info(Exception exception, string message, params object[] args)
+        {
+            this.WriteLine("Info", exception, message, args);
+        }
+        #endregion Info
+
+        #region Warn
+        /// <summary>
+        /// Logs a warning message.
+        /// </summary>
+        /// <param name="message">
+        /// The message you would like logged. This message may contain
+        /// string formatting which will be replaced with values from args.
+        /// </param>
+        /// <param name="args">
+        /// Arguments for string formatting.
+        /// </param>
+        /// <seealso cref="Verbose(string, params object[])"/>
+        public override void Warn(string message, params object[] args)
+        {
+            this.WriteLine("Warn", message, args);
+        }
+
+        /// <summary>
+        /// Logs a warning message.
+        /// </summary>
+        /// <param name="exception">
+        /// An exception to log.
+        /// </param>
+        /// <param name="message">
+        /// The message you would like logged. This message may contain
+        /// string formatting which will be replaced with values from args.
+        /// </param>
+        /// <param name="args">
+        /// Arguments for string formatting.
+        /// </param>
+        /// <seealso cref="Verbose(string, params object[])"/>
+        public override void Warn(Exception exception, string message, params object[] args)
+        {
+            this.WriteLine("Warn", exception, message, args);
+        }
+        #endregion Warn
+
+        #region Error
+        /// <summary>
+        /// Logs a error message.
+        /// </summary>
+        /// <param name="message">
+        /// The message you would like logged. This message may contain
+        /// string formatting which will be replaced with values from args.
+        /// </param>
+        /// <param name="args">
+        /// Arguments for string formatting.
+        /// </param>
+        /// <seealso cref="Verbose(string, params object[])"/>
+        public override void Error(string message, params object[] args)
+        {
+            this.WriteLine("Error", message, args);
+        }
+
+        /// <summary>
+        /// Logs a error message.
+        /// </summary>
+        /// <param name="exception">
+        /// An exception to log.
+        /// </param>
+        /// <param name="message">
+        /// The message you would like logged. This message may contain
+        /// string formatting which will be replaced with values from args.
+        /// </param>
+        /// <param name="args">
+        /// Arguments for string formatting.
+        /// </param>
+        /// <seealso cref="Verbose(string, params object[])"/>
+        public override void Error(Exception exception, string message, params object[] args)
+        {
+            this.WriteLine("Error", exception, message, args);
+        }
+        #endregion Error
+        
+        #region Fatal
+        /// <summary>
+        /// Logs a fatal message (for NLog fatal).
+        /// </summary>
+        /// <param name="message">
+        /// The message you would like logged. This message may contain
+        /// string formatting which will be replaced with values from args.
+        /// </param>
+        /// <param name="args">
+        /// Arguments for string formatting.
+        /// </param>
+        /// <seealso cref="Error(String, Object[])"/>
+        public override void Fatal(string message, params object[] args)
+        {
+            this.WriteLine("Fatal", message, args);
+        }
+
+        /// <summary>
+        /// Logs a fatal message (for NLog fatal).
+        /// </summary>
+        /// <param name="exception">
+        /// An exception to log.
+        /// </param>
+        /// <param name="message">
+        /// The message you would like logged. This message may contain
+        /// string formatting which will be replaced with values from args.
+        /// </param>
+        /// <param name="args">
+        /// Arguments for string formatting.
+        /// </param>
+        /// <seealso cref="Error(Exception, String, Object[])"/>
+        public override void Fatal(Exception exception, string message, params object[] args)
+        {
+            this.WriteLine("Fatal", exception, message, args);
+        }
+        #endregion Fatal
+    }
+}
diff --git a/AltBeacon.Library/src/AltBeacon/Logging/VerboseDiagnosticsLoggerFactory.cs b/AltBeacon.Library/src/AltBeacon/Logging/VerboseDiagnosticsLoggerFactory.cs
new file mode 100644
index 0000000..5a5cb33
--- /dev/null
+++ b/AltBeacon.Library/src/AltBeacon/Logging/VerboseDiagnosticsLoggerFactory.cs
@@ -0,0 +1,46 @@
+// <copyright file="VerboseDiagnosticsLoggerFactory.cs" company="Radius Networks, Inc.">
+//     Copyright (c) Radius Networks, Inc.
+//     http://www.radiusnetworks.com
+// </copyright>
+// 
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements. See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership. The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License. You may obtain a copy of the License at
+// 
+// http://www.apache.org/licenses/LICENSE-2.0
+// 
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations
+// under the License.
+namespace AltBeacon.Logging
+{
+    /// <summary>
+    /// Creates logging interfaces which uses <see cref="System.Diagnostics.Debug"/>
+    /// class for logs Verbose (Trace) or higher level.
+    /// This class can not be inherited.
+    /// </summary>
+    public sealed class VerboseDiagnosticsLoggerFactory : ILoggerFactory
+    {
+        /// <summary>
+        /// Gets the specified named logger.
+        /// </summary>
+        /// <param name="name">
+        /// Name of the logger.
+        /// </param>
+        /// <returns>
+        /// The logger reference. Multiple calls to <code>GetLogger</code> with 
+        /// the same argument aren't guaranteed to return the same logger reference.
+        /// </returns>
+        public ILogger GetLogger(string name)
+        {
+            return new VerboseDiagnosticsLogger(name);
+        }
+    }
+}
diff --git a/AltBeacon.Library/src/AltBeacon/Logging/WarningDiagnosticsLogger.cs b/AltBeacon.Library/src/AltBeacon/Logging/WarningDiagnosticsLogger.cs
new file mode 100644
index 0000000..cc0fea6
--- /dev/null
+++ b/AltBeacon.Library/src/AltBeacon/Logging/WarningDiagnosticsLogger.cs
@@ -0,0 +1,284 @@
+// <copyright file="WarningDiagnosticsLogger.cs" company="Radius Networks, Inc.">
+//     Copyright (c) Radius Networks, Inc.
+//     http://www.radiusnetworks.com
+// </copyright>
+// 
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements. See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership. The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License. You may obtain a copy of the License at
+// 
+// http://www.apache.org/licenses/LICENSE-2.0
+// 
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations
+// under the License.
+namespace AltBeacon.Logging
+{
+    using System;
+    using System.Diagnostics;
+    using System.Text;
+
+    /// <summary>
+    /// A logger that uses <see cref="System.Diagnostics.Debug"/>
+    /// class for logs Warning or higher level.
+    /// This class can not be inherited.
+    /// </summary>
+    public sealed class WarningDiagnosticsLogger : BaseDiagnosticsLogger
+    {
+        #region Constructor
+        /// <summary>
+        /// Initializes a new instance of the <see cref="WarningDiagnosticsLogger"/> class.
+        /// </summary>
+        /// <param name="name">
+        /// Identifier of the source of a log message. It usually
+        /// identifies the class or activity where the log call occurs.
+        /// </param>
+        public WarningDiagnosticsLogger(string name)
+            : base(name)
+        {
+        }
+        #endregion Constructor
+
+        #region Trace
+        /// <summary>
+        /// Does nothing.
+        /// </summary>
+        /// <param name="message">
+        /// The parameter is not used.
+        /// </param>
+        /// <param name="args">
+        /// The parameter is not used.
+        /// </param>
+        /// <seealso cref="Verbose(String, Object[])"/>
+        public override void Trace(string message, params object[] args)
+        {
+        }
+
+        /// <summary>
+        /// Does nothing.
+        /// </summary>
+        /// <param name="exception">
+        /// The parameter is not used.
+        /// </param>
+        /// <param name="message">
+        /// The parameter is not used.
+        /// </param>
+        /// <param name="args">
+        /// The parameter is not used.
+        /// </param>
+        /// <seealso cref="Verbose(Exception, string, Object[])"/>
+        public override void Trace(Exception exception, string message, params object[] args)
+        {
+        }
+        #endregion Trace
+
+        #region Verbose
+        /// <summary>
+        /// Does nothing.
+        /// </summary>
+        /// <param name="message">
+        /// The parameter is not used.
+        /// </param>
+        /// <param name="args">
+        /// The parameter is not used.
+        /// </param>
+        /// <seealso cref="Trace(String, Object[])"/>
+        public override void Verbose(string message, params object[] args)
+        {
+        }
+
+        /// <summary>
+        /// Does nothing.
+        /// </summary>
+        /// <param name="exception">
+        /// The parameter is not used.
+        /// </param>
+        /// <param name="message">
+        /// The parameter is not used.
+        /// </param>
+        /// <param name="args">
+        /// The parameter is not used.
+        /// </param>
+        /// <seealso cref="Trace(Exception, String, Object[])"/>
+        public override void Verbose(Exception exception, string message, params object[] args)
+        {
+        }
+        #endregion Verbose
+
+        #region Debug
+        /// <summary>
+        /// Does nothing.
+        /// </summary>
+        /// <param name="message">
+        /// The parameter is not used.
+        /// </param>
+        /// <param name="args">
+        /// The parameter is not used.
+        /// </param>
+        public override void Debug(string message, params object[] args)
+        {
+        }
+
+        /// <summary>
+        /// Does nothing.
+        /// </summary>
+        /// <param name="exception">
+        /// The parameter is not used.
+        /// </param>
+        /// <param name="message">
+        /// The parameter is not used.
+        /// </param>
+        /// <param name="args">
+        /// The parameter is not used.
+        /// </param>
+        public override void Debug(Exception exception, string message, params object[] args)
+        {
+        }
+        #endregion Debug
+
+        #region Info
+        /// <summary>
+        /// Does nothing.
+        /// </summary>
+        /// <param name="message">
+        /// The parameter is not used.
+        /// </param>
+        /// <param name="args">
+        /// The parameter is not used.
+        /// </param>
+        public override void Info(string message, params object[] args)
+        {
+        }
+
+        /// <summary>
+        /// Does nothing.
+        /// </summary>
+        /// <param name="exception">
+        /// The parameter is not used.
+        /// </param>
+        /// <param name="message">
+        /// The parameter is not used.
+        /// </param>
+        /// <param name="args">
+        /// The parameter is not used.
+        /// </param>
+        public override void Info(Exception exception, string message, params object[] args)
+        {
+        }
+        #endregion Info
+
+        #region Warn
+        /// <summary>
+        /// Logs a warning message.
+        /// </summary>
+        /// <param name="message">
+        /// The message you would like logged. This message may contain
+        /// string formatting which will be replaced with values from args.
+        /// </param>
+        /// <param name="args">
+        /// Arguments for string formatting.
+        /// </param>
+        public override void Warn(string message, params object[] args)
+        {
+            this.WriteLine("Warn", message, args);
+        }
+
+        /// <summary>
+        /// Logs a warning message.
+        /// </summary>
+        /// <param name="exception">
+        /// An exception to log.
+        /// </param>
+        /// <param name="message">
+        /// The message you would like logged. This message may contain
+        /// string formatting which will be replaced with values from args.
+        /// </param>
+        /// <param name="args">
+        /// Arguments for string formatting.
+        /// </param>
+        public override void Warn(Exception exception, string message, params object[] args)
+        {
+            this.WriteLine("Warn", exception, message, args);
+        }
+        #endregion Warn
+
+        #region Error
+        /// <summary>
+        /// Logs a error message.
+        /// </summary>
+        /// <param name="message">
+        /// The message you would like logged. This message may contain
+        /// string formatting which will be replaced with values from args.
+        /// </param>
+        /// <param name="args">
+        /// Arguments for string formatting.
+        /// </param>
+        public override void Error(string message, params object[] args)
+        {
+            this.WriteLine("Error", message, args);
+        }
+
+        /// <summary>
+        /// Logs a error message.
+        /// </summary>
+        /// <param name="exception">
+        /// An exception to log.
+        /// </param>
+        /// <param name="message">
+        /// The message you would like logged. This message may contain
+        /// string formatting which will be replaced with values from args.
+        /// </param>
+        /// <param name="args">
+        /// Arguments for string formatting.
+        /// </param>
+        public override void Error(Exception exception, string message, params object[] args)
+        {
+            this.WriteLine("Error", exception, message, args);
+        }
+        #endregion Error
+
+        #region Fatal
+        /// <summary>
+        /// Logs a fatal message (for NLog fatal).
+        /// </summary>
+        /// <param name="message">
+        /// The message you would like logged. This message may contain
+        /// string formatting which will be replaced with values from args.
+        /// </param>
+        /// <param name="args">
+        /// Arguments for string formatting.
+        /// </param>
+        /// <seealso cref="Error(String, Object[])"/>
+        public override void Fatal(string message, params object[] args)
+        {
+            this.WriteLine("Fatal", message, args);
+        }
+
+        /// <summary>
+        /// Logs a fatal message (for NLog fatal).
+        /// </summary>
+        /// <param name="exception">
+        /// An exception to log.
+        /// </param>
+        /// <param name="message">
+        /// The message you would like logged. This message may contain
+        /// string formatting which will be replaced with values from args.
+        /// </param>
+        /// <param name="args">
+        /// Arguments for string formatting.
+        /// </param>
+        /// <seealso cref="Error(Exception, String, Object[])"/>
+        public override void Fatal(Exception exception, string message, params object[] args)
+        {
+            this.WriteLine("Fatal", exception, message, args);
+        }
+        #endregion Fatal
+    }
+}
\ No newline at end of file
diff --git a/AltBeacon.Library/src/AltBeacon/Logging/WarningDiagnosticsLoggerFactory.cs b/AltBeacon.Library/src/AltBeacon/Logging/WarningDiagnosticsLoggerFactory.cs
new file mode 100644
index 0000000..4f8a86d
--- /dev/null
+++ b/AltBeacon.Library/src/AltBeacon/Logging/WarningDiagnosticsLoggerFactory.cs
@@ -0,0 +1,46 @@
+// <copyright file="WarningDiagnosticsLoggerFactory.cs" company="Radius Networks, Inc.">
+//     Copyright (c) Radius Networks, Inc.
+//     http://www.radiusnetworks.com
+// </copyright>
+// 
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements. See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership. The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License. You may obtain a copy of the License at
+// 
+// http://www.apache.org/licenses/LICENSE-2.0
+// 
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations
+// under the License.
+namespace AltBeacon.Logging
+{
+    /// <summary>
+    /// Creates logging interfaces which uses <see cref="System.Diagnostics.Debug"/>
+    /// class for logs Warning or higher level.
+    /// This class can not be inherited.
+    /// </summary>
+    public sealed class WarningDiagnosticsLoggerFactory : ILoggerFactory
+    {
+        /// <summary>
+        /// Gets the specified named logger.
+        /// </summary>
+        /// <param name="name">
+        /// Name of the logger.
+        /// </param>
+        /// <returns>
+        /// The logger reference. Multiple calls to <code>GetLogger</code> with 
+        /// the same argument aren't guaranteed to return the same logger reference.
+        /// </returns>
+        public ILogger GetLogger(string name)
+        {
+            return new VerboseDiagnosticsLogger(name);
+        }
+    }
+}

From c0423c2197acaca569b66ac6477f4e174ba4f964 Mon Sep 17 00:00:00 2001
From: Furkan VAROL <furkanvarol@hotmail.com>
Date: Tue, 10 Mar 2015 23:07:48 +0200
Subject: [PATCH 2/9] missing part of FromScanData method

---
 .../src/AltBeacon/Beacon/BeaconParser.cs      | 37 +++++++++++++++----
 1 file changed, 30 insertions(+), 7 deletions(-)

diff --git a/AltBeacon.Library/src/AltBeacon/Beacon/BeaconParser.cs b/AltBeacon.Library/src/AltBeacon/Beacon/BeaconParser.cs
index 524f534..39620f7 100644
--- a/AltBeacon.Library/src/AltBeacon/Beacon/BeaconParser.cs
+++ b/AltBeacon.Library/src/AltBeacon/Beacon/BeaconParser.cs
@@ -795,18 +795,41 @@ protected static bool AreByteArraysMatch(byte[] array1, int offset1, byte[] arra
         /// </returns>
         protected Beacon FromScanData(byte[] scanData, int rssi, BluetoothDevice device, Beacon.Builder beaconBuilder)
         {
-            int startByte = 2;
-            bool patternFound = false;
-            int matchingBeaconSize = this.matchingBeaconTypeCodeEndOffset.Value - 
+            int maxByteForMatch = 5; // for manufacturer data-based beacons
+            byte[] serviceUuidBytes = null;
+
+            int matchingBeaconSize = this.matchingBeaconTypeCodeEndOffset.Value -
                 this.matchingBeaconTypeCodeStartOffset.Value + 1;
             byte[] typeCodeBytes = LongToByteArray(this.MatchingBeaconTypeCode, matchingBeaconSize);
 
-            while (startByte <= 5)
+            if (this.ServiceUuid != null)
+            {
+                maxByteForMatch = 11; // for uuid-based beacons
+                int serviceUuidSize = this.ServiceUuidEndOffset - this.ServiceUuidStartOffset + 1;
+                serviceUuidBytes = LongToByteArray(this.ServiceUuid.Value, serviceUuidSize);
+            }
+
+            int startByte = 2;
+            bool patternFound = false;
+
+            while (startByte <= maxByteForMatch)
             {
-                if (AreByteArraysMatch(scanData, startByte + this.matchingBeaconTypeCodeStartOffset.Value, typeCodeBytes, 0))
+                if (this.ServiceUuid == null)
+                {
+                    if (AreByteArraysMatch(scanData, startByte + this.MatchingBeaconTypeCodeStartOffset, typeCodeBytes, 0))
+                    {
+                        patternFound = true;
+                        break;
+                    }
+                }
+                else
                 {
-                    patternFound = true;
-                    break;
+                    if (AreByteArraysMatch(scanData, startByte + this.ServiceUuidStartOffset, serviceUuidBytes, 0) &&
+                            AreByteArraysMatch(scanData, startByte + this.MatchingBeaconTypeCodeStartOffset, typeCodeBytes, 0))
+                    {
+                        patternFound = true;
+                        break;
+                    }
                 }
 
                 startByte++;

From 850f5b0ccaf00fd841405f0d15c6ade89a788bab Mon Sep 17 00:00:00 2001
From: Furkan VAROL <furkanvarol@hotmail.com>
Date: Tue, 10 Mar 2015 23:08:44 +0200
Subject: [PATCH 3/9] Beacon and BeaconParser has been adapter to LogManager
 (TODOs has been done)

---
 .../src/AltBeacon/Beacon/Beacon.cs            | 18 ++---
 .../src/AltBeacon/Beacon/BeaconParser.cs      | 74 +++++++++----------
 2 files changed, 45 insertions(+), 47 deletions(-)

diff --git a/AltBeacon.Library/src/AltBeacon/Beacon/Beacon.cs b/AltBeacon.Library/src/AltBeacon/Beacon/Beacon.cs
index 0fd5eeb..da5bfa6 100644
--- a/AltBeacon.Library/src/AltBeacon/Beacon/Beacon.cs
+++ b/AltBeacon.Library/src/AltBeacon/Beacon/Beacon.cs
@@ -27,6 +27,7 @@ namespace AltBeacon.Beacon
     using System.Collections.Generic;
     using System.Collections.ObjectModel;
     using System.Text;
+    using AltBeacon.Logging;
 
     /// <summary>
     /// <para>
@@ -56,9 +57,9 @@ namespace AltBeacon.Beacon
     public class Beacon
     {
         /// <summary>
-        /// Logger Tag
+        /// Current Class Logger Reference
         /// </summary>
-        private const string Tag = "Beacon";
+        private static readonly ILogger Logger = LogManager.GetLogger("Beacon");
 
         /// TODO DistanceCalculator
         /*protected static DistanceCalculator sDistanceCalculator = null;*/
@@ -224,11 +225,10 @@ public double Distance
                     {
                         bestRssiAvailable = this.RunningAverageRssi.Value;
                     }
-                    ////TODO LogManager
-                    ////else
-                    ////{
-                    ////    LogManager.d(Tag, "Not using running average RSSI because it is null");
-                    ////}
+                    else
+                    {
+                        Logger.Debug("Not using running average RSSI because it is null");
+                    }
 
                     this.distance = CalculateDistance(this.TxPower, bestRssiAvailable);
                 }
@@ -283,7 +283,6 @@ public double Distance
         /// </summary>
         public int ServiceUuid { get; protected set; }
 
-
         /// <summary>
         /// Gets and sets the DistanceCalculator to use with this beacon.
         /// </summary>
@@ -410,8 +409,7 @@ protected static double CalculateDistance(int txPower, double bestRssiAvailable)
             ////}
             ////else
             ////{
-                ////TODO LogManager
-                ////LogManager.e(Tag, "Distance calculator not set.  Distance will bet set to -1");
+                ////Logger.Error("Distance calculator not set.  Distance will bet set to -1");
                 return -1.0;
             ////}
         }
diff --git a/AltBeacon.Library/src/AltBeacon/Beacon/BeaconParser.cs b/AltBeacon.Library/src/AltBeacon/Beacon/BeaconParser.cs
index 39620f7..991231f 100644
--- a/AltBeacon.Library/src/AltBeacon/Beacon/BeaconParser.cs
+++ b/AltBeacon.Library/src/AltBeacon/Beacon/BeaconParser.cs
@@ -29,6 +29,7 @@ namespace AltBeacon.Beacon
     using System.Text;
     using System.Text.RegularExpressions;
     using AltBeacon.Bluetooth;
+    using AltBeacon.Logging;
 
     /// <summary>
     /// <para>
@@ -52,9 +53,9 @@ public partial class BeaconParser
     {
         #region Static Fields
         /// <summary>
-        /// Logger Tag
+        /// Current Class Logger Reference
         /// </summary>
-        private const string Tag = "BeaconParser";
+        private static readonly ILogger Logger = LogManager.GetLogger("BeaconParser");
 
         /// <summary>
         /// Identifier Pattern
@@ -416,8 +417,7 @@ public BeaconParser SetBeaconLayout(string beaconLayout)
 
                 if (!found)
                 {
-                    ////TODO LogManager
-                    ////LogManager.d(Tag, "cannot parse term " + term);
+                    Logger.Debug("cannot parse term " + term);
                     throw new BeaconLayoutException("Cannot parse beacon layout term: " + term);
                 }
             }
@@ -699,19 +699,16 @@ protected static string ByteArrayToFormattedString(byte[] byteBuffer, int startI
             {
                 long number = 0L;
 
-                //// TODO LogManager
-                //// LogManager.d(Tag, "Byte array is size " + bytes.Length);
+                Logger.Debug("Byte array is size " + bytes.Length);
                 for (int i = 0; i < bytes.Length; i++)
                 {
-                    //// TODO LogManager
-                    //// LogManager.d(Tag, "index is " + i);
+                    Logger.Debug("index is " + i);
                     long byteValue = (long)(bytes[bytes.Length - i - 1] & 0xff);
                     long positionValue = (long)Math.Pow(256.0, i * 1.0);
                     long calculatedValue = (long)(byteValue * positionValue);
-                    //// TODO LogManager
-                    //// LogManager.d(Tag, "calculatedValue for position " + i + 
-                    ////     " with positionValue " + positionValue + " and byteValue " + 
-                    ////     byteValue + " is " + calculatedValue);
+                    Logger.Debug("calculatedValue for position " + i + 
+                         " with positionValue " + positionValue + " and byteValue " + 
+                         byteValue + " is " + calculatedValue);
                     number += calculatedValue;
                 }
 
@@ -838,41 +835,44 @@ protected Beacon FromScanData(byte[] scanData, int rssi, BluetoothDevice device,
             if (patternFound == false)
             {
                 // This is not a beacon
-                // TODO LogManager
-                /*if (this.ServiceUuid == null)
+                if (this.ServiceUuid == null)
                 {
-                    TODO LogManager
-                    if (LogManager.isVerboseLoggingEnabled())
+                    if (LogManager.VerboseLoggingEnabled)
                     {
-                        LogManager.d(TAG, "This is not a matching Beacon advertisement. " + 
-                            "(Was expecting %s. The bytes I see are: %s",
-                            byteArrayToString(typeCodeBytes), bytesToHex(scanData));
+                        Logger.Debug(
+                            "This is not a matching Beacon advertisement. " + 
+                            "(Was expecting {0}. The bytes I see are: {1}",
+                            ByteArrayToString(typeCodeBytes),
+                            BytesToHex(scanData));
                     }
                 }   
                 else
                 {
-                    if (LogManager.isVerboseLoggingEnabled())
+                    if (LogManager.VerboseLoggingEnabled)
                     {
-                        LogManager.d(TAG, "This is not a matching Beacon advertisement. " + 
-                            "(Was expecting %s and %s. The bytes I see are: %s", 
-                            byteArrayToString(serviceUuidBytes), 
-                            byteArrayToString(typeCodeBytes), bytesToHex(scanData));
+                        Logger.Debug(
+                            "This is not a matching Beacon advertisement. " + 
+                            "(Was expecting {0} and {1}. The bytes I see are: {2}", 
+                            ByteArrayToString(serviceUuidBytes), 
+                            ByteArrayToString(typeCodeBytes),
+                            BytesToHex(scanData));
                     }
-                }*/
+                }
+
                 return null;
             }
             else
             {
-                //// TODO LogManager
-                //// if (LogManager.isVerboseLoggingEnabled())
-                //// {
-                ////     LogManager.d(TAG, "This is a recognized beacon advertisement -- %s seen",
-                ////             byteArrayToString(typeCodeBytes));
-                //// }
-                ////
-                //// TODO LogManager
-                //// LogManager.d(Tag, "This is a recognized beacon advertisement -- " + 
-                ////     getMatchingBeaconTypeCode().ToString("x4") + " seen");
+                if (LogManager.VerboseLoggingEnabled)
+                {
+                    Logger.Debug(
+                        "This is a recognized beacon advertisement -- {0} seen",
+                        ByteArrayToString(typeCodeBytes));
+                }
+
+                Logger.Debug(
+                    "This is a recognized beacon advertisement -- {0} seen",
+                    this.MatchingBeaconTypeCode.ToString("x4"));
             }
 
             List<Identifier> identifiers = new List<Identifier>();
@@ -897,8 +897,8 @@ TODO LogManager
                     this.dataLittleEndianFlags[i]);
 
                 dataFields.Add(long.Parse(dataString));
-                //// TODO LogManager
-                //// LogManager.d(Tag, "parsing found data field " + i);
+                
+                Logger.Debug("parsing found data field " + i);
                 //// TODO: error handling needed here on the parse
             }
 

From 66c58fa9838e0c19de9728d2c0908e469a73a61d Mon Sep 17 00:00:00 2001
From: Furkan VAROL <furkanvarol@hotmail.com>
Date: Wed, 11 Mar 2015 21:36:37 +0200
Subject: [PATCH 4/9] fixed on LogManagers predefined logger factory var type
 also a default logger factory static var has been added

---
 .../src/AltBeacon/Logging/LogManager.cs            | 14 ++++++++++----
 1 file changed, 10 insertions(+), 4 deletions(-)

diff --git a/AltBeacon.Library/src/AltBeacon/Logging/LogManager.cs b/AltBeacon.Library/src/AltBeacon/Logging/LogManager.cs
index 177e3a6..50db179 100644
--- a/AltBeacon.Library/src/AltBeacon/Logging/LogManager.cs
+++ b/AltBeacon.Library/src/AltBeacon/Logging/LogManager.cs
@@ -31,24 +31,30 @@ namespace AltBeacon.Logging
     public static class LogManager
     {
         #region Factory Fields
+        /// <summary>
+        /// Default Logger Factory
+        /// <see cref="WarningDiagnosticsLoggerFactory"/>
+        /// </summary>
+        public static readonly ILoggerFactory DefaultLoggerFactory = new WarningDiagnosticsLoggerFactory();
+
         /// <summary>
         /// Predefined Empty Logger Factory
         /// <see cref="AltBeacon.Logging.EmptyLoggerFactory"/>
         /// </summary>
-        public static readonly EmptyLoggerFactory EmptyLoggerFactory = new EmptyLoggerFactory();
+        public static readonly ILoggerFactory EmptyLoggerFactory = new EmptyLoggerFactory();
 
         /// <summary>
         /// Predefined Verbose(Trace) or higher level Logger Factory
         /// <see cref="AltBeacon.Logging.VerboseDiagnosticsLoggerFactory"/>
         /// </summary>
-        public static readonly VerboseDiagnosticsLoggerFactory VerboseDiagnosticsLoggerFactory =
+        public static readonly ILoggerFactory VerboseDiagnosticsLoggerFactory =
             new VerboseDiagnosticsLoggerFactory();
 
         /// <summary>
         /// Predefined Warning or higher level Logger Factory
         /// <see cref="AltBeacon.Logging.WarningDiagnosticsLoggerFactory"/>
         /// </summary>
-        public static readonly WarningDiagnosticsLoggerFactory WarningDiagnosticsLoggerFactory =
+        public static readonly ILoggerFactory WarningDiagnosticsLoggerFactory =
             new WarningDiagnosticsLoggerFactory();
         #endregion Factory Fields
 
@@ -56,7 +62,7 @@ public static class LogManager
         /// <summary>
         /// <see cref="LoggerFactory"/>
         /// </summary>
-        private static ILoggerFactory loggerFactory = WarningDiagnosticsLoggerFactory;
+        private static ILoggerFactory loggerFactory = DefaultLoggerFactory;
 
         /// <summary>
         /// <see cref="VerboseLoggingEnabled"/>

From 93d3b9cc1e93cdb7a85dbd928ee1f3fe2563dbd7 Mon Sep 17 00:00:00 2001
From: Furkan VAROL <furkanvarol@hotmail.com>
Date: Thu, 12 Mar 2015 20:11:39 +0200
Subject: [PATCH 5/9] Portable Class Library has been changed with Class
 Library (Library Project Type)

---
 AltBeacon.Library/AltBeacon.Library.csproj | 14 +++++++++-----
 1 file changed, 9 insertions(+), 5 deletions(-)

diff --git a/AltBeacon.Library/AltBeacon.Library.csproj b/AltBeacon.Library/AltBeacon.Library.csproj
index f846335..da5abce 100644
--- a/AltBeacon.Library/AltBeacon.Library.csproj
+++ b/AltBeacon.Library/AltBeacon.Library.csproj
@@ -2,7 +2,6 @@
 <Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
   <PropertyGroup>
-    <MinimumVisualStudioVersion>11.0</MinimumVisualStudioVersion>
     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
     <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
     <ProjectGuid>{CB062D54-BA72-4AE5-9E1B-6E4A2CA68C30}</ProjectGuid>
@@ -11,9 +10,7 @@
     <RootNamespace>AltBeacon</RootNamespace>
     <AssemblyName>AltBeacon.Library</AssemblyName>
     <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
-    <TargetFrameworkProfile>Profile7</TargetFrameworkProfile>
     <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
     <DebugSymbols>true</DebugSymbols>
@@ -33,7 +30,14 @@
     <WarningLevel>4</WarningLevel>
   </PropertyGroup>
   <ItemGroup>
-    <!-- A reference to the entire .NET Framework is automatically included -->
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Numerics" />
+    <Reference Include="System.Xml.Linq" />
+    <Reference Include="System.Data.DataSetExtensions" />
+    <Reference Include="Microsoft.CSharp" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
     <Compile Include="Properties\AssemblyInfo.cs" />
@@ -55,7 +59,7 @@
     <Compile Include="src\AltBeacon\Logging\WarningDiagnosticsLogger.cs" />
     <Compile Include="src\AltBeacon\Logging\WarningDiagnosticsLoggerFactory.cs" />
   </ItemGroup>
-  <Import Project="$(MSBuildExtensionsPath32)\Microsoft\Portable\$(TargetFrameworkVersion)\Microsoft.Portable.CSharp.targets" />
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.
   <Target Name="BeforeBuild">

From 17c0f0d78aceee45a142e433e0cb42a7e407a071 Mon Sep 17 00:00:00 2001
From: Furkan VAROL <furkanvarol@hotmail.com>
Date: Thu, 12 Mar 2015 21:40:22 +0200
Subject: [PATCH 6/9] UnitTests for logging package

---
 .../AltBeacon.LibraryTest.csproj              |   8 +
 .../Logging/EmptyLoggerFactoryTest.cs         |  82 ++
 .../src/AltBeacon/Logging/EmptyLoggerTest.cs  |  49 ++
 .../src/AltBeacon/Logging/LogManagerTest.cs   | 173 ++++
 .../VerboseDiagnosticsLoggerFactoryTest.cs    |  82 ++
 .../Logging/VerboseDiagnosticsLoggerTest.cs   | 790 ++++++++++++++++++
 .../WarningDiagnosticsLoggerFactoryTest.cs    |  82 ++
 .../Logging/WarningDiagnosticsLoggerTest.cs   | 766 +++++++++++++++++
 8 files changed, 2032 insertions(+)
 create mode 100644 AltBeacon.LibraryTest/src/AltBeacon/Logging/EmptyLoggerFactoryTest.cs
 create mode 100644 AltBeacon.LibraryTest/src/AltBeacon/Logging/EmptyLoggerTest.cs
 create mode 100644 AltBeacon.LibraryTest/src/AltBeacon/Logging/LogManagerTest.cs
 create mode 100644 AltBeacon.LibraryTest/src/AltBeacon/Logging/VerboseDiagnosticsLoggerFactoryTest.cs
 create mode 100644 AltBeacon.LibraryTest/src/AltBeacon/Logging/VerboseDiagnosticsLoggerTest.cs
 create mode 100644 AltBeacon.LibraryTest/src/AltBeacon/Logging/WarningDiagnosticsLoggerFactoryTest.cs
 create mode 100644 AltBeacon.LibraryTest/src/AltBeacon/Logging/WarningDiagnosticsLoggerTest.cs

diff --git a/AltBeacon.LibraryTest/AltBeacon.LibraryTest.csproj b/AltBeacon.LibraryTest/AltBeacon.LibraryTest.csproj
index 3b80c3d..df83da0 100644
--- a/AltBeacon.LibraryTest/AltBeacon.LibraryTest.csproj
+++ b/AltBeacon.LibraryTest/AltBeacon.LibraryTest.csproj
@@ -54,6 +54,13 @@
     <Compile Include="src\AltBeacon\Beacon\IdentifierTest.cs" />
     <Compile Include="src\AltBeacon\Beacon\BeaconTest.cs" />
     <Compile Include="src\AltBeacon\Beacon\BeaconParserTest.cs" />
+    <Compile Include="src\AltBeacon\Logging\WarningDiagnosticsLoggerFactoryTest.cs" />
+    <Compile Include="src\AltBeacon\Logging\VerboseDiagnosticsLoggerFactoryTest.cs" />
+    <Compile Include="src\AltBeacon\Logging\LogManagerTest.cs" />
+    <Compile Include="src\AltBeacon\Logging\EmptyLoggerTest.cs" />
+    <Compile Include="src\AltBeacon\Logging\EmptyLoggerFactoryTest.cs" />
+    <Compile Include="src\AltBeacon\Logging\WarningDiagnosticsLoggerTest.cs" />
+    <Compile Include="src\AltBeacon\Logging\VerboseDiagnosticsLoggerTest.cs" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\AltBeacon.Library\AltBeacon.Library.csproj">
@@ -61,6 +68,7 @@
       <Name>AltBeacon.Library</Name>
     </ProjectReference>
   </ItemGroup>
+  <ItemGroup />
   <Choose>
     <When Condition="'$(VisualStudioVersion)' == '10.0' And '$(IsCodedUITest)' == 'True'">
       <ItemGroup>
diff --git a/AltBeacon.LibraryTest/src/AltBeacon/Logging/EmptyLoggerFactoryTest.cs b/AltBeacon.LibraryTest/src/AltBeacon/Logging/EmptyLoggerFactoryTest.cs
new file mode 100644
index 0000000..2e9d245
--- /dev/null
+++ b/AltBeacon.LibraryTest/src/AltBeacon/Logging/EmptyLoggerFactoryTest.cs
@@ -0,0 +1,82 @@
+// <copyright file="EmptyLoggerFactoryTest.cs" company="Radius Networks, Inc.">
+//     Copyright (c) Radius Networks, Inc.
+//     http://www.radiusnetworks.com
+// </copyright>
+// 
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements. See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership. The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License. You may obtain a copy of the License at
+// 
+// http://www.apache.org/licenses/LICENSE-2.0
+// 
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations
+// under the License.
+namespace AltBeacon.Logging
+{
+    using System;
+    using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+    /// <summary>
+    /// <see cref="AltBeacon.Logging.EmptyLoggerFactory"/> test class.
+    /// </summary>
+    [TestClass]
+    public class EmptyLoggerFactoryTest
+    {
+        #region Logger Name
+        /// <summary>
+        /// Logger Name Test
+        /// </summary>
+        [TestMethod]
+        public void TestLoggerName()
+        {
+            var logger = new EmptyLoggerFactory().GetLogger("EmptyLoggerFactoryTest");
+
+            Assert.AreEqual(
+                "EmptyLoggerFactoryTest",
+                logger.Name,
+                "Logger name should be set to EmptyLoggerFactoryTest");
+        }
+        #endregion Logger Name
+
+        #region Logger Type
+        /// <summary>
+        /// Logger Type Test
+        /// </summary>
+        [TestMethod]
+        public void TestLoggerType()
+        {
+            var logger = new EmptyLoggerFactory().GetLogger("EmptyLoggerFactoryTest");
+
+            Assert.IsInstanceOfType(
+                logger,
+                typeof(EmptyLogger),
+                "EmptyLoggerFactory.GetLogger method must give EmptyLogger objects");
+        }
+        #endregion Logger Type
+
+        #region Logger Reference (Two Logger Same Name)
+        /// <summary>
+        /// Logger Reference Test (Two Logger Same Name)
+        /// </summary>
+        [TestMethod]
+        public void TestTwoLoggerWithSameName()
+        {
+            var logger1 = new EmptyLoggerFactory().GetLogger("EmptyLoggerFactoryTest");
+            var logger2 = new EmptyLoggerFactory().GetLogger("EmptyLoggerFactoryTest");
+
+            Assert.AreNotSame(
+                logger1,
+                logger2,
+                "When getting logger with same name twice, different logger should be returned");
+        }
+        #endregion Logger Reference (Two Logger Same Name)
+    }
+}
diff --git a/AltBeacon.LibraryTest/src/AltBeacon/Logging/EmptyLoggerTest.cs b/AltBeacon.LibraryTest/src/AltBeacon/Logging/EmptyLoggerTest.cs
new file mode 100644
index 0000000..d71b5a7
--- /dev/null
+++ b/AltBeacon.LibraryTest/src/AltBeacon/Logging/EmptyLoggerTest.cs
@@ -0,0 +1,49 @@
+// <copyright file="EmptyLoggerTest.cs" company="Radius Networks, Inc.">
+//     Copyright (c) Radius Networks, Inc.
+//     http://www.radiusnetworks.com
+// </copyright>
+// 
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements. See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership. The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License. You may obtain a copy of the License at
+// 
+// http://www.apache.org/licenses/LICENSE-2.0
+// 
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations
+// under the License.
+namespace AltBeacon.Logging
+{
+    using System;
+    using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+    /// <summary>
+    /// <see cref="AltBeacon.Logging.EmptyLogger"/> test class.
+    /// </summary>
+    [TestClass]
+    public class EmptyLoggerTest
+    {
+        #region Logger Name
+        /// <summary>
+        /// Logger Name Test
+        /// </summary>
+        [TestMethod]
+        public void TestLoggerName()
+        {
+            var logger = new VerboseDiagnosticsLogger("EmptyLoggerTest");
+
+            Assert.AreEqual(
+                "EmptyLoggerTest",
+                logger.Name,
+                "Logger name should be set to EmptyLoggerTest");
+        }
+        #endregion Logger Name
+    }
+}
diff --git a/AltBeacon.LibraryTest/src/AltBeacon/Logging/LogManagerTest.cs b/AltBeacon.LibraryTest/src/AltBeacon/Logging/LogManagerTest.cs
new file mode 100644
index 0000000..40d9b2d
--- /dev/null
+++ b/AltBeacon.LibraryTest/src/AltBeacon/Logging/LogManagerTest.cs
@@ -0,0 +1,173 @@
+// <copyright file="LogManagerTest.cs" company="Radius Networks, Inc.">
+//     Copyright (c) Radius Networks, Inc.
+//     http://www.radiusnetworks.com
+// </copyright>
+// 
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements. See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership. The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License. You may obtain a copy of the License at
+// 
+// http://www.apache.org/licenses/LICENSE-2.0
+// 
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations
+// under the License.
+namespace AltBeacon.Logging
+{
+    using System;
+    using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+    /// <summary>
+    /// <see cref="AltBeacon.Logging.LogManager"/> test class.
+    /// </summary>
+    [TestClass]
+    public class LogManagerTest
+    {
+        [TestMethod]
+        public void TestVerboseLoggingEnabledTrue()
+        {
+            LogManager.VerboseLoggingEnabled = false;
+            LogManager.VerboseLoggingEnabled = true;
+
+            Assert.AreEqual(
+                true, 
+                LogManager.VerboseLoggingEnabled, 
+                "VerboseLoggingEnabled should be set to true");
+        }
+
+        [TestMethod]
+        public void TestVerboseLoggingEnabledFalse()
+        {
+            LogManager.VerboseLoggingEnabled = true;
+            LogManager.VerboseLoggingEnabled = false;
+
+            Assert.AreEqual(
+                false, 
+                LogManager.VerboseLoggingEnabled, 
+                "VerboseLoggingEnabled should be set to false");
+        }
+
+        [TestMethod]
+        public void TestDefaultLoggerFactory()
+        {
+            Assert.AreEqual(
+                LogManager.DefaultLoggerFactory, 
+                LogManager.LoggerFactory, 
+                "Initial value of the LoggerFactory must equal to DefaultLoggerFactory, " + 
+                "this test can be failed because of checking static reference and " + 
+                "it may be altered before this test is called. Just ignore it.");
+        }
+
+        [TestMethod]
+        [ExpectedException(typeof(NullReferenceException), "LogManager.LoggerFactory can no be null.")]
+        public void TestNullLoggerFactory()
+        {
+            LogManager.LoggerFactory = null;
+        }
+
+        [TestMethod]
+        public void TestEmptyLoggerFactory()
+        {
+            LogManager.LoggerFactory = LogManager.EmptyLoggerFactory;
+
+            Assert.AreEqual(
+                LogManager.EmptyLoggerFactory, 
+                LogManager.LoggerFactory, 
+                "LoggerFactory should be set to EmptyLoggerFactory");
+        }
+
+        [TestMethod]
+        public void TestVerboseDiagnosticsLoggerFactory()
+        {
+            LogManager.LoggerFactory = LogManager.VerboseDiagnosticsLoggerFactory;
+
+            Assert.AreEqual(
+                LogManager.VerboseDiagnosticsLoggerFactory, 
+                LogManager.LoggerFactory, 
+                "LoggerFactory should be set to VerboseDiagnosticsLoggerFactory");
+        }
+
+        [TestMethod]
+        public void TestWarningDiagnosticsLoggerFactory()
+        {
+            LogManager.LoggerFactory = LogManager.WarningDiagnosticsLoggerFactory;
+
+            Assert.AreEqual(
+                LogManager.WarningDiagnosticsLoggerFactory, 
+                LogManager.LoggerFactory, 
+                "LoggerFactory should be set to WarningDiagnosticsLoggerFactory");
+        }
+
+        [TestMethod]
+        public void TestEmptyLoggerFactoryName()
+        {
+            LogManager.LoggerFactory = LogManager.EmptyLoggerFactory;
+            ILogger logger = LogManager.GetLogger("TestLogger");
+
+            Assert.AreEqual(
+                "TestLogger",
+                logger.Name,
+                "LoggerFactory.GetLogger must create a ILogger with the same name " + 
+                    "it is provided to it if LoggerFactory is set to EmptyLoggerFactory");
+        }
+
+        [TestMethod]
+        public void TestVerboseDiagnosticsLoggerFactoryName()
+        {
+            LogManager.LoggerFactory = LogManager.VerboseDiagnosticsLoggerFactory;
+            ILogger logger = LogManager.GetLogger("TestLogger");
+
+            Assert.AreEqual(
+                "TestLogger",
+                logger.Name,
+                "LoggerFactory.GetLogger must create a ILogger with the same name " +
+                    "it is provided to it if LoggerFactory is set to VerboseDiagnosticsLoggerFactory");
+        }
+
+        [TestMethod]
+        public void TestWarningDiagnosticsLoggerFactoryName()
+        {
+            LogManager.LoggerFactory = LogManager.WarningDiagnosticsLoggerFactory;
+            ILogger logger = LogManager.GetLogger("TestLogger");
+
+            Assert.AreEqual(
+                "TestLogger",
+                logger.Name,
+                "LoggerFactory.GetLogger must create a ILogger with the same name " +
+                    "it is provided to it if LoggerFactory is set to WarningDiagnosticsLoggerFactory");
+        }        
+
+        [TestMethod]
+        public void TestGetLoggerDifferentNameDifferentObject()
+        {
+            LogManager.LoggerFactory = LogManager.DefaultLoggerFactory;
+            ILogger loggerFirst = LogManager.GetLogger("TestLoggerFirst");
+            ILogger loggerSecond = LogManager.GetLogger("TestLoggerSecond");
+
+            Assert.AreNotSame(
+                loggerFirst,
+                loggerSecond,
+                "LoggerFactory.GetLogger must create different logger when different name is provided");
+        }
+
+        [TestMethod]
+        public void TestGetLoggerSameNameDifferentObject()
+        {
+            LogManager.LoggerFactory = LogManager.DefaultLoggerFactory;
+            ILogger loggerFirst1 = LogManager.GetLogger("TestLoggerFirst");
+            ILogger loggerFirst2 = LogManager.GetLogger("TestLoggerFirst");
+
+            Assert.AreNotSame(
+                loggerFirst1,
+                loggerFirst2,
+                "LoggerFactory.GetLogger must create different logger even same name is provided");
+        }
+    }
+}
diff --git a/AltBeacon.LibraryTest/src/AltBeacon/Logging/VerboseDiagnosticsLoggerFactoryTest.cs b/AltBeacon.LibraryTest/src/AltBeacon/Logging/VerboseDiagnosticsLoggerFactoryTest.cs
new file mode 100644
index 0000000..ebdd1b6
--- /dev/null
+++ b/AltBeacon.LibraryTest/src/AltBeacon/Logging/VerboseDiagnosticsLoggerFactoryTest.cs
@@ -0,0 +1,82 @@
+// <copyright file="VerboseDiagnosticsLoggerFactoryTest.cs" company="Radius Networks, Inc.">
+//     Copyright (c) Radius Networks, Inc.
+//     http://www.radiusnetworks.com
+// </copyright>
+// 
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements. See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership. The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License. You may obtain a copy of the License at
+// 
+// http://www.apache.org/licenses/LICENSE-2.0
+// 
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations
+// under the License.
+namespace AltBeacon.Logging
+{
+    using System;
+    using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+    /// <summary>
+    /// <see cref="AltBeacon.Logging.VerboseDiagnosticsLoggerFactory"/> test class.
+    /// </summary>
+    [TestClass]
+    public class VerboseDiagnosticsLoggerFactoryTest
+    {
+        #region Logger Name
+        /// <summary>
+        /// Logger Name Test
+        /// </summary>
+        [TestMethod]
+        public void TestLoggerName()
+        {
+            var logger = new VerboseDiagnosticsLoggerFactory().GetLogger("VerboseDiagnosticsLoggerFactoryTest");
+
+            Assert.AreEqual(
+                "VerboseDiagnosticsLoggerFactoryTest",
+                logger.Name,
+                "Logger name should be set to VerboseDiagnosticsLoggerFactoryTest");
+        }
+        #endregion Logger Name
+
+        #region Logger Type
+        /// <summary>
+        /// Logger Type Test
+        /// </summary>
+        [TestMethod]
+        public void TestLoggerType()
+        {
+            var logger = new VerboseDiagnosticsLoggerFactory().GetLogger("VerboseDiagnosticsLoggerFactoryTest");
+
+            Assert.IsInstanceOfType(
+                logger,
+                typeof(VerboseDiagnosticsLogger),
+                "VerboseDiagnosticsLoggerFactory.GetLogger method must give VerboseDiagnosticsLogger objects");
+        }
+        #endregion Logger Type
+
+        #region Logger Reference (Two Logger Same Name)
+        /// <summary>
+        /// Logger Reference Test (Two Logger Same Name)
+        /// </summary>
+        [TestMethod]
+        public void TestTwoLoggerWithSameName()
+        {
+            var logger1 = new VerboseDiagnosticsLoggerFactory().GetLogger("VerboseDiagnosticsLoggerFactoryTest");
+            var logger2 = new VerboseDiagnosticsLoggerFactory().GetLogger("VerboseDiagnosticsLoggerFactoryTest");
+
+            Assert.AreNotSame(
+                logger1,
+                logger2,
+                "When getting logger with same name twice, different logger should be returned");
+        }
+        #endregion Logger Reference (Two Logger Same Name)
+    }
+}
diff --git a/AltBeacon.LibraryTest/src/AltBeacon/Logging/VerboseDiagnosticsLoggerTest.cs b/AltBeacon.LibraryTest/src/AltBeacon/Logging/VerboseDiagnosticsLoggerTest.cs
new file mode 100644
index 0000000..00c799d
--- /dev/null
+++ b/AltBeacon.LibraryTest/src/AltBeacon/Logging/VerboseDiagnosticsLoggerTest.cs
@@ -0,0 +1,790 @@
+// <copyright file="VerboseDiagnosticsLoggerTest.cs" company="Radius Networks, Inc.">
+//     Copyright (c) Radius Networks, Inc.
+//     http://www.radiusnetworks.com
+// </copyright>
+// 
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements. See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership. The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License. You may obtain a copy of the License at
+// 
+// http://www.apache.org/licenses/LICENSE-2.0
+// 
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations
+// under the License.
+namespace AltBeacon.Logging
+{
+    using System;
+    using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+    /// <summary>
+    /// <see cref="AltBeacon.Logging.VerboseDiagnosticsLogger"/> test class.
+    /// </summary>
+    [TestClass]
+    public class VerboseDiagnosticsLoggerTest : System.Diagnostics.TraceListener
+    {
+        #region Fields
+        /// <summary>
+        /// Last log message
+        /// </summary>
+        private string lastLogMessage;
+        #endregion Fields
+
+        #region Each Test Initialization and Cleanup
+        /// <summary>
+        /// Test initialize method which runs before each test.
+        /// </summary>
+        [TestInitialize]
+        public void TestInitializeMethod()
+        {
+            System.Diagnostics.Debug.Listeners.Add(this);
+            this.lastLogMessage = null;
+        }
+
+        /// <summary>
+        /// Test cleanup method which runs after each test.
+        /// </summary>
+        [TestCleanup]
+        public void TestCleanupMethod()
+        {
+            System.Diagnostics.Debug.Listeners.Remove(this);
+            this.lastLogMessage = null;
+        }
+        #endregion Each Test Initialization and Cleanup
+
+        #region Logger Name
+        /// <summary>
+        /// Logger Name Test
+        /// </summary>
+        [TestMethod]
+        public void TestLoggerName()
+        {
+            var logger = new VerboseDiagnosticsLogger("VerboseDiagnosticsLoggerTest");
+
+            Assert.AreEqual(
+                "VerboseDiagnosticsLoggerTest",
+                logger.Name,
+                "Logger name should be set to VerboseDiagnosticsLoggerTest");
+        }
+        #endregion Logger Name
+
+        #region Verbose
+        /// <summary>
+        /// Verbose Type Test
+        /// </summary>
+        [TestMethod]
+        public void TestVerboseType()
+        {
+            var logger = new VerboseDiagnosticsLogger("VerboseDiagnosticsLoggerTest");
+
+            logger.Verbose("dummy");
+
+            StringAssert.Contains(
+                this.lastLogMessage,
+                "Verbose",
+                "last log message must contain \"Verbose\"");
+        }
+
+        /// <summary>
+        /// Verbose Log Message Test
+        /// </summary>
+        [TestMethod]
+        public void TestVerboseMessage()
+        {
+            var logger = new VerboseDiagnosticsLogger("VerboseDiagnosticsLoggerTest");
+
+            logger.Verbose("this is a test");
+
+            StringAssert.Contains(
+                this.lastLogMessage, 
+                "this is a test", 
+                "last log message must contain \"this is a test \"");
+        }
+
+        /// <summary>
+        /// Verbose Log Message with Parameter (formatted string) Test
+        /// </summary>
+        [TestMethod]
+        public void TestVerboseMessageWithParam()
+        {
+            var logger = new VerboseDiagnosticsLogger("VerboseDiagnosticsLoggerTest");
+
+            logger.Verbose("{0} {1} {2} {3}", "this", "is", "a", "test");
+
+            StringAssert.Contains(
+                this.lastLogMessage, 
+                "this is a test", 
+                "last log message must contain \"this is a test\"");
+        }
+
+        /// <summary>
+        /// Verbose Log with Exception Test
+        /// </summary>
+        [TestMethod]
+        public void TestVerboseException()
+        {
+            var logger = new VerboseDiagnosticsLogger("VerboseDiagnosticsLoggerTest");
+
+            logger.Verbose(new Exception("oops something went wrong!"), "dummy");
+
+            StringAssert.Contains(
+                this.lastLogMessage,
+                "oops something went wrong!",
+                "last log message must contain \"oops something went wrong!\"");
+        }
+
+        /// <summary>
+        /// Verbose Log Message with Exception Test
+        /// </summary>
+        [TestMethod]
+        public void TestVerboseExceptionMessage()
+        {
+            var logger = new VerboseDiagnosticsLogger("VerboseDiagnosticsLoggerTest");
+
+            logger.Verbose(new Exception("oops something went wrong!"), "this is a test");
+
+            StringAssert.Contains(
+                this.lastLogMessage,
+                "this is a test",
+                "last log message must contain \"this is a test\"");
+        }
+
+        /// <summary>
+        /// Verbose Log Message with Parameter (formatted string) and Exception Test
+        /// </summary>
+        [TestMethod]
+        public void TestVerboseExceptionMessageWithParam()
+        {
+            var logger = new VerboseDiagnosticsLogger("VerboseDiagnosticsLoggerTest");
+
+            logger.Verbose(new Exception("oops something went wrong!"), "{0} {1} {2} {3}", "this", "is", "a", "test");
+
+            StringAssert.Contains(
+                this.lastLogMessage,
+                "this is a test",
+                "last log message must contain \"this is a test\"");
+        }
+        #endregion Verbose
+
+        #region Trace
+        /// <summary>
+        /// Trace Type Test
+        /// </summary>
+        [TestMethod]
+        public void TestTraceType()
+        {
+            var logger = new VerboseDiagnosticsLogger("VerboseDiagnosticsLoggerTest");
+
+            logger.Trace("dummy");
+
+            StringAssert.Contains(
+                this.lastLogMessage,
+                "Trace",
+                "last log message must contain \"Trace\"");
+        }
+
+        /// <summary>
+        /// Trace Log Message Test
+        /// </summary>
+        [TestMethod]
+        public void TestTraceMessage()
+        {
+            var logger = new VerboseDiagnosticsLogger("VerboseDiagnosticsLoggerTest");
+
+            logger.Trace("this is a test");
+
+            StringAssert.Contains(
+                this.lastLogMessage,
+                "this is a test",
+                "last log message must contain \"this is a test \"");
+        }
+
+        /// <summary>
+        /// Trace Log Message with Parameter (formatted string) Test
+        /// </summary>
+        [TestMethod]
+        public void TestTraceMessageWithParam()
+        {
+            var logger = new VerboseDiagnosticsLogger("VerboseDiagnosticsLoggerTest");
+
+            logger.Trace("{0} {1} {2} {3}", "this", "is", "a", "test");
+
+            StringAssert.Contains(
+                this.lastLogMessage,
+                "this is a test",
+                "last log message must contain \"this is a test\"");
+        }
+
+        /// <summary>
+        /// Trace Log with Exception Test
+        /// </summary>
+        [TestMethod]
+        public void TestTraceException()
+        {
+            var logger = new VerboseDiagnosticsLogger("VerboseDiagnosticsLoggerTest");
+
+            logger.Trace(new Exception("oops something went wrong!"), "dummy");
+
+            StringAssert.Contains(
+                this.lastLogMessage,
+                "oops something went wrong!",
+                "last log message must contain \"oops something went wrong!\"");
+        }
+
+        /// <summary>
+        /// Trace Log Message with Exception Test
+        /// </summary>
+        [TestMethod]
+        public void TestTraceExceptionMessage()
+        {
+            var logger = new VerboseDiagnosticsLogger("VerboseDiagnosticsLoggerTest");
+
+            logger.Trace(new Exception("oops something went wrong!"), "this is a test");
+
+            StringAssert.Contains(
+                this.lastLogMessage,
+                "this is a test",
+                "last log message must contain \"this is a test\"");
+        }
+
+        /// <summary>
+        /// Trace Log Message with Parameter (formatted string) and Exception Test
+        /// </summary>
+        [TestMethod]
+        public void TestTraceExceptionMessageWithParam()
+        {
+            var logger = new VerboseDiagnosticsLogger("VerboseDiagnosticsLoggerTest");
+
+            logger.Trace(new Exception("oops something went wrong!"), "{0} {1} {2} {3}", "this", "is", "a", "test");
+
+            StringAssert.Contains(
+                this.lastLogMessage,
+                "this is a test",
+                "last log message must contain \"this is a test\"");
+        }
+        #endregion Trace
+
+        #region Debug
+        /// <summary>
+        /// Debug Type Test
+        /// </summary>
+        [TestMethod]
+        public void TestDebugType()
+        {
+            var logger = new VerboseDiagnosticsLogger("VerboseDiagnosticsLoggerTest");
+
+            logger.Debug("dummy");
+
+            StringAssert.Contains(
+                this.lastLogMessage,
+                "Debug",
+                "last log message must contain \"Debug\"");
+        }
+
+        /// <summary>
+        /// Debug Log Message Test
+        /// </summary>
+        [TestMethod]
+        public void TestDebugMessage()
+        {
+            var logger = new VerboseDiagnosticsLogger("VerboseDiagnosticsLoggerTest");
+
+            logger.Debug("this is a test");
+
+            StringAssert.Contains(
+                this.lastLogMessage,
+                "this is a test",
+                "last log message must contain \"this is a test \"");
+        }
+
+        /// <summary>
+        /// Debug Log Message with Parameter (formatted string) Test
+        /// </summary>
+        [TestMethod]
+        public void TestDebugMessageWithParam()
+        {
+            var logger = new VerboseDiagnosticsLogger("VerboseDiagnosticsLoggerTest");
+
+            logger.Debug("{0} {1} {2} {3}", "this", "is", "a", "test");
+
+            StringAssert.Contains(
+                this.lastLogMessage,
+                "this is a test",
+                "last log message must contain \"this is a test\"");
+        }
+
+        /// <summary>
+        /// Debug Log with Exception Test
+        /// </summary>
+        [TestMethod]
+        public void TestDebugException()
+        {
+            var logger = new VerboseDiagnosticsLogger("VerboseDiagnosticsLoggerTest");
+
+            logger.Debug(new Exception("oops something went wrong!"), "dummy");
+
+            StringAssert.Contains(
+                this.lastLogMessage,
+                "oops something went wrong!",
+                "last log message must contain \"oops something went wrong!\"");
+        }
+
+        /// <summary>
+        /// Debug Log Message with Exception Test
+        /// </summary>
+        [TestMethod]
+        public void TestDebugExceptionMessage()
+        {
+            var logger = new VerboseDiagnosticsLogger("VerboseDiagnosticsLoggerTest");
+
+            logger.Debug(new Exception("oops something went wrong!"), "this is a test");
+
+            StringAssert.Contains(
+                this.lastLogMessage,
+                "this is a test",
+                "last log message must contain \"this is a test\"");
+        }
+
+        /// <summary>
+        /// Debug Log Message with Parameter (formatted string) and Exception Test
+        /// </summary>
+        [TestMethod]
+        public void TestDebugExceptionMessageWithParam()
+        {
+            var logger = new VerboseDiagnosticsLogger("VerboseDiagnosticsLoggerTest");
+
+            logger.Debug(new Exception("oops something went wrong!"), "{0} {1} {2} {3}", "this", "is", "a", "test");
+
+            StringAssert.Contains(
+                this.lastLogMessage,
+                "this is a test",
+                "last log message must contain \"this is a test\"");
+        }
+        #endregion Debug
+
+        #region Info
+        /// <summary>
+        /// Info Type Test
+        /// </summary>
+        [TestMethod]
+        public void TestInfoType()
+        {
+            var logger = new VerboseDiagnosticsLogger("VerboseDiagnosticsLoggerTest");
+
+            logger.Info("dummy");
+
+            StringAssert.Contains(
+                this.lastLogMessage,
+                "Info",
+                "last log message must contain \"Info\"");
+        }
+
+        /// <summary>
+        /// Info Log Message Test
+        /// </summary>
+        [TestMethod]
+        public void TestInfoMessage()
+        {
+            var logger = new VerboseDiagnosticsLogger("VerboseDiagnosticsLoggerTest");
+
+            logger.Info("this is a test");
+
+            StringAssert.Contains(
+                this.lastLogMessage,
+                "this is a test",
+                "last log message must contain \"this is a test \"");
+        }
+
+        /// <summary>
+        /// Info Log Message with Parameter (formatted string) Test
+        /// </summary>
+        [TestMethod]
+        public void TestInfoMessageWithParam()
+        {
+            var logger = new VerboseDiagnosticsLogger("VerboseDiagnosticsLoggerTest");
+
+            logger.Info("{0} {1} {2} {3}", "this", "is", "a", "test");
+
+            StringAssert.Contains(
+                this.lastLogMessage,
+                "this is a test",
+                "last log message must contain \"this is a test\"");
+        }
+
+        /// <summary>
+        /// Info Log with Exception Test
+        /// </summary>
+        [TestMethod]
+        public void TestInfoException()
+        {
+            var logger = new VerboseDiagnosticsLogger("VerboseDiagnosticsLoggerTest");
+
+            logger.Info(new Exception("oops something went wrong!"), "dummy");
+
+            StringAssert.Contains(
+                this.lastLogMessage,
+                "oops something went wrong!",
+                "last log message must contain \"oops something went wrong!\"");
+        }
+
+        /// <summary>
+        /// Info Log Message with Exception Test
+        /// </summary>
+        [TestMethod]
+        public void TestInfoExceptionMessage()
+        {
+            var logger = new VerboseDiagnosticsLogger("VerboseDiagnosticsLoggerTest");
+
+            logger.Info(new Exception("oops something went wrong!"), "this is a test");
+
+            StringAssert.Contains(
+                this.lastLogMessage,
+                "this is a test",
+                "last log message must contain \"this is a test\"");
+        }
+
+        /// <summary>
+        /// Info Log Message with Parameter (formatted string) and Exception Test
+        /// </summary>
+        [TestMethod]
+        public void TestInfoExceptionMessageWithParam()
+        {
+            var logger = new VerboseDiagnosticsLogger("VerboseDiagnosticsLoggerTest");
+
+            logger.Info(new Exception("oops something went wrong!"), "{0} {1} {2} {3}", "this", "is", "a", "test");
+
+            StringAssert.Contains(
+                this.lastLogMessage,
+                "this is a test",
+                "last log message must contain \"this is a test\"");
+        }
+        #endregion Info
+
+        #region Warn
+        /// <summary>
+        /// Warn Type Test
+        /// </summary>
+        [TestMethod]
+        public void TestWarnType()
+        {
+            var logger = new VerboseDiagnosticsLogger("VerboseDiagnosticsLoggerTest");
+
+            logger.Warn("dummy");
+
+            StringAssert.Contains(
+                this.lastLogMessage,
+                "Warn",
+                "last log message must contain \"Warn\"");
+        }
+
+        /// <summary>
+        /// Warn Log Message Test
+        /// </summary>
+        [TestMethod]
+        public void TestWarnMessage()
+        {
+            var logger = new VerboseDiagnosticsLogger("VerboseDiagnosticsLoggerTest");
+
+            logger.Warn("this is a test");
+
+            StringAssert.Contains(
+                this.lastLogMessage,
+                "this is a test",
+                "last log message must contain \"this is a test \"");
+        }
+
+        /// <summary>
+        /// Warn Log Message with Parameter (formatted string) Test
+        /// </summary>
+        [TestMethod]
+        public void TestWarnMessageWithParam()
+        {
+            var logger = new VerboseDiagnosticsLogger("VerboseDiagnosticsLoggerTest");
+
+            logger.Warn("{0} {1} {2} {3}", "this", "is", "a", "test");
+
+            StringAssert.Contains(
+                this.lastLogMessage,
+                "this is a test",
+                "last log message must contain \"this is a test\"");
+        }
+
+        /// <summary>
+        /// Warn Log with Exception Test
+        /// </summary>
+        [TestMethod]
+        public void TestWarnException()
+        {
+            var logger = new VerboseDiagnosticsLogger("VerboseDiagnosticsLoggerTest");
+
+            logger.Warn(new Exception("oops something went wrong!"), "dummy");
+
+            StringAssert.Contains(
+                this.lastLogMessage,
+                "oops something went wrong!",
+                "last log message must contain \"oops something went wrong!\"");
+        }
+
+        /// <summary>
+        /// Warn Log Message with Exception Test
+        /// </summary>
+        [TestMethod]
+        public void TestWarnExceptionMessage()
+        {
+            var logger = new VerboseDiagnosticsLogger("VerboseDiagnosticsLoggerTest");
+
+            logger.Warn(new Exception("oops something went wrong!"), "this is a test");
+
+            StringAssert.Contains(
+                this.lastLogMessage,
+                "this is a test",
+                "last log message must contain \"this is a test\"");
+        }
+
+        /// <summary>
+        /// Warn Log Message with Parameter (formatted string) and Exception Test
+        /// </summary>
+        [TestMethod]
+        public void TestWarnExceptionMessageWithParam()
+        {
+            var logger = new VerboseDiagnosticsLogger("VerboseDiagnosticsLoggerTest");
+
+            logger.Warn(new Exception("oops something went wrong!"), "{0} {1} {2} {3}", "this", "is", "a", "test");
+
+            StringAssert.Contains(
+                this.lastLogMessage,
+                "this is a test",
+                "last log message must contain \"this is a test\"");
+        }
+        #endregion Warn
+
+        #region Error
+        /// <summary>
+        /// Error Type Test
+        /// </summary>
+        [TestMethod]
+        public void TestErrorType()
+        {
+            var logger = new VerboseDiagnosticsLogger("VerboseDiagnosticsLoggerTest");
+
+            logger.Error("dummy");
+
+            StringAssert.Contains(
+                this.lastLogMessage,
+                "Error",
+                "last log message must contain \"Error\"");
+        }
+
+        /// <summary>
+        /// Error Log Message Test
+        /// </summary>
+        [TestMethod]
+        public void TestErrorMessage()
+        {
+            var logger = new VerboseDiagnosticsLogger("VerboseDiagnosticsLoggerTest");
+
+            logger.Error("this is a test");
+
+            StringAssert.Contains(
+                this.lastLogMessage,
+                "this is a test",
+                "last log message must contain \"this is a test \"");
+        }
+
+        /// <summary>
+        /// Error Log Message with Parameter (formatted string) Test
+        /// </summary>
+        [TestMethod]
+        public void TestErrorMessageWithParam()
+        {
+            var logger = new VerboseDiagnosticsLogger("VerboseDiagnosticsLoggerTest");
+
+            logger.Error("{0} {1} {2} {3}", "this", "is", "a", "test");
+
+            StringAssert.Contains(
+                this.lastLogMessage,
+                "this is a test",
+                "last log message must contain \"this is a test\"");
+        }
+
+        /// <summary>
+        /// Error Log with Exception Test
+        /// </summary>
+        [TestMethod]
+        public void TestErrorException()
+        {
+            var logger = new VerboseDiagnosticsLogger("VerboseDiagnosticsLoggerTest");
+
+            logger.Error(new Exception("oops something went wrong!"), "dummy");
+
+            StringAssert.Contains(
+                this.lastLogMessage,
+                "oops something went wrong!",
+                "last log message must contain \"oops something went wrong!\"");
+        }
+
+        /// <summary>
+        /// Error Log Message with Exception Test
+        /// </summary>
+        [TestMethod]
+        public void TestErrorExceptionMessage()
+        {
+            var logger = new VerboseDiagnosticsLogger("VerboseDiagnosticsLoggerTest");
+
+            logger.Error(new Exception("oops something went wrong!"), "this is a test");
+
+            StringAssert.Contains(
+                this.lastLogMessage,
+                "this is a test",
+                "last log message must contain \"this is a test\"");
+        }
+
+        /// <summary>
+        /// Error Log Message with Parameter (formatted string) and Exception Test
+        /// </summary>
+        [TestMethod]
+        public void TestErrorExceptionMessageWithParam()
+        {
+            var logger = new VerboseDiagnosticsLogger("VerboseDiagnosticsLoggerTest");
+
+            logger.Error(new Exception("oops something went wrong!"), "{0} {1} {2} {3}", "this", "is", "a", "test");
+
+            StringAssert.Contains(
+                this.lastLogMessage,
+                "this is a test",
+                "last log message must contain \"this is a test\"");
+        }
+        #endregion Error
+
+        #region Fatal
+        /// <summary>
+        /// Fatal Type Test
+        /// </summary>
+        [TestMethod]
+        public void TestFatalType()
+        {
+            var logger = new VerboseDiagnosticsLogger("VerboseDiagnosticsLoggerTest");
+
+            logger.Fatal("dummy");
+
+            StringAssert.Contains(
+                this.lastLogMessage,
+                "Fatal",
+                "last log message must contain \"Fatal\"");
+        }
+
+        /// <summary>
+        /// Fatal Log Message Test
+        /// </summary>
+        [TestMethod]
+        public void TestFatalMessage()
+        {
+            var logger = new VerboseDiagnosticsLogger("VerboseDiagnosticsLoggerTest");
+
+            logger.Fatal("this is a test");
+
+            StringAssert.Contains(
+                this.lastLogMessage,
+                "this is a test",
+                "last log message must contain \"this is a test \"");
+        }
+
+        /// <summary>
+        /// Fatal Log Message with Parameter (formatted string) Test
+        /// </summary>
+        [TestMethod]
+        public void TestFatalMessageWithParam()
+        {
+            var logger = new VerboseDiagnosticsLogger("VerboseDiagnosticsLoggerTest");
+
+            logger.Fatal("{0} {1} {2} {3}", "this", "is", "a", "test");
+
+            StringAssert.Contains(
+                this.lastLogMessage,
+                "this is a test",
+                "last log message must contain \"this is a test\"");
+        }
+
+        /// <summary>
+        /// Fatal Log with Exception Test
+        /// </summary>
+        [TestMethod]
+        public void TestFatalException()
+        {
+            var logger = new VerboseDiagnosticsLogger("VerboseDiagnosticsLoggerTest");
+
+            logger.Fatal(new Exception("oops something went wrong!"), "dummy");
+
+            StringAssert.Contains(
+                this.lastLogMessage,
+                "oops something went wrong!",
+                "last log message must contain \"oops something went wrong!\"");
+        }
+
+        /// <summary>
+        /// Fatal Log Message with Exception Test
+        /// </summary>
+        [TestMethod]
+        public void TestFatalExceptionMessage()
+        {
+            var logger = new VerboseDiagnosticsLogger("VerboseDiagnosticsLoggerTest");
+
+            logger.Fatal(new Exception("oops something went wrong!"), "this is a test");
+
+            StringAssert.Contains(
+                this.lastLogMessage,
+                "this is a test",
+                "last log message must contain \"this is a test\"");
+        }
+
+        /// <summary>
+        /// Fatal Log Message with Parameter (formatted string) and Exception Test
+        /// </summary>
+        [TestMethod]
+        public void TestFatalExceptionMessageWithParam()
+        {
+            var logger = new VerboseDiagnosticsLogger("VerboseDiagnosticsLoggerTest");
+
+            logger.Fatal(new Exception("oops something went wrong!"), "{0} {1} {2} {3}", "this", "is", "a", "test");
+
+            StringAssert.Contains(
+                this.lastLogMessage,
+                "this is a test",
+                "last log message must contain \"this is a test\"");
+        }
+        #endregion Fatal
+
+        #region System.Diagnostics.TraceListener Members
+        /// <summary>
+        /// When overridden in a derived class, writes the specified message to the listener you
+        /// create in the derived class.
+        /// </summary>
+        /// <param name="message">
+        /// A message to write.
+        /// </param>
+        public override void Write(string message)
+        {
+            this.lastLogMessage = message;
+        }
+
+        /// <summary>
+        /// When overridden in a derived class, writes a message to the listener you
+        /// create in the derived class, followed by a line terminator.
+        /// </summary>
+        /// <param name="message">
+        /// A message to write.
+        /// </param>
+        public override void WriteLine(string message)
+        {
+            this.lastLogMessage = message;
+        }
+        #endregion System.Diagnostics.TraceListener Members
+    }
+}
diff --git a/AltBeacon.LibraryTest/src/AltBeacon/Logging/WarningDiagnosticsLoggerFactoryTest.cs b/AltBeacon.LibraryTest/src/AltBeacon/Logging/WarningDiagnosticsLoggerFactoryTest.cs
new file mode 100644
index 0000000..0e00dc2
--- /dev/null
+++ b/AltBeacon.LibraryTest/src/AltBeacon/Logging/WarningDiagnosticsLoggerFactoryTest.cs
@@ -0,0 +1,82 @@
+// <copyright file="WarningDiagnosticsLoggerFactoryTest.cs" company="Radius Networks, Inc.">
+//     Copyright (c) Radius Networks, Inc.
+//     http://www.radiusnetworks.com
+// </copyright>
+// 
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements. See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership. The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License. You may obtain a copy of the License at
+// 
+// http://www.apache.org/licenses/LICENSE-2.0
+// 
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations
+// under the License.
+namespace AltBeacon.Logging
+{
+    using System;
+    using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+    /// <summary>
+    /// <see cref="AltBeacon.Logging.WarningDiagnosticsLoggerFactory"/> test class.
+    /// </summary>
+    [TestClass]
+    public class WarningDiagnosticsLoggerFactoryTest
+    {
+        #region Logger Name
+        /// <summary>
+        /// Logger Name Test
+        /// </summary>
+        [TestMethod]
+        public void TestLoggerName()
+        {
+            var logger = new WarningDiagnosticsLoggerFactory().GetLogger("WarningDiagnosticsLoggerFactoryTest");
+
+            Assert.AreEqual(
+                "WarningDiagnosticsLoggerFactoryTest",
+                logger.Name,
+                "Logger name should be set to WarningDiagnosticsLoggerFactoryTest");
+        }
+        #endregion Logger Name
+
+        #region Logger Type
+        /// <summary>
+        /// Logger Type Test
+        /// </summary>
+        [TestMethod]
+        public void TestLoggerType()
+        {
+            var logger = new WarningDiagnosticsLoggerFactory().GetLogger("WarningDiagnosticsLoggerFactoryTest");
+
+            Assert.IsInstanceOfType(
+                logger,
+                typeof(WarningDiagnosticsLogger),
+                "WarningDiagnosticsLoggerFactory.GetLogger method must give WarningDiagnosticsLogger objects");
+        }
+        #endregion Logger Type
+
+        #region Logger Reference (Two Logger Same Name)
+        /// <summary>
+        /// Logger Reference Test (Two Logger Same Name)
+        /// </summary>
+        [TestMethod]
+        public void TestTwoLoggerWithSameName()
+        {
+            var logger1 = new WarningDiagnosticsLoggerFactory().GetLogger("WarningDiagnosticsLoggerFactoryTest");
+            var logger2 = new WarningDiagnosticsLoggerFactory().GetLogger("WarningDiagnosticsLoggerFactoryTest");
+
+            Assert.AreNotSame(
+                logger1,
+                logger2,
+                "When getting logger with same name twice, different logger should be returned");
+        }
+        #endregion Logger Reference (Two Logger Same Name)
+    }
+}
diff --git a/AltBeacon.LibraryTest/src/AltBeacon/Logging/WarningDiagnosticsLoggerTest.cs b/AltBeacon.LibraryTest/src/AltBeacon/Logging/WarningDiagnosticsLoggerTest.cs
new file mode 100644
index 0000000..63975d9
--- /dev/null
+++ b/AltBeacon.LibraryTest/src/AltBeacon/Logging/WarningDiagnosticsLoggerTest.cs
@@ -0,0 +1,766 @@
+// <copyright file="WarningDiagnosticsLoggerTest.cs" company="Radius Networks, Inc.">
+//     Copyright (c) Radius Networks, Inc.
+//     http://www.radiusnetworks.com
+// </copyright>
+// 
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements. See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership. The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License. You may obtain a copy of the License at
+// 
+// http://www.apache.org/licenses/LICENSE-2.0
+// 
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations
+// under the License.
+namespace AltBeacon.Logging
+{
+    using System;
+    using Microsoft.VisualStudio.TestTools.UnitTesting;
+    
+    /// <summary>
+    /// <see cref="AltBeacon.Logging.WarningDiagnosticsLogger"/> test class.
+    /// </summary>
+    [TestClass]
+    public class WarningDiagnosticsLoggerTest : System.Diagnostics.TraceListener
+    {
+        #region Fields
+        /// <summary>
+        /// Last log message
+        /// </summary>
+        private string lastLogMessage;
+        #endregion Fields
+
+        #region Each Test Initialization and Cleanup
+        /// <summary>
+        /// Test initialize method which runs before each test.
+        /// </summary>
+        [TestInitialize]
+        public void TestInitializeMethod()
+        {
+            System.Diagnostics.Debug.Listeners.Add(this);
+            this.lastLogMessage = null;
+        }
+
+        /// <summary>
+        /// Test cleanup method which runs after each test.
+        /// </summary>
+        [TestCleanup]
+        public void TestCleanupMethod()
+        {
+            System.Diagnostics.Debug.Listeners.Remove(this);
+            this.lastLogMessage = null;
+        }
+        #endregion Each Test Initialization and Cleanup
+
+        #region Logger Name
+        /// <summary>
+        /// Logger Name Test
+        /// </summary>
+        [TestMethod]
+        public void TestLoggerName()
+        {
+            var logger = new WarningDiagnosticsLogger("WarningDiagnosticsLoggerTest");
+
+            Assert.AreEqual(
+                "WarningDiagnosticsLoggerTest",
+                logger.Name,
+                "Logger name should be set to WarningDiagnosticsLoggerTest");
+        }
+        #endregion Logger Name
+
+        #region Verbose
+        /// <summary>
+        /// Verbose Type Test
+        /// </summary>
+        [TestMethod]
+        public void TestVerboseType()
+        {
+            var logger = new WarningDiagnosticsLogger("WarningDiagnosticsLoggerTest");
+
+            logger.Verbose("dummy");
+
+            Assert.IsNull(
+                this.lastLogMessage,
+                "last log message must be null for \"Verbose\"");
+        }
+
+        /// <summary>
+        /// Verbose Log Message Test
+        /// </summary>
+        [TestMethod]
+        public void TestVerboseMessage()
+        {
+            var logger = new WarningDiagnosticsLogger("WarningDiagnosticsLoggerTest");
+
+            logger.Verbose("this is a test");
+
+            Assert.IsNull(
+                this.lastLogMessage,
+                "last log message must be null for \"Verbose\"");
+        }
+
+        /// <summary>
+        /// Verbose Log Message with Parameter (formatted string) Test
+        /// </summary>
+        [TestMethod]
+        public void TestVerboseMessageWithParam()
+        {
+            var logger = new WarningDiagnosticsLogger("WarningDiagnosticsLoggerTest");
+
+            logger.Verbose("{0} {1} {2} {3}", "this", "is", "a", "test");
+
+            Assert.IsNull(
+                this.lastLogMessage,
+                "last log message must be null for \"Verbose\"");
+        }
+
+        /// <summary>
+        /// Verbose Log with Exception Test
+        /// </summary>
+        [TestMethod]
+        public void TestVerboseException()
+        {
+            var logger = new WarningDiagnosticsLogger("WarningDiagnosticsLoggerTest");
+
+            logger.Verbose(new Exception("oops something went wrong!"), "dummy");
+
+            Assert.IsNull(
+                this.lastLogMessage,
+                "last log message must be null for \"Verbose\"");
+        }
+
+        /// <summary>
+        /// Verbose Log Message with Exception Test
+        /// </summary>
+        [TestMethod]
+        public void TestVerboseExceptionMessage()
+        {
+            var logger = new WarningDiagnosticsLogger("WarningDiagnosticsLoggerTest");
+
+            logger.Verbose(new Exception("oops something went wrong!"), "this is a test");
+
+            Assert.IsNull(
+                this.lastLogMessage,
+                "last log message must be null for \"Verbose\"");
+        }
+
+        /// <summary>
+        /// Verbose Log Message with Parameter (formatted string) and Exception Test
+        /// </summary>
+        [TestMethod]
+        public void TestVerboseExceptionMessageWithParam()
+        {
+            var logger = new WarningDiagnosticsLogger("WarningDiagnosticsLoggerTest");
+
+            logger.Verbose(new Exception("oops something went wrong!"), "{0} {1} {2} {3}", "this", "is", "a", "test");
+
+            Assert.IsNull(
+                this.lastLogMessage,
+                "last log message must be null for \"Verbose\"");
+        }
+        #endregion Verbose
+
+        #region Trace
+        /// <summary>
+        /// Trace Type Test
+        /// </summary>
+        [TestMethod]
+        public void TestTraceType()
+        {
+            var logger = new WarningDiagnosticsLogger("WarningDiagnosticsLoggerTest");
+
+            logger.Trace("dummy");
+
+            Assert.IsNull(
+                this.lastLogMessage,
+                "last log message must be null for \"Trace\"");
+        }
+
+        /// <summary>
+        /// Trace Log Message Test
+        /// </summary>
+        [TestMethod]
+        public void TestTraceMessage()
+        {
+            var logger = new WarningDiagnosticsLogger("WarningDiagnosticsLoggerTest");
+
+            logger.Trace("this is a test");
+
+            Assert.IsNull(
+                this.lastLogMessage,
+                "last log message must be null for \"Trace\"");
+        }
+
+        /// <summary>
+        /// Trace Log Message with Parameter (formatted string) Test
+        /// </summary>
+        [TestMethod]
+        public void TestTraceMessageWithParam()
+        {
+            var logger = new WarningDiagnosticsLogger("WarningDiagnosticsLoggerTest");
+
+            logger.Trace("{0} {1} {2} {3}", "this", "is", "a", "test");
+
+            Assert.IsNull(
+                this.lastLogMessage,
+                "last log message must be null for \"Trace\"");
+        }
+
+        /// <summary>
+        /// Trace Log with Exception Test
+        /// </summary>
+        [TestMethod]
+        public void TestTraceException()
+        {
+            var logger = new WarningDiagnosticsLogger("WarningDiagnosticsLoggerTest");
+
+            logger.Trace(new Exception("oops something went wrong!"), "dummy");
+
+            Assert.IsNull(
+                this.lastLogMessage,
+                "last log message must be null for \"Trace\"");
+        }
+
+        /// <summary>
+        /// Trace Log Message with Exception Test
+        /// </summary>
+        [TestMethod]
+        public void TestTraceExceptionMessage()
+        {
+            var logger = new WarningDiagnosticsLogger("WarningDiagnosticsLoggerTest");
+
+            logger.Trace(new Exception("oops something went wrong!"), "this is a test");
+
+            Assert.IsNull(
+                this.lastLogMessage,
+                "last log message must be null for \"Trace\"");
+        }
+
+        /// <summary>
+        /// Trace Log Message with Parameter (formatted string) and Exception Test
+        /// </summary>
+        [TestMethod]
+        public void TestTraceExceptionMessageWithParam()
+        {
+            var logger = new WarningDiagnosticsLogger("WarningDiagnosticsLoggerTest");
+
+            logger.Trace(new Exception("oops something went wrong!"), "{0} {1} {2} {3}", "this", "is", "a", "test");
+
+            Assert.IsNull(
+                this.lastLogMessage,
+                "last log message must be null for \"Trace\"");
+        }
+        #endregion Trace
+
+        #region Debug
+        /// <summary>
+        /// Debug Type Test
+        /// </summary>
+        [TestMethod]
+        public void TestDebugType()
+        {
+            var logger = new WarningDiagnosticsLogger("WarningDiagnosticsLoggerTest");
+
+            logger.Debug("dummy");
+
+            Assert.IsNull(
+                this.lastLogMessage,
+                "last log message must be null for \"Debug\"");
+        }
+
+        /// <summary>
+        /// Debug Log Message Test
+        /// </summary>
+        [TestMethod]
+        public void TestDebugMessage()
+        {
+            var logger = new WarningDiagnosticsLogger("WarningDiagnosticsLoggerTest");
+
+            logger.Debug("this is a test");
+
+            Assert.IsNull(
+                this.lastLogMessage,
+                "last log message must be null for \"Debug\"");
+        }
+
+        /// <summary>
+        /// Debug Log Message with Parameter (formatted string) Test
+        /// </summary>
+        [TestMethod]
+        public void TestDebugMessageWithParam()
+        {
+            var logger = new WarningDiagnosticsLogger("WarningDiagnosticsLoggerTest");
+
+            logger.Debug("{0} {1} {2} {3}", "this", "is", "a", "test");
+
+            Assert.IsNull(
+                this.lastLogMessage,
+                "last log message must be null for \"Debug\"");
+        }
+
+        /// <summary>
+        /// Debug Log with Exception Test
+        /// </summary>
+        [TestMethod]
+        public void TestDebugException()
+        {
+            var logger = new WarningDiagnosticsLogger("WarningDiagnosticsLoggerTest");
+
+            logger.Debug(new Exception("oops something went wrong!"), "dummy");
+
+            Assert.IsNull(
+                this.lastLogMessage,
+                "last log message must be null for \"Debug\"");
+        }
+
+        /// <summary>
+        /// Debug Log Message with Exception Test
+        /// </summary>
+        [TestMethod]
+        public void TestDebugExceptionMessage()
+        {
+            var logger = new WarningDiagnosticsLogger("WarningDiagnosticsLoggerTest");
+
+            logger.Debug(new Exception("oops something went wrong!"), "this is a test");
+
+            Assert.IsNull(
+                this.lastLogMessage,
+                "last log message must be null for \"Debug\"");
+        }
+
+        /// <summary>
+        /// Debug Log Message with Parameter (formatted string) and Exception Test
+        /// </summary>
+        [TestMethod]
+        public void TestDebugExceptionMessageWithParam()
+        {
+            var logger = new WarningDiagnosticsLogger("WarningDiagnosticsLoggerTest");
+
+            logger.Debug(new Exception("oops something went wrong!"), "{0} {1} {2} {3}", "this", "is", "a", "test");
+
+            Assert.IsNull(
+                this.lastLogMessage,
+                "last log message must be null for \"Debug\"");
+        }
+        #endregion Debug
+
+        #region Info
+        /// <summary>
+        /// Info Type Test
+        /// </summary>
+        [TestMethod]
+        public void TestInfoType()
+        {
+            var logger = new WarningDiagnosticsLogger("WarningDiagnosticsLoggerTest");
+
+            logger.Info("dummy");
+
+            Assert.IsNull(
+                this.lastLogMessage,
+                "last log message must be null for \"Info\"");
+        }
+
+        /// <summary>
+        /// Info Log Message Test
+        /// </summary>
+        [TestMethod]
+        public void TestInfoMessage()
+        {
+            var logger = new WarningDiagnosticsLogger("WarningDiagnosticsLoggerTest");
+
+            logger.Info("this is a test");
+
+            Assert.IsNull(
+                this.lastLogMessage,
+                "last log message must be null for \"Info\"");
+        }
+
+        /// <summary>
+        /// Info Log Message with Parameter (formatted string) Test
+        /// </summary>
+        [TestMethod]
+        public void TestInfoMessageWithParam()
+        {
+            var logger = new WarningDiagnosticsLogger("WarningDiagnosticsLoggerTest");
+
+            logger.Info("{0} {1} {2} {3}", "this", "is", "a", "test");
+
+            Assert.IsNull(
+                this.lastLogMessage,
+                "last log message must be null for \"Info\"");
+        }
+
+        /// <summary>
+        /// Info Log with Exception Test
+        /// </summary>
+        [TestMethod]
+        public void TestInfoException()
+        {
+            var logger = new WarningDiagnosticsLogger("WarningDiagnosticsLoggerTest");
+
+            logger.Info(new Exception("oops something went wrong!"), "dummy");
+
+            Assert.IsNull(
+                this.lastLogMessage,
+                "last log message must be null for \"Info\"");
+        }
+
+        /// <summary>
+        /// Info Log Message with Exception Test
+        /// </summary>
+        [TestMethod]
+        public void TestInfoExceptionMessage()
+        {
+            var logger = new WarningDiagnosticsLogger("WarningDiagnosticsLoggerTest");
+
+            logger.Info(new Exception("oops something went wrong!"), "this is a test");
+
+            Assert.IsNull(
+                this.lastLogMessage,
+                "last log message must be null for \"Info\"");
+        }
+
+        /// <summary>
+        /// Info Log Message with Parameter (formatted string) and Exception Test
+        /// </summary>
+        [TestMethod]
+        public void TestInfoExceptionMessageWithParam()
+        {
+            var logger = new WarningDiagnosticsLogger("WarningDiagnosticsLoggerTest");
+
+            logger.Info(new Exception("oops something went wrong!"), "{0} {1} {2} {3}", "this", "is", "a", "test");
+
+            Assert.IsNull(
+                this.lastLogMessage,
+                "last log message must be null for \"Info\"");
+        }
+        #endregion Info
+
+        #region Warn
+        /// <summary>
+        /// Warn Type Test
+        /// </summary>
+        [TestMethod]
+        public void TestWarnType()
+        {
+            var logger = new WarningDiagnosticsLogger("WarningDiagnosticsLoggerTest");
+
+            logger.Warn("dummy");
+
+            StringAssert.Contains(
+                this.lastLogMessage,
+                "Warn",
+                "last log message must contain \"Warn\"");
+        }
+
+        /// <summary>
+        /// Warn Log Message Test
+        /// </summary>
+        [TestMethod]
+        public void TestWarnMessage()
+        {
+            var logger = new WarningDiagnosticsLogger("WarningDiagnosticsLoggerTest");
+
+            logger.Warn("this is a test");
+
+            StringAssert.Contains(
+                this.lastLogMessage,
+                "this is a test",
+                "last log message must contain \"this is a test \"");
+        }
+
+        /// <summary>
+        /// Warn Log Message with Parameter (formatted string) Test
+        /// </summary>
+        [TestMethod]
+        public void TestWarnMessageWithParam()
+        {
+            var logger = new WarningDiagnosticsLogger("WarningDiagnosticsLoggerTest");
+
+            logger.Warn("{0} {1} {2} {3}", "this", "is", "a", "test");
+
+            StringAssert.Contains(
+                this.lastLogMessage,
+                "this is a test",
+                "last log message must contain \"this is a test\"");
+        }
+
+        /// <summary>
+        /// Warn Log with Exception Test
+        /// </summary>
+        [TestMethod]
+        public void TestWarnException()
+        {
+            var logger = new WarningDiagnosticsLogger("WarningDiagnosticsLoggerTest");
+
+            logger.Warn(new Exception("oops something went wrong!"), "dummy");
+
+            StringAssert.Contains(
+                this.lastLogMessage,
+                "oops something went wrong!",
+                "last log message must contain \"oops something went wrong!\"");
+        }
+
+        /// <summary>
+        /// Warn Log Message with Exception Test
+        /// </summary>
+        [TestMethod]
+        public void TestWarnExceptionMessage()
+        {
+            var logger = new WarningDiagnosticsLogger("WarningDiagnosticsLoggerTest");
+
+            logger.Warn(new Exception("oops something went wrong!"), "this is a test");
+
+            StringAssert.Contains(
+                this.lastLogMessage,
+                "this is a test",
+                "last log message must contain \"this is a test\"");
+        }
+
+        /// <summary>
+        /// Warn Log Message with Parameter (formatted string) and Exception Test
+        /// </summary>
+        [TestMethod]
+        public void TestWarnExceptionMessageWithParam()
+        {
+            var logger = new WarningDiagnosticsLogger("WarningDiagnosticsLoggerTest");
+
+            logger.Warn(new Exception("oops something went wrong!"), "{0} {1} {2} {3}", "this", "is", "a", "test");
+
+            StringAssert.Contains(
+                this.lastLogMessage,
+                "this is a test",
+                "last log message must contain \"this is a test\"");
+        }
+        #endregion Warn
+
+        #region Error
+        /// <summary>
+        /// Error Type Test
+        /// </summary>
+        [TestMethod]
+        public void TestErrorType()
+        {
+            var logger = new WarningDiagnosticsLogger("WarningDiagnosticsLoggerTest");
+
+            logger.Error("dummy");
+
+            StringAssert.Contains(
+                this.lastLogMessage,
+                "Error",
+                "last log message must contain \"Error\"");
+        }
+
+        /// <summary>
+        /// Error Log Message Test
+        /// </summary>
+        [TestMethod]
+        public void TestErrorMessage()
+        {
+            var logger = new WarningDiagnosticsLogger("WarningDiagnosticsLoggerTest");
+
+            logger.Error("this is a test");
+
+            StringAssert.Contains(
+                this.lastLogMessage,
+                "this is a test",
+                "last log message must contain \"this is a test \"");
+        }
+
+        /// <summary>
+        /// Error Log Message with Parameter (formatted string) Test
+        /// </summary>
+        [TestMethod]
+        public void TestErrorMessageWithParam()
+        {
+            var logger = new WarningDiagnosticsLogger("WarningDiagnosticsLoggerTest");
+
+            logger.Error("{0} {1} {2} {3}", "this", "is", "a", "test");
+
+            StringAssert.Contains(
+                this.lastLogMessage,
+                "this is a test",
+                "last log message must contain \"this is a test\"");
+        }
+
+        /// <summary>
+        /// Error Log with Exception Test
+        /// </summary>
+        [TestMethod]
+        public void TestErrorException()
+        {
+            var logger = new WarningDiagnosticsLogger("WarningDiagnosticsLoggerTest");
+
+            logger.Error(new Exception("oops something went wrong!"), "dummy");
+
+            StringAssert.Contains(
+                this.lastLogMessage,
+                "oops something went wrong!",
+                "last log message must contain \"oops something went wrong!\"");
+        }
+
+        /// <summary>
+        /// Error Log Message with Exception Test
+        /// </summary>
+        [TestMethod]
+        public void TestErrorExceptionMessage()
+        {
+            var logger = new WarningDiagnosticsLogger("WarningDiagnosticsLoggerTest");
+
+            logger.Error(new Exception("oops something went wrong!"), "this is a test");
+
+            StringAssert.Contains(
+                this.lastLogMessage,
+                "this is a test",
+                "last log message must contain \"this is a test\"");
+        }
+
+        /// <summary>
+        /// Error Log Message with Parameter (formatted string) and Exception Test
+        /// </summary>
+        [TestMethod]
+        public void TestErrorExceptionMessageWithParam()
+        {
+            var logger = new WarningDiagnosticsLogger("WarningDiagnosticsLoggerTest");
+
+            logger.Error(new Exception("oops something went wrong!"), "{0} {1} {2} {3}", "this", "is", "a", "test");
+
+            StringAssert.Contains(
+                this.lastLogMessage,
+                "this is a test",
+                "last log message must contain \"this is a test\"");
+        }
+        #endregion Error
+
+        #region Fatal
+        /// <summary>
+        /// Fatal Type Test
+        /// </summary>
+        [TestMethod]
+        public void TestFatalType()
+        {
+            var logger = new WarningDiagnosticsLogger("WarningDiagnosticsLoggerTest");
+
+            logger.Fatal("dummy");
+
+            StringAssert.Contains(
+                this.lastLogMessage,
+                "Fatal",
+                "last log message must contain \"Fatal\"");
+        }
+
+        /// <summary>
+        /// Fatal Log Message Test
+        /// </summary>
+        [TestMethod]
+        public void TestFatalMessage()
+        {
+            var logger = new WarningDiagnosticsLogger("WarningDiagnosticsLoggerTest");
+
+            logger.Fatal("this is a test");
+
+            StringAssert.Contains(
+                this.lastLogMessage,
+                "this is a test",
+                "last log message must contain \"this is a test \"");
+        }
+
+        /// <summary>
+        /// Fatal Log Message with Parameter (formatted string) Test
+        /// </summary>
+        [TestMethod]
+        public void TestFatalMessageWithParam()
+        {
+            var logger = new WarningDiagnosticsLogger("WarningDiagnosticsLoggerTest");
+
+            logger.Fatal("{0} {1} {2} {3}", "this", "is", "a", "test");
+
+            StringAssert.Contains(
+                this.lastLogMessage,
+                "this is a test",
+                "last log message must contain \"this is a test\"");
+        }
+
+        /// <summary>
+        /// Fatal Log with Exception Test
+        /// </summary>
+        [TestMethod]
+        public void TestFatalException()
+        {
+            var logger = new WarningDiagnosticsLogger("WarningDiagnosticsLoggerTest");
+
+            logger.Fatal(new Exception("oops something went wrong!"), "dummy");
+
+            StringAssert.Contains(
+                this.lastLogMessage,
+                "oops something went wrong!",
+                "last log message must contain \"oops something went wrong!\"");
+        }
+
+        /// <summary>
+        /// Fatal Log Message with Exception Test
+        /// </summary>
+        [TestMethod]
+        public void TestFatalExceptionMessage()
+        {
+            var logger = new WarningDiagnosticsLogger("WarningDiagnosticsLoggerTest");
+
+            logger.Fatal(new Exception("oops something went wrong!"), "this is a test");
+
+            StringAssert.Contains(
+                this.lastLogMessage,
+                "this is a test",
+                "last log message must contain \"this is a test\"");
+        }
+
+        /// <summary>
+        /// Fatal Log Message with Parameter (formatted string) and Exception Test
+        /// </summary>
+        [TestMethod]
+        public void TestFatalExceptionMessageWithParam()
+        {
+            var logger = new WarningDiagnosticsLogger("WarningDiagnosticsLoggerTest");
+
+            logger.Fatal(new Exception("oops something went wrong!"), "{0} {1} {2} {3}", "this", "is", "a", "test");
+
+            StringAssert.Contains(
+                this.lastLogMessage,
+                "this is a test",
+                "last log message must contain \"this is a test\"");
+        }
+        #endregion Fatal
+
+        #region System.Diagnostics.TraceListener Members
+        /// <summary>
+        /// When overridden in a derived class, writes the specified message to the listener you
+        /// create in the derived class.
+        /// </summary>
+        /// <param name="message">
+        /// A message to write.
+        /// </param>
+        public override void Write(string message)
+        {
+            this.lastLogMessage = message;
+        }
+
+        /// <summary>
+        /// When overridden in a derived class, writes a message to the listener you
+        /// create in the derived class, followed by a line terminator.
+        /// </summary>
+        /// <param name="message">
+        /// A message to write.
+        /// </param>
+        public override void WriteLine(string message)
+        {
+            this.lastLogMessage = message;
+        }
+        #endregion System.Diagnostics.TraceListener Members
+    }
+}

From 1ec58d2229d2be88edabe717b6c66e010a6d7a60 Mon Sep 17 00:00:00 2001
From: Furkan VAROL <furkanvarol@hotmail.com>
Date: Thu, 12 Mar 2015 21:40:41 +0200
Subject: [PATCH 7/9] bug fix on WarningDiagnosticsLoggerFactory

---
 .../src/AltBeacon/Logging/WarningDiagnosticsLoggerFactory.cs    | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/AltBeacon.Library/src/AltBeacon/Logging/WarningDiagnosticsLoggerFactory.cs b/AltBeacon.Library/src/AltBeacon/Logging/WarningDiagnosticsLoggerFactory.cs
index 4f8a86d..56d3327 100644
--- a/AltBeacon.Library/src/AltBeacon/Logging/WarningDiagnosticsLoggerFactory.cs
+++ b/AltBeacon.Library/src/AltBeacon/Logging/WarningDiagnosticsLoggerFactory.cs
@@ -40,7 +40,7 @@ public sealed class WarningDiagnosticsLoggerFactory : ILoggerFactory
         /// </returns>
         public ILogger GetLogger(string name)
         {
-            return new VerboseDiagnosticsLogger(name);
+            return new WarningDiagnosticsLogger(name);
         }
     }
 }

From 071e902d52b18b8989bc58beb150e4d79911956b Mon Sep 17 00:00:00 2001
From: Furkan VAROL <furkanvarol@hotmail.com>
Date: Thu, 12 Mar 2015 21:51:44 +0200
Subject: [PATCH 8/9] .Net version has been dropped from 4.5 to 4.0

---
 AltBeacon.Library/AltBeacon.Library.csproj         | 3 ++-
 AltBeacon.LibraryTest/AltBeacon.LibraryTest.csproj | 3 ++-
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/AltBeacon.Library/AltBeacon.Library.csproj b/AltBeacon.Library/AltBeacon.Library.csproj
index da5abce..26f5277 100644
--- a/AltBeacon.Library/AltBeacon.Library.csproj
+++ b/AltBeacon.Library/AltBeacon.Library.csproj
@@ -9,8 +9,9 @@
     <AppDesignerFolder>Properties</AppDesignerFolder>
     <RootNamespace>AltBeacon</RootNamespace>
     <AssemblyName>AltBeacon.Library</AssemblyName>
-    <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
+    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
     <FileAlignment>512</FileAlignment>
+    <TargetFrameworkProfile />
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
     <DebugSymbols>true</DebugSymbols>
diff --git a/AltBeacon.LibraryTest/AltBeacon.LibraryTest.csproj b/AltBeacon.LibraryTest/AltBeacon.LibraryTest.csproj
index df83da0..176ebb3 100644
--- a/AltBeacon.LibraryTest/AltBeacon.LibraryTest.csproj
+++ b/AltBeacon.LibraryTest/AltBeacon.LibraryTest.csproj
@@ -8,7 +8,7 @@
     <AppDesignerFolder>Properties</AppDesignerFolder>
     <RootNamespace>AltBeacon</RootNamespace>
     <AssemblyName>AltBeacon.LibraryTest</AssemblyName>
-    <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
+    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
     <FileAlignment>512</FileAlignment>
     <ProjectTypeGuids>{3AC096D0-A1C2-E12C-1390-A8335801FDAB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
     <VisualStudioVersion Condition="'$(VisualStudioVersion)' == ''">10.0</VisualStudioVersion>
@@ -16,6 +16,7 @@
     <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\$(VisualStudioVersion)\UITestExtensionPackages</ReferencePath>
     <IsCodedUITest>False</IsCodedUITest>
     <TestProjectType>UnitTest</TestProjectType>
+    <TargetFrameworkProfile />
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
     <DebugSymbols>true</DebugSymbols>

From 010943f53a5adf09ab1a6b4625a5e2551b99258a Mon Sep 17 00:00:00 2001
From: Furkan VAROL <furkanvarol@hotmail.com>
Date: Fri, 3 Apr 2015 23:21:10 +0300
Subject: [PATCH 9/9] VerboseLoggingEnabled has been renamed to
 DebugLoggingEnabled Also BeaconParser's debug logs has been encapsulated with
 DebugLoggingEnabled condition

---
 .../src/AltBeacon/Beacon/BeaconParser.cs         | 16 ++++++++--------
 .../src/AltBeacon/Logging/LogManager.cs          | 11 ++++++-----
 .../src/AltBeacon/Logging/LogManagerTest.cs      | 12 ++++++------
 3 files changed, 20 insertions(+), 19 deletions(-)

diff --git a/AltBeacon.Library/src/AltBeacon/Beacon/BeaconParser.cs b/AltBeacon.Library/src/AltBeacon/Beacon/BeaconParser.cs
index 991231f..df57c31 100644
--- a/AltBeacon.Library/src/AltBeacon/Beacon/BeaconParser.cs
+++ b/AltBeacon.Library/src/AltBeacon/Beacon/BeaconParser.cs
@@ -417,7 +417,11 @@ public BeaconParser SetBeaconLayout(string beaconLayout)
 
                 if (!found)
                 {
-                    Logger.Debug("cannot parse term " + term);
+                    if (LogManager.DebugLoggingEnabled)
+                    {
+                        Logger.Debug("cannot parse term " + term);
+                    }
+
                     throw new BeaconLayoutException("Cannot parse beacon layout term: " + term);
                 }
             }
@@ -837,7 +841,7 @@ protected Beacon FromScanData(byte[] scanData, int rssi, BluetoothDevice device,
                 // This is not a beacon
                 if (this.ServiceUuid == null)
                 {
-                    if (LogManager.VerboseLoggingEnabled)
+                    if (LogManager.DebugLoggingEnabled)
                     {
                         Logger.Debug(
                             "This is not a matching Beacon advertisement. " + 
@@ -848,7 +852,7 @@ protected Beacon FromScanData(byte[] scanData, int rssi, BluetoothDevice device,
                 }   
                 else
                 {
-                    if (LogManager.VerboseLoggingEnabled)
+                    if (LogManager.DebugLoggingEnabled)
                     {
                         Logger.Debug(
                             "This is not a matching Beacon advertisement. " + 
@@ -863,16 +867,12 @@ protected Beacon FromScanData(byte[] scanData, int rssi, BluetoothDevice device,
             }
             else
             {
-                if (LogManager.VerboseLoggingEnabled)
+                if (LogManager.DebugLoggingEnabled)
                 {
                     Logger.Debug(
                         "This is a recognized beacon advertisement -- {0} seen",
                         ByteArrayToString(typeCodeBytes));
                 }
-
-                Logger.Debug(
-                    "This is a recognized beacon advertisement -- {0} seen",
-                    this.MatchingBeaconTypeCode.ToString("x4"));
             }
 
             List<Identifier> identifiers = new List<Identifier>();
diff --git a/AltBeacon.Library/src/AltBeacon/Logging/LogManager.cs b/AltBeacon.Library/src/AltBeacon/Logging/LogManager.cs
index 50db179..c1bcda6 100644
--- a/AltBeacon.Library/src/AltBeacon/Logging/LogManager.cs
+++ b/AltBeacon.Library/src/AltBeacon/Logging/LogManager.cs
@@ -65,9 +65,9 @@ public static class LogManager
         private static ILoggerFactory loggerFactory = DefaultLoggerFactory;
 
         /// <summary>
-        /// <see cref="VerboseLoggingEnabled"/>
+        /// <see cref="DebugLoggingEnabled"/>
         /// </summary>
-        private static bool verboseLoggingEnabled = false;
+        private static bool debugLoggingEnabled = false;
         #endregion Private Fields
 
         #region Properties
@@ -99,17 +99,18 @@ public static ILoggerFactory LoggerFactory
         /// <summary>
         /// Gets or sets a value indicating whether verbose logging is enabled.
         /// If not, expensive calculations to create log strings should be avoided.
+        /// This flag is extensively used in BeaconParser.
         /// </summary>
-        public static bool VerboseLoggingEnabled
+        public static bool DebugLoggingEnabled
         {
             get
             {
-                return verboseLoggingEnabled;
+                return debugLoggingEnabled;
             }
 
             set
             {
-                verboseLoggingEnabled = value;
+                debugLoggingEnabled = value;
             }
         }
         #endregion Properties
diff --git a/AltBeacon.LibraryTest/src/AltBeacon/Logging/LogManagerTest.cs b/AltBeacon.LibraryTest/src/AltBeacon/Logging/LogManagerTest.cs
index 40d9b2d..faf56e8 100644
--- a/AltBeacon.LibraryTest/src/AltBeacon/Logging/LogManagerTest.cs
+++ b/AltBeacon.LibraryTest/src/AltBeacon/Logging/LogManagerTest.cs
@@ -33,24 +33,24 @@ public class LogManagerTest
         [TestMethod]
         public void TestVerboseLoggingEnabledTrue()
         {
-            LogManager.VerboseLoggingEnabled = false;
-            LogManager.VerboseLoggingEnabled = true;
+            LogManager.DebugLoggingEnabled = false;
+            LogManager.DebugLoggingEnabled = true;
 
             Assert.AreEqual(
                 true, 
-                LogManager.VerboseLoggingEnabled, 
+                LogManager.DebugLoggingEnabled, 
                 "VerboseLoggingEnabled should be set to true");
         }
 
         [TestMethod]
         public void TestVerboseLoggingEnabledFalse()
         {
-            LogManager.VerboseLoggingEnabled = true;
-            LogManager.VerboseLoggingEnabled = false;
+            LogManager.DebugLoggingEnabled = true;
+            LogManager.DebugLoggingEnabled = false;
 
             Assert.AreEqual(
                 false, 
-                LogManager.VerboseLoggingEnabled, 
+                LogManager.DebugLoggingEnabled, 
                 "VerboseLoggingEnabled should be set to false");
         }