refactor tests/type_declaration

Author: Mr-Leshiy

rust/cbork-cddl-parser/tests/common/mod.rs

@@ -18,7 +18,6 @@ pub(crate) mod type_declarations;
 pub struct CDDLTestParser;
 
 /// # Panics
-#[allow(dead_code)]
 pub(crate) fn check_tests_rule(
     rule_type: Rule, passes: &[impl AsRef<str>], fails: &[impl AsRef<str>],
 ) {

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

@@ -59,12 +59,23 @@ fn check_rule_type_composition() {
         .enumerate();
 
     let assign_iter = ASSIGNT_PASSES.iter();
-    let type_iter = [TYPE_PASSES, TYPE_FAILS].into_iter().flatten().enumerate();
+    let type_iter = [
+        TYPE_PASSES,
+        TYPE1_PASSES,
+        TYPE2_PASSES,
+        TYPE_FAILS,
+        TYPE1_FAILS,
+        TYPE2_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(" ");
+        |(((i, typename), assign), (k, r#type))| {
+            let is_passes = i < TYPENAME_PASSES.len()
+                && k < TYPE_PASSES.len() + TYPE1_PASSES.len() + TYPE2_PASSES.len();
+            let input = [typename.to_owned(), assign.to_owned(), r#type.to_owned()].join(" ");
             (input, is_passes)
         },
     );

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

@@ -2,84 +2,103 @@
 // cspell: words rangeop RANGEOP
 
 mod common;
-use common::{type_declarations::*, CDDLTestParser, Rule};
-use pest::Parser;
+use common::{type_declarations::*, Rule};
 
-#[test]
 /// Test if the `ctlop` rule passes properly.
 /// This uses a special rule in the Grammar to test `ctlop` exhaustively.
+#[test]
 fn check_ctlop() {
     common::check_tests_rule(Rule::ctlop_TEST, CTLOP_PASSES, CTLOP_FAILS);
 }
 
-#[test]
 /// Test if the `rangeop` rule passes properly.
 /// This uses a special rule in the Grammar to test `rangeop` exhaustively.
+#[test]
 fn check_rangeop() {
     common::check_tests_rule(Rule::rangeop_TEST, RANGEOP_PASSES, RANGEOP_FAILS);
 }
 
-#[test]
 /// Test if the `type2` rule passes properly.
 /// This uses a special rule in the Grammar to test `type2` exhaustively.
+#[test]
 fn check_type2() {
     common::check_tests_rule(Rule::type2_TEST, TYPE2_PASSES, TYPE2_FAILS);
 }
 
-#[test]
 /// Test if the `type1` rule passes properly.
 /// This uses a special rule in the Grammar to test `type1` exhaustively.
+#[test]
 fn check_type1() {
     common::check_tests_rule(Rule::type1_TEST, TYPE1_PASSES, TYPE1_FAILS);
 }
 
-#[test]
 /// Test if the `type1` rule passes properly based on composition of type2 test cases.
+#[test]
 fn check_type1_composition() {
-    let j_len = CTLOP_PASSES.len() + RANGEOP_PASSES.len();
-    for (i, test_i) in [TYPE2_PASSES, TYPE_FAILS].into_iter().flatten().enumerate() {
-        for (j, test_j) in [CTLOP_PASSES, RANGEOP_PASSES]
-            .into_iter()
-            .flatten()
-            .enumerate()
-        {
-            for (k, test_k) in [TYPE2_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::type1_TEST, &input);
-                if (0..TYPE2_PASSES.len()).contains(&i)
-                    && (0..j_len).contains(&j)
-                    && (0..TYPE2_PASSES.len()).contains(&k)
-                {
-                    assert!(parse.is_ok());
-                } else {
-                    assert!(parse.is_err());
-                }
-            }
-        }
-    }
+    let separator_iter = [CTLOP_PASSES, RANGEOP_PASSES].into_iter().flatten();
+
+    let type_iter = [TYPE2_PASSES, TYPE_FAILS, TYPE1_FAILS, TYPE2_FAILS]
+        .into_iter()
+        .flatten()
+        .enumerate();
+
+    let rules_iter = type_iter.clone().zip(separator_iter).zip(type_iter).map(
+        |(((i, type_1), separator), (j, type_2))| {
+            let is_passed = i < TYPE2_PASSES.len() && j < TYPE2_PASSES.len();
+            let input = [type_1.to_owned(), separator.to_owned(), type_2.to_owned()].join(" ");
+            (input, is_passed)
+        },
+    );
+
+    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::type1_TEST, &passes, &fails);
 }
 
-#[test]
 /// Test if the `type` rule passes properly.
 /// This uses a special rule in the Grammar to test `type` exhaustively.
+#[test]
 fn check_type() {
     common::check_tests_rule(Rule::type_TEST, TYPE_PASSES, TYPE_FAILS);
 }
 
-#[test]
 /// Test if the `type` rule passes properly based on composition of type2 test cases.
+#[test]
 fn check_type_composition() {
     // type2 composition testing
-    for (i, test_i) in [TYPE2_PASSES, TYPE_FAILS].into_iter().flatten().enumerate() {
-        for (j, test_j) in [TYPE2_PASSES, TYPE_FAILS].into_iter().flatten().enumerate() {
+    let type_iter = [TYPE2_PASSES, TYPE_FAILS, TYPE1_FAILS, TYPE2_FAILS]
+        .into_iter()
+        .flatten()
+        .enumerate();
+
+    let rules_iter = type_iter
+        .clone()
+        .zip(type_iter)
+        .map(|((i, test_i), (j, test_j))| {
+            let is_passed = i < TYPE2_PASSES.len() && j < TYPE2_PASSES.len();
             let input = [test_i.to_owned(), "/", test_j.to_owned()].join(" ");
-            let parse = CDDLTestParser::parse(Rule::type_TEST, &input);
-
-            if (0..TYPE2_PASSES.len()).contains(&i) && (0..TYPE2_PASSES.len()).contains(&j) {
-                assert!(parse.is_ok());
-            } else {
-                assert!(parse.is_err());
-            }
-        }
-    }
+            (input, is_passed)
+        });
+
+    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::type_TEST, &passes, &fails);
 }