Update src/number_theory/euler_totient.rs

Co-authored-by: Piotr Idzik <[email protected]>

Author: triuyen

src/number_theory/euler_totient.rs

@@ -29,74 +29,29 @@ pub fn euler_totient(n: u64) -> u64 {
 mod tests {
     use super::*;
 
-    #[test]
-    fn test_euler_totient_comprehensive() {
-        let test_cases = vec![
-            // Edges cases
-            (1, 1),
-            // small numbers
-            (2, 1),
-            (3, 2),
-            (4, 2),
-            (5, 4),
-            (6, 2),
-            //Prime numbers (φ(p) = p - 1)
-            (7, 6),
-            (11, 10),
-            (13, 12),
-            (17, 16),
-            (19, 18),
-            // Prime powers (φ(p^k) = p^(k-1) * (p-1))
-            (8, 4),   // 2^3
-            (9, 6),   // 3^2
-            (16, 8),  // 2^4
-            (25, 20), // 5^2
-            (27, 18), // 3^3
-            (32, 16), // 2^5
-            // Composite numbers
-            (10, 4), // 2 * 5
-            (12, 4), // 2^2 * 3
-            (15, 8), // 3 * 5
-            (18, 6), // 2 * 3^2
-            (20, 8), // 2^2 * 5
-            (30, 8), // 2 * 3 * 5
-            // Large numbers
-            (50, 20),    // 2 * 5^2
-            (100, 40),   // 2^2 * 5^2
-            (1000, 400), // 2^3 * 5^3
-        ];
-
-        for (input, expected) in test_cases {
-            assert_eq!(
-                euler_totient(input),
-                expected,
-                "φ({input}) should be {expected}"
-            );
-        }
+    macro_rules! test_euler_totient {
+        ($($name:ident: $test_case:expr,)*) => {
+            $(
+                #[test]
+                fn $name() {
+                    let (input, expected) = $test_case;
+                    assert_eq!(euler_totient(input), expected)
+                }
+            )*
+        };
     }
 
-    #[test]
-    fn test_edge_cases() {
-        let edge_cases = vec![
-            (2, 1),    // Smallest prime
-            (4, 2),    // Power of 2
-            (6, 2),    // 2 * 3 (two small primes)
-            (35, 24),  // 5 * 7 (two larger primes)
-            (77, 60),  // 7 * 11 (ensures the final `if num > 1` branch)
-            (128, 64), // Large power of 2
-        ];
-
-        for (input, expected) in edge_cases {
-            assert_eq!(euler_totient(input), expected);
-        }
-    }
-
-    #[test]
-    fn test_prime_property() {
-        // For any prime p, φ(p) = p - 1
-        let primes = vec![2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31];
-        for p in primes {
-            assert_eq!(euler_totient(p), p - 1, "φ({p}) should be {}", p - 1);
-        }
+    test_euler_totient! {
+        prime_2: (2, 1),
+        prime_3: (3, 2),
+        prime_5: (5, 4),
+        prime_7: (7, 6),
+        // ...
+        composite_10: (10, 4), // 2 * 5
+        composite_15: (15, 8), // 3 * 5
+        // ...
+        prime_power_2_to_3: (8, 4),
+        prime_power_3_to_2: (9, 6),
+        // ...
     }
 }