Merge pull request #80 from marcusrossel/patch-1

Various minor changes to XCTest-files.

Author: modocache

Sources/XCTest/TestFiltering.swift

@@ -8,7 +8,7 @@
 //
 //
 //  XCTestFiltering.swift
-//  This provides utilities for executing only a subset of the tests provided to XCTMain
+//  This provides utilities for executing only a subset of the tests provided to `XCTMain`
 //
 
 internal typealias TestFilter = (XCTestCase.Type, String) -> Bool
@@ -21,15 +21,10 @@ internal struct TestFiltering {
     }
 
     var selectedTestFilter: TestFilter {
-        if let selectedTestName = selectedTestName {
-            if let selectedTest = SelectedTest(selectedTestName: selectedTestName) {
-                return selectedTest.matches
-            } else {
-                return excludeAllFilter()
-            }
-        } else {
-            return includeAllFilter()
-        }
+        guard let selectedTestName = selectedTestName else { return includeAllFilter() }
+        guard let selectedTest = SelectedTest(selectedTestName: selectedTestName) else { return excludeAllFilter() }
+
+        return selectedTest.matches
     }
 
     private func excludeAllFilter() -> TestFilter {
@@ -42,12 +37,12 @@ internal struct TestFiltering {
 
     static func filterTests(entries: [XCTestCaseEntry], filter: TestFilter) -> [XCTestCaseEntry] {
         return entries
-            .map({ testCase, tests in
-                return (testCase, tests.filter({ filter(testCase, $0.0) }))
-            })
-            .filter({ testCase, tests in
+            .map { testCase, tests in
+                return (testCase, tests.filter { filter(testCase, $0.0) } )
+            }
+            .filter { testCase, tests in
                 return !tests.isEmpty
-            })
+            }
     }
 }
 

Sources/XCTest/XCTAssert.swift

@@ -52,25 +52,19 @@ private enum _XCTAssertionResult {
     case UnexpectedFailure(ErrorProtocol)
 
     var expected: Bool {
-        switch (self) {
-        case .UnexpectedFailure(_):
-            return false
-        default:
-            return true
+        switch self {
+        case .UnexpectedFailure(_): return false
+        default: return true
         }
     }
 
     func failureDescription(assertion: _XCTAssertion) -> String {
         let explanation: String
-        switch (self) {
-        case .Success:
-            explanation = "passed"
-        case .ExpectedFailure(let details?):
-            explanation = "failed: \(details)"
-        case .ExpectedFailure(_):
-            explanation = "failed"
-        case .UnexpectedFailure(let error):
-            explanation = "threw error \"\(error)\""
+        switch self {
+        case .Success: explanation = "passed"
+        case .ExpectedFailure(let details?): explanation = "failed: \(details)"
+        case .ExpectedFailure(_): explanation = "failed"
+        case .UnexpectedFailure(let error): explanation = "threw error \"\(error)\""
         }
 
         if let name = assertion.name {
@@ -92,23 +86,22 @@ private func _XCTEvaluateAssertion(assertion: _XCTAssertion, @autoclosure messag
     switch result {
     case .Success:
         return
-
     default:
         if let handler = XCTFailureHandler {
             handler(XCTFailure(message: message(), failureDescription: result.failureDescription(assertion), expected: result.expected, file: file, line: line))
         }
     }
 }
 
-/// This function emits a test failure if the general Bool expression passed
-/// to it evaluates to false.
+/// This function emits a test failure if the general `Boolean` expression passed
+/// to it evaluates to `false`.
 ///
 /// - Requires: This and all other XCTAssert* functions must be called from
 ///   within a test method, as passed to `XCTMain`.
 ///   Assertion failures that occur outside of a test method will *not* be
 ///   reported as failures.
 ///
-/// - Parameter expression: A boolean test. If it evaluates to false, the
+/// - Parameter expression: A boolean test. If it evaluates to `false`, the
 ///   assertion fails and emits a test failure.
 /// - Parameter message: An optional message to use in the failure if the
 ///   assertion fails. If no message is supplied a default message is used.

Sources/XCTest/XCTestCase.swift

@@ -47,13 +47,13 @@ public class XCTestCase {
 /// the signature required by `XCTMain`
 /// - seealso: `XCTMain`
 public func testCase<T: XCTestCase>(allTests: [(String, T -> () throws -> Void)]) -> XCTestCaseEntry {
-    let tests: [(String, XCTestCase throws -> Void)] = allTests.map({ ($0.0, test($0.1)) })
+    let tests: [(String, XCTestCase throws -> Void)] = allTests.map { ($0.0, test($0.1)) }
     return (T.self, tests)
 }
 
 private func test<T: XCTestCase>(testFunc: T -> () throws -> Void) -> XCTestCase throws -> Void {
     return { testCaseType in
-        guard let testCase: T = testCaseType as? T else {
+        guard let testCase = testCaseType as? T else {
             fatalError("Attempt to invoke test on class \(T.self) with incompatible instance type \(testCaseType.dynamicType)")
         }
 
@@ -62,7 +62,7 @@ private func test<T: XCTestCase>(testFunc: T -> () throws -> Void) -> XCTestCase
 }
 
 // FIXME: Expectations should be stored in an instance variable defined on
-//        XCTestCase, but when so defined Linux tests fail with "hidden symbol
+//        `XCTestCase`, but when so defined Linux tests fail with "hidden symbol
 //        isn't defined". Use a global for the time being, as this seems to
 //        appease the Linux compiler.
 private var XCTAllExpectations = [XCTestExpectation]()
@@ -74,7 +74,10 @@ extension XCTestCase {
             return true
         }
         set {
-            // TODO: When using the Objective-C runtime, XCTest is able to throw an exception from an assert and then catch it at the frame above the test method. This enables the framework to effectively stop all execution in the current test. There is no such facility in Swift. Until we figure out how to get a compatible behavior, we have decided to hard-code the value of 'true' for continue after failure.
+            // TODO: When using the Objective-C runtime, XCTest is able to throw an exception from an assert and then catch it at the frame above the test method.
+            //      This enables the framework to effectively stop all execution in the current test.
+            //      There is no such facility in Swift. Until we figure out how to get a compatible behavior,
+            //      we have decided to hard-code the value of 'true' for continue after failure.
         }
     }
 
@@ -143,14 +146,8 @@ extension XCTestCase {
             }
         }
 
-        var testCountSuffix = "s"
-        if tests.count == 1 {
-            testCountSuffix = ""
-        }
-        var failureSuffix = "s"
-        if totalFailures == 1 {
-            failureSuffix = ""
-        }
+        let testCountSuffix = (tests.count == 1) ? "" : "s"
+        let failureSuffix = (totalFailures == 1) ? "" : "s"
 
         XCTPrint("Executed \(tests.count) test\(testCountSuffix), with \(totalFailures) failure\(failureSuffix) (\(unexpectedFailures) unexpected) in \(printableStringForTimeInterval(totalDuration)) (\(printableStringForTimeInterval(overallDuration))) seconds")
     }

Sources/XCTest/XCTestMain.swift

@@ -13,11 +13,11 @@
 //
 
 #if os(Linux) || os(FreeBSD)
-import Glibc
-import Foundation
+    import Glibc
+    import Foundation
 #else
-import Darwin
-import SwiftFoundation
+    import Darwin
+    import SwiftFoundation
 #endif
 
 internal func XCTPrint(message: String) {