separate the internal keyword names and the deck names more clearly
so far, these two concepts were partially mingled in Opm::Parser...
This commit is contained in:
Andreas Lauser
parent
09c5a24473
commit
fe638c2fc8
@ -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->getKeyword(*iterator);
|
||||
Opm::ParserKeywordConstPtr keyword = parser->getParserKeyword(*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->getAllKeywords();
|
||||
keywords = parser->getAllParserKeywordNames();
|
||||
} else {
|
||||
keywords.push_back(argv[1]);
|
||||
}
|
||||
|
||||
@ -41,8 +41,8 @@ static ParserPtr createWWCTParser() {
|
||||
ParserKeywordPtr summaryKeyword = ParserKeyword::createFixedSized("SUMMARY" , (size_t) 0);
|
||||
|
||||
ParserPtr parser(new Parser());
|
||||
parser->addKeyword(parserKeyword);
|
||||
parser->addKeyword(summaryKeyword);
|
||||
parser->addParserKeyword(parserKeyword);
|
||||
parser->addParserKeyword(summaryKeyword);
|
||||
return parser;
|
||||
}
|
||||
|
||||
@ -110,8 +110,8 @@ static ParserPtr createBPRParser() {
|
||||
}
|
||||
ParserKeywordPtr summaryKeyword = ParserKeyword::createFixedSized("SUMMARY" , (size_t) 0);
|
||||
ParserPtr parser(new Parser());
|
||||
parser->addKeyword(parserKeyword);
|
||||
parser->addKeyword(summaryKeyword);
|
||||
parser->addParserKeyword(parserKeyword);
|
||||
parser->addParserKeyword(summaryKeyword);
|
||||
return parser;
|
||||
}
|
||||
|
||||
@ -221,7 +221,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->getKeyword("RADFIN4");
|
||||
ParserKeywordConstPtr parserKeyword = parser->getParserKeyword("RADFIN4");
|
||||
ParserRecordConstPtr parserRecord = parserKeyword->getRecord();
|
||||
ParserItemConstPtr nwmaxItem = parserRecord->get("NWMAX");
|
||||
ParserIntItemConstPtr intItem = std::static_pointer_cast<const ParserIntItem>(nwmaxItem);
|
||||
|
||||
@ -43,8 +43,8 @@ BOOST_AUTO_TEST_CASE( parse_ACTION_OK ) {
|
||||
ParserKeywordConstPtr THROW = ParserKeyword::createFixedSized("THROW" , UNKNOWN , THROW_EXCEPTION );
|
||||
|
||||
BOOST_REQUIRE( parser->loadKeywordFromFile( boost::filesystem::path( std::string(KEYWORD_DIRECTORY) + std::string("/W/WCONHIST") )) );
|
||||
parser->addKeyword( DIMENS );
|
||||
parser->addKeyword( THROW );
|
||||
parser->addParserKeyword( DIMENS );
|
||||
parser->addParserKeyword( THROW );
|
||||
|
||||
BOOST_REQUIRE( parser->canParseKeyword( "DIMENS" ));
|
||||
BOOST_REQUIRE( parser->canParseKeyword( "WCONHIST" ));
|
||||
|
||||
@ -115,22 +115,8 @@ namespace Opm {
|
||||
}
|
||||
|
||||
size_t Parser::size() const {
|
||||
return m_parserKeywords.size();
|
||||
return m_deckParserKeywords.size();
|
||||
}
|
||||
|
||||
|
||||
void Parser::addKeyword(ParserKeywordConstPtr parserKeyword) {
|
||||
for (auto nameIt = parserKeyword->deckNamesBegin();
|
||||
nameIt != parserKeyword->deckNamesEnd();
|
||||
++nameIt)
|
||||
{
|
||||
m_parserKeywords[*nameIt] = parserKeyword;
|
||||
}
|
||||
|
||||
if (parserKeyword->hasMatchRegex())
|
||||
m_wildCardKeywords[parserKeyword->getName()] = parserKeyword;
|
||||
}
|
||||
|
||||
|
||||
ParserKeywordConstPtr Parser::matchingKeyword(const std::string& name) const {
|
||||
for (auto iter = m_wildCardKeywords.begin(); iter != m_wildCardKeywords.end(); ++iter) {
|
||||
@ -141,55 +127,78 @@ namespace Opm {
|
||||
}
|
||||
|
||||
|
||||
bool Parser::hasKeyword(const std::string& keyword) const {
|
||||
return (m_parserKeywords.find(keyword) != m_parserKeywords.end());
|
||||
bool Parser::hasKeyword(const std::string& internalKeywordName) const {
|
||||
return (m_internalParserKeywords.count(internalKeywordName) > 0);
|
||||
}
|
||||
|
||||
|
||||
bool Parser::hasWildCardKeyword(const std::string& keyword) const {
|
||||
return (m_wildCardKeywords.find(keyword) != m_parserKeywords.end());
|
||||
bool Parser::hasWildCardKeyword(const std::string& internalKeywordName) const {
|
||||
return (m_wildCardKeywords.count(internalKeywordName) > 0);
|
||||
}
|
||||
|
||||
|
||||
bool Parser::canParseKeyword( const std::string& keyword) const {
|
||||
if (hasKeyword(keyword))
|
||||
bool Parser::canParseKeyword( const std::string& deckKeywordName) const {
|
||||
if (!ParserKeyword::validDeckName(deckKeywordName))
|
||||
return false;
|
||||
|
||||
if (m_deckParserKeywords.count(deckKeywordName) > 0)
|
||||
return true;
|
||||
else {
|
||||
ParserKeywordConstPtr wildCardKeyword = matchingKeyword( keyword );
|
||||
if (wildCardKeyword)
|
||||
return true;
|
||||
else
|
||||
return false;
|
||||
}
|
||||
|
||||
ParserKeywordConstPtr wildCardKeyword = matchingKeyword( deckKeywordName );
|
||||
return wildCardKeyword?true:false;
|
||||
}
|
||||
|
||||
void Parser::addParserKeyword(ParserKeywordConstPtr parserKeyword) {
|
||||
m_internalParserKeywords[parserKeyword->getName()] = parserKeyword;
|
||||
|
||||
for (auto nameIt = parserKeyword->deckNamesBegin();
|
||||
nameIt != parserKeyword->deckNamesEnd();
|
||||
++nameIt)
|
||||
{
|
||||
m_deckParserKeywords[*nameIt] = parserKeyword;
|
||||
}
|
||||
|
||||
if (parserKeyword->hasMatchRegex())
|
||||
m_wildCardKeywords[parserKeyword->getName()] = parserKeyword;
|
||||
}
|
||||
|
||||
bool Parser::dropParserKeyword(const std::string& parserKeywordName) {
|
||||
// remove from the internal from the internal names
|
||||
bool erase = (m_internalParserKeywords.erase( parserKeywordName ) > 0);
|
||||
|
||||
// remove keyword from the deck names map
|
||||
auto deckParserKeywordIt = m_deckParserKeywords.begin();
|
||||
while (deckParserKeywordIt != m_deckParserKeywords.end()) {
|
||||
if (deckParserKeywordIt->second->getName() == parserKeywordName)
|
||||
// note the post-increment of the iterator. this is required to keep the
|
||||
// iterator valid for while at the same time erasing it...
|
||||
m_deckParserKeywords.erase(deckParserKeywordIt++);
|
||||
else
|
||||
++ deckParserKeywordIt;
|
||||
}
|
||||
|
||||
// remove the keyword from the wildcard list
|
||||
m_wildCardKeywords.erase( parserKeywordName );
|
||||
|
||||
bool Parser::dropKeyword(const std::string& keyword) {
|
||||
bool erase = (m_parserKeywords.erase( keyword ) == 1);
|
||||
m_wildCardKeywords.erase( keyword );
|
||||
|
||||
return erase;
|
||||
}
|
||||
|
||||
|
||||
|
||||
ParserKeywordConstPtr Parser::getKeyword(const std::string& keyword) const {
|
||||
if (hasKeyword(keyword)) {
|
||||
return m_parserKeywords.at(keyword);
|
||||
ParserKeywordConstPtr Parser::getParserKeyword(const std::string& deckKeywordName) const {
|
||||
if (hasKeyword(deckKeywordName)) {
|
||||
return m_deckParserKeywords.at(deckKeywordName);
|
||||
} else {
|
||||
ParserKeywordConstPtr wildCardKeyword = matchingKeyword( keyword );
|
||||
ParserKeywordConstPtr wildCardKeyword = matchingKeyword( deckKeywordName );
|
||||
|
||||
if (wildCardKeyword)
|
||||
return wildCardKeyword;
|
||||
else
|
||||
throw std::invalid_argument("Do not have parser keyword for parsing: " + keyword);
|
||||
throw std::invalid_argument("Do not have parser keyword for parsing: " + deckKeywordName);
|
||||
}
|
||||
}
|
||||
|
||||
std::vector<std::string> Parser::getAllKeywords () const {
|
||||
std::vector<std::string> Parser::getAllParserKeywordNames () const {
|
||||
std::vector<std::string> keywords;
|
||||
for (auto iterator = m_parserKeywords.begin(); iterator != m_parserKeywords.end(); iterator++) {
|
||||
for (auto iterator = m_deckParserKeywords.begin(); iterator != m_deckParserKeywords.end(); iterator++) {
|
||||
keywords.push_back(iterator->first);
|
||||
}
|
||||
for (auto iterator = m_wildCardKeywords.begin(); iterator != m_wildCardKeywords.end(); iterator++) {
|
||||
@ -261,7 +270,7 @@ namespace Opm {
|
||||
std::cout << parserState->rawKeyword->getKeywordName() << std::endl;
|
||||
|
||||
if (canParseKeyword(parserState->rawKeyword->getKeywordName())) {
|
||||
ParserKeywordConstPtr parserKeyword = getKeyword(parserState->rawKeyword->getKeywordName());
|
||||
ParserKeywordConstPtr parserKeyword = getParserKeyword(parserState->rawKeyword->getKeywordName());
|
||||
ParserKeywordActionEnum action = parserKeyword->getAction();
|
||||
if (action == INTERNALIZE) {
|
||||
DeckKeywordPtr deckKeyword = parserKeyword->parse(parserState->rawKeyword);
|
||||
@ -291,7 +300,7 @@ namespace Opm {
|
||||
Json::JsonObject jsonKeyword = jsonKeywords.get_array_item(index);
|
||||
ParserKeywordConstPtr parserKeyword = ParserKeyword::createFromJson(jsonKeyword);
|
||||
|
||||
addKeyword(parserKeyword);
|
||||
addParserKeyword(parserKeyword);
|
||||
}
|
||||
} else
|
||||
throw std::invalid_argument("Input JSON object is not an array");
|
||||
@ -299,7 +308,7 @@ namespace Opm {
|
||||
|
||||
RawKeywordPtr Parser::createRawKeyword(const std::string & keywordString, std::shared_ptr<ParserState> parserState) const {
|
||||
if (canParseKeyword(keywordString)) {
|
||||
ParserKeywordConstPtr parserKeyword = getKeyword( keywordString );
|
||||
ParserKeywordConstPtr parserKeyword = getParserKeyword( keywordString );
|
||||
ParserKeywordActionEnum action = parserKeyword->getAction();
|
||||
|
||||
if (action == THROW_EXCEPTION)
|
||||
@ -390,7 +399,7 @@ namespace Opm {
|
||||
try {
|
||||
Json::JsonObject jsonKeyword(configFile);
|
||||
ParserKeywordConstPtr parserKeyword = ParserKeyword::createFromJson(jsonKeyword);
|
||||
addKeyword(parserKeyword);
|
||||
addParserKeyword(parserKeyword);
|
||||
return true;
|
||||
}
|
||||
catch (...) {
|
||||
@ -432,7 +441,7 @@ namespace Opm {
|
||||
for (size_t index=0; index < deck->size(); ++index) {
|
||||
DeckKeywordPtr deckKeyword = deck->getKeyword( index );
|
||||
if (canParseKeyword( deckKeyword->name())) {
|
||||
ParserKeywordConstPtr parserKeyword = getKeyword( deckKeyword->name() );
|
||||
ParserKeywordConstPtr parserKeyword = getParserKeyword( deckKeyword->name() );
|
||||
if (parserKeyword->hasDimension()) {
|
||||
parserKeyword->applyUnitsToDeck(deck , deckKeyword);
|
||||
}
|
||||
|
||||
@ -51,20 +51,32 @@ namespace Opm {
|
||||
DeckPtr parseStream(std::shared_ptr<std::istream> inputStream, bool strictParsing=true) const;
|
||||
|
||||
/// Method to add ParserKeyword instances, these holding type and size information about the keywords and their data.
|
||||
void addKeyword(ParserKeywordConstPtr parserKeyword);
|
||||
bool dropKeyword(const std::string& keyword);
|
||||
bool canParseKeyword( const std::string& keyword) const;
|
||||
ParserKeywordConstPtr getKeyword(const std::string& keyword) const;
|
||||
std::vector<std::string> getAllKeywords () const;
|
||||
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;
|
||||
|
||||
void loadKeywords(const Json::JsonObject& jsonKeywords);
|
||||
bool loadKeywordFromFile(const boost::filesystem::path& configFile);
|
||||
|
||||
void loadKeywordsFromDirectory(const boost::filesystem::path& directory , bool recursive = true);
|
||||
size_t size() const;
|
||||
void applyUnitsToDeck(DeckPtr deck) const;
|
||||
|
||||
/*!
|
||||
* \brief Returns the approximate number of recognized keywords in decks
|
||||
*
|
||||
* This is an approximate number because regular expresions are disconsidered.
|
||||
*/
|
||||
size_t size() const;
|
||||
|
||||
private:
|
||||
std::map<std::string, ParserKeywordConstPtr> m_parserKeywords;
|
||||
// associative map of the parser internal name and the corresponding ParserKeyword object
|
||||
std::map<std::string, ParserKeywordConstPtr> m_internalParserKeywords;
|
||||
// associative map of deck names and the corresponding ParserKeyword object
|
||||
std::map<std::string, ParserKeywordConstPtr> m_deckParserKeywords;
|
||||
// associative map of the parser internal names and the corresponding
|
||||
// ParserKeyword object for keywords which match a regular expression
|
||||
std::map<std::string, ParserKeywordConstPtr> m_wildCardKeywords;
|
||||
|
||||
bool hasKeyword(const std::string& keyword) const;
|
||||
|
||||
@ -530,12 +530,8 @@ namespace Opm {
|
||||
|
||||
bool ParserKeyword::equal(const ParserKeyword& other) const {
|
||||
// compare the deck names. we don't care about the ordering of the strings.
|
||||
for (auto deckNameIt = m_deckNames.begin(); deckNameIt != m_deckNames.end(); ++deckNameIt)
|
||||
if (!other.m_deckNames.count(*deckNameIt))
|
||||
return false;
|
||||
for (auto deckNameIt = other.m_deckNames.begin(); deckNameIt != other.m_deckNames.end(); ++deckNameIt)
|
||||
if (!m_deckNames.count(*deckNameIt))
|
||||
return false;
|
||||
if (m_deckNames != other.m_deckNames)
|
||||
return false;
|
||||
|
||||
if ((m_name == other.m_name) &&
|
||||
(m_matchRegexString == other.m_matchRegexString) &&
|
||||
|
||||
@ -163,7 +163,7 @@ static void generateSourceForKeyword(std::iostream& of, KeywordElementType keywo
|
||||
of << "{" << std::endl;
|
||||
of << indent << "ParserKeywordPtr ";
|
||||
parserKeyword->inlineNew(of , keywordName , indent);
|
||||
of << indent << "addKeyword( " << keywordName << ");" << std::endl;
|
||||
of << indent << "addParserKeyword( " << keywordName << ");" << std::endl;
|
||||
of << "}" << std::endl << std::endl;
|
||||
|
||||
std::cout << "Creating keyword: " << keywordName << std::endl;
|
||||
|
||||
@ -47,14 +47,14 @@ BOOST_AUTO_TEST_CASE(addKeyword_keyword_doesntfail) {
|
||||
Parser parser;
|
||||
{
|
||||
ParserKeywordPtr equilKeyword = ParserKeyword::createDynamicSized("EQUIL");
|
||||
parser.addKeyword(equilKeyword);
|
||||
parser.addParserKeyword(equilKeyword);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
BOOST_AUTO_TEST_CASE(canParseKeyword_canParseKeyword_returnstrue) {
|
||||
ParserPtr parser(new Parser());
|
||||
parser->addKeyword(ParserKeyword::createDynamicSized("FJAS"));
|
||||
parser->addParserKeyword(ParserKeyword::createDynamicSized("FJAS"));
|
||||
BOOST_CHECK(parser->canParseKeyword("FJAS"));
|
||||
}
|
||||
|
||||
@ -62,30 +62,30 @@ BOOST_AUTO_TEST_CASE(canParseKeyword_canParseKeyword_returnstrue) {
|
||||
BOOST_AUTO_TEST_CASE(getKeyword_haskeyword_returnskeyword) {
|
||||
ParserPtr parser(new Parser());
|
||||
ParserKeywordConstPtr parserKeyword = ParserKeyword::createDynamicSized("FJAS");
|
||||
parser->addKeyword(parserKeyword);
|
||||
BOOST_CHECK_EQUAL(parserKeyword, parser->getKeyword("FJAS"));
|
||||
parser->addParserKeyword(parserKeyword);
|
||||
BOOST_CHECK_EQUAL(parserKeyword, parser->getParserKeyword("FJAS"));
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(getKeyword_hasnotkeyword_getKeywordThrowsException) {
|
||||
ParserPtr parser(new Parser());
|
||||
ParserKeywordConstPtr parserKeyword = ParserKeyword::createDynamicSized("FJAS");
|
||||
parser->addKeyword(parserKeyword);
|
||||
BOOST_CHECK_THROW(parser->getKeyword("FJASS"), std::invalid_argument);
|
||||
parser->addParserKeyword(parserKeyword);
|
||||
BOOST_CHECK_THROW(parser->getParserKeyword("FJASS"), std::invalid_argument);
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(getAllKeywords_hasTwoKeywords_returnsCompleteList) {
|
||||
BOOST_AUTO_TEST_CASE(getAllParserKeywordNames_hasTwoKeywords_returnsCompleteList) {
|
||||
ParserPtr parser(new Parser(false));
|
||||
std::cout << parser->getAllKeywords().size() << std::endl;
|
||||
std::cout << parser->getAllParserKeywordNames().size() << std::endl;
|
||||
ParserKeywordConstPtr firstParserKeyword = ParserKeyword::createDynamicSized("FJAS");
|
||||
parser->addKeyword(firstParserKeyword);
|
||||
parser->addParserKeyword(firstParserKeyword);
|
||||
ParserKeywordConstPtr secondParserKeyword = ParserKeyword::createDynamicSized("SAJF");
|
||||
parser->addKeyword(secondParserKeyword);
|
||||
BOOST_CHECK_EQUAL(2U, parser->getAllKeywords().size());
|
||||
parser->addParserKeyword(secondParserKeyword);
|
||||
BOOST_CHECK_EQUAL(2U, parser->getAllParserKeywordNames().size());
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(getAllKeywords_hasNoKeywords_returnsEmptyList) {
|
||||
BOOST_AUTO_TEST_CASE(getAllParserKeywordNames_hasNoKeywords_returnsEmptyList) {
|
||||
ParserPtr parser(new Parser(false));
|
||||
BOOST_CHECK_EQUAL(0U, parser->getAllKeywords().size());
|
||||
BOOST_CHECK_EQUAL(0U, parser->getAllParserKeywordNames().size());
|
||||
}
|
||||
|
||||
|
||||
@ -93,18 +93,18 @@ BOOST_AUTO_TEST_CASE(getAllKeywords_hasNoKeywords_returnsEmptyList) {
|
||||
/************************ JSON config related tests **********************'*/
|
||||
|
||||
|
||||
BOOST_AUTO_TEST_CASE(addKeywordJSON_canParseKeyword_returnstrue) {
|
||||
BOOST_AUTO_TEST_CASE(addParserKeywordJSON_canParseKeyword_returnstrue) {
|
||||
ParserPtr parser(new Parser());
|
||||
Json::JsonObject jsonConfig("{\"name\": \"BPR\", \"size\" : 100 , \"items\" :[{\"name\":\"ItemX\" , \"size_type\":\"SINGLE\" , \"value_type\" : \"DOUBLE\"}]}");
|
||||
parser->addKeyword(ParserKeyword::createFromJson( jsonConfig ));
|
||||
parser->addParserKeyword(ParserKeyword::createFromJson( jsonConfig ));
|
||||
BOOST_CHECK(parser->canParseKeyword("BPR"));
|
||||
}
|
||||
|
||||
|
||||
BOOST_AUTO_TEST_CASE(addKeywordJSON_size_isObject_allGood) {
|
||||
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->addKeyword(ParserKeyword::createFromJson( jsonConfig ));
|
||||
parser->addParserKeyword(ParserKeyword::createFromJson( jsonConfig ));
|
||||
BOOST_CHECK(parser->canParseKeyword("EQUIXL"));
|
||||
}
|
||||
|
||||
@ -238,27 +238,27 @@ BOOST_AUTO_TEST_CASE(loadConfigFromDirectory_default) {
|
||||
|
||||
BOOST_AUTO_TEST_CASE(DropKeyword) {
|
||||
ParserPtr parser(new Parser());
|
||||
BOOST_CHECK_EQUAL(false , parser->dropKeyword("DoesNotHaveThis"));
|
||||
BOOST_CHECK_EQUAL(false , parser->dropParserKeyword("DoesNotHaveThis"));
|
||||
BOOST_CHECK_EQUAL(true , parser->canParseKeyword("BPR"));
|
||||
BOOST_CHECK_EQUAL(true , parser->dropKeyword("BLOCK_PROBE"));
|
||||
BOOST_CHECK_EQUAL(false , parser->dropKeyword("BLOCK_PROBE"));
|
||||
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(true , parser->canParseKeyword("TVDPX"));
|
||||
BOOST_CHECK_EQUAL(true , parser->dropKeyword("TVDP*"));
|
||||
BOOST_CHECK_EQUAL(true , parser->dropParserKeyword("TVDP"));
|
||||
BOOST_CHECK_EQUAL(false , parser->canParseKeyword("TVDPX"));
|
||||
}
|
||||
|
||||
|
||||
BOOST_AUTO_TEST_CASE(ReplaceKeyword) {
|
||||
ParserPtr parser(new Parser());
|
||||
ParserKeywordConstPtr eqldims = parser->getKeyword("EQLDIMS");
|
||||
ParserKeywordConstPtr eqldims = parser->getParserKeyword("EQLDIMS");
|
||||
|
||||
BOOST_CHECK_EQUAL( 5U , eqldims->numItems());
|
||||
BOOST_CHECK( parser->loadKeywordFromFile( "testdata/parser/EQLDIMS2" ) );
|
||||
|
||||
|
||||
eqldims = parser->getKeyword("EQLDIMS");
|
||||
eqldims = parser->getParserKeyword("EQLDIMS");
|
||||
BOOST_CHECK_EQUAL( 1U , eqldims->numItems());
|
||||
}
|
||||
|
||||
@ -273,9 +273,9 @@ BOOST_AUTO_TEST_CASE(WildCardTest) {
|
||||
|
||||
BOOST_CHECK(!parser->canParseKeyword("TVDP"));
|
||||
|
||||
ParserKeywordConstPtr keyword1 = parser->getKeyword("TVDPA");
|
||||
ParserKeywordConstPtr keyword2 = parser->getKeyword("TVDPBC");
|
||||
ParserKeywordConstPtr keyword3 = parser->getKeyword("TVDPXXX");
|
||||
ParserKeywordConstPtr keyword1 = parser->getParserKeyword("TVDPA");
|
||||
ParserKeywordConstPtr keyword2 = parser->getParserKeyword("TVDPBC");
|
||||
ParserKeywordConstPtr keyword3 = parser->getParserKeyword("TVDPXXX");
|
||||
|
||||
BOOST_CHECK_EQUAL( keyword1 , keyword2 );
|
||||
BOOST_CHECK_EQUAL( keyword1 , keyword3 );
|
||||
|
||||
Loading…
Reference in New Issue
Block a user