summaryrefslogtreecommitdiffstats
path: root/kmymoney2/mymoney/mymoneyfiletest.cpp
diff options
context:
space:
mode:
authortpearson <tpearson@283d02a7-25f6-0310-bc7c-ecb5cbfe19da>2011-07-04 22:38:03 +0000
committertpearson <tpearson@283d02a7-25f6-0310-bc7c-ecb5cbfe19da>2011-07-04 22:38:03 +0000
commitdadc34655c3ab961b0b0b94a10eaaba710f0b5e8 (patch)
tree99e72842fe687baea16376a147619b6048d7e441 /kmymoney2/mymoney/mymoneyfiletest.cpp
downloadkmymoney-dadc34655c3ab961b0b0b94a10eaaba710f0b5e8.tar.gz
kmymoney-dadc34655c3ab961b0b0b94a10eaaba710f0b5e8.zip
Added kmymoney
git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/applications/kmymoney@1239792 283d02a7-25f6-0310-bc7c-ecb5cbfe19da
Diffstat (limited to 'kmymoney2/mymoney/mymoneyfiletest.cpp')
-rw-r--r--kmymoney2/mymoney/mymoneyfiletest.cpp1550
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;
+ }
+
+}