getopt2 0.1.0

/*
 * Copyright (c) Radim Kolar 2013, 2018, 2023.
 * SPDX-License-Identifier: MIT
 *
 * getopt2 library is licensed under MIT license:
 *   https://spdx.org/licenses/MIT.html
*/

/* tests for private helpers functions */

use super::*;


//    validate_optstring tests

#[test]
fn validate_optstring_ok() {
   assert!(validate_optstring("valid").is_ok());
}

#[test]
fn validate_optstring_ok_question_mark() {
   assert!(validate_optstring("valid?").is_ok());
}

#[test]
fn validate_optstring_ok_semi() {
   assert!(validate_optstring("val:id").is_ok());
}

#[test]
fn validate_optstring_invalid_char() {
   assert!(validate_optstring("!valid").is_err());
}

#[test]
fn validate_optstring_supported_extension_semi_start() {
   assert!(validate_optstring(":valid").is_ok());
}

#[test]
fn validate_optstring_posix_plus_start() {
   assert!(validate_optstring("+posix").is_ok());
}

#[test]
fn validate_optstring_posix_plus_with_semi_start() {
   assert!(validate_optstring("+:posix").is_ok());
}

#[test]
fn validate_optstring_invalid_posix_plus_with_double_semi_start() {
   assert!(validate_optstring("+::posix").is_err());
}

#[test]
fn validate_optstring_invalid_plus_position() {
   assert!(validate_optstring("posix+").is_err());
   assert!(validate_optstring("po+six").is_err());
}

#[test]
fn validate_optstring_invalid_double_semi_start() {
   assert!(validate_optstring("::notvalid").is_err());
}

#[test]
fn validate_optstring_valid_double_semi_mid() {
   assert!(validate_optstring("double::semi").is_ok());
}

#[test]
fn validate_optstring_valid_double_semi_end() {
   assert!(validate_optstring("double:semi:end::").is_ok());
}

#[test]
fn validate_optstring_invalid_triple_semi_start() {
   assert!(validate_optstring(":::triple:semi").is_err());
}

#[test]
fn validate_optstring_invalid_triple_semi_mid() {
   assert!(validate_optstring("triple:::semi").is_err());
}

#[test]
fn validate_optstring_invalid_triple_semi_end() {
   assert!(validate_optstring("triple:semi:::").is_err());
}

#[test]
fn validate_optstring_invalid_empty() {
   assert!(validate_optstring("").is_err());
}

#[test]
fn validate_optstring_invalid_semi_only() {
   assert! ( validate_optstring(":").is_err() );
}

#[test]
fn validate_optstring_invalid_plus_only() {
   assert! ( validate_optstring("+").is_err() );
}

#[test]
fn validate_optstring_invalid_plus_semi_only() {
   assert! ( validate_optstring("+:").is_err() );
}

#[test]
fn validate_optstring_invalid_plus_double_semi_only() {
   assert! ( validate_optstring("+::").is_err() );
}

#[test]
fn validate_optstring_invalid_not_alphanum() {
   assert!(validate_optstring("@#$%!").is_err());
}

#[test]
fn validate_opt_question_mark() {
   assert!(validate_optstring(":?").is_ok());
}

#[test]
fn validate_question_mark() {
   assert!(validate_optstring("?").is_ok());
}

#[test]
fn validate_question_mark_w_arg() {
   assert!(validate_optstring("?:").is_ok());
}

#[test]
fn validate_optstring_spaces_outside() {
   assert!(validate_optstring(" a:b ").is_err());
}

#[test]
fn validate_optstring_spaces_inside() {
   assert!(validate_optstring("a: b").is_err());
}

#[test]
fn validate_optstring_spaces_only() {
   assert!(validate_optstring("  ").is_err());
}

//    build_options_map tests

#[test]
fn optionsmap_arg_tail() {
   let map = build_options_map("ab:");
   assert_eq!(map.get(&'a'), Some(&argument::NO));
   assert_eq!(map.get(&'b'), Some(&argument::YES));
   assert_eq!(map.get(&':'), None);
   assert_eq!(map.len(), 2);
}

#[test]
fn optionsmap_without_args() {
   let map = build_options_map("abc");
   assert_eq!(map.get(&'a'), Some(&argument::NO));
   assert_eq!(map.get(&'b'), Some(&argument::NO));
   assert_eq!(map.get(&'c'), Some(&argument::NO));
   assert_eq!(map.get(&':'), None);
   assert_eq!(map.len(), 3);
}

#[test]
fn optionsmap_with_args() {
   let map = build_options_map("a:b:c:");
   assert_eq!(map.get(&'a'), Some(&argument::YES));
   assert_eq!(map.get(&'b'), Some(&argument::YES));
   assert_eq!(map.get(&'c'), Some(&argument::YES));
   assert_eq!(map.get(&':'), None);
   assert_eq!(map.len(), 3);
}

#[test]
fn optionsmap_arg_in_middle() {
   let map = build_options_map("ab:c");
   assert_eq!(map.get(&'a'), Some(&argument::NO));
   assert_eq!(map.get(&'b'), Some(&argument::YES));
   assert_eq!(map.get(&'c'), Some(&argument::NO));
   assert_eq!(map.get(&':'), None);
   assert_eq!(map.len(), 3);
}

#[test]
fn optionsmap_optional_arg_at_start() {
   let map = build_options_map("a::b:c");
   assert_eq!(map.get(&'a'), Some(&argument::OPTIONAL));
   assert_eq!(map.get(&'b'), Some(&argument::YES));
   assert_eq!(map.get(&'c'), Some(&argument::NO));
   assert_eq!(map.get(&':'), None);
   assert_eq!(map.len(), 3);
}

#[test]
fn optionsmap_optional_arg_in_middle() {
   let map = build_options_map("ab::c");
   assert_eq!(map.get(&'a'), Some(&argument::NO));
   assert_eq!(map.get(&'b'), Some(&argument::OPTIONAL));
   assert_eq!(map.get(&'c'), Some(&argument::NO));
   assert_eq!(map.get(&':'), None);
   assert_eq!(map.len(), 3);
}

#[test]
fn optionsmap_optional_arg_at_end() {
   let map = build_options_map("ab:c::");
   assert_eq!(map.get(&'a'), Some(&argument::NO));
   assert_eq!(map.get(&'b'), Some(&argument::YES));
   assert_eq!(map.get(&'c'), Some(&argument::OPTIONAL));
   assert_eq!(map.get(&':'), None);
   assert_eq!(map.len(), 3);
}

#[test]
fn optionsmap_semi_start() {
   let map = build_options_map(":a:b:c");
   assert_eq!(map.get(&'a'), Some(&argument::YES));
   assert_eq!(map.get(&'b'), Some(&argument::YES));
   assert_eq!(map.get(&'c'), Some(&argument::NO));
   assert_eq!(map.get(&':'), None);
   assert_eq!(map.len(), 3);
}

#[test]
fn optionsmap_plus_start() {
   let map = build_options_map("+ab:c");
   assert_eq!(map.get(&'a'), Some(&argument::NO));
   assert_eq!(map.get(&'b'), Some(&argument::YES));
   assert_eq!(map.get(&'c'), Some(&argument::NO));
   assert_eq!(map.get(&':'), None);
   assert_eq!(map.get(&'+'), None);
   assert_eq!(map.len(), 3);
}

#[test]
fn optionsmap_plus_semi_start() {
   let map = build_options_map("+:ab:c");
   assert_eq!(map.get(&'a'), Some(&argument::NO));
   assert_eq!(map.get(&'b'), Some(&argument::YES));
   assert_eq!(map.get(&'c'), Some(&argument::NO));
   assert_eq!(map.get(&':'), None);
   assert_eq!(map.get(&'+'), None);
   assert_eq!(map.len(), 3);
}

// is_option tests

#[test]
fn is_option_double_dash() {
   let ref map = build_options_map("a:b:c:");
   assert_eq! ( is_option("--", map), false );
}

#[test]
fn is_option_dash() {
   let ref map = build_options_map("a:b:c:");
   assert_eq! ( is_option("-", map), false );
}

#[test]
fn is_option_ok() {
   let ref map = build_options_map("a:b:c:");
   assert_eq! ( is_option("-b", map), true );
}

#[test]
fn is_option_not_in_map() {
   let ref map = build_options_map("a:b:c:");
   assert_eq! ( is_option("-z", map), false );
}

// is_possible_option tests

#[test]
fn possible_option_double_dash() {
   assert_eq! ( is_possible_option("--"), false );
}

#[test]
fn possible_option_dash() {
   assert_eq! ( is_possible_option("-"), false );
}

#[test]
fn possible_option_ok() {
   assert_eq! ( is_possible_option("-b"), true );
}

#[test]
fn possible_option_bad_char() {
   assert_eq! ( is_possible_option("-/"), false );
}