db-jdo-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From m..@apache.org
Subject svn commit: r171355 [18/31] - in /incubator/jdo/trunk/fostore20: ./ src/ src/conf/ src/java/ src/java/org/ src/java/org/apache/ src/java/org/apache/jdo/ src/java/org/apache/jdo/impl/ src/java/org/apache/jdo/impl/fostore/ test/ test/conf/ test/fsuid2/ test/fsuid2/org/ test/fsuid2/org/apache/ test/fsuid2/org/apache/jdo/ test/fsuid2/org/apache/jdo/pc/ test/java/ test/java/org/ test/java/org/apache/ test/java/org/apache/jdo/ test/java/org/apache/jdo/impl/ test/java/org/apache/jdo/impl/fostore/ test/java/org/apache/jdo/pc/ test/java/org/apache/jdo/pc/appid/ test/java/org/apache/jdo/pc/empdept/ test/java/org/apache/jdo/pc/serializable/ test/java/org/apache/jdo/pc/xempdept/ test/java/org/apache/jdo/test/ test/java/org/apache/jdo/test/query/ test/java/org/apache/jdo/test/util/ test/jdo/ test/jdo/org/ test/jdo/org/apache/ test/jdo/org/apache/jdo/ test/jdo/org/apache/jdo/pc/ test/jdo/org/apache/jdo/pc/appid/ test/jdo/org/apache/jdo/pc/empdept/ test/jdo/org/apache/jdo/pc/serializable/ test/jdo/org/apache/jdo/pc/xempdept/
Date Sun, 22 May 2005 18:40:21 GMT
Added: incubator/jdo/trunk/fostore20/test/java/org/apache/jdo/test/Test_JDOModel.java
URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/fostore20/test/java/org/apache/jdo/test/Test_JDOModel.java?rev=171355&view=auto
==============================================================================
--- incubator/jdo/trunk/fostore20/test/java/org/apache/jdo/test/Test_JDOModel.java (added)
+++ incubator/jdo/trunk/fostore20/test/java/org/apache/jdo/test/Test_JDOModel.java Sun May 22 11:40:13 2005
@@ -0,0 +1,460 @@
+/*
+ * 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.test;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.security.AccessController;
+import java.security.PrivilegedAction;
+import java.util.Arrays;
+
+import javax.jdo.JDOFatalInternalException;
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+
+import org.apache.jdo.impl.model.java.runtime.RuntimeJavaModelFactory;
+import org.apache.jdo.impl.model.jdo.util.PrintSupport;
+import org.apache.jdo.model.java.JavaModel;
+import org.apache.jdo.model.jdo.JDOClass;
+import org.apache.jdo.model.jdo.JDOField;
+import org.apache.jdo.model.jdo.JDOIdentityType;
+import org.apache.jdo.model.jdo.JDOModel;
+import org.apache.jdo.model.jdo.NullValueTreatment;
+import org.apache.jdo.model.jdo.PersistenceModifier;
+import org.apache.jdo.pc.PCArrays;
+import org.apache.jdo.pc.appid.PCRect;
+import org.apache.jdo.pc.empdept.PCFullTimeEmployee;
+import org.apache.jdo.pc.serializable.PCSub3;
+import org.apache.jdo.pc.xempdept.Employee;
+import org.apache.jdo.test.util.AbstractTest;
+import org.apache.jdo.test.util.JDORITestRunner;
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+import org.w3c.dom.Node;
+import org.w3c.dom.NodeList;
+import org.xml.sax.EntityResolver;
+import org.xml.sax.InputSource;
+import org.xml.sax.SAXException;
+
+/**
+ * This is a very simple test of the JDOModel.
+ * 
+ * @author Dave Bristor
+ */
+public class Test_JDOModel extends AbstractTest {
+    
+    /** RuntimeJavaModelFactory. */
+    private RuntimeJavaModelFactory javaModelFactory;
+    private JDOModel jdoModel;
+    
+    /** */
+    public static void main(String args[]) {
+        JDORITestRunner.run(Test_JDOModel.class);
+    }
+
+    /** */
+    protected void setUp() {
+        javaModelFactory = (RuntimeJavaModelFactory) AccessController.doPrivileged(
+            new PrivilegedAction () {
+                public Object run () {
+                    return RuntimeJavaModelFactory.getInstance();
+                }});
+        JavaModel javaModel =
+            javaModelFactory.getJavaModel(this.getClass().getClassLoader());
+        jdoModel = javaModel.getJDOModel();
+    }
+    
+    /** */
+    protected void tearDown() { }
+
+    /** */
+    public void testXML() throws Exception {
+        DocumentBuilderFactory domParserFactory = DocumentBuilderFactory.newInstance();
+        DocumentBuilder domParser = domParserFactory.newDocumentBuilder();
+        domParser.setEntityResolver(new JDOEntityResolver());
+
+        // package.jdo in org.apache.jdo.pc
+        handleJDOFile(getResourceAsStream(PCArrays.class, "package.jdo"), domParser);
+        // package.jdo in org.apache.jdo.pc.empdept
+        handleJDOFile(getResourceAsStream(PCFullTimeEmployee.class, "package.jdo"), domParser);
+        // package.jdo in org.apache.jdo.pc.serializable
+        handleJDOFile(getResourceAsStream(PCSub3.class, "package.jdo"), domParser);
+        // package.jdo in org.apache.jdo.pc.appid
+        handleJDOFile(getResourceAsStream(PCRect.class, "package.jdo"), domParser);
+        // Employee.jdo in org.apache.jdo.pc.xempdept
+        handleJDOFile(getResourceAsStream(Employee.class, "Employee.jdo"), domParser);
+    }
+
+    /** 
+     * Tests the JDOModel properties of selected pc classes to make sure
+     * that the default calulation of the JDOModel is correct.
+     */
+    public void testDefaults() {
+        verifyPCFullTimeEmployee();
+        verifyPCSub3();
+    }
+
+    /** */
+    protected void handleJDOFile(InputStream is, DocumentBuilder domParser)
+        throws Exception {
+        Document dom = domParser.parse(is);
+        String packageName = getPackageName(dom);
+        handleClassElements(dom.getElementsByTagName("class"), packageName);
+    }
+
+    /** */
+    protected String getPackageName(Document dom) {
+        NodeList packageElements = dom.getElementsByTagName("package");
+        int length = packageElements.getLength();
+        if (length != 1)
+            fail("Multiple package nodes");
+        Node packageElement = packageElements.item(0);
+        String packageName =
+            packageElement.getAttributes().getNamedItem("name").getNodeValue();
+        if (debug) logger.debug("packageName: " + packageName);
+        return packageName;
+    }
+
+    /** */
+    protected void handleClassElements(NodeList classElements,
+                                       String packageName) {
+        for (int i = 0; i < classElements.getLength(); i++) {
+            handleClassElement((Element)classElements.item(i), packageName);
+        }
+    }
+    
+    /** */
+    protected void handleClassElement(Element classElement, String packageName) {
+        String fullClassName = packageName + '.' + classElement.getAttribute("name");
+        if (debug) logger.debug("class: " + fullClassName);
+        JDOClass jdoClass = jdoModel.getJDOClass(fullClassName);
+        assertNotNull("No JDOClass instance for class " + fullClassName, jdoClass);
+
+        // handle identity type attribute
+        if (classElement.hasAttribute("identity-type")) {
+            String identityType = classElement.getAttribute("identity-type");
+            if (debug) logger.debug("  identity-type: " + identityType);
+            assertEquals("Wrong identity-type of class " + fullClassName, 
+                         identityType, 
+                         JDOIdentityType.toString(jdoClass.getIdentityType()));
+        }
+
+        // handle objectid-class attribute
+        if (classElement.hasAttribute("objectid-class")) {
+            String objectIdClass = classElement.getAttribute("objectid-class");
+            if (debug) logger.debug("  objectid-class: " + objectIdClass);
+            assertEquals("Wrong objectid-class of class " + fullClassName, 
+                         objectIdClass, 
+                         jdoClass.getDeclaredObjectIdClassName());
+        }
+
+        // handle requires-extent attribute
+        if (classElement.hasAttribute("requires-extent")) {
+            String requiresExtent = classElement.getAttribute("requires-extent");
+            if (debug) logger.debug("  requires-extent: " + requiresExtent);
+            assertEquals("Wrong requires-extent of class " + fullClassName, 
+                         Boolean.valueOf(requiresExtent).booleanValue(), 
+                         jdoClass.requiresExtent());
+        }
+
+        // handle persistence-capable-superclass attribute
+        if (classElement.hasAttribute("persistence-capable-superclass")) {
+            String pcSuperClass =
+                classElement.getAttribute("persistence-capable-superclass");
+            if (debug)
+                logger.debug("  persistence-capable-superclass: " + pcSuperClass);
+            // Note, this code assumes the persistence-capable-superclass
+            // attribute is either a fully qualified class name or a class
+            // in the same package as the pc class!
+            assertEquals("Wrong persistence-capable-superclass of class " +
+                         fullClassName, 
+                         getQualifiedClassName(pcSuperClass, packageName), 
+                         jdoClass.getPersistenceCapableSuperclassName());
+        }
+            
+        // handle field subelements
+        handleFieldElements(classElement.getElementsByTagName("field"), jdoClass);
+    }
+
+    /** */
+    protected void handleFieldElements(NodeList fields, JDOClass jdoClass) {
+        for (int i = 0; i < fields.getLength(); i++) {
+            handleFieldElement((Element)fields.item(i), jdoClass);
+        }
+    }
+    
+    /** */
+    protected void handleFieldElement(Element fieldElement, JDOClass jdoClass) {
+        String fieldName = fieldElement.getAttribute("name");
+        String className = jdoClass.getName();
+        if (debug) logger.debug("  field: " + fieldName);
+        JDOField jdoField = jdoClass.getField(fieldName);
+        assertNotNull("No JDOField instance for field " + fieldName +
+                      " of class " + className, jdoField);
+
+        // handle persistence-modifier attribute
+        if (fieldElement.hasAttribute("persistence-modifier")) {
+            String persistenceModifier =
+                fieldElement.getAttribute("persistence-modifier");
+            if (debug)
+                logger.debug("    persistence-modifier: " + persistenceModifier);
+            assertEquals("Wrong persistence-modifier of field " + fieldName +
+                         " of class " + className, 
+                         persistenceModifier, 
+                         PersistenceModifier.toString(jdoField.getPersistenceModifier()));
+        }
+        
+        // handle primary-key attribute
+        if (fieldElement.hasAttribute("primary-key")) {
+            String primaryKey = fieldElement.getAttribute("primary-key");
+            if (debug) logger.debug("    primary-key: " + primaryKey);
+            assertEquals("Wrong primary-key of field " + fieldName + " of class " + className, 
+                         Boolean.valueOf(primaryKey).booleanValue(), 
+                         jdoField.isPrimaryKey());
+        }
+
+        // handle null-value attribute 
+        if (fieldElement.hasAttribute("null-value")) {
+            String nullValue = fieldElement.getAttribute("null-value");
+            if (debug) logger.debug("    null-value: " + nullValue);
+            assertEquals("Wrong null-value of field " + fieldName +
+                         " of class " + className, 
+                         nullValue, 
+                         NullValueTreatment.toString(jdoField.getNullValueTreatment()));
+        }
+
+        // handle default-fetch-group attribute 
+        if (fieldElement.hasAttribute("default-fetch-group")) {
+            String dfg = fieldElement.getAttribute("default-fetch-group");
+            if (debug) logger.debug("    default-fetch-group: " + dfg);
+            assertEquals("Wrong default-fetch-group of field " + fieldName +
+                         " of class " + className, 
+                         Boolean.valueOf(dfg).booleanValue(), 
+                         jdoField.isDefaultFetchGroup());
+        }
+
+        // handle embedded attribute 
+        if (fieldElement.hasAttribute("embedded")) {
+            String embedded = fieldElement.getAttribute("embedded");
+            if (debug) logger.debug("    embedded: " + embedded);
+            assertEquals("Wrong embedded of field " + fieldName +
+                         " of class " + className, 
+                         Boolean.valueOf(embedded).booleanValue(), 
+                         jdoField.isEmbedded());
+        }
+        
+    }
+
+    /** 
+     * Verify metadata for org.apache.jdo.pc.empdept.PCFullTimeEmployee.
+     */ 
+    protected void verifyPCFullTimeEmployee() {
+        Class clazz = PCFullTimeEmployee.class;
+        String className = clazz.getName();
+        JDOClass jdoClass = javaModelFactory.getJavaType(clazz).getJDOClass();
+        assertNotNull("No JDOClass instance for class " + className, jdoClass);
+        assertEquals("Wrong identity type of class " + className, 
+                     JDOIdentityType.DATASTORE, 
+                     jdoClass.getIdentityType());
+        assertEquals("Wrong pc super class of class " + className, 
+                     "org.apache.jdo.pc.empdept.PCEmployee", 
+                     jdoClass.getPersistenceCapableSuperclassName());
+        assertEquals("Wrong number of declared managed fields of class " + className, 
+                     1, 
+                     jdoClass.getDeclaredManagedFieldCount());
+        assertEquals("Wrong number of inherited managed fields of class " + className, 
+                     10, 
+                     jdoClass.getInheritedManagedFieldCount());
+        assertEquals("Wrong list of managed fields of class " + className, 
+                     "[birthdate, firstname, lastname, department, empid, employees, hiredate, insurance, manager, projects, salary]",
+                     Arrays.asList(jdoClass.getManagedFields()).toString());
+        assertEquals("Wrong list of default fetch group fields of class " + className, 
+                     "[birthdate, firstname, lastname, empid, hiredate, salary]",
+                     Arrays.asList(jdoClass.getDefaultFetchGroupFields()).toString());
+        assertEquals("Wrong list of  managedFieldNumbers of class " + className, 
+                     "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]",
+                     PrintSupport.asList(jdoClass.getManagedFieldNumbers()).toString());
+        assertEquals("Wrong list of  persistentFieldNumbers of class " + className, 
+                     "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]",
+                     PrintSupport.asList(jdoClass.getPersistentFieldNumbers()).toString());
+        assertEquals("Wrong list of primaryKeyFieldNumbers of class " + className, 
+                     "[]",
+                     PrintSupport.asList(jdoClass.getPrimaryKeyFieldNumbers()).toString());
+        assertEquals("Wrong list of persistentNonPKFieldNs of class " + className, 
+                     "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]",
+                     PrintSupport.asList(jdoClass.getPersistentNonPrimaryKeyFieldNumbers()).toString());
+        assertEquals("Wrong list of persistentRelshipFieldNumbers of class " + className, 
+                     "[3, 5, 7, 8, 9]",
+                     PrintSupport.asList(jdoClass.getPersistentRelationshipFieldNumbers()).toString());
+        assertEquals("Wrong list of persistentSerializableFieldNumbers of class " + className, 
+                     "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]",
+                     PrintSupport.asList(jdoClass.getPersistentSerializableFieldNumbers()).toString());
+
+        JDOField[] jdoFields = jdoClass.getDeclaredFields();
+        assertEquals("Wrong number of declared fields of class" + className,
+                     1,
+                     jdoFields.length);
+        JDOField jdoField = jdoFields[0];
+        String fieldName = jdoField.getName();
+        assertEquals("Wrong name of field of class " + className,
+                     "salary",
+                     fieldName);
+        assertEquals("Wrong type of field " + fieldName + " of class " + className,
+                     "double",
+                     jdoField.getType().toString());
+        assertEquals("Wrong field number of field " + fieldName + " of class " + className,
+                     10,
+                     jdoField.getFieldNumber());
+    }
+    
+    
+    /** 
+     * Verify metadata for org.apache.jdo.pc.serializable.PCSub3. 
+     * It explicitly defines the dfg attribute.
+     */
+    protected void verifyPCSub3() {
+        Class clazz = PCSub3.class;
+        String className = clazz.getName();
+        JDOClass jdoClass = javaModelFactory.getJavaType(clazz).getJDOClass();
+        assertNotNull("No JDOClass instance for class " + className, jdoClass);
+        assertEquals("Wrong identity type of class " + className, 
+                     JDOIdentityType.DATASTORE, 
+                     jdoClass.getIdentityType());
+        assertEquals("Wrong pc super class of class " + className, 
+                     "org.apache.jdo.pc.serializable.PCSuper", 
+                     jdoClass.getPersistenceCapableSuperclassName());
+        assertEquals("Wrong number of declared managed fields of class " + className, 
+                     2, 
+                     jdoClass.getDeclaredManagedFieldCount());
+        assertEquals("Wrong number of inherited managed fields of class " + className, 
+                     2, 
+                     jdoClass.getInheritedManagedFieldCount());
+        assertEquals("Wrong list of managed fields of class " + className, 
+                     "[s01, t02, s03, t04]",
+                     Arrays.asList(jdoClass.getManagedFields()).toString());
+        assertEquals("Wrong list of  managedFieldNumbers of class " + className, 
+                     "[0, 1, 2, 3]",
+                     PrintSupport.asList(jdoClass.getManagedFieldNumbers()).toString());
+        assertEquals("Wrong list of  persistentFieldNumbers of class " + className, 
+                     "[0, 1, 2, 3]",
+                     PrintSupport.asList(jdoClass.getPersistentFieldNumbers()).toString());
+        assertEquals("Wrong list of primaryKeyFieldNumbers of class " + className, 
+                     "[]",
+                     PrintSupport.asList(jdoClass.getPrimaryKeyFieldNumbers()).toString());
+        assertEquals("Wrong list of persistentNonPKFieldNs of class " + className, 
+                     "[0, 1, 2, 3]",
+                     PrintSupport.asList(jdoClass.getPersistentNonPrimaryKeyFieldNumbers()).toString());
+        assertEquals("Wrong list of persistentRelshipFieldNumbers of class " + className, 
+                     "[]",
+                     PrintSupport.asList(jdoClass.getPersistentRelationshipFieldNumbers()).toString());
+        assertEquals("Wrong list of persistentSerializableFieldNumbers of class " + className, 
+                     "[0, 2]",
+                     PrintSupport.asList(jdoClass.getPersistentSerializableFieldNumbers()).toString());
+
+        JDOField[] jdoFields = jdoClass.getDeclaredFields();
+        assertEquals("Wrong number of declared fields of class" + className,
+                     2,
+                     jdoFields.length);
+
+        JDOField jdoField;
+        String fieldName;
+
+        jdoField = jdoFields[0];
+        fieldName = jdoField.getName();
+        assertEquals("Wrong name of field of class " + className,
+                     "s03",
+                     fieldName);
+        assertEquals("Wrong type of field " + fieldName + " of class " + className,
+                     "java.lang.String",
+                     jdoField.getType().toString());
+        assertEquals("Wrong field number of field " + fieldName + " of class " +
+                     className,
+                     2,
+                     jdoField.getFieldNumber());
+        
+        jdoField = jdoFields[1];
+        fieldName = jdoField.getName();
+        assertEquals("Wrong name of field of class " + className,
+                     "t04",
+                     fieldName);
+        assertEquals("Wrong type of field " + fieldName + " of class " + className,
+                     "java.lang.String",
+                     jdoField.getType().toString());
+        assertEquals("Wrong field number of field " + fieldName + " of class " + className,
+                     3,
+                     jdoField.getFieldNumber());
+    }
+
+    /** */
+    protected String getQualifiedClassName(String className, String packageName) {
+        if (className.indexOf('.') == -1) {
+            // not qualified
+            return packageName + '.' + className;
+        }
+        return className;
+    }
+
+    /** */
+    protected InputStream getResourceAsStream(final Class clazz,
+                                              final String resourceName) {
+        return (InputStream)AccessController.doPrivileged(
+            new PrivilegedAction () {
+                public Object run () {
+                    return clazz.getResourceAsStream(resourceName);
+                }});
+    }
+    
+    /**
+     * Implementation of EntityResolver interface to check the jdo.dtd location
+     **/
+    private static class JDOEntityResolver 
+        implements EntityResolver 
+    {
+        private static final String RECOGNIZED_PUBLIC_ID = 
+            "-//Sun Microsystems, Inc.//DTD Java Data Objects Metadata 1.0//EN";
+        private static final String RECOGNIZED_SYSTEM_ID = 
+            "file:/javax/jdo/jdo.dtd";
+
+        public InputSource resolveEntity(String publicId, String systemId)
+            throws SAXException, IOException 
+        {
+            // check for recognized ids
+            if (((publicId != null) && RECOGNIZED_PUBLIC_ID.equals(publicId)) ||
+                ((publicId == null) && (systemId != null) && 
+                 RECOGNIZED_SYSTEM_ID.equals(systemId))) {
+                // Substitute the dtd with the one from javax.jdo.jdo.dtd,
+                // but only if the publicId is equal to RECOGNIZED_PUBLIC_ID
+                // or there is no publicID and the systemID is equal to
+                // RECOGNIZED_SYSTEM_ID. 
+                InputStream stream = (InputStream) AccessController.doPrivileged (
+                    new PrivilegedAction () {
+                        public Object run () {
+                            return getClass().getClassLoader().
+                                getResourceAsStream("javax/jdo/jdo.dtd"); //NOI18N
+                        }});
+                if (stream == null) {
+                    throw new JDOFatalInternalException(
+                        "Cannot load javax/jdo/jdo.dtd, because the file does not exist in the jdo.jar file, or the test case class is not granted permission to read this file.  The metadata .xml file contained PUBLIC=" + publicId + " SYSTEM=" + systemId + ".");
+                }
+                return new InputSource(new InputStreamReader(stream));
+            }
+            return null;
+        }
+    }
+}
+

Added: incubator/jdo/trunk/fostore20/test/java/org/apache/jdo/test/Test_KeyFieldNull.java
URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/fostore20/test/java/org/apache/jdo/test/Test_KeyFieldNull.java?rev=171355&view=auto
==============================================================================
--- incubator/jdo/trunk/fostore20/test/java/org/apache/jdo/test/Test_KeyFieldNull.java (added)
+++ incubator/jdo/trunk/fostore20/test/java/org/apache/jdo/test/Test_KeyFieldNull.java Sun May 22 11:40:13 2005
@@ -0,0 +1,109 @@
+/*
+ * 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.test;
+
+
+import javax.jdo.JDOUserException;
+import javax.jdo.PersistenceManager;
+import javax.jdo.Transaction;
+
+import org.apache.jdo.pc.appid.PCObjectKey;
+import org.apache.jdo.test.util.AbstractTest;
+import org.apache.jdo.test.util.JDORITestRunner;
+
+/**
+* Test makePersistent with an instance with null key fields throws an exception.
+*
+* @author Craig Russell
+*/
+public class Test_KeyFieldNull extends AbstractTest {
+    
+    /** */
+    public static void main(String args[]) {
+        JDORITestRunner.run(Test_KeyFieldNull.class);
+    }
+
+    /** Create an instance with a null key field and verify that the proper
+     * exception is thrown.
+     */
+    public void test1() {
+        PersistenceManager pm = pmf.getPersistenceManager();
+        Transaction tx = pm.currentTransaction();
+        try {
+            tx.begin();
+            PCObjectKey obj = new PCObjectKey();
+            try {
+                pm.makePersistent(obj);
+                fail("Test failed. Expected JDOUserException on makePersistent with key field null");
+            } catch (JDOUserException ex) {
+                if (debug) logger.debug("caught expected " + ex);
+            }
+        }
+        finally {
+            if (tx != null && tx.isActive())
+                tx.rollback();
+            if (pm != null && !pm.isClosed())
+                pm.close();
+        }
+    }
+    
+    /** Create an instance with a null key field and verify that the proper
+     * exception is thrown for makePersistentAll.
+     */
+    public void test2() {
+        PersistenceManager pm = pmf.getPersistenceManager();
+        Transaction tx = pm.currentTransaction();
+        try {
+            tx.begin();
+            PCObjectKey obj = new PCObjectKey();
+            try {
+                pm.makePersistentAll(new Object[] {obj});
+                fail("Test failed. Expected JDOUserException on makePersistent with key field null");
+            } catch (JDOUserException ex) {
+                if (debug) logger.debug("caught expected " + ex);
+            }
+        }
+        finally {
+            if (tx != null && tx.isActive())
+                tx.rollback();
+            if (pm != null && !pm.isClosed())
+                pm.close();
+        }
+    }
+    
+    /** GetObjectById with an object id with a key field null and verify that the
+     * proper exception is thrown.
+     */
+    public void test3() {
+        PersistenceManager pm = pmf.getPersistenceManager();
+        try {
+            PCObjectKey pcobj = new PCObjectKey();
+            PCObjectKey.Oid key = new PCObjectKey.Oid();
+            try {
+                Object obj = pm.getObjectById(key, false);
+                fail("Test failed. Expected JDOUserException on getObjectById with key field null");
+            } catch (JDOUserException ex) {
+                if (debug) logger.debug("caught expected " + ex);
+            }
+        }
+        finally {
+            if (pm != null && !pm.isClosed())
+                pm.close();
+        }
+    }    
+
+}

Added: incubator/jdo/trunk/fostore20/test/java/org/apache/jdo/test/Test_LargeObj.java
URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/fostore20/test/java/org/apache/jdo/test/Test_LargeObj.java?rev=171355&view=auto
==============================================================================
--- incubator/jdo/trunk/fostore20/test/java/org/apache/jdo/test/Test_LargeObj.java (added)
+++ incubator/jdo/trunk/fostore20/test/java/org/apache/jdo/test/Test_LargeObj.java Sun May 22 11:40:13 2005
@@ -0,0 +1,54 @@
+/*
+ * 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.test;
+
+import org.apache.jdo.pc.LargeObjFactory;
+import org.apache.jdo.test.util.Factory;
+import org.apache.jdo.test.util.JDORITestRunner;
+
+/**
+* Tests that we can insert a large object.  Size is optionally given as
+* system property; default is 100,000 integers in an array.
+* To test that we can fetch the object(s), use Test_FetchExisting.
+*
+* @author Dave Bristor
+*/
+public class Test_LargeObj extends Test_Insert {
+
+    /** */
+    private static int size = Integer.getInteger("size", 100000).intValue();
+    
+    /** */
+    public static void main(String args[]) {
+        JDORITestRunner.run(Test_LargeObj.class);
+    }
+
+    /** */
+    public void test() throws Exception
+    {
+        if (debug) logger.debug("Test_LargeObj size: " + size);
+        insertObjects();
+        checkExtent(factory.getPCClass(), numInsert);
+        writeOIDs();
+    }
+
+    /** */
+    protected Factory getFactory(int verify) {
+        return new LargeObjFactory(size);
+    }
+    
+}

Added: incubator/jdo/trunk/fostore20/test/java/org/apache/jdo/test/Test_LifeCycle.java
URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/fostore20/test/java/org/apache/jdo/test/Test_LifeCycle.java?rev=171355&view=auto
==============================================================================
--- incubator/jdo/trunk/fostore20/test/java/org/apache/jdo/test/Test_LifeCycle.java (added)
+++ incubator/jdo/trunk/fostore20/test/java/org/apache/jdo/test/Test_LifeCycle.java Sun May 22 11:40:13 2005
@@ -0,0 +1,854 @@
+/*
+ * 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.
+ */
+
+/*
+ * Test_LifeCycle.java
+ *
+ * Created on July 19, 2001, 3:42 PM
+ */
+
+package org.apache.jdo.test;
+
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.Iterator;
+
+import javax.jdo.JDODataStoreException;
+import javax.jdo.JDOException;
+import javax.jdo.JDOFatalUserException;
+import javax.jdo.JDOHelper;
+import javax.jdo.JDOUserException;
+import javax.jdo.PersistenceManager;
+
+import org.apache.jdo.pc.empdept.PCPerson;
+import org.apache.jdo.test.util.AbstractTest;
+import org.apache.jdo.test.util.JDORITestRunner;
+
+/**
+ * Tests LifeCycle state transitions for datastore transactions with
+ * retainValues flag set to true.
+ *
+ * @author  clr
+ * @version
+ */
+public class Test_LifeCycle extends AbstractTest {
+
+    final static int BEGIN_TRANSACTION = 0;
+    final static int COMMIT_TRANSACTION = 1;
+    final static int ROLLBACK_TRANSACTION = 2;
+    final static int MAKE_PERSISTENT = 10;
+    final static int DELETE_PERSISTENT = 11;
+    final static int MAKE_TRANSIENT = 12;
+    final static int MAKE_TRANSACTIONAL = 13;
+    final static int MAKE_NONTRANSACTIONAL = 14;
+    final static int EVICT = 15;
+    final static int REFRESH = 16;
+    final static int READ_FIELD = 20;
+    final static int WRITE_FIELD = 21;
+    final static int GET_OBJECT_ID = 22;
+    final static int GET_OBJECT_BY_ID_WITH_VALIDATE = 23;
+    final static int GET_OBJECT_BY_ID_WOUT_VALIDATE = 24;
+    final static int MAKE_DIRTY = 25;
+    final static int CATCH_JDO_EXCEPTION = 30;
+    final static int CATCH_JDO_USER_EXCEPTION = 31;
+    final static int CATCH_JDO_DATASTORE_EXCEPTION = 32;
+    final static int CATCH_JDO_FATAL_USER_EXCEPTION = 33;
+    final static int CATCH_JDO_FATAL_INTERNAL_EXCEPTION = 34;
+    final static int ASSERT_TRANSIENT = 100;
+    final static int ASSERT_TRANSIENT_CLEAN = 101;
+    final static int ASSERT_TRANSIENT_DIRTY = 102;
+    final static int ASSERT_PERSISTENT_NEW = 103;
+    final static int ASSERT_PERSISTENT_CLEAN = 104;
+    final static int ASSERT_PERSISTENT_NONTRANSACTIONAL = 105;
+    final static int ASSERT_PERSISTENT_DIRTY = 106;
+    final static int ASSERT_PERSISTENT_NEW_DELETED = 107;
+    final static int ASSERT_PERSISTENT_DELETED = 108;
+    final static int ASSERT_HOLLOW = 109;
+    final static int CREATE_TRANSIENT = 200;
+
+    ArrayList cases = new ArrayList();
+
+    static PCPerson instance = null;
+    static Object oid = null;
+    static Date date = new Date();
+
+    static String testCaseName;
+    static PersistenceManager persistenceManager;
+    static Throwable thrown;
+
+    static boolean verbose = Boolean.getBoolean("verbose");
+
+    /** Creates new Test_LifeCycle */
+    public Test_LifeCycle() {
+        int i = 0;
+        cases.add (new Case (i++, "Transient: makeTransient, read, write", new int[] { // 0
+            CREATE_TRANSIENT, ASSERT_TRANSIENT
+            ,GET_OBJECT_ID, ASSERT_TRANSIENT //
+            ,MAKE_TRANSIENT, ASSERT_TRANSIENT // A5.9-5
+            ,READ_FIELD, ASSERT_TRANSIENT // A5.9-13
+            ,WRITE_FIELD, ASSERT_TRANSIENT // A5.9-16
+            ,MAKE_DIRTY, ASSERT_TRANSIENT // A5.9-16
+            ,DELETE_PERSISTENT, CATCH_JDO_USER_EXCEPTION // A5.9-2
+            ,MAKE_NONTRANSACTIONAL, CATCH_JDO_USER_EXCEPTION // A5.9-4
+            ,EVICT, ASSERT_TRANSIENT // A5.9-12
+            ,REFRESH, ASSERT_TRANSIENT // A5.9-10
+            }));
+        cases.add (new Case (i++, "Transient: read, write, commit, rollback", new int[] { // 1
+            CREATE_TRANSIENT, ASSERT_TRANSIENT
+            ,BEGIN_TRANSACTION, ASSERT_TRANSIENT
+            ,READ_FIELD, ASSERT_TRANSIENT // A5.9-15
+            ,WRITE_FIELD, ASSERT_TRANSIENT // A5.9-17
+            ,COMMIT_TRANSACTION, ASSERT_TRANSIENT // A5.9-6
+            ,BEGIN_TRANSACTION, ASSERT_TRANSIENT
+            ,ROLLBACK_TRANSACTION, ASSERT_TRANSIENT // A5.9-8
+            }));
+        cases.add (new Case (i++, "Transient: makeTransactional, read, commit, rollback", new int[] { // 2
+            CREATE_TRANSIENT, ASSERT_TRANSIENT
+            ,BEGIN_TRANSACTION, ASSERT_TRANSIENT
+            ,MAKE_TRANSACTIONAL, ASSERT_TRANSIENT_CLEAN
+            ,MAKE_TRANSACTIONAL, ASSERT_TRANSIENT_CLEAN // A5.9-88
+            ,READ_FIELD, ASSERT_TRANSIENT_CLEAN // A5.9-100
+            ,MAKE_TRANSIENT, ASSERT_TRANSIENT_CLEAN // A5.9-90
+            ,DELETE_PERSISTENT, CATCH_JDO_USER_EXCEPTION // A5.9-87
+            ,EVICT, ASSERT_TRANSIENT_CLEAN // A5.9-97
+            ,REFRESH, ASSERT_TRANSIENT_CLEAN // A5.9-95
+            ,COMMIT_TRANSACTION, ASSERT_TRANSIENT_CLEAN // A5.9-92
+            ,EVICT, ASSERT_TRANSIENT_CLEAN // A5.9-97
+            ,REFRESH, ASSERT_TRANSIENT_CLEAN // A5.9-95
+            ,READ_FIELD, ASSERT_TRANSIENT_CLEAN // A5.9-98
+            ,WRITE_FIELD, ASSERT_TRANSIENT_CLEAN // A5.9-101
+            ,MAKE_DIRTY, ASSERT_TRANSIENT_CLEAN // A5.9-101
+            ,BEGIN_TRANSACTION, ASSERT_TRANSIENT_CLEAN
+            ,ROLLBACK_TRANSACTION, ASSERT_TRANSIENT_CLEAN // A5.9-94
+            }));
+        cases.add (new Case (i++, "TransientClean: read, write, makeTransactional, makeTransient, commit, rollback", new int[] { // 3
+            ASSERT_TRANSIENT_CLEAN
+            ,BEGIN_TRANSACTION, ASSERT_TRANSIENT_CLEAN
+            ,WRITE_FIELD, ASSERT_TRANSIENT_DIRTY // A5.9-102
+            ,READ_FIELD, ASSERT_TRANSIENT_DIRTY // A5.9-117
+            ,MAKE_DIRTY, ASSERT_TRANSIENT_DIRTY // A5.9-102
+            ,EVICT, ASSERT_TRANSIENT_DIRTY // A5.9-114
+            ,REFRESH, ASSERT_TRANSIENT_DIRTY // A5.9-112
+            ,MAKE_TRANSACTIONAL, ASSERT_TRANSIENT_DIRTY // A5.9-105
+            ,MAKE_NONTRANSACTIONAL, CATCH_JDO_USER_EXCEPTION // A5.9-106
+            ,MAKE_TRANSIENT, ASSERT_TRANSIENT_DIRTY // A5.9-107
+            ,DELETE_PERSISTENT, CATCH_JDO_USER_EXCEPTION // A5.9-104
+            ,COMMIT_TRANSACTION, ASSERT_TRANSIENT_CLEAN // A5.9-109
+            ,BEGIN_TRANSACTION, ASSERT_TRANSIENT_CLEAN
+            ,WRITE_FIELD, ASSERT_TRANSIENT_DIRTY // A5.9-119
+            ,ROLLBACK_TRANSACTION, ASSERT_TRANSIENT_CLEAN // A5.9-111
+            ,BEGIN_TRANSACTION, ASSERT_TRANSIENT_CLEAN
+            ,MAKE_DIRTY, ASSERT_TRANSIENT_DIRTY // A5.9-119
+            ,ROLLBACK_TRANSACTION, ASSERT_TRANSIENT_CLEAN // A5.9-111
+            }));
+        cases.add (new Case (i++, "TransientClean: makeTransactional, makeNonTransactional, commit, rollback", new int[] { // 4
+            ASSERT_TRANSIENT_CLEAN
+            ,BEGIN_TRANSACTION, ASSERT_TRANSIENT_CLEAN
+            ,MAKE_TRANSACTIONAL, ASSERT_TRANSIENT_CLEAN // A5.9-88
+            ,MAKE_NONTRANSACTIONAL, ASSERT_TRANSIENT // A5.9-89
+            ,COMMIT_TRANSACTION, ASSERT_TRANSIENT // A5.9-6
+            ,BEGIN_TRANSACTION, ASSERT_TRANSIENT
+            ,MAKE_TRANSACTIONAL, ASSERT_TRANSIENT_CLEAN
+            ,MAKE_NONTRANSACTIONAL, ASSERT_TRANSIENT // A5.9-89
+            ,ROLLBACK_TRANSACTION, ASSERT_TRANSIENT // A5.9-8
+            }));
+        cases.add (new Case (i++, "Transient: makeTransactional, makePersistent, rollback", new int[] { // 5
+            CREATE_TRANSIENT, ASSERT_TRANSIENT
+            ,BEGIN_TRANSACTION, ASSERT_TRANSIENT
+            ,MAKE_TRANSACTIONAL, ASSERT_TRANSIENT_CLEAN
+            ,MAKE_PERSISTENT, ASSERT_PERSISTENT_NEW // A5.9-86
+            ,EVICT, ASSERT_PERSISTENT_NEW // A5.9-29
+            ,REFRESH, ASSERT_PERSISTENT_NEW // A5.9-27
+            ,ROLLBACK_TRANSACTION, ASSERT_TRANSIENT // A5.9-8
+            }));
+        cases.add (new Case (i++, "Transient: makeTransactional, write, makePersistent, rollback", new int[] { // 6
+            CREATE_TRANSIENT, ASSERT_TRANSIENT
+            ,BEGIN_TRANSACTION, ASSERT_TRANSIENT
+            ,MAKE_TRANSACTIONAL, ASSERT_TRANSIENT_CLEAN
+            ,WRITE_FIELD, ASSERT_TRANSIENT_DIRTY // A5.9-102
+            ,MAKE_PERSISTENT, ASSERT_PERSISTENT_NEW // A5.9-103
+            ,ROLLBACK_TRANSACTION, ASSERT_TRANSIENT // A5.9-8
+            }));
+
+        cases.add (new Case (i++, "Transient: makePersistent, rollback", new int[] { // 7
+            CREATE_TRANSIENT, ASSERT_TRANSIENT
+            ,BEGIN_TRANSACTION , ASSERT_TRANSIENT
+            ,MAKE_PERSISTENT, ASSERT_PERSISTENT_NEW // A5.9-1
+            ,MAKE_PERSISTENT, ASSERT_PERSISTENT_NEW // A5.9-18
+            ,GET_OBJECT_ID, ASSERT_PERSISTENT_NEW // A5.9-18
+            ,MAKE_TRANSACTIONAL, ASSERT_PERSISTENT_NEW // A5.9-20
+            ,MAKE_NONTRANSACTIONAL, CATCH_JDO_USER_EXCEPTION // A5.9-21
+            ,MAKE_TRANSIENT, CATCH_JDO_USER_EXCEPTION // A5.9-22
+            ,READ_FIELD, ASSERT_PERSISTENT_NEW // A5.9-32
+            ,WRITE_FIELD, ASSERT_PERSISTENT_NEW // A5.9-34
+            ,MAKE_DIRTY, ASSERT_PERSISTENT_NEW // A5.9-34
+            ,ROLLBACK_TRANSACTION, ASSERT_TRANSIENT  // A5.9-25
+            }));
+        cases.add (new Case (i++, "Transient: makePersistent, delete, rollback", new int[] { // 8
+            CREATE_TRANSIENT, ASSERT_TRANSIENT
+            ,BEGIN_TRANSACTION, ASSERT_TRANSIENT
+            ,MAKE_PERSISTENT, ASSERT_PERSISTENT_NEW
+            ,DELETE_PERSISTENT, ASSERT_PERSISTENT_NEW_DELETED // A5.9-19
+            ,MAKE_PERSISTENT, ASSERT_PERSISTENT_NEW_DELETED // A5.9-120
+            ,DELETE_PERSISTENT, ASSERT_PERSISTENT_NEW_DELETED // A5.9-121
+            ,MAKE_TRANSACTIONAL, ASSERT_PERSISTENT_NEW_DELETED // A5.9-122
+            ,EVICT, ASSERT_PERSISTENT_NEW_DELETED // A5.9-131
+            ,REFRESH, ASSERT_PERSISTENT_NEW_DELETED // A5.9-129
+            ,MAKE_TRANSIENT, CATCH_JDO_USER_EXCEPTION // A5.9-124
+            ,MAKE_NONTRANSACTIONAL, CATCH_JDO_USER_EXCEPTION // A5.9-123
+            ,READ_FIELD, CATCH_JDO_USER_EXCEPTION // A5.9-134
+            ,WRITE_FIELD, CATCH_JDO_USER_EXCEPTION // A5.9-136
+            ,MAKE_DIRTY, CATCH_JDO_USER_EXCEPTION // A5.9-136
+            ,ROLLBACK_TRANSACTION, ASSERT_TRANSIENT // A5.9-127
+            }));
+        cases.add (new Case (i++, "Transient: makePersistent, delete, commit", new int[] { // 9
+            CREATE_TRANSIENT, ASSERT_TRANSIENT
+            ,BEGIN_TRANSACTION, ASSERT_TRANSIENT
+            ,MAKE_PERSISTENT, ASSERT_PERSISTENT_NEW
+            ,DELETE_PERSISTENT, ASSERT_PERSISTENT_NEW_DELETED // A5.9-19
+            ,COMMIT_TRANSACTION, ASSERT_TRANSIENT // A5.9-125
+            }));
+        cases.add (new Case (i++, "Transient: makePersistent, commit", new int[] { // 10
+            CREATE_TRANSIENT, ASSERT_TRANSIENT
+            ,BEGIN_TRANSACTION, ASSERT_TRANSIENT
+            ,MAKE_PERSISTENT, ASSERT_PERSISTENT_NEW
+            ,COMMIT_TRANSACTION, ASSERT_PERSISTENT_NONTRANSACTIONAL // A5.9-23
+            }));
+        cases.add (new Case (i++, "Nontransactional: makeNontransactional, read, write", new int[] { // 11
+            ASSERT_PERSISTENT_NONTRANSACTIONAL
+            ,MAKE_NONTRANSACTIONAL, ASSERT_PERSISTENT_NONTRANSACTIONAL // A5.9-157
+            ,READ_FIELD, ASSERT_PERSISTENT_NONTRANSACTIONAL // A5.9-166
+            ,WRITE_FIELD, ASSERT_PERSISTENT_NONTRANSACTIONAL // A5.9-169
+            ,MAKE_DIRTY, ASSERT_PERSISTENT_NONTRANSACTIONAL // A5.9-169
+            }));
+        cases.add (new Case (i++, "Nontransactional: makePersistent, makeTransactional", new int[] { // 12
+            ASSERT_PERSISTENT_NONTRANSACTIONAL
+            ,MAKE_PERSISTENT, CATCH_JDO_USER_EXCEPTION // A12.5.7-1
+            ,BEGIN_TRANSACTION, ASSERT_PERSISTENT_NONTRANSACTIONAL
+            ,MAKE_PERSISTENT, ASSERT_PERSISTENT_NONTRANSACTIONAL // A5.9-154
+            ,MAKE_TRANSACTIONAL, ASSERT_PERSISTENT_CLEAN // A5.9-156
+            ,COMMIT_TRANSACTION, ASSERT_PERSISTENT_NONTRANSACTIONAL
+            }));
+        cases.add (new Case (i++, "PersistentDirty: makePersistent, makeTransactional, commit", new int[] { // 13
+            ASSERT_PERSISTENT_NONTRANSACTIONAL
+            ,BEGIN_TRANSACTION, ASSERT_PERSISTENT_NONTRANSACTIONAL
+            ,WRITE_FIELD, ASSERT_PERSISTENT_DIRTY // A5.9-170
+            ,MAKE_DIRTY, ASSERT_PERSISTENT_DIRTY // A5.9-170
+            ,EVICT, ASSERT_PERSISTENT_DIRTY // A5.9-63
+            ,WRITE_FIELD, ASSERT_PERSISTENT_DIRTY // A5.9-68
+            ,READ_FIELD, ASSERT_PERSISTENT_DIRTY // A5.9-66
+            ,MAKE_TRANSACTIONAL, ASSERT_PERSISTENT_DIRTY // A5.9-54
+            ,MAKE_NONTRANSACTIONAL, CATCH_JDO_USER_EXCEPTION // A5.9-55
+            ,MAKE_TRANSIENT, CATCH_JDO_USER_EXCEPTION // A5.9-56
+            ,MAKE_PERSISTENT, ASSERT_PERSISTENT_DIRTY // A5.9-52
+            ,COMMIT_TRANSACTION, ASSERT_PERSISTENT_NONTRANSACTIONAL // A5.9-57
+            }));
+        cases.add (new Case (i++, "PersistentDirty: rollback", new int[] { // 14
+            ASSERT_PERSISTENT_NONTRANSACTIONAL
+            ,BEGIN_TRANSACTION, ASSERT_PERSISTENT_NONTRANSACTIONAL
+            ,READ_FIELD, ASSERT_PERSISTENT_CLEAN
+            ,MAKE_DIRTY, ASSERT_PERSISTENT_DIRTY // A5.9-51
+            ,ROLLBACK_TRANSACTION, ASSERT_PERSISTENT_NONTRANSACTIONAL // A5.9-59
+            }));
+        cases.add (new Case (i++, "PersistentDirty: commit", new int[] { // 15
+            ASSERT_PERSISTENT_NONTRANSACTIONAL
+            ,BEGIN_TRANSACTION, ASSERT_PERSISTENT_NONTRANSACTIONAL
+            ,READ_FIELD, ASSERT_PERSISTENT_CLEAN
+            ,MAKE_DIRTY, ASSERT_PERSISTENT_DIRTY // A5.9-51
+            ,COMMIT_TRANSACTION, ASSERT_PERSISTENT_NONTRANSACTIONAL // A5.9-57
+            }));
+        cases.add (new Case (i++, "PersistentDirty: refresh", new int[] { // 16
+            ASSERT_PERSISTENT_NONTRANSACTIONAL
+            ,BEGIN_TRANSACTION, ASSERT_PERSISTENT_NONTRANSACTIONAL
+            ,READ_FIELD, ASSERT_PERSISTENT_CLEAN
+            ,WRITE_FIELD, ASSERT_PERSISTENT_DIRTY // A5.9-51
+            ,REFRESH, ASSERT_PERSISTENT_CLEAN // A5.9-61
+            ,ROLLBACK_TRANSACTION, ASSERT_PERSISTENT_NONTRANSACTIONAL // A5.9-59
+            }));
+        cases.add (new Case (i++, "PersistentClean: makePersistent, makeTransactional", new int[] { // 17
+            ASSERT_PERSISTENT_NONTRANSACTIONAL
+            ,BEGIN_TRANSACTION, ASSERT_PERSISTENT_NONTRANSACTIONAL
+            ,READ_FIELD, ASSERT_PERSISTENT_CLEAN // A5.9-168
+            ,READ_FIELD, ASSERT_PERSISTENT_CLEAN // A5.9-49
+            ,MAKE_PERSISTENT, ASSERT_PERSISTENT_CLEAN // A5.9-35
+            ,MAKE_TRANSACTIONAL, ASSERT_PERSISTENT_CLEAN // A5.9-37
+            ,COMMIT_TRANSACTION, ASSERT_PERSISTENT_NONTRANSACTIONAL // A5.9-40
+            }));
+        cases.add (new Case (i++, "PersistentClean: makeNontransactional", new int[] { // 18
+            ASSERT_PERSISTENT_NONTRANSACTIONAL
+            ,BEGIN_TRANSACTION, ASSERT_PERSISTENT_NONTRANSACTIONAL
+            ,READ_FIELD, ASSERT_PERSISTENT_CLEAN
+            ,MAKE_NONTRANSACTIONAL, ASSERT_PERSISTENT_NONTRANSACTIONAL // A5.9-38
+            ,COMMIT_TRANSACTION, ASSERT_PERSISTENT_NONTRANSACTIONAL
+            }));
+        cases.add (new Case (i++, "PersistentDeleted: rollback", new int[] { // 19
+            ASSERT_PERSISTENT_NONTRANSACTIONAL
+            ,BEGIN_TRANSACTION, ASSERT_PERSISTENT_NONTRANSACTIONAL
+            ,READ_FIELD, ASSERT_PERSISTENT_CLEAN
+            ,DELETE_PERSISTENT, ASSERT_PERSISTENT_DELETED // A5.9-36
+            ,EVICT, ASSERT_PERSISTENT_DELETED // A5.9-148
+            ,REFRESH, ASSERT_PERSISTENT_DELETED // A5.9-146
+            ,READ_FIELD, CATCH_JDO_USER_EXCEPTION // A5.9-134
+            ,ROLLBACK_TRANSACTION ,ASSERT_PERSISTENT_NONTRANSACTIONAL // A5.9-145
+            }));
+        cases.add (new Case (i++, "PersistentDeleted: makePersistent, makeTransactional, commit", new int[] { // 20
+            ASSERT_PERSISTENT_NONTRANSACTIONAL
+            ,BEGIN_TRANSACTION, ASSERT_PERSISTENT_NONTRANSACTIONAL
+            ,GET_OBJECT_ID, ASSERT_PERSISTENT_NONTRANSACTIONAL
+            ,DELETE_PERSISTENT, ASSERT_PERSISTENT_DELETED // A5.9-155
+            ,MAKE_PERSISTENT, ASSERT_PERSISTENT_DELETED // A5.9-137
+            ,DELETE_PERSISTENT, ASSERT_PERSISTENT_DELETED // A5.9-138
+            ,MAKE_TRANSACTIONAL, ASSERT_PERSISTENT_DELETED // A5.9-139
+            ,MAKE_NONTRANSACTIONAL, CATCH_JDO_USER_EXCEPTION // A5.9-140
+            ,MAKE_TRANSIENT, CATCH_JDO_USER_EXCEPTION // A5.9-141
+            ,READ_FIELD, CATCH_JDO_USER_EXCEPTION // A5.9-151
+            ,WRITE_FIELD, CATCH_JDO_USER_EXCEPTION // A5.9-153
+            ,MAKE_DIRTY, CATCH_JDO_USER_EXCEPTION // A5.9-153
+            ,COMMIT_TRANSACTION, ASSERT_TRANSIENT // A5.9-142
+            }));
+        cases.add (new Case (i++, "Transient: getObjectById(false), getObjectById(true), makePersistent, commit", new int[] { // 21
+            CREATE_TRANSIENT, ASSERT_TRANSIENT
+            ,BEGIN_TRANSACTION, ASSERT_TRANSIENT
+            ,GET_OBJECT_BY_ID_WOUT_VALIDATE, ASSERT_PERSISTENT_NONTRANSACTIONAL
+            ,READ_FIELD, CATCH_JDO_DATASTORE_EXCEPTION
+            ,GET_OBJECT_BY_ID_WITH_VALIDATE, CATCH_JDO_DATASTORE_EXCEPTION
+            ,MAKE_PERSISTENT, ASSERT_PERSISTENT_NEW
+            ,GET_OBJECT_ID, ASSERT_PERSISTENT_NEW
+            ,COMMIT_TRANSACTION, ASSERT_PERSISTENT_NONTRANSACTIONAL // A5.9-23
+            }));
+        cases.add (new Case (i++, "Nontransactional: getObjectById(false), getObjectById(true)", new int[] { // 22
+            ASSERT_PERSISTENT_NONTRANSACTIONAL
+            ,BEGIN_TRANSACTION, ASSERT_PERSISTENT_NONTRANSACTIONAL
+            ,GET_OBJECT_BY_ID_WOUT_VALIDATE, ASSERT_PERSISTENT_NONTRANSACTIONAL
+            ,GET_OBJECT_BY_ID_WITH_VALIDATE, ASSERT_PERSISTENT_CLEAN
+            ,COMMIT_TRANSACTION, ASSERT_PERSISTENT_NONTRANSACTIONAL // A5.9-23
+            }));
+        cases.add (new Case (i++, "Nontransactional: makeTransient, commit, rollback", new int[] { // 23
+            ASSERT_PERSISTENT_NONTRANSACTIONAL
+            ,BEGIN_TRANSACTION, ASSERT_PERSISTENT_NONTRANSACTIONAL
+            ,MAKE_TRANSIENT, ASSERT_TRANSIENT // A5.9-158
+            ,COMMIT_TRANSACTION, ASSERT_TRANSIENT
+            ,BEGIN_TRANSACTION, ASSERT_TRANSIENT
+            ,MAKE_PERSISTENT, ASSERT_PERSISTENT_NEW
+            ,COMMIT_TRANSACTION, ASSERT_PERSISTENT_NONTRANSACTIONAL // A5.9-23
+            ,BEGIN_TRANSACTION, ASSERT_PERSISTENT_NONTRANSACTIONAL
+            ,MAKE_TRANSIENT, ASSERT_TRANSIENT // A5.9-158
+            ,ROLLBACK_TRANSACTION, ASSERT_TRANSIENT
+            ,BEGIN_TRANSACTION, ASSERT_TRANSIENT
+            ,MAKE_PERSISTENT, ASSERT_PERSISTENT_NEW
+            ,COMMIT_TRANSACTION, ASSERT_PERSISTENT_NONTRANSACTIONAL // A5.9-23
+            ,MAKE_TRANSIENT, ASSERT_TRANSIENT // A5.9-158
+            }));
+        cases.add (new Case (i++, "Nontransactional: evict", new int[] { // 24
+            CREATE_TRANSIENT, ASSERT_TRANSIENT
+            ,BEGIN_TRANSACTION, ASSERT_TRANSIENT
+            ,MAKE_PERSISTENT, ASSERT_PERSISTENT_NEW
+            ,COMMIT_TRANSACTION, ASSERT_PERSISTENT_NONTRANSACTIONAL // A5.9-23
+            ,REFRESH, ASSERT_PERSISTENT_NONTRANSACTIONAL // A5.9-163
+            ,EVICT, ASSERT_HOLLOW // A5.9-165
+            ,EVICT, ASSERT_HOLLOW // A5.9-80
+            ,REFRESH, ASSERT_HOLLOW // A5.9-78
+            ,READ_FIELD, ASSERT_PERSISTENT_NONTRANSACTIONAL
+            ,BEGIN_TRANSACTION, ASSERT_PERSISTENT_NONTRANSACTIONAL
+            ,EVICT, ASSERT_HOLLOW // A5.9-80
+            ,REFRESH, ASSERT_HOLLOW // A5.9-78
+            ,COMMIT_TRANSACTION, ASSERT_HOLLOW // A5.9-23
+            }));
+        cases.add (new Case (i++, "PersistentClean: evict", new int[] { // 25
+            ASSERT_HOLLOW
+            ,BEGIN_TRANSACTION, ASSERT_HOLLOW
+            ,READ_FIELD, ASSERT_PERSISTENT_CLEAN
+            ,REFRESH, ASSERT_PERSISTENT_CLEAN // A5.9-44
+            ,EVICT, ASSERT_HOLLOW // A5.9-46
+            ,COMMIT_TRANSACTION, ASSERT_HOLLOW // A5.9-23
+            }));
+        cases.add (new Case (i++, "Hollow: makeDirty", new int[] { // 26
+            ASSERT_HOLLOW
+            ,BEGIN_TRANSACTION, ASSERT_HOLLOW
+            ,MAKE_DIRTY, ASSERT_PERSISTENT_DIRTY // A5.9-85
+            ,COMMIT_TRANSACTION, ASSERT_PERSISTENT_NONTRANSACTIONAL // A5.9-23
+            ,BEGIN_TRANSACTION, ASSERT_PERSISTENT_NONTRANSACTIONAL
+            ,EVICT, ASSERT_HOLLOW // A5.9-80
+            ,COMMIT_TRANSACTION, ASSERT_HOLLOW // A5.9-23
+            ,MAKE_DIRTY, ASSERT_PERSISTENT_NONTRANSACTIONAL // A5.9-84
+            }));
+    }
+    
+    /** */
+    public static void main(String args[]) {
+        JDORITestRunner.run(Test_LifeCycle.class);
+    }
+
+    /** */
+    public void test() {
+        persistenceManager = pmf.getPersistenceManager();
+        for (Iterator i = cases.iterator(); i.hasNext();) {
+            Case testcase = (Case) i.next();
+            testcase.execute();
+        }
+    }
+
+    /**
+     * Initializes JDO startup properties with default values.
+     * Sub classes can overwrite this method in order to change those default
+     * values.
+     */
+    protected void initProperties()
+    {   super.initProperties();
+    //properties.setProperty( "javax.jdo.option.ConnectionUserName", "" );
+    //properties.setProperty( "javax.jdo.option.ConnectionPassword", "" );
+    //properties.setProperty( "javax.jdo.option.ConnectionURL", "fostore:test" );
+        properties.setProperty( "javax.jdo.option.NontransactionalWrite", "true" );
+        properties.setProperty( "javax.jdo.option.Optimistic", "false" );
+    }
+
+    /** */
+    static void resetThrown() {
+        thrown = null;
+    }
+
+    /** */
+    class Case {
+        int number;
+        String name;
+        int[] procedures;
+        Case (int number, String name, int[] procedures) {
+            this.number = number;
+            this.name = name;
+            this.procedures = procedures;
+        }
+        int execute () {
+            printFlush ("Test case " + number + ": " + name);
+            testCaseName = name;
+            for (int i = 0; i < procedures.length; ++i) {
+                try {
+                    switch (procedures[i]) {
+                        case BEGIN_TRANSACTION:
+                            resetThrown();
+                            Procedure.beginTransaction();
+                            break;
+                        case COMMIT_TRANSACTION:
+                            resetThrown();
+                            Procedure.commitTransaction();
+                            break;
+                        case ROLLBACK_TRANSACTION:
+                            resetThrown();
+                            Procedure.rollbackTransaction();
+                            break;
+                       case CREATE_TRANSIENT:
+                            resetThrown();
+                            Procedure.createTransient();
+                            break;
+                        case MAKE_PERSISTENT:
+                            resetThrown();
+                            Procedure.makePersistent();
+                            break;
+                        case DELETE_PERSISTENT:
+                            resetThrown();
+                            Procedure.deletePersistent();
+                            break;
+                        case MAKE_TRANSACTIONAL:
+                            resetThrown();
+                            Procedure.makeTransactional();
+                            break;
+                        case MAKE_TRANSIENT:
+                            resetThrown();
+                            Procedure.makeTransient();
+                            break;
+                        case MAKE_NONTRANSACTIONAL:
+                            resetThrown();
+                            Procedure.makeNontransactional();
+                            break;
+                        case EVICT:
+                            resetThrown();
+                            Procedure.evict();
+                            break;
+                        case REFRESH:
+                            resetThrown();
+                            Procedure.refresh();
+                            break;
+                        case ASSERT_PERSISTENT_NEW:
+                            Procedure.assertPersistentNew();
+                            break;
+                        case ASSERT_PERSISTENT_NEW_DELETED:
+                            Procedure.assertPersistentNewDeleted();
+                            break;
+                        case ASSERT_TRANSIENT:
+                            Procedure.assertTransient();
+                            break;
+                        case ASSERT_TRANSIENT_CLEAN:
+                            Procedure.assertTransientClean();
+                            break;
+                        case ASSERT_TRANSIENT_DIRTY:
+                            Procedure.assertTransientDirty();
+                            break;
+                        case ASSERT_PERSISTENT_CLEAN:
+                            Procedure.assertPersistentClean();
+                            break;
+                        case ASSERT_PERSISTENT_DIRTY:
+                            Procedure.assertPersistentDirty();
+                            break;
+                        case ASSERT_PERSISTENT_NONTRANSACTIONAL:
+                            Procedure.assertPersistentNontransactional();
+                            break;
+                        case ASSERT_HOLLOW:
+                            Procedure.assertHollow();
+                            break;
+                        case ASSERT_PERSISTENT_DELETED:
+                            Procedure.assertPersistentDeleted();
+                            break;
+                        case READ_FIELD:
+                            resetThrown();
+                            Procedure.readField();
+                            break;
+                        case WRITE_FIELD:
+                            resetThrown();
+                            Procedure.writeField();
+                            break;
+                        case GET_OBJECT_ID:
+                            resetThrown();
+                            Procedure.getObjectId();
+                            break;
+                        case GET_OBJECT_BY_ID_WITH_VALIDATE:
+                            resetThrown();
+                            Procedure.getObjectById(true);
+                            break;
+                        case GET_OBJECT_BY_ID_WOUT_VALIDATE:
+                            resetThrown();
+                            Procedure.getObjectById(false);
+                            break;
+                        case MAKE_DIRTY:
+                            resetThrown();
+                            Procedure.makeDirty();
+                            break;
+                        case CATCH_JDO_EXCEPTION:
+                            Procedure.catchJDOException();
+                            resetThrown();
+                            break;
+                        case CATCH_JDO_USER_EXCEPTION:
+                            Procedure.catchJDOUserException();
+                            resetThrown();
+                            break;
+                        case CATCH_JDO_FATAL_USER_EXCEPTION:
+                            Procedure.catchJDOFatalUserException();
+                            resetThrown();
+                            break;
+                        case CATCH_JDO_DATASTORE_EXCEPTION:
+                            Procedure.catchJDODataStoreException();
+                            resetThrown();
+                            break;
+                        default:
+                            throw new JDOException ("Unknown Procedure " + procedures[i]);
+                    }
+                } catch (JDOException t) {
+                    thrown = t;
+                } catch (RuntimeException e) {
+                    e.printStackTrace();
+                    throw new JDOException ("Test failed", e);
+                }
+            }
+            return 0;
+        }
+    }
+
+    /** */
+    static class Procedure {
+        static void createTransient() {
+            printFlush ("createTransient");
+            instance = new PCPerson("First", "Last", date);
+        }
+        static void makePersistent() {
+            printFlush ("makePersistent");
+            persistenceManager.makePersistent(instance);
+        }
+        static void deletePersistent() {
+            printFlush ("deletePersistent");
+            persistenceManager.deletePersistent(instance);
+        }
+        static void makeTransient() {
+            printFlush ("makeTransient");
+            persistenceManager.makeTransient(instance);
+        }
+        static void makeTransactional() {
+            printFlush ("makeTransactional");
+            persistenceManager.makeTransactional(instance);
+        }
+        static void makeNontransactional() {
+            printFlush ("makeNontransactional");
+            persistenceManager.makeNontransactional(instance);
+        }
+        static void refresh() {
+            printFlush ("refresh");
+            persistenceManager.refresh(instance);
+        }
+        static void evict() {
+            printFlush ("evict");
+            persistenceManager.evict(instance);
+        }
+        static void getObjectId() {
+            printFlush ("getObjectId");
+            oid = persistenceManager.getObjectId(instance);
+        }
+        static void getObjectById(boolean validate) {
+            printFlush ("getObjectById_" + validate);
+            Object o = persistenceManager.getObjectById(oid, validate);
+            instance = (PCPerson)o;
+        }
+        static void assertPersistentNew() {
+            printFlush ("assertPersistentNew");
+            if (thrown != null)
+                throw new RuntimeException ("Caught exception: " + thrown);
+            if (!Assert.isPersistentNew(instance))
+                throw new RuntimeException ("Assertion PersistentNew failed" +
+                Assert.printLifeCycleState());
+        }
+        static void assertPersistentNewDeleted() {
+            printFlush ("assertPersistentNewDeleted");
+            if (thrown != null)
+                throw new RuntimeException ("Caught exception: " + thrown);
+            if (!Assert.isPersistentNewDeleted(instance))
+                throw new RuntimeException ("Assertion NewDeleted failed" +
+                Assert.printLifeCycleState());
+        }
+        static void assertTransient() {
+            printFlush ("assertTransient");
+            if (thrown != null)
+                throw new RuntimeException ("Caught exception: " + thrown);
+            if (!Assert.isTransient(instance))
+                throw new RuntimeException ("Assertion Transient failed" +
+                Assert.printLifeCycleState());
+        }
+        static void assertTransientClean() {
+            printFlush ("assertTransientClean");
+            if (thrown != null)
+                throw new RuntimeException ("Caught exception: " + thrown);
+            if (!Assert.isTransientClean(instance))
+                throw new RuntimeException ("Assertion TransientClean failed" +
+                Assert.printLifeCycleState());
+        }
+        static void assertTransientDirty() {
+            printFlush ("assertTransientDirty");
+            if (thrown != null)
+                throw new RuntimeException ("Caught exception: " + thrown);
+            if (!Assert.isTransientDirty(instance))
+                throw new RuntimeException ("Assertion TransientDirty failed" +
+                Assert.printLifeCycleState());
+        }
+        static void assertPersistentClean() {
+            printFlush ("assertPersistentClean");
+            if (thrown != null)
+                throw new RuntimeException ("Caught exception: " + thrown);
+            if (!Assert.isPersistentClean(instance))
+                throw new RuntimeException ("Assertion PersistentClean failed" +
+                Assert.printLifeCycleState());
+        }
+        static void assertPersistentDirty() {
+            printFlush ("assertPersistentDirty");
+            if (thrown != null)
+                throw new RuntimeException ("Caught exception: " + thrown);
+            if (!Assert.isPersistentDirty(instance))
+                throw new RuntimeException ("Assertion PersistentDirty failed" +
+                Assert.printLifeCycleState());
+        }
+        static void assertPersistentDeleted() {
+            printFlush ("assertPersistentDeleted");
+            if (thrown != null)
+                throw new RuntimeException ("Caught exception: " + thrown);
+            if (!Assert.isPersistentDeleted(instance))
+                throw new RuntimeException ("Assertion PersistentDeleted failed" +
+                Assert.printLifeCycleState());
+        }
+        static void assertPersistentNontransactional() {
+            printFlush ("assertPersistentNontransactional");
+            if (thrown != null)
+                throw new RuntimeException ("Caught exception: " + thrown);
+            if (!Assert.isPersistentNontransactional(instance))
+                throw new RuntimeException ("Assertion PersistentNontransactional failed: " +
+                Assert.printLifeCycleState());
+        }
+        static void assertHollow() {
+            printFlush ("assertHollow");
+            if (thrown != null)
+                throw new RuntimeException ("Caught exception: " + thrown);
+            if (!Assert.isHollow(instance))
+                throw new RuntimeException ("Assertion Hollow failed: " +
+                Assert.printLifeCycleState());
+        }
+        static void beginTransaction() {
+            printFlush ("beginTransaction");
+            persistenceManager.currentTransaction().begin();
+        }
+        static void commitTransaction() {
+            printFlush ("commitTransaction");
+            persistenceManager.currentTransaction().commit();
+        }
+        static void rollbackTransaction() {
+            printFlush ("rollbackTransaction");
+            persistenceManager.currentTransaction().rollback();
+        }
+        static void readField() {
+            printFlush ("readField");
+            instance.getBirthdate();
+        }
+        static void writeField() {
+            printFlush ("writeField");
+            instance.setBirthdate(new Date());
+        }
+        static void makeDirty() {
+            printFlush ("makeDirty");
+            JDOHelper.makeDirty(instance, "lastname");
+        }
+        static void catchJDOException() {
+            printFlush ("catchJDOException");
+            if (thrown == null || !JDOException.class.isAssignableFrom(thrown.getClass()))
+                throw new RuntimeException ("Expected JDOException, got " + thrown);
+        }
+        static void catchJDOUserException() {
+            printFlush ("catchJDOUserException");
+            if (thrown == null || !JDOUserException.class.isAssignableFrom(thrown.getClass()))
+                throw new RuntimeException ("Expected JDOUserException, got " + thrown);
+        }
+        static void catchJDOFatalUserException() {
+            printFlush ("catchJDOFatalUserException");
+            if (thrown == null || !JDOFatalUserException.class.isAssignableFrom(thrown.getClass()))
+                throw new RuntimeException ("Expected JDOFatalUserException, got " + thrown);
+        }
+        static void catchJDODataStoreException() {
+            printFlush ("catchJDODataStoreException");
+            if (thrown == null || !JDODataStoreException.class.isAssignableFrom(thrown.getClass()))
+                throw new RuntimeException ("Expected JDODataStoreException, got " + thrown);
+        }
+    }
+
+    /** */
+    static void flush() {
+        try {
+            System.out.flush();
+        } catch (Exception e) {}
+    }
+
+    /** */
+    static void printFlush (String s) {
+        if (verbose) {
+            System.out.println (s);
+            flush();
+        }
+    }
+
+    /** */
+    static class Assert {
+        static String printLifeCycleState() {
+            return
+                testCaseName + ": isPersistent: " + JDOHelper.isPersistent(instance) +
+                ", isNew: " + JDOHelper.isNew(instance) +
+                ", isDirty: " + JDOHelper.isDirty(instance) +
+                ", isDeleted: " + JDOHelper.isDeleted(instance) +
+                ", isTransactional: " + JDOHelper.isTransactional(instance);
+        }
+        static boolean isTransient(Object instance) {
+            return (
+              (!JDOHelper.isPersistent(instance))
+            & (!JDOHelper.isNew(instance))
+            & (!JDOHelper.isDirty(instance))
+            & (!JDOHelper.isDeleted(instance))
+            & (!JDOHelper.isTransactional(instance))
+            );
+        }
+        static boolean isTransientClean(Object instance) {
+            return (
+              (!JDOHelper.isPersistent(instance))
+            & (!JDOHelper.isNew(instance))
+            & (!JDOHelper.isDirty(instance))
+            & (!JDOHelper.isDeleted(instance))
+            & (JDOHelper.isTransactional(instance))
+            );
+        }
+        static boolean isTransientDirty(Object instance) {
+            return (
+              (!JDOHelper.isPersistent(instance))
+            & (!JDOHelper.isNew(instance))
+            & (JDOHelper.isDirty(instance))
+            & (!JDOHelper.isDeleted(instance))
+            & (JDOHelper.isTransactional(instance))
+            );
+        }
+        static boolean isPersistentNew(Object instance) {
+            return (
+              (JDOHelper.isPersistent(instance))
+            & (JDOHelper.isNew(instance))
+            & (JDOHelper.isDirty(instance))
+            & (!JDOHelper.isDeleted(instance))
+            & (JDOHelper.isTransactional(instance))
+            );
+        }
+        static boolean isPersistentNewDeleted(Object instance) {
+            return (
+              (JDOHelper.isPersistent(instance))
+            & (JDOHelper.isNew(instance))
+            & (JDOHelper.isDirty(instance))
+            & (JDOHelper.isDeleted(instance))
+            & (JDOHelper.isTransactional(instance))
+            );
+        }
+        static boolean isPersistentDeleted(Object instance) {
+            return (
+              (JDOHelper.isPersistent(instance))
+            & (!JDOHelper.isNew(instance))
+            & (JDOHelper.isDirty(instance))
+            & (JDOHelper.isDeleted(instance))
+            & (JDOHelper.isTransactional(instance))
+            );
+        }
+        static boolean isPersistentClean(Object instance) {
+            return (
+              (JDOHelper.isPersistent(instance))
+            & (!JDOHelper.isNew(instance))
+            & (!JDOHelper.isDirty(instance))
+            & (!JDOHelper.isDeleted(instance))
+            & (JDOHelper.isTransactional(instance))
+            );
+        }
+        static boolean isPersistentDirty(Object instance) {
+            return (
+              (JDOHelper.isPersistent(instance))
+            & (!JDOHelper.isNew(instance))
+            & (JDOHelper.isDirty(instance))
+            & (!JDOHelper.isDeleted(instance))
+            & (JDOHelper.isTransactional(instance))
+            );
+        }
+        static boolean isPersistentNontransactional(Object instance) {
+            return (
+              (JDOHelper.isPersistent(instance))
+            & (!JDOHelper.isNew(instance))
+            & (!JDOHelper.isDirty(instance))
+            & (!JDOHelper.isDeleted(instance))
+            & (!JDOHelper.isTransactional(instance))
+            );
+        }
+	// The same as PersistentNontransactional from a user's perspective:
+        static boolean isHollow(Object instance) {
+            return (
+              (JDOHelper.isPersistent(instance))
+            & (!JDOHelper.isNew(instance))
+            & (!JDOHelper.isDirty(instance))
+            & (!JDOHelper.isDeleted(instance))
+            & (!JDOHelper.isTransactional(instance))
+            );
+        }
+    }
+
+}



Mime
View raw message