Added initial Species tests

3 files changed, 1043 insertions, 1 deletions

diff --git a/sigmod/test/CMakeLists.txt b/sigmod/test/CMakeLists.txt
index ef83d7bd..26234479 100644
--- a/sigmod/test/CMakeLists.txt
+++ b/sigmod/test/CMakeLists.txt
@@ -49,7 +49,7 @@ MAKE_TEST(sigmod-tests libraries Nature)
 # MAKE_TEST(sigmod-tests libraries Sigmod)
 MAKE_TEST(sigmod-tests libraries Skin)
 MAKE_TEST(sigmod-tests libraries Sound)
-# MAKE_TEST(sigmod-tests libraries Species)
+MAKE_TEST(sigmod-tests libraries Species)
 MAKE_TEST(sigmod-tests libraries SpeciesAbility)
 MAKE_TEST(sigmod-tests libraries SpeciesItem)
 MAKE_TEST(sigmod-tests libraries SpeciesMove)
diff --git a/sigmod/test/TestSpecies.cpp b/sigmod/test/TestSpecies.cpp
new file mode 100644
index 00000000..f56e2896
--- /dev/null
+++ b/sigmod/test/TestSpecies.cpp
@@ -0,0 +1,963 @@
+/*
+ * 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 "TestSpecies.h"
+
+// Sigmod includes
+#include "../Rules.h"
+#include "../Sigmod.h"
+#include "../Species.h"
+
+// Qt includes
+#include <QtCore/QFile>
+#include <QtTest/QTest>
+
+void TestSpecies::initTestCase()
+{
+    TestSigmodObject::initTestCase();
+    
+    m_species1 = m_sigmod->newSpecies();
+    m_species2 = m_sigmod->newSpecies();
+    m_species3 = m_sigmod->newSpecies();
+}
+
+void TestSpecies::cleanupTestCase()
+{
+    TestSigmodObject::cleanupTestCase();
+}
+
+void TestSpecies::init()
+{
+    TestSigmodObject::init();
+    
+    makeConnections(m_species1);
+    makeConnections(m_species2);
+    makeConnections(m_species3);
+}
+
+void TestSpecies::cleanup()
+{
+    closeConnections(m_species1);
+    closeConnections(m_species2);
+    closeConnections(m_species3);
+    
+    TestSigmodObject::cleanup();
+}
+
+#include <QtCore/QtDebug>
+
+void TestSpecies::validation()
+{
+    m_species1->validate();
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 6);
+    
+    m_species1->setName("Foo");
+    m_species1->validate();
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 11);
+    
+    m_sigmod->rules()->setMaxEVPerStat(10);
+    
+    m_species1->setEffortValue(Sigmod::ST_HP, 5);
+    m_species1->validate();
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 16);
+    
+    m_sigmod->rules()->setMaxEVPerStat(2);
+    
+    m_species1->validate();
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 22);
+    
+    m_sigmod->rules()->setMaxEVPerStat(20);
+    
+    m_species1->setEffortValue(Sigmod::ST_Attack, 15);
+    m_species1->validate();
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 27);
+    
+    m_sigmod->rules()->setMaxEVPerStat(10);
+    
+    m_species1->validate();
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 33);
+    
+    m_sigmod->rules()->setMaxEVPerStat(30);
+    
+    m_species1->setEffortValue(Sigmod::ST_Defense, 25);
+    m_species1->validate();
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 38);
+    
+    m_sigmod->rules()->setMaxEVPerStat(20);
+    
+    m_species1->validate();
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 44);
+    
+    m_sigmod->rules()->setMaxEVPerStat(40);
+    
+    m_species1->setEffortValue(Sigmod::ST_Speed, 35);
+    m_species1->validate();
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 49);
+    
+    m_sigmod->rules()->setMaxEVPerStat(30);
+    
+    m_species1->validate();
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 55);
+    
+    m_sigmod->rules()->setMaxEVPerStat(50);
+    
+    m_species1->setEffortValue(Sigmod::ST_SpecialAttack, 45);
+    m_species1->validate();
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 60);
+    
+    m_sigmod->rules()->setMaxEVPerStat(40);
+    
+    m_species1->validate();
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 66);
+    
+    m_sigmod->rules()->setSpecialSplit(true);
+    m_sigmod->rules()->setMaxEVPerStat(60);
+    
+    m_species1->setEffortValue(Sigmod::ST_SpecialDefense, 55);
+    m_species1->validate();
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 71);
+    
+    m_sigmod->rules()->setSpecialSplit(true);
+    m_sigmod->rules()->setMaxEVPerStat(50);
+    
+    m_species1->validate();
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 77);
+    
+    m_sigmod->rules()->setSpecialSplit(false);
+    
+    m_species1->validate();
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 82);
+    
+    m_sigmod->newSprite();
+    
+    m_species1->setFrontMaleSprite(0);
+    m_species1->validate();
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 86);
+    
+    m_sigmod->newSprite();
+    
+    m_species1->setBackMaleSprite(1);
+    m_species1->validate();
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 89);
+    
+    m_sigmod->rules()->setGenderAllowed(true);
+    
+    m_species1->validate();
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 94);
+    
+    m_sigmod->newSprite();
+    
+    m_species1->setFrontFemaleSprite(2);
+    m_species1->validate();
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 98);
+    
+    m_sigmod->newSprite();
+    
+    m_species1->setBackFemaleSprite(3);
+    m_species1->validate();
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 101);
+    
+    m_sigmod->newSkin();
+    
+    m_species1->setSkin(0);
+    m_species1->validate();
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 103);
+    
+    m_species1->setEncyclopediaNumber(-1);
+    m_species1->validate();
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 104);
+    
+    m_species1->setEncyclopediaNumber(0);
+    m_species1->setEncyclopediaEntry("Foo");
+    m_species1->validate();
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 105);
+    
+    m_sigmod->rules()->setBreedingAllowed(true);
+    
+    m_species1->validate();
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 106);
+    
+    m_sigmod->newEggGroup();
+    
+    m_species1->setEggGroup(0, true);
+    m_species1->validate();
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 108);
+    
+    m_sigmod->newSpecies();
+    
+    m_species1->setEggSpecies(1);
+    m_species1->validate();
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 110);
+    
+    m_sigmod->species(1)->setGrowth(Sigmod::Species::Fast);
+    
+    m_species1->validate();
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 113);
+    
+    m_species1->setGrowth(Sigmod::Species::Fast);
+    m_species1->validate();
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 115);
+    
+    m_species1->setEggSteps(10);
+    m_species1->validate();
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 116);
+    
+    m_sigmod->rules()->setMaxAbilities(1);
+    
+    m_species1->validate();
+    
+    QCOMPARE(m_warnings.size(), 1);
+    QCOMPARE(m_errors.size(), 117);
+    
+    m_species1->newAbility();
+    m_species1->validate();
+    
+    QCOMPARE(m_warnings.size(), 1);
+    QCOMPARE(m_errors.size(), 118);
+    
+    m_sigmod->rules()->setMaxHeldItems(1);
+    
+    m_species1->validate();
+    
+    QCOMPARE(m_warnings.size(), 2);
+    QCOMPARE(m_errors.size(), 119);
+    
+    m_species1->newItem();
+    m_species1->validate();
+    
+    QCOMPARE(m_warnings.size(), 2);
+    QCOMPARE(m_errors.size(), 120);
+    
+    m_species1->newMove();
+    m_species1->validate();
+    
+    QCOMPARE(m_warnings.size(), 2);
+    QCOMPARE(m_errors.size(), 120);
+    
+    m_sigmod->newType();
+    m_sigmod->newEggGroup();
+    
+    m_species1->setType(0, true);
+    m_species1->setEggGroup(0, true);
+}
+
+void TestSpecies::saving()
+{
+    QDomDocument xml = Sigmod::Object::xml(m_species1);
+    QFile file("species.xml");
+    
+    QVERIFY(file.open(QIODevice::WriteOnly));
+    file.write(xml.toByteArray());
+    file.close();
+}
+
+void TestSpecies::loading()
+{
+    QDomDocument xml;
+    QFile file("species.xml");
+    
+    m_sigmod->rules()->setSpecialSplit(true);
+    m_sigmod->rules()->setMaxEVPerStat(60);
+    m_sigmod->newSkin();
+    m_sigmod->newType();
+    m_sigmod->newEggGroup();
+    
+    m_species1->setName("Bar");
+    m_species1->setBaseStat(Sigmod::ST_HP, 10);
+    m_species1->setBaseStat(Sigmod::ST_Attack, 10);
+    m_species1->setBaseStat(Sigmod::ST_Defense, 10);
+    m_species1->setBaseStat(Sigmod::ST_Speed, 10);
+    m_species1->setBaseStat(Sigmod::ST_SpecialAttack, 10);
+    m_species1->setBaseStat(Sigmod::ST_SpecialDefense, 10);
+    m_species1->setEffortValue(Sigmod::ST_HP, 18);
+    m_species1->setEffortValue(Sigmod::ST_Attack, 18);
+    m_species1->setEffortValue(Sigmod::ST_Defense, 18);
+    m_species1->setEffortValue(Sigmod::ST_Speed, 18);
+    m_species1->setEffortValue(Sigmod::ST_SpecialAttack, 18);
+    m_species1->setEffortValue(Sigmod::ST_SpecialDefense, 18);
+    m_species1->setGrowth(Sigmod::Species::Normal);
+    m_species1->setExperienceValue(10);
+    m_species1->setCatchValue(10);
+    m_species1->setMaxHoldWeight(100);
+    m_species1->setRunChance(Sigcore::Fraction(1, 2));
+    m_species1->setFleeChance(Sigcore::Fraction(1, 2));
+    m_species1->setItemChance(Sigcore::Fraction(1, 2));
+    m_species1->setEncyclopediaNumber(1);
+    m_species1->setWeight(100);
+    m_species1->setHeight(100);
+    m_species1->setFrontMaleSprite(3);
+    m_species1->setBackMaleSprite(2);
+    m_species1->setFrontFemaleSprite(1);
+    m_species1->setBackFemaleSprite(0);
+    m_species1->setSkin(1);
+    m_species1->setEncyclopediaEntry("Bar");
+    m_species1->setGenderFactor(Sigcore::Fraction(3, 4));
+    m_species1->setEggSpecies(2);
+    m_species1->setEggSteps(100);
+    m_species1->setType(0, false);
+    m_species1->setType(1, true);
+    m_species1->setEggGroup(0, false);
+    m_species1->setEggGroup(1, true);
+    m_species1->setEvolution(Sigcore::Script("python", "import os"));
+    
+    QVERIFY(file.open(QIODevice::ReadOnly));
+    QVERIFY(xml.setContent(&file));
+    m_species1->load(xml.firstChildElement("Species"));
+    
+    QCOMPARE(m_species1->name(), QString("Foo"));
+    QCOMPARE(m_species1->baseStat(Sigmod::ST_HP), 1);
+    QCOMPARE(m_species1->baseStat(Sigmod::ST_Attack), 1);
+    QCOMPARE(m_species1->baseStat(Sigmod::ST_Defense), 1);
+    QCOMPARE(m_species1->baseStat(Sigmod::ST_Speed), 1);
+    QCOMPARE(m_species1->baseStat(Sigmod::ST_SpecialAttack), 1);
+    QCOMPARE(m_species1->baseStat(Sigmod::ST_SpecialDefense), 1);
+    QCOMPARE(m_species1->effortValue(Sigmod::ST_HP), 5);
+    QCOMPARE(m_species1->effortValue(Sigmod::ST_Attack), 15);
+    QCOMPARE(m_species1->effortValue(Sigmod::ST_Defense), 25);
+    QCOMPARE(m_species1->effortValue(Sigmod::ST_Speed), 35);
+    QCOMPARE(m_species1->effortValue(Sigmod::ST_SpecialAttack), 45);
+    QCOMPARE(m_species1->effortValue(Sigmod::ST_SpecialDefense), 55);
+    // FIXME
+    QEXPECT_FAIL(0, "Loading enumeration data from XML file doesn't work", Continue);
+    QCOMPARE(m_species1->growth(), Sigmod::Species::Fast);
+    QCOMPARE(m_species1->experienceValue(), 0);
+    QCOMPARE(m_species1->catchValue(), 0);
+    QCOMPARE(m_species1->maxHoldWeight(), 0);
+    QCOMPARE(m_species1->runChance(), Sigcore::Fraction(1, 1));
+    QCOMPARE(m_species1->fleeChance(), Sigcore::Fraction(1, 1));
+    QCOMPARE(m_species1->itemChance(), Sigcore::Fraction(1, 1));
+    QCOMPARE(m_species1->encyclopediaNumber(), 0);
+    QCOMPARE(m_species1->weight(), 0);
+    QCOMPARE(m_species1->height(), 0);
+    QCOMPARE(m_species1->encyclopediaEntry(), QString("Foo"));
+    QCOMPARE(m_species1->frontMaleSprite(), 0);
+    QCOMPARE(m_species1->backMaleSprite(), 1);
+    QCOMPARE(m_species1->frontFemaleSprite(), 2);
+    QCOMPARE(m_species1->backFemaleSprite(), 3);
+    QCOMPARE(m_species1->skin(), 0);
+    QCOMPARE(m_species1->genderFactor(), Sigcore::Fraction(1, 2));
+    QCOMPARE(m_species1->eggSpecies(), 1);
+    QCOMPARE(m_species1->eggSteps(), 10);
+    QCOMPARE(m_species1->type(0), true);
+    QCOMPARE(m_species1->type(1), false);
+    QCOMPARE(m_species1->eggGroup(0), true);
+    QCOMPARE(m_species1->eggGroup(1), false);
+    QCOMPARE(m_species1->evolution(), Sigcore::Script());
+}
+
+void TestSpecies::setName()
+{
+    m_species2->setName("Foo");
+    m_species2->setName("Foo");
+    
+    QCOMPARE(m_species2->name(), QString("Foo"));
+    
+    QCOMPARE(m_changedCount, 1);
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 0);
+}
+
+// void TestSpecies::setBaseStat()
+// {
+//     m_species2->set();
+//     m_species2->set();
+//     
+//     QCOMPARE(m_species2->(), );
+//     
+//     QCOMPARE(m_changedCount, 1);
+//     
+//     QCOMPARE(m_warnings.size(), 0);
+//     QCOMPARE(m_errors.size(), 0);
+// }
+// 
+// void TestSpecies::setEffortValue()
+// {
+//     m_species2->set();
+//     m_species2->set();
+//     
+//     QCOMPARE(m_species2->(), );
+//     
+//     QCOMPARE(m_changedCount, 1);
+//     
+//     QCOMPARE(m_warnings.size(), 0);
+//     QCOMPARE(m_errors.size(), 0);
+// }
+
+void TestSpecies::setGrowth()
+{
+    m_species2->setGrowth(Sigmod::Species::Erratic);
+    m_species2->setGrowth(Sigmod::Species::Erratic);
+    
+    QCOMPARE(m_species2->growth(), Sigmod::Species::Erratic);
+    
+    QCOMPARE(m_changedCount, 1);
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 0);
+}
+
+void TestSpecies::setExperienceValue()
+{
+    m_species2->setExperienceValue(-1);
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 1);
+    
+    m_species2->setExperienceValue(10);
+    m_species2->setExperienceValue(10);
+    
+    QCOMPARE(m_species2->experienceValue(), 10);
+    
+    QCOMPARE(m_changedCount, 1);
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 1);
+}
+
+void TestSpecies::setCatchValue()
+{
+    m_species2->setCatchValue(0);
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 1);
+    
+    m_species2->setCatchValue(256);
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 2);
+    
+    m_species2->setCatchValue(10);
+    m_species2->setCatchValue(10);
+    
+    QCOMPARE(m_species2->catchValue(), 10);
+    
+    QCOMPARE(m_changedCount, 1);
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 2);
+}
+
+void TestSpecies::setMaxHoldWeight()
+{
+    m_species2->setMaxHoldWeight(-1);
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 1);
+    
+    m_species2->setMaxHoldWeight(10);
+    m_species2->setMaxHoldWeight(10);
+    
+    QCOMPARE(m_species2->maxHoldWeight(), 10);
+    
+    QCOMPARE(m_changedCount, 1);
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 1);
+}
+
+void TestSpecies::setRunChance()
+{
+    m_species2->setRunChance(Sigcore::Fraction(-1, 1));
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 1);
+    
+    m_species2->setRunChance(Sigcore::Fraction(2, 1));
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 2);
+    
+    m_species2->setRunChance(Sigcore::Fraction(3, 4));
+    m_species2->setRunChance(Sigcore::Fraction(3, 4));
+    
+    QCOMPARE(m_species2->runChance(), Sigcore::Fraction(3, 4));
+    
+    QCOMPARE(m_changedCount, 1);
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 2);
+}
+
+void TestSpecies::setFleeChance()
+{
+    m_species2->setFleeChance(Sigcore::Fraction(-1, 1));
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 1);
+    
+    m_species2->setFleeChance(Sigcore::Fraction(2, 1));
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 2);
+    
+    m_species2->setFleeChance(Sigcore::Fraction(3, 4));
+    m_species2->setFleeChance(Sigcore::Fraction(3, 4));
+    
+    QCOMPARE(m_species2->fleeChance(), Sigcore::Fraction(3, 4));
+    
+    QCOMPARE(m_changedCount, 1);
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 2);
+}
+
+void TestSpecies::setItemChance()
+{
+    m_species2->setItemChance(Sigcore::Fraction(-1, 1));
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 1);
+    
+    m_species2->setItemChance(Sigcore::Fraction(2, 1));
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 2);
+    
+    m_species2->setItemChance(Sigcore::Fraction(3, 4));
+    m_species2->setItemChance(Sigcore::Fraction(3, 4));
+    
+    QCOMPARE(m_species2->itemChance(), Sigcore::Fraction(3, 4));
+    
+    QCOMPARE(m_changedCount, 1);
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 2);
+}
+
+void TestSpecies::setEncyclopediaNumber()
+{
+    m_species2->setEncyclopediaNumber(-2);
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 1);
+    
+    m_species2->setEncyclopediaNumber(5);
+    m_species2->setEncyclopediaNumber(5);
+    
+    QCOMPARE(m_species2->encyclopediaNumber(), 5);
+    
+    QCOMPARE(m_changedCount, 1);
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 1);
+}
+
+void TestSpecies::setWeight()
+{
+    m_species2->setWeight(-1);
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 1);
+    
+    m_species2->setWeight(10);
+    m_species2->setWeight(10);
+    
+    QCOMPARE(m_species2->weight(), 10);
+    
+    QCOMPARE(m_changedCount, 1);
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 1);
+}
+
+void TestSpecies::setHeight()
+{
+    m_species2->setHeight(-1);
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 1);
+    
+    m_species2->setHeight(10);
+    m_species2->setHeight(10);
+    
+    QCOMPARE(m_species2->height(), 10);
+    
+    QCOMPARE(m_changedCount, 1);
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 1);
+}
+
+void TestSpecies::setFrontMaleSprite()
+{
+    m_species2->setFrontMaleSprite(4);
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 1);
+    
+    m_species2->setGenderFactor(Sigcore::Fraction(1, 1));
+    m_sigmod->newSprite();
+    
+    m_species2->setFrontMaleSprite(4);
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 2);
+    
+    m_species2->setGenderFactor(Sigcore::Fraction(1, 2));
+    
+    m_species2->setFrontMaleSprite(4);
+    m_species2->setFrontMaleSprite(4);
+    
+    QCOMPARE(m_species2->frontMaleSprite(), 4);
+    
+    QCOMPARE(m_changedCount, 3);
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 2);
+}
+
+void TestSpecies::setBackMaleSprite()
+{
+    m_species2->setBackMaleSprite(5);
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 1);
+    
+    m_species2->setGenderFactor(Sigcore::Fraction(1, 1));
+    m_sigmod->newSprite();
+    
+    m_species2->setBackMaleSprite(5);
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 2);
+    
+    m_species2->setGenderFactor(Sigcore::Fraction(1, 2));
+    
+    m_species2->setBackMaleSprite(5);
+    m_species2->setBackMaleSprite(5);
+    
+    QCOMPARE(m_species2->backMaleSprite(), 5);
+    
+    QCOMPARE(m_changedCount, 3);
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 2);
+}
+
+void TestSpecies::setFrontFemaleSprite()
+{
+    m_sigmod->rules()->setGenderAllowed(true);
+    
+    m_species2->setFrontFemaleSprite(6);
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 1);
+    
+    m_species2->setGenderFactor(Sigcore::Fraction(0, 1));
+    m_sigmod->newSprite();
+    
+    m_species2->setFrontFemaleSprite(6);
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 2);
+    
+    m_species2->setGenderFactor(Sigcore::Fraction(1, 2));
+    
+    m_species2->setFrontFemaleSprite(6);
+    m_species2->setFrontFemaleSprite(6);
+    
+    QCOMPARE(m_species2->frontFemaleSprite(), 6);
+    
+    QCOMPARE(m_changedCount, 3);
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 2);
+    
+    m_sigmod->rules()->setGenderAllowed(false);
+    
+    m_species2->setFrontFemaleSprite(6);
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 3);
+}
+
+void TestSpecies::setBackFemaleSprite()
+{
+    m_sigmod->rules()->setGenderAllowed(true);
+    
+    m_species2->setBackFemaleSprite(7);
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 1);
+    
+    m_species2->setGenderFactor(Sigcore::Fraction(0, 1));
+    m_sigmod->newSprite();
+    
+    m_species2->setBackFemaleSprite(7);
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 2);
+    
+    m_species2->setGenderFactor(Sigcore::Fraction(1, 2));
+    
+    m_species2->setBackFemaleSprite(7);
+    m_species2->setBackFemaleSprite(7);
+    
+    QCOMPARE(m_species2->backFemaleSprite(), 7);
+    
+    QCOMPARE(m_changedCount, 3);
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 2);
+    
+    m_sigmod->rules()->setGenderAllowed(false);
+    
+    m_species2->setBackFemaleSprite(7);
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 3);
+}
+
+void TestSpecies::setSkin()
+{
+    m_species2->setSkin(2);
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 1);
+    
+    m_sigmod->newSkin();
+    
+    m_species2->setSkin(2);
+    m_species2->setSkin(2);
+    
+    QCOMPARE(m_species2->skin(), 2);
+    
+    QCOMPARE(m_changedCount, 1);
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 1);
+}
+
+void TestSpecies::setEncyclopediaEntry()
+{
+    m_species2->setEncyclopediaEntry("Foo");
+    m_species2->setEncyclopediaEntry("Foo");
+    
+    QCOMPARE(m_species2->encyclopediaEntry(), QString("Foo"));
+    
+    QCOMPARE(m_changedCount, 1);
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 0);
+}
+
+void TestSpecies::setGenderFactor()
+{
+    m_species2->setGenderFactor(Sigcore::Fraction(-2, 1));
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 1);
+    
+    m_species2->setGenderFactor(Sigcore::Fraction(2, 1));
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 2);
+    
+    m_species2->setGenderFactor(Sigcore::Fraction(1, 4));
+    m_species2->setGenderFactor(Sigcore::Fraction(1, 4));
+    
+    QCOMPARE(m_species2->genderFactor(), Sigcore::Fraction(1, 4));
+    
+    QCOMPARE(m_changedCount, 1);
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 2);
+}
+
+void TestSpecies::setEggSpecies()
+{
+    m_species2->setEggSpecies(2);
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 0);
+    
+    m_sigmod->newSpecies();
+    
+    m_species2->setEggSpecies(2);
+    m_species2->setEggSpecies(2);
+    
+    QCOMPARE(m_species2->eggSpecies(), 2);
+    
+    QCOMPARE(m_changedCount, 1);
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 0);
+}
+
+void TestSpecies::setEggSteps()
+{
+    m_species2->setEggSteps(0);
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 1);
+    
+    m_species2->setEggSteps(1000);
+    m_species2->setEggSteps(1000);
+    
+    QCOMPARE(m_species2->eggSteps(), 1000);
+    
+    QCOMPARE(m_changedCount, 1);
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 1);
+}
+
+// void TestSpecies::setType()
+// {
+//     m_species2->set();
+//     m_species2->set();
+//     
+//     QCOMPARE(m_species2->(), );
+//     
+//     QCOMPARE(m_changedCount, 1);
+//     
+//     QCOMPARE(m_warnings.size(), 0);
+//     QCOMPARE(m_errors.size(), 0);
+// }
+// 
+// void TestSpecies::setEggGroup()
+// {
+//     m_species2->set();
+//     m_species2->set();
+//     
+//     QCOMPARE(m_species2->(), );
+//     
+//     QCOMPARE(m_changedCount, 1);
+//     
+//     QCOMPARE(m_warnings.size(), 0);
+//     QCOMPARE(m_errors.size(), 0);
+// }
+
+void TestSpecies::setEvolution()
+{
+    m_species2->setEvolution(Sigcore::Script("python", "import os"));
+    m_species2->setEvolution(Sigcore::Script("python", "import os"));
+    
+    QCOMPARE(m_species2->evolution(), Sigcore::Script("python", "import os"));
+    
+    QCOMPARE(m_changedCount, 1);
+    
+    QCOMPARE(m_warnings.size(), 0);
+    QCOMPARE(m_errors.size(), 0);
+}
+
+void TestSpecies::assignment()
+{
+    *m_species3 = *m_species2;
+    
+    QCOMPARE(m_species3->name(), QString("Foo"));
+//     QCOMPARE(m_species3->baseStat(Sigmod::ST_HP), 10);
+//     QCOMPARE(m_species3->baseStat(Sigmod::ST_Attack), 10);
+//     QCOMPARE(m_species3->baseStat(Sigmod::ST_Defense), 10);
+//     QCOMPARE(m_species3->baseStat(Sigmod::ST_Speed), 10);
+//     QCOMPARE(m_species3->baseStat(Sigmod::ST_SpecialAttack), 10);
+//     QCOMPARE(m_species3->baseStat(Sigmod::ST_SpecialDefense), 10);
+//     QCOMPARE(m_species3->effortValue(Sigmod::ST_HP), 18);
+//     QCOMPARE(m_species3->effortValue(Sigmod::ST_Attack), 18);
+//     QCOMPARE(m_species3->effortValue(Sigmod::ST_Defense), 18);
+//     QCOMPARE(m_species3->effortValue(Sigmod::ST_Speed), 18);
+//     QCOMPARE(m_species3->effortValue(Sigmod::ST_SpecialAttack), 18);
+//     QCOMPARE(m_species3->effortValue(Sigmod::ST_SpecialDefense), 18);
+    QCOMPARE(m_species3->growth(), Sigmod::Species::Erratic);
+    QCOMPARE(m_species3->experienceValue(), 10);
+    QCOMPARE(m_species3->catchValue(), 10);
+    QCOMPARE(m_species3->maxHoldWeight(), 10);
+    QCOMPARE(m_species3->runChance(), Sigcore::Fraction(3, 4));
+    QCOMPARE(m_species3->fleeChance(), Sigcore::Fraction(3, 4));
+    QCOMPARE(m_species3->itemChance(), Sigcore::Fraction(3, 4));
+    QCOMPARE(m_species3->encyclopediaNumber(), 5);
+    QCOMPARE(m_species3->weight(), 10);
+    QCOMPARE(m_species3->height(), 10);
+    QCOMPARE(m_species3->encyclopediaEntry(), QString("Foo"));
+    QCOMPARE(m_species3->frontMaleSprite(), 4);
+    QCOMPARE(m_species3->backMaleSprite(), 5);
+    QCOMPARE(m_species3->frontFemaleSprite(), 6);
+    QCOMPARE(m_species3->backFemaleSprite(), 7);
+    QCOMPARE(m_species3->skin(), 2);
+    QCOMPARE(m_species3->genderFactor(), Sigcore::Fraction(1, 4));
+    QCOMPARE(m_species3->eggSpecies(), 2);
+    QCOMPARE(m_species3->eggSteps(), 1000);
+//     QCOMPARE(m_species3->type(), );
+//     QCOMPARE(m_species3->type(), );
+//     QCOMPARE(m_species3->type(), );
+//     QCOMPARE(m_species3->eggGroup(), );
+//     QCOMPARE(m_species3->eggGroup(), );
+//     QCOMPARE(m_species3->eggGroup(), );
+    QCOMPARE(m_species3->evolution(), Sigcore::Script("python", "import os"));
+}
+
+QTEST_APPLESS_MAIN(TestSpecies)
diff --git a/sigmod/test/TestSpecies.h b/sigmod/test/TestSpecies.h
new file mode 100644
index 00000000..412447f8
--- /dev/null
+++ b/sigmod/test/TestSpecies.h
@@ -0,0 +1,79 @@
+/*
+ * 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_TESTSPECIES
+#define SIGMOD_TESTSPECIES
+
+// Test includes
+#include "TestSigmodObject.h"
+
+// Sigmod includes
+#include "../Species.h"
+
+class TestSpecies : public TestSigmodObject
+{
+    Q_OBJECT
+    
+    private slots:
+        void initTestCase();
+        void cleanupTestCase();
+        
+        void init();
+        void cleanup();
+        
+        void validation();
+        void saving();
+        void loading();
+        
+        void setName();
+//         void setBaseStat();
+//         void setEffortValue();
+        void setGrowth();
+        void setExperienceValue();
+        void setCatchValue();
+        void setMaxHoldWeight();
+        void setRunChance();
+        void setFleeChance();
+        void setItemChance();
+        void setEncyclopediaNumber();
+        void setWeight();
+        void setHeight();
+        void setEncyclopediaEntry();
+        void setFrontMaleSprite();
+        void setBackMaleSprite();
+        void setFrontFemaleSprite();
+        void setBackFemaleSprite();
+        void setGenderFactor();
+        void setSkin();
+        void setEggSpecies();
+        void setEggSteps();
+//         void setType();
+//         void setEggGroup();
+        void setEvolution();
+        
+//         void abilities();
+//         void items();
+//         void moves();
+        
+        void assignment();
+    private:
+        Sigmod::Species* m_species1;
+        Sigmod::Species* m_species2;
+        Sigmod::Species* m_species3;
+};
+
+#endif