527 lines
17 KiB
Rust
527 lines
17 KiB
Rust
//! Tests ported from ../inshellah/test/test_inshellah.ml.
|
|
//!
|
|
//! Covers the help parser, manpage parser, groff stripping, and nushell
|
|
//! generation. The single .nu store parser test (`test_nu_file_parsing`) is
|
|
//! not included — it requires porting store.ml first.
|
|
|
|
use inshellah::parsers::help::help_parser;
|
|
use inshellah::parsers::manpage::{
|
|
ManpageResult, OwnedParam, OwnedSwitch, extract_synopsis_command,
|
|
parse_manpage_string, strip_groff_escapes,
|
|
};
|
|
use inshellah::parsers::nushell::{generate_extern, generate_module};
|
|
use inshellah::store::parse_nu_completions;
|
|
use inshellah::types::{HelpResult, Param, Switch};
|
|
|
|
fn parse(txt: &str) -> HelpResult<'_> {
|
|
match help_parser(txt) {
|
|
Ok((_, r)) => r,
|
|
Err(e) => panic!("parse_help failed: {e:?}"),
|
|
}
|
|
}
|
|
|
|
// --- Help parser tests ---
|
|
|
|
#[test]
|
|
fn gnu_basic() {
|
|
let r = parse(" -a, --all do not ignore entries starting with .\n");
|
|
assert_eq!(r.entries.len(), 1);
|
|
let e = &r.entries[0];
|
|
assert!(matches!(&e.switch, Switch::Both('a', l) if *l == "all"));
|
|
assert!(e.param.is_none());
|
|
assert!(!e.desc.is_empty());
|
|
}
|
|
|
|
#[test]
|
|
fn gnu_eq_param() {
|
|
let r = parse(" --block-size=SIZE scale sizes by SIZE\n");
|
|
assert_eq!(r.entries.len(), 1);
|
|
let e = &r.entries[0];
|
|
assert!(matches!(&e.switch, Switch::Long(l) if *l == "block-size"));
|
|
assert!(matches!(&e.param, Some(Param::Mandatory(p)) if *p == "SIZE"));
|
|
}
|
|
|
|
#[test]
|
|
fn gnu_opt_param() {
|
|
let r = parse(" --color[=WHEN] color the output WHEN\n");
|
|
assert_eq!(r.entries.len(), 1);
|
|
let e = &r.entries[0];
|
|
assert!(matches!(&e.switch, Switch::Long(l) if *l == "color"));
|
|
assert!(matches!(&e.param, Some(Param::Optional(p)) if *p == "WHEN"));
|
|
}
|
|
|
|
#[test]
|
|
fn underscore_param() {
|
|
let r = parse(" --time-style=TIME_STYLE time/date format\n");
|
|
assert_eq!(r.entries.len(), 1);
|
|
let e = &r.entries[0];
|
|
assert!(matches!(&e.param, Some(Param::Mandatory(p)) if *p == "TIME_STYLE"));
|
|
}
|
|
|
|
#[test]
|
|
fn short_only() {
|
|
let r = parse(" -v verbose output\n");
|
|
assert_eq!(r.entries.len(), 1);
|
|
assert!(matches!(r.entries[0].switch, Switch::Short('v')));
|
|
}
|
|
|
|
#[test]
|
|
fn long_only() {
|
|
let r = parse(" --help display help\n");
|
|
assert_eq!(r.entries.len(), 1);
|
|
assert!(matches!(&r.entries[0].switch, Switch::Long(l) if *l == "help"));
|
|
}
|
|
|
|
#[test]
|
|
fn multiline_desc() {
|
|
let txt = " --block-size=SIZE with -l, scale sizes by SIZE when printing them;\n e.g., '--block-size=M'; see SIZE format below\n";
|
|
let r = parse(txt);
|
|
assert_eq!(r.entries.len(), 1);
|
|
let combined: String = r.entries[0].desc.join(" ");
|
|
assert!(combined.len() > 50, "desc was: {combined}");
|
|
}
|
|
|
|
#[test]
|
|
fn multiple_entries() {
|
|
let txt = " -a, --all do not ignore entries starting with .\n -A, --almost-all do not list implied . and ..\n --author with -l, print the author of each file\n";
|
|
let r = parse(txt);
|
|
assert_eq!(r.entries.len(), 3);
|
|
}
|
|
|
|
#[test]
|
|
fn clap_short_sections() {
|
|
let txt = "INPUT OPTIONS:\n -e, --regexp=PATTERN A pattern to search for.\n -f, --file=PATTERNFILE Search for patterns from the given file.\nSEARCH OPTIONS:\n -s, --case-sensitive Search case sensitively.\n";
|
|
let r = parse(txt);
|
|
assert_eq!(r.entries.len(), 3);
|
|
let e = &r.entries[0];
|
|
assert!(matches!(&e.switch, Switch::Both('e', l) if *l == "regexp"));
|
|
assert!(matches!(&e.param, Some(Param::Mandatory(p)) if *p == "PATTERN"));
|
|
}
|
|
|
|
#[test]
|
|
fn clap_long_style() {
|
|
let txt = " -H, --hidden\n Include hidden directories and files.\n\n --no-ignore\n Do not respect ignore files.\n";
|
|
let r = parse(txt);
|
|
assert_eq!(r.entries.len(), 2);
|
|
let e = &r.entries[0];
|
|
assert!(matches!(&e.switch, Switch::Both('H', l) if *l == "hidden"));
|
|
assert!(!e.desc.is_empty());
|
|
}
|
|
|
|
#[test]
|
|
fn clap_long_angle_param() {
|
|
let txt = " --nonprintable-notation <notation>\n Set notation for non-printable characters.\n";
|
|
let r = parse(txt);
|
|
assert_eq!(r.entries.len(), 1);
|
|
let e = &r.entries[0];
|
|
assert!(matches!(&e.switch, Switch::Long(l) if *l == "nonprintable-notation"));
|
|
assert!(matches!(&e.param, Some(Param::Mandatory(p)) if *p == "notation"));
|
|
}
|
|
|
|
#[test]
|
|
fn space_upper_param() {
|
|
let r = parse(" -f, --foo FOO foo help\n");
|
|
assert_eq!(r.entries.len(), 1);
|
|
let e = &r.entries[0];
|
|
assert!(matches!(&e.switch, Switch::Both('f', l) if *l == "foo"));
|
|
assert!(matches!(&e.param, Some(Param::Mandatory(p)) if *p == "FOO"));
|
|
}
|
|
|
|
#[test]
|
|
fn go_cobra_flags() {
|
|
let txt = "Flags:\n -D, --debug Enable debug mode\n -H, --host string Daemon socket to connect to\n -v, --version Print version information\n";
|
|
let r = parse(txt);
|
|
assert_eq!(r.entries.len(), 3);
|
|
let host = &r.entries[1];
|
|
assert!(matches!(&host.switch, Switch::Both('H', l) if *l == "host"));
|
|
assert!(matches!(&host.param, Some(Param::Mandatory(p)) if *p == "string"));
|
|
}
|
|
|
|
#[test]
|
|
fn go_cobra_subcommands() {
|
|
let txt = "Common Commands:\n run Create and run a new container from an image\n exec Execute a command in a running container\n build Build an image from a Dockerfile\n";
|
|
let r = parse(txt);
|
|
assert!(!r.subcommands.is_empty(), "expected subcommands, got: {:?}", r.subcommands.len());
|
|
}
|
|
|
|
#[test]
|
|
fn busybox_tab() {
|
|
let r = parse("\t-1\tOne column output\n\t-a\tInclude names starting with .\n");
|
|
assert_eq!(r.entries.len(), 2);
|
|
assert!(matches!(r.entries[0].switch, Switch::Short('1')));
|
|
}
|
|
|
|
#[test]
|
|
fn no_debug_prints() {
|
|
// the old ocaml parser had print_endline at module load time; this test
|
|
// documents that no such side effects exist in the rust port.
|
|
let _ = parse(" -v verbose\n");
|
|
}
|
|
|
|
#[test]
|
|
fn slash_switch_separator() {
|
|
let r = parse(" --verbose / -v Increase verbosity\n");
|
|
assert_eq!(r.entries.len(), 1);
|
|
let e = &r.entries[0];
|
|
assert!(matches!(&e.switch, Switch::Both('v', l) if *l == "verbose"));
|
|
assert!(e.param.is_none());
|
|
let combined: String = e.desc.join(" ");
|
|
assert_eq!(combined.trim(), "Increase verbosity");
|
|
}
|
|
|
|
// --- Manpage parser tests ---
|
|
|
|
#[test]
|
|
fn manpage_tp_style() {
|
|
let groff = r#".SH OPTIONS
|
|
.TP
|
|
\fB\-a\fR, \fB\-\-all\fR
|
|
do not ignore entries starting with .
|
|
.TP
|
|
\fB\-A\fR, \fB\-\-almost\-all\fR
|
|
do not list implied . and ..
|
|
.TP
|
|
\fB\-\-block\-size\fR=\fISIZE\fR
|
|
with \fB\-l\fR, scale sizes by SIZE
|
|
.SH AUTHOR
|
|
Written by someone.
|
|
"#;
|
|
let r = parse_manpage_string(groff);
|
|
assert_eq!(r.entries.len(), 3, "entries: {:?}", r.entries);
|
|
assert!(matches!(&r.entries[0].switch, OwnedSwitch::Both('a', l) if l == "all"));
|
|
assert!(!r.entries[0].desc.is_empty());
|
|
assert!(matches!(&r.entries[2].switch, OwnedSwitch::Long(l) if l == "block-size"));
|
|
assert!(matches!(&r.entries[2].param, Some(OwnedParam::Mandatory(p)) if p == "SIZE"));
|
|
}
|
|
|
|
#[test]
|
|
fn manpage_ip_style() {
|
|
let groff = r#".SH OPTIONS
|
|
.IP "\fB\-k\fR, \fB\-\-insecure\fR"
|
|
Allow insecure connections.
|
|
.IP "\fB\-o\fR, \fB\-\-output\fR \fIfile\fR"
|
|
Write output to file.
|
|
.SH SEE ALSO
|
|
"#;
|
|
let r = parse_manpage_string(groff);
|
|
assert_eq!(r.entries.len(), 2, "entries: {:?}", r.entries);
|
|
assert!(matches!(&r.entries[0].switch, OwnedSwitch::Both('k', l) if l == "insecure"));
|
|
}
|
|
|
|
#[test]
|
|
fn manpage_groff_stripping() {
|
|
let s = strip_groff_escapes(r#"\fB\-\-color\fR[=\fIWHEN\fR]"#);
|
|
// font escapes removed
|
|
assert!(!(s.contains('f') && s.contains('B') && s.contains('\\')));
|
|
// dashes converted
|
|
assert!(s.contains('-'));
|
|
let s2 = strip_groff_escapes(r#"\(aqhello\(aq"#);
|
|
assert!(s2.contains('\''), "expected apostrophe in: {s2}");
|
|
}
|
|
|
|
#[test]
|
|
fn manpage_empty_options() {
|
|
let groff = ".SH NAME\nfoo \\- does stuff\n.SH DESCRIPTION\nDoes stuff.\n";
|
|
let r = parse_manpage_string(groff);
|
|
assert_eq!(r.entries.len(), 0);
|
|
}
|
|
|
|
#[test]
|
|
fn manpage_nix3_style() {
|
|
let groff = r#".SH Options
|
|
.SS Logging-related options
|
|
.IP "\(bu" 3
|
|
.UR #opt-verbose
|
|
\f(CR--verbose\fR
|
|
.UE
|
|
/ \f(CR-v\fR
|
|
.IP
|
|
Increase the logging verbosity level.
|
|
.IP "\(bu" 3
|
|
.UR #opt-quiet
|
|
\f(CR--quiet\fR
|
|
.UE
|
|
.IP
|
|
Decrease the logging verbosity level.
|
|
.SH SEE ALSO
|
|
"#;
|
|
let r = parse_manpage_string(groff);
|
|
assert_eq!(r.entries.len(), 2, "entries: {:?}", r.entries);
|
|
assert!(matches!(&r.entries[0].switch, OwnedSwitch::Both('v', l) if l == "verbose"));
|
|
assert!(!r.entries[0].desc.is_empty());
|
|
assert!(matches!(&r.entries[1].switch, OwnedSwitch::Long(l) if l == "quiet"));
|
|
assert!(!r.entries[1].desc.is_empty());
|
|
}
|
|
|
|
#[test]
|
|
fn manpage_nix3_with_params() {
|
|
let groff = r#".SH Options
|
|
.IP "\(bu" 3
|
|
.UR #opt-arg
|
|
\f(CR--arg\fR
|
|
.UE
|
|
\fIname\fR \fIexpr\fR
|
|
.IP
|
|
Pass the value as the argument name to Nix functions.
|
|
.IP "\(bu" 3
|
|
.UR #opt-include
|
|
\f(CR--include\fR
|
|
.UE
|
|
/ \f(CR-I\fR \fIpath\fR
|
|
.IP
|
|
Add path to search path entries.
|
|
.IP
|
|
This option may be given multiple times.
|
|
.SH SEE ALSO
|
|
"#;
|
|
let r = parse_manpage_string(groff);
|
|
assert_eq!(r.entries.len(), 2, "entries: {:?}", r.entries);
|
|
assert!(matches!(&r.entries[0].switch, OwnedSwitch::Long(l) if l == "arg"));
|
|
assert!(r.entries[0].param.is_some());
|
|
assert!(matches!(&r.entries[1].switch, OwnedSwitch::Both('I', l) if l == "include"));
|
|
assert!(matches!(&r.entries[1].param, Some(OwnedParam::Mandatory(p)) if p == "path"));
|
|
}
|
|
|
|
#[test]
|
|
fn synopsis_subcommand() {
|
|
let groff = r#".SH "SYNOPSIS"
|
|
.sp
|
|
.nf
|
|
\fBgit\fR \fBcommit\fR [\fB\-a\fR | \fB\-\-interactive\fR]
|
|
.fi
|
|
.SH "DESCRIPTION"
|
|
"#;
|
|
let cmd = extract_synopsis_command(groff);
|
|
assert_eq!(cmd.as_deref(), Some("git commit"));
|
|
}
|
|
|
|
#[test]
|
|
fn synopsis_standalone() {
|
|
let groff = ".SH Synopsis\n.LP\n\\f(CRnix-build\\fR [\\fIpaths\\fR]\n.SH Description\n";
|
|
let cmd = extract_synopsis_command(groff);
|
|
assert_eq!(cmd.as_deref(), Some("nix-build"));
|
|
}
|
|
|
|
#[test]
|
|
fn synopsis_nix3() {
|
|
let groff = ".SH Synopsis\n.LP\n\\f(CRnix run\\fR [\\fIoption\\fR] \\fIinstallable\\fR\n.SH Description\n";
|
|
let cmd = extract_synopsis_command(groff);
|
|
assert_eq!(cmd.as_deref(), Some("nix run"));
|
|
}
|
|
|
|
#[test]
|
|
fn italic_synopsis() {
|
|
let groff = ".SH Synopsis\n.LP\n\\f(CRnix-env\\fR \\fIoperation\\fR [\\fIoptions\\fR] [\\fIarguments…\\fR]\n.SH Description\n";
|
|
let cmd = extract_synopsis_command(groff);
|
|
assert_eq!(cmd.as_deref(), Some("nix-env"));
|
|
}
|
|
|
|
#[test]
|
|
fn synopsis_italic_command_name() {
|
|
// git-am.1 (and many other git manpages) put the entire command
|
|
// invocation in italics: `\fIgit am\fR [...]`. should still resolve
|
|
// to "git am" rather than treating it as a placeholder.
|
|
let groff = ".SH \"SYNOPSIS\"\n.sp\n.nf\n\\fIgit am\\fR [\\-\\-signoff] [\\-\\-keep]\n.fi\n.SH \"DESCRIPTION\"\n";
|
|
let cmd = extract_synopsis_command(groff);
|
|
assert_eq!(cmd.as_deref(), Some("git am"));
|
|
}
|
|
|
|
// --- Font/dedup tests (only the font-spacing one is portable) ---
|
|
|
|
#[test]
|
|
fn font_boundary_spacing() {
|
|
// \fB--max-results\fR\fIcount\fR should become "--max-results count"
|
|
let s = strip_groff_escapes(r#"\fB\-\-max\-results\fR\fIcount\fR"#);
|
|
assert!(s.contains("--max-results count"), "got: {s}");
|
|
// \fB--color\fR[=\fIWHEN\fR] should NOT insert space before =
|
|
let s2 = strip_groff_escapes(r#"\fB\-\-color\fR[=\fIWHEN\fR]"#);
|
|
assert!(s2.contains("--color[=WHEN]"), "got: {s2}");
|
|
}
|
|
|
|
// --- COMMANDS section tests ---
|
|
|
|
#[test]
|
|
fn commands_section_subcommands() {
|
|
let groff = r#".SH OPTIONS
|
|
.TP
|
|
\fB\-\-user\fR
|
|
Talk to the service manager of the calling user.
|
|
.TP
|
|
\fB\-\-system\fR
|
|
Talk to the service manager of the system.
|
|
.SH COMMANDS
|
|
.PP
|
|
\fBstart\fR \fIUNIT\fR\&...
|
|
.RS 4
|
|
Start (activate) one or more units.
|
|
.RE
|
|
.PP
|
|
\fBstop\fR \fIUNIT\fR\&...
|
|
.RS 4
|
|
Stop (deactivate) one or more units.
|
|
.RE
|
|
.PP
|
|
\fBreload\fR \fIUNIT\fR\&...
|
|
.RS 4
|
|
Asks all units to reload their configuration.
|
|
.RE
|
|
.SH SEE ALSO
|
|
"#;
|
|
let r = parse_manpage_string(groff);
|
|
assert_eq!(r.entries.len(), 2, "options entries: {:?}", r.entries);
|
|
assert_eq!(r.subcommands.len(), 3, "subcommands: {:?}", r.subcommands);
|
|
let names: Vec<&str> = r.subcommands.iter().map(|sc| sc.name.as_str()).collect();
|
|
assert!(names.contains(&"start"));
|
|
assert!(names.contains(&"stop"));
|
|
assert!(names.contains(&"reload"));
|
|
let start_sc = r.subcommands.iter().find(|sc| sc.name == "start").unwrap();
|
|
assert!(!start_sc.desc.is_empty());
|
|
}
|
|
|
|
// --- Nushell generation tests ---
|
|
|
|
fn to_owned_result(r: &HelpResult<'_>) -> ManpageResult {
|
|
r.into()
|
|
}
|
|
|
|
#[test]
|
|
fn nushell_basic() {
|
|
let r = parse(" -a, --all do not ignore entries starting with .\n");
|
|
let nu = generate_extern("ls", &to_owned_result(&r));
|
|
assert!(nu.contains("export extern \"ls\""), "nu = {nu}");
|
|
assert!(nu.contains("--all(-a)"), "nu = {nu}");
|
|
assert!(nu.contains("# do not ignore"), "nu = {nu}");
|
|
}
|
|
|
|
#[test]
|
|
fn nushell_param_types() {
|
|
let txt = " -w, --width=COLS set output width\n --block-size=SIZE scale sizes\n -o, --output FILE output file\n";
|
|
let r = parse(txt);
|
|
let nu = generate_extern("ls", &to_owned_result(&r));
|
|
assert!(nu.contains("--width(-w): int"), "nu = {nu}");
|
|
assert!(nu.contains("--block-size: string"), "nu = {nu}");
|
|
assert!(nu.contains("--output(-o): path"), "nu = {nu}");
|
|
}
|
|
|
|
#[test]
|
|
fn nushell_subcommands() {
|
|
let txt = "Common Commands:\n run Create and run a new container\n exec Execute a command\n\nFlags:\n -D, --debug Enable debug mode\n";
|
|
let r = parse(txt);
|
|
let nu = generate_extern("docker", &to_owned_result(&r));
|
|
assert!(nu.contains("export extern \"docker\""), "nu = {nu}");
|
|
assert!(nu.contains("--debug(-D)"), "nu = {nu}");
|
|
assert!(nu.contains("export extern \"docker run\""), "nu = {nu}");
|
|
assert!(nu.contains("export extern \"docker exec\""), "nu = {nu}");
|
|
}
|
|
|
|
#[test]
|
|
fn nushell_from_manpage() {
|
|
let groff = r#".SH OPTIONS
|
|
.TP
|
|
\fB\-a\fR, \fB\-\-all\fR
|
|
do not ignore entries starting with .
|
|
.TP
|
|
\fB\-\-block\-size\fR=\fISIZE\fR
|
|
scale sizes by SIZE
|
|
.SH AUTHOR
|
|
"#;
|
|
let result = parse_manpage_string(groff);
|
|
let nu = generate_extern("ls", &result);
|
|
assert!(nu.contains("export extern \"ls\""), "nu = {nu}");
|
|
assert!(nu.contains("--all(-a)"), "nu = {nu}");
|
|
assert!(nu.contains("--block-size: string"), "nu = {nu}");
|
|
}
|
|
|
|
#[test]
|
|
fn nushell_module() {
|
|
let r = parse(" -v, --verbose verbose output\n");
|
|
let nu = generate_module("myapp", &to_owned_result(&r));
|
|
assert!(nu.contains("module myapp-completions"), "nu = {nu}");
|
|
assert!(nu.contains("export extern \"myapp\""), "nu = {nu}");
|
|
assert!(nu.contains("--verbose(-v)"), "nu = {nu}");
|
|
}
|
|
|
|
#[test]
|
|
fn dedup_entries_help() {
|
|
let txt = " -v, --verbose verbose output\n --verbose verbose mode\n -v be verbose\n";
|
|
let r = parse(txt);
|
|
let nu = generate_extern("test", &to_owned_result(&r));
|
|
let count = nu.matches("--verbose").count();
|
|
assert_eq!(count, 1, "expected --verbose to appear once, nu = {nu}");
|
|
assert!(nu.contains("--verbose(-v)"), "nu = {nu}");
|
|
}
|
|
|
|
#[test]
|
|
fn dedup_manpage_entries() {
|
|
let groff = r#".SH OPTIONS
|
|
.TP
|
|
\fB\-v\fR, \fB\-\-verbose\fR
|
|
Be verbose.
|
|
.SH DESCRIPTION
|
|
Use \fB\-v\fR for verbose output.
|
|
Use \fB\-\-verbose\fR to see more.
|
|
"#;
|
|
let result = parse_manpage_string(groff);
|
|
let nu = generate_extern("test", &result);
|
|
assert!(nu.contains("--verbose(-v)"), "nu = {nu}");
|
|
let verbose_lines: Vec<&str> =
|
|
nu.lines().filter(|l| l.contains("verbose")).collect();
|
|
assert_eq!(verbose_lines.len(), 1, "expected 1 verbose line, got: {verbose_lines:?}");
|
|
}
|
|
|
|
#[test]
|
|
fn nu_file_parsing() {
|
|
let nu_source = r#"module completions {
|
|
|
|
# Unofficial CLI tool
|
|
export extern mytool [
|
|
--help(-h) # Print help
|
|
--version(-V) # Print version
|
|
]
|
|
|
|
# List all items
|
|
export extern "mytool list" [
|
|
--raw # Output as JSON
|
|
--format(-f): string # Output format
|
|
--help(-h) # Print help
|
|
name?: string # Filter by name
|
|
]
|
|
|
|
}
|
|
|
|
use completions *
|
|
"#;
|
|
let r = parse_nu_completions("mytool", nu_source);
|
|
assert_eq!(r.entries.len(), 2, "entries: {:?}", r.entries);
|
|
assert!(!r.subcommands.is_empty(), "subcommands: {:?}", r.subcommands);
|
|
assert!(r.subcommands.iter().any(|sc| sc.name == "list"));
|
|
assert_eq!(r.description, "Unofficial CLI tool");
|
|
|
|
let r2 = parse_nu_completions("mytool list", nu_source);
|
|
assert_eq!(r2.entries.len(), 3, "list entries: {:?}", r2.entries);
|
|
let has_format = r2.entries.iter().any(
|
|
|e| matches!(&e.switch, OwnedSwitch::Both('f', l) if l == "format"),
|
|
);
|
|
assert!(has_format, "list should have --format(-f): {:?}", r2.entries);
|
|
assert!(!r2.positionals.is_empty(), "list should have a positional");
|
|
}
|
|
|
|
#[test]
|
|
fn self_listing_detection() {
|
|
let txt = r#"systemctl [OPTIONS...] COMMAND ...
|
|
|
|
Unit Commands:
|
|
start UNIT... Start (activate) one or more units
|
|
stop UNIT... Stop (deactivate) one or more units
|
|
status [PATTERN...] Show runtime status
|
|
|
|
Options:
|
|
--user Talk to the user service manager
|
|
--system Talk to the system service manager
|
|
"#;
|
|
let r = parse(txt);
|
|
let has_start = r.subcommands.iter().any(|sc| sc.name == "start");
|
|
assert!(has_start, "expected start in subcommands: {:?}",
|
|
r.subcommands.iter().map(|sc| sc.name).collect::<Vec<_>>());
|
|
assert!(r.entries.len() >= 2);
|
|
}
|