Huge refactor. Introduce anyhow for error handling.

src/mapping/map.rs

@@ -1,7 +1,9 @@
 use std::fs::File;
+use std::io::Write;
 
 use super::{Cluster, Domain, Stage};
 
+use anyhow;
 use ron::de::from_reader;
 use ron::error::SpannedError;
 use serde::{Deserialize, Serialize};
@@ -197,11 +199,178 @@ impl MapFile {
     }
 }
 
-pub fn write_map_to_file(file: File, map: &MapFile) -> ron::error::Result<String> {
-    ron::ser::to_string_pretty(
-        map,
-        ron::ser::PrettyConfig::new()
-            .new_line("\n".to_string())
-            .struct_names(true),
-    )
+pub fn write_map_to_file(file: &mut File, map: &MapFile) -> anyhow::Result<usize> {
+    let written_bytes = file.write(
+        ron::ser::to_string_pretty(
+            map,
+            ron::ser::PrettyConfig::new()
+                .new_line("\n".to_string())
+                .struct_names(true),
+        )?
+        .as_bytes(),
+    )?;
+
+    Ok(written_bytes)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    // Test for MapFile::update()
+
+    // Test for MapFile::get_stage()
+    #[test]
+    fn test_get_stage() {
+        use std::vec;
+
+        let mut mf = MapFile::default();
+        let mut mf_stage = mf.get_stage();
+
+        // If this fails here, there's something SERIOUSLY wrong.
+        assert!(
+            mf_stage == Stage::Untested,
+            "Determined stage to be {:?}, when {:?} was expeccted.",
+            mf_stage,
+            Stage::Untested
+        );
+
+        let stages = vec![
+            Stage::Damaged,
+            Stage::ForIsolation(1),
+            Stage::ForIsolation(0),
+            Stage::Untested,
+        ];
+
+        mf.map = vec![];
+
+        for stage in stages {
+            mf.map.push(*Cluster::default().set_stage(stage));
+
+            mf_stage = mf.get_stage();
+
+            assert!(
+                stage == mf_stage,
+                "Expected stage to be {:?}, determined {:?} instead.",
+                stage,
+                mf_stage
+            )
+        }
+    }
+
+    // Test for MapFile::get_clusters()
+    #[test]
+    fn test_get_clusters() {
+        let mut mf = MapFile::default();
+
+        mf.map = vec![
+            *Cluster::default().set_stage(Stage::Damaged),
+            *Cluster::default().set_stage(Stage::ForIsolation(0)),
+            *Cluster::default().set_stage(Stage::ForIsolation(1)),
+            Cluster::default(),
+            Cluster::default(),
+            *Cluster::default().set_stage(Stage::ForIsolation(1)),
+            *Cluster::default().set_stage(Stage::ForIsolation(0)),
+            *Cluster::default().set_stage(Stage::Damaged),
+        ];
+
+        let stages = vec![
+            Stage::Damaged,
+            Stage::ForIsolation(1),
+            Stage::ForIsolation(0),
+            Stage::Untested,
+        ];
+
+        for stage in stages {
+            let expected = vec![
+                *Cluster::default().set_stage(stage),
+                *Cluster::default().set_stage(stage),
+            ];
+            let received = mf.get_clusters(stage);
+
+            assert!(
+                expected == received,
+                "Expected clusters {:?}, got {:?}.",
+                expected,
+                received
+            )
+        }
+    }
+
+    // Test for MapFile::defrag()
+    #[test]
+    fn test_defrag() {
+        let mut mf = MapFile {
+            sector_size: 1,
+            domain: Domain { start: 0, end: 8 },
+            map: vec![
+                Cluster {
+                    domain: Domain { start: 0, end: 1 },
+                    stage: Stage::Untested,
+                },
+                Cluster {
+                    domain: Domain { start: 1, end: 2 },
+                    stage: Stage::Untested,
+                },
+                Cluster {
+                    domain: Domain { start: 2, end: 3 },
+                    stage: Stage::Untested,
+                },
+                Cluster {
+                    domain: Domain { start: 3, end: 4 },
+                    stage: Stage::ForIsolation(0),
+                },
+                Cluster {
+                    domain: Domain { start: 4, end: 5 },
+                    stage: Stage::ForIsolation(0),
+                },
+                Cluster {
+                    domain: Domain { start: 5, end: 6 },
+                    stage: Stage::ForIsolation(1),
+                },
+                Cluster {
+                    domain: Domain { start: 6, end: 7 },
+                    stage: Stage::ForIsolation(0),
+                },
+                Cluster {
+                    domain: Domain { start: 7, end: 8 },
+                    stage: Stage::Damaged,
+                },
+            ],
+        };
+
+        let expected = vec![
+            Cluster {
+                domain: Domain { start: 0, end: 3 },
+                stage: Stage::Untested,
+            },
+            Cluster {
+                domain: Domain { start: 3, end: 5 },
+                stage: Stage::ForIsolation(0),
+            },
+            Cluster {
+                domain: Domain { start: 5, end: 6 },
+                stage: Stage::ForIsolation(1),
+            },
+            Cluster {
+                domain: Domain { start: 6, end: 7 },
+                stage: Stage::ForIsolation(0),
+            },
+            Cluster {
+                domain: Domain { start: 7, end: 8 },
+                stage: Stage::Damaged,
+            },
+        ];
+
+        mf.defrag();
+
+        let received = mf.map;
+
+        assert!(
+            expected == received,
+            "Expected {:?} after defragging, got {:?}.",
+            expected,
+            received
+        )
+    }
 }