harmony-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From telli...@apache.org
Subject svn commit: r549073 - in /harmony/enhanced/classlib/branches/java6/modules/luni/src: main/java/java/util/PriorityQueue.java test/api/common/tests/api/java/util/PriorityQueueTest.java
Date Wed, 20 Jun 2007 11:33:48 GMT
Author: tellison
Date: Wed Jun 20 04:33:47 2007
New Revision: 549073

URL: http://svn.apache.org/viewvc?view=rev&rev=549073
Log:
Apply patch HARMONY-4203 ([classlib][luni][java6] New feature of java.util.PriorityQueue for
java6)

Modified:
    harmony/enhanced/classlib/branches/java6/modules/luni/src/main/java/java/util/PriorityQueue.java
    harmony/enhanced/classlib/branches/java6/modules/luni/src/test/api/common/tests/api/java/util/PriorityQueueTest.java

Modified: harmony/enhanced/classlib/branches/java6/modules/luni/src/main/java/java/util/PriorityQueue.java
URL: http://svn.apache.org/viewvc/harmony/enhanced/classlib/branches/java6/modules/luni/src/main/java/java/util/PriorityQueue.java?view=diff&rev=549073&r1=549072&r2=549073
==============================================================================
--- harmony/enhanced/classlib/branches/java6/modules/luni/src/main/java/java/util/PriorityQueue.java
(original)
+++ harmony/enhanced/classlib/branches/java6/modules/luni/src/main/java/java/util/PriorityQueue.java
Wed Jun 20 04:33:47 2007
@@ -19,6 +19,7 @@
 import java.io.ObjectInputStream;
 import java.io.ObjectOutputStream;
 import java.io.Serializable;
+import java.lang.reflect.Array;
 
 /**
  * PriorityQueue holds elements on a priority heap, which orders elements
@@ -230,17 +231,13 @@
         if (o == null) {
             return false;
         }
-        int targetIndex;
-        for (targetIndex = 0; targetIndex < size; targetIndex++) {
-            if (0 == this.compare((E) o, elements[targetIndex])) {
-                break;
+        for (int i = 0; i < size; i++) {
+            if (elements[i].equals(o)) {
+                removeAt(i);
+                return true;
             }
         }
-        if (size == 0 || size == targetIndex) {
-            return false;
-        }
-        removeAt(targetIndex);
-        return true;
+        return false;
     }
 
     /**
@@ -256,6 +253,73 @@
     @Override
     public boolean add(E o) {
         return offer(o);
+    }
+    
+    /**
+     * Answers if there is an element in this queue equals to the object.
+     * 
+     * @see java.util.AbstractCollection#contains(java.lang.Object)
+     */
+    @Override
+    public boolean contains(Object object) {
+        for (int i = 0; i < size; i++) {
+            if(elements[i].equals(object)){
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Returns all the elements in an array. The result is a copy of all the
+     * elements.
+     * 
+     * @return the Array of all the elements
+     * @see java.util.AbstractCollection#toArray()
+     */
+    @Override
+    public Object[] toArray() {
+        return newArray(new Object[size()]);
+    }
+
+    /**
+     * Returns all the elements in an array, and the type of the result array is
+     * the type of the argument array. If the argument array is big enough, the
+     * elements from the queue will be stored in it(element immediately
+     * following the end of the queue is set to null, if any); otherwise, it
+     * will return a new array with the size of the argument array and size of
+     * the queue.
+     * 
+     * @param <T>
+     *            the type of elements in the array
+     * @param array
+     *            the array stores all the elements from the queue, if it has
+     *            enough space; otherwise, a new array of the same type and the
+     *            size of the queue will be used
+     * @return the Array of all the elements
+     * @throws ArrayStoreException
+     *             if the type of the argument array is not compatible with
+     *             every element in the queue
+     * @throws NullPointerException
+     *             if the argument array is null
+     * @see java.util.AbstractCollection#toArray(T[])
+     */
+    @Override
+    public <T> T[] toArray(T[] array) {
+        return newArray(array);
+    }
+
+    @SuppressWarnings("unchecked")
+    private <T> T[] newArray(T[] array) {
+        if (size > array.length) {
+            Class<?> clazz = array.getClass().getComponentType();
+            array = (T[]) Array.newInstance(clazz, size);
+        }
+        System.arraycopy(elements, 0, array, 0, size);
+        if (size < array.length) {
+            array[size] = null;
+        }
+        return array;
     }
 
     private class PriorityIterator implements Iterator<E> {

Modified: harmony/enhanced/classlib/branches/java6/modules/luni/src/test/api/common/tests/api/java/util/PriorityQueueTest.java
URL: http://svn.apache.org/viewvc/harmony/enhanced/classlib/branches/java6/modules/luni/src/test/api/common/tests/api/java/util/PriorityQueueTest.java?view=diff&rev=549073&r1=549072&r2=549073
==============================================================================
--- harmony/enhanced/classlib/branches/java6/modules/luni/src/test/api/common/tests/api/java/util/PriorityQueueTest.java
(original)
+++ harmony/enhanced/classlib/branches/java6/modules/luni/src/test/api/common/tests/api/java/util/PriorityQueueTest.java
Wed Jun 20 04:33:47 2007
@@ -27,9 +27,8 @@
 import java.util.SortedSet;
 import java.util.TreeSet;
 
-import tests.util.SerializationTester;
-
 import junit.framework.TestCase;
+import tests.util.SerializationTester;
 
 public class PriorityQueueTest extends TestCase {
 
@@ -594,7 +593,7 @@
             queue.offer(array[i]);
         }
         assertFalse(queue.contains("BB"));
-        assertTrue(queue.remove("BB"));
+        assertFalse(queue.remove("BB"));
     }
 
     /**
@@ -607,12 +606,7 @@
         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
-        }
+        assertFalse(integerQueue.remove(""));
     }
 
     /**
@@ -634,12 +628,7 @@
         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
-        }
+        assertFalse(integerQueue.remove(new Float(1.3F)));
 
         // although argument element type is not compatible with those in queue,
         // but comparator supports it.
@@ -652,12 +641,7 @@
         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
-        }
+        assertTrue(queue.remove(o));
     }
 
     /**
@@ -671,7 +655,7 @@
         queue = new PriorityQueue<Object>(100, comparator);
         assertEquals(comparator, queue.comparator());
     }
-
+    
     /**
      * @tests serialization/deserialization.
      */
@@ -722,6 +706,73 @@
         Arrays.sort(array);
         Integer I = (Integer) o;
         assertEquals(array[0], I);
+    }
+    
+    /**
+     * @tests {@link PriorityQueue#contains(Object)}
+     */
+    public void test_contains() throws Exception {
+        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]);
+        }
+        for (int i = 0; i < array.length; i++) {
+            assertTrue(integerQueue.contains(array[i]));
+        }
+        assertFalse(integerQueue.contains(null));
+    }
+    
+    /**
+     * @tests {@link PriorityQueue#toArray()}
+     */
+    public void test_toArray() throws Exception {
+        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]);
+        }
+        Object[] returnArray = integerQueue.toArray();
+        assertEquals(returnArray.length,integerQueue.size());
+        for (int i = 0; i < returnArray.length; i++) {
+            assertTrue(integerQueue.contains(returnArray[i]));
+        }
+    }
+    
+    /**
+     * @tests {@link PriorityQueue#toArray(T[])}
+     */
+    public void test_toArray_$T() throws Exception {
+        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]);
+        }
+        Object[] returnArray = integerQueue.toArray(new Integer[0]);
+        assertEquals(returnArray.length,integerQueue.size());
+        for (int i = 0; i < returnArray.length; i++) {
+            assertTrue(integerQueue.contains(returnArray[i]));
+        }
+        returnArray = integerQueue.toArray(new Integer[10]);
+        assertEquals(10,returnArray.length);
+        for (int i = 0; i < array.length; i++) {
+            assertTrue(integerQueue.contains(returnArray[i]));
+        }
+        for (int i = array.length; i < 10; i++) {
+            assertNull(returnArray[i]);
+        }
+        try {
+            integerQueue.toArray(null);
+            fail("should throw NullPointerException");
+        } catch (NullPointerException e) {
+            // expected
+        }
+        try {
+            integerQueue.toArray(new String[1]);
+            fail("should throw ArrayStoreException");
+        } catch (ArrayStoreException e) {
+            // expected
+        }
     }
 
     private static class MockComparator<E> implements Comparator<E> {



Mime
View raw message