refactor tests/rules.rs

Author: Mr-Leshiy

rust/cbork-cddl-parser/tests/rules.rs

@@ -2,19 +2,18 @@
 // cspell: words assigng assignt ASSIGNT GENERICPARM genericparm
 
 mod common;
-use common::{rules::*, type_declarations::*, CDDLTestParser, Rule};
-use pest::Parser;
+use common::{rules::*, type_declarations::*, Rule};
 
-#[test]
 /// Test if the `genericarg` rule passes properly.
 /// This uses a special rule in the Grammar to test `genericarg` exhaustively.
+#[test]
 fn check_genericarg() {
     common::check_tests_rule(Rule::genericarg_TEST, GENERICARG_PASSES, GENERICARG_FAILS);
 }
 
-#[test]
 /// Test if the `genericparm` rule passes properly.
 /// This uses a special rule in the Grammar to test `genericparm` exhaustively.
+#[test]
 fn check_genericparm() {
     common::check_tests_rule(
         Rule::genericparm_TEST,
@@ -23,61 +22,69 @@ fn check_genericparm() {
     );
 }
 
-#[test]
 /// Test if the `assigng` rule passes properly.
 /// This uses a special rule in the Grammar to test `assigng` exhaustively.
+#[test]
 fn check_assigng() {
     common::check_tests_rule(Rule::assigng_TEST, ASSIGNG_PASSES, ASSIGNG_FAILS);
 }
 
-#[test]
 /// Test if the `assignt` rule passes properly.
 /// This uses a special rule in the Grammar to test `assignt` exhaustively.
+#[test]
 fn check_assignt() {
     common::check_tests_rule(Rule::assignt_TEST, ASSIGNT_PASSES, ASSIGNT_FAILS);
 }
 
-#[test]
 /// Test if the `typename` rule passes properly.
 /// This uses a special rule in the Grammar to test `typename` exhaustively.
+#[test]
 fn check_typename() {
     common::check_tests_rule(Rule::typename_TEST, TYPENAME_PASSES, TYPENAME_FAILS);
 }
 
-#[test]
 /// Test if the `groupname` rule passes properly.
 /// This uses a special rule in the Grammar to test `groupname` exhaustively.
+#[test]
 fn check_groupname() {
     common::check_tests_rule(Rule::groupname_TEST, GROUPNAME_PASSES, GROUPNAME_FAILS);
 }
 
-#[test]
 /// Test if the `rule` rule passes properly for type variant.
+#[test]
 fn check_rule_type_composition() {
-    for (i, test_i) in [TYPENAME_PASSES, TYPENAME_FAILS]
+    let typename_iter = [TYPENAME_PASSES, TYPENAME_FAILS]
         .into_iter()
         .flatten()
-        .enumerate()
-    {
-        for (j, test_j) in [ASSIGNT_PASSES].into_iter().flatten().enumerate() {
-            for (k, test_k) in [TYPE_PASSES, TYPE_FAILS].into_iter().flatten().enumerate() {
-                let input = [test_i.to_owned(), test_j.to_owned(), test_k.to_owned()].join(" ");
-                let parse = CDDLTestParser::parse(Rule::rule_TEST, &input);
-                if (0..TYPENAME_PASSES.len()).contains(&i)
-                    && (0..ASSIGNT_PASSES.len()).contains(&j)
-                    && (0..TYPE_PASSES.len()).contains(&k)
-                {
-                    assert!(parse.is_ok());
-                } else {
-                    assert!(parse.is_err());
-                }
-            }
-        }
-    }
+        .enumerate();
+
+    let assign_iter = ASSIGNT_PASSES.iter();
+    let type_iter = [TYPE_PASSES, TYPE_FAILS].into_iter().flatten().enumerate();
+
+    let rules_iter = typename_iter.zip(assign_iter).zip(type_iter).map(
+        |(((i, &test_i), &test_j), (k, &test_k))| {
+            let is_passes = i < TYPENAME_PASSES.len() && k < TYPE_PASSES.len();
+            let input = [test_i.to_string(), test_j.to_string(), test_k.to_string()].join(" ");
+            (input, is_passes)
+        },
+    );
+
+    let passes = rules_iter
+        .clone()
+        .filter(|(_, is_passes)| *is_passes)
+        .map(|(input, _)| input)
+        .collect::<Vec<_>>();
+
+    let fails = rules_iter
+        .filter(|(_, is_passes)| !*is_passes)
+        .map(|(input, _)| input)
+        .collect::<Vec<_>>();
+
+    common::check_tests_rule(Rule::rule_TEST, &passes, &fails);
 }
 
-#[test]
 /// Test if the `rule` rule passes properly for group variant.
+#[test]
 fn check_rule_group() {
     common::check_tests_rule(Rule::rule_TEST, RULE_GROUP_PASSES, RULE_GROUP_FAILS);
 }