use unilang_parser :: *;
use unilang_parser ::error ::ErrorKind;
use unilang_parser ::UnilangParserOptions;
#[ test ]
fn tm2_1_multi_segment_path_with_positional_arg()
{
let parser = Parser ::new( UnilangParserOptions ::default() );
let input = "cmd.sub.another arg";
let result = parser.parse_repl_input( input );
assert!( result.is_ok(), "Parse failed for input '{}' : {:?}", input, result.err() );
let instruction = result.unwrap();
assert_eq!(
instruction.command_path_slices,
vec![ "cmd".to_string(), "sub".to_string(), "another".to_string() ]
);
assert_eq!( instruction.positional_arguments.len(), 1 );
assert_eq!( instruction.positional_arguments[ 0 ].value, "arg".to_string() );
assert!( instruction.named_arguments.is_empty() );
assert!( !instruction.help_requested );
}
#[ test ]
fn tm2_2_command_path_ends_with_named_arg()
{
let parser = Parser ::new( UnilangParserOptions ::default() );
let input = "cmd arg ::val";
let result = parser.parse_repl_input( input );
assert!( result.is_ok(), "Parse failed for input '{}' : {:?}", input, result.err() );
let instruction = result.unwrap();
assert_eq!( instruction.command_path_slices, vec![ "cmd".to_string() ] );
assert!( instruction.positional_arguments.is_empty() );
assert_eq!( instruction.named_arguments.len(), 1 );
assert_eq!( instruction.named_arguments.get( "arg" ).unwrap()[0].value, "val".to_string() );
assert!( !instruction.help_requested );
}
#[ test ]
fn tm2_3_command_path_ends_with_quoted_string()
{
let parser = Parser ::new( UnilangParserOptions ::default() );
let input = "cmd \"quoted_arg\"";
let result = parser.parse_repl_input( input );
assert!( result.is_ok(), "Parse failed for input '{}' : {:?}", input, result.err() );
let instruction = result.unwrap();
assert_eq!( instruction.command_path_slices, vec![ "cmd".to_string() ] );
assert_eq!( instruction.positional_arguments.len(), 1 );
assert_eq!( instruction.positional_arguments[ 0 ].value, "quoted_arg".to_string() );
assert!( instruction.named_arguments.is_empty() );
assert!( !instruction.help_requested );
}
#[ test ]
fn tm2_4_command_path_ends_with_comment_operator()
{
let parser = Parser ::new( UnilangParserOptions ::default() );
let input = "cmd #comment";
let result = parser.parse_repl_input( input );
assert!(
result.is_err(),
"Expected error for input '{}', but got Ok: {:?}",
input,
result.ok()
);
if let Err( e ) = result
{
assert_eq!( e.kind, ErrorKind ::Syntax( "Unexpected token '#' in arguments".to_string() ) );
}
}
#[ test ]
fn tm2_5_trailing_dot_after_command_path()
{
let parser = Parser ::new( UnilangParserOptions ::default() );
let input = "cmd.";
let result = parser.parse_repl_input( input );
assert!(
result.is_err(),
"Expected error for input '{}', but got Ok: {:?}",
input,
result.ok()
);
if let Err( e ) = result
{
assert_eq!( e.kind, ErrorKind ::Syntax( "Command path cannot end with a '.'".to_string() ) );
}
}
#[ test ]
fn tm2_6_named_arg_followed_by_help_operator()
{
let parser = Parser ::new( UnilangParserOptions ::default() );
let input = "cmd name ::val ?";
let result = parser.parse_repl_input( input );
assert!( result.is_ok(), "Parse failed for input '{}' : {:?}", input, result.err() );
let instruction = result.unwrap();
assert_eq!( instruction.command_path_slices, vec![ "cmd".to_string() ] );
assert!( instruction.positional_arguments.is_empty() );
assert_eq!( instruction.named_arguments.len(), 1 );
assert_eq!( instruction.named_arguments.get( "name" ).unwrap()[0].value, "val".to_string() );
assert!( instruction.help_requested );
}
#[ test ]
fn tm2_7_help_operator_followed_by_other_tokens()
{
let parser = Parser ::new( UnilangParserOptions ::default() );
let input = "cmd ? arg";
let result = parser.parse_repl_input( input );
assert!(
result.is_err(),
"Expected error for input '{}', but got Ok: {:?}",
input,
result.ok()
);
if let Err( e ) = result
{
assert_eq!(
e.kind,
ErrorKind ::Syntax( "Help operator '?' must be the last token".to_string() )
);
}
}
#[ test ]
fn tm2_8_named_arg_with_simple_quoted_value()
{
let parser = Parser ::new( UnilangParserOptions ::default() );
let input = "cmd name :: \"value with spaces\"";
let result = parser.parse_repl_input( input );
assert!( result.is_ok(), "Parse failed for input '{}' : {:?}", input, result.err() );
let instruction = result.unwrap();
assert_eq!( instruction.command_path_slices, vec![ "cmd".to_string() ] );
assert!( instruction.positional_arguments.is_empty() );
assert_eq!( instruction.named_arguments.len(), 1 );
assert_eq!(
instruction.named_arguments.get( "name" ).unwrap()[0].value,
"value with spaces".to_string()
);
assert!( !instruction.help_requested );
}
#[ test ]
fn tm2_9_named_arg_with_quoted_value_containing_double_colon()
{
let parser = Parser ::new( UnilangParserOptions ::default() );
let input = "cmd msg :: \"DEPRECATED ::message\"";
let result = parser.parse_repl_input( input );
assert!( result.is_ok(), "Parse failed for input '{}' : {:?}", input, result.err() );
let instruction = result.unwrap();
assert_eq!( instruction.command_path_slices, vec![ "cmd".to_string() ] );
assert!( instruction.positional_arguments.is_empty() );
assert_eq!( instruction.named_arguments.len(), 1 );
assert_eq!(
instruction.named_arguments.get( "msg" ).unwrap()[0].value,
"DEPRECATED ::message".to_string()
);
assert!( !instruction.help_requested );
}
#[ test ]
fn tm2_10_multiple_named_args_with_simple_quoted_values()
{
let parser = Parser ::new( UnilangParserOptions ::default() );
let input = "cmd name1 :: \"val1\" name2 :: \"val2\"";
let result = parser.parse_repl_input( input );
assert!( result.is_ok(), "Parse failed for input '{}' : {:?}", input, result.err() );
let instruction = result.unwrap();
assert_eq!( instruction.command_path_slices, vec![ "cmd".to_string() ] );
assert!( instruction.positional_arguments.is_empty() );
assert_eq!( instruction.named_arguments.len(), 2 );
assert_eq!( instruction.named_arguments.get( "name1" ).unwrap()[0].value, "val1".to_string() );
assert_eq!( instruction.named_arguments.get( "name2" ).unwrap()[0].value, "val2".to_string() );
assert!( !instruction.help_requested );
}
#[ test ]
fn tm2_11_named_arg_with_comma_separated_value()
{
let parser = Parser ::new( UnilangParserOptions ::default() );
let input = "cmd tags ::dev,rust,unilang";
let result = parser.parse_repl_input( input );
assert!( result.is_ok(), "Parse failed for input '{}' : {:?}", input, result.err() );
let instruction = result.unwrap();
assert_eq!( instruction.command_path_slices, vec![ "cmd".to_string() ] );
assert!( instruction.positional_arguments.is_empty() );
assert_eq!( instruction.named_arguments.len(), 1 );
assert_eq!(
instruction.named_arguments.get( "tags" ).unwrap()[0].value,
"dev,rust,unilang".to_string()
);
assert!( !instruction.help_requested );
}
#[ test ]
fn tm2_12_named_arg_with_key_value_pair_string()
{
let parser = Parser ::new( UnilangParserOptions ::default() );
let input = "cmd headers ::Content-Type=application/json,Auth-Token=xyz";
let result = parser.parse_repl_input( input );
assert!( result.is_ok(), "Parse failed for input '{}' : {:?}", input, result.err() );
let instruction = result.unwrap();
assert_eq!( instruction.command_path_slices, vec![ "cmd".to_string() ] );
assert!( instruction.positional_arguments.is_empty() );
assert_eq!( instruction.named_arguments.len(), 1 );
assert_eq!(
instruction.named_arguments.get( "headers" ).unwrap()[0].value,
"Content-Type=application/json,Auth-Token=xyz".to_string()
);
assert!( !instruction.help_requested );
}
#[ test ]
fn s6_1_whitespace_separation_and_command_path()
{
let parser = Parser ::new( UnilangParserOptions ::default() );
let input = " cmd.sub arg1 ";
let result = parser.parse_repl_input( input );
assert!( result.is_ok(), "Parse failed for input '{}' : {:?}", input, result.err() );
let instruction = result.unwrap();
assert_eq!( instruction.command_path_slices, vec![ "cmd".to_string(), "sub".to_string() ] );
assert_eq!( instruction.positional_arguments.len(), 1 );
assert_eq!( instruction.positional_arguments[ 0 ].value, "arg1".to_string() );
}
#[ test ]
fn s6_2_whitespace_in_quoted_positional_arg()
{
let parser = Parser ::new( UnilangParserOptions ::default() );
let input = "cmd \"val with spaces\"";
let result = parser.parse_repl_input( input );
assert!( result.is_ok(), "Parse failed for input '{}' : {:?}", input, result.err() );
let instruction = result.unwrap();
assert_eq!( instruction.command_path_slices, vec![ "cmd".to_string() ] );
assert_eq!( instruction.positional_arguments.len(), 1 );
assert_eq!( instruction.positional_arguments[ 0 ].value, "val with spaces".to_string() );
}
#[ test ]
fn s6_3_multi_segment_path_and_positional_arg_transition()
{
let parser = Parser ::new( UnilangParserOptions ::default() );
let input = "cmd.sub.action arg1";
let result = parser.parse_repl_input( input );
assert!( result.is_ok(), "Parse failed for input '{}' : {:?}", input, result.err() );
let instruction = result.unwrap();
assert_eq!(
instruction.command_path_slices,
vec![ "cmd".to_string(), "sub".to_string(), "action".to_string() ]
);
assert_eq!( instruction.positional_arguments.len(), 1 );
assert_eq!( instruction.positional_arguments[ 0 ].value, "arg1".to_string() );
}
#[ test ]
fn s6_4_multi_segment_path_and_named_arg_transition()
{
let parser = Parser ::new( UnilangParserOptions ::default() );
let input = "cmd.sub name ::val";
let result = parser.parse_repl_input( input );
assert!( result.is_ok(), "Parse failed for input '{}' : {:?}", input, result.err() );
let instruction = result.unwrap();
assert_eq!( instruction.command_path_slices, vec![ "cmd".to_string(), "sub".to_string() ] );
assert_eq!( instruction.named_arguments.len(), 1 );
assert_eq!( instruction.named_arguments.get( "name" ).unwrap()[0].value, "val".to_string() );
}
#[ test ]
fn s6_5_leading_dot_command_with_arg()
{
let parser = Parser ::new( UnilangParserOptions ::default() );
let input = ".cmd arg";
let result = parser.parse_repl_input( input );
assert!( result.is_ok(), "Parse failed for input '{}' : {:?}", input, result.err() );
let instruction = result.unwrap();
assert_eq!( instruction.command_path_slices, vec![ "cmd".to_string() ] );
assert_eq!( instruction.positional_arguments.len(), 1 );
assert_eq!( instruction.positional_arguments[ 0 ].value, "arg".to_string() );
}
#[ test ]
fn s6_6_trailing_dot_syntax_error()
{
let parser = Parser ::new( UnilangParserOptions ::default() );
let input = "cmd.";
let result = parser.parse_repl_input( input );
assert!(
result.is_err(),
"Expected error for input '{}', but got Ok: {:?}",
input,
result.ok()
);
if let Err( e ) = result
{
assert_eq!( e.kind, ErrorKind ::Syntax( "Command path cannot end with a '.'".to_string() ) );
}
}
#[ test ]
fn s6_7_consecutive_dots_syntax_error()
{
let parser = Parser ::new( UnilangParserOptions ::default() );
let input = "cmd..sub";
let result = parser.parse_repl_input( input );
assert!(
result.is_err(),
"Expected error for input '{}', but got Ok: {:?}",
input,
result.ok()
);
if let Err( e ) = result
{
assert_eq!( e.kind, ErrorKind ::Syntax( "Consecutive dots in command path".to_string() ) );
}
}
#[ test ]
fn s6_8_help_operator_correct_placement()
{
let parser = Parser ::new( UnilangParserOptions ::default() );
let input = "cmd ?";
let result = parser.parse_repl_input( input );
assert!( result.is_ok(), "Parse failed for input '{}' : {:?}", input, result.err() );
let instruction = result.unwrap();
assert_eq!( instruction.command_path_slices, vec![ "cmd".to_string() ] );
assert!( instruction.help_requested );
}
#[ test ]
fn s6_9_named_arg_followed_by_help_operator()
{
let parser = Parser ::new( UnilangParserOptions ::default() );
let input = "cmd name ::val ?";
let result = parser.parse_repl_input( input );
assert!( result.is_ok(), "Parse failed for input '{}' : {:?}", input, result.err() );
let instruction = result.unwrap();
assert_eq!( instruction.command_path_slices, vec![ "cmd".to_string() ] );
assert_eq!( instruction.named_arguments.len(), 1 );
assert_eq!( instruction.named_arguments.get( "name" ).unwrap()[0].value, "val".to_string() );
assert!( instruction.help_requested );
}
#[ test ]
fn s6_10_help_operator_followed_by_other_tokens_error()
{
let parser = Parser ::new( UnilangParserOptions ::default() );
let input = "cmd ? arg";
let result = parser.parse_repl_input( input );
assert!(
result.is_err(),
"Expected error for input '{}', but got Ok: {:?}",
input,
result.ok()
);
if let Err( e ) = result
{
assert_eq!(
e.kind,
ErrorKind ::Syntax( "Help operator '?' must be the last token".to_string() )
);
}
}
#[ test ]
fn s6_11_multiple_positional_arguments()
{
let parser = Parser ::new( UnilangParserOptions ::default() );
let input = "cmd pos1 pos2";
let result = parser.parse_repl_input( input );
assert!( result.is_ok(), "Parse failed for input '{}' : {:?}", input, result.err() );
let instruction = result.unwrap();
assert_eq!( instruction.command_path_slices, vec![ "cmd".to_string() ] );
assert_eq!( instruction.positional_arguments.len(), 2 );
assert_eq!( instruction.positional_arguments[ 0 ].value, "pos1".to_string() );
assert_eq!( instruction.positional_arguments[ 1 ].value, "pos2".to_string() );
}
#[ test ]
fn s6_12_single_named_argument()
{
let parser = Parser ::new( UnilangParserOptions ::default() );
let input = "cmd key ::val";
let result = parser.parse_repl_input( input );
assert!( result.is_ok(), "Parse failed for input '{}' : {:?}", input, result.err() );
let instruction = result.unwrap();
assert_eq!( instruction.command_path_slices, vec![ "cmd".to_string() ] );
assert_eq!( instruction.named_arguments.len(), 1 );
assert_eq!( instruction.named_arguments.get( "key" ).unwrap()[0].value, "val".to_string() );
}
#[ test ]
fn s6_13_named_arg_quoted_value_with_spaces()
{
let parser = Parser ::new( UnilangParserOptions ::default() );
let input = "cmd key :: \"val with spaces\"";
let result = parser.parse_repl_input( input );
assert!( result.is_ok(), "Parse failed for input '{}' : {:?}", input, result.err() );
let instruction = result.unwrap();
assert_eq!( instruction.command_path_slices, vec![ "cmd".to_string() ] );
assert_eq!( instruction.named_arguments.len(), 1 );
assert_eq!(
instruction.named_arguments.get( "key" ).unwrap()[0].value,
"val with spaces".to_string()
);
}
#[ test ]
fn s6_14_positional_after_named_allowed()
{
let parser = Parser ::new( UnilangParserOptions ::default() ); let input = "cmd name ::val pos1";
let result = parser.parse_repl_input( input );
assert!( result.is_ok(), "Parse failed for input '{}' : {:?}", input, result.err() );
let instruction = result.unwrap();
assert_eq!( instruction.command_path_slices, vec![ "cmd".to_string() ] );
assert_eq!( instruction.named_arguments.len(), 1 );
assert_eq!( instruction.named_arguments.get( "name" ).unwrap()[0].value, "val".to_string() );
assert_eq!( instruction.positional_arguments.len(), 1 );
assert_eq!( instruction.positional_arguments[ 0 ].value, "pos1".to_string() );
}
#[ test ]
fn s6_15_positional_after_named_error()
{
let parser = Parser ::new( UnilangParserOptions
{
error_on_positional_after_named: true,
..Default ::default()
});
let input = "cmd name ::val pos1";
let result = parser.parse_repl_input( input );
assert!(
result.is_err(),
"Expected error for input '{}', but got Ok: {:?}",
input,
result.ok()
);
if let Err( e ) = result
{
assert_eq!(
e.kind,
ErrorKind ::Syntax( "Positional argument after named argument".to_string() )
);
}
}
#[ test ]
fn s6_16_duplicate_named_arg_last_wins()
{
let parser = Parser ::new( UnilangParserOptions ::default() ); let input = "cmd name ::val1 name ::val2";
let result = parser.parse_repl_input( input );
assert!( result.is_ok(), "Parse failed for input '{}' : {:?}", input, result.err() );
let instruction = result.unwrap();
assert_eq!( instruction.command_path_slices, vec![ "cmd".to_string() ] );
assert_eq!( instruction.named_arguments.len(), 1 );
let name_values = instruction.named_arguments.get( "name" ).unwrap();
assert_eq!( name_values.len(), 2 );
assert_eq!( name_values.last().unwrap().value, "val2".to_string() );
}
#[ test ]
fn s6_17_duplicate_named_arg_error()
{
let parser = Parser ::new( UnilangParserOptions
{
error_on_duplicate_named_arguments: true,
..Default ::default()
});
let input = "cmd name ::val1 name ::val2";
let result = parser.parse_repl_input( input );
assert!(
result.is_err(),
"Expected error for input '{}', but got Ok: {:?}",
input,
result.ok()
);
if let Err( e ) = result
{
assert_eq!( e.kind, ErrorKind ::Syntax( "Duplicate named argument 'name'".to_string() ) );
}
}
#[ test ]
fn s6_18_multi_instruction_basic()
{
let parser = Parser ::new( UnilangParserOptions ::default() );
let input = "cmd1 arg1 ;; cmd2 name ::val";
let result = parser.parse_multiple_instructions( input );
assert!( result.is_ok(), "Parse failed for input '{}' : {:?}", input, result.err() );
let instructions = result.unwrap();
assert_eq!( instructions.len(), 2 );
assert_eq!( instructions[ 0 ].command_path_slices, vec![ "cmd1".to_string() ] );
assert_eq!( instructions[ 0 ].positional_arguments.len(), 1 );
assert_eq!( instructions[ 0 ].positional_arguments[ 0 ].value, "arg1".to_string() );
assert_eq!( instructions[ 1 ].command_path_slices, vec![ "cmd2".to_string() ] );
assert_eq!( instructions[ 1 ].named_arguments.len(), 1 );
assert_eq!( instructions[ 1 ].named_arguments.get( "name" ).unwrap()[0].value, "val".to_string() );
}
#[ test ]
fn s6_19_multi_instruction_empty_segment_error()
{
let parser = Parser ::new( UnilangParserOptions ::default() );
let input = "cmd1 ;;;; cmd2";
let result = parser.parse_multiple_instructions( input );
assert!(
result.is_err(),
"Expected error for input '{}', but got Ok: {:?}",
input,
result.ok()
);
if let Err( e ) = result
{
assert_eq!( e.kind, ErrorKind ::EmptyInstructionSegment );
}
}
#[ test ]
fn s6_20_multi_instruction_trailing_delimiter_error()
{
let parser = Parser ::new( UnilangParserOptions ::default() );
let input = "cmd1 ;;";
let result = parser.parse_multiple_instructions( input );
assert!(
result.is_err(),
"Expected error for input '{}', but got Ok: {:?}",
input,
result.ok()
);
if let Err( e ) = result
{
assert_eq!( e.kind, ErrorKind ::TrailingDelimiter );
}
}
#[ test ]
fn s6_21_transition_by_non_identifier_token()
{
let parser = Parser ::new( UnilangParserOptions ::default() );
let input = "cmd !arg";
let result = parser.parse_repl_input( input );
assert!(
result.is_err(),
"Expected error for input '{}', but got Ok: {:?}",
input,
result.ok()
);
if let Err( e ) = result
{
assert_eq!( e.kind, ErrorKind ::Syntax( "Unexpected token '!' in arguments".to_string() ) );
}
}
#[ test ]
fn s6_22_transition_by_quoted_string()
{
let parser = Parser ::new( UnilangParserOptions ::default() );
let input = "cmd \"arg\"";
let result = parser.parse_repl_input( input );
assert!( result.is_ok(), "Parse failed for input '{}' : {:?}", input, result.err() );
let instruction = result.unwrap();
assert_eq!( instruction.command_path_slices, vec![ "cmd".to_string() ] );
assert_eq!( instruction.positional_arguments.len(), 1 );
assert_eq!( instruction.positional_arguments[ 0 ].value, "arg".to_string() );
}
#[ test ]
fn s6_23_transition_by_help_operator()
{
let parser = Parser ::new( UnilangParserOptions ::default() );
let input = "cmd ?";
let result = parser.parse_repl_input( input );
assert!( result.is_ok(), "Parse failed for input '{}' : {:?}", input, result.err() );
let instruction = result.unwrap();
assert_eq!( instruction.command_path_slices, vec![ "cmd".to_string() ] );
assert!( instruction.help_requested );
}
#[ test ]
fn s6_24_named_arg_value_with_double_colon()
{
let parser = Parser ::new( UnilangParserOptions ::default() );
let input = "cmd msg :: \"DEPRECATED ::message\"";
let result = parser.parse_repl_input( input );
assert!( result.is_ok(), "Parse failed for input '{}' : {:?}", input, result.err() );
let instruction = result.unwrap();
assert_eq!( instruction.command_path_slices, vec![ "cmd".to_string() ] );
assert_eq!( instruction.named_arguments.len(), 1 );
assert_eq!(
instruction.named_arguments.get( "msg" ).unwrap()[0].value,
"DEPRECATED ::message".to_string()
);
}
#[ test ]
fn s6_25_named_arg_value_with_commas()
{
let parser = Parser ::new( UnilangParserOptions ::default() );
let input = "cmd tags ::dev,rust,unilang";
let result = parser.parse_repl_input( input );
assert!( result.is_ok(), "Parse failed for input '{}' : {:?}", input, result.err() );
let instruction = result.unwrap();
assert_eq!( instruction.command_path_slices, vec![ "cmd".to_string() ] );
assert_eq!( instruction.named_arguments.len(), 1 );
assert_eq!(
instruction.named_arguments.get( "tags" ).unwrap()[0].value,
"dev,rust,unilang".to_string()
);
}
#[ test ]
fn s6_26_named_arg_value_with_key_value_pair()
{
let parser = Parser ::new( UnilangParserOptions ::default() );
let input = "cmd headers ::Content-Type=application/json,Auth-Token=xyz";
let result = parser.parse_repl_input( input );
assert!( result.is_ok(), "Parse failed for input '{}' : {:?}", input, result.err() );
let instruction = result.unwrap();
assert_eq!( instruction.command_path_slices, vec![ "cmd".to_string() ] );
assert_eq!( instruction.named_arguments.len(), 1 );
assert_eq!(
instruction.named_arguments.get( "headers" ).unwrap()[0].value,
"Content-Type=application/json,Auth-Token=xyz".to_string()
);
}
#[ test ]
fn s6_27_command_path_whitespace_around_dot()
{
let parser = Parser ::new( UnilangParserOptions ::default() );
let input = "cmd . sub";
let result = parser.parse_repl_input( input );
assert!( result.is_ok(), "Parse failed for input '{}' : {:?}", input, result.err() );
let instruction = result.unwrap();
assert_eq!( instruction.command_path_slices, vec![ "cmd".to_string(), "sub".to_string() ] );
}
#[ test ]
fn s6_28_command_path_invalid_identifier_segment()
{
let parser = Parser ::new( UnilangParserOptions ::default() );
let input = "cmd.123.sub";
let result = parser.parse_repl_input( input );
assert!(
result.is_err(),
"Expected error for input '{}', but got Ok: {:?}",
input,
result.ok()
);
if let Err( e ) = result
{
assert_eq!(
e.kind,
ErrorKind ::Syntax( "Invalid identifier '123' in command path".to_string() )
);
}
}
#[ test ]
fn s6_29_command_path_longest_possible_sequence()
{
let parser = Parser ::new( UnilangParserOptions ::default() );
let input = "cmd.sub arg";
let result = parser.parse_repl_input( input );
assert!( result.is_ok(), "Parse failed for input '{}' : {:?}", input, result.err() );
let instruction = result.unwrap();
assert_eq!( instruction.command_path_slices, vec![ "cmd".to_string(), "sub".to_string() ] );
assert_eq!( instruction.positional_arguments.len(), 1 );
assert_eq!( instruction.positional_arguments[ 0 ].value, "arg".to_string() );
}
#[ test ]
fn s6_30_multiple_consecutive_whitespace()
{
let parser = Parser ::new( UnilangParserOptions ::default() );
let input = "cmd arg";
let result = parser.parse_repl_input( input );
assert!( result.is_ok(), "Parse failed for input '{}' : {:?}", input, result.err() );
let instruction = result.unwrap();
assert_eq!( instruction.command_path_slices, vec![ "cmd".to_string() ] );
assert_eq!( instruction.positional_arguments.len(), 1 );
assert_eq!( instruction.positional_arguments[ 0 ].value, "arg".to_string() );
}