#[test]
fn test_process_chat_input_empty_gh219() {
let mut history = vec![];
let action = process_chat_input("", &mut history);
assert!(matches!(action, ChatAction::Continue));
}
#[test]
fn test_process_chat_input_exit_gh219() {
let mut history = vec![];
let action = process_chat_input("exit", &mut history);
assert!(matches!(action, ChatAction::Exit));
}
#[test]
fn test_process_chat_input_quit_gh219() {
let mut history = vec![];
let action = process_chat_input("/quit", &mut history);
assert!(matches!(action, ChatAction::Exit));
}
#[test]
fn test_process_chat_input_clear_gh219() {
let mut history = vec![("hello".to_string(), "world".to_string())];
let action = process_chat_input("/clear", &mut history);
assert!(matches!(action, ChatAction::Continue));
assert!(history.is_empty());
}
#[test]
fn test_process_chat_input_history_gh219() {
let mut history = vec![("user1".to_string(), "reply1".to_string())];
let action = process_chat_input("/history", &mut history);
assert!(matches!(action, ChatAction::Continue));
assert_eq!(history.len(), 1); }
#[test]
fn test_process_chat_input_normal_message_gh219() {
let mut history = vec![];
let action = process_chat_input("hello world", &mut history);
match action {
ChatAction::Respond(msg) => assert_eq!(msg, "hello world"),
_ => panic!("Expected Respond action"),
}
}
#[test]
fn test_process_chat_input_special_chars_gh219() {
let mut history = vec![];
let action = process_chat_input("hello! @#$%", &mut history);
match action {
ChatAction::Respond(msg) => assert_eq!(msg, "hello! @#$%"),
_ => panic!("Expected Respond action"),
}
}
#[test]
fn test_validate_chat_model_registry_pacha_gh219() {
let result = validate_chat_model("pacha://my-model");
assert!(result.is_ok());
}
#[test]
fn test_validate_chat_model_registry_hf_gh219() {
let result = validate_chat_model("hf://org/model");
assert!(result.is_ok());
}
#[test]
fn test_validate_chat_model_nonexistent_gh219() {
let result = validate_chat_model("/nonexistent/path/model.gguf");
assert!(result.is_err());
}
#[test]
fn test_load_chat_history_none_gh219() {
let history = load_chat_history(None);
assert!(history.is_empty());
}
#[test]
fn test_load_chat_history_nonexistent_file_gh219() {
let history = load_chat_history(Some("/nonexistent/history.json"));
assert!(history.is_empty());
}
#[test]
fn test_load_save_chat_history_roundtrip_gh219() {
let dir = std::env::temp_dir();
let path = dir.join("test_chat_history_gh219.json");
let path_str = path.to_str().expect("valid path");
let history = vec![
("hello".to_string(), "hi there".to_string()),
("how are you?".to_string(), "I'm fine".to_string()),
];
save_chat_history(Some(path_str), &history);
let loaded = load_chat_history(Some(path_str));
assert_eq!(loaded.len(), 2);
assert_eq!(loaded[0].0, "hello");
assert_eq!(loaded[1].1, "I'm fine");
let _ = std::fs::remove_file(&path);
}
#[test]
fn test_save_chat_history_none_path_gh219() {
let history = vec![("test".to_string(), "reply".to_string())];
save_chat_history(None, &history);
}
#[test]
fn test_load_chat_history_invalid_json_gh219() {
let dir = std::env::temp_dir();
let path = dir.join("test_chat_invalid_gh219.json");
std::fs::write(&path, "not valid json").expect("write");
let loaded = load_chat_history(Some(path.to_str().expect("valid path")));
assert!(loaded.is_empty()); let _ = std::fs::remove_file(&path);
}
#[test]
fn test_format_model_prompt_raw_mode_gh219() {
let result = format_model_prompt("any_model.gguf", "hello world", None, true);
assert_eq!(result, "hello world");
}
#[test]
fn test_format_model_prompt_raw_mode_with_system_gh219() {
let result = format_model_prompt("model.gguf", "prompt", Some("system msg"), true);
assert_eq!(result, "prompt");
}
#[test]
fn test_format_model_prompt_non_raw_gh219() {
let result = format_model_prompt("model.gguf", "hello", None, false);
assert!(!result.is_empty());
}
#[test]
fn test_format_model_prompt_non_raw_with_system_gh219() {
let result = format_model_prompt("model.gguf", "hello", Some("You are helpful"), false);
assert!(!result.is_empty());
}
#[test]
fn test_detect_model_source_local_gguf_gh219() {
let result = detect_model_source("model.gguf", false);
assert!(result.is_err());
}
#[test]
fn test_detect_model_source_pacha_gh219() {
let result = detect_model_source("pacha://my-model:latest", false);
assert!(result.is_ok());
assert!(matches!(result.unwrap(), ModelSource::RegistryPacha));
}
#[test]
fn test_detect_model_source_hf_gh219() {
let result = detect_model_source("hf://meta-llama/Llama-3.2-1B", false);
assert!(result.is_ok());
}
#[test]
fn test_detect_model_source_name_with_tag_gh219() {
let result = detect_model_source("llama3:8b", false);
assert!(result.is_ok());
assert!(matches!(result.unwrap(), ModelSource::RegistryPacha));
}
#[test]
fn test_detect_model_source_bare_name_gh219() {
let result = detect_model_source("model", false);
assert!(result.is_ok());
}
#[test]
fn test_setup_trace_config_none_gh219() {
let config = setup_trace_config(None);
assert!(config.is_none());
}
#[test]
fn test_setup_trace_config_enabled_no_value_gh219() {
let config = setup_trace_config(Some(None));
assert!(config.is_some());
let c = config.unwrap();
assert!(c.verbose);
}
#[test]
fn test_setup_trace_config_with_steps_gh219() {
let config = setup_trace_config(Some(Some("attention,embed".to_string())));
assert!(config.is_some());
}
#[test]
fn test_validate_suite_or_error_valid_gh219() {
assert!(validate_suite_or_error("tensor_ops"));
assert!(validate_suite_or_error("inference"));
}
#[test]
fn test_validate_suite_or_error_invalid_gh219() {
assert!(!validate_suite_or_error("nonexistent"));
assert!(!validate_suite_or_error(""));
}
#[test]
fn test_print_bench_config_all_none_gh219() {
print_bench_config("realizar", None, None, None);
}
#[test]
fn test_print_bench_config_all_some_gh219() {
print_bench_config(
"ollama",
Some("llama3:8b"),
Some("http://localhost:11434"),
Some("/tmp/results.json"),
);
}
#[test]
fn test_write_bench_json_basic_gh219() {
let dir = std::env::temp_dir();
let path = dir.join("test_bench_output_gh219.json");
let path_str = path.to_str().expect("valid path");
let result = write_bench_json(
path_str,
"test bench_a ... bench: 100 ns/iter (+/- 10)",
Some("tensor_ops"),
Some("realizar"),
Some("model.gguf"),
);
assert!(result.is_ok());
let content = std::fs::read_to_string(&path).expect("read");
assert!(content.contains("tensor_ops"));
assert!(content.contains("realizar"));
let _ = std::fs::remove_file(&path);
}
#[test]
fn test_write_bench_json_empty_output_gh219() {
let dir = std::env::temp_dir();
let path = dir.join("test_bench_empty_gh219.json");
let path_str = path.to_str().expect("valid path");
let result = write_bench_json(path_str, "", None, None, None);
assert!(result.is_ok());
let _ = std::fs::remove_file(&path);
}
#[test]
fn test_write_bench_json_invalid_path_gh219() {
let result = write_bench_json(
"/nonexistent/dir/output.json",
"data",
None,
None,
None,
);
assert!(result.is_err());
}
#[test]
fn test_parse_bench_line_valid_gh219() {
let line = "test bench_add ... bench: 100 ns/iter (+/- 10)";
let result = parse_bench_line(line, None);
assert!(result.is_some());
let val = result.unwrap();
assert_eq!(val["time_ns"], 100);
}
#[test]
fn test_parse_bench_line_with_suite_gh219() {
let line = "test bench_mul ... bench: 500 ns/iter (+/- 50)";
let result = parse_bench_line(line, Some("math"));
assert!(result.is_some());
assert_eq!(result.unwrap()["suite"], "math");
}
#[test]
fn test_parse_bench_line_no_bench_keyword_gh219() {
let line = "this is not a bench line";
let result = parse_bench_line(line, None);
assert!(result.is_none());
}
#[test]
fn test_parse_bench_line_no_ns_iter_gh219() {
let line = "test bench_add ... bench: 100 ms (+/- 10)";
let result = parse_bench_line(line, None);
assert!(result.is_none());
}
#[test]
fn test_parse_bench_line_too_short_gh219() {
let line = "test bench:";
let result = parse_bench_line(line, None);
assert!(result.is_none());
}
#[test]
fn test_parse_bench_line_commas_gh219() {
let line = "test bench_matmul ... bench: 1,234,567 ns/iter (+/- 100)";
let result = parse_bench_line(line, None);
assert!(result.is_some());
assert_eq!(result.unwrap()["time_ns"], 1234567);
}