automaton

An automaton library & basic programs written in Rust
git clone git://git.ethandl.dev/automaton
Log | Files | Refs | README

enfa_tests.rs (2954B)

      1 use crate::{
      2     enfa::ENFA,
      3     tests::testlib::util::{rand_string, read_directory},
      4     Automaton, Encodable, FiniteStateAutomaton,
      5 };
      6 use std::fs;
      7 
      8 #[test]
      9 fn run_static_tests() {
     10     const NUM_EXTS: usize = 2;
     11     let expected_exts: [&str; NUM_EXTS] = [".input", ".expect"];
     12     let mut expected_files: [String; NUM_EXTS] = ["".to_owned(), "".to_owned()];
     13     let mut expected_paths: [String; NUM_EXTS] = ["".to_owned(), "".to_owned()];
     14 
     15     let enfas = read_directory("ENFAs").expect("Unable to read items in ENFAs directory");
     16     let enfa_tests =
     17         read_directory("ENFAs/tests").expect("Unable to read items in the ENFAs/tests directory");
     18 
     19     for (filename, file) in enfas.iter() {
     20         for i in 0..NUM_EXTS {
     21             expected_files[i] = format!("{}{}", filename, expected_exts[i]);
     22             expected_paths[i] = format!("ENFAs/tests/{}{}", filename, expected_exts[i]);
     23         }
     24         if expected_files
     25             .iter()
     26             .all(|fname| enfa_tests.contains_key(fname))
     27         {
     28             let enfa = ENFA::parse(file.as_str()).expect("Unable to parse ENFA!");
     29             let inputs: Vec<String> = fs::read_to_string(expected_paths[0].clone())
     30                 .expect(&format!(
     31                     "Unable to read file {} to string",
     32                     expected_paths[0]
     33                 ))
     34                 .lines()
     35                 .map(String::from)
     36                 .collect();
     37             let expected: Vec<bool> = fs::read_to_string(expected_paths[1].clone())
     38                 .expect(&format!(
     39                     "Unable to read file {} to string",
     40                     expected_paths[0]
     41                 ))
     42                 .lines()
     43                 .map(|str| match str {
     44                     "t" => true,
     45                     _ => false,
     46                 })
     47                 .collect();
     48             assert_eq!(inputs.len(), expected.len());
     49             for ((index, input), expect) in inputs.iter().enumerate().zip(expected) {
     50                 assert_eq!(
     51                     enfa.accepts(input),
     52                     expect,
     53                     "Test no: {index}, input: {input}, file: {filename}"
     54                 );
     55             }
     56             println!(
     57                 "Successfully ran {} tests in {}",
     58                 inputs.len(),
     59                 expected_paths[0]
     60             )
     61         }
     62     }
     63 }
     64 
     65 #[test]
     66 fn dfa_conversion() {
     67     let enfas: Vec<String> = read_directory("ENFAs")
     68         .expect("Unable to read items in the ENFAs directory")
     69         .values()
     70         .map(String::to_owned)
     71         .collect();
     72 
     73     for enfa_enc in enfas.iter() {
     74         let enfa = ENFA::parse(enfa_enc.as_str()).expect("Unable to parse NFA!");
     75         let as_dfa = enfa.as_dfa().expect("Error converting NFA to DFA!");
     76 
     77         for i in 1..500 {
     78             let input = rand_string(i, enfa.alphabet.iter().map(char::to_owned).collect());
     79             assert_eq!(enfa.accepts(&input), as_dfa.accepts(&input));
     80         }
     81     }
     82 }