| /* Copyright (c) 2001-2010, The HSQL Development Group |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions are met: |
| * |
| * Redistributions of source code must retain the above copyright notice, this |
| * list of conditions and the following disclaimer. |
| * |
| * Redistributions in binary form must reproduce the above copyright notice, |
| * this list of conditions and the following disclaimer in the documentation |
| * and/or other materials provided with the distribution. |
| * |
| * Neither the name of the HSQL Development Group nor the names of its |
| * contributors may be used to endorse or promote products derived from this |
| * software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |
| * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
| * ARE DISCLAIMED. IN NO EVENT SHALL HSQL DEVELOPMENT GROUP, HSQLDB.ORG, |
| * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, |
| * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, |
| * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
| * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND |
| * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS |
| * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| |
| package org.hsqldb.test; |
| |
| import java.util.ArrayList; |
| import java.util.Enumeration; |
| import java.util.Random; |
| import java.util.Vector; |
| |
| import org.hsqldb.lib.HsqlArrayList; |
| import org.hsqldb.lib.HsqlLinkedList; |
| import org.hsqldb.lib.HsqlList; |
| import org.hsqldb.lib.StopWatch; |
| |
| import junit.framework.TestCase; |
| |
| /** |
| * Randomly excutes methods on the HsqlList data structures and compares the |
| * results with equivalent calls on the java vector class. |
| * |
| * @author dnordahl@users |
| */ |
| public class TestDataStructures extends TestCase { |
| |
| private static final int NUMBER_OF_TEST_RUNS = 100000; |
| private static final int NUMBER_OF_ITERATIONS_PER_RUN = 80; |
| private Random randomGenerator; |
| |
| //Commands |
| private static final int ADD = 1; |
| private static final int ADD_AT = 2; |
| private static final int GET = 3; |
| private static final int REMOVE = 4; |
| private static final int SET = 5; |
| private static final int OPTIMIZE = 6; |
| private static final int REMOVE_ALL = 7; |
| private Vector listCommandsCalled; |
| |
| /** Creates a new instance of TestDataStructures */ |
| public TestDataStructures(String s) { |
| |
| super(s); |
| |
| randomGenerator = new Random(System.currentTimeMillis()); |
| listCommandsCalled = new Vector(NUMBER_OF_ITERATIONS_PER_RUN); |
| } |
| |
| /** Runs a test on the hsqldb lists */ |
| public void testLists() { |
| |
| HsqlArrayList arrayList = new HsqlArrayList(); |
| HsqlLinkedList linkedList = new HsqlLinkedList(); |
| Vector vector = new Vector(); |
| Vector listCommandsCalled = new Vector(NUMBER_OF_ITERATIONS_PER_RUN); |
| Integer tempInt = null; |
| int tempCommandCode; |
| int tempPosition; |
| boolean arrayListException = false; |
| boolean linkedListException = false; |
| boolean vectorException = false; |
| Object arrayListObject = null; |
| Object linkedListObject = null; |
| Object vectorObject = null; |
| |
| for (int i = 0; i < getRandomInt(3, 12); i++) { // prime the contents with a couple items |
| tempInt = getRandomInteger(); |
| |
| arrayList.add(tempInt); |
| linkedList.add(tempInt); |
| vector.addElement(tempInt); |
| listCommandsCalled.addElement("Add"); |
| } |
| |
| compareLists(arrayList, linkedList, vector); |
| |
| for (int j = 0; j < NUMBER_OF_ITERATIONS_PER_RUN; j++) { |
| tempCommandCode = getRandomInt(0, 15); // 0 and 8 are ignored or used for a special op |
| |
| switch (tempCommandCode) { |
| |
| case ADD : |
| tempInt = getRandomInteger(); |
| |
| listCommandsCalled.addElement("Add"); |
| arrayList.add(tempInt); |
| linkedList.add(tempInt); |
| vector.addElement(tempInt); |
| break; |
| |
| case ADD_AT : |
| tempInt = getRandomInteger(); |
| tempPosition = getRandomInt(0, vector.size()); |
| |
| listCommandsCalled.addElement("Add at " + tempPosition); |
| |
| try { |
| arrayList.add(tempPosition, tempInt); |
| } catch (Exception ex) { |
| arrayListException = true; |
| } |
| |
| try { |
| linkedList.add(tempPosition, tempInt); |
| } catch (Exception ex) { |
| linkedListException = true; |
| } |
| |
| try { |
| vector.insertElementAt(tempInt, tempPosition); |
| } catch (Exception ex) { |
| vectorException = true; |
| } |
| break; |
| |
| case GET : |
| tempPosition = getRandomInt(0, vector.size() -1); |
| |
| listCommandsCalled.addElement("Get " + tempPosition); |
| |
| try { |
| arrayListObject = arrayList.get(tempPosition); |
| } catch (Exception ex) { |
| arrayListException = true; |
| } |
| |
| try { |
| linkedListObject = linkedList.get(tempPosition); |
| } catch (Exception ex) { |
| linkedListException = true; |
| } |
| |
| try { |
| vectorObject = vector.elementAt(tempPosition); |
| } catch (Exception ex) { |
| vectorException = true; |
| } |
| break; |
| |
| case REMOVE : |
| tempPosition = getRandomInt(0, vector.size() - 1); |
| |
| listCommandsCalled.addElement("Remove " + tempPosition); |
| |
| try { |
| arrayListObject = arrayList.remove(tempPosition); |
| } catch (Exception ex) { |
| arrayListException = true; |
| } |
| |
| try { |
| linkedListObject = linkedList.remove(tempPosition); |
| } catch (Exception ex) { |
| linkedListException = true; |
| } |
| |
| try { |
| vectorObject = vector.elementAt(tempPosition); |
| |
| vector.removeElementAt(tempPosition); |
| } catch (Exception ex) { |
| vectorException = true; |
| } |
| break; |
| |
| case SET : |
| tempInt = getRandomInteger(); |
| tempPosition = getRandomInt(0, vector.size() -1); |
| |
| listCommandsCalled.addElement("Set " + tempPosition); |
| |
| try { |
| arrayList.set(tempPosition, tempInt); |
| } catch (Exception ex) { |
| arrayListException = true; |
| } |
| |
| try { |
| linkedList.set(tempPosition, tempInt); |
| } catch (Exception ex) { |
| linkedListException = true; |
| } |
| |
| try { |
| vector.setElementAt(tempInt, tempPosition); |
| } catch (Exception ex) { |
| vectorException = true; |
| } |
| break; |
| |
| case OPTIMIZE : |
| listCommandsCalled.addElement("Optimize"); |
| arrayList.trim(); |
| vector.trimToSize(); |
| break; |
| |
| case REMOVE_ALL : |
| if (getRandomInt(0, 5) == 4) { // to limit the frequency of this call |
| listCommandsCalled.addElement("Remove all"); |
| |
| if (vector.size() == 0) { |
| break; |
| } |
| |
| for (int k = arrayList.size() - 1; k >= 0; k--) { |
| arrayList.remove(k); |
| linkedList.remove(k); |
| } |
| |
| vector.removeAllElements(); |
| } |
| break; |
| |
| default : |
| } |
| |
| if (arrayListException || linkedListException || vectorException) { |
| |
| // if an exception is thrown in vector but not one of the lists or vice versa |
| if (!(arrayListException && linkedListException |
| && vectorException)) { |
| if (!(arrayListException && vectorException)) { |
| System.out.println( |
| "Exception descrepancy with vector and arraylist"); |
| } else if (!(linkedListException && vectorException)) { |
| System.out.println( |
| "Exception descrepancy with vector and linkedlist"); |
| } else { |
| System.out.println("Error in TestDataStructures"); |
| } |
| |
| this.printListCommandsCalled(listCommandsCalled); |
| fail("test failed"); |
| |
| //System.exit(0); |
| } |
| |
| return; |
| } |
| |
| if (!objectEquals(linkedListObject, arrayListObject, |
| vectorObject)) { |
| System.out.println("Objects returned inconsistent"); |
| this.printListCommandsCalled(listCommandsCalled); |
| fail("test failed"); |
| |
| //System.exit(0); |
| } |
| |
| compareLists(arrayList, linkedList, vector); |
| } |
| } |
| |
| /** |
| * Compare contents of lists to the vector. Print out stuff if they are |
| * inconsistent and exit. |
| */ |
| public void compareLists(HsqlArrayList arrayList, |
| HsqlLinkedList linkedList, Vector vector) { |
| |
| boolean arrayListError = false; |
| boolean linkedListError = false; |
| |
| if (!equalsVector(arrayList, vector)) { |
| System.out.println("Error in array list implementation"); |
| |
| arrayListError = true; |
| } |
| |
| if (!equalsVector(linkedList, vector)) { |
| System.out.println("Error in linked list implementation"); |
| |
| linkedListError = true; |
| } |
| |
| if (arrayListError || linkedListError) { |
| this.printListCommandsCalled(listCommandsCalled); |
| System.out.flush(); |
| fail("test failed"); |
| } |
| } |
| |
| /** Prints the list of commands called so far */ |
| public void printListCommandsCalled(Vector commands) { |
| |
| int commandCode = 0; |
| |
| for (int i = 0; i < commands.size(); i++) { |
| System.out.println((String) commands.elementAt(i)); |
| } |
| |
| System.out.flush(); |
| } |
| |
| /** Returns whether three objects are equal */ |
| private boolean objectEquals(Object lObject, Object aObject, |
| Object vObject) { |
| |
| if (lObject == null && aObject == null && vObject == null) { |
| return true; |
| } |
| |
| try { |
| if (!lObject.equals(vObject)) { |
| System.out.println("LinkList object returned inconsistent"); |
| |
| return false; |
| } else if (!aObject.equals(vObject)) { |
| System.out.println("ArrayList object returned inconsistent"); |
| |
| return false; |
| } else { |
| return true; |
| } |
| } catch (NullPointerException ex) { |
| return false; |
| } |
| } |
| |
| /** Returns a random integer in the range of the lowBound and highBound */ |
| private int getRandomInt(int lowBound, int highBound) { |
| |
| double random = randomGenerator.nextDouble(); |
| |
| return ((int) (((highBound - lowBound) * random) + .5)) + lowBound; |
| } |
| |
| /** |
| * Returns an Integer object with a value between Integer.MIN_VALUE and |
| * Integer.MAX_VALUE |
| */ |
| private Integer getRandomInteger() { |
| return new Integer(getRandomInt(0, (int) (Integer.MAX_VALUE / 100.0))); |
| } |
| |
| /** Tells whether the given list contains the same data as the vector */ |
| private boolean equalsVector(HsqlList list, Vector vector) { |
| |
| if (list.size() != vector.size()) { |
| return false; |
| } |
| |
| org.hsqldb.lib.Iterator listElements = list.iterator(); |
| Enumeration vectorElements = vector.elements(); |
| Object listObj = null; |
| Object vectorObj = null; |
| |
| while (listElements.hasNext()) { |
| listObj = listElements.next(); |
| vectorObj = vectorElements.nextElement(); |
| |
| if (!listObj.equals(vectorObj)) { |
| return false; |
| } |
| } |
| |
| return true; |
| } |
| |
| public void testGrowth() { |
| |
| HsqlArrayList d = new HsqlArrayList(); |
| |
| for (int i = 0; i < 12; i++) { |
| d.add(new Integer(i)); |
| } |
| |
| for (int i = 0; i < d.size(); i++) { |
| System.out.println(d.get(i)); |
| } |
| |
| d = new HsqlArrayList(); |
| |
| for (int i = 0; i < 12; i++) { |
| d.add(new Integer(i)); |
| } |
| |
| d.set(11, new Integer(11)); |
| |
| for (int i = 0; i < d.size(); i++) { |
| System.out.println(d.get(i)); |
| } |
| |
| org.hsqldb.lib.Iterator it = d.iterator(); |
| |
| for (int i = 0; it.hasNext(); i++) { |
| Integer value = (Integer) it.next(); |
| |
| System.out.println(value); |
| assertEquals(i, value.intValue()); |
| } |
| |
| //- |
| assertEquals(12, d.size()); |
| } |
| |
| public void testSpeed() { |
| |
| randomGenerator = new Random(System.currentTimeMillis()); |
| |
| int TEST_RUNS = 100000; |
| int LOOP_COUNT = 1000; |
| HsqlArrayList arrayList = new HsqlArrayList(TEST_RUNS); |
| ArrayList utilArrayList = new ArrayList(TEST_RUNS); |
| Vector vector = new Vector(TEST_RUNS); |
| Integer value = new Integer(randomGenerator.nextInt()); |
| Integer INT_0 = new Integer(0); |
| StopWatch sw = new StopWatch(); |
| |
| System.out.println(sw.currentElapsedTimeToMessage("time")); |
| |
| for (int i = 0; i < TEST_RUNS; i++) { |
| arrayList.add(INT_0); |
| } |
| |
| for (int i = 0; i < TEST_RUNS; i++) { |
| for (int j = 0; j < LOOP_COUNT; j++) { |
| arrayList.set(i, INT_0); |
| } |
| } |
| |
| System.out.println(sw.currentElapsedTimeToMessage("time HsqlArrayLsit")); |
| sw.zero(); |
| |
| for (int i = 0; i < TEST_RUNS; i++) { |
| utilArrayList.add(INT_0); |
| } |
| |
| for (int i = 0; i < TEST_RUNS; i++) { |
| for (int j = 0; j < LOOP_COUNT; j++) { |
| utilArrayList.set(i, INT_0); |
| } |
| } |
| |
| System.out.println(sw.currentElapsedTimeToMessage("time ArrayList")); |
| sw.zero(); |
| |
| for (int i = 0; i < TEST_RUNS; i++) { |
| vector.addElement(INT_0); |
| } |
| |
| for (int i = 0; i < TEST_RUNS; i++) { |
| for (int j = 0; j < LOOP_COUNT; j++) { |
| vector.setElementAt(INT_0, i); |
| } |
| } |
| |
| System.out.println(sw.currentElapsedTimeToMessage("time Vector")); |
| } |
| |
| public static void main(String[] args) { |
| |
| TestDataStructures test = new TestDataStructures("testLists"); |
| |
| for (int i = 0; i < NUMBER_OF_TEST_RUNS; i++) { |
| test.testLists(); |
| |
| if (i % 1000 == 0) { |
| System.out.println("Finished " + i + " tests"); |
| System.out.flush(); |
| } |
| } |
| |
| System.out.println( |
| "After " + NUMBER_OF_TEST_RUNS + " tests of a maximum of " |
| + NUMBER_OF_ITERATIONS_PER_RUN |
| + " list commands each test, the list tests passed"); |
| test.testGrowth(); |
| } |
| } |
