Added initial Rules tests

3 files changed, 265 insertions, 1 deletions

diff --git a/sigmod/test/CMakeLists.txt b/sigmod/test/CMakeLists.txt
index bd12b690..252a540e 100644
--- a/sigmod/test/CMakeLists.txt
+++ b/sigmod/test/CMakeLists.txt
@@ -45,7 +45,7 @@ MAKE_TEST(sigmod-tests libraries MapWildList)
 MAKE_TEST(sigmod-tests libraries MapWildListEncounter)
 MAKE_TEST(sigmod-tests libraries Move)
 MAKE_TEST(sigmod-tests libraries Nature)
-# MAKE_TEST(sigmod-tests libraries Rules)
+MAKE_TEST(sigmod-tests libraries Rules)
 # MAKE_TEST(sigmod-tests libraries Sigmod)
 MAKE_TEST(sigmod-tests libraries Skin)
 MAKE_TEST(sigmod-tests libraries Sound)
diff --git a/sigmod/test/TestRules.cpp b/sigmod/test/TestRules.cpp
new file mode 100644
index 00000000..6d29fe9b
--- /dev/null
+++ b/sigmod/test/TestRules.cpp
@@ -0,0 +1,190 @@
+/*
+ * Copyright 2008-2009 Ben Boeckel <MathStuf@gmail.com>
+ * 
+ * This program 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.
+ * 
+ * This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+// Header include
+#include "TestRules.h"
+
+// Sigmod includes
+#include "../Rules.h"
+#include "../Sigmod.h"
+
+// Qt includes
+#include <QtCore/QFile>
+#include <QtTest/QTest>
+
+void TestRules::initTestCase()
+{
+    TestSigmodObject::initTestCase();
+    
+    m_rules1 = (new Sigmod::Sigmod)->rules();
+    m_rules2 = (new Sigmod::Sigmod)->rules();
+    m_rules3 = (new Sigmod::Sigmod)->rules();
+}
+
+void TestRules::cleanupTestCase()
+{
+    TestSigmodObject::cleanupTestCase();
+}
+
+void TestRules::init()
+{
+    TestSigmodObject::init();
+    
+    makeConnections(m_rules1);
+    makeConnections(m_rules2);
+    makeConnections(m_rules3);
+}
+
+void TestRules::cleanup()
+{
+    closeConnections(m_rules1);
+    closeConnections(m_rules2);
+    closeConnections(m_rules3);
+    
+    TestSigmodObject::cleanup();
+}
+
+void TestRules::validation()
+{
+    m_rules1->validate();
+    
+    QCOMPARE(m_warnings.size(), 1);
+    QCOMPARE(m_errors.size(), 0);
+    
+    // TODO: Stress test validation here?
+    
+    m_rules1->setMaxMoney(5);
+    m_rules1->validate();
+    
+    QCOMPARE(m_warnings.size(), 1);
+    QCOMPARE(m_errors.size(), 0);
+}
+
+void TestRules::saving()
+{
+    QDomDocument xml = Sigmod::Object::xml(m_rules1);
+    QFile file("rules.xml");
+    
+    QVERIFY(file.open(QIODevice::WriteOnly));
+    file.write(xml.toByteArray());
+    file.close();
+}
+
+void TestRules::loading()
+{
+    QDomDocument xml;
+    QFile file("rules.xml");
+    
+    m_rules1->setGenderAllowed(true);
+    m_rules1->setBreedingAllowed(true);
+    m_rules1->setCriticalDomains(true);
+    m_rules1->setUseTurns(false);
+    m_rules1->setPausedATB(true);
+    m_rules1->setNumBoxes(10);
+    m_rules1->setBoxSize(15);
+    m_rules1->setMaxParty(10);
+    m_rules1->setMaxFight(2);
+    m_rules1->setMaxPlayers(4);
+    m_rules1->setMaxHeldItems(3);
+    m_rules1->setMaxAbilities(3);
+    m_rules1->setMaxNatures(3);
+    m_rules1->setMaxMoves(3);
+    m_rules1->setMaxLevel(3);
+    m_rules1->setMaxStages(3);
+    m_rules1->setMaxMoney(3);
+    m_rules1->setMaxTotalWeight(100);
+    m_rules1->setAllowSwitchStyle(true);
+    m_rules1->setSpecialSplit(true);
+    m_rules1->setSpecialDVSplit(true);
+    m_rules1->setEffortValuesAllowed(true);
+    m_rules1->setMaxTotalEV(100);
+    m_rules1->setMaxEVPerStat(25);
+    
+    QVERIFY(file.open(QIODevice::ReadOnly));
+    QVERIFY(xml.setContent(&file));
+    m_rules1->load(xml.firstChildElement("Rules"));
+    
+    QCOMPARE(m_rules1->genderAllowed(), false);
+    QCOMPARE(m_rules1->breedingAllowed(), false);
+    QCOMPARE(m_rules1->criticalDomains(), false);
+    QCOMPARE(m_rules1->useTurns(), true);
+    QCOMPARE(m_rules1->pausedATB(), false);
+    QCOMPARE(m_rules1->numBoxes(), 0);
+    QCOMPARE(m_rules1->boxSize(), 1);
+    QCOMPARE(m_rules1->maxParty(), 1);
+    QCOMPARE(m_rules1->maxFight(), 1);
+    QCOMPARE(m_rules1->maxPlayers(), 2);
+    QCOMPARE(m_rules1->maxHeldItems(), 0);
+    QCOMPARE(m_rules1->maxAbilities(), 0);
+    QCOMPARE(m_rules1->maxNatures(), 0);
+    QCOMPARE(m_rules1->maxMoves(), 1);
+    QCOMPARE(m_rules1->maxLevel(), 1);
+    QCOMPARE(m_rules1->maxStages(), 6);
+    QCOMPARE(m_rules1->maxMoney(), 5);
+    QCOMPARE(m_rules1->maxTotalWeight(), 0);
+    QCOMPARE(m_rules1->allowSwitchStyle(), false);
+    QCOMPARE(m_rules1->specialSplit(), false);
+    QCOMPARE(m_rules1->specialDVSplit(), false);
+    QCOMPARE(m_rules1->effortValuesAllowed(), false);
+    QCOMPARE(m_rules1->maxTotalEV(), 0);
+    QCOMPARE(m_rules1->maxEVPerStat(), 0);
+}
+
+// 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::assignment()
+{
+    *m_rules3 = *m_rules2;
+    
+//     QCOMPARE(m_rules3->genderAllowed(), );
+//     QCOMPARE(m_rules3->breedingAllowed(), );
+//     QCOMPARE(m_rules3->criticalDomains(), );
+//     QCOMPARE(m_rules3->useTurns(), );
+//     QCOMPARE(m_rules3->pausedATB(), );
+//     QCOMPARE(m_rules3->numBoxes(), );
+//     QCOMPARE(m_rules3->boxSize(), );
+//     QCOMPARE(m_rules3->maxParty(), );
+//     QCOMPARE(m_rules3->maxFight(), );
+//     QCOMPARE(m_rules3->maxPlayers(), );
+//     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(), );
+}
+
+QTEST_APPLESS_MAIN(TestRules)
diff --git a/sigmod/test/TestRules.h b/sigmod/test/TestRules.h
new file mode 100644
index 00000000..44dff2e5
--- /dev/null
+++ b/sigmod/test/TestRules.h
@@ -0,0 +1,74 @@
+/*
+ * Copyright 2008-2009 Ben Boeckel <MathStuf@gmail.com>
+ * 
+ * This program 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.
+ * 
+ * This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef SIGMOD_TESTRULES
+#define SIGMOD_TESTRULES
+
+// Test includes
+#include "TestSigmodObject.h"
+
+// Sigmod includes
+#include "../Rules.h"
+
+class TestRules : public TestSigmodObject
+{
+    Q_OBJECT
+    
+    private slots:
+        void initTestCase();
+        void cleanupTestCase();
+        
+        void init();
+        void cleanup();
+        
+        void validation();
+        void saving();
+        void loading();
+        
+//         void setGenderAllowed();
+//         void setBreedingAllowed();
+//         void setCriticalDomains();
+//         void setUseTurns();
+//         void setPausedATB();
+//         void setNumBoxes();
+//         void setBoxSize();
+//         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 assignment();
+    private:
+        Sigmod::Rules* m_rules1;
+        Sigmod::Rules* m_rules2;
+        Sigmod::Rules* m_rules3;
+};
+
+#endif