This repository has been archived on 2023-07-19. You can view files and clone it, but cannot push or open issues or pull requests.
plasp/tests/TestPDDLParser.cpp

221 lines
6.5 KiB
C++
Raw Normal View History

#include <gtest/gtest.h>
#include <fstream>
#include <iostream>
#include <sstream>
#include <stdexcept>
#include <plasp/pddl/Description.h>
2016-06-03 17:12:39 +02:00
#include <plasp/pddl/expressions/Either.h>
2016-06-04 14:46:05 +02:00
#include <plasp/pddl/expressions/PrimitiveType.h>
#include <plasp/pddl/expressions/Reference.h>
////////////////////////////////////////////////////////////////////////////////////////////////////
class PDDLParserTests : public ::testing::Test
{
protected:
PDDLParserTests()
: m_blocksworldDomainFile(readFile("data/blocksworld-domain.pddl")),
2016-06-01 16:47:34 +02:00
m_storageDomainFile(readFile("data/storage-domain.pddl")),
2016-06-02 23:41:40 +02:00
m_whiteSpaceTestFile(readFile("data/white-space-test.pddl")),
2016-06-01 16:47:34 +02:00
m_woodworkingDomainFile(readFile("data/woodworking-domain.pddl"))
{
}
static std::stringstream readFile(const std::string &path)
{
std::ifstream fileStream(path, std::ios::in);
std::stringstream outputStream;
if (!fileStream.is_open())
throw std::runtime_error("Could not open file \"" + path + "\"");
outputStream << fileStream.rdbuf();
return outputStream;
}
std::stringstream m_blocksworldDomainFile;
std::stringstream m_storageDomainFile;
2016-06-02 23:41:40 +02:00
std::stringstream m_whiteSpaceTestFile;
2016-06-01 16:47:34 +02:00
std::stringstream m_woodworkingDomainFile;
};
////////////////////////////////////////////////////////////////////////////////////////////////////
TEST_F(PDDLParserTests, ParseBlocksWorldDomain)
{
2016-06-04 14:46:05 +02:00
using namespace plasp::pddl;
try
{
2016-06-04 14:46:05 +02:00
const auto description = Description::fromStream(m_blocksworldDomainFile);
ASSERT_NO_THROW(description.domain());
const auto &domain = description.domain();
// Name
ASSERT_EQ(domain.name(), "blocks");
// Requirements
ASSERT_EQ(domain.requirements().size(), 2u);
2016-06-04 14:46:05 +02:00
ASSERT_EQ(domain.requirements()[0].type(), Requirement::Type::STRIPS);
ASSERT_EQ(domain.requirements()[1].type(), Requirement::Type::Typing);
// Types
ASSERT_EQ(domain.types().size(), 1u);
const auto &block = *domain.types()[0];
ASSERT_EQ(block.name(), "block");
ASSERT_EQ(block.parentTypes().size(), 0u);
// Predicates
ASSERT_EQ(domain.predicates().size(), 5u);
const auto &on = *domain.predicates()[0];
ASSERT_EQ(on.name(), "on");
ASSERT_EQ(on.arguments().size(), 2u);
2016-06-03 13:37:23 +02:00
ASSERT_EQ(on.arguments()[0]->name(), "x");
2016-06-04 14:46:05 +02:00
const auto *onArgument0Type = dynamic_cast<const expressions::PrimitiveType *>(on.arguments()[0]->type());
ASSERT_EQ(onArgument0Type, &block);
2016-06-03 13:37:23 +02:00
ASSERT_EQ(on.arguments()[1]->name(), "y");
2016-06-04 14:46:05 +02:00
const auto onArgument1Type = dynamic_cast<const expressions::PrimitiveType *>(on.arguments()[1]->type());
ASSERT_EQ(onArgument1Type, &block);
const auto &handempty = *domain.predicates()[3];
ASSERT_EQ(handempty.name(), "handempty");
ASSERT_TRUE(handempty.arguments().empty());
}
catch (const std::exception &e)
{
FAIL() << e.what();
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////
TEST_F(PDDLParserTests, ParseStorageDomain)
{
2016-06-04 14:46:05 +02:00
using namespace plasp::pddl;
try
{
const auto description = plasp::pddl::Description::fromStream(m_storageDomainFile);
ASSERT_NO_THROW(description.domain());
const auto &domain = description.domain();
// Name
ASSERT_EQ(domain.name(), "storage-propositional");
// Requirements
ASSERT_EQ(domain.requirements().size(), 1u);
2016-06-04 14:46:05 +02:00
ASSERT_EQ(domain.requirements()[0].type(), Requirement::Type::Typing);
// Types
ASSERT_EQ(domain.types().size(), 10u);
const auto &hoist = *domain.types()[0];
const auto &surface = *domain.types()[1];
const auto &area = *domain.types()[3];
const auto &object = *domain.types()[4];
const auto &storearea = *domain.types()[7];
const auto &crate = *domain.types()[9];
const auto &hoistParents = hoist.parentTypes();
ASSERT_EQ(hoistParents.size(), 1u);
ASSERT_TRUE(std::find(hoistParents.cbegin(), hoistParents.cend(), &object) != hoistParents.cend());
const auto &areaParents = area.parentTypes();
ASSERT_EQ(areaParents.size(), 2u);
ASSERT_TRUE(std::find(areaParents.cbegin(), areaParents.cend(), &object) != areaParents.cend());
ASSERT_TRUE(std::find(areaParents.cbegin(), areaParents.cend(), &surface) != areaParents.cend());
// Predicates
ASSERT_EQ(domain.predicates().size(), 8u);
const auto &on = *domain.predicates()[5];
ASSERT_EQ(on.name(), "on");
ASSERT_EQ(on.arguments().size(), 2u);
2016-06-03 13:37:23 +02:00
ASSERT_EQ(on.arguments()[0]->name(), "c");
2016-06-04 14:46:05 +02:00
const auto onArgument0Type = dynamic_cast<const expressions::PrimitiveType *>(on.arguments()[0]->type());
ASSERT_EQ(onArgument0Type, &crate);
2016-06-03 13:37:23 +02:00
ASSERT_EQ(on.arguments()[1]->name(), "s");
2016-06-04 14:46:05 +02:00
const auto onArgument1Type = dynamic_cast<const expressions::PrimitiveType *>(on.arguments()[1]->type());
ASSERT_EQ(onArgument1Type, &storearea);
const auto &in = *domain.predicates()[1];
ASSERT_EQ(in.name(), "in");
ASSERT_EQ(in.arguments().size(), 2u);
2016-06-03 13:37:23 +02:00
ASSERT_EQ(in.arguments()[0]->name(), "x");
2016-06-04 14:46:05 +02:00
const auto inArgument0Type = dynamic_cast<const expressions::Either *>(in.arguments()[0]->type());
2016-06-03 17:12:39 +02:00
ASSERT_EQ(inArgument0Type->arguments().size(), 2u);
2016-06-04 14:46:05 +02:00
ASSERT_EQ(dynamic_cast<const expressions::Reference<expressions::PrimitiveType> *>(inArgument0Type->arguments()[0].get())->value(), &storearea);
ASSERT_EQ(dynamic_cast<const expressions::Reference<expressions::PrimitiveType> *>(inArgument0Type->arguments()[1].get())->value(), &crate);
}
catch (const std::exception &e)
{
FAIL() << e.what();
}
}
2016-06-01 16:47:34 +02:00
////////////////////////////////////////////////////////////////////////////////////////////////////
TEST_F(PDDLParserTests, ParseConstants)
{
2016-06-04 14:46:05 +02:00
using namespace plasp::pddl;
2016-06-01 16:47:34 +02:00
try
{
2016-06-04 14:46:05 +02:00
const auto description = Description::fromStream(m_woodworkingDomainFile);
2016-06-01 16:47:34 +02:00
ASSERT_NO_THROW(description.domain());
const auto &domain = description.domain();
// Name
ASSERT_EQ(domain.name(), "woodworking");
// Types
const auto &acolour = *domain.types()[0];
const auto &surface = *domain.types()[4];
const auto &treatmentstatus = *domain.types()[5];
// Constants
ASSERT_EQ(domain.constants().size(), 8u);
ASSERT_EQ(domain.constants()[0]->type(), &surface);
ASSERT_EQ(domain.constants()[2]->type(), &surface);
ASSERT_EQ(domain.constants()[3]->type(), &treatmentstatus);
ASSERT_EQ(domain.constants()[6]->type(), &treatmentstatus);
ASSERT_EQ(domain.constants()[7]->type(), &acolour);
}
catch (const std::exception &e)
{
FAIL() << e.what();
}
}
2016-06-02 23:41:40 +02:00
////////////////////////////////////////////////////////////////////////////////////////////////////
TEST_F(PDDLParserTests, ParseWithWhiteSpace)
{
2016-06-04 14:46:05 +02:00
using namespace plasp::pddl;
2016-06-02 23:41:40 +02:00
try
{
2016-06-04 14:46:05 +02:00
ASSERT_NO_THROW(Description::fromStream(m_whiteSpaceTestFile));
2016-06-02 23:41:40 +02:00
}
catch (const std::exception &e)
{
FAIL() << e.what();
}
}