harmony-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From mloe...@apache.org
Subject svn commit: r415247 - in /incubator/harmony/enhanced/classlib/trunk/modules/luni/src: main/java/java/util/ test/java/tests/api/java/util/ test/resources/serialization/java/util/
Date Mon, 19 Jun 2006 05:32:22 GMT
Author: mloenko
Date: Sun Jun 18 22:32:21 2006
New Revision: 415247

URL: http://svn.apache.org/viewvc?rev=415247&view=rev
Log:
integrated HARMONY-574
[classlib][util]Java 5 Enhancement:new class java.util.PriorityQueue
with minor changes

Added:
    incubator/harmony/enhanced/classlib/trunk/modules/luni/src/main/java/java/util/PriorityQueue.java
    incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/tests/api/java/util/PriorityQueueTest.java
    incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/resources/serialization/java/util/PriorityQueue.golden.ser
  (with props)
Modified:
    incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/tests/api/java/util/AllTests.java

Added: incubator/harmony/enhanced/classlib/trunk/modules/luni/src/main/java/java/util/PriorityQueue.java
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/luni/src/main/java/java/util/PriorityQueue.java?rev=415247&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/luni/src/main/java/java/util/PriorityQueue.java
(added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/luni/src/main/java/java/util/PriorityQueue.java
Sun Jun 18 22:32:21 2006
@@ -0,0 +1,386 @@
+/* Copyright 2006 The Apache Software Foundation or its licensors, as applicable
+ * 
+ * Licensed 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.
+ */
+package java.util;
+
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.io.Serializable;
+
+/**
+ * PriorityQueue holds elements on a priority heap, which orders elements
+ * according to the comparator specified at construction or their natural order.
+ * If the queue uses natural order, any element that is not comparable is not
+ * permitted to insert to the queue.
+ * 
+ * The least element of the specified ordering is stored at the head of the
+ * queue and the greatest element is stored at the tail of the queue.
+ * 
+ * PriorityQueue is not synchronized. If mutiple threads will access it
+ * concurrently, use the PriorityBlockingQueue.
+ */
+public class PriorityQueue<E> extends AbstractQueue<E> implements Serializable
{
+
+    private static final long serialVersionUID = -7720805057305804111L;
+
+    private static final int DEFAULT_CAPACITY = 11;
+
+    private static final double DEFAULT_INIT_CAPACITY_RATIO = 1.1;
+
+    private static final int DEFAULT_CAPACITY_RATIO = 2;
+
+    private int size = 0;
+
+    private Comparator<? super E> comparator;
+
+    private transient E[] elements;
+
+    /**
+     * Constructs a priority queue with the capacity of 11 and natural ordering.
+     */
+    public PriorityQueue() {
+        this(DEFAULT_CAPACITY);
+    }
+
+    /**
+     * Constructs a priority queue with specified capacity and natural ordering.
+     * 
+     * @param initialCapacity the specified capacity.
+     * @throws IllegalArgumentException if the initialCapacity is less than 1
+     */
+    public PriorityQueue(int initialCapacity) {
+        this(initialCapacity, null);
+    }
+
+    /**
+     * Constructs a priority queue with specified capacity and comparator.
+     * 
+     * @param initialCapacity the specified capacity.
+     * @param comparator the specified comparator. If it is null, the natural
+     *        ordering will be used.
+     * @throws IllegalArgumentException if the initialCapacity is less than 1
+     */
+    public PriorityQueue(int initialCapacity, Comparator<? super E> comparator) {
+        if (initialCapacity < 1) {
+            throw new IllegalArgumentException();
+        }
+        elements = newElementArray(initialCapacity);
+        this.comparator = comparator;
+    }
+
+    /**
+     * Constructs a priority queue that contains the elements of a collection.
+     * The constructed priority queue has the initial capacity of 110% the
+     * collection. And the priority queue uses natural ordering to order its
+     * elements.
+     * 
+     * @param c the collection whose elements will be added to the priority
+     *        queue to be constructed.
+     * @throws ClassCastException if any of the elements in the collection is
+     *         not comparable.
+     * @throws NullPointerExcepiton if any of the elements in the colleciton is
+     *         null.
+     */
+    public PriorityQueue(Collection<? extends E> c) {
+        if (c instanceof PriorityQueue) {
+            getFromPriorityQueue((PriorityQueue<? extends E>) c);
+        } else if (c instanceof SortedSet) {
+            getFromSortedSet((SortedSet<? extends E>) c);
+        } else {
+            initSize(c);
+            addAll(c);
+        }
+    }
+
+    /**
+     * Constructs a priority queue that contains the elements of another
+     * priority queue. The constructed priority queue has the initial capacity
+     * of 110% the latter one. And the two priority queue has the same
+     * comparator.
+     * 
+     * @param c the priority queue whose elements will be added to the priority
+     *        queue to be constructed.
+     */
+    public PriorityQueue(PriorityQueue<? extends E> c) {
+        getFromPriorityQueue(c);
+    }
+
+    /**
+     * Constructs a priority queue that contains the elements of a sorted set.
+     * The constructed priority queue has the initial capacity of 110% the
+     * sorted set. And the priority queue has the same comparator of the sorted
+     * set.
+     * 
+     * @param c the sorted set whose elements will be added to the priority
+     *        queue to be constructed.
+     */
+    public PriorityQueue(SortedSet<? extends E> c) {
+        getFromSortedSet(c);
+    }
+
+    /**
+     * Gets the iterator of the priority queue, which will not return elements
+     * in any specified ordering.
+     * 
+     * @return the iterator of the priority queue.
+     */
+    public Iterator<E> iterator() {
+        return new PriorityIterator();
+    }
+
+    /**
+     * Gets the size of the priority queue. If the size of the queue is greater
+     * than the Integer.MAX, then it returns Integer.MAX.
+     * 
+     * @return the size of the priority queue.
+     */
+    public int size() {
+        return size;
+    }
+
+    /**
+     * Removes all the elements of the priority queue.
+     */
+    public void clear() {
+        Arrays.fill(elements, null);
+        size = 0;
+    }
+
+    /**
+     * Inserts the element to the priority queue.
+     * 
+     * @return true
+     * @throws ClassCastException if the element cannot be compared with the
+     *         elements in the priority queue using the ordering of the priority
+     *         queue.
+     * @throws NullPointerExcepiton if the element is null.
+     */
+    public boolean offer(E o) {
+        if (null == o) {
+            throw new NullPointerException();
+        }
+        growToSize(size + 1);
+        elements[size] = o;
+        siftUp(size++);
+        return true;
+    }
+
+    /**
+     * Gets and removes the head of the queue.
+     * 
+     * @return the head of the queue. Null if the queue is empty.
+     */
+    public E poll() {
+        if (isEmpty()) {
+            return null;
+        }
+        E result = elements[0];
+        removeAt(0);
+        return result;
+    }
+
+    /**
+     * Gets but not removes the head of the queue.
+     * 
+     * @return the head of the queue. Null if the queue is empty.
+     */
+    public E peek() {
+        if (isEmpty()) {
+            return null;
+        }
+        return elements[0];
+    }
+
+    /**
+     * Gets the comparator of the priority queue.
+     * 
+     * @return the comparator of the priority queue. Null if the natural
+     *         ordering is used.
+     */
+    public Comparator<? super E> comparator() {
+        return comparator;
+    }
+
+    /**
+     * Removes the specified object of the priority queue.
+     * 
+     * @param o the object to be removed.
+     * @return true if the object is in the priority queue, false if the object
+     *         is not in the priority queue.
+     */
+    public boolean remove(Object o) {
+        if (o == null) {
+            return false;
+        }
+        int targetIndex;
+        for (targetIndex = 0; targetIndex < size; targetIndex++) {
+            if (0 == this.compare((E) o, elements[targetIndex])) {
+                break;
+            }
+        }
+        if (size == 0 || size == targetIndex) {
+            return false;
+        }
+        removeAt(targetIndex);
+        return true;
+    }
+
+    /**
+     * Adds the specified object to the priority queue.
+     * 
+     * @param o the object to be added.
+     * @return true.
+     * @throws ClassCastException if the element cannot be compared with the
+     *         elements in the priority queue using the ordering of the priority
+     *         queue.
+     * @throws NullPointerExcepiton if the element is null.
+     */
+    public boolean add(E o) {
+        return offer(o);
+    }
+
+    private class PriorityIterator implements Iterator<E> {
+
+        private int currentIndex = -1;
+
+        private boolean allowRemove = false;
+
+        public boolean hasNext() {
+            return currentIndex < size - 1;
+        }
+
+        public E next() {
+            if (!hasNext()) {
+                throw new NoSuchElementException();
+            }
+            allowRemove = true;
+            return elements[++currentIndex];
+        }
+
+        public void remove() {
+            if (!allowRemove) {
+                throw new IllegalStateException();
+            }
+            allowRemove = false;
+            removeAt(currentIndex--);
+        }
+    }
+
+    private void readObject(ObjectInputStream in) throws IOException,
+            ClassNotFoundException {
+        in.defaultReadObject();
+        int capacity = in.readInt();
+        elements = newElementArray(capacity);
+        for (int i = 0; i < size; i++) {
+            elements[i] = (E) in.readObject();
+        }
+    }
+
+    private E[] newElementArray(int capacity) {
+        return (E[]) new Object[capacity];
+    }
+
+    private void writeObject(ObjectOutputStream out) throws IOException {
+        out.defaultWriteObject();
+        out.writeInt(elements.length);
+        for (int i = 0; i < size; i++) {
+            out.writeObject(elements[i]);
+        }
+    }
+
+    private void getFromPriorityQueue(PriorityQueue<? extends E> c) {
+        initSize(c);
+        comparator = (Comparator<? super E>) c.comparator();
+        System.arraycopy(c.elements, 0, elements, 0, c.size());
+        size = c.size();
+    }
+
+    private void getFromSortedSet(SortedSet<? extends E> c) {
+        initSize(c);
+        comparator = (Comparator<? super E>) c.comparator();
+        Iterator<? extends E> iter = c.iterator();
+        while (iter.hasNext()) {
+            elements[size++] = iter.next();
+        }
+    }
+
+    private void removeAt(int index) {
+        size--;
+        elements[index] = elements[size];
+        siftDown(index);
+        elements[size] = null;
+    }
+
+    private int compare(E o1, E o2) {
+        if (null != comparator) {
+            return comparator.compare(o1, o2);
+        } else {
+            return ((Comparable<? super E>) o1).compareTo(o2);
+        }
+    }
+
+    private void siftUp(int childIndex) {
+        E target = elements[childIndex];
+        int parentIndex;
+        while (childIndex > 0) {
+            parentIndex = (childIndex - 1) / 2;
+            E parent = elements[parentIndex];
+            if (compare(parent, target) <= 0) {
+                break;
+            }
+            elements[childIndex] = parent;
+            childIndex = parentIndex;
+        }
+        elements[childIndex] = target;
+    }
+
+    private void siftDown(int rootIndex) {
+        E target = elements[rootIndex];
+        int childIndex;
+        while ((childIndex = rootIndex * 2 + 1) < size) {
+            if (childIndex + 1 < size
+                    && compare(elements[childIndex + 1], elements[childIndex]) <
0) {
+                childIndex++;
+            }
+            if (compare(target, elements[childIndex]) <= 0) {
+                break;
+            }
+            elements[rootIndex] = elements[childIndex];
+            rootIndex = childIndex;
+        }
+        elements[rootIndex] = target;
+    }
+
+    private void initSize(Collection<? extends E> c) {
+        if (null == c) {
+            throw new NullPointerException();
+        }
+        if (c.isEmpty()) {
+            elements = newElementArray(1);
+        } else {
+            int capacity = (int) Math.ceil(c.size()
+                    * DEFAULT_INIT_CAPACITY_RATIO);
+            elements = newElementArray(capacity);
+        }
+    }
+
+    private void growToSize(int size) {
+        if (size > elements.length) {
+            E[] newElements = newElementArray(size * DEFAULT_CAPACITY_RATIO);
+            System.arraycopy(elements, 0, newElements, 0, elements.length);
+            elements = newElements;
+        }
+    }
+}

Modified: incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/tests/api/java/util/AllTests.java
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/tests/api/java/util/AllTests.java?rev=415247&r1=415246&r2=415247&view=diff
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/tests/api/java/util/AllTests.java
(original)
+++ incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/tests/api/java/util/AllTests.java
Sun Jun 18 22:32:21 2006
@@ -73,6 +73,7 @@
 		suite.addTestSuite(MissingResourceExceptionTest.class);
 		suite.addTestSuite(NoSuchElementExceptionTest.class);
 		suite.addTestSuite(ObservableTest.class);
+        suite.addTestSuite(PriorityQueueTest.class);
 		suite.addTestSuite(PropertiesTest.class);
 		suite.addTestSuite(PropertyPermissionTest.class);
 		suite.addTestSuite(PropertyResourceBundleTest.class);

Added: incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/tests/api/java/util/PriorityQueueTest.java
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/tests/api/java/util/PriorityQueueTest.java?rev=415247&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/tests/api/java/util/PriorityQueueTest.java
(added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/tests/api/java/util/PriorityQueueTest.java
Sun Jun 18 22:32:21 2006
@@ -0,0 +1,765 @@
+/* Copyright 2006 The Apache Software Foundation or its licensors, as applicable
+ * 
+ * Licensed 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.
+ */
+
+package tests.api.java.util;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Comparator;
+import java.util.Iterator;
+import java.util.List;
+import java.util.NoSuchElementException;
+import java.util.PriorityQueue;
+import java.util.SortedSet;
+import java.util.TreeSet;
+
+import tests.util.SerializationTester;
+
+import junit.framework.TestCase;
+
+public class PriorityQueueTest extends TestCase {
+
+    private static final String SERIALIZATION_FILE_NAME = "serialization/java/util/PriorityQueue.golden.ser";
//$NON-NLS-1$    
+
+    /**
+     * @tests java.util.PriorityQueue#iterator()
+     */
+    public void test_iterator() {
+        PriorityQueue<Integer> integerQueue = new PriorityQueue<Integer>();
+        Integer[] array = { 2, 45, 7, -12, 9 };
+        for (int i = 0; i < array.length; i++) {
+            integerQueue.offer(array[i]);
+        }
+        Iterator<Integer> iter = integerQueue.iterator();
+        assertNotNull(iter);
+        ArrayList<Integer> iterResult = new ArrayList<Integer>();
+        while (iter.hasNext()) {
+            iterResult.add(iter.next());
+        }
+        Object[] resultArray = iterResult.toArray();
+        Arrays.sort(array);
+        Arrays.sort(resultArray);
+        assertTrue(Arrays.equals(array, resultArray));
+    }
+
+    /**
+     * @tests java.util.PriorityQueue#iterator()
+     */
+    public void test_iterator_empty() {
+        PriorityQueue<Integer> integerQueue = new PriorityQueue<Integer>();
+        Iterator<Integer> iter = integerQueue.iterator();
+        try {
+            iter.next();
+            fail("should throw NoSuchElementException");
+        } catch (NoSuchElementException e) {
+            // expected
+        }
+
+        iter = integerQueue.iterator();
+        try {
+            iter.remove();
+            fail("should throw IllegalStateException");
+        } catch (IllegalStateException e) {
+            // expected
+        }
+    }
+
+    /**
+     * @tests java.util.PriorityQueue#iterator()
+     */
+    public void test_iterator_outofbound() {
+        PriorityQueue<Integer> integerQueue = new PriorityQueue<Integer>();
+        integerQueue.offer(0);
+        Iterator<Integer> iter = integerQueue.iterator();
+        iter.next();
+        try {
+            iter.next();
+            fail("should throw NoSuchElementException");
+        } catch (NoSuchElementException e) {
+            // expected
+        }
+
+        iter = integerQueue.iterator();
+        iter.next();
+        iter.remove();
+        try {
+            iter.next();
+            fail("should throw NoSuchElementException");
+        } catch (NoSuchElementException e) {
+            // expected
+        }
+    }
+
+    /**
+     * @tests java.util.PriorityQueue#iterator()
+     */
+    public void test_iterator_remove() {
+        PriorityQueue<Integer> integerQueue = new PriorityQueue<Integer>();
+        Integer[] array = { 2, 45, 7, -12, 9 };
+        for (int i = 0; i < array.length; i++) {
+            integerQueue.offer(array[i]);
+        }
+        Iterator<Integer> iter = integerQueue.iterator();
+        assertNotNull(iter);
+        for (int i = 0; i < array.length; i++) {
+            iter.next();
+            if (2 == i) {
+                iter.remove();
+            }
+        }
+        assertEquals(array.length - 1, integerQueue.size());
+
+        iter = integerQueue.iterator();
+        Integer[] newArray = new Integer[array.length - 1];
+        for (int i = 0; i < newArray.length; i++) {
+            newArray[i] = iter.next();
+        }
+
+        Arrays.sort(newArray);
+        for (int i = 0; i < integerQueue.size(); i++) {
+            assertEquals(newArray[i], integerQueue.poll());
+        }
+
+    }
+
+    /**
+     * @tests java.util.PriorityQueue#iterator()
+     */
+    public void test_iterator_remove_illegalState() {
+        PriorityQueue<Integer> integerQueue = new PriorityQueue<Integer>();
+        Integer[] array = { 2, 45, 7, -12, 9 };
+        for (int i = 0; i < array.length; i++) {
+            integerQueue.offer(array[i]);
+        }
+        Iterator<Integer> iter = integerQueue.iterator();
+        assertNotNull(iter);
+        try {
+            iter.remove();
+            fail("should throw IllegalStateException");
+        } catch (IllegalStateException e) {
+            // expected
+        }
+        iter.next();
+        iter.remove();
+        try {
+            iter.remove();
+            fail("should throw IllegalStateException");
+        } catch (IllegalStateException e) {
+            // expected
+        }
+
+    }
+
+    /**
+     * @tests java.util.PriorityQueue.size()
+     */
+    public void test_size() {
+        PriorityQueue<Integer> integerQueue = new PriorityQueue<Integer>();
+        assertEquals(0, integerQueue.size());
+        int[] array = { 2, 45, 7, -12, 9 };
+        for (int i = 0; i < array.length; i++) {
+            integerQueue.offer(array[i]);
+        }
+        assertEquals(array.length, integerQueue.size());
+    }
+
+    /**
+     * @tests java.util.PriorityQueue#PriorityQueue()
+     */
+    public void test_Constructor() {
+        PriorityQueue<Object> queue = new PriorityQueue<Object>();
+        assertNotNull(queue);
+        assertEquals(0, queue.size());
+        assertNull(queue.comparator());
+    }
+
+    /**
+     * @tests java.util.PriorityQueue#PriorityQueue(int)
+     */
+    public void test_ConstructorI() {
+        PriorityQueue<Object> queue = new PriorityQueue<Object>(100);
+        assertNotNull(queue);
+        assertEquals(0, queue.size());
+        assertNull(queue.comparator());
+    }
+
+    /**
+     * @tests java.util.PriorityQueue#PriorityQueue(int, Comparator<? super E>)
+     */
+    public void test_ConstructorILjava_util_Comparator() {
+        PriorityQueue<Object> queue = new PriorityQueue<Object>(100,
+                (Comparator<Object>) null);
+        assertNotNull(queue);
+        assertEquals(0, queue.size());
+        assertNull(queue.comparator());
+
+        MockComparator<Object> comparator = new MockComparator<Object>();
+        queue = new PriorityQueue<Object>(100, comparator);
+        assertNotNull(queue);
+        assertEquals(0, queue.size());
+        assertEquals(comparator, queue.comparator());
+    }
+
+    /**
+     * @tests java.util.PriorityQueue#PriorityQueue(int, Comparator<? super E>)
+     */
+    public void test_ConstructorILjava_util_Comparator_illegalCapacity() {
+        try {
+            new PriorityQueue<Object>(0, new MockComparator<Object>());
+            fail("should throw IllegalArgumentException");
+        } catch (IllegalArgumentException e) {
+            // expected
+        }
+
+        try {
+            new PriorityQueue<Object>(-1, new MockComparator<Object>());
+            fail("should throw IllegalArgumentException");
+        } catch (IllegalArgumentException e) {
+            // expected
+        }
+    }
+
+    /**
+     * @tests java.util.PriorityQueue#PriorityQueue(int, Comparator<? super E>)
+     */
+    public void test_ConstructorILjava_util_Comparator_cast() {
+        MockComparatorCast<Object> objectComparator = new MockComparatorCast<Object>();
+        PriorityQueue<Integer> integerQueue = new PriorityQueue<Integer>(100,
+                objectComparator);
+        assertNotNull(integerQueue);
+        assertEquals(0, integerQueue.size());
+        assertEquals(objectComparator, integerQueue.comparator());
+        Integer[] array = { 2, 45, 7, -12, 9 };
+        List<Integer> list = Arrays.asList(array);
+        integerQueue.addAll(list);
+        assertEquals(list.size(), integerQueue.size());
+        // just test here no cast exception raises.
+    }
+
+    /**
+     * @tests java.util.PriorityQueue#PriorityQueue(Collection)
+     */
+    public void test_ConstructorLjava_util_Colleciton() {
+        Integer[] array = { 2, 45, 7, -12, 9 };
+        List<Integer> list = Arrays.asList(array);
+        PriorityQueue<Integer> integerQueue = new PriorityQueue<Integer>(list);
+        assertEquals(array.length, integerQueue.size());
+        assertNull(integerQueue.comparator());
+        Arrays.sort(array);
+        for (int i = 0; i < array.length; i++) {
+            assertEquals(array[i], integerQueue.poll());
+        }
+    }
+
+    /**
+     * @tests java.util.PriorityQueue#PriorityQueue(Collection)
+     */
+    public void test_ConstructorLjava_util_Colleciton_null() {
+        ArrayList<Object> list = new ArrayList<Object>();
+        list.add(new Float(11));
+        list.add(null);
+        list.add(new Integer(10));
+        try {
+            new PriorityQueue<Object>(list);
+            fail("should throw NullPointerException");
+        } catch (NullPointerException e) {
+            // expected
+        }
+    }
+
+    /**
+     * @tests java.util.PriorityQueue#PriorityQueue(Collection)
+     */
+    public void test_ConstructorLjava_util_Colleciton_non_comparable() {
+        ArrayList<Object> list = new ArrayList<Object>();
+        list.add(new Float(11));
+        list.add(new Integer(10));
+        try {
+            new PriorityQueue<Object>(list);
+            fail("should throw ClassCastException");
+        } catch (ClassCastException e) {
+            // expected
+        }
+    }
+
+    /**
+     * @tests java.util.PriorityQueue#PriorityQueue(Collection)
+     */
+    public void test_ConstructorLjava_util_Colleciton_from_priorityqueue() {
+        String[] array = { "AAAAA", "AA", "AAAA", "AAAAAAAA" };
+        PriorityQueue<String> queue = new PriorityQueue<String>(4,
+                new MockComparatorStringByLength());
+        for (int i = 0; i < array.length; i++) {
+            queue.offer(array[i]);
+        }
+        Collection<String> c = queue;
+        PriorityQueue<String> constructedQueue = new PriorityQueue<String>(c);
+        assertEquals(queue.comparator(), constructedQueue.comparator());
+        while (queue.size() > 0) {
+            assertEquals(queue.poll(), constructedQueue.poll());
+        }
+        assertEquals(0, constructedQueue.size());
+    }
+
+    /**
+     * @tests java.util.PriorityQueue#PriorityQueue(Collection)
+     */
+    public void test_ConstructorLjava_util_Colleciton_from_sortedset() {
+        int[] array = { 3, 5, 79, -17, 5 };
+        TreeSet<Integer> treeSet = new TreeSet<Integer>(new MockComparator<Integer>());
+        for (int i = 0; i < array.length; i++) {
+            treeSet.add(array[i]);
+        }
+        Collection<? extends Integer> c = treeSet;
+        PriorityQueue<Integer> queue = new PriorityQueue<Integer>(c);
+        assertEquals(treeSet.comparator(), queue.comparator());
+        Iterator<Integer> iter = treeSet.iterator();
+        while (iter.hasNext()) {
+            assertEquals(iter.next(), queue.poll());
+        }
+        assertEquals(0, queue.size());
+    }
+
+    /**
+     * @tests java.util.PriorityQueue#PriorityQueue(PriorityQueue<? * extends
+     *        E>)
+     */
+    public void test_ConstructorLjava_util_PriorityQueue() {
+        PriorityQueue<Integer> integerQueue = new PriorityQueue<Integer>();
+        int[] array = { 2, 45, 7, -12, 9 };
+        for (int i = 0; i < array.length; i++) {
+            integerQueue.offer(array[i]);
+        }
+        PriorityQueue<Object> objectQueue = new PriorityQueue<Object>(
+                integerQueue);
+        assertEquals(integerQueue.size(), objectQueue.size());
+        assertEquals(integerQueue.comparator(), objectQueue.comparator());
+        Arrays.sort(array);
+        for (int i = 0; i < array.length; i++) {
+            assertEquals(array[i], objectQueue.poll());
+        }
+    }
+
+    /**
+     * @tests java.util.PriorityQueue#PriorityQueue(PriorityQueue<? * extends
+     *        E>)
+     */
+    public void test_ConstructorLjava_util_PriorityQueue_null() {
+        try {
+            new PriorityQueue<Object>((PriorityQueue<Integer>) null);
+            fail("should throw NullPointerException");
+        } catch (NullPointerException e) {
+            // expected
+        }
+    }
+
+    /**
+     * @tests java.util.PriorityQueue#PriorityQueue(SortedSet<? extends E>)
+     */
+    public void test_ConstructorLjava_util_SortedSet() {
+        int[] array = { 3, 5, 79, -17, 5 };
+        TreeSet<Integer> treeSet = new TreeSet<Integer>();
+        for (int i = 0; i < array.length; i++) {
+            treeSet.add(array[i]);
+        }
+        PriorityQueue<Integer> queue = new PriorityQueue<Integer>(treeSet);
+        Iterator<Integer> iter = treeSet.iterator();
+        while (iter.hasNext()) {
+            assertEquals(iter.next(), queue.poll());
+        }
+    }
+
+    /**
+     * @tests java.util.PriorityQueue#PriorityQueue(SortedSet<? extends E>)
+     */
+    public void test_ConstructorLjava_util_SortedSet_null() {
+        try {
+            new PriorityQueue<Integer>((SortedSet<? extends Integer>) null);
+            fail("should throw NullPointerException");
+        } catch (NullPointerException e) {
+            // expected
+        }
+    }
+
+    /**
+     * @tests java.util.PriorityQueue#offer(Object)
+     */
+    public void test_offerLjava_lang_Object() {
+        PriorityQueue<String> queue = new PriorityQueue<String>(10,
+                new MockComparatorStringByLength());
+        String[] array = { "AAAAA", "AA", "AAAA", "AAAAAAAA" };
+        for (int i = 0; i < array.length; i++) {
+            queue.offer(array[i]);
+        }
+        String[] sortedArray = { "AA", "AAAA", "AAAAA", "AAAAAAAA" };
+        for (int i = 0; i < sortedArray.length; i++) {
+            assertEquals(sortedArray[i], queue.poll());
+        }
+        assertEquals(0, queue.size());
+        assertNull(queue.poll());
+    }
+
+    /**
+     * @tests java.util.PriorityQueue#offer(Object)
+     */
+    public void test_offerLjava_lang_Object_null() {
+        PriorityQueue<Object> queue = new PriorityQueue<Object>();
+        try {
+            queue.offer(null);
+            fail("should throw NullPointerException");
+        } catch (NullPointerException e) {
+            // expected
+        }
+    }
+
+    /**
+     * @tests java.util.PriorityQueue#offer(Object)
+     */
+    public void test_offer_Ljava_lang_Object_non_Comparable() {
+        PriorityQueue<Object> queue = new PriorityQueue<Object>();
+        queue.offer(new Integer(10));
+        try {
+            queue.offer(new Float(1.3));
+            fail("should throw ClassCastException");
+        } catch (ClassCastException e) {
+            // expected
+        }
+
+        queue = new PriorityQueue<Object>();
+        queue.offer(new Integer(10));
+        try {
+            queue.offer(new Object());
+            fail("should throw ClassCastException");
+        } catch (ClassCastException e) {
+            // expected
+        }
+    }
+
+    /**
+     * @tests java.util.PriorityQueue#poll()
+     */
+    public void test_poll() {
+        PriorityQueue<String> stringQueue = new PriorityQueue<String>();
+        String[] array = { "MYTESTSTRING", "AAAAA", "BCDEF", "ksTRD", "AAAAA" };
+        for (int i = 0; i < array.length; i++) {
+            stringQueue.offer(array[i]);
+        }
+        Arrays.sort(array);
+        for (int i = 0; i < array.length; i++) {
+            assertEquals(array[i], stringQueue.poll());
+        }
+        assertEquals(0, stringQueue.size());
+        assertNull(stringQueue.poll());
+    }
+
+    /**
+     * @tests java.util.PriorityQueue#poll()
+     */
+    public void test_poll_empty() {
+        PriorityQueue<Object> queue = new PriorityQueue<Object>();
+        assertEquals(0, queue.size());
+        assertNull(queue.poll());
+    }
+
+    /**
+     * @tests java.util.PriorityQueue#peek()
+     */
+    public void test_peek() {
+        PriorityQueue<Integer> integerQueue = new PriorityQueue<Integer>();
+        int[] array = { 2, 45, 7, -12, 9 };
+        for (int i = 0; i < array.length; i++) {
+            integerQueue.add(array[i]);
+        }
+        Arrays.sort(array);
+        assertEquals(new Integer(array[0]), integerQueue.peek());
+        assertEquals(new Integer(array[0]), integerQueue.peek());
+    }
+
+    /**
+     * @tests java.util.PriorityQueue#peek()
+     */
+    public void test_peek_empty() {
+        PriorityQueue<Object> queue = new PriorityQueue<Object>();
+        assertEquals(0, queue.size());
+        assertNull(queue.peek());
+        assertNull(queue.peek());
+    }
+
+    /**
+     * @tests java.util.PriorityQueue#Clear()
+     */
+    public void test_clear() {
+        PriorityQueue<Integer> integerQueue = new PriorityQueue<Integer>();
+        int[] array = { 2, 45, 7, -12, 9 };
+        for (int i = 0; i < array.length; i++) {
+            integerQueue.offer(array[i]);
+        }
+        integerQueue.clear();
+        assertTrue(integerQueue.isEmpty());
+    }
+
+    /**
+     * @tests java.util.PriorityQueue#add(Object)
+     */
+    public void test_add_Ljava_lang_Object() {
+        PriorityQueue<Integer> integerQueue = new PriorityQueue<Integer>();
+        Integer[] array = { 2, 45, 7, -12, 9 };
+        for (int i = 0; i < array.length; i++) {
+            integerQueue.add(array[i]);
+        }
+        Arrays.sort(array);
+        assertEquals(array.length, integerQueue.size());
+        for (int i = 0; i < array.length; i++) {
+            assertEquals(array[i], integerQueue.poll());
+        }
+        assertEquals(0, integerQueue.size());
+    }
+
+    /**
+     * @tests java.util.PriorityQueue#add(Object)
+     */
+    public void test_add_Ljava_lang_Object_null() {
+        PriorityQueue<Object> queue = new PriorityQueue<Object>();
+        try {
+            queue.add(null);
+            fail("should throw NullPointerException");
+        } catch (NullPointerException e) {
+            // expected
+        }
+    }
+
+    /**
+     * @tests java.util.PriorityQueue#add(Object)
+     */
+    public void test_add_Ljava_lang_Object_non_Comparable() {
+        PriorityQueue<Object> queue = new PriorityQueue<Object>();
+        queue.add(new Integer(10));
+        try {
+            queue.add(new Float(1.3));
+            fail("should throw ClassCastException");
+        } catch (ClassCastException e) {
+            // expected
+        }
+
+        queue = new PriorityQueue<Object>();
+        queue.add(new Integer(10));
+        try {
+            queue.add(new Object());
+            fail("should throw ClassCastException");
+        } catch (ClassCastException e) {
+            // expected
+        }
+    }
+
+    /**
+     * @tests java.util.PriorityQueue#remove(Object)
+     * 
+     */
+    public void test_remove_Ljava_lang_Object() {
+        Integer[] array = { 2, 45, 7, -12, 9, 23, 17, 1118, 10, 16, 39 };
+        List<Integer> list = Arrays.asList(array);
+        PriorityQueue<Integer> integerQueue = new PriorityQueue<Integer>(list);
+        assertTrue(integerQueue.remove(16));
+        Integer[] newArray = { 2, 45, 7, -12, 9, 23, 17, 1118, 10, 39 };
+        Arrays.sort(newArray);
+        for (int i = 0; i < newArray.length; i++) {
+            assertEquals(newArray[i], integerQueue.poll());
+        }
+        assertEquals(0, integerQueue.size());
+    }
+
+    /**
+     * @tests java.util.PriorityQueue#remove(Object)
+     * 
+     */
+    public void test_remove_Ljava_lang_Object_using_comparator() {
+        PriorityQueue<String> queue = new PriorityQueue<String>(10,
+                new MockComparatorStringByLength());
+        String[] array = { "AAAAA", "AA", "AAAA", "AAAAAAAA" };
+        for (int i = 0; i < array.length; i++) {
+            queue.offer(array[i]);
+        }
+        assertFalse(queue.contains("BB"));
+        assertTrue(queue.remove("BB"));
+    }
+
+    /**
+     * @tests java.util.PriorityQueue#remove(Object)
+     * 
+     */
+    public void test_remove_Ljava_lang_Object_not_exists() {
+        Integer[] array = { 2, 45, 7, -12, 9, 23, 17, 1118, 10, 16, 39 };
+        List<Integer> list = Arrays.asList(array);
+        PriorityQueue<Integer> integerQueue = new PriorityQueue<Integer>(list);
+        assertFalse(integerQueue.remove(111));
+        assertFalse(integerQueue.remove(null));
+        try {
+            integerQueue.remove("");
+            fail("should throw ClassCastException");
+        } catch (ClassCastException e) {
+            // expected
+        }
+    }
+
+    /**
+     * @tests java.util.PriorityQueue#remove(Object)
+     * 
+     */
+    public void test_remove_Ljava_lang_Object_null() {
+        Integer[] array = { 2, 45, 7, -12, 9, 23, 17, 1118, 10, 16, 39 };
+        List<Integer> list = Arrays.asList(array);
+        PriorityQueue<Integer> integerQueue = new PriorityQueue<Integer>(list);
+        assertFalse(integerQueue.remove(null));
+    }
+
+    /**
+     * @tests java.util.PriorityQueue#remove(Object)
+     * 
+     */
+    public void test_remove_Ljava_lang_Object_not_Compatible() {
+        Integer[] array = { 2, 45, 7, -12, 9, 23, 17, 1118, 10, 16, 39 };
+        List<Integer> list = Arrays.asList(array);
+        PriorityQueue<Integer> integerQueue = new PriorityQueue<Integer>(list);
+        try {
+            integerQueue.remove(new Float(1.3F));
+            fail("should throw ClassCastException");
+        } catch (ClassCastException e) {
+            // expected
+        }
+
+        // although argument element type is not compatible with those in queue,
+        // but comparator supports it.
+        MockComparator<Object> comparator = new MockComparator<Object>();
+        PriorityQueue<Integer> integerQueue1 = new PriorityQueue<Integer>(100,
+                comparator);
+        integerQueue1.offer(1);
+        assertFalse(integerQueue1.remove(new Float(1.3F)));
+
+        PriorityQueue<Object> queue = new PriorityQueue<Object>();
+        Object o = new Object();
+        queue.offer(o);
+        try {
+            queue.remove(o);
+            fail("should throw ClassCastException");
+        } catch (ClassCastException e) {
+            // expected
+        }
+    }
+
+    /**
+     * @tests java.util.PriorityQueue#comparator()
+     */
+    public void test_comparator() {
+        PriorityQueue<Object> queue = new PriorityQueue<Object>();
+        assertNull(queue.comparator());
+
+        MockComparator<Object> comparator = new MockComparator<Object>();
+        queue = new PriorityQueue<Object>(100, comparator);
+        assertEquals(comparator, queue.comparator());
+    }
+
+    /**
+     * @tests serialization/deserialization.
+     */
+    public void test_Serialization() throws Exception {
+        Integer[] array = { 2, 45, 7, -12, 9, 23, 17, 1118, 10, 16, 39 };
+        List<Integer> list = Arrays.asList(array);
+        PriorityQueue<Integer> srcIntegerQueue = new PriorityQueue<Integer>(
+                list);
+        PriorityQueue<Integer> destIntegerQueue = (PriorityQueue<Integer>) SerializationTester
+                .getDeserilizedObject(srcIntegerQueue);
+        Arrays.sort(array);
+        for (int i = 0; i < array.length; i++) {
+            assertEquals(array[i], destIntegerQueue.poll());
+        }
+        assertEquals(0, destIntegerQueue.size());
+    }
+
+    /**
+     * @tests serialization/deserialization.
+     */
+    public void test_Serialization_casting() throws Exception {
+        Integer[] array = { 2, 45, 7, -12, 9, 23, 17, 1118, 10, 16, 39 };
+        List<Integer> list = Arrays.asList(array);
+        PriorityQueue<Integer> srcIntegerQueue = new PriorityQueue<Integer>(
+                list);
+        PriorityQueue<String> destStringQueue = (PriorityQueue<String>) SerializationTester
+                .getDeserilizedObject(srcIntegerQueue);
+        // will not incur class cast exception.
+        Object o = destStringQueue.peek();
+        Arrays.sort(array);
+        Integer I = (Integer) o;
+        assertEquals(array[0], I);
+    }
+
+    /**
+     * @tests serialization/deserialization compatibility with RI.
+     */
+    public void test_SerializationCompatibility_cast() throws Exception {
+        Integer[] array = { 2, 45, 7, -12, 9, 23, 17, 1118, 10, 16, 39 };
+        List<Integer> list = Arrays.asList(array);
+        PriorityQueue<Integer> srcIntegerQueue = new PriorityQueue<Integer>(
+                list);
+        PriorityQueue<String> destStringQueue = (PriorityQueue<String>) SerializationTester
+                .readObject(srcIntegerQueue, SERIALIZATION_FILE_NAME);
+
+        // will not incur class cast exception.
+        Object o = destStringQueue.peek();
+        Arrays.sort(array);
+        Integer I = (Integer) o;
+        assertEquals(array[0], I);
+    }
+
+    private static class MockComparator<E> implements Comparator<E> {
+
+        public int compare(E object1, E object2) {
+            int hashcode1 = object1.hashCode();
+            int hashcode2 = object2.hashCode();
+            if (hashcode1 > hashcode2) {
+                return 1;
+            } else if (hashcode1 == hashcode2) {
+                return 0;
+            } else {
+                return -1;
+            }
+        }
+    }
+
+    private static class MockComparatorStringByLength implements
+            Comparator<String> {
+
+        public int compare(String object1, String object2) {
+            int length1 = object1.length();
+            int length2 = object2.length();
+            if (length1 > length2) {
+                return 1;
+            } else if (length1 == length2) {
+                return 0;
+            } else {
+                return -1;
+            }
+        }
+
+    }
+
+    private static class MockComparatorCast<E> implements Comparator<E> {
+
+        public int compare(E object1, E object2) {
+            return 0;
+        }
+    }
+
+}

Added: incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/resources/serialization/java/util/PriorityQueue.golden.ser
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/resources/serialization/java/util/PriorityQueue.golden.ser?rev=415247&view=auto
==============================================================================
Binary file - no diff available.

Propchange: incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/resources/serialization/java/util/PriorityQueue.golden.ser
------------------------------------------------------------------------------
    svn:mime-type = application/octet-stream



Mime
View raw message