OilfieldToolsNet/opm-common
4
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

fix some screw-up with internal vs deck names

Browse Source 
Parser::hasKeyword() was called with deckNames but looked up the map
for internal names. This patch renames the method to hasDeckName(),
renames Parser::getKeyword() to Parser::getKeywordFromDeckName() and
adapts/extends the tests.
This commit is contained in:
Andreas Lauser 2014-07-01 16:57:07 +02:00
parent e2eca64f59
commit f754bd9c45
7 changed files with 118 additions and 81 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
opm/parser/eclipse/Applications/opm-eclkw.cpp
View File

@ -81,7 +81,7 @@ static void printItems(Opm::ParserKeywordConstPtr keyword)
static void printKeywords (Opm::ParserPtr parser, std::vector<std::string>& keywords)
{
for (auto iterator = keywords.begin(); iterator != keywords.end(); ++iterator) {
Opm::ParserKeywordConstPtr keyword = parser->getParserKeyword(*iterator);
Opm::ParserKeywordConstPtr keyword = parser->getParserKeywordFromDeckName(*iterator);
printKeyword(keyword);
printItems(keyword);
}
@ -101,7 +101,7 @@ static std::vector<std::string> createListOfKeywordsToDescribe(char** argv, bool
{
std::vector<std::string> keywords;
if (allKeywords) {
keywords = parser->getAllParserKeywordNames();
keywords = parser->getAllDeckNames();
} else {
keywords.push_back(argv[1]);
}

37
opm/parser/eclipse/IntegrationTests/IntegrationTests.cpp
View File

@ -49,8 +49,8 @@ static ParserPtr createWWCTParser() {
BOOST_AUTO_TEST_CASE(parse_fileWithWWCTKeyword_deckReturned) {
boost::filesystem::path singleKeywordFile("testdata/integration_tests/wwct.data");
ParserPtr parser = createWWCTParser();
BOOST_CHECK( parser->canParseKeyword("WWCT"));
BOOST_CHECK( parser->canParseKeyword("SUMMARY"));
BOOST_CHECK( parser->canParseDeckKeyword("WWCT"));
BOOST_CHECK( parser->canParseDeckKeyword("SUMMARY"));
BOOST_CHECK_NO_THROW(DeckPtr deck = parser->parseFile(singleKeywordFile.string()));
}
@ -63,8 +63,8 @@ BOOST_AUTO_TEST_CASE(parse_stringWithWWCTKeyword_deckReturned) {
" 'WELL-1' 'WELL-2' / -- Ehne mehne muh\n"
"/\n";
ParserPtr parser = createWWCTParser();
BOOST_CHECK( parser->canParseKeyword("WWCT"));
BOOST_CHECK( parser->canParseKeyword("SUMMARY"));
BOOST_CHECK( parser->canParseDeckKeyword("WWCT"));
BOOST_CHECK( parser->canParseDeckKeyword("SUMMARY"));
BOOST_CHECK_NO_THROW(DeckPtr deck = parser->parseString(wwctString));
}
@ -79,8 +79,8 @@ BOOST_AUTO_TEST_CASE(parse_streamWithWWCTKeyword_deckReturned) {
std::shared_ptr<std::istream> wwctStream(new std::istringstream(wwctString));
ParserPtr parser = createWWCTParser();
BOOST_CHECK( parser->canParseKeyword("WWCT"));
BOOST_CHECK( parser->canParseKeyword("SUMMARY"));
BOOST_CHECK( parser->canParseDeckKeyword("WWCT"));
BOOST_CHECK( parser->canParseDeckKeyword("SUMMARY"));
BOOST_CHECK_NO_THROW(DeckPtr deck = parser->parseStream(wwctStream));
}
@ -100,6 +100,29 @@ BOOST_AUTO_TEST_CASE(parse_fileWithWWCTKeyword_dataIsCorrect) {
BOOST_CHECK_EQUAL("WELL-2", deck->getKeyword("WWCT" , 0)->getRecord(0)->getItem(0)->getString(1));
}
BOOST_AUTO_TEST_CASE(parser_internal_name_vs_deck_name) {
ParserPtr parser(new Opm::Parser());
// the WELL_PROBE keyword is present by default
BOOST_CHECK(parser->hasInternalKeyword("WELL_PROBE"));
// the NONEXISTING_PROBE keyword is _not_ present by default
BOOST_CHECK(!parser->hasInternalKeyword("NONEXISTING_PROBE"));
// internal names cannot appear in the deck if the deck names and/or deck regular
// match expressions are given
BOOST_CHECK(!parser->canParseDeckKeyword("WELL_PROBE"));
// an existing deck name
BOOST_CHECK(parser->canParseDeckKeyword("WWPR"));
// a non-existing deck name
BOOST_CHECK(!parser->canParseDeckKeyword("WWPRFOO"));
// user defined quantity. (regex needs to be used.)
BOOST_CHECK(parser->canParseDeckKeyword("WUFOO"));
}
static ParserPtr createBPRParser() {
ParserKeywordPtr parserKeyword = ParserKeyword::createDynamicSized("BPR");
{
@ -221,7 +244,7 @@ BOOST_AUTO_TEST_CASE(parse_truncatedrecords_deckFilledWithDefaults) {
BOOST_CHECK_EQUAL(ParserItem::defaultInt(), radfin4_2_nodata->getRecord(0)->getItem(1)->getInt(0));
ParserKeywordConstPtr parserKeyword = parser->getParserKeyword("RADFIN4");
ParserKeywordConstPtr parserKeyword = parser->getParserKeywordFromDeckName("RADFIN4");
ParserRecordConstPtr parserRecord = parserKeyword->getRecord();
ParserItemConstPtr nwmaxItem = parserRecord->get("NWMAX");
ParserIntItemConstPtr intItem = std::static_pointer_cast<const ParserIntItem>(nwmaxItem);

6
opm/parser/eclipse/IntegrationTests/ParseACTION.cpp
View File

@ -46,9 +46,9 @@ BOOST_AUTO_TEST_CASE( parse_ACTION_OK ) {
parser->addParserKeyword( DIMENS );
parser->addParserKeyword( THROW );
BOOST_REQUIRE( parser->canParseKeyword( "DIMENS" ));
BOOST_REQUIRE( parser->canParseKeyword( "WCONHIST" ));
BOOST_REQUIRE( parser->canParseKeyword( "THROW" ));
BOOST_REQUIRE( parser->canParseDeckKeyword( "DIMENS" ));
BOOST_REQUIRE( parser->canParseDeckKeyword( "WCONHIST" ));
BOOST_REQUIRE( parser->canParseDeckKeyword( "THROW" ));
BOOST_REQUIRE_THROW( parser->parseFile( actionFile2.string() , false) , std::invalid_argument );

2
opm/parser/eclipse/IntegrationTests/ParseVFPPROD.cpp
View File

@ -38,7 +38,7 @@ using namespace Opm;
BOOST_AUTO_TEST_CASE( parse_VFPPROD_OK ) {
ParserPtr parser(new Parser());
boost::filesystem::path file("testdata/integration_tests/VFPPROD/VFPPROD1");
BOOST_CHECK( parser->canParseKeyword("VFPPROD"));
BOOST_CHECK( parser->canParseDeckKeyword("VFPPROD"));
DeckPtr deck = parser->parseFile(file.string());

35
opm/parser/eclipse/Parser/Parser.cpp
View File

@ -118,6 +118,14 @@ namespace Opm {
return m_deckParserKeywords.size();
}
bool Parser::hasInternalKeyword(const std::string& internalKeywordName) const {
return (m_internalParserKeywords.count(internalKeywordName) > 0);
}
ParserKeywordConstPtr Parser::getParserKeywordFromInternalName(const std::string& internalKeywordName) const {
return m_internalParserKeywords.at(internalKeywordName);
}
ParserKeywordConstPtr Parser::matchingKeyword(const std::string& name) const {
for (auto iter = m_wildCardKeywords.begin(); iter != m_wildCardKeywords.end(); ++iter) {
if (iter->second->matches(name))
@ -126,16 +134,11 @@ namespace Opm {
return ParserKeywordConstPtr();
}
bool Parser::hasKeyword(const std::string& internalKeywordName) const {
return (m_internalParserKeywords.count(internalKeywordName) > 0);
}
bool Parser::hasWildCardKeyword(const std::string& internalKeywordName) const {
return (m_wildCardKeywords.count(internalKeywordName) > 0);
}
bool Parser::canParseKeyword( const std::string& deckKeywordName) const {
bool Parser::canParseDeckKeyword( const std::string& deckKeywordName) const {
if (!ParserKeyword::validDeckName(deckKeywordName))
return false;
@ -183,8 +186,8 @@ namespace Opm {
ParserKeywordConstPtr Parser::getParserKeyword(const std::string& deckKeywordName) const {
if (hasKeyword(deckKeywordName)) {
ParserKeywordConstPtr Parser::getParserKeywordFromDeckName(const std::string& deckKeywordName) const {
if (m_deckParserKeywords.count(deckKeywordName)) {
return m_deckParserKeywords.at(deckKeywordName);
} else {
ParserKeywordConstPtr wildCardKeyword = matchingKeyword( deckKeywordName );
@ -196,7 +199,7 @@ namespace Opm {
}
}
std::vector<std::string> Parser::getAllParserKeywordNames () const {
std::vector<std::string> Parser::getAllDeckNames () const {
std::vector<std::string> keywords;
for (auto iterator = m_deckParserKeywords.begin(); iterator != m_deckParserKeywords.end(); iterator++) {
keywords.push_back(iterator->first);
@ -269,8 +272,8 @@ namespace Opm {
if (verbose)
std::cout << parserState->rawKeyword->getKeywordName() << std::endl;
if (canParseKeyword(parserState->rawKeyword->getKeywordName())) {
ParserKeywordConstPtr parserKeyword = getParserKeyword(parserState->rawKeyword->getKeywordName());
if (canParseDeckKeyword(parserState->rawKeyword->getKeywordName())) {
ParserKeywordConstPtr parserKeyword = getParserKeywordFromDeckName(parserState->rawKeyword->getKeywordName());
ParserKeywordActionEnum action = parserKeyword->getAction();
if (action == INTERNALIZE) {
DeckKeywordPtr deckKeyword = parserKeyword->parse(parserState->rawKeyword);
@ -307,8 +310,8 @@ namespace Opm {
}
RawKeywordPtr Parser::createRawKeyword(const std::string & keywordString, std::shared_ptr<ParserState> parserState) const {
if (canParseKeyword(keywordString)) {
ParserKeywordConstPtr parserKeyword = getParserKeyword( keywordString );
if (canParseDeckKeyword(keywordString)) {
ParserKeywordConstPtr parserKeyword = getParserKeywordFromDeckName( keywordString );
ParserKeywordActionEnum action = parserKeyword->getAction();
if (action == THROW_EXCEPTION)
@ -374,7 +377,7 @@ namespace Opm {
}
} else {
if (parserState->rawKeyword->getSizeType() == Raw::UNKNOWN) {
if (canParseKeyword(line)) {
if (canParseDeckKeyword(line)) {
parserState->rawKeyword->finalizeUnknownSize();
parserState->nextKeyword = line;
return true;
@ -440,8 +443,8 @@ namespace Opm {
deck->initUnitSystem();
for (size_t index=0; index < deck->size(); ++index) {
DeckKeywordPtr deckKeyword = deck->getKeyword( index );
if (canParseKeyword( deckKeyword->name())) {
ParserKeywordConstPtr parserKeyword = getParserKeyword( deckKeyword->name() );
if (canParseDeckKeyword( deckKeyword->name())) {
ParserKeywordConstPtr parserKeyword = getParserKeywordFromDeckName( deckKeyword->name() );
if (parserKeyword->hasDimension()) {
parserKeyword->applyUnitsToDeck(deck , deckKeyword);
}

19
opm/parser/eclipse/Parser/Parser.hpp
View File

@ -53,9 +53,10 @@ namespace Opm {
/// Method to add ParserKeyword instances, these holding type and size information about the keywords and their data.
void addParserKeyword(ParserKeywordConstPtr parserKeyword);
bool dropParserKeyword(const std::string& parserKeywordName);
bool canParseKeyword( const std::string& deckKeywordName) const;
ParserKeywordConstPtr getParserKeyword(const std::string& deckKeywordName) const;
std::vector<std::string> getAllParserKeywordNames () const;
bool canParseDeckKeyword( const std::string& deckKeywordName) const;
ParserKeywordConstPtr getParserKeywordFromDeckName(const std::string& deckKeywordName) const;
std::vector<std::string> getAllDeckNames () const;
void loadKeywords(const Json::JsonObject& jsonKeywords);
bool loadKeywordFromFile(const boost::filesystem::path& configFile);
@ -70,6 +71,17 @@ namespace Opm {
*/
size_t size() const;
/*!
* \brief Returns whether the parser knows about an keyword with a given internal
* name.
*/
bool hasInternalKeyword(const std::string& internalKeywordName) const;
/*!
* \brief Retrieve a ParserKeyword object given an internal keyword name.
*/
ParserKeywordConstPtr getParserKeywordFromInternalName(const std::string& internalKeywordName) const;
private:
// associative map of the parser internal name and the corresponding ParserKeyword object
std::map<std::string, ParserKeywordConstPtr> m_internalParserKeywords;
@ -79,7 +91,6 @@ namespace Opm {
// ParserKeyword object for keywords which match a regular expression
std::map<std::string, ParserKeywordConstPtr> m_wildCardKeywords;
bool hasKeyword(const std::string& keyword) const;
bool hasWildCardKeyword(const std::string& keyword) const;
ParserKeywordConstPtr matchingKeyword(const std::string& keyword) const;

96
opm/parser/eclipse/Parser/tests/ParserTests.cpp
View File

@ -52,10 +52,10 @@ BOOST_AUTO_TEST_CASE(addKeyword_keyword_doesntfail) {
}
BOOST_AUTO_TEST_CASE(canParseKeyword_canParseKeyword_returnstrue) {
BOOST_AUTO_TEST_CASE(canParseDeckKeyword_returnstrue) {
ParserPtr parser(new Parser());
parser->addParserKeyword(ParserKeyword::createDynamicSized("FJAS"));
BOOST_CHECK(parser->canParseKeyword("FJAS"));
BOOST_CHECK(parser->canParseDeckKeyword("FJAS"));
}
@ -63,29 +63,29 @@ BOOST_AUTO_TEST_CASE(getKeyword_haskeyword_returnskeyword) {
ParserPtr parser(new Parser());
ParserKeywordConstPtr parserKeyword = ParserKeyword::createDynamicSized("FJAS");
parser->addParserKeyword(parserKeyword);
BOOST_CHECK_EQUAL(parserKeyword, parser->getParserKeyword("FJAS"));
BOOST_CHECK_EQUAL(parserKeyword, parser->getParserKeywordFromDeckName("FJAS"));
}
BOOST_AUTO_TEST_CASE(getKeyword_hasnotkeyword_getKeywordThrowsException) {
ParserPtr parser(new Parser());
ParserKeywordConstPtr parserKeyword = ParserKeyword::createDynamicSized("FJAS");
parser->addParserKeyword(parserKeyword);
BOOST_CHECK_THROW(parser->getParserKeyword("FJASS"), std::invalid_argument);
BOOST_CHECK_THROW(parser->getParserKeywordFromDeckName("FJASS"), std::invalid_argument);
}
BOOST_AUTO_TEST_CASE(getAllParserKeywordNames_hasTwoKeywords_returnsCompleteList) {
BOOST_AUTO_TEST_CASE(getAllDeckNames_hasTwoKeywords_returnsCompleteList) {
ParserPtr parser(new Parser(false));
std::cout << parser->getAllParserKeywordNames().size() << std::endl;
std::cout << parser->getAllDeckNames().size() << std::endl;
ParserKeywordConstPtr firstParserKeyword = ParserKeyword::createDynamicSized("FJAS");
parser->addParserKeyword(firstParserKeyword);
ParserKeywordConstPtr secondParserKeyword = ParserKeyword::createDynamicSized("SAJF");
parser->addParserKeyword(secondParserKeyword);
BOOST_CHECK_EQUAL(2U, parser->getAllParserKeywordNames().size());
BOOST_CHECK_EQUAL(2U, parser->getAllDeckNames().size());
}
BOOST_AUTO_TEST_CASE(getAllParserKeywordNames_hasNoKeywords_returnsEmptyList) {
BOOST_AUTO_TEST_CASE(getAllDeckNames_hasNoKeywords_returnsEmptyList) {
ParserPtr parser(new Parser(false));
BOOST_CHECK_EQUAL(0U, parser->getAllParserKeywordNames().size());
BOOST_CHECK_EQUAL(0U, parser->getAllDeckNames().size());
}
@ -93,11 +93,11 @@ BOOST_AUTO_TEST_CASE(getAllParserKeywordNames_hasNoKeywords_returnsEmptyList) {
/************************ JSON config related tests **********************'*/
BOOST_AUTO_TEST_CASE(addParserKeywordJSON_canParseKeyword_returnstrue) {
BOOST_AUTO_TEST_CASE(addParserKeywordJSON_canParseDeckKeyword_returnstrue) {
ParserPtr parser(new Parser());
Json::JsonObject jsonConfig("{\"name\": \"BPR\", \"size\" : 100 , \"items\" :[{\"name\":\"ItemX\" , \"size_type\":\"SINGLE\" , \"value_type\" : \"DOUBLE\"}]}");
parser->addParserKeyword(ParserKeyword::createFromJson( jsonConfig ));
BOOST_CHECK(parser->canParseKeyword("BPR"));
BOOST_CHECK(parser->canParseDeckKeyword("BPR"));
}
@ -105,7 +105,7 @@ BOOST_AUTO_TEST_CASE(addParserKeywordJSON_size_isObject_allGood) {
ParserPtr parser(new Parser());
Json::JsonObject jsonConfig("{\"name\": \"EQUIXL\", \"size\" : {\"keyword\":\"EQLDIMS\" , \"item\" : \"NTEQUL\"}, \"items\" :[{\"name\":\"ItemX\" , \"size_type\":\"SINGLE\" , \"value_type\" : \"DOUBLE\"}]}");
parser->addParserKeyword(ParserKeyword::createFromJson( jsonConfig ));
BOOST_CHECK(parser->canParseKeyword("EQUIXL"));
BOOST_CHECK(parser->canParseDeckKeyword("EQUIXL"));
}
@ -119,12 +119,12 @@ BOOST_AUTO_TEST_CASE(loadKeywordsJSON_notArray_throw) {
BOOST_AUTO_TEST_CASE(loadKeywordsJSON_canParseKeyword_returnstrue) {
BOOST_AUTO_TEST_CASE(loadKeywordsJSON_canParseDeckKeyword_returnstrue) {
ParserPtr parser(new Parser());
Json::JsonObject jsonConfig( "[{\"name\" : \"BPR\" , \"size\" : 100, \"items\" :[{\"name\":\"ItemX\" , \"size_type\":\"SINGLE\" , \"value_type\" : \"DOUBLE\"}]}]");
parser->loadKeywords( jsonConfig );
BOOST_CHECK(parser->canParseKeyword("BPR"));
BOOST_CHECK(parser->canParseDeckKeyword("BPR"));
}
@ -140,9 +140,9 @@ BOOST_AUTO_TEST_CASE(loadKeywordsJSON_manyKeywords_returnstrue) {
Json::JsonObject jsonConfig( "[{\"name\" : \"BPR\" , \"size\" : 100 , \"items\" :[{\"name\":\"ItemX\" , \"size_type\":\"SINGLE\" , \"value_type\" : \"DOUBLE\"}]}, {\"name\" : \"WWCT\", \"size\" : 0} , {\"name\" : \"EQUIL\" , \"size\" : 0}]");
parser->loadKeywords( jsonConfig );
BOOST_CHECK(parser->canParseKeyword("BPR"));
BOOST_CHECK(parser->canParseKeyword("WWCT"));
BOOST_CHECK(parser->canParseKeyword("EQUIL"));
BOOST_CHECK(parser->canParseDeckKeyword("BPR"));
BOOST_CHECK(parser->canParseDeckKeyword("WWCT"));
BOOST_CHECK(parser->canParseDeckKeyword("EQUIL"));
BOOST_CHECK_EQUAL( 3U , parser->size() );
}
@ -178,7 +178,7 @@ BOOST_AUTO_TEST_CASE(loadKeywordFromFile_validKeyword_returnsTrueHasKeyword) {
boost::filesystem::path configFile("testdata/json/BPR");
BOOST_CHECK_EQUAL( true , parser->loadKeywordFromFile( configFile ));
BOOST_CHECK_EQUAL( 1U , parser->size() );
BOOST_CHECK_EQUAL( true , parser->canParseKeyword("BPR") );
BOOST_CHECK_EQUAL( true , parser->canParseDeckKeyword("BPR") );
}
@ -191,12 +191,12 @@ BOOST_AUTO_TEST_CASE(loadConfigFromDirectory_directoryDoesNotexist_throws) {
BOOST_AUTO_TEST_CASE(loadConfigFromDirectory_notRecursive_allNames) {
ParserPtr parser(new Parser(false));
BOOST_CHECK_EQUAL(false , parser->canParseKeyword("BPR"));
BOOST_CHECK_EQUAL(false , parser->canParseDeckKeyword("BPR"));
boost::filesystem::path configPath("testdata/config/directory1");
BOOST_CHECK_NO_THROW(parser->loadKeywordsFromDirectory( configPath, false));
BOOST_CHECK(parser->canParseKeyword("WWCT"));
BOOST_CHECK_EQUAL(true , parser->canParseKeyword("BPR"));
BOOST_CHECK_EQUAL(false , parser->canParseKeyword("DIMENS"));
BOOST_CHECK(parser->canParseDeckKeyword("WWCT"));
BOOST_CHECK_EQUAL(true , parser->canParseDeckKeyword("BPR"));
BOOST_CHECK_EQUAL(false , parser->canParseDeckKeyword("DIMENS"));
}
@ -204,78 +204,78 @@ BOOST_AUTO_TEST_CASE(loadConfigFromDirectory_notRecursive_strictNames) {
ParserPtr parser(new Parser(false));
boost::filesystem::path configPath("testdata/config/directory1");
BOOST_CHECK_NO_THROW(parser->loadKeywordsFromDirectory( configPath, false));
BOOST_CHECK(parser->canParseKeyword("WWCT"));
BOOST_CHECK(parser->canParseDeckKeyword("WWCT"));
// the file name for the following keyword is "Bpr", but that
// does not matter
BOOST_CHECK_EQUAL(true , parser->canParseKeyword("BPR"));
BOOST_CHECK_EQUAL(false , parser->canParseKeyword("DIMENS"));
BOOST_CHECK_EQUAL(true , parser->canParseDeckKeyword("BPR"));
BOOST_CHECK_EQUAL(false , parser->canParseDeckKeyword("DIMENS"));
}
BOOST_AUTO_TEST_CASE(loadConfigFromDirectory_Recursive_allNames) {
ParserPtr parser(new Parser(false));
BOOST_CHECK_EQUAL(false , parser->canParseKeyword("BPR"));
BOOST_CHECK_EQUAL(false , parser->canParseDeckKeyword("BPR"));
boost::filesystem::path configPath("testdata/config/directory1");
BOOST_CHECK_NO_THROW(parser->loadKeywordsFromDirectory( configPath, true));
BOOST_CHECK(parser->canParseKeyword("WWCT"));
BOOST_CHECK_EQUAL(true , parser->canParseKeyword("BPR"));
BOOST_CHECK_EQUAL(true , parser->canParseKeyword("DIMENS"));
BOOST_CHECK(parser->canParseDeckKeyword("WWCT"));
BOOST_CHECK_EQUAL(true , parser->canParseDeckKeyword("BPR"));
BOOST_CHECK_EQUAL(true , parser->canParseDeckKeyword("DIMENS"));
}
BOOST_AUTO_TEST_CASE(loadConfigFromDirectory_default) {
ParserPtr parser(new Parser(false));
BOOST_CHECK_EQUAL(false , parser->canParseKeyword("BPR"));
BOOST_CHECK_EQUAL(false , parser->canParseDeckKeyword("BPR"));
boost::filesystem::path configPath("testdata/config/directory1");
BOOST_CHECK_NO_THROW(parser->loadKeywordsFromDirectory( configPath ));
BOOST_CHECK(parser->canParseKeyword("WWCT"));
BOOST_CHECK(parser->canParseDeckKeyword("WWCT"));
// the file name for the following keyword is "Bpr", but that
// does not matter
BOOST_CHECK_EQUAL(true , parser->canParseKeyword("BPR"));
BOOST_CHECK_EQUAL(true , parser->canParseKeyword("DIMENS"));
BOOST_CHECK_EQUAL(true , parser->canParseDeckKeyword("BPR"));
BOOST_CHECK_EQUAL(true , parser->canParseDeckKeyword("DIMENS"));
}
BOOST_AUTO_TEST_CASE(DropKeyword) {
ParserPtr parser(new Parser());
BOOST_CHECK_EQUAL(false , parser->dropParserKeyword("DoesNotHaveThis"));
BOOST_CHECK_EQUAL(true , parser->canParseKeyword("BPR"));
BOOST_CHECK_EQUAL(true , parser->canParseDeckKeyword("BPR"));
BOOST_CHECK_EQUAL(true , parser->dropParserKeyword("BLOCK_PROBE"));
BOOST_CHECK_EQUAL(false , parser->dropParserKeyword("BLOCK_PROBE"));
BOOST_CHECK_EQUAL(false , parser->canParseKeyword("BPR"));
BOOST_CHECK_EQUAL(false , parser->canParseDeckKeyword("BPR"));
BOOST_CHECK_EQUAL(true , parser->canParseKeyword("TVDPX"));
BOOST_CHECK_EQUAL(true , parser->canParseDeckKeyword("TVDPX"));
BOOST_CHECK_EQUAL(true , parser->dropParserKeyword("TVDP"));
BOOST_CHECK_EQUAL(false , parser->canParseKeyword("TVDPX"));
BOOST_CHECK_EQUAL(false , parser->canParseDeckKeyword("TVDPX"));
}
BOOST_AUTO_TEST_CASE(ReplaceKeyword) {
ParserPtr parser(new Parser());
ParserKeywordConstPtr eqldims = parser->getParserKeyword("EQLDIMS");
ParserKeywordConstPtr eqldims = parser->getParserKeywordFromDeckName("EQLDIMS");
BOOST_CHECK_EQUAL( 5U , eqldims->numItems());
BOOST_CHECK( parser->loadKeywordFromFile( "testdata/parser/EQLDIMS2" ) );
eqldims = parser->getParserKeyword("EQLDIMS");
eqldims = parser->getParserKeywordFromDeckName("EQLDIMS");
BOOST_CHECK_EQUAL( 1U , eqldims->numItems());
}
BOOST_AUTO_TEST_CASE(WildCardTest) {
ParserPtr parser(new Parser());
BOOST_CHECK(!parser->canParseKeyword("TVDP*"));
BOOST_CHECK(!parser->canParseKeyword("TVDP"));
BOOST_CHECK(parser->canParseKeyword("TVDPXXX"));
BOOST_CHECK(!parser->canParseKeyword("TVDPIAMTOOLONG"));
BOOST_CHECK(!parser->canParseKeyword("TVD"));
BOOST_CHECK(!parser->canParseDeckKeyword("TVDP*"));
BOOST_CHECK(!parser->canParseDeckKeyword("TVDP"));
BOOST_CHECK(parser->canParseDeckKeyword("TVDPXXX"));
BOOST_CHECK(!parser->canParseDeckKeyword("TVDPIAMTOOLONG"));
BOOST_CHECK(!parser->canParseDeckKeyword("TVD"));
BOOST_CHECK(!parser->canParseKeyword("TVDP"));
BOOST_CHECK(!parser->canParseDeckKeyword("TVDP"));
ParserKeywordConstPtr keyword1 = parser->getParserKeyword("TVDPA");
ParserKeywordConstPtr keyword2 = parser->getParserKeyword("TVDPBC");
ParserKeywordConstPtr keyword3 = parser->getParserKeyword("TVDPXXX");
ParserKeywordConstPtr keyword1 = parser->getParserKeywordFromDeckName("TVDPA");
ParserKeywordConstPtr keyword2 = parser->getParserKeywordFromDeckName("TVDPBC");
ParserKeywordConstPtr keyword3 = parser->getParserKeywordFromDeckName("TVDPXXX");
BOOST_CHECK_EQUAL( keyword1 , keyword2 );
BOOST_CHECK_EQUAL( keyword1 , keyword3 );