public void TestGetWaitQueueLength()
        {
            Mutex sync = new Mutex();
            AbstractQueuedSynchronizer.ConditionObject c = sync.NewCondition();
            Pair data = new Pair(sync, c);

            Thread t1 = new Thread(TestGetWaitQueueLengthRunnable1);
            Thread t2 = new Thread(TestGetWaitQueueLengthRunnable2);

            try
            {
                t1.Start(data);
                Thread.Sleep(SHORT_DELAY_MS);
                t2.Start(data);
                Thread.Sleep(SHORT_DELAY_MS);
                sync.Acquire(1);
                Assert.IsTrue(sync.HasWaiters(c));
                Assert.AreEqual(2, sync.GetWaitQueueLength(c));
                c.SignalAll();
                sync.Release(1);
                Thread.Sleep(SHORT_DELAY_MS);
                sync.Acquire(1);
                Assert.IsFalse(sync.HasWaiters(c));
                Assert.AreEqual(0, sync.GetWaitQueueLength(c));
                sync.Release(1);
                t1.Join(SHORT_DELAY_MS);
                t2.Join(SHORT_DELAY_MS);
                Assert.IsFalse(t1.IsAlive);
                Assert.IsFalse(t2.IsAlive);
            }
            catch (Exception e)
            {
                UnexpectedException(e);
            }
        }
        public void TestGetWaitQueueLengthAE()
        {
            Mutex sync = new Mutex();
            AbstractQueuedSynchronizer.ConditionObject c = (sync.NewCondition());
            Mutex sync2 = new Mutex();

            try
            {
                sync2.GetWaitQueueLength(c);
                ShouldThrow();
            }
            catch (ArgumentException)
            {
            }
            catch (Exception e)
            {
                UnexpectedException(e);
            }
        }
        public void TestGetWaitingThreadsTSE()
        {
            Mutex sync = new Mutex();
            AbstractQueuedSynchronizer.ConditionObject c = (sync.NewCondition());

            try
            {
                sync.GetWaitingThreads(c);
                ShouldThrow();
            }
            catch (ThreadStateException)
            {
            }
            catch (Exception e)
            {
                UnexpectedException(e);
            }
        }
        public void TestAwait()
        {
            Mutex sync = new Mutex();
            AbstractQueuedSynchronizer.ConditionObject c = sync.NewCondition();
            Pair data = new Pair(sync, c);
            Thread t = new Thread(TestAwaitRunnable);

            try
            {
                t.Start(data);
                Thread.Sleep(SHORT_DELAY_MS);
                sync.Acquire(1);
                c.Signal();
                sync.Release(1);
                t.Join(SHORT_DELAY_MS);
                Assert.IsFalse(t.IsAlive);
            }
            catch (Exception e)
            {
                UnexpectedException(e);
            }
        }
        public void TestAwaitUntilTimeout()
        {
            Mutex sync = new Mutex();
            AbstractQueuedSynchronizer.ConditionObject c = sync.NewCondition();

            try
            {
                sync.Acquire(1);
                DateTime deadline = DateTime.Now;
                Assert.IsFalse(c.AwaitUntil(deadline.AddSeconds(5)));
                sync.Release(1);
            }
            catch (Exception e)
            {
                UnexpectedException(e);
            }
        }
 public void TestAwaitTimeout()
 {
     Mutex sync = new Mutex();
     AbstractQueuedSynchronizer.ConditionObject c = sync.NewCondition();
     try
     {
         sync.Acquire(1);
         Assert.IsFalse(c.Await(SHORT_DELAY_MS) > 0);
         sync.Release(1);
     }
     catch (Exception e)
     {
         UnexpectedException(e);
     }
 }
 public void TestSignalThreadStateException()
 {
     Mutex sync = new Mutex();
     AbstractQueuedSynchronizer.ConditionObject c = sync.NewCondition();
     try
     {
         c.Signal();
         ShouldThrow();
     }
     catch (ThreadStateException)
     {
     }
     catch (Exception e)
     {
         UnexpectedException(e);
     }
 }
 public void TestOwns()
 {
     Mutex sync = new Mutex();
     AbstractQueuedSynchronizer.ConditionObject c = sync.NewCondition();
     Mutex sync2 = new Mutex();
     Assert.IsTrue(sync.Owns(c));
     Assert.IsFalse(sync2.Owns(c));
 }