anchor.diff:          "Cannot add to a non-extendable array");
     }
   
  +  void sort(int compare(a, b)) {
  +    DualPivotQuicksort.sort(this, compare);
  +  }
  +
  +  int indexOf(element, [int start = 0]) {
  +    return Arrays.indexOf(this, element, start, this.length);
  +  }
  +
  +  int lastIndexOf(element, [int start = null]) {
  +    if (start === null) start = length - 1;
  +    return Arrays.lastIndexOf(this, element, start);
  +  }
  +
     void clear() {
       throw const UnsupportedOperationException(
           "Cannot remove from a non-extendable array");
     }
   
  +  int removeLast() {
  +    throw const UnsupportedOperationException(
  +        "Cannot remove from a non-extendable array");
  +  }
  +
  +  last() {
  +    return this[length - 1];
  +  }
  +
  +  void removeRange(int start, int length) {
  +    throw const UnsupportedOperationException(
  +        "Cannot remove from a non-extendable array");
  +  }
  +
     void insertRange(int start, int length, [initialValue]) {
       throw const UnsupportedOperationException(
           "Cannot add to a non-extendable array");
  -  }
  -
  -  set length(int newLength) {
  -    throw const UnsupportedOperationException(
  -        "Cannot resize a non-extendable array");
  -  }
  -
  -  int removeLast() {
  -    throw const UnsupportedOperationException(
  -        "Cannot remove from a non-extendable array");
  -  }
  -
  -  void removeRange(int start, int length) {
  -    throw const UnsupportedOperationException(
  -        "Cannot remove from a non-extendable array");
     }
   }
   
  
positive.code:         "Cannot add to a non-extendable array");
    }
  
    void clear() {
      throw const UnsupportedOperationException(
          "Cannot remove from a non-extendable array");
    }
  
    int indexOf(element, [int start = 0]) {
      for (int i = start; i < length; i++) {
        if (this[i] == element) return i;
      }
      return -1;
    }
  
    void insertRange(int start, int length, [initialValue]) {
      throw const UnsupportedOperationException(
          "Cannot add to a non-extendable array");
    }
  
    int get length() {
      return _length();
    }
  
    set length(newLength) {
      throw const UnsupportedOperationException(
          "Cannot resize a non-extendable array");
    }
  
    int removeLast() {
      throw const UnsupportedOperationException(
          "Cannot remove from a non-extendable array");
    }
  
    void removeRange(int start, int length) {
      throw const UnsupportedOperationException(
          "Cannot remove from a non-extendable array");
    }
  
    ByteArray asByteArray([int start = 0, int length]) {
  
negative.code: 
  
  abstract class _ByteArrayBase {
  
    // Methods implementing the Collection interface.
  
    void forEach(void f(element)) {
      var len = this.length;
      for (var i = 0; i < len; i++) {
        f(this[i]);
      }
    }
  
    Collection map(f(element)) {
      return Collections.map(this,
                             new GrowableObjectArray.withCapacity(length),
                             f);
    }
  
    Collection filter(bool f(element)) {
      return Collections.filter(this, new GrowableObjectArray(), f);
    }
  
    bool every(bool f(element)) {
      return Collections.every(this, f);
    }
  
    bool some(bool f(element)) {
      return Collections.some(this, f);;
    }
  
    bool isEmpty() {
      return this.length === 0;
    }
  
    int get length() {
      return _length();
    }
  
    // Methods implementing the List interface.
  
    set length(newLength) {
      throw const UnsupportedOperationException(
          "Cannot resize a non-extendable array");
    }
  
    void add(value) {
      throw const UnsupportedOperationException(
          "Cannot add to a non-extendable array");
  