functora-tagged tests

Author: functora

rust/functora-tagged/tests/infallible.rs

@@ -0,0 +1,8 @@
+use functora_tagged::infallible::InfallibleInto;
+use std::convert::Infallible;
+
+#[test]
+fn test_infallible_into() {
+    let result_ok: Result<i32, Infallible> = Ok(10);
+    assert_eq!(result_ok.infallible(), 10);
+}

rust/functora-tagged/tests/parse_error.rs

@@ -0,0 +1,104 @@
+use derive_more::Display;
+use functora_tagged::parse_error::ParseError;
+use functora_tagged::refine::Refine;
+use std::error::Error;
+use std::fmt::Debug;
+
+#[derive(Debug, Display, PartialEq, Eq, Clone)]
+struct MyRefineError;
+
+impl Error for MyRefineError {}
+
+#[derive(Debug, Display)]
+struct MyTag;
+
+impl Refine<i32> for MyTag {
+    type RefineError = MyRefineError;
+
+    fn refine(rep: i32) -> Result<i32, Self::RefineError> {
+        if rep > 0 { Ok(rep) } else { Err(MyRefineError) }
+    }
+}
+
+type TestParseError = ParseError<i32, MyTag>;
+
+#[test]
+fn test_parse_error_decode() {
+    let decode_err = "abc".parse::<i32>().unwrap_err();
+    let parse_error =
+        TestParseError::Decode(decode_err.clone());
+
+    let formatted_error = format!("{}", parse_error);
+    assert!(
+        formatted_error.contains(&decode_err.to_string())
+    );
+
+    let debug_formatted_error =
+        format!("{:?}", parse_error);
+    assert_eq!(
+        debug_formatted_error,
+        "Decode(ParseIntError { kind: InvalidDigit })"
+    );
+
+    assert_eq!(
+        parse_error,
+        TestParseError::Decode(decode_err)
+    );
+    assert_ne!(
+        parse_error,
+        TestParseError::Refine(MyRefineError)
+    );
+    assert_eq!(parse_error.clone(), parse_error);
+}
+
+#[test]
+fn test_parse_error_refine() {
+    let refine_err = MyRefineError;
+    let parse_error =
+        TestParseError::Refine(refine_err.clone());
+
+    let formatted_error = format!("{}", parse_error);
+    assert!(
+        formatted_error.contains(&refine_err.to_string())
+    );
+
+    let debug_formatted_error =
+        format!("{:?}", parse_error);
+    assert_eq!(
+        debug_formatted_error,
+        "Refine(MyRefineError)"
+    );
+
+    assert_eq!(
+        parse_error,
+        TestParseError::Refine(refine_err)
+    );
+    let decode_err_for_neq =
+        "abc".parse::<i32>().unwrap_err();
+    assert_ne!(
+        parse_error,
+        TestParseError::Decode(decode_err_for_neq)
+    );
+    assert_eq!(parse_error.clone(), parse_error);
+}
+
+#[test]
+fn test_parse_error_eq() {
+    let decode_err1 = "abc".parse::<i32>().unwrap_err();
+    let decode_err2 = "abc".parse::<i32>().unwrap_err();
+    let refine_err1 = MyRefineError;
+
+    let err_decode1 =
+        TestParseError::Decode(decode_err1.clone());
+    let err_decode2 =
+        TestParseError::Decode(decode_err2.clone());
+
+    let err_refine1 =
+        TestParseError::Refine(refine_err1.clone());
+    let err_refine2 =
+        TestParseError::Refine(refine_err1.clone());
+
+    assert_eq!(err_decode1, err_decode2);
+    assert_eq!(err_refine1, err_refine2);
+    assert_ne!(err_decode1, err_refine1);
+}

rust/functora-tagged/tests/refine.rs

@@ -0,0 +1,71 @@
+use derive_more::Display;
+use functora_tagged::refine::Refine;
+use std::error::Error;
+use std::fmt::Debug;
+
+#[derive(Debug, Display, PartialEq, Eq, Clone)]
+struct MyRefineError;
+
+impl Error for MyRefineError {}
+
+#[derive(Debug)]
+struct MyTag;
+
+impl Refine<String> for MyTag {
+    type RefineError = MyRefineError;
+
+    fn refine(
+        rep: String,
+    ) -> Result<String, Self::RefineError> {
+        Ok(rep)
+    }
+}
+
+#[test]
+fn test_refine_default_implementation() {
+    let rep_value = String::from("test_string");
+    let refined_rep = MyTag::refine(rep_value.clone());
+
+    assert!(refined_rep.is_ok());
+    assert_eq!(refined_rep.unwrap(), rep_value);
+}
+
+struct StrictTag;
+
+impl Refine<String> for StrictTag {
+    type RefineError = String;
+
+    fn refine(
+        rep: String,
+    ) -> Result<String, Self::RefineError> {
+        if rep.starts_with("strict_") {
+            Ok(rep)
+        } else {
+            Err(format!(
+                "String must start with 'strict_': {}",
+                rep
+            ))
+        }
+    }
+}
+
+#[test]
+fn test_refine_custom_implementation() {
+    let strict_value = String::from("strict_value");
+    let refined_strict =
+        StrictTag::refine(strict_value.clone());
+    assert!(refined_strict.is_ok());
+    assert_eq!(refined_strict.unwrap(), strict_value);
+
+    let non_strict_value = String::from("non_strict_value");
+    let refined_non_strict =
+        StrictTag::refine(non_strict_value.clone());
+    assert!(refined_non_strict.is_err());
+    assert_eq!(
+        refined_non_strict.unwrap_err(),
+        format!(
+            "String must start with 'strict_': {}",
+            non_strict_value
+        )
+    );
+}

rust/functora-tagged/tests/tagged.rs

@@ -0,0 +1,178 @@
+use derive_more::Display;
+use functora_tagged::parse_error::ParseError;
+use functora_tagged::refine::Refine;
+use functora_tagged::tagged::Tagged;
+use std::fmt::Debug;
+use std::hash::{Hash, Hasher};
+use std::str::FromStr;
+
+#[derive(Debug, Display, PartialEq, Eq, Clone)]
+struct MyRefineError;
+
+impl std::error::Error for MyRefineError {}
+
+#[derive(Debug)]
+struct MyTag;
+
+impl Refine<i32> for MyTag {
+    type RefineError = MyRefineError;
+
+    fn refine(rep: i32) -> Result<i32, Self::RefineError> {
+        if rep >= 0 {
+            Ok(rep)
+        } else {
+            Err(MyRefineError)
+        }
+    }
+}
+
+type TestTagged = Tagged<i32, MyTag>;
+type TestParseError = ParseError<i32, MyTag>;
+
+#[test]
+fn test_tagged_new() {
+    let rep_value = 10;
+    let tagged_instance = TestTagged::new(rep_value);
+    assert!(tagged_instance.is_ok());
+    assert_eq!(tagged_instance.unwrap().rep(), &rep_value);
+
+    let negative_rep_value = -5;
+    let tagged_instance_err =
+        TestTagged::new(negative_rep_value);
+    assert!(tagged_instance_err.is_err());
+    assert_eq!(
+        tagged_instance_err.unwrap_err(),
+        MyRefineError
+    );
+}
+
+#[test]
+fn test_tagged_rep() {
+    let rep_value = 20;
+    let tagged_instance =
+        TestTagged::new(rep_value).unwrap();
+    assert_eq!(tagged_instance.rep(), &rep_value);
+}
+
+#[test]
+fn test_tagged_eq_partial_eq() {
+    let tagged1 = TestTagged::new(30).unwrap();
+    let tagged2 = TestTagged::new(30).unwrap();
+    let tagged3 = TestTagged::new(40).unwrap();
+
+    assert_eq!(tagged1, tagged2);
+    assert_ne!(tagged1, tagged3);
+}
+
+#[test]
+fn test_tagged_ord_partial_ord() {
+    let tagged1 = TestTagged::new(50).unwrap();
+    let tagged2 = TestTagged::new(50).unwrap();
+    let tagged3 = TestTagged::new(60).unwrap();
+    let tagged4 = TestTagged::new(40).unwrap();
+
+    assert_eq!(
+        tagged1.cmp(&tagged2),
+        std::cmp::Ordering::Equal
+    );
+    assert_eq!(
+        tagged1.partial_cmp(&tagged2),
+        Some(std::cmp::Ordering::Equal)
+    );
+
+    assert_eq!(
+        tagged1.cmp(&tagged3),
+        std::cmp::Ordering::Less
+    );
+    assert_eq!(
+        tagged1.partial_cmp(&tagged3),
+        Some(std::cmp::Ordering::Less)
+    );
+
+    assert_eq!(
+        tagged1.cmp(&tagged4),
+        std::cmp::Ordering::Greater
+    );
+    assert_eq!(
+        tagged1.partial_cmp(&tagged4),
+        Some(std::cmp::Ordering::Greater)
+    );
+}
+
+#[test]
+fn test_tagged_clone() {
+    let tagged1 = TestTagged::new(70).unwrap();
+    let tagged2 = tagged1.clone();
+
+    assert_eq!(tagged1, tagged2);
+    assert_eq!(tagged1.rep(), tagged2.rep());
+}
+
+#[test]
+fn test_tagged_display() {
+    let tagged_instance = TestTagged::new(80).unwrap();
+    assert_eq!(tagged_instance.to_string(), "80");
+}
+
+#[test]
+fn test_tagged_hash() {
+    let tagged1 = TestTagged::new(90).unwrap();
+    let tagged2 = TestTagged::new(90).unwrap();
+    let tagged3 = TestTagged::new(100).unwrap();
+
+    let mut hasher1 =
+        std::collections::hash_map::DefaultHasher::new();
+    tagged1.hash(&mut hasher1);
+    let hash1 = hasher1.finish();
+
+    let mut hasher2 =
+        std::collections::hash_map::DefaultHasher::new();
+    tagged2.hash(&mut hasher2);
+    let hash2 = hasher2.finish();
+
+    let mut hasher3 =
+        std::collections::hash_map::DefaultHasher::new();
+    tagged3.hash(&mut hasher3);
+    let hash3 = hasher3.finish();
+
+    assert_eq!(hash1, hash2);
+    assert_ne!(hash1, hash3);
+}
+
+#[test]
+fn test_tagged_deref() {
+    let rep_value = 110;
+    let tagged_instance =
+        TestTagged::new(rep_value).unwrap();
+    assert_eq!(*tagged_instance, rep_value);
+    assert_eq!(tagged_instance.abs(), rep_value.abs());
+}
+
+#[test]
+fn test_tagged_from_str() {
+    let s_ok = "120";
+    let tagged_ok = TestTagged::from_str(s_ok).unwrap();
+    assert_eq!(tagged_ok.rep(), &120);
+
+    let s_decode_err = "abc";
+    let parse_result_decode: Result<
+        TestTagged,
+        TestParseError,
+    > = FromStr::from_str(s_decode_err);
+    assert!(parse_result_decode.is_err());
+    match parse_result_decode.unwrap_err() {
+        TestParseError::Decode(_) => {}
+        _ => panic!("Expected Decode error"),
+    }
+
+    let s_refine_err = "-10";
+    let parse_result_refine: Result<
+        TestTagged,
+        TestParseError,
+    > = FromStr::from_str(s_refine_err);
+    assert!(parse_result_refine.is_err());
+    match parse_result_refine.unwrap_err() {
+        TestParseError::Refine(_) => {}
+        _ => panic!("Expected Refine error"),
+    }
+}