Differences between revisions 1 and 2
Revision 1 as of 2005-09-19 03:31:36
Size: 5758
Comment: New page: sample TCK test
Revision 2 as of 2009-09-20 23:08:51
Size: 5758
Editor: localhost
Comment: converted to 1.6 markup
No differences found!
  • /*
     * 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;
        }
        
    }

SampleTest (last edited 2009-09-20 23:08:51 by localhost)