/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.jdo.tck;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintStream;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Properties;
import java.util.StringTokenizer;
import java.util.Vector;
import javax.jdo.Extent;
import javax.jdo.JDOException;
import javax.jdo.JDOFatalException;
import javax.jdo.JDOHelper;
import javax.jdo.JDOObjectNotFoundException;
import javax.jdo.PersistenceManager;
import javax.jdo.PersistenceManagerFactory;
import javax.jdo.Query;
import junit.framework.AssertionFailedError;
import junit.framework.TestCase;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
public abstract class JDO_Test extends TestCase {
public static final int TRANSIENT = 0;
public static final int PERSISTENT_NEW = 1;
public static final int PERSISTENT_CLEAN = 2;
public static final int PERSISTENT_DIRTY = 3;
public static final int HOLLOW = 4;
public static final int TRANSIENT_CLEAN = 5;
public static final int TRANSIENT_DIRTY = 6;
public static final int PERSISTENT_NEW_DELETED = 7;
public static final int PERSISTENT_DELETED = 8;
public static final int PERSISTENT_NONTRANSACTIONAL = 9;
public static final int PERSISTENT_NONTRANSACTIONAL_DIRTY = 10;
public static final int DETACHED_CLEAN = 11;
public static final int DETACHED_DIRTY = 12;
public static final int NUM_STATES = 13;
public static final int ILLEGAL_STATE = 13;
public static final String[] states = {
"transient",
"persistent-new",
"persistent-clean",
"persistent-dirty",
"hollow",
"transient-clean",
"transient-dirty",
"persistent-new-deleted",
"persistent-deleted",
"persistent-nontransactional",
"persistent-nontransactional-dirty",
"detached-clean",
"detached-dirty",
"illegal"
};
private static final int IS_PERSISTENT = 0;
private static final int IS_TRANSACTIONAL = 1;
private static final int IS_DIRTY = 2;
private static final int IS_NEW = 3;
private static final int IS_DELETED = 4;
private static final int IS_DETACHED = 5;
private static final int NUM_STATUSES = 6;
/*
* This table indicates the values returned by the status interrogation
* methods for each state. This is used to determine the current lifecycle
* state of an object.
*/
private static final boolean state_statuses[][] = {
// IS_PERSISTENT IS_TRANSACTIONAL IS_DIRTY IS_NEW IS_DELETED IS_DETACHED
// transient
{ false, false, false, false, false, false},
// persistent-new
{ true, true, true, true, false, false},
// persistent-clean
{ true, true, false, false, false, false},
// persistent-dirty
{ true, true, true, false, false, false},
// hollow
{ true, false, false, false, false, false},
// transient-clean
{ false, true, false, false, false, false},
// transient-dirty
{ false, true, true, false, false, false},
// persistent-new-deleted
{ true, true, true, true, true, false},
// persistent-deleted
{ true, true, true, false, true, false},
// persistent-nontransactional
{ true, false, false, false, false, false},
// persistent-nontransactional-dirty
{ true, false, true, false, false, false},
// detached_clean
{ false, false, false, false, false, true},
// detached_dirty
{ false, false, true, false, false, true}
};
/** Name of the PersistenceManagerFactoryClass PMF property. */
public static final String PMF_CLASS_PROP =
"javax.jdo.PersistenceManagerFactoryClass";
/** Name of the ConnectionURL PMF property. */
public static final String CONNECTION_URL_PROP =
"javax.jdo.option.ConnectionURL";
/** Name of the ConnectionUserName PMF property. */
public static final String CONNECTION_USERNAME_PROP =
"javax.jdo.option.ConnectionUserName";
/** Name of the ConnectionPassword PMF property. */
public static final String CONNECTION_PASSWORD_PROP =
"javax.jdo.option.ConnectionPassword";
/** identitytype value for applicationidentity. */
public static final String APPLICATION_IDENTITY = "applicationidentity";
/** identitytype value for datastoreidentity. */
public static final String DATASTORE_IDENTITY = "datastoreidentity";
/**
* String indicating the type of identity used for the current test case.
* The value is either "applicationidentity" or "datastoreidentity".
*/
protected final String identitytype = System.getProperty("jdo.tck.identitytype");
/**
* String indicating the name of the schema for the current test.
*/
protected final String schemaname = System.getProperty("jdo.tck.schemaname");
/** Name of the file containing the properties for the PMF. */
protected static String PMFProperties = System.getProperty("PMFProperties");
/** Flag indicating whether to clean up data after tests or not.
* If false then test will not clean up data from database.
* The default value is true.
*/
protected static boolean cleanupData =
System.getProperty("jdo.tck.cleanupaftertest", "true").equalsIgnoreCase("true");
/** Flag indicating whether to close the PMF after each test or not.
* It defaults to false.
*/
protected static final boolean closePMFAfterEachTest =
System.getProperty("jdo.tck.closePMFAfterEachTest", "false").equalsIgnoreCase("true");
/** The Properties object for the PersistenceManagerFactory. */
protected static Properties PMFPropertiesObject;
/** The PersistenceManagerFactory. */
protected static PersistenceManagerFactory pmf;
/** The collection of supported options of the pmf. */
private static Collection supportedOptions;
/** The name of the pmf supported options summary file. */
private static final String PMF_SUPPORTED_OPTIONS_FILE_NAME = "pmf_supported_options.txt";
/** The PersistenceManager. */
protected PersistenceManager pm;
// Flag indicating successful test run
protected boolean testSucceeded;
/** Logger */
protected Log logger =
LogFactory.getFactory().getInstance("org.apache.jdo.tck");
/** true if debug logging in enabled. */
protected boolean debug = logger.isDebugEnabled();
/**
* Indicates an exception thrown in method <code>tearDown</code>.
* At the end of method <code>tearDown</code> this field is nullified.
*/
private Throwable tearDownThrowable;
/**
* A list of registered oid instances.
* Corresponding pc instances are deleted in <code>localTearDown</code>.
*/
private Collection tearDownInstances = new LinkedList();
/**
* A list of registered pc classes.
* The extents of these classes are deleted in <code>localTearDown</code>.
*/
private Collection tearDownClasses = new LinkedList();
/** */
protected final void setUp() throws Exception {
pmf = getPMF();
localSetUp();
}
/**
* Subclasses may override this method to allocate any data and resources
* that they need in order to successfully execute this testcase.
*/
protected void localSetUp() {}
/**
* Runs the bare test sequence.
* @exception Throwable if any exception is thrown
*/
public final void runBare() throws Throwable {
try {
testSucceeded = false;
setUp();
runTest();
testSucceeded = true;
}
catch (AssertionFailedError e) {
if (logger.isInfoEnabled())
logger.info("Exception during setUp or runtest: ", e);
throw e;
}
catch (Throwable t) {
if (logger.isInfoEnabled())
logger.info("Exception during setUp or runtest: ", t);
throw t;
}
finally {
tearDown();
if (debug) {
logger.debug("Free memory: " + Runtime.getRuntime().freeMemory());
}
}
}
/**
* Sets field <code>tearDownThrowable</code> if it is <code>null</code>.
* Else, the given throwable is logged using fatal log level.
* @param throwable the throwable
*/
private void setTearDownThrowable(String context, Throwable throwable)
{
if (logger.isInfoEnabled())
logger.info("Exception during "+context+": ", throwable);
if (this.tearDownThrowable == null) {
this.tearDownThrowable = throwable;
}
}
/**
* This method clears data and resources allocated by testcases.
* It first closes the persistence manager of this testcase.
* Then it calls method <code>localTearDown</code>.
* Subclasses may override that method to clear any data and resources
* that they have allocated in method <code>localSetUp</code>.
* Finally, this method closes the persistence manager factory.<p>
*
* <b>Note:</b>These methods are called always, regardless of any exceptions.
* The first caught exception is kept in field <code>tearDownThrowable</code>.
* That exception is thrown as a nested exception of <code>JDOFatalException</code>
* if and only if the testcase executed successful.
* Otherwise that exception is logged using fatal log level.
* All other exceptions are logged using fatal log level, always.<p>
*
* <b>Note:</b>By default, the method tearDown does not close the pmf.
* This is done at the end of each configuration, unless the property
* jdo.tck.closePMFAfterEachTest is set to true.
*/
protected final void tearDown() {
try {
cleanupPM();
}
catch (Throwable t) {
setTearDownThrowable("cleanupPM", t);
}
if ((pmf == null || pmf.isClosed()) &&
(this.tearDownInstances.size() > 0 || this.tearDownClasses.size() > 0))
throw new JDOFatalException ("PMF must not be nullified or closed when tear down instances and /or classes have been added.");
if (pmf != null && pmf.isClosed())
pmf = null;
try {
if (cleanupData) {
localTearDown();
}
}
catch (Throwable t) {
setTearDownThrowable("localTearDown", t);
}
if (closePMFAfterEachTest) {
try {
closePMF();
}
catch (Throwable t) {
setTearDownThrowable("closePMF", t);
}
}
if (this.tearDownThrowable != null) {
Throwable t = this.tearDownThrowable;
this.tearDownThrowable = null;
if (testSucceeded) {
// runTest succeeded, but this method threw exception => error
throw new JDOFatalException("Exception during tearDown", t);
}
}
}
/**
* Deletes all registered pc instances and extents of all registered pc classes.
* Subclasses may override this method to clear any data and resources
* that they have allocated in method <code>localSetUp</code>.
*/
protected void localTearDown() {
deleteTearDownInstances();
deleteTearDownClasses();
}
protected void addTearDownObjectId(Object oid) {
// ensure that oid is not a PC instance
if (JDOHelper.getObjectId(oid) != null ||
JDOHelper.isTransactional(oid))
throw new IllegalArgumentException("oid");
this.tearDownInstances.add(oid);
}
protected void addTearDownInstance(Object pc) {
Object oid = JDOHelper.getObjectId(pc);
addTearDownObjectId(oid);
}
protected void addTearDownClass(Class pcClass) {
this.tearDownClasses.add(pcClass);
}
protected void addTearDownClass(Class[] pcClasses) {
if (pcClasses == null) return;
for (int i = 0; i < pcClasses.length; ++i) {
addTearDownClass(pcClasses[i]);
}
}
/**
* Deletes and removes tear down instances.
* If there are no tear down instances,
* the this method is a noop.
* Otherwise, tear down instances are deleted
* exactly in the order they have been added.
* Tear down instances are deleted in a separate transaction.
*/
protected void deleteTearDownInstances() {
if (this.tearDownInstances.size() > 0) {
getPM();
try {
this.pm.currentTransaction().begin();
for (Iterator i = this.tearDownInstances.iterator(); i.hasNext(); ) {
Object pc;
try {
pc = this.pm.getObjectById(i.next(), true);
}
catch (JDOObjectNotFoundException e) {
pc = null;
}
// we only delete those persistent instances
// which have not been deleted by tests already.
if (pc != null) {
this.pm.deletePersistent(pc);
}
}
this.pm.currentTransaction().commit();
}
finally {
this.tearDownInstances.clear();
cleanupPM();
}
}
}
/**
* Deletes and removes tear down classes.
* If there are no tear down classes,
* the this method is a noop.
* Otherwise, tear down classes are deleted
* exactly in the order they have been added.
* Tear down classes are deleted in a separate transaction.
* Deleting a tear down class means to delete the extent.
*/
protected void deleteTearDownClasses() {
if (this.tearDownClasses.size() > 0) {
getPM();
try {
this.pm.currentTransaction().begin();
for (Iterator i = this.tearDownClasses.iterator(); i.hasNext(); ) {
this.pm.deletePersistentAll(getAllObjects(this.pm, (Class)i.next()));
}
this.pm.currentTransaction().commit();
}
finally {
this.tearDownClasses.clear();
cleanupPM();
}
}
}
/** */
protected Collection getAllObjects(PersistenceManager pm, Class pcClass) {
Collection col = new Vector() ;
Query query = pm.newQuery();
query.setClass(pcClass);
Extent candidates = null;
try {
candidates = pm.getExtent(pcClass, false);
} catch (JDOException ex) {
if (debug) logger.debug("Exception thrown for getExtent of class " +
pcClass.getName());
return col;
}
query.setCandidates(candidates);
Object result = query.execute();
return (Collection)result;
}
/**
* Get the <code>PersistenceManagerFactory</code> instance
* for the implementation under test.
* @return field <code>pmf</code> if it is not <code>null</code>,
* else sets field <code>pmf</code> to a new instance and returns that instance.
*/
protected PersistenceManagerFactory getPMF()
{
if (pmf == null) {
PMFPropertiesObject = loadProperties(PMFProperties); // will exit here if no properties
pmf = JDOHelper.getPersistenceManagerFactory(PMFPropertiesObject);
if (supportedOptions == null) {
supportedOptions = pmf.supportedOptions();
}
}
return pmf;
}
/**
* Get the <code>PersistenceManagerFactory</code> instance
* for the implementation under test. This method does NOT use the
* JDOHelper method to retrieve the PMF, instead it creates an instance of
* the class specified as javax.jdo.PersistenceManagerFactoryClass
* property. The returned PMF is not configured.
* @return field <code>pmf</code> if it is not <code>null</code>,
* else sets field <code>pmf</code> to a new instance and returns that instance.
*/
protected PersistenceManagerFactory getUnconfiguredPMF()
{
if (pmf == null) {
PMFPropertiesObject = loadProperties(PMFProperties); // will exit here if no properties
String name = PMFPropertiesObject.getProperty(PMF_CLASS_PROP);
try {
Class pmfClass = Class.forName(name);
pmf = (PersistenceManagerFactory) pmfClass.newInstance();
if (supportedOptions == null) {
supportedOptions = pmf.supportedOptions();
}
} catch (ClassNotFoundException ex) {
throw new JDOException("Cannot find PMF class '" + name + "'.",
ex);
} catch (InstantiationException ex) {
throw new JDOException("Cannot instantiate PMF class '" +
name + "'.", ex);
} catch (IllegalAccessException ex) {
throw new JDOException("Cannot access PMF class '" + name +
"' or its no-arg constructor.", ex);
}
}
return pmf;
}
/**
* Get the <code>PersistenceManager</code> instance
* for the implementation under test.
*/
protected PersistenceManager getPM() {
if (pm == null) {
pm = getPMF().getPersistenceManager();
}
return pm;
}
/**
* This method cleans up the environment: closes the
* <code>PersistenceManager</code>. This should avoid leaving
* multiple PersistenceManager instances around, in case the
* PersistenceManagerFactory performs PersistenceManager pooling.
*/
protected void cleanupPM()
{
cleanupPM(pm);
pm = null;
}
/**
* This method cleans up the specified
* <code>PersistenceManager</code>. If the pm still has an open
* transaction, it will be rolled back, before closing the pm.
*/
protected static void cleanupPM(PersistenceManager pm)
{
if ((pm != null) && !pm.isClosed()) {
if (pm.currentTransaction().isActive()) {
pm.currentTransaction().rollback();
}
pm.close();
}
}
/** Closes the pmf stored in this instance. */
public static void closePMF() {
JDOException failure = null;
while (pmf != null) {
try {
if (!pmf.isClosed())
pmf.close();
pmf = null;
}
catch (JDOException ex) {
// store failure of first call pmf.close
if (failure == null)
failure = ex;
PersistenceManager[] pms = getFailedPersistenceManagers(
"closePMF", ex);
for (int i = 0; i < pms.length; i++) {
cleanupPM(pms[i]);
}
}
}
// rethrow JDOException thrown by pmf.close
if (failure != null)
throw failure;
}
/** */
protected static PersistenceManager[] getFailedPersistenceManagers(
String assertionFailure, JDOException ex) {
Throwable[] nesteds = ex.getNestedExceptions();
int numberOfExceptions = nesteds==null ? 0 : nesteds.length;
PersistenceManager[] result = new PersistenceManager[numberOfExceptions];
for (int i = 0; i < numberOfExceptions; ++i) {
JDOException exc = (JDOException)nesteds[i];
Object failedObject = exc.getFailedObject();
if (exc.getFailedObject() instanceof PersistenceManager) {
result[i] = (PersistenceManager)failedObject;
} else {
throw new JDOFatalException(assertionFailure,
"Unexpected failed object of type: " +
failedObject.getClass().getName());
}
}
return result;
}
/**
* This method load Properties from a given file.
*/
protected Properties loadProperties(String fileName)
{
if (fileName == null) {
fileName = System.getProperty("user.home") + "/.jdo/PMFProperties.properties";
}
Properties props = new Properties();
InputStream propStream = null;
try {
propStream = new FileInputStream(fileName);
}
catch (IOException ex) {
System.out.println("Could not open properties file \"" + fileName + "\"");
System.out.println("Please specify a system property PMFProperties " +
"with the PMF properties file name as value " +
"(defaults to {user.home}/.jdo/PMFProperties.properties)");
System.exit(1);
}
try {
props.load(propStream);
}
catch (IOException ex) {
System.out.println("Error loading properties file \"" + fileName + "\"");
ex.printStackTrace();
System.exit(1);
}
return props;
}
/**
* Prints the specified msg (if debug is true), before it aborts the
* test case.
*/
public void fail(String assertionFailure, String msg) {
if (debug) logger.debug(msg);
fail(assertionFailure + NL + msg);
}
// Helper methods to check for supported options
/**
* Dump the supportedOptions to the a file in the specified directory.
*/
public static void dumpSupportedOptions(String directory) {
if (supportedOptions == null)
return;
File file = new File(directory, PMF_SUPPORTED_OPTIONS_FILE_NAME);
if (file.exists())
// PMF supported options have been dumped before => return
return;
PrintStream resultStream = null;
try {
resultStream = new PrintStream(new FileOutputStream(file));
for (Iterator it = supportedOptions.iterator(); it.hasNext();) {
resultStream.println((String)it.next());
}
} catch (FileNotFoundException e) {
throw new JDOFatalException(
"dumpSupportedOptions: cannot create file " + file.getName(), e);
} finally {
if (resultStream != null)
resultStream.close();
}
}
/**
* Prints a message (if debug is true) saying the test with the
* specified name is not executed, because the JDO implementation under
* test does not support the specified optional feature.
* @param testName the name of the test method that is skipped.
* @param optionalFeature the name of the option not supported by the
* JDO implementation under tets.
*/
protected void printUnsupportedOptionalFeatureNotTested(
String testName, String optionalFeature) {
if (debug) {
logger.debug(
"Test " + testName +
" was not run, because optional feature " + optionalFeature +
" is not supported by the JDO implementation under test");
}
}
/** Reports whether TransientTransactional is supported. */
public boolean isTransientTransactionalSupported() {
return getPMF().supportedOptions().contains(
"javax.jdo.option.TransientTransactional");
}
/** Reports whether NontransactionalRead is supported. */
public boolean isNontransactionalReadSupported(){
return getPMF().supportedOptions().contains(
"javax.jdo.option.NontransactionalRead");
}
/** Reports whether NontransactionalWrite is supported. */
public boolean isNontransactionalWriteSupported() {
return getPMF().supportedOptions().contains(
"javax.jdo.option.NontransactionalWrite");
}
/** Reports whether RetainValues is supported. */
public boolean isRetainValuesSupported()
{
return getPMF().supportedOptions().contains(
"javax.jdo.option.RetainValues");
}
/** Reports whether Optimistic is supported. */
public boolean isOptimisticSupported() {
return getPMF().supportedOptions().contains(
"javax.jdo.option.Optimistic");
}
/** Reports whether Application Identity is supported. */
public boolean isApplicationIdentitySupported() {
return getPMF().supportedOptions().contains(
"javax.jdo.option.ApplicationIdentity");
}
/** Reports whether Datastore Identity is supported. */
public boolean isDatastoreIdentitySupported() {
return getPMF().supportedOptions().contains(
"javax.jdo.option.DatastoreIdentity");
}
/** Reports whether Non-Durable Identity is supported. */
public boolean isNonDurableIdentitySupported() {
return getPMF().supportedOptions().contains(
"javax.jdo.option.NonDurableIdentity");
}
/** Reports whether an <code>ArrayList</code> collection is supported. */
public boolean isArrayListSupported() {
return getPMF().supportedOptions().contains(
"javax.jdo.option.ArrayList");
}
/** Reports whether a <code>HashMap</code> collection is supported. */
public boolean isHashMapSupported() {
return getPMF().supportedOptions().contains(
"javax.jdo.option.HashMap");
}
/** Reports whether a <code>Hashtable</code> collection is supported. */
public boolean isHashtableSupported() {
return getPMF().supportedOptions().contains(
"javax.jdo.option.Hashtable");
}
/** Reports whether a <code>LinkedList</code> collection is supported. */
public boolean isLinkedListSupported() {
return getPMF().supportedOptions().contains(
"javax.jdo.option.LinkedList");
}
/** Reports whether a <code>TreeMap</code> collection is supported. */
public boolean isTreeMapSupported() {
return getPMF().supportedOptions().contains(
"javax.jdo.option.TreeMap");
}
/** Reports whether a <code>TreeSet</code> collection is supported. */
public boolean isTreeSetSupported() {
return getPMF().supportedOptions().contains(
"javax.jdo.option.TreeSet");
}
/** Reports whether a <code>Vector</code> collection is supported. */
public boolean isVectorSupported() {
return getPMF().supportedOptions().contains(
"javax.jdo.option.Vector");
}
/** Reports whether a <code>Map</code> collection is supported. */
public boolean isMapSupported() {
return getPMF().supportedOptions().contains(
"javax.jdo.option.Map");
}
/** Reports whether a <code>List</code> collection is supported. */
public boolean isListSupported() {
return getPMF().supportedOptions().contains(
"javax.jdo.option.List");
}
/** Reports whether arrays are supported. */
public boolean isArraySupported() {
return getPMF().supportedOptions().contains(
"javax.jdo.option.Array");
}
/** Reports whether a null collection is supported. */
public boolean isNullCollectionSupported() {
return getPMF().supportedOptions().contains(
"javax.jdo.option.NullCollection");
}
/** Reports whether Changing Application Identity is supported. */
public boolean isChangeApplicationIdentitySupported() {
return getPMF().supportedOptions().contains(
"javax.jdo.option.ChangeApplicationIdentity");
}
/** Reports whether Binary Compatibility is supported. */
public boolean isBinaryCompatibilitySupported() {
return getPMF().supportedOptions().contains(
"javax.jdo.option.BinaryCompatibility");
}
/** Reports whether UnconstrainedVariables is supported. */
public boolean isUnconstrainedVariablesSupported() {
return getPMF().supportedOptions().contains(
"javax.jdo.option.UnconstrainedVariables");
}
/** Reports whether SQL queries are supported. */
public boolean isSQLSupported() {
return getPMF().supportedOptions().contains(
"javax.jdo.query.SQL");
}
/** Reports whether getting the DataStoreConnection is supported. */
public boolean isDataStoreConnectionSupported() {
return getPMF().supportedOptions().contains(
"javax.jdo.option.GetDataStoreConnection");
}
/**
* Determine if a class is loadable in the current environment.
*/
public static boolean isClassLoadable(String className) {
try {
Class.forName(className);
return true;
} catch (ClassNotFoundException ex) {
return false;
}
}
/**
* Determine if the environment is 1.4 version of JRE or better.
*/
public static boolean isJRE14orBetter() {
return isClassLoadable("java.util.Currency");
}
/**
* This utility method returns a <code>String</code> that indicates the
* current state of an instance.
* @param o The object.
* @return The current state of the instance, by using the
* <code>JDOHelper</code> state interrogation methods.
*/
public static String getStateOfInstance(Object o)
{
boolean existingEntries = false;
StringBuffer buff = new StringBuffer("{");
if( JDOHelper.isPersistent(o) ){
buff.append("persistent");
existingEntries = true;
}
if( JDOHelper.isTransactional(o) ){
if( existingEntries ) buff.append(", ");
buff.append("transactional");
existingEntries = true;
}
if( JDOHelper.isDirty(o) ){
if( existingEntries ) buff.append(", ");
buff.append("dirty");
existingEntries = true;
}
if( JDOHelper.isNew(o) ){
if( existingEntries ) buff.append(", ");
buff.append("new");
existingEntries = true;
}
if( JDOHelper.isDeleted(o) ){
if( existingEntries ) buff.append(", ");
buff.append("deleted");
}
if( JDOHelper.isDetached(o) ){
if( existingEntries ) buff.append(", ");
buff.append("detached");
}
buff.append("}");
return buff.toString();
}
/**
* This method will return the current lifecycle state of an instance.
*/
public static int currentState(Object o)
{
boolean[] status = new boolean[NUM_STATUSES];
status[IS_PERSISTENT] = JDOHelper.isPersistent(o);
status[IS_TRANSACTIONAL] = JDOHelper.isTransactional(o);
status[IS_DIRTY] = JDOHelper.isDirty(o);
status[IS_NEW] = JDOHelper.isNew(o);
status[IS_DELETED] = JDOHelper.isDeleted(o);
status[IS_DETACHED] = JDOHelper.isDetached(o);
int i, j;
outerloop:
for( i = 0; i < NUM_STATES; ++i ){
for( j = 0; j < NUM_STATUSES; ++j ){
if( status[j] != state_statuses[i][j] )
continue outerloop;
}
return i;
}
return NUM_STATES;
}
/**
* Tests if a found state matches an expected state.
*/
public static boolean compareStates(int found_state, int expected_state)
{
// status interrogation gives same values for PERSISTENT_NONTRANSACTIONAL and HOLLOW
return (expected_state < 0
|| found_state == expected_state
|| (found_state == HOLLOW && expected_state == PERSISTENT_NONTRANSACTIONAL)
|| (found_state == PERSISTENT_NONTRANSACTIONAL && expected_state == HOLLOW));
}
/** This method mangles an object by changing all its non-static,
* non-final fields.
* It returns true if the object was mangled, and false if there
* are no fields to mangle.
*/
protected boolean mangleObject (Object oid)
throws Exception {
Field[] fields = getModifiableFields(oid);
if (fields.length == 0) return false;
for (int i = 0; i < fields.length; ++i) {
Field field = fields[i];
Class fieldType = field.getType();
if (fieldType == long.class) {
field.setLong(oid, 10000L + field.getLong(oid));
} else if (fieldType == int.class) {
field.setInt(oid, 10000 + field.getInt(oid));
} else if (fieldType == short.class) {
field.setShort(oid, (short)(10000 + field.getShort(oid)));
} else if (fieldType == byte.class) {
field.setByte(oid, (byte)(100 + field.getByte(oid)));
} else if (fieldType == char.class) {
field.setChar(oid, (char)(10 + field.getChar(oid)));
} else if (fieldType == String.class) {
field.set(oid, "This is certainly a challenge" + (String)field.get(oid));
} else if (fieldType == Integer.class) {
field.set(oid, new Integer(10000 + ((Integer)field.get(oid)).intValue()));
} else if (fieldType == Long.class) {
field.set(oid, new Long(10000L + ((Long)field.get(oid)).longValue()));
} else if (fieldType == Short.class) {
field.set(oid, new Short((short)(10000 + ((Short)field.get(oid)).shortValue())));
} else if (fieldType == Byte.class) {
field.set(oid, new Byte((byte)(100 + ((Byte)field.get(oid)).byteValue())));
} else if (fieldType == Character.class) {
field.set(oid, new Character((char)(10 + ((Character)(field.get(oid))).charValue())));
}
}
return true;
}
/** Returns modifiable Fields of the class of the parameter.
* Fields are considered modifiable if they are not static or final.
* This method requires several permissions in order to run with
* a SecurityManager, hence the doPrivileged block:
* <ul>
* <li>ReflectPermission("suppressAccessChecks")</li>
* <li>RuntimePermission("accessDeclaredMembers")</li>
* </ul>
*/
protected Field[] getModifiableFields(final Object obj) {
return (Field[])AccessController.doPrivileged(
new PrivilegedAction () {
public Object run () {
Class cls = obj.getClass();
List result = new ArrayList();
Field[] fields = cls.getFields();
for (int i = 0; i < fields.length; ++i) {
Field field = fields[i];
int modifiers = field.getModifiers();
if (Modifier.isFinal(modifiers) ||
Modifier.isStatic(modifiers))
continue;
field.setAccessible(true);
result.add(field);
}
return result.toArray(new Field[result.size()]);
}
}
);
}
/**
* Returns <code>true</code> if the current test runs with application
* identity. This means the system property jdo.tck.identitytype has the
* value applicationidentity.
* @return <code>true</code> if current test runs with application
* identity; <code>false</code> otherwise:
*/
public boolean runsWithApplicationIdentity() {
return APPLICATION_IDENTITY.equals(identitytype);
}
/**
* Prints a message (if debug is true) saying the test with the
* specified name is not executed, because the JDO implementation under
* test is run for an inapplicable identity type.
* @param testName the name of the test method that is skipped.
* @param requiredIdentityType the name of the required identity type.
*/
protected void printNonApplicableIdentityType(
String testName, String requiredIdentityType) {
if (debug) {
logger.debug(
"Test " + testName +
" was not run, because it is only applicable for identity type " +
requiredIdentityType +
". The identity type of the current configuration is " +
identitytype);
}
}
/**
* Returns the value of the PMF property
* given by argument <code>key</code>.
* @param key the key
* @return the value
*/
protected String getPMFProperty(String key) {
return PMFPropertiesObject.getProperty(key);
}
/**
* Returns <code>true</code> if the implementation under test
* supports all JDO options contained in system property
* <code>jdo.tck.requiredOptions</code>.
* @return <code>true</code> if the implementation under test
* supports all JDO options contained in system property
* <code>jdo.tck.requiredOptions</code>
*/
protected boolean isTestToBePerformed() {
boolean isTestToBePerformed = true;
String requiredOptions = System.getProperty("jdo.tck.requiredOptions");
Collection supportedOptions = getPMF().supportedOptions();
StringTokenizer tokenizer = new StringTokenizer(
requiredOptions, " ,;\n\r\t");
while (tokenizer.hasMoreTokens()) {
String requiredOption = tokenizer.nextToken();
logger.debug("Required option: " + requiredOption);
if (!requiredOption.equals("") &&
!supportedOptions.contains(requiredOption)) {
isTestToBePerformed = false;
printUnsupportedOptionalFeatureNotTested(
getClass().getName(), requiredOption);
}
}
return isTestToBePerformed;
}
/** New line.
*/
public static final String NL = System.getProperty("line.separator");
/** A buffer of of error messages.
*/
protected static StringBuffer messages;
/** Appends to error messages.
*/
protected static synchronized void appendMessage(String message) {
if (messages == null) {
messages = new StringBuffer(NL);
}
messages.append(message);
messages.append(NL);
}
/** Appends to error messages.
*/
protected static synchronized void deferredAssertTrue(boolean test,
String context, String message) {
if (!test) {
appendMessage(context + ": " +message);
}
}
/**
* Returns collected error messages, or <code>null</code> if there
* are none, and clears the buffer.
*/
protected static synchronized String retrieveMessages() {
if (messages == null) {
return null;
}
final String msg = messages.toString();
messages = null;
return msg;
}
/**
* Fail the test if there are any error messages.
*/
protected void failOnError() {
String errors = retrieveMessages();
if (errors != null) {
fail (errors);
}
}
}