test: conversions

src/lib.rs

@@ -583,4 +583,93 @@ mod tests {
         assert_eq!(r.num, a.num);
         assert_eq!(r.den, a.den);
     }
+
+    #[test]
+    fn test_from_i32_basic() {
+        let f = Fraction::from(5i32);
+        assert_eq!(f.num, 5);
+        assert_eq!(f.den, 1);
+    }
+
+    #[test]
+    fn test_from_i32_negative() {
+        let f = Fraction::from(-7i32);
+        assert_eq!(f.num, -7);
+        assert_eq!(f.den, 1);
+    }
+
+    #[test]
+    fn test_from_i64_basic() {
+        let f = Fraction::from(10i64);
+        assert_eq!(f.num, 10);
+        assert_eq!(f.den, 1);
+    }
+
+    #[test]
+    fn test_from_i64_zero() {
+        let f = Fraction::from(0i64);
+        assert_eq!(f.num, 0);
+        assert_eq!(f.den, 1);
+    }
+
+    #[test]
+    fn test_try_from_i32_tuple_valid() {
+        let f = Fraction::try_from((6i32, 8i32)).unwrap();
+        assert_eq!(f.num, 6);
+        assert_eq!(f.den, 8);
+    }
+
+    #[test]
+    fn test_try_from_i32_tuple_zero_denominator() {
+        let f = Fraction::try_from((1i32, 0i32));
+        assert!(matches!(f, Err(FractionError::ZeroDenominator)));
+    }
+
+    #[test]
+    fn test_try_from_i32_tuple_negative_denominator() {
+        let f = Fraction::try_from((3i32, -4i32)).unwrap();
+        assert_eq!(f.num, 3);
+        assert_eq!(f.den, -4);
+    }
+
+    #[test]
+    fn test_try_from_i64_tuple_valid() {
+        let f = Fraction::try_from((15i64, 20i64)).unwrap();
+        assert_eq!(f.num, 15);
+        assert_eq!(f.den, 20);
+    }
+
+    #[test]
+    fn test_try_from_i64_tuple_zero_denominator() {
+        let f = Fraction::try_from((1i64, 0i64));
+        assert!(matches!(f, Err(FractionError::ZeroDenominator)));
+    }
+
+    #[test]
+    fn test_try_from_i64_tuple_negative_values() {
+        let f = Fraction::try_from((-3i64, -5i64)).unwrap();
+        assert_eq!(f.num, -3);
+        assert_eq!(f.den, -5);
+    }
+
+    #[test]
+    fn test_try_into_i64_valid() {
+        let f = Fraction::new(8, 1).unwrap();
+        let value: i64 = f.try_into().unwrap();
+        assert_eq!(value, 8);
+    }
+
+    #[test]
+    fn test_try_into_i64_invalid_fraction() {
+        let f = Fraction::new(3, 2).unwrap();
+        let result: Result<i64, _> = f.try_into();
+        assert!(matches!(result, Err(FractionError::InvalidInteger)));
+    }
+
+    #[test]
+    fn test_try_into_i64_negative() {
+        let f = Fraction::new(-10, 1).unwrap();
+        let value: i64 = f.try_into().unwrap();
+        assert_eq!(value, -10);
+    }
 }