conformance.naming

Class QueueTest

java.lang.Object

test.Test

conformance.naming.NamingTest

conformance.naming.QueueTest

public class QueueTest
extends NamingTest

Tests lock queueing.

This test starts five threads. The first two attempt to lock the root directory for shared access. The third attempts to lock it for exclusive access. The last two also attempt to take it for shared access. It then ensures that the following are true:

• The first two threads are able to take the lock simultaneously. Likewise with the last two threads.
• The exclusive access thread - the third thread - cannot take the lock until after the first two threads are done.
• The exclusive access thread takes the lock before the last two threads.

Note that each thread is started and allowed to try to take the lock before the next thread, but no thread releases the lock until all threads have been started. This allows all the threads to queue in the lock method before the rest of the test precedes.

Threads should be served from the queue in the order they arrived. Shared access threads arriving after an exclusive access thread is queued should not be able to take the lock ahead of the shared access user.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
private class	QueueTest.QueuedLockUser Queueing thread.

Field Summary

Fields

Modifier and Type	Field and Description
private boolean	all_threads_started Indicates that all threads have been started and have most likely queued at the lock.
private static int	DELAY Delay between thread starts, in milliseconds.
private int	lock_count Number of threads that have succesfully locked the root directory.
static java.lang.String	notice Test notice.
static java.lang.Class[]	prerequisites Prerequisites.
private boolean	rendezvous_first Used to determine whether the current shared access user is the first at the rendezvous, and therefore should wait, or is the second, and therefore should wake the other thread.
private Path	root Path to the root directory.
private int	thread_exits Number of threads that have released the lock on the root directory.
private boolean	wake_all Indicates that the test is complete and any sleeping threads should be awakened.

Fields inherited from class conformance.naming.NamingTest

registration_stub, service_stub

Constructor Summary

Constructors

Constructor and Description
QueueTest()

Method Summary

Modifier and Type	Method and Description
protected void	clean() Wakes all threads.
protected void	perform() Performs the test.
private void	startThread(boolean exclusive, int expect_lock_count) Starts a thread and gives it time to enter the root directory lock's queue.

Methods inherited from class conformance.naming.NamingTest

initialize

Methods inherited from class test.Test

cleanupFailure, cleanupSuccess, failure, success, task, task

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

notice

public static final java.lang.String notice

Test notice.

See Also:

Constant Field Values

prerequisites

public static final java.lang.Class[] prerequisites

Prerequisites.

root

private final Path root

Path to the root directory.

all_threads_started

private boolean all_threads_started

Indicates that all threads have been started and have most likely queued at the lock.

lock_count

private int lock_count

Number of threads that have succesfully locked the root directory. Each thread expects this not to exceed some other number.

rendezvous_first

private boolean rendezvous_first

Used to determine whether the current shared access user is the first at the rendezvous, and therefore should wait, or is the second, and therefore should wake the other thread.

thread_exits

private int thread_exits

Number of threads that have released the lock on the root directory. Used to determine whether the test is complete.

DELAY

private static final int DELAY

Delay between thread starts, in milliseconds. This is long enough to make it very likely that each new thread will call lock and enter the lock's queue before the next thread started does so.

See Also:

Constant Field Values

wake_all

private boolean wake_all

Indicates that the test is complete and any sleeping threads should be awakened.

Constructor Detail

QueueTest

public QueueTest()

Method Detail

perform

protected void perform()

Performs the test.

Specified by:

perform in class Test

startThread

private void startThread(boolean exclusive,
                         int expect_lock_count)

Starts a thread and gives it time to enter the root directory lock's queue.

Parameters:

exclusive - Whether or not the thread is to request exclusive access to the root directory.

expect_lock_count - Number of threads the new thread expects to have taken the lock by the time it does so.

clean

protected void clean()

Wakes all threads.

Overrides:

clean in class NamingTest