/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

/*

 * This file is available under and governed by the GNU General Public

 * License version 2 only, as published by the Free Software Foundation.

 * However, the following notice accompanied the original version of this

 * file:

 *

 * Written by Doug Lea with assistance from members of JCP JSR-166

 * Expert Group and released to the public domain, as explained at

 * http://creativecommons.org/publicdomain/zero/1.0/

 * Other contributors include John Vint

 */

import static java.util.concurrent.TimeUnit.MILLISECONDS;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collection;

import java.util.Iterator;

import java.util.List;

import java.util.NoSuchElementException;

import java.util.Queue;

import java.util.concurrent.BlockingQueue;

import java.util.concurrent.Callable;

import java.util.concurrent.CountDownLatch;

import java.util.concurrent.Executors;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.LinkedTransferQueue;

import junit.framework.Test;

@SuppressWarnings({"unchecked", "rawtypes"})

public class LinkedTransferQueueTest extends JSR166TestCase {

    public static class Generic extends BlockingQueueTest {

        protected BlockingQueue emptyCollection() {

            return new LinkedTransferQueue();

        }

    }

    public static void main(String[] args) {

        main(suite(), args);

    }

    public static Test suite() {

        class Implementation implements CollectionImplementation {

            public Class<?> klazz() { return LinkedTransferQueue.class; }

            public Collection emptyCollection() { return new LinkedTransferQueue(); }

            public Object makeElement(int i) { return i; }

            public boolean isConcurrent() { return true; }

            public boolean permitsNulls() { return false; }

        }

        return newTestSuite(LinkedTransferQueueTest.class,

                            new Generic().testSuite(),

                            CollectionTest.testSuite(new Implementation()));

    }

    /**

     * Constructor builds new queue with size being zero and empty

     * being true

     */

    public void testConstructor1() {

        assertEquals(0, new LinkedTransferQueue().size());

        assertTrue(new LinkedTransferQueue().isEmpty());

    }

    /**

     * Initializing constructor with null collection throws

     * NullPointerException

     */

    public void testConstructor2() {

        try {

            new LinkedTransferQueue(null);

            shouldThrow();

        } catch (NullPointerException success) {}

    }

    /**

     * Initializing from Collection of null elements throws

     * NullPointerException

     */

    public void testConstructor3() {

        Collection<Integer> elements = Arrays.asList(new Integer[SIZE]);

        try {

            new LinkedTransferQueue(elements);

            shouldThrow();

        } catch (NullPointerException success) {}

    }

    /**

     * Initializing constructor with a collection containing some null elements

     * throws NullPointerException

     */

    public void testConstructor4() {

        Integer[] ints = new Integer[SIZE];

        for (int i = 0; i < SIZE - 1; ++i)

            ints[i] = i;

        Collection<Integer> elements = Arrays.asList(ints);

        try {

            new LinkedTransferQueue(elements);

            shouldThrow();

        } catch (NullPointerException success) {}

    }

    /**

     * Queue contains all elements of the collection it is initialized by

     */

    public void testConstructor5() {

        Integer[] ints = new Integer[SIZE];

        for (int i = 0; i < SIZE; ++i) {

            ints[i] = i;

        }

        List intList = Arrays.asList(ints);

        LinkedTransferQueue q

            = new LinkedTransferQueue(intList);

        assertEquals(q.size(), intList.size());

        assertEquals(q.toString(), intList.toString());

        assertTrue(Arrays.equals(q.toArray(),

                                     intList.toArray()));

        assertTrue(Arrays.equals(q.toArray(new Object[0]),

                                 intList.toArray(new Object[0])));

        assertTrue(Arrays.equals(q.toArray(new Object[SIZE]),

                                 intList.toArray(new Object[SIZE])));

        for (int i = 0; i < SIZE; ++i) {

            assertEquals(ints[i], q.poll());

        }

    }

    /**

     * remainingCapacity() always returns Integer.MAX_VALUE

     */

    public void testRemainingCapacity() {

        BlockingQueue q = populatedQueue(SIZE);

        for (int i = 0; i < SIZE; ++i) {

            assertEquals(Integer.MAX_VALUE, q.remainingCapacity());

            assertEquals(SIZE - i, q.size());

            assertEquals(i, q.remove());

        }

        for (int i = 0; i < SIZE; ++i) {

            assertEquals(Integer.MAX_VALUE, q.remainingCapacity());

            assertEquals(i, q.size());

            assertTrue(q.add(i));

        }

    }

    /**

     * addAll(this) throws IllegalArgumentException

     */

    public void testAddAllSelf() {

        LinkedTransferQueue q = populatedQueue(SIZE);

        try {

            q.addAll(q);

            shouldThrow();

        } catch (IllegalArgumentException success) {}

    }

    /**

     * addAll of a collection with any null elements throws

     * NullPointerException after possibly adding some elements

     */

    public void testAddAll3() {

        LinkedTransferQueue q = new LinkedTransferQueue();

        Integer[] ints = new Integer[SIZE];

        for (int i = 0; i < SIZE - 1; ++i)

            ints[i] = i;

        try {

            q.addAll(Arrays.asList(ints));

            shouldThrow();

        } catch (NullPointerException success) {}

    }

    /**

     * Queue contains all elements, in traversal order, of successful addAll

     */

    public void testAddAll5() {

        Integer[] empty = new Integer[0];

        Integer[] ints = new Integer[SIZE];

        for (int i = 0; i < SIZE; ++i) {

            ints[i] = i;

        }

        LinkedTransferQueue q = new LinkedTransferQueue();

        assertFalse(q.addAll(Arrays.asList(empty)));

        assertTrue(q.addAll(Arrays.asList(ints)));

        for (int i = 0; i < SIZE; ++i) {

            assertEquals(ints[i], q.poll());

        }

    }

    /**

     * all elements successfully put are contained

     */

    public void testPut() {

        LinkedTransferQueue<Integer> q = new LinkedTransferQueue<>();

        for (int i = 0; i < SIZE; ++i) {

            assertEquals(i, q.size());

            q.put(i);

            assertTrue(q.contains(i));

        }

    }

    /**

     * take retrieves elements in FIFO order

     */

    public void testTake() throws InterruptedException {

        LinkedTransferQueue<Integer> q = populatedQueue(SIZE);

        for (int i = 0; i < SIZE; ++i) {

            assertEquals(i, (int) q.take());

        }

    }

    /**

     * take removes existing elements until empty, then blocks interruptibly

     */

    public void testBlockingTake() throws InterruptedException {

        final BlockingQueue q = populatedQueue(SIZE);

        final CountDownLatch pleaseInterrupt = new CountDownLatch(1);

        Thread t = newStartedThread(new CheckedRunnable() {

            public void realRun() throws InterruptedException {

                for (int i = 0; i < SIZE; i++) assertEquals(i, q.take());

                Thread.currentThread().interrupt();

                try {

                    q.take();

                    shouldThrow();

                } catch (InterruptedException success) {}

                assertFalse(Thread.interrupted());

                pleaseInterrupt.countDown();

                try {

                    q.take();

                    shouldThrow();

                } catch (InterruptedException success) {}

                assertFalse(Thread.interrupted());

            }});

        await(pleaseInterrupt);

        t.interrupt();

        awaitTermination(t);

    }

    /**

     * poll succeeds unless empty

     */

    public void testPoll() throws InterruptedException {

        LinkedTransferQueue<Integer> q = populatedQueue(SIZE);

        for (int i = 0; i < SIZE; ++i) {

            assertEquals(i, (int) q.poll());

        }

        assertNull(q.poll());

        checkEmpty(q);

    }

    /**

     * timed poll with zero timeout succeeds when non-empty, else times out

     */

    public void testTimedPoll0() throws InterruptedException {

        LinkedTransferQueue<Integer> q = populatedQueue(SIZE);

        for (int i = 0; i < SIZE; ++i) {

            assertEquals(i, (int) q.poll(0, MILLISECONDS));

        }

        assertNull(q.poll(0, MILLISECONDS));

        checkEmpty(q);

    }

    /**

     * timed poll with nonzero timeout succeeds when non-empty, else times out

     */

    public void testTimedPoll() throws InterruptedException {

        LinkedTransferQueue<Integer> q = populatedQueue(SIZE);

        long startTime = System.nanoTime();

        for (int i = 0; i < SIZE; ++i)

            assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));

        assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);

        startTime = System.nanoTime();

        assertNull(q.poll(timeoutMillis(), MILLISECONDS));

        assertTrue(millisElapsedSince(startTime) >= timeoutMillis());

        checkEmpty(q);

    }

    /**

     * Interrupted timed poll throws InterruptedException instead of

     * returning timeout status

     */

    public void testInterruptedTimedPoll() throws InterruptedException {

        final BlockingQueue<Integer> q = populatedQueue(SIZE);

        final CountDownLatch pleaseInterrupt = new CountDownLatch(1);

        Thread t = newStartedThread(new CheckedRunnable() {

            public void realRun() throws InterruptedException {

                for (int i = 0; i < SIZE; i++)

                    assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));

                Thread.currentThread().interrupt();

                try {

                    shouldThrow();

                } catch (InterruptedException success) {}

                assertFalse(Thread.interrupted());

                pleaseInterrupt.countDown();

                try {

                    shouldThrow();

                } catch (InterruptedException success) {}

                assertFalse(Thread.interrupted());

            }});

        await(pleaseInterrupt);

        t.interrupt();

        awaitTermination(t);

        checkEmpty(q);

    }

    /**

     * timed poll after thread interrupted throws InterruptedException

     * instead of returning timeout status

     */

    public void testTimedPollAfterInterrupt() throws InterruptedException {

        final BlockingQueue<Integer> q = populatedQueue(SIZE);

        Thread t = newStartedThread(new CheckedRunnable() {

            public void realRun() throws InterruptedException {

                Thread.currentThread().interrupt();

                for (int i = 0; i < SIZE; ++i)

                try {

                    shouldThrow();

                } catch (InterruptedException success) {}

                assertFalse(Thread.interrupted());

            }});

        awaitTermination(t);

        checkEmpty(q);

    }

    /**

     * peek returns next element, or null if empty

     */

    public void testPeek() throws InterruptedException {

        LinkedTransferQueue<Integer> q = populatedQueue(SIZE);

        for (int i = 0; i < SIZE; ++i) {

            assertEquals(i, (int) q.peek());

            assertEquals(i, (int) q.poll());

            assertTrue(q.peek() == null ||

                       i != (int) q.peek());

        }

        assertNull(q.peek());

        checkEmpty(q);

    }

    /**

     * element returns next element, or throws NoSuchElementException if empty

     */

    public void testElement() throws InterruptedException {

        LinkedTransferQueue<Integer> q = populatedQueue(SIZE);

        for (int i = 0; i < SIZE; ++i) {

            assertEquals(i, (int) q.element());

            assertEquals(i, (int) q.poll());

        }

        try {

            q.element();

            shouldThrow();

        } catch (NoSuchElementException success) {}

        checkEmpty(q);

    }

    /**

     * remove removes next element, or throws NoSuchElementException if empty

     */

    public void testRemove() throws InterruptedException {

        LinkedTransferQueue<Integer> q = populatedQueue(SIZE);

        for (int i = 0; i < SIZE; ++i) {

            assertEquals(i, (int) q.remove());

        }

        try {

            q.remove();

            shouldThrow();

        } catch (NoSuchElementException success) {}

        checkEmpty(q);

    }

    /**

     * An add following remove(x) succeeds

     */

    public void testRemoveElementAndAdd() throws InterruptedException {

        LinkedTransferQueue q = new LinkedTransferQueue();

        assertTrue(q.add(one));

        assertTrue(q.add(two));

        assertTrue(q.remove(one));

        assertTrue(q.remove(two));

        assertTrue(q.add(three));

        assertSame(q.take(), three);

    }

    /**

     * contains(x) reports true when elements added but not yet removed

     */

    public void testContains() {

        LinkedTransferQueue<Integer> q = populatedQueue(SIZE);

        for (int i = 0; i < SIZE; ++i) {

            assertTrue(q.contains(i));

            assertEquals(i, (int) q.poll());

            assertFalse(q.contains(i));

        }

    }

    /**

     * clear removes all elements

     */

    public void testClear() throws InterruptedException {

        LinkedTransferQueue q = populatedQueue(SIZE);

        q.clear();

        checkEmpty(q);

        assertEquals(Integer.MAX_VALUE, q.remainingCapacity());

        q.add(one);

        assertFalse(q.isEmpty());

        assertEquals(1, q.size());

        assertTrue(q.contains(one));

        q.clear();

        checkEmpty(q);

    }

    /**

     * containsAll(c) is true when c contains a subset of elements

     */

    public void testContainsAll() {

        LinkedTransferQueue<Integer> q = populatedQueue(SIZE);

        LinkedTransferQueue<Integer> p = new LinkedTransferQueue<>();

        for (int i = 0; i < SIZE; ++i) {

            assertTrue(q.containsAll(p));

            assertFalse(p.containsAll(q));

            p.add(i);

        }

        assertTrue(p.containsAll(q));

    }

    /**

     * retainAll(c) retains only those elements of c and reports true

     * if changed

     */

    public void testRetainAll() {

        LinkedTransferQueue q = populatedQueue(SIZE);

        LinkedTransferQueue p = populatedQueue(SIZE);

        for (int i = 0; i < SIZE; ++i) {

            boolean changed = q.retainAll(p);

            if (i == 0) {

                assertFalse(changed);

            } else {

                assertTrue(changed);

            }

            assertTrue(q.containsAll(p));

            assertEquals(SIZE - i, q.size());

            p.remove();

        }

    }

    /**

     * removeAll(c) removes only those elements of c and reports true

     * if changed

     */

    public void testRemoveAll() {

        for (int i = 1; i < SIZE; ++i) {

            LinkedTransferQueue q = populatedQueue(SIZE);

            LinkedTransferQueue p = populatedQueue(i);

            assertTrue(q.removeAll(p));

            assertEquals(SIZE - i, q.size());

            for (int j = 0; j < i; ++j) {

                assertFalse(q.contains(p.remove()));

            }

        }

    }

    /**

     * toArray() contains all elements in FIFO order

     */

    public void testToArray() {

        LinkedTransferQueue q = populatedQueue(SIZE);

        Object[] a = q.toArray();

        assertSame(Object[].class, a.getClass());

        for (Object o : a)

            assertSame(o, q.poll());

        assertTrue(q.isEmpty());

    }

    /**

     * toArray(a) contains all elements in FIFO order

     */

    public void testToArray2() {

        LinkedTransferQueue<Integer> q = populatedQueue(SIZE);

        Integer[] ints = new Integer[SIZE];

        Integer[] array = q.toArray(ints);

        assertSame(ints, array);

        for (Integer o : ints)

            assertSame(o, q.poll());

        assertTrue(q.isEmpty());

    }

    /**

     * toArray(incompatible array type) throws ArrayStoreException

     */

    public void testToArray1_BadArg() {

        LinkedTransferQueue q = populatedQueue(SIZE);