/*

* Copyright 2009 Weaver authors

*

* This code is part of the Weaver tutorial and may be freely used.

*/

import static org.easymock.EasyMock.createMock;

import static org.easymock.EasyMock.expect;

import static org.easymock.EasyMock.makeThreadSafe;

import static org.easymock.EasyMock.replay;

import static org.easymock.EasyMock.reset;

import static org.easymock.EasyMock.verify;

import com.google.testing.threadtester.Script;

import com.google.testing.threadtester.ScriptedTask;

import com.google.testing.threadtester.Scripter;

import com.google.testing.threadtester.ThreadedTest;

import com.google.testing.threadtester.ThreadedTestRunner;

import junit.framework.TestCase;

import java.util.concurrent.locks.ReadWriteLock;

import java.util.concurrent.locks.ReentrantReadWriteLock;

/**

* Tests {@link UserCache} using a {@link Script}.

*

* @author alasdair.mackintosh@gmail.com (Alasdair Mackintosh)

*/

public class UserCacheTest extends TestCase {

private static final String USER = "user";

private static final String AVATAR1 = "A1";

private static final String AVATAR2 = "A2";

private UserDb db;

private RenderingContext context;

private UserCache cache;

// Create a cache, and verify that it initialises itself from the database.

private void createCache() {

db = createMock(UserDb.class);

makeThreadSafe(db, true);

context = createMock(RenderingContext.class);

makeThreadSafe(context, true);

expect(db.getAvatar(USER)).andReturn(AVATAR1);

replay(db, context);

cache = new UserCache(db, USER, context);

verify(db, context);

}

private void resetMocks() {

// Note that resetting a mock will clear the thread-safe setting, so we need to

// mark the mock as threadsafe every time we reset it. Annoying but true...

reset(db);

makeThreadSafe(db, true);

reset(context);

makeThreadSafe(context, true);

}

/** Simple test for non-threaded operation */

public void testUserCacheBasicOperation() {

createCache();

// Verify a normal draw operation

resetMocks();

context.draw(AVATAR1);

replay(db, context);

cache.drawUserAvatar();

verify(db, context);

// Update the user, and verify that the cache is updated.

resetMocks();

db.update(USER);

expect(db.getAvatar(USER)).andReturn(AVATAR2);

context.draw(AVATAR2);

replay(db, context);

cache.updateUser();

cache.drawUserAvatar();

verify(db, context);

}

/** Runner for the threaded tests */

public void testThreadedTests() {

ThreadedTestRunner runner = new ThreadedTestRunner();

runner.setDebug(false); // Set this to true for debugging the scripting

runner.runTests(getClass(), UserCache.class);

}

/**

* Multithreaded test demonstrating the use of scripts.

*/

@ThreadedTest

public void runUserCacheMultiThreaded() throws Exception {

createCache();

// Update the user, which will mark the cache as invalid. This

// means that when we call cache.drawUserAvatar() below, it will

// refresh the cache.

resetMocks();

db.update(USER);

expect(db.getAvatar(USER)).andReturn(AVATAR2);

context.draw(AVATAR2);

replay(db, context);

cache.updateUser();

// Create two scripts. The main script will call

// cache.drawUserAvatar(). It will yeild control to the second

// script at two different pooints, and the second script will

// then verify the state of the locks.

final Script<UserCache> main = new Script<UserCache>(cache);

final Script<UserCache> second = new Script<UserCache>(main);

// Create control and target objects to allow us to specify a release point.

final UserCache control = main.object();

final UserDb dbTarget = main.createTarget(UserDb.class);

final RenderingContext contextTarget = main.createTarget(RenderingContext.class);

final ReadWriteLock lockTarget = main.createTarget(ReadWriteLock.class);

// Some of the methods that we are invoking are void, which means that we cannot use the

// main.in(xx).beforeCallng(yy) syntax. Instead we need to invoke a method on the control

// object, and then use inLastMethod() and beforeCalling(). This is analagous to

// EasyMock.expectLastcall()

//

// In this case we want to release control twice. The first time will be just before we

// call getAvatar(), and the second will be just before we callcontext.draw().

control.updateCache();

main.inLastMethod().beforeCalling(dbTarget.getAvatar("")).releaseTo(second);

control.drawUserAvatar();

main.inLastMethod();

contextTarget.draw("");

main.beforeCallingLastMethod().releaseTo(second);

main.addTask(new ScriptedTask<UserCache>() {

@Override

public void execute() {

cache.drawUserAvatar();

}

});

second.addTask(new ScriptedTask<UserCache>() {

@Override

public void execute() {

// The second task verifies the locks at the point where it is released, and then

// returns control to the first script.

ReentrantReadWriteLock lock = cache.rwl;

// This is the first point where the main script releases control to the second

// script. We print some diagnostics, and release control back to the main.

System.out.printf("First release - write = %s, num readers = %d\n",

lock.isWriteLocked(), lock.getReadLockCount());

releaseTo(main);

// This is the second point where the main script releases control to the second

// script. Again, print diagnostics, and release control back to the main.

System.out.printf("Second release - write = %s, num readers = %d\n",

lock.isWriteLocked(), lock.getReadLockCount());

releaseTo(main);

}

});

// Run the two scripts defined above.

new Scripter<UserCache>(main, second).execute();

}

}