diff --git a/dotnet/src/support/Events/EventFiringWebDriver.cs b/dotnet/src/support/Events/EventFiringWebDriver.cs
index ac428cf2830b5..77a3b5f3b50a5 100644
--- a/dotnet/src/support/Events/EventFiringWebDriver.cs
+++ b/dotnet/src/support/Events/EventFiringWebDriver.cs
@@ -20,6 +20,7 @@
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Drawing;
+using System.Threading.Tasks;
 
 namespace OpenQA.Selenium.Support.Events
 {
@@ -845,12 +846,24 @@ public EventFiringNavigation(EventFiringWebDriver driver)
             /// Move the browser back
             /// </summary>
             public void Back()
+            {
+                Task.Run(async delegate
+                {
+                    await this.BackAsync();
+                }).GetAwaiter().GetResult();
+            }
+
+            /// <summary>
+            /// Move the browser back as an asynchronous task.
+            /// </summary>
+            /// <returns>A task object representing the asynchronous operation</returns>
+            public async Task BackAsync()
             {
                 try
                 {
                     WebDriverNavigationEventArgs e = new WebDriverNavigationEventArgs(this.parentDriver);
                     this.parentDriver.OnNavigatingBack(e);
-                    this.wrappedNavigation.Back();
+                    await this.wrappedNavigation.BackAsync().ConfigureAwait(false);
                     this.parentDriver.OnNavigatedBack(e);
                 }
                 catch (Exception ex)
@@ -861,15 +874,27 @@ public void Back()
             }
 
             /// <summary>
-            /// Move the browser forward
+            /// Move a single "item" forward in the browser's history.
             /// </summary>
             public void Forward()
+            {
+                Task.Run(async delegate
+                {
+                    await this.ForwardAsync();
+                }).GetAwaiter().GetResult();
+            }
+
+            /// <summary>
+            /// Move a single "item" forward in the browser's history as an asynchronous task.
+            /// </summary>
+            /// <returns>A task object representing the asynchronous operation.</returns>
+            public async Task ForwardAsync()
             {
                 try
                 {
                     WebDriverNavigationEventArgs e = new WebDriverNavigationEventArgs(this.parentDriver);
                     this.parentDriver.OnNavigatingForward(e);
-                    this.wrappedNavigation.Forward();
+                    await this.wrappedNavigation.ForwardAsync().ConfigureAwait(false);
                     this.parentDriver.OnNavigatedForward(e);
                 }
                 catch (Exception ex)
@@ -880,16 +905,34 @@ public void Forward()
             }
 
             /// <summary>
-            /// Navigate to a url for your test
+            /// Navigate to a url.
             /// </summary>
             /// <param name="url">String of where you want the browser to go to</param>
             public void GoToUrl(string url)
             {
+                Task.Run(async delegate
+                {
+                    await this.GoToUrlAsync(url);
+                }).GetAwaiter().GetResult();
+            }
+
+            /// <summary>
+            /// Navigate to a url as an asynchronous task.
+            /// </summary>
+            /// <param name="url">String of where you want the browser to go.</param>
+            /// <returns>A task object representing the asynchronous operation.</returns>
+            public async Task GoToUrlAsync(string url)
+            {
+                if (url == null)
+                {
+                    throw new ArgumentNullException(nameof(url), "url cannot be null");
+                }
+
                 try
                 {
                     WebDriverNavigationEventArgs e = new WebDriverNavigationEventArgs(this.parentDriver, url);
                     this.parentDriver.OnNavigating(e);
-                    this.wrappedNavigation.GoToUrl(url);
+                    await this.wrappedNavigation.GoToUrlAsync(url).ConfigureAwait(false);
                     this.parentDriver.OnNavigated(e);
                 }
                 catch (Exception ex)
@@ -900,38 +943,52 @@ public void GoToUrl(string url)
             }
 
             /// <summary>
-            /// Navigate to a url for your test
+            /// Navigate to a url.
             /// </summary>
             /// <param name="url">Uri object of where you want the browser to go to</param>
             public void GoToUrl(Uri url)
+            {
+                Task.Run(async delegate
+                {
+                    await this.GoToUrlAsync(url);
+                }).GetAwaiter().GetResult();
+            }
+
+            /// <summary>
+            /// Navigate to a url as an asynchronous task.
+            /// </summary>
+            /// <param name="url">Uri object of where you want the browser to go.</param>
+            /// <returns>A task object representing the asynchronous operation.</returns>
+            public async Task GoToUrlAsync(Uri url)
             {
                 if (url == null)
                 {
                     throw new ArgumentNullException(nameof(url), "url cannot be null");
                 }
 
-                try
-                {
-                    WebDriverNavigationEventArgs e = new WebDriverNavigationEventArgs(this.parentDriver, url.ToString());
-                    this.parentDriver.OnNavigating(e);
-                    this.wrappedNavigation.GoToUrl(url);
-                    this.parentDriver.OnNavigated(e);
-                }
-                catch (Exception ex)
-                {
-                    this.parentDriver.OnException(new WebDriverExceptionEventArgs(this.parentDriver, ex));
-                    throw;
-                }
+                await this.GoToUrlAsync(url.ToString()).ConfigureAwait(false);
             }
 
             /// <summary>
-            /// Refresh the browser
+            /// Reload the current page.
             /// </summary>
             public void Refresh()
+            {
+                Task.Run(async delegate
+                {
+                    await this.RefreshAsync();
+                }).GetAwaiter().GetResult();
+            }
+
+            /// <summary>
+            /// Reload the current page as an asynchronous task.
+            /// </summary>
+            /// <returns>A task object representing the asynchronous operation.</returns>
+            public async Task RefreshAsync()
             {
                 try
                 {
-                    this.wrappedNavigation.Refresh();
+                    await this.wrappedNavigation.RefreshAsync().ConfigureAwait(false);
                 }
                 catch (Exception ex)
                 {
diff --git a/dotnet/src/webdriver/ICommandExecutor.cs b/dotnet/src/webdriver/ICommandExecutor.cs
index 68cfe200391f4..3bcfb520166d3 100644
--- a/dotnet/src/webdriver/ICommandExecutor.cs
+++ b/dotnet/src/webdriver/ICommandExecutor.cs
@@ -17,6 +17,7 @@
 // </copyright>
 
 using System;
+using System.Threading.Tasks;
 
 namespace OpenQA.Selenium
 {
@@ -39,5 +40,13 @@ public interface ICommandExecutor : IDisposable
         /// <param name="commandToExecute">The command you wish to execute</param>
         /// <returns>A response from the browser</returns>
         Response Execute(Command commandToExecute);
+
+
+        /// <summary>
+        /// Executes a command as an asynchronous task.
+        /// </summary>
+        /// <param name="commandToExecute">The command you wish to execute</param>
+        /// <returns>A task object representing the asynchronous operation</returns>
+        Task<Response> ExecuteAsync(Command commandToExecute);
     }
 }
diff --git a/dotnet/src/webdriver/INavigation.cs b/dotnet/src/webdriver/INavigation.cs
index bff75d4743e6b..a55b4dfda12bf 100644
--- a/dotnet/src/webdriver/INavigation.cs
+++ b/dotnet/src/webdriver/INavigation.cs
@@ -17,6 +17,7 @@
 // </copyright>
 
 using System;
+using System.Threading.Tasks;
 
 namespace OpenQA.Selenium
 {
@@ -31,12 +32,24 @@ public interface INavigation
         /// </summary>
         void Back();
 
+        /// <summary>
+        /// Move back a single entry in the browser's history as an asynchronous task.
+        /// </summary>
+        /// <returns>A task object representing the asynchronous operation.</returns>
+        Task BackAsync();
+
         /// <summary>
         /// Move a single "item" forward in the browser's history.
         /// </summary>
         /// <remarks>Does nothing if we are on the latest page viewed.</remarks>
         void Forward();
 
+        /// <summary>
+        /// Move a single "item" forward in the browser's history as an asynchronous task.
+        /// </summary>
+        /// <returns>A task object representing the asynchronous operation.</returns>
+        Task ForwardAsync();
+
         /// <summary>
         ///  Load a new web page in the current browser window.
         /// </summary>
@@ -52,6 +65,13 @@ public interface INavigation
         /// </remarks>
         void GoToUrl(string url);
 
+        /// <summary>
+        /// Navigate to a url as an asynchronous task.
+        /// </summary>
+        /// <param name="url">String of where you want the browser to go.</param>
+        /// <returns>A task object representing the asynchronous operation.</returns>
+        Task GoToUrlAsync(string url);
+
         /// <summary>
         ///  Load a new web page in the current browser window.
         /// </summary>
@@ -67,9 +87,22 @@ public interface INavigation
         /// </remarks>
         void GoToUrl(Uri url);
 
+        /// <summary>
+        /// Navigate to a url as an asynchronous task.
+        /// </summary>
+        /// <param name="url">Uri object of where you want the browser to go.</param>
+        /// <returns>A task object representing the asynchronous operation.</returns>
+        Task GoToUrlAsync(Uri url);
+
         /// <summary>
         /// Refreshes the current page.
         /// </summary>
         void Refresh();
+
+        /// <summary>
+        /// Reload the current page as an asynchronous task.
+        /// </summary>
+        /// <returns>A task object representing the asynchronous operation.</returns>
+        Task RefreshAsync();
     }
 }
diff --git a/dotnet/src/webdriver/Navigator.cs b/dotnet/src/webdriver/Navigator.cs
index f8f6047e91f5a..48683a03c9fe1 100644
--- a/dotnet/src/webdriver/Navigator.cs
+++ b/dotnet/src/webdriver/Navigator.cs
@@ -18,6 +18,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Threading.Tasks;
 
 namespace OpenQA.Selenium
 {
@@ -38,26 +39,63 @@ public Navigator(WebDriver driver)
         }
 
         /// <summary>
-        /// Move the browser back
+        /// Move back a single entry in the browser's history.
         /// </summary>
         public void Back()
         {
-            this.driver.InternalExecute(DriverCommand.GoBack, null);
+            Task.Run(async delegate
+            {
+                await this.BackAsync();
+            }).GetAwaiter().GetResult();
+        }
+
+        /// <summary>
+        /// Move back a single entry in the browser's history as an asynchronous task.
+        /// </summary>
+        /// <returns>A task object representing the asynchronous operation.</returns>
+        public async Task BackAsync()
+        {
+            await this.driver.InternalExecuteAsync(DriverCommand.GoBack, null).ConfigureAwait(false);
         }
 
         /// <summary>
-        /// Move the browser forward
+        /// Move a single "item" forward in the browser's history.
         /// </summary>
         public void Forward()
         {
-            this.driver.InternalExecute(DriverCommand.GoForward, null);
+            Task.Run(async delegate
+            {
+                await this.ForwardAsync();
+            }).GetAwaiter().GetResult();
+        }
+
+        /// <summary>
+        /// Move a single "item" forward in the browser's history as an asynchronous task.
+        /// </summary>
+        /// <returns>A task object representing the asynchronous operation.</returns>
+        public async Task ForwardAsync()
+        {
+            await this.driver.InternalExecuteAsync(DriverCommand.GoForward, null).ConfigureAwait(false);
         }
 
         /// <summary>
-        /// Navigate to a url for your test
+        /// Navigate to a url.
         /// </summary>
         /// <param name="url">String of where you want the browser to go to</param>
         public void GoToUrl(string url)
+        {
+            Task.Run(async delegate
+            {
+                await this.GoToUrlAsync(url);
+            }).GetAwaiter().GetResult();
+        }
+
+        /// <summary>
+        /// Navigate to a url as an asynchronous task.
+        /// </summary>
+        /// <param name="url">String of where you want the browser to go.</param>
+        /// <returns>A task object representing the asynchronous operation.</returns>
+        public async Task GoToUrlAsync(string url)
         {
             if (url == null)
             {
@@ -68,31 +106,55 @@ public void GoToUrl(string url)
             {
                 { "url", url }
             };
-            this.driver.InternalExecute(DriverCommand.Get, parameters);
-
+            await this.driver.InternalExecuteAsync(DriverCommand.Get, parameters).ConfigureAwait(false);
         }
 
         /// <summary>
-        /// Navigate to a url for your test
+        /// Navigate to a url.
         /// </summary>
-        /// <param name="url">Uri object of where you want the browser to go to</param>
+        /// <param name="url">Uri object of where you want the browser to go.</param>
         public void GoToUrl(Uri url)
+        {
+            Task.Run(async delegate
+            {
+                await this.GoToUrlAsync(url);
+            }).GetAwaiter().GetResult();
+        }
+
+        /// <summary>
+        /// Navigate to a url as an asynchronous task.
+        /// </summary>
+        /// <param name="url">Uri object of where you want the browser to go.</param>
+        /// <returns>A task object representing the asynchronous operation.</returns>
+        public async Task GoToUrlAsync(Uri url)
         {
             if (url == null)
             {
                 throw new ArgumentNullException(nameof(url), "URL cannot be null.");
             }
 
-            this.GoToUrl(url.ToString());
+            await this.GoToUrlAsync(url.ToString()).ConfigureAwait(false);
         }
 
         /// <summary>
-        /// Refresh the browser
+        /// Reload the current page.
         /// </summary>
         public void Refresh()
+        {
+            Task.Run(async delegate
+            {
+                await this.RefreshAsync();
+            }).GetAwaiter().GetResult();
+        }
+
+        /// <summary>
+        /// Reload the current page as an asynchronous task.
+        /// </summary>
+        /// <returns>A task object representing the asynchronous operation.</returns>
+        public async Task RefreshAsync()
         {
             // driver.SwitchTo().DefaultContent();
-            this.driver.InternalExecute(DriverCommand.Refresh, null);
+            await this.driver.InternalExecuteAsync(DriverCommand.Refresh, null).ConfigureAwait(false);
         }
     }
 }
diff --git a/dotnet/src/webdriver/Remote/DriverServiceCommandExecutor.cs b/dotnet/src/webdriver/Remote/DriverServiceCommandExecutor.cs
index 4b0fcb27ed7fc..1e486ad96f98d 100644
--- a/dotnet/src/webdriver/Remote/DriverServiceCommandExecutor.cs
+++ b/dotnet/src/webdriver/Remote/DriverServiceCommandExecutor.cs
@@ -17,6 +17,7 @@
 // </copyright>
 
 using System;
+using System.Threading.Tasks;
 
 namespace OpenQA.Selenium.Remote
 {
@@ -92,6 +93,16 @@ public HttpCommandExecutor HttpExecutor
         /// <param name="commandToExecute">The command you wish to execute</param>
         /// <returns>A response from the browser</returns>
         public Response Execute(Command commandToExecute)
+        {
+            return Task.Run(() => this.ExecuteAsync(commandToExecute)).GetAwaiter().GetResult();
+        }
+
+        /// <summary>
+        /// Executes a command as an asynchronous task.
+        /// </summary>
+        /// <param name="commandToExecute">The command you wish to execute</param>
+        /// <returns>A task object representing the asynchronous operation</returns>
+        public async Task<Response> ExecuteAsync(Command commandToExecute)
         {
             if (commandToExecute == null)
             {
@@ -108,7 +119,7 @@ public Response Execute(Command commandToExecute)
             // command, so that we can get the finally block.
             try
             {
-                toReturn = this.internalExecutor.Execute(commandToExecute);
+                toReturn = await this.internalExecutor.ExecuteAsync(commandToExecute).ConfigureAwait(false);
             }
             finally
             {
diff --git a/dotnet/src/webdriver/Remote/HttpCommandExecutor.cs b/dotnet/src/webdriver/Remote/HttpCommandExecutor.cs
index 3dbb5e4efd179..1872e418a7888 100644
--- a/dotnet/src/webdriver/Remote/HttpCommandExecutor.cs
+++ b/dotnet/src/webdriver/Remote/HttpCommandExecutor.cs
@@ -158,6 +158,16 @@ public bool TryAddCommand(string commandName, CommandInfo info)
         /// <param name="commandToExecute">The command you wish to execute</param>
         /// <returns>A response from the browser</returns>
         public virtual Response Execute(Command commandToExecute)
+        {
+            return Task.Run(() => this.ExecuteAsync(commandToExecute)).GetAwaiter().GetResult();
+        }
+
+        /// <summary>
+        /// Executes a command as an asynchronous task.
+        /// </summary>
+        /// <param name="commandToExecute">The command you wish to execute</param>
+        /// <returns>A task object representing the asynchronous operation</returns>
+        public virtual async Task<Response> ExecuteAsync(Command commandToExecute)
         {
             if (commandToExecute == null)
             {
@@ -184,7 +194,7 @@ public virtual Response Execute(Command commandToExecute)
             HttpResponseInfo responseInfo = null;
             try
             {
-                responseInfo = Task.Run(async () => await this.MakeHttpRequest(requestInfo)).GetAwaiter().GetResult();
+                responseInfo = await this.MakeHttpRequest(requestInfo).ConfigureAwait(false);
             }
             catch (HttpRequestException ex)
             {
diff --git a/dotnet/src/webdriver/WebDriver.cs b/dotnet/src/webdriver/WebDriver.cs
index 3de43e25c452f..d063e8f5905ea 100644
--- a/dotnet/src/webdriver/WebDriver.cs
+++ b/dotnet/src/webdriver/WebDriver.cs
@@ -24,6 +24,7 @@
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Globalization;
+using System.Threading.Tasks;
 
 namespace OpenQA.Selenium
 {
@@ -556,7 +557,25 @@ internal ReadOnlyCollection<IWebElement> GetElementsFromResponse(Response respon
         /// <returns>WebDriver Response</returns>
         internal Response InternalExecute(string driverCommandToExecute, Dictionary<string, object> parameters)
         {
-            return this.Execute(driverCommandToExecute, parameters);
+            return Task.Run(() => this.InternalExecuteAsync(driverCommandToExecute, parameters)).GetAwaiter().GetResult();
+        }
+
+        /// <summary>
+        /// Executes commands with the driver asynchronously
+        /// </summary>
+        /// <param name="driverCommandToExecute">Command that needs executing</param>
+        /// <param name="parameters">Parameters needed for the command</param>
+        /// <returns>A task object representing the asynchronous operation</returns>
+        internal Task<Response> InternalExecuteAsync(string driverCommandToExecute,
+            Dictionary<string, object> parameters)
+        {
+            return this.ExecuteAsync(driverCommandToExecute, parameters);
+        }
+
+        internal Response Execute(string driverCommandToExecute,
+            Dictionary<string, object> parameters)
+        {
+            return Task.Run(() => this.ExecuteAsync(driverCommandToExecute, parameters)).GetAwaiter().GetResult();
         }
 
         /// <summary>
@@ -565,7 +584,7 @@ internal Response InternalExecute(string driverCommandToExecute, Dictionary<stri
         /// <param name="driverCommandToExecute">A <see cref="DriverCommand"/> value representing the command to execute.</param>
         /// <param name="parameters">A <see cref="Dictionary{K, V}"/> containing the names and values of the parameters of the command.</param>
         /// <returns>A <see cref="Response"/> containing information about the success or failure of the command and any data returned by the command.</returns>
-        protected virtual Response Execute(string driverCommandToExecute, Dictionary<string, object> parameters)
+        protected virtual async Task<Response> ExecuteAsync(string driverCommandToExecute, Dictionary<string, object> parameters)
         {
             Command commandToExecute = new Command(this.sessionId, driverCommandToExecute, parameters);
 
@@ -573,7 +592,7 @@ protected virtual Response Execute(string driverCommandToExecute, Dictionary<str
 
             try
             {
-                commandResponse = this.executor.Execute(commandToExecute);
+                commandResponse = await this.executor.ExecuteAsync(commandToExecute).ConfigureAwait(false);
             }
             catch (System.Net.Http.HttpRequestException e)
             {
diff --git a/dotnet/test/common/NavigationTest.cs b/dotnet/test/common/NavigationTest.cs
index ee40894aa047c..e1b514bf04cb9 100644
--- a/dotnet/test/common/NavigationTest.cs
+++ b/dotnet/test/common/NavigationTest.cs
@@ -1,5 +1,6 @@
 using NUnit.Framework;
 using System;
+using System.Threading.Tasks;
 
 namespace OpenQA.Selenium
 {
@@ -40,7 +41,7 @@ public void ShouldAcceptInvalidUrlsUsingUris()
             INavigation navigation;
             navigation = driver.Navigate();
             Assert.That(() => navigation.GoToUrl((Uri)null), Throws.InstanceOf<ArgumentNullException>());
-            // new Uri("") and new Uri("isidsji30342??éåµñ©æ") 
+            // new Uri("") and new Uri("isidsji30342??éåµñ©æ")
             // throw an exception, so we needn't worry about them.
         }
 
@@ -90,5 +91,73 @@ public void ShouldRefreshPage()
             Assert.AreEqual("What's for dinner?", changedDiv.Text);
         }
 
+        [Test]
+        [NeedsFreshDriver(IsCreatedBeforeTest = true)]
+        public Task ShouldNotHaveProblemNavigatingWithNoPagesBrowsedAsync()
+        {
+            var navigation = driver.Navigate();
+            Assert.DoesNotThrowAsync(async () => await navigation.BackAsync());
+            Assert.DoesNotThrowAsync(async () => await navigation.ForwardAsync());
+            return Task.CompletedTask;
+        }
+
+        [Test]
+        public async Task ShouldGoBackAndForwardAsync()
+        {
+            INavigation navigation = driver.Navigate();
+
+            await navigation.GoToUrlAsync(macbethPage);
+            await navigation.GoToUrlAsync(simpleTestPage);
+
+            await navigation.BackAsync();
+            Assert.AreEqual(macbethTitle, driver.Title);
+
+            await navigation.ForwardAsync();
+            Assert.AreEqual(simpleTestTitle, driver.Title);
+        }
+
+        [Test]
+        public void ShouldAcceptInvalidUrlsUsingUrisAsync()
+        {
+            INavigation navigation = driver.Navigate();
+            Assert.That(async () => await navigation.GoToUrlAsync((Uri)null), Throws.InstanceOf<ArgumentNullException>());
+        }
+
+        [Test]
+        public async Task ShouldGoToUrlUsingStringAsync()
+        {
+            var navigation = driver.Navigate();
+
+            await navigation.GoToUrlAsync(macbethPage);
+            Assert.AreEqual(macbethTitle, driver.Title);
+
+            await navigation.GoToUrlAsync(simpleTestPage);
+            Assert.AreEqual(simpleTestTitle, driver.Title);
+        }
+
+        [Test]
+        public void ShouldGoToUrlUsingUriAsync()
+        {
+            var navigation = driver.Navigate();
+
+            navigation.GoToUrlAsync(new Uri(macbethPage));
+            Assert.AreEqual(driver.Title, macbethTitle);
+            navigation.GoToUrl(new Uri(simpleTestPage));
+            Assert.AreEqual(simpleTestTitle, driver.Title);
+        }
+
+        [Test]
+        public async Task ShouldRefreshPageAsync()
+        {
+            await driver.Navigate().GoToUrlAsync(javascriptPage);
+            IWebElement changedDiv = driver.FindElement(By.Id("dynamo"));
+            driver.FindElement(By.Id("updatediv")).Click();
+
+            Assert.AreEqual("Fish and chips!", changedDiv.Text);
+            await driver.Navigate().RefreshAsync();
+
+            changedDiv = driver.FindElement(By.Id("dynamo"));
+            Assert.AreEqual("What's for dinner?", changedDiv.Text);
+        }
     }
 }
diff --git a/dotnet/test/support/Events/EventFiringWebDriverTest.cs b/dotnet/test/support/Events/EventFiringWebDriverTest.cs
index 972be725adfa9..3d59f056f3ee8 100644
--- a/dotnet/test/support/Events/EventFiringWebDriverTest.cs
+++ b/dotnet/test/support/Events/EventFiringWebDriverTest.cs
@@ -58,12 +58,15 @@ Navigated back
 Navigating forward
 Navigated forward
 ";
+            string normalizedExpectedLog = expectedLog.Replace("\r\n", "\n").Replace("\r", "\n");
             mockDriver.VerifySet(x => x.Url = "http://www.get.com", Times.Once);
             mockDriver.Verify(x => x.Navigate(), Times.Exactly(3));
-            mockNavigation.Verify(x => x.GoToUrl("http://www.navigate-to.com"), Times.Once);
-            mockNavigation.Verify(x => x.Back(), Times.Once);
-            mockNavigation.Verify(x => x.Forward(), Times.Once);
-            Assert.AreEqual(expectedLog, log.ToString());
+            mockNavigation.Verify(x => x.GoToUrlAsync("http://www.navigate-to.com"), Times.Once);
+            mockNavigation.Verify(x => x.BackAsync(), Times.Once);
+            mockNavigation.Verify(x => x.ForwardAsync(), Times.Once);
+
+            string normalizedActualLog =  log.ToString().Replace("\r\n", "\n").Replace("\r", "\n");
+            Assert.AreEqual(normalizedExpectedLog, normalizedActualLog);
         }
 
         [Test]