Adding a few unittests.

Author: john-michaelburke

console_backend/src/main_tab.rs

@@ -218,7 +218,18 @@ impl<'a, S: MessageSender> MainTab<'a, S> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use std::{sync::mpsc, time::Duration};
+    use crate::types::{PosLLH, VelNED};
+    use crate::utils::{mm_to_m, ms_to_sec};
+    use glob::glob;
+    use sbp::messages::navigation::{MsgPosLLH, MsgVelNED};
+    use std::{
+        fs::File,
+        io::{BufRead, BufReader},
+        sync::mpsc,
+        time::Duration,
+    };
+    use tempfile::TempDir;
+
     struct GpsTimeTests {
         pub zero_week: i16,
         pub good_week: i16,
@@ -276,4 +287,268 @@ mod tests {
         main.realtime_delay(Some(later_gps_time_good));
         assert!(now.elapsed() < Duration::from_millis(5));
     }
+
+    #[test]
+    fn csv_logging_test() {
+        let tmp_dir = TempDir::new().unwrap();
+        let tmp_dir = tmp_dir.path().to_path_buf();
+        let shared_state = SharedState::new();
+        let client_send = TestSender { inner: Vec::new() };
+        let mut main = MainTab::new(shared_state, client_send);
+        assert_eq!(main.last_csv_logging, CsvLogging::OFF);
+        main.shared_state.set_csv_logging(CsvLogging::ON);
+        main.shared_state.set_logging_directory(tmp_dir.clone());
+
+        let flags = 0x01;
+        let lat = 45_f64;
+        let lon = -45_f64;
+        let height = 1337_f64;
+        let n_sats = 13;
+        let h_accuracy = 0;
+        let v_accuracy = 0;
+        let tow = 1337;
+        let sender_id = Some(1337);
+
+        let msg = MsgPosLLH {
+            sender_id,
+            flags,
+            lat,
+            lon,
+            height,
+            n_sats,
+            h_accuracy,
+            v_accuracy,
+            tow,
+        };
+
+        let n = 1;
+        let e = 2;
+        let d = 3;
+        let msg_two = MsgVelNED {
+            sender_id,
+            flags,
+            n,
+            e,
+            d,
+            n_sats,
+            tow,
+            h_accuracy: 0,
+            v_accuracy: 0,
+        };
+
+        {
+            main.serialize_sbp(&SBP::MsgPosLLH(msg.clone()));
+            main.solution_tab.handle_pos_llh(PosLLH::MsgPosLLH(msg));
+            main.serialize_sbp(&SBP::MsgVelNED(msg_two.clone()));
+            main.solution_tab
+                .handle_vel_ned(VelNED::MsgVelNED(msg_two.clone()));
+            assert_eq!(main.last_csv_logging, CsvLogging::ON);
+            main.end_csv_logging().unwrap();
+            main.serialize_sbp(&SBP::MsgVelNED(msg_two));
+            assert_eq!(main.last_csv_logging, CsvLogging::OFF);
+        }
+
+        let pattern = tmp_dir.join("position_log_*");
+        let path = glob(&pattern.to_string_lossy())
+            .unwrap()
+            .next()
+            .unwrap()
+            .unwrap();
+        let mut reader = csv::Reader::from_reader(File::open(path).unwrap());
+        let mut records = reader.records();
+        let record = records.next().unwrap().unwrap();
+        let tow_: &f64 = &record[2].parse().unwrap();
+        assert!(tow_ - ms_to_sec(tow as f64) <= f64::EPSILON);
+        let lat_: &f64 = &record[3].parse().unwrap();
+        assert!(lat_ - lat <= f64::EPSILON);
+        let lon_: &f64 = &record[4].parse().unwrap();
+        assert!(lon_ - lon <= f64::EPSILON);
+
+        let pattern = tmp_dir.join("velocity_log_*");
+        let path = glob(&pattern.to_string_lossy())
+            .unwrap()
+            .next()
+            .unwrap()
+            .unwrap();
+        let mut reader = csv::Reader::from_reader(File::open(path).unwrap());
+        let mut records = reader.records();
+        let record = records.next().unwrap().unwrap();
+        let tow_: &f64 = &record[2].parse().unwrap();
+        assert!(tow_ - ms_to_sec(tow as f64) <= f64::EPSILON);
+        let n_: &f64 = &record[3].parse().unwrap();
+        let e_: &f64 = &record[4].parse().unwrap();
+        let d_: &f64 = &record[5].parse().unwrap();
+        assert!(n_ - mm_to_m(n as f64) <= f64::EPSILON);
+        assert!(e_ - mm_to_m(e as f64) <= f64::EPSILON);
+        assert!(d_ - mm_to_m(d as f64) <= f64::EPSILON);
+    }
+
+    #[test]
+    fn sbp_logging_test() {
+        let tmp_dir = TempDir::new().unwrap();
+        let tmp_dir = tmp_dir.path().to_path_buf();
+        let shared_state = SharedState::new();
+        let client_send = TestSender { inner: Vec::new() };
+        let mut main = MainTab::new(shared_state, client_send);
+        assert_eq!(main.last_sbp_logging, SbpLogging::OFF);
+        main.shared_state.set_sbp_logging(SbpLogging::SBP);
+        main.shared_state.set_logging_directory(tmp_dir.clone());
+
+        let flags = 0x01;
+        let lat = 45_f64;
+        let lon = -45_f64;
+        let height = 1337_f64;
+        let n_sats = 13;
+        let h_accuracy = 0;
+        let v_accuracy = 0;
+        let tow = 1337;
+        let sender_id = Some(1337);
+
+        let msg_one = MsgPosLLH {
+            sender_id,
+            flags,
+            lat,
+            lon,
+            height,
+            n_sats,
+            h_accuracy,
+            v_accuracy,
+            tow,
+        };
+
+        let n = 1;
+        let e = 2;
+        let d = 3;
+        let msg_two = MsgVelNED {
+            sender_id,
+            flags,
+            n,
+            e,
+            d,
+            n_sats,
+            tow,
+            h_accuracy: 0,
+            v_accuracy: 0,
+        };
+
+        {
+            main.serialize_sbp(&SBP::MsgPosLLH(msg_one.clone()));
+            main.serialize_sbp(&SBP::MsgVelNED(msg_two.clone()));
+            assert_eq!(main.last_sbp_logging, SbpLogging::SBP);
+            main.close_sbp();
+            main.serialize_sbp(&SBP::MsgVelNED(msg_two.clone()));
+            assert_eq!(main.last_sbp_logging, SbpLogging::OFF);
+        }
+
+        let pattern = tmp_dir.join("swift-gnss-*.sbp");
+        let path = glob(&pattern.to_string_lossy())
+            .unwrap()
+            .next()
+            .unwrap()
+            .unwrap();
+        let file_read = File::open(path).unwrap();
+        let mut messages = sbp::iter_messages(file_read);
+        let msg = messages.next().unwrap().unwrap();
+        match msg {
+            SBP::MsgPosLLH(msg) => {
+                assert_eq!(msg.sender_id, msg_one.sender_id);
+                assert_eq!(msg.flags, msg_one.flags);
+                assert_eq!(msg.tow, msg_one.tow);
+                assert!(msg.lat - msg_one.lat <= f64::EPSILON);
+                assert!(msg.lon - msg_one.lon <= f64::EPSILON);
+                assert!(msg.height - msg_one.height <= f64::EPSILON);
+            }
+            _ => panic!("first message does not match"),
+        }
+        let msg = messages.next().unwrap().unwrap();
+        match msg {
+            SBP::MsgVelNED(msg) => {
+                assert_eq!(msg.sender_id, msg_two.sender_id);
+                assert_eq!(msg.flags, msg_two.flags);
+                assert_eq!(msg.n, msg_two.n);
+                assert_eq!(msg.e, msg_two.e);
+                assert_eq!(msg.d, msg_two.d);
+            }
+            _ => panic!("second message does not match"),
+        }
+    }
+
+    #[test]
+    fn sbp_json_logging_test() {
+        let tmp_dir = TempDir::new().unwrap();
+        let tmp_dir = tmp_dir.path().to_path_buf();
+        let shared_state = SharedState::new();
+        let client_send = TestSender { inner: Vec::new() };
+        let mut main = MainTab::new(shared_state, client_send);
+        assert_eq!(main.last_sbp_logging, SbpLogging::OFF);
+        main.shared_state.set_sbp_logging(SbpLogging::SBP_JSON);
+        main.shared_state.set_logging_directory(tmp_dir.clone());
+
+        let flags = 0x01;
+        let lat = 45_f64;
+        let lon = -45_f64;
+        let height = 1337_f64;
+        let n_sats = 13;
+        let h_accuracy = 0;
+        let v_accuracy = 0;
+        let tow = 1337;
+        let sender_id = Some(1337);
+
+        let msg_one = MsgPosLLH {
+            sender_id,
+            flags,
+            lat,
+            lon,
+            height,
+            n_sats,
+            h_accuracy,
+            v_accuracy,
+            tow,
+        };
+
+        let n = 1;
+        let e = 2;
+        let d = 3;
+        let msg_two = MsgVelNED {
+            sender_id,
+            flags,
+            n,
+            e,
+            d,
+            n_sats,
+            tow,
+            h_accuracy: 0,
+            v_accuracy: 0,
+        };
+
+        {
+            main.serialize_sbp(&SBP::MsgPosLLH(msg_one));
+            main.serialize_sbp(&SBP::MsgVelNED(msg_two.clone()));
+            assert_eq!(main.last_sbp_logging, SbpLogging::SBP_JSON);
+            main.close_sbp();
+            main.serialize_sbp(&SBP::MsgVelNED(msg_two));
+            assert_eq!(main.last_sbp_logging, SbpLogging::OFF);
+        }
+
+        let pattern = tmp_dir.join("swift-gnss-*.sbp.json");
+        let path = glob(&pattern.to_string_lossy())
+            .unwrap()
+            .next()
+            .unwrap()
+            .unwrap();
+        let file_read = File::open(path).unwrap();
+        let output_file = BufReader::new(file_read);
+        let mut lines = output_file.lines();
+        let line = lines.next().unwrap();
+        let value: serde_json::Value = serde_json::from_str(&line.unwrap()).unwrap();
+        let value = value.as_object().unwrap();
+        let lat_ = value.get("lat").unwrap();
+        assert_eq!(*lat_, serde_json::json!(lat));
+
+        let line = lines.next().unwrap();
+        let value: serde_json::Value = serde_json::from_str(&line.unwrap()).unwrap();
+        let value = value.as_object().unwrap();
+        let n_ = value.get("n").unwrap();
+        assert_eq!(*n_, serde_json::json!(n));
+    }
 }

console_backend/src/output.rs

@@ -86,10 +86,13 @@ impl CsvSerializer {
 #[cfg(test)]
 mod tests {
     use super::*;
+
+    use sbp::messages::{navigation::MsgAgeCorrections, system::MsgInsUpdates};
     use serde::Serialize;
-    use std::path::Path;
+    use std::{fs::File, path::Path};
     use tempfile::TempDir;
     const TEST_FILEPATH: &str = "test.csv";
+    const TEST_SBP_FILEPATH: &str = "test.sbp";
 
     #[derive(Serialize)]
     struct TestDataSet {
@@ -126,4 +129,60 @@ mod tests {
         }
         assert!(Path::new(&filepath).is_file());
     }
+    #[test]
+    fn sbp_serializer_test() {
+        let tmp_dir = TempDir::new().unwrap();
+        let filepath = tmp_dir.path();
+        let filepath = filepath.join(TEST_SBP_FILEPATH);
+        let msg_one = MsgAgeCorrections {
+            sender_id: Some(1337),
+            age: 0xFFFF,
+            tow: 0,
+        };
+        let msg_one_wrapped = SBP::MsgAgeCorrections(msg_one.clone());
+        let msg_two = MsgInsUpdates {
+            sender_id: Some(1337),
+            gnsspos: 4,
+            gnssvel: 4,
+            wheelticks: 0xff_u8,
+            speed: 0,
+            nhc: 0,
+            zerovel: 0,
+            tow: 0,
+        };
+        let msg_two_wrapped = SBP::MsgInsUpdates(msg_two.clone());
+        {
+            let mut sbp_logger = SbpLogger::new_sbp(&filepath).unwrap();
+            sbp_logger.serialize(&msg_one_wrapped).unwrap();
+            sbp_logger.serialize(&msg_two_wrapped).unwrap();
+        }
+        assert!(&filepath.is_file());
+        {
+            let file_read = File::open(filepath).unwrap();
+            let mut messages = sbp::iter_messages(file_read);
+            let msg = messages.next().unwrap().unwrap();
+            match msg {
+                SBP::MsgAgeCorrections(msg) => {
+                    assert_eq!(msg.sender_id, msg_one.sender_id);
+                    assert_eq!(msg.age, msg_one.age);
+                    assert_eq!(msg.tow, msg_one.tow);
+                }
+                _ => panic!("first message does not match"),
+            }
+            let msg = messages.next().unwrap().unwrap();
+            match msg {
+                SBP::MsgInsUpdates(msg) => {
+                    assert_eq!(msg.sender_id, msg_two.sender_id);
+                    assert_eq!(msg.gnsspos, msg_two.gnsspos);
+                    assert_eq!(msg.gnssvel, msg_two.gnssvel);
+                    assert_eq!(msg.wheelticks, msg_two.wheelticks);
+                    assert_eq!(msg.speed, msg_two.speed);
+                    assert_eq!(msg.nhc, msg_two.nhc);
+                    assert_eq!(msg.zerovel, msg_two.zerovel);
+                    assert_eq!(msg.tow, msg_two.tow);
+                }
+                _ => panic!("second message does not match"),
+            }
+        }
+    }
 }

console_backend/src/types.rs

@@ -1822,7 +1822,6 @@ mod tests {
         if filename.exists() {
             let mut backup_filename = filename.clone();
             backup_filename.set_extension("backup");
-            println!("{:?}", backup_filename);
             fs::rename(filename, backup_filename).unwrap();
         }
     }