/*
    * Licensed to the Apache Software Foundation (ASF) under one or more
    * contributor license agreements.  See the NOTICE file distributed with
    * this work for additional information regarding copyright ownership.
    * The ASF licenses this file to You 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 org.apache.commons.collections.primitives.adapters;
  
  import java.util.Arrays;
  import java.util.Iterator;
  import java.util.List;
  import java.util.ListIterator;
  
  import org.apache.commons.collections.BulkTest;
  import org.apache.commons.collections.list.AbstractTestList;
  
  /**
   * @version $Revision: 480451 $ $Date: 2006-11-29 02:45:08 -0500 (Wed, 29 Nov 2006) $
   * @author Rodney Waldhoff
   */
  public abstract class BaseTestList extends AbstractTestList {
  
      // conventional
      // ------------------------------------------------------------------------
  
      public BaseTestList(String testName) {
          super(testName);
      }
  
      // tests
      // ------------------------------------------------------------------------
  
      public final void testAddAllAtIndex() {
          List source = makeFullList();
          List dest = makeFullList();
          
          dest.addAll(1,source);
           
          Iterator iter = dest.iterator();
          assertTrue(iter.hasNext());
          assertEquals(source.get(0),iter.next());
          for(int i=0;i<source.size();i++) {
              assertTrue(iter.hasNext());
              assertEquals(source.get(i),iter.next());
          }
          for(int i=1;i<source.size();i++) {
              assertTrue(iter.hasNext());
              assertEquals(source.get(i),iter.next());
          }
          assertFalse(iter.hasNext());
      }
  
      /**
       * Override to change assertSame to assertEquals.
       */
      public void testListListIteratorPreviousRemove() {
          if (isRemoveSupported() == false) return;
          resetFull();
          ListIterator it = getList().listIterator();
          Object zero = it.next();
          Object one = it.next();
          Object two = it.next();
          Object two2 = it.previous();
          Object one2 = it.previous();
          assertEquals(one, one2);
          assertEquals(two, two2);
          assertEquals(zero, getList().get(0));
          assertEquals(one, getList().get(1));
          assertEquals(two, getList().get(2));
          it.remove();
          assertEquals(zero, getList().get(0));
          assertEquals(two, getList().get(1));
      }
  
      /**
       * Override to change assertSame to assertEquals.
       */
      public BulkTest bulkTestSubList() {
          if (getFullElements().length - 6 < 10) return null;
          return new PrimitiveBulkTestSubList(this);
      }
  
  
      /**
       * Whole class copied as sub list constructor was package scoped in 3.1.
       */
      public static class PrimitiveBulkTestSubList extends BaseTestList {
          private BaseTestList outer;
      
         PrimitiveBulkTestSubList(BaseTestList outer) {
             super("");
             this.outer = outer;
         }
     
         public Object[] getFullElements() {
             List l = Arrays.asList(outer.getFullElements());
             return l.subList(3, l.size() - 3).toArray();
         }
         public Object[] getOtherElements() {
             return outer.getOtherElements();
         }
         public boolean isAddSupported() {
             return outer.isAddSupported();
         }
         public boolean isSetSupported() {
             return outer.isSetSupported();
         }
         public boolean isRemoveSupported() {
             return outer.isRemoveSupported();
         }
     
         public List makeEmptyList() {
             return outer.makeFullList().subList(4, 4);
         }
         public List makeFullList() {
             int size = getFullElements().length;
             return outer.makeFullList().subList(3, size - 3);
         }
         public void resetEmpty() {
             outer.resetFull();
             this.collection = outer.getList().subList(4, 4);
             this.confirmed = outer.getConfirmedList().subList(4, 4);
         }
         public void resetFull() {
             outer.resetFull();
             int size = outer.confirmed.size();
             this.collection = outer.getList().subList(3, size - 3);
             this.confirmed = outer.getConfirmedList().subList(3, size - 3);
         }
         public void verify() {
             super.verify();
             outer.verify();
         }
         public boolean isTestSerialization() {
             return false;
         }
         /**
          * Override to change assertSame to assertEquals.
          */
         public void testListListIteratorPreviousRemove() {
             if (isRemoveSupported() == false)
                 return;
             resetFull();
             ListIterator it = getList().listIterator();
             Object zero = it.next();
             Object one = it.next();
             Object two = it.next();
             Object two2 = it.previous();
             Object one2 = it.previous();
             assertEquals(one, one2);
             assertEquals(two, two2);
             assertEquals(zero, getList().get(0));
             assertEquals(one, getList().get(1));
             assertEquals(two, getList().get(2));
             it.remove();
             assertEquals(zero, getList().get(0));
             assertEquals(two, getList().get(1));
         }
     }
 }