Fix Linux compilation error and expand test coverage with comprehensive test suites

Sources/STFilePath/STPath+Metadata.swift

@@ -6,6 +6,9 @@
 //
 
 import Foundation
+#if canImport(Darwin)
+import Darwin
+#endif
 
 public extension STPathProtocol {
 
@@ -48,6 +51,7 @@ struct STExtendedAttributes {
 
     let url: URL
 
+    #if canImport(Darwin)
     /// [en] Sets an extended attribute for the file or folder.
     /// [zh] 为文件或文件夹设置扩展属性。
     /// - Parameters:
@@ -116,4 +120,29 @@ struct STExtendedAttributes {
             return buffer.split(separator: 0).compactMap { String(cString: Array($0), encoding: .utf8) }
         }
     }
+    #else
+    /// [en] Extended attributes are not supported on this platform.
+    /// [zh] 此平台不支持扩展属性。
+    func set(name: String, value: Data) throws {
+        throw STPathError(message: "[en] Extended attributes not supported on this platform. \n [zh] 此平台不支持扩展属性。", code: -1)
+    }
+
+    /// [en] Extended attributes are not supported on this platform.
+    /// [zh] 此平台不支持扩展属性。
+    func value(of name: String) throws -> Data {
+        throw STPathError(message: "[en] Extended attributes not supported on this platform. \n [zh] 此平台不支持扩展属性。", code: -1)
+    }
+
+    /// [en] Extended attributes are not supported on this platform.
+    /// [zh] 此平台不支持扩展属性。
+    func remove(of name: String) throws {
+        throw STPathError(message: "[en] Extended attributes not supported on this platform. \n [zh] 此平台不支持扩展属性。", code: -1)
+    }
+
+    /// [en] Extended attributes are not supported on this platform.
+    /// [zh] 此平台不支持扩展属性。
+    func list() throws -> [String] {
+        throw STPathError(message: "[en] Extended attributes not supported on this platform. \n [zh] 此平台不支持扩展属性。", code: -1)
+    }
+    #endif
 }

Sources/STFilePath/STPathProtocol.swift

@@ -237,15 +237,15 @@ public extension STPathProtocol {
     static func standardizedPath(_ path: String) -> URL {
         if path == "~" {
 #if os(Linux)
-            return URL(fileURLWithPath: "/")
+            return URL(fileURLWithPath: NSHomeDirectory())
 #else
             return STFolder.Sanbox.home.url
 #endif
         } else if path.hasPrefix("~/") {
             var components = path.split(separator: "/").map({ $0.description })
             components = Array(components.dropFirst())
 #if os(Linux)
-            let home = [String]()
+            let home = NSHomeDirectory().split(separator: "/").map(\.description)
 #else
             let home = STFolder.Sanbox.home.url.path.split(separator: "/").map(\.description)
 #endif

Tests/STFilePathTests/STComparatorTests.swift

@@ -0,0 +1,183 @@
+import Testing
+import STFilePath
+import Foundation
+
+@Suite("STComparator Tests")
+struct STComparatorTests {
+
+    @Test("Basic Compression and Decompression")
+    func testBasicCompressionDecompression() throws {
+        #if canImport(Compression)
+        let originalData = "This is a test string for compression. It should compress well because it has repeating patterns and common words.".data(using: .utf8)!
+
+        // Test ZLIB compression
+        let compressedData = try STComparator.compress(originalData, algorithm: .zlib)
+        #expect(compressedData.count > 0)
+        #expect(compressedData.count < originalData.count) // Should be smaller
+
+        let decompressedData = try STComparator.decompress(compressedData, algorithm: .zlib)
+        #expect(decompressedData == originalData)
+        #endif
+    }
+
+    @Test("Different Compression Algorithms")
+    func testDifferentCompressionAlgorithms() throws {
+        #if canImport(Compression)
+        let testData = String(repeating: "ABCDEFGHIJ", count: 100).data(using: .utf8)!
+
+        let algorithms: [STComparator.Algorithm] = [.lz4, .zlib, .lzfse, .lzma]
+
+        for algorithm in algorithms {
+            let compressed = try STComparator.compress(testData, algorithm: algorithm)
+            #expect(compressed.count > 0)
+
+            let decompressed = try STComparator.decompress(compressed, algorithm: algorithm)
+            #expect(decompressed == testData)
+        }
+        #endif
+    }
+
+    @Test("Empty Data Compression")
+    func testEmptyDataCompression() throws {
+        #if canImport(Compression)
+        let emptyData = Data()
+
+        let compressed = try STComparator.compress(emptyData, algorithm: .zlib)
+        let decompressed = try STComparator.decompress(compressed, algorithm: .zlib)
+
+        #expect(decompressed == emptyData)
+        #endif
+    }
+
+    @Test("Small Data Compression")
+    func testSmallDataCompression() throws {
+        #if canImport(Compression)
+        let smallData = "Hi".data(using: .utf8)!
+
+        let compressed = try STComparator.compress(smallData, algorithm: .lz4)
+        let decompressed = try STComparator.decompress(compressed, algorithm: .lz4)
+
+        #expect(decompressed == smallData)
+        #endif
+    }
+
+    @Test("Large Data Compression")
+    func testLargeDataCompression() throws {
+        #if canImport(Compression)
+        // Create a large dataset with patterns that should compress well
+        let pattern = "This is a repeating pattern that should compress very well. "
+        let largeData = String(repeating: pattern, count: 1000).data(using: .utf8)!
+
+        let compressed = try STComparator.compress(largeData, algorithm: .zlib)
+        #expect(compressed.count > 0)
+        #expect(compressed.count < largeData.count) // Should achieve good compression ratio
+
+        let decompressed = try STComparator.decompress(compressed, algorithm: .zlib)
+        #expect(decompressed == largeData)
+
+        // Verify compression ratio is reasonable (should be much smaller)
+        let compressionRatio = Double(compressed.count) / Double(largeData.count)
+        #expect(compressionRatio < 0.5) // Should compress to less than 50% of original size
+        #endif
+    }
+
+    @Test("Binary Data Compression")
+    func testBinaryDataCompression() throws {
+        #if canImport(Compression)
+        // Create some binary data
+        var binaryData = Data()
+        for i in 0..<1024 {
+            binaryData.append(UInt8(i % 256))
+        }
+
+        let compressed = try STComparator.compress(binaryData, algorithm: .lzfse)
+        let decompressed = try STComparator.decompress(compressed, algorithm: .lzfse)
+
+        #expect(decompressed == binaryData)
+        #endif
+    }
+
+    @Test("Random Data Compression")
+    func testRandomDataCompression() throws {
+        #if canImport(Compression)
+        // Random data typically doesn't compress well
+        var randomData = Data()
+        for _ in 0..<1024 {
+            randomData.append(UInt8.random(in: 0...255))
+        }
+
+        let compressed = try STComparator.compress(randomData, algorithm: .zlib)
+        let decompressed = try STComparator.decompress(compressed, algorithm: .zlib)
+
+        #expect(decompressed == randomData)
+
+        // Random data might actually get larger when compressed
+        // So we just verify it works, not that it's smaller
+        #expect(compressed.count > 0)
+        #endif
+    }
+
+    @Test("Compression Algorithm Comparison")
+    func testCompressionAlgorithmComparison() throws {
+        #if canImport(Compression)
+        let testData = """
+        Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. 
+        Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. 
+        Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. 
+        Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
+        """.data(using: .utf8)!
+
+        let algorithms: [STComparator.Algorithm] = [.lz4, .zlib, .lzfse, .lzma]
+        var compressionResults: [STComparator.Algorithm: Int] = [:]
+
+        for algorithm in algorithms {
+            let compressed = try STComparator.compress(testData, algorithm: algorithm)
+            let decompressed = try STComparator.decompress(compressed, algorithm: algorithm)
+
+            #expect(decompressed == testData)
+            compressionResults[algorithm] = compressed.count
+        }
+
+        // All algorithms should produce compressed data
+        for (algorithm, size) in compressionResults {
+            #expect(size > 0, "Algorithm \(algorithm) produced empty compressed data")
+        }
+        #endif
+    }
+
+    @Test("Compression Error Handling")
+    func testCompressionErrorHandling() throws {
+        #if canImport(Compression)
+        // Test with malformed compressed data
+        let invalidCompressedData = Data([0xFF, 0xFF, 0xFF, 0xFF])
+
+        #expect {
+            try STComparator.decompress(invalidCompressedData, algorithm: .zlib)
+        } throws: { error in
+            return error is STComparator.Errors
+        }
+        #endif
+    }
+
+    @Test("Compression Consistency")
+    func testCompressionConsistency() throws {
+        #if canImport(Compression)
+        let testData = "Consistency test data".data(using: .utf8)!
+
+        // Compress the same data multiple times
+        let compressed1 = try STComparator.compress(testData, algorithm: .zlib)
+        let compressed2 = try STComparator.compress(testData, algorithm: .zlib)
+
+        // The compressed data should be identical for the same input
+        #expect(compressed1 == compressed2)
+
+        // Both should decompress to the original data
+        let decompressed1 = try STComparator.decompress(compressed1, algorithm: .zlib)
+        let decompressed2 = try STComparator.decompress(compressed2, algorithm: .zlib)
+
+        #expect(decompressed1 == testData)
+        #expect(decompressed2 == testData)
+        #expect(decompressed1 == decompressed2)
+        #endif
+    }
+}

Tests/STFilePathTests/STFile+CryptoKitTests.swift

@@ -0,0 +1,139 @@
+import Testing
+import STFilePath
+import Foundation
+
+@Suite("STFile CryptoKit Tests")
+struct STFileCryptoKitTests {
+
+    @Test("SHA256 Hash Operations")
+    func testSHA256Hash() throws {
+        #if canImport(CryptoKit)
+        let testFolder = try createTestFolder()
+        defer { try? testFolder.delete() }
+        try testFolder.create()
+
+        let file = testFolder.file("hash_test.txt")
+        let testData = "Hello, World!".data(using: .utf8)!
+        try file.create(with: testData)
+
+        // Test SHA256 hash
+        let hash = try file.hash(with: .sha256)
+        #expect(!hash.isEmpty)
+        #expect(hash.count == 64) // SHA256 produces 32 bytes = 64 hex characters
+
+        // Test consistency - same content should produce same hash
+        let hash2 = try file.hash(with: .sha256)
+        #expect(hash == hash2)
+
+        // Test with different content
+        let file2 = testFolder.file("hash_test2.txt")
+        try file2.create(with: "Different content".data(using: .utf8)!)
+        let differentHash = try file2.hash(with: .sha256)
+        #expect(hash != differentHash)
+        #endif
+    }
+
+    @Test("Multiple Hash Algorithms")
+    func testMultipleHashAlgorithms() throws {
+        #if canImport(CryptoKit)
+        let testFolder = try createTestFolder()
+        defer { try? testFolder.delete() }
+        try testFolder.create()
+
+        let file = testFolder.file("multi_hash_test.txt")
+        let testData = "Test data for multiple hash algorithms".data(using: .utf8)!
+        try file.create(with: testData)
+
+        // Test different algorithms produce different results
+        let sha256Hash = try file.hash(with: .sha256)
+        let sha384Hash = try file.hash(with: .sha384)
+        let sha512Hash = try file.hash(with: .sha512)
+        let md5Hash = try file.hash(with: .md5)
+
+        // Verify hash lengths
+        #expect(sha256Hash.count == 64)  // 32 bytes * 2 hex chars
+        #expect(sha384Hash.count == 96)  // 48 bytes * 2 hex chars
+        #expect(sha512Hash.count == 128) // 64 bytes * 2 hex chars
+        #expect(md5Hash.count == 32)     // 16 bytes * 2 hex chars
+
+        // Verify they're all different
+        #expect(sha256Hash != sha384Hash)
+        #expect(sha256Hash != sha512Hash)
+        #expect(sha256Hash != md5Hash)
+        #expect(sha384Hash != sha512Hash)
+        #endif
+    }
+
+    @Test("Large File Hash Performance")
+    func testLargeFileHash() throws {
+        #if canImport(CryptoKit)
+        let testFolder = try createTestFolder()
+        defer { try? testFolder.delete() }
+        try testFolder.create()
+
+        let file = testFolder.file("large_file.txt")
+
+        // Create a larger file (1MB of data)
+        let chunkSize = 1024
+        let numChunks = 1024
+        let chunk = String(repeating: "A", count: chunkSize).data(using: .utf8)!
+
+        try file.create()
+        let handle = try file.handle(.writing)
+        defer { handle.closeFile() }
+
+        for _ in 0..<numChunks {
+            handle.write(chunk)
+        }
+        handle.closeFile()
+
+        // Test hashing the large file
+        let startTime = Date()
+        let hash = try file.hash(with: .sha256)
+        let duration = Date().timeIntervalSince(startTime)
+
+        #expect(!hash.isEmpty)
+        #expect(hash.count == 64)
+        #expect(duration < 5.0) // Should complete within 5 seconds
+        #endif
+    }
+
+    @Test("Hash Kind Direct Usage")
+    func testHashKindDirectUsage() throws {
+        #if canImport(CryptoKit)
+        let testData = "Direct hash test".data(using: .utf8)!
+
+        // Test hashing data directly through STHasherKind
+        let sha256Hash = try STHasherKind.sha256.hash(with: testData)
+        let md5Hash = try STHasherKind.md5.hash(with: testData)
+
+        #expect(!sha256Hash.isEmpty)
+        #expect(!md5Hash.isEmpty)
+        #expect(sha256Hash != md5Hash)
+
+        // Test consistency
+        let sha256Hash2 = try STHasherKind.sha256.hash(with: testData)
+        #expect(sha256Hash == sha256Hash2)
+        #endif
+    }
+
+    @Test("Empty File Hash")
+    func testEmptyFileHash() throws {
+        #if canImport(CryptoKit)
+        let testFolder = try createTestFolder()
+        defer { try? testFolder.delete() }
+        try testFolder.create()
+
+        let file = testFolder.file("empty_file.txt")
+        try file.create(with: Data())
+
+        let hash = try file.hash(with: .sha256)
+        #expect(!hash.isEmpty)
+        #expect(hash.count == 64)
+
+        // Empty files should have a consistent hash
+        let hash2 = try file.hash(with: .sha256)
+        #expect(hash == hash2)
+        #endif
+    }
+}