/**@class jsr166.AbstractQueuedLongSynchronizerTest
@extends jsr166.JSR166TestCase

*/
var AbstractQueuedLongSynchronizerTest = {

/**isHeldExclusively is false upon construction
*/
testIsHeldExclusively : function(  ) {},

/**acquiring released sync succeeds
*/
testAcquire : function(  ) {},

/**tryAcquire on a released sync succeeds
*/
testTryAcquire : function(  ) {},

/**hasQueuedThreads reports whether there are waiting threads
*/
testHasQueuedThreads : function(  ) {},

/**isQueued(null) throws NullPointerException
*/
testIsQueuedNPE : function(  ) {},

/**isQueued reports whether a thread is queued
*/
testIsQueued : function(  ) {},

/**getFirstQueuedThread returns first waiting thread or null if none
*/
testGetFirstQueuedThread : function(  ) {},

/**hasContended reports false if no thread has ever blocked, else true
*/
testHasContended : function(  ) {},

/**getQueuedThreads returns all waiting threads
*/
testGetQueuedThreads : function(  ) {},

/**getExclusiveQueuedThreads returns all exclusive waiting threads
*/
testGetExclusiveQueuedThreads : function(  ) {},

/**getSharedQueuedThreads does not include exclusively waiting threads
*/
testGetSharedQueuedThreads_Exclusive : function(  ) {},

/**getSharedQueuedThreads returns all shared waiting threads
*/
testGetSharedQueuedThreads_Shared : function(  ) {},

/**tryAcquireNanos is interruptible
*/
testTryAcquireNanos_Interruptible : function(  ) {},

/**tryAcquire on exclusively held sync fails
*/
testTryAcquireWhenSynced : function(  ) {},

/**tryAcquireNanos on an exclusively held sync times out
*/
testAcquireNanos_Timeout : function(  ) {},

/**getState is true when acquired and false when not
*/
testGetState : function(  ) {},

/**acquireInterruptibly succeeds when released, else is interruptible
*/
testAcquireInterruptibly : function(  ) {},

/**owns is true for a condition created by sync else false
*/
testOwns : function(  ) {},

/**Calling await without holding sync throws IllegalMonitorStateException
*/
testAwait_IMSE : function(  ) {},

/**Calling signal without holding sync throws IllegalMonitorStateException
*/
testSignal_IMSE : function(  ) {},

/**Calling signalAll without holding sync throws IllegalMonitorStateException
*/
testSignalAll_IMSE : function(  ) {},

/**await/awaitNanos/awaitUntil without a signal times out
*/
testAwaitTimed_Timeout : function(  ) {},

/**
*/
testAwaitNanos_Timeout : function(  ) {},

/**
*/
testAwaitUntil_Timeout : function(  ) {},

/**
*/
testAwait_Timeout : function(  ) {},

/**await/awaitNanos/awaitUntil returns when signalled
*/
testSignal_await : function(  ) {},

/**
*/
testSignal_awaitTimed : function(  ) {},

/**
*/
testSignal_awaitNanos : function(  ) {},

/**
*/
testSignal_awaitUntil : function(  ) {},

/**
*/
testSignal : function(  ) {},

/**hasWaiters(null) throws NullPointerException
*/
testHasWaitersNPE : function(  ) {},

/**getWaitQueueLength(null) throws NullPointerException
*/
testGetWaitQueueLengthNPE : function(  ) {},

/**getWaitingThreads throws NPE if null
*/
testGetWaitingThreadsNPE : function(  ) {},

/**hasWaiters throws IllegalArgumentException if not owned
*/
testHasWaitersIAE : function(  ) {},

/**hasWaiters throws IllegalMonitorStateException if not synced
*/
testHasWaitersIMSE : function(  ) {},

/**getWaitQueueLength throws IllegalArgumentException if not owned
*/
testGetWaitQueueLengthIAE : function(  ) {},

/**getWaitQueueLength throws IllegalMonitorStateException if not synced
*/
testGetWaitQueueLengthIMSE : function(  ) {},

/**getWaitingThreads throws IllegalArgumentException if not owned
*/
testGetWaitingThreadsIAE : function(  ) {},

/**getWaitingThreads throws IllegalMonitorStateException if not synced
*/
testGetWaitingThreadsIMSE : function(  ) {},

/**hasWaiters returns true when a thread is waiting, else false
*/
testHasWaiters : function(  ) {},

/**getWaitQueueLength returns number of waiting threads
*/
testGetWaitQueueLength : function(  ) {},

/**getWaitingThreads returns only and all waiting threads
*/
testGetWaitingThreads : function(  ) {},

/**awaitUninterruptibly is uninterruptible
*/
testAwaitUninterruptibly : function(  ) {},

/**await/awaitNanos/awaitUntil is interruptible
*/
testInterruptible_await : function(  ) {},

/**
*/
testInterruptible_awaitTimed : function(  ) {},

/**
*/
testInterruptible_awaitNanos : function(  ) {},

/**
*/
testInterruptible_awaitUntil : function(  ) {},

/**
*/
testInterruptible : function(  ) {},

/**signalAll wakes up all threads
*/
testSignalAll_await : function(  ) {},

/**
*/
testSignalAll_awaitTimed : function(  ) {},

/**
*/
testSignalAll_awaitNanos : function(  ) {},

/**
*/
testSignalAll_awaitUntil : function(  ) {},

/**
*/
testSignalAll : function(  ) {},

/**toString indicates current state
*/
testToString : function(  ) {},

/**A serialized AQS deserializes with current state, but no queued threads
*/
testSerialization : function(  ) {},

/**tryReleaseShared setting state changes getState
*/
testGetStateWithReleaseShared : function(  ) {},

/**releaseShared has no effect when already signalled
*/
testReleaseShared : function(  ) {},

/**acquireSharedInterruptibly returns after release, but not before
*/
testAcquireSharedInterruptibly : function(  ) {},

/**tryAcquireSharedNanos returns after release, but not before
*/
testTryAcquireSharedNanos : function(  ) {},

/**acquireSharedInterruptibly is interruptible
*/
testAcquireSharedInterruptibly_Interruptible : function(  ) {},

/**tryAcquireSharedNanos is interruptible
*/
testTryAcquireSharedNanos_Interruptible : function(  ) {},

/**tryAcquireSharedNanos times out if not released before timeout
*/
testTryAcquireSharedNanos_Timeout : function(  ) {},

/**awaitNanos/timed await with 0 wait times out immediately
*/
testAwait_Zero : function(  ) {},

/**awaitNanos/timed await with maximum negative wait times does not underflow
*/
testAwait_NegativeInfinity : function(  ) {},


};