* Copyright (c) 2009, 2012 Erik Berglund.

*  

*      This file is part of Conserve.

*  

*       Conserve is free software: you can redistribute it and/or modify

*       it under the terms of the GNU Lesser General Public License as published by

*       the Free Software Foundation, either version 3 of the License, or

*       (at your option) any later version.

*  

*       Conserve is distributed in the hope that it will be useful,

*       but WITHOUT ANY WARRANTY; without even the implied warranty of

*       MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

*       GNU Lesser General Public License for more details.

*  

*       You should have received a copy of the GNU Lesser General Public License

*       along with Conserve.  If not, see <http://www.gnu.org/licenses/>.

*******************************************************************************/

* Integration test of various functionality.

*

* @author Erik Berglund

*

*/

  // Settings for test

  protected String driver;

  protected String database;

  protected String login;

  protected String password;

  protected String secondDatabase;

  private static final Logger LOGGER = Logger.getLogger("org.conserve");

  // create a log handler that outputs all warning events to the console

  static

  {

    ConsoleHandler consoleHandler = new ConsoleHandler();

    LOGGER.addHandler(consoleHandler);

    Level level = Level.FINE;

    LOGGER.setLevel(level);

    consoleHandler.setLevel(level);

  }

  /**

   * Classes overriding this method should set database connection strings

   * before calling deleteAll().

   *

   * @throws java.lang.Exception

   */

  @Before

  public void setUp() throws Exception

  {

    driver = "org.h2.Driver";

    database = "jdbc:h2:tcp://localhost/~/test";

    secondDatabase = "jdbc:h2:tcp://localhost/~/test2";

    login = "sa";

    password = "";

    deleteAll();

  }

  /**

   * @throws java.lang.Exception

   */

  @After

  public void tearDown() throws Exception

  {

    // deleteAll();

  }

  protected void deleteAll() throws SQLException

  {

    PersistenceManager persist = new PersistenceManager(driver, database, login, password);

    persist.deleteObjects(new Object());// clear everything

    persist.close();

  }

  /**

   * Test method for

   * {@link org.conserve.PersistenceManager#saveObject(java.lang.Object)}.

   */

  @Test

  public void testAddSimplestObject() throws Exception

  {

    PersistenceManager persist = new PersistenceManager(driver, database, login, password);

    // create a test object

    SimplestObject so = new SimplestObject();

    so.setFoo(0.67);

    persist.saveObject(so);

    persist.close();

  }

  /**

   * Test method for

   * {@link org.conserve.PersistenceManager#saveObject(java.lang.Object)}.

   */

  @Test

  public void testAddObject() throws Exception

  {

    PersistenceManager persist = new PersistenceManager(driver, database, login, password);

    // create a test object

    SimpleObject so = new SimpleObject();

    so.setAge(1000L);

    so.setCount(3);

    so.setName("foo bar");

    so.setScale(0.67);

    persist.saveObject(so);

    LessSimpleObject lso = new LessSimpleObject();

    lso.setAge(1000000L);

    lso.setCount(123456);

    lso.setKey((short) 99);

    lso.setName("j random");

    lso.setScale(-9.0);

    persist.saveObject(lso);

    // insert the same object again

    persist.saveObject(lso);

    // new less-simple object

    persist.close();

  }

  /**

   * Try returning the objects inserted, make sure the right count is

   * returned.

   *

   */

  @Test

  public void testGetObjectFromInterface() throws Exception

  {

    PersistenceManager persist = new PersistenceManager(driver, database, login, password);

    // create a test object

    SimpleObject so = new SimpleObject();

    so.setAge(1000L);

    so.setCount(3);

    so.setName("foo bar");

    so.setScale(0.67);

    persist.saveObject(so);

    LessSimpleObject lso = new LessSimpleObject();

    lso.setAge(1000000L);

    lso.setCount(123456);

    lso.setKey((short) 99);

    lso.setName("j random");

    lso.setScale(-9.0);

    persist.saveObject(lso);

    // insert the same object again

    persist.saveObject(lso);

    persist.close();

    persist = new PersistenceManager(driver, database, login, password);

    // try getting all the objects

    List<BaseInterface> obs = persist.getObjects(BaseInterface.class, new All());

    assertEquals(1, obs.size());

    persist.close();

  }

  /**

   * Try returning the objects

   *

   */

  @Test

  public void testGetObjectFromClass() throws Exception

  {

    PersistenceManager persist = new PersistenceManager(driver, database, login, password);

    // create a test object

    SimpleObject so = new SimpleObject();

    so.setAge(1000L);

    so.setCount(3);

    so.setName("foo bar");

    so.setScale(0.67);

    persist.saveObject(so);

    LessSimpleObject lso = new LessSimpleObject();

    lso.setAge(1000000L);

    lso.setCount(123456);

    lso.setKey((short) 99);

    lso.setName("j random");

    lso.setScale(-9.0);

    persist.saveObject(lso);

    // insert the same object again

    persist.saveObject(lso);

    persist.close();

    persist = new PersistenceManager(driver, database, login, password);

    // try getting all the objects

    SimpleObject pattern = new SimpleObject();

    pattern.setCount(3);

    List<SimpleObject> obs = persist.getObjects(SimpleObject.class, new GreaterOrEqual(pattern));

    assertEquals(2, obs.size());

    pattern.setCount(4);

    obs = persist.getObjects(SimpleObject.class, new GreaterOrEqual(pattern));

    assertEquals(1, obs.size());

    pattern.setCount(3);

    List<LessSimpleObject> obs2 = persist.getObjects(LessSimpleObject.class, new GreaterOrEqual(pattern));

    assertEquals(1, obs2.size());

    // assert that two objects are equal if they are the result of the same

    // search

    List<LessSimpleObject> obs3 = persist.getObjects(LessSimpleObject.class, new GreaterOrEqual(pattern));

    assertEquals(obs2.get(0), obs3.get(0));

    persist.close();

  }

  /**

   * Test deleting objects.

   */

  @Test

  public void testDeleteObject() throws Exception

  {

    PersistenceManager persist = new PersistenceManager(driver, database, login, password);

    // create a test object

    SimpleObject so = new SimpleObject();

    so.setAge(1000L);

    so.setCount(3);

    so.setName("foo bar");

    so.setScale(0.67);

    persist.saveObject(so);

    LessSimpleObject lso = new LessSimpleObject();

    lso.setAge(1000000L);

    lso.setCount(123456);

    lso.setKey((short) 99);

    lso.setName("j random");

    lso.setScale(-9.0);

    persist.saveObject(lso);

    // insert the same object again

    persist.saveObject(lso);

    persist.close();

    persist = new PersistenceManager(driver, database, login, password);

    // try deleting one object

    List<Object> allObjects = persist.getObjectsMatching(new Object());

    assertEquals(2, allObjects.size());

    // delete one LessSimpleObject

    SimpleObject pattern = new LessSimpleObject();

    persist.deleteObjects(LessSimpleObject.class, new GreaterOrEqual(pattern));

    allObjects = persist.getObjectsMatching(new Object());

    assertEquals(1, allObjects.size());

    // delete all objects

    persist.deleteObjects(new Object());

    allObjects = persist.getObjectsMatching(new Object());

    assertTrue(allObjects.isEmpty());

    persist.close();

  }

  /**

   * Test inserting complex objects.

   *

   */

  @Test

  public void testAddComplexObject() throws Exception

  {

    PersistenceManager persist = new PersistenceManager(driver, database, login, password);

    ComplexObject co = new ComplexObject(new double[] { 1.1, 2.2, 3.3 });

    LessSimpleObject so = new LessSimpleObject();

    so.setScale(0.67);

    co.setObject(so);

    SimplestObject sto = new SimplestObject();

    sto.setFoo(9999.6);

    co.setSimplestObject(sto);

    persist.saveObject(co);

    ComplexObject co2 = new ComplexObject(co.getData());

    co2.setObject(so);

    co2.setSimplestObject(sto);

    persist.saveObject(co2);

    persist.close();

    persist = new PersistenceManager(driver, database, login, password);

    // List<Object> allList = persist.getObjects(new Object());

    // assertEquals(4, allList.size());

    List<ComplexObject> complexList = persist.getObjectsMatching(new ComplexObject());

    assertEquals(2, complexList.size());

    ComplexObject a = complexList.get(0);

    ComplexObject b = complexList.get(1);

    assertEquals(a.getData(), b.getData());

    assertTrue(a.getData() != null);

    assertEquals(3, a.getData().length);

    assertTrue(a.getData()[2] == 3.3);

    persist.close();

  }

  /**

   * Add/remove/retrieve objects with arrays of complex objects.

   *

   * @throws Exception

   */

  @Test

  public void testComplexArray() throws Exception

  {

    // create the database connection

    PersistenceManager persist = new PersistenceManager(driver, database, login, password);

    ComplexObject co1 = new ComplexObject(new double[] { 1.1, 2.2, 3.3, 4.4 });

    persist.saveObject(co1);

    // create an array of complex objects

    ComplexArrayObject cao = new ComplexArrayObject();

    ComplexObject[] coArray = new ComplexObject[3];

    for (int x = 0; x < coArray.length; x++)

    {

      ComplexObject co = new ComplexObject();

      co.setData(new double[] { x, x * 2, x * 3 });

      SimpleObject so = new SimpleObject();

      so.setAge((long) x);

      co.setObject(so);

      coArray[x] = co;

    }

    cao.setData(coArray);

    persist.saveObject(cao);

    persist.close();

    persist = new PersistenceManager(driver, database, login, password);

    List<ComplexArrayObject> res = persist.getObjectsMatching(new ComplexArrayObject());

    assertEquals(1, res.size());

    ComplexArrayObject ob1 = res.get(0);

    assertEquals(3, ob1.getData().length);

    persist.close();

  }

  /**

   * Make sure no unrelated objects are deleted when deleting a complex

   * object.

   */

  @Test

  public void testDeleteComplexObject() throws Exception

  {

    // create the database connection

    PersistenceManager persist = new PersistenceManager(driver, database, login, password);

    ComplexObject co1 = new ComplexObject(new double[] { 1.1, 2.2, 3.3, 4.4 });

    // saving the object gives it an outside reference

    persist.saveObject(co1);

    // create an array of complex objects

    ComplexObject[] coArray = new ComplexObject[3];

    for (int x = 0; x < coArray.length - 1; x++)

    {

      ComplexObject co = new ComplexObject();

      co.setData(new double[] { x, x * 2, x * 3 });

      SimpleObject so = new SimpleObject();

      so.setAge((long) x);

      co.setObject(so);

      coArray[x] = co;

    }

    // one of the complex objects in the array has an outside reference

    coArray[2] = co1;

    ComplexArrayObject cao = new ComplexArrayObject();

    cao.setData(coArray);

    persist.saveObject(cao);

    persist.close();

    // check that there is one ComplexArrayObject

    persist = new PersistenceManager(driver, database, login, password);

    List<ComplexArrayObject> res = persist.getObjectsMatching(new ComplexArrayObject());

    assertEquals(1, res.size());

    ComplexArrayObject ob1 = res.get(0);

    // check that the ComplexArrayObject contains 3 ComplexObjects

    assertEquals(3, ob1.getData().length);

    persist.close();

    persist = new PersistenceManager(driver, database, login, password);

    persist.deleteObjects(new ComplexArrayObject());

    List<ComplexObject> tmp = persist.getObjectsMatching(new ComplexObject());

    assertEquals(1, tmp.size());

    persist.close();

  }

  /**

   * Test adding an array that consists of other arrays.

   *

   */

  @Test

  public void testArrayOfArrays() throws Exception

  {

    PersistenceManager persist = new PersistenceManager(driver, database, login, password);

    ComplexObject co = new ComplexObject();

    SimplestObject[][][] array = new SimplestObject[1][1][1];

    for (int x = 0; x < array.length; x++)

    {

      for (int y = 0; y < array[x].length; y++)

      {

        array[x][y][0] = new SimplestObject();

      }

    }

    co.setObject(array);

    persist.saveObject(co);

    ComplexObject co2 = new ComplexObject();

    SimplestObject[][][] array2 = new SimplestObject[1][][];

    array2[0] = array[0];

    co2.setObject(array2);

    persist.saveObject(co2);

    persist.close();

    persist = new PersistenceManager(driver, database, login, password);

    List<ComplexObject> cos = persist.getObjectsMatching(new ComplexObject());

    assertEquals(2, cos.size());

    co = cos.get(0);

    SimplestObject[][][] resArray = (SimplestObject[][][]) co.getObject();

    assertTrue(resArray != null);

    assertEquals(1, resArray.length);

    assertEquals(1, resArray[0].length);

    assertEquals(1, resArray[0][0].length);

    assertTrue(resArray[0][0][0] != null);

    co2 = cos.get(1);

    SimplestObject[][][] resArray2 = (SimplestObject[][][]) co2.getObject();

    assertTrue(resArray != resArray2);

    assertArrayEquals(resArray[0], resArray2[0]);

    persist.close();

  }

  /**

   * Makes sure that it is possible to search based on contents of complex

   * objects.

   *

   * @throws Exception

   */

  @Test

  public void testInnerMatching() throws Exception

  {

    PersistenceManager persist = new PersistenceManager(driver, database, login, password);

    SimplestObject so = new SimplestObject();

    so.setFoo(1.0);

    ComplexObject co = new ComplexObject();

    co.setObject(so);

    persist.saveObject(co);

    // close the persistence object

    persist.close();

    // re-open the persistence object

    persist = new PersistenceManager(driver, database, login, password);

    // create a SimplestObject so that no results will match

    so = new SimplestObject();

    so.setFoo(2.0);

    // make sure this matches no results

    ComplexObject search = new ComplexObject();

    search.setObject(so);

    List<ComplexObject> none = persist.getObjectsMatching(search);

    assertEquals(0, none.size());

    // change the search so that one object is returned

    so.setFoo(1.0);

    List<ComplexObject> one = persist.getObjectsMatching(search);

    assertEquals(1, one.size());

    persist.close();

  }

  /**

   * Makes sure that it is possible to search based on contents of primitive

   * arrays.

   *

   * @throws Exception

   */

  @Test

  public void testArrayMatching() throws Exception

  {

    PersistenceManager persist = new PersistenceManager(driver, database, login, password);

    // create a complex object with an Integer array as object

    Integer[] intArray = new Integer[] { 4, 5, 6 };

    ComplexObject co = new ComplexObject();

    co.setObject(intArray);

    persist.saveObject(co);

    // close the persistence object

    persist.close();

    // re-open the persistence object

    persist = new PersistenceManager(driver, database, login, password);

    // create an integer array where all entries but one is null

    Integer[] searchArray = new Integer[3];

    searchArray[2] = 7;

    // make sure this matches no results

    ComplexObject search = new ComplexObject();

    search.setObject(searchArray);

    List<ComplexObject> none = persist.getObjectsMatching(search);

    assertEquals(0, none.size());

    // change the search so that one object is returned

    searchArray[1] = 5;

    searchArray[2] = 6;

    List<ComplexObject> one = persist.getObjectsMatching(search);

    assertEquals(1, one.size());

    persist.close();

  }

  /**

   * Makes sure that it is possible to search based on contents of

   * non-primitive arrays.

   *

   * @throws Exception

   */

  @Test

  public void testComplexArrayMatching() throws Exception

  {

    PersistenceManager persist = new PersistenceManager(driver, database, login, password);

    // create a complex object with an Integer array as object

    SimplestObject[] array = new SimplestObject[] { new SimplestObject(), new SimplestObject(),

        new SimplestObject() };

    for (int x = 0; x < array.length; x++)

    {

      array[x].setFoo((double) (x + 1));

    }

    ComplexObject co = new ComplexObject();

    co.setObject(array);

    persist.saveObject(co);

    // close the persistence object

    persist.close();

    // re-open the persistence object

    persist = new PersistenceManager(driver, database, login, password);

    // create an integer array where all entries but one is null

    SimplestObject[] searchArray = new SimplestObject[3];

    searchArray[2] = new SimplestObject();

    searchArray[2].setFoo(2.0);

    // make sure this matches no results

    ComplexObject search = new ComplexObject();

    search.setObject(searchArray);

    List<ComplexObject> none = persist.getObjectsMatching(search);

    assertEquals(0, none.size());

    // change the search so that one object is returned

    searchArray[1] = new SimplestObject();

    searchArray[1].setFoo(2.0);

    searchArray[2].setFoo(3.0);

    List<ComplexObject> one = persist.getObjectsMatching(search);

    assertEquals(1, one.size());

    persist.close();

  }

  /**

   * Make sure that it is possible to search based on contents of arrays of

   * arrays.

   *

   * @throws Exception

   */

  @Test

  public void testArrayOfArraysMatching() throws Exception

  {

    PersistenceManager persist = new PersistenceManager(driver, database, login, password);

    // create a complex object with an Integer array as object

    SimplestObject[][] array = new SimplestObject[][] { {},

        { new SimplestObject(), new SimplestObject(), new SimplestObject() }, {} };

    for (int x = 0; x < array[1].length; x++)

    {

      array[1][x].setFoo((double) (x + 1));

    }

    ComplexObject co = new ComplexObject();

    co.setObject(array);

    persist.saveObject(co);

    // close the persistence object

    persist.close();

    // re-open the persistence object

    persist = new PersistenceManager(driver, database, login, password);

    // create an integer array where all entries but one is null

    SimplestObject[][] searchArray = new SimplestObject[3][3];

    searchArray[1][2] = new SimplestObject();

    searchArray[1][2].setFoo(2.0);

    // make sure this matches no results

    ComplexObject search = new ComplexObject();

    search.setObject(searchArray);

    List<ComplexObject> none = persist.getObjectsMatching(search);

    assertEquals(0, none.size());

    // change the search so that one object is returned

    searchArray[1][1] = new SimplestObject();

    searchArray[1][1].setFoo(2.0);

    searchArray[1][2].setFoo(3.0);

    List<ComplexObject> one = persist.getObjectsMatching(search);

    assertEquals(1, one.size());

    persist.close();

  }

  /**

   * Tries to save a variety of objects implementing java.util.Collection.

   *

   * @throws Exception

   */

  @Test

  public void testCollectionSave() throws Exception

  {

    ArrayList<Double> foo = new ArrayList<Double>();

    foo.add(6.9);

    foo.add(1.1);

    PersistenceManager persist = new PersistenceManager(driver, database, login, password);

    persist.saveObject(foo);

    List<Object> all = persist.getObjectsMatching(new Object());

    assertEquals(1, all.size());

    persist.close();

  }

  /**

   * Saves an instance of Collection and loads it, verifying that the contents

   * are still the same.

   */

  @Test

  public void testCollectionLoad() throws Exception

  {

    ArrayList<Double> foo = new ArrayList<Double>();

    foo.add(6.9);

    foo.add(1.1);

    PersistenceManager persist = new PersistenceManager(driver, database, login, password);

    persist.saveObject(foo);

    persist.close();

    persist = new PersistenceManager(driver, database, login, password);

    List<ArrayList<Object>> result = persist.getObjectsMatching(new ArrayList<Object>());

    assertEquals(1, result.size());

    ArrayList<?> first = result.get(0);

    assertEquals(2, first.size());

    assertEquals(6.9, first.get(0));

    assertEquals(1.1, first.get(1));

    List<Object> all = persist.getObjectsMatching(new Object());

    assertEquals(1, all.size());

    persist.close();

  }

  /**

   * Tries to save a variety of objects implementing java.util.Map.

   *

   * @throws Exception

   */

  @Test

  public void testMapSave() throws Exception

  {

    Map<String, Double> map = new HashMap<String, Double>();

    map.put("KEY", 3.0);

    map.put("ANOTHERKEY", 4.0);

    PersistenceManager persist = new PersistenceManager(driver, database, login, password);

    persist.saveObject(map);

    List<Object> all = persist.getObjectsMatching(new Object());

    assertEquals(1, all.size());

    persist.close();

  }

  /**

   * Saves an instance of Map and loads it, verifying that the contents are

   * still the same.

   */

  @Test

  public void testMapLoad() throws Exception

  {

    Map<String, Double> map = new HashMap<String, Double>();

    map.put("KEY", 3.0);

    map.put("ANOTHERKEY", 4.0);

    PersistenceManager persist = new PersistenceManager(driver, database, login, password);

    persist.saveObject(map);

    persist.close();

    persist = new PersistenceManager(driver, database, login, password);

    List<HashMap<Object, Object>> results = persist.getObjectsMatching(new HashMap<Object, Object>());

    assertEquals(1, results.size());

    HashMap<?, ?> first = results.get(0);

    assertEquals(2, first.size());

    assertEquals(3.0, first.get("KEY"));

    assertEquals(4.0, first.get("ANOTHERKEY"));

    List<Object> all = persist.getObjectsMatching(new Object());

    assertEquals(1, all.size());

    persist.close();

  }

  /**

   * Search in collections based on contents.

   *

   * @throws Exception

   */

  @SuppressWarnings("rawtypes")

  @Test

  public void testCollectionSearch() throws Exception

  {

    // store some ArrayLists in the database

    List<String> list = new ArrayList<String>();