Finished Rules tests and fixed some tests in Rules

3 files changed, 319 insertions, 45 deletions

diff --git a/sigmod/Rules.cpp b/sigmod/Rules.cpp
index e8fa0d7b..18300a1a 100644
--- a/sigmod/Rules.cpp
+++ b/sigmod/Rules.cpp
@@ -250,13 +250,13 @@ CHECK_BEGIN(Rules, bool, specialDVSplit)
     }
 CHECK_END()
 CHECK(Rules, bool, effortValuesAllowed)
-CHECK_BOUNDS(Rules, int, maxTotalEV, 0, INT_MAX)
+CHECK_BEGIN(Rules, int, maxTotalEV)
+    if (m_effortValuesAllowed)
+        TBOUNDS(maxTotalEV, 0, INT_MAX);
+CHECK_END()
 CHECK_BEGIN(Rules, int, maxEVPerStat)
-    if (m_maxTotalEV)
-    {
+    if (m_effortValuesAllowed && m_maxTotalEV)
         TBOUNDS(maxEVPerStat, 0, m_maxTotalEV);
-        return false;
-    }
 CHECK_END()
 
 Sigmod::Rules& Sigmod::Rules::operator=(const Rules& rhs)
diff --git a/sigmod/test/TestRules.cpp b/sigmod/test/TestRules.cpp
index e9971469..0ba20d37 100644
--- a/sigmod/test/TestRules.cpp
+++ b/sigmod/test/TestRules.cpp
@@ -330,18 +330,292 @@ void TestRules::setMaxPlayers()
     QCOMPARE(m_errors.size(), 1);
 }
 
-// void TestRules::set()
-// {
-//     m_rules2->set();
-//     m_rules2->set();
-//     
-//     QCOMPARE(m_rules2->(), );
-//     
-//     QCOMPARE(m_changedCount, 1);
-//     
-//     QCOMPARE(m_warnings.size(), 0);
-//     QCOMPARE(m_errors.size(), 0);
-// }
+void TestRules::setMaxHeldItems()
+{
+    m_rules2->setMaxHeldItems(-1);
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 1);
+    
+    m_rules2->setMaxHeldItems(5);
+    m_rules2->setMaxHeldItems(5);
+    
+    QCOMPARE(m_rules2->maxHeldItems(), 5);
+    
+    QCOMPARE(m_changedCount, 1);
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 1);
+}
+
+void TestRules::setMaxAbilities()
+{
+    m_rules2->setMaxAbilities(-1);
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 1);
+    
+    m_rules2->setMaxAbilities(5);
+    m_rules2->setMaxAbilities(5);
+    
+    QCOMPARE(m_rules2->maxAbilities(), 5);
+    
+    QCOMPARE(m_changedCount, 1);
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 1);
+}
+
+void TestRules::setMaxNatures()
+{
+    m_rules2->setMaxNatures(-1);
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 1);
+    
+    m_rules2->setMaxNatures(5);
+    m_rules2->setMaxNatures(5);
+    
+    QCOMPARE(m_rules2->maxNatures(), 5);
+    
+    QCOMPARE(m_changedCount, 1);
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 1);
+}
+
+void TestRules::setMaxMoves()
+{
+    m_rules2->setMaxMoves(0);
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 1);
+    
+    m_rules2->setMaxMoves(5);
+    m_rules2->setMaxMoves(5);
+    
+    QCOMPARE(m_rules2->maxMoves(), 5);
+    
+    QCOMPARE(m_changedCount, 1);
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 1);
+}
+
+void TestRules::setMaxLevel()
+{
+    m_rules2->setMaxLevel(0);
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 1);
+    
+    m_rules2->setMaxLevel(5);
+    m_rules2->setMaxLevel(5);
+    
+    QCOMPARE(m_rules2->maxLevel(), 5);
+    
+    QCOMPARE(m_changedCount, 1);
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 1);
+}
+
+void TestRules::setMaxStages()
+{
+    m_rules2->setMaxStages(-1);
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 1);
+    
+    m_rules2->setMaxStages(5);
+    m_rules2->setMaxStages(5);
+    
+    QCOMPARE(m_rules2->maxStages(), 5);
+    
+    QCOMPARE(m_changedCount, 1);
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 1);
+}
+
+void TestRules::setMaxMoney()
+{
+    m_rules2->setMaxMoney(-1);
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 1);
+    
+    m_rules2->setMaxMoney(5);
+    m_rules2->setMaxMoney(5);
+    
+    QCOMPARE(m_rules2->maxMoney(), 5);
+    
+    QCOMPARE(m_changedCount, 1);
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 1);
+}
+
+void TestRules::setMaxTotalWeight()
+{
+    m_rules2->setMaxTotalWeight(-2);
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 1);
+    
+    m_rules2->setMaxTotalWeight(5);
+    m_rules2->setMaxTotalWeight(5);
+    
+    QCOMPARE(m_rules2->maxTotalWeight(), 5);
+    
+    QCOMPARE(m_changedCount, 1);
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 1);
+}
+
+void TestRules::setAllowSwitchStyle()
+{
+    m_rules2->setAllowSwitchStyle(true);
+    m_rules2->setAllowSwitchStyle(true);
+    
+    QCOMPARE(m_rules2->allowSwitchStyle(), true);
+    
+    QCOMPARE(m_changedCount, 1);
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 0);
+}
+
+void TestRules::setSpecialSplit()
+{
+    m_rules2->setSpecialSplit(true);
+    m_rules2->setSpecialSplit(true);
+    
+    QCOMPARE(m_rules2->specialSplit(), true);
+    
+    QCOMPARE(m_changedCount, 1);
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 0);
+}
+
+void TestRules::setSpecialDVSplit()
+{
+    m_rules2->setSpecialSplit(false);
+    
+    QCOMPARE(m_changedCount, 1);
+    
+    m_rules2->setSpecialDVSplit(true);
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 1);
+    
+    m_rules2->setSpecialSplit(true);
+    
+    QCOMPARE(m_changedCount, 2);
+    
+    m_rules2->setSpecialDVSplit(true);
+    m_rules2->setSpecialDVSplit(true);
+    
+    QCOMPARE(m_rules2->specialDVSplit(), true);
+    
+    QCOMPARE(m_changedCount, 3);
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 1);
+}
+
+void TestRules::setEffortValuesAllowed()
+{
+    m_rules2->setEffortValuesAllowed(true);
+    m_rules2->setEffortValuesAllowed(true);
+    
+    QCOMPARE(m_rules2->effortValuesAllowed(), true);
+    
+    QCOMPARE(m_changedCount, 1);
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 0);
+}
+
+void TestRules::setMaxTotalEV()
+{
+    m_rules2->setMaxTotalEV(-1);
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 1);
+    
+    m_rules2->setEffortValuesAllowed(false);
+    
+    QCOMPARE(m_changedCount, 1);
+    
+    m_rules2->setMaxTotalEV(-1);
+    
+    QCOMPARE(m_changedCount, 2);
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 1);
+    
+    m_rules2->setEffortValuesAllowed(true);
+    
+    QCOMPARE(m_changedCount, 3);
+    
+    m_rules2->setMaxTotalEV(5);
+    m_rules2->setMaxTotalEV(5);
+    
+    QCOMPARE(m_rules2->maxTotalEV(), 5);
+    
+    QCOMPARE(m_changedCount, 4);
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 1);
+}
+
+void TestRules::setMaxEVPerStat()
+{
+    m_rules2->setMaxEVPerStat(-1);
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 1);
+    
+    m_rules2->setMaxEVPerStat(6);
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 2);
+    
+    m_rules2->setEffortValuesAllowed(false);
+    
+    QCOMPARE(m_changedCount, 1);
+    
+    m_rules2->setMaxEVPerStat(-1);
+    
+    QCOMPARE(m_changedCount, 2);
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 2);
+    
+    m_rules2->setMaxEVPerStat(6);
+    
+    QCOMPARE(m_changedCount, 3);
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 2);
+    
+    m_rules2->setEffortValuesAllowed(true);
+    
+    QCOMPARE(m_changedCount, 4);
+    
+    m_rules2->setMaxEVPerStat(3);
+    m_rules2->setMaxEVPerStat(3);
+    
+    QCOMPARE(m_rules2->maxEVPerStat(), 3);
+    
+    QCOMPARE(m_changedCount, 5);
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 2);
+}
 
 void TestRules::assignment()
 {
@@ -357,20 +631,20 @@ void TestRules::assignment()
     QCOMPARE(m_rules3->maxParty(), 5);
     QCOMPARE(m_rules3->maxFight(), 2);
     QCOMPARE(m_rules3->maxPlayers(), 3);
-//     QCOMPARE(m_rules3->maxHeldItems(), );
-//     QCOMPARE(m_rules3->maxAbilities(), );
-//     QCOMPARE(m_rules3->maxNatures(), );
-//     QCOMPARE(m_rules3->maxMoves(), );
-//     QCOMPARE(m_rules3->maxLevel(), );
-//     QCOMPARE(m_rules3->maxStages(), );
-//     QCOMPARE(m_rules3->maxMoney(), );
-//     QCOMPARE(m_rules3->maxTotalWeight(), );
-//     QCOMPARE(m_rules3->allowSwitchStyle(), );
-//     QCOMPARE(m_rules3->specialSplit(), );
-//     QCOMPARE(m_rules3->specialDVSplit(), );
-//     QCOMPARE(m_rules3->effortValuesAllowed(), );
-//     QCOMPARE(m_rules1->maxTotalEV(), );
-//     QCOMPARE(m_rules3->maxEVPerStat(), );
+    QCOMPARE(m_rules3->maxHeldItems(), 5);
+    QCOMPARE(m_rules3->maxAbilities(), 5);
+    QCOMPARE(m_rules3->maxNatures(), 5);
+    QCOMPARE(m_rules3->maxMoves(), 5);
+    QCOMPARE(m_rules3->maxLevel(), 5);
+    QCOMPARE(m_rules3->maxStages(), 5);
+    QCOMPARE(m_rules3->maxMoney(), 5);
+    QCOMPARE(m_rules3->maxTotalWeight(), 5);
+    QCOMPARE(m_rules3->allowSwitchStyle(), true);
+    QCOMPARE(m_rules3->specialSplit(), true);
+    QCOMPARE(m_rules3->specialDVSplit(), true);
+    QCOMPARE(m_rules3->effortValuesAllowed(), true);
+    QCOMPARE(m_rules3->maxTotalEV(), 5);
+    QCOMPARE(m_rules3->maxEVPerStat(), 3);
 }
 
 QTEST_APPLESS_MAIN(TestRules)
diff --git a/sigmod/test/TestRules.h b/sigmod/test/TestRules.h
index c538e116..78b75f72 100644
--- a/sigmod/test/TestRules.h
+++ b/sigmod/test/TestRules.h
@@ -49,20 +49,20 @@ class TestRules : public TestSigmodObject
         void setMaxParty();
         void setMaxFight();
         void setMaxPlayers();
-//         void setMaxHeldItems();
-//         void setMaxAbilities();
-//         void setMaxNatures();
-//         void setMaxMoves();
-//         void setMaxLevel();
-//         void setMaxStages();
-//         void setMaxMoney();
-//         void setMaxTotalWeight();
-//         void setAllowSwitchStyle();
-//         void setSpecialSplit();
-//         void setSpecialDVSplit();
-//         void setEffortValuesAllowed();
-//         void setMaxTotalEV();
-//         void setMaxEVPerStat();
+        void setMaxHeldItems();
+        void setMaxAbilities();
+        void setMaxNatures();
+        void setMaxMoves();
+        void setMaxLevel();
+        void setMaxStages();
+        void setMaxMoney();
+        void setMaxTotalWeight();
+        void setAllowSwitchStyle();
+        void setSpecialSplit();
+        void setSpecialDVSplit();
+        void setEffortValuesAllowed();
+        void setMaxTotalEV();
+        void setMaxEVPerStat();
         
         void assignment();
     private: