From 5777ed7e1d89b1fb99c3b1b639c4c78ed4e067d4 Mon Sep 17 00:00:00 2001
From: Nico Wagner <n.wagner@dnb.de>
Date: Mon, 2 Sep 2024 08:21:11 +0000
Subject: [PATCH] add tests

Signed-off-by: Nico Wagner <n.wagner@dnb.de>
---
 pica-record/src/subfield.rs | 207 ++++++++++++++++++++++++------------
 1 file changed, 141 insertions(+), 66 deletions(-)

diff --git a/pica-record/src/subfield.rs b/pica-record/src/subfield.rs
index f43035aae..062f7a5e6 100644
--- a/pica-record/src/subfield.rs
+++ b/pica-record/src/subfield.rs
@@ -122,6 +122,81 @@ pub fn parse_subfield_code(i: &mut &[u8]) -> PResult<SubfieldCode> {
         .parse_next(i)
 }
 
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_subfield_code_new() {
+        for c in '0'..='z' {
+            if c.is_ascii_alphanumeric() {
+                assert_eq!(
+                    SubfieldCode::new(c).unwrap(),
+                    SubfieldCode(c)
+                );
+            } else {
+                assert_eq!(
+                    SubfieldCode::new(c).unwrap_err(),
+                    PicaError::InvalidSubfieldCode(c)
+                );
+            }
+        }
+    }
+
+    #[test]
+    fn test_subfield_code_from_unchecked() {
+        for c in '0'..='z' {
+            if c.is_ascii_alphanumeric() {
+                assert_eq!(
+                    SubfieldCode::from_unchecked(c),
+                    SubfieldCode(c)
+                );
+            }
+        }
+    }
+
+    #[test]
+    fn test_subfield_code_as_byte() {
+        for c in '0'..='z' {
+            if c.is_ascii_alphanumeric() {
+                let code = SubfieldCode::new(c).unwrap();
+                assert_eq!(code.as_byte(), c as u8);
+            }
+        }
+    }
+
+    #[test]
+    fn test_parse_subfield_code() {
+        for c in b'0'..=b'z' {
+            if c.is_ascii_alphanumeric() {
+                assert_eq!(
+                    parse_subfield_code.parse(&[c]).unwrap(),
+                    SubfieldCode::from_unchecked(c)
+                );
+            } else {
+                assert!(parse_subfield_code.parse(&[c]).is_err());
+            }
+        }
+    }
+
+    #[test]
+    fn test_subfield_code_try_from_char() {
+        for c in '0'..='z' {
+            if c.is_ascii_alphanumeric() {
+                assert_eq!(
+                    SubfieldCode::try_from(c).unwrap(),
+                    SubfieldCode(c)
+                );
+            } else {
+                assert_eq!(
+                    SubfieldCode::try_from(c).unwrap_err(),
+                    PicaError::InvalidSubfieldCode(c)
+                );
+            }
+        }
+    }
+}
+
 /// -----{ TODO }-----------------------------------------
 use std::io::{self, Write};
 use std::iter;
@@ -456,69 +531,69 @@ impl quickcheck::Arbitrary for Subfield {
     }
 }
 
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn parse_subfield_code() {
-        for c in b'0'..=b'z' {
-            if c.is_ascii_alphanumeric() {
-                assert_eq!(
-                    super::parse_subfield_code.parse(&[c]).unwrap(),
-                    c as char
-                );
-            } else {
-                assert!(super::parse_subfield_code
-                    .parse(&[c])
-                    .is_err());
-            }
-        }
-    }
-
-    #[test]
-    fn parse_subfield_value() {
-        macro_rules! parse_success {
-            ($input:expr, $expected:expr, $rest:expr) => {
-                assert_eq!(
-                    super::parse_subfield_value
-                        .parse_peek($input)
-                        .unwrap(),
-                    ($rest.as_bytes(), $expected.as_bstr())
-                );
-            };
-        }
-
-        parse_success!(b"abc", b"abc", b"");
-        parse_success!(b"a\x1ebc", b"a", b"\x1ebc");
-        parse_success!(b"a\x1fbc", b"a", b"\x1fbc");
-        parse_success!(b"", b"", b"");
-    }
-
-    #[test]
-    fn parse_subfield() {
-        use super::parse_subfield;
-
-        assert_eq!(
-            parse_subfield.parse(b"\x1fa123").unwrap(),
-            SubfieldRef::new('a', "123")
-        );
-
-        assert_eq!(
-            parse_subfield.parse(b"\x1fa").unwrap(),
-            SubfieldRef::new('a', "")
-        );
-
-        assert!(parse_subfield.parse(b"a123").is_err());
-        assert!(parse_subfield.parse(b"").is_err());
-    }
-
-    #[cfg_attr(miri, ignore)]
-    #[quickcheck_macros::quickcheck]
-    fn parse_arbitrary_subfield(subfield: Subfield) -> bool {
-        let mut bytes = Vec::<u8>::new();
-        let _ = subfield.write_to(&mut bytes);
-
-        super::parse_subfield.parse(&bytes).is_ok()
-    }
-}
+// #[cfg(test)]
+// mod tests {
+//     use super::*;
+
+//     #[test]
+//     fn parse_subfield_code() {
+//         for c in b'0'..=b'z' {
+//             if c.is_ascii_alphanumeric() {
+//                 assert_eq!(
+//                     super::parse_subfield_code.parse(&[c]).unwrap(),
+//                     c as char
+//                 );
+//             } else {
+//                 assert!(super::parse_subfield_code
+//                     .parse(&[c])
+//                     .is_err());
+//             }
+//         }
+//     }
+
+//     #[test]
+//     fn parse_subfield_value() {
+//         macro_rules! parse_success {
+//             ($input:expr, $expected:expr, $rest:expr) => {
+//                 assert_eq!(
+//                     super::parse_subfield_value
+//                         .parse_peek($input)
+//                         .unwrap(),
+//                     ($rest.as_bytes(), $expected.as_bstr())
+//                 );
+//             };
+//         }
+
+//         parse_success!(b"abc", b"abc", b"");
+//         parse_success!(b"a\x1ebc", b"a", b"\x1ebc");
+//         parse_success!(b"a\x1fbc", b"a", b"\x1fbc");
+//         parse_success!(b"", b"", b"");
+//     }
+
+//     #[test]
+//     fn parse_subfield() {
+//         use super::parse_subfield;
+
+//         assert_eq!(
+//             parse_subfield.parse(b"\x1fa123").unwrap(),
+//             SubfieldRef::new('a', "123")
+//         );
+
+//         assert_eq!(
+//             parse_subfield.parse(b"\x1fa").unwrap(),
+//             SubfieldRef::new('a', "")
+//         );
+
+//         assert!(parse_subfield.parse(b"a123").is_err());
+//         assert!(parse_subfield.parse(b"").is_err());
+//     }
+
+//     #[cfg_attr(miri, ignore)]
+//     #[quickcheck_macros::quickcheck]
+//     fn parse_arbitrary_subfield(subfield: Subfield) -> bool {
+//         let mut bytes = Vec::<u8>::new();
+//         let _ = subfield.write_to(&mut bytes);
+
+//         super::parse_subfield.parse(&bytes).is_ok()
+//     }
+// }