JUnit Test Cases

[Chris Be]

Two test cases that may come in handy . Note: They may need to be adjusted to match your particular database interface, or implementation. Any suggestions welcome.

1. Database interface functionality, non-threaded:

package suncertify.db;
 
import junit.framework.TestCase;
 
/**
 * Test database implementation, non-threaded.
 * 
 * @author ChrisBe
 * 
 */
public class DatabaseTest extends TestCase {
 
    /**
     * The database implementation to test.
     */
    private Database db;
 
    /**
     * Initialize database implementation.
     */
    protected void setUp() throws Exception {
super.setUp();
db = Database.getDatabase(Database.dbFileLocation);
    }
 
    /**
     * testDeleteRecord
     */
    public void testDeleteRecord() throws Exception {
 
long lockCookie = db.lockRecord(30);
try {
    db.setDelFlag(30, Database.validFlag);
    assertTrue("Set record 30 to valid record.", db
    .verifyValidRecord(30));
    db.deleteRecord(30, lockCookie);
    boolean isValid = true;
    try {
isValid = db.verifyValidRecord(30);
    } catch (RecordNotFoundException rnfe) {
isValid = false;
    }
    assertFalse("Record valid status.", isValid);
    db.setDelFlag(30, Database.validFlag);
    assertTrue("Reset to valid record.", db.verifyValidRecord(30));
} finally {
    db.unlock(30, lockCookie);
}
    }
 
    /**
     * testReadRecord
     * 
     * @throws Exception
     */
    public void testReadRecord() throws Exception {
 
// test first record
// TODO
 
// test last record
// TODO
 
// test reading all 30 records as given in file.
for (int i = 0; i <= 30; i++) {
    String[] recordData = db.readRecord(i);
    boolean debug = true;
}
assertTrue("Read all records", true);
 
// ensure we cannot read deleted records.
long lockCookie = db.lockRecord(29);
try {
    db.deleteRecord(29, lockCookie);
} finally {
    db.unlock(29, lockCookie);
}
boolean isValid = true;
try {
    isValid = db.verifyValidRecord(29);
} catch (RecordNotFoundException rnfe) {
    isValid = false;
} finally {
    assertFalse("Set record 29 to invalid record.", isValid);
}
boolean canRead = true;
try {
    String[] record = db.readRecord(29);
    canRead = true;
} catch (RecordNotFoundException rnfe) {
    canRead = false;
} finally {
    assertFalse("Should not be able to read deleted record 29.",
    canRead);
}
db.setDelFlag(29, Database.validFlag);
assertTrue("Reset record 29 to valid.", db.verifyValidRecord(29));
 
// ensure we cannot read a record beyond database
boolean encounteredException = false;
try {
    db.readRecord(db.getNumRecValidDel() + 1);
} catch (RecordNotFoundException e) {
    encounteredException = true;
}
assertEquals(
"Expected RecordNotFoundException when reading beyond size.",
true, encounteredException);
 
// ensure we cannot read a record negative beyond database
encounteredException = false;
try {
    db.readRecord(-1);
} catch (RecordNotFoundException e) {
    encounteredException = true;
}
assertEquals(
"Expected RecordNotFoundException when reading beyond file.",
true, encounteredException);
 
// read far beyond file
encounteredException = false;
try {
    db.readRecord(5000);
} catch (RecordNotFoundException e) {
    encounteredException = true;
}
assertEquals(
"Expected RecordNotFoundException when reading beyond file.",
true, encounteredException);
    }
 
    /**
     * testCreateRecord
     * 
     * @throws Exception
     */
    public void testCreateRecord() throws Exception {
long numRecs = db.getNumRecValidDel();
 
String[] testRecord = new String[] { "name", "location", "10", "Y",
"$111.11", "1980/01/01", "1234" };
String[] writtenRecord = null;
long newRecNo = db.createRecord(testRecord);
try {
    writtenRecord = db.readRecord(newRecNo);
} finally {
    assertEquals("Record created.", numRecs + 1, newRecNo);
    for (int i = 0; i < testRecord.length; i++) {
assertEquals("Test record and written record data match.",
testRecord[i], writtenRecord[i].trim());
    }
}
    }
 
    /**
     * testUpdateRecord
     * 
     * @throws Exception
     */
    public void testUpdateRecord() throws Exception {
 
String[] testRecord = new String[] { "updName", "updLocation", "1",
"Y", "$111.11", "1980/01/01", "1234" };
String[] updateRecord = new String[] { "updNameChanged",
"updLocationChanged", "99", "N", "$999.99", "1999/09/09",
"9999" };
 
long newRecNo = db.createRecord(testRecord);
long lockCookie = db.lockRecord(newRecNo);
String[] updatedRecord = null;
try {
    db.updateRecord(newRecNo, updateRecord, lockCookie);
    updatedRecord = db.readRecord(newRecNo);
} finally {
    db.unlock(newRecNo, lockCookie);
    for (int i = 0; i < updateRecord.length; i++) {
assertEquals("Update record and written record data match.",
updateRecord[i], updatedRecord[i].trim());
    }
}
    }
 
    /**
     * getNewCookie
     * 
     * @throws Exception
     */
    public void testGetNewCookie() throws Exception {
for (int i = (int) db.getNewCookie(); i < 100; i++) {
    assertEquals("New cookie value.", i + 1, (int) db.getNewCookie());
}
    }
}
    

2. A fully fledged concurrency test.

   
package suncertify.db;
 
import junit.framework.TestCase;
 
/**
 * JUnit test to exercise the DBAccess interface and inspect database
 * concurrency.
 * 
 * @author ChrisBe
 */
public class DatabaseConcurrencyTest extends TestCase {
 
    /**
     * Number of concurrent threads to spawn.
     */
    private static final int NUM_THREADS = 1000;
 
    /**
     * Test up to action in the switch block. 0=test lock/unlock only and so on.
     * Refer to switch block in performAction method.
     * 
     * @see TestThread#performAction()
     */
    private static final int TEST_UP_TO_ACTION = 5;
 
    /**
     * Test up to the given record. Set to 0 to only test one record (recNo =
     * 0).
     */
    private static final int TEST_UP_TO_RECORD = 30;
 
    /**
     * Number of subsequent actions to be performed by each thread.
     */
    private static final int NUM_ACTIONS_PER_THREAD = 5;
 
    /**
     * Maximum delay in thread execution.
     */
    private static final long MAX_SLEEP_MS = 10;
 
    private DBAccess db;
 
    /**
     * Initialize the DBAccess implementation.
     */
    protected void setUp() throws Exception {
this.db = Database.getDatabase(Database.dbFileLocation);
super.setUp();
    }
 
    /**
     * Test concurrency. NOTE: I haven't quite figured out yet how to make it
     * fail properly if concurrency does not work.
     * 
     * @throws Exception
     */
    public void testConcurrency() throws Exception {
 
TestThread[] testThreads = new TestThread[NUM_THREADS];
 
// launch all threads
for (int i = 0; i < testThreads.length; i++) {
    testThreads[i] = new TestThread("T" + i);
    testThreads[i].start();
}
 
// wait for all threads to finish.
for (int i = 0; i < testThreads.length; i++) {
    TestThread t = testThreads[i];
    t.join();
    assertEquals("Failures in thread=" + t.getName(), 0, t.failures);
}
    }
 
    /**
     * Log a message. Customize for your own logging needs.
     * 
     * @param msg
     *                the mesage to log.
     */
    private static void logMsg(String msg) {
System.out.println(Thread.currentThread().getName() + ": " + msg);
    }
 
    /**
     * A test thread.
     * 
     * @author ChrisBe
     * 
     */
    class TestThread extends Thread {
private RandomAction recordAction;
int failures = NUM_ACTIONS_PER_THREAD;
 
/**
 * Constructor.
 * 
 * @param name
 */
private TestThread(String name) {
    super(name);
}
 
/**
 * Overridden method to run the thread and sequentially perform all
 * thread actions.
 */
public void run() {
    for (int i = 0; i < NUM_ACTIONS_PER_THREAD; i++) {
String actionDetails = "<details>";
try {
    actionDetails = this.newRandomAction();
    logMsg("Started action" + i + ": " + actionDetails);
    this.performAction();
    logMsg("Completed action" + i + ": "
    + this.getActionDetails());
    failures--;
} catch (RecordNotFoundException ex) {
    logMsg("Aborted action" + i + ": "
    + this.getActionDetails() + ", record invalid.");
    failures--;
} catch (SecurityException se) {
    fail("Aborted action" + i + ": Record access violation: "
    + this.getActionDetails() + ", " + se.getMessage());
} catch (Exception e) {
    fail();
    e.printStackTrace();
}
    }
}
 
/**
 * Assigns a new action to this thread.
 * 
 * @return the action details.
 * @throws Exception
 */
private String newRandomAction() throws Exception {
    this.recordAction = new RandomAction();
    return getActionDetails();
}
 
/**
 * Return the details of the current action.
 * 
 * @return the action details.
 */
private String getActionDetails() {
    switch (recordAction.getActionIndex()) {
    case 0:
return "lockUnlockRecord=" + recordAction.getRecNo();
    case 1:
return "deleteRecord=" + recordAction.getRecNo();
    case 2:
return "updateRecord=" + recordAction.getRecNo();
    case 3:
return "readRecord=" + recordAction.getRecNo();
    default:
return "createRecord=" + recordAction.getRecNo();
    }
}
 
/**
 * Perform the action of this thread.
 * 
 * @throws SecurityException
 * @throws RecordNotFoundException
 * @throws InterruptedException
 */
private void performAction() throws RecordNotFoundException,
SecurityException, InterruptedException {
    switch (recordAction.getActionIndex()) {
    case 0:
this.doLockUnlock();
break;
    case 1:
this.doDelete();
break;
    case 2:
this.doUpdate();
break;
    case 3:
this.doRead();
break;
    default:
this.doCreate();
break;
 
    }
}
 
/**
 * Create action.
 */
private void doCreate() {
    String[] newRecord = new String[] {
    "Creator=" + Thread.currentThread().getName(), "location",
    "1", "Y", "$111.11", "1980/01/01", "1234" };
    long newRecordNum = -1;
    try {
newRecordNum = db.createRecord(newRecord);
    } catch (DuplicateKeyException e) {
e.printStackTrace();
    }
    recordAction.setRecNo(newRecordNum);
}
 
/**
 * Read action.
 * 
 * @throws RecordNotFoundException
 * @throws InterruptedException
 */
private void doRead() throws RecordNotFoundException,
InterruptedException {
    Thread.sleep(recordAction.getDelay());
    db.readRecord(recordAction.getRecNo());
}
 
/**
 * Lock/unlock action.
 * 
 * @throws RecordNotFoundException
 * @throws SecurityException
 */
private void doLockUnlock() throws RecordNotFoundException,
SecurityException {
 
    long lockCookie = db.lockRecord(recordAction.getRecNo());
    try {
Thread.sleep(recordAction.getDelay());
db.unlock(recordAction.getRecNo(), lockCookie);
    } catch (SecurityException se) {
fail(se.getMessage()
+ " Record should be locked by this thread, but is not.");
throw se;
    } catch (InterruptedException ie) {
db.unlock(recordAction.getRecNo(), lockCookie);
    }
}
 
/**
 * Update action.
 * 
 * @throws RecordNotFoundException
 * @throws SecurityException
 * @throws InterruptedException
 */
private void doUpdate() throws RecordNotFoundException,
SecurityException, InterruptedException {
    long lockCookie = db.lockRecord(recordAction.getRecNo());
    try {
Thread.sleep(recordAction.getDelay());
String[] record = db.readRecord(recordAction.getRecNo());
// Update booking value
record[record.length - 1] = Thread.currentThread().getName();
db.updateRecord(recordAction.getRecNo(), record, lockCookie);
 
    } catch (RecordNotFoundException rnfe) {
fail(rnfe.getMessage()
+ " Locked record was deleted by other thread.");
throw rnfe;
    } catch (SecurityException se) {
fail(se.getMessage()
+ " Locked record was locked by another record.");
throw se;
    } finally {
db.unlock(recordAction.getRecNo(), lockCookie);
    }
}
 
/**
 * Delete action.
 * 
 * @throws RecordNotFoundException
 * @throws SecurityException
 * @throws InterruptedException
 */
private void doDelete() throws RecordNotFoundException,
SecurityException, InterruptedException {
    long lockCookie = db.lockRecord(recordAction.getRecNo());
    try {
Thread.sleep(recordAction.getDelay());
db.deleteRecord(recordAction.getRecNo(), lockCookie);
    } catch (RecordNotFoundException rnfe) {
fail(rnfe.getMessage()
+ " Locked record was deleted by other thread.");
    } catch (SecurityException se) {
fail(se.getMessage()
+ " Locked record was locked by another record.");
    } finally {
db.unlock(recordAction.getRecNo(), lockCookie);
    }
}
    }
 
    /**
     * A container for a random database action.
     * 
     * @author ChrisBe
     * 
     */
    class RandomAction {
 
/**
 * The record number to action on.
 */
private int recNo;
/**
 * The index of the action to perform.
 * 
 * @see TestThread#performAction()
 */
private int actionIndex;
 
/**
 * The time to delay the action.
 */
private int executionDelay;
 
/**
 * A randomly chosen action to be performed, on a randomly chosen record
 * number, with a randomly selected execution delay.
 */
public RandomAction() {
    this.recNo = (int) ((Math.random() * TEST_UP_TO_RECORD) - 0);
    this.actionIndex = (int) (Math.random() * TEST_UP_TO_ACTION);
    this.executionDelay = (int) (Math.random() * MAX_SLEEP_MS);
}
 
/**
 * The record to perform the action on.
 * 
 * @return the record index.
 */
public int getRecNo() {
    return recNo;
}
 
/**
 * The index of the action to perform.
 * 
 * @return the index.
 * @see TestThread#performAction()
 */
public int getActionIndex() {
    return actionIndex;
}
 
/**
 * A delay for performing the action.
 * 
 * @return the delay.
 */
public int getDelay() {
    return executionDelay;
}
 
/**
 * Mutate the record to action on.
 * 
 * @param recNo
 *                the new record to action on.
 */
public void setRecNo(long recNo) {
    this.recNo = (int) recNo;
}
    }
}
 

[Daniel Vogt]

thanks for this test! it is very useful and inspired.

[Tomasz Wilk]

I find them usefull too.
But I don't agree with one thing. ConcurrencyTest fails if a read method throws exception. It is possible and legal to get this if a record was previously deleted. Therefore it can be considered as invalid (deleted) record and i.e. RecordNotFoundException has to be thrown.

Regards,
Tomek

[Chris Be]

Originally posted by Tomasz Wilk:
[qb]ConcurrencyTest fails if a read method throws exception. It is possible and legal to get this if a record was previously deleted. Therefore it can be considered as invalid (deleted) record and i.e. RecordNotFoundException has to be thrown.
/qb]

Tomek,

I think you may have overlooked some critical test code sections. ConcurrencyTest does not
fail at all upon encountering a RecordNotFoundException. To the contrary, it acknowledges that the attempt to access the record was due to an invalid record accessed, and decrements the failure count required to pass the test.

catch (RecordNotFoundException ex) {
   logMsg("Aborted action" + i + ": " + this.getActionDetails() + ", record invalid.");
   failures--;
} 

[ October 01, 2007: Message edited by: Chris Be ]

[Naveen Narayanan]

Chris ,
I am not sure right/wrong , but have a doubt �

private void doUpdate() throws RecordNotFoundException,
   SecurityException, InterruptedException {
   long lockCookie = db.lockRecord(recordAction.getRecNo());
   try {
Thread.sleep(recordAction.getDelay());

Probably lockRecord can throw RecordNotFoundException , if a thread attempt to modify a deleted record ..(previously deleted one)
Can I suggest lockRecord also in try catch block and return it in a controlled manner so that it doesn�t be considered a failure �

try{
    long lockCookie = db.lockRecord(recordAction.getRecNo());
    logMsg("Update Locked "+recNo);
} catch (RecordNotFoundException rnfe) {
    logMsg(rnfe.getMessage()+ " Could not lock the record .");
    throw rnfe;
}
try {
   Thread.sleep(recordAction.getDelay());

Expecting your comments

[Chris Be]

Originally posted by Naveen Narayanan:
Chris ,
I am not sure right/wrong , but have a doubt �
Expecting your comments

Yes SIR!

Well, you are suggesting the typical log-and-rethrow exception handling anti-pattern. Exception handling is worth taking much time to study (e.g. here), since done badly, it is a black hole swallowing up valuable resources during software maintenance.
[ November 15, 2007: Message edited by: Chris Be ]

[Sean Beecroft]

I've had to modify this test for the BS. It is more comprehensive then my own concurrency testing. As a result I may have found a dead lock in my code.

[Chris Bicnal]

Hi Sean,

How did you modify these classes to work with B&S, could you share your code?

Thanks,

Chris