Request for review : 7121314 : Behavior mismatch between AbstractCollection.toArray(T[] ) and its spec (original) (raw)

Sun Apr 1 03:25:59 UTC 2012

      in concurrent modification.
 static class TestCollection<E> extends AbstractCollection<E> {

     private final E[] elements;

     private int[] sizes;
     private int nextSize;

     public TestCollection(E[] elements) {
        this.elements = elements;
        setSizeSequence(new int[]{elements.length});
     }

     /*
      * Sets the values that size() will return on each use. The next
      * call to size will return sizes[0], then sizes[1] etc. This
      * allows us to emulate a concurrent change to the contents of
      * the collection without having to perform concurrent changes.
      * If sizes[n+1] contains a larger value, the collection will 
     /* can change collection's size after each invocation */
     @Override
     public int size() {
         return sizes[nextSize == sizes.length-1 ? nextSize : 
     @Override
     public Iterator<E> iterator() {
         return new Iterator<E>() {
             int pos = 0;
             public boolean hasNext() {
                 return pos < sizes[nextSize];
             }
             public E next() {
                 return elements[pos++];
             }
             public void remove() {
                 throw new UnsupportedOperationException("Not 
 // Check incompatible type of target array
 try {
   res = CANDIDATE.toArray(new String[CAP]);
   check(false);
 } catch (Throwable t) {
   check(t instanceof ArrayStoreException);
 }

 // Check more elements than a.length
 a = new Object[CAP-1]; // appears too small
 res = CANDIDATE.toArray(a);
 check(res != a);
 check(res[LAST] != null);

 // Check equal elements as a.length
 a = new Object[CAP]; // appears to match
 res = CANDIDATE.toArray(a);
 check(res == a);
 check(res[last()] != null);

 // Check equal elements as a.length
 a = new Object[CAP+1]; // appears too big
 res = CANDIDATE.toArray(a);
 check(res == a);
 check(res[last()] == null);

 // Check less elements than expected, but more than a.length
 a = new Object[CAP-2]; // appears too small
 CANDIDATE.setSizeSequence(CAP, CAP-1);
 res = CANDIDATE.toArray(a);
 check(res != a);
 check(res.length == CAP-1);
 check(res[LAST-1] != null);

 // Check less elements than expected, but equal as a.length
 a = Arrays.copyOf(OBJECTS, CAP); // appears to match
 CANDIDATE.setSizeSequence(CAP, CAP-1);
 res = CANDIDATE.toArray(a);
 check(res == a);
 check(res[last()] == null);

 // Check more elements than expected and more than a.length
 a = new Object[CAP-1]; // appears to match
 CANDIDATE.setSizeSequence(CAP-1, CAP);
 res = CANDIDATE.toArray(a);
 check(res != a);
 check(res[LAST] != null);

 // Check more elements than expected, but equal as a.length
 a = new Object[CAP-1]; // appears to match
 CANDIDATE.setSizeSequence(CAP-2, CAP-1);
 res = CANDIDATE.toArray(a);
 check(res == a);
 check(res[last()] != null);

 // Check more elements than expected, but less than a.length
 a = Arrays.copyOf(OBJECTS, CAP); // appears to match
 CANDIDATE.setSizeSequence(CAP-2, CAP-1);
 res = CANDIDATE.toArray(a);
 check(res == a);
 check(res[last()] == null);

 test_7121314();
 // Check less elements than a.length and less than expected
 a = Arrays.copyOf(OBJECTS, CAP-1); // appears too small
 CANDIDATE.setSizeSequence(CAP, CAP-2);
 res = CANDIDATE.toArray(a);
 check(res == a);
 check(res[last()] == null);