import json import tempfile import unittest from pathlib import Path from unittest import mock from rsi_loop import config, episodes, llm, mine, proposal, replay, runner, runtime, scoring, transcript from rsi_loop.runner import _eligible_cluster LAB_NODES = {"android": "evaluator-android-01.shiro0.icu", "ios": "temp-ios-01"} def assistant(tool_id, name, tool_input, tokens=1000): return { "type": "assistant", "message": { "usage": {"input_tokens": tokens}, "content": [{"type": "tool_use", "id": tool_id, "name": name, "input": tool_input}], }, } def result(tool_id, text, is_error=False, timestamp="2026-09-01T00:00:00Z"): return { "type": "user", "timestamp": timestamp, "message": {"content": [{ "type": "tool_result", "tool_use_id": tool_id, "content": text, "is_error": is_error, }]}, } class TranscriptTests(unittest.TestCase): def test_read_only_output_does_not_become_failure(self): rows = [ assistant("a", "Bash", {"command": "grep -R error src"}), result("a", "error: source fixture\nExit code 1"), ] call = transcript.calls(rows)[0] self.assertTrue(call["read_only"]) self.assertTrue(call["ok"]) self.assertIsNone(call["wall"]) def test_repeated_failure_point_is_after_first_failure(self): rows = [ assistant("a", "Bash", {"command": "adb install app.apk"}), result("a", "INSTALL_FAILED_VERSION_DOWNGRADE", True), assistant("b", "Bash", {"command": "adb install app.apk"}), result("b", "INSTALL_FAILED_VERSION_DOWNGRADE", True), ] found = episodes.find_episodes(rows) self.assertEqual(len(found), 1) episode = found[0] self.assertEqual(episode["n_fail"], 2) self.assertEqual(episode["point_call"], 0) self.assertEqual(episode["point_row"], 1) def test_wait_point_is_before_wait_command(self): rows = [ assistant("a", "Bash", {"command": "adb shell input tap 1 2"}), result("a", "ok"), assistant("b", "Bash", {"command": "until adb shell dumpsys window; do sleep 5; done"}), result("b", "done"), ] point = episodes.harvest_wait_points(rows)[0] self.assertEqual(point["point_call"], 0) self.assertEqual(point["point_row"], 1) class ProposalTests(unittest.TestCase): def test_only_inserts_and_preserves_placeholders(self): base = "A {{task}}\nB\nC {{round}}" candidate = proposal.apply_insertion(base, "新增一\n新增二", "B") self.assertEqual(candidate, "A {{task}}\nB\n新增一\n新增二\nC {{round}}") self.assertIsNone(proposal.candidate_error(base, candidate)) self.assertEqual(proposal.inserted_text(base, candidate), "新增一\n新增二") def test_rejects_changed_line_and_ambiguous_anchor(self): base = "A\nB\nB" with self.assertRaises(ValueError): proposal.apply_insertion(base, "X", "B") self.assertIsNotNone(proposal.candidate_error("A\nB", "A\nB changed")) def test_reach_target_cannot_touch_evidence_capture(self): base = "步骤 3\n复现问题。\n步骤 4" shoot = proposal.apply_insertion(base, "- 启动 App 后立刻 record-evidence 拍一张 before-1-x.png", "复现问题。") route = proposal.apply_insertion(base, "- 先按 TestSpec 的入口用 deeplink 直达目标页", "复现问题。") self.assertIsNotNone(proposal.gaming_error("reach_s", base, shoot)) self.assertIsNotNone(proposal.gaming_error("reach_miss", base, shoot)) self.assertIsNone(proposal.gaming_error("reach_s", base, route)) self.assertIsNone(proposal.gaming_error("evidence_fail", base, shoot)) def test_business_metrics_are_registrable_for_every_replay_type(self): for ptype, allowed in proposal.METRICS_BY_REPLAY.items(): self.assertTrue(allowed & proposal.BUSINESS_METRICS, ptype) self.assertTrue(allowed <= proposal.TARGET_METRICS, ptype) def test_nested_json_reply_is_parsed(self): with mock.patch.object(llm, "ask", return_value='```json\n{"a":{"b":1}}\n```'): self.assertEqual(llm.ask_json("x"), {"a": {"b": 1}}) def test_online_metric_must_match_offline_action_shape(self): value = { "title": "x", "summary": "x", "hypothesis": "x", "method": "x", "targetMetric": "tool_calls", "afterLine": None, "content": "新增纪律", } cluster = { "stage": "bug.run", "problemClass": "decision_error", "cluster": "wait", "clusterTitle": "等待", "replayType": "T2_wait", "wasteCalls": 3, "episodes": 1, "transcripts": 1, "samples": [], } with mock.patch.object(llm, "ask_json", return_value=value): with self.assertRaisesRegex(ValueError, "不对应"): proposal.create(cluster, "base") class ScoringTests(unittest.TestCase): def test_action_shape_rules(self): self.assertEqual(scoring.classify_action( "T2_wait", {}, {"name": "Bash", "input": {"command": "sleep 30"}}, ), "bad") self.assertEqual(scoring.classify_action( "T2_wait", {}, {"name": "Bash", "input": {"command": "node wait-for.js"}}, ), "good") self.assertEqual(scoring.classify_action( "T3_frida", {}, {"name": "Bash", "input": {"command": "frida -U -n app -l hook.js"}}, ), "bad") self.assertEqual(scoring.classify_action( "T3_frida", {}, {"name": "Bash", "input": {"command": "frida --version"}}, ), "good") point = {"fam": "adb install app.apk"} self.assertEqual(scoring.classify_action( "T1_repeat", point, {"name": "Bash", "input": {"command": "adb install app.apk"}}, ), "bad") self.assertEqual(scoring.classify_action( "T1_repeat", point, {"name": "Bash", "input": {"command": "adb shell getprop"}}, ), "good") def test_paired_bootstrap_is_deterministic_and_positive(self): records = [] for point in range(20): for seed in range(2): records.append({"pointId": str(point), "arm": "base", "seed": seed, "classification": "bad"}) records.append({"pointId": str(point), "arm": "candidate", "seed": seed, "classification": "good"}) a = scoring.offline_summary(records) b = scoring.offline_summary(records) self.assertEqual(a, b) self.assertEqual(a["points"], 20) self.assertEqual(a["seeds"], 2) self.assertGreater(a["ciLow"], 0) class AuditAndSelectionTests(unittest.TestCase): def test_audit_requires_verbatim_evidence(self): raw = { "classification": "decision_error", "cluster": "repeat_same_command", "clusterTitle": "重复撞墙", "replayType": "T1_repeat", "correctInfoStep": 3, "evidence": ["Exit code 1"], "rationale": "已出现错误", } self.assertIsNotNone(mine._valid_audit(raw, "tool result: Exit code 1")) raw["evidence"] = ["模型编造的引文"] self.assertIsNone(mine._valid_audit(raw, "tool result: Exit code 1")) def test_live_stage_and_cooldown_are_skipped(self): now = 2_000_000_000_000 clusters = [ {"stage": "bug.run", "platform": "android", "cluster": "a", "replayType": "T1_repeat"}, {"stage": "bug.run", "platform": "ios", "cluster": "b", "replayType": "T2_wait"}, {"stage": "bug.run", "platform": "ios", "cluster": "c", "replayType": "T3_frida"}, ] state = { "labNodes": LAB_NODES, "live": [{"stage": "bug.run", "platform": "android"}], "recent": [{"stage": "bug.run", "platform": "ios", "cluster": "b", "createdAt": now}], } with tempfile.TemporaryDirectory() as d, mock.patch.object(config, "DATA", Path(d)): self.assertEqual(_eligible_cluster(clusters, state, now, point_count=lambda c: 30)["cluster"], "c") def test_cluster_without_enough_points_is_skipped(self): now = 2_000_000_000_000 clusters = [ {"stage": "bug.run", "platform": "android", "cluster": "few", "replayType": "T1_repeat"}, {"stage": "bug.run", "platform": "android", "cluster": "many", "replayType": "T1_repeat"}, ] counts = {"few": 5, "many": 40} state = {"labNodes": LAB_NODES} with tempfile.TemporaryDirectory() as d, mock.patch.object(config, "DATA", Path(d)): got = _eligible_cluster(clusters, state, now, point_count=lambda c: counts[c["cluster"]]) self.assertEqual(got["cluster"], "many") runner._record_skip(clusters[1], "anchor missing", now) self.assertIsNone(_eligible_cluster(clusters, state, now, point_count=lambda c: counts[c["cluster"]])) class ReplayFidelityTests(unittest.TestCase): PROMPT = "你是自主 Bug 修复 Agent。\n工作区在 /Users/fei/bug_workspace/123。\n## 等待\n用 wait-for。\n## 结尾" def test_insert_at_anchor_with_placeholder_and_no_heading(self): ins = {"afterLine": "工作区在 {{workspace}}。", "content": "新纪律一\n新纪律二"} out = replay.insert_into_text(self.PROMPT, ins) lines = out.split("\n") self.assertEqual(lines[1], "工作区在 /Users/fei/bug_workspace/123。") self.assertEqual(lines[2:4], ["新纪律一", "新纪律二"]) self.assertNotIn("候选", out) def test_null_anchor_appends_at_end_and_missing_anchor_raises(self): out = replay.insert_into_text(self.PROMPT, {"afterLine": None, "content": "末尾纪律"}) self.assertTrue(out.endswith("## 结尾\n末尾纪律")) with self.assertRaises(replay.AnchorMissing): replay.insert_into_text(self.PROMPT, {"afterLine": "不存在的一行", "content": "x"}) def test_candidate_applies_checks_first_prompt(self): rows = [{"type": "user", "message": {"role": "user", "content": self.PROMPT}}] self.assertTrue(replay.candidate_applies(rows, {"afterLine": "## 等待", "content": "x"})) self.assertFalse(replay.candidate_applies(rows, {"afterLine": "## 不存在", "content": "x"})) self.assertTrue(replay.candidate_applies(rows, None)) def test_environment_snapshot_uses_this_runs_cwd(self): rows = [ {"type": "user", "message": {"role": "user", "content": self.PROMPT}}, {"type": "attachment", "attachment": {"type": "environment", "snapshot": {"workingDirectory": "/Users/fei/ai_workspace"}, "changes": [{"field": "workingDirectory"}]}}, ] loc = {"environment": {"type": "environment", "snapshot": {"workingDirectory": "/probe/dir", "platform": "darwin"}}} out, _ = replay._neutralize(rows, "sid", loc, Path("/runs/abc"), Path("/proj/abc"), {"afterLine": "## 等待", "content": "新纪律"}) env = out[1]["attachment"] self.assertEqual(env["snapshot"]["workingDirectory"], "/runs/abc") self.assertNotIn("changes", env) self.assertIn("## 等待\n新纪律\n用 wait-for。", out[0]["message"]["content"]) class ClusterConsolidationTests(unittest.TestCase): def _audits(self, d): rows = [ {"episodeId": "e1", "stage": "bug.run", "classification": "decision_error", "cluster": "app_ready_blind_wait", "clusterTitle": "盲等就绪", "replayType": "T2_wait"}, {"episodeId": "e2", "stage": "bug.run", "classification": "decision_error", "cluster": "fixed_sleep_before_ready", "clusterTitle": "定长 sleep 等就绪", "replayType": "T2_wait"}, {"episodeId": "e3", "stage": "bug.run", "classification": "decision_error", "cluster": "frida_retry", "clusterTitle": "Frida 原样重试", "replayType": "T3_frida"}, ] (Path(d) / "a.jsonl").write_text("\n".join(json.dumps(r, ensure_ascii=False) for r in rows)) def test_canon_follows_chain_and_stops_on_cycle(self): self.assertEqual(mine.canon("a", {"a": "b", "b": "c"}), "c") self.assertIn(mine.canon("a", {"a": "b", "b": "a"}), ("a", "b")) self.assertEqual(mine.canon("x", {}), "x") def test_consolidation_validates_and_merges(self): with tempfile.TemporaryDirectory() as d, mock.patch.object(config, "DATA", Path(d)), \ mock.patch.object(config, "AUDITS", Path(d) / "a.jsonl"): self._audits(d) reply = {"merge": { "fixed_sleep_before_ready": "app_ready_blind_wait", # 同机制、同重放型 → 并 "frida_retry": "app_ready_blind_wait", # 重放型不同 → 拒 "app_ready_blind_wait": "made_up_name", # 规范名不存在 → 拒 }} with mock.patch.object(llm, "ask_json", return_value=reply): r = mine.consolidate_clusters() self.assertEqual(r["merged"], 1) names = {k["cluster"]: k["count"] for k in mine.known_clusters()} self.assertEqual(names, {"app_ready_blind_wait": 2, "frida_retry": 1}) def test_audit_prompt_lists_known_clusters(self): known = [{"cluster": "app_ready_blind_wait", "clusterTitle": "盲等就绪", "classification": "decision_error", "replayType": "T2_wait", "count": 5}] p = mine._audit_prompt({"stage": "bug.run", "label": "wall:x", "n_fail": 2, "first_call": 1, "last_call": 3}, "时间线", known) self.assertIn("app_ready_blind_wait", p) self.assertIn("必须复用", p) class LabModeTests(unittest.TestCase): def test_lab_run_sessions_are_not_mined(self): with tempfile.TemporaryDirectory() as d, mock.patch.object(config, "DATA", Path(d)), \ mock.patch.object(config, "EPISODES", Path(d) / "e.jsonl"), mock.patch.object(config, "POINTS", Path(d) / "p.jsonl"), \ mock.patch.object(mine, "transcript_files", return_value=[(Path(d) / "x.jsonl", {"workspaceKey": "rsi-lab-abc", "node": "n", "file": "x.jsonl"})]), \ mock.patch.object(mine, "load_rows", side_effect=AssertionError("复跑会话不该被读")): r = mine.mine_local() self.assertEqual(r["episodes"], 0) def test_only_submits_bug_run_with_lab_node(self): now = 2_000_000_000_000 clusters = [ {"stage": "feature.run.first", "platform": "android", "cluster": "f", "replayType": "T2_wait"}, {"stage": "bug.run", "platform": "ios", "cluster": "no_lab_node", "replayType": "T1_repeat"}, {"stage": "bug.run", "platform": "android", "cluster": "ok", "replayType": "T2_wait"}, ] state = {"labNodes": {"android": "evaluator-android-01.shiro0.icu"}} with tempfile.TemporaryDirectory() as d, mock.patch.object(config, "DATA", Path(d)): self.assertEqual(_eligible_cluster(clusters, state, now, point_count=lambda c: 30)["cluster"], "ok") # 没配实验机就一个都不提 self.assertIsNone(_eligible_cluster(clusters, {}, now, point_count=lambda c: 30)) def test_lab_verdicts_get_conclusions(self): self.assertIn("lab_passed", runner.TERMINAL) self.assertIn("lab_failed", runner.TERMINAL) self.assertIn("declined", runner.TERMINAL) class PlatformTests(unittest.TestCase): def test_live_experiment_only_blocks_its_own_platform(self): now = 2_000_000_000_000 clusters = [ {"stage": "bug.run", "platform": "android", "cluster": "a", "replayType": "T2_wait"}, {"stage": "bug.run", "platform": "ios", "cluster": "b", "replayType": "T2_wait"}, ] state = {"labNodes": LAB_NODES, "live": [{"stage": "bug.run", "platform": "android"}]} with tempfile.TemporaryDirectory() as d, mock.patch.object(config, "DATA", Path(d)): self.assertEqual(_eligible_cluster(clusters, state, now, point_count=lambda c: 30)["cluster"], "b") # 不带平台的旧实验对所有平台生效 legacy = {"labNodes": LAB_NODES, "live": [{"stage": "bug.run", "platform": None}]} self.assertIsNone(_eligible_cluster(clusters, legacy, now, point_count=lambda c: 30)) def test_replay_points_stay_on_cluster_platform(self): pts = [ {"id": "a", "stage": "bug.run", "platform": "android", "ptype": "T2_wait"}, {"id": "i", "stage": "bug.run", "platform": "ios", "ptype": "T2_wait"}, ] with mock.patch.object(mine, "_read_jsonl", return_value=pts): got = mine.replay_points({"stage": "bug.run", "platform": "ios", "replayType": "T2_wait"}) self.assertEqual([p["id"] for p in got], ["i"]) def test_node_without_transcripts_is_not_an_error(self): import urllib.error def fake_get(path, timeout=60): if path == "/nodes": return {"nodes": [{"id": "on", "platform": "android"}, {"id": "off", "platform": "ios"}]} if path.startswith("/nodes/off/"): raise urllib.error.HTTPError(path, 404, "not found", {}, None) return {"files": []} with tempfile.TemporaryDirectory() as d, \ mock.patch.object(config, "DATA", Path(d)), mock.patch.object(config, "TX_DIR", Path(d) / "tx"), \ mock.patch.object(config, "RUNS", Path(d) / "runs"), mock.patch.object(config, "STATE", Path(d) / "state.json"), \ mock.patch.object(config, "NODES", []), mock.patch("rsi_loop.api.get", side_effect=fake_get): stats = mine.sync_transcripts(2_000_000_000_000) self.assertEqual(stats["nodes"], 1) self.assertEqual(stats["notEnabled"], ["off"]) self.assertEqual(stats["errors"], []) class SyncTests(unittest.TestCase): def test_one_broken_download_does_not_stop_the_rest(self): files = [{"file": f"{i:08d}-0000-0000-0000-000000000000.jsonl", "size": 10, "mtime": 2_000_000_000_000} for i in range(3)] calls = {"n": 0} def fake_download(path, dest): calls["n"] += 1 if "00000001-" in path: raise IOError("IncompleteRead(542248 bytes read)") dest.write_text("{}") return 10 with tempfile.TemporaryDirectory() as d, \ mock.patch.object(config, "DATA", Path(d)), mock.patch.object(config, "TX_DIR", Path(d) / "tx"), \ mock.patch.object(config, "RUNS", Path(d) / "runs"), mock.patch.object(config, "STATE", Path(d) / "state.json"), \ mock.patch.object(config, "NODES", ["n1"]), \ mock.patch("rsi_loop.api.get", return_value={"files": files}), \ mock.patch("rsi_loop.api.download", side_effect=fake_download), \ mock.patch("rsi_loop.mine.time.sleep"): stats = mine.sync_transcripts(2_000_000_000_000) self.assertEqual(stats["downloaded"], 2) self.assertEqual(len(stats["errors"]), 1) self.assertIn("IncompleteRead", stats["errors"][0]) class DryRunTests(unittest.TestCase): def test_dry_run_post_never_touches_network(self): from rsi_loop import api with tempfile.TemporaryDirectory() as d, mock.patch.object(config, "DATA", Path(d)), \ mock.patch.object(config, "DRY_RUN", True), \ mock.patch("urllib.request.urlopen", side_effect=AssertionError("dry-run 不该联网")): got = api.post("/experiments", {"title": "t", "stage": "bug.run"}) self.assertEqual(got["experiment"]["status"], "dry_run") self.assertTrue(api.event("运行摘要")) lines = (Path(d) / "dry_posts.jsonl").read_text().splitlines() self.assertEqual([json.loads(l)["path"] for l in lines], ["/experiments", "/events"]) runner._record_skip({"stage": "bug.run", "cluster": "x"}, "anchor", 1) self.assertFalse((Path(d) / "skips.json").exists()) class FirstTurnTests(unittest.TestCase): def test_text_then_tool_use_is_one_turn(self): lines = [ json.dumps({"type": "system", "subtype": "init"}), json.dumps({"type": "assistant", "message": {"id": "m1", "content": [{"type": "text", "text": "先冷启动看登录态。"}]}}), json.dumps({"type": "assistant", "message": {"id": "m1", "content": [ {"type": "tool_use", "id": "t1", "name": "Bash", "input": {"command": "adb shell monkey -p x 1"}}]}}), json.dumps({"type": "result", "is_error": False}), ] first, err = replay.first_turn(lines) self.assertIsNone(err) self.assertEqual(scoring.action_of({"first": first})["input"]["command"], "adb shell monkey -p x 1") def test_error_result_is_reported(self): first, err = replay.first_turn([json.dumps({"type": "result", "is_error": True, "result": "Failed to authenticate"})]) self.assertIsNone(first) self.assertIn("authenticate", err) class SamplingTests(unittest.TestCase): def _points(self): mk = lambda i, stage, ptype, ep: {"id": f"p{i}", "stage": stage, "ptype": ptype, "episodeId": ep, # noqa: E731 "node": "n", "file": f"f{i}", "point_row": 1} target = [mk(i, "bug.run", "T1_repeat", f"t{i}") for i in range(20)] others = [ mk(100, "bug.run", "T2_wait", None), # 同 stage 等待点:可进保留集 mk(101, "bug.run", "T1_repeat", "real"), # 同 stage 审计过的真失败:可进 mk(102, "bug.run", "T1_repeat", "unaudited"), # 没审计过(可能是误报):不进 mk(103, "feature.run.first", "T2_wait", None), # 其它 stage:不进 ] return target, others def test_holdout_is_same_stage_and_audited_and_anchor_checked(self): target, others = self._points() cluster = {"stage": "bug.run", "cluster": "x", "replayType": "T1_repeat"} with mock.patch.object(mine, "replay_points", side_effect=lambda c=None: target if c else target + others), \ mock.patch.object(mine, "real_episode_ids", return_value={"real"}), \ mock.patch.object(mine, "load_rows_for_point", side_effect=lambda p: p["id"]), \ mock.patch.object(replay, "candidate_applies", side_effect=lambda rows, ins: rows != "p3"): t, h, seeds, skipped = runner._sample_points(cluster, {"afterLine": "a", "content": "b"}) self.assertEqual({p["id"] for p in h}, {"p100", "p101"}) self.assertNotIn("p3", {p["id"] for p in t}) self.assertEqual(skipped["targetAnchorMissing"], 1) self.assertGreaterEqual(seeds, 2) def test_high_error_rate_aborts_without_offline_result(self): target, _ = self._points() cluster = {"stage": "bug.run", "cluster": "x", "replayType": "T1_repeat"} with tempfile.TemporaryDirectory() as d, \ mock.patch.object(config, "RUNS", Path(d)), \ mock.patch.object(mine, "replay_points", side_effect=lambda c=None: target), \ mock.patch.object(mine, "real_episode_ids", return_value=set()), \ mock.patch.object(mine, "load_rows_for_point", return_value=[]), \ mock.patch.object(replay, "candidate_applies", return_value=True), \ mock.patch.object(replay, "prepare"), \ mock.patch.object(replay, "run_point", return_value={"first": None, "secs": 0, "error": "Failed to authenticate"}): with self.assertRaises(runner.ReplayAborted): runner.run_replays(cluster, {"afterLine": None, "content": "x"}) class RuntimeProposalTests(unittest.TestCase): KNOBS = { "effort": {"label": "思考强度", "values": ["low", "medium", "high", "xhigh", "max"], "doc": "d"}, "ui_settle": {"label": "等界面稳定", "values": ["on"], "doc": "d", "platforms": ["ios"]}, } def _exp(self, platform, profile): return {"kind": "runtime", "platform": platform, "candidateProfile": json.dumps(profile)} def test_skips_tried_baseline_and_off_platform(self): exps = [self._exp("android", {"effort": "medium"}), self._exp("ios", {"ui_settle": "on"})] with mock.patch.object(config, "LAB_BASELINE", {"android": {"effort": "xhigh"}}): # medium 试过、xhigh 是实验机现行 → high;ui_settle 不适用 Android self.assertEqual(runtime.next_candidate("android", self.KNOBS, exps), ("effort", "high")) # iOS:effort 一个都没试过,从 medium 开始 self.assertEqual(runtime.next_candidate("ios", self.KNOBS, exps), ("effort", "medium")) def test_exhausted_catalog_proposes_nothing(self): exps = [self._exp("ios", {"effort": v}) for v in ["low", "medium", "high", "xhigh", "max"]] exps.append(self._exp("ios", {"ui_settle": "on"})) self.assertIsNone(runtime.next_candidate("ios", self.KNOBS, exps)) def test_free_lab_nodes_each_get_one(self): state = {"runtimeKnobs": self.KNOBS, "labNodes": LAB_NODES} posted = [] with mock.patch.object(runner.api, "post", side_effect=lambda path, body, timeout=120: posted.append(body) or {"experiment": {"id": "x", "title": body["title"], "status": "lab"}}), \ mock.patch.object(config, "LAB_BASELINE", {}): got = runner._submit_runtime_experiments(state, [], busy={"android"}) self.assertEqual([b["platform"] for b in posted], ["ios"]) self.assertEqual(posted[0]["candidateProfile"], {"effort": "medium"}) self.assertEqual(got[0]["status"], "lab") class IosWaitPointTests(unittest.TestCase): def test_catuse_probe_counts_as_ui_wait(self): self.assertTrue(episodes.UI_LIKE.search("sleep 20; catuse apps 2>&1 | head -20")) self.assertTrue(episodes._is_wait("sleep 20; catuse apps 2>&1 | head -20")) if __name__ == "__main__": unittest.main()