test: 简化 NPE 复现策略 - 只重复运行原始失败测试

优化原因:
- 之前运行了太多测试（1004 个），包括人工延迟的测试
- 更高效的方式：只重复运行历史上真正失败过的测试

新策略:
- 只运行 shouldOkWhenAiFlowWithExampleSelector 1000 次
- 使用真实的 ExampleSelector 配置（不添加人工延迟）
- 移除了模拟测试，更接近真实失败场景

预期:
- 运行更快（无人工延迟）
- 只运行 1003 个测试（原 3 个 + 1000 次重复）
- 根据 0.5% 失败率，1000 次应该触发约 5 次 NPE

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Sonnet 4.5 <[email protected]>

Author: CodeCasterX

framework/fel/java/fel-flow/src/test/java/modelengine/fel/engine/operators/PatternTest.java

@@ -81,8 +81,8 @@ void shouldOkWhenAiFlowWithNormalRunnableParallel() {
         assertThat(answer1.toString()).isEqualTo("answer question1 from context with my history");
     }
 
-    @Test
-    @DisplayName("测试 ExampleSelector")
+    @RepeatedTest(1000)
+    @DisplayName("测试 ExampleSelector - 重复运行以复现 NPE")
     void shouldOkWhenAiFlowWithExampleSelector() {
         Example[] examples = {new DefaultExample("2+2", "4"), new DefaultExample("2+3", "5")};
         Conversation<String, Prompt> converse = AiFlows.<String>create()
@@ -98,62 +98,6 @@ void shouldOkWhenAiFlowWithExampleSelector() {
         assertThat(converse.offer("1+2").await().text()).isEqualTo("2+2=4\n2+3=5\n1+2=");
     }
 
-    @RepeatedTest(500)
-    @DisplayName("【复现测试】强制触发 runnableParallel 的竞态条件 NPE")
-    void shouldReproduceNPEInRunnableParallel() {
-        // 慢分支：模拟 fewShot() 的延迟，增大竞态窗口
-        modelengine.fel.engine.operators.patterns.SyncTipper<String> slowBranch = arg -> {
-            try {
-                Thread.sleep(200);  // 200ms 延迟
-            } catch (InterruptedException e) {
-                Thread.currentThread().interrupt();
-            }
-            return Tip.from("slow", "slow-value");
-        };
-
-        // 快分支：模拟 question() 的快速返回
-        modelengine.fel.engine.operators.patterns.SyncTipper<String> fastBranch = arg -> {
-            return Tip.from("fast", "fast-value");
-        };
-
-        // 执行并发聚合
-        Conversation<String, Prompt> converse = AiFlows.<String>create()
-                .runnableParallel(fastBranch, slowBranch)
-                .prompt(Prompts.human("{{fast}} {{slow}}"))
-                .close()
-                .converse();
-
-        // 在修复前：这里应该偶发抛出 NullPointerException
-        // 在修复后：这里应该稳定通过
-        String result = converse.offer("test").await().text();
-
-        assertThat(result).contains("fast-value", "slow-value");
-    }
-
-    @RepeatedTest(500)
-    @DisplayName("【复现测试】使用原测试配置重复运行")
-    void shouldReproduceOriginalTestFailure() {
-        // 使用原始失败测试的完全相同配置
-        Example[] examples = {new DefaultExample("2+2", "4"), new DefaultExample("2+3", "5")};
-
-        Conversation<String, Prompt> converse = AiFlows.<String>create()
-                .runnableParallel(
-                        question(),
-                        fewShot(ExampleSelector.builder()
-                                .template("{{q}}={{a}}", "q", "a")
-                                .delimiter("\n")
-                                .example(examples)
-                                .build()))
-                .prompt(Prompts.human("{{examples}}\n{{question}}="))
-                .close()
-                .converse();
-
-        // 在修复前：偶发 NPE
-        // 在修复后：稳定通过
-        assertThat(converse.offer("1+2").await().text())
-                .isEqualTo("2+2=4\n2+3=5\n1+2=");
-    }
-
     @Test
     @DisplayName("测试 Retriever")
     void shouldOkWhenAiFlowWithRetriever() {