using J2N.Threading;
using J2N.Threading.Atomic;
using Lucene.Net.Attributes;
using Lucene.Net.Support.Threading;
using Lucene.Net.Util;
using NUnit.Framework;
using RandomizedTesting.Generators;
using System;
using System.Collections.Generic;
using System.Drawing;
using System.Threading;
using System.Threading.Tasks;
using Assert = Lucene.Net.TestFramework.Assert;

namespace Lucene.Net.Support.Threading
{
    /*
     * Licensed to the Apache Software Foundation (ASF) under one or more
     * contributor license agreements.  See the NOTICE file distributed with
     * this work for additional information regarding copyright ownership.
     * The ASF licenses this file to You under the Apache License, Version 2.0
     * (the "License"); you may not use this file except in compliance with
     * the License.  You may obtain a copy of the License at
     *
     *     http://www.apache.org/licenses/LICENSE-2.0
     *
     * Unless required by applicable law or agreed to in writing, software
     * distributed under the License is distributed on an "AS IS" BASIS,
     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     * See the License for the specific language governing permissions and
     * limitations under the License.
     */

    [TestFixture]
    public class ReentrantLockTest : JSR166TestCase
    {
        //public static void main(String[] args)
        //{
        //    junit.textui.TestRunner.run(suite());
        //}
        //public static Test suite()
        //{
        //    return new TestSuite(ReentrantLockTest.class);
        //}

        /**
        * A runnable calling lockInterruptibly
        */
        private class InterruptibleLockRunnable : ThreadJob
        {
            private readonly ReentrantLock @lock;
            public InterruptibleLockRunnable(ReentrantLock l)
            {
                @lock = l;
            }

            public override void Run()
            {
                try
                {
#pragma warning disable 612, 618
                    @lock.LockInterruptibly();
#pragma warning restore 612, 618
                }
                catch (System.Threading.ThreadInterruptedException)
                {
                    // success
                }
            }
        }

        /**
         * A runnable calling lockInterruptibly that expects to be
         * interrupted
         */
        private class InterruptedLockRunnable : ThreadJob
        {
            private readonly ReentrantLockTest outerInstance;
            private readonly ReentrantLock @lock;
            public InterruptedLockRunnable(ReentrantLockTest outerInstance, ReentrantLock l)
            {
                this.outerInstance = outerInstance;
                @lock = l;
            }

            public override void Run()
            {
                try
                {
#pragma warning disable 612, 618
                    @lock.LockInterruptibly();
#pragma warning restore 612, 618
                    outerInstance.threadShouldThrow();
                }
                catch (System.Threading.ThreadInterruptedException)
                {
                    // success
                }
            }
        }

        ///**
        // * Subclass to expose protected methods
        // */
        //static class PublicReentrantLock extends ReentrantLock
        //{
        //    PublicReentrantLock() { super(); }
        //    public Collection<Thread> getQueuedThreads()
        //    {
        //        return super.getQueuedThreads();
        //    }
        //    public Collection<Thread> getWaitingThreads(Condition c)
        //    {
        //        return super.getWaitingThreads(c);
        //    }


        //}

        ///**
        // * Constructor sets given fairness
        // */
        //public void testConstructor()
        //{
        //    ReentrantLock rl = new ReentrantLock();
        //    assertFalse(rl.isFair());
        //    ReentrantLock r2 = new ReentrantLock(true);
        //    assertTrue(r2.isFair());
        //}

        ///**
        // * locking an unlocked lock succeeds
        // */
        //[Test]
        //public void TestLock()
        //{
        //    ReentrantLock rl = new ReentrantLock();
        //    rl.Lock();
        //    assertTrue(rl.IsLocked);
        //    rl.Unlock();
        //}

        ///**
        // * locking an unlocked fair lock succeeds
        // */
        //public void testFairLock()
        //{
        //    ReentrantLock rl = new ReentrantLock(true);
        //    rl.lock () ;
        //    assertTrue(rl.isLocked());
        //    rl.unlock();
        //}


        /**
         * Unlocking an unlocked lock throws IllegalMonitorStateException
         */
        [Test]
        public void TestUnlock_IllegalMonitorStateException()
        {
            ReentrantLock rl = new ReentrantLock();

            try
            {
                rl.Unlock();
                shouldThrow();
            }
            catch (SynchronizationLockException)
            {
                // success
            }
        }

        ///**
        // * tryLock on an unlocked lock succeeds
        // */
        //[Test]
        //public void TestTryLock()
        //{
        //    ReentrantLock rl = new ReentrantLock();
        //    assertTrue(rl.TryLock());
        //    assertTrue(rl.IsLocked);
        //    rl.Unlock();
        //}


        ///**
        // * hasQueuedThreads reports whether there are waiting threads
        // */
        //[Test]
        //[Ignore("Behavior differs from Java around interrupts, but Lucene.NET doesn't support interrupts or use this property.")]
        //public void TesthasQueuedThreads()
        //{
        //    ReentrantLock @lock = new ReentrantLock();
        //    ThreadJob t1 = new InterruptedLockRunnable(this, @lock);
        //    ThreadJob t2 = new InterruptibleLockRunnable(@lock);
        //    try
        //    {
        //        assertFalse(@lock.HasQueuedThreads);
        //        @lock.Lock();
        //        t1.Start();
        //        Thread.Sleep(SHORT_DELAY_MS);
        //        assertTrue(@lock.HasQueuedThreads);
        //        t2.Start();
        //        Thread.Sleep(SHORT_DELAY_MS);
        //        assertTrue(@lock.HasQueuedThreads);
        //        t1.Interrupt();
        //        Thread.Sleep(SHORT_DELAY_MS);
        //        assertTrue(@lock.HasQueuedThreads);
        //        @lock.Unlock();
        //        Thread.Sleep(SHORT_DELAY_MS);
        //        //assertFalse(@lock.HasQueuedThreads); // LUCENENET: Behavior differs from Java around interrupts, but Lucene.NET doesn't support interrupts or use this property.
        //        t1.Join();
        //        t2.Join();

        //        assertFalse(@lock.HasQueuedThreads); // LUCENENET: Added assert
        //    }
        //    catch (Exception e) when (e.IsException())
        //    {
        //        unexpectedException();
        //    }
        //}

        ///**
        // * getQueueLength reports number of waiting threads
        // */
        //[Test]
        //[Ignore("Behavior differs from Java around interrupts, but Lucene.NET doesn't support interrupts or use this property.")]
        //public void TestGetQueueLength()
        //{
        //    ReentrantLock @lock = new ReentrantLock();
        //    ThreadJob t1 = new InterruptedLockRunnable(this, @lock);
        //    ThreadJob t2 = new InterruptibleLockRunnable(@lock);
        //    try
        //    {
        //        assertEquals(0, @lock.QueueLength);
        //        @lock.Lock();
        //        t1.Start();
        //        Thread.Sleep(SHORT_DELAY_MS);
        //        assertEquals(1, @lock.QueueLength);
        //        t2.Start();
        //        Thread.Sleep(SHORT_DELAY_MS);
        //        assertEquals(2, @lock.QueueLength);
        //        t1.Interrupt();
        //        Thread.Sleep(SHORT_DELAY_MS);
        //        assertEquals(1, @lock.QueueLength);
        //        @lock.Unlock();
        //        Thread.Sleep(SHORT_DELAY_MS);
        //        //assertEquals(0, @lock.QueueLength); // LUCENENET: Behavior differs from Java around interrupts, but Lucene.NET doesn't support interrupts or use this property.
        //        t1.Join();
        //        t2.Join();

        //        assertEquals(0, @lock.QueueLength); // LUCENENET: Added assert
        //    }
        //    catch (Exception e) when (e.IsException())
        //    {
        //        unexpectedException();
        //    }
        //}

        ///**
        // * getQueueLength reports number of waiting threads
        // */
        //public void testGetQueueLength_fair()
        //{
        //    final ReentrantLock lock = new ReentrantLock(true);
        //    Thread t1 = new Thread(new InterruptedLockRunnable(lock));
        //    Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
        //    try
        //    {
        //        assertEquals(0, lock.getQueueLength()) ;
        //        lock.lock () ;
        //        t1.start();
        //        Thread.sleep(SHORT_DELAY_MS);
        //        assertEquals(1, lock.getQueueLength()) ;
        //        t2.start();
        //        Thread.sleep(SHORT_DELAY_MS);
        //        assertEquals(2, lock.getQueueLength()) ;
        //        t1.interrupt();
        //        Thread.sleep(SHORT_DELAY_MS);
        //        assertEquals(1, lock.getQueueLength()) ;
        //        lock.unlock();
        //        Thread.sleep(SHORT_DELAY_MS);
        //        assertEquals(0, lock.getQueueLength()) ;
        //        t1.join();
        //        t2.join();
        //    }
        //    catch (Exception e)
        //    {
        //        unexpectedException();
        //    }
        //}

        ///**
        // * hasQueuedThread(null) throws NPE
        // */
        //public void testHasQueuedThreadNPE()
        //{
        //    final ReentrantLock sync = new ReentrantLock();
        //    try
        //    {
        //        sync.hasQueuedThread(null);
        //        shouldThrow();
        //    }
        //    catch (NullPointerException success)
        //    {
        //    }
        //}

        ///**
        // * hasQueuedThread reports whether a thread is queued.
        // */
        //public void testHasQueuedThread()
        //{
        //    final ReentrantLock sync = new ReentrantLock();
        //    Thread t1 = new Thread(new InterruptedLockRunnable(sync));
        //    Thread t2 = new Thread(new InterruptibleLockRunnable(sync));
        //    try
        //    {
        //        assertFalse(sync.hasQueuedThread(t1));
        //        assertFalse(sync.hasQueuedThread(t2));
        //        sync.lock () ;
        //        t1.start();
        //        Thread.sleep(SHORT_DELAY_MS);
        //        assertTrue(sync.hasQueuedThread(t1));
        //        t2.start();
        //        Thread.sleep(SHORT_DELAY_MS);
        //        assertTrue(sync.hasQueuedThread(t1));
        //        assertTrue(sync.hasQueuedThread(t2));
        //        t1.interrupt();
        //        Thread.sleep(SHORT_DELAY_MS);
        //        assertFalse(sync.hasQueuedThread(t1));
        //        assertTrue(sync.hasQueuedThread(t2));
        //        sync.unlock();
        //        Thread.sleep(SHORT_DELAY_MS);
        //        assertFalse(sync.hasQueuedThread(t1));
        //        Thread.sleep(SHORT_DELAY_MS);
        //        assertFalse(sync.hasQueuedThread(t2));
        //        t1.join();
        //        t2.join();
        //    }
        //    catch (Exception e)
        //    {
        //        unexpectedException();
        //    }
        //}


        ///**
        // * getQueuedThreads includes waiting threads
        // */
        //public void testGetQueuedThreads()
        //{
        //    final PublicReentrantLock lock = new PublicReentrantLock();
        //    Thread t1 = new Thread(new InterruptedLockRunnable(lock));
        //    Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
        //    try
        //    {
        //        assertTrue(lock.getQueuedThreads().isEmpty()) ;
        //        lock.lock () ;
        //        assertTrue(lock.getQueuedThreads().isEmpty()) ;
        //        t1.start();
        //        Thread.sleep(SHORT_DELAY_MS);
        //        assertTrue(lock.getQueuedThreads().contains(t1)) ;
        //        t2.start();
        //        Thread.sleep(SHORT_DELAY_MS);
        //        assertTrue(lock.getQueuedThreads().contains(t1)) ;
        //        assertTrue(lock.getQueuedThreads().contains(t2)) ;
        //        t1.interrupt();
        //        Thread.sleep(SHORT_DELAY_MS);
        //        assertFalse(lock.getQueuedThreads().contains(t1)) ;
        //        assertTrue(lock.getQueuedThreads().contains(t2)) ;
        //        lock.unlock();
        //        Thread.sleep(SHORT_DELAY_MS);
        //        assertTrue(lock.getQueuedThreads().isEmpty()) ;
        //        t1.join();
        //        t2.join();
        //    }
        //    catch (Exception e)
        //    {
        //        unexpectedException();
        //    }
        //}


        ///**
        // * timed tryLock is interruptible.
        // */
        //public void testInterruptedException2()
        //{
        //    final ReentrantLock lock = new ReentrantLock();
        //    lock.lock () ;
        //    Thread t = new Thread(new Runnable()
        //        {
        //            public void run()
        //        {
        //            try
        //            {
        //                lock.tryLock(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
        //                threadShouldThrow();
        //            }
        //            catch (InterruptedException success) { }
        //        }
        //    });
        //    try {
        //        t.start();
        //        t.interrupt();
        //    } catch(Exception e){
        //        unexpectedException();
        //    }
        //}

        /**
         * TryLock on a locked lock fails
         */
        [Test]
        public void TestTryLockWhenLocked()
        {
            ReentrantLock @lock = new ReentrantLock();
            @lock.Lock();
            Thread t = new Thread(() =>
            {
                threadAssertFalse(@lock.TryLock());
            });
            try
            {
                t.Start();
                t.Join();
                @lock.Unlock();
            }
            catch (Exception e) when (e.IsException())
            {
                unexpectedException();
            }
        }

        ///**
        // * Timed tryLock on a locked lock times out
        // */
        //public void testTryLock_Timeout()
        //{
        //    final ReentrantLock lock = new ReentrantLock();
        //    lock.lock () ;
        //    Thread t = new Thread(new Runnable()
        //        {
        //            public void run()
        //        {
        //            try
        //            {
        //                threadAssertFalse(lock.tryLock(1, TimeUnit.MILLISECONDS)) ;
        //            }
        //            catch (Exception ex)
        //            {
        //                threadUnexpectedException();
        //            }
        //        }
        //    });
        //    try {
        //        t.start();
        //        t.join();
        //        lock.unlock();
        //    } catch(Exception e){
        //        unexpectedException();
        //    }
        //}

        ///**
        // * getHoldCount returns number of recursive holds
        // */
        //[Test]
        //public void testGetHoldCount()
        //{
        //    ReentrantLock @lock = new ReentrantLock();
        //    for (int i = 1; i <= SIZE; i++)
        //    {
        //                @lock.lock () ;
        //        assertEquals(i, @lock.getHoldCount()) ;
        //    }
        //    for (int i = SIZE; i > 0; i--)
        //    {
        //                @lock.Unlock();
        //        assertEquals(i - 1, @lock.getHoldCount()) ;
        //    }
        //}


        ///**
        // * isLocked is true when locked and false when not
        // */
        //[Test]
        //public void TestIsLocked()
        //{
        //    ReentrantLock @lock = new ReentrantLock();
        //    @lock.Lock();
        //    assertTrue(@lock.IsLocked);
        //    @lock.Unlock();
        //    assertFalse(@lock.IsLocked);
        //    Thread t = new Thread(() =>
        //    {
        //        @lock.Lock();
        //        try
        //        {
        //            Thread.Sleep(SMALL_DELAY_MS);
        //        }
        //        catch (Exception e)
        //        {
        //            threadUnexpectedException();
        //        }
        //        @lock.Unlock();
        //    });

        //    try
        //    {
        //        t.Start();
        //        Thread.Sleep(SHORT_DELAY_MS);
        //        assertTrue(@lock.IsLocked);
        //        t.Join();
        //        assertFalse(@lock.IsLocked);
        //    }
        //    catch (Exception e) when (e.IsException())
        //    {
        //        unexpectedException();
        //    }
        //}

        /**
         * lockInterruptibly is interruptible.
         */
        [Test]
        [Ignore("LUCENENET: LockInterruptibly() is broken, but it is not in use anywhere but in the tests. Technically, Lucene.NET does not support Thread.Interrupt().")]
        public void TestLockInterruptibly1()
        {
            ReentrantLock @lock = new ReentrantLock();
            @lock.Lock();
            ThreadJob t = new InterruptedLockRunnable(this, @lock);
            try
            {
                t.Start();
                Thread.Sleep(SHORT_DELAY_MS);
                t.Interrupt();
                Thread.Sleep(SHORT_DELAY_MS);
                @lock.Unlock();
                t.Join();
            }
            catch (Exception e) when (e.IsException())
            {
                unexpectedException();
            }
        }

        ///**
        // * lockInterruptibly succeeds when unlocked, else is interruptible
        // */
        //[Test]
        //[Ignore("LUCENENET: LockInterruptibly() is broken, but it is not in use anywhere but in the tests. Technically, Lucene.NET does not support Thread.Interrupt().")]
        //public void TestLockInterruptibly2()
        //{
        //    ReentrantLock @lock = new ReentrantLock();
        //    try
        //    {
        //        @lock.LockInterruptibly();
        //    }
        //    catch (Exception e) when (e.IsException())
        //    {
        //        unexpectedException();
        //    }
        //    ThreadJob t = new InterruptedLockRunnable(this, @lock);
        //    try
        //    {
        //        t.Start();
        //        t.Interrupt();
        //        assertTrue(@lock.IsLocked);
        //        assertTrue(@lock.IsHeldByCurrentThread);
        //        t.Join();
        //    }
        //    catch (Exception e) when (e.IsException())
        //    {
        //        unexpectedException();
        //    }
        //}


        ///**
        // * Calling await without holding lock throws IllegalMonitorStateException
        // */
        //public void testAwait_IllegalMonitor()
        //{
        //    final ReentrantLock lock = new ReentrantLock();
        //    final Condition c = lock.newCondition();
        //    try
        //    {
        //        c.await();
        //        shouldThrow();
        //    }
        //    catch (IllegalMonitorStateException success)
        //    {
        //    }
        //    catch (Exception ex)
        //    {
        //        unexpectedException();
        //    }
        //}

        ///**
        // * Calling signal without holding lock throws IllegalMonitorStateException
        // */
        //public void testSignal_IllegalMonitor()
        //{
        //    final ReentrantLock lock = new ReentrantLock();
        //    final Condition c = lock.newCondition();
        //    try
        //    {
        //        c.signal();
        //        shouldThrow();
        //    }
        //    catch (IllegalMonitorStateException success)
        //    {
        //    }
        //    catch (Exception ex)
        //    {
        //        unexpectedException();
        //    }
        //}

        ///**
        // * awaitNanos without a signal times out
        // */
        //public void testAwaitNanos_Timeout()
        //{
        //    final ReentrantLock lock = new ReentrantLock();
        //    final Condition c = lock.newCondition();
        //    try
        //    {
        //        lock.lock () ;
        //        long t = c.awaitNanos(100);
        //        assertTrue(t <= 0);
        //        lock.unlock();
        //    }
        //    catch (Exception ex)
        //    {
        //        unexpectedException();
        //    }
        //}

        ///**
        // *  timed await without a signal times out
        // */
        //public void testAwait_Timeout()
        //{
        //    final ReentrantLock lock = new ReentrantLock();
        //    final Condition c = lock.newCondition();
        //    try
        //    {
        //        lock.lock () ;
        //        c.await(SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
        //        lock.unlock();
        //    }
        //    catch (Exception ex)
        //    {
        //        unexpectedException();
        //    }
        //}

        ///**
        // * awaitUntil without a signal times out
        // */
        //public void testAwaitUntil_Timeout()
        //{
        //    final ReentrantLock lock = new ReentrantLock();
        //    final Condition c = lock.newCondition();
        //    try
        //    {
        //        lock.lock () ;
        //        java.util.Date d = new java.util.Date();
        //        c.awaitUntil(new java.util.Date(d.getTime() + 10));
        //        lock.unlock();
        //    }
        //    catch (Exception ex)
        //    {
        //        unexpectedException();
        //    }
        //}

        ///**
        // * await returns when signalled
        // */
        //public void testAwait()
        //{
        //    final ReentrantLock lock = new ReentrantLock();
        //    final Condition c = lock.newCondition();
        //    Thread t = new Thread(new Runnable()
        //    {

        //        public void run()
        //        {
        //            try
        //            {
        //                lock.lock () ;
        //                c.await();
        //                lock.unlock();
        //            }
        //            catch (InterruptedException e)
        //            {
        //                threadUnexpectedException();
        //            }
        //        }
        //    });

        //    try {
        //        t.start();
        //        Thread.sleep(SHORT_DELAY_MS);
        //        lock.lock();
        //        c.signal();
        //        lock.unlock();
        //        t.join(SHORT_DELAY_MS);
        //        assertFalse(t.isAlive());
        //    }
        //    catch (Exception ex) {
        //        unexpectedException();
        //    }
        //}

        ///**
        // * hasWaiters throws NPE if null
        // */
        //public void testHasWaitersNPE()
        //{
        //    final ReentrantLock lock = new ReentrantLock();
        //    try
        //    {
        //        lock.hasWaiters(null);
        //        shouldThrow();
        //    }
        //    catch (NullPointerException success)
        //    {
        //    }
        //    catch (Exception ex)
        //    {
        //        unexpectedException();
        //    }
        //}

        ///**
        // * getWaitQueueLength throws NPE if null
        // */
        //public void testGetWaitQueueLengthNPE()
        //{
        //    final ReentrantLock lock = new ReentrantLock();
        //    try
        //    {
        //        lock.getWaitQueueLength(null);
        //        shouldThrow();
        //    }
        //    catch (NullPointerException success)
        //    {
        //    }
        //    catch (Exception ex)
        //    {
        //        unexpectedException();
        //    }
        //}


        ///**
        // * getWaitingThreads throws NPE if null
        // */
        //public void testGetWaitingThreadsNPE()
        //{
        //    final PublicReentrantLock lock = new PublicReentrantLock();
        //    try
        //    {
        //        lock.getWaitingThreads(null);
        //        shouldThrow();
        //    }
        //    catch (NullPointerException success)
        //    {
        //    }
        //    catch (Exception ex)
        //    {
        //        unexpectedException();
        //    }
        //}


        ///**
        // * hasWaiters throws IAE if not owned
        // */
        //public void testHasWaitersIAE()
        //{
        //    final ReentrantLock lock = new ReentrantLock();
        //    final Condition c = (lock.newCondition()) ;
        //    final ReentrantLock lock2 = new ReentrantLock();
        //    try
        //    {
        //        lock2.hasWaiters(c);
        //        shouldThrow();
        //    }
        //    catch (IllegalArgumentException success)
        //    {
        //    }
        //    catch (Exception ex)
        //    {
        //        unexpectedException();
        //    }
        //}

        ///**
        // * hasWaiters throws IMSE if not locked
        // */
        //public void testHasWaitersIMSE()
        //{
        //    final ReentrantLock lock = new ReentrantLock();
        //    final Condition c = (lock.newCondition()) ;
        //    try
        //    {
        //        lock.hasWaiters(c);
        //        shouldThrow();
        //    }
        //    catch (IllegalMonitorStateException success)
        //    {
        //    }
        //    catch (Exception ex)
        //    {
        //        unexpectedException();
        //    }
        //}


        ///**
        // * getWaitQueueLength throws IAE if not owned
        // */
        //public void testGetWaitQueueLengthIAE()
        //{
        //    final ReentrantLock lock = new ReentrantLock();
        //    final Condition c = (lock.newCondition()) ;
        //    final ReentrantLock lock2 = new ReentrantLock();
        //    try
        //    {
        //        lock2.getWaitQueueLength(c);
        //        shouldThrow();
        //    }
        //    catch (IllegalArgumentException success)
        //    {
        //    }
        //    catch (Exception ex)
        //    {
        //        unexpectedException();
        //    }
        //}

        ///**
        // * getWaitQueueLength throws IMSE if not locked
        // */
        //public void testGetWaitQueueLengthIMSE()
        //{
        //    final ReentrantLock lock = new ReentrantLock();
        //    final Condition c = (lock.newCondition()) ;
        //    try
        //    {
        //        lock.getWaitQueueLength(c);
        //        shouldThrow();
        //    }
        //    catch (IllegalMonitorStateException success)
        //    {
        //    }
        //    catch (Exception ex)
        //    {
        //        unexpectedException();
        //    }
        //}


        ///**
        // * getWaitingThreads throws IAE if not owned
        // */
        //public void testGetWaitingThreadsIAE()
        //{
        //    final PublicReentrantLock lock = new PublicReentrantLock();
        //    final Condition c = (lock.newCondition()) ;
        //    final PublicReentrantLock lock2 = new PublicReentrantLock();
        //    try
        //    {
        //        lock2.getWaitingThreads(c);
        //        shouldThrow();
        //    }
        //    catch (IllegalArgumentException success)
        //    {
        //    }
        //    catch (Exception ex)
        //    {
        //        unexpectedException();
        //    }
        //}

        ///**
        // * getWaitingThreads throws IMSE if not locked
        // */
        //public void testGetWaitingThreadsIMSE()
        //{
        //    final PublicReentrantLock lock = new PublicReentrantLock();
        //    final Condition c = (lock.newCondition()) ;
        //    try
        //    {
        //        lock.getWaitingThreads(c);
        //        shouldThrow();
        //    }
        //    catch (IllegalMonitorStateException success)
        //    {
        //    }
        //    catch (Exception ex)
        //    {
        //        unexpectedException();
        //    }
        //}


        ///**
        // * hasWaiters returns true when a thread is waiting, else false
        // */
        //public void testHasWaiters()
        //{
        //    final ReentrantLock lock = new ReentrantLock();
        //    final Condition c = lock.newCondition();
        //    Thread t = new Thread(new Runnable()
        //    {

        //        public void run()
        //        {
        //            try
        //            {
        //                lock.lock () ;
        //                threadAssertFalse(lock.hasWaiters(c)) ;
        //                threadAssertEquals(0, lock.getWaitQueueLength(c)) ;
        //                c.await();
        //                lock.unlock();
        //            }
        //            catch (InterruptedException e)
        //            {
        //                threadUnexpectedException();
        //            }
        //        }
        //    });

        //    try
        //    {
        //        t.start();
        //        Thread.sleep(SHORT_DELAY_MS);
        //        lock.lock () ;
        //        assertTrue(lock.hasWaiters(c)) ;
        //        assertEquals(1, lock.getWaitQueueLength(c)) ;
        //        c.signal();
        //        lock.unlock();
        //        Thread.sleep(SHORT_DELAY_MS);
        //        lock.lock () ;
        //        assertFalse(lock.hasWaiters(c)) ;
        //        assertEquals(0, lock.getWaitQueueLength(c)) ;
        //        lock.unlock();
        //        t.join(SHORT_DELAY_MS);
        //        assertFalse(t.isAlive());
        //    }
        //    catch (Exception ex)
        //    {
        //        unexpectedException();
        //    }
        //}

        ///**
        // * getWaitQueueLength returns number of waiting threads
        // */
        //public void testGetWaitQueueLength()
        //{
        //    final ReentrantLock lock = new ReentrantLock();
        //    final Condition c = lock.newCondition();
        //    Thread t1 = new Thread(new Runnable()
        //    {

        //        public void run()
        //        {
        //            try
        //            {
        //                lock.lock () ;
        //                threadAssertFalse(lock.hasWaiters(c)) ;
        //                threadAssertEquals(0, lock.getWaitQueueLength(c)) ;
        //                c.await();
        //                lock.unlock();
        //            }
        //            catch (InterruptedException e)
        //            {
        //                threadUnexpectedException();
        //            }
        //        }
        //    });

        //    Thread t2 = new Thread(new Runnable()
        //    {

        //        public void run()
        //        {
        //            try
        //            {
        //                lock.lock () ;
        //                threadAssertTrue(lock.hasWaiters(c)) ;
        //                threadAssertEquals(1, lock.getWaitQueueLength(c)) ;
        //                c.await();
        //                lock.unlock();
        //            }
        //            catch (InterruptedException e)
        //            {
        //                threadUnexpectedException();
        //            }
        //        }
        //    });

        //    try
        //    {
        //        t1.start();
        //        Thread.sleep(SHORT_DELAY_MS);
        //        t2.start();
        //        Thread.sleep(SHORT_DELAY_MS);
        //        lock.lock () ;
        //        assertTrue(lock.hasWaiters(c)) ;
        //        assertEquals(2, lock.getWaitQueueLength(c)) ;
        //        c.signalAll();
        //        lock.unlock();
        //        Thread.sleep(SHORT_DELAY_MS);
        //        lock.lock () ;
        //        assertFalse(lock.hasWaiters(c)) ;
        //        assertEquals(0, lock.getWaitQueueLength(c)) ;
        //        lock.unlock();
        //        t1.join(SHORT_DELAY_MS);
        //        t2.join(SHORT_DELAY_MS);
        //        assertFalse(t1.isAlive());
        //        assertFalse(t2.isAlive());
        //    }
        //    catch (Exception ex)
        //    {
        //        unexpectedException();
        //    }
        //}

        ///**
        // * getWaitingThreads returns only and all waiting threads
        // */
        //public void testGetWaitingThreads()
        //{
        //    final PublicReentrantLock lock = new PublicReentrantLock();
        //    final Condition c = lock.newCondition();
        //    Thread t1 = new Thread(new Runnable()
        //    {

        //        public void run()
        //        {
        //            try
        //            {
        //                lock.lock () ;
        //                threadAssertTrue(lock.getWaitingThreads(c).isEmpty()) ;
        //                c.await();
        //                lock.unlock();
        //            }
        //            catch (InterruptedException e)
        //            {
        //                threadUnexpectedException();
        //            }
        //        }
        //    });

        //    Thread t2 = new Thread(new Runnable()
        //    {

        //        public void run()
        //        {
        //            try
        //            {
        //                lock.lock () ;
        //                threadAssertFalse(lock.getWaitingThreads(c).isEmpty()) ;
        //                c.await();
        //                lock.unlock();
        //            }
        //            catch (InterruptedException e)
        //            {
        //                threadUnexpectedException();
        //            }
        //        }
        //    });

        //    try
        //    {
        //        lock.lock () ;
        //        assertTrue(lock.getWaitingThreads(c).isEmpty()) ;
        //        lock.unlock();
        //        t1.start();
        //        Thread.sleep(SHORT_DELAY_MS);
        //        t2.start();
        //        Thread.sleep(SHORT_DELAY_MS);
        //        lock.lock () ;
        //        assertTrue(lock.hasWaiters(c)) ;
        //        assertTrue(lock.getWaitingThreads(c).contains(t1)) ;
        //        assertTrue(lock.getWaitingThreads(c).contains(t2)) ;
        //        c.signalAll();
        //        lock.unlock();
        //        Thread.sleep(SHORT_DELAY_MS);
        //        lock.lock () ;
        //        assertFalse(lock.hasWaiters(c)) ;
        //        assertTrue(lock.getWaitingThreads(c).isEmpty()) ;
        //        lock.unlock();
        //        t1.join(SHORT_DELAY_MS);
        //        t2.join(SHORT_DELAY_MS);
        //        assertFalse(t1.isAlive());
        //        assertFalse(t2.isAlive());
        //    }
        //    catch (Exception ex)
        //    {
        //        unexpectedException();
        //    }
        //}

        ///** A helper class for uninterruptible wait tests */
        //class UninterruptableThread extends Thread
        //{
        //    private ReentrantLock lock;
        //    private Condition c;

        //    public volatile boolean canAwake = false;
        //    public volatile boolean interrupted = false;
        //    public volatile boolean lockStarted = false;

        //    public UninterruptableThread(ReentrantLock lock, Condition c)
        //    {
        //        this.lock = lock;
        //        this.c = c;
        //    }

        //    public synchronized void run()
        //    {
        //        lock.lock () ;
        //        lockStarted = true;

        //        while (!canAwake)
        //        {
        //            c.awaitUninterruptibly();
        //        }

        //        interrupted = isInterrupted();
        //        lock.unlock();
        //    }
        //}

        ///**
        // * awaitUninterruptibly doesn't abort on interrupt
        // */
        //public void testAwaitUninterruptibly()
        //{
        //    final ReentrantLock lock = new ReentrantLock();
        //    final Condition c = lock.newCondition();
        //    UninterruptableThread thread = new UninterruptableThread(lock, c);

        //    try
        //    {
        //        thread.start();

        //        while (!thread.lockStarted)
        //        {
        //            Thread.sleep(100);
        //        }

        //        lock.lock () ;
        //        try
        //        {
        //            thread.interrupt();
        //            thread.canAwake = true;
        //            c.signal();
        //        }
        //        finally
        //        {
        //            lock.unlock();
        //        }

        //        thread.join();
        //        assertTrue(thread.interrupted);
        //        assertFalse(thread.isAlive());
        //    }
        //    catch (Exception ex)
        //    {
        //        unexpectedException();
        //    }
        //}

        ///**
        // * await is interruptible
        // */
        //public void testAwait_Interrupt()
        //{
        //    final ReentrantLock lock = new ReentrantLock();
        //    final Condition c = lock.newCondition();
        //    Thread t = new Thread(new Runnable()
        //    {

        //        public void run()
        //        {
        //            try
        //            {
        //                lock.lock () ;
        //                c.await();
        //                lock.unlock();
        //                threadShouldThrow();
        //            }
        //            catch (InterruptedException success)
        //            {
        //            }
        //        }
        //    });

        //    try {
        //        t.start();
        //        Thread.sleep(SHORT_DELAY_MS);
        //        t.interrupt();
        //        t.join(SHORT_DELAY_MS);
        //        assertFalse(t.isAlive());
        //    }
        //    catch (Exception ex) {
        //        unexpectedException();
        //    }
        //}

        ///**
        // * awaitNanos is interruptible
        // */
        //public void testAwaitNanos_Interrupt()
        //{
        //    final ReentrantLock lock = new ReentrantLock();
        //    final Condition c = lock.newCondition();
        //    Thread t = new Thread(new Runnable()
        //    {

        //        public void run()
        //        {
        //            try
        //            {
        //                lock.lock () ;
        //                c.awaitNanos(1000 * 1000 * 1000); // 1 sec
        //                lock.unlock();
        //                threadShouldThrow();
        //            }
        //            catch (InterruptedException success)
        //            {
        //            }
        //        }
        //    });

        //    try
        //    {
        //        t.start();
        //        Thread.sleep(SHORT_DELAY_MS);
        //        t.interrupt();
        //        t.join(SHORT_DELAY_MS);
        //        assertFalse(t.isAlive());
        //    }
        //    catch (Exception ex)
        //    {
        //        unexpectedException();
        //    }
        //}

        ///**
        // * awaitUntil is interruptible
        // */
        //public void testAwaitUntil_Interrupt()
        //{
        //    final ReentrantLock lock = new ReentrantLock();
        //    final Condition c = lock.newCondition();
        //    Thread t = new Thread(new Runnable()
        //    {

        //        public void run()
        //        {
        //            try
        //            {
        //                lock.lock () ;
        //                java.util.Date d = new java.util.Date();
        //                c.awaitUntil(new java.util.Date(d.getTime() + 10000));
        //                lock.unlock();
        //                threadShouldThrow();
        //            }
        //            catch (InterruptedException success)
        //            {
        //            }
        //        }
        //    });

        //    try
        //    {
        //        t.start();
        //        Thread.sleep(SHORT_DELAY_MS);
        //        t.interrupt();
        //        t.join(SHORT_DELAY_MS);
        //        assertFalse(t.isAlive());
        //    }
        //    catch (Exception ex)
        //    {
        //        unexpectedException();
        //    }
        //}

        ///**
        // * signalAll wakes up all threads
        // */
        //public void testSignalAll()
        //{
        //    final ReentrantLock lock = new ReentrantLock();
        //    final Condition c = lock.newCondition();
        //    Thread t1 = new Thread(new Runnable()
        //    {

        //        public void run()
        //        {
        //            try
        //            {
        //                lock.lock () ;
        //                c.await();
        //                lock.unlock();
        //            }
        //            catch (InterruptedException e)
        //            {
        //                threadUnexpectedException();
        //            }
        //        }
        //    });

        //    Thread t2 = new Thread(new Runnable()
        //    {

        //        public void run()
        //        {
        //            try
        //            {
        //                lock.lock () ;
        //                c.await();
        //                lock.unlock();
        //            }
        //            catch (InterruptedException e)
        //            {
        //                threadUnexpectedException();
        //            }
        //        }
        //    });

        //    try
        //    {
        //        t1.start();
        //        t2.start();
        //        Thread.sleep(SHORT_DELAY_MS);
        //        lock.lock () ;
        //        c.signalAll();
        //        lock.unlock();
        //        t1.join(SHORT_DELAY_MS);
        //        t2.join(SHORT_DELAY_MS);
        //        assertFalse(t1.isAlive());
        //        assertFalse(t2.isAlive());
        //    }
        //    catch (Exception ex)
        //    {
        //        unexpectedException();
        //    }
        //}

        ///**
        // * await after multiple reentrant locking preserves lock count
        // */
        //public void testAwaitLockCount()
        //{
        //    final ReentrantLock lock = new ReentrantLock();
        //    final Condition c = lock.newCondition();
        //    Thread t1 = new Thread(new Runnable()
        //    {

        //        public void run()
        //        {
        //            try
        //            {
        //                lock.lock () ;
        //                threadAssertEquals(1, lock.getHoldCount()) ;
        //                c.await();
        //                threadAssertEquals(1, lock.getHoldCount()) ;
        //                lock.unlock();
        //            }
        //            catch (InterruptedException e)
        //            {
        //                threadUnexpectedException();
        //            }
        //        }
        //    });

        //    Thread t2 = new Thread(new Runnable()
        //    {

        //        public void run()
        //        {
        //            try
        //            {
        //                lock.lock () ;
        //                lock.lock () ;
        //                threadAssertEquals(2, lock.getHoldCount()) ;
        //                c.await();
        //                threadAssertEquals(2, lock.getHoldCount()) ;
        //                lock.unlock();
        //                lock.unlock();
        //            }
        //            catch (InterruptedException e)
        //            {
        //                threadUnexpectedException();
        //            }
        //        }
        //    });

        //    try
        //    {
        //        t1.start();
        //        t2.start();
        //        Thread.sleep(SHORT_DELAY_MS);
        //        lock.lock () ;
        //        c.signalAll();
        //        lock.unlock();
        //        t1.join(SHORT_DELAY_MS);
        //        t2.join(SHORT_DELAY_MS);
        //        assertFalse(t1.isAlive());
        //        assertFalse(t2.isAlive());
        //    }
        //    catch (Exception ex)
        //    {
        //        unexpectedException();
        //    }
        //}

        ///**
        // * A serialized lock deserializes as unlocked
        // */
        //public void testSerialization()
        //{
        //    ReentrantLock l = new ReentrantLock();
        //    l.lock () ;
        //    l.unlock();

        //    try
        //    {
        //        ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
        //        ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
        //            out.writeObject(l);
        //            out.close();

        //        ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
        //        ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
        //        ReentrantLock r = (ReentrantLock) in.readObject();
        //        r.lock () ;
        //        r.unlock();
        //    }
        //    catch (Exception e)
        //    {
        //        e.printStackTrace();
        //        unexpectedException();
        //    }
        //}

        /**
         * toString indicates current lock state
         */
        [Test]
        [Ignore("LUCENENET: Not implemented")]
        public void TestToString()
        {
            ReentrantLock @lock = new ReentrantLock();
            string us = @lock.ToString();
            assertTrue(us.IndexOf("Unlocked", StringComparison.Ordinal) >= 0);
            @lock.Lock();
            string ls = @lock.ToString();
            assertTrue(ls.IndexOf("Locked", StringComparison.Ordinal) >= 0);
        }

        //[Test]
        //[LuceneNetSpecific]
        //public void TestReentry()
        //{
        //    ReentrantLock @lock = new ReentrantLock();
        //    assertFalse(@lock.IsLocked);
        //    @lock.Lock();
        //    assertTrue(@lock.IsLocked);
        //    @lock.TryLock();
        //    assertTrue(@lock.IsLocked);
        //    @lock.Lock();
        //    assertTrue(@lock.IsLocked);

        //    // Now unwind the stack
        //    @lock.Unlock();
        //    assertTrue(@lock.IsLocked);
        //    @lock.Unlock();
        //    assertTrue(@lock.IsLocked);
        //    @lock.Unlock();
        //    assertFalse(@lock.IsLocked);

        //    Assert.Throws<SynchronizationLockException>(() => @lock.Unlock());
        //}

        //[Test]
        //[LuceneNetSpecific]
        //public async Task TestReentryWithTasks()
        //{
        //    var @lock = new ReentrantLock();
        //    assertFalse(@lock.IsLocked);

        //    var task1 = Task.Run(() =>
        //    {
        //        @lock.Lock();
        //        assertEquals(1, @lock.reentrantCount.Value);
        //        assertTrue(@lock.IsLocked);

        //        @lock.TryLock();
        //        assertEquals(2, @lock.reentrantCount.Value);
        //        assertTrue(@lock.IsLocked);

        //        @lock.Lock();
        //        assertEquals(3, @lock.reentrantCount.Value);
        //        assertTrue(@lock.IsLocked);

        //        // Simulate work
        //        Thread.Sleep(300);

        //        // Now unwind the stack
        //        @lock.Unlock();
        //        assertEquals(2, @lock.reentrantCount.Value);
        //        assertTrue(@lock.IsLocked);

        //        @lock.Unlock();
        //        assertEquals(1, @lock.reentrantCount.Value);
        //        assertTrue(@lock.IsLocked);

        //        //lock (@lock.syncLock)
        //        {
        //            @lock.Unlock();
        //            assertEquals(0, @lock.reentrantCount.Value);
        //            assertFalse(@lock.IsLocked);
        //        }

        //        Assert.Throws<SynchronizationLockException>(() => @lock.Unlock());
        //    });

        //    var task2 = Task.Run(async () =>
        //    {
        //        // Wait a bit to ensure task1 has started and locked
        //        await Task.Delay(100);

        //        // Try to lock
        //        @lock.Lock();

        //        // Simulate work
        //        Thread.Sleep(100);

        //        //lock (@lock.syncLock)
        //        {
        //            @lock.Unlock();
        //            assertEquals(0, @lock.reentrantCount.Value);
        //            assertFalse(@lock.IsLocked);
        //        }

        //        Assert.Throws<SynchronizationLockException>(() => @lock.Unlock());

        //    });

        //    await Task.WhenAll(task1, task2);
        //}

        //#if DEBUG
        //        private static void DoWorkReentrant(ReentrantLock @lock)
        //        {
        //            @lock.Lock();
        //            assertEquals(1, @lock.reentrantCount.Value);
        //            assertTrue(@lock.IsLocked);

        //            @lock.TryLock();
        //            assertEquals(2, @lock.reentrantCount.Value);
        //            assertTrue(@lock.IsLocked);

        //            @lock.Lock();
        //            assertEquals(3, @lock.reentrantCount.Value);
        //            assertTrue(@lock.IsLocked);

        //            // Simulate work
        //            Thread.Sleep(300);

        //            // Now unwind the stack
        //            @lock.Unlock();
        //            assertEquals(2, @lock.reentrantCount.Value);
        //            assertTrue(@lock.IsLocked);

        //            @lock.Unlock();
        //            assertEquals(1, @lock.reentrantCount.Value);
        //            assertTrue(@lock.IsLocked);

        //            lock (@lock.syncLock)
        //            {
        //                @lock.Unlock();
        //                assertEquals(0, @lock.reentrantCount.Value);
        //                assertFalse(@lock.IsLocked);
        //            }

        //            Assert.Throws<SynchronizationLockException>(() => @lock.Unlock());
        //        }


        //        [Test]
        //        [Slow]
        //        [LuceneNetSpecific]
        //        public void TestQueueCompletionWithTasks()
        //        {
        //            var @lock = new ReentrantLock();
        //            assertEquals(0, @lock.queueCount);
        //            assertEquals(0, @lock.dequeueCount);
        //            assertEquals(0, @lock.poolReturnCount);

        //            var tasks = new List<Task>();

        //            for (int i = 0; i < 10; i++)
        //            {
        //                tasks.Add(Task.Factory.StartNew((@lock) =>
        //                {
        //                    DoWorkReentrant((ReentrantLock)@lock);
        //                }, @lock));
        //            }

        //            // Wait for all tasks to complete
        //            Task.WaitAll(tasks.ToArray());

        //            // Make sure everything that was queued has also been dequeued
        //            assertTrue(@lock.queueCount > 0);
        //            assertEquals(@lock.queueCount, @lock.dequeueCount);
        //            assertEquals(@lock.queueCount, @lock.poolReturnCount);

        //            Console.WriteLine($"{nameof(@lock.queueCount)}: {@lock.queueCount}");
        //            Console.WriteLine($"{nameof(@lock.dequeueCount)}: {@lock.dequeueCount}");
        //            Console.WriteLine($"{nameof(@lock.poolReturnCount)}: {@lock.poolReturnCount}");
        //        }
        //#endif
    }
}