content: /*
   * CDDL HEADER START
   *
   * The contents of this file are subject to the terms of the Common Development
   * and Distribution License (the "License").
   * You may not use this file except in compliance with the License.
   *
   * You can obtain a copy of the license at
   * src/com/vodafone360/people/VODAFONE.LICENSE.txt or
   * http://github.com/360/360-Engine-for-Android
   * See the License for the specific language governing permissions and
   * limitations under the License.
   *
   * When distributing Covered Code, include this CDDL HEADER in each file and
   * include the License file at src/com/vodafone360/people/VODAFONE.LICENSE.txt.
   * If applicable, add the following below this CDDL HEADER, with the fields
   * enclosed by brackets "[]" replaced with your own identifying information:
   * Portions Copyright [yyyy] [name of copyright owner]
   *
   * CDDL HEADER END
   *
   * Copyright 2010 Vodafone Sales & Services Ltd.  All rights reserved.
   * Use is subject to license terms.
   */
  
  package com.vodafone360.people.tests.utils;
  
  import junit.framework.TestCase;
  
  import com.vodafone360.people.utils.DynamicArrayLong;
  
  /**
   * JUnit tests for the DynamicArrayLong class.
   * 
   * @see DynamicArrayLong
   */
  public class DynamicArrayLongTest extends TestCase {
  
      /**
       * Tests the default constructor.
       */
      public void testDefaultContructor() {
          
          DynamicArrayLong array = new DynamicArrayLong();
          
          // check that the array is empty after creation
          assertEquals(0, array.size());
      }
      
      /**
       * Tests the constructor specifying the initial capacity.
       */
      public void testConstructorWithInitialCapacity() {
          
          DynamicArrayLong array = new DynamicArrayLong(10);
          boolean exceptionThrown;
          
          // check that the array is empty after creation
          assertEquals(0, array.size());
          
          // check that exceptions are thrown with capacity <= 0
          try {
              
              exceptionThrown = false;
              array = new DynamicArrayLong(0);
          } catch(IllegalArgumentException iae) {
              
              exceptionThrown = true;
          }
          
          assertTrue(exceptionThrown);
          
          try {
              
              exceptionThrown = false;
              array = new DynamicArrayLong(-10);
          } catch(IllegalArgumentException iae) {
              
              exceptionThrown = true;
          }
          
          assertTrue(exceptionThrown);
      }
      
      /**
       * Tests the add(), get() and size() methods.
       */
      public void testAddGetSize() {
          
          final int ADDS_COUNT = 20;
          final DynamicArrayLong array = new DynamicArrayLong();
          
          // check that the array is empty after creation
          assertEquals(0, array.size());
          
          // perform checks for add/get/size methods
          for (int i = 0; i < ADDS_COUNT; i++) {
              
              final int ret = array.add(i+10);
              assertEquals(i, ret);
              assertEquals(i+10, array.get(i));
              assertEquals(i+1, array.size());
          }
      }
      
      /**
       * Tests the add(), get() and size() methods when going over the initial capacity
       */
      public void testAddGetSizeOverInitialCapacity() {
          
          final int ADDS_COUNT = 100;
          final DynamicArrayLong array = new DynamicArrayLong(ADDS_COUNT / 2);
          
          // check that the array is empty after creation
          assertEquals(0, array.size());
          
          // perform checks for add/get/size methods
          for (int i = 0; i < ADDS_COUNT; i++) {
              
              final int ret = array.add(i+10);
              assertEquals(i, ret);
              assertEquals(i+10, array.get(i));
              assertEquals(i+1, array.size());
          }
          
          // re-check the values from the beginning
          for (int i = 0; i < ADDS_COUNT; i++) {
  
              assertEquals(i+10, array.get(i));
          }
          assertEquals(ADDS_COUNT, array.size());
      }
      
      /**
       * Tests the get() method.
       */
      public void testGet() {
          
          final int ADDS_COUNT = 100;
          final DynamicArrayLong array = new DynamicArrayLong(); 
          
          testGetExceptions(array);
          
          for (int i = 0; i < ADDS_COUNT; i++) {
              
              final int ret = array.add(i+10);
              assertEquals(i, ret);
              assertEquals(i+10, array.get(i));
              assertEquals(i+1, array.size());
              testGetExceptions(array);
          }
          
          testGetExceptions(array);
      }
      
      /**
       * Tests the add(long[]) method.
       */
      public void testAddArray() {
          
          final DynamicArrayLong array = new DynamicArrayLong(10);
          final long[] subArray = new long[5];
          
          assertEquals(0, array.size());
         
          // adds arrays containing increasing number to the DynamicArrayLong 
          for (int i = 0; i <= 4; i++) {
              
              for (int j = 0; j < subArray.length; j++) {
                  subArray[j] = i * subArray.length + (j + 1);
              }
              final int index = array.add(subArray);
              assertEquals((i + 1) * subArray.length - 1, index);
              assertEquals((i + 1) * subArray.length, array.size());
          }
          
          // re-check the values from the beginning
          // it shall contain the values [1, 2, 3...19, 20] in the same order
          for (int i = 0; i < array.size(); i++) {
  
              assertEquals(i+1, array.get(i));
          }
      }
      
      /**
       * Tests the toArray() method.
       */
      public void testToArray() {
          
          final int ADDS_COUNT = 20;
          final DynamicArrayLong array = new DynamicArrayLong(ADDS_COUNT / 4);
          
          // check that the array is empty after creation
          assertEquals(0, array.size());
          
          // add the values [0..ADDS_COUNT] to the array
          for (int i = 0; i < ADDS_COUNT; i++) {
              
              array.add(i);
          }
          
          // get all the values in the DynamicArrayLong as a primitive long array
          final long[] toArray = array.toArray();
          assertEquals(ADDS_COUNT, toArray.length);
          
          // check that the values in the array are [0..ADDS_COUNT] 
          for (int i = 0; i < toArray.length; i++) {
  
              assertEquals(i, toArray[i]);
          }
      }
      
      /**
       * Helper method to test the get() exception cases to the provided DynamicArrayLong
       * 
       * @param array the DynamicArrayLong to check
       */
      private void testGetExceptions(DynamicArrayLong array) {
  
          boolean exceptionThrown;
          
          // check negative case
          try {
              
              exceptionThrown = false;
              array.get(-10);
          } catch(ArrayIndexOutOfBoundsException e) {
              
              exceptionThrown = true;
          }
          assertTrue(exceptionThrown);
          
          // check positive case
          try {
              
              exceptionThrown = false;
              array.get(array.size() + 10);
          } catch(ArrayIndexOutOfBoundsException e) {
              
              exceptionThrown = true;
          }
          assertTrue(exceptionThrown);
      }
  }
  