From d5ccbb6e9c9388cb2aed7e191273223b50843476 Mon Sep 17 00:00:00 2001 From: Johannes Altmanninger Date: Sat, 9 Dec 2023 20:47:43 +0100 Subject: [PATCH] Port test_error_messages --- fish-rust/src/tests/mod.rs | 1 + fish-rust/src/tests/parse_util.rs | 70 +++++++++++++++++++++ src/fish_tests.cpp | 101 ------------------------------ 3 files changed, 71 insertions(+), 101 deletions(-) create mode 100644 fish-rust/src/tests/parse_util.rs diff --git a/fish-rust/src/tests/mod.rs b/fish-rust/src/tests/mod.rs index c421d7723..56f6e280e 100644 --- a/fish-rust/src/tests/mod.rs +++ b/fish-rust/src/tests/mod.rs @@ -13,6 +13,7 @@ mod fd_monitor; mod highlight; mod history; mod pager; +mod parse_util; mod parser; #[cfg(test)] mod redirection; diff --git a/fish-rust/src/tests/parse_util.rs b/fish-rust/src/tests/parse_util.rs new file mode 100644 index 000000000..068c1a90b --- /dev/null +++ b/fish-rust/src/tests/parse_util.rs @@ -0,0 +1,70 @@ +use pcre2::utf32::Regex; + +use crate::ffi_tests::add_test; +use crate::parse_constants::{ + ERROR_BAD_VAR_CHAR1, ERROR_BRACKETED_VARIABLE1, ERROR_BRACKETED_VARIABLE_QUOTED1, + ERROR_NOT_ARGV_AT, ERROR_NOT_ARGV_COUNT, ERROR_NOT_ARGV_STAR, ERROR_NOT_PID, ERROR_NOT_STATUS, + ERROR_NO_VAR_NAME, +}; +use crate::parse_util::parse_util_detect_errors; +use crate::wchar::prelude::*; +use crate::wchar_ext::WExt; + +add_test!("test_error_messages", || { + // Given a format string, returns a list of non-empty strings separated by format specifiers. The + // format specifiers themselves are omitted. + fn separate_by_format_specifiers(format: &wstr) -> Vec<&wstr> { + let format_specifier_regex = Regex::new(L!(r"%l?[ds]").as_char_slice()).unwrap(); + let mut result = vec![]; + let mut offset = 0; + for mtch in format_specifier_regex.find_iter(format.as_char_slice()) { + let mtch = mtch.unwrap(); + result.push(&format[offset..mtch.start()]); + offset = mtch.end(); + } + result + } + + // Given a format string 'format', return true if the string may have been produced by that format + // string. We do this by splitting the format string around the format specifiers, and then ensuring + // that each of the remaining chunks is found (in order) in the string. + fn string_matches_format(s: &wstr, format: &wstr) -> bool { + let components = separate_by_format_specifiers(format); + let mut idx = 0; + for component in components { + let Some(relpos) = s[idx..].find(component) else { + return false; + }; + idx += relpos + component.len(); + assert!(idx <= s.len()); + } + true + } + + macro_rules! validate { + ($src:expr, $error_text_format:expr) => { + let mut errors = vec![]; + let res = parse_util_detect_errors(L!($src), Some(&mut errors), false); + assert!(res.is_err()); + assert!( + string_matches_format(&errors[0].text, L!($error_text_format)), + "{}", + $src + ); + }; + } + + validate!("echo $^", ERROR_BAD_VAR_CHAR1); + validate!("echo foo${a}bar", ERROR_BRACKETED_VARIABLE1); + validate!("echo foo\"${a}\"bar", ERROR_BRACKETED_VARIABLE_QUOTED1); + validate!("echo foo\"${\"bar", ERROR_BAD_VAR_CHAR1); + validate!("echo $?", ERROR_NOT_STATUS); + validate!("echo $$", ERROR_NOT_PID); + validate!("echo $#", ERROR_NOT_ARGV_COUNT); + validate!("echo $@", ERROR_NOT_ARGV_AT); + validate!("echo $*", ERROR_NOT_ARGV_STAR); + validate!("echo $", ERROR_NO_VAR_NAME); + validate!("echo foo\"$\"bar", ERROR_NO_VAR_NAME); + validate!("echo \"foo\"$\"bar\"", ERROR_NO_VAR_NAME); + validate!("echo foo $ bar", ERROR_NO_VAR_NAME); +}); diff --git a/src/fish_tests.cpp b/src/fish_tests.cpp index d21792233..c3e673952 100644 --- a/src/fish_tests.cpp +++ b/src/fish_tests.cpp @@ -1077,106 +1077,6 @@ static void test_input() { } } -// Given a format string, returns a list of non-empty strings separated by format specifiers. The -// format specifiers themselves are omitted. -static std::vector separate_by_format_specifiers(const wchar_t *format) { - std::vector result; - const wchar_t *cursor = format; - const wchar_t *end = format + std::wcslen(format); - while (cursor < end) { - const wchar_t *next_specifier = std::wcschr(cursor, '%'); - if (next_specifier == nullptr) { - next_specifier = end; - } - assert(next_specifier != nullptr); - - // Don't return empty strings. - if (next_specifier > cursor) { - result.emplace_back(cursor, next_specifier - cursor); - } - - // Walk over the format specifier (if any). - cursor = next_specifier; - if (*cursor != '%') { - continue; - } - - cursor++; - // Flag - if (std::wcschr(L"#0- +'", *cursor)) cursor++; - // Minimum field width - while (iswdigit(*cursor)) cursor++; - // Precision - if (*cursor == L'.') { - cursor++; - while (iswdigit(*cursor)) cursor++; - } - // Length modifier - if (!std::wcsncmp(cursor, L"ll", 2) || !std::wcsncmp(cursor, L"hh", 2)) { - cursor += 2; - } else if (std::wcschr(L"hljtzqL", *cursor)) { - cursor++; - } - // The format specifier itself. We allow any character except NUL. - if (*cursor != L'\0') { - cursor += 1; - } - assert(cursor <= end); - } - return result; -} - -// Given a format string 'format', return true if the string may have been produced by that format -// string. We do this by splitting the format string around the format specifiers, and then ensuring -// that each of the remaining chunks is found (in order) in the string. -static bool string_matches_format(const wcstring &string, const wchar_t *format) { - bool result = true; - std::vector components = separate_by_format_specifiers(format); - size_t idx = 0; - for (const auto &component : components) { - size_t where = string.find(component, idx); - if (where == wcstring::npos) { - result = false; - break; - } - idx = where + component.size(); - assert(idx <= string.size()); - } - return result; -} - -// todo!("port this") -static void test_error_messages() { - say(L"Testing error messages"); - const struct error_test_t { - const wchar_t *src; - const wchar_t *error_text_format; - } error_tests[] = {{L"echo $^", ERROR_BAD_VAR_CHAR1}, - {L"echo foo${a}bar", ERROR_BRACKETED_VARIABLE1}, - {L"echo foo\"${a}\"bar", ERROR_BRACKETED_VARIABLE_QUOTED1}, - {L"echo foo\"${\"bar", ERROR_BAD_VAR_CHAR1}, - {L"echo $?", ERROR_NOT_STATUS}, - {L"echo $$", ERROR_NOT_PID}, - {L"echo $#", ERROR_NOT_ARGV_COUNT}, - {L"echo $@", ERROR_NOT_ARGV_AT}, - {L"echo $*", ERROR_NOT_ARGV_STAR}, - {L"echo $", ERROR_NO_VAR_NAME}, - {L"echo foo\"$\"bar", ERROR_NO_VAR_NAME}, - {L"echo \"foo\"$\"bar\"", ERROR_NO_VAR_NAME}, - {L"echo foo $ bar", ERROR_NO_VAR_NAME}}; - - auto errors = new_parse_error_list(); - for (const auto &test : error_tests) { - errors->clear(); - parse_util_detect_errors(test.src, &*errors); - do_test(!errors->empty()); - if (!errors->empty()) { - do_test1(string_matches_format(*errors->at(0)->text(), test.error_text_format), - test.src); - } - } -} - // todo!("port this") static void test_wwrite_to_fd() { say(L"Testing wwrite_to_fd"); @@ -1487,7 +1387,6 @@ static const test_t s_tests[]{ {TEST_GROUP("enum"), test_enum_array}, {TEST_GROUP("autosuggestion"), test_autosuggestion_combining}, {TEST_GROUP("test_abbreviations"), test_abbreviations}, - {TEST_GROUP("error_messages"), test_error_messages}, {TEST_GROUP("convert"), test_convert}, {TEST_GROUP("convert"), test_convert_private_use}, {TEST_GROUP("convert_ascii"), test_convert_ascii},