Adjust duration output from the summary output lines

Instead of outputting the average and summed execution time for each test
run, output the summed execution time of each test run and the total
elapsed time between the beginning and end of the test case's execution.
The new output follows the behavior of Darwin's XCTest framework.

Author: briancroom

XCTest/XCTestCase.swift

@@ -31,38 +31,37 @@ extension XCTestCase {
         var totalDuration = 0.0
         var totalFailures = 0
         var unexpectedFailures = 0
-        for (name, test) in tests {
-            XCTCurrentTestCase = self
-            let method = "\(self.dynamicType).\(name)"
-            var duration: Double = 0.0
-            print("Test Case '\(method)' started.")
-            
-            setUp()
-            
-            let start = currentTimeIntervalSinceReferenceTime()
-            test()
-            let end = currentTimeIntervalSinceReferenceTime()
-            
-            tearDown()
-            
-            duration = end - start
-            totalDuration += duration
-            for failure in XCTCurrentFailures {
-                failure.emit(method)
-                totalFailures += 1
-                if !failure.expected {
-                    unexpectedFailures += 1
+        let overallDuration = measureTimeExecutingBlock {
+            for (name, test) in tests {
+                XCTCurrentTestCase = self
+                let method = "\(self.dynamicType).\(name)"
+                print("Test Case '\(method)' started.")
+
+                setUp()
+
+                let duration = measureTimeExecutingBlock(test)
+
+                tearDown()
+
+                totalDuration += duration
+                for failure in XCTCurrentFailures {
+                    failure.emit(method)
+                    totalFailures += 1
+                    if !failure.expected {
+                        unexpectedFailures += 1
+                    }
                 }
+                var result = "passed"
+                if XCTCurrentFailures.count > 0 {
+                    result = "failed"
+                }
+                print("Test Case '\(method)' \(result) (\(printableStringForTimeInterval(duration)) seconds).")
+                XCTAllRuns.append(XCTRun(duration: duration, method: method, passed: XCTCurrentFailures.count == 0, failures: XCTCurrentFailures))
+                XCTCurrentFailures.removeAll()
+                XCTCurrentTestCase = nil
             }
-            var result = "passed"
-            if XCTCurrentFailures.count > 0 {
-                result = "failed"
-            }
-            print("Test Case '\(method)' \(result) (\(printableStringForTimeInterval(duration)) seconds).")
-            XCTAllRuns.append(XCTRun(duration: duration, method: method, passed: XCTCurrentFailures.count == 0, failures: XCTCurrentFailures))
-            XCTCurrentFailures.removeAll()
-            XCTCurrentTestCase = nil
         }
+
         var testCountSuffix = "s"
         if tests.count == 1 {
             testCountSuffix = ""
@@ -71,9 +70,8 @@ extension XCTestCase {
         if totalFailures == 1 {
             failureSuffix = ""
         }
-        let averageDuration = totalDuration / Double(tests.count)
-        
-        print("Executed \(tests.count) test\(testCountSuffix), with \(totalFailures) failure\(failureSuffix) (\(unexpectedFailures) unexpected) in \(printableStringForTimeInterval(averageDuration)) (\(printableStringForTimeInterval(totalDuration))) seconds")
+
+        print("Executed \(tests.count) test\(testCountSuffix), with \(totalFailures) failure\(failureSuffix) (\(unexpectedFailures) unexpected) in \(printableStringForTimeInterval(totalDuration)) (\(printableStringForTimeInterval(overallDuration))) seconds")
     }
 
     // This function is for the use of XCTestCase only, but we must make it public or clients will get a link failure when using XCTest (23476006)

XCTest/XCTestMain.swift

@@ -30,7 +30,7 @@ struct XCTFailure {
 }
 
 internal struct XCTRun {
-    var duration: Double
+    var duration: TimeInterval
     var method: String
     var passed: Bool
     var failures: [XCTFailure]
@@ -44,9 +44,12 @@ internal struct XCTRun {
 /// This function will not return. If the test cases pass, then it will call `exit(0)`. If there is a failure, then it will call `exit(1)`.
 /// - Parameter testCases: An array of test cases to run.
 @noreturn public func XCTMain(testCases: [XCTestCase]) {
-    for testCase in testCases {
-        testCase.invokeTest()
+    let overallDuration = measureTimeExecutingBlock {
+        for testCase in testCases {
+            testCase.invokeTest()
+        }
     }
+
     let (totalDuration, totalFailures, totalUnexpectedFailures) = XCTAllRuns.reduce((0.0, 0, 0)) { totals, run in (totals.0 + run.duration, totals.1 + run.failures.count, totals.2 + run.unexpectedFailures.count) }
 
     var testCountSuffix = "s"
@@ -57,8 +60,8 @@ internal struct XCTRun {
     if totalFailures == 1 {
         failureSuffix = ""
     }
-    let averageDuration = totalDuration / Double(XCTAllRuns.count)
-    print("Total executed \(XCTAllRuns.count) test\(testCountSuffix), with \(totalFailures) failure\(failureSuffix) (\(totalUnexpectedFailures) unexpected) in \(printableStringForTimeInterval(averageDuration)) (\(printableStringForTimeInterval(totalDuration))) seconds")
+
+    print("Total executed \(XCTAllRuns.count) test\(testCountSuffix), with \(totalFailures) failure\(failureSuffix) (\(totalUnexpectedFailures) unexpected) in \(printableStringForTimeInterval(totalDuration)) (\(printableStringForTimeInterval(overallDuration))) seconds")
     exit(totalFailures > 0 ? 1 : 0)
 }
 

XCTest/XCTimeUtilities.swift

@@ -17,18 +17,28 @@
     import Darwin
 #endif
 
+internal typealias TimeInterval = Double
+
 /// Returns the number of seconds since the reference time as a Double.
-internal func currentTimeIntervalSinceReferenceTime() -> Double {
+private func currentTimeIntervalSinceReferenceTime() -> TimeInterval {
     var tv = timeval()
-    let currentTime = withUnsafeMutablePointer(&tv, { (t: UnsafeMutablePointer<timeval>) -> Double in
+    let currentTime = withUnsafeMutablePointer(&tv, { (t: UnsafeMutablePointer<timeval>) -> TimeInterval in
         gettimeofday(t, nil)
-        return Double(t.memory.tv_sec) + Double(t.memory.tv_usec) / 1000000.0
+        return TimeInterval(t.memory.tv_sec) + TimeInterval(t.memory.tv_usec) / 1000000.0
     })
     return currentTime
 }
 
+/// Execute the given block and return the time spent during execution
+internal func measureTimeExecutingBlock(@noescape block: () -> Void) -> TimeInterval {
+    let start = currentTimeIntervalSinceReferenceTime()
+    block()
+    let end = currentTimeIntervalSinceReferenceTime()
+
+    return end - start
+}
+
 /// Returns a string version of the given time interval rounded to no more than 3 decimal places.
-internal func printableStringForTimeInterval(timeInterval: Double) -> String {
+internal func printableStringForTimeInterval(timeInterval: TimeInterval) -> String {
     return String(round(timeInterval * 1000.0) / 1000.0)
 }
-