Merge pull request #952 from joakim-hove/rawkeyword-refactor

Rawkeyword refactor
This commit is contained in:
Joakim Hove 2019-08-15 16:45:29 +02:00 committed by GitHub
commit 7e3ad77329
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
9 changed files with 148 additions and 138 deletions

View File

@ -74,10 +74,10 @@ namespace Opm {
* \brief Returns whether the parser knows about a keyword
*/
bool hasKeyword( const std::string& ) const;
const ParserKeyword* getKeyword(const std::string& name) const;
const ParserKeyword& getKeyword(const std::string& name) const;
bool isRecognizedKeyword( const string_view& deckKeywordName) const;
const ParserKeyword* getParserKeywordFromDeckName(const string_view& deckKeywordName) const;
const ParserKeyword& getParserKeywordFromDeckName(const string_view& deckKeywordName) const;
std::vector<std::string> getAllDeckNames () const;
void loadKeywords(const Json::JsonObject& jsonKeywords);

View File

@ -21,7 +21,6 @@
#include <iosfwd>
#include <string>
#include <memory>
#include <set>
#include <boost/regex.hpp>
@ -124,7 +123,7 @@ namespace Opm {
SectionNameSet::const_iterator validSectionNamesBegin() const;
SectionNameSet::const_iterator validSectionNamesEnd() const;
DeckKeyword parse(const ParseContext& parseContext, ErrorGuard& errors, std::shared_ptr< RawKeyword > rawKeyword, const std::string& filename) const;
DeckKeyword parse(const ParseContext& parseContext, ErrorGuard& errors, RawKeyword& rawKeyword, const std::string& filename) const;
enum ParserKeywordSizeEnum getSizeType() const;
const KeywordSize& getKeywordSize() const;
bool isDataKeyword() const;

View File

@ -40,8 +40,18 @@ namespace Opm {
class RawKeyword {
public:
RawKeyword(const string_view& name , Raw::KeywordSizeEnum sizeType , const std::string& filename, size_t lineNR);
RawKeyword(const string_view& name , const std::string& filename, size_t lineNR , size_t inputSize , bool isTableCollection = false);
RawKeyword(const string_view& name,
Raw::KeywordSizeEnum sizeType,
const std::string& filename,
size_t lineNR,
bool slash_terminated);
RawKeyword(const string_view& name,
const std::string& filename,
size_t lineNR ,
size_t inputSize,
bool slash_terminated,
bool isTableCollection);
const std::string& getKeywordName() const;
void addRawRecordString( const string_view& );
@ -60,6 +70,7 @@ namespace Opm {
bool unKnownSize() const;
void finalizeUnknownSize();
void terminateRecord();
bool slashTerminatedRecords() const;
const std::string& getFilename() const;
size_t getLineNR() const;
@ -73,7 +84,6 @@ namespace Opm {
iterator end();
bool is_title() const;
bool slash_terminated_records = true;
private:
Raw::KeywordSizeEnum m_sizeType;
bool m_isFinished = false;
@ -82,6 +92,7 @@ namespace Opm {
size_t m_currentNumTables = 0;
std::string m_name;
std::list< RawRecord > m_records;
bool slash_terminated_records;
string_view m_partialRecordString;
size_t m_lineNR;

View File

@ -256,7 +256,6 @@ class ParserState {
boost::filesystem::path rootPath;
public:
std::shared_ptr< RawKeyword > rawKeyword;
ParserKeywordSizeEnum lastSizeType = SLASH_TERMINATED;
std::string lastKeyWord;
@ -442,74 +441,69 @@ void ParserState::addPathAlias( const std::string& alias, const std::string& pat
}
std::shared_ptr<RawKeyword> createRawKeyword(const ParserKeyword* parserKeyword, const std::string& keywordString, ParserState& parserState, const Parser& parser) {
bool slash_terminated_records = parserKeyword->slashTerminatedRecords();
RawKeyword * newRawKeyword(const ParserKeyword& parserKeyword, const std::string& keywordString, ParserState& parserState, const Parser& parser) {
bool slash_terminated_records = parserKeyword.slashTerminatedRecords();
if( parserKeyword->getSizeType() == SLASH_TERMINATED || parserKeyword->getSizeType() == UNKNOWN) {
if( parserKeyword.getSizeType() == SLASH_TERMINATED || parserKeyword.getSizeType() == UNKNOWN) {
const auto rawSizeType = parserKeyword->getSizeType() == SLASH_TERMINATED
const auto rawSizeType = parserKeyword.getSizeType() == SLASH_TERMINATED
? Raw::SLASH_TERMINATED
: Raw::UNKNOWN;
auto raw_keyword = std::make_shared< RawKeyword >( keywordString, rawSizeType,
parserState.current_path().string(),
parserState.line() );
raw_keyword->slash_terminated_records = slash_terminated_records;
return raw_keyword;
return new RawKeyword( keywordString, rawSizeType,
parserState.current_path().string(),
parserState.line(),
slash_terminated_records);
}
if( parserKeyword->hasFixedSize() ) {
auto raw_keyword = std::make_shared< RawKeyword >( keywordString,
parserState.current_path().string(),
parserState.line(),
parserKeyword->getFixedSize(),
parserKeyword->isTableCollection() );
raw_keyword->slash_terminated_records = slash_terminated_records;
return raw_keyword;
}
if( parserKeyword.hasFixedSize() )
return new RawKeyword( keywordString,
parserState.current_path().string(),
parserState.line(),
parserKeyword.getFixedSize(),
slash_terminated_records,
parserKeyword.isTableCollection() );
const auto& keyword_size = parserKeyword->getKeywordSize();
const auto& keyword_size = parserKeyword.getKeywordSize();
const auto& deck = parserState.deck;
if( deck.hasKeyword(keyword_size.keyword ) ) {
const auto& sizeDefinitionKeyword = deck.getKeyword(keyword_size.keyword);
const auto& record = sizeDefinitionKeyword.getRecord(0);
const auto targetSize = record.getItem( keyword_size.item ).get< int >( 0 ) + keyword_size.shift;
auto raw_keyword = std::make_shared< RawKeyword >( keywordString,
parserState.current_path().string(),
parserState.line(),
targetSize,
parserKeyword->isTableCollection() );
raw_keyword->slash_terminated_records = slash_terminated_records;
return raw_keyword;
return new RawKeyword( keywordString,
parserState.current_path().string(),
parserState.line(),
targetSize,
slash_terminated_records,
parserKeyword.isTableCollection() );
}
std::string msg = "Expected the kewyord: " +keyword_size.keyword
+ " to infer the number of records in: " + keywordString;
parserState.parseContext.handleError(ParseContext::PARSE_MISSING_DIMS_KEYWORD , msg, parserState.errors );
const auto* keyword = parser.getKeyword( keyword_size.keyword );
const auto& record = keyword->getRecord(0);
const auto& keyword = parser.getKeyword( keyword_size.keyword );
const auto& record = keyword.getRecord(0);
const auto& int_item = record.get( keyword_size.item);
const auto targetSize = int_item.getDefault< int >( ) + keyword_size.shift;
auto raw_keyword = std::make_shared< RawKeyword >( keywordString,
parserState.current_path().string(),
parserState.line(),
targetSize,
parserKeyword->isTableCollection() );
raw_keyword->slash_terminated_records = slash_terminated_records;
return raw_keyword;
return new RawKeyword( keywordString,
parserState.current_path().string(),
parserState.line(),
targetSize,
slash_terminated_records,
parserKeyword.isTableCollection() );
}
std::shared_ptr< RawKeyword > createRawKeyword( const string_view& kw, ParserState& parserState, const Parser& parser ) {
RawKeyword * newRawKeyword( const string_view& kw, ParserState& parserState, const Parser& parser ) {
auto keywordString = ParserKeyword::getDeckName( kw );
if (parser.isRecognizedKeyword(keywordString)) {
parserState.unknown_keyword = false;
const auto* parserKeyword = parser.getParserKeywordFromDeckName( keywordString.string() );
return createRawKeyword(parserKeyword, keywordString.string(), parserState, parser);
const auto& parserKeyword = parser.getParserKeywordFromDeckName( keywordString.string() );
return newRawKeyword(parserKeyword, keywordString.string(), parserState, parser);
}
if (keywordString.size() > RawConsts::maxKeywordLength) {
@ -519,8 +513,8 @@ std::shared_ptr< RawKeyword > createRawKeyword( const string_view& kw, ParserSta
parserState.parseContext.handleError(ParseContext::PARSE_LONG_KEYWORD, msg, parserState.errors);
parserState.unknown_keyword = false;
const auto* parserKeyword = parser.getParserKeywordFromDeckName( keyword8 );
return createRawKeyword(parserKeyword, keyword8, parserState, parser);
const auto& parserKeyword = parser.getParserKeywordFromDeckName( keyword8 );
return newRawKeyword(parserKeyword, keyword8, parserState, parser);
}
}
@ -537,31 +531,31 @@ std::shared_ptr< RawKeyword > createRawKeyword( const string_view& kw, ParserSta
}
bool tryParseKeyword( ParserState& parserState, const Parser& parser ) {
bool tryParseKeyword( ParserState& parserState, const Parser& parser, std::unique_ptr<RawKeyword>& rawKeyword ) {
if (parserState.nextKeyword.length() > 0) {
parserState.rawKeyword = createRawKeyword( parserState.nextKeyword, parserState, parser );
rawKeyword.reset( newRawKeyword( parserState.nextKeyword, parserState, parser ));
parserState.nextKeyword = emptystr;
}
if (parserState.rawKeyword && parserState.rawKeyword->isFinished())
if (rawKeyword && rawKeyword->isFinished())
return true;
while( !parserState.done() ) {
auto line = parserState.getline();
if( line.empty() && !parserState.rawKeyword ) continue;
if( line.empty() && !parserState.rawKeyword->is_title() ) continue;
if( line.empty() && !rawKeyword ) continue;
if( line.empty() && !rawKeyword->is_title() ) continue;
std::string keywordString;
if( parserState.rawKeyword == NULL ) {
if( !rawKeyword ) {
if( RawKeyword::isKeywordPrefix( line, keywordString ) ) {
parserState.rawKeyword = createRawKeyword( keywordString, parserState, parser );
rawKeyword.reset( newRawKeyword( keywordString, parserState, parser ));
parserState.lastSizeType = SLASH_TERMINATED;
if ( parser.isRecognizedKeyword(line) ) {
const auto* parserKeyword = parser.getParserKeywordFromDeckName( line );
parserState.lastSizeType = parserKeyword->getSizeType();
parserState.lastKeyWord = parserState.rawKeyword->getKeywordName();
const auto& parserKeyword = parser.getParserKeywordFromDeckName( line );
parserState.lastSizeType = parserKeyword.getSizeType();
parserState.lastKeyWord = rawKeyword->getKeywordName();
}
} else {
/* We are looking at some random gibberish?! */
@ -570,7 +564,7 @@ bool tryParseKeyword( ParserState& parserState, const Parser& parser ) {
}
}
} else {
if (parserState.rawKeyword->getSizeType() == Raw::UNKNOWN) {
if (rawKeyword->getSizeType() == Raw::UNKNOWN) {
/*
When we are spinning through a keyword of size type UNKNOWN it
is essential to recognize a string as the next keyword. The
@ -589,32 +583,32 @@ bool tryParseKeyword( ParserState& parserState, const Parser& parser ) {
auto space_pos = line_string.find(' ');
const std::string candidate_name = line_string.substr(0, space_pos);
if( parser.isRecognizedKeyword( candidate_name ) ) {
parserState.rawKeyword->finalizeUnknownSize();
rawKeyword->finalizeUnknownSize();
parserState.nextKeyword = line;
return true;
}
}
if (parserState.rawKeyword->slash_terminated_records)
if (rawKeyword->slashTerminatedRecords())
line = strip_slash(line);
else
line = strip_last_slash(line);
parserState.rawKeyword->addRawRecordString(line);
rawKeyword->addRawRecordString(line);
}
if (parserState.rawKeyword
&& parserState.rawKeyword->isFinished()
&& parserState.rawKeyword->getSizeType() != Raw::UNKNOWN)
if (rawKeyword
&& rawKeyword->isFinished()
&& rawKeyword->getSizeType() != Raw::UNKNOWN)
{
return true;
}
}
if (parserState.rawKeyword
&& parserState.rawKeyword->getSizeType() == Raw::UNKNOWN)
if (rawKeyword
&& rawKeyword->getSizeType() == Raw::UNKNOWN)
{
parserState.rawKeyword->finalizeUnknownSize();
rawKeyword->finalizeUnknownSize();
return true;
}
@ -625,23 +619,22 @@ bool parseState( ParserState& parserState, const Parser& parser ) {
std::string filename = parserState.current_path().string();
while( !parserState.done() ) {
std::unique_ptr<RawKeyword> rawKeyword;
parserState.rawKeyword.reset();
const bool streamOK = tryParseKeyword( parserState, parser );
if( !parserState.rawKeyword && !streamOK )
const bool streamOK = tryParseKeyword( parserState, parser, rawKeyword );
if( !rawKeyword && !streamOK )
continue;
if (parserState.rawKeyword->getKeywordName() == Opm::RawConsts::end)
if (rawKeyword->getKeywordName() == Opm::RawConsts::end)
return true;
if (parserState.rawKeyword->getKeywordName() == Opm::RawConsts::endinclude) {
if (rawKeyword->getKeywordName() == Opm::RawConsts::endinclude) {
parserState.closeFile();
continue;
}
if (parserState.rawKeyword->getKeywordName() == Opm::RawConsts::paths) {
for( const auto& record : *parserState.rawKeyword ) {
if (rawKeyword->getKeywordName() == Opm::RawConsts::paths) {
for( const auto& record : *rawKeyword ) {
std::string pathName = readValueToken<std::string>(record.getItem(0));
std::string pathValue = readValueToken<std::string>(record.getItem(1));
parserState.addPathAlias( pathName, pathValue );
@ -650,8 +643,8 @@ bool parseState( ParserState& parserState, const Parser& parser ) {
continue;
}
if (parserState.rawKeyword->getKeywordName() == Opm::RawConsts::include) {
auto& firstRecord = parserState.rawKeyword->getFirstRecord( );
if (rawKeyword->getKeywordName() == Opm::RawConsts::include) {
auto& firstRecord = rawKeyword->getFirstRecord( );
std::string includeFileAsString = readValueToken<std::string>(firstRecord.getItem(0));
boost::filesystem::path includeFile = parserState.getIncludeFilePath( includeFileAsString );
@ -659,29 +652,28 @@ bool parseState( ParserState& parserState, const Parser& parser ) {
continue;
}
if( parser.isRecognizedKeyword( parserState.rawKeyword->getKeywordName() ) ) {
const auto& kwname = parserState.rawKeyword->getKeywordName();
const auto* parserKeyword = parser.getParserKeywordFromDeckName( kwname );
if( parser.isRecognizedKeyword( rawKeyword->getKeywordName() ) ) {
const auto& kwname = rawKeyword->getKeywordName();
const auto& parserKeyword = parser.getParserKeywordFromDeckName( kwname );
try {
parserState.deck.addKeyword( parserKeyword->parse( parserState.parseContext, parserState.errors, parserState.rawKeyword, filename ) );
parserState.deck.addKeyword( parserKeyword.parse( parserState.parseContext, parserState.errors, *rawKeyword, filename ) );
} catch (const std::exception& exc) {
/*
This catch-all of parsing errors is to be able to write a good
error message; the parser is quite confused at this state and
we should not be tempted to continue the parsing.
*/
const auto& rawKeyword = *parserState.rawKeyword;
std::string msg = "\nFailed to parse keyword: " + rawKeyword.getKeywordName() + "\n" +
"Starting at location: " + filename + "(" + std::to_string(rawKeyword.getLineNR()) + ")\n\n" +
std::string msg = "\nFailed to parse keyword: " + rawKeyword->getKeywordName() + "\n" +
"Starting at location: " + filename + "(" + std::to_string(rawKeyword->getLineNR()) + ")\n\n" +
"Inner exception: " + exc.what() + "\n";
throw std::invalid_argument(msg);
}
} else {
DeckKeyword deckKeyword( parserState.rawKeyword->getKeywordName(), false );
const std::string msg = "The keyword " + parserState.rawKeyword->getKeywordName() + " is not recognized";
DeckKeyword deckKeyword( rawKeyword->getKeywordName(), false );
const std::string msg = "The keyword " + rawKeyword->getKeywordName() + " is not recognized";
deckKeyword.setLocation( filename,
parserState.rawKeyword->getLineNR());
rawKeyword->getLineNR());
parserState.deck.addKeyword( std::move( deckKeyword ) );
OpmLog::warning(Log::fileMessage(parserState.current_path().string(), parserState.line(), msg));
}
@ -862,21 +854,21 @@ bool Parser::hasKeyword( const std::string& name ) const {
!= this->m_deckParserKeywords.end();
}
const ParserKeyword* Parser::getKeyword( const std::string& name ) const {
const ParserKeyword& Parser::getKeyword( const std::string& name ) const {
return getParserKeywordFromDeckName( string_view( name ) );
}
const ParserKeyword* Parser::getParserKeywordFromDeckName(const string_view& name ) const {
const ParserKeyword& Parser::getParserKeywordFromDeckName(const string_view& name ) const {
auto candidate = m_deckParserKeywords.find( name );
if( candidate != m_deckParserKeywords.end() ) return candidate->second;
if( candidate != m_deckParserKeywords.end() ) return *candidate->second;
const auto* wildCardKeyword = matchingKeyword( name );
if ( !wildCardKeyword )
throw std::invalid_argument( "Do not have parser keyword for parsing: " + name );
return wildCardKeyword;
return *wildCardKeyword;
}
std::vector<std::string> Parser::getAllDeckNames () const {
@ -951,10 +943,10 @@ std::vector<std::string> Parser::getAllDeckNames () const {
if( !isRecognizedKeyword( deckKeyword.name() ) ) continue;
const auto* parserKeyword = getParserKeywordFromDeckName( deckKeyword.name() );
if( !parserKeyword->hasDimension() ) continue;
const auto& parserKeyword = getParserKeywordFromDeckName( deckKeyword.name() );
if( !parserKeyword.hasDimension() ) continue;
parserKeyword->applyUnitsToDeck(deck , deckKeyword);
parserKeyword.applyUnitsToDeck(deck , deckKeyword);
}
}
@ -998,7 +990,7 @@ std::vector<std::string> Parser::getAllDeckNames () const {
continue;
const auto& parserKeyword = parser.getParserKeywordFromDeckName( curKeywordName );
if (ensureKeywordSectionAffiliation && !parserKeyword->isValidSection(curSectionName)) {
if (ensureKeywordSectionAffiliation && !parserKeyword.isValidSection(curSectionName)) {
std::string msg =
"The keyword '"+curKeywordName+"' is located in the '"+curSectionName
+"' section where it is invalid";

View File

@ -469,21 +469,21 @@ void set_dimensions( ParserItem& item,
DeckKeyword ParserKeyword::parse(const ParseContext& parseContext,
ErrorGuard& errors,
std::shared_ptr< RawKeyword > rawKeyword,
RawKeyword& rawKeyword,
const std::string& filename) const {
if( !rawKeyword->isFinished() )
throw std::invalid_argument("Tried to create a deck keyword from an incomplete raw keyword " + rawKeyword->getKeywordName());
if( !rawKeyword.isFinished() )
throw std::invalid_argument("Tried to create a deck keyword from an incomplete raw keyword " + rawKeyword.getKeywordName());
DeckKeyword keyword( rawKeyword->getKeywordName() );
keyword.setLocation( rawKeyword->getFilename(), rawKeyword->getLineNR() );
DeckKeyword keyword( rawKeyword.getKeywordName() );
keyword.setLocation( rawKeyword.getFilename(), rawKeyword.getLineNR() );
keyword.setDataKeyword( isDataKeyword() );
size_t record_nr = 0;
for( auto& rawRecord : *rawKeyword ) {
for( auto& rawRecord : rawKeyword ) {
if( m_records.size() == 0 && rawRecord.size() > 0 )
throw std::invalid_argument("Missing item information " + rawKeyword->getKeywordName());
throw std::invalid_argument("Missing item information " + rawKeyword.getKeywordName());
keyword.addRecord( getRecord( record_nr ).parse( parseContext, errors, rawRecord, rawKeyword->getKeywordName(), filename ) );
keyword.addRecord( getRecord( record_nr ).parse( parseContext, errors, rawRecord, rawKeyword.getKeywordName(), filename ) );
record_nr++;
}

View File

@ -29,7 +29,8 @@ namespace Opm {
static const std::string emptystr = "";
RawKeyword::RawKeyword(const string_view& name, Raw::KeywordSizeEnum sizeType , const std::string& filename, size_t lineNR) :
RawKeyword::RawKeyword(const string_view& name, Raw::KeywordSizeEnum sizeType , const std::string& filename, size_t lineNR, bool slash_terminated) :
slash_terminated_records(slash_terminated),
m_partialRecordString( emptystr )
{
if (sizeType == Raw::SLASH_TERMINATED || sizeType == Raw::UNKNOWN) {
@ -39,7 +40,9 @@ namespace Opm {
throw std::invalid_argument("Error - invalid sizetype on input");
}
RawKeyword::RawKeyword(const string_view& name , const std::string& filename, size_t lineNR , size_t inputSize, bool isTableCollection ) {
RawKeyword::RawKeyword(const string_view& name , const std::string& filename, size_t lineNR , size_t inputSize, bool slash_terminated, bool isTableCollection ) :
slash_terminated_records(slash_terminated)
{
commonInit(name.string(),filename,lineNR);
if (isTableCollection) {
m_sizeType = Raw::TABLE_COLLECTION;
@ -206,5 +209,10 @@ namespace Opm {
Raw::KeywordSizeEnum RawKeyword::getSizeType() const {
return m_sizeType;
}
bool RawKeyword::slashTerminatedRecords() const {
return this->slash_terminated_records;
}
}

View File

@ -92,7 +92,7 @@ BOOST_AUTO_TEST_CASE(canParseDeckKeyword_returnstrue) {
BOOST_AUTO_TEST_CASE(getKeyword_haskeyword_returnskeyword) {
Parser parser;
parser.addParserKeyword( createDynamicSized( "FJAS" ) );
BOOST_CHECK_EQUAL("FJAS", parser.getParserKeywordFromDeckName("FJAS")->getName());
BOOST_CHECK_EQUAL("FJAS", parser.getParserKeywordFromDeckName("FJAS").getName());
}
BOOST_AUTO_TEST_CASE(getKeyword_hasnotkeyword_getKeywordThrowsException) {
@ -271,8 +271,8 @@ BOOST_AUTO_TEST_CASE(ReplaceKeyword) {
Parser parser;
BOOST_CHECK( parser.loadKeywordFromFile( prefix() + "parser/EQLDIMS2" ) );
const auto* eqldims = parser.getParserKeywordFromDeckName("EQLDIMS");
const auto& record = eqldims->getRecord(0);
const auto& eqldims = parser.getParserKeywordFromDeckName("EQLDIMS");
const auto& record = eqldims.getRecord(0);
BOOST_CHECK(record.hasItem("NEW"));
}
@ -286,9 +286,9 @@ BOOST_AUTO_TEST_CASE(WildCardTest) {
BOOST_CHECK(!parser.isRecognizedKeyword("TVDP"));
const auto* keyword1 = parser.getParserKeywordFromDeckName("TVDPA");
const auto* keyword2 = parser.getParserKeywordFromDeckName("TVDPBC");
const auto* keyword3 = parser.getParserKeywordFromDeckName("TVDPXXX");
const auto& keyword1 = parser.getParserKeywordFromDeckName("TVDPA");
const auto& keyword2 = parser.getParserKeywordFromDeckName("TVDPBC");
const auto& keyword3 = parser.getParserKeywordFromDeckName("TVDPXXX");
BOOST_CHECK_EQUAL( keyword1 , keyword2 );
BOOST_CHECK_EQUAL( keyword1 , keyword3 );
@ -1612,12 +1612,12 @@ BOOST_AUTO_TEST_CASE(ParseEmptyRecord) {
const auto& tabdimsKeyword = createFixedSized("TEST" , 1);
ParserRecord record;
ParserItem item("ITEM", INT);
auto rawkeyword = std::make_shared< RawKeyword >( tabdimsKeyword->getName() , "FILE" , 10U , 1 );
RawKeyword rawkeyword( tabdimsKeyword->getName() , "FILE" , 10U , 1 , true, false);
ParseContext parseContext;
ErrorGuard errors;
BOOST_CHECK_EQUAL( Raw::FIXED , rawkeyword->getSizeType());
rawkeyword->addRawRecordString("/");
BOOST_CHECK_EQUAL( Raw::FIXED , rawkeyword.getSizeType());
rawkeyword.addRawRecordString("/");
record.addItem(item);
tabdimsKeyword->addRecord( record );

View File

@ -30,24 +30,24 @@
using namespace Opm;
BOOST_AUTO_TEST_CASE(RawKeywordGiveKeywordToConstructorKeywordSet) {
RawKeyword keyword("KEYYWORD", Raw::SLASH_TERMINATED , "FILE" , 10U);
RawKeyword keyword("KEYYWORD", Raw::SLASH_TERMINATED , "FILE" , 10U, true);
BOOST_CHECK(keyword.getKeywordName() == "KEYYWORD");
BOOST_CHECK_EQUAL(Raw::SLASH_TERMINATED , keyword.getSizeType());
}
BOOST_AUTO_TEST_CASE(RawKeywordSizeTypeInvalidThrows) {
BOOST_CHECK_THROW( RawKeyword("KEYYWORD", Raw::FIXED , "FILE" , 0U) , std::invalid_argument);
BOOST_CHECK_THROW( RawKeyword("KEYYWORD", Raw::TABLE_COLLECTION , "FILE" , 10U) , std::invalid_argument);
BOOST_CHECK_THROW( RawKeyword("KEYYWORD", Raw::FIXED , "FILE" , 0U, true) , std::invalid_argument);
BOOST_CHECK_THROW( RawKeyword("KEYYWORD", Raw::TABLE_COLLECTION , "FILE" , 10U, true) , std::invalid_argument);
}
BOOST_AUTO_TEST_CASE(RawKeywordFinalizeWrongSizeTYpeThrows) {
RawKeyword kw("KEYYWORD", Raw::SLASH_TERMINATED , "FILE" , 0U);
RawKeyword kw("KEYYWORD", Raw::SLASH_TERMINATED , "FILE" , 0U, true);
BOOST_CHECK_THROW( kw.finalizeUnknownSize() , std::invalid_argument );
}
BOOST_AUTO_TEST_CASE(RawKeywordFinalizeUnknownSize) {
RawKeyword kw("KEYYWORD", Raw::UNKNOWN , "FILE" , 0U);
RawKeyword kw("KEYYWORD", Raw::UNKNOWN , "FILE" , 0U, true);
BOOST_CHECK( !kw.isFinished() );
kw.finalizeUnknownSize();
BOOST_CHECK( kw.isFinished() );
@ -57,34 +57,34 @@ BOOST_AUTO_TEST_CASE(RawKeywordFinalizeUnknownSize) {
BOOST_AUTO_TEST_CASE(RawKeywordGiveKeywordToConstructorTooLongThrows) {
BOOST_CHECK_THROW(RawKeyword keyword("KEYYYWORD", Raw::SLASH_TERMINATED , "FILE" , 10U), std::invalid_argument);
BOOST_CHECK_THROW(RawKeyword keyword("KEYYYWORD", Raw::SLASH_TERMINATED , "FILE" , 10U, true), std::invalid_argument);
}
BOOST_AUTO_TEST_CASE(RawKeywordSetKeywordInitialWhitespaceInKeywordThrows) {
BOOST_CHECK_THROW(RawKeyword(" TELONG", Raw::SLASH_TERMINATED, "FILE" , 10U), std::invalid_argument);
BOOST_CHECK_THROW(RawKeyword(" TELONG", Raw::SLASH_TERMINATED, "FILE" , 10U, true), std::invalid_argument);
}
BOOST_AUTO_TEST_CASE(constructor_mixedCaseName_throws) {
BOOST_CHECK_NO_THROW(RawKeyword("Test", Raw::SLASH_TERMINATED , "FILE" , 10U));
BOOST_CHECK_NO_THROW(RawKeyword("Test", Raw::SLASH_TERMINATED , "FILE" , 10U, true));
}
BOOST_AUTO_TEST_CASE(RawKeywordSetKeywordInitialTabInKeywordThrows) {
BOOST_CHECK_THROW( RawKeyword("\tTELONG", Raw::SLASH_TERMINATED , "FILE" , 10U), std::invalid_argument);
BOOST_CHECK_THROW( RawKeyword("\tTELONG", Raw::SLASH_TERMINATED , "FILE" , 10U, true), std::invalid_argument);
}
BOOST_AUTO_TEST_CASE(RawKeywordSetCorrectLenghtKeywordNoError) {
RawKeyword keyword("GOODONE", Raw::SLASH_TERMINATED , "FILE" , 10U);
RawKeyword keyword("GOODONE", Raw::SLASH_TERMINATED , "FILE" , 10U, true);
BOOST_CHECK(keyword.getKeywordName() == "GOODONE");
}
BOOST_AUTO_TEST_CASE(RawKeywordSet8CharKeywordWithTrailingWhitespaceKeywordTrimmed) {
RawKeyword keyword("GOODONEE ", Raw::SLASH_TERMINATED , "FILE" , 10U);
RawKeyword keyword("GOODONEE ", Raw::SLASH_TERMINATED , "FILE" , 10U, true);
BOOST_CHECK(keyword.getKeywordName() == "GOODONEE");
}
BOOST_AUTO_TEST_CASE(addRecord_singleRecord_recordAdded) {
RawKeyword keyword("TEST", Raw::SLASH_TERMINATED , "FILE" , 10U);
RawKeyword keyword("TEST", Raw::SLASH_TERMINATED , "FILE" , 10U, true);
keyword.addRawRecordString("test 1 3 4 /");
BOOST_CHECK_EQUAL(1U, keyword.size());
}
@ -107,7 +107,7 @@ BOOST_AUTO_TEST_CASE(isFinished_undef_size) {
string_view finalizer1( inputstr + ln2, inputstr + ln3 );
string_view finalizer2( inputstr + ln3 , inputstr + ln4 );
RawKeyword keyword("TEST", Raw::SLASH_TERMINATED , "FILE" , 10U);
RawKeyword keyword("TEST", Raw::SLASH_TERMINATED , "FILE" , 10U, true);
BOOST_CHECK( !keyword.isFinished() );
keyword.addRawRecordString( incomplete1 );
@ -122,13 +122,13 @@ BOOST_AUTO_TEST_CASE(isFinished_undef_size) {
BOOST_AUTO_TEST_CASE(isFinished_Fixedsize0) {
RawKeyword keyword("TEST" , "FILE" , 10U , 0U);
RawKeyword keyword("TEST" , "FILE" , 10U , 0U, true, false);
BOOST_CHECK( keyword.isFinished() );
}
BOOST_AUTO_TEST_CASE(isFinished_Fixedsize1) {
RawKeyword keyword("TEST" , "FILE" , 10U, 1U);
RawKeyword keyword("TEST" , "FILE" , 10U, 1U, true, false);
BOOST_CHECK( !keyword.isFinished() );
keyword.addRawRecordString("test 1 3 4 /");
BOOST_CHECK( keyword.isFinished() );
@ -136,7 +136,7 @@ BOOST_AUTO_TEST_CASE(isFinished_Fixedsize1) {
BOOST_AUTO_TEST_CASE(isFinished_FixedsizeMulti) {
RawKeyword keyword("TEST", "FILE" , 10U , 4U);
RawKeyword keyword("TEST", "FILE" , 10U , 4U, true, false);
const char* inputstr = "test 1 2 3 4 //1 2 3 3 4 1 2 3 3 4 /1 2 3 3 /";
const size_t ln1 = std::strlen( "test 1 2 3 4 /" );
@ -167,27 +167,27 @@ BOOST_AUTO_TEST_CASE(isFinished_FixedsizeMulti) {
}
BOOST_AUTO_TEST_CASE(isTableCollection) {
RawKeyword keyword1("TEST" , "FILE" , 10U, 4U , false);
RawKeyword keyword2("TEST2", Raw::SLASH_TERMINATED , "FILE" , 10U);
RawKeyword keyword1("TEST" , "FILE" , 10U, 4U ,true, false);
RawKeyword keyword2("TEST2", Raw::SLASH_TERMINATED , "FILE" , 10U, true);
BOOST_CHECK_EQUAL( Raw::FIXED , keyword1.getSizeType());
BOOST_CHECK_EQUAL( Raw::SLASH_TERMINATED , keyword2.getSizeType());
}
BOOST_AUTO_TEST_CASE(CreateTableCollection) {
RawKeyword keyword1("TEST" , "FILE" , 10U, 2, true);
RawKeyword keyword1("TEST" , "FILE" , 10U, 2, true, true);
BOOST_CHECK_EQUAL( Raw::TABLE_COLLECTION , keyword1.getSizeType());
}
BOOST_AUTO_TEST_CASE(CreateWithFileAndLine) {
RawKeyword keyword1("TEST" , Raw::SLASH_TERMINATED , "XXX", 100);
RawKeyword keyword1("TEST" , Raw::SLASH_TERMINATED , "XXX", 100, true);
BOOST_CHECK_EQUAL( "XXX" , keyword1.getFilename());
BOOST_CHECK_EQUAL( 100U , keyword1.getLineNR() );
}
BOOST_AUTO_TEST_CASE(isUnknownSize) {
RawKeyword keyword("TEST2", Raw::UNKNOWN , "FILE" , 10U);
RawKeyword keyword("TEST2", Raw::UNKNOWN , "FILE" , 10U, true);
BOOST_CHECK_EQUAL( Raw::UNKNOWN , keyword.getSizeType( ));
}

View File

@ -231,8 +231,8 @@ BOOST_AUTO_TEST_CASE(parse_truncatedrecords_deckFilledWithDefaults) {
BOOST_CHECK(lastItem_1.defaultApplied(0));
BOOST_CHECK_EQUAL(lastItem_1.get< int >(0), 1);
auto* parserKeyword = parser.getParserKeywordFromDeckName("RADFIN4");
const auto& parserRecord = parserKeyword->getRecord(0);
const auto& parserKeyword = parser.getParserKeywordFromDeckName("RADFIN4");
const auto& parserRecord = parserKeyword.getRecord(0);
const auto& intItem = parserRecord.get("NWMAX");
BOOST_CHECK_EQUAL(18, radfin4_0_full.getRecord(0).getItem(10).get< int >(0));