Update tests to meet the new requirements

briancroom · briancroom · commit ced7f2b35226 · 2016-01-22T09:59:25.000-05:00
* Add XCTestCaseType conformances and update XCTMain invocation
* Use the static allTests property
diff --git a/Tests/Functional/ErrorHandling/main.swift b/Tests/Functional/ErrorHandling/main.swift
@@ -27,19 +27,19 @@
 #endif
 
 class ErrorHandling: XCTestCase {
-    var allTests: [(String, () throws -> ())] {
+    static var allTests: [(String, XCTestCaseType throws -> Void)] {
         return [
             // Tests for XCTAssertThrowsError
-            ("test_shouldButDoesNotThrowErrorInAssertion", test_shouldButDoesNotThrowErrorInAssertion),
-            ("test_shouldThrowErrorInAssertion", test_shouldThrowErrorInAssertion),
-            ("test_throwsErrorInAssertionButFailsWhenCheckingError", test_throwsErrorInAssertionButFailsWhenCheckingError),
+            ("test_shouldButDoesNotThrowErrorInAssertion", test(test_shouldButDoesNotThrowErrorInAssertion)),
+            ("test_shouldThrowErrorInAssertion", test(test_shouldThrowErrorInAssertion)),
+            ("test_throwsErrorInAssertionButFailsWhenCheckingError", test(test_throwsErrorInAssertionButFailsWhenCheckingError)),
             
             // Tests for "testFoo() throws"
-            ("test_canAndDoesThrowErrorFromTestMethod", test_canAndDoesThrowErrorFromTestMethod),
-            ("test_canButDoesNotThrowErrorFromTestMethod", test_canButDoesNotThrowErrorFromTestMethod),
+            ("test_canAndDoesThrowErrorFromTestMethod", test(test_canAndDoesThrowErrorFromTestMethod)),
+            ("test_canButDoesNotThrowErrorFromTestMethod", test(test_canButDoesNotThrowErrorFromTestMethod)),
             
             // Tests for throwing assertion expressions
-            ("test_assertionExpressionCanThrow", test_assertionExpressionCanThrow), 
+            ("test_assertionExpressionCanThrow", test(test_assertionExpressionCanThrow)),
         ]
     }
     
@@ -103,4 +103,5 @@ class ErrorHandling: XCTestCase {
     }
 }
 
-XCTMain([ErrorHandling()])
+extension ErrorHandling: XCTestCaseType {}
+XCTMain([ErrorHandling.self])
diff --git a/Tests/Functional/FailingTestSuite/main.swift b/Tests/Functional/FailingTestSuite/main.swift
@@ -22,9 +22,9 @@
 #endif
 
 class PassingTestCase: XCTestCase {
-    var allTests: [(String, () throws -> ())] {
+    static var allTests: [(String, XCTestCaseType throws -> Void)] {
         return [
-            ("test_passes", test_passes),
+            ("test_passes", test(test_passes)),
         ]
     }
 
@@ -34,11 +34,11 @@ class PassingTestCase: XCTestCase {
 }
 
 class FailingTestCase: XCTestCase {
-    var allTests: [(String, () throws -> ())] {
+    static var allTests: [(String, XCTestCaseType throws -> Void)] {
         return [
-            ("test_passes", test_passes),
-            ("test_fails", test_fails),
-            ("test_fails_with_message", test_fails_with_message),
+            ("test_passes", test(test_passes)),
+            ("test_fails", test(test_fails)),
+            ("test_fails_with_message", test(test_fails_with_message)),
         ]
     }
 
@@ -55,7 +55,9 @@ class FailingTestCase: XCTestCase {
     }
 }
 
+extension PassingTestCase: XCTestCaseType {}
+extension FailingTestCase: XCTestCaseType {}
 XCTMain([
-    PassingTestCase(),
-    FailingTestCase(),
+    PassingTestCase.self,
+    FailingTestCase.self,
 ])
diff --git a/Tests/Functional/FailureMessagesTestCase/main.swift b/Tests/Functional/FailureMessagesTestCase/main.swift
@@ -78,30 +78,30 @@
 
 // Regression test for https://github.com/apple/swift-corelibs-xctest/pull/22
 class FailureMessagesTestCase: XCTestCase {
-    var allTests : [(String, () throws -> Void)] {
+    static var allTests: [(String, XCTestCaseType throws -> Void)] {
         return [
-            ("testAssert", testAssert),
-            ("testAssertEqualOptionals", testAssertEqualOptionals),
-            ("testAssertEqualArraySlices", testAssertEqualArraySlices),
-            ("testAssertEqualContiguousArrays", testAssertEqualContiguousArrays),
-            ("testAssertEqualArrays", testAssertEqualArrays),
-            ("testAssertEqualDictionaries", testAssertEqualDictionaries),
-            ("testAssertEqualWithAccuracy", testAssertEqualWithAccuracy),
-            ("testAssertFalse", testAssertFalse),
-            ("testAssertGreaterThan", testAssertGreaterThan),
-            ("testAssertGreaterThanOrEqual", testAssertGreaterThanOrEqual),
-            ("testAssertLessThan", testAssertLessThan),
-            ("testAssertLessThanOrEqual", testAssertLessThanOrEqual),
-            ("testAssertNil", testAssertNil),
-            ("testAssertNotEqualOptionals", testAssertNotEqualOptionals),
-            ("testAssertNotEqualArraySlices", testAssertNotEqualArraySlices),
-            ("testAssertNotEqualContiguousArrays", testAssertNotEqualContiguousArrays),
-            ("testAssertNotEqualArrays", testAssertNotEqualArrays),
-            ("testAssertNotEqualDictionaries", testAssertNotEqualDictionaries),
-            ("testAssertNotEqualWithAccuracy", testAssertNotEqualWithAccuracy),
-            ("testAssertNotNil", testAssertNotNil),
-            ("testAssertTrue", testAssertTrue),
-            ("testFail", testFail),
+            ("testAssert", test(testAssert)),
+            ("testAssertEqualOptionals", test(testAssertEqualOptionals)),
+            ("testAssertEqualArraySlices", test(testAssertEqualArraySlices)),
+            ("testAssertEqualContiguousArrays", test(testAssertEqualContiguousArrays)),
+            ("testAssertEqualArrays", test(testAssertEqualArrays)),
+            ("testAssertEqualDictionaries", test(testAssertEqualDictionaries)),
+            ("testAssertEqualWithAccuracy", test(testAssertEqualWithAccuracy)),
+            ("testAssertFalse", test(testAssertFalse)),
+            ("testAssertGreaterThan", test(testAssertGreaterThan)),
+            ("testAssertGreaterThanOrEqual", test(testAssertGreaterThanOrEqual)),
+            ("testAssertLessThan", test(testAssertLessThan)),
+            ("testAssertLessThanOrEqual", test(testAssertLessThanOrEqual)),
+            ("testAssertNil", test(testAssertNil)),
+            ("testAssertNotEqualOptionals", test(testAssertNotEqualOptionals)),
+            ("testAssertNotEqualArraySlices", test(testAssertNotEqualArraySlices)),
+            ("testAssertNotEqualContiguousArrays", test(testAssertNotEqualContiguousArrays)),
+            ("testAssertNotEqualArrays", test(testAssertNotEqualArrays)),
+            ("testAssertNotEqualDictionaries", test(testAssertNotEqualDictionaries)),
+            ("testAssertNotEqualWithAccuracy", test(testAssertNotEqualWithAccuracy)),
+            ("testAssertNotNil", test(testAssertNotNil)),
+            ("testAssertTrue", test(testAssertTrue)),
+            ("testFail", test(testFail)),
         ]
     }
 
@@ -194,4 +194,5 @@ class FailureMessagesTestCase: XCTestCase {
     }
 }
 
-XCTMain([FailureMessagesTestCase()])
+extension FailureMessagesTestCase: XCTestCaseType {}
+XCTMain([FailureMessagesTestCase.self])
diff --git a/Tests/Functional/NegativeAccuracyTestCase/main.swift b/Tests/Functional/NegativeAccuracyTestCase/main.swift
@@ -22,12 +22,12 @@
 
 // Regression test for https://github.com/apple/swift-corelibs-xctest/pull/7
 class NegativeAccuracyTestCase: XCTestCase {
-    var allTests: [(String, () throws -> ())] {
+    static var allTests: [(String, XCTestCaseType throws -> Void)] {
         return [
-            ("test_equalWithAccuracy_passes", test_equalWithAccuracy_passes),
-            ("test_equalWithAccuracy_fails", test_equalWithAccuracy_fails),
-            ("test_notEqualWithAccuracy_passes", test_notEqualWithAccuracy_passes),
-            ("test_notEqualWithAccuracy_fails", test_notEqualWithAccuracy_fails),
+            ("test_equalWithAccuracy_passes", test(test_equalWithAccuracy_passes)),
+            ("test_equalWithAccuracy_fails", test(test_equalWithAccuracy_fails)),
+            ("test_notEqualWithAccuracy_passes", test(test_notEqualWithAccuracy_passes)),
+            ("test_notEqualWithAccuracy_fails", test(test_notEqualWithAccuracy_fails)),
         ]
     }
 
@@ -48,4 +48,5 @@ class NegativeAccuracyTestCase: XCTestCase {
     }
 }
 
-XCTMain([NegativeAccuracyTestCase()])
+extension NegativeAccuracyTestCase: XCTestCaseType {}
+XCTMain([NegativeAccuracyTestCase.self])
diff --git a/Tests/Functional/SingleFailingTestCase/main.swift b/Tests/Functional/SingleFailingTestCase/main.swift
@@ -14,9 +14,9 @@
 #endif
 
 class SingleFailingTestCase: XCTestCase {
-    var allTests: [(String, () throws -> ())] {
+    static var allTests: [(String, XCTestCaseType throws -> Void)] {
         return [
-            ("test_fails", test_fails),
+            ("test_fails", test(test_fails))
         ]
     }
 
@@ -25,4 +25,5 @@ class SingleFailingTestCase: XCTestCase {
     }
 }
 
-XCTMain([SingleFailingTestCase()])
+extension SingleFailingTestCase: XCTestCaseType {}
+XCTMain([SingleFailingTestCase.self])
diff --git a/Tests/Functional/TestCaseLifecycle/main.swift b/Tests/Functional/TestCaseLifecycle/main.swift
@@ -21,9 +21,9 @@
 #endif
 
 class SetUpTearDownTestCase: XCTestCase {
-    var allTests: [(String, () throws -> Void)] {
+    static var allTests: [(String, XCTestCaseType throws -> Void)] {
         return [
-            ("test_hasValueFromSetUp", test_hasValueFromSetUp),
+            ("test_hasValueFromSetUp", test(test_hasValueFromSetUp)),
         ]
     }
 
@@ -47,10 +47,10 @@ class SetUpTearDownTestCase: XCTestCase {
 }
 
 class NewInstanceForEachTestTestCase: XCTestCase {
-    var allTests: [(String, () throws -> Void)] {
+    static var allTests: [(String, XCTestCaseType throws -> Void)] {
         return [
-            ("test_hasInitializedValue", test_hasInitializedValue),
-            ("test_hasInitializedValueInAnotherTest", test_hasInitializedValueInAnotherTest),
+            ("test_hasInitializedValue", test(test_hasInitializedValue)),
+            ("test_hasInitializedValueInAnotherTest", test(test_hasInitializedValueInAnotherTest)),
         ]
     }
 
@@ -66,7 +66,9 @@ class NewInstanceForEachTestTestCase: XCTestCase {
     }
 }
 
+extension SetUpTearDownTestCase: XCTestCaseType {}
+extension NewInstanceForEachTestTestCase: XCTestCaseType {}
 XCTMain([
-    SetUpTearDownTestCase(),
-    NewInstanceForEachTestTestCase()
+    SetUpTearDownTestCase.self,
+    NewInstanceForEachTestTestCase.self
 ])

Original file line number	Diff line number	Diff line change
`@@ -22,9 +22,9 @@`
`22`	`22`	`#endif`
`23`	`23`
`24`	`24`	`class PassingTestCase: XCTestCase {`
`25`		`- var allTests: [(String, () throws -> ())] {`
	`25`	`+ static var allTests: [(String, XCTestCaseType throws -> Void)] {`
`26`	`26`	`return [`
`27`		`- ("test_passes", test_passes),`
	`27`	`+ ("test_passes", test(test_passes)),`
`28`	`28`	`]`
`29`	`29`	`}`
`30`	`30`
`@@ -34,11 +34,11 @@ class PassingTestCase: XCTestCase {`
`34`	`34`	`}`
`35`	`35`
`36`	`36`	`class FailingTestCase: XCTestCase {`
`37`		`- var allTests: [(String, () throws -> ())] {`
	`37`	`+ static var allTests: [(String, XCTestCaseType throws -> Void)] {`
`38`	`38`	`return [`
`39`		`- ("test_passes", test_passes),`
`40`		`- ("test_fails", test_fails),`
`41`		`- ("test_fails_with_message", test_fails_with_message),`
	`39`	`+ ("test_passes", test(test_passes)),`
	`40`	`+ ("test_fails", test(test_fails)),`
	`41`	`+ ("test_fails_with_message", test(test_fails_with_message)),`
`42`	`42`	`]`
`43`	`43`	`}`
`44`	`44`
`@@ -55,7 +55,9 @@ class FailingTestCase: XCTestCase {`
`55`	`55`	`}`
`56`	`56`	`}`
`57`	`57`
	`58`	`+extension PassingTestCase: XCTestCaseType {}`
	`59`	`+extension FailingTestCase: XCTestCaseType {}`
`58`	`60`	`XCTMain([`
`59`		`- PassingTestCase(),`
`60`		`- FailingTestCase(),`
	`61`	`+ PassingTestCase.self,`
	`62`	`+ FailingTestCase.self,`
`61`	`63`	`])`
Original file line number	Diff line number	Diff line change
`@@ -22,12 +22,12 @@`
`22`	`22`
`23`	`23`	`// Regression test for https://github.com/apple/swift-corelibs-xctest/pull/7`
`24`	`24`	`class NegativeAccuracyTestCase: XCTestCase {`
`25`		`- var allTests: [(String, () throws -> ())] {`
	`25`	`+ static var allTests: [(String, XCTestCaseType throws -> Void)] {`
`26`	`26`	`return [`
`27`		`- ("test_equalWithAccuracy_passes", test_equalWithAccuracy_passes),`
`28`		`- ("test_equalWithAccuracy_fails", test_equalWithAccuracy_fails),`
`29`		`- ("test_notEqualWithAccuracy_passes", test_notEqualWithAccuracy_passes),`
`30`		`- ("test_notEqualWithAccuracy_fails", test_notEqualWithAccuracy_fails),`
	`27`	`+ ("test_equalWithAccuracy_passes", test(test_equalWithAccuracy_passes)),`
	`28`	`+ ("test_equalWithAccuracy_fails", test(test_equalWithAccuracy_fails)),`
	`29`	`+ ("test_notEqualWithAccuracy_passes", test(test_notEqualWithAccuracy_passes)),`
	`30`	`+ ("test_notEqualWithAccuracy_fails", test(test_notEqualWithAccuracy_fails)),`
`31`	`31`	`]`
`32`	`32`	`}`
`33`	`33`
`@@ -48,4 +48,5 @@ class NegativeAccuracyTestCase: XCTestCase {`
`48`	`48`	`}`
`49`	`49`	`}`
`50`	`50`
`51`		`-XCTMain([NegativeAccuracyTestCase()])`
	`51`	`+extension NegativeAccuracyTestCase: XCTestCaseType {}`
	`52`	`+XCTMain([NegativeAccuracyTestCase.self])`
Original file line number	Diff line number	Diff line change
`@@ -14,9 +14,9 @@`
`14`	`14`	`#endif`
`15`	`15`
`16`	`16`	`class SingleFailingTestCase: XCTestCase {`
`17`		`- var allTests: [(String, () throws -> ())] {`
	`17`	`+ static var allTests: [(String, XCTestCaseType throws -> Void)] {`
`18`	`18`	`return [`
`19`		`- ("test_fails", test_fails),`
	`19`	`+ ("test_fails", test(test_fails))`
`20`	`20`	`]`
`21`	`21`	`}`
`22`	`22`
`@@ -25,4 +25,5 @@ class SingleFailingTestCase: XCTestCase {`
`25`	`25`	`}`
`26`	`26`	`}`
`27`	`27`
`28`		`-XCTMain([SingleFailingTestCase()])`
	`28`	`+extension SingleFailingTestCase: XCTestCaseType {}`
	`29`	`+XCTMain([SingleFailingTestCase.self])`
Original file line number	Diff line number	Diff line change
`@@ -21,9 +21,9 @@`
`21`	`21`	`#endif`
`22`	`22`
`23`	`23`	`class SetUpTearDownTestCase: XCTestCase {`
`24`		`- var allTests: [(String, () throws -> Void)] {`
	`24`	`+ static var allTests: [(String, XCTestCaseType throws -> Void)] {`
`25`	`25`	`return [`
`26`		`- ("test_hasValueFromSetUp", test_hasValueFromSetUp),`
	`26`	`+ ("test_hasValueFromSetUp", test(test_hasValueFromSetUp)),`
`27`	`27`	`]`
`28`	`28`	`}`
`29`	`29`
`@@ -47,10 +47,10 @@ class SetUpTearDownTestCase: XCTestCase {`
`47`	`47`	`}`
`48`	`48`
`49`	`49`	`class NewInstanceForEachTestTestCase: XCTestCase {`
`50`		`- var allTests: [(String, () throws -> Void)] {`
	`50`	`+ static var allTests: [(String, XCTestCaseType throws -> Void)] {`
`51`	`51`	`return [`
`52`		`- ("test_hasInitializedValue", test_hasInitializedValue),`
`53`		`- ("test_hasInitializedValueInAnotherTest", test_hasInitializedValueInAnotherTest),`
	`52`	`+ ("test_hasInitializedValue", test(test_hasInitializedValue)),`
	`53`	`+ ("test_hasInitializedValueInAnotherTest", test(test_hasInitializedValueInAnotherTest)),`
`54`	`54`	`]`
`55`	`55`	`}`
`56`	`56`
`@@ -66,7 +66,9 @@ class NewInstanceForEachTestTestCase: XCTestCase {`
`66`	`66`	`}`
`67`	`67`	`}`
`68`	`68`
	`69`	`+extension SetUpTearDownTestCase: XCTestCaseType {}`
	`70`	`+extension NewInstanceForEachTestTestCase: XCTestCaseType {}`
`69`	`71`	`XCTMain([`
`70`		`- SetUpTearDownTestCase(),`
`71`		`- NewInstanceForEachTestTestCase()`
	`72`	`+ SetUpTearDownTestCase.self,`
	`73`	`+ NewInstanceForEachTestTestCase.self`
`72`	`74`	`])`