re-enable most unit tests again

rfuzzo · Mar 10, 2024 · 0477618 · 0477618
1 parent eaf03db
commit 0477618
Show file tree

Hide file tree

Showing 13 changed files with 191,970 additions and 238 deletions.
diff --git a/base_rules.json b/base_rules.json
diff --git a/base_rules_order.json b/base_rules_order.json
diff --git a/src/parser.rs b/src/parser.rs
@@ -194,28 +194,46 @@ impl Parser {
             // lowercase all
             let mut line = line.to_lowercase();
 
+            // trim inline comments
             line = if let Some(index) = line.find(';') {
                 line[..index].trim_end().to_owned()
             } else {
                 line.trim_end().to_owned()
             };
 
-            if chunk.is_some() && line.trim().is_empty() {
-                // end chunk
+            // we skip empty lines
+            if line.trim().is_empty() {
+                continue;
+            }
+
+            fn new_rule(line: &str) -> bool {
+                // check if a new rule has started by matching the first chars to the rules names
+                line.starts_with("[order")
+                    || line.starts_with("[nearstart")
+                    || line.starts_with("[nearend")
+                    || line.starts_with("[note")
+                    || line.starts_with("[conflict")
+                    || line.starts_with("[requires")
+                    || line.starts_with("[patch")
+            }
+
+            // we are inside a chunk
+            if chunk.is_some() && new_rule(&line) {
+                // end current chunk
                 if let Some(chunk) = chunk.take() {
                     chunks.push(chunk);
                 }
-            } else if !line.trim().is_empty() {
-                // read to chunk, preserving newline delimeters
-                let delimited_line = line + "\n";
-                if let Some(chunk) = &mut chunk {
-                    chunk.data.extend(delimited_line.as_bytes());
-                } else {
-                    chunk = Some(ChunkWrapper::new(
-                        delimited_line.as_bytes().to_vec(),
-                        (idx + 1).to_string(),
-                    ));
-                }
+            }
+
+            // read to current chunk, preserving newline delimeters
+            let delimited_line = line + "\n";
+            if let Some(chunk) = &mut chunk {
+                chunk.data.extend(delimited_line.as_bytes());
+            } else {
+                chunk = Some(ChunkWrapper::new(
+                    delimited_line.as_bytes().to_vec(),
+                    (idx + 1).to_string(),
+                ));
             }
         }
         // parse last chunk

diff --git a/src/sorter.rs b/src/sorter.rs
@@ -192,7 +192,14 @@ impl Sorter {
                 }
                 return Ok(result);
             }
-            log::debug!("{}, index {}", i, index);
+
+            if let Some(edge) = edges.get(index) {
+                let resoved_0 = &index_dict_rev[&edge.0];
+                let resoved_1 = &index_dict_rev[&edge.1];
+                log::debug!("{}, index {} ({}, {})", i, index, resoved_0, resoved_1);
+            } else {
+                log::debug!("{}, index {}", i, index);
+            }
         }
 
         log::error!("Out of iterations");

diff --git a/tests/integration_tests.rs b/tests/integration_tests.rs
@@ -2,6 +2,7 @@
 mod integration_tests {
     use std::{fs::create_dir_all, io::Write};
 
+    use log::warn;
     use plox::{parser::*, rules::EOrderRule, sorter::*, *};
     use rand::seq::SliceRandom;
     use rand::thread_rng;
@@ -39,7 +40,7 @@ mod integration_tests {
             .init_from_file("./tests/plox/rules_order.txt")
             .expect("failed rule parsing");
 
-        assert_eq!(5, parser.order_rules.len());
+        assert_eq!(8, parser.order_rules.len());
 
         let mods = debug_get_mods_from_order_rules(&parser.order_rules);
 
@@ -183,33 +184,31 @@ mod integration_tests {
         }
     }
 
-    #[allow(dead_code)]
-    //TODO disabled for now #[test]
+    #[test]
     fn test_mlox_user_rules() -> std::io::Result<()> {
         init();
 
         let mut parser = new_tes3_parser();
         parser.init_from_file("./tests/mlox/mlox_user.txt")?;
 
-        let mods = debug_get_mods_from_order_rules(&parser.order_rules);
-
-        // let mut rng = thread_rng();
-        // mods.shuffle(&mut rng);
+        let mut mods = debug_get_mods_from_order_rules(&parser.order_rules);
 
-        // let file = std::fs::File::create("tmp/mods.json").expect("file create failed");
-        // serde_json::to_writer_pretty(file, &mods).expect("serialize failed");
+        let mut rng = thread_rng();
+        mods.shuffle(&mut rng);
 
-        match new_unstable_sorter().topo_sort(&mods, &parser.order_rules) {
+        match new_stable_sorter().topo_sort(&mods, &parser.order_rules) {
             Ok(result) => {
                 assert!(
                     checkresult(&result, &parser.order_rules),
                     "stable(true) order is wrong"
                 );
             }
-            Err(e) => panic!("Error: {}", e),
+            Err(e) => {
+                panic!("Error: {}", e)
+            }
         }
 
-        match new_stable_sorter().topo_sort(&mods, &parser.order_rules) {
+        match new_unstable_sorter().topo_sort(&mods, &parser.order_rules) {
             Ok(result) => {
                 assert!(
                     checkresult(&result, &parser.order_rules),
@@ -222,30 +221,31 @@ mod integration_tests {
         Ok(())
     }
 
-    #[allow(dead_code)]
-    //TODO disabled for now #[test]
+    #[test]
     fn test_mlox_base_rules() -> std::io::Result<()> {
         init();
 
         let mut parser = new_tes3_parser();
         parser.init_from_file("./tests/mlox/mlox_base.txt")?;
 
-        let mods = debug_get_mods_from_order_rules(&parser.order_rules);
+        let mut mods = debug_get_mods_from_order_rules(&parser.order_rules);
 
-        // let mut rng = thread_rng();
-        // mods.shuffle(&mut rng);
+        let mut rng = thread_rng();
+        mods.shuffle(&mut rng);
 
-        match new_unstable_sorter().topo_sort(&mods, &parser.order_rules) {
+        match new_stable_sorter().topo_sort(&mods, &parser.order_rules) {
             Ok(result) => {
                 assert!(
                     checkresult(&result, &parser.order_rules),
                     "stable(true) order is wrong"
                 );
             }
-            Err(e) => panic!("Error: {}", e),
+            Err(e) => {
+                panic!("Error: {}", e)
+            }
         }
 
-        match new_stable_sorter().topo_sort(&mods, &parser.order_rules) {
+        match new_unstable_sorter().topo_sort(&mods, &parser.order_rules) {
             Ok(result) => {
                 assert!(
                     checkresult(&result, &parser.order_rules),
@@ -259,7 +259,7 @@ mod integration_tests {
     }
 
     #[allow(dead_code)]
-    //TODO disabled for now #[test]
+    //#[test]
     fn test_mlox_rules() -> std::io::Result<()> {
         init();
 
@@ -271,17 +271,30 @@ mod integration_tests {
         // let mut rng = thread_rng();
         // mods.shuffle(&mut rng);
 
-        match new_unstable_sorter().topo_sort(&mods, &parser.order_rules) {
+        warn!("MODS: {}", mods.len());
+
+        match new_stable_sorter().topo_sort(&mods, &parser.order_rules) {
             Ok(result) => {
                 assert!(
                     checkresult(&result, &parser.order_rules),
                     "stable(true) order is wrong"
                 );
             }
-            Err(e) => panic!("Error: {}", e),
+            Err(e) => {
+                match new_unstable_sorter().topo_sort(&mods, &parser.order_rules) {
+                    Ok(result) => {
+                        assert!(
+                            checkresult(&result, &parser.order_rules),
+                            "stable(true) order is wrong"
+                        );
+                    }
+                    Err(e) => panic!("Error: {}", e),
+                }
+                panic!("Error: {}", e)
+            }
         }
 
-        match new_stable_sorter().topo_sort(&mods, &parser.order_rules) {
+        match new_unstable_sorter().topo_sort(&mods, &parser.order_rules) {
             Ok(result) => {
                 assert!(
                     checkresult(&result, &parser.order_rules),
@@ -298,8 +311,7 @@ mod integration_tests {
         Sorter::new(sorter::ESortType::StableFull, 1000)
     }
 
-    #[allow(dead_code)]
-    //#[test]
+    #[test]
     fn test_optimized_sort() -> std::io::Result<()> {
         init();
 
@@ -323,8 +335,7 @@ mod integration_tests {
         Ok(())
     }
 
-    #[allow(dead_code)]
-    //#[test]
+    #[test]
     fn test_optimized_sort_time() -> std::io::Result<()> {
         init();
 

diff --git a/tests/mlox/mlox_base.txt b/tests/mlox/mlox_base.txt
@@ -34397,6 +34397,7 @@ Rose_Cottage_Bathing_Patch.esp
 [Order] ; ( Ref: "Stinkers_ReadMe_v1.71.txt" )
 Stinkers.esp
 BE_Bathing_Patch.esp
+
 [Order]
 Balmora Expansion v1.4.esp
 Balmora Expansion v1.4+(1.4).esp