Convert SortComparator tests

Author: jmschonfeld

Tests/FoundationEssentialsTests/SortComparatorTests.swift

@@ -10,56 +10,46 @@
 //
 //===----------------------------------------------------------------------===//
 
-#if canImport(TestSupport)
-import TestSupport
-#endif
 
-#if FOUNDATION_FRAMEWORK
-@testable import Foundation
-#else
+import Testing
+
+#if canImport(FoundationEssentials)
 @testable import FoundationEssentials
-#endif // FOUNDATION_FRAMEWORK
+#else
+@testable import Foundation
+#endif
 
-class SortComparatorTests: XCTestCase {
-    func test_comparable_descriptors() {
+@Suite("SortComparator")
+private struct SortComparatorTests {
+    @Test func comparableDescriptors() {
         let intDesc: ComparableComparator<Int> = ComparableComparator<Int>()
-        XCTAssertEqual(intDesc.compare(0, 1), .orderedAscending)
+        #expect(intDesc.compare(0, 1) == .orderedAscending)
         let result = intDesc.compare(1000, -10)
-        XCTAssertEqual(result, .orderedDescending)
+        #expect(result == .orderedDescending)
     }
 
 
-    func test_order() {
+    @Test func order() {
         var intDesc: ComparableComparator<Int> = ComparableComparator<Int>(order: .reverse)
-        XCTAssertEqual(intDesc.compare(0, 1), .orderedDescending)
-        XCTAssertEqual(intDesc.compare(1000, -10), .orderedAscending)
-        XCTAssertEqual(intDesc.compare(100, 100), .orderedSame)
+        #expect(intDesc.compare(0, 1) == .orderedDescending)
+        #expect(intDesc.compare(1000, -10) == .orderedAscending)
+        #expect(intDesc.compare(100, 100) == .orderedSame)
 
         intDesc.order = .forward
-        XCTAssertEqual(intDesc.compare(0, 1), .orderedAscending)
-        XCTAssertEqual(intDesc.compare(1000, -10), .orderedDescending)
-        XCTAssertEqual(intDesc.compare(100, 100), .orderedSame)
-    }
-    
-    func test_compare_options_descriptor() {
-        let compareOptions = String.Comparator(options: [.numeric])
-        XCTAssertEqual(
-            compareOptions.compare("ttestest005", "test2"),
-            "test005".compare("test2", options: [.numeric]))
-        XCTAssertEqual(
-            compareOptions.compare("test2", "test005"),
-            "test2".compare("test005", options: [.numeric]))
+        #expect(intDesc.compare(0, 1) == .orderedAscending)
+        #expect(intDesc.compare(1000, -10) == .orderedDescending)
+        #expect(intDesc.compare(100, 100) == .orderedSame)
     }
 
-    func testAnySortComparatorEquality() {
+    @Test func anySortComparatorEquality() {
         let a: ComparableComparator<Int> = ComparableComparator<Int>()
         let b: ComparableComparator<Int> = ComparableComparator<Int>(order: .reverse)
         let c: ComparableComparator<Double> = ComparableComparator<Double>()
-        XCTAssertEqual(AnySortComparator(a), AnySortComparator(a))
-        XCTAssertEqual(AnySortComparator(b), AnySortComparator(b))
-        XCTAssertEqual(AnySortComparator(c), AnySortComparator(c))
-        XCTAssertNotEqual(AnySortComparator(a), AnySortComparator(b))
-        XCTAssertNotEqual(AnySortComparator(b), AnySortComparator(c))
-        XCTAssertNotEqual(AnySortComparator(a), AnySortComparator(c))
+        #expect(AnySortComparator(a) == AnySortComparator(a))
+        #expect(AnySortComparator(b) == AnySortComparator(b))
+        #expect(AnySortComparator(c) == AnySortComparator(c))
+        #expect(AnySortComparator(a) != AnySortComparator(b))
+        #expect(AnySortComparator(b) != AnySortComparator(c))
+        #expect(AnySortComparator(a) != AnySortComparator(c))
     }
 }

Tests/FoundationInternationalizationTests/StringSortComparatorTests.swift

@@ -10,43 +10,48 @@
 //
 //===----------------------------------------------------------------------===//
 
-#if canImport(TestSupport)
-import TestSupport
-#endif
+import Testing
 
-#if FOUNDATION_FRAMEWORK
-@testable import Foundation
-#else
+#if canImport(FoundationEssentials)
 @testable import FoundationEssentials
 @testable import FoundationInternationalization
-#endif // FOUNDATION_FRAMEWORK
+#else
+@testable import Foundation
+#endif
 
-class StringSortComparatorTests: XCTestCase {
+@Suite("String SortComparator")
+private struct StringSortComparatorTests {
+    @Test func compareOptionsDescriptor() {
+        let compareOptions = String.Comparator(options: [.numeric])
+        #expect(
+            compareOptions.compare("ttestest005", "test2") ==
+            "test005".compare("test2", options: [.numeric]))
+        #expect(
+            compareOptions.compare("test2", "test005") ==
+            "test2".compare("test005", options: [.numeric]))
+    }
+    
 #if FOUNDATION_FRAMEWORK
     // TODO: Until we support String.compare(_:options:locale:) in FoundationInternationalization, only support unlocalized comparisons
     // https://github.com/apple/swift-foundation/issues/284
-    func test_locale() {
+    @Test func locale() {
         let swedishComparator = String.Comparator(options: [], locale: Locale(identifier: "sv"))
-        XCTAssertEqual(swedishComparator.compare("ă", "ã"), .orderedAscending)
-        XCTAssertEqual(swedishComparator.locale, Locale(identifier: "sv"))
+        #expect(swedishComparator.compare("ă", "ã") == .orderedAscending)
+        #expect(swedishComparator.locale, Locale(identifier: "sv"))
     }
 
-    func test_nil_locale() {
+    @Test func nilLocale() {
         let swedishComparator = String.Comparator(options: [], locale: nil)
-        XCTAssertEqual(swedishComparator.compare("ă", "ã"), .orderedDescending)
+        #expect(swedishComparator.compare("ă", "ã") == .orderedDescending)
     }
 
-    func test_standard_localized() throws {
-        // This test is only verified to work with en
-        guard Locale.current.language.languageCode == .english else {
-            throw XCTSkip("Test only verified to work with English as current language")
-        }
-        
+    @Test(.enabled(if: Locale.current.language.languageCode == .english, "Test only verified to work with English as current language"))
+    func standardLocalized() throws {
         let localizedStandard = String.StandardComparator.localizedStandard
-        XCTAssertEqual(localizedStandard.compare("ă", "ã"), .orderedAscending)
+        #expect(localizedStandard.compare("ă", "ã") == .orderedAscending)
 
         let unlocalizedStandard = String.StandardComparator.lexical
-        XCTAssertEqual(unlocalizedStandard.compare("ă", "ã"), .orderedDescending)
+        #expect(unlocalizedStandard.compare("ă", "ã") == .orderedDescending)
     }
 #endif
 }