Merge branch 'wozzo-GH-2005' into develop

* wozzo-GH-2005:
  (GH-2005) Add setup and teardown to report if run. * fixes #2005

src/Cake.Core.Tests/Unit/CakeEngineTests.cs

@@ -977,6 +977,42 @@ public async Task Should_Log_Task_Teardown_Exception_If_Both_Task_And_Task_Teard
                 Assert.Contains(fixture.Log.Entries, x => x.Message.StartsWith("Task Teardown error (A):"));
             }
 
+            [Fact]
+            public async Task Should_Return_Report_That_Contains_Entry_For_Setup_First()
+            {
+                // Given
+                var fixture = new CakeEngineFixture();
+                var engine = fixture.CreateEngine();
+                engine.RegisterSetupAction(x => { });
+                engine.RegisterTask("A");
+
+                // When
+                var report = await engine.RunTargetAsync(fixture.Context, fixture.ExecutionStrategy, "A");
+
+                // Then
+                Assert.Equal(2, report.Count());
+                Assert.Equal("**Setup**", report.ElementAt(0).TaskName);
+                Assert.Equal("A", report.ElementAt(1).TaskName);
+            }
+
+            [Fact]
+            public async Task Should_Return_Report_That_Contains_Entry_For_Teardown_Last()
+            {
+                // Given
+                var fixture = new CakeEngineFixture();
+                var engine = fixture.CreateEngine();
+                engine.RegisterTeardownAction(x => { });
+                engine.RegisterTask("A");
+
+                // When
+                var report = await engine.RunTargetAsync(fixture.Context, fixture.ExecutionStrategy, "A");
+
+                // Then
+                Assert.Equal(2, report.Count());
+                Assert.Equal("A", report.ElementAt(0).TaskName);
+                Assert.Equal("**Teardown**", report.ElementAt(1).TaskName);
+            }
+
             [Fact]
             public async Task Should_Return_Report_That_Contains_Executed_Tasks_In_Order()
             {

src/Cake.Core/CakeEngine.cs

@@ -128,12 +128,12 @@ public async Task<CakeReport> RunTargetAsync(ICakeContext context, IExecutionStr
             var exceptionWasThrown = false;
             Exception thrownException = null;
 
+            var stopWatch = new Stopwatch();
+            var report = new CakeReport();
+
             try
             {
-                PerformSetup(strategy, context);
-
-                var stopWatch = new Stopwatch();
-                var report = new CakeReport();
+                PerformSetup(strategy, context, stopWatch, report);
 
                 foreach (var taskNode in graph.Traverse(target))
                 {
@@ -165,7 +165,7 @@ public async Task<CakeReport> RunTargetAsync(ICakeContext context, IExecutionStr
             }
             finally
             {
-                PerformTeardown(strategy, context, exceptionWasThrown, thrownException);
+                PerformTeardown(strategy, context, stopWatch, report, exceptionWasThrown, thrownException);
             }
         }
 
@@ -199,12 +199,15 @@ public void RegisterTaskTeardownAction(Action<ITaskTeardownContext> action)
         /// </summary>
         public event EventHandler<TaskTeardownEventArgs> TaskTeardown;
 
-        private void PerformSetup(IExecutionStrategy strategy, ICakeContext context)
+        private void PerformSetup(IExecutionStrategy strategy, ICakeContext context, Stopwatch stopWatch, CakeReport report)
         {
+            stopWatch.Restart();
+
             PublishEvent(Setup, new SetupEventArgs(context));
             if (_setupAction != null)
             {
                 strategy.PerformSetup(_setupAction, context);
+                report.Add("**Setup**", stopWatch.Elapsed);
             }
         }
 
@@ -230,9 +233,7 @@ private static bool ShouldTaskExecute(ICakeContext context, CakeTask task, bool
 
         private async Task ExecuteTaskAsync(ICakeContext context, IExecutionStrategy strategy, Stopwatch stopWatch, CakeTask task, CakeReport report)
         {
-            // Reset the stop watch.
-            stopWatch.Reset();
-            stopWatch.Start();
+            stopWatch.Restart();
 
             PerformTaskSetup(context, strategy, task, false);
 
@@ -375,8 +376,10 @@ private void HandleErrors(IExecutionStrategy strategy, Action<Exception> errorHa
             }
         }
 
-        private void PerformTeardown(IExecutionStrategy strategy, ICakeContext context, bool exceptionWasThrown, Exception thrownException)
+        private void PerformTeardown(IExecutionStrategy strategy, ICakeContext context, Stopwatch stopWatch, CakeReport report, bool exceptionWasThrown, Exception thrownException)
         {
+            stopWatch.Restart();
+
             var teardownContext = new TeardownContext(context, thrownException);
             PublishEvent(Teardown, new TeardownEventArgs(teardownContext));
             if (_teardownAction != null)
@@ -393,8 +396,13 @@ private void PerformTeardown(IExecutionStrategy strategy, ICakeContext context,
                         // If no other exception was thrown, we throw this one.
                         throw;
                     }
+
                     _log.Error("Teardown error: {0}", ex.ToString());
                 }
+                finally
+                {
+                    report.Add("**Teardown**", stopWatch.Elapsed);
+                }
             }
         }