tck/src/main/java/org/apache/jdo/tck/query/delete/DeleteCallback.java - db-jdo - Git at Google

 /*
  * 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.delete;

 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.HashSet;
 import java.util.List;
 import javax.jdo.JDOHelper;
 import javax.jdo.PersistenceManager;
 import javax.jdo.Query;
 import javax.jdo.Transaction;
 import javax.jdo.listener.DeleteLifecycleListener;
 import javax.jdo.listener.InstanceLifecycleEvent;
 import javax.jdo.listener.StoreLifecycleListener;
 import org.apache.jdo.tck.pc.company.CompanyModelReader;
 import org.apache.jdo.tck.pc.company.Department;
 import org.apache.jdo.tck.pc.company.Employee;
 import org.apache.jdo.tck.pc.company.IEmployee;
 import org.apache.jdo.tck.pc.company.IProject;
 import org.apache.jdo.tck.pc.company.Person;
 import org.apache.jdo.tck.pc.company.Project;
 import org.apache.jdo.tck.pc.mylib.MylibReader;
 import org.apache.jdo.tck.pc.mylib.PrimitiveTypes;
 import org.apache.jdo.tck.query.QueryElementHolder;
 import org.apache.jdo.tck.query.QueryTest;
 import org.apache.jdo.tck.util.BatchTestRunner;
 import org.apache.jdo.tck.util.ConversionHelper;

 /**
  * <B>Title:</B> Delete Persistent All. <br>
  * <B>Keywords:</B> query <br>
  * <B>Assertion ID:</B> A14.8-4 <br>
  * <B>Assertion Description: </B> Dirty instances of affected classes are first flushed to the
  * datastore. Instances already in the cache when deleted via these methods or brought into the
  * cache as a result of these methods undergo the life cycle transitions as if deletePersistent had
  * been called on them. That is, if an affected class implements the DeleteCallback interface, the
  * instances to be deleted are instantiated in memory and the jdoPreDelete method is called prior to
  * deleting the instance in the datastore. If any LifecycleListener instances are registered with
  * affected classes, these listeners are called for each deleted instance. Before returning control
  * to the application, instances of affected classes in the cache are refreshed by the
  * implementation so their status in the cache reflects whether they were deleted from the
  * datastore.
  */
 public class DeleteCallback extends QueryTest {

   /** */
   private static final String ASSERTION_FAILED = "Assertion A14.8-4 (DeleteCallback) failed: ";

   /**
    * The array of valid queries which may be executed as single string queries and as API queries.
    */
   private static final QueryElementHolder<?>[] VALID_QUERIES = {
     new QueryElementHolder<>(
         /*UNIQUE*/ null,
         /*RESULT*/ null,
         /*INTO*/ null,
         /*FROM*/ Person.class,
         /*EXCLUDE*/ null,
         /*WHERE*/ null,
         /*VARIABLES*/ null,
         /*PARAMETERS*/ null,
         /*IMPORTS*/ null,
         /*GROUP BY*/ null,
         /*ORDER BY*/ null,
         /*FROM*/ null,
         /*TO*/ null),
     new QueryElementHolder<>(
         /*UNIQUE*/ null,
         /*RESULT*/ null,
         /*INTO*/ null,
         /*FROM*/ PrimitiveTypes.class,
         /*EXCLUDE*/ null,
         /*WHERE*/ null,
         /*VARIABLES*/ null,
         /*PARAMETERS*/ null,
         /*IMPORTS*/ null,
         /*GROUP BY*/ null,
         /*ORDER BY*/ null,
         /*FROM*/ null,
         /*TO*/ null)
   };

   /** The expected results of valid queries. */
   private final List<?>[] expectedResult = {
     getTransientCompanyModelInstancesAsList(Employee.class, "emp1", "emp2", "emp3", "emp4", "emp5"),
     getTransientMylibInstancesAsList(
         "primitiveTypesPositive", "primitiveTypesNegative", "primitiveTypesCharacterStringLiterals")
   };

   /**
    * The <code>main</code> is called when the class is directly executed from the command line.
    *
    * @param args The arguments passed to the program.
    */
   public static void main(String[] args) {
     BatchTestRunner.run(DeleteCallback.class);
   }

   /** */
   public void testRelationshipsAPI() {
     queryUpdateDeleteVerify(0, false, "middlename");
   }

   /** */
   public void testRelationshipsSingleString() {
     queryUpdateDeleteVerify(0, true, "middlename");
   }

   /** */
   public void testNoRelationshipsAPI() {
     queryUpdateDeleteVerify(1, false, "stringNull");
   }

   /** */
   public void testNoRelationshipsSingleString() {
     queryUpdateDeleteVerify(1, true, "stringNull");
   }

   /**
    * @see org.apache.jdo.tck.JDO_Test#localSetUp()
    */
   @Override
   protected void localSetUp() {
     addTearDownClass(CompanyModelReader.getTearDownClasses());
     addTearDownClass(MylibReader.getTearDownClasses());
     loadAndPersistCompanyModel(getPM());
     loadAndPersistMylib(getPM());
   }

   /**
    * Adds a lifecycle listener to the persistence manager.
    * Converts the query element holder instance refered to by argument
    * <code>index</code> to a JDO query instance based on argument
    * <code>asSingleString</code>.
    * Executes the query instance and marks all queried pc instances as dirty
    * by calling {@link JDOHelper#makeDirty(java.lang.Object, java.lang.String)}.
    * Passes argument <code>fieldName</code> to that call.
    * Afterwards, calls {@link Query#deletePersistentAll()}, and
    * verifies the lifecycle callbacks and the lifecycle states.
    * @param index the index of the query element holder instance
    * @param fieldName the field name passed as argument to
    * {@link JDOHelper#makeDirty(java.lang.Object, java.lang.String)
    * @param asSingleString determines if the query is executed as
    * single string query or as API query.
    */
   private void queryUpdateDeleteVerify(int index, boolean asSingleString, String fieldName) {
     PersistenceManager pm = getPM();
     Transaction transaction = pm.currentTransaction();
     transaction.begin();
     try {
       LifecycleVerifier lifecycleVerifier;
       Query<?> query =
           asSingleString
               ? VALID_QUERIES[index].getSingleStringQuery(pm)
               : VALID_QUERIES[index].getAPIQuery(pm);

       Collection<?> result = executeQuery(query, index, asSingleString);
       try {
         lifecycleVerifier = new LifecycleVerifier(result);
         pm.addInstanceLifecycleListener(
             lifecycleVerifier, VALID_QUERIES[index].getCandidateClass());
         updateInstances(result, fieldName);
         deleteInstances(query, index, asSingleString, result.size());
       } finally {
         query.close(result);
       }

       lifecycleVerifier.verifyCallbacksAndStates();
     } finally {
       if (transaction.isActive()) {
         transaction.rollback();
       }
     }
   }

   /**
    * Executes the given query, checks and returns the query result. Note: This mthod does not close
    * the query result.
    *
    * @param query the query.
    * @param index the index of the query element holder instance which was used to created the given
    *     query.
    * @param asSingleString indicates if the given query was created using API methods or if it was
    *     created by a single string.
    * @return the query result.
    */
   private Collection<?> executeQuery(Query<?> query, int index, boolean asSingleString) {
     if (logger.isDebugEnabled()) {
       if (asSingleString) {
         logger.debug("Executing single string query: " + VALID_QUERIES[index]);
       } else {
         logger.debug("Executing API query: " + VALID_QUERIES[index]);
       }
     }

     Collection<?> result = (Collection<?>) query.execute();

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

     checkQueryResultWithoutOrder(ASSERTION_FAILED, result, expectedResult[index]);
     return result;
   }

   /**
    * Makes all instances in the given collection dirty.
    * If instances are employees, then all relationships are cleared.
    * @param instances the instances
    * @param fieldName the field name passed as argument to
    * {@link JDOHelper#makeDirty(java.lang.Object, java.lang.String)
    */
   private void updateInstances(Collection<?> instances, String fieldName) {
     for (Object pc : instances) {
       // clear employee relationships
       if (pc instanceof Employee) {
         Employee employee = (Employee) pc;
         if (employee.getDentalInsurance() != null) {
           employee.getDentalInsurance().setEmployee(null);
         }
         if (employee.getMedicalInsurance() != null) {
           employee.getMedicalInsurance().setEmployee(null);
         }
         if (employee.getDepartment() != null) {
           ((Department) employee.getDepartment()).removeEmployee(employee);
         }
         if (employee.getFundingDept() != null) {
           ((Department) employee.getFundingDept()).removeEmployee(employee);
         }
         if (employee.getManager() != null) {
           ((Employee) employee.getManager()).removeFromTeam(employee);
         }
         if (employee.getMentor() != null) {
           employee.getMentor().setProtege(null);
         }
         if (employee.getProtege() != null) {
           employee.getProtege().setMentor(null);
         }
         if (employee.getHradvisor() != null) {
           ((Employee) employee.getHradvisor()).removeAdvisee(employee);
         }
         if (employee.getReviewedProjects() != null) {
           for (IProject iProject : employee.getReviewedProjects()) {
             Project other = (Project) iProject;
             other.removeReviewer(employee);
           }
         }
         if (employee.getProjects() != null) {
           for (IProject iProject : employee.getProjects()) {
             Project other = (Project) iProject;
             other.removeMember(employee);
           }
         }
         if (employee.getTeam() != null) {
           for (IEmployee iEmployee : employee.getTeam()) {
             Employee other = (Employee) iEmployee;
             other.setManager(null);
           }
         }
         if (employee.getHradvisees() != null) {
           for (IEmployee iEmployee : employee.getHradvisees()) {
             Employee other = (Employee) iEmployee;
             other.setHradvisor(employee);
           }
         }
       }

       // make the instance dirty.
       if (logger.isDebugEnabled()) {
         logger.debug("Calling JDOHelper.makeDirty(" + pc + ", \"" + fieldName + "\")");
       }
       JDOHelper.makeDirty(pc, fieldName);
     }
   }

   /**
    * Calls {@link Query#deletePersistentAll()} on the given query.
    *
    * @param query the query.
    * @param index the index of the query element holder instance which was used to created the given
    *     query.
    * @param asSingleString indicates if the given query was created using API methods or if it was
    *     created by a single string.
    * @param expectedNumberOfDeletedInstances the expected number of deleted instances.
    */
   private void deleteInstances(
       Query<?> query, int index, boolean asSingleString, int expectedNumberOfDeletedInstances) {
     if (logger.isDebugEnabled()) {
       if (asSingleString) {
         logger.debug("Deleting persistent by single string query: " + VALID_QUERIES[index]);
       } else {
         logger.debug("Deleting persistent by API query: " + VALID_QUERIES[index]);
       }
     }

     long nr = query.deletePersistentAll();

     if (logger.isDebugEnabled()) {
       logger.debug(nr + " objects deleted.");
     }

     if (nr != expectedNumberOfDeletedInstances) {
       fail(
           ASSERTION_FAILED,
           "deletePersistentAll returned "
               + nr
               + ", expected is "
               + expectedNumberOfDeletedInstances
               + ". Query: "
               + VALID_QUERIES[index]);
     }
   }

   /**
    * A lifecycle listener which may be added to persistence managers.
    * Gathers delete events and store events and keeps those
    * in a list.
    * Method {@link LifecycleVerifier#verifyCallbacksAndStates()}
    * may be called to check if the right events have been called
    * on all expected instances.
    * The expected instances are passed through
    * {@link LifecycleVerifier#LifecycleVerifier(Collection).
    */
   private class LifecycleVerifier implements DeleteLifecycleListener, StoreLifecycleListener {

     /** The oids of expected pc instances. */
     private final Collection<Object> expectedOids = new HashSet<>();

     /** The list of events. */
     private final List<InstanceLifecycleEvent> events = new ArrayList<>();

     /**
      * Argument <code>expectedPCInstances</code> holds pc instances which are expected to be sources
      * of events.
      *
      * @param expectedPCInstances the pc instances which are expected to be sources of events.
      */
     public LifecycleVerifier(Collection<?> expectedPCInstances) {
       for (Object expectedPCInstance : expectedPCInstances) {
         this.expectedOids.add(JDOHelper.getObjectId(expectedPCInstance));
       }
     }

     /**
      * Verifies if the right events have been called for all expected pc instances. All store events
      * must have been fired before the first delete event has been fired. Furthermore, checks if pc
      * instances kept in delete events have state persistent-deleted. The test case fails if one of
      * these conditions is violated.
      */
     public void verifyCallbacksAndStates() {
       if (logger.isDebugEnabled()) {
         logger.debug("Verifying callbacks and states.");
       }
       // The two collections are filled iterating through the list of
       // events. Finally, they are compared against field expectedOids.
       // Note: Set implementations are used instead of list
       // implementations to eliminate duplicates. Duplicates may occur
       // if multiple updates or deletions are executed for the same
       // pc instances.
       Collection<Object> oidsOfDeletedInstances = new HashSet<>();
       Collection<Object> oidsOfUpdateInstances = new HashSet<>();

       boolean hasDeleteEventBeenPassed = false;
       int size = events.size();
       for (InstanceLifecycleEvent event : events) {
         Object source = event.getSource();
         int eventType = event.getEventType();
         if (eventType == InstanceLifecycleEvent.DELETE) {
           if (logger.isDebugEnabled()) {
             logger.debug("Verifying delete event on " + JDOHelper.getObjectId(source));
           }
           hasDeleteEventBeenPassed = true;
           if (!JDOHelper.isDeleted(source)) {
             fail(
                 ASSERTION_FAILED, "PC instance must have persistent deleted " + "state: " + source);
           }
           oidsOfDeletedInstances.add(JDOHelper.getObjectId(source));
         } else if (eventType == InstanceLifecycleEvent.STORE) {
           if (logger.isDebugEnabled()) {
             logger.debug("Verifying store event on " + JDOHelper.getObjectId(source));
           }

           if (hasDeleteEventBeenPassed) {
             fail(
                 ASSERTION_FAILED,
                 "PC instances must not be flushed " + "after delete has been executed.");
           }
           oidsOfUpdateInstances.add(JDOHelper.getObjectId(source));
         }
       }

       if (!equalsCollection(oidsOfDeletedInstances, this.expectedOids)) {
         String lf = System.getProperty("line.separator");
         fail(
             ASSERTION_FAILED,
             "Got delete events for oids "
                 + oidsOfDeletedInstances
                 + '.'
                 + lf
                 + "Expected deleted events for oids "
                 + this.expectedOids
                 + '.');
       } else if (!oidsOfUpdateInstances.containsAll(this.expectedOids)) {
         String lf = System.getProperty("line.separator");
         fail(
             ASSERTION_FAILED,
             "Got store events for oids "
                 + oidsOfUpdateInstances
                 + '.'
                 + lf
                 + "Expected store events for oids "
                 + this.expectedOids
                 + '.');
       }
     }

     /**
      * @see DeleteLifecycleListener#preDelete(javax.jdo.listener.InstanceLifecycleEvent)
      */
     public void preDelete(InstanceLifecycleEvent event) {
       if (logger.isDebugEnabled()) {
         logger.debug("preDelete event: " + JDOHelper.getObjectId(event.getSource()));
       }
     }

     /**
      * @see DeleteLifecycleListener#postDelete(javax.jdo.listener.InstanceLifecycleEvent)
      */
     public void postDelete(InstanceLifecycleEvent event) {
       this.events.add(event);
       if (logger.isDebugEnabled()) {
         logger.debug("postDelete event: " + JDOHelper.getObjectId(event.getSource()));
       }
     }

     /**
      * @see StoreLifecycleListener#preStore(javax.jdo.listener.InstanceLifecycleEvent)
      */
     public void preStore(InstanceLifecycleEvent event) {
       if (logger.isDebugEnabled()) {
         logger.debug("preStore event: " + JDOHelper.getObjectId(event.getSource()));
       }
     }

     /**
      * @see StoreLifecycleListener#postStore(javax.jdo.listener.InstanceLifecycleEvent)
      */
     public void postStore(InstanceLifecycleEvent event) {
       this.events.add(event);
       if (logger.isDebugEnabled()) {
         logger.debug("postStore event: " + JDOHelper.getObjectId(event.getSource()));
       }
     }
   }
 }
	/*
	* 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.delete;

	import java.util.ArrayList;
	import java.util.Collection;
	import java.util.HashSet;
	import java.util.List;
	import javax.jdo.JDOHelper;
	import javax.jdo.PersistenceManager;
	import javax.jdo.Query;
	import javax.jdo.Transaction;
	import javax.jdo.listener.DeleteLifecycleListener;
	import javax.jdo.listener.InstanceLifecycleEvent;
	import javax.jdo.listener.StoreLifecycleListener;
	import org.apache.jdo.tck.pc.company.CompanyModelReader;
	import org.apache.jdo.tck.pc.company.Department;
	import org.apache.jdo.tck.pc.company.Employee;
	import org.apache.jdo.tck.pc.company.IEmployee;
	import org.apache.jdo.tck.pc.company.IProject;
	import org.apache.jdo.tck.pc.company.Person;
	import org.apache.jdo.tck.pc.company.Project;
	import org.apache.jdo.tck.pc.mylib.MylibReader;
	import org.apache.jdo.tck.pc.mylib.PrimitiveTypes;
	import org.apache.jdo.tck.query.QueryElementHolder;
	import org.apache.jdo.tck.query.QueryTest;
	import org.apache.jdo.tck.util.BatchTestRunner;
	import org.apache.jdo.tck.util.ConversionHelper;

	/**
	* <B>Title:</B> Delete Persistent All. <br>
	* <B>Keywords:</B> query <br>
	* <B>Assertion ID:</B> A14.8-4 <br>
	* <B>Assertion Description: </B> Dirty instances of affected classes are first flushed to the
	* datastore. Instances already in the cache when deleted via these methods or brought into the
	* cache as a result of these methods undergo the life cycle transitions as if deletePersistent had
	* been called on them. That is, if an affected class implements the DeleteCallback interface, the
	* instances to be deleted are instantiated in memory and the jdoPreDelete method is called prior to
	* deleting the instance in the datastore. If any LifecycleListener instances are registered with
	* affected classes, these listeners are called for each deleted instance. Before returning control
	* to the application, instances of affected classes in the cache are refreshed by the
	* implementation so their status in the cache reflects whether they were deleted from the
	* datastore.
	*/
	public class DeleteCallback extends QueryTest {

	/** */
	private static final String ASSERTION_FAILED = "Assertion A14.8-4 (DeleteCallback) failed: ";

	/**
	* The array of valid queries which may be executed as single string queries and as API queries.
	*/
	private static final QueryElementHolder<?>[] VALID_QUERIES = {
	new QueryElementHolder<>(
	/UNIQUE/ null,
	/RESULT/ null,
	/INTO/ null,
	/FROM/ Person.class,
	/EXCLUDE/ null,
	/WHERE/ null,
	/VARIABLES/ null,
	/PARAMETERS/ null,
	/IMPORTS/ null,
	/GROUP BY/ null,
	/ORDER BY/ null,
	/FROM/ null,
	/TO/ null),
	new QueryElementHolder<>(
	/UNIQUE/ null,
	/RESULT/ null,
	/INTO/ null,
	/FROM/ PrimitiveTypes.class,
	/EXCLUDE/ null,
	/WHERE/ null,
	/VARIABLES/ null,
	/PARAMETERS/ null,
	/IMPORTS/ null,
	/GROUP BY/ null,
	/ORDER BY/ null,
	/FROM/ null,
	/TO/ null)
	};

	/** The expected results of valid queries. */
	private final List<?>[] expectedResult = {
	getTransientCompanyModelInstancesAsList(Employee.class, "emp1", "emp2", "emp3", "emp4", "emp5"),
	getTransientMylibInstancesAsList(
	"primitiveTypesPositive", "primitiveTypesNegative", "primitiveTypesCharacterStringLiterals")
	};

	/**
	* The <code>main</code> is called when the class is directly executed from the command line.
	*
	* @param args The arguments passed to the program.
	*/
	public static void main(String[] args) {
	BatchTestRunner.run(DeleteCallback.class);
	}

	/** */
	public void testRelationshipsAPI() {
	queryUpdateDeleteVerify(0, false, "middlename");
	}

	/** */
	public void testRelationshipsSingleString() {
	queryUpdateDeleteVerify(0, true, "middlename");
	}

	/** */
	public void testNoRelationshipsAPI() {
	queryUpdateDeleteVerify(1, false, "stringNull");
	}

	/** */
	public void testNoRelationshipsSingleString() {
	queryUpdateDeleteVerify(1, true, "stringNull");
	}

	/**
	* @see org.apache.jdo.tck.JDO_Test#localSetUp()
	*/
	@Override
	protected void localSetUp() {
	addTearDownClass(CompanyModelReader.getTearDownClasses());
	addTearDownClass(MylibReader.getTearDownClasses());
	loadAndPersistCompanyModel(getPM());
	loadAndPersistMylib(getPM());
	}

	/**
	* Adds a lifecycle listener to the persistence manager.
	* Converts the query element holder instance refered to by argument
	* <code>index</code> to a JDO query instance based on argument
	* <code>asSingleString</code>.
	* Executes the query instance and marks all queried pc instances as dirty
	* by calling {@link JDOHelper#makeDirty(java.lang.Object, java.lang.String)}.
	* Passes argument <code>fieldName</code> to that call.
	* Afterwards, calls {@link Query#deletePersistentAll()}, and
	* verifies the lifecycle callbacks and the lifecycle states.
	* @param index the index of the query element holder instance
	* @param fieldName the field name passed as argument to
	* {@link JDOHelper#makeDirty(java.lang.Object, java.lang.String)
	* @param asSingleString determines if the query is executed as
	* single string query or as API query.
	*/
	private void queryUpdateDeleteVerify(int index, boolean asSingleString, String fieldName) {
	PersistenceManager pm = getPM();
	Transaction transaction = pm.currentTransaction();
	transaction.begin();
	try {
	LifecycleVerifier lifecycleVerifier;
	Query<?> query =
	asSingleString
	? VALID_QUERIES[index].getSingleStringQuery(pm)
	: VALID_QUERIES[index].getAPIQuery(pm);

	Collection<?> result = executeQuery(query, index, asSingleString);
	try {
	lifecycleVerifier = new LifecycleVerifier(result);
	pm.addInstanceLifecycleListener(
	lifecycleVerifier, VALID_QUERIES[index].getCandidateClass());
	updateInstances(result, fieldName);
	deleteInstances(query, index, asSingleString, result.size());
	} finally {
	query.close(result);
	}

	lifecycleVerifier.verifyCallbacksAndStates();
	} finally {
	if (transaction.isActive()) {
	transaction.rollback();
	}
	}
	}

	/**
	* Executes the given query, checks and returns the query result. Note: This mthod does not close
	* the query result.
	*
	* @param query the query.
	* @param index the index of the query element holder instance which was used to created the given
	* query.
	* @param asSingleString indicates if the given query was created using API methods or if it was
	* created by a single string.
	* @return the query result.
	*/
	private Collection<?> executeQuery(Query<?> query, int index, boolean asSingleString) {
	if (logger.isDebugEnabled()) {
	if (asSingleString) {
	logger.debug("Executing single string query: " + VALID_QUERIES[index]);
	} else {
	logger.debug("Executing API query: " + VALID_QUERIES[index]);
	}
	}

	Collection<?> result = (Collection<?>) query.execute();

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

	checkQueryResultWithoutOrder(ASSERTION_FAILED, result, expectedResult[index]);
	return result;
	}

	/**
	* Makes all instances in the given collection dirty.
	* If instances are employees, then all relationships are cleared.
	* @param instances the instances
	* @param fieldName the field name passed as argument to
	* {@link JDOHelper#makeDirty(java.lang.Object, java.lang.String)
	*/
	private void updateInstances(Collection<?> instances, String fieldName) {
	for (Object pc : instances) {
	// clear employee relationships
	if (pc instanceof Employee) {
	Employee employee = (Employee) pc;
	if (employee.getDentalInsurance() != null) {
	employee.getDentalInsurance().setEmployee(null);
	}
	if (employee.getMedicalInsurance() != null) {
	employee.getMedicalInsurance().setEmployee(null);
	}
	if (employee.getDepartment() != null) {
	((Department) employee.getDepartment()).removeEmployee(employee);
	}
	if (employee.getFundingDept() != null) {
	((Department) employee.getFundingDept()).removeEmployee(employee);
	}
	if (employee.getManager() != null) {
	((Employee) employee.getManager()).removeFromTeam(employee);
	}
	if (employee.getMentor() != null) {
	employee.getMentor().setProtege(null);
	}
	if (employee.getProtege() != null) {
	employee.getProtege().setMentor(null);
	}
	if (employee.getHradvisor() != null) {
	((Employee) employee.getHradvisor()).removeAdvisee(employee);
	}
	if (employee.getReviewedProjects() != null) {
	for (IProject iProject : employee.getReviewedProjects()) {
	Project other = (Project) iProject;
	other.removeReviewer(employee);
	}
	}
	if (employee.getProjects() != null) {
	for (IProject iProject : employee.getProjects()) {
	Project other = (Project) iProject;
	other.removeMember(employee);
	}
	}
	if (employee.getTeam() != null) {
	for (IEmployee iEmployee : employee.getTeam()) {
	Employee other = (Employee) iEmployee;
	other.setManager(null);
	}
	}
	if (employee.getHradvisees() != null) {
	for (IEmployee iEmployee : employee.getHradvisees()) {
	Employee other = (Employee) iEmployee;
	other.setHradvisor(employee);
	}
	}
	}

	// make the instance dirty.
	if (logger.isDebugEnabled()) {
	logger.debug("Calling JDOHelper.makeDirty(" + pc + ", \"" + fieldName + "\")");
	}
	JDOHelper.makeDirty(pc, fieldName);
	}
	}

	/**
	* Calls {@link Query#deletePersistentAll()} on the given query.
	*
	* @param query the query.
	* @param index the index of the query element holder instance which was used to created the given
	* query.
	* @param asSingleString indicates if the given query was created using API methods or if it was
	* created by a single string.
	* @param expectedNumberOfDeletedInstances the expected number of deleted instances.
	*/
	private void deleteInstances(
	Query<?> query, int index, boolean asSingleString, int expectedNumberOfDeletedInstances) {
	if (logger.isDebugEnabled()) {
	if (asSingleString) {
	logger.debug("Deleting persistent by single string query: " + VALID_QUERIES[index]);
	} else {
	logger.debug("Deleting persistent by API query: " + VALID_QUERIES[index]);
	}
	}

	long nr = query.deletePersistentAll();

	if (logger.isDebugEnabled()) {
	logger.debug(nr + " objects deleted.");
	}

	if (nr != expectedNumberOfDeletedInstances) {
	fail(
	ASSERTION_FAILED,
	"deletePersistentAll returned "
	+ nr
	+ ", expected is "
	+ expectedNumberOfDeletedInstances
	+ ". Query: "
	+ VALID_QUERIES[index]);
	}
	}

	/**
	* A lifecycle listener which may be added to persistence managers.
	* Gathers delete events and store events and keeps those
	* in a list.
	* Method {@link LifecycleVerifier#verifyCallbacksAndStates()}
	* may be called to check if the right events have been called
	* on all expected instances.
	* The expected instances are passed through
	* {@link LifecycleVerifier#LifecycleVerifier(Collection).
	*/
	private class LifecycleVerifier implements DeleteLifecycleListener, StoreLifecycleListener {

	/** The oids of expected pc instances. */
	private final Collection<Object> expectedOids = new HashSet<>();

	/** The list of events. */
	private final List<InstanceLifecycleEvent> events = new ArrayList<>();

	/**
	* Argument <code>expectedPCInstances</code> holds pc instances which are expected to be sources
	* of events.
	*
	* @param expectedPCInstances the pc instances which are expected to be sources of events.
	*/
	public LifecycleVerifier(Collection<?> expectedPCInstances) {
	for (Object expectedPCInstance : expectedPCInstances) {
	this.expectedOids.add(JDOHelper.getObjectId(expectedPCInstance));
	}
	}

	/**
	* Verifies if the right events have been called for all expected pc instances. All store events
	* must have been fired before the first delete event has been fired. Furthermore, checks if pc
	* instances kept in delete events have state persistent-deleted. The test case fails if one of
	* these conditions is violated.
	*/
	public void verifyCallbacksAndStates() {
	if (logger.isDebugEnabled()) {
	logger.debug("Verifying callbacks and states.");
	}
	// The two collections are filled iterating through the list of
	// events. Finally, they are compared against field expectedOids.
	// Note: Set implementations are used instead of list
	// implementations to eliminate duplicates. Duplicates may occur
	// if multiple updates or deletions are executed for the same
	// pc instances.
	Collection<Object> oidsOfDeletedInstances = new HashSet<>();
	Collection<Object> oidsOfUpdateInstances = new HashSet<>();

	boolean hasDeleteEventBeenPassed = false;
	int size = events.size();
	for (InstanceLifecycleEvent event : events) {
	Object source = event.getSource();
	int eventType = event.getEventType();
	if (eventType == InstanceLifecycleEvent.DELETE) {
	if (logger.isDebugEnabled()) {
	logger.debug("Verifying delete event on " + JDOHelper.getObjectId(source));
	}
	hasDeleteEventBeenPassed = true;
	if (!JDOHelper.isDeleted(source)) {
	fail(
	ASSERTION_FAILED, "PC instance must have persistent deleted " + "state: " + source);
	}
	oidsOfDeletedInstances.add(JDOHelper.getObjectId(source));
	} else if (eventType == InstanceLifecycleEvent.STORE) {
	if (logger.isDebugEnabled()) {
	logger.debug("Verifying store event on " + JDOHelper.getObjectId(source));
	}

	if (hasDeleteEventBeenPassed) {
	fail(
	ASSERTION_FAILED,
	"PC instances must not be flushed " + "after delete has been executed.");
	}
	oidsOfUpdateInstances.add(JDOHelper.getObjectId(source));
	}
	}

	if (!equalsCollection(oidsOfDeletedInstances, this.expectedOids)) {
	String lf = System.getProperty("line.separator");
	fail(
	ASSERTION_FAILED,
	"Got delete events for oids "
	+ oidsOfDeletedInstances
	+ '.'
	+ lf
	+ "Expected deleted events for oids "
	+ this.expectedOids
	+ '.');
	} else if (!oidsOfUpdateInstances.containsAll(this.expectedOids)) {
	String lf = System.getProperty("line.separator");
	fail(
	ASSERTION_FAILED,
	"Got store events for oids "
	+ oidsOfUpdateInstances
	+ '.'
	+ lf
	+ "Expected store events for oids "
	+ this.expectedOids
	+ '.');
	}
	}

	/**
	* @see DeleteLifecycleListener#preDelete(javax.jdo.listener.InstanceLifecycleEvent)
	*/
	public void preDelete(InstanceLifecycleEvent event) {
	if (logger.isDebugEnabled()) {
	logger.debug("preDelete event: " + JDOHelper.getObjectId(event.getSource()));
	}
	}

	/**
	* @see DeleteLifecycleListener#postDelete(javax.jdo.listener.InstanceLifecycleEvent)
	*/
	public void postDelete(InstanceLifecycleEvent event) {
	this.events.add(event);
	if (logger.isDebugEnabled()) {
	logger.debug("postDelete event: " + JDOHelper.getObjectId(event.getSource()));
	}
	}

	/**
	* @see StoreLifecycleListener#preStore(javax.jdo.listener.InstanceLifecycleEvent)
	*/
	public void preStore(InstanceLifecycleEvent event) {
	if (logger.isDebugEnabled()) {
	logger.debug("preStore event: " + JDOHelper.getObjectId(event.getSource()));
	}
	}

	/**
	* @see StoreLifecycleListener#postStore(javax.jdo.listener.InstanceLifecycleEvent)
	*/
	public void postStore(InstanceLifecycleEvent event) {
	this.events.add(event);
	if (logger.isDebugEnabled()) {
	logger.debug("postStore event: " + JDOHelper.getObjectId(event.getSource()));
	}
	}
	}
	}