tests++

Author: mickeyl

Tests/CornucopiaCoreTests/Extensions/Array/ArrayHexTests.swift

@@ -0,0 +1,28 @@
+//
+//  Cornucopia – (C) Dr. Lauer Information Technology
+//
+import XCTest
+@testable import CornucopiaCore
+
+final class ArrayHexTests: XCTestCase {
+
+    func testHexDecodedStringProducesUppercaseOutput() {
+
+        let bytes: [UInt8] = [0xDE, 0xAD, 0xBE, 0xEF]
+        let hex = deprecatedHexString(from: bytes)
+        XCTAssertEqual(hex, "DEADBEEF")
+    }
+
+    func testHexDecodedStringWithSpacesInsertsDelimiter() {
+
+        let bytes: [UInt8] = [0x00, 0xAB, 0xCD]
+        let hexWithSpaces = deprecatedHexStringWithSpaces(from: bytes)
+        XCTAssertEqual(hexWithSpaces, "00 AB CD")
+    }
+
+    @available(*, deprecated)
+    private func deprecatedHexString(from bytes: [UInt8]) -> String { bytes.CC_hexDecodedString }
+
+    @available(*, deprecated)
+    private func deprecatedHexStringWithSpaces(from bytes: [UInt8]) -> String { bytes.CC_hexDecodedStringWithSpaces }
+}

Tests/CornucopiaCoreTests/Extensions/AsyncSequence/AsyncSequenceCollectTests.swift

@@ -0,0 +1,41 @@
+//
+//  Cornucopia – (C) Dr. Lauer Information Technology
+//
+import XCTest
+@testable import CornucopiaCore
+
+final class AsyncSequenceCollectTests: XCTestCase {
+
+    func testCollectReturnsAllElements() async throws {
+
+        let expected = Array(0..<5)
+        let stream = AsyncStream<Int> { continuation in
+            expected.forEach { continuation.yield($0) }
+            continuation.finish()
+        }
+
+        let collected = try await stream.CC_collect()
+        XCTAssertEqual(collected, expected)
+    }
+
+    func testCollectPropagatesErrors() async {
+
+        enum SampleError: Error {
+            case boom
+        }
+
+        let stream = AsyncThrowingStream<Int, Error> { continuation in
+            continuation.yield(42)
+            continuation.finish(throwing: SampleError.boom)
+        }
+
+        do {
+            _ = try await stream.CC_collect()
+            XCTFail("Expected CC_collect to rethrow the original error.")
+        } catch {
+            guard case SampleError.boom = error else {
+                return XCTFail("Unexpected error: \\(error)")
+            }
+        }
+    }
+}

Tests/CornucopiaCoreTests/Extensions/BinaryInteger/BinaryIntegerParityTests.swift

@@ -0,0 +1,23 @@
+//
+//  Cornucopia – (C) Dr. Lauer Information Technology
+//
+import XCTest
+@testable import CornucopiaCore
+
+final class BinaryIntegerParityTests: XCTestCase {
+
+    func testParityInitializerDetectsEvenAndOddValues() {
+
+        XCTAssertEqual(Cornucopia.Core.Parity(0), .even)
+        XCTAssertEqual(Cornucopia.Core.Parity(1), .odd)
+        XCTAssertEqual(Cornucopia.Core.Parity(2), .even)
+        XCTAssertEqual(Cornucopia.Core.Parity(-3), .odd)
+    }
+
+    func testBinaryIntegerExtensionBridgesToParity() {
+
+        XCTAssertEqual(42.CC_parity, .even)
+        XCTAssertEqual(17.CC_parity, .odd)
+        XCTAssertEqual((-96).CC_parity, .even)
+    }
+}

Tests/CornucopiaCoreTests/Extensions/CaseIterable/CaseIterableRandomElementTests.swift

@@ -0,0 +1,32 @@
+//
+//  Cornucopia – (C) Dr. Lauer Information Technology
+//
+import XCTest
+@testable import CornucopiaCore
+
+final class CaseIterableRandomElementTests: XCTestCase {
+
+    private enum SampleEnum: CaseIterable {
+        case foo
+        case bar
+        case baz
+    }
+
+    private enum SingleCaseEnum: CaseIterable {
+        case only
+    }
+
+    func testRandomElementReturnsMemberOfAllCases() {
+
+        for _ in 0..<50 {
+            guard let element = SampleEnum.CC_randomElement else {
+                return XCTFail("Expected a random element for non-empty CaseIterable type.")
+            }
+            XCTAssertTrue(SampleEnum.allCases.contains(element))
+        }
+    }
+
+    func testRandomElementForSingleCaseEnumAlwaysReturnsThatCase() {
+        XCTAssertEqual(SingleCaseEnum.CC_randomElement, .only)
+    }
+}

Tests/CornucopiaCoreTests/Extensions/Collection/CollectionSortByKeyPathTests.swift

@@ -0,0 +1,37 @@
+//
+//  Cornucopia – (C) Dr. Lauer Information Technology
+//
+import XCTest
+@testable import CornucopiaCore
+
+final class CollectionSortByKeyPathTests: XCTestCase {
+
+    struct Payload: Equatable {
+        let value: Int
+        let label: String
+    }
+
+    func testSortByKeyPathAscending() {
+
+        let payloads = [
+            Payload(value: 2, label: "b"),
+            Payload(value: 1, label: "a"),
+            Payload(value: 3, label: "c"),
+        ]
+
+        let sorted = payloads.CC_sorted(by: \.value, <)
+        XCTAssertEqual(sorted.map(\.value), [1, 2, 3])
+    }
+
+    func testSortByKeyPathDescendingWithCustomComparator() {
+
+        let payloads = [
+            Payload(value: 5, label: "middle"),
+            Payload(value: 1, label: "low"),
+            Payload(value: 10, label: "high"),
+        ]
+
+        let sorted = payloads.CC_sorted(by: \.value) { lhs, rhs in lhs > rhs }
+        XCTAssertEqual(sorted.map(\.value), [10, 5, 1])
+    }
+}

Tests/CornucopiaCoreTests/Extensions/CoreFoundation/CFAbsoluteTimePrettyPrintTests.swift

@@ -0,0 +1,40 @@
+//
+//  Cornucopia – (C) Dr. Lauer Information Technology
+//
+import CoreFoundation
+import XCTest
+@testable import CornucopiaCore
+
+final class CFAbsoluteTimePrettyPrintTests: XCTestCase {
+
+    func testPrettyPrintForHoursAndMinutes() {
+
+        let interval = 2 * CFTimeInterval.hour + 15 * CFTimeInterval.minute
+        XCTAssertEqual(interval.CC_prettyDescription, "2h 15m")
+    }
+
+    func testPrettyPrintForMinutesAndSeconds() {
+
+        let interval = 1 * CFTimeInterval.minute + 45 * CFTimeInterval.second
+        XCTAssertEqual(interval.CC_prettyDescription, "1m 45s")
+    }
+
+    func testPrettyPrintForSecondsAndMilliseconds() {
+
+        let interval = 3 * CFTimeInterval.second + 400 * CFTimeInterval.ms
+        XCTAssertEqual(interval.CC_prettyDescription, "3s 400ms")
+    }
+
+    func testPrettyPrintFallsBackToNanoseconds() {
+
+        let interval = 250 * CFTimeInterval.ns
+        let pretty = interval.CC_prettyDescription
+        XCTAssertTrue(pretty.hasSuffix("ns"))
+
+        let numericPortion = pretty.dropLast(2)
+        guard let value = Double(numericPortion) else {
+            return XCTFail("Expected numeric portion in nanosecond description: \\(pretty)")
+        }
+        XCTAssertEqual(value, 250.0, accuracy: 0.0001)
+    }
+}

Tests/CornucopiaCoreTests/Extensions/Stream/StreamThrowingIOTests.swift

@@ -0,0 +1,86 @@
+//
+//  Cornucopia – (C) Dr. Lauer Information Technology
+//
+import Foundation
+import XCTest
+@testable import CornucopiaCore
+
+final class StreamThrowingIOTests: XCTestCase {
+
+    func testInputStreamThrowingReadTransfersBytes() throws {
+
+        let payload = Data("cornucopia".utf8)
+        let stream = InputStream(data: payload)
+        stream.open()
+        defer { stream.close() }
+
+        var buffer = [UInt8](repeating: 0, count: payload.count)
+        let bytesRead = try buffer.withUnsafeMutableBufferPointer { pointer -> Int in
+            guard let baseAddress = pointer.baseAddress else { XCTFail("Pointer base address not available."); return 0 }
+            return try stream.CC_read(baseAddress, maxLength: pointer.count)
+        }
+
+        XCTAssertEqual(bytesRead, payload.count)
+        XCTAssertEqual(Data(buffer), payload)
+    }
+
+    func testInputStreamThrowingReadThrowsEOF() throws {
+
+        let stream = InputStream(data: Data([0x01]))
+        stream.open()
+        defer { stream.close() }
+
+        var buffer = [UInt8](repeating: 0, count: 1)
+        _ = try buffer.withUnsafeMutableBufferPointer { pointer -> Int in
+            guard let baseAddress = pointer.baseAddress else { XCTFail("Pointer base address not available."); return 0 }
+            return try stream.CC_read(baseAddress, maxLength: pointer.count)
+        }
+
+        XCTAssertThrowsError(try buffer.withUnsafeMutableBufferPointer { pointer -> Int in
+            guard let baseAddress = pointer.baseAddress else { XCTFail("Pointer base address not available."); return 0 }
+            return try stream.CC_read(baseAddress, maxLength: pointer.count)
+        }) { error in
+            guard case InputStream.Exception.eof? = error as? InputStream.Exception else {
+                return XCTFail("Expected EOF, got \\(error)")
+            }
+        }
+    }
+
+    func testOutputStreamThrowingWritePersistsData() throws {
+
+        let stream = OutputStream.toMemory()
+        stream.open()
+        defer { stream.close() }
+
+        let payload: [UInt8] = [0xCA, 0xFE, 0xBA, 0xBE]
+        let written = try payload.withUnsafeBytes { pointer -> Int in
+            guard let baseAddress = pointer.bindMemory(to: UInt8.self).baseAddress else {
+                XCTFail("Pointer base address not available."); return 0
+            }
+            return try stream.CC_write(baseAddress, maxLength: payload.count)
+        }
+
+        XCTAssertEqual(written, payload.count)
+        let data = stream.property(forKey: .dataWrittenToMemoryStreamKey) as? Data
+        XCTAssertEqual(data, Data(payload))
+    }
+
+    func testOutputStreamThrowingWriteThrowsWhenClosed() {
+
+        let stream = OutputStream.toMemory()
+        stream.open()
+        stream.close()
+
+        let payload: [UInt8] = [0x00]
+        XCTAssertThrowsError(try payload.withUnsafeBytes { pointer -> Int in
+            guard let baseAddress = pointer.bindMemory(to: UInt8.self).baseAddress else {
+                XCTFail("Pointer base address not available."); return 0
+            }
+            return try stream.CC_write(baseAddress, maxLength: payload.count)
+        }) { error in
+            guard case OutputStream.Exception.unknown? = error as? OutputStream.Exception else {
+                return XCTFail("Expected unknown error, got \\(error)")
+            }
+        }
+    }
+}