コード例 #1
0
        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);
            }
        }
コード例 #2
0
        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);
            }
        }
コード例 #3
0
        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);
            }
        }
コード例 #4
0
        public void TestAcquireInterruptibly1()
        {
            Mutex sync = new Mutex();
            sync.Acquire(1);
            Thread t = new Thread(InterruptedSyncRunnable);

            try
            {
                t.Start(sync);
                Thread.Sleep(SHORT_DELAY_MS);
                t.Interrupt();
                Thread.Sleep(SHORT_DELAY_MS);
                sync.Release(1);
                t.Join();
            }
            catch(Exception e)
            {
                UnexpectedException(e);
            }
        }
コード例 #5
0
 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);
     }
 }
コード例 #6
0
        public void TestAcquireTimedTimeout()
        {
            Mutex sync = new Mutex();
            sync.Acquire(1);
            Thread t = new Thread(TestAcquireTimedTimeoutRunnable);

            try
            {
                t.Start(sync);
                t.Join();
                sync.Release(1);
            }
            catch (Exception e)
            {
                UnexpectedException(e);
            }
        }
コード例 #7
0
        public void TestGetState()
        {
            Mutex sync = new Mutex();
            sync.Acquire(1);
            Assert.IsTrue(sync.AccessIsHeldExclusively());
            sync.Release(1);
            Assert.IsFalse(sync.AccessIsHeldExclusively());
            Thread t = new Thread(TestGetStateRunnable);

            try
            {
                t.Start(sync);
                Thread.Sleep(SHORT_DELAY_MS);
                Assert.IsTrue(sync.AccessIsHeldExclusively());
                t.Join();
                Assert.IsFalse(sync.AccessIsHeldExclusively());
            }
            catch(Exception e)
            {
                UnexpectedException(e);
            }
        }
コード例 #8
0
        public void TestThreadInterruptedException2()
        {
            Mutex sync = new Mutex();
            sync.Acquire(1);
            Thread t = new Thread(TestThreadInterruptedException2Rannable);

            try
            {
                t.Start(sync);
                t.Interrupt();
                t.Join();
            }
            catch(Exception e)
            {
                UnexpectedException(e);
            }
        }
コード例 #9
0
        public void TestTryAcquireWhenSynced()
        {
            Mutex sync = new Mutex();
            sync.Acquire(1);
            Thread t = new Thread(TestTryAcquireWhenSyncedRunnable);

            try
            {
                t.Start(sync);
                t.Join();
                sync.Release(1);
            }
            catch(Exception e)
            {
                UnexpectedException(e);
            }
        }
コード例 #10
0
 public void TestGetSharedQueuedThreads()
 {
     Mutex sync = new Mutex();
     Thread t1 = new Thread(InterruptedSyncRunnable);
     Thread t2 = new Thread(InterruptibleSyncRunnable);
     try {
         Assert.IsTrue(sync.SharedQueuedThreads.IsEmpty());
         sync.Acquire(1);
         Assert.IsTrue(sync.SharedQueuedThreads.IsEmpty());
         t1.Start(sync);
         Thread.Sleep(SHORT_DELAY_MS);
         Assert.IsTrue(sync.SharedQueuedThreads.IsEmpty());
         t2.Start(sync);
         Thread.Sleep(SHORT_DELAY_MS);
         Assert.IsTrue(sync.SharedQueuedThreads.IsEmpty());
         t1.Interrupt();
         Thread.Sleep(SHORT_DELAY_MS);
         Assert.IsTrue(sync.SharedQueuedThreads.IsEmpty());
         sync.Release(1);
         Thread.Sleep(SHORT_DELAY_MS);
         Assert.IsTrue(sync.SharedQueuedThreads.IsEmpty());
         t1.Join();
         t2.Join();
     }
     catch(Exception e)
     {
         UnexpectedException(e);
     }
 }
コード例 #11
0
 public void TestHasContended()
 {
     Mutex sync = new Mutex();
     Thread t1 = new Thread(InterruptedSyncRunnable);
     Thread t2 = new Thread(InterruptibleSyncRunnable);
     try
     {
         Assert.IsFalse(sync.HasContended);
         sync.Acquire(1);
         t1.Start(sync);
         Thread.Sleep(SHORT_DELAY_MS);
         Assert.IsTrue(sync.HasContended);
         t2.Start(sync);
         Thread.Sleep(SHORT_DELAY_MS);
         Assert.IsTrue(sync.HasContended);
         t1.Interrupt();
         Thread.Sleep(SHORT_DELAY_MS);
         Assert.IsTrue(sync.HasContended);
         sync.Release(1);
         Thread.Sleep(SHORT_DELAY_MS);
         Assert.IsTrue(sync.HasContended);
         t1.Join();
         t2.Join();
     }
     catch(Exception e)
     {
         UnexpectedException(e);
     }
 }
コード例 #12
0
 public void TestGetFirstQueuedThread()
 {
     Mutex sync = new Mutex();
     Thread t1 = new Thread(InterruptedSyncRunnable);
     Thread t2 = new Thread(InterruptibleSyncRunnable);
     try
     {
         Assert.IsNull(sync.FirstQueuedThread);
         sync.Acquire(1);
         t1.Start(sync);
         Thread.Sleep(SHORT_DELAY_MS);
         Assert.AreEqual(t1, sync.FirstQueuedThread);
         t2.Start(sync);
         Thread.Sleep(SHORT_DELAY_MS);
         Assert.AreEqual(t1, sync.FirstQueuedThread);
         t1.Interrupt();
         Thread.Sleep(SHORT_DELAY_MS);
         Thread.Sleep(SHORT_DELAY_MS);
         Assert.AreEqual(t2, sync.FirstQueuedThread);
         sync.Release(1);
         Thread.Sleep(SHORT_DELAY_MS);
         Assert.IsNull(sync.FirstQueuedThread);
         t1.Join();
         t2.Join();
     }
     catch(Exception e)
     {
         UnexpectedException(e);
     }
 }
コード例 #13
0
 public void TestAcquire()
 {
     Mutex rl = new Mutex();
     rl.Acquire(1);
     Assert.IsTrue(rl.AccessIsHeldExclusively());
     rl.Release(1);
     Assert.IsFalse(rl.AccessIsHeldExclusively());
 }
コード例 #14
0
 public void TestToString()
 {
     Mutex sync = new Mutex();
     String us = sync.ToString();
     Assert.IsTrue(us.IndexOf("State = 0") >= 0);
     sync.Acquire(1);
     String ls = sync.ToString();
     Assert.IsTrue(ls.IndexOf("State = 1") >= 0);
 }