tck/src/main/java/org/apache/jdo/tck/api/converter/PointAttributeConverterTest.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
  *
  *     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
  * limitations under the License.
  */
 package org.apache.jdo.tck.api.converter;

 import java.lang.reflect.InvocationTargetException;
 import java.util.List;
 import javax.jdo.JDOHelper;
 import javax.jdo.Query;
 import javax.jdo.Transaction;
 import org.apache.jdo.tck.JDO_Test;
 import org.apache.jdo.tck.pc.converter.IPCRect;
 import org.apache.jdo.tck.pc.converter.PCRect;
 import org.apache.jdo.tck.pc.converter.PCRectAnnotated;
 import org.apache.jdo.tck.pc.mylib.Point;
 import org.apache.jdo.tck.util.BatchTestRunner;
 import org.apache.jdo.tck.util.PointToStringConverter;

 /**
  * <B>Title:</B>PointAttributeConverterTest <br>
  * <B>Keywords:</B> mapping <br>
  * <B>Assertion ID:</B> [not identified] <br>
  * <B>Assertion Description: </B> A IPCRect instance refers two Point instances, that are stored as
  * strings in the datastore. A Point instance is converted using an AttributeConverter.
  */
 public class PointAttributeConverterTest extends JDO_Test {

   private static final int UL_X = 1;
   private static final int UL_Y = 10;
   private static final int LR_X = 10;
   private static final int LR_Y = 1;

   /**
    * 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(PointAttributeConverterTest.class);
   }

   /**
    * @see org.apache.jdo.tck.JDO_Test#localSetUp()
    */
   @Override
   protected void localSetUp() {
     addTearDownClass(PCRect.class);
     addTearDownClass(PCRectAnnotated.class);
   }

   /** Test method creating and storing a PCRectString instance. */
   public void testStorePCRectStringInstance() {
     runStoreIPCRectInstance(PCRect.class);
   }

   /** Test method reading a PCRectString instance from the datastore. */
   public void testReadPCRectStringInstance() {
     runReadIPCRectInstance(PCRect.class);
   }

   /** Test method modifying a PCRectString instance and storing in the datastore. */
   public void testModifyPCRectStringInstance() {
     runModifyIPCRectInstance(PCRect.class);
   }

   /** Test method running a PCRectString query with a query parameter of type Point. */
   public void testPCRectStringQueryWithPointParam() {
     runQueryWithPointParameter(PCRect.class);
   }

   /** Test method running a PCRectString query with a query parameter of type String. */
   public void testPCRectStringQueryWithStringParam() throws Exception {
     runQueryWithStringParameter(PCRect.class);
   }

   /** Test method creating and storing a PCRectStringAnnotated instance. */
   public void testStorePCRectStringAnnotatedInstance() {
     runStoreIPCRectInstance(PCRectAnnotated.class);
   }

   /** Test method reading a PCRectStringAnnotated instance from the datastore. */
   public void testReadPCRectStringAnnotatedInstance() {
     runReadIPCRectInstance(PCRectAnnotated.class);
   }

   /** Test method modifying a PCRectStringAnnotated instance and storing in the datastore. */
   public void testModifyPCRectStringAnnotatedInstance() {
     runModifyIPCRectInstance(PCRectAnnotated.class);
   }

   /** Test method running a PCRectStringAnnotated query with a query parameter of type String. */
   public void testPCRectStringAnnotatedQueryWithPointParam() {
     runQueryWithPointParameter(PCRectAnnotated.class);
   }

   /** Test method running a PCRectStringAnnotated query with a query parameter of type Point. */
   public void testPCRectStringAnnotatedQueryWithStringParam() throws Exception {
     runQueryWithStringParameter(PCRectAnnotated.class);
   }

   // Helper methods

   /**
    * Helper method creating a IPCRect instance. It should call AttributeConverter method
    * convertToDatastore.
    */
   private <T extends IPCRect> void runStoreIPCRectInstance(Class<T> pcrectClass) {
     int nrOfDbCalls = PointToStringConverter.getNrOfConvertToDatastoreCalls();
     int nrOfAttrCalls = PointToStringConverter.getNrOfConvertToAttributeCalls();

     // Create a persistent IPCRect instance and store its oid
     // AttributeConverter method convertToDatastore is called when persisting instance
     createIPCRectInstances(pcrectClass, 1);

     // convertToDatastore should be called twice
     assertEquals(2, PointToStringConverter.getNrOfConvertToDatastoreCalls() - nrOfDbCalls);
     // convertToAttribute should not be called
     assertEquals(0, PointToStringConverter.getNrOfConvertToAttributeCalls() - nrOfAttrCalls);
   }

   /**
    * Helper method reading a IPCRect instance from the datastore. It should call AttributeConverter
    * method convertToAttribute.
    */
   private <T extends IPCRect> void runReadIPCRectInstance(Class<T> pcrectClass) {
     IPCRect rect;
     Object oid;
     int nrOfDbCalls;
     int nrOfAttrCalls;

     // Create a persistent IPCRect instance and store its oid
     oid = createIPCRectInstances(pcrectClass, 1);

     // Cleanup the 2nd-level cache and close the pm to make sure PCRect instances are not cached
     pm.getPersistenceManagerFactory().getDataStoreCache().evictAll(false, pcrectClass);
     pm.close();
     pm = null;

     nrOfDbCalls = PointToStringConverter.getNrOfConvertToDatastoreCalls();
     nrOfAttrCalls = PointToStringConverter.getNrOfConvertToAttributeCalls();
     pm = getPM();
     pm.currentTransaction().begin();
     // Read the IPCRect instance from the datastore, this should call convertToAttribute
     rect = (IPCRect) pm.getObjectById(oid);
     Point ul = rect.getUpperLeft();
     Point lr = rect.getLowerRight();
     pm.currentTransaction().commit();

     // convertToDatastore should not be called
     assertEquals(0, PointToStringConverter.getNrOfConvertToDatastoreCalls() - nrOfDbCalls);
     // convertToAttribute should be called twice
     assertEquals(2, PointToStringConverter.getNrOfConvertToAttributeCalls() - nrOfAttrCalls);
     // Check the values of the associated Point instances
     assertEquals(UL_X, ul.getX());
     assertEquals(UL_Y, ul.getY() == null ? 0 : ul.getY().intValue());
     assertEquals(LR_X, lr.getX());
     assertEquals(LR_Y, lr.getY() == null ? 0 : lr.getY().intValue());
   }

   /**
    * Helper method modifying a IPCRect instance. It should call AttributeConverter method
    * convertToDatastore.
    */
   private <T extends IPCRect> void runModifyIPCRectInstance(Class<T> pcrectClass) {
     Transaction tx;
     IPCRect rect;
     Object oid;
     int nrOfDbCalls;
     int nrOfAttrCalls;

     // Create a persistent IPCRect instance and store its oid
     oid = createIPCRectInstances(pcrectClass, 1);

     // Cleanup the 2nd-level cache and close the pm to make sure PCRect instances are not cached
     pm.getPersistenceManagerFactory().getDataStoreCache().evictAll(false, pcrectClass);
     pm.close();
     pm = null;

     nrOfDbCalls = PointToStringConverter.getNrOfConvertToDatastoreCalls();
     nrOfAttrCalls = PointToStringConverter.getNrOfConvertToAttributeCalls();
     pm = getPM();
     tx = pm.currentTransaction();
     tx.begin();
     rect = (IPCRect) pm.getObjectById(oid);
     // should trigger convertToAttribute
     rect.getLowerRight();
     rect.getUpperLeft();
     // Update IPCRect instance, this should call convertToDatastore
     rect.setUpperLeft(new Point(UL_X + 1, UL_Y + 1));
     rect.setLowerRight(new Point(LR_X + 1, LR_Y + 1));
     // IPCRect instance should be dirty
     assertTrue(JDOHelper.isDirty(rect));
     tx.commit();

     // convertToDatastore should be called twice
     assertEquals(2, PointToStringConverter.getNrOfConvertToDatastoreCalls() - nrOfDbCalls);
     // convertToAttribute should be called twice
     assertEquals(2, PointToStringConverter.getNrOfConvertToAttributeCalls() - nrOfAttrCalls);
   }

   /**
    * Helper method running a query with a Point parameter. The parameter value is converted using
    * the AttributeConverter.
    *
    * @throws Exception
    */
   private <T extends IPCRect> void runQueryWithPointParameter(Class<T> pcrectClass) {
     int nrOfDbCalls;
     int nrOfAttrCalls;

     nrOfDbCalls = PointToStringConverter.getNrOfConvertToDatastoreCalls();
     nrOfAttrCalls = PointToStringConverter.getNrOfConvertToAttributeCalls();
     createIPCRectInstances(pcrectClass, 5);
     // convertToDatastore should be called twice per instance = 10 times
     assertEquals(10, PointToStringConverter.getNrOfConvertToDatastoreCalls() - nrOfDbCalls);
     // convertToAttribute should not be called
     assertEquals(0, PointToStringConverter.getNrOfConvertToAttributeCalls() - nrOfAttrCalls);

     // Cleanup the 2nd-level cache and close the pm to make sure PCRect instances are not cached
     pm.getPersistenceManagerFactory().getDataStoreCache().evictAll(false, pcrectClass);
     pm.close();
     pm = null;

     nrOfDbCalls = PointToStringConverter.getNrOfConvertToDatastoreCalls();
     nrOfAttrCalls = PointToStringConverter.getNrOfConvertToAttributeCalls();
     pm = getPM();
     pm.currentTransaction().begin();
     try (Query<T> q = pm.newQuery(pcrectClass, "this.upperLeft == :point")) {
       q.setParameters(new Point(UL_X + 1, UL_Y + 1));
       // AttributeConverter method convertToAttribute is called when loading instance from the
       // datastore
       List<T> res = q.executeList();
       assertEquals(1, res.size());
       IPCRect rect = res.get(0);
       Point ul = rect.getUpperLeft();
       Point lr = rect.getLowerRight();

       // Check the coordinates of the associated Point instances
       assertEquals(UL_X + 1, ul.getX());
       assertEquals(UL_Y + 1, ul.getY() == null ? 0 : ul.getY().intValue());
       assertEquals(LR_X + 1, lr.getX());
       assertEquals(LR_Y + 1, lr.getY() == null ? 0 : lr.getY().intValue());
     } catch (Exception e) {
       fail(e.getMessage());
     } finally {
       pm.currentTransaction().commit();
     }

     // convertToDatastore should be called to handle the query parameter
     assertTrue(PointToStringConverter.getNrOfConvertToDatastoreCalls() - nrOfDbCalls >= 1);
     // convertToAttribute should be called at least twice
     assertTrue(PointToStringConverter.getNrOfConvertToAttributeCalls() - nrOfAttrCalls >= 2);
   }

   /**
    * Helper method running a query with a Point parameter. The string parameter is compared to the
    * converted Point field.
    *
    * @throws Exception
    */
   private <T extends IPCRect> void runQueryWithStringParameter(Class<T> pcrectClass)
       throws Exception {
     int nrOfDbCalls;
     int nrOfAttrCalls;

     nrOfDbCalls = PointToStringConverter.getNrOfConvertToDatastoreCalls();
     nrOfAttrCalls = PointToStringConverter.getNrOfConvertToAttributeCalls();
     createIPCRectInstances(pcrectClass, 5);
     // convertToDatastore should be called twice per instance = 10 times
     assertEquals(10, PointToStringConverter.getNrOfConvertToDatastoreCalls() - nrOfDbCalls);
     // convertToAttribute should not be called
     assertEquals(0, PointToStringConverter.getNrOfConvertToAttributeCalls() - nrOfAttrCalls);

     // Cleanup the 2nd-level cache and close the pm to make sure PCRect instances are not cached
     pm.getPersistenceManagerFactory().getDataStoreCache().evictAll(false, pcrectClass);
     pm.close();
     pm = null;

     nrOfDbCalls = PointToStringConverter.getNrOfConvertToDatastoreCalls();
     nrOfAttrCalls = PointToStringConverter.getNrOfConvertToAttributeCalls();
     pm = getPM();
     pm.currentTransaction().begin();
     try (Query<T> q = pm.newQuery(pcrectClass, "this.upperLeft == str")) {
       q.declareParameters("String str");
       q.setParameters("3:12");
       // AttributeConverter method convertToAttribute is called when loading instance from the
       // datastore
       List<T> res = q.executeList();
       assertEquals(1, res.size());
       IPCRect rect = res.get(0);
       Point ul = rect.getUpperLeft();
       Point lr = rect.getLowerRight();

       // Check the coordinates of the associated Point instances
       assertEquals(UL_X + 2, ul.getX());
       assertEquals(UL_Y + 2, ul.getY() == null ? 0 : ul.getY().intValue());
       assertEquals(LR_X + 2, lr.getX());
       assertEquals(LR_Y + 2, lr.getY() == null ? 0 : lr.getY().intValue());
     } finally {
       pm.currentTransaction().commit();
     }

     // convertToDatastore should not be called
     assertTrue(PointToStringConverter.getNrOfConvertToDatastoreCalls() - nrOfDbCalls == 0);
     // convertToAttribute should be called at least twice
     assertTrue(PointToStringConverter.getNrOfConvertToAttributeCalls() - nrOfAttrCalls >= 2);
   }

   /**
    * Helper method to create IPCRect instances.
    *
    * @param pcrectClass class instance of the IPCRect implementation class to be created
    * @param nrOfObjects number of IPCRect instances to be created
    * @return ObjectId of the first IPCRect instance
    */
   private <T extends IPCRect> Object createIPCRectInstances(Class<T> pcrectClass, int nrOfObjects) {
     IPCRect rect;
     Object oid = null;

     if (nrOfObjects < 1) {
       return null;
     }

     pm = getPM();
     try {
       pm.currentTransaction().begin();
       rect = pcrectClass.getConstructor().newInstance();
       rect.setUpperLeft(new Point(UL_X, UL_Y));
       rect.setLowerRight(new Point(LR_X, LR_Y));
       pm.makePersistent(rect);
       oid = pm.getObjectId(rect);
       for (int i = 1; i < nrOfObjects; i++) {
         rect = pcrectClass.getConstructor().newInstance();
         rect.setUpperLeft(new Point(UL_X + i, UL_Y + i));
         rect.setLowerRight(new Point(LR_X + i, LR_Y + i));
         pm.makePersistent(rect);
       }
       pm.currentTransaction().commit();
     } catch (NoSuchMethodException
         | SecurityException
         | InstantiationException
         | IllegalAccessException
         | IllegalArgumentException
         | InvocationTargetException ex) {
       fail("Error creating IPCRect instance: " + ex.getMessage());
     } finally {
       if (pm.currentTransaction().isActive()) {
         pm.currentTransaction().rollback();
       }
     }
     return oid;
   }
 }
	/*
	* 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
	*
	* 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
	* limitations under the License.
	*/
	package org.apache.jdo.tck.api.converter;

	import java.lang.reflect.InvocationTargetException;
	import java.util.List;
	import javax.jdo.JDOHelper;
	import javax.jdo.Query;
	import javax.jdo.Transaction;
	import org.apache.jdo.tck.JDO_Test;
	import org.apache.jdo.tck.pc.converter.IPCRect;
	import org.apache.jdo.tck.pc.converter.PCRect;
	import org.apache.jdo.tck.pc.converter.PCRectAnnotated;
	import org.apache.jdo.tck.pc.mylib.Point;
	import org.apache.jdo.tck.util.BatchTestRunner;
	import org.apache.jdo.tck.util.PointToStringConverter;

	/**
	* <B>Title:</B>PointAttributeConverterTest <br>
	* <B>Keywords:</B> mapping <br>
	* <B>Assertion ID:</B> [not identified] <br>
	* <B>Assertion Description: </B> A IPCRect instance refers two Point instances, that are stored as
	* strings in the datastore. A Point instance is converted using an AttributeConverter.
	*/
	public class PointAttributeConverterTest extends JDO_Test {

	private static final int UL_X = 1;
	private static final int UL_Y = 10;
	private static final int LR_X = 10;
	private static final int LR_Y = 1;

	/**
	* 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(PointAttributeConverterTest.class);
	}

	/**
	* @see org.apache.jdo.tck.JDO_Test#localSetUp()
	*/
	@Override
	protected void localSetUp() {
	addTearDownClass(PCRect.class);
	addTearDownClass(PCRectAnnotated.class);
	}

	/** Test method creating and storing a PCRectString instance. */
	public void testStorePCRectStringInstance() {
	runStoreIPCRectInstance(PCRect.class);
	}

	/** Test method reading a PCRectString instance from the datastore. */
	public void testReadPCRectStringInstance() {
	runReadIPCRectInstance(PCRect.class);
	}

	/** Test method modifying a PCRectString instance and storing in the datastore. */
	public void testModifyPCRectStringInstance() {
	runModifyIPCRectInstance(PCRect.class);
	}

	/** Test method running a PCRectString query with a query parameter of type Point. */
	public void testPCRectStringQueryWithPointParam() {
	runQueryWithPointParameter(PCRect.class);
	}

	/** Test method running a PCRectString query with a query parameter of type String. */
	public void testPCRectStringQueryWithStringParam() throws Exception {
	runQueryWithStringParameter(PCRect.class);
	}

	/** Test method creating and storing a PCRectStringAnnotated instance. */
	public void testStorePCRectStringAnnotatedInstance() {
	runStoreIPCRectInstance(PCRectAnnotated.class);
	}

	/** Test method reading a PCRectStringAnnotated instance from the datastore. */
	public void testReadPCRectStringAnnotatedInstance() {
	runReadIPCRectInstance(PCRectAnnotated.class);
	}

	/** Test method modifying a PCRectStringAnnotated instance and storing in the datastore. */
	public void testModifyPCRectStringAnnotatedInstance() {
	runModifyIPCRectInstance(PCRectAnnotated.class);
	}

	/** Test method running a PCRectStringAnnotated query with a query parameter of type String. */
	public void testPCRectStringAnnotatedQueryWithPointParam() {
	runQueryWithPointParameter(PCRectAnnotated.class);
	}

	/** Test method running a PCRectStringAnnotated query with a query parameter of type Point. */
	public void testPCRectStringAnnotatedQueryWithStringParam() throws Exception {
	runQueryWithStringParameter(PCRectAnnotated.class);
	}

	// Helper methods

	/**
	* Helper method creating a IPCRect instance. It should call AttributeConverter method
	* convertToDatastore.
	*/
	private <T extends IPCRect> void runStoreIPCRectInstance(Class<T> pcrectClass) {
	int nrOfDbCalls = PointToStringConverter.getNrOfConvertToDatastoreCalls();
	int nrOfAttrCalls = PointToStringConverter.getNrOfConvertToAttributeCalls();

	// Create a persistent IPCRect instance and store its oid
	// AttributeConverter method convertToDatastore is called when persisting instance
	createIPCRectInstances(pcrectClass, 1);

	// convertToDatastore should be called twice
	assertEquals(2, PointToStringConverter.getNrOfConvertToDatastoreCalls() - nrOfDbCalls);
	// convertToAttribute should not be called
	assertEquals(0, PointToStringConverter.getNrOfConvertToAttributeCalls() - nrOfAttrCalls);
	}

	/**
	* Helper method reading a IPCRect instance from the datastore. It should call AttributeConverter
	* method convertToAttribute.
	*/
	private <T extends IPCRect> void runReadIPCRectInstance(Class<T> pcrectClass) {
	IPCRect rect;
	Object oid;
	int nrOfDbCalls;
	int nrOfAttrCalls;

	// Create a persistent IPCRect instance and store its oid
	oid = createIPCRectInstances(pcrectClass, 1);

	// Cleanup the 2nd-level cache and close the pm to make sure PCRect instances are not cached
	pm.getPersistenceManagerFactory().getDataStoreCache().evictAll(false, pcrectClass);
	pm.close();
	pm = null;

	nrOfDbCalls = PointToStringConverter.getNrOfConvertToDatastoreCalls();
	nrOfAttrCalls = PointToStringConverter.getNrOfConvertToAttributeCalls();
	pm = getPM();
	pm.currentTransaction().begin();
	// Read the IPCRect instance from the datastore, this should call convertToAttribute
	rect = (IPCRect) pm.getObjectById(oid);
	Point ul = rect.getUpperLeft();
	Point lr = rect.getLowerRight();
	pm.currentTransaction().commit();

	// convertToDatastore should not be called
	assertEquals(0, PointToStringConverter.getNrOfConvertToDatastoreCalls() - nrOfDbCalls);
	// convertToAttribute should be called twice
	assertEquals(2, PointToStringConverter.getNrOfConvertToAttributeCalls() - nrOfAttrCalls);
	// Check the values of the associated Point instances
	assertEquals(UL_X, ul.getX());
	assertEquals(UL_Y, ul.getY() == null ? 0 : ul.getY().intValue());
	assertEquals(LR_X, lr.getX());
	assertEquals(LR_Y, lr.getY() == null ? 0 : lr.getY().intValue());
	}

	/**
	* Helper method modifying a IPCRect instance. It should call AttributeConverter method
	* convertToDatastore.
	*/
	private <T extends IPCRect> void runModifyIPCRectInstance(Class<T> pcrectClass) {
	Transaction tx;
	IPCRect rect;
	Object oid;
	int nrOfDbCalls;
	int nrOfAttrCalls;

	// Create a persistent IPCRect instance and store its oid
	oid = createIPCRectInstances(pcrectClass, 1);

	// Cleanup the 2nd-level cache and close the pm to make sure PCRect instances are not cached
	pm.getPersistenceManagerFactory().getDataStoreCache().evictAll(false, pcrectClass);
	pm.close();
	pm = null;

	nrOfDbCalls = PointToStringConverter.getNrOfConvertToDatastoreCalls();
	nrOfAttrCalls = PointToStringConverter.getNrOfConvertToAttributeCalls();
	pm = getPM();
	tx = pm.currentTransaction();
	tx.begin();
	rect = (IPCRect) pm.getObjectById(oid);
	// should trigger convertToAttribute
	rect.getLowerRight();
	rect.getUpperLeft();
	// Update IPCRect instance, this should call convertToDatastore
	rect.setUpperLeft(new Point(UL_X + 1, UL_Y + 1));
	rect.setLowerRight(new Point(LR_X + 1, LR_Y + 1));
	// IPCRect instance should be dirty
	assertTrue(JDOHelper.isDirty(rect));
	tx.commit();

	// convertToDatastore should be called twice
	assertEquals(2, PointToStringConverter.getNrOfConvertToDatastoreCalls() - nrOfDbCalls);
	// convertToAttribute should be called twice
	assertEquals(2, PointToStringConverter.getNrOfConvertToAttributeCalls() - nrOfAttrCalls);
	}

	/**
	* Helper method running a query with a Point parameter. The parameter value is converted using
	* the AttributeConverter.
	*
	* @throws Exception
	*/
	private <T extends IPCRect> void runQueryWithPointParameter(Class<T> pcrectClass) {
	int nrOfDbCalls;
	int nrOfAttrCalls;

	nrOfDbCalls = PointToStringConverter.getNrOfConvertToDatastoreCalls();
	nrOfAttrCalls = PointToStringConverter.getNrOfConvertToAttributeCalls();
	createIPCRectInstances(pcrectClass, 5);
	// convertToDatastore should be called twice per instance = 10 times
	assertEquals(10, PointToStringConverter.getNrOfConvertToDatastoreCalls() - nrOfDbCalls);
	// convertToAttribute should not be called
	assertEquals(0, PointToStringConverter.getNrOfConvertToAttributeCalls() - nrOfAttrCalls);

	// Cleanup the 2nd-level cache and close the pm to make sure PCRect instances are not cached
	pm.getPersistenceManagerFactory().getDataStoreCache().evictAll(false, pcrectClass);
	pm.close();
	pm = null;

	nrOfDbCalls = PointToStringConverter.getNrOfConvertToDatastoreCalls();
	nrOfAttrCalls = PointToStringConverter.getNrOfConvertToAttributeCalls();
	pm = getPM();
	pm.currentTransaction().begin();
	try (Query<T> q = pm.newQuery(pcrectClass, "this.upperLeft == :point")) {
	q.setParameters(new Point(UL_X + 1, UL_Y + 1));
	// AttributeConverter method convertToAttribute is called when loading instance from the
	// datastore
	List<T> res = q.executeList();
	assertEquals(1, res.size());
	IPCRect rect = res.get(0);
	Point ul = rect.getUpperLeft();
	Point lr = rect.getLowerRight();

	// Check the coordinates of the associated Point instances
	assertEquals(UL_X + 1, ul.getX());
	assertEquals(UL_Y + 1, ul.getY() == null ? 0 : ul.getY().intValue());
	assertEquals(LR_X + 1, lr.getX());
	assertEquals(LR_Y + 1, lr.getY() == null ? 0 : lr.getY().intValue());
	} catch (Exception e) {
	fail(e.getMessage());
	} finally {
	pm.currentTransaction().commit();
	}

	// convertToDatastore should be called to handle the query parameter
	assertTrue(PointToStringConverter.getNrOfConvertToDatastoreCalls() - nrOfDbCalls >= 1);
	// convertToAttribute should be called at least twice
	assertTrue(PointToStringConverter.getNrOfConvertToAttributeCalls() - nrOfAttrCalls >= 2);
	}

	/**
	* Helper method running a query with a Point parameter. The string parameter is compared to the
	* converted Point field.
	*
	* @throws Exception
	*/
	private <T extends IPCRect> void runQueryWithStringParameter(Class<T> pcrectClass)
	throws Exception {
	int nrOfDbCalls;
	int nrOfAttrCalls;

	nrOfDbCalls = PointToStringConverter.getNrOfConvertToDatastoreCalls();
	nrOfAttrCalls = PointToStringConverter.getNrOfConvertToAttributeCalls();
	createIPCRectInstances(pcrectClass, 5);
	// convertToDatastore should be called twice per instance = 10 times
	assertEquals(10, PointToStringConverter.getNrOfConvertToDatastoreCalls() - nrOfDbCalls);
	// convertToAttribute should not be called
	assertEquals(0, PointToStringConverter.getNrOfConvertToAttributeCalls() - nrOfAttrCalls);

	// Cleanup the 2nd-level cache and close the pm to make sure PCRect instances are not cached
	pm.getPersistenceManagerFactory().getDataStoreCache().evictAll(false, pcrectClass);
	pm.close();
	pm = null;

	nrOfDbCalls = PointToStringConverter.getNrOfConvertToDatastoreCalls();
	nrOfAttrCalls = PointToStringConverter.getNrOfConvertToAttributeCalls();
	pm = getPM();
	pm.currentTransaction().begin();
	try (Query<T> q = pm.newQuery(pcrectClass, "this.upperLeft == str")) {
	q.declareParameters("String str");
	q.setParameters("3:12");
	// AttributeConverter method convertToAttribute is called when loading instance from the
	// datastore
	List<T> res = q.executeList();
	assertEquals(1, res.size());
	IPCRect rect = res.get(0);
	Point ul = rect.getUpperLeft();
	Point lr = rect.getLowerRight();

	// Check the coordinates of the associated Point instances
	assertEquals(UL_X + 2, ul.getX());
	assertEquals(UL_Y + 2, ul.getY() == null ? 0 : ul.getY().intValue());
	assertEquals(LR_X + 2, lr.getX());
	assertEquals(LR_Y + 2, lr.getY() == null ? 0 : lr.getY().intValue());
	} finally {
	pm.currentTransaction().commit();
	}

	// convertToDatastore should not be called
	assertTrue(PointToStringConverter.getNrOfConvertToDatastoreCalls() - nrOfDbCalls == 0);
	// convertToAttribute should be called at least twice
	assertTrue(PointToStringConverter.getNrOfConvertToAttributeCalls() - nrOfAttrCalls >= 2);
	}

	/**
	* Helper method to create IPCRect instances.
	*
	* @param pcrectClass class instance of the IPCRect implementation class to be created
	* @param nrOfObjects number of IPCRect instances to be created
	* @return ObjectId of the first IPCRect instance
	*/
	private <T extends IPCRect> Object createIPCRectInstances(Class<T> pcrectClass, int nrOfObjects) {
	IPCRect rect;
	Object oid = null;

	if (nrOfObjects < 1) {
	return null;
	}

	pm = getPM();
	try {
	pm.currentTransaction().begin();
	rect = pcrectClass.getConstructor().newInstance();
	rect.setUpperLeft(new Point(UL_X, UL_Y));
	rect.setLowerRight(new Point(LR_X, LR_Y));
	pm.makePersistent(rect);
	oid = pm.getObjectId(rect);
	for (int i = 1; i < nrOfObjects; i++) {
	rect = pcrectClass.getConstructor().newInstance();
	rect.setUpperLeft(new Point(UL_X + i, UL_Y + i));
	rect.setLowerRight(new Point(LR_X + i, LR_Y + i));
	pm.makePersistent(rect);
	}
	pm.currentTransaction().commit();
	} catch (NoSuchMethodException
	\| SecurityException
	\| InstantiationException
	\| IllegalAccessException
	\| IllegalArgumentException
	\| InvocationTargetException ex) {
	fail("Error creating IPCRect instance: " + ex.getMessage());
	} finally {
	if (pm.currentTransaction().isActive()) {
	pm.currentTransaction().rollback();
	}
	}
	return oid;
	}
	}