Merge pull request #84 from sunsided/feature/test-coverage

Improve test coverage
sunsided · May 19, 2024 · 399cb98 · 399cb98
2 parents 1b19e59 + 22d348e
commit 399cb98
Show file tree

Hide file tree

Showing 96 changed files with 2,345 additions and 225 deletions.
diff --git a/src/parsers/action_def.rs b/src/parsers/action_def.rs
@@ -1,13 +1,14 @@
 //! Provides parsers for action definitions.
 
-use crate::parsers::{empty_or, parens, prefix_expr, typed_list, ws, ParseResult, Span};
-use crate::parsers::{parse_action_symbol, parse_effect, parse_pre_gd, parse_variable};
-use crate::types::ActionDefinition;
 use nom::bytes::complete::tag;
 use nom::character::complete::multispace1;
 use nom::combinator::{map, opt};
 use nom::sequence::{preceded, tuple};
 
+use crate::parsers::{empty_or, parens, prefix_expr, typed_list, ws, ParseResult, Span};
+use crate::parsers::{parse_action_symbol, parse_effect, parse_pre_gd, parse_variable};
+use crate::types::ActionDefinition;
+
 /// Parses an action definition.
 ///
 /// ## Example
@@ -119,3 +120,32 @@ impl crate::parsers::Parser for ActionDefinition {
         parse_action_def(input)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::{
+        ActionDefinition, ActionSymbol, Effects, Parser, PreconditionGoalDefinitions, ToTyped,
+        TypedList, Variable,
+    };
+
+    #[test]
+    fn test_parse() {
+        let input = r#"(:action take-out
+                            :parameters (?x - physob)
+                            :precondition (not (= ?x B))
+                            :effect (not (in ?x))
+                        )"#;
+
+        let (_, action) = ActionDefinition::parse(input).unwrap();
+
+        assert_eq!(
+            action,
+            ActionDefinition::new(
+                ActionSymbol::from_str("take-out"),
+                TypedList::from_iter([Variable::from_str("x").to_typed("physob")]),
+                PreconditionGoalDefinitions::from_str("(not (= ?x B))").unwrap(),
+                Some(Effects::from_str("(not (in ?x))").unwrap())
+            )
+        );
+    }
+}
diff --git a/src/parsers/action_symbol.rs b/src/parsers/action_symbol.rs
@@ -1,8 +1,9 @@
 //! Provides parsers for action symbols.
 
+use nom::combinator::map;
+
 use crate::parsers::{parse_name, ParseResult, Span};
 use crate::types::ActionSymbol;
-use nom::combinator::map;
 
 /// Parses an action symbol, i.e. `<name>`.
 ///
@@ -42,3 +43,14 @@ impl crate::parsers::Parser for ActionSymbol {
         parse_action_symbol(input)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::{ActionSymbol, Parser};
+
+    #[test]
+    fn test_parse() {
+        let (_, action_symbol) = ActionSymbol::parse("abcde").unwrap();
+        assert_eq!(action_symbol, "abcde".into());
+    }
+}
diff --git a/src/parsers/assign_op.rs b/src/parsers/assign_op.rs
@@ -1,12 +1,13 @@
 //! Provides parsers for assignment operations.
 
-use crate::parsers::{ParseResult, Span};
-use crate::types::assign_op::names;
-use crate::types::AssignOp;
 use nom::branch::alt;
 use nom::bytes::complete::tag;
 use nom::combinator::map;
 
+use crate::parsers::{ParseResult, Span};
+use crate::types::assign_op::names;
+use crate::types::AssignOp;
+
 /// Parses an assignment operation, i.e. `assign | scale-up | scale-down | increase | decrease`.
 ///
 /// ## Example
@@ -49,3 +50,17 @@ impl crate::parsers::Parser for AssignOp {
         parse_assign_op(input)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::{AssignOp, Parser};
+
+    #[test]
+    fn test_parse() {
+        let (_, assign_op) = AssignOp::parse("assign").unwrap();
+        assert_eq!(assign_op, AssignOp::Assign);
+
+        let (_, assign_op) = AssignOp::parse("scale-up").unwrap();
+        assert_eq!(assign_op, AssignOp::ScaleUp);
+    }
+}
diff --git a/src/parsers/assign_op_t.rs b/src/parsers/assign_op_t.rs
@@ -1,12 +1,13 @@
 //! Provides parsers for assignment operations.
 
-use crate::parsers::{ParseResult, Span};
-use crate::types::assign_op_t::names;
-use crate::types::AssignOpT;
 use nom::branch::alt;
 use nom::bytes::complete::tag;
 use nom::combinator::map;
 
+use crate::parsers::{ParseResult, Span};
+use crate::types::assign_op_t::names;
+use crate::types::AssignOpT;
+
 /// Parses an assignment operation, i.e. `increase | decrease`.
 ///
 /// ## Example
@@ -41,3 +42,14 @@ impl crate::parsers::Parser for AssignOpT {
         parse_assign_op_t(input)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::{AssignOpT, Parser};
+
+    #[test]
+    fn test_parse() {
+        let (_, value) = AssignOpT::parse("increase").unwrap();
+        assert_eq!(value, AssignOpT::Increase);
+    }
+}
diff --git a/src/parsers/atomic_formula.rs b/src/parsers/atomic_formula.rs
@@ -49,11 +49,24 @@ where
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::parsers::parse_term;
+    use crate::parsers::{parse_name, parse_term, UnwrapValue};
+    use crate::{EqualityAtomicFormula, Predicate, PredicateAtomicFormula};
 
     #[test]
     fn it_works() {
         let input = "(can-move ?from-waypoint ?to-waypoint)";
         let (_, _effect) = atomic_formula(parse_term)(Span::new(input)).unwrap();
     }
+
+    #[test]
+    fn test_parse() {
+        assert!(atomic_formula(parse_name)(Span::new("(= x y)")).is_value(
+            AtomicFormula::Equality(EqualityAtomicFormula::new("x".into(), "y".into()))
+        ));
+        assert!(
+            atomic_formula(parse_name)(Span::new("(move a b)")).is_value(AtomicFormula::Predicate(
+                PredicateAtomicFormula::new(Predicate::from("move"), vec!["a".into(), "b".into()])
+            ))
+        );
+    }
 }
diff --git a/src/parsers/atomic_formula_skeleton.rs b/src/parsers/atomic_formula_skeleton.rs
@@ -27,7 +27,7 @@ pub fn parse_atomic_formula_skeleton<'a, T: Into<Span<'a>>>(
 ) -> ParseResult<'a, AtomicFormulaSkeleton> {
     map(
         parens(tuple((parse_predicate, ws(typed_list(parse_variable))))),
-        |tuple| AtomicFormulaSkeleton::from(tuple),
+        AtomicFormulaSkeleton::from,
     )(input.into())
 }
 
@@ -59,3 +59,25 @@ impl crate::parsers::Parser for AtomicFormulaSkeleton {
         parse_atomic_formula_skeleton(input)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::{AtomicFormulaSkeleton, Parser, Predicate, Variable};
+    use crate::{ToTyped, TypedList};
+
+    #[test]
+    fn test_parse() {
+        let (_, value) = AtomicFormulaSkeleton::parse("(at ?x - physob ?y - location)").unwrap();
+
+        assert_eq!(
+            value,
+            AtomicFormulaSkeleton::new(
+                Predicate::from("at"),
+                TypedList::from_iter([
+                    Variable::from("x").to_typed("physob"),
+                    Variable::from("y").to_typed("location")
+                ])
+            )
+        );
+    }
+}
diff --git a/src/parsers/atomic_function_skeleton.rs b/src/parsers/atomic_function_skeleton.rs
@@ -29,7 +29,7 @@ pub fn parse_atomic_function_skeleton<'a, T: Into<Span<'a>>>(
             parse_function_symbol,
             ws(typed_list(parse_variable)),
         ))),
-        |tuple| AtomicFunctionSkeleton::from(tuple),
+        AtomicFunctionSkeleton::from,
     )(input.into())
 }
 
@@ -40,8 +40,7 @@ impl crate::parsers::Parser for AtomicFunctionSkeleton {
     ///
     /// ## Example
     /// ```
-    /// # use pddl::parsers::{parse_atomic_function_skeleton, Span, UnwrapValue};
-    /// # use pddl::{Variable, AtomicFunctionSkeleton, Predicate, FunctionSymbol, Parser};
+    /// # use pddl::{Variable, AtomicFunctionSkeleton, FunctionSymbol, Parser};
     /// # use pddl::{ToTyped, TypedList};
     /// let (_, value) = AtomicFunctionSkeleton::parse("(battery-amount ?r - rover)").unwrap();
     ///
@@ -60,3 +59,21 @@ impl crate::parsers::Parser for AtomicFunctionSkeleton {
         parse_atomic_function_skeleton(input)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::{AtomicFunctionSkeleton, FunctionSymbol, Parser, Variable};
+    use crate::{ToTyped, TypedList};
+
+    #[test]
+    fn test_parse() {
+        let (_, value) = AtomicFunctionSkeleton::parse("(battery-amount ?r - rover)").unwrap();
+        assert_eq!(
+            value,
+            AtomicFunctionSkeleton::new(
+                FunctionSymbol::from("battery-amount"),
+                TypedList::from_iter([Variable::from("r").to_typed("rover")])
+            )
+        );
+    }
+}
diff --git a/src/parsers/basic_function_term.rs b/src/parsers/basic_function_term.rs
@@ -66,3 +66,23 @@ impl crate::parsers::Parser for BasicFunctionTerm {
         parse_basic_function_term(input)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::{BasicFunctionTerm, Parser};
+
+    #[test]
+    fn test_parse() {
+        let (_, value) = BasicFunctionTerm::parse("abcde").unwrap();
+        assert_eq!(value, BasicFunctionTerm::new("abcde".into(), []));
+
+        let (_, value) = BasicFunctionTerm::parse("(abcde)").unwrap();
+        assert_eq!(value, BasicFunctionTerm::new("abcde".into(), []));
+
+        let (_, value) = BasicFunctionTerm::parse("(abcde x y z)").unwrap();
+        assert_eq!(
+            value,
+            BasicFunctionTerm::new("abcde".into(), ["x".into(), "y".into(), "z".into()])
+        );
+    }
+}
diff --git a/src/parsers/binary_comp.rs b/src/parsers/binary_comp.rs
@@ -1,11 +1,12 @@
 //! Provides parsers for binary comparison operations.
 
-use crate::parsers::{ParseResult, Span};
-use crate::types::{binary_comp::names, BinaryComp};
 use nom::branch::alt;
 use nom::bytes::complete::tag;
 use nom::combinator::map;
 
+use crate::parsers::{ParseResult, Span};
+use crate::types::{binary_comp::names, BinaryComp};
+
 /// Parses a binary comparison operation.
 ///
 /// ## Example
@@ -49,3 +50,26 @@ impl crate::parsers::Parser for BinaryComp {
         parse_binary_comp(input)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::{BinaryComp, Parser};
+
+    #[test]
+    fn test_parse() {
+        let (_, value) = BinaryComp::parse(">=").unwrap();
+        assert_eq!(value, BinaryComp::GreaterOrEqual);
+
+        let (_, value) = BinaryComp::parse(">").unwrap();
+        assert_eq!(value, BinaryComp::GreaterThan);
+
+        let (_, value) = BinaryComp::parse("<=").unwrap();
+        assert_eq!(value, BinaryComp::LessThanOrEqual);
+
+        let (_, value) = BinaryComp::parse("<").unwrap();
+        assert_eq!(value, BinaryComp::LessThan);
+
+        let (_, value) = BinaryComp::parse("=").unwrap();
+        assert_eq!(value, BinaryComp::Equal);
+    }
+}
diff --git a/src/parsers/binary_op.rs b/src/parsers/binary_op.rs
@@ -1,11 +1,12 @@
 //! Provides parsers for binary-operand operations.
 
-use crate::parsers::{ParseResult, Span};
-use crate::types::{binary_op::names, BinaryOp};
 use nom::branch::alt;
 use nom::bytes::complete::tag;
 use nom::combinator::map;
 
+use crate::parsers::{ParseResult, Span};
+use crate::types::{binary_op::names, BinaryOp};
+
 /// Parses a two-operand operation, i.e. `* | + | - | /`.
 ///
 /// ## Example
@@ -47,3 +48,23 @@ impl crate::parsers::Parser for BinaryOp {
         parse_binary_op(input)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::{BinaryOp, Parser};
+
+    #[test]
+    fn test_parse() {
+        let (_, value) = BinaryOp::parse("*").unwrap();
+        assert_eq!(value, BinaryOp::Multiplication);
+
+        let (_, value) = BinaryOp::parse("/").unwrap();
+        assert_eq!(value, BinaryOp::Division);
+
+        let (_, value) = BinaryOp::parse("+").unwrap();
+        assert_eq!(value, BinaryOp::Addition);
+
+        let (_, value) = BinaryOp::parse("-").unwrap();
+        assert_eq!(value, BinaryOp::Subtraction);
+    }
+}