18d - PBT 深度指南

传统单元测试（Example-Based Testing）：
  test("1 + 1 = 2")           → 只验证一个具体例子
  test("sort([3,1,2]) = [1,2,3]") → 只验证一个具体输入

Property-Based Testing：
  test("对于任意 a, b: a + b = b + a")       → 验证所有输入的交换律
  test("对于任意列表 xs: sort(xs) 是有序的")  → 验证排序的普遍属性

┌──────────────┐     ┌──────────────┐     ┌──────────────┐
│  定义属性     │     │  生成输入     │     │  检验属性     │
│  (Property)  │────▶│  (Generator) │────▶│  (Assertion)  │
└──────────────┘     └──────────────┘     └──────────────┘
                                                 │
                                          通过？  │  失败？
                                          ┌──────┴──────┐
                                          ▼             ▼
                                     增加样本数     ┌──────────┐
                                     继续测试      │  收缩     │
                                                   │ (Shrink)  │
                                                   └────┬─────┘
                                                        ▼
                                                   最小反例
                                                (Minimal Counter-example)

import fc from 'fast-check';
 
// 安装：npm install fast-check --save-dev
 
// 基本属性测试
test('排序后数组是有序的', () => {
  fc.assert(
    fc.property(
      fc.array(fc.integer()),  // 生成器：整数数组
      (arr) => {               // 属性：排序后有序
        const sorted = arr.slice().sort((a, b) => a - b);
        for (let i = 1; i < sorted.length; i++) {
          expect(sorted[i]).toBeGreaterThanOrEqual(sorted[i - 1]);
        }
      }
    )
  );
});

from hypothesis import given, strategies as st
 
# 安装：pip install hypothesis
 
# 基本属性测试
@given(st.lists(st.integers()))
def test_sort_preserves_length(xs):
    """排序不改变列表长度"""
    assert len(sorted(xs)) == len(xs)
 
@given(st.lists(st.integers()))
def test_sort_is_idempotent(xs):
    """排序是幂等的"""
    assert sorted(sorted(xs)) == sorted(xs)

// Cargo.toml: proptest = "1.6"
use proptest::prelude::*;
 
proptest! {
    /// 排序后数组是有序的
    #[test]
    fn sort_produces_ordered_output(mut vec in prop::collection::vec(any::<i32>(), 0..100)) {
        vec.sort();
        for window in vec.windows(2) {
            prop_assert!(window[0] <= window[1]);
        }
    }
}

-- 安装：cabal install QuickCheck
import Test.QuickCheck
 
-- 排序后数组是有序的
prop_sortOrdered :: [Int] -> Bool
prop_sortOrdered xs = isOrdered (sort xs)
  where isOrdered []       = True
        isOrdered [_]      = True
        isOrdered (a:b:cs) = a <= b && isOrdered (b:cs)
 
-- 运行：quickCheck prop_sortOrdered

// build.gradle: testImplementation 'net.jqwik:jqwik:1.9.2'
import net.jqwik.api.*;
 
class SortProperties {
    @Property
    void sortPreservesLength(@ForAll List<Integer> list) {
        List<Integer> sorted = new ArrayList<>(list);
        Collections.sort(sorted);
        Assertions.assertEquals(list.size(), sorted.size());
    }
}

import fc from 'fast-check';
 
// 1. 基础组合：从简单生成器构建复杂生成器
const emailArb = fc.tuple(
  fc.stringMatching(/^[a-z]{1,20}$/),      // 用户名
  fc.constantFrom('gmail.com', 'outlook.com', 'company.cn')  // 域名
).map(([user, domain]) => `${user}@${domain}`);
 
// 2. 关联约束：索引不超出数组长度
const indexedArrayArb = fc.array(fc.integer(), { minLength: 1 }).chain(
  (arr) => fc.tuple(
    fc.constant(arr),
    fc.integer({ min: 0, max: arr.length - 1 })  // 索引约束在数组范围内
  )
);
 
// 3. 权重偏向：增加边缘值的生成概率
const amountArb = fc.oneof(
  { weight: 1, arbitrary: fc.constant(0) },           // 零值
  { weight: 1, arbitrary: fc.constant(0.01) },         // 最小正值
  { weight: 1, arbitrary: fc.constant(Number.MAX_SAFE_INTEGER) }, // 极大值
  { weight: 7, arbitrary: fc.double({ min: 0.01, max: 1000000, noNaN: true }) }  // 正常范围
);
 
// 4. 递归生成器：树结构
const treeArb: fc.Arbitrary<Tree> = fc.letrec((tie) => ({
  tree: fc.oneof(
    { weight: 1, arbitrary: fc.record({ value: fc.integer(), children: fc.constant([]) }) },
    { weight: 2, arbitrary: fc.record({
      value: fc.integer(),
      children: fc.array(tie('tree'), { minLength: 1, maxLength: 3 })
    })}
  )
})).tree;

from hypothesis import strategies as st, given, assume
 
# 1. 复合策略：构建领域对象
user_strategy = st.builds(
    User,
    name=st.text(min_size=1, max_size=50, alphabet=st.characters(
        whitelist_categories=('L', 'N', 'Z')  # 字母、数字、空格
    )),
    age=st.integers(min_value=0, max_value=150),
    email=st.emails()
)
 
# 2. filter + assume：过滤无效输入
@given(st.lists(st.integers(), min_size=1))
def test_max_is_in_list(xs):
    assume(len(set(xs)) > 0)  # 过滤空集
    result = max(xs)
    assert result in xs
 
# 3. flatmap（链式生成）：关联约束
@given(
    st.integers(min_value=1, max_value=100).flatmap(
        lambda n: st.tuples(
            st.just(n),
            st.lists(st.integers(), min_size=n, max_size=n)
        )
    )
)
def test_list_has_expected_length(args):
    n, xs = args
    assert len(xs) == n
 
# 4. 递归策略：JSON 值
json_strategy = st.recursive(
    st.none() | st.booleans() | st.floats(allow_nan=False) | st.text(),
    lambda children: st.lists(children) | st.dictionaries(st.text(), children),
    max_leaves=50
)

use proptest::prelude::*;
 
// 1. 自定义 Strategy：有效的 HTTP 状态码
fn http_status_code() -> impl Strategy<Value = u16> {
    prop_oneof![
        1 => Just(200u16),        // 成功
        1 => Just(404),           // 未找到
        1 => Just(500),           // 服务器错误
        7 => (100u16..600),       // 一般范围
    ]
}
 
// 2. prop_compose!：构建复杂类型
prop_compose! {
    fn valid_file_path()(
        segments in prop::collection::vec("[a-z]{1,10}", 1..5),
        ext in prop_oneof![Just("txt"), Just("rs"), Just("md")]
    ) -> String {
        format!("{}.{}", segments.join("/"), ext)
    }
}
 
// 3. 关联约束：缓冲区和偏移量
prop_compose! {
    fn buffer_with_offset()(
        data in prop::collection::vec(any::<u8>(), 1..1024)
    )(
        offset in 0..data.len(),
        data in Just(data)
    ) -> (Vec<u8>, usize) {
        (data, offset)
    }
}
 
proptest! {
    #[test]
    fn read_at_offset_is_safe((data, offset) in buffer_with_offset()) {
        // offset 保证在 data 范围内，不会越界
        let _byte = data[offset];
    }
}

import net.jqwik.api.*;
 
class GeneratorExamples {
 
    // 1. 自定义 Arbitrary 提供者
    @Provide
    Arbitrary<String> validEmails() {
        Arbitrary<String> users = Arbitraries.strings()
            .alpha().ofMinLength(1).ofMaxLength(20);
        Arbitrary<String> domains = Arbitraries.of(
            "gmail.com", "outlook.com", "company.cn"
        );
        return Combinators.combine(users, domains)
            .as((user, domain) -> user + "@" + domain);
    }
 
    @Property
    void emailContainsAtSign(@ForAll("validEmails") String email) {
        Assertions.assertTrue(email.contains("@"));
    }
 
    // 2. 带约束的组合
    @Provide
    Arbitrary<List<Integer>> sortedLists() {
        return Arbitraries.integers().between(-1000, 1000)
            .list().ofMinSize(1).ofMaxSize(50)
            .map(list -> {
                Collections.sort(list);
                return list;
            });
    }
}

你是一位 PBT 专家。为以下函数设计智能生成器。

## 待测函数签名
[粘贴函数签名和类型定义]

## 前置条件
[列出输入的约束条件]

## 要求
1. 使用 [fast-check / Hypothesis / proptest / jqwik] 框架
2. 生成器必须：
   - 只生成满足前置条件的输入
   - 包含边缘值（空、零、极值）的权重偏向
   - 多个参数之间的关联约束正确
3. 不要使用 filter/assume 丢弃超过 20% 的输入
4. 为每个生成器添加注释说明设计意图

发现失败输入：[42, -7, 0, 1000, -3, 8, 15]
                    │
                    ▼ 尝试简化
            [42, -7, 0, 1000]  → 仍然失败
                    │
                    ▼ 继续简化
            [-7, 0, 1000]     → 仍然失败
                    │
                    ▼ 继续简化
            [0, 1000]         → 仍然失败
                    │
                    ▼ 尝试简化值
            [0, 1]            → 通过了！回退
                    │
                    ▼ 最终结果
            [0, 1000]         → 最小反例！

import fc from 'fast-check';
 
// 自定义 Arbitrary：保证收缩后仍满足约束
// 示例：生成偶数，收缩时也保持偶数
const evenIntArb = fc.integer({ min: -1000, max: 1000 })
  .map(n => n % 2 === 0 ? n : n + 1)  // 映射为偶数
  // fast-check 的集成收缩会自动处理：
  // 收缩 integer → 映射为偶数 → 收缩后仍是偶数

from hypothesis import strategies as st
 
# Hypothesis 的收缩是自动的，但可以通过策略设计引导收缩方向
@st.composite
def sorted_pairs(draw):
    """生成有序对 (a, b)，其中 a <= b，收缩时保持有序"""
    a = draw(st.integers(min_value=0, max_value=100))
    b = draw(st.integers(min_value=a, max_value=a + 100))
    return (a, b)
    # Hypothesis 会分别收缩 a 和 b，但 b 的范围依赖 a，
    # 所以收缩后 a <= b 始终成立

use proptest::prelude::*;
use proptest::strategy::{NewTree, ValueTree};
use proptest::test_runner::TestRunner;
 
// proptest 的收缩基于 ValueTree
// 每个 Strategy 生成一个 ValueTree，ValueTree 知道如何收缩自己
 
// 大多数情况下，使用 prop_compose! 和内置组合子即可获得良好的收缩
// 只有在需要精确控制收缩行为时才需要手动实现 ValueTree
 
// 示例：使用 prop_filter_map 在收缩时保持约束
fn non_empty_sorted_vec() -> impl Strategy<Value = Vec<i32>> {
    prop::collection::vec(any::<i32>(), 1..50)
        .prop_map(|mut v| { v.sort(); v })
    // prop_map 保证收缩后的值也会经过排序
}

-- QuickCheck 要求为自定义类型实现 Arbitrary（含 shrink）
data Interval = Interval Int Int  -- (lo, hi) 其中 lo <= hi
 
instance Arbitrary Interval where
  arbitrary = do
    lo <- choose (-100, 100)
    hi <- choose (lo, lo + 100)
    return (Interval lo hi)
 
  shrink (Interval lo hi) =
    -- 收缩策略：尝试缩小范围，保持 lo <= hi
    [ Interval lo' hi' | lo' <- shrink lo, hi' <- shrink hi, lo' <= hi' ]
    ++ [ Interval lo hi' | hi' <- [lo .. hi - 1] ]  -- 缩小上界
    ++ [ Interval lo' hi | lo' <- [lo + 1 .. hi] ]  -- 增大下界

// TypeScript + fast-check
// Validates: Requirements - 数据完整性
import fc from 'fast-check';
 
// 生成器：模拟 API 响应对象
const apiResponseArb = fc.record({
  id: fc.uuid(),
  name: fc.string({ minLength: 0, maxLength: 200 }),
  score: fc.double({ min: -1e10, max: 1e10, noNaN: true, noDefaultInfinity: true }),
  tags: fc.array(fc.string(), { maxLength: 10 }),
  metadata: fc.dictionary(
    fc.stringMatching(/^[a-z_]{1,20}$/),
    fc.oneof(fc.string(), fc.integer(), fc.boolean())
  )
});
 
test('JSON 序列化往返保持数据不变', () => {
  fc.assert(
    fc.property(apiResponseArb, (response) => {
      const serialized = JSON.stringify(response);
      const deserialized = JSON.parse(serialized);
      expect(deserialized).toEqual(response);
    })
  );
});

// Rust + proptest
// Validates: Requirements - 数据完整性
use proptest::prelude::*;
use serde::{Serialize, Deserialize};
 
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
struct Config {
    name: String,
    port: u16,
    debug: bool,
}
 
proptest! {
    #[test]
    fn config_roundtrip(
        name in "[a-zA-Z0-9_]{1,50}",
        port in any::<u16>(),
        debug in any::<bool>()
    ) {
        let config = Config { name, port, debug };
        let json = serde_json::to_string(&config).unwrap();
        let restored: Config = serde_json::from_str(&json).unwrap();
        prop_assert_eq!(config, restored);
    }
}

# Python + Hypothesis
# Validates: Requirements - 排序正确性
from hypothesis import given, strategies as st
from collections import Counter
 
@given(st.lists(st.integers(min_value=-10000, max_value=10000)))
def test_sort_is_ordered(xs):
    """排序后相邻元素满足 a <= b"""
    result = sorted(xs)
    for i in range(len(result) - 1):
        assert result[i] <= result[i + 1]
 
@given(st.lists(st.integers()))
def test_sort_preserves_elements(xs):
    """排序不增加也不丢失元素"""
    result = sorted(xs)
    assert Counter(result) == Counter(xs)
 
@given(st.lists(st.integers()))
def test_sort_is_idempotent(xs):
    """排序两次与排序一次结果相同"""
    assert sorted(sorted(xs)) == sorted(xs)

// TypeScript + fast-check
// Validates: Requirements - 状态流转正确性
 
type OrderState = 'created' | 'paid' | 'shipped' | 'delivered' | 'cancelled';
 
const VALID_TRANSITIONS: Record<OrderState, OrderState[]> = {
  created:   ['paid', 'cancelled'],
  paid:      ['shipped', 'cancelled'],
  shipped:   ['delivered'],
  delivered: [],
  cancelled: [],
};
 
function transition(current: OrderState, next: OrderState): OrderState {
  if (VALID_TRANSITIONS[current].includes(next)) return next;
  throw new Error(`Invalid transition: ${current} -> ${next}`);
}
 
const orderStateArb = fc.constantFrom<OrderState>(
  'created', 'paid', 'shipped', 'delivered', 'cancelled'
);
 
test('合法转换总是成功', () => {
  fc.assert(
    fc.property(orderStateArb, (state) => {
      for (const next of VALID_TRANSITIONS[state]) {
        expect(transition(state, next)).toBe(next);
      }
    })
  );
});
 
test('非法转换总是抛出异常', () => {
  fc.assert(
    fc.property(
      orderStateArb,
      orderStateArb,
      (current, next) => {
        if (!VALID_TRANSITIONS[current].includes(next)) {
          expect(() => transition(current, next)).toThrow();
        }
      }
    )
  );
});

// Java + jqwik
// Validates: Requirements - 价格计算正确性
import net.jqwik.api.*;
 
class PricingProperties {
 
    @Property
    void discountNeverExceedsOriginalPrice(
        @ForAll @DoubleRange(min = 0.01, max = 100000) double price,
        @ForAll @DoubleRange(min = 0, max = 1) double discountRate
    ) {
        double discounted = price * (1 - discountRate);
        Assertions.assertTrue(discounted >= 0,
            "折扣后价格不能为负");
        Assertions.assertTrue(discounted <= price,
            "折扣后价格不能超过原价");
    }
 
    @Property
    void taxCalculationIsAdditive(
        @ForAll @DoubleRange(min = 0.01, max = 10000) double price,
        @ForAll @DoubleRange(min = 0, max = 0.5) double taxRate
    ) {
        double withTax = price * (1 + taxRate);
        double tax = withTax - price;
        // 税额应等于 price * taxRate（允许浮点误差）
        Assertions.assertTrue(Math.abs(tax - price * taxRate) < 0.01,
            "税额计算误差超出允许范围");
    }
}

// Rust + proptest
// Validates: Requirements - 数据结构正确性
use proptest::prelude::*;
use std::collections::BTreeSet;
 
/// 属性：BTreeSet 的插入和删除操作后，集合语义正确
proptest! {
    #[test]
    fn btreeset_insert_contains(values in prop::collection::vec(any::<i32>(), 0..100)) {
        let mut set = BTreeSet::new();
        for &v in &values {
            set.insert(v);
            // 插入后必须能查到
            prop_assert!(set.contains(&v));
        }
        // 集合大小不超过插入的去重数量
        let unique: BTreeSet<_> = values.iter().collect();
        prop_assert_eq!(set.len(), unique.len());
    }
 
    #[test]
    fn btreeset_remove_consistency(
        inserts in prop::collection::vec(any::<i32>(), 1..50),
        removes in prop::collection::vec(any::<i32>(), 0..30)
    ) {
        let mut set = BTreeSet::new();
        for &v in &inserts {
            set.insert(v);
        }
        for &v in &removes {
            set.remove(&v);
            // 删除后必须查不到
            prop_assert!(!set.contains(&v));
        }
    }
}

# Python + Hypothesis
# Validates: Requirements - 编解码正确性
import base64
from hypothesis import given, strategies as st
 
@given(st.binary(min_size=0, max_size=10000))
def test_base64_roundtrip(data):
    """Base64 编码后解码得到原始数据"""
    encoded = base64.b64encode(data)
    decoded = base64.b64decode(encoded)
    assert decoded == data
 
@given(st.binary(min_size=0, max_size=1000))
def test_base64_output_is_valid(data):
    """Base64 编码结果只包含合法字符"""
    encoded = base64.b64encode(data)
    valid_chars = set(b'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=')
    assert all(byte in valid_chars for byte in encoded)
 
@given(st.binary())
def test_base64_length_formula(data):
    """Base64 编码长度满足数学公式"""
    encoded = base64.b64encode(data)
    expected_len = 4 * ((len(data) + 2) // 3)  # 向上取整到 4 的倍数
    assert len(encoded) == expected_len

// Rust + proptest
// Validates: Requirements - 并发安全性
use proptest::prelude::*;
use std::sync::{Arc, Mutex};
use std::thread;
 
proptest! {
    #[test]
    fn concurrent_counter_is_consistent(
        increments in prop::collection::vec(1..100i64, 1..20),
    ) {
        let counter = Arc::new(Mutex::new(0i64));
        let expected_sum: i64 = increments.iter().sum();
 
        let handles: Vec<_> = increments.into_iter().map(|inc| {
            let counter = Arc::clone(&counter);
            thread::spawn(move || {
                let mut val = counter.lock().unwrap();
                *val += inc;
            })
        }).collect();
 
        for h in handles {
            h.join().unwrap();
        }
 
        let final_value = *counter.lock().unwrap();
        // 无论线程执行顺序如何，最终值必须等于所有增量之和
        prop_assert_eq!(final_value, expected_sum);
    }
}

┌─────────────────┐     ┌─────────────────┐     ┌─────────────────┐
│ requirements.md │     │   design.md     │     │   tasks.md      │
│ 定义验收标准     │────▶│ 提取正确性属性   │────▶│ 生成测试任务     │
└─────────────────┘     └─────────────────┘     └─────────────────┘
                                                        │
                                                        ▼
                                                ┌─────────────────┐
                                                │ Kiro 自动执行    │
                                                │ 1. 读取属性定义   │
                                                │ 2. 分析代码签名   │
                                                │ 3. 选择 PBT 框架  │
                                                │ 4. 设计生成器     │
                                                │ 5. 生成测试代码   │
                                                │ 6. 运行测试       │
                                                │ 7. 分析反例       │
                                                └─────────────────┘
                                                        │
                                              ┌─────────┼─────────┐
                                              ▼         ▼         ▼
                                          代码 bug   测试 bug   spec 问题
                                          修复代码   修复测试   提示用户

## Correctness Properties
 
Property 1: 哈希确定性
- 对于任意文件内容 content，hash(content) 在多次计算中必须返回相同结果
- Validates: Requirement 3, Criteria 2
 
Property 2: 同步幂等性
- 对于任意文件集合 files，如果本地和远程完全相同，
  computeSyncPlan(files, files) 的操作列表必须为空
- Validates: Requirement 3, Criteria 2

- [ ] 5.1 实现 Property 1 的 PBT（哈希确定性）
- [ ] 5.2 实现 Property 2 的 PBT（同步幂等性）

基于以下 design.md 中的正确性属性，生成 Property-Based Test。

## 正确性属性
[粘贴 design.md 中的 Correctness Properties 部分]

## 待测代码
[粘贴相关代码文件]

## 要求
1. 使用 [fast-check / proptest / Hypothesis] 框架
2. 每个属性标注 "Validates: Requirements X.Y"
3. 生成器约束到有意义的输入空间
4. 不使用 mock，测试真实逻辑
5. 包含边缘值权重偏向

1. 文件哈希必须是确定性的——相同内容总是产生相同哈希
2. 同步计划必须是幂等的——已同步的文件不应再次同步
3. 忽略规则必须是一致的——同一路径的判断结果不变
4. 同步操作必须保持文件完整性——同步后文件内容不变

use proptest::prelude::*;
 
proptest! {
    /// Property: 文件哈希的确定性
    /// Validates: Requirements 1
    #[test]
    fn hash_is_deterministic(
        content in prop::collection::vec(any::<u8>(), 0..10000)
    ) {
        let hash1 = compute_hash(&content);
        let hash2 = compute_hash(&content);
        prop_assert_eq!(hash1, hash2, "同一内容的哈希必须相同");
    }
 
    /// Property: 不同内容大概率产生不同哈希（抗碰撞）
    /// Validates: Requirements 1
    #[test]
    fn hash_collision_resistance(
        content1 in prop::collection::vec(any::<u8>(), 1..1000),
        content2 in prop::collection::vec(any::<u8>(), 1..1000),
    ) {
        prop_assume!(content1 != content2);
        let hash1 = compute_hash(&content1);
        let hash2 = compute_hash(&content2);
        // 不同内容应产生不同哈希（极小概率碰撞可接受）
        prop_assert_ne!(hash1, hash2);
    }
 
    /// Property: 忽略规则的一致性
    /// Validates: Requirements 3
    #[test]
    fn ignore_rules_are_consistent(
        path in "[a-z]{1,10}(/[a-z]{1,10}){0,5}",
        pattern in "(\\*\\.[a-z]{1,4}|[a-z]+/)"
    ) {
        let engine = IgnoreEngine::new(vec![pattern.clone()]);
        let result1 = engine.should_ignore(&path);
        let result2 = engine.should_ignore(&path);
        prop_assert_eq!(result1, result2, "同一路径的忽略判断必须一致");
    }
}

import fc from 'fast-check';
import { computeSyncPlan, SyncFile } from '../src/sync';
 
// 生成器：模拟文件系统中的文件
const syncFileArb = fc.record({
  path: fc.stringMatching(/^[a-z]{1,10}(\/[a-z]{1,10}){0,3}\.[a-z]{2,4}$/),
  content: fc.string({ maxLength: 1000 }),
  hash: fc.hexaString({ minLength: 64, maxLength: 64 }),
  modifiedAt: fc.date({ min: new Date('2020-01-01'), max: new Date('2026-12-31') })
});
 
describe('SyncEngine Properties', () => {
  // Property: 同步计划的幂等性
  // Validates: Requirements 2
  test('已同步的文件不产生同步操作', () => {
    fc.assert(
      fc.property(
        fc.array(syncFileArb, { minLength: 0, maxLength: 20 }),
        (files) => {
          // 本地和远程完全相同时，同步计划应为空
          const plan = computeSyncPlan(files, files);
          expect(plan.actions).toHaveLength(0);
        }
      )
    );
  });
 
  // Property: 同步计划覆盖所有差异文件
  // Validates: Requirements 2
  test('所有差异文件都在同步计划中', () => {
    fc.assert(
      fc.property(
        fc.array(syncFileArb, { minLength: 1, maxLength: 10 }),
        fc.array(syncFileArb, { minLength: 1, maxLength: 10 }),
        (local, remote) => {
          const plan = computeSyncPlan(local, remote);
          // 每个只在本地存在的文件都应有上传操作
          const localOnly = local.filter(
            l => !remote.some(r => r.path === l.path)
          );
          for (const file of localOnly) {
            expect(plan.actions.some(
              a => a.path === file.path && a.type === 'upload'
            )).toBe(true);
          }
        }
      )
    );
  });
});