/*
 * 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
<<<<<<< Updated upstream
 *
 *     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
=======
 * 
 *     https://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 
>>>>>>> Stashed changes
 * limitations under the License.
 */

package org.apache.jdo.tck.query;

import java.math.BigDecimal;
import java.math.BigInteger;
import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import javax.jdo.JDOException;
import javax.jdo.JDOFatalInternalException;
import javax.jdo.JDOQLTypedQuery;
import javax.jdo.JDOUserException;
import javax.jdo.PersistenceManager;
import javax.jdo.Query;
import javax.jdo.Transaction;
import org.apache.jdo.tck.AbstractReaderTest;
import org.apache.jdo.tck.pc.company.CompanyModelReader;
import org.apache.jdo.tck.pc.mylib.MylibReader;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.pc.mylib.PrimitiveTypes;
import org.apache.jdo.tck.util.ConversionHelper;
import org.apache.jdo.tck.util.EqualityHelper;

public abstract class QueryTest extends AbstractReaderTest {

  /** */
  public static final String SERIALZED_QUERY = "query.ser";

  /** */
  public static final String COMPANY_TESTDATA =
      "org/apache/jdo/tck/pc/company/companyForQueryTests.xml";

  /** */
  public static final String MYLIB_TESTDATA = "org/apache/jdo/tck/pc/mylib/mylibForQueryTests.xml";

  /** List of inserted instances (see methods insertPCPoints and getFromInserted). */
  protected final List<PCPoint> inserted = new ArrayList<>();

  /**
   * The company model reader is used to read company model instances from an XML file. Instances
   * refered by this reader are made persistent by {@link
   * QueryTest#loadAndPersistCompanyModel(PersistenceManager)}.
   */
  private CompanyModelReader companyModelReaderForPersistentInstances;

  /**
   * The company model reader is used to read company model instances from an XML file. Instances
   * refered by this reader remain transient.
   */
  private CompanyModelReader companyModelReaderForTransientInstances;

  /**
   * The mylib reader is used to read mylib instances from an XML file. Instances refered by this
   * reader are made persistent by {@link QueryTest#loadAndPersistMylib(PersistenceManager)}.
   */
  private MylibReader mylibReaderForPersistentInstances;

  /**
   * The mylib reader is used to read mylib instances from an XML file. Instances refered by this
   * reader are made persistent by
   */
  private MylibReader mylibReaderForTransientInstances;

  // Helper methods to create persistent PCPoint instances

  /**
   * @param pm the PersistenceManager
   */
  public void loadAndPersistPCPoints(PersistenceManager pm) {
    insertPCPoints(pm, 5);
  }

  /**
   * @param pm the PersistenceManager
   * @param numInsert number of instances to be inserted
   */
  protected void insertPCPoints(PersistenceManager pm, int numInsert) {
    Transaction tx = pm.currentTransaction();
    try {
      tx.begin();
      for (int i = 0; i < numInsert; i++) {
        PCPoint pc = new PCPoint(i, i);
        pm.makePersistent(pc);
        inserted.add(pc);
      }
      tx.commit();
      tx = null;
      if (debug) logger.debug("Total objects inserted : " + numInsert);
    } finally {
      if ((tx != null) && tx.isActive()) tx.rollback();
    }
  }

  /**
   * @param list list
   * @return list
   */
  public List<PCPoint> getFromInserted(List<PCPoint> list) {
    if (list == null) return null;

    List<PCPoint> result = new ArrayList<>();
    for (PCPoint pc : list) {
      for (PCPoint pci : inserted) {
        if (pc.getX() == pci.getX()) {
          result.add(pci);
          break;
        }
      }
    }
    return result;
  }

  // Company model and mylib helper methods

  /**
   * Returns the name of the company test data resource.
   *
   * @return name of the company test data resource.
   */
  protected String getCompanyTestDataResource() {
    return COMPANY_TESTDATA;
  }

  /**
   * Initializes and returns the company model reader for persistent instances.
   *
   * @return the company model reader for persistent instances.
   */
  private CompanyModelReader getCompanyModelReaderForPersistentInstances() {
    if (companyModelReaderForPersistentInstances == null) {
      companyModelReaderForPersistentInstances =
          new CompanyModelReader(getCompanyTestDataResource());
    }
    return companyModelReaderForPersistentInstances;
  }

  /**
   * Initializes and returns the company model reader for transient instances.
   *
   * @return the company model reader for transient instances.
   */
  private CompanyModelReader getCompanyModelReaderForTransientInstances() {
    if (companyModelReaderForTransientInstances == null) {
      companyModelReaderForTransientInstances =
          new CompanyModelReader(getCompanyTestDataResource());
    }
    return companyModelReaderForTransientInstances;
  }

  /**
   * Initializes and returns the mylib reader for persistent instances.
   *
   * @return the mylib reader for persistent instances.
   */
  private MylibReader getMylibReaderForPersistentInstances() {
    if (mylibReaderForPersistentInstances == null) {
      mylibReaderForPersistentInstances = new MylibReader(MYLIB_TESTDATA);
    }
    return mylibReaderForPersistentInstances;
  }

  /**
   * Initializes and returns the mylib reader for transient instances.
   *
   * @return the mylib reader for transient instances.
   */
  private MylibReader getMylibReaderForTransientInstances() {
    if (mylibReaderForTransientInstances == null) {
      mylibReaderForTransientInstances = new MylibReader(MYLIB_TESTDATA);
    }
    return mylibReaderForTransientInstances;
  }

  /**
   * Reads a graph of company model objects from the internal reader. This methods explictly calls
   * makePersistent for all named instances using the specified PersistenceManager. The method
   * returns the CompanyModelReader instance allowing to access a compay model instance by name.
   *
   * @param pm the PersistenceManager
   * @return the company model reader
   */
  public CompanyModelReader loadAndPersistCompanyModel(PersistenceManager pm) {
    makePersistentAll(pm, getRootList(getCompanyModelReaderForPersistentInstances()));
    return getCompanyModelReaderForPersistentInstances();
  }

  /**
   * Reads a graph of mylib objects from the internal reader. This methods explictly calls
   * makePersistent for all named instances using the specified PersistenceManager. The method
   * returns the CompanyModelReader instance allowing to access a compay model instance by name.
   *
   * @param pm the PersistenceManager
   * @return mylib reader
   */
  public MylibReader loadAndPersistMylib(PersistenceManager pm) {
    makePersistentAll(pm, getRootList(getMylibReaderForPersistentInstances()));
    return getMylibReaderForPersistentInstances();
  }

  /**
   * Persists the given pc instances.
   *
   * @param pm the PersistenceManager
   * @param pcInstances the pc instances to persist
   */
  private void makePersistentAll(PersistenceManager pm, List<?> pcInstances) {
    Transaction tx = pm.currentTransaction();
    tx.begin();
    try {
      pm.makePersistentAll(pcInstances);
      if (debug) logger.debug("inserted " + pcInstances);
      tx.commit();
    } finally {
      if (tx.isActive()) {
        tx.rollback();
      }
    }
  }

  /**
   * Returns a persistent company model instance for the given bean name.
   *
   * @param clazz class of the returned instance
   * @param beanName the bean name.
   * @return the persistent company model instance.
   */
  protected <T> T getPersistentCompanyModelInstance(Class<T> clazz, String beanName) {
    return beanName == null
        ? null
        : getBean(getCompanyModelReaderForPersistentInstances(), clazz, beanName);
  }

  /**
   * Returns a transient company model instance for the given bean name.
   *
   * @param clazz the class of teh returned instance
   * @param beanName the bean name.
   * @return the transient company model instance.
   */
  protected <T> T getTransientCompanyModelInstance(Class<T> clazz, String beanName) {
    return beanName == null
        ? null
        : getBean(getCompanyModelReaderForTransientInstances(), clazz, beanName);
  }

  /**
   * Returns a list of persistent company model instances for beans names in the given argument.
   *
   * @param elementType the element type of the returned list
   * @param beanNames the bean names of company model instances.
   * @return the list of persistent company model instances.
   */
  protected <T> List<T> getPersistentCompanyModelInstancesAsList(
      Class<T> elementType, String... beanNames) {
    List<T> result = new ArrayList<>(beanNames.length);
    for (String beanName : beanNames) {
      result.add(getPersistentCompanyModelInstance(elementType, beanName));
    }
    return result;
  }
  /**
   * Returns a list of transient company model instances for beans names in the given argument.
   *
   * @param elementType the element type of the returned list
   * @param beanNames the bean names of company model instances.
   * @return the list of transient company model instances.
   */
  protected <T> List<T> getTransientCompanyModelInstancesAsList(
      Class<T> elementType, String... beanNames) {
    List<T> result = new ArrayList<>(beanNames.length);
    for (String beanName : beanNames) {
      result.add(getTransientCompanyModelInstance(elementType, beanName));
    }
    return result;
  }

  /**
   * Returns a persistent mylib instance for the given bean name.
   *
   * @param beanName the bean name.
   * @return the persistent mylib instance.
   */
  protected Object getPersistentMylibInstance(String beanName) {
    return beanName == null ? null : getBean(getMylibReaderForPersistentInstances(), beanName);
  }

  /**
   * Returns a transient mylib instance for the given bean name.
   *
   * @param beanName the bean name.
   * @return the transient mylib instance.
   */
  protected Object getTransientMylibInstance(String beanName) {
    return beanName == null ? null : getBean(getMylibReaderForTransientInstances(), beanName);
  }

  /**
   * Returns an array of persistent mylib instances for beans names in the given argument.
   *
   * @param beanNames the bean names of mylib instances.
   * @return the array of persistent mylib instances.
   */
  protected Object[] getPersistentMylibInstances(String... beanNames) {
    Object[] result = new Object[beanNames.length];
    for (int i = 0; i < beanNames.length; i++) {
      result[i] = getPersistentMylibInstance(beanNames[i]);
    }
    return result;
  }

  /**
   * Returns an array of transient mylib instances for beans names in the given argument.
   *
   * @param beanNames the bean names of mylib instances.
   * @return the array of transient mylib instances.
   */
  protected Object[] getTransientMylibInstances(String... beanNames) {
    Object[] result = new Object[beanNames.length];
    for (int i = 0; i < beanNames.length; i++) {
      result[i] = getTransientMylibInstance(beanNames[i]);
    }
    return result;
  }

  /**
   * Returns a list of persistent mylib instances for beans names in the given argument.
   *
   * @param beanNames the bean names of mylib instances.
   * @return the list of persistent mylib instances.
   */
  protected List<Object> getPersistentMylibInstancesAsList(String... beanNames) {
    return Arrays.asList(getPersistentMylibInstances(beanNames));
  }

  /**
   * Returns a list of transient mylib instances for beans names in the given argument.
   *
   * @param beanNames the bean names of mylib instances.
   * @return the list of transient mylib instances.
   */
  protected List<Object> getTransientMylibInstancesAsList(String... beanNames) {
    return Arrays.asList(getTransientMylibInstances(beanNames));
  }

  // PrimitiveTypes helper methods (creation and query)

  /**
   * @param pm the PersistenceManager
   */
  public void loadAndPersistPrimitiveTypes(PersistenceManager pm) {
    insertPrimitiveTypes(pm);
  }

  /**
   * @param pm the PersistenceManager
   */
  protected void insertPrimitiveTypes(PersistenceManager pm) {
    boolean bFlag = false;
    String strValue = "";
    char charValue = '\u0000';
    int numInsert = 10;

    Transaction tx = pm.currentTransaction();
    try {
      tx.begin();
      for (int i = 1; i <= numInsert; i++) {
        if (i % 2 == 1) {
          bFlag = true;
          strValue = "Odd" + i;
          charValue = 'O';
        } else {
          bFlag = false;
          strValue = "Even" + i;
          charValue = 'E';
        }
        PrimitiveTypes primitiveObject =
            new PrimitiveTypes(
                i,
                bFlag,
                Boolean.valueOf(bFlag),
                (byte) i,
                Byte.valueOf((byte) i),
                (short) i,
                Short.valueOf((short) i),
                i,
                Integer.valueOf(i),
                i,
                Long.valueOf(i),
                i,
                Float.valueOf(i),
                i,
                Double.valueOf(i),
                charValue,
                Character.valueOf(charValue),
                Calendar.getInstance().getTime(),
                strValue,
                new BigDecimal(String.valueOf(i)),
                new BigInteger(String.valueOf(i)),
                Long.valueOf(i));
        pm.makePersistent(primitiveObject);
      }
      tx.commit();
      tx = null;
      if (debug) logger.debug("Total objects inserted : " + numInsert);
    } finally {
      if ((tx != null) && tx.isActive()) tx.rollback();
    }
  }

  /**
   * Creates and executes a PrimitiveTypes query with the specified filter. The method checks
   * whether the query returns the expected result.
   *
   * @param filter the filter
   * @param pm the PersistenceManager
   * @param expected expected
   * @param assertion assertion
   */
  protected void runSimplePrimitiveTypesQuery(
      String filter, PersistenceManager pm, Collection<PrimitiveTypes> expected, String assertion) {
    Query<PrimitiveTypes> q = pm.newQuery(PrimitiveTypes.class);
    q.setFilter(filter);
    List<PrimitiveTypes> results = q.executeList();
    if (debug) logger.debug("execute '" + filter + "' returns " + results.size() + " instance(s)");
    checkQueryResultWithoutOrder(assertion, filter, results, expected);
  }

  /**
   * Creates and executes a PrimitiveTypes query with the specified filter, parameter declarations
   * and parameter values. The method checks whether the query returns the expected result.
   *
   * @param filter the filter
   * @param paramDecl the parameter declaration
   * @param paramValue the parameter values
   * @param pm the PersistenceManager
   * @param expected expected
   * @param assertion assertion
   */
  protected void runParameterPrimitiveTypesQuery(
      String filter,
      String paramDecl,
      Object paramValue,
      PersistenceManager pm,
      Collection<PrimitiveTypes> expected,
      String assertion) {
    Query<PrimitiveTypes> q = pm.newQuery(PrimitiveTypes.class);
    q.setFilter(filter);
    q.declareParameters(paramDecl);
    q.setParameters(paramValue);
    List<PrimitiveTypes> results = q.executeList();
    if (debug)
      logger.debug(
          "execute '"
              + filter
              + "' with param '"
              + paramValue
              + "' returns "
              + results.size()
              + " instance(s)");
    checkQueryResultWithoutOrder(assertion, filter, results, expected);
  }

  // Helper methods to check query result

  /**
   * Verify that expected equals result, including the order of the elements. If not equal, fail the
   * test. If there is a filter != null, do not use this method. Use the method of the same name
   * that takes a String as the second argument.
   *
   * @param assertion assertion
   * @param result the result
   * @param expected the expected
   */
  protected void checkQueryResultWithOrder(String assertion, Object result, Object expected) {
    if (!equals(result, expected)) {
      queryFailed(assertion, "null", result, expected);
    }
  }

  /**
   * Verify that expected equals result, ignoring the order of the elements. If not equal, fail the
   * test. If there is a filter != null, do not use this method. Use the method of the same name
   * that takes a String as the second argument.
   *
   * @param assertion assertion
   * @param result the result
   * @param expected the expected
   */
  protected void checkQueryResultWithoutOrder(String assertion, Object result, Object expected) {
    // We need to explicitly check on collections passed as parameters
    // because equals(Object, Object) checks on lists and afterwards
    // on collections. This ensures, lists are compared without order
    // for queries without an ordering specification.
    if (result instanceof Collection && expected instanceof Collection) {
      if (!equalsCollection((Collection<?>) result, (Collection<?>) expected)) {
        queryFailed(assertion, "null", result, expected);
      }
    } else {
      if (!equals(result, expected)) {
        queryFailed(assertion, "null", result, expected);
      }
    }
  }

  private void queryFailed(String assertion, String query, Object result, Object expected) {
    String lf = System.getProperty("line.separator");
    result = ConversionHelper.convertObjectArrayElements(result);
    expected = ConversionHelper.convertObjectArrayElements(expected);
    fail(
        assertion,
        "Wrong query result: "
            + lf
            + "query: "
            + query
            + lf
            + "expected: "
            + expected.getClass().getName()
            + " of size "
            + size(expected)
            + lf
            + expected
            + lf
            + "got:      "
            + result.getClass().getName()
            + " of size "
            + size(result)
            + lf
            + result);
  }

  /**
   * @param assertion assertion
   * @param query the query
   * @param result the result
   * @param expected expected
   */
  protected void checkQueryResultWithOrder(
      String assertion, String query, Object result, Object expected) {
    if (!equals(result, expected)) {
      queryFailed(assertion, query, result, expected);
    }
  }

  /**
   * @param assertion assertion
   * @param query the query
   * @param result the result
   * @param expected expected
   */
  protected void checkQueryResultWithoutOrder(
      String assertion, String query, Object result, Object expected) {
    // We need to explicitly check on collections passed as parameters
    // because equals(Object, Object) checks on lists and afterwards
    // on collections. This ensures, lists are compared without order
    // for queries without an ordering specification.
    if (result instanceof Collection && expected instanceof Collection) {
      if (!equalsCollection((Collection<?>) result, (Collection<?>) expected)) {
        queryFailed(assertion, query, result, expected);
      }
    } else {
      if (!equals(result, expected)) {
        queryFailed(assertion, query, result, expected);
      }
    }
  }

  /**
   * Returns <code>true</code> if <code>o1</code> and <code>o2</code> equal. This method is capable
   * to compare object arrays, collections of object arrays, maps of object arrays. This method
   * implements a narrowing in case of floating point values. In case of big decimals it calls
   * {@link BigDecimal#compareTo(java.math.BigDecimal)}. It allows <code>o1</code> and/or <code>o2
   * </code> to be <code>null</code>.
   *
   * @param o1 the first object
   * @param o2 the second object
   * @return <code>true</code> if <code>o1</code> and <code>o2</code> equal.
   */
  protected boolean equals(Object o1, Object o2) {
    boolean result;
    if (o1 == o2) {
      result = true;
    } else if ((o1 instanceof Object[]) && (o2 instanceof Object[])) {
      result = equalsObjectArray((Object[]) o1, (Object[]) o2);
    } else if ((o1 instanceof List) && (o2 instanceof List)) {
      result = equalsList((List<?>) o1, (List<?>) o2);
    } else if ((o1 instanceof Collection) && (o2 instanceof Collection)) {
      result = equalsCollection((Collection<?>) o1, (Collection<?>) o2);
    } else if ((o1 instanceof Map) && (o2 instanceof Map)) {
      result = equalsMap((Map<?, ?>) o1, (Map<?, ?>) o2);
    } else if ((o1 instanceof Float) && (o2 instanceof Float)) {
      result = closeEnough(((Float) o1).floatValue(), ((Float) o2).floatValue());
    } else if ((o1 instanceof Double) && (o2 instanceof Double)) {
      result = closeEnough(((Double) o1).floatValue(), ((Double) o2).floatValue());
    } else if ((o1 instanceof BigDecimal) && (o2 instanceof BigDecimal)) {
      result = ((BigDecimal) o1).compareTo((BigDecimal) o2) == 0;
    } else if (o1 != null) {
      result = o1.equals(o2);
    } else {
      // Due to the first if and due to the last if, we have:
      // o1 == null && o2 != null
      result = false;
    }
    return result;
  }

  /**
   * Returns <code>true</code> if <code>o1</code> and <code>o2</code> equal. This method iterates
   * over both object arrays and calls {@link QueryTest#equals(Object, Object)} passing
   * corresponding instances. {@link QueryTest#equals(Object, Object)} is called rather than {@link
   * Object#equals(java.lang.Object)} because object arrays having equal elements cannot be compared
   * calling {@link Object#equals(java.lang.Object)}. This method does not allow <code>o1</code> and
   * <code>o2</code> to be <code>null</code> both.
   *
   * @param o1 the first object array
   * @param o2 the second object array
   * @return <code>true</code> if <code>o1</code> and <code>o2</code> equal.
   */
  protected boolean equalsObjectArray(Object[] o1, Object[] o2) {
    boolean result = true;
    if (o1 != o2) {
      if (o1.length != o2.length) {
        result = false;
      } else {
        for (int i = 0; i < o1.length; i++) {
          if (!equals(o1[i], o2[i])) {
            result = false;
            break;
          }
        }
      }
    }
    return result;
  }

  /**
   * Returns <code>true</code> if <code>o1</code> and <code>o2</code> equal. This method iterates
   * both lists and calls {@link QueryTest#equals(Object, Object)} on corresponding elements. {@link
   * QueryTest#equals(Object, Object)} is called rather than {@link Object#equals(java.lang.Object)}
   * because object arrays having equal elements cannot be compared calling {@link
   * Object#equals(java.lang.Object)}. This method does not allow <code>o1</code> and <code>o2
   * </code> to be <code>null</code> both.
   *
   * @param o1 the first list
   * @param o2 the second list
   * @return <code>true</code> if <code>o1</code> and <code>o2</code> equal.
   */
  protected <S, T> boolean equalsList(List<S> o1, List<T> o2) {
    boolean result = true;
    if (o1 != o2) {
      if (o1.size() != o2.size()) {
        result = false;
      } else {
        Iterator<S> i = o1.iterator();
        Iterator<T> ii = o2.iterator();
        while (i.hasNext()) {
          Object firstObject = i.next();
          Object secondObject = ii.next();
          if (!equals(firstObject, secondObject)) {
            result = false;
            break;
          }
        }
      }
    }
    return result;
  }

  /**
   * Returns <code>true</code> if <code>o1</code> and <code>o2</code> equal. This method iterates
   * over the first collection and checks if each instance is contained in the second collection by
   * calling remove(Collection, Object). This guarantees that the cardinality of each instance in
   * the first collection matches the cardinality of each instance in the second collection. This
   * method does not allow <code>o1</code> and <code>o2</code> to be <code>null</code> both.
   *
   * @param o1 the first collection
   * @param o2 the second collection
   * @return <code>true</code> if <code>o1</code> and <code>o2</code> equal.
   */
  protected <S, T> boolean equalsCollection(Collection<S> o1, Collection<T> o2) {
    // make a copy of o2 so we can destroy it
    Collection<T> o2copy = new ArrayList<>();
    for (T t : o2) {
      o2copy.add(t);
    }
    boolean result = true;
    if (o1 != o2) {
      if (o1.size() != o2.size()) {
        result = false;
      } else {
        for (S oo1 : o1) {
          if (!remove(o2copy, oo1)) {
            result = false;
            break;
          }
        }
      }
    }
    return result;
  }

  /**
   * Returns <code>true</code> if <code>o1</code> and <code>o2</code> equal. This method checks if
   * the key sets and the value sets of both maps equal calling equalsCollection(Collection,
   * Collection). This method does not allow <code>o1</code> and <code>o2</code> to be <code>null
   * </code> both.
   *
   * @param o1 the first map
   * @param o2 the second map
   * @return <code>true</code> if <code>o1</code> and <code>o2</code> equal.
   */
  protected <K1, V1, K2, V2> boolean equalsMap(Map<K1, V1> o1, Map<K2, V2> o2) {
    boolean result = true;
    if (o1 != o2) {
      if (o1.size() != o2.size()) {
        result = false;
      } else {
        for (Map.Entry<K1, V1> entry : o1.entrySet()) {
          K1 key = entry.getKey();
          V1 value = entry.getValue();
          V2 value2 = o2.get(key);
          if (!equals(value, value2)) {
            result = false;
            break;
          }
        }
      }
    }
    return result;
  }

  /**
   * Returns <code>true</code> if <code>o</code> is contained in the given collection. This method
   * iterates the given collection and calls {@link QueryTest#equals(Object, Object)} for each
   * instance. {@link QueryTest#equals(Object, Object)} is called rather than {@link
   * Object#equals(java.lang.Object)} because object arrays having equal elements cannot be compared
   * calling {@link Object#equals(java.lang.Object)}.
   *
   * @param col the collection
   * @param o the object
   * @return <code>true</code> if <code>o</code> is contained in the given collection.
   */
  private boolean contains(Collection<Object> col, Object o) {
    for (Object value : col) {
      if (equals(o, value)) {
        return true;
      }
    }
    return false;
  }

  /**
   * Returns <code>true</code> if <code>o</code> is contained in the given collection and was
   * removed. This method iterates the given collection and calls {@link QueryTest#equals(Object,
   * Object)} for each instance. {@link QueryTest#equals(Object, Object)} is called rather than
   * {@link Object#equals(java.lang.Object)} because object arrays having equal elements cannot be
   * compared calling {@link Object#equals(java.lang.Object)}.
   *
   * @param col the collection
   * @param o the object
   * @return <code>true</code> if <code>o</code> is contained in the given collection and was
   *     removed.
   */
  private <T> boolean remove(Collection<T> col, Object o) {
    for (Iterator<T> i = col.iterator(); i.hasNext(); ) {
      if (equals(o, i.next())) {
        i.remove();
        return true;
      }
    }
    return false;
  }

  /**
   * Returns <code>true</code> if the specified float values are close enough to be considered to be
   * equal for a deep equals comparison. Floating point values are not exact, so comparing them
   * using <code>==</code> might not return useful results. This method checks that both double
   * values are within some percent of each other.
   *
   * @param d1 one double to be tested for close enough
   * @param d2 the other double to be tested for close enough
   * @return <code>true</code> if the specified values are close enough.
   */
  public boolean closeEnough(double d1, double d2) {
    if (d1 == d2) return true;

    double diff = Math.abs(d1 - d2);
    return diff < Math.abs((d1 + d2) * EqualityHelper.DOUBLE_EPSILON);
  }

  /**
   * Returns <code>true</code> if the specified float values are close enough to be considered to be
   * equal for a deep equals comparison. Floating point values are not exact, so comparing them
   * using <code>==</code> might not return useful results. This method checks that both float
   * values are within some percent of each other.
   *
   * @param f1 one float to be tested for close enough
   * @param f2 the other float to be tested for close enough
   * @return <code>true</code> if the specified values are close enough.
   */
  public boolean closeEnough(float f1, float f2) {
    if (f1 == f2) return true;

    float diff = Math.abs(f1 - f2);
    return diff < Math.abs((f1 + f2) * EqualityHelper.FLOAT_EPSILON);
  }

  /**
   * Returns the size of the object. If it is a multivalued object (Collection, Map, or array)
   * return the number of elements. If not, return 1.
   *
   * @param o the object
   * @return size
   */
  protected int size(Object o) {
    if (o instanceof Collection) {
      return ((Collection<?>) o).size();
    }
    if (o instanceof Object[]) {
      return ((Object[]) o).length;
    }
    if (o instanceof Map) {
      return ((Map<?, ?>) o).size();
    }
    return 1;
  }

  // Debugging helper methods

  /**
   * @param results the results
   * @param expected expected values
   */
  protected void printOutput(Object results, Collection<?> expected) {
    if (!debug) return;

    Iterator<?> iter = null;
    PCPoint pcp = null;
    if (results == null) {
      logger.debug("Query returns null");
      return;
    }
    if (!(results instanceof Collection)) {
      logger.debug(
          "Query result is not a collection: "
              + (results == null ? "null" : results.getClass().getName()));
    }
    logger.debug("Retrived Objects are:");
    iter = ((Collection<?>) results).iterator();
    while (iter.hasNext()) {
      pcp = (PCPoint) iter.next();
      logger.debug("X = " + pcp.getX() + "\tY = " + pcp.getY());
    }

    logger.debug("Expected Objects are:");
    iter = expected.iterator();
    while (iter.hasNext()) {
      pcp = (PCPoint) iter.next();
      logger.debug("X = " + pcp.getX() + "\tY = " + pcp.getY());
    }
  }

  // compile query methods

  /**
   * Compiles the given query element holder instance as a JDO API query. Argument <code>positive
   * </code> determines if the compilation is supposed to succeed or to fail. If <code>true</code>
   * and the compilation fails, then the test case fails prompting argument <code>assertion</code>.
   * If <code>false</code> and the compilation succeeds, then the test case fails prompting argument
   * <code>assertion</code>. Otherwise the test case succeeds.
   *
   * @param assertion the assertion to prompt if the test case fails.
   * @param queryElementHolder the query to execute.
   * @param positive determines if the compilation is supposed to succeed or to fail.
   */
  protected void compileAPIQuery(
      String assertion, QueryElementHolder<?> queryElementHolder, boolean positive) {
    if (logger.isDebugEnabled()) {
      logger.debug("Compiling API query: " + queryElementHolder);
    }
    compile(assertion, queryElementHolder, false, queryElementHolder.toString(), positive);
  }

  /**
   * Compiles the given query element holder instance as a JDO single string query. Argument <code>
   * positive</code> determines if the compilation is supposed to succeed or to fail. If <code>true
   * </code> and the compilation fails, then the test case fails prompting argument <code>assertion
   * </code>. If <code>false</code> and the compilation succeeds, then the test case fails prompting
   * argument <code>assertion</code>. Otherwise the test case succeeds.
   *
   * @param assertion the assertion to prompt if the test case fails.
   * @param queryElementHolder the query to execute.
   * @param positive determines if the compilation is supposed to succeed or to fail.
   */
  protected void compileSingleStringQuery(
      String assertion, QueryElementHolder<?> queryElementHolder, boolean positive) {
    if (logger.isDebugEnabled())
      logger.debug("Compiling single string query: " + queryElementHolder);
    compile(assertion, queryElementHolder, true, queryElementHolder.toString(), positive);
  }

  /**
   * Compiles the given single string query. Argument <code>positive</code> determines if the
   * compilation is supposed to succeed or to fail. If <code>true</code> and the compilation fails,
   * then the test case fails prompting argument <code>assertion</code>. If <code>false</code> and
   * the compilation succeeds, then the test case fails prompting argument <code>assertion</code>.
   * Otherwise the test case succeeds.
   *
   * @param assertion the assertion to prompt if the test case fails.
   * @param singleStringQuery the single string query
   * @param positive determines if the compilation is supposed to succeed or to fail.
   */
  protected void compileSingleStringQuery(
      String assertion, String singleStringQuery, boolean positive) {
    if (logger.isDebugEnabled())
      logger.debug("Compiling single string query: " + singleStringQuery);
    compile(assertion, null, true, singleStringQuery, positive);
  }

  /**
   * Compiles the given query element holder instance as a JDO API query or single string query,
   * depending on argument <code>asSingleString</code>. Argument <code>singleStringQuery</code> is
   * used to support queries which cannot be expressed as query element holder instances. That
   * argument is ignored if argument <code>queryElementHolder</code> is set. Argument <code>positive
   * </code> determines if the compilation is supposed to succeed or to fail. If <code>true</code>
   * and the compilation fails, then the test case fails prompting argument <code>assertion</code>.
   * If <code>false</code> and the compilation succeeds, then the test case fails prompting argument
   * <code>assertion</code>. Otherwise the test case succeeds.
   *
   * @param assertion the assertion to prompt if the test case fails.
   * @param queryElementHolder the query to compile.
   * @param asSingleString determines if the query specified by <code>queryElementHolder</code> is
   *     compiled as single string query or as API query.
   * @param singleStringQuery the query to compile as a JDO single string query if there is no query
   *     element holder.
   * @param positive determines if the compilation is supposed to succeed or to fail.
   */
  private void compile(
      String assertion,
      QueryElementHolder<?> queryElementHolder,
      boolean asSingleString,
      String singleStringQuery,
      boolean positive) {
    getPM();
    try {
      Query<?> query;
      if (queryElementHolder != null) {
        if (asSingleString) {
          query = queryElementHolder.getSingleStringQuery(pm);
        } else {
          query = queryElementHolder.getAPIQuery(pm);
        }
      } else {
        query = getPM().newQuery(singleStringQuery);
      }
      compile(assertion, query, singleStringQuery, positive);
    } catch (JDOUserException e) {
      // This exception handler considers a JDOUserException
      // to be thrown in newQuery methods.
      // A JDOUserException may be expected in case of negative tests.
      if (positive) {
        fail(
            assertion
                + "Query '"
                + queryElementHolder
                + "' must be compilable. The exception message is: "
                + e.getMessage());
      }
    }
  }

  /**
   * Compiles the given query instance. Argument <code>positive</code> determines if the compilation
   * is supposed to succeed or to fail. If <code>true</code> and the compilation fails, then the
   * test case fails prompting arguments <code>assertion</code> and <code>queryText</code>. If
   * <code>false</code> and the compilation succeeds, then the test case fails prompting argument
   * <code>assertion</code> and <code>queryText</code>. Otherwise the test case succeeds.
   *
   * @param assertion asserting text
   * @param query the query instance
   * @param queryText the text representation of the query
   * @param positive positive test
   */
  protected void compile(String assertion, Query<?> query, String queryText, boolean positive) {
    getPM();
    Transaction tx = pm.currentTransaction();
    tx.begin();
    try {
      query.compile();
      if (!positive) {
        fail(assertion, "Query compilation must throw JDOUserException: " + queryText);
      }
    } catch (JDOUserException e) {
      if (positive) {
        fail(
            assertion,
            "Query '"
                + queryText
                + "' must be compilable. The exception message is: "
                + e.getMessage());
      }
    } finally {
      if (tx.isActive()) {
        tx.rollback();
      }
    }
  }

  // execute query methods

  /**
   * Executes the given query element holder instance as a JDO API query. The result of that query
   * is compared against the given argument <code>expectedResult</code>. If the expected result does
   * not match the returned query result, then the test case fails prompting argument <code>
   * assertion</code>.
   *
   * @param assertion the assertion to prompt if the test case fails.
   * @param queryElementHolder the query to execute.
   * @param expectedResult the expected query result.
   */
  protected void executeAPIQuery(
      String assertion, QueryElementHolder<?> queryElementHolder, Object expectedResult) {
    if (logger.isDebugEnabled()) {
      logger.debug("Executing API query: " + queryElementHolder);
    }
    execute(assertion, queryElementHolder, false, expectedResult);
  }

  /**
   * Executes the given query element holder instance as a JDO single string query. The result of
   * that query is compared against the given argument <code>expectedResult</code>. If the expected
   * result does not match the returned query result, then the test case fails prompting argument
   * <code>assertion</code>.
   *
   * @param assertion the assertion to prompt if the test case fails.
   * @param queryElementHolder the query to execute.
   * @param expectedResult the expected query result.
   */
  protected void executeSingleStringQuery(
      String assertion, QueryElementHolder<?> queryElementHolder, Object expectedResult) {
    if (logger.isDebugEnabled())
      logger.debug("Executing single string query: " + queryElementHolder);
    execute(assertion, queryElementHolder, true, expectedResult);
  }

  /**
   * @param assertion assertion text
   * @param queryElementHolder query elements
   * @param expectedResult expected query result
   */
  protected void executeJDOQLTypedQuery(
      String assertion, QueryElementHolder<?> queryElementHolder, Object expectedResult) {
    executeJDOQLTypedQuery(assertion, queryElementHolder, null, false, expectedResult);
  }

  /**
   * @param assertion assertion text
   * @param queryElementHolder query elements
   * @param resultClass result class object
   * @param resultClauseSpecified flag whether result clause is specified
   * @param expectedResult the expected query result
   */
  protected void executeJDOQLTypedQuery(
      String assertion,
      QueryElementHolder<?> queryElementHolder,
      Class<?> resultClass,
      boolean resultClauseSpecified,
      Object expectedResult) {
    String singleStringQuery = queryElementHolder.toString();
    getPM();
    Transaction tx = pm.currentTransaction();
    tx.begin();
    try {
      JDOQLTypedQuery<?> query = queryElementHolder.getJDOQLTypedQuery();
      if (query == null) {
        throw new JDOFatalInternalException("Missing JDOQLTyped instance");
      }
      Object result = null;
      try {
        Map<String, ?> paramValues = queryElementHolder.getParamValues();
        if (paramValues != null) {
          query.setParameters(paramValues);
        }

        if (resultClass != null) {
          if (queryElementHolder.isUnique()) {
            // result class specified and unique result
            result = query.executeResultUnique(resultClass);
          } else {
            // result class specified and list result
            result = query.executeResultList(resultClass);
          }
        } else if (resultClauseSpecified) {
          if (queryElementHolder.isUnique()) {
            // result class specified and unique result
            result = query.executeResultUnique();
          } else {
            // result class specified and list result
            result = query.executeResultList();
          }
        } else {
          if (queryElementHolder.isUnique()) {
            // no result class and unique result
            result = query.executeUnique();
          } else {
            // no result class and list result
            result = query.executeList();
          }
        }

        if (logger.isDebugEnabled()) {
          logger.debug("Query result: " + ConversionHelper.convertObjectArrayElements(result));
        }

        checkResult(
            assertion,
            singleStringQuery,
            queryElementHolder.hasOrdering(),
            result,
            expectedResult,
            true);
      } finally {
        query.close(result);
      }
    } catch (JDOUserException e) {
      String msg = "JDOUserException thrown while executing query:\n" + singleStringQuery;
      throw new JDOException(msg, e);
    } catch (JDOException e) {
      String msg = "JDOException thrown while executing query:\n" + singleStringQuery;
      throw new JDOException(msg, e);
    } finally {
      if (tx.isActive()) {
        tx.rollback();
      }
    }
  }

  /**
   * Converts the given query element holder instance to a JDO query instance, based on argument
   * <code>asSingleString</code>. Afterwards, delegates to method {@link QueryTest#execute(String,
   * Query, String, boolean, Object, Object, boolean)}.
   *
   * @param assertion the assertion to prompt if the test case fails.
   * @param queryElementHolder the query to execute.
   * @param asSingleString determines if the query is executed as single string query or as API
   *     query.
   * @param expectedResult the expected query result.
   * @return the query result
   */
  private Object execute(
      String assertion,
      QueryElementHolder<?> queryElementHolder,
      boolean asSingleString,
      Object expectedResult) {
    getPM();
    Query<?> query =
        asSingleString
            ? queryElementHolder.getSingleStringQuery(pm)
            : queryElementHolder.getAPIQuery(pm);
    Object result =
        execute(
            assertion,
            query,
            queryElementHolder.toString(),
            queryElementHolder.hasOrdering(),
            queryElementHolder.getParamValues(),
            expectedResult,
            true);
    return result;
  }

  /**
   * Executes the given query instance delegating to execute(String, Query, String, boolean, Object,
   * Object, boolean). Logs argument <code>singleStringQuery</code> if debug logging is enabled.
   *
   * @param assertion the assertion to prompt if the test case fails.
   * @param query the query to execute.
   * @param singleStringQuery the single string representation of the query. This parameter is only
   *     used as part of the falure message.
   * @param hasOrdering indicates if the query has an ordering clause.
   * @param parameters the parmaters of the query.
   * @param expectedResult the expected query result.
   * @param positive indicates if query execution is supposed to fail
   * @return the query result
   */
  protected Object executeJDOQuery(
      String assertion,
      Query<?> query,
      String singleStringQuery,
      boolean hasOrdering,
      Object[] parameters,
      Object expectedResult,
      boolean positive) {
    if (logger.isDebugEnabled()) {
      logger.debug("Executing JDO query: " + singleStringQuery);
    }
    return execute(
        assertion, query, singleStringQuery, hasOrdering, parameters, expectedResult, positive);
  }

  /**
   * Executes the given SQL string as a JDO SQL query. The result of that query is compared against
   * the given argument <code>expectedResult</code>. If the expected result does not match the
   * returned query result, then the test case fails prompting argument <code>assertion</code>.
   * Argument <code>unique</code> indicates, if the query is supposed to return a single result.
   * Argument <code>sql</code> may contain the substring <code>"{0}"</code>. All occurences of this
   * substring are replaced by the value of PMF property <code>"javax.jdo.mapping.Schema"</code>.
   *
   * @param assertion the assertion to prompt if the test case fails.
   * @param sql the SQL string.
   * @param candidateClass the candidate class.
   * @param resultClass the result class.
   * @param positive positive option
   * @param parameters the parameters of the query.
   * @param expectedResult the expected query result.
   * @param unique indicates, if the query is supposed to return a single result.
   */
  @SuppressWarnings("unchecked")
  protected <T> void executeSQLQuery(
      String assertion,
      String sql,
      Class<T> candidateClass,
      Class<?> resultClass,
      boolean positive,
      Object parameters,
      Object expectedResult,
      boolean unique) {
    String schema = getPMFProperty("javax.jdo.mapping.Schema");
    sql = MessageFormat.format(sql, new Object[] {schema});
    if (logger.isDebugEnabled()) logger.debug("Executing SQL query: " + sql);
    Query<T> query = getPM().newQuery("javax.jdo.query.SQL", sql);
    if (unique) {
      query.setUnique(unique);
    }
    if (candidateClass != null) {
      query.setClass(candidateClass);
    }
    if (resultClass != null) {
      query.setResultClass(resultClass);
    }
    execute(assertion, query, sql, false, parameters, expectedResult, positive);
  }

  /**
   * Executes the given query instance. If argument <code>parameters</code> is an object array, then
   * it is passed as an argument to the method {@link Query#executeWithArray(java.lang.Object[])}.
   * If argument <code>parameters</code> is a map, then it is passed as an argument to the method
   * {@link Query#executeWithMap(java.util.Map)}. If argument <code>parameters</code> is a list,
   * then the list elements are passed as arguments to the execute methods taking actual parameter
   * values. If argument <code>parameters</code> is <code>null</code>, then method {@link
   * Query#execute()} is called on the given query instance instead.
   *
   * <p>The result of query execution is compared against the argument <code>expectedResult</code>.
   * If the two values differ, then this method throws an {@link
   * junit.framework.AssertionFailedError} and the calling test case fails prompting argument <code>
   * assertion</code>.
   *
   * <p>If argument <code>positive</code> is <code>false</code>, then the test case invoking this
   * method is considered to be a negative test case. Then, query execution is expected to throw a
   * {@link JDOUserException}. If query execution succeeds in this case, then this method throws an
   * {@link junit.framework.AssertionFailedError} and the calling test case fails prompting argument
   * <code>assertion</code>.
   *
   * <p>
   *
   * @param assertion the assertion to prompt if the test case fails.
   * @param query the query to execute.
   * @param singleStringQuery the single string representation of the query. This parameter is only
   *     used as part of the falure message.
   * @param hasOrdering indicates if the query has an ordering clause.
   * @param parameters the parmaters of the query.
   * @param expectedResult the expected query result.
   * @param positive indicates if query execution is supposed to fail
   * @return the query result
   */
  @SuppressWarnings("unchecked")
  private Object execute(
      String assertion,
      Query<?> query,
      String singleStringQuery,
      boolean hasOrdering,
      Object parameters,
      Object expectedResult,
      boolean positive) {
    Object result = null;
    getPM();
    Transaction tx = pm.currentTransaction();
    tx.begin();
    try {
      try {
        if (parameters == null) {
          result = query.execute();
        } else if (parameters instanceof Object[]) {
          result = query.executeWithArray((Object[]) parameters);
        } else if (parameters instanceof Map) {
          result = query.executeWithMap((Map<String, Object>) parameters);
        } else if (parameters instanceof List) {
          List<?> list = (List<?>) parameters;
          switch (list.size()) {
            case 1:
              result = query.execute(list.get(0));
              break;
            case 2:
              result = query.execute(list.get(0), list.get(1));
              break;
            case 3:
              result = query.execute(list.get(0), list.get(1), list.get(2));
              break;
            default:
              throw new IllegalArgumentException(
                  "Argument parameters is a list " + "and must have 1, 2, or 3 elements.");
          }
        } else {
          throw new IllegalArgumentException(
              "Argument parameters " + "must be instance of List, Map, Object[], or null.");
        }

        if (logger.isDebugEnabled()) {
          logger.debug("Query result: " + ConversionHelper.convertObjectArrayElements(result));
        }

        checkResult(assertion, singleStringQuery, hasOrdering, result, expectedResult, positive);

      } finally {
        query.close(result);
      }
    } catch (JDOUserException e) {
      if (positive) {
        String msg = "JDOUserException thrown while executing query:\n" + singleStringQuery;
        throw new JDOException(msg, e);
      }
    } catch (JDOException e) {
      String msg = "JDOException thrown while executing query:\n" + singleStringQuery;
      throw new JDOException(msg, e);
    } finally {
      if (tx.isActive()) {
        tx.rollback();
      }
    }
    return result;
  }

  /**
   * @param assertion the assertion to prompt if the test case fails.
   * @param singleStringQuery the single string representation of the query. This parameter is only
   *     used as part of the falure message.
   * @param hasOrdering indicates if the query has an ordering clause.
   * @param positive indicates if query execution is supposed to fail
   * @param result the query result.
   * @param expectedResult the expected query result.
   */
  private void checkResult(
      String assertion,
      String singleStringQuery,
      boolean hasOrdering,
      Object result,
      Object expectedResult,
      boolean positive) {
    if (positive) {
      if (hasOrdering) {
        checkQueryResultWithOrder(assertion, singleStringQuery, result, expectedResult);
      } else {
        checkQueryResultWithoutOrder(assertion, singleStringQuery, result, expectedResult);
      }
    } else {
      fail(assertion, "Query must throw JDOUserException: " + singleStringQuery);
    }
  }

  /**
   * Converts the given query element holder instance to a JDO query instance. Calls {@link
   * Query#deletePersistentAll()}, or {@link Query#deletePersistentAll(java.util.Map)}, or {@link
   * Query#deletePersistentAll(java.lang.Object[])} depending on the type of argument <code>
   * parameters</code>. If the number of deleted objects does not match <code>
   * expectedNrOfDeletedObjects</code>, then the test case fails prompting argument <code>assertion
   * </code>.
   *
   * @param assertion the assertion to prompt if the test case fails.
   * @param queryElementHolder the query to execute.
   * @param expectedNrOfDeletedObjects the expected number of deleted objects.
   */
  protected void deletePersistentAllByAPIQuery(
      String assertion, QueryElementHolder<?> queryElementHolder, long expectedNrOfDeletedObjects) {
    if (logger.isDebugEnabled()) {
      logger.debug("Deleting persistent by API query: " + queryElementHolder);
    }
    delete(assertion, queryElementHolder, false, expectedNrOfDeletedObjects);
  }

  /**
   * Converts the given query element holder instance to a JDO query instance. Calls {@link
   * Query#deletePersistentAll()}, or {@link Query#deletePersistentAll(java.util.Map)}, or {@link
   * Query#deletePersistentAll(java.lang.Object[])} depending on the type of argument <code>
   * parameters</code>. If the number of deleted objects does not match <code>
   * expectedNrOfDeletedObjects</code>, then the test case fails prompting argument <code>assertion
   * </code>.
   *
   * @param assertion the assertion to prompt if the test case fails.
   * @param queryElementHolder the query to execute.
   * @param expectedNrOfDeletedObjects the expected number of deleted objects.
   */
  protected void deletePersistentAllBySingleStringQuery(
      String assertion, QueryElementHolder<?> queryElementHolder, long expectedNrOfDeletedObjects) {
    if (logger.isDebugEnabled()) {
      logger.debug("Deleting persistent by single string query: " + queryElementHolder);
    }
    delete(assertion, queryElementHolder, true, expectedNrOfDeletedObjects);
  }

  /**
   * Converts the given query element holder instance to a
   * JDO query based on argument <code>asSingleString</code>.
   * Calls {@link Query#deletePersistentAll()}, or
   * {@link Query#deletePersistentAll(java.util.Map), or
   * {@link Query#deletePersistentAll(java.lang.Object[])
   * depending on the type of argument <code>parameters</code>.
   * If the number of deleted objects does not
   * match <code>expectedNrOfDeletedObjects</code>,
   * then the test case fails prompting argument <code>assertion</code>.
   * @param assertion the assertion to prompt if the test case fails.
   * @param queryElementHolder the query to execute.
   * @param asSingleString determines if the query is executed as
   * single string query or as API query.
   * @param parameters the parmaters of the query.
   * @param expectedNrOfDeletedObjects the expected number of deleted objects.
   */
  private void delete(
      String assertion,
      QueryElementHolder<?> queryElementHolder,
      boolean asSingleString,
      long expectedNrOfDeletedObjects) {
    getPM();
    Query<?> query =
        asSingleString
            ? queryElementHolder.getSingleStringQuery(pm)
            : queryElementHolder.getAPIQuery(pm);
    delete(
        assertion,
        query,
        queryElementHolder.toString(),
        queryElementHolder.getParamValues(),
        expectedNrOfDeletedObjects);
    boolean positive = expectedNrOfDeletedObjects >= 0;
    if (positive) {
      execute(
          assertion,
          queryElementHolder,
          asSingleString,
          queryElementHolder.isUnique() ? null : Collections.emptyList());
    }
  }

  /**
   * Calls {@link Query#deletePersistentAll()}, or
   * {@link Query#deletePersistentAll(java.util.Map), or
   * {@link Query#deletePersistentAll(java.lang.Object[])
   * depending on the type of argument <code>parameters</code>.
   * If the number of deleted objects does not
   * match <code>expectedNrOfDeletedObjects</code>,
   * then the test case fails prompting argument <code>assertion</code>.
   * Argument <code>singleStringQuery</code> is only used as part
   * of the failure message.
   * @param assertion the assertion to prompt if the test case fails.
   * @param query the query to execute.
   * @param singleStringQuery the single string representation of the query.
   * @param parameters the parmaters of the query.
   * @param expectedNrOfDeletedObjects the expected number of deleted objects.
   */
  @SuppressWarnings("unchecked")
  private void delete(
      String assertion,
      Query<?> query,
      String singleStringQuery,
      Object parameters,
      long expectedNrOfDeletedObjects) {
    boolean positive = expectedNrOfDeletedObjects >= 0;
    getPM();
    Transaction tx = pm.currentTransaction();
    tx.begin();
    try {
      try {
        long nr;
        if (parameters == null) {
          nr = query.deletePersistentAll();
        } else if (parameters instanceof Object[]) {
          nr = query.deletePersistentAll((Object[]) parameters);
        } else if (parameters instanceof Map) {
          nr = query.deletePersistentAll((Map<String, Object>) parameters);
        } else {
          throw new IllegalArgumentException(
              "Argument parameters " + "must be instance of Object[], Map, or null.");
        }
        if (logger.isDebugEnabled()) {
          logger.debug(nr + " objects deleted.");
        }

        if (positive) {
          if (nr != expectedNrOfDeletedObjects) {
            fail(
                assertion,
                "deletePersistentAll returned "
                    + nr
                    + ", expected is "
                    + expectedNrOfDeletedObjects
                    + ". Query: "
                    + singleStringQuery);
          }
        } else {
          fail(assertion, "deletePersistentAll must throw JDOUserException: " + singleStringQuery);
        }
      } finally {
        query.closeAll();
      }
      tx.commit();
    } catch (JDOUserException e) {
      if (positive) {
        String msg = "JDOUserException thrown while executing query:\n" + singleStringQuery;
        throw new JDOException(msg, e);
      }
    } catch (JDOException e) {
      String msg = "JDOException thrown while executing query:\n" + singleStringQuery;
      throw new JDOException(msg, e);
    } finally {
      if (tx.isActive()) {
        tx.rollback();
      }
    }
  }
}