Add gatestream tests (#49)

* Add gatestream tests

* Fix expected matrix size in gate. Add gate tests.

* Add gate tests

* Add cycle tests

* Add measurements tests

* Add qref tests

* Add seq nr tests

* Remove recursion limit. More TeeFile tests.

* Fix TeeFile debug test

dqcsim/src/common/log/tee_file.rs

@@ -83,7 +83,7 @@ impl ::std::str::FromStr for TeeFileConfiguration {
         let file: PathBuf = splitter
             .next()
             .ok_or_else(|| {
-                TeeFileError::ParseError("Expected a colon in tee file description.".to_string())
+                TeeFileError::ParseError("expected a colon in tee file description".to_string())
             })?
             .into();
         Ok(TeeFileConfiguration { filter, file })
@@ -111,7 +111,17 @@ mod test {
             TeeFileConfiguration::from_str("info:/tmp/hello:/there").unwrap(),
             TeeFileConfiguration::new(LoglevelFilter::Info, "/tmp/hello:/there"),
         );
-        assert!(TeeFileConfiguration::from_str("hello").is_err());
+
+        let tfc = TeeFileConfiguration::from_str("hello");
+        assert!(tfc.is_err());
+        assert_eq!(tfc.unwrap_err().to_string(), "hello is not a valid loglevel filter, valid values are off, fatal, error, warn, note, info, debug, or trace");
+
+        let tfc = TeeFileConfiguration::from_str("info");
+        assert!(tfc.is_err());
+        assert_eq!(
+            tfc.unwrap_err().to_string(),
+            "expected a colon in tee file description"
+        );
     }
 
     #[test]
@@ -129,6 +139,13 @@ mod test {
             format!("{:?}", tf),
             "TeeFileConfiguration { filter: Info, file: \"hello:/there\" }"
         );
+
+        let tfc = TeeFileConfiguration::new(LoglevelFilter::Trace, "/dev/zero");
+        let tf = TeeFile::new(tfc);
+
+        assert!(
+            format!("{:?}", tf.unwrap()).starts_with("TeeFile { configuration: TeeFileConfiguration { filter: Trace, file: \"/dev/zero\" }, buffer: Some(File {")
+        );
     }
 
     #[test]

dqcsim/src/common/types/cycle.rs

@@ -69,6 +69,7 @@ impl Cycle {
 
 impl Into<u64> for Cycle {
     fn into(self) -> u64 {
+        assert!(self.0 >= 0, "Cycle count negative");
         self.0 as u64
     }
 }
@@ -78,3 +79,64 @@ impl Into<i64> for Cycle {
         self.0
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn zero() {
+        let c = Cycle::t_zero();
+        assert_eq!(c, Cycle(0i64));
+    }
+
+    #[test]
+    fn advance() {
+        let c = Cycle::t_zero();
+        let c = c.advance(1234u64);
+        assert_eq!(c, Cycle(1234));
+        let c = c.advance(1u64);
+        assert_eq!(c, Cycle(1235));
+    }
+
+    #[test]
+    #[should_panic]
+    fn overflow() {
+        let c = Cycle::t_zero();
+        c.advance(std::u64::MAX);
+    }
+
+    #[test]
+    #[should_panic]
+    fn convert_negative() {
+        let a = 18446744073709551574u64;
+        let c = Cycle(-42);
+        let c: u64 = c.into();
+        assert_eq!(a, c);
+    }
+
+    #[test]
+    fn convert() {
+        let a = 1234u64;
+        let c = Cycle(1234);
+        let c: u64 = c.into();
+        assert_eq!(a, c);
+
+        let a = 1234i64;
+        let c = Cycle(1234);
+        let c: i64 = c.into();
+        assert_eq!(a, c);
+    }
+
+    #[test]
+    fn ops() {
+        let a = Cycle(21);
+        let b: CycleDelta = 21;
+        let c: CycleDelta = -2;
+        assert_eq!(a + b, Cycle(42));
+        assert_eq!(a - b, Cycle(0));
+        assert_eq!(a + c, Cycle(19));
+        assert_eq!(a - c, Cycle(23));
+        assert_eq!(a - a, 0 as CycleDelta);
+    }
+}