You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
kmymoney/kmymoney2/mymoney/mymoneyfiletest.cpp

1555 lines
52 KiB

/***************************************************************************
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. *
* *
***************************************************************************/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "mymoneyfiletest.h"
#include <iostream>
#include <memory>
#include <unistd.h>
#include <tqfile.h>
#include <tqdatastream.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(TQString());
TQString 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");
TQString 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 () {
TQValueList<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);
TQValueList<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) {
TQString 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;
TQString 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 () {
TQValueList<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(TQDate(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() == TQDate(1,2,3));
// construct a transaction and add it to the pool
t.setPostDate(TQDate(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() == TQDate(2002,2,1));
CPPUNIT_ASSERT(t.entryDate() == TQDate::currentDate());
CPPUNIT_ASSERT(m->dirty() == true);
// check the balance of the accounts
a = m->account("A000001");
CPPUNIT_ASSERT(a.lastModified() == TQDate::currentDate());
CPPUNIT_ASSERT(a.balance() == MyMoneyMoney(-1000));
MyMoneyAccount b = m->account("A000003");
CPPUNIT_ASSERT(b.lastModified() == TQDate::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(TQDate(2004,2,1));
storage->m_dirty = false;
MyMoneyFileTransaction ft;
try {
m->modifyTransaction(t);
ft.commit();
t = m->transaction("T000000000000000001");
CPPUNIT_ASSERT(t.postDate() == TQDate(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() == TQDate(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(TQDate(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(TQDate(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");
TQValueList<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;
TQValueList<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
TQValueList<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(TQValueList<MyMoneyAccount::accountTypeE>& list, MyMoneyAccount& parent)
{
MyMoneyAccount a;
MyMoneyAccount stock = m->account("A000002");
TQValueList<MyMoneyAccount::accountTypeE>::Iterator it;
MyMoneyFileTransaction ft;
for(it = list.begin(); it != list.end(); ++it) {
a.setName(TQString("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", TQChar(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() == TQChar(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() == TQChar(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() == TQDate::currentDate());
} catch(MyMoneyException *e) {
unexpectedException(e);
}
// add a second currency
MyMoneyFileTransaction ft;
try {
m->addCurrency(second);
ft.commit();
} catch(MyMoneyException *e) {
unexpectedException(e);
}
TQString refName = TQString("%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() == TQDate::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;
}
}