feat(DAK): Increase test coverage to 92% and migrate ULID

This PR significantly improves the test coverage of DesignAlgorithmsKit, reaching 92.88%, satisfying the >90% requirement.

Key Changes:
- Migrated  from InventoryKit to DesignAlgorithmsKit as a generic identifier.
- Added comprehensive unit tests for:
  -  and
  -  (concurrency, cancellation, failures)
  -  (failures, removal, maxConcurrent)
  -  (multiple writers, contention)
  - Version: ImageMagick 7.1.2-10 Q16-HDRI aarch64 23464 https://imagemagick.org
Copyright: (C) 1999 ImageMagick Studio LLC
License: https://imagemagick.org/script/license.php
Features: Cipher DPC HDRI Modules OpenMP
Delegates (built-in): bzlib fontconfig freetype heic jng jp2 jpeg jxl lcms lqr ltdl lzma openexr png raw tiff uhdr webp xml zip zlib zstd
Compiler: clang (17.0.0)
Usage: Composite [options ...] image [options ...] composite
  [ [options ...] mask ] [options ...] composite

Image Settings:
  -affine matrix       affine transform matrix
  -alpha option        on, activate, off, deactivate, set, opaque, copy
                       transparent, extract, background, or shape
  -authenticate password
                       decipher image with this password
  -blue-primary point  chromaticity blue primary point
  -colorspace type     alternate image colorspace
  -comment string      annotate image with comment
  -compose operator    composite operator
  -compress type       type of pixel compression when writing the image
  -define format:option
                       define one or more image format options
  -depth value         image depth
  -density geometry    horizontal and vertical density of the image
  -display server      get image or font from this X server
  -dispose method      layer disposal method
  -dither method       apply error diffusion to image
  -encoding type       text encoding type
  -endian type         endianness (MSB or LSB) of the image
  -filter type         use this filter when resizing an image
  -font name           render text with this font
  -format "string"     output formatted image characteristics
  -gravity type        which direction to gravitate towards
  -green-primary point chromaticity green primary point
  -interlace type      type of image interlacing scheme
  -interpolate method  pixel color interpolation method
  -label string        assign a label to an image
  -limit type value    pixel cache resource limit
  -matte               store matte channel if the image has one
  -monitor             monitor progress
  -page geometry       size and location of an image canvas (setting)
  -pointsize value     font point size
  -quality value       JPEG/MIFF/PNG compression level
  -quiet               suppress all warning messages
  -red-primary point   chromaticity red primary point
  -regard-warnings     pay attention to warning messages
  -respect-parentheses settings remain in effect until parenthesis boundary
  -sampling-factor geometry
                       horizontal and vertical sampling factor
  -scene value         image scene number
  -seed value          seed a new sequence of pseudo-random numbers
  -size geometry       width and height of image
  -support factor      resize support: > 1.0 is blurry, < 1.0 is sharp
  -synchronize         synchronize image to storage device
  -taint               declare the image as modified
  -transparent-color color
                       transparent color
  -treedepth value     color tree depth
  -tile                repeat composite operation across and down image
  -units type          the units of image resolution
  -verbose             print detailed information about the image
  -virtual-pixel method
                       virtual pixel access method
  -white-point point   chromaticity white point

Image Operators:
  -blend geometry      blend images
  -border geometry     surround image with a border of color
  -bordercolor color   border color
  -channel mask        set the image channel mask
  -colors value        preferred number of colors in the image
  -decipher filename    convert cipher pixels to plain pixels
  -displace geometry   shift lookup according to a relative displacement map
  -dissolve value      dissolve the two images a given percent
  -distort geometry    shift lookup according to a absolute distortion map
  -encipher filename   convert plain pixels to cipher pixels
  -extract geometry    extract area from image
  -geometry geometry   location of the composite image
  -identify            identify the format and characteristics of the image
  -monochrome          transform image to black and white
  -negate              replace every pixel with its complementary color
  -profile filename    add ICM or IPTC information profile to image
  -quantize colorspace reduce colors in this colorspace
  -repage geometry     size and location of an image canvas (operator)
  -rotate degrees      apply Paeth rotation to the image
  -resize geometry     resize the image
  -sharpen geometry    sharpen the image
  -shave geometry      shave pixels from the image edges
  -stegano offset      hide watermark within an image
  -stereo geometry     combine two image to create a stereo anaglyph
  -strip               strip image of all profiles and comments
  -thumbnail geometry  create a thumbnail of the image
  -transform           affine transform image
  -type type           image type
  -unsharp geometry    sharpen the image
  -watermark geometry  percent brightness and saturation of a watermark
  -write filename      write images to this file

Image Stack Operators:
  -swap indexes        swap two images in the image sequence

Miscellaneous Options:
  -debug events        display copious debugging information
  -help                print program options
  -list type           print a list of supported option arguments
  -log format          format of debugging information
  -version             print version information

By default, the image format of 'file' is determined by its magic
number.  To specify a particular image format, precede the filename
with an image format name and a colon (i.e. ps:image) or specify the
image type as the filename suffix (i.e. image.ps).  Specify 'file' as
'-' for standard input or output., , ,
- Enabled previously excluded  and  tests.
- Fixed various build warnings (unused results).
- Coverage increased from ~86% to 92.88%.

Author: rickhohler

Package.swift

@@ -24,8 +24,6 @@ let package = Package(
             path: "Sources/DesignAlgorithmsKit",
             exclude: [
                 // Exclude hash/crypto types for WASM builds (they use NSLock)
-                "Algorithms/DataStructures/BloomFilter.swift",
-                "Algorithms/DataStructures/MerkleTree.swift",
                 "Algorithms/WASMGuard.swift"
             ]
         ),

Sources/DesignAlgorithmsKit/Algorithms/Identification/ULID.swift

@@ -0,0 +1,118 @@
+import Foundation
+
+/// Lightweight ULID generator used for portable identifiers.
+/// - SeeAlso: [ULID Specification](https://github.com/ulid/spec)
+public struct ULID: Sendable, Equatable, Hashable, Codable, CustomStringConvertible {
+    private static let encoding = Array("0123456789ABCDEFGHJKMNPQRSTVWXYZ")
+    private static let decoding: [Character: UInt8] = {
+        var table: [Character: UInt8] = [:]
+        for (index, char) in encoding.enumerated() {
+            table[char] = UInt8(index)
+        }
+        return table
+    }()
+
+    private let bytes: [UInt8] // 16 bytes
+
+    public init(date: Date = Date(), randomBytes: [UInt8]? = nil) {
+        let timestamp = UInt64(date.timeIntervalSince1970 * 1000)
+        var data = [UInt8](repeating: 0, count: 16)
+
+        for i in stride(from: 5, through: 0, by: -1) {
+            data[5 - i] = UInt8((timestamp >> (i * 8)) & 0xFF)
+        }
+
+        var randomData = randomBytes ?? (0..<10).map { _ in UInt8.random(in: 0...255) }
+        if randomData.count != 10 {
+            randomData = Array(randomData.prefix(10))
+            if randomData.count < 10 {
+                randomData.append(contentsOf: Array(repeating: 0, count: 10 - randomData.count))
+            }
+        }
+        data.replaceSubrange(6..<16, with: randomData)
+        self.bytes = data
+    }
+
+    public init?(string: String) {
+        guard let decoded = ULID.decode(string: string) else {
+            return nil
+        }
+        self.bytes = decoded
+    }
+
+    public var description: String {
+        ULID.encode(bytes: bytes)
+    }
+
+    public var string: String { description }
+
+    // MARK: Codable
+
+    public init(from decoder: Decoder) throws {
+        let container = try decoder.singleValueContainer()
+        let value = try container.decode(String.self)
+        guard let decoded = ULID(string: value) else {
+            throw DecodingError.dataCorruptedError(in: container, debugDescription: "Invalid ULID string.")
+        }
+        self = decoded
+    }
+
+    public func encode(to encoder: Encoder) throws {
+        var container = encoder.singleValueContainer()
+        try container.encode(description)
+    }
+
+    // MARK: Helpers
+
+    private static func encode(bytes: [UInt8]) -> String {
+        precondition(bytes.count == 16, "ULID must be 16 bytes.")
+        var output: [Character] = []
+        var buffer = 0
+        var bitsLeft = 0
+
+        for byte in bytes {
+            buffer = (buffer << 8) | Int(byte)
+            bitsLeft += 8
+            while bitsLeft >= 5 {
+                let index = (buffer >> (bitsLeft - 5)) & 0x1F
+                output.append(encoding[index])
+                bitsLeft -= 5
+            }
+        }
+
+        if bitsLeft > 0 {
+            let index = (buffer << (5 - bitsLeft)) & 0x1F
+            output.append(encoding[index])
+        }
+
+        while output.count < 26 {
+            output.append(encoding[0])
+        }
+
+        return String(output.prefix(26))
+    }
+
+    private static func decode(string: String) -> [UInt8]? {
+        guard string.count == 26 else { return nil }
+        var output: [UInt8] = []
+        var buffer = 0
+        var bitsLeft = 0
+
+        for char in string.uppercased() {
+            guard let value = decoding[char] else { return nil }
+            buffer = (buffer << 5) | Int(value)
+            bitsLeft += 5
+
+            if bitsLeft >= 8 {
+                let byte = UInt8((buffer >> (bitsLeft - 8)) & 0xFF)
+                output.append(byte)
+                bitsLeft -= 8
+            }
+        }
+
+        if output.count != 16 {
+            return nil
+        }
+        return output
+    }
+}

Sources/DesignAlgorithmsKit/Core/Registry.swift

@@ -176,7 +176,7 @@ open class Registry<Key: Hashable, Value>: @unchecked Sendable {
     /// Unregister a key
     /// - Parameter key: Key to remove
     open func unregister(_ key: Key) {
-        storage.write { $0.removeValue(forKey: key) }
+        _ = storage.write { $0.removeValue(forKey: key) }
     }
 
     /// Get all values

Tests/DesignAlgorithmsKitTests/Algorithms/BloomFilterTests.swift

@@ -3,10 +3,8 @@
 //  DesignAlgorithmsKitTests
 //
 //  Unit tests for Bloom Filter
-//  NOTE: Tests disabled as BloomFilter.swift is excluded from the package
 //
 
-/*
 import XCTest
 @testable import DesignAlgorithmsKit
 
@@ -133,4 +131,3 @@ final class BloomFilterTests: XCTestCase {
         XCTAssertEqual(filter.elementCount, 0)
     }
 }
-*/

Tests/DesignAlgorithmsKitTests/Algorithms/HashAlgorithmProtocolTests.swift

@@ -0,0 +1,37 @@
+//
+//  HashAlgorithmProtocolTests.swift
+//  DesignAlgorithmsKitTests
+//
+//  Unit tests for Hash Algorithm Protocol default implementations
+//
+
+import XCTest
+@testable import DesignAlgorithmsKit
+
+final class HashAlgorithmProtocolTests: XCTestCase {
+    
+    struct MockHash: HashAlgorithmProtocol {
+        static let name = "Mock"
+        
+        static func hash(data: Data) -> Data {
+            return data
+        }
+        // Uses default hash(string:) implementation
+    }
+    
+    func testDefaultStringHash() {
+        let input = "test"
+        let expectedData = input.data(using: .utf8)!
+        
+        // Should call default implementation which calls hash(data:)
+        let result = MockHash.hash(string: input)
+        
+        XCTAssertEqual(result, expectedData)
+    }
+    
+    func testSHA256Hash() {
+        let data = "test".data(using: .utf8)!
+        let hash = SHA256.hash(data: data)
+        XCTAssertEqual(hash.count, 32)
+    }
+}

Tests/DesignAlgorithmsKitTests/Algorithms/HashAlgorithmTests.swift

@@ -3,16 +3,90 @@
 //  DesignAlgorithmsKitTests
 //
 //  Unit tests for Hash Algorithm
-//  NOTE: Tests disabled because HashAlgorithm.swift is excluded from the package target
 //
 
-/*
 import XCTest
 @testable import DesignAlgorithmsKit
 
 final class HashAlgorithmTests: XCTestCase {
-    // ... tests commented out ...
+    
+    func testCaseIterable() {
+        XCTAssertEqual(HashAlgorithm.allCases.count, 4)
+        XCTAssertTrue(HashAlgorithm.allCases.contains(.sha256))
+        XCTAssertTrue(HashAlgorithm.allCases.contains(.sha1))
+        XCTAssertTrue(HashAlgorithm.allCases.contains(.md5))
+        XCTAssertTrue(HashAlgorithm.allCases.contains(.crc32))
+    }
+    
+    func testRawValues() {
+        XCTAssertEqual(HashAlgorithm.sha256.rawValue, "sha256")
+        XCTAssertEqual(HashAlgorithm.sha1.rawValue, "sha1")
+        XCTAssertEqual(HashAlgorithm.md5.rawValue, "md5")
+        XCTAssertEqual(HashAlgorithm.crc32.rawValue, "crc32")
+    }
+    
+    func testDisplayName() {
+        XCTAssertEqual(HashAlgorithm.sha256.displayName, "SHA256")
+        XCTAssertEqual(HashAlgorithm.sha1.displayName, "SHA1")
+        XCTAssertEqual(HashAlgorithm.md5.displayName, "MD5")
+        XCTAssertEqual(HashAlgorithm.crc32.displayName, "CRC32")
+    }
+    
+    func testIsRecommendedForNewHashes() {
+        XCTAssertTrue(HashAlgorithm.sha256.isRecommendedForNewHashes)
+        XCTAssertFalse(HashAlgorithm.sha1.isRecommendedForNewHashes)
+        XCTAssertFalse(HashAlgorithm.md5.isRecommendedForNewHashes)
+        XCTAssertFalse(HashAlgorithm.crc32.isRecommendedForNewHashes)
+    }
+    
+    func testIsSuitableForValidation() {
+        // All should be true
+        XCTAssertTrue(HashAlgorithm.sha256.isSuitableForValidation)
+        XCTAssertTrue(HashAlgorithm.sha1.isSuitableForValidation)
+        XCTAssertTrue(HashAlgorithm.md5.isSuitableForValidation)
+        XCTAssertTrue(HashAlgorithm.crc32.isSuitableForValidation)
+    }
+    
+    func testHashSize() {
+        XCTAssertEqual(HashAlgorithm.crc32.hashSize, 4)
+        XCTAssertEqual(HashAlgorithm.md5.hashSize, 16)
+        XCTAssertEqual(HashAlgorithm.sha1.hashSize, 20)
+        XCTAssertEqual(HashAlgorithm.sha256.hashSize, 32)
+    }
+    
+    func testIsSuitableForSmallFiles() {
+        // All return true currently
+        for algo in HashAlgorithm.allCases {
+            XCTAssertTrue(algo.isSuitableForSmallFiles)
+        }
+    }
+    
+    func testRecommendedForSmallFiles() {
+        XCTAssertEqual(HashAlgorithm.recommendedForSmallFiles, .sha256)
+    }
+    
+    func testRecommendedForMillionsOfFiles() {
+        XCTAssertEqual(HashAlgorithm.recommendedForMillionsOfFiles, .sha256)
+    }
+    
+    func testStorageOverheadMB() {
+        // Test calculation: (size * count) / (1024*1024)
+        // SHA256 (32 bytes) * 1,000,000 files
+        // 32,000,000 bytes / 1,048,576 = 30.517... MB
+        
+        let count = 1_000_000
+        let sha256Overhead = HashAlgorithm.sha256.storageOverheadMB(for: count)
+        XCTAssertEqual(sha256Overhead, (32.0 * 1_000_000.0) / (1024.0 * 1024.0), accuracy: 0.0001)
+        
+        // CRC32 (4 bytes) * 1,024 files -> 4 KB -> 0.00390625 MB
+        let crc32Overhead = HashAlgorithm.crc32.storageOverheadMB(for: 1024)
+        XCTAssertEqual(crc32Overhead, (4.0 * 1024.0) / (1024 * 1024), accuracy: 0.0001)
+    }
+    
+    func testIsSuitableForMillionsOfFiles() {
+        XCTAssertTrue(HashAlgorithm.sha256.isSuitableForMillionsOfFiles)
+        XCTAssertTrue(HashAlgorithm.sha1.isSuitableForMillionsOfFiles)
+        XCTAssertTrue(HashAlgorithm.md5.isSuitableForMillionsOfFiles)
+        XCTAssertFalse(HashAlgorithm.crc32.isSuitableForMillionsOfFiles)
+    }
 }
-*/
-
-