Rework reading from device and clean up.

src/mapping/mod.rs

@@ -0,0 +1,187 @@
+pub mod cluster;
+pub mod domain;
+pub mod map;
+
+use serde::{Deserialize, Serialize};
+
+pub use cluster::Cluster;
+pub use domain::Domain;
+pub use map::MapFile;
+
+#[derive(Clone, Copy, Debug, Serialize, Deserialize, PartialEq, PartialOrd)]
+pub enum Stage {
+    Intact,
+    Untested,
+    ForIsolation(u8),
+    Damaged,
+}
+
+impl Default for Stage {
+    fn default() -> Self {
+        Stage::Untested
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    // Test for Cluster::subdivide()
+
+    // 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
+        )
+    }
+}