TestCases to understand Thread.State

Explainations of Thread.State:
/**
* Thread state for a thread which has not yet started.
*/
NEW,

/**
* Thread state for a runnable thread. A thread in the runnable
* state is executing in the Java virtual machine but it may
* be waiting for other resources from the operating system
* such as processor.
*/
RUNNABLE,

/**
* Thread state for a thread blocked waiting for a monitor lock.
* A thread in the blocked state is waiting for a monitor lock
* to enter a synchronized block/method or
* reenter a synchronized block/method after calling
* {@link Object#wait() Object.wait}.
*/
BLOCKED,

/**
* Thread state for a waiting thread.
* A thread is in the waiting state due to calling one of the
* following methods:
* <ul>
* <li>{@link Object#wait() Object.wait} with no timeout</li>
* <li>{@link Thread#join() Thread.join} with no timeout</li>
* <li>{@link LockSupport#park() LockSupport.park}</li>
* </ul>
*
* <p>A thread in the waiting state is waiting for another thread to
* perform a particular action.
*
* For example, a thread that has called <tt>Object.wait()</tt>
* on an object is waiting for another thread to call
* <tt>Object.notify()</tt> or <tt>Object.notifyAll()</tt> on
* that object. A thread that has called <tt>Thread.join()</tt>
* is waiting for a specified thread to terminate.
*/
WAITING,

/**
* Thread state for a waiting thread with a specified waiting time.
* A thread is in the timed waiting state due to calling one of
* the following methods with a specified positive waiting time:
* <ul>
* <li>{@link Thread#sleep Thread.sleep}</li>
* <li>{@link Object#wait(long) Object.wait} with timeout</li>
* <li>{@link Thread#join(long) Thread.join} with timeout</li>
* <li>{@link LockSupport#parkNanos LockSupport.parkNanos}</li>
* <li>{@link LockSupport#parkUntil LockSupport.parkUntil}</li>
* </ul>
*/
TIMED_WAITING,

/**
* Thread state for a terminated thread.
* The thread has completed execution.
*/
TERMINATED;
}


TestCases to understand Thread.State:
import junit.framework.TestCase;
import junit.framework.Assert;

public class ThreadStateTest extends TestCase {
private Thread thread;

public void setUp()throws Exception
{
super.setUp();
thread = new Thread();
}
public void [color=red]testThreadIsInNewStateAfterConstructedBeforeStarted[/color]()
{
Assert.assertEquals(Thread.State.NEW, thread.getState());

thread.start();
Assert.assertTrue("Thread state is not NEW after call of start()",Thread.State.NEW != thread.getState());
}

public void [color=red]testThreadIsInRunnableStateAfterStarted[/color]()
{
thread.start();
Assert.assertEquals(Thread.State.RUNNABLE, thread.getState());
}

public void [color=red]testThreadIsInWaitingState[/color](){
thread = new Thread()
{
private Object lock = new Object();
public void run()
{
synchronized(lock)
{
try{
System.out.println("Getting into lock.wait()");
lock.wait();
}catch(InterruptedException interruptedEx)
{
interruptedEx.printStackTrace();
}
}
}
};
thread.start();

//here hold a sec,make sure this thread gets the monitor.
holdASec();
Assert.assertEquals(Thread.State.WAITING,thread.getState());
}

public void [color=red]testThreadIsInTimedWaitingState[/color](){
thread = new Thread()
{
private Object lock = new Object();
public void run()
{
synchronized(lock)
{
try{
System.out.println("Getting into lock.wait(time)");
lock.wait(50000);
}catch(InterruptedException interruptedEx)
{
interruptedEx.printStackTrace();
}
}
}
};
thread.start();

//here hold a sec,make sure this thread gets the monitor.
holdASec();
Assert.assertEquals(Thread.State.TIMED_WAITING,thread.getState());
}

public void [color=red]testThreadIsInBlockStateWhenWaitingToGetMonitor[/color]()
{
final Object sharedLock = new Object();

Thread anotherThreadHoldsTheLockForAWhile = new Thread()
{
public void run()
{
synchronized(sharedLock)
{
System.out.println(getName() + "holding sharedLock");

try{
Thread.sleep(50000);
}catch(InterruptedException e)
{
e.printStackTrace();
}
}
}
};
anotherThreadHoldsTheLockForAWhile.start();

//holds a sec to ensure the thread anotherThreadHoldsTheLockForAWhile got the sharedLock first
holdASec();
thread = new Thread()
{
public void run()
{
synchronized(sharedLock)
{
System.out.println("Got the lock");
}
}
};
thread.start();
holdASec();
Assert.assertEquals(Thread.State.BLOCKED, thread.getState());
}

public void [color=red]testThreadIsInTerminatedStateAfterCompletion[/color]()
{
thread.start();
holdASec();
Assert.assertEquals(Thread.State.TERMINATED, thread.getState());
}

private void holdASec()
{
try{
Thread.sleep(5000);
}catch(InterruptedException e)
{
e.printStackTrace();
}
}
}