Added kmymoney

git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/applications/kmymoney@1239792 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

1 files changed, 1550 insertions, 0 deletions

diff --git a/kmymoney2/mymoney/mymoneyfiletest.cpp b/kmymoney2/mymoney/mymoneyfiletest.cpp
new file mode 100644
index 0000000..e081fa0
--- /dev/null
+++ b/kmymoney2/mymoney/mymoneyfiletest.cpp
@@ -0,0 +1,1550 @@
+/***************************************************************************
+                          mymoneyfiletest.cpp
+                          -------------------
+    copyright            : (C) 2002 by Thomas Baumgart
+    email                : ipwizard@users.sourceforge.net
+ ***************************************************************************/
+
+/***************************************************************************
+ *                                                                         *
+ *   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 2 of the License, or     *
+ *   (at your option) any later version.                                   *
+ *                                                                         *
+ ***************************************************************************/
+
+#include "mymoneyfiletest.h"
+#include <iostream>
+
+#include <memory>
+#include <unistd.h>
+#include <qfile.h>
+#include <qdatastream.h>
+
+MyMoneyFileTest:: MyMoneyFileTest () {}
+
+
+void MyMoneyFileTest::setUp () {
+        storage = new MyMoneySeqAccessMgr;
+        m = MyMoneyFile::instance();
+        m->attachStorage(storage);
+}
+
+void MyMoneyFileTest::tearDown () {
+        m->detachStorage(storage);
+        delete storage;
+}
+
+void MyMoneyFileTest::testEmptyConstructor() {
+        MyMoneyPayee user = m->user();
+
+        CPPUNIT_ASSERT(user.name().isEmpty());
+        CPPUNIT_ASSERT(user.address().isEmpty());
+        CPPUNIT_ASSERT(user.city().isEmpty());
+        CPPUNIT_ASSERT(user.state().isEmpty());
+        CPPUNIT_ASSERT(user.postcode().isEmpty());
+        CPPUNIT_ASSERT(user.telephone().isEmpty());
+        CPPUNIT_ASSERT(user.email().isEmpty());
+
+        CPPUNIT_ASSERT(m->institutionCount() == 0);
+        CPPUNIT_ASSERT(m->dirty() == false);
+        CPPUNIT_ASSERT(m->accountCount() == 5);
+}
+
+void MyMoneyFileTest::testAddOneInstitution() {
+        MyMoneyInstitution institution;
+
+        institution.setName("institution1");
+        institution.setTown("town");
+        institution.setStreet("street");
+        institution.setPostcode("postcode");
+        institution.setTelephone("telephone");
+        institution.setManager("manager");
+        institution.setSortcode("sortcode");
+
+        // MyMoneyInstitution institution_file("", institution);
+        MyMoneyInstitution institution_id("I000002", institution);
+        MyMoneyInstitution institution_noname(institution);
+        institution_noname.setName(QString());
+
+        QString id;
+
+        CPPUNIT_ASSERT(m->institutionCount() == 0);
+        storage->m_dirty = false;
+
+        MyMoneyFileTransaction ft;
+        try {
+                m->addInstitution(institution);
+                ft.commit();
+                CPPUNIT_ASSERT(institution.id() == "I000001");
+                CPPUNIT_ASSERT(m->institutionCount() == 1);
+                CPPUNIT_ASSERT(m->dirty() == true);
+        } catch(MyMoneyException *e) {
+                CPPUNIT_FAIL("Unexpected exception");
+                delete e;
+        }
+
+        ft.restart();
+        try {
+                m->addInstitution(institution_id);
+                CPPUNIT_FAIL("Missing expected exception");
+        } catch(MyMoneyException *e) {
+                ft.commit();
+                CPPUNIT_ASSERT(m->institutionCount() == 1);
+                delete e;
+        }
+
+        ft.restart();
+        try {
+                m->addInstitution(institution_noname);
+                CPPUNIT_FAIL("Missing expected exception");
+        } catch(MyMoneyException *e) {
+                ft.commit();
+                CPPUNIT_ASSERT(m->institutionCount() == 1);
+                delete e;
+        }
+}
+
+void MyMoneyFileTest::testAddTwoInstitutions() {
+        testAddOneInstitution();
+        MyMoneyInstitution institution;
+        institution.setName("institution2");
+        institution.setTown("town");
+        institution.setStreet("street");
+        institution.setPostcode("postcode");
+        institution.setTelephone("telephone");
+        institution.setManager("manager");
+        institution.setSortcode("sortcode");
+
+        QString id;
+
+        storage->m_dirty = false;
+        MyMoneyFileTransaction ft;
+        try {
+                m->addInstitution(institution);
+                ft.commit();
+
+                CPPUNIT_ASSERT(institution.id() == "I000002");
+                CPPUNIT_ASSERT(m->institutionCount() == 2);
+                CPPUNIT_ASSERT(m->dirty() == true);
+        } catch(MyMoneyException *e) {
+                CPPUNIT_FAIL("Unexpected exception");
+                delete e;
+        }
+
+        storage->m_dirty = false;
+
+        try {
+                institution = m->institution("I000001");
+                CPPUNIT_ASSERT(institution.id() == "I000001");
+                CPPUNIT_ASSERT(m->institutionCount() == 2);
+                CPPUNIT_ASSERT(m->dirty() == false);
+
+                institution = m->institution("I000002");
+                CPPUNIT_ASSERT(institution.id() == "I000002");
+                CPPUNIT_ASSERT(m->institutionCount() == 2);
+                CPPUNIT_ASSERT(m->dirty() == false);
+        } catch (MyMoneyException *e) {
+                CPPUNIT_FAIL("Unexpected exception");
+                delete e;
+        }
+}
+
+void MyMoneyFileTest::testRemoveInstitution() {
+        testAddTwoInstitutions();
+
+        MyMoneyInstitution i;
+
+        CPPUNIT_ASSERT(m->institutionCount() == 2);
+
+        i = m->institution("I000001");
+        CPPUNIT_ASSERT(i.id() == "I000001");
+        CPPUNIT_ASSERT(i.accountCount() == 0);
+
+        storage->m_dirty = false;
+        MyMoneyFileTransaction ft;
+        try {
+                m->removeInstitution(i);
+                ft.commit();
+                CPPUNIT_ASSERT(m->institutionCount() == 1);
+                CPPUNIT_ASSERT(m->dirty() == true);
+        } catch (MyMoneyException *e) {
+                CPPUNIT_FAIL("Unexpected exception");
+                delete e;
+        }
+
+        storage->m_dirty = false;
+
+        try {
+                m->institution("I000001");
+                CPPUNIT_FAIL("Missing expected exception");
+        } catch(MyMoneyException *e) {
+                CPPUNIT_ASSERT(m->institutionCount() == 1);
+                CPPUNIT_ASSERT(m->dirty() == false);
+                delete e;
+        }
+
+        ft.restart();
+        try {
+                m->removeInstitution(i);
+                CPPUNIT_FAIL("Missing expected exception");
+        } catch(MyMoneyException *e) {
+                ft.commit();
+                CPPUNIT_ASSERT(m->institutionCount() == 1);
+                CPPUNIT_ASSERT(m->dirty() == false);
+                delete e;
+        }
+}
+
+void MyMoneyFileTest::testInstitutionRetrieval () {
+
+        testAddOneInstitution();
+
+        storage->m_dirty = false;
+
+        MyMoneyInstitution institution;
+
+        CPPUNIT_ASSERT(m->institutionCount() == 1);
+
+        try {
+                institution = m->institution("I000001");
+                CPPUNIT_ASSERT(institution.id() == "I000001");
+                CPPUNIT_ASSERT(m->institutionCount() == 1);
+        } catch (MyMoneyException *e) {
+                CPPUNIT_FAIL("Unexpected exception");
+                delete e;
+        }
+
+        try {
+                institution = m->institution("I000002");
+                CPPUNIT_FAIL("Missing expected exception");
+        } catch(MyMoneyException *e) {
+                CPPUNIT_ASSERT(m->institutionCount() == 1);
+                delete e;
+        }
+
+        CPPUNIT_ASSERT(m->dirty() == false);
+}
+
+void MyMoneyFileTest::testInstitutionListRetrieval () {
+        QValueList<MyMoneyInstitution> list;
+
+        storage->m_dirty = false;
+        list = m->institutionList();
+        CPPUNIT_ASSERT(m->dirty() == false);
+        CPPUNIT_ASSERT(list.count() == 0);
+
+        testAddTwoInstitutions();
+
+        storage->m_dirty = false;
+        list = m->institutionList();
+        CPPUNIT_ASSERT(m->dirty() == false);
+        CPPUNIT_ASSERT(list.count() == 2);
+
+        QValueList<MyMoneyInstitution>::ConstIterator it;
+        it = list.begin();
+
+        CPPUNIT_ASSERT((*it).name() == "institution1");
+        ++it;
+        CPPUNIT_ASSERT((*it).name() == "institution2");
+        ++it;
+        CPPUNIT_ASSERT(it == list.end());
+}
+
+void MyMoneyFileTest::testInstitutionModify() {
+        testAddTwoInstitutions();
+        MyMoneyInstitution institution;
+
+        institution = m->institution("I000001");
+        institution.setStreet("new street");
+        institution.setTown("new town");
+        institution.setPostcode("new postcode");
+        institution.setTelephone("new telephone");
+        institution.setManager("new manager");
+        institution.setName("new name");
+        institution.setSortcode("new sortcode");
+
+        storage->m_dirty = false;
+
+        MyMoneyFileTransaction ft;
+        try {
+                m->modifyInstitution(institution);
+                ft.commit();
+                CPPUNIT_ASSERT(institution.id() == "I000001");
+                CPPUNIT_ASSERT(m->institutionCount() == 2);
+                CPPUNIT_ASSERT(m->dirty() == true);
+        } catch(MyMoneyException *e) {
+                delete e;
+                CPPUNIT_FAIL("Unexpected exception");
+        }
+
+        MyMoneyInstitution newInstitution;
+        newInstitution = m->institution("I000001");
+
+        CPPUNIT_ASSERT(newInstitution.id() == "I000001");
+        CPPUNIT_ASSERT(newInstitution.street() == "new street");
+        CPPUNIT_ASSERT(newInstitution.town() == "new town");
+        CPPUNIT_ASSERT(newInstitution.postcode() == "new postcode");
+        CPPUNIT_ASSERT(newInstitution.telephone() == "new telephone");
+        CPPUNIT_ASSERT(newInstitution.manager() == "new manager");
+        CPPUNIT_ASSERT(newInstitution.name() == "new name");
+        CPPUNIT_ASSERT(newInstitution.sortcode() == "new sortcode");
+
+        storage->m_dirty = false;
+
+        ft.restart();
+        MyMoneyInstitution failInstitution2("I000003", newInstitution);
+        try {
+                m->modifyInstitution(failInstitution2);
+                CPPUNIT_FAIL("Exception expected");
+        } catch(MyMoneyException *e) {
+                ft.commit();
+                delete e;
+                CPPUNIT_ASSERT(failInstitution2.id() == "I000003");
+                CPPUNIT_ASSERT(m->institutionCount() == 2);
+                CPPUNIT_ASSERT(m->dirty() == false);
+        }
+}
+
+void MyMoneyFileTest::testSetFunctions() {
+        MyMoneyPayee user = m->user();
+
+        CPPUNIT_ASSERT(user.name().isEmpty());
+        CPPUNIT_ASSERT(user.address().isEmpty());
+        CPPUNIT_ASSERT(user.city().isEmpty());
+        CPPUNIT_ASSERT(user.state().isEmpty());
+        CPPUNIT_ASSERT(user.postcode().isEmpty());
+        CPPUNIT_ASSERT(user.telephone().isEmpty());
+        CPPUNIT_ASSERT(user.email().isEmpty());
+
+        MyMoneyFileTransaction ft;
+        storage->m_dirty = false;
+        user.setName("Name");
+        m->setUser(user);
+        CPPUNIT_ASSERT(m->dirty() == true);
+        storage->m_dirty = false;
+        user.setAddress("Street");
+        m->setUser(user);
+        CPPUNIT_ASSERT(m->dirty() == true);
+        storage->m_dirty = false;
+        user.setCity("Town");
+        m->setUser(user);
+        CPPUNIT_ASSERT(m->dirty() == true);
+        storage->m_dirty = false;
+        user.setState("County");
+        m->setUser(user);
+        CPPUNIT_ASSERT(m->dirty() == true);
+        storage->m_dirty = false;
+        user.setPostcode("Postcode");
+        m->setUser(user);
+        CPPUNIT_ASSERT(m->dirty() == true);
+        storage->m_dirty = false;
+        user.setTelephone("Telephone");
+        m->setUser(user);
+        CPPUNIT_ASSERT(m->dirty() == true);
+        storage->m_dirty = false;
+        user.setEmail("Email");
+        m->setUser(user);
+        CPPUNIT_ASSERT(m->dirty() == true);
+        storage->m_dirty = false;
+
+        ft.commit();
+        user = m->user();
+        CPPUNIT_ASSERT(user.name() == "Name");
+        CPPUNIT_ASSERT(user.address() == "Street");
+        CPPUNIT_ASSERT(user.city() == "Town");
+        CPPUNIT_ASSERT(user.state() == "County");
+        CPPUNIT_ASSERT(user.postcode() == "Postcode");
+        CPPUNIT_ASSERT(user.telephone() == "Telephone");
+        CPPUNIT_ASSERT(user.email() == "Email");
+}
+
+void MyMoneyFileTest::testAddAccounts() {
+        testAddTwoInstitutions();
+        MyMoneyAccount  a, b, c;
+        a.setAccountType(MyMoneyAccount::Checkings);
+        b.setAccountType(MyMoneyAccount::Checkings);
+
+        MyMoneyInstitution institution;
+
+        storage->m_dirty = false;
+
+        CPPUNIT_ASSERT(m->accountCount() == 5);
+
+        institution = m->institution("I000001");
+        CPPUNIT_ASSERT(institution.id() == "I000001");
+
+        a.setName("Account1");
+        a.setInstitutionId(institution.id());
+
+        MyMoneyFileTransaction ft;
+        try {
+                MyMoneyAccount parent = m->asset();
+                m->addAccount(a, parent);
+                ft.commit();
+                CPPUNIT_ASSERT(m->accountCount() == 6);
+                CPPUNIT_ASSERT(a.parentAccountId() == "AStd::Asset");
+                CPPUNIT_ASSERT(a.id() == "A000001");
+                CPPUNIT_ASSERT(a.institutionId() == "I000001");
+                CPPUNIT_ASSERT(m->dirty() == true);
+                CPPUNIT_ASSERT(m->asset().accountList().count() == 1);
+                CPPUNIT_ASSERT(m->asset().accountList()[0] == "A000001");
+
+                institution = m->institution("I000001");
+                CPPUNIT_ASSERT(institution.accountCount() == 1);
+                CPPUNIT_ASSERT(institution.accountList()[0] == "A000001");
+
+        } catch(MyMoneyException *e) {
+                delete e;
+                CPPUNIT_FAIL("Unexpected exception!");
+        }
+
+        // try to add this account again, should not work
+        ft.restart();
+        try {
+                MyMoneyAccount parent = m->asset();
+                m->addAccount(a, parent);
+                CPPUNIT_FAIL("Expecting exception!");
+        } catch(MyMoneyException *e) {
+                ft.commit();
+                delete e;
+        }
+
+        // check that we can modify the local object and
+        // reload it from the file
+        a.setName("AccountX");
+        a = m->account("A000001");
+        CPPUNIT_ASSERT(a.name() == "Account1");
+
+        storage->m_dirty = false;
+
+        // check if we can get the same info to a different object
+        c = m->account("A000001");
+        CPPUNIT_ASSERT(c.accountType() == MyMoneyAccount::Checkings);
+        CPPUNIT_ASSERT(c.id() == "A000001");
+        CPPUNIT_ASSERT(c.name() == "Account1");
+        CPPUNIT_ASSERT(c.institutionId() == "I000001");
+
+        CPPUNIT_ASSERT(m->dirty() == false);
+
+        // add a second account
+        institution = m->institution("I000002");
+        b.setName("Account2");
+        b.setInstitutionId(institution.id());
+        ft.restart();
+        try {
+                MyMoneyAccount parent = m->asset();
+                m->addAccount(b, parent);
+                ft.commit();
+                CPPUNIT_ASSERT(m->dirty() == true);
+                CPPUNIT_ASSERT(b.id() == "A000002");
+                CPPUNIT_ASSERT(b.parentAccountId() == "AStd::Asset");
+                CPPUNIT_ASSERT(m->accountCount() == 7);
+
+                institution = m->institution("I000001");
+                CPPUNIT_ASSERT(institution.accountCount() == 1);
+                CPPUNIT_ASSERT(institution.accountList()[0] == "A000001");
+
+                institution = m->institution("I000002");
+                CPPUNIT_ASSERT(institution.accountCount() == 1);
+                CPPUNIT_ASSERT(institution.accountList()[0] == "A000002");
+
+                CPPUNIT_ASSERT(m->asset().accountList().count() == 2);
+                CPPUNIT_ASSERT(m->asset().accountList()[0] == "A000001");
+                CPPUNIT_ASSERT(m->asset().accountList()[1] == "A000002");
+
+        } catch(MyMoneyException *e) {
+                delete e;
+                CPPUNIT_FAIL("Unexpected exception!");
+        }
+
+        MyMoneyAccount p;
+
+        p = m->account("A000002");
+        CPPUNIT_ASSERT(p.accountType() == MyMoneyAccount::Checkings);
+        CPPUNIT_ASSERT(p.id() == "A000002");
+        CPPUNIT_ASSERT(p.name() == "Account2");
+        CPPUNIT_ASSERT(p.institutionId() == "I000002");
+}
+
+void MyMoneyFileTest::testModifyAccount() {
+        testAddAccounts();
+        storage->m_dirty = false;
+
+        MyMoneyAccount p = m->account("A000001");
+        MyMoneyInstitution institution;
+
+        CPPUNIT_ASSERT(p.accountType() == MyMoneyAccount::Checkings);
+        CPPUNIT_ASSERT(p.name() == "Account1");
+
+        p.setName("New account name");
+        MyMoneyFileTransaction ft;
+        try {
+                m->modifyAccount(p);
+                ft.commit();
+
+                CPPUNIT_ASSERT(m->dirty() == true);
+                CPPUNIT_ASSERT(m->accountCount() == 7);
+                CPPUNIT_ASSERT(p.accountType() == MyMoneyAccount::Checkings);
+                CPPUNIT_ASSERT(p.name() == "New account name");
+
+        } catch(MyMoneyException *e) {
+                delete e;
+                CPPUNIT_FAIL("Unexpected exception!");
+        }
+        storage->m_dirty = false;
+
+        // try to move account to new institution
+        p.setInstitutionId("I000002");
+        ft.restart();
+        try {
+                m->modifyAccount(p);
+                ft.commit();
+
+                CPPUNIT_ASSERT(m->dirty() == true);
+                CPPUNIT_ASSERT(m->accountCount() == 7);
+                CPPUNIT_ASSERT(p.accountType() == MyMoneyAccount::Checkings);
+                CPPUNIT_ASSERT(p.name() == "New account name");
+                CPPUNIT_ASSERT(p.institutionId() == "I000002");
+
+                institution = m->institution("I000001");
+                CPPUNIT_ASSERT(institution.accountCount() == 0);
+
+                institution = m->institution("I000002");
+                CPPUNIT_ASSERT(institution.accountCount() == 2);
+                CPPUNIT_ASSERT(institution.accountList()[0] == "A000002");
+                CPPUNIT_ASSERT(institution.accountList()[1] == "A000001");
+
+        } catch(MyMoneyException *e) {
+                delete e;
+                CPPUNIT_FAIL("Unexpected exception!");
+        }
+        storage->m_dirty = false;
+
+        // try to fool engine a bit
+        p.setParentAccountId("A000001");
+        ft.restart();
+        try {
+                m->modifyAccount(p);
+                CPPUNIT_FAIL("Expecting exception!");
+        } catch(MyMoneyException *e) {
+                ft.commit();
+                delete e;
+        }
+}
+
+void MyMoneyFileTest::testReparentAccount() {
+        testAddAccounts();
+        storage->m_dirty = false;
+
+        MyMoneyAccount p = m->account("A000001");
+        MyMoneyAccount q = m->account("A000002");
+        MyMoneyAccount o = m->account(p.parentAccountId());
+
+        // make A000001 a child of A000002
+        MyMoneyFileTransaction ft;
+        try {
+                CPPUNIT_ASSERT(p.parentAccountId() != q.id());
+                CPPUNIT_ASSERT(o.accountCount() == 2);
+                CPPUNIT_ASSERT(q.accountCount() == 0);
+                m->reparentAccount(p, q);
+                ft.commit();
+                CPPUNIT_ASSERT(m->dirty() == true);
+                CPPUNIT_ASSERT(p.parentAccountId() == q.id());
+                CPPUNIT_ASSERT(q.accountCount() == 1);
+                CPPUNIT_ASSERT(q.id() == "A000002");
+                CPPUNIT_ASSERT(p.id() == "A000001");
+                CPPUNIT_ASSERT(q.accountList()[0] == p.id());
+
+                o = m->account(o.id());
+                CPPUNIT_ASSERT(o.accountCount() == 1);
+        } catch(MyMoneyException *e) {
+                delete e;
+                CPPUNIT_FAIL("Unexpected exception!");
+        }
+}
+
+void MyMoneyFileTest::testRemoveStdAccount(const MyMoneyAccount& acc) {
+        QString txt("Exception expected while removing account ");
+        txt += acc.id();
+        MyMoneyFileTransaction ft;
+        try {
+                m->removeAccount(acc);
+                CPPUNIT_FAIL(txt.latin1());
+        } catch(MyMoneyException *e) {
+                ft.commit();
+                delete e;
+        }
+}
+
+void MyMoneyFileTest::testRemoveAccount() {
+        MyMoneyInstitution institution;
+
+        testAddAccounts();
+        CPPUNIT_ASSERT(m->accountCount() == 7);
+        storage->m_dirty = false;
+
+        QString id;
+        MyMoneyAccount p = m->account("A000001");
+
+        MyMoneyFileTransaction ft;
+        try {
+                MyMoneyAccount q("Ainvalid", p);
+                m->removeAccount(q);
+                CPPUNIT_FAIL("Exception expected!");
+        } catch(MyMoneyException *e) {
+                ft.commit();
+                delete e;
+        }
+
+        ft.restart();
+        try {
+                m->removeAccount(p);
+                ft.commit();
+                CPPUNIT_ASSERT(m->dirty() == true);
+                CPPUNIT_ASSERT(m->accountCount() == 6);
+                institution = m->institution("I000001");
+                CPPUNIT_ASSERT(institution.accountCount() == 0);
+                CPPUNIT_ASSERT(m->asset().accountList().count() == 1);
+
+                institution = m->institution("I000002");
+                CPPUNIT_ASSERT(institution.accountCount() == 1);
+
+        } catch(MyMoneyException *e) {
+                delete e;
+                CPPUNIT_FAIL("Unexpected exception!");
+        }
+
+        // Check that the standard account-groups cannot be removed
+        testRemoveStdAccount(m->liability());
+        testRemoveStdAccount(m->asset());
+        testRemoveStdAccount(m->expense());
+        testRemoveStdAccount(m->income());
+}
+
+void MyMoneyFileTest::testRemoveAccountTree() {
+        testReparentAccount();
+        MyMoneyAccount a = m->account("A000002");
+
+        MyMoneyFileTransaction ft;
+        // remove the account
+        try {
+                m->removeAccount(a);
+                ft.commit();
+        } catch(MyMoneyException *e) {
+                delete e;
+                CPPUNIT_FAIL("Unexpected exception!");
+        }
+        CPPUNIT_ASSERT(m->accountCount() == 6);
+
+        // make sure it's gone
+        try {
+                m->account("A000002");
+                CPPUNIT_FAIL("Exception expected!");
+        } catch(MyMoneyException *e) {
+                delete e;
+        }
+
+        // make sure that children are re-parented to parent account
+        try {
+                a = m->account("A000001");
+                CPPUNIT_ASSERT(a.parentAccountId() == m->asset().id());
+        } catch(MyMoneyException *e) {
+                delete e;
+                CPPUNIT_FAIL("Unexpected exception!");
+        }
+
+}
+
+void MyMoneyFileTest::testAccountListRetrieval () {
+        QValueList<MyMoneyAccount> list;
+
+        storage->m_dirty = false;
+        m->accountList(list);
+        CPPUNIT_ASSERT(m->dirty() == false);
+        CPPUNIT_ASSERT(list.count() == 0);
+
+        testAddAccounts();
+
+        storage->m_dirty = false;
+        list.clear();
+        m->accountList(list);
+        CPPUNIT_ASSERT(m->dirty() == false);
+        CPPUNIT_ASSERT(list.count() == 2);
+
+        CPPUNIT_ASSERT(list[0].accountType() == MyMoneyAccount::Checkings);
+        CPPUNIT_ASSERT(list[1].accountType() == MyMoneyAccount::Checkings);
+}
+
+void MyMoneyFileTest::testAddTransaction () {
+        testAddAccounts();
+        MyMoneyTransaction t, p;
+
+        MyMoneyAccount exp1;
+        exp1.setAccountType(MyMoneyAccount::Expense);
+        exp1.setName("Expense1");
+        MyMoneyAccount exp2;
+        exp2.setAccountType(MyMoneyAccount::Expense);
+        exp2.setName("Expense2");
+
+        MyMoneyFileTransaction ft;
+        try {
+                MyMoneyAccount parent = m->expense();
+                m->addAccount(exp1, parent);
+                m->addAccount(exp2, parent);
+                ft.commit();
+        } catch(MyMoneyException *e) {
+                delete e;
+                CPPUNIT_FAIL("Unexpected exception!");
+        }
+
+        // fake the last modified flag to check that the
+        // date is updated when we add the transaction
+        MyMoneyAccount a = m->account("A000001");
+        a.setLastModified(QDate(1,2,3));
+        ft.restart();
+        try {
+                m->modifyAccount(a);
+                ft.commit();
+        } catch(MyMoneyException *e) {
+                delete e;
+                CPPUNIT_FAIL("Unexpected exception!");
+        }
+        ft.restart();
+
+        CPPUNIT_ASSERT(m->accountCount() == 9);
+        a = m->account("A000001");
+        CPPUNIT_ASSERT(a.lastModified() == QDate(1,2,3));
+
+        // construct a transaction and add it to the pool
+        t.setPostDate(QDate(2002,2,1));
+        t.setMemo("Memotext");
+
+        MyMoneySplit split1;
+        MyMoneySplit split2;
+
+        split1.setAccountId("A000001");
+        split1.setShares(-1000);
+        split1.setValue(-1000);
+        split2.setAccountId("A000003");
+        split2.setValue(1000);
+        split2.setShares(1000);
+        try {
+                t.addSplit(split1);
+                t.addSplit(split2);
+        } catch(MyMoneyException *e) {
+                delete e;
+                CPPUNIT_FAIL("Unexpected exception!");
+        }
+
+/*
+        // FIXME: we don't have a payee and a number field right now
+        // guess we should have a number field per split, don't know
+        // about the payee
+        t.setMethod(MyMoneyCheckingTransaction::Withdrawal);
+        t.setPayee("Thomas Baumgart");
+        t.setNumber("1234");
+        t.setState(MyMoneyCheckingTransaction::Cleared);
+*/
+        storage->m_dirty = false;
+
+        ft.restart();
+        try {
+                m->addTransaction(t);
+                ft.commit();
+        } catch(MyMoneyException *e) {
+                delete e;
+                CPPUNIT_FAIL("Unexpected exception!");
+        }
+        ft.restart();
+
+        CPPUNIT_ASSERT(t.id() == "T000000000000000001");
+        CPPUNIT_ASSERT(t.postDate() == QDate(2002,2,1));
+        CPPUNIT_ASSERT(t.entryDate() == QDate::currentDate());
+        CPPUNIT_ASSERT(m->dirty() == true);
+
+        // check the balance of the accounts
+        a = m->account("A000001");
+        CPPUNIT_ASSERT(a.lastModified() == QDate::currentDate());
+        CPPUNIT_ASSERT(a.balance() == MyMoneyMoney(-1000));
+
+        MyMoneyAccount b = m->account("A000003");
+        CPPUNIT_ASSERT(b.lastModified() == QDate::currentDate());
+        CPPUNIT_ASSERT(b.balance() == MyMoneyMoney(1000));
+
+        storage->m_dirty = false;
+
+        // locate transaction in MyMoneyFile via id
+
+        try {
+                p = m->transaction("T000000000000000001");
+                CPPUNIT_ASSERT(p.splitCount() == 2);
+                CPPUNIT_ASSERT(p.memo() == "Memotext");
+                CPPUNIT_ASSERT(p.splits()[0].accountId() == "A000001");
+                CPPUNIT_ASSERT(p.splits()[1].accountId() == "A000003");
+        } catch(MyMoneyException *e) {
+                delete e;
+                CPPUNIT_FAIL("Unexpected exception!");
+        }
+
+        // check if it's in the account(s) as well
+
+        try {
+                p = m->transaction("A000001", 0);
+                CPPUNIT_ASSERT(p.id() == "T000000000000000001");
+                CPPUNIT_ASSERT(p.splitCount() == 2);
+                CPPUNIT_ASSERT(p.memo() == "Memotext");
+                CPPUNIT_ASSERT(p.splits()[0].accountId() == "A000001");
+                CPPUNIT_ASSERT(p.splits()[1].accountId() == "A000003");
+        } catch(MyMoneyException *e) {
+                delete e;
+                CPPUNIT_FAIL("Unexpected exception!");
+        }
+
+        try {
+                p = m->transaction("A000003", 0);
+                CPPUNIT_ASSERT(p.id() == "T000000000000000001");
+                CPPUNIT_ASSERT(p.splitCount() == 2);
+                CPPUNIT_ASSERT(p.memo() == "Memotext");
+                CPPUNIT_ASSERT(p.splits()[0].accountId() == "A000001");
+                CPPUNIT_ASSERT(p.splits()[1].accountId() == "A000003");
+        } catch(MyMoneyException *e) {
+                delete e;
+                CPPUNIT_FAIL("Unexpected exception!");
+        }
+}
+
+void MyMoneyFileTest::testIsStandardAccount() {
+        CPPUNIT_ASSERT(m->isStandardAccount(m->liability().id()) == true);
+        CPPUNIT_ASSERT(m->isStandardAccount(m->asset().id()) == true);
+        CPPUNIT_ASSERT(m->isStandardAccount(m->expense().id()) == true);
+        CPPUNIT_ASSERT(m->isStandardAccount(m->income().id()) == true);
+        CPPUNIT_ASSERT(m->isStandardAccount("A00001") == false);
+}
+
+void MyMoneyFileTest::testHasActiveSplits() {
+        testAddTransaction();
+
+        CPPUNIT_ASSERT(m->hasActiveSplits("A000001") == true);
+        CPPUNIT_ASSERT(m->hasActiveSplits("A000002") == false);
+}
+
+void MyMoneyFileTest::testModifyTransactionSimple() {
+        // this will test that we can modify the basic attributes
+        // of a transaction
+        testAddTransaction();
+
+        MyMoneyTransaction t = m->transaction("T000000000000000001");
+        t.setMemo("New Memotext");
+        storage->m_dirty = false;
+
+        MyMoneyFileTransaction ft;
+        try {
+                m->modifyTransaction(t);
+                ft.commit();
+                t = m->transaction("T000000000000000001");
+                CPPUNIT_ASSERT(t.memo() == "New Memotext");
+                CPPUNIT_ASSERT(m->dirty() == true);
+
+        } catch(MyMoneyException *e) {
+                delete e;
+                CPPUNIT_FAIL("Unexpected exception!");
+        }
+}
+
+void MyMoneyFileTest::testModifyTransactionNewPostDate() {
+        // this will test that we can modify the basic attributes
+        // of a transaction
+        testAddTransaction();
+
+        MyMoneyTransaction t = m->transaction("T000000000000000001");
+        t.setPostDate(QDate(2004,2,1));
+        storage->m_dirty = false;
+
+        MyMoneyFileTransaction ft;
+        try {
+                m->modifyTransaction(t);
+                ft.commit();
+                t = m->transaction("T000000000000000001");
+                CPPUNIT_ASSERT(t.postDate() == QDate(2004,2,1));
+                t = m->transaction("A000001", 0);
+                CPPUNIT_ASSERT(t.id() == "T000000000000000001");
+                CPPUNIT_ASSERT(m->dirty() == true);
+
+        } catch(MyMoneyException *e) {
+                delete e;
+                CPPUNIT_FAIL("Unexpected exception!");
+        }
+}
+
+void MyMoneyFileTest::testModifyTransactionNewAccount() {
+        // this will test that we can modify the basic attributes
+        // of a transaction
+        testAddTransaction();
+
+        MyMoneyTransaction t = m->transaction("T000000000000000001");
+        MyMoneySplit s;
+        s = t.splits()[0];
+        s.setAccountId("A000002");
+        t.modifySplit(s);
+
+        storage->m_dirty = false;
+        MyMoneyFileTransaction ft;
+        try {
+/* removed with MyMoneyAccount::Transaction
+                CPPUNIT_ASSERT(m->account("A000001").transactionCount() == 1);
+                CPPUNIT_ASSERT(m->account("A000002").transactionCount() == 0);
+                CPPUNIT_ASSERT(m->account("A000003").transactionCount() == 1);
+*/
+                MyMoneyTransactionFilter f1("A000001");
+                MyMoneyTransactionFilter f2("A000002");
+                MyMoneyTransactionFilter f3("A000003");
+                CPPUNIT_ASSERT(m->transactionList(f1).count() == 1);
+                CPPUNIT_ASSERT(m->transactionList(f2).count() == 0);
+                CPPUNIT_ASSERT(m->transactionList(f3).count() == 1);
+
+                m->modifyTransaction(t);
+                ft.commit();
+                t = m->transaction("T000000000000000001");
+                CPPUNIT_ASSERT(t.postDate() == QDate(2002,2,1));
+                t = m->transaction("A000002", 0);
+                CPPUNIT_ASSERT(m->dirty() == true);
+/* removed with MyMoneyAccount::Transaction
+                CPPUNIT_ASSERT(m->account("A000001").transactionCount() == 0);
+                CPPUNIT_ASSERT(m->account("A000002").transactionCount() == 1);
+                CPPUNIT_ASSERT(m->account("A000003").transactionCount() == 1);
+*/
+                CPPUNIT_ASSERT(m->transactionList(f1).count() == 0);
+                CPPUNIT_ASSERT(m->transactionList(f2).count() == 1);
+                CPPUNIT_ASSERT(m->transactionList(f3).count() == 1);
+
+        } catch(MyMoneyException *e) {
+                delete e;
+                CPPUNIT_FAIL("Unexpected exception!");
+        }
+}
+
+void MyMoneyFileTest::testRemoveTransaction () {
+        testModifyTransactionNewPostDate();
+
+        MyMoneyTransaction t;
+        t = m->transaction("T000000000000000001");
+
+        storage->m_dirty = false;
+        MyMoneyFileTransaction ft;
+        try {
+                m->removeTransaction(t);
+                ft.commit();
+                CPPUNIT_ASSERT(m->dirty() == true);
+                CPPUNIT_ASSERT(m->transactionCount() == 0);
+/* removed with MyMoneyAccount::Transaction
+                CPPUNIT_ASSERT(m->account("A000001").transactionCount() == 0);
+                CPPUNIT_ASSERT(m->account("A000002").transactionCount() == 0);
+                CPPUNIT_ASSERT(m->account("A000003").transactionCount() == 0);
+*/
+                MyMoneyTransactionFilter f1("A000001");
+                MyMoneyTransactionFilter f2("A000002");
+                MyMoneyTransactionFilter f3("A000003");
+                CPPUNIT_ASSERT(m->transactionList(f1).count() == 0);
+                CPPUNIT_ASSERT(m->transactionList(f2).count() == 0);
+                CPPUNIT_ASSERT(m->transactionList(f3).count() == 0);
+
+        } catch(MyMoneyException *e) {
+                delete e;
+                CPPUNIT_FAIL("Unexpected exception!");
+        }
+}
+
+/*
+ * This function is currently not implemented. It's kind of tricky
+ * because it modifies a lot of objects in a single call. This might
+ * be a problem for the undo/redo stuff. That's why I left it out in
+ * the first run. We migh add it, if we need it.
+ * /
+void testMoveSplits() {
+        testModifyTransactionNewPostDate();
+
+        CPPUNIT_ASSERT(m->account("A000001").transactionCount() == 1);
+        CPPUNIT_ASSERT(m->account("A000002").transactionCount() == 0);
+        CPPUNIT_ASSERT(m->account("A000003").transactionCount() == 1);
+
+        try {
+                m->moveSplits("A000001", "A000002");
+                CPPUNIT_ASSERT(m->account("A000001").transactionCount() == 0);
+                CPPUNIT_ASSERT(m->account("A000002").transactionCount() == 1);
+                CPPUNIT_ASSERT(m->account("A000003").transactionCount() == 1);
+        } catch(MyMoneyException *e) {
+                delete e;
+                CPPUNIT_FAIL("Unexpected exception!");
+        }
+}
+*/
+
+void MyMoneyFileTest::testBalanceTotal() {
+        testAddTransaction();
+        MyMoneyTransaction t;
+
+        // construct a transaction and add it to the pool
+        t.setPostDate(QDate(2002,2,1));
+        t.setMemo("Memotext");
+
+        MyMoneySplit split1;
+        MyMoneySplit split2;
+
+        MyMoneyFileTransaction ft;
+        try {
+                split1.setAccountId("A000002");
+                split1.setShares(-1000);
+                split1.setValue(-1000);
+                split2.setAccountId("A000004");
+                split2.setValue(1000);
+                split2.setShares(1000);
+                t.addSplit(split1);
+                t.addSplit(split2);
+                m->addTransaction(t);
+                ft.commit();
+                ft.restart();
+                CPPUNIT_ASSERT(t.id() == "T000000000000000002");
+                CPPUNIT_ASSERT(m->totalBalance("A000001") == MyMoneyMoney(-1000));
+                CPPUNIT_ASSERT(m->totalBalance("A000002") == MyMoneyMoney(-1000));
+
+                MyMoneyAccount p = m->account("A000001");
+                MyMoneyAccount q = m->account("A000002");
+                m->reparentAccount(p, q);
+                ft.commit();
+                CPPUNIT_ASSERT(m->totalBalance("A000001") == MyMoneyMoney(-1000));
+                CPPUNIT_ASSERT(m->totalBalance("A000002") == MyMoneyMoney(-2000));
+        } catch(MyMoneyException *e) {
+                delete e;
+                CPPUNIT_FAIL("Unexpected exception!");
+        }
+}
+
+void MyMoneyFileTest::testSetAccountName() {
+        MyMoneyFileTransaction ft;
+        try {
+                m->setAccountName(STD_ACC_LIABILITY, "Verbindlichkeiten");
+                ft.commit();
+        } catch (MyMoneyException *e) {
+                delete e;
+                CPPUNIT_FAIL("Unexpected exception");
+        }
+        ft.restart();
+        try {
+                m->setAccountName(STD_ACC_ASSET, "Vermögen");
+                ft.commit();
+        } catch (MyMoneyException *e) {
+                delete e;
+                CPPUNIT_FAIL("Unexpected exception");
+        }
+        ft.restart();
+        try {
+                m->setAccountName(STD_ACC_EXPENSE, "Ausgaben");
+                ft.commit();
+        } catch (MyMoneyException *e) {
+                delete e;
+                CPPUNIT_FAIL("Unexpected exception");
+        }
+        ft.restart();
+        try {
+                m->setAccountName(STD_ACC_INCOME, "Einnahmen");
+                ft.commit();
+        } catch (MyMoneyException *e) {
+                delete e;
+                CPPUNIT_FAIL("Unexpected exception");
+        }
+        ft.restart();
+
+        CPPUNIT_ASSERT(m->liability().name() == "Verbindlichkeiten");
+        CPPUNIT_ASSERT(m->asset().name() == "Vermögen");
+        CPPUNIT_ASSERT(m->expense().name() == "Ausgaben");
+        CPPUNIT_ASSERT(m->income().name() == "Einnahmen");
+
+        try {
+                m->setAccountName("A000001", "New account name");
+                ft.commit();
+                CPPUNIT_FAIL("Exception expected");
+        } catch (MyMoneyException *e) {
+                delete e;
+        }
+}
+
+void MyMoneyFileTest::testAddPayee() {
+        MyMoneyPayee p;
+
+        p.setName("THB");
+        CPPUNIT_ASSERT(m->dirty() == false);
+        MyMoneyFileTransaction ft;
+        try {
+                m->addPayee(p);
+                ft.commit();
+                CPPUNIT_ASSERT(m->dirty() == true);
+                CPPUNIT_ASSERT(p.id() == "P000001");
+
+        } catch (MyMoneyException *e) {
+                delete e;
+                CPPUNIT_FAIL("Unexpected exception");
+        }
+}
+
+void MyMoneyFileTest::testModifyPayee() {
+        MyMoneyPayee p;
+
+        testAddPayee();
+
+        p = m->payee("P000001");
+        p.setName("New name");
+        MyMoneyFileTransaction ft;
+        try {
+                m->modifyPayee(p);
+                ft.commit();
+                p = m->payee("P000001");
+                CPPUNIT_ASSERT(p.name() == "New name");
+
+        } catch (MyMoneyException *e) {
+                delete e;
+                CPPUNIT_FAIL("Unexpected exception");
+        }
+}
+
+void MyMoneyFileTest::testRemovePayee() {
+        MyMoneyPayee p;
+
+        testAddPayee();
+        CPPUNIT_ASSERT(m->payeeList().count() == 1);
+
+        p = m->payee("P000001");
+        MyMoneyFileTransaction ft;
+        try {
+                m->removePayee(p);
+                ft.commit();
+                CPPUNIT_ASSERT(m->payeeList().count() == 0);
+
+        } catch (MyMoneyException *e) {
+                delete e;
+                CPPUNIT_FAIL("Unexpected exception");
+        }
+}
+
+void MyMoneyFileTest::testAddTransactionStd() {
+        testAddAccounts();
+        MyMoneyTransaction t, p;
+        MyMoneyAccount a;
+
+        a = m->account("A000001");
+
+        // construct a transaction and add it to the pool
+        t.setPostDate(QDate(2002,2,1));
+        t.setMemo("Memotext");
+
+        MyMoneySplit split1;
+        MyMoneySplit split2;
+
+        split1.setAccountId("A000001");
+        split1.setShares(-1000);
+        split1.setValue(-1000);
+        split2.setAccountId(STD_ACC_EXPENSE);
+        split2.setValue(1000);
+        split2.setShares(1000);
+        try {
+                t.addSplit(split1);
+                t.addSplit(split2);
+        } catch(MyMoneyException *e) {
+                delete e;
+                CPPUNIT_FAIL("Unexpected exception!");
+        }
+
+/*
+        // FIXME: we don't have a payee and a number field right now
+        // guess we should have a number field per split, don't know
+        // about the payee
+        t.setMethod(MyMoneyCheckingTransaction::Withdrawal);
+        t.setPayee("Thomas Baumgart");
+        t.setNumber("1234");
+        t.setState(MyMoneyCheckingTransaction::Cleared);
+*/
+        storage->m_dirty = false;
+
+        MyMoneyFileTransaction ft;
+        try {
+                m->addTransaction(t);
+                ft.commit();
+                CPPUNIT_FAIL("Missing expected exception!");
+        } catch(MyMoneyException *e) {
+                delete e;
+        }
+
+        CPPUNIT_ASSERT(m->dirty() == false);
+}
+
+void MyMoneyFileTest::testAttachStorage() {
+        IMyMoneyStorage *store = new MyMoneySeqAccessMgr;
+        MyMoneyFile *file = new MyMoneyFile;
+
+        CPPUNIT_ASSERT(file->storageAttached() == false);
+        try {
+                file->attachStorage(store);
+                CPPUNIT_ASSERT(file->storageAttached() == true);
+        } catch(MyMoneyException *e) {
+                delete e;
+                CPPUNIT_FAIL("Unexpected exception!");
+        }
+
+        try {
+                file->attachStorage(store);
+                CPPUNIT_FAIL("Exception expected!");
+        } catch(MyMoneyException *e) {
+                delete e;
+        }
+
+        try {
+                file->attachStorage(0);
+                CPPUNIT_FAIL("Exception expected!");
+        } catch(MyMoneyException *e) {
+                delete e;
+        }
+
+        try {
+                file->detachStorage(store);
+                CPPUNIT_ASSERT(file->storageAttached() == false);
+        } catch(MyMoneyException *e) {
+                delete e;
+                CPPUNIT_FAIL("Unexpected exception!");
+        }
+
+        delete store;
+        delete file;
+}
+
+
+void MyMoneyFileTest::testAccount2Category() {
+        testReparentAccount();
+        CPPUNIT_ASSERT(m->accountToCategory("A000001") == "Account2:Account1");
+        CPPUNIT_ASSERT(m->accountToCategory("A000002") == "Account2");
+}
+
+void MyMoneyFileTest::testCategory2Account() {
+        testAddTransaction();
+        MyMoneyAccount a = m->account("A000003");
+        MyMoneyAccount b = m->account("A000004");
+
+        MyMoneyFileTransaction ft;
+        try {
+                m->reparentAccount(b, a);
+                ft.commit();
+                CPPUNIT_ASSERT(m->categoryToAccount("Expense1") == "A000003");
+                CPPUNIT_ASSERT(m->categoryToAccount("Expense1:Expense2") == "A000004");
+                CPPUNIT_ASSERT(m->categoryToAccount("Acc2").isEmpty());
+        } catch(MyMoneyException *e) {
+                unexpectedException(e);
+        }
+}
+
+void MyMoneyFileTest::testAttachedStorage() {
+        CPPUNIT_ASSERT(m->storageAttached() == true);
+        CPPUNIT_ASSERT(m->storage() != 0);
+        IMyMoneyStorage *p = m->storage();
+        m->detachStorage(p);
+        CPPUNIT_ASSERT(m->storageAttached() == false);
+        CPPUNIT_ASSERT(m->storage() == 0);
+        m->attachStorage(p);
+        CPPUNIT_ASSERT(m->storageAttached() == true);
+        CPPUNIT_ASSERT(m->storage() != 0);
+}
+
+void MyMoneyFileTest::testHasAccount() {
+        testAddAccounts();
+
+        MyMoneyAccount a, b;
+        a.setAccountType(MyMoneyAccount::Checkings);
+        a.setName("Account3");
+        b = m->account("A000001");
+        MyMoneyFileTransaction ft;
+        try {
+                m->addAccount(a, b);
+                ft.commit();
+                CPPUNIT_ASSERT(m->accountCount() == 8);
+                CPPUNIT_ASSERT(a.parentAccountId() == "A000001");
+                CPPUNIT_ASSERT(m->hasAccount("A000001", "Account3") == true);
+                CPPUNIT_ASSERT(m->hasAccount("A000001", "Account2") == false);
+                CPPUNIT_ASSERT(m->hasAccount("A000002", "Account3") == false);
+        } catch(MyMoneyException *e) {
+                unexpectedException(e);
+        }
+}
+
+void MyMoneyFileTest::testAddEquityAccount() {
+        MyMoneyAccount i;
+        i.setName("Investment");
+        i.setAccountType(MyMoneyAccount::Investment);
+
+        MyMoneyFileTransaction ft;
+        try {
+                MyMoneyAccount parent = m->asset();
+                m->addAccount(i, parent);
+                ft.commit();
+        } catch(MyMoneyException *e) {
+                unexpectedException(e);
+        }
+        // keep a copy for later use
+        m_inv = i;
+
+        // make sure, that only equity accounts can be children to it
+        MyMoneyAccount a;
+        a.setName("Testaccount");
+        QValueList<MyMoneyAccount::accountTypeE> list;
+        list << MyMoneyAccount::Checkings;
+        list << MyMoneyAccount::Savings;
+        list << MyMoneyAccount::Cash;
+        list << MyMoneyAccount::CreditCard;
+        list << MyMoneyAccount::Loan;
+        list << MyMoneyAccount::CertificateDep;
+        list << MyMoneyAccount::Investment;
+        list << MyMoneyAccount::MoneyMarket;
+        list << MyMoneyAccount::Asset;
+        list << MyMoneyAccount::Liability;
+        list << MyMoneyAccount::Currency;
+        list << MyMoneyAccount::Income;
+        list << MyMoneyAccount::Expense;
+        list << MyMoneyAccount::AssetLoan;
+
+        QValueList<MyMoneyAccount::accountTypeE>::Iterator it;
+        for(it = list.begin(); it != list.end(); ++it) {
+                a.setAccountType(*it);
+                ft.restart();
+                try {
+                        char    msg[100];
+                        m->addAccount(a, i);
+                        sprintf(msg, "Can add non-equity type %d to investment", *it);
+                        CPPUNIT_FAIL(msg);
+                } catch(MyMoneyException *e) {
+                        ft.commit();
+                        delete e;
+                }
+        }
+        ft.restart();
+        try {
+                a.setName("Teststock");
+                a.setAccountType(MyMoneyAccount::Stock);
+                m->addAccount(a,i);
+                ft.commit();
+        } catch(MyMoneyException *e) {
+                unexpectedException(e);
+        }
+}
+
+void MyMoneyFileTest::testReparentEquity() {
+        testAddEquityAccount();
+        testAddEquityAccount();
+        MyMoneyAccount parent;
+
+        // check the bad cases
+        QValueList<MyMoneyAccount::accountTypeE> list;
+        list << MyMoneyAccount::Checkings;
+        list << MyMoneyAccount::Savings;
+        list << MyMoneyAccount::Cash;
+        list << MyMoneyAccount::CertificateDep;
+        list << MyMoneyAccount::MoneyMarket;
+        list << MyMoneyAccount::Asset;
+        list << MyMoneyAccount::AssetLoan;
+        list << MyMoneyAccount::Currency;
+        parent = m->asset();
+        testReparentEquity(list, parent);
+
+        list.clear();
+        list << MyMoneyAccount::CreditCard;
+        list << MyMoneyAccount::Loan;
+        list << MyMoneyAccount::Liability;
+        parent = m->liability();
+        testReparentEquity(list, parent);
+
+        list.clear();
+        list << MyMoneyAccount::Income;
+        parent = m->income();
+        testReparentEquity(list, parent);
+
+        list.clear();
+        list << MyMoneyAccount::Expense;
+        parent = m->expense();
+        testReparentEquity(list, parent);
+
+        // now check the good case
+        MyMoneyAccount stock = m->account("A000002");
+        MyMoneyAccount inv = m->account(m_inv.id());
+        MyMoneyFileTransaction ft;
+        try {
+                m->reparentAccount(stock, inv);
+                ft.commit();
+        } catch(MyMoneyException *e) {
+                unexpectedException(e);
+        }
+}
+
+void MyMoneyFileTest::testReparentEquity(QValueList<MyMoneyAccount::accountTypeE>& list, MyMoneyAccount& parent)
+{
+        MyMoneyAccount a;
+        MyMoneyAccount stock = m->account("A000002");
+
+        QValueList<MyMoneyAccount::accountTypeE>::Iterator it;
+        MyMoneyFileTransaction ft;
+        for(it = list.begin(); it != list.end(); ++it) {
+                a.setName(QString("Testaccount %1").arg(*it));
+                a.setAccountType(*it);
+                try {
+                        m->addAccount(a, parent);
+                        char    msg[100];
+                        m->reparentAccount(stock, a);
+                        sprintf(msg, "Can reparent stock to non-investment type %d account", *it);
+                        CPPUNIT_FAIL(msg);
+                } catch(MyMoneyException *e) {
+                        ft.commit();
+                        delete e;
+                }
+                ft.restart();
+        }
+}
+
+void MyMoneyFileTest::testBaseCurrency(void)
+{
+        MyMoneySecurity base("EUR", "Euro", QChar(0x20ac));
+        MyMoneySecurity ref;
+
+        // make sure, no base currency is set
+        try {
+                ref = m->baseCurrency();
+                CPPUNIT_ASSERT(ref.id().isEmpty());
+        } catch(MyMoneyException *e) {
+                unexpectedException(e);
+        }
+
+        // make sure, we cannot assign an unknown currency
+        try {
+                m->setBaseCurrency(base);
+                CPPUNIT_FAIL("Missing expected exception");
+        } catch(MyMoneyException *e) {
+                delete e;
+        }
+
+        MyMoneyFileTransaction ft;
+        // add the currency and try again
+        try {
+                m->addCurrency(base);
+                m->setBaseCurrency(base);
+                ft.commit();
+        } catch(MyMoneyException *e) {
+                unexpectedException(e);
+        }
+        ft.restart();
+
+        // make sure, the base currency is set
+        try {
+                ref = m->baseCurrency();
+                CPPUNIT_ASSERT(ref.id() == "EUR");
+                CPPUNIT_ASSERT(ref.name() == "Euro");
+                CPPUNIT_ASSERT(ref.tradingSymbol() == QChar(0x20ac));
+        } catch(MyMoneyException *e) {
+                unexpectedException(e);
+        }
+
+        // check if it gets reset when attaching a new storage
+        m->detachStorage(storage);
+
+        MyMoneySeqAccessMgr* newStorage = new MyMoneySeqAccessMgr;
+        m->attachStorage(newStorage);
+
+        ref = m->baseCurrency();
+        CPPUNIT_ASSERT(ref.id().isEmpty());
+
+        m->detachStorage(newStorage);
+        delete newStorage;
+
+        m->attachStorage(storage);
+        ref = m->baseCurrency();
+        CPPUNIT_ASSERT(ref.id() == "EUR");
+        CPPUNIT_ASSERT(ref.name() == "Euro");
+        CPPUNIT_ASSERT(ref.tradingSymbol() == QChar(0x20ac));
+}
+
+void MyMoneyFileTest::testOpeningBalanceNoBase(void)
+{
+        MyMoneyAccount openingAcc;
+        MyMoneySecurity base;
+
+        try {
+                base = m->baseCurrency();
+                openingAcc = m->openingBalanceAccount(base);
+                CPPUNIT_FAIL("Missing expected exception");
+        } catch(MyMoneyException *e) {
+                delete e;
+        }
+}
+
+void MyMoneyFileTest::testOpeningBalance(void)
+{
+        MyMoneyAccount openingAcc;
+        MyMoneySecurity second("USD", "US Dollar", "$");
+        testBaseCurrency();
+
+        try {
+                openingAcc = m->openingBalanceAccount(m->baseCurrency());
+                CPPUNIT_ASSERT(openingAcc.parentAccountId() == m->equity().id());
+                CPPUNIT_ASSERT(openingAcc.name() == MyMoneyFile::OpeningBalancesPrefix);
+                CPPUNIT_ASSERT(openingAcc.openingDate() == QDate::currentDate());
+        } catch(MyMoneyException *e) {
+                unexpectedException(e);
+        }
+
+        // add a second currency
+        MyMoneyFileTransaction ft;
+        try {
+                m->addCurrency(second);
+                ft.commit();
+        } catch(MyMoneyException *e) {
+                unexpectedException(e);
+        }
+
+        QString refName = QString("%1 (%2)").arg(MyMoneyFile::OpeningBalancesPrefix).arg("USD");
+        try {
+                openingAcc = m->openingBalanceAccount(second);
+                CPPUNIT_ASSERT(openingAcc.parentAccountId() == m->equity().id());
+                CPPUNIT_ASSERT(openingAcc.name() == refName);
+                CPPUNIT_ASSERT(openingAcc.openingDate() == QDate::currentDate());
+        } catch(MyMoneyException *e) {
+                unexpectedException(e);
+        }
+}
+
+void MyMoneyFileTest::testModifyStdAccount() {
+        CPPUNIT_ASSERT(m->asset().currencyId().isEmpty());
+        CPPUNIT_ASSERT(m->asset().name() == "Asset");
+        testBaseCurrency();
+        CPPUNIT_ASSERT(m->asset().currencyId().isEmpty());
+        CPPUNIT_ASSERT(!m->baseCurrency().id().isEmpty());
+
+        MyMoneyFileTransaction ft;
+        try {
+                MyMoneyAccount acc = m->asset();
+                acc.setName("Anlagen");
+                acc.setCurrencyId(m->baseCurrency().id());
+                m->modifyAccount(acc);
+                ft.commit();
+
+                CPPUNIT_ASSERT(m->asset().name() == "Anlagen");
+                CPPUNIT_ASSERT(m->asset().currencyId() == m->baseCurrency().id());
+        } catch(MyMoneyException *e) {
+                unexpectedException(e);
+        }
+
+        ft.restart();
+        try {
+                MyMoneyAccount acc = m->asset();
+                acc.setNumber("Test");
+                m->modifyAccount(acc);
+                CPPUNIT_FAIL("Missing expected exception");
+        } catch(MyMoneyException *e) {
+                ft.rollback();
+                delete e;
+        }
+
+}