public void TC_Predicates() { PDDLInputData data = new PDDLInputData(GetFilePath("TC_Predicates.pddl"), GetFilePath("Dummy_P.pddl")); Assert.IsTrue(Utilities.CheckToStringExport(data)); Assert.AreEqual(3, data.Domain.Predicates.Count); var pred0 = data.Domain.Predicates[0]; Assert.AreEqual("predicateA", pred0.Name); Assert.AreEqual("?a", pred0.Terms[0].TermName); Assert.AreEqual(DefinitionTerm.DefaultType, pred0.Terms[0].TypeNames[0]); var pred1 = data.Domain.Predicates[1]; Assert.AreEqual("predicateB", pred1.Name); Assert.AreEqual("?a", pred1.Terms[0].TermName); Assert.AreEqual("typeA", pred1.Terms[0].TypeNames[0]); Assert.AreEqual("?b", pred1.Terms[1].TermName); Assert.AreEqual("typeA", pred1.Terms[1].TypeNames[0]); var pred2 = data.Domain.Predicates[2]; Assert.AreEqual("predicateC", pred2.Name); Assert.AreEqual(0, pred2.Terms.Count); }
public void TC_RequirementsInProblem() { PDDLInputData data = new PDDLInputData(GetFilePath("Dummy_D.pddl"), GetFilePath("TC_RequirementsInProblem.pddl")); Assert.IsTrue(Utilities.CheckToStringExport(data)); Assert.AreEqual(21, new HashSet <Requirement>(data.Problem.Requirements).Count); }
/// <summary> /// Exports the given input data into a string PDDL representation and checks if it's a valid input by loading it again. /// </summary> /// <param name="data">Input data to be checked.</param> /// <returns>True if the string representation of the data is a valid PDDL input. False otherwise.</returns> public static bool CheckToStringExport(PDDLInputData data) { string domainString = data.Domain?.ToString(); string problemString = data.Problem?.ToString(); string domainTempFile = CreateAndWriteToTemporaryFile(domainString); string problemTempFile = CreateAndWriteToTemporaryFile(problemString); PDDLInputData exportedData = new PDDLInputData(domainTempFile, problemTempFile); DeleteTemporaryFile(domainTempFile); DeleteTemporaryFile(problemTempFile); if (data.Domain != null && !data.Domain.ToString().Equals(exportedData.Domain.ToString())) { return(false); } if (data.Problem != null && !data.Problem.ToString().Equals(exportedData.Problem.ToString())) { return(false); } return(true); }
public void TC_DurativeActions() { PDDLInputData data = new PDDLInputData(GetFilePath("TC_DurativeActions.pddl"), GetFilePath("Dummy_P.pddl")); Assert.IsTrue(Utilities.CheckToStringExport(data)); Assert.AreEqual(2, data.Domain.DurativeActions.Count); var durativeAction0 = data.Domain.DurativeActions[0]; Assert.AreEqual("actionA", durativeAction0.Name); Assert.AreEqual(1, durativeAction0.Parameters.Count); Assert.AreEqual("?a", durativeAction0.Parameters[0].ParameterName); Assert.AreEqual(Parameter.DefaultType, durativeAction0.Parameters[0].TypeNames[0]); Assert.AreEqual(0, durativeAction0.Durations.Count); Assert.AreEqual(0, durativeAction0.Conditions.Count); Assert.AreEqual(0, durativeAction0.Effects.Count); var durativeAction1 = data.Domain.DurativeActions[1]; Assert.AreEqual("actionB", durativeAction1.Name); Assert.AreEqual(0, durativeAction1.Parameters.Count); Assert.AreEqual(0, durativeAction1.Durations.Count); Assert.AreEqual(0, durativeAction1.Conditions.Count); Assert.AreEqual(0, durativeAction1.Effects.Count); }
public void TC_Metric() { PDDLInputData data = new PDDLInputData(GetFilePath("Dummy_D.pddl"), GetFilePath("TC_Metric.pddl")); Assert.IsTrue(Utilities.CheckToStringExport(data)); Assert.AreEqual(OptimizationSpecifier.MAXIMIZE, data.Problem.Metric.OptimizationSpecifier); var andExpr = data.Problem.Metric.Expression as MetricPlus; Assert.IsNotNull(andExpr); Assert.AreEqual(8, andExpr.Arguments.Count); var expr0 = andExpr.Arguments[0] as MetricMinus; Assert.IsNotNull(expr0); Assert.IsTrue(expr0.Argument1 is MetricNumber); Assert.IsTrue(expr0.Argument2 is MetricNumber); var expr1 = andExpr.Arguments[1] as MetricMultiply; Assert.IsNotNull(expr1); Assert.AreEqual(3, expr1.Arguments.Count); Assert.IsTrue(expr1.Arguments[0] is MetricNumber); Assert.IsTrue(expr1.Arguments[1] is MetricNumber); Assert.IsTrue(expr1.Arguments[2] is MetricNumber); var expr2 = andExpr.Arguments[2] as MetricDivide; Assert.IsNotNull(expr2); Assert.IsTrue(expr2.Argument1 is MetricNumber); Assert.IsTrue(expr2.Argument2 is MetricNumber); var expr3 = andExpr.Arguments[3] as MetricUnaryMinus; Assert.IsNotNull(expr3); Assert.IsTrue(expr3.Argument is MetricNumber); var expr4 = andExpr.Arguments[4] as MetricNumericFunction; Assert.IsNotNull(expr4); Assert.AreEqual("numFunc", expr4.Name); Assert.AreEqual(0, expr4.Terms.Count); var expr5 = andExpr.Arguments[5] as MetricNumericFunction; Assert.IsNotNull(expr5); Assert.AreEqual("numFunc", expr5.Name); Assert.AreEqual(0, expr5.Terms.Count); var expr6 = andExpr.Arguments[6] as MetricTotalTime; Assert.IsNotNull(expr6); var expr7 = andExpr.Arguments[7] as MetricPreferenceViolation; Assert.IsNotNull(expr7); Assert.AreEqual("prefName", expr7.PreferenceName); }
public void TC_NumericExpressions() { PDDLInputData data = new PDDLInputData(GetFilePath("TC_NumericExpressions.pddl"), GetFilePath("Dummy_P.pddl")); Assert.IsTrue(Utilities.CheckToStringExport(data)); Assert.AreEqual(1, data.Domain.Actions.Count); var preconditions = data.Domain.Actions[0].Preconditions; Assert.AreEqual(7, preconditions.Count); var expr0 = preconditions[0] as EqualsExpression; Assert.IsNotNull(expr0); Assert.IsTrue(expr0.Term1 is ObjectFunctionTerm); Assert.IsTrue(expr0.Term2 is ObjectFunctionTerm); var expr1 = preconditions[1] as EqualsExpression; Assert.IsNotNull(expr1); Assert.IsTrue(expr1.Term1 is ObjectFunctionTerm); Assert.IsTrue(expr1.Term2 is VariableTerm); var expr2 = preconditions[2] as NumericCompareExpression; Assert.IsNotNull(expr2); Assert.AreEqual(NumericComparer.EQ, expr2.NumericComparer); Assert.IsTrue(expr2.NumericExpression1 is NumericFunction); Assert.IsTrue(expr2.NumericExpression2 is NumericFunction); var expr3 = preconditions[3] as NumericCompareExpression; Assert.IsNotNull(expr3); Assert.AreEqual(NumericComparer.LT, expr3.NumericComparer); Assert.IsTrue(expr3.NumericExpression1 is NumericFunction); Assert.IsTrue(expr3.NumericExpression2 is Number); var expr4 = preconditions[4] as NumericCompareExpression; Assert.IsNotNull(expr4); Assert.AreEqual(NumericComparer.LTE, expr4.NumericComparer); Assert.IsTrue(expr4.NumericExpression1 is Plus); Assert.IsTrue(expr4.NumericExpression2 is Minus); var expr5 = preconditions[5] as NumericCompareExpression; Assert.IsNotNull(expr5); Assert.AreEqual(NumericComparer.GT, expr5.NumericComparer); Assert.IsTrue(expr5.NumericExpression1 is Multiply); Assert.IsTrue(expr5.NumericExpression2 is UnaryMinus); var expr6 = preconditions[6] as NumericCompareExpression; Assert.IsNotNull(expr6); Assert.AreEqual(NumericComparer.GTE, expr6.NumericComparer); Assert.IsTrue(expr6.NumericExpression1 is Number); Assert.IsTrue(expr6.NumericExpression2 is Divide); }
public void TC_DurativeEffects() { PDDLInputData data = new PDDLInputData(GetFilePath("TC_DurativeEffects.pddl"), GetFilePath("Dummy_P.pddl")); Assert.IsTrue(Utilities.CheckToStringExport(data)); Assert.AreEqual(1, data.Domain.DurativeActions.Count); var durAction = data.Domain.DurativeActions[0]; Assert.AreEqual(6, durAction.Effects.Count); var effect0 = durAction.Effects[0] as ForallDurativeEffect; Assert.IsNotNull(effect0); Assert.AreEqual(1, effect0.Parameters.Count); Assert.AreEqual("?b", effect0.Parameters[0].ParameterName); Assert.AreEqual(1, effect0.Effects.Count); Assert.IsTrue(effect0.Effects[0] is AtTimedEffect); var effect1 = durAction.Effects[1] as WhenDurativeEffect; Assert.IsNotNull(effect1); Assert.IsTrue(effect1.Expression is AtTimedExpression); Assert.IsTrue(effect1.Effect is AtTimedEffect); var effect2 = durAction.Effects[2] as AtTimedEffect; Assert.IsNotNull(effect2); Assert.AreEqual(TimeSpecifier.START, effect2.TimeSpecifier); Assert.AreEqual(1, effect2.Effects.Count); Assert.IsTrue(effect2.Effects[0] is PredicateEffect); var effect3 = durAction.Effects[3] as AtTimedEffect; Assert.IsNotNull(effect3); Assert.AreEqual(TimeSpecifier.END, effect3.TimeSpecifier); Assert.AreEqual(1, effect3.Effects.Count); Assert.IsTrue(effect3.Effects[0] is PredicateEffect); var effect4 = durAction.Effects[4] as AssignTimedEffect; Assert.IsNotNull(effect4); Assert.AreEqual(TimedEffectAssignOperator.INCREASE, effect4.AssignOperator); Assert.AreEqual("numFunc", effect4.Function.Name); Assert.AreEqual(0, effect4.Function.Terms.Count); Assert.IsTrue(effect4.Value is PrimitiveTimedNumericExpression); var effect5 = durAction.Effects[5] as AssignTimedEffect; Assert.IsNotNull(effect5); Assert.AreEqual(TimedEffectAssignOperator.DECREASE, effect5.AssignOperator); Assert.AreEqual("numFunc", effect5.Function.Name); Assert.AreEqual(0, effect5.Function.Terms.Count); Assert.IsTrue(effect5.Value is CompoundTimedNumericExpression); Assert.IsTrue(((CompoundTimedNumericExpression)effect5.Value).NumericExpression is Number); }
public void TC_Length() { PDDLInputData data = new PDDLInputData(GetFilePath("Dummy_D.pddl"), GetFilePath("TC_Length.pddl")); Assert.IsTrue(Utilities.CheckToStringExport(data)); Assert.AreEqual(2, data.Problem.Length.Count); Assert.AreEqual(LengthSpecifier.SERIAL, data.Problem.Length[0].LengthSpecifier); Assert.AreEqual(55, data.Problem.Length[0].Parameter); Assert.AreEqual(LengthSpecifier.PARALLEL, data.Problem.Length[1].LengthSpecifier); Assert.AreEqual(66, data.Problem.Length[1].Parameter); }
public void TC_StripsHeuristic() { var sasProblem = new Planner.SAS.Problem(new SASInputData(GetFilePath("TC_Gripper.sas"))); var pddlProblem = new Planner.PDDL.Problem(new PDDLInputData(GetFilePath("TC_Gripper_D.pddl"), GetFilePath("TC_Gripper_P.pddl"))); var heuristic = new StripsHeuristic(sasProblem); Assert.AreEqual(4, heuristic.GetValue(sasProblem.GetInitialState())); Assert.AreEqual(4, heuristic.GetValue(new Planner.SAS.State(0, 0, 0, 0, 0, 0, 0))); Assert.AreEqual(3, heuristic.GetValue(new Planner.SAS.State(1, 0, 0, 0, 0, 0, 0))); Assert.AreEqual(2, heuristic.GetValue(new Planner.SAS.State(0, 1, 1, 0, 0, 0, 0))); Assert.AreEqual(0, heuristic.GetValue(new Planner.SAS.State(1, 1, 1, 1, 0, 0, 0))); Assert.AreEqual(4, heuristic.GetValue(sasProblem.GetGoalConditions())); Assert.AreEqual(0, heuristic.GetValue(new Planner.SAS.Conditions(new Planner.SAS.Assignment(0, 0)))); Assert.AreEqual(2, heuristic.GetValue(new Planner.SAS.Conditions(new Planner.SAS.Assignment(1, 1), new Planner.SAS.Assignment(2, 1)))); Assert.AreEqual(1, heuristic.GetValue(new Planner.SAS.ConditionsClause(new Planner.SAS.Conditions(new Planner.SAS.Assignment(0, 1), new Planner.SAS.Assignment(1, 1)), new Planner.SAS.Conditions(new Planner.SAS.Assignment(2, 1))))); Assert.AreEqual(int.MaxValue, heuristic.GetValue(new Planner.SAS.ConditionsContradiction())); Assert.AreEqual(4, heuristic.GetValue(sasProblem.GetGoalConditions().GetCorrespondingRelativeStates(sasProblem).First())); Assert.AreEqual("STRIPS Heuristic", heuristic.GetName()); Assert.AreEqual(11, heuristic.GetCallsCount()); var data = new PDDLInputData(GetFilePath("TC_Gripper_D.pddl"), GetFilePath("TC_Gripper_P.pddl")); Planner.PDDL.IdManager idManager = new Planner.PDDL.IdManager(data); Planner.PDDL.PrimitivesFactory factory = new Planner.PDDL.PrimitivesFactory(idManager); Planner.PDDL.GroundingManager groundingManager = new Planner.PDDL.GroundingManager(data, idManager); Planner.PDDL.EvaluationManager evaluationManager = new Planner.PDDL.EvaluationManager(groundingManager, pddlProblem.RigidRelations); var atPred = factory.CreatePredicate("at", "ball1", "roomb"); var atPred2 = factory.CreatePredicate("at", "ball2", "roomb"); var heuristic2 = new StripsHeuristic(pddlProblem); Assert.AreEqual(2, heuristic2.GetValue(pddlProblem.GetInitialState())); Assert.AreEqual(1, heuristic2.GetValue(new Planner.PDDL.State(new HashSet <Planner.PDDL.IAtom> { atPred }, null, null, idManager))); Assert.AreEqual(0, heuristic2.GetValue(new Planner.PDDL.State(new HashSet <Planner.PDDL.IAtom> { atPred, atPred2 }, null, null, idManager))); Assert.AreEqual(2, heuristic2.GetValue(pddlProblem.GetGoalConditions())); Assert.AreEqual(1, heuristic2.GetValue(new Planner.PDDL.Conditions(new Planner.PDDL.PredicateExpression(atPred, idManager), evaluationManager))); Assert.AreEqual(1, heuristic2.GetValue(new Planner.PDDL.ConditionsCNF(new HashSet <Planner.PDDL.IConjunctCNF> { new Planner.PDDL.PredicateLiteralCNF(new Planner.PDDL.PredicateExpression(atPred, idManager), false) }, evaluationManager, null))); Assert.AreEqual(2, heuristic2.GetValue(pddlProblem.GetGoalConditions().GetCorrespondingRelativeStates(pddlProblem).First())); Assert.AreEqual("STRIPS Heuristic", heuristic2.GetName()); Assert.AreEqual(7, heuristic2.GetCallsCount()); }
public void TC_DurativeExpressions() { PDDLInputData data = new PDDLInputData(GetFilePath("TC_DurativeExpressions.pddl"), GetFilePath("Dummy_P.pddl")); Assert.IsTrue(Utilities.CheckToStringExport(data)); Assert.AreEqual(1, data.Domain.DurativeActions.Count); var durAction = data.Domain.DurativeActions[0]; Assert.AreEqual(6, durAction.Conditions.Count); var condition0 = durAction.Conditions[0] as ForallDurativeExpression; Assert.IsNotNull(condition0); Assert.AreEqual(1, condition0.Parameters.Count); Assert.AreEqual("?b", condition0.Parameters[0].ParameterName); Assert.IsTrue(condition0.Expression is AtTimedExpression); var condition1 = durAction.Conditions[1] as AndDurativeExpression; Assert.IsNotNull(condition1); Assert.AreEqual(1, condition1.Arguments.Count); Assert.IsTrue(condition1.Arguments[0] is AtTimedExpression); var condition2 = durAction.Conditions[2] as PreferencedTimedExpression; Assert.IsNotNull(condition2); Assert.AreEqual("prefName", condition2.Name); Assert.IsTrue(condition2.Expression is AtTimedExpression); var condition3 = durAction.Conditions[3] as AtTimedExpression; Assert.IsNotNull(condition3); Assert.AreEqual(TimeSpecifier.START, condition3.TimeSpecifier); Assert.IsTrue(condition3.Expression is PredicateExpression); var condition4 = durAction.Conditions[4] as AtTimedExpression; Assert.IsNotNull(condition4); Assert.AreEqual(TimeSpecifier.END, condition4.TimeSpecifier); Assert.IsTrue(condition4.Expression is PredicateExpression); var condition5 = durAction.Conditions[5] as OverTimedExpression; Assert.IsNotNull(condition5); Assert.AreEqual(IntervalSpecifier.ALL, condition5.IntervalSpecifier); Assert.IsTrue(condition5.Expression is PredicateExpression); }
public void TC_Problem() { PDDLInputData data = new PDDLInputData(GetFilePath("Dummy_D.pddl"), GetFilePath("TC_Problem.pddl")); Assert.IsTrue(Utilities.CheckToStringExport(data)); Assert.AreEqual("problemName", data.Problem.Name); Assert.AreEqual("domainName", data.Problem.DomainName); Assert.AreEqual(0, data.Problem.Requirements.Count); Assert.AreEqual(0, data.Problem.Objects.Count); Assert.AreEqual(0, data.Problem.Init.Count); Assert.AreEqual(0, data.Problem.Goal.Count); Assert.AreEqual(0, data.Problem.Constraints.Count); Assert.IsNull(data.Problem.Metric.Expression); Assert.AreEqual(0, data.Problem.Length.Count); }
public void TC_Domain() { PDDLInputData data = new PDDLInputData(GetFilePath("TC_Domain.pddl"), GetFilePath("Dummy_P.pddl")); Assert.IsTrue(Utilities.CheckToStringExport(data)); Assert.AreEqual("domainName", data.Domain.Name); Assert.AreEqual(0, data.Domain.Requirements.Count); Assert.AreEqual(0, data.Domain.Types.Count); Assert.AreEqual(0, data.Domain.Constants.Count); Assert.AreEqual(0, data.Domain.Predicates.Count); Assert.AreEqual(0, data.Domain.Functions.Count); Assert.AreEqual(0, data.Domain.Constraints.Count); Assert.AreEqual(0, data.Domain.Actions.Count); Assert.AreEqual(0, data.Domain.DurativeActions.Count); Assert.AreEqual(0, data.Domain.DerivedPredicates.Count); }
public void TC_Types() { PDDLInputData data = new PDDLInputData(GetFilePath("TC_Types.pddl"), GetFilePath("Dummy_P.pddl")); Assert.IsTrue(Utilities.CheckToStringExport(data)); Assert.AreEqual(6, data.Domain.Types.Count); var type0 = data.Domain.Types[0]; Assert.AreEqual("typeA", type0.TypeName); Assert.AreEqual(2, type0.BaseTypeNames.Count); Assert.AreEqual("typeA", type0.BaseTypeNames[0]); Assert.AreEqual("typeB", type0.BaseTypeNames[1]); var type1 = data.Domain.Types[1]; Assert.AreEqual("typeB", type1.TypeName); Assert.AreEqual(1, type1.BaseTypeNames.Count); Assert.AreEqual("typeA", type1.BaseTypeNames[0]); var type2 = data.Domain.Types[2]; Assert.AreEqual("typeC", type2.TypeName); Assert.AreEqual(1, type2.BaseTypeNames.Count); Assert.AreEqual("typeF", type2.BaseTypeNames[0]); var type3 = data.Domain.Types[3]; Assert.AreEqual("typeD", type3.TypeName); Assert.AreEqual(2, type3.BaseTypeNames.Count); Assert.AreEqual("typeA", type3.BaseTypeNames[0]); Assert.AreEqual("typeB", type3.BaseTypeNames[1]); var type4 = data.Domain.Types[4]; Assert.AreEqual("typeE", type4.TypeName); Assert.AreEqual(1, type4.BaseTypeNames.Count); Assert.AreEqual(Type.DefaultBaseType, type4.BaseTypeNames[0]); var type5 = data.Domain.Types[5]; Assert.AreEqual("typeF", type5.TypeName); Assert.AreEqual(1, type5.BaseTypeNames.Count); Assert.AreEqual(Type.DefaultBaseType, type5.BaseTypeNames[0]); }
public void TC_Goal() { PDDLInputData data = new PDDLInputData(GetFilePath("Dummy_D.pddl"), GetFilePath("TC_Goal.pddl")); Assert.IsTrue(Utilities.CheckToStringExport(data)); var goalCondition = data.Problem.Goal; Assert.AreEqual(9, goalCondition.Count); Assert.IsTrue(goalCondition[0] is PreferenceExpression); Assert.IsTrue(goalCondition[1] is PredicateExpression); Assert.IsTrue(goalCondition[2] is EqualsExpression); Assert.IsTrue(goalCondition[3] is OrExpression); Assert.IsTrue(goalCondition[4] is NotExpression); Assert.IsTrue(goalCondition[5] is ImplyExpression); Assert.IsTrue(goalCondition[6] is ExistsExpression); Assert.IsTrue(goalCondition[7] is ForallExpression); Assert.IsTrue(goalCondition[8] is NumericCompareExpression); }
public void TC_Terms() { PDDLInputData data = new PDDLInputData(GetFilePath("TC_Terms.pddl"), GetFilePath("Dummy_P.pddl")); Assert.IsTrue(Utilities.CheckToStringExport(data)); Assert.AreEqual(1, data.Domain.Predicates.Count); var predicate = data.Domain.Predicates[0]; Assert.AreEqual(5, predicate.Terms.Count); var param0 = predicate.Terms[0]; Assert.AreEqual("?a", param0.TermName); Assert.AreEqual(2, param0.TypeNames.Count); Assert.AreEqual("typeA", param0.TypeNames[0]); Assert.AreEqual("typeB", param0.TypeNames[1]); var param1 = predicate.Terms[1]; Assert.AreEqual("?b", param1.TermName); Assert.AreEqual(1, param1.TypeNames.Count); Assert.AreEqual("typeB", param1.TypeNames[0]); var param2 = predicate.Terms[2]; Assert.AreEqual("?c", param2.TermName); Assert.AreEqual(1, param2.TypeNames.Count); Assert.AreEqual("typeB", param2.TypeNames[0]); var param3 = predicate.Terms[3]; Assert.AreEqual("?d", param3.TermName); Assert.AreEqual(1, param3.TypeNames.Count); Assert.AreEqual("typeA", param3.TypeNames[0]); var param4 = predicate.Terms[4]; Assert.AreEqual("?e", param4.TermName); Assert.AreEqual(1, param4.TypeNames.Count); Assert.AreEqual(Parameter.DefaultType, param4.TypeNames[0]); }
public void TC_Parameters() { PDDLInputData data = new PDDLInputData(GetFilePath("TC_Parameters.pddl"), GetFilePath("Dummy_P.pddl")); Assert.IsTrue(Utilities.CheckToStringExport(data)); Assert.AreEqual(1, data.Domain.Actions.Count); var action = data.Domain.Actions[0]; Assert.AreEqual(5, action.Parameters.Count); var param0 = action.Parameters[0]; Assert.AreEqual("?a", param0.ParameterName); Assert.AreEqual(2, param0.TypeNames.Count); Assert.AreEqual("typeA", param0.TypeNames[0]); Assert.AreEqual("typeB", param0.TypeNames[1]); var param1 = action.Parameters[1]; Assert.AreEqual("?b", param1.ParameterName); Assert.AreEqual(1, param1.TypeNames.Count); Assert.AreEqual("typeB", param1.TypeNames[0]); var param2 = action.Parameters[2]; Assert.AreEqual("?c", param2.ParameterName); Assert.AreEqual(1, param2.TypeNames.Count); Assert.AreEqual("typeB", param2.TypeNames[0]); var param3 = action.Parameters[3]; Assert.AreEqual("?d", param3.ParameterName); Assert.AreEqual(1, param3.TypeNames.Count); Assert.AreEqual("typeA", param3.TypeNames[0]); var param4 = action.Parameters[4]; Assert.AreEqual("?e", param4.ParameterName); Assert.AreEqual(1, param4.TypeNames.Count); Assert.AreEqual(Parameter.DefaultType, param4.TypeNames[0]); }
public void TC_Functions() { PDDLInputData data = new PDDLInputData(GetFilePath("TC_Functions.pddl"), GetFilePath("Dummy_P.pddl")); Assert.IsTrue(Utilities.CheckToStringExport(data)); Assert.AreEqual(4, data.Domain.Functions.Count); var func0 = data.Domain.Functions[0]; Assert.AreEqual("functionA", func0.Name); Assert.AreEqual(2, func0.ReturnValueTypes.Count); Assert.AreEqual("typeA", func0.ReturnValueTypes[0]); Assert.AreEqual("typeB", func0.ReturnValueTypes[1]); Assert.AreEqual("?a", func0.Terms[0].TermName); Assert.AreEqual(DefinitionTerm.DefaultType, func0.Terms[0].TypeNames[0]); var func1 = data.Domain.Functions[1]; Assert.AreEqual("functionB", func1.Name); Assert.AreEqual(1, func1.ReturnValueTypes.Count); Assert.AreEqual("object", func1.ReturnValueTypes[0]); Assert.AreEqual("?a", func1.Terms[0].TermName); Assert.AreEqual("typeA", func1.Terms[0].TypeNames[0]); var func2 = data.Domain.Functions[2]; Assert.AreEqual("functionC", func2.Name); Assert.AreEqual(1, func2.ReturnValueTypes.Count); Assert.AreEqual("object", func2.ReturnValueTypes[0]); Assert.AreEqual("?a", func2.Terms[0].TermName); Assert.AreEqual("typeA", func2.Terms[0].TypeNames[0]); Assert.AreEqual("?b", func2.Terms[1].TermName); Assert.AreEqual("typeA", func2.Terms[1].TypeNames[0]); var func3 = data.Domain.Functions[3]; Assert.AreEqual("functionD", func3.Name); Assert.AreEqual(1, func3.ReturnValueTypes.Count); Assert.AreEqual(Function.DefaultReturnType, func3.ReturnValueTypes[0]); Assert.AreEqual(0, func3.Terms.Count); }
public void TC_DerivedPredicates() { PDDLInputData data = new PDDLInputData(GetFilePath("TC_DerivedPredicates.pddl"), GetFilePath("Dummy_P.pddl")); Assert.IsTrue(Utilities.CheckToStringExport(data)); Assert.AreEqual(2, data.Domain.DerivedPredicates.Count); var pred0 = data.Domain.DerivedPredicates[0]; Assert.AreEqual("notEquals", pred0.Predicate.Name); Assert.AreEqual(2, pred0.Predicate.Terms.Count); Assert.AreEqual("?a", pred0.Predicate.Terms[0].TermName); Assert.AreEqual("?b", pred0.Predicate.Terms[1].TermName); Assert.IsTrue(pred0.Expression is NotExpression); var pred1 = data.Domain.DerivedPredicates[1]; Assert.AreEqual("totalTimeLesserThan10", pred1.Predicate.Name); Assert.AreEqual(0, pred1.Predicate.Terms.Count); Assert.IsTrue(pred1.Expression is NumericCompareExpression); }
public void TC_Constants() { PDDLInputData data = new PDDLInputData(GetFilePath("TC_Constants.pddl"), GetFilePath("Dummy_P.pddl")); Assert.IsTrue(Utilities.CheckToStringExport(data)); Assert.AreEqual(5, data.Domain.Constants.Count); var const0 = data.Domain.Constants[0]; Assert.AreEqual("constA", const0.ConstantName); Assert.AreEqual(2, const0.TypeNames.Count); Assert.AreEqual("typeA", const0.TypeNames[0]); Assert.AreEqual("typeB", const0.TypeNames[1]); var const1 = data.Domain.Constants[1]; Assert.AreEqual("constB", const1.ConstantName); Assert.AreEqual(2, const1.TypeNames.Count); Assert.AreEqual("typeA", const1.TypeNames[0]); Assert.AreEqual("typeB", const1.TypeNames[1]); var const2 = data.Domain.Constants[2]; Assert.AreEqual("constC", const2.ConstantName); Assert.AreEqual(2, const2.TypeNames.Count); Assert.AreEqual("typeA", const2.TypeNames[0]); Assert.AreEqual("typeB", const2.TypeNames[1]); var const3 = data.Domain.Constants[3]; Assert.AreEqual("constD", const3.ConstantName); Assert.AreEqual(1, const3.TypeNames.Count); Assert.AreEqual(Constant.DefaultType, const3.TypeNames[0]); var const4 = data.Domain.Constants[4]; Assert.AreEqual("constE", const4.ConstantName); Assert.AreEqual(1, const4.TypeNames.Count); Assert.AreEqual(Constant.DefaultType, const4.TypeNames[0]); }
public void TC_Objects() { PDDLInputData data = new PDDLInputData(GetFilePath("Dummy_D.pddl"), GetFilePath("TC_Objects.pddl")); Assert.IsTrue(Utilities.CheckToStringExport(data)); Assert.AreEqual(5, data.Problem.Objects.Count); var object0 = data.Problem.Objects[0]; Assert.AreEqual("objectA", object0.ObjectName); Assert.AreEqual(2, object0.TypeNames.Count); Assert.AreEqual("typeA", object0.TypeNames[0]); Assert.AreEqual("typeB", object0.TypeNames[1]); var object1 = data.Problem.Objects[1]; Assert.AreEqual("objectB", object1.ObjectName); Assert.AreEqual(2, object1.TypeNames.Count); Assert.AreEqual("typeA", object1.TypeNames[0]); Assert.AreEqual("typeB", object1.TypeNames[1]); var object2 = data.Problem.Objects[2]; Assert.AreEqual("objectC", object2.ObjectName); Assert.AreEqual(2, object2.TypeNames.Count); Assert.AreEqual("typeA", object2.TypeNames[0]); Assert.AreEqual("typeB", object2.TypeNames[1]); var object3 = data.Problem.Objects[3]; Assert.AreEqual("objectD", object3.ObjectName); Assert.AreEqual(1, object3.TypeNames.Count); Assert.AreEqual(Object.DefaultType, object3.TypeNames[0]); var object4 = data.Problem.Objects[4]; Assert.AreEqual("objectE", object4.ObjectName); Assert.AreEqual(1, object4.TypeNames.Count); Assert.AreEqual(Object.DefaultType, object4.TypeNames[0]); }
public void TC_DurativeConstraints() { PDDLInputData data = new PDDLInputData(GetFilePath("TC_DurativeConstraints.pddl"), GetFilePath("Dummy_P.pddl")); Assert.IsTrue(Utilities.CheckToStringExport(data)); Assert.AreEqual(1, data.Domain.DurativeActions.Count); var durAction = data.Domain.DurativeActions[0]; Assert.AreEqual(3, durAction.Durations.Count); var durConstr0 = durAction.Durations[0] as AtDurativeConstraint; Assert.IsNotNull(durConstr0); Assert.AreEqual(TimeSpecifier.START, durConstr0.TimeSpecifier); var durSubConstr0 = durConstr0.DurativeConstraint as CompareDurativeConstraint; Assert.IsNotNull(durSubConstr0); Assert.AreEqual(DurationComparer.LTE, durSubConstr0.DurationComparer); Assert.IsTrue(durSubConstr0.Value is Number); var durConstr1 = durAction.Durations[1] as AtDurativeConstraint; Assert.IsNotNull(durConstr1); Assert.AreEqual(TimeSpecifier.END, durConstr1.TimeSpecifier); Assert.IsTrue(durConstr1.DurativeConstraint is CompareDurativeConstraint); var durSubConstr1 = durConstr1.DurativeConstraint as CompareDurativeConstraint; Assert.IsNotNull(durSubConstr1); Assert.AreEqual(DurationComparer.EQ, durSubConstr1.DurationComparer); Assert.IsTrue(durSubConstr1.Value is NumericFunction); var durConstr2 = durAction.Durations[2] as CompareDurativeConstraint; Assert.IsNotNull(durConstr2); Assert.AreEqual(DurationComparer.GTE, durConstr2.DurationComparer); Assert.IsTrue(durConstr2.Value is Plus); }
public void TC_Expressions() { PDDLInputData data = new PDDLInputData(GetFilePath("TC_Expressions.pddl"), GetFilePath("Dummy_P.pddl")); Assert.IsTrue(Utilities.CheckToStringExport(data)); Assert.AreEqual(1, data.Domain.Actions.Count); Assert.AreEqual("actionA", data.Domain.Actions[0].Name); Assert.AreEqual(2, data.Domain.Actions[0].Parameters.Count); var preconditions = data.Domain.Actions[0].Preconditions; Assert.AreEqual(9, preconditions.Count); Assert.IsTrue(preconditions[0] is PreferenceExpression); Assert.IsTrue(preconditions[1] is PredicateExpression); Assert.IsTrue(preconditions[2] is EqualsExpression); Assert.IsTrue(preconditions[3] is OrExpression); Assert.IsTrue(preconditions[4] is NotExpression); Assert.IsTrue(preconditions[5] is ImplyExpression); Assert.IsTrue(preconditions[6] is ExistsExpression); Assert.IsTrue(preconditions[7] is ForallExpression); Assert.IsTrue(preconditions[8] is NumericCompareExpression); }
public void TC_Actions() { PDDLInputData data = new PDDLInputData(GetFilePath("TC_Actions.pddl"), GetFilePath("Dummy_P.pddl")); Assert.IsTrue(Utilities.CheckToStringExport(data)); Assert.AreEqual(4, data.Domain.Actions.Count); var action0 = data.Domain.Actions[0]; Assert.AreEqual("actionA", action0.Name); Assert.AreEqual(1, action0.Parameters.Count); Assert.AreEqual("?a", action0.Parameters[0].ParameterName); Assert.AreEqual(Parameter.DefaultType, action0.Parameters[0].TypeNames[0]); Assert.AreEqual(0, action0.Preconditions.Count); Assert.AreEqual(0, action0.Effects.Count); var action1 = data.Domain.Actions[1]; Assert.AreEqual("actionB", action1.Name); Assert.AreEqual(0, action1.Parameters.Count); Assert.AreEqual(0, action1.Preconditions.Count); Assert.AreEqual(0, action1.Effects.Count); var action2 = data.Domain.Actions[2]; Assert.AreEqual("actionC", action2.Name); Assert.AreEqual(0, action2.Parameters.Count); Assert.AreEqual(0, action2.Preconditions.Count); Assert.AreEqual(0, action2.Effects.Count); var action3 = data.Domain.Actions[3]; Assert.AreEqual("actionD", action3.Name); Assert.AreEqual(0, action3.Parameters.Count); Assert.AreEqual(0, action3.Preconditions.Count); Assert.AreEqual(0, action3.Effects.Count); }
/// <summary> /// Tests a batch of problems in the specified subfolder. All test problems need to be loaded without errors/exceptions. /// </summary> /// <param name="subFolder">Test cases subfolder.</param> /// <param name="problems">List of problem names.</param> private static void TestBatch(string subFolder, params string[] problems) { List <FilePaths> filePathsList = new List <FilePaths>(); foreach (var problem in problems) { filePathsList.Add(GetFilePaths(subFolder, problem)); } foreach (var filePath in filePathsList) { try { PDDLInputData data = new PDDLInputData(filePath.Domain, filePath.Problem); Assert.IsNotNull(data.Domain); Assert.IsNotNull(data.Problem); Assert.IsTrue(Utilities.CheckToStringExport(data)); } catch (System.Exception e) { throw new System.Exception($"{filePath.ProblemId}: {e.Message}"); } } }
public void TC_ConstraintsInProblem() { PDDLInputData data = new PDDLInputData(GetFilePath("TC_ConstraintsInDomain.pddl"), GetFilePath("TC_ConstraintsInProblem.pddl")); Assert.IsTrue(Utilities.CheckToStringExport(data)); Assert.AreEqual(11, data.Problem.Constraints.Count); var constr0 = data.Problem.Constraints[0] as ForallConstraint; Assert.IsNotNull(constr0); Assert.AreEqual(1, constr0.Parameters.Count); Assert.AreEqual("?a", constr0.Parameters[0].ParameterName); Assert.AreEqual(Parameter.DefaultType, constr0.Parameters[0].TypeNames[0]); var argConstraints = constr0.Constraints; Assert.AreEqual(1, argConstraints.Count); Assert.IsTrue(argConstraints[0] is AlwaysConstraint); var constr1 = data.Problem.Constraints[1] as AtEndConstraint; Assert.IsNotNull(constr1); Assert.IsTrue(constr1.Expression is PredicateExpression); var constr2 = data.Problem.Constraints[2] as AlwaysConstraint; Assert.IsNotNull(constr2); Assert.IsTrue(constr2.Expression is PredicateExpression); var constr3 = data.Problem.Constraints[3] as SometimeConstraint; Assert.IsNotNull(constr3); Assert.IsTrue(constr3.Expression is PredicateExpression); var constr4 = data.Problem.Constraints[4] as WithinConstraint; Assert.IsNotNull(constr4); Assert.AreEqual(6.0, constr4.Number); Assert.IsTrue(constr4.Expression is PredicateExpression); var constr5 = data.Problem.Constraints[5] as AtMostOnceConstraint; Assert.IsNotNull(constr5); Assert.IsTrue(constr5.Expression is PredicateExpression); var constr6 = data.Problem.Constraints[6] as SometimeAfterConstraint; Assert.IsNotNull(constr6); Assert.IsTrue(constr6.Expression1 is PredicateExpression); Assert.IsTrue(constr6.Expression2 is PredicateExpression); var constr7 = data.Problem.Constraints[7] as SometimeBeforeConstraint; Assert.IsNotNull(constr7); Assert.IsTrue(constr7.Expression1 is PredicateExpression); Assert.IsTrue(constr7.Expression2 is PredicateExpression); var constr8 = data.Problem.Constraints[8] as AlwaysWithinConstraint; Assert.IsNotNull(constr8); Assert.AreEqual(6.0, constr8.Number); Assert.IsTrue(constr8.Expression1 is PredicateExpression); Assert.IsTrue(constr8.Expression2 is PredicateExpression); var constr9 = data.Problem.Constraints[9] as HoldDuringConstraint; Assert.IsNotNull(constr9); Assert.AreEqual(6.0, constr9.Number1); Assert.AreEqual(6.0, constr9.Number2); Assert.IsTrue(constr9.Expression is PredicateExpression); var constr10 = data.Problem.Constraints[10] as HoldAfterConstraint; Assert.IsNotNull(constr10); Assert.AreEqual(6.0, constr10.Number); Assert.IsTrue(constr10.Expression is PredicateExpression); }
public void TC_Effects() { PDDLInputData data = new PDDLInputData(GetFilePath("TC_Effects.pddl"), GetFilePath("Dummy_P.pddl")); Assert.IsTrue(Utilities.CheckToStringExport(data)); Assert.AreEqual(1, data.Domain.Actions.Count); var effects = data.Domain.Actions[0].Effects; Assert.AreEqual(7, effects.Count); var effect0 = effects[0] as PredicateEffect; Assert.IsNotNull(effect0); Assert.AreEqual("pred", effect0.Name); Assert.AreEqual(1, effect0.Terms.Count); Assert.IsTrue(effect0.Terms[0] is VariableTerm); Assert.AreEqual("?aa", ((VariableTerm)effect0.Terms[0]).Name); var effect1 = effects[1] as EqualsEffect; Assert.IsNotNull(effect1); Assert.IsTrue(effect1.Term1 is ObjectFunctionTerm); Assert.IsTrue(effect1.Term2 is ConstantTerm); var effect2 = effects[2] as ForallEffect; Assert.IsNotNull(effect2); Assert.AreEqual(1, effect2.Parameters.Count); Assert.AreEqual("?cc", effect2.Parameters[0].ParameterName); Assert.AreEqual("typeA", effect2.Parameters[0].TypeNames[0]); Assert.AreEqual(1, effect2.Effects.Count); Assert.IsTrue(effect2.Effects[0] is PredicateEffect); var effect3 = effects[3] as WhenEffect; Assert.IsNotNull(effect3); Assert.IsTrue(effect3.Expression is PredicateExpression); Assert.AreEqual(2, effect3.Effects.Count); Assert.IsTrue(effect3.Effects[0] is PredicateEffect); Assert.IsTrue(effect3.Effects[1] is PredicateEffect); var effect4 = effects[4] as NumericAssignEffect; Assert.IsNotNull(effect4); Assert.AreEqual(AssignOperator.ASSIGN, effect4.AssignOperator); Assert.AreEqual("numFunc", effect4.Function.Name); Assert.AreEqual(0, effect4.Function.Terms.Count); Assert.IsTrue(effect4.Value is Number); var effect5 = effects[5] as ObjectAssignEffect; Assert.IsNotNull(effect5); Assert.AreEqual("objFunc", effect5.Function.Name); Assert.AreEqual(0, effect5.Function.Terms.Count); Assert.IsTrue(effect5.Value is VariableTerm); var effect6 = effects[6] as NumericAssignEffect; Assert.IsNotNull(effect6); Assert.AreEqual(AssignOperator.SCALE_UP, effect6.AssignOperator); Assert.AreEqual("numFunc", effect6.Function.Name); Assert.IsTrue(effect6.Value is Plus); }
public void TC_Init() { PDDLInputData data = new PDDLInputData(GetFilePath("TC_Init_D.pddl"), GetFilePath("TC_Init_P.pddl")); Assert.IsTrue(Utilities.CheckToStringExport(data)); Assert.AreEqual(8, data.Problem.Init.Count); var initElem0 = data.Problem.Init[0] as PredicateInitElement; Assert.IsNotNull(initElem0); Assert.AreEqual("pred", initElem0.Name); Assert.AreEqual(1, initElem0.Terms.Count); Assert.AreEqual("constA", initElem0.Terms[0].Name); var initElem1 = data.Problem.Init[1] as EqualsInitElement; Assert.IsNotNull(initElem1); Assert.AreEqual("constA", initElem1.Term1.Name); Assert.AreEqual("constB", initElem1.Term2.Name); var initElem2 = data.Problem.Init[2] as NotInitElement; Assert.IsNotNull(initElem2); Assert.IsTrue(initElem2.Element is PredicateInitElement); var initElem3 = data.Problem.Init[3] as AtInitElement; Assert.IsNotNull(initElem3); Assert.AreEqual(5, initElem3.Number); Assert.IsTrue(initElem3.Element is PredicateInitElement); var initElem4 = data.Problem.Init[4] as EqualsNumericFunctionInitElement; Assert.IsNotNull(initElem4); Assert.AreEqual("numFuncA", initElem4.Function.Name); Assert.AreEqual(0, initElem4.Function.Terms.Count); Assert.AreEqual(66, initElem4.Number); var initElem5 = data.Problem.Init[5] as EqualsObjectFunctionInitElement; Assert.IsNotNull(initElem5); Assert.AreEqual("objFuncA", initElem5.Function.Name); Assert.AreEqual(0, initElem5.Function.Terms.Count); Assert.AreEqual("constA", initElem5.Term.Name); var initElem6 = data.Problem.Init[6] as EqualsNumericFunctionInitElement; Assert.IsNotNull(initElem6); Assert.AreEqual("numFuncB", initElem6.Function.Name); Assert.AreEqual(1, initElem6.Function.Terms.Count); Assert.AreEqual("constA", initElem6.Function.Terms[0].Name); Assert.AreEqual(55, initElem6.Number); var initElem7 = data.Problem.Init[7] as EqualsObjectFunctionInitElement; Assert.IsNotNull(initElem7); Assert.AreEqual("objFuncB", initElem7.Function.Name); Assert.AreEqual(1, initElem7.Function.Terms.Count); Assert.AreEqual("constA", initElem7.Function.Terms[0].Name); Assert.AreEqual("constB", initElem7.Term.Name); }