Hamcrest

// 1. 核心匹配器接口 (泛型)
interface Matcher<T> {
    func matches(item: T): Bool
    func describeMismatch(item: T, description: Description): Unit
    func toDescription(): String
}

// 2. 描述器 (用于生成错误信息)
class Description {
    private var text: StringBuilder
    
    func appendText(text: String): Description {
        this.text.append(text)
        return this
    }
    
    func appendValue(value: Any): Description {
        this.text.append(ValueFormatter.format(value))
        return this
    }
    
    func toString(): String {
        return this.text.toString()
    }
}

// 3. 基础匹配器实现示例 (相等)
class IsEqual<T>: Matcher<T> {
    private var expected: T
    
    init(expected: T) {
        self.expected = expected
    }
    
    func matches(item: T): Bool {
        return item == this.expected // 利用仓颉 Equatable 协议
    }
    
    func describeMismatch(item: T, description: Description): Unit {
        description.appendText("was ").appendValue(item)
    }
    
    static func equalTo<T>(value: T): Matcher<T> {
        return IsEqual(value)
    }
}

// 4. 组合匹配器 (And)
class AllOf<T>: Matcher<T> {
    private var matchers: List<Matcher<T>>
    
    init(matchers: List<Matcher<T>>) {
        self.matchers = matchers
    }
    
    func matches(item: T): Bool {
        // 短路求值
        for m in this.matchers {
            if (!m.matches(item)) {
                return false
            }
        }
        return true
    }
    
    func describeMismatch(item: T, description: Description): Unit {
        description.appendText("all of ")
        for i in 0..<this.matchers.size() {
            if (!this.matchers[i].matches(item)) {
                this.matchers[i].describeMismatch(item, description)
                break
            }
        }
    }
    
    static func allOf<T>(matchers: List<Matcher<T>>): Matcher<T> {
        return AllOf(matchers)
    }
}

// 5. 集合匹配器 (包含元素)
class ContainsElement<T>: Matcher<List<T>> {
    private var matcher: Matcher<T>
    
    init(matcher: Matcher<T>) {
        self.matcher = matcher
    }
    
    func matches(item: List<T>): Bool {
        for elem in item {
            if (this.matcher.matches(elem)) {
                return true
            }
        }
        return false
    }
    
    func describeMismatch(item: List<T>, description: Description): Unit {
        description.appendText("did not contain an item matching ").appendText(this.matcher.toDescription())
    }
    
    static func hasItem<T>(matcher: Matcher<T>): Matcher<List<T>> {
        return ContainsElement(matcher)
    }
}

// 6. 业务场景示例：用户订单测试
struct Order {
    let id: String
    let status: String
    let items: List<OrderItem>
    let totalAmount: Double
}

func testOrderValidation() {
    let order = Order(id: "1001", status: "PAID", items: [...], totalAmount: 99.9)
    
    // 链式组合断言，编译期类型安全
    let orderMatcher: Matcher<Order> = AllOf.allOf([
        // 检查 ID
        IsEqual.equalTo("1001"), 
        // 检查状态
        IsEqual.equalTo("PAID"), 
        // 检查总金额 (自定义数值范围匹配器)
        NumberMatchers.closeTo(99.9, 0.01),
        // 检查包含特定商品 (嵌套匹配)
        CollectionMatchers.hasItem(
            ItemMatchers.hasProperty("name", IsEqual.equalTo("Laptop"))
        )
    ])
    
    // 执行断言
    if (!orderMatcher.matches(order)) {
        let desc = Description()
        orderMatcher.describeMismatch(order, desc)
        print("Assertion Failed: \(desc.toString())")
    }
}

# PR 自动化流水线
cjpm fmt --check
cjpm build --release
cjpm lint --deny-warnings
cjpm test --coverage --min-coverage 95
cjpm bench --threshold 10% # 确保性能不回退