fixing macros

brightdigit · Apr 5, 2024 · 1e66112 · 1e66112
1 parent feb8c03
commit 1e66112
Show file tree

Hide file tree

Showing 7 changed files with 170 additions and 319 deletions.
diff --git a/Tests/LinuxMain.swift b/Tests/LinuxMain.swift
diff --git a/Tests/OptionsTests/EnumSetTests.swift b/Tests/OptionsTests/EnumSetTests.swift
@@ -27,64 +27,62 @@
 //  OTHER DEALINGS IN THE SOFTWARE.
 //
 
-#if canImport(XCTest)
-  @testable import Options
-  import XCTest
+@testable import Options
+import XCTest
 
-  internal final class EnumSetTests: XCTestCase {
-    private static let text = "[\"a\",\"b\",\"c\"]"
+internal final class EnumSetTests: XCTestCase {
+  private static let text = "[\"a\",\"b\",\"c\"]"
 
-    internal func testDecoder() {
-      // swiftlint:disable:next force_unwrapping
-      let data = Self.text.data(using: .utf8)!
-      let decoder = JSONDecoder()
-      let actual: EnumSet<MockCollectionEnum>
-      do {
-        actual = try decoder.decode(EnumSet<MockCollectionEnum>.self, from: data)
-      } catch {
-        XCTAssertNil(error)
-        return
-      }
-      XCTAssertEqual(actual.rawValue, 7)
+  internal func testDecoder() {
+    // swiftlint:disable:next force_unwrapping
+    let data = Self.text.data(using: .utf8)!
+    let decoder = JSONDecoder()
+    let actual: EnumSet<MockCollectionEnum>
+    do {
+      actual = try decoder.decode(EnumSet<MockCollectionEnum>.self, from: data)
+    } catch {
+      XCTAssertNil(error)
+      return
     }
+    XCTAssertEqual(actual.rawValue, 7)
+  }
 
-    internal func testEncoder() {
-      let enumSet = EnumSet<MockCollectionEnum>(values: [.a, .b, .c])
-      let encoder = JSONEncoder()
-      let data: Data
-      do {
-        data = try encoder.encode(enumSet)
-      } catch {
-        XCTAssertNil(error)
-        return
-      }
-
-      let dataText = String(bytes: data, encoding: .utf8)
+  internal func testEncoder() {
+    let enumSet = EnumSet<MockCollectionEnum>(values: [.a, .b, .c])
+    let encoder = JSONEncoder()
+    let data: Data
+    do {
+      data = try encoder.encode(enumSet)
+    } catch {
+      XCTAssertNil(error)
+      return
+    }
 
-      guard let text = dataText else {
-        XCTAssertNotNil(dataText)
-        return
-      }
+    let dataText = String(bytes: data, encoding: .utf8)
 
-      XCTAssertEqual(text, Self.text)
+    guard let text = dataText else {
+      XCTAssertNotNil(dataText)
+      return
     }
 
-    internal func testInitValue() {
-      let set = EnumSet<MockCollectionEnum>(rawValue: 7)
-      XCTAssertEqual(set.rawValue, 7)
-    }
+    XCTAssertEqual(text, Self.text)
+  }
 
-    internal func testInitValues() {
-      let values: [MockCollectionEnum] = [.a, .b, .c]
-      let set = EnumSet(values: values)
-      XCTAssertEqual(set.rawValue, 7)
-    }
+  internal func testInitValue() {
+    let set = EnumSet<MockCollectionEnum>(rawValue: 7)
+    XCTAssertEqual(set.rawValue, 7)
+  }
 
-    internal func testArray() {
-      let expected: [MockCollectionEnum] = [.b, .d]
-      let enumSet = EnumSet<MockCollectionEnum>(values: expected)
-      let actual = enumSet.array()
-      XCTAssertEqual(actual, expected)
-    }
+  internal func testInitValues() {
+    let values: [MockCollectionEnum] = [.a, .b, .c]
+    let set = EnumSet(values: values)
+    XCTAssertEqual(set.rawValue, 7)
+  }
+
+  internal func testArray() {
+    let expected: [MockCollectionEnum] = [.b, .d]
+    let enumSet = EnumSet<MockCollectionEnum>(values: expected)
+    let actual = enumSet.array()
+    XCTAssertEqual(actual, expected)
   }
-#endif
+}
diff --git a/Tests/OptionsTests/MappedEnumTests.swift b/Tests/OptionsTests/MappedEnumTests.swift
@@ -27,46 +27,43 @@
 //  OTHER DEALINGS IN THE SOFTWARE.
 //
 
-#if canImport(XCTest)
-  @testable import Options
-  import XCTest
+@testable import Options
+import XCTest
 
-  internal final class MappedEnumTests: XCTestCase {
-    private static let text = "\"a\""
-    internal func testDecoder() throws {
-      // swiftlint:disable:next force_unwrapping
-      let data = Self.text.data(using: .utf8)!
-      let decoder = JSONDecoder()
-      let actual: MappedEnum<MockCollectionEnum>
-      do {
-        actual = try decoder.decode(MappedEnum<MockCollectionEnum>.self, from: data)
-      } catch {
-        XCTAssertNil(error)
-        return
-      }
-      XCTAssertEqual(actual.value, .a)
+internal final class MappedEnumTests: XCTestCase {
+  private static let text = "\"a\""
+  internal func testDecoder() throws {
+    // swiftlint:disable:next force_unwrapping
+    let data = Self.text.data(using: .utf8)!
+    let decoder = JSONDecoder()
+    let actual: MappedEnum<MockCollectionEnum>
+    do {
+      actual = try decoder.decode(MappedEnum<MockCollectionEnum>.self, from: data)
+    } catch {
+      XCTAssertNil(error)
+      return
     }
+    XCTAssertEqual(actual.value, .a)
+  }
 
-    internal func testEncoder() throws {
-      let encoder = JSONEncoder()
-      let describedEnum: MappedEnum<MockCollectionEnum> = .init(value: .a)
-      let data: Data
-      do {
-        data = try encoder.encode(describedEnum)
-      } catch {
-        XCTAssertNil(error)
-        return
-      }
-
-      let dataText = String(bytes: data, encoding: .utf8)
+  internal func testEncoder() throws {
+    let encoder = JSONEncoder()
+    let describedEnum: MappedEnum<MockCollectionEnum> = .init(value: .a)
+    let data: Data
+    do {
+      data = try encoder.encode(describedEnum)
+    } catch {
+      XCTAssertNil(error)
+      return
+    }
 
-      guard let text = dataText else {
-        XCTAssertNotNil(dataText)
-        return
-      }
+    let dataText = String(bytes: data, encoding: .utf8)
 
-      XCTAssertEqual(text, Self.text)
+    guard let text = dataText else {
+      XCTAssertNotNil(dataText)
+      return
     }
-  }
 
-#endif
+    XCTAssertEqual(text, Self.text)
+  }
+}
diff --git a/Tests/OptionsTests/MappedValueCollectionRepresentedTests.swift b/Tests/OptionsTests/MappedValueCollectionRepresentedTests.swift
@@ -27,54 +27,51 @@
 //  OTHER DEALINGS IN THE SOFTWARE.
 //
 
-#if canImport(XCTest)
-  @testable import Options
-  import XCTest
+@testable import Options
+import XCTest
 
-  internal final class MappedValueCollectionRepresentedTests: XCTestCase {
-    internal func testRawValue() {
-      try XCTAssertEqual(MockCollectionEnum.rawValue(basedOn: "a"), 0)
-      try XCTAssertEqual(MockCollectionEnum.rawValue(basedOn: "b"), 1)
-      try XCTAssertEqual(MockCollectionEnum.rawValue(basedOn: "c"), 2)
-      try XCTAssertEqual(MockCollectionEnum.rawValue(basedOn: "d"), 3)
-    }
-
-    internal func testString() {
-      try XCTAssertEqual(MockCollectionEnum.mappedValue(basedOn: 0), "a")
-      try XCTAssertEqual(MockCollectionEnum.mappedValue(basedOn: 1), "b")
-      try XCTAssertEqual(MockCollectionEnum.mappedValue(basedOn: 2), "c")
-      try XCTAssertEqual(MockCollectionEnum.mappedValue(basedOn: 3), "d")
-    }
+internal final class MappedValueCollectionRepresentedTests: XCTestCase {
+  internal func testRawValue() {
+    try XCTAssertEqual(MockCollectionEnum.rawValue(basedOn: "a"), 0)
+    try XCTAssertEqual(MockCollectionEnum.rawValue(basedOn: "b"), 1)
+    try XCTAssertEqual(MockCollectionEnum.rawValue(basedOn: "c"), 2)
+    try XCTAssertEqual(MockCollectionEnum.rawValue(basedOn: "d"), 3)
+  }
 
-    internal func testRawValueFailure() {
-      let caughtError: MappedValueRepresentableError?
-      do {
-        _ = try MockCollectionEnum.rawValue(basedOn: "e")
-        caughtError = nil
-      } catch let error as MappedValueRepresentableError {
-        caughtError = error
-      } catch {
-        XCTAssertNil(error)
-        caughtError = nil
-      }
+  internal func testString() {
+    try XCTAssertEqual(MockCollectionEnum.mappedValue(basedOn: 0), "a")
+    try XCTAssertEqual(MockCollectionEnum.mappedValue(basedOn: 1), "b")
+    try XCTAssertEqual(MockCollectionEnum.mappedValue(basedOn: 2), "c")
+    try XCTAssertEqual(MockCollectionEnum.mappedValue(basedOn: 3), "d")
+  }
 
-      XCTAssertEqual(caughtError, .valueNotFound)
+  internal func testRawValueFailure() {
+    let caughtError: MappedValueRepresentableError?
+    do {
+      _ = try MockCollectionEnum.rawValue(basedOn: "e")
+      caughtError = nil
+    } catch let error as MappedValueRepresentableError {
+      caughtError = error
+    } catch {
+      XCTAssertNil(error)
+      caughtError = nil
     }
 
-    internal func testStringFailure() {
-      let caughtError: MappedValueRepresentableError?
-      do {
-        _ = try MockCollectionEnum.mappedValue(basedOn: .max)
-        caughtError = nil
-      } catch let error as MappedValueRepresentableError {
-        caughtError = error
-      } catch {
-        XCTAssertNil(error)
-        caughtError = nil
-      }
+    XCTAssertEqual(caughtError, .valueNotFound)
+  }
 
-      XCTAssertEqual(caughtError, .valueNotFound)
+  internal func testStringFailure() {
+    let caughtError: MappedValueRepresentableError?
+    do {
+      _ = try MockCollectionEnum.mappedValue(basedOn: .max)
+      caughtError = nil
+    } catch let error as MappedValueRepresentableError {
+      caughtError = error
+    } catch {
+      XCTAssertNil(error)
+      caughtError = nil
     }
-  }
 
-#endif
+    XCTAssertEqual(caughtError, .valueNotFound)
+  }
+}