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

Combine test files, reduce number of targets

Browse Source 
In an effort to reduce the numbers of targets built, and consequently
the repeated work and overhead of compiling boost test, a series of
test programs are combined to larger modules.

Every target typically has a constant cost of 3-6s, depending on the
computer, just for the make to set up dependencies and for the compiler
to parse and compile the testing framework and other dependencies. Each
set of tests typically add very little, so significant savings are
achieved by merging targets.

When tested on a 2015 i5m laptop, this reduced serial, single-core
compile time from ~14m45s to ~11m15s.
This commit is contained in:
Jørgen Kvalsvik
2017-05-24 14:48:27 +02:00
parent e884b0664c
commit 477fa5a988
65 changed files with 4292 additions and 6027 deletions
Download Patch File Download Diff File Expand all files Collapse all files

85
tests/parser/BoxManagerTests.cpp
View File

@@ -1,85 +0,0 @@
/*
Copyright 2014 Statoil ASA.
This file is part of the Open Porous Media project (OPM).
OPM is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OPM is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with OPM. If not, see <http://www.gnu.org/licenses/>.
*/
#include <stdexcept>
#include <iostream>
#include <memory>
#include <boost/filesystem.hpp>
#define BOOST_TEST_MODULE BoxManagerTests
#include <boost/test/unit_test.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/Box.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/BoxManager.hpp>
BOOST_AUTO_TEST_CASE(CreateBoxManager) {
Opm::BoxManager boxManager(10,10,10);
Opm::Box box(10,10,10);
BOOST_CHECK( box.equal( boxManager.getGlobalBox()) );
BOOST_CHECK( box.equal( boxManager.getActiveBox()) );
BOOST_CHECK( !boxManager.getInputBox() );
BOOST_CHECK( !boxManager.getKeywordBox() );
}
BOOST_AUTO_TEST_CASE(TestInputBox) {
Opm::BoxManager boxManager(10,10,10);
Opm::Box inputBox( boxManager.getGlobalBox(), 0,4,0,4,0,4);
boxManager.setInputBox( 0,4,0,4,0,4 );
BOOST_CHECK( inputBox.equal( boxManager.getInputBox()) );
BOOST_CHECK( inputBox.equal( boxManager.getActiveBox()) );
boxManager.endSection();
BOOST_CHECK( !boxManager.getInputBox() );
BOOST_CHECK( boxManager.getActiveBox().equal( boxManager.getGlobalBox()));
}
BOOST_AUTO_TEST_CASE(TestKeywordBox) {
Opm::BoxManager boxManager(10,10,10);
Opm::Box inputBox( boxManager.getGlobalBox() , 0,4,0,4,0,4);
Opm::Box keywordBox( boxManager.getGlobalBox() , 0,2,0,2,0,2);
boxManager.setInputBox( 0,4,0,4,0,4 );
boxManager.setKeywordBox( 0,2,0,2,0,2 );
BOOST_CHECK( inputBox.equal( boxManager.getInputBox()) );
BOOST_CHECK( keywordBox.equal( boxManager.getKeywordBox()) );
BOOST_CHECK( keywordBox.equal( boxManager.getActiveBox()) );
// Must end keyword first
BOOST_CHECK_THROW( boxManager.endSection() , std::invalid_argument );
boxManager.endKeyword();
BOOST_CHECK( inputBox.equal( boxManager.getActiveBox()) );
BOOST_CHECK( !boxManager.getKeywordBox() );
boxManager.endSection();
BOOST_CHECK( !boxManager.getInputBox() );
BOOST_CHECK( boxManager.getActiveBox().equal( boxManager.getGlobalBox()));
}

75
tests/parser/BoxTests.cpp
View File

@@ -28,6 +28,7 @@
#include <boost/date_time/posix_time/posix_time.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/Box.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/BoxManager.hpp>
BOOST_AUTO_TEST_CASE(CreateBox) {
BOOST_CHECK_THROW( new Opm::Box(-1,0,0) , std::invalid_argument);
@@ -53,7 +54,7 @@ BOOST_AUTO_TEST_CASE(CreateBox) {
for (i=0; i < box.getDim(0); i++) {
size_t g = i + j*box.getDim(0) + k*box.getDim(0)*box.getDim(1);
BOOST_CHECK_EQUAL( indexList[g] , g);
}
}
}
@@ -83,19 +84,17 @@ BOOST_AUTO_TEST_CASE(CreateSubBox) {
BOOST_CHECK( !subBox2.isGlobal());
BOOST_CHECK_EQUAL( 60U , subBox2.size() );
{
size_t i,j,k;
size_t d = 0;
const std::vector<size_t>& indexList = subBox2.getIndexList();
size_t i,j,k;
size_t d = 0;
const std::vector<size_t>& indexList = subBox2.getIndexList();
for (k=0; k < subBox2.getDim(2); k++) {
for (j=0; j < subBox2.getDim(1); j++) {
for (i=0; i < subBox2.getDim(0); i++) {
for (k=0; k < subBox2.getDim(2); k++) {
for (j=0; j < subBox2.getDim(1); j++) {
for (i=0; i < subBox2.getDim(0); i++) {
size_t g = (i + 1) + (j + 1)*globalBox.getDim(0) + (k + 1)*globalBox.getDim(0)*globalBox.getDim(1);
BOOST_CHECK_EQUAL( indexList[d] , g);
d++;
}
size_t g = (i + 1) + (j + 1)*globalBox.getDim(0) + (k + 1)*globalBox.getDim(0)*globalBox.getDim(1);
BOOST_CHECK_EQUAL( indexList[d] , g);
d++;
}
}
}
@@ -120,4 +119,56 @@ BOOST_AUTO_TEST_CASE(BoxEqual) {
BOOST_CHECK( !subBox4.equal( subBox5 ));
}
BOOST_AUTO_TEST_CASE(CreateBoxManager) {
Opm::BoxManager boxManager(10,10,10);
Opm::Box box(10,10,10);
BOOST_CHECK( box.equal( boxManager.getGlobalBox()) );
BOOST_CHECK( box.equal( boxManager.getActiveBox()) );
BOOST_CHECK( !boxManager.getInputBox() );
BOOST_CHECK( !boxManager.getKeywordBox() );
}
BOOST_AUTO_TEST_CASE(TestInputBox) {
Opm::BoxManager boxManager(10,10,10);
Opm::Box inputBox( boxManager.getGlobalBox(), 0,4,0,4,0,4);
boxManager.setInputBox( 0,4,0,4,0,4 );
BOOST_CHECK( inputBox.equal( boxManager.getInputBox()) );
BOOST_CHECK( inputBox.equal( boxManager.getActiveBox()) );
boxManager.endSection();
BOOST_CHECK( !boxManager.getInputBox() );
BOOST_CHECK( boxManager.getActiveBox().equal( boxManager.getGlobalBox()));
}
BOOST_AUTO_TEST_CASE(TestKeywordBox) {
Opm::BoxManager boxManager(10,10,10);
Opm::Box inputBox( boxManager.getGlobalBox() , 0,4,0,4,0,4);
Opm::Box keywordBox( boxManager.getGlobalBox() , 0,2,0,2,0,2);
boxManager.setInputBox( 0,4,0,4,0,4 );
boxManager.setKeywordBox( 0,2,0,2,0,2 );
BOOST_CHECK( inputBox.equal( boxManager.getInputBox()) );
BOOST_CHECK( keywordBox.equal( boxManager.getKeywordBox()) );
BOOST_CHECK( keywordBox.equal( boxManager.getActiveBox()) );
// Must end keyword first
BOOST_CHECK_THROW( boxManager.endSection() , std::invalid_argument );
boxManager.endKeyword();
BOOST_CHECK( inputBox.equal( boxManager.getActiveBox()) );
BOOST_CHECK( !boxManager.getKeywordBox() );
boxManager.endSection();
BOOST_CHECK( !boxManager.getInputBox() );
BOOST_CHECK( boxManager.getActiveBox().equal( boxManager.getGlobalBox()));
}

83
tests/parser/CompletionTests.cpp
View File

@@ -33,8 +33,23 @@
#include <opm/parser/eclipse/Deck/DeckKeyword.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Completion.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/CompletionSet.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/ScheduleEnums.hpp>
namespace Opm {
inline std::ostream& operator<<( std::ostream& stream, const Completion& c ) {
return stream << "(" << c.getI() << "," << c.getJ() << "," << c.getK() << ")";
}
inline std::ostream& operator<<( std::ostream& stream, const CompletionSet& cs ) {
stream << "{ ";
for( const auto& c : cs ) stream << c << " ";
return stream << "}";
}
}
BOOST_AUTO_TEST_CASE(CreateCompletionOK) {
@@ -69,6 +84,74 @@ BOOST_AUTO_TEST_CASE(CompletionTestssameCoordinate) {
BOOST_CHECK_EQUAL( false , completion1.sameCoordinate( completion5 ));
}
BOOST_AUTO_TEST_CASE(CreateCompletionSetOK) {
Opm::CompletionSet completionSet;
BOOST_CHECK_EQUAL( 0U , completionSet.size() );
}
BOOST_AUTO_TEST_CASE(AddCompletionSizeCorrect) {
Opm::CompletionSet completionSet;
Opm::Completion completion1( 10,10,10, 1, 0.0,Opm::WellCompletion::OPEN , Opm::Value<double>("ConnectionTransmissibilityFactor",99.88), Opm::Value<double>("D",22.33), Opm::Value<double>("SKIN",33.22), 0);
Opm::Completion completion2( 11,10,10, 1, 0.0,Opm::WellCompletion::OPEN , Opm::Value<double>("ConnectionTransmissibilityFactor",99.88), Opm::Value<double>("D",22.33), Opm::Value<double>("SKIN",33.22), 0);
completionSet.add( completion1 );
BOOST_CHECK_EQUAL( 1U , completionSet.size() );
completionSet.add( completion2 );
BOOST_CHECK_EQUAL( 2U , completionSet.size() );
BOOST_CHECK_EQUAL( completion1 , completionSet.get(0) );
}
BOOST_AUTO_TEST_CASE(CompletionSetGetOutOfRangeThrows) {
Opm::CompletionSet completionSet;
Opm::Completion completion1( 10,10,10,1, 0.0,Opm::WellCompletion::OPEN , Opm::Value<double>("ConnectionTransmissibilityFactor",99.88), Opm::Value<double>("D",22.33), Opm::Value<double>("SKIN",33.22), 0);
Opm::Completion completion2( 11,10,10,1, 0.0,Opm::WellCompletion::OPEN , Opm::Value<double>("ConnectionTransmissibilityFactor",99.88), Opm::Value<double>("D",22.33), Opm::Value<double>("SKIN",33.22), 0);
completionSet.add( completion1 );
BOOST_CHECK_EQUAL( 1U , completionSet.size() );
completionSet.add( completion2 );
BOOST_CHECK_EQUAL( 2U , completionSet.size() );
BOOST_CHECK_THROW( completionSet.get(10) , std::out_of_range );
}
BOOST_AUTO_TEST_CASE(AddCompletionSameCellUpdates) {
Opm::CompletionSet completionSet;
Opm::Completion completion1( 10,10,10, 1, 0.0, Opm::WellCompletion::OPEN , Opm::Value<double>("ConnectionTransmissibilityFactor",99.88), Opm::Value<double>("D",22.33), Opm::Value<double>("SKIN",33.22), 0);
Opm::Completion completion2( 10,10,10, 1, 0.0,Opm::WellCompletion::SHUT , Opm::Value<double>("ConnectionTransmissibilityFactor",99.88), Opm::Value<double>("D",22.33), Opm::Value<double>("SKIN",33.22), 0);
completionSet.add( completion1 );
BOOST_CHECK_EQUAL( 1U , completionSet.size() );
completionSet.add( completion2 );
BOOST_CHECK_EQUAL( 1U , completionSet.size() );
}
BOOST_AUTO_TEST_CASE(AddCompletionCopy) {
Opm::CompletionSet completionSet;
Opm::Completion completion1( 10,10,10, 1, 0.0, Opm::WellCompletion::OPEN , Opm::Value<double>("ConnectionTransmissibilityFactor",99.88), Opm::Value<double>("D",22.33), Opm::Value<double>("SKIN",33.22), 0);
Opm::Completion completion2( 10,10,11, 1, 0.0, Opm::WellCompletion::SHUT , Opm::Value<double>("ConnectionTransmissibilityFactor",99.88), Opm::Value<double>("D",22.33), Opm::Value<double>("SKIN",33.22), 0);
Opm::Completion completion3( 10,10,12, 1, 0.0, Opm::WellCompletion::SHUT , Opm::Value<double>("ConnectionTransmissibilityFactor",99.88), Opm::Value<double>("D",22.33), Opm::Value<double>("SKIN",33.22), 0);
completionSet.add( completion1 );
completionSet.add( completion2 );
completionSet.add( completion3 );
BOOST_CHECK_EQUAL( 3U , completionSet.size() );
auto copy = completionSet;
BOOST_CHECK_EQUAL( 3U , copy.size() );
BOOST_CHECK_EQUAL( completion1 , copy.get(0));
BOOST_CHECK_EQUAL( completion2 , copy.get(1));
BOOST_CHECK_EQUAL( completion3 , copy.get(2));
}

164
tests/parser/DeckDoubleItemTests.cpp
View File

@@ -1,164 +0,0 @@
/*
Copyright 2013 Statoil ASA.
This file is part of the Open Porous Media project (OPM).
OPM is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OPM is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with OPM. If not, see <http://www.gnu.org/licenses/>.
*/
#define BOOST_TEST_MODULE DeckItemTests
#include <boost/test/unit_test.hpp>
#include <stdexcept>
#include <opm/parser/eclipse/Deck/DeckItem.hpp>
#include <opm/parser/eclipse/Units/Dimension.hpp>
using namespace Opm;
BOOST_AUTO_TEST_CASE(InitializeDouble) {
BOOST_REQUIRE_NO_THROW( DeckItem( "HEI", double() ) );
}
BOOST_AUTO_TEST_CASE(GetDoubleAtIndex_NoData_ExceptionThrown) {
DeckItem deckDoubleItem( "TEST", double() );
BOOST_CHECK_THROW(deckDoubleItem.get< double >(0), std::out_of_range);
deckDoubleItem.push_back(1.89);
BOOST_CHECK_THROW(deckDoubleItem.get< double >(1), std::out_of_range);
}
BOOST_AUTO_TEST_CASE(sizeDouble_correct) {
DeckItem deckDoubleItem( "TEST", double() );
BOOST_CHECK_EQUAL( 0U , deckDoubleItem.size());
deckDoubleItem.push_back( 100.0 );
BOOST_CHECK_EQUAL( 1U , deckDoubleItem.size());
deckDoubleItem.push_back( 100.0 );
deckDoubleItem.push_back( 100.0 );
BOOST_CHECK_EQUAL( 3U , deckDoubleItem.size());
}
BOOST_AUTO_TEST_CASE(SetInDeck) {
DeckItem deckDoubleItem( "TEST", double() );
BOOST_CHECK( deckDoubleItem.size() == 0 );
deckDoubleItem.push_backDefault( 1.0 );
BOOST_CHECK( deckDoubleItem.size() == 1 );
BOOST_CHECK_EQUAL( true , deckDoubleItem.defaultApplied(0) );
deckDoubleItem.push_back( 10.0 );
BOOST_CHECK( deckDoubleItem.size() == 2 );
BOOST_CHECK_EQUAL( false , deckDoubleItem.defaultApplied(1) );
deckDoubleItem.push_backDefault( 1.0 );
BOOST_CHECK( deckDoubleItem.size() == 3 );
BOOST_CHECK_EQUAL( true , deckDoubleItem.defaultApplied(2) );
}
BOOST_AUTO_TEST_CASE(DummyDefaults) {
DeckItem deckDoubleItem( "TEST", double() );
BOOST_CHECK_EQUAL(deckDoubleItem.size(), 0);
deckDoubleItem.push_backDummyDefault();
BOOST_CHECK_EQUAL(deckDoubleItem.size(), 0);
BOOST_CHECK_EQUAL(true, deckDoubleItem.defaultApplied(0));
BOOST_CHECK_THROW(deckDoubleItem.get< double >(0), std::out_of_range);
}
BOOST_AUTO_TEST_CASE(PushBackMultiple) {
DeckItem item( "HEI", double() );
item.push_back(10.22 , 100 );
BOOST_CHECK_EQUAL( 100U , item.size() );
for (size_t i=0; i < 100; i++)
BOOST_CHECK_EQUAL(10.22 , item.get< double >(i));
}
BOOST_AUTO_TEST_CASE(PushBackDimension) {
DeckItem item( "HEI", double() );
Dimension activeDimension{ "Length" , 100 };
Dimension defaultDimension{ "Length" , 10 };
item.push_back(1.234);
item.push_backDimension( activeDimension , defaultDimension);
item.push_backDefault(5.678);
item.push_backDimension( activeDimension , defaultDimension);
}
BOOST_AUTO_TEST_CASE(PushBackDimensionInvalidType) {
DeckItem item( "HEI", int() );
Dimension dim{ "Length" , 100 };
BOOST_CHECK_THROW( item.push_backDimension( dim , dim ) , std::logic_error );
}
BOOST_AUTO_TEST_CASE(GetSIWithoutDimensionThrows) {
DeckItem item( "HEI", double() );
item.push_back(10.22 , 100 );
BOOST_CHECK_THROW( item.getSIDouble(0) , std::invalid_argument );
BOOST_CHECK_THROW( item.getSIDoubleData() , std::invalid_argument );
}
BOOST_AUTO_TEST_CASE(GetSISingleDimensionCorrect) {
DeckItem item( "HEI", double() );
Dimension dim{ "Length" , 100 };
item.push_back(1.0 , 100 );
item.push_backDimension( dim , dim );
BOOST_CHECK_EQUAL( 1.0 , item.get< double >(0) );
BOOST_CHECK_EQUAL( 100 , item.getSIDouble(0) );
}
BOOST_AUTO_TEST_CASE(GetSISingleDefault) {
DeckItem item( "HEI", double() );
Dimension dim{ "Length" , 1 };
Dimension defaultDim{ "Length" , 100 };
item.push_backDefault( 1.0 );
item.push_backDimension( dim , defaultDim );
BOOST_CHECK_EQUAL( 1 , item.get< double >(0) );
BOOST_CHECK_EQUAL( 100 , item.getSIDouble(0) );
}
BOOST_AUTO_TEST_CASE(GetSIMultipleDim) {
DeckItem item( "HEI", double() );
Dimension dim1{ "Length" , 2 };
Dimension dim2{ "Length" , 4 };
Dimension dim3{ "Length" , 8 };
Dimension dim4{ "Length" ,16 };
Dimension defaultDim{ "Length" , 100 };
item.push_back( 1.0, 16 );
item.push_backDimension( dim1 , defaultDim );
item.push_backDimension( dim2 , defaultDim );
item.push_backDimension( dim3 , defaultDim );
item.push_backDimension( dim4 , defaultDim );
for (size_t i=0; i < 16; i+= 4) {
BOOST_CHECK_EQUAL( 2 , item.getSIDouble(i) );
BOOST_CHECK_EQUAL( 4 , item.getSIDouble(i+ 1) );
BOOST_CHECK_EQUAL( 8 , item.getSIDouble(i+2) );
BOOST_CHECK_EQUAL(16 , item.getSIDouble(i+3) );
}
}

125
tests/parser/DeckIntItemTests.cpp
View File

@@ -1,125 +0,0 @@
/*
Copyright 2013 Statoil ASA.
This file is part of the Open Porous Media project (OPM).
OPM is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OPM is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with OPM. If not, see <http://www.gnu.org/licenses/>.
*/
#define BOOST_TEST_MODULE DeckItemTests
#include <boost/test/unit_test.hpp>
#include <stdexcept>
#include <opm/parser/eclipse/Deck/DeckItem.hpp>
using namespace Opm;
BOOST_AUTO_TEST_CASE(Initialize) {
BOOST_REQUIRE_NO_THROW( DeckItem m( "TEST", int() ) );
}
BOOST_AUTO_TEST_CASE(HasValue) {
DeckItem deckIntItem( "TEST", int() );
BOOST_CHECK_EQUAL( false , deckIntItem.hasValue(0) );
deckIntItem.push_back(1);
BOOST_CHECK_EQUAL( true , deckIntItem.hasValue(0) );
BOOST_CHECK_EQUAL( false , deckIntItem.hasValue(1) );
}
BOOST_AUTO_TEST_CASE(DummyDefaults) {
DeckItem deckIntItem( "TEST", int() );
BOOST_CHECK_EQUAL(deckIntItem.size(), 0);
deckIntItem.push_backDummyDefault();
BOOST_CHECK_EQUAL(deckIntItem.size(), 0);
BOOST_CHECK_EQUAL(true, deckIntItem.defaultApplied(0));
BOOST_CHECK_EQUAL( false , deckIntItem.hasValue(0));
BOOST_CHECK_EQUAL( false , deckIntItem.hasValue(1));
BOOST_CHECK_THROW(deckIntItem.get< int >(0), std::out_of_range);
}
BOOST_AUTO_TEST_CASE(GetIntAtIndex_NoData_ExceptionThrown) {
DeckItem deckIntItem( "TEST", int() );
deckIntItem.push_back(100);
BOOST_CHECK(deckIntItem.get< int >(0) == 100);
BOOST_CHECK_THROW(deckIntItem.get< int >(1), std::out_of_range);
}
BOOST_AUTO_TEST_CASE(InitializeDefaultApplied) {
DeckItem deckIntItem( "TEST", int() );
BOOST_CHECK( deckIntItem.size() == 0 );
}
BOOST_AUTO_TEST_CASE(size_correct) {
DeckItem deckIntItem( "TEST", int() );
BOOST_CHECK_EQUAL( 0U , deckIntItem.size());
deckIntItem.push_back( 100 );
BOOST_CHECK_EQUAL( 1U , deckIntItem.size());
deckIntItem.push_back( 100 );
deckIntItem.push_back( 100 );
BOOST_CHECK_EQUAL( 3U , deckIntItem.size());
}
BOOST_AUTO_TEST_CASE(DefaultNotApplied) {
DeckItem deckIntItem( "TEST", int() );
BOOST_CHECK( deckIntItem.size() == 0 );
deckIntItem.push_back( 100 );
BOOST_CHECK( deckIntItem.size() == 1 );
BOOST_CHECK( deckIntItem.get< int >(0) == 100 );
BOOST_CHECK( !deckIntItem.defaultApplied(0) );
BOOST_CHECK_THROW( deckIntItem.defaultApplied(1), std::out_of_range );
BOOST_CHECK_THROW( deckIntItem.get< int >(1), std::out_of_range );
}
BOOST_AUTO_TEST_CASE(UseDefault) {
DeckItem deckIntItem( "TEST", int() );
deckIntItem.push_backDefault( 100 );
BOOST_CHECK( deckIntItem.defaultApplied(0) );
BOOST_CHECK( deckIntItem.get< int >(0) == 100 );
BOOST_CHECK_THROW( deckIntItem.defaultApplied(1), std::out_of_range );
BOOST_CHECK_THROW( deckIntItem.get< int >(1), std::out_of_range );
}
BOOST_AUTO_TEST_CASE(DefaultApplied) {
DeckItem deckIntItem( "TEST", int() );
BOOST_CHECK( deckIntItem.size() == 0 );
deckIntItem.push_backDefault( 100 );
BOOST_CHECK( deckIntItem.size() == 1 );
BOOST_CHECK( deckIntItem.get< int >(0) == 100 );
BOOST_CHECK( deckIntItem.defaultApplied(0) );
deckIntItem.push_back( 10 );
BOOST_CHECK_EQUAL( false, deckIntItem.defaultApplied(1) );
deckIntItem.push_backDefault( 1 );
BOOST_CHECK_EQUAL( true , deckIntItem.defaultApplied(2) );
BOOST_CHECK_EQUAL( 3 , deckIntItem.size() );
}
BOOST_AUTO_TEST_CASE(PushBackMultiple) {
DeckItem item( "HEI", int() );
item.push_back(10 , 100U );
BOOST_CHECK_EQUAL( 100U , item.size() );
for (size_t i=0; i < 100; i++)
BOOST_CHECK_EQUAL(10 , item.get< int >(i));
}

82
tests/parser/DeckKeywordTests.cpp
View File

@@ -1,82 +0,0 @@
/*
Copyright 2013 Statoil ASA.
This file is part of the Open Porous Media project (OPM).
OPM is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OPM is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with OPM. If not, see <http://www.gnu.org/licenses/>.
*/
#include <stdexcept>
#define BOOST_TEST_MODULE DeckKeywordTests
#include <boost/test/unit_test.hpp>
#include <opm/parser/eclipse/Deck/DeckKeyword.hpp>
#include <opm/parser/eclipse/Deck/DeckRecord.hpp>
#include <opm/parser/eclipse/Deck/DeckItem.hpp>
using namespace Opm;
BOOST_AUTO_TEST_CASE(Initialize) {
DeckKeyword deckKeyword1("KW");
}
BOOST_AUTO_TEST_CASE(DataKeyword) {
DeckKeyword kw("KW");
BOOST_CHECK_EQUAL( false , kw.isDataKeyword());
kw.setDataKeyword( );
BOOST_CHECK_EQUAL( true , kw.isDataKeyword());
kw.setDataKeyword( false );
BOOST_CHECK_EQUAL( false , kw.isDataKeyword());
kw.setDataKeyword( true );
BOOST_CHECK_EQUAL( true , kw.isDataKeyword());
}
BOOST_AUTO_TEST_CASE(name_nameSetInConstructor_nameReturned) {
DeckKeyword deckKeyword( "KW" );
BOOST_CHECK_EQUAL("KW", deckKeyword.name());
}
BOOST_AUTO_TEST_CASE(size_noRecords_returnszero) {
DeckKeyword deckKeyword( "KW" );
BOOST_CHECK_EQUAL(0U, deckKeyword.size());
}
BOOST_AUTO_TEST_CASE(addRecord_onerecord_recordadded) {
DeckKeyword deckKeyword( "KW" );
deckKeyword.addRecord( DeckRecord() );
BOOST_CHECK_EQUAL(1U, deckKeyword.size());
for (auto iter = deckKeyword.begin(); iter != deckKeyword.end(); ++iter) {
//
}
}
BOOST_AUTO_TEST_CASE(getRecord_outofrange_exceptionthrown) {
DeckKeyword deckKeyword( "KW" );
deckKeyword.addRecord(DeckRecord());
BOOST_CHECK_THROW(deckKeyword.getRecord(1), std::out_of_range);
}
BOOST_AUTO_TEST_CASE(setUnknown_wasknown_nowunknown) {
DeckKeyword deckKeyword( "KW", false );
BOOST_CHECK(!deckKeyword.isKnown());
}

102
tests/parser/DeckRecordTests.cpp
View File

@@ -1,102 +0,0 @@
/*
Copyright 2013 Statoil ASA.
This file is part of the Open Porous Media project (OPM).
OPM is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OPM is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with OPM. If not, see <http://www.gnu.org/licenses/>.
*/
#define BOOST_TEST_MODULE DeckRecordTests
#include <stdexcept>
#include <boost/test/unit_test.hpp>
#include <opm/parser/eclipse/Deck/DeckRecord.hpp>
#include <opm/parser/eclipse/Deck/DeckItem.hpp>
#include <opm/parser/eclipse/Parser/ParseContext.hpp>
#include <opm/parser/eclipse/Parser/ParserRecord.hpp>
#include <opm/parser/eclipse/RawDeck/RawRecord.hpp>
#include <boost/test/test_tools.hpp>
using namespace Opm;
BOOST_AUTO_TEST_CASE(Initialize) {
BOOST_CHECK_NO_THROW(DeckRecord deckRecord);
}
BOOST_AUTO_TEST_CASE(size_defaultConstructor_sizezero) {
DeckRecord deckRecord;
BOOST_CHECK_EQUAL(0U, deckRecord.size());
}
BOOST_AUTO_TEST_CASE(addItem_singleItem_sizeone) {
DeckRecord deckRecord;
deckRecord.addItem( DeckItem { "TEST", int() } );
BOOST_CHECK_EQUAL(1U, deckRecord.size());
}
BOOST_AUTO_TEST_CASE(addItem_multipleItems_sizecorrect) {
DeckRecord deckRecord;
deckRecord.addItem( DeckItem { "TEST", int() } );
deckRecord.addItem( DeckItem { "TEST2", int() } );
deckRecord.addItem( DeckItem { "TEST3", int() } );
BOOST_CHECK_EQUAL(3U, deckRecord.size());
}
BOOST_AUTO_TEST_CASE(addItem_differentItemsSameName_throws) {
DeckRecord deckRecord;
deckRecord.addItem( DeckItem { "TEST", int() } );
BOOST_CHECK_THROW( deckRecord.addItem( DeckItem { "TEST", int() } ), std::invalid_argument );
std::vector< DeckItem > items = { DeckItem { "TEST", int() }, DeckItem { "TEST" , int() } };
BOOST_CHECK_THROW( DeckRecord( std::move( items ) ), std::invalid_argument );
}
BOOST_AUTO_TEST_CASE(get_byIndex_returnsItem) {
DeckRecord deckRecord;
deckRecord.addItem( DeckItem { "TEST", int() } );
BOOST_CHECK_NO_THROW(deckRecord.getItem(0U));
}
BOOST_AUTO_TEST_CASE(get_indexoutofbounds_throws) {
DeckRecord deckRecord;
deckRecord.addItem( DeckItem { "TEST", int() } );
BOOST_CHECK_THROW(deckRecord.getItem(1), std::out_of_range);
}
BOOST_AUTO_TEST_CASE(get_byName_returnsItem) {
DeckRecord deckRecord;
deckRecord.addItem( DeckItem { "TEST", int() } );
deckRecord.getItem("TEST");
}
BOOST_AUTO_TEST_CASE(get_byNameNonExisting_throws) {
DeckRecord deckRecord;
deckRecord.addItem( DeckItem { "TEST", int() } );
BOOST_CHECK_THROW(deckRecord.getItem("INVALID"), std::invalid_argument);
}
BOOST_AUTO_TEST_CASE(StringsWithSpaceOK) {
ParserItem itemString("STRINGITEM1", "" );
ParserRecord record1;
RawRecord rawRecord( " ' VALUE ' " );
ParseContext parseContext;
MessageContainer msgContainer;
record1.addItem( itemString );
const auto deckRecord = record1.parse( parseContext , msgContainer, rawRecord );
BOOST_CHECK_EQUAL(" VALUE " , deckRecord.getItem(0).get< std::string >(0));
}

91
tests/parser/DeckStringItemTests.cpp
View File

@@ -1,91 +0,0 @@
/*
Copyright 2013 Statoil ASA.
This file is part of the Open Porous Media project (OPM).
OPM is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OPM is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with OPM. If not, see <http://www.gnu.org/licenses/>.
*/
#include <stdexcept>
#define BOOST_TEST_MODULE DeckStringItemTests
#include <boost/test/unit_test.hpp>
#include <opm/parser/eclipse/Deck/DeckItem.hpp>
using namespace Opm;
BOOST_AUTO_TEST_CASE(InitializeString) {
DeckItem stringItem("TEST", std::string() );
BOOST_CHECK_EQUAL("TEST", stringItem.name());
}
BOOST_AUTO_TEST_CASE(DummyDefaults) {
DeckItem deckStringItem("TEST", std::string() );
BOOST_CHECK_EQUAL(deckStringItem.size(), 0);
deckStringItem.push_backDummyDefault();
BOOST_CHECK_EQUAL(deckStringItem.size(), 0);
BOOST_CHECK_EQUAL(true, deckStringItem.defaultApplied(0));
BOOST_CHECK_THROW(deckStringItem.get< std::string >(0), std::out_of_range);
}
BOOST_AUTO_TEST_CASE(GetStringAtIndex_NoData_ExceptionThrown) {
DeckItem deckStringItem( "TEST", std::string() );
BOOST_CHECK_THROW(deckStringItem.get< std::string >(0), std::out_of_range);
deckStringItem.push_back("SA");
BOOST_CHECK_THROW(deckStringItem.get< std::string >(1), std::out_of_range);
}
BOOST_AUTO_TEST_CASE(size_variouspushes_sizecorrect) {
DeckItem deckStringItem( "TEST", std::string() );
BOOST_CHECK_EQUAL(0U, deckStringItem.size());
deckStringItem.push_back("WELL-3");
BOOST_CHECK_EQUAL(1U, deckStringItem.size());
deckStringItem.push_back("WELL-4");
deckStringItem.push_back("WELL-5");
BOOST_CHECK_EQUAL(3U, deckStringItem.size());
}
BOOST_AUTO_TEST_CASE(DefaultNotApplied) {
DeckItem deckStringItem( "TEST", std::string() );
BOOST_CHECK( deckStringItem.size() == 0 );
deckStringItem.push_back( "FOO") ;
BOOST_CHECK( deckStringItem.size() == 1 );
BOOST_CHECK( deckStringItem.get< std::string >(0) == "FOO" );
BOOST_CHECK( !deckStringItem.defaultApplied(0) );
}
BOOST_AUTO_TEST_CASE(DefaultApplied) {
DeckItem deckStringItem( "TEST", std::string() );
BOOST_CHECK( deckStringItem.size() == 0 );
deckStringItem.push_backDefault( "FOO" );
BOOST_CHECK( deckStringItem.size() == 1 );
BOOST_CHECK( deckStringItem.get< std::string >(0) == "FOO" );
BOOST_CHECK( deckStringItem.defaultApplied(0) );
}
BOOST_AUTO_TEST_CASE(PushBackMultiple) {
DeckItem stringItem( "TEST", std::string() );
stringItem.push_back("Heisann ", 100U );
BOOST_CHECK_EQUAL( 100U , stringItem.size() );
for (size_t i=0; i < 100; i++)
BOOST_CHECK_EQUAL("Heisann " , stringItem.get< std::string >(i));
}

398
tests/parser/DeckTests.cpp
View File

@@ -26,13 +26,13 @@
#include <opm/parser/eclipse/Deck/Deck.hpp>
#include <opm/parser/eclipse/Deck/DeckKeyword.hpp>
#include <opm/parser/eclipse/Parser/ParseContext.hpp>
#include <opm/parser/eclipse/Parser/ParserItem.hpp>
#include <opm/parser/eclipse/Parser/ParserRecord.hpp>
#include <opm/parser/eclipse/RawDeck/RawRecord.hpp>
using namespace Opm;
BOOST_AUTO_TEST_CASE(Initialize) {
BOOST_REQUIRE_NO_THROW(Deck deck);
}
BOOST_AUTO_TEST_CASE(Initializer_lists) {
DeckKeyword foo( "foo" );
DeckKeyword bar( "bar" );
@@ -169,3 +169,393 @@ BOOST_AUTO_TEST_CASE(set_and_get_data_file) {
BOOST_CHECK_EQUAL(file, deck.getDataFile());
}
BOOST_AUTO_TEST_CASE(DummyDefaultsString) {
DeckItem deckStringItem("TEST", std::string() );
BOOST_CHECK_EQUAL(deckStringItem.size(), 0);
deckStringItem.push_backDummyDefault();
BOOST_CHECK_EQUAL(deckStringItem.size(), 0);
BOOST_CHECK_EQUAL(true, deckStringItem.defaultApplied(0));
BOOST_CHECK_THROW(deckStringItem.get< std::string >(0), std::out_of_range);
}
BOOST_AUTO_TEST_CASE(GetStringAtIndex_NoData_ExceptionThrown) {
DeckItem deckStringItem( "TEST", std::string() );
BOOST_CHECK_THROW(deckStringItem.get< std::string >(0), std::out_of_range);
deckStringItem.push_back("SA");
BOOST_CHECK_THROW(deckStringItem.get< std::string >(1), std::out_of_range);
}
BOOST_AUTO_TEST_CASE(size_variouspushes_sizecorrect) {
DeckItem deckStringItem( "TEST", std::string() );
BOOST_CHECK_EQUAL(0U, deckStringItem.size());
deckStringItem.push_back("WELL-3");
BOOST_CHECK_EQUAL(1U, deckStringItem.size());
deckStringItem.push_back("WELL-4");
deckStringItem.push_back("WELL-5");
BOOST_CHECK_EQUAL(3U, deckStringItem.size());
}
BOOST_AUTO_TEST_CASE(DefaultNotAppliedString) {
DeckItem deckStringItem( "TEST", std::string() );
BOOST_CHECK( deckStringItem.size() == 0 );
deckStringItem.push_back( "FOO") ;
BOOST_CHECK( deckStringItem.size() == 1 );
BOOST_CHECK( deckStringItem.get< std::string >(0) == "FOO" );
BOOST_CHECK( !deckStringItem.defaultApplied(0) );
}
BOOST_AUTO_TEST_CASE(DefaultAppliedString) {
DeckItem deckStringItem( "TEST", std::string() );
BOOST_CHECK( deckStringItem.size() == 0 );
deckStringItem.push_backDefault( "FOO" );
BOOST_CHECK( deckStringItem.size() == 1 );
BOOST_CHECK( deckStringItem.get< std::string >(0) == "FOO" );
BOOST_CHECK( deckStringItem.defaultApplied(0) );
}
BOOST_AUTO_TEST_CASE(PushBackMultipleString) {
DeckItem stringItem( "TEST", std::string() );
stringItem.push_back("Heisann ", 100U );
BOOST_CHECK_EQUAL( 100U , stringItem.size() );
for (size_t i=0; i < 100; i++)
BOOST_CHECK_EQUAL("Heisann " , stringItem.get< std::string >(i));
}
BOOST_AUTO_TEST_CASE(GetDoubleAtIndex_NoData_ExceptionThrown) {
DeckItem deckDoubleItem( "TEST", double() );
BOOST_CHECK_THROW(deckDoubleItem.get< double >(0), std::out_of_range);
deckDoubleItem.push_back(1.89);
BOOST_CHECK_THROW(deckDoubleItem.get< double >(1), std::out_of_range);
}
BOOST_AUTO_TEST_CASE(sizeDouble_correct) {
DeckItem deckDoubleItem( "TEST", double() );
BOOST_CHECK_EQUAL( 0U , deckDoubleItem.size());
deckDoubleItem.push_back( 100.0 );
BOOST_CHECK_EQUAL( 1U , deckDoubleItem.size());
deckDoubleItem.push_back( 100.0 );
deckDoubleItem.push_back( 100.0 );
BOOST_CHECK_EQUAL( 3U , deckDoubleItem.size());
}
BOOST_AUTO_TEST_CASE(SetInDeck) {
DeckItem deckDoubleItem( "TEST", double() );
BOOST_CHECK( deckDoubleItem.size() == 0 );
deckDoubleItem.push_backDefault( 1.0 );
BOOST_CHECK( deckDoubleItem.size() == 1 );
BOOST_CHECK_EQUAL( true , deckDoubleItem.defaultApplied(0) );
deckDoubleItem.push_back( 10.0 );
BOOST_CHECK( deckDoubleItem.size() == 2 );
BOOST_CHECK_EQUAL( false , deckDoubleItem.defaultApplied(1) );
deckDoubleItem.push_backDefault( 1.0 );
BOOST_CHECK( deckDoubleItem.size() == 3 );
BOOST_CHECK_EQUAL( true , deckDoubleItem.defaultApplied(2) );
}
BOOST_AUTO_TEST_CASE(DummyDefaultsDouble) {
DeckItem deckDoubleItem( "TEST", double() );
BOOST_CHECK_EQUAL(deckDoubleItem.size(), 0);
deckDoubleItem.push_backDummyDefault();
BOOST_CHECK_EQUAL(deckDoubleItem.size(), 0);
BOOST_CHECK_EQUAL(true, deckDoubleItem.defaultApplied(0));
BOOST_CHECK_THROW(deckDoubleItem.get< double >(0), std::out_of_range);
}
BOOST_AUTO_TEST_CASE(PushBackMultipleDouble) {
DeckItem item( "HEI", double() );
item.push_back(10.22 , 100 );
BOOST_CHECK_EQUAL( 100U , item.size() );
for (size_t i=0; i < 100; i++)
BOOST_CHECK_EQUAL(10.22 , item.get< double >(i));
}
BOOST_AUTO_TEST_CASE(PushBackDimension) {
DeckItem item( "HEI", double() );
Dimension activeDimension{ "Length" , 100 };
Dimension defaultDimension{ "Length" , 10 };
item.push_back(1.234);
item.push_backDimension( activeDimension , defaultDimension);
item.push_backDefault(5.678);
item.push_backDimension( activeDimension , defaultDimension);
}
BOOST_AUTO_TEST_CASE(PushBackDimensionInvalidType) {
DeckItem item( "HEI", int() );
Dimension dim{ "Length" , 100 };
BOOST_CHECK_THROW( item.push_backDimension( dim , dim ) , std::logic_error );
}
BOOST_AUTO_TEST_CASE(GetSIWithoutDimensionThrows) {
DeckItem item( "HEI", double() );
item.push_back(10.22 , 100 );
BOOST_CHECK_THROW( item.getSIDouble(0) , std::invalid_argument );
BOOST_CHECK_THROW( item.getSIDoubleData() , std::invalid_argument );
}
BOOST_AUTO_TEST_CASE(GetSISingleDimensionCorrect) {
DeckItem item( "HEI", double() );
Dimension dim{ "Length" , 100 };
item.push_back(1.0 , 100 );
item.push_backDimension( dim , dim );
BOOST_CHECK_EQUAL( 1.0 , item.get< double >(0) );
BOOST_CHECK_EQUAL( 100 , item.getSIDouble(0) );
}
BOOST_AUTO_TEST_CASE(GetSISingleDefault) {
DeckItem item( "HEI", double() );
Dimension dim{ "Length" , 1 };
Dimension defaultDim{ "Length" , 100 };
item.push_backDefault( 1.0 );
item.push_backDimension( dim , defaultDim );
BOOST_CHECK_EQUAL( 1 , item.get< double >(0) );
BOOST_CHECK_EQUAL( 100 , item.getSIDouble(0) );
}
BOOST_AUTO_TEST_CASE(GetSIMultipleDim) {
DeckItem item( "HEI", double() );
Dimension dim1{ "Length" , 2 };
Dimension dim2{ "Length" , 4 };
Dimension dim3{ "Length" , 8 };
Dimension dim4{ "Length" ,16 };
Dimension defaultDim{ "Length" , 100 };
item.push_back( 1.0, 16 );
item.push_backDimension( dim1 , defaultDim );
item.push_backDimension( dim2 , defaultDim );
item.push_backDimension( dim3 , defaultDim );
item.push_backDimension( dim4 , defaultDim );
for (size_t i=0; i < 16; i+= 4) {
BOOST_CHECK_EQUAL( 2 , item.getSIDouble(i) );
BOOST_CHECK_EQUAL( 4 , item.getSIDouble(i+ 1) );
BOOST_CHECK_EQUAL( 8 , item.getSIDouble(i+2) );
BOOST_CHECK_EQUAL(16 , item.getSIDouble(i+3) );
}
}
BOOST_AUTO_TEST_CASE(HasValue) {
DeckItem deckIntItem( "TEST", int() );
BOOST_CHECK_EQUAL( false , deckIntItem.hasValue(0) );
deckIntItem.push_back(1);
BOOST_CHECK_EQUAL( true , deckIntItem.hasValue(0) );
BOOST_CHECK_EQUAL( false , deckIntItem.hasValue(1) );
}
BOOST_AUTO_TEST_CASE(DummyDefaultsInt) {
DeckItem deckIntItem( "TEST", int() );
BOOST_CHECK_EQUAL(deckIntItem.size(), 0);
deckIntItem.push_backDummyDefault();
BOOST_CHECK_EQUAL(deckIntItem.size(), 0);
BOOST_CHECK_EQUAL(true, deckIntItem.defaultApplied(0));
BOOST_CHECK_EQUAL( false , deckIntItem.hasValue(0));
BOOST_CHECK_EQUAL( false , deckIntItem.hasValue(1));
BOOST_CHECK_THROW(deckIntItem.get< int >(0), std::out_of_range);
}
BOOST_AUTO_TEST_CASE(GetIntAtIndex_NoData_ExceptionThrown) {
DeckItem deckIntItem( "TEST", int() );
deckIntItem.push_back(100);
BOOST_CHECK(deckIntItem.get< int >(0) == 100);
BOOST_CHECK_THROW(deckIntItem.get< int >(1), std::out_of_range);
}
BOOST_AUTO_TEST_CASE(InitializeDefaultApplied) {
DeckItem deckIntItem( "TEST", int() );
BOOST_CHECK( deckIntItem.size() == 0 );
}
BOOST_AUTO_TEST_CASE(size_correct) {
DeckItem deckIntItem( "TEST", int() );
BOOST_CHECK_EQUAL( 0U , deckIntItem.size());
deckIntItem.push_back( 100 );
BOOST_CHECK_EQUAL( 1U , deckIntItem.size());
deckIntItem.push_back( 100 );
deckIntItem.push_back( 100 );
BOOST_CHECK_EQUAL( 3U , deckIntItem.size());
}
BOOST_AUTO_TEST_CASE(DefaultNotAppliedInt) {
DeckItem deckIntItem( "TEST", int() );
BOOST_CHECK( deckIntItem.size() == 0 );
deckIntItem.push_back( 100 );
BOOST_CHECK( deckIntItem.size() == 1 );
BOOST_CHECK( deckIntItem.get< int >(0) == 100 );
BOOST_CHECK( !deckIntItem.defaultApplied(0) );
BOOST_CHECK_THROW( deckIntItem.defaultApplied(1), std::out_of_range );
BOOST_CHECK_THROW( deckIntItem.get< int >(1), std::out_of_range );
}
BOOST_AUTO_TEST_CASE(UseDefault) {
DeckItem deckIntItem( "TEST", int() );
deckIntItem.push_backDefault( 100 );
BOOST_CHECK( deckIntItem.defaultApplied(0) );
BOOST_CHECK( deckIntItem.get< int >(0) == 100 );
BOOST_CHECK_THROW( deckIntItem.defaultApplied(1), std::out_of_range );
BOOST_CHECK_THROW( deckIntItem.get< int >(1), std::out_of_range );
}
BOOST_AUTO_TEST_CASE(DefaultAppliedInt) {
DeckItem deckIntItem( "TEST", int() );
BOOST_CHECK( deckIntItem.size() == 0 );
deckIntItem.push_backDefault( 100 );
BOOST_CHECK( deckIntItem.size() == 1 );
BOOST_CHECK( deckIntItem.get< int >(0) == 100 );
BOOST_CHECK( deckIntItem.defaultApplied(0) );
deckIntItem.push_back( 10 );
BOOST_CHECK_EQUAL( false, deckIntItem.defaultApplied(1) );
deckIntItem.push_backDefault( 1 );
BOOST_CHECK_EQUAL( true , deckIntItem.defaultApplied(2) );
BOOST_CHECK_EQUAL( 3 , deckIntItem.size() );
}
BOOST_AUTO_TEST_CASE(PushBackMultipleInt) {
DeckItem item( "HEI", int() );
item.push_back(10 , 100U );
BOOST_CHECK_EQUAL( 100U , item.size() );
for (size_t i=0; i < 100; i++)
BOOST_CHECK_EQUAL(10 , item.get< int >(i));
}
BOOST_AUTO_TEST_CASE(size_defaultConstructor_sizezero) {
DeckRecord deckRecord;
BOOST_CHECK_EQUAL(0U, deckRecord.size());
}
BOOST_AUTO_TEST_CASE(addItem_singleItem_sizeone) {
DeckRecord deckRecord;
deckRecord.addItem( DeckItem { "TEST", int() } );
BOOST_CHECK_EQUAL(1U, deckRecord.size());
}
BOOST_AUTO_TEST_CASE(addItem_multipleItems_sizecorrect) {
DeckRecord deckRecord;
deckRecord.addItem( DeckItem { "TEST", int() } );
deckRecord.addItem( DeckItem { "TEST2", int() } );
deckRecord.addItem( DeckItem { "TEST3", int() } );
BOOST_CHECK_EQUAL(3U, deckRecord.size());
}
BOOST_AUTO_TEST_CASE(addItem_differentItemsSameName_throws) {
DeckRecord deckRecord;
deckRecord.addItem( DeckItem { "TEST", int() } );
BOOST_CHECK_THROW( deckRecord.addItem( DeckItem { "TEST", int() } ), std::invalid_argument );
std::vector< DeckItem > items = { DeckItem { "TEST", int() }, DeckItem { "TEST" , int() } };
BOOST_CHECK_THROW( DeckRecord( std::move( items ) ), std::invalid_argument );
}
BOOST_AUTO_TEST_CASE(get_byIndex_returnsItem) {
DeckRecord deckRecord;
deckRecord.addItem( DeckItem { "TEST", int() } );
BOOST_CHECK_NO_THROW(deckRecord.getItem(0U));
}
BOOST_AUTO_TEST_CASE(get_indexoutofbounds_throws) {
DeckRecord deckRecord;
deckRecord.addItem( DeckItem { "TEST", int() } );
BOOST_CHECK_THROW(deckRecord.getItem(1), std::out_of_range);
}
BOOST_AUTO_TEST_CASE(get_byName_returnsItem) {
DeckRecord deckRecord;
deckRecord.addItem( DeckItem { "TEST", int() } );
deckRecord.getItem("TEST");
}
BOOST_AUTO_TEST_CASE(get_byNameNonExisting_throws) {
DeckRecord deckRecord;
deckRecord.addItem( DeckItem { "TEST", int() } );
BOOST_CHECK_THROW(deckRecord.getItem("INVALID"), std::invalid_argument);
}
BOOST_AUTO_TEST_CASE(StringsWithSpaceOK) {
ParserItem itemString("STRINGITEM1", "" );
ParserRecord record1;
RawRecord rawRecord( " ' VALUE ' " );
ParseContext parseContext;
MessageContainer msgContainer;
record1.addItem( itemString );
const auto deckRecord = record1.parse( parseContext , msgContainer, rawRecord );
BOOST_CHECK_EQUAL(" VALUE " , deckRecord.getItem(0).get< std::string >(0));
}
BOOST_AUTO_TEST_CASE(DataKeyword) {
DeckKeyword kw("KW");
BOOST_CHECK_EQUAL( false , kw.isDataKeyword());
kw.setDataKeyword( );
BOOST_CHECK_EQUAL( true , kw.isDataKeyword());
kw.setDataKeyword( false );
BOOST_CHECK_EQUAL( false , kw.isDataKeyword());
kw.setDataKeyword( true );
BOOST_CHECK_EQUAL( true , kw.isDataKeyword());
}
BOOST_AUTO_TEST_CASE(name_nameSetInConstructor_nameReturned) {
DeckKeyword deckKeyword( "KW" );
BOOST_CHECK_EQUAL("KW", deckKeyword.name());
}
BOOST_AUTO_TEST_CASE(size_noRecords_returnszero) {
DeckKeyword deckKeyword( "KW" );
BOOST_CHECK_EQUAL(0U, deckKeyword.size());
}
BOOST_AUTO_TEST_CASE(addRecord_onerecord_recordadded) {
DeckKeyword deckKeyword( "KW" );
deckKeyword.addRecord( DeckRecord() );
BOOST_CHECK_EQUAL(1U, deckKeyword.size());
for (auto iter = deckKeyword.begin(); iter != deckKeyword.end(); ++iter) {
//
}
}
BOOST_AUTO_TEST_CASE(getRecord_outofrange_exceptionthrown) {
DeckKeyword deckKeyword( "KW" );
deckKeyword.addRecord(DeckRecord());
BOOST_CHECK_THROW(deckKeyword.getRecord(1), std::out_of_range);
}
BOOST_AUTO_TEST_CASE(setUnknown_wasknown_nowunknown) {
DeckKeyword deckKeyword( "KW", false );
BOOST_CHECK(!deckKeyword.isKnown());
}

98
tests/parser/GridPropertiesTests.cpp
View File

@@ -1,98 +0,0 @@
/*
Copyright 2014 Statoil ASA.
This file is part of the Open Porous Media project (OPM).
OPM is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OPM is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with OPM. If not, see <http://www.gnu.org/licenses/>.
*/
#include <stdexcept>
#include <iostream>
#define BOOST_TEST_MODULE EclipseGridTests
#include <boost/filesystem.hpp>
#include <boost/test/unit_test.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>
#include <opm/parser/eclipse/Parser/Parser.hpp>
#include <opm/parser/eclipse/Deck/Deck.hpp>
#include <opm/parser/eclipse/Deck/DeckKeyword.hpp>
#include <opm/parser/eclipse/Deck/Section.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/GridProperties.hpp>
BOOST_AUTO_TEST_CASE(Empty) {
typedef Opm::GridProperties<int>::SupportedKeywordInfo SupportedKeywordInfo;
std::vector<SupportedKeywordInfo> supportedKeywords = {
SupportedKeywordInfo("SATNUM" , 0, "1"),
SupportedKeywordInfo("FIPNUM" , 2, "1")
};
const Opm::EclipseGrid grid(10, 7, 9);
Opm::GridProperties<int> gridProperties(grid, std::move(supportedKeywords));
BOOST_CHECK( gridProperties.supportsKeyword("SATNUM") );
BOOST_CHECK( gridProperties.supportsKeyword("FIPNUM") );
BOOST_CHECK( !gridProperties.supportsKeyword("FLUXNUM") );
BOOST_CHECK( !gridProperties.hasKeyword("SATNUM"));
BOOST_CHECK( !gridProperties.hasKeyword("FLUXNUM"));
BOOST_CHECK_THROW( gridProperties.getDeckKeyword("SATNUM") , std::invalid_argument);
BOOST_CHECK_THROW( gridProperties.getDeckKeyword("NONONO") , std::invalid_argument);
}
BOOST_AUTO_TEST_CASE(addKeyword) {
typedef Opm::GridProperties<int>::SupportedKeywordInfo SupportedKeywordInfo;
std::vector<SupportedKeywordInfo> supportedKeywords = {
SupportedKeywordInfo("SATNUM" , 0, "1")
};
Opm::EclipseGrid grid(10,7,9);
Opm::GridProperties<int> gridProperties(grid, std::move( supportedKeywords ));
BOOST_CHECK_THROW( gridProperties.addKeyword("NOT-SUPPORTED"), std::invalid_argument);
BOOST_CHECK( gridProperties.addKeyword("SATNUM"));
BOOST_CHECK( !gridProperties.addKeyword("SATNUM"));
BOOST_CHECK( gridProperties.hasKeyword("SATNUM"));
}
BOOST_AUTO_TEST_CASE(hasKeyword_assertKeyword) {
typedef Opm::GridProperties<int>::SupportedKeywordInfo SupportedKeywordInfo;
std::vector<SupportedKeywordInfo> supportedKeywords = {
SupportedKeywordInfo("SATNUM" , 0, "1"),
SupportedKeywordInfo("FIPNUM" , 0, "1")
};
const Opm::EclipseGrid grid(10, 7, 9);
const Opm::GridProperties<int> gridProperties( grid, std::move( supportedKeywords ) );
// calling getKeyword() should not change the semantics of hasKeyword()!
BOOST_CHECK(!gridProperties.hasKeyword("SATNUM"));
BOOST_CHECK(!gridProperties.hasKeyword("FIPNUM"));
gridProperties.assertKeyword("FIPNUM");
gridProperties.getKeyword("SATNUM");
BOOST_CHECK(gridProperties.hasKeyword("SATNUM"));
BOOST_CHECK(gridProperties.hasKeyword("FIPNUM"));
BOOST_CHECK_THROW( gridProperties.getKeyword( "NOT-SUPPORTED" ), std::invalid_argument );
}

59
tests/parser/GridPropertyTests.cpp
View File

@@ -496,3 +496,62 @@ BOOST_AUTO_TEST_CASE(CheckLimits) {
p1.checkLimits(0,2);
BOOST_CHECK_THROW( p1.checkLimits(-2,0) , std::invalid_argument);
}
BOOST_AUTO_TEST_CASE(PropertiesEmpty) {
typedef Opm::GridProperties<int>::SupportedKeywordInfo SupportedKeywordInfo;
std::vector<SupportedKeywordInfo> supportedKeywords = {
SupportedKeywordInfo("SATNUM" , 0, "1"),
SupportedKeywordInfo("FIPNUM" , 2, "1")
};
const Opm::EclipseGrid grid(10, 7, 9);
Opm::GridProperties<int> gridProperties(grid, std::move(supportedKeywords));
BOOST_CHECK( gridProperties.supportsKeyword("SATNUM") );
BOOST_CHECK( gridProperties.supportsKeyword("FIPNUM") );
BOOST_CHECK( !gridProperties.supportsKeyword("FLUXNUM") );
BOOST_CHECK( !gridProperties.hasKeyword("SATNUM"));
BOOST_CHECK( !gridProperties.hasKeyword("FLUXNUM"));
BOOST_CHECK_THROW( gridProperties.getDeckKeyword("SATNUM") , std::invalid_argument);
BOOST_CHECK_THROW( gridProperties.getDeckKeyword("NONONO") , std::invalid_argument);
}
BOOST_AUTO_TEST_CASE(addKeyword) {
typedef Opm::GridProperties<int>::SupportedKeywordInfo SupportedKeywordInfo;
std::vector<SupportedKeywordInfo> supportedKeywords = {
SupportedKeywordInfo("SATNUM" , 0, "1")
};
Opm::EclipseGrid grid(10,7,9);
Opm::GridProperties<int> gridProperties(grid, std::move( supportedKeywords ));
BOOST_CHECK_THROW( gridProperties.addKeyword("NOT-SUPPORTED"), std::invalid_argument);
BOOST_CHECK( gridProperties.addKeyword("SATNUM"));
BOOST_CHECK( !gridProperties.addKeyword("SATNUM"));
BOOST_CHECK( gridProperties.hasKeyword("SATNUM"));
}
BOOST_AUTO_TEST_CASE(hasKeyword_assertKeyword) {
typedef Opm::GridProperties<int>::SupportedKeywordInfo SupportedKeywordInfo;
std::vector<SupportedKeywordInfo> supportedKeywords = {
SupportedKeywordInfo("SATNUM" , 0, "1"),
SupportedKeywordInfo("FIPNUM" , 0, "1")
};
const Opm::EclipseGrid grid(10, 7, 9);
const Opm::GridProperties<int> gridProperties( grid, std::move( supportedKeywords ) );
// calling getKeyword() should not change the semantics of hasKeyword()!
BOOST_CHECK(!gridProperties.hasKeyword("SATNUM"));
BOOST_CHECK(!gridProperties.hasKeyword("FIPNUM"));
gridProperties.assertKeyword("FIPNUM");
gridProperties.getKeyword("SATNUM");
BOOST_CHECK(gridProperties.hasKeyword("SATNUM"));
BOOST_CHECK(gridProperties.hasKeyword("FIPNUM"));
BOOST_CHECK_THROW( gridProperties.getKeyword( "NOT-SUPPORTED" ), std::invalid_argument );
}

63
tests/parser/GroupTests.cpp
View File

@@ -292,9 +292,9 @@ BOOST_AUTO_TEST_CASE(createDeckWithGEFAC) {
BOOST_AUTO_TEST_CASE(createDeckWithWGRUPCONandWCONPROD) {
/* Test deck with well guide rates for group control:
BOOST_AUTO_TEST_CASE(createDeckWithWGRUPCONandWCONPROD) {
/* Test deck with well guide rates for group control:
GRUPCON (well guide rates for group control)
WCONPROD (conrol data for production wells) with GRUP control mode */
@@ -314,7 +314,7 @@ BOOST_AUTO_TEST_CASE(createDeckWithWGRUPCONandWCONPROD) {
" 'B-43A' 8 8 2 2 'OPEN' 1* 46.825 0.311 4332.346 1* 1* 'X' 22.123 / \n"
"/\n"
"WGRUPCON\n"
" 'B-37T2' YES 30 OIL / \n"
" 'B-43A' YES 30 OIL / \n"
@@ -325,7 +325,7 @@ BOOST_AUTO_TEST_CASE(createDeckWithWGRUPCONandWCONPROD) {
" 'B-43A' 'OPEN' 'GRUP' 1200 2* 3000.000 2* 1* 11 0.000 5* / / \n"
"/\n";
Opm::ParseContext parseContext;
auto deck = parser.parseString(input, parseContext);
@@ -342,5 +342,56 @@ BOOST_AUTO_TEST_CASE(createDeckWithWGRUPCONandWCONPROD) {
BOOST_CHECK_EQUAL(currentWell->getGuideRatePhase(0), Opm::GuideRate::OIL);
BOOST_CHECK_EQUAL(currentWell->getGuideRateScalingFactor(0), 1.0);
}
BOOST_AUTO_TEST_CASE(CreateGroupTree_DefaultConstructor_HasFieldNode) {
GroupTree tree;
BOOST_CHECK(tree.exists("FIELD"));
}
BOOST_AUTO_TEST_CASE(GetNode_NonExistingNode_ReturnsNull) {
GroupTree tree;
BOOST_CHECK(!tree.exists("Non-existing"));
}
BOOST_AUTO_TEST_CASE(GetNodeAndParent_AllOK) {
GroupTree tree;
tree.update("GRANDPARENT", "FIELD");
tree.update("PARENT", "GRANDPARENT");
tree.update("GRANDCHILD", "PARENT");
const auto grandchild = tree.exists("GRANDCHILD");
BOOST_CHECK(grandchild);
auto parent = tree.parent("GRANDCHILD");
BOOST_CHECK_EQUAL("PARENT", parent);
BOOST_CHECK( tree.children( "PARENT" ).front() == "GRANDCHILD" );
}
BOOST_AUTO_TEST_CASE(UpdateTree_ParentNotSpecified_AddedUnderField) {
GroupTree tree;
tree.update("CHILD_OF_FIELD");
BOOST_CHECK(tree.exists("CHILD_OF_FIELD"));
BOOST_CHECK_EQUAL( "FIELD", tree.parent( "CHILD_OF_FIELD" ) );
}
BOOST_AUTO_TEST_CASE(UpdateTree_ParentIsField_AddedUnderField) {
GroupTree tree;
tree.update("CHILD_OF_FIELD", "FIELD");
BOOST_CHECK( tree.exists( "CHILD_OF_FIELD" ) );
BOOST_CHECK_EQUAL( "FIELD", tree.parent( "CHILD_OF_FIELD" ) );
}
BOOST_AUTO_TEST_CASE(UpdateTree_ParentNotAdded_ChildAndParentAdded) {
GroupTree tree;
tree.update("CHILD", "NEWPARENT");
BOOST_CHECK( tree.exists("CHILD") );
BOOST_CHECK_EQUAL( "NEWPARENT", tree.parent( "CHILD" ) );
BOOST_CHECK_EQUAL( "CHILD", tree.children( "NEWPARENT" ).front() );
}
BOOST_AUTO_TEST_CASE(UpdateTree_AddFieldNode_Throws) {
GroupTree tree;
BOOST_CHECK_THROW(tree.update("FIELD", "NEWPARENT"), std::invalid_argument );
BOOST_CHECK_THROW(tree.update("FIELD"), std::invalid_argument );
}

80
tests/parser/GroupTreeTests.cpp
View File

@@ -1,80 +0,0 @@
/*
Copyright 2013 Statoil ASA.
This file is part of the Open Porous Media project (OPM).
OPM is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OPM is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with OPM. If not, see <http://www.gnu.org/licenses/>.
*/
#include <opm/parser/eclipse/EclipseState/Schedule/GroupTree.hpp>
#define BOOST_TEST_MODULE GroupTreeTests
#include <boost/test/unit_test.hpp>
#include <stdexcept>
#include <iostream>
using namespace Opm;
BOOST_AUTO_TEST_CASE(CreateGroupTree_DefaultConstructor_HasFieldNode) {
GroupTree tree;
BOOST_CHECK(tree.exists("FIELD"));
}
BOOST_AUTO_TEST_CASE(GetNode_NonExistingNode_ReturnsNull) {
GroupTree tree;
BOOST_CHECK(!tree.exists("Non-existing"));
}
BOOST_AUTO_TEST_CASE(GetNodeAndParent_AllOK) {
GroupTree tree;
tree.update("GRANDPARENT", "FIELD");
tree.update("PARENT", "GRANDPARENT");
tree.update("GRANDCHILD", "PARENT");
const auto grandchild = tree.exists("GRANDCHILD");
BOOST_CHECK(grandchild);
auto parent = tree.parent("GRANDCHILD");
BOOST_CHECK_EQUAL("PARENT", parent);
BOOST_CHECK( tree.children( "PARENT" ).front() == "GRANDCHILD" );
}
BOOST_AUTO_TEST_CASE(UpdateTree_ParentNotSpecified_AddedUnderField) {
GroupTree tree;
tree.update("CHILD_OF_FIELD");
BOOST_CHECK(tree.exists("CHILD_OF_FIELD"));
BOOST_CHECK_EQUAL( "FIELD", tree.parent( "CHILD_OF_FIELD" ) );
}
BOOST_AUTO_TEST_CASE(UpdateTree_ParentIsField_AddedUnderField) {
GroupTree tree;
tree.update("CHILD_OF_FIELD", "FIELD");
BOOST_CHECK( tree.exists( "CHILD_OF_FIELD" ) );
BOOST_CHECK_EQUAL( "FIELD", tree.parent( "CHILD_OF_FIELD" ) );
}
BOOST_AUTO_TEST_CASE(UpdateTree_ParentNotAdded_ChildAndParentAdded) {
GroupTree tree;
tree.update("CHILD", "NEWPARENT");
BOOST_CHECK( tree.exists("CHILD") );
BOOST_CHECK_EQUAL( "NEWPARENT", tree.parent( "CHILD" ) );
BOOST_CHECK_EQUAL( "CHILD", tree.children( "NEWPARENT" ).front() );
}
BOOST_AUTO_TEST_CASE(UpdateTree_AddFieldNode_Throws) {
GroupTree tree;
BOOST_CHECK_THROW(tree.update("FIELD", "NEWPARENT"), std::invalid_argument );
BOOST_CHECK_THROW(tree.update("FIELD"), std::invalid_argument );
}

123
tests/parser/ParserEnumTests.cpp
View File

@@ -1,123 +0,0 @@
/*
Copyright 2013 Statoil ASA.
This file is part of the Open Porous Media project (OPM).
OPM is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OPM is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with OPM. If not, see <http://www.gnu.org/licenses/>.
*/
#define BOOST_TEST_MODULE ParserEnumTests
#include <boost/test/unit_test.hpp>
#include <opm/parser/eclipse/Parser/ParserEnums.hpp>
using namespace Opm;
/*****************************************************************/
BOOST_AUTO_TEST_CASE(TestKeywordSizeEnum2String) {
BOOST_CHECK_EQUAL( "SLASH_TERMINATED" , ParserKeywordSizeEnum2String(SLASH_TERMINATED));
BOOST_CHECK_EQUAL( "FIXED" , ParserKeywordSizeEnum2String(FIXED));
BOOST_CHECK_EQUAL( "OTHER_KEYWORD_IN_DECK" , ParserKeywordSizeEnum2String(OTHER_KEYWORD_IN_DECK));
BOOST_CHECK_EQUAL( "UNKNOWN" , ParserKeywordSizeEnum2String(UNKNOWN));
}
BOOST_AUTO_TEST_CASE(TestKeywordSizeEnumFromString) {
BOOST_CHECK_THROW( ParserKeywordSizeEnumFromString("XXX") , std::invalid_argument );
BOOST_CHECK_EQUAL( FIXED , ParserKeywordSizeEnumFromString("FIXED"));
BOOST_CHECK_EQUAL( SLASH_TERMINATED , ParserKeywordSizeEnumFromString("SLASH_TERMINATED"));
BOOST_CHECK_EQUAL( "OTHER_KEYWORD_IN_DECK" , ParserKeywordSizeEnum2String(OTHER_KEYWORD_IN_DECK));
BOOST_CHECK_EQUAL( "UNKNOWN" , ParserKeywordSizeEnum2String(UNKNOWN));
}
BOOST_AUTO_TEST_CASE(TestKeywordSizeEnumLoop) {
BOOST_CHECK_EQUAL( FIXED , ParserKeywordSizeEnumFromString( ParserKeywordSizeEnum2String( FIXED ) ));
BOOST_CHECK_EQUAL( SLASH_TERMINATED , ParserKeywordSizeEnumFromString( ParserKeywordSizeEnum2String( SLASH_TERMINATED ) ));
BOOST_CHECK_EQUAL( OTHER_KEYWORD_IN_DECK , ParserKeywordSizeEnumFromString( ParserKeywordSizeEnum2String( OTHER_KEYWORD_IN_DECK ) ));
BOOST_CHECK_EQUAL( UNKNOWN , ParserKeywordSizeEnumFromString( ParserKeywordSizeEnum2String( UNKNOWN ) ));
BOOST_CHECK_EQUAL( "FIXED" , ParserKeywordSizeEnum2String(ParserKeywordSizeEnumFromString( "FIXED" ) ));
BOOST_CHECK_EQUAL( "SLASH_TERMINATED" , ParserKeywordSizeEnum2String(ParserKeywordSizeEnumFromString( "SLASH_TERMINATED" ) ));
BOOST_CHECK_EQUAL( "OTHER_KEYWORD_IN_DECK" , ParserKeywordSizeEnum2String(ParserKeywordSizeEnumFromString( "OTHER_KEYWORD_IN_DECK" ) ));
BOOST_CHECK_EQUAL( "UNKNOWN" , ParserKeywordSizeEnum2String(ParserKeywordSizeEnumFromString( "UNKNOWN" ) ));
}
/*****************************************************************/
BOOST_AUTO_TEST_CASE(TestValueTypeEnum2String) {
BOOST_CHECK_EQUAL( "INT" , ParserValueTypeEnum2String(INT));
BOOST_CHECK_EQUAL( "FLOAT" , ParserValueTypeEnum2String(FLOAT));
BOOST_CHECK_EQUAL( "STRING" , ParserValueTypeEnum2String(STRING));
}
BOOST_AUTO_TEST_CASE(TestValueTypeEnumFromString) {
BOOST_CHECK_THROW( ParserValueTypeEnumFromString("XXX") , std::invalid_argument );
BOOST_CHECK_EQUAL( INT , ParserValueTypeEnumFromString("INT"));
BOOST_CHECK_EQUAL( STRING , ParserValueTypeEnumFromString("STRING"));
BOOST_CHECK_EQUAL( FLOAT , ParserValueTypeEnumFromString("FLOAT"));
}
BOOST_AUTO_TEST_CASE(TestValueTypeEnumLoop) {
BOOST_CHECK_EQUAL( INT , ParserValueTypeEnumFromString( ParserValueTypeEnum2String( INT ) ));
BOOST_CHECK_EQUAL( FLOAT , ParserValueTypeEnumFromString( ParserValueTypeEnum2String( FLOAT ) ));
BOOST_CHECK_EQUAL( STRING , ParserValueTypeEnumFromString( ParserValueTypeEnum2String( STRING ) ));
BOOST_CHECK_EQUAL( "INT" , ParserValueTypeEnum2String(ParserValueTypeEnumFromString( "INT" ) ));
BOOST_CHECK_EQUAL( "FLOAT" , ParserValueTypeEnum2String(ParserValueTypeEnumFromString( "FLOAT" ) ));
BOOST_CHECK_EQUAL( "STRING" , ParserValueTypeEnum2String(ParserValueTypeEnumFromString( "STRING" ) ));
}
/*****************************************************************/
BOOST_AUTO_TEST_CASE(TestKeywordActionEnum2String) {
BOOST_CHECK_EQUAL( "INTERNALIZE" , ParserKeywordActionEnum2String(INTERNALIZE));
BOOST_CHECK_EQUAL( "IGNORE" , ParserKeywordActionEnum2String(IGNORE));
BOOST_CHECK_EQUAL( "IGNORE_WARNING" , ParserKeywordActionEnum2String(IGNORE_WARNING));
BOOST_CHECK_EQUAL( "THROW_EXCEPTION" , ParserKeywordActionEnum2String(THROW_EXCEPTION));
}
BOOST_AUTO_TEST_CASE(TestKeywordActionEnumFromString) {
BOOST_CHECK_THROW( ParserKeywordActionEnumFromString("XXX") , std::invalid_argument );
BOOST_CHECK_EQUAL( INTERNALIZE , ParserKeywordActionEnumFromString("INTERNALIZE"));
BOOST_CHECK_EQUAL( IGNORE_WARNING , ParserKeywordActionEnumFromString("IGNORE_WARNING"));
BOOST_CHECK_EQUAL( IGNORE , ParserKeywordActionEnumFromString("IGNORE"));
BOOST_CHECK_EQUAL( THROW_EXCEPTION , ParserKeywordActionEnumFromString("THROW_EXCEPTION"));
}
BOOST_AUTO_TEST_CASE(TestKeywordActionEnumLoop) {
BOOST_CHECK_EQUAL( INTERNALIZE , ParserKeywordActionEnumFromString( ParserKeywordActionEnum2String( INTERNALIZE ) ));
BOOST_CHECK_EQUAL( IGNORE , ParserKeywordActionEnumFromString( ParserKeywordActionEnum2String( IGNORE ) ));
BOOST_CHECK_EQUAL( IGNORE_WARNING , ParserKeywordActionEnumFromString( ParserKeywordActionEnum2String( IGNORE_WARNING ) ));
BOOST_CHECK_EQUAL( THROW_EXCEPTION , ParserKeywordActionEnumFromString( ParserKeywordActionEnum2String( THROW_EXCEPTION ) ));
BOOST_CHECK_EQUAL( "INTERNALIZE" , ParserKeywordActionEnum2String(ParserKeywordActionEnumFromString( "INTERNALIZE" ) ));
BOOST_CHECK_EQUAL( "IGNORE" , ParserKeywordActionEnum2String(ParserKeywordActionEnumFromString( "IGNORE" ) ));
BOOST_CHECK_EQUAL( "IGNORE_WARNING" , ParserKeywordActionEnum2String(ParserKeywordActionEnumFromString( "IGNORE_WARNING" ) ));
BOOST_CHECK_EQUAL( "THROW_EXCEPTION" , ParserKeywordActionEnum2String(ParserKeywordActionEnumFromString( "THROW_EXCEPTION" ) ));
}

611
tests/parser/ParserItemTests.cpp
View File

@@ -1,611 +0,0 @@
/*
Copyright 2013 Statoil ASA.
This file is part of the Open Porous Media project (OPM).
OPM is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OPM is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with OPM. If not, see <http://www.gnu.org/licenses/>.
*/
#define BOOST_TEST_MODULE ParserItemTests
#include <boost/test/unit_test.hpp>
#include <opm/json/JsonObject.hpp>
#include <opm/parser/eclipse/Parser/ParserEnums.hpp>
#include <opm/parser/eclipse/Parser/ParserItem.hpp>
#include <opm/parser/eclipse/RawDeck/RawRecord.hpp>
#include <cmath>
using namespace Opm;
BOOST_AUTO_TEST_CASE(Initialize) {
auto sizeType = ParserItem::item_size::SINGLE;
BOOST_CHECK_NO_THROW(ParserItem item1("ITEM1", sizeType));
}
BOOST_AUTO_TEST_CASE(ScalarCheck) {
ParserItem item1("ITEM1", ParserItem::item_size::SINGLE );
ParserItem item2("ITEM1", ParserItem::item_size::ALL );
BOOST_CHECK( item1.scalar());
BOOST_CHECK( !item2.scalar());
}
BOOST_AUTO_TEST_CASE(Initialize_DefaultSizeType) {
ParserItem item1(std::string("ITEM1"));
BOOST_CHECK_EQUAL( ParserItem::item_size::SINGLE, item1.sizeType());
}
BOOST_AUTO_TEST_CASE(Initialize_Default) {
ParserItem item1(std::string("ITEM1"));
ParserItem item2(std::string("ITEM1"), 88);
BOOST_CHECK(!item1.hasDefault());
BOOST_CHECK_THROW(item1.getDefault< int >(), std::invalid_argument);
BOOST_CHECK(item2.hasDefault());
BOOST_CHECK_EQUAL(item2.getDefault< int >(), 88);
}
BOOST_AUTO_TEST_CASE(Initialize_Default_Double) {
ParserItem item1(std::string("ITEM1"));
ParserItem item2("ITEM1", 88.91);
BOOST_CHECK(!item1.hasDefault());
BOOST_CHECK_THROW( item1.getDefault< double >(), std::invalid_argument );
BOOST_CHECK_EQUAL( 88.91 , item2.getDefault< double >());
}
BOOST_AUTO_TEST_CASE(Initialize_Default_String) {
ParserItem item1(std::string("ITEM1"));
BOOST_CHECK(!item1.hasDefault());
BOOST_CHECK_THROW(item1.getDefault< std::string >(), std::invalid_argument);
ParserItem item2("ITEM1", "String");
BOOST_CHECK(item2.hasDefault());
BOOST_CHECK_EQUAL( "String" , item2.getDefault< std::string >());
}
BOOST_AUTO_TEST_CASE(scan_PreMatureTerminator_defaultUsed) {
ParserItem itemInt("ITEM2", 123);
RawRecord rawRecord1( "" );
const auto defaulted = itemInt.scan(rawRecord1);
BOOST_CHECK(defaulted.defaultApplied(0));
BOOST_CHECK_EQUAL(defaulted.get< int >(0), 123);
}
BOOST_AUTO_TEST_CASE(InitializeIntItem_setDescription_canReadBack) {
ParserItem itemInt("ITEM1");
std::string description("This is the description");
itemInt.setDescription(description);
BOOST_CHECK_EQUAL( description, itemInt.getDescription() );
}
/******************************************************************/
/* <Json> */
BOOST_AUTO_TEST_CASE(InitializeIntItem_FromJsonObject_missingName_throws) {
Json::JsonObject jsonConfig("{\"nameX\": \"ITEM1\" , \"size_type\" : \"ALL\"}");
BOOST_CHECK_THROW( ParserItem item1( jsonConfig ) , std::invalid_argument );
}
BOOST_AUTO_TEST_CASE(InitializeIntItem_FromJsonObject_defaultSizeType) {
Json::JsonObject jsonConfig("{\"name\": \"ITEM1\", \"value_type\": \"INT\" }");
ParserItem item1( jsonConfig );
BOOST_CHECK_EQUAL( ParserItem::item_size::SINGLE , item1.sizeType());
}
BOOST_AUTO_TEST_CASE(InitializeIntItem_FromJsonObject) {
Json::JsonObject jsonConfig("{\"name\": \"ITEM1\" , \"size_type\" : \"ALL\", \"value_type\": \"INT\" }");
ParserItem item1( jsonConfig );
BOOST_CHECK_EQUAL( "ITEM1" , item1.name() );
BOOST_CHECK_EQUAL( ParserItem::item_size::ALL, item1.sizeType() );
BOOST_CHECK(item1.getDefault< int >() < 0);
}
BOOST_AUTO_TEST_CASE(InitializeIntItem_FromJsonObject_withDefault) {
Json::JsonObject jsonConfig("{\"name\": \"ITEM1\" , \"size_type\" : \"SINGLE\", \"default\" : 100, \"value_type\": \"INT\" }");
ParserItem item1( jsonConfig );
BOOST_CHECK_EQUAL( 100 , item1.getDefault< int >() );
}
BOOST_AUTO_TEST_CASE(InitializeIntItem_FromJsonObject_withDefaultInvalid_throws) {
Json::JsonObject jsonConfig("{\"name\": \"ITEM1\" , \"size_type\" : \"SINGLE\", \"default\" : \"100X\"}");
BOOST_CHECK_THROW( ParserItem item1( jsonConfig ) , std::invalid_argument );
}
BOOST_AUTO_TEST_CASE(InitializeIntItem_FromJsonObject_withSizeTypeALL_throws) {
Json::JsonObject jsonConfig("{\"name\": \"ITEM1\" , \"value_type\": \"INT\", \"size_type\" : \"ALL\", \"default\" : 100}");
BOOST_CHECK_THROW( ParserItem item1( jsonConfig ) , std::invalid_argument );
}
BOOST_AUTO_TEST_CASE(InitializeIntItem_WithDescription_DescriptionPropertyShouldBePopulated) {
std::string description("Description goes here");
Json::JsonObject jsonConfig("{\"name\": \"ITEM1\" , \"value_type\": \"INT\", \"description\" : \"Description goes here\"}");
ParserItem item(jsonConfig);
BOOST_CHECK_EQUAL( "Description goes here", item.getDescription() );
}
BOOST_AUTO_TEST_CASE(InitializeIntItem_WithoutDescription_DescriptionPropertyShouldBeEmpty) {
Json::JsonObject jsonConfig("{\"name\": \"ITEM1\", \"value_type\": \"INT\" }");
ParserItem item(jsonConfig);
BOOST_CHECK_EQUAL( "", item.getDescription() );
}
/* </Json> */
/******************************************************************/
/* EQUAL */
BOOST_AUTO_TEST_CASE(IntItem_Equal_ReturnsTrue) {
auto sizeType = ParserItem::item_size::ALL;
ParserItem item1("ITEM1", sizeType);
ParserItem item2("ITEM1", sizeType);
ParserItem item3 = item1;
BOOST_CHECK_EQUAL( item1, item2 );
BOOST_CHECK_EQUAL( item1, item3 );
}
BOOST_AUTO_TEST_CASE(IntItem_Different_ReturnsFalse) {
ParserItem item1("ITEM1", ParserItem::item_size::ALL);
ParserItem item2("ITEM2", ParserItem::item_size::ALL);
ParserItem item3("ITEM1");
ParserItem item4("ITEM1" , 42);
BOOST_CHECK_NE( item1, item2 );
BOOST_CHECK_NE( item1, item3 );
BOOST_CHECK_NE( item2, item3 );
BOOST_CHECK_NE( item4, item3 );
}
BOOST_AUTO_TEST_CASE(DoubleItem_DimEqual_ReturnsTrue) {
auto sizeType = ParserItem::item_size::ALL;
ParserItem item1("ITEM1", sizeType, 0.0);
ParserItem item2("ITEM1", sizeType, 0.0);
item1.push_backDimension("Length*Length");
item2.push_backDimension("Length*Length");
BOOST_CHECK_EQUAL( item1, item2 );
}
BOOST_AUTO_TEST_CASE(DoubleItem_DimDifferent_ReturnsFalse) {
auto sizeType = ParserItem::item_size::ALL;
ParserItem item1("ITEM1", sizeType, 0.0); // Dim: []
ParserItem item2("ITEM1", sizeType, 0.0); // Dim: [Length]
ParserItem item3("ITEM1", sizeType, 0.0); // Dim: [Length ,Length]
ParserItem item4("ITEM1", sizeType, 0.0); // Dim: [t]
item2.push_backDimension("Length");
item3.push_backDimension("Length");
item3.push_backDimension("Length");
item4.push_backDimension("Time");
BOOST_CHECK_NE(item1, item2 );
BOOST_CHECK_NE(item2, item3 );
BOOST_CHECK_NE(item2, item1 );
BOOST_CHECK_NE(item2, item4 );
BOOST_CHECK_NE(item1, item3 );
BOOST_CHECK_NE(item3, item1 );
BOOST_CHECK_NE(item4, item2 );
}
BOOST_AUTO_TEST_CASE(DoubleItem_Different_ReturnsFalse) {
ParserItem item1("ITEM1", ParserItem::item_size::ALL, 0.0);
ParserItem item2("ITEM2", ParserItem::item_size::ALL, 0.0);
ParserItem item3("ITEM1", 0.0 );
ParserItem item4("ITEM1", 42.89);
BOOST_CHECK_NE( item1, item2 );
BOOST_CHECK_NE( item1, item3 );
BOOST_CHECK_NE( item2, item3 );
BOOST_CHECK_NE( item4, item3 );
}
BOOST_AUTO_TEST_CASE(StringItem_Equal_ReturnsTrue) {
auto sizeType = ParserItem::item_size::ALL;
ParserItem item1("ITEM1", sizeType, "");
ParserItem item2("ITEM1", sizeType, "");
ParserItem item3 = item1;
BOOST_CHECK_EQUAL( item1, item2 );
BOOST_CHECK_EQUAL( item1, item3 );
}
BOOST_AUTO_TEST_CASE(StringItem_Different_ReturnsFalse) {
ParserItem item1("ITEM1", ParserItem::item_size::ALL, "");
ParserItem item2("ITEM2", ParserItem::item_size::ALL, "");
ParserItem item3("ITEM1", "" );
ParserItem item4("ITEM1", "42.89");
BOOST_CHECK_NE( item1, item2 );
BOOST_CHECK_NE( item1, item3 );
BOOST_CHECK_NE( item2, item3 );
BOOST_CHECK_NE( item4, item3 );
}
/******************************************************************/
BOOST_AUTO_TEST_CASE(Name_ReturnsCorrectName) {
auto sizeType = ParserItem::item_size::ALL;
ParserItem item1("ITEM1", sizeType);
BOOST_CHECK_EQUAL("ITEM1", item1.name());
ParserItem item2("", sizeType);
BOOST_CHECK_EQUAL("", item2.name());
}
BOOST_AUTO_TEST_CASE(Size_ReturnsCorrectSizeTypeSingle) {
auto sizeType = ParserItem::item_size::SINGLE;
ParserItem item1("ITEM1", sizeType);
BOOST_CHECK_EQUAL(sizeType, item1.sizeType());
}
BOOST_AUTO_TEST_CASE(Size_ReturnsCorrectSizeTypeAll) {
auto sizeType = ParserItem::item_size::ALL;
ParserItem item1("ITEM1", sizeType);
BOOST_CHECK_EQUAL(sizeType, item1.sizeType());
}
BOOST_AUTO_TEST_CASE(Scan_All_CorrectIntSetInDeckItem) {
auto sizeType = ParserItem::item_size::ALL;
ParserItem itemInt("ITEM", sizeType, 0);
RawRecord rawRecord( "100 443 10*77 10*1 25" );
const auto deckIntItem = itemInt.scan(rawRecord);
BOOST_CHECK_EQUAL(23U, deckIntItem.size());
BOOST_CHECK_EQUAL(77, deckIntItem.get< int >(3));
BOOST_CHECK_EQUAL(1, deckIntItem.get< int >(21));
BOOST_CHECK_EQUAL(25, deckIntItem.get< int >(22));
}
BOOST_AUTO_TEST_CASE(Scan_All_WithDefaults) {
auto sizeType = ParserItem::item_size::ALL;
ParserItem itemInt("ITEM", sizeType);
itemInt.setType( int() );
RawRecord rawRecord( "100 10* 10*1 25" );
const auto deckIntItem = itemInt.scan(rawRecord);
BOOST_CHECK_EQUAL(22U, deckIntItem.size());
BOOST_CHECK(!deckIntItem.defaultApplied(0));
BOOST_CHECK( deckIntItem.defaultApplied(1));
BOOST_CHECK(!deckIntItem.defaultApplied(11));
BOOST_CHECK(!deckIntItem.defaultApplied(21));
BOOST_CHECK_EQUAL(1, deckIntItem.get< int >(20));
BOOST_CHECK_EQUAL(25, deckIntItem.get< int >(21));
}
BOOST_AUTO_TEST_CASE(Scan_SINGLE_CorrectIntSetInDeckItem) {
ParserItem itemInt(std::string("ITEM2"), 0);
RawRecord rawRecord("100 44.3 'Heisann'" );
const auto deckIntItem = itemInt.scan(rawRecord);
BOOST_CHECK_EQUAL(100, deckIntItem.get< int >(0));
}
BOOST_AUTO_TEST_CASE(Scan_SeveralInts_CorrectIntsSetInDeckItem) {
ParserItem itemInt1(std::string("ITEM1"), 0);
ParserItem itemInt2(std::string("ITEM2"), 0);
ParserItem itemInt3(std::string("ITEM3"), 0);
RawRecord rawRecord( "100 443 338932 222.33 'Heisann' " );
const auto deckIntItem1 = itemInt1.scan(rawRecord);
BOOST_CHECK_EQUAL(100, deckIntItem1.get< int >(0));
const auto deckIntItem2 = itemInt2.scan(rawRecord);
BOOST_CHECK_EQUAL(443, deckIntItem2.get< int >(0));
const auto deckIntItem3 = itemInt3.scan(rawRecord);
BOOST_CHECK_EQUAL(338932, deckIntItem3.get< int >(0));
}
BOOST_AUTO_TEST_CASE(Scan_Multiplier_CorrectIntsSetInDeckItem) {
auto sizeType = ParserItem::item_size::ALL;
ParserItem itemInt("ITEM2", sizeType, 0);
RawRecord rawRecord( "3*4 " );
const auto deckIntItem = itemInt.scan(rawRecord);
BOOST_CHECK_EQUAL(4, deckIntItem.get< int >(0));
BOOST_CHECK_EQUAL(4, deckIntItem.get< int >(1));
BOOST_CHECK_EQUAL(4, deckIntItem.get< int >(2));
}
BOOST_AUTO_TEST_CASE(Scan_StarNoMultiplier_ExceptionThrown) {
auto sizeType = ParserItem::item_size::SINGLE;
ParserItem itemInt("ITEM2", sizeType , 100);
RawRecord rawRecord( "*45 " );
BOOST_CHECK_THROW(itemInt.scan(rawRecord), std::invalid_argument);
}
BOOST_AUTO_TEST_CASE(Scan_MultipleItems_CorrectIntsSetInDeckItem) {
ParserItem itemInt1(std::string("ITEM1"), 0);
ParserItem itemInt2(std::string("ITEM2"), 0);
RawRecord rawRecord( "10 20" );
const auto deckIntItem1 = itemInt1.scan(rawRecord);
const auto deckIntItem2 = itemInt2.scan(rawRecord);
BOOST_CHECK_EQUAL(10, deckIntItem1.get< int >(0));
BOOST_CHECK_EQUAL(20, deckIntItem2.get< int >(0));
}
BOOST_AUTO_TEST_CASE(Scan_MultipleDefault_CorrectIntsSetInDeckItem) {
ParserItem itemInt1("ITEM1", 10);
ParserItem itemInt2("ITEM2", 20);
RawRecord rawRecord( "* * " );
const auto deckIntItem1 = itemInt1.scan(rawRecord);
const auto deckIntItem2 = itemInt2.scan(rawRecord);
BOOST_CHECK_EQUAL(10, deckIntItem1.get< int >(0));
BOOST_CHECK_EQUAL(20, deckIntItem2.get< int >(0));
}
BOOST_AUTO_TEST_CASE(Scan_MultipleWithMultiplier_CorrectIntsSetInDeckItem) {
ParserItem itemInt1("ITEM1", 10);
ParserItem itemInt2("ITEM2", 20);
RawRecord rawRecord( "2*30" );
const auto deckIntItem1 = itemInt1.scan(rawRecord);
const auto deckIntItem2 = itemInt2.scan(rawRecord);
BOOST_CHECK_EQUAL(30, deckIntItem1.get< int >(0));
BOOST_CHECK_EQUAL(30, deckIntItem2.get< int >(0));
}
BOOST_AUTO_TEST_CASE(Scan_MalformedMultiplier_Throw) {
ParserItem itemInt1("ITEM1" , 10);
RawRecord rawRecord( "2.10*30" );
BOOST_CHECK_THROW(itemInt1.scan(rawRecord), std::invalid_argument);
}
BOOST_AUTO_TEST_CASE(Scan_MalformedMultiplierChar_Throw) {
ParserItem itemInt1("ITEM1", 10);
RawRecord rawRecord( "210X30" );
BOOST_CHECK_THROW(itemInt1.scan(rawRecord), std::invalid_argument);
}
BOOST_AUTO_TEST_CASE(Scan_MultipleWithMultiplierDefault_CorrectIntsSetInDeckItem) {
ParserItem itemInt1("ITEM1", 10);
ParserItem itemInt2("ITEM2", 20);
RawRecord rawRecord( "2*" );
const auto deckIntItem1 = itemInt1.scan(rawRecord);
const auto deckIntItem2 = itemInt2.scan(rawRecord);
BOOST_CHECK_EQUAL(10, deckIntItem1.get< int >(0));
BOOST_CHECK_EQUAL(20, deckIntItem2.get< int >(0));
}
BOOST_AUTO_TEST_CASE(Scan_RawRecordErrorInRawData_ExceptionThrown) {
ParserItem itemInt(std::string("ITEM2"), 0);
// Wrong type
RawRecord rawRecord2( "333.2 /" );
BOOST_CHECK_THROW(itemInt.scan(rawRecord2), std::invalid_argument);
// Wrong type
RawRecord rawRecord3( "100X /" );
BOOST_CHECK_THROW(itemInt.scan(rawRecord3), std::invalid_argument);
// Wrong type
RawRecord rawRecord5( "astring /" );
BOOST_CHECK_THROW(itemInt.scan(rawRecord5), std::invalid_argument);
}
/*********************String************************'*/
/*****************************************************************/
/*</json>*/
BOOST_AUTO_TEST_CASE(InitializeStringItem_FromJsonObject_missingName_throws) {
Json::JsonObject jsonConfig("{\"nameX\": \"ITEM1\" , \"size_type\" : \"ALL\"}");
BOOST_CHECK_THROW( ParserItem item1( jsonConfig ) , std::invalid_argument );
}
BOOST_AUTO_TEST_CASE(InitializeStringItem_FromJsonObject_withDefault) {
Json::JsonObject jsonConfig("{\"name\": \"ITEM1\" , \"value_type\": \"STRING\", \"size_type\" : \"SINGLE\", \"default\" : \"100\"}");
ParserItem item1( jsonConfig );
BOOST_CHECK_EQUAL( "100" , item1.getDefault< std::string >() );
}
BOOST_AUTO_TEST_CASE(InitializeStringItem_FromJsonObject_withDefaultInvalid_throws) {
Json::JsonObject jsonConfig("{\"name\": \"ITEM1\" , \"size_type\" : \"ALL\", \"default\" : [1,2,3]}");
BOOST_CHECK_THROW( ParserItem item1( jsonConfig ) , std::invalid_argument );
}
/*</json>*/
/*****************************************************************/
BOOST_AUTO_TEST_CASE(init_defaultvalue_defaultset) {
ParserItem itemString(std::string("ITEM1") , "DEFAULT");
RawRecord rawRecord( "'1*'" );
BOOST_CHECK_EQUAL("1*", itemString.scan( rawRecord ).get< std::string >(0) );
RawRecord rawRecord1( "13*" );
BOOST_CHECK_EQUAL("DEFAULT" , itemString.scan( rawRecord1 ).get< std::string >(0) );
RawRecord rawRecord2( "*" );
BOOST_CHECK_EQUAL("DEFAULT", itemString.scan( rawRecord2 ).get< std::string >(0) );
ParserItem itemStringDefaultChanged("ITEM2", "SPECIAL");
RawRecord rawRecord3( "*" );
BOOST_CHECK_EQUAL("SPECIAL", itemStringDefaultChanged.scan( rawRecord3 ).get< std::string >(0) );
}
BOOST_AUTO_TEST_CASE(scan_all_valuesCorrect) {
auto sizeType = ParserItem::item_size::ALL;
ParserItem itemString("ITEMWITHMANY", sizeType, "");
RawRecord rawRecord( "'WELL1' FISK BANAN 3*X OPPLEGG_FOR_DATAANALYSE 'Foo$*!% BAR' " );
const auto deckItem = itemString.scan(rawRecord);
BOOST_CHECK_EQUAL(8U, deckItem.size());
BOOST_CHECK_EQUAL("WELL1", deckItem.get< std::string >(0));
BOOST_CHECK_EQUAL("FISK", deckItem.get< std::string >(1));
BOOST_CHECK_EQUAL("BANAN", deckItem.get< std::string >(2));
BOOST_CHECK_EQUAL("X", deckItem.get< std::string >(3));
BOOST_CHECK_EQUAL("X", deckItem.get< std::string >(4));
BOOST_CHECK_EQUAL("X", deckItem.get< std::string >(5));
BOOST_CHECK_EQUAL("OPPLEGG_FOR_DATAANALYSE", deckItem.get< std::string >(6));
BOOST_CHECK_EQUAL("Foo$*!% BAR", deckItem.get< std::string >(7));
}
BOOST_AUTO_TEST_CASE(scan_all_withdefaults) {
auto sizeType = ParserItem::item_size::ALL;
ParserItem itemString("ITEMWITHMANY", sizeType, 0);
RawRecord rawRecord( "10*1 10* 10*2 " );
const auto deckItem = itemString.scan(rawRecord);
BOOST_CHECK_EQUAL(30U, deckItem.size());
BOOST_CHECK( !deckItem.defaultApplied(0) );
BOOST_CHECK( !deckItem.defaultApplied(9) );
BOOST_CHECK( deckItem.defaultApplied(10) );
BOOST_CHECK( deckItem.defaultApplied(19) );
BOOST_CHECK( !deckItem.defaultApplied(20) );
BOOST_CHECK( !deckItem.defaultApplied(29) );
BOOST_CHECK_THROW(deckItem.get< int >(30), std::out_of_range);
BOOST_CHECK_THROW(deckItem.defaultApplied(30), std::out_of_range);
BOOST_CHECK_EQUAL(1, deckItem.get< int >(0));
BOOST_CHECK_EQUAL(1, deckItem.get< int >(9));
BOOST_CHECK_EQUAL(2, deckItem.get< int >(20));
BOOST_CHECK_EQUAL(2, deckItem.get< int >(29));
}
BOOST_AUTO_TEST_CASE(scan_single_dataCorrect) {
ParserItem itemString( "ITEM1", "");
RawRecord rawRecord( "'WELL1' 'WELL2'" );
const auto deckItem = itemString.scan(rawRecord);
BOOST_CHECK_EQUAL(1U, deckItem.size());
BOOST_CHECK_EQUAL("WELL1", deckItem.get< std::string >(0));
}
BOOST_AUTO_TEST_CASE(scan_singleWithMixedRecord_dataCorrect) {
ParserItem itemString("ITEM1", "");
ParserItem itemInt("ITEM1", "");
RawRecord rawRecord( "2 'WELL1' /" );
itemInt.scan(rawRecord);
const auto deckItem = itemString.scan(rawRecord);
BOOST_CHECK_EQUAL("WELL1", deckItem.get< std::string >(0));
}
/******************String and int**********************/
BOOST_AUTO_TEST_CASE(scan_intsAndStrings_dataCorrect) {
RawRecord rawRecord( "'WELL1' 2 2 2*3" );
auto sizeTypeItemBoxed = ParserItem::item_size::ALL;
ParserItem itemSingleString(std::string("ITEM1"), "");
const auto deckItemWell1 = itemSingleString.scan(rawRecord);
BOOST_CHECK_EQUAL("WELL1", deckItemWell1.get< std::string >(0));
ParserItem itemSomeInts("SOMEINTS", sizeTypeItemBoxed, 0 );
const auto deckItemInts = itemSomeInts.scan(rawRecord);
BOOST_CHECK_EQUAL(2, deckItemInts.get< int >(0));
BOOST_CHECK_EQUAL(2, deckItemInts.get< int >(1));
BOOST_CHECK_EQUAL(3, deckItemInts.get< int >(2));
BOOST_CHECK_EQUAL(3, deckItemInts.get< int >(3));
}
/*****************************************************************/
BOOST_AUTO_TEST_CASE(ParserDefaultHasDimensionReturnsFalse) {
ParserItem intItem(std::string("SOMEINTS"), 0);
ParserItem stringItem(std::string("SOMESTRING"), "");
ParserItem doubleItem(std::string("SOMEDOUBLE"), 0.0);
BOOST_CHECK( !intItem.hasDimension() );
BOOST_CHECK( !stringItem.hasDimension() );
BOOST_CHECK( !doubleItem.hasDimension() );
}
BOOST_AUTO_TEST_CASE(ParserIntItemGetDimensionThrows) {
ParserItem intItem(std::string("SOMEINT"));
BOOST_CHECK_THROW( intItem.getDimension(0) , std::invalid_argument );
BOOST_CHECK_THROW( intItem.push_backDimension("Length") , std::invalid_argument );
}
BOOST_AUTO_TEST_CASE(ParserDoubleItemAddMultipleDimensionToSIngleSizeThrows) {
ParserItem doubleItem(std::string("SOMEDOUBLE"), 0.0);
doubleItem.push_backDimension("Length*Length");
BOOST_CHECK_THROW( doubleItem.push_backDimension("Length*Length"), std::invalid_argument);
}
BOOST_AUTO_TEST_CASE(ParserDoubleItemWithDimensionHasReturnsCorrect) {
ParserItem doubleItem("SOMEDOUBLE", 0.0);
BOOST_CHECK( !doubleItem.hasDimension() );
doubleItem.push_backDimension("Length*Length");
BOOST_CHECK( doubleItem.hasDimension() );
}
BOOST_AUTO_TEST_CASE(ParserDoubleItemGetDimension) {
ParserItem doubleItem( "SOMEDOUBLE" , ParserItem::item_size::ALL, 0.0 );
BOOST_CHECK_THROW( doubleItem.getDimension( 10 ) , std::out_of_range );
BOOST_CHECK_THROW( doubleItem.getDimension( 0 ) , std::out_of_range );
doubleItem.push_backDimension("Length");
doubleItem.push_backDimension("Length*Length");
doubleItem.push_backDimension("Length*Length*Length");
BOOST_CHECK_EQUAL( "Length" , doubleItem.getDimension(0));
BOOST_CHECK_EQUAL( "Length*Length" , doubleItem.getDimension(1));
BOOST_CHECK_EQUAL( "Length*Length*Length" , doubleItem.getDimension(2));
BOOST_CHECK_THROW( doubleItem.getDimension( 3 ) , std::out_of_range );
}

512
tests/parser/ParserKeywordTests.cpp
View File

@@ -1,512 +0,0 @@
/*
Copyright 2013 Statoil ASA.
This file is part of the Open Porous Media project (OPM).
OPM is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OPM is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with OPM. If not, see <http://www.gnu.org/licenses/>.
*/
#define BOOST_TEST_MODULE ParserTests
#include <boost/test/unit_test.hpp>
#include <opm/json/JsonObject.hpp>
#include <opm/parser/eclipse/Deck/DeckKeyword.hpp>
#include <opm/parser/eclipse/Deck/DeckRecord.hpp>
#include <opm/parser/eclipse/Parser/ParseContext.hpp>
#include <opm/parser/eclipse/Parser/ParserItem.hpp>
#include <opm/parser/eclipse/Parser/ParserKeyword.hpp>
#include <opm/parser/eclipse/Parser/ParserKeywords/A.hpp>
#include <opm/parser/eclipse/Parser/ParserRecord.hpp>
#include <opm/parser/eclipse/RawDeck/RawEnums.hpp>
#include <opm/parser/eclipse/RawDeck/RawKeyword.hpp>
#include <opm/parser/eclipse/RawDeck/RawRecord.hpp>
using namespace Opm;
namespace {
std::shared_ptr<ParserKeyword> createFixedSized(const std::string& kw , size_t size) {
std::shared_ptr<ParserKeyword> pkw = std::make_shared<ParserKeyword>(kw);
pkw->setFixedSize( size );
return pkw;
}
std::shared_ptr<ParserKeyword> createDynamicSized(const std::string& kw) {
std::shared_ptr<ParserKeyword> pkw = std::make_shared<ParserKeyword>(kw);
pkw->setSizeType(SLASH_TERMINATED);
return pkw;
}
std::shared_ptr<ParserKeyword> createTable(const std::string& name,
const std::string& sizeKeyword,
const std::string& sizeItem,
bool isTableCollection) {
std::shared_ptr<ParserKeyword> pkw = std::make_shared<ParserKeyword>(name);
pkw->initSizeKeyword(sizeKeyword , sizeItem);
pkw->setTableCollection(isTableCollection);
return pkw;
}
}
BOOST_AUTO_TEST_CASE(construct_withname_nameSet) {
const auto& parserKeyword = createDynamicSized("BPR");
BOOST_CHECK_EQUAL(parserKeyword->getName(), "BPR");
}
BOOST_AUTO_TEST_CASE(NamedInit) {
std::string keyword("KEYWORD");
const auto& parserKeyword = createFixedSized(keyword, (size_t) 100);
BOOST_CHECK_EQUAL(parserKeyword->getName(), keyword);
}
BOOST_AUTO_TEST_CASE(ParserKeyword_default_SizeTypedefault) {
std::string keyword("KEYWORD");
const auto& parserKeyword = createDynamicSized(keyword);
BOOST_CHECK_EQUAL(parserKeyword->getSizeType() , SLASH_TERMINATED);
}
BOOST_AUTO_TEST_CASE(ParserKeyword_withSize_SizeTypeFIXED) {
std::string keyword("KEYWORD");
const auto& parserKeyword = createFixedSized(keyword, (size_t) 100);
BOOST_CHECK_EQUAL(parserKeyword->getSizeType() , FIXED);
}
BOOST_AUTO_TEST_CASE(ParserKeyword_withOtherSize_SizeTypeOTHER) {
std::string keyword("KEYWORD");
const auto& parserKeyword = createTable(keyword, "EQUILDIMS" , "NTEQUIL" , false);
const std::pair<std::string,std::string>& sizeKW = parserKeyword->getSizeDefinitionPair();
BOOST_CHECK_EQUAL(OTHER_KEYWORD_IN_DECK , parserKeyword->getSizeType() );
BOOST_CHECK_EQUAL("EQUILDIMS", sizeKW.first );
BOOST_CHECK_EQUAL("NTEQUIL" , sizeKW.second );
}
BOOST_AUTO_TEST_CASE(ParserKeyword_validDeckName) {
BOOST_CHECK_EQUAL( true , ParserKeyword::validDeckName("SUMMARY"));
BOOST_CHECK_EQUAL( true , ParserKeyword::validDeckName("MixeCase"));
BOOST_CHECK_EQUAL( false , ParserKeyword::validDeckName("NAMETOOLONG"));
BOOST_CHECK_EQUAL( true , ParserKeyword::validDeckName("STRING88"));
BOOST_CHECK_EQUAL( false , ParserKeyword::validDeckName("88STRING"));
BOOST_CHECK_EQUAL( false , ParserKeyword::validDeckName("KEY.EXT"));
BOOST_CHECK_EQUAL( false , ParserKeyword::validDeckName("STRING~"));
BOOST_CHECK_EQUAL( true , ParserKeyword::validDeckName("MINUS-"));
BOOST_CHECK_EQUAL( true , ParserKeyword::validDeckName("PLUS+"));
BOOST_CHECK_EQUAL( false , ParserKeyword::validDeckName("SHARP#"));
BOOST_CHECK_EQUAL( false , ParserKeyword::validDeckName("-MINUS"));
BOOST_CHECK_EQUAL( false , ParserKeyword::validDeckName("+PLUS"));
BOOST_CHECK_EQUAL( false , ParserKeyword::validDeckName("#SHARP"));
BOOST_CHECK_EQUAL( false , ParserKeyword::validDeckName("TVDP*"));
BOOST_CHECK_EQUAL( false , ParserKeyword::validDeckName("*"));
}
BOOST_AUTO_TEST_CASE(ParserKeyword_validInternalName) {
BOOST_CHECK_EQUAL( true , ParserKeyword::validInternalName("SUMMARY"));
BOOST_CHECK_EQUAL( true , ParserKeyword::validInternalName("MixeCase"));
BOOST_CHECK_EQUAL( true , ParserKeyword::validInternalName("NAMEISQUITELONG"));
BOOST_CHECK_EQUAL( true , ParserKeyword::validInternalName("I_have_underscores"));
BOOST_CHECK_EQUAL( false , ParserKeyword::validInternalName("WHATABOUT+"));
BOOST_CHECK_EQUAL( false , ParserKeyword::validInternalName("ORMINUS-"));
BOOST_CHECK_EQUAL( false , ParserKeyword::validInternalName("NOSHARP#"));
BOOST_CHECK_EQUAL( true , ParserKeyword::validInternalName("STRING88"));
BOOST_CHECK_EQUAL( false , ParserKeyword::validInternalName("88STRING"));
BOOST_CHECK_EQUAL( false , ParserKeyword::validInternalName("KEY.EXT"));
BOOST_CHECK_EQUAL( false , ParserKeyword::validInternalName("STRING~"));
BOOST_CHECK_EQUAL( false , ParserKeyword::validInternalName("TVDP*"));
BOOST_CHECK_EQUAL( false , ParserKeyword::validInternalName("*"));
}
BOOST_AUTO_TEST_CASE(ParserKeywordMatches) {
const auto& parserKeyword = createFixedSized("HELLO", (size_t) 1);
parserKeyword->clearDeckNames();
parserKeyword->setMatchRegex("WORLD.+");
BOOST_CHECK_EQUAL( false , parserKeyword->matches("HELLO"));
BOOST_CHECK_EQUAL( false , parserKeyword->matches("WORLD"));
BOOST_CHECK_EQUAL( true , parserKeyword->matches("WORLDABC"));
BOOST_CHECK_EQUAL( false , parserKeyword->matches("WORLD#BC"));
BOOST_CHECK_EQUAL( false , parserKeyword->matches("WORLDIAMTOOLONG"));
}
BOOST_AUTO_TEST_CASE(AddDataKeyword_correctlyConfigured) {
const auto& parserKeyword = createFixedSized("PORO", (size_t) 1);
ParserItem item( "ACTNUM" , ParserItem::item_size::ALL, 0 );
ParserRecord record;
BOOST_CHECK( !parserKeyword->isDataKeyword() );
record.addDataItem( item );
parserKeyword->addRecord( record );
BOOST_CHECK( parserKeyword->isDataKeyword() );
BOOST_CHECK( parserKeyword->hasFixedSize() );
BOOST_CHECK_EQUAL(1U , parserKeyword->getFixedSize() );
}
BOOST_AUTO_TEST_CASE(WrongConstructor_addDataItem_throws) {
const auto& parserKeyword = createDynamicSized("PORO");
ParserItem dataItem( "ACTNUM" , ParserItem::item_size::ALL );
ParserRecord record;
record.addDataItem( dataItem );
BOOST_CHECK_THROW( parserKeyword->addDataRecord( record ) , std::invalid_argument);
}
BOOST_AUTO_TEST_CASE(DefaultConstructur_setDescription_canReadBack) {
const auto& parserKeyword = createDynamicSized("BPR");
std::string description("This is the description");
parserKeyword->setDescription(description);
BOOST_CHECK_EQUAL( description, parserKeyword->getDescription());
}
/*****************************************************************/
/* json */
BOOST_AUTO_TEST_CASE(ConstructFromJsonObject) {
Json::JsonObject jsonObject("{\"name\": \"XXX\", \"sections\":[], \"size\" : 0}");
const auto& parserKeyword = std::make_shared<const ParserKeyword>(jsonObject);
BOOST_CHECK_EQUAL("XXX" , parserKeyword->getName());
BOOST_CHECK_EQUAL( true , parserKeyword->hasFixedSize() );
}
BOOST_AUTO_TEST_CASE(ConstructMultiNameFromJsonObject) {
const auto jsonString =
"{"
" \"name\": \"XXX\" ,"
" \"sections\":[],"
" \"size\" : 0,"
" \"deck_names\" : ["
" \"XXA\","
" \"XXB\","
" \"XXC\""
" ]"
"}";
Json::JsonObject jsonObject(jsonString);
auto parserKeyword = std::make_shared<const ParserKeyword>(jsonObject);
BOOST_CHECK_EQUAL("XXX" , parserKeyword->getName());
BOOST_CHECK(parserKeyword->matches("XXA"));
BOOST_CHECK(parserKeyword->matches("XXB"));
BOOST_CHECK(parserKeyword->hasMultipleDeckNames());
BOOST_CHECK(!parserKeyword->matches("XXD"));
BOOST_CHECK(!parserKeyword->matches("XXX"));
}
BOOST_AUTO_TEST_CASE(ConstructFromJsonObject_withSize) {
Json::JsonObject jsonObject("{\"name\": \"BPR\", \"sections\":[\"SUMMARY\"], \"size\" : 100 , \"items\" :[{\"name\":\"ItemX\" , \"size_type\":\"SINGLE\" , \"value_type\" : \"DOUBLE\"}]}");
const auto& parserKeyword = std::make_shared<const ParserKeyword>(jsonObject);
BOOST_CHECK_EQUAL("BPR" , parserKeyword->getName());
BOOST_CHECK_EQUAL( true , parserKeyword->hasFixedSize() );
BOOST_CHECK_EQUAL( 100U , parserKeyword->getFixedSize() );
}
BOOST_AUTO_TEST_CASE(ConstructFromJsonObject_nosize_notItems_OK) {
Json::JsonObject jsonObject("{\"name\": \"BPR\", \"sections\":[\"SUMMARY\"]}");
const auto& parserKeyword = std::make_shared<const ParserKeyword>(jsonObject);
BOOST_CHECK_EQUAL( true , parserKeyword->hasFixedSize() );
BOOST_CHECK_EQUAL( 0U , parserKeyword->getFixedSize());
}
BOOST_AUTO_TEST_CASE(ConstructFromJsonObject_withSizeOther) {
Json::JsonObject jsonObject("{\"name\": \"BPR\", \"sections\":[\"SUMMARY\"], \"size\" : {\"keyword\" : \"Bjarne\" , \"item\": \"BjarneIgjen\"}, \"items\" :[{\"name\":\"ItemX\" , \"value_type\" : \"DOUBLE\"}]}");
const auto& parserKeyword = std::make_shared<const ParserKeyword>(jsonObject);
const std::pair<std::string,std::string>& sizeKW = parserKeyword->getSizeDefinitionPair();
BOOST_CHECK_EQUAL("BPR" , parserKeyword->getName());
BOOST_CHECK_EQUAL( false , parserKeyword->hasFixedSize() );
BOOST_CHECK_EQUAL(OTHER_KEYWORD_IN_DECK , parserKeyword->getSizeType());
BOOST_CHECK_EQUAL("Bjarne", sizeKW.first );
BOOST_CHECK_EQUAL("BjarneIgjen" , sizeKW.second );
}
BOOST_AUTO_TEST_CASE(ConstructFromJsonObject_missingName_throws) {
Json::JsonObject jsonObject("{\"nameXX\": \"BPR\", \"sections\":[\"SUMMARY\"], \"size\" : 100}");
BOOST_CHECK_THROW(std::make_shared<const ParserKeyword>(jsonObject) , std::invalid_argument);
}
/*
"items": [{"name" : "I" , "size_type" : "SINGLE" , "value_type" : "int"}]
*/
BOOST_AUTO_TEST_CASE(ConstructFromJsonObject_invalidItems_throws) {
Json::JsonObject jsonObject("{\"name\": \"BPR\", \"sections\":[\"SUMMARY\"], \"size\" : 100 , \"items\" : 100}");
BOOST_CHECK_THROW(std::make_shared<const ParserKeyword>(jsonObject) , std::invalid_argument);
}
BOOST_AUTO_TEST_CASE(ConstructFromJsonObject_ItemMissingName_throws) {
Json::JsonObject jsonObject("{\"name\": \"BPR\", \"sections\":[\"SUMMARY\"], \"size\" : 100 , \"items\" : [{\"nameX\" : \"I\" , \"value_type\" : \"INT\"}]}");
BOOST_CHECK_THROW(std::make_shared<const ParserKeyword>(jsonObject) , std::invalid_argument);
}
BOOST_AUTO_TEST_CASE(ConstructFromJsonObject_ItemMissingValueType_throws) {
Json::JsonObject jsonObject("{\"name\": \"BPR\", \"sections\":[\"SUMMARY\"], \"size\" : 100 , \"items\" : [{\"name\" : \"I\" , \"size_type\" : \"SINGLE\" , \"Xvalue_type\" : \"INT\"}]}");
BOOST_CHECK_THROW(std::make_shared<const ParserKeyword>(jsonObject) , std::invalid_argument);
}
BOOST_AUTO_TEST_CASE(ConstructFromJsonObject_ItemInvalidEnum_throws) {
Json::JsonObject jsonObject1("{\"name\": \"BPR\", \"sections\":[\"SUMMARY\"], \"size\" : 100 , \"items\" : [{\"name\" : \"I\" , \"size_type\" : \"XSINGLE\" , \"value_type\" : \"INT\"}]}");
Json::JsonObject jsonObject2("{\"name\": \"BPR\", \"sections\":[\"SUMMARY\"], \"size\" : 100 , \"items\" : [{\"name\" : \"I\" , \"size_type\" : \"SINGLE\" , \"value_type\" : \"INTX\"}]}");
BOOST_CHECK_THROW(std::make_shared<const ParserKeyword>(jsonObject1) , std::invalid_argument);
BOOST_CHECK_THROW(std::make_shared<const ParserKeyword>(jsonObject2) , std::invalid_argument);
}
BOOST_AUTO_TEST_CASE(ConstructFromJsonObjectItemsOK) {
Json::JsonObject jsonObject("{\"name\": \"BPR\", \"sections\":[\"SUMMARY\"], \"size\" : 100 , \"items\" : [{\"name\" : \"I\", \"value_type\" : \"INT\"}]}");
const auto& parserKeyword = std::make_shared<const ParserKeyword>(jsonObject);
const auto& record = parserKeyword->getRecord(0);
const auto& item = record.get( 0 );
BOOST_CHECK_EQUAL( 1U , record.size( ) );
BOOST_CHECK_EQUAL( "I" , item.name( ) );
BOOST_CHECK_EQUAL( ParserItem::item_size::SINGLE , item.sizeType());
}
BOOST_AUTO_TEST_CASE(ConstructFromJsonObject_sizeFromOther) {
Json::JsonObject jsonConfig("{\"name\": \"EQUILX\", \"sections\":[\"PROPS\"], \"size\" : {\"keyword\":\"EQLDIMS\" , \"item\" : \"NTEQUL\"}, \"items\" :[{\"name\":\"ItemX\" ,\"value_type\" : \"DOUBLE\"}]}");
BOOST_CHECK_NO_THROW( std::make_shared<const ParserKeyword>(jsonConfig) );
}
BOOST_AUTO_TEST_CASE(Default_NotData) {
auto parserKeyword = createDynamicSized("BPR");
BOOST_CHECK_EQUAL( false , parserKeyword->isDataKeyword());
}
BOOST_AUTO_TEST_CASE(AddDataKeywordFromJson_defaultThrows) {
Json::JsonObject jsonConfig("{\"name\": \"ACTNUM\", \"sections\":[\"GRID\"], \"data\" : {\"value_type\": \"INT\" , \"default\" : 100}}");
BOOST_CHECK_THROW( std::make_shared<const ParserKeyword>(jsonConfig) , std::invalid_argument);
}
BOOST_AUTO_TEST_CASE(AddDataKeywordFromJson_correctlyConfigured) {
Json::JsonObject jsonConfig("{\"name\": \"ACTNUM\", \"sections\":[\"GRID\"], \"data\" : {\"value_type\": \"INT\"}}");
const auto& parserKeyword = std::make_shared<const ParserKeyword>(jsonConfig);
const auto& parserRecord = parserKeyword->getRecord(0);
const auto& item = parserRecord.get(0);
BOOST_CHECK( parserKeyword->isDataKeyword() );
BOOST_CHECK( parserKeyword->hasFixedSize( ) );
BOOST_CHECK_EQUAL(1U , parserKeyword->getFixedSize() );
BOOST_CHECK_EQUAL( item.name() , ParserKeywords::ACTNUM::data::itemName );
BOOST_CHECK_EQUAL( ParserItem::item_size::ALL, item.sizeType() );
}
BOOST_AUTO_TEST_CASE(AddkeywordFromJson_numTables_incoorect_throw) {
Json::JsonObject jsonConfig("{\"name\": \"PVTG\", \"sections\":[\"PROPS\"], \"num_tables\" : 100}");
BOOST_CHECK_THROW(std::make_shared<const ParserKeyword>(jsonConfig) , std::invalid_argument);
}
BOOST_AUTO_TEST_CASE(AddkeywordFromJson_isTableCollection) {
Json::JsonObject jsonConfig("{\"name\": \"PVTG\", \"sections\":[\"PROPS\"], \"num_tables\" : {\"keyword\": \"TABDIMS\" , \"item\" : \"NTPVT\"} , \"items\" : [{\"name\" : \"data\", \"value_type\" : \"DOUBLE\"}]}");
const auto& parserKeyword = std::make_shared<const ParserKeyword>(jsonConfig);
BOOST_CHECK_EQUAL( true , parserKeyword->isTableCollection() );
BOOST_CHECK_EQUAL( false , parserKeyword->isDataKeyword());
BOOST_CHECK_EQUAL( false , parserKeyword->hasFixedSize( ));
}
BOOST_AUTO_TEST_CASE(ConstructFromJsonObject_InvalidSize_throws) {
Json::JsonObject jsonObject1("{\"name\": \"BPR\", \"sections\":[\"SUMMARY\"], \"size\" : \"string\" , \"items\" : [{\"name\" : \"I\" , \"size_type\" : \"SINGLE\" , \"value_type\" : \"INT\"}]}");
Json::JsonObject jsonObject2("{\"name\": \"BPR\", \"sections\":[\"SUMMARY\"], \"size\" : [1,2,3] , \"items\" : [{\"name\" : \"I\" , \"size_type\" : \"SINGLE\" , \"value_type\" : \"INT\"}]}");
BOOST_CHECK_THROW(std::make_shared<const ParserKeyword>(jsonObject1) , std::invalid_argument);
BOOST_CHECK_THROW(std::make_shared<const ParserKeyword>(jsonObject2) , std::invalid_argument);
}
BOOST_AUTO_TEST_CASE(ConstructFromJsonObject_SizeUNKNOWN_OK) {
Json::JsonObject jsonObject1("{\"name\": \"BPR\", \"sections\":[\"SUMMARY\"], \"size\" : \"UNKNOWN\" , \"items\" : [{\"name\" : \"I\" , \"size_type\" : \"SINGLE\" , \"value_type\" : \"INT\"}]}");
auto parserKeyword = std::make_shared<const ParserKeyword>(jsonObject1);
BOOST_CHECK_EQUAL( UNKNOWN , parserKeyword->getSizeType() );
}
BOOST_AUTO_TEST_CASE(ConstructFromJsonObject_WithDescription_DescriptionPropertyShouldBePopulated) {
Json::JsonObject jsonObject("{\"name\": \"BPR\", \"sections\":[\"SUMMARY\"], \"description\" : \"Description\"}");
auto parserKeyword = std::make_shared<const ParserKeyword>(jsonObject);
BOOST_CHECK_EQUAL( "Description", parserKeyword->getDescription() );
}
BOOST_AUTO_TEST_CASE(ConstructFromJsonObject_WithoutDescription_DescriptionPropertyShouldBeEmpty) {
Json::JsonObject jsonObject("{\"name\": \"BPR\", \"sections\":[\"SUMMARY\"]}");
auto parserKeyword = std::make_shared<const ParserKeyword>(jsonObject);
BOOST_CHECK_EQUAL( "", parserKeyword->getDescription() );
}
/* </Json> */
/*****************************************************************/
BOOST_AUTO_TEST_CASE(getFixedSize_sizeObjectHasFixedSize_sizeReturned) {
const auto& parserKeyword = createFixedSized("JA", (size_t) 3);
BOOST_CHECK_EQUAL(3U, parserKeyword->getFixedSize());
}
BOOST_AUTO_TEST_CASE(getFixedSize_sizeObjectDoesNotHaveFixedSizeObjectSet_ExceptionThrown) {
const auto& parserKeyword = createDynamicSized("JA");
BOOST_CHECK_THROW(parserKeyword->getFixedSize(), std::logic_error);
}
BOOST_AUTO_TEST_CASE(hasFixedSize_hasFixedSizeObject_returnstrue) {
const auto& parserKeyword = createFixedSized("JA", (size_t) 2);
BOOST_CHECK(parserKeyword->hasFixedSize());
}
BOOST_AUTO_TEST_CASE(hasFixedSize_sizeObjectDoesNotHaveFixedSize_returnsfalse) {
const auto& parserKeyword = createDynamicSized("JA");
BOOST_CHECK(!parserKeyword->hasFixedSize());
}
/******/
/* Tables: */
BOOST_AUTO_TEST_CASE(DefaultIsNot_TableKeyword) {
const auto& parserKeyword = createDynamicSized("JA");
BOOST_CHECK(!parserKeyword->isTableCollection());
}
BOOST_AUTO_TEST_CASE(ConstructorIsTableCollection) {
const auto& parserKeyword = createTable("JA" , "TABDIMS" , "NTPVT" , true);
const std::pair<std::string,std::string>& sizeKW = parserKeyword->getSizeDefinitionPair();
BOOST_CHECK(parserKeyword->isTableCollection());
BOOST_CHECK(!parserKeyword->hasFixedSize());
BOOST_CHECK_EQUAL( parserKeyword->getSizeType() , OTHER_KEYWORD_IN_DECK);
BOOST_CHECK_EQUAL("TABDIMS", sizeKW.first );
BOOST_CHECK_EQUAL("NTPVT" , sizeKW.second );
}
BOOST_AUTO_TEST_CASE(ParseEmptyRecord) {
const auto& tabdimsKeyword = createFixedSized("TEST" , 1);
ParserRecord record;
ParserItem item("ITEM", ParserItem::item_size::ALL );
item.setType( int() );
auto rawkeyword = std::make_shared< RawKeyword >( tabdimsKeyword->getName() , "FILE" , 10U , 1 );
ParseContext parseContext;
MessageContainer msgContainer;
BOOST_CHECK_EQUAL( Raw::FIXED , rawkeyword->getSizeType());
rawkeyword->addRawRecordString("/");
record.addItem(item);
tabdimsKeyword->addRecord( record );
const auto deckKeyword = tabdimsKeyword->parse( parseContext , msgContainer, rawkeyword );
BOOST_REQUIRE_EQUAL( 1U , deckKeyword.size());
const auto& deckRecord = deckKeyword.getRecord(0);
BOOST_REQUIRE_EQUAL( 1U , deckRecord.size());
BOOST_CHECK_EQUAL(0U , deckRecord.getItem( 0 ).size());
}
/*****************************************************************/
/* Dimension */
BOOST_AUTO_TEST_CASE(ParseKeywordHasDimensionCorrect) {
const auto& parserKeyword = createDynamicSized("JA");
ParserItem item1("I", ParserItem::item_size::SINGLE, 0 );
ParserItem item2("ID", ParserItem::item_size::SINGLE, 0.0 );
ParserRecord record;
BOOST_CHECK( !parserKeyword->hasDimension());
record.addItem( item1 );
parserKeyword->addRecord( record );
BOOST_CHECK( !parserKeyword->hasDimension() );
BOOST_CHECK_EQUAL( 0U , item1.numDimensions() );
item2.push_backDimension("Length*Length/Time");
record.addItem( item2 );
const auto& parserKeyword2 = createDynamicSized("JA");
parserKeyword2->addRecord( record );
BOOST_CHECK( parserKeyword2->hasDimension() );
BOOST_CHECK_EQUAL( 1U , item2.numDimensions() );
}
BOOST_AUTO_TEST_CASE(ConstructFromJsonObject_withDimension) {
Json::JsonObject jsonObject("{\"name\": \"BPR\", \"sections\":[\"SUMMARY\"], \"size\" : 100 , \"items\" :[{\"name\":\"ItemX\" , \"size_type\":\"SINGLE\" , \"value_type\" : \"DOUBLE\" , \"dimension\" : \"Length*Length/Time\"}]}");
const auto& parserKeyword = std::make_shared<ParserKeyword>(jsonObject);
const auto& record = parserKeyword->getRecord(0);
const auto& item = record.get("ItemX");
BOOST_CHECK_EQUAL("BPR" , parserKeyword->getName());
BOOST_CHECK( parserKeyword->hasFixedSize() );
BOOST_CHECK_EQUAL( 100U , parserKeyword->getFixedSize() );
BOOST_CHECK( parserKeyword->hasDimension() );
BOOST_CHECK( item.hasDimension() );
BOOST_CHECK_EQUAL( 1U , item.numDimensions() );
}
BOOST_AUTO_TEST_CASE(ConstructFromJsonObject_withDimensionList) {
Json::JsonObject jsonObject("{\"name\": \"BPR\", \"sections\":[\"SUMMARY\"], \"size\" : 100 , \"items\" :[{\"name\":\"ItemX\" , \"size_type\":\"ALL\" , \"value_type\" : \"DOUBLE\" , \"dimension\" : [\"Length*Length/Time\" , \"Time\", \"1\"]}]}");
const auto& parserKeyword = std::make_shared<ParserKeyword>(jsonObject);
const auto& record = parserKeyword->getRecord(0);
const auto& item = record.get("ItemX");
BOOST_CHECK_EQUAL("BPR" , parserKeyword->getName());
BOOST_CHECK_EQUAL( true , parserKeyword->hasFixedSize() );
BOOST_CHECK_EQUAL( 100U , parserKeyword->getFixedSize() );
BOOST_CHECK( parserKeyword->hasDimension() );
BOOST_CHECK( item.hasDimension() );
BOOST_CHECK_EQUAL( 3U , item.numDimensions() );
}
BOOST_AUTO_TEST_CASE(ConstructFromJson_withRecords) {
const std::string json_string1 = "{\"name\" : \"MULTFLT\", \"sections\" : [\"GRID\", \"EDIT\", \"SCHEDULE\"], \"records\" : [["
"{\"name\" : \"fault\" , \"value_type\" : \"STRING\"},"
"{\"name\" : \"factor\" , \"value_type\" : \"DOUBLE\"}]]}";
const std::string json_string2 = "{\"name\" : \"MULTFLT\", \"sections\" : [\"GRID\", \"EDIT\", \"SCHEDULE\"], \"items\" : ["
"{\"name\" : \"fault\" , \"value_type\" : \"STRING\"},"
"{\"name\" : \"factor\" , \"value_type\" : \"DOUBLE\"}]}";
Json::JsonObject jsonObject1( json_string1 );
Json::JsonObject jsonObject2( json_string2 );
auto kw1 = std::make_shared<ParserKeyword>( jsonObject1 );
auto kw2 = std::make_shared<ParserKeyword>( jsonObject2 );
BOOST_CHECK_EQUAL( *kw1, *kw2 );
}
BOOST_AUTO_TEST_CASE(ConstructFromJson_withRecords_and_items_throws) {
const std::string json_string = "{\"name\" : \"MULTFLT\", \"sections\" : [\"GRID\", \"EDIT\", \"SCHEDULE\"], \"records\" : [["
"{\"name\" : \"fault\" , \"value_type\" : \"STRING\"},"
"{\"name\" : \"factor\" , \"value_type\" : \"DOUBLE\"}]],\"items\" : ["
"{\"name\" : \"fault\" , \"value_type\" : \"STRING\"},"
"{\"name\" : \"factor\" , \"value_type\" : \"DOUBLE\"}]}";
Json::JsonObject jsonObject( json_string );
BOOST_CHECK_THROW( std::make_shared<const ParserKeyword>( jsonObject ) , std::invalid_argument);
}
BOOST_AUTO_TEST_CASE(Create1Arg) {
ParserKeyword kw("GRID");
BOOST_CHECK_EQUAL( false , kw.hasDimension() );
BOOST_CHECK( kw.hasFixedSize() );
BOOST_CHECK_EQUAL( kw.getFixedSize( ) , 0 );
BOOST_CHECK_THROW( kw.getRecord( 0 ) , std::invalid_argument );
}

373
tests/parser/ParserRecordTests.cpp
View File

@@ -1,373 +0,0 @@
/*
Copyright 2013 Statoil ASA.
This file is part of the Open Porous Media project (OPM).
OPM is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OPM is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with OPM. If not, see <http://www.gnu.org/licenses/>.
*/
#define BOOST_TEST_MODULE ParserTests
#include <boost/test/unit_test.hpp>
#include <opm/parser/eclipse/Deck/DeckRecord.hpp>
#include <opm/parser/eclipse/Parser/ParseContext.hpp>
#include <opm/parser/eclipse/Parser/ParserEnums.hpp>
#include <opm/parser/eclipse/Parser/ParserRecord.hpp>
#include <opm/parser/eclipse/Parser/ParserItem.hpp>
#include <opm/parser/eclipse/RawDeck/RawRecord.hpp>
#include <boost/test/test_tools.hpp>
#include "opm/parser/eclipse/RawDeck/RawKeyword.hpp"
#include "opm/parser/eclipse/Parser/ParserKeyword.hpp"
using namespace Opm;
const static auto SINGLE = ParserItem::item_size::SINGLE;
const static auto ALL = ParserItem::item_size::ALL;
BOOST_AUTO_TEST_CASE(DefaultConstructor_NoParams_NoThrow) {
BOOST_CHECK_NO_THROW(ParserRecord record);
}
BOOST_AUTO_TEST_CASE(Size_NoElements_ReturnsZero) {
ParserRecord record;
BOOST_CHECK_EQUAL(0U, record.size());
}
BOOST_AUTO_TEST_CASE(Size_OneItem_Return1) {
ParserItem itemInt("ITEM1", SINGLE );
ParserRecord record;
record.addItem(itemInt);
BOOST_CHECK_EQUAL(1U, record.size());
}
BOOST_AUTO_TEST_CASE(Get_OneItem_Return1) {
ParserItem itemInt("ITEM1", SINGLE);
ParserRecord record;
record.addItem(itemInt);
BOOST_CHECK_EQUAL(record.get(0), itemInt);
}
BOOST_AUTO_TEST_CASE(Get_outOfRange_Throw) {
BOOST_CHECK_THROW(ParserRecord{}.get(0), std::out_of_range);
}
BOOST_AUTO_TEST_CASE(Get_KeyNotFound_Throw) {
ParserRecord record;
BOOST_CHECK_THROW(record.get("Hei"), std::out_of_range );
}
BOOST_AUTO_TEST_CASE(Get_KeyFound_OK) {
ParserItem itemInt("ITEM1", SINGLE );
ParserRecord record;
record.addItem(itemInt);
BOOST_CHECK_EQUAL(record.get("ITEM1"), itemInt);
}
BOOST_AUTO_TEST_CASE(Get_GetByNameAndIndex_OK) {
ParserItem itemInt("ITEM1", SINGLE);
ParserRecord record;
record.addItem(itemInt);
const auto& itemByName = record.get("ITEM1");
const auto& itemByIndex = record.get(0);
BOOST_CHECK_EQUAL(itemInt, itemByName);
BOOST_CHECK_EQUAL(itemInt, itemByIndex);
}
BOOST_AUTO_TEST_CASE(addItem_SameName_Throw) {
ParserItem itemInt1("ITEM1", SINGLE);
ParserItem itemInt2("ITEM1", SINGLE);
ParserRecord record;
record.addItem(itemInt1);
BOOST_CHECK_THROW(record.addItem(itemInt2), std::invalid_argument);
}
static ParserRecord createSimpleParserRecord() {
ParserItem itemInt1("ITEM1", SINGLE, 0 );
ParserItem itemInt2("ITEM2", SINGLE, 0 );
ParserRecord record;
record.addItem(itemInt1);
record.addItem(itemInt2);
return record;
}
BOOST_AUTO_TEST_CASE(parse_validRecord_noThrow) {
auto record = createSimpleParserRecord();
ParseContext parseContext;
RawRecord raw( string_view( "100 443" ) );
MessageContainer msgContainer;
BOOST_CHECK_NO_THROW(record.parse(parseContext, msgContainer, raw ) );
}
BOOST_AUTO_TEST_CASE(parse_validRecord_deckRecordCreated) {
auto record = createSimpleParserRecord();
RawRecord rawRecord( string_view( "100 443" ) );
ParseContext parseContext;
MessageContainer msgContainer;
const auto deckRecord = record.parse(parseContext , msgContainer, rawRecord);
BOOST_CHECK_EQUAL(2U, deckRecord.size());
}
// INT INT DOUBLE DOUBLE INT DOUBLE
static ParserRecord createMixedParserRecord() {
auto sizeType = SINGLE;
ParserItem itemInt1( "INTITEM1", sizeType, 0 );
ParserItem itemInt2( "INTITEM2", sizeType, 0 );
ParserItem itemInt3( "INTITEM3", sizeType, 0 );
ParserItem itemDouble1( "DOUBLEITEM1", sizeType, 0.0 );
ParserItem itemDouble2( "DOUBLEITEM2", sizeType, 0.0 );
ParserItem itemDouble3( "DOUBLEITEM3", sizeType, 0.0 );
ParserRecord record;
record.addItem(itemInt1);
record.addItem(itemInt2);
record.addItem(itemDouble1);
record.addItem(itemDouble2);
record.addItem(itemInt3);
record.addItem(itemDouble3);
return record;
}
BOOST_AUTO_TEST_CASE(parse_validMixedRecord_noThrow) {
auto record = createMixedParserRecord();
RawRecord rawRecord( string_view( "1 2 10.0 20.0 4 90.0") );
ParseContext parseContext;
MessageContainer msgContainer;
BOOST_CHECK_NO_THROW(record.parse(parseContext , msgContainer, rawRecord));
}
BOOST_AUTO_TEST_CASE(Equal_Equal_ReturnsTrue) {
auto record1 = createMixedParserRecord();
auto record2 = createMixedParserRecord();
BOOST_CHECK(record1.equal(record1));
BOOST_CHECK(record1.equal(record2));
}
BOOST_AUTO_TEST_CASE(Equal_Different_ReturnsFalse) {
auto sizeType = SINGLE;
ParserItem itemInt( "INTITEM1", sizeType, 0 );
ParserItem itemDouble( "DOUBLEITEM1", sizeType, 0.0 );
ParserItem itemString( "STRINGITEM1", sizeType, "" );
ParserRecord record1;
ParserRecord record2;
ParserRecord record3;
record1.addItem(itemInt);
record1.addItem(itemDouble);
record2.addItem(itemInt);
record2.addItem(itemDouble);
record2.addItem(itemString);
record3.addItem(itemDouble);
record3.addItem(itemInt);
BOOST_CHECK(!record1.equal(record2));
BOOST_CHECK(!record1.equal(record3));
}
BOOST_AUTO_TEST_CASE(ParseWithDefault_defaultAppliedCorrectInDeck) {
ParserRecord parserRecord;
ParserItem itemInt("ITEM1", SINGLE , 100 );
ParserItem itemString("ITEM2", SINGLE , "DEFAULT" );
ParserItem itemDouble("ITEM3", SINGLE , 3.14 );
parserRecord.addItem(itemInt);
parserRecord.addItem(itemString);
parserRecord.addItem(itemDouble);
// according to the RM, this is invalid ("an asterisk by itself is not sufficient"),
// but it seems to appear in the wild. Thus, we interpret this as "1*"...
{
RawRecord rawRecord( "* " );
const auto& deckStringItem = itemString.scan(rawRecord);
const auto& deckIntItem = itemInt.scan(rawRecord);
const auto& deckDoubleItem = itemDouble.scan(rawRecord);
BOOST_CHECK(deckStringItem.size() == 1);
BOOST_CHECK(deckIntItem.size() == 1);
BOOST_CHECK(deckDoubleItem.size() == 1);
BOOST_CHECK(deckStringItem.defaultApplied(0));
BOOST_CHECK(deckIntItem.defaultApplied(0));
BOOST_CHECK(deckDoubleItem.defaultApplied(0));
}
{
RawRecord rawRecord( "" );
const auto deckStringItem = itemString.scan(rawRecord);
const auto deckIntItem = itemInt.scan(rawRecord);
const auto deckDoubleItem = itemDouble.scan(rawRecord);
BOOST_CHECK_EQUAL(deckStringItem.size(), 1);
BOOST_CHECK_EQUAL(deckIntItem.size(), 1);
BOOST_CHECK_EQUAL(deckDoubleItem.size(), 1);
BOOST_CHECK(deckStringItem.defaultApplied(0));
BOOST_CHECK(deckIntItem.defaultApplied(0));
BOOST_CHECK(deckDoubleItem.defaultApplied(0));
}
{
RawRecord rawRecord( "TRYGVE 10 2.9 " );
// let the raw record be "consumed" by the items. Note that the scan() method
// modifies the rawRecord object!
const auto& deckStringItem = itemString.scan(rawRecord);
const auto& deckIntItem = itemInt.scan(rawRecord);
const auto& deckDoubleItem = itemDouble.scan(rawRecord);
BOOST_CHECK_EQUAL(deckStringItem.size(), 1);
BOOST_CHECK_EQUAL(deckIntItem.size(), 1);
BOOST_CHECK_EQUAL(deckDoubleItem.size(), 1);
BOOST_CHECK(!deckStringItem.defaultApplied(0));
BOOST_CHECK(!deckIntItem.defaultApplied(0));
BOOST_CHECK(!deckDoubleItem.defaultApplied(0));
}
// again this is invalid according to the RM, but it is used anyway in the wild...
{
RawRecord rawRecord( "* * *" );
const auto deckStringItem = itemString.scan(rawRecord);
const auto deckIntItem = itemInt.scan(rawRecord);
const auto deckDoubleItem = itemDouble.scan(rawRecord);
BOOST_CHECK_EQUAL(deckStringItem.size(), 1);
BOOST_CHECK_EQUAL(deckIntItem.size(), 1);
BOOST_CHECK_EQUAL(deckDoubleItem.size(), 1);
BOOST_CHECK(deckStringItem.defaultApplied(0));
BOOST_CHECK(deckIntItem.defaultApplied(0));
BOOST_CHECK(deckDoubleItem.defaultApplied(0));
}
{
RawRecord rawRecord( "3*" );
const auto deckStringItem = itemString.scan(rawRecord);
const auto deckIntItem = itemInt.scan(rawRecord);
const auto deckDoubleItem = itemDouble.scan(rawRecord);
BOOST_CHECK_EQUAL(deckStringItem.size(), 1);
BOOST_CHECK_EQUAL(deckIntItem.size(), 1);
BOOST_CHECK_EQUAL(deckDoubleItem.size(), 1);
BOOST_CHECK(deckStringItem.defaultApplied(0));
BOOST_CHECK(deckIntItem.defaultApplied(0));
BOOST_CHECK(deckDoubleItem.defaultApplied(0));
}
}
BOOST_AUTO_TEST_CASE(Parse_RawRecordTooManyItems_Throws) {
ParserRecord parserRecord;
ParserItem itemI( "I", SINGLE, 0 );
ParserItem itemJ( "J", SINGLE, 0 );
ParserItem itemK( "K", SINGLE, 0 );
ParseContext parseContext;
parserRecord.addItem(itemI);
parserRecord.addItem(itemJ);
parserRecord.addItem(itemK);
RawRecord rawRecord( "3 3 3 " );
MessageContainer msgContainer;
BOOST_CHECK_NO_THROW(parserRecord.parse(parseContext , msgContainer, rawRecord));
RawRecord rawRecordOneExtra( "3 3 3 4 " );
BOOST_CHECK_THROW(parserRecord.parse(parseContext , msgContainer, rawRecordOneExtra), std::invalid_argument);
RawRecord rawRecordForgotRecordTerminator( "3 3 3 \n 4 4 4 " );
BOOST_CHECK_THROW(parserRecord.parse(parseContext , msgContainer, rawRecordForgotRecordTerminator), std::invalid_argument);
}
BOOST_AUTO_TEST_CASE(Parse_RawRecordTooFewItems) {
ParserRecord parserRecord;
ParserItem itemI( "I", SINGLE );
ParserItem itemJ( "J", SINGLE );
ParserItem itemK( "K", SINGLE );
itemI.setType( int() );
itemJ.setType( int() );
itemK.setType( int() );
parserRecord.addItem(itemI);
parserRecord.addItem(itemJ);
parserRecord.addItem(itemK);
ParseContext parseContext;
RawRecord rawRecord( "3 3 " );
// no default specified for the third item, record can be parsed just fine but trying
// to access the data will raise an exception...
MessageContainer msgContainer;
BOOST_CHECK_NO_THROW(parserRecord.parse(parseContext , msgContainer, rawRecord));
auto record = parserRecord.parse(parseContext , msgContainer, rawRecord);
BOOST_CHECK_NO_THROW(record.getItem(2));
BOOST_CHECK_THROW(record.getItem(2).get< int >(0), std::out_of_range);
}
BOOST_AUTO_TEST_CASE(ParseRecordHasDimensionCorrect) {
ParserRecord parserRecord;
ParserItem itemI( "I", SINGLE, 0.0 );
BOOST_CHECK( !parserRecord.hasDimension() );
parserRecord.addItem( itemI );
BOOST_CHECK( !parserRecord.hasDimension() );
ParserItem item2( "ID", SINGLE, 0.0 );
item2.push_backDimension("Length*Length/Time");
parserRecord.addItem( item2 );
BOOST_CHECK( parserRecord.hasDimension() );
}
BOOST_AUTO_TEST_CASE(DefaultNotDataRecord) {
ParserRecord record;
BOOST_CHECK_EQUAL( false , record.isDataRecord() );
}
BOOST_AUTO_TEST_CASE(MixingDataAndItems_throws1) {
ParserRecord record;
ParserItem dataItem( "ACTNUM" , ALL );
ParserItem item ( "XXX" , ALL );
record.addDataItem( dataItem );
BOOST_CHECK_THROW( record.addItem( item ) , std::invalid_argument);
BOOST_CHECK_THROW( record.addItem( dataItem ) , std::invalid_argument);
}
BOOST_AUTO_TEST_CASE(MixingDataAndItems_throws2) {
ParserRecord record;
ParserItem dataItem( "ACTNUM" , ALL);
ParserItem item ( "XXX" , ALL);
record.addItem( item );
BOOST_CHECK_THROW( record.addDataItem( dataItem ) , std::invalid_argument);
}

1478
tests/parser/ParserTests.cpp
View File

File diff suppressed because it is too large Load Diff

72
tests/parser/RawKeywordTests.cpp
View File

@@ -191,3 +191,75 @@ BOOST_AUTO_TEST_CASE(isUnknownSize) {
BOOST_CHECK_EQUAL( Raw::UNKNOWN , keyword.getSizeType( ));
}
BOOST_AUTO_TEST_CASE(RawRecordGetRecordsCorrectElementsReturned) {
Opm::RawRecord record(" 'NODIR ' 'REVERS' 1 20 ");
BOOST_CHECK_EQUAL((unsigned) 4, record.size());
BOOST_CHECK_EQUAL("'NODIR '", record.getItem(0));
BOOST_CHECK_EQUAL("'REVERS'", record.getItem(1));
BOOST_CHECK_EQUAL("1", record.getItem(2));
BOOST_CHECK_EQUAL("20", record.getItem(3));
}
BOOST_AUTO_TEST_CASE(RawRecordIsCompleteRecordCompleteRecordReturnsTrue) {
bool isComplete = Opm::RawRecord::isTerminatedRecordString("'NODIR ' 'REVERS' 1 20 /");
BOOST_CHECK_EQUAL(true, isComplete);
}
BOOST_AUTO_TEST_CASE(RawRecordIsCompleteRecordInCompleteRecordReturnsFalse) {
bool isComplete = Opm::RawRecord::isTerminatedRecordString("'NODIR ' 'REVERS' 1 20 ");
BOOST_CHECK_EQUAL(false, isComplete);
}
BOOST_AUTO_TEST_CASE(Rawrecord_OperatorThis_OK) {
Opm::RawRecord record(" 'NODIR ' 'REVERS' 1 20 ");
BOOST_CHECK_EQUAL("'NODIR '", record.getItem(0));
BOOST_CHECK_EQUAL("'REVERS'", record.getItem(1));
BOOST_CHECK_EQUAL("1", record.getItem(2));
BOOST_CHECK_EQUAL("20", record.getItem(3));
BOOST_CHECK_THROW(record.getItem(4), std::out_of_range);
}
BOOST_AUTO_TEST_CASE(Rawrecord_PushFront_OK) {
Opm::RawRecord record(" 'NODIR ' 'REVERS' 1 20 ");
record.prepend( 1, "String2" );
record.prepend( 1, "String1" );
BOOST_CHECK_EQUAL("String1", record.getItem(0));
BOOST_CHECK_EQUAL("String2", record.getItem(1));
}
BOOST_AUTO_TEST_CASE(Rawrecord_size_OK) {
Opm::RawRecord record(" 'NODIR ' 'REVERS' 1 20 ");
BOOST_CHECK_EQUAL(4U, record.size());
record.prepend( 1, "String2");
record.prepend( 1, "String1");
BOOST_CHECK_EQUAL(6U, record.size());
}
BOOST_AUTO_TEST_CASE(Rawrecord_sizeEmpty_OK) {
Opm::RawRecord record("");
BOOST_CHECK_EQUAL(0U, record.size());
}
BOOST_AUTO_TEST_CASE(Rawrecord_spaceOnlyEmpty_OK) {
Opm::RawRecord record(" ");
BOOST_CHECK_EQUAL(0U, record.size());
}
BOOST_AUTO_TEST_CASE(Rawrecord_noFileAndKeywordGiven_EmptyStringUsed) {
Opm::RawRecord record("32 33 ");
BOOST_CHECK_EQUAL("", record.getKeywordName());
BOOST_CHECK_EQUAL("", record.getFileName());
}
BOOST_AUTO_TEST_CASE(Rawrecord_FileAndKeywordGiven_CorrectStringsReturned) {
const std::string fileName = "/this/is/it";
const std::string keywordName = "KEYWD";
Opm::RawRecord record("32 33 ", fileName, keywordName);
BOOST_CHECK_EQUAL(keywordName, record.getKeywordName());
BOOST_CHECK_EQUAL(fileName, record.getFileName());
}

97
tests/parser/RawRecordTests.cpp
View File

@@ -1,97 +0,0 @@
/*
Copyright 2013 Statoil ASA.
This file is part of the Open Porous Media project (OPM).
OPM is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OPM is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with OPM. If not, see <http://www.gnu.org/licenses/>.
*/
#define BOOST_TEST_MODULE ParserTests
#include <stdexcept>
#include <boost/test/unit_test.hpp>
#include <opm/parser/eclipse/RawDeck/RawRecord.hpp>
BOOST_AUTO_TEST_CASE(RawRecordGetRecordsCorrectElementsReturned) {
Opm::RawRecord record(" 'NODIR ' 'REVERS' 1 20 ");
BOOST_CHECK_EQUAL((unsigned) 4, record.size());
BOOST_CHECK_EQUAL("'NODIR '", record.getItem(0));
BOOST_CHECK_EQUAL("'REVERS'", record.getItem(1));
BOOST_CHECK_EQUAL("1", record.getItem(2));
BOOST_CHECK_EQUAL("20", record.getItem(3));
}
BOOST_AUTO_TEST_CASE(RawRecordIsCompleteRecordCompleteRecordReturnsTrue) {
bool isComplete = Opm::RawRecord::isTerminatedRecordString("'NODIR ' 'REVERS' 1 20 /");
BOOST_CHECK_EQUAL(true, isComplete);
}
BOOST_AUTO_TEST_CASE(RawRecordIsCompleteRecordInCompleteRecordReturnsFalse) {
bool isComplete = Opm::RawRecord::isTerminatedRecordString("'NODIR ' 'REVERS' 1 20 ");
BOOST_CHECK_EQUAL(false, isComplete);
}
BOOST_AUTO_TEST_CASE(Rawrecord_OperatorThis_OK) {
Opm::RawRecord record(" 'NODIR ' 'REVERS' 1 20 ");
BOOST_CHECK_EQUAL("'NODIR '", record.getItem(0));
BOOST_CHECK_EQUAL("'REVERS'", record.getItem(1));
BOOST_CHECK_EQUAL("1", record.getItem(2));
BOOST_CHECK_EQUAL("20", record.getItem(3));
BOOST_CHECK_THROW(record.getItem(4), std::out_of_range);
}
BOOST_AUTO_TEST_CASE(Rawrecord_PushFront_OK) {
Opm::RawRecord record(" 'NODIR ' 'REVERS' 1 20 ");
record.prepend( 1, "String2" );
record.prepend( 1, "String1" );
BOOST_CHECK_EQUAL("String1", record.getItem(0));
BOOST_CHECK_EQUAL("String2", record.getItem(1));
}
BOOST_AUTO_TEST_CASE(Rawrecord_size_OK) {
Opm::RawRecord record(" 'NODIR ' 'REVERS' 1 20 ");
BOOST_CHECK_EQUAL(4U, record.size());
record.prepend( 1, "String2");
record.prepend( 1, "String1");
BOOST_CHECK_EQUAL(6U, record.size());
}
BOOST_AUTO_TEST_CASE(Rawrecord_sizeEmpty_OK) {
Opm::RawRecord record("");
BOOST_CHECK_EQUAL(0U, record.size());
}
BOOST_AUTO_TEST_CASE(Rawrecord_spaceOnlyEmpty_OK) {
Opm::RawRecord record(" ");
BOOST_CHECK_EQUAL(0U, record.size());
}
BOOST_AUTO_TEST_CASE(Rawrecord_noFileAndKeywordGiven_EmptyStringUsed) {
Opm::RawRecord record("32 33 ");
BOOST_CHECK_EQUAL("", record.getKeywordName());
BOOST_CHECK_EQUAL("", record.getFileName());
}
BOOST_AUTO_TEST_CASE(Rawrecord_FileAndKeywordGiven_CorrectStringsReturned) {
const std::string fileName = "/this/is/it";
const std::string keywordName = "KEYWD";
Opm::RawRecord record("32 33 ", fileName, keywordName);
BOOST_CHECK_EQUAL(keywordName, record.getKeywordName());
BOOST_CHECK_EQUAL(fileName, record.getFileName());
}

433
tests/parser/ScheduleEnumTests.cpp
View File

@@ -1,433 +0,0 @@
/*
Copyright 2013 Statoil ASA.
This file is part of the Open Porous Media project (OPM).
OPM is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OPM is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with OPM. If not, see <http://www.gnu.org/licenses/>.
*/
#define BOOST_TEST_MODULE ParserEnumTests
#include <boost/test/unit_test.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/ScheduleEnums.hpp>
using namespace Opm;
BOOST_AUTO_TEST_CASE(TestCompletionStateEnum2String) {
BOOST_CHECK_EQUAL( "AUTO" , WellCompletion::StateEnum2String(WellCompletion::AUTO));
BOOST_CHECK_EQUAL( "OPEN" , WellCompletion::StateEnum2String(WellCompletion::OPEN));
BOOST_CHECK_EQUAL( "SHUT" , WellCompletion::StateEnum2String(WellCompletion::SHUT));
}
BOOST_AUTO_TEST_CASE(TestCompletionStateEnumFromString) {
BOOST_CHECK_THROW( WellCompletion::StateEnumFromString("XXX") , std::invalid_argument );
BOOST_CHECK_EQUAL( WellCompletion::AUTO , WellCompletion::StateEnumFromString("AUTO"));
BOOST_CHECK_EQUAL( WellCompletion::SHUT , WellCompletion::StateEnumFromString("SHUT"));
BOOST_CHECK_EQUAL( WellCompletion::SHUT , WellCompletion::StateEnumFromString("STOP"));
BOOST_CHECK_EQUAL( WellCompletion::OPEN , WellCompletion::StateEnumFromString("OPEN"));
}
BOOST_AUTO_TEST_CASE(TestCompletionStateEnumLoop) {
BOOST_CHECK_EQUAL( WellCompletion::AUTO , WellCompletion::StateEnumFromString( WellCompletion::StateEnum2String( WellCompletion::AUTO ) ));
BOOST_CHECK_EQUAL( WellCompletion::SHUT , WellCompletion::StateEnumFromString( WellCompletion::StateEnum2String( WellCompletion::SHUT ) ));
BOOST_CHECK_EQUAL( WellCompletion::OPEN , WellCompletion::StateEnumFromString( WellCompletion::StateEnum2String( WellCompletion::OPEN ) ));
BOOST_CHECK_EQUAL( "AUTO" , WellCompletion::StateEnum2String(WellCompletion::StateEnumFromString( "AUTO" ) ));
BOOST_CHECK_EQUAL( "OPEN" , WellCompletion::StateEnum2String(WellCompletion::StateEnumFromString( "OPEN" ) ));
BOOST_CHECK_EQUAL( "SHUT" , WellCompletion::StateEnum2String(WellCompletion::StateEnumFromString( "SHUT" ) ));
}
/*****************************************************************/
BOOST_AUTO_TEST_CASE(TestCompletionDirectionEnum2String)
{
using namespace WellCompletion;
BOOST_CHECK_EQUAL("X", DirectionEnum2String(DirectionEnum::X));
BOOST_CHECK_EQUAL("Y", DirectionEnum2String(DirectionEnum::Y));
BOOST_CHECK_EQUAL("Z", DirectionEnum2String(DirectionEnum::Z));
}
BOOST_AUTO_TEST_CASE(TestCompletionDirectionEnumFromString)
{
using namespace WellCompletion;
BOOST_CHECK_THROW(DirectionEnumFromString("XXX"), std::invalid_argument);
BOOST_CHECK_EQUAL(DirectionEnum::X, DirectionEnumFromString("X"));
BOOST_CHECK_EQUAL(DirectionEnum::Y, DirectionEnumFromString("Y"));
BOOST_CHECK_EQUAL(DirectionEnum::Z, DirectionEnumFromString("Z"));
}
BOOST_AUTO_TEST_CASE(TestCompletionDirectionEnumLoop)
{
using namespace WellCompletion;
BOOST_CHECK_EQUAL(DirectionEnum::X, DirectionEnumFromString(DirectionEnum2String(DirectionEnum::X)));
BOOST_CHECK_EQUAL(DirectionEnum::Y, DirectionEnumFromString(DirectionEnum2String(DirectionEnum::Y)));
BOOST_CHECK_EQUAL(DirectionEnum::Z, DirectionEnumFromString(DirectionEnum2String(DirectionEnum::Z)));
BOOST_CHECK_EQUAL("X", DirectionEnum2String(DirectionEnumFromString("X")));
BOOST_CHECK_EQUAL("Y", DirectionEnum2String(DirectionEnumFromString("Y")));
BOOST_CHECK_EQUAL("Z", DirectionEnum2String(DirectionEnumFromString("Z")));
}
/*****************************************************************/
BOOST_AUTO_TEST_CASE(TestGroupInjectionControlEnum2String) {
BOOST_CHECK_EQUAL( "NONE" , GroupInjection::ControlEnum2String(GroupInjection::NONE));
BOOST_CHECK_EQUAL( "RATE" , GroupInjection::ControlEnum2String(GroupInjection::RATE));
BOOST_CHECK_EQUAL( "RESV" , GroupInjection::ControlEnum2String(GroupInjection::RESV));
BOOST_CHECK_EQUAL( "REIN" , GroupInjection::ControlEnum2String(GroupInjection::REIN));
BOOST_CHECK_EQUAL( "VREP" , GroupInjection::ControlEnum2String(GroupInjection::VREP));
BOOST_CHECK_EQUAL( "FLD" , GroupInjection::ControlEnum2String(GroupInjection::FLD));
}
BOOST_AUTO_TEST_CASE(TestGroupInjectionControlEnumFromString) {
BOOST_CHECK_THROW( GroupInjection::ControlEnumFromString("XXX") , std::invalid_argument );
BOOST_CHECK_EQUAL( GroupInjection::NONE , GroupInjection::ControlEnumFromString("NONE"));
BOOST_CHECK_EQUAL( GroupInjection::RATE , GroupInjection::ControlEnumFromString("RATE"));
BOOST_CHECK_EQUAL( GroupInjection::RESV , GroupInjection::ControlEnumFromString("RESV"));
BOOST_CHECK_EQUAL( GroupInjection::REIN , GroupInjection::ControlEnumFromString("REIN"));
BOOST_CHECK_EQUAL( GroupInjection::VREP , GroupInjection::ControlEnumFromString("VREP"));
BOOST_CHECK_EQUAL( GroupInjection::FLD , GroupInjection::ControlEnumFromString("FLD"));
}
BOOST_AUTO_TEST_CASE(TestGroupInjectionControlEnumLoop) {
BOOST_CHECK_EQUAL( GroupInjection::NONE , GroupInjection::ControlEnumFromString( GroupInjection::ControlEnum2String( GroupInjection::NONE ) ));
BOOST_CHECK_EQUAL( GroupInjection::RATE , GroupInjection::ControlEnumFromString( GroupInjection::ControlEnum2String( GroupInjection::RATE ) ));
BOOST_CHECK_EQUAL( GroupInjection::RESV , GroupInjection::ControlEnumFromString( GroupInjection::ControlEnum2String( GroupInjection::RESV ) ));
BOOST_CHECK_EQUAL( GroupInjection::REIN , GroupInjection::ControlEnumFromString( GroupInjection::ControlEnum2String( GroupInjection::REIN ) ));
BOOST_CHECK_EQUAL( GroupInjection::VREP , GroupInjection::ControlEnumFromString( GroupInjection::ControlEnum2String( GroupInjection::VREP ) ));
BOOST_CHECK_EQUAL( GroupInjection::FLD , GroupInjection::ControlEnumFromString( GroupInjection::ControlEnum2String( GroupInjection::FLD ) ));
BOOST_CHECK_EQUAL( "NONE" , GroupInjection::ControlEnum2String(GroupInjection::ControlEnumFromString( "NONE" ) ));
BOOST_CHECK_EQUAL( "RATE" , GroupInjection::ControlEnum2String(GroupInjection::ControlEnumFromString( "RATE" ) ));
BOOST_CHECK_EQUAL( "RESV" , GroupInjection::ControlEnum2String(GroupInjection::ControlEnumFromString( "RESV" ) ));
BOOST_CHECK_EQUAL( "REIN" , GroupInjection::ControlEnum2String(GroupInjection::ControlEnumFromString( "REIN" ) ));
BOOST_CHECK_EQUAL( "VREP" , GroupInjection::ControlEnum2String(GroupInjection::ControlEnumFromString( "VREP" ) ));
BOOST_CHECK_EQUAL( "FLD" , GroupInjection::ControlEnum2String(GroupInjection::ControlEnumFromString( "FLD" ) ));
}
/*****************************************************************/
BOOST_AUTO_TEST_CASE(TestGroupProductionControlEnum2String) {
BOOST_CHECK_EQUAL( "NONE" , GroupProduction::ControlEnum2String(GroupProduction::NONE));
BOOST_CHECK_EQUAL( "ORAT" , GroupProduction::ControlEnum2String(GroupProduction::ORAT));
BOOST_CHECK_EQUAL( "WRAT" , GroupProduction::ControlEnum2String(GroupProduction::WRAT));
BOOST_CHECK_EQUAL( "GRAT" , GroupProduction::ControlEnum2String(GroupProduction::GRAT));
BOOST_CHECK_EQUAL( "LRAT" , GroupProduction::ControlEnum2String(GroupProduction::LRAT));
BOOST_CHECK_EQUAL( "CRAT" , GroupProduction::ControlEnum2String(GroupProduction::CRAT));
BOOST_CHECK_EQUAL( "RESV" , GroupProduction::ControlEnum2String(GroupProduction::RESV));
BOOST_CHECK_EQUAL( "PRBL" , GroupProduction::ControlEnum2String(GroupProduction::PRBL));
}
BOOST_AUTO_TEST_CASE(TestGroupProductionControlEnumFromString) {
BOOST_CHECK_THROW( GroupProduction::ControlEnumFromString("XXX") , std::invalid_argument );
BOOST_CHECK_EQUAL(GroupProduction::NONE , GroupProduction::ControlEnumFromString("NONE"));
BOOST_CHECK_EQUAL(GroupProduction::ORAT , GroupProduction::ControlEnumFromString("ORAT"));
BOOST_CHECK_EQUAL(GroupProduction::WRAT , GroupProduction::ControlEnumFromString("WRAT"));
BOOST_CHECK_EQUAL(GroupProduction::GRAT , GroupProduction::ControlEnumFromString("GRAT"));
BOOST_CHECK_EQUAL(GroupProduction::LRAT , GroupProduction::ControlEnumFromString("LRAT"));
BOOST_CHECK_EQUAL(GroupProduction::CRAT , GroupProduction::ControlEnumFromString("CRAT"));
BOOST_CHECK_EQUAL(GroupProduction::RESV , GroupProduction::ControlEnumFromString("RESV"));
BOOST_CHECK_EQUAL(GroupProduction::PRBL , GroupProduction::ControlEnumFromString("PRBL"));
}
BOOST_AUTO_TEST_CASE(TestGroupProductionControlEnumLoop) {
BOOST_CHECK_EQUAL( GroupProduction::NONE, GroupProduction::ControlEnumFromString( GroupProduction::ControlEnum2String( GroupProduction::NONE ) ));
BOOST_CHECK_EQUAL( GroupProduction::ORAT, GroupProduction::ControlEnumFromString( GroupProduction::ControlEnum2String( GroupProduction::ORAT ) ));
BOOST_CHECK_EQUAL( GroupProduction::WRAT, GroupProduction::ControlEnumFromString( GroupProduction::ControlEnum2String( GroupProduction::WRAT ) ));
BOOST_CHECK_EQUAL( GroupProduction::GRAT, GroupProduction::ControlEnumFromString( GroupProduction::ControlEnum2String( GroupProduction::GRAT ) ));
BOOST_CHECK_EQUAL( GroupProduction::LRAT, GroupProduction::ControlEnumFromString( GroupProduction::ControlEnum2String( GroupProduction::LRAT ) ));
BOOST_CHECK_EQUAL( GroupProduction::CRAT, GroupProduction::ControlEnumFromString( GroupProduction::ControlEnum2String( GroupProduction::CRAT ) ));
BOOST_CHECK_EQUAL( GroupProduction::RESV, GroupProduction::ControlEnumFromString( GroupProduction::ControlEnum2String( GroupProduction::RESV ) ));
BOOST_CHECK_EQUAL( GroupProduction::PRBL, GroupProduction::ControlEnumFromString( GroupProduction::ControlEnum2String( GroupProduction::PRBL ) ));
BOOST_CHECK_EQUAL( "NONE" , GroupProduction::ControlEnum2String(GroupProduction::ControlEnumFromString( "NONE" ) ));
BOOST_CHECK_EQUAL( "ORAT" , GroupProduction::ControlEnum2String(GroupProduction::ControlEnumFromString( "ORAT" ) ));
BOOST_CHECK_EQUAL( "WRAT" , GroupProduction::ControlEnum2String(GroupProduction::ControlEnumFromString( "WRAT" ) ));
BOOST_CHECK_EQUAL( "GRAT" , GroupProduction::ControlEnum2String(GroupProduction::ControlEnumFromString( "GRAT" ) ));
BOOST_CHECK_EQUAL( "LRAT" , GroupProduction::ControlEnum2String(GroupProduction::ControlEnumFromString( "LRAT" ) ));
BOOST_CHECK_EQUAL( "CRAT" , GroupProduction::ControlEnum2String(GroupProduction::ControlEnumFromString( "CRAT" ) ));
BOOST_CHECK_EQUAL( "RESV" , GroupProduction::ControlEnum2String(GroupProduction::ControlEnumFromString( "RESV" ) ));
BOOST_CHECK_EQUAL( "PRBL" , GroupProduction::ControlEnum2String(GroupProduction::ControlEnumFromString( "PRBL" ) ));
}
/*****************************************************************/
BOOST_AUTO_TEST_CASE(TestGroupProductionExceedLimitControlEnum2String) {
BOOST_CHECK_EQUAL( "NONE" , GroupProductionExceedLimit::ActionEnum2String(GroupProductionExceedLimit::NONE));
BOOST_CHECK_EQUAL( "CON" , GroupProductionExceedLimit::ActionEnum2String(GroupProductionExceedLimit::CON));
BOOST_CHECK_EQUAL( "+CON" , GroupProductionExceedLimit::ActionEnum2String(GroupProductionExceedLimit::CON_PLUS));
BOOST_CHECK_EQUAL( "WELL" , GroupProductionExceedLimit::ActionEnum2String(GroupProductionExceedLimit::WELL));
BOOST_CHECK_EQUAL( "PLUG" , GroupProductionExceedLimit::ActionEnum2String(GroupProductionExceedLimit::PLUG));
BOOST_CHECK_EQUAL( "RATE" , GroupProductionExceedLimit::ActionEnum2String(GroupProductionExceedLimit::RATE));
}
BOOST_AUTO_TEST_CASE(TestGroupProductionExceedLimitActionEnumFromString) {
BOOST_CHECK_THROW( GroupProductionExceedLimit::ActionEnumFromString("XXX") , std::invalid_argument );
BOOST_CHECK_EQUAL(GroupProductionExceedLimit::NONE , GroupProductionExceedLimit::ActionEnumFromString("NONE"));
BOOST_CHECK_EQUAL(GroupProductionExceedLimit::CON , GroupProductionExceedLimit::ActionEnumFromString("CON" ));
BOOST_CHECK_EQUAL(GroupProductionExceedLimit::CON_PLUS , GroupProductionExceedLimit::ActionEnumFromString("+CON"));
BOOST_CHECK_EQUAL(GroupProductionExceedLimit::WELL , GroupProductionExceedLimit::ActionEnumFromString("WELL"));
BOOST_CHECK_EQUAL(GroupProductionExceedLimit::PLUG , GroupProductionExceedLimit::ActionEnumFromString("PLUG"));
BOOST_CHECK_EQUAL(GroupProductionExceedLimit::RATE , GroupProductionExceedLimit::ActionEnumFromString("RATE"));
}
BOOST_AUTO_TEST_CASE(TestGroupProductionExceedLimitActionEnumLoop) {
BOOST_CHECK_EQUAL( GroupProductionExceedLimit::NONE , GroupProductionExceedLimit::ActionEnumFromString( GroupProductionExceedLimit::ActionEnum2String( GroupProductionExceedLimit::NONE ) ));
BOOST_CHECK_EQUAL( GroupProductionExceedLimit::CON , GroupProductionExceedLimit::ActionEnumFromString( GroupProductionExceedLimit::ActionEnum2String( GroupProductionExceedLimit::CON ) ));
BOOST_CHECK_EQUAL( GroupProductionExceedLimit::CON_PLUS , GroupProductionExceedLimit::ActionEnumFromString( GroupProductionExceedLimit::ActionEnum2String( GroupProductionExceedLimit::CON_PLUS ) ));
BOOST_CHECK_EQUAL( GroupProductionExceedLimit::WELL , GroupProductionExceedLimit::ActionEnumFromString( GroupProductionExceedLimit::ActionEnum2String( GroupProductionExceedLimit::WELL ) ));
BOOST_CHECK_EQUAL( GroupProductionExceedLimit::PLUG , GroupProductionExceedLimit::ActionEnumFromString( GroupProductionExceedLimit::ActionEnum2String( GroupProductionExceedLimit::PLUG ) ));
BOOST_CHECK_EQUAL( GroupProductionExceedLimit::RATE , GroupProductionExceedLimit::ActionEnumFromString( GroupProductionExceedLimit::ActionEnum2String( GroupProductionExceedLimit::RATE ) ));
BOOST_CHECK_EQUAL("NONE" , GroupProductionExceedLimit::ActionEnum2String(GroupProductionExceedLimit::ActionEnumFromString( "NONE" ) ));
BOOST_CHECK_EQUAL("CON" , GroupProductionExceedLimit::ActionEnum2String(GroupProductionExceedLimit::ActionEnumFromString( "CON" ) ));
BOOST_CHECK_EQUAL("+CON" , GroupProductionExceedLimit::ActionEnum2String(GroupProductionExceedLimit::ActionEnumFromString( "+CON" ) ));
BOOST_CHECK_EQUAL("WELL" , GroupProductionExceedLimit::ActionEnum2String(GroupProductionExceedLimit::ActionEnumFromString( "WELL" ) ));
BOOST_CHECK_EQUAL("PLUG" , GroupProductionExceedLimit::ActionEnum2String(GroupProductionExceedLimit::ActionEnumFromString( "PLUG" ) ));
BOOST_CHECK_EQUAL("RATE" , GroupProductionExceedLimit::ActionEnum2String(GroupProductionExceedLimit::ActionEnumFromString( "RATE" ) ));
}
/*****************************************************************/
BOOST_AUTO_TEST_CASE(TestInjectorEnum2String) {
BOOST_CHECK_EQUAL( "OIL" , WellInjector::Type2String(WellInjector::OIL));
BOOST_CHECK_EQUAL( "GAS" , WellInjector::Type2String(WellInjector::GAS));
BOOST_CHECK_EQUAL( "WATER" , WellInjector::Type2String(WellInjector::WATER));
BOOST_CHECK_EQUAL( "MULTI" , WellInjector::Type2String(WellInjector::MULTI));
}
BOOST_AUTO_TEST_CASE(TestInjectorEnumFromString) {
BOOST_CHECK_THROW( WellInjector::TypeFromString("XXX") , std::invalid_argument );
BOOST_CHECK_EQUAL( WellInjector::OIL , WellInjector::TypeFromString("OIL"));
BOOST_CHECK_EQUAL( WellInjector::WATER , WellInjector::TypeFromString("WATER"));
BOOST_CHECK_EQUAL( WellInjector::WATER , WellInjector::TypeFromString("WAT"));
BOOST_CHECK_EQUAL( WellInjector::GAS , WellInjector::TypeFromString("GAS"));
BOOST_CHECK_EQUAL( WellInjector::MULTI , WellInjector::TypeFromString("MULTI"));
}
BOOST_AUTO_TEST_CASE(TestInjectorEnumLoop) {
BOOST_CHECK_EQUAL( WellInjector::OIL , WellInjector::TypeFromString( WellInjector::Type2String( WellInjector::OIL ) ));
BOOST_CHECK_EQUAL( WellInjector::WATER , WellInjector::TypeFromString( WellInjector::Type2String( WellInjector::WATER ) ));
BOOST_CHECK_EQUAL( WellInjector::GAS , WellInjector::TypeFromString( WellInjector::Type2String( WellInjector::GAS ) ));
BOOST_CHECK_EQUAL( WellInjector::MULTI , WellInjector::TypeFromString( WellInjector::Type2String( WellInjector::MULTI ) ));
BOOST_CHECK_EQUAL( "MULTI" , WellInjector::Type2String(WellInjector::TypeFromString( "MULTI" ) ));
BOOST_CHECK_EQUAL( "OIL" , WellInjector::Type2String(WellInjector::TypeFromString( "OIL" ) ));
BOOST_CHECK_EQUAL( "GAS" , WellInjector::Type2String(WellInjector::TypeFromString( "GAS" ) ));
BOOST_CHECK_EQUAL( "WATER" , WellInjector::Type2String(WellInjector::TypeFromString( "WATER" ) ));
}
/*****************************************************************/
BOOST_AUTO_TEST_CASE(InjectorCOntrolMopdeEnum2String) {
BOOST_CHECK_EQUAL( "RATE" , WellInjector::ControlMode2String(WellInjector::RATE));
BOOST_CHECK_EQUAL( "RESV" , WellInjector::ControlMode2String(WellInjector::RESV));
BOOST_CHECK_EQUAL( "BHP" , WellInjector::ControlMode2String(WellInjector::BHP));
BOOST_CHECK_EQUAL( "THP" , WellInjector::ControlMode2String(WellInjector::THP));
BOOST_CHECK_EQUAL( "GRUP" , WellInjector::ControlMode2String(WellInjector::GRUP));
}
BOOST_AUTO_TEST_CASE(InjectorControlModeEnumFromString) {
BOOST_CHECK_THROW( WellInjector::ControlModeFromString("XXX") , std::invalid_argument );
BOOST_CHECK_EQUAL( WellInjector::RATE , WellInjector::ControlModeFromString("RATE"));
BOOST_CHECK_EQUAL( WellInjector::BHP , WellInjector::ControlModeFromString("BHP"));
BOOST_CHECK_EQUAL( WellInjector::RESV , WellInjector::ControlModeFromString("RESV"));
BOOST_CHECK_EQUAL( WellInjector::THP , WellInjector::ControlModeFromString("THP"));
BOOST_CHECK_EQUAL( WellInjector::GRUP , WellInjector::ControlModeFromString("GRUP"));
}
BOOST_AUTO_TEST_CASE(InjectorControlModeEnumLoop) {
BOOST_CHECK_EQUAL( WellInjector::RATE , WellInjector::ControlModeFromString( WellInjector::ControlMode2String( WellInjector::RATE ) ));
BOOST_CHECK_EQUAL( WellInjector::BHP , WellInjector::ControlModeFromString( WellInjector::ControlMode2String( WellInjector::BHP ) ));
BOOST_CHECK_EQUAL( WellInjector::RESV , WellInjector::ControlModeFromString( WellInjector::ControlMode2String( WellInjector::RESV ) ));
BOOST_CHECK_EQUAL( WellInjector::THP , WellInjector::ControlModeFromString( WellInjector::ControlMode2String( WellInjector::THP ) ));
BOOST_CHECK_EQUAL( WellInjector::GRUP , WellInjector::ControlModeFromString( WellInjector::ControlMode2String( WellInjector::GRUP ) ));
BOOST_CHECK_EQUAL( "THP" , WellInjector::ControlMode2String(WellInjector::ControlModeFromString( "THP" ) ));
BOOST_CHECK_EQUAL( "RATE" , WellInjector::ControlMode2String(WellInjector::ControlModeFromString( "RATE" ) ));
BOOST_CHECK_EQUAL( "RESV" , WellInjector::ControlMode2String(WellInjector::ControlModeFromString( "RESV" ) ));
BOOST_CHECK_EQUAL( "BHP" , WellInjector::ControlMode2String(WellInjector::ControlModeFromString( "BHP" ) ));
BOOST_CHECK_EQUAL( "GRUP" , WellInjector::ControlMode2String(WellInjector::ControlModeFromString( "GRUP" ) ));
}
/*****************************************************************/
BOOST_AUTO_TEST_CASE(InjectorStatusEnum2String) {
BOOST_CHECK_EQUAL( "OPEN" , WellCommon::Status2String(WellCommon::OPEN));
BOOST_CHECK_EQUAL( "SHUT" , WellCommon::Status2String(WellCommon::SHUT));
BOOST_CHECK_EQUAL( "AUTO" , WellCommon::Status2String(WellCommon::AUTO));
BOOST_CHECK_EQUAL( "STOP" , WellCommon::Status2String(WellCommon::STOP));
}
BOOST_AUTO_TEST_CASE(InjectorStatusEnumFromString) {
BOOST_CHECK_THROW( WellCommon::StatusFromString("XXX") , std::invalid_argument );
BOOST_CHECK_EQUAL( WellCommon::OPEN , WellCommon::StatusFromString("OPEN"));
BOOST_CHECK_EQUAL( WellCommon::AUTO , WellCommon::StatusFromString("AUTO"));
BOOST_CHECK_EQUAL( WellCommon::SHUT , WellCommon::StatusFromString("SHUT"));
BOOST_CHECK_EQUAL( WellCommon::STOP , WellCommon::StatusFromString("STOP"));
}
BOOST_AUTO_TEST_CASE(InjectorStatusEnumLoop) {
BOOST_CHECK_EQUAL( WellCommon::OPEN , WellCommon::StatusFromString( WellCommon::Status2String( WellCommon::OPEN ) ));
BOOST_CHECK_EQUAL( WellCommon::AUTO , WellCommon::StatusFromString( WellCommon::Status2String( WellCommon::AUTO ) ));
BOOST_CHECK_EQUAL( WellCommon::SHUT , WellCommon::StatusFromString( WellCommon::Status2String( WellCommon::SHUT ) ));
BOOST_CHECK_EQUAL( WellCommon::STOP , WellCommon::StatusFromString( WellCommon::Status2String( WellCommon::STOP ) ));
BOOST_CHECK_EQUAL( "STOP" , WellCommon::Status2String(WellCommon::StatusFromString( "STOP" ) ));
BOOST_CHECK_EQUAL( "OPEN" , WellCommon::Status2String(WellCommon::StatusFromString( "OPEN" ) ));
BOOST_CHECK_EQUAL( "SHUT" , WellCommon::Status2String(WellCommon::StatusFromString( "SHUT" ) ));
BOOST_CHECK_EQUAL( "AUTO" , WellCommon::Status2String(WellCommon::StatusFromString( "AUTO" ) ));
}
/*****************************************************************/
BOOST_AUTO_TEST_CASE(ProducerCOntrolMopdeEnum2String) {
BOOST_CHECK_EQUAL( "ORAT" , WellProducer::ControlMode2String(WellProducer::ORAT));
BOOST_CHECK_EQUAL( "WRAT" , WellProducer::ControlMode2String(WellProducer::WRAT));
BOOST_CHECK_EQUAL( "GRAT" , WellProducer::ControlMode2String(WellProducer::GRAT));
BOOST_CHECK_EQUAL( "LRAT" , WellProducer::ControlMode2String(WellProducer::LRAT));
BOOST_CHECK_EQUAL( "CRAT" , WellProducer::ControlMode2String(WellProducer::CRAT));
BOOST_CHECK_EQUAL( "RESV" , WellProducer::ControlMode2String(WellProducer::RESV));
BOOST_CHECK_EQUAL( "BHP" , WellProducer::ControlMode2String(WellProducer::BHP));
BOOST_CHECK_EQUAL( "THP" , WellProducer::ControlMode2String(WellProducer::THP));
BOOST_CHECK_EQUAL( "GRUP" , WellProducer::ControlMode2String(WellProducer::GRUP));
}
BOOST_AUTO_TEST_CASE(ProducerControlModeEnumFromString) {
BOOST_CHECK_THROW( WellProducer::ControlModeFromString("XRAT") , std::invalid_argument );
BOOST_CHECK_EQUAL( WellProducer::ORAT , WellProducer::ControlModeFromString("ORAT"));
BOOST_CHECK_EQUAL( WellProducer::WRAT , WellProducer::ControlModeFromString("WRAT"));
BOOST_CHECK_EQUAL( WellProducer::GRAT , WellProducer::ControlModeFromString("GRAT"));
BOOST_CHECK_EQUAL( WellProducer::LRAT , WellProducer::ControlModeFromString("LRAT"));
BOOST_CHECK_EQUAL( WellProducer::CRAT , WellProducer::ControlModeFromString("CRAT"));
BOOST_CHECK_EQUAL( WellProducer::RESV , WellProducer::ControlModeFromString("RESV"));
BOOST_CHECK_EQUAL( WellProducer::BHP , WellProducer::ControlModeFromString("BHP" ));
BOOST_CHECK_EQUAL( WellProducer::THP , WellProducer::ControlModeFromString("THP" ));
BOOST_CHECK_EQUAL( WellProducer::GRUP , WellProducer::ControlModeFromString("GRUP"));
}
BOOST_AUTO_TEST_CASE(ProducerControlModeEnumLoop) {
BOOST_CHECK_EQUAL( WellProducer::ORAT , WellProducer::ControlModeFromString( WellProducer::ControlMode2String( WellProducer::ORAT ) ));
BOOST_CHECK_EQUAL( WellProducer::WRAT , WellProducer::ControlModeFromString( WellProducer::ControlMode2String( WellProducer::WRAT ) ));
BOOST_CHECK_EQUAL( WellProducer::GRAT , WellProducer::ControlModeFromString( WellProducer::ControlMode2String( WellProducer::GRAT ) ));
BOOST_CHECK_EQUAL( WellProducer::LRAT , WellProducer::ControlModeFromString( WellProducer::ControlMode2String( WellProducer::LRAT ) ));
BOOST_CHECK_EQUAL( WellProducer::CRAT , WellProducer::ControlModeFromString( WellProducer::ControlMode2String( WellProducer::CRAT ) ));
BOOST_CHECK_EQUAL( WellProducer::RESV , WellProducer::ControlModeFromString( WellProducer::ControlMode2String( WellProducer::RESV ) ));
BOOST_CHECK_EQUAL( WellProducer::BHP , WellProducer::ControlModeFromString( WellProducer::ControlMode2String( WellProducer::BHP ) ));
BOOST_CHECK_EQUAL( WellProducer::THP , WellProducer::ControlModeFromString( WellProducer::ControlMode2String( WellProducer::THP ) ));
BOOST_CHECK_EQUAL( WellProducer::GRUP , WellProducer::ControlModeFromString( WellProducer::ControlMode2String( WellProducer::GRUP ) ));
BOOST_CHECK_EQUAL( "ORAT" , WellProducer::ControlMode2String(WellProducer::ControlModeFromString( "ORAT" ) ));
BOOST_CHECK_EQUAL( "WRAT" , WellProducer::ControlMode2String(WellProducer::ControlModeFromString( "WRAT" ) ));
BOOST_CHECK_EQUAL( "GRAT" , WellProducer::ControlMode2String(WellProducer::ControlModeFromString( "GRAT" ) ));
BOOST_CHECK_EQUAL( "LRAT" , WellProducer::ControlMode2String(WellProducer::ControlModeFromString( "LRAT" ) ));
BOOST_CHECK_EQUAL( "CRAT" , WellProducer::ControlMode2String(WellProducer::ControlModeFromString( "CRAT" ) ));
BOOST_CHECK_EQUAL( "RESV" , WellProducer::ControlMode2String(WellProducer::ControlModeFromString( "RESV" ) ));
BOOST_CHECK_EQUAL( "BHP" , WellProducer::ControlMode2String(WellProducer::ControlModeFromString( "BHP" ) ));
BOOST_CHECK_EQUAL( "THP" , WellProducer::ControlMode2String(WellProducer::ControlModeFromString( "THP" ) ));
BOOST_CHECK_EQUAL( "GRUP" , WellProducer::ControlMode2String(WellProducer::ControlModeFromString( "GRUP" ) ));
}
/*******************************************************************/
/*****************************************************************/
BOOST_AUTO_TEST_CASE(GuideRatePhaseEnum2String) {
BOOST_CHECK_EQUAL( "OIL" , GuideRate::GuideRatePhaseEnum2String(GuideRate::OIL));
BOOST_CHECK_EQUAL( "WAT" , GuideRate::GuideRatePhaseEnum2String(GuideRate::WAT));
BOOST_CHECK_EQUAL( "GAS" , GuideRate::GuideRatePhaseEnum2String(GuideRate::GAS));
BOOST_CHECK_EQUAL( "LIQ" , GuideRate::GuideRatePhaseEnum2String(GuideRate::LIQ));
BOOST_CHECK_EQUAL( "COMB" , GuideRate::GuideRatePhaseEnum2String(GuideRate::COMB));
BOOST_CHECK_EQUAL( "WGA" , GuideRate::GuideRatePhaseEnum2String(GuideRate::WGA));
BOOST_CHECK_EQUAL( "CVAL" , GuideRate::GuideRatePhaseEnum2String(GuideRate::CVAL));
BOOST_CHECK_EQUAL( "RAT" , GuideRate::GuideRatePhaseEnum2String(GuideRate::RAT));
BOOST_CHECK_EQUAL( "RES" , GuideRate::GuideRatePhaseEnum2String(GuideRate::RES));
BOOST_CHECK_EQUAL( "UNDEFINED" , GuideRate::GuideRatePhaseEnum2String(GuideRate::UNDEFINED));
}
BOOST_AUTO_TEST_CASE(GuideRatePhaseEnumFromString) {
BOOST_CHECK_THROW( GuideRate::GuideRatePhaseEnumFromString("XRAT") , std::invalid_argument );
BOOST_CHECK_EQUAL( GuideRate::OIL , GuideRate::GuideRatePhaseEnumFromString("OIL"));
BOOST_CHECK_EQUAL( GuideRate::WAT , GuideRate::GuideRatePhaseEnumFromString("WAT"));
BOOST_CHECK_EQUAL( GuideRate::GAS , GuideRate::GuideRatePhaseEnumFromString("GAS"));
BOOST_CHECK_EQUAL( GuideRate::LIQ , GuideRate::GuideRatePhaseEnumFromString("LIQ"));
BOOST_CHECK_EQUAL( GuideRate::COMB , GuideRate::GuideRatePhaseEnumFromString("COMB"));
BOOST_CHECK_EQUAL( GuideRate::WGA , GuideRate::GuideRatePhaseEnumFromString("WGA"));
BOOST_CHECK_EQUAL( GuideRate::CVAL , GuideRate::GuideRatePhaseEnumFromString("CVAL"));
BOOST_CHECK_EQUAL( GuideRate::RAT , GuideRate::GuideRatePhaseEnumFromString("RAT"));
BOOST_CHECK_EQUAL( GuideRate::RES , GuideRate::GuideRatePhaseEnumFromString("RES"));
BOOST_CHECK_EQUAL( GuideRate::UNDEFINED, GuideRate::GuideRatePhaseEnumFromString("UNDEFINED"));
}
BOOST_AUTO_TEST_CASE(GuideRatePhaseEnum2Loop) {
BOOST_CHECK_EQUAL( GuideRate::OIL , GuideRate::GuideRatePhaseEnumFromString( GuideRate::GuideRatePhaseEnum2String( GuideRate::OIL ) ));
BOOST_CHECK_EQUAL( GuideRate::WAT , GuideRate::GuideRatePhaseEnumFromString( GuideRate::GuideRatePhaseEnum2String( GuideRate::WAT ) ));
BOOST_CHECK_EQUAL( GuideRate::GAS , GuideRate::GuideRatePhaseEnumFromString( GuideRate::GuideRatePhaseEnum2String( GuideRate::GAS ) ));
BOOST_CHECK_EQUAL( GuideRate::LIQ , GuideRate::GuideRatePhaseEnumFromString( GuideRate::GuideRatePhaseEnum2String( GuideRate::LIQ ) ));
BOOST_CHECK_EQUAL( GuideRate::COMB , GuideRate::GuideRatePhaseEnumFromString( GuideRate::GuideRatePhaseEnum2String( GuideRate::COMB ) ));
BOOST_CHECK_EQUAL( GuideRate::WGA , GuideRate::GuideRatePhaseEnumFromString( GuideRate::GuideRatePhaseEnum2String( GuideRate::WGA ) ));
BOOST_CHECK_EQUAL( GuideRate::CVAL , GuideRate::GuideRatePhaseEnumFromString( GuideRate::GuideRatePhaseEnum2String( GuideRate::CVAL ) ));
BOOST_CHECK_EQUAL( GuideRate::RAT , GuideRate::GuideRatePhaseEnumFromString( GuideRate::GuideRatePhaseEnum2String( GuideRate::RAT ) ));
BOOST_CHECK_EQUAL( GuideRate::RES , GuideRate::GuideRatePhaseEnumFromString( GuideRate::GuideRatePhaseEnum2String( GuideRate::RES ) ));
BOOST_CHECK_EQUAL( GuideRate::UNDEFINED , GuideRate::GuideRatePhaseEnumFromString( GuideRate::GuideRatePhaseEnum2String( GuideRate::UNDEFINED ) ));
BOOST_CHECK_EQUAL( "OIL" , GuideRate::GuideRatePhaseEnum2String(GuideRate::GuideRatePhaseEnumFromString( "OIL" ) ));
BOOST_CHECK_EQUAL( "WAT" , GuideRate::GuideRatePhaseEnum2String(GuideRate::GuideRatePhaseEnumFromString( "WAT" ) ));
BOOST_CHECK_EQUAL( "GAS" , GuideRate::GuideRatePhaseEnum2String(GuideRate::GuideRatePhaseEnumFromString( "GAS" ) ));
BOOST_CHECK_EQUAL( "LIQ" , GuideRate::GuideRatePhaseEnum2String(GuideRate::GuideRatePhaseEnumFromString( "LIQ" ) ));
BOOST_CHECK_EQUAL( "COMB" , GuideRate::GuideRatePhaseEnum2String(GuideRate::GuideRatePhaseEnumFromString( "COMB" ) ));
BOOST_CHECK_EQUAL( "WGA" , GuideRate::GuideRatePhaseEnum2String(GuideRate::GuideRatePhaseEnumFromString( "WGA" ) ));
BOOST_CHECK_EQUAL( "CVAL" , GuideRate::GuideRatePhaseEnum2String(GuideRate::GuideRatePhaseEnumFromString( "CVAL" ) ));
BOOST_CHECK_EQUAL( "RAT" , GuideRate::GuideRatePhaseEnum2String(GuideRate::GuideRatePhaseEnumFromString( "RAT" ) ));
BOOST_CHECK_EQUAL( "RES" , GuideRate::GuideRatePhaseEnum2String(GuideRate::GuideRatePhaseEnumFromString( "RES" ) ));
BOOST_CHECK_EQUAL( "UNDEFINED" , GuideRate::GuideRatePhaseEnum2String(GuideRate::GuideRatePhaseEnumFromString( "UNDEFINED" ) ));
}

407
tests/parser/ScheduleTests.cpp
View File

@@ -1555,3 +1555,410 @@ BOOST_AUTO_TEST_CASE( COMPLUMP_specific_coordinates ) {
BOOST_CHECK_EQUAL( open, cs2.getFromIJK( 1, 1, 4 ).getState() );
BOOST_CHECK_EQUAL( shut, cs2.getFromIJK( 1, 1, 5 ).getState() );
}
BOOST_AUTO_TEST_CASE(TestCompletionStateEnum2String) {
BOOST_CHECK_EQUAL( "AUTO" , WellCompletion::StateEnum2String(WellCompletion::AUTO));
BOOST_CHECK_EQUAL( "OPEN" , WellCompletion::StateEnum2String(WellCompletion::OPEN));
BOOST_CHECK_EQUAL( "SHUT" , WellCompletion::StateEnum2String(WellCompletion::SHUT));
}
BOOST_AUTO_TEST_CASE(TestCompletionStateEnumFromString) {
BOOST_CHECK_THROW( WellCompletion::StateEnumFromString("XXX") , std::invalid_argument );
BOOST_CHECK_EQUAL( WellCompletion::AUTO , WellCompletion::StateEnumFromString("AUTO"));
BOOST_CHECK_EQUAL( WellCompletion::SHUT , WellCompletion::StateEnumFromString("SHUT"));
BOOST_CHECK_EQUAL( WellCompletion::SHUT , WellCompletion::StateEnumFromString("STOP"));
BOOST_CHECK_EQUAL( WellCompletion::OPEN , WellCompletion::StateEnumFromString("OPEN"));
}
BOOST_AUTO_TEST_CASE(TestCompletionStateEnumLoop) {
BOOST_CHECK_EQUAL( WellCompletion::AUTO , WellCompletion::StateEnumFromString( WellCompletion::StateEnum2String( WellCompletion::AUTO ) ));
BOOST_CHECK_EQUAL( WellCompletion::SHUT , WellCompletion::StateEnumFromString( WellCompletion::StateEnum2String( WellCompletion::SHUT ) ));
BOOST_CHECK_EQUAL( WellCompletion::OPEN , WellCompletion::StateEnumFromString( WellCompletion::StateEnum2String( WellCompletion::OPEN ) ));
BOOST_CHECK_EQUAL( "AUTO" , WellCompletion::StateEnum2String(WellCompletion::StateEnumFromString( "AUTO" ) ));
BOOST_CHECK_EQUAL( "OPEN" , WellCompletion::StateEnum2String(WellCompletion::StateEnumFromString( "OPEN" ) ));
BOOST_CHECK_EQUAL( "SHUT" , WellCompletion::StateEnum2String(WellCompletion::StateEnumFromString( "SHUT" ) ));
}
/*****************************************************************/
BOOST_AUTO_TEST_CASE(TestCompletionDirectionEnum2String)
{
using namespace WellCompletion;
BOOST_CHECK_EQUAL("X", DirectionEnum2String(DirectionEnum::X));
BOOST_CHECK_EQUAL("Y", DirectionEnum2String(DirectionEnum::Y));
BOOST_CHECK_EQUAL("Z", DirectionEnum2String(DirectionEnum::Z));
}
BOOST_AUTO_TEST_CASE(TestCompletionDirectionEnumFromString)
{
using namespace WellCompletion;
BOOST_CHECK_THROW(DirectionEnumFromString("XXX"), std::invalid_argument);
BOOST_CHECK_EQUAL(DirectionEnum::X, DirectionEnumFromString("X"));
BOOST_CHECK_EQUAL(DirectionEnum::Y, DirectionEnumFromString("Y"));
BOOST_CHECK_EQUAL(DirectionEnum::Z, DirectionEnumFromString("Z"));
}
BOOST_AUTO_TEST_CASE(TestCompletionDirectionEnumLoop)
{
using namespace WellCompletion;
BOOST_CHECK_EQUAL(DirectionEnum::X, DirectionEnumFromString(DirectionEnum2String(DirectionEnum::X)));
BOOST_CHECK_EQUAL(DirectionEnum::Y, DirectionEnumFromString(DirectionEnum2String(DirectionEnum::Y)));
BOOST_CHECK_EQUAL(DirectionEnum::Z, DirectionEnumFromString(DirectionEnum2String(DirectionEnum::Z)));
BOOST_CHECK_EQUAL("X", DirectionEnum2String(DirectionEnumFromString("X")));
BOOST_CHECK_EQUAL("Y", DirectionEnum2String(DirectionEnumFromString("Y")));
BOOST_CHECK_EQUAL("Z", DirectionEnum2String(DirectionEnumFromString("Z")));
}
/*****************************************************************/
BOOST_AUTO_TEST_CASE(TestGroupInjectionControlEnum2String) {
BOOST_CHECK_EQUAL( "NONE" , GroupInjection::ControlEnum2String(GroupInjection::NONE));
BOOST_CHECK_EQUAL( "RATE" , GroupInjection::ControlEnum2String(GroupInjection::RATE));
BOOST_CHECK_EQUAL( "RESV" , GroupInjection::ControlEnum2String(GroupInjection::RESV));
BOOST_CHECK_EQUAL( "REIN" , GroupInjection::ControlEnum2String(GroupInjection::REIN));
BOOST_CHECK_EQUAL( "VREP" , GroupInjection::ControlEnum2String(GroupInjection::VREP));
BOOST_CHECK_EQUAL( "FLD" , GroupInjection::ControlEnum2String(GroupInjection::FLD));
}
BOOST_AUTO_TEST_CASE(TestGroupInjectionControlEnumFromString) {
BOOST_CHECK_THROW( GroupInjection::ControlEnumFromString("XXX") , std::invalid_argument );
BOOST_CHECK_EQUAL( GroupInjection::NONE , GroupInjection::ControlEnumFromString("NONE"));
BOOST_CHECK_EQUAL( GroupInjection::RATE , GroupInjection::ControlEnumFromString("RATE"));
BOOST_CHECK_EQUAL( GroupInjection::RESV , GroupInjection::ControlEnumFromString("RESV"));
BOOST_CHECK_EQUAL( GroupInjection::REIN , GroupInjection::ControlEnumFromString("REIN"));
BOOST_CHECK_EQUAL( GroupInjection::VREP , GroupInjection::ControlEnumFromString("VREP"));
BOOST_CHECK_EQUAL( GroupInjection::FLD , GroupInjection::ControlEnumFromString("FLD"));
}
BOOST_AUTO_TEST_CASE(TestGroupInjectionControlEnumLoop) {
BOOST_CHECK_EQUAL( GroupInjection::NONE , GroupInjection::ControlEnumFromString( GroupInjection::ControlEnum2String( GroupInjection::NONE ) ));
BOOST_CHECK_EQUAL( GroupInjection::RATE , GroupInjection::ControlEnumFromString( GroupInjection::ControlEnum2String( GroupInjection::RATE ) ));
BOOST_CHECK_EQUAL( GroupInjection::RESV , GroupInjection::ControlEnumFromString( GroupInjection::ControlEnum2String( GroupInjection::RESV ) ));
BOOST_CHECK_EQUAL( GroupInjection::REIN , GroupInjection::ControlEnumFromString( GroupInjection::ControlEnum2String( GroupInjection::REIN ) ));
BOOST_CHECK_EQUAL( GroupInjection::VREP , GroupInjection::ControlEnumFromString( GroupInjection::ControlEnum2String( GroupInjection::VREP ) ));
BOOST_CHECK_EQUAL( GroupInjection::FLD , GroupInjection::ControlEnumFromString( GroupInjection::ControlEnum2String( GroupInjection::FLD ) ));
BOOST_CHECK_EQUAL( "NONE" , GroupInjection::ControlEnum2String(GroupInjection::ControlEnumFromString( "NONE" ) ));
BOOST_CHECK_EQUAL( "RATE" , GroupInjection::ControlEnum2String(GroupInjection::ControlEnumFromString( "RATE" ) ));
BOOST_CHECK_EQUAL( "RESV" , GroupInjection::ControlEnum2String(GroupInjection::ControlEnumFromString( "RESV" ) ));
BOOST_CHECK_EQUAL( "REIN" , GroupInjection::ControlEnum2String(GroupInjection::ControlEnumFromString( "REIN" ) ));
BOOST_CHECK_EQUAL( "VREP" , GroupInjection::ControlEnum2String(GroupInjection::ControlEnumFromString( "VREP" ) ));
BOOST_CHECK_EQUAL( "FLD" , GroupInjection::ControlEnum2String(GroupInjection::ControlEnumFromString( "FLD" ) ));
}
/*****************************************************************/
BOOST_AUTO_TEST_CASE(TestGroupProductionControlEnum2String) {
BOOST_CHECK_EQUAL( "NONE" , GroupProduction::ControlEnum2String(GroupProduction::NONE));
BOOST_CHECK_EQUAL( "ORAT" , GroupProduction::ControlEnum2String(GroupProduction::ORAT));
BOOST_CHECK_EQUAL( "WRAT" , GroupProduction::ControlEnum2String(GroupProduction::WRAT));
BOOST_CHECK_EQUAL( "GRAT" , GroupProduction::ControlEnum2String(GroupProduction::GRAT));
BOOST_CHECK_EQUAL( "LRAT" , GroupProduction::ControlEnum2String(GroupProduction::LRAT));
BOOST_CHECK_EQUAL( "CRAT" , GroupProduction::ControlEnum2String(GroupProduction::CRAT));
BOOST_CHECK_EQUAL( "RESV" , GroupProduction::ControlEnum2String(GroupProduction::RESV));
BOOST_CHECK_EQUAL( "PRBL" , GroupProduction::ControlEnum2String(GroupProduction::PRBL));
}
BOOST_AUTO_TEST_CASE(TestGroupProductionControlEnumFromString) {
BOOST_CHECK_THROW( GroupProduction::ControlEnumFromString("XXX") , std::invalid_argument );
BOOST_CHECK_EQUAL(GroupProduction::NONE , GroupProduction::ControlEnumFromString("NONE"));
BOOST_CHECK_EQUAL(GroupProduction::ORAT , GroupProduction::ControlEnumFromString("ORAT"));
BOOST_CHECK_EQUAL(GroupProduction::WRAT , GroupProduction::ControlEnumFromString("WRAT"));
BOOST_CHECK_EQUAL(GroupProduction::GRAT , GroupProduction::ControlEnumFromString("GRAT"));
BOOST_CHECK_EQUAL(GroupProduction::LRAT , GroupProduction::ControlEnumFromString("LRAT"));
BOOST_CHECK_EQUAL(GroupProduction::CRAT , GroupProduction::ControlEnumFromString("CRAT"));
BOOST_CHECK_EQUAL(GroupProduction::RESV , GroupProduction::ControlEnumFromString("RESV"));
BOOST_CHECK_EQUAL(GroupProduction::PRBL , GroupProduction::ControlEnumFromString("PRBL"));
}
BOOST_AUTO_TEST_CASE(TestGroupProductionControlEnumLoop) {
BOOST_CHECK_EQUAL( GroupProduction::NONE, GroupProduction::ControlEnumFromString( GroupProduction::ControlEnum2String( GroupProduction::NONE ) ));
BOOST_CHECK_EQUAL( GroupProduction::ORAT, GroupProduction::ControlEnumFromString( GroupProduction::ControlEnum2String( GroupProduction::ORAT ) ));
BOOST_CHECK_EQUAL( GroupProduction::WRAT, GroupProduction::ControlEnumFromString( GroupProduction::ControlEnum2String( GroupProduction::WRAT ) ));
BOOST_CHECK_EQUAL( GroupProduction::GRAT, GroupProduction::ControlEnumFromString( GroupProduction::ControlEnum2String( GroupProduction::GRAT ) ));
BOOST_CHECK_EQUAL( GroupProduction::LRAT, GroupProduction::ControlEnumFromString( GroupProduction::ControlEnum2String( GroupProduction::LRAT ) ));
BOOST_CHECK_EQUAL( GroupProduction::CRAT, GroupProduction::ControlEnumFromString( GroupProduction::ControlEnum2String( GroupProduction::CRAT ) ));
BOOST_CHECK_EQUAL( GroupProduction::RESV, GroupProduction::ControlEnumFromString( GroupProduction::ControlEnum2String( GroupProduction::RESV ) ));
BOOST_CHECK_EQUAL( GroupProduction::PRBL, GroupProduction::ControlEnumFromString( GroupProduction::ControlEnum2String( GroupProduction::PRBL ) ));
BOOST_CHECK_EQUAL( "NONE" , GroupProduction::ControlEnum2String(GroupProduction::ControlEnumFromString( "NONE" ) ));
BOOST_CHECK_EQUAL( "ORAT" , GroupProduction::ControlEnum2String(GroupProduction::ControlEnumFromString( "ORAT" ) ));
BOOST_CHECK_EQUAL( "WRAT" , GroupProduction::ControlEnum2String(GroupProduction::ControlEnumFromString( "WRAT" ) ));
BOOST_CHECK_EQUAL( "GRAT" , GroupProduction::ControlEnum2String(GroupProduction::ControlEnumFromString( "GRAT" ) ));
BOOST_CHECK_EQUAL( "LRAT" , GroupProduction::ControlEnum2String(GroupProduction::ControlEnumFromString( "LRAT" ) ));
BOOST_CHECK_EQUAL( "CRAT" , GroupProduction::ControlEnum2String(GroupProduction::ControlEnumFromString( "CRAT" ) ));
BOOST_CHECK_EQUAL( "RESV" , GroupProduction::ControlEnum2String(GroupProduction::ControlEnumFromString( "RESV" ) ));
BOOST_CHECK_EQUAL( "PRBL" , GroupProduction::ControlEnum2String(GroupProduction::ControlEnumFromString( "PRBL" ) ));
}
/*****************************************************************/
BOOST_AUTO_TEST_CASE(TestGroupProductionExceedLimitControlEnum2String) {
BOOST_CHECK_EQUAL( "NONE" , GroupProductionExceedLimit::ActionEnum2String(GroupProductionExceedLimit::NONE));
BOOST_CHECK_EQUAL( "CON" , GroupProductionExceedLimit::ActionEnum2String(GroupProductionExceedLimit::CON));
BOOST_CHECK_EQUAL( "+CON" , GroupProductionExceedLimit::ActionEnum2String(GroupProductionExceedLimit::CON_PLUS));
BOOST_CHECK_EQUAL( "WELL" , GroupProductionExceedLimit::ActionEnum2String(GroupProductionExceedLimit::WELL));
BOOST_CHECK_EQUAL( "PLUG" , GroupProductionExceedLimit::ActionEnum2String(GroupProductionExceedLimit::PLUG));
BOOST_CHECK_EQUAL( "RATE" , GroupProductionExceedLimit::ActionEnum2String(GroupProductionExceedLimit::RATE));
}
BOOST_AUTO_TEST_CASE(TestGroupProductionExceedLimitActionEnumFromString) {
BOOST_CHECK_THROW( GroupProductionExceedLimit::ActionEnumFromString("XXX") , std::invalid_argument );
BOOST_CHECK_EQUAL(GroupProductionExceedLimit::NONE , GroupProductionExceedLimit::ActionEnumFromString("NONE"));
BOOST_CHECK_EQUAL(GroupProductionExceedLimit::CON , GroupProductionExceedLimit::ActionEnumFromString("CON" ));
BOOST_CHECK_EQUAL(GroupProductionExceedLimit::CON_PLUS , GroupProductionExceedLimit::ActionEnumFromString("+CON"));
BOOST_CHECK_EQUAL(GroupProductionExceedLimit::WELL , GroupProductionExceedLimit::ActionEnumFromString("WELL"));
BOOST_CHECK_EQUAL(GroupProductionExceedLimit::PLUG , GroupProductionExceedLimit::ActionEnumFromString("PLUG"));
BOOST_CHECK_EQUAL(GroupProductionExceedLimit::RATE , GroupProductionExceedLimit::ActionEnumFromString("RATE"));
}
BOOST_AUTO_TEST_CASE(TestGroupProductionExceedLimitActionEnumLoop) {
BOOST_CHECK_EQUAL( GroupProductionExceedLimit::NONE , GroupProductionExceedLimit::ActionEnumFromString( GroupProductionExceedLimit::ActionEnum2String( GroupProductionExceedLimit::NONE ) ));
BOOST_CHECK_EQUAL( GroupProductionExceedLimit::CON , GroupProductionExceedLimit::ActionEnumFromString( GroupProductionExceedLimit::ActionEnum2String( GroupProductionExceedLimit::CON ) ));
BOOST_CHECK_EQUAL( GroupProductionExceedLimit::CON_PLUS , GroupProductionExceedLimit::ActionEnumFromString( GroupProductionExceedLimit::ActionEnum2String( GroupProductionExceedLimit::CON_PLUS ) ));
BOOST_CHECK_EQUAL( GroupProductionExceedLimit::WELL , GroupProductionExceedLimit::ActionEnumFromString( GroupProductionExceedLimit::ActionEnum2String( GroupProductionExceedLimit::WELL ) ));
BOOST_CHECK_EQUAL( GroupProductionExceedLimit::PLUG , GroupProductionExceedLimit::ActionEnumFromString( GroupProductionExceedLimit::ActionEnum2String( GroupProductionExceedLimit::PLUG ) ));
BOOST_CHECK_EQUAL( GroupProductionExceedLimit::RATE , GroupProductionExceedLimit::ActionEnumFromString( GroupProductionExceedLimit::ActionEnum2String( GroupProductionExceedLimit::RATE ) ));
BOOST_CHECK_EQUAL("NONE" , GroupProductionExceedLimit::ActionEnum2String(GroupProductionExceedLimit::ActionEnumFromString( "NONE" ) ));
BOOST_CHECK_EQUAL("CON" , GroupProductionExceedLimit::ActionEnum2String(GroupProductionExceedLimit::ActionEnumFromString( "CON" ) ));
BOOST_CHECK_EQUAL("+CON" , GroupProductionExceedLimit::ActionEnum2String(GroupProductionExceedLimit::ActionEnumFromString( "+CON" ) ));
BOOST_CHECK_EQUAL("WELL" , GroupProductionExceedLimit::ActionEnum2String(GroupProductionExceedLimit::ActionEnumFromString( "WELL" ) ));
BOOST_CHECK_EQUAL("PLUG" , GroupProductionExceedLimit::ActionEnum2String(GroupProductionExceedLimit::ActionEnumFromString( "PLUG" ) ));
BOOST_CHECK_EQUAL("RATE" , GroupProductionExceedLimit::ActionEnum2String(GroupProductionExceedLimit::ActionEnumFromString( "RATE" ) ));
}
/*****************************************************************/
BOOST_AUTO_TEST_CASE(TestInjectorEnum2String) {
BOOST_CHECK_EQUAL( "OIL" , WellInjector::Type2String(WellInjector::OIL));
BOOST_CHECK_EQUAL( "GAS" , WellInjector::Type2String(WellInjector::GAS));
BOOST_CHECK_EQUAL( "WATER" , WellInjector::Type2String(WellInjector::WATER));
BOOST_CHECK_EQUAL( "MULTI" , WellInjector::Type2String(WellInjector::MULTI));
}
BOOST_AUTO_TEST_CASE(TestInjectorEnumFromString) {
BOOST_CHECK_THROW( WellInjector::TypeFromString("XXX") , std::invalid_argument );
BOOST_CHECK_EQUAL( WellInjector::OIL , WellInjector::TypeFromString("OIL"));
BOOST_CHECK_EQUAL( WellInjector::WATER , WellInjector::TypeFromString("WATER"));
BOOST_CHECK_EQUAL( WellInjector::WATER , WellInjector::TypeFromString("WAT"));
BOOST_CHECK_EQUAL( WellInjector::GAS , WellInjector::TypeFromString("GAS"));
BOOST_CHECK_EQUAL( WellInjector::MULTI , WellInjector::TypeFromString("MULTI"));
}
BOOST_AUTO_TEST_CASE(TestInjectorEnumLoop) {
BOOST_CHECK_EQUAL( WellInjector::OIL , WellInjector::TypeFromString( WellInjector::Type2String( WellInjector::OIL ) ));
BOOST_CHECK_EQUAL( WellInjector::WATER , WellInjector::TypeFromString( WellInjector::Type2String( WellInjector::WATER ) ));
BOOST_CHECK_EQUAL( WellInjector::GAS , WellInjector::TypeFromString( WellInjector::Type2String( WellInjector::GAS ) ));
BOOST_CHECK_EQUAL( WellInjector::MULTI , WellInjector::TypeFromString( WellInjector::Type2String( WellInjector::MULTI ) ));
BOOST_CHECK_EQUAL( "MULTI" , WellInjector::Type2String(WellInjector::TypeFromString( "MULTI" ) ));
BOOST_CHECK_EQUAL( "OIL" , WellInjector::Type2String(WellInjector::TypeFromString( "OIL" ) ));
BOOST_CHECK_EQUAL( "GAS" , WellInjector::Type2String(WellInjector::TypeFromString( "GAS" ) ));
BOOST_CHECK_EQUAL( "WATER" , WellInjector::Type2String(WellInjector::TypeFromString( "WATER" ) ));
}
/*****************************************************************/
BOOST_AUTO_TEST_CASE(InjectorCOntrolMopdeEnum2String) {
BOOST_CHECK_EQUAL( "RATE" , WellInjector::ControlMode2String(WellInjector::RATE));
BOOST_CHECK_EQUAL( "RESV" , WellInjector::ControlMode2String(WellInjector::RESV));
BOOST_CHECK_EQUAL( "BHP" , WellInjector::ControlMode2String(WellInjector::BHP));
BOOST_CHECK_EQUAL( "THP" , WellInjector::ControlMode2String(WellInjector::THP));
BOOST_CHECK_EQUAL( "GRUP" , WellInjector::ControlMode2String(WellInjector::GRUP));
}
BOOST_AUTO_TEST_CASE(InjectorControlModeEnumFromString) {
BOOST_CHECK_THROW( WellInjector::ControlModeFromString("XXX") , std::invalid_argument );
BOOST_CHECK_EQUAL( WellInjector::RATE , WellInjector::ControlModeFromString("RATE"));
BOOST_CHECK_EQUAL( WellInjector::BHP , WellInjector::ControlModeFromString("BHP"));
BOOST_CHECK_EQUAL( WellInjector::RESV , WellInjector::ControlModeFromString("RESV"));
BOOST_CHECK_EQUAL( WellInjector::THP , WellInjector::ControlModeFromString("THP"));
BOOST_CHECK_EQUAL( WellInjector::GRUP , WellInjector::ControlModeFromString("GRUP"));
}
BOOST_AUTO_TEST_CASE(InjectorControlModeEnumLoop) {
BOOST_CHECK_EQUAL( WellInjector::RATE , WellInjector::ControlModeFromString( WellInjector::ControlMode2String( WellInjector::RATE ) ));
BOOST_CHECK_EQUAL( WellInjector::BHP , WellInjector::ControlModeFromString( WellInjector::ControlMode2String( WellInjector::BHP ) ));
BOOST_CHECK_EQUAL( WellInjector::RESV , WellInjector::ControlModeFromString( WellInjector::ControlMode2String( WellInjector::RESV ) ));
BOOST_CHECK_EQUAL( WellInjector::THP , WellInjector::ControlModeFromString( WellInjector::ControlMode2String( WellInjector::THP ) ));
BOOST_CHECK_EQUAL( WellInjector::GRUP , WellInjector::ControlModeFromString( WellInjector::ControlMode2String( WellInjector::GRUP ) ));
BOOST_CHECK_EQUAL( "THP" , WellInjector::ControlMode2String(WellInjector::ControlModeFromString( "THP" ) ));
BOOST_CHECK_EQUAL( "RATE" , WellInjector::ControlMode2String(WellInjector::ControlModeFromString( "RATE" ) ));
BOOST_CHECK_EQUAL( "RESV" , WellInjector::ControlMode2String(WellInjector::ControlModeFromString( "RESV" ) ));
BOOST_CHECK_EQUAL( "BHP" , WellInjector::ControlMode2String(WellInjector::ControlModeFromString( "BHP" ) ));
BOOST_CHECK_EQUAL( "GRUP" , WellInjector::ControlMode2String(WellInjector::ControlModeFromString( "GRUP" ) ));
}
/*****************************************************************/
BOOST_AUTO_TEST_CASE(InjectorStatusEnum2String) {
BOOST_CHECK_EQUAL( "OPEN" , WellCommon::Status2String(WellCommon::OPEN));
BOOST_CHECK_EQUAL( "SHUT" , WellCommon::Status2String(WellCommon::SHUT));
BOOST_CHECK_EQUAL( "AUTO" , WellCommon::Status2String(WellCommon::AUTO));
BOOST_CHECK_EQUAL( "STOP" , WellCommon::Status2String(WellCommon::STOP));
}
BOOST_AUTO_TEST_CASE(InjectorStatusEnumFromString) {
BOOST_CHECK_THROW( WellCommon::StatusFromString("XXX") , std::invalid_argument );
BOOST_CHECK_EQUAL( WellCommon::OPEN , WellCommon::StatusFromString("OPEN"));
BOOST_CHECK_EQUAL( WellCommon::AUTO , WellCommon::StatusFromString("AUTO"));
BOOST_CHECK_EQUAL( WellCommon::SHUT , WellCommon::StatusFromString("SHUT"));
BOOST_CHECK_EQUAL( WellCommon::STOP , WellCommon::StatusFromString("STOP"));
}
BOOST_AUTO_TEST_CASE(InjectorStatusEnumLoop) {
BOOST_CHECK_EQUAL( WellCommon::OPEN , WellCommon::StatusFromString( WellCommon::Status2String( WellCommon::OPEN ) ));
BOOST_CHECK_EQUAL( WellCommon::AUTO , WellCommon::StatusFromString( WellCommon::Status2String( WellCommon::AUTO ) ));
BOOST_CHECK_EQUAL( WellCommon::SHUT , WellCommon::StatusFromString( WellCommon::Status2String( WellCommon::SHUT ) ));
BOOST_CHECK_EQUAL( WellCommon::STOP , WellCommon::StatusFromString( WellCommon::Status2String( WellCommon::STOP ) ));
BOOST_CHECK_EQUAL( "STOP" , WellCommon::Status2String(WellCommon::StatusFromString( "STOP" ) ));
BOOST_CHECK_EQUAL( "OPEN" , WellCommon::Status2String(WellCommon::StatusFromString( "OPEN" ) ));
BOOST_CHECK_EQUAL( "SHUT" , WellCommon::Status2String(WellCommon::StatusFromString( "SHUT" ) ));
BOOST_CHECK_EQUAL( "AUTO" , WellCommon::Status2String(WellCommon::StatusFromString( "AUTO" ) ));
}
/*****************************************************************/
BOOST_AUTO_TEST_CASE(ProducerCOntrolMopdeEnum2String) {
BOOST_CHECK_EQUAL( "ORAT" , WellProducer::ControlMode2String(WellProducer::ORAT));
BOOST_CHECK_EQUAL( "WRAT" , WellProducer::ControlMode2String(WellProducer::WRAT));
BOOST_CHECK_EQUAL( "GRAT" , WellProducer::ControlMode2String(WellProducer::GRAT));
BOOST_CHECK_EQUAL( "LRAT" , WellProducer::ControlMode2String(WellProducer::LRAT));
BOOST_CHECK_EQUAL( "CRAT" , WellProducer::ControlMode2String(WellProducer::CRAT));
BOOST_CHECK_EQUAL( "RESV" , WellProducer::ControlMode2String(WellProducer::RESV));
BOOST_CHECK_EQUAL( "BHP" , WellProducer::ControlMode2String(WellProducer::BHP));
BOOST_CHECK_EQUAL( "THP" , WellProducer::ControlMode2String(WellProducer::THP));
BOOST_CHECK_EQUAL( "GRUP" , WellProducer::ControlMode2String(WellProducer::GRUP));
}
BOOST_AUTO_TEST_CASE(ProducerControlModeEnumFromString) {
BOOST_CHECK_THROW( WellProducer::ControlModeFromString("XRAT") , std::invalid_argument );
BOOST_CHECK_EQUAL( WellProducer::ORAT , WellProducer::ControlModeFromString("ORAT"));
BOOST_CHECK_EQUAL( WellProducer::WRAT , WellProducer::ControlModeFromString("WRAT"));
BOOST_CHECK_EQUAL( WellProducer::GRAT , WellProducer::ControlModeFromString("GRAT"));
BOOST_CHECK_EQUAL( WellProducer::LRAT , WellProducer::ControlModeFromString("LRAT"));
BOOST_CHECK_EQUAL( WellProducer::CRAT , WellProducer::ControlModeFromString("CRAT"));
BOOST_CHECK_EQUAL( WellProducer::RESV , WellProducer::ControlModeFromString("RESV"));
BOOST_CHECK_EQUAL( WellProducer::BHP , WellProducer::ControlModeFromString("BHP" ));
BOOST_CHECK_EQUAL( WellProducer::THP , WellProducer::ControlModeFromString("THP" ));
BOOST_CHECK_EQUAL( WellProducer::GRUP , WellProducer::ControlModeFromString("GRUP"));
}
BOOST_AUTO_TEST_CASE(ProducerControlModeEnumLoop) {
BOOST_CHECK_EQUAL( WellProducer::ORAT , WellProducer::ControlModeFromString( WellProducer::ControlMode2String( WellProducer::ORAT ) ));
BOOST_CHECK_EQUAL( WellProducer::WRAT , WellProducer::ControlModeFromString( WellProducer::ControlMode2String( WellProducer::WRAT ) ));
BOOST_CHECK_EQUAL( WellProducer::GRAT , WellProducer::ControlModeFromString( WellProducer::ControlMode2String( WellProducer::GRAT ) ));
BOOST_CHECK_EQUAL( WellProducer::LRAT , WellProducer::ControlModeFromString( WellProducer::ControlMode2String( WellProducer::LRAT ) ));
BOOST_CHECK_EQUAL( WellProducer::CRAT , WellProducer::ControlModeFromString( WellProducer::ControlMode2String( WellProducer::CRAT ) ));
BOOST_CHECK_EQUAL( WellProducer::RESV , WellProducer::ControlModeFromString( WellProducer::ControlMode2String( WellProducer::RESV ) ));
BOOST_CHECK_EQUAL( WellProducer::BHP , WellProducer::ControlModeFromString( WellProducer::ControlMode2String( WellProducer::BHP ) ));
BOOST_CHECK_EQUAL( WellProducer::THP , WellProducer::ControlModeFromString( WellProducer::ControlMode2String( WellProducer::THP ) ));
BOOST_CHECK_EQUAL( WellProducer::GRUP , WellProducer::ControlModeFromString( WellProducer::ControlMode2String( WellProducer::GRUP ) ));
BOOST_CHECK_EQUAL( "ORAT" , WellProducer::ControlMode2String(WellProducer::ControlModeFromString( "ORAT" ) ));
BOOST_CHECK_EQUAL( "WRAT" , WellProducer::ControlMode2String(WellProducer::ControlModeFromString( "WRAT" ) ));
BOOST_CHECK_EQUAL( "GRAT" , WellProducer::ControlMode2String(WellProducer::ControlModeFromString( "GRAT" ) ));
BOOST_CHECK_EQUAL( "LRAT" , WellProducer::ControlMode2String(WellProducer::ControlModeFromString( "LRAT" ) ));
BOOST_CHECK_EQUAL( "CRAT" , WellProducer::ControlMode2String(WellProducer::ControlModeFromString( "CRAT" ) ));
BOOST_CHECK_EQUAL( "RESV" , WellProducer::ControlMode2String(WellProducer::ControlModeFromString( "RESV" ) ));
BOOST_CHECK_EQUAL( "BHP" , WellProducer::ControlMode2String(WellProducer::ControlModeFromString( "BHP" ) ));
BOOST_CHECK_EQUAL( "THP" , WellProducer::ControlMode2String(WellProducer::ControlModeFromString( "THP" ) ));
BOOST_CHECK_EQUAL( "GRUP" , WellProducer::ControlMode2String(WellProducer::ControlModeFromString( "GRUP" ) ));
}
/*******************************************************************/
/*****************************************************************/
BOOST_AUTO_TEST_CASE(GuideRatePhaseEnum2String) {
BOOST_CHECK_EQUAL( "OIL" , GuideRate::GuideRatePhaseEnum2String(GuideRate::OIL));
BOOST_CHECK_EQUAL( "WAT" , GuideRate::GuideRatePhaseEnum2String(GuideRate::WAT));
BOOST_CHECK_EQUAL( "GAS" , GuideRate::GuideRatePhaseEnum2String(GuideRate::GAS));
BOOST_CHECK_EQUAL( "LIQ" , GuideRate::GuideRatePhaseEnum2String(GuideRate::LIQ));
BOOST_CHECK_EQUAL( "COMB" , GuideRate::GuideRatePhaseEnum2String(GuideRate::COMB));
BOOST_CHECK_EQUAL( "WGA" , GuideRate::GuideRatePhaseEnum2String(GuideRate::WGA));
BOOST_CHECK_EQUAL( "CVAL" , GuideRate::GuideRatePhaseEnum2String(GuideRate::CVAL));
BOOST_CHECK_EQUAL( "RAT" , GuideRate::GuideRatePhaseEnum2String(GuideRate::RAT));
BOOST_CHECK_EQUAL( "RES" , GuideRate::GuideRatePhaseEnum2String(GuideRate::RES));
BOOST_CHECK_EQUAL( "UNDEFINED" , GuideRate::GuideRatePhaseEnum2String(GuideRate::UNDEFINED));
}
BOOST_AUTO_TEST_CASE(GuideRatePhaseEnumFromString) {
BOOST_CHECK_THROW( GuideRate::GuideRatePhaseEnumFromString("XRAT") , std::invalid_argument );
BOOST_CHECK_EQUAL( GuideRate::OIL , GuideRate::GuideRatePhaseEnumFromString("OIL"));
BOOST_CHECK_EQUAL( GuideRate::WAT , GuideRate::GuideRatePhaseEnumFromString("WAT"));
BOOST_CHECK_EQUAL( GuideRate::GAS , GuideRate::GuideRatePhaseEnumFromString("GAS"));
BOOST_CHECK_EQUAL( GuideRate::LIQ , GuideRate::GuideRatePhaseEnumFromString("LIQ"));
BOOST_CHECK_EQUAL( GuideRate::COMB , GuideRate::GuideRatePhaseEnumFromString("COMB"));
BOOST_CHECK_EQUAL( GuideRate::WGA , GuideRate::GuideRatePhaseEnumFromString("WGA"));
BOOST_CHECK_EQUAL( GuideRate::CVAL , GuideRate::GuideRatePhaseEnumFromString("CVAL"));
BOOST_CHECK_EQUAL( GuideRate::RAT , GuideRate::GuideRatePhaseEnumFromString("RAT"));
BOOST_CHECK_EQUAL( GuideRate::RES , GuideRate::GuideRatePhaseEnumFromString("RES"));
BOOST_CHECK_EQUAL( GuideRate::UNDEFINED, GuideRate::GuideRatePhaseEnumFromString("UNDEFINED"));
}
BOOST_AUTO_TEST_CASE(GuideRatePhaseEnum2Loop) {
BOOST_CHECK_EQUAL( GuideRate::OIL , GuideRate::GuideRatePhaseEnumFromString( GuideRate::GuideRatePhaseEnum2String( GuideRate::OIL ) ));
BOOST_CHECK_EQUAL( GuideRate::WAT , GuideRate::GuideRatePhaseEnumFromString( GuideRate::GuideRatePhaseEnum2String( GuideRate::WAT ) ));
BOOST_CHECK_EQUAL( GuideRate::GAS , GuideRate::GuideRatePhaseEnumFromString( GuideRate::GuideRatePhaseEnum2String( GuideRate::GAS ) ));
BOOST_CHECK_EQUAL( GuideRate::LIQ , GuideRate::GuideRatePhaseEnumFromString( GuideRate::GuideRatePhaseEnum2String( GuideRate::LIQ ) ));
BOOST_CHECK_EQUAL( GuideRate::COMB , GuideRate::GuideRatePhaseEnumFromString( GuideRate::GuideRatePhaseEnum2String( GuideRate::COMB ) ));
BOOST_CHECK_EQUAL( GuideRate::WGA , GuideRate::GuideRatePhaseEnumFromString( GuideRate::GuideRatePhaseEnum2String( GuideRate::WGA ) ));
BOOST_CHECK_EQUAL( GuideRate::CVAL , GuideRate::GuideRatePhaseEnumFromString( GuideRate::GuideRatePhaseEnum2String( GuideRate::CVAL ) ));
BOOST_CHECK_EQUAL( GuideRate::RAT , GuideRate::GuideRatePhaseEnumFromString( GuideRate::GuideRatePhaseEnum2String( GuideRate::RAT ) ));
BOOST_CHECK_EQUAL( GuideRate::RES , GuideRate::GuideRatePhaseEnumFromString( GuideRate::GuideRatePhaseEnum2String( GuideRate::RES ) ));
BOOST_CHECK_EQUAL( GuideRate::UNDEFINED , GuideRate::GuideRatePhaseEnumFromString( GuideRate::GuideRatePhaseEnum2String( GuideRate::UNDEFINED ) ));
BOOST_CHECK_EQUAL( "OIL" , GuideRate::GuideRatePhaseEnum2String(GuideRate::GuideRatePhaseEnumFromString( "OIL" ) ));
BOOST_CHECK_EQUAL( "WAT" , GuideRate::GuideRatePhaseEnum2String(GuideRate::GuideRatePhaseEnumFromString( "WAT" ) ));
BOOST_CHECK_EQUAL( "GAS" , GuideRate::GuideRatePhaseEnum2String(GuideRate::GuideRatePhaseEnumFromString( "GAS" ) ));
BOOST_CHECK_EQUAL( "LIQ" , GuideRate::GuideRatePhaseEnum2String(GuideRate::GuideRatePhaseEnumFromString( "LIQ" ) ));
BOOST_CHECK_EQUAL( "COMB" , GuideRate::GuideRatePhaseEnum2String(GuideRate::GuideRatePhaseEnumFromString( "COMB" ) ));
BOOST_CHECK_EQUAL( "WGA" , GuideRate::GuideRatePhaseEnum2String(GuideRate::GuideRatePhaseEnumFromString( "WGA" ) ));
BOOST_CHECK_EQUAL( "CVAL" , GuideRate::GuideRatePhaseEnum2String(GuideRate::GuideRatePhaseEnumFromString( "CVAL" ) ));
BOOST_CHECK_EQUAL( "RAT" , GuideRate::GuideRatePhaseEnum2String(GuideRate::GuideRatePhaseEnumFromString( "RAT" ) ));
BOOST_CHECK_EQUAL( "RES" , GuideRate::GuideRatePhaseEnum2String(GuideRate::GuideRatePhaseEnumFromString( "RES" ) ));
BOOST_CHECK_EQUAL( "UNDEFINED" , GuideRate::GuideRatePhaseEnum2String(GuideRate::GuideRatePhaseEnumFromString( "UNDEFINED" ) ));
}

96
tests/parser/StringTests.cpp
View File

@@ -60,3 +60,99 @@ BOOST_AUTO_TEST_CASE( write_parts_of_dst ) {
BOOST_CHECK_EQUAL( dst, "STRINGmixed" );
BOOST_CHECK_EQUAL( view, "string" );
}
BOOST_AUTO_TEST_CASE(fullStringView) {
std::string srcstr = "lorem ipsum";
string_view view( srcstr );
BOOST_CHECK_EQUAL_COLLECTIONS(
srcstr.begin(), srcstr.end(),
view.begin(), view.end() );
}
BOOST_AUTO_TEST_CASE(viewCorrectSize) {
std::string srcstr = "lorem ipsum";
string_view full( srcstr );
BOOST_CHECK_EQUAL( srcstr.size(), full.size() );
string_view view( srcstr, 5 );
BOOST_CHECK_EQUAL( 5, view.size() );
BOOST_CHECK_EQUAL( 5, view.length() );
}
BOOST_AUTO_TEST_CASE(viewOperatorAt) {
std::string srcstr = "lorem ipsum";
string_view view( srcstr );
for( size_t i = 0; i < view.size(); ++i )
BOOST_CHECK_EQUAL( view[ i ], srcstr[ i ] );
}
BOOST_AUTO_TEST_CASE(viewFrontBack) {
std::string srcstr = "lorem ipsum";
string_view view( srcstr );
BOOST_CHECK_EQUAL( view.front(), 'l' );
BOOST_CHECK_EQUAL( view.back(), 'm' );
}
BOOST_AUTO_TEST_CASE(viewSubstr) {
std::string srcstr = "lorem ipsum";
string_view view( srcstr );
BOOST_CHECK_NO_THROW( view.string() );
BOOST_CHECK_EQUAL( srcstr, view.string() );
BOOST_CHECK_EQUAL( srcstr, view.substr() );
BOOST_CHECK_EQUAL( "", view.substr( 0, 0 ) );
BOOST_CHECK_EQUAL( srcstr.substr( 1 ), view.substr( 1 ) );
BOOST_CHECK_THROW( view.substr( srcstr.size() + 1 ), std::out_of_range );
BOOST_CHECK_THROW( view.substr( 0, srcstr.size() + 1 ), std::out_of_range );
BOOST_CHECK_THROW( view.substr( 1, 0 ), std::invalid_argument );
BOOST_CHECK_NO_THROW( view.substr( 0, 0 ) );
}
BOOST_AUTO_TEST_CASE(viewStream) {
std::string srcstr = "lorem ipsum";
string_view view( srcstr );
std::stringstream str;
str << view;
BOOST_CHECK_EQUAL( srcstr, str.str() );
}
BOOST_AUTO_TEST_CASE(equalityOperators) {
std::string srcstr = "lorem ipsum";
std::string diffstr = "lorem";
string_view view( srcstr );
BOOST_CHECK_EQUAL( srcstr, view );
BOOST_CHECK_NE( diffstr, view );
BOOST_CHECK_EQUAL( view, srcstr );
BOOST_CHECK_NE( view, diffstr );
BOOST_CHECK_EQUAL( "lorem ipsum", view );
BOOST_CHECK_NE( "lorem", view );
BOOST_CHECK_EQUAL( view, "lorem ipsum" );
BOOST_CHECK_NE( view, "lorem" );
}
BOOST_AUTO_TEST_CASE(plusOperator) {
std::string total = "lorem ipsum";
std::string lhs = "lorem";
std::string ws = " ";
std::string rhs = "ipsum";
string_view lhs_view( lhs );
string_view rhs_view( rhs );
BOOST_CHECK_EQUAL( total, lhs_view + ws + rhs_view );
BOOST_CHECK_EQUAL( lhs + ws, lhs_view + ws );
BOOST_CHECK_EQUAL( ws + rhs, ws + rhs_view );
}

106
tests/parser/StringviewTests.cpp
View File

@@ -1,106 +0,0 @@
#define BOOST_TEST_MODULE StringviewTests
#include <sstream>
#include <string>
#include <boost/test/unit_test.hpp>
#include <opm/parser/eclipse/Utility/Stringview.hpp>
using namespace Opm;
BOOST_AUTO_TEST_CASE(fullStringView) {
std::string srcstr = "lorem ipsum";
string_view view( srcstr );
BOOST_CHECK_EQUAL_COLLECTIONS(
srcstr.begin(), srcstr.end(),
view.begin(), view.end() );
}
BOOST_AUTO_TEST_CASE(viewCorrectSize) {
std::string srcstr = "lorem ipsum";
string_view full( srcstr );
BOOST_CHECK_EQUAL( srcstr.size(), full.size() );
string_view view( srcstr, 5 );
BOOST_CHECK_EQUAL( 5, view.size() );
BOOST_CHECK_EQUAL( 5, view.length() );
}
BOOST_AUTO_TEST_CASE(viewOperatorAt) {
std::string srcstr = "lorem ipsum";
string_view view( srcstr );
for( size_t i = 0; i < view.size(); ++i )
BOOST_CHECK_EQUAL( view[ i ], srcstr[ i ] );
}
BOOST_AUTO_TEST_CASE(viewFrontBack) {
std::string srcstr = "lorem ipsum";
string_view view( srcstr );
BOOST_CHECK_EQUAL( view.front(), 'l' );
BOOST_CHECK_EQUAL( view.back(), 'm' );
}
BOOST_AUTO_TEST_CASE(viewSubstr) {
std::string srcstr = "lorem ipsum";
string_view view( srcstr );
BOOST_CHECK_NO_THROW( view.string() );
BOOST_CHECK_EQUAL( srcstr, view.string() );
BOOST_CHECK_EQUAL( srcstr, view.substr() );
BOOST_CHECK_EQUAL( "", view.substr( 0, 0 ) );
BOOST_CHECK_EQUAL( srcstr.substr( 1 ), view.substr( 1 ) );
BOOST_CHECK_THROW( view.substr( srcstr.size() + 1 ), std::out_of_range );
BOOST_CHECK_THROW( view.substr( 0, srcstr.size() + 1 ), std::out_of_range );
BOOST_CHECK_THROW( view.substr( 1, 0 ), std::invalid_argument );
BOOST_CHECK_NO_THROW( view.substr( 0, 0 ) );
}
BOOST_AUTO_TEST_CASE(viewStream) {
std::string srcstr = "lorem ipsum";
string_view view( srcstr );
std::stringstream str;
str << view;
BOOST_CHECK_EQUAL( srcstr, str.str() );
}
BOOST_AUTO_TEST_CASE(equalityOperators) {
std::string srcstr = "lorem ipsum";
std::string diffstr = "lorem";
string_view view( srcstr );
BOOST_CHECK_EQUAL( srcstr, view );
BOOST_CHECK_NE( diffstr, view );
BOOST_CHECK_EQUAL( view, srcstr );
BOOST_CHECK_NE( view, diffstr );
BOOST_CHECK_EQUAL( "lorem ipsum", view );
BOOST_CHECK_NE( "lorem", view );
BOOST_CHECK_EQUAL( view, "lorem ipsum" );
BOOST_CHECK_NE( view, "lorem" );
}
BOOST_AUTO_TEST_CASE(plusOperator) {
std::string total = "lorem ipsum";
std::string lhs = "lorem";
std::string ws = " ";
std::string rhs = "ipsum";
string_view lhs_view( lhs );
string_view rhs_view( rhs );
BOOST_CHECK_EQUAL( total, lhs_view + ws + rhs_view );
BOOST_CHECK_EQUAL( lhs + ws, lhs_view + ws );
BOOST_CHECK_EQUAL( ws + rhs, ws + rhs_view );
}

237
tests/parser/WellPropertiesTests.cpp
View File

@@ -1,237 +0,0 @@
/*
Copyright 2014 Statoil ASA.
This file is part of the Open Porous Media project (OPM).
OPM is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OPM is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with OPM. If not, see <http://www.gnu.org/licenses/>.
*/
#define BOOST_TEST_MODULE WellPropertiesTest
#include <boost/test/unit_test.hpp>
#include <opm/parser/eclipse/Deck/Deck.hpp>
#include <opm/parser/eclipse/Deck/DeckKeyword.hpp>
#include <opm/parser/eclipse/Deck/DeckRecord.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/ScheduleEnums.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/WellInjectionProperties.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/WellProductionProperties.hpp>
#include <opm/parser/eclipse/Parser/ParseContext.hpp>
#include <opm/parser/eclipse/Parser/Parser.hpp>
#include <string>
namespace {
namespace WCONHIST {
std::string all_specified_CMODE_BHP() {
const std::string input =
"WCONHIST\n"
"'P' 'OPEN' 'BHP' 1 2 3/\n/\n";
return input;
}
std::string all_specified() {
const std::string input =
"WCONHIST\n"
"'P' 'OPEN' 'ORAT' 1 2 3/\n/\n";
return input;
}
std::string orat_defaulted() {
const std::string input =
"WCONHIST\n"
"'P' 'OPEN' 'WRAT' 1* 2 3/\n/\n";
return input;
}
std::string owrat_defaulted() {
const std::string input =
"WCONHIST\n"
"'P' 'OPEN' 'GRAT' 1* 1* 3/\n/\n";
return input;
}
std::string all_defaulted() {
const std::string input =
"WCONHIST\n"
"'P' 'OPEN' 'LRAT'/\n/\n";
return input;
}
std::string all_defaulted_with_bhp() {
const std::string input =
"WCONHIST\n"
"-- 1 2 3 4-9 10\n"
" 'P' 'OPEN' 'RESV' 6* 500/\n/\n";
return input;
}
Opm::WellProductionProperties properties(const std::string& input) {
Opm::Parser parser;
auto deck = parser.parseString(input, Opm::ParseContext());
const auto& record = deck.getKeyword("WCONHIST").getRecord(0);
Opm::WellProductionProperties hist = Opm::WellProductionProperties::history( 100 , record);;
return hist;
}
} // namespace WCONHIST
namespace WCONPROD {
std::string
all_specified_CMODE_BHP()
{
const std::string input =
"WCONPROD\n"
"'P' 'OPEN' 'BHP' 1 2 3/\n/\n";
return input;
}
Opm::WellProductionProperties
properties(const std::string& input)
{
Opm::Parser parser;
auto deck = parser.parseString(input, Opm::ParseContext());
const auto& kwd = deck.getKeyword("WCONHIST");
const auto& record = kwd.getRecord(0);
Opm::WellProductionProperties pred = Opm::WellProductionProperties::prediction( record, false );
return pred;
}
}
} // namespace anonymous
BOOST_AUTO_TEST_CASE(WCH_All_Specified_BHP_Defaulted)
{
const Opm::WellProductionProperties& p =
WCONHIST::properties(WCONHIST::all_specified());
// WCONHIST always supports {O,W,G}RAT, LRAT, and
// RESV--irrespective of actual specification.
BOOST_CHECK(p.hasProductionControl(Opm::WellProducer::ORAT));
BOOST_CHECK(p.hasProductionControl(Opm::WellProducer::WRAT));
BOOST_CHECK(p.hasProductionControl(Opm::WellProducer::GRAT));
BOOST_CHECK(p.hasProductionControl(Opm::WellProducer::LRAT));
BOOST_CHECK(p.hasProductionControl(Opm::WellProducer::RESV));
BOOST_CHECK_EQUAL(p.controlMode , Opm::WellProducer::ORAT);
// BHP must be explicitly provided/specified
BOOST_CHECK(! p.hasProductionControl(Opm::WellProducer::BHP));
}
BOOST_AUTO_TEST_CASE(WCH_ORAT_Defaulted_BHP_Defaulted)
{
const Opm::WellProductionProperties& p =
WCONHIST::properties(WCONHIST::orat_defaulted());
// WCONHIST always supports {O,W,G}RAT, LRAT, and
// RESV--irrespective of actual specification.
BOOST_CHECK(p.hasProductionControl(Opm::WellProducer::ORAT));
BOOST_CHECK(p.hasProductionControl(Opm::WellProducer::WRAT));
BOOST_CHECK(p.hasProductionControl(Opm::WellProducer::GRAT));
BOOST_CHECK(p.hasProductionControl(Opm::WellProducer::LRAT));
BOOST_CHECK(p.hasProductionControl(Opm::WellProducer::RESV));
BOOST_CHECK_EQUAL(p.controlMode , Opm::WellProducer::WRAT);
// BHP must be explicitly provided/specified
BOOST_CHECK(! p.hasProductionControl(Opm::WellProducer::BHP));
}
BOOST_AUTO_TEST_CASE(WCH_OWRAT_Defaulted_BHP_Defaulted)
{
const Opm::WellProductionProperties& p =
WCONHIST::properties(WCONHIST::owrat_defaulted());
// WCONHIST always supports {O,W,G}RAT, LRAT, and
// RESV--irrespective of actual specification.
BOOST_CHECK(p.hasProductionControl(Opm::WellProducer::ORAT));
BOOST_CHECK(p.hasProductionControl(Opm::WellProducer::WRAT));
BOOST_CHECK(p.hasProductionControl(Opm::WellProducer::GRAT));
BOOST_CHECK(p.hasProductionControl(Opm::WellProducer::LRAT));
BOOST_CHECK(p.hasProductionControl(Opm::WellProducer::RESV));
BOOST_CHECK_EQUAL(p.controlMode , Opm::WellProducer::GRAT);
// BHP must be explicitly provided/specified
BOOST_CHECK(! p.hasProductionControl(Opm::WellProducer::BHP));
}
BOOST_AUTO_TEST_CASE(WCH_Rates_Defaulted_BHP_Defaulted)
{
const Opm::WellProductionProperties& p =
WCONHIST::properties(WCONHIST::all_defaulted());
// WCONHIST always supports {O,W,G}RAT, LRAT, and
// RESV--irrespective of actual specification.
BOOST_CHECK(p.hasProductionControl(Opm::WellProducer::ORAT));
BOOST_CHECK(p.hasProductionControl(Opm::WellProducer::WRAT));
BOOST_CHECK(p.hasProductionControl(Opm::WellProducer::GRAT));
BOOST_CHECK(p.hasProductionControl(Opm::WellProducer::LRAT));
BOOST_CHECK(p.hasProductionControl(Opm::WellProducer::RESV));
BOOST_CHECK_EQUAL(p.controlMode , Opm::WellProducer::LRAT);
// BHP must be explicitly provided/specified
BOOST_CHECK(! p.hasProductionControl(Opm::WellProducer::BHP));
}
BOOST_AUTO_TEST_CASE(WCH_Rates_Defaulted_BHP_Specified)
{
const Opm::WellProductionProperties& p =
WCONHIST::properties(WCONHIST::all_defaulted_with_bhp());
// WCONHIST always supports {O,W,G}RAT, LRAT, and
// RESV--irrespective of actual specification.
BOOST_CHECK(p.hasProductionControl(Opm::WellProducer::ORAT));
BOOST_CHECK(p.hasProductionControl(Opm::WellProducer::WRAT));
BOOST_CHECK(p.hasProductionControl(Opm::WellProducer::GRAT));
BOOST_CHECK(p.hasProductionControl(Opm::WellProducer::LRAT));
BOOST_CHECK(p.hasProductionControl(Opm::WellProducer::RESV));
BOOST_CHECK_EQUAL(p.controlMode , Opm::WellProducer::RESV);
/*
BHP in WCONHIST is not an available control; just information
about the historical BHP.
*/
BOOST_CHECK_EQUAL(false , p.hasProductionControl(Opm::WellProducer::BHP));
}
BOOST_AUTO_TEST_CASE(BHP_CMODE)
{
BOOST_CHECK_THROW( WCONHIST::properties(WCONHIST::all_specified_CMODE_BHP()) , std::invalid_argument);
BOOST_CHECK_THROW( WCONPROD::properties(WCONPROD::all_specified_CMODE_BHP()) , std::invalid_argument);
}
BOOST_AUTO_TEST_CASE(CMODE_DEFAULT) {
const Opm::WellProductionProperties Pproperties;
const Opm::WellInjectionProperties Iproperties;
BOOST_CHECK_EQUAL( Pproperties.controlMode , Opm::WellProducer::CMODE_UNDEFINED );
BOOST_CHECK_EQUAL( Iproperties.controlMode , Opm::WellInjector::CMODE_UNDEFINED );
}

205
tests/parser/WellTests.cpp
View File

@@ -797,3 +797,208 @@ BOOST_AUTO_TEST_CASE(testWellNameInWellNamePattern) {
const std::string& wellnamePattern2 = "NONE";
BOOST_CHECK_EQUAL(Opm::Well::wellNameInWellNamePattern(wellname1, wellnamePattern2), false);
}
namespace {
namespace WCONHIST {
std::string all_specified_CMODE_BHP() {
const std::string input =
"WCONHIST\n"
"'P' 'OPEN' 'BHP' 1 2 3/\n/\n";
return input;
}
std::string all_specified() {
const std::string input =
"WCONHIST\n"
"'P' 'OPEN' 'ORAT' 1 2 3/\n/\n";
return input;
}
std::string orat_defaulted() {
const std::string input =
"WCONHIST\n"
"'P' 'OPEN' 'WRAT' 1* 2 3/\n/\n";
return input;
}
std::string owrat_defaulted() {
const std::string input =
"WCONHIST\n"
"'P' 'OPEN' 'GRAT' 1* 1* 3/\n/\n";
return input;
}
std::string all_defaulted() {
const std::string input =
"WCONHIST\n"
"'P' 'OPEN' 'LRAT'/\n/\n";
return input;
}
std::string all_defaulted_with_bhp() {
const std::string input =
"WCONHIST\n"
"-- 1 2 3 4-9 10\n"
" 'P' 'OPEN' 'RESV' 6* 500/\n/\n";
return input;
}
Opm::WellProductionProperties properties(const std::string& input) {
Opm::Parser parser;
auto deck = parser.parseString(input, Opm::ParseContext());
const auto& record = deck.getKeyword("WCONHIST").getRecord(0);
Opm::WellProductionProperties hist = Opm::WellProductionProperties::history( 100 , record);;
return hist;
}
} // namespace WCONHIST
namespace WCONPROD {
std::string
all_specified_CMODE_BHP()
{
const std::string input =
"WCONPROD\n"
"'P' 'OPEN' 'BHP' 1 2 3/\n/\n";
return input;
}
Opm::WellProductionProperties
properties(const std::string& input)
{
Opm::Parser parser;
auto deck = parser.parseString(input, Opm::ParseContext());
const auto& kwd = deck.getKeyword("WCONHIST");
const auto& record = kwd.getRecord(0);
Opm::WellProductionProperties pred = Opm::WellProductionProperties::prediction( record, false );
return pred;
}
}
} // namespace anonymous
BOOST_AUTO_TEST_CASE(WCH_All_Specified_BHP_Defaulted)
{
const Opm::WellProductionProperties& p =
WCONHIST::properties(WCONHIST::all_specified());
// WCONHIST always supports {O,W,G}RAT, LRAT, and
// RESV--irrespective of actual specification.
BOOST_CHECK(p.hasProductionControl(Opm::WellProducer::ORAT));
BOOST_CHECK(p.hasProductionControl(Opm::WellProducer::WRAT));
BOOST_CHECK(p.hasProductionControl(Opm::WellProducer::GRAT));
BOOST_CHECK(p.hasProductionControl(Opm::WellProducer::LRAT));
BOOST_CHECK(p.hasProductionControl(Opm::WellProducer::RESV));
BOOST_CHECK_EQUAL(p.controlMode , Opm::WellProducer::ORAT);
// BHP must be explicitly provided/specified
BOOST_CHECK(! p.hasProductionControl(Opm::WellProducer::BHP));
}
BOOST_AUTO_TEST_CASE(WCH_ORAT_Defaulted_BHP_Defaulted)
{
const Opm::WellProductionProperties& p =
WCONHIST::properties(WCONHIST::orat_defaulted());
// WCONHIST always supports {O,W,G}RAT, LRAT, and
// RESV--irrespective of actual specification.
BOOST_CHECK(p.hasProductionControl(Opm::WellProducer::ORAT));
BOOST_CHECK(p.hasProductionControl(Opm::WellProducer::WRAT));
BOOST_CHECK(p.hasProductionControl(Opm::WellProducer::GRAT));
BOOST_CHECK(p.hasProductionControl(Opm::WellProducer::LRAT));
BOOST_CHECK(p.hasProductionControl(Opm::WellProducer::RESV));
BOOST_CHECK_EQUAL(p.controlMode , Opm::WellProducer::WRAT);
// BHP must be explicitly provided/specified
BOOST_CHECK(! p.hasProductionControl(Opm::WellProducer::BHP));
}
BOOST_AUTO_TEST_CASE(WCH_OWRAT_Defaulted_BHP_Defaulted)
{
const Opm::WellProductionProperties& p =
WCONHIST::properties(WCONHIST::owrat_defaulted());
// WCONHIST always supports {O,W,G}RAT, LRAT, and
// RESV--irrespective of actual specification.
BOOST_CHECK(p.hasProductionControl(Opm::WellProducer::ORAT));
BOOST_CHECK(p.hasProductionControl(Opm::WellProducer::WRAT));
BOOST_CHECK(p.hasProductionControl(Opm::WellProducer::GRAT));
BOOST_CHECK(p.hasProductionControl(Opm::WellProducer::LRAT));
BOOST_CHECK(p.hasProductionControl(Opm::WellProducer::RESV));
BOOST_CHECK_EQUAL(p.controlMode , Opm::WellProducer::GRAT);
// BHP must be explicitly provided/specified
BOOST_CHECK(! p.hasProductionControl(Opm::WellProducer::BHP));
}
BOOST_AUTO_TEST_CASE(WCH_Rates_Defaulted_BHP_Defaulted)
{
const Opm::WellProductionProperties& p =
WCONHIST::properties(WCONHIST::all_defaulted());
// WCONHIST always supports {O,W,G}RAT, LRAT, and
// RESV--irrespective of actual specification.
BOOST_CHECK(p.hasProductionControl(Opm::WellProducer::ORAT));
BOOST_CHECK(p.hasProductionControl(Opm::WellProducer::WRAT));
BOOST_CHECK(p.hasProductionControl(Opm::WellProducer::GRAT));
BOOST_CHECK(p.hasProductionControl(Opm::WellProducer::LRAT));
BOOST_CHECK(p.hasProductionControl(Opm::WellProducer::RESV));
BOOST_CHECK_EQUAL(p.controlMode , Opm::WellProducer::LRAT);
// BHP must be explicitly provided/specified
BOOST_CHECK(! p.hasProductionControl(Opm::WellProducer::BHP));
}
BOOST_AUTO_TEST_CASE(WCH_Rates_Defaulted_BHP_Specified)
{
const Opm::WellProductionProperties& p =
WCONHIST::properties(WCONHIST::all_defaulted_with_bhp());
// WCONHIST always supports {O,W,G}RAT, LRAT, and
// RESV--irrespective of actual specification.
BOOST_CHECK(p.hasProductionControl(Opm::WellProducer::ORAT));
BOOST_CHECK(p.hasProductionControl(Opm::WellProducer::WRAT));
BOOST_CHECK(p.hasProductionControl(Opm::WellProducer::GRAT));
BOOST_CHECK(p.hasProductionControl(Opm::WellProducer::LRAT));
BOOST_CHECK(p.hasProductionControl(Opm::WellProducer::RESV));
BOOST_CHECK_EQUAL(p.controlMode , Opm::WellProducer::RESV);
/*
BHP in WCONHIST is not an available control; just information
about the historical BHP.
*/
BOOST_CHECK_EQUAL(false , p.hasProductionControl(Opm::WellProducer::BHP));
}
BOOST_AUTO_TEST_CASE(BHP_CMODE)
{
BOOST_CHECK_THROW( WCONHIST::properties(WCONHIST::all_specified_CMODE_BHP()) , std::invalid_argument);
BOOST_CHECK_THROW( WCONPROD::properties(WCONPROD::all_specified_CMODE_BHP()) , std::invalid_argument);
}
BOOST_AUTO_TEST_CASE(CMODE_DEFAULT) {
const Opm::WellProductionProperties Pproperties;
const Opm::WellInjectionProperties Iproperties;
BOOST_CHECK_EQUAL( Pproperties.controlMode , Opm::WellProducer::CMODE_UNDEFINED );
BOOST_CHECK_EQUAL( Iproperties.controlMode , Opm::WellInjector::CMODE_UNDEFINED );
}