Return-Path: Delivered-To: apmail-db-jdo-commits-archive@www.apache.org Received: (qmail 86571 invoked from network); 19 Mar 2005 05:08:08 -0000 Received: from hermes.apache.org (HELO mail.apache.org) (209.237.227.199) by minotaur.apache.org with SMTP; 19 Mar 2005 05:08:08 -0000 Received: (qmail 88583 invoked by uid 500); 19 Mar 2005 05:08:07 -0000 Mailing-List: contact jdo-commits-help@db.apache.org; run by ezmlm Precedence: bulk List-Help: List-Unsubscribe: List-Post: List-Id: Reply-To: jdo-dev@db.apache.org Delivered-To: mailing list jdo-commits@db.apache.org Delivered-To: moderator for jdo-commits@db.apache.org Received: (qmail 4296 invoked by uid 99); 19 Mar 2005 01:32:58 -0000 X-ASF-Spam-Status: No, hits=-9.6 required=10.0 tests=ALL_TRUSTED,NO_REAL_NAME,UPPERCASE_25_50 X-Spam-Check-By: apache.org Message-ID: <20050319010615.28351.qmail@minotaur.apache.org> Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-Mailer: svnmailer-1.0.0-dev Date: Sat, 19 Mar 2005 01:06:15 -0000 Subject: svn commit: r158176 [66/79] - in incubator/jdo/trunk/ri11: ./ src/ src/conf/ src/java/ src/java/org/ src/java/org/apache/ src/java/org/apache/jdo/ src/java/org/apache/jdo/ejb/ src/java/org/apache/jdo/enhancer/ src/java/org/apache/jdo/impl/ src/java/org/apache/jdo/impl/enhancer/ src/java/org/apache/jdo/impl/enhancer/classfile/ src/java/org/apache/jdo/impl/enhancer/core/ src/java/org/apache/jdo/impl/enhancer/generator/ src/java/org/apache/jdo/impl/enhancer/meta/ src/java/org/apache/jdo/impl/enhancer/meta/model/ src/java/org/apache/jdo/impl/enhancer/meta/prop/ src/java/org/apache/jdo/impl/enhancer/meta/util/ src/java/org/apache/jdo/impl/enhancer/util/ src/java/org/apache/jdo/impl/fostore/ src/java/org/apache/jdo/impl/jdoql/ src/java/org/apache/jdo/impl/jdoql/jdoqlc/ src/java/org/apache/jdo/impl/jdoql/scope/ src/java/org/apache/jdo/impl/jdoql/tree/ src/java/org/apache/jdo/impl/model/ src/java/org/apache/jdo/impl/model/java/ src/java/org/apache/jdo/impl/model/java/runtime/ src/java/org/apache/jdo/impl/model/jdo/ src/java/org/apache/jdo/impl/model/jdo/caching/ src/java/org/apache/jdo/impl/model/jdo/util/ src/java/org/apache/jdo/impl/model/jdo/xml/ src/java/org/apache/jdo/impl/pm/ src/java/org/apache/jdo/impl/sco/ src/java/org/apache/jdo/impl/state/ src/java/org/apache/jdo/jdoql/ src/java/org/apache/jdo/jdoql/tree/ src/java/org/apache/jdo/model/ src/java/org/apache/jdo/model/java/ src/java/org/apache/jdo/model/jdo/ src/java/org/apache/jdo/pm/ src/java/org/apache/jdo/sco/ src/java/org/apache/jdo/state/ src/java/org/apache/jdo/store/ src/java/org/apache/jdo/util/ test/ test/conf/ test/enhancer/ test/enhancer/sempdept/ test/enhancer/sempdept/src/ test/enhancer/sempdept/src/empdept/ 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/ xdocs/ To: jdo-commits@db.apache.org From: mbo@apache.org X-Virus-Checked: Checked X-Spam-Rating: minotaur.apache.org 1.6.2 0/1000/N Added: incubator/jdo/trunk/ri11/test/java/org/apache/jdo/test/Test_JDOModel= .java URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/ri11/test/java/org/a= pache/jdo/test/Test_JDOModel.java?view=3Dauto&rev=3D158176 =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D --- incubator/jdo/trunk/ri11/test/java/org/apache/jdo/test/Test_JDOModel.ja= va (added) +++ incubator/jdo/trunk/ri11/test/java/org/apache/jdo/test/Test_JDOModel.ja= va Fri Mar 18 17:02:29 2005 @@ -0,0 +1,460 @@ +/* + * Copyright 2005 The Apache Software Foundation. + *=20 + * 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=20 + *=20 + * http://www.apache.org/licenses/LICENSE-2.0 + *=20 + * Unless required by applicable law or agreed to in writing, software=20 + * distributed under the License is distributed on an "AS IS" BASIS,=20 + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied= .=20 + * See the License for the specific language governing permissions and=20 + * 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. + *=20 + * @author Dave Bristor + */ +public class Test_JDOModel extends AbstractTest { + =20 + /** RuntimeJavaModelFactory. */ + private RuntimeJavaModelFactory javaModelFactory; + private JDOModel jdoModel; + =20 + /** */ + public static void main(String args[]) { + JDORITestRunner.run(Test_JDOModel.class); + } + + /** */ + protected void setUp() { + javaModelFactory =3D (RuntimeJavaModelFactory) AccessController.do= Privileged( + new PrivilegedAction () { + public Object run () { + return RuntimeJavaModelFactory.getInstance(); + }}); + JavaModel javaModel =3D + javaModelFactory.getJavaModel(this.getClass().getClassLoader()= ); + jdoModel =3D javaModel.getJDOModel(); + } + =20 + /** */ + protected void tearDown() { } + + /** */ + public void testXML() throws Exception { + DocumentBuilderFactory domParserFactory =3D DocumentBuilderFactory= .newInstance(); + DocumentBuilder domParser =3D 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, "packa= ge.jdo"), domParser); + // package.jdo in org.apache.jdo.pc.serializable + handleJDOFile(getResourceAsStream(PCSub3.class, "package.jdo"), do= mParser); + // package.jdo in org.apache.jdo.pc.appid + handleJDOFile(getResourceAsStream(PCRect.class, "package.jdo"), do= mParser); + // Employee.jdo in org.apache.jdo.pc.xempdept + handleJDOFile(getResourceAsStream(Employee.class, "Employee.jdo"),= domParser); + } + + /**=20 + * 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 =3D domParser.parse(is); + String packageName =3D getPackageName(dom); + handleClassElements(dom.getElementsByTagName("class"), packageName= ); + } + + /** */ + protected String getPackageName(Document dom) { + NodeList packageElements =3D dom.getElementsByTagName("package"); + int length =3D packageElements.getLength(); + if (length !=3D 1) + fail("Multiple package nodes"); + Node packageElement =3D packageElements.item(0); + String packageName =3D + packageElement.getAttributes().getNamedItem("name").getNodeVal= ue(); + if (debug) logger.debug("packageName: " + packageName); + return packageName; + } + + /** */ + protected void handleClassElements(NodeList classElements, + String packageName) { + for (int i =3D 0; i < classElements.getLength(); i++) { + handleClassElement((Element)classElements.item(i), packageName= ); + } + } + =20 + /** */ + protected void handleClassElement(Element classElement, String package= Name) { + String fullClassName =3D packageName + '.' + classElement.getAttri= bute("name"); + if (debug) logger.debug("class: " + fullClassName); + JDOClass jdoClass =3D jdoModel.getJDOClass(fullClassName); + assertNotNull("No JDOClass instance for class " + fullClassName, j= doClass); + + // handle identity type attribute + if (classElement.hasAttribute("identity-type")) { + String identityType =3D classElement.getAttribute("identity-ty= pe"); + if (debug) logger.debug(" identity-type: " + identityType); + assertEquals("Wrong identity-type of class " + fullClassName,=20 + identityType,=20 + JDOIdentityType.toString(jdoClass.getIdentityType= ())); + } + + // handle objectid-class attribute + if (classElement.hasAttribute("objectid-class")) { + String objectIdClass =3D classElement.getAttribute("objectid-c= lass"); + if (debug) logger.debug(" objectid-class: " + objectIdClass); + assertEquals("Wrong objectid-class of class " + fullClassName,=20 + objectIdClass,=20 + jdoClass.getDeclaredObjectIdClassName()); + } + + // handle requires-extent attribute + if (classElement.hasAttribute("requires-extent")) { + String requiresExtent =3D classElement.getAttribute("requires-= extent"); + if (debug) logger.debug(" requires-extent: " + requiresExtent= ); + assertEquals("Wrong requires-extent of class " + fullClassName= ,=20 + Boolean.valueOf(requiresExtent).booleanValue(),=20 + jdoClass.requiresExtent()); + } + + // handle persistence-capable-superclass attribute + if (classElement.hasAttribute("persistence-capable-superclass")) { + String pcSuperClass =3D + classElement.getAttribute("persistence-capable-superclass"= ); + if (debug) + logger.debug(" persistence-capable-superclass: " + pcSupe= rClass); + // 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,=20 + getQualifiedClassName(pcSuperClass, packageName),=20 + jdoClass.getPersistenceCapableSuperclassName()); + } + =20 + // handle field subelements + handleFieldElements(classElement.getElementsByTagName("field"), jd= oClass); + } + + /** */ + protected void handleFieldElements(NodeList fields, JDOClass jdoClass)= { + for (int i =3D 0; i < fields.getLength(); i++) { + handleFieldElement((Element)fields.item(i), jdoClass); + } + } + =20 + /** */ + protected void handleFieldElement(Element fieldElement, JDOClass jdoCl= ass) { + String fieldName =3D fieldElement.getAttribute("name"); + String className =3D jdoClass.getName(); + if (debug) logger.debug(" field: " + fieldName); + JDOField jdoField =3D 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 =3D + fieldElement.getAttribute("persistence-modifier"); + if (debug) + logger.debug(" persistence-modifier: " + persistenceMod= ifier); + assertEquals("Wrong persistence-modifier of field " + fieldNam= e + + " of class " + className,=20 + persistenceModifier,=20 + PersistenceModifier.toString(jdoField.getPersiste= nceModifier())); + } + =20 + // handle primary-key attribute + if (fieldElement.hasAttribute("primary-key")) { + String primaryKey =3D fieldElement.getAttribute("primary-key"); + if (debug) logger.debug(" primary-key: " + primaryKey); + assertEquals("Wrong primary-key of field " + fieldName + " of = class " + className,=20 + Boolean.valueOf(primaryKey).booleanValue(),=20 + jdoField.isPrimaryKey()); + } + + // handle null-value attribute=20 + if (fieldElement.hasAttribute("null-value")) { + String nullValue =3D fieldElement.getAttribute("null-value"); + if (debug) logger.debug(" null-value: " + nullValue); + assertEquals("Wrong null-value of field " + fieldName + + " of class " + className,=20 + nullValue,=20 + NullValueTreatment.toString(jdoField.getNullValue= Treatment())); + } + + // handle default-fetch-group attribute=20 + if (fieldElement.hasAttribute("default-fetch-group")) { + String dfg =3D fieldElement.getAttribute("default-fetch-group"= ); + if (debug) logger.debug(" default-fetch-group: " + dfg); + assertEquals("Wrong default-fetch-group of field " + fieldName= + + " of class " + className,=20 + Boolean.valueOf(dfg).booleanValue(),=20 + jdoField.isDefaultFetchGroup()); + } + + // handle embedded attribute=20 + if (fieldElement.hasAttribute("embedded")) { + String embedded =3D fieldElement.getAttribute("embedded"); + if (debug) logger.debug(" embedded: " + embedded); + assertEquals("Wrong embedded of field " + fieldName + + " of class " + className,=20 + Boolean.valueOf(embedded).booleanValue(),=20 + jdoField.isEmbedded()); + } + =20 + } + + /**=20 + * Verify metadata for org.apache.jdo.pc.empdept.PCFullTimeEmployee. + */=20 + protected void verifyPCFullTimeEmployee() { + Class clazz =3D PCFullTimeEmployee.class; + String className =3D clazz.getName(); + JDOClass jdoClass =3D javaModelFactory.getJavaType(clazz).getJDOCl= ass(); + assertNotNull("No JDOClass instance for class " + className, jdoCl= ass); + assertEquals("Wrong identity type of class " + className,=20 + JDOIdentityType.DATASTORE,=20 + jdoClass.getIdentityType()); + assertEquals("Wrong pc super class of class " + className,=20 + "org.apache.jdo.pc.empdept.PCEmployee",=20 + jdoClass.getPersistenceCapableSuperclassName()); + assertEquals("Wrong number of declared managed fields of class " += className,=20 + 1,=20 + jdoClass.getDeclaredManagedFieldCount()); + assertEquals("Wrong number of inherited managed fields of class " = + className,=20 + 10,=20 + jdoClass.getInheritedManagedFieldCount()); + assertEquals("Wrong list of managed fields of class " + className,=20 + "[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,=20 + "[birthdate, firstname, lastname, empid, hiredate, sa= lary]", + Arrays.asList(jdoClass.getDefaultFetchGroupFields()).= toString()); + assertEquals("Wrong list of managedFieldNumbers of class " + clas= sName,=20 + "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]", + PrintSupport.asList(jdoClass.getManagedFieldNumbers()= )=2EtoString()); + assertEquals("Wrong list of persistentFieldNumbers of class " + c= lassName,=20 + "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]", + PrintSupport.asList(jdoClass.getPersistentFieldNumber= s()).toString()); + assertEquals("Wrong list of primaryKeyFieldNumbers of class " + cl= assName,=20 + "[]", + PrintSupport.asList(jdoClass.getPrimaryKeyFieldNumber= s()).toString()); + assertEquals("Wrong list of persistentNonPKFieldNs of class " + cl= assName,=20 + "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]", + PrintSupport.asList(jdoClass.getPersistentNonPrimaryK= eyFieldNumbers()).toString()); + assertEquals("Wrong list of persistentRelshipFieldNumbers of class= " + className,=20 + "[3, 5, 7, 8, 9]", + PrintSupport.asList(jdoClass.getPersistentRelationshi= pFieldNumbers()).toString()); + assertEquals("Wrong list of persistentSerializableFieldNumbers of = class " + className,=20 + "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]", + PrintSupport.asList(jdoClass.getPersistentSerializabl= eFieldNumbers()).toString()); + + JDOField[] jdoFields =3D jdoClass.getDeclaredFields(); + assertEquals("Wrong number of declared fields of class" + classNam= e, + 1, + jdoFields.length); + JDOField jdoField =3D jdoFields[0]; + String fieldName =3D jdoField.getName(); + assertEquals("Wrong name of field of class " + className, + "salary", + fieldName); + assertEquals("Wrong type of field " + fieldName + " of class " + c= lassName, + "double", + jdoField.getType().toString()); + assertEquals("Wrong field number of field " + fieldName + " of cla= ss " + className, + 10, + jdoField.getFieldNumber()); + } + =20 + =20 + /**=20 + * Verify metadata for org.apache.jdo.pc.serializable.PCSub3.=20 + * It explicitly defines the dfg attribute. + */ + protected void verifyPCSub3() { + Class clazz =3D PCSub3.class; + String className =3D clazz.getName(); + JDOClass jdoClass =3D javaModelFactory.getJavaType(clazz).getJDOCl= ass(); + assertNotNull("No JDOClass instance for class " + className, jdoCl= ass); + assertEquals("Wrong identity type of class " + className,=20 + JDOIdentityType.DATASTORE,=20 + jdoClass.getIdentityType()); + assertEquals("Wrong pc super class of class " + className,=20 + "org.apache.jdo.pc.serializable.PCSuper",=20 + jdoClass.getPersistenceCapableSuperclassName()); + assertEquals("Wrong number of declared managed fields of class " += className,=20 + 2,=20 + jdoClass.getDeclaredManagedFieldCount()); + assertEquals("Wrong number of inherited managed fields of class " = + className,=20 + 2,=20 + jdoClass.getInheritedManagedFieldCount()); + assertEquals("Wrong list of managed fields of class " + className,=20 + "[s01, t02, s03, t04]", + Arrays.asList(jdoClass.getManagedFields()).toString()= ); + assertEquals("Wrong list of managedFieldNumbers of class " + clas= sName,=20 + "[0, 1, 2, 3]", + PrintSupport.asList(jdoClass.getManagedFieldNumbers()= )=2EtoString()); + assertEquals("Wrong list of persistentFieldNumbers of class " + c= lassName,=20 + "[0, 1, 2, 3]", + PrintSupport.asList(jdoClass.getPersistentFieldNumber= s()).toString()); + assertEquals("Wrong list of primaryKeyFieldNumbers of class " + cl= assName,=20 + "[]", + PrintSupport.asList(jdoClass.getPrimaryKeyFieldNumber= s()).toString()); + assertEquals("Wrong list of persistentNonPKFieldNs of class " + cl= assName,=20 + "[0, 1, 2, 3]", + PrintSupport.asList(jdoClass.getPersistentNonPrimaryK= eyFieldNumbers()).toString()); + assertEquals("Wrong list of persistentRelshipFieldNumbers of class= " + className,=20 + "[]", + PrintSupport.asList(jdoClass.getPersistentRelationshi= pFieldNumbers()).toString()); + assertEquals("Wrong list of persistentSerializableFieldNumbers of = class " + className,=20 + "[0, 2]", + PrintSupport.asList(jdoClass.getPersistentSerializabl= eFieldNumbers()).toString()); + + JDOField[] jdoFields =3D jdoClass.getDeclaredFields(); + assertEquals("Wrong number of declared fields of class" + classNam= e, + 2, + jdoFields.length); + + JDOField jdoField; + String fieldName; + + jdoField =3D jdoFields[0]; + fieldName =3D jdoField.getName(); + assertEquals("Wrong name of field of class " + className, + "s03", + fieldName); + assertEquals("Wrong type of field " + fieldName + " of class " + c= lassName, + "java.lang.String", + jdoField.getType().toString()); + assertEquals("Wrong field number of field " + fieldName + " of cla= ss " + + className, + 2, + jdoField.getFieldNumber()); + =20 + jdoField =3D jdoFields[1]; + fieldName =3D jdoField.getName(); + assertEquals("Wrong name of field of class " + className, + "t04", + fieldName); + assertEquals("Wrong type of field " + fieldName + " of class " + c= lassName, + "java.lang.String", + jdoField.getType().toString()); + assertEquals("Wrong field number of field " + fieldName + " of cla= ss " + className, + 3, + jdoField.getFieldNumber()); + } + + /** */ + protected String getQualifiedClassName(String className, String packag= eName) { + if (className.indexOf('.') =3D=3D -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); + }}); + } + =20 + /** + * Implementation of EntityResolver interface to check the jdo.dtd loc= ation + **/ + private static class JDOEntityResolver=20 + implements EntityResolver=20 + { + private static final String RECOGNIZED_PUBLIC_ID =3D=20 + "-//Sun Microsystems, Inc.//DTD Java Data Objects Metadata 1.0= //EN"; + private static final String RECOGNIZED_SYSTEM_ID =3D=20 + "file:/javax/jdo/jdo.dtd"; + + public InputSource resolveEntity(String publicId, String systemId) + throws SAXException, IOException=20 + { + // check for recognized ids + if (((publicId !=3D null) && RECOGNIZED_PUBLIC_ID.equals(publi= cId)) || + ((publicId =3D=3D null) && (systemId !=3D null) &&=20 + 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.=20 + InputStream stream =3D (InputStream) AccessController.doPr= ivileged ( + new PrivilegedAction () { + public Object run () { + return getClass().getClassLoader(). + getResourceAsStream("javax/jdo/jdo.dtd"); = //NOI18N + }}); + if (stream =3D=3D null) { + throw new JDOFatalInternalException( + "Cannot load javax/jdo/jdo.dtd, because the file d= oes not exist in the jdo.jar file, or the test case class is not granted pe= rmission to read this file. The metadata .xml file contained PUBLIC=3D" + = publicId + " SYSTEM=3D" + systemId + "."); + } + return new InputSource(new InputStreamReader(stream)); + } + return null; + } + } +} + Added: incubator/jdo/trunk/ri11/test/java/org/apache/jdo/test/Test_KeyField= Null.java URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/ri11/test/java/org/a= pache/jdo/test/Test_KeyFieldNull.java?view=3Dauto&rev=3D158176 =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D --- incubator/jdo/trunk/ri11/test/java/org/apache/jdo/test/Test_KeyFieldNul= l=2Ejava (added) +++ incubator/jdo/trunk/ri11/test/java/org/apache/jdo/test/Test_KeyFieldNul= l=2Ejava Fri Mar 18 17:02:29 2005 @@ -0,0 +1,109 @@ +/* + * Copyright 2005 The Apache Software Foundation. + *=20 + * 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=20 + *=20 + * http://www.apache.org/licenses/LICENSE-2.0 + *=20 + * Unless required by applicable law or agreed to in writing, software=20 + * distributed under the License is distributed on an "AS IS" BASIS,=20 + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied= .=20 + * See the License for the specific language governing permissions and=20 + * 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 exce= ption. +* +* @author Craig Russell +*/ +public class Test_KeyFieldNull extends AbstractTest { + =20 + /** */ + 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 =3D pmf.getPersistenceManager(); + Transaction tx =3D pm.currentTransaction(); + try { + tx.begin(); + PCObjectKey obj =3D new PCObjectKey(); + try { + pm.makePersistent(obj); + fail("Test failed. Expected JDOUserException on makePersis= tent with key field null"); + } catch (JDOUserException ex) { + if (debug) logger.debug("caught expected " + ex); + } + } + finally { + if (tx !=3D null && tx.isActive()) + tx.rollback(); + if (pm !=3D null && !pm.isClosed()) + pm.close(); + } + } + =20 + /** Create an instance with a null key field and verify that the proper + * exception is thrown for makePersistentAll. + */ + public void test2() { + PersistenceManager pm =3D pmf.getPersistenceManager(); + Transaction tx =3D pm.currentTransaction(); + try { + tx.begin(); + PCObjectKey obj =3D new PCObjectKey(); + try { + pm.makePersistentAll(new Object[] {obj}); + fail("Test failed. Expected JDOUserException on makePersis= tent with key field null"); + } catch (JDOUserException ex) { + if (debug) logger.debug("caught expected " + ex); + } + } + finally { + if (tx !=3D null && tx.isActive()) + tx.rollback(); + if (pm !=3D null && !pm.isClosed()) + pm.close(); + } + } + =20 + /** GetObjectById with an object id with a key field null and verify t= hat the + * proper exception is thrown. + */ + public void test3() { + PersistenceManager pm =3D pmf.getPersistenceManager(); + try { + PCObjectKey pcobj =3D new PCObjectKey(); + PCObjectKey.Oid key =3D new PCObjectKey.Oid(); + try { + Object obj =3D pm.getObjectById(key, false); + fail("Test failed. Expected JDOUserException on getObjectB= yId with key field null"); + } catch (JDOUserException ex) { + if (debug) logger.debug("caught expected " + ex); + } + } + finally { + if (pm !=3D null && !pm.isClosed()) + pm.close(); + } + } =20 + +} Added: incubator/jdo/trunk/ri11/test/java/org/apache/jdo/test/Test_LargeObj= .java URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/ri11/test/java/org/a= pache/jdo/test/Test_LargeObj.java?view=3Dauto&rev=3D158176 =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D --- incubator/jdo/trunk/ri11/test/java/org/apache/jdo/test/Test_LargeObj.ja= va (added) +++ incubator/jdo/trunk/ri11/test/java/org/apache/jdo/test/Test_LargeObj.ja= va Fri Mar 18 17:02:29 2005 @@ -0,0 +1,54 @@ +/* + * Copyright 2005 The Apache Software Foundation. + *=20 + * 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=20 + *=20 + * http://www.apache.org/licenses/LICENSE-2.0 + *=20 + * Unless required by applicable law or agreed to in writing, software=20 + * distributed under the License is distributed on an "AS IS" BASIS,=20 + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied= .=20 + * See the License for the specific language governing permissions and=20 + * 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 =3D Integer.getInteger("size", 100000).intValu= e(); + =20 + /** */ + 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); + } + =20 +} Added: incubator/jdo/trunk/ri11/test/java/org/apache/jdo/test/Test_LifeCycl= e=2Ejava URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/ri11/test/java/org/a= pache/jdo/test/Test_LifeCycle.java?view=3Dauto&rev=3D158176 =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D --- incubator/jdo/trunk/ri11/test/java/org/apache/jdo/test/Test_LifeCycle.j= ava (added) +++ incubator/jdo/trunk/ri11/test/java/org/apache/jdo/test/Test_LifeCycle.j= ava Fri Mar 18 17:02:29 2005 @@ -0,0 +1,854 @@ +/* + * Copyright 2005 The Apache Software Foundation. + *=20 + * 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=20 + *=20 + * http://www.apache.org/licenses/LICENSE-2.0 + *=20 + * Unless required by applicable law or agreed to in writing, software=20 + * distributed under the License is distributed on an "AS IS" BASIS,=20 + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied= .=20 + * See the License for the specific language governing permissions and=20 + * 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 =3D 0; + final static int COMMIT_TRANSACTION =3D 1; + final static int ROLLBACK_TRANSACTION =3D 2; + final static int MAKE_PERSISTENT =3D 10; + final static int DELETE_PERSISTENT =3D 11; + final static int MAKE_TRANSIENT =3D 12; + final static int MAKE_TRANSACTIONAL =3D 13; + final static int MAKE_NONTRANSACTIONAL =3D 14; + final static int EVICT =3D 15; + final static int REFRESH =3D 16; + final static int READ_FIELD =3D 20; + final static int WRITE_FIELD =3D 21; + final static int GET_OBJECT_ID =3D 22; + final static int GET_OBJECT_BY_ID_WITH_VALIDATE =3D 23; + final static int GET_OBJECT_BY_ID_WOUT_VALIDATE =3D 24; + final static int MAKE_DIRTY =3D 25; + final static int CATCH_JDO_EXCEPTION =3D 30; + final static int CATCH_JDO_USER_EXCEPTION =3D 31; + final static int CATCH_JDO_DATASTORE_EXCEPTION =3D 32; + final static int CATCH_JDO_FATAL_USER_EXCEPTION =3D 33; + final static int CATCH_JDO_FATAL_INTERNAL_EXCEPTION =3D 34; + final static int ASSERT_TRANSIENT =3D 100; + final static int ASSERT_TRANSIENT_CLEAN =3D 101; + final static int ASSERT_TRANSIENT_DIRTY =3D 102; + final static int ASSERT_PERSISTENT_NEW =3D 103; + final static int ASSERT_PERSISTENT_CLEAN =3D 104; + final static int ASSERT_PERSISTENT_NONTRANSACTIONAL =3D 105; + final static int ASSERT_PERSISTENT_DIRTY =3D 106; + final static int ASSERT_PERSISTENT_NEW_DELETED =3D 107; + final static int ASSERT_PERSISTENT_DELETED =3D 108; + final static int ASSERT_HOLLOW =3D 109; + final static int CREATE_TRANSIENT =3D 200; + + ArrayList cases =3D new ArrayList(); + + static PCPerson instance =3D null; + static Object oid =3D null; + static Date date =3D new Date(); + + static String testCaseName; + static PersistenceManager persistenceManager; + static Throwable thrown; + + static boolean verbose =3D Boolean.getBoolean("verbose"); + + /** Creates new Test_LifeCycle */ + public Test_LifeCycle() { + int i =3D 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, rollbac= k", 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, com= mit, 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, makeTransa= ctional, 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, make= NonTransactional, 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, makePersi= stent, 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, ma= kePersistent, 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", n= ew 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, roll= back", 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, comm= it", 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, makeT= ransactional", 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-1= 54 + ,MAKE_TRANSACTIONAL, ASSERT_PERSISTENT_CLEAN // A5.9-156 + ,COMMIT_TRANSACTION, ASSERT_PERSISTENT_NONTRANSACTIONAL + })); + cases.add (new Case (i++, "PersistentDirty: makePersistent, makeTr= ansactional, 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 // A= 5=2E9-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 // A= 5=2E9-59 + })); + cases.add (new Case (i++, "PersistentClean: makePersistent, makeTr= ansactional", 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 // A= 5=2E9-145 + })); + cases.add (new Case (i++, "PersistentDeleted: makePersistent, make= Transactional, 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), getObj= ectById(true), makePersistent, commit", new int[] { // 21 + CREATE_TRANSIENT, ASSERT_TRANSIENT + ,BEGIN_TRANSACTION, ASSERT_TRANSIENT + ,GET_OBJECT_BY_ID_WOUT_VALIDATE, ASSERT_PERSISTENT_NONTRANSACT= IONAL + ,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_NONTRANSACT= IONAL + ,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 + })); + } + =20 + /** */ + public static void main(String args[]) { + JDORITestRunner.run(Test_LifeCycle.class); + } + + /** */ + public void test() { + persistenceManager =3D pmf.getPersistenceManager(); + for (Iterator i =3D cases.iterator(); i.hasNext();) { + Case testcase =3D (Case) i.next(); + testcase.execute(); + } + } + + /** + * Initializes JDO startup properties with default values. + * Sub classes can overwrite this method in order to change those defa= ult + * 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:t= est" ); + properties.setProperty( "javax.jdo.option.NontransactionalWrite", = "true" ); + properties.setProperty( "javax.jdo.option.Optimistic", "false" ); + } + + /** */ + static void resetThrown() { + thrown =3D null; + } + + /** */ + class Case { + int number; + String name; + int[] procedures; + Case (int number, String name, int[] procedures) { + this.number =3D number; + this.name =3D name; + this.procedures =3D procedures; + } + int execute () { + printFlush ("Test case " + number + ": " + name); + testCaseName =3D name; + for (int i =3D 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 =3D t; + } catch (RuntimeException e) { + e.printStackTrace(); + throw new JDOException ("Test failed", e); + } + } + return 0; + } + } + + /** */ + static class Procedure { + static void createTransient() { + printFlush ("createTransient"); + instance =3D 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 =3D persistenceManager.getObjectId(instance); + } + static void getObjectById(boolean validate) { + printFlush ("getObjectById_" + validate); + Object o =3D persistenceManager.getObjectById(oid, validate); + instance =3D (PCPerson)o; + } + static void assertPersistentNew() { + printFlush ("assertPersistentNew"); + if (thrown !=3D null) + throw new RuntimeException ("Caught exception: " + thrown); + if (!Assert.isPersistentNew(instance)) + throw new RuntimeException ("Assertion PersistentNew faile= d" + + Assert.printLifeCycleState()); + } + static void assertPersistentNewDeleted() { + printFlush ("assertPersistentNewDeleted"); + if (thrown !=3D 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 !=3D 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 !=3D null) + throw new RuntimeException ("Caught exception: " + thrown); + if (!Assert.isTransientClean(instance)) + throw new RuntimeException ("Assertion TransientClean fail= ed" + + Assert.printLifeCycleState()); + } + static void assertTransientDirty() { + printFlush ("assertTransientDirty"); + if (thrown !=3D null) + throw new RuntimeException ("Caught exception: " + thrown); + if (!Assert.isTransientDirty(instance)) + throw new RuntimeException ("Assertion TransientDirty fail= ed" + + Assert.printLifeCycleState()); + } + static void assertPersistentClean() { + printFlush ("assertPersistentClean"); + if (thrown !=3D null) + throw new RuntimeException ("Caught exception: " + thrown); + if (!Assert.isPersistentClean(instance)) + throw new RuntimeException ("Assertion PersistentClean fai= led" + + Assert.printLifeCycleState()); + } + static void assertPersistentDirty() { + printFlush ("assertPersistentDirty"); + if (thrown !=3D null) + throw new RuntimeException ("Caught exception: " + thrown); + if (!Assert.isPersistentDirty(instance)) + throw new RuntimeException ("Assertion PersistentDirty fai= led" + + Assert.printLifeCycleState()); + } + static void assertPersistentDeleted() { + printFlush ("assertPersistentDeleted"); + if (thrown !=3D null) + throw new RuntimeException ("Caught exception: " + thrown); + if (!Assert.isPersistentDeleted(instance)) + throw new RuntimeException ("Assertion PersistentDeleted f= ailed" + + Assert.printLifeCycleState()); + } + static void assertPersistentNontransactional() { + printFlush ("assertPersistentNontransactional"); + if (thrown !=3D null) + throw new RuntimeException ("Caught exception: " + thrown); + if (!Assert.isPersistentNontransactional(instance)) + throw new RuntimeException ("Assertion PersistentNontransa= ctional failed: " + + Assert.printLifeCycleState()); + } + static void assertHollow() { + printFlush ("assertHollow"); + if (thrown !=3D 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 =3D=3D null || !JDOException.class.isAssignableFrom= (thrown.getClass())) + throw new RuntimeException ("Expected JDOException, got " = + thrown); + } + static void catchJDOUserException() { + printFlush ("catchJDOUserException"); + if (thrown =3D=3D null || !JDOUserException.class.isAssignable= From(thrown.getClass())) + throw new RuntimeException ("Expected JDOUserException, go= t " + thrown); + } + static void catchJDOFatalUserException() { + printFlush ("catchJDOFatalUserException"); + if (thrown =3D=3D null || !JDOFatalUserException.class.isAssig= nableFrom(thrown.getClass())) + throw new RuntimeException ("Expected JDOFatalUserExceptio= n, got " + thrown); + } + static void catchJDODataStoreException() { + printFlush ("catchJDODataStoreException"); + if (thrown =3D=3D null || !JDODataStoreException.class.isAssig= nableFrom(thrown.getClass())) + throw new RuntimeException ("Expected JDODataStoreExceptio= n, 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)) + ); + } + } + +}