完成 Phase 5 生产环境加固：单元测试、性能测试、基准测试、CI配置

Author: Developer

.github/workflows/tests.yml

@@ -0,0 +1,37 @@
+name: BSText Tests
+
+on:
+  push:
+    branches: [ main, dev, dev/v3.0 ]
+  pull_request:
+    branches: [ main, dev, dev/v3.0 ]
+
+jobs:
+  test:
+    name: Test on Xcode
+    runs-on: macos-latest
+    
+    strategy:
+      matrix:
+        platform: [iOS]
+        xcode: [latest-stable]
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v4
+      
+    - name: Set up Xcode
+      uses: maxim-lobanov/setup-xcode@v1
+      with:
+        xcode-version: ${{ matrix.xcode }}
+        
+    - name: Build and test
+      run: |
+        set -o pipefail
+        xcodebuild -scheme BSText -destination 'platform=iOS Simulator,name=iPhone 15,OS=latest' -enableCodeCoverage YES clean test | xcpretty
+        
+    - name: Upload coverage
+      uses: codecov/codecov-action@v4
+      with:
+        file: ./coverage.xml
+        flags: unittests

BSTextTests/BSTextBenchmark.swift

@@ -0,0 +1,207 @@
+import Foundation
+@testable import BSText
+
+public struct BenchmarkResult {
+    let name: String
+    let iterations: Int
+    let totalTime: TimeInterval
+    let averageTime: TimeInterval
+    let minTime: TimeInterval
+    let maxTime: TimeInterval
+}
+
+public class BSTextBenchmark {
+    
+    public static let shared = BSTextBenchmark()
+    
+    private init() {}
+    
+    public func measure(name: String, iterations: Int = 100, block: () throws -> Void) rethrows -> BenchmarkResult {
+        var times: [TimeInterval] = []
+        times.reserveCapacity(iterations)
+        
+        for _ in 0..<iterations {
+            let start = Date()
+            try block()
+            let end = Date()
+            let time = end.timeIntervalSince(start)
+            times.append(time)
+        }
+        
+        let totalTime = times.reduce(0, +)
+        let averageTime = totalTime / Double(iterations)
+        let minTime = times.min() ?? 0
+        let maxTime = times.max() ?? 0
+        
+        return BenchmarkResult(
+            name: name,
+            iterations: iterations,
+            totalTime: totalTime,
+            averageTime: averageTime,
+            minTime: minTime,
+            maxTime: maxTime
+        )
+    }
+    
+    public func printResult(_ result: BenchmarkResult) {
+        print("""
+        ===== Benchmark: \(result.name) =====
+        Iterations: \(result.iterations)
+        Total Time: \(String(format: "%.4f", result.totalTime))s
+        Average Time: \(String(format: "%.6f", result.averageTime))s
+        Min Time: \(String(format: "%.6f", result.minTime))s
+        Max Time: \(String(format: "%.6f", result.maxTime))s
+        """)
+    }
+}
+
+public class BSTextMemoryMonitor {
+    
+    public static func getMemoryUsage() -> UInt64? {
+        var info = mach_task_basic_info()
+        var count = mach_msg_type_number_t(MemoryLayout<mach_task_basic_info>.size)/4
+        
+        let result = withUnsafeMutablePointer(to: &info) {
+            $0.withMemoryRebound(to: integer_t.self, capacity: 1) {
+                task_info(mach_task_self_, task_flavor_t(MACH_TASK_BASIC_INFO), $0, &count)
+            }
+        }
+        
+        guard result == KERN_SUCCESS else {
+            return nil
+        }
+        
+        return info.resident_size
+    }
+    
+    public static func formatMemory(_ bytes: UInt64) -> String {
+        let kb = Double(bytes) / 1024.0
+        let mb = kb / 1024.0
+        let gb = mb / 1024.0
+        
+        if gb >= 1 {
+            return String(format: "%.2f GB", gb)
+        } else if mb >= 1 {
+            return String(format: "%.2f MB", mb)
+        } else if kb >= 1 {
+            return String(format: "%.2f KB", kb)
+        } else {
+            return String(format: "%d bytes", bytes)
+        }
+    }
+    
+    public static func measureMemory(name: String, block: () throws -> Void) rethrows {
+        let before = getMemoryUsage() ?? 0
+        print("Before \(name): \(formatMemory(before))")
+        
+        try block()
+        
+        let after = getMemoryUsage() ?? 0
+        print("After \(name): \(formatMemory(after))")
+        
+        let diff = Int64(after) - Int64(before)
+        if diff > 0 {
+            print("Memory increase: +\(formatMemory(UInt64(diff)))")
+        } else if diff < 0 {
+            print("Memory decrease: \(formatMemory(UInt64(abs(diff))))")
+        } else {
+            print("No memory change")
+        }
+    }
+}
+
+public class BSTextProfilingHelper {
+    
+    public static func profileTextViewPerformance() {
+        print("\n===== BSText Performance Benchmarks =====\n")
+        
+        let benchmark = BSTextBenchmark.shared
+        
+        let textViewResult = benchmark.measure(name: "BSTextView Initialization", iterations: 1000) {
+            _ = BSTextView(frame: CGRect(x: 0, y: 0, width: 320, height: 200))
+        }
+        benchmark.printResult(textViewResult)
+        
+        let textView = BSTextView(frame: CGRect(x: 0, y: 0, width: 320, height: 200))
+        let largeText = (0..<1000).map { "Line \($0): Test content\n" }.joined()
+        
+        let setTextResult = benchmark.measure(name: "BSTextView Set Text", iterations: 100) {
+            textView.text = largeText
+        }
+        benchmark.printResult(setTextResult)
+        
+        let sizeThatFitsResult = benchmark.measure(name: "BSTextView Size That Fits", iterations: 100) {
+            _ = textView.sizeThatFits(CGSize(width: 320, height: CGFloat.greatestFiniteMagnitude))
+        }
+        benchmark.printResult(sizeThatFitsResult)
+    }
+    
+    public static func profileMarkdownPerformance() {
+        print("\n===== Markdown Performance Benchmarks =====\n")
+        
+        let benchmark = BSTextBenchmark.shared
+        let parser = BSTextMarkdownParser()
+        
+        let simpleMarkdown = "# Heading\n**Bold** *italic*\n- List item\n- Another item"
+        let simpleResult = benchmark.measure(name: "Simple Markdown Parsing", iterations: 1000) {
+            _ = parser.parse(simpleMarkdown)
+        }
+        benchmark.printResult(simpleResult)
+        
+        let largeMarkdown = (0..<100).map { 
+            "# Heading \($0)\n**Bold** *italic* `code`\n- List item 1\n- List item 2\n\n" 
+        }.joined()
+        
+        let largeResult = benchmark.measure(name: "Large Markdown Parsing", iterations: 100) {
+            _ = parser.parse(largeMarkdown)
+        }
+        benchmark.printResult(largeResult)
+    }
+    
+    public static func profileSyntaxPerformance() {
+        print("\n===== Syntax Highlighting Performance Benchmarks =====\n")
+        
+        let benchmark = BSTextBenchmark.shared
+        let parser = BSTextSyntaxParser()
+        
+        let simpleCode = """
+        let x = 5
+        func hello() {
+            print("world")
+        }
+        """
+        
+        parser.language = .swift
+        let simpleSwiftResult = benchmark.measure(name: "Simple Swift Syntax Highlighting", iterations: 1000) {
+            _ = parser.parse(simpleCode)
+        }
+        benchmark.printResult(simpleSwiftResult)
+        
+        let largeCode = (0..<50).map {
+            """
+            func function\($0)(param: String) -> String {
+                let result = "Result: \\(param)"
+                return result
+            }
+            """
+        }.joined(separator: "\n\n")
+        
+        let largeSwiftResult = benchmark.measure(name: "Large Swift Syntax Highlighting", iterations: 100) {
+            _ = parser.parse(largeCode)
+        }
+        benchmark.printResult(largeSwiftResult)
+    }
+    
+    public static func profileMemoryUsage() {
+        print("\n===== Memory Usage Benchmarks =====\n")
+        
+        BSTextMemoryMonitor.measureMemory(name: "Create BSTextView") {
+            _ = BSTextView(frame: CGRect(x: 0, y: 0, width: 320, height: 200))
+        }
+        
+        BSTextMemoryMonitor.measureMemory(name: "Create Large Text Content") {
+            let textView = BSTextView(frame: CGRect(x: 0, y: 0, width: 320, height: 200))
+            textView.text = (0..<10000).map { "Line \($0)\n" }.joined()
+        }
+    }
+}

BSTextTests/BSTextCoreTests.swift

@@ -0,0 +1,128 @@
+import XCTest
+@testable import BSText
+
+final class BSTextCoreTests: XCTestCase {
+    
+    var textView: BSTextView!
+    
+    override func setUp() {
+        super.setUp()
+        textView = BSTextView(frame: CGRect(x: 0, y: 0, width: 320, height: 200))
+    }
+    
+    override func tearDown() {
+        textView = nil
+        super.tearDown()
+    }
+    
+    func testTextViewInitialization() {
+        XCTAssertNotNil(textView)
+        XCTAssertEqual(textView.backgroundColor, .systemBackground)
+    }
+    
+    func testTextEditing() {
+        let testText = "Hello, BSText!"
+        textView.text = testText
+        
+        XCTAssertEqual(textView.text, testText)
+    }
+    
+    func testTextReplacement() {
+        textView.text = "Hello, World!"
+        textView.selectedRange = NSRange(location: 7, length: 5)
+        textView.replaceSelection(with: "BSText")
+        
+        XCTAssertEqual(textView.text, "Hello, BSText!")
+    }
+    
+    func testClearAllText() {
+        textView.text = "Hello, World!"
+        textView.clearAllText()
+        
+        XCTAssertEqual(textView.text, "")
+    }
+    
+    func testSelectAllText() {
+        textView.text = "Hello, World!"
+        textView.selectAllText()
+        
+        XCTAssertEqual(textView.selectedRange, NSRange(location: 0, length: textView.text.count))
+    }
+    
+    func testVisibleFragmentCount() {
+        textView.text = "Line 1\nLine 2\nLine 3\nLine 4\nLine 5"
+        let count = textView.visibleFragmentCount
+        XCTAssertGreaterThanOrEqual(count, 0)
+    }
+}
+
+final class BSTextContentStorageTests: XCTestCase {
+    
+    var contentStorage: BSTextContentStorage!
+    
+    override func setUp() {
+        super.setUp()
+        contentStorage = BSTextContentStorage()
+    }
+    
+    override func tearDown() {
+        contentStorage = nil
+        super.tearDown()
+    }
+    
+    func testContentStorageInitialization() {
+        XCTAssertNotNil(contentStorage)
+    }
+    
+    func testTextStorageDelegation() {
+        contentStorage.string = "Test Text"
+        XCTAssertEqual(contentStorage.string, "Test Text")
+    }
+}
+
+final class BSTextCacheTests: XCTestCase {
+    
+    var cache: BSTextCache!
+    
+    override func setUp() {
+        super.setUp()
+        cache = BSTextCache()
+    }
+    
+    override func tearDown() {
+        cache = nil
+        super.tearDown()
+    }
+    
+    func testCacheInitialization() {
+        XCTAssertNotNil(cache)
+    }
+    
+    func testCacheSetAndGet() {
+        let key = "testKey"
+        let value = "testValue"
+        
+        cache.setObject(value as AnyObject, forKey: key)
+        
+        let retrievedValue = cache.object(forKey: key) as? String
+        XCTAssertEqual(retrievedValue, value)
+    }
+    
+    func testCacheRemove() {
+        let key = "testKey"
+        cache.setObject("value" as AnyObject, forKey: key)
+        cache.removeObject(forKey: key)
+        
+        let retrievedValue = cache.object(forKey: key)
+        XCTAssertNil(retrievedValue)
+    }
+    
+    func testCacheRemoveAll() {
+        cache.setObject("value1" as AnyObject, forKey: "key1")
+        cache.setObject("value2" as AnyObject, forKey: "key2")
+        cache.removeAllObjects()
+        
+        XCTAssertNil(cache.object(forKey: "key1"))
+        XCTAssertNil(cache.object(forKey: "key2"))
+    }
+}