/* * Copyright 2005 The Apache Software Foundation. * * Licensed 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 * * 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 * limitations under the License. */ package org.apache.jdo.tck.api.persistencemanager; import java.util.Collection; import java.util.Iterator; import javax.jdo.Query; import javax.jdo.Transaction; import org.apache.jdo.tck.pc.mylib.PCPoint; import org.apache.jdo.tck.pc.mylib.PCRect; import org.apache.jdo.tck.util.BatchTestRunner; /** *<B>Title:</B> Only one instance of persistent object in cache per PersistenceManager *<BR> *<B>Keywords:</B> cache *<BR> *<B>Assertion ID:</B> A5.4-10. *<BR> *<B>Assertion Description: </B> JDO implementations must manage the cache of JDO instances such that there is only one JDO instance, associated with each <code>PersistenceManager</code> representing the persistent state of each corresponding data store object. */ public class OneInstanceOfObjectPerPersistenceManager extends PersistenceManagerTest { /** */ private static final String ASSERTION_FAILED = "Assertion A5.4-10 (OneInstanceOfObjectPerPersistenceManager) " + "failed: "; /** * 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(OneInstanceOfObjectPerPersistenceManager.class); } /** * This test creates objects in one transaction and commits. * The important object is p1. * Then, in a second transaction, it gets an object p1a by id, * gets another object p1b by navigation, and a third object p1c by * query. All of these represent the same datastore object and * therefore must be identical in the same PersistenceManager. */ public void test() { /** The getPM method is declared in a superclass. * This is the standard way to get a PersistenceManager. * The method automatically gets a PersistenceManagerFactory, * gets a PersistenceManager, and puts the PersistenceManager into * the field pm. */ getPM(); /** This is the standard way to get a Transaction. */ Transaction tx = pm.currentTransaction(); /** Any values for these flags should be set before * beginning a transaction. */ tx.setRetainValues(false); tx.setRestoreValues(false); /** This is the standard way to begin a transaction. */ tx.begin(); /** Create new objects to be persisted. */ PCPoint p1 = new PCPoint(10, 20); PCPoint p2 = new PCPoint(20, 40); PCRect rect = new PCRect(0, p1, p2); /** This test relies on persistence by reachability. */ pm.makePersistent(rect); /** This is the standard way to commit a transaction. */ tx.commit(); /** Begin a new transaction so that the navigation * uses the object id to load the target object into the cache. * The RetainValues flag false guarantees that the object fields * are no longer loaded. */ tx.begin(); Object p1Id = pm.getObjectId(p1); /** Retrieves the field values from the datastore. */ PCPoint p1a = (PCPoint)pm.getObjectById(p1Id, true); /** Navigate to the point. */ PCPoint p1b = rect.getUpperLeft(); /** Query for the point by its values in the datastore. */ PCPoint p1c = findPoint(10, 20); tx.commit(); tx = null; /** Use a StringBuffer to collect results. */ StringBuffer results = new StringBuffer(); /** Compare the original object with the object obtained * by getObjectById. */ if (p1 != p1a) { results.append("getObjectById results differ. "); } /** Compare the original object with the object obtained * by navigating from another object. */ if (p1 != p1b) { results.append("navigation results differ. "); } /** Compare the original object with the object obtained * by query. */ if (p1 != p1c) { results.append("query results differ. "); } if (results.length() != 0) { fail(ASSERTION_FAILED + results.toString()); } /** The standard way to end each test method is to simply return. * Exceptions are caught by JUnit. * The tearDown method ends the transaction and closes * the PersistenceManager. */ } /** */ private PCPoint findPoint (int x, int y) { Query q = getPM().newQuery (PCPoint.class); q.declareParameters ("int px, int py"); q.setFilter ("x == px & y == py"); Collection results = (Collection)q.execute (new Integer(x), new Integer(y)); Iterator it = results.iterator(); PCPoint ret = (PCPoint)it.next(); return ret; } }