@team-agent/installer 0.5.106 → 0.5.108

package/crates/team-agent/src/cli/status_port/brief.rs

@@ -117,6 +117,14 @@ struct BriefNode {
     tmux_command: Option<String>,
 }
 
+#[derive(Clone, Debug, PartialEq, Eq)]
+struct AttachContext {
+    endpoint: String,
+    session: String,
+    window: String,
+    pane: String,
+}
+
 #[derive(Debug)]
 struct ProbeResult {
     nodes: Vec<ProbeNode>,
@@ -150,34 +158,45 @@ pub(crate) fn status_brief_scoped(
     state: &Value,
     agent: Option<&str>,
 ) -> Value {
-    let registered = registered_nodes(state, agent);
-    let probes = probe_registered_endpoints(&registered);
-    let nodes = registered
-        .iter()
-        .map(|node| project_node(node, probes.get(node.endpoint.as_deref().unwrap_or(""))))
-        .collect::<Vec<_>>();
+    let nodes = project_status_nodes(state, agent);
     json!({
-        "nodes": nodes.into_iter().map(BriefNode::into_json).collect::<Vec<_>>()
+        "nodes": nodes
+            .into_iter()
+            .map(|(node, _)| node.into_json())
+            .collect::<Vec<_>>()
     })
 }
 
-/// Human output is the exact same nine-field projection as JSON, rendered in
-/// stable field order. Null values remain explicit rather than becoming a
-/// diagnostic or an inferred value.
+/// Human output keeps the legacy single-node form and groups shared attach
+/// context only when multiple nodes make that repetition useful.
 pub(crate) fn format_status_brief(
-    workspace: &Path,
+    _workspace: &Path,
     state: &Value,
     agent: Option<&str>,
 ) -> String {
-    let value = status_brief_scoped(workspace, state, agent);
-    value
-        .get("nodes")
-        .and_then(Value::as_array)
-        .into_iter()
-        .flatten()
-        .filter_map(format_brief_node)
-        .collect::<Vec<_>>()
-        .join("\n")
+    let nodes = project_status_nodes(state, agent);
+    if nodes.len() <= 1 {
+        return nodes
+            .into_iter()
+            .filter_map(|(node, _)| format_brief_node(&node.into_json()))
+            .collect::<Vec<_>>()
+            .join("\n");
+    }
+    format_multi_node_brief(nodes)
+}
+
+fn project_status_nodes(
+    state: &Value,
+    agent: Option<&str>,
+) -> Vec<(BriefNode, Option<AttachContext>)> {
+    let registered = registered_nodes(state, agent);
+    let probes = probe_registered_endpoints(&registered);
+    registered
+        .iter()
+        .map(|node| {
+            project_node_with_attach(node, probes.get(node.endpoint.as_deref().unwrap_or("")))
+        })
+        .collect()
 }
 
 pub(crate) fn registered_agent_exists(state: &Value, agent: &str) -> bool {
@@ -322,6 +341,86 @@ fn format_brief_node(value: &Value) -> Option<String> {
     ))
 }
 
+fn format_multi_node_brief(nodes: Vec<(BriefNode, Option<AttachContext>)>) -> String {
+    let mut groups = Vec::<(String, String)>::new();
+    for (_, context) in &nodes {
+        let Some(context) = context else { continue };
+        if !groups.iter().any(|(endpoint, session)| {
+            endpoint == &context.endpoint && session == &context.session
+        }) {
+            groups.push((context.endpoint.clone(), context.session.clone()));
+        }
+    }
+
+    let mut lines = groups
+        .iter()
+        .enumerate()
+        .map(|(index, (endpoint, session))| {
+            format_attach_template(index + 1, endpoint, session)
+        })
+        .collect::<Vec<_>>();
+    if !groups.is_empty() {
+        lines.push(
+            "TMUX templates: replace <target> with the window.pane part of the matching ATTACH value."
+                .to_string(),
+        );
+    }
+    lines.push(
+        "NAME\tPROVIDER\tMODEL\tEFFORT\tRUNTIME_STATUS\tACTIVITY\tHEALTH\tSESSION_NAME\tATTACH"
+            .to_string(),
+    );
+    for (node, context) in nodes {
+        let attach = context
+            .as_ref()
+            .and_then(|context| {
+                groups
+                    .iter()
+                    .position(|(endpoint, session)| {
+                        endpoint == &context.endpoint && session == &context.session
+                    })
+                    .map(|index| format!("{}:{}.{}", index + 1, context.window, context.pane))
+            })
+            .unwrap_or_else(|| "null".to_string());
+        lines.push(
+            [
+                escape_human_cell(&node.name),
+                escape_human_cell(&node.provider),
+                escape_human_cell(node.model.as_deref().unwrap_or("null")),
+                escape_human_cell(node.effort.as_deref().unwrap_or("null")),
+                escape_human_cell(&node.runtime_status),
+                escape_human_cell(&node.activity),
+                escape_human_cell(&node.health),
+                escape_human_cell(node.session_name.as_deref().unwrap_or("null")),
+                escape_human_cell(&attach),
+            ]
+            .join("\t"),
+        );
+    }
+    lines.join("\n")
+}
+
+fn format_attach_template(group: usize, endpoint: &str, session: &str) -> String {
+    let flag = if Path::new(endpoint).is_absolute() {
+        "-S"
+    } else {
+        "-L"
+    };
+    let target = format!("{session}:<target>");
+    format!(
+        "TMUX[{group}] tmux {flag} {} attach -t {}",
+        shell_quote(endpoint),
+        shell_quote(&target)
+    )
+}
+
+fn escape_human_cell(value: &str) -> String {
+    value
+        .replace('\\', "\\\\")
+        .replace('\t', "\\t")
+        .replace('\n', "\\n")
+        .replace('\r', "\\r")
+}
+
 fn display_optional(value: &Value) -> String {
     value
         .as_str()
@@ -1051,14 +1150,22 @@ fn non_empty(value: &Value, key: &str) -> Option<String> {
         .map(str::to_string)
 }
 
+#[cfg(test)]
 fn project_node(node: &RegisteredNode, probe: Option<&Option<ProbeResult>>) -> BriefNode {
+    project_node_with_attach(node, probe).0
+}
+
+fn project_node_with_attach(
+    node: &RegisteredNode,
+    probe: Option<&Option<ProbeResult>>,
+) -> (BriefNode, Option<AttachContext>) {
     let stopped = matches!(
         node.lifecycle.as_deref(),
         Some("stopped" | "done" | "failed" | "error" | "terminated")
     );
     let matched = match_result(node, probe);
     if stopped {
-        return match matched {
+        let projected = match matched {
             MatchResult::Missing => BriefNode {
                 name: node.name.clone(),
                 provider: node.provider.clone(),
@@ -1072,14 +1179,15 @@ fn project_node(node: &RegisteredNode, probe: Option<&Option<ProbeResult>>) -> B
             },
             MatchResult::Unique(_) | MatchResult::Ambiguous => BriefNode::unknown(node),
         };
+        return (projected, None);
     }
     let MatchResult::Unique(observed) = matched else {
-        return BriefNode::unknown(node);
+        return (BriefNode::unknown(node), None);
     };
     if !node.provider.eq_ignore_ascii_case("unknown")
         && !node.provider.eq_ignore_ascii_case(&observed.provider)
     {
-        return BriefNode::unknown(node);
+        return (BriefNode::unknown(node), None);
     }
     let pi_channel = observed.provider.eq_ignore_ascii_case("pi")
         && observed.evidence_method.as_deref() == Some("pi_activity_channel");
@@ -1097,21 +1205,31 @@ fn project_node(node: &RegisteredNode, probe: Option<&Option<ProbeResult>>) -> B
     } else {
         valid_health(&observed.health)
     };
-    BriefNode {
-        name: node.name.clone(),
-        provider: if node.provider.eq_ignore_ascii_case("unknown") {
-            observed.provider.clone()
-        } else {
-            node.provider.clone()
+    let tmux_command = tmux_command(node, observed);
+    let attach = tmux_command.as_ref().map(|_| AttachContext {
+        endpoint: observed.socket.clone(),
+        session: observed.session.clone(),
+        window: observed.window.clone(),
+        pane: observed.pane.clone(),
+    });
+    (
+        BriefNode {
+            name: node.name.clone(),
+            provider: if node.provider.eq_ignore_ascii_case("unknown") {
+                observed.provider.clone()
+            } else {
+                node.provider.clone()
+            },
+            model: node.model.clone(),
+            effort: node.effort.clone(),
+            runtime_status: "running".to_string(),
+            activity: activity.to_string(),
+            health: health.to_string(),
+            session_name: observed.session_name.clone(),
+            tmux_command,
         },
-        model: node.model.clone(),
-        effort: node.effort.clone(),
-        runtime_status: "running".to_string(),
-        activity: activity.to_string(),
-        health: health.to_string(),
-        session_name: observed.session_name.clone(),
-        tmux_command: tmux_command(node, observed),
-    }
+        attach,
+    )
 }
 
 fn match_result<'a>(

package/crates/team-agent/src/cli/tests/base.rs

@@ -13,33 +13,19 @@ use serde_json::json;
 // =========================================================================
 
 #[test]
-fn provider_args_strips_leading_dashdash() {
-    // golden: _provider_args(["--","-x"]) == ["-x"]
-    assert_eq!(
-        provider_args(&["--".into(), "-x".into()]),
-        vec!["-x".to_string()]
-    );
-}
-
-#[test]
-fn provider_args_keeps_when_no_leading_dashdash() {
-    // golden: _provider_args(["-x","-y"]) == ["-x","-y"]
-    assert_eq!(
-        provider_args(&["-x".into(), "-y".into()]),
-        vec!["-x".to_string(), "-y".to_string()]
-    );
-}
-
-#[test]
-fn provider_args_empty_is_empty() {
-    // golden: _provider_args([]) == []
-    assert_eq!(provider_args(&[]), Vec::<String>::new());
-}
-
-#[test]
-fn provider_args_lone_dashdash_yields_empty() {
-    // golden: _provider_args(["--"]) == []  (values[1:] of single-elem list)
-    assert_eq!(provider_args(&["--".into()]), Vec::<String>::new());
+fn provider_args_cases() {
+    // (old case-id, input, Python golden); values[1:] of a lone "--" is empty.
+    const CASES: &[(&str, &[&str], &[&str])] = &[
+        ("provider_args_strips_leading_dashdash", &["--", "-x"], &["-x"]),
+        ("provider_args_keeps_when_no_leading_dashdash", &["-x", "-y"], &["-x", "-y"]),
+        ("provider_args_empty_is_empty", &[], &[]),
+        ("provider_args_lone_dashdash_yields_empty", &["--"], &[]),
+    ];
+    for (id, input, expected) in CASES {
+        let argv: Vec<String> = input.iter().map(|arg| (*arg).to_string()).collect();
+        let expected: Vec<String> = expected.iter().map(|arg| (*arg).to_string()).collect();
+        assert_eq!(provider_args(&argv), expected, "{id}");
+    }
 }
 
 // =========================================================================
@@ -47,118 +33,72 @@ fn provider_args_lone_dashdash_yields_empty() {
 // =========================================================================
 
 #[test]
-fn leader_launcher_args_empty_all_default() {
-    // golden: {'provider_args': [], 'attach_existing': False, 'confirm_attach': False, 'attach_session': None}
-    let got = leader_launcher_args(&[]).expect("empty should parse");
-    assert_eq!(got, LeaderLauncherArgs::default());
-    assert!(got.provider_args.is_empty());
-    assert!(!got.attach_existing);
-    assert!(!got.confirm_attach);
-    assert_eq!(got.attach_session, None);
-    assert!(!got.external_leader);
-}
-
-#[test]
-fn leader_launcher_args_attach_and_confirm() {
-    // golden: ["--attach","--confirm"] -> attach_existing=True, confirm_attach=True
-    let got = leader_launcher_args(&["--attach".into(), "--confirm".into()]).unwrap();
-    assert!(got.attach_existing);
-    assert!(got.confirm_attach);
-    assert!(got.provider_args.is_empty());
-    assert_eq!(got.attach_session, None);
-}
-
-#[test]
-fn leader_launcher_args_attach_existing_alias() {
-    // golden: ["--attach-existing"] -> attach_existing=True (alias of --attach)
-    let got = leader_launcher_args(&["--attach-existing".into()]).unwrap();
-    assert!(got.attach_existing);
-    assert!(!got.confirm_attach);
-}
-
-#[test]
-fn leader_launcher_args_external_leader_opt_out() {
-    let got = leader_launcher_args(&[
-        "--external-leader".into(),
-        "--".into(),
-        "--model".into(),
-        "opus".into(),
-    ])
-    .unwrap();
-    assert!(got.external_leader);
-    assert!(!got.attach_existing);
-    assert_eq!(
-        got.provider_args,
-        vec!["--model".to_string(), "opus".to_string()]
-    );
-}
-
-#[test]
-fn leader_launcher_args_external_leader_after_dashdash_errors() {
-    let err = leader_launcher_args(&["--".into(), "--external-leader".into()])
-        .expect_err("Team Agent flags after -- must not be silently passed to provider");
-    assert!(
-        err.to_string()
-            .contains("Team Agent launcher flag --external-leader must appear before --"),
-        "unexpected error: {err}"
-    );
-}
-
-#[test]
-fn leader_launcher_args_attach_session_spaced() {
-    // golden: ["--attach-session","mysess"] -> attach_session="mysess"
-    let got = leader_launcher_args(&["--attach-session".into(), "mysess".into()]).unwrap();
-    assert_eq!(got.attach_session, Some("mysess".to_string()));
-    assert!(!got.attach_existing);
-}
-
-#[test]
-fn leader_launcher_args_attach_session_equals() {
-    // golden: ["--attach-session=mysess"] -> attach_session="mysess"
-    let got = leader_launcher_args(&["--attach-session=mysess".into()]).unwrap();
-    assert_eq!(got.attach_session, Some("mysess".to_string()));
-}
-
-#[test]
-fn leader_launcher_args_dashdash_passthrough_strips_separator() {
-    // ["--attach","--","-x","--provider-confirm"] ->
-    //   provider_args=["-x","--provider-confirm"], attach_existing=True, confirm_attach=False
-    // Known Team Agent launcher flags after `--` are rejected by a separate guard.
-    let got = leader_launcher_args(&[
-        "--attach".into(),
-        "--".into(),
-        "-x".into(),
-        "--provider-confirm".into(),
-    ])
-    .unwrap();
-    assert!(got.attach_existing);
-    assert!(!got.confirm_attach);
-    assert_eq!(
-        got.provider_args,
-        vec!["-x".to_string(), "--provider-confirm".to_string()]
-    );
-}
-
-#[test]
-fn leader_launcher_args_unknown_tokens_collect_as_provider_args() {
-    // golden: ["foo","--attach","bar"] -> provider_args=["foo","bar"], attach_existing=True
-    let got = leader_launcher_args(&["foo".into(), "--attach".into(), "bar".into()]).unwrap();
-    assert_eq!(
-        got.provider_args,
-        vec!["foo".to_string(), "bar".to_string()]
-    );
-    assert!(got.attach_existing);
-}
-
-#[test]
-fn leader_launcher_args_attach_session_missing_value_errors() {
-    // golden: ["--attach-session"] raises RuntimeError("--attach-session requires a tmux session name")
-    let err = leader_launcher_args(&["--attach-session".into()]).unwrap_err();
-    let msg = err.to_string();
-    assert!(
-        msg.contains("--attach-session requires a tmux session name"),
-        "expected exact missing-value message, got: {msg}"
-    );
+fn leader_launcher_args_success_cases() {
+    // (old case-id, argv, complete expected structure), including default false flags.
+    let cases: &[(&str, &[&str], LeaderLauncherArgs)] = &[
+        ("leader_launcher_args_empty_all_default", &[], LeaderLauncherArgs::default()),
+        ("leader_launcher_args_attach_and_confirm", &["--attach", "--confirm"], LeaderLauncherArgs {
+            attach_existing: true,
+            confirm_attach: true,
+            ..Default::default()
+        }),
+        // --attach-existing is an alias of --attach.
+        ("leader_launcher_args_attach_existing_alias", &["--attach-existing"], LeaderLauncherArgs {
+            attach_existing: true,
+            ..Default::default()
+        }),
+        ("leader_launcher_args_external_leader_opt_out", &["--external-leader", "--", "--model", "opus"], LeaderLauncherArgs {
+            provider_args: vec!["--model".to_string(), "opus".to_string()],
+            external_leader: true,
+            ..Default::default()
+        }),
+        ("leader_launcher_args_attach_session_spaced", &["--attach-session", "mysess"], LeaderLauncherArgs {
+            attach_session: Some("mysess".to_string()),
+            ..Default::default()
+        }),
+        ("leader_launcher_args_attach_session_equals", &["--attach-session=mysess"], LeaderLauncherArgs {
+            attach_session: Some("mysess".to_string()),
+            ..Default::default()
+        }),
+        // Known Team Agent launcher flags after `--` are rejected by the error table.
+        ("leader_launcher_args_dashdash_passthrough_strips_separator", &["--attach", "--", "-x", "--provider-confirm"], LeaderLauncherArgs {
+            provider_args: vec!["-x".to_string(), "--provider-confirm".to_string()],
+            attach_existing: true,
+            ..Default::default()
+        }),
+        ("leader_launcher_args_unknown_tokens_collect_as_provider_args", &["foo", "--attach", "bar"], LeaderLauncherArgs {
+            provider_args: vec!["foo".to_string(), "bar".to_string()],
+            attach_existing: true,
+            ..Default::default()
+        }),
+    ];
+    for (id, input, expected) in cases {
+        let argv: Vec<String> = input.iter().map(|arg| (*arg).to_string()).collect();
+        let got = leader_launcher_args(&argv).unwrap_or_else(|err| panic!("{id}: {err}"));
+        assert_eq!(got, *expected, "{id}");
+    }
+}
+
+#[test]
+fn leader_launcher_args_error_cases() {
+    // Preserve the original error-substring contract, rather than requiring exact equality.
+    const CASES: &[(&str, &[&str], &str)] = &[
+        (
+            "leader_launcher_args_external_leader_after_dashdash_errors",
+            &["--", "--external-leader"],
+            "Team Agent launcher flag --external-leader must appear before --",
+        ),
+        (
+            "leader_launcher_args_attach_session_missing_value_errors",
+            &["--attach-session"],
+            "--attach-session requires a tmux session name",
+        ),
+    ];
+    for (id, input, expected) in CASES {
+        let argv: Vec<String> = input.iter().map(|arg| (*arg).to_string()).collect();
+        let err = leader_launcher_args(&argv).expect_err(id);
+        assert!(err.to_string().contains(*expected), "{id}: unexpected error: {err}");
+    }
 }
 
 // =========================================================================
@@ -166,37 +106,22 @@ fn leader_launcher_args_attach_session_missing_value_errors() {
 // =========================================================================
 
 #[test]
-fn send_target_fanout_strips_and_filters_empty() {
-    // golden: _send_target(targets="a, b ,,c") == ["a","b","c"]
-    let got = send_target(Some("a, b ,,c"), None);
-    assert_eq!(
-        got,
-        MessageTarget::Fanout(vec!["a".to_string(), "b".to_string(), "c".to_string()])
-    );
-}
-
-#[test]
-fn send_target_single_target() {
-    // golden: _send_target(target="agent_x") == "agent_x"
-    assert_eq!(
-        send_target(None, Some("agent_x")),
-        MessageTarget::Single("agent_x".to_string())
-    );
-}
-
-#[test]
-fn send_target_broadcast_star() {
-    // skeleton contract: bare "*" target -> Broadcast (send.py interprets "*" as全队广播)
-    assert_eq!(send_target(None, Some("*")), MessageTarget::Broadcast);
-}
-
-#[test]
-fn send_target_empty_targets_falls_through_to_target() {
-    // golden: targets="" is falsy in Python -> returns args.target ("fallback")
-    assert_eq!(
-        send_target(Some(""), Some("fallback")),
-        MessageTarget::Single("fallback".to_string())
-    );
+fn send_target_cases() {
+    // (old case-id, targets, target, complete expected enum).
+    let cases: &[(&str, Option<&str>, Option<&str>, MessageTarget)] = &[
+        (
+            "send_target_fanout_strips_and_filters_empty", Some("a, b ,,c"), None,
+            MessageTarget::Fanout(vec!["a".to_string(), "b".to_string(), "c".to_string()]),
+        ),
+        ("send_target_single_target", None, Some("agent_x"), MessageTarget::Single("agent_x".to_string())),
+        // A bare "*" means broadcast to the whole team.
+        ("send_target_broadcast_star", None, Some("*"), MessageTarget::Broadcast),
+        // targets="" is falsy in Python, so it falls through to args.target.
+        ("send_target_empty_targets_falls_through_to_target", Some(""), Some("fallback"), MessageTarget::Single("fallback".to_string())),
+    ];
+    for (id, targets, target, expected) in cases {
+        assert_eq!(send_target(*targets, *target), *expected, "{id}");
+    }
 }
 
 // =========================================================================
@@ -205,61 +130,23 @@ fn send_target_empty_targets_falls_through_to_target() {
 // =========================================================================
 
 #[test]
-fn classify_failed_takes_priority() {
-    // raw in {failed,error} OR hstatus in {failed,error} -> Failed
-    assert_eq!(classify_agent_bucket("failed", ""), SummaryBucket::Failed);
-    assert_eq!(classify_agent_bucket("error", ""), SummaryBucket::Failed);
-    assert_eq!(
-        classify_agent_bucket("running", "error"),
-        SummaryBucket::Failed
-    );
-}
-
-#[test]
-fn classify_stopped() {
-    // raw in {stopped,done} OR hstatus==done -> Stopped
-    assert_eq!(classify_agent_bucket("stopped", ""), SummaryBucket::Stopped);
-    assert_eq!(classify_agent_bucket("done", ""), SummaryBucket::Stopped);
-    assert_eq!(
-        classify_agent_bucket("running", "done"),
-        SummaryBucket::Stopped
-    );
-}
-
-#[test]
-fn classify_busy() {
-    // raw==busy OR hstatus in {running,working} -> Busy
-    assert_eq!(classify_agent_bucket("busy", ""), SummaryBucket::Busy);
-    assert_eq!(classify_agent_bucket("", "running"), SummaryBucket::Busy);
-    assert_eq!(classify_agent_bucket("", "working"), SummaryBucket::Busy);
-}
-
-#[test]
-fn classify_hstatus_idle_beats_raw_running() {
-    // golden: raw=running, h=idle -> idle  (hstatus==idle branch precedes raw==running branch)
-    assert_eq!(
-        classify_agent_bucket("running", "idle"),
-        SummaryBucket::Idle
-    );
-}
-
-#[test]
-fn classify_pure_running() {
-    // raw==running, no overriding hstatus -> Running
-    assert_eq!(classify_agent_bucket("running", ""), SummaryBucket::Running);
-}
-
-#[test]
-fn classify_blocked_and_unmatched_are_unknown_never_idle() {
-    // bug-071/077/085: blocked/stuck/missing AND any unmatched value -> Unknown, NOT idle.
-    assert_eq!(classify_agent_bucket("blocked", ""), SummaryBucket::Unknown);
-    assert_eq!(classify_agent_bucket("stuck", ""), SummaryBucket::Unknown);
-    assert_eq!(classify_agent_bucket("", "missing"), SummaryBucket::Unknown);
-    assert_eq!(
-        classify_agent_bucket("weird_value", ""),
-        SummaryBucket::Unknown
-    );
-    assert_eq!(classify_agent_bucket("", ""), SummaryBucket::Unknown);
+fn classify_agent_bucket_cases() {
+    // (old case-id, all original (raw, health) inputs, expected bucket).
+    const CASES: &[(&str, &[(&str, &str)], SummaryBucket)] = &[
+        ("classify_failed_takes_priority", &[("failed", ""), ("error", ""), ("running", "error")], SummaryBucket::Failed),
+        ("classify_stopped", &[("stopped", ""), ("done", ""), ("running", "done")], SummaryBucket::Stopped),
+        ("classify_busy", &[("busy", ""), ("", "running"), ("", "working")], SummaryBucket::Busy),
+        // hstatus==idle precedes the raw==running branch.
+        ("classify_hstatus_idle_beats_raw_running", &[("running", "idle")], SummaryBucket::Idle),
+        ("classify_pure_running", &[("running", "")], SummaryBucket::Running),
+        // bug-071/077/085: unmatched and blocked/stuck/missing are Unknown, NEVER idle.
+        ("classify_blocked_and_unmatched_are_unknown_never_idle", &[("blocked", ""), ("stuck", ""), ("", "missing"), ("weird_value", ""), ("", "")], SummaryBucket::Unknown),
+    ];
+    for (id, inputs, expected) in CASES {
+        for &(raw, health) in inputs.iter() {
+            assert_eq!(classify_agent_bucket(raw, health), *expected, "{id}: raw={raw:?}, health={health:?}");
+        }
+    }
 }
 
 #[test]