|
|
use super::LodaCppError; |
|
|
use std::error::Error; |
|
|
|
|
|
pub struct LodaCppEvalSteps { |
|
|
steps: Vec<u64>, |
|
|
} |
|
|
|
|
|
impl LodaCppEvalSteps { |
|
|
fn new(steps: Vec<u64>) -> Self { |
|
|
Self { |
|
|
steps: steps, |
|
|
} |
|
|
} |
|
|
|
|
|
pub fn parse(raw_output_from_lodacpp: &String, term_count: usize) -> Result<LodaCppEvalSteps, Box<dyn Error>> { |
|
|
let trimmed_output: String = raw_output_from_lodacpp.trim().to_string(); |
|
|
if trimmed_output.is_empty() { |
|
|
error!("No output to parse."); |
|
|
return Err(Box::new(LodaCppError::NoOutput)); |
|
|
} |
|
|
let step_strings = trimmed_output.split(","); |
|
|
let mut steps_vec = Vec::<u64>::with_capacity(term_count); |
|
|
for step_string in step_strings { |
|
|
if step_string.starts_with("+") { |
|
|
error!("Positive number should not start with plus symbol. '{}'", step_string); |
|
|
return Err(Box::new(LodaCppError::ParseSteps)); |
|
|
} |
|
|
let value: u64 = match step_string.parse::<u64>() { |
|
|
Ok(value) => value, |
|
|
Err(error) => { |
|
|
error!("Unable to parse a number as u64. '{}', error: {:?}", step_string, error); |
|
|
return Err(Box::new(LodaCppError::ParseSteps)); |
|
|
} |
|
|
}; |
|
|
steps_vec.push(value); |
|
|
}; |
|
|
Ok(LodaCppEvalSteps::new(steps_vec)) |
|
|
} |
|
|
|
|
|
#[allow(dead_code)] |
|
|
pub fn steps(&self) -> &Vec<u64> { |
|
|
&self.steps |
|
|
} |
|
|
} |
|
|
|
|
|
#[cfg(test)] |
|
|
mod tests { |
|
|
use super::*; |
|
|
|
|
|
fn to_compact_comma_string(steps: &Vec<u64>) -> String { |
|
|
let strings: Vec<String> = steps.iter().map(|item| { |
|
|
item.to_string() |
|
|
}).collect(); |
|
|
strings.join(",") |
|
|
} |
|
|
|
|
|
fn parse(input: &str) -> String { |
|
|
let s = input.to_string(); |
|
|
let eval_ok: LodaCppEvalSteps = match LodaCppEvalSteps::parse(&s, 0) { |
|
|
Ok(value) => value, |
|
|
Err(error) => { |
|
|
if let Some(lodacpp_error) = error.downcast_ref::<LodaCppError>() { |
|
|
if LodaCppError::NoOutput == *lodacpp_error { |
|
|
return "ERROR NoOutput".to_string(); |
|
|
} |
|
|
if LodaCppError::ParseSteps == *lodacpp_error { |
|
|
return "ERROR ParseSteps".to_string(); |
|
|
} |
|
|
return format!("ERROR LODACPP: {:?}", lodacpp_error); |
|
|
} |
|
|
return format!("ERROR OTHER: {:?}", error); |
|
|
} |
|
|
}; |
|
|
to_compact_comma_string(eval_ok.steps()) |
|
|
} |
|
|
|
|
|
#[test] |
|
|
fn test_10000_parse_ok() { |
|
|
assert_eq!(parse("\n 42\t "), "42"); |
|
|
assert_eq!(parse("0"), "0"); |
|
|
assert_eq!(parse("0,0"), "0,0"); |
|
|
assert_eq!(parse("0,1,2,3"), "0,1,2,3"); |
|
|
assert_eq!(parse("0000555"), "555"); |
|
|
} |
|
|
|
|
|
#[test] |
|
|
fn test_20000_parse_error() { |
|
|
assert_eq!(parse(""), "ERROR NoOutput"); |
|
|
assert_eq!(parse(" "), "ERROR NoOutput"); |
|
|
assert_eq!(parse(" \n "), "ERROR NoOutput"); |
|
|
assert_eq!(parse("1,2,overflow"), "ERROR ParseSteps"); |
|
|
assert_eq!(parse("c++ exception"), "ERROR ParseSteps"); |
|
|
assert_eq!(parse("-1,2,-3,4"), "ERROR ParseSteps"); |
|
|
assert_eq!(parse("+123"), "ERROR ParseSteps"); |
|
|
} |
|
|
} |
|
|
|
