patrick/plasp
Archived
1
0
Fork 0
Code Issues 12 Releases 8 Activity

Added normalization tests for implications.

Browse Source 
These tests ensure that implications are correctly reduced to
disjunctions in preconditions (nested and not) and goal descriptions.
This commit is contained in:
Patrick Lühne 2017-11-09 19:34:47 +01:00
parent b063f5047e
commit 0cf84dd5ca
Signed by: patrick
GPG Key ID: 05F3611E97A70ABF
2 changed files with 110 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

61
lib/pddl/tests/TestNormalization.cpp
View File

@ -97,3 +97,64 @@ TEST_CASE("[normalization] A simple PDDL description is preserved by normalizati
CHECK(goalAnd2->arguments[0].get<pddl::normalizedAST::ConstantPointer>()->declaration == objects[1].get()); CHECK(goalAnd2->arguments[0].get<pddl::normalizedAST::ConstantPointer>()->declaration == objects[1].get());
CHECK(goalAnd2->arguments[1].get<pddl::normalizedAST::ConstantPointer>()->declaration == objects[5].get()); CHECK(goalAnd2->arguments[1].get<pddl::normalizedAST::ConstantPointer>()->declaration == objects[5].get());
} }
////////////////////////////////////////////////////////////////////////////////////////////////////
TEST_CASE("[normalization] Implications are correctly reduced", "[normalization]")
{
pddl::Tokenizer tokenizer;
pddl::Context context(std::move(tokenizer), ignoreWarnings);
const auto domainFile = fs::path("data") / "normalization" / "normalization-2.pddl";
context.tokenizer.read(domainFile);
auto description = pddl::parseDescription(context);
const auto normalizedDescription = pddl::normalize(std::move(description));
const auto &actions = normalizedDescription.domain->actions;
SECTION("top-level “imply” statement")
{
const auto &a1Pre = actions[0]->precondition.value().get<pddl::normalizedAST::Literal>().get<pddl::normalizedAST::AtomicFormula>().get<pddl::normalizedAST::DerivedPredicatePointer>();
REQUIRE(a1Pre->arguments.size() == 1);
CHECK(a1Pre->arguments[0].get<pddl::normalizedAST::VariablePointer>()->declaration->name == "x");
CHECK(a1Pre->declaration->existentialParameters.empty());
CHECK(a1Pre->declaration->parameters.size() == 1);
const auto &a1PreOr = a1Pre->declaration->precondition.value().get<pddl::normalizedAST::OrPointer<pddl::normalizedAST::Literal>>();
REQUIRE(a1PreOr->arguments.size() == 2);
const auto &a1PreOr1Not = a1PreOr->arguments[0].get<pddl::normalizedAST::NotPointer<pddl::normalizedAST::AtomicFormula>>()->argument.get<pddl::normalizedAST::PredicatePointer>();
CHECK(a1PreOr1Not->declaration->name == "test-predicate-0");
const auto &a1PreOr2 = a1PreOr->arguments[1].get<pddl::normalizedAST::AtomicFormula>().get<pddl::normalizedAST::PredicatePointer>();
CHECK(a1PreOr2->declaration->name == "test-predicate-1");
}
SECTION("nested “imply” statement")
{
const auto &and1 = actions[1]->precondition.value().get<pddl::normalizedAST::AndPointer<pddl::normalizedAST::Literal>>();
REQUIRE(and1->arguments.size() == 2);
const auto &d1 = and1->arguments[0].get<pddl::normalizedAST::AtomicFormula>().get<pddl::normalizedAST::DerivedPredicatePointer>();
const auto &and2 = d1->declaration->precondition.value().get<pddl::normalizedAST::AndPointer<pddl::normalizedAST::Literal>>();
REQUIRE(and2->arguments.size() == 2);
const auto &d2 = and2->arguments[0].get<pddl::normalizedAST::AtomicFormula>().get<pddl::normalizedAST::DerivedPredicatePointer>();
const auto &or_ = d2->declaration->precondition.value().get<pddl::normalizedAST::OrPointer<pddl::normalizedAST::Literal>>();
REQUIRE(or_->arguments.size() == 2);
const auto &or1Not = or_->arguments[0].get<pddl::normalizedAST::NotPointer<pddl::normalizedAST::AtomicFormula>>()->argument.get<pddl::normalizedAST::PredicatePointer>();
CHECK(or1Not->declaration->name == "test-predicate-0");
const auto &or2 = or_->arguments[1].get<pddl::normalizedAST::AtomicFormula>().get<pddl::normalizedAST::PredicatePointer>();
CHECK(or2->declaration->name == "test-predicate-1");
}
SECTION("“imply” statement in goal description")
{
const auto &goal = normalizedDescription.problem.value()->goal.value();
const auto &and_ = goal.get<pddl::normalizedAST::AndPointer<pddl::normalizedAST::Literal>>();
REQUIRE(and_->arguments.size() == 2);
const auto &d = and_->arguments[0].get<pddl::normalizedAST::AtomicFormula>().get<pddl::normalizedAST::DerivedPredicatePointer>();
const auto &or_ = d->declaration->precondition.value().get<pddl::normalizedAST::OrPointer<pddl::normalizedAST::Literal>>();
REQUIRE(or_->arguments.size() == 2);
const auto &or1Not = or_->arguments[0].get<pddl::normalizedAST::NotPointer<pddl::normalizedAST::AtomicFormula>>()->argument.get<pddl::normalizedAST::PredicatePointer>();
CHECK(or1Not->declaration->name == "test-predicate-0");
const auto &or2 = or_->arguments[1].get<pddl::normalizedAST::AtomicFormula>().get<pddl::normalizedAST::PredicatePointer>();
CHECK(or2->declaration->name == "test-predicate-1");
}
}

49
tests/data/normalization/normalization-2.pddl Normal file
View File

@ -0,0 +1,49 @@
; tests that “imply” statements in preconditions are correctly reduced
(define (domain test-normalization)
(:predicates
(test-predicate-0)
(test-predicate-1 ?x)
(test-predicate-2 ?x ?y))
; top-level “imply” statement
(:action test-action-1
:parameters
(?x)
:precondition
(imply
(test-predicate-0)
(test-predicate-1 ?x))
:effect
(test-predicate-1 ?x))
; nested “imply” statement
(:action test-action-2
:parameters
(?x)
:precondition
(and
(and
(imply
(test-predicate-0)
(test-predicate-1 ?x))
(test-predicate-0))
(test-predicate-0))
:effect
(test-predicate-1 ?x))
)
(define (problem test-normalization)
(:domain test-normalization)
(:objects a b c)
(:init
(test-predicate-0))
; “imply” statement in goal
(:goal
(and
(imply
(test-predicate-0)
(test-predicate-1 a))
(test-predicate-0))))