[SR-1417] Add non-optional overloads of XCTAssertEqual and XCTAssertN…

Documentation/Linux.md

@@ -4,22 +4,22 @@ When running on the Objective-C runtime, XCTest is able to find all of your test
 
 ```swift
 class TestNSURL : XCTestCase {
-    static var allTests : [(String, (TestNSURL) -> () throws -> Void)] {
-        return [
-            ("test_URLStrings", test_URLStrings),
-            ("test_fileURLWithPath_relativeToURL", test_fileURLWithPath_relativeToURL),
-            ("test_fileURLWithPath", test_fileURLWithPath),
-            ("test_fileURLWithPath_isDirectory", test_fileURLWithPath_isDirectory),
-            // Other tests go here
-        ]
-    }
-
-    func test_fileURLWithPath_relativeToURL() {
-        // Write your test here. Most of the XCTAssert macros you are familiar with are available.
-        XCTAssertTrue(theBestNumber == 42, "The number is wrong")
-    }
-
-    // Other tests go here
+static var allTests = {
+return [
+("test_URLStrings", test_URLStrings),
+("test_fileURLWithPath_relativeToURL", test_fileURLWithPath_relativeToURL),
+("test_fileURLWithPath", test_fileURLWithPath),
+("test_fileURLWithPath_isDirectory", test_fileURLWithPath_isDirectory),
+// Other tests go here
+]
+}()
+
+func test_fileURLWithPath_relativeToURL() {
+// Write your test here. Most of the XCTAssert macros you are familiar with are available.
+XCTAssertTrue(theBestNumber == 42, "The number is wrong")
+}
+
+// Other tests go here
 }
 ```
 
@@ -29,11 +29,27 @@ Also, this version of XCTest does not use the external test runner binary. Inste
 XCTMain([testCase(TestNSString.allTests), testCase(TestNSArray.allTests), testCase(TestNSDictionary.allTests)])
 ```
 
-The `XCTMain` function does not return, and will cause your test app to exit with either `0` for success or `1` for failure. Command line arguments given to the executable can be used to select a particular test or test case to execute. For example:
+We are currently investigating ideas on how to make these additional steps for test discovery automatic when running on the Swift runtime.
+
+# Command Line Usage
+The `XCTMain` function does not return, and will cause your test app to exit with either `0` for success or `1` for failure. Certain command line arguments can be used to modify the test runner behavior:
+
+* A particular test or test case can be selected to execute. For example:
 
 ```sh
-./FooTests FooTestCase/testFoo  # Run a single test case
-./FooTests FooTestCase          # Run all the tests in FooTestCase
+$ ./FooTests Tests.FooTestCase/testFoo  # Run a single test case
+$ ./FooTests Tests.FooTestCase          # Run all the tests in FooTestCase
 ```
+* Tests can be listed, instead of executed.
 
-We are currently investigating ideas on how to make these additional steps for test discovery automatic when running on the Swift runtime.
+```sh
+$ ./FooTests --list-tests
+Listing 4 tests in FooTests.xctest:
+
+Tests.FooTestCase/testFoo
+Tests.FooTestCase/testBar
+Tests.BarTestCase/test123
+
+$ ./FooTests --dump-tests-json
+{"tests":[{"tests":[{"tests":[{"name":"testFoo"},{"name":"testBar"}],"name":"Tests.FooTestCase"},{"tests":[{"name":"test123"}],"name":"Tests.BarTestCase"}],"name":"Tests.xctest"}],"name":"All tests"}
+```

Sources/XCTest/Private/ArgumentParser.swift

@@ -0,0 +1,65 @@
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2016 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See http://swift.org/LICENSE.txt for license information
+// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//
+//  ArgumentParser.swift
+//  Tools for parsing test execution configuration from command line arguments.
+//
+
+/// Utility for converting command line arguments into a strongly-typed
+/// representation of the passed-in options
+internal struct ArgumentParser {
+
+    /// The basic operations that can be performed by an XCTest runner executable
+    enum ExecutionMode {
+        /// Run a test or test suite, printing results to stdout and exiting with
+        /// a non-0 return code if any tests failed. The name of a test or class
+        /// may be provided to only run a subset of test cases.
+        case run(selectedTestName: String?)
+
+        /// The different ways that the tests can be represented when they are listed
+        enum ListType {
+            /// A flat list of the tests that can be run. The lines in this
+            /// output are valid test names for the `run` mode.
+            case humanReadable
+
+            /// A JSON representation of the test suite, intended for consumption
+            /// by other tools
+            case json
+        }
+
+        /// Print a list of all the tests in the suite.
+        case list(type: ListType)
+
+        var selectedTestName: String? {
+            if case .run(let name) = self {
+                return name
+            } else {
+                return nil
+            }
+        }
+    }
+
+    private let arguments: [String]
+
+    init(arguments: [String] = Process.arguments) {
+        self.arguments = arguments
+    }
+
+    var executionMode: ExecutionMode {
+        if arguments.count <= 1 {
+            return .run(selectedTestName: nil)
+        } else if arguments[1] == "--list-tests" || arguments[1] == "-l" {
+            return .list(type: .humanReadable)
+        } else if arguments[1] == "--dump-tests-json" {
+            return .list(type: .json)
+        } else {
+            return .run(selectedTestName: arguments[1])
+        }
+    }
+}

Sources/XCTest/PrintObserver.swift → Sources/XCTest/Private/PrintObserver.swift

@@ -76,7 +76,7 @@ internal class PrintObserver: XCTestObservation {
     }
 }
 
-extension PrintObserver: _XCTestObservation {
+extension PrintObserver: XCTestInternalObservation {
     func testCase(_ testCase: XCTestCase, didMeasurePerformanceResults results: String, file: StaticString, line: UInt) {
         printAndFlush("\(file):\(line): Test Case '\(testCase.name)' measured \(results)")
     }

Sources/XCTest/TestFiltering.swift → Sources/XCTest/Private/TestFiltering.swift

@@ -16,7 +16,7 @@ internal typealias TestFilter = (XCTestCase.Type, String) -> Bool
 internal struct TestFiltering {
     private let selectedTestName: String?
 
-    init(selectedTestName: String? = ArgumentParser().selectedTestName) {
+    init(selectedTestName: String?) {
         self.selectedTestName = selectedTestName
     }
 

Sources/XCTest/Private/TestListing.swift

@@ -0,0 +1,107 @@
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2016 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See http://swift.org/LICENSE.txt for license information
+// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//
+//  TestListing.swift
+//  Implementation of the mode for printing the list of tests.
+//
+
+#if os(Linux) || os(FreeBSD)
+    import Foundation
+#else
+    import SwiftFoundation
+#endif
+
+internal struct TestListing {
+    private let testSuite: XCTestSuite
+
+    init(testSuite: XCTestSuite) {
+        self.testSuite = testSuite
+    }
+
+    /// Prints a flat list of the tests in the suite, in the format used to
+    /// specify a test by name when running tests.
+    func printTestList() {
+        let list = testSuite.list()
+        let tests = list.count == 1 ? "test" : "tests"
+        let bundleName = testSuite.findBundleTestSuite()?.name ?? "<<unknown bundle>>"
+
+        print("Listing \(list.count) \(tests) in \(bundleName):\n")
+        for entry in testSuite.list() {
+            print(entry)
+        }
+    }
+
+    /// Prints a JSON representation of the tests in the suite, mirring the internal
+    /// tree representation of test suites and test cases. This output is intended
+    /// to be consumed by other tools.
+    func printTestJSON() {
+        let json = try! NSJSONSerialization.data(withJSONObject: testSuite.dictionaryRepresentation())
+        print(NSString(data: json, encoding: NSUTF8StringEncoding)!)
+    }
+}
+
+protocol Listable {
+    func list() -> [String]
+    func dictionaryRepresentation() -> NSDictionary
+}
+
+private func moduleName(value: Any) -> String {
+    let moduleAndType = String(reflecting: value.dynamicType)
+    return String(moduleAndType.characters.split(separator: ".").first!)
+}
+
+extension XCTestSuite: Listable {
+    private var listables: [Listable] {
+        return tests
+            .flatMap({ ($0 as? Listable) })
+    }
+
+    private var listingName: String {
+        if let childTestCase = tests.first as? XCTestCase where name == String(childTestCase.dynamicType) {
+            return "\(moduleName(value: childTestCase)).\(name)"
+        } else {
+            return name
+        }
+    }
+
+    func list() -> [String] {
+        return listables.flatMap({ $0.list() })
+    }
+
+    func dictionaryRepresentation() -> NSDictionary {
+        let listedTests = tests.flatMap({ ($0 as? Listable)?.dictionaryRepresentation() })
+        return [
+                   "name": listingName.bridge(),
+                   "tests": listedTests.bridge()
+            ].bridge()
+    }
+
+    func findBundleTestSuite() -> XCTestSuite? {
+        if name.hasSuffix(".xctest") {
+            return self
+        } else {
+            return tests.flatMap({ ($0 as? XCTestSuite)?.findBundleTestSuite() }).first
+        }
+    }
+}
+
+extension XCTestCase: Listable {
+    func list() -> [String] {
+        let adjustedName = name.characters
+            .split(separator: ".")
+            .map(String.init)
+            .joined(separator: "/")
+        return ["\(moduleName(value: self)).\(adjustedName)"]
+    }
+
+    func dictionaryRepresentation() -> NSDictionary {
+        let methodName = String(name.characters.split(separator: ".").last!)
+        return ["name": methodName].bridge()
+    }
+}

Sources/XCTest/Private/XCTestInternalObservation.swift

@@ -0,0 +1,32 @@
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2016 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See http://swift.org/LICENSE.txt for license information
+// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//
+//  XCTestInternalObservation.swift
+//  Extra hooks used within XCTest for being notified about additional events
+//  during a test run.
+//
+
+/// Expanded version of `XCTestObservation` used internally to respond to
+/// additional events not publicly exposed.
+internal protocol XCTestInternalObservation: XCTestObservation {
+    /// Called when a test case finishes measuring performance and has results
+    /// to report
+    /// - Parameter testCase: The test case that did the measurements.
+    /// - Parameter results: The measured values and derived stats.
+    /// - Parameter file: The path to the source file where the failure was
+    ///   reported, if available.
+    /// - Parameter line: The line number in the source file where the failure
+    ///   was reported.
+    func testCase(_ testCase: XCTestCase, didMeasurePerformanceResults results: String, file: StaticString, line: UInt)
+}
+
+// All `XCInternalTestObservation` methods are optional, so empty default implementations are provided
+internal extension XCTestInternalObservation {
+    func testCase(_ testCase: XCTestCase, didMeasurePerformanceResults results: String, file: StaticString, line: UInt) {}
+}

Sources/XCTest/XCTAssert.swift → Sources/XCTest/Public/XCTAssert.swift

@@ -156,6 +156,17 @@ public func XCTAssert(_ expression: @autoclosure () throws -> Boolean, _ message
     XCTAssertTrue(expression, message, file: file, line: line)
 }
 
+public func XCTAssertEqual<T: Equatable>(_ expression1: @autoclosure () throws -> T, _ expression2: @autoclosure () throws -> T, _ message: @autoclosure () -> String = "", file: StaticString = #file, line: UInt = #line) {
+    _XCTEvaluateAssertion(.equal, message: message, file: file, line: line) {
+        let (value1, value2) = (try expression1(), try expression2())
+        if value1 == value2 {
+            return .success
+        } else {
+            return .expectedFailure("(\"\(value1)\") is not equal to (\"\(value2)\")")
+        }
+    }
+}
+
 public func XCTAssertEqual<T: Equatable>(_ expression1: @autoclosure () throws -> T?, _ expression2: @autoclosure () throws -> T?, _ message: @autoclosure () -> String = "", file: StaticString = #file, line: UInt = #line) {
     _XCTEvaluateAssertion(.equal, message: message, file: file, line: line) {
         let (value1, value2) = (try expression1(), try expression2())
@@ -288,6 +299,17 @@ public func XCTAssertNil(_ expression: @autoclosure () throws -> Any?, _ message
     }
 }
 
+public func XCTAssertNotEqual<T: Equatable>(_ expression1: @autoclosure () throws -> T, _ expression2: @autoclosure () throws -> T, _ message: @autoclosure () -> String = "", file: StaticString = #file, line: UInt = #line) {
+    _XCTEvaluateAssertion(.notEqual, message: message, file: file, line: line) {
+        let (value1, value2) = (try expression1(), try expression2())
+        if value1 != value2 {
+            return .success
+        } else {
+            return .expectedFailure("(\"\(value1)\") is equal to (\"\(value2)\")")
+        }
+    }
+}
+
 public func XCTAssertNotEqual<T: Equatable>(_ expression1: @autoclosure () throws -> T?, _ expression2: @autoclosure () throws -> T?, _ message: @autoclosure () -> String = "", file: StaticString = #file, line: UInt = #line) {
     _XCTEvaluateAssertion(.notEqual, message: message, file: file, line: line) {
         let (value1, value2) = (try expression1(), try expression2())