Added kmymoney

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

1 files changed, 1705 insertions, 0 deletions

diff --git a/kmymoney2/mymoney/storage/mymoneyseqaccessmgrtest.cpp b/kmymoney2/mymoney/storage/mymoneyseqaccessmgrtest.cpp
new file mode 100644
index 0000000..09bf791
--- /dev/null
+++ b/kmymoney2/mymoney/storage/mymoneyseqaccessmgrtest.cpp
@@ -0,0 +1,1705 @@
+/***************************************************************************
+                          mymoneyseqaccessmgrtest.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 "mymoneyseqaccessmgrtest.h"
+#include <iostream>
+
+MyMoneySeqAccessMgrTest::MyMoneySeqAccessMgrTest()
+{
+}
+
+
+void MyMoneySeqAccessMgrTest::setUp()
+{
+	m = new MyMoneySeqAccessMgr;
+	MyMoneyFile* file = MyMoneyFile::instance();
+	file->attachStorage(m);
+	m->startTransaction();
+}
+
+void MyMoneySeqAccessMgrTest::tearDown()
+{
+	m->commitTransaction();
+	MyMoneyFile* file = MyMoneyFile::instance();
+	file->detachStorage(m);
+	delete m;
+}
+
+void MyMoneySeqAccessMgrTest::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->m_nextInstitutionID == 0);
+	CPPUNIT_ASSERT(m->m_nextAccountID == 0);
+	CPPUNIT_ASSERT(m->m_nextTransactionID == 0);
+	CPPUNIT_ASSERT(m->m_nextPayeeID == 0);
+	CPPUNIT_ASSERT(m->m_nextScheduleID == 0);
+	CPPUNIT_ASSERT(m->m_nextReportID == 0);
+	CPPUNIT_ASSERT(m->m_institutionList.count() == 0);
+	CPPUNIT_ASSERT(m->m_accountList.count() == 5);
+	CPPUNIT_ASSERT(m->m_transactionList.count() == 0);
+	CPPUNIT_ASSERT(m->m_transactionKeys.count() == 0);
+	CPPUNIT_ASSERT(m->m_payeeList.count() == 0);
+	CPPUNIT_ASSERT(m->m_scheduleList.count() == 0);
+
+	CPPUNIT_ASSERT(m->m_dirty == false);
+	CPPUNIT_ASSERT(m->m_creationDate == QDate::currentDate());
+
+	CPPUNIT_ASSERT(m->liability().name() == "Liability");
+	CPPUNIT_ASSERT(m->asset().name() == "Asset");
+	CPPUNIT_ASSERT(m->expense().name() == "Expense");
+	CPPUNIT_ASSERT(m->income().name() == "Income");
+	CPPUNIT_ASSERT(m->equity().name() == "Equity");
+}
+
+void MyMoneySeqAccessMgrTest::testSetFunctions() {
+	MyMoneyPayee user = m->user();
+
+	m->m_dirty = false;
+	user.setName("Name");
+	m->setUser(user);
+	m->commitTransaction();
+	m->startTransaction();
+	CPPUNIT_ASSERT(m->dirty() == true);
+	m->m_dirty = false;
+	user.setAddress("Street");
+	m->setUser(user);
+	m->commitTransaction();
+	m->startTransaction();
+	CPPUNIT_ASSERT(m->dirty() == true);
+	m->m_dirty = false;
+	user.setCity("Town");
+	m->setUser(user);
+	m->commitTransaction();
+	m->startTransaction();
+	CPPUNIT_ASSERT(m->dirty() == true);
+	m->m_dirty = false;
+	user.setState("County");
+	m->setUser(user);
+	m->commitTransaction();
+	m->startTransaction();
+	CPPUNIT_ASSERT(m->dirty() == true);
+	m->m_dirty = false;
+	user.setPostcode("Postcode");
+	m->setUser(user);
+	m->commitTransaction();
+	m->startTransaction();
+	CPPUNIT_ASSERT(m->dirty() == true);
+	m->m_dirty = false;
+	user.setTelephone("Telephone");
+	m->setUser(user);
+	m->commitTransaction();
+	m->startTransaction();
+	CPPUNIT_ASSERT(m->dirty() == true);
+	m->m_dirty = false;
+	user.setEmail("Email");
+	m->setUser(user);
+	m->commitTransaction();
+	m->startTransaction();
+	CPPUNIT_ASSERT(m->dirty() == true);
+	m->m_dirty = false;
+	m->setValue("key", "value");
+	m->commitTransaction();
+	m->startTransaction();
+	CPPUNIT_ASSERT(m->dirty() == true);
+
+	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");
+	CPPUNIT_ASSERT(m->value("key") == "value");
+
+	m->m_dirty = false;
+	m->deletePair("key");
+	m->commitTransaction();
+	m->startTransaction();
+	CPPUNIT_ASSERT(m->dirty() == true);
+}
+
+void MyMoneySeqAccessMgrTest::testSupportFunctions()
+{
+	CPPUNIT_ASSERT(m->nextInstitutionID() == "I000001");
+	CPPUNIT_ASSERT(m->m_nextInstitutionID == 1);
+	CPPUNIT_ASSERT(m->nextAccountID() == "A000001");
+	CPPUNIT_ASSERT(m->m_nextAccountID == 1);
+	CPPUNIT_ASSERT(m->nextTransactionID() == "T000000000000000001");
+	CPPUNIT_ASSERT(m->m_nextTransactionID == 1);
+	CPPUNIT_ASSERT(m->nextPayeeID() == "P000001");
+	CPPUNIT_ASSERT(m->m_nextPayeeID == 1);
+	CPPUNIT_ASSERT(m->nextScheduleID() == "SCH000001");
+	CPPUNIT_ASSERT(m->m_nextScheduleID == 1);
+	CPPUNIT_ASSERT(m->nextReportID() == "R000001");
+	CPPUNIT_ASSERT(m->m_nextReportID == 1);
+}
+
+void MyMoneySeqAccessMgrTest::testIsStandardAccount()
+{
+	CPPUNIT_ASSERT(m->isStandardAccount(STD_ACC_LIABILITY) == true);
+	CPPUNIT_ASSERT(m->isStandardAccount(STD_ACC_ASSET) == true);
+	CPPUNIT_ASSERT(m->isStandardAccount(STD_ACC_EXPENSE) == true);
+	CPPUNIT_ASSERT(m->isStandardAccount(STD_ACC_INCOME) == true);
+	CPPUNIT_ASSERT(m->isStandardAccount("A0002") == false);
+}
+
+void MyMoneySeqAccessMgrTest::testNewAccount() {
+	MyMoneyAccount a;
+
+	a.setName("AccountName");
+	a.setNumber("AccountNumber");
+
+	m->addAccount(a);
+	m->commitTransaction();
+	m->startTransaction();
+
+	CPPUNIT_ASSERT(m->m_nextAccountID == 1);
+	CPPUNIT_ASSERT(m->dirty() == true);
+	CPPUNIT_ASSERT(m->m_accountList.count() == 6);
+	CPPUNIT_ASSERT(m->m_accountList["A000001"].name() == "AccountName");
+}
+
+void MyMoneySeqAccessMgrTest::testAccount() {
+	testNewAccount();
+	m->m_dirty = false;
+
+	MyMoneyAccount a;
+
+	// make sure that an invalid ID causes an exception
+	try {
+		a = m->account("Unknown ID");
+		CPPUNIT_FAIL("Exception expected");
+	} catch (MyMoneyException *e) {
+		delete e;
+	}
+	m->commitTransaction();
+	m->startTransaction();
+	CPPUNIT_ASSERT(m->dirty() == false);
+
+	// now make sure, that a real ID works
+	try {
+		a = m->account("A000001");
+		m->commitTransaction();
+		m->startTransaction();
+		CPPUNIT_ASSERT(a.name() == "AccountName");
+		CPPUNIT_ASSERT(a.id() == "A000001");
+		CPPUNIT_ASSERT(m->dirty() == true);
+	} catch (MyMoneyException *e) {
+		delete e;
+		CPPUNIT_FAIL("Unexpected exception");
+	}
+}
+
+void MyMoneySeqAccessMgrTest::testAddNewAccount() {
+	testNewAccount();
+
+	MyMoneyAccount a,b;
+	b.setName("Account2");
+	b.setNumber("Acc2");
+	m->addAccount(b);
+	m->commitTransaction();
+	m->startTransaction();
+
+	m->m_dirty = false;
+
+	CPPUNIT_ASSERT(m->m_nextAccountID == 2);
+	CPPUNIT_ASSERT(m->m_accountList.count() == 7);
+
+	// try to add account to undefined account
+	try {
+		MyMoneyAccount c("UnknownID", b);
+		m->addAccount(c, a);
+		CPPUNIT_FAIL("Exception expected");
+	} catch (MyMoneyException *e) {
+		delete e;
+	}
+	m->commitTransaction();
+	m->startTransaction();
+
+	CPPUNIT_ASSERT(m->dirty() == false);
+	// now try to add account 1 as sub-account to account 2
+	a = m->account("A000001");
+	try {
+		CPPUNIT_ASSERT(m->m_accountList[STD_ACC_ASSET].accountList().count() == 0);
+		m->addAccount(b, a);
+		m->commitTransaction();
+		m->startTransaction();
+		CPPUNIT_ASSERT(m->m_accountList["A000002"].accountList()[0] == "A000001");
+		CPPUNIT_ASSERT(m->m_accountList["A000002"].accountList().count() == 1);
+		CPPUNIT_ASSERT(m->m_accountList[STD_ACC_ASSET].accountList().count() == 0);
+		CPPUNIT_ASSERT(m->dirty() == true);
+	} catch (MyMoneyException *e) {
+		delete e;
+		CPPUNIT_FAIL("Unexpected exception");
+	}
+}
+
+void MyMoneySeqAccessMgrTest::testAddInstitution() {
+	MyMoneyInstitution i;
+
+	i.setName("Inst Name");
+
+	m->addInstitution(i);
+	CPPUNIT_ASSERT(m->m_institutionList.count() == 1);
+	CPPUNIT_ASSERT(m->m_nextInstitutionID == 1);
+	CPPUNIT_ASSERT(m->m_institutionList["I000001"].name() == "Inst Name");
+}
+
+void MyMoneySeqAccessMgrTest::testInstitution() {
+	testAddInstitution();
+	MyMoneyInstitution i;
+
+	m->m_dirty = false;
+
+	// try to find unknown institution
+	try {
+		i = m->institution("Unknown ID");
+		CPPUNIT_FAIL("Exception expected");
+	} catch (MyMoneyException *e) {
+		delete e;
+	}
+
+	CPPUNIT_ASSERT(m->dirty() == false);
+
+	// now try to find real institution
+	try {
+		i = m->institution("I000001");
+		CPPUNIT_ASSERT(i.name() == "Inst Name");
+		CPPUNIT_ASSERT(m->dirty() == false);
+	} catch (MyMoneyException *e) {
+		delete e;
+		CPPUNIT_FAIL("Unexpected exception");
+	}
+}
+
+void MyMoneySeqAccessMgrTest::testAccount2Institution() {
+	testAddInstitution();
+	testAddNewAccount();
+
+	MyMoneyInstitution i;
+	MyMoneyAccount a, b;
+
+	try {
+		i = m->institution("I000001");
+		a = m->account("A000001");
+	} catch (MyMoneyException *e) {
+		delete e;
+		CPPUNIT_FAIL("Unexpected exception");
+	}
+
+	m->m_dirty = false;
+
+	// try to add to a false institution
+	MyMoneyInstitution fake("Unknown ID", i);
+	a.setInstitutionId(fake.id());
+	try {
+		m->modifyAccount(a);
+		CPPUNIT_FAIL("Exception expected");
+	} catch (MyMoneyException *e) {
+		delete e;
+	}
+	m->commitTransaction();
+	m->startTransaction();
+
+	CPPUNIT_ASSERT(m->dirty() == false);
+	// now try to do it with a real institution
+	try {
+		CPPUNIT_ASSERT(i.accountList().count() == 0);
+		a.setInstitutionId(i.id());
+		m->modifyAccount(a);
+		m->commitTransaction();
+		m->startTransaction();
+		CPPUNIT_ASSERT(m->dirty() == true);
+		CPPUNIT_ASSERT(a.institutionId() == i.id());
+		b = m->account("A000001");
+		CPPUNIT_ASSERT(b.institutionId() == i.id());
+		CPPUNIT_ASSERT(i.accountList().count() == 0);
+	} catch (MyMoneyException *e) {
+		delete e;
+		CPPUNIT_FAIL("Unexpected exception");
+	}
+}
+
+void MyMoneySeqAccessMgrTest::testModifyAccount() {
+	testAccount2Institution();
+
+	// test the OK case
+	MyMoneyAccount a = m->account("A000001");
+	a.setName("New account name");
+	m->m_dirty = false;
+	try {
+		m->modifyAccount(a);
+		m->commitTransaction();
+		m->startTransaction();
+		MyMoneyAccount b = m->account("A000001");
+		CPPUNIT_ASSERT(b.parentAccountId() == a.parentAccountId());
+		CPPUNIT_ASSERT(b.name() == "New account name");
+		CPPUNIT_ASSERT(m->dirty() == true);
+	} catch (MyMoneyException *e) {
+		delete e;
+		CPPUNIT_FAIL("Unexpected exception");
+	}
+
+	// modify institution to unknown id
+	MyMoneyAccount c("Unknown ID", a);
+	m->m_dirty = false;
+	try {
+		m->modifyAccount(c);
+		CPPUNIT_FAIL("Exception expected");
+	} catch (MyMoneyException *e) {
+		delete e;
+	}
+
+	// use different account type
+	MyMoneyAccount d;
+	d.setAccountType(MyMoneyAccount::CreditCard);
+	MyMoneyAccount f("A000001", d);
+	try {
+		m->modifyAccount(f);
+		CPPUNIT_FAIL("Exception expected");
+	} catch (MyMoneyException *e) {
+		delete e;
+	}
+
+	// use different parent
+	a.setParentAccountId("A000002");
+	try {
+		m->modifyAccount(c);
+		CPPUNIT_FAIL("Exception expected");
+	} catch (MyMoneyException *e) {
+		delete e;
+	}
+}
+
+void MyMoneySeqAccessMgrTest::testModifyInstitution() {
+	testAddInstitution();
+	MyMoneyInstitution i = m->institution("I000001");
+
+	m->m_dirty = false;
+	i.setName("New inst name");
+	try {
+		m->modifyInstitution(i);
+		m->commitTransaction();
+		m->startTransaction();
+		CPPUNIT_ASSERT(m->dirty() == true);
+		i = m->institution("I000001");
+		CPPUNIT_ASSERT(i.name() == "New inst name");
+
+	} catch (MyMoneyException *e) {
+		delete e;
+		CPPUNIT_FAIL("Unexpected exception");
+	}
+
+	// try to modify an institution that does not exist
+	MyMoneyInstitution f("Unknown ID", i);
+	try {
+		m->modifyInstitution(f);
+		CPPUNIT_FAIL("Exception expected");
+	} catch (MyMoneyException *e) {
+		delete e;
+	}
+}
+
+void MyMoneySeqAccessMgrTest::testReparentAccount() {
+	// this one adds some accounts to the database
+	MyMoneyAccount ex1;
+	ex1.setAccountType(MyMoneyAccount::Expense);
+	MyMoneyAccount ex2;
+	ex2.setAccountType(MyMoneyAccount::Expense);
+	MyMoneyAccount ex3;
+	ex3.setAccountType(MyMoneyAccount::Expense);
+	MyMoneyAccount ex4;
+	ex4.setAccountType(MyMoneyAccount::Expense);
+	MyMoneyAccount in;
+	in.setAccountType(MyMoneyAccount::Income);
+	MyMoneyAccount ch;
+	ch.setAccountType(MyMoneyAccount::Checkings);
+
+	ex1.setName("Sales Tax");
+	ex2.setName("Sales Tax 16%");
+	ex3.setName("Sales Tax 7%");
+	ex4.setName("Grosseries");
+
+	in.setName("Salary");
+	ch.setName("My checkings account");
+
+	try {
+		m->addAccount(ex1);
+		m->addAccount(ex2);
+		m->addAccount(ex3);
+		m->addAccount(ex4);
+		m->addAccount(in);
+		m->addAccount(ch);
+
+		CPPUNIT_ASSERT(ex1.id() == "A000001");
+		CPPUNIT_ASSERT(ex2.id() == "A000002");
+		CPPUNIT_ASSERT(ex3.id() == "A000003");
+		CPPUNIT_ASSERT(ex4.id() == "A000004");
+		CPPUNIT_ASSERT(in.id() == "A000005");
+		CPPUNIT_ASSERT(ch.id() == "A000006");
+
+		MyMoneyAccount parent = m->expense();
+
+		m->addAccount(parent, ex1);
+		m->addAccount(ex1, ex2);
+		m->addAccount(parent, ex3);
+		m->addAccount(parent, ex4);
+
+		parent = m->income();
+		m->addAccount(parent, in);
+
+		parent = m->asset();
+		m->addAccount(parent, ch);
+
+		CPPUNIT_ASSERT(m->expense().accountCount() == 3);
+		CPPUNIT_ASSERT(m->account(ex1.id()).accountCount() == 1);
+		CPPUNIT_ASSERT(ex3.parentAccountId() == STD_ACC_EXPENSE);
+
+		m->reparentAccount(ex3, ex1);
+		CPPUNIT_ASSERT(m->expense().accountCount() == 2);
+		CPPUNIT_ASSERT(m->account(ex1.id()).accountCount() == 2);
+		CPPUNIT_ASSERT(ex3.parentAccountId() == ex1.id());
+	} catch (MyMoneyException *e) {
+		std::cout << std::endl << e->what() << std::endl;
+		delete e;
+		CPPUNIT_FAIL("Unexpected exception");
+	}
+}
+
+void MyMoneySeqAccessMgrTest::testAddTransactions() {
+	testReparentAccount();
+
+	MyMoneyAccount ch;
+	MyMoneyTransaction t1, t2;
+	MyMoneySplit s;
+
+	try {
+		// I made some money, great
+		s.setAccountId("A000006");	// Checkings
+		s.setShares(100000);
+		s.setValue(100000);
+		CPPUNIT_ASSERT(s.id().isEmpty());
+		t1.addSplit(s);
+
+		s.setId(QString());	// enable re-usage of split variable
+		s.setAccountId("A000005");	// Salary
+		s.setShares(-100000);
+		s.setValue(-100000);
+		CPPUNIT_ASSERT(s.id().isEmpty());
+		t1.addSplit(s);
+
+		t1.setPostDate(QDate(2002,5,10));
+	} catch (MyMoneyException *e) {
+		unexpectedException(e);
+	}
+
+	m->m_dirty = false;
+	try {
+		m->addTransaction(t1);
+		m->commitTransaction();
+		m->startTransaction();
+		CPPUNIT_ASSERT(m->dirty() == true);
+		CPPUNIT_ASSERT(t1.id() == "T000000000000000001");
+		CPPUNIT_ASSERT(t1.splitCount() == 2);
+		CPPUNIT_ASSERT(m->transactionCount() == 1);
+	} catch (MyMoneyException *e) {
+		unexpectedException(e);
+	}
+
+	try {
+		// I spent some money, not so great
+		s.setId(QString());	// enable re-usage of split variable
+		s.setAccountId("A000004");	// Grosseries
+		s.setShares(10000);
+		s.setValue(10000);
+		CPPUNIT_ASSERT(s.id().isEmpty());
+		t2.addSplit(s);
+
+		s.setId(QString());	// enable re-usage of split variable
+		s.setAccountId("A000002");	// 16% sales tax
+		s.setShares(1200);
+		s.setValue(1200);
+		CPPUNIT_ASSERT(s.id().isEmpty());
+		t2.addSplit(s);
+
+		s.setId(QString());	// enable re-usage of split variable
+		s.setAccountId("A000003");	// 7% sales tax
+		s.setShares(400);
+		s.setValue(400);
+		CPPUNIT_ASSERT(s.id().isEmpty());
+		t2.addSplit(s);
+
+		s.setId(QString());	// enable re-usage of split variable
+		s.setAccountId("A000006");	// Checkings account
+		s.setShares(-11600);
+		s.setValue(-11600);
+		CPPUNIT_ASSERT(s.id().isEmpty());
+		t2.addSplit(s);
+
+		t2.setPostDate(QDate(2002,5,9));
+	} catch (MyMoneyException *e) {
+		unexpectedException(e);
+	}
+	m->m_dirty = false;
+	try {
+		m->addTransaction(t2);
+		m->commitTransaction();
+		m->startTransaction();
+		CPPUNIT_ASSERT(m->dirty() == true);
+		CPPUNIT_ASSERT(t2.id() == "T000000000000000002");
+		CPPUNIT_ASSERT(t2.splitCount() == 4);
+		CPPUNIT_ASSERT(m->transactionCount() == 2);
+
+		QMap<QString, QString>::ConstIterator it_k;
+		QMap<QString, MyMoneyTransaction>::ConstIterator it_t;
+		it_k = m->m_transactionKeys.begin();
+		it_t = m->m_transactionList.begin();
+
+		CPPUNIT_ASSERT((*it_k) == "2002-05-10-T000000000000000001");
+		CPPUNIT_ASSERT((*it_t).id() == "T000000000000000002");
+		++it_k;
+		++it_t;
+		CPPUNIT_ASSERT((*it_k) == "2002-05-09-T000000000000000002");
+		CPPUNIT_ASSERT((*it_t).id() == "T000000000000000001");
+		++it_k;
+		++it_t;
+		CPPUNIT_ASSERT(it_k == m->m_transactionKeys.end());
+		CPPUNIT_ASSERT(it_t == m->m_transactionList.end());
+
+		ch = m->account("A000006");
+
+		// check that the account's transaction list is updated
+		QValueList<MyMoneyTransaction> list;
+		MyMoneyTransactionFilter filter("A000006");
+		list = m->transactionList(filter);
+		CPPUNIT_ASSERT(list.size() == 2);
+
+		QValueList<MyMoneyTransaction>::ConstIterator it;
+		it = list.begin();
+		CPPUNIT_ASSERT((*it).id() == "T000000000000000002");
+		++it;
+		CPPUNIT_ASSERT((*it).id() == "T000000000000000001");
+		++it;
+		CPPUNIT_ASSERT(it == list.end());
+
+/* removed with MyMoneyAccount::Transaction
+		CPPUNIT_ASSERT(ch.transactionCount() == 2);
+
+		QValueList<MyMoneyAccount::Transaction>::ConstIterator it_l;
+		it_l = ch.transactionList().begin();
+		CPPUNIT_ASSERT((*it_l).transactionID() == "T000000000000000002");
+		CPPUNIT_ASSERT((*it_l).balance() == -11600);
+		++it_l;
+
+		CPPUNIT_ASSERT((*it_l).transactionID() == "T000000000000000001");
+		CPPUNIT_ASSERT((*it_l).balance() == -11600+100000);
+
+		++it_l;
+		CPPUNIT_ASSERT(it_l == ch.transactionList().end());
+*/
+
+	} catch (MyMoneyException *e) {
+		unexpectedException(e);
+	}
+}
+
+void MyMoneySeqAccessMgrTest::testTransactionCount() {
+	testAddTransactions();
+	CPPUNIT_ASSERT(m->transactionCount("A000001") == 0);
+	CPPUNIT_ASSERT(m->transactionCount("A000002") == 1);
+	CPPUNIT_ASSERT(m->transactionCount("A000003") == 1);
+	CPPUNIT_ASSERT(m->transactionCount("A000004") == 1);
+	CPPUNIT_ASSERT(m->transactionCount("A000005") == 1);
+	CPPUNIT_ASSERT(m->transactionCount("A000006") == 2);
+}
+
+void MyMoneySeqAccessMgrTest::testBalance() {
+	testAddTransactions();
+
+	CPPUNIT_ASSERT(m->balance("A000001").isZero());
+	CPPUNIT_ASSERT(m->balance("A000002") == MyMoneyMoney(1200));
+	CPPUNIT_ASSERT(m->balance("A000003") == MyMoneyMoney(400));
+	CPPUNIT_ASSERT(m->totalBalance("A000001") == MyMoneyMoney(1600));
+	CPPUNIT_ASSERT(m->balance("A000006", QDate(2002,5,9)) == MyMoneyMoney(-11600));
+	CPPUNIT_ASSERT(m->balance("A000005", QDate(2002,5,10)) == MyMoneyMoney(-100000));
+	CPPUNIT_ASSERT(m->balance("A000006", QDate(2002,5,10)) == MyMoneyMoney(88400));
+}
+
+void MyMoneySeqAccessMgrTest::testModifyTransaction() {
+	testAddTransactions();
+
+	MyMoneyTransaction t = m->transaction("T000000000000000002");
+	MyMoneySplit s;
+	MyMoneyAccount ch;
+
+	// just modify simple stuff (splits)
+	CPPUNIT_ASSERT(t.splitCount() == 4);
+
+	s = t.splits()[0];
+	s.setShares(11000);
+	s.setValue(11000);
+	t.modifySplit(s);
+
+	CPPUNIT_ASSERT(t.splitCount() == 4);
+	s = t.splits()[3];
+	s.setShares(-12600);
+	s.setValue(-12600);
+	t.modifySplit(s);
+
+	try {
+		CPPUNIT_ASSERT(m->balance("A000004") == MyMoneyMoney(10000));
+		CPPUNIT_ASSERT(m->balance("A000006") == MyMoneyMoney(100000-11600));
+		CPPUNIT_ASSERT(m->totalBalance("A000001") == MyMoneyMoney(1600));
+		m->modifyTransaction(t);
+		CPPUNIT_ASSERT(m->balance("A000004") == MyMoneyMoney(11000));
+		CPPUNIT_ASSERT(m->balance("A000006") == MyMoneyMoney(100000-12600));
+		CPPUNIT_ASSERT(m->totalBalance("A000001") == MyMoneyMoney(1600));
+	} catch (MyMoneyException *e) {
+		delete e;
+		CPPUNIT_FAIL("Unexpected exception");
+	}
+
+	// now modify the date
+	t.setPostDate(QDate(2002,5,11));
+	try {
+		m->modifyTransaction(t);
+		CPPUNIT_ASSERT(m->balance("A000004") == MyMoneyMoney(11000));
+		CPPUNIT_ASSERT(m->balance("A000006") == MyMoneyMoney(100000-12600));
+		CPPUNIT_ASSERT(m->totalBalance("A000001") == MyMoneyMoney(1600));
+
+		QMap<QString, QString>::ConstIterator it_k;
+		QMap<QString, MyMoneyTransaction>::ConstIterator it_t;
+		it_k = m->m_transactionKeys.begin();
+		it_t = m->m_transactionList.begin();
+		CPPUNIT_ASSERT((*it_k) == "2002-05-10-T000000000000000001");
+		CPPUNIT_ASSERT((*it_t).id() == "T000000000000000001");
+		++it_k;
+		++it_t;
+		CPPUNIT_ASSERT((*it_k) == "2002-05-11-T000000000000000002");
+		CPPUNIT_ASSERT((*it_t).id() == "T000000000000000002");
+		++it_k;
+		++it_t;
+		CPPUNIT_ASSERT(it_k == m->m_transactionKeys.end());
+		CPPUNIT_ASSERT(it_t == m->m_transactionList.end());
+
+		ch = m->account("A000006");
+
+		// check that the account's transaction list is updated
+		QValueList<MyMoneyTransaction> list;
+		MyMoneyTransactionFilter filter("A000006");
+		list = m->transactionList(filter);
+		CPPUNIT_ASSERT(list.size() == 2);
+
+		QValueList<MyMoneyTransaction>::ConstIterator it;
+		it = list.begin();
+		CPPUNIT_ASSERT((*it).id() == "T000000000000000001");
+		++it;
+		CPPUNIT_ASSERT((*it).id() == "T000000000000000002");
+		++it;
+		CPPUNIT_ASSERT(it == list.end());
+
+/* removed with MyMoneyAccount::Transaction
+		// CPPUNIT_ASSERT(ch.transactionCount() == 2);
+
+		QValueList<MyMoneyAccount::Transaction>::ConstIterator it_l;
+		it_l = ch.transactionList().begin();
+		CPPUNIT_ASSERT((*it_l).transactionID() == "T000000000000000001");
+		CPPUNIT_ASSERT((*it_l).balance() == 100000);
+		++it_l;
+
+		CPPUNIT_ASSERT((*it_l).transactionID() == "T000000000000000002");
+		CPPUNIT_ASSERT((*it_l).balance() == -12600+100000);
+
+		++it_l;
+		CPPUNIT_ASSERT(it_l == ch.transactionList().end());
+*/
+	} catch (MyMoneyException *e) {
+		delete e;
+		CPPUNIT_FAIL("Unexpected exception");
+	}
+}
+
+
+void MyMoneySeqAccessMgrTest::testRemoveUnusedAccount() {
+	testAccount2Institution();
+
+	MyMoneyAccount a = m->account("A000001");
+	MyMoneyInstitution i = m->institution("I000001");
+
+	m->m_dirty = false;
+	// make sure, we cannot remove the standard account groups
+	try {
+		m->removeAccount(m->liability());
+		CPPUNIT_FAIL("Exception expected");
+	} catch (MyMoneyException *e) {
+		delete e;
+	}
+
+	try {
+		m->removeAccount(m->asset());
+		CPPUNIT_FAIL("Exception expected");
+	} catch (MyMoneyException *e) {
+		delete e;
+	}
+
+	try {
+		m->removeAccount(m->expense());
+		CPPUNIT_FAIL("Exception expected");
+	} catch (MyMoneyException *e) {
+		delete e;
+	}
+
+	try {
+		m->removeAccount(m->income());
+		CPPUNIT_FAIL("Exception expected");
+	} catch (MyMoneyException *e) {
+		delete e;
+	}
+
+	// try to remove the account still attached to the institution
+	try {
+		m->removeAccount(a);
+		CPPUNIT_FAIL("Exception expected");
+	} catch (MyMoneyException *e) {
+		delete e;
+	}
+
+	// now really remove an account
+
+	try {
+		CPPUNIT_ASSERT(i.accountCount() == 0);
+		CPPUNIT_ASSERT(m->accountCount() == 7);
+
+		a.setInstitutionId(QString());
+		m->modifyAccount(a);
+		m->removeAccount(a);
+		m->commitTransaction();
+		m->startTransaction();
+		CPPUNIT_ASSERT(m->accountCount() == 6);
+		CPPUNIT_ASSERT(m->dirty() == true);
+		i = m->institution("I000001");
+		CPPUNIT_ASSERT(i.accountCount() == 0);
+	} catch (MyMoneyException *e) {
+		delete e;
+		CPPUNIT_FAIL("Unexpected exception");
+	}
+}
+
+void MyMoneySeqAccessMgrTest::testRemoveUsedAccount() {
+	testAddTransactions();
+
+	MyMoneyAccount a = m->account("A000006");
+
+	try {
+		m->removeAccount(a);
+		CPPUNIT_FAIL("Exception expected");
+	} catch (MyMoneyException *e) {
+		delete e;
+	}
+}
+
+void MyMoneySeqAccessMgrTest::testRemoveInstitution() {
+	testModifyInstitution();
+	testReparentAccount();
+
+	MyMoneyInstitution i;
+	MyMoneyAccount a;
+
+	// assign the checkings account to the institution
+	try {
+		i = m->institution("I000001");
+		a = m->account("A000006");
+		a.setInstitutionId(i.id());
+		m->modifyAccount(a);
+		CPPUNIT_ASSERT(i.accountCount() == 0);
+	} catch (MyMoneyException *e) {
+		delete e;
+		CPPUNIT_FAIL("Unexpected exception");
+	}
+
+	m->m_dirty = false;
+	// now remove the institution and see if the account survived ;-)
+	try {
+		m->removeInstitution(i);
+		a.setInstitutionId(QString());
+		m->modifyAccount(a);
+		m->commitTransaction();
+		m->startTransaction();
+		a = m->account("A000006");
+		CPPUNIT_ASSERT(m->dirty() == true);
+		CPPUNIT_ASSERT(a.institutionId().isEmpty());
+		CPPUNIT_ASSERT(m->institutionCount() == 0);
+	} catch (MyMoneyException *e) {
+		delete e;
+		CPPUNIT_FAIL("Unexpected exception");
+	}
+}
+
+void MyMoneySeqAccessMgrTest::testRemoveTransaction() {
+	testAddTransactions();
+
+	MyMoneyTransaction t = m->transaction("T000000000000000002");
+
+	m->m_dirty = false;
+	try {
+		m->removeTransaction(t);
+		m->commitTransaction();
+		m->startTransaction();
+		CPPUNIT_ASSERT(m->dirty() == true);
+		CPPUNIT_ASSERT(m->transactionCount() == 1);
+/* removed with MyMoneyAccount::Transaction
+		CPPUNIT_ASSERT(m->account("A000006").transactionCount() == 1);
+*/
+	} catch (MyMoneyException *e) {
+		delete e;
+		CPPUNIT_FAIL("Unexpected exception");
+	}
+}
+
+void MyMoneySeqAccessMgrTest::testTransactionList() {
+	testAddTransactions();
+
+	QValueList<MyMoneyTransaction> list;
+	MyMoneyTransactionFilter filter("A000006");
+	list = m->transactionList(filter);
+	CPPUNIT_ASSERT(list.count() == 2);
+	CPPUNIT_ASSERT((*(list.at(0))).id() == "T000000000000000002");
+	CPPUNIT_ASSERT((*(list.at(1))).id() == "T000000000000000001");
+
+	filter.clear();
+	filter.addAccount(QString("A000003"));
+	list = m->transactionList(filter);
+	CPPUNIT_ASSERT(list.count() == 1);
+	CPPUNIT_ASSERT((*(list.at(0))).id() == "T000000000000000002");
+
+	filter.clear();
+	list = m->transactionList(filter);
+	CPPUNIT_ASSERT(list.count() == 2);
+	CPPUNIT_ASSERT((*(list.at(0))).id() == "T000000000000000002");
+	CPPUNIT_ASSERT((*(list.at(1))).id() == "T000000000000000001");
+}
+
+void MyMoneySeqAccessMgrTest::testAddPayee() {
+	MyMoneyPayee p;
+
+	p.setName("THB");
+	m->m_dirty = false;
+	try {
+		CPPUNIT_ASSERT(m->m_nextPayeeID == 0);
+		m->addPayee(p);
+		m->commitTransaction();
+		m->startTransaction();
+		CPPUNIT_ASSERT(m->dirty() == true);
+		CPPUNIT_ASSERT(m->m_nextPayeeID == 1);
+	} catch (MyMoneyException *e) {
+		delete e;
+		CPPUNIT_FAIL("Unexpected exception");
+	}
+
+}
+
+void MyMoneySeqAccessMgrTest::testSetAccountName() {
+	try {
+		m->setAccountName(STD_ACC_LIABILITY, "Verbindlichkeiten");
+	} catch (MyMoneyException *e) {
+		delete e;
+		CPPUNIT_FAIL("Unexpected exception");
+	}
+	try {
+		m->setAccountName(STD_ACC_ASSET, "Verm�gen");
+	} catch (MyMoneyException *e) {
+		delete e;
+		CPPUNIT_FAIL("Unexpected exception");
+	}
+	try {
+		m->setAccountName(STD_ACC_EXPENSE, "Ausgaben");
+	} catch (MyMoneyException *e) {
+		delete e;
+		CPPUNIT_FAIL("Unexpected exception");
+	}
+	try {
+		m->setAccountName(STD_ACC_INCOME, "Einnahmen");
+	} catch (MyMoneyException *e) {
+		delete e;
+		CPPUNIT_FAIL("Unexpected exception");
+	}
+
+	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");
+		CPPUNIT_FAIL("Exception expected");
+	} catch (MyMoneyException *e) {
+		delete e;
+	}
+}
+
+void MyMoneySeqAccessMgrTest::testModifyPayee() {
+	MyMoneyPayee p;
+
+	testAddPayee();
+
+	p = m->payee("P000001");
+	p.setName("New name");
+	m->m_dirty = false;
+	try {
+		m->modifyPayee(p);
+		m->commitTransaction();
+		m->startTransaction();
+		p = m->payee("P000001");
+		CPPUNIT_ASSERT(p.name() == "New name");
+		CPPUNIT_ASSERT(m->dirty() == true);
+	} catch (MyMoneyException *e) {
+		delete e;
+		CPPUNIT_FAIL("Unexpected exception");
+	}
+}
+
+void MyMoneySeqAccessMgrTest::testRemovePayee() {
+	testAddPayee();
+	m->m_dirty = false;
+
+	// check that we can remove an unreferenced payee
+	MyMoneyPayee p = m->payee("P000001");
+	try {
+		CPPUNIT_ASSERT(m->m_payeeList.count() == 1);
+		m->removePayee(p);
+		m->commitTransaction();
+		m->startTransaction();
+		CPPUNIT_ASSERT(m->m_payeeList.count() == 0);
+		CPPUNIT_ASSERT(m->dirty() == true);
+	} catch (MyMoneyException *e) {
+		delete e;
+		CPPUNIT_FAIL("Unexpected exception");
+	}
+
+	// add transaction
+	testAddTransactions();
+
+	MyMoneyTransaction tr = m->transaction("T000000000000000001");
+	MyMoneySplit sp;
+	sp = tr.splits()[0];
+	sp.setPayeeId("P000001");
+	tr.modifySplit(sp);
+
+	// check that we cannot add a transaction referencing
+	// an unknown payee
+	try {
+		m->modifyTransaction(tr);
+		CPPUNIT_FAIL("Expected exception");
+	} catch (MyMoneyException *e) {
+		delete e;
+	}
+
+	m->m_nextPayeeID = 0;		// reset here, so that the
+					// testAddPayee will not fail
+	testAddPayee();
+
+	// check that it works when the payee exists
+	try {
+		m->modifyTransaction(tr);
+	} catch (MyMoneyException *e) {
+		delete e;
+		CPPUNIT_FAIL("Unexpected exception");
+	}
+
+	m->m_dirty = false;
+
+	// now check, that we cannot remove the payee
+	try {
+		m->removePayee(p);
+		CPPUNIT_FAIL("Expected exception");
+	} catch (MyMoneyException *e) {
+		delete e;
+	}
+	CPPUNIT_ASSERT(m->m_payeeList.count() == 1);
+}
+
+
+void MyMoneySeqAccessMgrTest::testRemoveAccountFromTree() {
+	MyMoneyAccount a, b, c;
+	a.setName("Acc A");
+	b.setName("Acc B");
+	c.setName("Acc C");
+
+	// build a tree A -> B -> C, remove B and see if A -> C
+	// remains in the storag manager
+
+	try {
+		m->addAccount(a);
+		m->addAccount(b);
+		m->addAccount(c);
+		m->reparentAccount(b, a);
+		m->reparentAccount(c, b);
+
+		CPPUNIT_ASSERT(a.accountList().count() == 1);
+		CPPUNIT_ASSERT(m->account(a.accountList()[0]).name() == "Acc B");
+
+		CPPUNIT_ASSERT(b.accountList().count() == 1);
+		CPPUNIT_ASSERT(m->account(b.accountList()[0]).name() == "Acc C");
+
+		CPPUNIT_ASSERT(c.accountList().count() == 0);
+
+		m->removeAccount(b);
+
+		// reload account info from titutionIDtorage
+		a = m->account(a.id());
+		c = m->account(c.id());
+
+		try {
+			b = m->account(b.id());
+			CPPUNIT_FAIL("Exception expected");
+		} catch (MyMoneyException *e) {
+			delete e;
+		}
+		CPPUNIT_ASSERT(a.accountList().count() == 1);
+		CPPUNIT_ASSERT(m->account(a.accountList()[0]).name() == "Acc C");
+
+		CPPUNIT_ASSERT(c.accountList().count() == 0);
+
+	} catch (MyMoneyException *e) {
+		unexpectedException(e);
+	}
+}
+
+void MyMoneySeqAccessMgrTest::testPayeeName() {
+	testAddPayee();
+
+	MyMoneyPayee p;
+	QString name("THB");
+
+	// OK case
+	try {
+		p = m->payeeByName(name);
+		CPPUNIT_ASSERT(p.name() == "THB");
+		CPPUNIT_ASSERT(p.id() == "P000001");
+	} catch (MyMoneyException *e) {
+		unexpectedException(e);
+	}
+
+	// Not OK case
+	name = "Thb";
+	try {
+		p = m->payeeByName(name);
+		CPPUNIT_FAIL("Exception expected");
+	} catch (MyMoneyException *e) {
+		delete e;
+	}
+}
+
+void MyMoneySeqAccessMgrTest::testAssignment() {
+	testAddTransactions();
+
+	MyMoneyPayee user;
+	user.setName("Thomas");
+	m->setUser(user);
+
+	MyMoneySeqAccessMgr test = *m;
+	testEquality(&test);
+}
+
+void MyMoneySeqAccessMgrTest::testEquality(const MyMoneySeqAccessMgr *t)
+{
+	CPPUNIT_ASSERT(m->user().name() == t->user().name());
+	CPPUNIT_ASSERT(m->user().address() == t->user().address());
+	CPPUNIT_ASSERT(m->user().city() == t->user().city());
+	CPPUNIT_ASSERT(m->user().state() == t->user().state());
+	CPPUNIT_ASSERT(m->user().postcode() == t->user().postcode());
+	CPPUNIT_ASSERT(m->user().telephone() == t->user().telephone());
+	CPPUNIT_ASSERT(m->user().email() == t->user().email());
+	CPPUNIT_ASSERT(m->m_nextInstitutionID == t->m_nextInstitutionID);
+	CPPUNIT_ASSERT(m->m_nextAccountID == t->m_nextAccountID);
+	CPPUNIT_ASSERT(m->m_nextTransactionID == t->m_nextTransactionID);
+	CPPUNIT_ASSERT(m->m_nextPayeeID == t->m_nextPayeeID);
+	CPPUNIT_ASSERT(m->m_nextScheduleID == t->m_nextScheduleID);
+	CPPUNIT_ASSERT(m->m_dirty == t->m_dirty);
+	CPPUNIT_ASSERT(m->m_creationDate == t->m_creationDate);
+	CPPUNIT_ASSERT(m->m_lastModificationDate == t->m_lastModificationDate);
+
+	/*
+	 * make sure, that the keys and values are the same
+	 * on the left and the right side
+	 */
+	CPPUNIT_ASSERT(m->m_payeeList.keys() == t->m_payeeList.keys());
+	CPPUNIT_ASSERT(m->m_payeeList.values() == t->m_payeeList.values());
+	CPPUNIT_ASSERT(m->m_transactionKeys.keys() == t->m_transactionKeys.keys());
+	CPPUNIT_ASSERT(m->m_transactionKeys.values() == t->m_transactionKeys.values());
+	CPPUNIT_ASSERT(m->m_institutionList.keys() == t->m_institutionList.keys());
+	CPPUNIT_ASSERT(m->m_institutionList.values() == t->m_institutionList.values());
+	CPPUNIT_ASSERT(m->m_accountList.keys() == t->m_accountList.keys());
+	CPPUNIT_ASSERT(m->m_accountList.values() == t->m_accountList.values());
+	CPPUNIT_ASSERT(m->m_transactionList.keys() == t->m_transactionList.keys());
+	CPPUNIT_ASSERT(m->m_transactionList.values() == t->m_transactionList.values());
+	CPPUNIT_ASSERT(m->m_balanceCache.keys() == t->m_balanceCache.keys());
+	CPPUNIT_ASSERT(m->m_balanceCache.values() == t->m_balanceCache.values());
+
+//	CPPUNIT_ASSERT(m->m_scheduleList.keys() == t->m_scheduleList.keys());
+//	CPPUNIT_ASSERT(m->m_scheduleList.values() == t->m_scheduleList.values());
+}
+
+void MyMoneySeqAccessMgrTest::testDuplicate() {
+	const MyMoneySeqAccessMgr* t;
+
+	testModifyTransaction();
+
+	t = m->duplicate();
+	testEquality(t);
+	delete t;
+}
+
+void MyMoneySeqAccessMgrTest::testAddSchedule() {
+	/* Note addSchedule() now calls validate as it should
+	 * so we need an account id.  Later this will
+	 * be checked to make sure its a valid account id.  The
+	 * tests currently fail because no splits are defined
+	 * for the schedules transaction.
+	*/
+
+
+	try {
+		CPPUNIT_ASSERT(m->m_scheduleList.count() == 0);
+		MyMoneyTransaction t1;
+		MyMoneySplit s1, s2;
+		s1.setAccountId("A000001");
+		t1.addSplit(s1);
+		s2.setAccountId("A000002");
+		t1.addSplit(s2);
+		MyMoneySchedule schedule("Sched-Name",
+				 MyMoneySchedule::TYPE_DEPOSIT,
+				 MyMoneySchedule::OCCUR_DAILY, 1,
+				 MyMoneySchedule::STYPE_MANUALDEPOSIT,
+				 QDate(),
+				 QDate(),
+				 true,
+				 false);
+		t1.setPostDate(QDate(2003,7,10));
+		schedule.setTransaction(t1);
+
+		m->addSchedule(schedule);
+
+		CPPUNIT_ASSERT(m->m_scheduleList.count() == 1);
+		CPPUNIT_ASSERT(schedule.id() == "SCH000001");
+		CPPUNIT_ASSERT(m->m_scheduleList["SCH000001"].id() == "SCH000001");
+	} catch(MyMoneyException *e) {
+		delete e;
+		CPPUNIT_FAIL("Unexpected exception");
+	}
+
+	try {
+		MyMoneySchedule schedule("Sched-Name",
+					 MyMoneySchedule::TYPE_DEPOSIT,
+					 MyMoneySchedule::OCCUR_DAILY, 1,
+					 MyMoneySchedule::STYPE_MANUALDEPOSIT,
+					 QDate(),
+					 QDate(),
+					 true,
+					 false);
+		m->addSchedule(schedule);
+		CPPUNIT_FAIL("Exception expected");
+	} catch(MyMoneyException *e) {
+		delete e;
+	}
+}
+
+void MyMoneySeqAccessMgrTest::testSchedule() {
+	testAddSchedule();
+	MyMoneySchedule sched;
+
+	sched = m->schedule("SCH000001");
+	CPPUNIT_ASSERT(sched.name() == "Sched-Name");
+	CPPUNIT_ASSERT(sched.id() == "SCH000001");
+
+	try {
+		m->schedule("SCH000002");
+		CPPUNIT_FAIL("Exception expected");
+	} catch(MyMoneyException *e) {
+		delete e;
+	}
+}
+
+void MyMoneySeqAccessMgrTest::testModifySchedule() {
+	testAddSchedule();
+	MyMoneySchedule sched;
+
+	sched = m->schedule("SCH000001");
+	sched.setId("SCH000002");
+	try {
+		m->modifySchedule(sched);
+		CPPUNIT_FAIL("Exception expected");
+	} catch(MyMoneyException *e) {
+		delete e;
+	}
+
+	sched = m->schedule("SCH000001");
+	sched.setName("New Sched-Name");
+	try {
+		m->modifySchedule(sched);
+		CPPUNIT_ASSERT(m->m_scheduleList.count() == 1);
+		CPPUNIT_ASSERT(m->m_scheduleList["SCH000001"].name() == "New Sched-Name");
+
+	} catch(MyMoneyException *e) {
+		delete e;
+		CPPUNIT_FAIL("Unexpected exception");
+	}
+
+}
+
+void MyMoneySeqAccessMgrTest::testRemoveSchedule() {
+	testAddSchedule();
+	m->commitTransaction();
+	m->startTransaction();
+	MyMoneySchedule sched;
+
+	sched = m->schedule("SCH000001");
+	sched.setId("SCH000002");
+	try {
+		m->removeSchedule(sched);
+		m->commitTransaction();
+		CPPUNIT_FAIL("Exception expected");
+	} catch(MyMoneyException *e) {
+		m->rollbackTransaction();
+		delete e;
+	}
+	m->startTransaction();
+
+	sched = m->schedule("SCH000001");
+	try {
+		m->removeSchedule(sched);
+		m->commitTransaction();
+		CPPUNIT_ASSERT(m->m_scheduleList.count() == 0);
+
+	} catch(MyMoneyException *e) {
+		m->rollbackTransaction();
+		delete e;
+		CPPUNIT_FAIL("Unexpected exception");
+	}
+	m->startTransaction();
+}
+
+void MyMoneySeqAccessMgrTest::testScheduleList() {
+	QDate	testDate = QDate::currentDate();
+	QDate	notOverdue = testDate.addDays(2);
+	QDate	overdue = testDate.addDays(-2);
+
+
+	MyMoneyTransaction t1;
+	MyMoneySplit s1, s2;
+	s1.setAccountId("A000001");
+	t1.addSplit(s1);
+	s2.setAccountId("A000002");
+	t1.addSplit(s2);
+	MyMoneySchedule schedule1("Schedule 1",
+				 MyMoneySchedule::TYPE_BILL,
+				 MyMoneySchedule::OCCUR_ONCE, 1,
+				 MyMoneySchedule::STYPE_DIRECTDEBIT,
+				 QDate(),
+				 QDate(),
+				 false,
+				 false);
+	t1.setPostDate(notOverdue);
+	schedule1.setTransaction(t1);
+	schedule1.setLastPayment(notOverdue);
+
+	MyMoneyTransaction t2;
+	MyMoneySplit s3, s4;
+	s3.setAccountId("A000001");
+	t2.addSplit(s3);
+	s4.setAccountId("A000003");
+	t2.addSplit(s4);
+	MyMoneySchedule schedule2("Schedule 2",
+				 MyMoneySchedule::TYPE_DEPOSIT,
+				 MyMoneySchedule::OCCUR_DAILY, 1,
+				 MyMoneySchedule::STYPE_DIRECTDEPOSIT,
+				 QDate(),
+				 QDate(),
+				 false,
+				 false);
+	t2.setPostDate(notOverdue.addDays(1));
+	schedule2.setTransaction(t2);
+	schedule2.setLastPayment(notOverdue.addDays(1));
+
+	MyMoneyTransaction t3;
+	MyMoneySplit s5, s6;
+	s5.setAccountId("A000005");
+	t3.addSplit(s5);
+	s6.setAccountId("A000006");
+	t3.addSplit(s6);
+	MyMoneySchedule schedule3("Schedule 3",
+				 MyMoneySchedule::TYPE_TRANSFER,
+				 MyMoneySchedule::OCCUR_WEEKLY, 1,
+				 MyMoneySchedule::STYPE_OTHER,
+				 QDate(),
+				 QDate(),
+				 false,
+				 false);
+	t3.setPostDate(notOverdue.addDays(2));
+	schedule3.setTransaction(t3);
+	schedule3.setLastPayment(notOverdue.addDays(2));
+
+	MyMoneyTransaction t4;
+	MyMoneySplit s7, s8;
+	s7.setAccountId("A000005");
+	t4.addSplit(s7);
+	s8.setAccountId("A000006");
+	t4.addSplit(s8);
+	MyMoneySchedule schedule4("Schedule 4",
+				 MyMoneySchedule::TYPE_BILL,
+				 MyMoneySchedule::OCCUR_WEEKLY, 1,
+				 MyMoneySchedule::STYPE_WRITECHEQUE,
+				 QDate(),
+				 notOverdue.addDays(31),
+				 false,
+				 false);
+	t4.setPostDate(overdue.addDays(-7));
+	schedule4.setTransaction(t4);
+
+	try {
+		m->addSchedule(schedule1);
+		m->addSchedule(schedule2);
+		m->addSchedule(schedule3);
+		m->addSchedule(schedule4);
+	} catch(MyMoneyException *e) {
+		qDebug("Error: %s", e->what().latin1());
+		delete e;
+		CPPUNIT_FAIL("Unexpected exception");
+	}
+
+	QValueList<MyMoneySchedule> list;
+
+	// no filter
+	list = m->scheduleList();
+	CPPUNIT_ASSERT(list.count() == 4);
+
+	// filter by type
+	list = m->scheduleList("", MyMoneySchedule::TYPE_BILL);
+	CPPUNIT_ASSERT(list.count() == 2);
+	CPPUNIT_ASSERT(list[0].name() == "Schedule 1");
+	CPPUNIT_ASSERT(list[1].name() == "Schedule 4");
+
+	// filter by occurence
+	list = m->scheduleList("", MyMoneySchedule::TYPE_ANY,
+				MyMoneySchedule::OCCUR_DAILY);
+	CPPUNIT_ASSERT(list.count() == 1);
+	CPPUNIT_ASSERT(list[0].name() == "Schedule 2");
+
+	// filter by payment type
+	list = m->scheduleList("", MyMoneySchedule::TYPE_ANY,
+				MyMoneySchedule::OCCUR_ANY,
+				MyMoneySchedule::STYPE_DIRECTDEPOSIT);
+	CPPUNIT_ASSERT(list.count() == 1);
+	CPPUNIT_ASSERT(list[0].name() == "Schedule 2");
+
+	// filter by account
+	list = m->scheduleList("A01");
+	CPPUNIT_ASSERT(list.count() == 0);
+	list = m->scheduleList("A000001");
+	CPPUNIT_ASSERT(list.count() == 2);
+	list = m->scheduleList("A000002");
+	CPPUNIT_ASSERT(list.count() == 1);
+
+	// filter by start date
+	list = m->scheduleList("", MyMoneySchedule::TYPE_ANY,
+				MyMoneySchedule::OCCUR_ANY,
+				MyMoneySchedule::STYPE_ANY,
+				notOverdue.addDays(31));
+	CPPUNIT_ASSERT(list.count() == 3);
+	CPPUNIT_ASSERT(list[0].name() == "Schedule 2");
+	CPPUNIT_ASSERT(list[1].name() == "Schedule 3");
+	CPPUNIT_ASSERT(list[2].name() == "Schedule 4");
+
+	// filter by end date
+	list = m->scheduleList("", MyMoneySchedule::TYPE_ANY,
+				MyMoneySchedule::OCCUR_ANY,
+				MyMoneySchedule::STYPE_ANY,
+				QDate(),
+				notOverdue.addDays(1));
+	CPPUNIT_ASSERT(list.count() == 3);
+	CPPUNIT_ASSERT(list[0].name() == "Schedule 1");
+	CPPUNIT_ASSERT(list[1].name() == "Schedule 2");
+	CPPUNIT_ASSERT(list[2].name() == "Schedule 4");
+
+	// filter by start and end date
+	list = m->scheduleList("", MyMoneySchedule::TYPE_ANY,
+				MyMoneySchedule::OCCUR_ANY,
+				MyMoneySchedule::STYPE_ANY,
+				notOverdue.addDays(-1),
+				notOverdue.addDays(1));
+	CPPUNIT_ASSERT(list.count() == 2);
+	CPPUNIT_ASSERT(list[0].name() == "Schedule 1");
+	CPPUNIT_ASSERT(list[1].name() == "Schedule 2");
+
+	// filter by overdue status
+	list = m->scheduleList("", MyMoneySchedule::TYPE_ANY,
+				MyMoneySchedule::OCCUR_ANY,
+				MyMoneySchedule::STYPE_ANY,
+				QDate(),
+				QDate(),
+				true);
+	CPPUNIT_ASSERT(list.count() == 1);
+	CPPUNIT_ASSERT(list[0].name() == "Schedule 4");
+}
+
+void MyMoneySeqAccessMgrTest::testAddCurrency()
+{
+	MyMoneySecurity curr("EUR", "Euro", "?", 100, 100);
+	CPPUNIT_ASSERT(m->m_currencyList.count() == 0);
+	m->m_dirty = false;
+	try {
+		m->addCurrency(curr);
+		m->commitTransaction();
+		m->startTransaction();
+		CPPUNIT_ASSERT(m->m_currencyList.count() == 1);
+		CPPUNIT_ASSERT(m->m_currencyList["EUR"].name() == "Euro");
+		CPPUNIT_ASSERT(m->dirty() == true);
+	} catch(MyMoneyException *e) {
+                delete e;
+                CPPUNIT_FAIL("Unexpected exception");
+	}
+
+	m->m_dirty = false;
+	try {
+		m->addCurrency(curr);
+                CPPUNIT_FAIL("Expected exception missing");
+	} catch(MyMoneyException *e) {
+		m->commitTransaction();
+		m->startTransaction();
+		CPPUNIT_ASSERT(m->dirty() == false);
+                delete e;
+	}
+}
+
+void MyMoneySeqAccessMgrTest::testModifyCurrency()
+{
+	MyMoneySecurity curr("EUR", "Euro", "?", 100, 100);
+	testAddCurrency();
+	m->m_dirty = false;
+	curr.setName("EURO");
+	try {
+		m->modifyCurrency(curr);
+		m->commitTransaction();
+		m->startTransaction();
+		CPPUNIT_ASSERT(m->m_currencyList.count() == 1);
+		CPPUNIT_ASSERT(m->m_currencyList["EUR"].name() == "EURO");
+		CPPUNIT_ASSERT(m->dirty() == true);
+	} catch(MyMoneyException *e) {
+                delete e;
+                CPPUNIT_FAIL("Unexpected exception");
+	}
+
+	m->m_dirty = false;
+
+	MyMoneySecurity unknownCurr("DEM", "Deutsche Mark", "DM", 100, 100);
+	try {
+		m->modifyCurrency(unknownCurr);
+                CPPUNIT_FAIL("Expected exception missing");
+	} catch(MyMoneyException *e) {
+		m->commitTransaction();
+		m->startTransaction();
+		CPPUNIT_ASSERT(m->dirty() == false);
+                delete e;
+	}
+}
+
+void MyMoneySeqAccessMgrTest::testRemoveCurrency()
+{
+	MyMoneySecurity curr("EUR", "Euro", "?", 100, 100);
+	testAddCurrency();
+	m->m_dirty = false;
+	try {
+		m->removeCurrency(curr);
+		m->commitTransaction();
+		m->startTransaction();
+		CPPUNIT_ASSERT(m->m_currencyList.count() == 0);
+		CPPUNIT_ASSERT(m->dirty() == true);
+	} catch(MyMoneyException *e) {
+                delete e;
+                CPPUNIT_FAIL("Unexpected exception");
+	}
+
+	m->m_dirty = false;
+
+	MyMoneySecurity unknownCurr("DEM", "Deutsche Mark", "DM", 100, 100);
+	try {
+		m->removeCurrency(unknownCurr);
+                CPPUNIT_FAIL("Expected exception missing");
+	} catch(MyMoneyException *e) {
+		m->commitTransaction();
+		m->startTransaction();
+		CPPUNIT_ASSERT(m->dirty() == false);
+                delete e;
+	}
+}
+
+void MyMoneySeqAccessMgrTest::testCurrency()
+{
+	MyMoneySecurity curr("EUR", "Euro", "?", 100, 100);
+	MyMoneySecurity newCurr;
+	testAddCurrency();
+	m->m_dirty = false;
+	try {
+		newCurr = m->currency("EUR");
+		m->commitTransaction();
+		m->startTransaction();
+		CPPUNIT_ASSERT(m->dirty() == false);
+		CPPUNIT_ASSERT(newCurr.id() == curr.id());
+		CPPUNIT_ASSERT(newCurr.name() == curr.name());
+	} catch(MyMoneyException *e) {
+                delete e;
+                CPPUNIT_FAIL("Unexpected exception");
+	}
+
+	try {
+		m->currency("DEM");
+                CPPUNIT_FAIL("Expected exception missing");
+	} catch(MyMoneyException *e) {
+		m->commitTransaction();
+		m->startTransaction();
+		CPPUNIT_ASSERT(m->dirty() == false);
+                delete e;
+	}
+}
+
+void MyMoneySeqAccessMgrTest::testCurrencyList()
+{
+	CPPUNIT_ASSERT(m->currencyList().count() == 0);
+
+	testAddCurrency();
+	CPPUNIT_ASSERT(m->currencyList().count() == 1);
+
+	MyMoneySecurity unknownCurr("DEM", "Deutsche Mark", "DM", 100, 100);
+	try {
+		m->addCurrency(unknownCurr);
+		m->m_dirty = false;
+		CPPUNIT_ASSERT(m->m_currencyList.count() == 2);
+		CPPUNIT_ASSERT(m->currencyList().count() == 2);
+		CPPUNIT_ASSERT(m->dirty() == false);
+	} catch(MyMoneyException *e) {
+                delete e;
+                CPPUNIT_FAIL("Unexpected exception");
+	}
+}
+
+void MyMoneySeqAccessMgrTest::testAccountList()
+{
+	QValueList<MyMoneyAccount> accounts;
+	m->accountList(accounts);
+	CPPUNIT_ASSERT(accounts.count() == 0);
+	testAddNewAccount();
+	accounts.clear();
+	m->accountList(accounts);
+	CPPUNIT_ASSERT(accounts.count() == 2);
+
+	MyMoneyAccount a = m->account("A000001");
+	MyMoneyAccount b = m->account("A000002");
+	m->reparentAccount(b, a);
+	accounts.clear();
+	m->accountList(accounts);
+	CPPUNIT_ASSERT(accounts.count() == 2);
+}
+
+void MyMoneySeqAccessMgrTest::testLoaderFunctions()
+{
+	// we don't need the transaction started by setup() here
+	m->rollbackTransaction();
+
+	// account loader
+	QMap<QString, MyMoneyAccount> amap;
+	MyMoneyAccount acc("A0000176", MyMoneyAccount());
+	amap[acc.id()] = acc;
+	m->loadAccounts(amap);
+	CPPUNIT_ASSERT(m->m_accountList.values() == amap.values());
+	CPPUNIT_ASSERT(m->m_accountList.keys() == amap.keys());
+	CPPUNIT_ASSERT(m->m_nextAccountID == 176);
+
+	// transaction loader
+	QMap<QString, MyMoneyTransaction> tmap;
+	MyMoneyTransaction t("T000000108", MyMoneyTransaction());
+	tmap[t.id()] = t;
+	m->loadTransactions(tmap);
+	CPPUNIT_ASSERT(m->m_transactionList.values() == tmap.values());
+	CPPUNIT_ASSERT(m->m_transactionList.keys() == tmap.keys());
+	CPPUNIT_ASSERT(m->m_nextTransactionID == 108);
+
+	// institution loader
+	QMap<QString, MyMoneyInstitution> imap;
+	MyMoneyInstitution inst("I000028", MyMoneyInstitution());
+	imap[inst.id()] = inst;
+	m->loadInstitutions(imap);
+	CPPUNIT_ASSERT(m->m_institutionList.values() == imap.values());
+	CPPUNIT_ASSERT(m->m_institutionList.keys() == imap.keys());
+	CPPUNIT_ASSERT(m->m_nextInstitutionID == 28);
+
+	// payee loader
+	QMap<QString, MyMoneyPayee> pmap;
+	MyMoneyPayee p("P1234", MyMoneyPayee());
+	pmap[p.id()] = p;
+	m->loadPayees(pmap);
+	CPPUNIT_ASSERT(m->m_payeeList.values() == pmap.values());
+	CPPUNIT_ASSERT(m->m_payeeList.keys() == pmap.keys());
+	CPPUNIT_ASSERT(m->m_nextPayeeID == 1234);
+
+	// security loader
+	QMap<QString, MyMoneySecurity> smap;
+	MyMoneySecurity s("S54321", MyMoneySecurity());
+	smap[s.id()] = s;
+	m->loadSecurities(smap);
+	CPPUNIT_ASSERT(m->m_securitiesList.values() == smap.values());
+	CPPUNIT_ASSERT(m->m_securitiesList.keys() == smap.keys());
+	CPPUNIT_ASSERT(m->m_nextSecurityID == 54321);
+
+	// schedule loader
+	QMap<QString, MyMoneySchedule> schmap;
+	MyMoneySchedule sch("SCH6789", MyMoneySchedule());
+	schmap[sch.id()] = sch;
+	m->loadSchedules(schmap);
+	CPPUNIT_ASSERT(m->m_scheduleList.values() == schmap.values());
+	CPPUNIT_ASSERT(m->m_scheduleList.keys() == schmap.keys());
+	CPPUNIT_ASSERT(m->m_nextScheduleID == 6789);
+
+	// report loader
+	QMap<QString, MyMoneyReport> rmap;
+	MyMoneyReport r("R1298", MyMoneyReport());
+	rmap[r.id()] = r;
+	m->loadReports(rmap);
+	CPPUNIT_ASSERT(m->m_reportList.values() == rmap.values());
+	CPPUNIT_ASSERT(m->m_reportList.keys() == rmap.keys());
+	CPPUNIT_ASSERT(m->m_nextReportID == 1298);
+
+	// budget loader
+	QMap<QString, MyMoneyBudget> bmap;
+	MyMoneyBudget b("B89765", MyMoneyBudget());
+	bmap[b.id()] = b;
+	m->loadBudgets(bmap);
+	CPPUNIT_ASSERT(m->m_budgetList.values() == bmap.values());
+	CPPUNIT_ASSERT(m->m_budgetList.keys() == bmap.keys());
+	CPPUNIT_ASSERT(m->m_nextBudgetID == 89765);
+
+	// restart a transaction so that teardown() is happy
+	m->startTransaction();
+}
+