public void testMasterUpdate() throws PersistenceException {
Complex fullname = new Complex("First", "Person");
// 1. load master object, add a new dependent object and commit
_db.begin();
TestLazyPerson loadPerson = (TestLazyEmployee) _db.load(TestLazyEmployee.class, fullname);
TestLazyAddress address = new TestLazyAddress();
address.setId(201);
address.setStreet("Halfpipe 1");
address.setCity("Skater Heaven");
address.setPerson(loadPerson);
loadPerson.getAddress().add(address);
_db.commit();
// 2. reuse master and commit. if we get a DuplicateIdentityException,
// the dependent object (id=201) was created twice.
_db.begin();
_db.update(loadPerson);
try {
_db.commit();
} catch (TransactionAbortedException e) {
if (e.getException() instanceof DuplicateIdentityException) {
stream.println("Error: The dependent object Address was just duplicated");
fail("The dependent object Address was just duplicated");
} else {
throw e;
}
}
// No DuplicateIdentityException means, that just one instance of Address (id=201)
// was created in the database. That's what we want to have.
}
public void testIterWithDelete() throws PersistenceException, SQLException {
stream.println("Running testIterWithDelete...");
// Tests iterating over a lazy-loaded Collection that has
// had data deleted
Complex fullname = new Complex("First", "Person");
// First add a record, then commit
_db.begin();
TestLazyEmployee loadPerson = (TestLazyEmployee) _db.load(TestLazyEmployee.class, fullname);
Collection addresses = loadPerson.getAddress();
TestLazyAddress la = new TestLazyAddress();
la.setId(999);
la.setStreet("Rogue Street");
la.setCity("Rogue City");
la.setState("RS");
la.setZip("10666");
la.setPerson(loadPerson);
addresses.add(la);
_db.commit();
// New transaction
_db.begin();
ArrayList masterData = new ArrayList();
// test java.util.Collection.clear() for lazy loading (bug 801)
loadPerson = (TestLazyEmployee) _db.load(TestLazyEmployee.class, fullname);
addresses = loadPerson.getAddress();
// Store the list in the database at the start of the transaction,
// for comparison purposes. Select a victim for deletion.
Iterator it = addresses.iterator();
// victim is last element to test bug 1022
int victim = addresses.size() - 1;
int recNo = 0;
TestLazyAddress victimAddr = null;
while (it.hasNext()) {
TestLazyAddress addr = (TestLazyAddress) it.next();
if (recNo++ == victim) {
victimAddr = addr;
} else {
masterData.add(addr);
}
}
// The expected number of items to iterate over
int collSize = addresses.size();
_db.rollback();
// Now start over, and add something to the collection. Then try
// iterating and clearing the collection
_db.begin();
loadPerson = (TestLazyEmployee) _db.load(TestLazyEmployee.class, fullname);
addresses = loadPerson.getAddress();
addresses.remove(victimAddr);
Iterator it2 = addresses.iterator();
while (it2.hasNext()) {
TestLazyAddress addr = (TestLazyAddress) it2.next();
if (addr.equals(victimAddr)) {
stream.println("Error: Deleted record should not show up in iteration");
fail("Error: Deleted record should not show up in iteration");
} else {
if (!masterData.remove(addr)) {
stream.println("Error: unrecognized element from list in testIterWithDelete");
fail("Error: unrecognized element from list in testIterWithDelete");
}
}
}
_db.rollback();
if (!masterData.isEmpty()) {
stream.println("Error: iteration/deletion failed in testIterWithDelete");
fail("Error: iteration/deletion failed in testIterWithDelete");
}
}
public void testCollection() throws PersistenceException, SQLException {
stream.println("Running testCollection...");
Complex fullname = new Complex("First", "Person");
// test java.util.Collection.clear() for lazy loading (bug 801)
_db.begin();
TestLazyPerson loadPerson = (TestLazyEmployee) _db.load(TestLazyEmployee.class, fullname);
Collection addresses = loadPerson.getAddress();
addresses.clear();
_db.commit();
_db.begin();
loadPerson = (TestLazyEmployee) _db.load(TestLazyEmployee.class, fullname);
addresses = loadPerson.getAddress();
// check if clear() work
if (!addresses.isEmpty()) {
stream.println("Error: Collection.clear() is not working!");
fail("Error: Collection.clear() is not working!");
}
// modify the collection to test java.util.Collection.addAll()
// for lazy loading (bug 801)
Collection c = new ArrayList();
TestLazyAddress address = new TestLazyAddress();
address.setId(101);
address.setStreet("Mattrew Street");
address.setCity("Rome City");
address.setState("RM");
address.setZip("10000");
address.setPerson(loadPerson);
c.add(address);
address = new TestLazyAddress();
address.setId(102);
address.setStreet("Luke Street");
address.setCity("Rome City");
address.setState("RM");
address.setZip("10000");
address.setPerson(loadPerson);
c.add(address);
address = new TestLazyAddress();
address.setId(103);
address.setStreet("John Street");
address.setCity("Rome City");
address.setState("RM");
address.setZip("10000");
address.setPerson(loadPerson);
c.add(address);
addresses.addAll(c);
_db.commit();
// check if add all work
_db.begin();
loadPerson = (TestLazyEmployee) _db.load(TestLazyEmployee.class, fullname);
addresses = loadPerson.getAddress();
Iterator itor = addresses.iterator();
boolean hasAddr1, hasAddr2, hasAddr3;
hasAddr1 = hasAddr2 = hasAddr3 = false;
while (itor.hasNext()) {
address = (TestLazyAddress) itor.next();
if (address.getId() == 101) hasAddr1 = true;
else if (address.getId() == 102) hasAddr2 = true;
else if (address.getId() == 103) hasAddr3 = true;
else {
stream.println("Error: Address with unexpected id is found! " + address);
fail("Erorr: Address with unexpected id is found! " + address);
}
}
if (!hasAddr1 || !hasAddr2 || !hasAddr3) {
stream.println("Error: Collection.addAll( Collection ) fail");
fail("Error: Collection.addAll( Collection ) fail");
}
_db.commit();
}
public void testIterWithAdd() throws PersistenceException, SQLException {
stream.println("Running testIterWithAdd...");
// Tests iterating over a lazy-loaded Collection that has
// had data added
ArrayList masterData = new ArrayList();
Complex fullname = new Complex("First", "Person");
// test java.util.Collection.clear() for lazy loading (bug 801)
_db.begin();
TestLazyPerson loadPerson = (TestLazyEmployee) _db.load(TestLazyEmployee.class, fullname);
Collection addresses = loadPerson.getAddress();
// Store the list in the database at the start of the transaction,
// for comparison purposes
Iterator it = addresses.iterator();
while (it.hasNext()) {
masterData.add(it.next());
}
_db.rollback();
// Now start over, and add something to the collection. Then try
// iterating and clearing the collection
_db.begin();
loadPerson = (TestLazyEmployee) _db.load(TestLazyEmployee.class, fullname);
addresses = loadPerson.getAddress();
int collSize = addresses.size();
TestLazyAddress la = new TestLazyAddress();
la.setId(999);
la.setStreet("Rogue Street");
la.setCity("Rogue City");
la.setState("RS");
la.setZip("10666");
la.setPerson(loadPerson);
addresses.add(la);
// bruce
stream.println("masterData size: " + masterData.size());
stream.println(" addresses size: " + addresses.size());
if (addresses.size() != masterData.size() + 1)
fail("Lazy collection size is different from what is expected");
boolean matchNewElement = false;
int matchCount = 0;
it = addresses.iterator();
/*
* The problem with the following block is that the second loop is
* entered but never exited.
*
*/
bigloop:
while (it.hasNext()) {
TestLazyAddress addr = (TestLazyAddress) it.next();
Iterator it2 = masterData.iterator();
while (it2.hasNext()) {
TestLazyAddress addr2 = (TestLazyAddress) it2.next();
stream.println(" addr: " + addr);
stream.println("addr2: " + addr2);
if (addr2.equals(addr)) {
stream.println("matched");
matchCount++;
continue bigloop;
} else if (addr == la) {
stream.println("matched lazy");
matchNewElement = true;
matchCount++;
continue bigloop;
} else {
stream.println("no match");
}
}
stream.println("newly added:" + la + "@" + System.identityHashCode(la));
stream.println("matchNewElement " + matchNewElement);
stream.println("matchCount " + matchCount);
fail(
"found unexpected address in the new lazy collection:"
+ addr
+ "@"
+ System.identityHashCode(la));
}
if (!matchNewElement) fail("Newly added element is missing");
if (matchCount != (masterData.size() + 1))
fail(
"Lazy collection contains unexpected number of elements. expected: "
+ (masterData.size() + 1)
+ " found: "
+ matchCount);
addresses.clear();
if (!addresses.isEmpty()) {
stream.println("Error: clear failed in testIterWithAdd");
fail("Error: clear failed in testIterWithAdd");
}
_db.rollback();
}
public void createDataObjects() throws PersistenceException, SQLException {
_db.begin();
// create person 1
TestLazyEmployee person = new TestLazyEmployee();
person.setFirstName("First");
person.setLastName("Person");
person.setBirthday(new Date(1922, 2, 2));
person.setStartDate(new Date(2000, 2, 2));
TestLazyAddress address1 = new TestLazyAddress();
address1.setId(1);
address1.setStreet("#1 Address Street");
address1.setCity("First City");
address1.setState("AB");
address1.setZip("10000");
address1.setPerson(person);
TestLazyAddress address2 = new TestLazyAddress();
address2.setId(2);
address2.setStreet("2nd Ave");
address2.setCity("Second City");
address2.setState("BC");
address2.setZip("22222");
address2.setPerson(person);
TestLazyAddress address3 = new TestLazyAddress();
address3.setId(3);
address3.setStreet("3rd Court");
address3.setCity("Third Ave");
address3.setState("AB");
address3.setZip("30003");
address3.setPerson(person);
ArrayList addresslist = new ArrayList();
addresslist.add(address1);
addresslist.add(address2);
addresslist.add(address3);
person.setAddress(addresslist);
TestLazyPayRoll pr1 = new TestLazyPayRoll();
pr1.setId(1);
pr1.setHoliday(15);
pr1.setHourlyRate(25);
pr1.setEmployee(person);
person.setPayRoll(pr1);
TestLazyContractCategory cc = new TestLazyContractCategory();
cc.setId(101);
cc.setName("Full-time slave");
_db.create(cc);
TestLazyContractCategory cc2 = new TestLazyContractCategory();
cc2.setId(102);
cc2.setName("Full-time employee");
_db.create(cc2);
ArrayList category = new ArrayList();
category.add(cc);
category.add(cc2);
TestLazyContract con = new TestLazyContract();
con.setPolicyNo(1001);
con.setComment(
"80 hours a week, no pay hoilday, no sick leave, arrive office at 7:30am everyday");
con.setContractNo(78);
con.setEmployee(person);
con.setCategory(category);
person.setContract(con);
_db.create(person);
_db.commit();
}