sp
/
tempest
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

fixed a lot of warnings in the tests 

Former-commit-id: b6752202ac
main
dehnert 10 years ago
parent
5365d50811
commit
e338cbe069
21 changed files with 252 additions and 265 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 2
      src/solver/GmmxxLinearEquationSolver.cpp
  2. 1
      src/solver/NativeLinearEquationSolver.cpp
  3. 2
      src/solver/TopologicalMinMaxLinearEquationSolver.cpp
  4. 12
      src/storage/expressions/BinaryBooleanFunctionExpression.cpp
  5. 8
      test/functional/modelchecker/NativeHybridMdpPrctlModelCheckerTest.cpp
  6. 2
      test/functional/parser/AtomicPropositionLabelingParserTest.cpp
  7. 22
      test/functional/parser/AutoParserTest.cpp
  8. 24
      test/functional/parser/DeterministicModelParserTest.cpp
  9. 90
      test/functional/parser/DeterministicSparseTransitionParserTest.cpp
  10. 14
      test/functional/parser/MarkovAutomatonParserTest.cpp
  11. 56
      test/functional/parser/MarkovAutomatonSparseTransitionParserTest.cpp
  12. 8
      test/functional/parser/PrismParserTest.cpp
  13. 48
      test/functional/solver/GlpkLpSolverTest.cpp
  14. 14
      test/functional/storage/BitVectorHashMapTest.cpp
  15. 6
      test/functional/storage/BitVectorTest.cpp
  16. 40
      test/functional/storage/DeterministicModelBisimulationDecompositionTest.cpp
  17. 6
      test/functional/storage/MaximalEndComponentDecompositionTest.cpp
  18. 10
      test/functional/storage/SchedulerTest.cpp
  19. 50
      test/functional/storage/SparseMatrixTest.cpp
  20. 14
      test/functional/storage/StronglyConnectedComponentDecompositionTest.cpp
  21. 88
      test/functional/utility/GraphTest.cpp

2
src/solver/GmmxxLinearEquationSolver.cpp
View File

@ -207,6 +207,7 @@ namespace storm {
case SolutionMethod::Qmr: return "qmr";
case SolutionMethod::Gmres: return "gmres";
case SolutionMethod::Jacobi: return "jacobi";
default: return "invalid";
}
}
@ -216,6 +217,7 @@ namespace storm {
case Preconditioner::Ilu: return "ilu";
case Preconditioner::Diagonal: return "diagonal";
case Preconditioner::None: return "none";
default: return "invalid";
}
}

1
src/solver/NativeLinearEquationSolver.cpp
View File

@ -158,6 +158,7 @@ namespace storm {
case SolutionMethod::Jacobi: return "jacobi";
case SolutionMethod::GaussSeidel: return "gauss-seidel";
case SolutionMethod::SOR: return "sor";
default: return "invalid";
}
}

2
src/solver/TopologicalMinMaxLinearEquationSolver.cpp
View File

@ -152,8 +152,6 @@ namespace storm {
// Iterate over all SCCs of the MDP as specified by the topological sort. This guarantees that an SCC is only
// solved after all SCCs it depends on have been solved.
int counter = 0;
for (auto sccIndexIt = optimalSccs.cbegin(); sccIndexIt != optimalSccs.cend() && converged; ++sccIndexIt) {
bool const useGpu = sccIndexIt->first;
storm::storage::StateBlock const& scc = sccIndexIt->second;

12
src/storage/expressions/BinaryBooleanFunctionExpression.cpp
View File

@ -15,13 +15,15 @@ namespace storm {
}
storm::expressions::OperatorType BinaryBooleanFunctionExpression::getOperator() const {
storm::expressions::OperatorType result = storm::expressions::OperatorType::And;
switch (this->getOperatorType()) {
case OperatorType::And: return storm::expressions::OperatorType::And; break;
case OperatorType::Or: return storm::expressions::OperatorType::Or; break;
case OperatorType::Xor: return storm::expressions::OperatorType::Xor; break;
case OperatorType::Implies: return storm::expressions::OperatorType::Implies; break;
case OperatorType::Iff: return storm::expressions::OperatorType::Iff; break;
case OperatorType::And: result = storm::expressions::OperatorType::And; break;
case OperatorType::Or: result = storm::expressions::OperatorType::Or; break;
case OperatorType::Xor: result = storm::expressions::OperatorType::Xor; break;
case OperatorType::Implies: result = storm::expressions::OperatorType::Implies; break;
case OperatorType::Iff: result = storm::expressions::OperatorType::Iff; break;
}
return result;
}
bool BinaryBooleanFunctionExpression::evaluateAsBool(Valuation const* valuation) const {

8
test/functional/modelchecker/NativeHybridMdpPrctlModelCheckerTest.cpp
View File

@ -24,8 +24,8 @@ TEST(NativeHybridMdpPrctlModelCheckerTest, Dice) {
options.buildRewards = true;
options.rewardModelName = "coinflips";
std::shared_ptr<storm::models::symbolic::Model<storm::dd::DdType::CUDD>> model = storm::builder::DdPrismModelBuilder<storm::dd::DdType::CUDD>::translateProgram(program, options);
EXPECT_EQ(169, model->getNumberOfStates());
EXPECT_EQ(436, model->getNumberOfTransitions());
EXPECT_EQ(169ul, model->getNumberOfStates());
EXPECT_EQ(436ul, model->getNumberOfTransitions());
ASSERT_EQ(model->getType(), storm::models::ModelType::Mdp);
@ -126,8 +126,8 @@ TEST(NativeHybridMdpPrctlModelCheckerTest, AsynchronousLeader) {
options.buildRewards = true;
options.rewardModelName = "rounds";
std::shared_ptr<storm::models::symbolic::Model<storm::dd::DdType::CUDD>> model = storm::builder::DdPrismModelBuilder<storm::dd::DdType::CUDD>::translateProgram(program, options);
EXPECT_EQ(3172, model->getNumberOfStates());
EXPECT_EQ(7144, model->getNumberOfTransitions());
EXPECT_EQ(3172ul, model->getNumberOfStates());
EXPECT_EQ(7144ul, model->getNumberOfTransitions());
ASSERT_EQ(model->getType(), storm::models::ModelType::Mdp);

2
test/functional/parser/AtomicPropositionLabelingParserTest.cpp
View File

@ -102,7 +102,7 @@ TEST(AtomicPropositionLabelingParserTest, MisspelledEndTagHeader) {
TEST(AtomicPropositionLabelingParserTest, NoLabelDeclaredNoneGiven) {
// No label between #DECLARATION and #END and no labels given.
storm::models::sparse::StateLabeling labeling = storm::parser::AtomicPropositionLabelingParser::parseAtomicPropositionLabeling(13, STORM_CPP_TESTS_BASE_PATH "/functional/parser/lab_files/labParser/noLabelsDecNoneGiven.lab");
ASSERT_EQ(labeling.getNumberOfLabels(), 0);
ASSERT_EQ(0ul, labeling.getNumberOfLabels());
for(uint_fast64_t i = 0; i < 13; i++) {
ASSERT_TRUE(labeling.getLabelsOfState(i).empty());
}

22
test/functional/parser/AutoParserTest.cpp
View File

@ -16,9 +16,9 @@ TEST(AutoParserTest, BasicParsing) {
// Test if parsed correctly.
ASSERT_EQ(storm::models::ModelType::Dtmc, modelPtr->getType());
ASSERT_EQ(12, modelPtr->getNumberOfStates());
ASSERT_EQ(26, modelPtr->getNumberOfTransitions());
ASSERT_EQ(1, modelPtr->getInitialStates().getNumberOfSetBits());
ASSERT_EQ(12ul, modelPtr->getNumberOfStates());
ASSERT_EQ(26ul, modelPtr->getNumberOfTransitions());
ASSERT_EQ(1ul, modelPtr->getInitialStates().getNumberOfSetBits());
ASSERT_TRUE(modelPtr->hasLabel("three"));
ASSERT_FALSE(modelPtr->hasStateRewards());
ASSERT_FALSE(modelPtr->hasTransitionRewards());
@ -40,27 +40,27 @@ TEST(AutoParserTest, Decision) {
// Dtmc
std::shared_ptr<storm::models::sparse::Model<double>> modelPtr = storm::parser::AutoParser::parseModel(STORM_CPP_TESTS_BASE_PATH "/functional/parser/tra_files/autoParser/dtmc.tra", STORM_CPP_TESTS_BASE_PATH "/functional/parser/lab_files/autoParser.lab");
ASSERT_EQ(storm::models::ModelType::Dtmc, modelPtr->getType());
ASSERT_EQ(12, modelPtr->getNumberOfStates());
ASSERT_EQ(26, modelPtr->getNumberOfTransitions());
ASSERT_EQ(12ul, modelPtr->getNumberOfStates());
ASSERT_EQ(26ul, modelPtr->getNumberOfTransitions());
// Ctmc
modelPtr.reset();
modelPtr = storm::parser::AutoParser::parseModel(STORM_CPP_TESTS_BASE_PATH "/functional/parser/tra_files/autoParser/ctmc.tra", STORM_CPP_TESTS_BASE_PATH "/functional/parser/lab_files/autoParser.lab");
ASSERT_EQ(storm::models::ModelType::Ctmc, modelPtr->getType());
ASSERT_EQ(12, modelPtr->getNumberOfStates());
ASSERT_EQ(26, modelPtr->getNumberOfTransitions());
ASSERT_EQ(12ul, modelPtr->getNumberOfStates());
ASSERT_EQ(26ul, modelPtr->getNumberOfTransitions());
// Mdp
modelPtr.reset();
modelPtr = storm::parser::AutoParser::parseModel(STORM_CPP_TESTS_BASE_PATH "/functional/parser/tra_files/autoParser/mdp.tra", STORM_CPP_TESTS_BASE_PATH "/functional/parser/lab_files/autoParser.lab");
ASSERT_EQ(storm::models::ModelType::Mdp, modelPtr->getType());
ASSERT_EQ(12, modelPtr->getNumberOfStates());
ASSERT_EQ(28, modelPtr->getNumberOfTransitions());
ASSERT_EQ(12ul, modelPtr->getNumberOfStates());
ASSERT_EQ(28ul, modelPtr->getNumberOfTransitions());
// MA
modelPtr.reset();
modelPtr = storm::parser::AutoParser::parseModel(STORM_CPP_TESTS_BASE_PATH "/functional/parser/tra_files/autoParser/ma.tra", STORM_CPP_TESTS_BASE_PATH "/functional/parser/lab_files/autoParser.lab");
ASSERT_EQ(storm::models::ModelType::MarkovAutomaton, modelPtr->getType());
ASSERT_EQ(12, modelPtr->getNumberOfStates());
ASSERT_EQ(27, modelPtr->getNumberOfTransitions());
ASSERT_EQ(12ul, modelPtr->getNumberOfStates());
ASSERT_EQ(27ul, modelPtr->getNumberOfTransitions());
}

24
test/functional/parser/DeterministicModelParserTest.cpp
View File

@ -18,14 +18,14 @@ TEST(DeterministicModelParserTest, BasicDtmcParsing) {
// Parse a Dtmc and check the result.
storm::models::sparse::Dtmc<double> dtmc(storm::parser::DeterministicModelParser::parseDtmc(STORM_CPP_TESTS_BASE_PATH "/functional/parser/tra_files/dtmc_general.tra", STORM_CPP_TESTS_BASE_PATH "/functional/parser/lab_files/dtmc_general.lab", STORM_CPP_TESTS_BASE_PATH "/functional/parser/rew_files/dtmc_general.state.rew", STORM_CPP_TESTS_BASE_PATH "/functional/parser/rew_files/dtmc_general.trans.rew"));
ASSERT_EQ(8, dtmc.getNumberOfStates());
ASSERT_EQ(16, dtmc.getNumberOfTransitions());
ASSERT_EQ(8ul, dtmc.getNumberOfStates());
ASSERT_EQ(16ul, dtmc.getNumberOfTransitions());
ASSERT_EQ(2, dtmc.getInitialStates().getNumberOfSetBits());
ASSERT_EQ(2ul, dtmc.getInitialStates().getNumberOfSetBits());
ASSERT_TRUE(dtmc.getInitialStates().get(0));
ASSERT_TRUE(dtmc.getInitialStates().get(7));
ASSERT_EQ(5, dtmc.getStateLabeling().getNumberOfLabels());
ASSERT_EQ(2, dtmc.getLabelsOfState(6).size());
ASSERT_EQ(5ul, dtmc.getStateLabeling().getNumberOfLabels());
ASSERT_EQ(2ul, dtmc.getLabelsOfState(6).size());
ASSERT_TRUE(dtmc.hasStateRewards());
ASSERT_EQ(42, dtmc.getStateRewardVector()[7]);
@ -36,7 +36,7 @@ TEST(DeterministicModelParserTest, BasicDtmcParsing) {
ASSERT_EQ(263.32, rewardSum);
ASSERT_TRUE(dtmc.hasTransitionRewards());
ASSERT_EQ(17, dtmc.getTransitionRewardMatrix().getEntryCount());
ASSERT_EQ(17ul, dtmc.getTransitionRewardMatrix().getEntryCount());
rewardSum = 0;
for(uint_fast64_t i = 0; i < dtmc.getTransitionRewardMatrix().getRowCount(); i++) {
rewardSum += dtmc.getTransitionRewardMatrix().getRowSum(i);
@ -50,14 +50,14 @@ TEST(DeterministicModelParserTest, BasicCtmcParsing) {
// Parse a Ctmc and check the result.
storm::models::sparse::Ctmc<double> ctmc(storm::parser::DeterministicModelParser::parseCtmc(STORM_CPP_TESTS_BASE_PATH "/functional/parser/tra_files/dtmc_general.tra", STORM_CPP_TESTS_BASE_PATH "/functional/parser/lab_files/dtmc_general.lab", STORM_CPP_TESTS_BASE_PATH "/functional/parser/rew_files/dtmc_general.state.rew", STORM_CPP_TESTS_BASE_PATH "/functional/parser/rew_files/dtmc_general.trans.rew"));
ASSERT_EQ(8, ctmc.getNumberOfStates());
ASSERT_EQ(16, ctmc.getNumberOfTransitions());
ASSERT_EQ(8ul, ctmc.getNumberOfStates());
ASSERT_EQ(16ul, ctmc.getNumberOfTransitions());
ASSERT_EQ(2, ctmc.getInitialStates().getNumberOfSetBits());
ASSERT_EQ(2ul, ctmc.getInitialStates().getNumberOfSetBits());
ASSERT_TRUE(ctmc.getInitialStates().get(0));
ASSERT_TRUE(ctmc.getInitialStates().get(7));
ASSERT_EQ(5, ctmc.getStateLabeling().getNumberOfLabels());
ASSERT_EQ(2, ctmc.getLabelsOfState(6).size());
ASSERT_EQ(5ul, ctmc.getStateLabeling().getNumberOfLabels());
ASSERT_EQ(2ul, ctmc.getLabelsOfState(6).size());
ASSERT_TRUE(ctmc.hasStateRewards());
ASSERT_EQ(42, ctmc.getStateRewardVector()[7]);
@ -68,7 +68,7 @@ TEST(DeterministicModelParserTest, BasicCtmcParsing) {
ASSERT_EQ(263.32, rewardSum);
ASSERT_TRUE(ctmc.hasTransitionRewards());
ASSERT_EQ(17, ctmc.getTransitionRewardMatrix().getEntryCount());
ASSERT_EQ(17ul, ctmc.getTransitionRewardMatrix().getEntryCount());
rewardSum = 0;
for(uint_fast64_t i = 0; i < ctmc.getTransitionRewardMatrix().getRowCount(); i++) {
rewardSum += ctmc.getTransitionRewardMatrix().getRowSum(i);

90
test/functional/parser/DeterministicSparseTransitionParserTest.cpp
View File

@ -29,73 +29,73 @@ TEST(DeterministicSparseTransitionParserTest, BasicTransitionsParsing) {
// Parse a deterministic transitions file and test the resulting matrix.
storm::storage::SparseMatrix<double> transitionMatrix = storm::parser::DeterministicSparseTransitionParser::parseDeterministicTransitions(STORM_CPP_TESTS_BASE_PATH "/functional/parser/tra_files/dtmc_general.tra");
ASSERT_EQ(8, transitionMatrix.getColumnCount());
ASSERT_EQ(21, transitionMatrix.getEntryCount());
ASSERT_EQ(8ul, transitionMatrix.getColumnCount());
ASSERT_EQ(21ul, transitionMatrix.getEntryCount());
// Test every entry of the matrix.
storm::storage::SparseMatrix<double>::const_iterator cIter = transitionMatrix.begin(0);
ASSERT_EQ(0, cIter->getColumn());
ASSERT_EQ(0ul, cIter->getColumn());
ASSERT_EQ(0, cIter->getValue());
cIter++;
ASSERT_EQ(1, cIter->getColumn());
ASSERT_EQ(1ul, cIter->getColumn());
ASSERT_EQ(1, cIter->getValue());
cIter++;
ASSERT_EQ(1, cIter->getColumn());
ASSERT_EQ(1ul, cIter->getColumn());
ASSERT_EQ(0, cIter->getValue());
cIter++;
ASSERT_EQ(2, cIter->getColumn());
ASSERT_EQ(2ul, cIter->getColumn());
ASSERT_EQ(0.5, cIter->getValue());
cIter++;
ASSERT_EQ(3, cIter->getColumn());
ASSERT_EQ(3ul, cIter->getColumn());
ASSERT_EQ(0.5, cIter->getValue());
cIter++;
ASSERT_EQ(2, cIter->getColumn());
ASSERT_EQ(2ul, cIter->getColumn());
ASSERT_EQ(0, cIter->getValue());
cIter++;
ASSERT_EQ(3, cIter->getColumn());
ASSERT_EQ(3ul, cIter->getColumn());
ASSERT_EQ(0.4, cIter->getValue());
cIter++;
ASSERT_EQ(4, cIter->getColumn());
ASSERT_EQ(4ul, cIter->getColumn());
ASSERT_EQ(0.4, cIter->getValue());
cIter++;
ASSERT_EQ(5, cIter->getColumn());
ASSERT_EQ(5ul, cIter->getColumn());
ASSERT_EQ(0.2, cIter->getValue());
cIter++;
ASSERT_EQ(3, cIter->getColumn());
ASSERT_EQ(3ul, cIter->getColumn());
ASSERT_EQ(1, cIter->getValue());
cIter++;
ASSERT_EQ(3, cIter->getColumn());
ASSERT_EQ(3ul, cIter->getColumn());
ASSERT_EQ(1, cIter->getValue());
cIter++;
ASSERT_EQ(4, cIter->getColumn());
ASSERT_EQ(4ul, cIter->getColumn());
ASSERT_EQ(0, cIter->getValue());
cIter++;
ASSERT_EQ(3, cIter->getColumn());
ASSERT_EQ(3ul, cIter->getColumn());
ASSERT_EQ(0.1, cIter->getValue());
cIter++;
ASSERT_EQ(4, cIter->getColumn());
ASSERT_EQ(4ul, cIter->getColumn());
ASSERT_EQ(0.1, cIter->getValue());
cIter++;
ASSERT_EQ(5, cIter->getColumn());
ASSERT_EQ(5ul, cIter->getColumn());
ASSERT_EQ(0.1, cIter->getValue());
cIter++;
ASSERT_EQ(6, cIter->getColumn());
ASSERT_EQ(6ul, cIter->getColumn());
ASSERT_EQ(0.7, cIter->getValue());
cIter++;
ASSERT_EQ(0, cIter->getColumn());
ASSERT_EQ(0ul, cIter->getColumn());
ASSERT_EQ(0.9, cIter->getValue());
cIter++;
ASSERT_EQ(5, cIter->getColumn());
ASSERT_EQ(5ul, cIter->getColumn());
ASSERT_EQ(0, cIter->getValue());
cIter++;
ASSERT_EQ(6, cIter->getColumn());
ASSERT_EQ(6ul, cIter->getColumn());
ASSERT_EQ(0.1, cIter->getValue());
cIter++;
ASSERT_EQ(6, cIter->getColumn());
ASSERT_EQ(6ul, cIter->getColumn());
ASSERT_EQ(0.224653, cIter->getValue());
cIter++;
ASSERT_EQ(7, cIter->getColumn());
ASSERT_EQ(7ul, cIter->getColumn());
ASSERT_EQ(0.775347, cIter->getValue());
}
@ -112,55 +112,55 @@ TEST(DeterministicSparseTransitionParserTest, BasicTransitionsRewardsParsing) {
// Test every entry of the matrix.
storm::storage::SparseMatrix<double>::const_iterator cIter = rewardMatrix.begin(0);
ASSERT_EQ(1, cIter->getColumn());
ASSERT_EQ(1ul, cIter->getColumn());
ASSERT_EQ(10, cIter->getValue());
cIter++;
ASSERT_EQ(2, cIter->getColumn());
ASSERT_EQ(2ul, cIter->getColumn());
ASSERT_EQ(5, cIter->getValue());
cIter++;
ASSERT_EQ(3, cIter->getColumn());
ASSERT_EQ(3ul, cIter->getColumn());
ASSERT_EQ(5.5, cIter->getValue());
cIter++;
ASSERT_EQ(3, cIter->getColumn());
ASSERT_EQ(3ul, cIter->getColumn());
ASSERT_EQ(21.4, cIter->getValue());
cIter++;
ASSERT_EQ(4, cIter->getColumn());
ASSERT_EQ(4ul, cIter->getColumn());
ASSERT_EQ(4, cIter->getValue());
cIter++;
ASSERT_EQ(5, cIter->getColumn());
ASSERT_EQ(5ul, cIter->getColumn());
ASSERT_EQ(2, cIter->getValue());
cIter++;
ASSERT_EQ(3, cIter->getColumn());
ASSERT_EQ(3ul, cIter->getColumn());
ASSERT_EQ(1, cIter->getValue());
cIter++;
ASSERT_EQ(3, cIter->getColumn());
ASSERT_EQ(3ul, cIter->getColumn());
ASSERT_EQ(1, cIter->getValue());
cIter++;
ASSERT_EQ(3, cIter->getColumn());
ASSERT_EQ(3ul, cIter->getColumn());
ASSERT_EQ(0.1, cIter->getValue());
cIter++;
ASSERT_EQ(4, cIter->getColumn());
ASSERT_EQ(4ul, cIter->getColumn());
ASSERT_EQ(1.1, cIter->getValue());
cIter++;
ASSERT_EQ(5, cIter->getColumn());
ASSERT_EQ(5ul, cIter->getColumn());
ASSERT_EQ(9.5, cIter->getValue());
cIter++;
ASSERT_EQ(6, cIter->getColumn());
ASSERT_EQ(6ul, cIter->getColumn());
ASSERT_EQ(6.7, cIter->getValue());
cIter++;
ASSERT_EQ(0, cIter->getColumn());
ASSERT_EQ(0ul, cIter->getColumn());
ASSERT_EQ(1, cIter->getValue());
cIter++;
ASSERT_EQ(5, cIter->getColumn());
ASSERT_EQ(5ul, cIter->getColumn());
ASSERT_EQ(0, cIter->getValue());
cIter++;
ASSERT_EQ(6, cIter->getColumn());
ASSERT_EQ(6ul, cIter->getColumn());
ASSERT_EQ(12, cIter->getValue());
cIter++;
ASSERT_EQ(6, cIter->getColumn());
ASSERT_EQ(6ul, cIter->getColumn());
ASSERT_EQ(35.224653, cIter->getValue());
cIter++;
ASSERT_EQ(7, cIter->getColumn());
ASSERT_EQ(7ul, cIter->getColumn());
ASSERT_EQ(9.875347, cIter->getValue());
}
@ -196,20 +196,20 @@ TEST(DeterministicSparseTransitionParserTest, FixDeadlocks) {
// Parse a transitions file with the fixDeadlocks Flag set and test if it works.
storm::storage::SparseMatrix<double> transitionMatrix = storm::parser::DeterministicSparseTransitionParser::parseDeterministicTransitions(STORM_CPP_TESTS_BASE_PATH "/functional/parser/tra_files/dtmc_deadlock.tra");
ASSERT_EQ(9, transitionMatrix.getColumnCount());
ASSERT_EQ(9ul, transitionMatrix.getColumnCount());
ASSERT_EQ(23, transitionMatrix.getEntryCount());
storm::storage::SparseMatrix<double>::const_iterator cIter = transitionMatrix.begin(7);
ASSERT_EQ(7, cIter->getColumn());
ASSERT_EQ(7ul, cIter->getColumn());
ASSERT_EQ(1, cIter->getValue());
cIter++;
ASSERT_EQ(6, cIter->getColumn());
ASSERT_EQ(6ul, cIter->getColumn());
ASSERT_EQ(0.224653, cIter->getValue());
cIter++;
ASSERT_EQ(7, cIter->getColumn());
ASSERT_EQ(7ul, cIter->getColumn());
ASSERT_EQ(0.775347, cIter->getValue());
cIter++;
ASSERT_EQ(8, cIter->getColumn());
ASSERT_EQ(8ul, cIter->getColumn());
ASSERT_EQ(0, cIter->getValue());
}

14
test/functional/parser/MarkovAutomatonParserTest.cpp
View File

@ -16,9 +16,9 @@ TEST(MarkovAutomatonParserTest, BasicParsing) {
storm::models::sparse::MarkovAutomaton<double> result = storm::parser::MarkovAutomatonParser::parseMarkovAutomaton(STORM_CPP_TESTS_BASE_PATH "/functional/parser/tra_files/ma_general.tra", STORM_CPP_TESTS_BASE_PATH "/functional/parser/lab_files/ma_general.lab", STORM_CPP_TESTS_BASE_PATH "/functional/parser/rew_files/ma_general.state.rew");
// Test sizes and counts.
ASSERT_EQ(6, result.getNumberOfStates());
ASSERT_EQ(7, result.getNumberOfChoices());
ASSERT_EQ(12, result.getNumberOfTransitions());
ASSERT_EQ(6ul, result.getNumberOfStates());
ASSERT_EQ(7ul, result.getNumberOfChoices());
ASSERT_EQ(12ul, result.getNumberOfTransitions());
// Test the exit rates. These have to be 0 for all non-Markovian states.
std::vector<double> rates = result.getExitRates();
@ -34,10 +34,10 @@ TEST(MarkovAutomatonParserTest, BasicParsing) {
ASSERT_EQ(0, result.getExitRate(5));
// Test the labeling.
ASSERT_EQ(3, result.getStateLabeling().getNumberOfLabels());
ASSERT_EQ(1, result.getInitialStates().getNumberOfSetBits());
ASSERT_EQ(0, result.getLabelsOfState(4).size());
ASSERT_EQ(1, result.getStateLabeling().getStates("goal").getNumberOfSetBits());
ASSERT_EQ(3ul, result.getStateLabeling().getNumberOfLabels());
ASSERT_EQ(1ul, result.getInitialStates().getNumberOfSetBits());
ASSERT_EQ(0ul, result.getLabelsOfState(4).size());
ASSERT_EQ(1ul, result.getStateLabeling().getStates("goal").getNumberOfSetBits());
// Test the state rewards.
ASSERT_TRUE(result.hasStateRewards());

56
test/functional/parser/MarkovAutomatonSparseTransitionParserTest.cpp
View File

@ -18,8 +18,8 @@
#include "src/exceptions/WrongFormatException.h"
#include "src/exceptions/FileIoException.h"
#define STATE_COUNT 6
#define CHOICE_COUNT 7
#define STATE_COUNT 6ul
#define CHOICE_COUNT 7ul
TEST(MarkovAutomatonSparseTransitionParserTest, NonExistingFile) {
@ -41,24 +41,24 @@ TEST(MarkovAutomatonSparseTransitionParserTest, BasicParsing) {
// Test all sizes and counts.
ASSERT_EQ(STATE_COUNT, transitionMatrix.getColumnCount());
ASSERT_EQ(CHOICE_COUNT, transitionMatrix.getRowCount());
ASSERT_EQ(12, transitionMatrix.getEntryCount());
ASSERT_EQ(6, transitionMatrix.getRowGroupCount());
ASSERT_EQ(7, transitionMatrix.getRowGroupIndices().size());
ASSERT_EQ(12ul, transitionMatrix.getEntryCount());
ASSERT_EQ(6ul, transitionMatrix.getRowGroupCount());
ASSERT_EQ(7ul, transitionMatrix.getRowGroupIndices().size());
ASSERT_EQ(CHOICE_COUNT, result.markovianChoices.size());
ASSERT_EQ(STATE_COUNT, result.markovianStates.size());
ASSERT_EQ(2, result.markovianStates.getNumberOfSetBits());
ASSERT_EQ(2ul, result.markovianStates.getNumberOfSetBits());
ASSERT_EQ(STATE_COUNT, result.exitRates.size());
// Test the general structure of the transition system (that will be an Markov automaton).
// Test the mapping between states and transition matrix rows.
ASSERT_EQ(0, transitionMatrix.getRowGroupIndices()[0]);
ASSERT_EQ(1, transitionMatrix.getRowGroupIndices()[1]);
ASSERT_EQ(2, transitionMatrix.getRowGroupIndices()[2]);
ASSERT_EQ(3, transitionMatrix.getRowGroupIndices()[3]);
ASSERT_EQ(4, transitionMatrix.getRowGroupIndices()[4]);
ASSERT_EQ(6, transitionMatrix.getRowGroupIndices()[5]);
ASSERT_EQ(7, transitionMatrix.getRowGroupIndices()[6]);
ASSERT_EQ(0ul, transitionMatrix.getRowGroupIndices()[0]);
ASSERT_EQ(1ul, transitionMatrix.getRowGroupIndices()[1]);
ASSERT_EQ(2ul, transitionMatrix.getRowGroupIndices()[2]);
ASSERT_EQ(3ul, transitionMatrix.getRowGroupIndices()[3]);
ASSERT_EQ(4ul, transitionMatrix.getRowGroupIndices()[4]);
ASSERT_EQ(6ul, transitionMatrix.getRowGroupIndices()[5]);
ASSERT_EQ(7ul, transitionMatrix.getRowGroupIndices()[6]);
// Test the Markovian states.
ASSERT_TRUE(result.markovianStates.get(0));
@ -119,24 +119,24 @@ TEST(MarkovAutomatonSparseTransitionParserTest, Whitespaces) {
// Test all sizes and counts.
ASSERT_EQ(STATE_COUNT, transitionMatrix.getColumnCount());
ASSERT_EQ(CHOICE_COUNT, transitionMatrix.getRowCount());
ASSERT_EQ(12, transitionMatrix.getEntryCount());
ASSERT_EQ(6, transitionMatrix.getRowGroupCount());
ASSERT_EQ(7, transitionMatrix.getRowGroupIndices().size());
ASSERT_EQ(12ul, transitionMatrix.getEntryCount());
ASSERT_EQ(6ul, transitionMatrix.getRowGroupCount());
ASSERT_EQ(7ul, transitionMatrix.getRowGroupIndices().size());
ASSERT_EQ(CHOICE_COUNT, result.markovianChoices.size());
ASSERT_EQ(STATE_COUNT, result.markovianStates.size());
ASSERT_EQ(2, result.markovianStates.getNumberOfSetBits());
ASSERT_EQ(2ul, result.markovianStates.getNumberOfSetBits());
ASSERT_EQ(STATE_COUNT, result.exitRates.size());
// Test the general structure of the transition system (that will be an Markov automaton).
// Test the mapping between states and transition matrix rows.
ASSERT_EQ(0, transitionMatrix.getRowGroupIndices()[0]);
ASSERT_EQ(1, transitionMatrix.getRowGroupIndices()[1]);
ASSERT_EQ(2, transitionMatrix.getRowGroupIndices()[2]);
ASSERT_EQ(3, transitionMatrix.getRowGroupIndices()[3]);
ASSERT_EQ(4, transitionMatrix.getRowGroupIndices()[4]);
ASSERT_EQ(6, transitionMatrix.getRowGroupIndices()[5]);
ASSERT_EQ(7, transitionMatrix.getRowGroupIndices()[6]);
ASSERT_EQ(0ul, transitionMatrix.getRowGroupIndices()[0]);
ASSERT_EQ(1ul, transitionMatrix.getRowGroupIndices()[1]);
ASSERT_EQ(2ul, transitionMatrix.getRowGroupIndices()[2]);
ASSERT_EQ(3ul, transitionMatrix.getRowGroupIndices()[3]);
ASSERT_EQ(4ul, transitionMatrix.getRowGroupIndices()[4]);
ASSERT_EQ(6ul, transitionMatrix.getRowGroupIndices()[5]);
ASSERT_EQ(7ul, transitionMatrix.getRowGroupIndices()[6]);
// Test the Markovian states.
ASSERT_TRUE(result.markovianStates.get(0));
@ -194,12 +194,12 @@ TEST(MarkovAutomatonSparseTransitionParserTest, FixDeadlocks) {
// Test if the result is consistent with the parsed Markov Automaton.
storm::storage::SparseMatrix<double> resultMatrix(result.transitionMatrixBuilder.build());
ASSERT_EQ(STATE_COUNT + 1, resultMatrix.getColumnCount());
ASSERT_EQ(13, resultMatrix.getEntryCount());
ASSERT_EQ(7, resultMatrix.getRowGroupCount());
ASSERT_EQ(8, resultMatrix.getRowGroupIndices().size());
ASSERT_EQ(13ul, resultMatrix.getEntryCount());
ASSERT_EQ(7ul, resultMatrix.getRowGroupCount());
ASSERT_EQ(8ul, resultMatrix.getRowGroupIndices().size());
ASSERT_EQ(CHOICE_COUNT +1, result.markovianChoices.size());
ASSERT_EQ(STATE_COUNT +1, result.markovianStates.size());
ASSERT_EQ(2, result.markovianStates.getNumberOfSetBits());
ASSERT_EQ(2ul, result.markovianStates.getNumberOfSetBits());
ASSERT_EQ(STATE_COUNT + 1, result.exitRates.size());
}

8
test/functional/parser/PrismParserTest.cpp
View File

@ -43,7 +43,7 @@ TEST(PrismParser, SimpleTest) {
[] x=5 -> 1: true;
endmodule)";
EXPECT_NO_THROW(result = storm::parser::PrismParser::parseFromString(testInput, "testfile"));
EXPECT_EQ(1, result.getNumberOfModules());
EXPECT_EQ(1ul, result.getNumberOfModules());
EXPECT_EQ(storm::prism::Program::ModelType::MDP, result.getModelType());
}
@ -99,9 +99,9 @@ TEST(PrismParser, ComplexTest) {
storm::prism::Program result;
EXPECT_NO_THROW(result = storm::parser::PrismParser::parseFromString(testInput, "testfile"));
EXPECT_EQ(storm::prism::Program::ModelType::MA, result.getModelType());
EXPECT_EQ(3, result.getNumberOfModules());
EXPECT_EQ(2, result.getNumberOfRewardModels());
EXPECT_EQ(1, result.getNumberOfLabels());
EXPECT_EQ(3ul, result.getNumberOfModules());
EXPECT_EQ(2ul, result.getNumberOfRewardModels());
EXPECT_EQ(1ul, result.getNumberOfLabels());
}
TEST(PrismParser, IllegalInputTest) {

48
test/functional/solver/GlpkLpSolverTest.cpp
View File

@ -159,14 +159,10 @@ TEST(GlpkLpSolver, LPInfeasible) {
ASSERT_FALSE(solver.isOptimal());
ASSERT_FALSE(solver.isUnbounded());
ASSERT_TRUE(solver.isInfeasible());
double xValue = 0;
ASSERT_THROW(xValue = solver.getContinuousValue(x), storm::exceptions::InvalidAccessException);
double yValue = 0;
ASSERT_THROW(yValue = solver.getContinuousValue(y), storm::exceptions::InvalidAccessException);
double zValue = 0;
ASSERT_THROW(zValue = solver.getContinuousValue(z), storm::exceptions::InvalidAccessException);
double objectiveValue = 0;
ASSERT_THROW(objectiveValue = solver.getObjectiveValue(), storm::exceptions::InvalidAccessException);
ASSERT_THROW(solver.getContinuousValue(x), storm::exceptions::InvalidAccessException);
ASSERT_THROW(solver.getContinuousValue(y), storm::exceptions::InvalidAccessException);
ASSERT_THROW(solver.getContinuousValue(z), storm::exceptions::InvalidAccessException);
ASSERT_THROW(solver.getObjectiveValue(), storm::exceptions::InvalidAccessException);
}
TEST(GlpkLpSolver, MILPInfeasible) {
@ -189,14 +185,10 @@ TEST(GlpkLpSolver, MILPInfeasible) {
ASSERT_FALSE(solver.isOptimal());
ASSERT_FALSE(solver.isUnbounded());
ASSERT_TRUE(solver.isInfeasible());
bool xValue = false;
ASSERT_THROW(xValue = solver.getBinaryValue(x), storm::exceptions::InvalidAccessException);
int_fast64_t yValue = 0;
ASSERT_THROW(yValue = solver.getIntegerValue(y), storm::exceptions::InvalidAccessException);
double zValue = 0;
ASSERT_THROW(zValue = solver.getContinuousValue(z), storm::exceptions::InvalidAccessException);
double objectiveValue = 0;
ASSERT_THROW(objectiveValue = solver.getObjectiveValue(), storm::exceptions::InvalidAccessException);
ASSERT_THROW(solver.getBinaryValue(x), storm::exceptions::InvalidAccessException);
ASSERT_THROW(solver.getIntegerValue(y), storm::exceptions::InvalidAccessException);
ASSERT_THROW(solver.getContinuousValue(z), storm::exceptions::InvalidAccessException);
ASSERT_THROW(solver.getObjectiveValue(), storm::exceptions::InvalidAccessException);
}
TEST(GlpkLpSolver, LPUnbounded) {
@ -217,14 +209,10 @@ TEST(GlpkLpSolver, LPUnbounded) {
ASSERT_FALSE(solver.isOptimal());
ASSERT_TRUE(solver.isUnbounded());
ASSERT_FALSE(solver.isInfeasible());
double xValue = 0;
ASSERT_THROW(xValue = solver.getContinuousValue(x), storm::exceptions::InvalidAccessException);
double yValue = 0;
ASSERT_THROW(yValue = solver.getContinuousValue(y), storm::exceptions::InvalidAccessException);
double zValue = 0;
ASSERT_THROW(zValue = solver.getContinuousValue(z), storm::exceptions::InvalidAccessException);
double objectiveValue = 0;
ASSERT_THROW(objectiveValue = solver.getObjectiveValue(), storm::exceptions::InvalidAccessException);
ASSERT_THROW(solver.getContinuousValue(x), storm::exceptions::InvalidAccessException);
ASSERT_THROW(solver.getContinuousValue(y), storm::exceptions::InvalidAccessException);
ASSERT_THROW(solver.getContinuousValue(z), storm::exceptions::InvalidAccessException);
ASSERT_THROW(solver.getObjectiveValue(), storm::exceptions::InvalidAccessException);
}
TEST(GlpkLpSolver, MILPUnbounded) {
@ -245,13 +233,9 @@ TEST(GlpkLpSolver, MILPUnbounded) {
ASSERT_FALSE(solver.isOptimal());
ASSERT_TRUE(solver.isUnbounded());
ASSERT_FALSE(solver.isInfeasible());
bool xValue = false;
ASSERT_THROW(xValue = solver.getBinaryValue(x), storm::exceptions::InvalidAccessException);
int_fast64_t yValue = 0;
ASSERT_THROW(yValue = solver.getIntegerValue(y), storm::exceptions::InvalidAccessException);
double zValue = 0;
ASSERT_THROW(zValue = solver.getContinuousValue(z), storm::exceptions::InvalidAccessException);
double objectiveValue = 0;
ASSERT_THROW(objectiveValue = solver.getObjectiveValue(), storm::exceptions::InvalidAccessException);
ASSERT_THROW(solver.getBinaryValue(x), storm::exceptions::InvalidAccessException);
ASSERT_THROW(solver.getIntegerValue(y), storm::exceptions::InvalidAccessException);
ASSERT_THROW(solver.getContinuousValue(z), storm::exceptions::InvalidAccessException);
ASSERT_THROW(solver.getObjectiveValue(), storm::exceptions::InvalidAccessException);
}
#endif

14
test/functional/storage/BitVectorHashMapTest.cpp
View File

@ -18,7 +18,7 @@ TEST(BitVectorHashMapTest, FindOrAdd) {
second.set(18);
ASSERT_NO_THROW(map.findOrAdd(second, 2));
EXPECT_EQ(1, map.findOrAdd(first, 3));
EXPECT_EQ(1ul, map.findOrAdd(first, 3));
storm::storage::BitVector third(64);
third.set(10);
@ -44,10 +44,10 @@ TEST(BitVectorHashMapTest, FindOrAdd) {
ASSERT_NO_THROW(map.findOrAdd(sixth, 6));
EXPECT_EQ(1, map.findOrAdd(first, 0));
EXPECT_EQ(2, map.findOrAdd(second, 0));
EXPECT_EQ(3, map.findOrAdd(third, 0));
EXPECT_EQ(4, map.findOrAdd(fourth, 0));
EXPECT_EQ(5, map.findOrAdd(fifth, 0));
EXPECT_EQ(6, map.findOrAdd(sixth, 0));
EXPECT_EQ(1ul, map.findOrAdd(first, 0));
EXPECT_EQ(2ul, map.findOrAdd(second, 0));
EXPECT_EQ(3ul, map.findOrAdd(third, 0));
EXPECT_EQ(4ul, map.findOrAdd(fourth, 0));
EXPECT_EQ(5ul, map.findOrAdd(fifth, 0));
EXPECT_EQ(6ul, map.findOrAdd(sixth, 0));
}

6
test/functional/storage/BitVectorTest.cpp
View File

@ -28,7 +28,7 @@ TEST(BitVectorTest, InitFromIterator) {
std::vector<uint_fast64_t> valueVector = {0, 4, 10};
storm::storage::BitVector vector(32, valueVector.begin(), valueVector.end());
ASSERT_EQ(32, vector.size());
ASSERT_EQ(32ul, vector.size());
for (uint_fast64_t i = 0; i < 32; ++i) {
if (i == 0 || i == 4 || i == 10) {
@ -296,8 +296,8 @@ TEST(BitVectorTest, OperatorModulo) {
storm::storage::BitVector moduloResult = vector1 % vector2;
ASSERT_EQ(moduloResult.size(), 8);
ASSERT_EQ(moduloResult.getNumberOfSetBits(), 2);
ASSERT_EQ(8ul, moduloResult.size());
ASSERT_EQ(2ul, moduloResult.getNumberOfSetBits());
for (uint_fast64_t i = 0; i < 8; ++i) {
if (i == 1 || i == 3) {

40
test/functional/storage/DeterministicModelBisimulationDecompositionTest.cpp
View File

@ -14,8 +14,8 @@ TEST(DeterministicModelBisimulationDecomposition, Die) {
ASSERT_NO_THROW(result = bisim.getQuotient());
EXPECT_EQ(storm::models::ModelType::Dtmc, result->getType());
EXPECT_EQ(13, result->getNumberOfStates());
EXPECT_EQ(20, result->getNumberOfTransitions());
EXPECT_EQ(13ul, result->getNumberOfStates());
EXPECT_EQ(20ul, result->getNumberOfTransitions());
#ifdef WINDOWS
storm::storage::DeterministicModelBisimulationDecomposition<double>::Options options;
@ -28,8 +28,8 @@ TEST(DeterministicModelBisimulationDecomposition, Die) {
ASSERT_NO_THROW(result = bisim2.getQuotient());
EXPECT_EQ(storm::models::ModelType::Dtmc, result->getType());
EXPECT_EQ(5, result->getNumberOfStates());
EXPECT_EQ(8, result->getNumberOfTransitions());
EXPECT_EQ(5ul, result->getNumberOfStates());
EXPECT_EQ(8ul, result->getNumberOfTransitions());
options.bounded = false;
options.weak = true;
@ -38,8 +38,8 @@ TEST(DeterministicModelBisimulationDecomposition, Die) {
ASSERT_NO_THROW(result = bisim3.getQuotient());
EXPECT_EQ(storm::models::ModelType::Dtmc, result->getType());
EXPECT_EQ(5, result->getNumberOfStates());
EXPECT_EQ(8, result->getNumberOfTransitions());
EXPECT_EQ(5ul, result->getNumberOfStates());
EXPECT_EQ(8ul, result->getNumberOfTransitions());
auto labelFormula = std::make_shared<storm::logic::AtomicLabelFormula>("one");
auto eventuallyFormula = std::make_shared<storm::logic::EventuallyFormula>(labelFormula);
@ -53,8 +53,8 @@ TEST(DeterministicModelBisimulationDecomposition, Die) {
storm::storage::DeterministicModelBisimulationDecomposition<double> bisim4(*dtmc, options2);
ASSERT_NO_THROW(result = bisim4.getQuotient());
EXPECT_EQ(storm::models::ModelType::Dtmc, result->getType());
EXPECT_EQ(5, result->getNumberOfStates());
EXPECT_EQ(8, result->getNumberOfTransitions());
EXPECT_EQ(5ul, result->getNumberOfStates());
EXPECT_EQ(8ul, result->getNumberOfTransitions());
}
TEST(DeterministicModelBisimulationDecomposition, Crowds) {
@ -68,8 +68,8 @@ TEST(DeterministicModelBisimulationDecomposition, Crowds) {
ASSERT_NO_THROW(result = bisim.getQuotient());
EXPECT_EQ(storm::models::ModelType::Dtmc, result->getType());
EXPECT_EQ(334, result->getNumberOfStates());
EXPECT_EQ(546, result->getNumberOfTransitions());
EXPECT_EQ(334ul, result->getNumberOfStates());
EXPECT_EQ(546ul, result->getNumberOfTransitions());
#ifdef WINDOWS
storm::storage::DeterministicModelBisimulationDecomposition<double>::Options options;
@ -82,8 +82,8 @@ TEST(DeterministicModelBisimulationDecomposition, Crowds) {
ASSERT_NO_THROW(result = bisim2.getQuotient());
EXPECT_EQ(storm::models::ModelType::Dtmc, result->getType());
EXPECT_EQ(65, result->getNumberOfStates());
EXPECT_EQ(105, result->getNumberOfTransitions());
EXPECT_EQ(65ul, result->getNumberOfStates());
EXPECT_EQ(105ul, result->getNumberOfTransitions());
options.bounded = false;
options.weak = true;
@ -92,8 +92,8 @@ TEST(DeterministicModelBisimulationDecomposition, Crowds) {
ASSERT_NO_THROW(result = bisim3.getQuotient());
EXPECT_EQ(storm::models::ModelType::Dtmc, result->getType());
EXPECT_EQ(43, result->getNumberOfStates());
EXPECT_EQ(83, result->getNumberOfTransitions());
EXPECT_EQ(43ul, result->getNumberOfStates());
EXPECT_EQ(83ul, result->getNumberOfTransitions());
auto labelFormula = std::make_shared<storm::logic::AtomicLabelFormula>("observe0Greater1");
auto eventuallyFormula = std::make_shared<storm::logic::EventuallyFormula>(labelFormula);
@ -107,8 +107,8 @@ TEST(DeterministicModelBisimulationDecomposition, Crowds) {
ASSERT_NO_THROW(result = bisim4.getQuotient());
EXPECT_EQ(storm::models::ModelType::Dtmc, result->getType());
EXPECT_EQ(64, result->getNumberOfStates());
EXPECT_EQ(104, result->getNumberOfTransitions());
EXPECT_EQ(64ul, result->getNumberOfStates());
EXPECT_EQ(104ul, result->getNumberOfTransitions());
auto probabilityOperatorFormula = std::make_shared<storm::logic::ProbabilityOperatorFormula>(eventuallyFormula);
@ -121,8 +121,8 @@ TEST(DeterministicModelBisimulationDecomposition, Crowds) {
ASSERT_NO_THROW(result = bisim5.getQuotient());
EXPECT_EQ(storm::models::ModelType::Dtmc, result->getType());
EXPECT_EQ(64, result->getNumberOfStates());
EXPECT_EQ(104, result->getNumberOfTransitions());
EXPECT_EQ(64ul, result->getNumberOfStates());
EXPECT_EQ(104ul, result->getNumberOfTransitions());
auto boundedUntilFormula = std::make_shared<storm::logic::BoundedUntilFormula>(std::make_shared<storm::logic::BooleanLiteralFormula>(true), labelFormula, 50);
@ -135,6 +135,6 @@ TEST(DeterministicModelBisimulationDecomposition, Crowds) {
ASSERT_NO_THROW(result = bisim6.getQuotient());
EXPECT_EQ(storm::models::ModelType::Dtmc, result->getType());
EXPECT_EQ(65, result->getNumberOfStates());
EXPECT_EQ(105, result->getNumberOfTransitions());
EXPECT_EQ(65ul, result->getNumberOfStates());
EXPECT_EQ(105ul, result->getNumberOfTransitions());
}

6
test/functional/storage/MaximalEndComponentDecompositionTest.cpp
View File

@ -12,7 +12,7 @@ TEST(MaximalEndComponentDecomposition, FullSystem1) {
storm::storage::MaximalEndComponentDecomposition<double> mecDecomposition;
ASSERT_NO_THROW(mecDecomposition = storm::storage::MaximalEndComponentDecomposition<double>(*markovAutomaton));
ASSERT_EQ(2, mecDecomposition.size());
ASSERT_EQ(2ul, mecDecomposition.size());
// Now, because there is no ordering we have to check the contents of the MECs in a symmetrical way.
storm::storage::MaximalEndComponent const& mec1 = mecDecomposition[0];
@ -80,7 +80,7 @@ TEST(MaximalEndComponentDecomposition, FullSystem2) {
storm::storage::MaximalEndComponentDecomposition<double> mecDecomposition;
ASSERT_NO_THROW(mecDecomposition = storm::storage::MaximalEndComponentDecomposition<double>(*markovAutomaton));
ASSERT_EQ(1, mecDecomposition.size());
ASSERT_EQ(1ul, mecDecomposition.size());
// Now, because there is no ordering we have to check the contents of the MECs in a symmetrical way.
storm::storage::MaximalEndComponent const& mec1 = mecDecomposition[0];
@ -112,7 +112,7 @@ TEST(MaximalEndComponentDecomposition, Subsystem) {
storm::storage::MaximalEndComponentDecomposition<double> mecDecomposition;
ASSERT_NO_THROW(mecDecomposition = storm::storage::MaximalEndComponentDecomposition<double>(*markovAutomaton, subsystem));
ASSERT_EQ(1, mecDecomposition.size());
ASSERT_EQ(1ul, mecDecomposition.size());
storm::storage::MaximalEndComponent const& mec1 = mecDecomposition[0];

10
test/functional/storage/SchedulerTest.cpp
View File

@ -12,10 +12,10 @@ TEST(SchedulerTest, PartialScheduler) {
ASSERT_NO_THROW(scheduler.setChoice(3, 4));
ASSERT_TRUE(scheduler.isChoiceDefined(0));
ASSERT_EQ(3, scheduler.getChoice(0));
ASSERT_EQ(3ul, scheduler.getChoice(0));
ASSERT_TRUE(scheduler.isChoiceDefined(3));
ASSERT_EQ(4, scheduler.getChoice(3));
ASSERT_EQ(4ul, scheduler.getChoice(3));
ASSERT_FALSE(scheduler.isChoiceDefined(1));
ASSERT_THROW(scheduler.getChoice(1), storm::exceptions::InvalidArgumentException);
@ -29,13 +29,13 @@ TEST(SchedulerTest, TotalScheduler) {
ASSERT_NO_THROW(scheduler.setChoice(3, 4));
ASSERT_TRUE(scheduler.isChoiceDefined(0));
ASSERT_EQ(3, scheduler.getChoice(0));
ASSERT_EQ(3ul, scheduler.getChoice(0));
ASSERT_TRUE(scheduler.isChoiceDefined(3));
ASSERT_EQ(4, scheduler.getChoice(3));
ASSERT_EQ(4ul, scheduler.getChoice(3));
ASSERT_TRUE(scheduler.isChoiceDefined(1));
ASSERT_EQ(0, scheduler.getChoice(1));
ASSERT_EQ(0ul, scheduler.getChoice(1));
ASSERT_THROW(scheduler.getChoice(4), storm::exceptions::InvalidArgumentException);
ASSERT_THROW(scheduler.setChoice(5, 2), storm::exceptions::InvalidArgumentException);

50
test/functional/storage/SparseMatrixTest.cpp
View File

@ -14,9 +14,9 @@ TEST(SparseMatrixBuilder, CreationWithDimensions) {
storm::storage::SparseMatrix<double> matrix;
ASSERT_NO_THROW(matrix = matrixBuilder.build());
ASSERT_EQ(3, matrix.getRowCount());
ASSERT_EQ(4, matrix.getColumnCount());
ASSERT_EQ(5, matrix.getEntryCount());
ASSERT_EQ(3ul, matrix.getRowCount());
ASSERT_EQ(4ul, matrix.getColumnCount());
ASSERT_EQ(5ul, matrix.getEntryCount());
}
TEST(SparseMatrixBuilder, CreationWithoutNumberOfEntries) {
@ -30,9 +30,9 @@ TEST(SparseMatrixBuilder, CreationWithoutNumberOfEntries) {
storm::storage::SparseMatrix<double> matrix;
ASSERT_NO_THROW(matrix = matrixBuilder.build());
ASSERT_EQ(3, matrix.getRowCount());
ASSERT_EQ(4, matrix.getColumnCount());
ASSERT_EQ(5, matrix.getEntryCount());
ASSERT_EQ(3ul, matrix.getRowCount());
ASSERT_EQ(4ul, matrix.getColumnCount());
ASSERT_EQ(5ul, matrix.getEntryCount());
}
TEST(SparseMatrixBuilder, CreationWithNumberOfRows) {
@ -46,9 +46,9 @@ TEST(SparseMatrixBuilder, CreationWithNumberOfRows) {
storm::storage::SparseMatrix<double> matrix;
ASSERT_NO_THROW(matrix = matrixBuilder.build());
ASSERT_EQ(3, matrix.getRowCount());
ASSERT_EQ(4, matrix.getColumnCount());
ASSERT_EQ(5, matrix.getEntryCount());
ASSERT_EQ(3ul, matrix.getRowCount());
ASSERT_EQ(4ul, matrix.getColumnCount());
ASSERT_EQ(5ul, matrix.getEntryCount());
}
TEST(SparseMatrixBuilder, CreationWithoutDimensions) {
@ -62,9 +62,9 @@ TEST(SparseMatrixBuilder, CreationWithoutDimensions) {
storm::storage::SparseMatrix<double> matrix;
ASSERT_NO_THROW(matrix = matrixBuilder.build());
ASSERT_EQ(2, matrix.getRowCount());
ASSERT_EQ(4, matrix.getColumnCount());
ASSERT_EQ(5, matrix.getEntryCount());
ASSERT_EQ(2ul, matrix.getRowCount());
ASSERT_EQ(4ul, matrix.getColumnCount());
ASSERT_EQ(5ul, matrix.getEntryCount());
}
TEST(SparseMatrixBuilder, AddNextValue) {
@ -117,9 +117,9 @@ TEST(SparseMatrix, Build) {
ASSERT_NO_THROW(matrixBuilder3.addNextValue(1, 3, 0.2));
storm::storage::SparseMatrix<double> matrix3;
ASSERT_NO_THROW(matrix3 = matrixBuilder3.build());
ASSERT_EQ(2, matrix3.getRowCount());
ASSERT_EQ(4, matrix3.getColumnCount());
ASSERT_EQ(5, matrix3.getEntryCount());
ASSERT_EQ(2ul, matrix3.getRowCount());
ASSERT_EQ(4ul, matrix3.getColumnCount());
ASSERT_EQ(5ul, matrix3.getEntryCount());
storm::storage::SparseMatrixBuilder<double> matrixBuilder4;
ASSERT_NO_THROW(matrixBuilder4.addNextValue(0, 1, 1.0));
@ -129,9 +129,9 @@ TEST(SparseMatrix, Build) {
ASSERT_NO_THROW(matrixBuilder4.addNextValue(1, 3, 0.2));
storm::storage::SparseMatrix<double> matrix4;
ASSERT_NO_THROW(matrix4 = matrixBuilder4.build(4));
ASSERT_EQ(4, matrix4.getRowCount());
ASSERT_EQ(4, matrix4.getColumnCount());
ASSERT_EQ(5, matrix4.getEntryCount());
ASSERT_EQ(4ul, matrix4.getRowCount());
ASSERT_EQ(4ul, matrix4.getColumnCount());
ASSERT_EQ(5ul, matrix4.getEntryCount());
storm::storage::SparseMatrixBuilder<double> matrixBuilder5;
ASSERT_NO_THROW(matrixBuilder5.addNextValue(0, 1, 1.0));
@ -141,9 +141,9 @@ TEST(SparseMatrix, Build) {
ASSERT_NO_THROW(matrixBuilder5.addNextValue(1, 3, 0.2));
storm::storage::SparseMatrix<double> matrix5;
ASSERT_NO_THROW(matrix5 = matrixBuilder5.build(0, 6));
ASSERT_EQ(2, matrix5.getRowCount());
ASSERT_EQ(6, matrix5.getColumnCount());
ASSERT_EQ(5, matrix5.getEntryCount());
ASSERT_EQ(2ul, matrix5.getRowCount());
ASSERT_EQ(6ul, matrix5.getColumnCount());
ASSERT_EQ(5ul, matrix5.getEntryCount());
}
TEST(SparseMatrix, CreationWithMovingContents) {
@ -156,10 +156,10 @@ TEST(SparseMatrix, CreationWithMovingContents) {
ASSERT_NO_THROW(storm::storage::SparseMatrix<double> matrix(4, {0, 2, 5, 5}, columnsAndValues, {0, 1, 2, 3}, false));
storm::storage::SparseMatrix<double> matrix(4, {0, 2, 5, 5}, columnsAndValues, {0, 1, 2, 3}, false);
ASSERT_EQ(3, matrix.getRowCount());
ASSERT_EQ(4, matrix.getColumnCount());
ASSERT_EQ(5, matrix.getEntryCount());
ASSERT_EQ(3, matrix.getRowGroupCount());
ASSERT_EQ(3ul, matrix.getRowCount());
ASSERT_EQ(4ul, matrix.getColumnCount());
ASSERT_EQ(5ul, matrix.getEntryCount());
ASSERT_EQ(3ul, matrix.getRowGroupCount());
}
TEST(SparseMatrix, CopyConstruct) {

14
test/functional/storage/StronglyConnectedComponentDecompositionTest.cpp
View File

@ -26,13 +26,13 @@ TEST(StronglyConnectedComponentDecomposition, SmallSystemFromMatrix) {
storm::storage::StronglyConnectedComponentDecomposition<double> sccDecomposition;
ASSERT_NO_THROW(sccDecomposition = storm::storage::StronglyConnectedComponentDecomposition<double>(matrix, allBits, false, false));
ASSERT_EQ(4, sccDecomposition.size());
ASSERT_EQ(4ul, sccDecomposition.size());
ASSERT_NO_THROW(sccDecomposition = storm::storage::StronglyConnectedComponentDecomposition<double>(matrix, allBits, true, false));
ASSERT_EQ(3, sccDecomposition.size());
ASSERT_EQ(3ul, sccDecomposition.size());
ASSERT_NO_THROW(sccDecomposition = storm::storage::StronglyConnectedComponentDecomposition<double>(matrix, allBits, true, true));
ASSERT_EQ(1, sccDecomposition.size());
ASSERT_EQ(1ul, sccDecomposition.size());
}
TEST(StronglyConnectedComponentDecomposition, FullSystem1) {
@ -43,13 +43,13 @@ TEST(StronglyConnectedComponentDecomposition, FullSystem1) {
storm::storage::StronglyConnectedComponentDecomposition<double> sccDecomposition;
ASSERT_NO_THROW(sccDecomposition = storm::storage::StronglyConnectedComponentDecomposition<double>(*markovAutomaton));
ASSERT_EQ(5, sccDecomposition.size());
ASSERT_EQ(5ul, sccDecomposition.size());
ASSERT_NO_THROW(sccDecomposition = storm::storage::StronglyConnectedComponentDecomposition<double>(*markovAutomaton, true));
ASSERT_EQ(2, sccDecomposition.size());
ASSERT_EQ(2ul, sccDecomposition.size());
ASSERT_NO_THROW(sccDecomposition = storm::storage::StronglyConnectedComponentDecomposition<double>(*markovAutomaton, true, true));
ASSERT_EQ(2, sccDecomposition.size());
ASSERT_EQ(2ul, sccDecomposition.size());
markovAutomaton = nullptr;
}
@ -74,7 +74,7 @@ TEST(StronglyConnectedComponentDecomposition, FullSystem2) {
ASSERT_TRUE(scc2 == storm::storage::StateBlock(correctScc1.begin(), correctScc1.end()) || scc2 == storm::storage::StateBlock(correctScc2.begin(), correctScc2.end()));
ASSERT_NO_THROW(sccDecomposition = storm::storage::StronglyConnectedComponentDecomposition<double>(*markovAutomaton, true, true));
ASSERT_EQ(1, sccDecomposition.size());
ASSERT_EQ(1ul, sccDecomposition.size());
markovAutomaton = nullptr;
}

88
test/functional/utility/GraphTest.cpp
View File

@ -20,16 +20,16 @@ TEST(GraphTest, SymbolicProb01) {
std::pair<storm::dd::Bdd<storm::dd::DdType::CUDD>, storm::dd::Bdd<storm::dd::DdType::CUDD>> statesWithProbability01;
ASSERT_NO_THROW(statesWithProbability01 = storm::utility::graph::performProb01(*model->as<storm::models::symbolic::Dtmc<storm::dd::DdType::CUDD>>(), model->getReachableStates(), model->getStates("observe0Greater1")));
EXPECT_EQ(4409, statesWithProbability01.first.getNonZeroCount());
EXPECT_EQ(1316, statesWithProbability01.second.getNonZeroCount());
EXPECT_EQ(4409ul, statesWithProbability01.first.getNonZeroCount());
EXPECT_EQ(1316ul, statesWithProbability01.second.getNonZeroCount());
ASSERT_NO_THROW(statesWithProbability01 = storm::utility::graph::performProb01(*model->as<storm::models::symbolic::Dtmc<storm::dd::DdType::CUDD>>(), model->getReachableStates(), model->getStates("observeIGreater1")));
EXPECT_EQ(1091, statesWithProbability01.first.getNonZeroCount());
EXPECT_EQ(4802, statesWithProbability01.second.getNonZeroCount());
EXPECT_EQ(1091ul, statesWithProbability01.first.getNonZeroCount());
EXPECT_EQ(4802ul, statesWithProbability01.second.getNonZeroCount());
ASSERT_NO_THROW(statesWithProbability01 = storm::utility::graph::performProb01(*model->as<storm::models::symbolic::Dtmc<storm::dd::DdType::CUDD>>(), model->getReachableStates(), model->getStates("observeOnlyTrueSender")));
EXPECT_EQ(5829, statesWithProbability01.first.getNonZeroCount());
EXPECT_EQ(1032, statesWithProbability01.second.getNonZeroCount());
EXPECT_EQ(5829ul, statesWithProbability01.first.getNonZeroCount());
EXPECT_EQ(1032ul, statesWithProbability01.second.getNonZeroCount());
}
TEST(GraphTest, SymbolicProb01MinMax) {
@ -41,12 +41,12 @@ TEST(GraphTest, SymbolicProb01MinMax) {
std::pair<storm::dd::Bdd<storm::dd::DdType::CUDD>, storm::dd::Bdd<storm::dd::DdType::CUDD>> statesWithProbability01;
ASSERT_NO_THROW(statesWithProbability01 = storm::utility::graph::performProb01Min(*model->as<storm::models::symbolic::Mdp<storm::dd::DdType::CUDD>>(), model->getReachableStates(), model->getStates("elected")));
EXPECT_EQ(0, statesWithProbability01.first.getNonZeroCount());
EXPECT_EQ(364, statesWithProbability01.second.getNonZeroCount());
EXPECT_EQ(0ul, statesWithProbability01.first.getNonZeroCount());
EXPECT_EQ(364ul, statesWithProbability01.second.getNonZeroCount());
ASSERT_NO_THROW(statesWithProbability01 = storm::utility::graph::performProb01Max(*model->as<storm::models::symbolic::Mdp<storm::dd::DdType::CUDD>>(), model->getReachableStates(), model->getStates("elected")));
EXPECT_EQ(0, statesWithProbability01.first.getNonZeroCount());
EXPECT_EQ(364, statesWithProbability01.second.getNonZeroCount());
EXPECT_EQ(0ul, statesWithProbability01.first.getNonZeroCount());
EXPECT_EQ(364ul, statesWithProbability01.second.getNonZeroCount());
program = storm::parser::PrismParser::parse(STORM_CPP_TESTS_BASE_PATH "/functional/builder/coin2-2.nm");
model = storm::builder::DdPrismModelBuilder<storm::dd::DdType::CUDD>::translateProgram(program);
@ -54,20 +54,20 @@ TEST(GraphTest, SymbolicProb01MinMax) {
ASSERT_TRUE(model->getType() == storm::models::ModelType::Mdp);
ASSERT_NO_THROW(statesWithProbability01 = storm::utility::graph::performProb01Min(*model->as<storm::models::symbolic::Mdp<storm::dd::DdType::CUDD>>(), model->getReachableStates(), model->getStates("all_coins_equal_0")));
EXPECT_EQ(77, statesWithProbability01.first.getNonZeroCount());
EXPECT_EQ(149, statesWithProbability01.second.getNonZeroCount());
EXPECT_EQ(77ul, statesWithProbability01.first.getNonZeroCount());
EXPECT_EQ(149ul, statesWithProbability01.second.getNonZeroCount());
ASSERT_NO_THROW(statesWithProbability01 = storm::utility::graph::performProb01Max(*model->as<storm::models::symbolic::Mdp<storm::dd::DdType::CUDD>>(), model->getReachableStates(), model->getStates("all_coins_equal_0")));
EXPECT_EQ(74, statesWithProbability01.first.getNonZeroCount());
EXPECT_EQ(198, statesWithProbability01.second.getNonZeroCount());
EXPECT_EQ(74ul, statesWithProbability01.first.getNonZeroCount());
EXPECT_EQ(198ul, statesWithProbability01.second.getNonZeroCount());
ASSERT_NO_THROW(statesWithProbability01 = storm::utility::graph::performProb01Min(*model->as<storm::models::symbolic::Mdp<storm::dd::DdType::CUDD>>(), model->getReachableStates(), model->getStates("all_coins_equal_1")));
EXPECT_EQ(94, statesWithProbability01.first.getNonZeroCount());
EXPECT_EQ(33, statesWithProbability01.second.getNonZeroCount());
EXPECT_EQ(94ul, statesWithProbability01.first.getNonZeroCount());
EXPECT_EQ(33ul, statesWithProbability01.second.getNonZeroCount());
ASSERT_NO_THROW(statesWithProbability01 = storm::utility::graph::performProb01Max(*model->as<storm::models::symbolic::Mdp<storm::dd::DdType::CUDD>>(), model->getReachableStates(), model->getStates("all_coins_equal_1")));
EXPECT_EQ(83, statesWithProbability01.first.getNonZeroCount());
EXPECT_EQ(35, statesWithProbability01.second.getNonZeroCount());
EXPECT_EQ(83ul, statesWithProbability01.first.getNonZeroCount());
EXPECT_EQ(35ul, statesWithProbability01.second.getNonZeroCount());
program = storm::parser::PrismParser::parse(STORM_CPP_TESTS_BASE_PATH "/functional/builder/csma2-2.nm");
model = storm::builder::DdPrismModelBuilder<storm::dd::DdType::CUDD>::translateProgram(program);
@ -75,12 +75,12 @@ TEST(GraphTest, SymbolicProb01MinMax) {
ASSERT_TRUE(model->getType() == storm::models::ModelType::Mdp);
ASSERT_NO_THROW(statesWithProbability01 = storm::utility::graph::performProb01Min(*model->as<storm::models::symbolic::Mdp<storm::dd::DdType::CUDD>>(), model->getReachableStates(), model->getStates("collision_max_backoff")));
EXPECT_EQ(993, statesWithProbability01.first.getNonZeroCount());
EXPECT_EQ(16, statesWithProbability01.second.getNonZeroCount());
EXPECT_EQ(993ul, statesWithProbability01.first.getNonZeroCount());
EXPECT_EQ(16ul, statesWithProbability01.second.getNonZeroCount());
ASSERT_NO_THROW(statesWithProbability01 = storm::utility::graph::performProb01Max(*model->as<storm::models::symbolic::Mdp<storm::dd::DdType::CUDD>>(), model->getReachableStates(), model->getStates("collision_max_backoff")));
EXPECT_EQ(993, statesWithProbability01.first.getNonZeroCount());
EXPECT_EQ(16, statesWithProbability01.second.getNonZeroCount());
EXPECT_EQ(993ul, statesWithProbability01.first.getNonZeroCount());
EXPECT_EQ(16ul, statesWithProbability01.second.getNonZeroCount());
}
TEST(GraphTest, ExplicitProb01) {
@ -92,16 +92,16 @@ TEST(GraphTest, ExplicitProb01) {
std::pair<storm::storage::BitVector, storm::storage::BitVector> statesWithProbability01;
ASSERT_NO_THROW(statesWithProbability01 = storm::utility::graph::performProb01(*model->as<storm::models::sparse::Dtmc<double>>(), storm::storage::BitVector(model->getNumberOfStates(), true), model->getStates("observe0Greater1")));
EXPECT_EQ(4409, statesWithProbability01.first.getNumberOfSetBits());
EXPECT_EQ(1316, statesWithProbability01.second.getNumberOfSetBits());
EXPECT_EQ(4409ul, statesWithProbability01.first.getNumberOfSetBits());
EXPECT_EQ(1316ul, statesWithProbability01.second.getNumberOfSetBits());
ASSERT_NO_THROW(statesWithProbability01 = storm::utility::graph::performProb01(*model->as<storm::models::sparse::Dtmc<double>>(), storm::storage::BitVector(model->getNumberOfStates(), true), model->getStates("observeIGreater1")));
EXPECT_EQ(1091, statesWithProbability01.first.getNumberOfSetBits());
EXPECT_EQ(4802, statesWithProbability01.second.getNumberOfSetBits());
EXPECT_EQ(1091ul, statesWithProbability01.first.getNumberOfSetBits());
EXPECT_EQ(4802ul, statesWithProbability01.second.getNumberOfSetBits());
ASSERT_NO_THROW(statesWithProbability01 = storm::utility::graph::performProb01(*model->as<storm::models::sparse::Dtmc<double>>(), storm::storage::BitVector(model->getNumberOfStates(), true), model->getStates("observeOnlyTrueSender")));
EXPECT_EQ(5829, statesWithProbability01.first.getNumberOfSetBits());
EXPECT_EQ(1032, statesWithProbability01.second.getNumberOfSetBits());
EXPECT_EQ(5829ul, statesWithProbability01.first.getNumberOfSetBits());
EXPECT_EQ(1032ul, statesWithProbability01.second.getNumberOfSetBits());
}
TEST(GraphTest, ExplicitProb01MinMax) {
@ -113,12 +113,12 @@ TEST(GraphTest, ExplicitProb01MinMax) {
std::pair<storm::storage::BitVector, storm::storage::BitVector> statesWithProbability01;
ASSERT_NO_THROW(statesWithProbability01 = storm::utility::graph::performProb01Min(*model->as<storm::models::sparse::Mdp<double>>(), storm::storage::BitVector(model->getNumberOfStates(), true), model->getStates("elected")));
EXPECT_EQ(0, statesWithProbability01.first.getNumberOfSetBits());
EXPECT_EQ(364, statesWithProbability01.second.getNumberOfSetBits());
EXPECT_EQ(0ul, statesWithProbability01.first.getNumberOfSetBits());
EXPECT_EQ(364ul, statesWithProbability01.second.getNumberOfSetBits());
ASSERT_NO_THROW(statesWithProbability01 = storm::utility::graph::performProb01Max(*model->as<storm::models::sparse::Mdp<double>>(), storm::storage::BitVector(model->getNumberOfStates(), true), model->getStates("elected")));
EXPECT_EQ(0, statesWithProbability01.first.getNumberOfSetBits());
EXPECT_EQ(364, statesWithProbability01.second.getNumberOfSetBits());
EXPECT_EQ(0ul, statesWithProbability01.first.getNumberOfSetBits());
EXPECT_EQ(364ul, statesWithProbability01.second.getNumberOfSetBits());
program = storm::parser::PrismParser::parse(STORM_CPP_TESTS_BASE_PATH "/functional/builder/coin2-2.nm");
model = storm::builder::ExplicitPrismModelBuilder<double>::translateProgram(program);
@ -126,20 +126,20 @@ TEST(GraphTest, ExplicitProb01MinMax) {
ASSERT_TRUE(model->getType() == storm::models::ModelType::Mdp);
ASSERT_NO_THROW(statesWithProbability01 = storm::utility::graph::performProb01Min(*model->as<storm::models::sparse::Mdp<double>>(), storm::storage::BitVector(model->getNumberOfStates(), true), model->getStates("all_coins_equal_0")));
EXPECT_EQ(77, statesWithProbability01.first.getNumberOfSetBits());
EXPECT_EQ(149, statesWithProbability01.second.getNumberOfSetBits());
EXPECT_EQ(77ul, statesWithProbability01.first.getNumberOfSetBits());
EXPECT_EQ(149ul, statesWithProbability01.second.getNumberOfSetBits());
ASSERT_NO_THROW(statesWithProbability01 = storm::utility::graph::performProb01Max(*model->as<storm::models::sparse::Mdp<double>>(), storm::storage::BitVector(model->getNumberOfStates(), true), model->getStates("all_coins_equal_0")));
EXPECT_EQ(74, statesWithProbability01.first.getNumberOfSetBits());
EXPECT_EQ(198, statesWithProbability01.second.getNumberOfSetBits());
EXPECT_EQ(74ul, statesWithProbability01.first.getNumberOfSetBits());
EXPECT_EQ(198ul, statesWithProbability01.second.getNumberOfSetBits());
ASSERT_NO_THROW(statesWithProbability01 = storm::utility::graph::performProb01Min(*model->as<storm::models::sparse::Mdp<double>>(), storm::storage::BitVector(model->getNumberOfStates(), true), model->getStates("all_coins_equal_1")));
EXPECT_EQ(94, statesWithProbability01.first.getNumberOfSetBits());
EXPECT_EQ(33, statesWithProbability01.second.getNumberOfSetBits());
EXPECT_EQ(94ul, statesWithProbability01.first.getNumberOfSetBits());
EXPECT_EQ(33ul, statesWithProbability01.second.getNumberOfSetBits());
ASSERT_NO_THROW(statesWithProbability01 = storm::utility::graph::performProb01Max(*model->as<storm::models::sparse::Mdp<double>>(), storm::storage::BitVector(model->getNumberOfStates(), true), model->getStates("all_coins_equal_1")));
EXPECT_EQ(83, statesWithProbability01.first.getNumberOfSetBits());
EXPECT_EQ(35, statesWithProbability01.second.getNumberOfSetBits());
EXPECT_EQ(83ul, statesWithProbability01.first.getNumberOfSetBits());
EXPECT_EQ(35ul, statesWithProbability01.second.getNumberOfSetBits());
program = storm::parser::PrismParser::parse(STORM_CPP_TESTS_BASE_PATH "/functional/builder/csma2-2.nm");
model = storm::builder::ExplicitPrismModelBuilder<double>::translateProgram(program);
@ -147,10 +147,10 @@ TEST(GraphTest, ExplicitProb01MinMax) {
ASSERT_TRUE(model->getType() == storm::models::ModelType::Mdp);
ASSERT_NO_THROW(statesWithProbability01 = storm::utility::graph::performProb01Min(*model->as<storm::models::sparse::Mdp<double>>(), storm::storage::BitVector(model->getNumberOfStates(), true), model->getStates("collision_max_backoff")));
EXPECT_EQ(993, statesWithProbability01.first.getNumberOfSetBits());
EXPECT_EQ(16, statesWithProbability01.second.getNumberOfSetBits());
EXPECT_EQ(993ul, statesWithProbability01.first.getNumberOfSetBits());
EXPECT_EQ(16ul, statesWithProbability01.second.getNumberOfSetBits());
ASSERT_NO_THROW(statesWithProbability01 = storm::utility::graph::performProb01Max(*model->as<storm::models::sparse::Mdp<double>>(), storm::storage::BitVector(model->getNumberOfStates(), true), model->getStates("collision_max_backoff")));
EXPECT_EQ(993, statesWithProbability01.first.getNumberOfSetBits());
EXPECT_EQ(16, statesWithProbability01.second.getNumberOfSetBits());
EXPECT_EQ(993ul, statesWithProbability01.first.getNumberOfSetBits());
EXPECT_EQ(16ul, statesWithProbability01.second.getNumberOfSetBits());
}
Write Preview
Loading…
Cancel
Save