" */
paramString = (String)param;
if (paramString.length() < 3) {
throw new JDOUserException(
msg.msg("EXC_ObjectIdentityStringConstructionTooShort") + //NOI18N
msg.msg("EXC_ObjectIdentityStringConstructionUsage", //NOI18N
paramString));
}
int indexOfDelimiter = paramString.indexOf(STRING_DELIMITER);
if (indexOfDelimiter < 0) {
throw new JDOUserException(
msg.msg("EXC_ObjectIdentityStringConstructionNoDelimiter") + //NOI18N
msg.msg("EXC_ObjectIdentityStringConstructionUsage", //NOI18N
paramString));
}
keyString = paramString.substring(indexOfDelimiter+1);
className = paramString.substring(0, indexOfDelimiter);
keyAsObject = helper.construct(className, keyString);
} else {
keyAsObject = param;
}
hashCode = hashClassName() ^ keyAsObject.hashCode();
}
/** Constructor only for Externalizable.
*/
public ObjectIdentity () {
}
/** Return the key.
* @return the key
*/
public Object getKey () {
return keyAsObject;
}
/** Return the String form of the object id. The class of the
* object id is written as the first part of the result so that
* the class can be reconstructed later. Then the toString
* of the key instance is appended. During construction,
* this process is reversed. The class is extracted from
* the first part of the String, and the String constructor
* of the key is used to construct the key itself.
* @return the String form of the key
*/
@Override
public String toString () {
return keyAsObject.getClass().getName()
+ STRING_DELIMITER
+ keyAsObject.toString();
}
/** Determine if the other object represents the same object id.
* @param obj the other object
* @return true if both objects represent the same object id
*/
@Override
public boolean equals (Object obj) {
if (this == obj) {
return true;
} else if (!super.equals (obj)) {
return false;
} else {
ObjectIdentity other = (ObjectIdentity) obj;
return keyAsObject.equals(other.keyAsObject);
}
}
/** Provide the hash code for this instance. The hash code is the
* hash code of the contained key.
* @return the hash code
*/
@Override
public int hashCode() {
return keyAsObject.hashCode();
}
/** Determine the ordering of identity objects.
* @param o Other identity
* @return The relative ordering between the objects
* @since 2.2
*/
@SuppressWarnings("unchecked")
public int compareTo(Object o) {
if (o instanceof ObjectIdentity) {
ObjectIdentity other = (ObjectIdentity)o;
int result = super.compare(other);
if (result == 0) {
if (other.keyAsObject instanceof Comparable &&
keyAsObject instanceof Comparable) {
return ((Comparable)keyAsObject).compareTo(
(Comparable)other.keyAsObject);
}
else
{
throw new ClassCastException("The key class (" +
keyAsObject.getClass().getName() +
") does not implement Comparable");
}
} else {
return result;
}
}
else if (o == null) {
throw new ClassCastException("object is null");
}
throw new ClassCastException(this.getClass().getName() +
" != " + o.getClass().getName());
}
/** Write this object. Write the superclass first.
* @param out the output
*/
@Override
public void writeExternal(ObjectOutput out) throws IOException {
super.writeExternal (out);
out.writeObject(keyAsObject);
}
/** Read this object. Read the superclass first.
* @param in the input
*/
@Override
public void readExternal(ObjectInput in)
throws IOException, ClassNotFoundException {
super.readExternal (in);
keyAsObject = in.readObject();
}
}
api/src/java/javax/jdo/identity/package.html 100664 2005 12500110371 21342 0 ustar mbouschen staff 0 0
Identity package
PersistenceCapable class that provides callback methods for life
* cycle events implements this interface.
*
* For JDO 2.0, InstanceCallbacks has been refactored to extend
* four other interfaces, without changing any of the methods or semantics.
* This allows fine-grained control over callbacks, for
* example to allow a class to implement the load callback without
* implementing any of the other callbacks. For backward compatibility
* with JDO 1.0, the InstanceCallbacks interface is preserved.
*
*
Classes which include non-persistent fields whose values depend
* on the values of persistent fields require callbacks on specific
* JDO instance life cycle events in order to correctly populate the
* values in these fields.
*
*
The callbacks might also be used if the persistent instances
* need to be put into the runtime infrastructure of the application.
* For example, a persistent instance might notify other instances
* on changes to state. The persistent instance might be in a list of
* managed instances. When the persistent instance is made hollow,
* it can no longer generate change events, and the persistent
* instance should be removed from the list of managed instances.
*
*
To implement this, the application programmer would implement
* jdoPostLoad to put itself into the list of managed
* instances, and implement jdoPreClear to remove itself from
* the list. With JDO 1.0, the domain class would be declared to implement
* InstanceCallbacks. With JDO 2.0, the domain class
* would be declared to implement
* javax.jdo.listener.LoadCallback and
* javax.jdo.listener.ClearCallback.
*
*
Note that JDO does not manage the state of non-persistent
* fields, and when a JDO instance transitions to hollow, JDO clears
* the persistent fields. It is the programmer's responsibility to
* clear non-persistent fields so that garbage collection of
* referred instances can occur.
*
* @since 1.0
* @version 2.0
*/
public interface InstanceCallbacks
extends javax.jdo.listener.ClearCallback,
javax.jdo.listener.DeleteCallback,
javax.jdo.listener.LoadCallback,
javax.jdo.listener.StoreCallback {
}
api/src/java/javax/jdo/JDOCanRetryException.java 100664 6027 12500110371 22046 0 ustar mbouschen staff 0 0 /*
* 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.
*/
/*
* JDOCanRetryException.java
*
*/
package javax.jdo;
/** This is the base class for exceptions that can be retried.
*
* @version 1.0
*/
public class JDOCanRetryException extends JDOException {
/**
* Constructs a new JDOCanRetryException without a detail message.
*/
public JDOCanRetryException() {
}
/**
* Constructs a new JDOCanRetryException with the specified detail message.
* @param msg the detail message.
*/
public JDOCanRetryException(String msg) {
super(msg);
}
/**
* Constructs a new JDOCanRetryException with the specified detail
* message and nested Throwables.
* @param msg the detail message.
* @param nested the nested Throwable[].
*/
public JDOCanRetryException(String msg, Throwable[] nested) {
super(msg, nested);
}
/**
* Constructs a new JDOCanRetryException with the specified detail
* message and nested Throwables.
* @param msg the detail message.
* @param nested the nested Throwable.
*/
public JDOCanRetryException(String msg, Throwable nested) {
super(msg, nested);
}
/** Constructs a new JDOCanRetryException with the specified detail message
* and failed object.
* @param msg the detail message.
* @param failed the failed object.
*/
public JDOCanRetryException(String msg, Object failed) {
super(msg, failed);
}
/** Constructs a new JDOCanRetryException with the specified detail message,
* nested Throwables, and failed object.
* @param msg the detail message.
* @param nested the nested Throwable[].
* @param failed the failed object.
*/
public JDOCanRetryException(String msg, Throwable[] nested, Object failed) {
super(msg, nested, failed);
}
/** Constructs a new JDOCanRetryException with the specified detail message,
* nested Throwables, and failed object.
* @param msg the detail message.
* @param nested the nested Throwable.
* @param failed the failed object.
*/
public JDOCanRetryException(String msg, Throwable nested, Object failed) {
super(msg, nested, failed);
}
}
api/src/java/javax/jdo/JDODataStoreException.java 100664 6060 12500110371 22202 0 ustar mbouschen staff 0 0 /*
* 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.
*/
/*
* JDODataStoreException.java
*
*/
package javax.jdo;
/** This class represents data store exceptions that can be retried.
*
* @version 1.0
*/
public class JDODataStoreException extends JDOCanRetryException {
/**
* Constructs a new JDODataStoreException without a detail message.
*/
public JDODataStoreException() {
}
/**
* Constructs a new JDODataStoreException with the specified detail message.
* @param msg the detail message.
*/
public JDODataStoreException(String msg) {
super(msg);
}
/**
* Constructs a new JDODataStoreException with the specified
* detail message and nested Throwables.
* @param msg the detail message.
* @param nested the nested Throwable[].
*/
public JDODataStoreException(String msg, Throwable[] nested) {
super(msg, nested);
}
/**
* Constructs a new JDODataStoreException with the specified
* detail message and nested Throwables.
* @param msg the detail message.
* @param nested the nested Throwable.
*/
public JDODataStoreException(String msg, Throwable nested) {
super(msg, nested);
}
/** Constructs a new JDODataStoreException with the specified detail message
* and failed object.
* @param msg the detail message.
* @param failed the failed object.
*/
public JDODataStoreException(String msg, Object failed) {
super(msg, failed);
}
/** Constructs a new JDODataStoreException with the specified detail message,
* nested Throwables, and failed object.
* @param msg the detail message.
* @param nested the nested Throwable[].
* @param failed the failed object.
*/
public JDODataStoreException(String msg, Throwable[] nested, Object failed) {
super(msg, nested, failed);
}
/** Constructs a new JDODataStoreException with the specified detail message,
* nested Throwables, and failed object.
* @param msg the detail message.
* @param nested the nested Throwable.
* @param failed the failed object.
*/
public JDODataStoreException(String msg, Throwable nested, Object failed) {
super(msg, nested, failed);
}
}
api/src/java/javax/jdo/JDODetachedFieldAccessException.java 100664 5014 12500110371 24101 0 ustar mbouschen staff 0 0 /*
* 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.
*/
/*
* JDODetachedFieldAccessException.java
*
*/
package javax.jdo;
/** This class represents exceptions caused by access of an unloaded field while
* the instance is detached.
*
* @version 2.0
* @since 2.0
*/
public class JDODetachedFieldAccessException extends JDOUserException {
/**
* Constructs a new JDODetachedFieldAccessException without a
* detail message.
* @since 2.0
*/
public JDODetachedFieldAccessException() {
}
/**
* Constructs a new JDODetachedFieldAccessException with the
* specified detail message.
* @param msg the detail message.
* @since 2.0
*/
public JDODetachedFieldAccessException(String msg) {
super(msg);
}
/** Constructs a new JDODetachedFieldAccessException
* with the specified detail message
* and failed object.
* @param msg the detail message.
* @param failed the failed object.
*/
public JDODetachedFieldAccessException(String msg, Object failed) {
super(msg, failed);
}
/**
* Constructs a new JDODetachedFieldAccessException with the
* specified detail message and nested Throwables.
* @param msg the detail message.
* @param nested the nested Throwable[].
* @since 2.0
*/
public JDODetachedFieldAccessException(String msg, Throwable[] nested) {
super(msg, nested);
}
/**
* Constructs a new JDODetachedFieldAccessException with the
* specified detail message and nested Throwables.
* @param msg the detail message.
* @param nested the nested Throwable.
* @since 2.0
*/
public JDODetachedFieldAccessException(String msg, Throwable nested) {
super(msg, nested);
}
}
api/src/java/javax/jdo/JDOEnhanceException.java 100664 3770 12500110371 21662 0 ustar mbouschen staff 0 0 /*
* 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 javax.jdo;
/**
* Exception thrown when an error occurs during enhancement.
* @since 3.0
*/
public class JDOEnhanceException extends JDOException
{
/**
* Constructs a new JDOEnhanceException without a
* detail message.
*/
public JDOEnhanceException()
{
}
/**
* Constructs a new JDOEnhanceException with the
* specified detail message.
* @param msg the detail message.
*/
public JDOEnhanceException(String msg)
{
super(msg);
}
/**
* Constructs a new JDOEnhanceException with the
* specified detail message and nested Throwables.
* @param msg the detail message.
* @param nested the nested Throwable[].
*/
public JDOEnhanceException(String msg, Throwable[] nested)
{
super(msg, nested);
}
/**
* Constructs a new JDOEnhanceException with the
* specified detail message and nested Throwables.
* @param msg the detail message.
* @param nested the nested Throwable.
*/
public JDOEnhanceException(String msg, Throwable nested)
{
super(msg, nested);
}
}
api/src/java/javax/jdo/JDOEnhancer.java 100664 13052 12500110371 20177 0 ustar mbouschen staff 0 0 /*
* 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 javax.jdo;
import java.lang.instrument.ClassFileTransformer;
import java.util.Properties;
import javax.jdo.metadata.JDOMetadata;
/**
* Interface for a JDO Enhancer.
* @since 3.0
*/
public interface JDOEnhancer extends ClassFileTransformer
{
/**
* Return non-configurable properties of this JDOEnhancer.
* Properties with keys "VendorName" and "VersionNumber" are required.
* Other keys are optional.
* @return the non-configurable properties of this JDOEnhancer.
*/
Properties getProperties();
/**
* Whether to provide verbose output
* @param flag Verbose?
* @return The enhancer
*/
JDOEnhancer setVerbose(boolean flag);
/**
* Mutator to set the location where enhanced classes are written.
* Mutator to set the location where enhanced classes are written.
* If this method is not called, classes will be enhanced in place,
* overwriting the existing classes. If overwriting classes in a jar file,
* the existing files in the jar file will be written unchanged except
* for the enhanced classes. The directory name can be absolute or relative.
* @param dirName Name of the directory
* @return The enhancer
*/
JDOEnhancer setOutputDirectory(String dirName);
/**
* Mutator to set the class loader to use for loading classes.
* @param loader ClassLoader to use
* @return The enhancer
*/
JDOEnhancer setClassLoader(ClassLoader loader);
/**
* Add a persistence-unit to the items to be enhanced.
* @param persistenceUnit Name of the persistence unit
* @return The enhancer
*/
JDOEnhancer addPersistenceUnit(String persistenceUnit);
/**
* Add an in-memory class to the items to be enhanced.
* The class name should be of the form "mydomain.MyClass".
* @param className Name of the class
* @param bytes The bytes of the class
* @return The enhancer
*/
JDOEnhancer addClass(String className, byte[] bytes);
/**
* Add class(es) to the items to be enhanced.
* The class names can be absolute file names, relative file names, or
* names of CLASSPATH resources.
* @param classNames Names of the classes
* @return The enhancer
*/
JDOEnhancer addClasses(String... classNames);
/**
* Add metadata file(s) to the items to be enhanced.
* The metadata file names can be absolute file names, relative file names, or
* names of CLASSPATH resources. They should be JDO XML metadata files.
* @param metadataFiles Names of the files
* @return The enhancer
*/
JDOEnhancer addFiles(String... metadataFiles);
/**
* Add a jar file to the items to be enhanced.
* The jar file name can be absolute, or relative or a CLASSPATH resource.
* @param jarFileName Name of the jar file
* @return The enhancer
*/
JDOEnhancer addJar(String jarFileName);
/**
* Method to enhance the items specified using addJar, addFiles, addClasses, addClass,
* addPersistenceUnit.
* @return Number of classes enhanced
* @throws JDOEnhanceException if an error occurs during enhancement. If multiple
* errors occur then the nested exceptions provides this detail.
*/
int enhance();
/**
* Method to validate the items specified using addJar, addFiles, addClasses, addClass,
* addPersistenceUnit.
* @return Number of classes validated
* @throws JDOEnhanceException if an error occurs during validation. If multiple
* errors occur then the nested exceptions provides this detail.
*/
int validate();
/**
* Method to retrieve the (enhanced) bytes of the specified class.
* Only applies to the classes enhanced in the most recent enhance() call.
* If no enhance has yet been performed will throw a JDOEnhanceException.
* If the specified class hasn't been enhanced then will throw a JDOEnhanceException.
* @param className Name of the class (of the form "mydomain.MyClass")
* @return Enhanced bytes
*/
byte[] getEnhancedBytes(String className);
/**
* Method to register metadata with the enhancement process managed by this
* JDOEnhancer.
* Metadata can be created using the method {@link #newMetadata}.
* If there is already metadata registered for a class contained in this metadata
* object then a JDOUserException will be thrown.
* @param metadata The Metadata to register.
* @since 3.0
*/
void registerMetadata(JDOMetadata metadata);
/**
* Method to return a new metadata object that can be subsequently modified
* and registered with the enhancement process using the method {@link #registerMetadata}.
* @return The metadata
* @since 3.0
*/
JDOMetadata newMetadata();
}
api/src/java/javax/jdo/JDOException.java 100664 24712 12500110371 20417 0 ustar mbouschen staff 0 0 /*
* 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.
*/
/*
* JDOException.java
*
*/
package javax.jdo;
import javax.jdo.spi.I18NHelper;
/** This is the root of all JDO Exceptions. It contains an optional detail
* message, an optional nested Throwable array and an optional failed object.
* @author Craig Russell
* @version 1.0.2
*/
public class JDOException extends java.lang.RuntimeException {
/** This exception was generated because of an exception in the runtime library.
* @serial the nested Throwable array
*/
Throwable[] nested;
/** This exception may be the result of incorrect parameters supplied
* to an API. This is the object from which the user can determine
* the cause of the problem.
* @serial the failed Object
*/
Object failed;
/** The Internationalization message helper.
*/
private static I18NHelper msg = I18NHelper.getInstance ("javax.jdo.Bundle"); //NOI18N
/** Flag indicating whether printStackTrace is being executed.
*/
private boolean inPrintStackTrace = false;
/**
* Constructs a new JDOException without a detail message.
*/
public JDOException() {
}
/**
* Constructs a new JDOException with the specified detail message.
* @param msg the detail message.
*/
public JDOException(String msg) {
super(msg);
}
/** Constructs a new JDOException with the specified detail message
* and nested Throwables.
* @param msg the detail message.
* @param nested the nested Throwable[].
*/
public JDOException(String msg, Throwable[] nested) {
super(msg);
this.nested = nested;
}
/** Constructs a new JDOException with the specified detail message
* and nested Throwable.
* @param msg the detail message.
* @param nested the nested Throwable.
*/
public JDOException(String msg, Throwable nested) {
super(msg);
this.nested = new Throwable[] {nested};
}
/** Constructs a new JDOException with the specified detail message
* and failed object.
* @param msg the detail message.
* @param failed the failed object.
*/
public JDOException(String msg, Object failed) {
super(msg);
this.failed = failed;
}
/** Constructs a new JDOException with the specified detail message,
* nested Throwables, and failed object.
* @param msg the detail message.
* @param nested the nested Throwable[].
* @param failed the failed object.
*/
public JDOException(String msg, Throwable[] nested, Object failed) {
super(msg);
this.nested = nested;
this.failed = failed;
}
/** Constructs a new JDOException with the specified detail message,
* nested Throwable, and failed object.
* @param msg the detail message.
* @param nested the nested Throwable.
* @param failed the failed object.
*/
public JDOException(String msg, Throwable nested, Object failed) {
super(msg);
this.nested = new Throwable[] {nested};
this.failed = failed;
}
/** The exception may include a failed object.
* @return the failed object.
*/
public Object getFailedObject() {
return failed;
}
/** The exception may have been caused by multiple exceptions in the runtime.
* If multiple objects caused the problem, each failed object will have
* its own Exception.
* @return the nested Throwable array.
*/
public Throwable[] getNestedExceptions() {
return nested;
}
/** Often there is only one nested exception, and this method returns it.
* If there are more than one, then this method returns the first nested
* exception. If there is no nested exception, then null is returned.
* @return the first or only nested Throwable.
* @since 1.0.1
*/
public synchronized Throwable getCause() {
// super.printStackTrace calls getCause to handle the cause.
// Returning null prevents the superclass from handling the cause;
// instead the local implementation of printStackTrace should
// handle the cause. Otherwise, the cause is printed twice.
if (nested == null || nested.length == 0 || inPrintStackTrace) {
return null;
} else {
return nested[0];
}
}
/** JDK 1.4 includes a new chaining mechanism for Throwable, but since
* JDO has its own "legacy" chaining mechanism, the "standard" mechanism
* cannot be used. This method always throws a JDOFatalInternalException.
* @param cause ignored.
* @return never.
*/
public Throwable initCause(Throwable cause) {
throw new JDOFatalInternalException(msg.msg("ERR_CannotInitCause"));
}
/** The String representation includes the name of the class,
* the descriptive comment (if any),
* the String representation of the failed Object (if any),
* and the String representation of the nested Throwables (if any).
* @return the String.
*/
public synchronized String toString() {
int len = nested==null?0:nested.length;
// calculate approximate size of the String to return
StringBuffer sb = new StringBuffer (10 + 100 * len);
sb.append (super.toString());
// include failed object information
if (failed != null) {
sb.append ("\n").append (msg.msg ("MSG_FailedObject"));
String failedToString = null;
try {
failedToString = failed.toString();
} catch (Exception ex) {
// include the information from the exception thrown by failed.toString
Object objectId = JDOHelper.getObjectId(failed);
if (objectId == null) {
failedToString = msg.msg("MSG_ExceptionGettingFailedToString", //NOI18N
exceptionToString(ex));
}
else {
// include the ObjectId information
String objectIdToString = null;
try {
objectIdToString = objectId.toString();
}
catch (Exception ex2) {
objectIdToString = exceptionToString(ex2);
}
failedToString = msg.msg("MSG_ExceptionGettingFailedToStringObjectId", //NOI18N
exceptionToString(ex), objectIdToString);
}
}
sb.append (failedToString);
}
// include nested Throwable information, but only if not called by
// printStackTrace; the stacktrace will include the cause anyway.
if (len > 0 && !inPrintStackTrace) {
sb.append ("\n").append (msg.msg ("MSG_NestedThrowables")).append ("\n");
Throwable exception = nested[0];
sb.append (exception==null?"null":exception.toString()); //NOI18N
for (int i=1; iJDOException and its backtrace to the
* standard error output.
* Print nested Throwables' stack trace as well.
*/
public void printStackTrace() {
printStackTrace (System.err);
}
/**
* Prints this JDOException and its backtrace to the
* specified print stream.
* Print nested Throwables' stack trace as well.
* @param s PrintStream to use for output
*/
public synchronized void printStackTrace(java.io.PrintStream s) {
int len = nested==null?0:nested.length;
synchronized (s) {
inPrintStackTrace = true;
super.printStackTrace(s);
if (len > 0) {
s.println (msg.msg ("MSG_NestedThrowablesStackTrace"));
for (int i=0; iJDOException and its backtrace to the specified
* print writer.
* Print nested Throwables' stack trace as well.
* @param s PrintWriter to use for output
*/
public synchronized void printStackTrace(java.io.PrintWriter s) {
int len = nested==null?0:nested.length;
synchronized (s) {
inPrintStackTrace = true;
super.printStackTrace(s);
if (len > 0) {
s.println (msg.msg ("MSG_NestedThrowablesStackTrace"));
for (int i=0; iJDOFatalDataStoreException without a detail message.
*/
public JDOFatalDataStoreException() {
}
/**
* Constructs a new JDOFatalDataStoreException with the specified detail message.
* @param msg the detail message.
*/
public JDOFatalDataStoreException(String msg) {
super(msg);
}
/** Constructs a new JDOFatalDataStoreException with the specified detail message
* and failed object.
* @param msg the detail message.
* @param failed the failed object.
*/
public JDOFatalDataStoreException(String msg, Object failed) {
super(msg, failed);
}
/**
* Constructs a new JDOFatalDataStoreException with the specified
* detail message and nested Throwables.
* @param msg the detail message.
* @param nested the nested Throwable[].
*/
public JDOFatalDataStoreException(String msg, Throwable[] nested) {
super(msg, nested);
}
/**
* Constructs a new JDOFatalDataStoreException with the specified
* detail message and nested Throwables.
* @param msg the detail message.
* @param nested the nested Throwable.
*/
public JDOFatalDataStoreException(String msg, Throwable nested) {
super(msg, nested);
}
/**
* Constructs a new JDOFatalDataStoreException with the specified
* detail message, nested Throwables, and failed object.
* @param msg the detail message.
* @param nested the nested Throwable[].
* @param failed the failed object.
*/
public JDOFatalDataStoreException(String msg, Throwable[] nested, Object failed) {
super(msg, nested, failed);
}
/**
* Constructs a new JDOFatalDataStoreException with the specified
* detail message, nested Throwables, and failed object.
* @param msg the detail message.
* @param nested the nested Throwable.
* @param failed the failed object.
*/
public JDOFatalDataStoreException(String msg, Throwable nested, Object failed) {
super(msg, nested, failed);
}
}
api/src/java/javax/jdo/JDOFatalException.java 100664 6074 12500110371 21350 0 ustar mbouschen staff 0 0 /*
* 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.
*/
/*
* JDOFatalException.java
*
*/
package javax.jdo;
/** This class represents exceptions that are fatal; that is, the condition
* that caused it cannot be bypassed even if the operation is retried.
*
* @version 1.0
*/
public class JDOFatalException extends JDOException {
/**
* Constructs a new JDOFatalException without a detail message.
*/
public JDOFatalException() {
}
/**
* Constructs a new JDOFatalException with the specified detail message.
* @param msg the detail message.
*/
public JDOFatalException(String msg) {
super(msg);
}
/**
* Constructs a new JDOFatalException with the specified detail
* message and nested Throwables.
* @param msg the detail message.
* @param nested the nested Throwable[].
*/
public JDOFatalException(String msg, Throwable[] nested) {
super(msg, nested);
}
/**
* Constructs a new JDOFatalException with the specified detail
* message and nested Throwables.
* @param msg the detail message.
* @param nested the nested Throwable.
*/
public JDOFatalException(String msg, Throwable nested) {
super(msg, nested);
}
/** Constructs a new JDOFatalException with the specified detail message
* and failed object.
* @param msg the detail message.
* @param failed the failed object.
*/
public JDOFatalException(String msg, Object failed) {
super(msg, failed);
}
/** Constructs a new JDOFatalException with the specified detail message,
* nested Throwables, and failed object.
* @param msg the detail message.
* @param nested the nested Throwable[].
* @param failed the failed object.
*/
public JDOFatalException(String msg, Throwable[] nested, Object failed) {
super(msg, nested, failed);
}
/** Constructs a new JDOFatalException with the specified detail message,
* nested Throwables, and failed object.
* @param msg the detail message.
* @param nested the nested Throwable.
* @param failed the failed object.
*/
public JDOFatalException(String msg, Throwable nested, Object failed) {
super(msg, nested, failed);
}
}
api/src/java/javax/jdo/JDOFatalInternalException.java 100664 6346 12500110371 23047 0 ustar mbouschen staff 0 0 /*
* 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.
*/
/*
* JDOFatalInternalException.java
*
*/
package javax.jdo;
/** This class represents errors in the implementation for which no user
* error handling is possible. The error should be reported to the JDO
* vendor for corrective action.
*
* @version 1.0
*/
public class JDOFatalInternalException extends JDOFatalException {
/**
* Constructs a new JDOFatalInternalException without a detail message.
*/
public JDOFatalInternalException() {
}
/**
* Constructs a new JDOFatalInternalException with the specified detail message.
* @param msg the detail message.
*/
public JDOFatalInternalException(String msg) {
super(msg);
}
/**
* Constructs a new JDOFatalInternalException with the specified
* detail message and nested Throwables.
* @param msg the detail message.
* @param nested the nested Throwable[].
*/
public JDOFatalInternalException(String msg, Throwable[] nested) {
super(msg, nested);
}
/**
* Constructs a new JDOFatalInternalException with the specified
* detail message and nested Throwables.
* @param msg the detail message.
* @param nested the nested Throwable.
*/
public JDOFatalInternalException(String msg, Throwable nested) {
super(msg, nested);
}
/**
* Constructs a new JDOFatalInternalException
* with the specified detail message and failed object.
* @param msg the detail message.
* @param failed the failed object.
*/
public JDOFatalInternalException(String msg, Object failed) {
super(msg, failed);
}
/**
* Constructs a new JDOFatalInternalException with the specified
* detail message, nested Throwables, and failed object.
* @param msg the detail message.
* @param nested the nested Throwable[].
* @param failed the failed object.
*/
public JDOFatalInternalException(String msg, Throwable[] nested, Object failed) {
super(msg, nested, failed);
}
/**
* Constructs a new JDOFatalInternalException with the specified
* detail message, nested Throwables, and failed object.
* @param msg the detail message.
* @param nested the nested Throwable.
* @param failed the failed object.
*/
public JDOFatalInternalException(String msg, Throwable nested, Object failed) {
super(msg, nested, failed);
}
}
api/src/java/javax/jdo/JDOFatalUserException.java 100664 6047 12500110371 22207 0 ustar mbouschen staff 0 0 /*
* 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.
*/
/*
* JDOUserException.java
*
*/
package javax.jdo;
/** This class represents user errors that cannot be retried.
*
* @version 1.0
*/
public class JDOFatalUserException extends JDOFatalException {
/**
* Constructs a new JDOFatalUserException without a detail message.
*/
public JDOFatalUserException() {
}
/**
* Constructs a new JDOFatalUserException with the specified detail message.
* @param msg the detail message.
*/
public JDOFatalUserException(String msg) {
super(msg);
}
/**
* Constructs a new JDOFatalUserException with the specified
* detail message and nested Throwables.
* @param msg the detail message.
* @param nested the nested Throwable[].
*/
public JDOFatalUserException(String msg, Throwable[] nested) {
super(msg, nested);
}
/**
* Constructs a new JDOFatalUserException with the specified
* detail message and nested Throwables.
* @param msg the detail message.
* @param nested the nested Throwable.
*/
public JDOFatalUserException(String msg, Throwable nested) {
super(msg, nested);
}
/** Constructs a new JDOFatalUserException with the specified
* detail message and failed object.
* @param msg the detail message.
* @param failed the failed object.
*/
public JDOFatalUserException(String msg, Object failed) {
super(msg, failed);
}
/** Constructs a new JDOFatalUserException with the specified
* detail message, nested Throwables, and failed object.
* @param msg the detail message.
* @param nested the nested Throwable[].
* @param failed the failed object.
*/
public JDOFatalUserException(String msg, Throwable[] nested, Object failed) {
super(msg, nested, failed);
}
/** Constructs a new JDOFatalUserException with the specified
* detail message, nested Throwables, and failed object.
* @param msg the detail message.
* @param nested the nested Throwable.
* @param failed the failed object.
*/
public JDOFatalUserException(String msg, Throwable nested, Object failed) {
super(msg, nested, failed);
}
}
api/src/java/javax/jdo/JDOHelper.java 100664 244711 12500110371 17723 0 ustar mbouschen staff 0 0 /*
* 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.
*/
/*
* JDOHelper.java
*
*/
package javax.jdo;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.URL;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.security.PrivilegedActionException;
import java.security.PrivilegedExceptionAction;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import javax.jdo.spi.I18NHelper;
import javax.jdo.spi.JDOImplHelper;
import javax.jdo.spi.JDOImplHelper.StateInterrogationBooleanReturn;
import javax.jdo.spi.JDOImplHelper.StateInterrogationObjectReturn;
import javax.jdo.spi.PersistenceCapable;
import javax.jdo.spi.StateInterrogation;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import javax.rmi.PortableRemoteObject;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.FactoryConfigurationError;
import javax.xml.parsers.ParserConfigurationException;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.ErrorHandler;
import org.xml.sax.SAXException;
import org.xml.sax.SAXParseException;
/**
* This class can be used by a JDO-aware application to call the JDO behavior
* of PersistenceCapable instances without declaring them to be
* PersistenceCapable.
* It is also used to acquire a PersistenceManagerFactory via
* various methods.
*
This helper class defines static methods that allow a JDO-aware
* application to examine the runtime state of instances. For example,
* an application can discover whether the instance is persistent,
* transactional, dirty, new, deleted, or detached; and to get its associated
* PersistenceManager if it has one.
*
* @version 2.1
*/
public class JDOHelper implements Constants {
/**
* A mapping from jdoconfig.xsd element attributes to PMF properties.
*/
static final Map ATTRIBUTE_PROPERTY_XREF
= createAttributePropertyXref();
/** The Internationalization message helper.
*/
private final static I18NHelper msg =
I18NHelper.getInstance ("javax.jdo.Bundle"); //NOI18N
/**
* Creates a map from jdoconfig.xsd element attributes to PMF properties.
* @return An unmodifiable Map of jdoconfig.xsd element attributes to PMF
* properties.
*/
static Map createAttributePropertyXref() {
Map xref = new HashMap();
xref.put(
PMF_ATTRIBUTE_CLASS,
PROPERTY_PERSISTENCE_MANAGER_FACTORY_CLASS);
xref.put(
PMF_ATTRIBUTE_CONNECTION_DRIVER_NAME,
PROPERTY_CONNECTION_DRIVER_NAME);
xref.put(
PMF_ATTRIBUTE_CONNECTION_FACTORY_NAME,
PROPERTY_CONNECTION_FACTORY_NAME);
xref.put(
PMF_ATTRIBUTE_CONNECTION_FACTORY2_NAME,
PROPERTY_CONNECTION_FACTORY2_NAME);
xref.put(
PMF_ATTRIBUTE_CONNECTION_PASSWORD,
PROPERTY_CONNECTION_PASSWORD);
xref.put(
PMF_ATTRIBUTE_CONNECTION_URL,
PROPERTY_CONNECTION_URL);
xref.put(
PMF_ATTRIBUTE_CONNECTION_USER_NAME,
PROPERTY_CONNECTION_USER_NAME);
xref.put(
PMF_ATTRIBUTE_IGNORE_CACHE,
PROPERTY_IGNORE_CACHE);
xref.put(
PMF_ATTRIBUTE_MAPPING,
PROPERTY_MAPPING);
xref.put(
PMF_ATTRIBUTE_MULTITHREADED,
PROPERTY_MULTITHREADED);
xref.put(
PMF_ATTRIBUTE_NONTRANSACTIONAL_READ,
PROPERTY_NONTRANSACTIONAL_READ);
xref.put(
PMF_ATTRIBUTE_NONTRANSACTIONAL_WRITE,
PROPERTY_NONTRANSACTIONAL_WRITE);
xref.put(
PMF_ATTRIBUTE_OPTIMISTIC,
PROPERTY_OPTIMISTIC);
xref.put(
PMF_ATTRIBUTE_PERSISTENCE_UNIT_NAME,
PROPERTY_PERSISTENCE_UNIT_NAME);
xref.put(
PMF_ATTRIBUTE_NAME,
PROPERTY_NAME);
xref.put(
PMF_ATTRIBUTE_RESTORE_VALUES,
PROPERTY_RESTORE_VALUES);
xref.put(
PMF_ATTRIBUTE_RETAIN_VALUES,
PROPERTY_RETAIN_VALUES);
xref.put(
PMF_ATTRIBUTE_DETACH_ALL_ON_COMMIT,
PROPERTY_DETACH_ALL_ON_COMMIT);
xref.put(
PMF_ATTRIBUTE_SERVER_TIME_ZONE_ID,
PROPERTY_SERVER_TIME_ZONE_ID);
xref.put(
PMF_ATTRIBUTE_DATASTORE_READ_TIMEOUT_MILLIS,
PROPERTY_DATASTORE_READ_TIMEOUT_MILLIS);
xref.put(
PMF_ATTRIBUTE_DATASTORE_WRITE_TIMEOUT_MILLIS,
PROPERTY_DATASTORE_WRITE_TIMEOUT_MILLIS);
return Collections.unmodifiableMap(xref);
}
/** The JDOImplHelper instance used for handling non-binary-compatible
* implementations.
*/
private static JDOImplHelper implHelper = (JDOImplHelper)
AccessController.doPrivileged(
new PrivilegedAction () {
public JDOImplHelper run () {
return JDOImplHelper.getInstance();
}
}
);
/** The singleton instance of JDOHelper.
* @since 2.1
*/
private static JDOHelper instance = new JDOHelper();
/**
* Return the singleton instance of JDOHelper. This instance is
* thread-safe.
* @since 2.1
* @return the thread-safe singleton JDOHelper
*/
public static JDOHelper getInstance() {
return instance;
}
/** Some applications might prefer to use instance
* methods instead of static methods.
* @since 2.1
*/
public JDOHelper() {}
/** The stateless instance used for handling non-binary-compatible
* implementations of getPersistenceManager.
*/
static StateInterrogationObjectReturn getPersistenceManager =
new StateInterrogationObjectReturn() {
public Object get(Object pc, StateInterrogation si) {
return si.getPersistenceManager(pc);
}
};
/** The stateless instance used for handling non-binary-compatible
* implementations of getObjectId.
*/
static StateInterrogationObjectReturn getObjectId =
new StateInterrogationObjectReturn() {
public Object get(Object pc, StateInterrogation si) {
return si.getObjectId(pc);
}
};
/** The stateless instance used for handling non-binary-compatible
* implementations of getTransactionalObjectId.
*/
static StateInterrogationObjectReturn getTransactionalObjectId =
new StateInterrogationObjectReturn() {
public Object get(Object pc, StateInterrogation si) {
return si.getTransactionalObjectId(pc);
}
};
/** The stateless instance used for handling non-binary-compatible
* implementations of getVersion.
*/
static StateInterrogationObjectReturn getVersion =
new StateInterrogationObjectReturn() {
public Object get(Object pc, StateInterrogation si) {
return si.getVersion(pc);
}
};
/** The stateless instance used for handling non-binary-compatible
* implementations of isPersistent.
*/
static StateInterrogationBooleanReturn isPersistent =
new StateInterrogationBooleanReturn() {
public Boolean is(Object pc, StateInterrogation si) {
return si.isPersistent(pc);
}
};
/** The stateless instance used for handling non-binary-compatible
* implementations of isTransactional.
*/
static StateInterrogationBooleanReturn isTransactional =
new StateInterrogationBooleanReturn() {
public Boolean is(Object pc, StateInterrogation si) {
return si.isTransactional(pc);
}
};
/** The stateless instance used for handling non-binary-compatible
* implementations of isDirty.
*/
static StateInterrogationBooleanReturn isDirty =
new StateInterrogationBooleanReturn() {
public Boolean is(Object pc, StateInterrogation si) {
return si.isDirty(pc);
}
};
/** The stateless instance used for handling non-binary-compatible
* implementations of isNew.
*/
static StateInterrogationBooleanReturn isNew =
new StateInterrogationBooleanReturn() {
public Boolean is(Object pc, StateInterrogation si) {
return si.isNew(pc);
}
};
/** The stateless instance used for handling non-binary-compatible
* implementations of isDeleted.
*/
static StateInterrogationBooleanReturn isDeleted =
new StateInterrogationBooleanReturn() {
public Boolean is(Object pc, StateInterrogation si) {
return si.isDeleted(pc);
}
};
/** The stateless instance used for handling non-binary-compatible
* implementations of isDetached.
*/
static StateInterrogationBooleanReturn isDetached =
new StateInterrogationBooleanReturn() {
public Boolean is(Object pc, StateInterrogation si) {
return si.isDetached(pc);
}
};
/** Return the associated PersistenceManager if there is one.
* Transactional and persistent instances return the associated
* PersistenceManager.
*
* Transient non-transactional instances and instances of classes
* that do not implement PersistenceCapable return
* null.
* @see PersistenceCapable#jdoGetPersistenceManager()
* @param pc the PersistenceCapable instance.
* @return the PersistenceManager associated with the parameter
* instance.
*/
public static PersistenceManager getPersistenceManager(Object pc) {
if (pc instanceof PersistenceCapable) {
return ((PersistenceCapable)pc).jdoGetPersistenceManager();
} else {
return (PersistenceManager)
implHelper.nonBinaryCompatibleGet(pc, getPersistenceManager);
}
}
/** Explicitly mark the parameter instance and field dirty.
* Normally, PersistenceCapable classes are able to detect
* changes made to their fields. However, if a reference to an array is
* given to a method outside the class, and the array is modified, then the
* persistent instance is not aware of the change. This API allows the
* application to notify the instance that a change was made to a field.
*
*
Transient instances and instances of classes
* that do not implement PersistenceCapable ignore this method.
* @see PersistenceCapable#jdoMakeDirty(String fieldName)
* @param pc the PersistenceCapable instance.
* @param fieldName the name of the field to be marked dirty.
*/
public static void makeDirty(Object pc, String fieldName) {
if (pc instanceof PersistenceCapable) {
((PersistenceCapable)pc).jdoMakeDirty(fieldName);
} else {
implHelper.nonBinaryCompatibleMakeDirty(pc, fieldName);
}
}
/** Return a copy of the JDO identity associated with the parameter
* instance.
*
*
Persistent instances of PersistenceCapable classes have a
* JDO identity managed by the PersistenceManager. This method
* returns a copy of the ObjectId that represents the JDO identity.
*
*
Transient instances and instances of classes that do not implement
* PersistenceCapable return null.
*
*
The ObjectId may be serialized
* and later restored, and used with a PersistenceManager from
* the same JDO implementation to locate a persistent instance with the same
* data store identity.
*
*
If the JDO identity is managed by the application, then the ObjectId
* may be used with a PersistenceManager from any JDO
* implementation that supports the PersistenceCapable class.
*
*
If the JDO identity is not managed by the application or the data
* store, then the ObjectId returned is only valid within the current
* transaction.
*
* @see PersistenceManager#getObjectId(Object pc)
* @see PersistenceCapable#jdoGetObjectId()
* @see PersistenceManager#getObjectById(Object oid, boolean validate)
* @param pc the PersistenceCapable instance.
* @return a copy of the ObjectId of the parameter instance as of the
* beginning of the transaction.
*/
public static Object getObjectId(Object pc) {
if (pc instanceof PersistenceCapable) {
return ((PersistenceCapable)pc).jdoGetObjectId();
} else {
return implHelper.nonBinaryCompatibleGet(pc, getObjectId);
}
}
/** Get object ids for a collection of instances. For each instance
* in the parameter, the getObjectId method is called. This method
* returns one identity instance for each element
* in the parameter. The order of iteration of the returned
* Collection exactly matches the order of iteration of the
* parameter Collection.
* @param pcs the persistence-capable instances
* @return the object ids of the parameters
* @see #getObjectId(Object pc)
* @see #getObjectIds(Object[] pcs)
* @since 2.0
*/
public static Collection getObjectIds(Collection pcs) {
ArrayList result = new ArrayList();
for (Iterator it = pcs.iterator(); it.hasNext();) {
result.add(getObjectId(it.next()));
}
return result;
}
/** Get object ids for an array of instances. For each instance
* in the parameter, the getObjectId method is called. This method
* returns one identity instance for each element
* in the parameter. The order of instances of the returned
* array exactly matches the order of instances of the
* parameter array.
* @param pcs the persistence-capable instances
* @return the object ids of the parameters
* @see #getObjectId(Object pc)
* @see #getObjectIds(Collection pcs)
* @since 2.0
*/
public static Object[] getObjectIds(Object[] pcs) {
Object[] result = new Object[pcs.length];
for (int i = 0; i < pcs.length; ++i) {
result[i] = getObjectId(pcs[i]);
}
return result;
}
/** Return a copy of the JDO identity associated with the parameter
* instance.
*
* @see PersistenceCapable#jdoGetTransactionalObjectId()
* @see PersistenceManager#getObjectById(Object oid, boolean validate)
* @param pc the PersistenceCapable instance.
* @return a copy of the ObjectId of the parameter instance as modified in
* this transaction.
*/
public static Object getTransactionalObjectId(Object pc) {
if (pc instanceof PersistenceCapable) {
return ((PersistenceCapable)pc).jdoGetTransactionalObjectId();
} else {
return implHelper.nonBinaryCompatibleGet(
pc, getTransactionalObjectId);
}
}
/**
* Return the version of the instance.
* @since 2.0
* @param pc the instance
* @return the version of the instance
*/
public static Object getVersion (Object pc) {
if (pc instanceof PersistenceCapable) {
return ((PersistenceCapable)pc).jdoGetVersion();
} else {
return implHelper.nonBinaryCompatibleGet(pc, getVersion);
}
}
/** Tests whether the parameter instance is dirty.
*
* Instances that have been modified, deleted, or newly
* made persistent in the current transaction return true.
*
*Transient instances and instances of classes that do not implement
* PersistenceCapable return false.
*
* @see javax.jdo.spi.StateManager#makeDirty(PersistenceCapable pc,
* String fieldName)
* @see PersistenceCapable#jdoIsDirty()
* @param pc the PersistenceCapable instance.
* @return true if the parameter instance has been modified in
* the current transaction.
*/
public static boolean isDirty(Object pc) {
if (pc instanceof PersistenceCapable) {
return ((PersistenceCapable)pc).jdoIsDirty();
} else {
return implHelper.nonBinaryCompatibleIs(pc, isDirty);
}
}
/** Tests whether the parameter instance is transactional.
*
* Instances whose state is associated with the current transaction
* return true.
*
*
Transient instances and instances of classes that do not implement
* PersistenceCapable return false.
* @see PersistenceCapable#jdoIsTransactional()
* @param pc the PersistenceCapable instance.
* @return true if the parameter instance is transactional.
*/
public static boolean isTransactional(Object pc) {
if (pc instanceof PersistenceCapable) {
return ((PersistenceCapable)pc).jdoIsTransactional();
} else {
return implHelper.nonBinaryCompatibleIs(pc, isTransactional);
}
}
/** Tests whether the parameter instance is persistent.
*
* Instances that represent persistent objects in the data store
* return true.
*
*
Transient instances and instances of classes that do not implement
* PersistenceCapable return false.
*
* @see PersistenceManager#makePersistent(Object pc)
* @see PersistenceCapable#jdoIsPersistent()
* @param pc the PersistenceCapable instance.
* @return true if the parameter instance is persistent.
*/
public static boolean isPersistent(Object pc) {
if (pc instanceof PersistenceCapable) {
return ((PersistenceCapable)pc).jdoIsPersistent();
} else {
return implHelper.nonBinaryCompatibleIs(pc, isPersistent);
}
}
/** Tests whether the parameter instance has been newly made persistent.
*
* Instances that have been made persistent in the current transaction
* return true.
*
*
Transient instances and instances of classes that do not implement
* PersistenceCapable return false.
*
* @see PersistenceManager#makePersistent(Object pc)
* @see PersistenceCapable#jdoIsNew()
* @param pc the PersistenceCapable instance.
* @return true if the parameter instance was made persistent
* in the current transaction.
*/
public static boolean isNew(Object pc) {
if (pc instanceof PersistenceCapable) {
return ((PersistenceCapable)pc).jdoIsNew();
} else {
return implHelper.nonBinaryCompatibleIs(pc, isNew);
}
}
/** Tests whether the parameter instance has been deleted.
*
* Instances that have been deleted in the current transaction return
* true.
*
*
Transient instances and instances of classes that do not implement
* PersistenceCapable return false.
*
* @see PersistenceManager#deletePersistent(Object pc)
* @see PersistenceCapable#jdoIsDeleted()
* @param pc the PersistenceCapable instance.
* @return true if the parameter instance was deleted
* in the current transaction.
*/
public static boolean isDeleted(Object pc) {
if (pc instanceof PersistenceCapable) {
return ((PersistenceCapable)pc).jdoIsDeleted();
} else {
return implHelper.nonBinaryCompatibleIs(pc, isDeleted);
}
}
/**
* Tests whether the parameter instance has been detached.
*
* Instances that have been detached return true.
*
*
Transient instances return false.
*
* @see PersistenceCapable#jdoIsDetached()
* @return true if this instance is detached.
* @since 2.0
* @param pc the instance
*/
public static boolean isDetached(Object pc) {
if (pc instanceof PersistenceCapable) {
return ((PersistenceCapable)pc).jdoIsDetached();
} else {
return implHelper.nonBinaryCompatibleIs(pc, isDetached);
}
}
/** Accessor for the state of the passed object.
* @param pc The object
* @return The object state
* @since 2.1
*/
public static ObjectState getObjectState(Object pc) {
if (pc == null) {
return null;
}
if (isDetached(pc)) {
if (isDirty(pc)) {
// Detached Dirty
return ObjectState.DETACHED_DIRTY;
}
else {
// Detached Not Dirty
return ObjectState.DETACHED_CLEAN;
}
}
else {
if (isPersistent(pc)) {
if (isTransactional(pc)) {
if (isDirty(pc)) {
if (isNew(pc)) {
if (isDeleted(pc)) {
// Persistent Transactional Dirty New Deleted
return ObjectState.PERSISTENT_NEW_DELETED;
} else {
// Persistent Transactional Dirty New Not Deleted
return ObjectState.PERSISTENT_NEW;
}
} else {
if (isDeleted(pc)) {
// Persistent Transactional Dirty Not New Deleted
return ObjectState.PERSISTENT_DELETED;
} else {
// Persistent Transactional Dirty Not New Not Deleted
return ObjectState.PERSISTENT_DIRTY;
}
}
} else {
// Persistent Transactional Not Dirty
return ObjectState.PERSISTENT_CLEAN;
}
}
else {
if (isDirty(pc)) {
// Persistent Nontransactional Dirty
return ObjectState.PERSISTENT_NONTRANSACTIONAL_DIRTY;
}
else {
// Persistent Nontransactional Not Dirty
return ObjectState.HOLLOW_PERSISTENT_NONTRANSACTIONAL;
}
}
}
else {
if (isTransactional(pc)) {
if (isDirty(pc)) {
// Not Persistent Transactional Dirty
return ObjectState.TRANSIENT_DIRTY;
} else {
// Not Persistent Transactional Not Dirty
return ObjectState.TRANSIENT_CLEAN;
}
}
else {
// Not Persistent Not Transactional
return ObjectState.TRANSIENT;
}
}
}
}
/** Get the anonymous PersistenceManagerFactory configured via
* the standard configuration file resource "META-INF/jdoconfig.xml", using
* the current thread's context class loader
* to locate the configuration file resource(s).
* @return the anonymous PersistenceManagerFactory.
* @since 2.1
* @see #getPersistenceManagerFactory(Map,String,ClassLoader,ClassLoader)
*/
public static PersistenceManagerFactory getPersistenceManagerFactory() {
ClassLoader cl = getContextClassLoader();
return getPersistenceManagerFactory(
null, ANONYMOUS_PERSISTENCE_MANAGER_FACTORY_NAME, cl, cl);
}
/** Get the anonymous PersistenceManagerFactory configured via
* the standard configuration file resource "META-INF/jdoconfig.xml", using
* the given class loader.
* @return the anonymous PersistenceManagerFactory.
* @param pmfClassLoader the ClassLoader used to load resources and classes
* @since 2.1
* @see #getPersistenceManagerFactory(Map,String,ClassLoader,ClassLoader)
*/
public static PersistenceManagerFactory getPersistenceManagerFactory(
ClassLoader pmfClassLoader) {
return getPersistenceManagerFactory(
null,
ANONYMOUS_PERSISTENCE_MANAGER_FACTORY_NAME,
pmfClassLoader, pmfClassLoader);
}
/** Get a PersistenceManagerFactory based on a Properties
* instance, using the current thread's context class loader to locate the
* PersistenceManagerFactory class.
* @return the PersistenceManagerFactory.
* @param props a Properties instance with properties of the
* PersistenceManagerFactory.
* @see #getPersistenceManagerFactory(java.util.Map,ClassLoader)
*/
public static PersistenceManagerFactory getPersistenceManagerFactory
(Map props) {
return getPersistenceManagerFactory(
null, props, getContextClassLoader());
}
/** Get a PersistenceManagerFactory based on a
* Map and a class loader.
* This method delegates to the getPersistenceManagerFactory
* method that takes a Map of overrides and a Map of properties,
* passing null as the overrides parameter.
* @see #getPersistenceManagerFactory(java.util.Map, java.util.Map, ClassLoader)
* @return the PersistenceManagerFactory.
* @param props a Map with properties of the
* PersistenceManagerFactory.
* @param pmfClassLoader the class loader used to load the
* PersistenceManagerFactory class
* @since 1.0
*/
public static PersistenceManagerFactory getPersistenceManagerFactory
(Map props, ClassLoader pmfClassLoader) {
return getPersistenceManagerFactory(
null, props, pmfClassLoader);
}
/**
* Get a PersistenceManagerFactory based on a
* Map of overrides, a Map of
* properties, and a class loader.
* The following are standard key names:
* "javax.jdo.PersistenceManagerFactoryClass"
*
* and properties of the form
* javax.jdo.option.InstanceLifecycleListener.{listenerClass}[=[{pcClasses}]]
* where {listenerClass} is the fully qualified name of a
* class that implements
* {@link javax.jdo.listener.InstanceLifecycleListener}, and
* {pcClasses} is an optional comma- or whitespace-delimited
* list of persistence-capable classes to be observed; the absence of a
* value for a property of this form means that instances of all
* persistence-capable classes will be observed by an instance of the given
* listener class.
*
JDO implementations
* are permitted to define key values of their own. Any key values not
* recognized by the implementation must be ignored. Key values that are
* recognized but not supported by an implementation must result in a
* JDOFatalUserException thrown by the method.
*
The returned PersistenceManagerFactory is not
* configurable (the setXXX methods will throw an
* exception).
*
JDO implementations might manage a map of instantiated
* PersistenceManagerFactory instances based on specified
* property key values, and return a previously instantiated
* PersistenceManagerFactory instance. In this case, the
* properties of the returned instance must exactly match the requested
* properties.
* @return the PersistenceManagerFactory.
* @param props a Properties instance with properties of the
* PersistenceManagerFactory.
* @param pmfClassLoader the class loader to use to load the
* PersistenceManagerFactory class
* @throws JDOFatalUserException if
*
the pmfClassLoader passed is invalid; or
* a valid class name cannot be obtained from
* either props or system resources
* (an entry in META-INF/services/javax.jdo.PersistenceManagerFactory); or
* all implementations throw an exception.
* exceptions = new ArrayList();
if (pmfClassLoader == null)
throw new JDOFatalUserException (msg.msg (
"EXC_GetPMFNullLoader")); //NOI18N
JDOImplHelper.assertOnlyKnownStandardProperties(overrides);
JDOImplHelper.assertOnlyKnownStandardProperties(props);
// first try to get the class name from the properties object.
String pmfClassName = (String) props.get (
PROPERTY_PERSISTENCE_MANAGER_FACTORY_CLASS);
if (!isNullOrBlank(pmfClassName)) {
// a valid name was returned from the properties.
return invokeGetPersistenceManagerFactoryOnImplementation(
pmfClassName, overrides, props, pmfClassLoader);
} else {
/*
* If you have a jar file that provides the jdo implementation,
* a file naming the implementation goes into the file
* packaged into the jar file, called
* META-INF/services/javax.jdo.PersistenceManagerFactory.
* The contents of the file is a string that is the PMF class name,
* null or blank.
* For each file in pmfClassLoader named
* META-INF/services/javax.jdo.PersistenceManagerFactory,
* this method will try to invoke the getPersistenceManagerFactory
* method of the implementation class.
* Return the factory if a valid class name is extracted from
* resources and the invocation returns an instance.
* Otherwise add the exception thrown to
* an exception list.
*/
Enumeration urls = null;
try {
urls = getResources(pmfClassLoader,
SERVICE_LOOKUP_PMF_RESOURCE_NAME);
} catch (Throwable ex) {
exceptions.add(ex);
}
if (urls != null){
while (urls.hasMoreElements()) {
try {
pmfClassName = getClassNameFromURL(
(URL) urls.nextElement());
// return the implementation that is valid.
PersistenceManagerFactory pmf =
invokeGetPersistenceManagerFactoryOnImplementation(
pmfClassName, overrides, props, pmfClassLoader);
return pmf;
} catch (Throwable ex) {
// remember exceptions from failed pmf invocations
exceptions.add(ex);
}
}
}
}
// no PMF class name in props and no services.
throw new JDOFatalUserException(msg.msg(
"EXC_GetPMFNoPMFClassNamePropertyOrPUNameProperty"),
(Throwable[])
exceptions.toArray(new Throwable[exceptions.size()]));
}
/** Get a class name from a URL. The URL is from getResources with
* e.g. META-INF/services/javax.jdo.PersistenceManagerFactory as the
* parameter. Parse the file, removing blank lines, comment lines,
* and comments.
* @param url the URL of the services file
* @return the name of the class contained in the file
* @throws java.io.IOException
* @since 2.1
*/
protected static String getClassNameFromURL (URL url)
throws IOException {
InputStream is = openStream(url);
BufferedReader reader = new BufferedReader(new InputStreamReader(is));
String line = null;
try {
while ((line = reader.readLine()) != null) {
line = line.trim();
if (line.length() == 0 || line.startsWith("#")) {
continue;
}
// else assume first line of text is the PMF class name
String[] tokens = line.split("\\s");
String pmfClassName = tokens[0];
int indexOfComment = pmfClassName.indexOf("#");
if (indexOfComment == -1) {
return pmfClassName;
}
// else pmfClassName has a comment at the end of it -- remove
return pmfClassName.substring(0, indexOfComment);
}
return null;
} finally {
try {
reader.close();
}
catch (IOException x) {
// gulp
}
}
}
/**
* Returns a named {@link PersistenceManagerFactory} or persistence
* unit.
*
* @since 2.1
* @see #getPersistenceManagerFactory(Map,String,ClassLoader,ClassLoader)
*/
public static PersistenceManagerFactory getPersistenceManagerFactory
(String name) {
ClassLoader cl = getContextClassLoader();
return getPersistenceManagerFactory(null, name, cl, cl);
}
/**
* Returns a named {@link PersistenceManagerFactory} or persistence
* unit.
*
* @since 1.0
* @see #getPersistenceManagerFactory(Map,String,ClassLoader,ClassLoader)
*/
public static PersistenceManagerFactory getPersistenceManagerFactory
(String name, ClassLoader loader) {
return getPersistenceManagerFactory(null, name, loader, loader);
}
/**
* Returns a named {@link PersistenceManagerFactory} or persistence
* unit.
*
* @since 2.0
* @see #getPersistenceManagerFactory(Map,String,ClassLoader,ClassLoader)
*/
public static PersistenceManagerFactory getPersistenceManagerFactory
(String name, ClassLoader resourceLoader, ClassLoader pmfLoader) {
return getPersistenceManagerFactory(
null, name, resourceLoader, pmfLoader);
}
/**
* Returns a named {@link PersistenceManagerFactory} or persistence
* unit.
*
* @since 2.1
* @see #getPersistenceManagerFactory(Map,String,ClassLoader,ClassLoader)
*/
public static PersistenceManagerFactory getPersistenceManagerFactory
(Map overrides, String name) {
ClassLoader cl = getContextClassLoader();
return getPersistenceManagerFactory(overrides, name, cl, cl);
}
/**
* Returns a named {@link PersistenceManagerFactory} or persistence
* unit.
*
* @since 2.1
* @see #getPersistenceManagerFactory(Map,String,ClassLoader,ClassLoader)
*/
public static PersistenceManagerFactory getPersistenceManagerFactory
(Map overrides, String name, ClassLoader resourceLoader) {
return getPersistenceManagerFactory(
overrides, name, resourceLoader, resourceLoader);
}
/**
* Returns a {@link PersistenceManagerFactory} configured based
* on the properties stored in the resource at
* name, or, if not found, returns a
* {@link PersistenceManagerFactory} with the given
* name or, if not found, returns a
* javax.persistence.EntityManagerFactory cast to a
* {@link PersistenceManagerFactory}. If the name given is null or consists
* only of whitespace, it is interpreted as
* {@link Constants#ANONYMOUS_PERSISTENCE_MANAGER_FACTORY_NAME}.
* The following are standard key names:
* "javax.jdo.PersistenceManagerFactoryClass"
*
* and properties of the form
* javax.jdo.option.InstanceLifecycleListener.{listenerClass}[=[{pcClasses}]]
* where {listenerClass} is the fully qualified name of a
* class that implements
* {@link javax.jdo.listener.InstanceLifecycleListener}, and
* {pcClasses} is an optional comma- or whitespace-delimited
* list of persistence-capable classes to be observed; the absence of a
* value for a property of this form means that instances of all
* persistence-capable classes will be observed by an instance of the given
* listener class.
* JDO implementations
* are permitted to define key values of their own. Any key values not
* recognized by the implementation must be ignored. Key values that are
* recognized but not supported by an implementation must result in a
* JDOFatalUserException thrown by the method.
*
The returned PersistenceManagerFactory is not
* configurable (the setXXX methods will throw an
* exception).
*
* This method loads the properties found at name, if any, via
* resourceLoader, and creates a {@link
* PersistenceManagerFactory} with pmfLoader. Any
* exceptions thrown during resource loading will
* be wrapped in a {@link JDOFatalUserException}.
* If multiple PMFs with the requested name are found, a
* {@link JDOFatalUserException} is thrown.
* @since 2.1
* @param overrides a Map containing properties that override properties
* defined in any resources loaded according to the "name" parameter
* @param name interpreted as the name of the resource containing the PMF
* properties, the name of the PMF, or the persistence unit name, in that
* order; if name is null, blank or whitespace, it is interpreted as
* indicating the anonymous {@link PersistenceManagerFactory}.
* @param resourceLoader the class loader to use to load properties file
* resources; must be non-null if name is non-null or blank
* @param pmfLoader the class loader to use to load the
* {@link PersistenceManagerFactory} or
* javax.persistence.EntityManagerFactory classes
* @return the {@link PersistenceManagerFactory} with properties in the
* given resource, with the given name, or with the given persitence unit
* name
* @see Constants#ANONYMOUS_PERSISTENCE_MANAGER_FACTORY_NAME
*/
public static PersistenceManagerFactory getPersistenceManagerFactory(
Map overrides,
String name,
ClassLoader resourceLoader,
ClassLoader pmfLoader) {
if (pmfLoader == null)
throw new JDOFatalUserException (msg.msg (
"EXC_GetPMFNullPMFLoader")); //NOI18N
if (resourceLoader == null) {
throw new JDOFatalUserException(msg.msg(
"EXC_GetPMFNullPropsLoader")); //NOI18N
}
Map props = null;
// trim spaces from name and ensure non-null
name = (name == null?ANONYMOUS_PERSISTENCE_MANAGER_FACTORY_NAME:name.trim());
if (!ANONYMOUS_PERSISTENCE_MANAGER_FACTORY_NAME.equals(name)) {
props = loadPropertiesFromResource(resourceLoader, name);
}
if (props != null) {
// add the SPI property to inform the implementation that
// the PMF was configured by the given resource name
// and not via named PMF for proper deserialization
props.put(PROPERTY_SPI_RESOURCE_NAME, name);
props.remove(PROPERTY_NAME);
return getPersistenceManagerFactory(overrides, props, pmfLoader);
}
// props were null; try getting from jdoconfig.xml
props = getPropertiesFromJdoconfig(name, pmfLoader);
if (props != null) {
// inform the impl that the config came from a jdoconfig.xml
// element with the given name
props.put(PROPERTY_NAME, name);
props.remove(PROPERTY_SPI_RESOURCE_NAME);
// we have loaded a Properties, delegate to implementation
return getPersistenceManagerFactory(overrides, props, pmfLoader);
}
// no properties found; last try to see if name is a JPA PU name
if (!ANONYMOUS_PERSISTENCE_MANAGER_FACTORY_NAME.equals(name)) {
props = new Properties();
props.put(PROPERTY_PERSISTENCE_UNIT_NAME, name);
return getPersistenceManagerFactory(overrides, props, pmfLoader);
}
// no PMF found; give up
throw new JDOFatalUserException (msg.msg (
"EXC_NoPMFConfigurableViaPropertiesOrXML", name)); //NOI18N
}
/** Invoke the getPersistenceManagerFactory method on the implementation.
* If the overrides parameter to this method is not null, the static method
* with Map overrides, Map properties parameters will be invoked.
* If the overrides parameter to this method is null, the static method
* with Map properties parameter will be invoked.
* @param pmfClassName the name of the implementation factory class
* @param overrides a Map of overrides
* @param properties a Map of properties
* @param cl the class loader to use to load the implementation class
* @return the PersistenceManagerFactory
*/
protected static PersistenceManagerFactory
invokeGetPersistenceManagerFactoryOnImplementation(
String pmfClassName, Map overrides, Map properties, ClassLoader cl) {
if (overrides != null) {
// overrides is not null; use getPersistenceManagerFactory(Map overrides, Map props)
try {
Class implClass = forName(pmfClassName, true, cl);
Method m = getMethod(implClass,
"getPersistenceManagerFactory", //NOI18N
new Class[]{Map.class, Map.class});
PersistenceManagerFactory pmf =
(PersistenceManagerFactory) invoke(m,
null, new Object[]{overrides, properties});
if (pmf == null) {
throw new JDOFatalInternalException(msg.msg (
"EXC_GetPMFNullPMF", pmfClassName)); //NOI18N
}
return pmf;
} catch (ClassNotFoundException e) {
throw new JDOFatalUserException(msg.msg(
"EXC_GetPMFClassNotFound", pmfClassName), e); //NOI18N
} catch (NoSuchMethodException e) {
throw new JDOFatalInternalException(msg.msg(
"EXC_GetPMFNoSuchMethod2", pmfClassName), e); //NOI18N
} catch (NullPointerException e) {
throw new JDOFatalInternalException (msg.msg(
"EXC_GetPMFNullPointerException", pmfClassName), e); //NOI18N
} catch (IllegalAccessException e) {
throw new JDOFatalUserException(msg.msg(
"EXC_GetPMFIllegalAccess", pmfClassName), e); //NOI18N
} catch (ClassCastException e) {
throw new JDOFatalInternalException (msg.msg(
"EXC_GetPMFClassCastException", pmfClassName), e); //NOI18N
} catch (InvocationTargetException ite) {
Throwable nested = ite.getTargetException();
if (nested instanceof JDOException) {
throw (JDOException)nested;
} else throw new JDOFatalInternalException (msg.msg(
"EXC_GetPMFUnexpectedException"), ite); //NOI18N
}
} else {
// overrides is null; use getPersistenceManagerFactory(Map props)
try {
Class implClass = forName(pmfClassName, true, cl);
Method m = getMethod(implClass,
"getPersistenceManagerFactory", //NOI18N
new Class[]{Map.class});
PersistenceManagerFactory pmf =
(PersistenceManagerFactory) invoke(m,
null, new Object[]{properties});
if (pmf == null) {
throw new JDOFatalInternalException(msg.msg (
"EXC_GetPMFNullPMF", pmfClassName)); //NOI18N
}
return pmf;
} catch (ClassNotFoundException e) {
throw new JDOFatalUserException(msg.msg(
"EXC_GetPMFClassNotFound", pmfClassName), e); //NOI18N
} catch (NoSuchMethodException e) {
throw new JDOFatalInternalException(msg.msg(
"EXC_GetPMFNoSuchMethod", pmfClassName), e); //NOI18N
} catch (NullPointerException e) {
throw new JDOFatalInternalException (msg.msg(
"EXC_GetPMFNullPointerException", pmfClassName), e); //NOI18N
} catch (IllegalAccessException e) {
throw new JDOFatalUserException(msg.msg(
"EXC_GetPMFIllegalAccess", pmfClassName), e); //NOI18N
} catch (ClassCastException e) {
throw new JDOFatalInternalException (msg.msg(
"EXC_GetPMFClassCastException", pmfClassName), e); //NOI18N
} catch (InvocationTargetException ite) {
Throwable nested = ite.getTargetException();
if (nested instanceof JDOException) {
throw (JDOException)nested;
} else throw new JDOFatalInternalException (msg.msg(
"EXC_GetPMFUnexpectedException"), ite); //NOI18N
}
}
}
/** Load a Properties instance by name from the class loader.
*
* @param resourceLoader the class loader from which to load the properties
* @param name the name of the resource
* @return a Properties instance or null if no resource is found
*/
protected static Map loadPropertiesFromResource(
ClassLoader resourceLoader, String name) {
InputStream in = null;
Properties props = null;
// try to load resources from properties file
try {
in = getResourceAsStream(resourceLoader, name);
if (in != null) {
// then some kind of resource was found by the given name;
// assume that it's a properties file
props = new Properties();
((Properties) props).load(in);
}
} catch (IOException ioe) {
throw new JDOFatalUserException(msg.msg(
"EXC_GetPMFIOExceptionRsrc", name), ioe); //NOI18N
} finally {
if (in != null) {
try {
in.close();
} catch (IOException ioe) {
}
}
}
return props;
}
/**
* @see #getNamedPMFProperties(String,ClassLoader,String)
* @since 2.1
*/
protected static Map getPropertiesFromJdoconfig(
String name,
ClassLoader resourceLoader) {
return getNamedPMFProperties(
name, resourceLoader, JDOCONFIG_RESOURCE_NAME);
}
/**
* Find and return the named {@link PersistenceManagerFactory}'s properties,
* or null if not found.
* If multiple named PMF property sets with
* the given name are found (including anonymous ones), throw
* {@link JDOFatalUserException}.
* This method is here only to facilitate testing; the parameter
* "jdoconfigResourceName" in public usage should always have the value
* given in the constant {@link Constants#JDOCONFIG_RESOURCE_NAME}.
*
* @param name The persistence unit name; null is disallowed.
* @param resourceLoader The ClassLoader used to load the standard JDO
* configuration file.
* @param jdoconfigResourceName The name of the configuration file to read.
* In public usage, this should always be the value of
* {@link Constants#JDOCONFIG_RESOURCE_NAME}.
* @return The named PersistenceManagerFactory properties if
* found, null if not.
* @since 2.1
* @throws JDOFatalUserException if multiple named PMF property sets are
* found with the given name, or any other exception is encountered.
*/
protected static Map getNamedPMFProperties(
String name,
ClassLoader resourceLoader,
String jdoconfigResourceName) {
// key is PU name, value is Map of PU properties
Map> propertiesByNameInAllConfigs
= new HashMap>();
try {
URL firstFoundConfigURL = null;
// get all JDO configurations
Enumeration resources =
getResources(resourceLoader, jdoconfigResourceName);
if (resources.hasMoreElements()) {
ArrayList processedResources = new ArrayList();
// get ready to parse XML
DocumentBuilderFactory factory = getDocumentBuilderFactory();
do {
URL currentConfigURL = resources.nextElement();
if (processedResources.contains(currentConfigURL)) {
continue;
}
else {
processedResources.add(currentConfigURL);
}
Map> propertiesByNameInCurrentConfig =
readNamedPMFProperties(
currentConfigURL,
name,
factory);
// try to detect duplicate requested PU
if (propertiesByNameInCurrentConfig.containsKey(name)) {
// possible dup -- check for it
if (firstFoundConfigURL == null) {
firstFoundConfigURL = currentConfigURL;
}
if (propertiesByNameInAllConfigs.containsKey(name))
throw new JDOFatalUserException (msg.msg(
"EXC_DuplicateRequestedNamedPMFFoundInDifferentConfigs",
"".equals(name)
? "(anonymous)"
: name,
firstFoundConfigURL.toExternalForm(),
currentConfigURL.toExternalForm())); //NOI18N
}
// no dups -- add found PUs to all PUs and keep going
propertiesByNameInAllConfigs
.putAll(propertiesByNameInCurrentConfig);
} while (resources.hasMoreElements());
}
}
catch (FactoryConfigurationError e) {
throw new JDOFatalUserException(
msg.msg("ERR_NoDocumentBuilderFactory"), e);
}
catch (IOException ioe) {
throw new JDOFatalUserException (msg.msg (
"EXC_GetPMFIOExceptionRsrc", name), ioe); //NOI18N
}
// done with reading all config resources;
// return what we found, which may very well be null
return (Map) propertiesByNameInAllConfigs.get(name);
}
protected static DocumentBuilderFactory getDocumentBuilderFactory() {
@SuppressWarnings("static-access")
DocumentBuilderFactory factory =
implHelper.getRegisteredDocumentBuilderFactory();
if (factory == null) {
factory = getDefaultDocumentBuilderFactory();
}
return factory;
}
protected static DocumentBuilderFactory getDefaultDocumentBuilderFactory() {
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
factory.setIgnoringComments(true);
factory.setNamespaceAware(true);
factory.setValidating(false);
factory.setIgnoringElementContentWhitespace(true);
factory.setExpandEntityReferences(true);
return factory;
}
protected static ErrorHandler getErrorHandler() {
@SuppressWarnings("static-access")
ErrorHandler handler = implHelper.getRegisteredErrorHandler();
if (handler == null) {
handler = getDefaultErrorHandler();
}
return handler;
}
protected static ErrorHandler getDefaultErrorHandler() {
return new ErrorHandler() {
public void error(SAXParseException exception)
throws SAXException {
throw exception;
}
public void fatalError(SAXParseException exception)
throws SAXException {
throw exception;
}
public void warning(SAXParseException exception)
throws SAXException {
// gulp: ignore warnings
}
};
}
/** Reads JDO configuration file, creates a Map for each
* persistence-manager-factory, then returns the map.
* @param url URL of a JDO configuration file compliant with
* javax/jdo/jdoconfig.xsd.
* @param requestedPMFName The name of the requested
* persistence unit (allows for fail-fast).
* @param factory The DocumentBuilderFactory to use for XML
* parsing.
* @return a Map holding persistence unit configurations; for
* the anonymous persistence unit, the
* value of the String key is the empty string, "".
*/
protected static Map> readNamedPMFProperties(
URL url,
String requestedPMFName,
DocumentBuilderFactory factory) {
requestedPMFName = requestedPMFName == null
? ""
: requestedPMFName.trim();
Map>
propertiesByName = new HashMap>();
InputStream in = null;
try {
DocumentBuilder builder = factory.newDocumentBuilder();
builder.setErrorHandler(getErrorHandler());
in = openStream(url);
Document doc = builder.parse(in);
Element root = doc.getDocumentElement();
if (root == null) {
throw new JDOFatalUserException(
msg.msg("EXC_InvalidJDOConfigNoRoot", url.toExternalForm())
);
}
NodeList pmfs = root.getElementsByTagName(
ELEMENT_PERSISTENCE_MANAGER_FACTORY);
for(int i = 0; i < pmfs.getLength(); i++) {
Node pmfElement = pmfs.item(i);
Properties pmfPropertiesFromAttributes
= readPropertiesFromPMFElementAttributes(pmfElement);
Properties pmfPropertiesFromElements
= readPropertiesFromPMFSubelements(pmfElement, url);
// for informative error handling, get name (or names) now
String pmfNameFromAtts =
pmfPropertiesFromAttributes.getProperty(PROPERTY_NAME);
String pmfNameFromElem =
pmfPropertiesFromElements.getProperty(PROPERTY_NAME);
String pmfName = null;
if (isNullOrBlank(pmfNameFromAtts)) {
// no PMF name attribute given
if (!isNullOrBlank(pmfNameFromElem)) {
// PMF name element was given
pmfName = pmfNameFromElem;
}
else {
// PMF name not given at all, means the "anonymous" PMF
pmfName = ANONYMOUS_PERSISTENCE_MANAGER_FACTORY_NAME;
}
}
else {
// PMF name given in an attribute
if (!isNullOrBlank(pmfNameFromElem)) {
// exception -- PMF name given as both att & elem
throw new JDOFatalUserException(
msg.msg(
"EXC_DuplicatePMFNamePropertyFoundWithinConfig",
pmfNameFromAtts,
pmfNameFromElem,
url.toExternalForm()));
}
pmfName = pmfNameFromAtts;
}
pmfName = pmfName == null ? "" : pmfName.trim();
// check for duplicate properties among atts & elems
if (requestedPMFName.equals(pmfName)) {
Iterator it =
pmfPropertiesFromAttributes.keySet().iterator();
while (it.hasNext()) {
String property = (String) it.next();
if (pmfPropertiesFromElements.contains(property)) {
throw new JDOFatalUserException(
msg.msg(
"EXC_DuplicatePropertyFound",
property,
pmfName,
url.toExternalForm()));
}
}
}
// at this point, we're guaranteed not to have duplicate
// properties -- merge them
Properties pmfProps = new Properties();
pmfProps.putAll(pmfPropertiesFromAttributes);
pmfProps.putAll(pmfPropertiesFromElements);
// check for duplicate requested PMF name
if (pmfName.equals(requestedPMFName)
&& propertiesByName.containsKey(pmfName)) {
throw new JDOFatalUserException(msg.msg(
"EXC_DuplicateRequestedNamedPMFFoundInSameConfig",
pmfName,
url.toExternalForm()));
}
propertiesByName.put(pmfName, pmfProps);
}
return propertiesByName;
}
catch (IOException ioe) {
throw new JDOFatalUserException(
msg.msg("EXC_GetPMFIOExceptionRsrc", url.toString()),
ioe); //NOI18N
}
catch (ParserConfigurationException e) {
throw new JDOFatalInternalException(
msg.msg("EXC_ParserConfigException"),
e);
}
catch (SAXParseException e) {
throw new JDOFatalUserException(
msg.msg(
"EXC_SAXParseException",
url.toExternalForm(),
new Integer(e.getLineNumber()),
new Integer(e.getColumnNumber())),
e);
}
catch (SAXException e) {
throw new JDOFatalUserException(
msg.msg("EXC_SAXException", url.toExternalForm()),
e);
}
catch (JDOException e) {
throw e;
}
catch (RuntimeException e) {
throw new JDOFatalUserException(
msg.msg("EXC_SAXException", url.toExternalForm()),
e);
}
finally {
if (in != null) {
try {
in.close();
}
catch (IOException ioe) { /* gulp */ }
}
}
}
protected static Properties readPropertiesFromPMFElementAttributes(
Node pmfElement) {
Properties p = new Properties();
NamedNodeMap attributes = pmfElement.getAttributes();
if (attributes == null) {
return p;
}
for(int i = 0; i < attributes.getLength(); i++) {
Node att = attributes.item(i);
String attName = att.getNodeName();
String attValue = att.getNodeValue().trim();
String jdoPropertyName =
(String) ATTRIBUTE_PROPERTY_XREF.get(attName);
p.put(
jdoPropertyName != null
? jdoPropertyName
: attName,
attValue);
}
return p;
}
protected static Properties readPropertiesFromPMFSubelements(
Node pmfElement, URL url) {
Properties p = new Properties();
NodeList elements = pmfElement.getChildNodes();
if (elements == null) {
return p;
}
for(int i = 0; i < elements.getLength(); i++) {
Node element = elements.item(i);
if (element.getNodeType() != Node.ELEMENT_NODE) {
continue;
}
String elementName = element.getNodeName();
NamedNodeMap attributes = element.getAttributes();
if (ELEMENT_PROPERTY.equalsIgnoreCase(elementName)) {
// attribute names or the
// "javax.jdo" property names in element "name"
// attributes. Handy-dandy.
String jdoPropertyName =
(String) ATTRIBUTE_PROPERTY_XREF.get(name);
String propertyName = jdoPropertyName != null
? jdoPropertyName
: name;
if (p.containsKey(propertyName)) {
throw new JDOFatalUserException(
msg.msg(
"EXC_DuplicatePropertyNameGivenInPropertyElement",
propertyName,
url));
}
// get the "value" attribute's value (optional)
Node valueAtt = attributes.getNamedItem(
PROPERTY_ATTRIBUTE_VALUE);
String value = valueAtt == null
? null
: valueAtt.getNodeValue().trim();
p.put(propertyName, value);
}
else if (ELEMENT_INSTANCE_LIFECYCLE_LISTENER.equals(elementName)) {
// propsFile. This method is equivalent to
* invoking {@link
* #getPersistenceManagerFactory(File,ClassLoader)} with
* Thread.currentThread().getContextClassLoader() as
* the loader argument.
* @since 2.0
* @param propsFile the file containing the Properties
* @return the PersistenceManagerFactory
*/
public static PersistenceManagerFactory getPersistenceManagerFactory
(File propsFile) {
return getPersistenceManagerFactory(
propsFile, getContextClassLoader());
}
/**
* Returns a {@link PersistenceManagerFactory} configured based
* on the properties stored in the file at
* propsFile. Creates a {@link
* PersistenceManagerFactory} with loader. Any
* IOExceptions or
* FileNotFoundExceptions thrown during resource
* loading will be wrapped in a {@link JDOFatalUserException}.
* @since 2.0
* @param propsFile the file containing the Properties
* @param loader the class loader to use to load the
* PersistenceManagerFactory class
* @return the PersistenceManagerFactory
*/
public static PersistenceManagerFactory getPersistenceManagerFactory
(File propsFile, ClassLoader loader) {
if (propsFile == null)
throw new JDOFatalUserException (msg.msg (
"EXC_GetPMFNullFile")); //NOI18N
InputStream in = null;
try {
in = new FileInputStream(propsFile);
return getPersistenceManagerFactory(in, loader);
} catch (FileNotFoundException fnfe) {
throw new JDOFatalUserException (msg.msg (
"EXC_GetPMFNoFile", propsFile), fnfe); //NOI18N
} finally {
if (in != null)
try {
in.close ();
} catch (IOException ioe) { }
}
}
/**
* Returns a {@link PersistenceManagerFactory} at the JNDI
* location specified by jndiLocation in the context
* context. If context is
* null, new InitialContext() will be
* used. This method is equivalent to invoking {@link
* #getPersistenceManagerFactory(String,Context,ClassLoader)}
* with Thread.currentThread().getContextClassLoader() as
* the loader argument.
* @since 2.0
* @param jndiLocation the JNDI location containing the
* PersistenceManagerFactory
* @param context the context in which to find the named
* PersistenceManagerFactory
* @return the PersistenceManagerFactory
*/
public static PersistenceManagerFactory getPersistenceManagerFactory
(String jndiLocation, Context context) {
return getPersistenceManagerFactory (jndiLocation, context,
getContextClassLoader());
}
/**
* Returns a {@link PersistenceManagerFactory} at the JNDI
* location specified by jndiLocation in the context
* context. If context is
* null, new InitialContext() will be
* used. Creates a {@link PersistenceManagerFactory} with
* loader. Any NamingExceptions thrown
* will be wrapped in a {@link JDOFatalUserException}.
* @since 2.0
* @param jndiLocation the JNDI location containing the
* PersistenceManagerFactory
* @param context the context in which to find the named
* PersistenceManagerFactory
* @param loader the class loader to use to load the
* PersistenceManagerFactory class
* @return the PersistenceManagerFactory
*/
public static PersistenceManagerFactory getPersistenceManagerFactory
(String jndiLocation, Context context, ClassLoader loader) {
if (jndiLocation == null)
throw new JDOFatalUserException (msg.msg (
"EXC_GetPMFNullJndiLoc")); //NOI18N
if (loader == null)
throw new JDOFatalUserException (msg.msg (
"EXC_GetPMFNullLoader")); //NOI18N
try {
if (context == null)
context = new InitialContext ();
Object o = context.lookup (jndiLocation);
return (PersistenceManagerFactory) PortableRemoteObject.narrow
(o, PersistenceManagerFactory.class);
} catch (NamingException ne) {
throw new JDOFatalUserException (msg.msg (
"EXC_GetPMFNamingException", jndiLocation, loader), ne); //NOI18N
}
}
/**
* Returns a {@link PersistenceManagerFactory} configured based
* on the Properties stored in the input stream at
* stream. This method is equivalent to
* invoking {@link
* #getPersistenceManagerFactory(InputStream,ClassLoader)} with
* Thread.currentThread().getContextClassLoader() as
* the loader argument.
* @since 2.0
* @param stream the stream containing the Properties
* @return the PersistenceManagerFactory
*/
public static PersistenceManagerFactory getPersistenceManagerFactory
(InputStream stream) {
return getPersistenceManagerFactory(
stream, getContextClassLoader());
}
/**
* Returns a {@link PersistenceManagerFactory} configured based
* on the Properties stored in the input stream at
* stream. Creates a {@link
* PersistenceManagerFactory} with loader. Any
* IOExceptions thrown during resource
* loading will be wrapped in a {@link JDOFatalUserException}.
* @since 2.0
* @param stream the stream containing the Properties
* @param loader the class loader to use to load the
* PersistenceManagerFactory class
* @return the PersistenceManagerFactory
*/
public static PersistenceManagerFactory getPersistenceManagerFactory
(InputStream stream, ClassLoader loader) {
if (stream == null)
throw new JDOFatalUserException (msg.msg (
"EXC_GetPMFNullStream")); //NOI18N
Properties props = new Properties ();
try {
props.load (stream);
} catch (IOException ioe) {
throw new JDOFatalUserException
(msg.msg ("EXC_GetPMFIOExceptionStream"), ioe); //NOI18N
}
return getPersistenceManagerFactory (props, loader);
}
/**
* Get a JDOEnhancer using the available enhancer(s) specified in
* "META-INF/services/JDOEnhancer" using the context class loader.
* @return the JDOEnhancer.
* @throws JDOFatalUserException if no available enhancer
* @since 3.0
*/
public static JDOEnhancer getEnhancer() {
return getEnhancer(getContextClassLoader());
}
/**
* Get a JDOEnhancer using the available enhancer(s) specified in
* "META-INF/services/JDOEnhancer"
* @param loader the loader to use for loading the JDOEnhancer class (if any)
* @return the JDOEnhancer.
* @throws JDOFatalUserException if no available enhancer
* @since 3.0
*/
public static JDOEnhancer getEnhancer(ClassLoader loader) {
ClassLoader ctrLoader = loader;
if (ctrLoader == null) {
ctrLoader = Thread.currentThread().getContextClassLoader();
}
/*
* If you have a jar file that provides the jdo enhancer implementation,
* a file naming the implementation goes into the file
* packaged into the jar file, called "META-INF/services/javax.jdo.JDOEnhancer".
* The contents of the file is a string that is the enhancer class name.
* For each file in the class loader named "META-INF/services/javax.jdo.JDOEnhancer",
* this method will invoke the default constructor of the implementation class.
* Return the enhancer if a valid class name is extracted from resources and
* the invocation returns an instance.
* Otherwise add the exception thrown to an exception list.
*/
ArrayList exceptions = new ArrayList();
int numberOfJDOEnhancers = 0;
try {
Enumeration urls = getResources(loader, SERVICE_LOOKUP_ENHANCER_RESOURCE_NAME);
if (urls != null) {
while (urls.hasMoreElements()) {
numberOfJDOEnhancers++;
try {
String enhancerClassName = getClassNameFromURL((URL)urls.nextElement());
Class enhancerClass = forName(enhancerClassName, true, ctrLoader);
JDOEnhancer enhancer = (JDOEnhancer)enhancerClass.newInstance();
return enhancer;
} catch (Throwable ex) {
// remember exceptions from failed enhancer invocations
exceptions.add(ex);
}
}
}
} catch (Throwable ex) {
exceptions.add(ex);
}
throw new JDOFatalUserException(msg.msg("EXC_GetEnhancerNoValidEnhancerAvailable", numberOfJDOEnhancers),
(Throwable[])exceptions.toArray(new Throwable[exceptions.size()]));
}
/** Get the context class loader associated with the current thread.
* This is done in a doPrivileged block because it is a secure method.
* @return the current thread's context class loader.
* @since 2.0
*/
private static ClassLoader getContextClassLoader() {
return AccessController.doPrivileged(
new PrivilegedAction () {
public ClassLoader run () {
return Thread.currentThread().getContextClassLoader();
}
}
);
}
/** Get the named resource as a stream from the resource loader.
* Perform this operation in a doPrivileged block.
*/
private static InputStream getResourceAsStream(
final ClassLoader resourceLoader, final String name) {
return AccessController.doPrivileged(
new PrivilegedAction() {
public InputStream run() {
return resourceLoader.getResourceAsStream(name);
}
}
);
}
/** Get the named Method from the named class.
* Perform this operation in a doPrivileged block.
*
* @param implClass the class
* @param methodName the name of the method
* @param parameterTypes the parameter types of the method
* @return the Method instance
*/
private static Method getMethod(
final Class implClass,
final String methodName,
final Class[] parameterTypes)
throws NoSuchMethodException {
try {
return AccessController.doPrivileged(
new PrivilegedExceptionAction() {
public Method run() throws NoSuchMethodException {
return implClass.getMethod(methodName, parameterTypes);
}
}
);
} catch (PrivilegedActionException ex) {
throw (NoSuchMethodException)ex.getException();
}
}
/** Invoke the method.
* Perform this operation in a doPrivileged block.
*/
private static Object invoke(final Method method,
final Object instance, final Object[] parameters)
throws IllegalAccessException, InvocationTargetException {
try {
return (Object) AccessController.doPrivileged(
new PrivilegedExceptionAction() {
public Object run()
throws IllegalAccessException,
InvocationTargetException {
return method.invoke (instance, parameters);
}
}
);
} catch (PrivilegedActionException ex) {
Exception cause = (Exception)ex.getException();
if (cause instanceof IllegalAccessException)
throw (IllegalAccessException)cause;
else //if (cause instanceof InvocationTargetException)
throw (InvocationTargetException)cause;
}
}
/** Get resources of the resource loader.
* Perform this operation in a doPrivileged block.
* @param resourceLoader
* @param resourceName
* @return the resources
*/
protected static Enumeration getResources(
final ClassLoader resourceLoader,
final String resourceName)
throws IOException {
try {
return AccessController.doPrivileged(
new PrivilegedExceptionAction>() {
public Enumeration run() throws IOException {
return resourceLoader.getResources(resourceName);
}
}
);
} catch (PrivilegedActionException ex) {
throw (IOException)ex.getException();
}
}
/** Get the named class.
* Perform this operation in a doPrivileged block.
*
* @param name the name of the class
* @param init whether to initialize the class
* @param loader which class loader to use
* @return the class
*/
private static Class forName(
final String name,
final boolean init,
final ClassLoader loader)
throws ClassNotFoundException {
try {
return AccessController.doPrivileged(
new PrivilegedExceptionAction>() {
public Class run() throws ClassNotFoundException {
return Class.forName(name, init, loader);
}
}
);
} catch (PrivilegedActionException ex) {
throw (ClassNotFoundException)ex.getException();
}
}
/** Open an input stream on the url.
* Perform this operation in a doPrivileged block.
*
* @param url
* @return the input stream
*/
private static InputStream openStream(final URL url)
throws IOException {
try {
return AccessController.doPrivileged(
new PrivilegedExceptionAction() {
public InputStream run() throws IOException {
return url.openStream();
}
}
);
} catch (PrivilegedActionException ex) {
throw (IOException)ex.getException();
}
}
}
api/src/java/javax/jdo/JDONullIdentityException.java 100664 4761 12500110371 22746 0 ustar mbouschen staff 0 0 /*
* 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.
*/
/*
* JDONullIdentityException.java
*
*/
package javax.jdo;
/** An instance of this class is thrown when attempting to create an object id
* when the object id constructor parameter is null. This might occur when
* creating an object id instance from a transient instance where an identity
* field is null.
*
* @since 2.0
* @version 2.0
*/
public class JDONullIdentityException extends JDOUserException {
/**
* Constructs a new JDONullIdentityException without a detail message.
*/
public JDONullIdentityException() {
}
/**
* Constructs a new JDONullIdentityException with the specified detail message.
* @param msg the detail message.
*/
public JDONullIdentityException(String msg) {
super(msg);
}
/** Constructs a new JDONullIdentityException with the specified detail message
* and failed object.
* @param msg the detail message.
* @param failed the failed object.
*/
public JDONullIdentityException(String msg, Object failed) {
super(msg, failed);
}
/**
* Constructs a new JDONullIdentityException with the specified
* detail message and nested Throwables.
* @param msg the detail message.
* @param nested the nested Throwable[].
*/
public JDONullIdentityException(String msg, Throwable[] nested) {
super(msg, nested);
}
/**
* Constructs a new JDONullIdentityException with the specified detail message
* and nested Throwables.
* @param msg the detail message.
* @param nested the nested Throwable.
*/
public JDONullIdentityException(String msg, Throwable nested) {
super(msg, nested);
}
}
api/src/java/javax/jdo/JDOObjectNotFoundException.java 100664 6330 12500110371 23177 0 ustar mbouschen staff 0 0 /*
* 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.
*/
/*
* JDOObjectNotFoundException.java
*
*/
package javax.jdo;
/** This class represents exceptions caused by the user accessing
* an object that does not exist in the datastore.
*
* @since 1.0.1
* @version 1.0.1
*/
public class JDOObjectNotFoundException extends JDODataStoreException {
/**
* Constructs a new JDOObjectNotFoundException
* without a detail message.
*/
public JDOObjectNotFoundException() {
}
/**
* Constructs a new JDOObjectNotFoundException
* with the specified detail message.
* @param msg the detail message.
*/
public JDOObjectNotFoundException(String msg) {
super(msg);
}
/** Constructs a new JDOObjectNotFoundException with the specified detail message
* and failed object.
* @param msg the detail message.
* @param failed the failed object.
*/
public JDOObjectNotFoundException(String msg, Object failed) {
super(msg, failed);
}
/**
* Constructs a new JDOObjectNotFoundException with the
* specified detail message and nested Throwables.
* @param msg the detail message.
* @param nested the nested Throwable.
*/
public JDOObjectNotFoundException(String msg, Throwable nested) {
super(msg, nested);
}
/**
* Constructs a new JDOObjectNotFoundException with the
* specified detail message and nested Throwables.
* @param msg the detail message.
* @param nested the nested Throwable[].
*/
public JDOObjectNotFoundException(String msg, Throwable[] nested) {
super(msg, nested);
}
/**
* Constructs a new JDOObjectNotFoundException with the specified
* detail message, nested Throwables, and failed object.
* @param msg the detail message.
* @param nested the nested Throwable[].
* @param failed the failed object.
*/
public JDOObjectNotFoundException(String msg, Throwable[] nested, Object failed) {
super(msg, nested, failed);
}
/**
* Constructs a new JDOFatalInternalException with the specified
* detail message, nested Throwables, and failed object.
* @param msg the detail message.
* @param nested the nested Throwable.
* @param failed the failed object.
*/
public JDOObjectNotFoundException(String msg, Throwable nested, Object failed) {
super(msg, nested, failed);
}
}
api/src/java/javax/jdo/JDOOptimisticVerificationException.java 100664 6075 12500110371 25011 0 ustar mbouschen staff 0 0 /*
* 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.
*/
/*
* JDOOptimisticVerificationException.java
*
*/
package javax.jdo;
/** This class represents optimistic verification failures. The nested
* exception array contains an exception for each instance that failed
* the optimistic verification.
*
* @since 1.0.1
* @version 1.0.1
*/
public class JDOOptimisticVerificationException extends JDOFatalDataStoreException {
/**
* Constructs a new JDOOptimisticVerificationException without a
* detail message.
*/
public JDOOptimisticVerificationException() {
}
/**
* Constructs a new JDOOptimisticVerificationException with the
* specified detail message.
* @param msg the detail message.
*/
public JDOOptimisticVerificationException(String msg) {
super(msg);
}
/** Constructs a new JDOOptimisticVerificationException with the
* specified detail message and failed object.
* @param msg the detail message.
* @param failed the failed object.
*/
public JDOOptimisticVerificationException(String msg, Object failed) {
super(msg, failed);
}
/**
* Constructs a new JDOOptimisticVerificationException with the
* specified detail message and nested Throwable[]s.
* @param msg the detail message.
* @param nested the nested Throwable[].
*/
public JDOOptimisticVerificationException(String msg, Throwable[] nested) {
super(msg, nested);
}
/**
* Constructs a new JDOOptimisticVerificationException with the specified
* detail message, nested Throwables, and failed object.
* @param msg the detail message.
* @param nested the nested Throwable[].
* @param failed the failed object.
*/
public JDOOptimisticVerificationException(String msg, Throwable[] nested, Object failed) {
super(msg, nested, failed);
}
/**
* Constructs a new JDOOptimisticVerificationException with the specified
* detail message, nested Throwables, and failed object.
* @param msg the detail message.
* @param nested the nested Throwable.
* @param failed the failed object.
*/
public JDOOptimisticVerificationException(String msg, Throwable nested, Object failed) {
super(msg, nested, failed);
}
}
api/src/java/javax/jdo/JDOQueryInterruptedException.java 100664 2703 12500110371 23647 0 ustar mbouschen staff 0 0 /*
* 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.
*/
/*
* JDOUnsupportedOptionException.java
*
*/
package javax.jdo;
/**
* This class represents exceptions caused when a query is cancelled by a user calling
* Query.cancel().
*
* @since 3.0
*/
public class JDOQueryInterruptedException extends JDOUserException {
/**
* Constructs a new JDOQueryInterruptedException without a detail message.
*/
public JDOQueryInterruptedException() {
}
/**
* Constructs a new JDOQueryInterruptedException with the specified detail message.
* @param msg the detail message.
*/
public JDOQueryInterruptedException(String msg) {
super(msg);
}
}
api/src/java/javax/jdo/JDOReadOnlyException.java 100664 4155 12500110371 22034 0 ustar mbouschen staff 0 0 /*
* 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.
*/
/*
* JDOReadOnlyException.java
*/
package javax.jdo;
/** This class represents exceptions caused by an attempt to update a datastore
* when the PMF was created as "read-only".
*
* @version 2.2
* @since 2.2
*/
public class JDOReadOnlyException extends JDOUserException {
/**
* Constructs a new JDOReadOnlyException without a
* detail message.
* @since 2.2
*/
public JDOReadOnlyException() {
}
/**
* Constructs a new JDOReadOnlyException with the
* specified detail message.
* @param msg the detail message.
* @since 2.2
*/
public JDOReadOnlyException(String msg) {
super(msg);
}
/**
* Constructs a new JDOReadOnlyException with the
* specified detail message and nested Throwables.
* @param msg the detail message.
* @param nested the nested Throwable[].
* @since 2.2
*/
public JDOReadOnlyException(String msg, Throwable[] nested) {
super(msg, nested);
}
/**
* Constructs a new JDOReadOnlyException with the
* specified detail message and nested Throwables.
* @param msg the detail message.
* @param nested the nested Throwable.
* @since 2.2
*/
public JDOReadOnlyException(String msg, Throwable nested) {
super(msg, nested);
}
} api/src/java/javax/jdo/JDOUnsupportedOptionException.java 100664 4156 12500110371 24041 0 ustar mbouschen staff 0 0 /*
* 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.
*/
/*
* JDOUnsupportedOptionException.java
*
*/
package javax.jdo;
/** This class represents exceptions caused by the use of optional features
* not supported by the JDO implementation.
*
* @version 1.0
*/
public class JDOUnsupportedOptionException extends JDOUserException {
/**
* Constructs a new JDOUnsupportedOptionException without a detail message.
*/
public JDOUnsupportedOptionException() {
}
/**
* Constructs a new JDOUnsupportedOptionException with the specified detail message.
* @param msg the detail message.
*/
public JDOUnsupportedOptionException(String msg) {
super(msg);
}
/**
* Constructs a new JDOUnsupportedOptionException with the
* specified detail message and nested Throwables.
* @param msg the detail message.
* @param nested the nested Throwable[].
*/
public JDOUnsupportedOptionException(String msg, Throwable[] nested) {
super(msg, nested);
}
/**
* Constructs a new JDOUnsupportedOptionException with the
* specified detail message and nested Throwables.
* @param msg the detail message.
* @param nested the nested Throwable.
*/
public JDOUnsupportedOptionException(String msg, Throwable nested) {
super(msg, nested);
}
}
api/src/java/javax/jdo/JDOUserCallbackException.java 100664 6212 12500110371 22646 0 ustar mbouschen staff 0 0 /*
* 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.
*/
/*
* JDOUserCallbackException.java
*
*/
package javax.jdo;
/** This class represents exceptions caused by exceptions thrown
* during execution of callbacks or listeners.
*
* @version 2.0
*/
public class JDOUserCallbackException extends JDOUserException {
/**
* Constructs a new JDOUserCallbackException
* without a detail message.
*/
public JDOUserCallbackException() {
}
/**
* Constructs a new JDOUserCallbackException
* with the specified detail message.
* @param msg the detail message.
*/
public JDOUserCallbackException(String msg) {
super(msg);
}
/**
* Constructs a new JDOUserCallbackException with the
* specified detail message and nested Throwables.
* @param msg the detail message.
* @param nested the nested Throwable[].
*/
public JDOUserCallbackException(String msg, Throwable[] nested) {
super(msg, nested);
}
/**
* Constructs a new JDOUserCallbackException with the
* specified detail message and nested Throwables.
* @param msg the detail message.
* @param nested the nested Throwable.
*/
public JDOUserCallbackException(String msg, Throwable nested) {
super(msg, nested);
}
/** Constructs a new JDOUserCallbackException with the specified detail message
* and failed object.
* @param msg the detail message.
* @param failed the failed object.
*/
public JDOUserCallbackException(String msg, Object failed) {
super(msg, failed);
}
/** Constructs a new JDOUserCallbackException with the specified detail message,
* nested Throwables, and failed object.
* @param msg the detail message.
* @param nested the nested Throwable[].
* @param failed the failed object.
*/
public JDOUserCallbackException(String msg, Throwable[] nested, Object failed) {
super(msg, nested, failed);
}
/** Constructs a new JDOUserException with the specified detail message,
* nested Throwables, and failed object.
* @param msg the detail message.
* @param nested the nested Throwable.
* @param failed the failed object.
*/
public JDOUserCallbackException(String msg, Throwable nested, Object failed) {
super(msg, nested, failed);
}
}
api/src/java/javax/jdo/JDOUserException.java 100664 5741 12500110371 21237 0 ustar mbouschen staff 0 0 /*
* 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.
*/
/*
* JDOUserException.java
*
*/
package javax.jdo;
/** This class represents user errors that can possibly be retried.
*
* @version 1.0
*/
public class JDOUserException extends JDOCanRetryException {
/**
* Constructs a new JDOUserException without a detail message.
*/
public JDOUserException() {
}
/**
* Constructs a new JDOUserException with the specified detail message.
* @param msg the detail message.
*/
public JDOUserException(String msg) {
super(msg);
}
/**
* Constructs a new JDOUserException with the specified detail message
* and nested Throwables.
* @param msg the detail message.
* @param nested the nested Throwable[].
*/
public JDOUserException(String msg, Throwable[] nested) {
super(msg, nested);
}
/**
* Constructs a new JDOUserException with the specified detail message
* and nested Throwables.
* @param msg the detail message.
* @param nested the nested Throwable.
*/
public JDOUserException(String msg, Throwable nested) {
super(msg, nested);
}
/** Constructs a new JDOUserException with the specified detail message
* and failed object.
* @param msg the detail message.
* @param failed the failed object.
*/
public JDOUserException(String msg, Object failed) {
super(msg, failed);
}
/** Constructs a new JDOUserException with the specified detail message,
* nested Throwables, and failed object.
* @param msg the detail message.
* @param nested the nested Throwable[].
* @param failed the failed object.
*/
public JDOUserException(String msg, Throwable[] nested, Object failed) {
super(msg, nested, failed);
}
/** Constructs a new JDOUserException with the specified detail message,
* nested Throwables, and failed object.
* @param msg the detail message.
* @param nested the nested Throwable.
* @param failed the failed object.
*/
public JDOUserException(String msg, Throwable nested, Object failed) {
super(msg, nested, failed);
}
}
api/src/java/javax/jdo/listener/AttachCallback.java 100664 3207 12500110371 22546 0 ustar mbouschen staff 0 0 /*
* 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.
*/
/*
* AttachCallback.java
*
*/
package javax.jdo.listener;
/**
* This interface is used to notify instances of attach events.
* @version 2.0
* @since 2.0
*/
public interface AttachCallback {
/**
* This method is called during the execution of
* {@link javax.jdo.PersistenceManager#makePersistent} on the detached
* instance before the copy is made.
* @since 2.0
*/
public void jdoPreAttach();
/**
* This method is called during the execution of
* {@link javax.jdo.PersistenceManager#makePersistent} on the persistent
* instance after the copy is made.
* @param attached The corresponding (non-attached) instance that was
* attached in the call to
* {@link javax.jdo.PersistenceManager#makePersistent}.
* @since 2.0
*/
public void jdoPostAttach(Object attached);
}
api/src/java/javax/jdo/listener/AttachLifecycleListener.java 100664 4022 12500110371 24453 0 ustar mbouschen staff 0 0 /*
* 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.
*/
/*
* AttachLifecycleListener.java
*
*/
package javax.jdo.listener;
/**
* This interface is implemented by listeners to be notified of
* attach events.
* @version 2.0
* @since 2.0
*/
public interface AttachLifecycleListener
extends InstanceLifecycleListener {
/**
* This method is called before a detached instance is attached, via the
* {@link javax.jdo.PersistenceManager#makePersistent} method. The source
* instance is the detached instance. This method is called before the
* corresponding {@link AttachCallback#jdoPreAttach} on the detached
* instance.
* @param event the attach event.
* @since 2.0
*/
void preAttach (InstanceLifecycleEvent event);
/**
* This method is called after a detached instance is attached, via the
* {@link javax.jdo.PersistenceManager#makePersistent} method. The source
* instance is the corresponding persistent instance in the cache; the
* target instance is the detached instance. This method is called after
* the corresponding {@link AttachCallback#jdoPostAttach} on the
* persistent instance.
* @param event the attach event.
* @since 2.0
*/
void postAttach (InstanceLifecycleEvent event);
}
api/src/java/javax/jdo/listener/ClearCallback.java 100664 2511 12500110371 22365 0 ustar mbouschen staff 0 0 /*
* 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.
*/
/*
* ClearCallback.java
*
*/
package javax.jdo.listener;
/**
* This interface is used to notify instances of clear events.
* @version 2.0
* @since 2.0
*/
public interface ClearCallback {
/**
* Called before the values in the instance are cleared.
*
* Transient fields should be cleared in this method.
* Associations between this
* instance and others in the runtime environment should be cleared.
*
*
This method is not modified by the enhancer.
*/
void jdoPreClear();
}
api/src/java/javax/jdo/listener/ClearLifecycleListener.java 100664 4320 12500110371 24276 0 ustar mbouschen staff 0 0 /*
* 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.
*/
/*
* ClearLifecycleListener.java
*
*/
package javax.jdo.listener;
/**
* This interface is implemented by listeners to be notified of
* clear events.
* @version 2.0
* @since 2.0
*/
public interface ClearLifecycleListener
extends InstanceLifecycleListener {
/**
* This method is called before the implementation calls the instance
* method {@link ClearCallback#jdoPreClear} and before it clears the values
* in the instance to their Java default values. This happens during
* an application call to evict, and in afterCompletion for commit
* with RetainValues false and rollback with RestoreValues false.
*
The method is called during any state transition to hollow.
* Non-persistent, non-transactional fields should be cleared
* in this method. Associations between this instance and others
* in the runtime environment should be cleared.
*
This method is not modified by the enhancer, so access to fields
* is not mediated.
* @param event the clear event.
* @since 2.0
*/
void preClear (InstanceLifecycleEvent event);
/**
* This method is called after the {@link ClearCallback#jdoPreClear}
* method is invoked on the instance and the fields have been cleared
* by the JDO implementation.
* @param event the clear event.
* @since 2.0
*/
void postClear (InstanceLifecycleEvent event);
}
api/src/java/javax/jdo/listener/CreateLifecycleListener.java 100664 2547 12500110371 24464 0 ustar mbouschen staff 0 0 /*
* 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.
*/
/*
* CreateLifecycleListener.java
*
*/
package javax.jdo.listener;
/**
* This interface is implemented by listeners to be notified of
* create events.
* @version 2.0
* @since 2.0
*/
public interface CreateLifecycleListener
extends InstanceLifecycleListener {
/**
* Invoked whenever an instance is made persistent via a
* call to {@link javax.jdo.PersistenceManager#makePersistent} or during
* persistence by reachability.
* @param event the create event.
* @since 2.0
*/
void postCreate (InstanceLifecycleEvent event);
}
api/src/java/javax/jdo/listener/DeleteCallback.java 100664 2666 12500110371 22554 0 ustar mbouschen staff 0 0 /*
* 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.
*/
/*
* DeleteCallback.java
*
*/
package javax.jdo.listener;
/**
* This interface is used to notify instances of delete events.
* @version 2.0
* @since 2.0
*/
public interface DeleteCallback
{
/**
* Called before the instance is deleted.
* This method is called before the state transition to persistent-deleted
* or persistent-new-deleted. Access to field values within this call
* are valid. Access to field values after this call are disallowed.
*
This method is modified by the enhancer so that fields referenced
* can be used in the business logic of the method.
*/
void jdoPreDelete();
}
api/src/java/javax/jdo/listener/DeleteLifecycleListener.java 100664 3573 12500110371 24463 0 ustar mbouschen staff 0 0 /*
* 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.
*/
/*
* DeleteLifecycleListener.java
*
*/
package javax.jdo.listener;
/**
* This interface is implemented by listeners to be notified of
* delete events.
* @version 2.0
* @since 2.0
*/
public interface DeleteLifecycleListener
extends InstanceLifecycleListener {
/**
* Invoked whenever a persistent instance is deleted, for example
* during {@link javax.jdo.PersistenceManager#deletePersistent}.
* Access to field values within this call are permitted.
*
This method is called before the instance callback
* {@link DeleteCallback#jdoPreDelete}.
* @param event the delete event.
* @since 2.0
*/
void preDelete (InstanceLifecycleEvent event);
/**
* Invoked whenever a persistent instance is deleted, for example
* during {@link javax.jdo.PersistenceManager#deletePersistent}.
*
This method is called after the instance transitions
* to persistent-deleted. Access to field values is not permitted.
* @param event the delete event.
* @since 2.0
*/
void postDelete (InstanceLifecycleEvent event);
}
api/src/java/javax/jdo/listener/DetachCallback.java 100664 3041 12500110371 22526 0 ustar mbouschen staff 0 0 /*
* 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.
*/
/*
* DetachCallback.java
*
*/
package javax.jdo.listener;
/**
* This interface is used to notify instances of detach events.
* @version 2.0
* @since 2.0
*/
public interface DetachCallback {
/**
* This method is called during the execution of
* {@link javax.jdo.PersistenceManager#detachCopy} on the
* persistent instance before the copy is made.
* @since 2.0
*/
public void jdoPreDetach();
/**
* This method is called during the execution of
* {@link javax.jdo.PersistenceManager#detachCopy} on the
* detached instance after the copy is made.
* @param detached The corresponding (attached) persistent instance.
* @since 2.0
*/
public void jdoPostDetach(Object detached);
}
api/src/java/javax/jdo/listener/DetachLifecycleListener.java 100664 3533 12500110371 24445 0 ustar mbouschen staff 0 0 /*
* 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.
*/
/*
* DetachLifecycleListener.java
*
*/
package javax.jdo.listener;
/**
* This interface is implemented by listeners to be notified of
* detach events.
* @version 2.0
* @since 2.0
*/
public interface DetachLifecycleListener
extends InstanceLifecycleListener {
/**
* This method is called during the execution of
* {@link javax.jdo.PersistenceManager#detachCopy} before the
* detached copy is made. It is called before the method
* {@link DetachCallback#jdoPreDetach} is called on the
* instance to be detached.
* @param event the detach event.
* @since 2.0
*/
void preDetach (InstanceLifecycleEvent event);
/**
* This method is called during the execution of
* {@link javax.jdo.PersistenceManager#detachCopy} after the
* detached copy is made. It is called after the method
* {@link DetachCallback#jdoPreDetach} is called on
* the detached instance.
* @param event the detach event.
* @since 2.0
*/
void postDetach (InstanceLifecycleEvent event);
}
api/src/java/javax/jdo/listener/DirtyLifecycleListener.java 100664 3165 12500110371 24351 0 ustar mbouschen staff 0 0 /*
* 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.
*/
/*
* DirtyLifecycleListener.java
*
*/
package javax.jdo.listener;
/**
* This interface is implemented by listeners to be notified of
* dirty events.
* @version 2.0
* @since 2.0
*/
public interface DirtyLifecycleListener
extends InstanceLifecycleListener {
/**
* Invoked whenever a persistent instance is first made dirty,
* during an operation that modifies the value of a persistent or
* transactional field. Called before the value is changed.
* @since 2.0
*/
void preDirty (InstanceLifecycleEvent event);
/**
* Invoked whenever a persistent instance is first made dirty,
* during an operation that modifies the value of a persistent or
* transactional field. Called after the value is changed.
* @since 2.0
*/
void postDirty (InstanceLifecycleEvent event);
}
api/src/java/javax/jdo/listener/InstanceLifecycleEvent.java 100664 14577 12500110371 24347 0 ustar mbouschen staff 0 0 /*
* 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.
*/
/*
* InstanceLifecycleEvent.java
*
*/
package javax.jdo.listener;
import javax.jdo.spi.I18NHelper;
/**
* This is the event class used in life cycle event notifications.
*
Note that although InstanceLifecycleEvent inherits Serializable interface
* from EventObject, it is not intended to be Serializable. Appropriate
* serialization methods are implemented to throw NotSerializableException.
* @version 2.0
* @since 2.0
*/
public class InstanceLifecycleEvent
extends java.util.EventObject {
private static final int FIRST_EVENT_TYPE = 0;
public static final int CREATE = 0;
public static final int LOAD = 1;
public static final int STORE = 2;
public static final int CLEAR = 3;
public static final int DELETE = 4;
public static final int DIRTY = 5;
public static final int DETACH = 6;
public static final int ATTACH = 7;
private static final int LAST_EVENT_TYPE = 7;
/** The Internationalization message helper.
*/
private final static I18NHelper msg = I18NHelper.getInstance ("javax.jdo.Bundle"); //NOI18N
/**
* The event type that triggered the construction of this event object.
*/
private final int eventType;
/**
* The "other" object associated with the event.
*/
private final Object target;
/**
* Creates a new event object with the specified
* source and type.
* @param source the instance that triggered the event
* @param type the event type
* @since 2.0
*/
public InstanceLifecycleEvent (Object source, int type) {
this(source, type, null);
}
/**
* Creates a new event object with the specified
* source, type, and target.
* @param source the instance that triggered the event
* @param type the event type
* @param target the "other" instance
* @since 2.0
*/
public InstanceLifecycleEvent (Object source, int type, Object target) {
super (source);
if (type < FIRST_EVENT_TYPE || type > LAST_EVENT_TYPE) {
throw new IllegalArgumentException(msg.msg("EXC_IllegalEventType"));
}
eventType = type;
this.target = target;
}
/**
* Returns the event type that triggered this event.
* @return the event type
* @since 2.0
*/
public int getEventType () {
return eventType;
}
/**
* The source object of the Event. Although not deprecated,
* it is recommended that the the methods
* getPersistentInstance() and
* getDetachedInstance() be used instead.
*
* @return The persistent instance on any pre- callback except preAttach,
* or the detached instance for a postDetach or preAttach callback.
*
* @see #getPersistentInstance()
* @see #getDetachedInstance()
* @see "Section 12.15, Java Data Objects 2.0 Specification"
*/
public Object getSource() {
return super.getSource();
}
/**
* The target object of the Event. Although not deprecated,
* it is recommended that the the methods
* getPersistentInstance() and
* getDetachedInstance() be used instead.
*
* @return The detached instance for preDetach and postAttach,
* the persistent instance otherwise.
*
* @since 2.0
* @see #getPersistentInstance()
* @see #getDetachedInstance()
* @see "Section 12.15, Java Data Objects 2.0 Specification"
*/
public Object getTarget () {
return target;
}
/**
* Returns the persistent instance involved in the event.
*
* @return The persistent instance involved in the event, or null if there
* was none.
*
* @see "Section 12.15, Java Data Objects 2.0 Specification"
*/
public Object getPersistentInstance() {
switch (getEventType()) {
case DETACH:
return target == null
? getSource() // preDetach: source is persistent instance
: getTarget(); // postDetach: target is persistent instance
case ATTACH:
return target == null
? null // preAttach: no persistent instance yet
: getSource(); // postAttach: source is persistent instance
}
// for all other events, source is persistent instance
return getSource();
}
/**
* Returns the detached instance involved in the event.
*
* @return The detached instance involved in the event, or null if there was none.
*
* @see "Section 12.15, Java Data Objects 2.0 Specification"
*/
public Object getDetachedInstance() {
switch (getEventType()) {
case DETACH:
return target == null
? null // preDetach: no detached instance yet
: getSource(); // postDetach: source is detached instance
case ATTACH:
return target == null
? getSource() // preAttach: source is detached instance
: getTarget(); // postAttach: target is detached instance
}
// for all other events, there is no detached instance
return null;
}
/**
* Serialization is not supported for InstanceLifecycleEvents.
* param out the output stream
* @since 2.0
*/
private void writeObject(java.io.ObjectOutputStream out)
throws java.io.IOException {
throw new java.io.NotSerializableException();
}
}
api/src/java/javax/jdo/listener/InstanceLifecycleListener.java 100664 2324 12500110371 25016 0 ustar mbouschen staff 0 0 /*
* 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.
*/
/*
* InstanceLifecycleListener.java
*
*/
package javax.jdo.listener;
/**
* All lifecycle listeners extend from this base interface.
* In order to minimize the impact on domain classes, instance callbacks
* can be defined to use a life-cycle listener pattern instead of
* having the domain class implement the callback interface(s).
*
* @version 2.0
* @since 2.0
*/
public interface InstanceLifecycleListener {
}
api/src/java/javax/jdo/listener/LoadCallback.java 100664 2537 12500110371 22226 0 ustar mbouschen staff 0 0 /*
* 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.
*/
/*
* LoadCallback.java
*
*/
package javax.jdo.listener;
/**
* This interface is used to notify instances of load events.
* @version 2.0
* @since 2.0
*/
public interface LoadCallback {
/**
* Called after the values are loaded from the data store into
* this instance.
*
*
This method is not modified by the enhancer.
*
Derived fields should be initialized in this method.
* The context in which this call is made does not allow access to
* other persistent JDO instances.
*/
void jdoPostLoad();
}
api/src/java/javax/jdo/listener/LoadLifecycleListener.java 100664 2560 12500110371 24133 0 ustar mbouschen staff 0 0 /*
* 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.
*/
/*
* LoadLifecycleListener.java
*
*/
package javax.jdo.listener;
/**
* This interface is implemented by listeners to be notified of
* load events.
* @version 2.0
* @since 2.0
*/
public interface LoadLifecycleListener
extends InstanceLifecycleListener {
/**
* Invoked whenever a persistent instance is loaded from the data
* store. It is called after the method {@link LoadCallback#jdoPostLoad}
* is invoked on the persistent instance.
* @param event the load event.
* @since 2.0
*/
void postLoad (InstanceLifecycleEvent event);
}
api/src/java/javax/jdo/listener/package.html 100664 4566 12500110371 21354 0 ustar mbouschen staff 0 0
Listener package
There are two kinds of interfaces defined to allow an application to
manage life cycle changes to persistent objects.
The first kind is defined
on the persistent domain class itself. This allows methods in the domain class
to be called during life cycle events. The domain class implements one or more
of the interfaces
{@link javax.jdo.listener.AttachCallback},
{@link javax.jdo.listener.ClearCallback},
{@link javax.jdo.listener.DeleteCallback},
{@link javax.jdo.listener.DetachCallback},
{@link javax.jdo.listener.LoadCallback}, or
{@link javax.jdo.listener.StoreCallback}.
The methods in the interfaces
are called during life cycle events.
The second kind is defined on an external class using the listener pattern.
Instances of classes that implement one or more of the listener interfaces
{@link javax.jdo.listener.AttachLifecycleListener},
{@link javax.jdo.listener.ClearLifecycleListener},
{@link javax.jdo.listener.CreateLifecycleListener},
{@link javax.jdo.listener.DeleteLifecycleListener},
{@link javax.jdo.listener.DetachLifecycleListener},
{@link javax.jdo.listener.DirtyLifecycleListener},
{@link javax.jdo.listener.LoadLifecycleListener}, or
{@link javax.jdo.listener.StoreLifecycleListener}
are registered
with the PersistenceManager or PersistenceManagerFactory
and receive callbacks during life cycle events
of the persistent instances of interest.
api/src/java/javax/jdo/listener/StoreCallback.java 100664 3034 12500110371 22434 0 ustar mbouschen staff 0 0 /*
* 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.
*/
/*
* StoreCallback.java
*
*/
package javax.jdo.listener;
/**
* This interface is used to notify instances of store events.
* @version 2.0
* @since 2.0
*/
public interface StoreCallback {
/**
* Called before the values are stored from this instance to the
* data store.
*
*
Data store fields that might have been affected by modified
* non-persistent fields should be updated in this method.
*
*
This method is modified by the enhancer so that changes to
* persistent fields will be reflected in the data store.
* The context in which this call is made allows access to the
* PersistenceManager and other persistent JDO instances.
*/
void jdoPreStore();
}
api/src/java/javax/jdo/listener/StoreLifecycleListener.java 100664 3440 12500110371 24346 0 ustar mbouschen staff 0 0 /*
* 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.
*/
/*
* StoreLifecycleListener.java
*
*/
package javax.jdo.listener;
/**
* This interface is implemented by listeners to be notified of
* store events.
* @version 2.0
* @since 2.0
*/
public interface StoreLifecycleListener
extends InstanceLifecycleListener {
/**
* Invoked whenever a persistent instance is stored, for example during
* {@link javax.jdo.PersistenceManager#flush} or
* {@link javax.jdo.Transaction#commit}. It is called before the
* method {@link StoreCallback#jdoPreStore} is invoked.
* @param event the store event.
* @since 2.0
*/
void preStore (InstanceLifecycleEvent event);
/**
* Invoked whenever a persistent instance is stored, for example during
* {@link javax.jdo.PersistenceManager#flush} or
* {@link javax.jdo.Transaction#commit}. It is called after the
* field values have been stored.
* @param event the store event.
* @since 2.0
*/
void postStore (InstanceLifecycleEvent event);
}
api/src/java/javax/jdo/metadata/ArrayMetadata.java 100664 4325 12500110371 22401 0 ustar mbouschen staff 0 0 /*
* 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 javax.jdo.metadata;
/**
* Represents details of an array in a field/property in a class.
* @since 3.0
*/
public interface ArrayMetadata extends Metadata {
/**
* Method to set the name of the element type
*
* @param type Name of the element type
*/
ArrayMetadata setElementType(String type);
/**
* Accessor for the element type
*
* @return The element type
*/
String getElementType();
/**
* Method to set whether the element is embedded
*
* @param val Whether it is embedded
*/
ArrayMetadata setEmbeddedElement(boolean val);
/**
* Accessor for whether the element is embedded
*
* @return whether the element is embedded
*/
Boolean getEmbeddedElement();
/**
* Method to set whether the element is serialised
*
* @param val Whether it is serialised
*/
ArrayMetadata setSerializedElement(boolean val);
/**
* Accessor for whether the element is serialised
*
* @return whether the element is serialised
*/
Boolean getSerializedElement();
/**
* Method to set whether the element is dependent
*
* @param val Whether it is dependent
*/
ArrayMetadata setDependentElement(boolean val);
/**
* Accessor for whether the element is dependent
*
* @return whether the element is dependent
*/
Boolean getDependentElement();
}
api/src/java/javax/jdo/metadata/ClassMetadata.java 100664 3141 12500110371 22363 0 ustar mbouschen staff 0 0 /*
* 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 javax.jdo.metadata;
import java.lang.reflect.Field;
/**
* Represents a class.
* @since 3.0
*/
public interface ClassMetadata extends TypeMetadata {
/**
* Method to define the persistence modifier.
* @param mod persistence modifier
*/
ClassMetadata setPersistenceModifier(ClassPersistenceModifier mod);
/**
* Accessor for the persistence modifier.
* @return persistence modifier
*/
ClassPersistenceModifier getPersistenceModifier();
/**
* Add a new field to this class.
* @param name Name of the field
* @return The FieldMetadata
*/
FieldMetadata newFieldMetadata(String name);
/**
* Add a new field to this class.
* @param fld The field
* @return The FieldMetadata
*/
FieldMetadata newFieldMetadata(Field fld);
}
api/src/java/javax/jdo/metadata/ClassPersistenceModifier.java 100664 2000 12500110371 24577 0 ustar mbouschen staff 0 0 /*
* 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 javax.jdo.metadata;
/**
* Enumeration of the persistence-modifier values for a class.
* @since 3.0
*/
public enum ClassPersistenceModifier
{
PERSISTENCE_CAPABLE,
PERSISTENCE_AWARE,
NON_PERSISTENT
}
api/src/java/javax/jdo/metadata/CollectionMetadata.java 100664 4362 12500110371 23417 0 ustar mbouschen staff 0 0 /*
* 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 javax.jdo.metadata;
/**
* Represents details of a collection in a field/property in a class.
* @since 3.0
*/
public interface CollectionMetadata extends Metadata {
/**
* Method to set the name of the element type
*
* @param type Name of the element type
*/
CollectionMetadata setElementType(String type);
/**
* Accessor for the element type
*
* @return The element type
*/
String getElementType();
/**
* Method to set whether the element is embedded
*
* @param val Whether it is embedded
*/
CollectionMetadata setEmbeddedElement(boolean val);
/**
* Accessor for whether the element is embedded
*
* @return whether the element is embedded
*/
Boolean getEmbeddedElement();
/**
* Method to set whether the element is serialised
*
* @param val Whether it is serialised
*/
CollectionMetadata setSerializedElement(boolean val);
/**
* Accessor for whether the element is serialised
*
* @return whether the element is serialised
*/
Boolean getSerializedElement();
/**
* Method to set whether the element is dependent
*
* @param val Whether it is dependent
*/
CollectionMetadata setDependentElement(boolean val);
/**
* Accessor for whether the element is dependent
*
* @return whether the element is dependent
*/
Boolean getDependentElement();
}
api/src/java/javax/jdo/metadata/ColumnMetadata.java 100664 7465 12500110371 22570 0 ustar mbouschen staff 0 0 /*
* 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 javax.jdo.metadata;
/**
* Represents an element in a collection/array.
* @since 3.0
*/
public interface ColumnMetadata extends Metadata {
/**
* Method to set the column name.
*
* @param name Column name
*/
ColumnMetadata setName(String name);
/**
* Accessor for the name of the column.
*
* @return The name
*/
String getName();
/**
* Method to set the target column (at the other side of the relation).
*
* @param target Target column
*/
ColumnMetadata setTarget(String target);
/**
* Accessor for the name of the target column.
*
* @return Target column name
*/
String getTarget();
/**
* Method to set the target field (at the other side of the relation).
*
* @param target Target field
*/
ColumnMetadata setTargetField(String target);
/**
* Accessor for the name of the target field.
*
* @return Target field name
*/
String getTargetField();
/**
* Method to set the JDBC type.
*
* @param type JDBC Type
*/
ColumnMetadata setJDBCType(String type);
/**
* Accessor for the JDBC Type
*
* @return JDBC Type
*/
String getJDBCType();
/**
* Method to set the SQL type.
*
* @param type SQL Type
*/
ColumnMetadata setSQLType(String type);
/**
* Accessor for the SQL Type
*
* @return SQL Type
*/
String getSQLType();
/**
* Method to set the length
*
* @param len Length
*/
ColumnMetadata setLength(int len);
/**
* Accessor for the length
*
* @return length
*/
Integer getLength();
/**
* Method to set the scale
*
* @param scale scale
*/
ColumnMetadata setScale(int scale);
/**
* Accessor for the scale
*
* @return scale
*/
Integer getScale();
/**
* Method to set whether it allows null.
*
* @param nulls Allows null?
*/
ColumnMetadata setAllowsNull(boolean nulls);
/**
* Accessor for whether the column allows null.
*
* @return Allows null?
*/
Boolean getAllowsNull();
/**
* Method to set the default value.
*
* @param val Default value
*/
ColumnMetadata setDefaultValue(String val);
/**
* Accessor for the default value
*
* @return Default value
*/
String getDefaultValue();
/**
* Method to set the insert value (for columns with no field/property).
*
* @param val Insert value
*/
ColumnMetadata setInsertValue(String val);
/**
* Accessor for the insert value (for columns with no field/property)
*
* @return Insert value
*/
String getInsertValue();
/**
* Method to set the position
*
* @param pos Position
*/
ColumnMetadata setPosition(int pos);
/**
* Accessor for the position
*
* @return position
*/
Integer getPosition();
}
api/src/java/javax/jdo/metadata/DatastoreIdentityMetadata.java 100664 5422 12500110371 24762 0 ustar mbouschen staff 0 0 /*
* 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 javax.jdo.metadata;
import javax.jdo.annotations.IdGeneratorStrategy;
/**
* Represents the datastore identity of a class.
* @since 3.0
*/
public interface DatastoreIdentityMetadata extends Metadata {
/**
* Method to set the datastore identity column name.
*
* @param column Name of the datastore identity column
*/
DatastoreIdentityMetadata setColumn(String column);
/**
* Accessor for the datastore identity column name
*
* @return The column name
*/
String getColumn();
/**
* Method to set the identity generation strategy.
*
* @param strategy The strategy
*/
DatastoreIdentityMetadata setStrategy(IdGeneratorStrategy strategy);
/**
* Accessor for the identity generation strategy.
*
* @return The strategy
*/
IdGeneratorStrategy getStrategy();
/**
* Method to set the custom identity generation strategy.
*
* @param strategy The strategy
*/
DatastoreIdentityMetadata setCustomStrategy(String strategy);
/**
* Accessor for the custom strategy (overriding "strategy").
*
* @return The strategy
*/
String getCustomStrategy();
/**
* Method to set the sequence key (when using "sequence" strategy)
*
* @param seq Sequence key
*/
DatastoreIdentityMetadata setSequence(String seq);
/**
* Accessor for the sequence key (when using "sequence" strategy)
*
* @return The sequence
*/
String getSequence();
/**
* Accessor for all column(s) defined on the datastore identity.
*
* @return The column(s)
*/
ColumnMetadata[] getColumns();
/**
* Add a new column for this datastore identity.
*
* @return The ColumnMetadata
*/
ColumnMetadata newColumnMetadata();
/**
* Accessor for the number of columns defined for this datastore identity.
*
* @return The number of columns
*/
int getNumberOfColumns();
}
api/src/java/javax/jdo/metadata/DiscriminatorMetadata.java 100664 6063 12500110371 24133 0 ustar mbouschen staff 0 0 /*
* 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 javax.jdo.metadata;
import javax.jdo.annotations.DiscriminatorStrategy;
/**
* Represents the discriminator for inheritance purposes for this class.
* @since 3.0
*/
public interface DiscriminatorMetadata extends Metadata {
/**
* Method to set the discriminator column.
*
* @param column Name of the discriminator clumn
*/
DiscriminatorMetadata setColumn(String column);
/**
* Accessor for the discriminator column name
*
* @return The column name
*/
String getColumn();
/**
* Method to set the discriminator value (when using "value-map" strategy).
*
* @param val Value for the discriminator for this class
*/
DiscriminatorMetadata setValue(String val);
/**
* Accessor for the discriminator value (when using "value-map" strategy).
*
* @return The value
*/
String getValue();
/**
* Method to set the discriminator strategy.
*
* @param strategy The strategy
*/
DiscriminatorMetadata setStrategy(DiscriminatorStrategy strategy);
/**
* Accessor for the discriminator strategy.
*
* @return The strategy
*/
DiscriminatorStrategy getStrategy();
/**
* Method to set whether indexed.
*
* @param indexed Whether indexed (true | false | unique)
*/
DiscriminatorMetadata setIndexed(Indexed indexed);
/**
* Accessor for whether indexed (true|false|unique)
*
* @return Indexed?
*/
Indexed getIndexed();
/**
* Accessor for all column(s) defined on the discriminator.
*
* @return The column(s)
*/
ColumnMetadata[] getColumns();
/**
* Add a new column for this discriminator.
*
* @return The ColumnMetadata
*/
ColumnMetadata newColumnMetadata();
/**
* Accessor for the number of columns defined for this discriminator.
*
* @return The number of columns
*/
int getNumberOfColumns();
/**
* Method to set the index metadata for the discriminator
*
* @return The IndexMetadata
*/
IndexMetadata newIndexMetadata();
/**
* Accessor for any index metadata for the discriminator
*
* @return Index metadata
*/
IndexMetadata getIndexMetadata();
}
api/src/java/javax/jdo/metadata/ElementMetadata.java 100664 7532 12500110371 22717 0 ustar mbouschen staff 0 0 /*
* 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 javax.jdo.metadata;
import javax.jdo.annotations.ForeignKeyAction;
/**
* Represents an element in a collection/array.
* @since 3.0
*/
public interface ElementMetadata extends Metadata {
/**
* Method to set the column name.
*
* @param column Column name
*/
ElementMetadata setColumn(String column);
/**
* Accessor for the name of the column.
*
* @return The name
*/
String getColumn();
/**
* Method to set the table name.
*
* @param table Table name
*/
ElementMetadata setTable(String table);
/**
* Accessor for the name of the table.
*
* @return The name
*/
String getTable();
/**
* Method to set the delete action of the FK
*
* @param action Delete action of the FK
*/
ElementMetadata setDeleteAction(ForeignKeyAction action);
/**
* Accessor for the delete action of the FK
*
* @return The FK delete-action
*/
ForeignKeyAction getDeleteAction();
/**
* Method to set the update action of the FK
*
* @param action Update action of the FK
*/
ElementMetadata setUpdateAction(ForeignKeyAction action);
/**
* Accessor for the update action of the FK
*
* @return The FK update-action
*/
ForeignKeyAction getUpdateAction();
/**
* Accessor for all column(s) defined on the element.
*
* @return The column(s)
*/
ColumnMetadata[] getColumns();
/**
* Add a new column for this element.
*
* @return The ColumnMetadata
*/
ColumnMetadata newColumnMetadata();
/**
* Accessor for the number of columns defined for this element.
*
* @return The number of columns
*/
int getNumberOfColumns();
/**
* Method to set new embedded metadata for the element.
*
* @return The EmbeddedMetadata
*/
EmbeddedMetadata newEmbeddedMetadata();
/**
* Accessor for any embedded metadata on this element
*
* @return The EmbeddedMetadata
*/
EmbeddedMetadata getEmbeddedMetadata();
/**
* Method to set new index metadata for the element.
*
* @return The IndexMetadata
*/
IndexMetadata newIndexMetadata();
/**
* Accessor for any index metadata on this element
*
* @return Index metadata
*/
IndexMetadata getIndexMetadata();
/**
* Method to set new unique constraint metadata for the element
*
* @return The UniqueMetadata
*/
UniqueMetadata newUniqueMetadata();
/**
* Accessor for any unique constraint metadata on this element.
*
* @return The UniqueMetadata
*/
UniqueMetadata getUniqueMetadata();
/**
* Method to set new foreign key metadata for the element
*
* @return The ForeignKeyMetadata
*/
ForeignKeyMetadata newForeignKeyMetadata();
/**
* Accessor for any foreign key metadata on this element.
*
* @return The ForeignKeyMetadata
*/
ForeignKeyMetadata getForeignKeyMetadata();
}
api/src/java/javax/jdo/metadata/EmbeddedMetadata.java 100664 6023 12500110371 23011 0 ustar mbouschen staff 0 0 /*
* 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 javax.jdo.metadata;
/**
* Represents embedding details of a field/property in a class.
* @since 3.0
*/
public interface EmbeddedMetadata extends Metadata {
/**
* Method to set the name of the owner field/property.
*
* @param member Name of the owner member
*/
EmbeddedMetadata setOwnerMember(String member);
/**
* Accessor for the owner field/property name.
*
* @return The owner member name
*/
String getOwnerMember();
/**
* Method to set any column that indicates a null embedded object
*
* @param col Null indicator column
*/
EmbeddedMetadata setNullIndicatorColumn(String col);
/**
* Accessor for any column indicating a null embedded object
*
* @return Whether to call post-load
*/
String getNullIndicatorColumn();
/**
* Method to set the value of a null indicator column to signify null object
*
* @param val Null indicator value
*/
EmbeddedMetadata setNullIndicatorValue(String val);
/**
* Accessor for a null indicator value
*
* @return Null indicator value
*/
String getNullIndicatorValue();
/**
* Accessor for all fields/properties defined on the fetch group.
*
* @return The members
*/
MemberMetadata[] getMembers();
/**
* Accessor for the number of fields/properties defined for embedding
*
* @return The number of members
*/
int getNumberOfMembers();
/**
* Add a new field to be embedded.
*
* @param name Name of the field
* @return The FieldMetadata
*/
FieldMetadata newFieldMetadata(String name);
/**
* Add a new property for embedding
*
* @param name Name of the property
* @return The PropertyMetadata
*/
PropertyMetadata newPropertyMetadata(String name);
/**
* Accessor for the discriminator metadata when handling inherited objects.
* @return Discriminator details
*/
DiscriminatorMetadata getDiscriminatorMetadata();
/**
* Method to define the new discriminator metadata for handling inherited embedded objects.
* @return Discriminator metadata
*/
DiscriminatorMetadata newDiscriminatorMetadata();
}
api/src/java/javax/jdo/metadata/ExtensionMetadata.java 100664 2423 12500110371 23274 0 ustar mbouschen staff 0 0 /*
* 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 javax.jdo.metadata;
/**
* A vendor extension defined in Metadata.
*
* @version 3.0
*/
public interface ExtensionMetadata {
/**
* Accessor for the vendor name (set at construction).
* @return The vendor
*/
String getVendorName();
/**
* Accessor for the key (set at construction).
* @return The key
*/
String getKey();
/**
* Accessor for the value (set at construction).
* @return The value
*/
String getValue();
}
api/src/java/javax/jdo/metadata/FetchGroupMetadata.java 100664 4136 12500110371 23371 0 ustar mbouschen staff 0 0 /*
* 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 javax.jdo.metadata;
/**
* Represents a fetch group for a class.
* @since 3.0
*/
public interface FetchGroupMetadata extends Metadata {
/**
* Accessor for the fetch group name (set on construction).
*
* @return The fetch group name
*/
String getName();
/**
* Method to set whether to call post load with this fetch group
*
* @param load Call post load
*/
FetchGroupMetadata setPostLoad(boolean load);
/**
* Accessor for whether to call post load for this fetch group
*
* @return Whether to call post-load
*/
Boolean getPostLoad();
/**
* Accessor for all fields/properties defined on the fetch group.
* @return The members
*/
MemberMetadata[] getMembers();
/**
* Accessor for the number of fields/properties defined for this fetch group.
*
* @return The number of members
*/
int getNumberOfMembers();
/**
* Add a new field for this fetch group.
*
* @param name Name of field
* @return The FieldMetadata
*/
FieldMetadata newFieldMetadata(String name);
/**
* Add a new property for this fetch group
*
* @param name Name of property
* @return The PropertyMetadata
*/
PropertyMetadata newPropertyMetadata(String name);
}
api/src/java/javax/jdo/metadata/FetchPlanMetadata.java 100664 4250 12500110371 23164 0 ustar mbouschen staff 0 0 /*
* 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 javax.jdo.metadata;
/**
* Represents a fetch plan for a class.
* @since 3.0
*/
public interface FetchPlanMetadata extends Metadata {
/**
* Accessor for the fetch plan name (set on construction).
*
* @return The fetch plan name
*/
String getName();
/**
* Method to set the max fetch depth for this plan.
*
* @param depth The max fetch depth
*/
FetchPlanMetadata setMaxFetchDepth(int depth);
/**
* Accessor for the max fetch depth.
*
* @return The max fetch depth
*/
int getMaxFetchDepth();
/**
* Method to set the fetch size.
*
* @param size The fetch size
*/
FetchPlanMetadata setFetchSize(int size);
/**
* Accessor for the max fetch depth.
*
* @return The max fetch depth
*/
int getFetchSize();
/**
* Accessor for all fetch groups defined for this fetch plan.
*
* @return The fetch groups
*/
FetchGroupMetadata[] getFetchGroups();
/**
* Add a new fetch group for this fetch plan.
*
* @param name Name of fetch group.
* @return The FetchGroupMetadata
*/
FetchGroupMetadata newFetchGroupMetadata(String name);
/**
* Accessor for the number of fetch groups defined for this fetch plan.
*
* @return The number of fetch groups
*/
int getNumberOfFetchGroups();
}
api/src/java/javax/jdo/metadata/FieldMetadata.java 100664 1662 12500110371 22347 0 ustar mbouschen staff 0 0 /*
* 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 javax.jdo.metadata;
/**
* Represents a field in a class.
* @since 3.0
*/
public interface FieldMetadata extends MemberMetadata {
}
api/src/java/javax/jdo/metadata/ForeignKeyMetadata.java 100664 7417 12500110371 23372 0 ustar mbouschen staff 0 0 /*
* 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 javax.jdo.metadata;
import javax.jdo.annotations.ForeignKeyAction;
/**
* Represents a FK constraint in an ORM context.
* @since 3.0
*/
public interface ForeignKeyMetadata extends Metadata {
/**
* Method to set the name of the constraint
*
* @param name Name of the constraint
*/
ForeignKeyMetadata setName(String name);
/**
* Accessor for the constraint name.
*
* @return The constraint name
*/
String getName();
/**
* Method to set the table name.
*
* @param table Table name
*/
ForeignKeyMetadata setTable(String table);
/**
* Accessor for the name of the table.
*
* @return The name
*/
String getTable();
/**
* Method to set whether it is unique.
*
* @param unique Unique?
*/
ForeignKeyMetadata setUnique(boolean unique);
/**
* Accessor for whether unique.
*
* @return Unique?
*/
Boolean getUnique();
/**
* Method to set whether it is deferred.
*
* @param def Deferred?
*/
ForeignKeyMetadata setDeferred(boolean def);
/**
* Accessor for whether the constraint can be deferred.
*
* @return Deferred?
*/
Boolean getDeferred();
/**
* Method to set the delete action of the FK
*
* @param action Delete action of the FK
*/
ForeignKeyMetadata setDeleteAction(ForeignKeyAction action);
/**
* Accessor for the delete action of the FK
*
* @return The FK delete-action
*/
ForeignKeyAction getDeleteAction();
/**
* Method to set the update action of the FK
*
* @param action Update action of the FK
*/
ForeignKeyMetadata setUpdateAction(ForeignKeyAction action);
/**
* Accessor for the update action of the FK
*
* @return The FK update-action
*/
ForeignKeyAction getUpdateAction();
/**
* Accessor for all column(s) defined on the FK.
*
* @return The column(s)
*/
ColumnMetadata[] getColumns();
/**
* Add a new column for this FK.
*
* @return The ColumnMetadata
*/
ColumnMetadata newColumnMetadata();
/**
* Accessor for the number of columns defined for this FK.
*
* @return The number of columns
*/
int getNumberOfColumns();
/**
* Accessor for all fields/properties defined on the FK.
* @return The members
*/
MemberMetadata[] getMembers();
/**
* Accessor for the number of fields/properties defined for this FK.
* @return The number of members
*/
int getNumberOfMembers();
/**
* Add a new field for this FK.
*
* @param name Name of the field
* @return The FieldMetadata
*/
FieldMetadata newFieldMetadata(String name);
/**
* Add a new property for this FK.
*
* @param name Name of the property
* @return The PropertyMetadata
*/
PropertyMetadata newPropertyMetadata(String name);
}
api/src/java/javax/jdo/metadata/Indexed.java 100664 1730 12500110371 21237 0 ustar mbouschen staff 0 0 /*
* 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 javax.jdo.metadata;
/**
* Enumeration of the indexed values.
*
* @version 3.0
* @since 3.0
*/
public enum Indexed
{
UNSPECIFIED,
TRUE,
FALSE,
UNIQUE
}
api/src/java/javax/jdo/metadata/IndexMetadata.java 100664 5407 12500110371 22374 0 ustar mbouschen staff 0 0 /*
* 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 javax.jdo.metadata;
/**
* Represents an index.
* @since 3.0
*/
public interface IndexMetadata extends Metadata {
/**
* Method to set the name of the index
*
* @param name Name of the index
*/
IndexMetadata setName(String name);
/**
* Accessor for the index name.
*
* @return The index name
*/
String getName();
/**
* Method to set the table name.
*
* @param table Table name
*/
IndexMetadata setTable(String table);
/**
* Accessor for the name of the table.
*
* @return The name
*/
String getTable();
/**
* Method to set whether it is unique.
*
* @param unique Unique?
*/
IndexMetadata setUnique(boolean unique);
/**
* Accessor for whether unique.
*
* @return Unique?
*/
boolean getUnique();
/**
* Accessor for all column(s) defined on the index.
*
* @return The column(s)
*/
ColumnMetadata[] getColumns();
/**
* Add a new column for this index.
*
* @return The ColumnMetadata
*/
ColumnMetadata newColumn();
/**
* Accessor for the number of columns defined for this index.
*
* @return The number of columns
*/
int getNumberOfColumns();
/**
* Accessor for all member(s) defined on the index.
*
* @return The fields/properties
*/
MemberMetadata[] getMembers();
/**
* Accessor for the number of fields/properties defined for this index.
*
* @return The number of members
*/
int getNumberOfMembers();
/**
* Add a new field for this index.
*
* @param name Name of the field
* @return The FieldMetadata
*/
FieldMetadata newFieldMetadata(String name);
/**
* Add a new property for this index.
*
* @param name Name of the property
* @return The PropertyMetadata
*/
PropertyMetadata newPropertyMetadata(String name);
}
api/src/java/javax/jdo/metadata/InheritanceMetadata.java 100664 4312 12500110371 23550 0 ustar mbouschen staff 0 0 /*
* 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 javax.jdo.metadata;
import javax.jdo.annotations.InheritanceStrategy;
/**
* Represents the inheritance of a class.
* @since 3.0
*/
public interface InheritanceMetadata extends Metadata {
/**
* Method to set the inheritance strategy.
*
* @param strategy The strategy
*/
InheritanceMetadata setStrategy(InheritanceStrategy strategy);
/**
* Accessor for the inheritance strategy.
*
* @return The strategy
*/
InheritanceStrategy getStrategy();
/**
* Method to set the custom inheritance strategy.
*
* @param strategy The strategy
*/
InheritanceMetadata setCustomStrategy(String strategy);
/**
* Accessor for the custom inheritance (overriding "strategy").
*
* @return The strategy
*/
String getCustomStrategy();
/**
* Method to define the new discriminator metadata.
*
* @return The DiscriminatorMetadata
*/
DiscriminatorMetadata newDiscriminatorMetadata();
/**
* Accessor for the discriminator (if any).
*
* @return Discriminator
*/
DiscriminatorMetadata getDiscriminatorMetadata();
/**
* Method to define the new join information
*
* @return The JoinMetadata
*/
JoinMetadata newJoinMetadata();
/**
* Accessor for the join (if any).
*
* @return Join information
*/
JoinMetadata getJoinMetadata();
}
api/src/java/javax/jdo/metadata/InterfaceMetadata.java 100664 1674 12500110371 23227 0 ustar mbouschen staff 0 0 /*
* 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 javax.jdo.metadata;
/**
* Represents a persistent-interface.
* @since 3.0
*/
public interface InterfaceMetadata extends TypeMetadata {
}
api/src/java/javax/jdo/metadata/JDOMetadata.java 100664 7530 12500110371 21740 0 ustar mbouschen staff 0 0 /*
* 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 javax.jdo.metadata;
/**
* Represents the top-level JDO metadata.
* @since 3.0
*/
public interface JDOMetadata extends Metadata {
/**
* Method to set the catalog (ORM) to apply to all classes in this
* JDO Metadata.
*
* @param catalog Catalog name
*/
JDOMetadata setCatalog(String catalog);
/**
* Accessor for the catalog (ORM) that all classes in this JDO Metadata
* default to.
*
* @return The catalog
*/
String getCatalog();
/**
* Method to set the schema (ORM) to apply to all classes in this JDO
* Metadata.
*
* @param schema Schema name
*/
JDOMetadata setSchema(String schema);
/**
* Accessor for the schema (ORM) that all classes in this JDO Metadata
* default to.
*
* @return The schema
*/
String getSchema();
/**
* Accessor for all packages defined on the JDO Metadata.
*
* @return The packages
*/
PackageMetadata[] getPackages();
/**
* Add a new package to this JDO Metadata.
*
* @param pkgName Name of the package
* @return The PackageMetadata
*/
PackageMetadata newPackageMetadata(String pkgName);
/**
* Add a new package to this JDO Metadata.
*
* @param pkg The package
* @return The PackageMetadata
*/
PackageMetadata newPackageMetadata(Package pkg);
/**
* Accessor for the number of packages defined in this JDO Metadata.
*
* @return The number of packages.
*/
int getNumberOfPackages();
/**
* Add a new class to this JDO Metadata.
* Adds its package also if not yet existing.
*
* @param cls Class to add
* @return The ClassMetadata
*/
ClassMetadata newClassMetadata(Class cls);
/**
* Add a new interface to this JDO Metadata.
* Adds its package also if not yet existing.
*
* @param cls Class to add
* @return The InterfaceMetadata
*/
InterfaceMetadata newInterfaceMetadata(Class cls);
/**
* Accessor for any named queries defined on the JDO Metadata.
*
* @return The queries
*/
QueryMetadata[] getQueries();
/**
* Add a new named query to this JDO Metadata.
*
* @param name Name of the query
* @return The QueryMetadata
*/
QueryMetadata newQueryMetadata(String name);
/**
* Accessor for the number of named queries defined in this JDO Metadata.
*
* @return The number of queries.
*/
int getNumberOfQueries();
/**
* Accessor for any fetch plans defined on the JDO Metadata.
*
* @return The fetch plans
*/
FetchPlanMetadata[] getFetchPlans();
/**
* Add a new fetch plan to this JDO Metadata.
*
* @param name Name of the query
* @return The FetchPlanMetadata
*/
FetchPlanMetadata newFetchPlanMetadata(String name);
/**
* Accessor for the number of fetch plans defined in this JDO Metadata.
*
* @return The number of fetch plans.
*/
int getNumberOfFetchPlans();
}
api/src/java/javax/jdo/metadata/JoinMetadata.java 100664 10460 12500110371 22237 0 ustar mbouschen staff 0 0 /*
* 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 javax.jdo.metadata;
import javax.jdo.annotations.ForeignKeyAction;
/**
* Represents join information.
* @since 3.0
*/
public interface JoinMetadata extends Metadata {
/**
* Method to set the join column.
*
* @param column Name of the join column
*/
JoinMetadata setColumn(String column);
/**
* Accessor for the join column name
*
* @return The column name
*/
String getColumn();
/**
* Method to set the table name.
*
* @param table Table name
*/
JoinMetadata setTable(String table);
/**
* Accessor for the name of the table.
*
* @return The name
*/
String getTable();
/**
* Method to set whether to use an outer join
*
* @param outer Outer join?
*/
JoinMetadata setOuter(boolean outer);
/**
* Accessor for whether to use an outer join.
*
* @return Outer join?
*/
boolean getOuter();
/**
* Method to set the delete action of the FK
*
* @param action Delete action of the FK
*/
JoinMetadata setDeleteAction(ForeignKeyAction action);
/**
* Accessor for the delete action of the FK
*
* @return The FK delete-action
*/
ForeignKeyAction getDeleteAction();
/**
* Method to set whether indexed.
*
* @param indexed Whether indexed (true | false | unique)
*/
JoinMetadata setIndexed(Indexed indexed);
/**
* Accessor for whether indexed (true|false|unique)
*
* @return Indexed?
*/
Indexed getIndexed();
/**
* Method to set whether it is unique.
*
* @param unique Unique?
*/
JoinMetadata setUnique(boolean unique);
/**
* Accessor for whether unique.
*
* @return Unique?
*/
Boolean getUnique();
/**
* Method to set new index metadata for the join.
*
* @return The IndexMetadata
*/
IndexMetadata newIndexMetadata();
/**
* Accessor for any index metadata on this join
*
* @return Index metadata
*/
IndexMetadata getIndexMetadata();
/**
* Method to set new unique constraint metadata for the join
*
* @return The UniqueMetadata
*/
UniqueMetadata newUniqueMetadata();
/**
* Accessor for any unique constraint metadata on this join.
*
* @return The UniqueMetadata
*/
UniqueMetadata getUniqueMetadata();
/**
* Method to set new foreign key metadata for the join
*
* @return The ForeignKeyMetadata
*/
ForeignKeyMetadata newForeignKeyMetadata();
/**
* Accessor for any foreign key metadata on this join.
*
* @return The ForeignKeyMetadata
*/
ForeignKeyMetadata getForeignKeyMetadata();
/**
* Method to set new primary key metadata for the join
*
* @return The PrimaryKeyMetadata
*/
PrimaryKeyMetadata newPrimaryKeyMetadata();
/**
* Accessor for any primary key metadata on this join.
*
* @return The PrimaryKeyMetadata
*/
PrimaryKeyMetadata getPrimaryKeyMetadata();
/**
* Accessor for all column(s) defined on the join.
*
* @return The column(s)
*/
ColumnMetadata[] getColumns();
/**
* Add a new column for this join.
*
* @return The ColumnMetadata
*/
ColumnMetadata newColumnMetadata();
/**
* Accessor for the number of columns defined for this join.
*
* @return The number of columns
*/
int getNumberOfColumns();
}
api/src/java/javax/jdo/metadata/KeyMetadata.java 100664 7371 12500110371 22057 0 ustar mbouschen staff 0 0 /*
* 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 javax.jdo.metadata;
import javax.jdo.annotations.ForeignKeyAction;
/**
* Represents a key in a map.
*/
public interface KeyMetadata extends Metadata {
/**
* Method to set the column name.
*
* @param column Column name
*/
KeyMetadata setColumn(String column);
/**
* Accessor for the name of the column.
*
* @return The name
*/
String getColumn();
/**
* Method to set the table name.
*
* @param table Table name
*/
KeyMetadata setTable(String table);
/**
* Accessor for the name of the table.
*
* @return The name
*/
String getTable();
/**
* Method to set the delete action of the FK
*
* @param action Delete action of the FK
*/
KeyMetadata setDeleteAction(ForeignKeyAction action);
/**
* Accessor for the delete action of the FK
*
* @return The FK delete-action
*/
ForeignKeyAction getDeleteAction();
/**
* Method to set the update action of the FK
*
* @param action Update action of the FK
*/
KeyMetadata setUpdateAction(ForeignKeyAction action);
/**
* Accessor for the update action of the FK
*
* @return The FK update-action
*/
ForeignKeyAction getUpdateAction();
/**
* Accessor for all column(s) defined on the key.
*
* @return The column(s)
*/
ColumnMetadata[] getColumns();
/**
* Add a new column for this key.
*
* @return The ColumnMetadata
*/
ColumnMetadata newColumnMetadata();
/**
* Accessor for the number of columns defined for this key.
*
* @return The number of columns
*/
int getNumberOfColumns();
/**
* Method to set new embedded metadata for the key.
*
* @return The EmbeddedMetadata
*/
EmbeddedMetadata newEmbeddedMetadata();
/**
* Accessor for any embedded metadata on this key
*
* @return The EmbeddedMetadata
*/
EmbeddedMetadata getEmbeddedMetadata();
/**
* Method to set new index metadata for the key.
*
* @return The IndexMetadata
*/
IndexMetadata newIndexMetadata();
/**
* Accessor for any index metadata on this key
*
* @return Index metadata
*/
IndexMetadata getIndexMetadata();
/**
* Method to set new unique constraint metadata for the key
*
* @return The UniqueMetadata
*/
UniqueMetadata newUniqueMetadata();
/**
* Accessor for any unique constraint metadata on this key.
*
* @return The UniqueMetadata
*/
UniqueMetadata getUniqueMetadata();
/**
* Method to set new foreign key metadata for the key
*
* @return The ForeignKeyMetadata
*/
ForeignKeyMetadata newForeignKeyMetadata();
/**
* Accessor for any foreign key metadata on this key.
*
* @return The ForeignKeyMetadata
*/
ForeignKeyMetadata getForeignKeyMetadata();
} api/src/java/javax/jdo/metadata/MapMetadata.java 100664 6515 12500110371 22043 0 ustar mbouschen staff 0 0 /*
* 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 javax.jdo.metadata;
/**
* Represents details of a map in a field/property in a class.
* @since 3.0
*/
public interface MapMetadata extends Metadata {
/**
* Method to set the name of the key type
*
* @param type Name of the key type
*/
MapMetadata setKeyType(String type);
/**
* Accessor for the key type
*
* @return The key type
*/
String getKeyType();
/**
* Method to set whether the key is embedded
*
* @param val Whether it is embedded
*/
MapMetadata setEmbeddedKey(boolean val);
/**
* Accessor for whether the key is embedded
*
* @return whether the key is embedded
*/
Boolean getEmbeddedKey();
/**
* Method to set whether the key is serialised
*
* @param val Whether it is serialised
*/
MapMetadata setSerializedKey(boolean val);
/**
* Accessor for whether the key is serialised
*
* @return whether the key is serialised
*/
Boolean getSerializedKey();
/**
* Method to set whether the key is dependent
*
* @param val Whether it is dependent
*/
MapMetadata setDependentKey(boolean val);
/**
* Accessor for whether the key is dependent
*
* @return whether the key is dependent
*/
Boolean getDependentKey();
/**
* Method to set the name of the value type
*
* @param type Name of the value type
*/
MapMetadata setValueType(String type);
/**
* Accessor for the value type
*
* @return The value type
*/
String getValueType();
/**
* Method to set whether the value is embedded
*
* @param val Whether it is embedded
*/
MapMetadata setEmbeddedValue(boolean val);
/**
* Accessor for whether the value is embedded
*
* @return whether the value is embedded
*/
Boolean getEmbeddedValue();
/**
* Method to set whether the value is serialised
*
* @param val Whether it is serialised
*/
MapMetadata setSerializedValue(boolean val);
/**
* Accessor for whether the value is serialised
*
* @return whether the value is serialised
*/
Boolean getSerializedValue();
/**
* Method to set whether the value is dependent
*
* @param val Whether it is dependent
*/
MapMetadata setDependentValue(boolean val);
/**
* Accessor for whether the value is dependent
*
* @return whether the value is dependent
*/
Boolean getDependentValue();
}
api/src/java/javax/jdo/metadata/MemberMetadata.java 100664 26200 12500110371 22546 0 ustar mbouschen staff 0 0 /*
* 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 javax.jdo.metadata;
import javax.jdo.annotations.ForeignKeyAction;
import javax.jdo.annotations.IdGeneratorStrategy;
import javax.jdo.annotations.NullValue;
import javax.jdo.annotations.PersistenceModifier;
/**
* Represents a field/property in a class/persistent-interface.
* @since 3.0
*/
public interface MemberMetadata extends Metadata {
/**
* Method to set the name.
*
* @param name name
*/
MemberMetadata setName(String name);
/**
* Accessor for the name of the field/property.
*
* @return The name
*/
String getName();
/**
* Method to set the table name.
*
* @param table Table name
*/
MemberMetadata setTable(String table);
/**
* Accessor for the name of the table.
*
* @return The name
*/
String getTable();
/**
* Method to set the column name.
*
* @param col Column name
*/
MemberMetadata setColumn(String col);
/**
* Accessor for the name of the column.
*
* @return The column name
*/
String getColumn();
/**
* Method to set the field type(s). For defining where we want to restrict
* what type is stored in a field
*
* @param type Type of field
*/
MemberMetadata setFieldType(String type);
/**
* Accessor for the type storable in the field
*
* @return The field type
*/
String getFieldType();
/**
* Method to set the delete action of the FK
*
* @param action Delete action of the FK
*/
MemberMetadata setDeleteAction(ForeignKeyAction action);
/**
* Accessor for the delete action of the FK
*
* @return The FK delete-action
*/
ForeignKeyAction getDeleteAction();
/**
* Method to set the persistence-modifier of the field/property.
*
* @param mod persistence modifier
*/
MemberMetadata setPersistenceModifier(PersistenceModifier mod);
/**
* Accessor for the persistence modifier of the field/property.
*
* @return The persistence modifier
*/
PersistenceModifier getPersistenceModifier();
/**
* Method to set the behaviour of a null value
*
* @param val Null value behaviour
*/
MemberMetadata setNullValue(NullValue val);
/**
* Accessor for the behaviour of a null value
*
* @return The null value behaviour
*/
NullValue getNullValue();
/**
* Method to set whether it is in the DFG.
*
* @param dfg DFG?
*/
MemberMetadata setDefaultFetchGroup(boolean dfg);
/**
* Accessor for whether part of the DFG.
*
* @return dfg?
*/
Boolean getDefaultFetchGroup();
/**
* Method to set whether it is unique.
*
* @param unique Unique?
*/
MemberMetadata setDependent(boolean unique);
/**
* Accessor for whether unique.
*
* @return Unique?
*/
Boolean getDependent();
/**
* Method to set whether it is embedded.
*
* @param emb Embedded?
*/
MemberMetadata setEmbedded(boolean emb);
/**
* Accessor for whether it is embedded.
*
* @return embedded?
*/
Boolean getEmbedded();
/**
* Method to set whether it is serialized.
*
* @param ser serialized?
*/
MemberMetadata setSerialized(boolean ser);
/**
* Accessor for whether it is serialized.
*
* @return serialized?
*/
Boolean getSerialized();
/**
* Method to set whether it is part of the pk
*
* @param pk PK?
*/
MemberMetadata setPrimaryKey(boolean pk);
/**
* Accessor for whether it is part of the pk.
*
* @return pk?
*/
boolean getPrimaryKey();
/**
* Method to set whether it is indexed.
*
* @param index Indexed?
*/
MemberMetadata setIndexed(boolean index);
/**
* Accessor for whether it is indexed.
*
* @return Indexed?
*/
Boolean getIndexed();
/**
* Method to set whether it is unique.
*
* @param unique Unique?
*/
MemberMetadata setUnique(boolean unique);
/**
* Accessor for whether unique.
*
* @return Unique?
*/
Boolean getUnique();
/**
* Method to set whether this is cacheable
*
* @param cacheable Cacheable?
*/
MemberMetadata setCacheable(boolean cacheable);
/**
* Accessor for whether this is cacheable.
*
* @return Detachable?
*/
boolean getCacheable();
/**
* Method to set the recursion depth (when used in a fetch group).
*
* @param depth Recursion depth
*/
MemberMetadata setRecursionDepth(int depth);
/**
* Accessor for the recursion depth (when part of a fetch group).
*
* @return Recursion depth?
*/
int getRecursionDepth();
/**
* Method to set the load fetch group.
*
* @param grp Load fetch group
*/
MemberMetadata setLoadFetchGroup(String grp);
/**
* Accessor for the name of the load fetch group
*
* @return The load fetch group
*/
String getLoadFetchGroup();
/**
* Method to set the value strategy
*
* @param str Value strategy
*/
MemberMetadata setValueStrategy(IdGeneratorStrategy str);
/**
* Accessor for the value strategy
*
* @return Value strategy
*/
IdGeneratorStrategy getValueStrategy();
/**
* Method to set the custom identity generation strategy.
*
* @param strategy The strategy
*/
MemberMetadata setCustomStrategy(String strategy);
/**
* Accessor for the custom strategy (overriding "strategy").
*
* @return The strategy
*/
String getCustomStrategy();
/**
* Method to set the sequence (when using value-strategy of "sequence")
*
* @param seq Sequence key
*/
MemberMetadata setSequence(String seq);
/**
* Accessor for the sequence (when using value-strategy of "sequence")
*
* @return Sequence key
*/
String getSequence();
/**
* Method to set the field on the other side of a bidirectional relation
* (this side is owner)
*
* @param map mapped-by field/property
*/
MemberMetadata setMappedBy(String map);
/**
* Accessor for the mapped-by field/property
*
* @return mapped-by field/property
*/
String getMappedBy();
/**
* Method to define the array details (if the field/property is an array)
*
* @return The ArrayMetadata
*/
ArrayMetadata newArrayMetadata();
/**
* Accessor for the array details.
*
* @return array details
*/
ArrayMetadata getArrayMetadata();
/**
* Method to define the array details (if the field/property is an array)
*
* @return The ArrayMetadata
*/
CollectionMetadata newCollectionMetadata();
/**
* Accessor for the array details.
*
* @return array details
*/
CollectionMetadata getCollectionMetadata();
/**
* Method to define the map details (if the field/property is an map)
*
* @return The MapMetadata
*/
MapMetadata newMapMetadata();
/**
* Accessor for the map details.
*
* @return map details
*/
MapMetadata getMapMetadata();
/**
* Method to define the join details
*
* @return The JoinMetadata
*/
JoinMetadata newJoinMetadata();
/**
* Accessor for the join details.
*
* @return join details
*/
JoinMetadata getJoinMetadata();
/**
* Method to define the embedded details
*
* @return The EmbeddedMetadata
*/
EmbeddedMetadata newEmbeddedMetadata();
/**
* Accessor for the embedded metadata.
*
* @return embedded metadata
*/
EmbeddedMetadata getEmbeddedMetadata();
/**
* Method to define the new element details
*
* @return The ElementMetadata
*/
ElementMetadata newElementMetadata();
/**
* Accessor for the element details
*
* @return element details
*/
ElementMetadata getElementMetadata();
/**
* Method to define the key details
*
* @return The KeyMetadata
*/
KeyMetadata newKeyMetadata();
/**
* Accessor for the key details
*
* @return key details
*/
KeyMetadata getKeyMetadata();
/**
* Method to define the value details
*
* @return The ValueMetadata
*/
ValueMetadata newValueMetadata();
/**
* Accessor for the value details
*
* @return value details
*/
ValueMetadata getValueMetadata();
/**
* Method to set index metadata for the field/property
*
* @return The metadata for any index
*/
IndexMetadata newIndexMetadata();
/**
* Accessor for any index metadata for the field/property
*
* @return Index metadata
*/
IndexMetadata getIndexMetadata();
/**
* Method to set new unique constraint metadata for the field/property
*
* @return The UniqueMetadata
*/
UniqueMetadata newUniqueMetadata();
/**
* Accessor for any unique constraint metadata on this field/property.
*
* @return The UniqueMetadata
*/
UniqueMetadata getUniqueMetadata();
/**
* Method to set new foreign key metadata for the field/property
*
* @return The ForeignKeyMetadata
*/
ForeignKeyMetadata newForeignKeyMetadata();
/**
* Accessor for any foreign key metadata on this field/property.
*
* @return The ForeignKeyMetadata
*/
ForeignKeyMetadata getForeignKeyMetadata();
/**
* Method to define the order details.
*
* @return The OrdeMetadata
*/
OrderMetadata newOrderMetadata();
/**
* Accessor for the order metadata.
*
* @return order metadata
*/
OrderMetadata getOrderMetadata();
/**
* Accessor for all column(s) defined on the join.
*
* @return The column(s)
*/
ColumnMetadata[] getColumns();
/**
* Add a new column for this join.
*
* @return The ColumnMetadata
*/
ColumnMetadata newColumnMetadata();
/**
* Accessor for the number of columns defined for this join.
*
* @return The number of columns
*/
int getNumberOfColumns();
}
api/src/java/javax/jdo/metadata/Metadata.java 100664 3275 12500110371 21405 0 ustar mbouschen staff 0 0 /*
* 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 javax.jdo.metadata;
/**
* This interface provides base level definitions for all metadata components.
*
* @version 3.0
*/
public interface Metadata {
/**
* Add a vendor extension to this metadata component.
*
* @param vendor Identifier for the vendor
* @param key The extension key
* @param value Value for the extension
* @return The ExtensionMetadata
*/
ExtensionMetadata newExtensionMetadata(String vendor, String key, String value);
/**
* Number of extensions on this component.
*
* @return Number of extensions
*/
int getNumberOfExtensions();
/**
* Accessor for the defined extensions for this component
*
* @return The extensions
*/
ExtensionMetadata[] getExtensions();
/**
* Accessor for the parent metadata component.
*
* @return The parent
*/
Metadata getParent();
}
api/src/java/javax/jdo/metadata/OrderMetadata.java 100664 4615 12500110371 22400 0 ustar mbouschen staff 0 0 /*
* 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 javax.jdo.metadata;
/**
* Represents ordering of a collection field/property.
* @since 3.0
*/
public interface OrderMetadata extends Metadata {
/**
* Method to set the version column name.
*
* @param column Name of the version clumn
*/
OrderMetadata setColumn(String column);
/**
* Accessor for the version column name
*
* @return The version column name
*/
String getColumn();
/**
* Method to set mapped-by information whether the order is present in the element class.
*
* @param mappedBy Field/property name in which to store the ordering in the element
*/
OrderMetadata setMappedBy(String mappedBy);
/**
* Accessor for the mapped-by field/property name in the element class.
*
* @return Name of field/property in element class
*/
String getMappedBy();
/**
* Accessor for all column(s) defined on the ordering.
*
* @return The column(s)
*/
ColumnMetadata[] getColumns();
/**
* Add a column for this ordering.
*
* @return The ColumnMetadata
*/
ColumnMetadata newColumnMetadata();
/**
* Accessor for the number of columns defined for this ordering.
*
* @return The number of columns
*/
int getNumberOfColumns();
/**
* Method to set index metadata for the ordering
*
* @return The metadata for any index
*/
IndexMetadata newIndexMetadata();
/**
* Accessor for any index metadata for the ordering
*
* @return Index metadata
*/
IndexMetadata getIndexMetadata();
}
api/src/java/javax/jdo/metadata/package.html 100664 2105 12500110371 21272 0 ustar mbouschen staff 0 0
Metadata package
JDO package
There are two major objectives of the JDO architecture:
first, to provide application programmers a transparent,
Java-centric view of persistent information, including enterprise data
and locally stored data; and second, to enable pluggable implementations
of data stores into
application servers. Data stored in data stores is presented as
instances of persistence-capable classes.
JDO defines interfaces and classes to be used by application programmers
when using classes whose instances are to be stored in persistent storage
(persistence-capable classes), and specifies the contracts between
suppliers of persistence-capable classes and the
runtime environment (which is part of the JDO implementation).
The JDO architecture defines a standard set of contracts between an
application programmer and an JDO vendor. These contracts focus on the
view of the Java instances of persistence capable classes.
The JDO PersistenceManagerFactory is the boostrap class for a JDO
application. The application gets an instance of the
PersistenceManagerFactory by construction or via JDNI lookup.
The application acquires an instance of the JDO PersistenceManager by
calling the getPersistenceManager method on an instance of JDO
PersistenceManagerFactory.
The JDO PersistenceManager is the primary interface for JDO-aware
application components:
it gives access to the current Transaction interface;
it is the factory for the Query interface;
it contains methods for managing the life cycle of persistent instances.
A JDO PersistenceManager instance supports any number of JDO instances
at a time. It is responsible for managing the identity of its
associated JDO instances. A JDO instance is associated with either
zero or one JDO PersistenceManager. It will be zero if and only if the
JDO instance is transient nontransactional. As soon as the instance is made persistent
or transactional, it will be associated with exactly one JDO PersistenceManager.
A JDO PersistenceManager instance supports one transaction at a time,
and uses one connection to the underlying data source at a time. The JDO
PersistenceManager instance might use multiple transactions serially,
and might use multiple connections serially.
Normally, cache management is automatic and transparent. When instances
are queried, navigated to, or modified, instantiation of instances and
their fields and garbage collection of unreferenced instances occurs
without any explicit control. When the transaction in which persistent
instances are created, deleted, or modified commits, eviction is
automatically done by the transaction completion mechanisms.
Operations on persistent JDO instances at the user's choice might be
performed in the context of a transaction. That is, the view of data
in the data store is transactionally consistent, according to the
standard definition of ACID transactions.
The Transaction interface is used to mark the beginning and end of a
application-defined unit of work. The PersistenceManager allows the
application to get the instance that manages these transactional
boundaries via the currentTransaction method.
The persistent manager instance is a factory for query instances,
and queries are executed in the context of the persistent manager instance.
The actual query execution might be performed by the JDO PersistenceManager
or might be delegated by the JDO PersistenceManager to its data store.
The actual query executed thus might be implemented in a very different
language from Java, and might be optimized to take advantage of particular
query language implementations.
Extents are collections of data store objects managed by the data store,
not by explicit user operations on collections. Extent capability is a
boolean property of classes that are persistence capable. If an instance
of a class that has a managed extent is made persistent via reachability,
the instance is put into the extent implicitly.
api/src/java/javax/jdo/PersistenceManager.java 100664 172063 12500110371 21726 0 ustar mbouschen staff 0 0 /*
* 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.
*/
/*
* PersistenceManager.java
*
*/
package javax.jdo;
import java.util.Collection;
import java.util.Date;
import java.util.EnumSet;
import java.util.Map;
import java.util.Set;
import javax.jdo.datastore.JDOConnection;
import javax.jdo.datastore.Sequence;
import javax.jdo.listener.InstanceLifecycleListener;
/** PersistenceManager is the primary interface for JDO-aware
* application components. It is the factory for Query and
* Transaction instances, and contains methods to manage the
* life cycle of PersistenceCapable instances.
*
*
A PersistenceManager is obtained from the
* {@link PersistenceManagerFactory}
* (recommended) or by construction.
* @version 2.1
*/
public interface PersistenceManager {
/**
* A PersistenceManager instance can be used until it is
* closed.
* @return true if this PersistenceManager has
* been closed.
* @see #close()
*/
boolean isClosed ();
/** Close this PersistenceManager so that no further requests
* may be made on it. A PersistenceManager instance can be
* used only until it is closed.
*
*
Closing a PersistenceManager might release it to the pool
* of available PersistenceManagers, or might be garbage
* collected, at the option of the JDO implementation. Before being used
* again to satisfy a getPersistenceManager() request, the
* default values for options will be restored to their values as specified
* in the PersistenceManagerFactory.
*
*
This method closes the PersistenceManager.
*/
void close ();
/** Return the Transaction instance associated with a
* PersistenceManager. There is one Transaction
* instance associated with each PersistenceManager instance.
* The Transaction instance supports options as well as
* transaction completion requests.
* @return the Transaction associated with this
* PersistenceManager.
*/
Transaction currentTransaction();
/** Mark an instance as no longer needed in the cache. Eviction is normally
* done automatically by the PersistenceManager at transaction
* completion. This method allows the application to explicitly provide a
* hint to the PersistenceManager that the instance is no
* longer needed in the cache.
* @param pc the instance to evict from the cache.
*/
void evict (Object pc);
/** Mark an array of instances as no longer needed in the cache.
* @see #evict(Object pc)
* @param pcs the array of instances to evict from the cache.
*/
void evictAll (Object... pcs);
/** Mark a Collection of instances as no longer needed in the
* cache.
* @see #evict(Object pc)
* @param pcs the Collection of instances to evict from the
* cache.
*/
void evictAll (Collection pcs);
/** Mark the parameter instances as no longer needed in the cache.
* @param pcClass the class of instances to evict
* @param subclasses if true, mark instances of subclasses also
* @since 2.1
*/
void evictAll (boolean subclasses, Class pcClass);
/** Mark all persistent-nontransactional instances as no longer needed
* in the cache. It transitions
* all persistent-nontransactional instances to hollow. Transactional
* instances are subject to eviction based on the RetainValues setting.
* @see #evict(Object pc)
*/
void evictAll ();
/** Refresh the state of the instance from the data store.
*
*
In an optimistic transaction, the state of instances in the cache
* might not match the state in the data store. This method is used to
* reload the state of the instance from the data store so that a subsequent
* commit is more likely to succeed.
*
Outside a transaction, this method will refresh nontransactional
* state.
* @param pc the instance to refresh.
*/
void refresh (Object pc);
/** Refresh the state of an array of instances from the data store.
*
* @see #refresh(Object pc)
* @param pcs the array of instances to refresh.
*/
void refreshAll (Object... pcs);
/** Refresh the state of a Collection of instances from the
* data store.
*
* @see #refresh(Object pc)
* @param pcs the Collection of instances to refresh.
*/
void refreshAll (Collection pcs);
/** Refresh the state of all applicable instances from the data store.
*
If called with an active transaction, all transactional instances
* will be refreshed. If called outside an active transaction, all
* nontransactional instances will be refreshed.
* @see #refresh(Object pc)
*/
void refreshAll ();
/**
* Refreshes all instances in the exception that failed verification.
*
* @since 2.0
*/
void refreshAll (JDOException jdoe);
/** Create a new Query with no elements.
* @return the new Query.
*/
Query newQuery ();
/** Create a new Query using elements from another
* Query. The other Query must have been created
* by the same JDO implementation. It might be active in a different
* PersistenceManager or might have been serialized and
* restored.
*
All of the settings of the other Query are copied to this
* Query, except for the candidate Collection or
* Extent.
* @return the new Query
* @param compiled another Query from the same JDO
* implementation
*/
Query newQuery (Object compiled);
/** Create a Construct a new query instance using the specified String
* as the single-string representation of the query.
* @param query the single-string query
* @return the new Query
* @since 2.0
*/
Query newQuery (String query);
/** Create a new Query using the specified language.
* @param language the language of the query parameter
* @param query the query, which is of a form determined by the language
* @return the new Query
*/
Query newQuery (String language, Object query);
/** Create a new Query specifying the Class of the
* candidate instances.
* @param cls the Class of the candidate instances
* @return the new Query
*/
Query newQuery (Class cls);
/** Create a new Query with the Class of the
* candidate instances and candidate Extent.
* @param cln the Extent of candidate instances
* @return the new Query
*/
Query newQuery (Extent cln);
/** Create a new Query with the candidate Class
* and Collection.
* @param cls the Class of results
* @param cln the Collection of candidate instances
* @return the new Query
*/
Query newQuery (Class cls, Collection cln);
/** Create a new Query with the Class of the
* candidate instances and filter.
* @param cls the Class of results
* @param filter the filter for candidate instances
* @return the new Query
*/
Query newQuery (Class cls, String filter);
/** Create a new Query with the Class of the
* candidate instances,
* candidate Collection, and filter.
* @param cls the Class of candidate instances
* @param cln the Collection of candidate instances
* @param filter the filter for candidate instances
* @return the new Query
*/
Query newQuery (Class cls, Collection cln, String filter);
/** Create a new Query with the
* candidate Extent and filter; the class
* is taken from the Extent.
* @param cln the Extent of candidate instances
* @param filter the filter for candidate instances
* @return the new Query
*/
Query newQuery (Extent cln, String filter);
/**
* Create a new Query with the given candidate class
* from a named query. The query name given must be the name of a
* query defined in metadata.
* @param cls the Class of candidate instances
* @param queryName the name of the query to look up in metadata
* @return the new Query
*/
Query newNamedQuery (Class cls, String queryName);
/** The PersistenceManager manages a collection of instances in
* the data store based on the class of the instances. This method returns
* an Extent of instances in the data store that might be
* iterated or given to a Query. The Extent
* itself might not reference any instances, but only hold the class name
* and an indicator as to whether subclasses are included in the
* Extent.
*
Note that the Extent might be very large.
* @param persistenceCapableClass Class of instances
* @param subclasses whether to include instances of subclasses
* @return an Extent of the specified Class
* @see Query
*/
Extent getExtent (Class persistenceCapableClass, boolean subclasses);
/**
* Equivalent to getExtent (persistenceCapableClass,
* true).
* @see #getExtent(Class,boolean)
* @since 2.0
*/
Extent getExtent (Class persistenceCapableClass);
/** This method locates a persistent instance in the cache of instances
* managed by this PersistenceManager.
* The getObjectById method attempts
* to find an instance in the cache with the specified JDO identity.
* The oid parameter object might have been returned by an
* earlier call to getObjectId or
* getTransactionalObjectId, or might have been constructed by
* the application.
* If the PersistenceManager is unable to resolve the
* oid parameter to an ObjectId instance, then it throws a
* JDOUserException.
*
If the validate flag is false, and there is
* already an instance in the cache with the same JDO identity as the
* oid parameter, then this method returns it. There is no
* change made to the state of the returned instance.
*
If there is not an instance already in the cache with the same JDO
* identity as the oid parameter, then this method creates an
* instance with the specified JDO identity and returns it. If there is no
* transaction in progress, the returned instance will be hollow or
* persistent-nontransactional, at the choice of the implementation.
*
If there is a transaction in progress, the returned instance will
* be hollow, persistent-nontransactional, or persistent-clean, at the
* choice of the implementation.
*
It is an implementation decision whether to access the data store,
* if required to determine the exact class. This will be the case of
* inheritance, where multiple PersistenceCapable classes share
* the same ObjectId class.
*
If the validate flag is false, and the instance does not
* exist in the data store, then this method might not fail. It is an
* implementation choice whether to fail immediately with a
* JDOObjectNotFoundException. But a subsequent access
* of the fields of the
* instance will throw a JDOObjectNotFoundException
* if the instance does not
* exist at that time. Further, if a relationship is established to this
* instance, then the transaction in which the association was made will
* fail.
*
If the validate flag is true, and there is
* already a transactional instance in the cache with the same JDO identity
* as the oid parameter, then this method returns it. There is
* no change made to the state of the returned instance.
*
If there is an instance already in the cache with the same JDO
* identity as the oid parameter, but the instance is not
* transactional, then it must be verified in the data store. If the
* instance does not exist in the datastore, then a
* JDOObjectNotFoundException is thrown.
*
If there is not an instance already in the cache with the same JDO
* identity as the oid parameter, then this method creates an
* instance with the specified JDO identity, verifies that it exists in the
* data store, and returns it. If there is no transaction in progress, the
* returned instance will be hollow or persistent-nontransactional,
* at the choice of the implementation.
*
If there is a data store transaction in progress, the returned
* instance will be persistent-clean.
* If there is an optimistic transaction in progress, the returned
* instance will be persistent-nontransactional.
* @see #getObjectId(Object pc)
* @see #getTransactionalObjectId(Object pc)
* @return the PersistenceCapable instance with the specified
* ObjectId
* @param oid an ObjectId
* @param validate if the existence of the instance is to be validated
*/
Object getObjectById (Object oid, boolean validate);
/**
* Looks up the instance of the given type with the given key.
* @param cls The type of object to load
* @param key either the string representation of the object id, or
* an object representation of a single field identity key
* @return the corresponding persistent instance
* @since 2.0
*/
T getObjectById (Class cls, Object key);
/**
* Looks up the instance corresponding to the specified oid. This is
* equivalent to getObjectById(oid, true);
* @param oid The object id of the object to load
* @return the corresponding persistent instance
*/
Object getObjectById (Object oid);
/** The ObjectId returned by this method represents the JDO identity of
* the instance. The ObjectId is a copy (clone) of the internal state
* of the instance, and changing it does not affect the JDO identity of
* the instance.
* The getObjectId method returns an ObjectId instance that
* represents the object identity of the specified JDO instance. The
* identity is guaranteed to be unique only in the context of the JDO
* PersistenceManager that created the identity, and only for
* two types of JDO Identity: those that are managed by the application, and
* those that are managed by the data store.
*
If the object identity is being changed in the transaction, by the
* application modifying one or more of the application key fields,
* then this method returns the identity as of the beginning of the
* transaction. The value returned by getObjectId will be
* different following afterCompletion processing for
* successful transactions.
Within a transaction, the ObjectId returned
* will compare equal to the ObjectId returned by only one among all JDO
* instances associated with the PersistenceManager regardless
* of the type of ObjectId.
*
The ObjectId does not necessarily contain any internal state of the
* instance, nor is it necessarily an instance of the class used to
* manage identity internally. Therefore, if the application makes a
* change to the ObjectId instance returned by this method, there is
* no effect on the instance from which the ObjectId was obtained.
*
The getObjectById method can be used between instances of
* PersistenceManager of different JDO vendors only for
* instances of persistence capable classes using application-managed
* (primary key) JDO identity. If it is used for instances of classes using
* datastore identity, the method might succeed, but there are no guarantees
* that the parameter and return instances are related in any way.
* @see #getTransactionalObjectId(Object pc)
* @see #getObjectById(Object oid, boolean validate)
* @param pc the PersistenceCapable instance
* @return the ObjectId of the instance
*/
Object getObjectId (Object pc);
/** The ObjectId returned by this method represents the JDO identity of
* the instance. The ObjectId is a copy (clone) of the internal state
* of the instance, and changing it does not affect the JDO identity of
* the instance.
*
If the object identity is being changed in the transaction, by the
* application modifying one or more of the application key fields,
* then this method returns the current identity in the transaction.
*
If there is no transaction in progress, or if none of the key fields
* is being modified, then this method will return the same value as
* getObjectId.
* @see #getObjectId(Object pc)
* @see #getObjectById(Object oid, boolean validate)
* @param pc a PersistenceCapable instance
* @return the ObjectId of the instance
*/
Object getTransactionalObjectId (Object pc);
/**
* This method returns an object id instance corresponding to the pcClass
* and key arguments.
* @param pcClass the Class of the persistence-capable instance
* @param key for single-field identity, the parameter for the
* constructor; for non-single-field application identity, the result
* of toString() on the object id instance.
* @return an instance of the object identity class
*/
Object newObjectIdInstance (Class pcClass, Object key);
/**
* Return the objects with the given oids.
* @param oids the oids of the objects to return
* @param validate if true, the existance of the objects in
* the datastore will be validated.
* @return the objects that were looked up, in the
* same order as the oids parameter.
* @see #getObjectById(Object,boolean)
* @since 2.0
*/
Collection getObjectsById (Collection oids, boolean validate);
/**
* Return the objects with the given oids. This method is equivalent
* to calling {@link #getObjectsById(Collection, boolean)}
* with the validate flag true.
* @param oids the oids of the objects to return
* @return the objects that were looked up, in the
* same order as the oids parameter.
* @see #getObjectsById(Collection,boolean)
* @since 2.0
*/
Collection getObjectsById (Collection oids);
/**
* Return the objects with the given oids.
* @param oids the oids of the objects to return
* @param validate if true, the existance of the objects in
* the datastore will be validated.
* @return the objects that were looked up, in the
* same order as the oids parameter.
* @see #getObjectById(Object,boolean)
* @see #getObjectsById(boolean,Object...)
* @deprecated
* @since 2.0
*/
Object[] getObjectsById (Object[] oids, boolean validate);
/**
* Return the objects with the given oids.
* @param oids the oids of the objects to return
* @param validate if true, the existance of the objects in
* the datastore will be validated.
* @return the objects that were looked up, in the
* same order as the oids parameter.
* @see #getObjectById(Object,boolean)
* @since 2.1
*/
Object[] getObjectsById (boolean validate, Object... oids);
/**
* Return the objects with the given oids. This method is equivalent
* to calling {@link #getObjectsById(boolean,Object...)}
* with the validate flag true.
* @param oids the oids of the objects to return
* @return the objects that were looked up, in the
* same order as the oids parameter.
* @see #getObjectsById(boolean,Object...)
* @since 2.0
*/
Object[] getObjectsById (Object... oids);
/** Make the parameter instance persistent in this
* PersistenceManager.
* This method makes transient instances persistent and applies detached
* instance changes to the cache. It must be called in the context of
* an active transaction, or a JDOUserException is thrown. For a transient
* instance, it assigns an object identity to the instance and transitions
* it to persistent-new. Any transient instances reachable from this
* instance via persistent fields of this instance become provisionally
* persistent, transitively. That is, they behave as persistent-new
* instances (return true to isPersistent, isNew, and isDirty).
* But at commit time, the reachability algorithm is run again,
* and instances made provisionally persistent that are not then
* reachable from persistent instances will revert to transient.
*
During makePersistent of transient instances, the create life cycle
* listener is called.
*
For detached instances, it locates or instantiates a persistent
* instance with the same JDO identity as the detached instance,
* and merges the persistent state of the detached instance into the
* persistent instance. Only the state of persistent fields is merged.
* If non-persistent state needs to be copied, the application should
* use the jdoPostAttach callback or the postAttach lifecycle event
* listener. Any references to the detached instances from instances
* in the closure of the parameter instances are modified to refer to
* the corresponding persistent instance instead of to the
* detached instance.
*
During attachment of detached instances, the attach callbacks
* and attach life cycle listeners are called.
*
During application of changes of the detached state, if the JDO
* implementation can determine that there were no changes made during
* detachment, then the implementation is not required to mark the
* corresponding instance dirty. If it cannot determine if changes
* were made, then it must mark the instance dirty.
* No consistency checking is done during makePersistent of detached
* instances. If consistency checking is required by the application,
* then flush or checkConsistency should be called after attaching the
* instances.
*
These methods have no effect on parameter persistent instances
* already managed by this PersistenceManager. They will throw a
* JDOUserException if the parameter instance is managed by a
* different PersistenceManager.
* If an instance is of a class whose identity type (application,
* datastore, or none) is not supported by the JDO implementation,
* then a JDOUserException will be thrown for that instance.
* The return value for parameter instances in the transient or persistent
* states is the same as the parameter value. The return value for
* parameter instances in the detached state is the persistent instance
* corresponding to the detached instance.
* The return values for makePersistentAll methods correspond by position
* to the parameter instances.
* @param pc an instance of a Class that is persistent
* capable.
* @return the parameter instance for parameters in the transient or
* persistent state, or the corresponding persistent instance
* for detached parameter instances
*/
T makePersistent (T pc);
/** Make an array of instances persistent.
* @param pcs an array of instances
* @return the parameter instances for parameters in the transient or
* persistent state, or the corresponding persistent instance
* for detached parameter instances, in the same order as in the
* parameter array
* @see #makePersistent(Object pc)
*/
T[] makePersistentAll (T... pcs);
/** Make a Collection of instances persistent.
* @param pcs a Collection of instances
* @return the parameter instance for parameters in the transient or
* persistent state, or the corresponding persistent instance
* for detached parameter instances, with an iteration in the same order
* as in the parameter Collection
* @see #makePersistent(Object pc)
*/
Collection makePersistentAll (Collection pcs);
/** Delete the persistent instance from the data store.
* This method must be called in an active transaction.
* The data store object will be removed at commit.
* Unlike makePersistent, which makes the closure of the
* instance persistent, the closure of the instance is not deleted from the
* data store. This method has no effect if the instance is already deleted
* in the current transaction.
* This method throws JDOUserException if the instance is
* transient or is managed by another PersistenceManager.
*
* @param pc a persistent instance
*/
void deletePersistent (Object pc);
/** Delete an array of instances from the data store.
* @param pcs a Collection of persistent instances
* @see #deletePersistent(Object pc)
*/
void deletePersistentAll (Object... pcs);
/** Delete a Collection of instances from the data store.
* @param pcs a Collection of persistent instances
* @see #deletePersistent(Object pc)
*/
void deletePersistentAll (Collection pcs);
/** Make an instance transient, removing it from management by this
* PersistenceManager.
*
* The instance loses its JDO identity and it is no longer associated
* with any PersistenceManager. The state of fields is
* preserved unchanged.
* @param pc the instance to make transient.
*/
void makeTransient (Object pc);
/** Make an array of instances transient, removing them from management by
* this PersistenceManager.
*
*
The instances lose their JDO identity and they are no longer
* associated with any PersistenceManager. The state of fields
* is preserved unchanged.
* @param pcs the instances to make transient.
*/
void makeTransientAll (Object... pcs);
/** Make a Collection of instances transient, removing them
* from management by this PersistenceManager.
*
*
The instances lose their JDO identity and they are no longer
* associated with any PersistenceManager. The state of fields
* is preserved unchanged.
* @param pcs the instances to make transient.
*/
void makeTransientAll (Collection pcs);
/** Make an instance transient, removing it from management by this
* PersistenceManager. If the useFetchPlan parameter is
* false, this method behaves exactly as makeTransient(Object pc).
*
The affected instance(s) lose their JDO identity and are no longer
* associated with any PersistenceManager. The state
* of fields is unchanged.
*
If the useFetchPlan parameter is true, then the current FetchPlan
* is applied to the pc parameter, as if detachCopy(Object) had been
* called. After the graph of instances is loaded, the instances
* reachable via loaded fields is made transient. The state of fields
* in the affected instances is as specified by the FetchPlan.
*
Unlike detachCopy, the instances are not detached; there is no
* detachment information in the instances.
*
The instances to be made transient do not need to
* implement the javax.jdo.spi.Detachable interface.
* @param pc the root instance to make transient.
* @param useFetchPlan whether to use the current fetch plan to determine
* which fields to load and which instances to make transient
* @since 2.0
*/
void makeTransient (Object pc, boolean useFetchPlan);
/** Make instances transient, removing them from management
* by this PersistenceManager. If the useFetchPlan parameter
* is false, this method behaves exactly as makeTransientAll(Object[] pcs).
*
The affected instance(s) lose their JDO identity and are no longer
* associated with any PersistenceManager. The state
* of fields is unchanged.
*
If the useFetchPlan parameter is true, then the current FetchPlan
* is applied to the pcs parameters and the entire graph of instances
* reachable via loaded fields is made transient. The state of fields
* in the affected instances is as specified by the FetchPlan.
*
Unlike detachCopy, the instances are not detached; there is no
* detachment information in the instances.
*
The instances to be made transient do not need to
* implement the javax.jdo.spi.Detachable interface.
* @param pcs the root instances to make transient.
* @param useFetchPlan whether to use the current fetch plan to determine
* which fields to load and which instances to make transient
* @see #makeTransientAll(boolean,Object...)
* @deprecated
* @since 2.0
*/
void makeTransientAll (Object[] pcs, boolean useFetchPlan);
/** Make instances transient, removing them from management
* by this PersistenceManager. If the useFetchPlan parameter
* is false, this method behaves exactly as makeTransientAll(Object[] pcs).
*
The affected instance(s) lose their JDO identity and are no longer
* associated with any PersistenceManager. The state
* of fields is unchanged.
*
If the useFetchPlan parameter is true, then the current FetchPlan
* is applied to the pcs parameters and the entire graph of instances
* reachable via loaded fields is made transient. The state of fields
* in the affected instances is as specified by the FetchPlan.
*
Unlike detachCopy, the instances are not detached; there is no
* detachment information in the instances.
*
The instances to be made transient do not need to
* implement the javax.jdo.spi.Detachable interface.
* @param pcs the root instances to make transient.
* @param useFetchPlan whether to use the current fetch plan to determine
* which fields to load and which instances to make transient
* @since 2.1
*/
void makeTransientAll (boolean useFetchPlan, Object... pcs);
/** Make instances transient, removing them from management
* by this PersistenceManager. If the useFetchPlan parameter
* is false, this method behaves exactly as
* makeTransientAll(Collection pcs).
*
The affected instance(s) lose their JDO identity and are no longer
* associated with any PersistenceManager. The state
* of fields is unchanged.
*
If the useFetchPlan parameter is true, then the current FetchPlan
* is applied to the pcs parameters and the entire graph of instances
* reachable via loaded fields is made transient. The state of fields
* in the affected instances is as specified by the FetchPlan.
*
Unlike detachCopy, the instances are not detached; there is no
* detachment information in the instances.
*
The instances to be made transient do not need to
* implement the javax.jdo.spi.Detachable interface.
* @param pcs the root instances to make transient.
* @param useFetchPlan whether to use the current fetch plan to determine
* which fields to load and which instances to make transient
* @since 2.0
*/
void makeTransientAll (Collection pcs, boolean useFetchPlan);
/** Make an instance subject to transactional boundaries.
*
*
Transient instances normally do not observe transaction boundaries.
* This method makes transient instances sensitive to transaction
* completion. If an instance is modified in a transaction, and the
* transaction rolls back, the state of the instance is restored to the
* state before the first change in the transaction.
*
*
For persistent instances read in optimistic transactions, this method
* allows the application to make the state of the instance part of the
* transactional state. At transaction commit, the state of the instance in
* the cache is compared to the state of the instance in the data store. If
* they are not the same, then an exception is thrown.
* @param pc the instance to make transactional.
*/
void makeTransactional (Object pc);
/** Make an array of instances subject to transactional boundaries.
* @param pcs the array of instances to make transactional.
* @see #makeTransactional(Object pc)
*/
void makeTransactionalAll (Object... pcs);
/** Make a Collection of instances subject to transactional
* boundaries.
* @param pcs the Collection of instances to make
* transactional.
* @see #makeTransactional(Object pc)
*/
void makeTransactionalAll (Collection pcs);
/** Make an instance non-transactional after commit.
*
*
Normally, at transaction completion, instances are evicted from the
* cache. This method allows an application to identify an instance as
* not being evicted from the cache at transaction completion. Instead,
* the instance remains in the cache with nontransactional state.
*
* @param pc the instance to make nontransactional.
*/
void makeNontransactional (Object pc);
/** Make an array of instances non-transactional after commit.
*
* @param pcs the array of instances to make nontransactional.
* @see #makeNontransactional(Object pc)
*/
void makeNontransactionalAll (Object... pcs);
/** Make a Collection of instances non-transactional after
* commit.
*
* @param pcs the Collection of instances to make
* nontransactional.
* @see #makeNontransactional(Object pc)
*/
void makeNontransactionalAll (Collection pcs);
/** Retrieve field values of an instance from the store. This tells
* the PersistenceManager that the application intends to use
* the instance, and its field values must be retrieved.
*
The PersistenceManager might use policy information about
* the class to retrieve associated instances.
* @param pc the instance
*/
void retrieve (Object pc);
/** Retrieve field values of an instance from the store. This tells
* the PersistenceManager that the application intends to use
* the instance, and its field values must be retrieved.
*
If the useFetchPlan parameter is false, this method behaves exactly
* as the corresponding method without the useFetchPlan parameter.
* If the useFetchPlan parameter is true, and the fetch plan has not been
* modified from its default setting, all fields in the current fetch plan
* are fetched, and other fields might be fetched lazily by the
* implementation. If the useFetchPlan parameter is true, and the fetch
* plan has been changed from its default setting, then the fields
* specified by the fetch plan are loaded, along with related instances
* specified by the fetch plan.
* @param pc the instance
* @param useFetchPlan whether to use the current fetch plan to determine
* which fields to load and which instances to retrieve.
* @since 2.0
*/
void retrieve (Object pc, boolean useFetchPlan);
/** Retrieve field values of instances from the store. This tells
* the PersistenceManager that the application intends to use
* the instances, and all field values must be retrieved.
*
The PersistenceManager might use policy information about
* the class to retrieve associated instances.
* @param pcs the instances
*/
void retrieveAll (Collection pcs);
/** Retrieve field values of instances from the store. This tells
* the PersistenceManager that the application intends to use
* the instances, and their field values should be retrieved. The fields
* in the current fetch group must be retrieved, and the implementation
* might retrieve more fields than the current fetch group.
*
If the useFetchPlan parameter is false, this method behaves exactly
* as the corresponding method without the useFetchPlan parameter.
* If the useFetchPlan parameter is true, and the fetch plan has not been
* modified from its default setting, all fields in the current fetch plan
* are fetched, and other fields might be fetched lazily by the
* implementation. If the useFetchPlan parameter is true, and the fetch
* plan has been changed from its default setting, then the fields
* specified by the fetch plan are loaded, along with related instances
* specified by the fetch plan.
* @param pcs the instances
* @param useFetchPlan whether to use the current fetch plan to determine
* which fields to load and which instances to retrieve.
* @since 1.0.1
*/
void retrieveAll (Collection pcs, boolean useFetchPlan);
/** Retrieve field values of instances from the store. This tells
* the PersistenceManager that the application intends to use
* the instances, and all field values must be retrieved.
*
The PersistenceManager might use policy information about
* the class to retrieve associated instances.
* @param pcs the instances
*/
void retrieveAll (Object... pcs);
/** Retrieve field values of instances from the store. This tells
* the PersistenceManager that the application intends to use
* the instances, and their field values should be retrieved. The fields
* in the current fetch group must be retrieved, and the implementation
* might retrieve more fields than the current fetch group.
*
If the useFetchPlan parameter is false, this method behaves exactly
* as the corresponding method without the useFetchPlan parameter.
* If the useFetchPlan parameter is true, and the fetch plan has not been
* modified from its default setting, all fields in the current fetch plan
* are fetched, and other fields might be fetched lazily by the
* implementation. If the useFetchPlan parameter is true, and the fetch
* plan has been changed from its default setting, then the fields
* specified by the fetch plan are loaded, along with related instances
* specified by the fetch plan.
* @param pcs the instances
* @param useFetchPlan whether to use the current fetch plan to determine
* which fields to load and which instances to retrieve.
* @deprecated
* @see #retrieveAll(boolean,Object...)
* @since 1.0.1
*/
void retrieveAll (Object[] pcs, boolean useFetchPlan);
/** Retrieve field values of instances from the store. This tells
* the PersistenceManager that the application intends to use
* the instances, and their field values should be retrieved. The fields
* in the current fetch group must be retrieved, and the implementation
* might retrieve more fields than the current fetch group.
*
If the useFetchPlan parameter is false, this method behaves exactly
* as the corresponding method without the useFetchPlan parameter.
* If the useFetchPlan parameter is true, and the fetch plan has not been
* modified from its default setting, all fields in the current fetch plan
* are fetched, and other fields might be fetched lazily by the
* implementation. If the useFetchPlan parameter is true, and the fetch
* plan has been changed from its default setting, then the fields
* specified by the fetch plan are loaded, along with related instances
* specified by the fetch plan.
* @param pcs the instances
* @param useFetchPlan whether to use the current fetch plan to determine
* which fields to load and which instances to retrieve.
* @since 2.1
*/
void retrieveAll (boolean useFetchPlan, Object... pcs);
/** The application can manage the PersistenceManager instances
* more easily by having an application object associated with each
* PersistenceManager instance.
* @param o the user instance to be remembered by the
* PersistenceManager
* @see #getUserObject
*/
void setUserObject (Object o);
/** The application can manage the PersistenceManager instances
* more easily by having an application object associated with each
* PersistenceManager instance.
* @return the user object associated with this
* PersistenceManager
* @see #setUserObject
*/
Object getUserObject ();
/** This method returns the PersistenceManagerFactory used to
* create this PersistenceManager.
* @return the PersistenceManagerFactory that created
* this PersistenceManager
*/
PersistenceManagerFactory getPersistenceManagerFactory();
/** Return the Class that implements the JDO Identity for the
* specified PersistenceCapable class. The application can use
* the returned Class to construct a JDO Identity instance for
* application identity PersistenceCapable classes. This JDO
* Identity instance can then be used to get an instance of the
* PersistenceCapable class for use in the application.
*
*
In order for the application to construct an instance of the ObjectId
* class it needs to know the class being used by the JDO implementation.
* @param cls the PersistenceCapable Class
* @return the Class of the ObjectId of the parameter
* @see #getObjectById
*/
Class getObjectIdClass(Class cls);
/** Set the Multithreaded flag for this PersistenceManager.
* Applications that use multiple threads to invoke methods or access fields
* from instances managed by this PersistenceManager must set
* this flag to true.
* Instances managed by this PersistenceManager include
* persistent or transactional instances of PersistenceCapable
* classes, as well as helper instances such as Query,
* Transaction, or Extent.
* @param flag the Multithreaded setting.
*/
void setMultithreaded (boolean flag);
/** Get the current Multithreaded flag for this
* PersistenceManager.
* @see #setMultithreaded
* @return the Multithreaded setting.
*/
boolean getMultithreaded();
/** Set the ignoreCache parameter for queries.
*
*
IgnoreCache set to true specifies that for all
* Query instances created by this
* PersistenceManager, the default is the cache should be
* ignored for queries.
* @param flag the ignoreCache setting.
*/
void setIgnoreCache(boolean flag);
/** Get the ignoreCache setting for queries.
*
*
IgnoreCache set to true specifies that for all
* Query instances created by this
* PersistenceManager, the default is the cache should be
* ignored for queries.
* @return the ignoreCache setting.
*/
boolean getIgnoreCache();
/**
* Specify a timeout interval (milliseconds) for any datastore read
* operations associated with this persistence manager. To unset
* the explicit timeout, specify null. For no timeout, specify 0.
* Read operations include, for example, those associated with query,
* getObjectById, refresh, retrieve, and extent iteration operations.
* If the datastore granularity is larger than milliseconds, the
* timeout value will be rounded up to the nearest supported datastore
* value.
* If a read operation hasn't completed within this interval, the operation
* will throw a JDODatastoreException.
* If multiple datastore operations are required to complete the query,
* the timeout value applies to each of them individually.
* If the datastore and JDO implementation support timeouts, then
* javax.jdo.option.DatastoreTimeout is returned by
* PersistenceManagerFactory.supportedOptions().
* If timeouts are not supported,this method will throw
* JDOUnsupportedOptionException.
* @since 3.0
* @param interval the timeout interval (milliseconds)
*/
void setDatastoreReadTimeoutMillis(Integer interval);
/** Get the effective timeout setting for datastore read operations
* associated with this persistence manager.
* If the timeout has not been set on this persistence manager explicitly,
* the default read timeout value from the persistence manager factory
* is returned.
* @see #setDatastoreReadTimeoutMillis(Integer)
* @see PersistenceManagerFactory#setDatastoreReadTimeoutMillis(Integer)
* @return the effective timeout setting (milliseconds).
* @since 3.0
*/
Integer getDatastoreReadTimeoutMillis();
/**
* Specify a timeout interval (milliseconds) for any write operations
* associated with this persistence manager. To unset the explicit timeout,
* specify null. For no timeout, specify 0.
* Datastore write operations include, for example, operations associated
* with flush, commit, and delete by query.
* If the datastore granularity is larger than milliseconds, the
* timeout value will be rounded up to the nearest supported datastore
* value.
* If a write operation hasn't completed within this interval, methods
* will throw a JDODatastoreException.
* If multiple datastore operations are required to complete the method,
* the timeout value applies to each of them individually.
* If the datastore and JDO implementation support timeouts, then
* javax.jdo.option.DatastoreTimeout is returned by
* PersistenceManagerFactory.supportedOptions().
* If timeouts are not supported,this method will throw
* JDOUnsupportedOptionException.
* @since 3.0
* @param interval the timeout interval (milliseconds)
*/
void setDatastoreWriteTimeoutMillis(Integer interval);
/** Get the effective timeout setting for write operations.
* If the timeout has not been set on this persistence manager explicitly,
* the default datastore write timeout value from the persistence manager
* factory is returned.
* @see #setDatastoreWriteTimeoutMillis(Integer)
* @see PersistenceManagerFactory#setDatastoreWriteTimeoutMillis(Integer)
* @return the effective timeout setting (milliseconds).
* @since 3.0
*/
Integer getDatastoreWriteTimeoutMillis();
/** Gets the detachAllOnCommit setting.
* @see #setDetachAllOnCommit(boolean)
* @since 2.0
* @return the detachAllOnCommit setting.
*/
boolean getDetachAllOnCommit();
/** Sets the detachAllOnCommit setting.
*
*
DetachAllOnCommit set to false specifies that the
* state of persistent instances in the cache after commit is defined
* by the retainValues flag. With this flag set to true,
* during beforeCompletion all cached instances are prepared for
* detachment according to the fetch plan in effect at commit. Loading
* fields and unloading fields required by the fetch plan is done after
* calling the user's beforeCompletion callback. During
* afterCompletion, before calling the user's
* afterCompletion callback, all detachable persistent
* instances in the cache transition to detached; non-detachable
* persistent instances transition to transient; and detachable
* instances can be serialized as detached instances. Transient
* transactional instances are unaffected by this flag.
*
* @see #getDetachAllOnCommit()
* @since 2.0
*/
void setDetachAllOnCommit(boolean flag);
/** Gets the copyOnAttach setting.
* @see #setCopyOnAttach(boolean)
* @since 2.1
* @return the copyOnAttach setting.
*/
boolean getCopyOnAttach();
/** Sets the copyOnAttach setting.
*
*
CopyOnAttach set to true specifies that during
* makePersistent, copies are made of detached parameter instances.
* With this flag set to false, detached parameter
* instances are attached directly and change their state from
* detached-clean to persistent-clean or from detached-dirty to
* persistent-dirty.
*
* @see #getCopyOnAttach()
* @since 2.1
*/
void setCopyOnAttach(boolean flag);
/**
* Detach the specified instance from the PersistenceManager.
* The flags for detachment (DETACH_LOAD_FIELDS and DETACH_UNLOAD_FIELDS)
* and the active fetch groups determine the scope of fetching for the
* graph of instances reachable from the pc parameter. The state of fields
* in the affected instances is as specified by the FetchPlan.
* @param pc the instance to detach
* @return the detached instance
* @see #detachCopyAll(Object[])
* @since 2.0
*/
T detachCopy (T pc);
/**
* Detach the specified instances from the PersistenceManager.
* The flags for detachment (DETACH_LOAD_FIELDS and DETACH_UNLOAD_FIELDS)
* and the active fetch groups determine the scope of fetching for the
* graph of instances reachable from the pcs parameter. The state of fields
* in the affected instances is as specified by the FetchPlan.
* @param pcs the instances to detach
* @return the detached instances
* @see #detachCopyAll(Object[])
* @since 2.0
*/
Collection detachCopyAll (Collection pcs);
/**
* Detach the specified instances from the PersistenceManager.
* The flags for detachment (DETACH_LOAD_FIELDS and DETACH_UNLOAD_FIELDS)
* and the active fetch groups determine the scope of fetching for the
* graph of instances reachable from the pcs parameter. The state of fields
* in the affected instances is as specified by the FetchPlan.
* The objects returned can be manipulated and re-attached with
* {@link #makePersistentAll(Object[])}.
* The detached instances will be
* unmanaged copies of the specified parameters, and are suitable
* for serialization and manipulation outside of a JDO
* environment. When detaching instances, only fields in the
* current {@link FetchPlan} will be traversed. Thus, to detach a
* graph of objects, relations to other persistent instances must
* either be in the default-fetch-group, or in the
* current custom {@link FetchPlan}.
* @param pcs the instances to detach
* @return the detached instances
* @throws JDOUserException if any of the instances to be detached do not
* implement the javax.jdo.spi.Detachable interface.
* @see #makePersistentAll(Object[])
* @see #getFetchPlan
* @since 2.0
*/
T[] detachCopyAll (T... pcs);
/**
* Put the specified key-value pair into the map of user objects.
* @since 2.0
*/
Object putUserObject (Object key, Object val);
/**
* Get the value for the specified key from the map of user objects.
* @param key the key of the object to be returned
* @return the object
* @since 2.0
*/
Object getUserObject (Object key);
/**
* Remove the specified key and its value from the map of user objects.
* @param key the key of the object to be removed
* @since 2.0
*/
Object removeUserObject (Object key);
/**
* Flushes all dirty, new, and deleted instances to the data
* store. It has no effect if a transaction is not active.
* If a datastore transaction is active, this method
* synchronizes the cache with the datastore and reports any
* exceptions.
* If an optimistic transaction is active, this method obtains
* a datastore connection, synchronizes the cache with the
* datastore using this connection and reports any
* exceptions. The connection obtained by this method is held
* until the end of the transaction.
* If exceptions occur during flush, the implementation will
* set the current transaction's RollbackOnly flag
* (see {@link Transaction#setRollbackOnly}).
* @since 2.0
*/
void flush ();
/**
* Validates the PersistenceManager cache with the
* datastore. This method has no effect if a transaction is not
* active.
* If a datastore transaction is active, this method verifies
* the consistency of instances in the cache against the
* datastore. An implementation might flush instances as if
* {@link #flush} were called, but it is not required to do
* so.
* If an optimistic transaction is active, this method obtains
* a datastore connection and verifies the consistency of the
* instances in the cache against the datastore. If any
* inconsistencies are detected, a {@link
* JDOOptimisticVerificationException} is thrown. This exception
* contains a nested {@link JDOOptimisticVerificationException}
* for each object that failed the consistency check. No
* datastore resources acquired during the execution of this
* method are held beyond the scope of this method.
* @since 2.0
*/
void checkConsistency ();
/**
* Returns the FetchPlan used by this
* PersistenceManager.
* @return the FetchPlan
* @since 2.0
*/
FetchPlan getFetchPlan ();
/**
* Creates an instance of a persistence-capable interface,
* or of a concrete or abstract class.
* The returned instance is transient.
* @param pcClass Must be a persistence-capable interface,
* or a concrete or abstract class that is declared in the metadata.
* @return the created instance
* @since 2.0
*/
T newInstance (Class pcClass);
/**
* Returns the sequence identified by name.
* @param name the name of the Sequence
* @return the Sequence
* @since 2.0
*/
Sequence getSequence (String name);
/**
* If this method is called while a datastore transaction is
* active, the object returned will be enlisted in the current
* transaction. If called in an optimistic transaction or outside
* an active transaction, the object returned will not be
* enlisted in any transaction.
* @return the JDOConnection instance
* @since 2.0
*/
JDOConnection getDataStoreConnection ();
/**
* Adds the listener instance to the list of lifecycle event
* listeners. The classes parameter identifies all
* of the classes of interest. If the classes
* parameter is specified as null, events for all
* persistent classes and interfaces will be sent to
* listenerInstance.
* The listenerInstance will be called for each event for which it
* implements the corresponding listenerInstance interface.
* @param listener the lifecycle listener
* @param classes the classes of interest to the listener
* @since 2.0
*/
void addInstanceLifecycleListener (InstanceLifecycleListener listener,
Class... classes);
/**
* Removes the listener instance from the list of lifecycle event listeners.
* @param listener the listener instance to be removed
* @since 2.0
*/
void removeInstanceLifecycleListener (InstanceLifecycleListener listener);
/**
* Get the Date as seen by the server.
* Clients using this method can order their operations according to
* a single time source. Implementations use the setting of the
* server time zone to prepare a Date instance that represents
* UTC time on the server.
* @return a Date instance corresponding to the UTC Date
* as seen by the server
* @since 2.1
*/
Date getServerDate();
/**
* Get the objects managed by this persistence manager.
* @return the objects
* @since 2.1
*/
Set getManagedObjects();
/**
* Get the objects managed by this persistence manager having the
* specified object states.
* @param states The states of objects that we are interested in
* @return the objects
* @since 2.1
*/
Set getManagedObjects(EnumSet states);
/**
* Get the objects managed by this persistence manager being instances of
* the specified classes.
* @param classes The classes of objects that we are interested in
* @return the objects
* @since 2.1
*/
Set getManagedObjects(Class... classes);
/**
* Get the objects managed by this persistence manager having the
* specified object states and being instances of the specified classes.
* @param states The states of objects that we are interested in
* @param classes The classes of objects that we are interested in
* @return the objects
* @since 2.1
*/
Set getManagedObjects(EnumSet states, Class... classes);
/**
* Get a modifiable FetchGroup for the Class and name.
* If a modifiable FetchGroup already exists in the
* PersistenceManager scope, return it.
* If not, create and populate a new FetchGroup from the
* existing definition in the {@link PersistenceManager} or
* {@link PersistenceManagerFactory}. If the definition for the
* FetchGroup is not in scope in either the
* PersistenceManager or
* PersistenceManagerFactory, create it with no members.
* The FetchGroup immediately
* becomes active and in scope of the PersistenceManager, and hides
* the corresponding fetch group in the PersistenceManagerFactory.
* @param cls the class or interface for the FetchGroup
* @param name the name of the fetch group
* @return the FetchGroup
* @throws JDOUserException if the class is not a persistence-capable
* class or interface
* @since 2.2
*/
FetchGroup getFetchGroup(Class cls, String name);
/**
* Set a persistence manager property. This can be a standard property
* or a vendor-extension property. If a vendor-extension property is
* not recognized, it is silently ignored.
* @param propertyName name of property
* @param value The value
* @throws JDOUserException if the value is not supported for the property
* @since 3.1
*/
public void setProperty(String propertyName, Object value);
/**
* Get the properties and associated values currently in effect for the
* persistence manager. Changing entries in the map will not have affect
* the configuration of the persistence manager.
* @return map of properties in effect
* @since 3.1
*/
public Map getProperties();
/**
* Get the names of the properties that are supported for use with the
* persistence manager. These can be standard JDO properties, or can be
* vendor-extension properties.
* @return property names Names of the properties accepted
* @since 3.1
*/
public Set getSupportedProperties();
}
api/src/java/javax/jdo/PersistenceManagerFactory.java 100664 76027 12500110371 23241 0 ustar mbouschen staff 0 0 /*
* 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.
*/
/*
* PersistenceManagerFactory.java
*
*/
package javax.jdo;
import javax.jdo.datastore.DataStoreCache;
import javax.jdo.listener.InstanceLifecycleListener;
import javax.jdo.metadata.TypeMetadata;
import javax.jdo.metadata.JDOMetadata;
import javax.jdo.spi.JDOPermission; // for getFetchGroups javadoc
import java.io.Serializable;
import java.util.Collection;
import java.util.Properties;
import java.util.Set;
/** The PersistenceManagerFactory is the interface to use to obtain
* PersistenceManager instances.
* All PersistenceManager instances obtained from the same
* PersistenceManagerFactory will have the same default properties.
*
* PersistenceManagerFactory instances may be configured and
* serialized for later use. They may be stored via JNDI and looked up
* and used later. Any properties configured will be saved and restored.
*
*
Once the first PersistenceManager is obtained from the
* PersistenceManagerFactory, the factory can no longer be
* configured.
*
If the ConnectionFactory property is set
* (non-null) then all other Connection properties including
* ConnectionFactoryName are ignored;
* otherwise, if ConnectionFactoryName is set
* (non-null) then all other Connection properties are ignored.
* Similarly, if the ConnectionFactory2 property is set
* (non-null) then ConnectionFactory2Name is ignored.
*
Operational state (PersistenceManager pooling, connection
* pooling, operational parameters) must not be serialized.
*
* @version 2.2
*/
public interface PersistenceManagerFactory extends Serializable {
/** Close this PersistenceManagerFactory. Check for
* JDOPermission("closePersistenceManagerFactory") and if not authorized,
* throw SecurityException.
*
If the authorization check succeeds, check to see that all
* PersistenceManager instances obtained from this PersistenceManagerFactory
* have no active transactions. If any PersistenceManager instances have
* an active transaction, throw a JDOUserException, with one nested
* JDOUserException for each PersistenceManager with an active Transaction.
*
If there are no active transactions, then close all PersistenceManager
* instances obtained from this PersistenceManagerFactory, mark this
* PersistenceManagerFactory as closed, disallow getPersistenceManager
* methods, and allow all other get methods. If a set method or
* getPersistenceManager method is called after close, then
* JDOUserException is thrown.
* @since 1.0.1
*/
void close();
/**
* A PersistenceManagerFactory instance can be used
* until it is closed.
* @return true if this PersistenceManagerFactory
* has been closed.
* @see #close()
* @since 2.0
*/
boolean isClosed();
/** Get an instance of PersistenceManager from this factory.
* The instance has default values for options.
*
*
After the first use of getPersistenceManager, no "set"
* methods will succeed.
*
* @return a PersistenceManager instance with default options.
*/
PersistenceManager getPersistenceManager();
/** Get a thread-safe instance of a proxy that dynamically binds
* on each method call to an instance of PersistenceManager.
*
When used with a PersistenceManagerFactory
* that uses TransactionType JTA,
* the proxy can be used in a server to dynamically bind to an instance
* from this factory associated with the thread's current transaction.
* In this case, the close method is ignored, as the
* PersistenceManager is automatically closed when the
* transaction completes.
*
When used with a PersistenceManagerFactory
* that uses TransactionType RESOURCE_LOCAL, the proxy uses an inheritable
* ThreadLocal to bind to an instance of PersistenceManager
* associated with the thread. In this case, the close method executed
* on the proxy closes the PersistenceManager and then
* clears the ThreadLocal.
* Use of this method does not affect the configurability of the
* PersistenceManagerFactory.
*
* @since 2.1
* @return a PersistenceManager proxy.
*/
PersistenceManager getPersistenceManagerProxy();
/** Get an instance of PersistenceManager from this factory.
* The instance has default values for options.
* The parameters userid and password are used
* when obtaining datastore connections from the connection pool.
*
*
After the first use of getPersistenceManager, no "set"
* methods will succeed.
*
* @return a PersistenceManager instance with default options.
* @param userid the userid for the connection
* @param password the password for the connection
*/
PersistenceManager getPersistenceManager(String userid, String password);
/** Set the user name for the data store connection.
* @param userName the user name for the data store connection.
*/
void setConnectionUserName(String userName);
/** Get the user name for the data store connection.
* @return the user name for the data store connection.
*/
String getConnectionUserName ();
/** Set the password for the data store connection.
* @param password the password for the data store connection.
*/
void setConnectionPassword (String password);
/** Set the URL for the data store connection.
* @param url the URL for the data store connection.
*/
void setConnectionURL (String url);
/** Get the URL for the data store connection.
* @return the URL for the data store connection.
*/
String getConnectionURL ();
/** Set the driver name for the data store connection.
* @param driverName the driver name for the data store connection.
*/
void setConnectionDriverName (String driverName);
/** Get the driver name for the data store connection.
* @return the driver name for the data store connection.
*/
String getConnectionDriverName ();
/** Set the name for the data store connection factory.
* @param connectionFactoryName the name of the data store connection
* factory.
*/
void setConnectionFactoryName (String connectionFactoryName);
/** Get the name for the data store connection factory.
* @return the name of the data store connection factory.
*/
String getConnectionFactoryName ();
/** Set the data store connection factory. JDO implementations
* will support specific connection factories. The connection
* factory interfaces are not part of the JDO specification.
* @param connectionFactory the data store connection factory.
*/
void setConnectionFactory (Object connectionFactory);
/** Get the data store connection factory.
* @return the data store connection factory.
*/
Object getConnectionFactory ();
/** Set the name for the second data store connection factory. This is
* needed for managed environments to get nontransactional connections for
* optimistic transactions.
* @param connectionFactoryName the name of the data store connection
* factory.
*/
void setConnectionFactory2Name (String connectionFactoryName);
/** Get the name for the second data store connection factory. This is
* needed for managed environments to get nontransactional connections for
* optimistic transactions.
* @return the name of the data store connection factory.
*/
String getConnectionFactory2Name ();
/** Set the second data store connection factory. This is
* needed for managed environments to get nontransactional connections for
* optimistic transactions. JDO implementations
* will support specific connection factories. The connection
* factory interfaces are not part of the JDO specification.
* @param connectionFactory the data store connection factory.
*/
void setConnectionFactory2 (Object connectionFactory);
/** Get the second data store connection factory. This is
* needed for managed environments to get nontransactional connections for
* optimistic transactions.
* @return the data store connection factory.
*/
Object getConnectionFactory2 ();
/** Set the default Multithreaded setting for all
* PersistenceManager instances obtained from this factory.
*
* @param flag the default Multithreaded setting.
*/
void setMultithreaded (boolean flag);
/** Get the default Multithreaded setting for all
* PersistenceManager instances obtained from this factory.
*
* @return the default Multithreaded setting.
*/
boolean getMultithreaded();
/** Set the Mapping setting for this factory. This is used to find the
* object-datastore mapping file(s).
*
* @param mapping the Mapping setting.
*/
void setMapping (String mapping);
/** Get the Mapping setting for this factory. This is used to find the
* object-datastore mapping file(s).
*
* @return the Mapping setting.
*/
String getMapping ();
/** Set the default Optimistic setting for all
* PersistenceManager instances obtained from this factory.
*
* @param flag the default Optimistic setting.
*/
void setOptimistic (boolean flag);
/** Get the default Optimistic setting for all
* PersistenceManager instances obtained from this factory.
*
* @return the default Optimistic setting.
*/
boolean getOptimistic();
/** Set the default RetainValues setting for all
* PersistenceManager instances obtained from this factory.
*
* @param flag the default RetainValues setting.
*/
void setRetainValues (boolean flag);
/** Get the default RetainValues setting for all
* PersistenceManager instances obtained from this factory.
*
* @return the default RetainValues setting.
*/
boolean getRetainValues ();
/** Set the default value for the RestoreValues property.
* If true, at rollback, fields of newly persistent instances
* are restored to
* their values as of the beginning of the transaction, and the instances
* revert to transient. Additionally, fields of modified
* instances of primitive types and immutable reference types
* are restored to their values as of the beginning of the
* transaction.
*
If false, at rollback, the values of fields of
* newly persistent instances are unchanged and the instances revert to
* transient. Additionally, dirty instances transition to hollow.
* If an implementation does not support this option, a
* JDOUnsupportedOptionException is thrown.
* @param restoreValues the value of the restoreValues property
*/
void setRestoreValues(boolean restoreValues);
/** Get the default value for the RestoreValues property.
* @return the value of the restoreValues property
*/
boolean getRestoreValues();
/** Set the default NontransactionalRead setting for all
* PersistenceManager instances obtained from this factory.
*
* @param flag the default NontransactionalRead setting.
*/
void setNontransactionalRead (boolean flag);
/** Get the default NontransactionalRead setting for all
* PersistenceManager instances obtained from this factory.
*
* @return the default NontransactionalRead setting.
*/
boolean getNontransactionalRead ();
/** Set the default NontransactionalWrite setting for all
* PersistenceManager instances obtained from this factory.
*
* @param flag the default NontransactionalWrite setting.
*/
void setNontransactionalWrite (boolean flag);
/** Get the default NontransactionalWrite setting for all
* PersistenceManager instances obtained from this factory.
*
* @return the default NontransactionalWrite setting.
*/
boolean getNontransactionalWrite ();
/** Set the default IgnoreCache setting for all
* PersistenceManager instances obtained from this factory.
*
* @param flag the default IgnoreCache setting.
*/
void setIgnoreCache (boolean flag);
/** Get the default IgnoreCache setting for all
* PersistenceManager instances obtained from this factory.
*
* @return the default IngoreCache setting.
*/
boolean getIgnoreCache ();
/** Gets the detachAllOnCommit setting.
* @see #setDetachAllOnCommit(boolean)
* @since 2.0
* @return the default detachAllOnCommit setting.
*/
boolean getDetachAllOnCommit();
/** Sets the default detachAllOnCommit setting for all
* PersistenceManager instances obtained from this
* factory.
* @see #getDetachAllOnCommit()
* @since 2.0
* @param flag the default DetachAllOnCommit setting
*/
void setDetachAllOnCommit(boolean flag);
/** Gets the default copyOnAttach setting for all
* PersistenceManager instances obtained from this
* factory.
* @see #setCopyOnAttach(boolean)
* @since 2.1
* @return the copyOnAttach setting.
*/
boolean getCopyOnAttach();
/** Sets the default copyOnAttach setting for all
* PersistenceManager instances obtained from this
* factory.
*
*
CopyOnAttach set to true specifies that during
* makePersistent, copies are made of detached parameter instances.
* With this flag set to false, detached parameter
* instances are attached directly and change their state from
* detached-clean to persistent-clean or from detached-dirty to
* persistent-dirty.
*
* @see #getCopyOnAttach()
* @since 2.1
*/
void setCopyOnAttach(boolean flag);
/**
* Sets the name of this PersistenceManagerFactory.
* @since 2.1
* @param name the name of this PMF
*/
void setName(String name);
/**
* Gets the name of this PersistenceManagerFactory.
* @since 2.1
* @return the name of this PMF
*/
String getName();
/**
* Sets the PersistenceUnitName for this PersistenceManagerFactory.
* This has the same semantics as the same-named property in
* JSR-220 PersistenceUnitInfo.
* @see #getPersistenceUnitName()
* @since 2.1
* @param name the PersistenceUnitName
*/
void setPersistenceUnitName(String name);
/**
* Gets the PersistenceUnitName for this PersistenceManagerFactory.
* @see #setPersistenceUnitName(String)
* @since 2.1
* @return the PersistenceUnitName
*/
String getPersistenceUnitName();
/**
* Sets the TimeZone ID of the server associated with this
* PersistenceManagerFactory. The parameter is a String
* suitable for use with TimeZone.getTimeZone(). The String
* must match an ID returned by TimeZone.getAvailableIDs().
* If the ServerTimeZoneID is not set, or set to the null String,
* assume that the server has the same TimeZone ID as the client.
* If incorrectly set, the result of PersistenceManager.getServerDate()
* might be incorrect.
* @see #getServerTimeZoneID()
* @see java.util.TimeZone#getTimeZone(String)
* @see java.util.TimeZone#getAvailableIDs()
* @see PersistenceManager#getServerDate()
* @since 2.1
* @param timezoneid the TimeZone ID of the server
* @throws JDOUserException if the parameter does not match
* an ID from TimeZone.getAvailableIDs()
*/
void setServerTimeZoneID(String timezoneid);
/**
* Gets the TimeZone ID of the server associated with this
* PersistenceManagerFactory. If not set, assume that
* the server has the same TimeZone ID as the client.
* @see #setServerTimeZoneID(String)
* @since 2.1
* @return the TimeZone of the server
*/
String getServerTimeZoneID();
/**
* Sets the TransactionType for this PersistenceManagerFactory.
* Permitted values are "JTA" and "RESOURCE_LOCAL".
* This has the same semantics as the same-named property in
* JSR-220 EntityManagerFactory.
* @see #getTransactionType()
* @see Constants#JTA
* @see Constants#RESOURCE_LOCAL
* @since 2.1
* @param name the TransactionType
* @throws JDOUserException if the parameter is not a permitted value
*/
void setTransactionType(String name);
/**
* Gets the TransactionType for this PersistenceManagerFactory.
* @see #setTransactionType(String)
* @since 2.1
* @return the TransactionType
*/
String getTransactionType();
/** Gets the value for read-only for this PMF.
* Indicates whether the datastore is read-only or writable.
* @see #setReadOnly(boolean)
* @since 2.2
* @return the readOnly setting.
*/
boolean getReadOnly();
/** Sets the value for whether the datastore is to be considered
* read-only.
*
*
ReadOnly set to false specifies that no updates
* can be performed to the datastore, and if updates are attempted
* a JDOReadOnlyException is thrown.
*
* @see #getReadOnly()
* @since 2.2
*/
void setReadOnly(boolean flag);
/** Get the value for transaction isolation level for this PMF.
* @return the transaction isolation level
* @see #setTransactionIsolationLevel(String)
* @since 2.2
*/
String getTransactionIsolationLevel();
/** Set the value for transaction isolation level for this PMF.
* Transaction isolation levels are defined in javax.jdo.Constants.
* If the requested level is not available, but a higher level is
* available, the higher level is silently used.
* If the requested level is not available, and no higher level is
* available, then JDOUnsupportedOptionException is thrown.
* Standard values in order from low to high are:
*
read-uncommitted
* read-committed
* repeatable-read
* snapshot
* serializable
* PersistenceManagerFactory.
* Properties with keys VendorName and
* VersionNumber are required. Other keys are optional.
* @return the non-configurable properties of this
* PersistenceManagerFactory.
*/
Properties getProperties();
/** The application can determine from the results of this
* method which optional features, and which query languages
* are supported by the JDO implementation.
* Each supported JDO feature is represented by a
* String with one of the following values:
*
*
javax.jdo.option.TransientTransactional
*
*
*
The standard JDO query language is represented by a
* String:
*
javax.jdo.query.JDOQL
* @return the Collection of Strings representing
* the supported options.
*/
Collection supportedOptions();
/**
* Return the {@link DataStoreCache} that this factory uses for
* controlling a second-level cache. If this factory does not use
* a second-level cache, the returned instance does nothing. This
* method never returns null.
* @since 2.0
* @return the DataStoreCache
*/
DataStoreCache getDataStoreCache ();
/**
* Add the parameter listener to the list of
* instance lifecycle event listeners set as the initial listeners
* for each PersistenceManager created by this PersistenceManagerFactory.
* The addInstanceLifecycleListener and
* removeInstanceLifecycleListener
* methods are considered to be configuration methods and
* can only be called when the PersistenceManagerFactory
* is configurable (before the first time {@link #getPersistenceManager}
* is called).
* The classes parameter identifies all
* of the classes of interest. If the classes
* parameter is specified as null, events for all
* persistent classes and interfaces will be sent to the listener.
* The listener will be called for each event for which it
* implements the corresponding {@link InstanceLifecycleListener}
* interface.
* @param listener the lifecycle listener
* @param classes the classes of interest to the listener
* @since 2.0
*/
void addInstanceLifecycleListener (InstanceLifecycleListener listener,
Class[] classes);
/**
* Remove the parameter listener instance from the list of
* instance lifecycle event listeners set as the initial listeners
* for each PersistenceManager created by this PersistenceManagerFactory.
* The addInstanceLifecycleListener and
* removeInstanceLifecycleListener
* methods are considered to be configuration methods and
* can only be called when the PersistenceManagerFactory
* is configurable (before the first time {@link #getPersistenceManager}
* is called).
* @param listener the listener instance to be removed
* @since 2.0
*/
void removeInstanceLifecycleListener (InstanceLifecycleListener listener);
/**
* Add the FetchGroups to the set of active fetch groups.
* FetchGroups are made unmodifiable before being added.
* FetchGroups that match existing FetchGroups
* replace the corresponding FetchGroups.
* The replaced FetchGroups become unscoped.
* Match is based on identical class and equal name.
* The methods {@link #addFetchGroups}, {@link #removeFetchGroups},
* {@link #getFetchGroups}, and {@link #removeAllFetchGroups}
* are internally serialized.
* @param groups an array of FetchGroups
* @throws SecurityException if the caller is not authorized for
* {@link JDOPermission} ("manageMetadata")
* @since 2.2
*/
void addFetchGroups(FetchGroup... groups);
/**
* Remove the FetchGroups from the set of active
* FetchGroups. Existing FetchGroups that match
* parameter FetchGroups are removed. Parameter
* FetchGroups that do not match any existing
* FetchGroup are ignored.
* Removed FetchGroups become unscoped.
* Match is based on identical class and equal name.
* The methods {@link #addFetchGroups}, {@link #removeFetchGroups},
* {@link #getFetchGroups}, and {@link #removeAllFetchGroups}
* are internally serialized.
* @param groups an array of FetchGroups
* @throws SecurityException if the caller is not authorized for
* {@link JDOPermission} ("manageMetadata")
* @since 2.2
*/
void removeFetchGroups(FetchGroup... groups);
/**
* Remove all FetchGroups from the set of active
* FetchGroups.
* All removed FetchGroups become unscoped.
* The methods {@link #addFetchGroups}, {@link #removeFetchGroups},
* {@link #getFetchGroups}, and {@link #removeAllFetchGroups}
* are internally serialized.
* @throws SecurityException if the caller is not authorized for
* {@link JDOPermission} ("manageMetadata")
* @since 2.2
*/
void removeAllFetchGroups();
/**
* Create an unscoped, modifiable FetchGroup for the Class and
* name. If a corresponding FetchGroup already exists in
* PersistenceManagerFactory scope, copy its definition
* to a new FetchGroup.
* If the FetchGroup does not already exist, create it
* with no members. The FetchGroup does not become
* in scope until it is added to the current set via
* {@link #addFetchGroups}.
* @param cls the class or interface for the FetchGroup
* @param name the name of the fetch group
* @return the FetchGroup
* @throws JDOUserException if the class is not a persistence-capable
* class or interface
* @since 2.2
*/
FetchGroup getFetchGroup(Class cls, String name);
/**
* Get a modifiable Set containing a mutable copy of all currently active
* (in scope) fetch groups.
* The methods {@link #addFetchGroups}, {@link #removeFetchGroups},
* {@link #getFetchGroups}, and {@link #removeAllFetchGroups}
* are internally serialized.
* @return a copy of all currently active fetch groups
* @throws SecurityException if the caller is not authorized for
* {@link JDOPermission} ("getMetadata")
* @since 2.2
*/
Set getFetchGroups();
/**
* Method to register metadata with the persistence process managed by this
* PersistenceManagerFactory.
* Metadata can be created using the method {@link #newMetadata}.
* If there is already metadata registered for a class contained in this metadata
* object then a JDOUserException will be thrown.
* @param metadata The Metadata to register.
* @since 3.0
*/
void registerMetadata(JDOMetadata metadata);
/**
* Method to return a new metadata object that can be subsequently modified
* and registered with the persistence process using the method {@link #registerMetadata}.
* @return The metadata
* @since 3.0
*/
JDOMetadata newMetadata();
/**
* Method to return the metadata object for the specified class/interface, if there is
* metadata defined for that class/interface.
* If there is no metadata for the specified class/interface, or the parameter is null,
* then null will be returned.
* @return The metadata
* @since 3.0
*/
TypeMetadata getMetadata(String className);
/**
* Method to return the currently managed classes for this factory.
* @return Collection of persistable classes that are managed by this factory
* @since 3.1
*/
Collection getManagedClasses();
}
api/src/java/javax/jdo/Query.java 100664 112704 12500110371 17250 0 ustar mbouschen staff 0 0 /*
* 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.
*/
/*
* Query.java
*
*/
package javax.jdo;
import java.io.Serializable;
import java.util.Collection;
import java.util.Map;
/** The Query interface allows applications to obtain persistent
* instances, values, and aggregate data
* from the data store.
*
* The {@link PersistenceManager} is the factory for Query
* instances. There may be many Query instances associated with a
* PersistenceManager. Multiple queries might be executed
* simultaneously by different threads, but the implementation might choose to
* execute them serially. In either case, the implementation must be thread
* safe.
*
* There are three required elements in a Query: the class of
* the results, the candidate collection of instances, and the filter.
*
*
There are optional elements: parameter declarations, variable
* declarations, import statements, ordering and grouping specifications,
* result and result class, the range of results,
* and flags indicating whether the query result
* is unique and whether the query can be modified.
*
The query namespace is modeled after methods in Java:
*
* setClass corresponds to the class definition
* declareParameters corresponds to formal parameters of a
* method
* declareVariables corresponds to local variables of a method
* setFilter and setOrdering correspond to the
* method body
*
* There are two namespaces in queries. Type names have their own
* namespace that is separate from the namespace for fields, variables
* and parameters.
*
The method setClass introduces the name of the candidate
* class in the type namespace. The method declareImports
* introduces the names of the imported class or interface types in the type
* namespace. Imported type names must be unique. When used (e.g. in a parameter
* declaration, cast expression, etc.) a type name must be the name of the
* candidate class, the name of a class or interface imported by method
* declareImports, or denote a class or interface from the same
* package as the candidate class.
*
The method setClass introduces the names of the candidate
* class fields.
*
The method declareParameters introduces the names of the
* parameters. A name introduced by declareParameters hides the
* name of a candidate class field of the same name. Parameter names must be
* unique.
*
The method declareVariables introduces the names of the
* variables. A name introduced by declareVariables hides the name
* of a candidate class field if equal. Variable names must be unique and must
* not conflict with parameter names.
*
The result of the query by default is a list of result class instances,
* but might be specified via setResult. The class of the result
* by default is the candidate class, but might be specified via
* setResultClass.
*
A hidden field may be accessed using the 'this' qualifier:
* this.fieldName.
*
The Query interface provides methods which execute the query
* based on the parameters given. They return a single instance or a
* List of result class instances which the
* user can iterate to get results. The signature
* of the execute methods specifies that they return an
* Object which must be cast to the appropriate result by the user.
*
Any parameters passed to the execute methods are used only
* for this execution, and are not remembered for future execution.
* @version 2.1
*/
public interface Query extends Serializable {
/**
* The string constant used as the first argument to
* {@link PersistenceManager#newQuery(String,Object)} to identify that the
* created query should obey the JDOQL syntax and semantic rules.
*
This is the default query language used when creating a query with any
* of the other {@link PersistenceManager#newQuery} methods, except
* {@link PersistenceManager#newQuery(Object)}, which uses the query
* language of the compiled query template object passed to that method.
* @since 2.0
*/
String JDOQL = "javax.jdo.query.JDOQL";
/**
* The string constant used as the first argument to {@link
* PersistenceManager#newQuery(String,Object)} to identify that
* the created query should use SQL semantics. This is only
* meaningful for relational JDO implementations.
* If this is used, the Object argument to the
* {@link PersistenceManager#newQuery(String,Object)} method
* should be a String containing a SQL
* SELECT statement.
* @since 2.0
*/
String SQL = "javax.jdo.query.SQL";
/** Set the class of the candidate instances of the query.
* The class specifies the class
* of the candidates of the query. Elements of the candidate collection
* that are of the specified class are filtered before being
* put into the result Collection.
*
* @param cls the Class of the candidate instances.
*/
void setClass(Class cls);
/** Set the candidate Extent to query.
* @param pcs the candidate Extent.
*/
void setCandidates(Extent pcs);
/** Set the candidate Collection to query.
* @param pcs the candidate Collection.
*/
void setCandidates(Collection pcs);
/** Set the filter for the query.
*
*
The filter specification is a String containing a Boolean
* expression that is to be evaluated for each of the instances
* in the candidate collection. If the filter is not specified,
* then it defaults to "true", which has the effect of filtering
* the input Collection only for class type.
*
An element of the candidate collection is returned in the result if:
*
it is assignment compatible to the candidate Class
* of the Query; and
* for all variables there exists a value for which the filter
* expression evaluates to true.
* The user may denote uniqueness in the filter expression by
* explicitly declaring an expression (for example, e1 != e2).
*
Rules for constructing valid expressions follow the Java
* language, except for these differences:
*
* Equality and ordering comparisons between primitives and instances
* of wrapper classes are valid.
* Equality and ordering comparisons of Date fields and
* Date parameters are valid.
* White space (non-printing characters space, tab, carriage
* return, and line feed) is a separator and is otherwise ignored.
* The assignment operators =, +=, etc. and
* pre- and post-increment and -decrement are not supported. Therefore,
* there are no side effects from evaluation of any expressions.
* Methods, including object construction, are not supported, except
* for Collection.contains(Object o),
* Collection.isEmpty(),
* String.startsWith(String s), and
* String.endsWith(String e). Implementations might choose to
* support non-mutating method calls as non-standard extensions.
* Navigation through a null-valued field, which would
* throw NullPointerException, is treated as if the filter
* expression returned false for the evaluation of the current
* set of variable values. Other values for variables might still qualify
* the candidate instance for inclusion in the result set.
* Navigation through multi-valued fields (Collection
* types) is specified using a variable declaration and the
* Collection.contains(Object o) method.
*
* Identifiers in the expression are considered to be in the name
* space of the specified class, with the addition of declared imports,
* parameters and variables. As in the Java language, this is a
* reserved word which means the element of the collection being evaluated.
*
Navigation through single-valued fields is specified by the Java
* language syntax of field_name.field_name....field_name.
*
A JDO implementation is allowed to reorder the filter expression
* for optimization purposes.
* @param filter the query filter.
*/
void setFilter(String filter);
/** Set the import statements to be used to identify the fully qualified
* name of variables or parameters. Parameters and unbound variables might
* come from a different class from the candidate class, and the names
* need to be declared in an import statement to eliminate ambiguity.
* Import statements are specified as a String with
* semicolon-separated statements.
*
The String parameter to this method follows the syntax of
* the import statement of the Java language.
* @param imports import statements separated by semicolons.
*/
void declareImports(String imports);
/** Declare the list of parameters query execution.
*
* The parameter declaration is a String containing one or more
* query parameter declarations separated with commas. Each parameter named
* in the parameter declaration must be bound to a value when
* the query is executed.
*
The String parameter to this method follows the syntax
* for formal parameters in the Java language.
* @param parameters the list of parameters separated by commas.
*/
void declareParameters(String parameters);
/** Declare the unbound variables to be used in the query. Variables
* might be used in the filter, and these variables must be declared
* with their type. The unbound variable declaration is a
* String containing one or more unbound variable declarations
* separated with semicolons. It follows the syntax for local variables in
* the Java language.
* @param variables the variables separated by semicolons.
*/
void declareVariables(String variables);
/** Set the ordering specification for the result Collection.
* The ordering specification is a String containing one or
* more ordering declarations separated by commas.
*
*
Each ordering declaration is the name of the field on which
* to order the results followed by one of the following words:
* "ascending" or "descending".
*
*
The field must be declared in the candidate class or must be
* a navigation expression starting with a field in the candidate class.
*
*
Valid field types are primitive types except boolean;
* wrapper types except Boolean; BigDecimal;
* BigInteger; String; and Date.
* @param ordering the ordering specification.
*/
void setOrdering(String ordering);
/** Set the ignoreCache option. The default value for this option was
* set by the PersistenceManagerFactory or the
* PersistenceManager used to create this Query.
*
* The ignoreCache option setting specifies whether the query should execute
* entirely in the back end, instead of in the cache. If this flag is set
* to true, an implementation might be able to optimize the
* query execution by ignoring changed values in the cache. For optimistic
* transactions, this can dramatically improve query response times.
* @param ignoreCache the setting of the ignoreCache option.
*/
void setIgnoreCache(boolean ignoreCache);
/** Get the ignoreCache option setting.
* @return the ignoreCache option setting.
* @see #setIgnoreCache
*/
boolean getIgnoreCache();
/** Verify the elements of the query and provide a hint to the query to
* prepare and optimize an execution plan.
*/
void compile();
/** Execute the query and return the filtered Collection.
*
Cancellation of the query using cancel() will result in JDOQueryInterruptedException
* being thrown here
* @return the filtered Collection.
* @see #executeWithArray(Object[] parameters)
*/
Object execute();
/** Execute the query and return the filtered Collection.
*
Cancellation of the query using cancel() will result in JDOQueryInterruptedException
* being thrown here
* @return the filtered Collection.
* @see #executeWithArray(Object[] parameters)
* @param p1 the value of the first parameter declared.
*/
Object execute(Object p1);
/** Execute the query and return the filtered Collection.
*
Cancellation of the query using cancel() will result in JDOQueryInterruptedException
* being thrown here
* @return the filtered Collection.
* @see #executeWithArray(Object[] parameters)
* @param p1 the value of the first parameter declared.
* @param p2 the value of the second parameter declared.
*/
Object execute(Object p1, Object p2);
/** Execute the query and return the filtered Collection.
*
Cancellation of the query using cancel() will result in JDOQueryInterruptedException
* being thrown here
* @return the filtered Collection.
* @see #executeWithArray(Object[] parameters)
* @param p1 the value of the first parameter declared.
* @param p2 the value of the second parameter declared.
* @param p3 the value of the third parameter declared.
*/
Object execute(Object p1, Object p2, Object p3);
/** Execute the query and return the filtered Collection. The
* query is executed with the parameters set by the Map values.
* Each Map entry consists of a key which is the name of the
* parameter in the declareParameters method, and a value which
* is the value used in the execute method. The keys in the
* Map and the declared parameters must exactly match or a
* JDOUserException is thrown.
*
Cancellation of the query using cancel() will result in JDOQueryInterruptedException
* being thrown here
* @return the filtered Collection.
* @see #executeWithArray(Object[] parameters)
* @param parameters the Map containing all of the parameters.
*/
Object executeWithMap (Map parameters);
/** Execute the query and return the filtered Collection.
*
*
The execution of the query obtains the values of the parameters and
* matches them against the declared parameters in order. The names
* of the declared parameters are ignored. The type of
* the declared parameters must match the type of the passed parameters,
* except that the passed parameters might need to be unwrapped to get
* their primitive values.
*
*
The filter, import, declared parameters, declared variables, and
* ordering statements are verified for consistency.
*
*
Each element in the candidate Collection is examined to
* see that it is assignment compatible to the Class of the
* query. It is then evaluated by the Boolean expression of the filter.
* The element passes the filter if there exist unique values for all
* variables for which the filter expression evaluates to true.
*
Cancellation of the query using cancel() will result in JDOQueryInterruptedException
* being thrown here
* @return the filtered Collection.
* @param parameters the Object array with all of the
* parameters.
*/
Object executeWithArray (Object... parameters);
/** Get the PersistenceManager associated with this
* Query.
*
*
If this Query was restored from a serialized form, it has
* no PersistenceManager, and this method returns
* null.
* @return the PersistenceManager associated with this
* Query.
*/
PersistenceManager getPersistenceManager();
/** Close a query result and release any resources associated with it. The
* parameter is the return from execute(...) and might have
* iterators open on it. Iterators associated with the query result are
* invalidated: they return false to hasNext()
* and throw NoSuchElementException to next().
* @param queryResult the result of execute(...) on this
* Query instance.
*/
void close (Object queryResult);
/** Close all query results associated with this Query
* instance, and release all resources associated with them. The query
* results might have iterators open on them. Iterators associated with the
* query results are invalidated:
* they return false to hasNext() and throw
* NoSuchElementException to next().
*/
void closeAll ();
/**
* Set the grouping expressions, optionally including a "having"
* clause. When grouping is specified, each result expression
* must either be an expression contained in the grouping, or an
* aggregate evaluated once per group.
*
* @param group a comma-delimited list of expressions, optionally
* followed by the "having" keyword and a boolean expression
* @since 2.0
*/
void setGrouping (String group);
/**
* Specify that only the first result of the query should be
* returned, rather than a collection. The execute method will
* return null if the query result size is 0.
* @since 2.0
* @param unique if true, only one element is returned
*/
void setUnique (boolean unique);
/**
* Specifies what type of data this query should return. If this
* is unset or set to null, this query returns
* instances of the query's candidate class. If set, this query
* will return expressions, including field values (projections) and
* aggregate function results.
* @param data a comma-delimited list of expressions
* (fields, functions on fields, or aggregate functions)
* to return from this query
* @since 2.0
*/
void setResult (String data);
/**
* Specify the type of object in which to return each element of
* the result of invoking {@link #execute} or one of its siblings.
* If the result is not set or set to null, the result class defaults
* to the candidate class of the query. If the result consists of one
* expression, the result class defaults to the type of that expression.
* If the result consists of more than one expression, the result class
* defaults to Object[].
* The result class may be specified to be one of the java.lang classes
* Character, Boolean, Byte, Short, Integer, Long, Float, Double, String,
* or Object[]; or one of the java.math classes BigInteger or BigDecimal;
* or the java.util class Date; or one of the java.sql classes Date,
* Time, or Timestamp; or a user-defined class.
*
If there are multiple result expressions, the result class
* must be able to hold all elements of the result specification
* or a JDOUserException is thrown.
*
If there is only one result expression, the result class must be
* assignable from the type of the result expression or must be able
* to hold all elements of the result specification. A single value
* must be able to be coerced into the specified result class
* (treating wrapper classes as equivalent to their unwrapped
* primitive types) or by matching. If the result class does not satisfy
* these conditions, a JDOUserException is thrown.
*
A constructor of a result class specified in the setResult method
* will be used if the results specification matches the parameters
* of the constructor by position and type. If more than one constructor
* satisfies the requirements, the JDO implementation chooses one of them.
* If no constructor satisfies the results requirements, or if the result
* class is specified via the setResultClass method, the following
* requirements apply:
*
* A user-defined result class must have a no-args constructor and
* one or more public set or put methods or
* fields.
* Each result expression must match one of:
*
* a public field that matches the name of the result expression
* and is of the type (treating wrapper types equivalent to primitive
* types) of the result expression;
* or if no public field matches the name and type, a public
* setor if neither of the above applies,a public method must be found
* with the signature void put(Object, Object).
* During processing of the results,
* the first argument is the name of the result expression and
* the second argument is the value from the query result.
*
*
* Portable result classes do not invoke any persistence behavior
* during their no-args constructor or setsetRange("50, 70");
or
* setRange(":from, :to"); or
* setRange("50, :to");.
* The execution of the query is
* modified to return only a subset of results. If the filter would
* normally return 100 instances, and fromIncl is set to 50, and
* toExcl is set to 70, then the first 50 results that would have
* been returned are skipped, the next 20 results are returned and the
* remaining 30 results are ignored. An implementation should execute
* the query such that the range algorithm is done at the data store.
* @param fromInclToExcl comma-separated fromIncl and toExcl values
* @see #setRange(long, long)
* @since 2.0
*/
void setRange (String fromInclToExcl);
/**
* Add a vendor-specific extension to this query. The key and value
* are not standard.
* An implementation must ignore keys that are not recognized.
* @param key the key of the extension
* @param value the value of the extension
* @since 2.0
*/
void addExtension (String key, Object value);
/**
* Set multiple extensions, or use null to clear all extensions.
* Map keys and values are not standard.
* An implementation must ignore entries that are not recognized.
* @param extensions the map of extensions
* @see #addExtension
* @since 2.0
*/
void setExtensions (Map extensions);
/**
* Returns the FetchPlan used by this
* Query. Modifications of the returned fetch plan will not
* cause this query's owning PersistenceManager's
* FetchPlan to be modified.
* @since 2.0
* @return the fetch plan used by this query
*/
FetchPlan getFetchPlan ();
/**
* Deletes all the instances of the candidate class that pass the
* filter.
* @see #deletePersistentAll()
* @param parameters for the query
* @return the number of instances of the candidate class that were deleted
* @since 2.0
*/
long deletePersistentAll (Object... parameters);
/**
* Deletes all the instances of the candidate class that pass the
* filter.
* @see #deletePersistentAll()
* @param parameters for the query
* @return the number of instances of the candidate class that were deleted
* @since 2.0
*/
long deletePersistentAll (Map parameters);
/**
* Deletes all the instances of the candidate class that pass the
* filter. Returns the number of instances of the candidate
* class that were deleted, specifically not including the number
* of dependent and embedded instances.
* Dirty instances of affected classes in the cache are first
* flushed to the datastore. Instances in the cache or brought into
* the cache as a result of executing one of the
* deletePersistentAll
* methods undergo life cycle changes as if deletePersistent
* were called on them.
*
Specifically, if the class of deleted instances implements the
* delete callback interface, the corresponding callback methods
* are called on the deleted instances. Similarly, if there are
* lifecycle listeners registered for delete events on affected
* classes, the listener is called for each appropriate deleted instance.
*
Before returning control to the application, instances of affected
* classes in the cache are refreshed to reflect whether they were
* deleted from the datastore.
*
* @return the number of instances of the candidate class that were deleted
* @since 2.0
*/
long deletePersistentAll ();
/**
* The unmodifiable flag, when set, disallows further
* modification of the query, except for specifying the range,
* result class, and ignoreCache option.
* The unmodifiable flag can also be set in metadata.
* @since 2.0
*/
void setUnmodifiable();
/**
* The unmodifiable flag, when set, disallows further
* modification of the query, except for specifying the range,
* result class, and ignoreCache option.
* @return the current setting of the flag
* @since 2.0
*/
boolean isUnmodifiable();
/**
* Add a subquery to this query.
* @param sub the subquery to add to this Query
* @param variableDeclaration the name of the variable in the outer query
* to bind the results of the subquery
* @param candidateCollectionExpression the candidate collection
* of the subquery as an expression using terms of the outer query
* @see #addSubquery(Query sub, String variableDeclaration,
* String candidateCollectionExpression, String... parameters)
* @since 2.1
*/
void addSubquery
(Query sub, String variableDeclaration,
String candidateCollectionExpression);
/**
* Add a subquery to this query.
* The String version of the method binds the named expression
* to the parameter implictly or explicitly declared in the
* subquery.
* @param sub the subquery to add to this Query
* @param variableDeclaration the name of the variable
* to be used in this Query
* @param candidateCollectionExpression the candidate collection
* to apply to the subquery
* @param parameter the expression from the outer query to bind
* the parameter in the subquery
* @see #addSubquery(Query sub, String variableDeclaration,
* String candidateCollectionExpression, String... parameters)
* @since 2.1
*/
void addSubquery
(Query sub, String variableDeclaration,
String candidateCollectionExpression, String parameter);
/**
* Add a subquery to this query.
* A subquery is composed as a Query and subsequently attached
* to a different query (the outer query) by calling this method.
* The query parameter instance is unmodified as a result of the
* addSubquery or subsequent execution of the outer query.
* Only some of the query parts are copied for use as the subquery.
* The parts copied include the candidate class, filter, parameter
* declarations, variable declarations, imports, ordering specification,
* uniqueness, result specification, and grouping specification.
* The association with a PersistenceManager, the candidate collection
* or extent, result class, and range limits are not used.
* The String parameters are trimmed of white space.
* The variableDeclaration parameter is the name of the variable
* containing the results of the subquery execution. If the same value
* of variableDeclaration is used to add multiple subqueries, the
* subquery replaces the previous subquery for the same named variable.
* If the subquery parameter is null, the variable is unset,
* effectively making the variable named in the variableDeclaration
* unbound. If the trimmed value is the empty String, or the parameter
* is null, then JDOUserException is thrown.
* The candidateCollectionExpression is the expression from the
* outer query that represents the candidates over which the subquery
* is evaluated. If the trimmed value is the empty String, or the
* parameter is null, then the candidate collection is the extent
* of the candidate class.
* The String... version of the method binds the named expressions in
* turn to parameters in the order in which they are declared in the
* subquery, or in the order they are found in the filter if not
* explicitly declared in the subquery.
* @param sub the subquery to add to this Query
* @param variableDeclaration the name of the variable in the outer query
* to bind the results of the subquery
* @param candidateCollectionExpression the candidate collection
* of the subquery as an expression using terms of the outer query
* @param parameters the expressions from the outer query to bind
* the parameters in the subquery
* @since 2.1
*/
void addSubquery
(Query sub, String variableDeclaration,
String candidateCollectionExpression, String... parameters);
/**
* Add a subquery to this query.
* The Map version of the method treats the key of each map entry as
* the name of the parameter in the subquery, with or without the
* leading ":", and the value as the name of the expression in the
* outer query. If the trimmed expression is the empty String for
* either the parameter or the value of the String[], or for any
* map key or value, that expression is ignored.
* @param sub the subquery to add to this Query
* @param variableDeclaration the name of the variable
* to be used in this Query
* @param candidateCollectionExpression the candidate collection
* to apply to the subquery
* @param parameters the expressions from the outer query to bind
* the parameter in the subquery
* @see #addSubquery(Query sub, String variableDeclaration,
* String candidateCollectionExpression, String... parameters)
* @since 2.1
*/
void addSubquery
(Query sub, String variableDeclaration,
String candidateCollectionExpression, Map parameters);
/**
* Specify a timeout interval (milliseconds) for any read operations
* associated with this query. To unset the explicit timeout for this
* query, specify null. For no timeout, specify 0.
* If the datastore granularity is larger than milliseconds, the
* timeout value will be rounded up to the nearest supported datastore
* value.
* If a read operation hasn't completed within this interval, executeXXX
* will throw a JDODatastoreException.
* If multiple datastore operations are required to complete the query,
* the timeout value applies to each of them individually.
* If the datastore and JDO implementation support timeouts, then
* javax.jdo.option.DatastoreTimeout is returned by
* PersistenceManagerFactory.supportedOptions().
* If timeouts are not supported,this method will throw
* JDOUnsupportedOptionException.
* @since 3.0
* @param interval the timeout interval (milliseconds)
*/
void setDatastoreReadTimeoutMillis(Integer interval);
/** Get the effective timeout setting for read operations.
* If the timeout has not been set on this query explicitly, the effective
* datastore read timeout value from the persistence manager is returned.
* @see #setDatastoreReadTimeoutMillis(Integer)
* @see PersistenceManager#setDatastoreReadTimeoutMillis(Integer)
* @return the effective timeout setting (milliseconds).
* @since 3.0
*/
Integer getDatastoreReadTimeoutMillis();
/**
* Specify a timeout interval (milliseconds) for any write operations
* associated with this query. To unset the explicit timeout for this
* query, specify null. For no timeout, specify 0.
* If the datastore granularity is larger than milliseconds, the
* timeout value will be rounded up to the nearest supported datastore
* value.
* If a write operation hasn't completed within this interval, deleteXXX
* will throw a JDODatastoreException.
* If multiple datastore operations are required to complete the query,
* the timeout value applies to each of them individually.
* If the datastore and JDO implementation support timeouts, then
* javax.jdo.option.DatastoreTimeout is returned by
* PersistenceManagerFactory.supportedOptions().
* If timeouts are not supported,this method will throw
* JDOUnsupportedOptionException.
* @since 3.0
* @param interval the timeout interval (milliseconds)
*/
void setDatastoreWriteTimeoutMillis(Integer interval);
/** Get the effective timeout setting for write operations.
* If the timeout has not been set on this query explicitly, the effective
* datastore write timeout value from the persistence manager is returned.
* @see #setDatastoreWriteTimeoutMillis(Integer)
* @see PersistenceManager#setDatastoreWriteTimeoutMillis(Integer)
* @return the effective timeout setting (milliseconds).
* @since 3.0
*/
Integer getDatastoreWriteTimeoutMillis();
/**
* Method to cancel any executing queries.
* If the underlying datastore doesn't support cancellation of queries this will
* throw JDOUnsupportedOptionException.
* If the cancellation fails (e.g in the underlying datastore) then this will throw
* a JDOException.
* @since 3.0
*/
void cancelAll();
/**
* Method to cancel an executing query in the specified thread.
* If the underlying datastore doesn't support cancellation of queries this will
* throw JDOUnsupportedOptionException.
* If the cancellation fails (e.g in the underlying datastore) then this will throw
* a JDOException.
* @since 3.0
*/
void cancel(Thread thread);
/**
* If true, a lock will be applied to all objects read in this
* query.
*
If false then retrieved objects will not be locked.
* If null will fallback to the value for metadata for the class in question.
* @param serialize the value of the serializeRead property
* @since 3.0
*/
void setSerializeRead(Boolean serialize);
/**
* Return the current value of the serializeRead property.
* @return the value of the serializeRead property
* @since 3.0
*/
Boolean getSerializeRead();
}
api/src/java/javax/jdo/spi/Detachable.java 100664 4043 12500110371 20706 0 ustar mbouschen staff 0 0 /*
* 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 javax.jdo.spi;
/**
* This interface is implemented by classes that can be detached from the
* persistence context and later attached. The interface includes the
* contract by which the StateManager can set the object id, version,
* BitSet of loaded fields, and BitSet of modified fields
* so they are preserved while outside the persistence environment.
*
The detached state is stored as a field in each instance of Detachable.
* The field is serialized so as to maintain the state of the instance
* while detached. While detached, only the BitSet of modified fields
* will be modified. The structure of the Object[] jdoDetachedState
* is as follows:
*
jdoDetachedState[0]: the Object Id of the instance
* jdoDetachedState[1]: the Version of the instance
* jdoDetachedState[2]: a BitSet of loaded fields
* jdoDetachedState[3]: a BitSet of modified fields
*
* I18NHelper msg = I18NHelper.getInstance("javax.jdo.Bundle");
*
* This call uses the class loader that loaded the I18NHelper class to find
* the specified Bundle. The class provides two overloaded getInstance
* methods allowing to specify a different class loader:
* {@link #getInstance(Class cls)} looks for a bundle
* called "Bundle.properties" located in the package of the specified class
* object and {@link #getInstance(String bundleName,ClassLoader loader)}
* uses the specified class loader to find the bundle.
*
* Subsequently, instance methods can be used to format message strings
* using the text from the bundle, as in
*
* throw new JDOFatalInternalException (msg.msg("ERR_NoMetadata",
* cls.getName()));
* @since 1.0.1
* @version 1.1
*/
public class I18NHelper {
/** Bundles that have already been loaded
*/
private static Hashtable
bundles = new Hashtable();
/** Helper instances that have already been created
*/
private static Hashtable
helpers = new Hashtable();
/** The default locale for this VM.
*/
private static Locale locale = Locale.getDefault();
/** The bundle used by this instance of the helper.
*/
private ResourceBundle bundle = null;
/** Throwable if ResourceBundle couldn't be loaded
*/
private Throwable failure = null;
/** The unqualified standard name of a bundle. */
private static final String bundleSuffix = ".Bundle"; // NOI18N
/** Constructor */
private I18NHelper() {
}
/** Constructor for an instance bound to a bundle.
* @param bundleName the name of the resource bundle
* @param loader the class loader from which to load the resource
* bundle
*/
private I18NHelper (String bundleName, ClassLoader loader) {
try {
bundle = loadBundle (bundleName, loader);
}
catch (Throwable e) {
failure = e;
}
}
/** An instance bound to a bundle. This method uses the current class
* loader to find the bundle.
* @param bundleName the name of the bundle
* @return the helper instance bound to the bundle
*/
public static I18NHelper getInstance (String bundleName) {
return getInstance (bundleName, I18NHelper.class.getClassLoader());
}
/** An instance bound to a bundle. This method figures out the bundle name
* for the class object's package and uses the class' class loader to
* find the bundle. Note, the specified class object must not be
* null.
* @param cls the class object from which to load the resource bundle
* @return the helper instance bound to the bundle
*/
public static I18NHelper getInstance (final Class cls) {
ClassLoader classLoader = AccessController.doPrivileged (
new PrivilegedAction () {
public ClassLoader run () {
return cls.getClassLoader();
}
}
);
String bundle = getPackageName (cls.getName()) + bundleSuffix;
return getInstance (bundle, classLoader);
}
/** An instance bound to a bundle. This method uses the specified class
* loader to find the bundle. Note, the specified class loader must not
* be null.
* @param bundleName the name of the bundle
* @param loader the class loader from which to load the resource
* bundle
* @return the helper instance bound to the bundle
*/
public static I18NHelper getInstance (String bundleName,
ClassLoader loader) {
I18NHelper helper = (I18NHelper) helpers.get (bundleName);
if (helper != null) {
return helper;
}
helper = new I18NHelper(bundleName, loader);
helpers.put (bundleName, helper);
// if two threads simultaneously create the same helper, return the first
// one to be put into the Hashtable. The other will be garbage collected.
return (I18NHelper) helpers.get (bundleName);
}
/** Message formatter
* @param messageKey the message key
* @return the resolved message text
*/
public String msg (String messageKey) {
assertBundle (messageKey);
return getMessage (bundle, messageKey);
}
/** Message formatter
* @param messageKey the message key
* @param arg1 the first argument
* @return the resolved message text
*/
public String msg (String messageKey, Object arg1) {
assertBundle (messageKey);
return getMessage (bundle, messageKey, arg1);
}
/** Message formatter
* @param messageKey the message key
* @param arg1 the first argument
* @param arg2 the second argument
* @return the resolved message text
*/
public String msg (String messageKey, Object arg1, Object arg2) {
assertBundle (messageKey);
return getMessage (bundle, messageKey, arg1, arg2);
}
/** Message formatter
* @param messageKey the message key
* @param arg1 the first argument
* @param arg2 the second argument
* @param arg3 the third argument
* @return the resolved message text
*/
public String msg (String messageKey, Object arg1, Object arg2, Object arg3) {
assertBundle (messageKey);
return getMessage (bundle, messageKey, arg1, arg2, arg3);
}
/** Message formatter
* @param messageKey the message key
* @param args the array of arguments
* @return the resolved message text
*/
public String msg (String messageKey, Object[] args) {
assertBundle (messageKey);
return getMessage (bundle, messageKey, args);
}
/** Message formatter
* @param messageKey the message key
* @param arg the argument
* @return the resolved message text
*/
public String msg (String messageKey, int arg) {
assertBundle (messageKey);
return getMessage(bundle, messageKey, arg);
}
/** Message formatter
* @param messageKey the message key
* @param arg the argument
* @return the resolved message text
*/
public String msg (String messageKey, boolean arg) {
assertBundle (messageKey);
return getMessage(bundle, messageKey, arg);
}
/** Returns the resource bundle used by this I18NHelper.
* @return the associated resource bundle
* @since 1.1
*/
public ResourceBundle getResourceBundle () {
assertBundle ();
return bundle;
}
//========= Internal helper methods ==========
/**
* Load ResourceBundle by bundle name
* @param bundleName the name of the bundle
* @param loader the class loader from which to load the resource bundle
* @return the ResourceBundle
*/
final private static ResourceBundle loadBundle(
String bundleName, ClassLoader loader) {
ResourceBundle messages = (ResourceBundle)bundles.get(bundleName);
if (messages == null) //not found as loaded - add
{
if (loader != null) {
messages = ResourceBundle.getBundle(bundleName, locale, loader);
} else {
// the JDO library is loaded by the boostrap class loader
messages = ResourceBundle.getBundle(bundleName, locale,
getSystemClassLoaderPrivileged());
}
bundles.put(bundleName, messages);
}
return messages;
}
/** Assert resources available
* @since 1.1
* @throws JDOFatalInternalException if the resource bundle could not
* be loaded during construction.
*/
private void assertBundle () {
if (failure != null)
throw new JDOFatalInternalException (
"No resources could be found for bundle:\"" +
bundle + "\" ", failure);
}
/** Assert resources available
* @param key the message key
* @since 1.0.2
* @throws JDOFatalInternalException if the resource bundle could not
* be loaded during construction.
*/
private void assertBundle (String key) {
if (failure != null)
throw new JDOFatalInternalException (
"No resources could be found to annotate error message key:\"" +
key + "\"", failure);
}
/**
* Returns message as String
* @param messages the resource bundle
* @param messageKey the message key
* @return the resolved message text
*/
final private static String getMessage(ResourceBundle messages, String messageKey)
{
return messages.getString(messageKey);
}
/**
* Formats message by adding array of arguments
* @param messages the resource bundle
* @param messageKey the message key
* @param msgArgs an array of arguments to substitute into the message
* @return the resolved message text
*/
final private static String getMessage(ResourceBundle messages,
String messageKey, Object[] msgArgs)
{
for (int i=0; iObject argument.
* @param messages the resource bundle
* @param messageKey the message key
* @param arg the argument
* @return the resolved message text
*/
final private static String getMessage(ResourceBundle messages,
String messageKey, Object arg)
{
Object []args = {arg};
return getMessage(messages, messageKey, args);
}
/**
* Formats message by adding two Object arguments.
* @param messages the resource bundle
* @param messageKey the message key
* @param arg1 the first argument
* @param arg2 the second argument
* @return the resolved message text
*/
final private static String getMessage(ResourceBundle messages,
String messageKey, Object arg1, Object arg2)
{
Object []args = {arg1, arg2};
return getMessage(messages, messageKey, args);
}
/**
* Formats message by adding three Object arguments.
* @param messages the resource bundle
* @param messageKey the message key
* @param arg1 the first argument
* @param arg2 the second argument
* @param arg3 the third argument
* @return the resolved message text
*/
final private static String getMessage(ResourceBundle messages,
String messageKey, Object arg1, Object arg2, Object arg3)
{
Object []args = {arg1, arg2, arg3};
return getMessage(messages, messageKey, args);
}
/**
* Formats message by adding an int as an argument.
* @param messages the resource bundle
* @param messageKey the message key
* @param arg the argument
* @return the resolved message text
*/
final private static String getMessage(ResourceBundle messages,
String messageKey, int arg)
{
Object []args = {new Integer(arg)};
return getMessage(messages, messageKey, args);
}
/**
* Formats message by adding a boolean as an argument.
* @param messages the resource bundle
* @param messageKey the message key
* @param arg the argument
* @return the resolved message text
*/
final private static String getMessage(ResourceBundle messages,
String messageKey, boolean arg)
{
Object []args = {String.valueOf(arg)};
return getMessage(messages, messageKey, args);
}
/**
* Returns the package portion of the specified class.
* @param className the name of the class from which to extract the
* package
* @return package portion of the specified class
*/
final private static String getPackageName(final String className)
{
final int index = className.lastIndexOf('.');
return ((index != -1) ? className.substring(0, index) : ""); // NOI18N
}
/**
* Get the system class loader. This must be done in a doPrivileged
* block because of security.
*/
private static ClassLoader getSystemClassLoaderPrivileged() {
return AccessController.doPrivileged (
new PrivilegedAction () {
public ClassLoader run () {
return ClassLoader.getSystemClassLoader();
}
}
);
}
}
api/src/java/javax/jdo/spi/JDOImplHelper.java 100664 141715 12500110371 21340 0 ustar mbouschen staff 0 0 /*
* 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.
*/
/*
* JDOImplHelper.java
*
*/
package javax.jdo.spi;
import org.xml.sax.ErrorHandler;
import java.lang.reflect.Constructor;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.text.DateFormat;
import java.text.ParsePosition;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Currency;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Set;
import java.util.WeakHashMap;
import javax.jdo.Constants;
import javax.jdo.JDOException;
import javax.jdo.JDOFatalInternalException;
import javax.jdo.JDOFatalUserException;
import javax.jdo.JDOHelper;
import javax.jdo.JDOUserException;
import javax.xml.parsers.DocumentBuilderFactory;
/** This class is a helper class for JDO implementations. It contains methods
* to register metadata for persistence-capable classes and to perform common
* operations needed by implementations, not by end users.
* JDOImplHelper allows construction of instances of
* persistence-capable classes without using reflection.
*
Persistence-capable classes register themselves via a static method
* at class load time.
* There is no security restriction on this access. JDO implementations
* get access to the functions provided by this class only if they are
* authorized by the security manager. To avoid having every call go through
* the security manager, only the call to get an instance is checked. Once an
* implementation
* has an instance, any of the methods can be invoked without security checks.
* @version 2.1
*
*/
public class JDOImplHelper extends java.lang.Object {
/** This synchronized HashMap contains a static mapping of
* PersistenceCapable class to
* metadata for the class used for constructing new instances. New entries
* are added by the static method in each PersistenceCapable
* class. Entries are never removed.
*/
private static Map registeredClasses =
Collections.synchronizedMap(new HashMap ());
/** This Set contains all classes that have registered for setStateManager
* permissions via authorizeStateManagerClass.
* Only the key is used in order to maintain a weak set of classes.
*/
private static final Map
authorizedStateManagerClasses = new WeakHashMap();
/** This list contains the registered listeners for
* RegisterClassEvents.
*/
private static final List
listeners = new ArrayList();
/** The list of registered StateInterrogation instances
*/
private static List
stateInterrogations = new ArrayList();
/** The singleton JDOImplHelper instance.
*/
private static JDOImplHelper jdoImplHelper = new JDOImplHelper();
/** The Internationalization message helper.
*/
private final static I18NHelper msg =
I18NHelper.getInstance ("javax.jdo.Bundle"); //NOI18N
/** The DateFormat pattern.
*/
private static String dateFormatPattern;
/** The default DateFormat instance.
*/
private static DateFormat dateFormat;
/**
* The DocumentBuilderFactory used during jdoconfig.xml parsing.
*/
private static DocumentBuilderFactory documentBuilderFactory;
/**
* The ErrorHandler used during jdoconfig.xml parsing.
*/
private static ErrorHandler errorHandler;
/**
* JDO standard properties that the user can configure.
*/
public static final Set USER_CONFIGURABLE_STANDARD_PROPERTIES = createUserConfigurableStandardProperties();
private static Set createUserConfigurableStandardProperties() {
Set props = new HashSet();
props.add(Constants.PROPERTY_CONNECTION_DRIVER_NAME);
props.add(Constants.PROPERTY_CONNECTION_FACTORY2_NAME);
props.add(Constants.PROPERTY_CONNECTION_FACTORY_NAME);
props.add(Constants.PROPERTY_CONNECTION_PASSWORD);
props.add(Constants.PROPERTY_CONNECTION_URL);
props.add(Constants.PROPERTY_CONNECTION_USER_NAME);
props.add(Constants.PROPERTY_COPY_ON_ATTACH);
props.add(Constants.PROPERTY_DATASTORE_READ_TIMEOUT_MILLIS);
props.add(Constants.PROPERTY_DATASTORE_WRITE_TIMEOUT_MILLIS);
props.add(Constants.PROPERTY_DETACH_ALL_ON_COMMIT);
props.add(Constants.PROPERTY_IGNORE_CACHE);
props.add(Constants.PROPERTY_INSTANCE_LIFECYCLE_LISTENER);
props.add(Constants.PROPERTY_MAPPING);
props.add(Constants.PROPERTY_MAPPING_CATALOG);
props.add(Constants.PROPERTY_MAPPING_SCHEMA);
props.add(Constants.PROPERTY_MULTITHREADED);
props.add(Constants.PROPERTY_NAME);
props.add(Constants.PROPERTY_NONTRANSACTIONAL_READ);
props.add(Constants.PROPERTY_NONTRANSACTIONAL_WRITE);
props.add(Constants.PROPERTY_OPTIMISTIC);
props.add(Constants.PROPERTY_PERSISTENCE_MANAGER_FACTORY_CLASS);
props.add(Constants.PROPERTY_PERSISTENCE_UNIT_NAME);
props.add(Constants.PROPERTY_READONLY);
props.add(Constants.PROPERTY_RESTORE_VALUES);
props.add(Constants.PROPERTY_RETAIN_VALUES);
props.add(Constants.PROPERTY_SERVER_TIME_ZONE_ID);
props.add(Constants.PROPERTY_SPI_RESOURCE_NAME);
props.add(Constants.PROPERTY_TRANSACTION_ISOLATION_LEVEL);
props.add(Constants.PROPERTY_TRANSACTION_TYPE);
return Collections.unmodifiableSet(props);
}
static final String JAVAX_JDO_PREFIX_LOWER_CASED =
Constants.JAVAX_JDO_PREFIX.toLowerCase();
static final String PROPERTY_PREFIX_INSTANCE_LIFECYCLE_LISTENER_LOWER_CASED =
Constants.PROPERTY_PREFIX_INSTANCE_LIFECYCLE_LISTENER.toLowerCase();
static final Set USER_CONFIGURABLE_STANDARD_PROPERTIES_LOWER_CASED =
createUserConfigurableStandardPropertiesLowerCased();
static Set createUserConfigurableStandardPropertiesLowerCased() {
Set mixedCased = createUserConfigurableStandardProperties();
Set lowerCased =
new HashSet(mixedCased.size());
for (String propertyName : mixedCased) {
lowerCased.add(propertyName.toLowerCase());
}
return Collections.unmodifiableSet(lowerCased);
}
/** Register the default DateFormat instance.
*/
static {
jdoImplHelper.registerDateFormat(getDateTimeInstance());
}
/** Creates new JDOImplHelper */
private JDOImplHelper() {
}
/** Get an instance of JDOImplHelper. This method
* checks that the caller is authorized for
* JDOPermission("getMetadata"), and if not, throws
* SecurityException.
* @return an instance of JDOImplHelper.
* @throws SecurityException if the caller is not authorized for
* JDOPermission("getMetadata").
*/
public static JDOImplHelper getInstance()
throws SecurityException {
SecurityManager sec = System.getSecurityManager();
if (sec != null) {
// throws exception if caller is not authorized
sec.checkPermission (JDOPermission.GET_METADATA);
}
return jdoImplHelper;
}
/** Get the field names for a PersistenceCapable class. The
* order of fields is the natural ordering of the String class
* (without considering localization).
* @param pcClass the PersistenceCapable class.
* @return the field names for the class.
*/
public String[] getFieldNames (Class pcClass) {
Meta meta = getMeta (pcClass);
return meta.getFieldNames();
}
/** Get the field types for a PersistenceCapable class. The
* order of fields is the same as for field names.
* @param pcClass the PersistenceCapable class.
* @return the field types for the class.
*/
public Class[] getFieldTypes (Class pcClass) {
Meta meta = getMeta (pcClass);
return meta.getFieldTypes();
}
/** Get the field flags for a PersistenceCapable class. The
* order of fields is the same as for field names.
* @param pcClass the PersistenceCapable class.
* @return the field types for the class.
*/
public byte[] getFieldFlags (Class pcClass) {
Meta meta = getMeta (pcClass);
return meta.getFieldFlags();
}
/** Get the persistence-capable superclass for a
* PersistenceCapable class.
* @param pcClass the PersistenceCapable class.
* @return The PersistenceCapable superclass for this class,
* or null if there isn't one.
*/
public Class getPersistenceCapableSuperclass (Class pcClass) {
Meta meta = getMeta (pcClass);
return meta.getPersistenceCapableSuperclass();
}
/** Create a new instance of the class and assign its
* jdoStateManager. The new instance has its
* jdoFlags set to LOAD_REQUIRED.
* @see PersistenceCapable#jdoNewInstance(StateManager sm)
* @param pcClass the PersistenceCapable class.
* @param sm the StateManager which will own the new instance.
* @return the new instance, or null if the class is not
* registered.
*/
public PersistenceCapable newInstance (Class pcClass, StateManager sm) {
Meta meta = getMeta (pcClass);
PersistenceCapable pcInstance = meta.getPC();
return pcInstance == null?null:pcInstance.jdoNewInstance(sm);
}
/** Create a new instance of the class and assign its
* jdoStateManager and key values from the ObjectId. If the
* oid parameter is null, no key values are copied.
* The new instance has its jdoFlags set to
* LOAD_REQUIRED.
* @see PersistenceCapable#jdoNewInstance(StateManager sm, Object oid)
* @param pcClass the PersistenceCapable class.
* @param sm the StateManager which will own the new instance.
* @return the new instance, or null if the class is not
* registered.
* @param oid the ObjectId instance from which to copy key field values.
*/
public PersistenceCapable newInstance
(Class pcClass, StateManager sm, Object oid) {
Meta meta = getMeta (pcClass);
PersistenceCapable pcInstance = meta.getPC();
return pcInstance == null?null:pcInstance.jdoNewInstance(sm, oid);
}
/** Create a new instance of the ObjectId class of this
* PersistenceCapable class.
* It is intended only for application identity. This method should
* not be called for classes that use single field identity;
* newObjectIdInstance(Class, Object) should be used instead.
* If the class has been
* enhanced for datastore identity, or if the class is abstract,
* null is returned.
* @param pcClass the PersistenceCapable class.
* @return the new ObjectId instance, or null if the class
* is not registered.
*/
public Object newObjectIdInstance (Class pcClass) {
Meta meta = getMeta (pcClass);
PersistenceCapable pcInstance = meta.getPC();
return pcInstance == null?null:pcInstance.jdoNewObjectIdInstance();
}
/** Create a new instance of the class used by the parameter Class
* for JDO identity, using the
* key constructor of the object id class. It is intended for single
* field identity. The identity
* instance returned has no relationship with the values of the primary key
* fields of the persistence-capable instance on which the method is called.
* If the key is the wrong class for the object id class, null is returned.
* For classes that use single field identity, if the parameter is
* of one of the following types, the behavior must be as specified:
*
Number or Character: the
* parameter must be the single field
* type or the wrapper class of the primitive field type; the parameter
* is passed to the single field identity constructor
* ObjectIdFieldSupplier: the field value
* is fetched from the ObjectIdFieldSupplier and passed to the
* single field identity constructor
* String: the String is passed to the
* single field identity constructor
* null
* if the class is not registered.
* @param obj the Object form of the object id
* @param pcClass the PersistenceCapable class.
* @since 2.0
*/
public Object newObjectIdInstance (Class pcClass, Object obj) {
Meta meta = getMeta (pcClass);
PersistenceCapable pcInstance = meta.getPC();
return (pcInstance == null)?null:pcInstance.jdoNewObjectIdInstance(obj);
}
/** Copy fields from an outside source to the key fields in the ObjectId.
* This method is generated in the PersistenceCapable class to
* generate a call to the field manager for each key field in the ObjectId.
* For example, an ObjectId class that has three key fields
* (int id, String name, and
* Float salary) would have the method generated:
*
* void jdoCopyKeyFieldsToObjectId (Object oid, ObjectIdFieldSupplier fm) {
*
*
The implementation is responsible for implementing the
* ObjectIdFieldSupplier to provide the values for the key
* fields.
* @param pcClass the PersistenceCapable Class.
* @param oid the ObjectId target of the copy.
* @param fm the field manager that supplies the field values.
*/
public void copyKeyFieldsToObjectId
(Class pcClass, PersistenceCapable.ObjectIdFieldSupplier fm, Object oid) {
Meta meta = getMeta (pcClass);
PersistenceCapable pcInstance = meta.getPC();
if (pcInstance == null) {
throw new JDOFatalInternalException (msg.msg(
"ERR_AbstractClassNoIdentity", pcClass.getName())); //NOI18N
}
pcInstance.jdoCopyKeyFieldsToObjectId(fm, oid);
}
/** Copy fields to an outside source from the key fields in the ObjectId.
* This method is generated in the PersistenceCapable class to
* generate a call to the field manager for each key field in the ObjectId.
* For example, an ObjectId class that has three key fields
* (int id, String name, and
* Float salary) would have the method generated:
*
void jdoCopyKeyFieldsFromObjectId
*
*
The implementation is responsible for implementing the
* ObjectIdFieldConsumer to store the values for the key
* fields.
* @param pcClass the PersistenceCapable class
* @param oid the ObjectId source of the copy.
* @param fm the field manager that receives the field values.
*/
public void copyKeyFieldsFromObjectId
(Class pcClass, PersistenceCapable.ObjectIdFieldConsumer fm, Object oid) {
Meta meta = getMeta (pcClass);
PersistenceCapable pcInstance = meta.getPC();
if (pcInstance == null) {
throw new JDOFatalInternalException (msg.msg(
"ERR_AbstractClassNoIdentity", pcClass.getName())); //NOI18N
}
pcInstance.jdoCopyKeyFieldsFromObjectId(fm, oid);
}
/** Register metadata by class. The registration will be done in the
* class named JDOImplHelper loaded by the same or an
* ancestor class loader as the PersistenceCapable class
* performing the registration.
*
* @param pcClass the PersistenceCapable class
* used as the key for lookup.
* @param fieldNames an array of String field names for
* persistent and transactional fields
* @param fieldTypes an array of Class field types
* @param fieldFlags the Field Flags for persistent and transactional fields
* @param pc an instance of the PersistenceCapable class
* @param persistenceCapableSuperclass the most immediate superclass that is
* PersistenceCapable
*/
public static void registerClass (Class pcClass,
String[] fieldNames, Class[] fieldTypes,
byte[] fieldFlags, Class persistenceCapableSuperclass,
PersistenceCapable pc) {
if (pcClass == null)
throw new NullPointerException(msg.msg("ERR_NullClass")); //NOI18N
Meta meta = new Meta (fieldNames, fieldTypes,
fieldFlags, persistenceCapableSuperclass, pc);
registeredClasses.put (pcClass, meta);
// handle class registration listeners
synchronized (listeners) {
if (!listeners.isEmpty()) {
RegisterClassEvent event = new RegisterClassEvent(
jdoImplHelper, pcClass, fieldNames, fieldTypes,
fieldFlags, persistenceCapableSuperclass);
for (Iterator i = listeners.iterator(); i.hasNext();) {
RegisterClassListener crl =
(RegisterClassListener)i.next();
if (crl != null) {
crl.registerClass(event);
}
}
}
}
}
/**
* Unregister metadata by class loader. This method unregisters all
* registered PersistenceCapable classes loaded by the
* specified class loader. Any attempt to get metadata for unregistered
* classes will result in a JDOFatalUserException.
* @param cl the class loader.
* @since 1.0.2
*/
public void unregisterClasses (ClassLoader cl)
{
SecurityManager sec = System.getSecurityManager();
if (sec != null) {
// throws exception if caller is not authorized
sec.checkPermission (JDOPermission.MANAGE_METADATA);
}
synchronized(registeredClasses) {
for (Iterator i = registeredClasses.keySet().iterator();
i.hasNext();) {
Class pcClass = (Class)i.next();
// Note, the pc class was registered by calling the static
// method JDOImplHelper.registerClass. This means the
// JDOImplHelper class loader is the same as or an ancestor
// of the class loader of the pc class. In this case method
// getClassLoader does not perform a security check for
// RuntimePermission("getClassLoader") and thus we do not
// need a privileged block for the getClassLoader call.
if ((pcClass != null) && (pcClass.getClassLoader() == cl)) {
// unregister pc class, if its class loader is the
// specified one.
i.remove();
}
}
}
}
/**
* Unregister metadata by class. This method unregisters the specified
* class. Any further attempt to get metadata for the specified class will
* result in a JDOFatalUserException.
* @param pcClass the PersistenceCapable class to be
* unregistered.
* @since 1.0.2
*/
public void unregisterClass (Class pcClass)
{
if (pcClass == null)
throw new NullPointerException(msg.msg("ERR_NullClass")); //NOI18N
SecurityManager sec = System.getSecurityManager();
if (sec != null) {
// throws exception if caller is not authorized
sec.checkPermission (JDOPermission.MANAGE_METADATA);
}
registeredClasses.remove(pcClass);
}
/**
* Add the specified RegisterClassListener to the listener
* list.
* @param crl the listener to be added
*/
public void addRegisterClassListener (RegisterClassListener crl) {
HashSet alreadyRegisteredClasses = null;
synchronized (listeners) {
listeners.add(crl);
// Make a copy of the existing set of registered classes.
// Between these two lines of code, any number of new class
// registrations might occur, and will then all wait until this
// synchronized block completes. Some of the class registrations
// might be delivered twice to the newly registered listener.
alreadyRegisteredClasses = new HashSet (registeredClasses.keySet());
}
// new registrations will call the new listener while the following
// occurs notify the new listener about already-registered classes
for (Iterator it = alreadyRegisteredClasses.iterator(); it.hasNext();) {
Class pcClass = (Class)it.next();
Meta meta = getMeta (pcClass);
RegisterClassEvent event = new RegisterClassEvent(
this, pcClass, meta.getFieldNames(), meta.getFieldTypes(),
meta.getFieldFlags(), meta.getPersistenceCapableSuperclass());
crl.registerClass (event);
}
}
/**
* Remove the specified RegisterClassListener from the listener
* list.
* @param crl the listener to be removed
*/
public void removeRegisterClassListener (RegisterClassListener crl) {
synchronized (listeners) {
listeners.remove(crl);
}
}
/**
* Returns a collection of class objects of the registered
* persistence-capable classes.
* @return registered persistence-capable classes
*/
public Collection getRegisteredClasses() {
return Collections.unmodifiableCollection(registeredClasses.keySet());
}
/** Look up the metadata for a PersistenceCapable class.
* @param pcClass the Class.
* @return the Meta for the Class.
*/
private static Meta getMeta (Class pcClass) {
Meta ret = (Meta) registeredClasses.get (pcClass);
if (ret == null) {
throw new JDOFatalUserException(
msg.msg ("ERR_NoMetadata", pcClass.getName())); //NOI18N
}
return ret;
}
/** Register a class authorized to replaceStateManager. The caller of
* this method must be authorized for JDOPermission("setStateManager").
* During replaceStateManager, a persistence-capable class will call
* the corresponding checkAuthorizedStateManager and the class of the
* instance of the parameter must have been registered.
* @param smClass a Class that is authorized for
* JDOPermission("setStateManager").
* @throws SecurityException if the caller is not authorized for
* JDOPermission("setStateManager").
* @since 1.0.1
*/
public static void registerAuthorizedStateManagerClass (Class smClass)
throws SecurityException {
if (smClass == null)
throw new NullPointerException(msg.msg("ERR_NullClass")); //NOI18N
SecurityManager sm = System.getSecurityManager();
if (sm != null) {
sm.checkPermission(JDOPermission.SET_STATE_MANAGER);
}
synchronized (authorizedStateManagerClasses) {
authorizedStateManagerClasses.put(smClass, null);
}
}
/** Register classes authorized to replaceStateManager. The caller of
* this method must be authorized for JDOPermission("setStateManager").
* During replaceStateManager, a persistence-capable class will call
* the corresponding checkAuthorizedStateManager and the class of the
* instance of the parameter must have been registered.
* @param smClasses a Collection of Classes that are authorized for
* JDOPermission("setStateManager").
* @throws SecurityException if the caller is not authorized for
* JDOPermission("setStateManager").
* @since 1.0.1
*/
public static void registerAuthorizedStateManagerClasses (
Collection smClasses) throws SecurityException {
SecurityManager sm = System.getSecurityManager();
if (sm != null) {
sm.checkPermission(JDOPermission.SET_STATE_MANAGER);
synchronized (authorizedStateManagerClasses) {
for (Iterator it = smClasses.iterator(); it.hasNext();) {
Object smClass = it.next();
if (!(smClass instanceof Class)) {
throw new ClassCastException(
msg.msg("ERR_StateManagerClassCast", //NOI18N
smClass.getClass().getName()));
}
registerAuthorizedStateManagerClass((Class)it.next());
}
}
}
}
/**
* Register a DocumentBuilderFactory instance for use in parsing the
* resource(s) META-INF/jdoconfig.xml. The default is governed by the
* semantics of DocumentBuilderFactory.newInstance().
*
* @param factory the DocumentBuilderFactory instance to use
* @since 2.1
*/
public synchronized void registerDocumentBuilderFactory(
DocumentBuilderFactory factory) {
documentBuilderFactory = factory;
}
/**
* Return the registered instance of DocumentBuilderFactory.
* @return the DocumentBuilderFactory if registered; null otherwise
* @since 2.1
*/
public static DocumentBuilderFactory getRegisteredDocumentBuilderFactory() {
return documentBuilderFactory;
}
/**
* Register an ErrorHandler instance for use in parsing the
* resource(s) META-INF/jdoconfig.xml. The default is an ErrorHandler
* that throws on error or fatalError and ignores warnings.
*
* @param handler the ErrorHandler instance to use
* @since 2.1
*/
public synchronized void registerErrorHandler(ErrorHandler handler) {
errorHandler = handler;
}
/**
* Return the registered instance of ErrorHandler.
* @return the registered ErrorHandler if registered; null otherwise
* @since 2.1
*/
public static ErrorHandler getRegisteredErrorHandler() {
return errorHandler;
}
/** Check that the parameter instance is of a class that is authorized for
* JDOPermission("setStateManager"). This method is called by the
* replaceStateManager method in persistence-capable classes.
* A class that is passed as the parameter to replaceStateManager must be
* authorized for JDOPermission("setStateManager"). To improve performance,
* first the set of authorized classes is checked, and if not present, a
* regular permission check is made. The regular permission check requires
* that all callers on the stack, including the persistence-capable class
* itself, must be authorized for JDOPermission("setStateManager").
* @param sm an instance of StateManager whose class is to be checked.
* @since 1.0.1
*/
public static void checkAuthorizedStateManager (StateManager sm) {
checkAuthorizedStateManagerClass(sm.getClass());
}
/** Check that the parameter instance is a class that is authorized for
* JDOPermission("setStateManager"). This method is called by the
* constructors of JDO Reference Implementation classes.
* @param smClass a Class to be checked for JDOPermission("setStateManager")
* @since 1.0.1
*/
public static void checkAuthorizedStateManagerClass (Class smClass) {
final SecurityManager scm = System.getSecurityManager();
if (scm == null) {
// if no security manager, no checking.
return;
}
synchronized(authorizedStateManagerClasses) {
if (authorizedStateManagerClasses.containsKey(smClass)) {
return;
}
}
// if not already authorized, perform "long" security checking.
scm.checkPermission(JDOPermission.SET_STATE_MANAGER);
}
/**
* Construct an instance of a key class using a String as input.
* This is a helper interface for use with ObjectIdentity.
* Classes without a String constructor (such as those in java.lang
* and java.util) will use this interface for constructing new instances.
* The result might be a singleton or use some other strategy.
*/
public interface StringConstructor {
/**
* Construct an instance of the class for which this instance
* is registered.
* @param s the parameter for construction
* @return the constructed object
*/
public Object construct(String s);
}
/**
* Special StringConstructor instances for use with specific
* classes that have no public String constructor. The Map is
* keyed on class instance and the value is an instance of
* StringConstructor.
*/
static final Map stringConstructorMap =
new HashMap();
/**
*
* Register special StringConstructor instances. These instances
* are for constructing instances from String parameters where there
* is no String constructor for them.
* @param cls the class to register a StringConstructor for
* @param sc the StringConstructor instance
* @return the previous StringConstructor registered for this class
*/
public Object registerStringConstructor(Class cls, StringConstructor sc) {
synchronized(stringConstructorMap) {
return stringConstructorMap.put(cls, sc);
}
}
/** Register the default special StringConstructor instances.
*/
static {
if (isClassLoadable("java.util.Currency")) {
jdoImplHelper.registerStringConstructor(
Currency.class, new StringConstructor() {
public Object construct(String s) {
try {
return Currency.getInstance(s);
} catch (IllegalArgumentException ex) {
throw new javax.jdo.JDOUserException(msg.msg(
"EXC_CurrencyStringConstructorIllegalArgument", //NOI18N
s), ex);
} catch (Exception ex) {
throw new JDOUserException(msg.msg(
"EXC_CurrencyStringConstructorException"), //NOI18N
ex);
}
}
});
}
jdoImplHelper.registerStringConstructor(Locale.class, new StringConstructor() {
public Object construct(String s) {
try {
return getLocale(s);
} catch (Exception ex) {
throw new JDOUserException(msg.msg(
"EXC_LocaleStringConstructorException"), ex); //NOI18N
}
}
});
jdoImplHelper.registerStringConstructor(Date.class, new StringConstructor() {
public synchronized Object construct(String s) {
try {
// first, try the String as a Long
return new Date(Long.parseLong(s));
} catch (NumberFormatException ex) {
// not a Long; try the formatted date
ParsePosition pp = new ParsePosition(0);
Date result = dateFormat.parse(s, pp);
if (result == null) {
throw new JDOUserException (msg.msg(
"EXC_DateStringConstructor", new Object[] //NOI18N
{s, new Integer(pp.getErrorIndex()),
dateFormatPattern}));
}
return result;
}
}
});
}
/**
* Parse the String to a Locale.
* @param s the name of the Locale
* @return the Locale corresponding to the name
*/
private static Locale getLocale(String s) {
String lang = s;
int firstUnderbar = s.indexOf('_');
if (firstUnderbar == -1) {
// nothing but language
return new Locale(lang);
}
lang = s.substring(0, firstUnderbar);
String country;
int secondUnderbar = s.indexOf('_', firstUnderbar + 1);
if (secondUnderbar == -1) {
// nothing but language, country
country = s.substring(firstUnderbar + 1);
return new Locale(lang, country);
}
country = s.substring(firstUnderbar + 1, secondUnderbar);
String variant = s.substring(secondUnderbar + 1);
return new Locale(lang, country, variant);
}
/**
* Determine if a class is loadable in the current environment.
* @param className the fully-qualified name of the class
* @return true if the class can be loaded; false otherwise
*/
private static boolean isClassLoadable(String className) {
try {
Class.forName(className);
return true;
} catch (ClassNotFoundException ex) {
return false;
}
}
/**
* Construct an instance of the parameter class, using the keyString
* as an argument to the constructor. If the class has a StringConstructor
* instance registered, use it. If not, try to find a constructor for
* the class with a single String argument. Otherwise, throw a
* JDOUserException.
* @param className the name of the class
* @param keyString the String parameter for the constructor
* @return the result of construction
*/
public static Object construct(String className, String keyString) {
StringConstructor stringConstructor;
try {
Class keyClass = Class.forName(className);
synchronized(stringConstructorMap) {
stringConstructor =
(StringConstructor) stringConstructorMap.get(keyClass);
}
if (stringConstructor != null) {
return stringConstructor.construct(keyString);
} else {
Constructor keyConstructor =
keyClass.getConstructor(new Class[]{String.class});
return keyConstructor.newInstance(new Object[]{keyString});
}
} catch (JDOException ex) {
throw ex;
} catch (Exception ex) {
/* ClassNotFoundException,
NoSuchMethodException,
InstantiationException,
IllegalAccessException,
InvocationTargetException */
throw new JDOUserException(
msg.msg("EXC_ObjectIdentityStringConstruction", //NOI18N
new Object[] {ex.toString(), className, keyString}), ex);
}
}
/**
* Get the DateFormat instance for the default locale from the VM.
* This requires the following privileges for JDOImplHelper in the
* security permissions file:
* permission java.util.PropertyPermission "user.country", "read";
* permission java.util.PropertyPermission "user.timezone", "read,write";
* permission java.util.PropertyPermission "java.home", "read";
* If these permissions are not present, or there is some other
* problem getting the default date format, a simple formatter is returned.
* @since 2.1
* @return the default date-time formatter
*/
static DateFormat getDateTimeInstance() {
DateFormat result = null;
try {
result = AccessController.doPrivileged (
new PrivilegedAction () {
public DateFormat run () {
return DateFormat.getDateTimeInstance();
}
}
);
} catch (Exception ex) {
result = DateFormat.getInstance();
}
return result;
}
/**
* Register a DateFormat instance for use with constructing Date
* instances. The default is the default DateFormat instance.
* If the new instance implements SimpleDateFormat, get its pattern
* for error messages.
* @since 2.0
* @param df the DateFormat instance to use
*/
public synchronized void registerDateFormat(DateFormat df) {
dateFormat = df;
if (df instanceof SimpleDateFormat) {
dateFormatPattern = ((SimpleDateFormat)df).toPattern();
} else {
dateFormatPattern = msg.msg("MSG_unknown"); //NOI18N
}
}
/** This is a helper class to manage metadata per persistence-capable
* class. The information is used at runtime to provide field names and
* field types to the JDO Model.
*
* This is the value of the HashMap which
* relates the PersistenceCapable Class
* as a key to the metadata.
*/
static class Meta {
/** Construct an instance of Meta.
* @param fieldNames An array of String
* @param fieldTypes An array of Class
* @param fieldFlags an array of int
* @param persistenceCapableSuperclass the most immediate
* PersistenceCapable superclass
* @param pc An instance of the PersistenceCapable class
*/
Meta (String[] fieldNames, Class[] fieldTypes, byte[] fieldFlags,
Class persistenceCapableSuperclass, PersistenceCapable pc) {
this.fieldNames = fieldNames;
this.fieldTypes = fieldTypes;
this.fieldFlags = fieldFlags;
this.persistenceCapableSuperclass = persistenceCapableSuperclass;
this.pc = pc;
}
/** This is an array of field names used
* for the Model at runtime. The field
* is passed by the static class initialization.
*/
String[] fieldNames;
/** Get the field names from the metadata.
* @return the array of field names.
*/
String[] getFieldNames() {
return fieldNames;
}
/** This is an array of field types used
* for the Model at runtime. The field
* is passed by the static class initialization.
*/
Class[] fieldTypes;
/** Get the field types from the metadata.
* @return the array of field types.
*/
Class[] getFieldTypes() {
return fieldTypes;
}
/** This is an array of field flags used
* for the Model at runtime. The field
* is passed by the static class initialization.
*/
byte[] fieldFlags;
/** Get the field types from the metadata.
* @return the array of field types.
*/
byte[] getFieldFlags() {
return fieldFlags;
}
/** This is the Class instance of the
* PersistenceCapable superclass.
*/
Class persistenceCapableSuperclass;
/** Return the PersistenceCapable superclass.
* @return the PersistenceCapable superclass
*/
Class getPersistenceCapableSuperclass() {
return persistenceCapableSuperclass;
}
/** This is an instance of PersistenceCapable,
* used at runtime to create new instances.
*/
PersistenceCapable pc;
/** Get an instance of the PersistenceCapable class.
* @return an instance of the PersistenceCapable Class.
*/
PersistenceCapable getPC() {
return pc;
}
/** Return the string form of the metadata.
* @return the string form
*/
public String toString() {
return "Meta-" + pc.getClass().getName(); //NOI18N
}
}
/**
* Add a StateInterrogation to the list. Create a new list
* in case there is an iterator open on the original list.
* @param si the StateInterrogation to add
*/
public synchronized void addStateInterrogation(StateInterrogation si) {
List newList =
new ArrayList(stateInterrogations);
newList.add(si);
stateInterrogations = newList;
}
/**
* Remove a StateInterrogation from the list. Create a new list
* in case there is an iterator open on the original list.
* @param si the StateInterrogation to remove
*/
public synchronized void removeStateInterrogation(StateInterrogation si) {
List newList =
new ArrayList(stateInterrogations);
newList.remove(si);
stateInterrogations = newList;
}
/**
* Return an Iterator over all StateInterrogation instances.
* Synchronize to avoid add/remove/iterate conflicts.
* @return an Iterator over all StateInterrogation instances.
*/
private synchronized Iterator getStateInterrogationIterator() {
return stateInterrogations.iterator();
}
/**
* Mark a non-binary-compatible instance dirty. Delegate to all
* registered StateInterrogation instances until one of them
* handles the call.
* @param pc the instance to mark dirty
* @param fieldName the field to mark dirty
*/
public void nonBinaryCompatibleMakeDirty(Object pc, String fieldName) {
Iterator sit = getStateInterrogationIterator();
while (sit.hasNext()) {
StateInterrogation si = (StateInterrogation)sit.next();
try {
if (si.makeDirty(pc, fieldName)) return;
} catch (Throwable t) {
continue; // ignore exceptions from errant StateInterrogations
}
}
}
/**
* Determine the state of a non-binary-compatible instance.
* Delegate to all registered StateInterrogation instances until
* one of them handles the call (returns a non-null Boolean
* with the answer).
* The caller provides the stateless "method object" that does
* the actual call to the StateInterrogation instance.
* @param pc the instance to be checked
* @param sibr the method object that delegates to the
* non-binary-compatible implementation
* @return Boolean.TRUE if the instance satisfies the state interrogation;
* Boolean.FALSE if the instance does not satisfy the interrogation;
* or null if the implementation does not manage the class of the instance
*/
public boolean nonBinaryCompatibleIs(Object pc,
StateInterrogationBooleanReturn sibr) {
Iterator sit = getStateInterrogationIterator();
while (sit.hasNext()) {
StateInterrogation si = (StateInterrogation)sit.next();
Boolean result;
try {
result = sibr.is(pc, si);
} catch (Throwable t) {
continue; // ignore exceptions from errant StateInterrogations
}
if (result != null) return result.booleanValue();
}
return false;
}
/**
* Return an object associated with a non-binary-compatible instance.
* Delegate to all registered StateInterrogation instances until
* one of them handles the call (returns a non-null answer).
* The caller provides the stateless "method object" that does
* the actual call to the StateInterrogation instance.
* @param pc the instance whose associated object is needed
* @param sibr the method object that delegates to the
* non-binary-compatible implementation
* @return the associated object or null if the implementation does not
* manage the class of the instance
*/
public Object nonBinaryCompatibleGet(Object pc,
StateInterrogationObjectReturn sibr) {
Iterator sit = getStateInterrogationIterator();
while (sit.hasNext()) {
StateInterrogation si = (StateInterrogation)sit.next();
Object result;
try {
result = sibr.get(pc, si);
} catch (Throwable t) {
continue; // ignore exceptions from errant StateInterrogations
}
if (result != null) return result;
}
return null;
}
/** This is an interface used to interrogate the state of an instance
* that does not implement PersistenceCapable. It is used for the
* methods that return a boolean value.
*/
public static interface StateInterrogationBooleanReturn {
/**
* Interrogate the state of the instance
* @param pc the instance
* @param si the method object
* @return the state of the instance or null
*/
public Boolean is(Object pc, StateInterrogation si);
}
/** This is an interface used to interrogate the state of an instance
* that does not implement PersistenceCapable. It is used for the
* methods that return an Object value.
*/
public static interface StateInterrogationObjectReturn {
/**
* Return the associated instance.
* @param pc the instance
* @param si the method object
* @return the associated object or null
*/
public Object get(Object pc, StateInterrogation si);
}
/**
* Examines the given map for keys beginning with the JDO standard prefix,
* {@link Constants#JAVAX_JDO_PREFIX}. If any property keys are found with
* that prefix but are unknown to this version of the JDO standard, a
* JDOUserException is thrown with a message indicating the unknown
* property. Keys that are not strings are ignored, as are string keys
* beginning with
* {@link Constants#PROPERTY_PREFIX_INSTANCE_LIFECYCLE_LISTENER} or not
* beginning with {@link Constants#JAVAX_JDO_PREFIX}.
*
* @param properties
* The properties to examine.
*
* @see Constants#JAVAX_JDO_PREFIX
* @see JDOHelper#USER_CONFIGURABLE_STANDARD_PROPERTIES
* @since 3.1
*/
public static void assertOnlyKnownStandardProperties(Map properties) {
if (properties == null || properties.isEmpty())
return;
List exceptions = new ArrayList();
StringBuilder unknowns = new StringBuilder();
for (Object key : properties.keySet()) {
if (!(key instanceof String)) {
continue; // ignore keys not of type string
}
String s = ((String) key).toLowerCase(); // compare case-insensitively
if (!s.startsWith(JAVAX_JDO_PREFIX_LOWER_CASED)) {
continue; // ignore vendor-specific keys
}
if (s.startsWith(PROPERTY_PREFIX_INSTANCE_LIFECYCLE_LISTENER_LOWER_CASED)) {
continue; // ignore listener class names
}
if (!USER_CONFIGURABLE_STANDARD_PROPERTIES_LOWER_CASED.contains(s)) {
exceptions.add(new JDOUserException(msg.msg(
"EXC_UnknownStandardProperty", s)));
if (exceptions.size() > 1) {
unknowns.append(",");
}
unknowns.append(s);
}
}
if (exceptions.size() == 1) {
throw exceptions.get(0);
} else if (exceptions.size() > 1) {
throw new JDOUserException(msg.msg("EXC_UnknownStandardProperties",
unknowns.toString()),
exceptions.toArray(new JDOUserException[] {}));
}
}
}
api/src/java/javax/jdo/spi/JDOPermission.java 100664 12164 12500110371 21402 0 ustar mbouschen staff 0 0 /*
* 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 javax.jdo.spi;
/**
* The JDOPermission class is for operations that are reserved for
* JDO implementations and should not be called by other code. A
* JDOPermission is a named permission and has no
* actions. There are two names currently defined. Each named permission
* has a corresponding public static final field which contains an instance
* of the named permission.
*
* The following table
* provides a summary description of what each named permission allows,
* and discusses the risks of granting code the permission.
*
*
*
*
* Permission Target Name
* What the Permission Allows
* Risks of Allowing this Permission
*
*
*
* setStateManagerThis allows setting the StateManager for an instance of
* PersistenceCapable. The StateManager
* has unlimited access to get and set persistent and transactional fields of
* the PersistenceCapable instance.
* This is dangerous in that information (possibly confidential)
* normally unavailable would be accessible to malicious code.
*
*
*
* getMetadataThis allows getting metadata for any PersistenceCapable
* class that has registered with JDOImplHelper.
* This is dangerous in that metadata information (possibly confidential)
* normally unavailable would be accessible to malicious code.
*
*
*
* manageMetadataThis allows managing metadata for any PersistenceCapable
* class that has registered with JDOImplHelper.
* This is dangerous in that metadata information (possibly confidential)
* normally unavailable would be manageable (modifiable) by malicious code.
*
*
*
*
* closePersistenceManagerFactoryThis allows closing a PersistenceManagerFactory,
* thereby releasing resources.
* This is dangerous in that resources bound to the
* PersistenceManagerFactory would be releaseable by
* malicious code.
*
*
*
*
* @see java.security.Permission
* @see java.security.BasicPermission
* @see javax.jdo.spi.JDOImplHelper
* @see javax.jdo.spi.PersistenceCapable
* @version 1.0.2
*/
public final
class JDOPermission extends java.security.BasicPermission {
/**
* Constructs a JDOPermission with the specified name.
*
* @param name the name of the JDOPermission
*/
public JDOPermission(String name) {
super(name);
}
/**
* Constructs a JDOPermission with the specified name and
* actions. The actions should be null; they are ignored.
* This constructor exists for use by the Policy object
* to instantiate new Permission objects.
*
* @param name the name of the JDOPermission
* @param actions should be null.
*/
public JDOPermission(String name, String actions) {
super(name, actions);
}
/** An instance of JDOPermission to be used for
* getMetadata permission checking.
*/
public final static JDOPermission GET_METADATA =
new JDOPermission("getMetadata"); // NOI18N
/** An instance of JDOPermission to be used for
* manageMetadata permission checking.
* @since 1.0.2
*/
public final static JDOPermission MANAGE_METADATA =
new JDOPermission("manageMetadata"); // NOI18N
/** An instance of JDOPermission to be used for
* setStateManager permission checking.
*/
public final static JDOPermission SET_STATE_MANAGER =
new JDOPermission("setStateManager"); // NOI18N
/** An instance of JDOPermission to be used for
* closePersistenceManagerFactory permission checking.
* @since 1.0.1
*/
public final static JDOPermission CLOSE_PERSISTENCE_MANAGER_FACTORY =
new JDOPermission("closePersistenceManagerFactory"); // NOI18N
}
api/src/java/javax/jdo/spi/package.html 100664 4443 12500110371 20314 0 ustar mbouschen staff 0 0
JDO Service Provider Interface package
This package contains the interfaces and classes used by JDO implementations.
JDO defines interfaces and classes to be used by application programmers
when using classes whose instances are to be stored in persistent storage
(persistence-capable classes), and specifies the contracts between
suppliers of persistence-capable classes and the
runtime environment (which is part of the JDO implementation).
The PersistenceCapable interface is implemented by all classes
whose instances are to be made persistent. The implementation might be
done by a combination of techniques, as determined by the JDO vendor:
Pre-processing .java files
Post-processing .class files
Generating .java or .class files directly from an abstraction
The StateManager interface is the implementation's contact point with
the PersistenceCapable instances. It defines methods that are called by
the PersistenceCapable instances to implement the required PersistenceCapable
behavior for persistent and transactional instances.
The JDOPermission class is used to manage security controls on JDO implementations.
The RegisterClassEvent class and RegisterClassListener interface are used
by JDO implementations that need access to metadata of PersistenceCapable classes.
The JDOImplHelper class contains helper methods for JDO implementations.
api/src/java/javax/jdo/spi/PersistenceCapable.java 100664 64620 12500110371 22455 0 ustar mbouschen staff 0 0 /*
* 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 javax.jdo.spi;
import javax.jdo.PersistenceManager;
/**
* A class that can be managed by a binary-compatible JDO implementation
* must implement this interface.
*
*
This interface defines methods that allow the implementation to manage
* the instances. It also defines methods that allow a JDO aware
* application to examine the runtime state of instances. For example,
* an application can discover whether the instance is persistent, transactional,
* dirty, new, deleted, or detached; and to get its associated
* PersistenceManager, object identity, and version if it has one.
*
*
In the Reference Implementation, the JDO Enhancer modifies the class
* to implement PersistenceCapable prior to loading the class into the runtime
* environment. The Reference Enhancer also adds code to implement the
* methods defined by PersistenceCapable.
*
*
The extra methods in the PersistenceCapable interface might be generated
* by pre-processing a .java file, or might be generated from a tool directly.
* The exact technique for generating the extra methods is not specified by
* JDO.
*
*
The PersistenceCapable interface is designed to avoid name conflicts
* in the scope of user-defined classes. All of its declared method
* names are prefixed with 'jdo'.
* @version 2.0
*/
public interface PersistenceCapable {
/** If jdoFlags is set to READ_WRITE_OK, then the fields in the default fetch group
* can be accessed for read or write without notifying the StateManager.
*/
static final byte READ_WRITE_OK = 0;
/** If jdoFlags is set to LOAD_REQUIRED, then the fields in the default fetch group
* cannot be accessed for read or write without notifying the StateManager.
*/
static final byte LOAD_REQUIRED = 1;
/** If jdoFlags is set to READ_OK, then the fields in the default fetch group
* can be accessed for read without notifying the StateManager.
*/
static final byte READ_OK = -1;
/** If jdoFieldFlags for a field includes CHECK_READ, then
* the field has been enhanced to call the jdoStateManager on read
* if the jdoFlags setting is not READ_OK or READ_WRITE_OK.
*/
static final byte CHECK_READ = 1;
/** If jdoFieldFlags for a field includes MEDIATE_READ, then
* the field has been enhanced to always call the jdoStateManager
* on all reads.
*/
static final byte MEDIATE_READ = 2;
/** If jdoFieldFlags for a field includes CHECK_WRITE,
* then the field has been enhanced to call the
* jdoStateManager on write if the jdoFlags setting is not
* READ_WRITE_OK;.
*/
static final byte CHECK_WRITE = 4;
/** If jdoFieldFlags for a field includes MEDIATE_WRITE, then
* the field has been enhanced to always call the jdoStateManager
* on all writes.
*/
static final byte MEDIATE_WRITE = 8;
/** If jdoFieldFlags for a field includes SERIALIZABLE,
* then the field is not declared as TRANSIENT.
*/
static final byte SERIALIZABLE = 16;
/** Return the associated PersistenceManager if there is one.
* Transactional and persistent instances return the associated
* PersistenceManager.
*
*
Transient non-transactional instances return null.
*
This method always delegates to the StateManager if it is non-null.
* @return the PersistenceManager associated with this instance.
*/
PersistenceManager jdoGetPersistenceManager();
/** This method sets the StateManager instance that manages the state
* of this instance. This method is normally used by the StateManager
* during the process of making an instance persistent, transient,
* or transactional.
*
* The caller of this method must have JDOPermission for the instance,
* if the instance is not already owned by a StateManager.
* If the parameter is null, and the StateManager approves the change,
* then the jdoFlags field will be reset to READ_WRITE_OK.
* If the parameter is not null, and the security manager approves
* the change, then the jdoFlags field will be reset to LOAD_REQUIRED.
* @param sm The StateManager which will own this instance, or null
* to reset the instance to transient state
* @throws SecurityException if the caller does not have JDOPermission
* @see JDOPermission
*/
void jdoReplaceStateManager(StateManager sm)
throws SecurityException;
/** The owning StateManager uses this method to ask the instance to
* provide the value of the single field identified by fieldNumber.
* @param fieldNumber the field whose value is to be provided by
* a callback to the StateManager's
* providedXXXField method
*/
void jdoProvideField(int fieldNumber);
/** The owning StateManager uses this method to ask the instance to
* provide the values of the multiple fields identified by fieldNumbers.
* @param fieldNumbers the fields whose values are to be provided by
* multiple callbacks to the StateManager's
* providedXXXField method
*/
void jdoProvideFields(int[] fieldNumbers);
/** The owning StateManager uses this method to ask the instance to
* replace the value of the single field identified by number.
* @param fieldNumber the field whose value is to be replaced by
* a callback to the StateManager's
* replacingXXXField method
*/
void jdoReplaceField(int fieldNumber);
/** The owning StateManager uses this method to ask the instance to
* replace the values of the multiple fields identified by number.
* @param fieldNumbers the fields whose values are to be replaced by
* multiple callbacks to the StateManager's
* replacingXXXField method
*/
void jdoReplaceFields(int[] fieldNumbers);
/** The owning StateManager uses this method to ask the instance to
* replace the value of the flags by calling back the StateManager
* replacingFlags method.
*/
void jdoReplaceFlags();
/** Copy field values from another instance of the same class
* to this instance.
*
This method will throw an exception if the other instance is
* not managed by the same StateManager as this instance.
* @param other the PC instance from which field values are to be copied
* @param fieldNumbers the field numbers to be copied into this instance
*/
void jdoCopyFields(Object other, int[] fieldNumbers);
/** Explicitly mark this instance and this field dirty.
* Normally, PersistenceCapable classes are able to detect changes made
* to their fields. However, if a reference to an array is given to a
* method outside the class, and the array is modified, then the
* persistent instance is not aware of the change. This API allows the
* application to notify the instance that a change was made to a field.
*
*
The field name should be the fully qualified name, including package
* name and class name of the class declaring the field. This allows
* unambiguous identification of the field to be marked dirty.
* If multiple classes declare the same field, and
* if the package and class name are not provided by the parameter in
* this API, then the field marked
* dirty is the field declared by the most derived class.
*
Transient instances ignore this method.
*
* @param fieldName the name of the field to be marked dirty.
*/
void jdoMakeDirty(String fieldName);
/** Return a copy of the JDO identity associated with this instance.
*
*
Persistent instances of PersistenceCapable classes have a JDO identity
* managed by the PersistenceManager. This method returns a copy of the
* ObjectId that represents the JDO identity.
*
*
Transient instances return null.
*
*
The ObjectId may be serialized
* and later restored, and used with a PersistenceManager from the same JDO
* implementation to locate a persistent instance with the same data store
* identity.
*
*
If the JDO identity is managed by the application, then the ObjectId may
* be used with a PersistenceManager from any JDO implementation that supports
* the PersistenceCapable class.
*
*
If the JDO identity is not managed by the application or the data store,
* then the ObjectId returned is only valid within the current transaction.
*
If the JDO identity is being changed in the transaction, this method
* returns the object id as of the beginning of the current transaction.
*
* @see PersistenceManager#getObjectId(Object pc)
* @see PersistenceManager#getObjectById(Object oid, boolean validate)
* @return a copy of the ObjectId of this instance as of the beginning of the transaction.
*/
Object jdoGetObjectId();
/** Return a copy of the JDO identity associated with this instance.
* This method is the same as jdoGetObjectId if the identity of the
* instance has not changed in the current transaction.
*
If the JDO identity is being changed in the transaction, this method
* returns the current object id as modified in the current transaction.
*
* @see #jdoGetObjectId()
* @see PersistenceManager#getObjectId(Object pc)
* @see PersistenceManager#getObjectById(Object oid, boolean validate)
* @return a copy of the ObjectId of this instance as modified in the transaction.
*/
Object jdoGetTransactionalObjectId();
/** Return the version of this instance.
* @return the version
* @since 2.0
*/
Object jdoGetVersion();
/** Tests whether this object is dirty.
*
* Instances that have been modified, deleted, or newly
* made persistent in the current transaction return true.
*
*
Transient instances return false.
*
* @see javax.jdo.JDOHelper#isDirty(Object pc)
* @see javax.jdo.JDOHelper#makeDirty(Object pc, String fieldName)
* @see #jdoMakeDirty(String fieldName)
* @return true if this instance has been modified in the current transaction.
*/
boolean jdoIsDirty();
/** Tests whether this object is transactional.
*
* Instances whose state is associated with the current transaction
* return true.
*
*
Transient instances return false.
*
* @see javax.jdo.JDOHelper#isTransactional(Object pc)
* @see PersistenceManager#makeTransactional(Object pc)
* @return true if this instance is transactional.
*/
boolean jdoIsTransactional();
/** Tests whether this object is persistent.
* Instances that represent persistent objects in the data store
* return true.
* @see javax.jdo.JDOHelper#isPersistent(Object pc)
* @see PersistenceManager#makePersistent(Object pc)
* @return true if this instance is persistent.
*/
boolean jdoIsPersistent();
/** Tests whether this object has been newly made persistent.
*
* Instances that have been made persistent in the current transaction
* return true.
*
*
Transient instances return false.
*
* @see javax.jdo.JDOHelper#isNew(Object pc)
* @see PersistenceManager#makePersistent(Object pc)
* @return true if this instance was made persistent
* in the current transaction.
*/
boolean jdoIsNew();
/** Tests whether this object has been deleted.
*
* Instances that have been deleted in the current transaction return true.
*
*
Transient instances return false.
*
* @see javax.jdo.JDOHelper#isDeleted(Object pc)
* @see PersistenceManager#deletePersistent(Object pc)
* @return true if this instance was deleted
* in the current transaction.
*/
boolean jdoIsDeleted();
/** Tests whether this object has been detached.
*
* Instances that have been detached return true.
*
*
Transient instances return false.
*
* @see javax.jdo.JDOHelper#isDetached(Object pc)
* @return true if this instance is detached.
* @since 2.0
*/
boolean jdoIsDetached();
/** Return a new instance of this class, with the jdoStateManager set to the
* parameter, and jdoFlags set to LOAD_REQUIRED.
*
This method is used as a performance optimization as an alternative to
* using reflection to construct a new instance. It is used by the
* JDOImplHelper class method newInstance.
* @return a new instance of this class.
* @see JDOImplHelper#newInstance(Class pcClass, StateManager sm)
* @param sm the StateManager that will own the new instance.
*/
PersistenceCapable jdoNewInstance(StateManager sm);
/** Return a new instance of this class, with the jdoStateManager set to the
* parameter, key fields initialized to the values in the oid, and jdoFlags
* set to LOAD_REQUIRED.
*
This method is used as a performance optimization as an alternative to
* using reflection to construct a new instance of a class that uses
* application identity. It is used by the
* JDOImplHelper class method newInstance.
* @return a new instance of this class.
* @see JDOImplHelper#newInstance(Class pcClass, StateManager sm)
* @param sm the StateManager that will own the new instance.
* @param oid an instance of the object id class (application identity).
*/
PersistenceCapable jdoNewInstance(StateManager sm, Object oid);
/** Create a new instance of the
* ObjectId class for this PersistenceCapable class and initialize
* the key fields from the instance on which this method is called.
* This method creates a new instance of the class used for JDO identity.
* It is intended only for application identity. If the class has been
* enhanced for datastore identity, or if the class is abstract,
* null is returned.
*
For classes using single field identity, this method must be called
* on an instance of a persistence-capable class with its primary key
* field initialized (not null), or a
* JDONullIdentityException is thrown.
*
The instance returned is initialized with the value(s) of the
* primary key field(s) of the instance on which the method is called.
* @return the new instance created.
*/
Object jdoNewObjectIdInstance();
/** Create a new instance of the class used for JDO identity, using the
* key constructor of the object id class. It is intended for single
* field identity. The identity
* instance returned has no relationship with the values of the primary key
* fields of the persistence-capable instance on which the method is called.
* If the key is the wrong class for the object id class, null is returned.
*
For classes that use single field identity, if the parameter is
* of one of the following types, the behavior must be as specified:
*
Number or Character: the
* parameter must be the single field
* type or the wrapper class of the primitive field type; the parameter
* is passed to the single field identity constructor
* ObjectIdFieldSupplier: the field value
* is fetched from the ObjectIdFieldSupplier and passed to the
* single field identity constructor
* String: the String is passed to the
* single field identity constructor
* JDOUserException.
* @param oid the ObjectId target of the key fields
*/
void jdoCopyKeyFieldsToObjectId(Object oid);
/** Copy fields from an outside source to the key fields in the ObjectId.
* This method is generated in the PersistenceCapable
* class to generate
* a call to the field manager for each key field in the ObjectId. For
* example, an ObjectId class that has three key fields (int id,
* String name, and Float salary) would have the method generated:
*
* void jdoCopyKeyFieldsToObjectId
*
(ObjectIdFieldSupplier fm, Object objectId) {
*
EmployeeKey oid = (EmployeeKey)objectId;
*
oid.id = fm.fetchIntField (0);
*
oid.name = fm.fetchStringField (1);
*
oid.salary = fm.fetchObjectField (2);
*
}
*
* The implementation is responsible for implementing the
* ObjectIdFieldSupplier to produce the values
* for the key fields.
*
For classes using single field identity, this method always
* throws JDOUserException.
* @param oid the ObjectId target of the copy.
* @param fm the field supplier that supplies the field values.
*/
void jdoCopyKeyFieldsToObjectId(ObjectIdFieldSupplier fm, Object oid);
/** Copy fields to an outside consumer from the key fields in the ObjectId.
* This method is generated in the PersistenceCapable
* class to generate
* a call to the field manager for each key field in the ObjectId. For
* example, an ObjectId class that has three key fields (int id,
* String name, and Float salary) would have the method generated:
*
* void copyKeyFieldsFromObjectId
*
(ObjectIdFieldConsumer fm, Object objectId) {
*
EmployeeKey oid = (EmployeeKey)objectId;
*
fm.storeIntField (0, oid.id);
*
fm.storeStringField (1, oid.name);
*
fm.storeObjectField (2, oid.salary);
*
}
*
*
The implementation is responsible for implementing the
* ObjectIdFieldConsumer to store the values for the
* key fields.
* @param oid the ObjectId source of the copy.
* @param fm the field manager that receives the field values.
*/
void jdoCopyKeyFieldsFromObjectId(ObjectIdFieldConsumer fm, Object oid);
/** This interface is a convenience interface that allows an instance to
* implement both ObjectIdFieldSupplier and
* ObjectIdFieldConsumer.
*/
static interface ObjectIdFieldManager extends ObjectIdFieldConsumer, ObjectIdFieldSupplier {}
/** This interface is used to provide fields to the Object id instance. It is used
* by the method copyKeyFieldsToObjectId. When the method is called, the
* generated code calls the instance of ObjectIdFieldManager for each field in
* the object id.
*/
static interface ObjectIdFieldSupplier {
/** Fetch one field from the field manager. This field will be stored in the
* proper field of the ObjectId.
* @param fieldNumber the field number of the key field.
* @return the value of the field to be stored into the ObjectId.
*/
boolean fetchBooleanField(int fieldNumber);
/** Fetch one field from the field manager. This field will be stored in the
* proper field of the ObjectId.
* @param fieldNumber the field number of the key field.
* @return the value of the field to be stored into the ObjectId.
*/
char fetchCharField(int fieldNumber);
/** Fetch one field from the field manager. This field will be stored in the
* proper field of the ObjectId.
* @param fieldNumber the field number of the key field.
* @return the value of the field to be stored into the ObjectId.
*/
byte fetchByteField(int fieldNumber);
/** Fetch one field from the field manager. This field will be stored in the
* proper field of the ObjectId.
* @param fieldNumber the field number of the key field.
* @return the value of the field to be stored into the ObjectId.
*/
short fetchShortField(int fieldNumber);
/** Fetch one field from the field manager. This field will be stored in the
* proper field of the ObjectId.
* @param fieldNumber the field number of the key field.
* @return the value of the field to be stored into the ObjectId.
*/
int fetchIntField(int fieldNumber);
/** Fetch one field from the field manager. This field will be stored in the
* proper field of the ObjectId.
* @param fieldNumber the field number of the key field.
* @return the value of the field to be stored into the ObjectId.
*/
long fetchLongField(int fieldNumber);
/** Fetch one field from the field manager. This field will be stored in the
* proper field of the ObjectId.
* @param fieldNumber the field number of the key field.
* @return the value of the field to be stored into the ObjectId.
*/
float fetchFloatField(int fieldNumber);
/** Fetch one field from the field manager. This field will be stored in the
* proper field of the ObjectId.
* @param fieldNumber the field number of the key field.
* @return the value of the field to be stored into the ObjectId.
*/
double fetchDoubleField(int fieldNumber);
/** Fetch one field from the field manager. This field will be stored in the
* proper field of the ObjectId.
* @param fieldNumber the field number of the key field.
* @return the value of the field to be stored into the ObjectId.
*/
String fetchStringField(int fieldNumber);
/** Fetch one field from the field manager. This field will be stored in the
* proper field of the ObjectId.
* @param fieldNumber the field number of the key field.
* @return the value of the field to be stored into the ObjectId.
*/
Object fetchObjectField(int fieldNumber);
}
/** This interface is used to store fields from the Object id instance. It is used
* by the method copyKeyFieldsFromObjectId. When the method is called, the
* generated code calls the instance of ObjectIdFieldManager for each field in
* the object id.
*/
static interface ObjectIdFieldConsumer {
/** Store one field into the field manager. This field was retrieved from
* the field of the ObjectId.
* @param fieldNumber the field number of the key field.
* @param value the value of the field from the ObjectId.
*/
void storeBooleanField(int fieldNumber, boolean value);
/** Store one field into the field manager. This field was retrieved from
* the field of the ObjectId.
* @param fieldNumber the field number of the key field.
* @param value the value of the field from the ObjectId.
*/
void storeCharField(int fieldNumber, char value);
/** Store one field into the field manager. This field was retrieved from
* the field of the ObjectId.
* @param fieldNumber the field number of the key field.
* @param value the value of the field from the ObjectId.
*/
void storeByteField(int fieldNumber, byte value);
/** Store one field into the field manager. This field was retrieved from
* the field of the ObjectId.
* @param fieldNumber the field number of the key field.
* @param value the value of the field from the ObjectId.
*/
void storeShortField(int fieldNumber, short value);
/** Store one field into the field manager. This field was retrieved from
* the field of the ObjectId.
* @param fieldNumber the field number of the key field.
* @param value the value of the field from the ObjectId.
*/
void storeIntField(int fieldNumber, int value);
/** Store one field into the field manager. This field was retrieved from
* the field of the ObjectId.
* @param fieldNumber the field number of the key field.
* @param value the value of the field from the ObjectId.
*/
void storeLongField(int fieldNumber, long value);
/** Store one field into the field manager. This field was retrieved from
* the field of the ObjectId.
* @param fieldNumber the field number of the key field.
* @param value the value of the field from the ObjectId.
*/
void storeFloatField(int fieldNumber, float value);
/** Store one field into the field manager. This field was retrieved from
* the field of the ObjectId.
* @param fieldNumber the field number of the key field.
* @param value the value of the field from the ObjectId.
*/
void storeDoubleField(int fieldNumber, double value);
/** Store one field into the field manager. This field was retrieved from
* the field of the ObjectId.
* @param fieldNumber the field number of the key field.
* @param value the value of the field from the ObjectId.
*/
void storeStringField(int fieldNumber, String value);
/** Store one field into the field manager. This field was retrieved from
* the field of the ObjectId.
* @param fieldNumber the field number of the key field.
* @param value the value of the field from the ObjectId.
*/
void storeObjectField(int fieldNumber, Object value);
}
}
api/src/java/javax/jdo/spi/RegisterClassEvent.java 100664 7320 12500110371 22447 0 ustar mbouschen staff 0 0 /*
* 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.
*/
/*
* RegisterClassEvent.java
*
*/
package javax.jdo.spi;
import java.util.EventObject;
/**
* A RegisterClassEvent event gets delivered whenever a persistence-capable
* class registers itself with the JDOImplHelper.
*
* @version 1.0
*/
public class RegisterClassEvent
extends EventObject
{
/** The class object of the registered persistence-capable class */
protected Class pcClass;
/** The names of managed fields of the persistence-capable class */
protected String[] fieldNames;
/** The types of managed fields of the persistence-capable class */
protected Class[] fieldTypes;
/** The flags of managed fields of the persistence-capable class */
protected byte[] fieldFlags;
/** */
protected Class persistenceCapableSuperclass;
/**
* Constructs a new RegisterClassEvent.
* @param helper the JDOImplHelper instance
* @param registeredClass the persistence-capable class
* @param fieldNames the names of the managed fields
* @param fieldTypes the types of the managed fields
* @param fieldFlags the flags of the managed fields
* @param persistenceCapableSuperclass the persistence-capable superclass
**/
public RegisterClassEvent(JDOImplHelper helper,
Class registeredClass,
String[] fieldNames,
Class[] fieldTypes,
byte[] fieldFlags,
Class persistenceCapableSuperclass)
{
super(helper);
this.pcClass = registeredClass;
this.fieldNames = fieldNames;
this.fieldTypes = fieldTypes;
this.fieldFlags = fieldFlags;
this.persistenceCapableSuperclass = persistenceCapableSuperclass;
}
/**
* Returns the class object of the registered persistence-capable class.
* @return the persistence-capable class.
*/
public Class getRegisteredClass()
{
return pcClass;
}
/**
* Returns the names of the managed field of the persistence-capable class.
* @return the names of the managed fields
*/
public String[] getFieldNames()
{
return fieldNames;
}
/**
* Returns the types of the managed field of the persistence-capable class.
* @return the types of the managed fields
*/
public Class[] getFieldTypes()
{
return fieldTypes;
}
/**
* Returns the flags of the managed field of the persistence-capable class.
* @return the flags of the managed fields
*/
public byte[] getFieldFlags()
{
return fieldFlags;
}
/**
* Returns the class object of the persistence-capable superclass.
* @return the persistence-capable superclass.
*/
public Class getPersistenceCapableSuperclass()
{
return persistenceCapableSuperclass;
}
}
api/src/java/javax/jdo/spi/RegisterClassListener.java 100664 3031 12500110371 23146 0 ustar mbouschen staff 0 0 /*
* 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.
*/
/*
* RegisterClassListener.java
*
*/
package javax.jdo.spi;
import java.util.EventListener;
/**
* A "RegisterClassEvent" event gets fired whenever a persistence-capable class
* is loaded and gets registered with the JDOImplHelper. You can register a
* RegisterClassListener so as to be notified of any registration of a
* persistence-capable class.
*
* @version 1.0
*/
public interface RegisterClassListener
extends EventListener
{
/**
* This method gets called when a persistence-capable class is registered.
* @param event a RegisterClassEvent instance describing the registered
* class plus metadata.
*/
public void registerClass(RegisterClassEvent event);
}
api/src/java/javax/jdo/spi/StateInterrogation.java 100664 23745 12500110371 22551 0 ustar mbouschen staff 0 0 /*
* 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.
*/
/*
* StateInterrogation.java
*
*/
package javax.jdo.spi;
import javax.jdo.PersistenceManager;
/**
* This interface is implemented by a non-binary-compatible JDO implementation
* to provide state interrogation for non-enhanced persistent classes.
*
*
A call to JDOHelper to get the status of an instance is handled
* internally if the parameter instance implements PersistenceCapable.
* For non-binary-compatible implementations, there is no requirement
* that persistent instances implement PersistenceCapable. Therefore,
* if the parameter does not implement PersistenceCapable, JDOHelper
* delegates to all registered instances of StateInterrogation until
* an instance can handle the request.
*
For JDOHelper isXXX methods, which return boolean, the
* corresponding method in StateInterrogation returns Boolean. If the
* return value is null then the StateInterrogation does
* not recognize the parameter as being handled by it. A non-null return
* value indicates that the implementation has determined the answer.
*
For JDOHelper getXXX methods, which return an Object, each
* registered StateInterrogation is given the parameter until one of
* them returns a non-null value, which is passed to the caller.
*
For JDOHelper makeDirty, each
* registered StateInterrogation is given the parameter until one of
* them returns true, indicating that it has handled the call.
* An instance that implements this interface must be registered with the
* {@link JDOImplHelper}.
* @version 2.0
* @since 2.0
*/
public interface StateInterrogation {
/** Tests whether the parameter instance is persistent.
*
* Instances that represent persistent objects in the data store
* return Boolean.TRUE.
*
*
Instances known by the implementation to be non-persistent
* return Boolean.FALSE.
*
*
Instances not recognized by the implementation return
* null.
*
* @see PersistenceManager#makePersistent(Object pc)
* @see PersistenceCapable#jdoIsPersistent()
* @param pc the instance.
* @return Boolean.TRUE if the parameter instance is persistent.
*/
Boolean isPersistent (Object pc);
/** Tests whether the parameter instance is transactional.
*
* Instances whose state is associated with the current transaction
* return Boolean.TRUE.
*
*
Instances known by the implementation to be non-transactional
* return Boolean.FALSE.
*
*
Instances not recognized by the implementation return
* null.
*
* @see PersistenceCapable#jdoIsTransactional()
* @param pc the instance.
* @return Boolean.TRUE if the parameter instance is transactional.
*/
Boolean isTransactional (Object pc);
/** Tests whether the parameter instance is dirty.
*
* Instances that have been modified, deleted, newly
* made persistent in the current transaction,
* or modified while detached return Boolean.TRUE.
*
*
Instances known by the implementation to be non-dirty
* return Boolean.FALSE.
*
*
Instances not recognized by the implementation return
* null.
*
* @see StateManager#makeDirty(PersistenceCapable pc, String fieldName)
* @see PersistenceCapable#jdoIsDirty()
* @param pc the instance.
* @return Boolean.TRUE if the parameter instance has been modified
* in the current transaction, or while detached.
*/
Boolean isDirty (Object pc);
/** Tests whether the parameter instance has been newly made persistent.
*
* Instances that have been made persistent in the current transaction
* return Boolean.TRUE.
*
*
Instances known by the implementation to be non-new
* return Boolean.FALSE.
*
*
Instances not recognized by the implementation return
* null.
*
* @see PersistenceManager#makePersistent(Object pc)
* @see PersistenceCapable#jdoIsNew()
* @param pc the instance.
* @return Boolean.TRUE if the parameter instance was made persistent
* in the current transaction.
*/
Boolean isNew (Object pc);
/** Tests whether the parameter instance has been deleted.
*
* Instances that have been deleted in the current transaction
* return Boolean.TRUE.
*
*
Instances known by the implementation to be non-deleted
* return Boolean.FALSE.
*
*
Instances not recognized by the implementation return
* null.
*
* @see PersistenceManager#deletePersistent(Object pc)
* @see PersistenceCapable#jdoIsDeleted()
* @param pc the instance.
* @return Boolean.TRUE if the parameter instance was deleted
* in the current transaction.
*/
Boolean isDeleted (Object pc);
/** Tests whether the parameter instance is detached.
*
* Instances that are detached return Boolean.TRUE.
*
*
Instances known by the implementation to be non-detached
* return Boolean.FALSE.
*
*
Instances not recognized by the implementation return
* null.
*
* @see PersistenceManager#detachCopy(Object pc)
* @see PersistenceCapable#jdoIsDeleted()
* @param pc the instance.
* @return Boolean.TRUE if the parameter instance is detached.
*/
Boolean isDetached (Object pc);
/** Return the associated PersistenceManager if there is one.
* Transactional and persistent instances return the associated
* PersistenceManager.
*
*
Transient non-transactional instances return null.
*
Instances unknown by the implementation return null.
* @see PersistenceCapable#jdoGetPersistenceManager()
* @param pc the instance.
* @return the PersistenceManager associated with the
* parameter instance.
*/
PersistenceManager getPersistenceManager (Object pc);
/** Return a copy of the JDO identity associated with the parameter
* instance.
*
*
Persistent instances of PersistenceCapable classes
* have a JDO identity
* managed by the PersistenceManager. This method returns
* a copy of the
* ObjectId that represents the JDO identity.
*
*
Instances unknown by the implementation return null.
*
The ObjectId may be serialized
* and later restored, and used with a PersistenceManager
* from the same JDO
* implementation to locate a persistent instance with the same data store
* identity.
*
*
If the JDO identity is managed by the application, then the ObjectId
* may be used with a PersistenceManager from any JDO
* implementation that supports
* the PersistenceCapable class.
*
*
If the JDO identity is not managed by the application or the data
* store, then the ObjectId returned is only valid within the current
* transaction.
*
* @see PersistenceManager#getObjectId(Object pc)
* @see PersistenceCapable#jdoGetObjectId()
* @see PersistenceManager#getObjectById(Object oid, boolean validate)
* @param pc the instance.
* @return a copy of the ObjectId of the parameter instance as of the
* beginning of the transaction.
*/
Object getObjectId (Object pc);
/** Return a copy of the JDO identity associated with the parameter
* instance.
*
*
Instances unknown by the implementation return null.
* @see PersistenceCapable#jdoGetTransactionalObjectId()
* @see PersistenceManager#getObjectById(Object oid, boolean validate)
* @param pc the instance.
* @return a copy of the ObjectId of the parameter instance as modified
* in this transaction.
*/
Object getTransactionalObjectId (Object pc);
/** Return the version of the parameter instance.
*
*
Instances unknown by the implementation return null.
* @see PersistenceCapable#jdoGetVersion()
* @param pc the instance.
* @return a copy of the ObjectId of the parameter instance as modified
* in this transaction.
*/
Object getVersion (Object pc);
/** Explicitly mark the parameter instance and field dirty.
* Normally, PersistenceCapable classes are able to detect
* changes made
* to their fields. However, if a reference to an array is given to a
* method outside the class, and the array is modified, then the
* persistent instance is not aware of the change. This API allows the
* application to notify the instance that a change was made to a field.
*
*
Instances unknown by the implementation are unaffected.
* @see PersistenceCapable#jdoMakeDirty(String fieldName)
* @param pc the instance.
* @param fieldName the name of the field to be marked dirty.
*/
boolean makeDirty (Object pc, String fieldName);
}
api/src/java/javax/jdo/spi/StateManager.java 100664 54736 12500110371 21303 0 ustar mbouschen staff 0 0 /*
* 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 javax.jdo.spi;
import javax.jdo.PersistenceManager;
/** This interface is the point of contact between managed instances of
* PersistenceCapable classes and the JDO implementation. It
* contains the methods used by PersistenceCapable instances to
* delegate behavior to the JDO implementation.
*
Each managed PersistenceCapable instance contains a reference
* to a StateManager. A StateManager might manage one
* or multiple instances of PersistenceCapable instances, at the
* choice of the implementation.
*
* @version 2.0
*
*/
public interface StateManager {
/** The owning StateManager uses this method to supply the
* value of the flags to the PersistenceCapable instance.
* @param pc the calling PersistenceCapable instance
* @return the value of jdoFlags to be stored in the
* PersistenceCapable instance
*/
byte replacingFlags(PersistenceCapable pc);
/** Replace the current value of jdoStateManager.
*
* This method is called by the PersistenceCapable whenever
* jdoReplaceStateManager is called and there is already
* an owning StateManager. This is a security precaution
* to ensure that the owning StateManager is the only
* source of any change to its reference in the
* PersistenceCapable.
* @return the new value for the jdoStateManager
* @param pc the calling PersistenceCapable instance
* @param sm the proposed new value for the jdoStateManager
*/
StateManager replacingStateManager (PersistenceCapable pc, StateManager sm);
/** Tests whether this object is dirty.
*
* Instances that have been modified, deleted, or newly
* made persistent in the current transaction return true.
*
*
Transient nontransactional instances return false.
*
* @see PersistenceCapable#jdoMakeDirty(String fieldName)
* @param pc the calling PersistenceCapable instance
* @return true if this instance has been modified in the
* current transaction.
*/
boolean isDirty(PersistenceCapable pc);
/** Tests whether this object is transactional.
*
* Instances that respect transaction boundaries return true.
* These instances include transient instances made transactional as a
* result of being the target of a makeTransactional method
* call; newly made persistent or deleted persistent instances; persistent
* instances read in data store transactions; and persistent instances
* modified in optimistic transactions.
*
*
Transient nontransactional instances return false.
*
* @param pc the calling PersistenceCapable instance
* @return true if this instance is transactional.
*/
boolean isTransactional(PersistenceCapable pc);
/** Tests whether this object is persistent.
*
* Instances whose state is stored in the data store return
* true.
*
*
Transient instances return false.
*
* @see PersistenceManager#makePersistent(Object pc)
* @param pc the calling PersistenceCapable instance
* @return true if this instance is persistent.
*/
boolean isPersistent(PersistenceCapable pc);
/** Tests whether this object has been newly made persistent.
*
* Instances that have been made persistent in the current transaction
* return true.
*
*
Transient instances return false.
*
* @see PersistenceManager#makePersistent(Object pc)
* @param pc the calling PersistenceCapable instance
* @return true if this instance was made persistent
* in the current transaction.
*/
boolean isNew(PersistenceCapable pc);
/** Tests whether this object has been deleted.
*
* Instances that have been deleted in the current transaction return
* true.
*
*
Transient instances return false.
*
* @see PersistenceManager#deletePersistent(Object pc)
* @param pc the calling PersistenceCapable instance
* @return true if this instance was deleted
* in the current transaction.
*/
boolean isDeleted(PersistenceCapable pc);
/** Return the PersistenceManager that owns this instance.
* @param pc the calling PersistenceCapable instance
* @return the PersistenceManager that owns this instance
*/
PersistenceManager getPersistenceManager (PersistenceCapable pc);
/** Mark the associated PersistenceCapable field dirty.
*
The StateManager will make a copy of the field
* so it can be restored if needed later, and then mark
* the field as modified in the current transaction.
* @param pc the calling PersistenceCapable instance
* @param fieldName the name of the field
*/
void makeDirty (PersistenceCapable pc, String fieldName);
/** Return the object representing the JDO identity
* of the calling instance. If the JDO identity is being changed in
* the current transaction, this method returns the identity as of
* the beginning of the transaction.
* @param pc the calling PersistenceCapable instance
* @return the object representing the JDO identity of the calling instance
*/
Object getObjectId (PersistenceCapable pc);
/** Return the object representing the JDO identity
* of the calling instance. If the JDO identity is being changed in
* the current transaction, this method returns the current identity as
* changed in the transaction.
* @param pc the calling PersistenceCapable instance
* @return the object representing the JDO identity of the calling instance
*/
Object getTransactionalObjectId (PersistenceCapable pc);
/** Return the object representing the version
* of the calling instance.
* @param pc the calling PersistenceCapable instance
* @return the object representing the version of the calling instance
* @since 2.0
*/
Object getVersion (PersistenceCapable pc);
/** Return true if the field is cached in the calling
* instance.
* @param pc the calling PersistenceCapable instance
* @param field the field number
* @return whether the field is cached in the calling instance
*/
boolean isLoaded (PersistenceCapable pc, int field);
/** Guarantee that the serializable transactional and persistent fields
* are loaded into the instance. This method is called by the generated
* jdoPreSerialize method prior to serialization of the
* instance.
* @param pc the calling PersistenceCapable instance
*/
void preSerialize (PersistenceCapable pc);
/** Return the value for the field.
* @param pc the calling PersistenceCapable instance
* @param field the field number
* @param currentValue the current value of the field
* @return the new value for the field
*/
boolean getBooleanField (
PersistenceCapable pc, int field, boolean currentValue);
/** Return the value for the field.
* @param pc the calling PersistenceCapable instance
* @param field the field number
* @param currentValue the current value of the field
* @return the new value for the field
*/
char getCharField (PersistenceCapable pc, int field, char currentValue);
/** Return the value for the field.
* @param pc the calling PersistenceCapable instance
* @param field the field number
* @param currentValue the current value of the field
* @return the new value for the field
*/
byte getByteField (PersistenceCapable pc, int field, byte currentValue);
/** Return the value for the field.
* @param pc the calling PersistenceCapable instance
* @param field the field number
* @param currentValue the current value of the field
* @return the new value for the field
*/
short getShortField (PersistenceCapable pc, int field, short currentValue);
/** Return the value for the field.
* @param pc the calling PersistenceCapable instance
* @param field the field number
* @param currentValue the current value of the field
* @return the new value for the field
*/
int getIntField (PersistenceCapable pc, int field, int currentValue);
/** Return the value for the field.
* @param pc the calling PersistenceCapable instance
* @param field the field number
* @param currentValue the current value of the field
* @return the new value for the field
*/
long getLongField (PersistenceCapable pc, int field, long currentValue);
/** Return the value for the field.
* @param pc the calling PersistenceCapable instance
* @param field the field number
* @param currentValue the current value of the field
* @return the new value for the field
*/
float getFloatField (PersistenceCapable pc, int field, float currentValue);
/** Return the value for the field.
* @param pc the calling PersistenceCapable instance
* @param field the field number
* @param currentValue the current value of the field
* @return the new value for the field
*/
double getDoubleField (PersistenceCapable pc, int field,
double currentValue);
/** Return the value for the field.
* @param pc the calling PersistenceCapable instance
* @param field the field number
* @param currentValue the current value of the field
* @return the new value for the field
*/
String getStringField (PersistenceCapable pc, int field,
String currentValue);
/** Return the value for the field.
* @param pc the calling PersistenceCapable instance
* @param field the field number
* @param currentValue the current value of the field
* @return the new value for the field
*/
Object getObjectField (PersistenceCapable pc, int field,
Object currentValue);
/** Mark the field as modified by the user.
* @param pc the calling PersistenceCapable instance
* @param field the field number
* @param currentValue the current value of the field
* @param newValue the proposed new value of the field */
void setBooleanField (PersistenceCapable pc, int field,
boolean currentValue, boolean newValue);
/** Mark the field as modified by the user.
* @param pc the calling PersistenceCapable instance
* @param field the field number
* @param currentValue the current value of the field
* @param newValue the proposed new value of the field */
void setCharField (PersistenceCapable pc, int field,
char currentValue, char newValue);
/** Mark the field as modified by the user.
* @param pc the calling PersistenceCapable instance
* @param field the field number
* @param currentValue the current value of the field
* @param newValue the proposed new value of the field */
void setByteField (PersistenceCapable pc, int field,
byte currentValue, byte newValue);
/** Mark the field as modified by the user.
* @param pc the calling PersistenceCapable instance
* @param field the field number
* @param currentValue the current value of the field
* @param newValue the proposed new value of the field */
void setShortField (PersistenceCapable pc, int field,
short currentValue, short newValue);
/** Mark the field as modified by the user.
* @param pc the calling PersistenceCapable instance
* @param field the field number
* @param currentValue the current value of the field
* @param newValue the proposed new value of the field */
void setIntField (PersistenceCapable pc, int field,
int currentValue, int newValue);
/** Mark the field as modified by the user.
* @param pc the calling PersistenceCapable instance
* @param field the field number
* @param currentValue the current value of the field
* @param newValue the proposed new value of the field */
void setLongField (PersistenceCapable pc, int field,
long currentValue, long newValue);
/** Mark the field as modified by the user.
* @param pc the calling PersistenceCapable instance
* @param field the field number
* @param currentValue the current value of the field
* @param newValue the proposed new value of the field */
void setFloatField (PersistenceCapable pc, int field,
float currentValue, float newValue);
/** Mark the field as modified by the user.
* @param pc the calling PersistenceCapable instance
* @param field the field number
* @param currentValue the current value of the field
* @param newValue the proposed new value of the field */
void setDoubleField (PersistenceCapable pc, int field,
double currentValue, double newValue);
/** Mark the field as modified by the user.
* @param pc the calling PersistenceCapable instance
* @param field the field number
* @param currentValue the current value of the field
* @param newValue the proposed new value of the field */
void setStringField (PersistenceCapable pc, int field,
String currentValue, String newValue);
/** Mark the field as modified by the user.
* @param pc the calling PersistenceCapable instance
* @param field the field number
* @param currentValue the current value of the field
* @param newValue the proposed new value of the field */
void setObjectField (PersistenceCapable pc, int field,
Object currentValue, Object newValue);
/** The value of the field requested to be provided to the
* StateManager.
* @param pc the calling PersistenceCapable instance
* @param field the field number
* @param currentValue the current value of the field
*/
void providedBooleanField (PersistenceCapable pc, int field,
boolean currentValue);
/** The value of the field requested to be provided to the
* StateManager.
* @param pc the calling PersistenceCapable instance
* @param field the field number
* @param currentValue the current value of the field
*/
void providedCharField (PersistenceCapable pc, int field,
char currentValue);
/** The value of the field requested to be provided to the
* StateManager.
* @param pc the calling PersistenceCapable instance
* @param field the field number
* @param currentValue the current value of the field
*/
void providedByteField (PersistenceCapable pc, int field,
byte currentValue);
/** The value of the field requested to be provided to the
* StateManager.
* @param pc the calling PersistenceCapable instance
* @param field the field number
* @param currentValue the current value of the field
*/
void providedShortField (PersistenceCapable pc, int field,
short currentValue);
/** The value of the field requested to be provided to the
* StateManager.
* @param pc the calling PersistenceCapable instance
* @param field the field number
* @param currentValue the current value of the field
*/
void providedIntField (PersistenceCapable pc, int field, int currentValue);
/** The value of the field requested to be provided to the
* StateManager.
* @param pc the calling PersistenceCapable instance
* @param field the field number
* @param currentValue the current value of the field
*/
void providedLongField (PersistenceCapable pc, int field,
long currentValue);
/** The value of the field requested to be provided to the
* StateManager.
* @param pc the calling PersistenceCapable instance
* @param field the field number
* @param currentValue the current value of the field
*/
void providedFloatField (PersistenceCapable pc, int field,
float currentValue);
/** The value of the field requested to be provided to the
* StateManager.
* @param pc the calling PersistenceCapable instance
* @param field the field number
* @param currentValue the current value of the field
*/
void providedDoubleField (PersistenceCapable pc, int field,
double currentValue);
/** The value of the field requested to be provided to the
* StateManager.
* @param pc the calling PersistenceCapable instance
* @param field the field number
* @param currentValue the current value of the field
*/
void providedStringField (PersistenceCapable pc, int field,
String currentValue);
/** The value of the field requested to be provided to the
* StateManager.
* @param pc the calling PersistenceCapable instance
* @param field the field number
* @param currentValue the current value of the field
*/
void providedObjectField (PersistenceCapable pc, int field,
Object currentValue);
/** The replacement value of the field in the calling instance.
* @param pc the calling PersistenceCapable instance
* @param field the field number
* @return the new value for the field
*/
boolean replacingBooleanField (PersistenceCapable pc, int field);
/** The replacement value of the field in the calling instance.
* @param pc the calling PersistenceCapable instance
* @param field the field number
* @return the new value for the field
*/
char replacingCharField (PersistenceCapable pc, int field);
/** The replacement value of the field in the calling instance.
* @param pc the calling PersistenceCapable instance
* @param field the field number
* @return the new value for the field
*/
byte replacingByteField (PersistenceCapable pc, int field);
/** The replacement value of the field in the calling instance.
* @param pc the calling PersistenceCapable instance
* @param field the field number
* @return the new value for the field
*/
short replacingShortField (PersistenceCapable pc, int field);
/** The replacement value of the field in the calling instance.
* @param pc the calling PersistenceCapable instance
* @param field the field number
* @return the new value for the field
*/
int replacingIntField (PersistenceCapable pc, int field);
/** The replacement value of the field in the calling instance.
* @param pc the calling PersistenceCapable instance
* @param field the field number
* @return the new value for the field
*/
long replacingLongField (PersistenceCapable pc, int field);
/** The replacement value of the field in the calling instance.
* @param pc the calling PersistenceCapable instance
* @param field the field number
* @return the new value for the field
*/
float replacingFloatField (PersistenceCapable pc, int field);
/** The replacement value of the field in the calling instance.
* @param pc the calling PersistenceCapable instance
* @param field the field number
* @return the new value for the field
*/
double replacingDoubleField (PersistenceCapable pc, int field);
/** The replacement value of the field in the calling instance.
* @param pc the calling PersistenceCapable instance
* @param field the field number
* @return the new value for the field
*/
String replacingStringField (PersistenceCapable pc, int field);
/** The replacement value of the field in the calling instance.
* @param pc the calling PersistenceCapable instance
* @param field the field number
* @return the new value for the field
*/
Object replacingObjectField (PersistenceCapable pc, int field);
/** The replacement value of the detached state in the calling instance.
* @param pc the calling Detachable instance
* @param state the current value of the detached state
* @return the replacement value for the detached state
* @since 2.0
*/
Object[] replacingDetachedState (Detachable pc, Object[] state);
}
api/src/java/javax/jdo/Transaction.java 100664 24104 12500110371 20404 0 ustar mbouschen staff 0 0 /*
* 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.
*/
/*
* Transaction.java
*
*/
package javax.jdo;
import javax.transaction.Synchronization;
/** The JDO Transaction interface provides for initiation and
* completion of transactions under user control.
* It is a sub-interface of the {@link PersistenceManager}
* that deals with options and transaction demarcation.
*
Transaction options include whether optimistic concurrency
* control should be used for the current transaction, whether instances
* may hold values in the cache outside transactions, and whether
* values should be retained in the cache after transaction completion. These
* options are valid for both managed and non-managed transactions.
*
*
Transaction initiation and completion methods have similar semantics to
* javax.transaction.UserTransaction when used outside a managed
* environment. When used in a managed environment, transaction initiation
* and completion methods may only be used with bean-managed transaction
* semantics.
* @version 3.0
*/
public interface Transaction
{
/** Begin a transaction. The type of transaction is determined by the
* setting of the Optimistic flag.
* @see #setOptimistic
* @see #getOptimistic
* @throws JDOUserException if transactions are managed by a container
* in the managed environment, or if the transaction is already active.
*/
void begin();
/** Commit the current transaction.
* @throws JDOUserException if transactions are managed by a container
* in the managed environment, or if the transaction is not active.
*/
void commit();
/** Roll back the current transaction.
* @throws JDOUserException if transactions are managed by a container
* in the managed environment, or if the transaction is not active.
*/
void rollback();
/** Returns whether there is a transaction currently active.
* @return true if the transaction is active.
*/
boolean isActive();
/**
* Returns the rollback-only status of the transaction. When
* begun, the rollback-only status is false. Either the
* application or the JDO implementation may set this flag
* using setRollbackOnly.
* @return true if the transaction has been
* marked for rollback.
* @since 2.0
*/
boolean getRollbackOnly();
/**
* Sets the rollback-only status of the transaction to true.
* After this flag is set to true, the transaction
* can no longer be committed, and any attempt to commit the
* transaction will throw JDOFatalDataStoreException.
* @since 2.0
*/
void setRollbackOnly();
/** If true, allow persistent instances to be read without
* a transaction active.
* If an implementation does not support this option, a
* JDOUnsupportedOptionException is thrown.
* @param nontransactionalRead the value of the nontransactionalRead
* property
*/
void setNontransactionalRead (boolean nontransactionalRead);
/** If true, allows persistent instances to be read without
* a transaction active.
* @return the value of the nontransactionalRead property
*/
boolean getNontransactionalRead ();
/** If true, allow persistent instances to be written without
* a transaction active.
* If an implementation does not support this option, a
* JDOUnsupportedOptionException is thrown.
* @param nontransactionalWrite the value of the nontransactionalRead
* property
*/
void setNontransactionalWrite (boolean nontransactionalWrite);
/** If true, allows persistent instances to be written without
* a transaction active.
* @return the value of the nontransactionalWrite property
*/
boolean getNontransactionalWrite ();
/** If true, at commit instances retain their values and the
* instances transition to persistent-nontransactional.
* If an implementation does not support this option, a
* JDOUnsupportedOptionException is thrown.
* @param retainValues the value of the retainValues property
*/
void setRetainValues(boolean retainValues);
/** If true, at commit time instances retain their field
* values.
* @return the value of the retainValues property
*/
boolean getRetainValues();
/** If true, at rollback, fields of newly persistent instances
* are restored to
* their values as of the beginning of the transaction, and the instances
* revert to transient. Additionally, fields of modified
* instances of primitive types and immutable reference types
* are restored to their values as of the beginning of the
* transaction.
* If false, at rollback, the values of fields of
* newly persistent instances are unchanged and the instances revert to
* transient. Additionally, dirty instances transition to hollow.
* If an implementation does not support this option, a
* JDOUnsupportedOptionException is thrown.
* @param restoreValues the value of the restoreValues property
*/
void setRestoreValues(boolean restoreValues);
/** Return the current value of the restoreValues property.
* @return the value of the restoreValues property
*/
boolean getRestoreValues();
/** Optimistic transactions do not hold data store locks until commit time.
* If an implementation does not support this option, a
* JDOUnsupportedOptionException is thrown.
* @param optimistic the value of the Optimistic flag.
*/
void setOptimistic(boolean optimistic);
/** Optimistic transactions do not hold data store locks until commit time.
* @return the value of the Optimistic property.
*/
boolean getOptimistic();
/** Get the value for transaction isolation level for this transaction.
* @return the transaction isolation level
* @see #setIsolationLevel(String)
* @since 2.2
*/
String getIsolationLevel();
/** Set the value for transaction isolation level for this transaction.
* Transaction isolation levels are defined in javax.jdo.Constants.
* If the requested level is not available, but a higher level is
* available, the higher level is silently used.
* If the requested level is not available, and no higher level is
* available, then JDOUnsupportedOptionException is thrown.
* Five standard isolation levels are defined. Other isolation levels
* might be supported by an implementation but are not standard.
*
Standard values in order of low to high are:
*
read-uncommitted
* read-committed
* repeatable-read
* snapshot
* serializable
* Synchronization instance to be
* notified on transaction completions. The beforeCompletion
* method is called prior to flushing instances to the data store.
*
* The afterCompletion method is called after performing
* state transitions of persistent and transactional instances, following
* the data store commit or rollback operation.
*
Only one Synchronization instance can be registered with
* the Transaction. If the application requires more than one
* instance to receive synchronization callbacks, then the single
* application instance is responsible for managing them, and forwarding
* callbacks to them.
* @param sync the Synchronization instance to be notified;
* null for none
*/
void setSynchronization(Synchronization sync);
/** The user-specified Synchronization instance for this
* Transaction instance.
* @return the user-specified Synchronization instance.
*/
Synchronization getSynchronization();
/** The Transaction instance is always associated with exactly
* one PersistenceManager.
*
* @return the PersistenceManager for this
* Transaction instance
*/
PersistenceManager getPersistenceManager();
/**
* If true, a lock will be applied to all objects read in this
* transaction.
*
If false then retrieved objects will not be locked.
* If null will fallback to the value for metadata for the class in question.
* @param serialize the value of the serializeRead property
* @since 3.0
*/
void setSerializeRead(Boolean serialize);
/**
* Return the current value of the serializeRead property.
* @return the value of the serializeRead property
* @since 3.0
*/
Boolean getSerializeRead();
}
api/src/schema/javax/jdo/jdo_2_0.dtd 100664 26232 12500110371 17510 0 ustar mbouschen staff 0 0
api/src/schema/javax/jdo/jdo_2_0.xsd 100664 140347 12500110371 17557 0 ustar mbouschen staff 0 0
api/src/schema/javax/jdo/jdo_2_1.xsd 100664 143370 12500110371 17557 0 ustar mbouschen staff 0 0
Please note,
the following subelements must not occur more than once:
- datastore-identity
- primary-key
- inheritance
- version
Please note,
the following subelements must not occur more than once:
- the choice of array, collection and map,
- join
- embedded
- key
- value
- order
- foreign-key
- index
- unique
Please note,
the following subelements must not occur more than once:
- datastore-identity
- primary-key
- inheritance
- version
Please note,
the following subelements must not occur more than once:
- primary-key
- foreign-key
- index
- unique
Please note,
the following subelements must not occur more than once:
- index
Please note,
the following subelements must not occur more than once:
- join
- discriminator
Please note,
the following subelements must not occur more than once:
- index
Please note,
the following subelements must not occur more than once:
- the choice of array, collection, and map
- join
- embedded
- key
- value
- order
- foreign-key
- index
- unique
Please note,
the following subelements must not occur more than once:
- the choice of columns, fields and properties
Please note,
the following subelements must not occur more than once:
- embedded
- foreign-key
- index
- unique
Please note,
the following subelements must not occur more than once:
- embedded
- foreign-key
- index
- unique
Please note,
the following subelements must not occur more than once:
- embedded
- foreign-key
- index
- unique
Please note,
the following subelements must not occur more than once:
- index
Please note,
the following subelements must not occur more than once:
- the choice of columns, fields or properties
Please note,
the following subelements must not occur more than once:
- the choice of columns, fields or properties
api/src/schema/javax/jdo/jdo_2_2.dtd 100664 27111 12500110371 17507 0 ustar mbouschen staff 0 0
api/src/schema/javax/jdo/jdo_2_2.xsd 100664 146000 12500110371 17551 0 ustar mbouschen staff 0 0
Please note,
the following subelements must not occur more than once:
- datastore-identity
- primary-key
- inheritance
- version
Please note,
the following subelements must not occur more than once:
- the choice of array, collection and map,
- join
- embedded
- key
- value
- order
- foreign-key
- index
- unique
Please note,
the following subelements must not occur more than once:
- datastore-identity
- primary-key
- inheritance
- version
Please note,
the following subelements must not occur more than once:
- primary-key
- foreign-key
- index
- unique
Please note,
the following subelements must not occur more than once:
- index
Please note,
the following subelements must not occur more than once:
- join
- discriminator
Please note,
the following subelements must not occur more than once:
- index
Please note,
the following subelements must not occur more than once:
- the choice of array, collection, and map
- join
- embedded
- key
- value
- order
- foreign-key
- index
- unique
Please note,
the following subelements must not occur more than once:
- the choice of columns, fields and properties
Please note,
the following subelements must not occur more than once:
- embedded
- foreign-key
- index
- unique
Please note,
the following subelements must not occur more than once:
- embedded
- foreign-key
- index
- unique
Please note,
the following subelements must not occur more than once:
- embedded
- foreign-key
- index
- unique
Please note,
the following subelements must not occur more than once:
- index
Please note,
the following subelements must not occur more than once:
- the choice of columns, fields or properties
Please note,
the following subelements must not occur more than once:
- the choice of columns, fields or properties
api/src/schema/javax/jdo/jdo_3_0.dtd 100664 27267 12500110371 17522 0 ustar mbouschen staff 0 0
api/src/schema/javax/jdo/jdo_3_0.xsd 100664 147220 12500110371 17555 0 ustar mbouschen staff 0 0
Please note,
the following subelements must not occur more than once:
- datastore-identity
- primary-key
- inheritance
- version
Please note,
the following subelements must not occur more than once:
- the choice of array, collection and map,
- join
- embedded
- key
- value
- order
- foreign-key
- index
- unique
Please note,
the following subelements must not occur more than once:
- datastore-identity
- primary-key
- inheritance
- version
Please note,
the following subelements must not occur more than once:
- primary-key
- foreign-key
- index
- unique
Please note,
the following subelements must not occur more than once:
- index
Please note,
the following subelements must not occur more than once:
- join
- discriminator
Please note,
the following subelements must not occur more than once:
- index
Please note,
the following subelements must not occur more than once:
- the choice of array, collection, and map
- join
- embedded
- key
- value
- order
- foreign-key
- index
- unique
Please note,
the following subelements must not occur more than once:
- the choice of columns, fields and properties
Please note,
the following subelements must not occur more than once:
- embedded
- foreign-key
- index
- unique
Please note,
the following subelements must not occur more than once:
- embedded
- foreign-key
- index
- unique
Please note,
the following subelements must not occur more than once:
- embedded
- foreign-key
- index
- unique
Please note,
the following subelements must not occur more than once:
- index
Please note,
the following subelements must not occur more than once:
- the choice of columns, fields or properties
Please note,
the following subelements must not occur more than once:
- the choice of columns, fields or properties
api/src/schema/javax/jdo/jdo_3_1.dtd 100664 27525 12500110371 17520 0 ustar mbouschen staff 0 0
api/src/schema/javax/jdo/jdo_3_1.xsd 100664 147531 12500110371 17563 0 ustar mbouschen staff 0 0
Please note,
the following subelements must not occur more than once:
- datastore-identity
- primary-key
- inheritance
- version
Please note,
the following subelements must not occur more than once:
- the choice of array, collection and map,
- join
- embedded
- key
- value
- order
- foreign-key
- index
- unique
Please note,
the following subelements must not occur more than once:
- datastore-identity
- primary-key
- inheritance
- version
Please note,
the following subelements must not occur more than once:
- primary-key
- foreign-key
- index
- unique
Please note,
the following subelements must not occur more than once:
- index
Please note,
the following subelements must not occur more than once:
- join
- discriminator
Please note,
the following subelements must not occur more than once:
- index
Please note,
the following subelements must not occur more than once:
- the choice of array, collection, and map
- join
- embedded
- key
- value
- order
- foreign-key
- index
- unique
Please note,
the following subelements must not occur more than once:
- the choice of columns, fields and properties
Please note,
the following subelements must not occur more than once:
- embedded
- foreign-key
- index
- unique
Please note,
the following subelements must not occur more than once:
- embedded
- foreign-key
- index
- unique
Please note,
the following subelements must not occur more than once:
- embedded
- foreign-key
- index
- unique
Please note,
the following subelements must not occur more than once:
- index
Please note,
the following subelements must not occur more than once:
- the choice of columns, fields or properties
Please note,
the following subelements must not occur more than once:
- the choice of columns, fields or properties
api/src/schema/javax/jdo/jdoconfig_2_1.dtd 100664 5402 12500110371 20653 0 ustar mbouschen staff 0 0
api/src/schema/javax/jdo/jdoconfig_2_1.xsd 100664 23162 12500110371 20721 0 ustar mbouschen staff 0 0
This is the XML Schema for the JDO configuration file.
The root configuration element for JDO.
Standard JDO PersistenceManagerFactory
configuration properties.
Vendor-specific properties are set using
additional vendor-specific attributes and/or
property elements.
Vendor-specific properties.
javax.jdo.listener.InstanceLifecycleListener
instance configuration.
There is one
instance-lifecycle-listener element
per listener instance.
Only one instance of the listener
class is supported in this
configuration file.
If multiple instances of the same
listener class is required, then the
API
PersistenceManagerFactory.addInstanceLifecycleListener(...)
must be used.
If attribute "classes" is missing,
all persistence-capable instances
are observed,
otherwise it is a comma- or
whitespace-delimited list of
persistence-capable
classes whose instances' will be
observed.
These are attributes corresponding to the standard properties
defined in JDO 2.1.
Any other attributes present, if unrecognized by a JDO
implementation, may be silently ignored.
api/src/schema/javax/jdo/jdoconfig_2_2.dtd 100664 5637 12500110371 20666 0 ustar mbouschen staff 0 0
api/src/schema/javax/jdo/jdoconfig_2_2.xsd 100664 20454 12500110371 20723 0 ustar mbouschen staff 0 0
This is the XML Schema for the JDO configuration file.
The root configuration element for JDO.
Standard JDO PersistenceManagerFactory configuration properties.
Vendor-specific properties are set using additional
vendor-specific attributes and/or property elements.
Vendor-specific properties.
javax.jdo.listener.InstanceLifecycleListener instance
configuration. There is one instance-lifecycle-listener
element per listener instance. Only one instance of the
listener class is supported in this configuration file.
If multiple instances of the same listener class is
required, then the API
PersistenceManagerFactory.addInstanceLifecycleListener(...)
must be used.
If attribute "classes" is missing, all persistence-capable
instances are observed; otherwise it is a comma- or
whitespace-delimited list of persistence-capable
classes whose instances will be observed.
These are attributes corresponding to the standard properties
defined in JDO.
Any other attributes present, if unrecognized by a JDO
implementation, may be silently ignored.
api/src/schema/javax/jdo/jdoconfig_3_0.dtd 100664 6110 12500110371 20650 0 ustar mbouschen staff 0 0
api/src/schema/javax/jdo/jdoconfig_3_0.xsd 100664 21174 12500110371 20722 0 ustar mbouschen staff 0 0
This is the XML Schema for the JDO configuration file.
The root configuration element for JDO.
Standard JDO PersistenceManagerFactory configuration properties.
Vendor-specific properties are set using additional
vendor-specific attributes and/or property elements.
Vendor-specific properties.
javax.jdo.listener.InstanceLifecycleListener instance
configuration. There is one instance-lifecycle-listener
element per listener instance. Only one instance of the
listener class is supported in this configuration file.
If multiple instances of the same listener class is
required, then the API
PersistenceManagerFactory.addInstanceLifecycleListener(...)
must be used.
If attribute "classes" is missing, all persistence-capable
instances are observed; otherwise it is a comma- or
whitespace-delimited list of persistence-capable
classes whose instances will be observed.
These are attributes corresponding to the standard properties
defined in JDO.
Any other attributes present, if unrecognized by a JDO
implementation, may be silently ignored.
api/src/schema/javax/jdo/jdoconfig_3_1.dtd 100664 6110 12500110371 20651 0 ustar mbouschen staff 0 0
api/src/schema/javax/jdo/jdoconfig_3_1.xsd 100664 21174 12500110371 20723 0 ustar mbouschen staff 0 0
This is the XML Schema for the JDO configuration file.
The root configuration element for JDO.
Standard JDO PersistenceManagerFactory configuration properties.
Vendor-specific properties are set using additional
vendor-specific attributes and/or property elements.
Vendor-specific properties.
javax.jdo.listener.InstanceLifecycleListener instance
configuration. There is one instance-lifecycle-listener
element per listener instance. Only one instance of the
listener class is supported in this configuration file.
If multiple instances of the same listener class is
required, then the API
PersistenceManagerFactory.addInstanceLifecycleListener(...)
must be used.
If attribute "classes" is missing, all persistence-capable
instances are observed; otherwise it is a comma- or
whitespace-delimited list of persistence-capable
classes whose instances will be observed.
These are attributes corresponding to the standard properties
defined in JDO.
Any other attributes present, if unrecognized by a JDO
implementation, may be silently ignored.
api/src/schema/javax/jdo/jdoquery_2_0.dtd 100664 3356 12500110371 20560 0 ustar mbouschen staff 0 0
api/src/schema/javax/jdo/jdoquery_2_0.xsd 100664 12060 12500110371 20613 0 ustar mbouschen staff 0 0
api/src/schema/javax/jdo/jdoquery_2_1.xsd 100664 10741 12500110371 20620 0 ustar mbouschen staff 0 0
api/src/schema/javax/jdo/jdoquery_2_2.dtd 100664 3356 12500110371 20562 0 ustar mbouschen staff 0 0
api/src/schema/javax/jdo/jdoquery_2_2.xsd 100664 10741 12500110371 20621 0 ustar mbouschen staff 0 0
api/src/schema/javax/jdo/jdoquery_3_0.dtd 100664 3553 12500110371 20560 0 ustar mbouschen staff 0 0
api/src/schema/javax/jdo/jdoquery_3_0.xsd 100664 11134 12500110371 20615 0 ustar mbouschen staff 0 0
api/src/schema/javax/jdo/jdoquery_3_1.dtd 100664 3553 12500110371 20561 0 ustar mbouschen staff 0 0
api/src/schema/javax/jdo/jdoquery_3_1.xsd 100664 11134 12500110371 20616 0 ustar mbouschen staff 0 0
api/src/schema/javax/jdo/orm_2_0.dtd 100664 20213 12500110371 17522 0 ustar mbouschen staff 0 0
api/src/schema/javax/jdo/orm_2_0.xsd 100664 103173 12500110371 17574 0 ustar mbouschen staff 0 0
api/src/schema/javax/jdo/orm_2_1.xsd 100664 106115 12500110371 17574 0 ustar mbouschen staff 0 0
Please note,
the following subelements must not occur more than once:
- datastore-identity
- primary-key
- inheritance
- version
Please note,
the following subelements must not occur more than once:
- join
- embedded
- key
- value
- order
- foreign-key
- index
- unique
Please note,
the following subelements must not occur more than once:
- datastore-identity
- primary-key
- inheritance
- version
Please note,
the following subelements must not occur more than once:
- primary-key
- foreign-key
- index
- unique
Please note,
the following subelements must not occur more than once:
- index
Please note,
the following subelements must not occur more than once:
- join
- discriminator
Please note,
the following subelements must not occur more than once:
- index
Please note,
the following subelements must not occur more than once:
- join
- embedded
- key
- value
- order
- foreign-key
- index
- unique
Please note,
the following subelements must not occur more than once:
- the choice of columns, fields and properties
Please note,
the following subelements must not occur more than once:
- embedded
- foreign-key
- index
- unique
Please note,
the following subelements must not occur more than once:
- embedded
- foreign-key
- index
- unique
Please note,
the following subelements must not occur more than once:
- embedded
- foreign-key
- index
- unique
Please note,
the following subelements must not occur more than once:
- index
Please note,
the following subelements must not occur more than once:
- the choice of columns, fields or properties
Please note,
the following subelements must not occur more than once:
- the choice of columns, fields or properties
api/src/schema/javax/jdo/orm_2_2.dtd 100664 20213 12500110371 17524 0 ustar mbouschen staff 0 0
api/src/schema/javax/jdo/orm_2_2.xsd 100664 106115 12500110371 17575 0 ustar mbouschen staff 0 0
Please note,
the following subelements must not occur more than once:
- datastore-identity
- primary-key
- inheritance
- version
Please note,
the following subelements must not occur more than once:
- join
- embedded
- key
- value
- order
- foreign-key
- index
- unique
Please note,
the following subelements must not occur more than once:
- datastore-identity
- primary-key
- inheritance
- version
Please note,
the following subelements must not occur more than once:
- primary-key
- foreign-key
- index
- unique
Please note,
the following subelements must not occur more than once:
- index
Please note,
the following subelements must not occur more than once:
- join
- discriminator
Please note,
the following subelements must not occur more than once:
- index
Please note,
the following subelements must not occur more than once:
- join
- embedded
- key
- value
- order
- foreign-key
- index
- unique
Please note,
the following subelements must not occur more than once:
- the choice of columns, fields and properties
Please note,
the following subelements must not occur more than once:
- embedded
- foreign-key
- index
- unique
Please note,
the following subelements must not occur more than once:
- embedded
- foreign-key
- index
- unique
Please note,
the following subelements must not occur more than once:
- embedded
- foreign-key
- index
- unique
Please note,
the following subelements must not occur more than once:
- index
Please note,
the following subelements must not occur more than once:
- the choice of columns, fields or properties
Please note,
the following subelements must not occur more than once:
- the choice of columns, fields or properties
api/src/schema/javax/jdo/orm_3_0.dtd 100664 20213 12500110371 17523 0 ustar mbouschen staff 0 0
api/src/schema/javax/jdo/orm_3_0.xsd 100664 106115 12500110371 17574 0 ustar mbouschen staff 0 0
Please note,
the following subelements must not occur more than once:
- datastore-identity
- primary-key
- inheritance
- version
Please note,
the following subelements must not occur more than once:
- join
- embedded
- key
- value
- order
- foreign-key
- index
- unique
Please note,
the following subelements must not occur more than once:
- datastore-identity
- primary-key
- inheritance
- version
Please note,
the following subelements must not occur more than once:
- primary-key
- foreign-key
- index
- unique
Please note,
the following subelements must not occur more than once:
- index
Please note,
the following subelements must not occur more than once:
- join
- discriminator
Please note,
the following subelements must not occur more than once:
- index
Please note,
the following subelements must not occur more than once:
- join
- embedded
- key
- value
- order
- foreign-key
- index
- unique
Please note,
the following subelements must not occur more than once:
- the choice of columns, fields and properties
Please note,
the following subelements must not occur more than once:
- embedded
- foreign-key
- index
- unique
Please note,
the following subelements must not occur more than once:
- embedded
- foreign-key
- index
- unique
Please note,
the following subelements must not occur more than once:
- embedded
- foreign-key
- index
- unique
Please note,
the following subelements must not occur more than once:
- index
Please note,
the following subelements must not occur more than once:
- the choice of columns, fields or properties
Please note,
the following subelements must not occur more than once:
- the choice of columns, fields or properties
api/src/schema/javax/jdo/orm_3_1.dtd 100664 20451 12500110371 17530 0 ustar mbouschen staff 0 0
api/src/schema/javax/jdo/orm_3_1.xsd 100664 106426 12500110371 17602 0 ustar mbouschen staff 0 0
Please note,
the following subelements must not occur more than once:
- datastore-identity
- primary-key
- inheritance
- version
Please note,
the following subelements must not occur more than once:
- join
- embedded
- key
- value
- order
- foreign-key
- index
- unique
Please note,
the following subelements must not occur more than once:
- datastore-identity
- primary-key
- inheritance
- version
Please note,
the following subelements must not occur more than once:
- primary-key
- foreign-key
- index
- unique
Please note,
the following subelements must not occur more than once:
- index
Please note,
the following subelements must not occur more than once:
- join
- discriminator
Please note,
the following subelements must not occur more than once:
- index
Please note,
the following subelements must not occur more than once:
- join
- embedded
- key
- value
- order
- foreign-key
- index
- unique
Please note,
the following subelements must not occur more than once:
- the choice of columns, fields and properties
Please note,
the following subelements must not occur more than once:
- embedded
- foreign-key
- index
- unique
Please note,
the following subelements must not occur more than once:
- embedded
- foreign-key
- index
- unique
Please note,
the following subelements must not occur more than once:
- embedded
- foreign-key
- index
- unique
Please note,
the following subelements must not occur more than once:
- index
Please note,
the following subelements must not occur more than once:
- the choice of columns, fields or properties
Please note,
the following subelements must not occur more than once:
- the choice of columns, fields or properties
api/test/java/javax/jdo/AbstractJDOConfigTest.java 100664 11741 12500110371 22400 0 ustar mbouschen staff 0 0 /*
* 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 javax.jdo;
import java.net.URL;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.Map;
import java.util.Random;
import javax.jdo.util.AbstractTest;
public abstract class AbstractJDOConfigTest extends AbstractTest {
/**
* A class path prefix used in the various tests where the class path
* needs to be set.
*/
protected static String JDOCONFIG_CLASSPATH_PREFIX
= initJDOConfigClasspathPrefix();
/**
* Returns the JDO configuration class path prefix's default value, which is
* the project base directory suffixed by the path to the configuration
* directory (test/schema/jdoconfig ).
*
* @return the default class path prefix used by this test suite.
*
*/
protected static String initJDOConfigClasspathPrefix() {
return initBasedir() + "test/schema/jdoconfig";
}
/**
* The class path used to specify the location of test class files.
* @return the class path where test class files can be found.
*/
protected static String TEST_CLASSPATH =
initTestClasspath();
/**
* Returns the default class path for JDO test class files
* (target/test-classes/ ).
* @return the default class path for JDO test class files.
*/
protected static String initTestClasspath() {
return initBasedir() + "target/test-classes/";
}
/**
* The class path used to locate the JDO API class files.
*/
protected static String API_CLASSPATH =
initAPIClasspath();
/**
* Returns the default class path for JDO API class files
* (target/classes/ ).
* @return the default class path for JDO API class files.
*/
protected static String initAPIClasspath() {
return initBasedir() + "target/classes/";
}
/**
* Returns the base directory for this project. This base directory
* is used to build up the other class paths defined in this test suite.
* The value returned is the value returned by
* System.getProperty("basedir").
* A trailing slash is appended to the path if it doesn't exist.
*
* @return the default base directory of the project.
*/
protected static String initBasedir() {
String basedir = System.getProperty("basedir");
if (basedir != null) {
if (!basedir.endsWith("/")) {
basedir += "/";
}
} else {
basedir = "";
}
return basedir;
}
/**
* A randomizer seeded with the system clock's current time.
*/
protected static Random RANDOM = new Random(System.currentTimeMillis());
/**
* Fails the test if the number of properties in the two specified
* {@link java.util.Map Map} objects are not identical or their values
* do not match.
* @param expected the first {@link java.util.Map Map} object to test.
* @param actual the second {@link java.util.Map Map} object to test.
*/
static void assertEqualProperties(Map expected, Map actual) {
Iterator i = expected.entrySet().iterator();
while (i.hasNext()) {
Map.Entry entry = (Map.Entry) i.next();
String key = (String) entry.getKey();
String expectedValue = (String) entry.getValue();
String actualValue = (String) actual.get(key);
assertEquals(
"Actual property at key [" + key + "] with value [" +
actualValue + "] not equal to expected value [" +
expectedValue + "]",
expectedValue,
actualValue);
}
}
protected String getPMFClassNameViaServiceLookup(ClassLoader loader) {
try {
Enumeration urls = JDOHelper.getResources(loader,
SERVICE_LOOKUP_PMF_RESOURCE_NAME);
while (urls.hasMoreElements()) {
// return the first one found
return JDOHelper.getClassNameFromURL((URL)urls.nextElement());
}
} catch (Exception ex) {
// ignore exceptions from i/o errors
}
return null;
}
}
api/test/java/javax/jdo/annotations/Line.java 100664 2006 12500110371 21510 0 ustar mbouschen staff 0 0 /*
* 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 javax.jdo.annotations;
/*
* Line.java
*
* Created on July 18, 2007, 9:41 AM
*
*/
public class Line {
/** Creates a new instance of Line */
public Line() {
}
Point point1;
Point point2;
}
api/test/java/javax/jdo/annotations/Point.java 100664 2000 12500110371 21704 0 ustar mbouschen staff 0 0 /*
* 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 javax.jdo.annotations;
/*
* Point.java
*
* Created on July 18, 2007, 9:41 AM
*
*/
public class Point {
/** Creates a new instance of Point */
public Point() {
}
int x;
Integer y;
}
api/test/java/javax/jdo/annotations/TestEmbeddedMap.java 100664 4073 12500110371 23616 0 ustar mbouschen staff 0 0 /*
* 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 javax.jdo.annotations;
import java.util.Map;
/*
* TestEmbeddedMap.java
*
* Created on July 18, 2007, 10:16 AM
*
*/
public abstract class TestEmbeddedMap {
/** Creates a new instance of TestEmbeddedMap */
public TestEmbeddedMap() {
}
@Persistent(table="INTEGER_LINES", embeddedKey="true", embeddedValue="true")
@Join(column="OWNER_FK")
@Key(column="INTEGER")
@Value(
embeddedMapping=@Embedded(
members={
@Persistent(name="point1.x", column="POINT1_X"),
@Persistent(name="point1.y", column="POINT2_Y"),
@Persistent(name="point2.x", column="POINT2_X"),
@Persistent(name="point2.y", column="POINT2_Y")
}))
Map integerLines;
@Persistent(table="INTEGER_LINES", embeddedKey="true", embeddedValue="true")
@Join(column="OWNER_FK")
@Key(column="INTEGER")
@Value(
embeddedMapping=@Embedded(
members={
@Persistent(name="point1.x", column="POINT1_X"),
@Persistent(name="point1.y", column="POINT2_Y"),
@Persistent(name="point2.x", column="POINT2_X"),
@Persistent(name="point2.y", column="POINT2_Y")
}))
abstract Map getIntegerLines();
}
api/test/java/javax/jdo/annotations/TestEmbeddedSet.java 100664 3723 12500110371 23635 0 ustar mbouschen staff 0 0 /*
* 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 javax.jdo.annotations;
import java.util.Set;
/*
* TestEmbeddedSet.java
*
* Created on July 18, 2007, 9:40 AM
*
*/
@PersistenceCapable
public abstract class TestEmbeddedSet {
/** Creates a new instance of TestEmbeddedSet */
public TestEmbeddedSet() {
}
@Persistent (table="LINES", embeddedElement="true")
@Join(column="OWNER_FK")
@Element (
embeddedMapping=@Embedded(
members={
@Persistent(name="point1.x", column="POINT1_X"),
@Persistent(name="point1.y", column="POINT2_Y"),
@Persistent(name="point2.x", column="POINT2_X"),
@Persistent(name="point2.y", column="POINT2_Y")
}))
Set lines;
@Persistent (embeddedElement="true")
@Join(column="OWNER_FK")
@Element (
embeddedMapping=@Embedded(
members={
@Persistent(name="point1.x", column="POINT1_X"),
@Persistent(name="point1.y", column="POINT2_Y"),
@Persistent(name="point2.x", column="POINT2_X"),
@Persistent(name="point2.y", column="POINT2_Y")
}))
abstract Set getLines();
}
api/test/java/javax/jdo/annotations/TestExtensions.java 100664 4030 12500110371 23617 0 ustar mbouschen staff 0 0 /*
* 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 javax.jdo.annotations;
/*
* TestExtensions verifies that annotations can include vendor extensions.
* This class is not used except to verify that it compiles.
* https://issues.apache.org/jira/browse/JDO-728
* Add extensions element to @Index, @ForeignKey, @Unique, @PrimaryKey annotations.
*/
public abstract class TestExtensions {
/** Creates a new instance of TestExtensions */
public TestExtensions() {
}
@PrimaryKey(extensions= {
@Extension(vendorName = "vendor 1", key = "key 1", value = "value 1"),
@Extension(vendorName = "vendor 2", key = "key 2", value = "value 2")}
)
long pk;
@Index(extensions= {
@Extension(vendorName = "vendor 1", key = "key 1", value = "value 1"),
@Extension(vendorName = "vendor 2", key = "key 2", value = "value 2")}
)
@Unique(extensions= {
@Extension(vendorName = "vendor 1", key = "key 1", value = "value 1"),
@Extension(vendorName = "vendor 2", key = "key 2", value = "value 2")}
)
@ForeignKey(extensions= {
@Extension(vendorName = "vendor 1", key = "key 1", value = "value 1"),
@Extension(vendorName = "vendor 2", key = "key 2", value = "value 2")}
)
long fk;
}
api/test/java/javax/jdo/EnhancerTest.java 100664 51443 12500110371 20700 0 ustar mbouschen staff 0 0 /*
* 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 javax.jdo;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
import java.nio.CharBuffer;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
import javax.jdo.util.AbstractTest;
import javax.jdo.util.BatchTestRunner;
/**
* Tests class javax.jdo.Enhancer (Enhancer main class).
*
*/
public class EnhancerTest extends AbstractTest {
/** The path delimiter for constructing classpaths. */
private static String pathDelimiter = System.getProperty("path.separator");
/** The maven basedir identifying the directory of the execution environment. */
private static String basedir = System.getProperty("basedir");
/** */
public static void main(String args[]) {
BatchTestRunner.run(EnhancerTest.class);
}
public void testUsageOption() {
// invoke enhancer with a usage option
InvocationResult result = invokeEnhancer("?");
String outputString = result.getOutputString();
String errorString = result.getErrorString();
assertEquals("Wrong exit code from Enhancer with stderr:\n" + errorString, 0, result.getExitValue());
assertTrue("Expected Usage message from out:\n" + outputString + " with err:\n" + errorString, outputString.contains("javax.jdo.Enhancer"));
}
public void testHelpOption() {
// invoke enhancer with a usage option
InvocationResult result = invokeEnhancer("-help");
String outputString = result.getOutputString();
String errorString = result.getErrorString();
assertEquals("Wrong exit code from Enhancer with stderr:\n" + errorString, 0, result.getExitValue());
assertTrue("Expected Usage message from out:\n" + outputString + " with err:\n" + errorString, outputString.contains("javax.jdo.Enhancer"));
}
public void testHOption() {
// invoke enhancer with a usage option
InvocationResult result = invokeEnhancer("-h");
String outputString = result.getOutputString();
String errorString = result.getErrorString();
assertEquals("Wrong exit code from Enhancer with stderr:\n" + errorString, 0, result.getExitValue());
assertTrue("Expected Usage message from out:\n" + outputString + " with err:\n" + errorString, outputString.contains("javax.jdo.Enhancer"));
}
public void testInvalidOption() {
// invoke enhancer with an invalid option
InvocationResult result = invokeEnhancer("-poo");
assertEquals("Wrong return value ", ENHANCER_USAGE_ERROR, result.getExitValue());
String errorString = result.getErrorString();
assertTrue("Expected Usage message from err:\n" + errorString, errorString.contains("javax.jdo.Enhancer"));
}
public void testProperties() {
// invoke enhancer with verbose option
InvocationResult result = invokeEnhancer("-v");
String outputString = result.getOutputString();
String errorString = result.getErrorString();
assertEquals("Wrong exit code from Enhancer with stderr:\n" + errorString, 0, result.getExitValue());
assertTrue("Expected MockEnhancer vendor message from out:\n" + outputString + " with err:\n" + errorString, outputString.contains(PROPERTY_ENHANCER_VENDOR_NAME));
assertTrue("Expected MockEnhancer version message from out:\n" + outputString + " with err:\n" + errorString, outputString.contains(PROPERTY_ENHANCER_VERSION_NUMBER));
assertTrue("Expected MockEnhancer vendor message from out:\n" + outputString + " with err:\n" + errorString, outputString.contains("Mock Enhancer"));
assertTrue("Expected MockEnhancer vendor message from out:\n" + outputString + " with err:\n" + errorString, outputString.contains("2.3.0"));
assertTrue("Expected MockEnhancer properties message from out:\n" + outputString + " with err:\n" + errorString, outputString.contains("MockKey"));
}
public void testVOption() {
// invoke enhancer with verbose option
InvocationResult result = invokeEnhancer("-v");
String outputString = result.getOutputString();
String errorString = result.getErrorString();
assertEquals("Wrong exit code from Enhancer with stderr:\n" + errorString, 0, result.getExitValue());
assertTrue("Expected Enhancer class message from out:\n" + outputString + " with err:\n" + errorString, outputString.contains("javax.jdo.MockEnhancer"));
}
public void testVerboseOption() {
// invoke enhancer with verbose option
InvocationResult result = invokeEnhancer("-verbose");
String outputString = result.getOutputString();
String errorString = result.getErrorString();
assertEquals("Wrong exit code from Enhancer with stderr:\n" + errorString, 0, result.getExitValue());
assertTrue("Expected Enhancer class message from out:\n" + outputString + " with err:\n" + errorString, outputString.contains("javax.jdo.MockEnhancer"));
}
public void testVerboseClasses() {
// invoke enhancer with .class parameter
InvocationResult result = invokeEnhancer("-v some.class");
String outputString = result.getOutputString();
String errorString = result.getErrorString();
assertEquals("Wrong exit code from Enhancer with stderr:\n" + errorString, 0, result.getExitValue());
assertTrue("Expected class message from out:\n" + outputString + " with err:\n" + errorString, outputString.contains("some.class"));
assertTrue("Expected number of classes from out:\n" + outputString + " with err:\n" + errorString, outputString.contains("1"));
}
public void testVerboseJars() {
// invoke enhancer with a .jar parameter
InvocationResult result = invokeEnhancer("-v some.jar");
String outputString = result.getOutputString();
String errorString = result.getErrorString();
assertEquals("Wrong exit code from Enhancer with stderr:\n" + errorString, 0, result.getExitValue());
assertTrue("Expected jar message from out:\n" + outputString + " with err:\n" + errorString, outputString.contains("some.jar"));
assertTrue("Expected number of jars from out:\n" + outputString + " with err:\n" + errorString, outputString.contains("1"));
}
public void testVerboseJDOs() {
// invoke enhancer with a .jdo parameter
InvocationResult result = invokeEnhancer("-v some.jdo");
String outputString = result.getOutputString();
String errorString = result.getErrorString();
assertEquals("Wrong exit code from Enhancer with stderr:\n" + errorString, 0, result.getExitValue());
assertTrue("Expected jdo message from out:\n" + outputString + " with err:\n" + errorString, outputString.contains("some.jdo"));
assertTrue("Expected number of jdos from out:\n" + outputString + " with err:\n" + errorString, outputString.contains("1"));
}
public void testVerboseAll() {
// invoke enhancer with multiple parameters
InvocationResult result = invokeEnhancer("-v some.class some.jar some.jdo");
String outputString = result.getOutputString();
String errorString = result.getErrorString();
assertEquals("Wrong exit code from Enhancer with stderr:\n" + errorString, 0, result.getExitValue());
assertTrue("Expected jdo message from out:\n" + outputString + " with err:\n" + errorString, outputString.contains("some.jdo"));
assertTrue("Expected jar message from out:\n" + outputString + " with err:\n" + errorString, outputString.contains("some.jar"));
assertTrue("Expected class message from out:\n" + outputString + " with err:\n" + errorString, outputString.contains("some.class"));
assertTrue("Expected number of elements from out:\n" + outputString + " with err:\n" + errorString, outputString.contains("3"));
}
public void testVerboseCheckonlyAll() {
// invoke enhancer with a checkonly option
InvocationResult result = invokeEnhancer("-v -checkonly some.class some.jar some.jdo");
String outputString = result.getOutputString();
String errorString = result.getErrorString();
assertEquals("Wrong exit code from Enhancer with stderr:\n" + errorString, 0, result.getExitValue());
assertTrue("Expected jdo message from out:\n" + outputString + " with err:\n" + errorString, outputString.contains("some.jdo"));
assertTrue("Expected jar message from out:\n" + outputString + " with err:\n" + errorString, outputString.contains("some.jar"));
assertTrue("Expected class message from out:\n" + outputString + " with err:\n" + errorString, outputString.contains("some.class"));
assertTrue("Expected number of elements from out:\n" + outputString + " with err:\n" + errorString, outputString.contains("3"));
}
public void testMissingPU() {
// invoke enhancer with missing parameter
InvocationResult result = invokeEnhancer("-v -pu");
assertEquals("Wrong return value ", 3, result.getExitValue());
}
public void testVerbosePU() {
// invoke enhancer with a pu parameter
InvocationResult result = invokeEnhancer("-v -pu myPU -pu yourPU");
String outputString = result.getOutputString();
String errorString = result.getErrorString();
assertEquals("Wrong exit code from Enhancer with stderr:\n" + errorString, 0, result.getExitValue());
assertTrue("Expected pu message from out:\n" + outputString + " with err:\n" + errorString, outputString.contains("myPU"));
assertTrue("Expected pu message from out:\n" + outputString + " with err:\n" + errorString, outputString.contains("yourPU"));
assertTrue("Expected number of elements from out:\n" + outputString + " with err:\n" + errorString, outputString.contains("2"));
}
public void testClasspath() {
// invoke enhancer with a classpath parameter
// JDOHelper must be loadable from this path
// the File.toURI should append "/" to the path, so only "target/classes" is needed
InvocationResult result = invokeEnhancer("-v -cp " + basedir + "/target/classes");
String outputString = result.getOutputString();
String errorString = result.getErrorString();
assertEquals("Wrong exit code from Enhancer with stderr:\n" + errorString, 0, result.getExitValue());
assertTrue("Expected classpath message from out:\n" + outputString + " with err:\n" + errorString, outputString.contains("target/classes"));
}
public void testBadClasspath() {
// invoke enhancer with a bad classpath parameter
// JDOHelper is not loadable from this path
InvocationResult result = invokeEnhancer("-v -cp target");
String outputString = result.getOutputString();
String errorString = result.getErrorString();
assertEquals("Wrong exit code from Enhancer with stderr:\n" + errorString, 1, result.getExitValue());
assertTrue("Expected classpath error message from out:\n" + outputString + " with err:\n" + errorString, errorString.contains("JDOHelper"));
}
public void testClasspathJar() throws IOException, InterruptedException {
// invoke enhancer with a classpath parameter
// JDOHelper must be loadable from this path
// create the jar file from the target/classes directory
String uuid = UUID.randomUUID().toString();
File uuidDir = new File(basedir + "/target/" + uuid);
uuidDir.mkdirs();
String enhancerJar = "target/" + uuid + "/enhancer-test.jar";
String enhancerJarPathname = basedir + "/" + enhancerJar;
Process create = Runtime.getRuntime().exec("jar -cf " + enhancerJarPathname + " -C " + basedir + "/target/classes .");
int returnCode = create.waitFor();
assertEquals("jar command returned wrong return code.", 0, returnCode);
// find the jdo.jar in target
InvocationResult result = invokeEnhancer("-v -cp " + enhancerJar);
String outputString = result.getOutputString();
String errorString = result.getErrorString();
assertEquals("Wrong exit code from Enhancer with stderr:\n" + errorString, 0, result.getExitValue());
assertTrue("Expected classpath message from out:\n" + outputString + " with err:\n" + errorString, outputString.contains(enhancerJar));
}
public void testOutputDirectory() {
// invoke enhancer with an output directory parameter
InvocationResult result = invokeEnhancer("-v -d some/output/directory");
String outputString = result.getOutputString();
String errorString = result.getErrorString();
assertEquals("Wrong exit code from Enhancer with stderr:\n" + errorString, 0, result.getExitValue());
assertTrue("Expected directory message from out:\n" + outputString + " with err:\n" + errorString, outputString.contains("some/output/directory"));
}
public void testMissingOutputDirectory() {
// invoke enhancer with missing parameter
InvocationResult result = invokeEnhancer("-v -d");
assertEquals("Wrong return value ", 3, result.getExitValue());
}
public void testDir() {
// invoke enhancer with directory and not recurse
InvocationResult result = invokeEnhancer("-v " + basedir + "/target/test-classes/enhancer-test-dir");
String outputString = result.getOutputString();
String errorString = result.getErrorString();
assertEquals("Wrong exit code from Enhancer with stderr:\n" + errorString, 0, result.getExitValue());
assertTrue("Expected directory enhancer-test-dir in message from out:\n" + outputString + " with err:\n" + errorString, outputString.contains("enhancer-test-dir"));
assertTrue("Expected file file1.jdo in message from out:\n" + outputString + " with err:\n" + errorString, outputString.contains("file1.jdo"));
assertTrue("Expected file file2.class in message from out:\n" + outputString + " with err:\n" + errorString, outputString.contains("file2.class"));
assertTrue("Expected file file3.jar in message from out:\n" + outputString + " with err:\n" + errorString, outputString.contains("file3.jar"));
assertFalse("Expected no directory enhancer-test-subdir in message from out:\n" + outputString + " with err:\n" + errorString, outputString.contains("enhancer-test-subdir"));
assertTrue("Expected 3 files to be enhanced in message from out:\n" + outputString + " with err:\n" + errorString, outputString.contains("3"));
}
public void testDirRecurse() {
// invoke enhancer with directory and recurse
InvocationResult result = invokeEnhancer("-v -r " + basedir + "/target/test-classes/enhancer-test-dir");
String outputString = result.getOutputString();
String errorString = result.getErrorString();
assertEquals("Wrong exit code from Enhancer with stderr:\n" + errorString, 0, result.getExitValue());
assertTrue("Expected directory enhancer-test-dir in message from out:\n" + outputString + " with err:\n" + errorString, outputString.contains("enhancer-test-dir"));
assertTrue("Expected directory enhancer-test-subdir in message from out:\n" + outputString + " with err:\n" + errorString, outputString.contains("enhancer-test-subdir"));
assertTrue("Expected file file1.jdo in message from out:\n" + outputString + " with err:\n" + errorString, outputString.contains("file1.jdo"));
assertTrue("Expected file file2.class in message from out:\n" + outputString + " with err:\n" + errorString, outputString.contains("file2.class"));
assertTrue("Expected file file3.jar in message from out:\n" + outputString + " with err:\n" + errorString, outputString.contains("file3.jar"));
assertTrue("Expected file file4.jdo in message from out:\n" + outputString + " with err:\n" + errorString, outputString.contains("file4.jdo"));
assertTrue("Expected file file5.class in message from out:\n" + outputString + " with err:\n" + errorString, outputString.contains("file5.class"));
assertTrue("Expected file file6.jar in message from out:\n" + outputString + " with err:\n" + errorString, outputString.contains("file6.jar"));
assertTrue("Expected 6 files to be enhanced in message from out:\n" + outputString + " with err:\n" + errorString, outputString.contains("6"));
}
private InvocationResult invokeEnhancer(String string) {
InvocationResult result = new InvocationResult();
try {
// create the java command to invoke the Enhancer
List commands = new ArrayList();
// find the java command in the user's path
commands.add("java");
commands.add("-cp");
commands.add("" + basedir + "/target/classes" + pathDelimiter + "" + basedir + "/target/test-classes");
commands.add("javax.jdo.Enhancer");
// add the test options (from the method parameter) to the java command
String[] optionArray = string.split(" ");
for (String option: optionArray) {
commands.add(option);
}
String[] cmdarray = commands.toArray(new String[commands.size()]);
ProcessBuilder builder = new ProcessBuilder(cmdarray);
Process proc = builder.start();
InputStream stdout = proc.getInputStream();
InputStream stderr = proc.getErrorStream();
CharBuffer outBuffer = CharBuffer.allocate(1000000);
CharBuffer errBuffer = CharBuffer.allocate(1000000);
Thread outputThread = createReaderThread(stdout, outBuffer);
Thread errorThread = createReaderThread(stderr, errBuffer);
int exitValue = proc.waitFor();
result.setExitValue(exitValue);
errorThread.join(10000); // wait ten seconds to get stderr after process terminates
outputThread.join(10000); // wait ten seconds to get stdout after process terminates
result.setErrorString(errBuffer.toString());
result.setOutputString(outBuffer.toString());
// wait until the Enhancer command finishes
} catch (InterruptedException ex) {
throw new RuntimeException("InterruptedException", ex);
} catch (IOException ex) {
throw new RuntimeException("IOException", ex);
} catch (JDOException jdoex) {
jdoex.printStackTrace();
Throwable[] throwables = jdoex.getNestedExceptions();
System.out.println("Exception throwables of size: " + throwables.length);
for (Throwable throwable: throwables) {
throwable.printStackTrace();
}
}
return result;
}
private Thread createReaderThread(final InputStream input, final CharBuffer output) {
final Reader reader = new InputStreamReader(input);
Thread thread = new Thread(
new Runnable() {
public void run() {
int count = 0;
int outputBytesRead = 0;
try {
while (-1 != (outputBytesRead = reader.read(output))) {
count += outputBytesRead;
}
} catch (IOException e) {
e.printStackTrace();
} finally {
output.flip();
}
}
});
thread.start();
return thread;
}
class InvocationResult {
private int exitValue;
private String errorString;
private String outputString;
int getExitValue() {
return exitValue;
}
private void setExitValue(int exitValue) {
this.exitValue = exitValue;
}
private void setErrorString(String errorString) {
this.errorString = errorString;
}
String getErrorString() {
return errorString;
}
private void setOutputString(String outputString) {
this.outputString = outputString;
}
String getOutputString() {
return outputString;
}
}
}
api/test/java/javax/jdo/identity/ByteIdentityTest.java 100664 13452 12500110371 23421 0 ustar mbouschen staff 0 0 /*
* 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.
*/
/*
* ByteIdentityTest.java
*
*/
package javax.jdo.identity;
import javax.jdo.JDONullIdentityException;
import javax.jdo.util.BatchTestRunner;
/**
*
*/
public class ByteIdentityTest extends SingleFieldIdentityTest {
/** Creates a new instance of ByteIdentityTest */
public ByteIdentityTest() {
}
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
BatchTestRunner.run(ByteIdentityTest.class);
}
public void testConstructor() {
ByteIdentity c1 = new ByteIdentity(Object.class, (byte)1);
ByteIdentity c2 = new ByteIdentity(Object.class, (byte)1);
ByteIdentity c3 = new ByteIdentity(Object.class, (byte)2);
assertEquals("Equal ByteIdentity instances compare not equal.", c1, c2);
assertFalse ("Not equal ByteIdentity instances compare equal", c1.equals(c3));
}
public void testByteConstructor() {
ByteIdentity c1 = new ByteIdentity(Object.class, (byte)1);
ByteIdentity c2 = new ByteIdentity(Object.class, new Byte((byte)1));
ByteIdentity c3 = new ByteIdentity(Object.class, new Byte((byte)2));
assertEquals ("Equal ByteIdentity instances compare not equal.", c1, c2);
assertFalse ("Not equal ByteIdentity instances compare equal", c1.equals(c3));
}
public void testToStringConstructor() {
ByteIdentity c1 = new ByteIdentity(Object.class, (byte)1);
ByteIdentity c2 = new ByteIdentity(Object.class, c1.toString());
assertEquals ("Equal ByteIdentity instances compare not equal.", c1, c2);
}
public void testStringConstructor() {
ByteIdentity c1 = new ByteIdentity(Object.class, (byte)1);
ByteIdentity c2 = new ByteIdentity(Object.class, "1");
ByteIdentity c3 = new ByteIdentity(Object.class, "2");
assertEquals ("Equal ByteIdentity instances compare not equal.", c1, c2);
assertFalse ("Not equal ByteIdentity instances compare equal", c1.equals(c3));
}
public void testIllegalStringConstructor() {
try {
ByteIdentity c1 = new ByteIdentity(Object.class, "b");
} catch (IllegalArgumentException iae) {
return; // good
}
fail ("No exception caught for illegal String.");
}
public void testSerialized() {
ByteIdentity c1 = new ByteIdentity(Object.class, (byte)1);
ByteIdentity c2 = new ByteIdentity(Object.class, "1");
ByteIdentity c3 = new ByteIdentity(Object.class, "2");
Object[] scis = writeReadSerialized(new Object[] {c1, c2, c3});
Object sc1 = scis[0];
Object sc2 = scis[1];
Object sc3 = scis[2];
assertEquals ("Equal ByteIdentity instances compare not equal.", c1, sc1);
assertEquals ("Equal ByteIdentity instances compare not equal.", c2, sc2);
assertEquals ("Equal ByteIdentity instances compare not equal.", sc1, c2);
assertEquals ("Equal ByteIdentity instances compare not equal.", sc2, c1);
assertFalse ("Not equal ByteIdentity instances compare equal.", c1.equals(sc3));
assertFalse ("Not equal ByteIdentity instances compare equal.", sc1.equals(c3));
assertFalse ("Not equal ByteIdentity instances compare equal.", sc1.equals(sc3));
assertFalse ("Not equal ByteIdentity instances compare equal.", sc3.equals(sc1));
}
public void testGetKeyAsObjectPrimitive() {
ByteIdentity c1 = new ByteIdentity(Object.class, (byte)1);
assertEquals("keyAsObject doesn't match.", c1.getKeyAsObject(), new Byte((byte)1));
}
public void testGetKeyAsObject() {
ByteIdentity c1 = new ByteIdentity(Object.class, new Byte((byte)1));
assertEquals("keyAsObject doesn't match.", c1.getKeyAsObject(), new Byte((byte)1));
}
public void testBadConstructorNullByteParam() {
try {
ByteIdentity c1 = new ByteIdentity(Object.class, (Byte)null);
} catch (JDONullIdentityException ex) {
return;
}
fail ("Failed to catch expected exception.");
}
public void testBadConstructorNullStringParam() {
try {
ByteIdentity c1 = new ByteIdentity(Object.class, (String)null);
} catch (JDONullIdentityException ex) {
return;
}
fail ("Failed to catch expected exception.");
}
public void testCompareTo() {
ByteIdentity c1 = new ByteIdentity(Object.class, (byte)1);
ByteIdentity c2 = new ByteIdentity(Object.class, (byte)1);
ByteIdentity c3 = new ByteIdentity(Object.class, (byte)2);
ByteIdentity c4 = new ByteIdentity(Class.class, (byte)1);
assertEquals("Equal ByteIdentity instances compare not equal.", 0, c1.compareTo(c2));
assertTrue("Not equal ByteIdentity instances have wrong compareTo result", c1.compareTo(c3) < 0);
assertTrue("Not equal ByteIdentity instances have wrong compareTo result", c3.compareTo(c1) > 0);
assertTrue("Not equal ByteIdentity instances have wrong compareTo result", c1.compareTo(c4) > 0);
}
}
api/test/java/javax/jdo/identity/CharIdentityTest.java 100664 14077 12500110371 23377 0 ustar mbouschen staff 0 0 /*
* 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.
*/
/*
* CharIdentityTest.java
*
*/
package javax.jdo.identity;
import javax.jdo.JDONullIdentityException;
import javax.jdo.util.BatchTestRunner;
/**
*
* @author clr
*/
public class CharIdentityTest extends SingleFieldIdentityTest {
/** Creates a new instance of CharIdentityTest */
public CharIdentityTest() {
}
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
BatchTestRunner.run(CharIdentityTest.class);
}
public void testConstructor() {
CharIdentity c1 = new CharIdentity(Object.class, 'a');
CharIdentity c2 = new CharIdentity(Object.class, 'a');
CharIdentity c3 = new CharIdentity(Object.class, 'b');
assertEquals("Equal CharIdentity instances compare not equal.", c1, c2);
assertFalse ("Not equal CharIdentity instances compare equal", c1.equals(c3));
}
public void testCharacterConstructor() {
CharIdentity c1 = new CharIdentity(Object.class, 'a');
CharIdentity c2 = new CharIdentity(Object.class, new Character('a'));
CharIdentity c3 = new CharIdentity(Object.class, new Character('b'));
assertEquals("Equal CharIdentity instances compare not equal.", c1, c2);
assertFalse ("Not equal CharIdentity instances compare equal", c1.equals(c3));
}
public void testToStringConstructor() {
CharIdentity c1 = new CharIdentity(Object.class, 'a');
CharIdentity c2 = new CharIdentity(Object.class, c1.toString());
assertEquals ("Equal CharIdentity instances compare not equal.", c1, c2);
}
public void testStringConstructor() {
CharIdentity c1 = new CharIdentity(Object.class, 'a');
CharIdentity c2 = new CharIdentity(Object.class, "a");
CharIdentity c3 = new CharIdentity(Object.class, "b");
assertEquals ("Equal CharIdentity instances compare not equal.", c1, c2);
assertFalse ("Not equal CharIdentity instances compare equal", c1.equals(c3));
}
public void testStringConstructorTooLong() {
try {
CharIdentity c1 = new CharIdentity(Object.class, "ab");
} catch (IllegalArgumentException iae) {
return; // good
}
fail ("No exception caught for String too long.");
}
public void testStringConstructorTooShort() {
try {
CharIdentity c1 = new CharIdentity(Object.class, "");
} catch (IllegalArgumentException iae) {
return; // good
}
fail ("No exception caught for String too short.");
}
public void testSerialized() {
CharIdentity c1 = new CharIdentity(Object.class, 'a');
CharIdentity c2 = new CharIdentity(Object.class, "a");
CharIdentity c3 = new CharIdentity(Object.class, "b");
Object[] scis = writeReadSerialized(new Object[] {c1, c2, c3});
Object sc1 = scis[0];
Object sc2 = scis[1];
Object sc3 = scis[2];
assertEquals ("Equal CharIdentity instances compare not equal.", c1, sc1);
assertEquals ("Equal CharIdentity instances compare not equal.", c2, sc2);
assertEquals ("Equal CharIdentity instances compare not equal.", sc1, c2);
assertEquals ("Equal CharIdentity instances compare not equal.", sc2, c1);
assertFalse ("Not equal CharIdentity instances compare equal.", c1.equals(sc3));
assertFalse ("Not equal CharIdentity instances compare equal.", sc1.equals(c3));
assertFalse ("Not equal CharIdentity instances compare equal.", sc1.equals(sc3));
assertFalse ("Not equal CharIdentity instances compare equal.", sc3.equals(sc1));
}
public void testGetKeyAsObjectPrimitive() {
CharIdentity c1 = new CharIdentity(Object.class, '1');
assertEquals("keyAsObject doesn't match.", c1.getKeyAsObject(), new Character('1'));
}
public void testGetKeyAsObject() {
CharIdentity c1 = new CharIdentity(Object.class, new Character('1'));
assertEquals("keyAsObject doesn't match.", c1.getKeyAsObject(), new Character('1'));
}
public void testBadConstructorNullCharacterParam() {
try {
CharIdentity c1 = new CharIdentity(Object.class, (Character)null);
} catch (JDONullIdentityException ex) {
return;
}
fail ("Failed to catch expected exception.");
}
public void testBadConstructorNullStringParam() {
try {
CharIdentity c1 = new CharIdentity(Object.class, (String)null);
} catch (JDONullIdentityException ex) {
return;
}
fail ("Failed to catch expected exception.");
}
public void testCompareTo() {
CharIdentity c1 = new CharIdentity(Object.class, '1');
CharIdentity c2 = new CharIdentity(Object.class, '1');
CharIdentity c3 = new CharIdentity(Object.class, '2');
CharIdentity c4 = new CharIdentity(Class.class, '1');
assertEquals("Equal CharIdentity instances compare not equal.", 0, c1.compareTo(c2));
assertTrue("Not equal CharIdentity instances have wrong compareTo result", c1.compareTo(c3) < 0);
assertTrue("Not equal CharIdentity instances have wrong compareTo result", c3.compareTo(c1) > 0);
assertTrue("Not equal CharIdentity instances have wrong compareTo result", c1.compareTo(c4) > 0);
}
}
api/test/java/javax/jdo/identity/ConcreteTestIdentity.java 100664 3520 12500110371 24233 0 ustar mbouschen staff 0 0 /*
* 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.
*/
/*
* ConcreteTestIdentity.java
*
*/
package javax.jdo.identity;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
/**
*
* @author clr
*/
public class ConcreteTestIdentity extends SingleFieldIdentity {
ConcreteTestIdentity(Class cls) {
super(cls);
}
/** This constructor is only for Serialization
*/
public ConcreteTestIdentity() {
super();
}
/** Determine the ordering of identity objects.
* @param o Other identity
* @return The relative ordering between the objects
* @since 2.2
*/
public int compareTo(Object o) {
throw new ClassCastException("Not implemented");
}
public void writeExternal(ObjectOutput out) throws IOException {
super.writeExternal(out);
}
public void readExternal(ObjectInput in)
throws IOException, ClassNotFoundException {
super.readExternal(in);
}
}
api/test/java/javax/jdo/identity/IntIdentityTest.java 100664 13270 12500110371 23246 0 ustar mbouschen staff 0 0 /*
* 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.
*/
/*
* IntIdentityTest.java
*
*/
package javax.jdo.identity;
import javax.jdo.JDONullIdentityException;
import javax.jdo.util.BatchTestRunner;
/**
*
*/
public class IntIdentityTest extends SingleFieldIdentityTest {
/** Creates a new instance of IntIdentityTest */
public IntIdentityTest() {
}
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
BatchTestRunner.run(IntIdentityTest.class);
}
public void testConstructor() {
IntIdentity c1 = new IntIdentity(Object.class, (int)1);
IntIdentity c2 = new IntIdentity(Object.class, (int)1);
IntIdentity c3 = new IntIdentity(Object.class, (int)2);
assertEquals("Equal IntIdentity instances compare not equal.", c1, c2);
assertFalse ("Not equal IntIdentity instances compare equal", c1.equals(c3));
}
public void testIntegerConstructor() {
IntIdentity c1 = new IntIdentity(Object.class, (int)1);
IntIdentity c2 = new IntIdentity(Object.class, new Integer((int)1));
IntIdentity c3 = new IntIdentity(Object.class, new Integer((int)2));
assertEquals ("Equal intIdentity instances compare not equal.", c1, c2);
assertFalse ("Not equal IntIdentity instances compare equal", c1.equals(c3));
}
public void testToStringConstructor() {
IntIdentity c1 = new IntIdentity(Object.class, (int)1);
IntIdentity c2 = new IntIdentity(Object.class, c1.toString());
assertEquals ("Equal IntIdentity instances compare not equal.", c1, c2);
}
public void testStringConstructor() {
IntIdentity c1 = new IntIdentity(Object.class, (int)1);
IntIdentity c2 = new IntIdentity(Object.class, "1");
IntIdentity c3 = new IntIdentity(Object.class, "2");
assertEquals ("Equal IntIdentity instances compare not equal.", c1, c2);
assertFalse ("Not equal IntIdentity instances compare equal", c1.equals(c3));
}
public void testIllegalStringConstructor() {
try {
IntIdentity c1 = new IntIdentity(Object.class, "b");
} catch (IllegalArgumentException iae) {
return; // good
}
fail ("No exception caught for illegal String.");
}
public void testSerialized() {
IntIdentity c1 = new IntIdentity(Object.class, (int)1);
IntIdentity c2 = new IntIdentity(Object.class, "1");
IntIdentity c3 = new IntIdentity(Object.class, "2");
Object[] scis = writeReadSerialized(new Object[] {c1, c2, c3});
Object sc1 = scis[0];
Object sc2 = scis[1];
Object sc3 = scis[2];
assertEquals ("Equal IntIdentity instances compare not equal.", c1, sc1);
assertEquals ("Equal IntIdentity instances compare not equal.", c2, sc2);
assertEquals ("Equal IntIdentity instances compare not equal.", sc1, c2);
assertEquals ("Equal IntIdentity instances compare not equal.", sc2, c1);
assertFalse ("Not equal InrIdentity instances compare equal.", c1.equals(sc3));
assertFalse ("Not equal IntIdentity instances compare equal.", sc1.equals(c3));
assertFalse ("Not equal IntIdentity instances compare equal.", sc1.equals(sc3));
assertFalse ("Not equal IntIdentity instances compare equal.", sc3.equals(sc1));
}
public void testGetKeyAsObjectPrimitive() {
IntIdentity c1 = new IntIdentity(Object.class, 1);
assertEquals("keyAsObject doesn't match.", c1.getKeyAsObject(), new Integer(1));
}
public void testGetKeyAsObject() {
IntIdentity c1 = new IntIdentity(Object.class, new Integer(1));
assertEquals("keyAsObject doesn't match.", c1.getKeyAsObject(), new Integer(1));
}
public void testBadConstructorNullIntegerParam() {
try {
IntIdentity c1 = new IntIdentity(Object.class, (Integer)null);
} catch (JDONullIdentityException ex) {
return;
}
fail ("Failed to catch expected exception.");
}
public void testBadConstructorNullStringParam() {
try {
IntIdentity c1 = new IntIdentity(Object.class, (String)null);
} catch (JDONullIdentityException ex) {
return;
}
fail ("Failed to catch expected exception.");
}
public void testCompareTo() {
IntIdentity c1 = new IntIdentity(Object.class, 1);
IntIdentity c2 = new IntIdentity(Object.class, 1);
IntIdentity c3 = new IntIdentity(Object.class, 2);
IntIdentity c4 = new IntIdentity(Class.class, 1);
assertEquals("Equal IntIdentity instances compare not equal.", 0, c1.compareTo(c2));
assertTrue("Not equal IntIdentity instances have wrong compareTo result", c1.compareTo(c3) < 0);
assertTrue("Not equal IntIdentity instances have wrong compareTo result", c3.compareTo(c1) > 0);
assertTrue("Not equal IntIdentity instances have wrong compareTo result", c1.compareTo(c4) > 0);
}
}
api/test/java/javax/jdo/identity/LongIdentityTest.java 100664 14036 12500110371 23414 0 ustar mbouschen staff 0 0 /*
* 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.
*/
/*
* LongIdentityTest.java
*
*/
package javax.jdo.identity;
import javax.jdo.JDONullIdentityException;
import javax.jdo.util.BatchTestRunner;
/**
*
*/
public class LongIdentityTest extends SingleFieldIdentityTest {
/** Creates a new instance of LongIdentityTest */
public LongIdentityTest() {
}
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
BatchTestRunner.run(LongIdentityTest.class);
}
public void testConstructor() {
LongIdentity c1 = new LongIdentity(Object.class, 1);
LongIdentity c2 = new LongIdentity(Object.class, 1);
LongIdentity c3 = new LongIdentity(Object.class, 2);
LongIdentity c4 = new LongIdentity(Object.class, 0x100000001L);
assertEquals("Equal LongIdentity instances compare not equal.", c1, c2);
assertFalse ("Not equal LongIdentity instances compare equal", c1.equals(c3));
assertFalse ("Not equal LongIdentity instances compare equal", c4.equals(c1));
}
public void testLongConstructor() {
LongIdentity c1 = new LongIdentity(Object.class, 1);
LongIdentity c2 = new LongIdentity(Object.class, new Long(1));
LongIdentity c3 = new LongIdentity(Object.class, new Long(2));
assertEquals ("Equal LongIdentity instances compare not equal.", c1, c2);
assertFalse ("Not equal LongIdentity instances compare equal", c1.equals(c3));
}
public void testToStringConstructor() {
LongIdentity c1 = new LongIdentity(Object.class, Long.MAX_VALUE);
LongIdentity c2 = new LongIdentity(Object.class, c1.toString());
assertEquals ("Equal LongIdentity instances compare not equal.", c1, c2);
}
public void testStringConstructor() {
LongIdentity c1 = new LongIdentity(Object.class, 1);
LongIdentity c2 = new LongIdentity(Object.class, "1");
LongIdentity c3 = new LongIdentity(Object.class, "2");
assertEquals ("Equal LongIdentity instances compare not equal.", c1, c2);
assertFalse ("Not equal LongIdentity instances compare equal", c1.equals(c3));
}
public void testIllegalStringConstructor() {
try {
LongIdentity c1 = new LongIdentity(Object.class, "b");
} catch (IllegalArgumentException iae) {
return; // good
}
fail ("No exception caught for illegal String.");
}
public void testSerialized() {
LongIdentity c1 = new LongIdentity(Object.class, 1);
LongIdentity c2 = new LongIdentity(Object.class, "1");
LongIdentity c3 = new LongIdentity(Object.class, "2");
Object[] scis = writeReadSerialized(new Object[] {c1, c2, c3});
Object sc1 = scis[0];
Object sc2 = scis[1];
Object sc3 = scis[2];
assertEquals ("Equal LongIdentity instances compare not equal.", c1, sc1);
assertEquals ("Equal LongIdentity instances compare not equal.", c2, sc2);
assertEquals ("Equal LongIdentity instances compare not equal.", sc1, c2);
assertEquals ("Equal LongIdentity instances compare not equal.", sc2, c1);
assertFalse ("Not equal LongIdentity instances compare equal.", c1.equals(sc3));
assertFalse ("Not equal LongIdentity instances compare equal.", sc1.equals(c3));
assertFalse ("Not equal LongIdentity instances compare equal.", sc1.equals(sc3));
assertFalse ("Not equal LongIdentity instances compare equal.", sc3.equals(sc1));
}
public void testGetKeyAsObjectPrimitive() {
LongIdentity c1 = new LongIdentity(Object.class, 1L);
assertEquals("keyAsObject doesn't match.", c1.getKeyAsObject(), new Long(1L));
}
public void testGetKeyAsObject() {
LongIdentity c1 = new LongIdentity(Object.class, new Long(1L));
assertEquals("keyAsObject doesn't match.", c1.getKeyAsObject(), new Long(1L));
}
public void testBadConstructorNullShortParam() {
try {
LongIdentity c1 = new LongIdentity(Object.class, (Long)null);
} catch (JDONullIdentityException ex) {
return;
}
fail ("Failed to catch expected exception.");
}
public void testBadConstructorNullStringParam() {
try {
LongIdentity c1 = new LongIdentity(Object.class, (String)null);
} catch (JDONullIdentityException ex) {
return;
}
fail ("Failed to catch expected exception.");
}
public void testCompareTo() {
LongIdentity c1 = new LongIdentity(Object.class, 1);
LongIdentity c2 = new LongIdentity(Object.class, 1);
LongIdentity c3 = new LongIdentity(Object.class, 2);
LongIdentity c4 = new LongIdentity(Class.class, 1);
LongIdentity c5 = new LongIdentity(Object.class, 0x100000001L);
assertEquals("Equal LongIdentity instances compare not equal.", 0, c1.compareTo(c2));
assertTrue("Not equal LongIdentity instances have wrong compareTo result", c1.compareTo(c3) < 0);
assertTrue("Not equal LongIdentity instances have wrong compareTo result", c3.compareTo(c1) > 0);
assertTrue("Not equal LongIdentity instances have wrong compareTo result", c1.compareTo(c4) > 0);
assertTrue("Not equal LongIdentity instances have wrong compareTo result", c5.compareTo(c1) > 0);
}
}
api/test/java/javax/jdo/identity/ObjectIdentityTest.java 100664 46723 12500110371 23733 0 ustar mbouschen staff 0 0 /*
* 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.
*/
/*
* ObjectIdentityTest.java
*
*/
package javax.jdo.identity;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.io.Serializable;
import java.math.BigDecimal;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.text.SimpleDateFormat;
import java.text.DateFormat;
import java.util.Currency;
import java.util.Date;
import java.util.Locale;
import javax.jdo.JDOUserException;
import javax.jdo.JDONullIdentityException;
import javax.jdo.spi.JDOImplHelper;
import javax.jdo.util.BatchTestRunner;
/**
*
*/
public class ObjectIdentityTest extends SingleFieldIdentityTest {
/** The JDOImplHelper instance used for Date formatting.
*/
private static JDOImplHelper helper = (JDOImplHelper)
AccessController.doPrivileged(
new PrivilegedAction () {
public JDOImplHelper run () {
return JDOImplHelper.getInstance();
}
}
);
/** Creates a new instance of ObjectIdentityTest */
public ObjectIdentityTest() {
}
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
BatchTestRunner.run(ObjectIdentityTest.class);
}
public void testConstructor() {
ObjectIdentity c1 = new ObjectIdentity(Object.class, new IdClass(1));
ObjectIdentity c2 = new ObjectIdentity(Object.class, new IdClass(1));
ObjectIdentity c3 = new ObjectIdentity(Object.class, new IdClass(2));
assertEquals("Equal ObjectIdentity instances compare not equal.", c1, c2);
assertFalse ("Not equal ObjectIdentity instances compare equal", c1.equals(c3));
}
public void testIntegerConstructor() {
ObjectIdentity c1 = new ObjectIdentity(Object.class, new Integer(1));
ObjectIdentity c2 = new ObjectIdentity(Object.class, new Integer(1));
ObjectIdentity c3 = new ObjectIdentity(Object.class, new Integer(2));
assertEquals("Equal ObjectIdentity instances compare not equal.", c1, c2);
assertFalse ("Not equal ObjectIdentity instances compare equal", c1.equals(c3));
}
public void testLongConstructor() {
ObjectIdentity c1 = new ObjectIdentity(Object.class, new Long(1));
ObjectIdentity c2 = new ObjectIdentity(Object.class, new Long(1));
ObjectIdentity c3 = new ObjectIdentity(Object.class, new Long(2));
assertEquals("Equal ObjectIdentity instances compare not equal.", c1, c2);
assertFalse ("Not equal ObjectIdentity instances compare equal", c1.equals(c3));
}
public void testDateConstructor() {
ObjectIdentity c1 = new ObjectIdentity(Object.class, new Date(1));
ObjectIdentity c2 = new ObjectIdentity(Object.class, new Date(1));
ObjectIdentity c3 = new ObjectIdentity(Object.class, new Date(2));
assertEquals("Equal ObjectIdentity instances compare not equal.", c1, c2);
assertFalse ("Not equal ObjectIdentity instances compare equal", c1.equals(c3));
}
public void testLocaleConstructor() {
ObjectIdentity c1 = new ObjectIdentity(Object.class, Locale.US);
ObjectIdentity c2 = new ObjectIdentity(Object.class, Locale.US);
ObjectIdentity c3 = new ObjectIdentity(Object.class, Locale.GERMANY);
assertEquals("Equal ObjectIdentity instances compare not equal.", c1, c2);
assertFalse ("Not equal ObjectIdentity instances compare equal", c1.equals(c3));
}
public void testCurrencyConstructor() {
if (!isClassLoadable("java.util.Currency")) return;
ObjectIdentity c1 = new ObjectIdentity(Object.class,
Currency.getInstance(Locale.US));
ObjectIdentity c2 = new ObjectIdentity(Object.class,
Currency.getInstance(Locale.US));
ObjectIdentity c3 = new ObjectIdentity(Object.class,
Currency.getInstance(Locale.GERMANY));
assertEquals("Equal ObjectIdentity instances compare not equal.", c1, c2);
assertFalse ("Not equal ObjectIdentity instances compare equal", c1.equals(c3));
}
public void testStringConstructor() {
ObjectIdentity c1 = new ObjectIdentity(Object.class,
"javax.jdo.identity.ObjectIdentityTest$IdClass:1");
ObjectIdentity c2 = new ObjectIdentity(Object.class,
"javax.jdo.identity.ObjectIdentityTest$IdClass:1");
ObjectIdentity c3 = new ObjectIdentity(Object.class,
"javax.jdo.identity.ObjectIdentityTest$IdClass:2");
assertEquals("Equal ObjectIdentity instances compare not equal.", c1, c2);
assertFalse ("Not equal ObjectIdentity instances compare equal", c1.equals(c3));
}
public void testToStringConstructor() {
ObjectIdentity c1 = new ObjectIdentity(Object.class, new IdClass(1));
ObjectIdentity c2 = new ObjectIdentity(Object.class, c1.toString());
assertEquals ("Equal ObjectIdentity instances compare not equal.", c1, c2);
}
public void testDateCompareTo() {
ObjectIdentity c1 = new ObjectIdentity(Object.class, new Date(1));
ObjectIdentity c2 = new ObjectIdentity(Object.class, new Date(1));
ObjectIdentity c3 = new ObjectIdentity(Object.class, new Date(2));
ObjectIdentity c4 = new ObjectIdentity(Class.class, new Date(1));
assertEquals("Equal ObjectIdentity instances compare not equal.", 0, c1.compareTo(c2));
assertTrue("Not equal ObjectIdentity instances have wrong compareTo result", c1.compareTo(c3) < 0);
assertTrue("Not equal ObjectIdentity instances have wrong compareTo result", c3.compareTo(c1) > 0);
assertTrue("Not equal ObjectIdentity instances have wrong compareTo result", c1.compareTo(c4) > 0);
}
public void testBadStringConstructorNullClass() {
try {
ObjectIdentity c1 = new ObjectIdentity(null, "1");
} catch (NullPointerException ex) {
return;
}
fail ("Failed to catch expected exception.");
}
public void testBadStringConstructorNullParam() {
try {
ObjectIdentity c1 = new ObjectIdentity(Object.class, null);
} catch (JDONullIdentityException ex) {
return;
}
fail ("Failed to catch expected exception.");
}
public void testBadStringConstructorTooShort() {
try {
ObjectIdentity c1 = new ObjectIdentity(Object.class, "xx");
} catch (JDOUserException ex) {
return;
}
fail ("Failed to catch expected exception.");
}
public void testBadStringConstructorNoDelimiter() {
try {
ObjectIdentity c1 = new ObjectIdentity(Object.class, "xxxxxxxxx");
} catch (JDOUserException ex) {
return;
}
fail ("Failed to catch expected exception.");
}
public void testBadStringConstructorBadClassName() {
try {
ObjectIdentity c1 = new ObjectIdentity(Object.class, "xx:yy");
} catch (JDOUserException ex) {
validateNestedException(ex, ClassNotFoundException.class);
return;
}
fail ("Failed to catch expected ClassNotFoundException.");
}
public void testBadStringConstructorNoStringConstructor() {
try {
ObjectIdentity c1 = new ObjectIdentity(Object.class,
"javax.jdo.identity.ObjectIdentityTest$BadIdClassNoStringConstructor:yy");
} catch (JDOUserException ex) {
validateNestedException(ex, NoSuchMethodException.class);
return;
}
fail ("Failed to catch expected NoSuchMethodException.");
}
public void testBadStringConstructorNoPublicStringConstructor() {
try {
ObjectIdentity c1 = new ObjectIdentity(Object.class,
"javax.jdo.identity.ObjectIdentityTest$BadIdClassNoPublicStringConstructor:yy");
} catch (JDOUserException ex) {
validateNestedException(ex, NoSuchMethodException.class);
return;
}
fail ("Failed to catch expected NoSuchMethodException.");
}
public void testBadStringConstructorIllegalArgument() {
try {
ObjectIdentity c1 = new ObjectIdentity(Object.class,
"javax.jdo.identity.ObjectIdentityTest$IdClass:yy");
} catch (JDOUserException ex) {
validateNestedException(ex, InvocationTargetException.class);
return;
}
fail ("Failed to catch expected InvocationTargetException.");
}
public void testStringDateConstructor() {
SimpleDateFormat usDateFormat = new SimpleDateFormat
("MMM dd, yyyy hh:mm:ss a", Locale.US);
helper.registerDateFormat(usDateFormat);
Object c1 = new ObjectIdentity(Object.class,
"java.util.Date:Jan 01, 1970 00:00:00 AM");
helper.registerDateFormat(DateFormat.getDateTimeInstance());
}
public void testStringDefaultDateConstructor() {
DateFormat dateFormat = DateFormat.getDateTimeInstance();
String rightNow = dateFormat.format(new Date());
Object c1 = new ObjectIdentity(Object.class,
"java.util.Date:" + rightNow);
}
public void testBadStringDateConstructor() {
try {
ObjectIdentity c1 = new ObjectIdentity(Object.class,
"java.util.Date:Jop 1, 1970 00:00:00");
} catch (JDOUserException ex) {
return;
}
fail ("Failed to catch expected Exception.");
}
public void testStringLocaleConstructorLanguage() {
if (!isClassLoadable("java.util.Currency")) return;
SingleFieldIdentity c1 = new ObjectIdentity(Object.class,
"java.util.Locale:en");
assertEquals(new Locale("en"), c1.getKeyAsObject());
}
public void testStringLocaleConstructorCountry() {
SingleFieldIdentity c1 = new ObjectIdentity(Object.class,
"java.util.Locale:_US");
assertEquals(new Locale("","US"), c1.getKeyAsObject());
}
public void testStringLocaleConstructorLanguageCountry() {
SingleFieldIdentity c1 = new ObjectIdentity(Object.class,
"java.util.Locale:en_US");
assertEquals(new Locale("en","US"), c1.getKeyAsObject());
}
public void testStringLocaleConstructorLanguageCountryVariant() {
SingleFieldIdentity c1 = new ObjectIdentity(Object.class,
"java.util.Locale:en_US_MAC");
assertEquals(new Locale("en","US","MAC"), c1.getKeyAsObject());
}
public void testStringCurrencyConstructor() {
if (!isClassLoadable("java.util.Currency")) return;
SingleFieldIdentity c1 = new ObjectIdentity(Object.class,
"java.util.Currency:USD");
}
public void testBadStringCurrencyConstructor() {
if (!isClassLoadable("java.util.Currency")) return;
try {
ObjectIdentity c1 = new ObjectIdentity(Object.class,
"java.util.Currency:NowhereInTheWorld");
} catch (JDOUserException ex) {
validateNestedException(ex, IllegalArgumentException.class);
return;
}
fail ("Failed to catch expected IllegalArgumentException.");
}
public void testSerializedIdClass() {
ObjectIdentity c1 = new ObjectIdentity(Object.class, new IdClass(1));
ObjectIdentity c2 = new ObjectIdentity(Object.class, new IdClass(1));
ObjectIdentity c3 = new ObjectIdentity(Object.class, new IdClass(2));
Object[] scis = writeReadSerialized(new Object[] {c1, c2, c3});
Object sc1 = scis[0];
Object sc2 = scis[1];
Object sc3 = scis[2];
assertEquals ("Equal ObjectIdentity instances compare not equal.", c1, sc1);
assertEquals ("Equal ObjectIdentity instances compare not equal.", c2, sc2);
assertEquals ("Equal ObjectIdentity instances compare not equal.", sc1, c2);
assertEquals ("Equal ObjectIdentity instances compare not equal.", sc2, c1);
assertFalse ("Not equal ObjectIdentity instances compare equal.", c1.equals(sc3));
assertFalse ("Not equal ObjectIdentity instances compare equal.", sc1.equals(c3));
assertFalse ("Not equal ObjectIdentity instances compare equal.", sc1.equals(sc3));
assertFalse ("Not equal ObjectIdentity instances compare equal.", sc3.equals(sc1));
}
public void testSerializedBigDecimal() {
ObjectIdentity c1 = new ObjectIdentity(Object.class, new BigDecimal("123456789.012"));
ObjectIdentity c2 = new ObjectIdentity(Object.class, new BigDecimal("123456789.012"));
ObjectIdentity c3 = new ObjectIdentity(Object.class, new BigDecimal("123456789.01"));
Object[] scis = writeReadSerialized(new Object[] {c1, c2, c3});
Object sc1 = scis[0];
Object sc2 = scis[1];
Object sc3 = scis[2];
assertEquals ("Equal ObjectIdentity instances compare not equal.", c1, sc1);
assertEquals ("Equal ObjectIdentity instances compare not equal.", c2, sc2);
assertEquals ("Equal ObjectIdentity instances compare not equal.", sc1, c2);
assertEquals ("Equal ObjectIdentity instances compare not equal.", sc2, c1);
assertFalse ("Not equal ObjectIdentity instances compare equal.", c1.equals(sc3));
assertFalse ("Not equal ObjectIdentity instances compare equal.", sc1.equals(c3));
assertFalse ("Not equal ObjectIdentity instances compare equal.", sc1.equals(sc3));
assertFalse ("Not equal ObjectIdentity instances compare equal.", sc3.equals(sc1));
}
public void testSerializedCurrency() {
if (!isClassLoadable("java.util.Currency")) return;
ObjectIdentity c1 = new ObjectIdentity(Object.class, Currency.getInstance(Locale.US));
ObjectIdentity c2 = new ObjectIdentity(Object.class, Currency.getInstance(Locale.US));
ObjectIdentity c3 = new ObjectIdentity(Object.class, Currency.getInstance(Locale.GERMANY));
Object[] scis = writeReadSerialized(new Object[] {c1, c2, c3});
Object sc1 = scis[0];
Object sc2 = scis[1];
Object sc3 = scis[2];
assertEquals ("Equal ObjectIdentity instances compare not equal.", c1, sc1);
assertEquals ("Equal ObjectIdentity instances compare not equal.", c2, sc2);
assertEquals ("Equal ObjectIdentity instances compare not equal.", sc1, c2);
assertEquals ("Equal ObjectIdentity instances compare not equal.", sc2, c1);
assertFalse ("Not equal ObjectIdentity instances compare equal.", c1.equals(sc3));
assertFalse ("Not equal ObjectIdentity instances compare equal.", sc1.equals(c3));
assertFalse ("Not equal ObjectIdentity instances compare equal.", sc1.equals(sc3));
assertFalse ("Not equal ObjectIdentity instances compare equal.", sc3.equals(sc1));
}
public void testSerializedDate() {
ObjectIdentity c1 = new ObjectIdentity(Object.class, new Date(1));
ObjectIdentity c2 = new ObjectIdentity(Object.class, "java.util.Date:1");
ObjectIdentity c3 = new ObjectIdentity(Object.class, new Date(2));
Object[] scis = writeReadSerialized(new Object[] {c1, c2, c3});
Object sc1 = scis[0];
Object sc2 = scis[1];
Object sc3 = scis[2];
assertEquals ("Equal ObjectIdentity instances compare not equal.", c1, sc1);
assertEquals ("Equal ObjectIdentity instances compare not equal.", c2, sc2);
assertEquals ("Equal ObjectIdentity instances compare not equal.", sc1, c2);
assertEquals ("Equal ObjectIdentity instances compare not equal.", sc2, c1);
assertFalse ("Not equal ObjectIdentity instances compare equal.", c1.equals(sc3));
assertFalse ("Not equal ObjectIdentity instances compare equal.", sc1.equals(c3));
assertFalse ("Not equal ObjectIdentity instances compare equal.", sc1.equals(sc3));
assertFalse ("Not equal ObjectIdentity instances compare equal.", sc3.equals(sc1));
}
public void testSerializedLocale() {
ObjectIdentity c1 = new ObjectIdentity(Object.class, Locale.US);
ObjectIdentity c2 = new ObjectIdentity(Object.class, Locale.US);
ObjectIdentity c3 = new ObjectIdentity(Object.class, Locale.GERMANY);
Object[] scis = writeReadSerialized(new Object[] {c1, c2, c3});
Object sc1 = scis[0];
Object sc2 = scis[1];
Object sc3 = scis[2];
assertEquals ("Equal ObjectIdentity instances compare not equal.", c1, sc1);
assertEquals ("Equal ObjectIdentity instances compare not equal.", c2, sc2);
assertEquals ("Equal ObjectIdentity instances compare not equal.", sc1, c2);
assertEquals ("Equal ObjectIdentity instances compare not equal.", sc2, c1);
assertFalse ("Not equal ObjectIdentity instances compare equal.", c1.equals(sc3));
assertFalse ("Not equal ObjectIdentity instances compare equal.", sc1.equals(c3));
assertFalse ("Not equal ObjectIdentity instances compare equal.", sc1.equals(sc3));
assertFalse ("Not equal ObjectIdentity instances compare equal.", sc3.equals(sc1));
}
public void testGetKeyAsObject() {
ObjectIdentity c1 = new ObjectIdentity(Object.class, new IdClass(1));
assertEquals("keyAsObject doesn't match.", c1.getKeyAsObject(), new IdClass(1));
}
private void validateNestedException(JDOUserException ex, Class expected) {
Throwable[] nesteds = ex.getNestedExceptions();
if (nesteds == null || nesteds.length != 1) {
fail ("Nested exception is null or length 0");
}
Throwable nested = nesteds[0];
if (nested != ex.getCause()) {
fail ("Nested exception is not == getCause()");
}
if (!(expected.isAssignableFrom(nested.getClass()))) {
fail ("Wrong nested exception. Expected "
+ expected.getName() + ", got "
+ nested.toString());
}
return;
}
public static class IdClass implements Serializable {
public int value;
public IdClass() {value = 0;}
public IdClass(int value) {this.value = value;}
public IdClass(String str) {this.value = Integer.parseInt(str);}
public String toString() {return Integer.toString(value);}
public int hashCode() {
return value;
}
public boolean equals (Object obj) {
if (this == obj) {
return true;
} else {
IdClass other = (IdClass) obj;
return value == other.value;
}
}
}
public static class BadIdClassNoStringConstructor {
}
public static class BadIdClassNoPublicStringConstructor {
private BadIdClassNoPublicStringConstructor(String str) {}
}
}
api/test/java/javax/jdo/identity/ShortIdentityTest.java 100664 13605 12500110371 23615 0 ustar mbouschen staff 0 0 /*
* 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.
*/
/*
* ShortIdentityTest.java
*
*/
package javax.jdo.identity;
import javax.jdo.JDONullIdentityException;
import javax.jdo.util.BatchTestRunner;
/**
*
*/
public class ShortIdentityTest extends SingleFieldIdentityTest {
/** Creates a new instance of ShortIdentityTest */
public ShortIdentityTest() {
}
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
BatchTestRunner.run(ShortIdentityTest.class);
}
public void testConstructor() {
ShortIdentity c1 = new ShortIdentity(Object.class, (short)1);
ShortIdentity c2 = new ShortIdentity(Object.class, (short)1);
ShortIdentity c3 = new ShortIdentity(Object.class, (short)2);
assertEquals("Equal ShortIdentity instances compare not equal.", c1, c2);
assertFalse ("Not equal ShortIdentity instances compare equal", c1.equals(c3));
}
public void testShortConstructor() {
ShortIdentity c1 = new ShortIdentity(Object.class, (short)1);
ShortIdentity c2 = new ShortIdentity(Object.class, new Short((short)1));
ShortIdentity c3 = new ShortIdentity(Object.class, new Short((short)2));
assertEquals ("Equal ShortIdentity instances compare not equal.", c1, c2);
assertFalse ("Not equal ShortIdentity instances compare equal", c1.equals(c3));
}
public void testToStringConstructor() {
ShortIdentity c1 = new ShortIdentity(Object.class, Short.MAX_VALUE);
ShortIdentity c2 = new ShortIdentity(Object.class, c1.toString());
assertEquals ("Equal ShortIdentity instances compare not equal.", c1, c2);
}
public void testStringConstructor() {
ShortIdentity c1 = new ShortIdentity(Object.class, (short)1);
ShortIdentity c2 = new ShortIdentity(Object.class, "1");
ShortIdentity c3 = new ShortIdentity(Object.class, "2");
assertEquals ("Equal ShortIdentity instances compare not equal.", c1, c2);
assertFalse ("Not equal ShortIdentity instances compare equal", c1.equals(c3));
}
public void testIllegalStringConstructor() {
try {
ShortIdentity c1 = new ShortIdentity(Object.class, "b");
} catch (IllegalArgumentException iae) {
return; // good
}
fail ("No exception caught for illegal String.");
}
public void testSerialized() {
ShortIdentity c1 = new ShortIdentity(Object.class, (short)1);
ShortIdentity c2 = new ShortIdentity(Object.class, "1");
ShortIdentity c3 = new ShortIdentity(Object.class, "2");
Object[] scis = writeReadSerialized(new Object[] {c1, c2, c3});
Object sc1 = scis[0];
Object sc2 = scis[1];
Object sc3 = scis[2];
assertEquals ("Equal ShortIdentity instances compare not equal.", c1, sc1);
assertEquals ("Equal ShortIdentity instances compare not equal.", c2, sc2);
assertEquals ("Equal ShortIdentity instances compare not equal.", sc1, c2);
assertEquals ("Equal ShortIdentity instances compare not equal.", sc2, c1);
assertFalse ("Not equal ShortIdentity instances compare equal.", c1.equals(sc3));
assertFalse ("Not equal ShortIdentity instances compare equal.", sc1.equals(c3));
assertFalse ("Not equal ShortIdentity instances compare equal.", sc1.equals(sc3));
assertFalse ("Not equal ShortIdentity instances compare equal.", sc3.equals(sc1));
}
public void testGetKeyAsObjectPrimitive() {
ShortIdentity c1 = new ShortIdentity(Object.class, (short)1);
assertEquals("keyAsObject doesn't match.", c1.getKeyAsObject(), new Short((short)1));
}
public void testGetKeyAsObject() {
ShortIdentity c1 = new ShortIdentity(Object.class, new Short((short)1));
assertEquals("keyAsObject doesn't match.", c1.getKeyAsObject(), new Short((short)1));
}
public void testBadConstructorNullShortParam() {
try {
ShortIdentity c1 = new ShortIdentity(Object.class, (Short)null);
} catch (JDONullIdentityException ex) {
return;
}
fail ("Failed to catch expected exception.");
}
public void testBadConstructorNullStringParam() {
try {
ShortIdentity c1 = new ShortIdentity(Object.class, (String)null);
} catch (JDONullIdentityException ex) {
return;
}
fail ("Failed to catch expected exception.");
}
public void testCompareTo() {
ShortIdentity c1 = new ShortIdentity(Object.class, (short)1);
ShortIdentity c2 = new ShortIdentity(Object.class, (short)1);
ShortIdentity c3 = new ShortIdentity(Object.class, (short)2);
ShortIdentity c4 = new ShortIdentity(Class.class, (short)1);
assertEquals("Equal ShortIdentity instances compare not equal.", 0, c1.compareTo(c2));
assertTrue("Not equal ShortIdentity instances have wrong compareTo result", c1.compareTo(c3) < 0);
assertTrue("Not equal ShortIdentity instances have wrong compareTo result", c3.compareTo(c1) > 0);
assertTrue("Not equal ShortIdentity instances have wrong compareTo result", c1.compareTo(c4) > 0);
}
}
api/test/java/javax/jdo/identity/SingleFieldIdentityTest.java 100664 7363 12500110371 24667 0 ustar mbouschen staff 0 0 /*
* 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.
*/
/*
* SingleFieldIdentityTest.java
*
*/
package javax.jdo.identity;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import javax.jdo.util.AbstractTest;
import javax.jdo.util.BatchTestRunner;
/**
*
*/
public class SingleFieldIdentityTest extends AbstractTest {
ConcreteTestIdentity cti1;
ConcreteTestIdentity cti2;
ConcreteTestIdentity cti3;
Object scti1;
Object scti2;
Object scti3;
/** Creates a new instance of SingleFieldIdentityTest */
public SingleFieldIdentityTest() {
}
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
BatchTestRunner.run(SingleFieldIdentityTest.class);
}
public void testConstructor() {
cti1 = new ConcreteTestIdentity(Object.class);
cti2 = new ConcreteTestIdentity(Object.class);
cti3 = new ConcreteTestIdentity(Class.class);
assertEquals ("Equal identity instances compare not equal.", cti1, cti2);
if (cti1.equals(cti3))
fail ("Not equal identity instances compare equal.");
}
public void testSerialized() {
cti1 = new ConcreteTestIdentity(Object.class);
cti2 = new ConcreteTestIdentity(Object.class);
cti3 = new ConcreteTestIdentity(Class.class);
Object[] sctis = writeReadSerialized(new Object[]{cti1, cti2, cti3});
scti1 = sctis[0];
scti2 = sctis[1];
scti3 = sctis[2];
assertEquals ("Deserialized instance compare not equal.", cti1, scti1);
assertEquals ("Deserialized instance compare not equal.", cti2, scti2);
assertEquals ("Deserialized instance compare not equal.", cti3, scti3);
assertEquals ("Deserialized instance compare not equal.", scti1, cti1);
assertEquals ("Deserialized instance compare not equal.", scti2, cti2);
assertEquals ("Deserialized instance compare not equal.", scti3, cti3);
if (scti1.equals(scti3))
fail ("Not equal identity instances compare equal.");
}
protected Object[] writeReadSerialized(Object[] in) {
int length = in.length;
Object[] result = new Object[length];
try {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos);
for (int i = 0; i < length; ++i) {
oos.writeObject(in[i]);
}
byte[] ba = baos.toByteArray();
ByteArrayInputStream bais = new ByteArrayInputStream(ba);
ObjectInputStream ois = new ObjectInputStream(bais);
for (int i = 0; i < length; ++i) {
result[i] = ois.readObject();
}
} catch (Exception e) {
fail(e.toString());
}
return result;
}
}
api/test/java/javax/jdo/identity/StringIdentityTest.java 100664 10413 12500110371 23756 0 ustar mbouschen staff 0 0 /*
* 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.
*/
/*
* StringIdentityTest.java
*
*/
package javax.jdo.identity;
import javax.jdo.JDONullIdentityException;
import javax.jdo.JDOUserException;
import javax.jdo.util.BatchTestRunner;
/**
*
*/
public class StringIdentityTest extends SingleFieldIdentityTest {
/** Creates a new instance of StringIdentityTest */
public StringIdentityTest() {
}
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
BatchTestRunner.run(StringIdentityTest.class);
}
public void testConstructor() {
StringIdentity c1 = new StringIdentity(Object.class, "1");
StringIdentity c2 = new StringIdentity(Object.class, "1");
StringIdentity c3 = new StringIdentity(Object.class, "2");
assertEquals("Equal StringIdentity instances compare not equal.", c1, c2);
assertFalse ("Not equal StringIdentity instances compare equal", c1.equals(c3));
}
public void testToStringConstructor() {
StringIdentity c1 = new StringIdentity(Object.class, "Now who's talking!");
StringIdentity c2 = new StringIdentity(Object.class, c1.toString());
assertEquals ("Equal StringIdentity instances compare not equal.", c1, c2);
}
public void testSerialized() {
StringIdentity c1 = new StringIdentity(Object.class, "1");
StringIdentity c2 = new StringIdentity(Object.class, "1");
StringIdentity c3 = new StringIdentity(Object.class, "2");
Object[] scis = writeReadSerialized(new Object[] {c1, c2, c3});
Object sc1 = scis[0];
Object sc2 = scis[1];
Object sc3 = scis[2];
assertEquals ("Equal StringIdentity instances compare not equal.", c1, sc1);
assertEquals ("Equal StringIdentity instances compare not equal.", c2, sc2);
assertEquals ("Equal StringIdentity instances compare not equal.", sc1, c2);
assertEquals ("Equal StringIdentity instances compare not equal.", sc2, c1);
assertFalse ("Not equal StringIdentity instances compare equal.", c1.equals(sc3));
assertFalse ("Not equal StringIdentity instances compare equal.", sc1.equals(c3));
assertFalse ("Not equal StringIdentity instances compare equal.", sc1.equals(sc3));
assertFalse ("Not equal StringIdentity instances compare equal.", sc3.equals(sc1));
}
public void testGetKeyAsObject() {
StringIdentity c1 = new StringIdentity(Object.class, "1");
assertEquals("keyAsObject doesn't match.", c1.getKeyAsObject(), "1");
}
public void testBadConstructorNullParam() {
try {
StringIdentity c1 = new StringIdentity(Object.class, null);
} catch (JDONullIdentityException ex) {
return;
}
fail ("Failed to catch expected exception.");
}
public void testCompareTo() {
StringIdentity c1 = new StringIdentity(Object.class, "1");
StringIdentity c2 = new StringIdentity(Object.class, "1");
StringIdentity c3 = new StringIdentity(Object.class, "2");
StringIdentity c4 = new StringIdentity(Class.class, "1");
assertEquals("Equal StringIdentity instances compare not equal.", 0, c1.compareTo(c2));
assertTrue("Not equal StringIdentity instances have wrong compareTo result", c1.compareTo(c3) < 0);
assertTrue("Not equal StringIdentity instances have wrong compareTo result", c3.compareTo(c1) > 0);
assertTrue("Not equal StringIdentity instances have wrong compareTo result", c1.compareTo(c4) > 0);
}
}
api/test/java/javax/jdo/JDOConfigTestClassLoader.java 100664 3562 12500110371 23013 0 ustar mbouschen staff 0 0 /*
* 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 javax.jdo;
import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.net.URLClassLoader;
/**
* A class loader that allows the user to add classpath entries.
*/
public class JDOConfigTestClassLoader extends URLClassLoader {
/**
* Uses the CTCCL as the parent and adds the given path to this loader's classpath.
*/
public JDOConfigTestClassLoader(String... additionalPath) throws IOException {
this(Thread.currentThread().getContextClassLoader(), additionalPath);
}
/**
* Uses the given ClassLoader as the parent & adds the given paths to this loader's classpath.
*/
public JDOConfigTestClassLoader(ClassLoader parent, String... additionalPaths) throws IOException {
super(new URL[] {}, parent);
for (String path : additionalPaths) {
addFile(path);
}
}
public void addFile(String s) throws IOException {
addFile(new File(s));
}
public void addFile(File f) throws IOException {
addURL(f.toURI().toURL());
}
@Override
public void addURL(URL url) {
super.addURL(url);
}
}
api/test/java/javax/jdo/JDOHelperConfigTest.java 100664 46246 12500110371 22064 0 ustar mbouschen staff 0 0 /*
* 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 javax.jdo;
import java.io.IOException;
import java.io.InputStream;
import java.net.URLClassLoader;
import java.util.HashMap;
import java.util.Map;
import javax.jdo.util.BatchTestRunner;
import junit.framework.TestSuite;
/**
*
* Tests class javax.jdo.JDOHelper for META-INF/jdoconfig.xml compliance.
*
*/
public class JDOHelperConfigTest extends AbstractJDOConfigTest implements
Constants {
public static void main(String args[]) {
BatchTestRunner.run(JDOHelperConfigTest.class);
}
/**
* {@inheritDoc}
*
* @return {@inheritDoc}
*/
public static TestSuite suite() {
return new TestSuite(JDOHelperConfigTest.class);
}
/**
* Builds up a {@link java.util.Map Map} object that contains key parameter
* values specific to a named test. All of the properties needed to run a
* particular test are loaded into this object.
*
* @param testVariant
* the name of the test to include in the {@link java.util.Map
* Map} values.
* @param listenerCount
* the number of life cycle listener class names to add to this
* map. The listener names will begin with the value stored in
* {@link javax.jdo.Constants.PROPERTY_INSTANCE_LIFECYCLE_LISTENER
* PROPERTY_INSTANCE_LIFECYCLE_LISTENER}.
* @param vendorSpecificPropertyCount
* the number of properties named of the form
*
*
* "property." + testVariant + ".name"
*
*
* that are added to the map.
* @param excludeName
* if true the property specified by
* {@link javax.jdo.Constants.PROPERTY_NAME PROPERTY_NAME} is not
* added to the map.
* @param excludePUName
* if true the property specified by
* {@link javax.jdo.Constants.PROPERTY_PERSISTENCE_UNIT_NAME
* PROPERTY_PERSISTENCE_UNIT_NAME} is not added to the map.
* @return a new {@link java.util.Map Map} object populated with properties
* that can be used in this test suite.
*/
protected Map prepareInitialExpectedMap(String testVariant,
int listenerCount, int vendorSpecificPropertyCount,
boolean excludeName, boolean excludePUName) {
Map expected = new HashMap();
if (!excludeName) {
expected.put(PROPERTY_NAME, PMF_ATTRIBUTE_NAME + "." + testVariant);
}
if (!excludePUName) {
expected.put(PROPERTY_PERSISTENCE_UNIT_NAME,
PMF_ATTRIBUTE_PERSISTENCE_UNIT_NAME + "." + testVariant);
}
expected.put(PROPERTY_PERSISTENCE_MANAGER_FACTORY_CLASS,
PMF_ATTRIBUTE_CLASS + "." + testVariant);
expected.put(PROPERTY_CONNECTION_DRIVER_NAME,
PMF_ATTRIBUTE_CONNECTION_DRIVER_NAME + "." + testVariant);
expected.put(PROPERTY_CONNECTION_FACTORY_NAME,
PMF_ATTRIBUTE_CONNECTION_FACTORY_NAME + "." + testVariant);
expected.put(PROPERTY_CONNECTION_FACTORY2_NAME,
PMF_ATTRIBUTE_CONNECTION_FACTORY2_NAME + "." + testVariant);
expected.put(PROPERTY_CONNECTION_PASSWORD,
PMF_ATTRIBUTE_CONNECTION_PASSWORD + "." + testVariant);
expected.put(PROPERTY_CONNECTION_URL, PMF_ATTRIBUTE_CONNECTION_URL
+ "." + testVariant);
expected.put(PROPERTY_CONNECTION_USER_NAME,
PMF_ATTRIBUTE_CONNECTION_USER_NAME + "." + testVariant);
expected.put(PROPERTY_IGNORE_CACHE, PMF_ATTRIBUTE_IGNORE_CACHE + "."
+ testVariant);
expected.put(PROPERTY_MAPPING, PMF_ATTRIBUTE_MAPPING + "."
+ testVariant);
expected.put(PROPERTY_MULTITHREADED, PMF_ATTRIBUTE_MULTITHREADED + "."
+ testVariant);
expected.put(PROPERTY_NONTRANSACTIONAL_READ,
PMF_ATTRIBUTE_NONTRANSACTIONAL_READ + "." + testVariant);
expected.put(PROPERTY_NONTRANSACTIONAL_WRITE,
PMF_ATTRIBUTE_NONTRANSACTIONAL_WRITE + "." + testVariant);
expected.put(PROPERTY_OPTIMISTIC, PMF_ATTRIBUTE_OPTIMISTIC + "."
+ testVariant);
expected.put(PROPERTY_RESTORE_VALUES, PMF_ATTRIBUTE_RESTORE_VALUES
+ "." + testVariant);
expected.put(PROPERTY_RETAIN_VALUES, PMF_ATTRIBUTE_RETAIN_VALUES + "."
+ testVariant);
expected.put(PROPERTY_DETACH_ALL_ON_COMMIT,
PMF_ATTRIBUTE_DETACH_ALL_ON_COMMIT + "." + testVariant);
expected.put(PROPERTY_SERVER_TIME_ZONE_ID,
PMF_ATTRIBUTE_SERVER_TIME_ZONE_ID + "." + testVariant);
// listeners
for (int i = 0; i < listenerCount; i++) {
expected.put(PROPERTY_PREFIX_INSTANCE_LIFECYCLE_LISTENER
+ "listener." + testVariant + ".listener" + i, "classes."
+ testVariant + ".classes" + i);
}
// vendor-specific properties
for (int i = 0; i < vendorSpecificPropertyCount; i++) {
expected.put("property." + testVariant + ".name" + i, "property."
+ testVariant + ".value" + i);
}
return expected;
}
/**
* Performs a test specified by testVariantName , by building up a
* property map and executing the test according to the property values.
* With this version of doPositiveTest the property name (
* {@link javax.jdo.Constants.PROPERTY_NAME PROPERTY_NAME}) and the
* {@link javax.jdo.Constants.PERSISTENCE_UNIT_NAME PERSISTENCE_UNIT_NAME})
* are included in the property map that is used to run the test.
*
* @param classpaths
* class paths to add to the class loader that runs the test that
* specify where jdoconfig.xml can be found.
* @param testVariantName
* the name of the test.
* @param listenerCount
* number of listeners utilized in the test.
* @param vendorSpecificPropertyCount
* number of vendor properties used in the test.
* @param checkEqualProperties
* if true the test's properties are tested.
* @throws java.io.IOException
* if an {@java.io.IOException
* IOException} occurs during class loading or any part of the
* test.
*/
protected void doPositiveTest(String[] classpaths, String testVariantName,
int listenerCount, int vendorSpecificPropertyCount,
boolean checkEqualProperties) throws IOException {
doPositiveTest(classpaths, testVariantName, listenerCount,
vendorSpecificPropertyCount, checkEqualProperties, false, false);
}
/**
* Performs a test specified by testVariantName , by building up a
* property map and executing the test according to the property values. An
* assertion exeception is thrown if the test being run has a negative
* (non-true) result. With this version of doPositiveTest the
* property name ({@link javax.jdo.Constants.PROPERTY_NAME PROPERTY_NAME})
* and the {@link javax.jdo.Constants.PERSISTENCE_UNIT_NAME
* PERSISTENCE_UNIT_NAME}) are included in the property map that is used to
* run the test.
*
* @param classpaths
* class paths to add to the class loader that runs the test that
* specify where jdoconfig.xml can be found.
* @param testVariantName
* the name of the test.
* @param listenerCount
* number of listeners utilized in the test.
* @param vendorSpecificPropertyCount
* number of vendor properties used in the test.
* @param checkEqualProperties
* if true the test's properties are tested.
* @param excludeName
* if true the property specified by
* {@link javax.jdo.Constants.PROPERTY_NAME PROPERTY_NAME} is not
* added to the map.
* @param excludePUName
* if true the property specified by
* {@link javax.jdo.Constants.PROPERTY_PERSISTENCE_UNIT_NAME
* PROPERTY_PERSISTENCE_UNIT_NAME} is not added to the map.
* @throws java.io.IOException
* if an {@java.io.IOException
* IOException} occurs during class loading or any part of the
* test.
*/
protected void doPositiveTest(String[] classpaths, String testVariantName,
int listenerCount, int vendorSpecificPropertyCount,
boolean checkEqualProperties, boolean excludeName,
boolean excludePUName) throws IOException {
URLClassLoader loader = new JDOConfigTestClassLoader(getClass()
.getClassLoader(), classpaths);
Map expected = prepareInitialExpectedMap(testVariantName,
listenerCount, vendorSpecificPropertyCount, excludeName,
excludePUName);
String name = testVariantName == null ? null : (String) expected
.get(PROPERTY_NAME);
Map actual = JDOHelper.getPropertiesFromJdoconfig(name, loader);
assertNotNull("No properties found", actual);
if (checkEqualProperties) {
assertEqualProperties(expected, actual);
}
}
public void testPositive00_PMF0_BasicPMFConfigUsingOnlyStandardAttributesAndListeners()
throws IOException {
doPositiveTest(new String[] { JDOCONFIG_CLASSPATH_PREFIX
+ "/Positive00" }, "positive00.pmf0", 2, 0, true);
}
public void testPositive00_PMF1_BasicPMFConfigUsingOnlyPropertyElementsWithStandardJavaxDotJDOProperties()
throws IOException {
doPositiveTest(new String[] { JDOCONFIG_CLASSPATH_PREFIX
+ "/Positive00" }, "positive00.pmf1", 2, 0, true);
}
public void testPositive00_PMF2_NestedPropertyElementsWithOnlyStandardAttributeNames()
throws IOException {
doPositiveTest(new String[] { JDOCONFIG_CLASSPATH_PREFIX
+ "/Positive00" }, "positive00.pmf2", 2, 0, true);
}
public void testPositive00_PMF3_StandardAttributesPlusNonstandardPropertiesInPropertyElements()
throws IOException {
doPositiveTest(new String[] { JDOCONFIG_CLASSPATH_PREFIX
+ "/Positive00" }, "positive00.pmf3", 2, 2, true);
}
public void testPositive00_PMF4_StandardAttributesPlusNonstandardAttributes()
throws IOException {
doPositiveTest(new String[] { JDOCONFIG_CLASSPATH_PREFIX
+ "/Positive00" }, "positive00.pmf4", 0, 2, true);
}
public void testPositive01_DuplicatePUsInDifferentConfigFilesButNotRequested()
throws IOException {
String[] classpaths = new String[] {
JDOCONFIG_CLASSPATH_PREFIX + "/Positive01/1a",
JDOCONFIG_CLASSPATH_PREFIX + "/Positive01/1b" };
URLClassLoader loader = new JDOConfigTestClassLoader(getClass()
.getClassLoader(), classpaths);
Map actual = JDOHelper.getPropertiesFromJdoconfig(
ANONYMOUS_PERSISTENCE_MANAGER_FACTORY_NAME, loader);
}
public void testPositive02_GetAnonymousPMFWithNoProperties()
throws IOException {
URLClassLoader loader = new JDOConfigTestClassLoader(getClass()
.getClassLoader(), JDOCONFIG_CLASSPATH_PREFIX + "/Positive02/");
Map properties = JDOHelper.getPropertiesFromJdoconfig(
ANONYMOUS_PERSISTENCE_MANAGER_FACTORY_NAME, loader);
assertNotNull("Anonymous PMF with no properties returned null",
properties);
assertTrue("Anonymous PMF with no properties had properties",
properties.size() == 0);
}
public void testPositive03_PMF0_PMFClassNameViaServicesLookup()
throws IOException {
URLClassLoader loader = new JDOConfigTestClassLoader(getClass()
.getClassLoader(), JDOCONFIG_CLASSPATH_PREFIX + "/Positive03/");
String expected = "class.positive03.pmf0";
String actual = getPMFClassNameViaServiceLookup(loader);
assertNotNull("No PMF name found via services lookup", actual);
assertEquals(expected, actual);
}
public void testPositive04_PMF0_PMFClassNameViaServicesLookup()
throws IOException {
URLClassLoader loader = new JDOConfigTestClassLoader(getClass()
.getClassLoader(), JDOCONFIG_CLASSPATH_PREFIX + "/Positive04/");
String expected = "class.positive04.pmf0";
String actual = getPMFClassNameViaServiceLookup(loader);
assertNotNull("No PMF name found via services lookup", actual);
assertEquals(expected, actual);
}
public void testPositive05_PMF0_PMFClassNameViaServicesLookup()
throws IOException {
URLClassLoader loader = new JDOConfigTestClassLoader(getClass()
.getClassLoader(), JDOCONFIG_CLASSPATH_PREFIX + "/Positive05/");
String expected = "class.positive05.pmf0";
String actual = getPMFClassNameViaServiceLookup(loader);
assertNotNull("No PMF name found via services lookup", actual);
assertEquals(expected, actual);
}
public void testPositive06_PMF0_GetAnonymousPMFProperties()
throws IOException {
URLClassLoader loader = new JDOConfigTestClassLoader(getClass()
.getClassLoader(), JDOCONFIG_CLASSPATH_PREFIX + "/Positive06/");
Map expected = prepareInitialExpectedMap("positive06.pmf0", 2, 0, true,
true);
Map actual = JDOHelper.getPropertiesFromJdoconfig(
ANONYMOUS_PERSISTENCE_MANAGER_FACTORY_NAME, loader);
assertNotNull("No properties found", actual);
assertEqualProperties(expected, actual);
}
public void testPositive07_PMF0_GetAnonymousPMFPropertiesWithPUName()
throws IOException {
URLClassLoader loader = new JDOConfigTestClassLoader(getClass()
.getClassLoader(), JDOCONFIG_CLASSPATH_PREFIX + "/Positive07/");
Map expected = prepareInitialExpectedMap("positive07.pmf0", 2, 0, true,
false);
Map actual = JDOHelper.getPropertiesFromJdoconfig(
ANONYMOUS_PERSISTENCE_MANAGER_FACTORY_NAME, loader);
assertNotNull("No properties found", actual);
assertEqualProperties(expected, actual);
}
public void testNegative00_EmptyJDOConfigXML() throws IOException {
try {
URLClassLoader loader = new JDOConfigTestClassLoader(getClass()
.getClassLoader(), JDOCONFIG_CLASSPATH_PREFIX
+ "/Negative0/");
JDOHelper.getPersistenceManagerFactory(loader);
fail("JDOHelper failed to throw JDOFatalUserException");
} catch (JDOFatalUserException x) {
// sunny day
}
}
public void testNegative01_NoPersistenceUnitsDefined() throws IOException {
try {
URLClassLoader loader = new JDOConfigTestClassLoader(getClass()
.getClassLoader(), JDOCONFIG_CLASSPATH_PREFIX
+ "/Negative01/");
JDOHelper.getPersistenceManagerFactory(loader);
fail("JDOHelper failed to throw JDOFatalUserException");
} catch (JDOFatalUserException x) {
// joy, sweet joy
}
}
public void testNegative02_DuplicateAnonymousPersistenceUnitsInSameConfig()
throws IOException {
try {
URLClassLoader loader = new JDOConfigTestClassLoader(getClass()
.getClassLoader(), JDOCONFIG_CLASSPATH_PREFIX
+ "/Negative02/");
JDOHelper.getPersistenceManagerFactory(loader);
fail("JDOHelper failed to throw JDOFatalUserException");
} catch (JDOFatalUserException x) {
// the cockles of my heart warmeth
}
}
public void testNegative03_DuplicateNamedPersistenceUnitsInSameConfig()
throws IOException {
try {
URLClassLoader loader = new JDOConfigTestClassLoader(getClass()
.getClassLoader(), JDOCONFIG_CLASSPATH_PREFIX
+ "/Negative03/");
JDOHelper.getPersistenceManagerFactory("name.negative03", loader);
fail("JDOHelper failed to throw JDOFatalUserException");
} catch (JDOFatalUserException x) {
// warm fuzzies
}
}
public void testNegative04_DuplicatePUNamePropertyInAttributeAndElement()
throws IOException {
try {
URLClassLoader loader = new JDOConfigTestClassLoader(getClass()
.getClassLoader(), JDOCONFIG_CLASSPATH_PREFIX
+ "/Negative04/");
JDOHelper.getPersistenceManagerFactory("name.negative04.value0",
loader);
fail("JDOHelper failed to throw JDOFatalUserException");
} catch (JDOFatalUserException x) {
// no cold pricklies
}
}
public void testNegative05_DuplicatePropertyInAttributeAndElement()
throws IOException {
try {
URLClassLoader loader = new JDOConfigTestClassLoader(getClass()
.getClassLoader(), JDOCONFIG_CLASSPATH_PREFIX
+ "/Negative05/");
JDOHelper.getPersistenceManagerFactory(loader);
fail("JDOHelper failed to throw JDOFatalUserException");
} catch (JDOFatalUserException x) {
// party!
}
}
public void testNegative06_DuplicatePUInDifferentConfigFiles()
throws IOException {
try {
URLClassLoader loader = new JDOConfigTestClassLoader(getClass()
.getClassLoader(), JDOCONFIG_CLASSPATH_PREFIX
+ "/Negative06/6a/", JDOCONFIG_CLASSPATH_PREFIX
+ "/Negative06/6b/");
JDOHelper.getPersistenceManagerFactory("name.negative06", loader);
fail("JDOHelper failed to throw JDOFatalUserException");
} catch (JDOFatalUserException x) {
// clear blue sky
}
}
public void testNegative07_EmptyServicesFile() throws IOException {
JDOConfigTestClassLoader testLoader = new JDOConfigTestClassLoader(
getClass().getClassLoader(), JDOCONFIG_CLASSPATH_PREFIX
+ "/Negative07/");
String shouldBeNull = getPMFClassNameViaServiceLookup(testLoader);
assertNull(shouldBeNull);
}
public void testNegative08_NoResourcesFound() {
String resource = "" + RANDOM.nextLong();
InputStream in = getClass().getClassLoader().getResourceAsStream(
resource);
assertNull(in);
// resource pretty much guaranteed not to exist
try {
JDOHelper.getPersistenceManagerFactory(resource);
fail("JDOHelper failed to throw JDOFatalUserException");
} catch (JDOFatalUserException x) {
// happy path
}
}
public void testNegative08_ServicesFileWithOnlyComments()
throws IOException {
JDOConfigTestClassLoader testLoader = new JDOConfigTestClassLoader(
getClass().getClassLoader(), JDOCONFIG_CLASSPATH_PREFIX
+ "/Negative08/");
String shouldBeNull = getPMFClassNameViaServiceLookup(testLoader);
assertNull(shouldBeNull);
}
public void testNegative09_MultipleInvalidClassesInDifferentServicesFiles()
throws IOException {
// no class name in Negative09/jdoconfig.xml
// 9a and 9b include services/javax.jdo.PersistenceManagerFactory
// with bad implementations
try {
URLClassLoader loader = new JDOConfigTestClassLoader(getClass()
.getClassLoader(), JDOCONFIG_CLASSPATH_PREFIX
+ "/Negative09/9a/", JDOCONFIG_CLASSPATH_PREFIX
+ "/Negative09/9b/", TEST_CLASSPATH, API_CLASSPATH);
JDOHelper.getPersistenceManagerFactory("name.negative09", loader);
fail("JDOHelper failed to throw JDOFatalUserException");
} catch (JDOFatalException x) {
Throwable[] nestedExceptions = x.getNestedExceptions();
if (nestedExceptions.length != 2) {
appendMessage("JDOHelper.getPersistenceManagerFactory wrong number of "
+ "nested exceptions. Expected 2, got "
+ nestedExceptions.length + "\n" + x);
}
for (int i = 0; i < nestedExceptions.length; ++i) {
Throwable exception = nestedExceptions[i];
if (!(exception instanceof JDOFatalException)) {
appendMessage("Nested exception "
+ exception.getClass().getName()
+ " is not a JDOFatalException.");
}
}
}
failOnError();
}
}
api/test/java/javax/jdo/JDOHelperTest.java 100664 60000 12500110371 20716 0 ustar mbouschen staff 0 0 /*
* 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 javax.jdo;
import java.io.File;
import java.io.InputStream;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;
import javax.jdo.pc.PCPoint;
import javax.jdo.spi.JDOImplHelper;
import javax.jdo.util.AbstractTest;
import javax.jdo.util.BatchTestRunner;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
/**
* Tests class javax.jdo.JDOHelper.
*
* TBD: implementation of testMakeDirty,
* TBD: testing interrogative methods for persistent instances
* TBD: getPMF for valid PMF class
*/
public class JDOHelperTest extends AbstractTest {
/** */
public static void main(String args[]) {
BatchTestRunner.run(JDOHelperTest.class);
}
/** The purpose of this test is simply to call some of the
* methods on a constructed instance of JDOHelper and verify that
* they do not throw exceptions. It is not a functional test.
* @since 2.1
*/
public void testConstructor() {
JDOHelper helper = new JDOHelper();
assertNull("getObjectId(null) returned non-null",
helper.getObjectId(null));
assertNull("getPersistenceManager(null) returned non-null",
helper.getPersistenceManager(null));
assertNull("getTransactionalObjectId(null) returned non-null",
helper.getTransactionalObjectId(null));
assertNull("getVersion(null) returned non-null",
helper.getVersion(null));
assertFalse("isDeleted(null) returned non-null",
helper.isDeleted(null));
assertFalse("isDetached(null) returned non-null",
helper.isDetached(null));
assertFalse("isDirty(null) returned non-null",
helper.isDirty(null));
assertFalse("isNew(null) returned non-null",
helper.isNew(null));
assertFalse("isPersistent(null) returned non-null",
helper.isPersistent(null));
assertFalse("isTransactional(null) returned non-null",
helper.isTransactional(null));
}
/** The purpose of this test is simply to call some of the
* methods on the static instance of JDOHelper and verify that
* they do not throw exceptions. It is not a functional test.
* @since 2.1
*/
public void testGetInstance() {
JDOHelper helper = JDOHelper.getInstance();
assertNull("getObjectId(null) returned non-null",
helper.getObjectId(null));
assertNull("getPersistenceManager(null) returned non-null",
helper.getPersistenceManager(null));
assertNull("getTransactionalObjectId(null) returned non-null",
helper.getTransactionalObjectId(null));
assertNull("getVersion(null) returned non-null",
helper.getVersion(null));
assertFalse("isDeleted(null) returned non-null",
helper.isDeleted(null));
assertFalse("isDetached(null) returned non-null",
helper.isDetached(null));
assertFalse("isDirty(null) returned non-null",
helper.isDirty(null));
assertFalse("isNew(null) returned non-null",
helper.isNew(null));
assertFalse("isPersistent(null) returned non-null",
helper.isPersistent(null));
assertFalse("isTransactional(null) returned non-null",
helper.isTransactional(null));
}
/** */
public void testGetPM() {
PCPoint p = new PCPoint(1, new Integer(1));
if (JDOHelper.getPersistenceManager(p) != null) {
fail("JDOHelper.getPersistenceManager should return null pm for non-persistent instance");
}
// TBD: test for persistent instance
}
/** */
public void testMakeDirty() {
// TBD: test JDOHelper.makeDirty(pc, fieldName);
}
/** */
public void testGetObjectId() {
PCPoint p = new PCPoint(1, new Integer(1));
if (JDOHelper.getObjectId(p) != null) {
fail("JDOHelper.getObjectId should return null ObjectId for non-persistent instance");
}
// TBD test JDOHelper.getObjectId(pc) for persistent instance
}
/** */
public void testGetTransactionObjectId() {
PCPoint p = new PCPoint(1, new Integer(1));
if (JDOHelper.getObjectId(p) != null) {
fail("JDOHelper.getTransactionalObjectId should return null ObjectId for non-persistent instance");
}
// TBD test JDOHelper.getTransactionalObjectId(pc) for persistent instance
}
/** */
public void testIsDirty() {
PCPoint p = new PCPoint(1, new Integer(1));
if (JDOHelper.isDirty(p)) {
fail("JDOHelper.isDirty should return false for non-persistent instance");
}
// TBD test JDOHelper.isDirty(pc) for persistent instance
}
/** */
public void testIsTransactional() {
PCPoint p = new PCPoint(1, new Integer(1));
if (JDOHelper.isTransactional(p)) {
fail("JDOHelper.isTransactional should return false for non-persistent instance");
}
// TBD test JDOHelper.isTransactional(pc) for persistent instance
}
/** */
public void testIsPersistent() {
PCPoint p = new PCPoint(1, new Integer(1));
if (JDOHelper.isPersistent(p)) {
fail("JDOHelper.isPersistent should return false for non-persistent instance");
}
// TBD test JDOHelper.isPersistent(pc) for persistent instance
}
/** */
public void testIsNew() {
PCPoint p = new PCPoint(1, new Integer(1));
if (JDOHelper.isNew(p)) {
fail("JDOHelper.isNew should return false for non-persistent instance");
}
// TBD test JDOHelper.isNew(pc) for persistent instance
}
/** */
public void testIsDeleted() {
PCPoint p = new PCPoint(1, new Integer(1));
if (JDOHelper.isDeleted(p)) {
fail("JDOHelper.isDeleted should return false for non-persistent instance");
}
// TBD test JDOHelper.isDeleted(pc) for persistent instance
}
/** Test null String resource with no class loader.
*/
public void testGetPMFNullResource() {
PersistenceManagerFactory pmf = null;
try {
pmf = JDOHelper.getPersistenceManagerFactory((String)null);
fail("Null resource name should result in JDOFatalUserException");
}
catch (JDOFatalUserException ex) {
if (verbose)
println("Caught expected exception " + ex);
}
}
/** Test null String resource with good class loader.
*/
public void testGetPMFNullResourceGoodClassLoader() {
PersistenceManagerFactory pmf = null;
try {
pmf = JDOHelper.getPersistenceManagerFactory((String)null, this.getClass().getClassLoader());
fail("Null resource name should result in JDOFatalUserException");
}
catch (JDOFatalUserException ex) {
if (verbose)
println("Caught expected exception " + ex);
}
}
/** Test bad String resource with no class loader.
*/
public void testGetPMFBadResource() {
PersistenceManagerFactory pmf = null;
try {
pmf = JDOHelper.getPersistenceManagerFactory("Whatever");
fail("Null resource name should result in JDOFatalUserException");
}
catch (JDOFatalUserException ex) {
if (verbose)
println("Caught expected exception " + ex);
}
}
/** Test null String resource with good class loader.
*/
public void testGetPMFBadResourceGoodClassLoader() {
PersistenceManagerFactory pmf = null;
try {
pmf = JDOHelper.getPersistenceManagerFactory("Whatever", this.getClass().getClassLoader());
fail("Null resource name should result in JDOFatalUserException");
}
catch (JDOFatalUserException ex) {
if (verbose)
println("Caught expected exception " + ex);
}
}
/** Test null File resource with no class loader.
*/
public void testGetPMFNullFile() {
PersistenceManagerFactory pmf = null;
try {
pmf = JDOHelper.getPersistenceManagerFactory((File)null);
fail("Null file should result in JDOFatalUserException");
}
catch (JDOFatalUserException ex) {
if (verbose)
println("Caught expected exception " + ex);
}
}
/** Test null File resource with good class loader.
*/
public void testGetPMFNullFileGoodClassLoader() {
PersistenceManagerFactory pmf = null;
try {
pmf = JDOHelper.getPersistenceManagerFactory((File)null, this.getClass().getClassLoader());
fail("Null file should result in JDOFatalUserException");
}
catch (JDOFatalUserException ex) {
if (verbose)
println("Caught expected exception " + ex);
}
}
/** Test bad File resource with no class loader.
*/
public void testGetPMFBadFile() {
PersistenceManagerFactory pmf = null;
try {
pmf = JDOHelper.getPersistenceManagerFactory(new File("Whatever"));
fail("Null file should result in JDOFatalUserException");
}
catch (JDOFatalUserException ex) {
if (verbose)
println("Caught expected exception " + ex);
}
}
/** Test bad File resource with good class loader.
*/
public void testGetPMFBadFileGoodClassLoader() {
PersistenceManagerFactory pmf = null;
try {
pmf = JDOHelper.getPersistenceManagerFactory(new File("Whatever"), this.getClass().getClassLoader());
fail("Null file should result in JDOFatalUserException");
}
catch (JDOFatalUserException ex) {
if (verbose)
println("Caught expected exception " + ex);
}
}
/** Test null JNDI resource name with no class loader.
*/
public void testGetPMFNullJNDI() {
PersistenceManagerFactory pmf = null;
try {
pmf = JDOHelper.getPersistenceManagerFactory((String)null, getInitialContext());
fail("Null JNDI resource name should result in JDOFatalUserException");
}
catch (JDOFatalUserException ex) {
if (verbose)
println("Caught expected exception " + ex);
}
}
/** Test null JNDI resource name with good class loader.
*/
public void testGetPMFNullJNDIGoodClassLoader() {
PersistenceManagerFactory pmf = null;
try {
pmf = JDOHelper.getPersistenceManagerFactory((String)null, getInitialContext(), this.getClass().getClassLoader());
fail("Null JNDI resource name should result in JDOFatalUserException");
}
catch (JDOFatalUserException ex) {
if (verbose)
println("Caught expected exception " + ex);
}
}
/** Test bad JNDI resource name with no class loader.
*/
public void testGetPMFBadJNDI() {
PersistenceManagerFactory pmf = null;
try {
pmf = JDOHelper.getPersistenceManagerFactory("Whatever", getInitialContext());
fail("Bad JNDI resource name should result in JDOFatalUserException");
}
catch (JDOFatalUserException ex) {
if (verbose)
println("Caught expected exception " + ex);
}
}
/** Test bad JNDI resource name with good class loader.
*/
public void testGetPMFBadJNDIGoodClassLoader() {
PersistenceManagerFactory pmf = null;
try {
pmf = JDOHelper.getPersistenceManagerFactory("Whatever", getInitialContext(), this.getClass().getClassLoader());
fail("Bad JNDI resource name should result in JDOFatalUserException");
}
catch (JDOFatalUserException ex) {
if (verbose)
println("Caught expected exception " + ex);
}
}
/** Test null stream with no class loader.
*/
public void testGetPMFNullStream() {
PersistenceManagerFactory pmf = null;
try {
pmf = JDOHelper.getPersistenceManagerFactory((InputStream)null);
fail("Null JNDI resource name should result in JDOFatalUserException");
}
catch (JDOFatalUserException ex) {
if (verbose)
println("Caught expected exception " + ex);
}
}
/** Test null stream with good class loader.
*/
public void testGetPMFNullStreamGoodClassLoader() {
PersistenceManagerFactory pmf = null;
try {
pmf = JDOHelper.getPersistenceManagerFactory((InputStream)null, this.getClass().getClassLoader());
fail("Null JNDI resource name should result in JDOFatalUserException");
}
catch (JDOFatalUserException ex) {
if (verbose)
println("Caught expected exception " + ex);
}
}
/** Test null ClassLoader.
*/
public void testGetPMFNullClassLoader() {
PersistenceManagerFactory pmf = null;
try {
pmf = JDOHelper.getPersistenceManagerFactory
("Whatever", (ClassLoader)null);
fail("Null ClassLoader should result in JDOFatalUserException");
}
catch (JDOFatalUserException ex) {
if (verbose)
println("Caught expected exception " + ex);
}
}
/** Test both null ClassLoaders.
*/
public void testGetPMFBothNullClassLoader() {
PersistenceManagerFactory pmf = null;
try {
pmf = JDOHelper.getPersistenceManagerFactory
("Whatever", (ClassLoader)null, (ClassLoader)null);
fail("Null ClassLoader should result in JDOFatalUserException");
}
catch (JDOFatalUserException ex) {
if (verbose)
println("Caught expected exception " + ex);
}
}
/** Test missing property javax.jdo.PersistenceManagerFactoryClass.
*/
public void testGetPMFNoClassNameProperty() {
PersistenceManagerFactory pmf = null;
try {
pmf = JDOHelper.getPersistenceManagerFactory(new Properties());
fail("Missing property PersistenceManagerFactoryClass should result in JDOFatalUserException ");
}
catch (JDOFatalUserException ex) {
if (verbose)
println("Caught expected exception " + ex);
}
}
/** Test bad PMF class does not exist.
*/
public void testBadPMFClassNotFound() {
PersistenceManagerFactory pmf = null;
Properties props = new Properties();
props.put("javax.jdo.PersistenceManagerFactoryClass",
"ThisClassDoesNotExist");
try {
pmf = JDOHelper.getPersistenceManagerFactory(props);
fail("Bad PersistenceManagerFactoryClass should result in JDOFatalUserException ");
}
catch (JDOFatalUserException ex) {
if (verbose)
println("Caught expected exception " + ex);
}
}
/** Test bad PMF class no method getPersistenceManagerFactory(Properties).
*/
public void testBadPMFNoGetPMFPropertiesMethod() {
PersistenceManagerFactory pmf = null;
Properties props = new Properties();
props.put("javax.jdo.PersistenceManagerFactoryClass",
"javax.jdo.JDOHelperTest$BadPMFNoGetPMFMethod");
try {
pmf = JDOHelper.getPersistenceManagerFactory(props);
fail("Bad PersistenceManagerFactory should result in JDOFatalInternalException ");
}
catch (JDOFatalInternalException ex) {
if (ex.getCause() instanceof NoSuchMethodException) {
if (verbose)
println("Caught expected exception " + ex);
} else {
fail("Bad PersistenceManagerFactory should result in " +
"JDOFatalInternalException with nested " +
"NoSuchMethodException. " +
"Actual nested exception was " + ex);
}
}
}
/** Test bad PMF class no method getPersistenceManagerFactory(Map).
*/
public void testBadPMFNoGetPMFMapMethod() {
PersistenceManagerFactory pmf = null;
Map props = new HashMap();
props.put("javax.jdo.PersistenceManagerFactoryClass",
"javax.jdo.JDOHelperTest$BadPMFNoGetPMFMethod");
try {
pmf = JDOHelper.getPersistenceManagerFactory(props);
fail("Bad PersistenceManagerFactory should result in JDOFatalInternalException ");
}
catch (JDOFatalInternalException ex) {
if (ex.getCause() instanceof NoSuchMethodException) {
if (verbose)
println("Caught expected exception " + ex);
} else {
fail("Bad PersistenceManagerFactory should result in " +
"JDOFatalInternalException with nested " +
"NoSuchMethodException. " +
"Actual nested exception was " + ex);
}
}
}
/** Test bad PMF class non-static getPMF method.
*/
public void testBadPMFNonStaticGetPMFMethod() {
PersistenceManagerFactory pmf = null;
Properties props = new Properties();
props.put("javax.jdo.PersistenceManagerFactoryClass",
"javax.jdo.JDOHelperTest$BadPMFNonStaticGetPMFMethod");
try {
pmf = JDOHelper.getPersistenceManagerFactory(props);
fail("Bad PersistenceManagerFactoryClass should result in JDOFatalInternalException ");
}
catch (JDOFatalInternalException ex) {
if (verbose)
println("Caught expected exception " + ex);
}
}
/** Test bad PMF class doesn't implement PMF.
*/
public void testBadPMFWrongReturnType() {
PersistenceManagerFactory pmf = null;
Properties props = new Properties();
props.put("javax.jdo.PersistenceManagerFactoryClass",
"javax.jdo.JDOHelperTest$BadPMFWrongReturnType");
try {
pmf = JDOHelper.getPersistenceManagerFactory(props);
fail("Bad PersistenceManagerFactoryClass should result in JDOFatalInternalException ");
}
catch (JDOFatalInternalException ex) {
if (verbose)
println("Caught expected exception " + ex);
}
}
/** Test bad PMF class getPersistenceManagerFactory throws Exception.
*/
public void testBadPMFGetPMFMethodThrowsJDOException() {
PersistenceManagerFactory pmf = null;
Properties props = new Properties();
props.put("javax.jdo.PersistenceManagerFactoryClass",
"javax.jdo.JDOHelperTest$BadPMFGetPMFMethodThrowsJDOException");
try {
pmf = JDOHelper.getPersistenceManagerFactory(props);
fail("BadPMFGetPMFMethodThrowsJDOException.GetPersistenceManagerFactory " +
"should result in JDOUnsupportedOptionException. " +
"No exception was thrown.");
}
catch (JDOUnsupportedOptionException ex) {
if (verbose)
println("Caught expected exception " + ex);
}
}
/** Test bad PMF class getPersistenceManagerFactory returns null.
*/
public void testBadPMFGetPMFMethodReturnsNull() {
PersistenceManagerFactory pmf = null;
Properties props = new Properties();
props.put("javax.jdo.PersistenceManagerFactoryClass",
"javax.jdo.JDOHelperTest$BadPMFGetPMFMethodReturnsNull");
try {
pmf = JDOHelper.getPersistenceManagerFactory(props);
fail("BadPMFGetPMFMethodReturnsNull.GetPersistenceManagerFactory " +
"should result in JDOFatalInternalException. " +
"No exception was thrown.");
}
catch (JDOFatalInternalException ex) {
if (verbose)
println("Caught expected exception " + ex);
}
}
/** Test that an unknown standard property cause JDOUserException.
*/
public void testUnknownStandardProperty() {
Properties p = new Properties();
p.setProperty("javax.jdo.unknown.standard.property", "value");
try {
JDOHelper.getPersistenceManagerFactory(p);
fail("testUnknownStandardProperties should result in JDOUserException. "
+ "No exception was thrown.");
} catch (JDOUserException x) {
if (verbose)
println("Caught expected exception " + x);
}
}
/**
* Test that unknown standard properties cause JDOUserException w/nested
* exceptions.
*/
public void testUnknownStandardProperties() {
Properties p = new Properties();
p.setProperty("javax.jdo.unknown.standard.property.1", "value");
p.setProperty("javax.jdo.unknown.standard.property.2", "value");
JDOUserException x = null;
try {
JDOHelper.getPersistenceManagerFactory(p);
fail("testUnknownStandardProperties should result in JDOUserException. "
+ "No exception was thrown.");
} catch (JDOUserException thrown) {
if (verbose)
println("Caught expected exception " + thrown);
x = thrown;
}
Throwable[] nesteds = x.getNestedExceptions();
assertNotNull(nesteds);
assertEquals("should have been 2 nested exceptions", 2, nesteds.length);
for (int i = 0; i < nesteds.length; i++) {
Throwable t = nesteds[i];
assertTrue("nested exception " + i
+ " should have been JDOUserException",
t instanceof JDOUserException);
}
}
private Context getInitialContext() {
try {
return new InitialContext();
} catch (NamingException ne) {
fail("Could not get Initial Context");
return null;
}
}
public static class BadPMFNoGetPMFMethod {
}
public static class BadPMFNonStaticGetPMFMethod {
public PersistenceManagerFactory
getPersistenceManagerFactory(Map props) {
return null;
}
}
public static class BadPMFWrongReturnType {
public static BadPMFWrongReturnType
getPersistenceManagerFactory(Map props) {
return new BadPMFWrongReturnType();
}
}
public static class BadPMFGetPMFMethodThrowsJDOException {
public static PersistenceManagerFactory
getPersistenceManagerFactory(Map props) {
throw new JDOUnsupportedOptionException(
"GetPMF method throws JDOUnsupportedOptionException");
}
}
public static class BadPMFGetPMFMethodThrowsJDOFatalInternalException {
public static PersistenceManagerFactory
getPersistenceManagerFactory(Map props) {
throw new JDOFatalInternalException(
"GetPMF method throws JDOFatalInternalException");
}
}
public static class BadPMFGetPMFMethodReturnsNull {
public static PersistenceManagerFactory
getPersistenceManagerFactory(Map props) {
return null;
}
}
}
api/test/java/javax/jdo/listener/InstanceLifecycleEventTest.java 100664 12421 12500110371 25361 0 ustar mbouschen staff 0 0 /*
* 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.
*/
/*
* InstanceLifecycleEventTest.java
*
*/
package javax.jdo.listener;
import javax.jdo.util.AbstractTest;
import javax.jdo.util.BatchTestRunner;
/**
* Tests that instances of InstanceLifecycleEvent can be created and
* that the source, type, and target instances are correct.
*/
public class InstanceLifecycleEventTest extends AbstractTest {
Object created = new Object();
Object loaded = new Object();
Object stored = new Object();
Object cleared = new Object();
Object deleted = new Object();
Object dirtied = new Object();
Object attached = new Object();
Object attachTarget = new Object();
Object detached = new Object();
Object detachTarget = new Object();
/** Creates a new instance of SingleFieldIdentityTest */
public InstanceLifecycleEventTest() {
}
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
BatchTestRunner.run(InstanceLifecycleEventTest.class);
}
public void testConstructorCreateEvent() {
InstanceLifecycleEvent e = new InstanceLifecycleEvent
(created, InstanceLifecycleEvent.CREATE);
assertSame ("Create source differs.", created, e.getSource());
assertEquals ("Create type differs.", InstanceLifecycleEvent.CREATE, e.getEventType());
}
public void testConstructorLoadEvent() {
InstanceLifecycleEvent e = new InstanceLifecycleEvent
(loaded, InstanceLifecycleEvent.LOAD);
assertSame ("Load source differs.", loaded, e.getSource());
assertEquals ("Load type differs.", InstanceLifecycleEvent.LOAD, e.getEventType());
}
public void testConstructorStoreEvent() {
InstanceLifecycleEvent e = new InstanceLifecycleEvent
(stored, InstanceLifecycleEvent.STORE);
assertSame ("Store source differs.", stored, e.getSource());
assertEquals ("Store type differs.", InstanceLifecycleEvent.STORE, e.getEventType());
}
public void testConstructorClearEvent() {
InstanceLifecycleEvent e = new InstanceLifecycleEvent
(cleared, InstanceLifecycleEvent.CLEAR);
assertSame ("Clear source differs.", cleared, e.getSource());
assertEquals ("Clear type differs.", InstanceLifecycleEvent.CLEAR, e.getEventType());
}
public void testConstructorDeleteEvent() {
InstanceLifecycleEvent e = new InstanceLifecycleEvent
(deleted, InstanceLifecycleEvent.DELETE);
assertSame ("Delete source differs.", deleted, e.getSource());
assertEquals ("Delete type differs.", InstanceLifecycleEvent.DELETE, e.getEventType());
}
public void testConstructorDirtyEvent() {
InstanceLifecycleEvent e = new InstanceLifecycleEvent
(dirtied, InstanceLifecycleEvent.DIRTY);
assertSame ("Dirty source differs.", dirtied, e.getSource());
assertEquals ("Dirty type differs.", InstanceLifecycleEvent.DIRTY, e.getEventType());
}
public void testConstructorDetachEvent() {
InstanceLifecycleEvent e = new InstanceLifecycleEvent
(detached, InstanceLifecycleEvent.DETACH, detachTarget);
assertSame ("Detach source differs.", detached, e.getSource());
assertEquals ("Detach type differs.", InstanceLifecycleEvent.DETACH, e.getEventType());
assertSame ("Detach target differs.", detachTarget, e.getTarget());
}
public void testConstructorAttachEvent() {
InstanceLifecycleEvent e = new InstanceLifecycleEvent
(attached, InstanceLifecycleEvent.ATTACH, attachTarget);
assertSame ("Attach source differs.", attached, e.getSource());
assertEquals ("Attach type differs.", InstanceLifecycleEvent.ATTACH, e.getEventType());
assertSame ("Attach target differs.", attachTarget, e.getTarget());
}
public void testIllegalConstructorTooSmall() {
try {
InstanceLifecycleEvent e = new InstanceLifecycleEvent (new Object(), -1);
} catch (IllegalArgumentException e) {
return; // good catch
}
fail ("Invalid event did not throw IllegalArgumentException.");
}
public void testIllegalConstructorTooBig() {
try {
InstanceLifecycleEvent e = new InstanceLifecycleEvent (new Object(), 8);
} catch (IllegalArgumentException e) {
return; // good catch
}
fail ("Invalid event did not throw IllegalArgumentException.");
}
}
api/test/java/javax/jdo/MockEnhancer.java 100664 10374 12500110371 20650 0 ustar mbouschen staff 0 0 /*
* 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 javax.jdo;
import java.lang.instrument.IllegalClassFormatException;
import java.security.ProtectionDomain;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Properties;
import static javax.jdo.Constants.PROPERTY_ENHANCER_VENDOR_NAME;
import static javax.jdo.Constants.PROPERTY_ENHANCER_VERSION_NUMBER;
import javax.jdo.metadata.JDOMetadata;
/**
* Tests class javax.jdo.Enhancer (main class).
*
*/
public class MockEnhancer implements JDOEnhancer {
static Properties props = new Properties();
static {
props.put(PROPERTY_ENHANCER_VENDOR_NAME, "Mock Enhancer");
props.put(PROPERTY_ENHANCER_VERSION_NUMBER, "2.3.0");
props.put("MockKey", "MockValue");
}
@SuppressWarnings("unused")
private boolean verbose;
private int numberOfElements;
private List classNames = new ArrayList();
private List jarNames = new ArrayList();
private List jdoNames = new ArrayList();
private List puNames = new ArrayList();
@SuppressWarnings("unused")
private String outputDirectory = null;
public MockEnhancer(){
}
public Properties getProperties() {
return props;
}
public JDOEnhancer setVerbose(boolean flag) {
this.verbose = flag;
return this;
}
public JDOEnhancer setOutputDirectory(String dirName) {
outputDirectory = dirName;
return this;
}
public JDOEnhancer setClassLoader(ClassLoader loader) {
// check to see if JDOHelper is loadable from the loader
try {
loader.loadClass("javax.jdo.JDOHelper");
} catch (ClassNotFoundException ex) {
// bad
throw new JDOFatalInternalException("Should be able to load JDOHelper from the class loader");
}
return this;
}
public JDOEnhancer addPersistenceUnit(String persistenceUnit) {
numberOfElements++;
this.puNames.add(persistenceUnit);
return this;
}
public JDOEnhancer addClass(String className, byte[] bytes) {
throw new UnsupportedOperationException("Not supported yet.");
}
public JDOEnhancer addClasses(String... classNames) {
numberOfElements += classNames.length;
this.classNames.addAll(Arrays.asList(classNames));
return this;
}
public JDOEnhancer addFiles(String... metadataFiles) {
numberOfElements += metadataFiles.length;
this.jdoNames.addAll(Arrays.asList(metadataFiles));
return this;
}
public JDOEnhancer addJar(String jarFileName) {
numberOfElements++;
this.jarNames.add(jarFileName);
return this;
}
public int enhance() {
return numberOfElements;
}
public int validate() {
return numberOfElements;
}
public byte[] getEnhancedBytes(String className) {
throw new UnsupportedOperationException("Not supported yet.");
}
public void registerMetadata(JDOMetadata metadata) {
throw new UnsupportedOperationException("Not supported yet.");
}
public JDOMetadata newMetadata() {
throw new UnsupportedOperationException("Not supported yet.");
}
public byte[] transform(ClassLoader loader, String className, Class classBeingRedefined, ProtectionDomain protectionDomain, byte[] classfileBuffer) throws IllegalClassFormatException {
throw new UnsupportedOperationException("Not supported yet.");
}
}
api/test/java/javax/jdo/ObjectStateTest.java 100664 21167 12500110371 21364 0 ustar mbouschen staff 0 0 /*
* 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 javax.jdo;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import javax.jdo.spi.PersistenceCapable;
import javax.jdo.util.AbstractTest;
import javax.jdo.util.BatchTestRunner;
/*
* ObjectStateTest.java
* This test class verifies the proper returned ObjectState for
* each life cycle state. See Table 3 in section 7.4.
*
* @since 2.1
*/
public class ObjectStateTest extends AbstractTest {
static final int PERSISTENT = 1;
static final int TRANSACTIONAL = 2;
static final int DIRTY = 4;
static final int NEW = 8;
static final int DELETED = 16;
static final int DETACHED = 32;
private static final Method jdoIsPersistent = getDeclaredMethod(
PersistenceCapable.class,
"jdoIsPersistent",
null);
private static final Method jdoIsTransactional = getDeclaredMethod(
PersistenceCapable.class,
"jdoIsTransactional",
null);
private static final Method jdoIsDirty = getDeclaredMethod(
PersistenceCapable.class,
"jdoIsDirty",
null);
private static final Method jdoIsNew = getDeclaredMethod(
PersistenceCapable.class,
"jdoIsNew",
null);
private static final Method jdoIsDeleted = getDeclaredMethod(
PersistenceCapable.class,
"jdoIsDeleted",
null);
private static final Method jdoIsDetached = getDeclaredMethod(
PersistenceCapable.class,
"jdoIsDetached",
null);
/** */
public static void main(String args[]) {
BatchTestRunner.run(ObjectStateTest.class);
}
public void testNull() {
PersistenceCapable mock = null;
assertObjectState("null", null, mock);
}
public void testTransient() {
PersistenceCapable mock = newMock(0);
assertObjectState("transient", ObjectState.TRANSIENT, mock);
}
public void testTransientClean() {
PersistenceCapable mock = newMock(TRANSACTIONAL);
assertObjectState("transient-clean", ObjectState.TRANSIENT_CLEAN, mock);
}
public void testTransientDirty() {
PersistenceCapable mock = newMock(TRANSACTIONAL+DIRTY);
assertObjectState("transient-dirty", ObjectState.TRANSIENT_DIRTY, mock);
}
public void testPersistentNew() {
PersistenceCapable mock = newMock(PERSISTENT+TRANSACTIONAL+NEW+DIRTY);
assertObjectState("persistent-new", ObjectState.PERSISTENT_NEW, mock);
}
public void testPersistentNontransactional() {
PersistenceCapable mock = newMock(PERSISTENT);
assertObjectState("persistent-nontransactional", ObjectState.HOLLOW_PERSISTENT_NONTRANSACTIONAL, mock);
}
public void testPersistentNontransactionalDirty() {
PersistenceCapable mock = newMock(PERSISTENT+DIRTY);
assertObjectState("persistent-nontransactional-dirty", ObjectState.PERSISTENT_NONTRANSACTIONAL_DIRTY, mock);
}
public void testPersistentClean() {
PersistenceCapable mock = newMock(PERSISTENT+TRANSACTIONAL);
assertObjectState("persistent-clean", ObjectState.PERSISTENT_CLEAN, mock);
}
public void testPersistentDirty() {
PersistenceCapable mock = newMock(PERSISTENT+TRANSACTIONAL+DIRTY);
assertObjectState("persistent-dirty", ObjectState.PERSISTENT_DIRTY, mock);
}
public void testPersistentDeleted() {
PersistenceCapable mock = newMock(PERSISTENT+TRANSACTIONAL+DIRTY+DELETED);
assertObjectState("persistent-deleted", ObjectState.PERSISTENT_DELETED, mock);
}
public void testPersistentNewDeleted() {
PersistenceCapable mock = newMock(PERSISTENT+TRANSACTIONAL+NEW+DIRTY+DELETED);
assertObjectState("persistent-new-deleted", ObjectState.PERSISTENT_NEW_DELETED, mock);
}
public void testDetachedClean() {
PersistenceCapable mock = newMock(DETACHED);
assertObjectState("detached-clean", ObjectState.DETACHED_CLEAN, mock);
}
public void testDetachedDirty() {
PersistenceCapable mock = newMock(DETACHED+DIRTY);
assertObjectState("detached-dirty", ObjectState.DETACHED_DIRTY, mock);
}
private void assertObjectState(String string,
ObjectState expected,
PersistenceCapable pc) {
ObjectState actual = JDOHelper.getObjectState(pc);
// test for == here because enums should be singleton
if (actual == expected)
return;
fail("ObjectState failure for " + string + NL +
"expected: " + expected +
", actual: " + actual);
}
/**
* Construct a new mock instance of PersistenceCapable that responds
* to methods jdoIsXXX by returning the bit value of its constructor
* masked with the value of XXX.
* @param i the sum of bit masks representing the life cycle state
* @return a mock instance of PersistenceCapable
*/
private PersistenceCapable newMock(final int i) {
return (PersistenceCapable)
Proxy.newProxyInstance(
PersistenceCapable.class.getClassLoader(),
new Class[] {PersistenceCapable.class},
new MockInvocationHandler(i));
}
private class MockInvocationHandler implements InvocationHandler {
/** States is the sum of all life cycle interrogatives.
*/
private int states;
/**
* Constructs an invocation handler with the specified bit fields set
* according to the sum of values of PERSISTENT, TRANSACTIONAL, DIRTY,
* NEW, DELETED, and DETACHED.
* @param i the bit field values for the life cycle interrogatives
*/
private MockInvocationHandler(int i) {
states = i;
}
/**
*
* @param object the PersistenceCapable instance
* @param method the method being invoked
* @param parameters parameters (should be null)
* @throws java.lang.Throwable unused
* @return for jdoIsXXX methods only, returns whether the
* bit field selected by the method is set in the
* mock handler
*/
public Object invoke(Object object, Method method, Object[] parameters)
throws Throwable {
if (method.equals(jdoIsPersistent)) {
return (0 != (states & PERSISTENT));
}
if (method.equals(jdoIsTransactional)) {
return (0 != (states & TRANSACTIONAL));
}
if (method.equals(jdoIsDirty)) {
return (0 != (states & DIRTY));
}
if (method.equals(jdoIsNew)) {
return (0 != (states & NEW));
}
if (method.equals(jdoIsDeleted)) {
return (0 != (states & DELETED));
}
if (method.equals(jdoIsDetached)) {
return (0 != (states & DETACHED));
}
fail("Unexpected method called: " + method.getName());
return Boolean.FALSE; // not reached
}
}
private static Method getDeclaredMethod
(Class clazz, String methodName, Class[] parameters) {
try {
@SuppressWarnings("unchecked")
Method result = clazz.getDeclaredMethod(methodName, parameters);
return result;
} catch (Exception ex) {
// human-readable class.methodName(parameter[,parameter])
StringBuffer sb = new StringBuffer(methodName);
String delimiter = "(";
for (Class parameter: parameters) {
sb.append(delimiter);
sb.append(parameter.getName());
delimiter = ",";
}
sb.append(")");
throw new RuntimeException
("getDeclaredMethod for " + clazz.getName() + "." +
sb + " threw..." + ex);
}
}
}
api/test/java/javax/jdo/pc/PCPoint.java 100664 33676 12500110371 20243 0 ustar mbouschen staff 0 0 /*
* 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 javax.jdo.pc;
import java.io.*;
import java.util.*;
import javax.jdo.PersistenceManager;
import javax.jdo.spi.*;
import javax.jdo.spi.PersistenceCapable;
/**
* This is a hand-enhanced version of a simple class with two fields. The
* enhanced code assumes datastore identity.
*
* @version 2.0
*/
public class PCPoint
implements PersistenceCapable
{
public int x;
public Integer y;
// JDO generated fields
protected transient StateManager jdoStateManager;
protected transient byte jdoFlags;
private static final int jdoInheritedFieldCount = 0;
private static final String jdoFieldNames[] = { "x", "y" };
private static final Class jdoFieldTypes[];
private static final byte jdoFieldFlags[] = {
(byte)(PersistenceCapable.CHECK_READ + PersistenceCapable.CHECK_WRITE +
PersistenceCapable.SERIALIZABLE),
(byte)(PersistenceCapable.CHECK_READ + PersistenceCapable.CHECK_WRITE +
PersistenceCapable.SERIALIZABLE),
};
private static final Class jdoPersistenceCapableSuperclass;
static
{
jdoFieldTypes = (new Class[] {
Integer.TYPE, sunjdo$classForName$("java.lang.Integer")
});
jdoPersistenceCapableSuperclass = null;
JDOImplHelper.registerClass(
sunjdo$classForName$("javax.jdo.pc.PCPoint"),
jdoFieldNames, jdoFieldTypes, jdoFieldFlags,
jdoPersistenceCapableSuperclass, new PCPoint());
}
/** JDO required no-args constructor. */
public PCPoint() { }
/** Constructor. */
public PCPoint(int x, Integer y) {
jdoSetx(this, x);
jdoSety(this, y);
}
/** */
public void setX(int x) {
jdoSetx(this, x);
}
/** */
public int getX() {
return jdoGetx(this);
}
/** */
public void setY(Integer y) {
jdoSety(this, y);
}
/** */
public Integer getY() {
return jdoGety(this);
}
/** */
public boolean equals(Object o) {
if (o == null || !(o instanceof PCPoint))
return false;
PCPoint other = (PCPoint)o;
if (jdoGetx(this) != jdoGetx(other))
return false;
if (jdoGety(this) == null)
return jdoGety(other) == null;
if (jdoGety(other) == null)
return jdoGety(this) == null;
else
return jdoGety(this).intValue() == jdoGety(other).intValue();
}
/** */
public int hashCode() {
int code = getX();
if (getY() != null) {
code += getY().intValue();
}
return code;
}
/** */
public String toString() {
return "PCPoint(x: " + getX() + ", y: " + getY() + ")";
}
// Generated methods in least-derived PersistenceCapable class
public final boolean jdoIsPersistent() {
StateManager statemanager = jdoStateManager;
if (statemanager != null)
return statemanager.isPersistent(this);
else
return false;
}
public final boolean jdoIsTransactional() {
StateManager statemanager = jdoStateManager;
if (statemanager != null)
return statemanager.isTransactional(this);
else
return false;
}
public final boolean jdoIsNew() {
StateManager statemanager = jdoStateManager;
if (statemanager != null)
return statemanager.isNew(this);
else
return false;
}
public final boolean jdoIsDirty() {
StateManager statemanager = jdoStateManager;
if (statemanager != null)
return statemanager.isDirty(this);
else
return false;
}
public final boolean jdoIsDeleted() {
StateManager statemanager = jdoStateManager;
if (statemanager != null)
return statemanager.isDeleted(this);
else
return false;
}
public final boolean jdoIsDetached() {
return false;
}
public final void jdoMakeDirty(String s) {
StateManager statemanager = jdoStateManager;
if (statemanager != null)
statemanager.makeDirty(this, s);
}
public final PersistenceManager jdoGetPersistenceManager() {
StateManager statemanager = jdoStateManager;
if (statemanager != null)
return statemanager.getPersistenceManager(this);
else
return null;
}
public final Object jdoGetObjectId() {
StateManager statemanager = jdoStateManager;
if (statemanager != null)
return statemanager.getObjectId(this);
else
return null;
}
public final Object jdoGetTransactionalObjectId() {
StateManager statemanager = jdoStateManager;
if (statemanager != null)
return statemanager.getTransactionalObjectId(this);
else
return null;
}
public final Object jdoGetVersion() {
StateManager statemanager = jdoStateManager;
if (statemanager != null)
return statemanager.getVersion(this);
else
return null;
}
public final synchronized void jdoReplaceStateManager(
StateManager statemanager) {
StateManager statemanager1 = jdoStateManager;
if (statemanager1 != null) {
jdoStateManager = statemanager1.replacingStateManager(
this, statemanager);
return;
}
else {
JDOImplHelper.checkAuthorizedStateManager(statemanager);
jdoStateManager = statemanager;
jdoFlags = PersistenceCapable.LOAD_REQUIRED;
return;
}
}
public final void jdoReplaceFlags() {
StateManager statemanager = jdoStateManager;
if (statemanager != null)
jdoFlags = statemanager.replacingFlags(this);
}
public final void jdoReplaceFields(int fields[]) {
if (fields == null)
throw new IllegalArgumentException("fields is null");
int i = fields.length;
for(int j = 0; j < i; j++)
jdoReplaceField(fields[j]);
}
public final void jdoProvideFields(int fields[]) {
if (fields == null)
throw new IllegalArgumentException("fields is null");
int i = fields.length;
for(int j = 0; j < i; j++)
jdoProvideField(fields[j]);
}
protected final void jdoPreSerialize() {
StateManager statemanager = jdoStateManager;
if (statemanager != null)
statemanager.preSerialize(this);
}
// Generated methods in PersistenceCapable root classes and all classes
// that declare objectid-class in xml metadata:
public void jdoCopyKeyFieldsToObjectId(
PersistenceCapable.ObjectIdFieldSupplier objectidfieldsupplier,
Object obj) { }
public void jdoCopyKeyFieldsToObjectId(Object obj) {
}
public void jdoCopyKeyFieldsFromObjectId(
PersistenceCapable.ObjectIdFieldConsumer objectidfieldconsumer,
Object obj) { }
protected void jdoCopyKeyFieldsFromObjectId(Object obj) {
}
public Object jdoNewObjectIdInstance() {
return null;
}
public Object jdoNewObjectIdInstance(Object o) {
return null;
}
// Generated methods in all PersistenceCapable classes
public PersistenceCapable jdoNewInstance(StateManager statemanager) {
PCPoint pcpoint = new PCPoint();
pcpoint.jdoFlags = PersistenceCapable.LOAD_REQUIRED;
pcpoint.jdoStateManager = statemanager;
return pcpoint;
}
public PersistenceCapable jdoNewInstance(
StateManager statemanager, Object obj) {
PCPoint pcpoint = new PCPoint();
pcpoint.jdoCopyKeyFieldsFromObjectId(obj);
pcpoint.jdoFlags = PersistenceCapable.LOAD_REQUIRED;
pcpoint.jdoStateManager = statemanager;
return pcpoint;
}
protected static int jdoGetManagedFieldCount() {
return 2;
}
public static final int jdoGetx(PCPoint pcpoint) {
if (pcpoint.jdoFlags <= PersistenceCapable.READ_WRITE_OK)
return pcpoint.x;
StateManager statemanager = pcpoint.jdoStateManager;
if (statemanager == null)
return pcpoint.x;
if (statemanager.isLoaded(pcpoint, jdoInheritedFieldCount + 0))
return pcpoint.x;
else
return statemanager.getIntField(
pcpoint, jdoInheritedFieldCount + 0, pcpoint.x);
}
public static final Integer jdoGety(PCPoint pcpoint) {
if (pcpoint.jdoFlags <= PersistenceCapable.READ_WRITE_OK)
return pcpoint.y;
StateManager statemanager = pcpoint.jdoStateManager;
if (statemanager == null)
return pcpoint.y;
if (statemanager.isLoaded(pcpoint, jdoInheritedFieldCount + 1))
return pcpoint.y;
else
return (Integer)statemanager.getObjectField(
pcpoint, jdoInheritedFieldCount + 1, pcpoint.y);
}
public static final void jdoSetx(PCPoint pcpoint, int i) {
if (pcpoint.jdoFlags == PersistenceCapable.READ_WRITE_OK) {
pcpoint.x = i;
return;
}
StateManager statemanager = pcpoint.jdoStateManager;
if (statemanager == null) {
pcpoint.x = i;
return;
}
else {
statemanager.setIntField(
pcpoint, jdoInheritedFieldCount + 0, pcpoint.x, i);
return;
}
}
public static final void jdoSety(PCPoint pcpoint, Integer integer) {
if (pcpoint.jdoFlags == PersistenceCapable.READ_WRITE_OK) {
pcpoint.y = integer;
return;
}
StateManager statemanager = pcpoint.jdoStateManager;
if (statemanager == null) {
pcpoint.y = integer;
return;
}
else {
statemanager.setObjectField(pcpoint, jdoInheritedFieldCount + 1, pcpoint.y, integer);
return;
}
}
public void jdoReplaceField(int field) {
StateManager statemanager = jdoStateManager;
switch(field - jdoInheritedFieldCount) {
case 0:
if (statemanager == null) {
throw new IllegalStateException("jdoStateManager is null");
}
else {
x = statemanager.replacingIntField(this, field);
return;
}
case 1:
if (statemanager == null) {
throw new IllegalStateException("jdoStateManager is null");
}
else {
y = (Integer)statemanager.replacingObjectField(this, field);
return;
}
}
throw new IllegalArgumentException("field number out of range");
}
public void jdoProvideField(int field) {
StateManager statemanager = jdoStateManager;
switch(field - jdoInheritedFieldCount) {
case 0:
if (statemanager == null) {
throw new IllegalStateException("jdoStateManager is null");
}
else {
statemanager.providedIntField(this, field, x);
return;
}
case 1:
if (statemanager == null) {
throw new IllegalStateException("jdoStateManager is null");
}
else {
statemanager.providedObjectField(this, field, y);
return;
}
}
throw new IllegalArgumentException("field number out of range");
}
public void jdoCopyFields(Object obj, int fieldNumbers[]) {
if (jdoStateManager == null)
throw new IllegalStateException("jdoStateManager is null");
if (!(obj instanceof PCPoint))
throw new ClassCastException(obj.getClass().getName());
if (fieldNumbers == null)
throw new IllegalArgumentException("fieldNumber is null");
PCPoint pcpoint = (PCPoint)obj;
if (pcpoint.jdoStateManager != jdoStateManager)
throw new IllegalArgumentException("wrong jdoStateManager");
int i = fieldNumbers.length;
for(int j = 0; j < i; j++)
jdoCopyField(pcpoint, fieldNumbers[j]);
}
protected final void jdoCopyField(PCPoint pcpoint, int fieldNumber)
{
switch(fieldNumber - jdoInheritedFieldCount) {
case 0:
if (pcpoint == null) {
throw new IllegalArgumentException("pcpoint is null");
}
else {
x = pcpoint.x;
return;
}
case 1:
if (pcpoint == null) {
throw new IllegalArgumentException("pcpoint is null");
}
else {
y = pcpoint.y;
return;
}
}
throw new IllegalArgumentException("field number out of range");
}
private void writeObject(java.io.ObjectOutputStream out)
throws java.io.IOException {
jdoPreSerialize();
out.defaultWriteObject();
}
protected static final Class sunjdo$classForName$(String s) {
try {
return Class.forName(s);
}
catch(ClassNotFoundException ex) {
throw new NoClassDefFoundError(ex.getMessage());
}
}
}
api/test/java/javax/jdo/PMFMapMapTest.java 100664 37651 12500110371 20700 0 ustar mbouschen staff 0 0 /*
* 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 javax.jdo;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.net.MalformedURLException;
import javax.jdo.util.AbstractTest;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.Properties;
import junit.framework.TestSuite;
import javax.jdo.util.BatchTestRunner;
/**
*
* Tests class javax.jdo.JDOHelper for calls to the impl's static method
* getPersistenceManagerFactory(Map overrides, Map props).
*
*/
public class PMFMapMapTest extends AbstractJDOConfigTest {
static String expectedDriverName = "Jane Doe";
static String expectedDriverName4NamedPMF = "Larry";
static String expectedDriverNameWithOverrides = "Gerard Manley Hopkins";
static String PMFName = "BookSearch";
static String resourceDir = "/Pmfmapmap01/";
static String propsDir = "/Pmfmapmap02/";
static String pmfServiceClass = "javax.jdo.stub.StubPMF";
static String propertiesFile = "propsfile.props";
PersistenceManagerFactory pmf;
Properties props;
Properties overrides;
URLClassLoader resourceClassLoader;
ClassLoader saveContextClassLoader;
public static void main(String args[]) {
BatchTestRunner.run(PMFMapMapTest.class);
}
/**
* {@inheritDoc}
*
* @return {@inheritDoc}
*/
public static TestSuite suite() {
return new TestSuite(PMFMapMapTest.class);
}
void setupResourceClassLoader(String dir) throws IOException {
switch (dir.charAt(dir.length() - 1)) {
case '\\':
dir = dir.substring(0, dir.length() - 1) + '/';
break;
case '/':
break;
default:
if (new File(dir).isDirectory()) {
dir += '/';
}
}
resourceClassLoader = new JDOConfigTestClassLoader(getClass()
.getClassLoader(), JDOCONFIG_CLASSPATH_PREFIX + dir);
}
/*
* static PersistenceManagerFactory getPersistenceManagerFactory() Get the
* anonymous PersistenceManagerFactory configured via the standard
* configuration file resource "META-INF/jdoconfig.xml", using the current
* thread's context class loader to locate the configuration file
* resource(s).
*/
public void testJDOConfigXML() throws IOException {
setupResourceClassLoader(resourceDir);
Thread.currentThread().setContextClassLoader(resourceClassLoader);
try {
pmf = JDOHelper.getPersistenceManagerFactory();
} catch (JDOFatalUserException ex) {
fail("Failed to find PersistenceManagerFactoryClass."
+ ex.getMessage());
}
String driverName = pmf.getConnectionDriverName();
if (!expectedDriverName.equals(driverName)) {
fail("Bad ConnectionDriverName(): " + driverName
+ ". Expected: \"" + expectedDriverName + "\"");
}
}
/*
* static PersistenceManagerFactory getPersistenceManagerFactory
* (java.lang.ClassLoader pmfClassLoader) Get the anonymous
* PersistenceManagerFactory configured via the standard configuration file
* resource "META-INF/jdoconfig.xml", using the given class loader.
*/
public void testJDOConfigXMLWithLoader() throws IOException {
setupResourceClassLoader(resourceDir);
try {
pmf = JDOHelper.getPersistenceManagerFactory(resourceClassLoader);
} catch (JDOFatalUserException ex) {
fail("Failed to find PersistenceManagerFactoryClass."
+ ex.getMessage());
}
String driverName = pmf.getConnectionDriverName();
if (!expectedDriverName.equals(driverName)) {
fail("Bad ConnectionDriverName(): " + driverName
+ ". Expected: \"" + expectedDriverName + "\"");
}
}
/*
* static PersistenceManagerFactory getPersistenceManagerFactory(
* java.io.File propsFile) Returns a PersistenceManagerFactory configured
* based on the properties stored in the file at propsFile.
*/
public void testPropsFile() throws IOException {
setupResourceClassLoader(propsDir);
Thread.currentThread().setContextClassLoader(resourceClassLoader);
try {
pmf = JDOHelper.getPersistenceManagerFactory(propertiesFile);
} catch (JDOFatalUserException ex) {
fail("Failed to find PersistenceManagerFactoryClass."
+ ex.getMessage());
}
String driverName = pmf.getConnectionDriverName();
if (!expectedDriverName.equals(driverName)) {
fail("Bad ConnectionDriverName(): " + driverName
+ ". Expected: \"" + expectedDriverName + "\"");
}
}
/*
* static PersistenceManagerFactory getPersistenceManagerFactory(
* java.io.File propsFile, java.lang.ClassLoader loader) Returns a
* PersistenceManagerFactory configured based on the properties stored in
* the file at propsFile.
*/
public void testPropsFileAndLoader() throws IOException {
setupResourceClassLoader(propsDir);
try {
pmf = JDOHelper.getPersistenceManagerFactory(propertiesFile,
resourceClassLoader);
} catch (JDOFatalUserException ex) {
fail("Failed to find PersistenceManagerFactoryClass."
+ ex.getMessage());
}
String driverName = pmf.getConnectionDriverName();
if (!expectedDriverName.equals(driverName)) {
fail("Bad ConnectionDriverName(): " + driverName
+ ". Expected: \"" + expectedDriverName + "\"");
}
}
/*
* static PersistenceManagerFactory getPersistenceManagerFactory(
* java.io.InputStream stream) Returns a PersistenceManagerFactory
* configured based on the Properties stored in the input stream at stream.
*/
public void testInputStream() throws IOException {
props = new Properties();
props.setProperty(PROPERTY_PERSISTENCE_MANAGER_FACTORY_CLASS,
pmfServiceClass);
props.setProperty(PROPERTY_CONNECTION_DRIVER_NAME, expectedDriverName);
ByteArrayOutputStream outstream = new ByteArrayOutputStream();
try {
props.store(outstream, "");
} catch (IOException ex) {
fail(ex.getMessage());
}
InputStream byteArrayInputStream = new ByteArrayInputStream(
outstream.toByteArray());
setupResourceClassLoader(resourceDir);
Thread.currentThread().setContextClassLoader(resourceClassLoader);
try {
pmf = JDOHelper.getPersistenceManagerFactory(byteArrayInputStream);
} catch (JDOFatalUserException ex) {
fail("Failed to find PersistenceManagerFactoryClass."
+ ex.getMessage());
}
String driverName = pmf.getConnectionDriverName();
if (!expectedDriverName.equals(driverName)) {
fail("Bad ConnectionDriverName(): " + driverName
+ ". Expected: \"" + expectedDriverName + "\"");
}
}
/*
* static PersistenceManagerFactory getPersistenceManagerFactory(
* java.io.InputStream stream, java.lang.ClassLoader loader) Returns a
* PersistenceManagerFactory configured based on the Properties stored in
* the input stream at stream.
*/
public void testInputStreamWithLoader() throws IOException {
props = new Properties();
props.setProperty(PROPERTY_PERSISTENCE_MANAGER_FACTORY_CLASS,
pmfServiceClass);
props.setProperty(PROPERTY_CONNECTION_DRIVER_NAME, expectedDriverName);
ByteArrayOutputStream outstream = new ByteArrayOutputStream();
try {
props.store(outstream, "");
} catch (IOException ex) {
fail(ex.getMessage());
}
InputStream byteArrayInputStream = new ByteArrayInputStream(
outstream.toByteArray());
setupResourceClassLoader(resourceDir);
try {
pmf = JDOHelper.getPersistenceManagerFactory(byteArrayInputStream,
resourceClassLoader);
} catch (JDOFatalUserException ex) {
fail("Failed to find PersistenceManagerFactoryClass."
+ ex.getMessage());
}
String driverName = pmf.getConnectionDriverName();
if (!expectedDriverName.equals(driverName)) {
fail("Bad ConnectionDriverName(): " + driverName
+ ". Expected: \"" + expectedDriverName + "\"");
}
}
/*
* static PersistenceManagerFactory getPersistenceManagerFactory(
* java.util.Map props) Get a PersistenceManagerFactory based on a
* Properties instance, using the current thread's context class loader to
* locate the PersistenceManagerFactory class.
*/
public void testProperties() throws IOException {
props = new Properties();
props.setProperty(PROPERTY_PERSISTENCE_MANAGER_FACTORY_CLASS,
pmfServiceClass);
props.setProperty(PROPERTY_CONNECTION_DRIVER_NAME, expectedDriverName);
setupResourceClassLoader(resourceDir);
Thread.currentThread().setContextClassLoader(resourceClassLoader);
try {
pmf = JDOHelper.getPersistenceManagerFactory(props);
} catch (JDOFatalUserException ex) {
fail("Failed to find PersistenceManagerFactoryClass."
+ ex.getMessage());
}
String driverName = pmf.getConnectionDriverName();
if (!expectedDriverName.equals(driverName)) {
fail("Bad ConnectionDriverName(): " + driverName
+ ". Expected: \"" + expectedDriverName + "\"");
}
}
/*
* static PersistenceManagerFactory getPersistenceManagerFactory(
* java.util.Map props, java.lang.ClassLoader pmfClassLoader) Get a
* PersistenceManagerFactory based on a Map and a class loader.
*/
public void testPropertiesAndLoader() throws IOException {
props = new Properties();
props.setProperty(PROPERTY_PERSISTENCE_MANAGER_FACTORY_CLASS,
pmfServiceClass);
props.setProperty(PROPERTY_CONNECTION_DRIVER_NAME, expectedDriverName);
setupResourceClassLoader(resourceDir);
try {
pmf = JDOHelper.getPersistenceManagerFactory(props,
resourceClassLoader);
} catch (JDOFatalUserException ex) {
fail("Failed to find PersistenceManagerFactoryClass."
+ ex.getMessage());
}
String driverName = pmf.getConnectionDriverName();
if (!expectedDriverName.equals(driverName)) {
fail("Bad ConnectionDriverName(): " + driverName
+ ". Expected: \"" + expectedDriverName + "\"");
}
}
/*
* static PersistenceManagerFactory getPersistenceManagerFactory
* (java.util.Map overrides, java.lang.String name) Returns a named
* PersistenceManagerFactory or persistence unit.
*/
public void testNamedPMFWithOverrides() throws IOException {
overrides = new Properties();
overrides.setProperty(PROPERTY_CONNECTION_DRIVER_NAME,
expectedDriverNameWithOverrides);
setupResourceClassLoader(resourceDir);
Thread.currentThread().setContextClassLoader(resourceClassLoader);
try {
pmf = JDOHelper.getPersistenceManagerFactory(overrides, PMFName);
} catch (JDOFatalUserException ex) {
fail("Failed to find PersistenceManagerFactoryClass."
+ ex.getMessage());
}
String driverName = pmf.getConnectionDriverName();
if (!expectedDriverNameWithOverrides.equals(driverName)) {
fail("Bad ConnectionDriverName(): " + driverName
+ ". Expected: \"" + expectedDriverNameWithOverrides
+ "\"");
}
}
/*
* static PersistenceManagerFactory getPersistenceManagerFactory(
* java.util.Map overrides, java.lang.String name,
* java.lang.ClassLoader resourceLoader) Returns a named
* PersistenceManagerFactory or persistence unit.
*/
public void testNamedPMFWithOverridesAndLoader() throws IOException {
overrides = new Properties();
overrides.setProperty(PROPERTY_CONNECTION_DRIVER_NAME,
expectedDriverNameWithOverrides);
setupResourceClassLoader(resourceDir);
try {
pmf = JDOHelper.getPersistenceManagerFactory(overrides, PMFName,
resourceClassLoader);
} catch (JDOFatalUserException ex) {
fail("Failed to find PersistenceManagerFactoryClass."
+ ex.getMessage());
}
String driverName = pmf.getConnectionDriverName();
if (!expectedDriverNameWithOverrides.equals(driverName)) {
fail("Bad ConnectionDriverName(): " + driverName
+ ". Expected: \"" + expectedDriverNameWithOverrides
+ "\"");
}
}
/*
* static PersistenceManagerFactory getPersistenceManagerFactory(
* java.util.Map overrides, java.lang.String name,
* java.lang.ClassLoader resourceLoader, java.lang.ClassLoader pmfLoader)
* Returns a PersistenceManagerFactory configured based on the properties
* stored in the resource at name, or, if not found, returns a
* PersistenceManagerFactory with the given name or, if not found, returns a
* javax.persistence.EntityManagerFactory cast to a
* PersistenceManagerFactory.
*/
public void testNamedPMFWithOverridesAndTwoLoaders() throws IOException {
overrides = new Properties();
overrides.setProperty(PROPERTY_CONNECTION_DRIVER_NAME,
expectedDriverNameWithOverrides);
setupResourceClassLoader(resourceDir);
try {
pmf = JDOHelper.getPersistenceManagerFactory(overrides, PMFName,
resourceClassLoader, Thread.currentThread()
.getContextClassLoader());
} catch (JDOFatalUserException ex) {
fail("Failed to find PersistenceManagerFactoryClass. "
+ ex.getMessage());
}
String driverName = pmf.getConnectionDriverName();
if (!expectedDriverNameWithOverrides.equals(driverName)) {
fail("Bad ConnectionDriverName(): " + driverName
+ ". Expected: \"" + expectedDriverNameWithOverrides
+ "\"");
}
}
/*
* static PersistenceManagerFactory getPersistenceManagerFactory(
* java.lang.String name) Returns a named PersistenceManagerFactory or
* persistence unit.
*/
public void testNamedPMF() throws IOException {
setupResourceClassLoader(resourceDir);
Thread.currentThread().setContextClassLoader(resourceClassLoader);
try {
pmf = JDOHelper.getPersistenceManagerFactory(PMFName);
} catch (JDOFatalUserException ex) {
fail("Failed to find PersistenceManagerFactoryClass. "
+ ex.getMessage());
}
String driverName = pmf.getConnectionDriverName();
if (!expectedDriverName4NamedPMF.equals(driverName)) {
fail("Bad ConnectionDriverName(): " + driverName
+ ". Expected: \"" + expectedDriverName4NamedPMF + "\"");
}
}
/*
* static PersistenceManagerFactory getPersistenceManagerFactory
* (java.lang.String name, java.lang.ClassLoader loader) Returns a named
* PersistenceManagerFactory or persistence unit.
*/
public void testNamedPMFWithLoader() throws IOException {
setupResourceClassLoader(resourceDir);
try {
pmf = JDOHelper.getPersistenceManagerFactory(PMFName,
resourceClassLoader);
} catch (JDOFatalUserException ex) {
fail("Failed to find PersistenceManagerFactoryClass. "
+ ex.getMessage());
}
String driverName = pmf.getConnectionDriverName();
if (!expectedDriverName4NamedPMF.equals(driverName)) {
fail("Bad ConnectionDriverName(): " + driverName
+ ". Expected: \"" + expectedDriverName4NamedPMF + "\"");
}
}
/*
* static PersistenceManagerFactory getPersistenceManagerFactory(
* java.lang.String name, java.lang.ClassLoader resourceLoader,
* java.lang.ClassLoader pmfLoader) Returns a named
* PersistenceManagerFactory or persistence unit.
*/
public void testNamedPMFWithTwoLoaders() throws IOException {
setupResourceClassLoader(resourceDir);
try {
pmf = JDOHelper.getPersistenceManagerFactory(PMFName,
resourceClassLoader, Thread.currentThread()
.getContextClassLoader());
} catch (JDOFatalUserException ex) {
fail("Failed to find PersistenceManagerFactoryClass. "
+ ex.getMessage());
}
String driverName = pmf.getConnectionDriverName();
if (!expectedDriverName4NamedPMF.equals(driverName)) {
fail("Bad ConnectionDriverName(): " + driverName
+ ". Expected: \"" + expectedDriverName4NamedPMF + "\"");
}
}
}
api/test/java/javax/jdo/PMFProxy.java 100664 3576 12500110371 17765 0 ustar mbouschen staff 0 0 /*
* 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 javax.jdo;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
*
*
*/
public class PMFProxy implements InvocationHandler {
private String connectionDriverName;
public static PersistenceManagerFactory newInstance() {
PersistenceManagerFactory pmf =
(PersistenceManagerFactory) Proxy.newProxyInstance(
PMFProxy.class.getClassLoader(),
new Class[]{PersistenceManagerFactory.class},
new PMFProxy());
return pmf;
}
/*
*
*/
public Object invoke(Object proxy, Method m, Object[] args)
throws Exception {
Object result = null;
if (m.getName().equals("getConnectionDriverName")) {
result = connectionDriverName;
} else if (m.getName().equals("setConnectionDriverName")) {
connectionDriverName = (String) args[0];
} else {
throw new Exception(
"Unexpected invocation of method: " + m);
}
return result;
}
}
api/test/java/javax/jdo/PMFService.java 100664 3530 12500110371 20232 0 ustar mbouschen staff 0 0 /*
* 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 javax.jdo;
import java.util.Map;
/**
*
*
*/
public class PMFService implements Constants{
public PMFService() {
}
public static PersistenceManagerFactory getPersistenceManagerFactory(
Map overrides, Map props) {
PersistenceManagerFactory pmf =
(PersistenceManagerFactory) PMFProxy.newInstance();
setPMFProperties(pmf, props, overrides);
return pmf;
}
public static PersistenceManagerFactory getPersistenceManagerFactory(
Map props) {
PersistenceManagerFactory pmf =
(PersistenceManagerFactory) PMFProxy.newInstance();
setPMFProperties(pmf, props, null);
return pmf;
}
private static void setPMFProperties(PersistenceManagerFactory pmf,
Map props, Map overrides) {
pmf.setConnectionDriverName((String)props.get(PROPERTY_CONNECTION_DRIVER_NAME));
if (overrides != null) {
pmf.setConnectionDriverName((String)overrides.get(PROPERTY_CONNECTION_DRIVER_NAME));
}
}
}
api/test/java/javax/jdo/schema/XMLTest.java 100664 11526 12500110371 21053 0 ustar mbouschen staff 0 0 /*
* 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 javax.jdo.schema;
import java.io.File;
import java.io.IOException;
import java.io.FilenameFilter;
import java.util.Arrays;
import java.util.List;
import javax.jdo.JDOFatalException;
import javax.jdo.util.AbstractTest;
import javax.jdo.util.BatchTestRunner;
import javax.jdo.util.XMLTestUtil;
import javax.xml.parsers.*;
import org.w3c.dom.Document;
import org.xml.sax.*;
import org.xml.sax.helpers.*;
/**
* Tests schema files.
*
*/
public class XMLTest extends AbstractTest {
/** */
protected static String BASEDIR = System.getProperty("basedir", ".");
/** File prefix */
protected static final String FILE_PREFIX = BASEDIR + "/test/schema/";
/** */
protected static final File JDO_XSD_FILE =
new File(BASEDIR + "/target/classes/javax/jdo/jdo_2_2.xsd");
/** */
protected static final File ORM_XSD_FILE =
new File(BASEDIR + "/target/classes/javax/jdo/orm_2_2.xsd");
/** */
protected static final File JDOQUERY_XSD_FILE =
new File(BASEDIR + "/target/classes/javax/jdo/jdoquery_2_2.xsd");
/** .xsd files */
protected static final File[] XSD_FILES =
new File[] {JDO_XSD_FILE, ORM_XSD_FILE, JDOQUERY_XSD_FILE};
/** XSD metadata files. */
protected static File[] positiveXSDJDO = getFiles("Positive", "-xsd.jdo");
protected static File[] negativeXSDJDO = getFiles("Negative", "-xsd.jdo");
protected static File[] positiveXSDORM = getFiles("Positive", "-xsd.orm");
protected static File[] negativeXSDORM = getFiles("Negative", "-xsd.orm");
protected static File[] positiveXSDJDOQUERY = getFiles("Positive", "-xsd.jdoquery");
protected static File[] negativeXSDJDOQUERY = getFiles("Negative", "-xsd.jdoquery");
/** DTD metadata files. */
protected static File[] positiveDTDJDO = getFiles("Positive", "-dtd.jdo");
protected static File[] negativeDTDJDO = getFiles("Negative", "-dtd.jdo");
protected static File[] positiveDTDORM = getFiles("Positive", "-dtd.orm");
protected static File[] negativeDTDORM = getFiles("Negative", "-dtd.orm");
protected static File[] positiveDTDJDOQUERY = getFiles("Positive", "-dtd.jdoquery");
protected static File[] negativeDTDJDOQUERY = getFiles("Negative", "-dtd.jdoquery");
/** Returns array of files of matching file names. */
protected static File[] getFiles(final String prefix, final String suffix) {
FilenameFilter filter = new FilenameFilter () {
public boolean accept(File file, String name) {
return (name.startsWith(prefix) && name.endsWith(suffix));
}
};
File dir = new File(FILE_PREFIX);
return dir.listFiles(filter);
}
/** */
public static void main(String args[]) {
BatchTestRunner.run(XMLTest.class);
}
/** Test XSD files jdo.xsd, orm.xsd, and jdoquery.xsd. */
public void testXSD() {
XMLTestUtil util = new XMLTestUtil();
appendMessage(util.checkXMLNonValidating(XSD_FILES));
failOnError();
}
/** Test XSD based .jdo, .orm and .jdoquery files. */
public void testXSDBased() {
XMLTestUtil util = new XMLTestUtil();
appendMessage(util.checkXML(positiveXSDJDO, true));
appendMessage(util.checkXML(negativeXSDJDO, false));
appendMessage(util.checkXML(positiveXSDORM, true));
appendMessage(util.checkXML(negativeXSDORM, false));
appendMessage(util.checkXML(positiveXSDJDOQUERY, true));
appendMessage(util.checkXML(negativeXSDJDOQUERY, false));
failOnError();
}
/** Test DTD based .jdo, .orm and .jdoquery files. */
public void testDTDBased() {
XMLTestUtil util = new XMLTestUtil();
appendMessage(util.checkXML(positiveDTDJDO, true));
appendMessage(util.checkXML(negativeDTDJDO, false));
appendMessage(util.checkXML(positiveDTDORM, true));
appendMessage(util.checkXML(negativeDTDORM, false));
appendMessage(util.checkXML(positiveDTDJDOQUERY, true));
appendMessage(util.checkXML(negativeDTDJDOQUERY, false));
failOnError();
}
}
api/test/java/javax/jdo/spi/JDOImplHelperTest.java 100664 24574 12500110371 22353 0 ustar mbouschen staff 0 0 /*
* 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 javax.jdo.spi;
import java.util.Collection;
import java.util.Properties;
import javax.jdo.Constants;
import javax.jdo.JDOHelper;
import javax.jdo.JDOUserException;
import javax.jdo.pc.PCPoint;
import javax.jdo.util.AbstractTest;
import javax.jdo.util.BatchTestRunner;
/**
* Tests class javax.jdo.spi.JDOImplHelper.
*
* Missing: testNewInstance + testNewObjectIdInstance
* Missing: tests for JDOImplHelper methods: copyKeyFieldsToObjectId and
* copyKeyFieldsFromObjectId.
*/
public class JDOImplHelperTest extends AbstractTest {
/** */
private RegisterClassEvent event;
/** */
public static void main(String args[]) {
BatchTestRunner.run(JDOImplHelperTest.class);
}
/** */
public void setUp() {
// make sure PCClass is loaded before any tests are run
PCPoint p = new PCPoint(1, new Integer(1));
}
/** */
public void testGetFieldNames() {
JDOImplHelper implHelper = JDOImplHelper.getInstance();
String[] fieldNames = implHelper.getFieldNames(PCPoint.class);
if (fieldNames == null) {
fail("array of field names is null");
}
if (fieldNames.length != 2) {
fail("Unexpected length of fieldNames; expected 2, got " +
fieldNames.length);
}
if (!fieldNames[0].equals("x")) {
fail("Unexpected field; expected x, got " + fieldNames[0]);
}
if (!fieldNames[1].equals("y")) {
fail("Unexpected field; expected y, got " + fieldNames[1]);
}
}
/** */
public void testGetFieldTypes() {
JDOImplHelper implHelper = JDOImplHelper.getInstance();
Class[] fieldTypes = implHelper.getFieldTypes(PCPoint.class);
if (fieldTypes == null) {
fail("array of field types is null");
}
if (fieldTypes.length != 2) {
fail("Unexpected length of fieldTypes; expected 2, got " +
fieldTypes.length);
}
if (fieldTypes[0] != int.class) {
fail("Unexpected field type; expected int, got " +
fieldTypes[0]);
}
if (fieldTypes[1] != Integer.class) {
fail("Unexpected field type; expected Integer, got " +
fieldTypes[1]);
}
}
/** */
public void testGetFieldFlags() {
byte expected = (byte) (PersistenceCapable.CHECK_READ +
PersistenceCapable.CHECK_WRITE + PersistenceCapable.SERIALIZABLE);
JDOImplHelper implHelper = JDOImplHelper.getInstance();
byte[] fieldFlags = implHelper.getFieldFlags(PCPoint.class);
if (fieldFlags == null) {
fail("array of field flags is null");
}
if (fieldFlags.length != 2) {
fail("Unexpected length of fieldFlags; expected 2, got " +
fieldFlags.length);
}
if (fieldFlags[0] != expected) {
fail("Unexpected field flag; expected " + expected +
", got " + fieldFlags[0]);
}
if (fieldFlags[1] != expected) {
fail("Unexpected field flag; expected " + expected +
", got " + fieldFlags[1]);
}
}
/** */
public void testGetPCSuperclass() {
JDOImplHelper implHelper = JDOImplHelper.getInstance();
Class pcSuper =
implHelper.getPersistenceCapableSuperclass(PCPoint.class);
if (pcSuper != null) {
fail("Wrong pc superclass of PCPoint; expected null, got " +
pcSuper);
}
}
/** */
public void testNewInstance() {
// TBD: test JDOImplHelper.newInstance(pcClass, sm) and
// JDOImplHelper.newInstance(pcClass, sm, oid)
}
/** */
public void testNewObjectIdInstance() {
// TBD: test JDOImplHelper.newObjectIdInstance(pcClass)
}
/** */
public void testClassRegistration() {
JDOImplHelper implHelper = JDOImplHelper.getInstance();
Collection registeredClasses = implHelper.getRegisteredClasses();
// test whether PCPoint is registered
if (!registeredClasses.contains(PCPoint.class)) {
fail("Missing registration of pc class PCPoint");
}
// Save registered meta data for restoring
String[] fieldNames = implHelper.getFieldNames(PCPoint.class);
Class[] fieldTypes = implHelper.getFieldTypes(PCPoint.class);
byte[] fieldFlags = implHelper.getFieldFlags(PCPoint.class);
Class pcSuperclass = implHelper.getPersistenceCapableSuperclass(PCPoint.class);
// test unregisterClass with null parameter
try {
implHelper.unregisterClass(null);
fail("Missing exception when calling unregisterClass(null)");
}
catch (NullPointerException ex) {
// expected exception => OK
}
// test unregister PCPoint class
implHelper.unregisterClass(PCPoint.class);
registeredClasses = implHelper.getRegisteredClasses();
if (registeredClasses.contains(PCPoint.class)) {
fail("PCPoint still registered");
}
// register PCPoint again
JDOImplHelper.registerClass(PCPoint.class, fieldNames, fieldTypes,
fieldFlags, pcSuperclass, new PCPoint());
}
/** */
public void testClassListenerRegistration() {
JDOImplHelper implHelper = JDOImplHelper.getInstance();
// add listener and check event
event = null;
RegisterClassListener listener = new SimpleListener();
implHelper.addRegisterClassListener(listener);
JDOImplHelper.registerClass(JDOImplHelperTest.class, new String[0],
new Class[0], new byte[0], null, null);
if (event == null) {
fail("Missing event ");
}
// remove listener and check event
event = null;
implHelper.removeRegisterClassListener(listener);
JDOImplHelper.registerClass(JDOImplHelperTest.class, new String[0],
new Class[0], new byte[0], null, null);
if (event != null) {
fail("Unexpected event " + event);
}
}
/**
* Test that an unknown standard property causes JDOUserException.
*/
public void testUnknownStandardProperty() {
Properties p = new Properties();
p.setProperty("javax.jdo.unknown.standard.property", "value");
JDOUserException x = null;
try {
JDOImplHelper.assertOnlyKnownStandardProperties(p);
fail("testUnknownStandardProperty should result in JDOUserException. "
+ "No exception was thrown.");
} catch (JDOUserException thrown) {
if (verbose)
println("Caught expected exception " + thrown);
x = thrown;
}
assertNull("should have had no nested exceptions",
x.getNestedExceptions());
}
/**
* Test that unknown standard properties cause JDOUserException w/nested
* exceptions.
*/
public void testUnknownStandardProperties() {
Properties p = new Properties();
p.setProperty("javax.jdo.unknown.standard.property.1", "value");
p.setProperty("javax.jdo.unknown.standard.property.2", "value");
JDOUserException x = null;
try {
JDOImplHelper.assertOnlyKnownStandardProperties(p);
fail("testUnknownStandardProperties should result in JDOUserException. "
+ "No exception was thrown.");
} catch (JDOUserException thrown) {
if (verbose)
println("Caught expected exception " + thrown);
x = thrown;
}
Throwable[] nesteds = x.getNestedExceptions();
assertNotNull(nesteds);
assertEquals("should have been 2 nested exceptions", 2, nesteds.length);
for (int i = 0; i < nesteds.length; i++) {
Throwable t = nesteds[i];
assertTrue("nested exception " + i
+ " should have been JDOUserException",
t instanceof JDOUserException);
}
}
/**
* Test that unknown non-standard properties & well-formed listener
* properties don't cause JDOUserException.
*/
public void testUnknownNonStandardPropertiesAndListeners() {
Properties p = new Properties();
p.put("unknown.property", "value");
p.put(new Object(), "value");
p.put(Constants.PROPERTY_PREFIX_INSTANCE_LIFECYCLE_LISTENER
+ "unknown.listener", "value");
JDOImplHelper.assertOnlyKnownStandardProperties(p);
}
/**
* Test that all JDO standard properties don't cause JDOUserException.
*/
public void testOnlyStandardProperties() {
Properties props = new Properties();
for (String p : JDOImplHelper.USER_CONFIGURABLE_STANDARD_PROPERTIES) {
props.setProperty(p, p);
}
JDOImplHelper.assertOnlyKnownStandardProperties(props);
}
/**
* Test that an known standard property in mixed case succeeds.
*/
public void testKnownStandardPropertyThatDiffersInCaseOnly() {
Properties p = new Properties();
p.setProperty("JaVaX.jDo.oPtIoN.CoNNectionDRiVerNamE", "value");
p.setProperty("jAvAx.JdO.lIsTeNeR.InstaNceLifeCycleLisTener.foo.Bar", "");
JDOImplHelper.assertOnlyKnownStandardProperties(p);
}
/** */
class SimpleListener implements RegisterClassListener {
/** */
public void registerClass(RegisterClassEvent event) {
JDOImplHelperTest.this.event = event;
}
}
}
api/test/java/javax/jdo/spi/StateInterrogationTest.java 100664 46720 12500110371 23577 0 ustar mbouschen staff 0 0 /*
* 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 javax.jdo.spi;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import javax.jdo.JDOHelper;
import javax.jdo.PersistenceManager;
import javax.jdo.util.AbstractTest;
import javax.jdo.util.BatchTestRunner;
/**
* This class tests the StateInterrogation interface. The test is in
* several parts:
*
Add and remove the StateInterrogation instance
* test interrogatives to return the correct answer
* test getters to return the correct answer
* test makeDirty to return.
* For the methods returning Object, return null if the object
* is not managed by this StateInterrogation.
*
*
For the methods returning Boolean, return null if the object
* is not managed by this StateInterrogation.
*
*
For the makeDirty method, return false if the object
* is not managed by this StateInterrogation.
*/
private static class StateInterrogationImpl implements StateInterrogation {
private int id;
public int hashCode() {
return id;
}
private StateInterrogationImpl(int id) {
this.id = id;
}
public boolean equals(Object other) {
if (other.getClass() != StateInterrogationImpl.class) return false;
return (other.hashCode() == id);
}
private boolean isMine(Object pc) {
return pc.hashCode() == id;
}
public javax.jdo.PersistenceManager getPersistenceManager(Object pc) {
return isMine(pc)?pmProxies[id]:null;
}
public Object getObjectId(Object pc) {
return isMine(pc)?new ObjectIdImpl(id):null;
}
public Object getTransactionalObjectId(Object pc) {
return isMine(pc)?new ObjectIdImpl(id):null;
}
public Object getVersion(Object pc) {
return isMine(pc)?new ObjectIdImpl(id):null;
}
public Boolean isDeleted(Object pc) {
if (isMine(pc)) {
return (pc.hashCode()==1)?Boolean.TRUE:Boolean.FALSE;
} else return null;
}
public Boolean isDetached(Object pc) {
if (isMine(pc)) {
return (pc.hashCode()==1)?Boolean.TRUE:Boolean.FALSE;
} else return null;
}
public Boolean isDirty(Object pc) {
if (isMine(pc)) {
return ((NonBinaryCompatiblePersistenceCapable)pc).isDirty()
?Boolean.TRUE:Boolean.FALSE;
} else return null;
}
public Boolean isNew(Object pc) {
if (isMine(pc)) {
return (pc.hashCode()==1)?Boolean.TRUE:Boolean.FALSE;
} else return null;
}
public Boolean isPersistent(Object pc) {
if (isMine(pc)) {
return (pc.hashCode()==1)?Boolean.TRUE:Boolean.FALSE;
} else return null;
}
public Boolean isTransactional(Object pc) {
if (isMine(pc)) {
return (pc.hashCode()==1)?Boolean.TRUE:Boolean.FALSE;
} else return null;
}
public boolean makeDirty(Object pc, String fieldName) {
if (isMine(pc)) {
((NonBinaryCompatiblePersistenceCapable)pc).setDirty(true);
return true;
} else return false;
}
}
/**
* The non-binary-compatible PersistenceCapable class.
*/
public static class NonBinaryCompatiblePersistenceCapable {
private int id;
private boolean dirty = false;
private NonBinaryCompatiblePersistenceCapable(int id) {
this.id = id;
}
public int hashCode() {
return id;
}
public void setDirty(boolean dirty) {
this.dirty = dirty;
}
public boolean isDirty() {
return dirty;
}
}
/**
* The non-binary-compatible object id class.
*/
public static class ObjectIdImpl {
private int id;
private ObjectIdImpl(int id) {
this.id = id;
}
public int hashCode() {
return id;
}
public boolean equals(Object other) {
if (other.getClass() != ObjectIdImpl.class) return false;
return (other.hashCode() == id);
}
}
/**
* The non-binary-compatible InvocationHandler class
* for PersistenceManager proxy.
*/
private static class InvocationHandlerImpl implements InvocationHandler {
private int id;
private InvocationHandlerImpl(int id) {
this.id = id;
}
public int hashCode() {
return id;
}
public boolean equals(Object other) {
if (other.getClass() != ObjectIdImpl.class) return false;
return (other.hashCode() == id);
}
public Object invoke(Object obj, java.lang.reflect.Method method,
Object[] params) throws Throwable {
String name = method.getName();
if (name == "hashCode") {
return new Integer(id);
} else if (name == "equals") {
Object other = params[0];
if (!(other instanceof PersistenceManager)) return Boolean.FALSE;
int otherid = Proxy.getInvocationHandler(other).hashCode();
if (otherid == id) return Boolean.TRUE;
return Boolean.FALSE;
}
return null;
}
}
} api/test/java/javax/jdo/stub/StubPMF.java 100664 40257 12500110371 20553 0 ustar mbouschen staff 0 0 /*
* 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 javax.jdo.stub;
import java.util.Collection;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
import javax.jdo.Constants;
import javax.jdo.FetchGroup;
import javax.jdo.PersistenceManager;
import javax.jdo.PersistenceManagerFactory;
import javax.jdo.datastore.DataStoreCache;
import javax.jdo.listener.InstanceLifecycleListener;
import javax.jdo.metadata.JDOMetadata;
import javax.jdo.metadata.TypeMetadata;
public class StubPMF implements PersistenceManagerFactory, Constants {
public static PersistenceManagerFactory getPersistenceManagerFactory(
Map props) {
StubPMF pmf = new StubPMF();
pmf.setProperties(props);
for (Object key : props.keySet()) {
if (!(key instanceof String)) {
continue;
}
String prop = (String) key;
if (!prop.startsWith("javax.jdo.")) {
continue;
}
pmf.setProperty(prop, props.get(prop));
}
return pmf;
}
public static PersistenceManagerFactory getPersistenceManagerFactory(
Map overrides, Map props) {
StubPMF pmf = new StubPMF();
pmf.setProperties(props);
pmf.setProperties(overrides);
return pmf;
}
String name;
String persistenceManagerFactoryClassName;
String spiResourceName;
String optionConnectionUserName;
String optionConnectionPassword;
String optionConnectionURL;
String optionConnectionDriverName;
String optionConnectionFactoryName;
Object optionConnectionFactory;
String optionConnectionFactory2Name;
Object optionConnectionFactory2;
boolean optionMultithreaded;
String optionMapping;
boolean optionOptimistic;
boolean optionRetainValues;
boolean optionRestoreValues;
boolean optionNontransactionalRead;
boolean optionNontransactionalWrite;
boolean optionIgnoreCache;
boolean optionDetachAllOnCommit;
boolean optionCopyOnAttach;
String optionName;
String optionPersistenceUnitName;
String optionServerTimeZoneID;
String optionTransactionType;
boolean optionReadOnly;
String optionTransactionIsolationLevel;
Integer optionDatastoreReadTimeoutMillis;
Integer optionDatastoreWriteTimeoutMillis;
Properties properties = new Properties();
public String getConnectionUserName() {
return optionConnectionUserName;
}
public void setConnectionUserName(String connectionUserName) {
this.optionConnectionUserName = connectionUserName;
}
public void setConnectionPassword(String connectionPassword) {
this.optionConnectionPassword = connectionPassword;
}
public String getConnectionURL() {
return optionConnectionURL;
}
public void setConnectionURL(String connectionURL) {
this.optionConnectionURL = connectionURL;
}
public String getConnectionDriverName() {
return optionConnectionDriverName;
}
public void setConnectionDriverName(String connectionDriverName) {
this.optionConnectionDriverName = connectionDriverName;
}
public String getConnectionFactoryName() {
return optionConnectionFactoryName;
}
public void setConnectionFactoryName(String connectionFactoryName) {
this.optionConnectionFactoryName = connectionFactoryName;
}
public Object getConnectionFactory() {
return optionConnectionFactory;
}
public void setConnectionFactory(Object connectionFactory) {
this.optionConnectionFactory = connectionFactory;
}
public String getConnectionFactory2Name() {
return optionConnectionFactory2Name;
}
public void setConnectionFactory2Name(String connectionFactory2Name) {
this.optionConnectionFactory2Name = connectionFactory2Name;
}
public Object getConnectionFactory2() {
return optionConnectionFactory2;
}
public void setConnectionFactory2(Object connectionFactory2) {
this.optionConnectionFactory2 = connectionFactory2;
}
public boolean getMultithreaded() {
return optionMultithreaded;
}
public void setMultithreaded(boolean multithreaded) {
this.optionMultithreaded = multithreaded;
}
public String getMapping() {
return optionMapping;
}
public void setMapping(String mapping) {
this.optionMapping = mapping;
}
public boolean getOptimistic() {
return optionOptimistic;
}
public void setOptimistic(boolean optimistic) {
this.optionOptimistic = optimistic;
}
public boolean getRetainValues() {
return optionRetainValues;
}
public void setRetainValues(boolean retainValues) {
this.optionRetainValues = retainValues;
}
public boolean getRestoreValues() {
return optionRestoreValues;
}
public void setRestoreValues(boolean restoreValues) {
this.optionRestoreValues = restoreValues;
}
public boolean getNontransactionalRead() {
return optionNontransactionalRead;
}
public void setNontransactionalRead(boolean nontransactionalRead) {
this.optionNontransactionalRead = nontransactionalRead;
}
public boolean getNontransactionalWrite() {
return optionNontransactionalWrite;
}
public void setNontransactionalWrite(boolean nontransactionalWrite) {
this.optionNontransactionalWrite = nontransactionalWrite;
}
public boolean getIgnoreCache() {
return optionIgnoreCache;
}
public void setIgnoreCache(boolean ignoreCache) {
this.optionIgnoreCache = ignoreCache;
}
public boolean getDetachAllOnCommit() {
return optionDetachAllOnCommit;
}
public void setDetachAllOnCommit(boolean detachAllOnCommit) {
this.optionDetachAllOnCommit = detachAllOnCommit;
}
public boolean getCopyOnAttach() {
return optionCopyOnAttach;
}
public void setCopyOnAttach(boolean copyOnAttach) {
this.optionCopyOnAttach = copyOnAttach;
}
public String getName() {
return optionName;
}
public void setName(String name) {
this.optionName = name;
}
public String getPersistenceUnitName() {
return optionPersistenceUnitName;
}
public void setPersistenceUnitName(String persistenceUnitName) {
this.optionPersistenceUnitName = persistenceUnitName;
}
public String getServerTimeZoneID() {
return optionServerTimeZoneID;
}
public void setServerTimeZoneID(String serverTimeZoneID) {
this.optionServerTimeZoneID = serverTimeZoneID;
}
public String getTransactionType() {
return optionTransactionType;
}
public void setTransactionType(String transactionType) {
this.optionTransactionType = transactionType;
}
public boolean getReadOnly() {
return optionReadOnly;
}
public void setReadOnly(boolean readOnly) {
this.optionReadOnly = readOnly;
}
public String getTransactionIsolationLevel() {
return optionTransactionIsolationLevel;
}
public void setTransactionIsolationLevel(String transactionIsolationLevel) {
this.optionTransactionIsolationLevel = transactionIsolationLevel;
}
public Integer getDatastoreReadTimeoutMillis() {
return optionDatastoreReadTimeoutMillis;
}
public void setDatastoreReadTimeoutMillis(Integer datastoreReadTimeoutMillis) {
this.optionDatastoreReadTimeoutMillis = datastoreReadTimeoutMillis;
}
public Integer getDatastoreWriteTimeoutMillis() {
return optionDatastoreWriteTimeoutMillis;
}
public void setDatastoreWriteTimeoutMillis(
Integer datastoreWriteTimeoutMillis) {
this.optionDatastoreWriteTimeoutMillis = datastoreWriteTimeoutMillis;
}
public void close() {
throw new UnsupportedOperationException("not implemented");
}
public boolean isClosed() {
return true;
}
public PersistenceManager getPersistenceManager() {
throw new UnsupportedOperationException("not implemented");
}
public PersistenceManager getPersistenceManagerProxy() {
throw new UnsupportedOperationException("not implemented");
}
public PersistenceManager getPersistenceManager(String userid,
String password) {
throw new UnsupportedOperationException("not implemented");
}
public Properties getProperties() {
return properties;
}
public Collection supportedOptions() {
throw new UnsupportedOperationException("not implemented");
}
public DataStoreCache getDataStoreCache() {
return new DataStoreCache() {
public void evict(Object oid) {
}
public void evictAll() {
}
public void evictAll(Object... oids) {
}
public void evictAll(Collection oids) {
}
public void evictAll(Class pcClass, boolean subclasses) {
}
public void evictAll(boolean subclasses, Class pcClass) {
}
public void pin(Object oid) {
}
public void pinAll(Collection oids) {
}
public void pinAll(Object... oids) {
}
public void pinAll(Class pcClass, boolean subclasses) {
}
public void pinAll(boolean subclasses, Class pcClass) {
}
public void unpin(Object oid) {
}
public void unpinAll(Collection oids) {
}
public void unpinAll(Object... oids) {
}
public void unpinAll(Class pcClass, boolean subclasses) {
}
public void unpinAll(boolean subclasses, Class pcClass) {
}
};
}
public void addInstanceLifecycleListener(
InstanceLifecycleListener listener, Class[] classes) {
throw new UnsupportedOperationException("not implemented");
}
public void removeInstanceLifecycleListener(
InstanceLifecycleListener listener) {
throw new UnsupportedOperationException("not implemented");
}
public void addFetchGroups(FetchGroup... groups) {
throw new UnsupportedOperationException("not implemented");
}
public void removeFetchGroups(FetchGroup... groups) {
throw new UnsupportedOperationException("not implemented");
}
public void removeAllFetchGroups() {
throw new UnsupportedOperationException("not implemented");
}
@SuppressWarnings("rawtypes")
public FetchGroup getFetchGroup(Class cls, String name) {
throw new UnsupportedOperationException("not implemented");
}
@SuppressWarnings("rawtypes")
public Set getFetchGroups() {
throw new UnsupportedOperationException("not implemented");
}
public void registerMetadata(JDOMetadata metadata) {
throw new UnsupportedOperationException("not implemented");
}
public JDOMetadata newMetadata() {
throw new UnsupportedOperationException("not implemented");
}
public TypeMetadata getMetadata(String className) {
throw new UnsupportedOperationException("not implemented");
}
void setSpiResourceName(String spiPropertiesResourceName) {
this.spiResourceName = spiPropertiesResourceName;
}
public String getSpiPropertiesResourceName() {
return spiResourceName;
}
void setPersistenceManagerFactoryClass(String className) {
this.persistenceManagerFactoryClassName = className;
}
public String getPersistenceManagerFactoryClass() {
return this.persistenceManagerFactoryClassName;
}
void setProperty(String name, Object value) {
String val = value.toString();
if (name.equals(PROPERTY_PERSISTENCE_MANAGER_FACTORY_CLASS)) {
setPersistenceManagerFactoryClass(val);
return;
}
if (name.equals(PROPERTY_CONNECTION_DRIVER_NAME)) {
setConnectionDriverName(val);
return;
}
if (name.equals(PROPERTY_CONNECTION_FACTORY_NAME)) {
setConnectionFactoryName(val);
return;
}
if (name.equals(PROPERTY_CONNECTION_FACTORY2_NAME)) {
setConnectionFactory2Name(val);
return;
}
if (name.equals(PROPERTY_CONNECTION_PASSWORD)) {
setConnectionPassword(val);
return;
}
if (name.equals(PROPERTY_CONNECTION_URL)) {
setConnectionURL(val);
return;
}
if (name.equals(PROPERTY_CONNECTION_USER_NAME)) {
setConnectionUserName(val);
return;
}
if (name.equals(PROPERTY_IGNORE_CACHE)) {
setCopyOnAttach(Boolean.parseBoolean(val));
return;
}
if (name.equals(PROPERTY_DATASTORE_READ_TIMEOUT_MILLIS)) {
setDatastoreReadTimeoutMillis(Integer.parseInt(val));
return;
}
if (name.equals(PROPERTY_DATASTORE_WRITE_TIMEOUT_MILLIS)) {
setDatastoreWriteTimeoutMillis(Integer.parseInt(val));
return;
}
if (name.equals(PROPERTY_DETACH_ALL_ON_COMMIT)) {
setDetachAllOnCommit(Boolean.parseBoolean(val));
return;
}
if (name.equals(PROPERTY_IGNORE_CACHE)) {
setIgnoreCache(Boolean.parseBoolean(val));
return;
}
if (name.equals(PROPERTY_MAPPING)) {
setMapping(val);
return;
}
if (name.equals(PROPERTY_MULTITHREADED)) {
setMultithreaded(Boolean.parseBoolean(val));
return;
}
if (name.equals(PROPERTY_NAME)) {
setName(val);
return;
}
if (name.equals(PROPERTY_NONTRANSACTIONAL_READ)) {
setNontransactionalRead(Boolean.parseBoolean(val));
return;
}
if (name.equals(PROPERTY_NONTRANSACTIONAL_WRITE)) {
setNontransactionalWrite(Boolean.parseBoolean(val));
return;
}
if (name.equals(PROPERTY_OPTIMISTIC)) {
setOptimistic(Boolean.parseBoolean(val));
return;
}
if (name.equals(PROPERTY_PERSISTENCE_UNIT_NAME)) {
setPersistenceUnitName(val);
return;
}
if (name.equals(PROPERTY_READONLY)) {
setReadOnly(Boolean.parseBoolean(val));
return;
}
if (name.equals(PROPERTY_RESTORE_VALUES)) {
setRestoreValues(Boolean.parseBoolean(val));
return;
}
if (name.equals(PROPERTY_RETAIN_VALUES)) {
setRetainValues(Boolean.parseBoolean(val));
return;
}
if (name.equals(PROPERTY_SERVER_TIME_ZONE_ID)) {
setServerTimeZoneID(val);
return;
}
if (name.equals(PROPERTY_TRANSACTION_ISOLATION_LEVEL)) {
setTransactionIsolationLevel(val);
return;
}
if (name.equals(PROPERTY_TRANSACTION_TYPE)) {
setTransactionType(val);
return;
}
if (name.equals(PROPERTY_SPI_RESOURCE_NAME)) {
setSpiResourceName(val);
return;
}
throw new IllegalArgumentException("unhandled stub PMF property "
+ name);
}
void setProperties(Map properties) {
for (Object key : properties.keySet()) {
String k = key.toString();
Object v = properties.get(key);
this.properties.put(k, v);
setProperty(k, v);
}
}
public Collection getManagedClasses() {
throw new UnsupportedOperationException("not implemented");
}
}
api/test/java/javax/jdo/util/AbstractTest.java 100664 5503 12500110371 21651 0 ustar mbouschen staff 0 0 /*
* 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 javax.jdo.util;
import java.io.PrintStream;
import javax.jdo.Constants;
import junit.framework.TestCase;
/** */
public abstract class AbstractTest extends TestCase implements Constants {
/** */
protected static PrintStream out = System.out;
/** If true, print extra messages. */
protected boolean verbose;
/**
* Construct and initialize from properties.
*/
protected AbstractTest() {
super(null);
verbose = Boolean.getBoolean("verbose");
}
/**
* Determine if a class is loadable in the current environment.
*/
protected static boolean isClassLoadable(String className) {
try {
Class.forName(className);
return true;
} catch (ClassNotFoundException ex) {
return false;
}
}
/**
*/
protected void println(String s) {
if (verbose)
out.println(s);
}
/** 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 (message != null) {
if (messages == null) {
messages = new StringBuffer();
}
messages.append(message);
messages.append(NL);
}
}
/**
* Returns collected error messages, or null 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);
}
}
}
api/test/java/javax/jdo/util/BatchResultPrinter.java 100664 6324 12500110371 23034 0 ustar mbouschen staff 0 0 /*
* 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 javax.jdo.util;
import java.io.PrintStream;
import junit.framework.AssertionFailedError;
import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestResult;
import junit.textui.ResultPrinter;
/**
* Default result printer implementation for running tests in batch mode.
*
* @author Michael Bouschen
*/
public class BatchResultPrinter
extends ResultPrinter
{
/** */
public BatchResultPrinter(PrintStream writer) {
super(writer);
}
/** Called in case of a test error. */
public void addError(Test test, Throwable t) {
getWriter().print(" ERROR");
}
/** Called in case of a test failure. */
public void addFailure(Test test, AssertionFailedError t) {
getWriter().print(" FAILURE");
}
/** Called when a test case is finished. */
public void endTest(Test test) {
getWriter().println();
}
/** Called when a test case is started. */
public void startTest(Test test) {
String testName;
if (test instanceof TestCase) {
testName = getClassBaseName(test) + "." + ((TestCase)test).getName();
}
else {
testName = test.toString();
}
getWriter().print("RUN " + testName);
}
/** */
protected void printHeader(long runTime) {
getWriter().println("Time: "+elapsedTimeAsString(runTime));
}
/** */
protected void printFooter(TestResult result) {
if (result.wasSuccessful()) {
getWriter().print("OK");
getWriter().println (" (" + result.runCount() + " test" + (result.runCount() == 1 ? "": "s") + ")");
} else {
getWriter().println("FAILURES!!!");
getWriter().println("Tests run: "+result.runCount()+
", Failures: "+result.failureCount()+
", Errors: "+result.errorCount());
}
}
// helper method
/**
* @return Name of the class of the given object without package prefix
*/
private String getClassBaseName(Object obj) {
if (obj == null) return null;
String className = obj.getClass().getName();
int index = className.lastIndexOf('.');
if (index != -1) {
className = className.substring(index + 1);
}
return className;
}
}
api/test/java/javax/jdo/util/BatchTestRunner.java 100664 13637 12500110371 22350 0 ustar mbouschen staff 0 0 /*
* 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 javax.jdo.util;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.io.PrintStream;
import junit.framework.Test;
import junit.framework.TestResult;
import junit.framework.TestSuite;
import junit.textui.ResultPrinter;
import junit.textui.TestRunner;
/**
* TestRunner class for running a single test or a test suite in batch
* mode. The format of the test output is specified by the result printer
* class. The main method sets an exit code according to the test result:
*
* 0: success
* 1: failure, the test shows an unexpected behavior
* 2: exception, the test throws an unhandled excption
*
*
* @author Michael Bouschen
*/
public class BatchTestRunner
extends TestRunner
{
/** Name of the system property to specify the result printer class. */
public static final String RESULTPRINTER_PROPERTY = "ResultPrinterClass";
/** Default of the system property ResultPrinterClass. */
public static final String RESULTPRINTER_DEFAULT = BatchResultPrinter.class.getName();
/**
* Constructor.
* It creates a result printer instance based on the system property
* and delegates to the constructor taking a result printer argument.
*/
public BatchTestRunner() {
super();
setPrinter(getResultPrinter());
}
/**
* Constructor. USes teh specified resultPrinter to format the test result.
*/
public BatchTestRunner(ResultPrinter resultPrinter) {
super(resultPrinter);
}
/** Runs all test methods from the specified class. */
public static void run(Class clazz) {
run(new TestSuite(clazz));
}
/** Runs the specified test. */
public static TestResult run(Test test) {
return new BatchTestRunner().doRun(test);
}
/** Runs the specified test and waits until the user types RETURN. */
public static void runAndWait(Test suite) {
new BatchTestRunner().doRun(suite, true);
}
/**
* Runs in batch mode and sets an exit code. If the specified String
* array includes a single fully qualified class name, this test class
* is executed. If it is empty it runs the TestListSuite.
*/
public static void main(String args[]) {
BatchTestRunner aTestRunner= new BatchTestRunner();
try {
/*
if ((args == null) || args.length == 0)
args = new String[] { TestListSuite.class.getName() };
*/
TestResult r = aTestRunner.start(args);
if (!r.wasSuccessful())
System.exit(FAILURE_EXIT);
System.exit(SUCCESS_EXIT);
} catch(Exception e) {
System.err.println(e.getMessage());
System.exit(EXCEPTION_EXIT);
}
}
/** Returns a result printer instance. n instance of tCheck the system property */
protected ResultPrinter getResultPrinter() {
String className = System.getProperty(RESULTPRINTER_PROPERTY);
if (className != null) {
className = className.trim();
if (className.length() != 0) {
String msg = null;
try {
// get class instance
Class clazz = Class.forName(className);
// constructor taking PrintStream arg
Constructor ctor = clazz.getConstructor(
new Class[] { PrintStream.class } );
// create instance
return (ResultPrinter)ctor.newInstance(
new Object[] { System.out });
}
catch (ClassNotFoundException ex) {
// specified ResultPrinter class not
msg = "Cannot find specified result printer class " +
className + ".";
}
catch (NoSuchMethodException ex) {
msg = "Class " + className +
" does not provide constructor taking a PrintStream.";
}
catch (InstantiationException ex) {
msg = "Class " + className + " is abstract.";
}
catch (IllegalAccessException ex) {
msg = "Constructor taking a PrintStream of class " +
className + " is not accessible.";
}
catch (InvocationTargetException ex) {
msg = "Constructor call results in exception " + ex + ".";
}
// ResultPrinter class specified, but not avaiable
System.out.println(msg);
ResultPrinter printer = getDefaultResultPrinter();
System.out.println("Using default result printer of class " +
printer.getClass().getName());
}
}
// ResultPrinter class not specified => use default
return getDefaultResultPrinter();
}
/**
* Returns an instance of the default result printer class
* BatchResultPrinter.
*/
protected ResultPrinter getDefaultResultPrinter() {
return new BatchResultPrinter(System.out);
}
}
api/test/java/javax/jdo/util/XMLTestUtil.java 100664 53703 12500110371 21431 0 ustar mbouschen staff 0 0 /*
* 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 javax.jdo.util;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.IOException;
import java.io.FileFilter;
import java.io.FilenameFilter;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.util.Arrays;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.StringTokenizer;
import javax.jdo.JDOFatalException;
import javax.xml.parsers.*;
import org.w3c.dom.Document;
import org.xml.sax.*;
import org.xml.sax.helpers.*;
/**
* Tests schema files.
*
*/
public class XMLTestUtil {
/** */
protected static String BASEDIR = System.getProperty("basedir", ".");
/** "http://www.w3.org/2001/XMLSchema" */
protected static final String XSD_TYPE =
"http://www.w3.org/2001/XMLSchema";
/** */
protected static final String SCHEMA_LANGUAGE_PROP =
"http://java.sun.com/xml/jaxp/properties/schemaLanguage";
/** */
protected static final String SCHEMA_LOCATION_PROP =
"http://apache.org/xml/properties/schema/external-schemaLocation";
/** jdo namespace */
protected static final String JDO_XSD_NS =
"http://java.sun.com/xml/ns/jdo/jdo";
/** orm namespace */
protected static final String ORM_XSD_NS =
"http://java.sun.com/xml/ns/jdo/orm";
/** jdoquery namespace */
protected static final String JDOQUERY_XSD_NS =
"http://java.sun.com/xml/ns/jdo/jdoquery";
/** jdo xsd file */
protected static final File JDO_XSD_FILE =
new File(BASEDIR + "/target/classes/javax/jdo/jdo_2_2.xsd");
/** orm xsd file */
protected static final File ORM_XSD_FILE =
new File(BASEDIR + "/target/classes/javax/jdo/orm_2_2.xsd");
/** jdoquery xsd file */
protected static final File JDOQUERY_XSD_FILE =
new File(BASEDIR + "/target/classes/javax/jdo/jdoquery_2_2.xsd");
/** Entity resolver */
protected static final EntityResolver resolver = new JDOEntityResolver();
/** Error handler */
protected static final Handler handler = new Handler();
/** Name of the metadata property, a comma separated list of JDO metadata
* file or directories containing such files. */
protected static String METADATA_PROP = "javax.jdo.metadata";
/** Name of the recursive property, allowing recursive search of metadata
* files. */
protected static String RECURSIVE_PROP = "javax.jdo.recursive";
/** Separator character for the metadata property. */
protected static final String DELIM = ",;";
/** Newline. */
protected static final String NL = System.getProperty("line.separator");
/** XSD builder for jdo namespace. */
private final DocumentBuilder jdoXsdBuilder =
createBuilder(JDO_XSD_NS + " " + JDO_XSD_FILE.toURI().toString());
/** XSD builder for orm namespace. */
private final DocumentBuilder ormXsdBuilder =
createBuilder(ORM_XSD_NS + " " + ORM_XSD_FILE.toURI().toString());
/** XSD builder for jdoquery namespace. */
private final DocumentBuilder jdoqueryXsdBuilder =
createBuilder(JDOQUERY_XSD_NS + " " + JDOQUERY_XSD_FILE.toURI().toString());
/** DTD builder. */
private final DocumentBuilder dtdBuilder = createBuilder(true);
/** Non validating builder. */
private final DocumentBuilder nonValidatingBuilder = createBuilder(false);
/** Create XSD builder. */
private DocumentBuilder createBuilder(String location) {
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
factory.setValidating(true);
factory.setNamespaceAware(true);
factory.setAttribute(SCHEMA_LANGUAGE_PROP, XSD_TYPE);
factory.setAttribute(SCHEMA_LOCATION_PROP, location);
return getParser(factory);
}
/** Create builder. */
private DocumentBuilder createBuilder(boolean validating) {
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
factory.setValidating(validating);
factory.setNamespaceAware(true);
return getParser(factory);
}
/** Returns a parser obtained from specified factroy. */
private DocumentBuilder getParser(DocumentBuilderFactory factory) {
try {
DocumentBuilder builder = factory.newDocumentBuilder();
builder.setEntityResolver(resolver);
builder.setErrorHandler(handler);
return builder;
} catch (ParserConfigurationException ex) {
throw new JDOFatalException("Cannot create XML parser", ex);
}
}
/** Parse the specified files. The valid parameter determines whether the
* specified files are valid JDO metadata files. The method does not throw
* an exception on an error, instead it instead it returns the error
* message(s) as string.
*/
public String checkXML(File[] files, boolean valid) {
StringBuffer messages = new StringBuffer();
for (int i = 0; i < files.length; i++) {
String msg = checkXML(files[i], valid);
if (msg != null) {
messages.append(msg);
}
}
return (messages.length() == 0) ? null : messages.toString();
}
/** Parse the specified files using a non validating parser. The method
* does not throw an exception on an error, instead it instead it returns
* the error message(s) as string.
*/
public String checkXMLNonValidating(File[] files) {
StringBuffer messages = new StringBuffer();
for (int i = 0; i < files.length; i++) {
String msg = checkXML(nonValidatingBuilder, files[i], true);
if (msg != null) {
messages.append(msg);
}
}
return (messages.length() == 0) ? null : messages.toString();
}
/** Parse the specified file. The method checks whether it is a XSD or
* DTD base file and parses the file using a builder according to the file
* name suffix. The valid parameter determines whether the specified files
* are valid JDO metadata files. The method does not throw an exception on
* an error, instead it returns the error message(s) as string.
*/
private String checkXML(File file, boolean valid) {
String messages = null;
String fileName = file.getName();
try {
if (isDTDBased(file)) {
messages = checkXML(dtdBuilder, file, valid);
} else if (fileName.endsWith(".jdo")) {
messages = checkXML(jdoXsdBuilder, file, valid);
} else if (fileName.endsWith(".orm")) {
messages = checkXML(ormXsdBuilder, file, valid);
} else if (fileName.endsWith(".jdoquery")) {
messages = checkXML(jdoqueryXsdBuilder, file, valid);
}
} catch (SAXException ex) {
messages = ex.getMessage();
}
return messages;
}
/** Parse the specified file using the specified builder. The valid
* parameter determines whether the specified files are valid JDO metadata
* files. The method does not throw an exception on an error, instead it
* returns the error message(s) as string.
*/
private String checkXML(DocumentBuilder builder, File file, boolean valid) {
String messages = null;
handler.init(file);
try {
builder.parse(file);
} catch (SAXParseException ex) {
handler.error(ex);
} catch (Exception ex) {
messages = "Fatal error processing " + file.getName() + ": " + ex + NL;
}
if (messages == null) {
messages = handler.getMessages();
}
if (!valid) {
if (messages != null) {
// expected error for negative test
messages = null;
} else {
messages = file.getName() + " is not valid, " +
"but the parser did not catch the error.";
}
}
return messages;
}
/** Checks whether the specifeid file is DTD or XSD based. The method
* throws a SAXException if the file has syntax errors. */
private boolean isDTDBased(File file) throws SAXException {
handler.init(file);
try {
Document document = nonValidatingBuilder.parse(file);
return document.getDoctype() != null;
} catch (SAXParseException ex) {
handler.error(ex);
throw new SAXException(handler.getMessages());
} catch (Exception ex) {
throw new SAXException(
"Fatal error processing " + file.getName() + ": " + ex);
}
}
/** ErrorHandler implementation. */
private static class Handler implements ErrorHandler {
private File fileUnderTest;
private String[] lines;
private StringBuffer messages;
public void error(SAXParseException ex) {
append("Handler.error: ", ex);
}
public void fatalError(SAXParseException ex) {
append("Handler.fatalError: ", ex);
}
public void warning(SAXParseException ex) {
append("Handler.warning: ", ex);
}
public void init(File file) {
this.fileUnderTest = file;
this.messages = new StringBuffer();
this.lines = null;
}
public String getMessages() {
return (messages.length() == 0) ? null : messages.toString();
}
private void append(String prefix, SAXParseException ex) {
int lineNumber = ex.getLineNumber();
int columnNumber = ex.getColumnNumber();
messages.append("------------------------").append(NL);
messages.append(prefix).append(fileUnderTest.getName());
messages.append(" [line=").append(lineNumber);
messages.append(", col=").append(columnNumber).append("]: ");
messages.append(ex.getMessage()).append(NL);
messages.append(getErrorLocation(lineNumber, columnNumber));
}
private String[] getLines() {
if (lines == null) {
try {
BufferedReader bufferedReader =
new BufferedReader(new FileReader(fileUnderTest));
ArrayList tmp = new ArrayList();
while (bufferedReader.ready()) {
tmp.add(bufferedReader.readLine());
}
lines = (String[])tmp.toArray(new String[tmp.size()]);
} catch (IOException ex) {
throw new JDOFatalException("getLines: caught IOException", ex);
}
}
return lines;
}
/** Return the error location for the file under test.
*/
private String getErrorLocation(int lineNumber, int columnNumber) {
String[] lines = getLines();
int length = lines.length;
if (lineNumber > length) {
return "Line number " + lineNumber +
" exceeds the number of lines in the file (" +
lines.length + ")";
} else if (lineNumber < 1) {
return "Line number " + lineNumber +
" does not allow retriving the error location.";
}
StringBuffer buf = new StringBuffer();
if (lineNumber > 2) {
buf.append(lines[lineNumber-3]);
buf.append(NL);
buf.append(lines[lineNumber-2]);
buf.append(NL);
}
buf.append(lines[lineNumber-1]);
buf.append(NL);
for (int i = 1; i < columnNumber; ++i) {
buf.append(' ');
}
buf.append("^\n");
if (lineNumber + 1 < length) {
buf.append(lines[lineNumber]);
buf.append(NL);
buf.append(lines[lineNumber+1]);
buf.append(NL);
}
return buf.toString();
}
}
/** Implementation of EntityResolver interface to check the jdo.dtd location
**/
private static class JDOEntityResolver
implements EntityResolver {
private static final String RECOGNIZED_JDO_PUBLIC_ID =
"-//Sun Microsystems, Inc.//DTD Java Data Objects Metadata 2.2//EN";
private static final String RECOGNIZED_JDO_SYSTEM_ID =
"file:/javax/jdo/jdo_2_2.dtd";
private static final String RECOGNIZED_JDO_SYSTEM_ID2 =
"http://java.sun.com/dtd/jdo_2_2.dtd";
private static final String RECOGNIZED_ORM_PUBLIC_ID =
"-//Sun Microsystems, Inc.//DTD Java Data Objects Mapping Metadata 2.2//EN";
private static final String RECOGNIZED_ORM_SYSTEM_ID =
"file:/javax/jdo/orm_2_2.dtd";
private static final String RECOGNIZED_ORM_SYSTEM_ID2 =
"http://java.sun.com/dtd/orm_2_2.dtd";
private static final String RECOGNIZED_JDOQUERY_PUBLIC_ID =
"-//Sun Microsystems, Inc.//DTD Java Data Objects Query Metadata 2.2//EN";
private static final String RECOGNIZED_JDOQUERY_SYSTEM_ID =
"file:/javax/jdo/jdoquery_2_2.dtd";
private static final String RECOGNIZED_JDOQUERY_SYSTEM_ID2 =
"http://java.sun.com/dtd/jdoquery_2_2.dtd";
private static final String JDO_DTD_FILENAME =
"javax/jdo/jdo_2_2.dtd";
private static final String ORM_DTD_FILENAME =
"javax/jdo/orm_2_2.dtd";
private static final String JDOQUERY_DTD_FILENAME =
"javax/jdo/jdoquery_2_2.dtd";
static Map publicIds = new HashMap();
static Map systemIds = new HashMap();
static {
publicIds.put(RECOGNIZED_JDO_PUBLIC_ID, JDO_DTD_FILENAME);
publicIds.put(RECOGNIZED_ORM_PUBLIC_ID, ORM_DTD_FILENAME);
publicIds.put(RECOGNIZED_JDOQUERY_PUBLIC_ID, JDOQUERY_DTD_FILENAME);
systemIds.put(RECOGNIZED_JDO_SYSTEM_ID, JDO_DTD_FILENAME);
systemIds.put(RECOGNIZED_ORM_SYSTEM_ID, ORM_DTD_FILENAME);
systemIds.put(RECOGNIZED_JDOQUERY_SYSTEM_ID, JDOQUERY_DTD_FILENAME);
systemIds.put(RECOGNIZED_JDO_SYSTEM_ID2, JDO_DTD_FILENAME);
systemIds.put(RECOGNIZED_ORM_SYSTEM_ID2, ORM_DTD_FILENAME);
systemIds.put(RECOGNIZED_JDOQUERY_SYSTEM_ID2, JDOQUERY_DTD_FILENAME);
}
public InputSource resolveEntity(String publicId, final String systemId)
throws SAXException, IOException
{
// check for recognized ids
String filename = (String)publicIds.get(publicId);
if (filename == null) {
filename = (String)systemIds.get(systemId);
}
final String finalName = filename;
if (finalName == null) {
return null;
} else {
// Substitute the dtd with the one from javax.jdo.jdo.dtd,
// but only if the publicId is equal to RECOGNIZED_PUBLIC_ID
// or there is no publicID and the systemID is equal to
// RECOGNIZED_SYSTEM_ID.
InputStream stream = AccessController.doPrivileged (
new PrivilegedAction () {
public InputStream run () {
return getClass().getClassLoader().
getResourceAsStream(finalName);
}
}
);
if (stream == null) {
throw new JDOFatalException("Cannot load " + finalName +
", because the file does not exist in the jdo.jar file, " +
"or the JDOParser class is not granted permission to read this file. " +
"The metadata .xml file contained PUBLIC=" + publicId +
" SYSTEM=" + systemId + ".");
}
return new InputSource(new InputStreamReader(stream));
}
}
}
/** Helper class to find all test JDO metadata files. */
public static class XMLFinder {
private List metadataFiles = new ArrayList();
private final boolean recursive;
/** Constructor. */
public XMLFinder(String[] fileNames, boolean recursive) {
this.recursive = recursive;
if (fileNames == null) return;
for (int i = 0; i < fileNames.length; i++) {
appendTestFiles(fileNames[i]);
}
}
/** Returns array of files of matching file names. */
private File[] getFiles(File dir, final String suffix) {
FilenameFilter filter = new FilenameFilter() {
public boolean accept(File file, String name) {
return name.endsWith(suffix);
}
};
return dir.listFiles(filter);
}
/** */
private File[] getDirectories(File dir) {
FileFilter filter = new FileFilter() {
public boolean accept(File pathname) {
return pathname.isDirectory();
}
};
return dir.listFiles(filter);
}
/** */
private void appendTestFiles(String fileName) {
File file = new File(fileName);
if (file.isDirectory()) {
processDirectory(file);
} else if (fileName.endsWith(".jdo") ||
fileName.endsWith(".orm") ||
fileName.endsWith(".jdoquery")) {
metadataFiles.add(new File(fileName));
}
}
/** Adds all files with suffix .jdo, .orm and .jdoquery to the list of
* metadata files. Recursively process subdirectories if recursive
* flag is set. */
private void processDirectory(File dir) {
metadataFiles.addAll(Arrays.asList(getFiles(dir, ".jdo")));
metadataFiles.addAll(Arrays.asList(getFiles(dir, ".orm")));
metadataFiles.addAll(Arrays.asList(getFiles(dir, ".jdoquery")));
if (recursive) {
File[] subdirs = getDirectories(dir);
for (int i = 0; i < subdirs.length; i++) {
processDirectory(subdirs[i]);
}
}
}
/** Returns an array of test files with suffix .jdo, .orm or .jdoquery. */
public File[] getMetadataFiles() {
return (File[])metadataFiles.toArray(new File[metadataFiles.size()]);
}
}
/** */
private static String[] checkMetadataSystemProperty() {
String[] ret = null;
String metadata = System.getProperty(METADATA_PROP);
if ((metadata != null) && (metadata.length() > 0)) {
List entries = new ArrayList();
StringTokenizer st = new StringTokenizer(metadata, DELIM);
while (st.hasMoreTokens()) {
entries.add(st.nextToken());
}
ret = (String[])entries.toArray(new String[entries.size()]);
}
return ret;
}
/**
* Command line tool to test JDO metadata files.
* Usage: XMLTestUtil [-r] +
*/
public static void main(String args[]) {
String[] fromProp = checkMetadataSystemProperty();
boolean recursive = Boolean.getBoolean(RECURSIVE_PROP);
// handle command line args
String[] fileNames = null;
if ((args.length > 0) && ("-r".equals(args[0]))) {
recursive = true;
fileNames = new String[args.length - 1];
System.arraycopy(args, 1, fileNames, 0, args.length - 1);
} else {
fileNames = args;
}
// check args
if ((fileNames.length == 0) && (fromProp == null)) {
System.err.println(
"No commandline arguments and system property metadata not defined; " +
"nothing to be tested.\nUsage: XMLTestUtil [-r] \n" +
"\tAll .jdo, .orm, and .jdoquery files in the directory (recursively) will be tested.");
} else if ((fileNames.length == 0) && (fromProp != null)) {
// use metadata system property
fileNames = fromProp;
} else if ((fileNames.length != 0) && (fromProp != null)) {
System.err.println(
"Commandline arguments specified and system property metadata defined; " +
"ignoring system property metadata.");
}
// run the test
XMLTestUtil xmlTest = new XMLTestUtil();
File[] files = new XMLFinder(fileNames, recursive).getMetadataFiles();
for (int i = 0; i < files.length; i++) {
File file = files[i];
System.out.print("Checking " + file.getPath() + ": ");
String messages = xmlTest.checkXML(file, true);
messages = (messages == null) ? "OK" : NL + messages;
System.out.println(messages);
}
}
}
api/test/resources/enhancer-test-dir/enhancer-test-subdir/file4.jdo 100664 1474 12500110370 25677 0 ustar mbouschen staff 0 0
api/test/resources/enhancer-test-dir/enhancer-test-subdir/file5.class 100664 0 12500110370 26131 0 ustar mbouschen staff 0 0 api/test/resources/enhancer-test-dir/enhancer-test-subdir/file6.jar 100664 0 12500110370 25601 0 ustar mbouschen staff 0 0 api/test/resources/enhancer-test-dir/file1.jdo 100664 1474 12500110370 21646 0 ustar mbouschen staff 0 0
api/test/resources/enhancer-test-dir/file2.class 100664 0 12500110370 22100 0 ustar mbouschen staff 0 0 api/test/resources/enhancer-test-dir/file3.jar 100664 0 12500110370 21550 0 ustar mbouschen staff 0 0 api/test/resources/META-INF/services/javax.jdo.JDOEnhancer 100664 1457 12500110370 23506 0 ustar mbouschen staff 0 0 #
# 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.
#
javax.jdo.MockEnhancer
api/test/schema/jdoconfig/Negative00/META-INF/jdoconfig.xml 100664 1475 12500110370 23553 0 ustar mbouschen staff 0 0
api/test/schema/jdoconfig/Negative01/META-INF/jdoconfig.xml 100664 1752 12500110370 23552 0 ustar mbouschen staff 0 0
api/test/schema/jdoconfig/Negative02/META-INF/jdoconfig.xml 100664 2106 12500110370 23545 0 ustar mbouschen staff 0 0
api/test/schema/jdoconfig/Negative03/META-INF/jdoconfig.xml 100664 2534 12500110370 23553 0 ustar mbouschen staff 0 0
api/test/schema/jdoconfig/Negative04/META-INF/jdoconfig.xml 100664 2711 12500110370 23551 0 ustar mbouschen staff 0 0
api/test/schema/jdoconfig/Negative05/META-INF/jdoconfig.xml 100664 2663 12500110370 23560 0 ustar mbouschen staff 0 0
api/test/schema/jdoconfig/Negative06/6a/META-INF/jdoconfig.xml 100664 2454 12500110370 24065 0 ustar mbouschen staff 0 0
api/test/schema/jdoconfig/Negative06/6b/META-INF/jdoconfig.xml 100664 2454 12500110370 24066 0 ustar mbouschen staff 0 0
api/test/schema/jdoconfig/Negative07/META-INF/services/javax.jdo.PersistenceManagerFactory 100664 1430 12500110370 31625 0 ustar mbouschen staff 0 0 #
# 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.
#
api/test/schema/jdoconfig/Negative08/META-INF/services/javax.jdo.PersistenceManagerFactory 100664 1503 12500110370 31627 0 ustar mbouschen staff 0 0 #
# 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.
#
# there are
# only comments
# in this file
api/test/schema/jdoconfig/Negative09/9a/META-INF/jdoconfig.xml 100664 2464 12500110370 24074 0 ustar mbouschen staff 0 0
api/test/schema/jdoconfig/Negative09/9a/META-INF/services/javax.jdo.PersistenceManagerFactory 100664 1505 12500110370 32143 0 ustar mbouschen staff 0 0 #
# 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.
#
javax.jdo.JDOHelperTest$BadPMFNoGetPMFMethod
api/test/schema/jdoconfig/Negative09/9b/META-INF/services/javax.jdo.PersistenceManagerFactory 100664 1542 12500110370 32145 0 ustar mbouschen staff 0 0 #
# 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.
#
javax.jdo.JDOHelperTest$BadPMFGetPMFMethodThrowsJDOFatalInternalException
api/test/schema/jdoconfig/Pmfmapmap01/META-INF/jdoconfig.xml 100664 3211 12500110370 23716 0 ustar mbouschen staff 0 0
api/test/schema/jdoconfig/Pmfmapmap02/propsfile.props 100664 1620 12500110370 23165 0 ustar mbouschen staff 0 0 #
# 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.
#
javax.jdo.PersistenceManagerFactoryClass javax.jdo.stub.StubPMF
javax.jdo.option.ConnectionDriverName Jane Doe
api/test/schema/jdoconfig/Positive00/META-INF/jdoconfig.xml 100664 26751 12500110370 23637 0 ustar mbouschen staff 0 0
api/test/schema/jdoconfig/Positive01/1a/META-INF/jdoconfig.xml 100664 2537 12500110370 24115 0 ustar mbouschen staff 0 0
api/test/schema/jdoconfig/Positive01/1b/META-INF/jdoconfig.xml 100664 2473 12500110370 24115 0 ustar mbouschen staff 0 0
api/test/schema/jdoconfig/Positive02/META-INF/jdoconfig.xml 100664 2434 12500110370 23611 0 ustar mbouschen staff 0 0
api/test/schema/jdoconfig/Positive03/META-INF/jdoconfig.xml 100664 2442 12500110370 23611 0 ustar mbouschen staff 0 0
api/test/schema/jdoconfig/Positive03/META-INF/services/javax.jdo.PersistenceManagerFactory 100664 1456 12500110370 31671 0 ustar mbouschen staff 0 0 #
# 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.
#
class.positive03.pmf0
api/test/schema/jdoconfig/Positive04/META-INF/jdoconfig.xml 100664 2442 12500110370 23612 0 ustar mbouschen staff 0 0
api/test/schema/jdoconfig/Positive04/META-INF/services/javax.jdo.PersistenceManagerFactory 100664 1533 12500110370 31666 0 ustar mbouschen staff 0 0 #
# 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.
#
#this is a comment
class.positive04.pmf0 # this is another comment
api/test/schema/jdoconfig/Positive05/META-INF/jdoconfig.xml 100664 2442 12500110370 23613 0 ustar mbouschen staff 0 0
api/test/schema/jdoconfig/Positive05/META-INF/services/javax.jdo.PersistenceManagerFactory 100664 1574 12500110370 31674 0 ustar mbouschen staff 0 0 #
# 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.
#
class.positive05.pmf0# this is a comment without whitespace separating it from the uncommented text
api/test/schema/jdoconfig/Positive06/META-INF/jdoconfig.xml 100664 5302 12500110370 23612 0 ustar mbouschen staff 0 0
api/test/schema/jdoconfig/Positive07/META-INF/jdoconfig.xml 100664 5434 12500110370 23621 0 ustar mbouschen staff 0 0
api/test/schema/Negative0-dtd.jdo 100664 2001 12500110371 17137 0 ustar mbouschen staff 0 0
api/test/schema/Negative0-dtd.jdoquery 100664 2033 12500110370 20231 0 ustar mbouschen staff 0 0
api/test/schema/Negative0-dtd.orm 100664 2011 12500110371 17161 0 ustar mbouschen staff 0 0
api/test/schema/Negative0-xsd.jdo 100664 2134 12500110371 17171 0 ustar mbouschen staff 0 0
api/test/schema/Negative0-xsd.jdoquery 100664 2173 12500110371 20262 0 ustar mbouschen staff 0 0
api/test/schema/Negative0-xsd.orm 100664 2134 12500110371 17212 0 ustar mbouschen staff 0 0
api/test/schema/Positive0-dtd.jdo 100664 2043 12500110371 17205 0 ustar mbouschen staff 0 0
api/test/schema/Positive0-dtd.jdoquery 100664 2275 12500110371 20302 0 ustar mbouschen staff 0 0
SELECT * FROM TestClass
api/test/schema/Positive0-dtd.orm 100664 2056 12500110371 17232 0 ustar mbouschen staff 0 0
api/test/schema/Positive0-xsd.jdo 100664 2176 12500110371 17237 0 ustar mbouschen staff 0 0
api/test/schema/Positive0-xsd.jdoquery 100664 2426 12500110371 20323 0 ustar mbouschen staff 0 0
SELECT * FROM TestClass
api/test/schema/Positive0-xsd.orm 100664 2176 12500110371 17260 0 ustar mbouschen staff 0 0
api/test/schema/Positive1-dtd.jdo 100664 14532 12500110371 17234 0 ustar mbouschen staff 0 0
SELECT firstname, lastname
INTO org.apache.jdo.tck.query.result.classes.FullName
FROM org.apache.jdo.tck.pc.company.Person
SELECT UNIQUE firstname, lastname
INTO org.apache.jdo.tck.query.result.classes.FullName
FROM org.apache.jdo.tck.pc.company.Person
WHERE firstname == 'emp1First'
SELECT UNIQUE firstname, lastname
INTO org.apache.jdo.tck.query.result.classes.FullName
FROM org.apache.jdo.tck.pc.company.Person
SELECT firstname, lastname
FROM org.apache.jdo.tck.pc.company.Person
SELECT FROM org.apache.jdo.tck.pc.company.Person
WHERE personid > 1
SELECT FROM org.apache.jdo.tck.pc.company.Person
SeLeCt FrOm org.apache.jdo.tck.pc.company.Person
api/test/schema/Positive1-dtd.orm 100664 7455 12500110371 17243 0 ustar mbouschen staff 0 0
SELECT firstname, lastname
INTO org.apache.jdo.tck.query.result.classes.FullName
FROM org.apache.jdo.tck.pc.company.Person
SELECT UNIQUE firstname, lastname
INTO org.apache.jdo.tck.query.result.classes.FullName
FROM org.apache.jdo.tck.pc.company.Person
WHERE firstname == 'emp1First'
SELECT UNIQUE firstname, lastname
INTO org.apache.jdo.tck.query.result.classes.FullName
FROM org.apache.jdo.tck.pc.company.Person
SELECT firstname, lastname
FROM org.apache.jdo.tck.pc.company.Person
SELECT FROM org.apache.jdo.tck.pc.company.Person
WHERE personid > 1
SELECT FROM org.apache.jdo.tck.pc.company.Person
SeLeCt FrOm org.apache.jdo.tck.pc.company.Person
api/test/schema/Positive1-xsd.jdo 100664 14677 12500110370 17270 0 ustar mbouschen staff 0 0
SELECT firstname, lastname
INTO org.apache.jdo.tck.query.result.classes.FullName
FROM org.apache.jdo.tck.pc.company.Person
SELECT UNIQUE firstname, lastname
INTO org.apache.jdo.tck.query.result.classes.FullName
FROM org.apache.jdo.tck.pc.company.Person
WHERE firstname == 'emp1First'
SELECT UNIQUE firstname, lastname
INTO org.apache.jdo.tck.query.result.classes.FullName
FROM org.apache.jdo.tck.pc.company.Person
SELECT firstname, lastname
FROM org.apache.jdo.tck.pc.company.Person
SELECT FROM org.apache.jdo.tck.pc.company.Person
WHERE personid > 1
SELECT FROM org.apache.jdo.tck.pc.company.Person
SeLeCt FrOm org.apache.jdo.tck.pc.company.Person
api/test/schema/Positive1-xsd.orm 100664 7615 12500110371 17264 0 ustar mbouschen staff 0 0
SELECT firstname, lastname
INTO org.apache.jdo.tck.query.result.classes.FullName
FROM org.apache.jdo.tck.pc.company.Person
SELECT UNIQUE firstname, lastname
INTO org.apache.jdo.tck.query.result.classes.FullName
FROM org.apache.jdo.tck.pc.company.Person
WHERE firstname == 'emp1First'
SELECT UNIQUE firstname, lastname
INTO org.apache.jdo.tck.query.result.classes.FullName
FROM org.apache.jdo.tck.pc.company.Person
SELECT firstname, lastname
FROM org.apache.jdo.tck.pc.company.Person
SELECT FROM org.apache.jdo.tck.pc.company.Person
WHERE personid > 1
SELECT FROM org.apache.jdo.tck.pc.company.Person
SeLeCt FrOm org.apache.jdo.tck.pc.company.Person
api/test/schema/Positive15.1-dtd.orm 100664 2605 12500110371 17457 0 ustar mbouschen staff 0 0
api/test/schema/Positive15.1-xsd.orm 100664 2725 12500110370 17504 0 ustar mbouschen staff 0 0
api/test/schema/Positive15.2.1-dtd.orm 100664 3256 12500110371 17622 0 ustar mbouschen staff 0 0
api/test/schema/Positive15.2.1-xsd.orm 100664 3376 12500110371 17650 0 ustar mbouschen staff 0 0
api/test/schema/Positive15.2.2-dtd.orm 100664 3003 12500110371 17611 0 ustar mbouschen staff 0 0
api/test/schema/Positive15.2.2-xsd.orm 100664 3123 12500110371 17637 0 ustar mbouschen staff 0 0
api/test/schema/Positive15.3.1-dtd.orm 100664 2412 12500110371 17614 0 ustar mbouschen staff 0 0
api/test/schema/Positive15.3.1-xsd.orm 100664 2532 12500110371 17642 0 ustar mbouschen staff 0 0
api/test/schema/Positive15.3.2-dtd.orm 100664 2456 12500110371 17625 0 ustar mbouschen staff 0 0
api/test/schema/Positive15.3.2-xsd.orm 100664 2576 12500110371 17653 0 ustar mbouschen staff 0 0
api/test/schema/Positive15.3.3-dtd.orm 100664 2432 12500110371 17620 0 ustar mbouschen staff 0 0
api/test/schema/Positive15.3.3-xsd.orm 100664 2552 12500110371 17646 0 ustar mbouschen staff 0 0
api/test/schema/Positive15.3.4-dtd.orm 100664 2610 12500110371 17617 0 ustar mbouschen staff 0 0
api/test/schema/Positive15.3.4-xsd.orm 100664 2730 12500110371 17645 0 ustar mbouschen staff 0 0
api/test/schema/Positive15.3.5-dtd.orm 100664 2752 12500110371 17627 0 ustar mbouschen staff 0 0
api/test/schema/Positive15.3.5-xsd.orm 100664 3063 12500110371 17646 0 ustar mbouschen staff 0 0
api/test/schema/Positive15.3.6-dtd.orm 100664 2643 12500110371 17627 0 ustar mbouschen staff 0 0
api/test/schema/Positive15.3.6-xsd.orm 100664 3375 12500110371 17655 0 ustar mbouschen staff 0 0
api/test/schema/Positive15.4-dtd.orm 100664 3660 12500110371 17464 0 ustar mbouschen staff 0 0
api/test/schema/Positive15.4-xsd.orm 100664 4000 12500110371 17474 0 ustar mbouschen staff 0 0
api/test/schema/Positive15.5-dtd.orm 100664 2571 12500110371 17465 0 ustar mbouschen staff 0 0
api/test/schema/Positive15.5-xsd.orm 100664 2711 12500110371 17504 0 ustar mbouschen staff 0 0
api/test/schema/Positive15.6-dtd.orm 100664 2552 12500110371 17465 0 ustar mbouschen staff 0 0
api/test/schema/Positive15.6-xsd.orm 100664 2672 12500110371 17513 0 ustar mbouschen staff 0 0
api/test/schema/Positive15.8.1-dtd.orm 100664 3143 12500110371 17623 0 ustar mbouschen staff 0 0
api/test/schema/Positive15.8.1-xsd.orm 100664 3263 12500110371 17651 0 ustar mbouschen staff 0 0
api/test/schema/Positive15.8.2-dtd.orm 100664 3167 12500110371 17632 0 ustar mbouschen staff 0 0
api/test/schema/Positive15.8.2-xsd.orm 100664 3307 12500110371 17651 0 ustar mbouschen staff 0 0
api/test/schema/Positive15.8.3-dtd.orm 100664 2732 12500110371 17630 0 ustar mbouschen staff 0 0
api/test/schema/Positive15.8.3-xsd.orm 100664 3052 12500110371 17647 0 ustar mbouschen staff 0 0
api/test/schema/Positive99-dtd.jdo 100664 36476 12500110371 17350 0 ustar mbouschen staff 0 0
api/test/schema/Positive99-dtd.jdoquery 100664 4676 12500110370 20412 0 ustar mbouschen staff 0 0
api/test/schema/Positive99-dtd.orm 100664 27611 12500110371 17360 0 ustar mbouschen staff 0 0
api/test/schema/Positive99-xsd.jdo 100664 36761 12500110371 17370 0 ustar mbouschen staff 0 0
api/test/schema/Positive99-xsd.jdoquery 100664 5167 12500110371 20432 0 ustar mbouschen staff 0 0
api/test/schema/Positive99-xsd.orm 100664 30075 12500110371 17401 0 ustar mbouschen staff 0 0
exectck/src/ 40775 0 12500110374 13210 5 ustar mbouschen staff 0 0 exectck/src/main/ 40775 0 12500110374 14134 5 ustar mbouschen staff 0 0 exectck/src/main/java/ 40775 0 12500110374 15055 5 ustar mbouschen staff 0 0 exectck/src/main/java/org/ 40775 0 12500110374 15644 5 ustar mbouschen staff 0 0 exectck/src/main/java/org/apache/ 40775 0 12500110374 17065 5 ustar mbouschen staff 0 0 exectck/src/main/java/org/apache/jdo/ 40775 0 12500110374 17641 5 ustar mbouschen staff 0 0 exectck/src/main/java/org/apache/jdo/exectck/ 40775 0 12500110374 21267 5 ustar mbouschen staff 0 0 exectck/src/main/resources/ 40775 0 12500110374 16146 5 ustar mbouschen staff 0 0 exectck/pom.xml 100664 11517 12500110374 14060 0 ustar mbouschen staff 0 0
org.apache.jdo
parent-pom
3.1
../parent-pom
4.0.0
org.apache.jdo
jdo-exectck
maven-plugin
3.1
JDO TCK Execution Maven Mojo
http://maven.apache.org
scm:svn:http://svn.apache.org/repos/asf/db/jdo/tags/jdo-3.1/3.1
scm:svn:https://svn.apache.org/repos/asf/db/jdo/tags/jdo-3.1/3.1
http://svn.apache.org/viewvc/db/jdo/tags/jdo-3.1/3.1
org.apache.maven.plugins
maven-compiler-plugin
2.0.2
1.6
1.6
org.apache.maven.plugins
maven-deploy-plugin
2.6
true
iut
jdo.tck.impl
iut
jdori
true
org.apache.maven
maven-plugin-api
junit
junit
org.apache.derby
derby
org.apache.derby
derbytools
commons-io
commons-io
javax.jdo
jdo-api
org.springframework
spring-core
org.springframework
spring-beans
commons-collections
commons-collections
org.eclipse.persistence
javax.persistence
exectck/src/main/java/org/apache/jdo/exectck/AbstractTCKMojo.java 100664 7456 12500110374 25175 0 ustar mbouschen staff 0 0 /*
* Copyright 2006-2012 The Apache Software Foundation.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.jdo.exectck;
import java.io.File;
import java.io.FileInputStream;
import java.util.Collection;
import java.util.HashSet;
import java.util.Properties;
import org.apache.maven.plugin.AbstractMojo;
import org.apache.maven.plugin.MojoExecutionException;
/**
* Abstract Mojo to be extended for the actual goals of this maven plugin.
*/
public abstract class AbstractTCKMojo extends AbstractMojo {
/**
* Location of TCK generated output.
* @parameter property="project.build.directory"
* default-value="${basedir}/target"
* @required
*/
protected String buildDirectory;
/**
* Location of the logs directory.
* @parameter property="project.log.directory"
* default-value="${project.build.directory}/logs"
* @required
*/
protected File logsDirectory;
/**
* Location of the configuration directory.
* @parameter property="project.conf.directory"
* default-value="${basedir}/src/conf"
* @required
*/
protected String confDirectory;
/**
* Location of the configuration directory.
* @parameter property="project.sql.directory"
* default-value="${basedir}/src/sql"
* @required
*/
protected String sqlDirectory;
/**
* List of configuration files, each describing a test configuration.
* Note: Collection can only be configured in pom.xml. Using multi-valued
* type because long String cannot be broken across lines in pom.xml.
* @parameter
* @optional
*/
protected Collection cfgs;
/**
* List of configuration files, each describing a test configuration.
* Allows command line override of configured cfgs value.
* @parameter property="jdo.tck.cfglist"
* @optional
*/
protected String cfgList;
/**
* List of databases to run tests under.
* Currently only derby is supported.
* @parameter property="jdo.tck.dblist"
* default-value="derby"
* @required
*/
protected String dblist;
protected Collection dbs = new HashSet();
/**
* List of identity types to be tested.
* @parameter property="jdo.tck.identitytypes"
* default-value="applicationidentity datastoreidentity"
* @required
*/
protected String identitytypes;
protected Collection idtypes = new HashSet();
/**
* Convenience method to set the cfgList from the file
* "src/conf/configurations.list".
* @throws MojoExecutionException If the file could not be found/opened
*/
protected void setCfgListFromFile() throws MojoExecutionException {
try {
Properties defaultProps = new Properties();
FileInputStream in = new FileInputStream(confDirectory + File.separator +
"configurations.list");
defaultProps.load(in);
in.close();
cfgList = defaultProps.getProperty("jdo.tck.cfglist");
}
catch (Exception e) {
// Error finding configurations.list
throw new MojoExecutionException("No configuration specified and could not " +
"find 'src/conf/configurations.list'");
}
}
}
exectck/src/main/java/org/apache/jdo/exectck/Enhance.java 100664 32673 12500110374 23623 0 ustar mbouschen staff 0 0 /*
* 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.exectck;
import java.net.MalformedURLException;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.apache.commons.io.FileUtils;
import org.apache.maven.plugin.AbstractMojo;
import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.plugin.MojoFailureException;
import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import javax.jdo.JDOEnhancer;
import javax.jdo.JDOHelper;
/**
* Goal that enhances test classes for testing a JDO implementation.
*
* @goal enhance
*
* @phase integration-test
*/
public class Enhance extends AbstractMojo {
private static final String[] PC_PKG_DIRS = {
"org" + File.separator + "apache" + File.separator + "jdo" + File.separator + "tck" + File.separator + "api" + File.separator,
"org" + File.separator + "apache" + File.separator + "jdo" + File.separator + "tck" + File.separator + "pc" + File.separator,
"org" + File.separator + "apache" + File.separator + "jdo" + File.separator + "tck" + File.separator + "models" + File.separator + "inheritance" + File.separator
};
/**
* Location of TCK generated output.
* @parameter property="jdo.tck.doEnhance"
* default-value="true"
* @required
*/
private boolean doEnhance;
/**
* Root of the TCK source installation.
* @parameter property="project.src.directory"
* default-value="${basedir}/src"
* @required
*/
private String srcDirectory;
/**
* Location of the logs directory.
* @parameter property="project.log.directory"
* default-value="${project.build.directory}/logs"
* @required
*/
private File logsDirectory;
/**
* Location of TCK generated output.
* @parameter property="project.build.directory"
* default-value="${basedir}/target"
* @required
*/
private String buildDirectory;
/**
* Implementation to be tested (jdori or iut).
* Any value other than "jdori" will test an appropriately configured IUT
* @parameter property="jdo.tck.impl"
* default-value="jdori"
* @required
*/
private String impl;
/**
* Location of implementation log file.
* @parameter property="jdo.tck.impl.logfile"
* default-value="${user.dir}/datanucleus.txt"
* @required
*/
private String implLogFile;
/**
* Location of jar files for implementation under test.
* @parameter property="project.lib.iut.directory"
* default-value="${basedir}/../lib/iut"
* @required
*/
private String iutLibsDirectory;
/**
* Location of jar files for implementation under test.
* @parameter property="project.lib.iut.directory"
* default-value="${basedir}/../lib/jdori"
* @required
*/
private String jdoriLibsDirectory;
/**
* List of identity types to be tested.
* @parameter property="jdo.tck.identitytypes"
* default-value="applicationidentity datastoreidentity"
* @required
*/
private String identitytypes;
private Collection idtypes;
@Override
public void execute() throws MojoExecutionException, MojoFailureException {
if (!doEnhance) {
System.out.println("Skipping Enhance goal!");
return;
}
idtypes = new HashSet();
PropertyUtils.string2Set(identitytypes, idtypes);
// Create directory for enhancer logs
String enhanceLogsDirName = logsDirectory + File.separator + "enhanced";
File enhancerLogsDir = new File(enhanceLogsDirName);
if (!(enhancerLogsDir.exists()) && !(enhancerLogsDir.mkdirs())) {
throw new MojoExecutionException("Failed to create directory "
+ enhancerLogsDir);
}
// Create directory for enhanced classes
String enhancedDirName = buildDirectory + File.separator + "enhanced"
+ File.separator + impl + File.separator;
File enhancedDir = new File(enhancedDirName);
if (!(enhancedDir.exists()) && !(enhancedDir.mkdirs())) {
throw new MojoExecutionException("Failed to create directory "
+ enhancedDir);
}
String[] metadataExtensions = {"jdo", "jdoquery", "orm", "xml", "properties"};
String[] srcDirs = {"jdo", "orm", "testdata"};
File toFile = null;
File fromFile = null;
String fromFileName = null;
String pkgName = null;
int startIdx = -1;
Iterator fi = null;
String[] classArray = new String[10];
String enhancedIdDirName = null;
String classesDirName = buildDirectory + File.separator
+ "classes" + File.separator;
ArrayList classes = null;
// Copy metadata from src to enhanced
for (String idtype : idtypes) {
for (String srcDir : srcDirs) {
String srcDirName = srcDirectory + File.separator + srcDir;
// iterator over list of abs name of metadata files in src
fi = FileUtils.iterateFiles(
new File(srcDirName), metadataExtensions, true);
while (fi.hasNext()) {
try {
fromFile = fi.next();
fromFileName = fromFile.toString();
if ((startIdx = fromFileName.indexOf(idtype + File.separator)) > -1) {
// fully specified name of file (idtype + package + filename)
pkgName = fromFileName.substring(startIdx);
toFile = new File(enhancedDirName + File.separator
+ pkgName);
FileUtils.copyFile(fromFile, toFile);
} else if (srcDir.equals("testdata")) {
startIdx = fromFileName.indexOf("org" + File.separator);
pkgName = fromFileName.substring(startIdx);
toFile = new File(enhancedDirName + File.separator
+ idtype + File.separator + pkgName);
FileUtils.copyFile(fromFile, toFile);
} else {
continue; // idtype not in pathname, do not copy
}
} catch (IOException ex) {
throw new MojoExecutionException("Failed to copy files from "
+ fromFileName + " to " + toFile.toString()
+ ": " + ex.getLocalizedMessage());
}
}
// Copy pc and pa classes from target/classes to enhanced
String[] extensions = {"class"};
enhancedIdDirName = enhancedDirName + idtype + File.separator;
classes = new ArrayList();
for (String pcPkgName : PC_PKG_DIRS) {
// iterator over list of abs name of class files in target/classes
fi = FileUtils.iterateFiles(
new File(classesDirName + pcPkgName), extensions, true);
while (fi.hasNext()) {
try {
fromFile = fi.next();
fromFileName = fromFile.toString();
// fully specified name of file (package + filename)
int index = fromFileName.indexOf(pcPkgName);
if (index == -1) {
throw new MojoExecutionException(
"Cannot get index of package path " + pcPkgName
+ " in file name" + fromFileName);
}
toFile = new File(enhancedIdDirName + fromFileName.substring(index));
FileUtils.copyFile(fromFile, toFile);
classes.add(toFile.toString());
} catch (IOException ex) {
throw new MojoExecutionException("Failed to copy files from "
+ fromFileName + " to " + toFile.toString()
+ ": " + ex.getLocalizedMessage());
}
}
}
}
// Enhance classes
// Build ClassLoader for finding enhancer
URL[] classPathURLs1 = new URL[2];
ArrayList cpList1 = new ArrayList();
ClassLoader enhancerLoader = null;
try {
// Must add enhancedIdDirName first!!
cpList1.add((new File(enhancedIdDirName)).toURI().toURL());
String[] jars = {"jar"};
if (impl.equals("jdori")) {
cpList1.add((new File(jdoriLibsDirectory)).toURI().toURL());
fi = FileUtils.iterateFiles(new File(jdoriLibsDirectory), jars, true);
while (fi.hasNext()) {
cpList1.add(fi.next().toURI().toURL());
}
} else {
cpList1.add((new File(iutLibsDirectory)).toURI().toURL());
fi = FileUtils.iterateFiles(new File(iutLibsDirectory), jars, true);
while (fi.hasNext()) {
cpList1.add(fi.next().toURI().toURL());
}
}
enhancerLoader = new URLClassLoader(cpList1.toArray(classPathURLs1),
getClass().getClassLoader());
System.out.println("ClassLoader enhancerLoader:");
Utilities.printClasspath(enhancerLoader);
} catch (MalformedURLException ex) {
Logger.getLogger(Enhance.class.getName()).log(Level.SEVERE, null, ex);
}
// Context classloader for finding log4j.properties
ClassLoader prevCl = Thread.currentThread().getContextClassLoader();
try {
URL implUrl;
if (impl.equals("jdori")) {
implUrl = (new File(jdoriLibsDirectory)).toURI().toURL();
} else {
implUrl = (new File(iutLibsDirectory)).toURI().toURL();
}
URL enhancedClassesUrl = (new File(enhancedIdDirName)).toURI().toURL();
// Classes dir needed for org.apache.jdo.tck.util.TCKFileAppender
URL classesUrl = (new File(classesDirName)).toURI().toURL();
ClassLoader loggingPropsCl =
URLClassLoader.newInstance(new URL[]{implUrl,
enhancedClassesUrl, classesUrl}, prevCl);
Thread.currentThread().setContextClassLoader(loggingPropsCl);
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("ClassLoader ContextClassLoader:");
Utilities.printClasspath(Thread.currentThread().getContextClassLoader());
System.out.println("Get enhancer");
JDOEnhancer enhancer = JDOHelper.getEnhancer(enhancerLoader);
System.out.println("enhancer.setVerbose()");
enhancer.setVerbose(true);
System.out.println("enhancer.setClassLoader()");
enhancer.setClassLoader(enhancerLoader);
String[] classArr = classes.toArray(classArray);
enhancer.addClasses(classArr);
System.out.println("Enhancing classes for identity type " + idtype);
// enhancer needs org/apache/jdo/tck/util/DeepEquality
enhancer.enhance();
Thread.currentThread().setContextClassLoader(prevCl);
// Move log to per-test location
String idname = "dsid";
if (idtype.trim().equals("applicationidentity")) {
idname = "app";
}
String testLogFilename = logsDirectory + File.separator +
"enhanced" + File.separator + idname +
"-" + impl + ".txt";
System.out.println("testLogFilename is " + testLogFilename);
try {
File logFile = new File(implLogFile);
File testLogFile = new File(testLogFilename);
FileUtils.copyFile(logFile, testLogFile);
} catch (Exception e) {
System.out.println(">> Error copying implementation log file: " +
e.getMessage());
}
}
System.out.println("");
}
}
exectck/src/main/java/org/apache/jdo/exectck/Help.java 100664 11117 12500110374 23140 0 ustar mbouschen staff 0 0 /*
* 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.exectck;
import org.apache.maven.plugin.AbstractMojo;
import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.plugin.MojoFailureException;
/**
* Goal that displays help text for the exectck Maven plugin.
*
* @goal help
*
* @phase integration-test
*
*/
public class Help extends AbstractMojo{
@Override
public void execute() throws MojoExecutionException, MojoFailureException {
StringBuffer msg = new StringBuffer();
msg.append("\n\n*** jdo-exectck Maven plugin ***\n\n");
msg.append("This plugin executes the JDO Technology Compatibility Kit (TCK)\n");
msg.append("against the Reference Implementation (RI) or an implementation under test (IUT).\n\n");
msg.append("- To display this help text, type \"mvn jdo-exectck:help\"\n");
msg.append("- To run the entire TCK type \"mvn integration-test\" or \"mvn install\"\n");
msg.append("- To run individual goals type \"mvn jdo-exectck:\"\n");
msg.append(" Specify command line parameters, described below, to configure the test.\n");
msg.append("\nGOALS\n");
msg.append("* installSchema\n");
msg.append(" Installs all of the database schemas required to execute tests\n");
msg.append(" in the current test configurations.\n");
msg.append("* enhance\n");
msg.append(" Enhances classes. Classes must first be compiled (mvn compile).\n");
msg.append("* runtck\n");
msg.append(" Runs the JDO Technology Compatibility Kit. Schema must first be installed and classes enhanced.\n");
msg.append("\nPARAMETERS\n");
msg.append("To set parameters from the command line, \n use the -D option and the parameter name.\n");
msg.append(" For example, \"mvn -Djdo.tck.identitytype=applicationidentity\"\n");
msg.append("* jdo.tck.impl\n");
msg.append(" jdori (reference implementation) or iut (mplementation under test\n");
msg.append("* jdo.tck.cfglist\n");
msg.append(" List of configuration files, each describing a test configuration.\n");
msg.append(" Default is all configurations.\n");
msg.append("* jdo.tck.dblist\n");
msg.append(" List of databases to run tests under.\n");
msg.append(" Currently only derby is supported\n");
msg.append("* jdo.tck.identitytypes\n");
msg.append(" List of identity types to be tested\n");
msg.append(" Default value is \"applicationidentity datastoreidentity\"\n");
msg.append("* project.lib.iut.directory\n");
msg.append(" Location of implementation jar files. Default: ${basedir}/../lib/iut\n");
msg.append("* jdo.tck.impl.logfile\n");
msg.append(" Location of implementation log file. Default: ${user.dir}/datanucleus.txt\n");
msg.append("* jdo.tck.doInstallSchema\n");
msg.append(" Setting this parameter to false will bypass schema installation.\n");
msg.append("* jdo.tck.doEnhance\n");
msg.append(" Setting this parameter to false will bypass enhancement.\n");
msg.append("* jdo.tck.doRunTCK\n");
msg.append(" Setting this parameter to false will bypass running the TCK.\n");
msg.append("* jdo.tck.runTCKVerbose\n");
msg.append(" Setting this parameter to true will display test progress and"
+ "error output while the TCK is running.\n");
msg.append("\n To run the TCK on an implementation under test, \n"
+ " place all required jars and their dependencies in lib/iut\n"
+ " and set jdo.tck.impl to iut:\n");
msg.append(" mvn integration-test -D jdo.tck.impl=\"iut\"\n\n");
msg.append("\n END EXECTCK HELP INFORMATION\n");
System.out.println(msg.toString());
}
}
exectck/src/main/java/org/apache/jdo/exectck/InstallSchema.java 100664 17166 12500110374 25011 0 ustar mbouschen staff 0 0 /*
* Copyright 2006-2012 The Apache Software Foundation.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.jdo.exectck;
import org.apache.commons.io.FileUtils;
import org.apache.maven.plugin.MojoExecutionException;
import java.io.File;
import java.io.IOException;
import java.util.Collection;
import java.util.HashSet;
/**
* Goal that installs a database schema for testing a JDO implementation.
*
* @goal installSchema
*
* @phase integration-test
*/
public class InstallSchema extends AbstractTCKMojo {
/**
* Location of TCK generated output.
* @parameter property="jdo.tck.doInstallSchema"
* default-value="true"
* @required
*/
private boolean doInstallSchema;
/**
* List of mappings required by the current configuration
*/
protected Collection mappings = new HashSet();
@Override
public void execute() throws MojoExecutionException {
if (!doInstallSchema) {
System.out.println("Skipping InstallSchema goal!");
return;
}
if (cfgs == null) {
if (cfgList != null) {
System.out.println("cfgList is " + cfgList);
cfgs = new HashSet();
PropertyUtils.string2Set(cfgList, cfgs);
}
else {
// Fallback to "src/conf/configurations.list"
setCfgListFromFile();
if (cfgList != null) {
cfgs = new HashSet();
PropertyUtils.string2Set(cfgList, cfgs);
}
if (cfgList == null) {
throw new MojoExecutionException(
"Could not find configurations to run TCK. " +
"Set cfgList parameter on command line or cfgs in pom.xml.");
}
}
}
PropertyUtils.string2Set(dblist, dbs);
PropertyUtils.string2Set(identitytypes, idtypes);
PropertyUtils.mappingsSet(cfgs, confDirectory, mappings);
System.out.println("*>Schemas to be installed for \n configurations: "
+ cfgs.toString() + "\n databases: " + dbs.toString()
+ "\n identity types: " + identitytypes.toString());
System.setProperty("java.security.manager", "default");
System.setProperty("java.security.policy", confDirectory
+ File.separator + "security.policy");
for (String db : dbs) {
if ("derby".equalsIgnoreCase(db)) {
// Currently we support only derby. To support additional db's, configuration
// data must be parameterized.
// Create directory for db logs
String dbLogsDirName = logsDirectory + File.separator + "database";
File dbLogsDir = new File(dbLogsDirName);
if (!(dbLogsDir.exists()) && !(dbLogsDir.mkdirs())) {
throw new MojoExecutionException("Failed to create directory "
+ dbLogsDir);
}
// Create database directory
String dbDirName = buildDirectory + File.separator + "database"
+ File.separator + db;
File dbDir = new File(dbDirName);
if (!(dbDir.exists()) && !(dbDir.mkdirs())) {
throw new MojoExecutionException("Failed to create directory "
+ dbDir);
}
// Copy derby.properties to db dir
File dbConf = new File(confDirectory + File.separator + db
+ ".properties");
File targetDir = new File(dbDirName);
try {
FileUtils.copyFileToDirectory(dbConf, targetDir, false);
} catch (IOException ex) {
throw new MojoExecutionException("Failed to copy file " + dbConf
+ " to " + dbDir + ": " + ex.getLocalizedMessage());
}
if (mappings.contains("0")) {
// If schema was explicitly specified as "0" change to "" since
// the schema file in that case is "schema.sql". Note that this
// removes a duplicate entry too
mappings.remove("0");
mappings.add("");
}
// Create database
for (String idtype : idtypes) {
for (String mapping : mappings) {
System.setProperty("ij.outfile", logsDirectory + File.separator
+ "database" + File.separator + db + "_" + idtype
+ "_" + mapping + ".txt");
System.out.print("*> Installing schema" + mapping
+ ".sql for " + db + " " + idtype + " ... ");
String[] args = {sqlDirectory + File.separator + db
+ File.separator + idtype + File.separator
+ "schema" + mapping + ".sql"};
System.setProperty("derby.system.home", dbDirName);
boolean success = true;
try {
org.apache.derby.tools.ij.main(args);
} catch (IOException ioex) {
success = false;
System.out.println("FAILED!");
throw new MojoExecutionException(
"*> Failed to execute ij: " +
ioex.getLocalizedMessage());
} catch (Exception ex) {
success = false;
System.out.println("FAILED!");
ex.printStackTrace();
System.out.println("*> Classpath is ");
new Utilities().printClasspath();
System.out.println("*> derby.system.home is \n "
+ System.getProperty("derby.system.home"));
System.out.println("*> jdo.tck.basedir is \n "
+ System.getProperty("jdo.tck.basedir"));
System.out.println("*> ij.outfile is \n "
+ System.getProperty("ij.outfile"));
System.out.println("*> java.security.manager is \n "
+ System.getProperty("java.security.manager"));
System.out.println("*> java.security.policy is \n "
+ System.getProperty("java.security.policy"));
} finally {
if (success) {
System.out.println("done");
}
}
}
}
System.out.println("*> See diagnostic output in " + dbLogsDir + ".");
System.out.println("");
}
}
}
}
exectck/src/main/java/org/apache/jdo/exectck/PropertyUtils.java 100664 11002 12500110374 25106 0 ustar mbouschen staff 0 0 /*
* Copyright 2006-2012 The Apache Software Foundation.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.jdo.exectck;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.Collection;
import java.util.List;
import java.util.Properties;
import java.util.logging.Level;
import java.util.logging.Logger;
/**
* Helper class that sets properties required for running the JDO TCK.
*
*/
public class PropertyUtils {
/**
* Separates white space separated items from a String into Collection entries
* Used to collect command line argument lists into a Collection
*
* @param names String of white space separated items
* @param list HashSet to contain String items
*/
public static void string2Set(String names, Collection list) {
String[] items = names.split("[ \t\n]");
for (String s : items) {
list.add(s);
}
}
/**
* Separates white space separated items from a String into HashSet entries
* Used to collect command line argument lists into a Collection
*
* @param names String of white space separated items
* @param list HashSet to contain String items
*/
public static void string2List(String names, List list) {
// System.out.println("names are " + names);
String[] items = names.split("[ \t\n]");
for (String s : items) {
list.add(s);
}
// System.out.println("List names are " + list.toString());
}
/**
* Parses a set of config files for the mapping entry and
* provides the mapping values in a Collection.
* @param cfglist config file names
* @param confDir directory where config files are found
* @param mappings object to containg mapping values
*/
public static void mappingsSet(Collection cfglist, String confDir,
Collection mappings) {
for (String cfg : cfglist) {
String mapping = "";
String confName = confDir + File.separator + cfg;
Properties props = new Properties();
FileInputStream fis = null;
// System.out.println("confName is " + confName);
try {
fis = new FileInputStream(confName);
props.load(fis);
mapping = props.getProperty("jdo.tck.mapping");
// System.out.println("Next mapping is " + mapping);
} catch (IOException e) {
e.printStackTrace();
try {
if (fis != null) {
fis.close();
}
} catch (IOException ex) {
Logger.getLogger(PropertyUtils.class.getName()).log(Level.SEVERE, null, ex);
}
return;
}
mappings.add(mapping);
}
}
/*
* Open a properties file and return a Properties object
*/
public static Properties getProperties(String fname){
Properties props = new Properties();
FileInputStream fis = null;
try {
fis = new FileInputStream(new File(fname));
props.load(fis);
} catch (IOException e) {
e.printStackTrace();
try {
if (fis != null) {
fis.close();
}
} catch (IOException ex) {
Logger.getLogger(PropertyUtils.class.getName()).log(Level.SEVERE, null, ex);
}
}
return props;
}
/*
* Set the value of key if found in properties.
*/
public static void setSysProperty(Properties properties, String key, String newkey) {
String value = properties.getProperty("key");
if (value != null) {
System.setProperty(newkey, value);
}
}
public static void setSysProperty(Properties properties, String key) {
setSysProperty(properties, key, key);
}
}
exectck/src/main/java/org/apache/jdo/exectck/RunTCK.java 100664 55132 12500110374 23363 0 ustar mbouschen staff 0 0 /*
* Copyright 2006-2012 The Apache Software Foundation.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.jdo.exectck;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.Properties;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.apache.commons.io.FileUtils;
import org.apache.jdo.exectck.Utilities.InvocationResult;
import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.plugin.MojoFailureException;
/**
* Goal that runs the JDO TCK against the Reference Implementation (RI)
* or an implementation under test (IUT).
*
* @goal runtck
*
* @phase integration-test
*/
public class RunTCK extends AbstractTCKMojo {
/**
* To skip running of TCK, set to false.
* @parameter property="jdo.tck.doRunTCK"
* default-value=true
* @required
*/
private boolean doRunTCK;
/**
* To run the RunTCK plugin goal in verbose mode.
* @parameter property="jdo.tck.runTCKVerbose"
* default-value=false
* @required
*/
private boolean runtckVerbose;
/**
* Run the TCK in a debugger.
* @parameter property="jdo.tck.debugTCK"
* default-value=false
* @required
*/
private boolean debugTCK;
/**
* Implementation to be tested (jdori or iut).
* Any value other than "jdori" will test an appropriately configured IUT
* @parameter property="jdo.tck.impl"
* default-value="jdori"
* @required
*/
private String impl;
/**
* Location of third party libraries such as JNDI.
* @parameter property="project.lib.ext.directory"
* default-value="${basedir}/../lib/ext"
* @required
*/
private String extLibsDirectory;
/**
* Location of implementation log file.
* @parameter property="jdo.tck.impl.logfile"
* default-value="${user.dir}/datanucleus.txt"
* @required
*/
private String implLogFile;
/**
* Location of jar files for implementation under test.
* @parameter property="project.lib.iut.directory"
* default-value="${basedir}/../lib/iut"
* @required
*/
private String iutLibsDirectory;
/**
* Location of jar files for implementation under test.
* @parameter property="project.lib.iut.directory"
* default-value="${basedir}/../lib/jdori"
* @required
*/
private String jdoriLibsDirectory;
/**
* Name of file in src/conf containing pmf properties.
* @parameter property="jdo.tck.pmfproperties"
* default-value="jdori-pmf.properties"
* @optional
*/
private String pmfProperties;
/**
* Name of file in src/conf containing property jdo.tck.exclude,
* whose value is a list of files to be excluded from testing.
* @parameter property="jdo.tck.excludefile"
* default-value="exclude.list"
* @required
*/
private String exclude;
/**
* Run the TCK tests in verbose mode.
* @parameter property="jdo.tck.verbose"
* default-value="false"
* @optional
*/
private String verbose;
/**
* To retain test output for debugging, set to false.
* @parameter property="jdo.tck.cleanupaftertest"
* default-value="true"
* @optional
*/
private String cleanupaftertest;
/**
* Properties to use in accessing database.
* @parameter property="database.runtck.sysproperties"
* default-value="-Dderby.system.home=${basedir}/target/database/derby"
* @optional
*/
private String dbproperties; // NOTE: only allows for one db
/**
* Properties to use in accessing database.
* @parameter property="jdo.tck.signaturefile"
* default-value="${basedir}/src/conf/jdo-3_1-signatures.txt"
* @optional
*/
private String signaturefile;
/**
* JVM properties.
* @parameter property="jdo.tck.jvmproperties"
* default-value="-Xmx512m"
* @optional
*/
private String jvmproperties;
/**
* User-supplied arguments for debug directives.
* @parameter property="jdo.tck.debug.jvmargs"
* default-value="-Xdebug -Xnoagent -Djava.compiler=NONE -Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=${jdo.tck.debug.port}"
* @optional
*/
private String debugDirectives;
/**
* Class used to run a batch of tests.
* @parameter property="jdo.tck.testrunnerclass"
* default-value="org.apache.jdo.tck.util.BatchTestRunner"
* @required
*/
private String testRunnerClass;
/**
* Class used to output test result and configuration information.
* @parameter property="jdo.tck.resultprinterclass"
* default-value="org.apache.jdo.tck.util.BatchResultPrinter"
* @required
*/
private String resultPrinterClass;
/**
* Helper method returning the trimmed value of the specified property.
* @param props the Properties object
* @param ke the key of the property to be returned
* @return the trimmed property value or the empty string if the property is not defined. + */
private String getTrimmedPropertyValue (Properties props, String key) {
String value = props.getProperty(key);
return value == null ? "" : value.trim();
}
@Override
public void execute() throws MojoExecutionException, MojoFailureException {
if (!doRunTCK) {
System.out.println("Skipping RunTCK goal!");
return;
}
Properties props = null;
boolean alreadyran = false;
String runonce = "false";
List propsString = new ArrayList();
List command;
String cpString = null;
InvocationResult result;
File fromFile = null;
File toFile = null;
if (impl.equals("iut")) {
pmfProperties="iut-pmf.properties";
}
if (cfgs == null) {
if (cfgList != null) {
cfgs = new ArrayList();
PropertyUtils.string2List(cfgList, (List)cfgs);
} else {
// Fallback to "src/conf/configurations.list"
setCfgListFromFile();
if (cfgList != null) {
cfgs = new ArrayList();
PropertyUtils.string2List(cfgList, (List)cfgs);
}
if (cfgList == null) {
throw new MojoExecutionException(
"Could not find configurations to run TCK. " +
"Set cfgList parameter on command line or cfgs in pom.xml");
}
}
}
PropertyUtils.string2Set(dblist, dbs);
PropertyUtils.string2Set(identitytypes, idtypes);
System.out.println("*>TCK to be run for implementation '" + impl +
"' on \n" +
" configurations: " + cfgs.toString() + "\n" +
" databases: " + dbs.toString() + "\n" +
" identitytypes: " + identitytypes.toString());
// Properties required for test execution
System.out.println("cleanupaftertest is " + cleanupaftertest);
propsString.add("-DResultPrinterClass=" + resultPrinterClass);
propsString.add("-Dverbose=" + verbose);
propsString.add("-Djdo.tck.cleanupaftertest=" + cleanupaftertest);
propsString.add("-DPMFProperties=" + buildDirectory + File.separator
+ "classes" + File.separator + pmfProperties);
propsString.add("-DPMF2Properties=" + buildDirectory + File.separator
+ "classes" + File.separator + pmfProperties);
String excludeFile = confDirectory + File.separator + exclude;
propsString.add("-Djdo.tck.exclude="
+ getTrimmedPropertyValue(PropertyUtils.getProperties(excludeFile), "jdo.tck.exclude"));
// Create configuration log directory
String timestamp = Utilities.now();
String thisLogDir = logsDirectory + File.separator + timestamp
+ File.separator;
String cfgDirName = thisLogDir + "configuration";
File cfgDir = new File(cfgDirName);
if (!(cfgDir.exists()) && !(cfgDir.mkdirs())) {
throw new MojoExecutionException("Failed to create directory "
+ cfgDirName);
}
propsString.add("-Djdo.tck.log.directory=" + thisLogDir);
// Copy JDO config files to classes dir
try {
fromFile = new File(confDirectory + File.separator + impl + "-jdoconfig.xml");
toFile = new File(buildDirectory + File.separator + "classes" +
File.separator + "META-INF" + File.separator + "jdoconfig.xml");
FileUtils.copyFile(fromFile, toFile);
fromFile = new File(confDirectory + File.separator + impl + "-persistence.xml");
toFile = new File(buildDirectory + File.separator + "classes" +
File.separator + "META-INF" + File.separator + "persistence.xml");
FileUtils.copyFile(fromFile, toFile);
} catch (IOException ex) {
Logger.getLogger(RunTCK.class.getName()).log(Level.SEVERE, null, ex);
}
// Get ClassLoader URLs to build classpath below
URL[] cpURLs = ((URLClassLoader) Thread.currentThread().getContextClassLoader()).getURLs();
ArrayList urlList = new ArrayList(Arrays.asList(cpURLs));
// Get contents of pmf properties file to build new file below
String pmfPropsReadFileName = confDirectory + File.separator + pmfProperties;
String defaultPropsContents = "";
try {
defaultPropsContents = Utilities.readFile(pmfPropsReadFileName);
} catch (IOException ex) {
Logger.getLogger(RunTCK.class.getName()).log(Level.SEVERE, null, ex);
}
for (String db : dbs) {
System.setProperty("jdo.tck.database", db);
alreadyran = false;
for (String idtype : idtypes) {
List idPropsString = new ArrayList();
idPropsString.addAll(propsString);
idPropsString.add("-Djdo.tck.identitytype=" + idtype);
String enhancedDirName = buildDirectory + File.separator + "enhanced"
+ File.separator + impl + File.separator + idtype + File.separator;
File enhancedDir = new File(enhancedDirName);
if (!(enhancedDir.exists())) {
throw new MojoExecutionException("Could not find enhanced directory "
+ enhancedDirName + ". Execute Enhance goal before RunTCK.");
}
// Set classpath string: add new entries to URLS from loader
ArrayList cpList = new ArrayList();
cpList.addAll(urlList);
try {
URL url1 = enhancedDir.toURI().toURL();
URL url2 = new File(buildDirectory + File.separator
+ "classes" + File.separator).toURI().toURL();
if (runtckVerbose) {
System.out.println("url2 is " + url2.toString());
}
cpList.add(url1);
cpList.add(url2);
String[] jars = {"jar"};
Iterator fi = FileUtils.iterateFiles(
new File(extLibsDirectory), jars, true);
while (fi.hasNext()) {
cpList.add(fi.next().toURI().toURL());
}
if (impl.equals("iut")) {
fi = FileUtils.iterateFiles(
new File(iutLibsDirectory), jars, true);
while (fi.hasNext()) {
cpList.add(fi.next().toURI().toURL());
}
} else {
fi = FileUtils.iterateFiles(
new File(jdoriLibsDirectory), jars, true);
while (fi.hasNext()) {
cpList.add(fi.next().toURI().toURL());
}
}
} catch (MalformedURLException ex) {
ex.printStackTrace();
Logger.getLogger(RunTCK.class.getName()).log(Level.SEVERE, null, ex);
}
cpString = Utilities.urls2ClasspathString(cpList);
if (runtckVerbose) {
System.out.println("\nClasspath is " + cpString);
}
for (String cfg : cfgs) {
List cfgPropsString = new ArrayList();
cfgPropsString.addAll(idPropsString);
// Parse conf file and set properties String
props = PropertyUtils.getProperties(confDirectory
+ File.separator + cfg);
cfgPropsString.add("-Djdo.tck.testdata="
+ getTrimmedPropertyValue(props, "jdo.tck.testdata"));
cfgPropsString.add("-Djdo.tck.standarddata="
+ getTrimmedPropertyValue(props, "jdo.tck.standarddata"));
cfgPropsString.add("-Djdo.tck.mapping.companyfactory="
+ getTrimmedPropertyValue(props, "jdo.tck.mapping.companyfactory"));
// innerPropsString.append("-Djdo.tck.description=\"" +
// props.getProperty("jdo.tck.description") + "\"");
cfgPropsString.add("-Djdo.tck.requiredOptions="
+ getTrimmedPropertyValue(props, "jdo.tck.requiredOptions"));
cfgPropsString.add("-Djdo.tck.signaturefile="
+ signaturefile);
String mapping = getTrimmedPropertyValue(props, "jdo.tck.mapping");
if (mapping == null) {
throw new MojoExecutionException(
"Could not find mapping value in conf file: " + cfg);
}
String classes = getTrimmedPropertyValue(props, "jdo.tck.classes");
String excludeList = getTrimmedPropertyValue(
PropertyUtils.getProperties(excludeFile), "jdo.tck.exclude");
if (classes == null) {
throw new MojoExecutionException(
"Could not find classes value in conf file: " + cfg);
}
classes = Utilities.removeSubstrs(classes, excludeList);
if (classes.equals("")) {
System.out.println("Skipping configuration " + cfg +
": classes excluded");
continue;
}
List classesList = Arrays.asList(classes.split(" "));
cfgPropsString.add("-Djdo.tck.schemaname=" + idtype + mapping);
cfgPropsString.add("-Djdo.tck.cfg=" + cfg);
runonce = getTrimmedPropertyValue(props, "runOnce");
runonce = (runonce == null) ? "false" : runonce;
// Add Mapping and schemaname to properties file
StringBuffer propsFileData = new StringBuffer();
propsFileData.append("\n### Properties below added by maven 2 goal RunTCK.jdori");
propsFileData.append("\njavax.jdo.mapping.Schema=" + idtype + mapping);
mapping = (mapping.equals("0")) ? "" : mapping;
propsFileData.append("\njavax.jdo.option.Mapping=standard" + mapping);
propsFileData.append("\n");
String pmfPropsWriteFileName = buildDirectory + File.separator
+ "classes" + File.separator + pmfProperties;
try {
BufferedWriter out = new BufferedWriter(new FileWriter(pmfPropsWriteFileName, false));
out.write(defaultPropsContents + propsFileData.toString());
out.close();
} catch (IOException ex) {
Logger.getLogger(RunTCK.class.getName()).log(Level.SEVERE, null, ex);
}
// build command line string
command = new ArrayList();
command.add("java");
command.add("-cp");
command.add(cpString);
command.addAll(cfgPropsString);
command.add(dbproperties);
command.add(jvmproperties);
if (debugTCK) {
command.add(debugDirectives);
}
command.add(testRunnerClass);
command.addAll(classesList);
if (runonce.equals("true") && alreadyran) {
continue;
}
if (debugTCK) {
System.out.println("Using debug arguments: \n"
+ debugDirectives);
}
// invoke class runner
System.out.print("*> Running tests for " + cfg +
" with " + idtype +
" on '" + db + "'" +
" mapping=" + mapping + " ... ");
try {
result = (new Utilities()).invokeTest(command);
if (result.getExitValue() == 0) {
System.out.println("success");
} else {
System.out.println("FAIL");
}
if (runtckVerbose) {
System.out.println("\nCommand line is: \n" + command.toString());
System.out.println("Test exit value is " + result.getExitValue());
System.out.println("Test result output:\n" + result.getOutputString());
System.out.println("Test result error:\n" + result.getErrorString());
}
} catch (java.lang.RuntimeException re) {
System.out.println("Exception on command " + command);
}
// Move log to per-test location
String idname = "dsid";
if (idtype.trim().equals("applicationidentity")) {
idname = "app";
}
String configName = cfg;
if (cfg.indexOf('.') > 0) {
configName = configName.substring(0, cfg.indexOf('.'));
}
String testLogFilename = thisLogDir
+ idname + "-" + configName + "-" + impl + ".txt";
try {
File logFile = new File(implLogFile);
FileUtils.copyFile(logFile, new File(testLogFilename));
} catch (Exception e) {
System.out.println(">> Error copying implementation log file: "
+ e.getMessage());
}
if (runonce.equals("true")) {
alreadyran = true;
}
}
}
}
// Remove log file
try {
FileUtils.forceDelete(new File(implLogFile));
} catch (Exception e) {
System.out.println(">> Error deleting log file: "
+ e.getMessage());
}
// Output results
command = new ArrayList();
command.add("java");
command.add("-cp");
command.add(cpString);
command.add("org.apache.jdo.tck.util.ResultSummary");
command.add(thisLogDir);
result = (new Utilities()).invokeTest(command, new File(buildDirectory));
// Create system configuration description file
command.set(3, "org.apache.jdo.tck.util.SystemCfgSummary");
command.set(4, cfgDirName);
command.add("system_config.txt");
result = (new Utilities()).invokeTest(command, new File(buildDirectory));
// Copy metadata from enhanced to configuration logs directory
for (String idtype : idtypes) {
String fromDirName = buildDirectory + File.separator + "enhanced"
+ File.separator + impl + File.separator + idtype + File.separator;
String[] metadataExtensions = {"jdo", "jdoquery", "orm", "xml", "properties"};
String fromFileName = null;
String pkgName = null;
int startIdx = -1;
// iterator over list of abs name of metadata files in src
Iterator fi = FileUtils.iterateFiles(
new File(fromDirName), metadataExtensions, true);
while (fi.hasNext()) {
try {
fromFile = fi.next();
fromFileName = fromFile.toString();
// System.out.println("Copying " + fromFileName);
if ((startIdx = fromFileName.indexOf(idtype + File.separator)) > -1) {
// fully specified name of file (idtype + package + filename)
pkgName = fromFileName.substring(startIdx);
toFile = new File(cfgDirName + File.separator
+ pkgName);
// System.out.println("Copy from source dir to " + toFile.toString());
FileUtils.copyFile(fromFile, toFile);
}
} catch (IOException ex) {
throw new MojoExecutionException("Failed to copy files from "
+ fromFileName + " to " + toFile.toString()
+ ": " + ex.getLocalizedMessage());
}
}
}
}
}
exectck/src/main/java/org/apache/jdo/exectck/Utilities.java 100664 21255 12500110374 24227 0 ustar mbouschen staff 0 0 /*
* 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.exectck;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
import java.net.URL;
import java.net.URLClassLoader;
import java.nio.CharBuffer;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.List;
import java.util.Map;
import javax.jdo.JDOException;
public class Utilities {
Utilities() {
}
public static final String DATE_FORMAT_NOW = "yyyyMMdd-HHmmss";
/*
* Return the current date/time as a String.
*/
public static String now() {
Calendar cal = Calendar.getInstance();
SimpleDateFormat sdf = new SimpleDateFormat(DATE_FORMAT_NOW);
return sdf.format(cal.getTime());
}
/*
* From an array of URLs, create a classpath String suitable for use
* as a command line argument
*/
public static String urls2ClasspathString(ArrayList urls) {
StringBuffer cp = new StringBuffer();
for (URL url: urls) {
cp.append(url.getPath());
cp.append(File.pathSeparator);
}
return cp.toString();
}
public static String removeSubstrs(String master, String exclude) {
String [] deleteThese = exclude.split(" ");
String filtered = master;
for (String sub: deleteThese) {
filtered = filtered.replaceAll(sub.trim(), "");
}
return filtered.trim();
}
public static void printClasspath(ClassLoader loader) {
//Get the URLs
URL[] urls = ((URLClassLoader) loader).getURLs();
System.out.println(urls.length + " URL(s) for loader: ");
for (int i = 0; i < urls.length; i++) {
if (urls[i] != null) {
System.out.println(" " + urls[i].getFile());
}
}
}
public void printClasspath() {
//Get the System Classloader
ClassLoader loader = ClassLoader.getSystemClassLoader();
//Get the URLs
URL[] urls = ((URLClassLoader) loader).getURLs();
for (int i = 0; i < urls.length; i++) {
System.out.println(" " + urls[i].getFile());
}
//Get the System Classloader
loader = Thread.currentThread().getContextClassLoader();
//Get the URLs
urls = ((URLClassLoader) loader).getURLs();
for (int i = 0; i < urls.length; i++) {
System.out.println(" " + urls[i].getFile());
}
}
static String readFile( String fileName ) throws IOException {
BufferedReader reader = new BufferedReader( new FileReader (fileName));
String line = null;
StringBuffer stringBuf = new StringBuffer();
String ls = System.getProperty("line.separator");
while( ( line = reader.readLine() ) != null ) {
stringBuf.append( line );
stringBuf.append( ls );
}
return stringBuf.toString();
}
InvocationResult invokeTest(List command) {
InvocationResult result = new InvocationResult();
try {
ProcessBuilder builder = new ProcessBuilder(command);
Map env = builder.environment();
Process proc = builder.start();
InputStream stdout = proc.getInputStream();
InputStream stderr = proc.getErrorStream();
CharBuffer outBuffer = CharBuffer.allocate(1000000);
CharBuffer errBuffer = CharBuffer.allocate(1000000);
Thread outputThread = createReaderThread(stdout, outBuffer);
Thread errorThread = createReaderThread(stderr, errBuffer);
int exitValue = proc.waitFor();
result.setExitValue(exitValue);
errorThread.join(10000); // wait ten seconds to get stderr after process terminates
outputThread.join(10000); // wait ten seconds to get stdout after process terminates
result.setErrorString(errBuffer.toString());
result.setOutputString(outBuffer.toString());
// wait until the Enhancer command finishes
} catch (InterruptedException ex) {
throw new RuntimeException("InterruptedException", ex);
} catch (IOException ex) {
throw new RuntimeException("IOException", ex);
} catch (JDOException jdoex) {
jdoex.printStackTrace();
Throwable[] throwables = jdoex.getNestedExceptions();
System.out.println("Exception throwables of size: " + throwables.length);
for (Throwable throwable: throwables) {
throwable.printStackTrace();
}
}
return result;
}
InvocationResult invokeTest(List command, File directory) {
InvocationResult result = new InvocationResult();
try {
ProcessBuilder builder = new ProcessBuilder(command);
builder.directory(directory);
Map env = builder.environment();
Process proc = builder.start();
InputStream stdout = proc.getInputStream();
InputStream stderr = proc.getErrorStream();
CharBuffer outBuffer = CharBuffer.allocate(1000000);
CharBuffer errBuffer = CharBuffer.allocate(1000000);
Thread outputThread = createReaderThread(stdout, outBuffer);
Thread errorThread = createReaderThread(stderr, errBuffer);
int exitValue = proc.waitFor();
result.setExitValue(exitValue);
errorThread.join(10000); // wait ten seconds to get stderr after process terminates
outputThread.join(10000); // wait ten seconds to get stdout after process terminates
result.setErrorString(errBuffer.toString());
result.setOutputString(outBuffer.toString());
// wait until the Enhancer command finishes
} catch (InterruptedException ex) {
throw new RuntimeException("InterruptedException", ex);
} catch (IOException ex) {
throw new RuntimeException("IOException", ex);
} catch (JDOException jdoex) {
jdoex.printStackTrace();
Throwable[] throwables = jdoex.getNestedExceptions();
System.out.println("Exception throwables of size: " + throwables.length);
for (Throwable throwable: throwables) {
throwable.printStackTrace();
}
}
return result;
}
private Thread createReaderThread(final InputStream input, final CharBuffer output) {
final Reader reader = new InputStreamReader(input);
Thread thread = new Thread(
new Runnable() {
public void run() {
int count = 0;
int outputBytesRead = 0;
try {
while (-1 != (outputBytesRead = reader.read(output))) {
count += outputBytesRead;
}
} catch (IOException e) {
e.printStackTrace();
} finally {
output.flip();
}
}
});
thread.start();
return thread;
}
class InvocationResult {
private int exitValue;
private String errorString;
private String outputString;
int getExitValue() {
return exitValue;
}
private void setExitValue(int exitValue) {
this.exitValue = exitValue;
}
private void setErrorString(String errorString) {
this.errorString = errorString;
}
String getErrorString() {
return errorString;
}
private void setOutputString(String outputString) {
this.outputString = outputString;
}
String getOutputString() {
return outputString;
}
}
}
copyjdorijars/src/ 40775 0 12500110374 14444 5 ustar mbouschen staff 0 0 copyjdorijars/src/main/ 40775 0 12500110374 15370 5 ustar mbouschen staff 0 0 copyjdorijars/src/main/resources/ 40775 0 12500110374 17402 5 ustar mbouschen staff 0 0 copyjdorijars/pom.xml 100664 11116 12500110374 15307 0 ustar mbouschen staff 0 0
org.apache.jdo
parent-pom
3.1
../parent-pom
4.0.0
org.apache.jdo
copy-jdori-jars
JDO RI Jar Copy
3.1
The Java Data Objects (JDO) API is a standard interface-based Java model abstraction of persistence, developed as Java Specification Request 243 under the auspices of the Java Community Process.
scm:svn:http://svn.apache.org/repos/asf/db/jdo/tags/jdo-3.1/3.1
scm:svn:https://svn.apache.org/repos/asf/db/jdo/tags/jdo-3.1/3.1
http://svn.apache.org/viewvc/db/jdo/tags/jdo-3.1/3.1
src/main
${basedir}/src/main/resources
${basedir}/../lib/jdori
maven-clean-plugin
2.5
${basedir}/../lib/jdori
*
false
org.apache.maven.plugins
maven-dependency-plugin
copy-dependencies
package
copy-dependencies
${basedir}/../lib/jdori
org.apache.maven.plugins
maven-deploy-plugin
2.6
true
org.datanucleus
datanucleus-core
4.0.5
org.datanucleus
datanucleus-rdbms
4.0.8
org.datanucleus
datanucleus-api-jdo
4.0.5
org.datanucleus
datanucleus-api-jpa
4.0.6
c3p0
c3p0
0.9.0.2
log4j
log4j
1.2.16
DataNucleus Nightly
http://www.datanucleus.org/downloads/maven2-nightly
false
true
copyjdorijars/src/main/resources/log4j.properties 100664 7741 12500110374 22645 0 ustar mbouschen staff 0 0 #
# 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.
#############################
# TCK loggers and appenders
#############################
# Root logger
log4j.rootLogger = ERROR, TCK
# TCK logger
log4j.logger.org.apache.jdo.tck = INFO, TCK
log4j.additivity.org.apache.jdo.tck = false
# SpringFramework loggers
log4j.logger.org.springframework = ERROR, TCK
log4j.additivity.org.springframework = false
log4j.logger.org.apache.jdo.tck.pc.company.CompanyModelReader = ERROR, TCK
log4j.logger.org.apache.jdo.tck.pc.mylib.MylibReader = ERROR, TCK
# TCK appenders
log4j.appender.TCK = org.apache.jdo.tck.util.TCKFileAppender
log4j.appender.TCK.File = tck.txt
log4j.appender.TCK.layout = org.apache.log4j.PatternLayout
log4j.appender.TCK.layout.ConversionPattern = %d{HH:mm:ss,SSS} (%t) %-5p [%c] - %m%n
############################################
# JDO vendor specific loggers and appenders
############################################
#log4j.logger. = INFO
#log4j.additivity. = false
#log4j.appender. = org.apache.jdo.tck.util.TCKFileAppender
#log4j.appender..File = .txt
#log4j.appender..layout = org.apache.log4j.PatternLayout
#log4j.appender..layout.ConversionPattern = %d{HH:mm:ss,SSS} (%t) %-5p [%c] - %m%n
###################################
# DataNucleus loggers and appenders
###################################
# DataNucleus loggers
# For more details on DataNucleus logging see
# http://www.datanucleus.org/products/accessplatform/logging.html
log4j.logger.DataNucleus = INFO, DataNucleus
log4j.logger.DataNucleus.Enhancer = INFO, DataNucleus
log4j.additivity.DataNucleus = false
#log4j.logger.DataNucleus.JDO = INFO, DataNucleus
#log4j.logger.DataNucleus.Persistence = INFO, DataNucleus
#log4j.logger.DataNucleus.Query = INFO, DataNucleus
#log4j.logger.DataNucleus.Lifecycle = INFO, DataNucleus
#log4j.logger.DataNucleus.Reachability = INFO, DataNucleus
#log4j.logger.DataNucleus.Cache = INFO, DataNucleus
#log4j.logger.DataNucleus.ClassLoading = INFO, DataNucleus
#log4j.logger.DataNucleus.MetaData = DEBUG, DataNucleus
#log4j.logger.DataNucleus.Management = DEBUG, DataNucleus
#log4j.logger.DataNucleus.General = DEBUG, DataNucleus
#log4j.logger.DataNucleus.Connection = DEBUG, DataNucleus
#log4j.logger.DataNucleus.JCA = DEBUG, DataNucleus
#log4j.logger.DataNucleus.Transaction = INFO, DataNucleus
#log4j.logger.DataNucleus.Plugin = INFO, DataNucleus
#log4j.logger.DataNucleus.Store.Poid = INFO, DataNucleus
#log4j.logger.DataNucleus.Datastore = DEBUG, DataNucleus
#log4j.logger.DataNucleus.Datastore.Schema = INFO, DataNucleus
#log4j.logger.DataNucleus.Datastore.Persist = INFO, DataNucleus
#log4j.logger.DataNucleus.Datastore.Retrieve = DEBUG, DataNucleus
#log4j.logger.DataNucleus.SchemaTool = INFO, DataNucleus
# C3P0 loggers
log4j.logger.com.mchange.v2 = INFO, DataNucleus
log4j.additivity.com.mchange.v2 = false
# DataNucleus appenders
log4j.appender.DataNucleus = org.apache.jdo.tck.util.TCKFileAppender
#log4j.appender.DataNucleus = org.apache.log4j.FileAppender
log4j.appender.DataNucleus.Enhancer.File = datanucleus.txt
log4j.appender.DataNucleus.File = datanucleus.txt
log4j.appender.DataNucleus.layout = org.apache.log4j.PatternLayout
log4j.appender.DataNucleus.layout.ConversionPattern = %d{HH:mm:ss,SSS} (%t) %-5p [%c] - %m%n
tck/src/ 40775 0 12500110374 12343 5 ustar mbouschen staff 0 0 tck/src/conf/ 40775 0 12500110374 13270 5 ustar mbouschen staff 0 0 tck/src/java/ 40775 0 12500110372 13262 5 ustar mbouschen staff 0 0 tck/src/java/org/ 40775 0 12500110372 14051 5 ustar mbouschen staff 0 0 tck/src/java/org/apache/ 40775 0 12500110372 15272 5 ustar mbouschen staff 0 0 tck/src/java/org/apache/jdo/ 40775 0 12500110372 16046 5 ustar mbouschen staff 0 0 tck/src/java/org/apache/jdo/tck/ 40775 0 12500110374 16631 5 ustar mbouschen staff 0 0 tck/src/java/org/apache/jdo/tck/api/ 40775 0 12500110374 17402 5 ustar mbouschen staff 0 0 tck/src/java/org/apache/jdo/tck/api/exceptions/ 40775 0 12500110374 21563 5 ustar mbouschen staff 0 0 tck/src/java/org/apache/jdo/tck/api/fetchgroup/ 40775 0 12500110374 21550 5 ustar mbouschen staff 0 0 tck/src/java/org/apache/jdo/tck/api/instancecallbacks/ 40775 0 12500110374 23046 5 ustar mbouschen staff 0 0 tck/src/java/org/apache/jdo/tck/api/jdohelper/ 40775 0 12500110373 21355 5 ustar mbouschen staff 0 0 tck/src/java/org/apache/jdo/tck/api/persistencecapable/ 40775 0 12500110373 23235 5 ustar mbouschen staff 0 0 tck/src/java/org/apache/jdo/tck/api/persistencemanager/ 40775 0 12500110374 23261 5 ustar mbouschen staff 0 0 tck/src/java/org/apache/jdo/tck/api/persistencemanager/cache/ 40775 0 12500110374 24324 5 ustar mbouschen staff 0 0 tck/src/java/org/apache/jdo/tck/api/persistencemanager/close/ 40775 0 12500110374 24366 5 ustar mbouschen staff 0 0 tck/src/java/org/apache/jdo/tck/api/persistencemanager/detach/ 40775 0 12500110374 24511 5 ustar mbouschen staff 0 0 tck/src/java/org/apache/jdo/tck/api/persistencemanager/extent/ 40775 0 12500110374 24570 5 ustar mbouschen staff 0 0 tck/src/java/org/apache/jdo/tck/api/persistencemanager/fetchplan/ 40775 0 12500110374 25225 5 ustar mbouschen staff 0 0 tck/src/java/org/apache/jdo/tck/api/persistencemanager/flags/ 40775 0 12500110374 24355 5 ustar mbouschen staff 0 0 tck/src/java/org/apache/jdo/tck/api/persistencemanager/getobject/ 40775 0 12500110374 25227 5 ustar mbouschen staff 0 0 tck/src/java/org/apache/jdo/tck/api/persistencemanager/lifecycle/ 40775 0 12500110374 25220 5 ustar mbouschen staff 0 0 tck/src/java/org/apache/jdo/tck/api/persistencemanager/nullargs/ 40775 0 12500110374 25110 5 ustar mbouschen staff 0 0 tck/src/java/org/apache/jdo/tck/api/persistencemanagerfactory/ 40775 0 12500110374 24651 5 ustar mbouschen staff 0 0 tck/src/java/org/apache/jdo/tck/api/persistencemanagerfactory/config/ 40775 0 12500110374 26116 5 ustar mbouschen staff 0 0 tck/src/java/org/apache/jdo/tck/api/persistencemanagerfactory/metadata/ 40775 0 12500110374 26431 5 ustar mbouschen staff 0 0 tck/src/java/org/apache/jdo/tck/enhancement/ 40775 0 12500110373 21115 5 ustar mbouschen staff 0 0 tck/src/java/org/apache/jdo/tck/extents/ 40775 0 12500110374 20323 5 ustar mbouschen staff 0 0 tck/src/java/org/apache/jdo/tck/lifecycle/ 40775 0 12500110374 20570 5 ustar mbouschen staff 0 0 tck/src/java/org/apache/jdo/tck/mapping/ 40775 0 12500110374 20264 5 ustar mbouschen staff 0 0 tck/src/java/org/apache/jdo/tck/models/ 40775 0 12500110373 20113 5 ustar mbouschen staff 0 0 tck/src/java/org/apache/jdo/tck/models/embedded/ 40775 0 12500110373 21644 5 ustar mbouschen staff 0 0 tck/src/java/org/apache/jdo/tck/models/fieldtypes/ 40775 0 12500110373 22263 5 ustar mbouschen staff 0 0 tck/src/java/org/apache/jdo/tck/models/inheritance/ 40775 0 12500110373 22404 5 ustar mbouschen staff 0 0 tck/src/java/org/apache/jdo/tck/pc/ 40775 0 12500110373 17232 5 ustar mbouschen staff 0 0 tck/src/java/org/apache/jdo/tck/pc/building/ 40775 0 12500110372 21026 5 ustar mbouschen staff 0 0 tck/src/java/org/apache/jdo/tck/pc/company/ 40775 0 12500110373 20700 5 ustar mbouschen staff 0 0 tck/src/java/org/apache/jdo/tck/pc/companyAnnotatedFC/ 40775 0 12500110373 22747 5 ustar mbouschen staff 0 0 tck/src/java/org/apache/jdo/tck/pc/companyAnnotatedJPA/ 40775 0 12500110372 23070 5 ustar mbouschen staff 0 0 tck/src/java/org/apache/jdo/tck/pc/companyAnnotatedPC/ 40775 0 12500110372 22760 5 ustar mbouschen staff 0 0 tck/src/java/org/apache/jdo/tck/pc/companyAnnotatedPI/ 40775 0 12500110372 22766 5 ustar mbouschen staff 0 0 tck/src/java/org/apache/jdo/tck/pc/companyListWithoutJoin/ 40775 0 12500110373 23740 5 ustar mbouschen staff 0 0 tck/src/java/org/apache/jdo/tck/pc/companyMapWithoutJoin/ 40775 0 12500110373 23542 5 ustar mbouschen staff 0 0 tck/src/java/org/apache/jdo/tck/pc/fieldtypes/ 40775 0 12500110373 21402 5 ustar mbouschen staff 0 0 tck/src/java/org/apache/jdo/tck/pc/inheritance/ 40775 0 12500110372 21522 5 ustar mbouschen staff 0 0 tck/src/java/org/apache/jdo/tck/pc/instancecallbacks/ 40775 0 12500110372 22675 5 ustar mbouschen staff 0 0 tck/src/java/org/apache/jdo/tck/pc/lifecycle/ 40775 0 12500110372 21170 5 ustar mbouschen staff 0 0 tck/src/java/org/apache/jdo/tck/pc/mylib/ 40775 0 12500110373 20346 5 ustar mbouschen staff 0 0 tck/src/java/org/apache/jdo/tck/pc/newInstance/ 40775 0 12500110373 21510 5 ustar mbouschen staff 0 0 tck/src/java/org/apache/jdo/tck/pc/order/ 40775 0 12500110373 20345 5 ustar mbouschen staff 0 0 tck/src/java/org/apache/jdo/tck/pc/query/ 40775 0 12500110372 20376 5 ustar mbouschen staff 0 0 tck/src/java/org/apache/jdo/tck/pc/shoppingcart/ 40775 0 12500110372 21732 5 ustar mbouschen staff 0 0 tck/src/java/org/apache/jdo/tck/pc/singlefieldidentity/ 40775 0 12500110372 23270 5 ustar mbouschen staff 0 0 tck/src/java/org/apache/jdo/tck/query/ 40775 0 12500110373 17775 5 ustar mbouschen staff 0 0 tck/src/java/org/apache/jdo/tck/query/api/ 40775 0 12500110373 20546 5 ustar mbouschen staff 0 0 tck/src/java/org/apache/jdo/tck/query/delete/ 40775 0 12500110373 21237 5 ustar mbouschen staff 0 0 tck/src/java/org/apache/jdo/tck/query/jdoql/ 40775 0 12500110373 21106 5 ustar mbouschen staff 0 0 tck/src/java/org/apache/jdo/tck/query/jdoql/keywords/ 40775 0 12500110373 22755 5 ustar mbouschen staff 0 0 tck/src/java/org/apache/jdo/tck/query/jdoql/methods/ 40775 0 12500110373 22551 5 ustar mbouschen staff 0 0 tck/src/java/org/apache/jdo/tck/query/jdoql/operators/ 40775 0 12500110373 23124 5 ustar mbouschen staff 0 0 tck/src/java/org/apache/jdo/tck/query/jdoql/parameters/ 40775 0 12500110373 23251 5 ustar mbouschen staff 0 0 tck/src/java/org/apache/jdo/tck/query/jdoql/subqueries/ 40775 0 12500110373 23275 5 ustar mbouschen staff 0 0 tck/src/java/org/apache/jdo/tck/query/jdoql/variables/ 40775 0 12500110373 23056 5 ustar mbouschen staff 0 0 tck/src/java/org/apache/jdo/tck/query/result/ 40775 0 12500110373 21313 5 ustar mbouschen staff 0 0 tck/src/java/org/apache/jdo/tck/query/result/classes/ 40775 0 12500110373 22750 5 ustar mbouschen staff 0 0 tck/src/java/org/apache/jdo/tck/query/sql/ 40775 0 12500110373 20574 5 ustar mbouschen staff 0 0 tck/src/java/org/apache/jdo/tck/transactions/ 40775 0 12500110373 21340 5 ustar mbouschen staff 0 0 tck/src/java/org/apache/jdo/tck/util/ 40775 0 12500110374 17606 5 ustar mbouschen staff 0 0 tck/src/java/org/apache/jdo/tck/util/signature/ 40775 0 12500110374 21607 5 ustar mbouschen staff 0 0 tck/src/jdo/ 40775 0 12500110372 13115 5 ustar mbouschen staff 0 0 tck/src/jdo/applicationidentity/ 40775 0 12500110371 17171 5 ustar mbouschen staff 0 0 tck/src/jdo/applicationidentity/org/ 40775 0 12500110371 17760 5 ustar mbouschen staff 0 0 tck/src/jdo/applicationidentity/org/apache/ 40775 0 12500110371 21201 5 ustar mbouschen staff 0 0 tck/src/jdo/applicationidentity/org/apache/jdo/ 40775 0 12500110371 21755 5 ustar mbouschen staff 0 0 tck/src/jdo/applicationidentity/org/apache/jdo/tck/ 40775 0 12500110372 22537 5 ustar mbouschen staff 0 0 tck/src/jdo/applicationidentity/org/apache/jdo/tck/api/ 40775 0 12500110371 23307 5 ustar mbouschen staff 0 0 tck/src/jdo/applicationidentity/org/apache/jdo/tck/api/instancecallbacks/ 40775 0 12500110371 26753 5 ustar mbouschen staff 0 0 tck/src/jdo/applicationidentity/org/apache/jdo/tck/pc/ 40775 0 12500110372 23141 5 ustar mbouschen staff 0 0 tck/src/jdo/applicationidentity/org/apache/jdo/tck/pc/building/ 40775 0 12500110372 24736 5 ustar mbouschen staff 0 0 tck/src/jdo/applicationidentity/org/apache/jdo/tck/pc/company/ 40775 0 12500110371 24606 5 ustar mbouschen staff 0 0 tck/src/jdo/applicationidentity/org/apache/jdo/tck/pc/companyListWithoutJoin/ 40775 0 12500110371 27646 5 ustar mbouschen staff 0 0 tck/src/jdo/applicationidentity/org/apache/jdo/tck/pc/companyMapWithoutJoin/ 40775 0 12500110371 27450 5 ustar mbouschen staff 0 0 tck/src/jdo/applicationidentity/org/apache/jdo/tck/pc/fieldtypes/ 40775 0 12500110371 25310 5 ustar mbouschen staff 0 0 tck/src/jdo/applicationidentity/org/apache/jdo/tck/pc/inheritance/ 40775 0 12500110371 25431 5 ustar mbouschen staff 0 0 tck/src/jdo/applicationidentity/org/apache/jdo/tck/pc/instancecallbacks/ 40775 0 12500110372 26605 5 ustar mbouschen staff 0 0 tck/src/jdo/applicationidentity/org/apache/jdo/tck/pc/lifecycle/ 40775 0 12500110372 25100 5 ustar mbouschen staff 0 0 tck/src/jdo/applicationidentity/org/apache/jdo/tck/pc/mylib/ 40775 0 12500110372 24255 5 ustar mbouschen staff 0 0 tck/src/jdo/applicationidentity/org/apache/jdo/tck/pc/newInstance/ 40775 0 12500110372 25417 5 ustar mbouschen staff 0 0 tck/src/jdo/applicationidentity/org/apache/jdo/tck/pc/order/ 40775 0 12500110371 24253 5 ustar mbouschen staff 0 0 tck/src/jdo/applicationidentity/org/apache/jdo/tck/pc/query/ 40775 0 12500110371 24305 5 ustar mbouschen staff 0 0 tck/src/jdo/applicationidentity/org/apache/jdo/tck/pc/shoppingcart/ 40775 0 12500110372 25642 5 ustar mbouschen staff 0 0 tck/src/jdo/applicationidentity/org/apache/jdo/tck/pc/singlefieldidentity/ 40775 0 12500110372 27200 5 ustar mbouschen staff 0 0 tck/src/jdo/datastoreidentity/ 40775 0 12500110372 16655 5 ustar mbouschen staff 0 0 tck/src/jdo/datastoreidentity/org/ 40775 0 12500110372 17444 5 ustar mbouschen staff 0 0 tck/src/jdo/datastoreidentity/org/apache/ 40775 0 12500110372 20665 5 ustar mbouschen staff 0 0 tck/src/jdo/datastoreidentity/org/apache/jdo/ 40775 0 12500110372 21441 5 ustar mbouschen staff 0 0 tck/src/jdo/datastoreidentity/org/apache/jdo/tck/ 40775 0 12500110372 22222 5 ustar mbouschen staff 0 0 tck/src/jdo/datastoreidentity/org/apache/jdo/tck/api/ 40775 0 12500110372 22773 5 ustar mbouschen staff 0 0 tck/src/jdo/datastoreidentity/org/apache/jdo/tck/api/instancecallbacks/ 40775 0 12500110372 26437 5 ustar mbouschen staff 0 0 tck/src/jdo/datastoreidentity/org/apache/jdo/tck/pc/ 40775 0 12500110372 22624 5 ustar mbouschen staff 0 0 tck/src/jdo/datastoreidentity/org/apache/jdo/tck/pc/building/ 40775 0 12500110372 24421 5 ustar mbouschen staff 0 0 tck/src/jdo/datastoreidentity/org/apache/jdo/tck/pc/company/ 40775 0 12500110372 24272 5 ustar mbouschen staff 0 0 tck/src/jdo/datastoreidentity/org/apache/jdo/tck/pc/companyListWithoutJoin/ 40775 0 12500110372 27332 5 ustar mbouschen staff 0 0 tck/src/jdo/datastoreidentity/org/apache/jdo/tck/pc/companyMapWithoutJoin/ 40775 0 12500110372 27134 5 ustar mbouschen staff 0 0 tck/src/jdo/datastoreidentity/org/apache/jdo/tck/pc/fieldtypes/ 40775 0 12500110372 24774 5 ustar mbouschen staff 0 0 tck/src/jdo/datastoreidentity/org/apache/jdo/tck/pc/inheritance/ 40775 0 12500110372 25115 5 ustar mbouschen staff 0 0 tck/src/jdo/datastoreidentity/org/apache/jdo/tck/pc/instancecallbacks/ 40775 0 12500110372 26270 5 ustar mbouschen staff 0 0 tck/src/jdo/datastoreidentity/org/apache/jdo/tck/pc/lifecycle/ 40775 0 12500110372 24563 5 ustar mbouschen staff 0 0 tck/src/jdo/datastoreidentity/org/apache/jdo/tck/pc/mylib/ 40775 0 12500110372 23740 5 ustar mbouschen staff 0 0 tck/src/jdo/datastoreidentity/org/apache/jdo/tck/pc/newInstance/ 40775 0 12500110372 25102 5 ustar mbouschen staff 0 0 tck/src/jdo/datastoreidentity/org/apache/jdo/tck/pc/order/ 40775 0 12500110372 23737 5 ustar mbouschen staff 0 0 tck/src/jdo/datastoreidentity/org/apache/jdo/tck/pc/query/ 40775 0 12500110372 23771 5 ustar mbouschen staff 0 0 tck/src/jdo/datastoreidentity/org/apache/jdo/tck/pc/shoppingcart/ 40775 0 12500110372 25325 5 ustar mbouschen staff 0 0 tck/src/jdo/datastoreidentity/org/apache/jdo/tck/pc/singlefieldidentity/ 40775 0 12500110372 26663 5 ustar mbouschen staff 0 0 tck/src/main/ 40775 0 12500110374 13267 5 ustar mbouschen staff 0 0 tck/src/main/resources/ 40775 0 12500110374 15301 5 ustar mbouschen staff 0 0 tck/src/main/resources/META-INF/ 40775 0 12500110374 16441 5 ustar mbouschen staff 0 0 tck/src/orm/ 40775 0 12500110372 13136 5 ustar mbouschen staff 0 0 tck/src/orm/applicationidentity/ 40775 0 12500110372 17213 5 ustar mbouschen staff 0 0 tck/src/orm/applicationidentity/org/ 40775 0 12500110372 20002 5 ustar mbouschen staff 0 0 tck/src/orm/applicationidentity/org/apache/ 40775 0 12500110372 21223 5 ustar mbouschen staff 0 0 tck/src/orm/applicationidentity/org/apache/jdo/ 40775 0 12500110372 21777 5 ustar mbouschen staff 0 0 tck/src/orm/applicationidentity/org/apache/jdo/tck/ 40775 0 12500110372 22560 5 ustar mbouschen staff 0 0 tck/src/orm/applicationidentity/org/apache/jdo/tck/api/ 40775 0 12500110372 23331 5 ustar mbouschen staff 0 0 tck/src/orm/applicationidentity/org/apache/jdo/tck/api/instancecallbacks/ 40775 0 12500110372 26775 5 ustar mbouschen staff 0 0 tck/src/orm/applicationidentity/org/apache/jdo/tck/pc/ 40775 0 12500110372 23162 5 ustar mbouschen staff 0 0 tck/src/orm/applicationidentity/org/apache/jdo/tck/pc/building/ 40775 0 12500110372 24757 5 ustar mbouschen staff 0 0 tck/src/orm/applicationidentity/org/apache/jdo/tck/pc/company/ 40775 0 12500110372 24630 5 ustar mbouschen staff 0 0 tck/src/orm/applicationidentity/org/apache/jdo/tck/pc/companyAnnotatedFC/ 40775 0 12500110372 26677 5 ustar mbouschen staff 0 0 tck/src/orm/applicationidentity/org/apache/jdo/tck/pc/companyListWithoutJoin/ 40775 0 12500110372 27670 5 ustar mbouschen staff 0 0 tck/src/orm/applicationidentity/org/apache/jdo/tck/pc/companyMapWithoutJoin/ 40775 0 12500110372 27472 5 ustar mbouschen staff 0 0 tck/src/orm/applicationidentity/org/apache/jdo/tck/pc/fieldtypes/ 40775 0 12500110372 25332 5 ustar mbouschen staff 0 0 tck/src/orm/applicationidentity/org/apache/jdo/tck/pc/inheritance/ 40775 0 12500110372 25453 5 ustar mbouschen staff 0 0 tck/src/orm/applicationidentity/org/apache/jdo/tck/pc/instancecallbacks/ 40775 0 12500110372 26626 5 ustar mbouschen staff 0 0 tck/src/orm/applicationidentity/org/apache/jdo/tck/pc/lifecycle/ 40775 0 12500110372 25121 5 ustar mbouschen staff 0 0 tck/src/orm/applicationidentity/org/apache/jdo/tck/pc/mylib/ 40775 0 12500110372 24276 5 ustar mbouschen staff 0 0 tck/src/orm/applicationidentity/org/apache/jdo/tck/pc/newInstance/ 40775 0 12500110372 25440 5 ustar mbouschen staff 0 0 tck/src/orm/applicationidentity/org/apache/jdo/tck/pc/order/ 40775 0 12500110372 24275 5 ustar mbouschen staff 0 0 tck/src/orm/applicationidentity/org/apache/jdo/tck/pc/query/ 40775 0 12500110372 24327 5 ustar mbouschen staff 0 0 tck/src/orm/applicationidentity/org/apache/jdo/tck/pc/shoppingcart/ 40775 0 12500110372 25663 5 ustar mbouschen staff 0 0 tck/src/orm/applicationidentity/org/apache/jdo/tck/pc/singlefieldidentity/ 40775 0 12500110372 27221 5 ustar mbouschen staff 0 0 tck/src/orm/datastoreidentity/ 40775 0 12500110372 16676 5 ustar mbouschen staff 0 0 tck/src/orm/datastoreidentity/org/ 40775 0 12500110372 17465 5 ustar mbouschen staff 0 0 tck/src/orm/datastoreidentity/org/apache/ 40775 0 12500110372 20706 5 ustar mbouschen staff 0 0 tck/src/orm/datastoreidentity/org/apache/jdo/ 40775 0 12500110372 21462 5 ustar mbouschen staff 0 0 tck/src/orm/datastoreidentity/org/apache/jdo/tck/ 40775 0 12500110372 22243 5 ustar mbouschen staff 0 0 tck/src/orm/datastoreidentity/org/apache/jdo/tck/api/ 40775 0 12500110372 23014 5 ustar mbouschen staff 0 0 tck/src/orm/datastoreidentity/org/apache/jdo/tck/api/instancecallbacks/ 40775 0 12500110372 26460 5 ustar mbouschen staff 0 0 tck/src/orm/datastoreidentity/org/apache/jdo/tck/pc/ 40775 0 12500110372 22645 5 ustar mbouschen staff 0 0 tck/src/orm/datastoreidentity/org/apache/jdo/tck/pc/building/ 40775 0 12500110372 24442 5 ustar mbouschen staff 0 0 tck/src/orm/datastoreidentity/org/apache/jdo/tck/pc/company/ 40775 0 12500110372 24313 5 ustar mbouschen staff 0 0 tck/src/orm/datastoreidentity/org/apache/jdo/tck/pc/companyAnnotatedFC/ 40775 0 12500110372 26362 5 ustar mbouschen staff 0 0 tck/src/orm/datastoreidentity/org/apache/jdo/tck/pc/companyListWithoutJoin/ 40775 0 12500110372 27353 5 ustar mbouschen staff 0 0 tck/src/orm/datastoreidentity/org/apache/jdo/tck/pc/companyMapWithoutJoin/ 40775 0 12500110372 27155 5 ustar mbouschen staff 0 0 tck/src/orm/datastoreidentity/org/apache/jdo/tck/pc/fieldtypes/ 40775 0 12500110372 25015 5 ustar mbouschen staff 0 0 tck/src/orm/datastoreidentity/org/apache/jdo/tck/pc/inheritance/ 40775 0 12500110372 25136 5 ustar mbouschen staff 0 0 tck/src/orm/datastoreidentity/org/apache/jdo/tck/pc/instancecallbacks/ 40775 0 12500110372 26311 5 ustar mbouschen staff 0 0 tck/src/orm/datastoreidentity/org/apache/jdo/tck/pc/lifecycle/ 40775 0 12500110372 24604 5 ustar mbouschen staff 0 0 tck/src/orm/datastoreidentity/org/apache/jdo/tck/pc/mylib/ 40775 0 12500110372 23761 5 ustar mbouschen staff 0 0 tck/src/orm/datastoreidentity/org/apache/jdo/tck/pc/newInstance/ 40775 0 12500110372 25123 5 ustar mbouschen staff 0 0 tck/src/orm/datastoreidentity/org/apache/jdo/tck/pc/query/ 40775 0 12500110372 24012 5 ustar mbouschen staff 0 0 tck/src/orm/datastoreidentity/org/apache/jdo/tck/pc/shoppingcart/ 40775 0 12500110372 25346 5 ustar mbouschen staff 0 0 tck/src/sql/ 40775 0 12500110372 13140 5 ustar mbouschen staff 0 0 tck/src/sql/derby/ 40775 0 12500110372 14245 5 ustar mbouschen staff 0 0 tck/src/sql/derby/applicationidentity/ 40775 0 12500110372 20322 5 ustar mbouschen staff 0 0 tck/src/sql/derby/datastoreidentity/ 40775 0 12500110372 20005 5 ustar mbouschen staff 0 0 tck/src/testdata/ 40775 0 12500110374 14154 5 ustar mbouschen staff 0 0 tck/src/testdata/org/ 40775 0 12500110374 14743 5 ustar mbouschen staff 0 0 tck/src/testdata/org/apache/ 40775 0 12500110374 16164 5 ustar mbouschen staff 0 0 tck/src/testdata/org/apache/jdo/ 40775 0 12500110374 16740 5 ustar mbouschen staff 0 0 tck/src/testdata/org/apache/jdo/tck/ 40775 0 12500110374 17521 5 ustar mbouschen staff 0 0 tck/src/testdata/org/apache/jdo/tck/pc/ 40775 0 12500110374 20123 5 ustar mbouschen staff 0 0 tck/src/testdata/org/apache/jdo/tck/pc/company/ 40775 0 12500110374 21571 5 ustar mbouschen staff 0 0 tck/src/testdata/org/apache/jdo/tck/pc/companyListWithoutJoin/ 40775 0 12500110374 24631 5 ustar mbouschen staff 0 0 tck/src/testdata/org/apache/jdo/tck/pc/companyMapWithoutJoin/ 40775 0 12500110374 24433 5 ustar mbouschen staff 0 0 tck/src/testdata/org/apache/jdo/tck/pc/mylib/ 40775 0 12500110374 21237 5 ustar mbouschen staff 0 0 tck/src/testdata/org/apache/jdo/tck/pc/order/ 40775 0 12500110374 21236 5 ustar mbouschen staff 0 0 tck/src/uml/ 40775 0 12500110372 13136 5 ustar mbouschen staff 0 0 tck/src/uml/org/ 40775 0 12500110372 13725 5 ustar mbouschen staff 0 0 tck/src/uml/org/apache/ 40775 0 12500110372 15146 5 ustar mbouschen staff 0 0 tck/src/uml/org/apache/jdo/ 40775 0 12500110372 15722 5 ustar mbouschen staff 0 0 tck/src/uml/org/apache/jdo/tck/ 40775 0 12500110372 16503 5 ustar mbouschen staff 0 0 tck/src/uml/org/apache/jdo/tck/pc/ 40775 0 12500110372 17105 5 ustar mbouschen staff 0 0 tck/src/uml/org/apache/jdo/tck/pc/shoppingcart/ 40775 0 12500110372 21606 5 ustar mbouschen staff 0 0 tck/pom.xml 100664 16764 12500110374 13224 0 ustar mbouschen staff 0 0
org.apache.jdo
parent-pom
3.1
../parent-pom
4.0.0
org.apache.jdo
jdo-tck
3.1
JDO Technology Compatibility Kit (TCK)
The Java Data Objects (JDO) API is a standard interface-based Java model abstraction of persistence, developed as Java Specification Request JSR 243 under the auspices of the Java Community Process.
The JDO TCK is a test suite designed to test implementations of the Java Data Objects specification. In order to claim compatibility with JDO, an implementation must pass all relevant tests of the JDOTCK.
NOTE!! There are no unit tests in this project.
scm:svn:http://svn.apache.org/repos/asf/db/jdo/tags/jdo-3.1/3.1
scm:svn:https://svn.apache.org/repos/asf/db/jdo/tags/jdo-3.1/3.1
http://svn.apache.org/viewvc/db/jdo/tags/jdo-3.1/3.1
src/java
META-INF
src/main/resources
META-INF/NOTICE.txt
${basedir}/src/conf
${basedir}/src/jdo
${basedir}/src/orm
${basedir}/src/sql
${basedir}/src/testdata
org.apache.jdo
jdo-exectck
3.1
integration-test
help
installSchema
enhance
runtck
maven-compiler-plugin
1.5
1.5
maven-jar-plugin
maven-javadoc-plugin
${project.name} ${pom.currentVersion}
${project.name} ${pom.currentVersion}
org.apache.maven.plugins
maven-deploy-plugin
2.6
true
iut
jdo.tck.impl
iut
jdori
true
javax.jdo
jdo-api
junit
junit
commons-logging
commons-logging
javax.transaction
transaction-api
org.springframework
spring-core
org.springframework
spring-beans
org.eclipse.persistence
javax.persistence
maven-changes-plugin
${basedir}/xdocs/changes.xml
maven-checkstyle-plugin
${basedir}/../jdo_checks.xml
${basedir}/../LICENSE.txt
maven-clean-plugin
2.5
${basedir}
query.ser
datanucleus.txt
tck/RunRules.html 100664 24472 12500110371 14344 0 ustar mbouschen staff 0 0
JDO 3.1 Technology Compatibility Kit Run Rules
Running the JDO 3.1 Technology Compatibility Kit
7-March-2015
Overview
In order to demonstrate compliance with the Java Data Objects
specification, an implementation must successfully run all of the TCK
tests that are not on the "excluded" list. The
implementation is hereinafter referred to as the IUT (Implementation
Under Test).
The results must be posted on a publicly accessible web site for
examination by the public. The posting includes the output of the
test run, which consists of multiple log files containing
configuration information and test results. For an example of the
required posting, please see http://db.apache.org/jdo/tck/final .
Prerequisites
In order to run the TCK, you must install Maven 2.x
Maven
http://maven.apache.org/
is the
driver of the test programs.
You must test the IUT on all configurations that the IUT supports.
This includes different hardware and operating systems, different
versions of Java, and different datastores. The TCK supports Java
versions 1.5 to 1.6.
Installation
Download the jdo.3.x-src.zip or jdo.3.x-src.gz file from the distribution location. Unpack the archive file into a directory of your choice.
Follow the instructions in the root level README.html file for building and running the JDO TCK.
Please take note of the following files:
Maven configuration file "pom.xml"
in the top level directory and subprojects.
These files must not be changed.
lib/ext -
Copy the jar files fscontext.jar and providerutil.jar used by the JNDI tests
into this directory.
It is permitted to use a different JNDI implementation; see
README.html for more information.
lib/iut - this directory is where the JDO implementation
jars are installed. It is empty in the distribution. To use the
maven target runtck (required for an implementation to prove
compliance), copy the JDO implementation jar files into this
directory. Alternatively, update the build.properties file in the
TCK directory to refer to an existing location of the IUT jar
files.
the TCK directory, which contains:
assertions - contains the assertions file identifying the
assertions tested by the tests. This is for reference.
target - this directory contains artifacts of compiling and
running the tests. It does not exist in the distribution and will
be created by the maven build process.
src - this directory contains the test configuration files
and directories:
testdata - this directory contains data (represented as
.xml files) loaded into the datastore for tests. These files must
not be modified.
sql - this directory contains DDL to define the tables
used in the tests. The files distributed must not be modified.
Files may be created for databases for which the DDL for the
database under test is not provided.
jdo - this directory contains .jdo metadata files for the
persistent classes used in the tests. These files must not be
modified.
orm - this directory contains .orm metadata files to map
the persistent classes to the sql tables. These files must not
be modified except to add DDL-generation information
(which is not used by the TCK).
java - this directory contains the source code to the TCK
tests. These files must not be modified.
conf - this directory contains the configuration
information for the test runs. The files iut-pmf.properties,
iut-jdoconfig.xml, and iut-persistence.xml in this directory
must be changed to provide properties for the IUT persistence
manager factory. The file jndi.properties may be changed
to use a different jndi provider. Other files must not be
modified, except to put a successfully challenged test case into
the trunk/tck20/test/conf/exclude.list. Please see below.
Modifying
the Configuration
The Implementation Under Test (IUT) can be installed into the
lib/iut directory. Any jar files in this
directory are added to the class path used to run the tests.
There are properties in the build.properties file in the TCK
directory that must be changed to configure the IUT execution and
enhancement (optional) environment. These properties begin with
iut.runtck and iut.enhancer.
There is are three properties files that must be modified to be
IUT-specific, all located in the TCK src/conf directory. The
iut-pmf.properties file contains information used to construct the
PersistenceManagerFactory used in the tests. iut-jdoconfig.xml and
iut-persistence.xml also contain PersistenceManagerFactory properties
used only in tests in the
org.apache.jdo.tck.api.persistencemanagerfactory.config package.
SQL DDL files are provided for the sql table definitions. The
existing files must not be changed, but files may be added in the
directory in order to provide DDL for additional databases supported
by the JDO implementation under test.
Running
the Tests
Follow the instructions in README.html for running the TCK on the JDO Reference Implementation
and the Implementation Under Test.
This will produce console output plus a
directory in the tck/target/logs directory whose name contains the
date/time the tests were started. This directory contains the output
of the tests. This is the directory to be published.
Some of the TCK tests require the implementation to support up to
20 instances of PersistenceManager with open transactions
simultaneously.
Debugging
the IUT while Running TCK tests
Execute "mvn jdo-exectck:help" in the TCK directory in order to
get information on running the TCK tests with a debugger. In
particular, properties jdo.tck.cleanupaftertest, jdo.tck.cfglist,
jdo.tck.identitytypes, and jdo.tck.dblist may be useful.
If you make a change to the IUT enhancer while debugging the TCK
tests (for implementations that use an enhancer) you must remove the
target/classes directory before continuing in order to make sure that
the classes are re-enhanced by the changed code.
Publishing
the Results of the TCK Tests
With a successful test run, the log directory with the results of
the tests must be published on a publicly-available web site. The
unmodified directory is the self-certification of the successful TCK
test run.
First
Level TCK Appeals Process
If
any test does not pass on the JDO implementation under test, this may
be due to an error in the implementation or in the TCK test. If you
believe that the failure is due to an error in the TCK test, you may
challenge the test. To do so, send email to: jdo-dev@db.apache.org
with a subject line containing "CHALLENGE" and the name of
the test program, e.g.
org.apache.jdo.tck.api.persistencemanager.ThreadSafe.java; and the
body of the email containing the details of the challenge.
The Maintenance Lead will respond within 15 working days with a
decision on whether there is an error in the test case. If the issue
is found by the Maintenance Lead to be due to an error in the test
case, the Maintenance Lead might patch the erroneous test or add the test
to the exclude list.
The user can obtain the TCK updates by checking out the latest minor version branch, 3.n.1.
If a fix is not provided within 15 working days of the receipt of the challenge,
then the user may put the test into the TCK file src/conf/exclude.list and
it will not be run as part of the TCK.
Decisions of the Maintenance Lead may be appealed to the full
expert group. A vote of the full expert group will be conducted by
the Maintenance Lead, and a majority of votes cast will decide the
issue. The Maintenance Lead has one vote, as does each member of the
expert group at the time of the vote.
tck/src/conf/applicationidentity.conf 100664 1714 12500110374 20314 0 ustar mbouschen staff 0 0 # 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.
# either datastoreidentity or applicationidentity
jdo.tck.identitytype = applicationidentity
jdo.tck.testclasses = ${jdo.tck.alltests}
jdo.tck.schema = schema1.sql
jdo.tck.requiredOptions =
tck/src/conf/commons-logging.properties 100664 3351 12500110374 20604 0 ustar mbouschen staff 0 0 #
# 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.
#
# This is a sample apache commons logging configuration file defining logging
# properties for the JDO TCK. It defines what logging implementation
# the apache commons logging API should use by specifying the property
# org.apache.commons.logging.Log (see below). Please note, that there are
# separate property files for each logging implementation to set the log
# level of the loggers:
# - SimpleLog: simplelog.properties
# - JDK1.4 logging: logging.properties
#
# The JDO TCK test cases use the following logger instance:
# org.apache.jdo.tck
#
# Uncomment the next line if you want to use the apache simple logger
#org.apache.commons.logging.Log = org.apache.commons.logging.impl.SimpleLog
# Uncomment the next line if you want to use JDK 1.4 logging
#org.apache.commons.logging.Log = org.apache.jdo.tck.util.JDOJdk14Logger
# Uncomment the next line if you want to use Log4j logging
org.apache.commons.logging.Log = org.apache.commons.logging.impl.Log4JLogger
tck/src/conf/company1-1Relationships.conf 100664 2117 12500110374 20667 0 ustar mbouschen staff 0 0 # 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.
jdo.tck.description = Completeness test with standard mapping, basic testdata with 1-1 relationships.
jdo.tck.mapping.companyfactory =
jdo.tck.classes = org.apache.jdo.tck.mapping.CompletenessTest
jdo.tck.testdata = org/apache/jdo/tck/pc/company/company1-1Relationships.xml
jdo.tck.mapping = 0
jdo.tck.requiredOptions =
tck/src/conf/company1-MRelationships.conf 100664 2117 12500110374 20723 0 ustar mbouschen staff 0 0 # 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.
jdo.tck.description = Completeness test with standard mapping, basic testdata with 1-M relationships.
jdo.tck.mapping.companyfactory =
jdo.tck.classes = org.apache.jdo.tck.mapping.CompletenessTest
jdo.tck.testdata = org/apache/jdo/tck/pc/company/company1-MRelationships.xml
jdo.tck.mapping = 0
jdo.tck.requiredOptions =
tck/src/conf/companyAllRelationships.conf 100664 2146 12500110374 21103 0 ustar mbouschen staff 0 0 # 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.
jdo.tck.description = Completeness test with standard mapping, basic testdata with all relationships \
and embedded objects.
jdo.tck.mapping.companyfactory =
jdo.tck.classes = org.apache.jdo.tck.mapping.CompletenessTest
jdo.tck.testdata = org/apache/jdo/tck/pc/company/companyAllRelationships.xml
jdo.tck.mapping = 0
jdo.tck.requiredOptions =
tck/src/conf/companyAnnotated1-1RelationshipsFCPM.conf 100664 2252 12500110374 23173 0 ustar mbouschen staff 0 0 # 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.
jdo.tck.description = Completeness test with standard mapping, basic testdata with 1-1 relationships, annotations.
jdo.tck.mapping.companyfactory = org.apache.jdo.tck.pc.companyAnnotatedFC.CompanyFactoryAnnotatedFCPMDelegator
jdo.tck.classes = org.apache.jdo.tck.mapping.CompletenessTest
jdo.tck.testdata = org/apache/jdo/tck/pc/company/company1-1Relationships.xml
jdo.tck.mapping = 0
jdo.tck.requiredOptions =
tck/src/conf/companyAnnotated1-MRelationshipsFCPM.conf 100664 2252 12500110374 23227 0 ustar mbouschen staff 0 0 # 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.
jdo.tck.description = Completeness test with standard mapping, basic testdata with 1-M relationships, annotations.
jdo.tck.mapping.companyfactory = org.apache.jdo.tck.pc.companyAnnotatedFC.CompanyFactoryAnnotatedFCPMDelegator
jdo.tck.classes = org.apache.jdo.tck.mapping.CompletenessTest
jdo.tck.testdata = org/apache/jdo/tck/pc/company/company1-MRelationships.xml
jdo.tck.mapping = 0
jdo.tck.requiredOptions =
tck/src/conf/companyAnnotatedAllRelationshipsFCConcrete.conf 100664 2307 12500110374 24634 0 ustar mbouschen staff 0 0 # 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.
jdo.tck.description = Completeness test with standard mapping, basic testdata with all relationships \
and embedded objects, annotations.
jdo.tck.mapping.companyfactory = org.apache.jdo.tck.pc.companyAnnotatedFC.CompanyFactoryAnnotatedFCConcreteDelegator
jdo.tck.classes = org.apache.jdo.tck.mapping.CompletenessTest
jdo.tck.testdata = org/apache/jdo/tck/pc/company/companyAllRelationships.xml
jdo.tck.mapping = 0
jdo.tck.requiredOptions =
tck/src/conf/companyAnnotatedAllRelationshipsFCPM.conf 100664 2301 12500110374 23400 0 ustar mbouschen staff 0 0 # 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.
jdo.tck.description = Completeness test with standard mapping, basic testdata with all relationships \
and embedded objects, annotations.
jdo.tck.mapping.companyfactory = org.apache.jdo.tck.pc.companyAnnotatedFC.CompanyFactoryAnnotatedFCPMDelegator
jdo.tck.classes = org.apache.jdo.tck.mapping.CompletenessTest
jdo.tck.testdata = org/apache/jdo/tck/pc/company/companyAllRelationships.xml
jdo.tck.mapping = 0
jdo.tck.requiredOptions =
tck/src/conf/companyAnnotatedAllRelationshipsJPAConcrete.conf 100664 2257 12500110374 24762 0 ustar mbouschen staff 0 0 # 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.
jdo.tck.description = Completeness test with standard mapping, basic testdata with M-M relationships, annotations.
jdo.tck.mapping.companyfactory = org.apache.jdo.tck.pc.companyAnnotatedJPA.CompanyFactoryAnnotatedJPAAppConcrete
jdo.tck.classes = org.apache.jdo.tck.mapping.CompletenessTestJPA
jdo.tck.testdata = org/apache/jdo/tck/pc/company/companyAllRelationships.xml
jdo.tck.mapping = 0
jdo.tck.requiredOptions =
tck/src/conf/companyAnnotatedAllRelationshipsJPAPM.conf 100664 2300 12500110374 23521 0 ustar mbouschen staff 0 0 # 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.
jdo.tck.description = Completeness test with standard mapping, basic testdata with all relationships \
and embedded objects, annotations.
jdo.tck.mapping.companyfactory = org.apache.jdo.tck.pc.companyAnnotatedJPA.CompanyFactoryAnnotatedJPAAppPM
jdo.tck.classes = org.apache.jdo.tck.mapping.CompletenessTestJPA
jdo.tck.testdata = org/apache/jdo/tck/pc/company/companyAllRelationships.xml
jdo.tck.mapping = 0
jdo.tck.requiredOptions =
tck/src/conf/companyAnnotatedAllRelationshipsPCConcrete.conf 100664 2307 12500110374 24646 0 ustar mbouschen staff 0 0 # 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.
jdo.tck.description = Completeness test with standard mapping, basic testdata with all relationships \
and embedded objects, annotations.
jdo.tck.mapping.companyfactory = org.apache.jdo.tck.pc.companyAnnotatedPC.CompanyFactoryAnnotatedPCConcreteDelegator
jdo.tck.classes = org.apache.jdo.tck.mapping.CompletenessTest
jdo.tck.testdata = org/apache/jdo/tck/pc/company/companyAllRelationships.xml
jdo.tck.mapping = 0
jdo.tck.requiredOptions =
tck/src/conf/companyAnnotatedAllRelationshipsPCPM.conf 100664 2301 12500110374 23412 0 ustar mbouschen staff 0 0 # 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.
jdo.tck.description = Completeness test with standard mapping, basic testdata with all relationships \
and embedded objects, annotations.
jdo.tck.mapping.companyfactory = org.apache.jdo.tck.pc.companyAnnotatedPC.CompanyFactoryAnnotatedPCPMDelegator
jdo.tck.classes = org.apache.jdo.tck.mapping.CompletenessTest
jdo.tck.testdata = org/apache/jdo/tck/pc/company/companyAllRelationships.xml
jdo.tck.mapping = 0
jdo.tck.requiredOptions =
tck/src/conf/companyAnnotatedAllRelationshipsPIPM.conf 100664 2234 12500110374 23425 0 ustar mbouschen staff 0 0 # 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.
jdo.tck.description = Completeness test with standard mapping, basic testdata with no relationships.
jdo.tck.mapping.companyfactory = org.apache.jdo.tck.pc.companyAnnotatedPI.CompanyFactoryAnnotatedPIPMDelegator
jdo.tck.classes = org.apache.jdo.tck.mapping.CompletenessTest
jdo.tck.testdata = org/apache/jdo/tck/pc/company/companyAllRelationships.xml
jdo.tck.mapping = 0
jdo.tck.requiredOptions =
tck/src/conf/companyAnnotatedEmbeddedFCPM.conf 100664 2270 12500110374 21621 0 ustar mbouschen staff 0 0 # 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.
jdo.tck.description = Completeness test with standard mapping, basic testdata with no relationships \
and embedded objects, annotations.
jdo.tck.mapping.companyfactory = org.apache.jdo.tck.pc.companyAnnotatedFC.CompanyFactoryAnnotatedFCPMDelegator
jdo.tck.classes = org.apache.jdo.tck.mapping.CompletenessTest
jdo.tck.testdata = org/apache/jdo/tck/pc/company/companyEmbedded.xml
jdo.tck.mapping = 0
jdo.tck.requiredOptions =
tck/src/conf/companyAnnotatedEmbeddedJPAConcrete.conf 100664 2231 12500110374 23166 0 ustar mbouschen staff 0 0 # 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.
jdo.tck.description = Completeness test with standard mapping, basic testdata with no relationships.
jdo.tck.mapping.companyfactory = org.apache.jdo.tck.pc.companyAnnotatedJPA.CompanyFactoryAnnotatedJPAAppConcrete
jdo.tck.classes = org.apache.jdo.tck.mapping.CompletenessTestJPA
jdo.tck.testdata = org/apache/jdo/tck/pc/company/companyEmbedded.xml
jdo.tck.mapping = 0
jdo.tck.requiredOptions =
tck/src/conf/companyAnnotatedEmbeddedJPAPM.conf 100664 2270 12500110374 21743 0 ustar mbouschen staff 0 0 # 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.
jdo.tck.description = Completeness test with standard mapping, basic testdata with all relationships \
and embedded objects, annotations.
jdo.tck.mapping.companyfactory = org.apache.jdo.tck.pc.companyAnnotatedJPA.CompanyFactoryAnnotatedJPAAppPM
jdo.tck.classes = org.apache.jdo.tck.mapping.CompletenessTestJPA
jdo.tck.testdata = org/apache/jdo/tck/pc/company/companyEmbedded.xml
jdo.tck.mapping = 0
jdo.tck.requiredOptions =
tck/src/conf/companyAnnotatedM-MRelationshipsFCConcrete.conf 100664 2260 12500110374 24510 0 ustar mbouschen staff 0 0 # 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.
jdo.tck.description = Completeness test with standard mapping, basic testdata with M-M relationships, annotations.
jdo.tck.mapping.companyfactory = org.apache.jdo.tck.pc.companyAnnotatedFC.CompanyFactoryAnnotatedFCConcreteDelegator
jdo.tck.classes = org.apache.jdo.tck.mapping.CompletenessTest
jdo.tck.testdata = org/apache/jdo/tck/pc/company/companyM-MRelationships.xml
jdo.tck.mapping = 0
jdo.tck.requiredOptions =
tck/src/conf/companyAnnotatedM-MRelationshipsFCPM.conf 100664 2252 12500110374 23263 0 ustar mbouschen staff 0 0 # 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.
jdo.tck.description = Completeness test with standard mapping, basic testdata with M-M relationships, annotations.
jdo.tck.mapping.companyfactory = org.apache.jdo.tck.pc.companyAnnotatedFC.CompanyFactoryAnnotatedFCPMDelegator
jdo.tck.classes = org.apache.jdo.tck.mapping.CompletenessTest
jdo.tck.testdata = org/apache/jdo/tck/pc/company/companyM-MRelationships.xml
jdo.tck.mapping = 0
jdo.tck.requiredOptions =
tck/src/conf/companyAnnotatedNoRelationshipsFCConcrete.conf 100664 2241 12500110374 24475 0 ustar mbouschen staff 0 0 # 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.
jdo.tck.description = Completeness test with standard mapping, basic testdata with no relationships.
jdo.tck.mapping.companyfactory = org.apache.jdo.tck.pc.companyAnnotatedFC.CompanyFactoryAnnotatedFCConcreteDelegator
jdo.tck.classes = org.apache.jdo.tck.mapping.CompletenessTest
jdo.tck.testdata = org/apache/jdo/tck/pc/company/companyNoRelationships.xml
jdo.tck.mapping = 0
jdo.tck.requiredOptions =
tck/src/conf/companyAnnotatedNoRelationshipsFCPM.conf 100664 2233 12500110374 23250 0 ustar mbouschen staff 0 0 # 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.
jdo.tck.description = Completeness test with standard mapping, basic testdata with no relationships.
jdo.tck.mapping.companyfactory = org.apache.jdo.tck.pc.companyAnnotatedFC.CompanyFactoryAnnotatedFCPMDelegator
jdo.tck.classes = org.apache.jdo.tck.mapping.CompletenessTest
jdo.tck.testdata = org/apache/jdo/tck/pc/company/companyNoRelationships.xml
jdo.tck.mapping = 0
jdo.tck.requiredOptions =
tck/src/conf/companyAnnotatedNoRelationshipsPCConcrete.conf 100664 2241 12500110374 24507 0 ustar mbouschen staff 0 0 # 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.
jdo.tck.description = Completeness test with standard mapping, basic testdata with no relationships.
jdo.tck.mapping.companyfactory = org.apache.jdo.tck.pc.companyAnnotatedPC.CompanyFactoryAnnotatedPCConcreteDelegator
jdo.tck.classes = org.apache.jdo.tck.mapping.CompletenessTest
jdo.tck.testdata = org/apache/jdo/tck/pc/company/companyNoRelationships.xml
jdo.tck.mapping = 0
jdo.tck.requiredOptions =
tck/src/conf/companyAnnotatedNoRelationshipsPCPM.conf 100664 2233 12500110374 23262 0 ustar mbouschen staff 0 0 # 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.
jdo.tck.description = Completeness test with standard mapping, basic testdata with no relationships.
jdo.tck.mapping.companyfactory = org.apache.jdo.tck.pc.companyAnnotatedPC.CompanyFactoryAnnotatedPCPMDelegator
jdo.tck.classes = org.apache.jdo.tck.mapping.CompletenessTest
jdo.tck.testdata = org/apache/jdo/tck/pc/company/companyNoRelationships.xml
jdo.tck.mapping = 0
jdo.tck.requiredOptions =
tck/src/conf/companyAnnotatedNoRelationshipsPIPM.conf 100664 2233 12500110374 23270 0 ustar mbouschen staff 0 0 # 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.
jdo.tck.description = Completeness test with standard mapping, basic testdata with no relationships.
jdo.tck.mapping.companyfactory = org.apache.jdo.tck.pc.companyAnnotatedPI.CompanyFactoryAnnotatedPIPMDelegator
jdo.tck.classes = org.apache.jdo.tck.mapping.CompletenessTest
jdo.tck.testdata = org/apache/jdo/tck/pc/company/companyNoRelationships.xml
jdo.tck.mapping = 0
jdo.tck.requiredOptions =
tck/src/conf/companyEmbedded.conf 100664 2135 12500110374 17315 0 ustar mbouschen staff 0 0 # 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.
jdo.tck.description = Completeness test with standard mapping, basic testdata with no relationships \
and embedded objects.
jdo.tck.mapping.companyfactory =
jdo.tck.classes = org.apache.jdo.tck.mapping.CompletenessTest
jdo.tck.testdata = org/apache/jdo/tck/pc/company/companyEmbedded.xml
jdo.tck.mapping = 0
jdo.tck.requiredOptions =
tck/src/conf/companyListWithoutJoin.conf 100664 2243 12500110374 20743 0 ustar mbouschen staff 0 0 # 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.
jdo.tck.description = Completeness test with companyListWithoutJoin model.
jdo.tck.mapping.companyfactory = org.apache.jdo.tck.pc.companyListWithoutJoin.CompanyFactoryPMClass
jdo.tck.testdata = org/apache/jdo/tck/pc/companyListWithoutJoin/companyListWithoutJoin.xml
jdo.tck.standarddata =
jdo.tck.mapping = 10
jdo.tck.classes = org.apache.jdo.tck.mapping.CompletenessTestList
jdo.tck.requiredOptions =
tck/src/conf/companyM-MRelationships.conf 100664 2117 12500110374 20757 0 ustar mbouschen staff 0 0 # 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.
jdo.tck.description = Completeness test with standard mapping, basic testdata with M-M relationships.
jdo.tck.mapping.companyfactory =
jdo.tck.classes = org.apache.jdo.tck.mapping.CompletenessTest
jdo.tck.testdata = org/apache/jdo/tck/pc/company/companyM-MRelationships.xml
jdo.tck.mapping = 0
jdo.tck.requiredOptions =
tck/src/conf/companyMapWithoutJoin.conf 100664 2235 12500110374 20546 0 ustar mbouschen staff 0 0 # 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.
jdo.tck.description = Completeness test with companyMapWithoutJoin model.
jdo.tck.mapping.companyfactory = org.apache.jdo.tck.pc.companyMapWithoutJoin.CompanyFactoryPMClass
jdo.tck.testdata = org/apache/jdo/tck/pc/companyMapWithoutJoin/companyMapWithoutJoin.xml
jdo.tck.standarddata =
jdo.tck.mapping = 9
jdo.tck.classes = org.apache.jdo.tck.mapping.CompletenessTestMap
jdo.tck.requiredOptions =
tck/src/conf/companyNoRelationships.conf 100664 2115 12500110374 20743 0 ustar mbouschen staff 0 0 # 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.
jdo.tck.description = Completeness test with standard mapping, basic testdata with no relationships.
jdo.tck.mapping.companyfactory =
jdo.tck.classes = org.apache.jdo.tck.mapping.CompletenessTest
jdo.tck.testdata = org/apache/jdo/tck/pc/company/companyNoRelationships.xml
jdo.tck.mapping = 0
jdo.tck.requiredOptions =
tck/src/conf/companyOverrideAnnotatedAllRelationshipsFCPM.conf 100664 2323 12500110374 25104 0 ustar mbouschen staff 0 0 # 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.
jdo.tck.description = Completeness test with mapping 11 overriding annotations, basic testdata with all relationships \
and embedded objects, annotations.
jdo.tck.mapping.companyfactory = org.apache.jdo.tck.pc.companyAnnotatedFC.CompanyFactoryAnnotatedFCPMDelegator
jdo.tck.classes = org.apache.jdo.tck.mapping.CompletenessTest
jdo.tck.testdata = org/apache/jdo/tck/pc/company/companyAllRelationships.xml
jdo.tck.mapping = 11
jdo.tck.requiredOptions =
tck/src/conf/companyPMClass.conf 100664 2232 12500110374 17124 0 ustar mbouschen staff 0 0 # 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.
jdo.tck.description = Completeness test with standard mapping, basic testdata with all relationships \
and embedded objects.
jdo.tck.mapping.companyfactory = org.apache.jdo.tck.pc.company.CompanyFactoryPMClass
jdo.tck.classes = org.apache.jdo.tck.mapping.CompletenessTest
jdo.tck.testdata = org/apache/jdo/tck/pc/company/companyAllRelationships.xml
jdo.tck.mapping = 0
jdo.tck.requiredOptions =
tck/src/conf/companyPMInterface.conf 100664 2236 12500110374 17763 0 ustar mbouschen staff 0 0 # 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.
jdo.tck.description = Completeness test with standard mapping, basic testdata with all relationships \
and embedded objects.
jdo.tck.mapping.companyfactory = org.apache.jdo.tck.pc.company.CompanyFactoryPMInterface
jdo.tck.classes = org.apache.jdo.tck.mapping.CompletenessTest
jdo.tck.testdata = org/apache/jdo/tck/pc/company/companyAllRelationships.xml
jdo.tck.mapping = 0
jdo.tck.requiredOptions =
tck/src/conf/compoundIdentity.conf 100664 2167 12500110374 17600 0 ustar mbouschen staff 0 0 # 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.
jdo.tck.description = Completeness test with standard mapping using order model for compound identity testing
jdo.tck.mapping.companyfactory = org.apache.jdo.tck.pc.order.OrderFactoryPMClass
jdo.tck.classes = org.apache.jdo.tck.mapping.CompletenessTestOrder
jdo.tck.testdata = org/apache/jdo/tck/pc/order/order.xml
jdo.tck.mapping = 0
jdo.tck.requiredOptions =
tck/src/conf/configurations.list 100664 7001 12500110374 17312 0 ustar mbouschen staff 0 0 # 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.
jdo.tck.cfglist = \
runonce.conf \
instancecallbacks.conf \
jdohelper.conf \
pm.conf \
pmf.conf \
detach.conf \
embeddedInheritance.conf \
enhancement.conf \
extents.conf \
fetchplan.conf \
fetchgroup.conf \
lifecycle.conf \
models.conf \
models1.conf \
query.conf \
jdoql.conf \
jdoql1.conf \
transactions.conf \
companyNoRelationships.conf \
companyEmbedded.conf \
company1-1Relationships.conf \
company1-MRelationships.conf \
companyM-MRelationships.conf \
companyAllRelationships.conf \
companyMapWithoutJoin.conf \
companyListWithoutJoin.conf \
companyPMClass.conf \
companyPMInterface.conf \
companyAnnotated1-1RelationshipsFCPM.conf \
companyAnnotated1-MRelationshipsFCPM.conf \
companyAnnotatedAllRelationshipsFCConcrete.conf \
companyAnnotatedAllRelationshipsFCPM.conf \
companyAnnotatedAllRelationshipsPCConcrete.conf \
companyAnnotatedAllRelationshipsJPAConcrete.conf \
companyAnnotatedAllRelationshipsJPAPM.conf \
companyAnnotatedAllRelationshipsPCPM.conf \
companyAnnotatedAllRelationshipsPIPM.conf \
companyAnnotatedEmbeddedFCPM.conf \
companyAnnotatedM-MRelationshipsFCConcrete.conf \
companyAnnotatedM-MRelationshipsFCPM.conf \
companyAnnotatedNoRelationshipsFCConcrete.conf \
companyAnnotatedNoRelationshipsFCPM.conf \
companyAnnotatedNoRelationshipsPCConcrete.conf \
companyAnnotatedEmbeddedJPAConcrete.conf \
companyAnnotatedEmbeddedJPAPM.conf \
companyAnnotatedNoRelationshipsPCPM.conf \
companyAnnotatedNoRelationshipsPIPM.conf \
companyOverrideAnnotatedAllRelationshipsFCPM.conf \
inheritance1.conf \
inheritance2.conf \
inheritance3.conf \
inheritance4.conf \
relationshipAllRelationships.conf \
relationshipNoRelationships.conf \
schemaAttributeClass.conf \
schemaAttributeOrm.conf \
schemaAttributePackage.conf \
compoundIdentity.conf \
throwOnUnknownStandardProperties.conf
tck/src/conf/datastoreidentity.conf 100664 1712 12500110374 17775 0 ustar mbouschen staff 0 0 # 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.
# either datastoreidentity or applicationidentity
jdo.tck.identitytype = datastoreidentity
jdo.tck.testclasses = ${jdo.tck.alltests}
jdo.tck.schema = schema2.sql
jdo.tck.requiredOptions =
tck/src/conf/derby.properties 100664 5452 12500110374 16616 0 ustar mbouschen staff 0 0 # 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.
# This flag must be set on Mac OSX
#derby.storage.fileSyncTransactionLog=true
#When this property is set to true, Derby writes the query plan information
#into the derby.log file for all executed queries.
#Default: false
#derby.language.logQueryPlan=true
#When this property is set to true, Derby writes the text and parameter values
#of all executed statements to the information log at the beginning of
#execution. It also writes information about commits and rollbacks.
#Information includes the time and thread number.
#Default: false
#derby.language.logStatementText=true
#Specifies name of the file to which the error log is written.
#If the file name is relative, it is taken as relative to the system directory.
#If this property is set, the derby.stream.error.method and
#derby.stream.error.field properties are ignored.
#Default: derby.log
derby.stream.error.file=../../logs/database/derby.txt
#Specifies which errors are logged to the Derby error log
#(typically the derby.log file). In test environments, use the setting
#derby.stream.error.logSeverityLevel=0 so that all problems are reported.
#Any error raised in a Derby system is given a level of severity.
#This property indicates the minimum severity necessary for an error to appear
#in the error log. The severities are defined in the class
#org.apache.derby.types.ExceptionSeverity.
#The higher the number, the more severe the error.
#20000: Errors that cause the statement to be rolled back,
#for example syntax errors and constraint violations.
#30000: Errors that cause the transaction to be rolled back,
#for example deadlocks.
#40000: Errors that cause the connection to be closed.
#50000: Errors that shut down the Derby system.
#Default: 40000
#derby.stream.error.logSeverityLevel=0
#Specifies whether to append to or destroy and re-create the derby.log file,
#which is used to record error and other information
#when Derby starts up in a JVM.
#You can set this property even if the file does not yet exist;
#Derby creates the file.
#Default: false
derby.infolog.append=true
tck/src/conf/detach.conf 100664 3250 12500110374 15464 0 ustar mbouschen staff 0 0 # 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.
jdo.tck.description = Detachment tests with standard mapping, no testdata.
jdo.tck.mapping.companyfactory =
jdo.tck.testdata =
jdo.tck.standarddata =
jdo.tck.mapping = 8
jdo.tck.classes = \
org.apache.jdo.tck.api.jdohelper.IsDetached \
org.apache.jdo.tck.api.persistencemanager.detach.DetachAllOnCommit \
org.apache.jdo.tck.api.persistencemanager.detach.DetachAttach \
org.apache.jdo.tck.api.persistencemanager.detach.DetachAttachDirty \
org.apache.jdo.tck.api.persistencemanager.detach.DetachCopy \
org.apache.jdo.tck.api.persistencemanager.detach.DetachSerialize \
org.apache.jdo.tck.api.persistencemanager.detach.SetDetachAllOnCommit \
org.apache.jdo.tck.api.persistencemanager.detach.DetachUndetachable \
org.apache.jdo.tck.api.persistencemanager.detach.DetachAccessUnloadedField \
org.apache.jdo.tck.api.persistencemanager.detach.CopyOnAttachFalse
jdo.tck.requiredOptions =
tck/src/conf/detach.list 100664 1500 12500110374 15506 0 ustar mbouschen staff 0 0 # 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.
jdo.tck.cfglist = \
detach.conf
tck/src/conf/embeddedInheritance.conf 100664 2045 12500110374 20140 0 ustar mbouschen staff 0 0 # 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.
jdo.tck.description = Detachment tests with standard mapping, no testdata.
jdo.tck.mapping.companyfactory =
jdo.tck.testdata =
jdo.tck.standarddata =
jdo.tck.mapping = 12
jdo.tck.classes = \
org.apache.jdo.tck.models.embedded.EmbeddedInheritance
jdo.tck.requiredOptions =
tck/src/conf/enhancement-test.properties 100664 2415 12500110374 20747 0 ustar mbouschen staff 0 0 #
# 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.
org.apache.jdo.tck.pc.inheritance=AllPersist,AllPersist2,AllPersist3,AllPersist4,FieldSameName,FieldSameName2,FieldSameName3,FieldSameName4,TopNonPersistB,TopNonPersistE,TopNonPersistF,TopNonPersistH,TopPersist,TopPersistE,TopPersistF,TopPersistH
org.apache.jdo.tck.pc.company=Address,Company,DentalInsurance,Department,Employee,FullTimeEmployee,Insurance,MedicalInsurance,PartTimeEmployee,Person,Project
org.apache.jdo.tck.pc.instancecallbacks=InstanceCallbackClass,InstanceCallbackNonPersistFdsClass
tck/src/conf/enhancement.conf 100664 2207 12500110374 16522 0 ustar mbouschen staff 0 0 # 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.
jdo.tck.description = All enhancement, persistencecapable tests with standard mapping, no testdata.
jdo.tck.mapping.companyfactory =
jdo.tck.testdata =
jdo.tck.standarddata =
jdo.tck.mapping = 0
jdo.tck.requiredOptions =
jdo.tck.classes = \
org.apache.jdo.tck.api.persistencecapable.CopyKeyFieldsFromObjectId \
org.apache.jdo.tck.api.persistencecapable.NewObjectIdInstance
tck/src/conf/exclude.list 100664 1440 12500110374 15712 0 ustar mbouschen staff 0 0 # 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.
jdo.tck.exclude =
tck/src/conf/extents.conf 100664 3271 12500110374 15731 0 ustar mbouschen staff 0 0 # 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.
jdo.tck.description = All extent tests with standard mapping, no testdata.
jdo.tck.mapping.companyfactory =
jdo.tck.testdata =
jdo.tck.standarddata =
jdo.tck.mapping = 0
jdo.tck.requiredOptions =
jdo.tck.classes = \
org.apache.jdo.tck.extents.CloseAll \
org.apache.jdo.tck.extents.CloseOfExtentIteratorIsIteratorSpecific \
org.apache.jdo.tck.extents.GetCandidateClass \
org.apache.jdo.tck.extents.GetPersistenceManager \
org.apache.jdo.tck.extents.HasSubclassesFalse \
org.apache.jdo.tck.extents.HasSubclassesTrue \
org.apache.jdo.tck.extents.InstancesDeletedPriorToIterationNotReturned \
org.apache.jdo.tck.extents.InstancesPersistedPriorToIterationReturned \
org.apache.jdo.tck.extents.IteratorHasNextFalseAfterExtentClose \
org.apache.jdo.tck.extents.IteratorMutatingMethods \
org.apache.jdo.tck.extents.IteratorNextAfterExtentClose \
org.apache.jdo.tck.extents.IteratorNextAfterExtentCloseAll \
org.apache.jdo.tck.extents.Iterators
tck/src/conf/fetchgroup.conf 100664 1767 12500110374 16415 0 ustar mbouschen staff 0 0 # 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.
jdo.tck.description = FetchGroup test.
jdo.tck.mapping.companyfactory =
jdo.tck.testdata =
jdo.tck.standarddata =
jdo.tck.mapping = 0
jdo.tck.requiredOptions =
jdo.tck.classes = \
org.apache.jdo.tck.api.fetchgroup.FetchGroupTest
tck/src/conf/fetchplan.conf 100664 2623 12500110374 16203 0 ustar mbouschen staff 0 0 # 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.
jdo.tck.description = All pm tests with standard mapping, no testdata.
jdo.tck.mapping.companyfactory =
jdo.tck.testdata =
jdo.tck.standarddata =
jdo.tck.mapping = 0
jdo.tck.requiredOptions =
jdo.tck.classes = \
org.apache.jdo.tck.api.persistencemanager.fetchplan.FetchPlanInterface \
org.apache.jdo.tck.api.persistencemanager.fetchplan.FetchPlanMakeTransient \
org.apache.jdo.tck.api.persistencemanager.fetchplan.FetchPlanQuery \
org.apache.jdo.tck.api.persistencemanager.fetchplan.FetchPlanRefresh \
org.apache.jdo.tck.api.persistencemanager.fetchplan.FetchPlanRetrieve \
org.apache.jdo.tck.api.persistencemanager.fetchplan.FetchPlanIsCopy
tck/src/conf/inheritance1.conf 100664 2401 12500110374 16603 0 ustar mbouschen staff 0 0 # 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.
jdo.tck.description = Completeness test with inheritance mapping 1: \
Separate table for each class in the inheritance hierarchy. \
Each table contains columns for the declared fields. \
Inheritance strategy: new-table for all classes.
jdo.tck.mapping.companyfactory =
jdo.tck.classes = org.apache.jdo.tck.mapping.CompletenessTest
jdo.tck.testdata = org/apache/jdo/tck/pc/company/companyAllRelationships.xml
jdo.tck.mapping = 1
jdo.tck.requiredOptions = javax.jdo.option.mapping.JoinedTablePerClass
tck/src/conf/inheritance2.conf 100664 3215 12500110374 16610 0 ustar mbouschen staff 0 0 # 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.
jdo.tck.description = Completeness test with inheritance mapping 2: \
Separate table for each class in the inheritance hierarchy. \
No tables for abstract classes. \
Each table contains columns for all fields. \
Managers, mentors, hradvisors, and employees of the month \
are fulltime employees. \
Only fulltime employees can have insurances, can be project members, \
and can be project reviewers. \
Separate phone number type tables for persons, fulltime employees, \
and parttime employees. \
Inheritance strategy: new-table for all classes.
jdo.tck.mapping.companyfactory =
jdo.tck.classes = org.apache.jdo.tck.mapping.CompletenessTest
jdo.tck.testdata = org/apache/jdo/tck/pc/company/companyAllRelationships.xml
jdo.tck.mapping = 2
jdo.tck.requiredOptions = javax.jdo.option.mapping.NonJoinedTablePerConcreteClass \
javax.jdo.option.mapping.RelationSubclassTable
tck/src/conf/inheritance3.conf 100664 2744 12500110374 16617 0 ustar mbouschen staff 0 0 # 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.
jdo.tck.description = Completeness test with inheritance mapping 3: \
Person has inheritance strategy "new-table". \
Employee has inheritance strategy "subclass-table". \
PartTimeEmployee and FullTimeEmployee has inheritance strategy "new-table". \
Insurance has inheritance strategy "subclass-table". \
MedicalInsurance and DentalInsurance have inheritance strategy "new-table".
jdo.tck.mapping.companyfactory =
jdo.tck.classes = org.apache.jdo.tck.mapping.CompletenessTest
jdo.tck.testdata = org/apache/jdo/tck/pc/company/companyAllRelationships.xml
jdo.tck.mapping = 3
jdo.tck.requiredOptions = javax.jdo.option.mapping.JoinedTablePerConcreteClass \
javax.jdo.option.mapping.RelationSubclassTable
tck/src/conf/inheritance4.conf 100664 2362 12500110374 16614 0 ustar mbouschen staff 0 0 # 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.
jdo.tck.description = Completeness test with inheritance mapping 4: \
Person, Employee, and Insurance have inheritance strategy "new-table". \
PartTimeEmployee, FullTimeEmployee, MedicalInsurance, and DentalInsurance \
have inheritance strategy "superclass-table".
jdo.tck.mapping.companyfactory =
jdo.tck.classes = org.apache.jdo.tck.mapping.CompletenessTest
jdo.tck.testdata = org/apache/jdo/tck/pc/company/companyAllRelationships.xml
jdo.tck.mapping = 4
jdo.tck.requiredOptions =
tck/src/conf/instancecallbacks.conf 100664 4164 12500110374 17705 0 ustar mbouschen staff 0 0 # 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.
jdo.tck.description = All instancecallback tests with standard mapping, no testdata.
jdo.tck.mapping.companyfactory =
jdo.tck.testdata =
jdo.tck.standarddata =
jdo.tck.mapping = 0
jdo.tck.requiredOptions =
jdo.tck.classes = \
org.apache.jdo.tck.api.instancecallbacks.AccessOtherInstancesInPrestore \
org.apache.jdo.tck.api.instancecallbacks.AccessingFieldsInPredelete \
org.apache.jdo.tck.api.instancecallbacks.CallingJdoPostload \
org.apache.jdo.tck.api.instancecallbacks.CallingJdoPreclear \
org.apache.jdo.tck.api.instancecallbacks.CallingJdoPredelete \
org.apache.jdo.tck.api.instancecallbacks.CallingJdoPrestore \
org.apache.jdo.tck.api.instancecallbacks.InstanceLifecycleListenerAttach \
org.apache.jdo.tck.api.instancecallbacks.InstanceLifecycleListenerClear \
org.apache.jdo.tck.api.instancecallbacks.InstanceLifecycleListenerCreate \
org.apache.jdo.tck.api.instancecallbacks.InstanceLifecycleListenerDelete \
org.apache.jdo.tck.api.instancecallbacks.InstanceLifecycleListenerDetach \
org.apache.jdo.tck.api.instancecallbacks.InstanceLifecycleListenerDirty \
org.apache.jdo.tck.api.instancecallbacks.InstanceLifecycleListenerLoad \
org.apache.jdo.tck.api.instancecallbacks.InstanceLifecycleListenerStore \
org.apache.jdo.tck.api.instancecallbacks.ModificationOfNontransactionalNonpersistentFields \
org.apache.jdo.tck.api.instancecallbacks.NoAccessToFieldsAfterPredelete
tck/src/conf/jdo-3_1-signatures.txt 100664 241647 12500110374 17522 0 ustar mbouschen staff 0 0 /*
* 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.
*/
public interface javax.jdo.Constants {
static String JAVAX_JDO = "javax.jdo";
static String JAVAX_JDO_PREFIX = "javax.jdo.";
static String SERVICE_LOOKUP_PMF_RESOURCE_NAME
= "META-INF/services/javax.jdo.PersistenceManagerFactory";
static String SERVICE_LOOKUP_ENHANCER_RESOURCE_NAME
= "META-INF/services/javax.jdo.JDOEnhancer";
static String JDOCONFIG_RESOURCE_NAME
= "META-INF/jdoconfig.xml";
static String JDOCONFIG_XSD_NS
= "http://java.sun.com/xml/ns/jdo/jdoconfig";
static String JDO_XSD_NS
= "http://java.sun.com/xml/ns/jdo/jdo";
static String ORM_XSD_NS
= "http://java.sun.com/xml/ns/jdo/orm";
static String JDOQUERY_XSD_NS
= "http://java.sun.com/xml/ns/jdo/jdoquery";
static String ELEMENT_PERSISTENCE_MANAGER_FACTORY
= "persistence-manager-factory";
static String PMF_ATTRIBUTE_CLASS
= "class";
static String PMF_ATTRIBUTE_NAME
= "name";
static String PMF_ATTRIBUTE_PERSISTENCE_UNIT_NAME
= "persistence-unit-name";
static String PMF_ATTRIBUTE_OPTIMISTIC
= "optimistic";
static String PMF_ATTRIBUTE_READONLY
= "readonly";
static String PMF_ATTRIBUTE_RETAIN_VALUES
= "retain-values";
static String PMF_ATTRIBUTE_RESTORE_VALUES
= "restore-values";
static String PMF_ATTRIBUTE_IGNORE_CACHE
= "ignore-cache";
static String PMF_ATTRIBUTE_NONTRANSACTIONAL_READ
= "nontransactional-read";
static String PMF_ATTRIBUTE_NONTRANSACTIONAL_WRITE
= "nontransactional-write";
static String PMF_ATTRIBUTE_MULTITHREADED
= "multithreaded";
static String PMF_ATTRIBUTE_CONNECTION_DRIVER_NAME
= "connection-driver-name";
static String PMF_ATTRIBUTE_CONNECTION_USER_NAME
= "connection-user-name";
static String PMF_ATTRIBUTE_CONNECTION_PASSWORD
= "connection-password";
static String PMF_ATTRIBUTE_CONNECTION_URL
= "connection-url";
static String PMF_ATTRIBUTE_CONNECTION_FACTORY_NAME
= "connection-factory-name";
static String PMF_ATTRIBUTE_CONNECTION_FACTORY2_NAME
= "connection-factory2-name";
static String PMF_ATTRIBUTE_DETACH_ALL_ON_COMMIT
= "detach-all-on-commit";
static String PMF_ATTRIBUTE_COPY_ON_ATTACH
= "copy-on-attach";
static String PMF_ATTRIBUTE_MAPPING
= "mapping";
static String PMF_ATTRIBUTE_SERVER_TIME_ZONE_ID
= "server-time-zone-id";
static String PMF_ATTRIBUTE_DATASTORE_READ_TIMEOUT_MILLIS
= "datastore-read-timeout-millis";
static String PMF_ATTRIBUTE_DATASTORE_WRITE_TIMEOUT_MILLIS
= "datastore-write-timeout-millis";
static String ELEMENT_PROPERTY
= "property";
static String PROPERTY_ATTRIBUTE_NAME
= "name";
static String PROPERTY_ATTRIBUTE_VALUE
= "value";
static String ELEMENT_INSTANCE_LIFECYCLE_LISTENER
= "instance-lifecycle-listener";
static String INSTANCE_LIFECYCLE_LISTENER_ATTRIBUTE_LISTENER
= "listener";
static String INSTANCE_LIFECYCLE_LISTENER_ATTRIBUTE_CLASSES
= "classes";
static String OPTION_TRANSACTIONAL_TRANSIENT
= "javax.jdo.option.TransientTransactional";
static String OPTION_NONTRANSACTIONAL_READ
= "javax.jdo.option.NontransactionalRead";
static String OPTION_NONTRANSACTIONAL_WRITE
= "javax.jdo.option.NontransactionalWrite";
static String OPTION_RETAIN_VALUES
= "javax.jdo.option.RetainValues";
static String OPTION_OPTIMISTIC
= "javax.jdo.option.Optimistic";
static String OPTION_APPLICATION_IDENTITY
= "javax.jdo.option.ApplicationIdentity";
static String OPTION_DATASTORE_IDENTITY
= "javax.jdo.option.DatastoreIdentity";
static String OPTION_NONDURABLE_IDENTITY
= "javax.jdo.option.NonDurableIdentity";
static String OPTION_ARRAYLIST
= "javax.jdo.option.ArrayList";
static String OPTION_LINKEDLIST
= "javax.jdo.option.LinkedList";
static String OPTION_TREEMAP
= "javax.jdo.option.TreeMap";
static String OPTION_TREESET
= "javax.jdo.option.TreeSet";
static String OPTION_VECTOR
= "javax.jdo.option.Vector";
static String OPTION_ARRAY
= "javax.jdo.option.Array";
static String OPTION_NULL_COLLECTION
= "javax.jdo.option.NullCollection";
static String OPTION_CHANGE_APPLICATION_IDENTITY
= "javax.jdo.option.ChangeApplicationIdentity";
static String OPTION_BINARY_COMPATIBILITY
= "javax.jdo.option.BinaryCompatibility";
static String OPTION_GET_DATASTORE_CONNECTION
= "javax.jdo.option.GetDataStoreConnection";
static String OPTION_GET_JDBC_CONNECTION
= "javax.jdo.option.GetJDBCConnection";
static String OPTION_DATASTORE_TIMEOUT
= "javax.jdo.option.DatastoreTimeout";
static String OPTION_QUERY_SQL
= "javax.jdo.query.SQL";
static String OPTION_QUERY_CANCEL
= "javax.jdo.option.QueryCancel";
static String OPTION_UNCONSTRAINED_QUERY_VARIABLES
= "javax.jdo.option.UnconstrainedQueryVariables";
static String OPTION_VERSION_DATETIME
= "javax.jdo.option.version.DateTime";
static String OPTION_VERSION_STATE_IMAGE
= "javax.jdo.option.version.StateImage";
static String OPTION_PREDIRTY_EVENT
= "javax.jdo.option.PreDirtyEvent";
static String OPTION_MAPPING_HETEROGENEOUS_OBJECT_TYPE
= "javax.jdo.option.mapping.HeterogeneousObjectType";
static String OPTION_MAPPING_HETEROGENEOUS_INTERFACE_TYPE
= "javax.jdo.option.mapping.HeterogeneousInterfaceType";
static String OPTION_MAPPING_JOINED_TABLE_PER_CLASS
= "javax.jdo.option.mapping.JoinedTablePerClass";
static String OPTION_MAPPING_JOINED_TABLE_PER_CONCRETE_CLASS
= "javax.jdo.option.mapping.JoinedTablePerConcreteClass";
static String OPTION_MAPPING_NON_JOINED_TABLE_PER_CONCRETE_CLASS
= "javax.jdo.option.mapping.NonJoinedTablePerConcreteClass";
static String OPTION_MAPPING_RELATION_SUBCLASS_TABLE
= "javax.jdo.option.mapping.RelationSubclassTable";
static String PROPERTY_PERSISTENCE_MANAGER_FACTORY_CLASS
= "javax.jdo.PersistenceManagerFactoryClass";
static String PROPERTY_OPTIMISTIC
= "javax.jdo.option.Optimistic";
static String PROPERTY_READONLY
= "javax.jdo.option.ReadOnly";
static String PROPERTY_RETAIN_VALUES
= "javax.jdo.option.RetainValues";
static String PROPERTY_RESTORE_VALUES
= "javax.jdo.option.RestoreValues";
static String PROPERTY_IGNORE_CACHE
= "javax.jdo.option.IgnoreCache";
static String PROPERTY_NONTRANSACTIONAL_READ
= "javax.jdo.option.NontransactionalRead";
static String PROPERTY_NONTRANSACTIONAL_WRITE
= "javax.jdo.option.NontransactionalWrite";
static String PROPERTY_MULTITHREADED
= "javax.jdo.option.Multithreaded";
static String PROPERTY_TRANSACTION_ISOLATION_LEVEL
= "javax.jdo.option.TransactionIsolationLevel";
static String PROPERTY_TRANSACTION_ISOLATION_LEVEL_READ_UNCOMMITTED
= "javax.jdo.option.TransactionIsolationLevel.read-uncommitted";
static String PROPERTY_TRANSACTION_ISOLATION_LEVEL_READ_COMMITTED
= "javax.jdo.option.TransactionIsolationLevel.read-committed";
static String PROPERTY_TRANSACTION_ISOLATION_LEVEL_REPEATABLE_READ
= "javax.jdo.option.TransactionIsolationLevel.repeatable-read";
static String PROPERTY_TRANSACTION_ISOLATION_LEVEL_SNAPSHOT
= "javax.jdo.option.TransactionIsolationLevel.snapshot";
static String PROPERTY_TRANSACTION_ISOLATION_LEVEL_SERIALIZABLE
= "javax.jdo.option.TransactionIsolationLevel.serializable";
static String PROPERTY_DETACH_ALL_ON_COMMIT
= "javax.jdo.option.DetachAllOnCommit";
static String PROPERTY_COPY_ON_ATTACH
= "javax.jdo.option.CopyOnAttach";
static String PROPERTY_CONNECTION_DRIVER_NAME
= "javax.jdo.option.ConnectionDriverName";
static String PROPERTY_CONNECTION_USER_NAME
= "javax.jdo.option.ConnectionUserName";
static String PROPERTY_CONNECTION_PASSWORD
= "javax.jdo.option.ConnectionPassword";
static String PROPERTY_CONNECTION_URL
= "javax.jdo.option.ConnectionURL";
static String PROPERTY_CONNECTION_FACTORY_NAME
= "javax.jdo.option.ConnectionFactoryName";
static String PROPERTY_CONNECTION_FACTORY2_NAME
= "javax.jdo.option.ConnectionFactory2Name";
static String PROPERTY_MAPPING
= "javax.jdo.option.Mapping";
static String PROPERTY_NAME
= "javax.jdo.option.Name";
static String PROPERTY_SPI_RESOURCE_NAME
= "javax.jdo.option.spi.ResourceName";
static String PROPERTY_PERSISTENCE_UNIT_NAME
= "javax.jdo.option.PersistenceUnitName";
static String PROPERTY_INSTANCE_LIFECYCLE_LISTENER
= "javax.jdo.listener.InstanceLifecycleListener";
static String PROPERTY_PREFIX_INSTANCE_LIFECYCLE_LISTENER
= "javax.jdo.listener.InstanceLifecycleListener.";
static String PROPERTY_MAPPING_CATALOG
= "javax.jdo.mapping.Catalog";
static String PROPERTY_MAPPING_SCHEMA
= "javax.jdo.mapping.Schema";
static String PROPERTY_SERVER_TIME_ZONE_ID
= "javax.jdo.option.ServerTimeZoneID";
static String PROPERTY_DATASTORE_READ_TIMEOUT_MILLIS
= "javax.jdo.option.DatastoreReadTimeoutMillis";
static String PROPERTY_DATASTORE_WRITE_TIMEOUT_MILLIS
= "javax.jdo.option.DatastoreWriteTimeoutMillis";
static String NONCONFIGURABLE_PROPERTY_VENDOR_NAME
= "VendorName";
static String NONCONFIGURABLE_PROPERTY_VERSION_NUMBER
= "VersionNumber";
static String JTA
= "JTA";
static String RESOURCE_LOCAL
= "RESOURCE_LOCAL";
static String JDOCONFIG_DTD_RESOURCE
= "javax/jdo/jdoconfig_3_0.dtd";
static String JDOCONFIG_XSD_RESOURCE
= "javax/jdo/jdoconfig_3_0.xsd";
static String JDO_DTD_RESOURCE
= "javax/jdo/jdo_3_0.dtd";
static String JDO_XSD_RESOURCE
= "javax/jdo/jdo_3_0.xsd";
static String ORM_DTD_RESOURCE
= "javax/jdo/orm_3_0.dtd";
static String ORM_XSD_RESOURCE
= "javax/jdo/orm_3_0.xsd";
static String JDOQUERY_DTD_RESOURCE
= "javax/jdo/jdoquery_3_0.dtd";
static String JDOQUERY_XSD_RESOURCE
= "javax/jdo/jdoquery_3_0.xsd";
static String ANONYMOUS_PERSISTENCE_MANAGER_FACTORY_NAME
= "";
public static final String TX_READ_UNCOMMITTED = "read-uncommitted";
public static final String TX_READ_COMMITTED = "read-committed";
public static final String TX_REPEATABLE_READ = "repeatable-read";
public static final String TX_SNAPSHOT = "snapshot";
public static final String TX_SERIALIZABLE = "serializable";
public static final String PROPERTY_ENHANCER_VENDOR_NAME = "VendorName";
public static final String PROPERTY_ENHANCER_VERSION_NUMBER = "VersionNumber";
public static final String PROPERTY_TRANSACTION_TYPE = "javax.jdo.option.TransactionType";
public static final int ENHANCER_EXCEPTION = 1;
public static final int ENHANCER_NO_JDO_ENHANCER_FOUND = 2;
public static final int ENHANCER_USAGE_ERROR = 3;
}
public interface javax.jdo.datastore.DataStoreCache {
public void evict(Object oid);
public void evictAll();
public varargs void evictAll(Object[] oids);
public void evictAll(java.util.Collection oids);
public void evictAll(Class pcClass, boolean subclasses);
public void evictAll(boolean subclasses, Class pcClass);
public void pin(Object oid);
public void pinAll(java.util.Collection oids);
public varargs void pinAll(Object[] oids);
public void pinAll(Class pcClass, boolean subclasses);
public void pinAll(boolean subclasses, Class pcClass);
public void unpin(Object oid);
public void unpinAll(java.util.Collection oids);
public varargs void unpinAll(Object[] oids);
public void unpinAll(Class pcClass, boolean subclasses);
public void unpinAll(boolean subclasses, Class pcClass);
}
public interface javax.jdo.datastore.JDOConnection {
public Object getNativeConnection();
public void close();
}
public interface javax.jdo.datastore.Sequence {
public String getName();
public Object next();
public void allocate(int additional);
public Object current();
public long nextValue();
public long currentValue();
}
public interface javax.jdo.Extent extends java.lang.Iterable {
public java.util.Iterator iterator();
public boolean hasSubclasses();
public Class getCandidateClass();
public javax.jdo.PersistenceManager getPersistenceManager();
public void closeAll();
public void close(java.util.Iterator it);
public javax.jdo.FetchPlan getFetchPlan();
}
public interface javax.jdo.FetchPlan {
public static final String DEFAULT = "default";
public static final String ALL = "all";
public static final int DETACH_UNLOAD_FIELDS = 2;
public static final int DETACH_LOAD_FIELDS = 1;
public static final int FETCH_SIZE_GREEDY = -1;
public static final int FETCH_SIZE_OPTIMAL = 0;
public javax.jdo.FetchPlan addGroup(String fetchGroupName);
public javax.jdo.FetchPlan removeGroup(String fetchGroupName);
public javax.jdo.FetchPlan clearGroups();
public java.util.Set getGroups();
public javax.jdo.FetchPlan setGroups(java.util.Collection fetchGroupNames);
public varargs javax.jdo.FetchPlan setGroups(String[]fetchGroupNames);
public javax.jdo.FetchPlan setGroup(String fetchGroupName);
public javax.jdo.FetchPlan setMaxFetchDepth(int fetchDepth);
public int getMaxFetchDepth();
public javax.jdo.FetchPlan setDetachmentRoots(java.util.Collection roots);
public java.util.Collection getDetachmentRoots();
public varargs javax.jdo.FetchPlan setDetachmentRootClasses(Class[] rootClasses);
public Class[] getDetachmentRootClasses();
public javax.jdo.FetchPlan setFetchSize(int fetchSize);
public int getFetchSize();
public javax.jdo.FetchPlan setDetachmentOptions(int options);
public int getDetachmentOptions();
}
public class javax.jdo.identity.ByteIdentity extends javax.jdo.identity.SingleFieldIdentity {
public ByteIdentity(Class pcClass, byte key);
public ByteIdentity(Class pcClass, Byte key);
public ByteIdentity(Class pcClass, String str);
public ByteIdentity();
public byte getKey();
public String toString();
public boolean equals(Object obj);
public int compareTo(Object obj);
public void writeExternal(java.io.ObjectOutput out) throws java.io.IOException;
public void readExternal(java.io.ObjectInput in) throws java.io.IOException, ClassNotFoundException;
}
public class javax.jdo.identity.CharIdentity extends javax.jdo.identity.SingleFieldIdentity {
public CharIdentity(Class pcClass, char key);
public CharIdentity(Class pcClass, Character key);
public CharIdentity(Class pcClass, String str);
public CharIdentity();
public char getKey();
public String toString();
public boolean equals(Object obj);
public int compareTo(Object obj);
public void writeExternal(java.io.ObjectOutput out) throws java.io.IOException;
public void readExternal(java.io.ObjectInput in) throws java.io.IOException, ClassNotFoundException;
}
public class javax.jdo.identity.IntIdentity extends javax.jdo.identity.SingleFieldIdentity {
public IntIdentity(Class pcClass, int key);
public IntIdentity(Class pcClass, Integer key);
public IntIdentity(Class pcClass, String str);
public IntIdentity();
public int getKey();
public String toString();
public boolean equals(Object obj);
public int compareTo(Object obj);
public void writeExternal(java.io.ObjectOutput out) throws java.io.IOException;
public void readExternal(java.io.ObjectInput in) throws java.io.IOException, ClassNotFoundException;
}
public class javax.jdo.identity.LongIdentity extends javax.jdo.identity.SingleFieldIdentity {
public LongIdentity(Class pcClass, long key);
public LongIdentity(Class pcClass, Long key);
public LongIdentity(Class pcClass, String str);
public LongIdentity();
public long getKey();
public String toString();
public boolean equals(Object obj);
public int compareTo(Object obj);
public void writeExternal(java.io.ObjectOutput out) throws java.io.IOException;
public void readExternal(java.io.ObjectInput in) throws java.io.IOException, ClassNotFoundException;
}
public class javax.jdo.identity.ObjectIdentity extends javax.jdo.identity.SingleFieldIdentity {
public ObjectIdentity(Class pcClass, Object param);
public ObjectIdentity();
public Object getKey();
public String toString();
public boolean equals(Object obj);
public int hashCode();
public int compareTo(Object obj);
public void writeExternal(java.io.ObjectOutput out) throws java.io.IOException;
public void readExternal(java.io.ObjectInput in) throws java.io.IOException, ClassNotFoundException;
}
public class javax.jdo.identity.ShortIdentity extends javax.jdo.identity.SingleFieldIdentity {
public ShortIdentity(Class pcClass, short key);
public ShortIdentity(Class pcClass, Short key);
public ShortIdentity(Class pcClass, String str);
public ShortIdentity();
public short getKey();
public String toString();
public boolean equals(Object obj);
public int compareTo(Object obj);
public void writeExternal(java.io.ObjectOutput out) throws java.io.IOException;
public void readExternal(java.io.ObjectInput in) throws java.io.IOException, ClassNotFoundException;
}
public abstract class javax.jdo.identity.SingleFieldIdentity implements java.io.Externalizable, java.lang.Comparable {
public SingleFieldIdentity();
public Class getTargetClass();
public String getTargetClassName();
public synchronized Object getKeyAsObject();
public boolean equals(Object obj);
public int hashCode();
public void writeExternal(java.io.ObjectOutput out) throws java.io.IOException;
public void readExternal(java.io.ObjectInput in) throws java.io.IOException, ClassNotFoundException;
}
public class javax.jdo.identity.StringIdentity extends javax.jdo.identity.SingleFieldIdentity {
public StringIdentity(Class pcClass, String key);
public StringIdentity();
public String getKey();
public String toString();
public boolean equals(Object obj);
public int compareTo(Object obj);
public void writeExternal(java.io.ObjectOutput out) throws java.io.IOException;
public void readExternal(java.io.ObjectInput in) throws java.io.IOException, ClassNotFoundException;
}
public interface javax.jdo.InstanceCallbacks extends javax.jdo.listener.ClearCallback, javax.jdo.listener.DeleteCallback, javax.jdo.listener.LoadCallback, javax.jdo.listener.StoreCallback {
}
public class javax.jdo.JDOCanRetryException extends javax.jdo.JDOException {
public JDOCanRetryException();
public JDOCanRetryException(String msg);
public JDOCanRetryException(String msg, Throwable[] nested);
public JDOCanRetryException(String msg, Throwable nested);
public JDOCanRetryException(String msg, Object failed);
public JDOCanRetryException(String msg, Throwable[] nested, Object failed);
public JDOCanRetryException(String msg, Throwable nested, Object failed);
}
public class javax.jdo.JDODataStoreException extends javax.jdo.JDOCanRetryException {
public JDODataStoreException();
public JDODataStoreException(String msg);
public JDODataStoreException(String msg, Throwable[] nested);
public JDODataStoreException(String msg, Throwable nested);
public JDODataStoreException(String msg, Object failed);
public JDODataStoreException(String msg, Throwable[] nested, Object failed);
public JDODataStoreException(String msg, Throwable nested, Object failed);
}
public class javax.jdo.JDODetachedFieldAccessException extends javax.jdo.JDOUserException {
public JDODetachedFieldAccessException();
public JDODetachedFieldAccessException(String msg);
public JDODetachedFieldAccessException(String, Object);
public JDODetachedFieldAccessException(String msg, Throwable[] nested);
public JDODetachedFieldAccessException(String msg, Throwable nested);
}
public class javax.jdo.JDOException extends RuntimeException {
public JDOException();
public JDOException(String msg);
public JDOException(String msg, Throwable[] nested);
public JDOException(String msg, Throwable nested);
public JDOException(String msg, Object failed);
public JDOException(String msg, Throwable[] nested, Object failed);
public JDOException(String msg, Throwable nested, Object failed);
public Object getFailedObject();
public Throwable[] getNestedExceptions();
public synchronized Throwable getCause();
public Throwable initCause(Throwable cause);
public synchronized String toString();
public void printStackTrace();
public synchronized void printStackTrace(java.io.PrintStream s);
public synchronized void printStackTrace(java.io.PrintWriter s);
}
public class javax.jdo.JDOFatalDataStoreException extends javax.jdo.JDOFatalException {
public JDOFatalDataStoreException();
public JDOFatalDataStoreException(String msg);
public JDOFatalDataStoreException(String msg, Object failed);
public JDOFatalDataStoreException(String msg, Throwable[] nested);
public JDOFatalDataStoreException(String msg, Throwable nested);
public JDOFatalDataStoreException(String msg, Throwable[] nested, Object failed);
public JDOFatalDataStoreException(String msg, Throwable nested, Object failed);
}
public class javax.jdo.JDOFatalException extends javax.jdo.JDOException {
public JDOFatalException();
public JDOFatalException(String msg);
public JDOFatalException(String msg, Throwable[] nested);
public JDOFatalException(String msg, Throwable nested);
public JDOFatalException(String msg, Object failed);
public JDOFatalException(String msg, Throwable[] nested, Object failed);
public JDOFatalException(String msg, Throwable nested, Object failed);
}
public class javax.jdo.JDOFatalInternalException extends javax.jdo.JDOFatalException {
public JDOFatalInternalException();
public JDOFatalInternalException(String msg);
public JDOFatalInternalException(String msg, Throwable[] nested);
public JDOFatalInternalException(String msg, Throwable nested);
public JDOFatalInternalException(String msg, Object failed);
public JDOFatalInternalException(String msg, Throwable[] nested, Object failed);
public JDOFatalInternalException(String msg, Throwable nested, Object failed);
}
public class javax.jdo.JDOFatalUserException extends javax.jdo.JDOFatalException {
public JDOFatalUserException();
public JDOFatalUserException(String msg);
public JDOFatalUserException(String msg, Throwable[] nested);
public JDOFatalUserException(String msg, Throwable nested);
public JDOFatalUserException(String msg, Object failed);
public JDOFatalUserException(String msg, Throwable[] nested, Object failed);
public JDOFatalUserException(String msg, Throwable nested, Object failed);
}
public class javax.jdo.JDOHelper implements javax.jdo.Constants {
public JDOHelper();
public static javax.jdo.JDOHelper getInstance();
public static javax.jdo.PersistenceManager getPersistenceManager(Object pc);
public static void makeDirty(Object pc, String fieldName);
public static Object getObjectId(Object pc);
public static java.util.Collection getObjectIds(java.util.Collection pcs);
public static Object[] getObjectIds(Object[] pcs);
public static Object getTransactionalObjectId(Object pc);
public static Object getVersion(Object pc);
public static boolean isDirty(Object pc);
public static boolean isTransactional(Object pc);
public static boolean isPersistent(Object pc);
public static boolean isNew(Object pc);
public static boolean isDeleted(Object pc);
public static boolean isDetached(Object pc);
public static enum javax.jdo.ObjectState getObjectState(Object pc);
public static javax.jdo.PersistenceManagerFactory getPersistenceManagerFactory();
public static javax.jdo.PersistenceManagerFactory getPersistenceManagerFactory(java.util.Map props);
public static javax.jdo.PersistenceManagerFactory getPersistenceManagerFactory(java.util.Map props, ClassLoader cl);
public static javax.jdo.PersistenceManagerFactory getPersistenceManagerFactory(java.util.Map props, java.lang.String name, ClassLoader propsloader, ClassLoader pmfloader);
public static javax.jdo.PersistenceManagerFactory getPersistenceManagerFactory(java.util.Map props, java.lang.String name, ClassLoader pmfloader);
public static javax.jdo.PersistenceManagerFactory getPersistenceManagerFactory(java.util.Map props, java.lang.String name);
public static javax.jdo.PersistenceManagerFactory getPersistenceManagerFactory(String propsResource);
public static javax.jdo.PersistenceManagerFactory getPersistenceManagerFactory(String propsResource, ClassLoader loader);
public static javax.jdo.PersistenceManagerFactory getPersistenceManagerFactory(String propsResource, ClassLoader propsLoader, ClassLoader pmfLoader);
public static javax.jdo.PersistenceManagerFactory getPersistenceManagerFactory(ClassLoader pmfLoader);
public static javax.jdo.PersistenceManagerFactory getPersistenceManagerFactory(java.io.File propsFile);
public static javax.jdo.PersistenceManagerFactory getPersistenceManagerFactory(java.io.File propsFile, ClassLoader loader);
public static javax.jdo.PersistenceManagerFactory getPersistenceManagerFactory(String jndiLocation, javax.naming.Context context);
public static javax.jdo.PersistenceManagerFactory getPersistenceManagerFactory(String jndiLocation, javax.naming.Context context, ClassLoader loader);
public static javax.jdo.PersistenceManagerFactory getPersistenceManagerFactory(java.io.InputStream stream);
public static javax.jdo.PersistenceManagerFactory getPersistenceManagerFactory(java.io.InputStream stream, ClassLoader loader);
public static javax.jdo.JDOEnhancer getEnhancer();
public static javax.jdo.JDOEnhancer getEnhancer(ClassLoader loader);
}
public class javax.jdo.JDONullIdentityException extends javax.jdo.JDOUserException {
public JDONullIdentityException();
public JDONullIdentityException(String msg);
public JDONullIdentityException(String msg, Object failed);
public JDONullIdentityException(String msg, Throwable[] nested);
public JDONullIdentityException(String msg, Throwable nested);
}
public class javax.jdo.JDOObjectNotFoundException extends javax.jdo.JDODataStoreException {
public JDOObjectNotFoundException();
public JDOObjectNotFoundException(String msg);
public JDOObjectNotFoundException(String msg, Object failed);
public JDOObjectNotFoundException(String msg, Throwable nested);
public JDOObjectNotFoundException(String msg, Throwable nested, Object failed);
public JDOObjectNotFoundException(String msg, Throwable[] nested);
public JDOObjectNotFoundException(String msg, Throwable[] nested, Object failed);
}
public class javax.jdo.JDOOptimisticVerificationException extends javax.jdo.JDOFatalDataStoreException {
public JDOOptimisticVerificationException();
public JDOOptimisticVerificationException(String msg);
public JDOOptimisticVerificationException(String msg, Object failed);
public JDOOptimisticVerificationException(String msg, Throwable[] nested);
public JDOOptimisticVerificationException(String msg, Throwable nested, Object failed);
public JDOOptimisticVerificationException(String msg, Throwable[] nested, Object failed);
}
public class javax.jdo.JDOUnsupportedOptionException extends javax.jdo.JDOUserException {
public JDOUnsupportedOptionException();
public JDOUnsupportedOptionException(String msg);
public JDOUnsupportedOptionException(String msg, Throwable[] nested);
public JDOUnsupportedOptionException(String msg, Throwable nested);
}
public class javax.jdo.JDOUserCallbackException extends javax.jdo.JDOUserException {
public JDOUserCallbackException();
public JDOUserCallbackException(String msg);
public JDOUserCallbackException(String msg, Throwable[] nested);
public JDOUserCallbackException(String msg, Throwable nested);
public JDOUserCallbackException(String msg, Object failed);
public JDOUserCallbackException(String msg, Throwable[] nested, Object failed);
public JDOUserCallbackException(String msg, Throwable nested, Object failed);
}
public class javax.jdo.JDOUserException extends javax.jdo.JDOCanRetryException {
public JDOUserException();
public JDOUserException(String msg);
public JDOUserException(String msg, Throwable[] nested);
public JDOUserException(String msg, Throwable nested);
public JDOUserException(String msg, Object failed);
public JDOUserException(String msg, Throwable[] nested, Object failed);
public JDOUserException(String msg, Throwable nested, Object failed);
}
public interface javax.jdo.listener.AttachCallback {
public void jdoPreAttach();
public void jdoPostAttach(Object attached);
}
public interface javax.jdo.listener.AttachLifecycleListener extends javax.jdo.listener.InstanceLifecycleListener {
public void preAttach(javax.jdo.listener.InstanceLifecycleEvent event);
public void postAttach(javax.jdo.listener.InstanceLifecycleEvent event);
}
public interface javax.jdo.listener.ClearCallback {
public void jdoPreClear();
}
public interface javax.jdo.listener.ClearLifecycleListener extends javax.jdo.listener.InstanceLifecycleListener {
public void preClear(javax.jdo.listener.InstanceLifecycleEvent event);
public void postClear(javax.jdo.listener.InstanceLifecycleEvent event);
}
public interface javax.jdo.listener.CreateLifecycleListener extends javax.jdo.listener.InstanceLifecycleListener {
public void postCreate(javax.jdo.listener.InstanceLifecycleEvent event);
}
public interface javax.jdo.listener.DeleteCallback {
public void jdoPreDelete();
}
public interface javax.jdo.listener.DeleteLifecycleListener extends javax.jdo.listener.InstanceLifecycleListener {
public void preDelete(javax.jdo.listener.InstanceLifecycleEvent event);
public void postDelete(javax.jdo.listener.InstanceLifecycleEvent event);
}
public interface javax.jdo.listener.DetachCallback {
public void jdoPreDetach();
public void jdoPostDetach(Object detached);
}
public interface javax.jdo.listener.DetachLifecycleListener extends javax.jdo.listener.InstanceLifecycleListener {
public void preDetach(javax.jdo.listener.InstanceLifecycleEvent event);
public void postDetach(javax.jdo.listener.InstanceLifecycleEvent event);
}
public interface javax.jdo.listener.DirtyLifecycleListener extends javax.jdo.listener.InstanceLifecycleListener {
public void preDirty(javax.jdo.listener.InstanceLifecycleEvent event);
public void postDirty(javax.jdo.listener.InstanceLifecycleEvent event);
}
public class javax.jdo.listener.InstanceLifecycleEvent extends java.util.EventObject {
public static final int CREATE = 0;
public static final int LOAD = 1;
public static final int STORE = 2;
public static final int CLEAR = 3;
public static final int DELETE = 4;
public static final int DIRTY = 5;
public static final int DETACH = 6;
public static final int ATTACH = 7;
public InstanceLifecycleEvent(Object source, int type);
public InstanceLifecycleEvent(Object source, int type, Object target);
public int getEventType();
public Object getSource();
public Object getTarget();
public Object getPersistentInstance();
public Object getDetachedInstance();
}
public interface javax.jdo.listener.InstanceLifecycleListener {
}
public interface javax.jdo.listener.LoadCallback {
public void jdoPostLoad();
}
public interface javax.jdo.listener.LoadLifecycleListener extends javax.jdo.listener.InstanceLifecycleListener {
public void postLoad(javax.jdo.listener.InstanceLifecycleEvent event);
}
public interface javax.jdo.listener.StoreCallback {
public void jdoPreStore();
}
public interface javax.jdo.listener.StoreLifecycleListener extends javax.jdo.listener.InstanceLifecycleListener {
public void preStore(javax.jdo.listener.InstanceLifecycleEvent event);
public void postStore(javax.jdo.listener.InstanceLifecycleEvent event);
}
public interface javax.jdo.PersistenceManager {
public boolean isClosed();
public void close();
public javax.jdo.Transaction currentTransaction();
public void evict(Object pc);
public varargs void evictAll(Object[] pcs);
public void evictAll(java.util.Collection pcs);
public void evictAll(boolean, Class);
public void evictAll();
public void refresh(Object pc);
public varargs void refreshAll(Object[] pcs);
public void refreshAll(java.util.Collection pcs);
public void refreshAll();
public void refreshAll(javax.jdo.JDOException jdoe);
public javax.jdo.Query newQuery();
public javax.jdo.Query newQuery(Object compiled);
public javax.jdo.Query newQuery(String query);
public javax.jdo.Query newQuery(String language, Object query);
public javax.jdo.Query newQuery(Class cls);
public javax.jdo.Query newQuery(javax.jdo.Extent cln);
public javax.jdo.Query newQuery(Class cls, java.util.Collection cln);
public javax.jdo.Query newQuery(Class cls, String filter);
public javax.jdo.Query newQuery(Class cls, java.util.Collection cln, String filter);
public javax.jdo.Query newQuery(javax.jdo.Extent cln, String filter);
public javax.jdo.Query newNamedQuery(Class cls, String queryName);
public javax.jdo.Extent getExtent(Class persistenceCapableClass, boolean subclasses);
public javax.jdo.Extent getExtent(Class persistenceCapableClass);
public Object getObjectById(Object oid, boolean validate);
public Object getObjectById(Class cls, Object key);
public Object getObjectById(Object oid);
public Object getObjectId(Object pc);
public Object getTransactionalObjectId(Object pc);
public Object newObjectIdInstance(Class pcClass, Object key);
public java.util.Collection getObjectsById(java.util.Collection oids, boolean validate);
public java.util.Collection getObjectsById(java.util.Collection oids);
public Object[] getObjectsById(Object[] oids, boolean validate);
public varargs Object[] getObjectsById(boolean validate,Object[] oids);
public varargs Object[] getObjectsById(Object[] oids);
public Object makePersistent(Object pc);
public varargs Object[] makePersistentAll(Object[] pcs);
public java.util.Collection makePersistentAll(java.util.Collection pcs);
public void deletePersistent(Object pc);
public varargs void deletePersistentAll(Object[] pcs);
public void deletePersistentAll(java.util.Collection pcs);
public void makeTransient(Object pc);
public varargs void makeTransientAll(Object[] pcs);
public void makeTransientAll(java.util.Collection pcs);
public void makeTransient(Object pc, boolean useFetchPlan);
public void makeTransientAll(Object[] pcs, boolean useFetchPlan);
public varargs void makeTransientAll(boolean useFetchPlan, Object[] pcs);
public void makeTransientAll(java.util.Collection pcs, boolean useFetchPlan);
public void makeTransactional(Object pc);
public varargs void makeTransactionalAll(Object[] pcs);
public void makeTransactionalAll(java.util.Collection pcs);
public void makeNontransactional(Object pc);
public varargs void makeNontransactionalAll(Object[] pcs);
public void makeNontransactionalAll(java.util.Collection pcs);
public void retrieve(Object pc);
public void retrieve(Object pc, boolean FGOnly);
public void retrieveAll(java.util.Collection pcs);
public void retrieveAll(java.util.Collection pcs, boolean FGOnly);
public varargs void retrieveAll(Object[] pcs);
public void retrieveAll(Object[] pcs, boolean FGOnly);
public varargs void retrieveAll(boolean FGOnly, Object[] pcs);
public void setUserObject(Object o);
public Object getUserObject();
public javax.jdo.PersistenceManagerFactory getPersistenceManagerFactory();
public Class getObjectIdClass(Class cls);
public void setMultithreaded(boolean flag);
public boolean getMultithreaded();
public void setIgnoreCache(boolean flag);
public boolean getIgnoreCache();
public boolean getDetachAllOnCommit();
public void setDetachAllOnCommit(boolean flag);
public boolean getCopyOnAttach();
public void setCopyOnAttach(boolean flag);
public Object detachCopy(Object pc);
public java.util.Collection detachCopyAll(java.util.Collection pcs);
public varargs Object[] detachCopyAll(Object [] pcs);
public Object putUserObject(Object key, Object val);
public Object getUserObject(Object key);
public Object removeUserObject(Object key);
public void flush();
public void checkConsistency();
public javax.jdo.FetchPlan getFetchPlan();
public Object newInstance(Class pcClass);
public java.util.Date getServerDate();
public javax.jdo.datastore.Sequence getSequence(String name);
public javax.jdo.datastore.JDOConnection getDataStoreConnection();
public varargs void addInstanceLifecycleListener(javax.jdo.listener.InstanceLifecycleListener listener, Class[] classes);
public void removeInstanceLifecycleListener(javax.jdo.listener.InstanceLifecycleListener listener);
public java.util.Set getManagedObjects();
public java.util.Set getManagedObjects(java.util.EnumSet states);
public varargs java.util.Set getManagedObjects(Class[] classes);
public varargs java.util.Set getManagedObjects(java.util.EnumSet states, Class[] classes);
javax.jdo.FetchGroup getFetchGroup(Class cls, String name);
public void setDatastoreReadTimeoutMillis(Integer interval);
public Integer getDatastoreReadTimeoutMillis();
public void setDatastoreWriteTimeoutMillis(Integer interval);
public Integer getDatastoreWriteTimeoutMillis();
public void setProperty(String propertyName, Object value);
public java.util.Map getProperties();
public java.util.Set getSupportedProperties();
}
public interface javax.jdo.PersistenceManagerFactory extends java.io.Serializable {
public void close();
public boolean isClosed();
public javax.jdo.PersistenceManager getPersistenceManager();
public javax.jdo.PersistenceManager getPersistenceManagerProxy();
public javax.jdo.PersistenceManager getPersistenceManager(String userid, String password);
public void setConnectionUserName(String userName);
public String getConnectionUserName();
public void setConnectionPassword(String password);
public void setConnectionURL(String URL);
public String getConnectionURL();
public void setConnectionDriverName(String driverName);
public String getConnectionDriverName();
public void setConnectionFactoryName(String connectionFactoryName);
public String getConnectionFactoryName();
public void setConnectionFactory(Object connectionFactory);
public Object getConnectionFactory();
public void setConnectionFactory2Name(String connectionFactoryName);
public String getConnectionFactory2Name();
public void setConnectionFactory2(Object connectionFactory);
public Object getConnectionFactory2();
public void setMultithreaded(boolean flag);
public boolean getMultithreaded();
public void setMapping(String mapping);
public String getMapping();
public void setOptimistic(boolean flag);
public boolean getOptimistic();
public void setRetainValues(boolean flag);
public boolean getRetainValues();
public void setRestoreValues(boolean restoreValues);
public boolean getRestoreValues();
public void setNontransactionalRead(boolean flag);
public boolean getNontransactionalRead();
public void setNontransactionalWrite(boolean flag);
public boolean getNontransactionalWrite();
public void setIgnoreCache(boolean flag);
public boolean getIgnoreCache();
public boolean getDetachAllOnCommit();
public void setDetachAllOnCommit(boolean flag);
public boolean getCopyOnAttach();
public void setCopyOnAttach(boolean flag);
public java.lang.String getName();
public void setName(java.lang.String);
public java.lang.String getPersistenceUnitName();
public void setPersistenceUnitName(java.lang.String);
public java.lang.String getServerTimeZoneID();
public void setServerTimeZoneID(java.lang.String);
public java.lang.String getTransactionType();
public void setTransactionType(java.lang.String);
public void setReadOnly(boolean flag);
public boolean getReadOnly();
public void setTransactionIsolationLevel(String);
public String getTransactionIsolationLevel();
public java.util.Properties getProperties();
public java.util.Collection supportedOptions();
public javax.jdo.datastore.DataStoreCache getDataStoreCache();
public void addInstanceLifecycleListener(javax.jdo.listener.InstanceLifecycleListener listener, Class[] classes);
public void removeInstanceLifecycleListener(javax.jdo.listener.InstanceLifecycleListener listener);
varargs void addFetchGroups(javax.jdo.FetchGroup[] groups);
varargs void removeFetchGroups(javax.jdo.FetchGroup[] groups);
void removeAllFetchGroups();
javax.jdo.FetchGroup getFetchGroup(Class cls, String name);
java.util.Set getFetchGroups();
public void registerMetadata(javax.jdo.metadata.JDOMetadata metadata);
public javax.jdo.metadata.JDOMetadata newMetadata();
public javax.jdo.metadata.TypeMetadata getMetadata(String className);
public void setDatastoreReadTimeoutMillis(Integer interval);
public Integer getDatastoreReadTimeoutMillis();
public void setDatastoreWriteTimeoutMillis(Integer interval);
public Integer getDatastoreWriteTimeoutMillis();
public java.util.Collection getManagedClasses();
}
public interface javax.jdo.Query extends java.io.Serializable {
public static final String JDOQL = "javax.jdo.query.JDOQL";
public static final String SQL = "javax.jdo.query.SQL";
public void setClass(Class cls);
public void setCandidates(javax.jdo.Extent pcs);
public void setCandidates(java.util.Collection pcs);
public void setFilter(String filter);
public void declareImports(String imports);
public void declareParameters(String parameters);
public void declareVariables(String variables);
public void setOrdering(String ordering);
public void setIgnoreCache(boolean ignoreCache);
public void addSubquery(javax.jdo.Query, java.lang.String, java.lang.String);
public void addSubquery(javax.jdo.Query, java.lang.String, java.lang.String, java.lang.String);
public varargs void addSubquery(javax.jdo.Query, java.lang.String, java.lang.String, java.lang.String[]);
public void addSubquery(javax.jdo.Query, java.lang.String, java.lang.String, java.util.Map);
public boolean getIgnoreCache();
public void compile();
public Object execute();
public Object execute(Object p1);
public Object execute(Object p1, Object p2);
public Object execute(Object p1, Object p2, Object p3);
public Object executeWithMap(java.util.Map parameters);
public varargs Object executeWithArray(Object[] parameters);
public javax.jdo.PersistenceManager getPersistenceManager();
public void close(Object queryResult);
public void closeAll();
public void setGrouping(String group);
public void setUnique(boolean unique);
public void setResult(String data);
public void setResultClass(Class cls);
public void setRange(long fromIncl, long toExcl);
public void setRange(String fromInclToExcl);
public void addExtension(String key, Object value);
public void setExtensions(java.util.Map extensions);
public javax.jdo.FetchPlan getFetchPlan();
public varargs long deletePersistentAll(Object[] parameters);
public long deletePersistentAll(java.util.Map parameters);
public long deletePersistentAll();
public void setUnmodifiable();
public boolean isUnmodifiable();
public void cancelAll();
public void cancel(Thread);
public Boolean getSerializeRead();
public void setSerializeRead(Boolean);
public void setDatastoreReadTimeoutMillis(Integer interval);
public Integer getDatastoreReadTimeoutMillis();
public void setDatastoreWriteTimeoutMillis(Integer interval);
public Integer getDatastoreWriteTimeoutMillis();
}
public interface javax.jdo.spi.Detachable {
public void jdoReplaceDetachedState();
}
public class javax.jdo.spi.JDOImplHelper extends Object {
public static javax.jdo.spi.JDOImplHelper getInstance() throws SecurityException;
public String[] getFieldNames(Class pcClass);
public Class[] getFieldTypes(Class pcClass);
public byte[] getFieldFlags(Class pcClass);
public Class getPersistenceCapableSuperclass(Class pcClass);
public javax.jdo.spi.PersistenceCapable newInstance(Class pcClass, javax.jdo.spi.StateManager sm);
public javax.jdo.spi.PersistenceCapable newInstance(Class pcClass, javax.jdo.spi.StateManager sm, Object oid);
public Object newObjectIdInstance(Class pcClass);
public Object newObjectIdInstance(Class pcClass, Object obj);
public void copyKeyFieldsToObjectId(Class pcClass, javax.jdo.spi.PersistenceCapable$ObjectIdFieldSupplier fm, Object oid);
public void copyKeyFieldsFromObjectId(Class pcClass, javax.jdo.spi.PersistenceCapable$ObjectIdFieldConsumer fm, Object oid);
public static void registerClass(Class pcClass, String[] fieldNames, Class[] fieldTypes, byte[] fieldFlags, Class persistenceCapableSuperclass, javax.jdo.spi.PersistenceCapable pc);
public void unregisterClasses(ClassLoader cl);
public void unregisterClass(Class pcClass);
public void addRegisterClassListener(javax.jdo.spi.RegisterClassListener crl);
public void removeRegisterClassListener(javax.jdo.spi.RegisterClassListener crl);
public java.util.Collection getRegisteredClasses();
public static void registerAuthorizedStateManagerClass(Class smClass) throws SecurityException;
public static void registerAuthorizedStateManagerClasses(java.util.Collection smClasses) throws SecurityException;
public static void checkAuthorizedStateManager(javax.jdo.spi.StateManager sm);
public static void checkAuthorizedStateManagerClass(Class smClass);
public Object registerStringConstructor(Class cls, javax.jdo.spi.JDOImplHelper$StringConstructor sc);
public static Object construct(String className, String keyString);
public synchronized void registerDateFormat(java.text.DateFormat df);
public synchronized void registerErrorHandler(org.xml.sax.ErrorHandler);
public static org.xml.sax.ErrorHandler getRegisteredErrorHandler();
public synchronized void registerDocumentBuilderFactory(javax.xml.parsers.DocumentBuilderFactory);
public static javax.xml.parsers.DocumentBuilderFactory getRegisteredDocumentBuilderFactory();
public synchronized void addStateInterrogation(javax.jdo.spi.StateInterrogation si);
public synchronized void removeStateInterrogation(javax.jdo.spi.StateInterrogation si);
public void nonBinaryCompatibleMakeDirty(Object pc, String fieldName);
public boolean nonBinaryCompatibleIs(Object pc, javax.jdo.spi.JDOImplHelper$StateInterrogationBooleanReturn sibr);
public Object nonBinaryCompatibleGet(Object pc, javax.jdo.spi.JDOImplHelper$StateInterrogationObjectReturn sibr);
public static void assertOnlyKnownStandardProperties(java.util.Map properties);
public static final java.util.Set USER_CONFIGURABLE_STANDARD_PROPERTIES;
}
static public interface javax.jdo.spi.JDOImplHelper$StringConstructor {
public Object construct(String s);
}
static public interface javax.jdo.spi.JDOImplHelper$StateInterrogationBooleanReturn {
public Boolean is(Object pc, javax.jdo.spi.StateInterrogation si);
}
static public interface javax.jdo.spi.JDOImplHelper$StateInterrogationObjectReturn {
public Object get(Object pc, javax.jdo.spi.StateInterrogation si);
}
public final class javax.jdo.spi.JDOPermission extends java.security.BasicPermission {
public JDOPermission(String name);
public JDOPermission(String name, String actions);
public static final javax.jdo.spi.JDOPermission GET_METADATA;
public static final javax.jdo.spi.JDOPermission MANAGE_METADATA;
public static final javax.jdo.spi.JDOPermission SET_STATE_MANAGER;
public static final javax.jdo.spi.JDOPermission CLOSE_PERSISTENCE_MANAGER_FACTORY;
}
public interface javax.jdo.spi.PersistenceCapable {
public static final byte READ_WRITE_OK = 0;
public static final byte LOAD_REQUIRED = 1;
public static final byte READ_OK = -1;
public static final byte CHECK_READ = 1;
public static final byte MEDIATE_READ = 2;
public static final byte CHECK_WRITE = 4;
public static final byte MEDIATE_WRITE = 8;
public static final byte SERIALIZABLE = 16;
public javax.jdo.PersistenceManager jdoGetPersistenceManager();
public void jdoReplaceStateManager(javax.jdo.spi.StateManager sm) throws SecurityException;
public void jdoProvideField(int fieldNumber);
public void jdoProvideFields(int[] fieldNumbers);
public void jdoReplaceField(int fieldNumber);
public void jdoReplaceFields(int[] fieldNumbers);
public void jdoReplaceFlags();
public void jdoCopyFields(Object other, int[] fieldNumbers);
public void jdoMakeDirty(String fieldName);
public Object jdoGetObjectId();
public Object jdoGetTransactionalObjectId();
public Object jdoGetVersion();
public boolean jdoIsDirty();
public boolean jdoIsTransactional();
public boolean jdoIsPersistent();
public boolean jdoIsNew();
public boolean jdoIsDeleted();
public boolean jdoIsDetached();
public javax.jdo.spi.PersistenceCapable jdoNewInstance(javax.jdo.spi.StateManager sm);
public javax.jdo.spi.PersistenceCapable jdoNewInstance(javax.jdo.spi.StateManager sm, Object oid);
public Object jdoNewObjectIdInstance();
public Object jdoNewObjectIdInstance(Object o);
public void jdoCopyKeyFieldsToObjectId(Object oid);
public void jdoCopyKeyFieldsToObjectId(javax.jdo.spi.PersistenceCapable$ObjectIdFieldSupplier fm, Object oid);
public void jdoCopyKeyFieldsFromObjectId(javax.jdo.spi.PersistenceCapable$ObjectIdFieldConsumer fm, Object oid);
}
static public interface javax.jdo.spi.PersistenceCapable$ObjectIdFieldManager extends javax.jdo.spi.PersistenceCapable$ObjectIdFieldConsumer, javax.jdo.spi.PersistenceCapable$ObjectIdFieldSupplier {
}
static public interface javax.jdo.spi.PersistenceCapable$ObjectIdFieldSupplier {
public boolean fetchBooleanField(int fieldNumber);
public char fetchCharField(int fieldNumber);
public byte fetchByteField(int fieldNumber);
public short fetchShortField(int fieldNumber);
public int fetchIntField(int fieldNumber);
public long fetchLongField(int fieldNumber);
public float fetchFloatField(int fieldNumber);
public double fetchDoubleField(int fieldNumber);
public String fetchStringField(int fieldNumber);
public Object fetchObjectField(int fieldNumber);
}
static public interface javax.jdo.spi.PersistenceCapable$ObjectIdFieldConsumer {
public void storeBooleanField(int fieldNumber, boolean value);
public void storeCharField(int fieldNumber, char value);
public void storeByteField(int fieldNumber, byte value);
public void storeShortField(int fieldNumber, short value);
public void storeIntField(int fieldNumber, int value);
public void storeLongField(int fieldNumber, long value);
public void storeFloatField(int fieldNumber, float value);
public void storeDoubleField(int fieldNumber, double value);
public void storeStringField(int fieldNumber, String value);
public void storeObjectField(int fieldNumber, Object value);
}
public class javax.jdo.spi.RegisterClassEvent extends java.util.EventObject {
public RegisterClassEvent(javax.jdo.spi.JDOImplHelper helper, Class registeredClass, String[] fieldNames, Class[] fieldTypes, byte[] fieldFlags, Class persistenceCapableSuperclass);
public Class getRegisteredClass();
public String[] getFieldNames();
public Class[] getFieldTypes();
public byte[] getFieldFlags();
public Class getPersistenceCapableSuperclass();
}
public interface javax.jdo.spi.RegisterClassListener extends java.util.EventListener {
public void registerClass(javax.jdo.spi.RegisterClassEvent event);
}
public interface javax.jdo.spi.StateInterrogation {
public Boolean isPersistent(Object pc);
public Boolean isTransactional(Object pc);
public Boolean isDirty(Object pc);
public Boolean isNew(Object pc);
public Boolean isDeleted(Object pc);
public Boolean isDetached(Object pc);
public javax.jdo.PersistenceManager getPersistenceManager(Object pc);
public Object getObjectId(Object pc);
public Object getTransactionalObjectId(Object pc);
public Object getVersion(Object pc);
public boolean makeDirty(Object pc, String fieldName);
}
public interface javax.jdo.spi.StateManager {
public byte replacingFlags(javax.jdo.spi.PersistenceCapable pc);
public javax.jdo.spi.StateManager replacingStateManager(javax.jdo.spi.PersistenceCapable pc, javax.jdo.spi.StateManager sm);
public boolean isDirty(javax.jdo.spi.PersistenceCapable pc);
public boolean isTransactional(javax.jdo.spi.PersistenceCapable pc);
public boolean isPersistent(javax.jdo.spi.PersistenceCapable pc);
public boolean isNew(javax.jdo.spi.PersistenceCapable pc);
public boolean isDeleted(javax.jdo.spi.PersistenceCapable pc);
public javax.jdo.PersistenceManager getPersistenceManager(javax.jdo.spi.PersistenceCapable pc);
public void makeDirty(javax.jdo.spi.PersistenceCapable pc, String fieldName);
public Object getObjectId(javax.jdo.spi.PersistenceCapable pc);
public Object getTransactionalObjectId(javax.jdo.spi.PersistenceCapable pc);
public Object getVersion(javax.jdo.spi.PersistenceCapable pc);
public boolean isLoaded(javax.jdo.spi.PersistenceCapable pc, int field);
public void preSerialize(javax.jdo.spi.PersistenceCapable pc);
public boolean getBooleanField(javax.jdo.spi.PersistenceCapable pc, int field, boolean currentValue);
public char getCharField(javax.jdo.spi.PersistenceCapable pc, int field, char currentValue);
public byte getByteField(javax.jdo.spi.PersistenceCapable pc, int field, byte currentValue);
public short getShortField(javax.jdo.spi.PersistenceCapable pc, int field, short currentValue);
public int getIntField(javax.jdo.spi.PersistenceCapable pc, int field, int currentValue);
public long getLongField(javax.jdo.spi.PersistenceCapable pc, int field, long currentValue);
public float getFloatField(javax.jdo.spi.PersistenceCapable pc, int field, float currentValue);
public double getDoubleField(javax.jdo.spi.PersistenceCapable pc, int field, double currentValue);
public String getStringField(javax.jdo.spi.PersistenceCapable pc, int field, String currentValue);
public Object getObjectField(javax.jdo.spi.PersistenceCapable pc, int field, Object currentValue);
public void setBooleanField(javax.jdo.spi.PersistenceCapable pc, int field, boolean currentValue, boolean newValue);
public void setCharField(javax.jdo.spi.PersistenceCapable pc, int field, char currentValue, char newValue);
public void setByteField(javax.jdo.spi.PersistenceCapable pc, int field, byte currentValue, byte newValue);
public void setShortField(javax.jdo.spi.PersistenceCapable pc, int field, short currentValue, short newValue);
public void setIntField(javax.jdo.spi.PersistenceCapable pc, int field, int currentValue, int newValue);
public void setLongField(javax.jdo.spi.PersistenceCapable pc, int field, long currentValue, long newValue);
public void setFloatField(javax.jdo.spi.PersistenceCapable pc, int field, float currentValue, float newValue);
public void setDoubleField(javax.jdo.spi.PersistenceCapable pc, int field, double currentValue, double newValue);
public void setStringField(javax.jdo.spi.PersistenceCapable pc, int field, String currentValue, String newValue);
public void setObjectField(javax.jdo.spi.PersistenceCapable pc, int field, Object currentValue, Object newValue);
public void providedBooleanField(javax.jdo.spi.PersistenceCapable pc, int field, boolean currentValue);
public void providedCharField(javax.jdo.spi.PersistenceCapable pc, int field, char currentValue);
public void providedByteField(javax.jdo.spi.PersistenceCapable pc, int field, byte currentValue);
public void providedShortField(javax.jdo.spi.PersistenceCapable pc, int field, short currentValue);
public void providedIntField(javax.jdo.spi.PersistenceCapable pc, int field, int currentValue);
public void providedLongField(javax.jdo.spi.PersistenceCapable pc, int field, long currentValue);
public void providedFloatField(javax.jdo.spi.PersistenceCapable pc, int field, float currentValue);
public void providedDoubleField(javax.jdo.spi.PersistenceCapable pc, int field, double currentValue);
public void providedStringField(javax.jdo.spi.PersistenceCapable pc, int field, String currentValue);
public void providedObjectField(javax.jdo.spi.PersistenceCapable pc, int field, Object currentValue);
public boolean replacingBooleanField(javax.jdo.spi.PersistenceCapable pc, int field);
public char replacingCharField(javax.jdo.spi.PersistenceCapable pc, int field);
public byte replacingByteField(javax.jdo.spi.PersistenceCapable pc, int field);
public short replacingShortField(javax.jdo.spi.PersistenceCapable pc, int field);
public int replacingIntField(javax.jdo.spi.PersistenceCapable pc, int field);
public long replacingLongField(javax.jdo.spi.PersistenceCapable pc, int field);
public float replacingFloatField(javax.jdo.spi.PersistenceCapable pc, int field);
public double replacingDoubleField(javax.jdo.spi.PersistenceCapable pc, int field);
public String replacingStringField(javax.jdo.spi.PersistenceCapable pc, int field);
public Object replacingObjectField(javax.jdo.spi.PersistenceCapable pc, int field);
public Object[] replacingDetachedState(javax.jdo.spi.Detachable pc, Object[] state);
}
public interface javax.jdo.Transaction {
public void begin();
public void commit();
public void rollback();
public boolean isActive();
public boolean getRollbackOnly();
public void setRollbackOnly();
public void setNontransactionalRead(boolean nontransactionalRead);
public boolean getNontransactionalRead();
public void setNontransactionalWrite(boolean nontransactionalWrite);
public boolean getNontransactionalWrite();
public void setRetainValues(boolean retainValues);
public boolean getRetainValues();
public void setRestoreValues(boolean restoreValues);
public boolean getRestoreValues();
public void setOptimistic(boolean optimistic);
public boolean getOptimistic();
void setIsolationLevel(String level);
String getIsolationLevel();
public void setSynchronization(javax.transaction.Synchronization sync);
public javax.transaction.Synchronization getSynchronization();
public javax.jdo.PersistenceManager getPersistenceManager();
public Boolean getSerializeRead();
public void setSerializeRead(Boolean);
}
public final enum javax.jdo.ObjectState extends java.lang.Enum {
public static final enum javax.jdo.ObjectState TRANSIENT;
public static final enum javax.jdo.ObjectState TRANSIENT_CLEAN;
public static final enum javax.jdo.ObjectState TRANSIENT_DIRTY;
public static final enum javax.jdo.ObjectState PERSISTENT_NEW;
public static final enum javax.jdo.ObjectState HOLLOW_PERSISTENT_NONTRANSACTIONAL;
public static final enum javax.jdo.ObjectState PERSISTENT_NONTRANSACTIONAL_DIRTY;
public static final enum javax.jdo.ObjectState PERSISTENT_CLEAN;
public static final enum javax.jdo.ObjectState PERSISTENT_DIRTY;
public static final enum javax.jdo.ObjectState PERSISTENT_DELETED;
public static final enum javax.jdo.ObjectState PERSISTENT_NEW_DELETED;
public static final enum javax.jdo.ObjectState DETACHED_CLEAN;
public static final enum javax.jdo.ObjectState DETACHED_DIRTY;
public static enum javax.jdo.ObjectState valueOf(java.lang.String);
public static javax.jdo.ObjectState[] values();
public String toString();
}
public annotation javax.jdo.annotations.Column extends java.lang.annotation.Annotation
{
String name() default "";
String target() default "";
String targetMember() default "";
String jdbcType() default "";
String sqlType() default "";
int length() default -1;
int scale() default -1;
String allowsNull() default "";
String defaultValue() default "";
String insertValue() default "";
javax.jdo.annotations.Extension[] extensions() default {};
int position() default -1;
}
public annotation javax.jdo.annotations.Columns extends java.lang.annotation.Annotation
{
javax.jdo.annotations.Column[] value();
}
public annotation javax.jdo.annotations.DatastoreIdentity extends java.lang.annotation.Annotation
{
enum javax.jdo.annotations.IdGeneratorStrategy strategy() default javax.jdo.annotations.IdGeneratorStrategy.UNSPECIFIED;
String customStrategy() default "";
String sequence() default "";
String column() default "";
javax.jdo.annotations.Column[] columns() default {};
javax.jdo.annotations.Extension[] extensions() default {};
}
public annotation javax.jdo.annotations.Discriminator extends java.lang.annotation.Annotation
{
enum javax.jdo.annotations.DiscriminatorStrategy strategy()
default javax.jdo.annotations.DiscriminatorStrategy.UNSPECIFIED;
String customStrategy() default "";
String indexed() default "";
String column() default "";
String value() default "";
javax.jdo.annotations.Column[] columns() default {};
}
public final enum javax.jdo.annotations.DiscriminatorStrategy extends java.lang.Enum
{
public static final enum javax.jdo.annotations.DiscriminatorStrategy UNSPECIFIED;
public static final enum javax.jdo.annotations.DiscriminatorStrategy NONE;
public static final enum javax.jdo.annotations.DiscriminatorStrategy VALUE_MAP;
public static final enum javax.jdo.annotations.DiscriminatorStrategy CLASS_NAME;
public static enum javax.jdo.annotations.DiscriminatorStrategy valueOf(java.lang.String);
public static javax.jdo.annotations.DiscriminatorStrategy[] values();
}
public annotation javax.jdo.annotations.Element extends java.lang.annotation.Annotation
{
Class[] types() default {};
String serialized() default "";
String embedded() default "";
javax.jdo.annotations.Embedded[] embeddedMapping() default {};
String dependent() default "";
String table() default "";
String column() default "";
enum javax.jdo.annotations.ForeignKeyAction deleteAction() default javax.jdo.annotations.ForeignKeyAction.UNSPECIFIED;
enum javax.jdo.annotations.ForeignKeyAction updateAction() default javax.jdo.annotations.ForeignKeyAction.UNSPECIFIED;
String indexed() default "";
String index() default "";
String unique() default "";
String uniqueKey() default "";
String mappedBy() default "";
javax.jdo.annotations.Column[] columns() default {};
String generateForeignKey() default "";
String foreignKey() default "";
javax.jdo.annotations.Extension[] extensions() default {};
}
public annotation javax.jdo.annotations.Embedded extends java.lang.annotation.Annotation
{
String ownerMember() default "";
String nullIndicatorColumn() default "";
String nullIndicatorValue() default "";
javax.jdo.annotations.Persistent[] members() default {};
javax.jdo.annotations.Discriminator discriminatorColumnName() default @javax.jdo.annotations.Discriminator;
}
public annotation javax.jdo.annotations.EmbeddedOnly extends java.lang.annotation.Annotation
{
}
public annotation javax.jdo.annotations.Extension extends java.lang.annotation.Annotation
{
String vendorName();
String key();
String value();
}
public annotation javax.jdo.annotations.Extensions extends java.lang.annotation.Annotation
{
javax.jdo.annotations.Extension[] value();
}
public annotation javax.jdo.annotations.FetchGroup extends java.lang.annotation.Annotation
{
String name() default "";
String postLoad() default "";
javax.jdo.annotations.Persistent[] members();
String[] fetchGroups() default {};
}
public annotation javax.jdo.annotations.FetchGroups extends java.lang.annotation.Annotation
{
javax.jdo.annotations.FetchGroup[] value();
}
public annotation javax.jdo.annotations.FetchPlan extends java.lang.annotation.Annotation
{
String name() default "";
String[] fetchGroups() default {};
int maxFetchDepth() default 1;
int fetchSize() default 0;
}
public annotation javax.jdo.annotations.FetchPlans extends java.lang.annotation.Annotation
{
javax.jdo.annotations.FetchPlan[] value();
}
public annotation javax.jdo.annotations.ForeignKey extends java.lang.annotation.Annotation
{
String name() default "";
String table() default "";
String deferred() default "";
String unique() default "";
enum javax.jdo.annotations.ForeignKeyAction deleteAction() default javax.jdo.annotations.ForeignKeyAction.RESTRICT;
enum javax.jdo.annotations.ForeignKeyAction updateAction() default javax.jdo.annotations.ForeignKeyAction.RESTRICT;
String[] members() default {};
javax.jdo.annotations.Column[] columns() default {};
javax.jdo.annotations.Extension[] extensions() default {};
}
public final enum javax.jdo.annotations.ForeignKeyAction extends java.lang.Enum
{
public static final enum javax.jdo.annotations.ForeignKeyAction UNSPECIFIED;
public static final enum javax.jdo.annotations.ForeignKeyAction RESTRICT;
public static final enum javax.jdo.annotations.ForeignKeyAction CASCADE;
public static final enum javax.jdo.annotations.ForeignKeyAction NULL;
public static final enum javax.jdo.annotations.ForeignKeyAction DEFAULT;
public static final enum javax.jdo.annotations.ForeignKeyAction NONE;
public static enum javax.jdo.annotations.ForeignKeyAction valueOf(java.lang.String);
public static javax.jdo.annotations.ForeignKeyAction[] values();
}
public annotation javax.jdo.annotations.ForeignKeys extends java.lang.annotation.Annotation
{
javax.jdo.annotations.ForeignKey[] value();
}
public final enum javax.jdo.annotations.IdGeneratorStrategy extends java.lang.Enum
{
public static final enum javax.jdo.annotations.IdGeneratorStrategy UNSPECIFIED;
public static final enum javax.jdo.annotations.IdGeneratorStrategy NATIVE;
public static final enum javax.jdo.annotations.IdGeneratorStrategy SEQUENCE;
public static final enum javax.jdo.annotations.IdGeneratorStrategy IDENTITY;
public static final enum javax.jdo.annotations.IdGeneratorStrategy INCREMENT;
public static final enum javax.jdo.annotations.IdGeneratorStrategy UUIDSTRING;
public static final enum javax.jdo.annotations.IdGeneratorStrategy UUIDHEX;
public static enum javax.jdo.annotations.IdGeneratorStrategy valueOf(java.lang.String);
public static javax.jdo.annotations.IdGeneratorStrategy[] values();
}
public final enum javax.jdo.annotations.IdentityType extends java.lang.Enum
{
public static final enum javax.jdo.annotations.IdentityType UNSPECIFIED;
public static final enum javax.jdo.annotations.IdentityType APPLICATION;
public static final enum javax.jdo.annotations.IdentityType DATASTORE;
public static final enum javax.jdo.annotations.IdentityType NONDURABLE;
public static enum javax.jdo.annotations.IdentityType valueOf(java.lang.String);
public static javax.jdo.annotations.IdentityType[] values();
}
public annotation javax.jdo.annotations.Index extends java.lang.annotation.Annotation
{
String name() default "";
String table() default "";
String unique() default "";
String[] members() default {};
javax.jdo.annotations.Column[] columns() default {};
javax.jdo.annotations.Extension[] extensions() default {};
}
public annotation javax.jdo.annotations.Indices extends java.lang.annotation.Annotation
{
javax.jdo.annotations.Index[] value();
}
public annotation javax.jdo.annotations.Inheritance extends java.lang.annotation.Annotation
{
enum javax.jdo.annotations.InheritanceStrategy strategy() default javax.jdo.annotations.InheritanceStrategy.UNSPECIFIED;
String customStrategy() default "";
}
public final enum javax.jdo.annotations.InheritanceStrategy extends java.lang.Enum
{
public static final enum javax.jdo.annotations.InheritanceStrategy UNSPECIFIED;
public static final enum javax.jdo.annotations.InheritanceStrategy NEW_TABLE;
public static final enum javax.jdo.annotations.InheritanceStrategy SUBCLASS_TABLE;
public static final enum javax.jdo.annotations.InheritanceStrategy SUPERCLASS_TABLE;
public static final enum javax.jdo.annotations.InheritanceStrategy COMPLETE_TABLE;
public static enum javax.jdo.annotations.InheritanceStrategy valueOf(java.lang.String);
public static javax.jdo.annotations.InheritanceStrategy[] values();
}
public annotation javax.jdo.annotations.Join extends java.lang.annotation.Annotation
{
String table() default "";
String column() default "";
String indexed() default "";
String index() default "";
String unique() default "";
String uniqueKey() default "";
String outer() default "";
enum javax.jdo.annotations.ForeignKeyAction deleteAction() default javax.jdo.annotations.ForeignKeyAction.UNSPECIFIED;
javax.jdo.annotations.Column[] columns() default {};
String generatePrimaryKey() default "";
String primaryKey() default "";
String generateForeignKey() default "";
String foreignKey() default "";
javax.jdo.annotations.Extension[] extensions() default {};
}
public annotation javax.jdo.annotations.Joins extends java.lang.annotation.Annotation
{
javax.jdo.annotations.Join[] value();
}
public annotation javax.jdo.annotations.Key extends java.lang.annotation.Annotation
{
Class[] types() default {};
String serialized() default "";
String embedded() default "";
javax.jdo.annotations.Embedded[] embeddedMapping() default {};
String dependent() default "";
String table() default "";
String column() default "";
enum javax.jdo.annotations.ForeignKeyAction deleteAction() default javax.jdo.annotations.ForeignKeyAction.UNSPECIFIED;
enum javax.jdo.annotations.ForeignKeyAction updateAction() default javax.jdo.annotations.ForeignKeyAction.UNSPECIFIED;
String indexed() default "";
String index() default "";
String unique() default "";
String uniqueKey() default "";
String mappedBy() default "";
javax.jdo.annotations.Column[] columns() default {};
String generateForeignKey() default "";
String foreignKey() default "";
javax.jdo.annotations.Extension[] extensions() default {};
}
public annotation javax.jdo.annotations.NotPersistent extends java.lang.annotation.Annotation
{
}
public final enum javax.jdo.annotations.NullValue extends java.lang.Enum
{
public static final enum javax.jdo.annotations.NullValue NONE;
public static final enum javax.jdo.annotations.NullValue EXCEPTION;
public static final enum javax.jdo.annotations.NullValue DEFAULT;
public static enum javax.jdo.annotations.NullValue valueOf(java.lang.String);
public static javax.jdo.annotations.NullValue[] values();
}
public annotation javax.jdo.annotations.Order extends java.lang.annotation.Annotation
{
String column() default "";
String mappedBy() default "";
javax.jdo.annotations.Column[] columns() default {};
javax.jdo.annotations.Extension[] extensions() default {};
}
public annotation javax.jdo.annotations.PersistenceAware extends java.lang.annotation.Annotation
{
}
public annotation javax.jdo.annotations.PersistenceCapable extends java.lang.annotation.Annotation
{
javax.jdo.annotations.Persistent[] members() default {};
String table() default "";
String catalog() default "";
String schema() default "";
String requiresExtent() default "";
String embeddedOnly() default "";
String detachable() default "";
enum javax.jdo.annotations.IdentityType identityType() default javax.jdo.annotations.IdentityType.UNSPECIFIED;
Class objectIdClass() default void.class;
javax.jdo.annotations.Extension[] extensions() default {};
String cacheable() default "true";
String serializeRead() default "false";
}
public final enum javax.jdo.annotations.PersistenceModifier extends java.lang.Enum
{
public static final enum javax.jdo.annotations.PersistenceModifier UNSPECIFIED;
public static final enum javax.jdo.annotations.PersistenceModifier PERSISTENT;
public static final enum javax.jdo.annotations.PersistenceModifier TRANSACTIONAL;
public static final enum javax.jdo.annotations.PersistenceModifier NONE;
public static enum javax.jdo.annotations.PersistenceModifier valueOf(java.lang.String);
public static javax.jdo.annotations.PersistenceModifier[] values();
}
public annotation javax.jdo.annotations.Persistent extends java.lang.annotation.Annotation
{
enum javax.jdo.annotations.PersistenceModifier persistenceModifier()
default javax.jdo.annotations.PersistenceModifier.UNSPECIFIED;
String table() default "";
String defaultFetchGroup() default "";
enum javax.jdo.annotations.NullValue nullValue() default javax.jdo.annotations.NullValue.NONE;
String embedded() default "";
String embeddedElement() default "";
String embeddedKey() default "";
String embeddedValue() default "";
String serialized() default "";
String serializedElement() default "";
String serializedKey() default "";
String serializedValue() default "";
String dependent() default "";
String dependentElement() default "";
String dependentKey() default "";
String dependentValue() default "";
String primaryKey() default "";
enum javax.jdo.annotations.IdGeneratorStrategy valueStrategy() default javax.jdo.annotations.IdGeneratorStrategy.UNSPECIFIED;
String customValueStrategy() default "";
String sequence() default "";
String loadFetchGroup() default "";
Class[] types() default {};
String mappedBy() default "";
javax.jdo.annotations.Column[] columns() default {};
String column() default "";
String nullIndicatorColumn() default "";
String name() default "";
int recursionDepth() default 1;
javax.jdo.annotations.Extension[] extensions() default {};
String cacheable() default "true";
}
public annotation javax.jdo.annotations.PrimaryKey extends java.lang.annotation.Annotation
{
String name() default "";
String column() default "";
javax.jdo.annotations.Column[] columns() default {};
javax.jdo.annotations.Extension[] extensions() default {};
}
public annotation javax.jdo.annotations.Queries extends java.lang.annotation.Annotation
{
javax.jdo.annotations.Query[] value();
}
public annotation javax.jdo.annotations.Query extends java.lang.annotation.Annotation
{
String name();
String value();
String language() default "JDOQL";
String unmodifiable() default "";
String unique() default "";
Class resultClass() default void.class;
String fetchPlan() default "";
javax.jdo.annotations.Extension[] extensions() default {};
}
public annotation javax.jdo.annotations.Sequence extends java.lang.annotation.Annotation
{
String name();
enum javax.jdo.annotations.SequenceStrategy strategy();
String datastoreSequence() default "";
Class factoryClass() default void.class;
javax.jdo.annotations.Extension[] extensions() default {};
int initialValue() default 1;
int allocationSize() default 50;
}
public final enum javax.jdo.annotations.SequenceStrategy extends java.lang.Enum
{
public static final enum javax.jdo.annotations.SequenceStrategy NONTRANSACTIONAL;
public static final enum javax.jdo.annotations.SequenceStrategy CONTIGUOUS;
public static final enum javax.jdo.annotations.SequenceStrategy NONCONTIGUOUS;
public static enum javax.jdo.annotations.SequenceStrategy valueOf(java.lang.String);
public static javax.jdo.annotations.SequenceStrategy[] values();
}
public annotation javax.jdo.annotations.Serialized extends java.lang.annotation.Annotation
{
}
public annotation javax.jdo.annotations.Transactional extends java.lang.annotation.Annotation
{
}
public annotation javax.jdo.annotations.Unique extends java.lang.annotation.Annotation
{
String name() default "";
String table() default "";
String deferred() default "";
String[] members() default {};
javax.jdo.annotations.Column[] columns() default {};
javax.jdo.annotations.Extension[] extensions() default {};
}
public annotation javax.jdo.annotations.Uniques extends java.lang.annotation.Annotation
{
javax.jdo.annotations.Unique[] value();
}
public annotation javax.jdo.annotations.Value extends java.lang.annotation.Annotation
{
Class[] types() default {};
String serialized() default "";
String embedded() default "";
javax.jdo.annotations.Embedded[] embeddedMapping() default {};
String dependent() default "";
String table() default "";
String column() default "";
enum javax.jdo.annotations.ForeignKeyAction deleteAction() default javax.jdo.annotations.ForeignKeyAction.UNSPECIFIED;
enum javax.jdo.annotations.ForeignKeyAction updateAction() default javax.jdo.annotations.ForeignKeyAction.UNSPECIFIED;
String indexed() default "";
String index() default "";
String unique() default "";
String uniqueKey() default "";
String mappedBy() default "";
javax.jdo.annotations.Column[] columns() default {};
String generateForeignKey() default "";
String foreignKey() default "";
javax.jdo.annotations.Extension[] extensions() default {};
}
public annotation javax.jdo.annotations.Version extends java.lang.annotation.Annotation
{
enum javax.jdo.annotations.VersionStrategy strategy() default javax.jdo.annotations.VersionStrategy.UNSPECIFIED;
String customStrategy() default "";
String column() default "";
String indexed() default "";
javax.jdo.annotations.Column[] columns() default {};
javax.jdo.annotations.Extension[] extensions() default {};
}
public final enum javax.jdo.annotations.VersionStrategy extends java.lang.Enum
{
public static final enum javax.jdo.annotations.VersionStrategy UNSPECIFIED;
public static final enum javax.jdo.annotations.VersionStrategy NONE;
public static final enum javax.jdo.annotations.VersionStrategy STATE_IMAGE;
public static final enum javax.jdo.annotations.VersionStrategy DATE_TIME;
public static final enum javax.jdo.annotations.VersionStrategy VERSION_NUMBER;
public static enum javax.jdo.annotations.VersionStrategy valueOf(java.lang.String);
public static javax.jdo.annotations.VersionStrategy[] values();
}
public annotation javax.jdo.annotations.Cacheable extends java.lang.annotation.Annotation
{
String value() default "true";
}
public interface javax.jdo.FetchGroup {
public static final String DEFAULT = "default";
public static final String RELATIONSHIP = "relationship";
public static final String MULTIVALUED = "multivalued";
public static final String BASIC = "basic";
public static final String ALL = "all";
String getName();
Class getType();
boolean getPostLoad();
javax.jdo.FetchGroup setPostLoad(boolean postLoad);
javax.jdo.FetchGroup addMember(String memberName);
varargs javax.jdo.FetchGroup addMembers(String[] memberNames);
javax.jdo.FetchGroup removeMember(String memberName);
varargs javax.jdo.FetchGroup removeMembers(String[] memberNames);
javax.jdo.FetchGroup addCategory(String categoryName);
javax.jdo.FetchGroup removeCategory(String categoryName);
javax.jdo.FetchGroup setRecursionDepth(String memberName, int recursionDepth);
int getRecursionDepth(String memberName);
java.util.Set getMembers();
javax.jdo.FetchGroup setUnmodifiable();
boolean isUnmodifiable();
int hashCode();
boolean equals(Object other);
}
/*** This causes some NPE in SignatureTest whatever that means ***/
/*
public interface JDOEnhancer extends java.lang.instrument.ClassFileTransformer {
java.util.Properties getProperties();
javax.jdo.JDOEnhancer setVerbose(boolean flag);
javax.jdo.JDOEnhancer setOutputDirectory(String dirName);
javax.jdo.JDOEnhancer setClassLoader(ClassLoader loader);
javax.jdo.JDOEnhancer addPersistenceUnit(String persistenceUnit);
javax.jdo.JDOEnhancer addClass(String className, byte[] bytes);
javax.jdo.JDOEnhancer addClasses(String... classNames);
javax.jdo.JDOEnhancer addFiles(String... metadataFiles);
javax.jdo.JDOEnhancer addJar(String jarFileName);
int enhance();
int validate();
byte[] getEnhancedBytes(String className);
void registerMetadata(javax.jdo.metadata.JDOMetadata metadata);
javax.jdo.metadata.JDOMetadata newMetadata();
} */
tck/src/conf/jdohelper.conf 100664 6523 12500110374 16216 0 ustar mbouschen staff 0 0 # 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.
jdo.tck.description = All jdohelper tests with standard mapping, no testdata.
jdo.tck.mapping.companyfactory =
jdo.tck.testdata =
jdo.tck.standarddata =
jdo.tck.mapping = 0
jdo.tck.requiredOptions =
jdo.tck.classes = \
org.apache.jdo.tck.api.jdohelper.GetObjectId \
org.apache.jdo.tck.api.jdohelper.GetObjectIdForNull \
org.apache.jdo.tck.api.jdohelper.GetObjectIdForTransient \
org.apache.jdo.tck.api.jdohelper.GetObjectIdNotPersistenceCapable \
org.apache.jdo.tck.api.jdohelper.GetObjectIds \
org.apache.jdo.tck.api.jdohelper.GetPersistenceManager \
org.apache.jdo.tck.api.jdohelper.GetPersistenceManagerForNull \
org.apache.jdo.tck.api.jdohelper.GetPersistenceManagerForTransient \
org.apache.jdo.tck.api.jdohelper.GetPersistenceManagerNotPersistenceCapable \
org.apache.jdo.tck.api.jdohelper.GetTransactionalObjectId \
org.apache.jdo.tck.api.jdohelper.GetTransactionalObjectIdForNull \
org.apache.jdo.tck.api.jdohelper.GetTransactionalObjectIdForTransient \
org.apache.jdo.tck.api.jdohelper.GetTransactionalObjectIdNotPersistenceCapable \
org.apache.jdo.tck.api.jdohelper.IsDeleted \
org.apache.jdo.tck.api.jdohelper.IsDeletedFalse \
org.apache.jdo.tck.api.jdohelper.IsDeletedForNull \
org.apache.jdo.tck.api.jdohelper.IsDeletedForTransient \
org.apache.jdo.tck.api.jdohelper.IsDeletedNotPersistenceCapable \
org.apache.jdo.tck.api.jdohelper.IsDirty \
org.apache.jdo.tck.api.jdohelper.IsDirtyFalse \
org.apache.jdo.tck.api.jdohelper.IsDirtyForNull \
org.apache.jdo.tck.api.jdohelper.IsDirtyForTransient \
org.apache.jdo.tck.api.jdohelper.IsDirtyNotPersistenceCapable \
org.apache.jdo.tck.api.jdohelper.IsNew \
org.apache.jdo.tck.api.jdohelper.IsNewFalse \
org.apache.jdo.tck.api.jdohelper.IsNewForNull \
org.apache.jdo.tck.api.jdohelper.IsNewForTransient \
org.apache.jdo.tck.api.jdohelper.IsNewNotPersistenceCapable \
org.apache.jdo.tck.api.jdohelper.IsPersistent \
org.apache.jdo.tck.api.jdohelper.IsPersistentFalse \
org.apache.jdo.tck.api.jdohelper.IsPersistentForNull \
org.apache.jdo.tck.api.jdohelper.IsPersistentForTransient \
org.apache.jdo.tck.api.jdohelper.IsPersistentNotPersistenceCapable \
org.apache.jdo.tck.api.jdohelper.IsTransactional \
org.apache.jdo.tck.api.jdohelper.IsTransactionalFalse \
org.apache.jdo.tck.api.jdohelper.IsTransactionalForNull \
org.apache.jdo.tck.api.jdohelper.IsTransactionalForTransient \
org.apache.jdo.tck.api.jdohelper.IsTransactionalNotPersistenceCapable \
org.apache.jdo.tck.api.jdohelper.MakeDirty \
org.apache.jdo.tck.api.jdohelper.MakeDirtyForNull \
org.apache.jdo.tck.api.jdohelper.MakeDirtyForTransient \
org.apache.jdo.tck.api.jdohelper.MakeDirtyNotPersistenceCapable
tck/src/conf/jdoql.conf 100664 15745 12500110374 15401 0 ustar mbouschen staff 0 0 # 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.
jdo.tck.description = All jdoql tests with standard mapping, no testdata.
jdo.tck.mapping.companyfactory =
jdo.tck.testdata =
jdo.tck.standarddata =
jdo.tck.mapping = 0
jdo.tck.requiredOptions =
jdo.tck.classes = \
org.apache.jdo.tck.query.jdoql.AssignmentPrePostIncrementDecrementNotSupported \
org.apache.jdo.tck.query.jdoql.Cast \
org.apache.jdo.tck.query.jdoql.CharacterAndStringLiterals \
org.apache.jdo.tck.query.jdoql.ComparingCollectionFieldToNull \
org.apache.jdo.tck.query.jdoql.ComparingPersistentAndNonPersistentInstance \
org.apache.jdo.tck.query.jdoql.DenoteUniquenessInFilter \
org.apache.jdo.tck.query.jdoql.ExecuteQueryWhenPersistenceManagerIsClosed \
org.apache.jdo.tck.query.jdoql.ExecutingMultipleQueriesSimultaneouslyIsThreadSafe \
org.apache.jdo.tck.query.jdoql.ExecutingQueryWhenNoTransactionNoNontransactionalRead \
org.apache.jdo.tck.query.jdoql.Having \
org.apache.jdo.tck.query.jdoql.IdentifiersEqualFieldNames \
org.apache.jdo.tck.query.jdoql.IfElseInFilter \
org.apache.jdo.tck.query.jdoql.IgnoreCacheFalse \
org.apache.jdo.tck.query.jdoql.MultipleActiveQueryInstanceInSamePersistenceManager \
org.apache.jdo.tck.query.jdoql.MultipleIdenticalImports \
org.apache.jdo.tck.query.jdoql.NamespaceOfIdentifiers \
org.apache.jdo.tck.query.jdoql.NavigationThroughACollectionField \
org.apache.jdo.tck.query.jdoql.NavigationThroughANullValuedField \
org.apache.jdo.tck.query.jdoql.NavigationThroughReferencesUsesDotOperator \
org.apache.jdo.tck.query.jdoql.NegativeRange \
org.apache.jdo.tck.query.jdoql.NullCollectionsAndContainsMethod \
org.apache.jdo.tck.query.jdoql.NullCollectionsAndIsEmpty \
org.apache.jdo.tck.query.jdoql.OrderingSpecification \
org.apache.jdo.tck.query.jdoql.ParenthesesMarkOperatorPrecedence \
org.apache.jdo.tck.query.jdoql.PositiveRange \
org.apache.jdo.tck.query.jdoql.QueryIsSerializable \
org.apache.jdo.tck.query.jdoql.QueryResultPassedToAnotherQuery \
org.apache.jdo.tck.query.jdoql.QueryWithNoFilter \
org.apache.jdo.tck.query.jdoql.RangeAsString \
org.apache.jdo.tck.query.jdoql.RestoredSerializedQueryInstanceLosesAssociationWithPM \
org.apache.jdo.tck.query.jdoql.SeparateNamespaceForTypeNames \
org.apache.jdo.tck.query.jdoql.WhiteSpaceIsACharacterAndIgnored \
org.apache.jdo.tck.query.jdoql.keywords.InvalidUseOfKeywords \
org.apache.jdo.tck.query.jdoql.keywords.KeywordsAsFieldNames \
org.apache.jdo.tck.query.jdoql.keywords.SingleString \
org.apache.jdo.tck.query.jdoql.keywords.ThisIsReservedWordForElementOfCollection \
org.apache.jdo.tck.query.jdoql.keywords.UppercaseLowercase \
org.apache.jdo.tck.query.jdoql.keywords.UseOfThisToAcessHiddenField \
org.apache.jdo.tck.query.jdoql.methods.EnumMethodToString \
org.apache.jdo.tck.query.jdoql.methods.MethodsAndObjectConstructionNotSupported \
org.apache.jdo.tck.query.jdoql.methods.StartsWithAndEndsWith \
org.apache.jdo.tck.query.jdoql.methods.SupportedCollectionMethods \
org.apache.jdo.tck.query.jdoql.methods.SupportedDateMethods \
org.apache.jdo.tck.query.jdoql.methods.SupportedTimeMethods \
org.apache.jdo.tck.query.jdoql.methods.SupportedJDOHelperMethods \
org.apache.jdo.tck.query.jdoql.methods.SupportedListMethods \
org.apache.jdo.tck.query.jdoql.methods.SupportedMapMethods \
org.apache.jdo.tck.query.jdoql.methods.SupportedMathMethods \
org.apache.jdo.tck.query.jdoql.methods.SupportedStringMethods \
org.apache.jdo.tck.query.jdoql.operators.BinaryAddition \
org.apache.jdo.tck.query.jdoql.operators.BinarySubtraction \
org.apache.jdo.tck.query.jdoql.operators.BitwiseComplement \
org.apache.jdo.tck.query.jdoql.operators.BooleanLogicalAND \
org.apache.jdo.tck.query.jdoql.operators.BooleanLogicalOR \
org.apache.jdo.tck.query.jdoql.operators.ConditionalAND \
org.apache.jdo.tck.query.jdoql.operators.ConditionalOR \
org.apache.jdo.tck.query.jdoql.operators.Division \
org.apache.jdo.tck.query.jdoql.operators.Equality \
org.apache.jdo.tck.query.jdoql.operators.EqualityAndComparisonsBetweenDateFieldsAndParameters \
org.apache.jdo.tck.query.jdoql.operators.EqualityAndComparisonsBetweenPrimitivesAndWrapperInstances \
org.apache.jdo.tck.query.jdoql.operators.EqualityAndComparisonsBetweenStringFieldsAndParameters \
org.apache.jdo.tck.query.jdoql.operators.GreaterThan \
org.apache.jdo.tck.query.jdoql.operators.GreaterThanOrEqual \
org.apache.jdo.tck.query.jdoql.operators.Instanceof \
org.apache.jdo.tck.query.jdoql.operators.LessThan \
org.apache.jdo.tck.query.jdoql.operators.LessThanOrEqual \
org.apache.jdo.tck.query.jdoql.operators.LogicalComplement \
org.apache.jdo.tck.query.jdoql.operators.Multiplication \
org.apache.jdo.tck.query.jdoql.operators.Modulo \
org.apache.jdo.tck.query.jdoql.operators.NotEquals \
org.apache.jdo.tck.query.jdoql.operators.PromotionOfNumericOperands \
org.apache.jdo.tck.query.jdoql.operators.SignInversion \
org.apache.jdo.tck.query.jdoql.operators.StringConcatenation \
org.apache.jdo.tck.query.jdoql.operators.UnaryPlus \
org.apache.jdo.tck.query.jdoql.parameters.BoundParameterCheck \
org.apache.jdo.tck.query.jdoql.parameters.ImplicitParameters \
org.apache.jdo.tck.query.jdoql.parameters.MixedParameters \
org.apache.jdo.tck.query.jdoql.parameters.OrderOfParameters \
org.apache.jdo.tck.query.jdoql.parameters.ParameterBoundToDifferentPM \
org.apache.jdo.tck.query.jdoql.parameters.ParameterDeclaredWithSameNameAsFieldOfCandidateClass \
org.apache.jdo.tck.query.jdoql.parameters.PrimitiveParameterPassedAsNull \
org.apache.jdo.tck.query.jdoql.subqueries.AggregateOnSize \
org.apache.jdo.tck.query.jdoql.subqueries.CorrelatedSubqueries \
org.apache.jdo.tck.query.jdoql.subqueries.CorrelatedSubqueriesWithParameters \
org.apache.jdo.tck.query.jdoql.subqueries.MultipleCallsReplaceSubquery \
org.apache.jdo.tck.query.jdoql.subqueries.NonCorrelatedSubqueries \
org.apache.jdo.tck.query.jdoql.subqueries.NullCandidateCollectionExpression \
org.apache.jdo.tck.query.jdoql.subqueries.NullSubqueryParameter \
org.apache.jdo.tck.query.jdoql.subqueries.NullVariableDeclaration \
org.apache.jdo.tck.query.jdoql.subqueries.UnmodifiedSubqueryInstance \
org.apache.jdo.tck.query.jdoql.variables.MixedVariables \
org.apache.jdo.tck.query.jdoql.variables.UnconstrainedVariable \
org.apache.jdo.tck.query.jdoql.variables.VariablesAndFields \
org.apache.jdo.tck.query.jdoql.variables.VariablesWithoutExtent \
org.apache.jdo.tck.query.jdoql.variables.VariableDeclaredWithSameNameAsFieldOfCandidateClass
tck/src/conf/jdoql1.conf 100664 2062 12500110374 15426 0 ustar mbouschen staff 0 0 # 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.
jdo.tck.description = Special jdoql test with mapping 1 which maps Enums to integer columns
jdo.tck.mapping.companyfactory =
jdo.tck.testdata =
jdo.tck.standarddata =
jdo.tck.mapping = 1
jdo.tck.requiredOptions =
jdo.tck.classes = \
org.apache.jdo.tck.query.jdoql.methods.EnumMethodOrdinal
tck/src/conf/jdori-jdoconfig.xml 100664 27175 12500110374 17212 0 ustar mbouschen staff 0 0
tck/src/conf/jdori-persistence.xml 100664 13237 12500110374 17566 0 ustar mbouschen staff 0 0
relations.Deity
tck/src/conf/jdori-pmf.properties 100664 3766 12500110374 17406 0 ustar mbouschen staff 0 0 # 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.
# -------------------------------------------------------------------
# P R O J E C T P R O P E R T I E S
# -------------------------------------------------------------------
#
# JDORI PMF Properties
javax.jdo.PersistenceManagerFactoryClass=org.datanucleus.api.jdo.JDOPersistenceManagerFactory
javax.jdo.option.ConnectionDriverName=org.apache.derby.jdbc.EmbeddedDriver
javax.jdo.option.ConnectionURL=jdbc:derby:jdotckdb
javax.jdo.option.ConnectionUserName=tckuser
javax.jdo.option.ConnectionPassword=tckuser
javax.jdo.option.Optimistic=false
javax.jdo.option.NontransactionalWrite=false
javax.jdo.option.NontransactionalRead=false
javax.jdo.option.RetainValues=false
javax.jdo.option.RestoreValues=false
datanucleus.metadata.validate=false
datanucleus.validateTables=false
datanucleus.validateConstraints=false
datanucleus.autoCreateSchema=false
datanucleus.autoCreateTables=false
datanucleus.autoCreateConstraints=false
datanucleus.autoCreateColumns=false
datanucleus.rdbms.CheckExistTablesOrViews=false
datanucleus.autoStartMechanism=None
datanucleus.connectionPoolingType=C3P0
datanucleus.connectionPool.maxStatements=20
datanucleus.implementationCreatorName=asm
datanucleus.rdbms.omitDatabaseMetaDataGetColumns=true
datanucleus.nontx.atomic=false
tck/src/conf/jndi.properties 100664 1535 12500110374 16433 0 ustar mbouschen staff 0 0 #
# 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.
java.naming.factory.initial=com.sun.jndi.fscontext.RefFSContextFactory
tck/src/conf/lifecycle.conf 100664 4052 12500110374 16174 0 ustar mbouschen staff 0 0 # 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.
jdo.tck.description = All lifecycle tests with standard mapping, no testdata.
jdo.tck.mapping.companyfactory =
jdo.tck.testdata =
jdo.tck.standarddata =
jdo.tck.mapping = 0
jdo.tck.requiredOptions =
jdo.tck.classes = \
org.apache.jdo.tck.lifecycle.HollowInstanceMaintainsPK \
org.apache.jdo.tck.lifecycle.MultiplePMsReturnInstancesRepresentingSamePC \
org.apache.jdo.tck.lifecycle.NontransactionalWriteThrows \
org.apache.jdo.tck.lifecycle.NontransactionalWriteDatastoreRollback \
org.apache.jdo.tck.lifecycle.NontransactionalWriteDatastoreCommit \
org.apache.jdo.tck.lifecycle.NontransactionalWriteDatastoreCommitConflict \
org.apache.jdo.tck.lifecycle.NontransactionalWriteOptimisticRollback \
org.apache.jdo.tck.lifecycle.NontransactionalWriteOptimisticCommit \
org.apache.jdo.tck.lifecycle.NontransactionalWriteOptimisticCommitConflict \
org.apache.jdo.tck.lifecycle.ObjectIdNotModifiedWhenObjectIdInstanceModified \
org.apache.jdo.tck.lifecycle.PMReturnsIdenticalInstancesForEqualObjIds \
org.apache.jdo.tck.lifecycle.PMsCanSharePCClassesButNotPCInstances \
org.apache.jdo.tck.lifecycle.StateTransitions \
org.apache.jdo.tck.lifecycle.StateTransitionsReturnedObjects \
org.apache.jdo.tck.lifecycle.TransientTransactionalStateCommit \
org.apache.jdo.tck.lifecycle.TransientTransactionalStateRollback
tck/src/conf/log4j.properties 100664 7741 12500110374 16533 0 ustar mbouschen staff 0 0 #
# 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.
#############################
# TCK loggers and appenders
#############################
# Root logger
log4j.rootLogger = ERROR, TCK
# TCK logger
log4j.logger.org.apache.jdo.tck = INFO, TCK
log4j.additivity.org.apache.jdo.tck = false
# SpringFramework loggers
log4j.logger.org.springframework = ERROR, TCK
log4j.additivity.org.springframework = false
log4j.logger.org.apache.jdo.tck.pc.company.CompanyModelReader = ERROR, TCK
log4j.logger.org.apache.jdo.tck.pc.mylib.MylibReader = ERROR, TCK
# TCK appenders
log4j.appender.TCK = org.apache.jdo.tck.util.TCKFileAppender
log4j.appender.TCK.File = tck.txt
log4j.appender.TCK.layout = org.apache.log4j.PatternLayout
log4j.appender.TCK.layout.ConversionPattern = %d{HH:mm:ss,SSS} (%t) %-5p [%c] - %m%n
############################################
# JDO vendor specific loggers and appenders
############################################
#log4j.logger. = INFO
#log4j.additivity. = false
#log4j.appender. = org.apache.jdo.tck.util.TCKFileAppender
#log4j.appender..File = .txt
#log4j.appender..layout = org.apache.log4j.PatternLayout
#log4j.appender..layout.ConversionPattern = %d{HH:mm:ss,SSS} (%t) %-5p [%c] - %m%n
###################################
# DataNucleus loggers and appenders
###################################
# DataNucleus loggers
# For more details on DataNucleus logging see
# http://www.datanucleus.org/products/accessplatform/logging.html
log4j.logger.DataNucleus = INFO, DataNucleus
log4j.logger.DataNucleus.Enhancer = INFO, DataNucleus
log4j.additivity.DataNucleus = false
#log4j.logger.DataNucleus.JDO = INFO, DataNucleus
#log4j.logger.DataNucleus.Persistence = INFO, DataNucleus
#log4j.logger.DataNucleus.Query = INFO, DataNucleus
#log4j.logger.DataNucleus.Lifecycle = INFO, DataNucleus
#log4j.logger.DataNucleus.Reachability = INFO, DataNucleus
#log4j.logger.DataNucleus.Cache = INFO, DataNucleus
#log4j.logger.DataNucleus.ClassLoading = INFO, DataNucleus
#log4j.logger.DataNucleus.MetaData = DEBUG, DataNucleus
#log4j.logger.DataNucleus.Management = DEBUG, DataNucleus
#log4j.logger.DataNucleus.General = DEBUG, DataNucleus
#log4j.logger.DataNucleus.Connection = DEBUG, DataNucleus
#log4j.logger.DataNucleus.JCA = DEBUG, DataNucleus
#log4j.logger.DataNucleus.Transaction = INFO, DataNucleus
#log4j.logger.DataNucleus.Plugin = INFO, DataNucleus
#log4j.logger.DataNucleus.Store.Poid = INFO, DataNucleus
#log4j.logger.DataNucleus.Datastore = DEBUG, DataNucleus
#log4j.logger.DataNucleus.Datastore.Schema = INFO, DataNucleus
#log4j.logger.DataNucleus.Datastore.Persist = INFO, DataNucleus
#log4j.logger.DataNucleus.Datastore.Retrieve = DEBUG, DataNucleus
#log4j.logger.DataNucleus.SchemaTool = INFO, DataNucleus
# C3P0 loggers
log4j.logger.com.mchange.v2 = INFO, DataNucleus
log4j.additivity.com.mchange.v2 = false
# DataNucleus appenders
log4j.appender.DataNucleus = org.apache.jdo.tck.util.TCKFileAppender
#log4j.appender.DataNucleus = org.apache.log4j.FileAppender
log4j.appender.DataNucleus.Enhancer.File = datanucleus.txt
log4j.appender.DataNucleus.File = datanucleus.txt
log4j.appender.DataNucleus.layout = org.apache.log4j.PatternLayout
log4j.appender.DataNucleus.layout.ConversionPattern = %d{HH:mm:ss,SSS} (%t) %-5p [%c] - %m%n
tck/src/conf/logging.properties 100664 3762 12500110374 17141 0 ustar mbouschen staff 0 0 #
# 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.
#
# This is a sample properties file to configure standard JDK 1.4 logging for
# the JDO TCK test cases. Below you find an entry for each of the JDO TCK
# logger instances. Please uncomment the line and adapt the log level to your
# needs, in case to want to enable a particular logger.
#
# The following describes the mapping between the log level of JDK 1.4 logging
# and apache commns logging:
# JDK 1.4 Apache
# FINEST trace
# FINE, FINER debug
# INFO, CONFIG info
# WARNING warn
# SEVERE error, fatal
#
#############################
# TCK loggers and appenders
#############################
# Root logger
.level = SEVERE
# TCK logger
org.apache.jdo.tck.level = INFO
# SpringFramework loggers
org.springframework.level = SEVERE
org.apache.jdo.tck.pc.company.CompanyModelReader.level = SEVERE
org.apache.jdo.tck.pc.mylib.MylibReader = SEVERE
org.apache.jdo.tck.util.TCKFileHandler.fileName = tck.txt
org.apache.jdo.tck.util.TCKFileHandler.level = FINEST
##############################
# JDO vendor specific loggers
##############################
# = INFO
######################
# Default handlers
######################
handlers = org.apache.jdo.tck.util.TCKFileHandler
tck/src/conf/models.conf 100664 10173 12500110374 15541 0 ustar mbouschen staff 0 0 # 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.
jdo.tck.description = All model tests with standard mapping, no testdata.
jdo.tck.mapping.companyfactory =
jdo.tck.testdata =
jdo.tck.standarddata =
jdo.tck.mapping = 0
jdo.tck.requiredOptions =
jdo.tck.classes = \
org.apache.jdo.tck.models.embedded.SecondClassObjectsTrackTheirChanges \
org.apache.jdo.tck.models.fieldtypes.TestArrayCollections \
org.apache.jdo.tck.models.fieldtypes.TestArrayListCollections \
org.apache.jdo.tck.models.fieldtypes.TestCollectionCollections \
org.apache.jdo.tck.models.fieldtypes.TestFieldsOfBigDecimal \
org.apache.jdo.tck.models.fieldtypes.TestFieldsOfBigInteger \
org.apache.jdo.tck.models.fieldtypes.TestFieldsOfBoolean \
org.apache.jdo.tck.models.fieldtypes.TestFieldsOfByte \
org.apache.jdo.tck.models.fieldtypes.TestFieldsOfCharacter \
org.apache.jdo.tck.models.fieldtypes.TestFieldsOfDate \
org.apache.jdo.tck.models.fieldtypes.TestFieldsOfDouble \
org.apache.jdo.tck.models.fieldtypes.TestFieldsOfFloat \
org.apache.jdo.tck.models.fieldtypes.TestFieldsOfInteger \
org.apache.jdo.tck.models.fieldtypes.TestFieldsOfLocale \
org.apache.jdo.tck.models.fieldtypes.TestFieldsOfLong \
org.apache.jdo.tck.models.fieldtypes.TestFieldsOfObject \
org.apache.jdo.tck.models.fieldtypes.TestFieldsOfPrimitiveboolean \
org.apache.jdo.tck.models.fieldtypes.TestFieldsOfPrimitivebyte \
org.apache.jdo.tck.models.fieldtypes.TestFieldsOfPrimitivechar \
org.apache.jdo.tck.models.fieldtypes.TestFieldsOfPrimitivedouble \
org.apache.jdo.tck.models.fieldtypes.TestFieldsOfPrimitivefloat \
org.apache.jdo.tck.models.fieldtypes.TestFieldsOfPrimitiveint \
org.apache.jdo.tck.models.fieldtypes.TestFieldsOfPrimitivelong \
org.apache.jdo.tck.models.fieldtypes.TestFieldsOfPrimitiveshort \
org.apache.jdo.tck.models.fieldtypes.TestFieldsOfShort \
org.apache.jdo.tck.models.fieldtypes.TestFieldsOfSimpleClass \
org.apache.jdo.tck.models.fieldtypes.TestFieldsOfSimpleEnum \
org.apache.jdo.tck.models.fieldtypes.TestFieldsOfSimpleInterface \
org.apache.jdo.tck.models.fieldtypes.TestFieldsOfString \
org.apache.jdo.tck.models.fieldtypes.TestHashMapStringKeyCollections \
org.apache.jdo.tck.models.fieldtypes.TestHashMapStringValueCollections \
org.apache.jdo.tck.models.fieldtypes.TestHashSetCollections \
org.apache.jdo.tck.models.fieldtypes.TestHashtableStringKeyCollections \
org.apache.jdo.tck.models.fieldtypes.TestHashtableStringValueCollections \
org.apache.jdo.tck.models.fieldtypes.TestLinkedListCollections \
org.apache.jdo.tck.models.fieldtypes.TestListCollections \
org.apache.jdo.tck.models.fieldtypes.TestMapStringKeyCollections \
org.apache.jdo.tck.models.fieldtypes.TestMapStringValueCollections \
org.apache.jdo.tck.models.fieldtypes.TestSetCollections \
org.apache.jdo.tck.models.fieldtypes.TestTreeMapStringKeyCollections \
org.apache.jdo.tck.models.fieldtypes.TestTreeMapStringValueCollections \
org.apache.jdo.tck.models.fieldtypes.TestTreeSetCollections \
org.apache.jdo.tck.models.fieldtypes.TestVectorCollections \
org.apache.jdo.tck.models.inheritance.FieldWithSameNameInSuperclass \
org.apache.jdo.tck.models.inheritance.NonPersistentFieldsAreNonPersistentInSubclasses \
org.apache.jdo.tck.models.inheritance.NonpersistentSuperClass \
org.apache.jdo.tck.models.inheritance.PersistenceCapableFlexibilityInInheritanceHierarchy \
org.apache.jdo.tck.models.inheritance.PersistentFieldsArePersistentInSubClasses \
org.apache.jdo.tck.models.inheritance.TransactionalFieldsAreTransactionalInSubclasses
tck/src/conf/models1.conf 100664 2044 12500110374 15600 0 ustar mbouschen staff 0 0 # 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.
jdo.tck.description = All model tests with standard mapping, no testdata.
jdo.tck.mapping.companyfactory =
jdo.tck.testdata =
jdo.tck.standarddata =
jdo.tck.mapping = 1
jdo.tck.requiredOptions =
jdo.tck.classes = \
org.apache.jdo.tck.models.fieldtypes.TestFieldsOfSimpleEnum
tck/src/conf/pm.conf 100664 23113 12500110374 14670 0 ustar mbouschen staff 0 0 # 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.
jdo.tck.description = All pm tests with standard mapping, no testdata.
jdo.tck.mapping.companyfactory =
jdo.tck.testdata =
jdo.tck.standarddata =
jdo.tck.mapping = 0
jdo.tck.requiredOptions =
jdo.tck.classes = \
org.apache.jdo.tck.api.persistencemanager.ChangingObjectIdHasNoEffectOnInstance \
org.apache.jdo.tck.api.persistencemanager.ConcurrentPersistenceManagers \
org.apache.jdo.tck.api.persistencemanager.ConcurrentPersistenceManagersSameClasses \
org.apache.jdo.tck.api.persistencemanager.CurrentTransaction \
org.apache.jdo.tck.api.persistencemanager.DataStoreCacheTest \
org.apache.jdo.tck.api.persistencemanager.DataStoreConnection \
org.apache.jdo.tck.api.persistencemanager.DataStoreConnectionThrows \
org.apache.jdo.tck.api.persistencemanager.DatastoreTimeout \
org.apache.jdo.tck.api.persistencemanager.DeletePersistent \
org.apache.jdo.tck.api.persistencemanager.DeletePersistentAllFails \
org.apache.jdo.tck.api.persistencemanager.DeletePersistentFailsIfInstanceIsTransient \
org.apache.jdo.tck.api.persistencemanager.DeletePersistentFailsIfInstanceManagedByAnotherPersistenceManager \
org.apache.jdo.tck.api.persistencemanager.DeletePersistentHasNoEffectOnDeletedInstances \
org.apache.jdo.tck.api.persistencemanager.GetPersistenceManagerFactory \
org.apache.jdo.tck.api.persistencemanager.GetProperties \
org.apache.jdo.tck.api.persistencemanager.GetSetUserObject \
org.apache.jdo.tck.api.persistencemanager.GetTransactionalObjectIdWhenObjectIdBeingChanged \
org.apache.jdo.tck.api.persistencemanager.GetTransactionalObjectIdWithNoTransaction \
org.apache.jdo.tck.api.persistencemanager.NewInstance \
org.apache.jdo.tck.api.persistencemanager.NoPersistenceManagerIfTransient \
org.apache.jdo.tck.api.persistencemanager.ObjectIdUniqueAmongInstances \
org.apache.jdo.tck.api.persistencemanager.OneInstanceOfObjectPerPersistenceManager \
org.apache.jdo.tck.api.persistencemanager.OnePersistenceManagerIfPersistentOrTransactional \
org.apache.jdo.tck.api.persistencemanager.OptimisticFailure \
org.apache.jdo.tck.api.persistencemanager.SameTransactionInstanceForAllCallsToCurrentTransaction \
org.apache.jdo.tck.api.persistencemanager.ThreadSafe \
org.apache.jdo.tck.api.persistencemanager.TransientTransactionalInstanceRetainsValuesAtCommit \
org.apache.jdo.tck.api.persistencemanager.cache.CallingEvictAllWithCollectionContainingNulls \
org.apache.jdo.tck.api.persistencemanager.cache.CallingRefreshAllWithCollectionContainingNulls \
org.apache.jdo.tck.api.persistencemanager.cache.EvictAllWithNoParameters \
org.apache.jdo.tck.api.persistencemanager.cache.EvictingCollectionOfInstancesSideEffects \
org.apache.jdo.tck.api.persistencemanager.cache.EvictingWithRestoreValuesFalse \
org.apache.jdo.tck.api.persistencemanager.cache.EvictingWithRetainValuesFalse \
org.apache.jdo.tck.api.persistencemanager.cache.PassingNullToEvictAllThrowsException \
org.apache.jdo.tck.api.persistencemanager.cache.PassingNullToEvictHasNoEffect \
org.apache.jdo.tck.api.persistencemanager.cache.PassingNullToRefreshAllThrowsException \
org.apache.jdo.tck.api.persistencemanager.cache.PassingNullToRefreshHasNoEffect \
org.apache.jdo.tck.api.persistencemanager.cache.RefreshAllNoParameterSideEffects \
org.apache.jdo.tck.api.persistencemanager.cache.RefreshAllSideEffects \
org.apache.jdo.tck.api.persistencemanager.cache.RefreshAllWithNoParameters \
org.apache.jdo.tck.api.persistencemanager.cache.RefreshSideEffects \
org.apache.jdo.tck.api.persistencemanager.cache.Retrieve \
org.apache.jdo.tck.api.persistencemanager.close.AfterCloseAllMethodsThrowException \
org.apache.jdo.tck.api.persistencemanager.close.CloseThrowsExceptionWhenActiveTx \
org.apache.jdo.tck.api.persistencemanager.close.IsClosedIsFalseUponConstruction \
org.apache.jdo.tck.api.persistencemanager.close.IsClosedIsFalseUponRetrievalFromPool \
org.apache.jdo.tck.api.persistencemanager.close.IsClosedIsTrueAfterClose \
org.apache.jdo.tck.api.persistencemanager.extent.GetExtentWithInstancesMadePersistentViaReachability \
org.apache.jdo.tck.api.persistencemanager.extent.GetExtentWithNoSubclasses \
org.apache.jdo.tck.api.persistencemanager.extent.GetExtentWithSubclasses \
org.apache.jdo.tck.api.persistencemanager.flags.GetIgnoreCache \
org.apache.jdo.tck.api.persistencemanager.flags.SetIgnoreCacheToFalse \
org.apache.jdo.tck.api.persistencemanager.flags.SetIgnoreCacheToTrue \
org.apache.jdo.tck.api.persistencemanager.flags.SetMultithreadedFalse \
org.apache.jdo.tck.api.persistencemanager.flags.SetMultithreadedTrue \
org.apache.jdo.tck.api.persistencemanager.flags.SettingFlagsWithTransactionInstance \
org.apache.jdo.tck.api.persistencemanager.getobject.GetObjectById \
org.apache.jdo.tck.api.persistencemanager.getobject.GetObjectByIdExactClass \
org.apache.jdo.tck.api.persistencemanager.getobject.GetObjectByIdNoValidationInstanceInCache \
org.apache.jdo.tck.api.persistencemanager.getobject.GetObjectByIdNoValidationInstanceInCacheNoStateChange \
org.apache.jdo.tck.api.persistencemanager.getobject.GetObjectByIdNoValidationInstanceNotInCache \
org.apache.jdo.tck.api.persistencemanager.getobject.GetObjectByIdNoValidationInstanceNotInCacheNoTx \
org.apache.jdo.tck.api.persistencemanager.getobject.GetObjectByIdNoValidationInstanceNotInDatastore \
org.apache.jdo.tck.api.persistencemanager.getobject.GetObjectByIdNotResolved \
org.apache.jdo.tck.api.persistencemanager.getobject.GetObjectByIdWithValidationInstanceInCache \
org.apache.jdo.tck.api.persistencemanager.getobject.GetObjectByIdWithValidationInstanceInCacheNotInDatastore \
org.apache.jdo.tck.api.persistencemanager.getobject.GetObjectByIdWithValidationInstanceNotInCacheNotInDatastore \
org.apache.jdo.tck.api.persistencemanager.getobject.GetObjectsById \
org.apache.jdo.tck.api.persistencemanager.getobject.GetObjectId \
org.apache.jdo.tck.api.persistencemanager.getobject.GetObjectIdClass \
org.apache.jdo.tck.api.persistencemanager.getobject.GetObjectIdClassForAbstractOrNonPersistenceCapableClass \
org.apache.jdo.tck.api.persistencemanager.getobject.GetObjectIdForNullOrNotPersistent \
org.apache.jdo.tck.api.persistencemanager.getobject.GetObjectIdWithApplicationModifyingIdentity \
org.apache.jdo.tck.api.persistencemanager.lifecycle.MakeNontransactionalAllFails \
org.apache.jdo.tck.api.persistencemanager.lifecycle.MakeNontransactionalDirtyInstance \
org.apache.jdo.tck.api.persistencemanager.lifecycle.MakeNontransactionalIsImmediate \
org.apache.jdo.tck.api.persistencemanager.lifecycle.MakeNontransactionalPersistentCleanInstance \
org.apache.jdo.tck.api.persistencemanager.lifecycle.MakeNontransactionalTransientCleanInstance \
org.apache.jdo.tck.api.persistencemanager.lifecycle.MakePersistent \
org.apache.jdo.tck.api.persistencemanager.lifecycle.MakePersistentAllFails \
org.apache.jdo.tck.api.persistencemanager.lifecycle.MakePersistentAndInstancesNotReachable \
org.apache.jdo.tck.api.persistencemanager.lifecycle.MakePersistentAssignsObjectId \
org.apache.jdo.tck.api.persistencemanager.lifecycle.MakePersistentFailsIfInstanceManagedByAnotherPersistenceManager \
org.apache.jdo.tck.api.persistencemanager.lifecycle.MakePersistentHasNoEffectOnPersistentInstances \
org.apache.jdo.tck.api.persistencemanager.lifecycle.MakeTransactional \
org.apache.jdo.tck.api.persistencemanager.lifecycle.MakeTransactionalANontransactionalPersistentInstance \
org.apache.jdo.tck.api.persistencemanager.lifecycle.MakeTransactionalAllFails \
org.apache.jdo.tck.api.persistencemanager.lifecycle.MakeTransactionalIsImmediate \
org.apache.jdo.tck.api.persistencemanager.lifecycle.MakeTransactionalPriorToTransactionRolledback \
org.apache.jdo.tck.api.persistencemanager.lifecycle.MakeTransactionalWithinTransactionRolledback \
org.apache.jdo.tck.api.persistencemanager.lifecycle.MakeTransient \
org.apache.jdo.tck.api.persistencemanager.lifecycle.MakeTransientAllFails \
org.apache.jdo.tck.api.persistencemanager.lifecycle.MakeTransientCausesLossOfIdentity \
org.apache.jdo.tck.api.persistencemanager.lifecycle.MakeTransientFailsWithDirtyInstance \
org.apache.jdo.tck.api.persistencemanager.lifecycle.MakeTransientFieldsPreservedUnchanged \
org.apache.jdo.tck.api.persistencemanager.lifecycle.MakeTransientHasNoEffectOnTransientInstances \
org.apache.jdo.tck.api.persistencemanager.lifecycle.MakeTransientNotSubjectToRollback \
org.apache.jdo.tck.api.persistencemanager.nullargs.MakePersistentNullArgs \
org.apache.jdo.tck.api.persistencemanager.nullargs.DeletePersistentNullArgs \
org.apache.jdo.tck.api.persistencemanager.nullargs.DetachCopyNullArgs \
org.apache.jdo.tck.api.persistencemanager.nullargs.MakeTransientNullArgs \
org.apache.jdo.tck.api.persistencemanager.nullargs.EvictNullArgs \
org.apache.jdo.tck.api.persistencemanager.nullargs.MakeNontransactionalNullArgs \
org.apache.jdo.tck.api.persistencemanager.nullargs.MakeTransactionalNullArgs \
org.apache.jdo.tck.api.persistencemanager.nullargs.RefreshNullArgs \
org.apache.jdo.tck.api.persistencemanager.nullargs.RetrieveNullArgs \
org.apache.jdo.tck.api.persistencemanager.nullargs.RetrieveWithFetchPlanNullArgs
tck/src/conf/pmf.conf 100664 7145 12500110374 15025 0 ustar mbouschen staff 0 0 # 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.
jdo.tck.description = All pmf tests with standard mapping, no testdata.
jdo.tck.mapping.companyfactory =
jdo.tck.testdata =
jdo.tck.standarddata =
jdo.tck.mapping = 0
jdo.tck.requiredOptions =
jdo.tck.classes = \
org.apache.jdo.tck.api.persistencemanagerfactory.AfterCloseGetPMThrowsException \
org.apache.jdo.tck.api.persistencemanagerfactory.AfterCloseSetMethodsThrowException \
org.apache.jdo.tck.api.persistencemanagerfactory.AfterGetPersistenceManagerNoSetMethodsSucceed \
org.apache.jdo.tck.api.persistencemanagerfactory.Close \
org.apache.jdo.tck.api.persistencemanagerfactory.CloseFailsIfTransactionActive \
org.apache.jdo.tck.api.persistencemanagerfactory.CloseWithoutPermissionThrowsSecurityException \
org.apache.jdo.tck.api.persistencemanagerfactory.FlushThrowsIfReadOnly \
org.apache.jdo.tck.api.persistencemanagerfactory.GetManagedClasses \
org.apache.jdo.tck.api.persistencemanagerfactory.GetPMFByFile \
org.apache.jdo.tck.api.persistencemanagerfactory.GetPMFByFileAndClassLoader \
org.apache.jdo.tck.api.persistencemanagerfactory.GetPMFByResource \
org.apache.jdo.tck.api.persistencemanagerfactory.GetPMFByResourceAndClassLoader \
org.apache.jdo.tck.api.persistencemanagerfactory.GetPMFByStream \
org.apache.jdo.tck.api.persistencemanagerfactory.GetPMFByStreamAndClassLoader \
org.apache.jdo.tck.api.persistencemanagerfactory.GetPMFByJNDILocation \
org.apache.jdo.tck.api.persistencemanagerfactory.GetPMFByJNDILocationAndClassLoader \
org.apache.jdo.tck.api.persistencemanagerfactory.GetPersistenceManager \
org.apache.jdo.tck.api.persistencemanagerfactory.GetPersistenceManagerFactoryByPropertiesInstance \
org.apache.jdo.tck.api.persistencemanagerfactory.GetPersistenceManagerForUser \
org.apache.jdo.tck.api.persistencemanagerfactory.GetProperties \
org.apache.jdo.tck.api.persistencemanagerfactory.SetConnectionPassword \
org.apache.jdo.tck.api.persistencemanagerfactory.SetConnectionURL \
org.apache.jdo.tck.api.persistencemanagerfactory.SetConnectionUserName \
org.apache.jdo.tck.api.persistencemanagerfactory.SetIgnoreCache \
org.apache.jdo.tck.api.persistencemanagerfactory.SetMultithreaded \
org.apache.jdo.tck.api.persistencemanagerfactory.SetNonTransactionalRead \
org.apache.jdo.tck.api.persistencemanagerfactory.SetNonTransactionalWrite \
org.apache.jdo.tck.api.persistencemanagerfactory.SetOptimistic \
org.apache.jdo.tck.api.persistencemanagerfactory.SetReadOnly \
org.apache.jdo.tck.api.persistencemanagerfactory.SetRetainValues \
org.apache.jdo.tck.api.persistencemanagerfactory.SetTransactionIsolationLevel \
org.apache.jdo.tck.api.persistencemanagerfactory.SupportedOptions \
org.apache.jdo.tck.api.persistencemanagerfactory.config.Jdoconfig \
org.apache.jdo.tck.api.persistencemanagerfactory.config.Persistence \
org.apache.jdo.tck.api.persistencemanagerfactory.config.JDOConfigListener \
org.apache.jdo.tck.api.persistencemanagerfactory.metadata.GetMetadataTest
tck/src/conf/query.conf 100664 11003 12500110374 15414 0 ustar mbouschen staff 0 0 # 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.
jdo.tck.description = All query tests with standard mapping, no testdata.
jdo.tck.mapping.companyfactory =
jdo.tck.testdata =
jdo.tck.standarddata =
jdo.tck.mapping = 0
jdo.tck.requiredOptions =
jdo.tck.classes = \
org.apache.jdo.tck.query.api.ChangeQuery \
org.apache.jdo.tck.query.api.Close \
org.apache.jdo.tck.query.api.CloseAll \
org.apache.jdo.tck.query.api.CompileQuery \
org.apache.jdo.tck.query.api.DeclareImports \
org.apache.jdo.tck.query.api.DeclareParameters \
org.apache.jdo.tck.query.api.DeclareVariables \
org.apache.jdo.tck.query.api.ExecuteQuery \
org.apache.jdo.tck.query.api.ExecuteQueryWithArray \
org.apache.jdo.tck.query.api.ExecuteQueryWithMap \
org.apache.jdo.tck.query.api.GetFetchPlan \
org.apache.jdo.tck.query.api.GetIgnoreCache \
org.apache.jdo.tck.query.api.GetPersistenceManager \
org.apache.jdo.tck.query.api.GetPersistenceManagerFromRestoredSerializedQuery \
org.apache.jdo.tck.query.api.InvalidNamedQuery \
org.apache.jdo.tck.query.api.MetadataSearchOrder \
org.apache.jdo.tck.query.api.NamedQueryNotFound \
org.apache.jdo.tck.query.api.NewNamedQuery \
org.apache.jdo.tck.query.api.NewQueryFromExistingQueryBoundToPMFromSameVendor \
org.apache.jdo.tck.query.api.NewQueryFromRestoredSerializedQuery \
org.apache.jdo.tck.query.api.NewQueryWithCandidateClass \
org.apache.jdo.tck.query.api.NewQueryWithCandidateClassAndCollection \
org.apache.jdo.tck.query.api.NewQueryWithCandidateClassAndExtent \
org.apache.jdo.tck.query.api.NewQueryWithCandidateClassAndFilter \
org.apache.jdo.tck.query.api.NewQueryWithCandidateClassCollectionFilter \
org.apache.jdo.tck.query.api.NewQueryWithExtent \
org.apache.jdo.tck.query.api.NewQueryWithExtentAndFilter \
org.apache.jdo.tck.query.api.NewQueryWithSpecifiedLanguageAndQuery \
org.apache.jdo.tck.query.api.NewQuerySingleString \
org.apache.jdo.tck.query.api.QueryExtentions \
org.apache.jdo.tck.query.api.SetCandidateCollection \
org.apache.jdo.tck.query.api.SetCandidateExtent \
org.apache.jdo.tck.query.api.SetFilter \
org.apache.jdo.tck.query.api.SetGrouping \
org.apache.jdo.tck.query.api.SetIgnoreCache \
org.apache.jdo.tck.query.api.SetOrdering \
org.apache.jdo.tck.query.api.SetRange \
org.apache.jdo.tck.query.api.SetResult \
org.apache.jdo.tck.query.api.SetResultClass \
org.apache.jdo.tck.query.api.SetUnique \
org.apache.jdo.tck.query.api.SetterReplacePreviousValues \
org.apache.jdo.tck.query.api.SingleStringQuery \
org.apache.jdo.tck.query.api.UnmodifiableQuery \
org.apache.jdo.tck.query.delete.DeleteCallback \
org.apache.jdo.tck.query.delete.DeletePersistentAll \
org.apache.jdo.tck.query.delete.DeleteQueryElements \
org.apache.jdo.tck.query.result.AggregateResult \
org.apache.jdo.tck.query.result.DefaultResult \
org.apache.jdo.tck.query.result.DefaultUnique \
org.apache.jdo.tck.query.result.DistinctCandidateInstances \
org.apache.jdo.tck.query.result.DistinctQuery \
org.apache.jdo.tck.query.result.Grouping \
org.apache.jdo.tck.query.result.IfElseResult \
org.apache.jdo.tck.query.result.ImmutableQueryResult \
org.apache.jdo.tck.query.result.MethodsInResult \
org.apache.jdo.tck.query.result.NPEInResultExpr \
org.apache.jdo.tck.query.result.NullResults \
org.apache.jdo.tck.query.result.ProjectedSCODoesNotTrackChanges \
org.apache.jdo.tck.query.result.ResultClassRequirements \
org.apache.jdo.tck.query.result.ResultExpressions \
org.apache.jdo.tck.query.result.ShapeOfResult \
org.apache.jdo.tck.query.result.Unique \
org.apache.jdo.tck.query.result.VariableInResult \
org.apache.jdo.tck.query.result.VariableInResultNavigation \
org.apache.jdo.tck.query.result.VariableInResultMultipleNavigation \
org.apache.jdo.tck.query.sql.ShapeOfResult \
org.apache.jdo.tck.query.sql.NoCandidateClass \
org.apache.jdo.tck.query.sql.AllowedAPIMethods \
org.apache.jdo.tck.query.sql.NewQuery \
org.apache.jdo.tck.query.sql.ExecuteWithMap
tck/src/conf/relationshipAllRelationships.conf 100664 2471 12500110374 22137 0 ustar mbouschen staff 0 0 # 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.
jdo.tck.description = Managed relationship tests with standard mapping, \
basic testdata with all relationships.
jdo.tck.mapping.companyfactory =
jdo.tck.testdata = org/apache/jdo/tck/pc/company/companyAllRelationships.xml
jdo.tck.mapping = 0
jdo.tck.requiredOptions =
jdo.tck.classes = org.apache.jdo.tck.mapping.Relationship1To1AllRelationships \
org.apache.jdo.tck.mapping.Relationship1ToManyAllRelationships \
org.apache.jdo.tck.mapping.RelationshipManyToManyAllRelationships \
org.apache.jdo.tck.mapping.RelationshipNegative1To1Test
tck/src/conf/relationshipNoRelationships.conf 100664 2466 12500110374 22007 0 ustar mbouschen staff 0 0 # 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.
jdo.tck.description = Managed relationship tests with standard mapping, \
basic testdata with no relationships.
jdo.tck.mapping.companyfactory =
jdo.tck.testdata = org/apache/jdo/tck/pc/company/companyNoRelationships.xml
jdo.tck.mapping = 0
jdo.tck.requiredOptions =
jdo.tck.classes = org.apache.jdo.tck.mapping.Relationship1To1NoRelationships \
org.apache.jdo.tck.mapping.Relationship1ToManyNoRelationships \
org.apache.jdo.tck.mapping.RelationshipManyToManyNoRelationships \
org.apache.jdo.tck.mapping.RelationshipNegative1ToManyTest
tck/src/conf/runonce.conf 100664 2172 12500110374 15707 0 ustar mbouschen staff 0 0 # 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.
jdo.tck.description = Verification of the JDO API classes and interfaces
jdo.tck.testdata =
jdo.tck.standarddata =
jdo.tck.mapping = 0
jdo.tck.requiredOptions =
# The runOnce flag must only be set in this configuration and no others
runOnce = true
jdo.tck.classes = \
org.apache.jdo.tck.api.SignatureTest \
org.apache.jdo.tck.api.exceptions.ExceptionConstructor
tck/src/conf/schemaAttributeClass.conf 100664 2352 12500110374 20350 0 ustar mbouschen staff 0 0 # 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.
jdo.tck.description = MakePersistent test with schema name specified as class attribute in orm for PCPoint. The schema name derived from jdo.tck.mapping 7, applicationidentity7 or datastoreidentity7, is overriden in the orm to specify schema applicationidentity_cls or datastoreidentity_cls.
jdo.tck.mapping.companyfactory =
jdo.tck.classes = org.apache.jdo.tck.api.persistencemanager.lifecycle.MakePersistent
jdo.tck.testdata =
jdo.tck.mapping = 7
jdo.tck.requiredOptions =
tck/src/conf/schemaAttributeOrm.conf 100664 2350 12500110374 20036 0 ustar mbouschen staff 0 0 # 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.
jdo.tck.description = MakePersistent test with schema name specified as orm attribute in orm for PCPoint. The schema name derived from jdo.tck.mapping 5, applicationidentity5 or datastoreidentity5, is overriden in the orm to specify schema applicationidentity_orm or datastoreidentity_orm.
jdo.tck.mapping.companyfactory =
jdo.tck.classes = org.apache.jdo.tck.api.persistencemanager.lifecycle.MakePersistent
jdo.tck.testdata =
jdo.tck.mapping = 5
jdo.tck.requiredOptions =
tck/src/conf/schemaAttributePackage.conf 100664 2354 12500110374 20640 0 ustar mbouschen staff 0 0 # 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.
jdo.tck.description = MakePersistent test with schema name specified as package attribute in orm for PCPoint. The schema name derived from jdo.tck.mapping 6, applicationidentity6 or datastoreidentity6, is overriden in the orm to specify schema applicationidentity_pkg or datastoreidentity_pkg.
jdo.tck.mapping.companyfactory =
jdo.tck.classes = org.apache.jdo.tck.api.persistencemanager.lifecycle.MakePersistent
jdo.tck.testdata =
jdo.tck.mapping = 6
jdo.tck.requiredOptions =
tck/src/conf/security.conf 100664 4765 12500110374 16117 0 ustar mbouschen staff 0 0 # 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.
jdo.tck.security = true
jdo.tck.description = All pmf tests with standard mapping, no testdata.
jdo.tck.mapping.companyfactory =
jdo.tck.testdata =
jdo.tck.standarddata =
jdo.tck.mapping = 0
jdo.tck.requiredOptions =
jdo.tck.classes = \
org.apache.jdo.tck.api.persistencemanagerfactory.AfterCloseGetPMThrowsException \
org.apache.jdo.tck.api.persistencemanagerfactory.AfterCloseSetMethodsThrowException \
org.apache.jdo.tck.api.persistencemanagerfactory.AfterGetPersistenceManagerNoSetMethodsSucceed \
org.apache.jdo.tck.api.persistencemanagerfactory.Close \
org.apache.jdo.tck.api.persistencemanagerfactory.CloseFailsIfTransactionActive \
org.apache.jdo.tck.api.persistencemanagerfactory.CloseWithoutPermissionThrowsSecurityException \
org.apache.jdo.tck.api.persistencemanagerfactory.GetPMFByFile \
org.apache.jdo.tck.api.persistencemanagerfactory.GetPMFByFileAndClassLoader \
org.apache.jdo.tck.api.persistencemanagerfactory.GetPMFByResource \
org.apache.jdo.tck.api.persistencemanagerfactory.GetPMFByResourceAndClassLoader \
org.apache.jdo.tck.api.persistencemanagerfactory.GetPMFByStream \
org.apache.jdo.tck.api.persistencemanagerfactory.GetPMFByStreamAndClassLoader \
org.apache.jdo.tck.api.persistencemanagerfactory.GetPMFByJNDILocation \
org.apache.jdo.tck.api.persistencemanagerfactory.GetPMFByJNDILocationAndClassLoader \
org.apache.jdo.tck.api.persistencemanagerfactory.GetPersistenceManager \
org.apache.jdo.tck.api.persistencemanagerfactory.GetPersistenceManagerForUser \
org.apache.jdo.tck.api.persistencemanagerfactory.GetProperties \
org.apache.jdo.tck.api.persistencemanagerfactory.config.Jdoconfig \
org.apache.jdo.tck.api.persistencemanagerfactory.config.Persistence \
org.apache.jdo.tck.api.persistencemanagerfactory.config.JDOConfigListener
tck/src/conf/security.policy 100664 10551 12500110374 16477 0 ustar mbouschen staff 0 0 // 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.
// JUnit code base
grant codeBase "file:/D:/users\\michael\\.maven/repository/junit/jars/junit-3.8.1.jar" {
permission java.io.FilePermission "${user.home}${/}junit.properties", "read";
};
// Springbeans code base
grant codeBase "file:/D:/users\\michael\\.maven/repository/org.springframework/jars/spring-beans-2.0.jar" {
permission java.lang.RuntimePermission "accessDeclaredMembers";
permission java.lang.reflect.ReflectPermission "suppressAccessChecks";
permission java.lang.RuntimePermission "getClassLoader";
};
// Springcore code base
grant codeBase "file:/D:/users\\michael\\.maven/repository/org.springframework/jars/spring-core-2.0.jar" {
permission java.lang.RuntimePermission "accessDeclaredMembers";
};
// TCK test classes
grant codeBase "file:/D:/projects/jdo/workspace/jdo/trunk/tck2/target/classes/-" {
permission javax.jdo.spi.JDOPermission "closePersistenceManagerFactory";
permission javax.jdo.spi.JDOPermission "setStateManager";
// needed for Springbeans
permission java.lang.RuntimePermission "accessDeclaredMembers";
permission java.lang.reflect.ReflectPermission "suppressAccessChecks";
permission java.lang.RuntimePermission "getClassLoader";
};
// TCK PC enhanced classes
grant codebase "file:/D:/projects/jdo/workspace/jdo/trunk/tck2/target/enhanced/-" {
permission javax.jdo.spi.JDOPermission "setStateManager";
};
// JDO API code base
grant codeBase "file:/D:/users\\michael\\.maven/repository/javax.jdo/jars/jdo2-api-2.2-SNAPSHOT.jar" {
permission javax.jdo.spi.JDOPermission "getMetadata";
permission javax.jdo.spi.JDOPermission "setStateManager";
};
// JDO RI code base
grant codeBase "file:/D:/users\\michael\\.maven/repository/org.datanucleus/jars/datanucleus-core-1.0-SNAPSHOT.jar" {
permission javax.jdo.spi.JDOPermission "closePersistenceManagerFactory";
permission javax.jdo.spi.JDOPermission "getMetadata";
permission javax.jdo.spi.JDOPermission "setStateManager";
permission java.lang.RuntimePermission "accessDeclaredMembers";
permission java.lang.reflect.ReflectPermission "suppressAccessChecks";
permission java.lang.RuntimePermission "getClassLoader";
permission java.lang.RuntimePermission "accessClassInPackage.sun.reflect";
};
// JDO RI enhancer base
grant codeBase "file:/D:/users\\michael\\.maven/repository/org.datanucleus/jars/datanucleus-enhancer-1.0-SNAPSHOT.jar" {
permission java.lang.RuntimePermission "accessDeclaredMembers";
permission java.lang.RuntimePermission "accessClassInPackage.sun.reflect";
};
// JDO RI store.rdbms code base
grant codeBase "file:/D:/users\\michael\\.maven/repository/org.datanucleus/jars/datanucleus-rdbms-1.0-SNAPSHOT.jar" {
permission java.lang.RuntimePermission "accessDeclaredMembers";
permission java.lang.reflect.ReflectPermission "suppressAccessChecks";
permission java.lang.RuntimePermission "getClassLoader";
};
// All classes in the classpath
grant {
// c3p0 seems to require PropertyPermission of write (don't know why)
permission java.util.PropertyPermission "*", "read, write";
permission java.io.FilePermission "${user.home}${/}.maven/repository${/}-", "read";
permission java.io.FilePermission "${jdo.tck.basedir}${/}target${/}-", "read, write";
// bug in security? needed for Derby to create tck2/target/database/derby/../../logs
permission java.io.FilePermission "${jdo.tck.basedir}${/}-", "read, write, delete";
// needed for JNDI FSContext
permission java.io.FilePermission "${/}", "read";
permission java.lang.RuntimePermission "createClassLoader";
permission java.io.FilePermission "${user.dir}${/}-", "read";
};
tck/src/conf/simplelog.properties 100664 3226 12500110374 17501 0 ustar mbouschen staff 0 0 #
# 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.
#
# This is a sample properties file to configure apache commons logging SimpleLog
# implementation for the JDO TCK test cases. Below you find an entry for each of
# the JDO TCK logger instances. Please uncomment the line and adapt the log
# level to your needs, in case to want to enable a particular logger.
#
######################
# Loggers
######################
# Root logger
org.apache.commons.logging.simplelog.defaultlog = error
# TCK logger
org.apache.commons.logging.simplelog.log.org.apache.jdo.tck = info
# SpringFramework loggers
org.apache.commons.logging.simplelog.log.org.springframework = error
org.apache.commons.logging.simplelog.log.org.apache.jdo.tck.pc.company.CompanyModelReader = error
org.apache.commons.logging.simplelog.log.org.apache.jdo.tck.pc.mylib.MylibReader = error
# JDO vendor specific loggers
#org.apache.commons.logging.simplelog.log. = info
tck/src/conf/throwOnUnknownStandardProperties.conf 100664 2114 12500110374 23010 0 ustar mbouschen staff 0 0 # 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.
jdo.tck.description = Checks that the implementation throws JDOUserException on unknown JDO standard properties.
jdo.tck.mapping.companyfactory =
jdo.tck.classes = org.apache.jdo.tck.api.persistencemanagerfactory.config.ThrowOnUnknownStandardProperties
jdo.tck.testdata =
jdo.tck.mapping =
jdo.tck.requiredOptions =
tck/src/conf/transactions.conf 100664 5325 12500110374 16751 0 ustar mbouschen staff 0 0 # 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.
jdo.tck.description = All transaction tests with standard mapping, no testdata.
jdo.tck.mapping.companyfactory =
jdo.tck.testdata =
jdo.tck.standarddata =
jdo.tck.mapping = 0
jdo.tck.requiredOptions =
jdo.tck.classes = \
org.apache.jdo.tck.transactions.AfterCompletionMethodCalledWhenCommitted \
org.apache.jdo.tck.transactions.AfterCompletionMethodCalledWhenRolledback \
org.apache.jdo.tck.transactions.AfterSetRollbackOnlyCommitFails \
org.apache.jdo.tck.transactions.BeforeCompletionMethodCalled \
org.apache.jdo.tck.transactions.BeforeCompletionMethodNotCalledBeforeRollback \
org.apache.jdo.tck.transactions.Commit \
org.apache.jdo.tck.transactions.GetPersistenceManager \
org.apache.jdo.tck.transactions.GetRetainValues \
org.apache.jdo.tck.transactions.GetRollbackOnlyReturnsFalseUntilSet \
org.apache.jdo.tck.transactions.GetSynchronization \
org.apache.jdo.tck.transactions.IsActive \
org.apache.jdo.tck.transactions.IsActiveUntilAfterCompletionMethodCalled \
org.apache.jdo.tck.transactions.Rollback \
org.apache.jdo.tck.transactions.SetIsolationLevel \
org.apache.jdo.tck.transactions.SetNontransactionalRead \
org.apache.jdo.tck.transactions.WhenNontransactionalReadIsFalse \
org.apache.jdo.tck.transactions.SetNontransactionalReadCalledDuringTxCompletion \
org.apache.jdo.tck.transactions.SetNontransactionalWriteCalledDuringTxCompletion \
org.apache.jdo.tck.transactions.SetNontransactionalReadTrueWhenNotSupported \
org.apache.jdo.tck.transactions.SetOptimistic \
org.apache.jdo.tck.transactions.SetOptimisticCalledDuringTxCompletion \
org.apache.jdo.tck.transactions.SetOptimisticDuringTransaction \
org.apache.jdo.tck.transactions.SetOptimisticTrueWhenNotSupported \
org.apache.jdo.tck.transactions.SetRetainValues \
org.apache.jdo.tck.transactions.SetRetainValuesCalledDuringTxCompletion \
org.apache.jdo.tck.transactions.SetRetainValuesTrueWhenNotSupported \
org.apache.jdo.tck.transactions.SetSynchronization \
org.apache.jdo.tck.transactions.SetSynchronizationToNull
tck/src/java/org/apache/jdo/tck/AbstractReaderTest.java 100664 5034 12500110373 23320 0 ustar mbouschen staff 0 0 /*
* 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.security.AccessController;
import java.security.PrivilegedAction;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.springframework.beans.factory.xml.XmlBeanFactory;
/*
* Abstract class for managed relationship tests
*/
public class AbstractReaderTest extends JDO_Test {
/** The list of all objects in the bean collection. */
protected List rootOids;
/** The name of the root object in the bean collection. */
protected static final String rootName = "root";
/** The name of the file containing the bean collection (test data). */
protected final String inputFilename = System.getProperty("jdo.tck.testdata");
/** The map of String (bean name) to Object (bean). */
protected Map oidMap = new HashMap();
/** Get the named bean from the bean factory.
*
* @param reader the xml bean reader
* @param name the name of the bean
* @return the named object
*/
protected Object getBean(final XmlBeanFactory reader, final String name) {
return AccessController.doPrivileged(
new PrivilegedAction() {
public Object run() {
return reader.getBean(name);
}
}
);
}
/** Get the root object from the bean factory.
*
* @param reader the xml bean reader
* @return the List of objects
*/
protected List getRootList(XmlBeanFactory reader) {
return (List) getBean(reader, rootName);
}
/** Get the named object from the Map of objects.
*
* @param name the bean name
* @return the named object
*/
protected Object getOidByName(String name) {
return oidMap.get((Object)name);
}
}
tck/src/java/org/apache/jdo/tck/api/exceptions/ExceptionConstructor.java 100664 34014 12500110374 26751 0 ustar mbouschen staff 0 0 /*
* 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.api.exceptions;
import java.lang.reflect.Constructor;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Exception Constructor
*Keywords: exception
*Assertion ID:
*Assertion Description:
*/
public class ExceptionConstructor extends JDO_Test {
protected static final Class[] classArrayEmpty =
new Class[] {};
protected static final Class[] classArrayString =
new Class[] {String.class};
protected static final Class[] classArrayStringObject =
new Class[] {String.class, Object.class};
protected static final Class[] classArrayStringThrowable =
new Class[] {String.class, Throwable.class};
protected static final Class[] classArrayStringThrowableArray =
new Class[] {String.class, Throwable[].class};
protected static final Class[] classArrayStringThrowableObject =
new Class[] {String.class, Throwable.class, Object.class};
protected static final Class[] classArrayStringThrowableArrayObject =
new Class[] {String.class, Throwable[].class, Object.class};
protected static final String message = "Message";
protected static final Object object = "Failed Object";
protected static final Throwable throwable = new Throwable("Throwable");
protected static final Object[] objectArrayEmpty =
new Object[]{};
protected static final Object[] objectArrayString =
new Object[]{message};
protected static final Object[] objectArrayStringObject =
new Object[]{message, object};
protected static final Object[] objectArrayStringThrowableArray =
new Object[] {message, new Throwable[] {throwable}};
protected static final Object[] objectArrayStringThrowable =
new Object[] {message, throwable};
protected static final Object[] objectArrayStringThrowableArrayObject =
new Object[] {message, new Throwable[] {throwable}, object};
protected static final Object[] objectArrayStringThrowableObject =
new Object[] {message, throwable, object};
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(ExceptionConstructor.class);
}
/* test all constructors
*
*/
public void testConstructors() {
constructJDOCanRetryException();
constructJDODataStoreException();
constructJDODetachedFieldAccessException();
constructJDOException();
constructJDOFatalDataStoreException();
constructJDOFatalException();
constructJDOFatalInternalException();
constructJDOFatalUserException();
constructJDONullIdentityException();
constructJDOObjectNotFoundException();
constructJDOOptimisticVerificationException();
constructJDOUnsupportedOptionException();
constructJDOUserCallbackException();
failOnError();
}
protected void constructJDOCanRetryException() {
constructEmpty(javax.jdo.JDOCanRetryException.class);
constructString(javax.jdo.JDOCanRetryException.class);
constructStringThrowableArray(javax.jdo.JDOCanRetryException.class);
constructStringThrowable(javax.jdo.JDOCanRetryException.class);
constructStringObject(javax.jdo.JDOCanRetryException.class);
constructStringThrowableArrayObject(javax.jdo.JDOCanRetryException.class);
constructStringThrowableObject(javax.jdo.JDOCanRetryException.class);
}
protected void constructJDODataStoreException() {
constructEmpty(javax.jdo.JDODataStoreException.class);
constructString(javax.jdo.JDODataStoreException.class);
constructStringThrowableArray(javax.jdo.JDODataStoreException.class);
constructStringThrowable(javax.jdo.JDODataStoreException.class);
constructStringObject(javax.jdo.JDODataStoreException.class);
constructStringThrowableArrayObject(javax.jdo.JDODataStoreException.class);
constructStringThrowableObject(javax.jdo.JDODataStoreException.class);
}
protected void constructJDODetachedFieldAccessException() {
constructEmpty(javax.jdo.JDODetachedFieldAccessException.class);
constructString(javax.jdo.JDODetachedFieldAccessException.class);
constructStringThrowableArray(javax.jdo.JDODetachedFieldAccessException.class);
constructStringThrowable(javax.jdo.JDODetachedFieldAccessException.class);
constructStringObject(javax.jdo.JDODetachedFieldAccessException.class);
}
protected void constructJDOException() {
constructEmpty(javax.jdo.JDOException.class);
constructString(javax.jdo.JDOException.class);
constructStringThrowableArray(javax.jdo.JDOException.class);
constructStringThrowable(javax.jdo.JDOException.class);
constructStringObject(javax.jdo.JDOException.class);
constructStringThrowableArrayObject(javax.jdo.JDOException.class);
constructStringThrowableObject(javax.jdo.JDOException.class);
}
protected void constructJDOFatalDataStoreException() {
constructEmpty(javax.jdo.JDOFatalDataStoreException.class);
constructString(javax.jdo.JDOFatalDataStoreException.class);
constructStringThrowableArray(javax.jdo.JDOFatalDataStoreException.class);
constructStringThrowable(javax.jdo.JDOFatalDataStoreException.class);
constructStringObject(javax.jdo.JDOFatalDataStoreException.class);
}
protected void constructJDOFatalException() {
constructEmpty(javax.jdo.JDOFatalException.class);
constructString(javax.jdo.JDOFatalException.class);
constructStringThrowableArray(javax.jdo.JDOFatalException.class);
constructStringThrowable(javax.jdo.JDOFatalException.class);
constructStringObject(javax.jdo.JDOFatalException.class);
constructStringThrowableArrayObject(javax.jdo.JDOFatalException.class);
constructStringThrowableObject(javax.jdo.JDOFatalException.class);
}
protected void constructJDOFatalInternalException() {
constructEmpty(javax.jdo.JDOFatalInternalException.class);
constructString(javax.jdo.JDOFatalInternalException.class);
constructStringThrowableArray(javax.jdo.JDOFatalInternalException.class);
constructStringThrowable(javax.jdo.JDOFatalInternalException.class);
constructStringObject(javax.jdo.JDOFatalInternalException.class);
constructStringThrowableArrayObject(javax.jdo.JDOFatalInternalException.class);
constructStringThrowableObject(javax.jdo.JDOFatalInternalException.class);
}
protected void constructJDOFatalUserException() {
constructEmpty(javax.jdo.JDOFatalUserException.class);
constructString(javax.jdo.JDOFatalUserException.class);
constructStringThrowableArray(javax.jdo.JDOFatalUserException.class);
constructStringThrowable(javax.jdo.JDOFatalUserException.class);
constructStringObject(javax.jdo.JDOFatalUserException.class);
constructStringThrowableArrayObject(javax.jdo.JDOFatalUserException.class);
constructStringThrowableObject(javax.jdo.JDOFatalUserException.class);
}
protected void constructJDONullIdentityException() {
constructEmpty(javax.jdo.JDONullIdentityException.class);
constructString(javax.jdo.JDONullIdentityException.class);
constructStringThrowableArray(javax.jdo.JDONullIdentityException.class);
constructStringThrowable(javax.jdo.JDONullIdentityException.class);
constructStringObject(javax.jdo.JDONullIdentityException.class);
}
protected void constructJDOObjectNotFoundException() {
constructEmpty(javax.jdo.JDOObjectNotFoundException.class);
constructString(javax.jdo.JDOObjectNotFoundException.class);
constructStringThrowableArray(javax.jdo.JDOObjectNotFoundException.class);
constructStringObject(javax.jdo.JDOObjectNotFoundException.class);
constructStringThrowableArrayObject(javax.jdo.JDOObjectNotFoundException.class);
constructStringThrowableObject(javax.jdo.JDOObjectNotFoundException.class);
}
protected void constructJDOOptimisticVerificationException() {
constructEmpty(javax.jdo.JDOOptimisticVerificationException.class);
constructString(javax.jdo.JDOOptimisticVerificationException.class);
constructStringThrowableArray(javax.jdo.JDOOptimisticVerificationException.class);
constructStringObject(javax.jdo.JDOOptimisticVerificationException.class);
constructStringThrowableArrayObject(javax.jdo.JDOOptimisticVerificationException.class);
constructStringThrowableObject(javax.jdo.JDOOptimisticVerificationException.class);
}
protected void constructJDOUnsupportedOptionException() {
constructEmpty(javax.jdo.JDOUnsupportedOptionException.class);
constructString(javax.jdo.JDOUnsupportedOptionException.class);
constructStringThrowableArray(javax.jdo.JDOUnsupportedOptionException.class);
constructStringThrowable(javax.jdo.JDOUnsupportedOptionException.class);
}
protected void constructJDOUserCallbackException() {
constructEmpty(javax.jdo.JDOUserCallbackException.class);
constructString(javax.jdo.JDOUserCallbackException.class);
constructStringThrowableArray(javax.jdo.JDOUserCallbackException.class);
constructStringThrowable(javax.jdo.JDOUserCallbackException.class);
constructStringObject(javax.jdo.JDOUserCallbackException.class);
constructStringThrowableArrayObject(javax.jdo.JDOUserCallbackException.class);
constructStringThrowableObject(javax.jdo.JDOUserCallbackException.class);
}
protected void constructEmpty(Class clazz) {
construct(clazz, classArrayEmpty, objectArrayEmpty,
null, null, null);
}
protected void constructString(Class clazz) {
construct(clazz, classArrayString, objectArrayString,
message, null, null);
}
protected void constructStringObject(Class clazz) {
construct(clazz, classArrayStringObject, objectArrayStringObject,
message, object, null);
}
protected void constructStringThrowableArray(Class clazz) {
construct(clazz, classArrayStringThrowableArray, objectArrayStringThrowableArray,
message, null, throwable);
}
protected void constructStringThrowable(Class clazz) {
construct(clazz, classArrayStringThrowable, objectArrayStringThrowable,
message, null, throwable);
}
protected void constructStringThrowableArrayObject(Class clazz) {
construct(clazz, classArrayStringThrowableArrayObject, objectArrayStringThrowableArrayObject,
message, object, throwable);
}
protected void constructStringThrowableObject(Class clazz) {
construct(clazz, classArrayStringThrowableObject, objectArrayStringThrowableObject,
message, object, throwable);
}
protected void construct(Class clazz, Class[] formal, Object[] params,
String expectedMessage, Object expectedObject, Throwable expectedCause) {
Constructor ctor = null;
try {
ctor = clazz.getConstructor(formal);
} catch (Throwable ex) {
appendMessage ("Throwable caught during getConstructor. " + ex);
return;
}
try {
throw (Throwable)ctor.newInstance(params);
} catch (javax.jdo.JDOException ex) {
// good catch
if (clazz.isInstance(ex)) {
Object actualObject = ex.getFailedObject();
if (expectedObject != null && !expectedObject.equals(actualObject)) {
appendMessage("Wrong failed object for exception of " +
clazz +
"; Expected: " + expectedObject +
" Actual: " + actualObject);
}
String actualMessage = ex.getMessage();
if (expectedMessage != null && !expectedMessage.equals(actualMessage)) {
appendMessage("Wrong message for exception of " +
clazz +
"; Expected: " + expectedMessage +
" Actual: " + actualMessage);
}
Throwable actualCause = ex.getCause();
if (expectedCause != null && !expectedCause.equals(actualCause)) {
appendMessage("Wrong cause for exception of " +
clazz +
"; Expected: " + expectedCause +
" Actual: " + actualCause);
}
return;
} else {
appendMessage ("Wrong Throwable type caught for " +
clazz +
"; Expected:" + clazz +
" Actual: " + ex.getClass());
}
} catch (Throwable t) {
appendMessage ("Wrong Throwable type caught for " +
clazz +
"; Expected:" + clazz +
" Actual: " + t.getClass());
}
}
}
tck/src/java/org/apache/jdo/tck/api/fetchgroup/FetchGroupTest.java 100664 56464 12500110374 25455 0 ustar mbouschen staff 0 0 /*
* 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.api.fetchgroup;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import javax.jdo.FetchGroup;
import javax.jdo.JDOException;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.company.Address;
import org.apache.jdo.tck.pc.company.Company;
import org.apache.jdo.tck.pc.company.DentalInsurance;
import org.apache.jdo.tck.pc.company.Department;
import org.apache.jdo.tck.pc.company.Employee;
import org.apache.jdo.tck.pc.company.FullTimeEmployee;
import org.apache.jdo.tck.pc.company.IEmployee;
import org.apache.jdo.tck.pc.company.Insurance;
import org.apache.jdo.tck.pc.company.MedicalInsurance;
import org.apache.jdo.tck.pc.company.PIEmployee;
import org.apache.jdo.tck.pc.company.PartTimeEmployee;
import org.apache.jdo.tck.pc.company.Person;
import org.apache.jdo.tck.pc.company.Project;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
* This class is an abstract superclass for the fetch plan tests.
* It contains methods useful for testing the behavior of the
* fetch plan.
*/
public class FetchGroupTest extends JDO_Test {
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(FetchGroupTest.class);
}
/** All fetch groups in this PMF. */
protected Set allPMFFetchGroups;
/** All fetch groups in this PMF. */
/**
* Employee.java:
private Date hiredate;
private double weeklyhours;
private DentalInsurance dentalInsurance;
private MedicalInsurance medicalInsurance;
private Department department;
private Department fundingDept;
private Employee manager;
private Employee mentor;
private Employee protege;
private Employee hradvisor;
private transient Set reviewedProjects = new HashSet(); // element-type is Project
private transient Set projects = new HashSet(); // element-type is Project
private transient Set team = new HashSet(); // element-type is Employee
private transient Set hradvisees = new HashSet(); // element-type is Employee
* Person.java:
private long personid;
private String firstname;
private String lastname;
private String middlename;
private Date birthdate;
private Address address;
private Map phoneNumbers = new HashMap();
*/
protected String[] basicMembers = new String[]{"hiredate", "weeklyhours",
"personid", "firstname", "lastname", "middlename", "birthdate"};
/** In org/apache/jdo/tck/pc/package.jdo, middlename is not in DFG */
protected String[] defaultMembers = new String[]{"hiredate", "weeklyhours",
"personid", "firstname", "lastname","birthdate"};
protected String[] allMembers = new String[]{"hiredate", "weeklyhours",
"dentalInsurance", "medicalInsurance", "department", "fundingDept",
"manager", "mentor", "protege", "hradvisor",
"reviewedProjects", "projects", "team", "hradvisees",
"personid", "firstname", "lastname", "middlename", "birthdate",
"address", "phoneNumbers"};
/** Address address is of type Address and is a relationship */
protected String[] relationshipMembers = new String[]{
"dentalInsurance", "medicalInsurance", "department", "fundingDept",
"manager", "mentor", "protege", "hradvisor",
"reviewedProjects", "projects", "team", "hradvisees", "address"};
/** Map phoneNumbers is not a relationship but is multivalued */
protected String[] multivaluedMembers = new String[]{
"reviewedProjects", "projects", "team", "hradvisees", "phoneNumbers"};
protected String[] allButMultivaluedMembers = new String[]
{"hiredate", "weeklyhours",
"dentalInsurance", "medicalInsurance", "department", "fundingDept",
"manager", "mentor", "protege", "hradvisor",
"personid", "firstname", "lastname", "middlename", "birthdate",
"address"};
/**
* SetUp for test.
*/
public void localSetUp() {
getPM(); // initialize pmf and pm fields
}
public void testPMFGetFetchGroup() {
allPMFFetchGroups = pmf.getFetchGroups();
Map unscopedFetchGroupMap = new HashMap();
unscopedFetchGroupMap.put("Address+default",
pmf.getFetchGroup(Address.class, "default"));
unscopedFetchGroupMap.put("Company+default",
pmf.getFetchGroup(Company.class, "default"));
unscopedFetchGroupMap.put("DentalInsurance+default",
pmf.getFetchGroup(DentalInsurance.class, "default"));
unscopedFetchGroupMap.put("Department+default",
pmf.getFetchGroup(Department.class, "default"));
unscopedFetchGroupMap.put("Employee+default",
pmf.getFetchGroup(Employee.class, "default"));
unscopedFetchGroupMap.put("FullTimeEmployee+default",
pmf.getFetchGroup(FullTimeEmployee.class, "default"));
unscopedFetchGroupMap.put("Insurance+default",
pmf.getFetchGroup(Insurance.class, "default"));
unscopedFetchGroupMap.put("MedicalInsurance+default",
pmf.getFetchGroup(MedicalInsurance.class, "default"));
unscopedFetchGroupMap.put("PartTimeEmployee+default",
pmf.getFetchGroup(PartTimeEmployee.class, "default"));
unscopedFetchGroupMap.put("Person+default",
pmf.getFetchGroup(Person.class, "default"));
unscopedFetchGroupMap.put("Project+default",
pmf.getFetchGroup(Project.class, "default"));
}
public void testPMFGetFetchGroupHashCode() {
FetchGroup scoped = pm.getFetchGroup(Address.class, "default");
FetchGroup unscoped = pmf.getFetchGroup(Address.class, "default");
int actual = scoped.hashCode();
int expected = unscoped.hashCode();
assertEquals("Scoped hash code does not equal unscoped hash code;"
+ "Expected: " + expected + " actual: " + actual,
actual, expected);
}
public void testPMGetFetchGroupIdentical() {
FetchGroup scoped = pm.getFetchGroup(Address.class, "default");
FetchGroup identical = pm.getFetchGroup(Address.class, "default");
assertSame("Modifiable FetchGroup is not identical to modifiable FetchGroup;"
+ "FetchGroup: " + printFetchGroup(scoped)
+ " identical: " + printFetchGroup(identical),
scoped, identical);
}
public void testPMGetFetchGroupUnmodifiableNotIdentical() {
FetchGroup scoped = pm.getFetchGroup(Address.class, "default");
scoped.setUnmodifiable();
FetchGroup modifiable = pm.getFetchGroup(Address.class, "default");
assertNotSame("Unmodifiable FetchGroup is identical to modifiable FetchGroup;"
+ "\nunmodifiable: " + printFetchGroup(scoped)
+ "\n modifiable: " + printFetchGroup(modifiable),
scoped, modifiable);
}
public void testPMFGetFetchGroupNotIdentical() {
FetchGroup first = pmf.getFetchGroup(Address.class, "default");
FetchGroup second = pmf.getFetchGroup(Address.class, "default");
assertNotSame("First FetchGroup is identical to second FetchGroup;"
+ "\n first: " + printFetchGroup(first)
+ "\nsecond: " + printFetchGroup(second),
first, second);
}
public void testPMGetFetchGroupEquals() {
FetchGroup unmodifiable = pm.getFetchGroup(Address.class, "default");
unmodifiable.setUnmodifiable();
FetchGroup modifiable = pm.getFetchGroup(Address.class, "default");
assertEquals("Unmodifiable FetchGroup is not equal to modifiable FetchGroup;"
+ "\nunmodifiable: " + printFetchGroup(unmodifiable)
+ "\n modifiable: " + printFetchGroup(modifiable),
unmodifiable, modifiable);
}
public void testPMModifiable() {
FetchGroup scoped = pm.getFetchGroup(Address.class, "default");
assertFalse("Scoped FetchGroup should be modifiable initially, but is unmodifiable.",
scoped.isUnmodifiable());
scoped.setUnmodifiable();
assertTrue("Scoped FetchGroup should be unmodifiable after setUnmodifiable, but is modifiable.",
scoped.isUnmodifiable());
}
public void testPMFModifiable() {
FetchGroup scoped = pmf.getFetchGroup(Address.class, "default");
assertFalse("Unscoped FetchGroup should be modifiable initially, but is unmodifiable.",
scoped.isUnmodifiable());
scoped.setUnmodifiable();
assertTrue("Unscoped FetchGroup should be unmodifiable after setUnmodifiable, but is modifiable.",
scoped.isUnmodifiable());
}
public void testCategoriesClass() {
checkAddCategory(Employee.class, FetchGroup.ALL, allMembers);
checkAddCategory(Employee.class, FetchGroup.BASIC, basicMembers);
checkAddCategory(Employee.class, FetchGroup.DEFAULT, defaultMembers);
checkAddCategory(Employee.class, FetchGroup.RELATIONSHIP, relationshipMembers);
checkAddCategory(Employee.class, FetchGroup.MULTIVALUED, multivaluedMembers);
failOnError();
}
public void testCategoriesInterface() {
checkAddCategory(PIEmployee.class, FetchGroup.ALL, allMembers);
checkAddCategory(PIEmployee.class, FetchGroup.BASIC, basicMembers);
checkAddCategory(PIEmployee.class, FetchGroup.DEFAULT, defaultMembers);
checkAddCategory(PIEmployee.class, FetchGroup.RELATIONSHIP, relationshipMembers);
checkAddCategory(PIEmployee.class, FetchGroup.MULTIVALUED, multivaluedMembers);
failOnError();
}
public void testRemoveCategory() {
FetchGroup fg = pm.getFetchGroup(Employee.class, "testRemoveCategory");
Set expectedSet = new HashSet();
expectedSet.addAll(Arrays.asList(allButMultivaluedMembers));
Set members = fg.getMembers();
fg.addCategory(FetchGroup.ALL);
fg.removeCategory(FetchGroup.MULTIVALUED);
members = fg.getMembers();
assertEquals("FetchGroup.addCategory(all).removeCategory(multivalued)"
+ " should contain all but multivalued members.\n",
expectedSet, members);
}
public void testAddMember() {
FetchGroup fg = pm.getFetchGroup(Employee.class, "testAddMember");
for (int i = 0; i < allMembers.length; ++i) {
String member = allMembers[i];
fg.addMember(member);
Set members = fg.getMembers();
assertTrue("FetchGroup should contain " + member + " but does not.\n"
+ printFetchGroup(fg),
members.contains(member));
assertEquals("FetchGroup should contain " + i+1
+ "members, but does not; ",
i+1, members.size());
}
}
public void testAddMembers() {
FetchGroup fg = pm.getFetchGroup(Employee.class, "testAddMembers");
fg.addMembers(multivaluedMembers);
fg.addMembers(allButMultivaluedMembers);
Set members = fg.getMembers();
Set expectedSet = new HashSet();
expectedSet.addAll(Arrays.asList(allMembers));
assertEquals("FetchGroup should contain all members.\n",
expectedSet, members);
}
public void testRemoveMembers() {
FetchGroup fg = pm.getFetchGroup(Employee.class, "testRemoveMembers");
fg.addMembers(allMembers);
fg.removeMembers(relationshipMembers);
Set members = fg.getMembers();
Set expectedSet = new HashSet();
expectedSet.addAll(Arrays.asList(basicMembers));
expectedSet.add("phoneNumbers");
assertEquals("FetchGroup should contain basic members " +
"plus address plus phoneNumbers.\n",
expectedSet, members);
fg.removeMembers(basicMembers);
members = fg.getMembers();
expectedSet = new HashSet();
expectedSet.add("phoneNumbers");
assertEquals("FetchGroup should contain address plus phoneNumbers.\n",
expectedSet, members);
}
public void testRemoveMember() {
FetchGroup fg = pm.getFetchGroup(Employee.class, "testRemoveMember");
fg.addCategory(FetchGroup.ALL);
for (int i = allMembers.length - 1; i >= 0; --i) {
String member = allMembers[i];
fg.removeMember(member);
Set members = fg.getMembers();
assertFalse("FetchGroup should not contain " + member + " but does.\n"
+ printFetchGroup(fg),
members.contains(member));
assertEquals("FetchGroup should contain " + i
+ "members, but does not; ",
i, members.size());
}
}
public void testRecursionDepth() {
FetchGroup fg = pm.getFetchGroup(Employee.class, "testRecursionDepth");
fg.addMember("manager");
int depth = fg.getRecursionDepth("manager");
assertEquals("Initial recursion depth for manager should be 1." +
printFetchGroup(fg),
1, depth);
fg.setRecursionDepth("manager", 64);
assertEquals("Recursion depth for manager should be 64." +
printFetchGroup(fg),
64, fg.getRecursionDepth("manager"));
}
public void testPostLoad() {
FetchGroup fg = pm.getFetchGroup(Employee.class, "testPostLoad");
assertFalse("New FetchGroup should have post-load false; "
+ printFetchGroup(fg),
fg.getPostLoad());
fg.setPostLoad(true);
assertTrue("After setPostLoad(true) FetchGroup should have post-load true; "
+ printFetchGroup(fg),
fg.getPostLoad());
fg.setPostLoad(false);
assertFalse("After setPostLoad, FetchGroup should have post-load false; "
+ printFetchGroup(fg),
fg.getPostLoad());
}
public void testUnmodifiableSetPostLoad() {
FetchGroup fg = pm.getFetchGroup(Employee.class, "testUnmodifiableSetPostLoad");
fg.setUnmodifiable();
try {
fg.setPostLoad(true);
fail("Unmodifiable FetchGroup should throw on setPostLoad.");
} catch(JDOException ex) {
// good catch!
}
}
public void testUnmodifiableAddMember() {
FetchGroup fg = pm.getFetchGroup(Employee.class, "testUnmodifiableAddMember");
fg.setUnmodifiable();
try {
fg.addMember("hiredate");
fail("Unmodifiable FetchGroup should throw on addMember.");
} catch(JDOException ex) {
// good catch!
}
}
public void testUnmodifiableAddMembers() {
FetchGroup fg = pm.getFetchGroup(Employee.class, "testUnmodifiableAddMembers");
fg.setUnmodifiable();
try {
fg.addMembers(allMembers);
fail("Unmodifiable FetchGroup should throw on addMembers.");
} catch(JDOException ex) {
// good catch!
}
}
public void testUnmodifiableRemoveMember() {
FetchGroup fg = pm.getFetchGroup(Employee.class, "testUnmodifiableRemoveMember");
fg.addMembers(allMembers);
fg.setUnmodifiable();
try {
fg.removeMember("hiredate");
fail("Unmodifiable FetchGroup should throw on removeMember.");
} catch(JDOException ex) {
// good catch!
}
}
public void testUnmodifiableRemoveMembers() {
FetchGroup fg = pm.getFetchGroup(Employee.class, "testUnmodifiableRemoveMembers");
fg.addMembers(allMembers);
fg.setUnmodifiable();
try {
fg.removeMembers(allMembers);
fail("Unmodifiable FetchGroup should throw on removeMembers.");
} catch(JDOException ex) {
// good catch!
}
}
public void testUnmodifiableAddCategory() {
FetchGroup fg = pm.getFetchGroup(Employee.class, "testUnmodifiableAddCategory");
fg.setUnmodifiable();
try {
fg.addCategory(FetchGroup.ALL);
fail("Unmodifiable FetchGroup should throw on addCategory.");
} catch(JDOException ex) {
// good catch!
}
}
public void testUnmodifiableRemoveCategory() {
FetchGroup fg = pm.getFetchGroup(Employee.class, "testUnmodifiableRemoveCategory");
fg.addCategory(FetchGroup.ALL);
fg.setUnmodifiable();
try {
fg.removeCategory(FetchGroup.ALL);
fail("Unmodifiable FetchGroup should throw on removeCategory.");
} catch(JDOException ex) {
// good catch!
}
}
public void testUnmodifiableSetRecursionDepth() {
FetchGroup fg = pm.getFetchGroup(Employee.class, "testUnmodifiableSetRecursionDepth");
fg.setUnmodifiable();
try {
fg.setRecursionDepth("hiredate", 64);
fail("Unmodifiable FetchGroup should throw on setRecursionDepth.");
} catch(JDOException ex) {
// good catch!
}
}
public void testUnmodifiableSetUnmodifiable() {
FetchGroup fg = pm.getFetchGroup(Employee.class, "testUnmodifiableSetUnmodifiable");
fg.setUnmodifiable();
fg.setUnmodifiable(); // should be ok
}
public void testPMGetFetchGroupClassNotPersistenceCapable() {
try {
FetchGroup fg = pm.getFetchGroup(Integer.class, "testPMGetFetchGroupClassNotPersistenceCapable");
fail("getFetchGroup should throw on nonPersistenceCapable class.");
} catch(JDOException ex) {
// good catch!
}
}
public void testPMGetFetchGroupInterfaceNotPersistenceCapable() {
try {
FetchGroup fg = pm.getFetchGroup(IEmployee.class, "testPMGetFetchGroupInterfaceNotPersistenceCapable");
fail("getFetchGroup should throw on nonPersistenceCapable interface.");
} catch(JDOException ex) {
// good catch!
}
}
public void testPMFGetFetchGroupClassNotPersistenceCapable() {
try {
FetchGroup fg = pmf.getFetchGroup(Integer.class, "testtestPMFGetFetchGroupClassNotPersistenceCapableGetFetchGroupClassNotPersistenceCapable");
fail("getFetchGroup should throw on nonPersistenceCapable class.");
} catch(JDOException ex) {
// good catch!
}
}
public void testPMFGetFetchGroupInterfaceNotPersistenceCapable() {
try {
FetchGroup fg = pmf.getFetchGroup(IEmployee.class, "testPMFGetFetchGroupInterfaceNotPersistenceCapable");
fail("getFetchGroup should throw on nonPersistenceCapable interface.");
} catch(JDOException ex) {
// good catch!
}
}
public void testAddMemberNotAMember() {
FetchGroup fg = pm.getFetchGroup(Employee.class, "testAddMemberNotAMember");
try {
fg.addMember("NotAMember");
fail("FetchGroup should throw on addMember(NotAMember).");
} catch(JDOException ex) {
// good catch!
}
}
public void testAddMembersNotAMember() {
FetchGroup fg = pm.getFetchGroup(Employee.class, "testAddMembersNotAMember");
try {
fg.addMembers(new String[]{"NotAMember"});
fail("FetchGroup should throw on addMembers(NotAMember).");
} catch(JDOException ex) {
// good catch!
}
}
public void testRemoveMemberNotAMember() {
FetchGroup fg = pm.getFetchGroup(Employee.class, "testRemoveMemberNotAMember");
fg.addCategory(FetchGroup.ALL);
try {
fg.removeMember("NotAMember");
fail("FetchGroup should throw on removeMember(NotAMember).");
} catch(JDOException ex) {
// good catch!
}
}
public void testRemoveMembersNotAMember() {
FetchGroup fg = pm.getFetchGroup(Employee.class, "testRemoveMembersNotAMember");
fg.addCategory(FetchGroup.ALL);
try {
fg.removeMembers(new String[]{"NotAMember"});
fail("FetchGroup should throw on removeMembers(NotAMember).");
} catch(JDOException ex) {
// good catch!
}
}
public void testSetRecursionDepthNotAMember() {
FetchGroup fg = pm.getFetchGroup(Employee.class, "testSetRecursionDepthNotAMember");
try {
fg.setRecursionDepth("NotAMember", 64);
fail("FetchGroup should throw on setRecursionDepth(NotAMember).");
} catch(JDOException ex) {
// good catch!
}
}
private void checkAddCategory(Class cls, String category, String[] expected) {
FetchGroup fg = pm.getFetchGroup(cls, "test" + count() + category);
Set expectedSet = new HashSet();
expectedSet.addAll(Arrays.asList(expected));
Set members = fg.getMembers();
assertTrue("New FetchGroup should have no members; "
+ printFetchGroup(fg),
members.isEmpty());
fg.addCategory(category);
members = fg.getMembers();
if (!members.equals(expectedSet)) {
appendMessage("FetchGroup(" + cls.getName()
+ ".addCategory(" + category + ") should contain\n"
+ expectedSet + " but contains\n" + members);
}
}
private String printFetchGroup(FetchGroup fg) {
StringBuffer sb = new StringBuffer("FetchGroup (");
sb.append(fg.getType().isInterface()?"interface: ":"class: ");
sb.append(fg.getType().getName());
sb.append("; name: ");
sb.append(fg.getName());
sb.append(fg.isUnmodifiable()?"; unmodifiable":"; modifiable");
Set members = fg.getMembers();
Iterator it = members.iterator();
if (it.hasNext()) {
sb.append("; members: ");
String member = (String)it.next();
formatMember(sb, fg, member);
}
while (it.hasNext()) {
sb.append(", ");
String member = (String)it.next();
formatMember(sb, fg, member);
}
sb.append(")");
return sb.toString();
}
protected void formatMember(StringBuffer sb, FetchGroup fg, String member) {
sb.append(member);
sb.append("[");
sb.append(fg.getRecursionDepth(member));
sb.append("]");
}
/** Counter */
protected int counter = 0;
protected String count() {
return String.valueOf(counter++);
}
}
tck/src/java/org/apache/jdo/tck/api/instancecallbacks/AbstractInstanceLifecycleListener.java 100664 51073 12500110374 32612 0 ustar mbouschen staff 0 0 /*
* 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.api.instancecallbacks;
import java.util.ArrayList;
import java.util.List;
import javax.jdo.JDOHelper;
import javax.jdo.listener.InstanceLifecycleEvent;
import javax.jdo.listener.InstanceLifecycleListener;
import javax.jdo.listener.AttachLifecycleListener;
import javax.jdo.listener.ClearLifecycleListener;
import javax.jdo.listener.CreateLifecycleListener;
import javax.jdo.listener.DeleteLifecycleListener;
import javax.jdo.listener.DetachLifecycleListener;
import javax.jdo.listener.DirtyLifecycleListener;
import javax.jdo.listener.LoadLifecycleListener;
import javax.jdo.listener.StoreLifecycleListener;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
* Title: Abstract test AbstractInstanceLifecycleListener
* Keywords: LifeCycleListener lifecycle listener callback
* Assertion IDs: A12.15-1, A12.15-2, A12.15-3, A12.15-4, A12.15-5,
* A12.15-6, A12.15-7, A12.15-8, A12.15-9, A12.15-10, A12.15-11, A12.15-12,
* A12.15-13, A12.15-14,
* Assertion Description:
* A12.15-1 void postCreate(InstanceLifecycleEvent event);
* This method is called whenever a persistent instance is created,
* during makePersistent. It is called after the instance transitions
* to persistent-new.
* A12.15-2 void postLoad(InstanceLifecycleEvent event);
* This method is called whenever a persistent instance is loaded.
* It is called after the jdoPostLoad method is invoked on the instance.
* A12.15-3 void preStore(InstanceLifecycleEvent event);
* This method is called whenever a persistent instance is stored,
* for example during flush or commit. It is called
* before the jdoPreStore method is invoked on the instance.
* A12.15-4 void postStore(InstanceLifecycleEvent event);
* This method is called whenever a persistent instance is stored,
* for example during flush or commit. It is called
* after the jdoPreStore method is invoked on the instance.
* An object identity for a per?sistent-new instance must have been assigned
* to the instance when this callback is invoked.
* A12.15-5 void preClear(InstanceLifecycleEvent event);
* This method is called whenever a persistent instance
* is cleared, for example during afterCompletion. It is called
* before the jdoPreClear method is invoked on the instance.
* A12.15-6 void postClear(InstanceLifecycleEvent event);
* This method is called whenever a persistent instance
* is cleared, for example during afterCom?pletion. It is called
* after the jdoPreClear method is invoked on the instance and the fields
* have been cleared by the JDO implementation.
* A12.15-7 void preDelete(InstanceLifecycleEvent event);
* This method is called whenever a persistent instance
* is deleted, during deletePersistent. It is called before
* the state transition and before the jdoPreDelete method
* is invoked on the instance.
* A12.15-8 void postDelete(InstanceLifecycleEvent event);
* This method is called whenever a persistent instance
* is deleted, during deletePersistent. It is called
* after the jdoPreDelete method is invoked on the instance
* and after the state transition.
* A12.15-9 void preDirty(InstanceLifecycleEvent event);
* This method is called whenever a persistent clean instance
* is first made dirty, during an operation that modifies
* the value of a persistent or transactional field. It is called
* before the field value is changed.
* A12.15-10 void postDirty(InstanceLifecycleEvent event);
* This method is called whenever a persistent clean instance
* is first made dirty, during an operation that modifies
* the value of a persistent or transactional field. It is called
* after the field value was changed.
* A12.15-11 void preDetach(InstanceLifecycleEvent event);
* This method is called before a persistent instance is copied
* for detachment.
* A12.15-12 void postDetach(InstanceLifecycleEvent event);
* This method is called whenever a persistent instance is copied
* for detachment.
* The source instance is the detached copy; the target instance
* is the persistent instance.
* A12.15-13 void preAttach(InstanceLifecycleEvent event);
* This method is called before a detached instance is attached.
* The source instance is the detached instance].
* A12.15-14 void postAttach(InstanceLifecycleEvent event);
* This method is called after a detached instance is attached.
* The source instance is the corresponding persistent instance in the cache;
* the target instance is the detached instance.
*
* This is the abstract base class for the lifecycle listener test classes.
* It contains constants, variables, and methods used by each listener test
* class. This class implements the setup and teardown methods used by each
* concrete test class.
*
* This class also includes the listener base class that is extended by
* each specific listener.
*
* The strategy of each test case is the same. A specific listener is
* implemented that responds only to events for that specific test; a
* specific persistence-capable class is also implemented, that responds
* only to callbacks for the specific test. A sequence of operations that
* stimulates the callbacks is executed. During these operations, listener
* events and callbacks are collected by the listener instance. Finally,
* the actual events and callbacks that were collected are analyzed and
* differences are reported.
*/
public abstract class AbstractInstanceLifecycleListener extends JDO_Test {
/** */
protected static final String ASSERTION1_FAILED =
"Assertion A12.15-1 (TestInstanceLifecycleListenerCreate) failed: ";
protected static final String ASSERTION2_FAILED =
"Assertion A12.15-2 (TestInstanceLifecycleListener) failed: ";
protected static final String ASSERTION3_FAILED =
"Assertion A12.15-3 (TestInstanceLifecycleListener) failed: ";
protected static final String ASSERTION4_FAILED =
"Assertion A12.15-4 (TestInstanceLifecycleListener) failed: ";
protected static final String ASSERTION5_FAILED =
"Assertion A12.15-5 (TestInstanceLifecycleListener) failed: ";
protected static final String ASSERTION6_FAILED =
"Assertion A12.15-6 (TestInstanceLifecycleListener) failed: ";
protected static final String ASSERTION7_FAILED =
"Assertion A12.15-7 (TestInstanceLifecycleListenerDelete) failed: ";
protected static final String ASSERTION8_FAILED =
"Assertion A12.15-8 (TestInstanceLifecycleListenerDelete) failed: ";
protected static final String ASSERTION9_FAILED =
"Assertion A12.15-9 (TestInstanceLifecycleListener) failed: ";
protected static final String ASSERTION10_FAILED =
"Assertion A12.15-10 (TestInstanceLifecycleListener) failed: ";
protected static final String ASSERTION11_FAILED =
"Assertion A12.15-11 (TestInstanceLifecycleListener) failed: ";
protected static final String ASSERTION12_FAILED =
"Assertion A12.15-12 (TestInstanceLifecycleListener) failed: ";
protected static final String ASSERTION13_FAILED =
"Assertion A12.15-13 (TestInstanceLifecycleListener) failed: ";
protected static final String ASSERTION14_FAILED =
"Assertion A12.15-14 (TestInstanceLifecycleListener) failed: ";
/**
* The listener to be used for the test. This method is implemented
* by the subclasses to use the proper listener.
*/
protected abstract InstanceLifecycleListenerImpl getListener();
/**
* The classes to be used for the test. This method is implemented
* by the subclasses to use the proper classes. The classes returned
* by this method are used for two purposes: they are used to register
* listeners; and they are used as the teardown classes whose instances
* are removed from the datastore at the end of the test.
*/
protected abstract Class[] getPersistentClasses();
/**
* Register a new InstanceLifecycleListenerImpl with the
* PersistenceManager.
*/
protected void addListener() {
getPM();
pm.addInstanceLifecycleListener(getListener(), getPersistentClasses());
}
/**
* Unregister the InstanceLifecycleListenerImpl with the
* PersistenceManager.
*/
protected void removeListener() {
getPM();
pm.removeInstanceLifecycleListener(getListener());
}
/**
* Set up for lifecycle tests:
* Register the LifecycleListener; add PCPoint to tearDownClasses.
*/
protected void localSetUp() {
addListener();
addTearDownClass(getPersistentClasses());
}
/**
* Clean up after lifecycle tests:
* Unregister the LifecycleListener.
*/
protected void localTearDown() {
removeListener(); // no callbacks for teardown
super.localTearDown();
}
/**
* The LifeCycleListener to be registered with the
* PersistenceManager. This is the base class that is extended
* by each test.
*/
protected abstract static class InstanceLifecycleListenerImpl
implements AttachLifecycleListener, ClearLifecycleListener,
CreateLifecycleListener, DeleteLifecycleListener,
DetachLifecycleListener, DirtyLifecycleListener,
LoadLifecycleListener, StoreLifecycleListener {
protected InstanceLifecycleListenerImpl() {}
protected Object expectedSource = null;
protected Object expectedTarget = null;
public void setExpectedSource(Object source) {
expectedSource = source;
}
public void setExpectedTarget(Object target) {
expectedTarget = target;
}
/**
* This is the list names of locations for listener events and
* callbacks. Each instance of an event or callback has a specific
* name that is associated with the value. The values
* are used during collection of events and both names and values
* are used for reporting results.
*/
private static List locations = new ArrayList();
/** These are indexes into the sequence array. Each index
* represents the position in the sequence array for the
* corresponding callback or listener event.
*/
public static final int PRE_ATTACH_CALLBACK;
public static final int POST_ATTACH_CALLBACK;
public static final int PRE_ATTACH_LISTENER;
public static final int POST_ATTACH_LISTENER;
public static final int PRE_CLEAR_CALLBACK;
public static final int PRE_CLEAR_LISTENER;
public static final int POST_CLEAR_LISTENER;
public static final int POST_CREATE_LISTENER;
public static final int PRE_DELETE_CALLBACK;
public static final int PRE_DELETE_LISTENER;
public static final int POST_DELETE_LISTENER;
public static final int PRE_DETACH_CALLBACK;
public static final int POST_DETACH_CALLBACK;
public static final int PRE_DETACH_LISTENER;
public static final int POST_DETACH_LISTENER;
public static final int PRE_DIRTY_LISTENER;
public static final int POST_DIRTY_LISTENER;
public static final int POST_LOAD_CALLBACK;
public static final int POST_LOAD_LISTENER;
public static final int PRE_STORE_CALLBACK;
public static final int PRE_STORE_LISTENER;
public static final int POST_STORE_LISTENER;
/**
* Initialize the list of names and the associated values. For each
* listener event and callback, add the name and then assign the value.
*/
static {
int index = 0;
locations.add("PRE_ATTACH_LISTENER");
PRE_ATTACH_LISTENER = index++;
locations.add("PRE_ATTACH_CALLBACK");
PRE_ATTACH_CALLBACK = index++;
locations.add("POST_ATTACH_CALLBACK");
POST_ATTACH_CALLBACK = index++;
locations.add("POST_ATTACH_LISTENER");
POST_ATTACH_LISTENER = index++;
locations.add("PRE_CLEAR_LISTENER");
PRE_CLEAR_LISTENER = index++;
locations.add("PRE_CLEAR_CALLBACK");
PRE_CLEAR_CALLBACK = index++;
locations.add("POST_CLEAR_LISTENER");
POST_CLEAR_LISTENER = index++;
locations.add("POST_CREATE_LISTENER");
POST_CREATE_LISTENER = index++;
locations.add("PRE_DELETE_LISTENER");
PRE_DELETE_LISTENER = index++;
locations.add("PRE_DELETE_CALLBACK");
PRE_DELETE_CALLBACK = index++;
locations.add("POST_DELETE_LISTENER");
POST_DELETE_LISTENER = index++;
locations.add("POST_DETACH_CALLBACK");
POST_DETACH_CALLBACK = index++;
locations.add("PRE_DETACH_LISTENER");
PRE_DETACH_LISTENER = index++;
locations.add("PRE_DETACH_CALLBACK");
PRE_DETACH_CALLBACK = index++;
locations.add("POST_DETACH_LISTENER");
POST_DETACH_LISTENER = index++;
locations.add("PRE_DIRTY_LISTENER");
PRE_DIRTY_LISTENER = index++;
locations.add("POST_DIRTY_LISTENER");
POST_DIRTY_LISTENER = index++;
locations.add("POST_LOAD_CALLBACK");
POST_LOAD_CALLBACK = index++;
locations.add("POST_LOAD_LISTENER");
POST_LOAD_LISTENER = index++;
locations.add("PRE_STORE_LISTENER");
PRE_STORE_LISTENER = index++;
locations.add("PRE_STORE_CALLBACK");
PRE_STORE_CALLBACK = index++;
locations.add("POST_STORE_LISTENER");
POST_STORE_LISTENER = index++;
}
private int[] actual = new int[locations.size()];
/** Track the current sequence of callbacks.
*/
private int current = 0;
public void notifyEvent(int event) {
actual[event] = ++current;
}
/**
* Initialize the expected ordering of callbacks and listeners.
* Each entry in the sequence is one of the PRE_ or POST_XXX_LISTENER
* or _CALLBACK above. The order in the sequence is the expected
* calling order.
*/
private static int[] newExpected(int[] sequence) {
int order = 0;
int[] result = new int[locations.size()];
for (int i = 0; i < sequence.length; ++i) {
result[sequence[i]] = ++order;
}
return result;
}
/**
* The error message buffer to report exceptions.
*/
protected StringBuffer messages = new StringBuffer();
protected void checkEventType(String where, int expected, int actual) {
if (expected != actual) {
messages.append(where + "wrong event type: " +
"expected <" + expected +
">, actual <" + actual + ">\n");
}
}
protected void checkEventSource(String where, Object eventSource) {
if (expectedSource != eventSource) {
messages.append(where + "wrong event source: " +
"expected <" + expectedSource +
">, actual <" + eventSource + ">\n");
}
}
protected void checkEventTarget(String where, Object eventTarget) {
if (expectedTarget != eventTarget) {
messages.append(where + "wrong event target: " +
"expected <" + expectedTarget +
">, actual <" + eventTarget + ">\n");
}
}
protected void checkTrue(String where, boolean condition) {
if (!condition) {
messages.append(where + "was not true.\n");
}
}
protected void checkSame(String where,
Object expected, Object actual) {
if (expected != actual) {
messages.append(where +
"expected <" + expected +
">, actual <" + actual + ">\n");
}
}
protected void checkPersistent(String where, Object obj) {
if (!JDOHelper.isPersistent(obj)) {
messages.append(where + "object should be persistent.\n");
}
}
protected void checkNotPersistent(String where, Object obj) {
if (JDOHelper.isPersistent(obj)) {
messages.append(where + "object should not be persistent.\n");
}
}
protected void checkDirty(String where, Object obj) {
if (!JDOHelper.isDirty(obj)) {
messages.append(where + "object should be dirty.\n");
}
}
protected void checkNotDirty(String where, Object obj) {
if (JDOHelper.isDirty(obj)) {
messages.append(where + "object should not be dirty.\n");
}
}
protected void checkNew(String where, Object obj) {
if (!JDOHelper.isNew(obj)) {
messages.append(where + "object should be new.\n");
}
}
protected void checkNotNew(String where, Object obj) {
if (JDOHelper.isNew(obj)) {
messages.append(where + "object should not be new.\n");
}
}
protected void checkDeleted(String where, Object obj) {
if (!JDOHelper.isDeleted(obj)) {
messages.append(where + "object should be deleted.\n");
}
}
protected void checkNotDeleted(String where, Object obj) {
if (JDOHelper.isDeleted(obj)) {
messages.append(where + "object should not be deleted.\n");
}
}
/**
* Verify the actual sequence of callbacks and listeners
* against the expected. Each of the expected and actual are
* int arrays in which each listener and callback have one
* position in the array and the value of the array at that
* position is the order, starting with 1, of the callback.
* If the callback or listener was never invoked, the value
* is 0.
*/
public void verifyCallbacks(String where, int[] expected) {
int[] expectedSequence = newExpected(expected);
for (int index = 0; index < locations.size(); ++index) {
if (expectedSequence[index] != actual[index]) {
messages.append("\nSequence verification failed for " +
locations.get(index) +
"; expected: <" + expectedSequence[index] +
"> actual: <" + actual[index] +
">\n");
}
}
if (messages.length() > 0) {
fail(where + "\n" + messages.toString());
}
}
public void postAttach(InstanceLifecycleEvent event) {
}
public void postClear(InstanceLifecycleEvent event) {
}
public void postCreate(InstanceLifecycleEvent event) {
}
public void postDelete(InstanceLifecycleEvent event) {
}
public void postDetach(InstanceLifecycleEvent event) {
}
public void postDirty(InstanceLifecycleEvent event) {
}
public void postLoad(InstanceLifecycleEvent event) {
}
public void postStore(InstanceLifecycleEvent event) {
}
public void preAttach(InstanceLifecycleEvent event) {
}
public void preClear(InstanceLifecycleEvent event) {
}
public void preDelete(InstanceLifecycleEvent event) {
}
public void preDetach(InstanceLifecycleEvent event) {
}
public void preDirty(InstanceLifecycleEvent event) {
}
public void preStore(InstanceLifecycleEvent event) {
}
}
}
tck/src/java/org/apache/jdo/tck/api/instancecallbacks/AccessingFieldsInPredelete.java 100664 20357 12500110374 31204 0 ustar mbouschen staff 0 0 /*
* 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.api.instancecallbacks;
import java.util.Date;
import javax.jdo.JDODataStoreException;
import javax.jdo.JDOUserException;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.instancecallbacks.InstanceCallbackClass;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Accessing Fields In Predelete
*Keywords: instancecallbacks
*Assertion ID: A10.4-2.
*Assertion Description:
Access to field values within a call to jdoPreDelete()
of a class implementing InstanceCallbacks are valid.
*/
/*
* Define a PersistenceCapable class containing some primative types,
* a Date attribute, a String attribute,
* one reference to an object of the same class and one
* Set collection attribute containing two instances of objects of this class.
*
* Create an object of this class (along with the referenced object and two members in the Set) and commit.
* Delete the object.
* Within jdoPreDelete(), capture the values of attribues and delete the referenced object
* and one of the two Set members.
*
* In the next transaction, verify the data captured from the attriubtes was what was expected and
* that all the objects that should have been deleted have been deleted and the
* Set member that was not deleted is still present.
* Also verify that jdoPreDelete() is called on each of these objects deleted within the first jdoPreDelete().
*/
public class AccessingFieldsInPredelete extends TestParts {
private static final String ASSERTION_FAILED =
"Assertion A10.4-2 (AccessingFieldsInPredelete) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(AccessingFieldsInPredelete.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
addTearDownClass(InstanceCallbackClass.class);
}
/** */
public void test() throws Exception {
pm = getPM();
Transaction t = pm.currentTransaction();
InstanceCallbackClass.initializeStaticsForTest();
InstanceCallbackClass.performPreDeleteTests = true;
t.begin();
Date createTime = new Date();
InstanceCallbackClass secondaryObj = new InstanceCallbackClass("secondaryObj", createTime, 2, 2.0, (short)-1, '2', null);
InstanceCallbackClass primaryObj = new InstanceCallbackClass("primaryObj", createTime, 1, 1.0, (short)3, '1', secondaryObj);
InstanceCallbackClass childA = new InstanceCallbackClass("childA", createTime, 3, 3.0, (short)-2, '3', null);
InstanceCallbackClass childB = new InstanceCallbackClass("childB", createTime, 4, 4.0, (short)-3, '4', null);
pm.makePersistent(primaryObj);
pm.makePersistent(secondaryObj);
pm.makePersistent(childA);
pm.makePersistent(childB);
primaryObj.addChild(childA);
primaryObj.addChild(childB);
Object secondaryObjId = pm.getObjectId(secondaryObj);
Object primaryObjId = pm.getObjectId(primaryObj);
Object childAId = pm.getObjectId(childA);
Object childBId = pm.getObjectId(childB);
t.commit();
t.begin();
primaryObj = (InstanceCallbackClass)pm.getObjectById(primaryObjId, true);
pm.deletePersistent(primaryObj);
t.commit();
t.begin();
try {
primaryObj = (InstanceCallbackClass)pm.getObjectById(primaryObjId, true);
fail(ASSERTION_FAILED, "primaryObj deleted but getObjectById() on its Id succeeded.");
} catch (JDOUserException e) {
// expected one of these exceptions
} catch (JDODataStoreException e) {
// expected one of these exceptions
}
// check that jdoPreDelete() provided proper access to the attributes in primaryObj
checkFieldValues(ASSERTION_FAILED, "jdoPreDelete attribute access: ", 1, "primaryObj", createTime, 1.0, (short)3, '1');
checkInstances(ASSERTION_FAILED, "jdoPreDelete instance access: ", 1, "secondaryObj", 2, 7);
checkPMAccess(ASSERTION_FAILED, "jdoPreDelete PersistenceManager access: ", 1, true);
// check that secondaryObj had jdoPreDelete() called on it and provided proper access to its attributes.
checkFieldValues(ASSERTION_FAILED, "jdoPreDelete attribute access: ", 2, "secondaryObj", createTime, 2.0, (short)-1, '2');
checkInstances(ASSERTION_FAILED, "jdoPreDelete instance access: ", 2, null, 0, 0);
checkPMAccess(ASSERTION_FAILED, "jdoPreDelete PersistenceManager access: ", 2, true);
// check that secondaryObj was deleted.
try {
secondaryObj = (InstanceCallbackClass)pm.getObjectById(secondaryObjId, true);
fail(ASSERTION_FAILED, "secondaryObj should have been deleted but getObjectById() on its Id succeeded.");
} catch (JDOUserException e) {
// expected one of these exceptions
} catch (JDODataStoreException e) {
// expected one of these exceptions
}
// check that first added member of Set had jdoPreDelete() called on it and provided proper access to its attributes.
checkFieldValues(ASSERTION_FAILED, "jdoPreDelete attribute access: ", 3, "childA", createTime, 3.0, (short)-2, '3');
checkInstances(ASSERTION_FAILED, "jdoPreDelete instance access: ", 3, null, 0, 0);
checkPMAccess(ASSERTION_FAILED, "jdoPreDelete PersistenceManager access: ", 3, true);
// verify first added member of Set was actaully deleted.
try {
childA = (InstanceCallbackClass)pm.getObjectById(childAId, true);
fail(ASSERTION_FAILED, "First added member of Set primaryObj.children should have been deleted but getObjectById() on its Id succeeded.");
} catch (JDOUserException e) {
// expected one of these exceptions
} catch (JDODataStoreException e) {
// expected one of these exceptions
}
// check that the second added member of Set did not have jdoPreDelete() called on it and it was not deleted.
if(InstanceCallbackClass.processedIndex[4] == true) {
fail(ASSERTION_FAILED, "jdoPreDelete() called on childB--it was not deleted.");
}
try {
childB = (InstanceCallbackClass)pm.getObjectById(childBId, true);
if( childB == null ){
if (debug) logger.debug("childB object is null");
} else {
if( childB.name == null )
if (debug) logger.debug("childB.name is null");
}
if(!childB.name.equals("childB")) {
fail(ASSERTION_FAILED, "childB.name should be \"childB\". Instead its value is \"" + childB.name + "\".");
}
} catch (JDOUserException e) {
fail(ASSERTION_FAILED, "Second added member of Set primaryObj.children should exist but getObjectById() got JDOUserException " + e);
} catch (JDODataStoreException e) {
fail(ASSERTION_FAILED, "Second added member of Set primaryObj.children should exist but getObjectById() got JDODataStoreException " + e);
}
t.rollback();
pm.close();
pm = null;
}
}
tck/src/java/org/apache/jdo/tck/api/instancecallbacks/AccessOtherInstancesInPrestore.java 100664 11052 12500110374 32113 0 ustar mbouschen staff 0 0 /*
* 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.api.instancecallbacks;
import java.util.Date;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.instancecallbacks.InstanceCallbackClass;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Access Other Instances In Prestore Method
*Keywords: instancecallbacks
*Assertion ID: A10.2-3.
*Assertion Description:
The context in which a call is made to jdoPreStore() allows access
to the PersistenceManager and other persistent JDO instances.
*/
/*
* Within jdoPreStore(), locate the PersistenceManager (JDOHelper.getPersistenceManager()) and use it
* to call currentTransaction(). Use the Transaction to call isActive() and verify active. These operations
* are done to help verify that we had access to a usable PersistenceManager.
*
* Create objects.
* Within jdoPreStore(), capture information about objects referenced.
* This includes a String, Date and Collection attribute.
* After commit() verify jdoPreStore() called and found what expected.
*/
public class AccessOtherInstancesInPrestore extends TestParts {
/** */
private static final String ASSERTION_FAILED =
"Assertion A10.2-3 (AccessOtherInstancesInPrestore) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(AccessOtherInstancesInPrestore.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
addTearDownClass(InstanceCallbackClass.class);
}
/** */
public void test() throws Exception
{
pm = getPM();
Transaction t = pm.currentTransaction();
InstanceCallbackClass.initializeStaticsForTest();
InstanceCallbackClass.performPreStoreTests = true;
t.begin();
// Create primaryObj which has a collection (children) of two objects and references another (nextObj).
// None of the other objects have a non-empty collection. The also all have nextObj set to null.
Date createTime = new Date();
InstanceCallbackClass secondaryObj = new InstanceCallbackClass("secondaryObj", createTime, 2, 2.0, (short)-1, '2', null);
InstanceCallbackClass primaryObj = new InstanceCallbackClass("primaryObj", createTime, 1, 1.0, (short)3, '1', secondaryObj);
InstanceCallbackClass childA = new InstanceCallbackClass("childA", createTime, 3, 3.0, (short)-2, '3', null);
InstanceCallbackClass childB = new InstanceCallbackClass("childB", createTime, 4, 4.0, (short)-3, '4', null);
pm.makePersistent(primaryObj);
primaryObj.addChild(childA);
primaryObj.addChild(childB);
t.commit();
// check that jdoPreStore provides access to instances for primaryObj
checkInstances(ASSERTION_FAILED, "jdoStore instance access: ", 1, "secondaryObj", 2, 7);
// check that jdoPreStore provides access to PersistenceManager for primaryObj
checkPMAccess(ASSERTION_FAILED, "jdoPreDelete PersistenceManager access: ", 1, true);
// check that jdoPreStore provides access to instances for secondaryObj
checkInstances(ASSERTION_FAILED, "jdoStore instance access: ", 2, null, 0, 0);
// check that jdoPreStore provides access to PersistenceManager for secondaryObj
checkPMAccess(ASSERTION_FAILED, "jdoPreDelete PersistenceManager access: ", 2, true);
// There is no need to check childA or childB. They are no different than secondaryObj.
pm.close();
pm = null;
}
}
tck/src/java/org/apache/jdo/tck/api/instancecallbacks/CallingJdoPostload.java 100664 14500 12500110374 27542 0 ustar mbouschen staff 0 0 /*
* 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.api.instancecallbacks;
import javax.jdo.JDODataStoreException;
import javax.jdo.JDOUserException;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.instancecallbacks.InstanceCallbackNonPersistFdsClass;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Calling InstanceCallbacks Postload Method
*Keywords: instancecallbacks
*Assertion ID: A10.1-1.
*Assertion Description:
The jdoPostLoad() method of a class implementing
InstanceCallbacks is called after the default fetch
group values are loaded from the StateManager into the instance.
*/
/*
* Create a persistent object and commit().
*
* Retrieve object in the next transaction and verify its state is hollow.
*
* Reference a persistent attribute and verify:
* the call to jdoPostLoad() occurred just before this reference--and after the object was retrieved (via getObjectById()),
* jdoPostLoad() was called exactly once and
* once the attribute has been referenced, the state of the object is persistent-clean
*
* Verify that the values of the persistent attributes available in jdoPostLoad() are the values actually in the object (the
* values have already been restored be the time jdoPostLoad() is called).
*/
public class CallingJdoPostload extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A10.1-1 (CallingJdoPostload) failed";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(CallingJdoPostload.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
addTearDownClass(InstanceCallbackNonPersistFdsClass.class);
}
/** */
public void test() throws Exception
{
pm = getPM();
Transaction t = pm.currentTransaction();
t.setRetainValues(false);
InstanceCallbackNonPersistFdsClass.initializeStaticsForTest();
t.begin();
// create instance
InstanceCallbackNonPersistFdsClass obj1 = new InstanceCallbackNonPersistFdsClass(2.2f, 13);
pm.makePersistent(obj1);
Object objPtr1 = pm.getObjectId (obj1);
obj1.setNonPersist(1, (char)2, 3.3, (short)4);
t.commit();
t.begin();
// set applicationStep before and after getObjectById() to be sure when jdoPostLoad() gets called.
InstanceCallbackNonPersistFdsClass.applicationStep = InstanceCallbackNonPersistFdsClass.beforeGetObjectById;
try {
obj1 = (InstanceCallbackNonPersistFdsClass)pm.getObjectById(objPtr1, true); // jdoPreLoad() called
} catch (JDOUserException e) {
// could not locate persistent object created in previous transaction
fail(ASSERTION_FAILED, "CallingJdoPostload: Could not locate persistent object obj1 created in previous transaction " + e);
return;
} catch (JDODataStoreException e) {
// could not locate persistent object created in previous transaction
fail(ASSERTION_FAILED, "CallingJdoPostload: Could not locate persistent object obj1 created in previous transaction " + e);
return;
}
int objectState = currentState(obj1);
// expect state to be hollow or persistent-clean
if(objectState != HOLLOW && objectState != PERSISTENT_CLEAN) {
fail(ASSERTION_FAILED, "State of object was not hollow or persistent clean after accessed via getObjectById((), state is " + states[objectState]);
}
InstanceCallbackNonPersistFdsClass.applicationStep = InstanceCallbackNonPersistFdsClass.afterGetObjectById;
int getIntValue = obj1.intValue; // reference attribute in default fetch group
objectState = currentState(obj1);
// expect jdoPostLoad() was called
if(!InstanceCallbackNonPersistFdsClass.postloadCalled) {
fail(ASSERTION_FAILED, "jdoPostLoad() never called");
}
// only check other information if jdoPostLoad() called
if(InstanceCallbackNonPersistFdsClass.postloadCalled) {
// expect jdoPostLoad() was called only once
if(InstanceCallbackNonPersistFdsClass.postloadCalledMultipleTimes) {
fail(ASSERTION_FAILED, "jdoPostLoad was called more than once for the same loaded object");
}
// verify the value of intValue was available in jdoPostLoad()
if(InstanceCallbackNonPersistFdsClass.savedIntValue != getIntValue) {
fail(ASSERTION_FAILED,
"intValue available in jdoPostLoad is incorrect. It was " +
InstanceCallbackNonPersistFdsClass.savedIntValue +
", it should be " + getIntValue);
}
// verify the value of floatValue was available in jdoPostLoad()
if(InstanceCallbackNonPersistFdsClass.savedFloatValue != obj1.floatValue) {
fail(ASSERTION_FAILED,
"floatValue available in jdoPostLoad is incorrect. It was " +
InstanceCallbackNonPersistFdsClass.savedFloatValue +
", it should be " + obj1.floatValue);
}
}
t.rollback();
pm.close();
pm = null;
}
}
tck/src/java/org/apache/jdo/tck/api/instancecallbacks/CallingJdoPreclear.java 100664 13245 12500110374 27517 0 ustar mbouschen staff 0 0 /*
* 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.api.instancecallbacks;
import java.util.Calendar;
import java.util.Date;
import javax.jdo.JDODataStoreException;
import javax.jdo.JDOUserException;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.instancecallbacks.InstanceCallbackClass;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Calling Jdo Preclear
*Keywords: instancecallbacks
*Assertion ID: A10.3-1.
*Assertion Description:
The jdoPreClear() method of a class implementing
InstanceCallbacks is called before the values in the instance
are cleared. (This happens during the state transition to hollow.)
*/
/*
* Create a new object, reference an existing object and
* modify an existing object and then commit.
*
* Check that each instance contains the values set into
* the persistent attributes prior to commit.
*/
public class CallingJdoPreclear extends TestParts {
/** */
private static final String ASSERTION_FAILED =
"Assertion A10.3-1 (CallingJdoPreclear) failed";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(CallingJdoPreclear.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
addTearDownClass(InstanceCallbackClass.class);
}
/** */
public void test() throws Exception {
pm = getPM();
Transaction t = pm.currentTransaction();
t.setRetainValues(false); // instances transit'n to hollow after commit
InstanceCallbackClass.initializeStaticsForTest();
t.begin();
Calendar cal = Calendar.getInstance();
cal.set(1999, 1, 15, 12, 0);
Date createTime = cal.getTime();
cal.set(2002, 1, 15, 12, 0);
Date laterDate = cal.getTime();
InstanceCallbackClass secondaryObj =
new InstanceCallbackClass("secondaryObj", createTime, 2, 2.2,
(short)-20, '2', null);
InstanceCallbackClass primaryObj =
new InstanceCallbackClass("primaryObj", laterDate, 1, 1.1,
(short)-10, '1', secondaryObj);
pm.makePersistent(primaryObj);
pm.makePersistent(secondaryObj);
Object secondaryObjId = pm.getObjectId(secondaryObj);
Object primaryObjId = pm.getObjectId(primaryObj);
t.commit();
InstanceCallbackClass.performPreClearTests = true;
t.setOptimistic(false);
t.begin();
try {
primaryObj = (InstanceCallbackClass)pm.getObjectById(primaryObjId,
true);
pm.retrieve(primaryObj); // load fields (make it persistent-clean)
} catch (JDOUserException e) {
fail(ASSERTION_FAILED, "Failed to find primaryObj created in "
+ "previous transaction. Got JDOUserException " + e);
return;
} catch (JDODataStoreException e) {
fail(ASSERTION_FAILED, "Failed to find primaryObj created in "
+ "previous transaction. Got JDODataStoreException " + e);
return;
}
secondaryObj = primaryObj.nextObj;
if(secondaryObj == null) {
fail(ASSERTION_FAILED, "Failed to find secondaryObj created in "
+ "previous transaction using reference from primaryObj.");
return;
}
pm.retrieve(secondaryObj);
// primaryObj contains one child; secondaryObj contains none
primaryObj.addChild(secondaryObj); // primaryObj is now dirty
cal.set(2005, 6, 28, 0, 0);
Date stillLaterDate = cal.getTime();
InstanceCallbackClass ternaryObj =
new InstanceCallbackClass("ternaryObj", stillLaterDate, 3, 3.3,
(short)-30, '3', null);
pm.makePersistent(ternaryObj);
ternaryObj.addChild(primaryObj);
t.commit();
// verify attributes in what was persistent-clean object--secondaryObj
checkFieldValues(ASSERTION_FAILED, "jdoPreClear attribute access: ",
2, "secondaryObj", createTime, 2.2, (short)-20, '2');
// verify attributes in what was persistent-dirty object--primaryObj
checkFieldValues(ASSERTION_FAILED, "jdoPreClear attribute access: ",
1, "primaryObj", laterDate, 1.1, (short)-10, '1');
// verify attributes in what was persistent-new object--ternaryObj
checkFieldValues(ASSERTION_FAILED, "jdoPreClear attribute access: ",
3, "ternaryObj", stillLaterDate, 3.3, (short)-30, '3');
pm.close();
pm = null;
InstanceCallbackClass.performPreClearTests = false;
}
}
tck/src/java/org/apache/jdo/tck/api/instancecallbacks/CallingJdoPredelete.java 100664 13530 12500110374 27670 0 ustar mbouschen staff 0 0 /*
* 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.api.instancecallbacks;
import javax.jdo.JDOException;
import javax.jdo.JDOUserException;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.instancecallbacks.InstanceCallbackClass;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Calling JDO Predelete
*Keywords: instancecallbacks
*Assertion ID: A10.4-1.
*Assertion Description:
jdoPreDelete() is called during the execution of
deletePersistent before the state transition to persistent-deleted
or persistent-new-deleted.
*/
/*
* Use the same PersistenceCapable class and objects as in the test AccessingFieldsInPredelete (but the
* referenced object and Set need not be created).
*
* Delete one such new persistent, one persistent clean and one persistent dirty object.
*
* For each of these objects:
* determine jdoPredelete is called after deletePersistent is called
* determine jdoPredelete is called before statements after deletePersistent is called.
* determine that in jdoPredelete, the state of the object is persistent-new, persistent-clean, or persistent-dirty
* (appropriately).
* determine that the state of the object after return from deletePersistent is persistent-deleted or
* persitent-new-deleted (appropriately).
*
*/
public class CallingJdoPredelete extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A10.4-1 (CallingJdoPredelete) failed";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(CallingJdoPredelete.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
addTearDownClass(InstanceCallbackClass.class);
}
/** */
public void test() throws Exception
{
pm = getPM();
Transaction t = pm.currentTransaction();
InstanceCallbackClass.initializeStaticsForTest();
InstanceCallbackClass.performPreDeleteTests = true; // enabling PreDelete tests
t.begin();
InstanceCallbackClass a = new InstanceCallbackClass(null, null, 1, 1.0, (short)-1, '1', null);
InstanceCallbackClass b = new InstanceCallbackClass(null, null, 2, 2.0, (short)-1, '2', null);
pm.makePersistent(a);
pm.makePersistent(b);
Object aId = pm.getObjectId(a);
Object bId = pm.getObjectId(b);
t.commit();
t.begin();
try {
a = (InstanceCallbackClass)pm.getObjectById(aId, true);
} catch (JDOUserException e) {
fail(ASSERTION_FAILED, "CallingJdoPredelete: Failed to find object a created in previous transaction, got JDOUserException " + e);
return;
}
try {
b = (InstanceCallbackClass)pm.getObjectById(bId, true);
} catch (JDOException e) {
fail(ASSERTION_FAILED, "CallingJdoPredelete: Failed to find object b created in previous transaction, got JDOUserException " + e);
return;
}
int getfld = a.intValue; // cause instance to be persistent-clean
int getfld2 = a.childToDelete;
b.childToDelete++; // make second object dirty
InstanceCallbackClass c = new InstanceCallbackClass(null, null, 3, 3.0, (short)-1, '3', null);
pm.makePersistent(c); // create persistent-new object
InstanceCallbackClass.preDeleteCalled = false;
pm.deletePersistent(a);
if(!InstanceCallbackClass.preDeleteCalled) {
fail(ASSERTION_FAILED, "jdoPreDelete not called when PERSISTENT_CLEAN object deleted.");
} else {
if(InstanceCallbackClass.objectState == PERSISTENT_DELETED) {
fail(ASSERTION_FAILED, "Error, state was persistent-deleted in jdoPredelete callback");
}
}
InstanceCallbackClass.preDeleteCalled = false;
pm.deletePersistent(b);
if(!InstanceCallbackClass.preDeleteCalled) {
fail(ASSERTION_FAILED, "jdoPreDelete not called when PERSISTENT_DIRTY object deleted.");
} else {
if(InstanceCallbackClass.objectState == PERSISTENT_DELETED) {
fail(ASSERTION_FAILED, "Error, state was persistent-deleted in jdoPredelete callback");
}
}
InstanceCallbackClass.preDeleteCalled = false;
pm.deletePersistent(c);
if(!InstanceCallbackClass.preDeleteCalled) {
fail(ASSERTION_FAILED,"jdoPreDelete not called when PERSISTENT_NEW object deleted.");
} else {
if(InstanceCallbackClass.objectState == PERSISTENT_NEW_DELETED) {
fail(ASSERTION_FAILED, "Error, state was persistent-new-deleted in jdoPredelete callback");
}
}
t.rollback();
pm.close();
pm = null;
}
}
tck/src/java/org/apache/jdo/tck/api/instancecallbacks/CallingJdoPrestore.java 100664 23516 12500110374 27567 0 ustar mbouschen staff 0 0 /*
* 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.api.instancecallbacks;
import javax.jdo.JDODataStoreException;
import javax.jdo.JDOUserException;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.instancecallbacks.InstanceCallbackClass;
import org.apache.jdo.tck.pc.instancecallbacks.InstanceCallbackNonPersistFdsClass;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Calling InstanceCallbacks Prestore Method
*Keywords: instancecallbacks
*Assertion ID: A10.2-1.
*Assertion Description:
The jdoPreStore() method of a class implementing
InstanceCallbacks is called before the values are
stored from the instance to the StateManager.
*/
/*
* Use non-managed and transactional values to construct a persistent attribute value to store in database.
* Check to see this constructed persistent attribute got stored.
*
* jdoPreStore() should have been called when obj1 and obj2 were created.
* jdoPreStore() should have been called again when obj2 was modified.
* jdoPreStore() should not be called a second time on obj1 because it was not modified.
/*
This test is accomplished in three transactions.
1) object1 and object2 are created. At commit, we expect jdoPreStore()
to be called on each and calculate values of persistent attributes from non-presistent attributes.
2) Retrieve object1 and object2 from the database and verify the persistent attributes
have values calculated in the jdoPreStore()s called in the previous transaction.
Change non-persistent fields in each but only change a persistent field in one of them.
3) Retrieve object1 and object2 from the database and verify that again jdoPreStore()
was called for each in the previous transaction.
*/
public class CallingJdoPrestore extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A10.2-1 (CallingJdoPrestore) failed";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(CallingJdoPrestore.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
addTearDownClass(InstanceCallbackNonPersistFdsClass.class);
}
/** */
public void test() throws Exception
{
pm = getPM();
Transaction t = pm.currentTransaction();
InstanceCallbackClass.initializeStaticsForTest();
InstanceCallbackClass.performPreStoreTests = true;
t.begin();
int expectedIntValue1, expectedIntValue2;
float expectedFloatValue1, expectedFloatValue2;
int origIntValue1 = 10, origIntValue2 = 12;
float origFloatValue1 = 2.5f, origFloatValue2 = -3.0f;
// create two instances
InstanceCallbackNonPersistFdsClass obj1 = new InstanceCallbackNonPersistFdsClass(origFloatValue1, origIntValue1);
pm.makePersistent(obj1);
Object objPtr1 = pm.getObjectId (obj1);
obj1.setNonPersist(5, (char)10, .25, (short)100);
expectedIntValue1 = obj1.calcIntValue();
expectedFloatValue1 = obj1.calcFloatValue();
InstanceCallbackNonPersistFdsClass obj2 = new InstanceCallbackNonPersistFdsClass(origFloatValue2, origIntValue2);
pm.makePersistent(obj2);
Object objPtr2 = pm.getObjectId (obj2);
obj2.setNonPersist(2, (char)125, .1, (short)750);
expectedIntValue2 = obj2.calcIntValue();
expectedFloatValue2 = obj2.calcFloatValue();
t.commit();
t.begin();
// read both objects back in to determine persistent state is as expected.
try {
obj1 = (InstanceCallbackNonPersistFdsClass)pm.getObjectById(objPtr1, true);
checkValues("Object1 created and read back in: ", origIntValue1, expectedIntValue1, obj1.intValue);
checkValues("Object1 created and read back in: ", origFloatValue1, expectedFloatValue1, obj1.floatValue);
origIntValue1 = obj1.intValue;
origFloatValue1 = obj1.floatValue;
obj1.setNonManaged(-1, (char)62);
expectedIntValue1 = obj1.calcIntValue();
expectedFloatValue1 = obj1.calcFloatValue();
} catch (JDOUserException e) {
// could not locate persistent object created in previous transaction
fail(ASSERTION_FAILED, "CallingJdoPrestore: Failed to find object obj1 created in previous transaction, got " + e);
return;
} catch (JDODataStoreException e) {
// could not locate persistent object created in previous transaction
fail(ASSERTION_FAILED, "CallingJdoPrestore: Failed to find object obj1 created in previous transaction, got " + e);
return;
}
try {
obj2 = (InstanceCallbackNonPersistFdsClass)pm.getObjectById(objPtr2, true);
checkValues("Object2 created and read back in: ", origIntValue2, expectedIntValue2, obj2.intValue);
checkValues("Object2 created and read back in: ", origFloatValue2, expectedFloatValue2, obj2.floatValue);
origIntValue2 = obj2.intValue;
origFloatValue2 = obj2.floatValue;
obj2.setNonPersist(12, (char)30, 5.0, (short)137);
expectedIntValue2 = obj2.calcIntValue();
expectedFloatValue2 = obj2.calcFloatValue();
// change obj2 making it persistent dirty (leave obj1 persistent clean).
obj2.incrementIntValue();
} catch (JDOUserException e) {
// could not locate persistent object created in previous transaction
fail(ASSERTION_FAILED, "CallingJdoPrestore: Failed to find object obj2 created in previous transaction, got " + e);
return;
} catch (JDODataStoreException e) {
// could not locate persistent object created in previous transaction
fail(ASSERTION_FAILED, "CallingJdoPrestore: Failed to find object obj2 created in previous transaction, got " + e);
return;
}
t.commit();
t.begin();
// read both objects back in to determine persistent state is as expected.
try {
// obj1 not made dirty, so jdoPreStore() should not have been called.
obj1 = (InstanceCallbackNonPersistFdsClass)pm.getObjectById(objPtr1, true);
checkValues("Object1, did not expect jdoPreStore to be called: ", origIntValue1, origIntValue1, obj1.intValue);
checkValues("Object1, did not expect jdoPreStore to be called: ", origFloatValue1, origFloatValue1, obj1.floatValue);
} catch (JDOUserException e) {
// could not locate persistent object created in previous transaction
fail(ASSERTION_FAILED, "CallingJdoPrestore: Failed to find object obj1 created in previous transaction, got " + e);
return;
} catch (JDODataStoreException e) {
// could not locate persistent object created in previous transaction
fail(ASSERTION_FAILED, "CallingJdoPrestore: Failed to find object obj1 created in previous transaction, got " + e);
return;
}
try {
obj2 = (InstanceCallbackNonPersistFdsClass)pm.getObjectById(objPtr2, true);
checkValues("Object2, expected jdoPreStore() to be called: ", origIntValue2, expectedIntValue2, obj2.intValue);
checkValues("Object2, expected jdoPreStore() to be called: ", origFloatValue2, expectedFloatValue2, obj2.floatValue);
} catch (JDOUserException e) {
// could not locate persistent object created in previous transaction
fail(ASSERTION_FAILED, "CallingJdoPrestore: Failed to find object obj2 created in previous transaction, got " + e);
return;
} catch (JDODataStoreException e) {
// could not locate persistent object created in previous transaction
fail(ASSERTION_FAILED, "CallingJdoPrestore: Failed to find object obj2 created in previous transaction, got " + e);
return;
}
t.rollback();
pm.close();
pm = null;
}
/** */
void checkValues(String title, int origIntValue, int expectedIntValue, int intValue) {
if(expectedIntValue != intValue) {
fail(ASSERTION_FAILED,
title + "Original persistent intValue is " + origIntValue +
", expected " + expectedIntValue +
". Instead intValue is " + intValue);
}
}
/** */
void checkValues(String title, float origFloatValue, float expectedFloatValue, float floatValue) {
if(expectedFloatValue != floatValue) {
fail(ASSERTION_FAILED,
title + "Original persistent floatValue is " + origFloatValue +
", expected " + expectedFloatValue +
". Instead floatVal is " + floatValue);
}
}
}
tck/src/java/org/apache/jdo/tck/api/instancecallbacks/InstanceLifecycleListenerAttach.java 100664 14034 12500110374 32247 0 ustar mbouschen staff 0 0 /*
* 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.api.instancecallbacks;
import java.util.Date;
import javax.jdo.listener.AttachCallback;
import javax.jdo.JDOHelper;
import javax.jdo.listener.InstanceLifecycleEvent;
import javax.jdo.listener.InstanceLifecycleListener;
import javax.jdo.listener.ClearLifecycleListener;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
* Title: Test TestInstanceLifecycleListenerAttach
* Keywords: LifeCycleListener preAttach postAttach
* Assertion IDs: A12.15-13 A12.15-14
* Assertion Description:
* A12.15-13 void preAttach(InstanceLifecycleEvent event);
* This method is called before a detached instance is attached.
* The source instance is the detached instance].
* A12.15-14 void postAttach(InstanceLifecycleEvent event);
* This method is called after a detached instance is attached.
* The source instance is the corresponding persistent instance in the cache;
* the target instance is the detached instance.
*/
public class InstanceLifecycleListenerAttach
extends AbstractInstanceLifecycleListener {
/**
* The InstanceLifecycleListener used for this test
*/
InstanceLifecycleListenerImpl listener =
new InstanceLifecycleListenerAttachImpl();
/** Return the listener.
*/
protected InstanceLifecycleListenerImpl getListener() {
return listener;
}
/**
* The persistent classes used for this test.
*/
private static Class[] persistentClasses = new Class[] {PC.class};
/** Return the persistent classes.
*/
protected Class[] getPersistentClasses() {
return persistentClasses;
}
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(InstanceLifecycleListenerAttach.class);
}
/**
* This test creates a new persistent instance and detaches it.
* The instance is attached in a new transaction, which causes
* the attach callbacks and listeners to be called.
*/
public void testAttach() {
// set up the persistent instance
PC pc = new PC();
getPM();
pm.currentTransaction().begin();
pm.makePersistent(pc);
PC detached = (PC)pm.detachCopy(pc);
detached.listener = listener;
pm.currentTransaction().commit();
pm.currentTransaction().begin();
listener.setExpectedSource(detached);
// makePersistent should cause the attach listeners to be called
PC attached = (PC)pm.makePersistent(detached);
pm.currentTransaction().commit();
// now check the callback and listener were called
listener.verifyCallbacks(ASSERTION13_FAILED, new int[] {
listener.PRE_ATTACH_LISTENER,
listener.PRE_ATTACH_CALLBACK,
listener.POST_ATTACH_LISTENER});
}
/**
* The LifeCycleListener to be registered with the
* PersistenceManager.
*/
private static class InstanceLifecycleListenerAttachImpl
extends InstanceLifecycleListenerImpl {
public void preAttach(InstanceLifecycleEvent event) {
notifyEvent(PRE_ATTACH_LISTENER);
checkEventType(ASSERTION13_FAILED,
InstanceLifecycleEvent.ATTACH, event.getEventType());
checkEventSource(ASSERTION13_FAILED, event.getSource());
}
public void postAttach(InstanceLifecycleEvent event) {
notifyEvent(POST_ATTACH_LISTENER);
checkEventType(ASSERTION14_FAILED,
InstanceLifecycleEvent.ATTACH, event.getEventType());
checkPersistent(ASSERTION14_FAILED + "in postAttach, source ",
event.getSource());
checkTrue(ASSERTION14_FAILED +
"in postAttach, source wasPostAttachCalled() ",
((PC)event.getSource()).wasPostAttachCalled());
checkSame(ASSERTION14_FAILED + "in postAttach, target ",
expectedSource, event.getTarget());
}
}
/** The persistence-capable class that implements the attach callback.
*/
public static class PC implements AttachCallback {
transient InstanceLifecycleListenerImpl listener;
transient boolean postAttachCalled = false;
public boolean wasPostAttachCalled() {
return postAttachCalled;
}
transient Object postAttachObject = null;
public Object getPostAttachObject() {
return postAttachObject;
}
int id;
public PC() {
}
public PC(InstanceLifecycleListenerImpl listener) {
id = counter++;
this.listener = listener;
}
static int counter = (int)(new Date().getTime());
public void jdoPreAttach() {
if (listener != null) {
listener.notifyEvent(listener.PRE_ATTACH_CALLBACK);
}
}
public void jdoPostAttach(Object obj) {
postAttachCalled = true;
postAttachObject = obj;
}
}
}
tck/src/java/org/apache/jdo/tck/api/instancecallbacks/InstanceLifecycleListenerClear.java 100664 12731 12500110374 32073 0 ustar mbouschen staff 0 0 /*
* 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.api.instancecallbacks;
import java.util.Date;
import javax.jdo.listener.ClearCallback;
import javax.jdo.JDOHelper;
import javax.jdo.listener.InstanceLifecycleEvent;
import javax.jdo.listener.InstanceLifecycleListener;
import javax.jdo.listener.ClearLifecycleListener;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
* Title: Test TestInstanceLifecycleListenerClear
* Keywords: LifeCycleListener hollow preClear postClear
* Assertion IDs: A12.15-5 A12.15-6
* Assertion Description:
* A12.15-5 void preClear(InstanceLifecycleEvent event);
* This method is called whenever a persistent instance
* is cleared, for example during afterCompletion. It is called
* before the jdoPreClear method is invoked on the instance.
* A12.15-6 void postClear(InstanceLifecycleEvent event);
* This method is called whenever a persistent instance
* is cleared, for example during afterCompletion. It is called
* after the jdoPreClear method is invoked on the instance and the fields
* have been cleared by the JDO implementation.
*/
public class InstanceLifecycleListenerClear
extends AbstractInstanceLifecycleListener {
/**
* The InstanceLifecycleListener used for this test
*/
InstanceLifecycleListenerImpl listener =
new InstanceLifecycleListenerClearImpl();
/** Return the listener.
*/
protected InstanceLifecycleListenerImpl getListener() {
return listener;
}
/**
* The persistent classes used for this test.
*/
private static Class[] persistentClasses = new Class[] {PC.class};
/** Return the persistent classes.
*/
protected Class[] getPersistentClasses() {
return persistentClasses;
}
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(InstanceLifecycleListenerClear.class);
}
/**
* This test creates a new persistent instance and commits it.
* Since the RetainValues flag is set to false, the persistent
* fields will be cleared, and the pre-clear listener,
* pre-clear callback, and post-clear listener will be called.
*/
public void testClear() {
// set up the persistent instance
PC pc = new PC(listener);
listener.setExpectedSource(pc);
// commit should cause the clear listeners to be called
getPM();
pm.currentTransaction().begin();
pm.currentTransaction().setRetainValues(false);
pm.makePersistent(pc);
pm.currentTransaction().commit();
// now check the callback and listeners were called
listener.verifyCallbacks(ASSERTION5_FAILED, new int[] {
listener.PRE_CLEAR_LISTENER,
listener.PRE_CLEAR_CALLBACK,
listener.POST_CLEAR_LISTENER});
}
/**
* The LifeCycleListener to be registered with the
* PersistenceManager.
*/
private static class InstanceLifecycleListenerClearImpl
extends InstanceLifecycleListenerImpl {
public void preClear(InstanceLifecycleEvent event) {
notifyEvent(PRE_CLEAR_LISTENER);
checkEventType(ASSERTION5_FAILED,
InstanceLifecycleEvent.CLEAR, event.getEventType());
checkEventSource(ASSERTION5_FAILED, event.getSource());
checkPersistent(ASSERTION5_FAILED + " in preClear, ",
expectedSource);
}
public void postClear(InstanceLifecycleEvent event) {
notifyEvent(POST_CLEAR_LISTENER);
checkEventType(ASSERTION6_FAILED,
InstanceLifecycleEvent.CLEAR, event.getEventType());
checkEventSource(ASSERTION6_FAILED, event.getSource());
checkPersistent(ASSERTION6_FAILED + " in postClear, ",
expectedSource);
}
}
/** The persistence-capable class that implements the clear callback.
*/
public static class PC implements ClearCallback {
transient InstanceLifecycleListenerImpl listener;
int id;
public PC() {
}
public PC(InstanceLifecycleListenerImpl listener) {
id = counter++;
this.listener = listener;
}
static int counter = (int)(new Date().getTime());
public void jdoPreClear() {
if (listener != null) {
listener.notifyEvent(listener.PRE_CLEAR_CALLBACK);
}
}
}
}
tck/src/java/org/apache/jdo/tck/api/instancecallbacks/InstanceLifecycleListenerCreate.java 100664 10135 12500110374 32244 0 ustar mbouschen staff 0 0 /*
* 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.api.instancecallbacks;
import javax.jdo.JDOHelper;
import javax.jdo.listener.InstanceLifecycleEvent;
import javax.jdo.listener.InstanceLifecycleListener;
import javax.jdo.listener.AttachLifecycleListener;
import javax.jdo.listener.ClearLifecycleListener;
import javax.jdo.listener.CreateLifecycleListener;
import javax.jdo.listener.DeleteLifecycleListener;
import javax.jdo.listener.DetachLifecycleListener;
import javax.jdo.listener.LoadLifecycleListener;
import javax.jdo.listener.StoreLifecycleListener;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
* Title: Test TestInstanceLifecycleListener
* Keywords: addLifeCycleListener removeLifeCycleListener
* Assertion IDs: A12.15-1
* Assertion Description:
* A12.15-1 void postCreate(InstanceLifecycleEvent event);
* This method is called whenever a persistent instance is created,
* during makePersistent. It is called after the instance transitions
* to persistent-new.
*/
public class InstanceLifecycleListenerCreate
extends AbstractInstanceLifecycleListener {
/**
* The InstanceLifecycleListener used for this test
*/
InstanceLifecycleListenerImpl listener =
new InstanceLifecycleListenerCreateImpl();
/** Return the listener.
*/
protected InstanceLifecycleListenerImpl getListener() {
return listener;
}
/**
* The persistent classes used for this test.
*/
private static Class[] persistentClasses = new Class[] {PCPoint.class};
/** Return the persistent classes.
*/
protected Class[] getPersistentClasses() {
return persistentClasses;
}
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(InstanceLifecycleListenerCreate.class);
}
/** */
public void testCreate() {
// set up the persistent instance
PCPoint point = new PCPoint(12, 15);
listener.setExpectedSource(point);
// makePersistent should cause the create listener to be called
getPM();
pm.currentTransaction().begin();
pm.makePersistent(point);
pm.currentTransaction().commit();
// verify that the listener was called
listener.verifyCallbacks(ASSERTION1_FAILED, new int[] {
listener.POST_CREATE_LISTENER});
}
/**
* The LifeCycleListener class to be registered with the
* PersistenceManager.
*/
private static class InstanceLifecycleListenerCreateImpl
extends InstanceLifecycleListenerImpl {
public void postCreate(InstanceLifecycleEvent event) {
notifyEvent(POST_CREATE_LISTENER);
checkEventType(ASSERTION1_FAILED,
InstanceLifecycleEvent.CREATE, event.getEventType());
checkEventSource(ASSERTION1_FAILED, event.getSource());
checkPersistent(ASSERTION1_FAILED + " in postCreate, ",
expectedSource);
checkNew(ASSERTION1_FAILED + " in postCreate, ",
expectedSource);
}
}
}
tck/src/java/org/apache/jdo/tck/api/instancecallbacks/InstanceLifecycleListenerDelete.java 100664 13124 12500110374 32244 0 ustar mbouschen staff 0 0 /*
* 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.api.instancecallbacks;
import java.util.Date;
import javax.jdo.listener.DeleteCallback;
import javax.jdo.JDOHelper;
import javax.jdo.listener.InstanceLifecycleEvent;
import javax.jdo.listener.InstanceLifecycleListener;
import javax.jdo.listener.DeleteLifecycleListener;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
* Title: Test TestInstanceLifecycleListenerDelete
* Keywords: LifeCycleListener deletePersistent preDelete postDelete
* Assertion IDs: A12.15-7 A12.15-8
* Assertion Description:
* A12.15-7 void preDelete(InstanceLifecycleEvent event);
* This method is called whenever a persistent instance
* is deleted, during deletePersistent. It is called before
* the state transition and before the jdoPreDelete method
* is invoked on the instance.
* A12.15-8 void postDelete(InstanceLifecycleEvent event);
* This method is called whenever a persistent instance
* is deleted, during deletePersistent. It is called
* after the jdoPreDelete method is invoked on the instance
* and after the state transition.
*/
public class InstanceLifecycleListenerDelete
extends AbstractInstanceLifecycleListener {
/**
* The InstanceLifecycleListener used for this test
*/
InstanceLifecycleListenerImpl listener =
new InstanceLifecycleListenerDeleteImpl();
/** Return the listener.
*/
protected InstanceLifecycleListenerImpl getListener() {
return listener;
}
/**
* The persistent classes used for this test.
*/
private static Class[] persistentClasses = new Class[] {PC.class};
/** Return the persistent classes.
*/
protected Class[] getPersistentClasses() {
return persistentClasses;
}
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(InstanceLifecycleListenerDelete.class);
}
/**
* This test creates a new persistent instance, and deletes it.
* The pre-delete listener, pre-delete callback, and post-delete
* listener will be called.
*/
public void testDelete() {
// set up the persistent instance
PC pc = new PC(listener);
listener.setExpectedSource(pc);
// deletePersistent should cause the delete listeners to be called
getPM();
pm.currentTransaction().begin();
pm.makePersistent(pc);
pm.deletePersistent(pc);
pm.currentTransaction().commit();
// now check the callback and listeners were called
listener.verifyCallbacks(ASSERTION7_FAILED, (new int[] {
listener.PRE_DELETE_LISTENER,
listener.PRE_DELETE_CALLBACK,
listener.POST_DELETE_LISTENER}));
}
/**
* The LifeCycleListener to be registered with the
* PersistenceManager.
*/
private static class InstanceLifecycleListenerDeleteImpl
extends InstanceLifecycleListenerImpl {
public void preDelete(InstanceLifecycleEvent event) {
notifyEvent(PRE_DELETE_LISTENER);
checkEventType(ASSERTION7_FAILED,
InstanceLifecycleEvent.DELETE, event.getEventType());
checkEventSource(ASSERTION7_FAILED, event.getSource());
checkPersistent(ASSERTION7_FAILED + " in preDelete, ",
expectedSource);
checkNotDeleted(ASSERTION7_FAILED + " in preDelete, ",
expectedSource);
}
public void postDelete(InstanceLifecycleEvent event) {
notifyEvent(POST_DELETE_LISTENER);
checkEventType(ASSERTION8_FAILED,
InstanceLifecycleEvent.DELETE, event.getEventType());
checkEventSource(ASSERTION8_FAILED, event.getSource());
checkPersistent(ASSERTION8_FAILED + " in postDelete, ",
expectedSource);
checkDeleted(ASSERTION8_FAILED + " in postDelete, ",
expectedSource);
}
}
/** The persistence-capable class that implements the delete callback.
*/
public static class PC implements DeleteCallback {
transient InstanceLifecycleListenerImpl listener;
int id;
public PC() {
}
public PC(InstanceLifecycleListenerImpl listener) {
id = counter++;
this.listener = listener;
}
static int counter = (int)(new Date().getTime());
public void jdoPreDelete() {
if (listener != null) {
listener.notifyEvent(listener.PRE_DELETE_CALLBACK);
}
}
}
}
tck/src/java/org/apache/jdo/tck/api/instancecallbacks/InstanceLifecycleListenerDetach.java 100664 14062 12500110374 32234 0 ustar mbouschen staff 0 0 /*
* 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.api.instancecallbacks;
import java.util.Date;
import javax.jdo.listener.DetachCallback;
import javax.jdo.JDOHelper;
import javax.jdo.listener.InstanceLifecycleEvent;
import javax.jdo.listener.InstanceLifecycleListener;
import javax.jdo.listener.ClearLifecycleListener;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
* Title: Test InstanceLifecycleListenerDetach
* Keywords: LifeCycleListener preDetach postDetach
* Assertion IDs: A12.15-11 A12.15-12
* Assertion Description:
* A12.15-11 void preDetach(InstanceLifecycleEvent event);
* This method is called before a persistent instance is copied
* for detachment.
* A12.15-12 void postDetach(InstanceLifecycleEvent event);
* This method is called whenever a persistent instance is copied
* for detachment.
* The source instance is the detached copy; the target instance
* is the persistent instance.
*/
public class InstanceLifecycleListenerDetach
extends AbstractInstanceLifecycleListener {
/**
* The InstanceLifecycleListener used for this test
*/
InstanceLifecycleListenerImpl listener =
new InstanceLifecycleListenerDetachImpl();
/** Return the listener.
*/
protected InstanceLifecycleListenerImpl getListener() {
return listener;
}
/**
* The persistent classes used for this test.
*/
private static Class[] persistentClasses = new Class[] {PC.class};
/** Return the persistent classes.
*/
protected Class[] getPersistentClasses() {
return persistentClasses;
}
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(InstanceLifecycleListenerLoad.class);
}
/**
* This test creates a new persistent instance and commits it.
* Since the RetainValues flag is set to false, the persistent
* fields will be cleared, and the pre-clear listener,
* pre-clear callback, and post-clear listener will be called.
*/
public void testDetach() {
// set up the persistent instance
PC pc = new PC(listener);
listener.setExpectedSource(pc);
getPM();
pm.currentTransaction().begin();
pm.makePersistent(pc);
// detachCopy should cause the detach listeners to be called
PC detached = (PC)pm.detachCopy(pc);
pm.currentTransaction().commit();
// now check the callback and listener were called
listener.verifyCallbacks(ASSERTION11_FAILED, new int[] {
listener.PRE_DETACH_LISTENER,
listener.PRE_DETACH_CALLBACK,
listener.POST_DETACH_LISTENER});
}
/**
* The LifeCycleListener to be registered with the
* PersistenceManager.
*/
private static class InstanceLifecycleListenerDetachImpl
extends InstanceLifecycleListenerImpl {
public void preDetach(InstanceLifecycleEvent event) {
notifyEvent(PRE_DETACH_LISTENER);
checkEventType(ASSERTION11_FAILED,
InstanceLifecycleEvent.DETACH, event.getEventType());
checkEventSource(ASSERTION11_FAILED, event.getSource());
checkPersistent(ASSERTION11_FAILED + "in preDetach, source ",
event.getSource());
}
public void postDetach(InstanceLifecycleEvent event) {
notifyEvent(POST_DETACH_LISTENER);
checkEventType(ASSERTION12_FAILED,
InstanceLifecycleEvent.DETACH, event.getEventType());
checkSame(ASSERTION12_FAILED + "in postDetach, target ",
expectedSource, event.getTarget());
checkNotPersistent(ASSERTION12_FAILED + "in postDetach, source ",
event.getSource());
checkPersistent(ASSERTION12_FAILED + "in postDetach, target ",
event.getTarget());
checkTrue(ASSERTION12_FAILED +
"in postDetach, source wasPostDetachCalled() ",
((PC)event.getSource()).wasPostDetachCalled());
}
}
/** The persistence-capable class that implements the load callback.
*/
public static class PC implements DetachCallback {
transient InstanceLifecycleListenerImpl listener;
int id;
public PC() {
}
public PC(InstanceLifecycleListenerImpl listener) {
id = counter++;
this.listener = listener;
}
static int counter = (int)(new Date().getTime());
transient boolean postDetachCalled = false;
public boolean wasPostDetachCalled() {
return postDetachCalled;
}
transient Object postDetachObject = null;
public Object getPostDetachObject() {
return postDetachObject;
}
public void jdoPreDetach() {
if (listener != null) {
listener.notifyEvent(listener.PRE_DETACH_CALLBACK);
}
}
public void jdoPostDetach(Object obj) {
postDetachCalled = true;
postDetachObject = obj;
}
}
}
tck/src/java/org/apache/jdo/tck/api/instancecallbacks/InstanceLifecycleListenerDirty.java 100664 11765 12500110374 32146 0 ustar mbouschen staff 0 0 /*
* 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.api.instancecallbacks;
import java.util.Date;
import javax.jdo.JDOHelper;
import javax.jdo.listener.InstanceLifecycleEvent;
import javax.jdo.listener.InstanceLifecycleListener;
import javax.jdo.listener.ClearLifecycleListener;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
* Title: Test InstanceLifecycleListenerDirty
* Keywords: LifeCycleListener preDirty postDirty
* Assertion IDs: A12.15-9 A12.15-10
* Assertion Description:
* A12.15-9 void preDirty(InstanceLifecycleEvent event);
* This method is called whenever a persistent clean instance
* is first made dirty, during an operation that modifies
* the value of a persistent or transactional field. It is called
* before the field value is changed.
* A12.15-10 void postDirty(InstanceLifecycleEvent event);
* This method is called whenever a persistent clean instance
* is first made dirty, during an operation that modifies
* the value of a persistent or transactional field. It is called
* after the field value was changed.
*/
public class InstanceLifecycleListenerDirty
extends AbstractInstanceLifecycleListener {
/**
* The InstanceLifecycleListener used for this test
*/
InstanceLifecycleListenerImpl listener =
new InstanceLifecycleListenerDirtyImpl();
/** Return the listener.
*/
protected InstanceLifecycleListenerImpl getListener() {
return listener;
}
/**
* The persistent classes used for this test.
*/
private static Class[] persistentClasses = new Class[] {PCPoint.class};
/** Return the persistent classes.
*/
protected Class[] getPersistentClasses() {
return persistentClasses;
}
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(InstanceLifecycleListenerDirty.class);
}
/**
* This test creates a new persistent instance and commits it.
* A new transaction is started and a persistent field is modified.
* This will call the dirty listeners.
*/
public void testDirty() {
// set up the persistent instance
PCPoint pc = new PCPoint(100, 200);
listener.setExpectedSource(pc);
// setY should cause the dirty listeners to be called
getPM();
pm.currentTransaction().begin();
pm.makePersistent(pc);
pm.currentTransaction().commit();
pm.currentTransaction().begin();
pc.setY(new Integer(666));
pm.currentTransaction().commit();
// now check the callback and listener were called
listener.verifyCallbacks(ASSERTION10_FAILED, new int[] {
listener.PRE_DIRTY_LISTENER,
listener.POST_DIRTY_LISTENER});
}
/**
* The LifeCycleListener to be registered with the
* PersistenceManager.
*/
private static class InstanceLifecycleListenerDirtyImpl
extends InstanceLifecycleListenerImpl {
public void preDirty(InstanceLifecycleEvent event) {
notifyEvent(PRE_DIRTY_LISTENER);
checkEventType(ASSERTION9_FAILED,
InstanceLifecycleEvent.DIRTY, event.getEventType());
checkEventSource(ASSERTION9_FAILED, event.getSource());
checkPersistent(ASSERTION9_FAILED + " in preDirty, ",
expectedSource);
checkNotDirty(ASSERTION9_FAILED + " in preDirty, ",
expectedSource);
}
public void postDirty(InstanceLifecycleEvent event) {
notifyEvent(POST_DIRTY_LISTENER);
checkEventType(ASSERTION10_FAILED,
InstanceLifecycleEvent.DIRTY, event.getEventType());
checkEventSource(ASSERTION10_FAILED, event.getSource());
checkPersistent(ASSERTION10_FAILED + " in postDirty,",
expectedSource);
checkDirty(ASSERTION9_FAILED + " in postDirty, ",
expectedSource);
}
}
}
tck/src/java/org/apache/jdo/tck/api/instancecallbacks/InstanceLifecycleListenerLoad.java 100664 11447 12500110374 31727 0 ustar mbouschen staff 0 0 /*
* 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.api.instancecallbacks;
import java.util.Date;
import javax.jdo.listener.LoadCallback;
import javax.jdo.JDOHelper;
import javax.jdo.listener.InstanceLifecycleEvent;
import javax.jdo.listener.InstanceLifecycleListener;
import javax.jdo.listener.ClearLifecycleListener;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
* Title: Test InstanceLifecycleListenerLoad
* Keywords: LifeCycleListener postLoad
* Assertion IDs: A12.15-2
* Assertion Description:
* A12.15-2 void postLoad(InstanceLifecycleEvent event);
* This method is called whenever a persistent instance is loaded.
* It is called after the jdoPostLoad method is invoked on the instance.
*/
public class InstanceLifecycleListenerLoad
extends AbstractInstanceLifecycleListener {
/**
* The InstanceLifecycleListener used for this test
*/
InstanceLifecycleListenerImpl listener =
new InstanceLifecycleListenerLoadImpl();
/** Return the listener.
*/
protected InstanceLifecycleListenerImpl getListener() {
return listener;
}
/**
* The persistent classes used for this test.
*/
private static Class[] persistentClasses = new Class[] {PC.class};
/** Return the persistent classes.
*/
protected Class[] getPersistentClasses() {
return persistentClasses;
}
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(InstanceLifecycleListenerLoad.class);
}
/**
* This test creates a new persistent instance and commits it.
* In a new transaction, a value is accessed, which causes the
* instance to be loaded.
*/
public void testLoad() {
// set up the persistent instance
PC pc = new PC(listener);
listener.setExpectedSource(pc);
// field access should cause the load listeners to be called
getPM();
pm.currentTransaction().begin();
pm.currentTransaction().setRetainValues(false);
pm.makePersistent(pc);
pm.currentTransaction().commit();
pm.currentTransaction().begin();
pc.getValue();
pm.currentTransaction().commit();
// now check the callback and listener were called
listener.verifyCallbacks(ASSERTION2_FAILED, new int[] {
listener.POST_LOAD_CALLBACK,
listener.POST_LOAD_LISTENER});
}
/**
* The LifeCycleListener to be registered with the
* PersistenceManager.
*/
private static class InstanceLifecycleListenerLoadImpl
extends InstanceLifecycleListenerImpl {
public void postLoad(InstanceLifecycleEvent event) {
notifyEvent(POST_LOAD_LISTENER);
checkEventType(ASSERTION2_FAILED,
InstanceLifecycleEvent.LOAD, event.getEventType());
checkEventSource(ASSERTION2_FAILED, event.getSource());
checkPersistent(ASSERTION2_FAILED + " in postLoad, ",
expectedSource);
checkNotNew(ASSERTION2_FAILED + " in postLoad, ",
expectedSource);
}
}
/** The persistence-capable class that implements the load callback.
*/
public static class PC implements LoadCallback {
transient InstanceLifecycleListenerImpl listener;
int id;
int value;
public int getValue() {
return value;
}
public PC() {
}
public PC(InstanceLifecycleListenerImpl listener) {
id = counter++;
this.listener = listener;
}
static int counter = (int)(new Date().getTime());
public void jdoPostLoad() {
if (listener != null) {
listener.notifyEvent(listener.POST_LOAD_CALLBACK);
}
}
}
}
tck/src/java/org/apache/jdo/tck/api/instancecallbacks/InstanceLifecycleListenerStore.java 100664 12430 12500110374 32135 0 ustar mbouschen staff 0 0 /*
* 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.api.instancecallbacks;
import java.util.Date;
import javax.jdo.listener.StoreCallback;
import javax.jdo.JDOHelper;
import javax.jdo.listener.InstanceLifecycleEvent;
import javax.jdo.listener.InstanceLifecycleListener;
import javax.jdo.listener.ClearLifecycleListener;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
* Title: Test InstanceLifecycleListenerLoad
* Keywords: LifeCycleListener preStore postStore
* Assertion IDs: A12.15-3 A12.15-4
* Assertion Description:
* A12.15-3 void preStore(InstanceLifecycleEvent event);
* This method is called whenever a persistent instance is stored,
* for example during flush or commit. It is called
* before the jdoPreStore method is invoked on the instance.
* A12.15-4 void postStore(InstanceLifecycleEvent event);
* This method is called whenever a persistent instance is stored,
* for example during flush or commit. It is called
* after the jdoPreStore method is invoked on the instance.
* An object identity for a per?sistent-new instance must have been assigned
* to the instance when this callback is invoked.
*/
public class InstanceLifecycleListenerStore
extends AbstractInstanceLifecycleListener {
/**
* The InstanceLifecycleListener used for this test
*/
InstanceLifecycleListenerImpl listener =
new InstanceLifecycleListenerStoreImpl();
/** Return the listener.
*/
protected InstanceLifecycleListenerImpl getListener() {
return listener;
}
/**
* The persistent classes used for this test.
*/
private static Class[] persistentClasses = new Class[] {PC.class};
/** Return the persistent classes.
*/
protected Class[] getPersistentClasses() {
return persistentClasses;
}
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(InstanceLifecycleListenerStore.class);
}
/**
* This test creates a new persistent instance and commits it.
* The store callback and listeners will be called.
*/
public void testStore() {
// set up the persistent instance
PC pc = new PC(listener);
listener.setExpectedSource(pc);
// commit should cause the store listeners to be called
getPM();
pm.currentTransaction().begin();
pm.makePersistent(pc);
pm.currentTransaction().commit();
// now check the callback and listener were called
listener.verifyCallbacks(ASSERTION2_FAILED, new int[] {
listener.PRE_STORE_LISTENER,
listener.PRE_STORE_CALLBACK,
listener.POST_STORE_LISTENER});
}
/**
* The LifeCycleListener to be registered with the
* PersistenceManager.
*/
private static class InstanceLifecycleListenerStoreImpl
extends InstanceLifecycleListenerImpl {
public void preStore(InstanceLifecycleEvent event) {
notifyEvent(PRE_STORE_LISTENER);
checkEventType(ASSERTION3_FAILED,
InstanceLifecycleEvent.STORE, event.getEventType());
checkEventSource(ASSERTION3_FAILED, event.getSource());
checkPersistent(ASSERTION3_FAILED + " in preStore, ",
expectedSource);
}
public void postStore(InstanceLifecycleEvent event) {
notifyEvent(POST_STORE_LISTENER);
checkEventType(ASSERTION4_FAILED,
InstanceLifecycleEvent.STORE, event.getEventType());
checkEventSource(ASSERTION4_FAILED, event.getSource());
checkPersistent(ASSERTION4_FAILED + " in postStore, ",
expectedSource);
}
}
/** The persistence-capable class that implements the load callback.
*/
public static class PC implements StoreCallback {
transient InstanceLifecycleListenerImpl listener;
int id;
public PC() {
}
public PC(InstanceLifecycleListenerImpl listener) {
id = counter++;
this.listener = listener;
}
static int counter = (int)(new Date().getTime());
public void jdoPreStore() {
if (listener != null) {
listener.notifyEvent(listener.PRE_STORE_CALLBACK);
}
}
}
}
././@LongLink 100644 0 0 155 12500111677 10254 L ustar 0 0 tck/src/java/org/apache/jdo/tck/api/instancecallbacks/ModificationOfNontransactionalNonpersistentFields.java tck/src/java/org/apache/jdo/tck/api/instancecallbacks/ModificationOfNontransactionalNonpersistentFie100664 17273 12500110374 34470 0 ustar mbouschen staff 0 0 /*
* 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.api.instancecallbacks;
import java.util.Iterator;
import javax.jdo.JDODataStoreException;
import javax.jdo.JDOUserException;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.instancecallbacks.InstanceCallbackNonPersistFdsClass;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Modification of Nontransactional Nonpersistent Fields
*Keywords: instancecallbacks
*Assertion ID: A6.4.1-3.
*Assertion Description:
Nontransactional non-persistent fields may be modified during execution of
user-written callbacks defined in interface InstanceCallbacks
at specific points in the life cycle.
*/
/*
* Test jdoPostLoad() by setting values into the non-managed and transactional attriubes.
* This includes creating and populating a collection and initializing a Date.
* Verify those values are set once the object is referenced.
*
* Test jdoPreClear(), jdoPreDelete() & jdoPreStore() by setting values into the nonmanaged and transactional attributes.
* This includes setting a collection and Date to null.
* Verify that no exceptions are thrown.
*/
public class ModificationOfNontransactionalNonpersistentFields extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A6.4.1-3 (ModificationOfNontransactionalNonpersistentFields) failed";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(ModificationOfNontransactionalNonpersistentFields.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
addTearDownClass(InstanceCallbackNonPersistFdsClass.class);
}
/** */
public void test() throws Exception
{
pm = getPM();
Transaction t = pm.currentTransaction();
t.setRetainValues(false);
InstanceCallbackNonPersistFdsClass.initializeStaticsForTest();
t.begin();
// create instance
InstanceCallbackNonPersistFdsClass obj1 = new InstanceCallbackNonPersistFdsClass(1.1f, 1);
pm.makePersistent(obj1);
Object objPtr1 = pm.getObjectId (obj1);
obj1.setNonPersist(1, (char)1, 0, (short)0);
t.commit(); // jdoPreStore() and jdoPreClear() called
t.begin();
try {
obj1 = (InstanceCallbackNonPersistFdsClass)pm.getObjectById(objPtr1, true); // jdoPostLoad() called
} catch (JDOUserException e) {
// could not locate persistent object created in previous transaction
fail(ASSERTION_FAILED, "ModificationOfNontransactionalNonpersistentFields: Could not locate persistent object obj1 created in previous transaction, got " + e);
return;
} catch (JDODataStoreException e) {
// could not locate persistent object created in previous transaction
fail(ASSERTION_FAILED, "ModificationOfNontransactionalNonpersistentFields: Could not locate persistent object obj1 created in previous transaction, got " + e);
return;
}
// check fields set in jdoPostLoad()
if(obj1.i != -10) {
fail(ASSERTION_FAILED, "jdoPostLoad: Value incorrect, obj1.i != -10; it is " + obj1.i);
}
if(obj1.c != '2') {
fail(ASSERTION_FAILED, "jdoPostLoad: Value incorrect, obj1.c != '2'; it is " + obj1.c);
}
if(obj1.d != 30.0) {
fail(ASSERTION_FAILED, "jdoPostLoad: Value incorrect, obj1.d != 30.0; it is " + obj1.d);
}
if(obj1.s != 40) {
fail(ASSERTION_FAILED, "jdoPostLoad: Value incorrect, obj1.s != 40; it is " + obj1.s);
}
if(obj1.loadTime != InstanceCallbackNonPersistFdsClass.savedLoadTime) {
fail(ASSERTION_FAILED,
"jdoPostLoad: Value incorrect, obj1.loadTime != " +
InstanceCallbackNonPersistFdsClass.savedLoadTime +
"; it is " + obj1.loadTime);
}
boolean childrenValueIncorrect = false;
if(obj1.children.size() != 3) {
childrenValueIncorrect = true;
}else {
if(!obj1.children.contains(InstanceCallbackNonPersistFdsClass.member1)) {
childrenValueIncorrect = true;
}
if(!obj1.children.contains(InstanceCallbackNonPersistFdsClass.member2)) {
childrenValueIncorrect = true;
}
if(!obj1.children.contains(InstanceCallbackNonPersistFdsClass.member3)) {
childrenValueIncorrect = true;
}
}
if(childrenValueIncorrect) {
if (debug) {
logger.debug("jdoPostLoad: Value incorrect, obj1.children does not contain the correct String members");
logger.debug("The members should be: " + InstanceCallbackNonPersistFdsClass.member1 + ", " +
InstanceCallbackNonPersistFdsClass.member2 + ", " + InstanceCallbackNonPersistFdsClass.member3);
logger.debug("obj1.children contains " + obj1.children.size() + " members");
if(obj1.children.size() != 0) {
logger.debug("Those members are:");
for(Iterator i = obj1.children.iterator(); i.hasNext();) {
logger.debug((String)i.next());
}
}
}
fail(ASSERTION_FAILED, "jdoPostLoad: Value incorrect, obj1.children does not contain the correct String members");
}
pm.deletePersistent(obj1); // jdoPreDelete() called
t.commit();
// check result of jdoPreStore(), jdoPreClear() and jdoPreDelete()
if (!InstanceCallbackNonPersistFdsClass.preClearCalled) {
fail(ASSERTION_FAILED, "jdoPreClear() never called on obj1");
}
if(!InstanceCallbackNonPersistFdsClass.preStoreCalled) {
fail(ASSERTION_FAILED, "jdoPreStore() never called on obj1");
}
if(!InstanceCallbackNonPersistFdsClass.preDeleteCalled) {
fail(ASSERTION_FAILED, "jdoPreDelete() never called on obj1");
}
if(InstanceCallbackNonPersistFdsClass.exceptions.size() != 0) {
for(int index = 0; index < InstanceCallbackNonPersistFdsClass.exceptions.size(); index++) {
fail(ASSERTION_FAILED,
"" + InstanceCallbackNonPersistFdsClass.callbackCalled.get(index) +
"operation " +
InstanceCallbackNonPersistFdsClass.attributeOpCausingExceptions.get(index) +
" resulted in exception " +
InstanceCallbackNonPersistFdsClass.exceptions.get(index));
}
}
pm.close();
pm = null;
}
}
tck/src/java/org/apache/jdo/tck/api/instancecallbacks/NoAccessToFieldsAfterPredelete.java 100664 14372 12500110374 32001 0 ustar mbouschen staff 0 0 /*
* 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.api.instancecallbacks;
import java.util.Date;
import java.util.HashSet;
import javax.jdo.JDODataStoreException;
import javax.jdo.JDOUserException;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.instancecallbacks.InstanceCallbackClass;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: No Access To Fields After Predelete
*Keywords: instancecallbacks
*Assertion ID: A10.4-3.
*Assertion Description:
Access to field values after a call to jdoPreDelete()
of a class implementing InstanceCallbacks are disallowed.
*/
/*
* Delete a persistent object and new object. While the objects are in state persitent-deleted (or persistent-new-deleted)
* access persistent fields (except do not reference primary key fields).
*
* Verify the field access results in a JDOUserException.
*/
public class NoAccessToFieldsAfterPredelete extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A10.4-3 (NoAccessToFieldsAfterPredelete) failed";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(NoAccessToFieldsAfterPredelete.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
addTearDownClass(InstanceCallbackClass.class);
}
/** */
public void test() throws Exception
{
pm = getPM();
Transaction t = pm.currentTransaction();
InstanceCallbackClass.initializeStaticsForTest();
t.begin();
// make intValue outside the range of zero to arraySize-1 to skip most jdoPreDelete() code.
InstanceCallbackClass a = new InstanceCallbackClass("object a", null, InstanceCallbackClass.arraySize, 6.0, (short)-1, '6', null);
pm.makePersistent(a);
Object aId = pm.getObjectId(a);
t.commit();
t.begin();
// relocte object.
try {
a = (InstanceCallbackClass)pm.getObjectById(aId, true);
} catch (JDOUserException e) {
fail(ASSERTION_FAILED, "NoAccessToFieldsAfterPredelete: Could not locate persistent object created in previous transaction, got " + e);
return;
} catch (JDODataStoreException e) {
fail(ASSERTION_FAILED, "NoAccessToFieldsAfterPredelete: Could not locate persistent object created in previous transaction, got " + e);
return;
}
pm.deletePersistent(a);
performAccessFieldTests("Object in state persistent-deleted: ", a);
InstanceCallbackClass b = new InstanceCallbackClass("object b", null, InstanceCallbackClass.arraySize + 1, 7.0, (short)-1, '7', null);
pm.makePersistent(b);
pm.deletePersistent(b);
performAccessFieldTests("Object in state persistent-new-deleted: ", b);
t.rollback();
pm.close();
pm = null;
}
/** */
void performAccessFieldTests(String title, InstanceCallbackClass o) {
try {
short x1 = o.childToDelete;
// http://issues.apache.org/jira/browse/JDO-413
// fail(ASSERTION_FAILED, title + "Accessed persistent short field childToDelete--should have gotten JDOUserException");
} catch (JDOUserException e) {
// expected
}
try {
double x2 = o.doubleValue;
// http://issues.apache.org/jira/browse/JDO-413
// fail(ASSERTION_FAILED, title + "Accessed persistent double field doubleValue--should have gotten JDOUserException");
} catch (JDOUserException e) {
// expected
}
try {
char x3 = o.charValue;
// http://issues.apache.org/jira/browse/JDO-413
// fail(ASSERTION_FAILED, title + "Accessed persistent char field charValue--should have gotten JDOUserException");
} catch (JDOUserException e) {
// expected
}
try {
String x4 = o.name;
// http://issues.apache.org/jira/browse/JDO-413
// fail(ASSERTION_FAILED,title + "Accessed persistent String field name--should have gotten JDOUserException");
} catch (JDOUserException e) {
// expected
}
try {
Date x5 = o.timeStamp;
// http://issues.apache.org/jira/browse/JDO-413
// fail(ASSERTION_FAILED, title + "Accessed persistent Date field timeStamp--should have gotten JDOUserException");
} catch (JDOUserException e) {
// expected
}
try {
HashSet x6 = o.children;
// http://issues.apache.org/jira/browse/JDO-413
// fail(ASSERTION_FAILED, title + "Accessed persistent HashSet field Children--should have gotten JDOUserException");
} catch (JDOUserException e) {
// expected
}
try {
InstanceCallbackClass x7 = o.nextObj;
// http://issues.apache.org/jira/browse/JDO-413
// fail(ASSERTION_FAILED, title + "Accessed persistent InstanceCallbackClass reference field nextObj--should have gotten JDOUserException");
} catch (JDOUserException e) {
// expected
}
}
}
tck/src/java/org/apache/jdo/tck/api/instancecallbacks/TestParts.java 100664 15022 12500110374 25757 0 ustar mbouschen staff 0 0 /*
* 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.api.instancecallbacks;
import java.util.Date;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.instancecallbacks.InstanceCallbackClass;
public abstract class TestParts extends JDO_Test {
/** */
public TestParts() {
}
/** */
void checkInstances(String assertion, String label, int intValue, String capturedNextObjName,
int numberOfChildren, int sumOfChildrenIntValue) {
if (InstanceCallbackClass.processedIndex[intValue] != true) {
fail(assertion, label + "Callback never made on object with intValue = " + intValue);
}
if (capturedNextObjName != null &&
InstanceCallbackClass.capturedNextObjName[intValue] == null) {
fail(assertion, label + "nextObj attribute for object with intValue = " +
intValue + " should not have been null.");
} else if (capturedNextObjName == null &&
InstanceCallbackClass.capturedNextObjName[intValue] != null) {
fail(assertion, label + "nextObj attribute for object with intValue = " +
intValue + " should have been null.");
} else if(capturedNextObjName != null &&
!InstanceCallbackClass.capturedNextObjName[intValue].equals(capturedNextObjName)) {
fail(assertion,
label + "nextObj.name attribute for object with intValue = " + intValue +
" should have been \"" + capturedNextObjName + "\". It was \"" +
InstanceCallbackClass.capturedNextObjName[intValue] + "\" instead.");
}
if(InstanceCallbackClass.numberOfChildren[intValue] != numberOfChildren) {
fail(assertion,
label + "Number of instances in attribute children for object with intValue = " +
intValue + " should have been " + numberOfChildren + ". It was " +
InstanceCallbackClass.numberOfChildren[intValue] + " instead.");
}
if(InstanceCallbackClass.sumOfChildrenIntValue[intValue] != sumOfChildrenIntValue) {
fail(assertion,
label + "Sum of intValue of instances in attribute children for object with intValue = " +
intValue + " should have been " + sumOfChildrenIntValue + ". It was " +
InstanceCallbackClass.sumOfChildrenIntValue[intValue] + " instead.");
}
}
/** */
void checkPMAccess(String assertion, String label, int intValue, boolean transactionActive) {
if (InstanceCallbackClass.processedIndex[intValue] != true) {
fail(assertion, label + "Callback never made on object with intValue = " + intValue);
return;
}
// Only verify isActive() returned true for the object if transactionActive is true
if (transactionActive && InstanceCallbackClass.transactionActive[intValue] != true) {
fail(assertion, label + "PersistenceManager.currentTransaction.isAcive() returned false");
}
}
/**
* The attributes are: label, name, date, intValue, doubleValue,
* childToDelete, charValue
*/
void checkFieldValues(String assertion, String label, int intValue,
String name, Date timeStamp, double doubleValue,
short childToDelete, char charValue) {
if (InstanceCallbackClass.processedIndex[intValue] != true) {
fail(assertion, label + "Callback never made on object with intValue = " + intValue);
return;
}
if (!InstanceCallbackClass.capturedName[intValue].equals(name)) {
fail(assertion,
label + "name attribute for object with intValue = " + intValue +
" should be \"" + name + "\". It was \"" +
InstanceCallbackClass.capturedName[intValue] + "\" instead.");
}
if (!InstanceCallbackClass.capturedTimeStamp[intValue].equals(timeStamp)) {
fail(assertion,
label + "timeStamp attribute for object with intValue = " + intValue +
" should be " + timeStamp + ". It was " +
InstanceCallbackClass.capturedTimeStamp[intValue] + " instead.");
}
if (InstanceCallbackClass.capturedDoubleValue[intValue] != doubleValue) {
fail (assertion,
label + "doubleValue attribute for object with intValue = " +
intValue + " should be " + doubleValue + ". It was " +
InstanceCallbackClass.capturedDoubleValue[intValue] + " instead.");
}
if (InstanceCallbackClass.capturedCharValue[intValue] != charValue) {
fail(assertion,
label + "charValue attribute for object with intValue = " +
intValue + " should be " + charValue + ". It was " +
InstanceCallbackClass.capturedCharValue[intValue] + " instead.");
}
if (InstanceCallbackClass.capturedChildToDelete[intValue] != childToDelete) {
fail(assertion,
label + "childToDelete attribute for object with intValue = " +
intValue + " should be " + childToDelete + ". It was " +
InstanceCallbackClass.capturedChildToDelete[intValue] + " instead.");
}
}
/** Touch fields to guarantee that they are loaded into the instance
*/
double touchFields (InstanceCallbackClass o) {
// make a checksum from the fields and return it; this cannot be optimized out...
double rc = o.doubleValue;
rc += o.intValue;
rc += o.charValue;
rc += o.childToDelete;
rc += o.name.length();
rc += o.timeStamp.getTime();
return rc;
}
}
tck/src/java/org/apache/jdo/tck/api/jdohelper/GetObjectId.java 100664 5460 12500110373 24445 0 ustar mbouschen staff 0 0 /*
* 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.api.jdohelper;
import javax.jdo.JDOHelper;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Get Objectid
*Keywords: jdohelper
*Assertion ID: A8.3-1
*Assertion Description:
* The jdohelper.getObjectId method returns an ObjectId instance that represents
* the object identity of the specified JDO Instance. Test: The method
* getObjectById returns the exact same object, evaluating to true when == is used .
*/
/*
* Revision History
* ================
* Author : Date : Version
* Azita Kamangar 9/26/01 1.0
*/
public class GetObjectId extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A8.3-1 (GetObjectId) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(GetObjectId.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
addTearDownClass(PCPoint.class);
}
/* test JDOHelper.getObjectId(Object pc)
*
*/
public void testGetObjectId() {
pm = getPM();
Transaction tx = pm.currentTransaction();
tx.begin();
PCPoint p1 = new PCPoint(1,3);
pm.makePersistent(p1);
Object oid = JDOHelper.getObjectId(p1);
if (oid == null)
fail(ASSERTION_FAILED,
"JDOHelper.getObjectId called for a P_NEW instance returned null ObjectId");
Object p2 = pm.getObjectById(oid, false);
if (p2 != p1)
fail(ASSERTION_FAILED,
"JDOHelper.getObjectBy returned different instance " + p2 + " expected " + p1);
tx.commit();
pm.close();
pm = null;
}
}
tck/src/java/org/apache/jdo/tck/api/jdohelper/GetObjectIdForNull.java 100664 4443 12500110373 25747 0 ustar mbouschen staff 0 0 /*
* 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.api.jdohelper;
import javax.jdo.JDOHelper;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Get Object Id For Null
*Keywords: jdohelper
*Assertion ID: A8.3-4.
*Assertion Description:
The jdohelper.getObjectId method returns null if Object is null.
Evaluating to true when == is used.
*/
/*
* Revision History
* ================
* Author : Date : Version
* Azita Kamangar 9/26/01 1.0
*/
public class GetObjectIdForNull extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A8.3-4 (GetObjectIdForNull) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(GetObjectIdForNull.class);
}
/* test jdohelper.getObjectId(Object pc)
*/
public void testGetObjectIdForNull() {
pm = getPM();
Transaction tx = pm.currentTransaction();
tx.begin();
Object p1 = null;
Object oid = JDOHelper.getObjectId(p1);
tx.commit();
if (oid != null)
fail(ASSERTION_FAILED,
"JDOHelper.getObjectId called for null instance returned non-null ObjectId");
pm.close();
pm = null;
}
}
tck/src/java/org/apache/jdo/tck/api/jdohelper/GetObjectIdForTransient.java 100664 4613 12500110373 27003 0 ustar mbouschen staff 0 0 /*
* 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.api.jdohelper;
import javax.jdo.JDOHelper;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Get Object Id For Transient
*Keywords: jdohelper
*Assertion ID: A8.3-2.
*Assertion Description:
The jdohelper.getObjectId method returns null if Object is a transient.
Evaluating to true when == is used.
*/
/*
* Revision History
* ================
* Author : Date : Version
* Azita Kamangar 9/27/01 1.0
*/
public class GetObjectIdForTransient extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A8.3-2 (GetObjectIdForTransient) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(GetObjectIdForTransient.class);
}
/* test JDOHelper.getObjectId(Object pc)
*
*/
public void testGetObjectIdForTransient() {
pm = getPM();
Transaction tx = pm.currentTransaction();
tx.begin();
PCPoint p1 = new PCPoint(1,3);
Object oid = JDOHelper.getObjectId(p1);
tx.commit();
if (oid != null)
fail(ASSERTION_FAILED,
"JDOHelper.getObjectId called for transient instance returned non-null ObjectId " + oid);
pm.close();
pm = null;
}
}
tck/src/java/org/apache/jdo/tck/api/jdohelper/GetObjectIdNotPersistenceCapable.java 100664 4642 12500110373 30604 0 ustar mbouschen staff 0 0 /*
* 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.api.jdohelper;
import javax.jdo.JDOHelper;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.mylib.Point;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Get Object Id Not Persistence Capable
*Keywords: jdohelper
*Assertion ID: A8.3-3.
*Assertion Description:
The jdohelper.getObjectId method returns null if Object is not persistence capable
*/
/*
* Revision History
* ================
* Author : Date : Version
* Azita Kamangar 9/26/01 1.0
*/
public class GetObjectIdNotPersistenceCapable extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A8.3-3 (GetObjectIdNotPersistenceCapable) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(GetObjectIdNotPersistenceCapable.class);
}
/* test JDOHelper.getObjectId(Object pc)
*
*/
public void testGetObjectIdNotPersistenceCapable() {
pm = getPM();
Transaction tx = pm.currentTransaction();
tx.begin();
Point p1 = new Point(1,3);
Object oid = JDOHelper.getObjectId(p1);
tx.commit();
if (oid != null)
fail(ASSERTION_FAILED,
"JDOHelper.getObjectId called for instance of non-pc class returned non-null ObjectId " + oid);
pm.close();
pm = null;
}
}
tck/src/java/org/apache/jdo/tck/api/jdohelper/GetObjectIds.java 100664 21573 12500110373 24653 0 ustar mbouschen staff 0 0 /*
* 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.api.jdohelper;
import java.util.List;
import java.util.Arrays;
import java.util.Collection;
import java.util.Date;
import java.util.Iterator;
import javax.jdo.JDOHelper;
import javax.jdo.PersistenceManager;
import javax.jdo.identity.SingleFieldIdentity;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.pc.singlefieldidentity.PCPointSingleFieldInteger;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Test GetObjectIds
*Keywords: getObjectIds getObjectId
*Assertion IDs: A8.3-11
*Assertion Description:
* These methods return the JDO identities of the parameter instances.
* For each instance in the parameter, the getObjectId method is called.
* They return one identity instance for each persistence-capable instance
* in the parameter. The order of iteration of the returned Collection
* exactly matches the order of iteration of the parameter Collection.]
*/
public class GetObjectIds extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A8.3-11 (GetObjectIds) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(GetObjectIds.class);
}
/** The parameter objects
*/
Object obj0;
Object obj1;
Object obj2;
Object obj3;
Object obj4;
Object[] objs;
/** The object ids
*/
Object oid0;
Object oid1;
Object oid2;
Object oid3;
Object oid4;
Object[] oids;
/** Typed objects
*/
PCPointSingleFieldInteger singleFieldIdentityObj0;
PCPointSingleFieldInteger singleFieldIdentityObj1;
PCPointSingleFieldInteger[] singleFieldIdentityObjs;
/** Typed object ids
*/
SingleFieldIdentity singleFieldIdentityOid0;
SingleFieldIdentity singleFieldIdentityOid1;
SingleFieldIdentity[] singleFieldIdentityOids;
/** The second persistence manager.
*/
PersistenceManager pm2;
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
addTearDownClass(PCPoint.class);
objs = new Object[] {
obj0 = null,
obj1 = new Date(),
obj2 = new PCPoint(23,45), // persistent in pm1
obj3 = new PCPoint(26,47), // persistent in pm2
obj4 = new PCPoint(23,45) // not persistent
};
singleFieldIdentityObjs = new PCPointSingleFieldInteger[] {
singleFieldIdentityObj0 = new PCPointSingleFieldInteger(0, 1), // persistent in pm1
singleFieldIdentityObj1 = new PCPointSingleFieldInteger(1, 1) // persistent in pm1
};
getPM();
pm.currentTransaction().begin();
pm.makePersistent(obj2);
if (runsWithApplicationIdentity()) {
pm.makePersistent(singleFieldIdentityObj0);
pm.makePersistent(singleFieldIdentityObj1);
}
pm.currentTransaction().commit();
pm2 = getPMF().getPersistenceManager();
pm2.currentTransaction().begin();
pm2.makePersistent(obj3);
pm2.currentTransaction().commit();
oids = new Object[] {
oid0 = JDOHelper.getObjectId(obj0),
oid1 = JDOHelper.getObjectId(obj1),
oid2 = JDOHelper.getObjectId(obj2),
oid3 = JDOHelper.getObjectId(obj3),
oid4 = JDOHelper.getObjectId(obj4),
};
singleFieldIdentityOids = new SingleFieldIdentity[] {
singleFieldIdentityOid0 = (SingleFieldIdentity)JDOHelper.getObjectId(singleFieldIdentityObj0),
singleFieldIdentityOid1 = (SingleFieldIdentity)JDOHelper.getObjectId(singleFieldIdentityObj1)
};
}
/**
* @see JDO_Test#localTearDown()
*/
protected void localTearDown() {
pm2.close();
}
/** */
public void testGetObjectIdsArray() {
StringBuffer messages = new StringBuffer();
Object[] expectedArray = oids;
Object[] actualArray = JDOHelper.getObjectIds(objs);
for (int i = 0; i < objs.length; ++i) {
Object expected = expectedArray[i];
Object actual = actualArray[i];
if (expected == null?
actual != null:
!expected.equals(actual)) {
messages.append(
"\nComparison failed for object ids at position " + i +
"\nexpected: " + expected +
"\nactual: " + actual);
}
}
if (messages.length() != 0) {
fail(ASSERTION_FAILED + "getObjectIds(Object[] pcs) " +
messages.toString());
}
}
/** */
public void testGetObjectIdsCollection() {
StringBuffer messages = new StringBuffer();
List paramList = Arrays.asList(objs);
List expectedList = Arrays.asList(oids);
Collection actualCollection = JDOHelper.getObjectIds(paramList);
Iterator expectedIterator = expectedList.iterator();
Iterator actualIterator = actualCollection.iterator();
for (int i = 0; i < objs.length; ++i) {
Object expected = expectedIterator.next();
Object actual = actualIterator.next();
if (expected == null?
actual != null:
!expected.equals(actual)) {
messages.append(
"\nComparison failed for object ids at position " + i +
"\nexpected: " + expected +
"\nactual: " + actual);
}
}
if (messages.length() != 0) {
fail(ASSERTION_FAILED + "getObjectIds(Collection pcs) " +
messages.toString());
}
}
/** */
public void testTypedGetObjectIdsArray() {
if (!runsWithApplicationIdentity()) return;
StringBuffer messages = new StringBuffer();
Object[] expectedArray = singleFieldIdentityOids;
Object[] actualArray = JDOHelper.getObjectIds(singleFieldIdentityObjs);
for (int i = 0; i < singleFieldIdentityObjs.length; ++i) {
Object expected = expectedArray[i];
Object actual = actualArray[i];
if (expected == null?
actual != null:
!expected.equals(actual)) {
messages.append(
"\nComparison failed for object ids at position " + i +
"\nexpected: " + expected +
"\nactual: " + actual);
}
}
if (messages.length() != 0) {
fail(ASSERTION_FAILED + "getObjectIds(Object[] pcs) " +
messages.toString());
}
}
/** */
public void testTypedGetObjectIdsCollection() {
if (!runsWithApplicationIdentity()) return;
StringBuffer messages = new StringBuffer();
List paramList = Arrays.asList(singleFieldIdentityObjs);
List expectedList = Arrays.asList(singleFieldIdentityOids);
Collection actualCollection = JDOHelper.getObjectIds(paramList);
Iterator expectedIterator = expectedList.iterator();
Iterator actualIterator = actualCollection.iterator();
for (int i = 0; i < singleFieldIdentityObjs.length; ++i) {
Object expected = expectedIterator.next();
Object actual = actualIterator.next();
if (expected == null?
actual != null:
!expected.equals(actual)) {
messages.append(
"\nComparison failed for object ids at position " + i +
"\nexpected: " + expected +
"\nactual: " + actual);
}
}
if (messages.length() != 0) {
fail(ASSERTION_FAILED + "getObjectIds(Collection pcs) " +
messages.toString());
}
}
}
tck/src/java/org/apache/jdo/tck/api/jdohelper/GetPersistenceManager.java 100664 5540 12500110373 26540 0 ustar mbouschen staff 0 0 /*
* 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.api.jdohelper;
import javax.jdo.JDOHelper;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Get Persistence Manager
*Keywords: jdohelper
*Assertion ID: A8.1-1.
*Assertion Description:
The jdohelper.getPersistenceManager method returns associated persistence manager
if the object parameter is not null and implements persistenceCapable.
evaluating to true when == is used.
*/
/*
* Revision History
* ================
* Author : Date : Version
* Azita Kamangar 9/26/01 1.0
*/
public class GetPersistenceManager extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A8.1-1 (GetPersistenceManager) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(GetPersistenceManager.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
addTearDownClass(PCPoint.class);
}
/* test jdohelper.getPersistenceManager(Object pc)
*
*/
public void testGetPersistenceManager() {
pm = getPM();
Transaction tx = pm.currentTransaction();
tx.begin();
PCPoint p1 = new PCPoint(1,3);
pm.makePersistent(p1);
PersistenceManager pm1= JDOHelper.getPersistenceManager(p1);
tx.commit();
if (pm1 == null)
fail(ASSERTION_FAILED,
"JDOHelper.getPersistenceManager returns null for persistent instance");
if (pm1 != pm)
fail(ASSERTION_FAILED,
"JDOHelper.getPersistenceManager returns wrong pm " + pm1 +
", expected " + pm);
pm.close();
pm = null;
}
}
tck/src/java/org/apache/jdo/tck/api/jdohelper/GetPersistenceManagerForNull.java 100664 4564 12500110373 30047 0 ustar mbouschen staff 0 0 /*
* 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.api.jdohelper;
import javax.jdo.JDOHelper;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Get Persistence Manager For Null
*Keywords: jdohelper
*Assertion ID: A8.1-4.
*Assertion Description:
The jdohelper.getPersistenceManager method returns null if Object is null.
Evaluating to true when == is used.
*/
/*
* Revision History
* ================
* Author : Date : Version
* Azita Kamangar 9/27/01 1.0
*/
public class GetPersistenceManagerForNull extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A8.1-4 (GetPersistenceManagerForNull) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(GetPersistenceManagerForNull.class);
}
/** */
public void testGetPersistenceManagerForNull() {
pm = getPM();
Transaction tx = pm.currentTransaction();
tx.begin();
Object p1 = null;
PersistenceManager pm1 = JDOHelper.getPersistenceManager(p1);
tx.commit();
if (pm1 != null)
fail(ASSERTION_FAILED,
"JDOHelper.getPersistenceManager with argument null returned non-null pm " + pm1);
pm.close();
pm = null;
}
}
tck/src/java/org/apache/jdo/tck/api/jdohelper/GetPersistenceManagerForTransient.java 100664 4764 12500110373 31106 0 ustar mbouschen staff 0 0 /*
* 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.api.jdohelper;
import javax.jdo.JDOHelper;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Get Persistence Manager For Transien
*Keywords: jdohelper
*Assertion ID: A8.1-2.
*Assertion Description:
The jdohelper.getPersistenceManager method returns null if object is transient
evaluating to true when == is used.
*/
/*
* Revision History
* ================
* Author : Date : Version
* Azita Kamangar 9/28/01 1.0
*/
public class GetPersistenceManagerForTransient extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A8.1-2 (GetPersistenceManagerForTransient) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(GetPersistenceManagerForTransient.class);
}
/* test jdohelper.getPersistenceManager(Object transient)
*/
public void testGetPersistenceManagerForTransient() {
pm = getPM();
Transaction tx = pm.currentTransaction();
tx.begin();
PCPoint p1 = new PCPoint(1,3);
tx.commit();
PersistenceManager pm1 = JDOHelper.getPersistenceManager(p1);
if (pm1 != null)
fail(ASSERTION_FAILED,
"JDOHelper.getPersistenceManager called for transient instance returned non-null pm " + pm1);
}
}
tck/src/java/org/apache/jdo/tck/api/jdohelper/GetPersistenceManagerNotPersistenceCapable.java 100664 5114 12500110373 32673 0 ustar mbouschen staff 0 0 /*
* 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.api.jdohelper;
import javax.jdo.JDOHelper;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.mylib.Point;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Get Persistence Manager Not Persistence Capable
*Keywords: jdohelper
*Assertion ID: A8.1-3.
*Assertion Description:
The jdohelper.getPersistenceManager method returns null if object is not
persistence capable evaluating to true when == is used.
*/
/*
* Revision History
* ================
* Author : Date : Version
* Azita Kamangar 9/28/01 1.0
*/
public class GetPersistenceManagerNotPersistenceCapable extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A8.1-3 (GetPersistenceManagerNotPersistenceCapable) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(GetPersistenceManagerNotPersistenceCapable.class);
}
/* test jdohelper.getPersistenceManager(Object pc)
*
*/
public void testGetPersistenceManagerNotPersistenceCapable() {
pm = getPM();
Transaction tx = pm.currentTransaction();
tx.begin();
Point p1 = new Point(1,3);
tx.commit();
PersistenceManager pm1 = JDOHelper.getPersistenceManager(p1);
if (pm1 != null)
fail(ASSERTION_FAILED,
"JDOHelper.getPersistenceManager called for instance of non-pc class returned non-null pm " + pm1);
pm.close();
pm = null;
}
}
tck/src/java/org/apache/jdo/tck/api/jdohelper/GetTransactionalObjectId.java 100664 5201 12500110373 27161 0 ustar mbouschen staff 0 0 /*
* 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.api.jdohelper;
import javax.jdo.JDOHelper;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Get Transactional Object Id
*Keywords: jdohelper
*Assertion ID: A8.3-5
*Assertion Description:
If the object parameter implements PersistenceCapable,
JDOHelper.getTransactionalObjectId delegates to the parameter instance and
returns the JDO identity of the instance.
*/
/*
* Revision History
* ================
* Author : Date : Version
* Azita Kamangar 9/26/01 1.0
*/
public class GetTransactionalObjectId extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A8.3-5 (GetTransactionalObjectId) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(GetTransactionalObjectId.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
addTearDownClass(PCPoint.class);
}
/* test JDOHelper.getTransactionalObjectId(Object pc)
*
*/
public void testGetTransactionalObjectId() {
pm = getPM();
Transaction tx = pm.currentTransaction();
tx.begin();
PCPoint p1 = new PCPoint(1,3);
pm.makePersistent(p1);
Object oid = JDOHelper.getTransactionalObjectId(p1);
tx.commit();
if (oid == null)
fail(ASSERTION_FAILED,
"JDOHelper.getTransactionalObjectId returned null oid.");
pm.close();
pm = null;
}
}
tck/src/java/org/apache/jdo/tck/api/jdohelper/GetTransactionalObjectIdForNull.java 100664 4650 12500110373 30472 0 ustar mbouschen staff 0 0 /*
* 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.api.jdohelper;
import javax.jdo.JDOHelper;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Get Transactional Object Id For Null
*Keywords: jdohelper
*Assertion ID: A8.3-8
*Assertion Description:
The jdohelper.getTransactionalObjectIdForNull method returns null if Object is null.Evaluating to true when == is used.
*/
/*
* Revision History
* ================
* Author : Date : Version
* Azita Kamangar 10/1/01 1.0
*/
public class GetTransactionalObjectIdForNull extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A8.3-8 (GetTransactionalObjectIdForNull) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(GetTransactionalObjectIdForNull.class);
}
/* test jdohelper.getTransactionalObjectId(Object pc)
*
*/
public void testGetTransactionalObjectIdForNull() {
pm = getPM();
Transaction tx = pm.currentTransaction();
tx.begin();
Object p1 = null;
Object oid = JDOHelper.getTransactionalObjectId(p1);
tx.commit();
if (oid != null)
fail(ASSERTION_FAILED,
"JDOHelper.getTransactionalObjectId with argument null returned non-null oid " + oid);
pm.close();
pm = null;
}
}
tck/src/java/org/apache/jdo/tck/api/jdohelper/GetTransactionalObjectIdForTransient.java 100664 4772 12500110373 31534 0 ustar mbouschen staff 0 0 /*
* 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.api.jdohelper;
import javax.jdo.JDOHelper;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Get Transactional Object Id For Transient
*Keywords: jdohelper
*Assertion ID: A8.3-6
*Assertion Description:
The jdohelper.getTransactionalObjectIdForTransient method returns null if Object is a transient.Evaluating to true when == is used.
*/
/*
* Revision History
* ================
* Author : Date : Version
* Azita Kamangar 10/1/01 1.0
*/
public class GetTransactionalObjectIdForTransient extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A8.3-6 (GetTransactionalObjectIdForTransient) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(GetTransactionalObjectIdForTransient.class);
}
/* test JDOHelper.getTransactionalObjectId(Object pc)
*
*/
public void testGetTransactionalObjectIdForTransient() {
pm = getPM();
Transaction tx = pm.currentTransaction();
tx.begin();
PCPoint p1 = new PCPoint(1,3);
Object oid = JDOHelper.getTransactionalObjectId(p1);
tx.commit();
if (oid != null)
fail(ASSERTION_FAILED,
"JDOHelper.getTransactionalObjectId called for transiewt instance returned non-null oid " + oid);
pm.close();
pm = null;
}
}
tck/src/java/org/apache/jdo/tck/api/jdohelper/GetTransactionalObjectIdNotPersistenceCapable.java 100664 4770 12500110373 33331 0 ustar mbouschen staff 0 0 /*
* 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.api.jdohelper;
import javax.jdo.JDOHelper;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.mylib.Point;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Get Object Id Not Persistence Capable
*Keywords: jdohelper
*Assertion ID: A8.3-7
*Assertion Description:
The jdohelper.getTransactionalObjectId method returns null if Object is not PC.Evaluating to true when == is used.
*/
/*
* Revision History
* ================
* Author : Date : Version
* Azita Kamangar 10/1/01 1.0
*/
public class GetTransactionalObjectIdNotPersistenceCapable extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A8.3-7 (GetTransactionalObjectIdNotPersistenceCapable) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(GetTransactionalObjectIdNotPersistenceCapable.class);
}
/* test JDOHelper.getTransactionalObjectId(Object pc)
*
*/
public void testGetTransactionalObjectIdNotPersistenceCapable() {
pm = getPM();
Transaction tx = pm.currentTransaction();
tx.begin();
Point p1 = new Point(1,3);
Object oid = JDOHelper.getTransactionalObjectId(p1);
tx.commit();
if (oid != null)
fail(ASSERTION_FAILED,
"JDOHelper.getTransactionalObjectId called for instance of non-pc class returned non-null ObjectId " + oid);
}
}
tck/src/java/org/apache/jdo/tck/api/jdohelper/IsDeleted.java 100664 5056 12500110373 24165 0 ustar mbouschen staff 0 0 /*
* 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.api.jdohelper;
import javax.jdo.JDOHelper;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Is Deleted
*Keywords: jdohelper
*Assertion ID: A8.4.5-1
*Assertion Description:
The jdohelper.isDeleted method returns true if the instance of persistence capable
have been deleted in the current transaction
evaluating to true when == is used.
*/
/*
* Revision History
* ================
* Author : Date : Version
* Azita Kamangar 9/26/01 1.0
*/
public class IsDeleted extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A8.4.5-1 (IsDeleted) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(IsDeleted.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
addTearDownClass(PCPoint.class);
}
/* test jdohelper.isDeleted(Object pc)
*
*/
public void testIsDeleted() {
pm = getPM();
Transaction tx = pm.currentTransaction();
tx.begin();
PCPoint p1 = new PCPoint(1,3);
pm.makePersistent(p1);
pm.deletePersistent(p1);
boolean deleted = JDOHelper.isDeleted(p1);
tx.commit();
if (!deleted)
fail(ASSERTION_FAILED,
"JDOHelper.isDeleted returns false for deleted instance");
pm.close();
pm = null;
}
}
tck/src/java/org/apache/jdo/tck/api/jdohelper/IsDeletedFalse.java 100664 5221 12500110373 25132 0 ustar mbouschen staff 0 0 /*
* 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.api.jdohelper;
import javax.jdo.JDOHelper;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Is Deleted False
*Keywords: jdohelper
*Assertion ID: A8.4.5-2
*Assertion Description:
The object parameter that implements PersistenceCapable, JDOHelper.isDeleted
delegates to the parameter instance and instances that have not been deleted
in the current transaction return false.
evaluating to true when == is used.
*/
/*
* Revision History
* ================
* Author : Date : Version
* Azita Kamangar 9/29/01 1.0
*/
public class IsDeletedFalse extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A8.4.5-2 (IsDeletedFalse) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(IsDeletedFalse.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
addTearDownClass(PCPoint.class);
}
/* test JDOHelper.isDeleted(Object pc)
*
*/
public void testIsDeletedFalse() {
pm = getPM();
Transaction tx = pm.currentTransaction();
tx.begin();
PCPoint p1 = new PCPoint(1,3);
pm.makePersistent(p1);
//pm.deletePersistent(p1);
boolean deleted = JDOHelper.isDeleted(p1);
tx.commit();
if (deleted)
fail(ASSERTION_FAILED,
"JDOHelper.isDeleted returns true for non-deleted instance");
pm.close();
pm = null;
}
}
tck/src/java/org/apache/jdo/tck/api/jdohelper/IsDeletedForNull.java 100664 4465 12500110373 25472 0 ustar mbouschen staff 0 0 /*
* 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.api.jdohelper;
import javax.jdo.JDOHelper;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Is Deleted For Null
*Keywords: jdohelper
*Assertion ID: A8.4.5-5
*Assertion Description:
The jdohelper.isDeleted method returns false for the instance of null,
evaluating to true when == is used.
*/
/*
* Revision History
* ================
* Author : Date : Version
* Azita Kamangar 9/28/01 1.0
*/
public class IsDeletedForNull extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A8.4.5-5 (IsDeletedForNull) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(IsDeletedForNull.class);
}
/* test JDOHelper.IsDeleted(object PC)
*
*/
public void testIsDeletedForNull() {
pm = getPM();
Transaction tx = pm.currentTransaction();
tx.begin();
Object p1 = null;
//pm.deletePersistent(p1);
boolean deleted = JDOHelper.isDeleted(p1);
tx.commit();
if (deleted)
fail(ASSERTION_FAILED,
"JDOHelper.isDeleted with argumnet null returns true.");
pm.close();
pm = null;
}
}
tck/src/java/org/apache/jdo/tck/api/jdohelper/IsDeletedForTransient.java 100664 4544 12500110373 26525 0 ustar mbouschen staff 0 0 /*
* 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.api.jdohelper;
import javax.jdo.JDOHelper;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Is Deleted For Transient
*Keywords: jdohelper
*Assertion ID: A8.4.5-3
*Assertion Description:
The JDOHelper.IsDeleted method returns false if the instance is a transient,
evaluating to true when == is used.
*/
/*
* Revision History
* ================
* Author : Date : Version
* Azita Kamangar 9/26/01 1.0
*/
public class IsDeletedForTransient extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A8.4.5-3 (IsDeletedForTransient) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(IsDeletedForTransient.class);
}
/* test JDOHelper.IsDeleted(Object pc)
*
*/
public void testIsDeletedForTransient() {
pm = getPM();
Transaction tx = pm.currentTransaction();
tx.begin();
PCPoint p1 = new PCPoint(1,3);
boolean deleted = JDOHelper.isDeleted(p1);
tx.commit();
if (deleted)
fail(ASSERTION_FAILED,
"JDOHelper.isDeleted called for transient instance returns true.");
pm.close();
pm = null;
}
}
tck/src/java/org/apache/jdo/tck/api/jdohelper/IsDeletedNotPersistenceCapable.java 100664 4631 12500110373 30321 0 ustar mbouschen staff 0 0 /*
* 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.api.jdohelper;
import javax.jdo.JDOHelper;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.mylib.Point;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Is Deleted Not Persistence Capable
*Keywords: jdohelper
*Assertion ID: A8.4.5-4
*Assertion Description:
The JDOHelper.IsDeleted method returns false if the instance is not persistence
capable , evaluating to true when == is used.
*/
/*
* Revision History
* ================
* Author : Date : Version
* Azita Kamangar 9/26/01 1.0
*/
public class IsDeletedNotPersistenceCapable extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A8.4.5-4 (IsDeletedNotPersistenceCapable) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(IsDeletedNotPersistenceCapable.class);
}
/* test JDOHelper.isDeleted(Object pc)
*
*/
public void testIsDeletedNotPersistenceCapable() {
pm = getPM();
Transaction tx = pm.currentTransaction();
tx.begin();
Point p1 = new Point(1,3);
boolean deleted = JDOHelper.isDeleted(p1);
tx.commit();
if (deleted)
fail(ASSERTION_FAILED,
"JDOHelper.isDeleted called for instance of non-pc class returns true.");
pm.close();
pm = null;
}
}
tck/src/java/org/apache/jdo/tck/api/jdohelper/IsDetached.java 100664 5615 12500110373 24321 0 ustar mbouschen staff 0 0 /*
* 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.api.jdohelper;
import org.apache.jdo.tck.api.persistencemanager.detach.DetachTest;
import org.apache.jdo.tck.pc.shoppingcart.Cart;
import org.apache.jdo.tck.pc.shoppingcart.Undetachable;
import org.apache.jdo.tck.util.BatchTestRunner;
import javax.jdo.JDOHelper;
import javax.jdo.Transaction;
/**
* Title: Test IsDetached
* Keywords:
* Assertion IDs: A8.5.6-1
* Assertion Description:
* Instances that have been detached return true.
* The method returns false if the instance is transient or null or if its class is not detachable.
*/
public class IsDetached extends DetachTest {
private static final String ASSERTION_FAILED = "Assertion A8.5.6-1 JDOHelper.isDetached(Object) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
*
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(IsDetached.class);
}
public void testNullTransientAndUndetachableIsDetachedFalse() {
pm = getPM();
pm.currentTransaction().begin();
assertFalse(ASSERTION_FAILED + "null object is detached", JDOHelper.isDetached(null));
assertFalse(ASSERTION_FAILED + "transient object is detached", JDOHelper.isDetached(new Cart("bob")));
assertFalse(ASSERTION_FAILED + "object of class marked not detachabled is detached", JDOHelper.isDetached(new Undetachable()));
pm.currentTransaction().commit();
}
public void testDetachableIsDetachedTrue() {
pm = getPM();
Transaction txn = pm.currentTransaction();
Cart c, detached;
Object oid;
txn.begin();
{
c = new Cart("bob");
pm.makePersistent(c);
oid = pm.getObjectId(c);
}
txn.commit();
txn.begin();
{
c = (Cart) pm.getObjectById(oid);
detached = (Cart) pm.detachCopy(c);
assertTrue(JDOHelper.isDetached(detached));
}
txn.commit();
}
}
tck/src/java/org/apache/jdo/tck/api/jdohelper/IsDirty.java 100664 4764 12500110373 23717 0 ustar mbouschen staff 0 0 /*
* 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.api.jdohelper;
import javax.jdo.JDOHelper;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Is Dirty
*Keywords: jdohelper
*Assertion ID: A8.4.1-1
*Assertion Description:
The jdohelper.isDirty method returns true if the instance of persistence capable
have changed the state in the current transaction
evaluating to true when == is used.
*/
/*
* Revision History
* ================
* Author : Date : Version
* Azita Kamangar 9/30/01 1.0
*/
public class IsDirty extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A8.4.1-1 (IsDirty) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(IsDirty.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
addTearDownClass(PCPoint.class);
}
/* test JDOHelper.isDeleted(Object pc)
*
*/
public void testIsDirty() {
pm = getPM();
Transaction tx = pm.currentTransaction();
tx.begin();
PCPoint p1 = new PCPoint(1,3);
pm.makePersistent(p1);
boolean dirty = JDOHelper.isDirty(p1);
tx.commit();
if (!dirty)
fail(ASSERTION_FAILED,
"JDOHelper.isDirty returns false for P-NEW instance");
pm.close();
pm = null;
}
}
tck/src/java/org/apache/jdo/tck/api/jdohelper/IsDirtyFalse.java 100664 5210 12500110373 24655 0 ustar mbouschen staff 0 0 /*
* 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.api.jdohelper;
import javax.jdo.JDOHelper;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Is Dirty False
*Keywords: jdohelper
*Assertion ID: A8.4.1-2
*Assertion Description:
The jdohelper.isDirty method returns false if the instance of persistence capable
have not changed the state in the current transaction
evaluating to true when == is used.
*/
/*
* Revision History
* ================
* Author : Date : Version
* Azita Kamangar 9/25/01 1.0
*/
public class IsDirtyFalse extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A8.4.1-2 (IsDirtyFalse) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(IsDirtyFalse.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
addTearDownClass(PCPoint.class);
}
/* test JDOHelper.isDirty(Object pc)
*
*/
public void testIsDirtyFalse() {
pm = getPM();
Transaction tx = pm.currentTransaction();
tx.begin();
PCPoint p1 = new PCPoint(1,3);
pm.makePersistent(p1);
tx.commit();
tx.begin();
// access p1 field to make sure the instance is loaded in new tx
p1.getX();
boolean dirty = JDOHelper.isDirty(p1);
tx.commit();
if (dirty)
fail(ASSERTION_FAILED,
"JDOHelper.isDirty returns true for P-CLEAN instance");
pm.close();
pm = null;
}
}
tck/src/java/org/apache/jdo/tck/api/jdohelper/IsDirtyForNull.java 100664 4374 12500110373 25216 0 ustar mbouschen staff 0 0 /*
* 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.api.jdohelper;
import javax.jdo.JDOHelper;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Is Dirty For Null
*Keywords: jdohelper
*Assertion ID: A8.4.1-5
*Assertion Description:
The jdohelper.isDirty method returns false if the instance is null,
evaluating to true when == is used.
*/
/*
* Revision History
* ================
* Author : Date : Version
* Azita Kamangar 9/27/01 1.0
*/
public class IsDirtyForNull extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A8.4.1-5 (IsDirtyForNull) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(IsDirtyForNull.class);
}
/* test JDOHelper.isDirthy(Object pc)
*
*/
public void testIsDirtyForNull() {
pm = getPM();
Transaction tx = pm.currentTransaction();
tx.begin();
Object p1 = null;
boolean dirty = JDOHelper.isDirty(p1);
tx.commit();
if (dirty)
fail(ASSERTION_FAILED,
"JDOHelper.isDirty with argument null returns true.");
pm.close();
pm = null;
}
}
tck/src/java/org/apache/jdo/tck/api/jdohelper/IsDirtyForTransient.java 100664 4517 12500110373 26252 0 ustar mbouschen staff 0 0 /*
* 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.api.jdohelper;
import javax.jdo.JDOHelper;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Is Dirty For Transient
*Keywords: jdohelper
*Assertion ID: A8.4.1-3
*Assertion Description:
The jdohelper.isDirty method returns false If the instance is transient,
evaluating to true when == is used.
*/
/*
* Revision History
* ================
* Author : Date : Version
* Azita Kamangar 9/28/01 1.0
*/
public class IsDirtyForTransient extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A8.4.1-3 (IsDirtyForTransient) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(IsDirtyForTransient.class);
}
/* test JDOHelper.isDeleted(Object pc)
*
*/
public void testIsDirtyForTransient() {
pm = getPM();
Transaction tx = pm.currentTransaction();
tx.begin();
PCPoint p1 = new PCPoint(1,3);
boolean dirty = JDOHelper.isDirty(p1);
tx.commit();
if (dirty)
fail(ASSERTION_FAILED,
"JDOHelper.isDirty returns true for transient instance");
pm.close();
pm = null;
}
}
tck/src/java/org/apache/jdo/tck/api/jdohelper/IsDirtyNotPersistenceCapable.java 100664 4622 12500110373 30046 0 ustar mbouschen staff 0 0 /*
* 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.api.jdohelper;
import javax.jdo.JDOHelper;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.mylib.Point;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Is Dirty Not Persistence Capable
*Keywords: jdohelper
*Assertion ID: A8.4.1-4
*Assertion Description:
The jdohelper.isDirty method returns false If the instance does not implement PersistenceCapable
evaluating to true when == is used.
*/
/*
* Revision History
* ================
* Author : Date : Version
* Azita Kamangar 9/26/01 1.0
*/
public class IsDirtyNotPersistenceCapable extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A8.4.1-4 (IsDirtyNotPersistenceCapable) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(IsDirtyNotPersistenceCapable.class);
}
/* test JDOHelper.isDeleted(Object pc)
*
*/
public void testIsDirtyNotPersistenceCapable() {
pm = getPM();
Transaction tx = pm.currentTransaction();
tx.begin();
Point p1 = new Point(1,3);
boolean dirty = JDOHelper.isDirty(p1);
tx.commit();
if (dirty)
fail(ASSERTION_FAILED,
"JDOHelper.isDirty returns true for instance of non-pc class.");
pm.close();
pm = null;
}
}
tck/src/java/org/apache/jdo/tck/api/jdohelper/IsNew.java 100664 4727 12500110373 23354 0 ustar mbouschen staff 0 0 /*
* 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.api.jdohelper;
import javax.jdo.JDOHelper;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Is New
*Keywords: jdohelper
*Assertion ID: A8.4.4-1
*Assertion Description:
The jdohelper.isNew method returns true for instances that have
been made persistent in the current transactionthe evaluating to
true when == is used.
*/
/*
* Revision History
* ================
* Author : Date : Version
* Azita Kamangar 10/2/01 1.0
*/
public class IsNew extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A8.4.4-1 (IsNew) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(IsNew.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
addTearDownClass(PCPoint.class);
}
/* test JDOHelper.isNew(Object pc)
*
*/
public void testIsNew() {
pm = getPM();
Transaction tx = pm.currentTransaction();
tx.begin();
PCPoint p1 = new PCPoint(1,3);
pm.makePersistent(p1);
boolean isNew = JDOHelper.isNew(p1);
tx.commit();
if (!isNew)
fail(ASSERTION_FAILED,
"JDOHelper.isNew returns false for P-NEW instance");
pm.close();
pm = null;
}
}
tck/src/java/org/apache/jdo/tck/api/jdohelper/IsNewFalse.java 100664 4661 12500110373 24324 0 ustar mbouschen staff 0 0 /*
* 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.api.jdohelper;
import javax.jdo.JDOHelper;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Is New False
*Keywords: jdohelper
*Assertion ID: A8.4.4-2
*Assertion Description:
The jdohelper.isnew method returns false for the instances that have not
been made persistent in the current transaction
evaluating to true when == is used.
*/
/*
* Revision History
* ================
* Author : Date : Version
* Azita Kamangar 10/2/01 1.0
*/
public class IsNewFalse extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A8.4.4-2 (IsNewFalse) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(IsNewFalse.class);
}
/* test JDOHelper.isNew(Object pc)
*
*/
public void testIsNewFalse() {
pm = getPM();
Transaction tx = pm.currentTransaction();
tx.begin();
PCPoint p1 = new PCPoint(1,3);
tx.commit();
tx.begin();
// access p1 field to make sure the instance is loaded in new tx
p1.getX();
boolean isNew = JDOHelper.isNew(p1);
tx.commit();
if (isNew)
fail(ASSERTION_FAILED,
"JDOHelper.isNew returns true for P-CLEAN instance");
pm.close();
pm = null;
}
}
tck/src/java/org/apache/jdo/tck/api/jdohelper/IsNewForNull.java 100664 4314 12500110373 24646 0 ustar mbouschen staff 0 0 /*
* 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.api.jdohelper;
import javax.jdo.JDOHelper;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Is New For Null
*Keywords: jdohelper
*Assertion ID: A8.4.4-5
*Assertion Description:
The jdohelper.isNew method returns false for the instance which is null,
evaluating to true when == is used.
*/
/*
* Revision History
* ================
* Author : Date : Version
* Azita Kamangar 10/2/01 1.0
*/
public class IsNewForNull extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A8.4.4-5 (IsNewForNull) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(IsNewForNull.class);
}
/* test JDOHelper.isNew(Object pc)
*
*/
public void testIsNewForNull() {
pm = getPM();
Transaction tx = pm.currentTransaction();
tx.begin();
Object p1 = null;
boolean isNew = JDOHelper.isNew(p1);
tx.commit();
if (isNew)
fail(ASSERTION_FAILED,
"JDOHelper.isNew with argument null returns true");
pm.close();
pm = null;
}
}
tck/src/java/org/apache/jdo/tck/api/jdohelper/IsNewForTransient.java 100664 4447 12500110373 25712 0 ustar mbouschen staff 0 0 /*
* 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.api.jdohelper;
import javax.jdo.JDOHelper;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Is New For Transient
*Keywords: jdohelper
*Assertion ID: A8.4.4-3
*Assertion Description:
The jdohelper.isNew method returns false If the instance is transient,
evaluating to true when == is used.
*/
/*
* Revision History
* ================
* Author : Date : Version
* Azita Kamangar 10/2/01 1.0
*/
public class IsNewForTransient extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A8.4.4-3 (IsNewForTransient) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(IsNewForTransient.class);
}
/* test JDOHelper.isNew(Object pc)
*
*/
public void testIsNewForTransient() {
pm = getPM();
Transaction tx = pm.currentTransaction();
tx.begin();
PCPoint p1 = new PCPoint(1,3);
boolean isNew = JDOHelper.isNew(p1);
tx.commit();
if (isNew)
fail(ASSERTION_FAILED,
"JDOHelper.isNew returns true for transient instance");
pm.close();
pm = null;
}
}
tck/src/java/org/apache/jdo/tck/api/jdohelper/IsNewNotPersistenceCapable.java 100664 4610 12500110373 27501 0 ustar mbouschen staff 0 0 /*
* 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.api.jdohelper;
import javax.jdo.JDOHelper;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.mylib.Point;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Is New Not Persistence Capable
*Keywords: jdohelper
*Assertion ID: A8.4.4-4
*Assertion Description:
The jdohelper.isNew method returns false If the instance does not implement PersistenceCapable
evaluating to true when == is used.
*/
/*
* Revision History
* ================
* Author : Date : Version
* Azita Kamangar 10/2/01 1.0
*/
public class IsNewNotPersistenceCapable extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A8.4.4-4 (IsNewNotPersistenceCapable) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(IsNewNotPersistenceCapable.class);
}
/* test JDOHelper.isNew(Object pc)
*
*/
public void testIsNewNotPersistenceCapable() {
pm = getPM();
Transaction tx = pm.currentTransaction();
tx.begin();
Point p1 = new Point(1,3);
boolean isNew = JDOHelper.isNew(p1);
tx.commit();
if (isNew)
fail(ASSERTION_FAILED,
"JDOHelper.isNew returns true for instance of non-pc class.");
pm.close();
pm = null;
}
}
tck/src/java/org/apache/jdo/tck/api/jdohelper/IsPersistent.java 100664 5000 12500110373 24744 0 ustar mbouschen staff 0 0 /*
* 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.api.jdohelper;
import javax.jdo.JDOHelper;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Is Persistent
*Keywords: jdohelper
*Assertion ID: A8.4.3-1
*Assertion Description:
The JDOHelper.isPersistent method returns true if instances represent
persistent objects in the data store
true when == is used.
*/
/*
* Revision History
* ================
* Author : Date : Version
* Azita Kamangar 10/2/01 1.0
*/
public class IsPersistent extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A8.4.3-1 (IsPersistent) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(IsPersistent.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
addTearDownClass(PCPoint.class);
}
/* test JDOHelper.isPersistent(Object pc)
*
*/
public void testIsPersistent() {
pm = getPM();
Transaction tx = pm.currentTransaction();
tx.begin();
PCPoint p1 = new PCPoint(1,3);
pm.makePersistent(p1);
boolean persistent = JDOHelper.isPersistent(p1);
tx.commit();
if (!persistent)
fail(ASSERTION_FAILED,
"JDOHelper.isPersistent returns false for P-NEW instance.");
pm.close();
pm = null;
}
}
tck/src/java/org/apache/jdo/tck/api/jdohelper/IsPersistentFalse.java 100664 4616 12500110373 25733 0 ustar mbouschen staff 0 0 /*
* 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.api.jdohelper;
import javax.jdo.JDOHelper;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Is Persistent False
*Keywords: jdohelper
*Assertion ID: A8.4.3-2
*Assertion Description:
The jdohelper.isPersistent method returns false for instances which do not represent
persistent objects in the data store .
evaluating to true when == is used.
*/
/*
* Revision History
* ================
* Author : Date : Version
* Azita Kamangar 10/2/01 1.0
*/
public class IsPersistentFalse extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A8.4.3-2 (IsPersistentFalse) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(IsPersistentFalse.class);
}
/* test JDOHelper.isPersistent(Object pc)
*
*/
public void testIsPersistentFalse() {
pm = getPM();
Transaction tx = pm.currentTransaction();
tx.begin();
PCPoint p1 = new PCPoint(1,3);
boolean persistent = JDOHelper.isPersistent(p1);
tx.commit();
if (persistent)
fail(ASSERTION_FAILED,
"JDOHelper.isPersistent returns true for transient instance.");
pm.close();
pm = null;
}
}
tck/src/java/org/apache/jdo/tck/api/jdohelper/IsPersistentForNull.java 100664 4435 12500110373 26261 0 ustar mbouschen staff 0 0 /*
* 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.api.jdohelper;
import javax.jdo.JDOHelper;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Is Persistent For Null
*Keywords: jdohelper
*Assertion ID: A8.4.3-5
*Assertion Description:
The jdohelper.isPersistent method returns false for the instance which is null,
evaluating to true when == is used.
*/
/*
* Revision History
* ================
* Author : Date : Version
* Azita Kamangar 10/2/01 1.0
*/
public class IsPersistentForNull extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A8.4.3-5 (IsPersistentForNull) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(IsPersistentForNull.class);
}
/* test JDOHelper.isPersistent(Object pc)
*
*/
public void testIsPersistentForNull() {
pm = getPM();
Transaction tx = pm.currentTransaction();
tx.begin();
Object p1 = null;
boolean persistent = JDOHelper.isPersistent(p1);
tx.commit();
if (persistent)
fail(ASSERTION_FAILED,
"JDOHelper.isPersistent with argumnet null returns true.");
pm.close();
pm = null;
}
}
tck/src/java/org/apache/jdo/tck/api/jdohelper/IsPersistentForTransient.java 100664 4572 12500110373 27320 0 ustar mbouschen staff 0 0 /*
* 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.api.jdohelper;
import javax.jdo.JDOHelper;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Is Persistent For Transient
*Keywords: jdohelper
*Assertion ID: A8.4.3-3
*Assertion Description:
The jdohelper.isPersistent method returns false If the instance is transient,
evaluating to true when == is used.
*/
/*
* Revision History
* ================
* Author : Date : Version
* Azita Kamangar 10/2/01 1.0
*/
public class IsPersistentForTransient extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A8.4.3-3 (IsPersistentForTransient) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(IsPersistentForTransient.class);
}
/* test JDOHelper.isPersistent(Object pc)
*
*/
public void testIsPersistentForTransient() {
pm = getPM();
Transaction tx = pm.currentTransaction();
tx.begin();
PCPoint p1 = new PCPoint(1,3);
boolean persistent = JDOHelper.isPersistent(p1);
tx.commit();
if (persistent)
fail(ASSERTION_FAILED,
"JDOHelper.isPersistent returns true for transient instance.");
pm.close();
pm = null;
}
}
tck/src/java/org/apache/jdo/tck/api/jdohelper/IsPersistentNotPersistenceCapable.java 100664 4671 12500110373 31117 0 ustar mbouschen staff 0 0 /*
* 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.api.jdohelper;
import javax.jdo.JDOHelper;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.mylib.Point;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Is Persistent Not Persistence Capable
*Keywords: jdohelper
*Assertion ID: A8.4.3-4
*Assertion Description:
The jdohelper.isPersistent method returns false If the instance does not implement PersistenceCapable
evaluating to true when == is used.
*/
/*
* Revision History
* ================
* Author : Date : Version
* Azita Kamangar 10/2/01 1.0
*/
public class IsPersistentNotPersistenceCapable extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A8.4.3-4 (IsPersistentNotPersistenceCapable) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(IsPersistentNotPersistenceCapable.class);
}
/* test JDOHelper.isPersistent(Object pc)
*
*/
public void testIsPersistentNotPersistenceCapable() {
pm = getPM();
Transaction tx = pm.currentTransaction();
tx.begin();
Point p1 = new Point(1,3);
boolean persistent = JDOHelper.isPersistent(p1);
tx.commit();
if (persistent)
fail(ASSERTION_FAILED,
"JDOHelper.isPersistent returns false for instance of non-pc class.");
pm.close();
pm = null;
}
}
tck/src/java/org/apache/jdo/tck/api/jdohelper/IsTransactional.java 100664 5577 12500110373 25431 0 ustar mbouschen staff 0 0 /*
* 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.api.jdohelper;
import javax.jdo.JDOHelper;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Is Transactional
*Keywords: jdohelper
*Assertion ID: A8.4.2-1
*Assertion Description:
The jdohelper.isTransactional method returns true and delegates to the parameter instance
and instances whose state is associated with the current transaction . evaluating to true when == is used.
*/
/*
* Revision History
* ================
* Author : Date : Version
* Azita Kamangar 10/4/01 1.0
*/
public class IsTransactional extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A8.4.2-1 (IsTransactional) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(IsTransactional.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
addTearDownClass(PCPoint.class);
}
/* test JDOHelper.IsTransactional(Object pc)
*
*/
public void testIsTransactional() {
pm = getPM();
Transaction tx = pm.currentTransaction();
tx.begin();
PCPoint p1 = new PCPoint(1,3);
pm.makePersistent(p1);
boolean transactional = JDOHelper.isTransactional(p1);
tx.commit();
if (!transactional)
fail(ASSERTION_FAILED,
"JDOHelper.isTransactional returns false for P-NEW instance");
tx.begin();
// check transactional flag in new tx
transactional = JDOHelper.isTransactional(p1);
tx.commit();
if (transactional)
fail(ASSERTION_FAILED,
"JDOHelper.isTransactional returns true for P-HOLLOW/P-NONTX instance");
pm.close();
pm = null;
}
}
tck/src/java/org/apache/jdo/tck/api/jdohelper/IsTransactionalFalse.java 100664 5731 12500110373 26374 0 ustar mbouschen staff 0 0 /*
* 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.api.jdohelper;
import javax.jdo.JDOHelper;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Is Transactional False
*Keywords: jdohelper
*Assertion ID: A8.4.2-2
*Assertion Description:
The jdohelper.isTransactional method returns false and delegates to the parameter
instance and instances whose state is not associated with the current transaction return false.
*/
/*
* Revision History
* ================
* Author : Date : Version
* Azita Kamangar 10/4/01 1.0
*/
public class IsTransactionalFalse extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A8.4.2-2 (IsTransactionalFalse) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(IsTransactionalFalse.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
addTearDownClass(PCPoint.class);
}
/* test JDOHelper.IsTransactionalFalse(Object pc)
*
*/
public void testIsTransactionalFalse() {
pm = getPM();
Transaction tx = pm.currentTransaction();
tx.setOptimistic(false);
tx.begin();
PCPoint p1 = new PCPoint(1,3);
pm.makePersistent(p1);
tx.commit();
tx.begin();
boolean transactional = JDOHelper.isTransactional(p1);
tx.commit();
if (transactional)
fail(ASSERTION_FAILED,
"JDOHelper.isTransactional returns true for P-HOLLOW/P-NONTX instance");
tx.begin();
// access field to make sure the instance is P-CLEAN
p1.getX();
transactional = JDOHelper.isTransactional(p1);
tx.commit();
if (!transactional)
fail(ASSERTION_FAILED,
"JDOHelper.isTransactional returns false for P-CLEAN instance");
pm.close();
pm = null;
}
}
tck/src/java/org/apache/jdo/tck/api/jdohelper/IsTransactionalForNull.java 100664 4446 12500110373 26725 0 ustar mbouschen staff 0 0 /*
* 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.api.jdohelper;
import javax.jdo.JDOHelper;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Is Transactional For Null
*Keywords: jdohelper
*Assertion ID: A8.4.2-5
*Assertion Description:
The jdohelper.isTransactional method returns false, if the instance is null.
*/
/*
* Revision History
* ================
* Author : Date : Version
* Azita Kamangar 10/4/01 1.0
*/
public class IsTransactionalForNull extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A8.4.2-5 (IsTransactionalForNull) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(IsTransactionalForNull.class);
}
/* test JDOHelper.IsTransactionalForNull(Object pc)
*
*/
public void testIsTransactionalForNull() {
pm = getPM();
Transaction tx = pm.currentTransaction();
tx.begin();
Object p1 = null;
boolean transactional = JDOHelper.isTransactional(p1);
tx.commit();
if (transactional)
fail(ASSERTION_FAILED,
"JDOHelper.isTransactional with argument null returns true.");
pm.close();
pm = null;
}
}
tck/src/java/org/apache/jdo/tck/api/jdohelper/IsTransactionalForTransient.java 100664 4631 12500110373 27756 0 ustar mbouschen staff 0 0 /*
* 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.api.jdohelper;
import javax.jdo.JDOHelper;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Is Transactional For Transient
*Keywords: jdohelper
*Assertion ID: A8.4.2-3
*Assertion Description:
The jdohelper.isTransactional method returns false if the instance is transien . evaluating to true when == is used.
*/
/*
* Revision History
* ================
* Author : Date : Version
* Azita Kamangar 10/4/01 1.0
*/
public class IsTransactionalForTransient extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A8.4.2-3 (IsTransactionalForTransient) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(IsTransactionalForTransient.class);
}
/* test JDOHelper.IsTransactionalForTransient(Object pc)
*
*/
public void testIsTransactionalForTransient() {
pm = getPM();
Transaction tx = pm.currentTransaction();
tx.begin();
PCPoint p1 = new PCPoint(1,3);
boolean transactional = JDOHelper.isTransactional(p1);
tx.commit();
if (transactional)
fail(ASSERTION_FAILED,
"JDOHelper.isTransactional returns true for transient instance.");
pm.close();
pm = null;
}
}
tck/src/java/org/apache/jdo/tck/api/jdohelper/IsTransactionalNotPersistenceCapable.java 100664 5000 12500110373 31544 0 ustar mbouschen staff 0 0 /*
* 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.api.jdohelper;
import javax.jdo.JDOHelper;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.mylib.Point;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Is Transactional Not Persistence Capable
*Keywords: jdohelper
*Assertion ID: A8.4.2-4
*Assertion Description:
The jdohelper.isTransactional method returns false If
the instance does not implement PersistenceCapable . evaluating to true when == is used.
*/
/*
* Revision History
* ================
* Author : Date : Version
* Azita Kamangar 10/4/01 1.0
*/
public class IsTransactionalNotPersistenceCapable extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A8.4.2-4 (IsTransactionalNotPersistenceCapable) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(IsTransactionalNotPersistenceCapable.class);
}
/* test JDOHelper.IsTransactionalNotPersistenceCapable(Object pc)
*
*/
public void testIsTransactionalNotPersistenceCapable() {
pm = getPM();
Transaction tx = pm.currentTransaction();
tx.begin();
Point p1 = new Point(1,3);
boolean transactional = JDOHelper.isTransactional(p1);
tx.commit();
if (transactional)
fail(ASSERTION_FAILED,
"JDOHelper.isTransactional returns true for instance of non-pc class.");
pm.close();
pm = null;
}
}
tck/src/java/org/apache/jdo/tck/api/jdohelper/MakeDirty.java 100664 5500 12500110373 24206 0 ustar mbouschen staff 0 0 /*
* 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.api.jdohelper;
import javax.jdo.JDOHelper;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Make Dirty
*Keywords: jdohelper
*Assertion ID: A8.2-1
*Assertion Description:
The jdohelper.makeDirty method delegates to the parameter instance
and marks the specified field dirty if parameter is instance of Persistence
capable . evaluating to true when == is used.
*/
/*
* Revision History
* ================
* Author : Date : Version
* Azita Kamangar 10/2/01 1.0
*/
public class MakeDirty extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A8.2-1 (MakeDirty) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(MakeDirty.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
addTearDownClass(PCPoint.class);
}
/* test JDOHelper.MakeDirty(Object pc)
*
*/
public void testMakeDirty() {
pm = getPM();
Transaction tx = pm.currentTransaction();
tx.begin();
PCPoint p1 = new PCPoint(1,3);
pm.makePersistent(p1);
if (debug) logger.debug(" isDirty1:"+ JDOHelper.isDirty(p1));
tx.commit();
if (debug) logger.debug(" isDirty2:" + JDOHelper.isDirty(p1));
tx.begin();
JDOHelper.makeDirty(p1,"x");
boolean dirty = JDOHelper.isDirty(p1);
tx.commit();
if (debug) logger.debug(" isDirty3:" + dirty);
if (!dirty)
fail(ASSERTION_FAILED,
"Instance is not dirty after calling JDOHelper.makeDirty");
pm.close();
pm = null;
}
}
tck/src/java/org/apache/jdo/tck/api/jdohelper/MakeDirtyForNull.java 100664 4470 12500110373 25515 0 ustar mbouschen staff 0 0 /*
* 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.api.jdohelper;
import javax.jdo.JDOHelper;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Make Dirty For Null
*Keywords: jdohelper
*Assertion ID: A8.2-3
*Assertion Description:
The JDOHelper.makeDirty method has no affect if the instance is null,
evaluating to true when == is used.
*/
/*
* Revision History
* ================
* Author : Date : Version
* Azita Kamangar 9/27/01 1.0
*/
public class MakeDirtyForNull extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A8.2-3 (MakeDirtyForNull) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(MakeDirtyForNull.class);
}
/* test JDOHelper.makeDirthy(Object pc)
*
*/
public void testMakeDirtyForNull() {
pm = getPM();
Transaction tx = pm.currentTransaction();
tx.begin();
Object p1 = null;
JDOHelper.makeDirty(p1,"x");
boolean dirty = JDOHelper.isDirty(p1);
tx.commit();
if (dirty)
fail(ASSERTION_FAILED,
"null instance is dirty after calling JDOHelper.makeDirty.");
pm.close();
pm = null;
}
}
tck/src/java/org/apache/jdo/tck/api/jdohelper/MakeDirtyForTransient.java 100664 5037 12500110373 26552 0 ustar mbouschen staff 0 0 /*
* 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.api.jdohelper;
import javax.jdo.JDOHelper;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Make Dirty For Transient
*Keywords: jdohelper
*Assertion ID: A8.2-2
*Assertion Description:
The JDOHelper.makeDirty method has no affect if the instance is transient,
evaluating to true when == is used.
*/
/*
* Revision History
* ================
* Author : Date : Version
* Azita Kamangar 10/3/01 1.0
*/
public class MakeDirtyForTransient extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A8.2-2 (MakeDirtyForTransient) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(MakeDirtyForTransient.class);
}
/* test JDOHelper.makeDirthy(Object pc)
*
*/
public void testMakeDirtyForTransient() {
pm = getPM();
Transaction tx = pm.currentTransaction();
tx.begin();
PCPoint p1 = new PCPoint(1,2);
if (debug) logger.debug(" isDirty1:"+ JDOHelper.isDirty(p1));
JDOHelper.makeDirty(p1,"x");
if (debug) logger.debug(" isDirty2:"+ JDOHelper.isDirty(p1));
boolean dirty = JDOHelper.isDirty(p1);
tx.commit();
if (dirty)
fail(ASSERTION_FAILED,
"transient instance is dirty after calling JDOHelper.makeDirty.");
pm.close();
pm = null;
}
}
tck/src/java/org/apache/jdo/tck/api/jdohelper/MakeDirtyNotPersistenceCapable.java 100664 4715 12500110373 30353 0 ustar mbouschen staff 0 0 /*
* 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.api.jdohelper;
import javax.jdo.JDOHelper;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.mylib.Point;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Make Dirty Not Persistence Capable
*Keywords: jdohelper
*Assertion ID: A8.2-4
*Assertion Description:
The JDOHelper.makeDirty method has no affect if the instance is not persistence capable
evaluating to true when == is used.
*/
/*
* Revision History
* ================
* Author : Date : Version
* Azita Kamangar 10/3/01 1.0
*/
public class MakeDirtyNotPersistenceCapable extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A8.2-4 (MakeDirtyNotPersistenceCapable) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(MakeDirtyNotPersistenceCapable.class);
}
/* test JDOHelper.makeDirthy(Object pc)
*
*/
public void testMakeDirtyNotPersistenceCapable() {
pm = getPM();
Transaction tx = pm.currentTransaction();
tx.begin();
Point p1 = new Point(1,2);
JDOHelper.makeDirty(p1,"x");
boolean dirty = JDOHelper.isDirty(p1);
tx.commit();
if (dirty)
fail(ASSERTION_FAILED,
"instance of non-pc class is dirty after calling JDOHelper.makeDirty.");
pm.close();
pm = null;
}
}
tck/src/java/org/apache/jdo/tck/api/persistencecapable/AbstractPersistenceCapableTest.java 100664 5067 12500110373 32265 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencecapable;
import javax.jdo.JDOHelper;
import javax.jdo.PersistenceManager;
import javax.jdo.spi.PersistenceCapable;
import org.apache.jdo.tck.JDO_Test;
/**
* This class is the super class for all persistence-capable tests.
* @author Michael Watzek
*/
abstract class AbstractPersistenceCapableTest extends JDO_Test {
/**
* Makes the given object persistent,
* adds it as tear down instance,
* and returns its object id.
* @param pc the transient instance to be made persistent
* @return the object id of the persistent instance
*/
protected Object makePersistent(Object pc) {
addTearDownClass(pc.getClass());
PersistenceManager pm = getPM();
pm.currentTransaction().begin();
pm.makePersistent(pc);
Object result = JDOHelper.getObjectId(pc);
pm.currentTransaction().commit();
return result;
}
protected boolean isTestToBePerformed() {
String testName = getClass().getName();
if (!isBinaryCompatibilitySupported()) {
printUnsupportedOptionalFeatureNotTested(
testName, "javax.jdo.option.BinaryCompatibility");
} else if (!isApplicationIdentitySupported()) {
printUnsupportedOptionalFeatureNotTested(
testName, "javax.jdo.option.ApplicationIdentity");
}
return isBinaryCompatibilitySupported() &&
isApplicationIdentitySupported() &&
runsWithApplicationIdentity();
}
protected void assertPersistenceCapable(Object o) {
if (!(o instanceof PersistenceCapable)) {
throw new IllegalArgumentException
("Argument o must be instance of PersistenceCapable.");
}
}
}
tck/src/java/org/apache/jdo/tck/api/persistencecapable/CopyKeyFieldsFromObjectId.java 100664 26101 12500110373 31157 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencecapable;
import javax.jdo.identity.ByteIdentity;
import javax.jdo.identity.CharIdentity;
import javax.jdo.identity.IntIdentity;
import javax.jdo.identity.LongIdentity;
import javax.jdo.identity.ObjectIdentity;
import javax.jdo.identity.ShortIdentity;
import javax.jdo.identity.SingleFieldIdentity;
import javax.jdo.identity.StringIdentity;
import javax.jdo.spi.PersistenceCapable;
import org.apache.jdo.tck.pc.singlefieldidentity.AbstractPCPointSingleField;
import org.apache.jdo.tck.pc.singlefieldidentity.PCPointSingleFieldByte;
import org.apache.jdo.tck.pc.singlefieldidentity.PCPointSingleFieldCharacter;
import org.apache.jdo.tck.pc.singlefieldidentity.PCPointSingleFieldDate;
import org.apache.jdo.tck.pc.singlefieldidentity.PCPointSingleFieldInteger;
import org.apache.jdo.tck.pc.singlefieldidentity.PCPointSingleFieldLong;
import org.apache.jdo.tck.pc.singlefieldidentity.PCPointSingleFieldPrimitivebyte;
import org.apache.jdo.tck.pc.singlefieldidentity.PCPointSingleFieldPrimitivechar;
import org.apache.jdo.tck.pc.singlefieldidentity.PCPointSingleFieldPrimitiveint;
import org.apache.jdo.tck.pc.singlefieldidentity.PCPointSingleFieldPrimitivelong;
import org.apache.jdo.tck.pc.singlefieldidentity.PCPointSingleFieldPrimitiveshort;
import org.apache.jdo.tck.pc.singlefieldidentity.PCPointSingleFieldShort;
import org.apache.jdo.tck.pc.singlefieldidentity.PCPointSingleFieldString;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: CopyKeyFieldsFromObjectId of PersistenceCapable
*Keywords: persistencecapable
*Assertion IDs: A7.12-25
*Assertion Description:
*
* A7.12-25main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(CopyKeyFieldsFromObjectId .class);
}
public void testSingleFieldIdentitybyte() {
if (isTestToBePerformed()) {
singleFieldIdentity(new PCPointSingleFieldPrimitivebyte(1, 2));
}
}
public void testSingleFieldIdentityByte() {
if (isTestToBePerformed()) {
singleFieldIdentity(new PCPointSingleFieldByte(1, 2));
}
}
public void testSingleFieldIdentitychar() {
if (isTestToBePerformed()) {
singleFieldIdentity(new PCPointSingleFieldPrimitivechar(1, 2));
}
}
public void testSingleFieldIdentityCharacter() {
if (isTestToBePerformed()) {
singleFieldIdentity(new PCPointSingleFieldCharacter(1, 2));
}
}
public void testSingleFieldIdentityint() {
if (isTestToBePerformed()) {
singleFieldIdentity(new PCPointSingleFieldPrimitiveint(1, 2));
}
}
public void testSingleFieldIdentityInteger() {
if (isTestToBePerformed()) {
singleFieldIdentity(new PCPointSingleFieldInteger(1, 2));
}
}
public void testSingleFieldIdentitylong() {
if (isTestToBePerformed()) {
singleFieldIdentity(new PCPointSingleFieldPrimitivelong(1, 2));
}
}
public void testSingleFieldIdentityLong() {
if (isTestToBePerformed()) {
singleFieldIdentity(new PCPointSingleFieldLong(1, 2));
}
}
public void testSingleFieldIdentityshort() {
if (isTestToBePerformed()) {
singleFieldIdentity(new PCPointSingleFieldPrimitiveshort(1, 2));
}
}
public void testSingleFieldIdentityShort() {
if (isTestToBePerformed()) {
singleFieldIdentity(new PCPointSingleFieldShort(1, 2));
}
}
public void testSingleFieldIdentityString() {
if (isTestToBePerformed()) {
singleFieldIdentity(new PCPointSingleFieldString(1, 2));
}
}
public void testSingleFieldIdentityDate() {
if (isTestToBePerformed()) {
singleFieldIdentity(new PCPointSingleFieldDate(1, 2));
}
}
/**
* The common method for test cases checking for assertion A7.12-25:Title: NewObjectIdInstance of PersistenceCapable
*Keywords: persistencecapable
*Assertion IDs: A7.12-38, A7.12-39
*Assertion Description:
*
* A7.12-38:PersistenceCapable.newObjectIdInstance() must be called
* on a persistent instance with its primary key field initialized,
* or a JDONullIdentityException is thrown.
*
* A7.12-39:main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(NewObjectIdInstance.class);
}
public void testSingleFieldIdentityNotInitializedByte() {
if (isTestToBePerformed()) {
singleFieldIdentityNotInitialized(new PCPointSingleFieldByte());
}
}
public void testSingleFieldIdentityNotInitializedCharacter() {
if (isTestToBePerformed()) {
singleFieldIdentityNotInitialized(new PCPointSingleFieldCharacter());
}
}
public void testSingleFieldIdentityNotInitializedInteger() {
if (isTestToBePerformed()) {
singleFieldIdentityNotInitialized(new PCPointSingleFieldInteger());
}
}
public void testSingleFieldIdentityNotInitializedLong() {
if (isTestToBePerformed()) {
singleFieldIdentityNotInitialized(new PCPointSingleFieldLong());
}
}
public void testSingleFieldIdentityNotInitializedShort() {
if (isTestToBePerformed()) {
singleFieldIdentityNotInitialized(new PCPointSingleFieldShort());
}
}
public void testSingleFieldIdentityNotInitializedString() {
if (isTestToBePerformed()) {
singleFieldIdentityNotInitialized(new PCPointSingleFieldString());
}
}
public void testSingleFieldIdentityNotInitializedDate() {
if (isTestToBePerformed()) {
singleFieldIdentityNotInitialized(new PCPointSingleFieldDate());
}
}
public void testSingleFieldIdentityInitializedbyte() {
if (isTestToBePerformed()) {
singleFieldIdentityInitialized(new PCPointSingleFieldPrimitivebyte(1, 2));
}
}
public void testSingleFieldIdentityInitializedByte() {
if (isTestToBePerformed()) {
singleFieldIdentityInitialized(new PCPointSingleFieldByte(1, 2));
}
}
public void testSingleFieldIdentityInitializedchar() {
if (isTestToBePerformed()) {
singleFieldIdentityInitialized(new PCPointSingleFieldPrimitivechar(1, 2));
}
}
public void testSingleFieldIdentityInitializedCharacter() {
if (isTestToBePerformed()) {
singleFieldIdentityInitialized(new PCPointSingleFieldCharacter(1, 2));
}
}
public void testSingleFieldIdentityInitializedint() {
if (isTestToBePerformed()) {
singleFieldIdentityInitialized(new PCPointSingleFieldPrimitiveint(1, 2));
}
}
public void testSingleFieldIdentityInitializedInteger() {
if (isTestToBePerformed()) {
singleFieldIdentityInitialized(new PCPointSingleFieldInteger(1, 2));
}
}
public void testSingleFieldIdentityInitializedlong() {
if (isTestToBePerformed()) {
singleFieldIdentityInitialized(new PCPointSingleFieldPrimitivelong(1, 2));
}
}
public void testSingleFieldIdentityInitializedLong() {
if (isTestToBePerformed()) {
singleFieldIdentityInitialized(new PCPointSingleFieldLong(1, 2));
}
}
public void testSingleFieldIdentityInitializedshort() {
if (isTestToBePerformed()) {
singleFieldIdentityInitialized(new PCPointSingleFieldPrimitiveshort(1, 2));
}
}
public void testSingleFieldIdentityInitializedShort() {
if (isTestToBePerformed()) {
singleFieldIdentityInitialized(new PCPointSingleFieldShort(1, 2));
}
}
public void testSingleFieldIdentityInitializedString() {
if (isTestToBePerformed()) {
singleFieldIdentityInitialized(new PCPointSingleFieldString(1, 2));
}
}
public void testSingleFieldIdentityInitializedDate() {
if (isTestToBePerformed()) {
singleFieldIdentityInitialized(new PCPointSingleFieldDate(1, 2));
}
}
/**
* The common method for test cases checking for assertion A7.12-38:PersistenceCapable.newObjectIdInstance() must be called
* on a persistent instance with its primary key field initialized,
* @param o the object to check
*/
private void singleFieldIdentityNotInitialized(AbstractPCPointSingleField o) {
assertPersistenceCapable(o);
PersistenceCapable pc = (PersistenceCapable) o;
try {
Object sfi = pc.jdoNewObjectIdInstance();
String message = ASSERTION_A7_12_38_FAILED +
"pc.jdoNewObjectIdInstance should throw " +
"JDONullIdentityException if PK field is null, but it returned "+sfi;
fail(message);
} catch (JDONullIdentityException e) {
// expected exception
if (debug)
logger.debug("caught expected exception " + e.toString());
}
}
/**
* The common method for test cases checking for assertion A7.12-39:Title: Calling EvictAll With Collection Containing Nulls
*Keywords: cache
*Assertion IDs: A12.5-11
*Assertion Description:
Passing a non-null Object[] or Collection arguments to evictAll that
contain null elements will have the documented behavior for non-null elements, and the null elements
will be ignored.
*/
public class CallingEvictAllWithCollectionContainingNulls extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.5-11 (CallingEvictAllWithCollectionContainingNulls) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(CallingEvictAllWithCollectionContainingNulls.class);
}
private PCPoint p1;
private PCPoint p2;
private PCPoint p3;
private PCPoint p4;
private PCPoint p5;
/** */
public void testCallingEvictAllWithCollectionContainingNulls() {
pm = getPM();
createObjects(pm);
runTestEvictAll1(pm);
runTestEvictAll2(pm);
pm.close();
pm = null;
}
/** */
private void createObjects(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
p1 = new PCPoint (1,3);
p2 = new PCPoint (4,3);
p3 = new PCPoint (4,2);
p4 = new PCPoint (3,3);
pm.makePersistent(p1);
pm.makePersistent(p2);
pm.makePersistent(p3);
pm.makePersistent(p4);
tx.commit();
}
finally {
if (tx.isActive())
tx.rollback();
}
}
/* test evictAll (Collection col1) */
private void runTestEvictAll1(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
PCPoint p5 = null;
Collection col1 = new java.util.HashSet();
col1.add (p1);
col1.add (p5);
col1.add (p2);
pm.evictAll(col1);
if (debug) logger.debug(" \nPASSED in testEvictAll1()");
}
finally {
if (tx.isActive())
tx.rollback();
}
}
/** test evictAll (Object[] objArray) */
private void runTestEvictAll2(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
PCPoint p5 = null;
Collection col1 = new java.util.HashSet();
col1.add (p3);
col1.add (p4);
col1.add (p5);
pm.evictAll(col1.toArray());
if (debug) logger.debug(" \nPASSED in testEvictAll2()");
}
finally {
if (tx.isActive())
tx.rollback();
}
}
}
././@LongLink 100644 0 0 161 12500111677 10251 L ustar 0 0 tck/src/java/org/apache/jdo/tck/api/persistencemanager/cache/CallingRefreshAllWithCollectionContainingNulls.java tck/src/java/org/apache/jdo/tck/api/persistencemanager/cache/CallingRefreshAllWithCollectionContaini100664 10050 12500110374 34236 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.cache;
import java.util.Collection;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.api.persistencemanager.PersistenceManagerTest;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Calling RefreshAll With Collection Containing Nulls
*Keywords: cache
*Assertion IDs: A12.5-12
*Assertion Description:
Passing a non-null Object[] or Collection arguments to refreshAll that
contain null elements will have the documented behavior for non-null elements, and the null
elements will be ignored.
*/
public class CallingRefreshAllWithCollectionContainingNulls extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.5-12 (CallingRefreshAllWithCollectionContainingNulls) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(CallingRefreshAllWithCollectionContainingNulls.class);
}
private PCPoint p1;
private PCPoint p2;
private PCPoint p3;
private PCPoint p4;
private PCPoint p5;
/** */
public void testCallingRefreshAllWithCollectionContainingNulls() {
pm = getPM();
createObjects(pm);
runTestRefreshAll1(pm);
runTestRefreshAll2(pm);
pm.close();
pm = null;
}
/** */
private void createObjects(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
p1 = new PCPoint (1,3);
p2 = new PCPoint (2,3);
p3 = new PCPoint (4,2);
p4 = new PCPoint (3,3);
pm.makePersistent(p1);
pm.makePersistent(p2);
pm.makePersistent(p3);
pm.makePersistent(p4);
tx.commit();
}
finally {
if (tx.isActive())
tx.rollback();
}
}
/** test refreshAll (Collection col1) */
private void runTestRefreshAll1(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
PCPoint p5 = null;
Collection col1 = new java.util.HashSet();
col1.add (p1);
col1.add (p5);
col1.add (p2);
pm.refreshAll(col1);
if (debug) logger.debug(" \nPASSED in testRefreshAll1()");
tx.rollback();
}
finally {
if (tx.isActive())
tx.rollback();
}
}
/* test refreshAll (Object[] objArray) */
private void runTestRefreshAll2(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
PCPoint p5 = null;
Collection col1 = new java.util.HashSet();
col1.add (p3);
col1.add (p4);
col1.add (p5);
pm.refreshAll(col1.toArray());
if (debug) logger.debug(" \nPASSED in testRefreshAll2()");
tx.rollback();
}
finally {
if (tx.isActive())
tx.rollback();
}
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanager/cache/EvictAllWithNoParameters.java 100664 11257 12500110374 32172 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.cache;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.api.persistencemanager.PersistenceManagerTest;
import org.apache.jdo.tck.pc.mylib.PCPoint2;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: EvictAllWithNoParameters
*Keywords: cache
*Assertion IDs: A12.5.1-2
*Assertion Description:
If PersistenceManager.evict is called with no parameter, then all referenced instances are evicted. For each instance evicted, it:
*
* calls the jdoPreClearmethod on each instance, if the class of the instance implements InstanceCallbacks
* clears persistent fields on each instance after the call to jdoPreClear()
* changes the state of instances to hollow or persistent-nontransactional (cannot distinguish between these two states) this is not directly testable.
*
*/
public class EvictAllWithNoParameters extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.5.1-2 (EvictAllWithNoParameters) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(EvictAllWithNoParameters.class);
}
private PCPoint2 pnt1 = null;
private PCPoint2 p1 = null;
/** */
public void testEvictAllWithNoParameters() {
pm = getPM();
createObjects(pm);
runTestEvictAll(pm);
pm.close();
pm = null;
}
/** */
private void createObjects(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
pnt1 = new PCPoint2(1,3);
p1 = new PCPoint2 (3,5);
pm.makePersistent(pnt1);
pm.makePersistent(p1);
tx.commit();
// P-nontransactional instance
// Check whether pmf supported optimitic tx
tx.setOptimistic(isOptimisticSupported());
tx.begin();
pnt1.getX();
tx.commit();
// P-clean instance
tx.setOptimistic(false);
tx.begin();
p1.getX();
tx.commit();
}
finally {
if (tx.isActive())
tx.rollback();
}
}
/** */
private void runTestEvictAll(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
pm.evictAll();
if ( !p1.wasClearCalled()) {
fail(ASSERTION_FAILED,
"missing call of p1.jdoPreClear during pm.evictAll");
}
if ( !pnt1.wasClearCalled()) {
fail(ASSERTION_FAILED,
"missing call of pnt1.jdoPreClear during pm.evictAll");
}
if ( testState(p1, HOLLOW, "hollow") ||
testState(p1, PERSISTENT_NONTRANSACTIONAL, "persistent_nontransaction")) {
; // expected result
}
else {
fail(ASSERTION_FAILED,
"p1 should be HOLLOW or P-NONTX after pm.evictAll.");
}
if ( testState(pnt1, HOLLOW, "hollow") ||
testState(pnt1, PERSISTENT_NONTRANSACTIONAL, "persistent_nontransaction")) {
; // expected result
}
else {
fail(ASSERTION_FAILED,
"pnt1 should be HOLLOW or P-NONTX after pm.evictAll.");
}
tx.commit();
if (debug) logger.debug(" \nPASSED in testEvictAll()");
}
finally {
if (tx.isActive())
tx.rollback();
}
}
}
././@LongLink 100644 0 0 153 12500111677 10252 L ustar 0 0 tck/src/java/org/apache/jdo/tck/api/persistencemanager/cache/EvictingCollectionOfInstancesSideEffects.java tck/src/java/org/apache/jdo/tck/api/persistencemanager/cache/EvictingCollectionOfInstancesSideEffect100664 15530 12500110374 34233 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.cache;
import java.util.Collection;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.api.persistencemanager.PersistenceManagerTest;
import org.apache.jdo.tck.pc.mylib.PCPoint2;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: EvictingCollectionOfInstancesSideEffects
*Keywords: cache
*Assertion IDs: A12.5.1-4
*Assertion Description:
If PersistenceManager.evict is called with no parameter, then all referenced instances are evicted. For each instance evicted, it:
*
* calls the jdoPreClearmethod on each instance, if the class of the instance implements InstanceCallbacks
* clears persistent fields on each instance after the call to jdoPreClear()
* changes the state of instances to hollow or persistent-nontransactional (cannot distinguish between these two states) this is not directly testable.
*
*/
public class EvictingCollectionOfInstancesSideEffects extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.5.1-4 (EvictingCollectionOfInstancesSideEffects) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(EvictingCollectionOfInstancesSideEffects.class);
}
private PCPoint2 pnt1 = null;
private PCPoint2 pnt2 = null;
private PCPoint2 p1 = null;
private PCPoint2 p2 = null;
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
addTearDownClass(PCPoint2.class);
super.localSetUp();
}
/** */
public void testEvictingCollectionOfInstancesSideEffects() {
pm = getPM();
createObjects(pm);
runTestEvictAllCollection(pm);
runTestEvictAllArray(pm);
pm.close();
pm = null;
}
/** */
private void createObjects(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
pnt1 = new PCPoint2(1,2);
pnt2 = new PCPoint2(2,3);
p1 = new PCPoint2 (3,1);
p2 = new PCPoint2 (4,2);
pm.makePersistent(pnt1);
pm.makePersistent(pnt2);
pm.makePersistent(p1);
pm.makePersistent(p2);
tx.commit();
// P-nontransactional instance
// Check whether pmf supported optimitic tx
tx.setOptimistic(isOptimisticSupported());
tx.begin();
pnt1.getX();
pnt2.getX();
tx.commit();
/* P-clean instance */
tx.setOptimistic(false);
tx.begin();
p1.getX();
p2.getX();
tx.commit();
}
finally {
if (tx.isActive())
tx.rollback();
}
}
/** */
private void runTestEvictAllCollection(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
Collection col1 = new java.util.HashSet();
col1.add(pnt1);
col1.add(p1);
pm.evictAll(col1);
if ( !p1.wasClearCalled()) {
fail(ASSERTION_FAILED,
"missing call of p1.jdoPreClear during pm.evictAll(Collection)");
}
if ( !pnt1.wasClearCalled()) {
fail(ASSERTION_FAILED,
"missing call of pnt1.jdoPreClear during pm.evictAll(Collection)");
}
if ( testState(p1, HOLLOW, "hollow") ||
testState(p1, PERSISTENT_NONTRANSACTIONAL, "persistent_nontransactional")) {
; // expected result
}
else {
fail(ASSERTION_FAILED,
"p1 should be HOLLOW or P-NONTX after pm.evictAll(Collection).");
}
if ( testState(pnt1, HOLLOW, "hollow") ||
testState(pnt1, PERSISTENT_NONTRANSACTIONAL, "persistent_nontransactional")) {
; // expected result
} else {
fail(ASSERTION_FAILED,
"pnt1 should be HOLLOW or P-NONTX after pm.evictAll(Collection).");
}
tx.commit();
}
finally {
if (tx.isActive())
tx.rollback();
}
}
/** */
private void runTestEvictAllArray(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
Collection col1 = new java.util.HashSet();
col1.add(pnt2);
col1.add(p2);
pm.evictAll(col1.toArray());
if ( !p2.wasClearCalled()) {
fail(ASSERTION_FAILED,
"missing call of p2.jdoPreClear during pm.evictAll(Object[])");
}
if ( !pnt2.wasClearCalled()) {
fail(ASSERTION_FAILED,
"missing call of pnt2.jdoPreClear during pm.evictAll(Object[])");
}
if ( testState(p2, HOLLOW, "hollow") ||
testState(p2, PERSISTENT_NONTRANSACTIONAL, "persistent_nontransactional")) {
; // expected result
} else {
fail(ASSERTION_FAILED,
"p2 should be HOLLOW or P-NONTX after pm.evictAll(Object[]).");
}
if ( testState(pnt2, HOLLOW, "hollow") ||
testState(pnt2, PERSISTENT_NONTRANSACTIONAL, "persistent_nontransactional")) {
; // expected result
} else {
fail(ASSERTION_FAILED,
"pnt2 should be HOLLOW or P-NONTX after pm.evictAll(Object[]).");
}
tx.commit();
}
finally {
if (tx.isActive())
tx.rollback();
}
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanager/cache/EvictingWithRestoreValuesFalse.java 100664 11056 12500110374 33412 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.cache;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.api.persistencemanager.PersistenceManagerTest;
import org.apache.jdo.tck.pc.mylib.PCPoint2;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Evicting With RestoreValues False
*Keywords: cache
*Assertion ID: A12.6.1-1.
*Assertion Description:
If users wish to automatically evict transactional instances at transaction
rollback time, then they should set RestoreValues to false.
For each persistent-clean instance that the
JDO PersistenceManager evicts, it:
calls the jdoPreClear method on each instance,
if the class of the instance implements InstanceCallbacks
clears persistent fields on each instance (sets the value of the field to its Java default value)
changes the state of instances to hollow
*/
public class EvictingWithRestoreValuesFalse extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.6.1-1 (EvictingWithRestoreValuesFalse) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(EvictingWithRestoreValuesFalse.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
addTearDownClass(PCPoint2.class);
super.localSetUp();
}
/** */
public void test() {
pm = getPM();
PCPoint2 pt = getHollowInstance();
Transaction tx = pm.currentTransaction();
tx.setRestoreValues(false); //This should cause eviction of transactional instances when transaction is later rolled back.
//Test
tx.begin();
makePersistentClean(pt);
tx.rollback(); // This should evict pt
verify(pt);
}
/** */
private PCPoint2 getHollowInstance() {
Transaction tx = pm.currentTransaction();
tx.begin();
PCPoint2 pt = new PCPoint2(1,2);
pm.makePersistent(pt);
tx.commit();
int curr = currentState(pt);
if (curr != HOLLOW){
fail(ASSERTION_FAILED,
"Unable to create HOLLOW instance, state is " + states[curr]);
}
return pt;
}
/** */
private void makePersistentClean(PCPoint2 pt) {
pm.makeTransactional(pt);
int curr = currentState(pt);
if (curr != PERSISTENT_CLEAN){
fail(ASSERTION_FAILED,
"Unable to create PERSISTENT_CLEAN instance, state is " + states[curr]);
}
}
/** */
private void verify(PCPoint2 pt) {
// When PersistenceManager evicts instances, it: calls the jdoPreClear method on each instance
if ( !pt.wasClearCalled()) {
fail(ASSERTION_FAILED,
"missing call of jdoPreClear");
}
// When PersistenceManager evicts instances, it: changes the state of the instances to hollow
int curr = currentState(pt);
if ( (curr != HOLLOW) && (curr != PERSISTENT_NONTRANSACTIONAL) ) {
fail(ASSERTION_FAILED,
"Instance should be HOLLOW after tx.rollback(), state is " + states[curr]);
}
pm.makeTransient(pt);
// When PersistenceManager evicts instances, it: clears persistent fields on each instance (sets the value of the field to its Java default value)
int x=pt.getX();
Integer y=pt.getY();
if ((x != 0) || (y != null)) {
fail(ASSERTION_FAILED,
"persistent fields not cleared, pt.getX()=="+x+" and pt.getY()=="+y);
}
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanager/cache/EvictingWithRetainValuesFalse.java 100664 11343 12500110374 33210 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.cache;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.api.persistencemanager.PersistenceManagerTest;
import org.apache.jdo.tck.pc.mylib.PCPoint2;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Evicting With RetainValues False
*Keywords: cache
*Assertion ID: A12.5.1-3.
*Assertion Description:
If users wish to automatically evict transactional instances at transaction
commit time, then they should set RetainValues to false.
For each persistent-clean instance that the
JDO PersistenceManager evicts, it:
calls the jdoPreClear method on each instance,
if the class of the instance implements InstanceCallbacks
clears persistent fields on each instance (sets the value of the field to its Java default value)
changes the state of instances to hollow
*/
public class EvictingWithRetainValuesFalse extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.5.1-3 (EvictingWithRetainValuesFalse) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(EvictingWithRetainValuesFalse.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
addTearDownClass(PCPoint2.class);
super.localSetUp();
}
/** */
public void test() {
if (!isRetainValuesSupported()) {
printUnsupportedOptionalFeatureNotTested(
getClass().getName(), "javax.jdo.option.RetainValues");
}
else
{
pm = getPM();
PCPoint2 pt = getHollowInstance();
Transaction tx = pm.currentTransaction();
tx.setRetainValues(false); //This should cause eviction of transactional instances when transaction is later commited.
//Test
tx.begin();
makePersistentClean(pt);
tx.commit(); // This should evict pt
verify(pt);
}
}
/** */
private PCPoint2 getHollowInstance() {
Transaction tx = pm.currentTransaction();
tx.begin();
PCPoint2 pt = new PCPoint2(1,2);
pm.makePersistent(pt);
tx.commit();
int curr = currentState(pt);
if (curr != HOLLOW){
fail(ASSERTION_FAILED,
"Unable to create HOLLOW instance, state is " + states[curr]);
}
return pt;
}
/** */
private void makePersistentClean(PCPoint2 pt) {
pm.makeTransactional(pt);
int curr = currentState(pt);
if (curr != PERSISTENT_CLEAN){
fail(ASSERTION_FAILED,
"Unable to create PERSISTENT_CLEAN instance, state is " + states[curr]);
}
}
/** */
private void verify(PCPoint2 pt) {
// When PersistenceManager evicts instances, it: calls the jdoPreClear method on each instance
if ( !pt.wasClearCalled()) {
fail(ASSERTION_FAILED,
"missing call of jdoPreClear");
}
// When PersistenceManager evicts instances, it: changes the state of the instances to hollow
int curr = currentState(pt);
if ( (curr != HOLLOW) && (curr != PERSISTENT_NONTRANSACTIONAL) ) {
fail(ASSERTION_FAILED,
"Instance should be HOLLOW after tx.commit(), state is " + states[curr]);
}
pm.makeTransient(pt);
// When PersistenceManager evicts instances, it: clears persistent fields on each instance (sets the value of the field to its Java default value)
int x=pt.getX();
Integer y=pt.getY();
if ((x != 0) || (y != null)) {
fail(ASSERTION_FAILED,
"persistent fields not cleared, pt.getX()=="+x+" and pt.getY()=="+y);
}
}
}
././@LongLink 100644 0 0 147 12500111677 10255 L ustar 0 0 tck/src/java/org/apache/jdo/tck/api/persistencemanager/cache/PassingNullToEvictAllThrowsException.java tck/src/java/org/apache/jdo/tck/api/persistencemanager/cache/PassingNullToEvictAllThrowsException.ja100664 7037 12500110374 34220 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.cache;
import java.util.Collection;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.api.persistencemanager.PersistenceManagerTest;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: PassingNullToEvictAllThrowsException
*Keywords:
*Assertion IDs: A12.5-9
*Assertion Description:
Passing a null valued argument to evictAll will throw a NullPointerException.
*/
public class PassingNullToEvictAllThrowsException extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.5-9 (PassingNullToEvictAllThrowsException) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(PassingNullToEvictAllThrowsException.class);
}
/** */
public void testPassingNullToEvictAllThrowsException() {
pm = getPM();
runTestEvictAll1(pm);
runTestEvictAll2(pm);
pm.close();
pm = null;
}
/* test evictAll (Collection pcs) */
private void runTestEvictAll1(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
if (debug) logger.debug ("** in runTestEvictAll1() ");
try {
tx.begin();
Collection col1 = null;
try {
pm.evictAll(col1);
fail(ASSERTION_FAILED,
"pm.evictAll should throw NullPointerException when called with argument null");
}
catch (NullPointerException ex) {
// expected exception
}
tx .rollback();
tx = null;
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
/* test evictAll (Object[] objArray) */
private void runTestEvictAll2(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
if (debug) logger.debug ("** in runTestEvictAll1() ");
try {
tx.begin();
Object[] arr = null;
try {
pm.evictAll(arr);
fail(ASSERTION_FAILED,
"pm.evictAll should throw NullPointerException when called with argument null");
}
catch (NullPointerException ex) {
// expected exception
}
tx .rollback();
tx = null;
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanager/cache/PassingNullToEvictHasNoEffect.java 100664 4733 12500110374 33076 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.cache;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.api.persistencemanager.PersistenceManagerTest;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: PassingNullToEvictHasNoEffect
*Keywords:
*Assertion IDs: A12.5-7
*Assertion Description:
Passing a null value to PersistenceManager.evict will have no effect. A
NullPointerException should NOT be thrown.
*/
public class PassingNullToEvictHasNoEffect extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.5-7 (PassingNullToEvictHasNoEffect) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(PassingNullToEvictHasNoEffect.class);
}
/** */
public void test() {
pm = getPM();
runTestPassingNullToEvictHasNoEffect(pm);
pm.close();
pm = null;
}
/* test evict (object pc) */
public void runTestPassingNullToEvictHasNoEffect(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
pm.evict(null);
if (debug)
logger.debug (" \nPASSED in testPassingNullToEvictHasNoEffect()");
tx.rollback();
tx = null;
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
}
././@LongLink 100644 0 0 151 12500111677 10250 L ustar 0 0 tck/src/java/org/apache/jdo/tck/api/persistencemanager/cache/PassingNullToRefreshAllThrowsException.java tck/src/java/org/apache/jdo/tck/api/persistencemanager/cache/PassingNullToRefreshAllThrowsException.100664 7175 12500110374 34234 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.cache;
import java.util.Collection;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.api.persistencemanager.PersistenceManagerTest;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Passing Null to RefreshAll Throws Exception
*Keywords: cache
*Assertion IDs: A12.5-10.
*Assertion Description:
Passing a null valued argument to refreshAll will throw a
NullPointerException.
*/
public class PassingNullToRefreshAllThrowsException
extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.5-10 (PassingNullToRefreshAllThrowsException) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(PassingNullToRefreshAllThrowsException.class);
}
/** */
public void testPassingNullToRefreshAllThrowsException() {
pm = getPM();
runTestRefreshAll1(pm);
runTestRefreshAll2(pm);
pm.close();
pm = null;
}
/* test refreshAll (Collection pcs) */
public void runTestRefreshAll1(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
if (debug) logger.debug("** in runTestRefreshAll1() ");
try {
tx.begin();
Collection col1 = null;
try {
pm.refreshAll(col1);
fail(ASSERTION_FAILED,
"pm.refreshAll should throw NullPointerException when called with argument null");
}
catch (NullPointerException ex) {
// expected exception
}
tx .rollback();
tx = null;
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
/* test refreshAll (Object[] objArray) */
public void runTestRefreshAll2(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
if (debug) logger.debug ("** in runTestRefreshAll1() ");
try {
tx = pm.currentTransaction();
tx.begin();
Object[] arr = null;
try {
pm.refreshAll(arr);
fail(ASSERTION_FAILED,
"pm.refreshAll should throw NullPointerException when called with argument null");
}
catch (NullPointerException ex) {
// expected exception
}
tx .rollback();
tx = null;
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanager/cache/PassingNullToRefreshHasNoEffect.java 100664 5071 12500110374 33416 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.cache;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.api.persistencemanager.PersistenceManagerTest;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Passing Null to Refresh has no Effect
*Keywords:
*Assertion IDs: A12.5-8
*Assertion Description:
Passing a null value to PersistenceManager.refresh will have no effect. A NullPointerException should NOT be thrown.
*/
public class PassingNullToRefreshHasNoEffect extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.5-8 (PassingNullToRefreshHasNoEffect) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(PassingNullToRefreshHasNoEffect.class);
}
/** */
public void test() {
pm = getPM();
runTestPassingNullToRefreshHasNoEffect(pm);
pm.close();
pm = null;
}
/* test evict (object pc) */
private void runTestPassingNullToRefreshHasNoEffect(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
PCPoint p1 = null;
pm.refresh(p1);
if (debug)
logger.debug (" \nPASSED in testPassingNullToRefreshHasNoEffect()");
tx.rollback();
tx = null;
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanager/cache/RefreshAllNoParameterSideEffects.java 100664 13602 12500110374 33600 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.cache;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.api.persistencemanager.PersistenceManagerTest;
import org.apache.jdo.tck.pc.mylib.VersionedPCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Refresh All No Parameters Side Effects
*Keywords: cache
*Assertion ID: A12.5.1-5B
*Assertion Description:
The refreshAll() updates the values in the parameter
instance[s] from the data in the data store. ((The intended use is for optimistic transactions where the state of
the JDO Instance is not guaranteed to reflect the state in the data store. This method can be used to minimize
the occurrence of commit failures due to mismatch between the state of cached instances and the state of
data in the data store.)) This can be tested by using 2 PersistenceManagers, independently change an object,
then refresh.
*/
/** */
public class RefreshAllNoParameterSideEffects extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.5.1-5B (RefreshAllNoParameterSideEffects) failed: ";
Object oid = null;
PersistenceManager pm1;
PersistenceManager pm2;
PersistenceManager pmVerify;
/** */
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(RefreshAllNoParameterSideEffects.class);
}
/** */
public void localSetUp () {
addTearDownClass(VersionedPCPoint.class);
pm = getPM();
Transaction tx = pm.currentTransaction();
tx.begin();
VersionedPCPoint pnt = new VersionedPCPoint (0,0);
pm.makePersistent(pnt);
oid = pm.getObjectId((Object)pnt);
tx.commit();
}
/** */
public void test() throws Exception {
if (!isOptimisticSupported()) {
printUnsupportedOptionalFeatureNotTested(
"RefreshAllNoParameterSideEffect",
"javax.jdo.option.Optimistic");
return;
}
pm1 = pmf.getPersistenceManager();
pm2 = pmf.getPersistenceManager();
pmVerify = pmf.getPersistenceManager();
try {
// don't refresh cache
runTestRefreshAllNoParameterSideEffects(false);
// refresh cache
runTestRefreshAllNoParameterSideEffects(true);
}
finally {
cleanupPM(pmVerify);
pmVerify = null;
cleanupPM(pm1);
pm1 = null;
cleanupPM(pm1);
pm2 = null;
}
failOnError();
}
/** */
private void runTestRefreshAllNoParameterSideEffects(boolean doRefresh)
throws Exception {
if (debug) logger.debug ("\nSTART RefreshAllNoParameterSideEffects");
Transaction tx1 = pm1.currentTransaction();
tx1.setOptimistic(true);
tx1.begin();
VersionedPCPoint pnt1 = (VersionedPCPoint)pm1.getObjectById(oid, true);
pnt1.setX(11); // make transactional
Transaction tx2 = pm2.currentTransaction();
tx2.begin();
VersionedPCPoint pnt2 = (VersionedPCPoint)pm2.getObjectById(oid);
pnt2.setX(22);
pnt2.setY(Integer.valueOf("22"));
tx2.commit();
if (doRefresh)
pm1.refreshAll();
pnt1.setX(33);
pnt1.setY(Integer.valueOf("33"));
try {
tx1.commit();
} catch (javax.jdo.JDOOptimisticVerificationException ove) {
if (doRefresh) {
appendMessage("Expected no exception on commit with doRefresh "
+ "true, but got " + ove.toString());
}
// else expect exception
} catch (Exception e) {
appendMessage("Unexpected exception on commit. doRefresh is "
+ doRefresh + ". Exception is: " + e.toString());
}
// verify that correct value was committed
VersionedPCPoint pntExpected = new VersionedPCPoint(33, 33);
if (!doRefresh) {
pntExpected.setX(22);
pntExpected.setY(Integer.valueOf("22"));
}
Transaction txVerify = pmVerify.currentTransaction();
txVerify.begin();
VersionedPCPoint pntVerify =
(VersionedPCPoint)pmVerify.getObjectById(oid, true);
if (pntVerify.getX() != pntExpected.getX()
|| pntVerify.getY().intValue() != pntExpected.getY().intValue())
{
appendMessage("After commit with doRefresh " + doRefresh
+ " expected ("
+ pntExpected.getX() + ", " + pntExpected.getY()
+ ") but actual is ("
+ pntVerify.getX() + ", " + pntVerify.getY() + ").");
}
txVerify.commit();
if (debug) logger.debug ("END RefreshAllNoParameterSideEffects"
+ "doRefresh is " + doRefresh);
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanager/cache/RefreshAllSideEffects.java 100664 16205 12500110374 31444 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.cache;
import java.util.Collection;
import java.util.ArrayList;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.api.persistencemanager.PersistenceManagerTest;
import org.apache.jdo.tck.pc.mylib.VersionedPCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Refresh All Side Effects
*Keywords: cache
*Assertion ID: A12.5.1-5D
*Assertion Description:
The refreshAll(Object[] pcs) updates the values in the parameter
instance[s] from the data in the data store. ((The intended use is for optimistic transactions where the state of
the JDO Instance is not guaranteed to reflect the state in the data store. This method can be used to minimize
the occurrence of commit failures due to mismatch between the state of cached instances and the state of
data in the data store.)) This can be tested by using 2 PersistenceManagers, independently change an object,
then refresh.
*/
/** */
public class RefreshAllSideEffects extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.5.1-5D (RefreshAllSideEffects) failed: ";
ArrayList oids = new ArrayList();
PersistenceManager pm1;
PersistenceManager pm2;
PersistenceManager pmVerify;
Collection coll = new ArrayList(); // Collection of persistent instances
boolean useCollection = true;
/** */
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(RefreshAllSideEffects.class);
}
/** */
public void localSetUp () {
addTearDownClass(VersionedPCPoint.class);
pm = getPM();
Transaction tx = pm.currentTransaction();
tx.begin();
VersionedPCPoint pnt1 = new VersionedPCPoint(0,0);
VersionedPCPoint pnt2 = new VersionedPCPoint (-1,-1);
coll.add(pnt1);
coll.add(pnt2);
pm.makePersistentAll(coll);
oids.add(0, pm.getObjectId((Object)pnt1));
oids.add(1, pm.getObjectId((Object)pnt2));
tx.commit();
}
/** */
public void testRefreshAllWithCollection() throws Exception {
useCollection = true;
runtest();
}
/** */
public void testRefreshAllWithArray() throws Exception {
useCollection = false;
runtest();
}
/** */
private void runtest() throws Exception {
if (!isOptimisticSupported()) {
printUnsupportedOptionalFeatureNotTested(
"RefreshAllSideEffects",
"javax.jdo.option.Optimistic");
return;
}
pm1 = pmf.getPersistenceManager();
pm2 = pmf.getPersistenceManager();
pmVerify = pmf.getPersistenceManager();
try {
// don't refresh cache
runTestRefreshAllSideEffects(false);
// refresh cache
runTestRefreshAllSideEffects(true);
}
finally {
cleanupPM(pmVerify);
pmVerify = null;
cleanupPM(pm1);
pm1 = null;
cleanupPM(pm1);
pm2 = null;
}
failOnError();
}
/** */
private void runTestRefreshAllSideEffects(boolean doRefresh)
throws Exception {
if (debug) logger.debug ("\nSTART RefreshAllSideEffects");
Transaction tx1 = pm1.currentTransaction();
tx1.setOptimistic(true);
tx1.begin();
Collection points1 = pm1.getObjectsById(oids, true);
((VersionedPCPoint)points1.toArray()[0]).setX(11); // make transactional
Transaction tx2 = pm2.currentTransaction();
tx2.begin();
Collection points2 = pm2.getObjectsById(oids);
((VersionedPCPoint)points2.toArray()[0]).setX(22);
((VersionedPCPoint)points2.toArray()[1]).setX(22);
((VersionedPCPoint)points2.toArray()[0]).setY(Integer.valueOf("22"));
((VersionedPCPoint)points2.toArray()[1]).setY(Integer.valueOf("22"));
tx2.commit();
if (doRefresh) {
if (useCollection)
pm1.refreshAll(points1);
else pm1.refreshAll(points1.toArray());
}
((VersionedPCPoint)points1.toArray()[0]).setX(33);
((VersionedPCPoint)points1.toArray()[1]).setX(33);
((VersionedPCPoint)points1.toArray()[0]).setY(Integer.valueOf("33"));
((VersionedPCPoint)points1.toArray()[1]).setY(Integer.valueOf("33"));
try {
tx1.commit();
} catch (javax.jdo.JDOOptimisticVerificationException ove) {
if (doRefresh) {
appendMessage("Expected no exception on commit with doRefresh "
+ "true, but got " + ove.toString());
}
// else expect exception
} catch (Exception e) {
appendMessage("Unexpected exception on commit. doRefresh is "
+ doRefresh + ". Exception is: " + e.toString());
}
// verify that correct value was committed
VersionedPCPoint pntExpected = new VersionedPCPoint(33, 33);
if (!doRefresh) {
pntExpected.setX(22);
pntExpected.setY(Integer.valueOf("22"));
}
Transaction txVerify = pmVerify.currentTransaction();
txVerify.begin();
Collection pointsVerify =
pmVerify.getObjectsById(oids, true);
if (((VersionedPCPoint)pointsVerify.toArray()[0]).getX()
!= pntExpected.getX()
|| ((VersionedPCPoint)pointsVerify.toArray()[0]).getY().intValue()
!= pntExpected.getY().intValue())
{
appendMessage("After commit with doRefresh " + doRefresh
+ " expected ("
+ pntExpected.getX() + ", " + pntExpected.getY()
+ ") but actual is ("
+ ((VersionedPCPoint)pointsVerify.toArray()[0]).getX()
+ ", "
+ ((VersionedPCPoint)pointsVerify.toArray()[0]).getY().intValue()
+ ").");
}
txVerify.commit();
if (debug) logger.debug ("END RefreshAllSideEffects"
+ "doRefresh is " + doRefresh);
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanager/cache/RefreshAllWithNoParameters.java 100664 6602 12500110374 32474 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.cache;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.api.persistencemanager.PersistenceManagerTest;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Refresh All With No Parameters
*Keywords: cache
*Assertion ID: A12.5.1-6.
*Assertion Description:
The PersistenceManager.refreshAll method with no parameters
causes all transactional instances to be refreshed. Note that this method
will cause loss of changes made to affected instances by the application
due to refreshing the contents from the data store.
The JDO PersistenceManager:
loads persistent values from the data store;
loads persistent fields into the instance;
calls the jdoPostLoad method on each persistent instance,
if the class of the instance implements InstanceCallbacks; and
changes the state of persistent-dirty instances to persistent-clean.
*/
public class RefreshAllWithNoParameters extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.5.1-6 (RefreshAllWithNoParameters) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(RefreshAllWithNoParameters.class);
}
/** */
public void test() {
pm = getPM();
runTestRefreshAll(pm);
pm.close();
pm = null;
}
/** */
private void runTestRefreshAll(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
PCPoint p = new PCPoint (100, 200);
pm.makePersistent(p);
tx.commit();
tx.begin();
p.setX(500);
p.setY(new Integer(800));
pm.refreshAll();
int currentX = p.getX();
Integer currentY = p.getY();
if ((currentX != 100) || !currentY.equals(new Integer(200))) {
fail(ASSERTION_FAILED,
"RefreshAll expected 100, 200; got " + currentX + ", " + currentY);
}
tx.commit();
tx = null;
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanager/cache/RefreshSideEffects.java 100664 17046 12500110374 31017 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.cache;
import javax.jdo.JDOFatalException;
import javax.jdo.PersistenceManager;
import javax.jdo.PersistenceManagerFactory;
import javax.jdo.Transaction;
import junit.framework.AssertionFailedError;
import org.apache.jdo.tck.api.persistencemanager.PersistenceManagerTest;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
import org.apache.jdo.tck.util.ThreadExceptionHandler;
/**
*Title: Refresh Side Effects
*Keywords: cache
*Assertion ID: A12.5.1-5A
*Assertion Description:
The refresh method updates the values in the parameter
instance[s] from the data in the data store. ((The intended use is for optimistic transactions where the state of
the JDO Instance is not guaranteed to reflect the state in the data store. This method can be used to minimize
the occurrence of commit failures due to mismatch between the state of cached instances and the state of
data in the data store.)) This can be tested by using 2 PersistenceManagers, independently change an object,
then refresh.
*/
/** */
public class RefreshSideEffects extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.5.1-5A (RefreshSideEffects) failed: ";
/** */
static final int DELAY = 100;
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(RefreshSideEffects.class);
}
/** */
public void test () throws Exception {
PersistenceManagerFactory pmf = getPMF();
PersistenceManager pm1 = pmf.getPersistenceManager();
PersistenceManager pm2 = pmf.getPersistenceManager();
try {
runTestRefreshSideEffects(pm1, pm2);
}
finally {
cleanupPM(pm2);
pm2 = null;
cleanupPM(pm1);
pm1 = null;
}
}
/** */
private void runTestRefreshSideEffects(PersistenceManager pm1,
PersistenceManager pm2) throws Exception {
if (debug) logger.debug ("\nSTART RefreshSideEffects");
ThreadExceptionHandler group = new ThreadExceptionHandler();
RefreshThreadT1 thread1 = new RefreshThreadT1(pm1);
Thread T1 = new Thread(group, thread1, "T1");
RefreshThreadT2 thread2 = new RefreshThreadT2(pm2);
Thread T2 = new Thread(group, thread2, "T2");
thread1.setOther(thread2);
thread2.setOther(thread1);
T1.start();
T2.start();
T1.join();
T2.join();
Throwable t1Problem = group.getUncaughtException(T1);
if (t1Problem != null) {
if (t1Problem instanceof AssertionFailedError)
throw (AssertionFailedError)t1Problem;
else
throw new JDOFatalException( "Thread "+T1.getName()+" results in exception ", t1Problem );
}
Throwable t2Problem = group.getUncaughtException(T2);
if (t2Problem != null) {
if (t2Problem instanceof AssertionFailedError)
throw (AssertionFailedError)t2Problem;
else
throw new JDOFatalException( "Thread "+T2.getName()+" results in exception ", t2Problem );
}
if (debug) logger.debug ("END RefreshSideEffects");
}
/** */
class RefreshThreadT1 implements Runnable {
PersistenceManager pm;
RefreshThreadT2 other;
boolean commitDone;
/** */
RefreshThreadT1(PersistenceManager pm) {
this.pm = pm;
this.other = null;
this.commitDone = false;
}
/** */
void setOther(RefreshThreadT2 other) {
this.other = other;
}
/** */
boolean isCommitDone() {
return commitDone;
}
/** */
synchronized public void run() {
PCPoint n1 = new PCPoint (5,1);
Transaction tx = pm.currentTransaction();
try {
RefreshSideEffects.this.logger.debug(" ThreadT1: START");
tx.begin();
n1.setX(500);
pm.makePersistent(n1);
pm.refresh(n1);
RefreshSideEffects.this.logger.debug(
" ThreadT1: waiting for ThreadT2.done");
while (!other.isDone()) {
try {
Thread.sleep(DELAY);
}
catch (InterruptedException ex) {
// ignore
}
}
tx.commit();
tx = null;
commitDone = true;
RefreshSideEffects.this.logger.debug(
" ThreadT1: commit finished.");
}
finally {
commitDone = true;
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
}
/** */
class RefreshThreadT2 implements Runnable {
PersistenceManager pm;
RefreshThreadT1 other;
boolean done;
/** */
RefreshThreadT2(PersistenceManager pm) {
this.pm = pm;
this.other = null;
this.done = false;
}
/** */
boolean isDone() {
return done;
}
/** */
void setOther(RefreshThreadT1 other) {
this.other = other;
}
/* test refresh() */
synchronized public void run() {
PCPoint p1 = new PCPoint (5,1);
Transaction tx = pm.currentTransaction();
try {
RefreshSideEffects.this.logger.debug(" ThreadT2: START");
tx.begin();
p1.setX(201);
pm.makePersistent(p1);
pm.refresh(p1);
done = true;
RefreshSideEffects.this.logger.debug(
" ThreadT2: waiting for commit of ThreadT1");
while (!other.isCommitDone()) {
try {
Thread.sleep(DELAY);
}
catch (InterruptedException ex) {
// ignore
}
}
tx.commit();
tx = null;
RefreshSideEffects.this.logger.debug(
" ThreadT2: commit finished.");
}
finally {
done = true;
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanager/cache/Retrieve.java 100664 24221 12500110374 27072 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.cache;
import java.util.ArrayList;
import java.util.Collection;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.api.persistencemanager.PersistenceManagerTest;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.pc.mylib.PCPoint2;
import org.apache.jdo.tck.pc.mylib.PCRect;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Retrieve
*Keywords: cache
*Assertion IDs: A12.6.1-2, A12.6.1-5
*Assertion Description:
These methods request the PersistenceManager to load all persistent fields into
the parameter instances. Subsequent to this call, the application might
call makeTransient on the parameter instances, and the fields can no
longer be touched by the PersistenceManager. The PersistenceManager
might also retrieve related instances according to a pre-read policy
(not specified by JDO).
The JDO PersistenceManager loads persistent values from the datastore into the instance
and if the class of the instance implements InstanceCallbacks calls jdoPostLoad.
*/
public class Retrieve extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertions A12.6.1-2, A12.6.1-5 (Retrieve) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(Retrieve.class);
}
private PCPoint p1 = null;
private String p1print = null;
private PCPoint p2 = null;
private PCPoint2 p3 = null;
private PCRect rect = null;
private static final Integer one = new Integer(1);
private static final Integer three = new Integer(3);
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
addTearDownClass(PCPoint2.class);
addTearDownClass(PCRect.class);
addTearDownClass(PCPoint.class);
}
/** */
public void test () {
pm = getPM();
runTestRetrieve(pm);
runTestRetrieveAllWithCollection(pm);
runTestRetrieveAllWithArray(pm);
runTestRetrieveAllWithCollectionDFGtrue(pm);
runTestRetrieveAllWithArrayDFGtrue(pm);
runTestRetrieveAllWithCollectionDFGfalse(pm);
runTestRetrieveAllWithArrayDFGfalse(pm);
pm.close();
pm = null;
}
/** */
private void runTestRetrieve(PersistenceManager pm) {
createObjects(pm);
Transaction tx = pm.currentTransaction();
try {
tx.begin();
pm.retrieve(p1);
pm.retrieve(p3);
pm.retrieve(rect);
pm.makeTransient(p1);
pm.makeTransient(p3);
pm.makeTransient(rect);
tx.commit();
tx = null;
checkP1();
checkP3();
checkRectP1();
checkRectId();
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
/** */
private void runTestRetrieveAllWithCollection(PersistenceManager pm) {
createObjects(pm);
Transaction tx = pm.currentTransaction();
try {
tx.begin();
Collection coll = new ArrayList();
coll.add(p1);
coll.add(p3);
coll.add(rect);
pm.retrieveAll(coll);
pm.makeTransientAll(coll);
tx.commit();
tx = null;
checkP1();
checkP3();
checkRectP1();
checkRectId();
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
/** */
private void runTestRetrieveAllWithCollectionDFGtrue(PersistenceManager pm) {
createObjects(pm);
Transaction tx = pm.currentTransaction();
try {
tx.begin();
Collection coll = new ArrayList();
coll.add(p1);
coll.add(p3);
coll.add(rect);
pm.retrieveAll(coll, true);
pm.makeTransientAll(coll);
tx.commit();
tx = null;
checkP1();
checkP3();
// checkRectP1(); p1 is not in the default fetch group by default
checkRectId();
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
/** */
private void runTestRetrieveAllWithCollectionDFGfalse(PersistenceManager pm) {
createObjects(pm);
Transaction tx = pm.currentTransaction();
try {
tx.begin();
Collection coll = new ArrayList();
coll.add(p1);
coll.add(p3);
coll.add(rect);
pm.retrieveAll(coll, false);
pm.makeTransientAll(coll);
tx.commit();
tx = null;
checkP1();
checkP3();
checkRectP1();
checkRectId();
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
/** */
private void runTestRetrieveAllWithArray(PersistenceManager pm) {
createObjects(pm);
Transaction tx = pm.currentTransaction();
try {
tx.begin();
Object[] objs = new Object[3];
objs[0] = p1;
objs[1] = p3;
objs[2] = rect;
pm.retrieveAll(objs);
pm.makeTransientAll(objs);
tx.commit();
tx = null;
checkP1();
checkP3();
checkRectP1();
checkRectId();
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
/** */
private void runTestRetrieveAllWithArrayDFGtrue(PersistenceManager pm) {
createObjects(pm);
Transaction tx = pm.currentTransaction();
try {
tx.begin();
Object[] objs = new Object[3];
objs[0] = p1;
objs[1] = p3;
objs[2] = rect;
pm.retrieveAll(objs, true);
pm.makeTransientAll(objs);
tx.commit();
tx = null;
checkP1();
checkP3();
// checkRectP1(); p1 is not in the default fetch group by default
checkRectId();
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
/** */
private void runTestRetrieveAllWithArrayDFGfalse(PersistenceManager pm) {
createObjects(pm);
Transaction tx = pm.currentTransaction();
try {
tx.begin();
Object[] objs = new Object[3];
objs[0] = p1;
objs[1] = p3;
objs[2] = rect;
pm.retrieveAll(objs, false);
pm.makeTransientAll(objs);
tx.commit();
tx = null;
checkP1();
checkP3();
checkRectP1();
checkRectId();
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
/** */
private void createObjects(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
tx.setRetainValues(false);
tx.begin();
p1 = new PCPoint(1,1);
p1print = p1.toString();
p2 = new PCPoint(2,2);
p3 = new PCPoint2(3,3);
rect = new PCRect(100, p1, p2);
pm.makePersistent(p1);
pm.makePersistent(p2);
pm.makePersistent(p3);
pm.makePersistent(rect);
if (debug) {
logger.debug("p1: " + p1.name());
logger.debug("p2: " + p2.name());
logger.debug("p3: " + p3.name());
logger.debug("rect id: " + rect.getId() +
", upperLeft: " + rect.getUpperLeft().name() +
", lowerRight: " + rect.getLowerRight().name());
}
tx.commit();
tx = null;
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
/** */
private void checkP1() {
if (((p1.getX() != 1) || (!one.equals(p1.getY())))) {
fail(ASSERTION_FAILED,
"Error in p1 fields. Expected x:1, y:1; got x:" + p1.getX() +
", y:" + p1.getY());
}
}
/** */
private void checkP3() {
if ((p3.getX() != 3) || (!three.equals(p3.getY()))) {
fail(ASSERTION_FAILED,
"Error in p3 fields. Expected x:3, y:3; got x:" + p3.getX() +
", y:" + p3.getY());
}
if (!p3.wasPostLoadCalled()) {
fail(ASSERTION_FAILED,
"missing call of jdoPostLoad for p3");
}
}
/** */
private void checkRectId() {
if (rect.getId() == 0) {
fail(ASSERTION_FAILED,
"Error in rect field id. Expected id!= 0; got id:0");
}
}
/** */
private void checkRectP1() {
if (rect.getUpperLeft()!= p1) {
fail(ASSERTION_FAILED,
"Error in rect field upperLeft. Expected:" + p1print +
", got:" + rect.getUpperLeft());
}
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanager/ChangingObjectIdHasNoEffectOnInstance.java 100664 4713 12500110374 33400 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Changing ObjectId Has No Effect On Instance
*Keywords: identity
*Assertion ID: A12.5.6-13.
*Assertion Description:
If the application makes a change to the ObjectId instance
returned by PersistenceManager.getObjectId, there is no effect
on the instance from which the ObjectId was obtained.
*/
public class ChangingObjectIdHasNoEffectOnInstance extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.5.6-13 (ChangingObjectIdHasNoEffectOnInstance) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(ChangingObjectIdHasNoEffectOnInstance.class);
}
/** */
public void testChangingObjectIdHasNoEffectOnInstance() throws Exception {
pm = getPM();
Object oid = createPCPointInstance(pm);
Object p1 = pm.getObjectById(oid, false);
Object oid2 = pm.getObjectId(p1);
mangleObject(oid);
// now oid3 should equal oid2 even though we mangled oid
Object oid3 = getPM().getObjectId(p1);
if (!oid2.equals(oid3))
fail(ASSERTION_FAILED,
"Changing the ObjectId returned by getObjectId has an effect on ObjectId's returned by subsequent calls of getObjectId");
pm.close();
pm = null;
}
}
././@LongLink 100644 0 0 145 12500111677 10253 L ustar 0 0 tck/src/java/org/apache/jdo/tck/api/persistencemanager/close/AfterCloseAllMethodsThrowException.java tck/src/java/org/apache/jdo/tck/api/persistencemanager/close/AfterCloseAllMethodsThrowException.java100664 6015 12500110374 34237 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.close;
import javax.jdo.JDOFatalUserException;
import javax.jdo.PersistenceManager;
import javax.jdo.PersistenceManagerFactory;
import javax.jdo.Transaction;
import org.apache.jdo.tck.api.persistencemanager.PersistenceManagerTest;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: AfterCloseAllMethodsThrowException
*Keywords: exception
*Assertion IDs: A12.5-6
*Assertion Description:
After the PersistenceManager.close method completes,
all methods on PersistenceManager except isClosed throw a
JDOFatalUserException.
*/
public class AfterCloseAllMethodsThrowException extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.5-6 (AfterCloseAllMethodsThrowException) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(AfterCloseAllMethodsThrowException.class);
}
private PersistenceManagerFactory pmf;
private PersistenceManager pm;
private Transaction tx;
/** */
public void testAfterCloseAllMethodsThrowException() {
pm = getPM();
pm.close();
runTestEvict();
runTestRefresh();
runTestIsClosed();
pm = null;
}
/** */
private void runTestEvict() {
try {
pm.evictAll();
fail(ASSERTION_FAILED,
"pm.evictAll does not throw exception if pm is closed.");
}
catch (JDOFatalUserException ex) {
// caught expected exception
}
}
/** */
private void runTestRefresh() {
try {
pm.refreshAll();
fail(ASSERTION_FAILED,
"pm.refreshAll does not throw exception if pm is closed.");
}
catch (JDOFatalUserException ex) {
// caught expected exception
}
}
/** */
private void runTestIsClosed() {
if (!pm.isClosed())
fail(ASSERTION_FAILED,
"pm.isClosed returns false for closed pm.");
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanager/close/CloseThrowsExceptionWhenActiveTx.java 100664 4335 12500110374 33760 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.close;
import javax.jdo.JDOUserException;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.api.persistencemanager.PersistenceManagerTest;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Close Throws Exception
*Keywords: exception
*Assertion IDs: A12.6-2.
*Assertion Description:
In a non-managed environment, if the current transaction is active, close throws JDOUserException.
*/
public class CloseThrowsExceptionWhenActiveTx extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.6-2 (CloseThrowsExceptionWhenActiveTx) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(CloseThrowsExceptionWhenActiveTx.class);
}
/** */
public void test() {
pm = getPM();
pm.currentTransaction().begin();
try {
pm.close();
fail(ASSERTION_FAILED, "JDOUserException was not thrown when closing PersistenceManager while transaction was open");
}
catch (JDOUserException juex) {
// expected this exception
}
finally {
pm.currentTransaction().rollback();
}
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanager/close/IsClosedIsFalseUponConstruction.java 100664 3702 12500110374 33561 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.close;
import org.apache.jdo.tck.util.BatchTestRunner;
import org.apache.jdo.tck.api.persistencemanager.PersistenceManagerTest;
/**
*Title: Is Closed returns false Upon Construction
*Keywords:
*Assertion IDs: A12.5-3
*Assertion Description:
The PersistenceManager.isClosed method returns false upon construction of
the PersistenceManager instance.
*/
public class IsClosedIsFalseUponConstruction extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.5-3 (IsClosedIsFalseUponConstruction) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(IsClosedIsFalseUponConstruction.class);
}
/** */
public void test() {
pm = getPM();
if (pm.isClosed()) {
fail(ASSERTION_FAILED,
"pm is closed after creation");
}
}
}
././@LongLink 100644 0 0 147 12500111677 10255 L ustar 0 0 tck/src/java/org/apache/jdo/tck/api/persistencemanager/close/IsClosedIsFalseUponRetrievalFromPool.java tck/src/java/org/apache/jdo/tck/api/persistencemanager/close/IsClosedIsFalseUponRetrievalFromPool.ja100664 4106 12500110374 34152 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.close;
import org.apache.jdo.tck.util.BatchTestRunner;
import org.apache.jdo.tck.api.persistencemanager.PersistenceManagerTest;
/**
*Title: Is Closed Is False Upon Retrieval From a Pool
*Keywords:
*Assertion IDs: A12.5-4
*Assertion Description:
The PersistenceManager.isClosed method returns false upon retrieval
of a PersistenceManager from a pool.
*/
public class IsClosedIsFalseUponRetrievalFromPool extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.5-4 (IsClosedIsFalseUponRetrievalFromPool) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(IsClosedIsFalseUponRetrievalFromPool.class);
}
/** */
public void testIsClosed() {
String sname="Jojo";
String spswd="mypswd";
pmf = getPMF();
pm = pmf.getPersistenceManager(sname,spswd);
if (pm.isClosed()) {
fail(ASSERTION_FAILED,
"pm is closed after creation");
}
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanager/close/IsClosedIsTrueAfterClose.java 100664 4163 12500110374 32143 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.close;
import javax.jdo.PersistenceManagerFactory;
import org.apache.jdo.tck.util.BatchTestRunner;
import org.apache.jdo.tck.api.persistencemanager.PersistenceManagerTest;
/**
*Title: Is Closed Is True After Close
*Keywords:
*Assertion IDs: A12.5-5
*Assertion Description:
The PersistenceManager.isClosed method returns true only after the
closemethod completes successfully, meaning the PersistenceManager has been closed. (same as A35-01).
*/
public class IsClosedIsTrueAfterClose extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.5-5 (IsClosedIsTrueAfterClose) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(IsClosedIsTrueAfterClose.class);
}
/** */
public void test() {
PersistenceManagerFactory pmf = getPMF();
pm = pmf.getPersistenceManager();
pm.close();
if (!pm.isClosed()) {
fail(ASSERTION_FAILED,
"pm.isClosed returns false after pm.close");
}
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanager/ConcurrentPersistenceManagers.java 100664 5753 12500110374 32240 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager;
import java.util.Properties;
import javax.jdo.JDOHelper;
import javax.jdo.PersistenceManager;
import javax.jdo.PersistenceManagerFactory;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Concurrent Persistence Managers
*Keywords: concurrency multipleJDOimpls
*Assertion ID: A5.2-1.
*Assertion Description:
An implementation should support its own PersistenceManager
concurrently with another PersistenceManager.
A non-reference implementation will be tested concurrently
with the Reference Implementation.
*/
public class ConcurrentPersistenceManagers extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A5.2-1 (ConcurrentPersistenceManagers) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(ConcurrentPersistenceManagers.class);
}
/** */
public void test() {
Properties pmfProperties = loadPMF2Properties();
PersistenceManagerFactory pmf2 = JDOHelper.getPersistenceManagerFactory(pmfProperties);
PersistenceManager pm2 = pmf2.getPersistenceManager();
Transaction tx2 = pm2.currentTransaction();
pm = getPM();
Transaction tx = pm.currentTransaction();
try {
tx.begin();
tx2.begin();
tx.commit();
tx = null;
tx2.commit();
tx2 = null;
}
finally {
cleanupPM(pm);
pm = null;
cleanupPM(pm2);
pm2 = null;
closePMF(pmf2);
}
}
private Properties loadPMF2Properties() {
String PMF2 = System.getProperty ("PMF2Properties", "jdori2.properties");
if (debug) logger.debug("Got PMF2Properties file name:" + PMF2);
Properties ret = loadProperties (PMF2);
if (debug) logger.debug("Got PMF2Properties: " + ret);
return ret;
}
}
././@LongLink 100644 0 0 145 12500111677 10253 L ustar 0 0 tck/src/java/org/apache/jdo/tck/api/persistencemanager/ConcurrentPersistenceManagersSameClasses.java tck/src/java/org/apache/jdo/tck/api/persistencemanager/ConcurrentPersistenceManagersSameClasses.java100664 12613 12500110374 34375 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager;
import java.util.Collection;
import java.util.Iterator;
import java.util.Properties;
import javax.jdo.JDOHelper;
import javax.jdo.PersistenceManager;
import javax.jdo.PersistenceManagerFactory;
import javax.jdo.Query;
import javax.jdo.Transaction;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.pc.mylib.PCRect;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Same Classes with Concurrent Persistence Managers
*Keywords: concurrency multipleJDOimpls
*Assertion ID: A5.2-2.
*Assertion Description:
The same classes must be supported concurrently by multiple
PersistenceManagers from different implementations.
*/
public class ConcurrentPersistenceManagersSameClasses extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A5.2-2 (ConcurrentPersistenceManagersSameClasses) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(ConcurrentPersistenceManagersSameClasses.class);
}
/** */
public void test() {
if (!isBinaryCompatibilitySupported()) {
printUnsupportedOptionalFeatureNotTested(
"org.apache.jdo.tck.api.persistencemanager.ConcurrentPersistenceManagersSameClasses",
"javax.jdo.option.BinaryCompatibility");
return;
}
Properties pmfProperties = loadPMF2Properties();
PersistenceManagerFactory pmf2 = JDOHelper.getPersistenceManagerFactory(pmfProperties);
PersistenceManager pm2 = pmf2.getPersistenceManager();
Transaction tx2 = pm2.currentTransaction();
PCPoint p21 = null;
PCPoint p22 = null;
PCRect rect2 = null;
pm = getPM();
Transaction tx = pm.currentTransaction();
try {
tx.begin();
tx2.begin();
PCPoint p11 = new PCPoint(110, 120);
PCPoint p12 = new PCPoint(120, 140);
PCRect rect1 = new PCRect (0, p11, p12);
pm.makePersistent (rect1);
p21 = new PCPoint(210, 220);
p22 = new PCPoint(220, 240);
rect2 = new PCRect (0, p21, p22);
pm2.makePersistent (rect2);
tx.commit();
tx2.commit();
tx.begin();
tx2.begin();
PCPoint p11a = findPoint (pm, 110, 120);
if (p11a != p11) {
fail(ASSERTION_FAILED,
"unexpected PCPoint instance, expected: 110, 120, found: " + p11a.getX() + ", " + p11a.getY());
}
PCPoint p21a = findPoint (pm2, 210, 220);
if (p21a != p21) {
fail(ASSERTION_FAILED,
"unexpected PCPoint instance, expected: 210, 220, found: " + p21a.getX() + ", " + p21a.getY());
}
tx.commit();
tx = null;
tx2.commit();
tx2 = null;
}
finally {
cleanupPM(pm);
pm = null;
try {
// delete pm2 instances
if (pm2.currentTransaction().isActive()) {
pm2.currentTransaction().rollback();
}
pm2.currentTransaction().begin();
pm2.deletePersistent(rect2);
pm2.deletePersistent(p21);
pm2.deletePersistent(p22);
pm2.currentTransaction().commit();
} finally {
cleanupPM(pm2);
pm2 = null;
closePMF(pmf2);
}
}
}
/** */
private Properties loadPMF2Properties() {
String PMF2 = System.getProperty ("PMF2Properties", "jdori2.properties");
if (debug) logger.debug("Got PMF2Properties file name:" + PMF2);
Properties ret = loadProperties (PMF2);
if (debug) logger.debug("Got PMF2Properties: " + ret);
return ret;
}
/** */
private PCPoint findPoint (PersistenceManager pm, int x, int y) {
Query q = pm.newQuery (PCPoint.class);
q.declareParameters ("int px, int py");
q.setFilter ("x == px & y == py");
Collection results = (Collection)q.execute (new Integer(x), new Integer(y));
Iterator it = results.iterator();
PCPoint ret = (PCPoint)it.next();
return ret;
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanager/CurrentTransaction.java 100664 3746 12500110374 30063 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: CurrentTransaction
*Keywords:
*Assertion ID: A12.5.2-1
*Assertion Description:
The PersistenceManager.currentTransaction method returns the
Transaction instance associated with the PersistenceManager.
*/
public class CurrentTransaction extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.5.2-1 (CurrentTransaction) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(CurrentTransaction.class);
}
/** */
public void testCurrentTransaction() {
pm = getPM();
PCPoint p1 = new PCPoint();
Transaction tx = pm.currentTransaction();
tx.begin();
pm.makePersistent(p1);
tx.commit();
pm.close();
pm = null;
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanager/DataStoreCacheTest.java 100664 6670 12500110374 27704 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager;
import java.util.Collection;
import java.util.HashSet;
import javax.jdo.datastore.DataStoreCache;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
* Title: DataStoreCacheTest
* Keywords: DataStoreCache cache pin unpin evict
* Assertion ID: A11.8
* Assertion Description:
Most JDO implementations allow instances
to be cached in a second-level cache, and allow
direct management of the cache by knowledgeable
applications. The second-level cache is
typically a single VM cache and is used for
persistent instances associated with a single
PersistenceManagerFactory. For the purpose
of standardizing this behavior, the
DataStoreCache interface is used.
*/
public class DataStoreCacheTest extends PersistenceManagerTest {
Object pointoid;
Collection pointoidCollection;
Object[] pointoidArray;
/** */
private static final String ASSERTION_FAILED =
"Assertion A11.8 (DataStoreCacheTest) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(DataStoreCacheTest.class);
}
/**
* In setup, create a persistent instance and get its oid.
* The oid is a valid parameter to the cache APIs.
*/
protected void localSetUp() {
addTearDownClass(PCPoint.class);
PCPoint point = new PCPoint(50, 100);
getPM().currentTransaction().begin();
pm.makePersistent(point);
pointoid = pm.getObjectId(point);
pointoidCollection = new HashSet();
pointoidCollection.add(pointoid);
pointoidArray = new Object[] {pointoid};
pm.currentTransaction().commit();
}
/**
* There is no mandated behavior of the DataStoreCache
* methods. This test makes sure that the instance
* returned does not throw exceptions on any method.
*/
public void testDataStoreCache() {
DataStoreCache ds = getPMF().getDataStoreCache();
ds.evict(pointoid);
ds.evictAll();
ds.evictAll(pointoidCollection);
ds.evictAll(pointoidArray);
ds.evictAll(PCPoint.class, true);
ds.pin(pointoid);
ds.unpin(pointoid);
ds.pinAll(pointoidCollection);
ds.unpinAll(pointoidCollection);
ds.pinAll(pointoidArray);
ds.unpinAll(pointoidArray);
ds.pinAll(PCPoint.class, true);
ds.unpinAll(PCPoint.class, true);
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanager/DataStoreConnection.java 100664 12416 12500110374 30153 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.Collection;
import java.util.HashSet;
import javax.jdo.datastore.JDOConnection;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: DataStoreConnection
*Keywords:
*Assertion ID: A12.5.2-1
*Assertion Description:
In order for the application to perform some
datastore-specific functions, such as to execute
a query that is not directly supported by JDO,
applications might need access to the
datastore connection used by the JDO implementation.
This method returns a wrapped
connection that can be cast to the appropriate
datastore connection and used by the application.
The capability to get the datastore connection is
indicated by the optional feature string
javax.jdo.option.GetDataStoreConnection.
*/
public class DataStoreConnection extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.5.2-1 (DataStoreConnection) failed: ";
protected PCPoint goldenPoint;
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(DataStoreConnection.class);
}
/** */
protected void localSetUp() {
addTearDownClass(PCPoint.class);
PCPoint point = new PCPoint(50, 100);
goldenPoint = new PCPoint(point.getX(), point.getY());
getPM().currentTransaction().begin();
pm.makePersistent(point);
pm.currentTransaction().commit();
}
/** */
public void testDataStoreConnection() {
if (!(isDataStoreConnectionSupported() && isSQLSupported())) {
printUnsupportedOptionalFeatureNotTested(
this.getClass().getName(),
"getDataStoreConnection AND SQLSupported.");
return;
}
getPM().currentTransaction().setOptimistic(false);
executeSQLWithDataStoreConnection();
if (!isOptimisticSupported()) {
printUnsupportedOptionalFeatureNotTested(
this.getClass().getName(),
"getDataStoreConnection AND SQLSupported AND Optimistic.");
return;
}
getPM().currentTransaction().setOptimistic(true);
executeSQLWithDataStoreConnection();
}
private void executeSQLWithDataStoreConnection() {
String schema = getPMFProperty("javax.jdo.mapping.Schema");
String sql = "SELECT X, Y FROM " + schema + ".PCPoint";
JDOConnection jconn = null;
try {
getPM().currentTransaction().begin();
jconn = pm.getDataStoreConnection();
Connection conn = (Connection)jconn;
if (conn.getAutoCommit()) {
appendMessage(ASSERTION_FAILED +
"Autocommit must not be true in JDO connection.");
};
PreparedStatement ps = conn.prepareStatement(sql);
ResultSet rs = ps.executeQuery();
Collection actuals = new HashSet();
while (rs.next()) {
PCPoint p = new PCPoint(rs.getInt(1), rs.getInt(2));
actuals.add(p);
}
if (actuals.size() != 1) {
appendMessage(ASSERTION_FAILED + "Wrong size of result of " +
sql + NL + "expected: 1, actual: " + actuals.size());
} else {
PCPoint actual = (PCPoint)actuals.iterator().next();
if (goldenPoint.getX() != actual.getX() ||
!goldenPoint.getY().equals(actual.getY())) {
appendMessage(ASSERTION_FAILED +
"Wrong values of PCPoint from SQL" +
"expected x: " + goldenPoint.getX() +
", y: " + goldenPoint.getX() + NL +
"actual x: " + actual.getX() +
", y: " + actual.getX()
);
}
}
} catch (Exception ex) {
appendMessage(ASSERTION_FAILED + " caught exception:" + ex);
} finally {
jconn.close();
getPM().currentTransaction().commit();
failOnError();
}
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanager/DataStoreConnectionThrows.java 100664 14514 12500110374 31363 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import javax.jdo.datastore.JDOConnection;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: DataStoreConnectionThrows
*Keywords:
*Assertion ID: A12.16-2
*Assertion Description:
For portability, a JDBC-based JDO implementation
will return an instance that implements
java.sql.Connection. The instance
will throw an exception for any of the
following method calls: commit, getMetaData,
releaseSavepoint, rollback, setAutoCommit,
setCatalog, setHoldability, setReadOnly,
setSavepoint, setTransactionIsolation, and
setTypeMap.
*/
public class DataStoreConnectionThrows extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.16-2 (DataStoreConnectionThrows) failed: ";
protected PCPoint goldenPoint;
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(DataStoreConnectionThrows.class);
}
/** */
protected void checkThrow(Connection conn, Call call) {
try {
call.execute(conn);
appendMessage(ASSERTION_FAILED +
"Failed to throw an exception for " + call.getName());
} catch (SQLException ex) {
appendMessage(ASSERTION_FAILED +
"Threw a SQLException for " + call.getName() + NL + ex);
return;
} catch (Exception ex) {
return;
}
}
/** */
interface Call {
String getName();
void execute(Connection conn) throws SQLException;
}
/** */
public void testDataStoreConnectionThrows() {
if (!(isDataStoreConnectionSupported() && isSQLSupported())) {
printUnsupportedOptionalFeatureNotTested(
this.getClass().getName(),
"getDataStoreConnection AND SQLSupported.");
return;
}
JDOConnection jconn = getPM().getDataStoreConnection();
Connection conn = (Connection)jconn;
check13Methods(conn);
if (isJRE14orBetter()) {
check14Methods(conn);
}
jconn.close();
failOnError();
}
/**
* These methods are defined in Java 1.3 Connection.
*/
protected void check13Methods(Connection conn) {
checkThrow(conn,
new Call() {
public String getName() {return "commit";}
public void execute(Connection conn)
throws SQLException {conn.commit();}
}
);
checkThrow(conn,
new Call() {
public String getName() {return "rollback";}
public void execute(Connection conn)
throws SQLException {conn.rollback();}
}
);
checkThrow(conn,
new Call() {
public String getName() {return "setTransactionIsolation";}
public void execute(Connection conn)
throws SQLException {
conn.setTransactionIsolation(
Connection.TRANSACTION_READ_COMMITTED);}
}
);
checkThrow(conn,
new Call() {
public String getName() {return "setAutoCommit";}
public void execute(Connection conn)
throws SQLException {conn.setAutoCommit(true);}
}
);
checkThrow(conn,
new Call() {
public String getName() {return "setCatalog";}
public void execute(Connection conn)
throws SQLException {conn.setCatalog("NONE");}
}
);
}
/**
* These methods are defined in Java 1.4 Connection.
*/
protected void check14Methods(Connection conn) {
checkThrow(conn,
new Call() {
public String getName() {return "setSavepoint";}
public void execute(Connection conn)
throws SQLException {conn.setSavepoint();}
}
);
checkThrow(conn,
new Call() {
public String getName() {return "releaseSavepoint";}
public void execute(Connection conn)
throws SQLException {conn.releaseSavepoint(null);}
}
);
checkThrow(conn,
new Call() {
public String getName() {return "setHoldability";}
public void execute(Connection conn)
throws SQLException {
conn.setHoldability(
ResultSet.CLOSE_CURSORS_AT_COMMIT);}
}
);
checkThrow(conn,
new Call() {
public String getName() {return "setTypeMap";}
public void execute(Connection conn)
throws SQLException {conn.setTypeMap(new HashMap());}
}
);
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanager/DatastoreTimeout.java 100664 50415 12500110374 27543 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager;
import java.util.List;
import junit.framework.AssertionFailedError;
import javax.jdo.JDOFatalException;
import javax.jdo.JDODataStoreException;
import javax.jdo.JDOUnsupportedOptionException;
import javax.jdo.PersistenceManager;
import javax.jdo.Query;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.pc.mylib.PCRect;
import org.apache.jdo.tck.util.BatchTestRunner;
import org.apache.jdo.tck.util.ThreadExceptionHandler;
/**
*Title: DatastoreTimeout
*Keywords: datastore timeout
*Assertion ID: A12.6.9-1, A14.6.1-7
*Assertion Description:
*/
public class DatastoreTimeout extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.6.9-1, A14.6.1-7 (DatastoreTimeout) failed: ";
/** Timeout value for datastore read */
private static Integer READ_TIMEOUT = new Integer(100);
/** Timeout value for datastore write */
private static Integer WRITE_TIMEOUT = new Integer(100);
/** Zero Timeout value */
private static Integer ZERO_TIMEOUT = new Integer(0);
/** Time for the main thread to sleep after starting a parallel thread. */
private static int MAIN_SLEEP_MILLIS = 1000;
/** Time for the parallel threads to sleep before commit. */
private static int THREAD_SLEEP_MILLIS_SHORT = 2500;
/** Time for the parallel threads to sleep before commit. */
private static int THREAD_SLEEP_MILLIS_LONG = 7500;
/** Oid of the PCRect instance created by localSetUp */
private Object rectOid;
/** Oid of the first PCPOint instance created by localSetUp */
private Object point1Oid;
/** Oid of the second PCPoint instance created by localSetUp */
private Object point2Oid;
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(DatastoreTimeout.class);
}
/** Method testing DatastoreReadTimeout. */
public void testDatastoreReadTimeout() throws Exception {
if (debug) logger.debug("isDatastoreTimeoutSupported:" + isDatastoreTimeoutSupported());
// Parallel thread writing the instances and causing them to be locked
ThreadExceptionHandler group = new ThreadExceptionHandler();
ParallelWriter runnable = new ParallelWriter(THREAD_SLEEP_MILLIS_LONG);
Thread t = new Thread(group, runnable, "Parallel Writer");
t.start();
// Wait for a second such that the other thread can lock the instances
Thread.sleep(MAIN_SLEEP_MILLIS);
try {
runQueryReadingPCPointInstances(READ_TIMEOUT);
runGetObjectByIdReadingPCPointInstance(READ_TIMEOUT);
runNavigationalReadPCPointInstance(READ_TIMEOUT);
}
finally {
t.join();
Throwable problem = group.getUncaughtException(t);
if (problem != null) {
if (problem instanceof AssertionFailedError)
throw (AssertionFailedError)problem;
else
throw new JDOFatalException( "Thread " + t.getName()+
" results in exception ", problem);
}
}
}
/** Method testing DatastoreWriteTimeout. */
public void testDatastoreWriteTimeout() throws Exception {
if (debug) logger.debug("isDatastoreTimeoutSupported:" + isDatastoreTimeoutSupported());
// Parallel thread reading the instances and causing them to be locked
ThreadExceptionHandler group = new ThreadExceptionHandler();
ParallelReader runnable = new ParallelReader(THREAD_SLEEP_MILLIS_LONG);
Thread t = new Thread(group, runnable, "Parallel Reader");
t.start();
// Wait for a second such that the other thread can lock the instances
Thread.sleep(MAIN_SLEEP_MILLIS);
try {
runUpdatePCointInstance(WRITE_TIMEOUT);
runDeletePCPointInstance(WRITE_TIMEOUT);
runDeletePCPointInstancesByQuery(WRITE_TIMEOUT);
}
finally {
t.join();
Throwable problem = group.getUncaughtException(t);
if (problem != null) {
if (problem instanceof AssertionFailedError)
throw (AssertionFailedError)problem;
else
throw new JDOFatalException( "Thread " + t.getName()+
" results in exception ", problem);
}
}
}
/** Method testing zero DatastoreReadTimeout. */
public void testZeroDatastoreReadTimeout() throws Exception {
// Parallel thread writing the instances and causing them to be locked
ThreadExceptionHandler group = new ThreadExceptionHandler();
ParallelWriter runnable = new ParallelWriter(THREAD_SLEEP_MILLIS_SHORT);
Thread t = new Thread(group, runnable, "Parallel Writer");
t.start();
// Wait for a second such that the other thread can lock the instances
Thread.sleep(MAIN_SLEEP_MILLIS);
try {
runQueryReadingPCPointInstances(ZERO_TIMEOUT);
}
finally {
t.join();
Throwable problem = group.getUncaughtException(t);
if (problem != null) {
if (problem instanceof AssertionFailedError)
throw (AssertionFailedError)problem;
else
throw new JDOFatalException( "Thread " + t.getName()+
" results in exception ", problem);
}
}
}
/** Method testing zero DatastoreWriteTimeout. */
public void testZeroDatastoreWriteTimeout() throws Exception {
// Parallel thread reading the instances and causing them to be locked
ThreadExceptionHandler group = new ThreadExceptionHandler();
ParallelReader runnable = new ParallelReader(THREAD_SLEEP_MILLIS_SHORT);
Thread t = new Thread(group, runnable, "Parallel Reader");
t.start();
// Wait for a second such that the other thread can lock the instances
Thread.sleep(MAIN_SLEEP_MILLIS);
try {
runUpdatePCointInstance(ZERO_TIMEOUT);
}
finally {
t.join();
Throwable problem = group.getUncaughtException(t);
if (problem != null) {
if (problem instanceof AssertionFailedError)
throw (AssertionFailedError)problem;
else
throw new JDOFatalException( "Thread " + t.getName()+
" results in exception ", problem);
}
}
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
addTearDownClass(PCRect.class);
addTearDownClass(PCPoint.class);
getPM();
try {
Transaction tx = pm.currentTransaction();
tx.begin();
PCPoint p1 = new PCPoint(110, 120);
PCPoint p2 = new PCPoint(130, 140);
PCRect rect = new PCRect (0, p1, p2);
pm.makePersistent (rect);
tx.commit();
rectOid = pm.getObjectId(rect);
point1Oid = pm.getObjectId(p1);
point2Oid = pm.getObjectId(p2);
}
finally {
cleanupPM();
}
}
// ----------------- Helper methods ---------------------------
/** DatastoreReadTimeout helper method: query reading PCPoint instance. */
private void runQueryReadingPCPointInstances(Integer timeout) {
getPM();
try {
pm.currentTransaction().begin();
Query q = pm.newQuery(PCPoint.class);
q.setDatastoreReadTimeoutMillis(timeout);
@SuppressWarnings("unused")
List result = (List)q.execute();
pm.currentTransaction().commit();
if (!isDatastoreTimeoutSupported()) {
fail(ASSERTION_FAILED, "Query.setDatastoreReadTimeoutMillis should throw a " +
"JDOUnsupportedOptionException, if datastore timeout is not supported ");
}
}
catch (JDOUnsupportedOptionException ex) {
if (isDatastoreTimeoutSupported()) {
fail(ASSERTION_FAILED, "Query.setDatastoreReadTimeoutMillis should not result " +
"in a JDOUnsupportedOptionException, if datastore timeout is supported ");
}
}
catch (JDODataStoreException ex) {
if (!isDatastoreTimeoutSupported()) {
fail(ASSERTION_FAILED, "Query.execute should not result in a " +
"JDODataStoreException, if datastore timeout is not supported.");
} else if (timeout == ZERO_TIMEOUT) {
fail(ASSERTION_FAILED, "Query.execute should not result in a " +
"JDODataStoreException, if zero timeout is specified (meaning no timeout).");
}
}
finally {
cleanupPM();
}
}
/** DatastoreReadTimeout helper method: getObjectById reading PCPoint instance. */
private void runGetObjectByIdReadingPCPointInstance(Integer timeout) {
getPM();
try {
pm.currentTransaction().begin();
pm.setDatastoreReadTimeoutMillis(timeout);
@SuppressWarnings("unused")
PCPoint point1 = (PCPoint)pm.getObjectById(point1Oid, true);
pm.currentTransaction().commit();
if (!isDatastoreTimeoutSupported()) {
fail(ASSERTION_FAILED, "PM.setDatastoreReadTimeoutMillis should throw a " +
"JDOUnsupportedOptionException, if datastore timeout is not supported ");
}
}
catch (JDOUnsupportedOptionException ex) {
if (isDatastoreTimeoutSupported()) {
fail(ASSERTION_FAILED, "PM.setDatastoreReadTimeoutMillis should not result " +
"in a JDOUnsupportedOptionException, if datastore timeout is supported ");
}
}
catch (JDODataStoreException ex) {
if (!isDatastoreTimeoutSupported()) {
fail(ASSERTION_FAILED, "PM.getObjectById should not result in a " +
"JDODataStoreException, if datastore timeout is not supported.");
} else if (timeout == ZERO_TIMEOUT) {
fail(ASSERTION_FAILED, "PM.getObjectById should not result in a " +
"JDODataStoreException, if zero timeout is specified (meaning no timeout).");
}
}
finally {
cleanupPM();
}
}
/** DatastoreReadTimeout helper method: navigation reading PCPoint instance. */
private void runNavigationalReadPCPointInstance(Integer timeout) {
getPM();
try {
pm.currentTransaction().begin();
pm.setDatastoreReadTimeoutMillis(timeout);
PCRect rect = (PCRect)pm.getObjectById(rectOid, true);
PCPoint p1 = rect.getUpperLeft();
p1.name();
pm.currentTransaction().commit();
if (!isDatastoreTimeoutSupported()) {
fail(ASSERTION_FAILED, "PM.setDatastoreReadTimeoutMillis should throw a " +
"JDOUnsupportedOptionException, if datastore timeout is not supported ");
}
}
catch (JDOUnsupportedOptionException ex) {
if (isDatastoreTimeoutSupported()) {
fail(ASSERTION_FAILED, "PM.setDatastoreReadTimeoutMillis should not result " +
"in a JDOUnsupportedOptionException, if datastore timeout is supported ");
}
}
catch (JDODataStoreException ex) {
if (!isDatastoreTimeoutSupported()) {
fail(ASSERTION_FAILED, "Navigational access should not result in a " +
"JDODataStoreException, if datastore timeout is not supported.");
} else if (timeout == ZERO_TIMEOUT) {
fail(ASSERTION_FAILED, "Navigational access should not result in a " +
"JDODataStoreException, if zero timeout is specified (meaning no timeout).");
}
}
finally {
cleanupPM();
}
}
/** DatastoreWriteTimeout helper method: update PCPoint instance. */
private void runUpdatePCointInstance(Integer timeout) {
getPM();
try {
pm.currentTransaction().begin();
pm.setDatastoreWriteTimeoutMillis(timeout);
PCPoint point1 = (PCPoint)pm.getObjectById(point1Oid, true);
point1.setX(500);
pm.currentTransaction().commit();
if (!isDatastoreTimeoutSupported()) {
fail(ASSERTION_FAILED, "PM.setDatastoreWriteTimeoutMillis should throw a " +
"JDOUnsupportedOptionException, if datastore timeout is not supported ");
}
}
catch (JDOUnsupportedOptionException ex) {
if (isDatastoreTimeoutSupported()) {
fail(ASSERTION_FAILED, "PM.setDatastoreWriteTimeoutMillis should not result " +
"in a JDOUnsupportedOptionException, if datastore timeout is supported ");
}
}
catch (JDODataStoreException ex) {
if (!isDatastoreTimeoutSupported()) {
fail(ASSERTION_FAILED, "PM.getObjectById should not result in a " +
"JDODataStoreException, if datastore timeout is not supported.");
} else if (timeout == ZERO_TIMEOUT) {
fail(ASSERTION_FAILED, "PM.getObjectById should not result in a " +
"JDODataStoreException, if zero timeout is specified (meaning no timeout).");
}
}
finally {
cleanupPM();
}
}
/** DatastoreWriteTimeout helper method: delete PCPoint instance. */
private void runDeletePCPointInstance(Integer timeout) {
getPM();
try {
pm.currentTransaction().begin();
pm.setDatastoreWriteTimeoutMillis(timeout);
PCPoint point1 = (PCPoint)pm.getObjectById(point1Oid, true);
pm.deletePersistent(point1);
pm.currentTransaction().commit();
if (!isDatastoreTimeoutSupported()) {
fail(ASSERTION_FAILED, "PM.setDatastoreWriteTimeoutMillis should throw a " +
"JDOUnsupportedOptionException, if datastore timeout is not supported ");
}
}
catch (JDOUnsupportedOptionException ex) {
if (isDatastoreTimeoutSupported()) {
fail(ASSERTION_FAILED, "PM.setDatastoreWriteTimeoutMillis should not result " +
"in a JDOUnsupportedOptionException, if datastore timeout is supported ");
}
}
catch (JDODataStoreException ex) {
if (!isDatastoreTimeoutSupported()) {
fail(ASSERTION_FAILED, "PM.getObjectById should not result in a " +
"JDODataStoreException, if datastore timeout is not supported.");
} else if (timeout == ZERO_TIMEOUT) {
fail(ASSERTION_FAILED, "PM.getObjectById should not result in a " +
"JDODataStoreException, if zero timeout is specified (meaning no timeout).");
}
}
finally {
cleanupPM();
}
}
/** DatastoreWriteTimeout helper method: delete by query. */
private void runDeletePCPointInstancesByQuery(Integer timeout) {
getPM();
try {
pm.currentTransaction().begin();
Query q = pm.newQuery(PCPoint.class);
q.setDatastoreWriteTimeoutMillis(timeout);
q.deletePersistentAll();
pm.currentTransaction().commit();
if (!isDatastoreTimeoutSupported()) {
fail(ASSERTION_FAILED, "Query.setDatastoreWriteTimeoutMillis should throw a " +
"JDOUnsupportedOptionException, if datastore timeout is not supported ");
}
}
catch (JDOUnsupportedOptionException ex) {
if (isDatastoreTimeoutSupported()) {
fail(ASSERTION_FAILED, "Query.setDatastoreWriteTimeoutMillis should not result " +
"in a JDOUnsupportedOptionException, if datastore timeout is supported ");
}
}
catch (JDODataStoreException ex) {
if (!isDatastoreTimeoutSupported()) {
fail(ASSERTION_FAILED, "Query.deletePersistentAll should not result in a " +
"JDODataStoreException, if datastore timeout is not supported.");
} else if (timeout == ZERO_TIMEOUT) {
fail(ASSERTION_FAILED, "Query.deletePersistentAll should not result in a " +
"JDODataStoreException, if zero timeout is specified (meaning no timeout).");
}
}
finally {
cleanupPM();
}
}
// ------------- Helper classes -------------------------------
/** Runnable class updating instances and causing them to be read locked. */
class ParallelReader implements Runnable {
private final int sleepMillis;
ParallelReader(int sleepMillis) {
this.sleepMillis = sleepMillis;
}
public void run() {
PersistenceManager parallelPM = getPMF().getPersistenceManager();
Transaction tx = parallelPM.currentTransaction();
// Run datastore transaction
tx.setOptimistic(false);
try {
tx.begin();
// read PCPoint instances
PCPoint p1 = (PCPoint)parallelPM.getObjectById(point1Oid, true);
p1.name();
PCPoint p2 = (PCPoint)parallelPM.getObjectById(point2Oid, true);
p2.name();
// Give the main thread a chance to try to write the instances
Thread.sleep(sleepMillis);
tx.commit();
}
catch (InterruptedException ex) {
throw new RuntimeException(ex);
}
finally {
cleanupPM(parallelPM);
}
}
}
/** Runnable class updating instances and causing them to be write locked. */
class ParallelWriter implements Runnable {
private final int sleepMillis;
ParallelWriter(int sleepMillis) {
this.sleepMillis = sleepMillis;
}
public void run() {
PersistenceManager parallelPM = getPMF().getPersistenceManager();
Transaction tx = parallelPM.currentTransaction();
// Run datastore transaction
tx.setOptimistic(false);
try {
tx.begin();
PCPoint p1 = (PCPoint)parallelPM.getObjectById(point1Oid);
p1.setX(210);
p1.setY(220);
PCPoint p2 = (PCPoint)parallelPM.getObjectById(point2Oid);
p2.setX(230);
p2.setY(240);
// Flush will set a write lock on the instances
parallelPM.flush();
// Give the main thread a chance to try to read the instances
Thread.sleep(sleepMillis);
tx.commit();
}
catch (InterruptedException ex) {
throw new RuntimeException(ex);
}
finally {
cleanupPM(parallelPM);
}
}
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanager/DeletePersistent.java 100664 17133 12500110374 27531 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager;
import java.util.Collection;
import java.util.HashSet;
import javax.jdo.JDOUserException;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Delete Persistent
*Keywords:
*Assertion IDs: A12.5.7-9
*Assertion Description:
PersistenceManager.deletePersistent and deletePersistentAll delete a persistent instance(s) from the data store. It must be called in the context of an active transaction, or a JDOUserExceptionis thrown. The representation in the data store will be deleted when this instance is flushed to the data store (via commit, or evict).
*/
public class DeletePersistent extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.5.7-9 (DeletePersistent) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(DeletePersistent.class);
}
private PCPoint p1 = null;
private PCPoint p2 = null;
private PCPoint p3 = null;
private PCPoint p4 = null;
private PCPoint p5 = null;
/** */
public void testDeletePersistent() {
pm = getPM();
createObjects(pm);
/* positive tests */
/* method called in the context of an active transaction */
runTestDeletePersistent1(pm);
runTestDeletePersistent2(pm);
runTestDeletePersistent3(pm);
/* negative tests */
/* method called in the context of an non-active transaction */
runTestDeletePersistent4(pm);
runTestDeletePersistent5(pm);
runTestDeletePersistent6(pm);
pm.close();
pm = null;
}
/** */
private void createObjects(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
p1 = new PCPoint(1,3);
p2 = new PCPoint(2,4);
p3 = new PCPoint(3,5);
p4 = new PCPoint(4,6);
p5 = new PCPoint(5,7);
pm.makePersistent(p1);
pm.makePersistent(p2);
pm.makePersistent(p3);
pm.makePersistent(p4);
pm.makePersistent(p5);
tx.commit();
}
finally {
if (tx.isActive())
tx.rollback();
}
}
/** test deletePersistent (Object pc) */
private void runTestDeletePersistent1(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
tx = pm.currentTransaction();
tx.begin();
pm.deletePersistent(p1);
tx.commit();
if (debug) logger.debug(" \nPASSED in testDeletePersistent1()");
}
finally {
if (tx.isActive())
tx.rollback();
}
}
/* test deletePersistentAll (Collection pcs) */
private void runTestDeletePersistent2(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
Collection col1 = new java.util.HashSet();
col1.add(p2);
col1.add(p3);
pm.deletePersistentAll(col1);
tx.commit();
if (debug) logger.debug(" \nPASSED in testDeletePersistent2()");
}
finally {
if (tx.isActive())
tx.rollback();
}
}
/* test deletePersistentAll (Object[] o) */
private void runTestDeletePersistent3(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
Collection col1 = new HashSet();
col1.add(p4);
col1.add(p5);
Object[] obj1= col1.toArray();
pm.deletePersistentAll(obj1);
tx.commit();
if (debug) logger.debug(" \nPASSED in testDeletePersistent3()");
}
finally {
if (tx.isActive())
tx.rollback();
}
}
/* test deletePersistent (Object pc) */
public void runTestDeletePersistent4(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
PCPoint np1 = new PCPoint(1,3);
pm.makePersistent(np1);
tx.commit();
try {
pm.deletePersistent(np1);
fail(ASSERTION_FAILED,
"pm.deletePersistent(Object) outside of tx should throw an exception");
}
catch (JDOUserException ex) {
// expected exception
}
}
finally {
if (tx.isActive())
tx.rollback();
}
}
/* test deletePersistentAll (Collection pcs) */
public void runTestDeletePersistent5(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
PCPoint np1 = new PCPoint (3,3);
PCPoint np2 = new PCPoint (4,4);
pm.makePersistent(np1);
pm.makePersistent(np2);
tx.commit();
Collection col1 = new java.util.HashSet();
col1.add(np1);
col1.add(np2);
try {
pm.deletePersistentAll(col1);
fail(ASSERTION_FAILED,
"pm.deletePersistentAll(Collection) outside of tx should throw an exception");
}
catch (JDOUserException ex) {
// expected exception
}
}
finally {
if (tx.isActive())
tx.rollback();
}
}
/* test deletePersistentAll (Object[] o) */
public void runTestDeletePersistent6(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
PCPoint np1 = new PCPoint (3,3);
PCPoint np2 = new PCPoint (4,4);
pm.makePersistent(np1);
pm.makePersistent(np2);
tx.commit();
Collection col1 = new java.util.HashSet();
col1.add(np1);
col1.add(np2);
Object[] obj1=col1.toArray();
try {
pm.deletePersistentAll(obj1);
fail(ASSERTION_FAILED,
"pm.deletePersistentAll(Object[]) outside of tx should throw an exception");
}
catch (JDOUserException ex) {
// expected exception
}
}
finally {
if (tx.isActive())
tx.rollback();
}
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanager/DeletePersistentAllFails.java 100664 12000 12500110374 31125 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager;
import java.util.Collection;
import javax.jdo.JDOUserException;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.pc.mylib.Point;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: DeletePersistentAll Fails
*Keywords: exception
*Assertion IDs: A12.5.7-2.
*Assertion Description:
If a collection or array of instances is passed to PersistenceManager.deletePersistentAll, and one or more of the instances fail to complete the required operation, then all instances will be attempted, and a JDOUserException will be thrown which contains nested exceptions, each of which contains one of the failing instances. The succeeding instances will transition to the specified life cycle state, and the failing instances will remain in their current state.
*/
public class DeletePersistentAllFails extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.5.7-2 (DeletePersistentAllFails) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(DeletePersistentAllFails.class);
}
private PCPoint p1 = null;
private PCPoint p2 = null;
private PCPoint p3 = null;
private PCPoint p4 = null;
private PCPoint p5 = null;
/** */
public void testDeletePersistentAllFails() {
pm = getPM();
createObjects(pm);
runTestDeletePersistentAllFails1(pm);
runTestDeletePersistentAllFails2(pm);
pm.close();
pm = null;
}
private void createObjects(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
p1 = new PCPoint(1,3);
p2 = new PCPoint(2,4);
p3 = new PCPoint(3,5);
p4 = new PCPoint(4,6);
p5 = new PCPoint(5,7);
pm.makePersistent(p1);
pm.makePersistent(p2);
pm.makePersistent(p3);
pm.makePersistent(p4);
pm.makePersistent(p5);
tx.commit();
}
finally {
if (tx.isActive())
tx.rollback();
}
}
/* test deletePersistentAll (Collection pcs) */
private void runTestDeletePersistentAllFails1(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
Point np3 = new Point (5,5);
Collection col1 = new java.util.HashSet();
col1.add(p1);
col1.add(p2);
col1.add(np3);
try {
pm.deletePersistentAll(col1);
fail(ASSERTION_FAILED,
"pm.deletePersistentAll(Collection) with non persistent instances should throw an exception");
}
catch (JDOUserException ex) {
// expected exception
}
tx.rollback();
}
finally {
if (tx.isActive())
tx.rollback();
}
}
/* test deletePersistentAll (Object[] o) */
private void runTestDeletePersistentAllFails2(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
Point np3 = new Point (5,5);
Collection col1 = new java.util.HashSet();
col1.add(p3);
col1.add(p4);
col1.add(np3);
Object[] obj1=col1.toArray();
try {
pm.deletePersistentAll(obj1);
fail(ASSERTION_FAILED,
"pm.deletePersistentAll(Object[]) with non persistent instances should throw an exception");
}
catch (JDOUserException ex) {
// expected exception
}
tx.rollback();
}
finally {
if (tx.isActive())
tx.rollback();
}
}
}
././@LongLink 100644 0 0 147 12500111677 10255 L ustar 0 0 tck/src/java/org/apache/jdo/tck/api/persistencemanager/DeletePersistentFailsIfInstanceIsTransient.java tck/src/java/org/apache/jdo/tck/api/persistencemanager/DeletePersistentFailsIfInstanceIsTransient.ja100664 10754 12500110374 34313 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager;
import java.util.Collection;
import javax.jdo.JDOUserException;
import javax.jdo.Transaction;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: DeletePersistent Fails If Instance Is Transient
*Keywords: exception
*Assertion IDs: A12.5.7-12.
*Assertion Description:
PersistenceManager.deletePersistent and deletePersistentAll will throw a JDOUserException if the parameter instance is transient.
*/
public class DeletePersistentFailsIfInstanceIsTransient extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.5.7-12 (DeletePersistentFailsIfInstanceIsTransient) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(DeletePersistentFailsIfInstanceIsTransient.class);
}
/** */
public void testDeletePersistentFailsIfInstanceIsTransient() {
pm = getPM();
runTestDeletePersistent();
runTestDeletePersistentAll1();
runTestDeletePersistentAll2();
pm.close();
pm = null;
}
/* test deletePersistent (Object pc) */
private void runTestDeletePersistent() {
Transaction tx = pm.currentTransaction();
try {
tx = pm.currentTransaction();
tx.begin();
PCPoint p1 = new PCPoint (3,3);
try {
pm.deletePersistent(p1);
fail(ASSERTION_FAILED,
"pm.deletePersistent(Object) with transient instance should throw exception");
}
catch (JDOUserException ex) {
// expected exception
}
tx.rollback();
}
finally {
if (tx.isActive())
tx.rollback();
}
}
/* test deletePersistentAll (Collection pcs) */
private void runTestDeletePersistentAll1() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
PCPoint p1 = new PCPoint (3,3);
PCPoint p2 = new PCPoint (4,4);
Collection col1 = new java.util.HashSet();
col1.add(p1);
col1.add(p2);
try {
pm.deletePersistentAll(col1);
fail(ASSERTION_FAILED,
"pm.deletePersistent(Collection) with transient instance(s) should throw exception");
}
catch (JDOUserException ex) {
// expected exception
}
tx.rollback();
}
finally {
if (tx.isActive())
tx.rollback();
}
}
/* test deletePersistentAll (Object[] o) */
private void runTestDeletePersistentAll2() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
PCPoint p1 = new PCPoint (3,3);
PCPoint p2 = new PCPoint (4,4);
Collection col1 = new java.util.HashSet();
col1.add(p1);
col1.add(p2);
try {
pm.deletePersistentAll(col1.toArray());
fail(ASSERTION_FAILED,
"pm.deletePersistent(Object[]) with transient instance(s) should throw exception");
}
catch (JDOUserException ex) {
// expected exception
}
tx.rollback();
}
finally {
if (tx.isActive())
tx.rollback();
}
}
}
././@LongLink 100644 0 0 176 12500111677 10257 L ustar 0 0 tck/src/java/org/apache/jdo/tck/api/persistencemanager/DeletePersistentFailsIfInstanceManagedByAnotherPersistenceManager.java tck/src/java/org/apache/jdo/tck/api/persistencemanager/DeletePersistentFailsIfInstanceManagedByAnoth100664 13167 12500110374 34301 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager;
import java.util.Collection;
import java.util.HashSet;
import javax.jdo.JDOUserException;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: DeletePersistent Fails If Instance Managed By Another PersistenceManager
*Keywords: exception
*Assertion IDs: A12.5.7-11.
*Assertion Description:
PersistenceManager.deletePersistent and deletePersistentAll will throw a JDOUserException if the parameter instance is managed by a different PersistenceManager.
*/
public class DeletePersistentFailsIfInstanceManagedByAnotherPersistenceManager extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.5.7-11 (DeletePersistentFailsIfInstanceManagedByAnotherPersistenceManager) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(DeletePersistentFailsIfInstanceManagedByAnotherPersistenceManager.class);
}
private PCPoint p1 = null;
private PCPoint p2 = null;
private PCPoint p3 = null;
private PCPoint p4 = null;
private PCPoint p5 = null;
/** */
public void testDeletePersistentFailsIfInstanceManagedByAnotherPersistenceManager() {
pm = getPM();
PersistenceManager pm2 = getPMF().getPersistenceManager();
try {
createObjects(pm2);
/* positive tests */
runTestDeletePersistent(pm);
runTestDeletePersistentAll1(pm);
runTestDeletePersistentAll2(pm);
}
finally {
cleanupPM(pm2);
pm2 = null;
cleanupPM(pm);
pm = null;
}
}
/** */
private void createObjects(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
p1 = new PCPoint(1,3);
p2 = new PCPoint(2,4);
p3 = new PCPoint(3,5);
p4 = new PCPoint(4,6);
p5 = new PCPoint(5,7);
pm.makePersistent(p1);
pm.makePersistent(p2);
pm.makePersistent(p3);
pm.makePersistent(p4);
pm.makePersistent(p5);
tx.commit();
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
/* test deletePersistent (Object pc) */
private void runTestDeletePersistent(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
try {
pm.deletePersistent(p1);
fail(ASSERTION_FAILED,
"pm.deletePersistent(Object) with pc instance managed by another pm should throw exception");
}
catch (JDOUserException ex) {
// expected exception
}
tx.rollback();
}
finally {
if (tx.isActive())
tx.rollback();
}
}
/* test deletePersistentAll (Collection pcs) */
private void runTestDeletePersistentAll1(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
Collection col1 = new HashSet();
col1.add(p2);
col1.add(p3);
try {
pm.deletePersistentAll(col1);
fail(ASSERTION_FAILED,
"pm.deletePersistent(Collection) with pc instance(s) managed by another pm should throw exception");
}
catch (JDOUserException ex) {
// expected exception
}
tx.rollback();
}
finally {
if (tx.isActive())
tx.rollback();
}
}
/* test deletePersistentAll (Object[] o) */
private void runTestDeletePersistentAll2(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
Collection col1 = new HashSet();
col1.add(p4);
col1.add(p5);
Object[] obj1= col1.toArray();
try {
pm.deletePersistentAll(obj1);
fail(ASSERTION_FAILED,
"pm.deletePersistent(Object[]) with pc instance(s) managed by another pm should throw exception");
}
catch (JDOUserException ex) {
// expected exception
}
tx.rollback();
}
finally {
if (tx.isActive())
tx.rollback();
}
}
}
././@LongLink 100644 0 0 152 12500111677 10251 L ustar 0 0 tck/src/java/org/apache/jdo/tck/api/persistencemanager/DeletePersistentHasNoEffectOnDeletedInstances.java tck/src/java/org/apache/jdo/tck/api/persistencemanager/DeletePersistentHasNoEffectOnDeletedInstances100664 11735 12500110374 34315 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager;
import java.util.Collection;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: DeletePersistent Has No Effect On Deleted Instances
*Keywords:
*Assertion IDs: A12.5.7-10.
*Assertion Description:
PersistenceManager.deletePersistent and deletePersistentAll have no effect on parameter instances already deleted in the transaction.
*/
public class DeletePersistentHasNoEffectOnDeletedInstances extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.5.7-10 (DeletePersistentHasNoEffectOnDeletedInstances) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(DeletePersistentHasNoEffectOnDeletedInstances.class);
}
private PCPoint p1 = null;
private PCPoint p2 = null;
private PCPoint p3 = null;
private PCPoint p4 = null;
private PCPoint p5 = null;
/** */
public void testDeletePersistentHasNoEffectOnDeletedInstances() {
pm = getPM();
createObjects(pm);
runTestDeletePersistent(pm);
runTestDeletePersistentAll1(pm);
runTestDeletePersistentAll2(pm);
pm.close();
pm = null;
}
/** */
private void createObjects(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
p1 = new PCPoint(1,3);
p2 = new PCPoint(2,4);
p3 = new PCPoint(3,5);
p4 = new PCPoint(4,6);
p5 = new PCPoint(5,7);
pm.makePersistent(p1);
pm.makePersistent(p2);
pm.makePersistent(p3);
pm.makePersistent(p4);
pm.makePersistent(p5);
tx.commit();
}
finally {
if (tx.isActive())
tx.rollback();
}
}
/* test makePersistent (Object pc) */
private void runTestDeletePersistent(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
pm.deletePersistent(p1);
pm.deletePersistent(p1);
pm.deletePersistent(p1);
pm.deletePersistent(p1);
tx.commit();
if (debug) logger.debug(" \nPASSED in testDeletePersistent()");
}
finally {
if (tx.isActive())
tx.rollback();
}
}
/* test makePersistentAll (Collection pcs) */
private void runTestDeletePersistentAll1(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
tx = pm.currentTransaction();
Collection col1 = new java.util.HashSet();
col1.add(p2);
col1.add(p3);
tx.begin();
pm.deletePersistentAll(col1);
pm.deletePersistentAll(col1);
pm.deletePersistentAll(col1);
pm.deletePersistentAll(col1);
tx.commit();
if (debug) logger.debug(" \nPASSED in testDeletePersistentAll1()");
}
finally {
if (tx.isActive())
tx.rollback();
}
}
/* test makePersistentAll (Object[] o) */
private void runTestDeletePersistentAll2(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
Collection col1 = new java.util.HashSet();
col1.add(p4);
col1.add(p5);
Object[] obj1= col1.toArray();
tx.begin();
pm.deletePersistentAll(obj1);
pm.deletePersistentAll(obj1);
pm.deletePersistentAll(obj1);
pm.deletePersistentAll(obj1);
tx.commit();
if (debug) logger.debug(" \nPASSED in testDeletePersistentAll2()");
}
finally {
if (tx.isActive())
tx.rollback();
}
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanager/detach/CopyOnAttachFalse.java 100664 6715 12500110374 30771 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.detach;
import javax.jdo.JDOUserException;
import org.apache.jdo.tck.pc.shoppingcart.Cart;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
* Title: Test DetachAttach
* Keywords: makePersistent detach
* Assertion IDs:
* Assertion Description:
* A12.6.8-29 [If the CopyOnAttach property is false, then the instance itself
is transitioned to persistent-clean for datastore transactions or persistent-nontransactional for optimistic
transactions. If there already is an instance in the cache with the same identity, JDOUserException
is thrown.]
*/
public class CopyOnAttachFalse extends DetachTest {
private static final String ASSERTION_FAILED =
"Assertion A12.6.8 (CopyOnAttachFalse) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(CopyOnAttachFalse.class);
}
/** */
/**
*/
public void testAttachClean() {
Cart detachedCart = createDetachedInstance(ASSERTION_FAILED);
pm.setCopyOnAttach(false);
pm.currentTransaction().begin();
Cart attachedCart = (Cart)pm.makePersistent(detachedCart);
assertTrue("Expected attached object to == detached object.",
attachedCart == detachedCart);
pm.currentTransaction().commit();
}
/** */
public void testAttachDirty() {
Cart detachedCart = createDetachedInstance(ASSERTION_FAILED);
pm.setCopyOnAttach(false);
pm.currentTransaction().begin();
cartEntry1.setQuantity(500);
goldenCartEntry.setQuantity(500);
Cart attachedCart = (Cart)pm.makePersistent(detachedCart);
assertTrue("Expected attached object to == detached object.",
attachedCart == detachedCart);
pm.currentTransaction().commit();
}
/**
*/
public void testNegativeAttachClean() {
Cart detachedCart = createDetachedInstance(ASSERTION_FAILED);
pm.setCopyOnAttach(false);
pm.currentTransaction().begin();
// Obtain new instance of cart1
pm.getObjectById(cart1oid, false);
try {
Cart attachedCart = (Cart)pm.makePersistent(detachedCart);
fail("Expected JDOUserException. Object with same identity as "
+ "attached object is already in the cache.");
} catch (JDOUserException jdoe) {
// expected exception
}
pm.currentTransaction().commit();
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanager/detach/DetachAccessUnloadedField.java 100664 12474 12500110374 32433 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.detach;
import javax.jdo.FetchPlan;
import javax.jdo.JDODetachedFieldAccessException;
import org.apache.jdo.tck.pc.shoppingcart.CartEntry;
import org.apache.jdo.tck.pc.shoppingcart.Product;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
* Title: Test DetachCopy
* Keywords: detachCopy detach
* Assertion IDs: A12.6.8-21
* Assertion Description:
* While detached, any field access to a field that was not loaded throws JDODetachedFieldAccessException.
*/
public class DetachAccessUnloadedField extends DetachTest {
private static final String ASSERTION_FAILED =
"Assertion A12.6.8-21 (DetachCopy) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(DetachAccessUnloadedField.class);
}
/**
* Positive test for field access of detached instance
* Field is in fetch group,
* loaded at detachment with DETACH_LOAD_FIELDS true
*/
public void testDetachCopyFieldAccessOk() {
// datastore transaction, retainValues=false
getPM().currentTransaction().begin();
// sets fetch group cart, entries, product
setCartFetchGroups();
// DETACH_LOAD_FIELDS true by default
CartEntry cartEntryDetached = (CartEntry)pm.detachCopy(cartEntry1);
try {
Product prod = cartEntryDetached.getProduct();
} catch (JDODetachedFieldAccessException jdoex) {
fail("Unexpected exception caught: " + jdoex.getMessage());
}
pm.currentTransaction().commit();
}
/**
* Positive test for access of loaded field of detached instance
* All fields are in the fetch plan
* detachment options = 0, fields loaded by access of an instance
*/
public void testDetachCopyAccessLoadedField() {
// datastore transaction, retainValues=false
getPM().currentTransaction().begin();
// sets fetch group cart, entries, product
setCartFetchGroups();
// loads Product field
int quantity = cartEntry1.getQuantity();
pm.getFetchPlan().setDetachmentOptions(0);
CartEntry cartEntryDetached = (CartEntry)pm.detachCopy(cartEntry1);
try {
Product prodDetached = cartEntryDetached.getProduct();
} catch (JDODetachedFieldAccessException jdoex) {
fail("Unexpected exception caught: " + jdoex.getMessage());
} finally {
pm.currentTransaction().commit();
}
}
/**
* Negative test for access of unloaded field of detached instance
* with DETACH_UNLOAD_FIELDS set
*/
public void testDetachCopyAccessUnloadedField() {
// datastore transaction, retainValues=false
getPM().currentTransaction().begin();
// sets fetch group cart, entries, product
setCartFetchGroups();
Product prod = cartEntry1.getProduct();
pm.getFetchPlan().removeGroup(CARTENTRY_PRODUCT);
pm.getFetchPlan().setDetachmentOptions(FetchPlan.DETACH_UNLOAD_FIELDS);
CartEntry cartEntryDetached = (CartEntry)pm.detachCopy(cartEntry1);
try {
Product prodDetached = cartEntryDetached.getProduct();
fail("Expected exception on access of unloaded field, " +
"but none thrown.");
} catch (JDODetachedFieldAccessException jdoex) {
// expect exception
} finally {
pm.currentTransaction().commit();
}
}
/**
* Negative test for access of field of detached instance
* where field was not loaded
*/
public void testDetachCopyAccessFieldNotInFetchPlan() {
// datastore transaction, retainValues=false
getPM().currentTransaction().begin();
FetchPlan fp = pm.getFetchPlan();
// Product field not in Fetch Plan
fp.addGroup(CART_ENTRIES);
fp.addGroup(CARTENTRY_CART);
CartEntry cartEntryDetached = (CartEntry)pm.detachCopy(cartEntry1);
try {
Product prod = cartEntryDetached.getProduct();
fail("Expected exception on access of field not in fetch plan" +
" and not loaded, but none thrown.");
} catch (JDODetachedFieldAccessException jdoex) {
// expect exception
} finally {
pm.currentTransaction().commit();
}
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanager/detach/DetachAllOnCommit.java 100664 5517 12500110374 30750 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.detach;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.Collection;
import java.util.HashSet;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.pc.shoppingcart.Cart;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
* Title: Test DetachAllOnCommit
* Keywords: DetachAllOnCommit detach
* Assertion IDs: A12.6.8-3
* Assertion Description:
With this flag set to true, during beforeCompletion
all cached instances are prepared
for detachment according to the fetch plan
in effect at commit. Loading fields and unload-
ing fields required by the fetch plan
is done after calling the user's beforeCompletion
callback. During afterCompletion, before calling
the user's afterCompletion callback, all detachable
persistent instances in the cache transition
to detached; non-detachable persistent instances
transition to transient; and detachable instances can be serialized
as detached instances. Transient transactional instances
are unaffected by this flag.
*/
public class DetachAllOnCommit extends DetachTest {
private static final String ASSERTION_FAILED =
"Assertion A12.6.8-3 (DetachAllOnCommit) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(DetachAllOnCommit.class);
}
/** */
public void testDetachAllOnCommit() {
getPM().currentTransaction().begin();
setCartFetchGroups();
pm.retrieveAll(cartClosure);
pm.setDetachAllOnCommit(true);
pm.currentTransaction().commit();
checkCartValues(ASSERTION_FAILED +
"after commit with DetachAllOnCommit," + NL, cart1);
failOnError();
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanager/detach/DetachAttach.java 100664 4476 12500110374 30001 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.detach;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.Collection;
import java.util.HashSet;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.pc.shoppingcart.Cart;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
* Title: Test DetachAttach
* Keywords: makePersistent detach
* Assertion IDs:
* Assertion Description:
For a detached instance, they locate or create a persistent
instance with the same JDO identity as the detached instance
*/
public class DetachAttach extends DetachTest {
private static final String ASSERTION_FAILED =
"Assertion A12.6.8 (DetachAttach) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(DetachAttach.class);
}
/** */
public void testAttachClean() {
Cart detachedCart = createDetachedInstance(ASSERTION_FAILED);
pm.currentTransaction().begin();
Cart attachedCart = (Cart)pm.makePersistent(detachedCart);
checkCartValues(ASSERTION_FAILED +
"after attach," + NL, attachedCart, true);
pm.currentTransaction().commit();
failOnError();
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanager/detach/DetachAttachDirty.java 100664 5455 12500110374 31013 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.detach;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.Collection;
import java.util.HashSet;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.pc.shoppingcart.Cart;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
* Title: Test DetachAttach
* Keywords: makePersistent detach dirty
* Assertion IDs: A12.6.8-26
* Assertion Description:
For a detached instance, they locate or create a persistent
instance with the same JDO identity as the detached instance,
and merge the persistent
state of the detached instance into the persistent instance.
*/
public class DetachAttachDirty extends DetachTest {
private static final String ASSERTION_FAILED =
"Assertion A12.6.8-26 (DetachAttachDirty) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(DetachAttach.class);
}
/** */
public void testAttachDirty() {
Cart detachedCart = createDetachedInstance(ASSERTION_FAILED);
pm.currentTransaction().begin();
cartEntry1.setQuantity(500);
goldenCartEntry.setQuantity(500);
Cart attachedCart = (Cart)pm.makePersistent(detachedCart);
checkCartValues(ASSERTION_FAILED +
"after attach," + NL, attachedCart, true);
pm.currentTransaction().commit();
pm.currentTransaction().begin();
Cart persistentCart = (Cart)pm.getObjectById(cart1oid);
checkCartValues(ASSERTION_FAILED +
"after attach, commit, begin, getObjectById," + NL,
persistentCart, true);
pm.currentTransaction().commit();
failOnError();
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanager/detach/DetachCopy.java 100664 7264 12500110374 27505 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.detach;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.Collection;
import java.util.HashSet;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.pc.shoppingcart.Cart;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
* Title: Test DetachCopy
* Keywords: detachCopy detach
* Assertion IDs: A12.6.8-13, A12.6.8-18, A12.6.8-19, A12.6.8-20
* Assertion Description:
For each instance in the parameter Collection, a
corresponding detached copy is returned. Each field in the
persistent instance is handled based on its type and whether the
field is contained in the fetch group for the persistence-capable
class. If there are duplicates in the parameter Collection,
the corresponding detached copy is used for each such duplicate.
*/
public class DetachCopy extends DetachTest {
private static final String ASSERTION_FAILED =
"Assertion A12.6.8-13, A12.6.8-18, A12.6.8-19, A12.6.8-20" +
" (DetachCopy) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(DetachCopy.class);
}
/** */
public void testDetachCopy() {
getPM().currentTransaction().begin();
setCartFetchGroups();
//pm.retrieveAll(cartClosure);
Cart cartDetached = (Cart)pm.detachCopy(cart1);
checkCartValues(ASSERTION_FAILED +
"after detachCopy," + NL, cartDetached);
pm.currentTransaction().commit();
failOnError();
}
/** */
public void testDetachCopyAllCollection() {
getPM().currentTransaction().begin();
setCartFetchGroups();
//pm.retrieveAll(cartClosure);
Collection instances = new HashSet();
instances.add(cart1);
Collection detached = pm.detachCopyAll(instances);
Cart cartDetached = (Cart)detached.iterator().next();
checkCartValues(ASSERTION_FAILED +
"after detachCopyAll(Collection)," + NL, cartDetached);
pm.currentTransaction().commit();
failOnError();
}
/** */
public void testDetachCopyAllArray() {
getPM().currentTransaction().begin();
setCartFetchGroups();
//pm.retrieveAll(cartClosure);
Object[] instances = new Object[]{cart1};
Object[] detached = pm.detachCopyAll(instances);
Cart cartDetached = (Cart)detached[0];
checkCartValues(ASSERTION_FAILED +
"after detachCopyAll(Object[])," + NL, cartDetached);
pm.currentTransaction().commit();
failOnError();
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanager/detach/DetachSerialize.java 100664 7340 12500110374 30515 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.detach;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.pc.shoppingcart.Cart;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
* Title: Test DetachSerialize
* Keywords: serialize detach
* Assertion IDs: A12.6.8-4, A12.6.8-5
* Assertion Description:
The JDO 1.0 specification requires that serialized instances
be made ready for serialization
by instantiating all serializable persistent fields
before calling writeObject. For binary-
compatible implementations, this is done by the enhancer
adding a call to the StateManager prior to invoking the user's
writeObject method.
The behavior is the same in
JDO 2.0, with the additional requirement that restored
detachable serialized instances are
treated as detached instances.
*/
public class DetachSerialize extends DetachTest {
private static final String ASSERTION_FAILED =
"Assertion A12.6.8-4, A12.6.8-5 (DetachSerialize) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(DetachSerialize.class);
}
/** */
public void testDetachSerialize() {
getPM().currentTransaction().begin();
setCartFetchGroups();
//pm.retrieveAll(cartClosure);
Cart cartDetached = (Cart)detachClosure(cart1);
checkCartValues(ASSERTION_FAILED + "after deserializing cart," + NL,
cartDetached);
pm.currentTransaction().commit();
failOnError();
}
/** Detach the parameter instance.
*/
protected Object detachClosure(Object pc) {
byte[] cartStream = serialize(pc);
return deserialize(cartStream);
}
/** */
private byte[] serialize(Object root) {
try {
ByteArrayOutputStream baos =
new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos);
oos.writeObject(root);
return baos.toByteArray();
} catch (Exception ex) {
fail(ASSERTION_FAILED + "serializing cart:" + ex.toString());
return null; // will not be reached
}
}
private Object deserialize(byte[] stream) {
try {
ByteArrayInputStream bais =
new ByteArrayInputStream(stream);
ObjectInputStream ois = new ObjectInputStream(bais);
return ois.readObject();
} catch (Exception ex) {
fail(ASSERTION_FAILED + "deserializing cart:" + ex.toString());
return null; // will not be reached
}
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanager/detach/DetachTest.java 100664 15105 12500110374 27523 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.detach;
import java.util.Iterator;
import javax.jdo.FetchPlan;
import javax.jdo.JDOHelper;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.shoppingcart.CartEntry;
import org.apache.jdo.tck.pc.shoppingcart.Cart;
import org.apache.jdo.tck.pc.shoppingcart.Product;
import org.apache.jdo.tck.pc.shoppingcart.Undetachable;
import javax.jdo.PersistenceManager;
/**
*
*/
public abstract class DetachTest extends JDO_Test {
protected Cart cart1;
protected CartEntry cartEntry1;
protected Product product1;
protected Object cart1oid;
protected Cart goldenCart;
protected CartEntry goldenCartEntry;
protected Object[] cartClosure;
protected final static String CART_ENTRIES = "Cart.entries";
protected final static String CARTENTRY_CART = "CartEntry.cart";
protected final static String CARTENTRY_PRODUCT = "CartEntry.product";
protected final static String[] CART_FETCH_GROUPS = new String[]
{FetchPlan.DEFAULT, CART_ENTRIES, CARTENTRY_CART, CARTENTRY_PRODUCT};
/** Creates a new instance of DetachTest */
public DetachTest() {
}
/** */
protected void localSetUp() {
addTearDownClass(CartEntry.class);
addTearDownClass(Cart.class);
addTearDownClass(Product.class);
addTearDownClass(Undetachable.class);
Product goldenProduct = new Product("PRODUCT1", "Product 1");
goldenCart = new Cart("142857");
goldenCartEntry =
goldenCart.newCartEntry(goldenProduct, 100);
product1 = new Product("PRODUCT1", "Product 1");
cart1 = new Cart("142857");
cartEntry1 = new CartEntry(
cart1, goldenCartEntry.getId(), product1, 100);
cartClosure = new Object[]
{cart1, cartEntry1, product1};
getPM().currentTransaction().begin();
pm.makePersistent(cart1);
cart1oid = pm.getObjectId(cart1);
pm.currentTransaction().commit();
}
/** */
protected void setCartFetchGroups() {
FetchPlan fp = getPM().getFetchPlan();
fp.setGroups(CART_FETCH_GROUPS);
fp.setMaxFetchDepth(2);
}
/** */
protected void checkState(String location, Object obj,
boolean persistent) {
if(persistent) {
if (JDOHelper.isPersistent(obj))
return;
} else if (JDOHelper.isDetached(obj))
return;
appendMessage(location +
" should be " +
(persistent?"persistent":"detached") +
" but is not. The object state is: " +
states[currentState(obj)] + " " + getStateOfInstance(obj));
}
/** */
protected void reportDifference(String location,
long expected, long actual) {
appendMessage(location + NL +
"expected: " + expected + NL +
"actual: " + actual);
}
/** */
protected void reportDifference(String location,
Object expected, Object actual) {
appendMessage(location + NL +
"expected: " + expected + NL +
" actual: " + actual);
}
/** */
protected void checkCartValues(String location, Cart cart) {
checkCartValues(location, cart, false);
}
/** */
protected void checkCartValues(String location, Cart cart,
boolean persistent) {
checkState(location + "Cart instance", cart, persistent);
if (!goldenCart.getCustomerId().equals(cart.getCustomerId()))
reportDifference(location +
" differences in cart.customerId",
goldenCart.getCustomerId(), cart.getCustomerId());
Iterator goldenCartEntries = goldenCart.getEntries();
Iterator cartEntries = cart.getEntries();
while (cartEntries.hasNext()) {
CartEntry goldenCartEntry = (CartEntry)goldenCartEntries.next();
CartEntry cartEntry = (CartEntry)cartEntries.next();
checkState(location + "CartEntry instance", cartEntry,
persistent);
Cart cartEntryCart = cartEntry.getCart();
if (cartEntryCart != cart) {
reportDifference(location +
" incorrect value for cartEntry.cart",
cart, cartEntryCart);
}
if (goldenCartEntry.getId() != cartEntry.getId())
reportDifference(location +
" differences in cartEntry.id",
goldenCartEntry.getId(), cartEntry.getId());
if (goldenCartEntry.getQuantity() != cartEntry.getQuantity())
reportDifference(location +
" differences in cartEntry.quantity",
goldenCartEntry.getQuantity(), cartEntry.getQuantity());
Product goldenProduct = goldenCartEntry.getProduct();
Product product = cartEntry.getProduct();
checkState(location + "Product instance", product,
persistent);
if (!goldenProduct.getDescription()
.equals(product.getDescription()))
reportDifference(location +
" differences in product.description",
goldenProduct.getDescription(), product.getDescription());
}
}
/** */
protected Cart createDetachedInstance(String ASSERTION_FAILED) {
getPM().currentTransaction().begin();
setCartFetchGroups();
pm.retrieveAll(cartClosure);
pm.setDetachAllOnCommit(true);
pm.currentTransaction().commit();
checkCartValues(ASSERTION_FAILED +
"after commit with DetachAllOnCommit,", cart1);
failOnError();
pm.setDetachAllOnCommit(false);
return cart1;
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanager/detach/DetachUndetachable.java 100664 5022 12500110374 31140 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.detach;
import javax.jdo.JDOHelper;
import org.apache.jdo.tck.pc.shoppingcart.Undetachable;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
* Title: Test DetachUndetachable
* Keywords: detachCopy detach detachable
* Assertion IDs: A12.6.8-32
* Assertion Description:
Instances to be detached that are not of a Detachable class are detached as transient instances.
*/
public class DetachUndetachable extends DetachTest {
private static final String ASSERTION_FAILED =
"Assertion A12.6.8-32 (DetachUndetachable) failed: ";
protected Undetachable un1;
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(DetachUndetachable.class);
}
/** */
public void testDetachUndetachable() {
setupUndetachable();
getPM().currentTransaction().begin();
Undetachable instance = (Undetachable)pm.detachCopy(un1);
if (JDOHelper.isPersistent((Object)instance)) {
appendMessage("testDetachUndetachable: should be transient" +
" but is not. The object state is: " +
states[currentState((Object)instance)]
+ " " + getStateOfInstance((Object)instance));
}
pm.currentTransaction().commit();
failOnError();
}
protected void setupUndetachable() {
un1 = new Undetachable();
getPM().currentTransaction().begin();
pm.makePersistent(un1);
pm.currentTransaction().commit();
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanager/detach/SetDetachAllOnCommit.java 100664 5143 12500110374 31417 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.detach;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
* Title: Test SetDetachAllOnCommit
* Keywords: DetachAllOnCommit commit detach
* Assertion IDs: A12.6.8-1, A12.6.8-2
* Assertion Description:
* We define a new property called DetachAllOnCommit
* PersistenceManager.setDetachAllOnCommit(boolean detachAllOnCommit)
* sets the DetachAllOnCommit property
* PersistenceManager.getDetachAllOnCommit()
* The value of the DetachAllOnCommit flag is returned.
*/
public class SetDetachAllOnCommit extends DetachTest {
private static final String ASSERTION_FAILED = "Assertion A12.6.8-1 (pm.setDetachAllOnCommit) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(SetDetachAllOnCommit.class);
}
/** */
public void test() {
pm = getPM();
runTestSetDetachAllOnCommit(pm);
pm.close();
pm = null;
}
/** */
protected void runTestSetDetachAllOnCommit(PersistenceManager pm) {
pm.setDetachAllOnCommit(false);
if (pm.getDetachAllOnCommit()) {
fail(ASSERTION_FAILED,
"pm.getDetachAllOnCommit() should return false after setting the flag to false.");
}
pm.setDetachAllOnCommit(true);
if (!pm.getDetachAllOnCommit()) {
fail(ASSERTION_FAILED,
"pm.getDetachAllOnCommit() should return true after setting the flag to true.");
}
}
}
././@LongLink 100644 0 0 167 12500111677 10257 L ustar 0 0 tck/src/java/org/apache/jdo/tck/api/persistencemanager/extent/GetExtentWithInstancesMadePersistentViaReachability.java tck/src/java/org/apache/jdo/tck/api/persistencemanager/extent/GetExtentWithInstancesMadePersistentVi100664 10131 12500110374 34406 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.extent;
import java.util.Iterator;
import java.util.Date;
import javax.jdo.Extent;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.api.persistencemanager.PersistenceManagerTest;
import org.apache.jdo.tck.pc.company.Company;
import org.apache.jdo.tck.pc.company.Department;
import org.apache.jdo.tck.pc.company.Address;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: GetExtentWithInstancesMadePersistentViaReachability
*Keywords: inheritance extent
*Assertion ID: A12.5.4-1.
*Assertion Description:
If an instance of a class or interface that has a managed extent is made persistent via reachability, the instance is put into the extent implicitly.
*/
public class GetExtentWithInstancesMadePersistentViaReachability extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.5.4-3 (GetExtentWithInstancesMadePersistentViaReachability) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(GetExtentWithInstancesMadePersistentViaReachability.class);
}
/** */
public void test() {
pm = getPM();
createObjects(pm);
runTest(pm);
}
/** */
private void createObjects(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
tx.begin();
Company comp = new Company(1L, "Sun Microsystems", new Date(), new Address(0,"","","","",""));
pm.makePersistent(comp);
//Add transient departments
comp.addDepartment(new Department(1L, "Department 1"));
comp.addDepartment(new Department(2L, "Department 2"));
comp.addDepartment(new Department(3L, "Department 3"));
tx.commit(); //Now the transient departments should be made persistent via reachability
}
/** */
private void runTest(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
tx.begin();
Extent e = pm.getExtent(Department.class, false);
boolean foundDep1 = false;
boolean foundDep2 = false;
boolean foundDep3 = false;
for (Iterator i = e.iterator(); i.hasNext();) {
Department dep = (Department) i.next();
if (dep.getName().equals("Department 1"))
foundDep1=true;
else if (dep.getName().equals("Department 2"))
foundDep2=true;
else if (dep.getName().equals("Department 3"))
foundDep3=true;
}
if (!foundDep1) {
fail(ASSERTION_FAILED,
"Extent of class " + Department.class.getName() + " does not include instance with deptid 1L");
}
if (!foundDep2) {
fail(ASSERTION_FAILED,
"Extent of class " + Department.class.getName() + " does not include instance with deptid 2L");
}
if (!foundDep3) {
fail(ASSERTION_FAILED,
"Extent of class " + Department.class.getName() + " does not include instance with deptid 3L");
}
tx.commit();
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanager/extent/GetExtentWithNoSubclasses.java 100664 7062 12500110374 32625 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.extent;
import java.util.Iterator;
import javax.jdo.Extent;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
import org.apache.jdo.tck.api.persistencemanager.PersistenceManagerTest;
/**
*Title: GetExtentWithNoSubclasses
*Keywords: inheritance extent
*Assertion ID: A12.5.4-2.
*Assertion Description:
The getExtent method returns an Extent that contains all of the instances in the parameter class. With the subclasses parameter false, only instances of the specified class are returned.
*/
public class GetExtentWithNoSubclasses extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.5.4-2 (GetExtentWithNoSubclasses) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(GetExtentWithNoSubclasses.class);
}
private PCPoint p1 = null;
private PCPoint p2 = null;
/** */
public void testGetExtentWithNoSubclasses() {
pm = getPM();
createObjects(pm);
runTestGetExtent(pm);
pm.close();
pm = null;
}
/** */
private void createObjects(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
PCPoint p1 = new PCPoint (1,3);
PCPoint p2 = new PCPoint (3,5);
pm.makePersistent(p1);
pm.makePersistent(p2);
tx.commit();
}
finally {
if (tx.isActive())
tx.rollback();
}
}
/** */
private void runTestGetExtent(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
Extent e = pm.getExtent(PCPoint.class, false);
int c = 0;
for (Iterator i = e.iterator(); i.hasNext();) {
PCPoint p = (PCPoint) i.next();
if (debug) logger.debug("p.getX() = " + p.getX());
if ((p.getX() == 1) || (p.getX() == 3)) {
// OK
}
else {
fail(ASSERTION_FAILED,
"Extent of class " + PCPoint.class.getName() +
" includes unexpected instance, p.getX():" + p.getX());
}
}
tx.commit();
}
finally {
if (tx.isActive())
tx.rollback();
}
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanager/extent/GetExtentWithSubclasses.java 100664 12262 12500110374 32346 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.extent;
import java.util.Date;
import java.util.Iterator;
import javax.jdo.Extent;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.api.persistencemanager.PersistenceManagerTest;
import org.apache.jdo.tck.pc.company.Employee;
import org.apache.jdo.tck.pc.company.FullTimeEmployee;
import org.apache.jdo.tck.pc.company.PartTimeEmployee;
import org.apache.jdo.tck.pc.company.Person;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: GetExtentWithSubclasses
*Keywords: inheritance extent
*Assertion ID: A12.5.4-3.
*Assertion Description:
The getExtent method returns an Extent that contains all of the instances in the parameter class or interface, and if the subclasses flag is true, all of the instances of the parameter class and its subclasses.
*/
public class GetExtentWithSubclasses extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.5.4-3 (GetExtentWithSubclasses) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(GetExtentWithSubclasses.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
addTearDownClass(FullTimeEmployee.class);
addTearDownClass(PartTimeEmployee.class);
addTearDownClass(Person.class);
super.localSetUp();
}
/** */
public void test() {
pm = getPM();
createObjects(pm);
runTest(pm);
}
/** */
private void createObjects(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
tx.begin();
Date date = new Date();
Person p1 = new Person(1L, "Craig", "Russell", null, date, null);
Employee p2 = new FullTimeEmployee(2L, "Michael", "Bouschen", null, date, null, date, 0.0);
Employee p3 = new PartTimeEmployee(3L, "Michelle", "Caisse", null, date, null, date, 0.0);
Employee p4 = new FullTimeEmployee(4L, "Victor", "Kirkebo", null, date, null, date, 0.0);
pm.makePersistent(p1);
pm.makePersistent(p2);
pm.makePersistent(p3);
pm.makePersistent(p4);
tx.commit();
}
/** */
private void runTest(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
tx.begin();
Extent e = pm.getExtent(Person.class, true);
boolean foundCraig = false;
boolean foundMichael = false;
boolean foundMichelle = false;
boolean foundVictor = false;
for (Iterator i = e.iterator(); i.hasNext();) {
Person p = (Person) i.next();
if ((p.getFirstname().equals("Craig")) && (p.getLastname().equals("Russell")))
foundCraig=true;
else if ((p.getFirstname().equals("Michael")) && (p.getLastname().equals("Bouschen")))
foundMichael=true;
else if ((p.getFirstname().equals("Michelle")) && (p.getLastname().equals("Caisse")))
foundMichelle=true;
else if ((p.getFirstname().equals("Victor")) && (p.getLastname().equals("Kirkebo")))
foundVictor=true;
}
if (!foundCraig) {
fail(ASSERTION_FAILED,
"Extent of class " + Person.class.getName() +
" does not include instance of class " + Person.class.getName() + " with personid 1L");
}
if (!foundMichael) {
fail(ASSERTION_FAILED,
"Extent of class " + Person.class.getName() +
" does not include instance of class " + Employee.class.getName() + " with personid 2L");
}
if (!foundMichelle) {
fail(ASSERTION_FAILED,
"Extent of class " + Person.class.getName() +
" does not include instance of class " + PartTimeEmployee.class.getName() + " with personid 3L");
}
if (!foundVictor) {
fail(ASSERTION_FAILED,
"Extent of class " + Person.class.getName() +
" does not include instance of class " + FullTimeEmployee.class.getName() + " with personid 4L");
}
tx.commit();
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanager/fetchplan/AbstractFetchPlanTest.java 100664 11566 12500110374 32406 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.fetchplan;
import java.util.Collection;
import java.util.HashSet;
import javax.jdo.FetchPlan;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.pc.mylib.PCRect;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
* This class is an abstract superclass for the fetch plan tests.
* It contains methods useful for testing the behavior of the
* fetch plan.
*/
public class AbstractFetchPlanTest extends JDO_Test {
/**
* The main method is not defined in this abstract class.
*/
/** The persistent instances used in the test.
*/
protected PCPoint upperLeft;
protected PCPoint lowerRight;
protected PCRect pcrect;
/** The oids of the persistent instances used in the test.
*/
protected Object upperLeftoid;
protected Object lowerRightoid;
protected Object pcrectoid;
/** The String arrays used for setting fetch groups.
*/
protected String[] defaultGroup = new String[]
{"default"};
protected String[] upperLeftGroup = new String[]
{"default", "PCRect.upperLeft"};
protected String[] lowerRightGroup = new String[]
{"default", "PCRect.lowerRight"};
protected String[] bothGroup = new String[]{
"default", "PCRect.upperLeft", "PCRect.lowerRight"};
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
addTearDownClass(PCRect.class);
addTearDownClass(PCPoint.class);
upperLeft = new PCPoint(0,10);
lowerRight = new PCPoint(10,0);
pcrect = new PCRect(upperLeft, lowerRight);
getPM().currentTransaction().begin();
pm.makePersistent(pcrect); // makes all three persistent
upperLeftoid = pm.getObjectId(upperLeft);
lowerRightoid = pm.getObjectId(lowerRight);
pcrectoid = pm.getObjectId(pcrect);
pm.currentTransaction().commit();
}
/** Set the default plus upper left field as the fetch group.
*/
protected void setDefaultGroup() {
FetchPlan fp = getPM().getFetchPlan();
fp.setGroups(defaultGroup);
}
/** Set the default plus upper left field as the fetch group.
*/
protected void setUpperLeftGroup() {
FetchPlan fp = getPM().getFetchPlan();
fp.setGroups(upperLeftGroup);
}
/** Set the default plus lower right field as the fetch group.
*/
protected void setLowerRightGroup() {
FetchPlan fp = getPM().getFetchPlan();
fp.setGroups(upperLeftGroup);
}
/** Set the default plus both fields as the fetch group.
*/
protected void setBothGroup() {
FetchPlan fp = getPM().getFetchPlan();
fp.setGroups(bothGroup);
}
/** */
protected void checkBothLoaded(String location, PCRect pcrect) {
checkUpperLeftLoaded(location, pcrect);
checkLowerRightLoaded(location, pcrect);
}
/** */
protected void checkUpperLeftLoaded(String location, PCRect pcrect) {
if (pcrect.upperLeft == null) {
appendMessage(location + NL + "Upper Left was null." + NL +
"The fetch plan includes PCRect.upperLeft and this field" +
" should have been loaded.");
}
}
/** */
protected void checkLowerRightLoaded(String location, PCRect pcrect) {
if (pcrect.lowerRight == null) {
appendMessage(location + NL + "Lower Right was null." + NL +
"The fetch plan includes PCRect.lowerRight and this field" +
" should have been loaded.");
}
}
protected void checkGroups(String location,
FetchPlan fetchPlan, String[] groups) {
Collection expected = new HashSet();
Collection actual = fetchPlan.getGroups();
for (int i = 0; i < groups.length; ++i) {
expected.add(groups[i]);
}
if (!expected.equals(actual)) {
appendMessage(location + NL + "Fetch groups differ." + NL +
"expected: " + expected + NL +
"actual: " + actual + NL);
}
}
} tck/src/java/org/apache/jdo/tck/api/persistencemanager/fetchplan/FetchPlanInterface.java 100664 30767 12500110374 31707 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.fetchplan;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashSet;
import java.util.Set;
import javax.jdo.FetchPlan;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.pc.mylib.PCRect;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Test TITLE
*Keywords: fetch plan
*Assertion IDs: 12.7.1-1
*Assertion Description:
public interface FetchPlan {
String DEFAULT = "default";
String ALL = "all";
int FETCH_SIZE_GREEDY = -1;
int FETCH_SIZE_OPTIMAL = 0;
int DETACH_LOAD_FIELDS = 1;
int DETACH_UNLOAD_FIELDS = 2;
A12.7.1-1 [/** Add the fetchgroup to the set of active fetch groups. Duplicate names will be removed.
FetchPlan addGroup(String fetchGroupName);
/** Remove the fetch group from the set active fetch groups.
FetchPlan removeGroup(String fetchGroupName);
/** Remove all active groups, including the default fetch group.
FetchPlan clearGroups();
/** Return an immutable Set of the names of all active fetch groups.
Set getGroups();
/** Set a Collection of group names to replace the current groups. Duplicate names will be removed.
FetchPlan setGroups(Collection fetchGroupNames);
/** Set an array of group names to replace the current groups. Duplicate names will be removed.
FetchPlan setGroups(String[] fetchGroupNames);
/** Set a single group to replace the current groups.
FetchPlan setGroup(String fetchGroupName);]
/** Set the roots for DetachAllOnCommit
FetchPlan setDetachmentRoots(Collection roots);
/** Get the roots for DetachAllOnCommit
Collection getDetachmentRoots();
/** Set the roots for DetachAllOnCommit
FetchPlan setDetachmentRootClasses(Class[] rootClasses);
/** Get the roots for DetachAllOnCommit
Class[] getDetachmentRootClasses();
/** Set the maximum fetch depth.
FetchPlan setMaxFetchDepth(int fetchDepth);
/** Get the maximum fetch depth.
int getMaxFetchDepth();
A12.7.1-2 [/** Set the fetch size for large result set support.
FetchPlan setFetchSize(int fetchSize);
/** Return the fetch size; 0 if not set; -1 for greedy fetching.
int getFetchSize();]
A12.7.1-3 [/** Set detachment options
FetchPlan setDetachmentOptions(int options);
/** Return the detachment options
int getDetachmentOptions();]
*/
public class FetchPlanInterface extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion 12.7.1-1 (FetchPlanTest) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(FetchPlanInterface.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
addTearDownClass(PCRect.class);
addTearDownClass(PCPoint.class);
}
/** */
protected boolean setEquals
(Collection expected, Collection actual) {
if (expected == actual)
return true;
if (expected == null || actual == null)
return false;
Set expectedSet = new HashSet(expected);
Set actualSet = new HashSet(actual);
return expectedSet.equals(actualSet);
}
/** */
protected void failCompare(String message,
Object expected, Object actual) {
appendMessage(ASSERTION_FAILED + message);
appendMessage("expected: " + expected);
appendMessage("actual: " + actual);
}
/** */
protected void failCompare(String message,
int expected, int actual) {
appendMessage(ASSERTION_FAILED + message);
appendMessage("expected: " + expected);
appendMessage("actual: " + actual);
}
/** */
public void testGroups() {
checkDefaultGroups();
checkClearGroups();
checkSetGroup();
checkAddGroup();
checkRemoveGroup();
checkClearGroups();
checkSetGroupsCollection();
checkSetGroupsArray();
failOnError();
}
/** */
public void testDetachmentRoots() {
checkGetDetachmentRoots();
checkSetDetachmentRoots();
checkSetDetachmentRootClasses();
failOnError();
}
/** */
public void testDetachmentOptions() {
int expectedOptions =
FetchPlan.DETACH_LOAD_FIELDS +
FetchPlan.DETACH_UNLOAD_FIELDS;
FetchPlan fp = getPM().getFetchPlan();
int initialOptions = fp.getDetachmentOptions();
if (FetchPlan.DETACH_LOAD_FIELDS != initialOptions) {
failCompare(
"testDetachmentOptions(): wrong getDetachmentOptions() " +
"after getPersistenceManager().",
FetchPlan.DETACH_LOAD_FIELDS, initialOptions);
}
fp.setDetachmentOptions(expectedOptions);
int actualOptions = fp.getDetachmentOptions();
if (expectedOptions != actualOptions) {
failCompare(
"testDetachmentOptions(): wrong getDetachmentOptions() " +
"after setDetachmentOptions().",
expectedOptions, actualOptions);
}
cleanupPM();
failOnError();
}
/** */
public void testMaxFetchDepth() {
int expectedMaxFetchDepth = 12;
FetchPlan fp = getPM().getFetchPlan();
fp.setMaxFetchDepth(expectedMaxFetchDepth);
int actualMaxFetchDepth = fp.getMaxFetchDepth();
if (expectedMaxFetchDepth != actualMaxFetchDepth) {
failCompare(
"testMaxFetchDepth(): wrong getMaxFetchDepth() " +
"after setMaxFetchDepth().",
expectedMaxFetchDepth, actualMaxFetchDepth);
}
cleanupPM();
failOnError();
}
/** */
public void testFetchSize() {
int expectedFetchSize = 12;
FetchPlan fp = getPM().getFetchPlan();
fp.setFetchSize(expectedFetchSize);
int actualFetchSize = fp.getFetchSize();
if (expectedFetchSize != actualFetchSize) {
failCompare(
"testFetchSize(): wrong getFetchSize() " +
"after setFetchSize().",
expectedFetchSize, actualFetchSize);
}
cleanupPM();
failOnError();
}
/** */
public void checkDefaultGroups() {
Set expectedGroups = new HashSet();
expectedGroups.add("default");
FetchPlan fp = getPM().getFetchPlan();
Collection groups = fp.getGroups();
if (!setEquals(expectedGroups, groups)) {
failCompare(
"checkDefaultGroups(): wrong getGroups() " +
"after getPersistenceManager().",
expectedGroups, groups);
}
cleanupPM();
}
/** */
public void checkClearGroups() {
Set expectedGroups = new HashSet();
FetchPlan fp = getPM().getFetchPlan();
fp.clearGroups();
Collection groups = fp.getGroups();
if (!setEquals(expectedGroups, groups)) {
failCompare(
"checkClearGroups(): wrong getGroups() " +
"after clearGroups.",
expectedGroups, groups);
}
cleanupPM();
}
/** */
public void checkSetGroup() {
Set expectedGroups = new HashSet();
expectedGroups.add("group1");
FetchPlan fp = getPM().getFetchPlan();
fp.setGroup("group1");
Collection groups = fp.getGroups();
if (!setEquals(expectedGroups, groups)) {
failCompare(
"checkSetGroup(): wrong getGroups() " +
"after setGroup.",
expectedGroups, groups);
}
cleanupPM();
}
/** */
public void checkAddGroup() {
Set expectedGroups = new HashSet();
expectedGroups.add("default");
expectedGroups.add("group1");
FetchPlan fp = getPM().getFetchPlan();
fp.addGroup("group1");
Collection groups = fp.getGroups();
if (!setEquals(expectedGroups, groups)) {
failCompare(
"checkAddGroup(): wrong getGroups() " +
"after addGroup.",
expectedGroups, groups);
}
cleanupPM();
}
/** */
public void checkRemoveGroup() {
Set expectedGroups = new HashSet();
FetchPlan fp = getPM().getFetchPlan();
fp.removeGroup("default");
Collection groups = fp.getGroups();
if (!setEquals(expectedGroups, groups)) {
failCompare(
"checkRemoveGroup(): wrong getGroups() " +
"after removeGroup.",
expectedGroups, groups);
}
cleanupPM();
}
/** */
public void checkSetGroupsCollection() {
Set expectedGroups = new HashSet();
expectedGroups.add("default");
expectedGroups.add("group1");
expectedGroups.add("group2");
FetchPlan fp = getPM().getFetchPlan();
fp.setGroups(expectedGroups);
Collection groups = fp.getGroups();
if (!setEquals(expectedGroups, groups)) {
failCompare(
"checkSetGroupsCollection(): wrong getGroups() " +
"after SetGroups(Collection).",
expectedGroups, groups);
}
cleanupPM();
}
/** */
public void checkSetGroupsArray() {
Set expectedGroups = new HashSet();
expectedGroups.add("default");
expectedGroups.add("group1");
expectedGroups.add("group2");
FetchPlan fp = getPM().getFetchPlan();
fp.setGroups(new String[] {"default", "group1", "group2"});
Collection groups = fp.getGroups();
if (!setEquals(expectedGroups, groups)) {
failCompare(
"checkSetGroupsArray(): wrong getGroups() " +
"after setGroups(String[]).",
expectedGroups, groups);
}
cleanupPM();
}
/** */
protected void checkGetDetachmentRoots() {
Set expectedRoots = new HashSet();
FetchPlan fp = getPM().getFetchPlan();
Collection roots = fp.getDetachmentRoots();
if (!setEquals(expectedRoots, roots)) {
failCompare(
"checkGetDetachmentRoots(): wrong getDetachmentRoots() " +
"after getPersistenceManager().",
expectedRoots, roots);
}
cleanupPM();
}
/** */
protected void checkSetDetachmentRoots() {
PCPoint p = new PCPoint(10, 20);
Set expectedRoots = new HashSet();
expectedRoots.add(p);
FetchPlan fp = getPM().getFetchPlan();
fp.setDetachmentRoots(expectedRoots);
Collection roots = fp.getDetachmentRoots();
if (!setEquals(expectedRoots, roots)) {
failCompare(
"checkGetDetachmentRoots(): wrong getDetachmentRoots() " +
"after setDetachmentRoots().",
expectedRoots, roots);
}
cleanupPM();
}
/** */
private void checkSetDetachmentRootClasses() {
Class[] expectedRootClasses = new Class[] {PCPoint.class};
FetchPlan fp = getPM().getFetchPlan();
fp.setDetachmentRootClasses(
expectedRootClasses);
Class[] rootClasses = fp.getDetachmentRootClasses();
if (!Arrays.equals(expectedRootClasses, rootClasses)) {
failCompare(
"checkGetDetachmentRootClasses(): " +
"wrong getDetachmentRootClasses() " +
"after setDetachmentRootClasses().",
expectedRootClasses, rootClasses);
}
cleanupPM();
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanager/fetchplan/FetchPlanIsCopy.java 100664 11247 12500110374 31205 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.fetchplan;
import java.util.Arrays;
import javax.jdo.Extent;
import javax.jdo.FetchPlan;
import javax.jdo.Query;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.pc.mylib.PCRect;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Test TITLE
*Keywords: fetch plan
*Assertion IDs: 12.7.5-1
*Assertion Description: Subsequent modifications of the Query FetchPlan are not reflected in the FetchPlan of the PersistenceManager.
*/
public class FetchPlanIsCopy extends AbstractFetchPlanTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion 12.7.5-1 (FetchPlanIsCopy) failed: ";
Query query = null;
Extent extent = null;
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(FetchPlanIsCopy.class);
}
/**
* @see JDO_Test#localSetUp()
protected void localSetUp() {
addTearDownClass(PCRect.class);
addTearDownClass(PCPoint.class);
}
*/
/** */
public void testRemoveGroup() {
beginFPTest();
query.getFetchPlan().removeGroup("PCRect.upperLeft");
// check that query fetch plan is changed
checkGroups(ASSERTION_FAILED + " testRemoveGroup()",
query.getFetchPlan(), defaultGroup);
closeFPTest("testRemoveGroup()");
}
/** */
public void testAddGroup() {
beginFPTest();
query.getFetchPlan().addGroup("PCRect.lowerRight");
// check that query fetch plan is changed
checkGroups(ASSERTION_FAILED + " testAddGroup()",
query.getFetchPlan(), bothGroup);
closeFPTest("testAddGroup()");
}
/** */
public void testClearGroups() {
beginFPTest();
query.getFetchPlan().clearGroups();
// check that query fetch plan is changed
checkGroups(ASSERTION_FAILED + " testClearGroups()",
query.getFetchPlan(), new String[]{});
closeFPTest("testClearGroup()");
}
/** */
public void testSetGroup() {
beginFPTest();
query.getFetchPlan().setGroup("default");
// check that query fetch plan is changed
checkGroups(ASSERTION_FAILED + " testSetGroup()",
query.getFetchPlan(), defaultGroup);
closeFPTest("testSetGroup()");
}
/** */
public void testSetGroupsCollection() {
beginFPTest();
query.getFetchPlan().setGroups(Arrays.asList(bothGroup));
// check that query fetch plan is changed
checkGroups(ASSERTION_FAILED + " testSetGroupsCollection()",
query.getFetchPlan(), bothGroup);
closeFPTest("testSetGroupsCollection()");
}
/** */
public void testSetGroupsArray() {
beginFPTest();
query.getFetchPlan().setGroups(bothGroup);
// check that query fetch plan is changed
checkGroups(ASSERTION_FAILED + " testSetGroupsArray()",
query.getFetchPlan(), bothGroup);
closeFPTest("testSetGroupsArray()");
}
/** */
public void beginFPTest() {
setUpperLeftGroup();
pm.currentTransaction().begin();
query = pm.newQuery(PCRect.class);
extent = pm.getExtent(PCRect.class);
}
/** */
public void closeFPTest(String location) {
// check that pm fetch plan is unchanged
checkGroups(ASSERTION_FAILED + " " + location,
pm.getFetchPlan(), upperLeftGroup);
// check that extent fetch plan is unchanged
checkGroups(ASSERTION_FAILED + " " + location,
extent.getFetchPlan(), upperLeftGroup);
pm.currentTransaction().rollback();
failOnError();
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanager/fetchplan/FetchPlanMakeTransient.java 100664 6555 12500110374 32532 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.fetchplan;
import java.util.Collection;
import java.util.HashSet;
import org.apache.jdo.tck.api.persistencemanager.fetchplan.AbstractFetchPlanTest;
import org.apache.jdo.tck.pc.mylib.PCRect;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Test FetchPlanMakeTransient
*Keywords: FetchPlan makeTransient
*Assertion IDs: Assertion 12.7.1
*Assertion Description:
If the useFetchPlan parameter is true, the current FetchPlan,
including MaxFetchDepth, DETACH_LOAD_FIELDS, and DETACH_UNLOAD_FIELDS,
is applied to the pc or pcs parameter instance(s) to load fields
and instances from the datastore. The DetachmentRoots is not affected.
After the fetch plan is used to load instances, the entire graph
of instances reachable via loaded fields of the parameter instances
is made transient. Transient fields are not modified by the method.
*/
public class FetchPlanMakeTransient extends AbstractFetchPlanTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion 12.7.1 (FetchPlanMakeTransient) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(FetchPlanMakeTransient.class);
}
/** */
public void testMakeTransientAllCollection() {
setBothGroup();
pm.currentTransaction().begin();
PCRect instance = (PCRect)pm.getObjectById(pcrectoid, false);
Collection instances = new HashSet();
instances.add(instance);
pm.makeTransientAll(instances, true);
checkBothLoaded(ASSERTION_FAILED, instance);
pm.currentTransaction().commit();
failOnError();
}
/** */
public void testMakeTransientAllArray() {
setBothGroup();
pm.currentTransaction().begin();
PCRect instance = (PCRect)pm.getObjectById(pcrectoid, false);
pm.makeTransientAll(new Object[]{instance}, true);
checkBothLoaded(ASSERTION_FAILED, instance);
pm.currentTransaction().commit();
failOnError();
}
/** */
public void testMakeTransient() {
setBothGroup();
pm.currentTransaction().begin();
PCRect instance = (PCRect)pm.getObjectById(pcrectoid, false);
pm.makeTransient(instance, true);
checkBothLoaded(ASSERTION_FAILED, instance);
pm.currentTransaction().commit();
failOnError();
}
} tck/src/java/org/apache/jdo/tck/api/persistencemanager/fetchplan/FetchPlanQuery.java 100664 4537 12500110374 31070 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.fetchplan;
import javax.jdo.FetchPlan;
import javax.jdo.Query;
import org.apache.jdo.tck.api.persistencemanager.fetchplan.AbstractFetchPlanTest;
import org.apache.jdo.tck.pc.mylib.PCRect;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Test FetchPlanQuery
*Keywords: FetchPlan Query
*Assertion IDs: Assertion 12.7.1
*Assertion Description:
12.7.1 When executing a query the JDO implementation loads the fields
as specified in the fetch plan associated with the Query instance.
*/
public class FetchPlanQuery extends AbstractFetchPlanTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion 12.7.1 (FetchPlanQuery) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(FetchPlanQuery.class);
}
/** */
public void testQuery() {
setBothGroup();
pm.currentTransaction().begin();
Query query = pm.newQuery(PCRect.class);
checkGroups(ASSERTION_FAILED + " after newQuery().getFetchPlan()",
query.getFetchPlan(), bothGroup);
query.setUnique(true);
PCRect instance = (PCRect)query.execute();
checkBothLoaded(ASSERTION_FAILED + " after query.execute()", instance);
pm.currentTransaction().commit();
failOnError();
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanager/fetchplan/FetchPlanRefresh.java 100664 6021 12500110374 31347 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.fetchplan;
import java.util.Collection;
import java.util.HashSet;
import org.apache.jdo.tck.api.persistencemanager.fetchplan.AbstractFetchPlanTest;
import org.apache.jdo.tck.pc.mylib.PCRect;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Test FetchPlanRefresh
*Keywords: FetchPlan getObjectById
*Assertion IDs: Assertion 12.7.1
*Assertion Description:
12.7.1 For refresh, after clearing fields in the instances,
the JDO implementation uses the fetch plan to determine
which fields to load from the datastore.
*/
public class FetchPlanRefresh extends AbstractFetchPlanTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion 12.7.1 (FetchPlanRefresh) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(FetchPlanRefresh.class);
}
/** */
public void testRefresh() {
setBothGroup();
pm.currentTransaction().begin();
PCRect instance = (PCRect)pm.getObjectById(pcrectoid, false);
pm.refresh(instance);
checkBothLoaded(ASSERTION_FAILED, instance);
pm.currentTransaction().commit();
failOnError();
}
/** */
public void testRefreshAllCollection() {
setBothGroup();
pm.currentTransaction().begin();
PCRect instance = (PCRect)pm.getObjectById(pcrectoid, false);
Collection instances = new HashSet();
instances.add(instance);
pm.refreshAll(instances);
checkBothLoaded(ASSERTION_FAILED, instance);
pm.currentTransaction().commit();
failOnError();
}
/** */
public void testRefreshAllArray() {
setBothGroup();
pm.currentTransaction().begin();
PCRect instance = (PCRect)pm.getObjectById(pcrectoid, false);
Object[] instances = new Object[]{instance};
pm.refreshAll(instances);
checkBothLoaded(ASSERTION_FAILED, instance);
pm.currentTransaction().commit();
failOnError();
}
} tck/src/java/org/apache/jdo/tck/api/persistencemanager/fetchplan/FetchPlanRetrieve.java 100664 6246 12500110374 31547 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.fetchplan;
import java.util.Collection;
import java.util.HashSet;
import org.apache.jdo.tck.api.persistencemanager.fetchplan.AbstractFetchPlanTest;
import org.apache.jdo.tck.pc.mylib.PCRect;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Test FetchPlanRetrieve
*Keywords: FetchPlan getObjectById
*Assertion IDs: Assertion 12.7.1
*Assertion Description:
12.7.1 For retrieve with FGonly true, the implementation uses the fetch plan to
determine which fields are loaded from the datastore. With FGonly false, the
implementation reverts to JDO 1 behavior, which loads all fields from the
datastore; in this case, no related instances are loaded.
*/
public class FetchPlanRetrieve extends AbstractFetchPlanTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion 12.7.1 (FetchPlanRetrieve) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(FetchPlanRetrieve.class);
}
/** */
public void testRetrieve() {
setBothGroup();
pm.currentTransaction().begin();
PCRect instance = (PCRect)pm.getObjectById(pcrectoid, false);
pm.retrieve(instance, true);
checkBothLoaded(ASSERTION_FAILED, instance);
pm.currentTransaction().commit();
failOnError();
}
/** */
public void testRetrieveAllCollection() {
setBothGroup();
pm.currentTransaction().begin();
PCRect instance = (PCRect)pm.getObjectById(pcrectoid, false);
Collection instances = new HashSet();
instances.add(instance);
pm.retrieveAll(instances, true);
checkBothLoaded(ASSERTION_FAILED, instance);
pm.currentTransaction().commit();
failOnError();
}
/** */
public void testRetrieveAllArray() {
setBothGroup();
pm.currentTransaction().begin();
PCRect instance = (PCRect)pm.getObjectById(pcrectoid, false);
Object[] instances = new Object[]{instance};
pm.retrieveAll(instances, true);
checkBothLoaded(ASSERTION_FAILED, instance);
pm.currentTransaction().commit();
failOnError();
}
} tck/src/java/org/apache/jdo/tck/api/persistencemanager/flags/GetIgnoreCache.java 100664 4606 12500110374 30132 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.flags;
import javax.jdo.Transaction;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
import org.apache.jdo.tck.api.persistencemanager.PersistenceManagerTest;
/**
*Title: Get IgnoreCache Value from PersistenceManager
*Keywords:
*Assertion ID: A12.5.3-1.
*Assertion Description:
The PersistenceManager.getIgnoreCache method returns the current value of the
IgnoreCache option.
*/
public class GetIgnoreCache extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.5.3-1 (GetIgnoreCache) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(GetIgnoreCache.class);
}
/** */
public void testGetIgnoreCache() {
pm = getPM();
Transaction tx = pm.currentTransaction();
try {
PCPoint p1 = new PCPoint();
tx.begin();
pm.setIgnoreCache(true);
boolean returnValue = pm.getIgnoreCache();
if (!returnValue)
fail(ASSERTION_FAILED,
"pm.getIgnoreCache() returns false after setting the falg to true");
tx.commit();
}
finally {
if (tx.isActive())
tx.rollback();
}
pm.close();
pm = null;
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanager/flags/SetIgnoreCacheToFalse.java 100664 5232 12500110374 31420 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.flags;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
import org.apache.jdo.tck.api.persistencemanager.PersistenceManagerTest;
/**
*Title: Set IgnoreCache To False
*Keywords:cache
*Assertion ID: A12.5.3-3.
*Assertion Description:
The PersistenceManager.setIgnoreCache method called with a value of false instructs the
query engine that the user expects queries to return results that reflect changed values in the cache.
*/
public class SetIgnoreCacheToFalse extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.5.3-3 (SetIgnoreCacheToFalse) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(SetIgnoreCacheToFalse.class);
}
/** */
public void test() {
pm = getPM();
runTestSetIgnoreCacheToFalse(pm);
pm.close();
pm = null;
}
/** */
private void runTestSetIgnoreCacheToFalse(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
PCPoint p1 = new PCPoint();
tx.begin();
pm.setIgnoreCache(false);
if (pm.getIgnoreCache()) {
fail(ASSERTION_FAILED,
"pm.getIgnoreCache() should return false after setting the flag to false.");
}
tx.commit();
tx = null;
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanager/flags/SetIgnoreCacheToTrue.java 100664 5355 12500110374 31313 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.flags;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
import org.apache.jdo.tck.api.persistencemanager.PersistenceManagerTest;
/**
*Title: Set IgnoreCache To True
*Keywords:cache
*Assertion ID: A12.5.3-2.
*Assertion Description:
The PersistenceManager.setIgnoreCache method called with a value of true is a hint to the
query engine that the user expects queries to be optimized to return approximate results by ignoring changed values in the
cache. This is not testable, except to see whether the get/set works.
*/
public class SetIgnoreCacheToTrue extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.5.3-2 (SetIgnoreCacheToTrue) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(SetIgnoreCacheToTrue.class);
}
/** */
public void test() {
pm = getPM();
runTestSetIgnoreCacheToTrue(pm);
pm.close();
pm = null;
}
/** */
public void runTestSetIgnoreCacheToTrue(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
PCPoint p1 = new PCPoint();
tx.begin();
pm.setIgnoreCache(true);
if (!pm.getIgnoreCache()) {
fail(ASSERTION_FAILED,
"pm.getIgnoreCache() should return true after setting the flag to true.");
}
tx.commit();
tx = null;
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanager/flags/SetMultithreadedFalse.java 100664 5170 12500110374 31542 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.flags;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
import org.apache.jdo.tck.api.persistencemanager.PersistenceManagerTest;
/**
*Title: Set Multithreaded False
*Keywords: multithreaded
*Assertion ID: A12.7-2.
*Assertion Description:
If PersistenceManager.setMultithreaded is called with a value of false, a value of false
will be returned when getMultithreaded is called.
*/
public class SetMultithreadedFalse extends PersistenceManagerTest{
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.7-2 (SetMultithreadedFalse) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(SetMultithreadedFalse.class);
}
/** */
public void test() {
pm = getPM();
runTestSetMultithreadedFalse(pm);
pm.close();
pm = null;
}
/** */
private void runTestSetMultithreadedFalse(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
PCPoint p1 = new PCPoint();
tx.begin();
pm.setMultithreaded(false);
if (pm.getMultithreaded()) {
fail(ASSERTION_FAILED,
"pm.getMultithreaded() should false true after setting the flag to false.");
}
tx.commit();
tx = null;
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanager/flags/SetMultithreadedTrue.java 100664 5332 12500110374 31427 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.flags;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.util.BatchTestRunner;
import org.apache.jdo.tck.api.persistencemanager.PersistenceManagerTest;
/**
*Title: Set Multithreaded True
*Keywords: multithreaded
*Assertion ID: A12.7-1.
*Assertion Description:
If PersistenceManager.setMultithreaded is called with a value of true, then the JDO
implementation must perform synchronizations to support multiple application threads. A value of true will be returned
when getMultithreaded is called. In testing, multi-threading should be turned on and then multi-threading tests should
be run.
*/
public class SetMultithreadedTrue extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.7-1 (SetMultithreadedTrue) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(SetMultithreadedTrue.class);
}
/** */
public void test() {
pm = getPM();
runTestSetMultithreadedTrue(pm);
pm.close();
pm = null;
}
/** */
public void runTestSetMultithreadedTrue(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
pm.setMultithreaded(true);
if (!pm.getMultithreaded()) {
fail(ASSERTION_FAILED,
"pm.getMultithreaded() should true true after setting the flag to true.");
}
tx.commit();
tx = null;
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
}
././@LongLink 100644 0 0 146 12500111677 10254 L ustar 0 0 tck/src/java/org/apache/jdo/tck/api/persistencemanager/flags/SettingFlagsWithTransactionInstance.java tck/src/java/org/apache/jdo/tck/api/persistencemanager/flags/SettingFlagsWithTransactionInstance.jav100664 4622 12500110374 34301 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.flags;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.util.BatchTestRunner;
import org.apache.jdo.tck.api.persistencemanager.PersistenceManagerTest;
/**
*Title: Setting Flags With Transaction instance
*Keywords:
*Assertion ID: A12.5.2-3.
*Assertion Description:
Even if the Transaction instance returned by PersistenceManager.currentTransaction
cannot be used for transaction completion (due to external transaction management), it still can be used to set flags.
*/
public class SettingFlagsWithTransactionInstance extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.5.2-3 (SettingFlagsWithTransactionInstance) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(SettingFlagsWithTransactionInstance.class);
}
/** */
public void test() {
pm = getPM();
runTestSettingFlagsWithTransactionInstance(pm);
pm.close();
pm = null;
}
/** */
private void runTestSettingFlagsWithTransactionInstance(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
tx.setNontransactionalRead(false);
tx.setNontransactionalWrite(false);
tx.setRetainValues(false);
tx.setOptimistic(false);
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanager/getobject/GetObjectById.java 100664 12414 12500110374 30627 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.getobject;
import javax.jdo.Transaction;
import org.apache.jdo.tck.util.BatchTestRunner;
import org.apache.jdo.tck.api.persistencemanager.PersistenceManagerTest;
/**
*Title: Get Object By Id
*Keywords: identity cache
*Assertion ID: A12.5.6-9.
*Assertion Description:
If PersistenceManager.getObjectById is called with a value of
true for the second parameter named validate,
and there is not an instance already in the cache with the same JDO identity
as the oid parameter, then this method creates an instance with the specified
JDO identity, verifies that it exists in the data store, and returns it.
If there is no transaction in progress, the returned instance will be
hollow or persistent-nontransactional, at the choice of the implementation.
If there is a data store transaction in progress,
the returned instance will be persistent-clean.
If there is an optimistic transaction in progress,
the returned instance will be persistent-nontransactional.
*/
public class GetObjectById extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.5.6-9 (GetObjectById) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(GetObjectById.class);
}
/** */
public void testGetObjectById() {
if (debug) logger.debug ("\nSTART GetObjectById");
Transaction tx = null;
try {
pm = getPM();
Object oid = createPCPointInstance(pm);
if (pm != null) {
pm.close();
pm = null; // make sure to get a different pm so obj is not in cache
}
Object obj = null;
int state = 0;
// nontransactional access
if (isNontransactionalReadSupported()) {
if (debug) logger.debug("nontransactional");
pm = getPM();
tx = pm.currentTransaction();
tx.setNontransactionalRead(true);
obj = pm.getObjectById(oid, true);
state = currentState (obj);
if (state != PERSISTENT_NONTRANSACTIONAL && state != HOLLOW) {
fail(ASSERTION_FAILED,
"Expected persistent-nontransactional or hollow; got " +
getStateOfInstance(obj));
}
tx = null;
pm.close();
pm = null; // make sure to get a different pm so obj is not in cache
}
// pessimistic transactional access
if (debug) logger.debug("pessimistic");
pm = getPM();
tx = pm.currentTransaction();
tx.setOptimistic(false);
tx.begin();
obj = pm.getObjectById(oid, true);
state = currentState (obj);
tx.commit();
tx = null;
if (state != PERSISTENT_CLEAN) {
fail(ASSERTION_FAILED,
"Expected persistent-clean; got " + getStateOfInstance(obj));
}
pm.close();
pm = null; // make sure to get a different pm so obj is not in cache
// optimistic transactional access
if (isOptimisticSupported()) {
if (debug) logger.debug("optimistic");
pm = getPM();
tx = pm.currentTransaction();
tx.setOptimistic(true);
tx.begin();
obj = pm.getObjectById(oid, true);
state = currentState (obj);
tx.commit();
if (state != PERSISTENT_NONTRANSACTIONAL & state != HOLLOW) {
fail(ASSERTION_FAILED,
"Expected persistent-nontransactional; got " + getStateOfInstance(obj));
}
tx = null;
pm.close();
pm = null; // make sure to get a different pm so obj is not in cache
}
}
finally {
if (debug) logger.debug ("END GetObjectById");
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanager/getobject/GetObjectByIdExactClass.java 100664 23620 12500110374 32603 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.getobject;
import java.util.Date;
import javax.jdo.Transaction;
import javax.jdo.JDOException;
import javax.jdo.identity.LongIdentity;
import org.apache.jdo.tck.util.BatchTestRunner;
import org.apache.jdo.tck.api.persistencemanager.PersistenceManagerTest;
import org.apache.jdo.tck.pc.singlefieldidentity.Person;
import org.apache.jdo.tck.pc.singlefieldidentity.Employee;
import org.apache.jdo.tck.pc.singlefieldidentity.PartTimeEmployee;
import org.apache.jdo.tck.pc.singlefieldidentity.FullTimeEmployee;
/**
*Title: Get Object By Id
*Keywords: identity cache
*Assertion ID: A12.5.6-2.
*Assertion Description:
* If the validate flag is false, the user asserts that the instance exists
* and the object id represents the exact class of the persistent instance
* (specifically not a subclass or an interface).
* If the class is abstract, throw JDOUserException (we cannot construct
* a hollow instance of an abstract class).
* If the class is actually not correct, an exception with an
* error message will be thrown later if any field other than the identity
* field id accessed.
*/
public class GetObjectByIdExactClass extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.5.6-2 (GetObjectById) failed: ";
/** */
private LongIdentity oid;
/** */
private long id;
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(GetObjectByIdExactClass.class);
}
@Override
public void localSetUp() {
if (!runsWithApplicationIdentity()) {
printNonApplicableIdentityType(
"GetObjectIdExactClass",
APPLICATION_IDENTITY);
return;
}
pm = getPM();
pm.currentTransaction().begin();
// create an instance of FullTimeEmployee.
FullTimeEmployee instance = new FullTimeEmployee();
instance.setPersonid(1000000L);
instance.setFirstname("Full");
instance.setLastname("Timer");
instance.setBirthdate(new Date());
pm.makePersistent(instance);
pm.currentTransaction().commit();
oid = (LongIdentity)pm.getObjectId(instance);
id = oid.getKey();
pm.close();
pm = null;
addTearDownClass(FullTimeEmployee.class);
}
/** */
public void testAbstractSuperclassExact() {
if (!runsWithApplicationIdentity()) return;
Transaction tx = null;
try {
pm = getPM();
pm.currentTransaction().begin();
// create the oid
Object abstractOid = new LongIdentity(Employee.class, id);
pm.getObjectById(abstractOid, false);
appendMessage(ASSERTION_FAILED + "getObjectById exact " +
"for abstract superclass must fail.");
} catch (JDOException ex) {
// good catch
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
failOnError();
}
/** */
public void testAbstractSuperclassNotExact() {
if (!runsWithApplicationIdentity()) return;
Transaction tx = null;
try {
pm = getPM();
pm.currentTransaction().begin();
// create the oid
Object abstractOid = new LongIdentity(Employee.class, id);
Object abstractInstance = pm.getObjectById(abstractOid, true);
if (abstractInstance.getClass() != FullTimeEmployee.class) {
appendMessage(ASSERTION_FAILED + "getObjectById not exact "
+ "for abstract superclass returned wrong type "
+ abstractInstance.getClass().getName());
}
} catch (JDOException ex) {
appendMessage(ASSERTION_FAILED + "getObjectById not exact "
+ "for abstract superclass threw exception "
+ ex.getMessage());
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
failOnError();
}
/** */
public void testConcreteSuperclassExact() {
if (!runsWithApplicationIdentity()) return;
Transaction tx = null;
Person instance = null;
try {
pm = getPM();
pm.currentTransaction().begin();
// create the oid
Object superclassOid = new LongIdentity(Person.class, id);
instance = (Person)pm.getObjectById(superclassOid, false);
if (instance.getClass() != Person.class) {
appendMessage(ASSERTION_FAILED + "getObjectById exact for "
+ "concrete superclass should return "
+ "Person.class but returned wrong type "
+ instance.getClass().getName());
}
} catch (Exception ex) {
appendMessage(ASSERTION_FAILED + "getObjectById exact for " +
"concrete superclass must succeed before accessing database.");
}
try {
instance.toString(); // accesses non-key fields
appendMessage(ASSERTION_FAILED + "getObjectById exact for "
+ "concrete superclass must fail when accessing database.");
} catch (JDOException ex) {
// good catch
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
failOnError();
}
/** */
public void testConcreteSuperclassNotExact() {
if (!runsWithApplicationIdentity()) return;
Transaction tx = null;
try {
pm = getPM();
pm.currentTransaction().begin();
// create the oid
Object superclassOid = new LongIdentity(Person.class, id);
Object instance = pm.getObjectById(superclassOid, true);
if (instance.getClass() != FullTimeEmployee.class) {
appendMessage(ASSERTION_FAILED + "getObjectById not exact for "
+ "concrete superclass should return FullTimeEmployee "
+ "but returned wrong type "
+ instance.getClass().getName());
}
} catch (JDOException ex) {
appendMessage(ASSERTION_FAILED + " getObjectById not exact for "
+ "concrete superclass must succeed but threw "
+ ex.getMessage());
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
failOnError();
}
/** */
public void testWrongClass() {
if (!runsWithApplicationIdentity()) return;
Transaction tx = null;
try {
pm = getPM();
pm.currentTransaction().begin();
// create the oid
Object wrongOid = new LongIdentity(PartTimeEmployee.class, id);
PartTimeEmployee wrongInstance =
(PartTimeEmployee)pm.getObjectById(wrongOid, false);
wrongInstance.toString();
appendMessage(ASSERTION_FAILED + " getObjectById exact "
+ "for wrong class must throw JDOUserException.");
} catch (JDOException ex) {
// good catch
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
failOnError();
}
/** */
public void testRightClassNotExact() {
if (!runsWithApplicationIdentity()) return;
Transaction tx = null;
try {
pm = getPM();
pm.currentTransaction().begin();
// create the oid
Object rightOid = new LongIdentity(FullTimeEmployee.class, id);
FullTimeEmployee rightInstance =
(FullTimeEmployee)pm.getObjectById(rightOid, true);
rightInstance.toString();
} catch (JDOException ex) {
appendMessage(ASSERTION_FAILED + " getObjectById not exact "
+ "for right class must succeed.");
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
failOnError();
}
/** */
public void testRightClassExact() {
if (!runsWithApplicationIdentity()) return;
Transaction tx = null;
try {
pm = getPM();
pm.currentTransaction().begin();
// create the oid
Object rightOid = new LongIdentity(FullTimeEmployee.class, id);
FullTimeEmployee rightInstance =
(FullTimeEmployee)pm.getObjectById(rightOid, false);
rightInstance.toString();
} catch (JDOException ex) {
appendMessage(ASSERTION_FAILED + " getObjectById exact "
+ "for right class must succeed.");
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
failOnError();
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanager/getobject/GetObjectByIdNotResolved.java 100664 5752 12500110374 33003 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.getobject;
import javax.jdo.JDOObjectNotFoundException;
import javax.jdo.Transaction;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
import org.apache.jdo.tck.api.persistencemanager.PersistenceManagerTest;
/**
*Title: Get ObjectId For Null Or Not Persistent
*Keywords: identity
*Assertion IDs: A12.5.6-1
*Assertion Description:
In a call to PersistenceManager.getObjectById, if the PersistenceManager is
unable to resolve the oid parameter to an ObjectId instance, then it throws a JDOUserException.
*/
public class GetObjectByIdNotResolved extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.5.6-1 (GetObjectByIdNotResolved) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(GetObjectByIdNotResolved.class);
}
/* passing null paramameter to getObjectId */
public void testGetObjectByIdNotResolved() {
pm = getPM();
if (debug) logger.debug(" *** testObjectByIdNotResolved *** ");
Transaction tx = pm.currentTransaction();
try {
tx.begin();
PCPoint p1 = new PCPoint (1,3);
pm.makePersistent(p1);
Object oid = pm.getObjectId(p1);
pm.deletePersistent(p1);
tx.commit();
tx.begin();
try {
PCPoint p2 = (PCPoint) pm.getObjectById(oid, true);
fail(ASSERTION_FAILED,
"pm.getObjectById(oid, true) should throw JDOObjectNotFoundException, if oid refers to an non existing object");
}
catch (JDOObjectNotFoundException e) {
// expected exception
}
tx.rollback();
tx = null;
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
pm.close();
pm = null;
}
}
././@LongLink 100644 0 0 157 12500111677 10256 L ustar 0 0 tck/src/java/org/apache/jdo/tck/api/persistencemanager/getobject/GetObjectByIdNoValidationInstanceInCache.java tck/src/java/org/apache/jdo/tck/api/persistencemanager/getobject/GetObjectByIdNoValidationInstanceIn100664 5501 12500110374 34152 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.getobject;
import javax.jdo.Transaction;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
import org.apache.jdo.tck.api.persistencemanager.PersistenceManagerTest;
/**
*Title: Get Object By Id No Validation, Instance In Cache
*Keywords: identity cache
*Assertion IDs: A12.5.6-2
*Assertion Description:
If PersistenceManager.getObjectById is called with a value of false
for the second parameter named validate, and there is already an instance in the cache with the
same JDO identity as the oid parameter, then this method returns it.
*/
public class GetObjectByIdNoValidationInstanceInCache extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.5.6-2 (GetObjectByIdNoValidationInstanceInCache) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(GetObjectByIdNoValidationInstanceInCache.class);
}
/** */
public void testGetObjectByIdNoValidationInstanceInCache() {
pm = getPM();
Transaction tx = pm.currentTransaction();
try {
tx.begin();
PCPoint p1 = new PCPoint (1,3);
pm.makePersistent(p1);
int curr = currentState(p1);
Object oid = pm.getObjectId(p1);
tx.commit();
tx.begin();
Object obj = pm.getObjectById(oid, false);
if (p1 != obj)
fail(ASSERTION_FAILED,
"pm.getObjectById(oid, false) should find existing instance in pm cache");
tx.commit();
tx = null;
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
pm.close();
pm = null;
}
}
././@LongLink 100644 0 0 174 12500111677 10255 L ustar 0 0 tck/src/java/org/apache/jdo/tck/api/persistencemanager/getobject/GetObjectByIdNoValidationInstanceInCacheNoStateChange.java tck/src/java/org/apache/jdo/tck/api/persistencemanager/getobject/GetObjectByIdNoValidationInstanceIn100664 6043 12500110374 34154 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.getobject;
import javax.jdo.Transaction;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
import org.apache.jdo.tck.api.persistencemanager.PersistenceManagerTest;
/**
*Title: Get Object By Id No Validation, Instance In Cache, No State Change
*Keywords: identity cache lifecycle
*Assertion IDs: A12.5.6-3
*Assertion Description:
If PersistenceManager.getObjectById is called with a value of false for the second parameter named validate, and there is already an instance in the cache with the same JDO identity as the oid parameter, there is no change made to the state of the returned instance.
*/
public class GetObjectByIdNoValidationInstanceInCacheNoStateChange extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.5.6-3 (GetObjectByIdNoValidationInstanceInCacheNoStateChange) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(GetObjectByIdNoValidationInstanceInCacheNoStateChange.class);
}
/** */
public void testGetObjectByIdNoValidationInstanceInCacheNoStateChange() {
pm = getPM();
Transaction tx = pm.currentTransaction();
try {
tx.begin();
PCPoint p1 = new PCPoint (1,3);
pm.makePersistent(p1);
Object oid = pm.getObjectId(p1);
tx.commit();
int curr = currentState(p1);
tx.begin();
Object obj = pm.getObjectById (oid, false);
int actualState = currentState(obj);
if (actualState != curr) {
fail(ASSERTION_FAILED,
"State mismatched - Expected state: " +
curr + " Actual state: " + actualState);
}
tx.commit();
tx = null;
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
pm.close();
pm = null;
}
}
././@LongLink 100644 0 0 162 12500111677 10252 L ustar 0 0 tck/src/java/org/apache/jdo/tck/api/persistencemanager/getobject/GetObjectByIdNoValidationInstanceNotInCache.java tck/src/java/org/apache/jdo/tck/api/persistencemanager/getobject/GetObjectByIdNoValidationInstanceNo100664 6403 12500110374 34162 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.getobject;
import javax.jdo.Transaction;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
import org.apache.jdo.tck.api.persistencemanager.PersistenceManagerTest;
/**
*Title: Get Object By Id No Validation Instance Not In Cache
*Keywords: identity cache
*Assertion IDs: A12.5.6-5
*Assertion Description:
If PersistenceManager.getObjectById is called with a value of false for the second parameter named validate, and there is not an instance already in the cache with the same JDO identity as the oid parameter, and there is a transaction in progress, then this method creates an instance with the specified JDO identity and returns it with a state of hollow, persistent-nontransactional, or persistent-clean, at the choice of the implementation.
*/
public class GetObjectByIdNoValidationInstanceNotInCache extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.5.6-5 (GetObjectByIdNoValidationInstanceNotInCache) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(GetObjectByIdNoValidationInstanceNotInCache.class);
}
/** */
public void testGetObjectByIdNoValidationInstanceNotInCache() {
pm = getPM();
Transaction tx = pm.currentTransaction();
try {
tx.begin();
PCPoint p1 = new PCPoint (1,3);
pm.makePersistent(p1);
Object oid = pm.getObjectId(p1);
pm.evict(p1);
tx.commit();
tx.begin();
Object obj = pm.getObjectById (oid, false);
int curr = currentState(obj);
if ( curr == HOLLOW ||
curr == PERSISTENT_NONTRANSACTIONAL ||
curr == PERSISTENT_CLEAN ) {
; // expected result
}
else {
fail(ASSERTION_FAILED,
"returned state mismatched - " +
" Actual state " + curr);
}
tx.commit();
tx = null;
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
pm.close();
pm = null;
}
}
././@LongLink 100644 0 0 166 12500111677 10256 L ustar 0 0 tck/src/java/org/apache/jdo/tck/api/persistencemanager/getobject/GetObjectByIdNoValidationInstanceNotInCacheNoTx.java tck/src/java/org/apache/jdo/tck/api/persistencemanager/getobject/GetObjectByIdNoValidationInstanceNo100664 6417 12500110374 34167 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.getobject;
import javax.jdo.Transaction;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
import org.apache.jdo.tck.api.persistencemanager.PersistenceManagerTest;
/**
*Title: Get Object By Id No Validation Instance Not In Cache, No Tx
*Keywords: identity cache
*Assertion IDs: A12.5.6-4
*Assertion Description:
If PersistenceManager.getObjectById is called with a value of false for the
second parameter named validate, and there is not an instance already in the cache with the same JDO identity as the oid parameter, and there is no transaction in progress, then this method creates an instance with the specified JDO identity and returns it with a state of hollow or persistent-nontransactional, at the choice of the implementation.
*/
public class GetObjectByIdNoValidationInstanceNotInCacheNoTx extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.5.6-4 (GetObjectByIdNoValidationInstanceNotInCacheNoTx) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(GetObjectByIdNoValidationInstanceNotInCacheNoTx.class);
}
/** */
public void testGetObjectByIdNoValidationInstanceNotInCacheNoTx() {
pm = getPM();
Transaction tx = pm.currentTransaction();
try {
tx.begin();
PCPoint p1 = new PCPoint (1,3);
pm.makePersistent(p1);
Object oid = pm.getObjectId(p1);
pm.evict(p1);
tx.commit();
/* get oid for p1, no transaction in progress */
Object obj = pm.getObjectById (oid, false);
int curr = currentState(p1);
if (curr == HOLLOW ||
curr == PERSISTENT_NONTRANSACTIONAL ||
curr == PERSISTENT_CLEAN ) {
// expected result
}
else {
fail(ASSERTION_FAILED,
"returned state mismatched - " +
" Actual state " + curr);
}
tx = null;
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
pm.close();
pm = null;
}
}
././@LongLink 100644 0 0 166 12500111677 10256 L ustar 0 0 tck/src/java/org/apache/jdo/tck/api/persistencemanager/getobject/GetObjectByIdNoValidationInstanceNotInDatastore.java tck/src/java/org/apache/jdo/tck/api/persistencemanager/getobject/GetObjectByIdNoValidationInstanceNo100664 6260 12500110374 34163 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.getobject;
import javax.jdo.JDOObjectNotFoundException;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
import org.apache.jdo.tck.api.persistencemanager.PersistenceManagerTest;
/**
*Title: Get Object By Id No Validation Instance Not In Datastore
*Keywords: identity exception
*Assertion ID: A12.5.6-6.
*Assertion Description:
If PersistenceManager.getObjectById is called with a value of
false for the second parameter named validate,
and the instance does not exist in the data store, a subsequent access
of the fields of the instance will throw a JDODatastoreException
if the instance does not exist at that time.
*/
public class GetObjectByIdNoValidationInstanceNotInDatastore extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.5.6-6 (GetIgnoreCGetObjectByIdNoValidationInstanceNotInDatastore) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(GetObjectByIdNoValidationInstanceNotInDatastore.class);
}
/** */
public void testGetObjectByIdNoValidationInstanceNotInDatastore() {
if (debug)
logger.debug ("\nSTART GetObjectByIdNoValidationInstanceNotInDatastore");
Object oid = null;
pm = getPM();
oid = createPCPointInstance(pm);
deletePCPointInstance(pm, oid);
try {
pm.currentTransaction().begin();
PCPoint p1 = (PCPoint)pm.getObjectById(oid, false); // might throw exception here
if (debug)
logger.debug ("Got object in cache, even though not in datastore.");
p1.getX(); // if not thrown above, throws exception here
pm.currentTransaction().commit();
fail(ASSERTION_FAILED,
"accessing unknown instance should throw JDOObjectNotFoundException");
}
catch (JDOObjectNotFoundException ex) {
// expected exception
}
if (debug)
logger.debug ("END GetObjectByIdNoValidationInstanceNotInDatastore");
}
}
././@LongLink 100644 0 0 161 12500111677 10251 L ustar 0 0 tck/src/java/org/apache/jdo/tck/api/persistencemanager/getobject/GetObjectByIdWithValidationInstanceInCache.java tck/src/java/org/apache/jdo/tck/api/persistencemanager/getobject/GetObjectByIdWithValidationInstance100664 6274 12500110374 34232 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.getobject;
import javax.jdo.Transaction;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
import org.apache.jdo.tck.api.persistencemanager.PersistenceManagerTest;
/**
*Title: Get Object By Id With Validation Instance in Cache
*Keywords: identity cache
*Assertion IDs: A12.5.6-7
*Assertion Description:
If PersistenceManager.getObjectById is called with a value of true for the second parameter named validate, and there is already a transactional instance in the cache with the same JDO identity as the oid parameter, then this method returns it. There is no change made to the state of the returned instance.
*/
public class GetObjectByIdWithValidationInstanceInCache extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.5.6-7 (GetObjectByIdWithValidationInstanceInCache) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(GetObjectByIdWithValidationInstanceInCache.class);
}
/** */
public void testGetObjectByIdWithValidationInstanceInCache() {
pm = getPM();
Transaction tx = pm.currentTransaction();
try {
tx.begin();
PCPoint p1 = new PCPoint (1,3);
pm.makePersistent(p1);
Object oid = pm.getObjectId(p1);
tx.commit();
int curr = currentState(p1);
tx.begin();
Object obj = pm.getObjectById(oid, false);
int curr2 = currentState(obj);
if (obj != p1) {
fail(ASSERTION_FAILED,
"pm.getObjectById(oid, false) should find existing instance in pm cache");
}
if (curr2 != curr) {
fail(ASSERTION_FAILED,
"State changed in the returned instance, expected state: " +
curr + " Actual state: " + curr2);
}
tx.commit();
tx = null;
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
pm.close();
pm = null;
}
}
././@LongLink 100644 0 0 177 12500111677 10260 L ustar 0 0 tck/src/java/org/apache/jdo/tck/api/persistencemanager/getobject/GetObjectByIdWithValidationInstanceInCacheNotInDatastore.java tck/src/java/org/apache/jdo/tck/api/persistencemanager/getobject/GetObjectByIdWithValidationInstance100664 6362 12500110374 34230 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.getobject;
import javax.jdo.JDOObjectNotFoundException;
import javax.jdo.Transaction;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
import org.apache.jdo.tck.api.persistencemanager.PersistenceManagerTest;
/**
*Title: Get Object By Id With Validation, Instance in Cache, Not in Datastore
*Keywords: identity cache
*Assertion IDs: A12.5.6-8.
*Assertion Description:
If PersistenceManager.getObjectById is called with a value of true
for the second parameter named validate, and there is an instance already in the cache with the
same JDO identity as the oid parameter, and the instance is not transactional, and the instance
does not exist in the datastore, then a JDODatastoreException is thrown.
*/
public class GetObjectByIdWithValidationInstanceInCacheNotInDatastore extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.5.6-8 (GetObjectByIdWithValidationInstanceInCacheNotInDatastore) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(GetObjectByIdWithValidationInstanceInCacheNotInDatastore.class);
}
/* passing null paramameter to getObjectId */
public void testGetObjectByIdWithValidationInstanceInCacheNotInDatastore() {
pm = getPM();
Transaction tx = pm.currentTransaction();
try {
tx.begin();
PCPoint p1 = new PCPoint (1,3);
pm.makePersistent(p1);
Object oid = pm.getObjectId(p1);
pm.deletePersistent(p1);
tx.commit();
tx.begin();
try {
PCPoint p2 = (PCPoint) pm.getObjectById(oid, true);
fail(ASSERTION_FAILED,
"pm.getObjectById(oid, true) should throw JDOObjectNotFoundException, if oid refers to an non existing object");
}
catch (JDOObjectNotFoundException ex) {
// expected exception
}
tx.rollback();
tx = null;
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
pm.close();
pm = null;
}
}
././@LongLink 100644 0 0 202 12500111677 10245 L ustar 0 0 tck/src/java/org/apache/jdo/tck/api/persistencemanager/getobject/GetObjectByIdWithValidationInstanceNotInCacheNotInDatastore.java tck/src/java/org/apache/jdo/tck/api/persistencemanager/getobject/GetObjectByIdWithValidationInstance100664 5533 12500110374 34227 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.getobject;
import javax.jdo.JDOObjectNotFoundException;
import javax.jdo.Transaction;
import org.apache.jdo.tck.api.persistencemanager.PersistenceManagerTest;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Get Object By Id With Validation, Instance Not in Cache, Not in Datastore
*Keywords: exception
*Assertion IDs: A12.6.5-2.
*Assertion Description:
Object getObjectById (Object oid, boolean validate) with validate==true. If the instance does not exist in the datastore, then a JDOObjectNotFoundException is thrown.
*/
public class GetObjectByIdWithValidationInstanceNotInCacheNotInDatastore extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.6.5-2 (GetObjectByIdWithValidationInstanceNotInCacheNotInDatastore) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(GetObjectByIdWithValidationInstanceNotInCacheNotInDatastore.class);
}
/** */
public void test() {
pm = getPM();
Transaction tx = pm.currentTransaction();
tx.setRestoreValues(false); //This should cause eviction of transactional instances when transaction is later rolled back.
tx.begin();
PCPoint p1 = new PCPoint (1,3);
pm.makePersistent(p1);
Object oid = pm.getObjectId(p1);
tx.rollback();
tx.begin();
try {
PCPoint p2 = (PCPoint) pm.getObjectById(oid, true);
fail(ASSERTION_FAILED, "pm.getObjectById(oid, true) should throw JDOObjectNotFoundException, if oid refers to an non existing object");
}
catch (JDOObjectNotFoundException ex) {
// expected exception
}
finally {
tx.rollback();
}
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanager/getobject/GetObjectId.java 100664 5274 12500110374 30322 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.getobject;
import javax.jdo.Transaction;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
import org.apache.jdo.tck.api.persistencemanager.PersistenceManagerTest;
/**
*Title: Get Objectid
*Keywords: identity
*Assertion ID: A12.5.6-10
*Assertion Description:
The PersistenceManager.getObjectId method returns an ObjectId instance that re presents the object identity of the specified JDO Instance. Test: The method g etObjectById returns the exact same object, evaluating to true when == is used .
*/
public class GetObjectId extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.5.6-10 (GetObjectId) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(GetObjectId.class);
}
/** */
public void testGetObjectId() {
pm = getPM();
Transaction tx = pm.currentTransaction();
try {
PCPoint p1 = new PCPoint(8,8);
tx = pm.currentTransaction();
tx.begin();
pm.makePersistent(p1);
Object oid = pm.getObjectId(p1);
tx.commit();
tx.begin();
Object obj = pm.getObjectById(oid, false);
if (obj != p1) {
fail(ASSERTION_FAILED,
"m.getObjectById(oid, false) should find existing instance in pm cache.");
}
tx.rollback();
tx = null;
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
pm.close();
pm = null;
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanager/getobject/GetObjectIdClass.java 100664 7077 12500110374 31313 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.getobject;
import javax.jdo.PersistenceManager;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
import org.apache.jdo.tck.api.persistencemanager.PersistenceManagerTest;
/**
*Title: Get ObjectId Class
*Keywords: identity
*Assertion IDs: A12.10-1
*Assertion Description:
The method PersistenceManager.getObjectIdClass returns the class of the
object id for the given class.
If the parameter class is not persistence-capable, or the parameter is null,
null is returned. If the object-id class defined in the metadata for the
parameter class is abstract then null is returned.
If the implementation does not support application identity, and the class
is defined in the jdo metadata to use application identity,
then null is returned.
*/
public class GetObjectIdClass extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.10-1 (GetObjectIdClass) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(GetObjectIdClass.class);
}
/** */
public void test() {
pm = getPM();
runTestGetObjectIdClassForNull(pm);
runTestGetObjectIdClassForNonPCClass(pm);
runTestGetObjectIdClassForAbstractClass(pm);
runTestGetObjectIdClass(pm);
pm.close();
pm = null;
}
/** */
private void runTestGetObjectIdClass(PersistenceManager pm) {
if (pm.getObjectIdClass(PCPoint.class) == null) {
fail(ASSERTION_FAILED,
"pm.getObjectIdClass(PCPoint.class) returned null");
}
}
/** */
private void runTestGetObjectIdClassForNull(PersistenceManager pm) {
Class cl = pm.getObjectIdClass(null);
if (cl != null) {
fail(ASSERTION_FAILED,
"pm.getObjectIdClass for null returned non-null class: " +
cl.getName());
}
}
/** */
private void runTestGetObjectIdClassForNonPCClass(PersistenceManager pm) {
Class cl = pm.getObjectIdClass(java.lang.Throwable.class);
if (cl != null) {
fail(ASSERTION_FAILED,
"pm.getObjectIdClass for non-PC class returned non-null class: " +
cl.getName());
}
}
private void runTestGetObjectIdClassForAbstractClass(PersistenceManager pm) {
// not implemented; the tck contains no classes with which to test this.
// we need an abstract class whose object-id class is itself abstract.
}
}
././@LongLink 100644 0 0 176 12500111677 10257 L ustar 0 0 tck/src/java/org/apache/jdo/tck/api/persistencemanager/getobject/GetObjectIdClassForAbstractOrNonPersistenceCapableClass.java tck/src/java/org/apache/jdo/tck/api/persistencemanager/getobject/GetObjectIdClassForAbstractOrNonPer100664 5420 12500110374 34137 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.getobject;
import javax.jdo.PersistenceManager;
import org.apache.jdo.tck.pc.mylib.Point;
import org.apache.jdo.tck.util.BatchTestRunner;
import org.apache.jdo.tck.api.persistencemanager.PersistenceManagerTest;
/**
*Title: Get ObjectId Class For Abstract or Non-PersistenceCapable Class
*Keywords: identity
*Assertion IDs: A12.10-2
*Assertion Description:
A call to PersistenceManager.getObjectIdClass returns null if the class is abstract or not persistence-capable, or the parameter is null.
*/
public class GetObjectIdClassForAbstractOrNonPersistenceCapableClass extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.10-2 (GetObjectIdClassForAbstractOrNonPersistenceCapableClass) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(GetObjectIdClassForAbstractOrNonPersistenceCapableClass.class);
}
/** */
public void testGetObjectIdClassForAbstractOrNonPersistenceCapableClass() {
pm = getPM();
runTestNonPcClass(pm);
runTestNullParam(pm);
pm.close();
pm = null;
}
/** */
private void runTestNonPcClass(PersistenceManager pm) {
Class c1 = pm.getObjectIdClass(Point.class);
if ( c1 != null) {
fail(ASSERTION_FAILED,
"pm.getObjectIdClass returns non-null ObjectId class for non pc class");
}
}
/** */
private void runTestNullParam(PersistenceManager pm) {
Class c1 = pm.getObjectIdClass(null);
if (c1 != null) {
fail(ASSERTION_FAILED,
"pm.getObjectIdClass for null returned non-null class: " +
c1.getName());
}
}
}
././@LongLink 100644 0 0 150 12500111677 10247 L ustar 0 0 tck/src/java/org/apache/jdo/tck/api/persistencemanager/getobject/GetObjectIdForNullOrNotPersistent.java tck/src/java/org/apache/jdo/tck/api/persistencemanager/getobject/GetObjectIdForNullOrNotPersistent.j100664 5246 12500110374 34176 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.getobject;
import javax.jdo.PersistenceManager;
import org.apache.jdo.tck.pc.mylib.Point;
import org.apache.jdo.tck.util.BatchTestRunner;
import org.apache.jdo.tck.api.persistencemanager.PersistenceManagerTest;
/**
*Title: GetObjectIdForNullOrNotPersistent
*Keywords: identity
*Assertion IDs: A12.5.6-14.
*Assertion Description:
If a call is made to PersistenceManager.getObjectId and the
parameter pc is not persistent, or is null, then null is returned.
*/
public class GetObjectIdForNullOrNotPersistent extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.5.6-14 (GetObjectIdForNullOrNotPersistent) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(GetObjectIdForNullOrNotPersistent.class);
}
/** */
public void testGetObjectIdForNullOrNotPersistent() {
pm = getPM();
runTestNonPcClass(pm);
runTestNullParam(pm);
pm.close();
pm = null;
}
/** */
private void runTestNonPcClass(PersistenceManager pm) {
Point p = new Point(1,3);
Object oid = pm.getObjectId(p);
if (oid != null) {
fail(ASSERTION_FAILED,
"pm.getObjectId returned non null ObjectId: " + oid +
" for instance of non-pc class");
}
}
/** */
private void runTestNullParam(PersistenceManager pm) {
Object oid = pm.getObjectId(null);
if (oid != null) {
fail(ASSERTION_FAILED,
"pm.getObjectId(null) returned non null ObjectId: " + oid);
}
}
}
././@LongLink 100644 0 0 150 12500111677 10247 L ustar 0 0 tck/src/java/org/apache/jdo/tck/api/persistencemanager/getobject/GetObjectIdForPersistentInterface.java tck/src/java/org/apache/jdo/tck/api/persistencemanager/getobject/GetObjectIdForPersistentInterface.j100664 6426 12500110374 34203 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.getobject;
import java.util.Date;
import javax.jdo.Transaction;
import javax.jdo.identity.LongIdentity;
import org.apache.jdo.tck.api.persistencemanager.PersistenceManagerTest;
import org.apache.jdo.tck.pc.company.Company;
import org.apache.jdo.tck.pc.company.ICompany;
import org.apache.jdo.tck.pc.company.PICompany;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Get ObjectidForPersistentInterface
*Keywords: identity
*Assertion ID: A12.6.6-1
*Assertion Description:
* For interfaces and classes that use a SingleFieldIdentity as
* the object-id class, if the returned instance is subsequently
* made persistent, the target class stored in the object-id
* instance is the parameter of the newInstance method that created it.
*/
public class GetObjectIdForPersistentInterface extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.6.6-1 (GetObjectId) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(GetObjectIdForPersistentInterface.class);
}
public void localSetUp() {
addTearDownClass(PICompany.class);
}
/** */
public void testGetObjectId() {
if (!runsWithApplicationIdentity()) {
printNonApplicableIdentityType(
"GetObjectIdForPersistentInterface",
APPLICATION_IDENTITY);
return;
}
pm = getPM();
Transaction tx = pm.currentTransaction();
ICompany icompany = (ICompany)pm.newInstance(PICompany.class);
icompany.setCompanyid(1001);
icompany.setName("GooTube");
icompany.setFounded(new Date());
tx.begin();
pm.makePersistent(icompany);
LongIdentity ioid = (LongIdentity)pm.getObjectId(icompany);
tx.commit();
Class pICompanyOidTargetClass = ioid.getTargetClass();
if (pICompanyOidTargetClass != PICompany.class)
appendMessage(ASSERTION_FAILED +
" getObjectId(icompany) should return interface class.\n" +
"expected: " + icompany.getClass().getName() + "\n" +
"actual: " + pICompanyOidTargetClass.getName());
failOnError();
}
}
././@LongLink 100644 0 0 162 12500111677 10252 L ustar 0 0 tck/src/java/org/apache/jdo/tck/api/persistencemanager/getobject/GetObjectIdWithApplicationModifyingIdentity.java tck/src/java/org/apache/jdo/tck/api/persistencemanager/getobject/GetObjectIdWithApplicationModifying100664 7155 12500110374 34270 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.getobject;
import javax.jdo.Transaction;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
import org.apache.jdo.tck.api.persistencemanager.PersistenceManagerTest;
/**
*Title: Get ObjectId With Application Modifying Identity
*Keywords: identity applicationidentity
*Assertion ID: A12.5.6-11.
*Assertion Description:
If the object identity is being changed in the transaction,
by the application modifying one or more of the application key fields,
then the method PersistenceManager.getObjectId returns the
identity as of the beginning of the transaction. The value returned by
getObjectId will be different following afterCompletion
processing for successful transactions.
*/
public class GetObjectIdWithApplicationModifyingIdentity extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.5.6-11 (GetObjectIdWithApplicationModifyingIdentity) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(GetObjectIdWithApplicationModifyingIdentity.class);
}
/** */
public void testGetObjectByIdWithApplicationModifyingIdentity() {
if (!isChangeApplicationIdentitySupported()) {
if (debug)
logger.debug("Implementation does not support chaning application identity");
return;
}
if (debug)
logger.debug("\nSTART GetObjectIdWithApplicationModifyingIdentity");
pm = getPM();
Object oid = createPCPointInstance(pm);
PCPoint p1 = (PCPoint) pm.getObjectById(oid, false);
Transaction tx = pm.currentTransaction();
try {
tx.begin();
p1.setX(10000); // this is the primary key
Object oid2 = pm.getObjectId (p1); // should be the same
tx.commit();
Object oid3 = pm.getObjectId (p1); // should be same as oid3
if (!oid.equals(oid2)) {
fail(ASSERTION_FAILED,
"Oid before is different from oid after modifying pk");
}
if (oid.equals(oid3)) {
fail(ASSERTION_FAILED,
"Oid before is the same as oid after modifying pk");
}
}
finally {
if (debug)
logger.debug("END GetObjectIdWithApplicationModifyingIdentity");
if ((tx != null) && tx.isActive())
tx.rollback();
}
pm.close();
pm = null;
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanager/getobject/GetObjectsById.java 100664 17137 12500110374 31021 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.getobject;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Test GetObjectsById
*Keywords: getObjectsById getObjectById
*Assertion IDs: 12.5.6-17
*Assertion Description:
* 12.5.6-17 [Collection getObjectsById (Collection oids);
* Object[] getObjectsById (Object[] oids);
* Collection getObjectsById (Collection oids, boolean validate);
* Object[] getObjectsById (Object[] oids, boolean validate);
* The getObjectsById method attempts to find instances in the cache
* with the specified JDO identities. The elements of the oids parameter
* object might have been returned by earlier calls to getObjectId
* or getTransactionalObjectId, or might have been constructed by
* the application. If a method with no validate parameter is used,
* the method behaves exactly as the correspond ing method with
* the validate flag set to true. If the Object[] form of the method
* is used, the returned objects correspond by position with
* the object ids in the oids parameter. If the Collection form
* of the method is used, the iterator over the returned Collection
* returns instances in the same order as the oids returned by
* an iterator over the parameter Collection. The cardinality of
* the return value is the same as the cardinality of
* the oids parameter. ]
*/
public class GetObjectsById extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion 12.5.6-17 (GetObjectsById) failed: ";
/** Number of persistent instances */
private static final int NUMBER_OF_INSTANCES = 50;
/** Persistent instances */
private final Collection instanceCollection =
new ArrayList(NUMBER_OF_INSTANCES);
/** Object ids */
private final Collection oidCollection =
new ArrayList(NUMBER_OF_INSTANCES);
/** Persistent instances */
private final Object[] instanceArray =
new Object[NUMBER_OF_INSTANCES];
/** Object ids */
private final Object[] oidArray =
new Object[NUMBER_OF_INSTANCES];
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(GetObjectsById.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
addTearDownClass(PCPoint.class);
getPM().currentTransaction().begin();
Object instance;
Object oid;
instanceCollection.clear();
oidCollection.clear();
for (int i = 0; i < NUMBER_OF_INSTANCES; ++i) {
instance = new PCPoint(i, 1000 + i);
pm.makePersistent(instance);
instanceCollection.add(instance);
instanceArray[i] = instance;
oid = pm.getObjectId(instance);
oidCollection.add(oid);
oidArray[i] = oid;
}
pm.currentTransaction().commit();
}
/** */
public void testCollection() {
getPM().currentTransaction().begin();
Collection result = pm.getObjectsById(oidCollection);
pm.currentTransaction().commit();
checkResultCollection("after getObjectsById(Collection)",
result);
failOnError();
}
/** */
public void testCollectionTrue() {
getPM().currentTransaction().begin();
Collection result = pm.getObjectsById(oidCollection, true);
pm.currentTransaction().commit();
checkResultCollection(
"after getObjectsById(Collection, true)",
result);
failOnError();
}
/** */
public void testCollectionFalse() {
getPM().currentTransaction().begin();
Collection result = pm.getObjectsById(oidCollection, false);
pm.currentTransaction().commit();
checkResultCollection(
"after getObjectsById(Collection, false)",
result);
failOnError();
}
/** */
public void testArray() {
getPM().currentTransaction().begin();
Object[] result = pm.getObjectsById(oidArray);
pm.currentTransaction().commit();
checkResultArray("after getObjectsById(Object[], false)", result);
failOnError();
}
/** */
public void testArrayTrue() {
getPM().currentTransaction().begin();
Object[] result = pm.getObjectsById(oidArray, true);
pm.currentTransaction().commit();
checkResultArray("after getObjectsById(Object[], false)", result);
failOnError();
}
/** */
public void testArrayFalse() {
getPM().currentTransaction().begin();
Object[] result = pm.getObjectsById(oidArray, false);
pm.currentTransaction().commit();
checkResultArray("after getObjectsById(Object[], false)", result);
failOnError();
}
/** Check the results of getObjectsById */
private void checkResultCollection(String location, Collection instances) {
Iterator expected = instanceCollection.iterator();
Iterator actual = instances.iterator();
for (int i = 0; i < NUMBER_OF_INSTANCES; ++i) {
checkIdentity(ASSERTION_FAILED + location + ", position " + i,
expected.next(), actual.next());
}
checkIteratorComplete(ASSERTION_FAILED,
actual);
}
/** Check the results of getObjectsById */
private void checkResultArray(String location, Object[] actual) {
int length = actual.length;
if (length != NUMBER_OF_INSTANCES) {
appendMessage(location + "incorrect length of result. " +
"expected: " + NUMBER_OF_INSTANCES +
" actual: " + length);
}
Object[] expected = instanceArray;
for (int i = 0; i < NUMBER_OF_INSTANCES; ++i) {
checkIdentity(ASSERTION_FAILED + location + ", position " + i,
expected[i], actual[i]);
}
}
/** Check the identity of the instances */
private void checkIdentity(String location,
Object expected, Object actual) {
if (expected != actual) {
appendMessage(location + "failed to compare \n" +
"expected: " + expected + " actual: " + actual);
}
}
/** Check that the iterator has no more elements */
private void checkIteratorComplete (String location, Iterator iterator) {
if (iterator.hasNext()) {
appendMessage(location +
"result iterator has more elements than expected.");
}
}
} tck/src/java/org/apache/jdo/tck/api/persistencemanager/GetPersistenceManagerFactory.java 100664 4355 12500110374 31777 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager;
import javax.jdo.PersistenceManager;
import javax.jdo.PersistenceManagerFactory;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Get PersistenceManagerFactory
*Keywords:
*Assertion ID: A12.9-1.
*Assertion Description:
The PersistenceManagerFactory that created a
PersistenceManager is returned by the method getPersistenceManagerFactory.
*/
public class GetPersistenceManagerFactory extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.9-1 (GetPersistenceManagerFactory) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(GetPersistenceManagerFactory.class);
}
/** */
public void testGetPersistenceManagerFactory() {
PersistenceManagerFactory pmf = getPMF();
// Note, getPM uses the pmf returned by getPMF
PersistenceManager pm = getPM();
PersistenceManagerFactory pmf2 = pm.getPersistenceManagerFactory();
pm.close();
if (pmf2 != pmf) {
fail(ASSERTION_FAILED,
"pm.getPMF() returned different pmf, expected " +
pmf + ", got " + pmf2);
}
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanager/GetProperties.java 100664 41366 12500110374 27047 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import javax.jdo.PersistenceManager;
import javax.jdo.Constants;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Test GetProperties
*Keywords: getProperties getSupportedProperties setProperty
*Assertion IDs:
*Assertion Description:
*/
public class GetProperties extends JDO_Test implements Constants {
/** */
private static final String ASSERTION_FAILED_12_19_1 =
"Assertion 12.19-1 setProperty() " +
"If a vendor-specific property is not recognized, it is silently ignored.\n";
private static final String ASSERTION_FAILED_12_19_2 =
"Assertion 12.19-2 setProperty() If the value for the property is not supported by the implementation, " +
"a JDOUserException is thrown.\n";
private static final String ASSERTION_FAILED_12_19_3 =
"Assertion 12.19-3 setProperty() " +
"Property names might exactly match the names of the properties in javax.jdo.Constants " +
"or might differ in case only.\n";
private static final String ASSERTION_FAILED_12_19_4 =
"Assertion 12.19-4 setProperty() " +
"Properties of the transaction associated with a persistence manager " +
"can be accessed via the named property in javax.jdo.Constants.\n";
private static final String ASSERTION_FAILED_12_19_5 =
"Assertion 12.19-5 getProperties() " +
"getProperties() Return a map of String, " +
"Object with the properties and values currently in effect.\n";
private static final String ASSERTION_FAILED_12_19_6 =
"Assertion 12.19-6 Changing the values in the map will not affect the properties in the PersistenceManager. ";
private static final String ASSERTION_FAILED_12_19_7 =
"Assertion 12.19-7 getSupportedProperties() Return the set of properties " +
"supported by this PersistenceManager.\n";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(GetProperties.class);
}
public void localSetUp() {
getPM();
}
public void localTearDown() {
// the PM is left in an unknown state due to setting properties so it must be cleaned up
cleanupPM();
}
private Collection supportedOptions;
private Set supportedProperties;
private static Set testRequiredProperties = new HashSet();
private static Map> testOptionalProperties = new HashMap>();
private interface TestProperty {
void test(PersistenceManager pm, Set supportedProperties);
Object get(PersistenceManager pm);
void set(PersistenceManager pm, Object value);
void setMessageForNullResult(String messageForNullResult);
void setMessageForWrongResultAfterSet(String messageForWrongResultAfterSet);
}
abstract class AbstractTestProperty implements TestProperty {
String propertyName;
Object testValue1;
Object testValue2;
protected String messageForNullResult = ASSERTION_FAILED_12_19_5;
protected String messageForWrongResultAfterSet = ASSERTION_FAILED_12_19_5;
AbstractTestProperty(String propertyName, Object testValue1, Object testValue2) {
this.propertyName = propertyName;
this.testValue1 = testValue1;
this.testValue2 = testValue2;
}
public void setMessageForNullResult(String messageForNullResult) {
this.messageForNullResult = messageForNullResult;
}
public void setMessageForWrongResultAfterSet(String messageForWrongResultAfterSet) {
this.messageForWrongResultAfterSet = messageForWrongResultAfterSet;
}
}
/** For each non-api supported property,
* getProperty(XXX) should return a value
* setProperty(XXX, value1) should succeed
* getProperties() should return value1
* setProperty(XXX, value2) should succeed
* getProperties() should return value2
*/
abstract class AbstractNonAPITestProperty extends AbstractTestProperty {
AbstractNonAPITestProperty(String propertyName, Object testValue1, Object testValue2) {
super(propertyName, testValue1, testValue2);
}
public Object get(PersistenceManager pm) {throw new RuntimeException("not implemented");};
public void set(PersistenceManager pm, Object value) {throw new RuntimeException("not implemented");};
public void test(PersistenceManager pm, Set supportedProperties) {
Object result0 = pm.getProperties().get(propertyName);
errorIfEqual(this.messageForNullResult + "getProperties().get(" + propertyName + ")", null, result0);
pm.setProperty(propertyName, testValue1);
Object result1 = pm.getProperties().get(propertyName);
errorIfNotEqual(this.messageForWrongResultAfterSet + "after pm.setProperty(" + propertyName + ", " + testValue1 + "), getProperties().get(" + propertyName + ")",
testValue1, result1);
pm.setProperty(propertyName, testValue2);
Object result2 = pm.getProperties().get(propertyName);
errorIfNotEqual(this.messageForWrongResultAfterSet + "after pm.setProperty(" + propertyName + ", " + testValue2 + "), getProperties().get(" + propertyName + ")",
testValue2, result2);
}
}
/** For each api supported property, and for each of two values
* getProperty(XXX) should return a value
* setProperty(XXX, value1) should succeed
* getXXX() should return value1
* setXXX(value2) should succeed
* getProperties() should return value2
*/
abstract class AbstractAPITestProperty extends AbstractTestProperty {
AbstractAPITestProperty(String propertyName, Object testValue1, Object testValue2) {
super(propertyName, testValue1, testValue2);
}
public void test(PersistenceManager pm, Set supportedProperties) {
Object result0 = pm.getProperties().get(propertyName);
errorIfEqual(this.messageForNullResult + "getProperties().get(" + propertyName + ")", null, result0);
pm.setProperty(propertyName, testValue1);
Object result1 = get(pm);
errorIfNotEqual(this.messageForWrongResultAfterSet + "after pm.setProperty(" + propertyName + ", " + testValue1 + "), getXXX for " + propertyName,
testValue1, result1);
set(pm, testValue2);
Object result2 = pm.getProperties().get(propertyName);
errorIfNotEqual(this.messageForWrongResultAfterSet + "after pm.setXXX(), getProperties.get(" + propertyName + ")",
testValue2, result2);
}
};
private TestProperty testCopyOnAttach =
new AbstractAPITestProperty(PROPERTY_COPY_ON_ATTACH, true, false) {
public Object get(PersistenceManager pm) {return pm.getCopyOnAttach();}
public void set(PersistenceManager pm, Object value) {pm.setCopyOnAttach((Boolean) value);}
};
private TestProperty testDatastoreReadTimeoutMillis =
new AbstractAPITestProperty(PROPERTY_DATASTORE_READ_TIMEOUT_MILLIS, 20, 40) {
public Object get(PersistenceManager pm) {return pm.getDatastoreReadTimeoutMillis();}
public void set(PersistenceManager pm, Object value) {pm.setDatastoreReadTimeoutMillis((Integer) value);}
};
private TestProperty testDatastoreWriteTimeoutMillis =
new AbstractAPITestProperty(PROPERTY_DATASTORE_WRITE_TIMEOUT_MILLIS, 60, 80) {
public Object get(PersistenceManager pm) {return pm.getDatastoreWriteTimeoutMillis();}
public void set(PersistenceManager pm, Object value) {pm.setDatastoreWriteTimeoutMillis((Integer) value);}
};
private TestProperty testMultithreaded =
new AbstractAPITestProperty(PROPERTY_MULTITHREADED, true, false) {
public Object get(PersistenceManager pm) {return pm.getMultithreaded();}
public void set(PersistenceManager pm, Object value) {pm.setMultithreaded((Boolean) value);}
};
private TestProperty testLowerCaseMultithreaded =
new AbstractAPITestProperty(PROPERTY_MULTITHREADED, true, false) {
public Object get(PersistenceManager pm) {return pm.getMultithreaded();}
public void set(PersistenceManager pm, Object value) {pm.setProperty("javax.jdo.option.multithreaded", (Boolean) value);}
};
private TestProperty testUpperCaseMultithreaded =
new AbstractAPITestProperty(PROPERTY_MULTITHREADED, true, false) {
public Object get(PersistenceManager pm) {return pm.getMultithreaded();}
public void set(PersistenceManager pm, Object value) {pm.setProperty("javax.jdo.option.MULTITHREADED", (Boolean) value);}
};
private TestProperty testDetachAllOnCommit =
new AbstractAPITestProperty(PROPERTY_DETACH_ALL_ON_COMMIT, true, false) {
public Object get(PersistenceManager pm) {return pm.getDetachAllOnCommit();}
public void set(PersistenceManager pm, Object value) {pm.setDetachAllOnCommit((Boolean) value);}
};
private TestProperty testIgnoreCache =
new AbstractAPITestProperty(PROPERTY_IGNORE_CACHE, true, false) {
public Object get(PersistenceManager pm) {return pm.getIgnoreCache();}
public void set(PersistenceManager pm, Object value) {pm.setIgnoreCache((Boolean) value);}
};
private TestProperty testOptimistic =
new AbstractAPITestProperty(PROPERTY_OPTIMISTIC, true, false) {
public Object get(PersistenceManager pm) {return pm.currentTransaction().getOptimistic();}
public void set(PersistenceManager pm, Object value) {pm.currentTransaction().setOptimistic((Boolean) value);}
};
private TestProperty testRetainValues =
new AbstractAPITestProperty(PROPERTY_RETAIN_VALUES, true, false) {
public Object get(PersistenceManager pm) {return pm.currentTransaction().getRetainValues();}
public void set(PersistenceManager pm, Object value) {pm.currentTransaction().setRetainValues((Boolean) value);}
};
private TestProperty testRestoreValues =
new AbstractAPITestProperty(PROPERTY_RESTORE_VALUES, true, false) {
public Object get(PersistenceManager pm) {return pm.currentTransaction().getRestoreValues();}
public void set(PersistenceManager pm, Object value) {pm.currentTransaction().setRestoreValues((Boolean) value);}
};
private TestProperty testNontransactionalRead =
new AbstractAPITestProperty(PROPERTY_NONTRANSACTIONAL_READ, true, false) {
public Object get(PersistenceManager pm) {return pm.currentTransaction().getNontransactionalRead();}
public void set(PersistenceManager pm, Object value) {pm.currentTransaction().setNontransactionalRead((Boolean) value);}
};
private TestProperty testNontransactionalWrite =
new AbstractAPITestProperty(PROPERTY_NONTRANSACTIONAL_WRITE, true, false) {
public Object get(PersistenceManager pm) {return pm.currentTransaction().getNontransactionalWrite();}
public void set(PersistenceManager pm, Object value) {pm.currentTransaction().setNontransactionalWrite((Boolean) value);}
};
private TestProperty testIllegalArgument =
new AbstractNonAPITestProperty(PROPERTY_IGNORE_CACHE, 1, false) {
};
private Set setOf(TestProperty... testPropertys) {
Set result = new HashSet();
for (TestProperty testProperty: testPropertys) {
result.add(testProperty);
}
return result;
}
/**
* For each option supported by the PMF, test that
* the corresponding pm property is supported.
*/
public void testGetSupportedProperties() {
testRequiredProperties.add(testCopyOnAttach);
testRequiredProperties.add(testDetachAllOnCommit);
testRequiredProperties.add(testIgnoreCache);
testRestoreValues.setMessageForWrongResultAfterSet(ASSERTION_FAILED_12_19_4);
testRequiredProperties.add(testRestoreValues);
testLowerCaseMultithreaded.setMessageForWrongResultAfterSet(ASSERTION_FAILED_12_19_3);
testUpperCaseMultithreaded.setMessageForWrongResultAfterSet(ASSERTION_FAILED_12_19_3);
testOptionalProperties.put(PROPERTY_MULTITHREADED, setOf(testMultithreaded, testLowerCaseMultithreaded,
testUpperCaseMultithreaded));
testOptionalProperties.put(OPTION_DATASTORE_TIMEOUT,
setOf(testDatastoreReadTimeoutMillis, testDatastoreWriteTimeoutMillis));
testOptimistic.setMessageForWrongResultAfterSet(ASSERTION_FAILED_12_19_4);
testOptionalProperties.put(PROPERTY_OPTIMISTIC, setOf(testOptimistic));
testRetainValues.setMessageForWrongResultAfterSet(ASSERTION_FAILED_12_19_4);
testOptionalProperties.put(PROPERTY_RETAIN_VALUES, setOf(testRetainValues));
testNontransactionalRead.setMessageForWrongResultAfterSet(ASSERTION_FAILED_12_19_4);
testOptionalProperties.put(PROPERTY_NONTRANSACTIONAL_READ, setOf(testNontransactionalRead));
testNontransactionalWrite.setMessageForWrongResultAfterSet(ASSERTION_FAILED_12_19_4);
testOptionalProperties.put(PROPERTY_NONTRANSACTIONAL_WRITE, setOf(testNontransactionalWrite));
supportedOptions = pmf.supportedOptions();
for (String supportedOption: supportedOptions) {
System.out.println("supportedOptions returned: " + supportedOption);
}
supportedProperties = pm.getSupportedProperties();
errorIfEqual(ASSERTION_FAILED_12_19_7, null, supportedProperties);
for (String supportedProperty: supportedProperties) {
System.out.println("supportedProperties returned: " + supportedProperty);
}
// test required properties
for (TestProperty testProperty: testRequiredProperties) {
testProperty.test(pm, supportedProperties);
}
Set> properties = pm.getProperties().entrySet();
for (Map.Entry entry: properties) {
System.out.println("getProperties returned: " + entry.getKey() + ": " + entry.getValue());
}
// for each supported option, test the corresponding supported property
for (String supportedOption: supportedOptions) {
Set supportedOptionTestList = testOptionalProperties.get(supportedOption);
if (supportedOptionTestList != null) {
System.out.println("testing " + supportedOption);
for (TestProperty supportedOptionTest: supportedOptionTestList) {
supportedOptionTest.test(pm, supportedProperties);
}
}
}
try {
testIllegalArgument.test(pm, supportedProperties);
appendMessage(ASSERTION_FAILED_12_19_2 + "setProperty(PROPERTY_IGNORE_CACHE, 1) failed: " +
"Illegal argument PROPERTY_IGNORE_CACHE failed to throw an exception.");
} catch (Throwable t) {
// good catch
}
try {
// unknown property should be ignored
pm.setProperty("com.mystery.property", true);
} catch (Throwable t) {
appendMessage(ASSERTION_FAILED_12_19_1 + "Property com.mystery.property threw an exception.");
}
// changing a property of the returned set of property values must not change the underlying property value
pm.setProperty(PROPERTY_COPY_ON_ATTACH, true);
Map props = pm.getProperties();
props.put(PROPERTY_COPY_ON_ATTACH, false);
errorIfNotEqual(ASSERTION_FAILED_12_19_6, true, pm.getCopyOnAttach());
failOnError();
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanager/GetPutRemoveUserObject.java 100664 14210 12500110374 30613 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Test GetPutRemoveUserObject
*Keywords: getUserObject putUserObject removeUserObject
*Assertion IDs: A12.11-1
*Assertion Description:
* Object putUserObject(Object key, Object value); This method models
* the put method of Map. The current value associated with the key
* is returned and replaced by the parameter value.
* If the parameter value is null, the implementation may remove
* the entry from the table of managed key/value pairs
* Object removeUserObject(Object key); This method models
* the remove method of Map. The current value associated with the key
* is returned and removed.
* Object getUserObject(Object key); This method models
* the get method of Map. The current value associated with the key
* is returned. If the key is not found in the table, null is returned.]..]
*/
public class GetPutRemoveUserObject extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.11-1 (GetPutRemoveUserObject) failed: ";
/** First key
*/
private static final String KEY1 = "jdo.tck.key1";
/** Second key
*/
private static final String KEY2 = "jdo.tck.key2";
/** Non-existent key
*/
private static final String KEY_DOES_NOT_EXIST = "jdo.tck.keyDoesNotExist";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(GetPutRemoveUserObject.class);
}
/** */
public void testGetNonexistentKey() {
getPM();
assertNull(ASSERTION_FAILED +
"Non-null value returned from key that does not exist.",
pm.getUserObject(KEY_DOES_NOT_EXIST));
}
public void testPutKey() {
getPM();
UserObject obj1p = new UserObject();
UserObject obj2p = new UserObject();
UserObject obj3p = new UserObject();
UserObject obj4p = new UserObject();
Object obj1pv = pm.putUserObject(KEY1, obj1p);
Object obj2pv = pm.putUserObject(KEY2, obj2p);
Object obj1rv = pm.putUserObject(KEY1, obj3p);
Object obj2rv = pm.putUserObject(KEY2, obj4p);
assertNull(ASSERTION_FAILED +
"putUserObject expected null on first put" +
"; actual: " + obj1pv,
obj1pv);
assertSame(ASSERTION_FAILED +
"putUserObject expected replaced object returned: " + obj1p +
"; actual: " + obj1rv,
obj1p, obj1rv);
assertNull(ASSERTION_FAILED +
"putUserObject expected null on first put" +
"; actual: " + obj2pv,
obj2pv);
assertSame(ASSERTION_FAILED +
"putUserObject expected replaced object returned: " + obj2p +
"; actual: " + obj2rv,
obj2p, obj2rv);
}
public void testGetKey() {
getPM();
UserObject obj1p = new UserObject();
UserObject obj2p = new UserObject();
Object obj1pv = pm.putUserObject(KEY1, obj1p);
Object obj2pv = pm.putUserObject(KEY2, obj2p);
Object obj1g = pm.getUserObject(KEY1);
Object obj2g = pm.getUserObject(KEY2);
pm.putUserObject(KEY1, null);
pm.putUserObject(KEY2, null);
assertNull(ASSERTION_FAILED +
"putUserObject expected null" +
"; actual: " + obj1pv,
obj1pv);
assertSame(ASSERTION_FAILED +
"getUserObject expected: " + obj1p +
"; actual: " + obj1g,
obj1p, obj1g);
assertNull(ASSERTION_FAILED +
"putUserObject expected null" +
"; actual: " + obj2pv,
obj2pv);
assertSame(ASSERTION_FAILED +
"getUserObject expected: " + obj2p +
"; actual: " + obj2g,
obj2p, obj2g);
}
public void testRemoveKey() {
getPM();
UserObject obj1p = new UserObject();
UserObject obj2p = new UserObject();
pm.putUserObject(KEY1, obj1p);
pm.putUserObject(KEY2, obj2p);
Object obj1r = pm.removeUserObject(KEY1);
Object obj1rr = pm.removeUserObject(KEY1);
Object obj2r = pm.removeUserObject(KEY2);
Object obj2rr = pm.removeUserObject(KEY2);
assertSame(ASSERTION_FAILED +
"removeUserObject(KEY1) expected: " + obj1p +
"; actual: " + obj1r,
obj1p, obj1r);
assertNull(ASSERTION_FAILED +
"getUserObject(KEY1) expected null: " +
"; actual: " + obj1rr,
obj1rr);
assertSame(ASSERTION_FAILED +
"removeUserObject(KEY2) returned: " + obj2p +
"; actual: " + obj2r,
obj2p, obj2r);
assertNull(ASSERTION_FAILED +
"getUserObject(KEY2) expected null: " +
"; actual: " + obj2rr,
obj2rr);
}
private class UserObject {
/** No implementation needed for this class. It is only used
* with == comparisons.
*/
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanager/GetSetUserObject.java 100664 4707 12500110374 27412 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.pc.mylib.Point;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Get/Set User Object
*Keywords:
*Assertion ID: A12.8-1.
*Assertion Description:
The PersistenceManager.setUserObject method is used to store an object associated with the PersistenceManager. One uses the method getUserObject to later
retrieve the object.
*/
public class GetSetUserObject extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.8-1 (GetSetUserObject) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(GetSetUserObject.class);
}
/** */
public void testGetSetUserObject() {
pm = getPM();
Transaction tx = pm.currentTransaction();
try {
tx.begin();
Point p = new Point(10,10);
pm.setUserObject(p);
tx.commit();
tx.begin();
Object obj = pm.getUserObject();
if (obj != p) {
fail(ASSERTION_FAILED,
"Unexpected pm user object, expected " + p + ", got " + obj);
}
tx.commit();
tx = null;
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
pm.close();
pm = null;
}
}
././@LongLink 100644 0 0 155 12500111677 10254 L ustar 0 0 tck/src/java/org/apache/jdo/tck/api/persistencemanager/GetTransactionalObjectIdWhenObjectIdBeingChanged.java tck/src/java/org/apache/jdo/tck/api/persistencemanager/GetTransactionalObjectIdWhenObjectIdBeingChan100664 6642 12500110374 34144 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Get Transactional ObjectId When ObjectId Being Changed
*Keywords: identity applicationidentity
*Assertion ID: A12.5.6-15.
*Assertion Description:
If the object identity is being changed in the transaction, by the application
modifying one or more of the application key fields, then
PersistenceManager.getTransactionalObjectId returns the current
identity in the transaction.
*/
public class GetTransactionalObjectIdWhenObjectIdBeingChanged extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.5.6-15 (GetTransactionalObjectIdWhenObjectIdBeingChanged) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(GetTransactionalObjectIdWhenObjectIdBeingChanged.class);
}
/** */
public void testGetObjectByIdWhenObjectIdBeingChanged() {
if (!isChangeApplicationIdentitySupported()) {
if (debug)
logger.debug("Implementation does not support chaning application identity");
return;
}
if (debug)
logger.debug("\nSTART GetTransactionalObjectIdWhenObjectIdBeingChanged");
pm = getPM();
Object oid = createPCPointInstance(pm);
PCPoint p1 = (PCPoint) pm.getObjectById (oid, false);
Transaction tx = pm.currentTransaction();
try {
tx.begin();
p1.setX(10000); // this is the primary key
Object oid2 = pm.getTransactionalObjectId (p1); // should be different
tx.commit();
Object oid3 = pm.getObjectId (p1); // should be same as oid2
if (oid.equals(oid2)) {
fail(ASSERTION_FAILED,
"Oid before is the same as transactional oid after modifying pk");
}
if (!oid2.equals(oid3)) {
fail(ASSERTION_FAILED,
"Oid after is different from transactional oid after modifying pk");
}
}
finally {
if (debug)
logger.debug("END GetTransactionalObjectIdWhenObjectIdBeingChanged");
if ((tx != null) && tx.isActive())
tx.rollback();
}
pm.close();
pm = null;
}
}
././@LongLink 100644 0 0 146 12500111677 10254 L ustar 0 0 tck/src/java/org/apache/jdo/tck/api/persistencemanager/GetTransactionalObjectIdWithNoTransaction.java tck/src/java/org/apache/jdo/tck/api/persistencemanager/GetTransactionalObjectIdWithNoTransaction.jav100664 5220 12500110374 34264 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Get Transactional ObjectId With No Transaction
*Keywords: identity
*Assertion ID: A12.5.6-16
*Assertion Description:
If there is no transaction in progress, or if none of the key fields is being
modified, then PersistenceManager.getTransactionalObjectId has the same behavior as
getObjectId.
*/
public class GetTransactionalObjectIdWithNoTransaction extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.5.6-16 (GetTransactionalObjectIdWithNoTransaction) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(GetTransactionalObjectIdWithNoTransaction.class);
}
/** */
public void testGetTransactionalObjectIdWithNoTransaction() {
pm = getPM();
Transaction tx = pm.currentTransaction();
try {
PCPoint p1 = new PCPoint();
tx.begin();
pm.makePersistent(p1);
Object oid = pm.getObjectId(p1);
tx.commit();
Object toid = pm.getTransactionalObjectId(p1);
if (!toid.equals(oid)) {
fail(ASSERTION_FAILED,
"pm.getTransactionalObjectId(p1) returned unexpected ObjectId, expected " +
oid + ", got " + toid);
}
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
pm.close();
pm = null;
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanager/lifecycle/MakeNontransactionalAllFails.java 100664 13434 12500110374 33730 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.lifecycle;
import java.util.Collection;
import javax.jdo.JDOUserException;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.pc.mylib.Point;
import org.apache.jdo.tck.util.BatchTestRunner;
import org.apache.jdo.tck.api.persistencemanager.PersistenceManagerTest;
/**
*Title: MakeNontransactionalAllFails
*Keywords: exception
*Assertion ID: A12.5.7-5
*Assertion Description:
If a collection or array of instances is passed to PersistenceManager.makeNontransactionalAll, and one or more of the instances fail to complete the required operation, then all instances will be attempted, and a JDOUserException will be thrown which contains a nested exception array, each exception of which contains one of the failing instances. The succeeding instances will transition to the specified life cycle state, and the failing instances will remain in their current state.
*/
public class MakeNontransactionalAllFails extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.5.7-5 (MakeNontransactionalAllFails) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(MakeNontransactionalAllFails.class);
}
private PCPoint p1 = null;
private PCPoint p2 = null;
private PCPoint p3 = null;
private PCPoint p4 = null;
private Point p5 = null;
/** */
public void testTransactionalInst() {
pm = getPM();
createObjects(pm);
runTestMakeNontransactional1(pm);
runTestMakeNontransactionalAll1(pm);
pm.close();
pm = null;
}
/** */
private void createObjects(PersistenceManager pm) {
p1 = new PCPoint(1,3);
p2 = new PCPoint(2,4);
p3 = new PCPoint(3,5);
p4 = new PCPoint(4,6);
}
/* test makeNontransactional (Object pc) */
private void runTestMakeNontransactional1(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
pm.makePersistent(p1);
try {
pm.makeNontransactional(p1);
fail(ASSERTION_FAILED,
"pm.makeNontransactional should throw a JDOUserException when called for a P-NEW instance.");
}
catch (JDOUserException ex) {
// expected exception
}
tx.rollback();
tx = null;
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
/* test makeNontransactionalAll (Collection pcs) */
private void runTestMakeNontransactionalAll1(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
pm.makePersistent(p2);
tx.commit();
tx.begin();
pm.makePersistent(p3);
pm.makePersistent(p4);
Collection col1 = new java.util.HashSet();
col1.add(p2);
col1.add(p3);
col1.add(p4);
try {
pm.makeNontransactionalAll(col1);
fail(ASSERTION_FAILED,
"pm.makeNontransactionalAll(Collection) should throw a JDOUserException when called for collection including P-NEW instances.");
}
catch (JDOUserException ex) {
// expected exception
}
tx.rollback();
tx = null;
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
/* test makeNontransactionalAll (Object[] pcs) */
private void testMakeNontransactionalAll2(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
tx = pm.currentTransaction();
tx.begin();
pm.makePersistent(p2);
tx.commit();
tx.begin();
pm.makePersistent(p3);
pm.makePersistent(p4);
Collection col1 = new java.util.HashSet();
col1.add(p2);
col1.add(p3);
col1.add(p4);
try {
pm.makeNontransactionalAll(col1.toArray());
fail(ASSERTION_FAILED,
"pm.makeNontransactionalAll(Object []) should throw a JDOUserException when called for an array including P-NEW instances.");
}
catch (JDOUserException ex) {
// expected exception
}
tx.rollback();
tx = null;
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
}
././@LongLink 100644 0 0 150 12500111677 10247 L ustar 0 0 tck/src/java/org/apache/jdo/tck/api/persistencemanager/lifecycle/MakeNontransactionalDirtyInstance.java tck/src/java/org/apache/jdo/tck/api/persistencemanager/lifecycle/MakeNontransactionalDirtyInstance.j100664 23726 12500110374 34336 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.lifecycle;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import javax.jdo.JDOUserException;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
import org.apache.jdo.tck.api.persistencemanager.PersistenceManagerTest;
/**
*Title: Make Nontransactional a Dirty Instance
*Keywords: exception
*Assertion IDs: A12.5.7-28
*Assertion Description:
If PersistenceManager.makeNontransactional or makeNontransactionalAll is called with an explicit dirty parameter instance, a JDOUserException is thrown.
*/
public class MakeNontransactionalDirtyInstance extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.5.7-28 (MakeNontransactionalDirtyInstance) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(MakeNontransactionalDirtyInstance.class);
}
private PCPoint p1 = null;
private PCPoint p2 = null;
private PCPoint p3 = null;
private PCPoint p4 = null;
private PCPoint p5 = null;
private PCPoint p6 = null;
private PCPoint p7 = null;
private PCPoint c1 = null;
private PCPoint c2 = null;
private PCPoint c3 = null;
private PCPoint c4 = null;
private PCPoint c5 = null;
private PCPoint c6 = null;
private PCPoint c7 = null;
private Collection pcol1 = new HashSet();
private Collection pcol2 = new HashSet();
private Collection ccol1 = new HashSet();
private Collection ccol2 = new HashSet();
/** */
public void testMakeNontransactional() {
pm = getPM();
/* call with an explicit persistent dirty parameter instance */
String pstate="persistent";
createPersistentObjects(pm);
if (debug)
logger.debug(" -- testing with persistent dirty instance -- ");
runTestMakeNontransactionalDirtyInstance(pm, p1,pstate);
runTestMakeNontransactionalDirtyInstanceAll1(pm, pcol1, pstate);
runTestMakeNontransactionalDirtyInstanceAll2(pm, pcol2, pstate);
/* call with an explicit transient dirty parameter instance */
pstate="transient";
createTcleanObjects(pm);
if (debug)
logger.debug (" -- testing with transient dirty instance -- ");
runTestMakeNontransactionalDirtyInstance(pm, c1,pstate);
runTestMakeNontransactionalDirtyInstanceAll1(pm, ccol1, pstate);
runTestMakeNontransactionalDirtyInstanceAll2(pm, ccol2, pstate);
pm.close();
pm = null;
}
/** */
private void createTcleanObjects(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
c1 = new PCPoint(1,3);
c2 = new PCPoint(2,4);
c3 = new PCPoint(3,5);
c4 = new PCPoint(4,6);
c5 = new PCPoint (5,7);
c6 = new PCPoint (6,8);
c7 = new PCPoint (7,9);
ccol1.add(c2);
ccol1.add(c3);
ccol1.add(c4);
ccol2.add(c5);
ccol2.add(c6);
ccol2.add(c7);
pm.makeTransactional(c1);
pm.makeTransactional(c2);
pm.makeTransactional(c3);
pm.makeTransactional(c4);
pm.makeTransactional(c5);
pm.makeTransactional(c6);
pm.makeTransactional(c7);
tx.commit();
tx = null;
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
/** */
private void createPersistentObjects(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
p1 = new PCPoint(1,3);
p2 = new PCPoint(2,4);
p3 = new PCPoint(3,5);
p4 = new PCPoint(4,6);
p5 = new PCPoint (5,7);
p6 = new PCPoint (6,8);
p7 = new PCPoint (7,9);
pm.makePersistent(p1);
pm.makePersistent(p2);
pm.makePersistent(p3);
pm.makePersistent(p4);
pm.makePersistent(p5);
pm.makePersistent(p6);
pm.makePersistent(p7);
pcol1.add(p2);
pcol1.add(p3);
pcol1.add(p4);
pcol2.add(p5);
pcol2.add(p6);
pcol2.add(p7);
tx.commit();
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
/** */
private void runTestMakeNontransactionalDirtyInstance(PersistenceManager pm, PCPoint obj, String state) {
Transaction tx = pm.currentTransaction();
try {
if (debug)
logger.debug(" ** in testMakeNontransactionalDirtyInstance()");
int curr;
tx.begin();
if (makeAndTestDirtyInstance(obj,state)) {
try {
pm.makeNontransactional(obj);
fail (ASSERTION_FAILED,
"pm.makeNontransactional should throw a JDOUserException when called for P-DIRTY instance.");
}
catch (JDOUserException ex) {
// expected exception
}
}
tx.rollback();
tx = null;
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
/** */
private void runTestMakeNontransactionalDirtyInstanceAll1(PersistenceManager pm, Collection tcol, String state) {
Transaction tx = pm.currentTransaction();
boolean stopFlag = false;
try {
if (debug)
logger.debug(" ** in testMakeNontransactionalDirtyInstanceAll1()");
int curr;
tx.begin();
Iterator iter = tcol.iterator();
while (iter.hasNext()) {
PCPoint p = (PCPoint) iter.next();
if (makeAndTestDirtyInstance(p,state))
stopFlag = true;
}
if (! stopFlag) {
try {
pm.makeNontransactionalAll(tcol);
fail (ASSERTION_FAILED,
"pm.makeNontransactionalAll(Collection) should throw a JDOUserException when called for a collection including P-DIRTY instances.");
}
catch (JDOUserException ex) {
// expected exception
}
}
tx.rollback();
tx = null;
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
/** */
private void runTestMakeNontransactionalDirtyInstanceAll2(PersistenceManager pm,
Collection tcol,
String state) {
Transaction tx = pm.currentTransaction();
boolean stopFlag = false;
try {
if (debug)
logger.debug(" ** in testMakeNontransactionalDirtyInstanceAll2()");
tx.begin();
Iterator iter = tcol.iterator();
while (iter.hasNext()) {
PCPoint p = (PCPoint) iter.next();
if (makeAndTestDirtyInstance(p,state))
stopFlag = true;
}
Object[] objArray = tcol.toArray();
if (! stopFlag) {
try {
pm.makeNontransactionalAll(objArray);
fail (ASSERTION_FAILED,
"pm.makeNontransactionalAll(Object []) should throw a JDOUserException when called for an arry including P-DIRTY instances.");
}
catch (JDOUserException ex) {
// expected exception
}
}
tx.rollback();
tx = null;
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
/** */
private boolean makeAndTestDirtyInstance (PCPoint obj, String state) {
int i = obj.getX();
i = i*10;
obj.setX(i);
int curr = currentState(obj);
if (state.equals("persistent")) {
if ( curr != PERSISTENT_DIRTY ) {
fail(ASSERTION_FAILED,
" Object not in persistent dirty state " +
" for " + obj.getX() + " current state: " + curr);
return false;
}
}
else if (state.equals("transient")) {
if ( curr != TRANSIENT_DIRTY ) {
fail(ASSERTION_FAILED,
" Object not in transient dirty state " +
" for " + obj.getX() + " current state: " + curr);
return false;
}
}
return true;
}
}
././@LongLink 100644 0 0 146 12500111677 10254 L ustar 0 0 tck/src/java/org/apache/jdo/tck/api/persistencemanager/lifecycle/MakeNontransactionalIsImmediate.java tck/src/java/org/apache/jdo/tck/api/persistencemanager/lifecycle/MakeNontransactionalIsImmediate.jav100664 17714 12500110374 34277 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.lifecycle;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
import org.apache.jdo.tck.api.persistencemanager.PersistenceManagerTest;
/**
*Title: Make Nontransactional is immediate
*Keywords:
*Assertion IDs: A12.5.7-29
*Assertion Description:
The effect of PersistenceManager.makeNontransactional or
makeNontransactionalAll is immediate and not subject to rollback.
*/
public class MakeNontransactionalIsImmediate extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.5.7-29 (MakeNontransactionalIsImmediate) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(MakeNontransactionalIsImmediate.class);
}
private PCPoint p1 = null;
private PCPoint p2 = null;
private PCPoint p3 = null;
private PCPoint p4 = null;
private PCPoint p5 = null;
private PCPoint p6 = null;
private PCPoint p7 = null;
private Collection col1 = new HashSet();
private Collection col2 = new HashSet();
/** */
public void testTransactionalInst() {
pm = getPM();
createTcleanObjects();
runTestMakeNontransactionalIsImmediate(pm);
runTestMakeNontransactionalIsImmediateAll1(pm);
runTestMakeNontransactionalIsImmediateAll2(pm);
pm.close();
pm = null;
}
/** */
private void createTcleanObjects() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
p1 = new PCPoint(1,3);
p2 = new PCPoint(2,4);
p3 = new PCPoint(3,5);
p4 = new PCPoint(4,6);
p5 = new PCPoint (5,7);
p6 = new PCPoint (6,8);
p7 = new PCPoint (7,9);
col1.add(p2);
col1.add(p3);
col1.add(p4);
col2.add(p5);
col2.add(p6);
col2.add(p7);
pm.makeTransactional(p1);
pm.makeTransactional(p2);
pm.makeTransactional(p3);
pm.makeTransactional(p4);
pm.makeTransactional(p5);
pm.makeTransactional(p6);
pm.makeTransactional(p7);
tx.commit();
tx = null;
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
/** */
private void runTestMakeNontransactionalIsImmediate(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
if (debug)
logger.debug (" ** in runTestMakeNontransactionalIsImmediate()");
int curr;
tx.begin();
if (testState(p1, TRANSIENT_CLEAN, "transient clean")) {
pm.makeNontransactional(p1);
if (! testState(p1, TRANSIENT, "transient")) {
fail(ASSERTION_FAILED,
"transient clean instance shoud become transient immediately after pm.makeNontransactional");
}
}
tx.rollback();
tx = null;
if (! testState(p1, TRANSIENT, "transient")) {
fail(ASSERTION_FAILED,
"tx.rollback should rollback effect of pm.makeNontransactional");
}
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
/** */
private void runTestMakeNontransactionalIsImmediateAll1(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
if (debug)
logger.debug(" ** in runTestMakeNontransactionalIsImmediateAll1()");
int curr;
tx.begin();
if (testState (p2, TRANSIENT_CLEAN, "transient clean") &&
testState (p3, TRANSIENT_CLEAN, "transient clean") &&
testState (p4, TRANSIENT_CLEAN, "transient clean")) {
pm.makeNontransactionalAll(col1);
if (! navigateAndTestTransientCol(col1)) {
fail(ASSERTION_FAILED,
"transient clean instances shoud become transient immediately after pm.makeNontransactionalAll(Collection)");
}
}
tx.rollback();
tx.begin();
if (! navigateAndTestTransientCol(col1)) {
fail(ASSERTION_FAILED,
"tx.rollback should rollback effect of pm.makeNontransactionalAll(Collection)");
}
tx.rollback();
tx = null;
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
/** */
private void runTestMakeNontransactionalIsImmediateAll2(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
if (debug)
logger.debug(" ** in runTestMakeNontransactionalIsImmediateAll2()");
int curr;
tx.begin();
Object[] objArray = col2.toArray();
if (testState (p5, TRANSIENT_CLEAN, "transient clean") &&
testState (p6, TRANSIENT_CLEAN, "transient clean") &&
testState (p7, TRANSIENT_CLEAN, "transient clean")) {
pm.makeNontransactionalAll(objArray);
if (! navigateAndTestTransientArray(objArray)) {
fail(ASSERTION_FAILED,
"transient clean instances shoud become transient immediately after pm.makeNontransactionalAll(Object[])");
}
}
tx.rollback();
tx.begin();
if (! navigateAndTestTransientArray(objArray)) {
fail(ASSERTION_FAILED,
"tx.rollback should rollback effect of pm.makeNontransactionalAll(Object[])");
}
tx.rollback();
tx = null;
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
/** */
private boolean navigateAndTestTransientCol (Collection col) {
boolean noError = true;
Iterator iter = col1.iterator();
while (iter.hasNext() ) {
PCPoint p = (PCPoint) iter.next();
if (! testState(p, TRANSIENT, "transient")) {
noError = false;
}
}
return noError;
}
/** */
private boolean navigateAndTestTransientArray (Object[] objArray) {
boolean noError = true;
for (int i=0; i < objArray.length; i++) {
PCPoint p = (PCPoint) objArray[i];
if (! testState(p, TRANSIENT, "transient")) {
noError = false;
}
}
return noError;
}
}
././@LongLink 100644 0 0 162 12500111677 10252 L ustar 0 0 tck/src/java/org/apache/jdo/tck/api/persistencemanager/lifecycle/MakeNontransactionalPersistentCleanInstance.java tck/src/java/org/apache/jdo/tck/api/persistencemanager/lifecycle/MakeNontransactionalPersistentClean100664 17303 12500110374 34423 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.lifecycle;
import java.util.Collection;
import java.util.Iterator;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
import org.apache.jdo.tck.api.persistencemanager.PersistenceManagerTest;
/**
*Title: Make Nontransactional a Persistent-Clean Instance
*Keywords: lifecycle
*Assertion IDs: A12.5.7-27
*Assertion Description:
PersistenceManager.makeNontransactional and makeNontransactionalAll makes a
*persistent-clean instance nontransactional and causes a state transition to
*persistent-nontransactional.
*/
public class MakeNontransactionalPersistentCleanInstance
extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.5.7-27 (MakeNontransactionalPersistentCleanInstance) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(MakeNontransactionalPersistentCleanInstance.class);
}
private PCPoint p1 = null;
private PCPoint p2 = null;
private PCPoint p3 = null;
private PCPoint p4 = null;
private PCPoint p5 = null;
private PCPoint p6 = null;
private PCPoint p7 = null;
private Collection col1 = new java.util.HashSet();
private Collection col2 = new java.util.HashSet();
/** */
public void testTransactionalInstance() {
pm = getPM();
createObjects(pm);
runTestMakeNontransactionalPersistentCleanInstance(pm);
runTestMakeNontransactionalPersistentCleanInstanceAll1(pm);
runTestMakeNontransactionalPersistentCleanInstanceAll2(pm);
pm.close();
pm = null;
}
/** */
private void createObjects(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
tx.setOptimistic(false);
tx.begin();
p1 = new PCPoint(1,3);
p2 = new PCPoint(2,4);
p3 = new PCPoint(3,5);
p4 = new PCPoint(4,6);
p5 = new PCPoint (5,7);
p6 = new PCPoint (6,8);
p7 = new PCPoint (7,9);
col1.add(p2);
col1.add(p3);
col1.add(p4);
col2.add(p5);
col2.add(p6);
col2.add(p7);
pm.makePersistent(p1);
pm.makePersistent(p2);
pm.makePersistent(p3);
pm.makePersistent(p4);
pm.makePersistent(p5);
pm.makePersistent(p6);
pm.makePersistent(p7);
tx.commit();
tx = null;
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
/** */
private void runTestMakeNontransactionalPersistentCleanInstance(
PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
if (debug)
logger.debug(" ** in testMakeNontransactionalPersistentCleanInstance()");
int curr;
tx.setOptimistic(false);
tx.begin();
if (makePersistentCleanInstance(p1)) {
pm.makeNontransactional(p1);
curr = currentState(p1);
if (curr == HOLLOW ||
curr == PERSISTENT_NONTRANSACTIONAL) {
}
else {
fail(ASSERTION_FAILED,
"Excpected P-HOLLOW or P-NONTX instance, instance is " +
getStateOfInstance(p1));
}
}
tx.commit();
tx = null;
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
/** */
private void runTestMakeNontransactionalPersistentCleanInstanceAll1(
PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
if (debug)
logger.debug(" ** in testMakeNontransactionalPersistentCleanInstanceAll1()");
int curr;
tx.setOptimistic(false);
tx.begin();
if ( makePersistentCleanInstance(p2) &&
makePersistentCleanInstance(p3) &&
makePersistentCleanInstance(p4)) {
pm.makeNontransactionalAll(col1);
Iterator iter = col1.iterator();
while (iter.hasNext() ) {
PCPoint p = (PCPoint) iter.next();
curr = currentState(p);
if (curr == HOLLOW ||
curr == PERSISTENT_NONTRANSACTIONAL) {
}
else {
fail(ASSERTION_FAILED,
"Expected persistent-nontransactional or hollow; got " +
getStateOfInstance(p));
}
}
}
tx.commit();
tx = null;
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
/** */
private void runTestMakeNontransactionalPersistentCleanInstanceAll2(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
if (debug)
logger.debug(" ** in testMakeNontransactionalPersistentCleanInstanceAll2()");
int curr;
if (tx.getOptimistic())
if (debug) logger.debug (" opt flag set to true");
tx.begin();
Object[] objArray = col2.toArray();
if ( makePersistentCleanInstance(p5) &&
makePersistentCleanInstance(p6) &&
makePersistentCleanInstance(p7)) {
pm.makeNontransactionalAll(objArray);
for (int i=0; i < objArray.length; i++) {
PCPoint p = (PCPoint) objArray[i];
curr = currentState(p);
if (curr == HOLLOW ||
curr == PERSISTENT_NONTRANSACTIONAL) {
}
else {
fail(ASSERTION_FAILED,
"Expected persistent-nontransactional or hollow; got " +
getStateOfInstance(p));
}
}
}
tx.commit();
tx = null;
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
/** */
private boolean makePersistentCleanInstance (PCPoint obj) {
int val = obj.getX();
return (testState(obj, PERSISTENT_CLEAN, "persistent clean"));
}
}
././@LongLink 100644 0 0 161 12500111677 10251 L ustar 0 0 tck/src/java/org/apache/jdo/tck/api/persistencemanager/lifecycle/MakeNontransactionalTransientCleanInstance.java tck/src/java/org/apache/jdo/tck/api/persistencemanager/lifecycle/MakeNontransactionalTransientCleanI100664 16703 12500110374 34346 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.lifecycle;
import java.util.Collection;
import java.util.Iterator;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
import org.apache.jdo.tck.api.persistencemanager.PersistenceManagerTest;
/**
*Title: MakeNontransactionalTransientCleanInstance
*Keywords: lifecycle
*Assertion IDs: A12.5.7-26
*Assertion Description:
PersistenceManager.makeNontransactional and makeNontransactionalAll makes a transient-clean instance nontransactional and causes a state transition to transient. After the method completes, the instance does not observe transaction boundaries.
*/
public class MakeNontransactionalTransientCleanInstance extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.5.7-26 (MakeNontransactionalTransientCleanInstance) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(MakeNontransactionalTransientCleanInstance.class);
}
private PCPoint p1 = null;
private PCPoint p2 = null;
private PCPoint p3 = null;
private PCPoint p4 = null;
private PCPoint p5 = null;
private PCPoint p6 = null;
private PCPoint p7 = null;
private Collection col1 = new java.util.HashSet();
private Collection col2 = new java.util.HashSet();
/** */
public void testTransactionalInst() {
pm = getPM();
createTcleanObjects(pm);
runTestMakeNontransactionalTransientCleanInstance(pm);
runTestMakeNontransactionalTransientCleanInstanceAll1(pm);
runTestMakeNontransactionalTransientCleanInstanceAll2(pm);
pm.close();
pm = null;
}
/** */
private void createTcleanObjects(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
tx = pm.currentTransaction();
tx.begin();
p1 = new PCPoint(1,3);
p2 = new PCPoint(2,4);
p3 = new PCPoint(3,5);
p4 = new PCPoint(4,6);
p5 = new PCPoint (5,7);
p6 = new PCPoint (6,8);
p7 = new PCPoint (7,9);
col1.add(p2);
col1.add(p3);
col1.add(p4);
col2.add(p5);
col2.add(p6);
col2.add(p7);
pm.makeTransactional(p1);
pm.makeTransactional(p2);
pm.makeTransactional(p3);
pm.makeTransactional(p4);
pm.makeTransactional(p5);
pm.makeTransactional(p6);
pm.makeTransactional(p7);
tx.commit();
tx = null;
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
/** */
private void runTestMakeNontransactionalTransientCleanInstance(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
if (debug)
logger.debug(" ** in testMakeNontransactionalTransientCleanInstance()");
int curr;
tx.begin();
if (testState(p1, TRANSIENT_CLEAN, "transient clean")) {
pm.makeNontransactional(p1);
if (testState(p1, TRANSIENT, "transient")) {
// expected result
}
else {
fail(ASSERTION_FAILED,
"expected transient instance after pm.makeNontransactional, instance is " +
getStateOfInstance(p1));
}
}
tx.commit();
tx = null;
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
/** */
private void runTestMakeNontransactionalTransientCleanInstanceAll1(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
if (debug)
logger.debug(" ** in testMakeNontransactionalTransientCleanInstanceAll1()");
int curr;
tx.begin();
if (testState(p2, TRANSIENT_CLEAN, "transient clean") &&
testState(p3, TRANSIENT_CLEAN, "transient clean") &&
testState(p4, TRANSIENT_CLEAN, "transient clean")) {
pm.makeNontransactionalAll(col1);
Iterator iter = col1.iterator();
while (iter.hasNext() ) {
PCPoint p = (PCPoint) iter.next();
if (testState(p, TRANSIENT, "transient")) {
// expected result
}
else {
fail(ASSERTION_FAILED,
"expected transient instance after pm.makeNontransactionalAll, instance is " +
getStateOfInstance(p));
}
}
}
tx.commit();
tx = null;
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
/** */
private void runTestMakeNontransactionalTransientCleanInstanceAll2(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
if (debug)
logger.debug (" ** in testMakeNontransactionalTransientCleanInstanceAll2()");
int curr;
tx.begin();
Object[] objArray = col2.toArray();
if (testState(p5, TRANSIENT_CLEAN, "transient clean") &&
testState(p6, TRANSIENT_CLEAN, "transient clean") &&
testState(p7, TRANSIENT_CLEAN, "transient clean")) {
pm.makeNontransactionalAll(objArray);
for (int i=0; i < objArray.length; i++) {
PCPoint p = (PCPoint) objArray[i];
if (testState(p, TRANSIENT, "transient")) {
// expected result
}
else {
fail(ASSERTION_FAILED,
"expected transient instance after pm.makeNontransactionalAll, instance is " +
getStateOfInstance(p));
}
}
}
tx.commit();
tx = null;
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanager/lifecycle/MakePersistent.java 100664 15320 12500110374 31137 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.lifecycle;
import java.util.Collection;
import java.util.HashSet;
import javax.jdo.JDOUserException;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
import org.apache.jdo.tck.api.persistencemanager.PersistenceManagerTest;
/**
*Title: make instance persistent
*Keywords: persistencemanager
*Assertion IDs: A12.5.7-6A
*Assertion Description:
The method PersistenceManager.makePersistent and
makePersistentAll makes a transient instance(s) persistent directly.
It must be called in the context of an active transaction,
or a JDOUserException is thrown.
*/
public class MakePersistent extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.5.7-6A (MakePersistent) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(MakePersistent.class);
}
private PCPoint p1 = null;
private PCPoint p2 = null;
private PCPoint p3 = null;
private PCPoint p4 = null;
private PCPoint p5 = null;
/**
* Overrides parent method to avoid querying for classes
* that may not exist in the schema
*/
protected void localSetUp() {
addTearDownClass(PCPoint.class);
}
/** */
public void testMakePersistent() {
pm = getPM();
createObjects();
/* positive tests */
runTestMakePersistent1(pm);
runTestMakePersistent2(pm);
runTestMakePersistent3(pm);
/* negative tests */
runTestMakePersistent4(pm);
runTestMakePersistent5(pm);
runTestMakePersistent6(pm);
pm.close();
pm = null;
}
/** */
private void createObjects() {
p1 = new PCPoint(1,3);
p2 = new PCPoint(2,4);
p3 = new PCPoint(3,5);
p4 = new PCPoint(4,6);
p5 = new PCPoint(5,7);
}
/* test makePersistent (Object pc) */
private void runTestMakePersistent1(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
pm.makePersistent(p1);
tx.commit();
tx = null;
if (debug) logger.debug(" \nPASSED in runTestMakePersistent1()");
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
/* test makePersistentAll (Collection pcs) */
private void runTestMakePersistent2(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
Collection col1 = new HashSet();
col1.add(p2);
col1.add(p3);
pm.makePersistentAll(col1);
tx.commit();
tx = null;
if (debug) logger.debug(" \nPASSED in runTestMakePersistent2()");
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
/* test makePersistentAll (Object[] o) */
private void runTestMakePersistent3(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
tx = pm.currentTransaction();
tx.begin();
Collection col1 = new HashSet();
col1.add(p1);
col1.add(p2);
Object[] obj1= col1.toArray();
pm.makePersistentAll(obj1);
tx.commit();
tx = null;
if (debug) logger.debug (" \nPASSED in runTestMakePersistent3()");
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
/* test makePersistent (Object pc) */
private void runTestMakePersistent4(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
if (tx.isActive())
tx.rollback();
PCPoint np1 = new PCPoint(1,3);
try {
pm.makePersistent(np1);
fail(ASSERTION_FAILED,
"pm.makePersistent outside of a tx should throw a JDOUserException");
}
catch (JDOUserException ex) {
// expected expected
}
}
/* test makePersistentAll (Collection pcs) */
private void runTestMakePersistent5(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
if (tx.isActive())
tx.rollback();
PCPoint np1 = new PCPoint (3,3);
PCPoint np2 = new PCPoint (4,4);
Collection col1 = new HashSet();
col1.add(np1);
col1.add(np2);
try {
pm.makePersistentAll(col1);
fail(ASSERTION_FAILED,
"pm.makePersistentAll(Collection) outside of a tx should throw a JDOUserException");
}
catch (JDOUserException ex) {
// expected expected
}
}
/* test makePersistentAll (Object[] o) */
private void runTestMakePersistent6(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
if (tx.isActive())
tx.rollback();
PCPoint np1 = new PCPoint (3,3);
PCPoint np2 = new PCPoint (4,4);
Collection col1 = new HashSet();
col1.add(np1);
col1.add(np2);
Object[] obj1=col1.toArray();
try {
pm.makePersistentAll(obj1);
fail(ASSERTION_FAILED,
"pm.makePersistentAll(Object[]) outside of a tx should throw a JDOUserException");
}
catch (JDOUserException ex) {
// expected expected
}
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanager/lifecycle/MakePersistentAllFails.java 100664 11076 12500110374 32553 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.lifecycle;
import java.util.Collection;
import javax.jdo.JDOUserException;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.pc.mylib.Point;
import org.apache.jdo.tck.util.BatchTestRunner;
import org.apache.jdo.tck.api.persistencemanager.PersistenceManagerTest;
/**
*Title: MakePersistentAll Fails
*Keywords: exception
*Assertion IDs: A12.5.7-1.
*Assertion Description:
If a collection or array of instances is passed to PersistenceManager.makePersistentAll, and one or more of the instances fail to complete the operation, then all instances will be attempted, and a JDOUserException will be thrown which contains a nested exception array, each exception of which contains one of the failing instances. The succeeding instances will transition to the specified life cycle state, and the failing instances will remain in their current state.
*/
public class MakePersistentAllFails extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.5.7-1 (MakePersistentAllFails) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(MakePersistentAllFails.class);
}
/** */
public void testMakePersistentAllFails() {
pm = getPM();
runTestMakePersistentAllFails1(pm);
runTestMakePersistentAllFails2(pm);
pm.close();
pm = null;
}
/* test makePersistentAll (Collection pcs) */
private void runTestMakePersistentAllFails1(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
PCPoint np1 = new PCPoint (3,3);
PCPoint np2 = new PCPoint (4,4);
Point np3 = new Point (5,5);
Collection col1 = new java.util.HashSet();
col1.add(np1);
col1.add(np2);
col1.add(np3);
try {
pm.makePersistentAll(col1);
fail(ASSERTION_FAILED,
"pm.makePersistentAll(Collection) should thro JDOUserException when called for collection including instance of non-pc class.");
}
catch (JDOUserException ex) {
// expected exception
}
tx.rollback();
tx = null;
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
/* test makePersistentAll (Object[] o) */
private void runTestMakePersistentAllFails2(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
PCPoint np1 = new PCPoint (3,3);
PCPoint np2 = new PCPoint (4,4);
Point np3 = new Point (5,5);
Collection col1 = new java.util.HashSet();
col1.add(np1);
col1.add(np2);
col1.add(np3);
Object[] obj1=col1.toArray();
try {
pm.makePersistentAll(obj1);
fail(ASSERTION_FAILED,
"pm.makePersistentAll(Object[]) should thro JDOUserException when called for array including instance of non-pc class ");
}
catch (JDOUserException ex) {
// expected exception
}
tx.rollback();
tx = null;
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
}
././@LongLink 100644 0 0 155 12500111677 10254 L ustar 0 0 tck/src/java/org/apache/jdo/tck/api/persistencemanager/lifecycle/MakePersistentAndInstancesNotReachable.java tck/src/java/org/apache/jdo/tck/api/persistencemanager/lifecycle/MakePersistentAndInstancesNotReacha100664 11117 12500110374 34277 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.lifecycle;
import java.util.Date;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.api.persistencemanager.PersistenceManagerTest;
import org.apache.jdo.tck.pc.company.Address;
import org.apache.jdo.tck.pc.company.Company;
import org.apache.jdo.tck.pc.company.Department;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: MakePersistent And Instances Not Reachable
*Keywords:
*Assertion ID: A12.5.7-6C.
*Assertion Description:
When calling PersistenceManager.makePersistent or makePersistentAll,
transient instances will become persistent and any transient instances reachable via persistent
fields will become provisionally persistent. That is, they behave as persistent-new instances
(return true to isPersistent, isNew, and isDirty).
But at commit time, the reachability algorithm is run again,
and instances made provisionally persistent that are not
currently reachable from persistent instances will revert to transient.
*/
public class MakePersistentAndInstancesNotReachable extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.5.7-6C (MakePersistentAndInstancesNotReachable) failed: ";
private Department dep1 = null;
private Department dep2 = null;
private Department dep3 = null;
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(MakePersistentAndInstancesNotReachable.class);
}
/** */
public void test() {
pm = getPM();
createObjects(pm);
runTest(pm);
}
/** */
private void createObjects(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
tx.begin();
Company comp = new Company(1L, "Sun Microsystems", new Date(), new Address(0,"","","","",""));
//Add transient departments
dep1 = new Department(1L, "Department 1");
dep2 = new Department(2L, "Department 1");
dep3 = new Department(3L, "Department 1");
comp.addDepartment(dep1);
comp.addDepartment(dep2);
comp.addDepartment(dep3);
pm.makePersistent(comp); //Now the transient departments should be made provisionally persistent via reachability
int curr = currentState(dep1);
if( curr != PERSISTENT_NEW ){
fail(ASSERTION_FAILED, "dep1 should be persistent-new, state is " + states[curr]);
}
curr = currentState(dep2);
if( curr != PERSISTENT_NEW ){
fail(ASSERTION_FAILED, "dep2 should be persistent-new, state is " + states[curr]);
}
curr = currentState(dep3);
if( curr != PERSISTENT_NEW ){
fail(ASSERTION_FAILED, "dep3 should be persistent-new, state is " + states[curr]);
}
//Remove departments
comp.removeDepartment(dep1);
comp.removeDepartment(dep2);
comp.removeDepartment(dep3);
tx.commit(); //Now the removed departments should be made transient again
}
/** */
void runTest(PersistenceManager pm) {
int curr = currentState(dep1);
if( curr != TRANSIENT ){
fail(ASSERTION_FAILED, "dep1 should be transient, state is " + states[curr]);
}
curr = currentState(dep2);
if( curr != TRANSIENT ){
fail(ASSERTION_FAILED, "dep2 should be transient, state is " + states[curr]);
}
curr = currentState(dep3);
if( curr != TRANSIENT ){
fail(ASSERTION_FAILED, "dep3 should be transient, state is " + states[curr]);
}
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanager/lifecycle/MakePersistentAssignsObjectId.java 100664 13327 12500110374 34100 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.lifecycle;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import javax.jdo.Transaction;
import javax.jdo.PersistenceManager;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
import org.apache.jdo.tck.api.persistencemanager.PersistenceManagerTest;
/**
*Title: make instance persistent
*Keywords: identity
*Assertion IDs: A12.5.7-6B
*Assertion Description:
The method PersistenceManager.makePersistent and
makePersistentAll will assign an object identity to the instance
and transitions it to persistent-new.
*/
public class MakePersistentAssignsObjectId extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.5.7-6B (MakePersistentAssignsObjectId) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(MakePersistentAssignsObjectId.class);
}
private PCPoint p1 = null;
private PCPoint p2 = null;
private PCPoint p3 = null;
private PCPoint p4 = null;
private PCPoint p5 = null;
/** */
public void testMakePersistentAssignsObjectId() {
pm = getPM();
createObjects();
/* positive tests */
runTestMakePersistentAssignsObjectId1(pm);
runTestMakePersistentAssignsObjectId2(pm);
runTestMakePersistentAssignsObjectId3(pm);
pm.close();
pm = null;
}
/** */
private void createObjects() {
p1 = new PCPoint(1,3);
p2 = new PCPoint(2,4);
p3 = new PCPoint(3,5);
p4 = new PCPoint(4,6);
p5 = new PCPoint(5,7);
}
/* test makePersistent (Object pc) */
private void runTestMakePersistentAssignsObjectId1(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
pm.makePersistent(p1);
if (!testState(p1, PERSISTENT_NEW, "persistent_new")) {
fail(ASSERTION_FAILED,
"expected P-NEW instance, instance is " + getStateOfInstance(p1) + ".");
}
if (pm.getObjectId(p1) == null) {
fail(ASSERTION_FAILED,
"pm.makePersistent should assign non-null oid.");
}
tx.commit();
tx = null;
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
/* test makePersistentAll (Collection pcs) */
private void runTestMakePersistentAssignsObjectId2(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
Collection col1 = new HashSet();
col1.add(p2);
col1.add(p3);
pm.makePersistentAll(col1);
for (Iterator i = col1.iterator(); i.hasNext();) {
PCPoint p = (PCPoint)i.next();
if (!testState(p, PERSISTENT_NEW, "persistent_new")) {
fail(ASSERTION_FAILED,
"expected P-NEW instance, instance is " + getStateOfInstance(p) + ".");
}
if (pm.getObjectId(p) == null) {
fail(ASSERTION_FAILED,
"pm.makePersistentAll should assign non-null oid.");
}
}
tx.commit();
tx = null;
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
/* test makePersistentAll (Object[] o) */
private void runTestMakePersistentAssignsObjectId3(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
int NUM_OBJS = 2;
tx.begin();
Collection col1 = new HashSet();
col1.add(p4);
col1.add(p5);
Object[] obj1= col1.toArray();
pm.makePersistentAll(obj1);
for (int i = 0; i < NUM_OBJS; i++) {
PCPoint p = (PCPoint)obj1[i];
if (!testState(p, PERSISTENT_NEW, "persistent_new")) {
fail(ASSERTION_FAILED,
"expected P-NEW instance, instance is " + getStateOfInstance(p) + ".");
}
if (pm.getObjectId(p) == null) {
fail(ASSERTION_FAILED,
"pm.makePersistentAll should assign non-null oid.");
}
}
tx.commit();
tx = null;
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
}
././@LongLink 100644 0 0 206 12500111677 10251 L ustar 0 0 tck/src/java/org/apache/jdo/tck/api/persistencemanager/lifecycle/MakePersistentFailsIfInstanceManagedByAnotherPersistenceManager.java tck/src/java/org/apache/jdo/tck/api/persistencemanager/lifecycle/MakePersistentFailsIfInstanceManage100664 13550 12500110374 34256 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.lifecycle;
import java.util.Collection;
import javax.jdo.JDOUserException;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
import org.apache.jdo.tck.api.persistencemanager.PersistenceManagerTest;
/**
*Title: MakePersistent Fails If Instance Managed By Another PersistenceManager
*Keywords: exception
*Assertion IDs: A12.5.7-8.
*Assertion Description:
PersistenceManager.makePersistent and makePersistentAll will throw a JDOUserException if the parameter instance is managed by a different PersistenceManager.
*/
public class MakePersistentFailsIfInstanceManagedByAnotherPersistenceManager extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.5.7-8 (MakePersistentFailsIfInstanceManagedByAnotherPersistenceManager) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(MakePersistentFailsIfInstanceManagedByAnotherPersistenceManager.class);
}
private PCPoint p1 = null;
private PCPoint p2 = null;
private PCPoint p3 = null;
private PCPoint p4 = null;
private PCPoint p5 = null;
/** */
public void testMakePersistentFailsIfInstanceManagedByAnotherPersistenceManager() {
pm = getPM();
PersistenceManager pm2 = getPMF().getPersistenceManager();
try {
createObjects(pm2);
/* positive tests */
runTestMakePersistent(pm);
runTestMakePersistentAll1(pm);
runTestMakePersistentAll2(pm);
}
finally {
cleanupPM(pm2);
pm2 = null;
cleanupPM(pm);
pm = null;
}
}
/** */
private void createObjects(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
p1 = new PCPoint(1,3);
p2 = new PCPoint(2,4);
p3 = new PCPoint(3,5);
p4 = new PCPoint(4,6);
p5 = new PCPoint(5,7);
pm.makePersistent(p1);
pm.makePersistent(p2);
pm.makePersistent(p3);
pm.makePersistent(p4);
pm.makePersistent(p5);
tx.commit();
tx = null;
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
/* test makePersistent (Object pc) */
private void runTestMakePersistent(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
try {
pm.makePersistent(p1);
fail(ASSERTION_FAILED,
"pm.makePersistent should throw JDOUserException if instance is already made persistence by different pm.");
}
catch (JDOUserException ex) {
// expected exception
}
tx.rollback();
tx = null;
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
/* test makePersistentAll (Collection pcs) */
private void runTestMakePersistentAll1(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
Collection col1 = new java.util.HashSet();
col1.add(p2);
col1.add(p3);
try {
pm.makePersistentAll(col1);
fail(ASSERTION_FAILED,
"pm.makePersistentAll(Collection) should throw JDOUserException if instance is already made persistence by different pm.");
}
catch (JDOUserException ex) {
// expected exception
}
tx.rollback();
tx = null;
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
/* test makePersistentAll (Object[] o) */
private void runTestMakePersistentAll2(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
Collection col1 = new java.util.HashSet();
col1.add(p4);
col1.add(p5);
Object[] obj1= col1.toArray();
try {
pm.makePersistentAll(obj1);
fail(ASSERTION_FAILED,
"pm.makePersistentAll(Object[]) should throw JDOUserException if instance is already made persistence by different pm.");
}
catch (JDOUserException ex) {
// expected exception
}
tx.rollback();
tx = null;
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
}
././@LongLink 100644 0 0 165 12500111677 10255 L ustar 0 0 tck/src/java/org/apache/jdo/tck/api/persistencemanager/lifecycle/MakePersistentHasNoEffectOnPersistentInstances.java tck/src/java/org/apache/jdo/tck/api/persistencemanager/lifecycle/MakePersistentHasNoEffectOnPersiste100664 12027 12500110374 34302 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.lifecycle;
import java.util.Collection;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
import org.apache.jdo.tck.api.persistencemanager.PersistenceManagerTest;
/**
*Title: MakePersistent Has No Effect On Persistent Instances
*Keywords:
*Assertion IDs: A12.5.7-7.
*Assertion Description:
PersistenceManager.makePersistent and makePersistentAll have no effect on
*parameter persistent instances already managed by the same PersistenceManager.
*/
public class MakePersistentHasNoEffectOnPersistentInstances
extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.5.7-7 (MakePersistentHasNoEffectOnPersistentInstances) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(MakePersistentHasNoEffectOnPersistentInstances.class);
}
private PCPoint p1 = null;
private PCPoint p2 = null;
private PCPoint p3 = null;
private PCPoint p4 = null;
private PCPoint p5 = null;
/** */
public void testMakePersistentHasNoEffectOnPersistentInstances() {
pm = getPM();
createObjects(pm);
runTestMakePersistent(pm);
runTestMakePersistentAll1(pm);
runTestMakePersistentAll2(pm);
pm.close();
pm = null;
}
/** */
private void createObjects(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
p1 = new PCPoint(1,3);
p2 = new PCPoint(2,4);
p3 = new PCPoint(3,5);
p4 = new PCPoint(4,6);
p5 = new PCPoint(5,7);
tx.commit();
tx = null;
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
/* test makePersistent (Object pc) */
private void runTestMakePersistent(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
tx = pm.currentTransaction();
tx.begin();
pm.makePersistent(p1);
pm.makePersistent(p1);
pm.makePersistent(p1);
pm.makePersistent(p1);
tx.commit();
tx = null;
if (debug) logger.debug (" \nPASSED in runTestMakePersistent()");
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
/* test makePersistentAll (Collection pcs) */
private void runTestMakePersistentAll1(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
Collection col1 = new java.util.HashSet();
col1.add(p2);
col1.add(p3);
pm.makePersistentAll(col1);
pm.makePersistentAll(col1);
pm.makePersistentAll(col1);
pm.makePersistentAll(col1);
tx.commit();
tx = null;
if (debug) logger.debug (" \nPASSED in runTestMakePersistentAll1()");
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
/* test makePersistentAll (Object[] o) */
private void runTestMakePersistentAll2(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
Collection col1 = new java.util.HashSet();
col1.add(p1);
col1.add(p2);
Object[] obj1= col1.toArray();
pm.makePersistentAll(obj1);
pm.makePersistentAll(obj1);
pm.makePersistentAll(obj1);
pm.makePersistentAll(obj1);
tx.commit();
tx = null;
if (debug) logger.debug (" \nPASSED in runTestMakePersistentAll2()");
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanager/lifecycle/MakeTransactional.java 100664 11711 12500110374 31601 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.lifecycle;
import java.util.Collection;
import java.util.Iterator;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
import org.apache.jdo.tck.api.persistencemanager.PersistenceManagerTest;
/**
*Title: MakeTransactional
*Keywords: transienttransactional lifecycle
*Assertion IDs: A12.5.7-20
*Assertion Description:
PersistenceManager.makeTransactional and makeTransactionalAll makes a transient instance transactional and causes a state transition to transient-clean. After the method completes, the instance observes transaction boundaries.
*/
public class MakeTransactional extends PersistenceManagerTest{
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.5.7-20 (MakeTransactional) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(MakeTransactional.class);
}
private PCPoint p = null;
private PCPoint p1 = null;
private PCPoint p2 = null;
private PCPoint p3 = null;
private PCPoint p4 = null;
/** */
public void testTransactionalInst() {
pm = getPM();
createObjects();
testMakeTransactional(pm);
testMakeTransactionalAll1(pm);
testMakeTransactionalAll2(pm);
pm.close();
pm = null;
}
/** */
private void createObjects() {
p1 = new PCPoint(1,3);
p2 = new PCPoint(2,4);
p3 = new PCPoint(3,5);
p4 = new PCPoint(4,6);
}
/** */
public void testMakeTransactional(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
pm.makeTransactional(p1);
if (currentState(p1) != TRANSIENT_CLEAN) {
fail(ASSERTION_FAILED,
"Expected T-CLEAN instance, instance is " +
getStateOfInstance(p1) + ".");
}
tx.commit();
tx = null;
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
/** */
public void testMakeTransactionalAll1(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
Collection col1 = new java.util.HashSet();
col1.add(p1);
col1.add(p2);
col1.add(p3);
col1.add(p4);
pm.makeTransactionalAll(col1);
Iterator iter = col1.iterator();
while (iter.hasNext() ) {
PCPoint p = (PCPoint) iter.next();
if (currentState(p) != TRANSIENT_CLEAN) {
fail(ASSERTION_FAILED,
"Expected T-CLEAN instance, instance " + p + " is " +
getStateOfInstance(p1) + ".");
}
}
tx.commit();
tx = null;
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
/** */
private void testMakeTransactionalAll2(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
Object[] objArray = {p1,p2,p3,p4};
pm.makeTransactionalAll(objArray);
for ( int i=0; i < objArray.length; i++) {
p = (PCPoint) objArray[i];
if (currentState(p) != TRANSIENT_CLEAN) {
fail(ASSERTION_FAILED,
"Expected T-CLEAN instance, instance " + p + " is " +
getStateOfInstance(p1) + ".");
}
}
tx.commit();
tx = null;
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanager/lifecycle/MakeTransactionalAllFails.java 100664 10763 12500110374 33217 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.lifecycle;
import java.util.Collection;
import javax.jdo.JDOUserException;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.pc.mylib.Point;
import org.apache.jdo.tck.util.BatchTestRunner;
import org.apache.jdo.tck.api.persistencemanager.PersistenceManagerTest;
/**
*Title: MakeTransactionalAllFails
*Keywords: exception
*Assertion ID: A12.5.7-4
*Assertion Description:
If a collection or array of instances is passed to
*PersistenceManager.makeTransactionalAll, and one or more of the instances
*fail to complete the required o peration, then all instances will be
*attempted, and a JDOUserException will be thrown which contains a nested
*exception array, each exception of which conta ins one of the failing
*instances. The succeeding instances will transition to the specified life
*cycle state, and the failing instances will remain in their current state.
*/
public class MakeTransactionalAllFails extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.5.7-4 (MakeTransactionalAllFails) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(MakeTransactionalAllFails.class);
}
private PCPoint p1 = null;
private Point p2 = null;
private Collection col1 = new java.util.HashSet();
/** */
public void testTransactionalInst() {
pm = getPM();
createObjects();
runTestMakeTransactionalAll1(pm);
runTestMakeTransactionalAll2(pm);
pm.close();
pm = null;
}
/** */
private void createObjects() {
p1 = new PCPoint(1,3);
p2 = new Point(2,4);
col1 = new java.util.HashSet();
col1.add(p1);
col1.add(p2);
}
/* test makeTransactional (Collection pcs) */
private void runTestMakeTransactionalAll1(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
if (debug) logger.debug(" in runTestMakeTransactionalAll2() ");
try {
tx.begin();
col1.add(p1);
col1.add(p2);
try {
pm.makeTransactionalAll(col1);
fail(ASSERTION_FAILED,
"pm.makeTransactionalAll(Collection) should throw JDOUserException when called for collection icnluding instance of non-pc class");
}
catch (JDOUserException ex) {
// expected exception
}
tx.rollback();
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
/* test makeTransactionalAll (Object[] pcs) */
private void runTestMakeTransactionalAll2(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
if (debug) logger.debug(" in runTestMakeTransactionalAll2() ");
try {
tx.begin();
try {
pm.makeTransactionalAll(col1.toArray());
fail(ASSERTION_FAILED,
"pm.makeTransactionalAll(Object[]) should throw JDOUserException when called for collection icnluding instance of non-pc class");
}
catch (JDOUserException ex) {
// expected exception
}
tx.rollback();
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
}
././@LongLink 100644 0 0 173 12500111677 10254 L ustar 0 0 tck/src/java/org/apache/jdo/tck/api/persistencemanager/lifecycle/MakeTransactionalANontransactionalPersistentInstance.java tck/src/java/org/apache/jdo/tck/api/persistencemanager/lifecycle/MakeTransactionalANontransactionalP100664 23254 12500110374 34345 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.lifecycle;
import java.util.Collection;
import javax.jdo.JDOUserException;
import javax.jdo.Transaction;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
import org.apache.jdo.tck.api.persistencemanager.PersistenceManagerTest;
/**
*Title: Make Transactional A Persistent Nontransactional Instance
*Keywords: persistentnontransactional
*Assertion IDs: A12.5.7-24
*Assertion Description:
PersistenceManager.makeTransactional and makeTransactionalAll can be used to mark a nontransactional persistent instance as being part of the read-consistency set of the transaction. In this case, the call must be made in the context of an active transaction, or a JDOUserException is thrown. To test this, get an instance in the persistence-nontransactional state, make it transactional, then in a
different transaction commit a change to the instance. An exception should then be thrown when the first transaction commits.
*/
public class MakeTransactionalANontransactionalPersistentInstance extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.5.7-24 (MakeTransactionalANontransactionalPersistentInstance) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(MakeTransactionalANontransactionalPersistentInstance.class);
}
private PCPoint p1 = null;
private PCPoint p2 = null;
private PCPoint p3 = null;
private PCPoint p4 = null;
private PCPoint p5 = null;
private PCPoint p6 = null;
private PCPoint p7 = null;
private Collection col1 = new java.util.HashSet();
private Collection col2 = new java.util.HashSet();
/** */
public void testTransactionalInstance() {
if (isOptimisticSupported()) {
pm = getPM();
createPNonTranObjects();
/* Positive cases */
runTestMakeTransactional();
runTestMakeTransactionalAll1();
runTestMakeTransactionalAll2();
/* Negative cases */
runTestMakeTransactionalNeg();
runTestMakeTransactionalAll1Neg();
runTestMakeTransactionalAll2Neg();
pm.close();
pm = null;
}
}
/** */
private void createPNonTranObjects() {
Transaction tx = pm.currentTransaction();
try {
tx.setOptimistic(false);
tx.begin();
p1 = new PCPoint(1,3);
p2 = new PCPoint(2,4);
p3 = new PCPoint(3,5);
p4 = new PCPoint(4,6);
p5 = new PCPoint (5,7);
p6 = new PCPoint (6,8);
p7 = new PCPoint (7,9);
col1.add(p2);
col1.add(p3);
col1.add(p4);
col2.add(p5);
col2.add(p6);
col2.add(p7);
pm.makePersistent(p1);
pm.makePersistent(p2);
pm.makePersistent(p3);
pm.makePersistent(p4);
pm.makePersistent(p5);
pm.makePersistent(p6);
pm.makePersistent(p7);
tx.commit();
tx = null;
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
/** */
public void runTestMakeTransactional() {
Transaction tx = pm.currentTransaction();
try {
if (debug) logger.debug(" ** in runTestMakeTransactional()");
int curr;
tx.setOptimistic(true);
tx.begin();
if (makePersistentNonTranInstance(p1)) {
pm.makeTransactional(p1);
}
tx.commit();
tx = null;
if (debug) logger.debug(" \nPASSED in runTestMakeTransactional()");
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
/** */
public void runTestMakeTransactionalNeg() {
Transaction tx = pm.currentTransaction();
try {
if (debug) logger.debug(" ** in runTestMakeTransactionalNeg()");
int curr;
tx.setOptimistic(true);
tx.begin();
if (makePersistentNonTranInstance(p1)) {
; // expected result
}
tx.commit();
tx = null;
try {
pm.makeTransactional(p1);
fail(ASSERTION_FAILED,
"pm.makeTransactional should throw JDOUserException outside of tx");
}
catch (JDOUserException ex) {
// expected exception
}
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
/** */
public void runTestMakeTransactionalAll1() {
Transaction tx = pm.currentTransaction();
try {
if (debug) logger.debug(" ** in runTestMakeTransactionalAll1()");
int curr;
tx.setOptimistic(true);
tx.begin();
if ( makePersistentNonTranInstance(p2) &&
makePersistentNonTranInstance(p3) &&
makePersistentNonTranInstance(p4)) {
pm.makeTransactionalAll(col1);
}
tx.commit();
tx = null;
if (debug)
logger.debug(" \nPASSED in runTestMakeTransactionalAll1()");
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
/** */
public void runTestMakeTransactionalAll1Neg() {
Transaction tx = pm.currentTransaction();
try {
if (debug) logger.debug(" ** in runTestMakeTransactionalAll1Neg()");
int curr;
tx.setOptimistic(true);
tx.begin();
if ( makePersistentNonTranInstance(p2) &&
makePersistentNonTranInstance(p3) &&
makePersistentNonTranInstance(p4)) {
; // expected result
}
tx.commit();
try {
pm.makeTransactionalAll(col1);
fail(ASSERTION_FAILED,
"pm.makeTransactionalAll(Collection) should throw JDOUserException outside of tx");
}
catch (JDOUserException ex) {
// expected exception
}
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
/** */
public void runTestMakeTransactionalAll2() {
Transaction tx = pm.currentTransaction();
try {
if (debug) logger.debug(" ** in runTestMakeTransactionalAll2()");
int curr;
tx.setOptimistic(true);
tx.begin();
Object[] objArray = col2.toArray();
if ( makePersistentNonTranInstance(p5) &&
makePersistentNonTranInstance(p6) &&
makePersistentNonTranInstance(p7)) {
pm.makeTransactionalAll(objArray);
}
tx.commit();
tx = null;
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
/** */
public void runTestMakeTransactionalAll2Neg() {
Transaction tx = pm.currentTransaction();
try {
if (debug) logger.debug(" ** in runTestMakeTransactionalAll2Neg()");
int curr;
tx = pm.currentTransaction();
tx.setOptimistic(true);
tx.begin();
Object[] objArray = col2.toArray();
if ( makePersistentNonTranInstance(p5) &&
makePersistentNonTranInstance(p6) &&
makePersistentNonTranInstance(p7)) {
; // expected result
}
tx.commit();
try {
pm.makeTransactionalAll(objArray);
fail(ASSERTION_FAILED,
"pm.makeTransactionalAll(Object[]) should throw JDOUserException outside of tx");
}
catch (JDOUserException ex) {
// expected exception
}
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
/** */
public boolean makePersistentNonTranInstance (PCPoint obj) {
int val = obj.getX();
int curr = currentState(obj);
if ( curr != PERSISTENT_NONTRANSACTIONAL &&
curr != HOLLOW) {
fail(ASSERTION_FAILED,
"expected P-HOLLOW or P-NONTX instance, instance " + obj +
" is " + getStateOfInstance(obj) + ".");
return false;
}
return true;
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanager/lifecycle/MakeTransactionalIsImmediate.java 100664 13510 12500110374 33713 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.lifecycle;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
import org.apache.jdo.tck.api.persistencemanager.PersistenceManagerTest;
/**
*Title: Make Nontransactional is immediate
*Keywords:
*Assertion IDs: A12.5.7-25
*Assertion Description:
The effect of PersistenceManager.makeTransactional or
makeTransactionalAll is immediate and not subject to rollback.
*/
public class MakeTransactionalIsImmediate extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.5.7-25 (MakeTransactionalIsImmediate) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(MakeTransactionalIsImmediate.class);
}
private PCPoint p1 = null;
private PCPoint p2 = null;
private PCPoint p3 = null;
private PCPoint p4 = null;
private PCPoint p5 = null;
private PCPoint p6 = null;
private PCPoint p7 = null;
private Collection col1 = new HashSet();
private Collection col2 = new HashSet();
/** */
public void testTransactionalInst() {
pm = getPM();
createTcleanObjects(pm);
runTestMakeTransactionalIsImmediate(pm);
runTestMakeTransactionalIsImmediateAll1(pm);
runTestMakeTransactionalIsImmediateAll2(pm);
pm.close();
pm = null;
}
/** */
private void createTcleanObjects(PersistenceManager pm) {
p1 = new PCPoint(1,3);
p2 = new PCPoint(2,4);
p3 = new PCPoint(3,5);
p4 = new PCPoint(4,6);
p5 = new PCPoint (5,7);
p6 = new PCPoint (6,8);
p7 = new PCPoint (7,9);
col1.add(p2);
col1.add(p3);
col1.add(p4);
col2.add(p5);
col2.add(p6);
col2.add(p7);
pm.makeTransactional(p1);
pm.makeTransactional(p2);
pm.makeTransactional(p3);
pm.makeTransactional(p4);
pm.makeTransactional(p5);
pm.makeTransactional(p6);
pm.makeTransactional(p7);
}
/** */
private void runTestMakeTransactionalIsImmediate(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
if (debug)
logger.debug(" ** in runTestMakeTransactionalIsImmediate()");
tx.begin();
pm.makeTransactional(p1);
tx.rollback();
if (!testState (p1, TRANSIENT_CLEAN, "transient_clean")) {
fail(ASSERTION_FAILED,
"expected T-CLEAN instance, instance " + p1 +
" is " + getStateOfInstance(p1));
}
tx = null;
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
/** */
private void runTestMakeTransactionalIsImmediateAll1(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
if (debug)
logger.debug(" ** in runTestMakeTransactionalIsImmediateAll1()");
tx = pm.currentTransaction();
tx.begin();
pm.makeTransactionalAll(col1);
tx.rollback();
for (Iterator iter = col1.iterator(); iter.hasNext();) {
PCPoint p = (PCPoint) iter.next();
if (!testState(p, TRANSIENT_CLEAN, "transient_clean")) {
fail(ASSERTION_FAILED,
"expected T-CLEAN instance, instance " + p1 +
" is " + getStateOfInstance(p));
}
}
tx = null;
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
/** */
private void runTestMakeTransactionalIsImmediateAll2(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
if (debug)
logger.debug(" ** in runTestMakeTransactionalIsImmediateAll2()");
tx.begin();
Object[] objArray = col2.toArray();
pm.makeTransactionalAll(objArray);
tx.rollback();
for (int i=0; i < objArray.length; i++) {
PCPoint p = (PCPoint) objArray[i];
if (!testState(p, TRANSIENT_CLEAN, "transient_clean")) {
fail(ASSERTION_FAILED,
"expected T-CLEAN instance, instance " + p1 +
" is " + getStateOfInstance(p));
}
}
tx = null;
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
}
././@LongLink 100644 0 0 164 12500111677 10254 L ustar 0 0 tck/src/java/org/apache/jdo/tck/api/persistencemanager/lifecycle/MakeTransactionalPriorToTransactionRolledback.java tck/src/java/org/apache/jdo/tck/api/persistencemanager/lifecycle/MakeTransactionalPriorToTransaction100664 15634 12500110374 34416 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.lifecycle;
import java.util.Collection;
import java.util.HashSet;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
import org.apache.jdo.tck.api.persistencemanager.PersistenceManagerTest;
/**
*Title: MakeTransactional Prior To a Transaction Rolledback
*Keywords:
*Assertion IDs: A12.5.7-23
*Assertion Description:
If the transaction in which an instance is made transactional (by
calling PersistenceManager.makeTransactional or makeTransactionalAll) is
rolled back, then the transient instance takes its values as of the beginning of the
transaction, if the call to makeTransactional was made prior to the beginning of the
current transaction.
*/
public class MakeTransactionalPriorToTransactionRolledback extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.5.7-23 (MakeTransactionalPriorToTransactionRolledback) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(MakeTransactionalPriorToTransactionRolledback.class);
}
private PCPoint p1 = null;
private PCPoint p2 = null;
private PCPoint p3 = null;
private PCPoint p4 = null;
private PCPoint p5 = null;
private PCPoint p6 = null;
private PCPoint p7 = null;
private Collection col1 = new HashSet();
private Collection col2 = new HashSet();
/** */
public void testTransactionalInst() {
pm = getPM();
pm.currentTransaction().setRestoreValues(true);
createObjects();
runTestMakeTransactionalPriorToTransactionRolledback(pm);
runTestMakeTransactionalPriorToTransactionRolledbackAll1(pm);
runTestMakeTransactionalPriorToTransactionRolledbackAll2(pm);
pm.close();
pm = null;
}
/** */
private void createObjects() {
p1 = new PCPoint(1,3);
p2 = new PCPoint(2,4);
p3 = new PCPoint(3,5);
p4 = new PCPoint(4,6);
p5 = new PCPoint(5,7);
col1.add(p2);
col1.add(p3);
col2.add(p4);
col2.add(p5);
}
public void runTestMakeTransactionalPriorToTransactionRolledback(
PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
if (debug)
logger.debug(" ** in runTestMakeTransactionalPriorToTransactionRolledback()");
p1.setY(new Integer(50));
tx.begin();
p1.setY(new Integer(100));
pm.makeTransactional(p1);
p1.setY(new Integer(200));
tx.rollback();
p1.setY(new Integer(300));
tx.begin();
p1.setY(new Integer(400));
tx.rollback();
if (p1.getY().intValue() != 300) {
fail(ASSERTION_FAILED,
"wrong value of p1.y, expected: 300, actual: " +
p1.getY().intValue());
}
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
/** */
private void runTestMakeTransactionalPriorToTransactionRolledbackAll1(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
if (debug)
logger.debug(" ** in runTestMakeTransactionalPriorToTransactionRolledbackAll1()");
p2.setY(new Integer(50));
p3.setY(new Integer(50));
tx.begin();
p2.setY(new Integer(100));
p3.setY(new Integer(100));
pm.makeTransactionalAll(col1);
p2.setY(new Integer(200));
p3.setY(new Integer(200));
tx.rollback();
p2.setY(new Integer(300));
p3.setY(new Integer(300));
tx.begin();
p2.setY(new Integer(400));
p3.setY(new Integer(400));
tx.rollback();
if (p2.getY().intValue() != 300) {
fail(ASSERTION_FAILED,
"wrong value of p2.y, expected: 300, actual: " +
p2.getY().intValue());
}
if (p3.getY().intValue() != 300) {
fail(ASSERTION_FAILED,
"wrong value of p3.y, expected: 300, actual: " +
p3.getY().intValue());
}
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
/** */
public void runTestMakeTransactionalPriorToTransactionRolledbackAll2(
PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
if (debug)
logger.debug (" ** in runTestMakeTransactionalPriorToTransactionRolledbackAll2()");
p2.setY(new Integer(50));
p3.setY(new Integer(50));
tx.begin();
p2.setY(new Integer(100));
p3.setY(new Integer(100));
Object[] objArray = col2.toArray();
pm.makeTransactionalAll(objArray);
p2.setY(new Integer(200));
p3.setY(new Integer(200));
tx.rollback();
p2.setY(new Integer(300));
p3.setY(new Integer(300));
tx.begin();
p2.setY(new Integer(400));
p3.setY(new Integer(400));
tx.rollback();
if (p2.getY().intValue() != 300) {
fail(ASSERTION_FAILED,
"wrong value of p2.y, expected: 300, actual: " +
p2.getY().intValue());
}
if (p3.getY().intValue() != 300) {
fail(ASSERTION_FAILED,
"wrong value of p3.y, expected: 300, actual: " +
p3.getY().intValue());
}
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
}
././@LongLink 100644 0 0 163 12500111677 10253 L ustar 0 0 tck/src/java/org/apache/jdo/tck/api/persistencemanager/lifecycle/MakeTransactionalWithinTransactionRolledback.java tck/src/java/org/apache/jdo/tck/api/persistencemanager/lifecycle/MakeTransactionalWithinTransactionR100664 14414 12500110374 34377 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.lifecycle;
import java.util.Collection;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
import org.apache.jdo.tck.api.persistencemanager.PersistenceManagerTest;
/**
*Title: MakeTransactionalWithinTransactionRolledback
*Keywords: transienttransactional
*Assertion IDs: A12.5.7-22
*Assertion Description:
If the transaction in which an instance is made transactional (by
calling PersistenceManager.makeTransactional or makeTransactionalAll) is
rolled back, then the transient instance takes its values as of the call to
makeTransactional if the call was made within the current transaction.
*/
public class MakeTransactionalWithinTransactionRolledback extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.5.7-22 (MakeTransactionalWithinTransactionRolledback) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(MakeTransactionalWithinTransactionRolledback.class);
}
private PCPoint p1 = null;
private PCPoint p2 = null;
private PCPoint p3 = null;
private PCPoint p4 = null;
private PCPoint p5 = null;
private PCPoint p6 = null;
private PCPoint p7 = null;
private Collection col1 = new java.util.HashSet();
private Collection col2 = new java.util.HashSet();
/** */
public void testTransactionalInst() {
pm = getPM();
pm.currentTransaction().setRestoreValues(true);
createObjects();
runTestMakeTransactionalWithinTransactionRolledback(pm);
runTestMakeTransactionalWithinTransactionRolledbackAll1(pm);
runTestMakeTransactionalWithinTransactionRolledbackAll2(pm);
pm.close();
pm = null;
}
/** */
private void createObjects() {
p1 = new PCPoint(1,3);
p2 = new PCPoint(2,4);
p3 = new PCPoint(3,5);
p4 = new PCPoint(4,6);
p5 = new PCPoint (5,7);
col1.add(p2);
col1.add(p3);
col2.add(p4);
col2.add(p5);
}
/** */
public void runTestMakeTransactionalWithinTransactionRolledback(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
if (debug)
logger.debug(" ** in runTestMakeTransactionalWithinTransactionRolledback()");
p1.setY(new Integer(100));
tx.begin();
p1.setY(new Integer(200));
pm.makeTransactional(p1);
p1.setY(new Integer(300));
tx.rollback();
if (p1.getY().intValue() != 200) {
fail(ASSERTION_FAILED,
"wrong value of p1.y, expected: 200, actual: " + p1.getY().intValue());
}
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
/** */
private void runTestMakeTransactionalWithinTransactionRolledbackAll1(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
if (debug)
logger.debug(" ** in runTestMakeTransactionalWithinTransactionRolledbackAll1()");
p2.setY(new Integer(100));
p3.setY(new Integer(100));
tx.begin();
p2.setY(new Integer(200));
p3.setY(new Integer(200));
pm.makeTransactionalAll(col1);
p2.setY(new Integer(300));
p3.setY(new Integer(300));
tx.rollback();
if (p2.getY().intValue() != 200) {
fail(ASSERTION_FAILED,
"wrong value of p2.y expected: 200, actual: " + p2.getY().intValue());
}
if (p3.getY().intValue() != 200) {
fail(ASSERTION_FAILED,
"wrong value of p3.y, expected: 200, actual: " + p3.getY().intValue());
}
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
/** */
private void runTestMakeTransactionalWithinTransactionRolledbackAll2(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
if (debug)
logger.debug(" ** in runTestMakeTransactionalWithinTransactionRolledbackAll2()");
p4.setY(new Integer(100));
p5.setY(new Integer(100));
tx.begin();
p4.setY(new Integer(200));
p5.setY(new Integer(200));
Object[] objArray = col2.toArray();
pm.makeTransactionalAll(objArray);
p4.setY(new Integer(300));
p5.setY(new Integer(300));
tx.rollback();
if (p4.getY().intValue() != 200) {
fail(ASSERTION_FAILED,
"wrong value of p4, expected: 200, actual: " + p4.getY().intValue());
}
if (p5.getY().intValue() != 200) {
fail(ASSERTION_FAILED,
"wrong value of p5.y, expected: 200, actual: " + p5.getY().intValue());
}
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanager/lifecycle/MakeTransient.java 100664 12652 12500110374 30753 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.lifecycle;
import java.util.Collection;
import java.util.Iterator;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
import org.apache.jdo.tck.api.persistencemanager.PersistenceManagerTest;
/**
*Title: MakeTransient
*Keywords: transient
*Assertion IDs: A12.5.7-13
*Assertion Description:
PersistenceManager.makeTransient and makeTransientAll make a persistent instance transient, so it is not associated with the PersistenceManager instance. It does not affect the persistent state in the data store.
*/
public class MakeTransient extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.5.7-13 (MakeTransient) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(MakeTransient.class);
}
private PCPoint p1 = null;
private PCPoint p2 = null;
private PCPoint p3 = null;
private PCPoint p4 = null;
private PCPoint p5 = null;
/** */
public void testMakeTransient() {
pm = getPM();
createPersistentObjects(pm);
runTestMakeTransient1(pm);
runTestMakeTransientAll1(pm);
runTestMakeTransientAll2(pm);
pm.close();
pm = null;
}
/** */
private void createPersistentObjects(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
p1 = new PCPoint(1,3);
p2 = new PCPoint(2,4);
p3 = new PCPoint(3,5);
p4 = new PCPoint(4,6);
p5 = new PCPoint(5,7);
pm.makePersistent(p1);
pm.makePersistent(p2);
pm.makePersistent(p3);
pm.makePersistent(p4);
pm.makePersistent(p5);
tx.commit();
tx = null;
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
/* test makeTransient (Object pc) */
private void runTestMakeTransient1(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
pm.makeTransient(p1);
tx.commit();
tx = null;
if (!testState(p1, TRANSIENT, "transient")) {
fail("expected TRANSIENT instance, instance " + p1 +
" is " + getStateOfInstance(p1));
}
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
/* test makeTransientAll (Collection pcs) */
private void runTestMakeTransientAll1(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
Collection col1 = new java.util.HashSet();
col1.add(p2);
col1.add(p3);
pm.makeTransientAll(col1);
tx.commit();
tx = null;
for (Iterator iter = col1.iterator(); iter.hasNext();) {
PCPoint p = (PCPoint) iter.next();
if (!testState(p, TRANSIENT, "transient")) {
fail("expected TRANSIENT instance, instance " + p1 +
" is " + getStateOfInstance(p));
}
}
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
/* test makeTransientAll (Object[] o) */
private void runTestMakeTransientAll2(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
int NUM_OBJS = 2;
tx.begin();
Collection col1 = new java.util.HashSet();
col1.add(p4);
col1.add(p5);
Object[] obj1= col1.toArray();
pm.makeTransientAll(obj1);
tx.commit();
tx = null;
for (int i=0; i < NUM_OBJS; ++i ) {
PCPoint p = (PCPoint) obj1[i];
if (!testState(p, TRANSIENT, "transient")) {
fail("expected TRANSIENT instance, instance " + p1 +
" is " + getStateOfInstance(p));
}
}
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanager/lifecycle/MakeTransientAllFails.java 100664 11054 12500110374 32356 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.lifecycle;
import java.util.Collection;
import java.util.HashSet;
import javax.jdo.JDOUserException;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.pc.mylib.Point;
import org.apache.jdo.tck.util.BatchTestRunner;
import org.apache.jdo.tck.api.persistencemanager.PersistenceManagerTest;
/**
*Title: MakeTransientAll Fail
*Keywords: exception
*Assertion IDs: A12.5.7-3
*Assertion Description:
If a collection or array of instances is passed to PersistenceManager.makeTransientAll, and one or more of the instances fail to complete the required operation, then all instances will be attempted, and a JDOUserException will be thrown which contains a nested exception array, each exception of which contains one of the failing instances. The succeeding instances will transition to the specified life cycle state, and the failing instances will remain in their current state.
*/
public class MakeTransientAllFails extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.5.7-3 (MakeTransientAllFails) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(MakeTransientAllFails.class);
}
/** */
public void testMakeTransientAllFails() {
pm = getPM();
runTestMakeTransientAllFails1(pm);
runTestMakeTransientAllFails2(pm);
pm.close();
pm = null;
}
/* test makeTansientAll (Collection pcs) */
private void runTestMakeTransientAllFails1(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
PCPoint np1 = new PCPoint (3,3);
PCPoint np2 = new PCPoint (4,4);
Point np3 = new Point (5,5);
Collection col1 = new HashSet();
col1.add(np1);
col1.add(np2);
col1.add(np3);
try {
pm.makeTransientAll(col1);
fail(ASSERTION_FAILED,
"pm.makeTransientAll(Collection) should throw JDOUserException when called for a collection including an instance of a non-pc class");
}
catch (JDOUserException ex) {
// expected exception
}
tx.rollback();
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
/* test makeTransientAll (Object[] o) */
private void runTestMakeTransientAllFails2(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
PCPoint np1 = new PCPoint (3,3);
PCPoint np2 = new PCPoint (4,4);
Point np3 = new Point (5,5);
Collection col1 = new java.util.HashSet();
col1.add(np1);
col1.add(np2);
col1.add(np3);
Object[] obj1=col1.toArray();
try {
pm.makeTransientAll(obj1);
fail(ASSERTION_FAILED,
"pm.makeTransientAll(Object[]) should throw JDOUserException when called for an array including an instance of a non-pc class");
}
catch (JDOUserException ex) {
// expected exception
}
tx.rollback();
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
}
././@LongLink 100644 0 0 150 12500111677 10247 L ustar 0 0 tck/src/java/org/apache/jdo/tck/api/persistencemanager/lifecycle/MakeTransientCausesLossOfIdentity.java tck/src/java/org/apache/jdo/tck/api/persistencemanager/lifecycle/MakeTransientCausesLossOfIdentity.j100664 13522 12500110374 34264 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.lifecycle;
import java.util.Collection;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
import org.apache.jdo.tck.api.persistencemanager.PersistenceManagerTest;
/**
*Title: MakeTransientCausesLossOfIdentity
*Keywords: transient identity
*Assertion IDs: A12.5.7-14
*Assertion Description:
PersistenceManager.makeTransient and makeTransientAll transition an instance to transient, causing it to lose its JDO identity.
*/
public class MakeTransientCausesLossOfIdentity extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.5.7-14 (MakeTransientCausesLossOfIdentity) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(MakeTransientCausesLossOfIdentity.class);
}
private PCPoint p1 = null;
private PCPoint p2 = null;
private PCPoint p3 = null;
private PCPoint p4 = null;
private PCPoint p5 = null;
/** */
public void testMakeTransientCausesLossOfIdentity() {
pm = getPM();
createPersistentObjects(pm);
runTestMakeTransientCausesLossOfIdentity1(pm);
runTestMakeTransientCausesLossOfIdentityAll1(pm);
runTestMakeTransientCausesLossOfIdentityAll2(pm);
pm.close();
pm = null;
}
/** */
private void createPersistentObjects(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
p1 = new PCPoint(1,3);
p2 = new PCPoint(2,4);
p3 = new PCPoint(3,5);
p4 = new PCPoint(4,6);
p5 = new PCPoint(5,7);
pm.makePersistent(p1);
pm.makePersistent(p2);
pm.makePersistent(p3);
pm.makePersistent(p4);
pm.makePersistent(p5);
tx.commit();
tx = null;
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
/* test makeTransient (Object pc) */
private void runTestMakeTransientCausesLossOfIdentity1(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
tx = pm.currentTransaction();
tx.begin();
pm.makeTransient(p1);
tx.commit();
Object oid = pm.getObjectId(p1);
if (oid != null) {
fail(ASSERTION_FAILED,
"pm.getObjectId(p1) returned non null ObjectId " + oid + " for transient instance");
}
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
/* test makeTransientAll (Collection pcs) */
private void runTestMakeTransientCausesLossOfIdentityAll1(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
tx = pm.currentTransaction();
tx.begin();
Collection col1 = new java.util.HashSet();
col1.add(p2);
col1.add(p3);
pm.makeTransientAll(col1);
tx.commit();
Object oid1 = pm.getObjectId(p2);
if (oid1 != null) {
fail(ASSERTION_FAILED,
"pm.getObjectId(p2) returned non null ObjectId " + oid1 + " for transient instance");
}
Object oid2 = pm.getObjectId(p3);
if (oid2 != null) {
fail(ASSERTION_FAILED,
"pm.getObjectId(p3) returned non null ObjectId " + oid2 + " for transient instance");
}
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
/* test makeTransientAll (Object[] o) */
private void runTestMakeTransientCausesLossOfIdentityAll2(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
tx = pm.currentTransaction();
tx.begin();
Collection col1 = new java.util.HashSet();
col1.add(p4);
col1.add(p5);
Object[] obj1= col1.toArray();
pm.makeTransientAll(obj1);
tx.commit();
Object oid1 = pm.getObjectId(p4);
if (oid1 != null) {
fail(ASSERTION_FAILED,
"pm.getObjectId(p4) returned non null ObjectId " + oid1 + " for transient instance");
}
Object oid2 = pm.getObjectId(p5);
if (oid2 != null) {
fail(ASSERTION_FAILED,
"pm.getObjectId(p5) returned non null ObjectId " + oid2 + " for transient instance");
}
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
}
././@LongLink 100644 0 0 152 12500111677 10251 L ustar 0 0 tck/src/java/org/apache/jdo/tck/api/persistencemanager/lifecycle/MakeTransientFailsWithDirtyInstance.java tck/src/java/org/apache/jdo/tck/api/persistencemanager/lifecycle/MakeTransientFailsWithDirtyInstance100664 13243 12500110374 34344 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.lifecycle;
import java.util.Collection;
import java.util.HashSet;
import javax.jdo.JDOUserException;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
import org.apache.jdo.tck.api.persistencemanager.PersistenceManagerTest;
/**
*Title: MakeTransientFailsWithDirtyInstance
*Keywords: exception
*Assertion IDs: A12.5.7-16
*Assertion Description:
If the instance passed to PersistenceManager.makeTransient or makeTransientAll is dirty, a JDOUserException is thrown.
*/
public class MakeTransientFailsWithDirtyInstance extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.5.7-16 (MakeTransientFailsWithDirtyInstance) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(MakeTransientFailsWithDirtyInstance.class);
}
private PCPoint p1 = null;
private PCPoint p2 = null;
private PCPoint p3 = null;
private PCPoint p4 = null;
private PCPoint p5 = null;
/** */
public void testMakeTransientFailsWithDirtyInstance() {
pm = getPM();
createObjects(pm);
runTestMakeTransient(pm);
runTestMakeTransientAll1(pm);
runTestMakeTransientAll2(pm);
pm.close();
pm = null;
}
/** */
private void createObjects(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
tx = pm.currentTransaction();
tx.begin();
p1 = new PCPoint(1,3);
p2 = new PCPoint(2,4);
p3 = new PCPoint(3,5);
p4 = new PCPoint(4,6);
p5 = new PCPoint(5,7);
pm.makePersistent(p1);
pm.makePersistent(p2);
pm.makePersistent(p3);
pm.makePersistent(p4);
pm.makePersistent(p5);
tx.commit();
tx = null;
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
/* test makeTansient (Object pc) */
private void runTestMakeTransient(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
// make instance dirty
p1.setX(100);
try {
pm.makeTransient(p1);
fail(ASSERTION_FAILED,
"pm.makeTransient should throw JDOUserException when called for P-DIRTY instance.");
}
catch (JDOUserException ex) {
// expected exception
}
tx.rollback();
tx = null;
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
/* test makeTansientAll (Collection pcs) */
private void runTestMakeTransientAll1(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
tx = pm.currentTransaction();
tx.begin();
Collection col1 = new HashSet();
col1.add(p2);
col1.add(p3);
p2.setX(200);
p3.setX(201);
try {
pm.makeTransientAll(col1);
fail(ASSERTION_FAILED,
"pm.makeTransientAll(Collection) should throw JDOUserException when called for a collection including P-DIRTY instances.");
}
catch (JDOUserException ex) {
// expected exception
}
tx.rollback();
tx = null;
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
/* test makeTransientAll (Object[] o) */
private void runTestMakeTransientAll2(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
Collection col1 = new HashSet();
col1.add(p4);
col1.add(p5);
p4.setX(300);
p5.setX(301);
Object[] obj1=col1.toArray();
try {
pm.makeTransientAll(obj1);
fail(ASSERTION_FAILED,
"pm.makeTransientAll(Object[]) should throw JDOUserException when called for an array including P-DIRTY instances.");
}
catch (JDOUserException ex) {
// expected exception
}
tx.rollback();
tx = null;
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
}
././@LongLink 100644 0 0 154 12500111677 10253 L ustar 0 0 tck/src/java/org/apache/jdo/tck/api/persistencemanager/lifecycle/MakeTransientFieldsPreservedUnchanged.java tck/src/java/org/apache/jdo/tck/api/persistencemanager/lifecycle/MakeTransientFieldsPreservedUnchang100664 17062 12500110374 34346 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.lifecycle;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
import org.apache.jdo.tck.api.persistencemanager.PersistenceManagerTest;
/**
*Title: MakeTransient Fields Preserved Unchanged
*Keywords: transient
*Assertion IDs: A12.5.7-15, A12.5.7-18
*Assertion Description:
If the instance passed to PersistenceManager.makeTransient or makeTransientAll has field values (persistent-nontransactional or persistent-clean), the fields in the cache are preserved unchanged. The instance(s) are not modified in any way.
*/
public class MakeTransientFieldsPreservedUnchanged extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.5.7-15, A12.5.7-18 (MakeTransientFieldsPreservedUnchanged) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(MakeTransientFieldsPreservedUnchanged.class);
}
private PCPoint p1 = null;
private PCPoint p2 = null;
private PCPoint p3 = null;
private PCPoint p4 = null;
private PCPoint p5 = null;
private PCPoint np1 = null;
private PCPoint np2 = null;
private PCPoint np3 = null;
private PCPoint np4 = null;
private PCPoint np5 = null;
/** */
public void testMakeTransientFieldsPreservedUnchanged() {
pm = getPM();
createObjects(pm);
runTestMakeTransientFieldsPreservedUnchanged1(pm);
runTestMakeTransientFieldsPreservedUnchangedAll1(pm);
runTestMakeTransientFieldsPreservedUnchangedAll2(pm);
pm.close();
pm = null;
}
/** */
private void createObjects(PersistenceManager pm) {
createPCleanObjects(pm);
createPNonTransactionalObjects(pm);
}
/** */
private void createPCleanObjects(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
// create P-clean instances
tx.setOptimistic(false);
tx.begin();
p1 = new PCPoint(1,3);
p2 = new PCPoint(2,4);
p3 = new PCPoint(3,5);
p4 = new PCPoint(4,6);
p5 = new PCPoint(5,7);
pm.makePersistent(p1);
pm.makePersistent(p2);
pm.makePersistent(p3);
pm.makePersistent(p4);
pm.makePersistent(p5);
tx.commit();
tx.begin();
p1.getX();
p2.getX();
p3.getX();
p4.getX();
p5.getX();
tx.commit();
tx = null;
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
/** */
private void createPNonTransactionalObjects(PersistenceManager pm) {
if (isOptimisticSupported()) {
Transaction tx = pm.currentTransaction();
try {
tx.setOptimistic(true);
tx.begin();
np1 = new PCPoint(1,3);
np2 = new PCPoint(2,4);
np3 = new PCPoint(3,5);
np4 = new PCPoint(4,6);
np5 = new PCPoint(5,7);
pm.makePersistent(np1);
pm.makePersistent(np2);
pm.makePersistent(np3);
pm.makePersistent(np4);
pm.makePersistent(np5);
tx.commit();
tx.begin();
np1.getX();
np2.getX();
np3.getX();
np4.getX();
np5.getX();
tx.commit();
tx = null;
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
}
/* test makeTransient (Object pc)
* instance passed has field values and is P-nontransactional *
*/
private void runTestMakeTransientFieldsPreservedUnchanged1(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
pm.makeTransient(p1);
tx.commit();
tx = null;
if (!testState(p1, TRANSIENT, "transient")) {
fail(ASSERTION_FAILED,
"expected TRANSIENT instance, instance " + p1 +
" is " + getStateOfInstance(p1));
}
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
/* test makeTransientAll (Collection pcs) */
private void runTestMakeTransientFieldsPreservedUnchangedAll1(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
Collection col1 = new HashSet();
col1.add(p2);
col1.add(p3);
pm.makeTransientAll(col1);
tx.commit();
tx = null;
for (Iterator iter = col1.iterator(); iter.hasNext();) {
PCPoint p = (PCPoint) iter.next();
if (!testState(p, TRANSIENT, "transient")) {
fail(ASSERTION_FAILED,
"expected TRANSIENT instance, instance " + p +
" is " + getStateOfInstance(p));
}
}
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
/* test makeTransientAll (Object[] o) */
private void runTestMakeTransientFieldsPreservedUnchangedAll2(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
int NUM_OBJS = 2;
tx.begin();
Collection col1 = new HashSet();
col1.add(p4);
col1.add(p5);
Object[] obj1= col1.toArray();
pm.makeTransientAll(obj1);
tx.commit();
tx = null;
for (int i=0; i < NUM_OBJS; ++i ) {
PCPoint p = (PCPoint) obj1[i];
if (!testState(p, TRANSIENT, "transient")) {
fail(ASSERTION_FAILED,
"expected TRANSIENT instance, instance " + p +
" is " + getStateOfInstance(p));
}
}
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
}
././@LongLink 100644 0 0 163 12500111677 10253 L ustar 0 0 tck/src/java/org/apache/jdo/tck/api/persistencemanager/lifecycle/MakeTransientHasNoEffectOnTransientInstances.java tck/src/java/org/apache/jdo/tck/api/persistencemanager/lifecycle/MakeTransientHasNoEffectOnTransient100664 11212 12500110374 34255 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.lifecycle;
import java.util.Collection;
import java.util.HashSet;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
import org.apache.jdo.tck.api.persistencemanager.PersistenceManagerTest;
/**
*Title: MakeTransientHasNoEffectOnTransientInstances
*Keywords: transient
*Assertion IDs: A12.5.7-19
*Assertion Description:
PersistenceManager.makeTransient and
makeTransientAll have no effect if the parameter instance is transient.
*/
public class MakeTransientHasNoEffectOnTransientInstances
extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.5.7-19 (MakeTransientHasNoEffectOnTransientInstances) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(MakeTransientHasNoEffectOnTransientInstances.class);
}
private PCPoint p1 = null;
private PCPoint p2 = null;
private PCPoint p3 = null;
private PCPoint p4 = null;
private PCPoint p5 = null;
/** */
public void testMakeTransientHasNoEffectOnTransientInstances() {
pm = getPM();
createTransientObjects();
runTestMakeTransientHasNoEffectOnTransientInstances1(pm);
runTestMakeTransientHasNoEffectOnTransientInstancesAll1(pm);
runTestMakeTransientHasNoEffectOnTransientInstancesAll2(pm);
pm.close();
pm = null;
}
/** */
private void createTransientObjects() {
p1 = new PCPoint(1,3);
p2 = new PCPoint(2,4);
p3 = new PCPoint(3,5);
p4 = new PCPoint(4,6);
p5 = new PCPoint(5,7);
}
/* test makeTransient (Object pc) */
private void runTestMakeTransientHasNoEffectOnTransientInstances1(
PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
pm.makeTransient(p1);
tx.commit();
tx = null;
if (debug)
logger.debug (" \nPASSED in runTestMakeTransientHasNoEffectOnTransientInstances()");
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
/* test makeTransientAll (Collection pcs) */
private void runTestMakeTransientHasNoEffectOnTransientInstancesAll1(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
Collection col1 = new HashSet();
col1.add(p2);
col1.add(p3);
pm.makeTransientAll(col1);
tx.commit();
tx = null;
if (debug)
logger.debug(" \nPASSED in runTestMakeTransientHasNoEffectOnTransientInstancesAll1()");
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
/* test makeTransientAll (Object[] o) */
private void runTestMakeTransientHasNoEffectOnTransientInstancesAll2(
PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
Collection col1 = new HashSet();
col1.add(p4);
col1.add(p5);
Object[] obj1= col1.toArray();
pm.makeTransientAll(obj1);
tx.commit();
tx = null;
if (debug)
logger.debug (" \nPASSED in runTestMakeTransientHasNoEffectOnTransientInstancesAll2()");
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
}
././@LongLink 100644 0 0 150 12500111677 10247 L ustar 0 0 tck/src/java/org/apache/jdo/tck/api/persistencemanager/lifecycle/MakeTransientNotSubjectToRollback.java tck/src/java/org/apache/jdo/tck/api/persistencemanager/lifecycle/MakeTransientNotSubjectToRollback.j100664 13516 12500110374 34241 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.lifecycle;
import java.util.Collection;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
import org.apache.jdo.tck.api.persistencemanager.PersistenceManagerTest;
/**
*Title: MakeTransientNotSubjectToRollback
*Keywords:
*Assertion IDs: A12.5.7-17
*Assertion Description:
The effect of PersistenceManager.makeTransient or makeTransientAll is immediate and not subject to rollback.
*/
public class MakeTransientNotSubjectToRollback extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.5.7-17 (MakeTransientNotSubjectToRollback) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(MakeTransientNotSubjectToRollback.class);
}
private PCPoint p1 = null;
private PCPoint p2 = null;
private PCPoint p3 = null;
private PCPoint p4 = null;
private PCPoint p5 = null;
/** */
public void testMakeTransientNotSubjectToRollback() {
pm = getPM();
createPersistentObjects(pm);
runTestMakeTransientNotSubjectToRollback1(pm);
runTestMakeTransientNotSubjectToRollbackAll1(pm);
runTestMakeTransientNotSubjectToRollbackAll2(pm);
pm.close();
pm = null;
}
/** */
private void createPersistentObjects(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
p1 = new PCPoint(1,3);
p2 = new PCPoint(2,4);
p3 = new PCPoint(3,5);
p4 = new PCPoint(4,6);
p5 = new PCPoint(5,7);
pm.makePersistent(p1);
pm.makePersistent(p2);
pm.makePersistent(p3);
pm.makePersistent(p4);
pm.makePersistent(p5);
tx.commit();
tx = null;
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
/* test makeTransient (Object pc) */
private void runTestMakeTransientNotSubjectToRollback1(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
pm.makeTransient(p1);
int curr1 = currentState(p1);
tx.rollback();
if (curr1 != currentState(p1)) {
fail(ASSERTION_FAILED,
"expected TRANSIENT instancew, instance " + p1 +
" is " + getStateOfInstance(p1));
}
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
/* test makeTransientAll (Collection pcs) */
private void runTestMakeTransientNotSubjectToRollbackAll1(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
Collection col1 = new java.util.HashSet();
col1.add(p2);
col1.add(p3);
pm.makeTransientAll(col1);
int p2_curr = currentState(p2);
int p3_curr = currentState(p3);
tx.rollback();
if (p2_curr != currentState(p2)) {
fail(ASSERTION_FAILED,
"expected TRANSIENT instancew, instance " + p2 +
" is " + getStateOfInstance(p2));
}
if (p3_curr != currentState(p3)) {
fail(ASSERTION_FAILED,
"expected TRANSIENT instancew, instance " + p3 +
" is " + getStateOfInstance(p3));
}
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
/* test makeTransientAll (Object[] o) */
private void runTestMakeTransientNotSubjectToRollbackAll2(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
Collection col1 = new java.util.HashSet();
col1.add(p4);
col1.add(p5);
Object[] obj1= col1.toArray();
pm.makeTransientAll(obj1);
int p4_curr = currentState(p4);
int p5_curr = currentState(p5);
tx.rollback();
if (p4_curr != currentState(p4)) {
fail(ASSERTION_FAILED,
"expected TRANSIENT instancew, instance " + p4 +
" is " + getStateOfInstance(p2));
}
if (p5_curr != currentState(p5)) {
fail(ASSERTION_FAILED,
"expected TRANSIENT instancew, instance " + p5 +
" is " + getStateOfInstance(p5));
}
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanager/NewInstance.java 100664 10755 12500110374 26467 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.pc.newInstance.AAddress;
import org.apache.jdo.tck.pc.newInstance.Address;
import org.apache.jdo.tck.pc.newInstance.IAddress;
import org.apache.jdo.tck.pc.newInstance.AAddress_bad;
import org.apache.jdo.tck.pc.newInstance.Address_bad;
import org.apache.jdo.tck.pc.newInstance.IAddress_bad;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Delete Persistent
*Keywords:
*Assertion IDs: A12.6.6-2
*Assertion Description:
* Persistent properties declared in the interface are defined as those that have both a get and a set method
* or both an is and a set method, named according to the JavaBeans naming conventions, and
* of a type supported as a persistent type.
* The implementing class will provide a suitable implementation for all property access methods and
* will throw JDOUserException for all other methods of the interface.
*/
public class NewInstance extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.6.6-2 (NewInstance) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(NewInstance.class);
}
/** test newInstance (Class pcInterface) */
public void testNewInstanceInterface() {
pm = getPM();
IAddress instance = pm.newInstance(IAddress.class);
}
/** test newInstance (Class pcAbstractClass) */
public void testNewInstanceAbstractClass() {
pm = getPM();
AAddress instance = pm.newInstance(AAddress.class);
}
/** test newInstance (Class pcClass) */
public void testNewInstanceClass() {
pm = getPM();
Address instance = pm.newInstance(Address.class);
}
/** test newInstance (Class pcInterface) */
public void testNewInstanceInterfaceBad() {
pm = getPM();
try {
pm.newInstance(IAddress_bad.class);
fail("Expected JDOUserException but no exception thrown. "
+ "Interface contains a method that is not property.");
} catch (javax.jdo.JDOUserException jdoe) {
// Expected exception
} catch (Exception e) {
fail("Expected JDOUserException but " + e.getMessage()
+ " thrown instead.");
}
}
/** test newInstance (Class pcAbstractClass) */
public void testNewInstanceAbstractClassBad() {
pm = getPM();
try {
pm.newInstance(AAddress_bad.class);
fail("Expected JDOUserException but no exception thrown. "
+ "Abstract class contains a method that is not property.");
} catch (javax.jdo.JDOUserException jdoe) {
// Expected exception
} catch (Exception e) {
fail("Expected JDOUserException but " + e.getMessage()
+ "t hrown instead.");
}
}
/** test newInstance (Class pcClass) */
public void testNewInstanceClassBad() {
pm = getPM();
try {
pm.newInstance(Address_bad.class);
fail("Expected JDOUserException but no exception thrown. "
+ "Class contains non-public no-args constructor.");
} catch (javax.jdo.JDOUserException jdoe) {
// Expected exception
} catch (Exception e) {
fail("Expected JDOUserException but " + e.getMessage()
+ " thrown instead.");
}
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanager/NoPersistenceManagerIfTransient.java 100664 3663 12500110374 32454 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: No PersistenceManager If Transient
*Keywords: transient
*Assertion ID: A12.5-1.
*Assertion Description:
A JDO Instance is associated with no PersistenceManager
if and only if the instance is in the transient state.
This is a duplicate of A8.1-2.
*/
public class NoPersistenceManagerIfTransient extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.5-1 (NoPersistenceManagerIfTransient) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(NoPersistenceManagerIfTransient.class);
}
/** */
public void test() {
if (debug)
logger.debug("org.apache.jdo.tck.api.persistencemanager.NoPersistenceManagerIfTransient duplicate of A8.1-2.");
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanager/nullargs/DeletePersistentNullArgs.java 100664 7703 12500110374 33012 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.nullargs;
import java.util.Collection;
import javax.jdo.JDOUserException;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: deletePersistent with Null Arguments
*Keywords:
*Assertion IDs: A12.6-3, A12.6-4, A12.6-5
*Assertion Description:
A12.6-3 [Null arguments to APIs that take an Object parameter cause the API to have no effect.] A12.6-4 [Null arguments to APIs that take Object[] or Collection will cause the API to throw NullPointerException.] A12.6-5 [Non-null Object[] or Collection arguments that contain null elements will have the documented behavior for non-null elements, and the null elements will be ignored.]
*/
public class DeletePersistentNullArgs extends PersistenceManagerNullsTest {
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(DeletePersistentNullArgs.class);
}
static MethodUnderTest deletePersistent =
new MethodUnderTestDeletePersistent();
static class MethodUnderTestDeletePersistent extends MethodUnderTest {
public void pmApi(PersistenceManager pm, Object pc) {
pm.deletePersistent(pc);
}
public void pmApi(PersistenceManager pm, Collection pcs) {
pm.deletePersistentAll(pcs);
}
public void pmApi(PersistenceManager pm, Object[] pcs) {
pm.deletePersistentAll(pcs);
}
};
/**
* Test that deletePersistent() with null valued argument does nothing.
*/
public void testDeletePersistentNullObject() {
executeNullObjectParameter(deletePersistent, "deletePersistent(null)");
}
/**
* Test that deletePersistentAll() with null valued Collection argument
* throws NullPointerException.
*/
public void testDeletePersistentNullCollection() {
executeNullCollectionParameter(deletePersistent,
"deletePersistentAll((Collection)null)");
}
/**
* Test that deletePersistentAll() with null valued array argument
* throws NullPointerException.
*/
public void testDeletePersistentNullArray() {
executeNullArrayParameter(deletePersistent,
"deletePersistentAll((Object[])null)");
}
/**
* Test that deletePersistentAll() with a null element of a
* Collection argument throws NullPointerException.
*/
public void testDeletePersistentCollectionNullElement() {
executeCollectionNullElement(collNullElem, deletePersistent,
"deletePersistentAll(Collection)");
}
/**
* Test that deletePersistentAll() with a null element of a
* array argument throws NullPointerException.
*/
public void testDeletePersistentArrayNullElement() {
executeArrayNullElement(arrayNullElem, deletePersistent,
"deletePersistentAll(Object[])");
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanager/nullargs/DetachCopyNullArgs.java 100664 7524 12500110374 31553 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.nullargs;
import java.util.Collection;
import javax.jdo.JDOUserException;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: detachCopy with Null Arguments
*Keywords:
*Assertion IDs: A12.6-3, A12.6-4, A12.6-5
*Assertion Description:
A12.6-3 [Null arguments to APIs that take an Object parameter cause the API to have no effect.] A12.6-4 [Null arguments to APIs that take Object[] or Collection will cause the API to throw NullPointerException.] A12.6-5 [Non-null Object[] or Collection arguments that contain null elements will have the documented behavior for non-null elements, and the null elements will be ignored.]
*/
public class DetachCopyNullArgs extends PersistenceManagerNullsTest {
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(DetachCopyNullArgs.class);
}
static MethodUnderTest detachCopy = new MethodUnderTestDetachCopy();
static class MethodUnderTestDetachCopy extends MethodUnderTest {
public Object pmApiReturn(PersistenceManager pm, Object pc) {
return pm.detachCopy(pc);
}
public Collection pmApiReturn(PersistenceManager pm, Collection pcs) {
return pm.detachCopyAll(pcs);
}
public Object[] pmApiReturn(PersistenceManager pm, Object[] pcs) {
return pm.detachCopyAll(pcs);
}
};
/**
* Test that detachCopy() with null valued argument does nothing.
*/
public void testDetachCopyNullObject() {
executeNullObjectParameterReturn(detachCopy, "detachCopy(null)");
}
/**
* Test that detachCopyAll() with null valued Collection argument
* throws NullPointerException.
*/
public void testDetachCopyNullCollection() {
executeNullCollectionParameterReturn(detachCopy,
"detachCopyAll((Collection)null)");
}
/**
* Test that detachCopyAll() with null valued array argument
* throws NullPointerException.
*/
public void testDetachCopyNullArray() {
executeNullArrayParameterReturn(detachCopy,
"detachCopyAll((Array)null)");
}
/**
* Test that detachCopyAll() with a null element of a
* Collection argument throws NullPointerException.
*/
public void testDetachCopyCollectionNullElement() {
executeCollectionNullElementReturn(collNullElem, detachCopy,
"detachCopyAll(Collection)");
}
/**
* Test that detachCopyAll() with a null element of a
* array argument throws NullPointerException.
*/
public void testDetachCopyArrayNullElement() {
executeArrayNullElementReturn(arrayNullElem, detachCopy,
"detachCopyAll(Array)");
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanager/nullargs/EvictNullArgs.java 100664 7204 12500110374 30575 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.nullargs;
import java.util.Collection;
import javax.jdo.JDOUserException;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: evict with Null Arguments
*Keywords:
*Assertion IDs: A12.6-3, A12.6-4, A12.6-5
*Assertion Description:
A12.6-3 [Null arguments to APIs that take an Object parameter cause the API to have no effect.] A12.6-4 [Null arguments to APIs that take Object[] or Collection will cause the API to throw NullPointerException.] A12.6-5 [Non-null Object[] or Collection arguments that contain null elements will have the documented behavior for non-null elements, and the null elements will be ignored.]
*/
public class EvictNullArgs extends PersistenceManagerNullsTest {
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(EvictNullArgs.class);
}
static MethodUnderTest evict =
new MethodUnderTestEvict();
static class MethodUnderTestEvict extends MethodUnderTest {
public void pmApi(PersistenceManager pm, Object pc) {
pm.evict(pc);
}
public void pmApi(PersistenceManager pm, Collection pcs) {
pm.evictAll(pcs);
}
public void pmApi(PersistenceManager pm, Object[] pcs) {
pm.evictAll(pcs);
}
};
/**
* Test that evict() with null valued argument does nothing.
*/
public void testEvictNullObject() {
executeNullObjectParameter(evict, "evict(null)");
}
/**
* Test that evictAll() with null valued Collection argument
* throws NullPointerException.
*/
public void testEvictNullCollection() {
executeNullCollectionParameter(evict,
"evictAll((Collection)null)");
}
/**
* Test that evictAll() with null valued array argument
* throws NullPointerException.
*/
public void testEvictNullArray() {
executeNullArrayParameter(evict,
"evictAll((Object[])null)");
}
/**
* Test that evictAll() with a null element of a
* Collection argument throws NullPointerException.
*/
public void testEvictCollectionNullElement() {
executeCollectionNullElement(collNullElem, evict,
"evictAll(Collection)");
}
/**
* Test that evictAll() with a null element of a
* array argument throws NullPointerException.
*/
public void testEvictArrayNullElement() {
executeArrayNullElement(arrayNullElem, evict,
"evictAll(Object[])");
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanager/nullargs/MakeNontransactionalNullArgs.java 100664 10067 12500110374 33657 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.nullargs;
import java.util.Collection;
import javax.jdo.JDOUserException;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: makeNontransactional with Null Arguments
*Keywords:
*Assertion IDs: A12.6-3, A12.6-4, A12.6-5
*Assertion Description:
A12.6-3 [Null arguments to APIs that take an Object parameter cause the API to have no effect.] A12.6-4 [Null arguments to APIs that take Object[] or Collection will cause the API to throw NullPointerException.] A12.6-5 [Non-null Object[] or Collection arguments that contain null elements will have the documented behavior for non-null elements, and the null elements will be ignored.]
*/
public class MakeNontransactionalNullArgs extends PersistenceManagerNullsTest {
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(MakeNontransactionalNullArgs.class);
}
static MethodUnderTest makeNontransactional =
new MethodUnderTestMakeNontransactional();
static class MethodUnderTestMakeNontransactional extends MethodUnderTest {
public void pmApi(PersistenceManager pm, Object pc) {
pm.makeNontransactional(pc);
}
public void pmApi(PersistenceManager pm, Collection pcs) {
pm.makeNontransactionalAll(pcs);
}
public void pmApi(PersistenceManager pm, Object[] pcs) {
pm.makeNontransactionalAll(pcs);
}
};
/**
* Test that makeNontransactional() with null valued argument does nothing.
*/
public void testMakeNontransactionalNullObject() {
executeNullObjectParameter(makeNontransactional, "makeNontransactional(null)");
}
/**
* Test that makeNontransactionalAll() with null valued Collection argument
* throws NullPointerException.
*/
public void testMakeNontransactionalNullCollection() {
executeNullCollectionParameter(makeNontransactional,
"makeNontransactionalAll((Collection)null)");
}
/**
* Test that makeNontransactionalAll() with null valued array argument
* throws NullPointerException.
*/
public void testMakeNontransactionalNullArray() {
executeNullArrayParameter(makeNontransactional,
"makeNontransactionalAll((Object[])null)");
}
/**
* Test that makeNontransactionalAll() with a null element of a
* Collection argument throws NullPointerException.
*/
public void testMakeNontransactionalCollectionNullElement() {
executeCollectionNullElement(collNullElem, makeNontransactional,
"makeNontransactionalAll(Collection)");
}
/**
* Test that makeNontransactionalAll() with a null element of a
* array argument throws NullPointerException.
*/
public void testMakeNontransactionalArrayNullElement() {
executeArrayNullElement(arrayNullElem, makeNontransactional,
"makeNontransactionalAll(Object[])");
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanager/nullargs/MakePersistentNullArgs.java 100664 7710 12500110374 32463 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.nullargs;
import java.util.Collection;
import javax.jdo.JDOUserException;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: makePersistent with Null Arguments
*Keywords:
*Assertion IDs: A12.6-3, A12.6-4, A12.6-5
*Assertion Description:
A12.6-3 [Null arguments to APIs that take an Object parameter cause the API to have no effect.] A12.6-4 [Null arguments to APIs that take Object[] or Collection will cause the API to throw NullPointerException.] A12.6-5 [Non-null Object[] or Collection arguments that contain null elements will have the documented behavior for non-null elements, and the null elements will be ignored.]
*/
public class MakePersistentNullArgs extends PersistenceManagerNullsTest {
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(MakePersistentNullArgs.class);
}
static MethodUnderTest makePersistent = new MethodUnderTestMakePersistent();
static class MethodUnderTestMakePersistent extends MethodUnderTest {
public Object pmApiReturn(PersistenceManager pm, Object pc) {
return pm.makePersistent(pc);
}
public Collection pmApiReturn(PersistenceManager pm, Collection pcs) {
return pm.makePersistentAll(pcs);
}
public Object[] pmApiReturn(PersistenceManager pm, Object[] pcs) {
return pm.makePersistentAll(pcs);
}
};
/**
* Test that makePersistent() with null valued argument does nothing.
*/
public void testMakePersistentNullObject() {
executeNullObjectParameterReturn(makePersistent, "makePersistent(null)");
}
/**
* Test that makePersistentAll() with null valued Collection argument
* throws NullPointerException.
*/
public void testMakePersistentNullCollection() {
executeNullCollectionParameterReturn(makePersistent,
"makePersistentAll((Collection)null)");
}
/**
* Test that makePersistentAll() with null valued array argument
* throws NullPointerException.
*/
public void testMakePersistentNullArray() {
executeNullArrayParameterReturn(makePersistent,
"makePersistentAll((Array)null)");
}
/**
* Test that makePersistentAll() with a null element of a
* Collection argument throws NullPointerException.
*/
public void testMakePersistentCollectionNullElement() {
executeCollectionNullElementReturn(collNullElem, makePersistent,
"makePersistentAll(Collection)");
}
/**
* Test that makePersistentAll() with a null element of a
* array argument throws NullPointerException.
*/
public void testMakePersistentArrayNullElement() {
executeArrayNullElementReturn(arrayNullElem, makePersistent,
"makePersistentAll(Array)");
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanager/nullargs/MakeTransactionalNullArgs.java 100664 7740 12500110374 33130 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.nullargs;
import java.util.Collection;
import javax.jdo.JDOUserException;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: makeTransactional with Null Arguments
*Keywords:
*Assertion IDs: A12.6-3, A12.6-4, A12.6-5
*Assertion Description:
A12.6-3 [Null arguments to APIs that take an Object parameter cause the API to have no effect.] A12.6-4 [Null arguments to APIs that take Object[] or Collection will cause the API to throw NullPointerException.] A12.6-5 [Non-null Object[] or Collection arguments that contain null elements will have the documented behavior for non-null elements, and the null elements will be ignored.]
*/
public class MakeTransactionalNullArgs extends PersistenceManagerNullsTest {
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(MakeTransactionalNullArgs.class);
}
static MethodUnderTest makeTransactional =
new MethodUnderTestMakeTransactional();
static class MethodUnderTestMakeTransactional extends MethodUnderTest {
public void pmApi(PersistenceManager pm, Object pc) {
pm.makeTransactional(pc);
}
public void pmApi(PersistenceManager pm, Collection pcs) {
pm.makeTransactionalAll(pcs);
}
public void pmApi(PersistenceManager pm, Object[] pcs) {
pm.makeTransactionalAll(pcs);
}
};
/**
* Test that makeTransactional() with null valued argument does nothing.
*/
public void testMakeTransactionalNullObject() {
executeNullObjectParameter(makeTransactional, "makeTransactional(null)");
}
/**
* Test that makeTransactionalAll() with null valued Collection argument
* throws NullPointerException.
*/
public void testMakeTransactionalNullCollection() {
executeNullCollectionParameter(makeTransactional,
"makeTransactionalAll((Collection)null)");
}
/**
* Test that makeTransactionalAll() with null valued array argument
* throws NullPointerException.
*/
public void testMakeTransactionalNullArray() {
executeNullArrayParameter(makeTransactional,
"makeTransactionalAll((Object[])null)");
}
/**
* Test that makeTransactionalAll() with a null element of a
* Collection argument throws NullPointerException.
*/
public void testMakeTransactionalCollectionNullElement() {
executeCollectionNullElement(collNullElem, makeTransactional,
"makeTransactionalAll(Collection)");
}
/**
* Test that makeTransactionalAll() with a null element of a
* array argument throws NullPointerException.
*/
public void testMakeTransactionalArrayNullElement() {
executeArrayNullElement(arrayNullElem, makeTransactional,
"makeTransactionalAll(Object[])");
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanager/nullargs/MakeTransientNullArgs.java 100664 7554 12500110374 32300 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.nullargs;
import java.util.Collection;
import javax.jdo.JDOUserException;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: makeTransient with Null Arguments
*Keywords:
*Assertion IDs: A12.6-3, A12.6-4, A12.6-5
*Assertion Description:
A12.6-3 [Null arguments to APIs that take an Object parameter cause the API to have no effect.] A12.6-4 [Null arguments to APIs that take Object[] or Collection will cause the API to throw NullPointerException.] A12.6-5 [Non-null Object[] or Collection arguments that contain null elements will have the documented behavior for non-null elements, and the null elements will be ignored.]
*/
public class MakeTransientNullArgs extends PersistenceManagerNullsTest {
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(MakeTransientNullArgs.class);
}
static MethodUnderTest makeTransient =
new MethodUnderTestMakeTransient();
static class MethodUnderTestMakeTransient extends MethodUnderTest {
public void pmApi(PersistenceManager pm, Object pc) {
pm.makeTransient(pc);
}
public void pmApi(PersistenceManager pm, Collection pcs) {
pm.makeTransientAll(pcs);
}
public void pmApi(PersistenceManager pm, Object[] pcs) {
pm.makeTransientAll(pcs);
}
};
/**
* Test that makeTransient() with null valued argument does nothing.
*/
public void testMakeTransientNullObject() {
executeNullObjectParameter(makeTransient, "makeTransient(null)");
}
/**
* Test that makeTransientAll() with null valued Collection argument
* throws NullPointerException.
*/
public void testMakeTransientNullCollection() {
executeNullCollectionParameter(makeTransient,
"makeTransientAll((Collection)null)");
}
/**
* Test that makeTransientAll() with null valued array argument
* throws NullPointerException.
*/
public void testMakeTransientNullArray() {
executeNullArrayParameter(makeTransient,
"makeTransientAll((Object[])null)");
}
/**
* Test that makeTransientAll() with a null element of a
* Collection argument throws NullPointerException.
*/
public void testMakeTransientCollectionNullElement() {
executeCollectionNullElement(collNullElem, makeTransient,
"makeTransientAll(Collection)");
}
/**
* Test that makeTransientAll() with a null element of a
* array argument throws NullPointerException.
*/
public void testMakeTransientArrayNullElement() {
executeArrayNullElement(arrayNullElem, makeTransient,
"makeTransientAll(Object[])");
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanager/nullargs/PersistenceManagerNullsTest.java 100664 42660 12500110374 33535 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.nullargs;
import java.util.Arrays;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import javax.jdo.JDOHelper;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.mylib.PCPoint;
/**
* The superclass for the tests of null arguments to pm methods.
*
* Null arguments to APIs that take an Object parameter cause the API
* to have no effect. Null arguments to APIs that take Object[] or Collection
* will cause the API to throw NullPointerException. Non-null Object[] or
* Collection arguments that contain null elements will have the documented
* behavior for non-null elements, and the null elements will be ignored.
*
*/
public class PersistenceManagerNullsTest extends JDO_Test {
/**
public static interface MethodUnderTest {
public void pmApi(PersistenceManager pm, Object obj);
public void pmApi(PersistenceManager pm, Collection coll);
public void pmApi(PersistenceManager pm, Object[] objs);
public Object pmApiReturn(PersistenceManager pm, Object obj);
public Collection pmApiReturn(PersistenceManager pm, Collection coll);
public Object[] pmApiReturn(PersistenceManager pm, Object [ ] objs);
}
*/
/**
*/
public static class MethodUnderTest {
public void pmApi(PersistenceManager pm, Object obj) {
throw new UnsupportedOperationException("Test must implement this method");
}
public void pmApi(PersistenceManager pm, Collection coll) {
throw new UnsupportedOperationException("Test must implement this method");
}
public void pmApi(PersistenceManager pm, Object[] objs) {
throw new UnsupportedOperationException("Test must implement this method");
}
public Object pmApiReturn(PersistenceManager pm, Object obj) {
throw new UnsupportedOperationException("Test must implement this method");
}
public Collection pmApiReturn(PersistenceManager pm, Collection coll) {
throw new UnsupportedOperationException("Test must implement this method");
}
public Object[] pmApiReturn(PersistenceManager pm, Object[] objs) {
throw new UnsupportedOperationException("Test must implement this method");
}
}
private static final String ASSERTION3_FAILED =
"Assertion A12.6-3 failed: ";
private static final String ASSERTION4_FAILED =
"Assertion A12.6-4 failed: ";
private static final String ASSERTION5_FAILED =
"Assertion A12.6-5 failed: ";
protected PCPoint pNotNull = null;
protected Collection collNullElem = null;
protected Collection expectedCollection = null;
protected Object[] arrayNullElem = new Object[] {null, null};
protected Object[] expectedArray = new Object[] {null, null};
protected Collection testInstances = null;
/** */
protected PersistenceManagerNullsTest() { }
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
// The order of addTearDownClass calls is significant
// as it takes into account database FKs.
addTearDownClass(PCPoint.class);
// Initialize test objects and expected values
pNotNull = new PCPoint(3, 5);
arrayNullElem[1] = pNotNull;
expectedArray[1] = pNotNull;
collNullElem = Arrays.asList(arrayNullElem);
pm = getPM();
Transaction tx = pm.currentTransaction();
try {
tx = pm.currentTransaction();
tx.begin();
try {
pm.makePersistent(pNotNull);
} catch (Exception e) {
e.printStackTrace();
}
tx.commit();
logger.debug(" \nSetup committed in DeletePersistentNullArgs()");
}
finally {
if (tx.isActive()) {
tx.rollback();
}
} expectedCollection = Arrays.asList(arrayNullElem);
}
protected static String toString(Object[] objs) {
StringBuffer out = new StringBuffer();
for (int i=0; i < objs.length; i++) {
out.append("[" + i + "]: ");
if (objs[i] == null)
out.append("null");
else out.append(objs[i].toString());
out.append(", ");
}
return out.toString();
}
protected static String toString(Collection objs) {
return toString(objs.toArray());
}
/**
* Checks if expected and actual arguments match for null/non-null value
* @return true if arguments match
* @param expected Collection
* @param actual Collection
*/
protected boolean checkReturn(Collection expected, Collection actual) {
Object eElem = null;
Object aElem = null;
if (expected.size() != actual.size())
return false;
Iterator eIt = expected.iterator();
Iterator aIt = actual.iterator();
while (eIt.hasNext()) {
eElem = eIt.next();
aElem = aIt.next();
if ( (eElem == null && aElem != null)
|| (aElem == null && eElem != null) )
return false;
}
return true;
}
/**
* Checks if expected and actual arguments match for null/non-null value
* @return true if arguments match
* @param expected Object[]
* @param actual Object[]
*/
protected boolean checkReturn(Object[] expected, Object[] actual) {
Object eElem = null;
Object aElem = null;
if (expected.length != actual.length)
return false;
for (int i=0; i < expected.length; i++) {
eElem = expected[i];
aElem = actual[i];
if ( (eElem == null && aElem != null)
|| (aElem == null && eElem != null) )
return false;
}
return true;
}
/**
* Test that method under test with null valued argument does nothing.
*/
public void executeNullObjectParameter(MethodUnderTest mut, String method) {
Transaction tx = pm.currentTransaction();
Object obj = null;
try {
tx = pm.currentTransaction();
tx.begin();
try {
mut.pmApi(pm, obj);
} catch (Exception e) {
fail(ASSERTION3_FAILED,
method + " on a null object should do nothing."
+ " Instead we get: " + e.toString());
}
tx.commit();
logger.debug(" \nPASSED in executeNullObjectParameter() on "
+ method);
} finally {
if (tx.isActive())
tx.rollback();
}
}
/**
* Test that the method under test with null valued Collection argument
* throws NullPointerException.
*/
public void executeNullCollectionParameter(MethodUnderTest mut,
String method) {
Collection coll = null;
Transaction tx = pm.currentTransaction();
try {
tx.begin();
try {
mut.pmApi(pm, coll);
fail(ASSERTION4_FAILED,
method
+ " with null Collection argument should throw NPE.");
} catch (NullPointerException npe) {
// this is what we want
} catch (Exception e) {
fail(ASSERTION4_FAILED,
method
+ " with null Collection argument should throw NPE."
+ " Instead we get: " + e.toString());
e.printStackTrace();
}
tx.commit();
logger.debug(" \nPASSED in executeNullCollectionParameter()");
} finally {
if (tx.isActive())
tx.rollback();
}
}
/**
* Test that the method under test with null valued array argument
* throws NullPointerException.
*/
public void executeNullArrayParameter(MethodUnderTest mut,
String method) {
Object[] array = null;
Transaction tx = pm.currentTransaction();
try {
tx.begin();
try {
mut.pmApi(pm, array);
fail(ASSERTION4_FAILED, method +
" with null array argument should throw NPE.");
} catch (NullPointerException npe) {
// this is what we want
} catch (Exception e) {
fail(ASSERTION4_FAILED,
method + " with null array argument should throw NPE."
+ " Instead we get: " + e.toString());
e.printStackTrace();
}
tx.commit();
logger.debug(" \nPASSED in executeNullArrayParameter()");
} finally {
if (tx.isActive())
tx.rollback();
}
}
/**
* Test that the method under test with a null element of a
* Collection argument ignores the null element.
*/
public void executeCollectionNullElement(Collection coll,
MethodUnderTest mut, String method) {
Transaction tx = pm.currentTransaction();
try {
tx = pm.currentTransaction();
tx.begin();
try {
mut.pmApi(pm, coll);
} catch (Exception e) {
fail(ASSERTION5_FAILED,
method + " on a null Collection element should"
+ " do nothing. Instead we get: " + e.toString());
e.printStackTrace();
}
tx.commit();
} finally {
if (tx.isActive())
tx.rollback();
}
}
/**
* Test that the method under test with a null element of a
* array argument ignores the null element.
*/
public void executeArrayNullElement(Object[] array, MethodUnderTest mut,
String method) {
Transaction tx = pm.currentTransaction();
try {
tx = pm.currentTransaction();
tx.begin();
try {
mut.pmApi(pm, array);
} catch (Exception e) {
fail(ASSERTION5_FAILED,
method + " on a null array element should "
+ "do nothing. Instead we get: " + e.toString());
e.printStackTrace();
}
tx.commit();
} finally {
if (tx.isActive())
tx.rollback();
}
}
/**
* Test that method under test with null valued argument does nothing.
*/
public void executeNullObjectParameterReturn(MethodUnderTest mut,
String method) {
Object returnVal = null;
Object obj = null;
Transaction tx = pm.currentTransaction();
try {
tx = pm.currentTransaction();
tx.begin();
try {
returnVal = mut.pmApiReturn(pm, obj);
} catch (Exception e) {
fail(ASSERTION3_FAILED,
method + " on a null object should do nothing."
+ " Instead we get: " + e.toString());
e.printStackTrace();
}
if (returnVal != null)
fail(ASSERTION3_FAILED,
method + " returns non-null Object; expected null.");
tx.commit();
logger.debug(" \nPASSED in executeNullObjectParameter() on "
+ method);
}
finally {
if (tx.isActive())
tx.rollback();
}
}
/**
* Test that the method under test with null valued Collection argument
* throws NullPointerException.
*/
public void executeNullCollectionParameterReturn( MethodUnderTest mut,
String method) {
Collection returnVal = null;
Collection coll = null;
Transaction tx = pm.currentTransaction();
try {
tx.begin();
try {
returnVal = mut.pmApiReturn(pm, coll);
fail(ASSERTION4_FAILED,
method
+ " with null Collection argument should throw NPE.");
} catch (NullPointerException npe) {
// this is what we want
} catch (Exception e) {
fail(ASSERTION4_FAILED,
method
+ " with null Collection argument should throw NPE."
+ " Instead we get: " + e.toString());
e.printStackTrace();
}
if (returnVal != null)
fail(ASSERTION4_FAILED,
method + " returns non-null Object. ");
tx.commit();
logger.debug(" \nPASSED in executeNullCollectionParameter()");
}
finally {
if (tx.isActive())
tx.rollback();
}
}
/**
* Test that the method under test with null valued array argument
* throws NullPointerException.
*/
public void executeNullArrayParameterReturn(MethodUnderTest mut,
String method) {
Object[] returnVal = null;
Object[] array = null;
Transaction tx = pm.currentTransaction();
try {
tx.begin();
try {
returnVal = mut.pmApiReturn(pm, array);
fail(ASSERTION4_FAILED, method
+ " with null array argument should throw NPE.");
} catch (NullPointerException npe) {
// this is what we want
} catch (Exception e) {
fail(ASSERTION4_FAILED,
method + " with null array argument should throw NPE."
+ " Instead we get: " + e.toString());
e.printStackTrace();
}
if (returnVal != null)
fail(ASSERTION4_FAILED,
method + " returns non-null Object.");
tx.commit();
logger.debug(" \nPASSED in executeNullArrayParameter()");
}
finally {
if (tx.isActive())
tx.rollback();
}
}
/**
* Test that the method under test with a null element of a
* Collection argument ignores the null element.
*/
public void executeCollectionNullElementReturn(Collection coll,
MethodUnderTest mut, String method) {
Collection returnVal = null;
Transaction tx = pm.currentTransaction();
try {
tx = pm.currentTransaction();
tx.begin();
try {
returnVal = mut.pmApiReturn(pm, coll);
} catch (Exception e) {
fail(ASSERTION5_FAILED,
method + " on a null Collection element should"
+ " do nothing. Instead we get: " + e.toString());
e.printStackTrace();
}
if (!checkReturn(expectedCollection, returnVal))
fail(ASSERTION5_FAILED,
method + " returns incorrect Object. Expected "
+ expectedCollection.toString() + " actual was "
+ returnVal.toString());
tx.commit();
} finally {
if (tx.isActive())
tx.rollback();
}
}
/**
* Test that the method under test with a null element of a
* array argument ignores the null element.
*/
public void executeArrayNullElementReturn(Object[] obj,
MethodUnderTest mut, String method) {
Object[] returnVal = null;
Transaction tx = pm.currentTransaction();
try {
tx = pm.currentTransaction();
tx.begin();
try {
returnVal = mut.pmApiReturn(pm, obj);
} catch (Exception e) {
fail(ASSERTION5_FAILED,
method + " on a null array element should "
+ "do nothing. Instead we get: " + e.toString());
e.printStackTrace();
}
if (!checkReturn(expectedArray, returnVal))
fail(ASSERTION5_FAILED,
method + " returns incorrect Object. Expected "
+ Arrays.asList(expectedArray).toString()
+ " actual was "
+ Arrays.asList(returnVal).toString());
tx.commit();
} finally {
if (tx.isActive())
tx.rollback();
}
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanager/nullargs/RefreshNullArgs.java 100664 7276 12500110374 31132 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.nullargs;
import java.util.Collection;
import javax.jdo.JDOUserException;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: refresh with Null Arguments
*Keywords:
*Assertion IDs: A12.6-3, A12.6-4, A12.6-5
*Assertion Description:
A12.6-3 [Null arguments to APIs that take an Object parameter cause the API to have no effect.] A12.6-4 [Null arguments to APIs that take Object[] or Collection will cause the API to throw NullPointerException.] A12.6-5 [Non-null Object[] or Collection arguments that contain null elements will have the documented behavior for non-null elements, and the null elements will be ignored.]
*/
public class RefreshNullArgs extends PersistenceManagerNullsTest {
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(RefreshNullArgs.class);
}
static MethodUnderTest refresh =
new MethodUnderTestRefresh();
static class MethodUnderTestRefresh extends MethodUnderTest {
public void pmApi(PersistenceManager pm, Object pc) {
pm.refresh(pc);
}
public void pmApi(PersistenceManager pm, Collection pcs) {
pm.refreshAll(pcs);
}
public void pmApi(PersistenceManager pm, Object[] pcs) {
pm.refreshAll(pcs);
}
};
/**
* Test that refresh() with null valued argument does nothing.
*/
public void testRefreshNullObject() {
executeNullObjectParameter(refresh, "refresh(null)");
}
/**
* Test that refreshAll() with null valued Collection argument
* throws NullPointerException.
*/
public void testRefreshNullCollection() {
executeNullCollectionParameter(refresh,
"refreshAll((Collection)null)");
}
/**
* Test that refreshAll() with null valued array argument
* throws NullPointerException.
*/
public void testRefreshNullArray() {
executeNullArrayParameter(refresh,
"refreshAll((Object[])null)");
}
/**
* Test that refreshAll() with a null element of a
* Collection argument throws NullPointerException.
*/
public void testRefreshCollectionNullElement() {
executeCollectionNullElement(collNullElem, refresh,
"refreshAll(Collection)");
}
/**
* Test that refreshAll() with a null element of a
* array argument throws NullPointerException.
*/
public void testRefreshArrayNullElement() {
executeArrayNullElement(arrayNullElem, refresh,
"refreshAll(Object[])");
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanager/nullargs/RetrieveNullArgs.java 100664 7333 12500110374 31313 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.nullargs;
import java.util.Collection;
import javax.jdo.JDOUserException;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: retrieve with Null Arguments
*Keywords:
*Assertion IDs: A12.6-3, A12.6-4, A12.6-5
*Assertion Description:
A12.6-3 [Null arguments to APIs that take an Object parameter cause the API to have no effect.] A12.6-4 [Null arguments to APIs that take Object[] or Collection will cause the API to throw NullPointerException.] A12.6-5 [Non-null Object[] or Collection arguments that contain null elements will have the documented behavior for non-null elements, and the null elements will be ignored.]
*/
public class RetrieveNullArgs extends PersistenceManagerNullsTest {
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(RetrieveNullArgs.class);
}
static MethodUnderTest retrieve =
new MethodUnderTestRetrieve();
static class MethodUnderTestRetrieve extends MethodUnderTest {
public void pmApi(PersistenceManager pm, Object pc) {
pm.retrieve(pc);
}
public void pmApi(PersistenceManager pm, Collection pcs) {
pm.retrieveAll(pcs);
}
public void pmApi(PersistenceManager pm, Object[] pcs) {
pm.retrieveAll(pcs);
}
};
/**
* Test that retrieve() with null valued argument does nothing.
*/
public void testRetrieveNullObject() {
executeNullObjectParameter(retrieve, "retrieve(null)");
}
/**
* Test that retrieveAll() with null valued Collection argument
* throws NullPointerException.
*/
public void testRetrieveNullCollection() {
executeNullCollectionParameter(retrieve,
"retrieveAll((Collection)null)");
}
/**
* Test that retrieveAll() with null valued array argument
* throws NullPointerException.
*/
public void testRetrieveNullArray() {
executeNullArrayParameter(retrieve,
"retrieveAll((Object[])null)");
}
/**
* Test that retrieveAll() with a null element of a
* Collection argument throws NullPointerException.
*/
public void testRetrieveCollectionNullElement() {
executeCollectionNullElement(collNullElem, retrieve,
"retrieveAll(Collection)");
}
/**
* Test that retrieveAll() with a null element of a
* array argument throws NullPointerException.
*/
public void testRetrieveArrayNullElement() {
executeArrayNullElement(arrayNullElem, retrieve,
"retrieveAll(Object[])");
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanager/nullargs/RetrieveWithFetchPlanNullArgs.java 100664 10102 12500110374 33740 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager.nullargs;
import java.util.Collection;
import javax.jdo.JDOUserException;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: retrieveWithFetchPlan with Null Arguments
*Keywords:
*Assertion IDs: A12.6-3, A12.6-4, A12.6-5
*Assertion Description:
A12.6-3 [Null arguments to APIs that take an Object parameter cause the API to have no effect.] A12.6-4 [Null arguments to APIs that take Object[] or Collection will cause the API to throw NullPointerException.] A12.6-5 [Non-null Object[] or Collection arguments that contain null elements will have the documented behavior for non-null elements, and the null elements will be ignored.]
*/
public class RetrieveWithFetchPlanNullArgs extends PersistenceManagerNullsTest {
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(RetrieveWithFetchPlanNullArgs.class);
}
static MethodUnderTest retrieveWithFetchPlan =
new MethodUnderTestRetrieveWithFetchPlan();
static class MethodUnderTestRetrieveWithFetchPlan extends MethodUnderTest {
public void pmApi(PersistenceManager pm, Object pc) {
pm.retrieve(pc, false);
}
public void pmApi(PersistenceManager pm, Collection pcs) {
pm.retrieveAll(pcs, false);
}
public void pmApi(PersistenceManager pm, Object[] pcs) {
pm.retrieveAll(pcs, false);
}
};
/**
* Test that retrieveWithFetchPlan() with null valued argument does nothing.
*/
public void testRetrieveWithFetchPlanNullObject() {
executeNullObjectParameter(retrieveWithFetchPlan, "retrieveWithFetchPlan(null)");
}
/**
* Test that retrieveWithFetchPlanAll() with null valued Collection argument
* throws NullPointerException.
*/
public void testRetrieveWithFetchPlanNullCollection() {
executeNullCollectionParameter(retrieveWithFetchPlan,
"retrieveWithFetchPlanAll((Collection)null)");
}
/**
* Test that retrieveWithFetchPlanAll() with null valued array argument
* throws NullPointerException.
*/
public void testRetrieveWithFetchPlanNullArray() {
executeNullArrayParameter(retrieveWithFetchPlan,
"retrieveWithFetchPlanAll((Object[])null)");
}
/**
* Test that retrieveWithFetchPlanAll() with a null element of a
* Collection argument throws NullPointerException.
*/
public void testRetrieveWithFetchPlanCollectionNullElement() {
executeCollectionNullElement(collNullElem, retrieveWithFetchPlan,
"retrieveWithFetchPlanAll(Collection)");
}
/**
* Test that retrieveWithFetchPlanAll() with a null element of a
* array argument throws NullPointerException.
*/
public void testRetrieveWithFetchPlanArrayNullElement() {
executeArrayNullElement(arrayNullElem, retrieveWithFetchPlan,
"retrieveWithFetchPlanAll(Object[])");
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanager/ObjectIdUniqueAmongInstances.java 100664 6337 12500110374 31736 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager;
import java.util.HashSet;
import java.util.Iterator;
import javax.jdo.Transaction;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: ObjectId Unique Among Instances
*Keywords: identity
*Assertion ID: A12.5.6-12.
*Assertion Description:
Within a transaction, the ObjectId returned will compare equal
to the ObjectId returned by only one among all JDO instances
associated with the PersistenceManager regardless of the type of
ObjectId.
*/
public class ObjectIdUniqueAmongInstances extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.5.6-12 (ObjectIdUniqueAmongInstances) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(ObjectIdUniqueAmongInstances.class);
}
/** */
public void test() {
final int count = 1000;
HashSet instances = new HashSet(count);
HashSet oids = new HashSet(count);
pm = getPM();
Transaction tx = pm.currentTransaction();
try {
tx.begin();
// Construct "count" persistent instances, and save them in a
// hashset.
for (int i = 0; i < count; ++i) {
PCPoint p = new PCPoint (i, count-i);
pm.makePersistent(p);
instances.add(p);
}
// For all new persistent instances, get the object ids and
// save them in another hashset. There should be the same
// number if the ids are all unique.
for (Iterator it = instances.iterator(); it.hasNext();) {
oids.add(pm.getObjectId(it.next()));
}
tx.commit();
tx = null;
if (oids.size() != instances.size()) {
fail(ASSERTION_FAILED,
"Oids has size: " + oids.size() + "; expected: " + instances.size());
}
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
pm.close();
pm = null;
}
}
././@LongLink 100644 0 0 145 12500111677 10253 L ustar 0 0 tck/src/java/org/apache/jdo/tck/api/persistencemanager/OneInstanceOfObjectPerPersistenceManager.java tck/src/java/org/apache/jdo/tck/api/persistencemanager/OneInstanceOfObjectPerPersistenceManager.java100664 13204 12500110374 34232 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager;
import java.util.Collection;
import java.util.Iterator;
import javax.jdo.Query;
import javax.jdo.Transaction;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.pc.mylib.PCRect;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Only one instance of persistent object in cache per
PersistenceManager
*Keywords: cache
*Assertion ID: A5.4-10.
*Assertion Description:
JDO implementations must manage the cache of JDO instances such that there is
only one JDO instance, associated with each PersistenceManager
representing the persistent state of each corresponding data store object.
*/
public class OneInstanceOfObjectPerPersistenceManager extends
PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A5.4-10 (OneInstanceOfObjectPerPersistenceManager) " +
"failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(OneInstanceOfObjectPerPersistenceManager.class);
}
/**
* This test creates objects in one transaction and commits.
* The important object is p1.
* Then, in a second transaction, it gets an object p1a by id,
* gets another object p1b by navigation, and a third object p1c by
* query. All of these represent the same datastore object and
* therefore must be identical in the same PersistenceManager.
*/
public void test() {
/** The getPM method is declared in a superclass.
* This is the standard way to get a PersistenceManager.
* The method automatically gets a PersistenceManagerFactory,
* gets a PersistenceManager, and puts the PersistenceManager into
* the field pm.
*/
getPM();
/** This is the standard way to get a Transaction.
*/
Transaction tx = pm.currentTransaction();
/** Any values for these flags should be set before
* beginning a transaction.
*/
tx.setRetainValues(false);
tx.setRestoreValues(false);
/** This is the standard way to begin a transaction.
*/
tx.begin();
/** Create new objects to be persisted.
*/
PCPoint p1 = new PCPoint(10, 20);
PCPoint p2 = new PCPoint(20, 40);
PCRect rect = new PCRect(0, p1, p2);
/** This test relies on persistence by reachability.
*/
pm.makePersistent(rect);
/** This is the standard way to commit a transaction.
*/
tx.commit();
/** Begin a new transaction so that the navigation
* uses the object id to load the target object into the cache.
* The RetainValues flag false guarantees that the object fields
* are no longer loaded.
*/
tx.begin();
Object p1Id = pm.getObjectId(p1);
/** Retrieves the field values from the datastore.
*/
PCPoint p1a = (PCPoint)pm.getObjectById(p1Id, true);
/** Navigate to the point.
*/
PCPoint p1b = rect.getUpperLeft();
/** Query for the point by its values in the datastore.
*/
PCPoint p1c = findPoint(10, 20);
tx.commit();
tx = null;
/** Use a StringBuffer to collect results.
*/
StringBuffer results = new StringBuffer();
/** Compare the original object with the object obtained
* by getObjectById.
*/
if (p1 != p1a) {
results.append("getObjectById results differ. ");
}
/** Compare the original object with the object obtained
* by navigating from another object.
*/
if (p1 != p1b) {
results.append("navigation results differ. ");
}
/** Compare the original object with the object obtained
* by query.
*/
if (p1 != p1c) {
results.append("query results differ. ");
}
if (results.length() != 0) {
fail(ASSERTION_FAILED + results.toString());
}
/** The standard way to end each test method is to simply return.
* Exceptions are caught by JUnit.
* The tearDown method ends the transaction and closes
* the PersistenceManager.
*/
}
/** */
private PCPoint findPoint (int x, int y) {
Query q = getPM().newQuery (PCPoint.class);
q.declareParameters ("int px, int py");
q.setFilter ("x == px & y == py");
Collection results = (Collection)q.execute (new Integer(x),
new Integer(y));
Iterator it = results.iterator();
PCPoint ret = (PCPoint)it.next();
return ret;
}
}
././@LongLink 100644 0 0 155 12500111677 10254 L ustar 0 0 tck/src/java/org/apache/jdo/tck/api/persistencemanager/OnePersistenceManagerIfPersistentOrTransactional.java tck/src/java/org/apache/jdo/tck/api/persistencemanager/OnePersistenceManagerIfPersistentOrTransactio100664 3765 12500110374 34426 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: One PersistenceManager If Persistent or Transactional
*Keywords:
*Assertion ID: A12.5-2.
*Assertion Description:
A JDO Instance is associated with exactly one PersistenceManager
if the instance is persistent or transactional.
This is a duplicate test.
*/
public class OnePersistenceManagerIfPersistentOrTransactional extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.5-2 (OnePersistenceManagerIfPersistentOrTransactional) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(OnePersistenceManagerIfPersistentOrTransactional.class);
}
/** */
public void test() {
if (debug)
logger.debug("org.apache.jdo.tck.api.persistencemanager.OnePersistenceManagerIfPersistentOrTransactional.run duplicate");
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanager/OptimisticFailure.java 100664 22522 12500110374 27700 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager;
import java.util.HashSet;
import java.util.Set;
import javax.jdo.JDOException;
import javax.jdo.JDOHelper;
import javax.jdo.JDOOptimisticVerificationException;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.pc.mylib.VersionedPCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: OptimisticFailure
*Keywords: optimistic
*Assertion IDs: A13.5-1
*Assertion Description:
* If any instance fails the verification, a JDOOptimisticVerificationException
* is thrown which contains an array of JDOOptimisticVerificationException,
* one for each instance that failed the verification. The optimistic
* transaction is failed, and the transaction is rolled back.
* The definition of "changed instance" is a JDO implementation choice,
* but it is required that a field that has been changed to different
* values in different transactions results in one of the transactions
* failing.
*/
public class OptimisticFailure extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A13.5-1 (OptimisticFailure) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(OptimisticFailure.class);
}
private VersionedPCPoint p1 = new VersionedPCPoint(1,1); // this will be updated in tx1, updated in tx2, verified in tx3
private VersionedPCPoint p2 = new VersionedPCPoint(2,2); // this will be updated in tx1, deleted in tx2, verified in tx3
private VersionedPCPoint p3 = new VersionedPCPoint(3,3); // this will be deleted in tx1, updated in tx2
private VersionedPCPoint p4 = new VersionedPCPoint(4,4); // this will be deleted in tx1, deleted in tx2
private VersionedPCPoint p5 = new VersionedPCPoint(5,5); // this will be unchanged in tx1, updated in tx2, verified in tx3
private Object p1oid = null;
private Object p2oid = null;
private Object p3oid = null;
private Object p4oid = null;
private Object p5oid = null;
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
addTearDownClass(VersionedPCPoint.class);
}
/** */
public void test() {
pm = getPM();
PersistenceManager pm2 = pmf.getPersistenceManager();
PersistenceManager pm3 = pmf.getPersistenceManager();
try {
runTestOptimistic(pm, pm2, pm3);
}
finally {
cleanupPM(pm3);
pm3 = null;
cleanupPM(pm2);
pm2 = null;
cleanupPM(pm);
pm = null;
}
}
/** */
private void runTestOptimistic(PersistenceManager pm1,
PersistenceManager pm2,
PersistenceManager pm3) {
if (!isOptimisticSupported()) {
if (debug)
logger.debug("OptimisticFailure tests not run; Optimistic not supported");
return;
}
Transaction tx1 = pm1.currentTransaction();
Transaction tx2 = pm2.currentTransaction();
Transaction tx3 = pm3.currentTransaction();
try {
tx1.setOptimistic(true);
tx2.setOptimistic(true);
// create five instances to test
tx1.begin();
pm1.makePersistent(p1);
pm1.makePersistent(p2);
pm1.makePersistent(p3);
pm1.makePersistent(p4);
pm1.makePersistent(p5);
p1oid = pm1.getObjectId(p1);
p2oid = pm1.getObjectId(p2);
p3oid = pm1.getObjectId(p3);
p4oid = pm1.getObjectId(p4);
p5oid = pm1.getObjectId(p5);
tx1.commit();
// update/delete the instances in tx1
tx1.begin();
VersionedPCPoint p1tx1 = (VersionedPCPoint)pm1.getObjectById(p1oid, true);
VersionedPCPoint p2tx1 = (VersionedPCPoint)pm1.getObjectById(p2oid, true);
VersionedPCPoint p3tx1 = (VersionedPCPoint)pm1.getObjectById(p3oid, true);
VersionedPCPoint p4tx1 = (VersionedPCPoint)pm1.getObjectById(p4oid, true);
p1tx1.setX(101);
p2tx1.setX(201);
pm1.deletePersistent(p3tx1);
pm1.deletePersistent(p4tx1);
// update/delete the instances in tx2
tx2.begin();
VersionedPCPoint p1tx2 = (VersionedPCPoint)pm2.getObjectById(p1oid, true);
VersionedPCPoint p2tx2 = (VersionedPCPoint)pm2.getObjectById(p2oid, true);
VersionedPCPoint p3tx2 = (VersionedPCPoint)pm2.getObjectById(p3oid, true);
VersionedPCPoint p4tx2 = (VersionedPCPoint)pm2.getObjectById(p4oid, true);
VersionedPCPoint p5tx2 = (VersionedPCPoint)pm2.getObjectById(p5oid, true);
p1tx2.setX(102);
pm2.deletePersistent(p2tx2);
p3tx2.setX(202);
pm2.deletePersistent(p4tx2);
p5tx2.setX(502); // this change must not be committed
Set expectedFailedObjects = new HashSet();
expectedFailedObjects.add(p1tx2);
expectedFailedObjects.add(p2tx2);
expectedFailedObjects.add(p3tx2);
expectedFailedObjects.add(p4tx2);
// commit tx1 (should succeed)
tx1.commit();
tx1 = null;
// commit tx2 (should fail)
try {
tx2.commit();
fail(ASSERTION_FAILED, "concurrent commit not detected");
}
catch (JDOOptimisticVerificationException ex) {
// verify the correct information in the exception
Throwable[] ts = ex.getNestedExceptions();
int length = ts==null ? 0 : ts.length;
int expectedFailures = expectedFailedObjects.size();
if (length != expectedFailures) {
fail(ASSERTION_FAILED,
"Nested exceptions[] wrong size: expected " +
expectedFailures + ", got " + length);
}
for (int i = 0; i < length; ++i) {
Throwable t = ts[i];
if (t instanceof JDOOptimisticVerificationException) {
if (debug)
logger.debug("Expected exception caught " + t.toString());
JDOException jex = (JDOException)t;
Object failed = jex.getFailedObject();
if (failed == null) {
fail(ASSERTION_FAILED,
"Found unexpected null in failed object");
}
else {
if (expectedFailedObjects.remove(failed)) {
if (debug)
logger.debug("Found expected failed instance, oid: " +
JDOHelper.getObjectId(failed));
}
else {
fail(ASSERTION_FAILED,
"Unexpected failed instance: " + failed.toString());
}
}
}
else {
fail(ASSERTION_FAILED,
"Unexpected nested exception: " + t.toString());
}
}
}
tx2 = null;
tx3.begin();
VersionedPCPoint p1tx3 = (VersionedPCPoint)pm3.getObjectById(p1oid, true);
VersionedPCPoint p2tx3 = (VersionedPCPoint)pm3.getObjectById(p2oid, true);
VersionedPCPoint p5tx3 = (VersionedPCPoint)pm3.getObjectById(p5oid, true);
verify(p1tx3, 101);
verify(p2tx3, 201);
verify(p5tx3, 5);
tx3.commit();
tx3 = null;
}
finally {
if ((tx3 != null) && tx3.isActive())
tx3.rollback();
if ((tx2 != null) && tx2.isActive())
tx2.rollback();
if ((tx1 != null) && tx1.isActive())
tx1.rollback();
}
}
/** */
protected void verify(VersionedPCPoint p, int value) {
if (p.getX() != value) {
fail(ASSERTION_FAILED,
"VersionedPCPoint has wrong value: expected " + value + ", got " + p.getX());
}
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanager/PersistenceManagerTest.java 100664 6653 12500110374 30652 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.company.Company;
import org.apache.jdo.tck.pc.company.Department;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.pc.mylib.PCPoint2;
import org.apache.jdo.tck.pc.mylib.PCRect;
public abstract class PersistenceManagerTest extends JDO_Test {
/** */
protected PersistenceManagerTest() { }
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
// The order of addTearDownClass calls is significant
// as it takes into account database FKs.
addTearDownClass(PCRect.class);
addTearDownClass(PCPoint.class);
addTearDownClass(Department.class);
addTearDownClass(Company.class);
}
/** */
protected Object createPCPointInstance(PersistenceManager pm) {
PCPoint p1 = new PCPoint(8,8);
Transaction tx = pm.currentTransaction();
tx.begin();
pm.makePersistent(p1);
Object oid = pm.getObjectId(p1);
tx.commit();
return oid;
}
/** */
public void deletePCPointInstance (PersistenceManager pm, Object oid) {
Transaction tx = pm.currentTransaction();
tx.begin();
Object p1 = pm.getObjectById(oid, true);
pm.deletePersistent(p1);
tx.commit();
}
/** */
public boolean testState(PCPoint obj, int expectState, String str) {
int actualState = currentState(obj);
if (actualState != expectState) {
if (debug) {
logger.debug(" Object not in " + str + " state for X = " +
obj.getX());
logger.debug(" current state: " + actualState +
" expected state: " + expectState);
}
return false;
}
return true;
}
/** */
public boolean testState(PCPoint2 obj, int expectState, String str) {
int actualState = currentState(obj);
if (actualState != expectState) {
if (debug) {
logger.debug(" Object not in " + str + " state for X = " +
obj.getX() );
logger.debug(" current state: " + actualState +
" expected state: " + expectState);
}
return false;
}
return true;
}
/** */
public void assertGetX(PCPoint p, int value, String assertion, String label) {
if (p.getX() != value) {
fail(assertion, label);
}
}
}
././@LongLink 100644 0 0 163 12500111677 10253 L ustar 0 0 tck/src/java/org/apache/jdo/tck/api/persistencemanager/SameTransactionInstanceForAllCallsToCurrentTransaction.java tck/src/java/org/apache/jdo/tck/api/persistencemanager/SameTransactionInstanceForAllCallsToCurrentTr100664 5213 12500110374 34315 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Same Transaction Instance For All Calls To Current Transaction
*Keywords:
*Assertion ID: A12.5.2-2.
*Assertion Description:
The identical Transaction instance will be returned by all
currentTransaction calls to the same PersistenceManager
until close.
*/
public class SameTransactionInstanceForAllCallsToCurrentTransaction extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.5.2-2 (SameTransactionInstanceForAllCallsToCurrentTransaction) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(SameTransactionInstanceForAllCallsToCurrentTransaction.class);
}
/** */
public void test() {
pm = getPM();
Transaction tx1 = getPM().currentTransaction();
tx1.begin();
Transaction tx2 = getPM().currentTransaction();
tx1.commit();
Transaction tx3 = getPM().currentTransaction();
if (tx1 != tx2) {
fail(ASSERTION_FAILED,
"tx1 before begin different from tx2 after begin");
}
if (tx2 != tx3) {
fail(ASSERTION_FAILED,
"tx2 after begin different from tx3 after commit");
}
if (!pm.isClosed()) {
if (pm.currentTransaction().isActive()) {
pm.currentTransaction().rollback();
}
pm.close();
}
pm = null;
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanager/ThreadSafe.java 100664 15737 12500110374 26264 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import javax.jdo.JDOUserException;
import javax.jdo.PersistenceManager;
import javax.jdo.PersistenceManagerFactory;
import javax.jdo.Transaction;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
import org.apache.jdo.tck.util.ThreadExceptionHandler;
import org.apache.jdo.tck.util.RogueBarrier;
/**
*Title: Thread Safe
*Keywords: multithreaded
*Assertion ID: A12.4-1.
*Assertion Description:
It is a requirement for all JDO implementations to be thread-safe. That is, the behavior of the implementation must be predictable in the presence of multiple application threads. This assertion will generate multiple test cases to be evaluated.
*/
public class ThreadSafe extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.4-1 (ThreadSafe) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(ThreadSafe.class);
}
private final int threadCount = 10;
private final ThreadExceptionHandler group = new ThreadExceptionHandler();
private final RogueBarrier barrier = new RogueBarrier(threadCount);
private int successCount = 0;
private int exceptionCount = 0;
/** */
public void testThreadSafe() throws Exception {
if (debug) logger.debug("\nSTART testThreadSafe");
// test thread-safety of PMF.getPersistenceManager():
// pmf.getPM(), pm.close()
final PCPoint[] nullPC = new PCPoint[threadCount];
runThreads(nullPC, "Concurrent PMF.getPersistenceManager()",
threadCount);
// test thread-safety of PMF.getPersistenceManager():
// pmf.getPM(), pm.makePersistent(private transient PC), pm.close()
final PCPoint[] localPC = new PCPoint[threadCount];
for (int i = 0; i < threadCount; i++) {
localPC[i] = new PCPoint(1,i);
}
runThreads(localPC, "Concurrent PMF.getPersistenceManager()"
+ ".makePersistent()", threadCount);
// test thread-safety of PM.makePersistent():
// pmf.getPM(), pm.makePersistent(shared transient PC), pm.close()
final PCPoint[] sharedPC = new PCPoint[threadCount];
final PCPoint p1 = new PCPoint(3,3);
for (int i = 0; i < threadCount; i++) {
sharedPC[i] = p1;
}
runThreads(sharedPC, "Concurrent PM.makePersistent("
+ "shared transient PC)", 1);
}
/** */
public void runThreads(Object[] pc, String header, int toSucceed) {
// start threads with their pc instance
final Thread[] threads = new Thread[threadCount];
for (int i = 0; i < threadCount; i++) {
Thread t = new Thread(group, new PMThread(pc[i]));
t.setName("ThreadSafeID-" + i);
threads[i] = t;
t.start();
}
// wait for all threads to finish
for (int i = 0; i < threadCount; i++) {
while (true) {
try {
threads[i].join();
break;
} catch (InterruptedException e) { // swallow
}
}
}
checkResults(header, toSucceed);
}
/** */
protected synchronized void checkResults(String header, int toSucceed) {
// check unhandled exceptions
final Set uncaught = group.getAllUncaughtExceptions();
if ((uncaught != null) && !uncaught.isEmpty()) {
StringBuffer report = new StringBuffer("Uncaught exceptions:\n");
for (Iterator i = uncaught.iterator(); i.hasNext();) {
Map.Entry next = (Map.Entry)i.next();
Thread thread = (Thread)next.getKey();
Throwable problem = (Throwable)next.getValue();
report.append(header + ": Uncaught exception " + problem
+ " in thread " + thread + "\n");
}
fail(ASSERTION_FAILED, report.toString());
group.clear();
}
// check success count
if (successCount != toSucceed) {
fail(ASSERTION_FAILED, header + ": Incorrect number of "
+ "\"succeeding\" threads; expected=" + toSucceed
+ " found=" + successCount);
}
successCount = 0;
// check exception count
final int toExcept = threadCount - toSucceed;
if (exceptionCount != toExcept) {
fail(ASSERTION_FAILED, header + ": Incorrect number of "
+ "\"failing\" threads; expected=" + toExcept
+ " found=" + exceptionCount);
}
exceptionCount = 0;
}
/** */
protected synchronized void markSuccess() {
logger.debug("[" + Thread.currentThread().getName() + "]: success");
successCount++;
}
/** */
protected synchronized void markExpectedException() {
logger.debug("[" + Thread.currentThread().getName() + "]: expected exception");
exceptionCount++;
}
/** */
class PMThread implements Runnable {
private final Object pc;
/** */
PMThread(Object pc) {
this.pc = pc;
}
/** */
public void run() {
ThreadSafe.this.logger.debug("[" + Thread.currentThread().getName()
+ "]: running");
final PersistenceManager pm = pmf.getPersistenceManager();
try {
Transaction tx = pm.currentTransaction();
tx.begin();
if (pc != null) {
pm.makePersistent(pc);
}
tx.commit();
markSuccess();
} catch (JDOUserException ex) {
markExpectedException();
} finally {
barrier.await();
cleanupPM(pm);
}
}
}
}
././@LongLink 100644 0 0 160 12500111677 10250 L ustar 0 0 tck/src/java/org/apache/jdo/tck/api/persistencemanager/TransientTransactionalInstanceRetainsValuesAtCommit.java tck/src/java/org/apache/jdo/tck/api/persistencemanager/TransientTransactionalInstanceRetainsValuesAt100664 12155 12500110374 34477 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanager;
import java.util.Collection;
import java.util.HashSet;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Transient Transactional Instance Retains Values At Commit
*Keywords: transienttransactional
*Assertion ID: A12.5.7-21
*Assertion Description:
If the transaction in which an instance is made transactional (by calling PersistenceManager.makeTransactional or makeTransactionalAll) commits, then the transient instance retains its values.
*/
public class TransientTransactionalInstanceRetainsValuesAtCommit extends PersistenceManagerTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A12.5.7-21 (TransientTransactionalInstanceRetainsValuesAtCommit) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(TransientTransactionalInstanceRetainsValuesAtCommit.class);
}
private PCPoint p1 = null;
private PCPoint p2 = null;
private PCPoint p3 = null;
private PCPoint p4 = null;
private PCPoint p5 = null;
private Collection col1 = new HashSet();
private Collection col2 = new HashSet();
/** */
public void testTransientTransactionalInstanceRetainsValuesAtCommit() {
pm = getPM();
createObjects(pm);
runTestTransientTransactional1(pm);
runTestTransientTransactional2(pm);
runTestTransientTransactional3(pm);
pm.close();
pm = null;
}
/** */
private void createObjects(PersistenceManager pm) {
p1 = new PCPoint(1,3);
p2 = new PCPoint(2,4);
p3 = new PCPoint(3,5);
p4 = new PCPoint(4,6);
p5 = new PCPoint (5,7);
col1.add(p2);
col1.add(p3);
col2.add(p4);
col2.add(p5);
}
/** */
private void runTestTransientTransactional1(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
if (debug) logger.debug(" ** in runTestTransientTransactional1() ");
try {
PCPoint p1 = new PCPoint(8,8);
p1.setX(100);
tx.begin();
p1.setX(200);
pm.makeTransactional(p1);
p1.setX(300);
tx.commit();
tx = null;
assertGetX (p1, 300, ASSERTION_FAILED, "runTestTransientTransactional1");
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
/** */
private void runTestTransientTransactional2(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
if (debug) logger.debug(" ** in runTestTransientTransactional2() ");
try {
p2.setX(100);
p3.setX(100);
tx.begin();
p2.setX(201);
p3.setX(201);
pm.makeTransactionalAll(col1);
p2.setX(301);
p3.setX(301);
tx.commit();
tx = null;
assertGetX (p2, 301, ASSERTION_FAILED, "runTestTransientTransactional2");
assertGetX (p3, 301, ASSERTION_FAILED, "runTestTransientTransactional2");
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
/** */
private void runTestTransientTransactional3(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
if (debug) logger.debug(" ** in runTestTransientTransactional3() ");
try {
p4.setX(100);
p5.setX(100);
tx.begin();
p4.setX(201);
p5.setX(201);
pm.makeTransactionalAll(col2.toArray());
p4.setX(301);
p5.setX(301);
tx.commit();
tx = null;
assertGetX (p4, 301, ASSERTION_FAILED, "runTestTransientTransactional2");
assertGetX (p5, 301, ASSERTION_FAILED, "runTestTransientTransactional2");
}
finally {
if ((tx != null) && tx.isActive())
tx.rollback();
}
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanagerfactory/AbstractGetPMF.java 100664 16434 12500110374 30407 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanagerfactory;
import java.lang.reflect.Method;
import java.io.File;
import java.util.Iterator;
import java.util.Map.Entry;
import java.util.Properties;
import java.util.Set;
import javax.jdo.JDOFatalUserException;
import javax.jdo.PersistenceManagerFactory;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.mylib.PCPoint;
/**
* The abstract super class for all GetPMF test cases.
* @author Michael Watzek
*/
abstract class AbstractGetPMF extends JDO_Test {
/**
* Used as the PMF name in positive tests.
* The variable is set to test/conf/jdori.properties.
* This file contains valid JDO properties.
*/
protected static final String validPropertiesFile = PMFProperties;
/**
* Used as the PMF name in negative tests.
* The variable is set to test/conf/logging.properties.
* This file does not contain valid JDO properties.
*/
/* protected static final String invalidPropertiesFile =
validPropertiesFile.substring(0, validPropertiesFile.lastIndexOf(File.separatorChar)+1) +
"logging.properties";
*/
protected static String invalidPropertiesFile;
static
{
if (validPropertiesFile==null)
System.out.println ("******************************");
invalidPropertiesFile = validPropertiesFile.substring(0, validPropertiesFile.lastIndexOf(File.separatorChar)+1) +
"logging.properties";
}
/**
* Used as the PMF name in positive JNDI tests.
* The variable is set to jdori.properties.
* This resource contains valid JDO properties.
*/
protected static final String jndiName =
validPropertiesFile.substring(0, validPropertiesFile.lastIndexOf(File.separatorChar)+1) +
"pmf.ser";
/**
* Removing the path prefix from argument name.
* @return argument name removed by the path prefix.
*/
protected String removePathPrefix(String name) {
int index = name.lastIndexOf(File.separatorChar);
if (index!=-1) {
name = name.substring(index+1);
}
return name;
}
protected void makePersistent() {
addTearDownClass(PCPoint.class);
pm = pmf.getPersistenceManager();
Transaction tx = pm.currentTransaction();
tx.begin();
PCPoint comp = new PCPoint(1, 2);
pm.makePersistent(comp);
tx.commit();
}
/**
* Returns pmf instance for the given name.
* Subclasses may use argument name as file name,
* resource name etc.
* @param name the name
* @return the pmf instance
*/
protected abstract PersistenceManagerFactory getPMF(String name);
/**
* This method creates a PMF calling
* method AbstractGetPMF#getPMF(name).
* It passes an name of an invalid properties file as parameter.
* The method expects the PMF creation to fail.
* @param assertionMessage the assertion message if the test fails.
*/
protected void checkGetPMFWithInvalidProperties(String assertionMessage) {
try {
pmf = getPMF(invalidPropertiesFile);
fail(assertionMessage);
} catch (JDOFatalUserException e) {
// expected exception
if (debug)
logger.debug("caught expected exception " + e.toString());
}
}
/**
* This method creates a PMF calling
* method AbstractGetPMF#getPMF(name).
* It passes an name of a valid properties file as parameter.
* The method expects the PMF creation to succeed.
*/
protected void checkGetPMFWithValidProperties() {
pmf = getPMF(validPropertiesFile);
verifyProperties(pmf, loadProperties(validPropertiesFile));
makePersistent();
}
/**
* Verify that the Properties are correctly set in the PMF.
*/
protected void verifyProperties(PersistenceManagerFactory pmf,
Properties props) {
Object[] noArgs = new Object[]{};
String javaxjdooption = "javax.jdo.option.";
Class pmfclass = pmf.getClass();
Set entries = props.entrySet();
StringBuffer buffer = new StringBuffer();
for (Iterator it = entries.iterator(); it.hasNext();) {
Entry entry = (Entry)it.next();
String key = (String)entry.getKey();
if (key.equals("javax.jdo.option.ConnectionPassword")) {
continue;
}
if (key.equals("javax.jdo.option.ConnectionUserName")) {
continue;
}
String expected = (String)entry.getValue();
if (key.startsWith(javaxjdooption)) {
String optionName = key.substring(javaxjdooption.length());
Method getMethod = getGetMethod(pmfclass, optionName);
Object actual = getValue(getMethod, pmf, noArgs);
if (actual == null) {
buffer.append("\n");
buffer.append("Key ");
buffer.append(key);
buffer.append(" was null.");
continue;
}
String actualString = actual.toString();
if (!expected.equals(actualString)) {
buffer.append("\n");
buffer.append("Key ");
buffer.append(key);
buffer.append(" expected: \"");
buffer.append(expected);
buffer.append("\" actual: \"");
buffer.append(actual);
buffer.append("\".");
}
}
}
if (buffer.length() != 0) {
fail(buffer.toString());
}
}
/** Get the "get" method corresponding to the option name.
*/
Method getGetMethod(Class cls, String optionName) {
try {
return cls.getMethod("get" + optionName, new Class[]{});
} catch (Exception ex) {
fail("Unexpected exception thrown from getMethod on PMF class with option name" +
optionName);
return null;
}
}
/**
* Get the result of executing the Method.
*/
Object getValue(Method method, Object obj, Object[] args) {
try {
return method.invoke(obj, args);
} catch (Exception ex) {
fail("Unexpected exception executing method " +
method.getName() + ".");
return null;
}
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanagerfactory/AfterCloseGetPMThrowsException.java 100664 5453 12500110374 33632 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanagerfactory;
import javax.jdo.JDOFatalUserException;
import javax.jdo.JDOUserException;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: AfterCloseGetPMThrowsException of PersistenceManagerFactory
*Keywords: persistencemanagerfactory
*Assertion IDs: A11.4-9B.
*Assertion Description:
* PersistenceManagerFactory.getPersistenceManager() throws
* JDOUserException after the PersistenceManagerFactory is closed.
*/
/*
* Revision History
* ================
* Author : Craig Russell
* Date : 05/16/03
*
*/
public class AfterCloseGetPMThrowsException extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A11.4-9B (AfterCloseGetPMThrowsException) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(AfterCloseGetPMThrowsException.class);
}
/** */
public void test() {
try {
pmf = getPMF();
closePMF(pmf); // don't use closePMF() because that sets pmf to null
pm = pmf.getPersistenceManager();
fail(ASSERTION_FAILED,
"pmf.getPersistenceManager should throw JDOUserException if pmf is closed.");
} catch (JDOUserException ex) {
// expected exception
if (debug)
logger.debug("caught expected exception " + ex.toString());
} catch (JDOFatalUserException ex) {
// unexpected exception
fail(ASSERTION_FAILED,
"Wrong exception thrown from getPersistenceManager after close.\n" +
"Expected JDOUserException, got JDOFatalUserException.");
} finally {
if (pm != null)
pm.close();
}
}
}
././@LongLink 100644 0 0 146 12500111677 10254 L ustar 0 0 tck/src/java/org/apache/jdo/tck/api/persistencemanagerfactory/AfterCloseSetMethodsThrowException.java tck/src/java/org/apache/jdo/tck/api/persistencemanagerfactory/AfterCloseSetMethodsThrowException.jav100664 23167 12500110374 34433 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanagerfactory;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;
import javax.jdo.JDOFatalInternalException;
import javax.jdo.JDOUserException;
import javax.jdo.PersistenceManagerFactory;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: AfterCloseSetMethodsThrowException
*Keywords: persistencemanagerfactory
*Assertion IDs: A11.4-9A.
*Assertion Description:
* If a set method is called after close, then JDOUserException is thrown.
*/
/*
* Revision History
* ================
* Author : Craig Russell
* Date : 05/16/03
*
*/
public class AfterCloseSetMethodsThrowException extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A11.4-9A (AfterCloseSetMethodsThrowException) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(AfterCloseSetMethodsThrowException.class);
}
/** */
public void test() {
Class[] stringParameters = new Class[]{String.class};
Class[] booleanParameters = new Class[]{boolean.class};
Class[] objectParameters = new Class[]{Object.class};
Class[] integerParameters = new Class[]{Integer.class};
Object[] stringParameter = new Object[]{"Nobody knows the trouble"};
Object[] booleanParameter = new Object[]{new Boolean(false)};
Object[] objectParameter = new Object[]{null};
Object[] integerParameter = new Object[]{new Integer(0)};
SetProperty[] setMethods = new SetProperty[] {
new SetProperty("setConnectionDriverName", stringParameters, stringParameter),
new SetProperty("setConnectionFactory", objectParameters, objectParameter),
new SetProperty("setConnectionFactory2", objectParameters, objectParameter),
new SetProperty("setConnectionFactoryName", stringParameters, stringParameter),
new SetProperty("setConnectionFactory2Name", stringParameters, stringParameter),
new SetProperty("setConnectionPassword", stringParameters, stringParameter),
new SetProperty("setConnectionURL", stringParameters, stringParameter),
new SetProperty("setConnectionUserName", stringParameters, stringParameter),
new SetProperty("setCopyOnAttach", booleanParameters, booleanParameter),
new SetProperty("setDetachAllOnCommit", booleanParameters, booleanParameter),
new SetProperty("setIgnoreCache", booleanParameters, booleanParameter),
new SetProperty("setMapping", stringParameters, stringParameter),
new SetProperty("setMultithreaded", booleanParameters, booleanParameter),
new SetProperty("setName", stringParameters, stringParameter),
new SetProperty("setNontransactionalRead", booleanParameters, booleanParameter),
new SetProperty("setNontransactionalWrite", booleanParameters, booleanParameter),
new SetProperty("setOptimistic", booleanParameters, booleanParameter),
new SetProperty("setPersistenceUnitName", stringParameters, stringParameter),
new SetProperty("setReadOnly", booleanParameters, booleanParameter),
new SetProperty("setRestoreValues", booleanParameters, booleanParameter),
new SetProperty("setRetainValues", booleanParameters, booleanParameter),
new SetProperty("setServerTimeZoneID", stringParameters, stringParameter),
new SetProperty("setTransactionIsolationLevel", stringParameters, stringParameter),
new SetProperty("setTransactionType", stringParameters, stringParameter)
};
GetProperty[] getMethods = new GetProperty[] {
new GetProperty("getConnectionDriverName"),
new GetProperty("getConnectionFactory"),
new GetProperty("getConnectionFactory2"),
new GetProperty("getConnectionFactoryName"),
new GetProperty("getConnectionFactory2Name"),
new GetProperty("getConnectionURL"),
new GetProperty("getConnectionUserName"),
new GetProperty("getCopyOnAttach"),
new GetProperty("getDataStoreCache"),
new GetProperty("getDetachAllOnCommit"),
new GetProperty("getFetchGroups"),
new GetProperty("getIgnoreCache"),
new GetProperty("getMapping"),
new GetProperty("getMultithreaded"),
new GetProperty("getName"),
new GetProperty("getNontransactionalRead"),
new GetProperty("getNontransactionalWrite"),
new GetProperty("getOptimistic"),
new GetProperty("getPersistenceUnitName"),
new GetProperty("getProperties"),
new GetProperty("getReadOnly"),
new GetProperty("getRestoreValues"),
new GetProperty("getRetainValues"),
new GetProperty("getServerTimeZoneID"),
new GetProperty("getTransactionIsolationLevel"),
new GetProperty("getTransactionType")
};
pmf = getPMF();
closePMF(pmf); // don't use closePMF() because that sets pmf to null
// each set method should throw an exception
Collection setCollection = Arrays.asList(setMethods);
for (Iterator it = setCollection.iterator(); it.hasNext();) {
SetProperty sp = (SetProperty)it.next();
String where = sp.getMethodName();
try {
sp.execute(pmf);
fail(ASSERTION_FAILED,
"pmf method " + where + " should throw JDOUserException when called for closed pmf");
} catch (JDOUserException ex) {
if (debug)
logger.debug("Caught expected exception " + ex.toString() +
" from " + where);
} catch (Exception ex) {
fail(ASSERTION_FAILED,
"Caught unexpected exception " + ex.toString() + " from " + where);
}
}
// each get method should succeed
Collection getCollection = Arrays.asList(getMethods);
for (Iterator it = getCollection.iterator(); it.hasNext();) {
GetProperty gp = (GetProperty)it.next();
String where = gp.getMethodName();
try {
gp.execute(pmf);
} catch (Exception ex) {
fail(ASSERTION_FAILED,
"Caught unexpected exception " + ex.toString() + " from " +
where);
}
}
}
/** */
class SetProperty {
java.lang.reflect.Method method;
String methodName;
Class[] parameters;
Object[] parameter;
SetProperty(String methodName, Class[] parameters, Object[] parameter) {
this.methodName = methodName;
this.parameters = parameters;
this.parameter = parameter;
try {
method = PersistenceManagerFactory.class.getMethod(methodName, parameters);
} catch (NoSuchMethodException ex) {
throw new JDOFatalInternalException("Method not defined: " + methodName);
}
}
void execute(PersistenceManagerFactory pmf) {
try {
method.invoke(pmf, parameter);
} catch (IllegalAccessException ex) {
throw new JDOFatalInternalException("IllegalAccessException", ex);
} catch (java.lang.reflect.InvocationTargetException ex) {
throw (RuntimeException)ex.getTargetException();
}
}
String getMethodName() {
return methodName;
}
}
/** */
class GetProperty {
java.lang.reflect.Method method;
String methodName;
GetProperty(String methodName) {
this.methodName = methodName;
try {
method = PersistenceManagerFactory.class.getMethod(methodName,
(Class[])null);
} catch (NoSuchMethodException ex) {
throw new JDOFatalInternalException("Method not defined: " + methodName);
}
}
void execute(PersistenceManagerFactory pmf) {
try {
method.invoke(pmf, (Object[])null);
} catch (IllegalAccessException ex) {
throw new JDOFatalInternalException("IllegalAccessException", ex);
} catch (java.lang.reflect.InvocationTargetException ex) {
throw (RuntimeException)ex.getTargetException();
}
}
String getMethodName() {
return methodName;
}
}
}
././@LongLink 100644 0 0 161 12500111677 10251 L ustar 0 0 tck/src/java/org/apache/jdo/tck/api/persistencemanagerfactory/AfterGetPersistenceManagerNoSetMethodsSucceed.java tck/src/java/org/apache/jdo/tck/api/persistencemanagerfactory/AfterGetPersistenceManagerNoSetMethods100664 21103 12500110374 34404 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanagerfactory;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;
import java.util.Properties;
import javax.jdo.JDOException;
import javax.jdo.JDOFatalInternalException;
import javax.jdo.JDOUserException;
import javax.jdo.PersistenceManagerFactory;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: After GetPersistenceManager No Set Methods Succeed
*Keywords:
*Assertion ID: A11.3-3.
*Assertion Description:
* After the first use of
* PersistenceManagerFactory.getPersistenceManager(),
* none of the set methods will succeed.
*/
public class AfterGetPersistenceManagerNoSetMethodsSucceed extends JDO_Test {
private String username;
private String password;
private Class[] stringParameters = null;
private Class[] booleanParameters = null;
private Object[] stringParameter = null;
private Object[] booleanParameter = null;
private SetProperty[] setMethods = null;
private GetProperty[] getMethods = null;
/** */
private static final String ASSERTION_FAILED =
"Assertion A11.3-3 (AfterGetPersistenceManagerNoSetMethodsSucceed) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(AfterGetPersistenceManagerNoSetMethodsSucceed.class);
}
/** */
public AfterGetPersistenceManagerNoSetMethodsSucceed() {
super();
initVariables();
}
/** */
public void initVariables() {
stringParameters = new Class[]{String.class};
booleanParameters = new Class[]{boolean.class};
stringParameter = new Object[]{"Nobody knows the trouble"};
booleanParameter = new Object[]{Boolean.FALSE};
setMethods = new SetProperty[] {
new SetProperty("setConnectionDriverName", stringParameters, stringParameter),
new SetProperty("setConnectionFactoryName", stringParameters, stringParameter),
new SetProperty("setConnectionFactory2Name", stringParameters, stringParameter),
new SetProperty("setConnectionURL", stringParameters, stringParameter),
new SetProperty("setConnectionUserName", stringParameters, stringParameter),
new SetProperty("setConnectionPassword", stringParameters, stringParameter),
new SetProperty("setIgnoreCache", booleanParameters, booleanParameter),
new SetProperty("setMultithreaded", booleanParameters, booleanParameter),
new SetProperty("setNontransactionalRead", booleanParameters, booleanParameter),
new SetProperty("setNontransactionalWrite", booleanParameters, booleanParameter),
new SetProperty("setOptimistic", booleanParameters, booleanParameter),
new SetProperty("setRestoreValues", booleanParameters, booleanParameter),
new SetProperty("setRetainValues", booleanParameters, booleanParameter)
};
getMethods = new GetProperty[] {
new GetProperty("getConnectionDriverName"),
new GetProperty("getConnectionFactoryName"),
new GetProperty("getConnectionFactory2Name"),
new GetProperty("getConnectionURL"),
new GetProperty("getConnectionUserName"),
new GetProperty("getIgnoreCache"),
new GetProperty("getMultithreaded"),
new GetProperty("getNontransactionalRead"),
new GetProperty("getNontransactionalWrite"),
new GetProperty("getOptimistic"),
new GetProperty("getRestoreValues"),
new GetProperty("getRetainValues")
};
}
/** */
public void testGetPersistenceManagerWithNoParametes() {
runTest(false);
}
/** */
public void testGetPersistenceManagerWithParameters() {
Properties props = loadProperties(PMFProperties);
username = props.getProperty(CONNECTION_USERNAME_PROP);
password = props.getProperty(CONNECTION_PASSWORD_PROP);
runTest(true);
}
/** */
public void runTest(boolean bUserAndPasswd) {
pmf = getPMF();
if (!bUserAndPasswd)
pm = getPM();
else
pm = getPMF().getPersistenceManager(username,password);
// each set method should throw an exception
Collection setCollection = Arrays.asList(setMethods);
for (Iterator it = setCollection.iterator(); it.hasNext();) {
SetProperty sp = (SetProperty)it.next();
String where = sp.getMethodName();
try {
sp.execute(pmf);
fail(ASSERTION_FAILED,
"pmf method " + where +
" should throw JDOUserException when called after getPersistenceManager");
} catch (JDOUserException ex) {
if (debug)
logger.debug("Caught expected exception " + ex.toString() + " from " + where);
}
}
// each get method should succeed
Collection getCollection = Arrays.asList(getMethods);
for (Iterator it = getCollection.iterator(); it.hasNext();) {
GetProperty gp = (GetProperty)it.next();
String where = gp.getMethodName();
try {
gp.execute(pmf);
} catch (JDOUserException ex) {
fail(ASSERTION_FAILED,
"Caught unexpected exception " + ex.toString() + " from " + where);
}
}
}
/** */
static class SetProperty {
java.lang.reflect.Method method;
String methodName;
Class[] parameters;
Object[] parameter;
SetProperty(String methodName, Class[] parameters, Object[] parameter) {
this.methodName = methodName;
this.parameters = parameters;
this.parameter = parameter;
try {
method = PersistenceManagerFactory.class.getMethod(methodName, parameters);
} catch (NoSuchMethodException ex) {
throw new JDOFatalInternalException("Method not defined: " + methodName);
}
}
void execute(PersistenceManagerFactory pmf) {
try {
method.invoke(pmf, parameter);
} catch (IllegalAccessException ex) {
throw new JDOFatalInternalException("IllegalAccessException", ex);
} catch (java.lang.reflect.InvocationTargetException ex) {
throw (JDOException)ex.getTargetException();
}
}
String getMethodName() {
return methodName;
}
}
/** */
static class GetProperty {
java.lang.reflect.Method method;
String methodName;
GetProperty(String methodName) {
this.methodName = methodName;
try {
method = PersistenceManagerFactory.class.getMethod(methodName,
(Class[])null);
} catch (NoSuchMethodException ex) {
throw new JDOFatalInternalException(
"Method not defined: " + methodName);
}
}
void execute(PersistenceManagerFactory pmf) {
try {
method.invoke(pmf, (Object[])null);
} catch (IllegalAccessException ex) {
throw new JDOFatalInternalException("IllegalAccessException", ex);
} catch (java.lang.reflect.InvocationTargetException ex) {
throw (JDOException)ex.getTargetException();
}
}
String getMethodName() {
return methodName;
}
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanagerfactory/Close.java 100664 10770 12500110374 26703 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanagerfactory;
import java.security.AccessController;
import java.security.PrivilegedAction;
import javax.jdo.JDOFatalUserException;
import javax.jdo.JDOUserException;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Close of PersistenceManagerFactory
*Keywords: persistencemanagerfactory
*Assertion IDs: A11.4-2, A11.4-10
*Assertion Description:
* PersistenceManagerFactory.close() closes this PersistenceManagerFactory.
*Assertion Description:
* PersistenceManagerFactory.isClosed(); Return true if this PersistenceManagerFactory is closed; and false otherwise.
*/
public class Close extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertions A11.4-2 (Close), A11.4-10 (isClosed) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(Close.class);
}
/** */
public void test() {
pmf = getPMF();
// check pmf.isClosed() before and after pmf.close()
try {
if (pmf.isClosed()) {
fail(ASSERTION_FAILED,
"PMF.isClosed() returned true on an open pmf");
}
closePMF(pmf); // don't use closePMF() because that sets pmf to null
if (!pmf.isClosed()) {
fail(ASSERTION_FAILED,
"PMF.isClosed() returned false on a closed pmf");
}
} catch (JDOUserException ex) {
// unexpected exception
fail(ASSERTION_FAILED,
"Unexpected exception at pmf.close()/isClosed(): " + ex);
} catch (JDOFatalUserException ex) {
// unexpected exception
fail(ASSERTION_FAILED,
"Unexpected exception at pmf.close()/isClosed(): " + ex);
}
// pmf.close() on already-closed pmf should not throw an exception
try {
// don't use closePMF methods because they check isClosed before calling
AccessController.doPrivileged(
new PrivilegedAction () {
public Object run () {
pmf.close();
return null;
}
}
);
} catch (JDOUserException ex) {
// unexpected exception
fail(ASSERTION_FAILED,
"Unexpected exception at repeated pmf.close(): " + ex);
} catch (JDOFatalUserException ex) {
// unexpected exception
fail(ASSERTION_FAILED,
"Unexpected exception at repeated pmf.close(): " + ex);
}
// trying to get a getPersistenceManager should result in a exception
try {
pm = pmf.getPersistenceManager();
fail(ASSERTION_FAILED,
"JDOUserException was not thrown when calling pmf.getPersistenceManager() after pmf was closed");
} catch (JDOUserException ex) {
// expected exception
if (debug) {
logger.debug("caught expected exception " + ex.toString());
}
} catch (JDOFatalUserException ex) {
// unexpected exception
fail(ASSERTION_FAILED,
"Wrong exception thrown from getPersistenceManager after close.\n" +
"Expected JDOUserException, got JDOFatalUserException.");
}
// have next invocation of getPMF() get a new pmf
pmf = null;
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanagerfactory/CloseFailsIfTransactionActive.java 100664 16651 12500110374 33507 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanagerfactory;
import javax.jdo.JDOException;
import javax.jdo.JDOUserException;
import javax.jdo.PersistenceManager;
import javax.jdo.PersistenceManagerFactory;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: CloseFailsIfTransactionActive of PersistenceManagerFactory
*Keywords: persistencemanagerfactory
*Assertion IDs: A11.4-4.
*Assertion Description:
* PersistenceManagerFactory.getPersistenceManager() throws
* JDOUserException after the PersistenceManagerFactory is closed.
* The exception contains an array of nested exceptions; each nested
* exception contains as its failed object the PersistenceManager whose
* Transaction is still active.
* During close of the PersistenceManagerFactory, all PersistenceManager
* instances obtained from this PersistenceManagerFactory are
* themselves closed.
*/
/*
* Revision History
* ================
* Author : Craig Russell
* Date : 05/16/03
*
*/
public class CloseFailsIfTransactionActive extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A11.4-4 (CloseFailsIfTransactionActive) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(CloseFailsIfTransactionActive.class);
}
protected boolean aborted = false;
/** */
public void test() {
PersistenceManager pm1 = null;
PersistenceManager pm2 = null;
cleanupPMF(getPMF());
pmf = null;
try {
pm1 = getPM();
pm2 = getPM();
pm1.currentTransaction().begin();
pm1.currentTransaction().commit();
pm2.currentTransaction().begin();
closePMF(pmf); // don't use closePMF() because that sets pmf to null
setAborted();
fail(ASSERTION_FAILED,
"Close incorrectly succeeded with active transaction");
}
catch (JDOUserException ex) {
try {
if (debug)
logger.debug("Caught expected exception " + ex.getMessage());
PersistenceManager[] pms = getFailedPersistenceManagers(ex);
if (pms.length != 1) {
setAborted();
fail(ASSERTION_FAILED,
"Unexpected number of nested exceptions: " + pms.length);
}
else {
Object failed = pms[0];
if (pm2.equals(failed)) {
if (debug)
logger.debug("Found expected failed object " +
failed.toString());
}
else {
setAborted();
fail(ASSERTION_FAILED,
"Found unexpected failed object " +
failed.toString());
}
}
if (pm1.isClosed()){
fail(ASSERTION_FAILED, "Unexpected pm1 is closed.");
}
if (pm2.isClosed()){
fail(ASSERTION_FAILED, "Unexpected pm2 is closed.");
}
}
catch (Exception uex) {
setAborted();
fail(ASSERTION_FAILED,
"Caught 1 unexpected exception " + uex.toString());
}
}
catch (Exception ex) {
setAborted();
fail(ASSERTION_FAILED,
"Caught 2 unexpected exception " + ex.toString());
}
if (!isAborted()) {
try {
pm2.currentTransaction().commit();
closePMF(pmf); // don't use closePMF() because that sets pmf to null
if (!pm1.isClosed()){
fail(ASSERTION_FAILED,
"Unexpected pm1 is not closed.");
}
if (!pm2.isClosed()) {
fail(ASSERTION_FAILED,
"Unexpected pm2 is not closed.");
}
}
catch (Exception ex) {
fail(ASSERTION_FAILED,
"Caught 3 unexpected exception " + ex.toString());
}
}
}
/** */
protected void cleanupPMF(PersistenceManagerFactory pmf) {
try {
closePMF(pmf); // don't use closePMF() because that sets pmf to null
} catch (JDOException ex) {
PersistenceManager[] pms = getFailedPersistenceManagers(ex);
int numberOfPersistenceManagers = pms.length;
for (int i = 0; i < numberOfPersistenceManagers; ++i) {
PersistenceManager pm = pms[i];
if (pm == null) {
fail(ASSERTION_FAILED,
"Found unexpected null PersistenceManager");
}
else {
Transaction tx = pm.currentTransaction();
if (tx.isActive()) {
if (debug)
logger.debug("Found active transaction; rolling back.");
tx.rollback();
}
else {
fail(ASSERTION_FAILED,
"Unexpectedly, this transaction is not active: " + tx);
}
}
}
}
}
/** */
protected void setAborted() {
aborted = true;
}
/** */
protected boolean isAborted() {
return aborted;
}
/** */
protected PersistenceManager[] getFailedPersistenceManagers(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 {
fail(ASSERTION_FAILED,
"Unexpected failed object of type: " +
failedObject.getClass().getName());
}
}
return result;
}
}
././@LongLink 100644 0 0 161 12500111677 10251 L ustar 0 0 tck/src/java/org/apache/jdo/tck/api/persistencemanagerfactory/CloseWithoutPermissionThrowsSecurityException.java tck/src/java/org/apache/jdo/tck/api/persistencemanagerfactory/CloseWithoutPermissionThrowsSecurityEx100664 7127 12500110374 34636 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanagerfactory;
import java.security.Permission;
import javax.jdo.JDOException;
import javax.jdo.PersistenceManagerFactory;
import javax.jdo.spi.JDOPermission;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Close of PersistenceManagerFactory Throws SecurityException if
* JDOPermission("closePersistenceManagerFactory") Is Not Set
*Keywords: persistencemanagerfactory SecurityException
*Assertion IDs: A11.4-3
*Assertion Description:
* PersistenceManagerFactory.close() closes this PersistenceManagerFactory.
* If JDOPermission("closePersistenceManagerFactory") is not set, then
* SecurityException in thrown.
*/
public class CloseWithoutPermissionThrowsSecurityException extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertions A11.4-3 (CloseWithoutPermissionThrowsSecurityException) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(CloseWithoutPermissionThrowsSecurityException.class);
}
/** */
public void test() {
pmf = getPMF();
closeWithMySecurityManager(pmf);
closePMF(pmf);
closeWithMySecurityManager(pmf);
}
private void closeWithMySecurityManager(PersistenceManagerFactory pmf) {
SecurityManager oldSecMgr = System.getSecurityManager();
try {
System.setSecurityManager(new MySecurityManager());
} catch (SecurityException se) {
// running with the TCK SecurityManager; don't run this test
return;
}
try {
pmf.close();
fail(ASSERTION_FAILED,
"SecurityException was not thrown when calling pmf.close() " +
"without JDOPermission.CLOSE_PERSISTENCE_MANAGER_FACTORY");
} catch (SecurityException ex) {
// expected exception if JDOPermission("closePersistenceManagerFactory") is not set
if (debug)
logger.debug("caught expected exception " + ex.toString());
} catch (JDOException e) {
fail(ASSERTION_FAILED, "Unexpected exception at pmf.close(): " + e);
}
finally {
System.setSecurityManager(oldSecMgr);
}
}
public class MySecurityManager extends SecurityManager {
public void checkPermission(Permission perm) {
if (perm==JDOPermission.CLOSE_PERSISTENCE_MANAGER_FACTORY)
throw new SecurityException(
"JDOPermission.CLOSE_PERSISTENCE_MANAGER_FACTORY not set");
}
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanagerfactory/config/Jdoconfig.java 100664 14531 12500110374 31004 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanagerfactory.config;
import java.util.HashMap;
import javax.jdo.JDOHelper;
import javax.jdo.PersistenceManager;
import javax.jdo.PersistenceManagerFactory;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Close of PersistenceManagerFactory
*Keywords: persistencemanagerfactory, jdoconfig.xml
*Assertion IDs: A11.1.2-1
*Assertion Description:
* Users can access a PersistenceManagerFactory by creating a jdoconfig.xml file
* and making it available on the class path as META-INF/jdoconfig.xml.
*/
public class Jdoconfig extends JDO_Test {
/** Creates a new instance of Jdoconfig */
public Jdoconfig() {
}
/** */
private static final String ASSERTION_FAILED =
"Assertion A11.1.2-1 failed: ";
private static final String ANONYMOUS_PMF_NAME = "";
// Do not use superclass pmf, pm
private PersistenceManagerFactory privatePmf = null;
private PersistenceManager privatePm = null;
private HashMap overrides = new HashMap();
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(Jdoconfig.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
/* Instance can be persisted ONLY if javax.jdo.mapping.Schema
* is overriden with
* JDOHelper.getPersistenceManagerFactory(Map overrides, ...).
* The value depends on identity type so can only be known at runtime.
*/
if (isTestToBePerformed()) {
overrides.put("javax.jdo.mapping.Schema", schemaname);
}
}
/** */
public void testGetPMFNoArgs() {
privatePmf = JDOHelper.getPersistenceManagerFactory();
checkIsOpen(ANONYMOUS_PMF_NAME);
}
/** */
public void testGetPMFEmptyString() {
String name = "";
privatePmf = JDOHelper.getPersistenceManagerFactory(name);
checkIsOpen(ANONYMOUS_PMF_NAME);
}
/** */
public void testGetPMFNull() {
String name = null;
privatePmf = JDOHelper.getPersistenceManagerFactory(name);
checkIsOpen(ANONYMOUS_PMF_NAME);
}
/** */
public void testGetPMFStringSpace() {
String name = " ";
privatePmf = JDOHelper.getPersistenceManagerFactory(name);
checkIsOpen(ANONYMOUS_PMF_NAME);
}
/** */
public void testGetPMFNamed() {
String name = "namedPMF0";
privatePmf = JDOHelper.getPersistenceManagerFactory(name);
assertEquals("Incorrect value for RestoreValues",
privatePmf.getRestoreValues(), false);
checkIsOpen(name);
}
/** */
public void testGetPMFEmptyStringOverrides() {
String name = "";
privatePmf = JDOHelper.getPersistenceManagerFactory(overrides, name);
checkPersistent(ANONYMOUS_PMF_NAME);
}
/** */
public void testGetPMFNullOverrides() {
String name = null;
privatePmf = JDOHelper.getPersistenceManagerFactory(overrides, name);
checkPersistent(ANONYMOUS_PMF_NAME);
}
/** */
public void testGetPMFStringSpaceOverrides() {
String name = " ";
privatePmf = JDOHelper.getPersistenceManagerFactory(overrides, name);
checkPersistent(ANONYMOUS_PMF_NAME);
}
/** */
public void testGetPMFNamedOverrides() {
String name = "namedPMF0";
privatePmf = JDOHelper.getPersistenceManagerFactory(overrides, name);
assertEquals("Incorrect value for RestoreValues",
privatePmf.getRestoreValues(), false);
checkPersistent(name);
}
/** */
public void testGetPMFNamedSpacesOverrides() {
String name = "namedPMF1";
privatePmf = JDOHelper.getPersistenceManagerFactory(overrides,
" \t" + name + " \n");
assertEquals("Incorrect value for RestoreValues",
privatePmf.getRestoreValues(), true);
checkPersistent(name);
}
/** */
public void checkIsOpen(String name) {
assertEquals("Incorrect PMF name", name, privatePmf.getName());
if (privatePmf.isClosed()) {
fail(ASSERTION_FAILED,
"PMF.isClosed() returned true on an open pmf");
}
closePMF(privatePmf);
// have next invocation of getPMF() get a new pmf
privatePmf = null;
}
/**
* Checks if instance can be persisted. Can be used if
* javax.jdo.mapping.Schema is overriden with the correct value
* with JDOHelper.getPersistenceManagerFactory(Map overrides, ...).
*/
public void checkPersistent(String name) {
assertEquals("Incorrect PMF name", name, privatePmf.getName());
makePersistent();
closePMF(privatePmf);
if (!privatePmf.isClosed()) {
fail(ASSERTION_FAILED,
"PMF.isClosed() returned false on a closed pmf");
}
// have next invocation of getPMF() get a new pmf
privatePmf = null;
}
protected void makePersistent() {
addTearDownClass(PCPoint.class);
privatePm = privatePmf.getPersistenceManager();
Transaction tx = privatePm.currentTransaction();
tx.begin();
PCPoint comp = new PCPoint(1, 2);
privatePm.makePersistent(comp);
tx.commit();
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanagerfactory/config/JDOConfigListener.java 100664 14410 12500110374 32346 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanagerfactory.config;
import java.util.HashMap;
import javax.jdo.JDOHelper;
import javax.jdo.PersistenceManager;
import javax.jdo.PersistenceManagerFactory;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: JDOConfigListener
*Keywords: persistencemanagerfactory, jdoconfig.xml
*Assertion IDs: A11.1-40
*Assertion Description:
Properties whose key begins with the prefix
* "javax.jdo.listener.InstanceLifecycleListener." have special treatment.
* The part of the key following the prefix is used as the class name of a class
* that implements javax.jdo.listener.InstanceLifecycleListener.
* The implementation first attempts to get an instance via the static method
* getInstance() that returns an instance that implements the
* javax.jdo.listener.InstanceLifecycleListener. If this is unsuccessful,
* an instance of this class is constructed via a no-args constructor.
* The value of the key is a comma-separated list of classes to which
* the instantiated listener is registered to listen.
*/
public class JDOConfigListener extends JDO_Test {
/** Creates a new instance of JDOConfigListener */
public JDOConfigListener() {
}
/** */
private static final String ASSERTION_FAILED =
"Assertions 11.1-40 failed: ";
private static final String ANONYMOUS_PMF_NAME = "";
// Do not use superclass pmf, pm
private PersistenceManagerFactory pmf = null;
private PersistenceManager pm = null;
private HashMap overrides = new HashMap();
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(JDOConfigListener.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
/* Instance can be persisted ONLY if javax.jdo.mapping.Schema
* is overriden with
* JDOHelper.getPersistenceManagerFactory(Map overrides, ...).
* The value depends on identity type so can only be known at runtime.
*/
if (isTestToBePerformed()) {
overrides.put("javax.jdo.mapping.Schema", schemaname);
}
}
/**
* Test instantiation of InstanceLifecycleListener where listener class
* and target classes are specified in jdoconfig.xml where listener
* class provides only a public no-args constructor.
*/
public void testPCPointListener() {
String pmfname = "testInstanceLifecycleListenerStore";
pmf = JDOHelper.getPersistenceManagerFactory(overrides, pmfname);
makePersistent();
assertTrue("Expected preStore() to have been invoked.",
StoreListener.isPreStore());
assertTrue("Expected postStore() to have been invoked.",
StoreListener.isPostStore());
}
/**
* Test instantiation of InstanceLifecycleListener where listener class
* and target classes are specified in jdoconfig.xml where listener
* class provides a static method getInstance().
*/
public void testPCPointListenerGetInstance() {
String pmfname = "testInstanceLifecycleListenerStoreGetInstance";
pmf = JDOHelper.getPersistenceManagerFactory(overrides, pmfname);
makePersistent();
assertTrue("Expected preStore() to have been invoked.",
StoreListenerGetInstance.isPreStore());
assertTrue("Expected postStore() to have been invoked.",
StoreListenerGetInstance.isPostStore());
}
/**
* Test instantiation of Instance LifeCycleListener specified via
* property overrides.
*/
public void testPCPointListenerOverrides() {
overrides.put("javax.jdo.listener.InstanceLifecycleListener.org.apache.jdo.tck.api.persistencemanagerfactory.config.StoreListener",
"org.apache.jdo.tck.pc.mylib.PCPoint");
String pmfname = "testInstanceLifecycleListenerStoreOverrides";
pmf = JDOHelper.getPersistenceManagerFactory(overrides, pmfname);
makePersistent();
assertTrue("Expected preStore() to have been invoked.",
StoreListener.isPreStore());
assertTrue("Expected postStore() to have been invoked.",
StoreListener.isPostStore());
}
/**
* Test instantiation of InstanceLifecycleListener where class value
* is null
*/
public void testPCPointListenerNullClasses() {
String pmfname = "testInstanceLifecycleListenerClassesNull";
pmf = JDOHelper.getPersistenceManagerFactory(overrides, pmfname);
makePersistent();
assertTrue("Expected preStore() to have been invoked.",
StoreListener.isPreStore());
assertTrue("Expected postStore() to have been invoked.",
StoreListener.isPostStore());
}
protected void makePersistent() {
addTearDownClass(PCPoint.class);
pm = pmf.getPersistenceManager();
Transaction tx = pm.currentTransaction();
tx.begin();
PCPoint comp = new PCPoint(1, 2);
pm.makePersistent(comp);
tx.commit();
}
protected void localTearDown() {
super.localTearDown();
StoreListener.resetValues();
StoreListenerGetInstance.resetValues();
closePMF();
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanagerfactory/config/Persistence.java 100664 11742 12500110374 31367 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanagerfactory.config;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;
import javax.jdo.Constants;
import javax.jdo.JDOHelper;
import javax.jdo.PersistenceManager;
import javax.jdo.PersistenceManagerFactory;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Close of PersistenceManagerFactory
*Keywords: persistencemanagerfactory, jdoconfig.xml
*Assertion IDs: A8.7-1
*Assertion Description:
* The application provides a resource named META-INF/persistence.xml and
* optionally META-INF/services/javax.persistence.EntityManagerFactory which
* contain configuration information
*/
public class Persistence extends JDO_Test {
/** Creates a new instance of Jdoconfig */
public Persistence() {
}
/** */
private static final String ASSERTION_FAILED =
"Assertion A11.1.2-1 failed: ";
// Do not use superclass pmf, pm
private PersistenceManagerFactory pmf = null;
private PersistenceManager pm = null;
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(Persistence.class);
}
/** */
public void testGetPMFfromNamedPU() {
String name = "PUNamed_" + identitytype + "0";
pmf = JDOHelper.getPersistenceManagerFactory(name);
assertEquals("Incorrect value for RestoreValues",
false, pmf.getRestoreValues());
runTest(name);
}
/** */
public void testGetPMFfromNamedPUWithNullOverrides() {
String name = "PUNamed_" + identitytype + "0";
pmf = JDOHelper.getPersistenceManagerFactory(null, name);
assertEquals("Incorrect value for RestoreValues",
false, pmf.getRestoreValues());
runTest(name);
}
/** */
public void testGetPMFfromNamedPUWithEmptyOverrides() {
String name = "PUNamed_" + identitytype + "0";
Map overrides = new HashMap();
pmf = JDOHelper.getPersistenceManagerFactory(overrides, name);
assertEquals("Incorrect value for RestoreValues",
false, pmf.getRestoreValues());
runTest(name);
}
/** */
public void testGetPMFfromNamedPUWithOverrides() {
String name = "PUNamed_" + identitytype + "0";
Properties overrides = new Properties();
overrides.setProperty(Constants.PROPERTY_RESTORE_VALUES, "true");
pmf = JDOHelper.getPersistenceManagerFactory(overrides, name);
assertEquals("Incorrect value for RestoreValues",
true, pmf.getRestoreValues());
runTest(name);
}
/** */
public void testGetPMFfromNamedPUWithWhiteSpace() {
String name = "PUNamed_" + identitytype + "0";
pmf = JDOHelper.getPersistenceManagerFactory(" \t" + name + " \n");
assertEquals("Incorrect value for RestoreValues",
false, pmf.getRestoreValues());
runTest(name);
}
/** */
public void runTest(String name) {
String actualPUName = pmf.getPersistenceUnitName();
assertEquals("Incorrect PersistenceUnitName", name, actualPUName);
// check pmf.isClosed() before and after pmf.close()
if (pmf.isClosed()) {
fail(ASSERTION_FAILED,
"PMF.isClosed() returned true on an open pmf");
}
makePersistent();
closePMF(pmf); // don't use closePMF() because that sets pmf to null
if (!pmf.isClosed()) {
fail(ASSERTION_FAILED,
"PMF.isClosed() returned false on a closed pmf");
}
// have next invocation of getPMF() get a new pmf
pmf = null;
}
protected void makePersistent() {
addTearDownClass(PCPoint.class);
pm = pmf.getPersistenceManager();
Transaction tx = pm.currentTransaction();
tx.begin();
PCPoint comp = new PCPoint(1, 2);
pm.makePersistent(comp);
tx.commit();
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanagerfactory/config/StoreListener.java 100664 3652 12500110374 31666 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanagerfactory.config;
import javax.jdo.listener.InstanceLifecycleEvent;
import javax.jdo.listener.StoreLifecycleListener;
/**
* A StoreLivecycleListener implementation that provides a public no-args
* constructor that may be invoked by a JDO implementation,
* but NO getInstance() method.
*/
public class StoreListener implements StoreLifecycleListener {
private static boolean preStore = false;
private static boolean postStore = false;
private static int instanceCount = 0;
public StoreListener() {
instanceCount++;
}
public static boolean isPreStore() {
return preStore;
}
public static boolean isPostStore() {
return postStore;
}
public static void resetValues() {
preStore = false;
postStore = false;
}
public void preStore(InstanceLifecycleEvent event) {
// System.out.println("preStore: event is " + event);
preStore = true;
}
public void postStore(InstanceLifecycleEvent event) {
// System.out.println("postStore: event is " + event);
postStore = true;
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanagerfactory/config/StoreListenerGetInstance.java 100664 4133 12500110374 34006 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanagerfactory.config;
import javax.jdo.listener.InstanceLifecycleEvent;
import javax.jdo.listener.StoreLifecycleListener;
/**
* A StoreLifecycleListener implementation that provides a getInstance() method
* that may be invoked by a JDO implementation.
*/
public class StoreListenerGetInstance implements StoreLifecycleListener {
private static boolean preStore = false;
private static boolean postStore = false;
private static int instanceCount = 0;
private static StoreListenerGetInstance slInstance =
new StoreListenerGetInstance();
private StoreListenerGetInstance() {
instanceCount++;
}
public static StoreListenerGetInstance getInstance() {
return slInstance;
}
public static boolean isPreStore() {
return preStore;
}
public static boolean isPostStore() {
return postStore;
}
public static void resetValues() {
preStore = false;
postStore = false;
}
public void preStore(InstanceLifecycleEvent event) {
// System.out.println("preStore: event is " + event);
preStore = true;
}
public void postStore(InstanceLifecycleEvent event) {
// System.out.println("postStore: event is " + event);
postStore = true;
}
}
././@LongLink 100644 0 0 153 12500111677 10252 L ustar 0 0 tck/src/java/org/apache/jdo/tck/api/persistencemanagerfactory/config/ThrowOnUnknownStandardProperties.java tck/src/java/org/apache/jdo/tck/api/persistencemanagerfactory/config/ThrowOnUnknownStandardPropertie100664 12042 12500110374 34510 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanagerfactory.config;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.Map;
import java.util.Properties;
import javax.jdo.JDOException;
import javax.jdo.JDOUserException;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.util.BatchTestRunner;
public class ThrowOnUnknownStandardProperties extends JDO_Test {
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(ThrowOnUnknownStandardProperties.class);
}
protected boolean preSetUp() {
return false;
}
protected boolean preTearDown() {
return false;
}
protected Method getStaticGetPMFMethod() {
Class pmfClass = getPMFClass();
try {
Method m = pmfClass.getDeclaredMethod(
"getPersistenceManagerFactory", new Class[] {Map.class});
if ((m.getModifiers() & Modifier.STATIC) != Modifier.STATIC) {
throw new JDOException(
"PMF class "
+ pmfClass.getName()
+ " method 'getPersistenceManagerFactory' is not static");
}
return m;
} catch (SecurityException e) {
throw new JDOException(
"Cannot get method 'getPersistenceManagerFactory' from PMF class "
+ pmfClass.getName(), e);
} catch (NoSuchMethodException e) {
throw new JDOException(
"No method 'getPersistenceManagerFactory' from PMF class "
+ pmfClass.getName(), e);
}
}
protected void invokeGetPMF(Object... args) throws Exception {
Method getPMF = getStaticGetPMFMethod();
getPMF.invoke(null, args);
}
public void testUnknownStandardProperty() {
Properties p = new Properties();
p.setProperty("javax.jdo.unknown.standard.property", "value");
try {
invokeGetPMF(p);
fail("testUnknownStandardProperty should result in JDOUserException. "
+ "No exception was thrown.");
} catch (InvocationTargetException ite) {
Throwable cause = ite.getCause();
if (cause != null && cause instanceof JDOUserException) {
// :)
} else {
throw new JDOException("PMF threw " + cause + " instead of JDOException");
}
} catch (Exception e) {
throw new JDOException(
"failed to invoke static getPersistenceManagerFactory(Map) method on PMF class",
e);
}
}
public void testUnknownStandardProperties() {
Properties p = new Properties();
p.setProperty("javax.jdo.unknown.standard.property.1", "value");
p.setProperty("javax.jdo.unknown.standard.property.2", "value");
JDOUserException x = null;
try {
invokeGetPMF(p);
fail("testUnknownStandardProperties should result in JDOUserException. "
+ "No exception was thrown.");
} catch (InvocationTargetException ite) {
Throwable cause = ite.getCause();
if (cause != null && cause instanceof JDOUserException) {
x = (JDOUserException) cause;
} else {
throw new JDOException("PMF threw " + cause + " instead of JDOException");
}
} catch (Exception e) {
throw new JDOException(
"failed to invoke static getPersistenceManagerFactory(Map) method on PMF class",
e);
}
Throwable[] nesteds = x.getNestedExceptions();
assertNotNull(nesteds);
assertEquals("should have been 2 nested exceptions", 2, nesteds.length);
for (int i = 0; i < nesteds.length; i++) {
Throwable t = nesteds[i];
assertTrue("nested exception " + i
+ " should have been JDOUserException",
t instanceof JDOUserException);
}
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanagerfactory/FlushThrowsIfReadOnly.java 100664 13535 12500110374 32045 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanagerfactory;
import java.util.Date;
import java.util.Properties;
import javax.jdo.Constants;
import javax.jdo.JDOHelper;
import javax.jdo.JDOReadOnlyException;
import javax.jdo.PersistenceManagerFactory;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.company.Address;
import org.apache.jdo.tck.pc.company.Company;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: ReadOnly property of PersistenceManagerFactory
*Keywords: persistencemanagerfactory
*Assertion IDs: A11.1-28
*Assertion Description:
* if an attempt is made to write (via flush) then JDOReadOnlyException
* is thrown.
*/
public class FlushThrowsIfReadOnly extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A11.1-28 FlushThrowsIfReadOnly failed: ";
/** Second PMF that is read-only */
PersistenceManagerFactory pmf2;
/** The company oid */
Object oid;
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(FlushThrowsIfReadOnly.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
addTearDownClass(Company.class);
Properties properties = loadProperties(PMFProperties);
properties.put(Constants.PROPERTY_READONLY, "true");
pmf2 = JDOHelper.getPersistenceManagerFactory(properties);
// insert an instance to find
getPM();
pm.currentTransaction().begin();
Company comp = new Company(1L, "Sun Microsystems", new Date(),
new Address(0,"","","","",""));
pm.makePersistent(comp);
oid = pm.getObjectId(comp);
pm.currentTransaction().commit();
pm.close();
}
/** */
public void testMakePersistent() {
//Try to makePersistent and flush the transaction
pm = pmf2.getPersistenceManager();
Transaction tx = pm.currentTransaction();
tx.begin();
Company comp = new Company(2L, "Sun Microsystems2", new Date(),
new Address(0,"","","","",""));
try {
pm.makePersistent(comp);
pm.flush();
fail("When the PersistenceManagerFactory is read only, " +
"flush of a persistent-new instance must throw " +
"JDOReadOnlyException.");
} catch (JDOReadOnlyException jDOReadOnlyException) {
// good catch
} catch (Throwable t) {
fail("When the PersistenceManagerFactory is read only, " +
"flush of a persistent-deleted instance must throw " +
"JDOReadOnlyException. Flush threw " + t);
}
tx.rollback();
pm.close();
pm = null;
closePMF(pmf2);
}
/** */
public void testUpdate() {
//Try to update and flush the transaction
pm = pmf2.getPersistenceManager();
pm.getExtent(Company.class); // make sure that oid class is loaded
Transaction tx = pm.currentTransaction();
tx.begin();
Company comp = (Company)pm.getObjectById(oid);
try {
comp.setName("new name");
pm.flush();
fail("When the PersistenceManagerFactory is read only, " +
"flush of an updated instance must throw " +
"JDOReadOnlyException.");
} catch (JDOReadOnlyException jDOReadOnlyException) {
// good catch
} catch (Throwable t) {
fail("When the PersistenceManagerFactory is read only, " +
"flush of a persistent-deleted instance must throw " +
"JDOReadOnlyException. Flush threw " + t);
}
tx.rollback();
pm.close();
pm = null;
closePMF(pmf2);
}
/** */
public void testDeletePersistent() {
//Try to deletePersistent and flush the transaction
pm = pmf2.getPersistenceManager();
pm.getExtent(Company.class); // make sure that oid class is loaded
Transaction tx = pm.currentTransaction();
tx.begin();
Company comp = (Company)pm.getObjectById(oid);
try {
pm.deletePersistent(comp);
pm.flush();
fail("When the PersistenceManagerFactory is read only, " +
"flush of a persistent-deleted instance must throw " +
"JDOReadOnlyException.");
} catch (JDOReadOnlyException jDOReadOnlyException) {
// good catch
} catch (Throwable t) {
fail("When the PersistenceManagerFactory is read only, " +
"flush of a persistent-deleted instance must throw " +
"JDOReadOnlyException. Flush threw " + t);
}
tx.rollback();
pm.close();
pm = null;
closePMF(pmf2);
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanagerfactory/GetManagedClasses.java 100664 5277 12500110374 31136 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanagerfactory;
import java.util.Collection;
import javax.jdo.Query;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.pc.mylib.PCRect;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: GetManagedClasses of PersistenceManagerFactory
*Keywords: persistencemanagerfactory
*Assertion IDs:
*Assertion Description:
* Test output from PersistenceManagerFactory.getManagedClasses().
*/
public class GetManagedClasses extends JDO_Test {
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(GetManagedClasses.class);
}
/** */
public void test() {
try {
// Get PMF and a PM, and do an Extent on some classes
pmf = getPMF();
pm = pmf.getPersistenceManager();
try {
pm.currentTransaction().begin();
pm.getExtent(PCPoint.class);
Query q = pm.newQuery(PCRect.class);
q.execute();
pm.currentTransaction().rollback();
} catch (Exception e) {
fail("Exception failed accessing Extents");
} finally {
if (pm.currentTransaction().isActive()) {
pm.currentTransaction().rollback();
}
}
// Check that the classes are now managed
Collection managedClasses = pmf.getManagedClasses();
assertTrue("PCPoint ought to be managed but isnt", managedClasses.contains(PCPoint.class));
assertTrue("PCRect ought to be managed but isnt", managedClasses.contains(PCRect.class));
} finally {
pm.close();
}
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanagerfactory/GetPersistenceManager.java 100664 4420 12500110374 32030 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanagerfactory;
import javax.jdo.PersistenceManager;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: GetPersistenceManager of PersistenceManagerFactory
*Keywords: persistencemanagerfactory
*Assertion IDs: A11.3-1.
*Assertion Description:
* PersistenceManagerFactory.getPersistenceManager() returns a
* PersistenceManager instance with the configured properties and the
* default values for option settings.
*/
public class GetPersistenceManager extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A11.3-1 (GetPersistenceManager) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(GetPersistenceManager.class);
}
/** */
public void test() {
PersistenceManager pm = null;
try {
pm = pmf.getPersistenceManager();
if (pm == null) {
fail(ASSERTION_FAILED, "pmf.getPersistenceManager should " +
"return a non-null value.");
}
}
finally {
if ((pm != null) && !pm.isClosed()) {
pm.close();
}
closePMF();
}
}
}
././@LongLink 100644 0 0 164 12500111677 10254 L ustar 0 0 tck/src/java/org/apache/jdo/tck/api/persistencemanagerfactory/GetPersistenceManagerFactoryByPropertiesInstance.java tck/src/java/org/apache/jdo/tck/api/persistencemanagerfactory/GetPersistenceManagerFactoryByProperti100664 5401 12500110374 34460 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanagerfactory;
import java.util.Date;
import javax.jdo.JDOHelper;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.company.Address;
import org.apache.jdo.tck.pc.company.Company;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Close of PersistenceManagerFactory
*Keywords: persistencemanagerfactory
*Assertion IDs: A11.1-32
*Assertion Description:
* An implementation must provide a method to construct a
* PersistenceManagerFactory by a Properties instance. This static method is
* called by the JDOHelper method getPersistenceManagerFactory (Properties
* props).
*/
public class GetPersistenceManagerFactoryByPropertiesInstance extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertions A11.1-32 (GetPersistenceManagerFactoryByPropertiesInstance) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(GetPersistenceManagerFactoryByPropertiesInstance.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
addTearDownClass(Company.class);
PMFPropertiesObject = loadProperties(PMFProperties);
pmf = JDOHelper.getPersistenceManagerFactory(PMFPropertiesObject);
}
/** */
public void test() {
//Try to get a PersistenceManager and begin and commit a transaction
pm = getPM();
Transaction tx = pm.currentTransaction();
tx.begin();
Company comp = new Company(1L, "Sun Microsystems", new Date(),
new Address(0,"","","","",""));
pm.makePersistent(comp);
tx.commit();
pm.close();
pm = null;
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanagerfactory/GetPersistenceManagerForUser.java 100664 5636 12500110374 33350 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanagerfactory;
import java.util.Properties;
import javax.jdo.JDOHelper;
import javax.jdo.PersistenceManager;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: GetPersistenceManagerForUser of PersistenceManagerFactory
*Keywords: persistencemanagerfactory
*Assertion IDs: A11.3-2.
*Assertion Description:
* PersistenceManagerFactory.getPersistenceManager(String userid,
* String password) returns a PersistenceManager instance with the
* configured properties and the default values for option settings.
*/
public class GetPersistenceManagerForUser extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A11.3-2 (GetPersistenceManagerForUser) failed: ";
/** The value of the ConnectionUserName property. */
private String username;
/** The value of the ConnectionPassword property. */
private String password;
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(GetPersistenceManagerForUser.class);
}
/** */
protected void localSetUp() {
Properties props = loadProperties(PMFProperties);
username = (String)props.remove(CONNECTION_USERNAME_PROP);
password = (String)props.remove(CONNECTION_PASSWORD_PROP);
pmf = JDOHelper.getPersistenceManagerFactory(props);
}
/** */
public void test() {
PersistenceManager pm = null;
try {
pm = pmf.getPersistenceManager(username, password);
if (pm == null) {
fail(ASSERTION_FAILED,
"pmf.getPersistenceManager(user, password) should " +
"return a non-null value.");
}
}
finally {
if ((pm != null) && !pm.isClosed()) {
pm.close();
}
closePMF();
}
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanagerfactory/GetPMFByFile.java 100664 5150 12500110374 27767 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanagerfactory;
import java.io.File;
import javax.jdo.JDOHelper;
import javax.jdo.PersistenceManagerFactory;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: GetPMFByFile of PersistenceManagerFactory
*Keywords: persistencemanagerfactory
*Assertion IDs: A8.6-13.
*Assertion Description:
* Uses the parameter(s) passed as arguments to construct a Properties
* instance, and then delegates to the static method
* getPersistenceManagerFactory in the class named in the property
* javax.jdo.PersistenceManagerFactoryClass.
* If there are any exceptions while trying to construct the Properties
* instance or to call the static method,
* then either A8.6-4 [JDOFatalUserException] or
* A8.6-5 [JDOFatalInternalException is thrown],
* depending on whether the exception is due to the user
* or the implementation.
* The nested exception indicates the cause of the exception.
*
* @author Michael Watzek
*/
public class GetPMFByFile extends AbstractGetPMF {
/** */
private static final String ASSERTION_FAILED =
"Assertion A8.6-13 (GetPMFByFile) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(GetPMFByFile.class);
}
/** */
public void testInvalidGetPMF() {
checkGetPMFWithInvalidProperties(ASSERTION_FAILED);
}
/** */
public void testValidGetPMF() {
checkGetPMFWithValidProperties();
}
/** */
protected PersistenceManagerFactory getPMF(String name) {
return JDOHelper.getPersistenceManagerFactory(new File(name));
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanagerfactory/GetPMFByFileAndClassLoader.java 100664 5660 12500110374 32535 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanagerfactory;
import java.io.File;
import javax.jdo.JDOHelper;
import javax.jdo.PersistenceManagerFactory;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: GetPMFByFileAndClassLoader of PersistenceManagerFactory
*Keywords: persistencemanagerfactory
*Assertion IDs: A8.6-14.
*Assertion Description:
* Uses the parameter(s) passed as arguments to construct a Properties
* instance, and then delegates to the static method
* getPersistenceManagerFactory in the class named in the property
* javax.jdo.PersistenceManagerFactoryClass.
* If there are any exceptions while trying to construct the Properties
* instance or to call the static method,
* then either A8.6-4 [JDOFatalUserException] or
* A8.6-5 [JDOFatalInternalException is thrown],
* depending on whether the exception is due to the user
* or the implementation.
* The nested exception indicates the cause of the exception.
*
* @author Michael Watzek
*/
public class GetPMFByFileAndClassLoader extends AbstractGetPMF {
/** */
private static final String ASSERTION_FAILED =
"Assertion A8.6-14 (GetPMFByFileAndClassLoader) failed: ";
private static final String propertiesFileDoesNotExist =
"FileDoesNotExist.properties";
private static final String propertiesFileExists =
System.getProperty("PMFProperties");
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(GetPMFByFileAndClassLoader.class);
}
/** */
public void testInvalidGetPMF() {
checkGetPMFWithInvalidProperties(ASSERTION_FAILED);
}
/** */
public void testValidGetPMF() {
checkGetPMFWithValidProperties();
}
/** */
protected PersistenceManagerFactory getPMF(String name) {
return JDOHelper.getPersistenceManagerFactory(new File(name),
Thread.currentThread().getContextClassLoader());
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanagerfactory/GetPMFByJNDILocation.java 100664 7643 12500110374 31336 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanagerfactory;
import java.io.File;
import javax.jdo.JDOFatalException;
import javax.jdo.JDOHelper;
import javax.jdo.PersistenceManagerFactory;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: GetPMFByJNDILocation of PersistenceManagerFactory
*Keywords: persistencemanagerfactory
*Assertion IDs: A8.6-19.
*Assertion Description:
* Uses the parameter(s) passed as arguments to construct a Properties
* instance, and then delegates to the static method
* getPersistenceManagerFactory in the class named in the property
* javax.jdo.PersistenceManagerFactoryClass.
* If there are any exceptions while trying to construct the Properties
* instance or to call the static method,
* then either A8.6-4 [JDOFatalUserException] or
* A8.6-5 [JDOFatalInternalException is thrown],
* depending on whether the exception is due to the user
* or the implementation.
* The nested exception indicates the cause of the exception.
*
* @author Michael Watzek
*/
public class GetPMFByJNDILocation extends AbstractGetPMF {
/** */
private static final String ASSERTION_FAILED =
"Assertion A8.6-19 (GetPMFByJNDILocation) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(GetPMFByJNDILocation.class);
}
/** */
public void testInvalidGetPMF() {
checkGetPMFWithInvalidProperties(ASSERTION_FAILED);
}
/** */
public void testValidGetPMF() {
checkGetPMFWithValidProperties();
}
/** */
protected PersistenceManagerFactory getPMF(String name) {
Context context = null;
try {
//We need a JNDI context which contains a PMF instance.
//For this reason, we create a JNDI context,
//create a PMF instance and bind that to the context.
context = new InitialContext();
if (name.equals(validPropertiesFile)) {
PersistenceManagerFactory pmf =
JDOHelper.getPersistenceManagerFactory(new File(name));
verifyProperties(pmf, loadProperties(validPropertiesFile));
context.bind(jndiName, pmf);
}
return JDOHelper.getPersistenceManagerFactory(jndiName, context);
} catch (NamingException e) {
throw new JDOFatalException("Caught NamingException trying to bind " +
e.getMessage(), e);
} finally {
if (context != null) {
try {
context.unbind(jndiName);
context.close();
} catch (NamingException e) {
fail("Caught NamingException trying to unbind or close." +
e.getMessage());
// stay quiet
}
}
}
}
}
././@LongLink 100644 0 0 146 12500111677 10254 L ustar 0 0 tck/src/java/org/apache/jdo/tck/api/persistencemanagerfactory/GetPMFByJNDILocationAndClassLoader.java tck/src/java/org/apache/jdo/tck/api/persistencemanagerfactory/GetPMFByJNDILocationAndClassLoader.jav100664 7414 12500110374 33731 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanagerfactory;
import java.io.File;
import javax.jdo.JDOFatalException;
import javax.jdo.JDOHelper;
import javax.jdo.PersistenceManagerFactory;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: GetPMFByJNDILocationAndClassLoader of PersistenceManagerFactory
*Keywords: persistencemanagerfactory
*Assertion IDs: A8.6-20.
*Assertion Description:
* Uses the parameter(s) passed as arguments to construct a Properties
* instance, and then delegates to the static method
* getPersistenceManagerFactory in the class named in the property
* javax.jdo.PersistenceManagerFactoryClass.
* If there are any exceptions while trying to construct the Properties
* instance or to call the static method,
* then either A8.6-4 [JDOFatalUserException] or
* A8.6-5 [JDOFatalInternalException is thrown],
* depending on whether the exception is due to the user
* or the implementation.
* The nested exception indicates the cause of the exception.
*
* @author Michael Watzek
*/
public class GetPMFByJNDILocationAndClassLoader extends AbstractGetPMF {
/** */
private static final String ASSERTION_FAILED =
"Assertion A8.6-20 (GetPMFByJNDILocationAndClassLoader) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(GetPMFByJNDILocationAndClassLoader.class);
}
/** */
public void testInvalidGetPMF() {
checkGetPMFWithInvalidProperties(ASSERTION_FAILED);
}
/** */
public void testValidGetPMF() {
checkGetPMFWithValidProperties();
}
/** */
protected PersistenceManagerFactory getPMF(String name) {
Context context = null;
try {
//We need a JNDI context which contains a PMF instance.
//For this reason, we create a JNDI context,
//create a PMF instance and bind that to the context.
context = new InitialContext();
if (name.equals(validPropertiesFile)) {
PersistenceManagerFactory pmf =
JDOHelper.getPersistenceManagerFactory(new File(name));
context.bind(jndiName, pmf);
}
return JDOHelper.getPersistenceManagerFactory(jndiName, context,
Thread.currentThread().getContextClassLoader());
} catch (NamingException e) {
throw new JDOFatalException("", e);
} finally {
if (context != null) {
try {
context.unbind(jndiName);
context.close();
} catch (NamingException e) {
// stay quiet
}
}
}
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanagerfactory/GetPMFByResource.java 100664 5152 12500110374 30701 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanagerfactory;
import javax.jdo.JDOHelper;
import javax.jdo.PersistenceManagerFactory;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: GetPMFByResource of PersistenceManagerFactory
*Keywords: persistencemanagerfactory
*Assertion IDs: A8.6-15.
*Assertion Description:
* Uses the parameter(s) passed as arguments to construct a Properties
* instance, and then delegates to the static method
* getPersistenceManagerFactory in the class named in the property
* javax.jdo.PersistenceManagerFactoryClass.
* If there are any exceptions while trying to construct the Properties
* instance or to call the static method,
* then either A8.6-4 [JDOFatalUserException] or
* A8.6-5 [JDOFatalInternalException is thrown],
* depending on whether the exception is due to the user
* or the implementation.
* The nested exception indicates the cause of the exception.
*
* @author Michael Watzek
*/
public class GetPMFByResource extends AbstractGetPMF {
/** */
private static final String ASSERTION_FAILED =
"Assertion A8.6-15 (GetPMFByResource) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(GetPMFByResource.class);
}
/** */
public void testInvalidGetPMF() {
checkGetPMFWithInvalidProperties(ASSERTION_FAILED);
}
/** */
public void testValidGetPMF() {
checkGetPMFWithValidProperties();
}
/** */
protected PersistenceManagerFactory getPMF(String name) {
return JDOHelper.getPersistenceManagerFactory(removePathPrefix(name));
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanagerfactory/GetPMFByResourceAndClassLoader.java 100664 5343 12500110374 33443 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanagerfactory;
import javax.jdo.JDOHelper;
import javax.jdo.PersistenceManagerFactory;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: GetPMFByResourceAndClassLoader of PersistenceManagerFactory
*Keywords: persistencemanagerfactory
*Assertion IDs: A8.6-16.
*Assertion Description:
* Uses the parameter(s) passed as arguments to construct a Properties
* instance, and then delegates to the static method
* getPersistenceManagerFactory in the class named in the property
* javax.jdo.PersistenceManagerFactoryClass.
* If there are any exceptions while trying to construct the Properties
* instance or to call the static method,
* then either A8.6-4 [JDOFatalUserException] or
* A8.6-5 [JDOFatalInternalException is thrown],
* depending on whether the exception is due to the user
* or the implementation.
* The nested exception indicates the cause of the exception.
*
* @author Michael Watzek
*/
public class GetPMFByResourceAndClassLoader extends AbstractGetPMF {
/** */
private static final String ASSERTION_FAILED =
"Assertion A8.6-16 (GetPMFByResourceAndClassLoader) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(GetPMFByResourceAndClassLoader.class);
}
/** */
public void testInvalidGetPMF() {
checkGetPMFWithInvalidProperties(ASSERTION_FAILED);
}
/** */
public void testValidGetPMF() {
checkGetPMFWithValidProperties();
}
/** */
protected PersistenceManagerFactory getPMF(String name) {
return JDOHelper.getPersistenceManagerFactory(removePathPrefix(name),
Thread.currentThread().getContextClassLoader());
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanagerfactory/GetPMFByStream.java 100664 6160 12500110374 30345 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanagerfactory;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import javax.jdo.JDOHelper;
import javax.jdo.PersistenceManagerFactory;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: GetPMFByStream of PersistenceManagerFactory
*Keywords: persistencemanagerfactory
*Assertion IDs: A8.6-17.
*Assertion Description:
* Uses the parameter(s) passed as arguments to construct a Properties
* instance, and then delegates to the static method
* getPersistenceManagerFactory in the class named in the property
* javax.jdo.PersistenceManagerFactoryClass.
* If there are any exceptions while trying to construct the Properties
* instance or to call the static method,
* then either A8.6-4 [JDOFatalUserException] or
* A8.6-5 [JDOFatalInternalException is thrown],
* depending on whether the exception is due to the user
* or the implementation.
* The nested exception indicates the cause of the exception.
*
* @author Michael Watzek
*/
public class GetPMFByStream extends AbstractGetPMF {
/** */
private static final String ASSERTION_FAILED =
"Assertion A8.6-17 (GetPMFByStream) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(GetPMFByStream.class);
}
/** */
public void testInvalidGetPMF() {
checkGetPMFWithInvalidProperties(ASSERTION_FAILED);
}
/** */
public void testValidGetPMF() {
checkGetPMFWithValidProperties();
}
/** */
protected PersistenceManagerFactory getPMF(String name) {
FileInputStream stream = null;
try {
stream = new FileInputStream(name);
return JDOHelper.getPersistenceManagerFactory(stream);
} catch (FileNotFoundException e) {
throw new RuntimeException("", e);
} finally {
if (stream != null) {
try {
stream.close();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanagerfactory/GetPMFByStreamAndClassLoader.java 100664 6355 12500110374 33113 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanagerfactory;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import javax.jdo.JDOHelper;
import javax.jdo.PersistenceManagerFactory;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: GetPMFByStreamAndClassLoader of PersistenceManagerFactory
*Keywords: persistencemanagerfactory
*Assertion IDs: A8.6-18.
*Assertion Description:
* Uses the parameter(s) passed as arguments to construct a Properties
* instance, and then delegates to the static method
* getPersistenceManagerFactory in the class named in the property
* javax.jdo.PersistenceManagerFactoryClass.
* If there are any exceptions while trying to construct the Properties
* instance or to call the static method,
* then either A8.6-4 [JDOFatalUserException] or
* A8.6-5 [JDOFatalInternalException is thrown],
* depending on whether the exception is due to the user
* or the implementation.
* The nested exception indicates the cause of the exception.
*
* @author Michael Watzek
*/
public class GetPMFByStreamAndClassLoader extends AbstractGetPMF {
/** */
private static final String ASSERTION_FAILED =
"Assertion A8.6-18 (GetPMFByStreamAndClassLoader) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(GetPMFByStreamAndClassLoader.class);
}
/** */
public void testInvalidGetPMF() {
checkGetPMFWithInvalidProperties(ASSERTION_FAILED);
}
/** */
public void testValidGetPMF() {
checkGetPMFWithValidProperties();
}
/** */
protected PersistenceManagerFactory getPMF(String name) {
FileInputStream stream = null;
try {
stream = new FileInputStream(name);
return JDOHelper.getPersistenceManagerFactory(stream,
Thread.currentThread().getContextClassLoader());
} catch (FileNotFoundException e) {
throw new RuntimeException("", e);
} finally {
if (stream != null) {
try {
stream.close();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanagerfactory/GetProperties.java 100664 5042 12500110374 30406 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanagerfactory;
import java.util.Enumeration;
import java.util.Properties;
import javax.jdo.PersistenceManagerFactory;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Get properties of PersistenceManagerFactory
*Keywords: persistencemanagerfactory
*Assertion IDs: A11.4-1.
*Assertion Description:
PersistenceManagerFactory.getProperties() returns a Properties instance
containing two standard JDO implementation properties
VendorName: The name of the JDO vendor.
VersionNumber: The version number string.
*/
public class GetProperties extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A11.4-1 (GetProperties) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(GetProperties.class);
}
/** */
public void test() {
PersistenceManagerFactory pmf = getPMF();
int foundStandardProperties = 0;
Properties p = pmf.getProperties();
for (Enumeration e = p.propertyNames(); e.hasMoreElements(); ) {
String s = (String) e.nextElement();
if (debug) logger.debug ("\t" + s + ": " + p.getProperty(s));
if (s.equals("VendorName") || s.equals("VersionNumber")) {
foundStandardProperties++;
}
}
if (foundStandardProperties != 2) {
fail(ASSERTION_FAILED,
"Standard properties not found.");
}
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanagerfactory/metadata/GetMetadataTest.java 100664 12144 12500110374 32433 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanagerfactory.metadata;
import javax.jdo.metadata.ColumnMetadata;
import javax.jdo.metadata.MemberMetadata;
import javax.jdo.metadata.Metadata;
import javax.jdo.metadata.PackageMetadata;
import javax.jdo.metadata.TypeMetadata;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Metadata Test
*Keywords:
*Assertion IDs: A11.10-1
*Assertion Description:
* Method to return the metadata object for the specified class/interface, if there is
* metadata defined for that class/interface.
* If the parameter is null, null is returned.
* If there is no metadata for the specified class/interface then null will be returned.
*/
public class GetMetadataTest extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A11.10-1 (getMetadata) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(GetMetadataTest.class);
}
/** test getMetadata with null class name*/
public void testNullParameter() {
pm = getPM();
String className = null;
TypeMetadata metadata = pmf.getMetadata(className);
assertNull(ASSERTION_FAILED
+ "metadata should return null if null parameter", metadata);
}
/** test getMetadata with concrete class name*/
public void testConcreteClassName() {
pm = getPM();
String className = "org.apache.jdo.tck.pc.company.PartTimeEmployee";
TypeMetadata metadata = pmf.getMetadata(className);
assertNotNull(ASSERTION_FAILED
+ "metadata must not be null for abstract class " + className, metadata);
Metadata parent = metadata.getParent();
assertNotNull(ASSERTION_FAILED
+ "parent metadata must not be null for concrete class " + className, parent);
String name = metadata.getName();
String packageName = ((PackageMetadata)parent).getName();
assertEquals(ASSERTION_FAILED
+ "metadata name and class name must match.", className, packageName + "." + name);
}
/** test getMetadata with abstract class name*/
public void testAbstractClassName() {
pm = getPM();
String className = "org.apache.jdo.tck.pc.company.Employee";
TypeMetadata metadata = pmf.getMetadata(className);
assertNotNull(ASSERTION_FAILED
+ "metadata must not be null for abstract class " + className, metadata);
Metadata parent = metadata.getParent();
assertNotNull(ASSERTION_FAILED
+ "parent metadata must not be null for abstract class " + className, parent);
String name = metadata.getName();
String packageName = ((PackageMetadata)parent).getName();
assertEquals(ASSERTION_FAILED
+ "metadata name and class name must match.", className, packageName + "." + name);
}
/** test getMetadata with invalid class name*/
public void testInvalidName() {
pm = getPM();
String className = "org.apache.jdo.tck.pc.company.Bogus";
TypeMetadata metadata = pmf.getMetadata(className);
assertNull(ASSERTION_FAILED
+ "metadata should return null if unknown parameter", metadata);
}
/** dump the contents of this metadata */
@SuppressWarnings("unused")
private void dump(TypeMetadata typeMetadata) {
StringBuilder buffer = new StringBuilder("Metadata for " + typeMetadata.getName());
buffer.append(" identityType: " + typeMetadata.getIdentityType());
MemberMetadata[] members = typeMetadata.getMembers();
if (members != null) {
for (MemberMetadata memberMetadata: members) {
buffer.append(" member: " + memberMetadata.getName());
}
}
ColumnMetadata[] columns = typeMetadata.getColumns();
if (columns != null) {
for (ColumnMetadata columnMetadata: columns) {
buffer.append("ColumnMetadata for " + columnMetadata.getName());
}
}
System.out.println(buffer.toString());
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanagerfactory/SetConnectionPassword.java 100664 4313 12500110374 32110 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanagerfactory;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Set ConnectionPassword of persistencemanagerfactory
*Keywords: persistencemanagerfactory
*Assertion IDs: A11.1-15.
*Assertion Description:
* PersistenceManagerFactory.setConnectionPassword(String password) sets the
* value of the ConnectionPassword property (the password for the user)
*/
public class SetConnectionPassword extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A11.1-15 (SetConnectionPassword) failed: ";
/** The value of the ConnectionPassword property. */
private String password;
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(SetConnectionPassword.class);
}
/** */
protected void localSetUp() {
closePMF();
pmf = getUnconfiguredPMF();
password = getPMFProperty(CONNECTION_PASSWORD_PROP);
}
/**
* Set ConnectionPassword.
*/
public void test() {
try {
pmf.setConnectionPassword(password);
} finally {
closePMF();
}
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanagerfactory/SetConnectionURL.java 100664 5352 12500110374 30754 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanagerfactory;
import javax.jdo.JDOException;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Set ConnectionURL of PersistenceManagerFactory
*Keywords: persistencemanagerfactory
*Assertion IDs: A11.1-16,A11.1-17.
*Assertion Description:
* PersistenceManagerFactory.setConnectionURL(String URL) sets the value of
* the ConnectionURL property (the URL for the data source).
* PersistenceManagerFactory.getConnectionURL() returns the value of the
* ConnectionURL property.
*/
public class SetConnectionURL extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A11.1-16,A11.1-17 (SetConnectionURL) failed: ";
/** The value of the ConnectionURL property. */
private String url;
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(SetConnectionURL.class);
}
/** */
protected void localSetUp() {
closePMF();
pmf = getUnconfiguredPMF();
url = getPMFProperty(CONNECTION_URL_PROP);
}
/** Set ConnectionURL value and get ConnectionURL value to verify. */
public void test() {
try {
if (url == null) {
throw new JDOException(
"Missing PMF property " + CONNECTION_URL_PROP);
}
pmf.setConnectionURL(url);
if (!url.equals(pmf.getConnectionURL())) {
fail(ASSERTION_FAILED,
"ConnectionURL set to '" + url + "' ," +
"value returned by PMF is '" +
pmf.getConnectionURL() + "'.");
}
} finally {
closePMF();
}
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanagerfactory/SetConnectionUserName.java 100664 5732 12500110374 32033 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanagerfactory;
import javax.jdo.JDOException;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Set ConnectionUserName of PersistenceManagerFactory
*Keywords: persistencemanagerfactory
*Assertion IDs: A11.1-13,A11.1-14.
*Assertion Description:
* PersistenceManagerFactory.setConnectionUserName(String name) sets the value
* of the ConnectionUserName property (the name of the user establishing the
* connection).
*/
public class SetConnectionUserName extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertions A11.1-13,A11.1-14 (SetConnectionUserName) failed: ";
/** The value of the ConnectionUserName property. */
private String username;
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(SetConnectionUserName.class);
}
/** */
protected void localSetUp() {
closePMF();
pmf = getUnconfiguredPMF();
username = getPMFProperty(CONNECTION_USERNAME_PROP);
}
/**
* Set ConnectionUserName value and get ConnectionUserName value to verify.
*/
public void test() {
try {
if (username == null) {
throw new JDOException(
"Missing PMF property " + CONNECTION_USERNAME_PROP);
}
pmf.setConnectionUserName(username);
if (!username.equals(pmf.getConnectionUserName())) {
fail(ASSERTION_FAILED,
"ConnectionUserName set to '" + username + "' ," +
"value returned by PMF is '" +
pmf.getConnectionUserName() + "'.");
}
}
catch (Exception ex) {
fail(ASSERTION_FAILED,
"Failed in setting ConnectionUserName " + ex);
}
if (debug)
logger.debug("ConnectionUserName: " + pmf.getConnectionUserName());
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanagerfactory/SetIgnoreCache.java 100664 5026 12500110374 30437 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanagerfactory;
import javax.jdo.PersistenceManagerFactory;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Set IgnoreCache of persistencemanagerfactory
*Keywords: persistencemanagerfactory
*Assertion IDs: A11.1-5.
*Assertion Description:
* PersistenceManagerFactory.setIgnoreCache(boolean flag) sets the value of
* the IgnoreCache property (the query mode that specifies whether cached
* instances are considered when evaluating the filter expression).
*/
public class SetIgnoreCache extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A11.1-5 (SetIgnoreCache) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(SetIgnoreCache.class);
}
/** */
protected void localSetUp() {
closePMF();
pmf = getUnconfiguredPMF();
}
/**
* Set IgnoreCache to true or false and use getIgnoreCache value to verify.
*/
public void test() {
try {
setIgnoreCache(false);
setIgnoreCache(true);
} finally {
closePMF();
}
}
/** */
private void setIgnoreCache(boolean newValue) {
pmf.setIgnoreCache(newValue);
boolean current = pmf.getIgnoreCache();
if (current != newValue) {
fail(ASSERTION_FAILED, "IgnoreCache set to " + newValue +
", value returned by PMF is " + current);
}
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanagerfactory/SetMultithreaded.java 100664 5224 12500110374 31063 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanagerfactory;
import java.util.Properties;
import javax.jdo.PersistenceManager;
import javax.jdo.PersistenceManagerFactory;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Set Multithreaded of persistencemanagerfactory
*Keywords: persistencemanagerfactory
*Assertion IDs: A11.1-11,A11.1-12.
*Assertion Description:
* PersistenceManagerFactory.setMultithreaded(boolean flag) sets the value of
* the Multithreaded flag that indicates that the application will invoke
* methods or access fields of managed instances from multiple threads.
*/
public class SetMultithreaded extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertions A11.1-11,A11.1-12 (SetMultithreaded) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(SetMultithreaded.class);
}
/** */
protected void localSetUp() {
closePMF();
pmf = getUnconfiguredPMF();
}
/**
* Set Multithreaded to true or false and use getMultithreaded value to
* verify.
*/
public void test() {
try {
setMultithreaded(false);
setMultithreaded(true);
} finally {
closePMF();
}
}
/** */
private void setMultithreaded(boolean newValue) {
pmf.setMultithreaded(newValue);
boolean current = pmf.getMultithreaded();
if (current != newValue) {
fail(ASSERTION_FAILED, "Multithreaded set to " + newValue +
", value returned by PMF is " + current);
}
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanagerfactory/SetNonTransactionalRead.java 100664 5223 12500110374 32340 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanagerfactory;
import javax.jdo.PersistenceManagerFactory;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Set NonTransactionalRead of persistencemanagerfactory
*Keywords: persistencemanagerfactory
*Assertion IDs: A11.1-7,A11.1-8.
*Assertion Description:
* PersistenceManagerFactory.setNontransactionalRead(boolean flag) sets the
* value of the NontransactionalRead property (the PersistenceManager mode
* that allows instances to be read outside a transaction).
*/
public class SetNonTransactionalRead extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertions A11.1-7,A11.1-8 (SetNonTransactionalRead) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(SetNonTransactionalRead.class);
}
/** */
protected void localSetUp() {
closePMF();
pmf = getUnconfiguredPMF();
}
/**
* Set NonTransactionalRead to true or false and use
* getNonTransactionalRead value to verify.
*/
public void test() {
try {
setNontransactionalRead(false);
setNontransactionalRead(true);
} finally {
closePMF();
}
}
/** */
private void setNontransactionalRead(boolean newValue) {
pmf.setNontransactionalRead(newValue);
boolean current = pmf.getNontransactionalRead();
if (current != newValue) {
fail(ASSERTION_FAILED, "NonTransactionalRead set to " + newValue +
", value returned by PMF is " + current);
}
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanagerfactory/SetNonTransactionalWrite.java 100664 5706 12500110374 32565 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanagerfactory;
import javax.jdo.PersistenceManagerFactory;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Set NonTransactionalWrite of persistencemanagerfactory
*Keywords: persistencemanagerfactory
*Assertion IDs: A11.1-9,A11.1-10.
*Assertion Description:
* PersistenceManagerFactory.setNontransactionalWrite(boolean flag) sets the
* value of the NontransactionalWrite property (the PersistenceManager mode
* that allows instances to be written outside a transaction).
*/
public class SetNonTransactionalWrite extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertions A11.1-9,A11.1-10 (SetNonTransactionalWrite) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(SetNonTransactionalWrite.class);
}
/** */
protected void localSetUp() {
closePMF();
pmf = getUnconfiguredPMF();
}
/** Set NonTransactionalWrite to true or false and use
* getNonTransactionalWrite value to verify.
*/
public void test () {
if (!isNontransactionalWriteSupported()) {
printUnsupportedOptionalFeatureNotTested(
"org.apache.jdo.tck.api.persistencemanagerfactory.SetNonTransactionalWrite",
"javax.jdo.option.NontransactionalWrite");
return;
}
try {
setNontransactionalWrite(false);
setNontransactionalWrite(true);
} finally {
closePMF();
}
}
/** */
private void setNontransactionalWrite(boolean newValue) {
pmf.setNontransactionalWrite(newValue);
boolean current = pmf.getNontransactionalWrite();
if (current != newValue) {
fail(ASSERTION_FAILED, "NonTransactionalWrite set to " + newValue +
", value returned by PMF is " + current);
}
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanagerfactory/SetOptimistic.java 100664 5422 12500110374 30414 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanagerfactory;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Set optimistic of persistencemanagerfactory
*Keywords: persistencemanagerfactory
*Assertion IDs: A11.1-1, A11.1-2.
*Assertion Description:
* PersistenceManagerFactory.getOptimistic() returns Value of the Optimistic
* property,persistenceManagerFactory.setOptimistic(boolean flag) sets the
* value of the Optimistic property (the transaction mode that specifies
* concurrency control.
*/
public class SetOptimistic extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A11.1-1, A11.1-2 (SetOptimistic) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(SetOptimistic.class);
}
/** */
protected void localSetUp() {
closePMF();
pmf = getUnconfiguredPMF();
}
/** Set Optimistic to true or false and use getOptimistic value to verify. */
public void test() {
if (!isOptimisticSupported()) {
printUnsupportedOptionalFeatureNotTested(
"org.apache.jdo.tck.api.persistencemanagerfactory.SetOptimistic",
"javax.jdo.option.Optimistic");
return;
}
try {
setOptimistic(false);
setOptimistic(true);
} finally {
closePMF();
}
}
/** */
private void setOptimistic(boolean newValue) {
pmf.setOptimistic(newValue);
boolean optimistic = pmf.getOptimistic();
if (optimistic != newValue) {
fail(ASSERTION_FAILED, "Optimistic set to " + newValue +
", value returned by PMF is " + optimistic);
}
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanagerfactory/SetReadOnly.java 100664 4754 12500110374 30014 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanagerfactory;
import javax.jdo.PersistenceManagerFactory;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Set ReadOnly property of persistencemanagerfactory
*Keywords: persistencemanagerfactory
*Assertion IDs: A11.1-29, A11.1-30
*Assertion Description:
* PersistenceManagerFactory.setReadOnly(boolean) sets the value of the
* ReadOnly property
* PersistenceManagerFactory.getReadOnly() returns the value of the
* ReadOnly property
*/
public class SetReadOnly extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A11.1-29, A11.1-30 (SetRetainValues) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(SetReadOnly.class);
}
/** */
protected void localSetUp() {
closePMF();
pmf = getUnconfiguredPMF();
}
/**
* Set ReadOnly to true or false and use getReadOnly to verify.
*/
public void test() {
try {
setReadOnly(false);
setReadOnly(true);
} finally {
closePMF();
}
}
/** */
private void setReadOnly(boolean newValue) {
pmf.setReadOnly(newValue);
boolean current = pmf.getReadOnly();
if (current != newValue) {
fail(ASSERTION_FAILED, "ReadOnly set to " + newValue +
", value returned by PMF is " + current);
}
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanagerfactory/SetRetainValues.java 100664 5211 12500110374 30666 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanagerfactory;
import javax.jdo.PersistenceManagerFactory;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Set RetainValues of persistencemanagerfactory
*Keywords: persistencemanagerfactory
*Assertion IDs: A11.1-3,A11.1-4.
*Assertion Description:
* PersistenceManagerFactory.setRetainValues(boolean flag) sets the value of
* the RetainValues property (the transaction mode that specifies the
* treatment of persistent instances after commit),
* PersistenceManagerFactory.getRetainValues() returns the value of the
* RetainValues property.
*/
public class SetRetainValues extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A11.1-3,A11.1-4 (SetRetainValues) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(SetRetainValues.class);
}
/** */
protected void localSetUp() {
closePMF();
pmf = getUnconfiguredPMF();
}
/**
* Set RetainValues to true or false and use getRetainValues value to
* verify.
*/
public void test() {
try {
setRetainValues(false);
setRetainValues(true);
} finally {
closePMF();
}
}
/** */
private void setRetainValues(boolean newValue) {
pmf.setRetainValues(newValue);
boolean current = pmf.getRetainValues();
if (current != newValue) {
fail(ASSERTION_FAILED, "RetainValues set to " + newValue +
", value returned by PMF is " + current);
}
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanagerfactory/SetTransactionIsolationLevel.java 100664 17466 12500110374 33462 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanagerfactory;
import java.util.HashMap;
import java.util.Map;
import javax.jdo.Constants;
import javax.jdo.JDOHelper;
import javax.jdo.JDOUnsupportedOptionException;
import javax.jdo.PersistenceManager;
import javax.jdo.PersistenceManagerFactory;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Set transaction isolation level of persistencemanagerfactory
*Keywords: persistencemanagerfactory
*Assertion IDs: A11.1-xxxx, A11.1-xxxx.
*Assertion Description:
* PersistenceManagerFactory.getTransactionIsolationLevel() returns the value
* of the transaction isolation level.
* PersistenceManagerFactory.setTransactionIsolationLevel(String) sets the value
* of the transaction isolation level.
*/
public class SetTransactionIsolationLevel extends JDO_Test
implements Constants {
/** */
private static final String ASSERTION_FAILED =
"Assertion A11.1-1, A11.1-2 (setTransactionIsolationLevel) failed: ";
/** All specified transaction isolation levels */
private static final String[] transactionIsolationLevels = new String[] {
TX_READ_UNCOMMITTED,
TX_READ_COMMITTED,
TX_REPEATABLE_READ,
TX_SNAPSHOT,
TX_SERIALIZABLE
};
private PersistenceManagerFactory pmf2;
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(SetTransactionIsolationLevel.class);
}
/** */
protected void localSetUp() {
// setUp gets a PMF that needs to be closed
closePMF();
}
/** Set TransactionIsolationLevel to all values via API. */
public void testSetTransactionIsolationLevelByAPI() {
// iterate through all possible TransactionIsolationLevels
for (int i = 0; i < transactionIsolationLevels.length; ++i) {
String transactionIsolationLevel = transactionIsolationLevels[i];
setTransactionIsolationLevelByAPI(transactionIsolationLevel);
}
failOnError();
}
/** Set TransactionIsolationLevel to all values from properties. */
public void testSetTransactionIsolationLevelFromProperties() {
// iterate through all possible TransactionIsolationLevels
for (int i = 0; i < transactionIsolationLevels.length; ++i) {
String transactionIsolationLevel = transactionIsolationLevels[i];
getPMFsetTransactionIsolationLevelFromProperties(transactionIsolationLevel);
}
failOnError();
}
/** Set TransactionIsolationLevel to all values. */
public void testTransactionIsolationLevelReadCommittedSupported() {
// this test depends on setUp initializing supportedOptions
String readCommitted =
PROPERTY_TRANSACTION_ISOLATION_LEVEL_READ_COMMITTED;
// make sure read committed is supported
if (!isSupported(readCommitted)) {
appendMessage(ASSERTION_FAILED
+ "\nSupportedOptions does not include "
+ readCommitted
+ ".");
}
failOnError();
}
/** */
private void setTransactionIsolationLevelByAPI(String level) {
pmf = getUnconfiguredPMF();
// Set datastore details so the implementation knows what is supported
pmf.setConnectionURL(getPMFProperty(CONNECTION_URL_PROP));
pmf.setConnectionUserName(getPMFProperty(CONNECTION_USERNAME_PROP));
pmf.setConnectionPassword(getPMFProperty(CONNECTION_PASSWORD_PROP));
pmf.setConnectionDriverName(getPMFProperty(PROPERTY_CONNECTION_DRIVER_NAME));
String property = PROPERTY_TRANSACTION_ISOLATION_LEVEL + "." + level;
try {
pmf.setTransactionIsolationLevel(level);
// Get first PM so the PMF is frozen
pmf.getPersistenceManager();
if (!isSupported(property)) {
appendMessage(ASSERTION_FAILED +
"\nCreated PersistenceManager for isolation level "+
level + " yet the PMF says that this level is not supported!\n");
}
} catch (JDOUnsupportedOptionException ex) {
// not supported, so check with the PMF if this should be supported
if (isSupported(property)) {
appendMessage(ASSERTION_FAILED +
"\nReceived JDOUnsupportedOptionException on creating the "+
"first PersistenceManager yet the PMF says that isolation level "+
"is supported!\n");
}
} catch (Throwable t) {
appendMessage(ASSERTION_FAILED +
"\nThe expected JDOUnsupportedOptionException was not " +
"thrown for unsupported isolation level " + level +
" but unexpected exception:\n" + t);
}
closePMF();
return;
}
/** */
private void getPMFsetTransactionIsolationLevelFromProperties(String level) {
String property = PROPERTY_TRANSACTION_ISOLATION_LEVEL + "." + level;
Map modifiedProps = new HashMap(PMFPropertiesObject);
modifiedProps.put(PROPERTY_TRANSACTION_ISOLATION_LEVEL, level);
if (isSupported(property)) {
pmf2 = JDOHelper.getPersistenceManagerFactory(modifiedProps);
String actual = pmf2.getTransactionIsolationLevel();
if (!validLevelSubstitution(level, actual)) {
appendMessage(ASSERTION_FAILED +
"\nTransactionIsolationLevel set to " + level +
"; value returned by PMF is " + actual);
}
PersistenceManager pm2 = pmf2.getPersistenceManager();
actual = pm2.currentTransaction().getIsolationLevel();
if (!validLevelSubstitution(level, actual)) {
appendMessage(ASSERTION_FAILED +
"\nTransactionIsolationLevel set to " + level +
"; value returned by Transaction is " + actual);
}
} else {
try {
pmf2 = JDOHelper.getPersistenceManagerFactory(modifiedProps);
// no exception thrown; bad
appendMessage(ASSERTION_FAILED +
"\nThe expected JDOUserException was not thrown for " +
"JDOHelper.getPersistenceManagerFactory " +
"for unsupported isolation level " + level + ".");
} catch (JDOUnsupportedOptionException ex) {
// good catch
} catch (Throwable t) {
appendMessage(ASSERTION_FAILED +
"\nThe expected JDOUserException was not thrown for " +
"JDOHelper.getPersistenceManagerFactory " +
"for unsupported isolation level " + level +
"but unexpected exception:\n" + t);
}
}
closePMF(pmf2);
return;
}
}
tck/src/java/org/apache/jdo/tck/api/persistencemanagerfactory/SupportedOptions.java 100664 4571 12500110374 31161 0 ustar mbouschen staff 0 0 /*
* 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.api.persistencemanagerfactory;
import java.util.Collection;
import java.util.Iterator;
import javax.jdo.PersistenceManagerFactory;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: SupportedOptions of persistencemanagerfactory
*Keywords: persistencemanagerfactory
*Assertion IDs: A11.5-1.
*Assertion Description:
* PersistenceManagerFactory.supportedOptions() returns a Collection
of String, each String instance representing an optional feature of the
implementation or a supported query language.
*/
/*
* Revision History
* ================
* Author : Linga Neerathilingam
* Date : 10/22/01
*
*/
public class SupportedOptions extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A11.5-1 (SupportedOptions) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(SupportedOptions.class);
}
/** */
public void test() {
PersistenceManagerFactory pmf = getPMF();
if (debug) logger.debug("Options supported by this implementation:");
Collection c = pmf.supportedOptions();
Iterator iter = c.iterator();
while( iter.hasNext() ){
String option = (String) iter.next();
if (debug) logger.debug(option);
}
}
}
tck/src/java/org/apache/jdo/tck/api/SignatureTest.java 100664 10205 12500110374 23161 0 ustar mbouschen staff 0 0 /*
* 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.api;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.util.BatchTestRunner;
import org.apache.jdo.tck.util.signature.SignatureVerifier;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.util.List;
import java.util.ArrayList;
import java.text.ParseException;
/**
*Title: SignatureTest
*Keywords: API
*Assertion IDs:
*Assertion Description:
* This test verifies that a set of JDO API classes and interfaces
* is compliant with a "signature" description, which has been verified
* against the JDO specification document. Any discrepancies between
* the feature declarations in the API classes and the signature descriptor
* are reported, including any public non-standard features found only in
* the API classes.
*/
public class SignatureTest extends JDO_Test {
private static String newLine = System.getProperty("line.separator");
/** */
private static final String ASSERTION_FAILED =
"API Signature Test failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(SignatureTest.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
}
/** Runs the API Signature Test. */
public void testSignatures() {
// create a SignatureVerifier instance
final StringWriter sw = new StringWriter();
final PrintWriter pw = new PrintWriter(sw); //auto-flushes on println
final boolean quiet = false;
final boolean verbose = debug;
final SignatureVerifier verifier
= new SignatureVerifier(pw, quiet, verbose);
// run the signature test
try {
// fetch name of signature file
final String signatureFileName
= System.getProperty("jdo.tck.signaturefile");
if (signatureFileName == null) {
fail(ASSERTION_FAILED,
"No system property defined: jdo.tck.signaturefile");
return;
}
// run the test
final List signatureFileNames = new ArrayList();
signatureFileNames.add(signatureFileName);
int status = verifier.test(signatureFileNames);
// print test's output in case of problems or debugging
if (status != 0) {
fail(ASSERTION_FAILED,
("Found problems or signature descrepancies." + newLine
+ "Test Output: " + newLine + sw.toString()));
logger.debug(sw.toString());
}
// print test's output in case of problems or debugging
if (debug) {
logger.debug(sw.toString());
}
} catch (IOException ex) {
fail(ASSERTION_FAILED,
("Exception caught: " + ex + newLine
+ "Test Output: " + newLine + sw.toString()));
} catch (ParseException ex) {
fail(ASSERTION_FAILED,
("Exception caught: " + ex + newLine
+ "Test Output: " + newLine + sw.toString()));
}
}
}
tck/src/java/org/apache/jdo/tck/enhancement/EnhancerTest.java 100664 7004 12500110373 24441 0 ustar mbouschen staff 0 0 /*
* 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.
*/
/*
* EnhancerTest.java
*
* Created on February 17, 2002, 1:59 PM
*/
package org.apache.jdo.tck.enhancement;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.List;
import java.util.Properties;
import java.util.StringTokenizer;
import org.apache.jdo.tck.JDO_Test;
/**
*
* @author Craig Russell
* @version 1.0
*/
public abstract class EnhancerTest extends JDO_Test {
/** Creates new EnhancerTest */
public EnhancerTest() {
}
/** */
protected Properties getProperties(String resourceName) {
Properties props = null;
try {
InputStream in = this.getClass().getClassLoader().getResourceAsStream(resourceName);
props = new Properties();
props.load(in);
} catch (Exception ex) {
ex.printStackTrace();
fail("EnhancerTest:",
"Error loading properties " + resourceName + " exception " + ex);
}
return props;
}
/** */
protected abstract void runTestOnePackage (String packageName, List fullyQualifiedClassNameList);
/** */
protected String convertClassName (String packageName, String className) {
return packageName + "." + className;
}
/** */
void runTestAllPackages() {
/** First, get classes to test from properties file.
*/
Properties classesToTest = getProperties("enhancement-test.properties"); //NOI18N
Enumeration enumeration = classesToTest.propertyNames();
int numberOfPackages = 0;
/** Each key is a package name; the value is a list of class names to test.
*/
while (enumeration.hasMoreElements()) {
++numberOfPackages;
String packageName = (String) enumeration.nextElement();
if (debug) logger.debug("EnhancerTest Package: " + packageName);
String classNames = (String) classesToTest.get(packageName);
if (debug) logger.debug("EnhancerTest Classes: " + classNames);
StringTokenizer st = new StringTokenizer(classNames, " ,");
ArrayList classNameList = new ArrayList();
/** Each entry is a list of class names separated by comma or space
*/
while (st.hasMoreTokens()) {
String className = st.nextToken();
String listEntry = convertClassName(packageName, className);
classNameList.add (listEntry);
if (debug) logger.debug("EnhancerTest Class: " + className);
}
runTestOnePackage (packageName, classNameList);
}
if (debug) logger.debug("EnhancerTest numberOfPackages: " + numberOfPackages);
return;
}
}
tck/src/java/org/apache/jdo/tck/extents/CloseAll.java 100664 5341 12500110374 22764 0 ustar mbouschen staff 0 0 /*
* 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.extents;
import java.util.Iterator;
import javax.jdo.Extent;
import org.apache.jdo.tck.pc.company.Employee;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: CloseAll
*Keywords: extent
*Assertion ID: A15.3-12.
*Assertion Description:
After a call to Extent.closeAll(), all iterators acquired from this
Extent will return false to hasNext().
*/
public class CloseAll extends ExtentTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A15.3-12 (CloseAll) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(CloseAll.class);
}
/** */
public void test() {
try {
beginTransaction();
Extent ex = getPM().getExtent (Employee.class, true);
Iterator it1 = ex.iterator();
deleteEmployee((Employee)it1.next());
Iterator it2 = ex.iterator();
addEmployee();
Iterator it3 = ex.iterator();
ex.closeAll();
if (it1.hasNext()) {
fail(ASSERTION_FAILED,
"After extent.closeAll() iterator1.hasNext(): " + it1.hasNext());
}
if (it2.hasNext()) {
fail(ASSERTION_FAILED,
"After extent.closeAll() iterator2.hasNext(): " + it2.hasNext());
}
if (it3.hasNext()) {
fail(ASSERTION_FAILED,
"After extent.closeAll() iterator3.hasNext(): " + it3.hasNext());
}
if (debug) logger.debug("Assertion A15.3-12 passed");
}
finally {
rollbackTransaction();
}
}
}
tck/src/java/org/apache/jdo/tck/extents/CloseOfExtentIteratorIsIteratorSpecific.java 100664 5226 12500110374 31200 0 ustar mbouschen staff 0 0 /*
* 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.extents;
import java.util.Collection;
import java.util.Iterator;
import javax.jdo.Extent;
import javax.jdo.Query;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Close of Extent Iterator is Iterator Specific
*Keywords: extent
*Assertion ID: A15.3-11.
*Assertion Description:
After a call to Extent.close(Iterator i),
the Extent itself can still be used to acquire other
iterators and can be used as the Extent for queries.
*/
public class CloseOfExtentIteratorIsIteratorSpecific extends ExtentTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A15.3-11 (CloseOfExtentIteratorIsIteratorSpecific) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(CloseOfExtentIteratorIsIteratorSpecific.class);
}
/** */
public void test() {
Extent ex = getExtent();
beginTransaction();
Iterator it1 = ex.iterator();
ex.close(it1);
int count = countIterator(ex.iterator());
if (count != 2) {
fail(ASSERTION_FAILED,
"iterating Employees after close of first iterator; counted " + count + " instances; should be 2");
}
Query q = getPM().newQuery(ex);
Collection c = (Collection)q.execute();
int count2 = countIterator(c.iterator());
commitTransaction();
if (count2 != 2) {
fail(ASSERTION_FAILED,
"in query after closing iterator; counted " + count2 + " instances; should be 2");
}
if (debug) logger.debug("Assertion A15.3-11 passed");
}
}
tck/src/java/org/apache/jdo/tck/extents/ExtentTest.java 100664 23247 12500110374 23422 0 ustar mbouschen staff 0 0 /*
* 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.extents;
import java.lang.reflect.Constructor;
import java.math.BigDecimal;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.HashSet;
import java.util.Iterator;
import java.util.TimeZone;
import javax.jdo.Extent;
import javax.jdo.JDOFatalInternalException;
import javax.jdo.PersistenceManager;
import javax.jdo.PersistenceManagerFactory;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.company.Address;
import org.apache.jdo.tck.pc.company.Company;
import org.apache.jdo.tck.pc.company.DentalInsurance;
import org.apache.jdo.tck.pc.company.Department;
import org.apache.jdo.tck.pc.company.Employee;
import org.apache.jdo.tck.pc.company.FullTimeEmployee;
import org.apache.jdo.tck.pc.company.MedicalInsurance;
import org.apache.jdo.tck.pc.company.PartTimeEmployee;
import org.apache.jdo.tck.pc.company.Project;
/**
*
* @author Craig Russell
* @version 1.0
*/
abstract class ExtentTest extends JDO_Test {
protected Class extentClass = Employee.class;
protected Company company;
protected Object companyOID;
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
addTearDownClass(DentalInsurance.class);
addTearDownClass(MedicalInsurance.class);
addTearDownClass(Project.class);
addTearDownClass(FullTimeEmployee.class);
addTearDownClass(PartTimeEmployee.class);
addTearDownClass(Employee.class);
addTearDownClass(Department.class);
addTearDownClass(Company.class);
}
/** Creates new ExtentTest */
public ExtentTest() {
if (PMFProperties == null)
{
PMFProperties = System.getProperty("user.home") + "/.jdo/PMFProperties.properties";
if (PMFProperties == null)
System.out.println ("Please specify PMF properties in {user.home}/.jdo/PMFProperties.properties");
}
}
/** */
protected void checkPM() {
try {
/** Don't use beginTransaction() because this calls getPM()
* which calls checkPM()! */
pm.currentTransaction().begin();
Extent ex = getPM().getExtent(Company.class, false);
int count = countIterator(ex.iterator());
pm.currentTransaction().commit();
if (count == 1) {
if (debug) logger.debug ("Found company");
return;
}
} catch (Exception e) {
e.printStackTrace(System.err);
System.err.println ("Failed to find Company; initializing DB");
}
initDB();
}
/** */
protected void initDB() {
HashSet h;
Address addr1 = new Address (7001L, "18 Network Circle",
"Santa Clara", "CA", "94455", "USA");
company = new Company (1L, "Sun Microsystems", new Date(), addr1);
GregorianCalendar born =
new GregorianCalendar(TimeZone.getTimeZone("America/Los_Angeles"));
GregorianCalendar hired =
new GregorianCalendar(TimeZone.getTimeZone("America/Los_Angeles"));
born.set(1969, 7, 20);
hired.set(1982, 5, 5);
Address addr2 = new Address (7002L, "43 Sematery Drive",
"Woodside", "CA", "94320", "USA");
Employee scott = new FullTimeEmployee(3001L, "Scott", "McNealy", "G",
born.getTime(), addr2,
hired.getTime(), 200000.0);
born.set(1960, 4, 8);
hired.set(1985, 2, 3);
Address addr3 = new Address (7003L, "1298 Wanderlust Road",
"Pleasanton", "CA", "95560", "USA");
Employee ed = new PartTimeEmployee(3002L, "Ed", "Zander", null,
born.getTime(), addr3,
hired.getTime(), 400000.0);
scott.addToTeam(ed);
// Set up their departments.
Department board =
new Department(2001L, "board", company);
h = new HashSet();
h.add(scott);
board.setEmployees(h);
scott.setDepartment(board);
company.addDepartment(board);
Department emg = new Department(2002L, "emg", company);
h = new HashSet();
h.add(ed);
emg.setEmployees(h);
ed.setDepartment(emg);
company.addDepartment(emg);
// Insure these guys
DentalInsurance scottDentalIns = new DentalInsurance(
5001L, "Aetna", scott, new BigDecimal("12000"));
MedicalInsurance scottMedicalIns = new MedicalInsurance(
5002L, "Aetna", scott, "PPO");
DentalInsurance edDentalIns = new DentalInsurance(
5003L, "BlueCross", ed, new BigDecimal("10000"));
MedicalInsurance edMedicalIns = new MedicalInsurance(
5004L, "BlueCross", ed, "EPO");
scott.setDentalInsurance(scottDentalIns);
scott.setMedicalInsurance(scottMedicalIns);
ed.setDentalInsurance(edDentalIns);
ed.setMedicalInsurance(edMedicalIns);
// Give them some projects to work on. Scott works on both; Ed only
// on one.
Project solaris = new Project(4001L, "Solaris", new BigDecimal(100.375));
Project sparc = new Project(4002L, "Sparc", new BigDecimal(200.500));
h = new HashSet();
h.add(scott);
h.add(ed);
solaris.setMembers(h); // Solaris is worked on by Scott and Ed
h = new HashSet();
h.add(scott);
sparc.setMembers(h); // Sparc is worked on by Scott
h = new HashSet();
h.add(solaris);
h.add(sparc);
scott.setProjects(h); // Scott works on Solaris and Sparc
h = new HashSet();
h.add(solaris);
ed.setProjects(h); // Ed works on Solaris
/* Now put all of these into the database
*/
pm.currentTransaction().begin();
pm.makePersistent (company);
pm.currentTransaction().commit();
// System.out.println ("Company OID: " + pm.getObjectId(company));
}
/** */
protected Employee addEmployee() {
Address addr1 = new Address (7004L, "456 Chelsey Lane",
"Mountain View", "CA", "94040", "USA");
Employee emp1 = new FullTimeEmployee (3003L, "First3003", "Last3003", "Middle3003",
new Date(), addr1, new Date(), 10000.0);
getPM().makePersistent (emp1);
return emp1;
}
/** */
protected void deleteEmployee(Employee e) {
getPM().deletePersistent (e);
}
/** */
protected int countIterator(Iterator it) {
int count = 0;
for (;it.hasNext();count++, it.next());
return count;
}
/** */
protected int printIterator(Iterator it) {
int count = 0;
for (;it.hasNext();count++) {
System.out.println (it.next().toString());
}
return count;
}
/** */
protected Extent getExtent() {
return getPM().getExtent(extentClass, true);
}
/** */
protected Object getCompanyOID () {
String companyOIDString = (String)
PMFPropertiesObject.get("org.apache.jdo.tck.extents.CompanyOID");
String companyOIDClassName = (String)
PMFPropertiesObject.get("org.apache.jdo.tck.extents.CompanyOIDClass");
if (companyOIDClassName == null) {
companyOIDClassName = "org.apache.jdo.impl.fostore.OID";
}
try {
Class companyOIDClass = Class.forName(companyOIDClassName);
Constructor companyOIDConstructor = companyOIDClass.getConstructor(new Class[] {String.class});
Object companyOID = companyOIDConstructor.newInstance (new Object[] {companyOIDString});
return companyOID;
}
catch (Exception ex) {
throw new JDOFatalInternalException (
"PMFProperties must be configured with the following properties\n" +
"\torg.apache.jdo.tck.extents.CompanyOID = \n" +
"\torg.apache.jdo.tck.extents.CompanyOIDClass = \n", ex);
}
}
/** */
protected PersistenceManager getPM() {
if (pm == null) {
pm = getPMF().getPersistenceManager();
checkPM();
}
return pm;
}
/** */
public PersistenceManagerFactory getPMF() {
if (pmf == null) {
pmf = super.getPMF();
}
return pmf;
}
/** */
protected void beginTransaction() {
getPM().currentTransaction().begin();
}
/** */
protected void commitTransaction() {
getPM().currentTransaction().commit();
}
/** */
protected void rollbackTransaction() {
getPM().currentTransaction().rollback();
}
}
tck/src/java/org/apache/jdo/tck/extents/GetCandidateClass.java 100664 3605 12500110374 24571 0 ustar mbouschen staff 0 0 /*
* 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.extents;
import javax.jdo.Extent;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Get Candidate Class
*Keywords: extent
*Assertion ID: A15.3-7.
*Assertion Description:
Extent.getCandidateClass() returns the class of the instances
contained in this Extent.
*/
public class GetCandidateClass extends ExtentTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A15.3-7 (GetCandidateClass) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(GetCandidateClass.class);
}
/** */
public void test() {
Extent ex = getExtent();
if (extentClass != ex.getCandidateClass()) {
fail(ASSERTION_FAILED,
"Candidate class in extent should be: " + extentClass.getClass().getName());
}
}
}
tck/src/java/org/apache/jdo/tck/extents/GetPersistenceManager.java 100664 4002 12500110374 25476 0 ustar mbouschen staff 0 0 /*
* 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.extents;
import javax.jdo.Extent;
import org.apache.jdo.tck.pc.company.Employee;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Get PersistenceManager
*Keywords: extent
*Assertion ID: A15.3-8.
*Assertion Description:
Extent.getPersistenceManager() returns the
PersistenceManager which created this Extent.
*/
public class GetPersistenceManager extends ExtentTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A15.3-8 (GetPersistenceManager) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(GetPersistenceManager.class);
}
/** */
public void test() {
Extent ex = getPM().getExtent (Employee.class, true);
if (pm != ex.getPersistenceManager()) {
fail(ASSERTION_FAILED,
"unexpected pm of extent, expected " + pm +
", got " + ex.getPersistenceManager());
}
}
}
tck/src/java/org/apache/jdo/tck/extents/HasSubclassesFalse.java 100664 3721 12500110374 25004 0 ustar mbouschen staff 0 0 /*
* 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.extents;
import javax.jdo.Extent;
import org.apache.jdo.tck.pc.company.Employee;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Has Subclasses is False
*Keywords: extent inheritance
*Assertion ID: A15.3-5.
*Assertion Description:
Extent.hasSubclasses() returns false
if the extent does not include subclasses.
*/
public class HasSubclassesFalse extends ExtentTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A15.3-5 (HasSubclassesFalse) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(HasSubclassesFalse.class);
}
/** */
public void test() {
Extent ex = getPM().getExtent (Employee.class, false);
if (ex.hasSubclasses()) {
fail(ASSERTION_FAILED,
"ex.hasSubclasses() returned true, but extent was created with subclasses=false.");
}
}
}
tck/src/java/org/apache/jdo/tck/extents/HasSubclassesTrue.java 100664 3704 12500110374 24672 0 ustar mbouschen staff 0 0 /*
* 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.extents;
import javax.jdo.Extent;
import org.apache.jdo.tck.pc.company.Employee;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Has Subclasses is True
*Keywords: extent inheritance
*Assertion ID: A15.3-6.
*Assertion Description:
Extent.hasSubclasses() returns true
if the extent includes subclasses.
*/
public class HasSubclassesTrue extends ExtentTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A15.3-6 (HasSubclassesTrue) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(HasSubclassesTrue.class);
}
/** */
public void test() {
Extent ex = getPM().getExtent (Employee.class, true);
if (!ex.hasSubclasses()) {
fail(ASSERTION_FAILED,
"ex.hasSubclasses() returned false, but extent was created with subclasses=true.");
}
}
}
tck/src/java/org/apache/jdo/tck/extents/InstancesDeletedPriorToIterationNotReturned.java 100664 5403 12500110374 32073 0 ustar mbouschen staff 0 0 /*
* 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.extents;
import java.util.Iterator;
import javax.jdo.Extent;
import org.apache.jdo.tck.pc.company.Employee;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Instances Deleted Prior to Iteration not Returned
*Keywords: extent
*Assertion ID: A15.3-3.
*Assertion Description:
If instances were deleted in the transaction prior to the execution of
Extent.iterator(), the returned Iterator
will not contain the instances.
*/
public class InstancesDeletedPriorToIterationNotReturned extends ExtentTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A15.3-3 (InstancesDeletedPriorToIterationNotReturned) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(InstancesDeletedPriorToIterationNotReturned.class);
}
/** */
public void test() {
try {
beginTransaction();
getPM().setIgnoreCache(false);
Extent ex = getPM().getExtent (Employee.class, true);
Iterator it1 = ex.iterator();
deleteEmployee((Employee)it1.next());
Iterator it2 = ex.iterator();
int count = countIterator(it2);
rollbackTransaction();
beginTransaction();
Iterator it3 = ex.iterator();
int count3 = countIterator(it3);
commitTransaction();
if (count != 1) {
fail(ASSERTION_FAILED,
"counted " + count + " after delete; should be 1");
}
if (count3 != 2) {
fail(ASSERTION_FAILED,
"counted " + count3 + "after rollback; should be 2");
}
}
finally {
}
}
}
tck/src/java/org/apache/jdo/tck/extents/InstancesPersistedPriorToIterationReturned.java 100664 5247 12500110374 32014 0 ustar mbouschen staff 0 0 /*
* 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.extents;
import java.util.Iterator;
import javax.jdo.Extent;
import org.apache.jdo.tck.pc.company.Employee;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Instances Persisted Prior to Iteration Returned
*Keywords: extent
*Assertion ID: A15.3-2.
*Assertion Description:
If instances were made persistent in the transaction prior to the execution of
Extent.iterator(), the returned Iterator
will contain the instances.
*/
public class InstancesPersistedPriorToIterationReturned extends ExtentTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A15.3-2 (InstancesPersistedPriorToIterationReturned) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(InstancesPersistedPriorToIterationReturned.class);
}
/** */
public void test() {
try {
beginTransaction();
getPM().setIgnoreCache(false);
Extent ex = getPM().getExtent (Employee.class, true);
addEmployee();
Iterator it = ex.iterator();
int count = countIterator(it);
rollbackTransaction();
beginTransaction();
Iterator it2 = ex.iterator();
int count2 = countIterator(it2);
commitTransaction();
if (count != 3) {
fail(ASSERTION_FAILED,
"Iterator: " + count + " should be 3");
}
if (count2 != 2) {
fail(ASSERTION_FAILED,
"Iterator2: " + count2 + "should be 2");
}
}
finally {
}
}
}
tck/src/java/org/apache/jdo/tck/extents/IteratorHasNextFalseAfterExtentClose.java 100664 6201 12500110374 30461 0 ustar mbouschen staff 0 0 /*
* 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.extents;
import java.util.Iterator;
import javax.jdo.Extent;
import org.apache.jdo.tck.pc.company.Employee;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Iterator HasNext returns False after Extent.close
*Keywords: extent
*Assertion ID: A15.3-9.
*Assertion Description:
After a call to Extent.close(Iterator i),
the parameter Iterator will return false
to hasNext().
*/
public class IteratorHasNextFalseAfterExtentClose extends ExtentTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A15.3-9 (IteratorHasNextFalseAfterExtentClose) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(IteratorHasNextFalseAfterExtentClose.class);
}
/** */
public void test() {
try {
beginTransaction();
Extent ex = getPM().getExtent (Employee.class, true);
Iterator it1 = ex.iterator();
deleteEmployee((Employee)it1.next());
Iterator it2 = ex.iterator();
addEmployee();
Iterator it3 = ex.iterator();
ex.close(it1);
ex.close(it2);
ex.close(it3);
rollbackTransaction();
beginTransaction();
Iterator it4 = ex.iterator();
int count4 = countIterator(it4);
rollbackTransaction();
if (debug) logger.debug ("Iterator4 after rollback: " + count4);
if (it1.hasNext()) {
fail(ASSERTION_FAILED,
"iterator1.hasNext(): " + it1.hasNext());
}
if (it2.hasNext()) {
fail(ASSERTION_FAILED,
"iterator2.hasNext(): " + it2.hasNext());
}
if (it3.hasNext()) {
fail(ASSERTION_FAILED,
"iterator3.hasNext(): " + it3.hasNext());
}
if (count4 != 2) {
fail(ASSERTION_FAILED,
"Iterator " + count4 + " should be 2");
}
}
finally {
}
}
}
tck/src/java/org/apache/jdo/tck/extents/IteratorMutatingMethods.java 100664 4503 12500110374 26113 0 ustar mbouschen staff 0 0 /*
* 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.extents;
import java.util.Iterator;
import javax.jdo.Extent;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Iterator Mutating Methods
*Keywords: extent exception
*Assertion ID: A15.3-4.
*Assertion Description:
If any mutating method, including the remove method,
is called on the Iterator returned by Extent.iterator(),
an UnsupportedOperationException is thrown.
*/
public class IteratorMutatingMethods extends ExtentTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A15.3-4 (IteratorMutatingMethods) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(IteratorMutatingMethods.class);
}
/** */
public void test() {
beginTransaction();
Extent ex = getExtent();
Iterator it = ex.iterator();
it.next();
try {
it.remove();
fail(ASSERTION_FAILED,
"extent.iterator().remove() should throw UnsupportedOperationException");
}
catch (UnsupportedOperationException expected) {
// expected exception
if (debug) logger.debug("expected exception " + ex);
}
finally {
}
commitTransaction();
}
}
tck/src/java/org/apache/jdo/tck/extents/IteratorNextAfterExtentClose.java 100664 6630 12500110374 27060 0 ustar mbouschen staff 0 0 /*
* 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.extents;
import java.util.Iterator;
import java.util.NoSuchElementException;
import javax.jdo.Extent;
import org.apache.jdo.tck.pc.company.Employee;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Iterator Next After Extent Close
*Keywords: extent exception
*Assertion ID: A15.3-10.
*Assertion Description:
After a call to Extent.close(Iterator i),
the parameter Iterator
will throw a NoSuchElementException to next().
*/
public class IteratorNextAfterExtentClose extends ExtentTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A15.3-10 (IteratorNextAfterExtentClose) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(IteratorNextAfterExtentClose.class);
}
/** */
public void test() {
try {
beginTransaction();
Extent ex = getPM().getExtent (Employee.class, true);
Iterator it1 = ex.iterator();
deleteEmployee((Employee)it1.next());
Iterator it2 = ex.iterator();
addEmployee();
Iterator it3 = ex.iterator();
ex.close(it1);
ex.close(it2);
ex.close(it3);
try {
tryNext(it1);
tryNext(it2);
tryNext(it3);
rollbackTransaction();
beginTransaction();
Iterator it4 = ex.iterator();
int count4 = countIterator(it4);
commitTransaction();
if (count4 != 2) {
fail(ASSERTION_FAILED,
"Iterator4 after rollback: " + count4 + "; should be 2");
}
}
catch (Exception unexpected) {
fail(ASSERTION_FAILED,
"unexpected exception " + unexpected);
}
}
catch (Exception unexpected) {
fail(ASSERTION_FAILED,
"unexpected exception " + unexpected);
}
}
/** */
void tryNext (Iterator it) throws Exception {
try {
it.next();
fail(ASSERTION_FAILED,
"expected NoSuchElementException thrown by iterator.next().");
} catch (NoSuchElementException expected) {
// expecteed exception
}
}
}
tck/src/java/org/apache/jdo/tck/extents/IteratorNextAfterExtentCloseAll.java 100664 5767 12500110374 27523 0 ustar mbouschen staff 0 0 /*
* 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.extents;
import java.util.Iterator;
import java.util.NoSuchElementException;
import javax.jdo.Extent;
import org.apache.jdo.tck.pc.company.Employee;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Iterator Next After Extent CloseAll
*Keywords: extent
*Assertion ID: A15.3-13.
*Assertion Description:
After a call to Extent.closeAll(), all iterators acquired from this
Extent will throw a NoSuchElementException
to next().
*/
public class IteratorNextAfterExtentCloseAll extends ExtentTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A15.3-13 (IteratorNextAfterExtentCloseAll) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(IteratorNextAfterExtentCloseAll.class);
}
/** */
public void test() {
try {
beginTransaction();
Extent ex = getPM().getExtent (Employee.class, true);
Iterator it1 = ex.iterator();
deleteEmployee((Employee)it1.next());
Iterator it2 = ex.iterator();
addEmployee();
Iterator it3 = ex.iterator();
ex.closeAll();
if (!tryNext(it1)) {
fail(ASSERTION_FAILED,
"iterator1.next() does not throw NoSuchElementException.");
}
if (!tryNext(it2)) {
fail(ASSERTION_FAILED,
"iterator2.next() does not throw NoSuchElementException.");
}
if (!tryNext(it3)) {
fail(ASSERTION_FAILED,
"iterator3.next() does not throw NoSuchElementException.");
}
}
finally {
rollbackTransaction();
}
}
/** */
boolean tryNext (Iterator it) {
try {
it.next();
} catch (NoSuchElementException expected) {
return true;
}
return false;
}
}
tck/src/java/org/apache/jdo/tck/extents/Iterators.java 100664 4124 12500110374 23240 0 ustar mbouschen staff 0 0 /*
* 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.extents;
import java.util.Iterator;
import javax.jdo.Extent;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Iterators
*Keywords: extent
*Assertion ID: A15.3-1.
*Assertion Description:
Extent.iterator() returns an Iterator
over all the instances in the Extent.
*/
public class Iterators extends ExtentTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A15.3-1 (Iterators) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(Iterators.class);
}
/** */
public void test() {
Extent ex = getExtent();
int count = 0;
beginTransaction();
for (Iterator it = ex.iterator(); it.hasNext();++count) {
Object emp = it.next();
if (debug) logger.debug(emp.toString());
}
rollbackTransaction();
if (count != 2) {
fail(ASSERTION_FAILED,
"Emplyoee extent should have 2 instances, got " + count);
}
}
}
tck/src/java/org/apache/jdo/tck/JDO_Test.java 100664 131076 12500110374 21254 0 ustar mbouschen staff 0 0 /*
* 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.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.StringTokenizer;
import java.util.Vector;
import javax.jdo.Constants;
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;
import org.springframework.util.ClassUtils;
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";
/** Map of transaction isolation String values to Integer */
protected final static Map levelValues = new HashMap();
static {
levelValues.put(Constants.TX_READ_UNCOMMITTED, 0);
levelValues.put(Constants.TX_READ_COMMITTED, 1);
levelValues.put(Constants.TX_REPEATABLE_READ, 2);
levelValues.put(Constants.TX_SNAPSHOT, 3);
levelValues.put(Constants.TX_SERIALIZABLE, 4);
}
/**
* 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. */
protected 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 tearDown.
* At the end of method tearDown this field is nullified.
*/
private Throwable tearDownThrowable;
/**
* A list of registered oid instances.
* Corresponding pc instances are deleted in localTearDown.
*/
private Collection tearDownInstances = new LinkedList();
/**
* A list of registered pc classes.
* The extents of these classes are deleted in localTearDown.
*/
private Collection tearDownClasses = new LinkedList();
/**
* Intended for subclasses so that they may skip this class's normal set up procedure.
* @return true to run normal set up, false to skip normal set up
*/
protected boolean preSetUp() {
return true;
}
protected final void setUp() throws Exception {
if (!preSetUp()) {
return;
}
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 tearDownThrowable if it is null.
* 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;
}
}
/**
* Intended for subclasses so that they may skip this class's normal tear down procedure.
* @return true to run normal tear down, false to skip normal tear down
*/
protected boolean preTearDown() {
return true;
}
/**
* This method clears data and resources allocated by testcases.
* It first closes the persistence manager of this testcase.
* Then it calls method localTearDown.
* Subclasses may override that method to clear any data and resources
* that they have allocated in method localSetUp.
* Finally, this method closes the persistence manager factory.
*
* Note: These methods are called always, regardless of any exceptions.
* The first caught exception is kept in field tearDownThrowable.
* That exception is thrown as a nested exception of JDOFatalException
* 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.
*
* Note: 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() {
if (!preTearDown()) {
return;
}
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 localSetUp.
*/
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 PersistenceManagerFactory instance
* for the implementation under test.
* @return field pmf if it is not null,
* else sets field pmf 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;
}
protected Class getPMFClass()
{
if (pmf != null) {
return pmf.getClass();
}
PMFPropertiesObject = loadProperties(PMFProperties);
String name = PMFPropertiesObject.getProperty(PMF_CLASS_PROP);
try {
return Class.forName(name);
} catch (ClassNotFoundException ex) {
throw new JDOException("Cannot find PMF class '" + name + "'.",
ex);
}
}
/**
* Get the PersistenceManagerFactory 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 pmf if it is not null,
* else sets field pmf to a new instance and returns that instance.
*/
protected PersistenceManagerFactory getUnconfiguredPMF()
{
if (pmf == null) {
String name = null;
try {
Class pmfClass = getPMFClass();
name = pmfClass.getName();
pmf = (PersistenceManagerFactory) pmfClass.newInstance();
if (supportedOptions == null) {
supportedOptions = pmf.supportedOptions();
}
} 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 PersistenceManager 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
* PersistenceManager. 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
* PersistenceManager. 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()) {
closePMF(pmf);
}
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]);
}
}
catch (RuntimeException ex) {
pmf = null;
ex.printStackTrace(System.out);
throw ex;
}
}
// rethrow JDOException thrown by pmf.close
if (failure != null)
throw failure;
}
/** Closes the pmf passed as a parameter.
* This must be done in a doPrivileged block.
*/
public static void closePMF(final PersistenceManagerFactory PMF) {
if (PMF != null) {
if (!PMF.isClosed()) {
AccessController.doPrivileged(
new PrivilegedAction () {
public Object run () {
PMF.close();
return null;
}
}
);
}
}
}
/** */
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 supportedOptions.contains(
"javax.jdo.option.TransientTransactional");
}
/** Reports whether NontransactionalRead is supported. */
public boolean isNontransactionalReadSupported(){
return supportedOptions.contains(
"javax.jdo.option.NontransactionalRead");
}
/** Reports whether NontransactionalWrite is supported. */
public boolean isNontransactionalWriteSupported() {
return supportedOptions.contains(
"javax.jdo.option.NontransactionalWrite");
}
/** Reports whether RetainValues is supported. */
public boolean isRetainValuesSupported()
{
return supportedOptions.contains(
"javax.jdo.option.RetainValues");
}
/** Reports whether Optimistic is supported. */
public boolean isOptimisticSupported() {
return supportedOptions.contains(
"javax.jdo.option.Optimistic");
}
/** Reports whether Application Identity is supported. */
public boolean isApplicationIdentitySupported() {
return supportedOptions.contains(
"javax.jdo.option.ApplicationIdentity");
}
/** Reports whether Datastore Identity is supported. */
public boolean isDatastoreIdentitySupported() {
return supportedOptions.contains(
"javax.jdo.option.DatastoreIdentity");
}
/** Reports whether Non-Durable Identity is supported. */
public boolean isNonDurableIdentitySupported() {
return supportedOptions.contains(
"javax.jdo.option.NonDurableIdentity");
}
/** Reports whether an ArrayList collection is supported. */
public boolean isArrayListSupported() {
return supportedOptions.contains(
"javax.jdo.option.ArrayList");
}
/** Reports whether a HashMap collection is supported. */
public boolean isHashMapSupported() {
return supportedOptions.contains(
"javax.jdo.option.HashMap");
}
/** Reports whether a Hashtable collection is supported. */
public boolean isHashtableSupported() {
return supportedOptions.contains(
"javax.jdo.option.Hashtable");
}
/** Reports whether a LinkedList collection is supported. */
public boolean isLinkedListSupported() {
return supportedOptions.contains(
"javax.jdo.option.LinkedList");
}
/** Reports whether a TreeMap collection is supported. */
public boolean isTreeMapSupported() {
return supportedOptions.contains(
"javax.jdo.option.TreeMap");
}
/** Reports whether a TreeSet collection is supported. */
public boolean isTreeSetSupported() {
return supportedOptions.contains(
"javax.jdo.option.TreeSet");
}
/** Reports whether a Vector collection is supported. */
public boolean isVectorSupported() {
return supportedOptions.contains(
"javax.jdo.option.Vector");
}
/** Reports whether a Map collection is supported. */
public boolean isMapSupported() {
return supportedOptions.contains(
"javax.jdo.option.Map");
}
/** Reports whether a List collection is supported. */
public boolean isListSupported() {
return supportedOptions.contains(
"javax.jdo.option.List");
}
/** Reports whether arrays are supported. */
public boolean isArraySupported() {
return supportedOptions.contains(
"javax.jdo.option.Array");
}
/** Reports whether a null collection is supported. */
public boolean isNullCollectionSupported() {
return supportedOptions.contains(
"javax.jdo.option.NullCollection");
}
/** Reports whether Changing Application Identity is supported. */
public boolean isChangeApplicationIdentitySupported() {
return supportedOptions.contains(
"javax.jdo.option.ChangeApplicationIdentity");
}
/** Reports whether Binary Compatibility is supported. */
public boolean isBinaryCompatibilitySupported() {
return supportedOptions.contains(
"javax.jdo.option.BinaryCompatibility");
}
/** Reports whether UnconstrainedVariables is supported. */
public boolean isUnconstrainedVariablesSupported() {
return supportedOptions.contains(
"javax.jdo.option.UnconstrainedVariables");
}
/** Reports whether SQL queries are supported. */
public boolean isSQLSupported() {
return supportedOptions.contains(
"javax.jdo.query.SQL");
}
/** Reports whether getting the DataStoreConnection is supported. */
public boolean isDataStoreConnectionSupported() {
return supportedOptions.contains(
"javax.jdo.option.GetDataStoreConnection");
}
/** Reports whether canceling a running query is supported. */
public boolean isQueryCancelSupported() {
return supportedOptions.contains(
"javax.jdo.option.QueryCancel");
}
/** Reports whether setting a Datastore timout is supported. */
public boolean isDatastoreTimeoutSupported() {
return supportedOptions.contains(
Constants.OPTION_DATASTORE_TIMEOUT);
}
/** Reports whether a feature is supported */
public boolean isSupported(String option) {
return supportedOptions.contains(option);
}
/**
* 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 String that indicates the
* current state of an instance.
* @param o The object.
* @return The current state of the instance, by using the
* JDOHelper 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:
*
* ReflectPermission("suppressAccessChecks")
* RuntimePermission("accessDeclaredMembers")
*
*/
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 true if the current test runs with application
* identity. This means the system property jdo.tck.identitytype has the
* value applicationidentity.
* @return true if current test runs with application
* identity; false 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 key.
* @param key the key
* @return the value
*/
protected String getPMFProperty(String key) {
return PMFPropertiesObject.getProperty(key);
}
/**
* Returns true if the implementation under test
* supports all JDO options contained in system property
* jdo.tck.requiredOptions.
* @return true if the implementation under test
* supports all JDO options contained in system property
* jdo.tck.requiredOptions
*/
protected boolean isTestToBePerformed() {
boolean isTestToBePerformed = true;
String requiredOptions = System.getProperty("jdo.tck.requiredOptions");
// Collection supportedOptions = 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);
}
}
/** Appends an error if the actual value does not equal the expected value.
* Primitive values are autoboxed. Null values are ok for both expected and actual.
*/
protected void errorIfNotEqual(String message, Object expected, Object actual) {
if (expected == null) {
if (actual != null) {
appendMessage(message + " failed. expected: null; actual: " + actual);
}
} else {
if (!expected.equals(actual)) {
appendMessage(message + " failed. expected: " + expected + "; actual: " + actual);
}
}
}
/** Appends an error if the actual value equals the unexpected value.
* Primitive values are autoboxed. Null values are ok for both unexpected and actual.
*/
protected void errorIfEqual(String message, Object unexpected, Object actual) {
if (unexpected == null) {
if (actual == null) {
appendMessage(message + " failed. unexpected: null");
}
} else {
if (unexpected.equals(actual)) {
appendMessage(message + " failed. unexpected: " + unexpected);
}
}
}
/**
* Returns collected error messages, or null 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);
}
}
/** Validate an actual isolation level against the requested level. */
protected boolean validLevelSubstitution(String requested, String actual) {
int requestedLevel = ((Integer)levelValues.get(requested)).intValue();
int actualLevel = ((Integer)levelValues.get(actual)).intValue();
return actualLevel >= requestedLevel;
}
}
tck/src/java/org/apache/jdo/tck/lifecycle/HollowInstanceMaintainsPK.java 100664 7323 12500110374 26565 0 ustar mbouschen staff 0 0 /*
* 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.lifecycle;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.mylib.PCPoint;
import org.apache.jdo.tck.pc.mylib.PCRect;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Test that Hollow Instances maintains PK
*Keywords: lifecycle hollow instance PK
*Assertion IDs: A5.5.4-3
*Assertion Description:
If the instance is of a class using application identity, the hollow instance maintains its primary key fields.
*/
public class HollowInstanceMaintainsPK extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A5.5.4-3 (HollowInstanceMaintainsPK) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(HollowInstanceMaintainsPK.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
addTearDownClass(PCRect.class);
addTearDownClass(PCPoint.class);
}
/** */
public void test() {
if (!isApplicationIdentitySupported()) {
printUnsupportedOptionalFeatureNotTested(
getClass().getName(),
"javax.jdo.option.ApplicationIdentity");
} else if (!runsWithApplicationIdentity()) {
printNonApplicableIdentityType(
getClass().getName(),
"javax.jdo.option.ApplicationIdentity");
}
else {
pm = getPM();
pm.currentTransaction().begin();
PCRect obj = getPersistentNewInstance();
long beforeValue=obj.getId();
pm.currentTransaction().commit(); // obj should transition to HOLLOW
//The next call obj.getId() is a primary key access.
//The method must not be called inside a transaction,
//because a JDO implementation must allow primary key accesses
//outside of transactions.
long afterValue=obj.getId();
if (beforeValue!=afterValue) {
fail(ASSERTION_FAILED,
"Key field value incorrect after commit. Expected: " +
beforeValue + " Found: " + afterValue);
}
}
}
/** */
private PCRect getPersistentNewInstance() {
PCRect obj = new PCRect(0, new PCPoint(1,5), new PCPoint(7,3));
pm.makePersistent(obj); // obj should transition to persistent-new
int curr = currentState(obj);
if( curr != PERSISTENT_NEW ){
fail(ASSERTION_FAILED,
"StateTransitions: Unable to create persistent-new instance " +
"from transient instance via makePersistent(), state is " +
states[curr]);
}
return obj;
}
}
tck/src/java/org/apache/jdo/tck/lifecycle/MultiplePMsReturnInstancesRepresentingSamePC.java 100664 11334 12500110374 32454 0 ustar mbouschen staff 0 0 /*
* 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.lifecycle;
import java.util.Iterator;
import javax.jdo.Extent;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.lifecycle.StateTransitionObj;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Test that Multiple PMs return different instances representing same PC object
*Keywords: lifecycle Multiple PMs getObjectById equal
*Assertion IDs: A5.4-7
*Assertion Description:
The instance returned by a call to getObjectById(Object) of different PersistenceManager
instances returned by the same PersistenceManagerFactory represent the same persistent object,
but with different Java object identity (specifically, all instances returned by getObjectId from the instances
must return true to equals comparisons with all others).
*/
public class MultiplePMsReturnInstancesRepresentingSamePC extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A5.4-7 (MultiplePMsReturnInstancesRepresentingSamePC) failed: ";
private static final int NUM_OBJECTS = 50;
/** The persistent instances of this test. */
private Object[] obj;
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(MultiplePMsReturnInstancesRepresentingSamePC.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
pm = getPM();
addTearDownClass(StateTransitionObj.class);
obj = generatePersistentInstances();
}
public void test() {
PersistenceManager pm2 = null;
PersistenceManager pm3 = null;
try {
// Get two more PMs
pm2 = pmf.getPersistenceManager();
pm3 = pmf.getPersistenceManager();
pm.currentTransaction().begin();
Extent extent = pm.getExtent(StateTransitionObj.class, false);
Iterator iter = extent.iterator();
if( !iter.hasNext() ){
fail(ASSERTION_FAILED,
"Extent for StateTransitionObj should not be empty");
}
extent.close(iter);
for (int i=0; iTitle: Test NontransactionalWriteDatastoreCommit
*Keywords: NontransactionalWrite datastore commit
*Assertion ID: A5.6.2-4, A5.6.2-6, A5.6.2-8, A5.6.2-10.
*Assertion Description:
A5.6.2-4 [If a datastore transaction is begun, commit will write
the changes to the datastore with no checking as to
the current state of the instances in the datastore.
That is, the changes made outside the transaction
together with any changes made inside the transaction
will overwrite the current state of the datastore.]
A5.6.2-6 [If a datastore transaction is begun, rollback will not write
any changes to the datastore.]
A5.6.2-8 [If an optimistic transaction is begun, commit will write
the changes to the datastore after checking as to the current state
of the instances in the datastore. The changes made outside
the transaction together with any changes made inside the transaction
will update the current state of the datastore if the version
checking is successful.]
A5.6.2-10 [If an optimistic transaction is begun, rollback will not write
any changes to the datastore. The persistent-nontransactional-dirty
instances will transition according to the RestoreValues flag. ]
*/
public class NontransactionalWriteDatastoreCommit
extends NontransactionalWriteTest {
/** */
protected static final String ASSERTION_FAILED =
"Assertion A5.6.2-4 (NontransactionalWriteDatastoreCommit) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(NontransactionalWriteDatastoreCommit.class);
}
/**
* Create a nontransactional dirty instance, begin and commit
* a datastore transaction, and check that the instance in
* the datastore has the value as changed by the transaction.
*/
public void testDatastoreCommit() {
if (!checkNontransactionalFeaturesSupported(false))
return;
createAndModifyVersionedPCPoint();
beginAndCommitTransaction(false);
checkXValue(ASSERTION_FAILED + "after datastore commit",
newXValue);
failOnError();
}
}
tck/src/java/org/apache/jdo/tck/lifecycle/NontransactionalWriteDatastoreCommitConflict.java 100664 6756 12500110374 32600 0 ustar mbouschen staff 0 0 /*
* 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.lifecycle;
import javax.jdo.JDOUnsupportedOptionException;
import javax.jdo.PersistenceManager;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.mylib.VersionedPCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Test NontransactionalWriteDatastoreCommitConflict
*Keywords: NontransactionalWrite datastore commit
*Assertion ID: A5.6.2-4, A5.6.2-6, A5.6.2-8, A5.6.2-10.
*Assertion Description:
A5.6.2-4 [If a datastore transaction is begun, commit will write
the changes to the datastore with no checking as to
the current state of the instances in the datastore.
That is, the changes made outside the transaction
together with any changes made inside the transaction
will overwrite the current state of the datastore.]
A5.6.2-6 [If a datastore transaction is begun, rollback will not write
any changes to the datastore.]
A5.6.2-8 [If an optimistic transaction is begun, commit will write
the changes to the datastore after checking as to the current state
of the instances in the datastore. The changes made outside
the transaction together with any changes made inside the transaction
will update the current state of the datastore if the version
checking is successful.]
A5.6.2-10 [If an optimistic transaction is begun, rollback will not write
any changes to the datastore. The persistent-nontransactional-dirty
instances will transition according to the RestoreValues flag. ]
*/
public class NontransactionalWriteDatastoreCommitConflict
extends NontransactionalWriteTest {
/** */
protected static final String ASSERTION_FAILED =
"Assertion A5.6.2-4 " +
"(NontransactionalWriteDatastoreCommitConflict) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(NontransactionalWriteDatastoreCommitConflict.class);
}
/**
* Create a nontransactional dirty instance, begin and commit
* a conflicting transaction, begin and commit a datastore
* transaction, and check that the instance in the datastore
* was overwritten by this datastore transaction.
*/
public void testDatastoreCommitConflict() {
if (!checkNontransactionalFeaturesSupported(false))
return;
createAndModifyVersionedPCPoint();
conflictingUpdate();
beginAndCommitTransaction(false);
checkXValue(ASSERTION_FAILED + "after datastore commit with conflict",
newXValue);
failOnError();
}
} tck/src/java/org/apache/jdo/tck/lifecycle/NontransactionalWriteDatastoreRollback.java 100664 6527 12500110374 31413 0 ustar mbouschen staff 0 0 /*
* 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.lifecycle;
import javax.jdo.JDOUnsupportedOptionException;
import javax.jdo.PersistenceManager;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.mylib.VersionedPCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Test NontransactionalWriteDatastoreRollback
*Keywords: NontransactionalWrite datastore rollback
*Assertion ID: A5.6.2-4, A5.6.2-6, A5.6.2-8, A5.6.2-10.
*Assertion Description:
A5.6.2-4 [If a datastore transaction is begun, commit will write
the changes to the datastore with no checking as to
the current state of the instances in the datastore.
That is, the changes made outside the transaction
together with any changes made inside the transaction
will overwrite the current state of the datastore.]
A5.6.2-6 [If a datastore transaction is begun, rollback will not write
any changes to the datastore.]
A5.6.2-8 [If an optimistic transaction is begun, commit will write
the changes to the datastore after checking as to the current state
of the instances in the datastore. The changes made outside
the transaction together with any changes made inside the transaction
will update the current state of the datastore if the version
checking is successful.]
A5.6.2-10 [If an optimistic transaction is begun, rollback will not write
any changes to the datastore. The persistent-nontransactional-dirty
instances will transition according to the RestoreValues flag. ]
*/
public class NontransactionalWriteDatastoreRollback
extends NontransactionalWriteTest {
/** */
protected static final String ASSERTION_FAILED =
"Assertion A5.6.2-6 (NontransactionalWriteDatastoreRollback) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(NontransactionalWriteDatastoreRollback.class);
}
/**
* Create a nontransactional dirty instance, begin and rollback
* a datastore transaction, and check that the instance in
* the datastore has the original value.
*/
public void testDatastoreRollback() {
if (!checkNontransactionalFeaturesSupported(false))
return;
createAndModifyVersionedPCPoint();
beginAndRollbackTransaction(false);
checkXValue(ASSERTION_FAILED + "after datastore rollback",
originalXValue);
failOnError();
}
} tck/src/java/org/apache/jdo/tck/lifecycle/NontransactionalWriteOptimisticCommit.java 100664 6535 12500110374 31307 0 ustar mbouschen staff 0 0 /*
* 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.lifecycle;
import javax.jdo.JDOUnsupportedOptionException;
import javax.jdo.PersistenceManager;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.mylib.VersionedPCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: TestNontransactionalWriteOptimisticCommit
*Keywords: NontransactionalWrite optimistic commit
*Assertion ID: A5.6.2-4, A5.6.2-6, A5.6.2-8, A5.6.2-10.
*Assertion Description:
A5.6.2-4 [If a datastore transaction is begun, commit will write
the changes to the datastore with no checking as to
the current state of the instances in the datastore.
That is, the changes made outside the transaction
together with any changes made inside the transaction
will overwrite the current state of the datastore.]
A5.6.2-6 [If a datastore transaction is begun, rollback will not write
any changes to the datastore.]
A5.6.2-8 [If an optimistic transaction is begun, commit will write
the changes to the datastore after checking as to the current state
of the instances in the datastore. The changes made outside
the transaction together with any changes made inside the transaction
will update the current state of the datastore if the version
checking is successful.]
A5.6.2-10 [If an optimistic transaction is begun, rollback will not write
any changes to the datastore. The persistent-nontransactional-dirty
instances will transition according to the RestoreValues flag. ]
*/
public class NontransactionalWriteOptimisticCommit
extends NontransactionalWriteTest {
/** */
protected static final String ASSERTION_FAILED =
"Assertion A5.6.2-8 (NontransactionalWriteOptimisticCommit) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(NontransactionalWriteOptimisticCommit.class);
}
/**
* Create a nontransactional dirty instance, begin and commit
* an optimistic transaction, and check that the instance in
* the datastore has the value as changed by the transaction.
*/
public void testOptimisticCommit() {
if (!checkNontransactionalFeaturesSupported(true))
return;
createAndModifyVersionedPCPoint();
beginAndCommitTransaction(true);
checkXValue(ASSERTION_FAILED + "after optimistic commit",
newXValue);
failOnError();
}
} tck/src/java/org/apache/jdo/tck/lifecycle/NontransactionalWriteOptimisticCommitConflict.java 100664 7101 12500110374 32757 0 ustar mbouschen staff 0 0 /*
* 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.lifecycle;
import javax.jdo.JDOUnsupportedOptionException;
import javax.jdo.PersistenceManager;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.mylib.VersionedPCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Test NontransactionalWriteOptimisticCommitConflict
*Keywords: NontransactionalWrite optimistic
*Assertion ID: A5.6.2-4, A5.6.2-6, A5.6.2-8, A5.6.2-10.
*Assertion Description:
A5.6.2-4 [If a datastore transaction is begun, commit will write
the changes to the datastore with no checking as to
the current state of the instances in the datastore.
That is, the changes made outside the transaction
together with any changes made inside the transaction
will overwrite the current state of the datastore.]
A5.6.2-6 [If a datastore transaction is begun, rollback will not write
any changes to the datastore.]
A5.6.2-8 [If an optimistic transaction is begun, commit will write
the changes to the datastore after checking as to the current state
of the instances in the datastore. The changes made outside
the transaction together with any changes made inside the transaction
will update the current state of the datastore if the version
checking is successful.]
A5.6.2-10 [If an optimistic transaction is begun, rollback will not write
any changes to the datastore. The persistent-nontransactional-dirty
instances will transition according to the RestoreValues flag. ]
*/
public class NontransactionalWriteOptimisticCommitConflict
extends NontransactionalWriteTest {
/** */
protected static final String ASSERTION_FAILED =
"Assertion A5.6.2-8 " +
"(NontransactionalWriteOptimisticCommitConflict) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run
(NontransactionalWriteOptimisticCommitConflict.class);
}
/**
* Create a nontransactional dirty instance, begin and commit
* a conflicting transaction, begin and commit an optimistic
* transaction and check that the instance in the datastore
* has the value as changed by the conflicting transaction.
*/
public void testOptimisticCommitConflict() {
if (!checkNontransactionalFeaturesSupported(true))
return;
String location =
ASSERTION_FAILED + "after optimistic commit with conflict";
createAndModifyVersionedPCPoint();
conflictingUpdate();
beginAndCommitTransactionFails(location, true);
checkXValue(location, conflictXValue);
failOnError();
}
} tck/src/java/org/apache/jdo/tck/lifecycle/NontransactionalWriteOptimisticRollback.java 100664 6521 12500110374 31603 0 ustar mbouschen staff 0 0 /*
* 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.lifecycle;
import javax.jdo.JDOUnsupportedOptionException;
import javax.jdo.PersistenceManager;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.mylib.VersionedPCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Test NontransactionalWriteOptimisticRollback
*Keywords: NontransactionalWrite optimistic rollback
*Assertion ID: A5.6.2-4, A5.6.2-6, A5.6.2-8, A5.6.2-10.
*Assertion Description:
A5.6.2-4 [If a datastore transaction is begun, commit will write
the changes to the datastore with no checking as to
the current state of the instances in the datastore.
That is, the changes made outside the transaction
together with any changes made inside the transaction
will overwrite the current state of the datastore.]
A5.6.2-6 [If a datastore transaction is begun, rollback will not write
any changes to the datastore.]
A5.6.2-8 [If an optimistic transaction is begun, commit will write
the changes to the datastore after checking as to the current state
of the instances in the datastore. The changes made outside
the transaction together with any changes made inside the transaction
will update the current state of the datastore if the version
checking is successful.]
A5.6.2-10 [If an optimistic transaction is begun, rollback will not write
any changes to the datastore. The persistent-nontransactional-dirty
instances will transition according to the RestoreValues flag. ]
*/
public class NontransactionalWriteOptimisticRollback
extends NontransactionalWriteTest {
/** */
protected static final String ASSERTION_FAILED =
"Assertion A5.6.2-10 (NontransactionalWriteOptimisticRollback) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(NontransactionalWriteOptimisticRollback.class);
}
/**
* Create a nontransactional dirty instance, begin and rollback
* a transaction, and check that the instance in the datastore
* has not been changed.
*/
public void testOptimisticRollback() {
if (!checkNontransactionalFeaturesSupported(true))
return;
createAndModifyVersionedPCPoint();
beginAndRollbackTransaction(true);
checkXValue(ASSERTION_FAILED + "after optimistic rollback",
originalXValue);
failOnError();
}
} tck/src/java/org/apache/jdo/tck/lifecycle/NontransactionalWriteTest.java 100664 20416 12500110374 26743 0 ustar mbouschen staff 0 0 /*
* 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.lifecycle;
import javax.jdo.JDOOptimisticVerificationException;
import javax.jdo.JDOUnsupportedOptionException;
import javax.jdo.PersistenceManager;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.mylib.VersionedPCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Test NontransactionalWrite abstract base class
*Keywords: NontransactionalWrite
*Assertion ID:
*Assertion Description:
*/
abstract public class NontransactionalWriteTest extends JDO_Test {
/**
* The ObjectId of the pc instance, set by method
* createAndModifyInstance.
*/
protected Object oid;
/**
* The original value of the X field of the pc instance,
* set by method createAndModifyInstance.
*/
protected int originalXValue = 100;
protected int newXValue = 999;
protected int conflictXValue = 555;
/**
* Create a new VersionedPCPoint instance,modify its X value,
* and store its oid in the test class oid. The persistence manager
* referenced by the pm field (in the superclass) manages the
* nontransactional dirty instance.
* This method is only executed if the
* JDO implementation supports the required features, otherwise
* this method would be localSetUp.
*/
protected VersionedPCPoint createAndModifyVersionedPCPoint() {
addTearDownClass(VersionedPCPoint.class);
getPM().currentTransaction().begin();
pm.currentTransaction().setNontransactionalWrite(true);
pm.currentTransaction().setNontransactionalRead(true);
pm.currentTransaction().setRetainValues(true);
VersionedPCPoint instance = new VersionedPCPoint(originalXValue, 200);
pm.makePersistent(instance);
oid = pm.getObjectId(instance);
pm.currentTransaction().commit();
instance.setX(newXValue);
return instance;
}
/**
* Begin and rollback a transaction using the persistence manager
* that manages the nontransactional dirty instance.
* @param optimistic use optimistic transaction
*/
protected void beginAndRollbackTransaction(boolean optimistic) {
getPM().currentTransaction().setOptimistic(optimistic);
pm.currentTransaction().begin();
pm.currentTransaction().rollback();
}
/**
* Begin and commit a transaction using the persistence manager
* that manages the nontransactional dirty instance.
* @param optimistic use optimistic transaction
*/
protected void beginAndCommitTransaction(boolean optimistic) {
getPM().currentTransaction().setOptimistic(optimistic);
pm.currentTransaction().begin();
pm.currentTransaction().commit();
}
/**
* Begin and commit a transaction using the persistence manager
* that manages the nontransactional dirty instance. This
* transaction must fail due to a conflicting update.
* @param optimistic use optimistic transaction
*/
protected void beginAndCommitTransactionFails(String location,
boolean optimistic) {
getPM().currentTransaction().setOptimistic(optimistic);
pm.currentTransaction().begin();
try {
pm.currentTransaction().commit();
} catch (JDOOptimisticVerificationException ex) {
// good catch; return
return;
}
appendMessage(location + "transaction succeeded but" +
" should not succeed.");
}
/**
* Check the x value of the persistent instance referenced
* by the oid. Use a new persistence manager and check the
* value in a new transaction so there is no interference
* with the persistence manager that managed the nontransactional
* dirty instance.
*/
protected void checkXValue(String location, int expectedXValue) {
PersistenceManager pmCheck = pmf.getPersistenceManager();
try {
pmCheck.currentTransaction().begin();
VersionedPCPoint instance =
(VersionedPCPoint)pmCheck.getObjectById(oid, true);
int actualXValue = instance.getX();
pmCheck.currentTransaction().commit();
if (expectedXValue != actualXValue) {
appendMessage(location + NL +
"expected: " + expectedXValue + NL +
" actual: " + actualXValue);
}
} finally {
cleanupPM(pmCheck);
}
}
/**
* Perform a conflicting transaction that updates the same field
* as the nontransactional dirty instance. The field value is
* conflictXValue. This conflicting transaction uses a new
* persistence manager.
*/
protected void conflictingUpdate() {
PersistenceManager pmConflict = pmf.getPersistenceManager();
try {
pmConflict.currentTransaction().setOptimistic(false);
pmConflict.currentTransaction().begin();
VersionedPCPoint instance =
(VersionedPCPoint)pmConflict.getObjectById(oid);
instance.setX(conflictXValue);
pmConflict.currentTransaction().commit();
} finally {
cleanupPM(pmConflict);
}
}
/**
* Check that all Nontransactional features are supported.
* @param optimistic check for whether Optimistic is supported as well.
*/
protected boolean checkNontransactionalFeaturesSupported
(boolean optimistic) {
if (!checkNontransactionalWriteSupported()
|| !checkNontransactionalReadSupported()
|| !checkRetainValuesSupported())
return false;
if (optimistic) {
if (!checkOptimisticSupported()) {
return false;
}
}
return true;
}
/**
* Check if NontransactionalWrite is supported, and log a debug
* message if it is not.
*/
protected boolean checkNontransactionalWriteSupported() {
if (!isNontransactionalWriteSupported()) {
printUnsupportedOptionalFeatureNotTested(
getClass().getName(),
"javax.jdo.option.NontransactionalWrite");
return false;
}
return true;
}
/**
* Check if NontransactionalRead is supported, and log a debug
* message if it is not.
*/
protected boolean checkNontransactionalReadSupported() {
if (!isNontransactionalReadSupported()) {
printUnsupportedOptionalFeatureNotTested(
getClass().getName(),
"javax.jdo.option.NontransactionalRead");
return false;
}
return true;
}
/**
* Check if Optimistic is supported, and log a debug
* message if it is not.
*/
protected boolean checkOptimisticSupported() {
if (!isOptimisticSupported()) {
printUnsupportedOptionalFeatureNotTested(
getClass().getName(),
"javax.jdo.option.Optimistic");
return false;
}
return true;
}
/**
* Check if RetainValues is supported, and log a debug
* message if it is not.
*/
protected boolean checkRetainValuesSupported() {
if (!isRetainValuesSupported()) {
printUnsupportedOptionalFeatureNotTested(
getClass().getName(),
"javax.jdo.option.RetainValues");
return false;
}
return true;
}
}
tck/src/java/org/apache/jdo/tck/lifecycle/NontransactionalWriteThrows.java 100664 5240 12500110374 27270 0 ustar mbouschen staff 0 0 /*
* 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.lifecycle;
import javax.jdo.JDOUnsupportedOptionException;
import javax.jdo.PersistenceManager;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.mylib.VersionedPCPoint;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Test NontransactionalWriteThrows
*Keywords: NontransactionalWrite
*Assertion ID: A13.4.2-6
*Assertion Description:
If an implementation does not support the [NontranasctionalWrite]
option, then an attempt to set the flag to an unsupported value
will throw JDOUnsupportedOptionException.
*/
public class NontransactionalWriteThrows extends NontransactionalWriteTest {
/** */
protected static final String ASSERTION_FAILED =
"Assertion A13.4.2-6 (NontransactionalWriteThrows) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(NontransactionalWriteThrows.class);
}
/**
* Make sure that if NontransactionalWrite is not supported,
* an exception is thrown when setting NontransactionalWrite.
*/
public void testNontransactionalWriteThrows() {
if (!checkNontransactionalWriteSupported()) {
try {
getPM().currentTransaction().setNontransactionalWrite(true);
} catch (JDOUnsupportedOptionException ex) {
return; // good catch
} catch (Exception ex) {
// threw wrong exception
appendMessage (ASSERTION_FAILED + "threw wrong exception " + ex);
}
appendMessage (ASSERTION_FAILED + "failed to throw " +
"JDOUnsupportedOptionException");
}
failOnError();
}
} tck/src/java/org/apache/jdo/tck/lifecycle/ObjectIdNotModifiedWhenObjectIdInstanceModified.java 100664 12351 12500110374 32733 0 ustar mbouschen staff 0 0 /*
* 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.lifecycle;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import javax.jdo.Extent;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.lifecycle.StateTransitionObj;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Test that ObjectId is not modified even if ObjectId returned by GetObjectId() is modified
*Keywords: lifecycle GetObjectId
*Assertion IDs: A5.4-6
*Assertion Description:
The object returned by any call to getObjectId might be modified by the user,
but that modification does not affect the identity of the object that was originally referred.
*/
public class ObjectIdNotModifiedWhenObjectIdInstanceModified extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A5.4-6 (ObjectIdNotModifiedWhenObjectIdInstanceModified) failed: ";
private static final int NUM_OBJECTS = 50;
/** The persistent instances of this test. */
private Object[] obj;
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(ObjectIdNotModifiedWhenObjectIdInstanceModified.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
pm = getPM();
addTearDownClass(StateTransitionObj.class);
obj = generatePersistentInstances();
}
public void test() throws Exception {
pm.currentTransaction().begin();
try {
Extent extent = pm.getExtent(StateTransitionObj.class, false);
Iterator iter = extent.iterator();
if( !iter.hasNext() ){
fail(ASSERTION_FAILED,
"Extent for StateTransitionObj should not be empty");
}
extent.close(iter);
int failures = 0;
StringBuffer report = new StringBuffer("Failures comparing oids.\n");
for (int i=0; iTitle: Test that a PM returns the same JDO instance if getObjectById(ObjectId) is called multiple times with the same objectId instance
*Keywords: lifecycle getObjectById
*Assertion IDs: A5.4-2, A5.4-8
*Assertion Description:
Any instances returned by any calls to getObjectById(Object) with the same object id instance to the same
PersistenceManager instance must be identical (assuming the instances were not garbage collected between calls).
*/
public class PMReturnsIdenticalInstancesForEqualObjIds extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertions A5.4-2, A5.4-8 (PMReturnsIdenticalInstancesForEqualObjIds) failed: ";
private static final int NUM_OBJECTS = 50;
/** The persistent instances of this test. */
private Object[] obj;
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(PMReturnsIdenticalInstancesForEqualObjIds.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
pm = getPM();
addTearDownClass(StateTransitionObj.class);
obj = generatePersistentInstances();
}
public void test() {
pm.currentTransaction().begin();
try {
Extent extent = pm.getExtent(StateTransitionObj.class, false);
Iterator iter = extent.iterator();
if( !iter.hasNext() ){
fail(ASSERTION_FAILED,
"Extent for StateTransitionObj should not be empty");
}
extent.close(iter);
for (int i=0; iTitle: Test PM ability to share PC classes but not PC instances
*Keywords: PM share PC class
*Assertion IDs: A5.2-1,A5.2-2,A5.2-3
*Assertion Description:
Several JDO PersistenceManagers might be coresident and might
share the same persistence capable classes] (although a JDO instance can be
associated with only one PersistenceManager at a time)
*/
public class PMsCanSharePCClassesButNotPCInstances extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertions A5.2-1,A5.2-2,A5.2-3 (PMsCanSharePCClassesButNotPCInstances) failed: ";
/** The number of active threads. Each thread has its own PM. */
private int threads = 0;
/** The total number of attempts to insert PC instances */
private int attempts = 0;
/** The number of inserters. Each inserter runs in its own thread. */
private int inserters = 5;
/** The number of objects inserted. */
protected int insertedCount = 0;
/** The number of objects that is expected to have been inserted. */
protected int insertedCountExpected = 0;
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(PMsCanSharePCClassesButNotPCInstances.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
addTearDownClass(StateTransitionObj.class);
}
public void testSharedPC() {
// test shared PC - only one PM should succeed to insert the shared PC
threads = 0;
attempts = 0;
insertedCount = 0;
insertedCountExpected = 1;
insertObjects(true);
}
public void testNonSharedPC() {
// test non-shared PCs - each PM should succeed to insert its own non-shared PC
threads = 0;
attempts = 0;
//insertedCount = 0; //Don't reset this value since we have not deleted the inserted object from the shared PC test above
insertedCountExpected += inserters;
insertObjects(false);
}
protected void insertObjects(boolean sharedPC) {
Object pc = null;
ThreadExceptionHandler threadGroup = new ThreadExceptionHandler();
for (int i = 0; i < inserters; i++) {
if (sharedPC) { // each thread shares one PC
if (pc==null)
pc = new StateTransitionObj(i);
}
else { // each thread has its own PC
pc = new StateTransitionObj(i);
}
threads++;
Thread t = new Thread(threadGroup, new Inserter(pmf, pc, sharedPC));
t.setName("Inserter-" + i);
t.start();
}
Thread.yield();
while (! attemptsComplete()) {
try {
Thread.sleep(100);
} catch (InterruptedException ex) {
logger.debug("interrupted while waiting for threads to insert");
}
}
while (threads > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException ex) {
logger.debug("interrupted while waiting for threads to finish");
}
}
Collection exceptions = threadGroup.getAllUncaughtExceptions();
for (Iterator i = exceptions.iterator(); i.hasNext(); ) {
Map.Entry entry = (Map.Entry) i.next();
Thread thread = (Thread)entry.getKey();
Throwable throwable = (Throwable)entry.getValue();
String message = "Uncaught exception " + throwable + " in thread " + thread;
if( throwable instanceof AssertionFailedError )
fail(ASSERTION_FAILED, message);
else
throw new JDOFatalException(message, throwable);
}
}
synchronized void signal() {
threads--;
}
protected synchronized void incrAttempts() {
attempts++;
}
protected synchronized boolean attemptsComplete() {
return attempts == inserters;
}
class Inserter implements Runnable {
private final PersistenceManager pm;
private final Object pc;
private final Class instanceClass;
private final boolean sharedPC;
Inserter(PersistenceManagerFactory pmf, Object pc, boolean sharedPC) {
this.pm = pmf.getPersistenceManager();
this.pc = pc;
this.instanceClass = pc.getClass();
this.sharedPC = sharedPC;
}
protected synchronized void announce(String msg, Object pc) {
insertedCount++;
Object oid = JDOHelper.getObjectId(pc);
if (debug)
logger.debug(msg + this.getClass().getName() + ": " + oid +
", " + pc);
}
public void run() {
Transaction tx = null;
try {
if (debug) logger.debug("running");
tx = pm.currentTransaction();
tx.begin();
try {
pm.makePersistent(pc);
announce("inserted ", pc);
tx.commit();
}
catch (JDOException ex) {
if (!sharedPC) //we expect an exception for all but one of the inserters in the case of a shared PC
throw ex;
}
finally {
incrAttempts();
if (tx != null && tx.isActive())
tx.rollback();
}
while (!attemptsComplete()) {
try {
Thread.sleep(100);
} catch (InterruptedException ex) {
if (debug) logger.debug(" interrupted");
}
}
//Verify that the number of inserted objects matches the expected number
if (insertedCount!=insertedCountExpected)
{
fail(ASSERTION_FAILED,
"Wrong number of objects in extent. Inserted=" +
insertedCount + " Expected=" + insertedCountExpected);
}
if (debug) logger.debug("getting Extent");
int objCount = 0;
if (debug)
logger.debug("getting Extent of " + instanceClass.getName());
tx.begin();
Extent e = pm.getExtent(instanceClass, false);
for (Iterator i = e.iterator(); i.hasNext();) {
Object instance = (Object)i.next();
objCount++;
}
tx.commit();
//Verify that the number of inserted objects matches the number of objects in the extent
if (insertedCount!=objCount)
{
fail(ASSERTION_FAILED,
"Wrong number of objects in extent. Inserted="+insertedCount+" Found="+objCount);
}
} finally {
if (tx != null && tx.isActive())
tx.rollback();
if (pm != null && !pm.isClosed())
pm.close();
PMsCanSharePCClassesButNotPCInstances.this.signal();
}
}
public String toString() {
String rc = "Inserter ";
if (debug) {
rc += Thread.currentThread().toString();
}
return rc;
}
}
}
tck/src/java/org/apache/jdo/tck/lifecycle/StateTransitions.java 100664 133274 12500110374 25120 0 ustar mbouschen staff 0 0 /*
* 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.lifecycle;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.util.Iterator;
import javax.jdo.Extent;
import javax.jdo.JDOFatalException;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.lifecycle.StateTransitionObj;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Test State Transitions
*Keywords: lifecycle
*Assertion IDs: A5.9-1 through A5.9-190
*Assertion Description:
All possible state transistions are being tested in this test.
*/
public class StateTransitions extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertions A5.9-1 through A5.9-190 (StateTransitions) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(StateTransitions.class);
}
private Transaction transaction;
private int scenario;
private int operation;
private int current_state;
private int expected_state;
private int new_state;
/**
* Operations that cause state changes
*/
private static final int MAKEPERSISTENT = 0;
private static final int DELETEPERSISTENT = 1;
private static final int MAKETRANSACTIONAL = 2;
private static final int MAKENONTRANSACTIONAL = 3;
private static final int MAKETRANSIENT = 4;
private static final int COMMITNORETAINVALUES = 5;
private static final int COMMITRETAINVALUES = 6;
private static final int ROLLBACKNORESTOREVALUES = 7;
private static final int ROLLBACKRESTOREVALUES = 8;
private static final int REFRESHDATASTORE = 9;
private static final int REFRESHOPTIMISTIC = 10;
private static final int EVICT = 11;
private static final int READOUTSIDETX = 12;
private static final int READOPTIMISTIC = 13;
private static final int READDATASTORE = 14;
private static final int WRITEOUTSIDETX = 15;
private static final int WRITEINSIDETX = 16;
private static final int RETRIEVEOUTSIDETX = 17;
private static final int RETRIEVEINSIDETX = 18;
private static final int DETACHALLONCOMMIT = 19;
private static final int DETACHCOPYOUTSIDETXNTRTRU = 20;
private static final int DETACHCOPYOUTSIDETXNTRFLS = 21;
private static final int DETACHCOPYINSIDEDATASTORETX = 22;
private static final int DETACHCOPYINSIDEOPTIMISTICTX = 23;
private static final int SERIALIZEOUTSIDETX = 24;
private static final int SERIALIZEDATASTORE = 25;
private static final int SERIALIZEOPTIMISTIC = 26;
private static final int NUM_OPERATIONS = 27;
private static final String[] operations = {
"makePersistent",
"deletePersistent",
"makeTransactional",
"makeNontransactional",
"makeTransient",
"commit, retainValues=false",
"commit, retainValues=true",
"rollback, restoreValues=false",
"rollback, restoreValues=true",
"refresh with active datastore tx",
"refresh with active optimistic tx",
"evict",
"read field outside tx",
"read field with active optimistic tx",
"read field with active datastore tx",
"write field outside tx",
"write field with active tx",
"retrieve outside tx",
"retrieve with active tx",
"commit, detachAllOnCommit=true",
"detachCopy outside tx with NontransactionalRead=true",
"detachCopy outside tx with NontransactionalRead=false",
"detachCopy with active datastore tx",
"detachCopy with active optimistic tx",
"serialize outside tx",
"serialize with active datastore tx",
"serialize with active optimistic tx"
};
/**
* Illegal state transitions
*/
private static final int UNCHANGED = -1;
private static final int ERROR = -2;
private static final int IMPOSSIBLE = -3;
private static final int NOT_APPLICABLE = -4;
private static final int UNSPECIFIED = -5;
/**
* State transitions
*/
public static final int[][] transitions = { // [operation] [current state] = new state
// 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
// makePersistent
{ PERSISTENT_NEW, UNCHANGED, UNCHANGED,
UNCHANGED, UNCHANGED, PERSISTENT_NEW,
PERSISTENT_NEW, UNCHANGED, UNCHANGED,
UNCHANGED, UNCHANGED, DETACHED_CLEAN,
DETACHED_DIRTY},
// deletePersistent
{ ERROR, PERSISTENT_NEW_DELETED, PERSISTENT_DELETED,
PERSISTENT_DELETED, PERSISTENT_DELETED, ERROR,
ERROR, UNCHANGED, UNCHANGED,
PERSISTENT_DELETED, PERSISTENT_DELETED, ERROR,
ERROR},
// makeTransactional
{ TRANSIENT_CLEAN, UNCHANGED, UNCHANGED,
UNCHANGED, PERSISTENT_CLEAN, UNCHANGED,
UNCHANGED, UNCHANGED, UNCHANGED,
PERSISTENT_CLEAN, PERSISTENT_DIRTY, ERROR,
ERROR},
// makeNontransactional
{ ERROR, ERROR, PERSISTENT_NONTRANSACTIONAL,
ERROR, UNCHANGED, TRANSIENT,
ERROR, ERROR, ERROR,
UNCHANGED, UNCHANGED, ERROR,
ERROR},
// makeTransient
{ UNCHANGED, ERROR, TRANSIENT,
ERROR, TRANSIENT, UNCHANGED,
UNCHANGED, ERROR, ERROR,
TRANSIENT, ERROR, ERROR,
ERROR},
// commit, retainValues = false
{ UNCHANGED, HOLLOW, HOLLOW,
HOLLOW, UNCHANGED, UNCHANGED,
TRANSIENT_CLEAN, TRANSIENT, TRANSIENT,
UNCHANGED, HOLLOW, UNCHANGED,
UNCHANGED},
// commit, retainValues = true
{ UNCHANGED, PERSISTENT_NONTRANSACTIONAL, PERSISTENT_NONTRANSACTIONAL,
PERSISTENT_NONTRANSACTIONAL, UNCHANGED, UNCHANGED,
TRANSIENT_CLEAN, TRANSIENT, TRANSIENT,
UNCHANGED, PERSISTENT_NONTRANSACTIONAL, UNCHANGED,
UNCHANGED},
// 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
// rollback, restoreValues = false
{ UNCHANGED, TRANSIENT, HOLLOW,
HOLLOW, UNCHANGED, UNCHANGED,
TRANSIENT_CLEAN, TRANSIENT, HOLLOW,
UNCHANGED, HOLLOW, UNCHANGED,
UNCHANGED},
// rollback, restoreValues = true
{ UNCHANGED, TRANSIENT, PERSISTENT_NONTRANSACTIONAL,
PERSISTENT_NONTRANSACTIONAL, UNCHANGED, UNCHANGED,
TRANSIENT_CLEAN, TRANSIENT, PERSISTENT_NONTRANSACTIONAL,
UNCHANGED, UNCHANGED, UNCHANGED,
UNCHANGED},
// refresh with active datastore transaction
{ UNCHANGED, UNCHANGED, UNCHANGED,
PERSISTENT_CLEAN, UNCHANGED, UNCHANGED,
UNCHANGED, UNCHANGED, UNCHANGED,
UNCHANGED, PERSISTENT_NONTRANSACTIONAL, UNCHANGED,
UNCHANGED},
// refresh with active optimistic transaction
{ UNCHANGED, UNCHANGED, UNCHANGED,
PERSISTENT_NONTRANSACTIONAL, UNCHANGED, UNCHANGED,
UNCHANGED, UNCHANGED, UNCHANGED,
UNCHANGED, PERSISTENT_NONTRANSACTIONAL, UNCHANGED,
UNCHANGED},
// evict
{ NOT_APPLICABLE, UNCHANGED, HOLLOW,
UNCHANGED, UNCHANGED, UNCHANGED,
UNCHANGED, UNCHANGED, UNCHANGED,
HOLLOW, HOLLOW, UNCHANGED,
UNCHANGED},
// read field outside transaction
{ UNCHANGED, IMPOSSIBLE, IMPOSSIBLE,
IMPOSSIBLE, PERSISTENT_NONTRANSACTIONAL, IMPOSSIBLE,
IMPOSSIBLE, IMPOSSIBLE, IMPOSSIBLE,
UNCHANGED, UNCHANGED, UNCHANGED,
UNCHANGED},
// read field with active optimistic transaction
{ UNCHANGED, UNCHANGED, UNCHANGED,
UNCHANGED, PERSISTENT_NONTRANSACTIONAL, UNCHANGED,
UNCHANGED, UNSPECIFIED, UNSPECIFIED,
UNCHANGED, UNCHANGED, UNCHANGED,
UNCHANGED},
// 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
// read field with active datastore transaction
{ UNCHANGED, UNCHANGED, UNCHANGED,
UNCHANGED, PERSISTENT_CLEAN, UNCHANGED,
UNCHANGED, UNSPECIFIED, UNSPECIFIED,
PERSISTENT_CLEAN, UNCHANGED, UNCHANGED,
UNCHANGED},
// write field outside transaction
{ UNCHANGED, IMPOSSIBLE, IMPOSSIBLE,
IMPOSSIBLE, PERSISTENT_NONTRANSACTIONAL, IMPOSSIBLE,
IMPOSSIBLE, IMPOSSIBLE, IMPOSSIBLE,
PERSISTENT_NONTRANSACTIONAL_DIRTY, UNCHANGED, DETACHED_DIRTY,
UNCHANGED},
// write field with active transaction
{ UNCHANGED, UNCHANGED, PERSISTENT_DIRTY,
UNCHANGED, PERSISTENT_DIRTY, TRANSIENT_DIRTY,
UNCHANGED, ERROR, ERROR,
PERSISTENT_DIRTY, UNCHANGED, DETACHED_DIRTY,
UNCHANGED},
// retrieve outside transaction
{ UNCHANGED, IMPOSSIBLE, IMPOSSIBLE,
IMPOSSIBLE, PERSISTENT_NONTRANSACTIONAL, IMPOSSIBLE,
IMPOSSIBLE, IMPOSSIBLE, IMPOSSIBLE,
UNCHANGED, UNCHANGED, UNCHANGED,
UNCHANGED},
// retrieve with active transaction
{ UNCHANGED, UNCHANGED, UNCHANGED,
UNCHANGED, PERSISTENT_CLEAN, UNCHANGED,
UNCHANGED, UNCHANGED, UNCHANGED,
PERSISTENT_CLEAN, UNCHANGED, UNCHANGED,
UNCHANGED},
// commit, detachAllOnCommit = true
{ UNCHANGED, DETACHED_CLEAN, DETACHED_CLEAN,
DETACHED_CLEAN, DETACHED_CLEAN, UNCHANGED,
TRANSIENT_CLEAN, TRANSIENT, TRANSIENT,
DETACHED_CLEAN, DETACHED_CLEAN, UNCHANGED,
UNCHANGED},
// 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
// detachCopy outside tx with NontransactionalRead=true
{ ERROR, IMPOSSIBLE, IMPOSSIBLE,
IMPOSSIBLE, PERSISTENT_NONTRANSACTIONAL, ERROR,
IMPOSSIBLE, IMPOSSIBLE, IMPOSSIBLE,
UNCHANGED, UNCHANGED, UNCHANGED,
UNCHANGED},
// detachCopy outside tx with NontransactionalRead=false
{ ERROR, IMPOSSIBLE, IMPOSSIBLE,
IMPOSSIBLE, ERROR, ERROR,
IMPOSSIBLE, IMPOSSIBLE, IMPOSSIBLE,
ERROR, ERROR, ERROR,
ERROR},
// detachCopy with active datastore tx
{ PERSISTENT_NEW, UNCHANGED, UNCHANGED,
UNCHANGED, PERSISTENT_CLEAN, PERSISTENT_NEW,
PERSISTENT_NEW, ERROR, ERROR,
PERSISTENT_CLEAN, IMPOSSIBLE, UNCHANGED,
UNCHANGED},
// detachCopy with active optimistic tx
{ PERSISTENT_NEW, UNCHANGED, UNCHANGED,
UNCHANGED, PERSISTENT_NONTRANSACTIONAL, PERSISTENT_NEW,
PERSISTENT_NEW, ERROR, ERROR,
UNCHANGED, IMPOSSIBLE, UNCHANGED,
UNCHANGED},
// serialize outside tx
{ UNCHANGED, IMPOSSIBLE, IMPOSSIBLE,
IMPOSSIBLE, UNCHANGED, IMPOSSIBLE,
IMPOSSIBLE, IMPOSSIBLE, IMPOSSIBLE,
UNCHANGED, UNCHANGED, UNCHANGED,
UNCHANGED},
// serialize with active datastore tx
{ UNCHANGED, UNCHANGED, UNCHANGED,
UNCHANGED, PERSISTENT_CLEAN, UNCHANGED,
UNCHANGED, UNCHANGED, UNCHANGED,
PERSISTENT_CLEAN, UNCHANGED, UNCHANGED,
UNCHANGED},
// serialize with active optimistic tx
{ UNCHANGED, UNCHANGED, UNCHANGED,
UNCHANGED, UNCHANGED, UNCHANGED,
UNCHANGED, UNCHANGED, UNCHANGED,
UNCHANGED, UNCHANGED, UNCHANGED,
UNCHANGED},
};
private static final int DATASTORE_TX = 0;
private static final int OPTIMISTIC_TX = 1;
private static final int NO_TX = 2;
private static final String[] scenario_string = {
"datastore transaction", "optimistic transaction", "no transaction"
};
private static final boolean[][] applies_to_scenario = {
// Datastore Optimistic No tx
{ true, true, false }, // makePersistent
{ true, true, false }, // deletePersistent
{ true, true, false }, // makeTransactional
{ true, true, false }, // makeNontransactional
{ true, true, false }, // makeTransient
{ true, true, false }, // commit RetainValues = false
{ true, true, false }, // commit RetainValues = true
{ true, true, false }, // rollback RestoreValues = false
{ true, true, false }, // rollback RestoreValues = true
{ true, false, false }, // refresh with active datastore transaction
{ false, true, false }, // refresh with active optimistic transaction
{ true, true, false }, // evict
{ false, false, true }, // read field outside of a transaction
{ false, true, false }, // read field with active optimistic transaction
{ true, false, false }, // read field with active datastore transaction
{ false, false, true }, // write field or makeDirty outside of a transaction
{ true, true, false }, // write field or makeDirty with active transaction
{ false, true, true }, // retrieve outside of a transaction or with active optimistic transaction
{ true, false, false }, // retrieve with active datastore transaction
{ true, true, false }, // commit, DetachAllOnCommit = true
{ false, false, true }, // detachCopy outside tx with NonTransactionaRead=true
{ false, false, true }, // detachCopy outside tx with NonTransactionaRead=false
{ true, false, false }, // detachCopy with active datastore tx
{ false, true, false }, // detachCopy with active optimistic tx
{ false, false, true }, // serialize outside tx
{ true, false, false }, // serialize with active datastore tx
{ false, true, false } // serialize with active optimistic tx
};
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
pm = getPM();
addTearDownClass(StateTransitionObj.class);
generatePersistentInstances();
}
public void test() {
scenario = DATASTORE_TX;
checkTransitions();
if( isOptimisticSupported() ){
scenario = OPTIMISTIC_TX;
checkTransitions();
}
scenario = NO_TX;
checkTransitions();
failOnError();
}
/** */
private void generatePersistentInstances()
{
if( doPersistentInstancesExist() ) return;
int i;
Transaction t = pm.currentTransaction();
t.begin();
for( i = 0; i < 50; ++i ){
StateTransitionObj sto = new StateTransitionObj(i);
sto.writeField(i);
pm.makePersistent(sto);
}
t.commit();
if( !doPersistentInstancesExist() )
if (debug)
logger.debug("StateTransitions unable to create instances of StateTransitionsObj");
}
/** */
private boolean doPersistentInstancesExist()
{
boolean ret;
Transaction t = pm.currentTransaction();
t.begin();
Extent e = pm.getExtent(StateTransitionObj.class, false);
Iterator iter = e.iterator();
ret = iter.hasNext();
t.rollback();
return ret;
}
/** */
public void prepareTransactionAndJDOSettings(Transaction transaction) {
transaction.setNontransactionalRead(false);
transaction.setNontransactionalWrite(false);
if( scenario != NO_TX ) {
if( operation == COMMITNORETAINVALUES )
transaction.setRetainValues(false);
if( operation == COMMITRETAINVALUES )
transaction.setRetainValues(true);
if( operation == ROLLBACKNORESTOREVALUES )
transaction.setRestoreValues(false);
if( operation == ROLLBACKRESTOREVALUES )
transaction.setRestoreValues(true);
if( operation == DETACHALLONCOMMIT )
pm.setDetachAllOnCommit(true);
else
pm.setDetachAllOnCommit(false);
transaction.setOptimistic(scenario == OPTIMISTIC_TX);
transaction.begin();
if( !transaction.isActive() )
if (debug)
logger.debug("StateTransitions: Transaction should be active, but it is not");
} else {
if( operation == READOUTSIDETX ||
operation == RETRIEVEOUTSIDETX ||
operation == DETACHCOPYOUTSIDETXNTRTRU ||
operation == SERIALIZEOUTSIDETX ) {
transaction.setNontransactionalRead(true);
}
if( operation == WRITEOUTSIDETX ||
current_state == PERSISTENT_NONTRANSACTIONAL_DIRTY) {
transaction.setNontransactionalWrite(true);
}
}
}
/** */
void checkTransitions()
{
for( operation = 0; operation < NUM_OPERATIONS; ++operation ){
// rule out situations that do not apply
if( !applies_to_scenario[operation][scenario] ) continue;
if( (operation == READOUTSIDETX ||
operation == RETRIEVEOUTSIDETX ||
operation == DETACHCOPYOUTSIDETXNTRTRU ||
operation == SERIALIZEOUTSIDETX) &&
!isNontransactionalReadSupported() ) continue;
if( operation == WRITEOUTSIDETX && !isNontransactionalWriteSupported() ) continue;
if( operation == COMMITRETAINVALUES && !isRetainValuesSupported() ) continue;
if( operation == MAKENONTRANSACTIONAL &&
!(isNontransactionalReadSupported() || isNontransactionalWriteSupported()) )
continue;
int NUM_JDO1_STATES = NUM_STATES - 2; // JDO1 is tested so far here.
for( current_state = 0; current_state < NUM_JDO1_STATES; ++current_state){
if( scenario == OPTIMISTIC_TX && current_state == PERSISTENT_CLEAN ) continue;
if( (current_state == TRANSIENT_CLEAN || current_state == TRANSIENT_DIRTY) &&
!isTransientTransactionalSupported() )
continue; // this state is not supported by implementation
if( current_state == PERSISTENT_NONTRANSACTIONAL &&
!(isNontransactionalReadSupported() || isNontransactionalWriteSupported()) )
continue; // this state is not supported by implementation
if( current_state == PERSISTENT_NONTRANSACTIONAL_DIRTY &&
!isNontransactionalWriteSupported() )
continue;
expected_state = transitions[operation][current_state];
if( expected_state == IMPOSSIBLE ) continue;
if( expected_state == NOT_APPLICABLE ) continue;
if( expected_state == UNSPECIFIED ) continue;
if( expected_state == UNCHANGED ) expected_state = current_state;
try {
transaction = pm.currentTransaction();
if( transaction.isActive()){
if (debug)
logger.debug("Transaction is active (but should not be), rolling back");
transaction.rollback();
}
prepareTransactionAndJDOSettings(transaction);
printSituation();
StateTransitionObj obj = getInstanceInState(current_state);
if( obj == null ){ // could not get object in state
if( transaction.isActive() ) transaction.rollback();
continue;
}
// Apply operation, catching possible exception
Exception e = null;
try {
applyOperation(operation, obj);
} catch( Exception excep ){
if( excep instanceof javax.jdo.JDOUserException ){
e = excep;
} else {
appendMessage(ASSERTION_FAILED + NL +
"StateTransitions: " +
scenario_string[scenario] +
"; current state " + states[current_state] + NL +
operations[operation] +
"; unexpected exception:" + excep);
continue;
}
}
// Get new state, verify correct transition and exceptions occurred
new_state = currentState(obj);
if( expected_state == ERROR ){
if( e == null ){
appendMessage(ASSERTION_FAILED + NL +
"StateTransitions: " +
scenario_string[scenario] +
"; current state " + states[current_state] + NL +
operations[operation] +
"; JDOUserException should have been thrown");
} else {
if( !compareStates(new_state, current_state) ) {
appendMessage(ASSERTION_FAILED + NL +
"StateTransitions: " +
scenario_string[scenario] +
"; current state " + states[current_state] + NL +
operations[operation] +
"; JDOUserException properly thrown, but instance should remain in current state," +
"instance changed state to " + states[new_state]);
}
}
}
if( !compareStates(new_state, expected_state) ) {
appendMessage(ASSERTION_FAILED + NL +
"StateTransitions: " +
scenario_string[scenario] +
"; current state " + states[current_state] + NL +
operations[operation] +
" transitioned instance to invalid state " + states[new_state] +
"; expected state " + states[expected_state]);
}
if( transaction.isActive() ) transaction.rollback();
}
catch(Exception unexpected_exception) {
if (debug) {
unexpected_exception.printStackTrace();
}
if (transaction.isActive())
transaction.rollback();
appendMessage(ASSERTION_FAILED + NL +
"StateTransitions: " +
scenario_string[scenario] +
"; current state " + states[current_state] + NL +
operations[operation] +
"; unexpected exception caught: " + unexpected_exception);
}
}
}
}
/** */
void printSituation()
{
if (debug) {
logger.debug(" (" + scenario_string[scenario] +
", initial state=" + states[current_state] +
", operation=" + operations[operation] + ")");
}
}
/** */
void applyOperation(int operation, StateTransitionObj stobj)
{
StateTransitionObj obj = (StateTransitionObj) stobj;
switch( operation ){
case MAKEPERSISTENT:
{
pm.makePersistent(obj);
break;
}
case DELETEPERSISTENT:
{
pm.deletePersistent(obj);
break;
}
case MAKETRANSACTIONAL:
{
pm.makeTransactional(obj);
break;
}
case MAKENONTRANSACTIONAL:
{
pm.makeNontransactional(obj);
break;
}
case MAKETRANSIENT:
{
pm.makeTransient(obj);
break;
}
case COMMITNORETAINVALUES:
{
pm.currentTransaction().commit();
break;
}
case COMMITRETAINVALUES:
{
pm.currentTransaction().commit();
break;
}
case ROLLBACKNORESTOREVALUES:
{
pm.currentTransaction().rollback();
break;
}
case ROLLBACKRESTOREVALUES:
{
pm.currentTransaction().rollback();
break;
}
case REFRESHDATASTORE:
{
pm.refresh(obj);
break;
}
case REFRESHOPTIMISTIC:
{
pm.refresh(obj);
break;
}
case EVICT:
{
pm.evict(obj);
break;
}
case READOUTSIDETX:
{
obj.readField();
break;
}
case READOPTIMISTIC:
{
obj.readField();
break;
}
case READDATASTORE:
{
obj.readField();
break;
}
case WRITEOUTSIDETX:
{
obj.writeField(42);
break;
}
case WRITEINSIDETX:
{
obj.writeField(42);
break;
}
case RETRIEVEOUTSIDETX:
{
pm.retrieve(obj);
break;
}
case RETRIEVEINSIDETX:
{
pm.retrieve(obj);
break;
}
case DETACHALLONCOMMIT:
{
pm.currentTransaction().commit();
break;
}
case DETACHCOPYOUTSIDETXNTRTRU:
{
pm.detachCopy(obj);
break;
}
case DETACHCOPYOUTSIDETXNTRFLS:
{
pm.detachCopy(obj);
break;
}
case DETACHCOPYINSIDEDATASTORETX:
{
pm.detachCopy(obj);
break;
}
case DETACHCOPYINSIDEOPTIMISTICTX:
{
pm.detachCopy(obj);
break;
}
case SERIALIZEOUTSIDETX:
{
ObjectOutputStream oos = null;
try {
oos = new ObjectOutputStream(new ByteArrayOutputStream());
oos.writeObject(obj);
} catch (IOException e) {
throw new JDOFatalException(e.getMessage(), e);
} finally {
if (oos != null) {
try {
oos.close();
} catch (IOException e) {
throw new JDOFatalException(e.getMessage(), e);
}
}
}
break;
}
case SERIALIZEDATASTORE:
case SERIALIZEOPTIMISTIC:
{
ObjectOutputStream oos = null;
try {
oos = new ObjectOutputStream(new ByteArrayOutputStream());
oos.writeObject(obj);
} catch (IOException e) {
throw new JDOFatalException(e.getMessage(), e);
} finally {
if (oos != null) {
try {
oos.close();
} catch (IOException e) {
throw new JDOFatalException(e.getMessage(), e);
}
}
}
break;
}
default:
{
appendMessage(ASSERTION_FAILED + NL +
"StateTransitions: " +
scenario_string[scenario] +
"; internal error, illegal operation: " + operation);
}
}
}
/**
* Get an instance in the specified state.
*/
public StateTransitionObj getInstanceInState(int state)
{
switch(state) {
case TRANSIENT:
return getTransientInstance();
case PERSISTENT_NEW:
return getPersistentNewInstance();
case PERSISTENT_CLEAN:
return getPersistentCleanInstance();
case PERSISTENT_DIRTY:
return getPersistentDirtyInstance();
case HOLLOW:
return getHollowInstance();
case TRANSIENT_CLEAN:
return getTransientCleanInstance();
case TRANSIENT_DIRTY:
return getTransientDirtyInstance();
case PERSISTENT_NEW_DELETED:
return getPersistentNewDeletedInstance();
case PERSISTENT_DELETED:
return getPersistentDeletedInstance();
case PERSISTENT_NONTRANSACTIONAL:
return getPersistentNontransactionalInstance();
case PERSISTENT_NONTRANSACTIONAL_DIRTY:
return getPersistentNontransactionalDirtyInstance();
case DETACHED_CLEAN:
return getDetachedCleanInstance();
case DETACHED_DIRTY:
return getDetachedDirtyInstance();
default:
return null;
}
}
/** */
public StateTransitionObj getTransientInstance()
{
StateTransitionObj obj = new StateTransitionObj(23);
int curr = currentState(obj);
if( curr != TRANSIENT ) {
if (debug) {
logger.debug("StateTransitions: Unable to create transient instance, state is " +
states[curr]);
}
return null;
}
return obj;
}
/** */
public StateTransitionObj getPersistentNewInstance()
{
StateTransitionObj obj = getTransientInstance();
if( obj == null ) return null;
pm.makePersistent(obj); // should transition to persistent-new
int curr = currentState(obj);
if( curr != PERSISTENT_NEW ) {
if (debug) {
logger.debug("StateTransitions: Unable to create persistent-new instance" +
" from transient instance via makePersistent(), state is " +
states[curr]);
}
return null;
}
return obj;
}
/** */
public StateTransitionObj getPersistentCleanInstance()
{
StateTransitionObj obj = getHollowInstance();
if( obj == null ) return null;
StateTransitionObj sto = (StateTransitionObj) obj;
sto.readField();
int curr = currentState(sto);
if( curr != PERSISTENT_CLEAN ) {
if (debug) {
logger.debug("StateTransition: Unable to create persistent-clean instance" +
" from a hollow instance by reading a field, state is " +
states[curr]);
}
return null;
}
return obj;
}
/** */
public StateTransitionObj getPersistentDirtyInstance()
{
StateTransitionObj obj = getHollowInstance();
if( obj == null ) return null;
StateTransitionObj pcobj = (StateTransitionObj) obj;
pcobj.writeField(23);
int curr = currentState(obj);
if( curr != PERSISTENT_DIRTY ) {
if (debug) {
logger.debug("StateTransition: Unable to create persistent-dirty instance" +
" from a hollow instance by writing a field, state is " +
states[curr]);
}
return null;
}
return obj;
}
/** */
public StateTransitionObj getHollowInstance()
{
if ( !transaction.isActive() )
transaction.begin();
if( !transaction.isActive() )
if (debug)
logger.debug("getHollowInstance: Transaction should be active, but it is not");
Extent extent = pm.getExtent(StateTransitionObj.class, false);
Iterator iter = extent.iterator();
if( !iter.hasNext() ){
if (debug)
logger.debug("Extent for StateTransitionObj should not be empty");
return null;
}
StateTransitionObj obj = (StateTransitionObj) iter.next();
pm.makeTransactional(obj);
transaction.setRetainValues(false);
transaction.commit(); // This should put the instance in the HOLLOW state
prepareTransactionAndJDOSettings(transaction);
int curr = currentState(obj);
if( curr != HOLLOW && curr != PERSISTENT_NONTRANSACTIONAL ){
if (debug) {
logger.debug("getHollowInstance: Attempt to get hollow instance via accessing extent failed, state is " +
states[curr]);
}
return null;
}
return obj;
}
/** */
public StateTransitionObj getTransientCleanInstance()
{
StateTransitionObj obj = getTransientInstance();
if( obj == null ) return null;
pm.makeTransactional(obj);
int curr = currentState(obj);
if( curr != TRANSIENT_CLEAN ) {
if (debug) {
logger.debug("StateTransition: Unable to create transient-clean instance" +
" from a transient instance via makeTransactional(), state is " +
states[curr]);
}
return null;
}
return obj;
}
/** */
public StateTransitionObj getTransientDirtyInstance()
{
StateTransitionObj obj = getTransientCleanInstance();
if( obj == null ) return null;
StateTransitionObj pcobj = (StateTransitionObj) obj;
pcobj.writeField(23);
int curr = currentState(obj);
if( curr != TRANSIENT_DIRTY ) {
if (debug) {
logger.debug("StateTransition: Unable to create transient-dirty instance" +
" from a transient-clean instance via modifying a field, state is " +
states[curr]);
}
return null;
}
return obj;
}
/** */
public StateTransitionObj getPersistentNewDeletedInstance()
{
StateTransitionObj obj = getPersistentNewInstance();
if( obj == null ) return null;
pm.deletePersistent(obj); // should transition to persistent-new-deleted
int curr = currentState(obj);
if( curr != PERSISTENT_NEW_DELETED) {
if (debug) {
logger.debug("StateTransition: Unable to create persistent-new-deleted instance" +
" from a persistent-new instance via deletePersistent, state is " +
states[curr]);
}
return null;
}
return obj;
}
/** */
public StateTransitionObj getPersistentDeletedInstance()
{
StateTransitionObj obj = getHollowInstance();
if( obj == null ) return null;
pm.deletePersistent(obj);
int curr = currentState(obj);
if( curr != PERSISTENT_DELETED ) {
if (debug) {
logger.debug("StateTransition: Unable to create persistent-deleted instance" +
" from a persistent instance via deletePersistent(), state is " +
states[curr]);
}
return null;
}
return obj;
}
/** */
public StateTransitionObj getPersistentNontransactionalInstance()
{
StateTransitionObj obj = getHollowInstance();
if( obj == null ) return null;
boolean nontransactionalRead =
pm.currentTransaction().getNontransactionalRead();
pm.currentTransaction().setNontransactionalRead(true);
obj.readField();
pm.makeNontransactional(obj);
pm.currentTransaction().setNontransactionalRead(nontransactionalRead);
int curr = currentState(obj);
if( curr != PERSISTENT_NONTRANSACTIONAL && curr != HOLLOW ) {
if (debug) {
logger.debug("StateTransition: Unable to create persistent-nontransactional instance" +
" from a persistent-clean instance via makeNontransactional(), state is " +
states[curr]);
}
return null;
}
return obj;
}
/** */
public StateTransitionObj getPersistentNontransactionalDirtyInstance()
{
StateTransitionObj obj = getPersistentNontransactionalInstance();
if( obj == null ) return null;
obj.writeField(10000);
int curr = currentState(obj);
if( curr != PERSISTENT_NONTRANSACTIONAL_DIRTY ) {
if (debug) {
logger.debug("StateTransition: Unable to create persistent-nontransactional-dirty instance" +
" from a persistent-clean instance via makeNontransactional()/JDOHelper.makeDirty," +
" state is " + states[curr]);
}
return null;
}
return obj;
}
/** */
public StateTransitionObj getDetachedCleanInstance()
{
StateTransitionObj obj = getHollowInstance();
if( obj == null ) return null;
obj = (StateTransitionObj) pm.detachCopy(obj);
int curr = currentState(obj);
if( curr != DETACHED_CLEAN ) {
if (debug) {
logger.debug("StateTransition: Unable to create detached-clean instance" +
" from a persistent-clean instance via detachCopy," +
" state is " + states[curr]);
}
return null;
}
return obj;
}
/** */
public StateTransitionObj getDetachedDirtyInstance()
{
StateTransitionObj obj = getHollowInstance();
if( obj == null ) return null;
obj = (StateTransitionObj) pm.detachCopy(obj);
obj.writeField(1000);
int curr = currentState(obj);
if( curr != DETACHED_DIRTY ) {
if (debug) {
logger.debug("StateTransition: Unable to create detached-dirty instance" +
" from a persistent-clean instance via detachCopy/persistent field modification," +
" state is " + states[curr]);
}
return null;
}
return obj;
}
}
tck/src/java/org/apache/jdo/tck/lifecycle/StateTransitionsReturnedObjects.java 100664 74727 12500110374 30132 0 ustar mbouschen staff 0 0 /*
* 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.lifecycle;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.Iterator;
import javax.jdo.Extent;
import javax.jdo.JDOFatalException;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.lifecycle.StateTransitionObj;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Test State Transitions
*Keywords: lifecycle
*Assertion IDs: A5.9-1 through A5.9-190
*Assertion Description:
All possible state transistions are being tested in this test.
*/
public class StateTransitionsReturnedObjects extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertions A5.9-1 through A5.5.8 (serialization, detachment, attachment) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(StateTransitionsReturnedObjects.class);
}
private Transaction transaction;
private int scenario;
private int operation;
private int current_state;
private int expected_state;
private int new_state;
/**
* Operations that cause state changes
*/
private static final int MAKEPERSISTENTOPTIMISTIC = 0;
private static final int MAKEPERSISTENTDATASTORE = 1;
private static final int DETACHCOPYOUTSIDETXNTRTRU = 2;
private static final int DETACHCOPYOUTSIDETXNTRFLS = 3;
private static final int DETACHCOPYINSIDEDATASTORETX = 4;
private static final int DETACHCOPYINSIDEOPTIMISTICTX = 5;
private static final int SERIALIZEOUTSIDETX = 6;
private static final int SERIALIZEINSIDETX = 7;
private static final int NUM_OPERATIONS = 8;
private static final String[] operations = {
"makePersistent with active optimistic tx",
"makePersistent with active datastore tx",
"detachCopy outside tx with NontransactionalRead true",
"detachCopy outside tx with NontransactionalRead false",
"detachCopy with active datastore tx",
"detachCopy with active optimistic tx",
"serialize outside tx",
"serialize with active tx"
};
/**
* Illegal state transitions
*/
private static final int UNCHANGED = -1;
private static final int ERROR = -2;
private static final int IMPOSSIBLE = -3;
private static final int NOT_APPLICABLE = -4;
private static final int UNSPECIFIED = -5;
/**
* State transitions
*/
public static final int[][] statesOfReturnedObjects = { // [operation] [current state] = new state
// 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
// makePersistent optimistic transaction
{ PERSISTENT_NEW, UNCHANGED, UNCHANGED,
UNCHANGED, UNCHANGED, PERSISTENT_NEW,
PERSISTENT_NEW, UNCHANGED, UNCHANGED,
UNCHANGED, UNCHANGED, PERSISTENT_NONTRANSACTIONAL,
PERSISTENT_DIRTY},
// makePersistent datastore transaction
{ PERSISTENT_NEW, UNCHANGED, UNCHANGED,
UNCHANGED, UNCHANGED, PERSISTENT_NEW,
PERSISTENT_NEW, UNCHANGED, UNCHANGED,
UNCHANGED, UNCHANGED, PERSISTENT_CLEAN,
PERSISTENT_DIRTY},
// detachCopy outside tx with NontransactionalRead=true
{ ERROR, IMPOSSIBLE, IMPOSSIBLE,
IMPOSSIBLE, DETACHED_CLEAN, ERROR,
IMPOSSIBLE, IMPOSSIBLE, IMPOSSIBLE,
DETACHED_CLEAN, UNSPECIFIED, DETACHED_CLEAN,
UNSPECIFIED},
// detachCopy outside tx with NontransactionalRead=false
{ ERROR, ERROR, ERROR,
ERROR, ERROR, ERROR,
IMPOSSIBLE, IMPOSSIBLE, IMPOSSIBLE,
ERROR, ERROR, ERROR,
ERROR},
// detachCopy with active datastore tx
{ DETACHED_CLEAN, DETACHED_CLEAN, DETACHED_CLEAN,
DETACHED_CLEAN, DETACHED_CLEAN, DETACHED_CLEAN,
DETACHED_CLEAN, ERROR, ERROR,
DETACHED_CLEAN, IMPOSSIBLE, DETACHED_CLEAN,
DETACHED_CLEAN},
// detachCopy with active optimistic tx
{ DETACHED_CLEAN, DETACHED_CLEAN, DETACHED_CLEAN,
DETACHED_CLEAN, DETACHED_CLEAN, DETACHED_CLEAN,
DETACHED_CLEAN, ERROR, ERROR,
DETACHED_CLEAN, IMPOSSIBLE, DETACHED_CLEAN,
DETACHED_CLEAN},
// serialize outside tx
{ UNCHANGED, IMPOSSIBLE, IMPOSSIBLE,
IMPOSSIBLE, DETACHED_CLEAN, IMPOSSIBLE,
IMPOSSIBLE, IMPOSSIBLE, IMPOSSIBLE,
DETACHED_CLEAN, UNSPECIFIED, UNCHANGED,
UNCHANGED},
// serialize with active tx
{ UNCHANGED, DETACHED_CLEAN, DETACHED_CLEAN,
DETACHED_CLEAN, DETACHED_CLEAN, TRANSIENT,
TRANSIENT, TRANSIENT, TRANSIENT,
DETACHED_CLEAN, TRANSIENT, UNCHANGED,
UNCHANGED},
};
private static final int DATASTORE_TX = 0;
private static final int OPTIMISTIC_TX = 1;
private static final int NO_TX = 2;
private static final String[] scenario_string = {
"datastore transaction", "optimistic transaction", "no transaction"
};
private static final boolean[][] applies_to_scenario = {
// Datastore Optimistic No tx
{ false, true, false }, // makePersistent active optimistic transaction
{ true, false, false }, // makePersistent active datastore transaction
// since the spec leaves detachCopy outside tx a bit underspecified,
// we decided to disable this scanario for now
{ false, false, true }, // detachCopy outside tx with NontransactionalRead=true
{ false, false, false }, // detachCopy outside tx with NontransactionalRead=false
{ true, true, false }, // detachCopy with active datastore tx
{ true, true, false }, // detachCopy with active optimistic tx
{ false, false, true }, // serialize outside tx
{ true, true, false } // serialize with active tx
};
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
pm = getPM();
addTearDownClass(StateTransitionObj.class);
generatePersistentInstances();
}
public void test() {
scenario = DATASTORE_TX;
checkTransitions();
if( isOptimisticSupported() ){
scenario = OPTIMISTIC_TX;
checkTransitions();
}
scenario = NO_TX;
checkTransitions();
failOnError();
}
/** */
private void generatePersistentInstances()
{
if( doPersistentInstancesExist() ) return;
int i;
Transaction t = pm.currentTransaction();
t.begin();
for( i = 0; i < 50; ++i ){
StateTransitionObj sto = new StateTransitionObj(i);
sto.writeField(i);
pm.makePersistent(sto);
}
t.commit();
if( !doPersistentInstancesExist() )
if (debug)
logger.debug("StateTransitionsReturnedObjects unable to create instances of StateTransitionsObj");
}
/** */
private boolean doPersistentInstancesExist()
{
boolean ret;
Transaction t = pm.currentTransaction();
t.begin();
Extent e = pm.getExtent(StateTransitionObj.class, false);
Iterator iter = e.iterator();
ret = iter.hasNext();
t.rollback();
return ret;
}
/** */
public void prepareTransactionAndJDOSettings(Transaction transaction) {
if( scenario != NO_TX ) {
transaction.setNontransactionalRead(false);
transaction.setNontransactionalWrite(false);
pm.setDetachAllOnCommit(false);
transaction.setOptimistic(scenario == OPTIMISTIC_TX);
transaction.begin();
if( !transaction.isActive() )
if (debug)
logger.debug("StateTransitionsReturnedObjects: Transaction should be active, but it is not");
} else {
if( operation == DETACHCOPYOUTSIDETXNTRTRU ||
operation == SERIALIZEOUTSIDETX ) {
transaction.setNontransactionalRead(true);
}
if( current_state == PERSISTENT_NONTRANSACTIONAL_DIRTY) {
transaction.setNontransactionalWrite(true);
}
}
}
/** */
void checkTransitions()
{
for( operation = 0; operation < NUM_OPERATIONS; ++operation ){
// rule out situations that do not apply
if( !applies_to_scenario[operation][scenario] ) continue;
if( (operation == DETACHCOPYOUTSIDETXNTRTRU ||
operation == SERIALIZEOUTSIDETX) &&
!isNontransactionalReadSupported() ) continue;
for( current_state = 0; current_state < NUM_STATES; ++current_state){
if( scenario == OPTIMISTIC_TX && current_state == PERSISTENT_CLEAN ) continue;
if( (current_state == TRANSIENT_CLEAN || current_state == TRANSIENT_DIRTY) &&
!isTransientTransactionalSupported() )
continue; // this state is not supported by implementation
if( current_state == PERSISTENT_NONTRANSACTIONAL &&
!(isNontransactionalReadSupported() || isNontransactionalWriteSupported()) )
continue; // this state is not supported by implementation
if( current_state == PERSISTENT_NONTRANSACTIONAL_DIRTY &&
!isNontransactionalWriteSupported() )
continue;
expected_state = statesOfReturnedObjects[operation][current_state];
if( expected_state == IMPOSSIBLE ) continue;
if( expected_state == NOT_APPLICABLE ) continue;
if( expected_state == UNSPECIFIED ) continue;
if( expected_state == UNCHANGED ) expected_state = current_state;
try {
transaction = pm.currentTransaction();
if( transaction.isActive()){
if (debug)
logger.debug("Transaction is active (but should not be), rolling back");
transaction.rollback();
}
prepareTransactionAndJDOSettings(transaction);
printSituation();
StateTransitionObj obj = getInstanceInState(current_state);
if( obj == null ){ // could not get object in state
if( transaction.isActive() ) transaction.rollback();
continue;
}
// Apply operation, catching possible exception
Exception e = null;
Object returnedObject = null;
try {
returnedObject = applyOperation(operation, obj);
} catch( Exception excep ){
if( excep instanceof javax.jdo.JDOUserException ){
e = excep;
} else {
appendMessage(ASSERTION_FAILED + NL +
"StateTransitionsReturnedObjects: " +
scenario_string[scenario] +
"; current state " + states[current_state] + NL +
operations[operation] +
"; unexpected exception: " + excep);
continue;
}
}
if( expected_state == ERROR ){
if( e == null ){
appendMessage(ASSERTION_FAILED + NL +
"StateTransitionsReturnedObjects: " +
scenario_string[scenario] +
"; current state " + states[current_state] + NL +
operations[operation] +
"; JDOUserException should have been thrown");
} else {
int stateOfObj = currentState(obj);
if( stateOfObj != current_state ){
appendMessage(ASSERTION_FAILED + NL +
"StateTransitionsReturnedObjects: " +
scenario_string[scenario] +
"; current state " + states[current_state] + NL +
operations[operation] +
"; JDOUserException properly thrown, but instance should remain in current state," +
" instance changed state to " + states[stateOfObj]);
}
}
} else {
// Get new state, verify correct transition and exceptions occurred
new_state = currentState(returnedObject);
if( !compareStates(new_state, expected_state) ) {
appendMessage(ASSERTION_FAILED + NL +
"StateTransitionsReturnedObjects: " +
scenario_string[scenario] +
"; current state " + states[current_state] + NL +
operations[operation] +
" returned instance in invalid state " + states[new_state] +
"; expected state " + states[expected_state]);
}
}
if( transaction.isActive() ) transaction.rollback();
}
catch(Exception unexpected_exception) {
if (transaction.isActive())
transaction.rollback();
appendMessage(ASSERTION_FAILED + NL +
"StateTransitionsReturnedObjects: " +
scenario_string[scenario] +
"; current state " + states[current_state] + NL +
operations[operation] +
"; unexpected exception caught: " + unexpected_exception);
}
}
}
}
/** */
void printSituation()
{
if (debug) {
logger.debug(" (" + scenario_string[scenario] +
", initial state=" + states[current_state] +
", " + operations[operation] + ")");
}
}
/** */
Object applyOperation(int operation, StateTransitionObj stobj)
{
Object result = null;
StateTransitionObj obj = (StateTransitionObj) stobj;
switch( operation ){
case MAKEPERSISTENTOPTIMISTIC:
case MAKEPERSISTENTDATASTORE:
result = pm.makePersistent(obj);
break;
case DETACHCOPYOUTSIDETXNTRTRU:
case DETACHCOPYOUTSIDETXNTRFLS:
case DETACHCOPYINSIDEDATASTORETX:
case DETACHCOPYINSIDEOPTIMISTICTX:
result = pm.detachCopy(obj);
break;
case SERIALIZEOUTSIDETX:
case SERIALIZEINSIDETX:
ObjectOutputStream oos = null;
ObjectInputStream ois = null;
try {
ByteArrayOutputStream byteArrayOutputStream =
new ByteArrayOutputStream();
oos = new ObjectOutputStream(byteArrayOutputStream);
oos.writeObject(obj);
ois = new ObjectInputStream(new ByteArrayInputStream(
byteArrayOutputStream.toByteArray()));
result = ois.readObject();
} catch (IOException e) {
throw new JDOFatalException(e.getMessage(), e);
} catch (ClassNotFoundException e) {
throw new JDOFatalException(e.getMessage(), e);
} finally {
try {
if (oos != null) {
oos.close();
}
if (ois != null) {
ois.close();
}
} catch (IOException e) {
throw new JDOFatalException(e.getMessage(), e);
}
}
break;
default:
appendMessage(ASSERTION_FAILED + NL +
"StateTransitionsReturnedObjects: " +
scenario_string[scenario] +
"; internal error, illegal operation: " + operation);
}
return result;
}
/**
* Get an instance in the specified state.
*/
public StateTransitionObj getInstanceInState(int state)
{
switch(state) {
case TRANSIENT:
return getTransientInstance();
case PERSISTENT_NEW:
return getPersistentNewInstance();
case PERSISTENT_CLEAN:
return getPersistentCleanInstance();
case PERSISTENT_DIRTY:
return getPersistentDirtyInstance();
case HOLLOW:
return getHollowInstance();
case TRANSIENT_CLEAN:
return getTransientCleanInstance();
case TRANSIENT_DIRTY:
return getTransientDirtyInstance();
case PERSISTENT_NEW_DELETED:
return getPersistentNewDeletedInstance();
case PERSISTENT_DELETED:
return getPersistentDeletedInstance();
case PERSISTENT_NONTRANSACTIONAL:
return getPersistentNontransactionalInstance();
case PERSISTENT_NONTRANSACTIONAL_DIRTY:
return getPersistentNontransactionalDirtyInstance();
case DETACHED_CLEAN:
return getDetachedCleanInstance();
case DETACHED_DIRTY:
return getDetachedDirtyInstance();
default:
return null;
}
}
/** */
public StateTransitionObj getTransientInstance()
{
StateTransitionObj obj = new StateTransitionObj(23);
int curr = currentState(obj);
if( curr != TRANSIENT ) {
if (debug) {
logger.debug("StateTransitionsReturnedObjects: Unable to create transient instance, state is " +
states[curr]);
}
return null;
}
return obj;
}
/** */
public StateTransitionObj getPersistentNewInstance()
{
StateTransitionObj obj = getTransientInstance();
if( obj == null ) return null;
pm.makePersistent(obj); // should transition to persistent-new
int curr = currentState(obj);
if( curr != PERSISTENT_NEW ) {
if (debug) {
logger.debug("StateTransitionsReturnedObjects: Unable to create persistent-new instance" +
" from transient instance via makePersistent(), state is " +
states[curr]);
}
return null;
}
return obj;
}
/** */
public StateTransitionObj getPersistentCleanInstance()
{
StateTransitionObj obj = getHollowInstance();
if( obj == null ) return null;
StateTransitionObj sto = (StateTransitionObj) obj;
sto.readField();
int curr = currentState(sto);
if( curr != PERSISTENT_CLEAN ) {
if (debug) {
logger.debug("StateTransitionsReturnedObjects: Unable to create persistent-clean instance" +
" from a hollow instance by reading a field, state is " +
states[curr]);
}
return null;
}
return obj;
}
/** */
public StateTransitionObj getPersistentDirtyInstance()
{
StateTransitionObj obj = getHollowInstance();
if( obj == null ) return null;
StateTransitionObj pcobj = (StateTransitionObj) obj;
pcobj.writeField(23);
int curr = currentState(obj);
if( curr != PERSISTENT_DIRTY ) {
if (debug) {
logger.debug("StateTransitionsReturnedObjects: Unable to create persistent-dirty instance" +
" from a hollow instance by writing a field, state is " +
states[curr]);
}
return null;
}
return obj;
}
/** */
public StateTransitionObj getHollowInstance()
{
if ( !transaction.isActive() )
transaction.begin();
if( !transaction.isActive() )
if (debug)
logger.debug("getHollowInstance: Transaction should be active, but it is not");
Extent extent = pm.getExtent(StateTransitionObj.class, false);
Iterator iter = extent.iterator();
if( !iter.hasNext() ){
if (debug)
logger.debug("Extent for StateTransitionObj should not be empty");
return null;
}
StateTransitionObj obj = (StateTransitionObj) iter.next();
pm.makeTransactional(obj);
transaction.setRetainValues(false);
transaction.commit(); // This should put the instance in the HOLLOW state
prepareTransactionAndJDOSettings(transaction);
int curr = currentState(obj);
if( curr != HOLLOW && curr != PERSISTENT_NONTRANSACTIONAL ){
if (debug) {
logger.debug("getHollowInstance: Attempt to get hollow instance via accessing extent failed, state is " +
states[curr]);
}
return null;
}
return obj;
}
/** */
public StateTransitionObj getTransientCleanInstance()
{
StateTransitionObj obj = getTransientInstance();
if( obj == null ) return null;
pm.makeTransactional(obj);
int curr = currentState(obj);
if( curr != TRANSIENT_CLEAN ) {
if (debug) {
logger.debug("StateTransitionsReturnedObjects: Unable to create transient-clean instance" +
" from a transient instance via makeTransactional(), state is " +
states[curr]);
}
return null;
}
return obj;
}
/** */
public StateTransitionObj getTransientDirtyInstance()
{
StateTransitionObj obj = getTransientCleanInstance();
if( obj == null ) return null;
StateTransitionObj pcobj = (StateTransitionObj) obj;
pcobj.writeField(23);
int curr = currentState(obj);
if( curr != TRANSIENT_DIRTY ) {
if (debug) {
logger.debug("StateTransitionsReturnedObjects: Unable to create transient-dirty instance" +
" from a transient-clean instance via modifying a field, state is " +
states[curr]);
}
return null;
}
return obj;
}
/** */
public StateTransitionObj getPersistentNewDeletedInstance()
{
StateTransitionObj obj = getPersistentNewInstance();
if( obj == null ) return null;
pm.deletePersistent(obj); // should transition to persistent-new-deleted
int curr = currentState(obj);
if( curr != PERSISTENT_NEW_DELETED) {
if (debug) {
logger.debug("StateTransitionsReturnedObjects: Unable to create persistent-new-deleted instance" +
" from a persistent-new instance via deletePersistent, state is " +
states[curr]);
}
return null;
}
return obj;
}
/** */
public StateTransitionObj getPersistentDeletedInstance()
{
StateTransitionObj obj = getHollowInstance();
if( obj == null ) return null;
pm.deletePersistent(obj);
int curr = currentState(obj);
if( curr != PERSISTENT_DELETED ) {
if (debug) {
logger.debug("StateTransitionsReturnedObjects: Unable to create persistent-deleted instance" +
" from a persistent instance via deletePersistent(), state is " +
states[curr]);
}
return null;
}
return obj;
}
/** */
public StateTransitionObj getPersistentNontransactionalInstance()
{
StateTransitionObj obj = getHollowInstance();
if( obj == null ) return null;
boolean nontransactionalRead =
pm.currentTransaction().getNontransactionalRead();
pm.currentTransaction().setNontransactionalRead(true);
obj.readField();
pm.makeNontransactional(obj);
pm.currentTransaction().setNontransactionalRead(nontransactionalRead);
int curr = currentState(obj);
if( curr != PERSISTENT_NONTRANSACTIONAL && curr != HOLLOW ) {
if (debug) {
logger.debug("StateTransitionsReturnedObjects: Unable to create persistent-nontransactional instance" +
" from a persistent-clean instance via makeNontransactional(), state is " +
states[curr]);
}
return null;
}
return obj;
}
/** */
public StateTransitionObj getPersistentNontransactionalDirtyInstance()
{
StateTransitionObj obj = getPersistentNontransactionalInstance();
if( obj == null ) return null;
obj.writeField(10000);
int curr = currentState(obj);
if( curr != PERSISTENT_NONTRANSACTIONAL_DIRTY ) {
if (debug) {
logger.debug("StateTransitionsReturnedObjects: Unable to create persistent-nontransactional-dirty instance" +
" from a persistent-clean instance via makeNontransactional()/JDOHelper.makeDirty," +
" state is " + states[curr]);
}
return null;
}
return obj;
}
/** */
public StateTransitionObj getDetachedCleanInstance()
{
StateTransitionObj obj = getHollowInstance();
if( obj == null ) return null;
obj = (StateTransitionObj) pm.detachCopy(obj);
int curr = currentState(obj);
if( curr != DETACHED_CLEAN ) {
if (debug) {
logger.debug("StateTransitionsReturnedObjects: Unable to create detached-clean instance" +
" from a persistent-clean instance via detachCopy," +
" state is " + states[curr]);
}
return null;
}
return obj;
}
/** */
public StateTransitionObj getDetachedDirtyInstance()
{
StateTransitionObj obj = getHollowInstance();
if( obj == null ) return null;
obj = (StateTransitionObj) pm.detachCopy(obj);
obj.writeField(1000);
int curr = currentState(obj);
if( curr != DETACHED_DIRTY ) {
if (debug) {
logger.debug("StateTransitionsReturnedObjects: Unable to create detached-dirty instance" +
" from a persistent-clean instance via detachCopy/persistent field modification," +
" state is " + states[curr]);
}
return null;
}
return obj;
}
}
tck/src/java/org/apache/jdo/tck/lifecycle/TransientTransactionalStateCommit.java 100664 7661 12500110374 30406 0 ustar mbouschen staff 0 0 /*
* 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.lifecycle;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.lifecycle.StateTransitionObj;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Test Transient Transactional Commit
*Keywords: lifecycle transienttransactional commit
*Assertion IDs: A5.1-3
*Assertion Description:
If TransientTransactional is supported, a transient transactional instance
will have its state preserved when its associated transaction commits.
*/
public class TransientTransactionalStateCommit extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A5.1-3 (TransientTransactionalStateCommit) failed: ";
private static final int CLEAN_VALUE = 12;
private static final int DIRTY_VALUE = 123;
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(TransientTransactionalStateCommit.class);
}
/** */
public void test() {
if (!isTransientTransactionalSupported()) {
logger.debug("Transient transactional instances are not supported");
}
else {
pm = getPM();
StateTransitionObj obj = getTransientInstance();
pm.currentTransaction().begin();
makeTransientDirty(obj);
int beforeValue=obj.readField();
pm.currentTransaction().commit();
int afterValue=obj.readField();
if (beforeValue!=afterValue)
{
fail(ASSERTION_FAILED,
"Field value incorrect after commit. Expected: " +
beforeValue + " Found: " + afterValue);
}
}
}
protected StateTransitionObj getTransientInstance() {
StateTransitionObj obj = new StateTransitionObj(CLEAN_VALUE);
int curr = currentState(obj);
if( curr != TRANSIENT ){
fail(ASSERTION_FAILED,
"Unable to create transient instance, state is " +
states[curr]);
}
return obj;
}
protected void makeTransientClean(StateTransitionObj obj) {
if( obj == null ) return;
pm.makeTransactional(obj);
int curr = currentState(obj);
if( curr != TRANSIENT_CLEAN ){
fail(ASSERTION_FAILED,
"Unable to create transient-clean instance " +
"from a transient instance via makeTransactional(), state is " +
states[curr]);
}
}
protected void makeTransientDirty(StateTransitionObj obj) {
if( obj == null ) return;
makeTransientClean(obj);
obj.writeField(DIRTY_VALUE);
int curr = currentState(obj);
if( curr != TRANSIENT_DIRTY ){
fail(ASSERTION_FAILED,
"Unable to create transient-dirty instance " +
"from a transient-clean instance via modifying a field, state is " +
states[curr]);
}
}
}
tck/src/java/org/apache/jdo/tck/lifecycle/TransientTransactionalStateRollback.java 100664 11001 12500110374 30706 0 ustar mbouschen staff 0 0 /*
* 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.lifecycle;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.lifecycle.StateTransitionObj;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Test Transient Transactional Rollback
*Keywords: lifecycle transienttransactional rollback
*Assertion IDs: A5.1-4
*Assertion Description:
If TransientTransactional is supported, a transient transactional instance
will have its state restored to its state prior to becoming transactional when
its associated transaction aborts or on rollback.
*/
public class TransientTransactionalStateRollback extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A5.1-4 (TransientTransactionalStateRollback) failed: ";
private static final int CLEAN_VALUE = 12;
private static final int DIRTY_VALUE = 123;
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(TransientTransactionalStateRollback.class);
}
/** */
public void test() {
if (!isTransientTransactionalSupported()) {
logger.debug("Transient transactional instances are not supported");
}
else {
pm = getPM();
// Get transient instance and read field value
StateTransitionObj obj = getTransientInstance();
int beforeValue=obj.readField();
// Start transaction
Transaction tx = pm.currentTransaction();
tx.begin();
// Get transient dirty instance
makeTransientDirty(obj);
// Rollback
tx.rollback();
int curr = currentState(obj);
if( curr != TRANSIENT_CLEAN ){
fail(ASSERTION_FAILED,
"StateTransition: Unable to create transient-clean instance " +
"from a transient-dirty instance via tx.rollback(), state is " + states[curr]);
}
// Check that field value has been rolled back
int afterValue=obj.readField();
if (beforeValue!=afterValue)
{
fail(ASSERTION_FAILED,
"Field value incorrect after rollback. Expected: "+beforeValue+" Found: "+afterValue);
}
}
}
protected StateTransitionObj getTransientInstance() {
StateTransitionObj obj = new StateTransitionObj(CLEAN_VALUE);
int curr = currentState(obj);
if( curr != TRANSIENT ){
fail(ASSERTION_FAILED,
"Unable to create transient instance, state is " + states[curr]);
}
return obj;
}
protected void makeTransientClean(StateTransitionObj obj) {
if( obj == null ) return;
pm.makeTransactional(obj);
int curr = currentState(obj);
if( curr != TRANSIENT_CLEAN ){
fail(ASSERTION_FAILED,
"Unable to create transient-clean instance " +
"from a transient instance via makeTransactional(), state is " + states[curr]);
}
}
protected void makeTransientDirty(StateTransitionObj obj) {
if( obj == null ) return;
makeTransientClean(obj);
obj.writeField(DIRTY_VALUE);
int curr = currentState(obj);
if( curr != TRANSIENT_DIRTY ){
fail(ASSERTION_FAILED,
"Unable to create transient-dirty instance " +
"from a transient-clean instance via modifying a field, state is " + states[curr]);
}
}
}
tck/src/java/org/apache/jdo/tck/mapping/AbstractRelationshipTest.java 100664 7112 12500110374 26212 0 ustar mbouschen staff 0 0 /*
* 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.mapping;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import org.apache.jdo.tck.AbstractReaderTest;
import org.apache.jdo.tck.pc.company.CompanyFactoryRegistry;
import org.apache.jdo.tck.pc.company.CompanyModelReader;
import org.apache.jdo.tck.pc.company.Employee;
import org.apache.jdo.tck.pc.company.Project;
/*
* Abstract class for managed relationship tests
*/
public class AbstractRelationshipTest extends AbstractReaderTest {
protected CompanyModelReader reader = null;
/** */
protected final boolean isTestToBePerformed = isTestToBePerformed();
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
if (isTestToBePerformed()) {
getPM();
CompanyFactoryRegistry.registerFactory(pm);
reader = new CompanyModelReader(inputFilename);
addTearDownClass(reader.getTearDownClassesFromFactory());
// persist test data
pm.currentTransaction().begin();
List rootList = getRootList(reader);
pm.makePersistentAll(rootList);
rootOids = new ArrayList();
for (Iterator i = rootList.iterator(); i.hasNext(); ) {
Object pc = i.next();
rootOids.add(pm.getObjectId(pc));
}
// DO THIS
// in xmlBeanFactory String[] getBeanDefinitionNames()
oidMap.put("emp1", pm.getObjectId(reader.getEmployee("emp1")));
oidMap.put("emp2", pm.getObjectId(reader.getEmployee("emp2")));
oidMap.put("emp4", pm.getObjectId(reader.getEmployee("emp4")));
oidMap.put("medicalIns1",
pm.getObjectId(reader.getMedicalInsurance("medicalIns1")));
oidMap.put("medicalIns2",
pm.getObjectId(reader.getMedicalInsurance("medicalIns2")));
oidMap.put("dept1", pm.getObjectId(reader.getDepartment("dept1")));
oidMap.put("dept2", pm.getObjectId(reader.getDepartment("dept2")));
oidMap.put("proj1", pm.getObjectId(reader.getProject("proj1")));
oidMap.put("proj2", pm.getObjectId(reader.getProject("proj2")));
pm.currentTransaction().commit();
cleanupPM();
}
}
protected boolean containsEmployee(Collection employees, long empid) {
for (Employee emp: employees) {
if (emp.getPersonid() == empid) {
return true;
}
}
return false;
}
protected boolean containsProject(Collection projects, long projid) {
for (Project project: projects) {
if (project.getProjid() == projid) {
return true;
}
}
return false;
}
}
tck/src/java/org/apache/jdo/tck/mapping/CompletenessTest.java 100664 10634 12500110374 24551 0 ustar mbouschen staff 0 0 /*
* 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.mapping;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import org.apache.jdo.tck.AbstractReaderTest;
import org.apache.jdo.tck.pc.company.CompanyFactoryRegistry;
import org.apache.jdo.tck.pc.company.CompanyModelReader;
import org.apache.jdo.tck.util.BatchTestRunner;
import org.apache.jdo.tck.util.DeepEquality;
import org.apache.jdo.tck.util.EqualityHelper;
//import org.springframework.beans.factory.xml.XmlBeanFactory;
/**
*Title: Completeness Test
*Keywords: mapping
*Assertion ID: A18.[not identified]
*Assertion Description:
*/
public class CompletenessTest extends AbstractReaderTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A18-[not identified] failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(CompletenessTest.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
if (isTestToBePerformed()) {
getPM();
CompanyFactoryRegistry.registerFactory(pm);
CompanyModelReader reader = new CompanyModelReader(inputFilename);
addTearDownClass(reader.getTearDownClassesFromFactory());
// persist test data
pm.currentTransaction().begin();
List rootList = getRootList(reader);
pm.makePersistentAll(rootList);
rootOids = new ArrayList();
for (Iterator i = rootList.iterator(); i.hasNext(); ) {
Object pc = i.next();
rootOids.add(pm.getObjectId(pc));
}
pm.currentTransaction().commit();
cleanupPM();
}
}
/** */
public void test() {
if (isTestToBePerformed()) {
// register the default factory
CompanyFactoryRegistry.registerFactory();
// get new obj graph to compare persistent graph with
CompanyModelReader reader = new CompanyModelReader(inputFilename);
List rootList = getRootList(reader);
getPM();
pm.currentTransaction().begin();
// compare persisted and new
int size = rootList.size();
StringBuffer msg = new StringBuffer();
for (int i = 0; i < size; i++) {
DeepEquality expected = (DeepEquality) rootList.get(i);
Object oid = rootOids.get(i);
Object persisted = pm.getObjectById(oid);
EqualityHelper equalityHelper = new EqualityHelper();
if (!expected.deepCompareFields(persisted, equalityHelper)) {
if (msg.length() > 0) {
msg.append("\n");
}
msg.append("Expected this instance:\n " +
expected + "\n" +
"Got persistent instance:" + "\n " +
persisted + "\n" +
"Detailed list of differences follows...\n");
msg.append(equalityHelper.getUnequalBuffer());
}
}
pm.currentTransaction().commit();
// fail test if at least one of the instances is not the expected one
if (msg.length() > 0) {
fail("CompletenessTest failed; see list of failures below:",
msg.toString());
}
}
}
}
tck/src/java/org/apache/jdo/tck/mapping/CompletenessTestJPA.java 100664 11015 12500110374 25076 0 ustar mbouschen staff 0 0 /*
* 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.mapping;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import org.apache.jdo.tck.AbstractReaderTest;
import org.apache.jdo.tck.pc.company.CompanyFactoryRegistry;
import org.apache.jdo.tck.pc.company.CompanyModelReader;
import org.apache.jdo.tck.util.BatchTestRunner;
import org.apache.jdo.tck.util.DeepEquality;
import org.apache.jdo.tck.util.EqualityHelper;
//import org.springframework.beans.factory.xml.XmlBeanFactory;
/**
*Title: Completeness Test JPA
*Keywords: mapping
*Assertion ID: A18.[not identified]
*Assertion Description:
*/
public class CompletenessTestJPA extends AbstractReaderTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A18-[not identified] failed: ";
/** */
private final boolean isTestToBePerformed = isTestToBePerformed();
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(CompletenessTestJPA.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
if (runsWithApplicationIdentity()) {
getPM();
CompanyFactoryRegistry.registerFactory(pm);
CompanyModelReader reader = new CompanyModelReader(inputFilename);
addTearDownClass(reader.getTearDownClassesFromFactory());
// persist test data
pm.currentTransaction().begin();
List rootList = getRootList(reader);
pm.makePersistentAll(rootList);
rootOids = new ArrayList();
for (Iterator i = rootList.iterator(); i.hasNext(); ) {
Object pc = i.next();
rootOids.add(pm.getObjectId(pc));
}
pm.currentTransaction().commit();
cleanupPM();
}
}
/** */
public void test() {
if (runsWithApplicationIdentity()) {
// register the default factory
CompanyFactoryRegistry.registerFactory();
// get new obj graph to compare persistent graph with
CompanyModelReader reader = new CompanyModelReader(inputFilename);
List rootList = getRootList(reader);
getPM();
pm.currentTransaction().begin();
// compare persisted and new
int size = rootList.size();
StringBuffer msg = new StringBuffer();
for (int i = 0; i < size; i++) {
DeepEquality expected = (DeepEquality) rootList.get(i);
Object oid = rootOids.get(i);
Object persisted = pm.getObjectById(oid);
EqualityHelper equalityHelper = new EqualityHelper();
if (!expected.deepCompareFields(persisted, equalityHelper)) {
if (msg.length() > 0) {
msg.append("\n");
}
msg.append("Expected this instance:\n " +
expected + "\n" +
"Got persistent instance:" + "\n " +
persisted + "\n" +
"Detailed list of differences follows...\n");
msg.append(equalityHelper.getUnequalBuffer());
}
}
pm.currentTransaction().commit();
// fail test if at least one of the instances is not the expected one
if (msg.length() > 0) {
fail("CompletenessTest failed; see list of failures below:",
msg.toString());
}
}
}
}
tck/src/java/org/apache/jdo/tck/mapping/CompletenessTestList.java 100664 11036 12500110374 25402 0 ustar mbouschen staff 0 0 /*
* 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.mapping;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import org.apache.jdo.tck.AbstractReaderTest;
import org.apache.jdo.tck.pc.companyListWithoutJoin.CompanyFactoryRegistry;
import org.apache.jdo.tck.pc.companyListWithoutJoin.CompanyModelReader;
import org.apache.jdo.tck.util.BatchTestRunner;
import org.apache.jdo.tck.util.DeepEquality;
import org.apache.jdo.tck.util.EqualityHelper;
//import org.springframework.beans.factory.xml.XmlBeanFactory;
/**
*Title: Completeness Test List
*Keywords: mapping
*Assertion ID: A18.[not identified]
*Assertion Description:
*/
public class CompletenessTestList extends AbstractReaderTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A18-[not identified] failed: ";
/** */
private final boolean isTestToBePerformed = isTestToBePerformed();
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(CompletenessTestList.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
if (isTestToBePerformed) {
getPM();
CompanyFactoryRegistry.registerFactory(pm);
CompanyModelReader reader = new CompanyModelReader(inputFilename);
addTearDownClass(reader.getTearDownClassesFromFactory());
// persist test data
pm.currentTransaction().begin();
List rootList = getRootList(reader);
pm.makePersistentAll(rootList);
rootOids = new ArrayList();
for (Iterator i = rootList.iterator(); i.hasNext(); ) {
Object pc = i.next();
rootOids.add(pm.getObjectId(pc));
}
pm.currentTransaction().commit();
cleanupPM();
}
}
/** */
public void test() {
if (isTestToBePerformed) {
// register the default factory
CompanyFactoryRegistry.registerFactory();
// get new obj graph to compare persistent graph with
CompanyModelReader reader = new CompanyModelReader(inputFilename);
List rootList = getRootList(reader);
getPM();
pm.currentTransaction().begin();
// compare persisted and new
int size = rootList.size();
StringBuffer msg = new StringBuffer();
for (int i = 0; i < size; i++) {
DeepEquality expected = (DeepEquality) rootList.get(i);
Object oid = rootOids.get(i);
Object persisted = pm.getObjectById(oid);
EqualityHelper equalityHelper = new EqualityHelper();
if (!expected.deepCompareFields(persisted, equalityHelper)) {
if (msg.length() > 0) {
msg.append("\n");
}
msg.append("Expected this instance:\n " +
expected + "\n" +
"Got persistent instance:" + "\n " +
persisted + "\n" +
"Detailed list of differences follows...\n");
msg.append(equalityHelper.getUnequalBuffer());
}
}
pm.currentTransaction().commit();
// fail test if at least one of the instances is not the expected one
if (msg.length() > 0) {
fail("CompletenessTestList failed; see list of failures below:",
msg.toString());
}
}
}
}
tck/src/java/org/apache/jdo/tck/mapping/CompletenessTestMap.java 100664 11030 12500110374 25176 0 ustar mbouschen staff 0 0 /*
* 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.mapping;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import org.apache.jdo.tck.AbstractReaderTest;
import org.apache.jdo.tck.pc.companyMapWithoutJoin.CompanyFactoryRegistry;
import org.apache.jdo.tck.pc.companyMapWithoutJoin.CompanyModelReader;
import org.apache.jdo.tck.util.BatchTestRunner;
import org.apache.jdo.tck.util.DeepEquality;
import org.apache.jdo.tck.util.EqualityHelper;
//import org.springframework.beans.factory.xml.XmlBeanFactory;
/**
*Title: Completeness Test Map
*Keywords: mapping
*Assertion ID: A18.[not identified]
*Assertion Description:
*/
public class CompletenessTestMap extends AbstractReaderTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A18-[not identified] failed: ";
/** */
private final boolean isTestToBePerformed = isTestToBePerformed();
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(CompletenessTestMap.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
if (isTestToBePerformed) {
getPM();
CompanyFactoryRegistry.registerFactory(pm);
CompanyModelReader reader = new CompanyModelReader(inputFilename);
addTearDownClass(reader.getTearDownClassesFromFactory());
// persist test data
pm.currentTransaction().begin();
List rootList = getRootList(reader);
pm.makePersistentAll(rootList);
rootOids = new ArrayList();
for (Iterator i = rootList.iterator(); i.hasNext(); ) {
Object pc = i.next();
rootOids.add(pm.getObjectId(pc));
}
pm.currentTransaction().commit();
cleanupPM();
}
}
/** */
public void test() {
if (isTestToBePerformed) {
// register the default factory
CompanyFactoryRegistry.registerFactory();
// get new obj graph to compare persistent graph with
CompanyModelReader reader = new CompanyModelReader(inputFilename);
List rootList = getRootList(reader);
getPM();
pm.currentTransaction().begin();
// compare persisted and new
int size = rootList.size();
StringBuffer msg = new StringBuffer();
for (int i = 0; i < size; i++) {
DeepEquality expected = (DeepEquality) rootList.get(i);
Object oid = rootOids.get(i);
Object persisted = pm.getObjectById(oid);
EqualityHelper equalityHelper = new EqualityHelper();
if (!expected.deepCompareFields(persisted, equalityHelper)) {
if (msg.length() > 0) {
msg.append("\n");
}
msg.append("Expected this instance:\n " +
expected + "\n" +
"Got persistent instance:" + "\n " +
persisted + "\n" +
"Detailed list of differences follows...\n");
msg.append(equalityHelper.getUnequalBuffer());
}
}
pm.currentTransaction().commit();
// fail test if at least one of the instances is not the expected one
if (msg.length() > 0) {
fail("CompletenessTestMap failed; see list of failures below:",
msg.toString());
}
}
}
}
tck/src/java/org/apache/jdo/tck/mapping/CompletenessTestOrder.java 100664 11564 12500110374 25550 0 ustar mbouschen staff 0 0 /*
* 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.mapping;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import org.apache.jdo.tck.AbstractReaderTest;
import org.apache.jdo.tck.pc.order.OrderFactoryRegistry;
import org.apache.jdo.tck.pc.order.OrderModelReader;
import org.apache.jdo.tck.util.BatchTestRunner;
import org.apache.jdo.tck.util.DeepEquality;
import org.apache.jdo.tck.util.EqualityHelper;
/**
*Title: Completeness Test for the Order model
*Keywords: mapping compound identity
*Assertion ID: A5.4.1-5
*Assertion Description: Compound identity is a special case of application identity. References to other persistence-capable classes can be defined as key fields. In this case, the object id class contains a field that is of the type of the object id of the relationship field.
*/
public class CompletenessTestOrder extends AbstractReaderTest {
/** */
private static final String ASSERTION_FAILED =
"Assertion A5.4.1-5[Compound identity is a special case of application identity. References to other persistence-capable classes can be defined as key fields. In this case, the object id class contains a field that is of the type of the object id of the relationship field.] failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(CompletenessTestOrder.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
if (runsWithApplicationIdentity()) {
getPM();
OrderFactoryRegistry.registerFactory(pm);
OrderModelReader reader = new OrderModelReader(inputFilename);
addTearDownClass(reader.getTearDownClassesFromFactory());
// persist test data
pm.currentTransaction().begin();
List rootList = getRootList(reader);
pm.makePersistentAll(rootList);
rootOids = new ArrayList();
for (Iterator i = rootList.iterator(); i.hasNext(); ) {
Object pc = i.next();
rootOids.add(pm.getObjectId(pc));
}
pm.currentTransaction().commit();
cleanupPM();
}
}
/** */
public void test() {
if (runsWithApplicationIdentity()) {
// register the default factory
OrderFactoryRegistry.registerFactory();
// get new obj graph to compare persistent graph with
OrderModelReader reader = new OrderModelReader(inputFilename);
List rootList = getRootList(reader);
getPM();
pm.currentTransaction().begin();
// compare persisted and new
int size = rootList.size();
StringBuffer msg = new StringBuffer();
for (int i = 0; i < size; i++) {
DeepEquality expected = (DeepEquality) rootList.get(i);
Object oid = rootOids.get(i);
Object persisted = pm.getObjectById(oid);
EqualityHelper equalityHelper = new EqualityHelper();
if (!expected.deepCompareFields(persisted, equalityHelper)) {
if (msg.length() > 0) {
msg.append("\n");
}
msg.append("Expected this instance:\n " +
expected + "\n" +
"Got persistent instance:" + "\n " +
persisted + "\n" +
"Detailed list of differences follows...\n");
msg.append(equalityHelper.getUnequalBuffer());
}
}
pm.currentTransaction().commit();
//fail test if at least one of the instances is not the expected one
if (msg.length() > 0) {
fail("CompletenessTestOrder failed; see list of failures below:",
msg.toString());
}
}
}
}
tck/src/java/org/apache/jdo/tck/mapping/Relationship1To1AllRelationships.java 100664 41012 12500110374 27546 0 ustar mbouschen staff 0 0 /*
* 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.mapping;
import java.util.Date;
import org.apache.jdo.tck.pc.company.FullTimeEmployee;
import org.apache.jdo.tck.pc.company.IEmployee;
import org.apache.jdo.tck.pc.company.IMedicalInsurance;
import org.apache.jdo.tck.pc.company.MedicalInsurance;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Relationship1To1AllRelationships
*Keywords: mapping, managed relationships
*Assertion ID: A15.3-14
*Assertion Description: Regardless of which side changes the relationship,
* flush (whether done as part of commit or explicitly by the user) will modify
* the datastore to reflect the change and will update the memory model
* for consistency...
*/
public class Relationship1To1AllRelationships extends AbstractRelationshipTest {
String testMethod = null;
protected String ASSERTION_FAILED =
"Assertion A15-3.14 (Relationship1To1AllRelationships) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(Relationship1To1AllRelationships.class);
}
Object emp1Oid = null;
Object emp2Oid = null;
Object medIns1Oid = null;
Object medIns2Oid = null;
IEmployee emp1 = null;
IEmployee emp2 = null;
IMedicalInsurance medIns1 = null;
IMedicalInsurance medIns2 = null;
/**
* @see AbstractRelationshipTest#localSetUp()
*/
protected void localSetUp() {
super.localSetUp();
if (isTestToBePerformed) {
getPM();
pm.currentTransaction().begin();
emp1Oid = getOidByName("emp1");
emp2Oid = getOidByName("emp2");
medIns1Oid = getOidByName("medicalIns1");
medIns2Oid = getOidByName("medicalIns2");
emp1 = (IEmployee)pm.getObjectById(emp1Oid);
emp2 = (IEmployee)pm.getObjectById(emp2Oid);
medIns1 = (IMedicalInsurance)pm.getObjectById(medIns1Oid);
medIns2 = (IMedicalInsurance)pm.getObjectById(medIns2Oid);
// Preconditions
assertTrue(ASSERTION_FAILED + testMethod +
": Test aborted, precondition is false; " +
"expected emp.getMedicalInsurance()to be medicalIns1",
emp1.getMedicalInsurance() == medIns1);
assertTrue(ASSERTION_FAILED + testMethod +
": Test aborted, precondition is false; " +
"expected ins.getEmployee() to be emp1",
medIns1.getEmployee() == emp1);
assertTrue(ASSERTION_FAILED + testMethod +
": Test aborted, precondition is false; " +
"expected emp.getMedicalInsurance()to be medicalIns1",
emp2.getMedicalInsurance() == medIns2);
assertTrue(ASSERTION_FAILED + testMethod +
": Test aborted, precondition is false; " +
"expected ins.getEmployee() to be emp1",
medIns2.getEmployee() == emp2);
}
}
/** */
public void testSetToExistingFromMappedSide() {
testMethod = "testSetToExistingFromMappedSide";
if (isTestToBePerformed) {
// Set relationship
medIns1.setEmployee(emp2);
pm.flush();
// Postcondition
deferredAssertTrue(emp2.getMedicalInsurance() == medIns1,
ASSERTION_FAILED + testMethod,
"Postcondition is false; "
+ "other side of relationship not set on flush");
deferredAssertTrue(emp1.getMedicalInsurance() == null,
ASSERTION_FAILED + testMethod,
"Postcondition is false; "
+ "previous relationship (emp1) not nulled on flush");
deferredAssertTrue(medIns2.getEmployee() == null,
ASSERTION_FAILED + testMethod,
"Postcondition is false; "
+ "previous relationship (medIns2) not nulled on flush");
pm.currentTransaction().commit();
cleanupPM();
getPM();
pm.currentTransaction().begin();
emp1 = (IEmployee)pm.getObjectById(emp1Oid);
emp2 = (IEmployee)pm.getObjectById(emp2Oid);
medIns1 = (IMedicalInsurance)pm.getObjectById(medIns1Oid);
medIns2 = (IMedicalInsurance)pm.getObjectById(medIns2Oid);
deferredAssertTrue(emp2.getMedicalInsurance() == medIns1,
ASSERTION_FAILED + testMethod,
"Postcondition is false; "
+ "other side of relationship not set in new pm");
deferredAssertTrue(emp1.getMedicalInsurance() == null,
ASSERTION_FAILED + testMethod,
"Postcondition is false; "
+ "previous relationship (emp1) not nulled in new pm");
deferredAssertTrue(medIns2.getEmployee() == null,
ASSERTION_FAILED + testMethod,
"Postcondition is false; "
+ "previous relationship (medIns2) not nulled in new pm");
pm.currentTransaction().commit();
failOnError();
}
}
/** */
public void testSetToExistingFromMappedBySide() {
testMethod = "testSetToExistingFromMappedBySide";
if (isTestToBePerformed) {
// Set relationship
emp1.setMedicalInsurance(medIns2);
pm.flush();
// Postcondition
deferredAssertTrue(medIns2.getEmployee() == emp1,
ASSERTION_FAILED + testMethod,
"Postcondition is false; "
+ "other side of relationship not set on flush.");
deferredAssertTrue(medIns1.getEmployee() == null,
ASSERTION_FAILED + testMethod,
"Postcondition is false; "
+ "previous relationship (medIns1) not nulled on flush.");
deferredAssertTrue(emp2.getMedicalInsurance() == null,
ASSERTION_FAILED + testMethod,
"Postcondition is false; "
+ "previous relationship (emp2) not nulled on flush");
pm.currentTransaction().commit();
cleanupPM();
getPM();
pm.currentTransaction().begin();
emp1 = (IEmployee)pm.getObjectById(emp1Oid);
emp2 = (IEmployee)pm.getObjectById(emp2Oid);
medIns1 = (IMedicalInsurance)pm.getObjectById(medIns1Oid);
medIns2 = (IMedicalInsurance)pm.getObjectById(medIns2Oid);
deferredAssertTrue(medIns2.getEmployee() == emp1,
ASSERTION_FAILED + testMethod,
"Postcondition is false; "
+ "other side of relationship not set in new pm.");
deferredAssertTrue(medIns1.getEmployee() == null,
ASSERTION_FAILED + testMethod,
"Postcondition is false; "
+ "previous relationship (medIns1) not nulled in new pm.");
deferredAssertTrue(emp2.getMedicalInsurance() == null,
ASSERTION_FAILED + testMethod,
"Postcondition is false; "
+ "previous relationship (emp2) not nulled in new pm.");
pm.currentTransaction().commit();
failOnError();
}
}
/** */
public void testSetToNullFromMappedSide() {
testMethod = "testSetToNullFromMappedSide";
if (isTestToBePerformed) {
// Set relationship
medIns1.setEmployee(null);
pm.flush();
// Postcondition
deferredAssertTrue(emp1.getMedicalInsurance() == null,
ASSERTION_FAILED + testMethod,
"Postcondition is false; "
+ "other side of relationship not set on flush");
pm.currentTransaction().commit();
cleanupPM();
getPM();
pm.currentTransaction().begin();
emp1 = (IEmployee)pm.getObjectById(emp1Oid);
deferredAssertTrue(
emp1.getMedicalInsurance() == null,
ASSERTION_FAILED + testMethod,
"In new transaction, postcondition is false; " +
"other side of relationship is not set.");
pm.currentTransaction().commit();
failOnError();
}
}
/** */
public void testSetToNullFromMappedBySide() {
testMethod = "testSetToNullFromMappedBySide";
if (isTestToBePerformed) {
// Set relationship
emp1.setMedicalInsurance(null);
pm.flush();
// Postcondition
deferredAssertTrue(medIns1.getEmployee() == null,
ASSERTION_FAILED + testMethod,
"Postcondition is false; "
+ "other side of relationship not set on flush");
pm.currentTransaction().commit();
cleanupPM();
getPM();
pm.currentTransaction().begin();
//emp1 = (IEmployee)pm.getObjectById(emp1Oid);
medIns1 = (IMedicalInsurance)pm.getObjectById(medIns1Oid);
deferredAssertTrue(
medIns1.getEmployee() == null,
ASSERTION_FAILED + testMethod,
"In new transaction, postcondition is false; " +
"other side of relationship is not set.");
pm.currentTransaction().commit();
failOnError();
}
}
/** */
public void testSetToNewFromMappedSide() {
testMethod = "testSetToNewFromMappedSide";
if (isTestToBePerformed) {
// Set relationship
IEmployee empNew = new FullTimeEmployee(99, "Matthew", "", "Adams",
new Date(0L), new Date(10000L), 125000);
pm.makePersistent(empNew);
medIns1.setEmployee(empNew);
Object empNewOid = pm.getObjectId((Object)empNew);
pm.flush();
assertFalse(testMethod + ": Test aborted, precondition is false; " +
"expected empNewOid to be non-null", empNewOid == null);
// Postcondition
deferredAssertTrue(empNew.getMedicalInsurance() == medIns1,
ASSERTION_FAILED + testMethod,
"Postcondition is false; "
+ "other side of relationship not set on flush");
deferredAssertTrue(emp1.getMedicalInsurance() == null,
ASSERTION_FAILED + testMethod,
"Postcondition is false; "
+ "previous relationship (emp1) not nulled on flush");
pm.currentTransaction().commit();
cleanupPM();
getPM();
pm.currentTransaction().begin();
emp1 = (IEmployee)pm.getObjectById(emp1Oid);
empNew = (IEmployee)pm.getObjectById(empNewOid);
medIns1 = (IMedicalInsurance)pm.getObjectById(medIns1Oid);
deferredAssertTrue(empNew.getMedicalInsurance() == medIns1,
ASSERTION_FAILED + testMethod,
"Postcondition is false; "
+ "other side of relationship not set in new pm");
deferredAssertTrue(emp1.getMedicalInsurance() == null,
ASSERTION_FAILED + testMethod,
"Postcondition is false; "
+ "previous relationship (emp1) not nulled in new pm");
pm.currentTransaction().commit();
failOnError();
}
}
/** */
public void testSetToNewFromMappedBySide() {
testMethod = "testSetToNewFromMappedBySide";
if (isTestToBePerformed) {
// Set relationship
IMedicalInsurance medInsNew = new MedicalInsurance(99L,
"Ameriblast", "B");
pm.makePersistent(medInsNew);
emp1.setMedicalInsurance(medInsNew);
Object medInsNewOid = pm.getObjectId((Object)medInsNew);
pm.flush();
assertFalse(testMethod + ": Test aborted, precondition is false; " +
"expected medInsNewOid to be non-null", medInsNewOid == null);
// Postcondition
deferredAssertTrue(medInsNew.getEmployee() == emp1,
ASSERTION_FAILED + testMethod,
"Postcondition is false; "
+ "other side of relationship not set on flush.");
deferredAssertTrue(medIns1.getEmployee() == null,
ASSERTION_FAILED + testMethod,
"Postcondition is false; "
+ "previous relationship (medIns1) not nulled on flush.");
pm.currentTransaction().commit();
cleanupPM();
getPM();
pm.currentTransaction().begin();
emp1 = (IEmployee)pm.getObjectById(emp1Oid);
medInsNew = (IMedicalInsurance)pm.getObjectById(medInsNewOid);
medIns1 = (IMedicalInsurance)pm.getObjectById(medIns1Oid);
deferredAssertTrue(medInsNew.getEmployee() == emp1,
ASSERTION_FAILED + testMethod,
"Postcondition is false; "
+ "other side of relationship not set in new pm");
deferredAssertTrue(medIns1.getEmployee() == null,
ASSERTION_FAILED + testMethod,
"Postcondition is false; "
+ "previous relationship (medIns1) not nulled in new pm");
pm.currentTransaction().commit();
failOnError();
}
}
/** */
public void testDeleteFromMappedSide() {
testMethod = "testDeleteFromMappedSide";
if (isTestToBePerformed) {
// Set relationship
pm.deletePersistent(medIns1);
pm.flush();
// Postcondition
deferredAssertTrue(emp1.getMedicalInsurance() == null,
ASSERTION_FAILED + testMethod,
"Postcondition is false; "
+ "other side of relationship not set on flush");
pm.currentTransaction().commit();
cleanupPM();
getPM();
pm.currentTransaction().begin();
emp1 = (IEmployee)pm.getObjectById(emp1Oid);
deferredAssertTrue(
emp1.getMedicalInsurance() == null,
ASSERTION_FAILED + testMethod,
"In new transaction, postcondition is false; " +
"other side of relationship is not set.");
pm.currentTransaction().commit();
failOnError();
}
}
/** */
public void testDeleteFromMappedBySide() {
testMethod = "testDeleteFromMappedBySide";
if (isTestToBePerformed) {
// Set relationship
pm.deletePersistent(emp1);
pm.flush();
// Postcondition
deferredAssertTrue(medIns1.getEmployee() == null,
ASSERTION_FAILED + testMethod,
"Postcondition is false; "
+ "other side of relationship not set on flush");
pm.currentTransaction().commit();
cleanupPM();
getPM();
pm.currentTransaction().begin();
medIns1 = (IMedicalInsurance)pm.getObjectById(medIns1Oid);
deferredAssertTrue(
medIns1.getEmployee() == null,
ASSERTION_FAILED + testMethod,
"In new transaction, postcondition is false; " +
"other side of relationship is not set.");
pm.currentTransaction().commit();
failOnError();
}
}
}
tck/src/java/org/apache/jdo/tck/mapping/Relationship1To1NoRelationships.java 100664 20364 12500110374 27421 0 ustar mbouschen staff 0 0 /*
* 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.mapping;
import java.util.Date;
import org.apache.jdo.tck.pc.company.Employee;
import org.apache.jdo.tck.pc.company.FullTimeEmployee;
import org.apache.jdo.tck.pc.company.MedicalInsurance;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Relationship1To1NoRelationships
*Keywords: mapping, managed relationships
*Assertion ID: A15.3-14
*Assertion Description: Regardless of which side changes the relationship,
* flush (whether done as part of commit or explicitly by the user) will modify
* the datastore to reflect the change and will update the memory model
* for consistency...
*/
public class Relationship1To1NoRelationships extends AbstractRelationshipTest {
String testMethod = null;
protected String ASSERTION_FAILED =
"Assertion A15-3.14 (Relationship1To1NoRelationships) failed: ";
Object emp1Oid = null;
Object emp2Oid = null;
Object medIns1Oid = null;
Object medIns2Oid = null;
Employee emp1 = null;
Employee emp2 = null;
MedicalInsurance medIns1 = null;
MedicalInsurance medIns2 = null;
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(Relationship1To1NoRelationships.class);
}
/**
* @see AbstractRelationshipTest#localSetUp()
*/
protected void localSetUp() {
super.localSetUp();
if (isTestToBePerformed) {
getPM();
pm.currentTransaction().begin();
emp1Oid = getOidByName("emp1");
medIns1Oid = getOidByName("medicalIns1");
emp1 = (Employee)pm.getObjectById(emp1Oid);
medIns1 = (MedicalInsurance)pm.getObjectById(medIns1Oid);
// Preconditions
assertTrue(ASSERTION_FAILED +
": Test aborted, precondition is false; " +
"expected emp.getMedicalInsurance()to be null",
emp1.getMedicalInsurance() == null);
assertTrue(ASSERTION_FAILED +
": Test aborted, precondition is false; " +
"expected ins.getEmployee() to be null",
medIns1.getEmployee() == null);
}
}
/** */
public void testSetToExistingFromMappedSide() {
testMethod = "testSetToExistingFromMappedSide";
if (isTestToBePerformed) {
// Set relationship
medIns1.setEmployee(emp1);
pm.flush();
// Postcondition
deferredAssertTrue(emp1.getMedicalInsurance() == medIns1,
ASSERTION_FAILED + testMethod,
"Postcondition is false; "
+ "other side of relationship not set on flush");
pm.currentTransaction().commit();
cleanupPM();
getPM();
pm.currentTransaction().begin();
emp1 = (Employee)pm.getObjectById(emp1Oid);
medIns1 = (MedicalInsurance)pm.getObjectById(medIns1Oid);
deferredAssertTrue(
emp1.getMedicalInsurance() == medIns1,
ASSERTION_FAILED + testMethod,
"In new transaction, postcondition is false; " +
"other side of relationship is not set.");
pm.currentTransaction().commit();
failOnError();
}
}
/** */
public void testSetToExistingFromMappedBySide() {
testMethod = "testSetToExistingFromMappedBySide";
if (isTestToBePerformed) {
// Set relationship
emp1.setMedicalInsurance(medIns1);
pm.flush();
// Postcondition
deferredAssertTrue(medIns1.getEmployee() == emp1,
ASSERTION_FAILED + testMethod,
"Postcondition is false; "
+ "other side of relationship not set on flush");
pm.currentTransaction().commit();
cleanupPM();
getPM();
pm.currentTransaction().begin();
emp1 = (Employee)pm.getObjectById(emp1Oid);
medIns1 = (MedicalInsurance)pm.getObjectById(medIns1Oid);
deferredAssertTrue(
medIns1.getEmployee() == emp1,
ASSERTION_FAILED + testMethod,
"In new transaction, postcondition is false; " +
"other side of relationship is not set.");
pm.currentTransaction().commit();
failOnError();
}
}
/** */
public void testSetToNewFromMappedSide() {
testMethod = "testSetToNewFromMappedSide";
if (isTestToBePerformed) {
// Set relationship
Employee empNew = new FullTimeEmployee(99, "Matthew", "", "Adams",
new Date(0L), new Date(10000L), 125000);
pm.makePersistent(empNew);
medIns1.setEmployee(empNew);
Object empNewOid = pm.getObjectId((Object)empNew);
pm.flush();
// Postcondition
deferredAssertTrue(empNew.getMedicalInsurance() == medIns1,
ASSERTION_FAILED + testMethod,
"Postcondition is false; "
+ "other side of relationship not set on flush");
pm.currentTransaction().commit();
cleanupPM();
getPM();
pm.currentTransaction().begin();
emp1 = (Employee)pm.getObjectById(emp1Oid);
empNew = (Employee)pm.getObjectById(empNewOid);
medIns1 = (MedicalInsurance)pm.getObjectById(medIns1Oid);
deferredAssertTrue(empNew.getMedicalInsurance() == medIns1,
ASSERTION_FAILED + testMethod,
"Postcondition is false; "
+ "other side of relationship not set in new pm");
pm.currentTransaction().commit();
failOnError();
}
}
/** */
public void testSetToNewFromMappedBySide() {
testMethod = "testSetToNewFromMappedBySide";
if (isTestToBePerformed) {
// Set relationship
MedicalInsurance medInsNew = new MedicalInsurance(99L,
"Ameriblast", "B");
pm.makePersistent(medInsNew);
emp1.setMedicalInsurance(medInsNew);
Object medInsNewOid = pm.getObjectId((Object)medInsNew);
pm.flush();
// Postcondition
deferredAssertTrue(medInsNew.getEmployee() == emp1,
ASSERTION_FAILED + testMethod,
"Postcondition is false; "
+ "other side of relationship not set on flush.");
pm.currentTransaction().commit();
cleanupPM();
getPM();
pm.currentTransaction().begin();
emp1 = (Employee)pm.getObjectById(emp1Oid);
medInsNew = (MedicalInsurance)pm.getObjectById(medInsNewOid);
medIns1 = (MedicalInsurance)pm.getObjectById(medIns1Oid);
deferredAssertTrue(medInsNew.getEmployee() == emp1,
ASSERTION_FAILED + testMethod,
"Postcondition is false; "
+ "other side of relationship not set in new pm");
pm.currentTransaction().commit();
failOnError();
}
}
}
tck/src/java/org/apache/jdo/tck/mapping/Relationship1ToManyAllRelationships.java 100664 42723 12500110374 30324 0 ustar mbouschen staff 0 0 /*
* 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.mapping;
import java.util.Date;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import javax.jdo.JDOHelper;
import org.apache.jdo.tck.pc.company.Department;
import org.apache.jdo.tck.pc.company.Employee;
import org.apache.jdo.tck.pc.company.FullTimeEmployee;
import org.apache.jdo.tck.pc.company.IDepartment;
import org.apache.jdo.tck.pc.company.IEmployee;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Relationship1ToManyAllRelationships
*Keywords: mapping, managed relationships
*Assertion ID: A15.3-14
*Assertion Description: Regardless of which side changes the relationship,
* flush (whether done as part of commit or explicitly by the user) will modify
* the datastore to reflect the change and will update the memory model
* for consistency...
*/
public class Relationship1ToManyAllRelationships extends AbstractRelationshipTest {
String testMethod = null;
protected String ASSERTION_FAILED =
"Assertion A15-3.14 (Relationship1ToManyAllRelationships) failed: ";
Object emp1Oid = null;
Object dept1Oid = null;
Object dept2Oid = null;
Employee emp1 = null;
Department dept1 = null;
Department dept2 = null;
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(Relationship1ToManyAllRelationships.class);
}
/**
* @see AbstractRelationshipTest#localSetUp()
*/
protected void localSetUp() {
super.localSetUp();
if (isTestToBePerformed) {
getPM();
pm.currentTransaction().begin();
emp1Oid = getOidByName("emp1");
dept1Oid = getOidByName("dept1");
dept2Oid = getOidByName("dept2");
emp1 = (Employee)pm.getObjectById(emp1Oid);
dept1 = (Department)pm.getObjectById(dept1Oid);
dept2 = (Department)pm.getObjectById(dept2Oid);
// Preconditions
assertTrue(ASSERTION_FAILED +
": Test aborted, precondition is false; " +
"expected emp.getDepartment()to be dept1",
emp1.getDepartment() == dept1);
assertTrue(ASSERTION_FAILED +
": Test aborted, precondition is false; " +
"expected dept.getEmployees() to contain emp1",
dept1.getEmployees().contains(emp1));
}
}
/** */
public void testSetToExistingFromMappedSide() {
testMethod = "testSetToExistingFromMappedSide";
if (isTestToBePerformed) {
// Set relationship
emp1.setDepartment(dept2);
pm.flush();
// Postcondition
deferredAssertTrue(dept2.getEmployees().contains(emp1),
ASSERTION_FAILED + testMethod,
"Postcondition is false; "
+ "other side of relationship not set on flush");
deferredAssertTrue(!dept1.getEmployees().contains(emp1),
ASSERTION_FAILED + testMethod,
"Postcondition is false; reference emp1 not removed "
+ "from previous relationship (dept1.employees)");
pm.currentTransaction().commit();
cleanupPM();
getPM();
pm.currentTransaction().begin();
emp1 = (Employee)pm.getObjectById(emp1Oid);
dept1 = (Department)pm.getObjectById(dept1Oid);
dept2 = (Department)pm.getObjectById(dept2Oid);
deferredAssertTrue(dept2.getEmployees().contains(emp1),
ASSERTION_FAILED + testMethod,
"Postcondition is false; "
+ "other side of relationship not set in new pm");
deferredAssertTrue(!dept1.getEmployees().contains(emp1),
ASSERTION_FAILED + testMethod,
"Postcondition is false; reference emp1 not removed "
+ "from previous relationship (dept1.employees)");
pm.currentTransaction().commit();
failOnError();
}
}
/** */
public void testAddExistingFromMappedbySide() {
testMethod = "testAddExistingFromMappedbySide";
if (isTestToBePerformed) {
// Set relationship
Object emp4Oid = getOidByName("emp4");
Employee emp4 = (Employee)pm.getObjectById(emp4Oid);
Object dept2Oid = getOidByName("dept2");
Department dept2 = (Department)pm.getObjectById(dept2Oid);
dept1.addEmployee(emp4);
pm.flush();
// Postcondition
deferredAssertTrue(emp4.getDepartment() == dept1,
ASSERTION_FAILED + testMethod,
"Postcondition is false; "
+ "other side of relationship not set on flush");
deferredAssertTrue(!dept2.getEmployees().contains(emp4),
ASSERTION_FAILED + testMethod,
"Postcondition is false; "
+ "previous relationship not unset on flush");
pm.currentTransaction().commit();
cleanupPM();
getPM();
pm.currentTransaction().begin();
emp4 = (Employee)pm.getObjectById(emp4Oid);
dept1 = (Department)pm.getObjectById(dept1Oid);
dept2 = (Department)pm.getObjectById(dept2Oid);
deferredAssertTrue(emp4.getDepartment() == dept1,
ASSERTION_FAILED + testMethod,
"In new transaction, postcondition is false; " +
"other side of relationship is not set.");
deferredAssertTrue(!dept2.getEmployees().contains(emp4),
ASSERTION_FAILED + testMethod,
"Postcondition is false; "
+ "previous relationship not unset on flush");
pm.currentTransaction().commit();
failOnError();
}
}
/** */
public void testReplaceFromMappedbySide() {
testMethod = "testReplaceFromMappedbySide";
if (isTestToBePerformed) {
// Set relationship
Object emp4Oid = getOidByName("emp4");
Employee emp4 = (Employee)pm.getObjectById(emp4Oid);
Object dept2Oid = getOidByName("dept2");
Department dept2 = (Department)pm.getObjectById(dept2Oid);
Set emps = new HashSet();
emps.add(emp4);
dept1.setEmployees(emps);
pm.flush();
// Postcondition
deferredAssertTrue(emp4.getDepartment() == dept1,
ASSERTION_FAILED + testMethod,
"Postcondition is false; "
+ "other side of relationship not set on flush");
deferredAssertTrue(!dept2.getEmployees().contains(emp4),
ASSERTION_FAILED + testMethod,
"Postcondition is false; "
+ "previous relationship not unset on flush");
pm.currentTransaction().commit();
cleanupPM();
getPM();
pm.currentTransaction().begin();
emp4 = (Employee)pm.getObjectById(emp4Oid);
dept1 = (Department)pm.getObjectById(dept1Oid);
dept2 = (Department)pm.getObjectById(dept2Oid);
deferredAssertTrue(emp4.getDepartment() == dept1,
ASSERTION_FAILED + testMethod,
"In new transaction, postcondition is false; " +
"other side of relationship is not set.");
deferredAssertTrue(!dept2.getEmployees().contains(emp4),
ASSERTION_FAILED + testMethod,
"Postcondition is false; "
+ "previous relationship not unset on flush");
pm.currentTransaction().commit();
failOnError();
}
}
/** */
public void testAddNewFromMappedbySide() {
testMethod = "testAddNewFromMappedbySide";
if (isTestToBePerformed) {
// Set relationship
Employee empNew = new FullTimeEmployee(101, "Jenny", "Merriwether",
"White", new Date(500L), new Date(10000L), 135000);
pm.makePersistent(empNew);
Object empNewOid = pm.getObjectId((Object)empNew);
dept1.addEmployee(empNew);
pm.flush();
// Postcondition
deferredAssertTrue(empNew.getDepartment() == dept1,
ASSERTION_FAILED + testMethod,
"Postcondition is false; "
+ "other side of relationship not set on flush");
pm.currentTransaction().commit();
cleanupPM();
getPM();
pm.currentTransaction().begin();
empNew = (Employee)pm.getObjectById(empNewOid);
dept1 = (Department)pm.getObjectById(dept1Oid);
deferredAssertTrue(empNew.getDepartment() == dept1,
ASSERTION_FAILED + testMethod,
"In new transaction, postcondition is false; " +
"other side of relationship is not set.");
pm.currentTransaction().commit();
failOnError();
}
}
/** */
public void testSetToNullFromMappedSide() {
testMethod = "testSetToNullFromMappedSide";
if (isTestToBePerformed) {
// Set relationship
emp1.setDepartment(null);
pm.flush();
// Postcondition
deferredAssertTrue(!dept1.getEmployees().contains(emp1),
ASSERTION_FAILED + testMethod,
"Postcondition is false; "
+ "other side of relationship not set on flush");
pm.currentTransaction().commit();
cleanupPM();
getPM();
pm.currentTransaction().begin();
emp1 = (Employee)pm.getObjectById(emp1Oid);
dept1 = (Department)pm.getObjectById(dept1Oid);
deferredAssertTrue(
!dept1.getEmployees().contains(emp1),
ASSERTION_FAILED + testMethod,
"In new transaction, postcondition is false; " +
"other side of relationship is not set.");
pm.currentTransaction().commit();
failOnError();
}
}
/** */
public void testSetToNullFromMappedbySide() {
testMethod = "testSetToNullFromMappedbySide";
if (isTestToBePerformed) {
// Set relationship
dept1.setEmployees(null);
pm.flush();
// Postcondition
deferredAssertTrue(emp1.getDepartment() == null,
ASSERTION_FAILED + testMethod,
"Postcondition is false; "
+ "other side of relationship not set on flush");
pm.currentTransaction().commit();
cleanupPM();
getPM();
pm.currentTransaction().begin();
emp1 = (Employee)pm.getObjectById(emp1Oid);
deferredAssertTrue(
emp1.getDepartment() == null,
ASSERTION_FAILED + testMethod,
"In new transaction, postcondition is false; " +
"other side of relationship is not set.");
pm.currentTransaction().commit();
failOnError();
}
}
/** */
public void testSetToNewFromMappedSide() {
testMethod = "testSetToNewFromMappedSide";
if (isTestToBePerformed) {
// Set relationship
IDepartment deptNew = new Department(99L, "The New Department");
pm.makePersistent(deptNew);
emp1.setDepartment(deptNew);
Object deptNewOid = pm.getObjectId((Object)deptNew);
pm.flush();
assertFalse(testMethod + ": Test aborted, precondition is false; " +
"expected deptNewOid to be non-null", deptNewOid == null);
// Postcondition
deferredAssertTrue(deptNew.getEmployees().contains(emp1),
ASSERTION_FAILED + testMethod,
"Postcondition is false; "
+ "other side of relationship not set on flush");
deferredAssertTrue(!dept1.getEmployees().contains(emp1),
ASSERTION_FAILED + testMethod,
"Postcondition is false; "
+ "previous relationship (dept1) not nulled on flush");
pm.currentTransaction().commit();
cleanupPM();
getPM();
pm.currentTransaction().begin();
emp1 = (Employee)pm.getObjectById(emp1Oid);
deptNew = (Department)pm.getObjectById(deptNewOid);
dept1 = (Department)pm.getObjectById(dept1Oid);
deferredAssertTrue(deptNew.getEmployees().contains(emp1),
ASSERTION_FAILED + testMethod,
"Postcondition is false; "
+ "other side of relationship not set in new pm");
deferredAssertTrue(!dept1.getEmployees().contains(emp1),
ASSERTION_FAILED + testMethod,
"Postcondition is false; "
+ "previous relationship (dept1) not nulled in new pm");
pm.currentTransaction().commit();
failOnError();
}
}
/** */
public void testRemoveFromMappedbySide() {
testMethod = "testRemoveFromMappedbySide";
if (isTestToBePerformed) {
// Set relationship
dept1.removeEmployee(emp1);
pm.flush();
// Postcondition
deferredAssertTrue(emp1.getDepartment() == null,
ASSERTION_FAILED + testMethod,
"Postcondition is false; "
+ "other side of relationship not set on flush");
pm.currentTransaction().commit();
cleanupPM();
getPM();
pm.currentTransaction().begin();
emp1 = (Employee)pm.getObjectById(emp1Oid);
deferredAssertTrue(
emp1.getDepartment() == null,
ASSERTION_FAILED + testMethod,
"In new transaction, postcondition is false; " +
"other side of relationship is not set.");
pm.currentTransaction().commit();
failOnError();
}
}
/** */
public void testDeleteFromMappedSide() {
testMethod = "testDeleteFromMappedSide";
if (isTestToBePerformed) {
// remember id
long emp1Id = emp1.getPersonid();
// Set relationship
pm.deletePersistent(emp1);
pm.flush();
// Postcondition
deferredAssertTrue(!containsEmployee(dept1.getEmployees(), emp1Id),
ASSERTION_FAILED + testMethod,
"Postcondition is false; "
+ "other side of relationship not set on flush");
pm.currentTransaction().commit();
cleanupPM();
getPM();
pm.currentTransaction().begin();
dept1 = (Department)pm.getObjectById(dept1Oid);
deferredAssertTrue(
!containsEmployee(dept1.getEmployees(), emp1Id),
ASSERTION_FAILED + testMethod,
"In new transaction, postcondition is false; " +
"other side of relationship is not set.");
pm.currentTransaction().commit();
failOnError();
}
}
/** */
public void testDeleteFromMappedbySide() {
testMethod = "testDeleteFromMappedbySide";
if (isTestToBePerformed) {
// Set relationship
pm.deletePersistent(dept1);
pm.flush();
// Postcondition
deferredAssertTrue(emp1.getDepartment() == null,
ASSERTION_FAILED + testMethod,
"Postcondition is false; "
+ "other side of relationship not set on flush");
pm.currentTransaction().commit();
cleanupPM();
getPM();
pm.currentTransaction().begin();
emp1 = (Employee)pm.getObjectById(emp1Oid);
deferredAssertTrue(
emp1.getDepartment() == null,
ASSERTION_FAILED + testMethod,
"In new transaction, postcondition is false; " +
"other side of relationship is not set.");
pm.currentTransaction().commit();
failOnError();
}
}
}
tck/src/java/org/apache/jdo/tck/mapping/Relationship1ToManyNoRelationships.java 100664 22570 12500110374 30166 0 ustar mbouschen staff 0 0 /*
* 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.mapping;
import java.util.Date;
import java.util.HashSet;
import java.util.Set;
import org.apache.jdo.tck.pc.company.Department;
import org.apache.jdo.tck.pc.company.Employee;
import org.apache.jdo.tck.pc.company.FullTimeEmployee;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Relationship1ToManyNoRelationships
*Keywords: mapping, managed relationships
*Assertion ID: A15.3-14
*Assertion Description: Regardless of which side changes the relationship,
* flush (whether done as part of commit or explicitly by the user) will modify
* the datastore to reflect the change and will update the memory model
* for consistency...
*/
public class Relationship1ToManyNoRelationships extends AbstractRelationshipTest {
String testMethod = null;
protected String ASSERTION_FAILED =
"Assertion A15-3.14 (Relationship1ToManyNoRelationships) failed: ";
Object emp1Oid = null;
Object dept1Oid = null;
Object dept2Oid = null;
Employee emp1 = null;
Department dept1 = null;
Department dept2 = null;
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(Relationship1ToManyNoRelationships.class);
}
/**
* @see AbstractRelationshipTest#localSetUp()
*/
protected void localSetUp() {
super.localSetUp();
if (isTestToBePerformed) {
getPM();
pm.currentTransaction().begin();
emp1Oid = getOidByName("emp1");
dept1Oid = getOidByName("dept1");
dept2Oid = getOidByName("dept2");
emp1 = (Employee)pm.getObjectById(emp1Oid);
dept1 = (Department)pm.getObjectById(dept1Oid);
dept2 = (Department)pm.getObjectById(dept2Oid);
// Preconditions
assertTrue(ASSERTION_FAILED +
": Test aborted, precondition is false; " +
"expected emp.getDepartment()to be null",
emp1.getDepartment() == null);
assertTrue(ASSERTION_FAILED + testMethod +
": Test aborted, precondition is false; " +
"expected dept.getEmployees() to be empty",
dept1.getEmployees().isEmpty());
}
}
/** */
public void testSetToExistingFromMappedSide() {
testMethod = "testSetToExistingFromMappedSide";
if (isTestToBePerformed) {
// Set relationship
emp1.setDepartment(dept1);
pm.flush();
// Postcondition
deferredAssertTrue(dept1.getEmployees().contains(emp1),
ASSERTION_FAILED + testMethod,
"Postcondition is false; "
+ "other side of relationship not set on flush");
pm.currentTransaction().commit();
cleanupPM();
getPM();
pm.currentTransaction().begin();
emp1 = (Employee)pm.getObjectById(emp1Oid);
dept1 = (Department)pm.getObjectById(dept1Oid);
deferredAssertTrue(
dept1.getEmployees().contains(emp1),
ASSERTION_FAILED + testMethod,
"In new transaction, postcondition is false; " +
"other side of relationship is not set.");
pm.currentTransaction().commit();
failOnError();
}
}
/** */
public void testAddExistingFromMappedbySide() {
testMethod = "testSetToExistingFromMappedbySide";
if (isTestToBePerformed) {
// Set relationship
Set emps = new HashSet();
emps.add(emp1);
dept1.setEmployees(emps);
pm.flush();
// Postcondition
deferredAssertTrue(emp1.getDepartment() == dept1,
ASSERTION_FAILED + testMethod,
"Postcondition is false; "
+ "other side of relationship not set on flush");
pm.currentTransaction().commit();
cleanupPM();
getPM();
pm.currentTransaction().begin();
emp1 = (Employee)pm.getObjectById(emp1Oid);
dept1 = (Department)pm.getObjectById(dept1Oid);
deferredAssertTrue(
emp1.getDepartment() == dept1,
ASSERTION_FAILED + testMethod,
"In new transaction, postcondition is false; " +
"other side of relationship is not set.");
pm.currentTransaction().commit();
failOnError();
}
}
/** */
public void testSetToNewFromMappedSide() {
testMethod = "testSetToNewFromMappedSide";
if (isTestToBePerformed) {
// Set relationship
Department deptNew = new Department(99L, "The New Department");
emp1.setDepartment(deptNew);
pm.makePersistent(deptNew);
Object deptNewOid = pm.getObjectId((Object)deptNew);
pm.flush();
assertFalse(testMethod + ": Test aborted, precondition is false; " +
"expected deptNewOid to be non-null", deptNewOid == null);
// Postcondition
deferredAssertTrue(deptNew.getEmployees().contains(emp1),
ASSERTION_FAILED + testMethod,
"Postcondition is false; "
+ "other side of relationship not set on flush");
deferredAssertTrue(!dept1.getEmployees().contains(emp1),
ASSERTION_FAILED + testMethod,
"Postcondition is false; "
+ "previous relationship (dept1) not nulled on flush");
pm.currentTransaction().commit();
cleanupPM();
getPM();
pm.currentTransaction().begin();
emp1 = (Employee)pm.getObjectById(emp1Oid);
deptNew = (Department)pm.getObjectById(deptNewOid);
dept1 = (Department)pm.getObjectById(dept1Oid);
deferredAssertTrue(deptNew.getEmployees().contains(emp1),
ASSERTION_FAILED + testMethod,
"Postcondition is false; "
+ "other side of relationship not set in new pm");
deferredAssertTrue(!dept1.getEmployees().contains(emp1),
ASSERTION_FAILED + testMethod,
"Postcondition is false; "
+ "previous relationship (dept1) not nulled in new pm");
pm.currentTransaction().commit();
failOnError();
}
}
/** */
public void testSetToNewFromMappedbySide() {
testMethod = "testSetToNewFromMappedbySide";
if (isTestToBePerformed) {
// Set relationship
Set emps = new HashSet();
Employee empNew = new FullTimeEmployee(101, "Jenny", "Merriwether",
"White", new Date(500L), new Date(10000L), 135000);
pm.makePersistent(empNew);
emps.add(empNew);
dept1.setEmployees(emps);
Object empNewOid = pm.getObjectId((Object)empNew);
pm.flush();
// Postcondition
deferredAssertTrue(empNew.getDepartment() == dept1,
ASSERTION_FAILED + testMethod,
"Postcondition is false; "
+ "other side of relationship not set on flush");
deferredAssertTrue(emp1.getDepartment() == null,
ASSERTION_FAILED + testMethod,
"Postcondition is false; "
+ "previous relationship not nulled on flush");
pm.currentTransaction().commit();
cleanupPM();
getPM();
pm.currentTransaction().begin();
empNew = (Employee)pm.getObjectById(empNewOid);
emp1 = (Employee)pm.getObjectById(emp1Oid);
dept1 = (Department)pm.getObjectById(dept1Oid);
deferredAssertTrue(empNew.getDepartment() == dept1,
ASSERTION_FAILED + testMethod,
"Postcondition is false; "
+ "other side of relationship not set in new pm");
deferredAssertTrue(emp1.getDepartment() == null,
ASSERTION_FAILED + testMethod,
"Postcondition is false; "
+ "previous relationship not nulled in new pm");
pm.currentTransaction().commit();
failOnError();
}
}
}
tck/src/java/org/apache/jdo/tck/mapping/RelationshipManyToManyAllRelationships.java 100664 44651 12500110374 31072 0 ustar mbouschen staff 0 0 /*
* 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.mapping;
import java.math.BigDecimal;
import java.util.Date;
import java.util.HashSet;
import java.util.Set;
import org.apache.jdo.tck.pc.company.Employee;
import org.apache.jdo.tck.pc.company.FullTimeEmployee;
import org.apache.jdo.tck.pc.company.IEmployee;
import org.apache.jdo.tck.pc.company.IProject;
import org.apache.jdo.tck.pc.company.Project;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: RelationshipManyToManyAllRelationships
*Keywords: mapping, managed relationships
*Assertion ID: A15.3-14
*Assertion Description: Regardless of which side changes the relationship,
* flush (whether done as part of commit or explicitly by the user) will modify
* the datastore to reflect the change and will update the memory model
* for consistency...
*/
public class RelationshipManyToManyAllRelationships
extends AbstractRelationshipTest {
String testMethod = null;
protected String ASSERTION_FAILED =
"Assertion A15-3.14 (RelationshipManyToManyAllRelationships) failed: ";
Object emp1Oid = null;
Object proj1Oid = null;
Employee emp1 = null;
Project proj1 = null;
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(RelationshipManyToManyAllRelationships.class);
}
/**
* @see AbstractRelationshipTest#localSetUp()
*/
protected void localSetUp() {
super.localSetUp();
if (isTestToBePerformed) {
getPM();
pm.currentTransaction().begin();
emp1Oid = getOidByName("emp1");
proj1Oid = getOidByName("proj1");
emp1 = (Employee)pm.getObjectById(emp1Oid);
proj1 = (Project)pm.getObjectById(proj1Oid);
// Preconditions
assertTrue(testMethod +
": Test aborted, precondition is false; " +
"expected emp.getProjects()to be contain proj1",
emp1.getProjects().contains(proj1));
assertTrue(testMethod +
": Test aborted, precondition is false; " +
"expected proj.getMembers() to contain emp1",
proj1.getMembers().contains(emp1));
}
}
/** */
public void testSetToNullFromMappedSide() {
testMethod = "testSetToNullFromMappedSide";
if (isTestToBePerformed) {
// Set relationship
proj1.setMembers(null);
pm.flush();
// Postcondition
deferredAssertTrue(!emp1.getProjects().contains(proj1),
ASSERTION_FAILED + testMethod,
"Postcondition is false; "
+ "other side of relationship not set on flush");
pm.currentTransaction().commit();
cleanupPM();
getPM();
pm.currentTransaction().begin();
emp1 = (Employee)pm.getObjectById(emp1Oid);
proj1 = (Project)pm.getObjectById(proj1Oid);
deferredAssertTrue(
!emp1.getProjects().contains(proj1),
ASSERTION_FAILED + testMethod,
"In new transaction, postcondition is false; " +
"other side of relationship is not set.");
pm.currentTransaction().commit();
failOnError();
}
}
/** */
public void testSetToNullFromMappedbySide() {
testMethod = "testSetToNullFromMappedbySide";
if (isTestToBePerformed) {
// Set relationship
emp1.setProjects(null);
pm.flush();
// Postcondition
deferredAssertTrue(!proj1.getMembers().contains(emp1),
ASSERTION_FAILED + testMethod,
"Postcondition is false; "
+ "other side of relationship not set on flush");
pm.currentTransaction().commit();
cleanupPM();
getPM();
pm.currentTransaction().begin();
emp1 = (Employee)pm.getObjectById(emp1Oid);
proj1 = (Project)pm.getObjectById(proj1Oid);
deferredAssertTrue(
!proj1.getMembers().contains(emp1),
ASSERTION_FAILED + testMethod,
"In new transaction, postcondition is false; " +
"other side of relationship is not set.");
pm.currentTransaction().commit();
failOnError();
}
}
/** */
public void testReplaceFromMappedSide() {
testMethod = "testReplaceFromMappedSide";
if (isTestToBePerformed) {
// Set relationship
IEmployee empNew = new FullTimeEmployee(100, "Jerry", "Valentine",
"Brown", new Date(500L), new Date(10000L), 125000);
pm.makePersistent(empNew);
Set members = new HashSet();
members.add(empNew);
proj1.setMembers(members);
Object empNewOid = pm.getObjectId((Object)empNew);
pm.flush();
// Postcondition
deferredAssertTrue(empNew.getProjects().contains(proj1),
ASSERTION_FAILED + testMethod,
"Postcondition is false; "
+ "other side of relationship not set on flush");
pm.currentTransaction().commit();
cleanupPM();
getPM();
pm.currentTransaction().begin();
empNew = (IEmployee)pm.getObjectById(empNewOid);
emp1 = (Employee)pm.getObjectById(emp1Oid);
proj1 = (Project)pm.getObjectById(proj1Oid);
deferredAssertTrue(empNew.getProjects().contains(proj1),
ASSERTION_FAILED + testMethod,
"Postcondition is false; "
+ "other side of relationship not set in new pm");
pm.currentTransaction().commit();
failOnError();
}
}
/** */
public void testReplaceFromMappedbySide() {
testMethod = "testReplaceFromMappedbySide";
if (isTestToBePerformed) {
// Set relationship
IProject projNew = new Project(99L, "Skunkworks",
new BigDecimal(10000.35));
pm.makePersistent(projNew);
Set projects = new HashSet();
projects.add(projNew);
emp1.setProjects(projects);
Object projNewOid = pm.getObjectId((Object)projNew);
pm.flush();
// Postcondition
deferredAssertTrue(projNew.getMembers().contains(emp1),
ASSERTION_FAILED + testMethod,
"Postcondition is false; "
+ "other side of relationship not set on flush");
pm.currentTransaction().commit();
cleanupPM();
getPM();
pm.currentTransaction().begin();
emp1 = (Employee)pm.getObjectById(emp1Oid);
projNew = (Project)pm.getObjectById(projNewOid);
proj1 = (Project)pm.getObjectById(proj1Oid);
deferredAssertTrue(projNew.getMembers().contains(emp1),
ASSERTION_FAILED + testMethod,
"Postcondition is false; "
+ "other side of relationship not set in new pm");
pm.currentTransaction().commit();
failOnError();
}
}
/** */
public void testAddNewFromMappedSide() {
testMethod = "testAddNewFromMappedSide";
if (isTestToBePerformed) {
// Set relationship
Employee empNew = new FullTimeEmployee(100, "Jerry", "Valentine",
"Brown", new Date(500L), new Date(10000L), 125000);
pm.makePersistent(empNew);
proj1.addMember(empNew);
Object empNewOid = pm.getObjectId((Object)empNew);
pm.flush();
// Postcondition
deferredAssertTrue(empNew.getProjects().contains(proj1),
ASSERTION_FAILED + testMethod,
"Postcondition is false; "
+ "other side of relationship not set on flush");
pm.currentTransaction().commit();
cleanupPM();
getPM();
pm.currentTransaction().begin();
empNew = (Employee)pm.getObjectById(empNewOid);
emp1 = (Employee)pm.getObjectById(emp1Oid);
proj1 = (Project)pm.getObjectById(proj1Oid);
deferredAssertTrue(empNew.getProjects().contains(proj1),
ASSERTION_FAILED + testMethod,
"Postcondition is false; "
+ "other side of relationship not set in new pm");
pm.currentTransaction().commit();
failOnError();
}
}
/** */
public void testAddNewFromMappedbySide() {
testMethod = "testAddNewFromMappedbySide";
if (isTestToBePerformed) {
// Set relationship
Project projNew = new Project(99L, "Skunkworks",
new BigDecimal(10000.35));
pm.makePersistent(projNew);
emp1.addProject(projNew);
Object projNewOid = pm.getObjectId((Object)projNew);
pm.flush();
// Postcondition
deferredAssertTrue(projNew.getMembers().contains(emp1),
ASSERTION_FAILED + testMethod,
"Postcondition is false; "
+ "other side of relationship not set on flush");
pm.currentTransaction().commit();
cleanupPM();
getPM();
pm.currentTransaction().begin();
emp1 = (Employee)pm.getObjectById(emp1Oid);
projNew = (Project)pm.getObjectById(projNewOid);
proj1 = (Project)pm.getObjectById(proj1Oid);
deferredAssertTrue(projNew.getMembers().contains(emp1),
ASSERTION_FAILED + testMethod,
"Postcondition is false; "
+ "other side of relationship not set in new pm");
pm.currentTransaction().commit();
failOnError();
}
}
/** */
public void testAddExistingFromMappedSide() {
testMethod = "testAddExistingFromMappedSide";
if (isTestToBePerformed) {
// Set relationship
Object emp4Oid = getOidByName("emp4");
Employee emp4 = (Employee)pm.getObjectById(emp4Oid);
proj1.addMember(emp4);
pm.flush();
// Postcondition
deferredAssertTrue(emp4.getProjects().contains(proj1),
ASSERTION_FAILED + testMethod,
"Postcondition is false; "
+ "other side of relationship not set on flush");
pm.currentTransaction().commit();
cleanupPM();
getPM();
pm.currentTransaction().begin();
emp4 = (Employee)pm.getObjectById(emp4Oid);
emp1 = (Employee)pm.getObjectById(emp1Oid);
proj1 = (Project)pm.getObjectById(proj1Oid);
deferredAssertTrue(emp4.getProjects().contains(proj1),
ASSERTION_FAILED + testMethod,
"Postcondition is false; "
+ "other side of relationship not set in new pm");
pm.currentTransaction().commit();
failOnError();
}
}
/** */
public void testAddExistingFromMappedbySide() {
testMethod = "testAddExistingFromMappedbySide";
if (isTestToBePerformed) {
// Set relationship
Object proj2Oid = getOidByName("proj2");
Project proj2 = (Project)pm.getObjectById(proj2Oid);
emp1.addProject(proj2);
pm.flush();
// Postcondition
deferredAssertTrue(proj2.getMembers().contains(emp1),
ASSERTION_FAILED + testMethod,
"Postcondition is false; "
+ "other side of relationship not set on flush");
pm.currentTransaction().commit();
cleanupPM();
getPM();
pm.currentTransaction().begin();
emp1 = (Employee)pm.getObjectById(emp1Oid);
proj2 = (Project)pm.getObjectById(proj2Oid);
proj1 = (Project)pm.getObjectById(proj1Oid);
deferredAssertTrue(proj2.getMembers().contains(emp1),
ASSERTION_FAILED + testMethod,
"Postcondition is false; "
+ "other side of relationship not set in new pm");
pm.currentTransaction().commit();
failOnError();
}
}
/** */
public void testRemoveFromMappedSide() {
testMethod = "testRemoveFromMappedSide";
if (isTestToBePerformed) {
// Set relationship
proj1.removeMember(emp1);
pm.flush();
// Postcondition
deferredAssertTrue(!emp1.getProjects().contains(proj1),
ASSERTION_FAILED + testMethod,
"Postcondition is false; "
+ "other side of relationship not set on flush");
pm.currentTransaction().commit();
cleanupPM();
getPM();
pm.currentTransaction().begin();
emp1 = (Employee)pm.getObjectById(emp1Oid);
proj1 = (Project)pm.getObjectById(proj1Oid);
deferredAssertTrue(
!emp1.getProjects().contains(proj1),
ASSERTION_FAILED + testMethod,
"In new transaction, postcondition is false; " +
"other side of relationship is not set.");
pm.currentTransaction().commit();
failOnError();
}
}
/** */
public void testRemoveFromMappedbySide() {
testMethod = "testRemoveFromMappedbySide";
if (isTestToBePerformed) {
// Set relationship
emp1.removeProject(proj1);
pm.flush();
// Postcondition
deferredAssertTrue(!proj1.getMembers().contains(emp1),
ASSERTION_FAILED + testMethod,
"Postcondition is false; "
+ "other side of relationship not set on flush");
pm.currentTransaction().commit();
cleanupPM();
getPM();
pm.currentTransaction().begin();
emp1 = (Employee)pm.getObjectById(emp1Oid);
proj1 = (Project)pm.getObjectById(proj1Oid);
deferredAssertTrue(
!proj1.getMembers().contains(emp1),
ASSERTION_FAILED + testMethod,
"In new transaction, postcondition is false; " +
"other side of relationship is not set.");
pm.currentTransaction().commit();
failOnError();
}
}
/** */
public void testDeleteFromMappedSide() {
testMethod = "testDeleteFromMappedSide";
if (isTestToBePerformed) {
// remember id
long proj1Id = proj1.getProjid();
// Set relationship
pm.deletePersistent(proj1);
pm.flush();
// Postcondition
deferredAssertTrue(!containsProject(emp1.getProjects(), proj1Id),
ASSERTION_FAILED + testMethod,
"Postcondition is false; "
+ "other side of relationship not set on flush");
pm.currentTransaction().commit();
cleanupPM();
getPM();
pm.currentTransaction().begin();
emp1 = (Employee)pm.getObjectById(emp1Oid);
deferredAssertTrue(
!containsProject(emp1.getProjects(), proj1Id),
ASSERTION_FAILED + testMethod,
"In new transaction, postcondition is false; " +
"other side of relationship is not set.");
pm.currentTransaction().commit();
failOnError();
}
}
/** */
public void testDeleteFromMappedbySide() {
testMethod = "testDeleteFromMappedbySide";
if (isTestToBePerformed) {
// remember id
long emp1Id = emp1.getPersonid();
// Set relationship
pm.deletePersistent(emp1);
pm.flush();
// Postcondition
deferredAssertTrue(!containsEmployee(proj1.getMembers(), emp1Id),
ASSERTION_FAILED + testMethod,
"Postcondition is false; "
+ "other side of relationship not set on flush");
pm.currentTransaction().commit();
cleanupPM();
getPM();
pm.currentTransaction().begin();
proj1 = (Project)pm.getObjectById(proj1Oid);
deferredAssertTrue(
!containsEmployee(proj1.getMembers(), emp1Id),
ASSERTION_FAILED + testMethod,
"In new transaction, postcondition is false; " +
"other side of relationship is not set.");
pm.currentTransaction().commit();
failOnError();
}
}
}
tck/src/java/org/apache/jdo/tck/mapping/RelationshipManyToManyNoRelationships.java 100664 21175 12500110374 30732 0 ustar mbouschen staff 0 0 /*
* 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.mapping;
import java.math.BigDecimal;
import java.util.Date;
import java.util.HashSet;
import java.util.Set;
import org.apache.jdo.tck.pc.company.Employee;
import org.apache.jdo.tck.pc.company.FullTimeEmployee;
import org.apache.jdo.tck.pc.company.Project;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: RelationshipManyToManyNoRelationships
*Keywords: mapping, managed relationships
*Assertion ID: A15.3-14
*Assertion Description: Regardless of which side changes the relationship,
* flush (whether done as part of commit or explicitly by the user) will modify
* the datastore to reflect the change and will update the memory model
* for consistency...
*/
public class RelationshipManyToManyNoRelationships extends AbstractRelationshipTest {
String testMethod = null;
protected String ASSERTION_FAILED =
"Assertion A15-3.14 (RelationshipManyToManyNoRelationships) failed: ";
Object emp1Oid = null;
Object proj1Oid = null;
Employee emp1 = null;
Project proj1 = null;
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(RelationshipManyToManyNoRelationships.class);
}
/**
* @see AbstractRelationshipTest#localSetUp()
*/
protected void localSetUp() {
super.localSetUp();
if (isTestToBePerformed) {
getPM();
pm.currentTransaction().begin();
emp1Oid = getOidByName("emp1");
proj1Oid = getOidByName("proj1");
emp1 = (Employee)pm.getObjectById(emp1Oid);
proj1 = (Project)pm.getObjectById(proj1Oid);
// Preconditions
assertTrue(testMethod +
": Test aborted, precondition is false; " +
"expected emp.getProjects()to be empty",
emp1.getProjects().isEmpty());
assertTrue(testMethod +
": Test aborted, precondition is false; " +
"expected ins.getMembers() to be empty",
proj1.getMembers().isEmpty());
}
}
/** */
public void testAddFromMappedSide() {
testMethod = "testAddFromMappedSide";
if (isTestToBePerformed) {
// Set relationship
Set emps = new HashSet();
emps.add(emp1);
proj1.setMembers(emps);
pm.flush();
// Postcondition
deferredAssertTrue(emp1.getProjects().contains(proj1),
ASSERTION_FAILED + testMethod,
"Postcondition is false; "
+ "other side of relationship not set on flush");
pm.currentTransaction().commit();
cleanupPM();
getPM();
pm.currentTransaction().begin();
emp1 = (Employee)pm.getObjectById(emp1Oid);
proj1 = (Project)pm.getObjectById(proj1Oid);
deferredAssertTrue(
emp1.getProjects().contains(proj1),
ASSERTION_FAILED + testMethod,
"In new transaction, postcondition is false; " +
"other side of relationship is not set.");
pm.currentTransaction().commit();
failOnError();
}
}
/** */
public void testAddFromMappedbySide() {
testMethod = "testAddFromMappedbySide";
if (isTestToBePerformed) {
// Set relationship
Set projs = new HashSet();
projs.add(proj1);
emp1.setProjects(projs);
pm.flush();
// Postcondition
deferredAssertTrue(proj1.getMembers().contains(emp1),
ASSERTION_FAILED + testMethod,
"Postcondition is false; "
+ "other side of relationship not set on flush");
pm.currentTransaction().commit();
cleanupPM();
getPM();
pm.currentTransaction().begin();
emp1 = (Employee)pm.getObjectById(emp1Oid);
proj1 = (Project)pm.getObjectById(proj1Oid);
deferredAssertTrue(
proj1.getMembers().contains(emp1),
ASSERTION_FAILED + testMethod,
"In new transaction, postcondition is false; " +
"other side of relationship is not set.");
pm.currentTransaction().commit();
failOnError();
}
}
/** */
public void testReplaceFromMappedSide() {
testMethod = "testReplaceFromMappedSide";
if (isTestToBePerformed) {
// Set relationship
Set members = new HashSet();
Employee empNew = new FullTimeEmployee(100, "Jerry", "Valentine",
"Brown", new Date(500L), new Date(10000L), 125000);
pm.makePersistent(empNew);
members.add(empNew);
proj1.setMembers(members);
Object empNewOid = pm.getObjectId(empNew);
pm.flush();
assertFalse(testMethod + ": Test aborted, precondition is false; " +
"expected empNewOid to be non-null", empNewOid == null);
// Postcondition
deferredAssertTrue(empNew.getProjects().contains(proj1),
ASSERTION_FAILED + testMethod,
"Postcondition is false; "
+ "other side of relationship not set on flush");
pm.currentTransaction().commit();
cleanupPM();
getPM();
pm.currentTransaction().begin();
empNew = (Employee)pm.getObjectById(empNewOid);
emp1 = (Employee)pm.getObjectById(emp1Oid);
proj1 = (Project)pm.getObjectById(proj1Oid);
deferredAssertTrue(empNew.getProjects().contains(proj1),
ASSERTION_FAILED + testMethod,
"Postcondition is false; "
+ "other side of relationship not set in new pm");
pm.currentTransaction().commit();
failOnError();
}
}
/** */
public void testReplaceFromMappedbySide() {
testMethod = "testReplaceFromMappedbySide";
if (isTestToBePerformed) {
// Set relationship
Set projects = new HashSet();
Project projNew = new Project(99L, "Skunkworks",
new BigDecimal(10000.35));
pm.makePersistent(projNew);
projects.add(projNew);
emp1.setProjects(projects);
Object projNewOid = pm.getObjectId((Object)projNew);
pm.flush();
assertFalse(testMethod + ": Test aborted, precondition is false; " +
"expected projNewOid to be non-null", projNewOid == null);
// Postcondition
deferredAssertTrue(projNew.getMembers().contains(emp1),
ASSERTION_FAILED + testMethod,
"Postcondition is false; "
+ "other side of relationship not set on flush");
pm.currentTransaction().commit();
cleanupPM();
getPM();
pm.currentTransaction().begin();
emp1 = (Employee)pm.getObjectById(emp1Oid);
projNew = (Project)pm.getObjectById(projNewOid);
proj1 = (Project)pm.getObjectById(proj1Oid);
deferredAssertTrue(projNew.getMembers().contains(emp1),
ASSERTION_FAILED + testMethod,
"Postcondition is false; "
+ "other side of relationship not set in new pm");
pm.currentTransaction().commit();
failOnError();
}
}
}
tck/src/java/org/apache/jdo/tck/mapping/RelationshipNegative1To1Test.java 100664 12374 12500110374 26704 0 ustar mbouschen staff 0 0 /*
* 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.mapping;
import java.util.Date;
import javax.jdo.JDOUserException;
import org.apache.jdo.tck.pc.company.FullTimeEmployee;
import org.apache.jdo.tck.pc.company.IEmployee;
import org.apache.jdo.tck.pc.company.IMedicalInsurance;
import org.apache.jdo.tck.pc.company.MedicalInsurance;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: RelationshipNegative1To1Test
*Keywords: mapping, managed relationships
*Assertion ID: A15.3-14
*Assertion Description: Regardless of which side changes the relationship,
* flush (whether done as part of commit or explicitly by the user) will modify
* the datastore to reflect the change and will update the memory model
* for consistency...
*/
public class RelationshipNegative1To1Test extends AbstractRelationshipTest {
String testMethod = null;
protected String ASSERTION_FAILED =
"Assertion A15-3.14 (RelationshipNegative1To1Test) failed: ";
Object emp1Oid = null;
Object emp2Oid = null;
Object medIns1Oid = null;
Object medIns2Oid = null;
IEmployee emp1 = null;
IEmployee emp2 = null;
IMedicalInsurance medIns1 = null;
IMedicalInsurance medIns2 = null;
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(RelationshipNegative1To1Test.class);
}
/**
* @see AbstractRelationshipTest#localSetUp()
*/
protected void localSetUp() {
super.localSetUp();
if (isTestToBePerformed) {
getPM();
pm.currentTransaction().begin();
emp1Oid = getOidByName("emp1");
emp2Oid = getOidByName("emp2");
medIns1Oid = getOidByName("medicalIns1");
medIns2Oid = getOidByName("medicalIns2");
emp1 = (IEmployee)pm.getObjectById(emp1Oid);
emp2 = (IEmployee)pm.getObjectById(emp2Oid);
medIns1 = (IMedicalInsurance)pm.getObjectById(medIns1Oid);
medIns2 = (IMedicalInsurance)pm.getObjectById(medIns2Oid);
}
}
/**
* Test that JdoUserException is thrown if two sides of a relationship
* do not refer to each other.
*/
public void testA2BbutNotB2AMapped() {
testMethod = "testA2BbutNotB2AMapped";
if (isTestToBePerformed) {
IEmployee empNew = new FullTimeEmployee(99, "Matthew", "", "Adams",
new Date(0L), new Date(10000L), 125000);
pm.makePersistent(empNew);
emp1.setMedicalInsurance(medIns2);
medIns2.setEmployee(empNew);
doFlush(testMethod);
}
}
/**
* Test that JdoUserException is thrown if two sides of a relationship
* do not refer to each other.
*/
public void testA2BbutNotB2AMappedBy() {
testMethod = "testA2BbutNotB2AMappedBy";
if (isTestToBePerformed) {
IMedicalInsurance medInsNew = new MedicalInsurance(99,
"The American Company", "B");
pm.makePersistent(medInsNew);
medIns2.setEmployee(emp1);
emp1.setMedicalInsurance(medInsNew);
doFlush(testMethod);
}
}
/**
* Test that JdoUserException is thrown setting mapped side
* of a one-to-one relationship and setting the other side to null
*/
public void testSetOtherSideToNullMapped() {
testMethod = "testSetOtherSideToNullMapped";
if (isTestToBePerformed) {
emp1.setMedicalInsurance(medIns2);
medIns2.setEmployee(null);
doFlush(testMethod);
}
}
/**
* Test that JdoUserException is thrown setting mapped by side
* of a one-to-one relationship and setting the other side to null
*/
public void testSetOtherSideToNullMappedBy() {
testMethod = "testSetOtherSideToNullMappedBy";
if (isTestToBePerformed) {
medIns2.setEmployee(emp1);
emp1.setMedicalInsurance(null);
doFlush(testMethod);
}
}
protected void doFlush(String method) {
try {
pm.flush();
fail(ASSERTION_FAILED + testMethod
+ ": expected JDOUserException on flush!");
} catch (JDOUserException jdoe) {
// expected exception
}
pm.currentTransaction().rollback();
}
}
tck/src/java/org/apache/jdo/tck/mapping/RelationshipNegative1ToManyTest.java 100664 11055 12500110374 27443 0 ustar mbouschen staff 0 0 /*
* 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.mapping;
import java.util.Date;
import javax.jdo.JDOUserException;
import org.apache.jdo.tck.pc.company.Department;
import org.apache.jdo.tck.pc.company.Employee;
import org.apache.jdo.tck.pc.company.FullTimeEmployee;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: RelationshipNegative1ToManyTest
*Keywords: mapping, managed relationships
*Assertion ID: A15.3-14
*Assertion Description: Regardless of which side changes the relationship,
* flush (whether done as part of commit or explicitly by the user) will modify
* the datastore to reflect the change and will update the memory model
* for consistency...
*/
public class RelationshipNegative1ToManyTest extends AbstractRelationshipTest {
String testMethod = null;
protected String ASSERTION_FAILED =
"Assertion A15-3.14 (RelationshipNegative1ToManyTest) failed: ";
Object emp1Oid = null;
Object dept1Oid = null;
Object dept2Oid = null;
Employee emp1 = null;
Department dept1 = null;
Department dept2 = null;
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(RelationshipNegative1ToManyTest.class);
}
/**
* @see AbstractRelationshipTest#localSetUp()
*/
protected void localSetUp() {
super.localSetUp();
if (isTestToBePerformed) {
getPM();
pm.currentTransaction().begin();
emp1Oid = getOidByName("emp1");
dept1Oid = getOidByName("dept1");
dept2Oid = getOidByName("dept2");
emp1 = (Employee)pm.getObjectById(emp1Oid);
dept1 = (Department)pm.getObjectById(dept1Oid);
dept2 = (Department)pm.getObjectById(dept2Oid);
}
}
/**
* Test that JdoUserException is thrown setting one side
* of a one-to-many relationship and deleting the other side
*/
public void testDeleteOtherSide() {
testMethod = "testDeleteOtherSide";
if (isTestToBePerformed) {
dept2.addEmployee(emp1);
pm.deletePersistent(emp1);
doFlush(testMethod);
}
}
/**
* adding a related instance (with a single-valued mapped-by relationship
* field) to more than one one-to-many collection relationship
*/
public void testAddToMoreThanOne() {
testMethod = "testAddToMoreThanOne";
if (isTestToBePerformed) {
Employee empNew = new FullTimeEmployee(99, "Matthew", "", "Adams",
new Date(0L), new Date(10000L), 125000);
pm.makePersistent(empNew);
dept1.addEmployee(empNew);
dept2.addEmployee(empNew);
doFlush(testMethod);
}
}
/**
* adding a related instance to a collection and setting the other side
* to a different instance
*/
public void testAInBbutNotB2A() {
testMethod = "testAInBbutNotB2A";
if (isTestToBePerformed) {
Employee empNew = new FullTimeEmployee(99, "Matthew", "", "Adams",
new Date(0L), new Date(10000L), 125000);
pm.makePersistent(empNew);
dept1.addEmployee(empNew);
empNew.setDepartment(dept2);
doFlush(testMethod);
}
}
protected void doFlush(String method) {
try {
pm.flush();
fail(ASSERTION_FAILED + testMethod
+ ": expected JDOUserException on flush!");
} catch (JDOUserException jdoe) {
// expected exception
}
pm.currentTransaction().rollback();
}
}
tck/src/java/org/apache/jdo/tck/models/embedded/EmbeddedInheritance.java 100664 20237 12500110373 26473 0 ustar mbouschen staff 0 0 /*
* 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.models.embedded;
import java.util.List;
import javax.jdo.Query;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.building.Kitchen;
import org.apache.jdo.tck.pc.building.MultifunctionOven;
import org.apache.jdo.tck.pc.building.Oven;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
* Title: Test EmbeddedInheritance
* Keywords:
* Assertion IDs:
* Assertion Description:
*/
public class EmbeddedInheritance extends JDO_Test {
/** */
protected void localSetUp() {
addTearDownClass(Kitchen.class);
}
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(EmbeddedInheritance.class);
}
/**
* Test for basic persistence of object with embedded object which has inheritance
* and persisting the base type of the embedded object.
*/
public void testPersistBase() {
Object id = null;
try {
getPM().currentTransaction().begin();
Kitchen kitchen1 = new Kitchen(1);
Oven oven = new Oven("Westinghouse", "Economy");
kitchen1.setOven(oven);
getPM().makePersistent(kitchen1);
getPM().currentTransaction().commit();
id = getPM().getObjectId(kitchen1);
}
catch (Exception e) {
fail("Exception on persist : " + e.getMessage());
}
finally {
if (getPM().currentTransaction().isActive()) {
getPM().currentTransaction().rollback();
}
}
getPM().currentTransaction().begin();
Kitchen kitchen = (Kitchen)getPM().getObjectById(id);
assertEquals("Id of object is incorrect", 1, kitchen.getId());
Oven oven = kitchen.getOven();
assertNotNull("Oven of Kitchen is null!", oven);
assertEquals("Oven is of incorrect type", Oven.class.getName(), oven.getClass().getName());
assertEquals("Oven make is incorrect", "Westinghouse", oven.getMake());
assertEquals("Oven model is incorrect", "Economy", oven.getModel());
getPM().currentTransaction().commit();
}
/**
* Test for basic persistence of object with embedded object which has inheritance
* and persisting the subclass type of the embedded object.
*/
public void testPersistSubclass() {
Object id = null;
try {
getPM().currentTransaction().begin();
Kitchen kitchen = new Kitchen(1);
MultifunctionOven oven = new MultifunctionOven("Westinghouse", "Economy");
oven.setMicrowave(true);
oven.setCapabilities("TIMER,CLOCK");
kitchen.setOven(oven);
getPM().makePersistent(kitchen);
getPM().currentTransaction().commit();
id = getPM().getObjectId(kitchen);
}
catch (Exception e) {
fail("Exception on persist : " + e.getMessage());
}
finally {
if (getPM().currentTransaction().isActive()) {
getPM().currentTransaction().rollback();
}
}
getPM().currentTransaction().begin();
Kitchen kitchen = (Kitchen)getPM().getObjectById(id);
assertEquals("Id of object is incorrect", 1, kitchen.getId());
Oven oven = kitchen.getOven();
assertNotNull("Oven of Kitchen is null!", oven);
assertEquals("Oven is of incorrect type", MultifunctionOven.class.getName(),
oven.getClass().getName());
MultifunctionOven multioven = (MultifunctionOven)oven;
assertEquals("Oven make is incorrect", "Westinghouse", multioven.getMake());
assertEquals("Oven model is incorrect", "Economy", multioven.getModel());
assertEquals("Oven microwave setting is incorrect", true, multioven.getMicrowave());
assertEquals("Oven capabilities is incorrect", "TIMER,CLOCK", multioven.getCapabilities());
getPM().currentTransaction().commit();
}
/**
* Test for querying of fields of base type of an embedded object.
*/
@SuppressWarnings("unchecked")
public void testQueryBase() {
Object id = null;
try {
getPM().currentTransaction().begin();
Kitchen kitchen = new Kitchen(1);
MultifunctionOven oven = new MultifunctionOven("Westinghouse", "Economy");
oven.setMicrowave(true);
oven.setCapabilities("TIMER,CLOCK");
kitchen.setOven(oven);
getPM().makePersistent(kitchen);
getPM().currentTransaction().commit();
id = getPM().getObjectId(kitchen);
}
catch (Exception e) {
fail("Exception on persist : " + e.getMessage());
}
finally {
if (getPM().currentTransaction().isActive()) {
getPM().currentTransaction().rollback();
}
}
getPM().currentTransaction().begin();
Query q = getPM().newQuery("SELECT FROM " + Kitchen.class.getName() +
" WHERE this.oven.make == 'Westinghouse'");
List kitchens = (List)q.execute();
assertNotNull("No results from query!", kitchens);
assertEquals("Number of query results was incorrect", 1, kitchens.size());
Kitchen kit = kitchens.iterator().next();
assertEquals("Kitchen result is incorrect", id, getPM().getObjectId(kit));
getPM().currentTransaction().commit();
}
/**
* Test for querying of fields of subclass type of an embedded object.
*/
@SuppressWarnings("unchecked")
public void testQuerySubclass() {
Object id = null;
try {
getPM().currentTransaction().begin();
Kitchen kitchen = new Kitchen(1);
MultifunctionOven oven = new MultifunctionOven("Westinghouse", "Economy");
oven.setMicrowave(true);
oven.setCapabilities("TIMER,CLOCK");
kitchen.setOven(oven);
getPM().makePersistent(kitchen);
getPM().currentTransaction().commit();
id = getPM().getObjectId(kitchen);
}
catch (Exception e) {
fail("Exception on persist : " + e.getMessage());
}
finally {
if (getPM().currentTransaction().isActive()) {
getPM().currentTransaction().rollback();
}
}
getPM().currentTransaction().begin();
Query q1 = getPM().newQuery("SELECT FROM " + Kitchen.class.getName() +
" WHERE this.oven instanceof org.apache.jdo.tck.pc.building.MultifunctionOven");
List kitchens1 = (List)q1.execute();
assertNotNull("No results from query!", kitchens1);
assertEquals("Number of query results was incorrect", 1, kitchens1.size());
// Query using cast and a field of the subclass embedded class
Query q2 = getPM().newQuery("SELECT FROM " + Kitchen.class.getName() +
" WHERE ((org.apache.jdo.tck.pc.building.MultifunctionOven)this.oven).capabilities == 'TIMER,CLOCK'");
List kitchens2 = (List)q2.execute();
assertNotNull("No results from query!", kitchens2);
assertEquals("Number of query results was incorrect", 1, kitchens2.size());
Kitchen kit = kitchens2.iterator().next();
assertEquals("Kitchen result is incorrect", id, getPM().getObjectId(kit));
getPM().currentTransaction().commit();
}
}
tck/src/java/org/apache/jdo/tck/models/embedded/SecondClassObjectsTrackTheirChanges.java 100664 13562 12500110373 31620 0 ustar mbouschen staff 0 0 /*
* 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.models.embedded;
import java.util.Date;
import java.util.Set;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.company.Address;
import org.apache.jdo.tck.pc.company.Company;
import org.apache.jdo.tck.pc.company.Department;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: SecondClassObjectsTrackTheirChanges
*Keywords: embedded lifecycle
*Assertion ID: A14.6.9-9
*Assertion Description:
If an SCO field is in the result, the projected field is not owned by any persistent instance, and modifying the SCO value has no effect on any persistent instance. If an FCO field is in the result, the projected field is a persistent instance, and modifications made to the instance are are reflected as changes to the datastore per transaction requirements.
*/
public class SecondClassObjectsTrackTheirChanges extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A14.6.9-9 (SecondClassObjectsTrackTheirChanges) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(SecondClassObjectsTrackTheirChanges.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
addTearDownClass(Company.class);
}
/** This tests that persistence-capable instances track changes
* or notify their owning instance that they are dirty */
public void testPCInstance() {
pm = getPM();
pm.currentTransaction().begin();
Company comp = getPersistentNewInstance(0);
pm.currentTransaction().commit(); // obj should transition to hollow
testHollowInstance(comp);
pm.currentTransaction().begin();
makePersistentCleanInstance(comp);
Address addr = (Address)comp.getAddress();
// comp or addr should transition to persistent-dirty
addr.setStreet("200 Orange Street");
int currComp = currentState(comp);
int currAddr = currentState(addr);
if ((currComp != PERSISTENT_DIRTY) && (currAddr != PERSISTENT_DIRTY)){
fail(ASSERTION_FAILED,
"Unable to create persistent-dirty instance " +
"from persistent-clean instance via changing Address instance, "
+ "state of Company instance is " + states[currComp]
+ " and state of Address instance is " + states[currAddr]);
}
}
/** This tests that mutable system class instances track changes
* or notify their owning instance that they are dirty */
public void testMutableSystemClass() {
pm = getPM();
pm.currentTransaction().begin();
Company comp = getPersistentNewInstance(1);
pm.currentTransaction().commit(); // obj should transition to hollow
testHollowInstance(comp);
pm.currentTransaction().begin();
makePersistentCleanInstance(comp);
Set depts = comp.getDepartments();
// comp or depts should transition to persistent-dirty
comp.addDepartment(new Department(0, "HR", comp));
int currComp = currentState(comp);
int currDepts = currentState(depts);
if ((currComp != PERSISTENT_DIRTY) && (currDepts != PERSISTENT_DIRTY)){
fail(ASSERTION_FAILED,
"Unable to create persistent-dirty instance "
+ "from persistent-clean instance via changing Departments "
+ "instance, state of Company instance is "
+ states[currComp] + " and state of Departments instance is "
+ states[currDepts]);
}
}
public Company getPersistentNewInstance(long companyid) {
Company obj = new Company(companyid, "MyCompany", new Date(),
new Address(0,"","","","",""));
pm.makePersistent(obj); // obj should transition to persistent-new
int curr = currentState(obj);
if( curr != PERSISTENT_NEW ){
fail(ASSERTION_FAILED,
"Unable to create persistent-new instance "
+ "from transient instance via makePersistent(), state is "
+ states[curr]);
}
return obj;
}
public void testHollowInstance(Company obj) {
int curr = currentState(obj);
if( curr != HOLLOW ){
fail(ASSERTION_FAILED,
"Unable to create hollow instance "
+ "from persistent-new instance via commit(), state is "
+ states[curr]);
}
}
public void makePersistentCleanInstance(Company obj) {
pm.makeTransactional(obj); // obj should transition to persistent-clean
int curr = currentState(obj);
if( curr != PERSISTENT_CLEAN ){
fail(ASSERTION_FAILED,
"Unable to create persistent-clean instance "
+ "from hollow instance via makeTransactional(obj), state is "
+ states[curr]);
}
}
}
tck/src/java/org/apache/jdo/tck/models/fieldtypes/TestArrayCollections.java 100664 15263 12500110373 27367 0 ustar mbouschen staff 0 0 /*
* 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.models.fieldtypes;
import java.lang.reflect.Array;
import java.math.BigDecimal;
import java.util.Arrays;
import java.util.Collection;
import java.util.Vector;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.fieldtypes.ArrayCollections;
import org.apache.jdo.tck.pc.fieldtypes.SimpleClass;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Support of field type array.
*Keywords: model
*Assertion ID: A6.4.3-39.
*Assertion Description:
JDO implementations may optionally support fields of array types.
*/
public class TestArrayCollections extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion (TestArrayCollections) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(TestArrayCollections.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
addTearDownClass(ArrayCollections.class);
addTearDownClass(SimpleClass.class);
}
/** */
public void test() {
pm = getPM();
runTest(pm);
pm.close();
pm = null;
}
/** */
void runTest(PersistenceManager pm)
{
if (!isArraySupported()) {
if (debug)
logger.debug("JDO Implementation does not support" +
"optional feature Array");
return;
}
Transaction tx = pm.currentTransaction();
ArrayCollections expectedValue = new ArrayCollections();
// turn on datastore transactions
tx.setOptimistic(false);
tx.begin();
ArrayCollections pi = new ArrayCollections();
pi.identifier = 1;
pm.makePersistent(pi);
Object oid = pm.getObjectId(pi);
// Provide initial set of values
setValues(pi, 1);
tx.commit();
// cache will be flushed
pi = null;
System.gc();
tx.begin();
setValues(expectedValue, 1);
// check if persistent fields have values set
checkValues(oid, expectedValue);
pi = (ArrayCollections) pm.getObjectById(oid, true);
// Provide new set of values
setValues(pi, 2);
tx.commit();
// cache will be flushed
pi = null;
System.gc();
tx.begin();
// check new values
setValues(expectedValue, 2);
checkValues(oid, expectedValue);
tx.commit();
}
/** */
private void setValues(ArrayCollections collect, int order)
{
Vector value;
Class vectorClass = null;
int n = collect.getLength();
for (int i = 0; i < n; ++i) {
String valueType = TestUtil.getFieldSpecs(
ArrayCollections.fieldSpecs[i]);
value = TestUtil.makeNewVectorInstance(valueType, order);
try {
// get the right class to instantiate
vectorClass = value.get(0).getClass();
} catch (Exception e) {
}
Object[] valueArray = (Object[])Array.newInstance(vectorClass,
value.size());
value.toArray(valueArray);
collect.set(i, valueArray);
if (debug)
logger.debug("Set " + i + "th value to: "
+ valueArray.toString());
}
}
/** */
private void checkValues(Object oid, ArrayCollections expectedValue)
{
StringBuffer sbuf = new StringBuffer();
ArrayCollections pi = (ArrayCollections) pm.getObjectById(oid, true);
int n = pi.getLength();
for (int i = 0; i < n; ++i) {
Object obj = new Object();
Class objClass = obj.getClass();
Object[] expected = (Object[])Array.newInstance(objClass, 5);
Object[] actual = (Object[])Array.newInstance(objClass, 5);
expected = expectedValue.get(i);
actual = pi.get(i);
if (actual == null) {
sbuf.append("\nFor " + ArrayCollections.fieldSpecs[i]
+ ", retrieved field is null.");
continue;
}
if (expected.length != actual.length) {
sbuf.append("\nFor element " + i + ", expected size = " +
expected.length + ", actual size = " + actual.length
+ " . ");
continue;
}
else if (!Arrays.equals(expected, actual)) {
if (TestUtil.getFieldSpecs(ArrayCollections.fieldSpecs[i]
).equals("BigDecimal")) {
for (int j = 0; j < actual.length; ++j) {
BigDecimal expectedBD = (BigDecimal)expected[j];
BigDecimal actualBD = (BigDecimal)actual[j];
if ((expectedBD.compareTo(actualBD) != 0)) {
sbuf.append("\nFor element " + i + "[" + j +
"], expected = " + expectedBD +
", actual = " + actualBD + " . ");
}
}
}
else {
sbuf.append("\nFor element " + i + ", expected = " +
expected + ", actual = " + actual + " . ");
}
}
}
if (sbuf.length() > 0) {
fail(ASSERTION_FAILED,
"Expected and observed do not match!!" + sbuf.toString());
}
}
}
tck/src/java/org/apache/jdo/tck/models/fieldtypes/TestArrayListCollections.java 100664 15216 12500110373 30221 0 ustar mbouschen staff 0 0 /*
* 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.models.fieldtypes;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
import java.util.Collection;
import java.util.Vector;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.fieldtypes.ArrayListCollections;
import org.apache.jdo.tck.pc.fieldtypes.SimpleClass;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Support of field type ArrayList.
*Keywords: model
*Assertion ID: A6.4.3-23.
*Assertion Description:
If the ArrayList optional feature is supported, then JDO implementation must
support fields of the mutable object class ArrayList,
supporting them as Second Class Objects or First Class Objects.
*/
public class TestArrayListCollections extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A6.4.3-23 (TestArrayListCollections) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(TestArrayListCollections.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
addTearDownClass(ArrayListCollections.class);
addTearDownClass(SimpleClass.class);
}
/** */
public void test() {
pm = getPM();
runTest(pm);
pm.close();
pm = null;
}
/** */
void runTest(PersistenceManager pm)
{
if (!isArrayListSupported()) {
if (debug)
logger.debug("JDO Implementation does not support optional " +
"feature ArrayList");
return;
}
Transaction tx = pm.currentTransaction();
ArrayListCollections expectedValue = new ArrayListCollections();
// turn on datastore transactions
tx.setOptimistic(false);
tx.begin();
ArrayListCollections pi = new ArrayListCollections();
pi.identifier = 1;
pm.makePersistent(pi);
Object oid = pm.getObjectId(pi);
// Provide initial set of values
setValues(pi, 1);
tx.commit();
// cache will be flushed
pi = null;
System.gc();
tx.begin();
setValues(expectedValue, 1);
checkValues(oid, expectedValue);
pi = (ArrayListCollections) pm.getObjectById(oid, true);
// Provide new set of values
setValues(pi, 2);
tx.commit();
// cache will be flushed
pi = null;
System.gc();
tx.begin();
// check new values
setValues(expectedValue, 2);
checkValues(oid, expectedValue);
tx.commit();
}
/** */
private void setValues(ArrayListCollections collect, int order)
{
Collection value;
int n = collect.getLength();
for (int i = 0; i < n; ++i) {
String valueType = TestUtil.getFieldSpecs(
ArrayListCollections.fieldSpecs[i]);
value = (Collection)TestUtil.makeNewVectorInstance(
valueType, order);
ArrayList arrayListValue = new ArrayList(value);
collect.set(i, arrayListValue);
if (debug)
logger.debug("Set " + i + "th value to: " + value.toString());
}
}
/** */
private void checkValues(Object oid, ArrayListCollections expectedValue)
{
int i;
StringBuffer sbuf = new StringBuffer();
ArrayListCollections pi = (ArrayListCollections)
pm.getObjectById(oid, true);
int n = pi.getLength();
for (i = 0; i < n; ++i) {
Collection expected = expectedValue.get(i);
Collection actual = pi.get(i);
if (actual == null) {
sbuf.append("\nFor element " + i
+ ", retrieved instance is null");
continue;
}
if (actual.size() != expected.size()) {
sbuf.append("\nFor element " + i + ", expected size = " +
expected.size() + ", actual size = " + actual.size()
+ " . ");
continue;
}
else if (! expected.equals(actual)) {
if (TestUtil.getFieldSpecs(ArrayListCollections.fieldSpecs[i]
).equals("BigDecimal")) {
if (debug) {
logger.debug("Field is " + i + " Class name is "
+ actual.getClass().getName()
+ " isInstance of Vector is "
+ actual.getClass().isInstance((Object)new Vector()));
}
List expectedL = (List)expected;
List actualL = (List)actual;
for (int j = 0; j < actualL.size(); ++j) {
BigDecimal bigDecCompareWith =
(BigDecimal)expectedL.get(j);
BigDecimal bigDecVal = (BigDecimal)actualL.get(j);
if ((bigDecCompareWith.compareTo(bigDecVal) != 0)) {
sbuf.append("\nFor element " + i + "(" + j +
"), expected = " + expected +
", actual = " + actualL + " . ");
}
}
}
else {
sbuf.append("\nFor element " + i + ", expected = " +
expected + ", actual = " + actual + " . ");
}
}
}
if (sbuf.length() > 0) {
fail(ASSERTION_FAILED,
"Expected and observed do not match!!" + sbuf.toString());
}
}
}
tck/src/java/org/apache/jdo/tck/models/fieldtypes/TestCollectionCollections.java 100664 14222 12500110373 30376 0 ustar mbouschen staff 0 0 /*
* 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.models.fieldtypes;
import java.math.BigDecimal;
import java.util.Collection;
import java.util.List;
import java.util.Vector;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.fieldtypes.CollectionCollections;
import org.apache.jdo.tck.pc.fieldtypes.SimpleClass;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Support of field type Collection.
*Keywords: model
*Assertion ID: A6.4.3-33.
*Assertion Description:
JDO implementations must support fields of the interface type
java.util.Collection, and may choose to support them
as Second Class Objects or First Class Objects.
*/
public class TestCollectionCollections extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A6.4.3-33 (TestCollectionCollections) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(TestCollectionCollections.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
addTearDownClass(CollectionCollections.class);
addTearDownClass(SimpleClass.class);
}
/** */
public void test() {
pm = getPM();
runTest(pm);
pm.close();
pm = null;
}
/** */
void runTest(PersistenceManager pm)
{
Transaction tx = pm.currentTransaction();
CollectionCollections expectedValue = new CollectionCollections();
// turn on datastore transactions
tx.setOptimistic(false);
tx.begin();
CollectionCollections pi = new CollectionCollections();
pi.identifier = 1;
pm.makePersistent(pi);
Object oid = pm.getObjectId(pi);
// Provide initial set of values
setValues(pi, 1);
tx.commit();
// cache will be flushed
pi = null;
System.gc();
tx.begin();
setValues(expectedValue, 1);
// check if persistent fields have values set
checkValues(oid, expectedValue);
pi = (CollectionCollections) pm.getObjectById(oid, true);
// Provide new set of values
setValues(pi, 2);
tx.commit();
// cache will be flushed
pi = null;
System.gc();
tx.begin();
// check new values
setValues(expectedValue, 2);
checkValues(oid, expectedValue);
tx.commit();
}
/** */
private void setValues(CollectionCollections colcol, int order)
{
Vector value;
int n = colcol.getLength();
for (int i = 0; i < n; ++i) {
String valueType = TestUtil.getFieldSpecs(
CollectionCollections.fieldSpecs[i]);
value = TestUtil.makeNewVectorInstance(valueType, order);
colcol.set(i, value);
if (debug)
logger.debug("Set " + i + "th value to: " + value.toString());
}
}
/** */
private void checkValues(Object oid, CollectionCollections expectedValue)
{
StringBuffer sbuf = new StringBuffer();
CollectionCollections pi = (CollectionCollections)
pm.getObjectById(oid, true);
int n = pi.getLength();
for (int i = 0; i < n; ++i) {
Collection expected = expectedValue.get(i);
Collection actual = pi.get(i);
if (actual.size() != expected.size()) {
sbuf.append("\nFor element " + i + ", expected size = " +
expected.size() + ", actual size = " + actual.size()
+ " . ");
}
else if (! expected.equals(actual)) {
if (TestUtil.getFieldSpecs(CollectionCollections.fieldSpecs[i]
).equals("BigDecimal")) {
if (debug) {
logger.debug("Field is " + i + " Class name is "
+ actual.getClass().getName()
+ " isInstance of Vector is "
+ actual.getClass().isInstance((Object)new Vector()));
}
List expectedL = (List)expected;
List actualL = (List)actual;
for (int j = 0; j < actualL.size(); ++j) {
BigDecimal bigDecCompareWith =
(BigDecimal)expectedL.get(j);
BigDecimal bigDecVal = (BigDecimal)actualL.get(j);
if ((bigDecCompareWith.compareTo(bigDecVal) != 0)) {
sbuf.append("\nFor element " + i + "(" + j +
"), expected = " + expected +
", actual = " + actualL + " . ");
}
}
}
else {
sbuf.append("\nFor element " + i + ", expected = " +
expected + ", actual = " + actual + " . ");
}
}
}
if (sbuf.length() > 0) {
fail(ASSERTION_FAILED,
"Expected and observed do not match!!" + sbuf.toString());
}
}
}
tck/src/java/org/apache/jdo/tck/models/fieldtypes/TestFieldsOfBigDecimal.java 100664 7706 12500110373 27471 0 ustar mbouschen staff 0 0 /*
* 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.models.fieldtypes;
import java.math.BigDecimal;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.fieldtypes.FieldsOfBigDecimal;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Support of field type BigDecimal.
*Keywords: model
*Assertion ID: A6.4.3-19.
*Assertion Description:
JDO implementations must support fields of the immutable object class
java.math.BigDecimal, and may choose to support them as
Second Class Objects or First Class Objects.
*/
public class TestFieldsOfBigDecimal extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A6.4.3-19 (TestFieldsOfBigDecimal) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(TestFieldsOfBigDecimal.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
addTearDownClass(FieldsOfBigDecimal.class);
}
/** */
public void test() {
pm = getPM();
runTest(pm);
pm.close();
pm = null;
}
/** */
void runTest(PersistenceManager pm)
{
Transaction tx = pm.currentTransaction();
int i, n;
BigDecimal firstValue = new BigDecimal("20079.0237");
BigDecimal secondValue = new BigDecimal("8907489.658");
tx.begin();
FieldsOfBigDecimal pi = new FieldsOfBigDecimal();
pi.identifier = 1;
pm.makePersistent(pi);
Object oid = pm.getObjectId(pi);
n = pi.getLength();
// Provide initial set of values
for( i = 0; i < n; ++i){
pi.set( i, firstValue);
}
tx.commit();
// cache will be flushed
pi = null;
System.gc();
tx.begin();
pi = (FieldsOfBigDecimal) pm.getObjectById(oid, true);
checkValues(oid, firstValue);
// Provide new set of values
for( i = 0; i < n; ++i){
pi.set(i, secondValue);
}
tx.commit();
// cache will be flushed
pi = null;
System.gc();
tx.begin();
// check new values
checkValues(oid, secondValue);
tx.commit();
}
/** */
private void checkValues(Object oid, BigDecimal startValue){
int i;
BigDecimal value;
FieldsOfBigDecimal pi = (FieldsOfBigDecimal) pm.getObjectById(oid, true);
int n = pi.getLength();
for( i = 0, value = startValue; i < n; ++i){
if( !FieldsOfBigDecimal.isPersistent[i] ) continue;
BigDecimal val = pi.get(i);
if(val.compareTo(value) != 0){
fail(ASSERTION_FAILED,
"Incorrect value for " + FieldsOfBigDecimal.fieldSpecs[i] +
", expected value " + value.toString() +
", value is " + val.toString());
}
}
}
}
tck/src/java/org/apache/jdo/tck/models/fieldtypes/TestFieldsOfBigInteger.java 100664 7737 12500110373 27534 0 ustar mbouschen staff 0 0 /*
* 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.models.fieldtypes;
import java.math.BigInteger;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.fieldtypes.FieldsOfBigInteger;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Support of field type BigInteger.
*Keywords: model
*Assertion ID: A6.4.3-20.
*Assertion Description:
JDO implementations must support fields of the immutable object class
java.math.BigInteger, and may choose to support them as
Second Class Objects or First Class Objects.
*/
public class TestFieldsOfBigInteger extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A6.4.3-20 (TestFieldsOfBigInteger) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(TestFieldsOfBigInteger.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
addTearDownClass(FieldsOfBigInteger.class);
}
/** */
public void test() {
pm = getPM();
runTest(pm);
pm.close();
pm = null;
}
/** */
void runTest(PersistenceManager pm)
{
Transaction tx = pm.currentTransaction();
int i, n;
BigInteger firstValue = new BigInteger("3958262948201938571947294821");
BigInteger secondValue = new BigInteger("896738");
tx.begin();
FieldsOfBigInteger pi = new FieldsOfBigInteger();
pi.identifier = 1;
pm.makePersistent(pi);
Object oid = pm.getObjectId(pi);
n = pi.getLength();
// Provide initial set of values
for( i = 0; i < n; ++i){
pi.set( i, firstValue);
}
tx.commit();
// cache will be flushed
pi = null;
System.gc();
tx.begin();
pi = (FieldsOfBigInteger) pm.getObjectById(oid, true);
checkValues(oid, firstValue);
// Provide new set of values
for( i = 0; i < n; ++i){
pi.set(i, secondValue);
}
tx.commit();
// cache will be flushed
pi = null;
System.gc();
tx.begin();
// check new values
checkValues(oid, secondValue);
tx.commit();
}
/** */
private void checkValues(Object oid, BigInteger startValue){
int i;
BigInteger value = startValue;
FieldsOfBigInteger pi = (FieldsOfBigInteger) pm.getObjectById(oid, true);
int n = pi.getLength();
for( i = 0; i < n; ++i){
if( !FieldsOfBigInteger.isPersistent[i] )
continue;
BigInteger val = pi.get(i);
if(!val.equals(value) ){
fail(ASSERTION_FAILED,
"Incorrect value for " + FieldsOfBigInteger.fieldSpecs[i] +
", expected value " + value.toString() +
", value is " + val.toString());
}
}
}
}
tck/src/java/org/apache/jdo/tck/models/fieldtypes/TestFieldsOfBoolean.java 100664 7507 12500110373 27067 0 ustar mbouschen staff 0 0 /*
* 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.models.fieldtypes;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.fieldtypes.FieldsOfBoolean;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Support of field type Boolean.
*Keywords: model
*Assertion ID: A6.4.3-9.
*Assertion Description:
JDO implementations must support fields of the immutable object class
java.lang.Boolean, and may choose to support them as
Second Class Objects or First Class Objects.
*/
public class TestFieldsOfBoolean extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A6.4.3-9 (TestFieldsOfBoolean) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(TestFieldsOfBoolean.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
addTearDownClass(FieldsOfBoolean.class);
}
/** */
public void test() {
pm = getPM();
runTest(pm);
pm.close();
pm = null;
}
/** */
void runTest(PersistenceManager pm)
{
Transaction tx = pm.currentTransaction();
int i, n;
Boolean firstValue = new Boolean(true);
Boolean secondValue = new Boolean(false);
tx.begin();
FieldsOfBoolean pi = new FieldsOfBoolean();
pi.identifier = 1;
pm.makePersistent(pi);
Object oid = pm.getObjectId(pi);
n = pi.getLength();
// Provide initial set of values
for( i = 0; i < n; ++i){
pi.set( i, firstValue);
}
tx.commit();
// cache will be flushed
pi = null;
System.gc();
tx.begin();
pi = (FieldsOfBoolean) pm.getObjectById(oid, true);
checkValues(oid, firstValue);
// Provide new set of values
for( i = 0; i < n; ++i){
pi.set(i, secondValue);
}
tx.commit();
// cache will be flushed
pi = null;
System.gc();
tx.begin();
// check new values
checkValues(oid, secondValue);
tx.commit();
}
/** */
private void checkValues(Object oid, Boolean startValue){
int i;
FieldsOfBoolean pi = (FieldsOfBoolean) pm.getObjectById(oid, true);
int n = pi.getLength();
for( i = 0; i < n; ++i){
if( !FieldsOfBoolean.isPersistent[i] )
continue;
Boolean val = pi.get(i);
if(!val.equals(startValue) ){
fail(ASSERTION_FAILED,
"Incorrect value for " + FieldsOfBoolean.fieldSpecs[i] +
", expected value " + startValue.toString() +
", value is " + val.toString());
}
}
}
}
tck/src/java/org/apache/jdo/tck/models/fieldtypes/TestFieldsOfByte.java 100664 7446 12500110373 26415 0 ustar mbouschen staff 0 0 /*
* 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.models.fieldtypes;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.fieldtypes.FieldsOfByte;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Support of field type Byte.
*Keywords: model
*Assertion ID: A6.4.3-11.
*Assertion Description:
JDO implementations must support fields of the immutable object class
java.lang.Byte, and may choose to support them as
Second Class Objects or First Class Objects.
*/
public class TestFieldsOfByte extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A6.4.3-11 (TestFieldsOfByte) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(TestFieldsOfByte.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
addTearDownClass(FieldsOfByte.class);
}
/** */
public void test() {
pm = getPM();
runTest(pm);
pm.close();
pm = null;
}
/** */
void runTest(PersistenceManager pm)
{
Transaction tx = pm.currentTransaction();
int i, n;
Byte firstValue = new Byte((byte)Byte.MIN_VALUE);
Byte secondValue = new Byte((byte)Byte.MAX_VALUE);
tx.begin();
FieldsOfByte pi = new FieldsOfByte();
pi.identifier = 1;
pm.makePersistent(pi);
Object oid = pm.getObjectId(pi);
n = pi.getLength();
// Provide initial set of values
for( i = 0; i < n; ++i){
pi.set( i, firstValue);
}
tx.commit();
// cache will be flushed
pi = null;
System.gc();
tx.begin();
pi = (FieldsOfByte) pm.getObjectById(oid, true);
checkValues(oid, firstValue);
// Provide new set of values
for( i = 0; i < n; ++i){
pi.set(i, secondValue);
}
tx.commit();
// cache will be flushed
pi = null;
System.gc();
tx.begin();
// check new values
checkValues(oid, secondValue);
tx.commit();
}
/** */
private void checkValues(Object oid, Byte startValue){
int i;
FieldsOfByte pi = (FieldsOfByte) pm.getObjectById(oid, true);
int n = pi.getLength();
for( i = 0; i < n; ++i){
if( !FieldsOfByte.isPersistent[i] )
continue;
Byte val = pi.get(i);
if(!val.equals(startValue) ){
fail(ASSERTION_FAILED,
"Incorrect value for " + FieldsOfByte.fieldSpecs[i] +
", expected value " + startValue.toString() +
", value is " + val.toString());
}
}
}
}
tck/src/java/org/apache/jdo/tck/models/fieldtypes/TestFieldsOfCharacter.java 100664 7623 12500110373 27403 0 ustar mbouschen staff 0 0 /*
* 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.models.fieldtypes;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.fieldtypes.FieldsOfCharacter;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Support of field type Character.
*Keywords: model
*Assertion ID: A6.4.3-10.
*Assertion Description:
JDO implementations must support fields of the immutable object class
java.lang.Character, and may choose to support them as
Second Class Objects or First Class Objects.
*/
public class TestFieldsOfCharacter extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A6.4.3-10 (TestFieldsOfCharacter) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(TestFieldsOfCharacter.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
addTearDownClass(FieldsOfCharacter.class);
}
/** */
public void test() {
pm = getPM();
runTest(pm);
pm.close();
pm = null;
}
/** */
void runTest(PersistenceManager pm)
{
Transaction tx = pm.currentTransaction();
int i, n;
Character firstValue = new Character((char)Character.MIN_VALUE);
Character secondValue = new Character((char)Character.MAX_VALUE);
tx.begin();
FieldsOfCharacter pi = new FieldsOfCharacter();
pi.identifier = 1;
pm.makePersistent(pi);
Object oid = pm.getObjectId(pi);
n = pi.getLength();
// Provide initial set of values
for( i = 0; i < n; ++i){
pi.set( i, firstValue);
}
tx.commit();
// cache will be flushed
pi = null;
System.gc();
tx.begin();
pi = (FieldsOfCharacter) pm.getObjectById(oid, true);
checkValues(oid, firstValue);
// Provide new set of values
for( i = 0; i < n; ++i){
pi.set(i, secondValue);
}
tx.commit();
// cache will be flushed
pi = null;
System.gc();
tx.begin();
// check new values
checkValues(oid, secondValue);
tx.commit();
}
/** */
private void checkValues(Object oid, Character startValue){
int i;
FieldsOfCharacter pi = (FieldsOfCharacter) pm.getObjectById(oid, true);
int n = pi.getLength();
for( i = 0; i < n; ++i){
if( !FieldsOfCharacter.isPersistent[i] )
continue;
Character val = pi.get(i);
if(!val.equals(startValue) ){
fail(ASSERTION_FAILED,
"Incorrect value for " + FieldsOfCharacter.fieldSpecs[i] +
", expected value " + startValue.toString() +
", value is " + val.toString());
}
}
}
}
tck/src/java/org/apache/jdo/tck/models/fieldtypes/TestFieldsOfDate.java 100664 7425 12500110373 26364 0 ustar mbouschen staff 0 0 /*
* 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.models.fieldtypes;
import java.util.Date;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.fieldtypes.FieldsOfDate;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Support of field type Date.
*Keywords: model
*Assertion ID: A6.4.3-21.
*Assertion Description:
JDO implementations must support fields of the mutable object class
java.util.Date, and may choose to support them as
Second Class Objects or First Class Objects.
*/
public class TestFieldsOfDate extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A6.4.3-21 (TestFieldsOfDate) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(TestFieldsOfDate.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
addTearDownClass(FieldsOfDate.class);
}
/** */
public void test() {
pm = getPM();
runTest(pm);
pm.close();
pm = null;
}
/** */
void runTest(PersistenceManager pm)
{
Transaction tx = pm.currentTransaction();
int i, n;
Date firstValue = new Date(2007908);
Date secondValue = new Date(890748967382l);
tx.begin();
FieldsOfDate pi = new FieldsOfDate();
pi.identifier = 1;
pm.makePersistent(pi);
Object oid = pm.getObjectId(pi);
n = pi.getLength();
// Provide initial set of values
for( i = 0; i < n; ++i){
pi.set( i, firstValue);
}
tx.commit();
// cache will be flushed
pi = null;
System.gc();
tx.begin();
pi = (FieldsOfDate) pm.getObjectById(oid, true);
checkValues(oid, firstValue);
// Provide new set of values
for( i = 0; i < n; ++i){
pi.set(i, secondValue);
}
tx.commit();
// cache will be flushed
pi = null;
System.gc();
tx.begin();
// check new values
checkValues(oid, secondValue);
tx.commit();
}
/** */
private void checkValues(Object oid, Date startValue){
int i;
FieldsOfDate pi = (FieldsOfDate) pm.getObjectById(oid, true);
int n = pi.getLength();
for( i = 0; i < n; ++i){
if( !FieldsOfDate.isPersistent[i] ) continue;
Date val = pi.get(i);
if(!val.equals(startValue) ){
fail(ASSERTION_FAILED,
"Incorrect value for " + FieldsOfDate.fieldSpecs[i] +
", expected value " + startValue.toString() +
", value is " + val.toString());
}
}
}
}
tck/src/java/org/apache/jdo/tck/models/fieldtypes/TestFieldsOfDouble.java 100664 7563 12500110373 26724 0 ustar mbouschen staff 0 0 /*
* 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.models.fieldtypes;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.fieldtypes.AllTypes;
import org.apache.jdo.tck.pc.fieldtypes.FieldsOfDouble;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Support of field type Double.
*Keywords: model
*Assertion ID: A6.4.3-16.
*Assertion Description:
JDO implementations must support fields of the immutable object class
java.lang.Double, and may choose to support them as
Second Class Objects or First Class Objects.
*/
public class TestFieldsOfDouble extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A6.4.3-16 (TestFieldsOfDouble) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(TestFieldsOfDouble.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
addTearDownClass(FieldsOfDouble.class);
}
/** */
public void test() {
pm = getPM();
runTest(pm);
pm.close();
pm = null;
}
/** */
void runTest(PersistenceManager pm)
{
Transaction tx = pm.currentTransaction();
int i, n;
Double firstValue = new Double(AllTypes.DOUBLE_SMALLEST);
Double secondValue = new Double(AllTypes.DOUBLE_LARGEST);
tx.begin();
FieldsOfDouble pi = new FieldsOfDouble();
pi.identifier = 1;
pm.makePersistent(pi);
Object oid = pm.getObjectId(pi);
n = pi.getLength();
// Provide initial set of values
for( i = 0; i < n; ++i){
pi.set( i, firstValue);
}
tx.commit();
// cache will be flushed
pi = null;
System.gc();
tx.begin();
pi = (FieldsOfDouble) pm.getObjectById(oid, true);
checkValues(oid, firstValue);
// Provide new set of values
for( i = 0; i < n; ++i){
pi.set(i, secondValue);
}
tx.commit();
// cache will be flushed
pi = null;
System.gc();
tx.begin();
// check new values
checkValues(oid, secondValue);
tx.commit();
}
/** */
private void checkValues(Object oid, Double startValue){
int i;
FieldsOfDouble pi = (FieldsOfDouble) pm.getObjectById(oid, true);
int n = pi.getLength();
for( i = 0; i < n; ++i){
if( !FieldsOfDouble.isPersistent[i] ) continue;
Double val = pi.get(i);
if(!val.equals(startValue) ){
fail(ASSERTION_FAILED,
"Incorrect value for " + FieldsOfDouble.fieldSpecs[i] +
", expected value " + startValue.toString() +
", value is " + val.toString());
}
}
}
}
tck/src/java/org/apache/jdo/tck/models/fieldtypes/TestFieldsOfFloat.java 100664 7535 12500110373 26556 0 ustar mbouschen staff 0 0 /*
* 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.models.fieldtypes;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.fieldtypes.AllTypes;
import org.apache.jdo.tck.pc.fieldtypes.FieldsOfFloat;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Support of field type Float.
*Keywords: model
*Assertion ID: A6.4.3-15.
*Assertion Description:
JDO implementations must support fields of the immutable object class
java.lang.Float, and may choose to support them as
Second Class Objects or First Class Objects.
*/
public class TestFieldsOfFloat extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A6.4.3-15 (TestFieldsOfFloat) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(TestFieldsOfFloat.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
addTearDownClass(FieldsOfFloat.class);
}
/** */
public void test() {
pm = getPM();
runTest(pm);
pm.close();
pm = null;
}
/** */
void runTest(PersistenceManager pm)
{
Transaction tx = pm.currentTransaction();
int i, n;
Float firstValue = new Float(AllTypes.FLOAT_SMALLEST);
Float secondValue = new Float(AllTypes.FLOAT_LARGEST);
tx.begin();
FieldsOfFloat pi = new FieldsOfFloat();
pi.identifier = 1;
pm.makePersistent(pi);
Object oid = pm.getObjectId(pi);
n = pi.getLength();
// Provide initial set of values
for( i = 0; i < n; ++i){
pi.set( i, firstValue);
}
tx.commit();
// cache will be flushed
pi = null;
System.gc();
tx.begin();
pi = (FieldsOfFloat) pm.getObjectById(oid, true);
checkValues(oid, firstValue);
// Provide new set of values
for( i = 0; i < n; ++i){
pi.set(i, secondValue);
}
tx.commit();
// cache will be flushed
pi = null;
System.gc();
tx.begin();
// check new values
checkValues(oid, secondValue);
tx.commit();
}
/** */
private void checkValues(Object oid, Float startValue){
int i;
FieldsOfFloat pi = (FieldsOfFloat) pm.getObjectById(oid, true);
int n = pi.getLength();
for( i = 0; i < n; ++i){
if( !FieldsOfFloat.isPersistent[i] ) continue;
Float val = pi.get(i);
if(!val.equals(startValue) ){
fail(ASSERTION_FAILED,
"Incorrect value for " + FieldsOfFloat.fieldSpecs[i] +
", expected value " + startValue.toString() +
", value is " + val.toString());
}
}
}
}
tck/src/java/org/apache/jdo/tck/models/fieldtypes/TestFieldsOfInteger.java 100664 7453 12500110373 27105 0 ustar mbouschen staff 0 0 /*
* 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.models.fieldtypes;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.fieldtypes.FieldsOfInteger;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Support of field type Integer.
*Keywords: model
*Assertion ID: A6.4.3-13.
*Assertion Description:
JDO implementations must support fields of the immutable object class
java.lang.Integer, and may choose to support them as
Second Class Objects or First Class Objects.
*/
public class TestFieldsOfInteger extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A6.4.3-13 (TestFieldsOfInteger) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(TestFieldsOfInteger.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
addTearDownClass(FieldsOfInteger.class);
}
/** */
public void test() {
pm = getPM();
runTest(pm);
pm.close();
pm = null;
}
/** */
void runTest(PersistenceManager pm)
{
Transaction tx = pm.currentTransaction();
int i, n;
Integer firstValue = new Integer(Integer.MIN_VALUE);
Integer secondValue = new Integer(Integer.MAX_VALUE);
tx.begin();
FieldsOfInteger pi = new FieldsOfInteger();
pi.identifier = 1;
pm.makePersistent(pi);
Object oid = pm.getObjectId(pi);
n = pi.getLength();
// Provide initial set of values
for( i = 0; i < n; ++i){
pi.set( i, firstValue);
}
tx.commit();
// cache will be flushed
pi = null;
System.gc();
tx.begin();
pi = (FieldsOfInteger) pm.getObjectById(oid, true);
checkValues(oid, firstValue);
// Provide new set of values
for( i = 0; i < n; ++i){
pi.set(i, secondValue);
}
tx.commit();
// cache will be flushed
pi = null;
System.gc();
tx.begin();
// check new values
checkValues(oid, secondValue);
tx.commit();
}
/** */
private void checkValues(Object oid, Integer startValue){
int i;
FieldsOfInteger pi = (FieldsOfInteger) pm.getObjectById(oid, true);
int n = pi.getLength();
for( i = 0; i < n; ++i){
if( !FieldsOfInteger.isPersistent[i] ) continue;
Integer val = pi.get(i);
if(!val.equals(startValue) ){
fail(ASSERTION_FAILED,
"Incorrect value for " + FieldsOfInteger.fieldSpecs[i] +
", expected value " + startValue.toString() +
", value is " + val.toString());
}
}
}
}
tck/src/java/org/apache/jdo/tck/models/fieldtypes/TestFieldsOfLocale.java 100664 7445 12500110373 26710 0 ustar mbouschen staff 0 0 /*
* 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.models.fieldtypes;
import java.util.Locale;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.fieldtypes.FieldsOfLocale;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Support of field type Locale.
*Keywords: model
*Assertion ID: A6.4.3-18.
*Assertion Description:
JDO implementations must support fields of the immutable object class
java.util.Locale, and may choose to support them as
Second Class Objects or First Class Objects.
*/
public class TestFieldsOfLocale extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A6.4.3-18 (TestFieldsOfLocale) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(TestFieldsOfLocale.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
addTearDownClass(FieldsOfLocale.class);
}
/** */
public void test() {
pm = getPM();
runTest(pm);
pm.close();
pm = null;
}
/** */
void runTest(PersistenceManager pm)
{
Transaction tx = pm.currentTransaction();
int i, n;
Locale firstValue = Locale.CHINA;
Locale secondValue = Locale.JAPANESE;
tx.begin();
FieldsOfLocale pi = new FieldsOfLocale();
pi.identifier = 1;
pm.makePersistent(pi);
Object oid = pm.getObjectId(pi);
n = pi.getLength();
// Provide initial set of values
for( i = 0; i < n; ++i){
pi.set( i, firstValue);
}
tx.commit();
// cache will be flushed
pi = null;
System.gc();
tx.begin();
pi = (FieldsOfLocale) pm.getObjectById(oid, true);
checkValues(oid, firstValue);
// Provide new set of values
for( i = 0; i < n; ++i){
pi.set(i, secondValue);
}
tx.commit();
// cache will be flushed
pi = null;
System.gc();
tx.begin();
// check new values
checkValues(oid, secondValue);
tx.commit();
}
/** */
private void checkValues(Object oid, Locale startValue){
int i;
Locale value;
FieldsOfLocale pi = (FieldsOfLocale) pm.getObjectById(oid, true);
int n = pi.getLength();
for( i = 0; i < n; ++i){
if( !FieldsOfLocale.isPersistent[i] ) continue;
Locale val = pi.get(i);
if(!val.equals(startValue) ){
fail(ASSERTION_FAILED,
"Incorrect value for " + FieldsOfLocale.fieldSpecs[i] +
", expected value " + startValue.toString() +
", value is " + val.toString());
}
}
}
}
tck/src/java/org/apache/jdo/tck/models/fieldtypes/TestFieldsOfLong.java 100664 7404 12500110373 26403 0 ustar mbouschen staff 0 0 /*
* 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.models.fieldtypes;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.fieldtypes.FieldsOfLong;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Support of field type Long.
*Keywords: model
*Assertion ID: A6.4.3-14.
*Assertion Description:
JDO implementations must support fields of the immutable object class
java.lang.Long, and may choose to support them as
Second Class Objects or First Class Objects.
*/
public class TestFieldsOfLong extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A6.4.3-14 (TestFieldsOfLong) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(TestFieldsOfLong.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
addTearDownClass(FieldsOfLong.class);
}
/** */
public void test() {
pm = getPM();
runTest(pm);
pm.close();
pm = null;
}
/** */
void runTest(PersistenceManager pm)
{
Transaction tx = pm.currentTransaction();
int i, n;
Long firstValue = new Long(Long.MIN_VALUE);
Long secondValue = new Long(Long.MAX_VALUE);
tx.begin();
FieldsOfLong pi = new FieldsOfLong();
pi.identifier = 1;
pm.makePersistent(pi);
Object oid = pm.getObjectId(pi);
n = pi.getLength();
// Provide initial set of values
for( i = 0; i < n; ++i){
pi.set( i, firstValue);
}
tx.commit();
// cache will be flushed
pi = null;
System.gc();
tx.begin();
pi = (FieldsOfLong) pm.getObjectById(oid, true);
checkValues(oid, firstValue);
// Provide new set of values
for( i = 0; i < n; ++i){
pi.set(i, secondValue);
}
tx.commit();
// cache will be flushed
pi = null;
System.gc();
tx.begin();
// check new values
checkValues(oid, secondValue);
tx.commit();
}
/** */
private void checkValues(Object oid, Long startValue){
int i;
FieldsOfLong pi = (FieldsOfLong) pm.getObjectById(oid, true);
int n = pi.getLength();
for( i = 0; i < n; ++i){
if( !FieldsOfLong.isPersistent[i] ) continue;
Long val = pi.get(i);
if(!val.equals(startValue) ){
fail(ASSERTION_FAILED,
"Incorrect value for " + FieldsOfLong.fieldSpecs[i] +
", expected value " + startValue.toString() +
", value is " + val.toString());
}
}
}
}
tck/src/java/org/apache/jdo/tck/models/fieldtypes/TestFieldsOfObject.java 100664 11145 12500110373 26727 0 ustar mbouschen staff 0 0 /*
* 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.models.fieldtypes;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.fieldtypes.FieldsOfObject;
import org.apache.jdo.tck.pc.fieldtypes.SimpleClass;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Support of field type Object.
*Keywords: model
*Assertion ID: A6.4.3-31.
*Assertion Description:
JDO implementations must support fields of Object class type
as First Class Objects. The implementation is permitted, but is not required,
to allow any class to be assigned to the field. If an implementation restricts
instances to be assigned to the field, a ClassCastException
must be thrown at the time of any incorrect assignment.
*/
public class TestFieldsOfObject extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A6.4.3-31 (TestFieldsOfObject) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(TestFieldsOfObject.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
addTearDownClass(FieldsOfObject.class);
}
/** */
public void test() {
pm = getPM();
runTest(pm);
pm.close();
pm = null;
}
/** */
void runTest(PersistenceManager pm)
{
Transaction tx = pm.currentTransaction();
int i, n;
Object firstValue = new SimpleClass(1, "Hello");
Object secondValue = new SimpleClass(333, "420");
tx.begin();
FieldsOfObject pi = new FieldsOfObject();
pi.identifier = 1;
pm.makePersistent(pi);
Object oid = pm.getObjectId(pi);
n = pi.getLength();
// Provide initial set of values
for( i = 0; i < n; ++i){
pi.set( i, firstValue);
}
tx.commit();
// cache will be flushed
pi = null;
System.gc();
tx.begin();
pi = (FieldsOfObject) pm.getObjectById(oid, true);
checkValues(oid, firstValue);
// Provide new set of values
for( i = 0; i < n; ++i){
pi.set(i, secondValue);
}
tx.commit();
// cache will be flushed
pi = null;
System.gc();
tx.begin();
// check new values
checkValues(oid, secondValue);
tx.commit();
}
/** */
private void checkValues(Object oid, Object startValue){
int i;
FieldsOfObject pi = (FieldsOfObject) pm.getObjectById(oid, true);
int n = pi.getLength();
StringBuffer buffer = new StringBuffer();
for( i = 0; i < n; ++i){
if( !FieldsOfObject.isPersistent[i] ) continue;
Object val = pi.get(i);
if (val == null) {
buffer.append("Field ");
buffer.append(FieldsOfObject.fieldSpecs[i]);
buffer.append(" is null. Expected ");
buffer.append(startValue.toString());
buffer.append(".\n");
continue;
}
if(!val.equals(startValue) ){
buffer.append("Field ");
buffer.append(FieldsOfObject.fieldSpecs[i]);
buffer.append(" has wrong value: expected ");
buffer.append(startValue.toString());
buffer.append(" actual ");
buffer.append(val.toString());
buffer.append(".\n");
}
}
if (buffer.length() > 0) {
fail(ASSERTION_FAILED,
buffer.toString());
}
}
}
tck/src/java/org/apache/jdo/tck/models/fieldtypes/TestFieldsOfPrimitiveboolean.java 100664 7410 12500110373 31011 0 ustar mbouschen staff 0 0 /*
* 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.models.fieldtypes;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.fieldtypes.FieldsOfPrimitiveboolean;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Support of field type boolean.
*Keywords: model
*Assertion ID: A6.4.3-1.
*Assertion Description:
JDO implementations must support fields of the primitive type boolean.
*/
public class TestFieldsOfPrimitiveboolean extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A6.4.3-1 (TestFieldsOfPrimitiveboolean) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(TestFieldsOfPrimitiveboolean.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
addTearDownClass(FieldsOfPrimitiveboolean.class);
}
/** */
public void test() {
pm = getPM();
runTest(pm);
pm.close();
pm = null;
}
/** */
void runTest(PersistenceManager pm)
{
Transaction tx = pm.currentTransaction();
int i, n;
boolean value;
tx.begin();
FieldsOfPrimitiveboolean pi = new FieldsOfPrimitiveboolean();
pi.identifier = 1;
pm.makePersistent(pi);
Object oid = pm.getObjectId(pi);
n = pi.getLength();
// Provide initial set of values
for( i = 0, value = true; i < n; ++i){
pi.set( i, value);
}
tx.commit();
// cache will be flushed
pi = null;
System.gc();
tx.begin();
pi = (FieldsOfPrimitiveboolean) pm.getObjectById(oid, true);
checkValues(oid, true);
// Provide new set of values
for( i = 0, value = false; i < n; ++i){
pi.set(i, value);
}
tx.commit();
// cache will be flushed
pi = null;
System.gc();
tx.begin();
// check new values
checkValues(oid, false);
tx.commit();
}
/** */
private void checkValues(Object oid, boolean startValue){
int i;
FieldsOfPrimitiveboolean pi = (FieldsOfPrimitiveboolean)
pm.getObjectById(oid, true);
int n = pi.getLength();
for( i = 0; i < n; ++i){
if( !FieldsOfPrimitiveboolean.isPersistent[i] ) continue;
boolean val = pi.get(i);
if( val != startValue ){
fail(ASSERTION_FAILED,
"Incorrect value for " +
FieldsOfPrimitiveboolean.fieldSpecs[i] +
", expected value " + startValue +
", value is " + val);
}
}
}
}
tck/src/java/org/apache/jdo/tck/models/fieldtypes/TestFieldsOfPrimitivebyte.java 100664 7330 12500110373 30336 0 ustar mbouschen staff 0 0 /*
* 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.models.fieldtypes;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.fieldtypes.FieldsOfPrimitivebyte;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Support of field type byte.
*Keywords: model
*Assertion ID: A6.4.3-2.
*Assertion Description:
JDO implementations must support fields of the primitive type int.
*/
public class TestFieldsOfPrimitivebyte extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A6.4.3-2 (TestFieldsOfPrimitivebyte) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(TestFieldsOfPrimitivebyte.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
addTearDownClass(FieldsOfPrimitivebyte.class);
}
/** */
public void test() {
pm = getPM();
runTest(pm);
pm.close();
pm = null;
}
/** */
void runTest(PersistenceManager pm)
{
Transaction tx = pm.currentTransaction();
int i, n;
byte value;
tx.begin();
FieldsOfPrimitivebyte pi = new FieldsOfPrimitivebyte();
pi.identifier = 1;
pm.makePersistent(pi);
Object oid = pm.getObjectId(pi);
n = pi.getLength();
// Provide initial set of values
for( i = 0, value = 10; i < n; ++i){
pi.set( i, value);
}
tx.commit();
// cache will be flushed
pi = null;
System.gc();
tx.begin();
pi = (FieldsOfPrimitivebyte) pm.getObjectById(oid, true);
checkValues(oid, (byte)10);
// Provide new set of values
for( i = 0, value = 127; i < n; ++i){
pi.set(i, value);
}
tx.commit();
// cache will be flushed
pi = null;
System.gc();
tx.begin();
// check new values
checkValues(oid, (byte)127);
tx.commit();
}
/** */
private void checkValues(Object oid, byte startValue){
int i;
FieldsOfPrimitivebyte pi = (FieldsOfPrimitivebyte)
pm.getObjectById(oid, true);
int n = pi.getLength();
for( i = 0; i < n; ++i){
if( !FieldsOfPrimitivebyte.isPersistent[i] ) continue;
byte val = pi.get(i);
if( val != startValue ){
fail(ASSERTION_FAILED,
"Incorrect value for " +
FieldsOfPrimitivebyte.fieldSpecs[i] +
", expected value " + startValue +
", value is " + val);
}
}
}
}
tck/src/java/org/apache/jdo/tck/models/fieldtypes/TestFieldsOfPrimitivechar.java 100664 7373 12500110373 30317 0 ustar mbouschen staff 0 0 /*
* 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.models.fieldtypes;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.fieldtypes.FieldsOfPrimitivechar;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Support of field type char.
*Keywords: model
*Assertion ID: A6.4.3-6.
*Assertion Description:
JDO implementations must support fields of the primitive type char.
*/
public class TestFieldsOfPrimitivechar extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A6.4.3-6 (TestFieldsOfPrimitivechar) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(TestFieldsOfPrimitivechar.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
addTearDownClass(FieldsOfPrimitivechar.class);
}
/** */
public void test() {
pm = getPM();
runTest(pm);
pm.close();
pm = null;
}
/** */
void runTest(PersistenceManager pm)
{
Transaction tx = pm.currentTransaction();
int i, n;
char value;
tx.begin();
FieldsOfPrimitivechar pi = new FieldsOfPrimitivechar();
pi.identifier = 1;
pm.makePersistent(pi);
Object oid = pm.getObjectId(pi);
n = pi.getLength();
// Provide initial set of values
for( i = 0, value = 'a'; i < n; ++i){
pi.set( i, value);
}
tx.commit();
// cache will be flushed
pi = null;
System.gc();
tx.begin();
pi = (FieldsOfPrimitivechar) pm.getObjectById(oid, true);
checkValues(oid, 'a'); // check if persistent fields have values set
// Provide new set of values
for( i = 0, value = 'Z'; i < n; ++i){
pi.set(i, value);
}
tx.commit();
// cache will be flushed
pi = null;
System.gc();
tx.begin();
// check new values
checkValues(oid, 'Z');
tx.commit();
}
/** */
private void checkValues(Object oid, char startValue){
int i;
FieldsOfPrimitivechar pi = (FieldsOfPrimitivechar)
pm.getObjectById(oid, true);
int n = pi.getLength();
for( i = 0; i < n; ++i){
if( !FieldsOfPrimitivechar.isPersistent[i] ) continue;
char val = pi.get(i);
if( val != startValue ){
fail(ASSERTION_FAILED,
"Incorrect value for " +
FieldsOfPrimitivechar.fieldSpecs[i] +
", expected value " + startValue +
", value is " + val);
}
}
}
}
tck/src/java/org/apache/jdo/tck/models/fieldtypes/TestFieldsOfPrimitivedouble.java 100664 7436 12500110373 30654 0 ustar mbouschen staff 0 0 /*
* 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.models.fieldtypes;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.fieldtypes.FieldsOfPrimitivedouble;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Support of field type double.
*Keywords: model
*Assertion ID: A6.4.3-8.
*Assertion Description:
JDO implementations must support fields of the primitive type double.
*/
public class TestFieldsOfPrimitivedouble extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A6.4.3-8 (TestFieldsOfPrimitivedouble) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(TestFieldsOfPrimitivedouble.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
addTearDownClass(FieldsOfPrimitivedouble.class);
}
/** */
public void test() {
pm = getPM();
runTest(pm);
pm.close();
pm = null;
}
/** */
void runTest(PersistenceManager pm)
{
Transaction tx = pm.currentTransaction();
int i, n;
double value;
tx.begin();
FieldsOfPrimitivedouble pi = new FieldsOfPrimitivedouble();
pi.identifier = 1;
pm.makePersistent(pi);
Object oid = pm.getObjectId(pi);
n = pi.getLength();
// Provide initial set of values
for( i = 0, value = (double)10.15; i < n; ++i){
pi.set( i, value);
}
tx.commit();
// cache will be flushed
pi = null;
System.gc();
tx.begin();
pi = (FieldsOfPrimitivedouble) pm.getObjectById(oid, true);
checkValues(oid, (double)10.15);
// Provide new set of values
for( i = 0, value = (double)68000.15; i < n; ++i){
pi.set(i, value);
}
tx.commit();
// cache will be flushed
pi = null;
System.gc();
tx.begin();
// check new values
checkValues(oid, (double)68000.15);
tx.commit();
}
/** */
private void checkValues(Object oid, double startValue){
int i;
FieldsOfPrimitivedouble pi = (FieldsOfPrimitivedouble)
pm.getObjectById(oid, true);
int n = pi.getLength();
for( i = 0; i < n; ++i){
if( !FieldsOfPrimitivedouble.isPersistent[i] ) continue;
double val = pi.get(i);
if( val != startValue ){
fail(ASSERTION_FAILED,
"Incorrect value for " +
FieldsOfPrimitivedouble.fieldSpecs[i] +
", expected value " + startValue +
", value is " + val);
}
}
}
}
tck/src/java/org/apache/jdo/tck/models/fieldtypes/TestFieldsOfPrimitivefloat.java 100664 7412 12500110373 30501 0 ustar mbouschen staff 0 0 /*
* 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.models.fieldtypes;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.fieldtypes.FieldsOfPrimitivefloat;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Support of field type float.
*Keywords: model
*Assertion ID: A6.4.3-7.
*Assertion Description:
JDO implementations must support fields of the primitive type float.
*/
public class TestFieldsOfPrimitivefloat extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A6.4.3-7 (TestFieldsOfPrimitivefloat) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(TestFieldsOfPrimitivefloat.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
addTearDownClass(FieldsOfPrimitivefloat.class);
}
/** */
public void test() {
pm = getPM();
runTest(pm);
pm.close();
pm = null;
}
/** */
void runTest(PersistenceManager pm)
{
Transaction tx = pm.currentTransaction();
int i, n;
float value;
tx.begin();
FieldsOfPrimitivefloat pi = new FieldsOfPrimitivefloat();
pi.identifier = 1;
pm.makePersistent(pi);
Object oid = pm.getObjectId(pi);
n = pi.getLength();
// Provide initial set of values
for( i = 0, value = (float)10.15; i < n; ++i){
pi.set( i, value);
}
tx.commit();
// cache will be flushed
pi = null;
System.gc();
tx.begin();
pi = (FieldsOfPrimitivefloat) pm.getObjectById(oid, true);
checkValues(oid, (float)10.15);
// Provide new set of values
for( i = 0, value = (float)33000.15; i < n; ++i){
pi.set(i, value);
}
tx.commit();
// cache will be flushed
pi = null;
System.gc();
tx.begin();
// check new values
checkValues(oid, (float)33000.15);
tx.commit();
}
/** */
private void checkValues(Object oid, float startValue){
int i;
FieldsOfPrimitivefloat pi = (FieldsOfPrimitivefloat)
pm.getObjectById(oid, true);
int n = pi.getLength();
for( i = 0; i < n; ++i){
if( !FieldsOfPrimitivefloat.isPersistent[i] ) continue;
float val = pi.get(i);
if( val != startValue ){
fail(ASSERTION_FAILED,
"Incorrect value for " +
FieldsOfPrimitivefloat.fieldSpecs[i] +
", expected value " + startValue +
", value is " + val);
}
}
}
}
tck/src/java/org/apache/jdo/tck/models/fieldtypes/TestFieldsOfPrimitiveint.java 100664 7465 12500110373 30176 0 ustar mbouschen staff 0 0 /*
* 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.models.fieldtypes;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.fieldtypes.FieldsOfPrimitiveint;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Support of field type int.
*Keywords: model
*Assertion ID: A6.4.3-4.
*Assertion Description:
JDO implementations must support fields of the primitive type int.
*/
public class TestFieldsOfPrimitiveint extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A6.4.3-4 (TestFieldsOfPrimitiveint) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(TestFieldsOfPrimitiveint.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
addTearDownClass(FieldsOfPrimitiveint.class);
}
/** */
public void test() {
pm = getPM();
runTest(pm);
pm.close();
pm = null;
}
/** */
void runTest(PersistenceManager pm)
{
Transaction tx = pm.currentTransaction();
int i, n, value;
tx.begin();
FieldsOfPrimitiveint pi = new FieldsOfPrimitiveint();
pi.identifier = 1;
pm.makePersistent(pi);
Object oid = pm.getObjectId(pi);
n = pi.getLength();
// Provide initial set of values
for( i = 0, value = 0; i < n; ++i, ++value ){
pi.set( i, value);
}
tx.commit();
// cache will be flushed
pi = null;
System.gc();
tx.begin();
pi = (FieldsOfPrimitiveint) pm.getObjectById(oid, true);
checkValues(oid, 0); // check if persistent fields have values set
// Provide new set of values
for( i = 0, value = 1000; i < n; ++i, ++value ){
pi.set(i, value);
}
tx.commit();
// cache will be flushed
pi = null;
System.gc();
tx.begin();
// check new values
checkValues(oid, 1000);
tx.commit();
}
/** */
private void checkValues(Object oid, int startValue){
int i, value;
FieldsOfPrimitiveint pi = (FieldsOfPrimitiveint)
pm.getObjectById(oid, true);
int n = pi.getLength();
for( i = 0, value = startValue; i < n; ++i, ++value){
if( !FieldsOfPrimitiveint.isPersistent[i] ) continue;
int val = pi.get(i);
if( val != value ){
fail(ASSERTION_FAILED,
"Incorrect value for " +
FieldsOfPrimitiveint.fieldSpecs[i] +
", expected value " + startValue +
", value is " + val);
}
}
}
}
tck/src/java/org/apache/jdo/tck/models/fieldtypes/TestFieldsOfPrimitivelong.java 100664 7423 12500110373 30335 0 ustar mbouschen staff 0 0 /*
* 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.models.fieldtypes;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.fieldtypes.FieldsOfPrimitivelong;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Support of field type long.
*Keywords: model
*Assertion ID: A6.4.3-5.
*Assertion Description:
JDO implementations must support fields of the primitive type long.
*/
public class TestFieldsOfPrimitivelong extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A6.4.3-5 (TestFieldsOfPrimitivelong) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(TestFieldsOfPrimitivelong.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
addTearDownClass(FieldsOfPrimitivelong.class);
}
/** */
public void test() {
pm = getPM();
runTest(pm);
pm.close();
pm = null;
}
/** */
void runTest(PersistenceManager pm)
{
Transaction tx = pm.currentTransaction();
int i, n;
long value;
tx.begin();
FieldsOfPrimitivelong pi = new FieldsOfPrimitivelong();
pi.identifier = 1;
pm.makePersistent(pi);
Object oid = pm.getObjectId(pi);
n = pi.getLength();
// Provide initial set of values
for( i = 0, value = 10; i < n; ++i){
pi.set( i, value);
}
tx.commit();
// cache will be flushed
pi = null;
System.gc();
tx.begin();
pi = (FieldsOfPrimitivelong) pm.getObjectById(oid, true);
checkValues(oid, 10); // check if persistent fields have values set
// Provide new set of values
for( i = 0, value = 67000; i < n; ++i){
pi.set(i, value);
}
tx.commit();
// cache will be flushed
pi = null;
System.gc();
tx.begin();
// check new values
checkValues(oid, 67000);
tx.commit();
}
/** */
private void checkValues(Object oid, long startValue){
int i;
long value;
FieldsOfPrimitivelong pi = (FieldsOfPrimitivelong)
pm.getObjectById(oid, true);
int n = pi.getLength();
for( i = 0; i < n; ++i){
if( !FieldsOfPrimitivelong.isPersistent[i] ) continue;
long val = pi.get(i);
if( val != startValue ){
fail(ASSERTION_FAILED,
"Incorrect value for " +
FieldsOfPrimitivelong.fieldSpecs[i] +
", expected value " + startValue +
", value is " + val);
}
}
}
}
tck/src/java/org/apache/jdo/tck/models/fieldtypes/TestFieldsOfPrimitiveshort.java 100664 7356 12500110373 30542 0 ustar mbouschen staff 0 0 /*
* 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.models.fieldtypes;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.fieldtypes.FieldsOfPrimitiveshort;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Support of field type short.
*Keywords: model
*Assertion ID: A6.4.3-3.
*Assertion Description:
JDO implementations must support fields of the primitive type short.
*/
public class TestFieldsOfPrimitiveshort extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A6.4.3-3 (TestFieldsOfPrimitiveshort) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(TestFieldsOfPrimitiveshort.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
addTearDownClass(FieldsOfPrimitiveshort.class);
}
/** */
public void test() {
pm = getPM();
runTest(pm);
pm.close();
pm = null;
}
/** */
void runTest(PersistenceManager pm)
{
Transaction tx = pm.currentTransaction();
int i, n;
short value;
tx.begin();
FieldsOfPrimitiveshort pi = new FieldsOfPrimitiveshort();
pi.identifier = 1;
pm.makePersistent(pi);
Object oid = pm.getObjectId(pi);
n = pi.getLength();
// Provide initial set of values
for( i = 0, value = 10; i < n; ++i){
pi.set( i, value);
}
tx.commit();
// cache will be flushed
pi = null;
System.gc();
tx.begin();
pi = (FieldsOfPrimitiveshort) pm.getObjectById(oid, true);
checkValues(oid, (short)10);
// Provide new set of values
for( i = 0, value = 32000; i < n; ++i){
pi.set(i, value);
}
tx.commit();
// cache will be flushed
pi = null;
System.gc();
tx.begin();
// check new values
checkValues(oid, (short)32000);
tx.commit();
}
/** */
private void checkValues(Object oid, short startValue){
int i;
FieldsOfPrimitiveshort pi = (FieldsOfPrimitiveshort)
pm.getObjectById(oid, true);
int n = pi.getLength();
for( i = 0; i < n; ++i){
if( !FieldsOfPrimitiveshort.isPersistent[i] ) continue;
short val = pi.get(i);
if( val != startValue ){
fail(ASSERTION_FAILED,
"Incorrect value for " +
FieldsOfPrimitiveshort.fieldSpecs[i] +
", expected value " + startValue +
", value is " + val);
}
}
}
}
tck/src/java/org/apache/jdo/tck/models/fieldtypes/TestFieldsOfShort.java 100664 7515 12500110373 26606 0 ustar mbouschen staff 0 0 /*
* 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.models.fieldtypes;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.fieldtypes.FieldsOfShort;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Support of field type Short.
*Keywords: model
*Assertion ID: A6.4.3-12.
*Assertion Description:
JDO implementations must support fields of the immutable object class
java.lang.Short, and may choose to support them as
Second Class Objects or First Class Objects.
*/
public class TestFieldsOfShort extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A6.4.3-12 (TestFieldsOfShort) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(TestFieldsOfShort.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
addTearDownClass(FieldsOfShort.class);
}
/** */
public void test() {
pm = getPM();
runTest(pm);
pm.close();
pm = null;
}
/** */
void runTest(PersistenceManager pm)
{
Transaction tx = pm.currentTransaction();
int i, n;
Short firstValue = new Short(Short.MIN_VALUE);
Short secondValue = new Short(Short.MAX_VALUE);
tx.begin();
FieldsOfShort pi = new FieldsOfShort();
pi.identifier = 1;
pm.makePersistent(pi);
Object oid = pm.getObjectId(pi);
n = pi.getLength();
// Provide initial set of values
for( i = 0; i < n; ++i){
pi.set( i, firstValue);
}
tx.commit();
// cache will be flushed
pi = null;
System.gc();
tx.begin();
pi = (FieldsOfShort) pm.getObjectById(oid, true);
checkValues(oid, firstValue);
// Provide new set of values
for( i = 0; i < n; ++i){
pi.set(i, secondValue);
}
tx.commit();
// cache will be flushed
pi = null;
System.gc();
tx.begin();
// check new values
checkValues(oid, secondValue);
tx.commit();
}
/** */
private void checkValues(Object oid, Short startValue){
int i;
Short value;
FieldsOfShort pi = (FieldsOfShort) pm.getObjectById(oid, true);
int n = pi.getLength();
for( i = 0, value = startValue; i < n; ++i){
if( !FieldsOfShort.isPersistent[i] ) continue;
Short val = pi.get(i);
if(!val.equals(startValue) ){
fail(ASSERTION_FAILED,
"Incorrect value for " + FieldsOfShort.fieldSpecs[i] +
", expected value " + startValue.toString() +
", value is " + val.toString());
}
}
}
}
tck/src/java/org/apache/jdo/tck/models/fieldtypes/TestFieldsOfSimpleClass.java 100664 7501 12500110373 27721 0 ustar mbouschen staff 0 0 /*
* 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.models.fieldtypes;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.fieldtypes.FieldsOfSimpleClass;
import org.apache.jdo.tck.pc.fieldtypes.SimpleClass;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Support of fields of PersistenceCapable class types
*Keywords: model
*Assertion ID: A6.4.3-30.
*Assertion Description:
JDO implementations must support fields of PersistenceCapable
class types as First Class Objects.
*/
public class TestFieldsOfSimpleClass extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A6.4.3-30 (TestFieldsOfSimpleClass) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(TestFieldsOfSimpleClass.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
addTearDownClass(FieldsOfSimpleClass.class);
}
/** */
public void test() {
pm = getPM();
runTest(pm);
pm.close();
pm = null;
}
/** */
void runTest(PersistenceManager pm)
{
Transaction tx = pm.currentTransaction();
int i, n;
SimpleClass firstValue = new SimpleClass(100, "Hello");
SimpleClass secondValue = new SimpleClass(2000, "Hello World");
tx.begin();
FieldsOfSimpleClass pi = new FieldsOfSimpleClass();
pi.identifier = 1;
pm.makePersistent(pi);
Object oid = pm.getObjectId(pi);
n = pi.getLength();
// Provide initial set of values
for( i = 0; i < n; ++i){
pi.set( i, firstValue);
}
tx.commit();
// cache will be flushed
pi = null;
System.gc();
tx.begin();
pi = (FieldsOfSimpleClass) pm.getObjectById(oid, true);
checkValues(oid, firstValue);
// Provide new set of values
for( i = 0; i < n; ++i){
pi.set(i, secondValue);
}
tx.commit();
// cache will be flushed
pi = null;
System.gc();
tx.begin();
// check new values
checkValues(oid, secondValue);
tx.commit();
}
/** */
private void checkValues(Object oid, SimpleClass startValue){
int i;
FieldsOfSimpleClass pi = (FieldsOfSimpleClass)
pm.getObjectById(oid, true);
int n = pi.getLength();
for( i = 0; i < n; ++i){
if( !FieldsOfSimpleClass.isPersistent[i] ) continue;
SimpleClass val = pi.get(i);
if(!val.equals(startValue) ){
fail(ASSERTION_FAILED,
"Incorrect value for " +
FieldsOfSimpleClass.fieldSpecs[i]);
}
}
}
}
tck/src/java/org/apache/jdo/tck/models/fieldtypes/TestFieldsOfSimpleEnum.java 100664 7427 12500110373 27567 0 ustar mbouschen staff 0 0 /*
* 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.models.fieldtypes;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.fieldtypes.FieldsOfSimpleEnum;
import org.apache.jdo.tck.pc.fieldtypes.SimpleEnum;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Support of field type Enum.
*Keywords: model
*Assertion ID: A???
*Assertion Description:
* TBD
*/
public class TestFieldsOfSimpleEnum extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A6.4.3-13 (TestFieldsOfEnum) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(TestFieldsOfSimpleEnum.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
addTearDownClass(FieldsOfSimpleEnum.class);
}
/** */
public void test() {
pm = getPM();
runTest(pm);
pm.close();
pm = null;
}
/** */
void runTest(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
int i, n;
SimpleEnum firstValue = SimpleEnum.AL;
SimpleEnum secondValue = SimpleEnum.WY;
tx.begin();
FieldsOfSimpleEnum pi = new FieldsOfSimpleEnum();
pi.identifier = 1;
pm.makePersistent(pi);
Object oid = pm.getObjectId(pi);
n = pi.getLength();
// Provide initial set of values
for( i = 0; i < n; ++i){
pi.set( i, firstValue);
}
tx.commit();
// cache will be flushed
pi = null;
System.gc();
tx.begin();
pi = (FieldsOfSimpleEnum) pm.getObjectById(oid, true);
checkValues(oid, firstValue);
// Provide new set of values
for( i = 0; i < n; ++i){
pi.set(i, secondValue);
}
tx.commit();
// cache will be flushed
pi = null;
System.gc();
tx.begin();
// check new values
checkValues(oid, secondValue);
tx.commit();
failOnError();
}
/** */
private void checkValues(Object oid, SimpleEnum startValue){
int i;
FieldsOfSimpleEnum pi = (FieldsOfSimpleEnum)pm.getObjectById(oid, true);
int n = pi.getLength();
for( i = 0; i < n; ++i){
if( !FieldsOfSimpleEnum.isPersistent[i] ) continue;
SimpleEnum val = pi.get(i);
if(!startValue.equals(val) ){
appendMessage(ASSERTION_FAILED +
"Incorrect value for " + FieldsOfSimpleEnum.fieldSpecs[i] +
", expected value " + startValue.toString() +
", value is " + val);
}
}
}
}
tck/src/java/org/apache/jdo/tck/models/fieldtypes/TestFieldsOfSimpleInterface.java 100664 7707 12500110373 30564 0 ustar mbouschen staff 0 0 /*
* 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.models.fieldtypes;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.fieldtypes.FieldsOfSimpleInterface;
import org.apache.jdo.tck.pc.fieldtypes.SimpleClass;
import org.apache.jdo.tck.pc.fieldtypes.SimpleInterface;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Support of interfaces as field type.
*Keywords: model
*Assertion ID: A6.4.3-32.
*Assertion Description:
JDO implementations must support fields of interface types, and may choose
to support them as Second Class Objects or First Class Objects.
*/
public class TestFieldsOfSimpleInterface extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A6.4.3-32 (TestFieldsOfSimpleInterface) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(TestFieldsOfSimpleInterface.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
addTearDownClass(FieldsOfSimpleInterface.class);
}
/** */
public void test() {
pm = getPM();
runTest(pm);
pm.close();
pm = null;
}
/** */
void runTest(PersistenceManager pm)
{
Transaction tx = pm.currentTransaction();
int i, n;
SimpleInterface firstValue = new SimpleClass(100, "Hello");
SimpleInterface secondValue = new SimpleClass(2000, "Hello World");
tx.begin();
FieldsOfSimpleInterface pi = new FieldsOfSimpleInterface();
pi.identifier = 1;
pm.makePersistent(pi);
Object oid = pm.getObjectId(pi);
n = pi.getLength();
// Provide initial set of values
for( i = 0; i < n; ++i){
pi.set( i, firstValue);
}
tx.commit();
// cache will be flushed
pi = null;
System.gc();
tx.begin();
pi = (FieldsOfSimpleInterface) pm.getObjectById(oid, true);
checkValues(oid, firstValue);
// Provide new set of values
for( i = 0; i < n; ++i){
pi.set(i, secondValue);
}
tx.commit();
// cache will be flushed
pi = null;
System.gc();
tx.begin();
// check new values
checkValues(oid, secondValue);
tx.commit();
}
/** */
private void checkValues(Object oid, SimpleInterface startValue){
int i;
FieldsOfSimpleInterface pi = (FieldsOfSimpleInterface)
pm.getObjectById(oid, true);
int n = pi.getLength();
for( i = 0; i < n; ++i){
if( !FieldsOfSimpleInterface.isPersistent[i] ) continue;
SimpleInterface val = pi.get(i);
if(!val.equals(startValue)){
fail(ASSERTION_FAILED,
"Incorrect value for " +
FieldsOfSimpleInterface.fieldSpecs[i]);
}
}
}
}
tck/src/java/org/apache/jdo/tck/models/fieldtypes/TestFieldsOfString.java 100664 7510 12500110373 26750 0 ustar mbouschen staff 0 0 /*
* 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.models.fieldtypes;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.fieldtypes.FieldsOfString;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Support of field type String.
*Keywords: model
*Assertion ID: A6.4.3-17.
*Assertion Description:
JDO implementations must support fields of the immutable object class
java.lang.String, and may choose to support them as
Second Class Objects or First Class Objects.
*/
public class TestFieldsOfString extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A6.4.3-17 (TestFieldsOfString) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(TestFieldsOfString.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
addTearDownClass(FieldsOfString.class);
}
/** */
public void test() {
pm = getPM();
runTest(pm);
pm.close();
pm = null;
}
/** */
void runTest(PersistenceManager pm)
{
Transaction tx = pm.currentTransaction();
int i, n;
String firstValue = new String("Hello");
String secondValue = new String("Hello World");
tx.begin();
FieldsOfString pi = new FieldsOfString();
pi.identifier = 1;
pm.makePersistent(pi);
Object oid = pm.getObjectId(pi);
n = pi.getLength();
// Provide initial set of values
for( i = 0; i < n; ++i){
pi.set( i, firstValue);
}
tx.commit();
// cache will be flushed
pi = null;
System.gc();
tx.begin();
pi = (FieldsOfString) pm.getObjectById(oid, true);
checkValues(oid, firstValue);
// Provide new set of values
for( i = 0; i < n; ++i){
pi.set(i, secondValue);
}
tx.commit();
// cache will be flushed
pi = null;
System.gc();
tx.begin();
// check new values
checkValues(oid, secondValue);
tx.commit();
}
/** */
private void checkValues(Object oid, String startValue){
int i;
String value;
FieldsOfString pi = (FieldsOfString) pm.getObjectById(oid, true);
int n = pi.getLength();
for( i = 0, value = startValue; i < n; ++i){
if( !FieldsOfString.isPersistent[i] ) continue;
String val = pi.get(i);
if(!val.equals(startValue) ){
fail(ASSERTION_FAILED,
"Incorrect value for " + FieldsOfString.fieldSpecs[i] +
", expected value " + value +
", value is " + val.toString());
}
}
}
}
tck/src/java/org/apache/jdo/tck/models/fieldtypes/TestHashMapStringKeyCollections.java 100664 15375 12500110373 31476 0 ustar mbouschen staff 0 0 /*
* 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.models.fieldtypes;
import java.math.BigDecimal;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Set;
import java.util.Vector;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.fieldtypes.HashMapStringKeyCollections;
import org.apache.jdo.tck.pc.fieldtypes.SimpleClass;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Support of field type HashMap, varying value type
*Keywords: model
*Assertion ID: A6.4.3-24.
*Assertion Description:
If the HashMap optional feature is supported, then JDO implementation must
support fields of the mutable object class HashMap,
supporting them as Second Class Objects or First Class Objects.
*/
public class TestHashMapStringKeyCollections extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A6.4.3-24 (TestHashMapStringKeyCollections) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(TestHashMapStringKeyCollections.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
addTearDownClass(HashMapStringKeyCollections.class);
addTearDownClass(SimpleClass.class);
}
/** */
public void test() {
pm = getPM();
runTest(pm);
pm.close();
pm = null;
}
/** */
void runTest(PersistenceManager pm)
{
if (!isHashMapSupported()) {
if (debug)
logger.debug("JDO Implementation does not support " +
"the optional feature HashMap");
return;
}
Transaction tx = pm.currentTransaction();
HashMapStringKeyCollections expectedValue =
new HashMapStringKeyCollections();
// turn on datastore transactions
tx.setOptimistic(false);
tx.begin();
HashMapStringKeyCollections pi = new HashMapStringKeyCollections();
pi.identifier = 1;
pm.makePersistent(pi);
Object oid = pm.getObjectId(pi);
// Provide initial set of values
setValues(pi, 1);
tx.commit();
// cache will be flushed
pi = null;
System.gc();
tx.begin();
setValues(expectedValue, 1);
checkValues(oid, expectedValue);
pi = (HashMapStringKeyCollections) pm.getObjectById(oid, true);
setValues(pi, 2);
tx.commit();
// cache will be flushed
pi = null;
System.gc();
tx.begin();
// check new values
setValues(expectedValue, 2);
checkValues(oid, expectedValue);
tx.commit();
}
/** */
private void setValues(HashMapStringKeyCollections collect, int order)
{
int keyOrder = order;
int valueOrder = (order == 1) ? 2 : 1; // why??
int n = collect.getLength();
for (int i = 0; i < n; ++i) {
Vector fieldSpecs = TestUtil.getFieldSpecsForMap(
HashMapStringKeyCollections.fieldSpecs[i]);
Vector key = TestUtil.makeNewVectorInstance(
(String)fieldSpecs.get(0), keyOrder);
Vector value = TestUtil.makeNewVectorInstance(
(String)fieldSpecs.get(1), valueOrder);
HashMap map = new HashMap();
for (int j = 0; j< key.size(); j++) {
map.put(key.get(j), value.get(j));
}
collect.set(i, map);
if (debug)
logger.debug("Set " + i + "th value to: " + map.toString());
}
}
/** */
private void checkValues(Object oid,
HashMapStringKeyCollections expectedValue)
{
StringBuffer sbuf = new StringBuffer();
HashMapStringKeyCollections pi = (HashMapStringKeyCollections)
pm.getObjectById(oid, true);
int n = pi.getLength();
for (int i = 0; i < n; ++i) {
HashMap expected = expectedValue.get(i);
HashMap actual = pi.get(i);
if (actual.size() != expected.size()) {
sbuf.append("\nFor element " + i + ", expected size = " +
expected.size() + ", actual size = " + actual.size()
+ " . ");
}
else if (! expected.equals(actual)) {
if (TestUtil.getFieldSpecsForMap(
HashMapStringKeyCollections.fieldSpecs[i]
).get(1).equals("BigDecimal")) {
Set keys = expected.keySet();
Iterator iter = keys.iterator();
while (iter.hasNext()) {
Object nextKey = iter.next();
BigDecimal expectedMapValue =
(BigDecimal)expected.get(nextKey);
BigDecimal actualMapValue =
(BigDecimal)actual.get(nextKey);
if ((expectedMapValue.compareTo(actualMapValue) != 0)) {
sbuf.append("\nFor element " + i + "("
+ (String)nextKey +
"), expected = " + expectedMapValue +
", actual = " + actualMapValue + " . ");
}
}
}
else {
sbuf.append("\nFor element " + i + ", expected = " +
expected + ", actual = " + actual + " . ");
}
}
}
if (sbuf.length() > 0) {
fail(ASSERTION_FAILED,
"Expected and observed do not match!!" + sbuf.toString());
}
}
}
tck/src/java/org/apache/jdo/tck/models/fieldtypes/TestHashMapStringValueCollections.java 100664 17001 12500110373 32006 0 ustar mbouschen staff 0 0 /*
* 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.models.fieldtypes;
import java.math.BigDecimal;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;
import java.util.Vector;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.fieldtypes.HashMapStringValueCollections;
import org.apache.jdo.tck.pc.fieldtypes.SimpleClass;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Support of field type HashMap, varying key type
*Keywords: model
*Assertion ID: A6.4.3-24.
*Assertion Description:
If the HashMap optional feature is supported, then JDO implementation must
support fields of the mutable object class HashMap,
supporting them as Second Class Objects or First Class Objects.
*/
public class TestHashMapStringValueCollections extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A6.4.3-24 (TestHashMapStringValueCollections) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(TestHashMapStringValueCollections.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
addTearDownClass(HashMapStringValueCollections.class);
addTearDownClass(SimpleClass.class);
}
/** */
public void test() {
pm = getPM();
runTest(pm);
pm.close();
pm = null;
}
/** */
void runTest(PersistenceManager pm)
{
if (!isHashMapSupported()) {
if (debug)
logger.debug("JDO Implementation does not support " +
"the optional feature HashMap");
return;
}
Transaction tx = pm.currentTransaction();
HashMapStringValueCollections expectedValue =
new HashMapStringValueCollections();
// turn on datastore transactions
tx.setOptimistic(false);
tx.begin();
HashMapStringValueCollections pi = new HashMapStringValueCollections();
pi.identifier = 1;
pm.makePersistent(pi);
Object oid = pm.getObjectId(pi);
// Provide initial set of values
setValues(pi, 1);
tx.commit();
// cache will be flushed
pi = null;
System.gc();
tx.begin();
setValues(expectedValue, 1);
checkValues(oid, expectedValue);
pi = (HashMapStringValueCollections) pm.getObjectById(oid, true);
// Provide new set of values -- reverse the keys and values
setValues(pi, 2);
tx.commit();
// cache will be flushed
pi = null;
System.gc();
tx.begin();
// check new values
setValues(expectedValue, 2);
checkValues(oid, expectedValue);
pi = (HashMapStringValueCollections) pm.getObjectById(oid, true);
tx.commit();
}
/** */
private void setValues(HashMapStringValueCollections collect, int order)
{
int keyOrder = order;
int valueOrder = (order == 1) ? 2 : 1; // why??
int n = collect.getLength();
for (int i = 0; i < n; ++i) {
Vector fieldSpecs = TestUtil.getFieldSpecsForMap(
HashMapStringValueCollections.fieldSpecs[i]);
Vector key = TestUtil.makeNewVectorInstance(
(String)fieldSpecs.get(0), keyOrder);
Vector value = TestUtil.makeNewVectorInstance(
(String)fieldSpecs.get(1), valueOrder);
HashMap map = new HashMap();
for (int j = 0; j< key.size(); j++) {
map.put(key.get(j), value.get(j));
}
collect.set(i, map);
if (debug)
logger.debug("Set " + i + "th value to: " + map.toString());
}
}
/** */
private void checkValues(Object oid,
HashMapStringValueCollections expectedValue)
{
StringBuffer sbuf = new StringBuffer();
HashMapStringValueCollections pi = (HashMapStringValueCollections)
pm.getObjectById(oid, true);
int n = pi.getLength();
for (int i = 0; i < n; ++i) {
HashMap expected = expectedValue.get(i);
HashMap actual = pi.get(i);
if (actual.size() != expected.size()) {
sbuf.append("\nFor element " + i + ", expected size = " +
expected.size() + ", actual size = " + actual.size()
+ " . ");
}
else if (! expected.equals(actual)) {
if (TestUtil.getFieldSpecsForMap(
HashMapStringValueCollections.fieldSpecs[i]
).get(0).equals("BigDecimal")) {
Set expectedKeySet = expected.keySet();
Set actualKeySet = actual.keySet();
Iterator expectedIter = expectedKeySet.iterator();
while (expectedIter.hasNext()) {
BigDecimal expectedKey = (BigDecimal) expectedIter.next();
// compare keys
if (!TestUtil.containsBigDecimalKey(expectedKey, actualKeySet)) {
sbuf.append("\nFor element " + i +
" expected key = " + expectedKey +
" not found in actual Map. Actual keyset is "
+ actualKeySet.toString());
// compare values
} else {
String expectedVal = (String) expected.get(expectedKey);
String actualValue = (String)
actual.get(TestUtil.getBigDecimalKey(expectedKey,
actualKeySet));
if (!expectedVal.equals(actualValue)) {
sbuf.append("\nFor element " + i +
" expected value = " + expectedVal +
" actual Value = " + actualValue);
}
}
}
}
else {
sbuf.append("\nFor element " + i + ", expected = " +
expected + ", actual = " + actual + " . ");
}
}
}
if (sbuf.length() > 0) {
fail(ASSERTION_FAILED,
"Expected and observed do not match!!" + sbuf.toString());
}
}
}
tck/src/java/org/apache/jdo/tck/models/fieldtypes/TestHashSetCollections.java 100664 14375 12500110373 27653 0 ustar mbouschen staff 0 0 /*
* 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.models.fieldtypes;
import java.math.BigDecimal;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.TreeSet;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.fieldtypes.HashSetCollections;
import org.apache.jdo.tck.pc.fieldtypes.SimpleClass;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Support of field type HashSet
*Keywords: model
*Assertion ID: A6.4.3-22.
*Assertion Description:
JDO implementations must support fields of the mutable object class
java.util.HashSet, and may choose to support them as
Second Class Objects or First Class Objects.
*/
public class TestHashSetCollections extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A6.4.3-22 (TestHashSetCollections) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(TestHashSetCollections.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
addTearDownClass(HashSetCollections.class);
addTearDownClass(SimpleClass.class);
}
/** */
public void test() {
pm = getPM();
runTest(pm);
pm.close();
pm = null;
}
/** */
void runTest(PersistenceManager pm)
{
Transaction tx = pm.currentTransaction();
HashSetCollections expectedValue = new HashSetCollections();
// turn on datastore transactions
tx.setOptimistic(false);
tx.begin();
HashSetCollections pi = new HashSetCollections();
pi.identifier = 1;
pm.makePersistent(pi);
Object oid = pm.getObjectId(pi);
// Provide initial set of values
setValues(pi, 1);
tx.commit();
// cache will be flushed
pi = null;
System.gc();
tx.begin();
setValues(expectedValue, 1);
checkValues(oid, expectedValue);
pi = (HashSetCollections) pm.getObjectById(oid, true);
// Provide new set of values
setValues(pi, 2);
tx.commit();
// cache will be flushed
pi = null;
System.gc();
tx.begin();
// check new values
setValues(expectedValue, 2);
checkValues(oid, expectedValue);
pi = (HashSetCollections) pm.getObjectById(oid, true);
tx.commit();
}
/** */
private void setValues(HashSetCollections collect, int order)
{
Collection value;
int n = collect.getLength();
for (int i = 0; i < n; ++i) {
String valueType = TestUtil.getFieldSpecs(
HashSetCollections.fieldSpecs[i]);
value = (Collection)TestUtil.makeNewVectorInstance(
valueType, order);
HashSet lvalue = new HashSet(value);
collect.set(i, lvalue);
if (debug)
logger.debug("Set " + i + "th value to: " + value.toString());
}
}
/** */
private void checkValues(Object oid, HashSetCollections expectedValue)
{
int i;
StringBuffer sbuf = new StringBuffer();
HashSetCollections pi = (HashSetCollections)
pm.getObjectById(oid, true);
int n = pi.getLength();
for (i = 0; i < n; ++i) {
HashSet expected = expectedValue.get(i);
HashSet actual = pi.get(i);
if (actual.size() != expected.size()) {
sbuf.append("\nFor element " + i + ", expected size = " +
expected.size() + ", actual size = " + actual.size()
+ " . ");
}
else if (! expected.equals(actual)) {
if (TestUtil.getFieldSpecs(HashSetCollections.fieldSpecs[i]
).equals("BigDecimal")) {
// sort values for comparison
TreeSet expectedTS = new TreeSet(expected);
TreeSet actualTS = new TreeSet(actual);
Iterator expectedIter = expectedTS.iterator();
Iterator actualIter = actualTS.iterator();
for (int j=0; j < expectedTS.size(); j++) {
BigDecimal bigDecExpected =
(BigDecimal)(expectedIter.next());
BigDecimal bigDecActual =
(BigDecimal)(actualIter.next());
bigDecActual.setScale(bigDecExpected.scale());
if ((bigDecExpected.compareTo(bigDecActual)) != 0) {
sbuf.append("\nFor element " + i + "(" + j +
"), expected = " + bigDecExpected +
", actual = " + bigDecActual);
}
}
}
else {
sbuf.append("\nFor element " + i + ", expected = " +
expected + ", actual = " + actual + " . ");
}
}
}
if (sbuf.length() > 0) {
fail(ASSERTION_FAILED,
"Expected and observed do not match!!" + sbuf.toString());
}
}
}
tck/src/java/org/apache/jdo/tck/models/fieldtypes/TestHashtableStringKeyCollections.java 100664 15577 12500110373 32054 0 ustar mbouschen staff 0 0 /*
* 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.models.fieldtypes;
import java.math.BigDecimal;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import java.util.Vector;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.fieldtypes.HashtableStringKeyCollections;
import org.apache.jdo.tck.pc.fieldtypes.SimpleClass;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Support of field type Hashtable, varying value type
*Keywords: model
*Assertion ID: A6.4.3-25.
*Assertion Description:
If the Hashtable optional feature is supported, then JDO implementation must
support fields of the mutable object class Hashtable,
supporting them as Second Class Objects or First Class Objects.
*/
public class TestHashtableStringKeyCollections extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A6.4.3-25 (TestHashtableStringKeyCollections) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(TestHashtableStringKeyCollections.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
addTearDownClass(HashtableStringKeyCollections.class);
addTearDownClass(SimpleClass.class);
}
/** */
public void test() {
pm = getPM();
runTest(pm);
pm.close();
pm = null;
}
/** */
void runTest(PersistenceManager pm)
{
if (!isHashtableSupported()) {
if (debug)
logger.debug("JDO Implementation does not support " +
"the optional feature Hashtable");
return;
}
Transaction tx = pm.currentTransaction();
HashtableStringKeyCollections expectedValue =
new HashtableStringKeyCollections();
// turn on datastore transactions
tx.setOptimistic(false);
tx.begin();
HashtableStringKeyCollections pi =
new HashtableStringKeyCollections();
pi.identifier = 1;
pm.makePersistent(pi);
Object oid = pm.getObjectId(pi);
// Provide initial set of values
setValues(pi, 1);
tx.commit();
// cache will be flushed
pi = null;
System.gc();
tx.begin();
setValues(expectedValue, 1);
checkValues(oid, expectedValue);
pi = (HashtableStringKeyCollections) pm.getObjectById(oid, true);
// Provide new set of values -- reverse the keys and values
setValues(pi, 2);
tx.commit();
// cache will be flushed
pi = null;
System.gc();
tx.begin();
setValues(expectedValue, 2);
// check new values
checkValues(oid, expectedValue);
tx.commit();
}
/** */
private void setValues(HashtableStringKeyCollections collect, int order)
{
int keyOrder = order;
int valueOrder = (order == 1) ? 2 : 1; // why??
int n = collect.getLength();
for (int i = 0; i < n; ++i) {
Vector fieldSpecs = TestUtil.getFieldSpecsForMap(
HashtableStringKeyCollections.fieldSpecs[i]);
Vector key = TestUtil.makeNewVectorInstance(
(String)fieldSpecs.get(0), keyOrder);
Vector value = TestUtil.makeNewVectorInstance(
(String)fieldSpecs.get(1), valueOrder);
Hashtable map = new Hashtable();
for (int j = 0; j< key.size(); j++) {
map.put(key.get(j), value.get(j));
}
collect.set(i, map);
if (debug)
logger.debug("Set " + i + "th value to: " + map.toString());
}
}
/** */
private void checkValues(Object oid,
HashtableStringKeyCollections expectedValue)
{
StringBuffer sbuf = new StringBuffer();
HashtableStringKeyCollections pi = (HashtableStringKeyCollections)
pm.getObjectById(oid, true);
int n = pi.getLength();
for (int i = 0; i < n; ++i) {
Hashtable expected = expectedValue.get(i);
Hashtable actual = pi.get(i);
if (actual.size() != expected.size()) {
sbuf.append("\nFor element " + i + ", expected size = " +
expected.size() + ", actual size = " + actual.size()
+ " . ");
}
else if (! expected.equals(actual)) {
if (TestUtil.getFieldSpecsForMap(
HashtableStringKeyCollections.fieldSpecs[i]
).get(1).equals("BigDecimal")) {
Set keys = expected.keySet();
Iterator iter = keys.iterator();
while (iter.hasNext()) {
Object nextKey = iter.next();
BigDecimal expectedMapValue =
(BigDecimal)expected.get(nextKey);
BigDecimal actualMapValue =
(BigDecimal)actual.get(nextKey);
if ((expectedMapValue.compareTo(actualMapValue) != 0)) {
sbuf.append("\nFor element " + i + "("
+ (String)nextKey +
"), expected = " + expectedMapValue +
", actual = " + actualMapValue + " . ");
}
}
}
else {
sbuf.append("\nFor element " + i + ", expected = " +
expected + ", actual = " + actual + " . ");
}
}
}
if (sbuf.length() > 0) {
fail(ASSERTION_FAILED,
"Expected and observed do not match!!" + sbuf.toString());
}
}
}
tck/src/java/org/apache/jdo/tck/models/fieldtypes/TestHashtableStringValueCollections.java 100664 16661 12500110373 32373 0 ustar mbouschen staff 0 0 /*
* 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.models.fieldtypes;
import java.math.BigDecimal;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Set;
import java.util.Vector;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.fieldtypes.HashtableStringValueCollections;
import org.apache.jdo.tck.pc.fieldtypes.SimpleClass;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Support of field type Hashtable, varying key type
*Keywords: model
*Assertion ID: A6.4.3-25.
*Assertion Description:
If the Hashtable optional feature is supported, then JDO implementation must
support fields of the mutable object class Hashtable,
supporting them as Second Class Objects or First Class Objects.
*/
public class TestHashtableStringValueCollections extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A6.4.3-25 (TestHashtableStringValueCollections) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(TestHashtableStringValueCollections.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
addTearDownClass(HashtableStringValueCollections.class);
addTearDownClass(SimpleClass.class);
}
/** */
public void test() {
pm = getPM();
runTest(pm);
pm.close();
pm = null;
}
/** */
void runTest(PersistenceManager pm) {
if (!isHashtableSupported()) {
if (debug)
logger.debug("JDO Implementation does not support " +
"the optional feature Hashtable");
return;
}
Transaction tx = pm.currentTransaction();
HashtableStringValueCollections expectedValue =
new HashtableStringValueCollections();
// turn on datastore transactions
tx.setOptimistic(false);
tx.begin();
HashtableStringValueCollections pi =
new HashtableStringValueCollections();
pi.identifier = 1;
pm.makePersistent(pi);
Object oid = pm.getObjectId(pi);
// Provide initial set of values
setValues(pi, 1);
tx.commit();
// cache will be flushed
pi = null;
System.gc();
tx.begin();
setValues(expectedValue, 1);
checkValues(oid, expectedValue);
pi = (HashtableStringValueCollections) pm.getObjectById(oid, true);
setValues(pi, 2);
tx.commit();
// cache will be flushed
pi = null;
System.gc();
tx.begin();
// check new values
setValues(expectedValue, 2);
checkValues(oid, expectedValue);
tx.commit();
}
/** */
private void setValues(HashtableStringValueCollections collect, int order)
{
int keyOrder = order;
int valueOrder = (order == 1) ? 2 : 1; // why??
int n = collect.getLength();
for (int i = 0; i < n; ++i) {
Vector fieldSpecs = TestUtil.getFieldSpecsForMap(
HashtableStringValueCollections.fieldSpecs[i]);
Vector key = TestUtil.makeNewVectorInstance(
(String)fieldSpecs.get(0), keyOrder);
Vector value = TestUtil.makeNewVectorInstance(
(String)fieldSpecs.get(1), valueOrder);
Hashtable map = new Hashtable();
for (int j = 0; j< key.size(); j++) {
map.put(key.get(j), value.get(j));
}
collect.set(i, map);
if (debug)
logger.debug("Set " + i + "th value to: " + map.toString());
}
}
/** */
private void checkValues(Object oid,
HashtableStringValueCollections expectedValue)
{
StringBuffer sbuf = new StringBuffer();
HashtableStringValueCollections pi = (HashtableStringValueCollections)
pm.getObjectById(oid, true);
int n = pi.getLength();
for (int i = 0; i < n; ++i) {
Hashtable expected = expectedValue.get(i);
Hashtable actual = pi.get(i);
if (actual.size() != expected.size()) {
sbuf.append("\nFor element " + i + ", expected size = " +
expected.size() + ", actual size = " + actual.size()
+ " . ");
}
else if (! expected.equals(actual)) {
if (TestUtil.getFieldSpecsForMap(
HashtableStringValueCollections.fieldSpecs[i]
).get(0).equals("BigDecimal")) {
Set expectedKeySet = expected.keySet();
Set actualKeySet = actual.keySet();
Iterator expectedIter = expectedKeySet.iterator();
while (expectedIter.hasNext()) {
BigDecimal expectedKey = (BigDecimal) expectedIter.next();
// compare keys
if (!TestUtil.containsBigDecimalKey(expectedKey, actualKeySet)) {
sbuf.append("\nFor element " + i +
" expected key = " + expectedKey +
" not found in actual Map. Actual keyset is "
+ actualKeySet.toString());
// compare values
} else {
String expectedVal = (String) expected.get(expectedKey);
String actualValue = (String)
actual.get(TestUtil.getBigDecimalKey(expectedKey,
actualKeySet));
if (!expectedVal.equals(actualValue)) {
sbuf.append("\nFor element " + i +
" expected value = " + expectedVal +
" actual Value = " + actualValue);
}
}
}
}
else {
sbuf.append("\nFor element " + i + ", expected = " +
expected + ", actual = " + actual + " . ");
}
}
}
if (sbuf.length() > 0) {
fail(ASSERTION_FAILED,
"Expected and observed do not match!!" + sbuf.toString());
}
}
}
tck/src/java/org/apache/jdo/tck/models/fieldtypes/TestLinkedListCollections.java 100664 14545 12500110373 30355 0 ustar mbouschen staff 0 0 /*
* 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.models.fieldtypes;
import java.math.BigDecimal;
import java.util.Collection;
import java.util.ListIterator;
import java.util.LinkedList;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.fieldtypes.LinkedListCollections;
import org.apache.jdo.tck.pc.fieldtypes.SimpleClass;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Support of field type LinkedList
*Keywords: model
*Assertion ID: A6.4.3-26.
*Assertion Description:
If the LinkedList optional feature is supported, then JDO implementation
must support fields of the mutable object class LinkedList,
supporting them as Second Class Objects or First Class Objects.
*/
public class TestLinkedListCollections extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A6.4.3-26 (TestLinkedListCollections) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(TestLinkedListCollections.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
addTearDownClass(LinkedListCollections.class);
addTearDownClass(SimpleClass.class);
}
/** */
public void test() {
pm = getPM();
runTest(pm);
pm.close();
pm = null;
}
/** */
void runTest(PersistenceManager pm)
{
if (!isLinkedListSupported()) {
if (debug)
logger.debug("JDO Implementation does not support " +
"the optional feature LinkedList");
return;
}
Transaction tx = pm.currentTransaction();
LinkedListCollections expectedValue = new LinkedListCollections();
// turn on datastore transactions
tx.setOptimistic(false);
tx.begin();
LinkedListCollections pi = new LinkedListCollections();
pi.identifier = 1;
pm.makePersistent(pi);
Object oid = pm.getObjectId(pi);
// Provide initial set of values
setValues(pi, 1);
tx.commit();
// cache will be flushed
pi = null;
System.gc();
tx.begin();
setValues(expectedValue, 1);
// check if persistent fields have values set
checkValues(oid, expectedValue);
pi = (LinkedListCollections) pm.getObjectById(oid, true);
// Provide new set of values
setValues(pi, 2);
tx.commit();
// cache will be flushed
pi = null;
System.gc();
tx.begin();
// check new values
setValues(expectedValue, 2);
checkValues(oid, expectedValue);
tx.commit();
}
/** */
private void setValues(LinkedListCollections collect, int order)
{
Collection value;
int n = collect.getLength();
for (int i = 0; i < n; ++i) {
String valueType = TestUtil.getFieldSpecs(
LinkedListCollections.fieldSpecs[i]);
value = (Collection)TestUtil.makeNewVectorInstance(
valueType, order);
LinkedList lvalue = new LinkedList(value);
collect.set(i, lvalue);
if (debug)
logger.debug("Set " + i + "th value to: " + value.toString());
}
}
/** */
private void checkValues(Object oid, LinkedListCollections expectedValue)
{
int i;
StringBuffer sbuf = new StringBuffer();
LinkedListCollections pi = (LinkedListCollections)
pm.getObjectById(oid, true);
int n = pi.getLength();
for (i = 0; i < n; ++i) {
LinkedList expected = expectedValue.get(i);
LinkedList actual = pi.get(i);
if (actual.size() != expected.size()) {
sbuf.append("\nFor element " + i + ", expected size = " +
expected.size() + ", actual size = " + actual.size()
+ " . ");
}
else if (! expected.equals(actual)) {
if (TestUtil.getFieldSpecs(LinkedListCollections.fieldSpecs[i]
).equals("BigDecimal")) {
ListIterator expectedIT = expected.listIterator();
ListIterator actualIt = actual.listIterator();
int index = 0;
while (expectedIT.hasNext()) {
BigDecimal bigDecExpected =
(BigDecimal)(expectedIT.next());
BigDecimal bigDecActual = (BigDecimal)(actualIt.next());
if ((bigDecExpected.compareTo(bigDecActual)) != 0) {
sbuf.append("\nFor element " + i + "(" + index +
"), expected = " + bigDecExpected +
", actual = " + bigDecActual);
}
index++;
}
}
else {
sbuf.append("\nFor element " + i + ", expected = " +
expected + ", actual = " + actual + " . ");
}
} }
if (sbuf.length() > 0) {
fail(ASSERTION_FAILED,
"Expected and observed do not match!!" + sbuf.toString());
}
}
}
tck/src/java/org/apache/jdo/tck/models/fieldtypes/TestListCollections.java 100664 14610 12500110373 27217 0 ustar mbouschen staff 0 0 /*
* 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.models.fieldtypes;
import java.math.BigDecimal;
import java.util.Collection;
import java.util.Vector;
import java.util.List;
import java.util.ListIterator;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.fieldtypes.ListCollections;
import org.apache.jdo.tck.pc.fieldtypes.SimpleClass;
import org.apache.jdo.tck.transactions.Commit;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Support of field type List
*Keywords: model
*Assertion ID: A6.4.3-36.
*Assertion Description:
If the List optional feature is supported, then JDO implementations must
support fields of the interface type List,
supporting them as Second Class Objects or First Class Objects.
*/
public class TestListCollections extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A6.4.3-36 (Commit) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(Commit.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
addTearDownClass(ListCollections.class);
addTearDownClass(SimpleClass.class);
}
/** */
public void test() {
pm = getPM();
runTest(pm);
pm.close();
pm = null;
}
/** */
void runTest(PersistenceManager pm) {
if (!isListSupported()) {
if (debug)
logger.debug("JDO Implementation does not support " +
"the optional feature List");
return;
}
if (!isLinkedListSupported() && !isArrayListSupported()) {
fail(ASSERTION_FAILED,
"JDO Implementation supports List, but neither " +
"ArrayList nor LinkedList.");
}
Transaction tx = pm.currentTransaction();
ListCollections expectedValue = new ListCollections();
// turn on datastore transactions
tx.setOptimistic(false);
tx.begin();
ListCollections pi = new ListCollections();
pi.identifier = 1;
pm.makePersistent(pi);
Object oid = pm.getObjectId(pi);
// Provide initial set of values
setValues(pi, 1);
tx.commit();
// cache will be flushed
pi = null;
System.gc();
tx.begin();
setValues(expectedValue, 1);
// check if persistent fields have values set
checkValues(oid, expectedValue);
pi = (ListCollections) pm.getObjectById(oid, true);
// Provide new set of values
setValues(pi, 2);
tx.commit();
// cache will be flushed
pi = null;
System.gc();
tx.begin();
// check new values
setValues(expectedValue, 2);
checkValues(oid, expectedValue);
tx.commit();
}
/** */
private void setValues(ListCollections collect, int order)
{
Vector value;
int n = collect.getLength();
for (int i = 0; i < n; ++i) {
String valueType = TestUtil.getFieldSpecs(
ListCollections.fieldSpecs[i]);
value = TestUtil.makeNewVectorInstance(valueType, order);
collect.set( i, value);
if (debug)
logger.debug("Set " + i + "th value to: " + value.toString());
}
}
/** */
private void checkValues(Object oid, ListCollections expectedValue)
{
int i;
StringBuffer sbuf = new StringBuffer();
ListCollections pi = (ListCollections)
pm.getObjectById(oid, true);
int n = pi.getLength();
for (i = 0; i < n; ++i) {
List expected = expectedValue.get(i);
List actual = pi.get(i);
if (actual.size() != expected.size()) {
sbuf.append("\nFor element " + i + ", expected size = " +
expected.size() + ", actual size = " + actual.size()
+ " . ");
}
else if (! expected.equals(actual)) {
if (TestUtil.getFieldSpecs(ListCollections.fieldSpecs[i]
).equals("BigDecimal")) {
ListIterator expectedIt = expected.listIterator();
ListIterator actualIt = actual.listIterator();
int index = 0;
while (expectedIt.hasNext()) {
BigDecimal bigDecExpected =
(BigDecimal)(expectedIt.next());
BigDecimal bigDecActual = (BigDecimal)(actualIt.next());
if ((bigDecExpected.compareTo(bigDecActual)) != 0) {
sbuf.append("\nFor element " + i + "(" + index +
"), expected = " + bigDecExpected +
", actual = " + bigDecActual);
}
index++;
}
}
else {
sbuf.append("\nFor element " + i + ", expected = " +
expected + ", actual = " + actual + " . ");
}
}
}
if (sbuf.length() > 0) {
fail(ASSERTION_FAILED,
"Expected and observed do not match!!" + sbuf.toString());
}
}
}
tck/src/java/org/apache/jdo/tck/models/fieldtypes/TestMapStringKeyCollections.java 100664 15507 12500110373 30667 0 ustar mbouschen staff 0 0 /*
* 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.models.fieldtypes;
import java.math.BigDecimal;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;
import java.util.Map;
import java.util.Vector;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.fieldtypes.MapStringKeyCollections;
import org.apache.jdo.tck.pc.fieldtypes.SimpleClass;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Support of field type Map, varying value type
*Keywords: model
*Assertion ID: A6.4.3-35.
*Assertion Description:
If the Map optional feature is supported, then JDO implementations
must support fields of the interface type Map,
supporting them as Second Class Objects or First Class Objects.
*/
public class TestMapStringKeyCollections extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A6.4.3-35 (TestMapStringKeyCollections) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(TestMapStringKeyCollections.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
addTearDownClass(MapStringKeyCollections.class);
addTearDownClass(SimpleClass.class);
}
/** */
public void test() {
pm = getPM();
runTest(pm);
pm.close();
pm = null;
}
/** */
void runTest(PersistenceManager pm) {
if (!isMapSupported()) {
if (debug)
logger.debug("JDO Implementation does not support " +
"the optional feature Map");
return;
}
if (!isMapSupported() && !isTreeMapSupported()) {
fail(ASSERTION_FAILED,
"JDO Implementation supports Map, but neither " +
"Map nor TreeMap.");
}
Transaction tx = pm.currentTransaction();
MapStringKeyCollections expectedValue = new MapStringKeyCollections();
// turn on datastore transactions
tx.setOptimistic(false);
tx.begin();
MapStringKeyCollections pi = new MapStringKeyCollections();
pi.identifier = 1;
pm.makePersistent(pi);
Object oid = pm.getObjectId(pi);
// Provide initial set of values
setValues(pi, 1);
tx.commit();
// cache will be flushed
pi = null;
System.gc();
tx.begin();
setValues(expectedValue, 1);
checkValues(oid, expectedValue);
pi = (MapStringKeyCollections) pm.getObjectById(oid, true);
setValues(pi, 2);
tx.commit();
// cache will be flushed
pi = null;
System.gc();
tx.begin();
// check new values
setValues(expectedValue, 2);
checkValues(oid, expectedValue);
tx.commit();
}
/** */
private void setValues(MapStringKeyCollections collect, int order)
{
int keyOrder = order;
int valueOrder = (order == 1) ? 2 : 1; // why??
int n = collect.getLength();
for (int i = 0; i < n; ++i) {
Vector fieldSpecs = TestUtil.getFieldSpecsForMap(
MapStringKeyCollections.fieldSpecs[i]);
Vector key = TestUtil.makeNewVectorInstance(
(String)fieldSpecs.get(0), keyOrder);
Vector value = TestUtil.makeNewVectorInstance(
(String)fieldSpecs.get(1), valueOrder);
HashMap map = new HashMap();
for (int j = 0; j< key.size(); j++) {
map.put(key.get(j), value.get(j));
}
collect.set(i, map);
if (debug)
logger.debug("Set " + i + "th value to: " + map.toString());
}
}
/** */
private void checkValues(Object oid,
MapStringKeyCollections expectedValue)
{
StringBuffer sbuf = new StringBuffer();
MapStringKeyCollections pi = (MapStringKeyCollections)
pm.getObjectById(oid, true);
int n = pi.getLength();
for (int i = 0; i < n; ++i) {
Map expected = expectedValue.get(i);
Map actual = pi.get(i);
if (actual.size() != expected.size()) {
sbuf.append("\nFor element " + i + ", expected size = " +
expected.size() + ", actual size = " + actual.size()
+ " . ");
}
else if (! expected.equals(actual)) {
if (TestUtil.getFieldSpecsForMap(
MapStringKeyCollections.fieldSpecs[i]
).get(1).equals("BigDecimal")) {
Set keys = expected.keySet();
Iterator iter = keys.iterator();
while (iter.hasNext()) {
Object nextKey = iter.next();
BigDecimal expectedMapValue =
(BigDecimal)expected.get(nextKey);
BigDecimal actualMapValue =
(BigDecimal)actual.get(nextKey);
if ((expectedMapValue.compareTo(actualMapValue) != 0)) {
sbuf.append("\nFor element " + i + "("
+ (String)nextKey +
"), expected = " + expectedMapValue +
", actual = " + actualMapValue + " . ");
}
}
}
else {
sbuf.append("\nFor element " + i + ", expected = " +
expected + ", actual = " + actual + " . ");
}
}
}
if (sbuf.length() > 0) {
fail(ASSERTION_FAILED,
"Expected and observed do not match!!" + sbuf.toString());
}
}
}
tck/src/java/org/apache/jdo/tck/models/fieldtypes/TestMapStringValueCollections.java 100664 16761 12500110373 31216 0 ustar mbouschen staff 0 0 /*
* 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.models.fieldtypes;
import java.math.BigDecimal;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.Vector;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.fieldtypes.MapStringValueCollections;
import org.apache.jdo.tck.pc.fieldtypes.SimpleClass;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Support of field type Map, varying key type
*Keywords: model
*Assertion ID: A6.4.3-35.
*Assertion Description:
If the Map optional feature is supported, then JDO implementations
must support fields of the interface type Map,
supporting them as Second Class Objects or First Class Objects.
*/
public class TestMapStringValueCollections extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A6.4.3-35 (TestMapStringValueCollections) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(TestMapStringValueCollections.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
addTearDownClass(MapStringValueCollections.class);
addTearDownClass(SimpleClass.class);
}
/** */
public void test() {
pm = getPM();
runTest(pm);
pm.close();
pm = null;
}
/** */
void runTest(PersistenceManager pm) {
if (!isMapSupported()) {
if (debug)
logger.debug("JDO Implementation does not support " +
"the optional feature Map");
return;
}
if (!isMapSupported() && !isTreeMapSupported()) {
fail(ASSERTION_FAILED,
"JDO Implementation supports Map, but neither " +
"Map nor TreeMap.");
}
Transaction tx = pm.currentTransaction();
MapStringValueCollections expectedValue =
new MapStringValueCollections();
// turn on datastore transactions
tx.setOptimistic(false);
tx.begin();
MapStringValueCollections pi = new MapStringValueCollections();
pi.identifier = 1;
pm.makePersistent(pi);
Object oid = pm.getObjectId(pi);
// Provide initial set of values
setValues(pi, 1);
tx.commit();
// cache will be flushed
pi = null;
System.gc();
tx.begin();
setValues(expectedValue, 1);
checkValues(oid, expectedValue);
pi = (MapStringValueCollections) pm.getObjectById(oid, true);
setValues(pi, 2);
tx.commit();
// cache will be flushed
pi = null;
System.gc();
tx.begin();
// check new values
setValues(expectedValue, 2);
checkValues(oid, expectedValue);
tx.commit();
}
/** */
private void setValues(MapStringValueCollections collect, int order)
{
int keyOrder = order;
int valueOrder = (order == 1) ? 2 : 1; // why??
int n = collect.getLength();
for (int i = 0; i < n; ++i) {
Vector fieldSpecs = TestUtil.getFieldSpecsForMap(
MapStringValueCollections.fieldSpecs[i]);
Vector key = TestUtil.makeNewVectorInstance(
(String)fieldSpecs.get(0), keyOrder);
Vector value = TestUtil.makeNewVectorInstance(
(String)fieldSpecs.get(1), valueOrder);
HashMap map = new HashMap();
for (int j = 0; j< key.size(); j++) {
map.put(key.get(j), value.get(j));
}
collect.set(i, map);
if (debug)
logger.debug("Set " + i + "th value to: " + map.toString());
}
}
/** */
private void checkValues(Object oid,
MapStringValueCollections expectedValue)
{
StringBuffer sbuf = new StringBuffer();
MapStringValueCollections pi = (MapStringValueCollections)
pm.getObjectById(oid, true);
int n = pi.getLength();
for (int i = 0; i < n; ++i) {
Map expected = expectedValue.get(i);
Map actual = pi.get(i);
if (actual.size() != expected.size()) {
sbuf.append("\nFor element " + i + ", expected size = " +
expected.size() + ", actual size = " + actual.size()
+ " . ");
}
else if (! expected.equals(actual)) {
if (TestUtil.getFieldSpecsForMap(
MapStringValueCollections.fieldSpecs[i]
).get(0).equals("BigDecimal")) {
Set expectedKeySet = expected.keySet();
Set actualKeySet = actual.keySet();
Iterator expectedIter = expectedKeySet.iterator();
while (expectedIter.hasNext()) {
BigDecimal expectedKey = (BigDecimal) expectedIter.next();
// compare keys
if (!TestUtil.containsBigDecimalKey(expectedKey, actualKeySet)) {
sbuf.append("\nFor element " + i +
" expected key = " + expectedKey +
" not found in actual Map. Actual keyset is "
+ actualKeySet.toString());
// compare values
} else {
String expectedVal = (String) expected.get(expectedKey);
String actualValue = (String)
actual.get(TestUtil.getBigDecimalKey(expectedKey,
actualKeySet));
if (!expectedVal.equals(actualValue)) {
sbuf.append("\nFor element " + i +
" expected value = " + expectedVal +
" actual Value = " + actualValue);
}
}
}
}
else {
sbuf.append("\nFor element " + i + ", expected = " +
expected + ", actual = " + actual + " . ");
}
}
}
if (sbuf.length() > 0) {
fail(ASSERTION_FAILED,
"Expected and observed do not match!!" + sbuf.toString());
}
}
}
tck/src/java/org/apache/jdo/tck/models/fieldtypes/TestSetCollections.java 100664 14270 12500110373 27041 0 ustar mbouschen staff 0 0 /*
* 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.models.fieldtypes;
import java.math.BigDecimal;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.fieldtypes.SetCollections;
import org.apache.jdo.tck.pc.fieldtypes.SimpleClass;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Support of field type Set.
*Keywords: model
*Assertion ID: A6.4.3-34.
*Assertion Description:
JDO implementations must support fields of the interface type
java.util.Set, and may choose to support them
as Second Class Objects or First Class Objects.
*/
public class TestSetCollections extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A6.4.3-34 (TestSetCollections) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(TestSetCollections.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
addTearDownClass(SetCollections.class);
addTearDownClass(SimpleClass.class);
}
/** */
public void test() {
pm = getPM();
runTest(pm);
pm.close();
pm = null;
}
/** */
void runTest(PersistenceManager pm) {
Transaction tx = pm.currentTransaction();
SetCollections expectedValue = new SetCollections();
// turn on datastore transactions
tx.setOptimistic(false);
tx.begin();
SetCollections pi = new SetCollections();
pi.identifier = 1;
pm.makePersistent(pi);
Object oid = pm.getObjectId(pi);
// Provide initial set of values
setValues(pi, 1);
tx.commit();
// cache will be flushed
pi = null;
System.gc();
tx.begin();
setValues(expectedValue, 1);
// check if persistent fields have values set
checkValues(oid, expectedValue);
pi = (SetCollections) pm.getObjectById(oid, true);
// Provide new set of values
setValues(pi, 2);
tx.commit();
// cache will be flushed
pi = null;
System.gc();
tx.begin();
// check new values
setValues(expectedValue, 2);
checkValues(oid, expectedValue);
tx.commit();
}
/** */
private void setValues(SetCollections collect, int order)
{
Collection value;
int n = collect.getLength();
for (int i = 0; i < n; ++i) {
String valueType = TestUtil.getFieldSpecs(
SetCollections.fieldSpecs[i]);
value = (Collection)TestUtil.makeNewVectorInstance(
valueType, order);
Set lvalue = new HashSet(value);
collect.set(i, lvalue);
if (debug)
logger.debug("Set " + i + "th value to: " + value.toString());
}
}
/** */
private void checkValues(Object oid, SetCollections expectedValue)
{
int i;
StringBuffer sbuf = new StringBuffer();
SetCollections pi = (SetCollections)
pm.getObjectById(oid, true);
int n = pi.getLength();
for (i = 0; i < n; ++i) {
Set expected = expectedValue.get(i);
Set actual = pi.get(i);
if (actual.size() != expected.size()) {
sbuf.append("\nFor element " + i + ", expected size = " +
expected.size() + ", actual size = " + actual.size()
+ " . ");
}
else if (! expected.equals(actual)) {
if (TestUtil.getFieldSpecs(SetCollections.fieldSpecs[i]
).equals("BigDecimal")) {
// sort values for comparison
TreeSet expectedTS = new TreeSet(expected);
TreeSet actualTS = new TreeSet(actual);
Iterator expectedIter = expectedTS.iterator();
Iterator actualIter = actualTS.iterator();
for (int j=0; j < expectedTS.size(); j++) {
BigDecimal bigDecExpected =
(BigDecimal)(expectedIter.next());
BigDecimal bigDecActual =
(BigDecimal)(actualIter.next());
bigDecActual.setScale(bigDecExpected.scale());
if ((bigDecExpected.compareTo(bigDecActual)) != 0) {
sbuf.append("\nFor element " + i + "(" + j +
"), expected = " + bigDecExpected +
", actual = " + bigDecActual);
}
}
}
else {
sbuf.append("\nFor element " + i + ", expected = " +
expected + ", actual = " + actual + " . ");
}
}
}
if (sbuf.length() > 0) {
fail(ASSERTION_FAILED,
"Expected and observed do not match!!" + sbuf.toString());
}
}
}
tck/src/java/org/apache/jdo/tck/models/fieldtypes/TestTreeMapStringKeyCollections.java 100664 15347 12500110373 31511 0 ustar mbouschen staff 0 0 /*
* 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.models.fieldtypes;
import java.math.BigDecimal;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import java.util.TreeMap;
import java.util.Vector;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.fieldtypes.TreeMapStringKeyCollections;
import org.apache.jdo.tck.pc.fieldtypes.SimpleClass;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Support of field type TreeMap, varying value type
*Keywords: model
*Assertion ID: A6.4.3-27.
*Assertion Description:
If the TreeMap optional feature is supported, then JDO implementation
must support fields of the mutable object class TreeMap,
supporting them as Second Class Objects or First Class Objects.
*/
public class TestTreeMapStringKeyCollections extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A6.4.3-27 (TestTreeMapStringKeyCollections) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(TestTreeMapStringKeyCollections.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
addTearDownClass(TreeMapStringKeyCollections.class);
addTearDownClass(SimpleClass.class);
}
/** */
public void test() {
pm = getPM();
runTest(pm);
pm.close();
pm = null;
}
/** */
void runTest(PersistenceManager pm) {
if (!isTreeMapSupported()) {
if (debug)
logger.debug("JDO Implementation does not support " +
"the optional feature TreeMap");
return;
}
Transaction tx = pm.currentTransaction();
TreeMapStringKeyCollections expectedValue =
new TreeMapStringKeyCollections();
// turn on datastore transactions
tx.setOptimistic(false);
tx.begin();
TreeMapStringKeyCollections pi = new TreeMapStringKeyCollections();
pi.identifier = 1;
pm.makePersistent(pi);
Object oid = pm.getObjectId(pi);
// Provide initial set of values
setValues(pi, 1);
tx.commit();
// cache will be flushed
pi = null;
System.gc();
tx.begin();
setValues(expectedValue, 1);
checkValues(oid, expectedValue);
pi = (TreeMapStringKeyCollections) pm.getObjectById(oid, true);
setValues(pi, 2);
tx.commit();
// cache will be flushed
pi = null;
System.gc();
tx.begin();
// check new values
setValues(expectedValue, 2);
checkValues(oid, expectedValue);
tx.commit();
}
/** */
private void setValues(TreeMapStringKeyCollections collect, int order)
{
int keyOrder = order;
int valueOrder = (order == 1) ? 2 : 1; // why??
int n = collect.getLength();
for (int i = 0; i < n; ++i) {
Vector fieldSpecs = TestUtil.getFieldSpecsForMap(
TreeMapStringKeyCollections.fieldSpecs[i]);
Vector key = TestUtil.makeNewVectorInstance(
(String)fieldSpecs.get(0), keyOrder);
Vector value = TestUtil.makeNewVectorInstance(
(String)fieldSpecs.get(1), valueOrder);
TreeMap map = new TreeMap();
for (int j = 0; j< key.size(); j++) {
map.put(key.get(j), value.get(j));
}
collect.set(i, map);
if (debug)
logger.debug("Set " + i + "th value to: " + map.toString());
}
}
/** */
private void checkValues(Object oid,
TreeMapStringKeyCollections expectedValue)
{
StringBuffer sbuf = new StringBuffer();
TreeMapStringKeyCollections pi = (TreeMapStringKeyCollections)
pm.getObjectById(oid, true);
int n = pi.getLength();
for (int i = 0; i < n; ++i) {
TreeMap expected = expectedValue.get(i);
TreeMap actual = pi.get(i);
if (actual.size() != expected.size()) {
sbuf.append("\nFor element " + i + ", expected size = " +
expected.size() + ", actual size = " + actual.size()
+ " . ");
}
else if (! expected.equals(actual)) {
if (TestUtil.getFieldSpecsForMap(
TreeMapStringKeyCollections.fieldSpecs[i]
).get(1).equals("BigDecimal")) {
Set keys = expected.keySet();
Iterator iter = keys.iterator();
while (iter.hasNext()) {
Object nextKey = iter.next();
BigDecimal expectedMapValue =
(BigDecimal)expected.get(nextKey);
BigDecimal actualMapValue =
(BigDecimal)actual.get(nextKey);
if ((expectedMapValue.compareTo(actualMapValue) != 0)) {
sbuf.append("\nFor element " + i + "("
+ (String)nextKey +
"), expected = " + expectedMapValue +
", actual = " + actualMapValue + " . ");
}
}
}
else {
sbuf.append("\nFor element " + i + ", expected = " +
expected + ", actual = " + actual + " . ");
}
}
}
if (sbuf.length() > 0) {
fail(ASSERTION_FAILED,
"Expected and observed do not match!!" + sbuf.toString());
}
}
}
tck/src/java/org/apache/jdo/tck/models/fieldtypes/TestTreeMapStringValueCollections.java 100664 16565 12500110373 32040 0 ustar mbouschen staff 0 0 /*
* 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.models.fieldtypes;
import java.math.BigDecimal;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeMap;
import java.util.Vector;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.fieldtypes.TreeMapStringValueCollections;
import org.apache.jdo.tck.pc.fieldtypes.SimpleClass;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Support of field type TreeMap, varying key type
*Keywords: model
*Assertion ID: A6.4.3-27.
*Assertion Description:
If the TreeMap optional feature is supported, then JDO implementation
must support fields of the mutable object class TreeMap,
supporting them as Second Class Objects or First Class Objects.
*/
public class TestTreeMapStringValueCollections extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A6.4.3-27 (TestTreeMapStringValueCollections) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(TestTreeMapStringValueCollections.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
addTearDownClass(TreeMapStringValueCollections.class);
addTearDownClass(SimpleClass.class);
}
/** */
public void test() {
pm = getPM();
runTest(pm);
pm.close();
pm = null;
}
/** */
void runTest(PersistenceManager pm) {
if (!isTreeMapSupported()) {
if (debug)
logger.debug("JDO Implementation does not support " +
"the optional feature TreeMap");
return;
}
Transaction tx = pm.currentTransaction();
TreeMapStringValueCollections expectedValue =
new TreeMapStringValueCollections();
// turn on datastore transactions
tx.setOptimistic(false);
tx.begin();
TreeMapStringValueCollections pi = new TreeMapStringValueCollections();
pi.identifier = 1;
pm.makePersistent(pi);
Object oid = pm.getObjectId(pi);
// Provide initial set of values
setValues(pi, 1);
tx.commit();
// cache will be flushed
pi = null;
System.gc();
tx.begin();
setValues(expectedValue, 1);
checkValues(oid, expectedValue);
pi = (TreeMapStringValueCollections) pm.getObjectById(oid, true);
setValues(pi, 2);
tx.commit();
// cache will be flushed
pi = null;
System.gc();
tx.begin();
// check new values
setValues(expectedValue, 2);
checkValues(oid, expectedValue);
tx.commit();
}
/** */
private void setValues(TreeMapStringValueCollections collect, int order)
{
int keyOrder = order;
int valueOrder = (order == 1) ? 2 : 1; // why??
int n = collect.getLength();
for (int i = 0; i < n; ++i) {
Vector fieldSpecs = TestUtil.getFieldSpecsForMap(
TreeMapStringValueCollections.fieldSpecs[i]);
Vector key = TestUtil.makeNewVectorInstance(
(String)fieldSpecs.get(0), keyOrder);
Vector value = TestUtil.makeNewVectorInstance(
(String)fieldSpecs.get(1), valueOrder);
TreeMap map = new TreeMap();
for (int j = 0; j< key.size(); j++) {
map.put(key.get(j), value.get(j));
}
collect.set(i, map);
if (debug)
logger.debug("Set " + i + "th value to: " + map.toString());
}
}
/** */
private void checkValues(Object oid,
TreeMapStringValueCollections expectedValue)
{
StringBuffer sbuf = new StringBuffer();
TreeMapStringValueCollections pi = (TreeMapStringValueCollections)
pm.getObjectById(oid, true);
int n = pi.getLength();
for (int i = 0; i < n; ++i) {
TreeMap expected = expectedValue.get(i);
TreeMap actual = pi.get(i);
if (actual.size() != expected.size()) {
sbuf.append("\nFor element " + i + ", expected size = " +
expected.size() + ", actual size = " + actual.size()
+ " . ");
}
else if (! expected.equals(actual)) {
if (TestUtil.getFieldSpecsForMap(
TreeMapStringValueCollections.fieldSpecs[i]
).get(0).equals("BigDecimal")) {
Set expectedKeySet = expected.keySet();
Set actualKeySet = actual.keySet();
Iterator expectedIter = expectedKeySet.iterator();
while (expectedIter.hasNext()) {
BigDecimal expectedKey = (BigDecimal) expectedIter.next();
// compare keys
if (!TestUtil.containsBigDecimalKey(expectedKey, actualKeySet)) {
sbuf.append("\nFor element " + i +
" expected key = " + expectedKey +
" not found in actual Map. Actual keyset is "
+ actualKeySet.toString());
// compare values
} else {
String expectedVal = (String) expected.get(expectedKey);
String actualValue = (String)
actual.get(TestUtil.getBigDecimalKey(expectedKey,
actualKeySet));
if (!expectedVal.equals(actualValue)) {
sbuf.append("\nFor element " + i +
" expected value = " + expectedVal +
" actual Value = " + actualValue);
}
}
}
}
else {
sbuf.append("\nFor element " + i + ", expected = " +
expected + ", actual = " + actual + " . ");
}
}
}
if (sbuf.length() > 0) {
fail(ASSERTION_FAILED,
"Expected and observed do not match!!" + sbuf.toString());
}
}
}
tck/src/java/org/apache/jdo/tck/models/fieldtypes/TestTreeSetCollections.java 100664 12745 12500110373 27666 0 ustar mbouschen staff 0 0 /*
* 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.models.fieldtypes;
import java.util.Collection;
import java.util.TreeSet;
import java.util.Vector;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.fieldtypes.TreeSetCollections;
import org.apache.jdo.tck.pc.fieldtypes.SimpleClass;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Support of field type TreeSet.
*Keywords: model
*Assertion ID: A6.4.3-28.
*Assertion Description:
If the TreeSet optional feature is supported, then JDO implementation
must support fields of the mutable object class TreeSet,
supporting them as Second Class Objects or First Class Objects.
*/
public class TestTreeSetCollections extends JDO_Test {
private PersistenceManager pm;
private Transaction tx;
private static String prefix = "TestTreeSetCollections: ";
private TreeSet defaultValue; // do not initialize, should be 0 for int
/** */
private static final String ASSERTION_FAILED =
"Assertion A6.4.3-28 (TestTreeSetCollections) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(TestTreeSetCollections.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
addTearDownClass(TreeSetCollections.class);
addTearDownClass(SimpleClass.class);
}
/** */
public void test() {
pm = getPM();
runTest(pm);
pm.close();
pm = null;
}
/** */
void runTest(PersistenceManager pm) {
if (!isTreeSetSupported()) {
if (debug)
logger.debug("JDO Implementation does not support " +
"the optional feature TreeSet");
return;
}
Transaction tx = pm.currentTransaction();
TreeSetCollections expectedValue = new TreeSetCollections();
// turn on datastore transactions
tx.setOptimistic(false);
tx.begin();
TreeSetCollections pi = new TreeSetCollections();
pi.identifier = 1;
pm.makePersistent(pi);
Object oid = pm.getObjectId(pi);
// Provide initial set of values
setValues(pi, 1);
tx.commit();
// cache will be flushed
pi = null;
System.gc();
tx.begin();
setValues(expectedValue, 1);
// check if persistent fields have values set
checkValues(oid, expectedValue);
pi = (TreeSetCollections) pm.getObjectById(oid, true);
// Provide new set of values
setValues(pi, 2);
tx.commit();
// cache will be flushed
pi = null;
System.gc();
tx.begin();
// check new values
setValues(expectedValue, 2);
checkValues(oid, expectedValue);
tx.commit();
}
/** */
private void setValues(TreeSetCollections collect, int order)
{
Vector value;
int n = collect.getLength();
for (int i = 0; i < n; ++i) {
String valueType = TestUtil.getFieldSpecs(
TreeSetCollections.fieldSpecs[i]);
value = TestUtil.makeNewVectorInstance(valueType, order);
TreeSet treeSet = new TreeSet((Collection)value);
collect.set(i, treeSet);
if (debug)
logger.debug("Set " + i + "th value to: " + treeSet.toString());
}
}
/** */
private void checkValues(Object oid, TreeSetCollections expectedValue)
{
StringBuffer sbuf = new StringBuffer();
TreeSetCollections pi = (TreeSetCollections)
pm.getObjectById(oid, true);
int n = pi.getLength();
for (int i = 0; i < n; ++i) {
Collection expected = expectedValue.get(i);
Collection actual = pi.get(i);
if (actual.size() != expected.size()) {
sbuf.append("\nFor element " + i + ", expected size = " +
expected.size() + ", actual size = " + actual.size()
+ " . ");
continue;
}
if (! expected.equals(actual)) {
sbuf.append("\nFor element " + i + ", expected = " +
expected + ", actual = " + actual + " . ");
}
}
if (sbuf.length() > 0) {
fail(ASSERTION_FAILED,
"Expected and observed do not match!!" + sbuf.toString());
}
}
}
tck/src/java/org/apache/jdo/tck/models/fieldtypes/TestUtil.java 100664 40243 12500110373 25023 0 ustar mbouschen staff 0 0 /*
* 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.models.fieldtypes;
import java.util.*;
import java.math.*;
import org.apache.jdo.tck.pc.fieldtypes.AllTypes;
import org.apache.jdo.tck.pc.fieldtypes.SimpleClass;
import org.apache.jdo.tck.pc.fieldtypes.SimpleEnum;
public class TestUtil {
public TestUtil() {
}
//gets the value type for fields of a collection class
public static String getFieldSpecs(String field) {
//sample field =public Collection CollectionOfObject0
//look for last space and get the String before the numbers
String valueType = "";
int indexOfLastSpace = field.lastIndexOf(" ");
String fieldName = field.substring(indexOfLastSpace);
int indexOfValueType = fieldName.indexOf("Of") + 2;
String valueTypeWithNumber = fieldName.substring(indexOfValueType);
int lastIndexOfValueType = 0;
for (int i=valueTypeWithNumber.length() -1; i>=0; i--) {
if (Character.isDigit(valueTypeWithNumber.charAt(i))) {
continue;
} else {
lastIndexOfValueType = i;
break;
}
}
valueType = valueTypeWithNumber.substring(0, lastIndexOfValueType+1);
return valueType;
}
//gets the key type and value type for fields of a Map class
public static Vector getFieldSpecsForMap(String field) {
//sample field =public HashMap HashMapOfObject_Object0
//fieldType -- look for the last space and get the value between Of and _
//valueType -- look for last _ and get the String before the numbers
String fieldType = "";
String valueType = "";
int indexOfLastSpace = field.lastIndexOf(" ");
String fieldName = field.substring(indexOfLastSpace);
int indexOfFieldType = fieldName.indexOf("Of") + 2;
String fieldTypeWithValueType = fieldName.substring(indexOfFieldType);
int indexOfUnderScore = fieldTypeWithValueType.indexOf("_");
fieldType = fieldTypeWithValueType.substring(0, indexOfUnderScore);
String valueTypeWithNumber =
fieldTypeWithValueType.substring(indexOfUnderScore + 1);
int lastIndexOfValueType = 0;
for (int i=valueTypeWithNumber.length() -1; i>=0; i--) {
if (Character.isDigit(valueTypeWithNumber.charAt(i))) {
continue;
} else {
lastIndexOfValueType = i;
break;
}
}
valueType = valueTypeWithNumber.substring(0, lastIndexOfValueType+1);
Vector fieldSpecs = new Vector();
fieldSpecs.add(fieldType);
fieldSpecs.add(valueType);
return fieldSpecs;
}
public static String [] elementTypes = new String[]
{"Object", "SimpleClass", "SimpleInterface",
"String", "Date", "Locale", "BigDecimal",
"BigInteger", "Byte", "Double", "Float",
"Integer", "Long", "Short", "SimpleEnum"};
private static int getIndexOf(String type) {
for (int i=0; i < elementTypes.length; i++) {
if (type.equals(elementTypes[i]))
return i;
}
return 9999;
}
public static Vector makeNewVectorInstance(String type, int order) {
Vector vec = new Vector();
switch (order) {
case(1):
switch (getIndexOf(type)) {
case(0):
vec.add(0, new SimpleClass(1, "Hello World"));
vec.add(1, new SimpleClass(2, "Java Data Objects"));
vec.add(2, new SimpleClass(2, "Java"));
vec.add(3, new SimpleClass(4, "Origami"));
vec.add(4, new SimpleClass(5, "watch"));
break;
case(1):
case(2):
vec.add(0, new SimpleClass(1, "Welcome"));
vec.add(1, new SimpleClass(2, "To"));
vec.add(2, new SimpleClass(3, "The"));
vec.add(3, new SimpleClass(4, "Beautiful"));
vec.add(4, new SimpleClass(5, "World"));
break;
case(3):
vec.add(0, new String("Hello"));
vec.add(1, new String("Welcome"));
vec.add(2, new String("To The"));
vec.add(3, new String("Beautiful"));
vec.add(4, new String("World"));
break;
case(4):
vec.add(0, new Date(2007908));
vec.add(1, new Date(89067382l));
vec.add(2, new Date(890673822));
vec.add(3, new Date(890673823));
vec.add(4, new Date(890673824));
break;
case(5):
vec.add(0, Locale.CHINA);
vec.add(1, Locale.FRANCE);
vec.add(2, Locale.GERMANY);
vec.add(3, Locale.JAPAN);
vec.add(4, Locale.ITALY);
break;
case(6):
vec.add(0, new BigDecimal("2007908.54548"));
vec.add(1, new BigDecimal("0.544"));
vec.add(2, new BigDecimal("3002323232.545454"));
vec.add(3, new BigDecimal("64564645656.78657"));
vec.add(4, new BigDecimal("4564565465.2342"));
break;
case(7):
vec.add(0, new BigInteger("2007908"));
vec.add(1, new BigInteger("767575"));
vec.add(2, new BigInteger("3002323232"));
vec.add(3, new BigInteger("64564645656"));
vec.add(4, new BigInteger("456445645"));
break;
case(8):
vec.add(0, new Byte((byte)Byte.MIN_VALUE));
vec.add(1, new Byte((byte)Byte.MAX_VALUE));
vec.add(2, new Byte((byte)(Byte.MAX_VALUE- 20)));
vec.add(3, new Byte((byte)(Byte.MAX_VALUE - 50)));
vec.add(4, new Byte((byte)(Byte.MAX_VALUE - 75)));
break;
case(9):
vec.add(0, new Double(AllTypes.DOUBLE_SMALLEST));
vec.add(1, new Double(AllTypes.DOUBLE_LARGEST));
vec.add(2, new Double(AllTypes.DOUBLE_LARGEST - 20000));
vec.add(3, new Double(AllTypes.DOUBLE_LARGEST
- 454545.436664));
vec.add(4, new Double(AllTypes.DOUBLE_LARGEST
- 2323235.76764677));
break;
case(10):
vec.add(0, new Float(AllTypes.FLOAT_SMALLEST));
vec.add(1, new Float(AllTypes.FLOAT_LARGEST));
vec.add(2, new Float(AllTypes.FLOAT_LARGEST - 20000));
vec.add(3, new Float(AllTypes.FLOAT_LARGEST
- 454545.434));
vec.add(4, new Float(AllTypes.FLOAT_LARGEST
- 565656.43434));
break;
case(11):
vec.add(0, new Integer(Integer.MIN_VALUE));
vec.add(1, new Integer(Integer.MAX_VALUE));
vec.add(2, new Integer(Integer.MAX_VALUE - 20000));
vec.add(3, new Integer(Integer.MAX_VALUE - 343434343));
vec.add(4, new Integer(Integer.MAX_VALUE - 565656));
break;
case(12):
vec.add(0, new Long(Long.MIN_VALUE));
vec.add(1, new Long(Long.MAX_VALUE));
vec.add(2, new Long(Long.MAX_VALUE - 20000));
vec.add(3, new Long(Long.MAX_VALUE - 343434343));
vec.add(4, new Long(Long.MAX_VALUE - 565656));
break;
case(13):
vec.add(0, new Short(Short.MIN_VALUE));
vec.add(1, new Short(Short.MAX_VALUE));
vec.add(2, new Short((short)(Short.MAX_VALUE - 20000)));
vec.add(3, new Short((short)(Short.MAX_VALUE - 343)));
vec.add(4, new Short((short)(Short.MAX_VALUE - 5656)));
break;
case(14):
vec.add(0, (SimpleEnum)SimpleEnum.AK);
vec.add(1, (SimpleEnum)SimpleEnum.FM);
vec.add(2, (SimpleEnum)SimpleEnum.KS);
vec.add(3, (SimpleEnum)SimpleEnum.NJ);
vec.add(4, (SimpleEnum)SimpleEnum.WI);
break;
default:
throw new IndexOutOfBoundsException();
}
return vec;
case(2):
switch (getIndexOf(type)) {
case(0):
vec.add(0, new SimpleClass(1, "Hi There"));
vec.add(1, new SimpleClass(1, "Hi"));
vec.add(2, new SimpleClass(2, "Object"));
vec.add(3, new SimpleClass(0, "Relational"));
vec.add(4, new SimpleClass(3, "Hi There"));
break;
case(1):
vec.add(0, new SimpleClass(1, "Peaches"));
vec.add(1, new SimpleClass(2, "Oranges"));
vec.add(2, new SimpleClass(3, "Blue Berries"));
vec.add(3, new SimpleClass(4, "Apples"));
vec.add(4, new SimpleClass(5, "Strawberries"));
break;
case(2):
vec.add(0, new SimpleClass(1, "Peaches"));
vec.add(1, new SimpleClass(2, "Oranges"));
vec.add(2, new SimpleClass(3, "Blue Berries"));
vec.add(3, new SimpleClass(4, "Apples"));
vec.add(4, new SimpleClass(5, "Strawberries"));
break;
case(3):
vec.add(0, new String("Peaches"));
vec.add(1, new String("Oranges"));
vec.add(2, new String("Blue Berries"));
vec.add(3, new String("Apples"));
vec.add(4, new String("Strawberries"));
break;
case(4):
vec.add(0, new Date(54545));
vec.add(1, new Date(8905454l));
vec.add(2, new Date(323545445));
vec.add(3, new Date(890748967382l));
vec.add(4, new Date(954545));
break;
case(5):
vec.add(0, Locale.ENGLISH);
vec.add(1, Locale.JAPANESE);
vec.add(2, Locale.CANADA_FRENCH);
vec.add(3, Locale.KOREA);
vec.add(4, Locale.UK);
break;
case(6):
vec.add(0, new BigDecimal("434238.5454898989"));
vec.add(1, new BigDecimal("6.544"));
vec.add(2, new BigDecimal("55552323232.545454"));
vec.add(3, new BigDecimal("6456456.7543543534865785"));
vec.add(4, new BigDecimal("456456.4353452342"));
break;
case(7):
vec.add(0, new BigInteger("345345345345345345345345"));
vec.add(1, new BigInteger("543543543543544"));
vec.add(2, new BigInteger("65323423432423423"));
vec.add(3, new BigInteger("87845634534543"));
vec.add(4, new BigInteger("53452567766657567"));
break;
case(8):
vec.add(0, new Byte((byte)(Byte.MAX_VALUE-34)));
vec.add(1, new Byte((byte)Byte.MIN_VALUE));
vec.add(2, new Byte((byte)(Byte.MAX_VALUE- 76)));
vec.add(3, new Byte((byte)Byte.MAX_VALUE));
vec.add(4, new Byte((byte)(Byte.MAX_VALUE - 12)));
break;
case(9):
vec.add(0, new Double(AllTypes.DOUBLE_LARGEST - 343434));
vec.add(1, new Double(AllTypes.DOUBLE_SMALLEST));
vec.add(2, new Double(AllTypes.DOUBLE_LARGEST));
vec.add(3, new Double(AllTypes.DOUBLE_LARGEST
- 65423445.436664));
vec.add(4, new Double(AllTypes.DOUBLE_LARGEST
- 7235.236764677));
break;
case(10):
vec.add(0, new Float(AllTypes.FLOAT_LARGEST - 5452));
vec.add(1, new Float(AllTypes.FLOAT_SMALLEST));
vec.add(2, new Float(AllTypes.FLOAT_LARGEST - 6564560.54));
vec.add(3, new Float(AllTypes.FLOAT_LARGEST));
vec.add(4, new Float(AllTypes.FLOAT_LARGEST - 9756.634));
break;
case(11):
vec.add(0, new Integer(Integer.MAX_VALUE - 54454));
vec.add(1, new Integer(Integer.MIN_VALUE));
vec.add(2, new Integer(Integer.MAX_VALUE));
vec.add(3, new Integer(Integer.MAX_VALUE - 767234));
vec.add(4, new Integer(Integer.MAX_VALUE - 23673446));
break;
case(12):
vec.add(0, new Long(Long.MAX_VALUE - 545345454));
vec.add(1, new Long(Long.MIN_VALUE));
vec.add(2, new Long(Long.MAX_VALUE));
vec.add(3, new Long(Long.MAX_VALUE - 3543343));
vec.add(4, new Long(Long.MAX_VALUE - 556));
break;
case(13):
vec.add(0, new Short((short)(Short.MAX_VALUE - 3434)));
vec.add(1, new Short(Short.MIN_VALUE));
vec.add(2, new Short((short)(Short.MAX_VALUE)));
vec.add(3, new Short((short)(Short.MAX_VALUE - 23344)));
vec.add(4, new Short((short)(Short.MAX_VALUE - 723)));
break;
case(14):
vec.add(0, (SimpleEnum)SimpleEnum.AZ);
vec.add(1, (SimpleEnum)SimpleEnum.SD);
vec.add(2, (SimpleEnum)SimpleEnum.NV);
vec.add(3, (SimpleEnum)SimpleEnum.WV);
vec.add(4, (SimpleEnum)SimpleEnum.PA);
break;
default:
throw new IndexOutOfBoundsException();
}
return vec;
default:
throw new IndexOutOfBoundsException();
}
}
protected static boolean containsBigDecimalKey(BigDecimal keyValue,
Set bigDecimalKeySet)
{
Iterator iter = bigDecimalKeySet.iterator();
while (iter.hasNext()) {
BigDecimal nextVal = (BigDecimal) iter.next();
if (keyValue.compareTo(nextVal) == 0) {
return true;
}
}
return false;
}
protected static BigDecimal getBigDecimalKey(BigDecimal keyValue,
Set bigDecimalKeySet)
{
Iterator iter = bigDecimalKeySet.iterator();
while (iter.hasNext()) {
BigDecimal nextVal = (BigDecimal) iter.next();
if (keyValue.compareTo(nextVal) == 0) {
return nextVal;
}
}
return null;
}
}
tck/src/java/org/apache/jdo/tck/models/fieldtypes/TestVectorCollections.java 100664 14304 12500110373 27546 0 ustar mbouschen staff 0 0 /*
* 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.models.fieldtypes;
import java.math.BigDecimal;
import java.util.Collection;
import java.util.Vector;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.fieldtypes.VectorCollections;
import org.apache.jdo.tck.pc.fieldtypes.SimpleClass;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Support of field type Vector.
*Keywords: model
*Assertion ID: A6.4.3-29.
*Assertion Description:
If the Vector optional feature is supported, then JDO implementation
must support fields of the mutable object class Vector,
supporting them as Second Class Objects or First Class Objects.
*/
public class TestVectorCollections extends JDO_Test {
/** */
private static final String ASSERTION_FAILED =
"Assertion A6.4.3-29 (TestVectorCollections) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(TestVectorCollections.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
addTearDownClass(VectorCollections.class);
addTearDownClass(SimpleClass.class);
}
/** */
public void test() {
pm = getPM();
runTest(pm);
pm.close();
pm = null;
}
/** */
void runTest(PersistenceManager pm)
{
if (!isVectorSupported()) {
if (debug)
logger.debug("JDO Implementation does not support " +
"the optional feature Vector");
return;
}
Transaction tx = pm.currentTransaction();
VectorCollections expectedValue = new VectorCollections();
// turn on datastore transactions
tx.setOptimistic(false);
tx.begin();
VectorCollections pi = new VectorCollections();
pi.identifier = 1;
pm.makePersistent(pi);
Object oid = pm.getObjectId(pi);
// Provide initial set of values
setValues(pi, 1);
tx.commit();
// cache will be flushed
pi = null;
System.gc();
tx.begin();
setValues(expectedValue, 1);
// check if persistent fields have values set
checkValues(oid, expectedValue);
pi = (VectorCollections) pm.getObjectById(oid, true);
// Provide new set of values
setValues(pi, 2);
tx.commit();
// cache will be flushed
pi = null;
System.gc();
tx.begin();
// check new values
setValues(expectedValue, 2);
checkValues(oid, expectedValue);
tx.commit();
}
/** */
private void setValues(VectorCollections collect, int order)
{
Vector value;
int n = collect.getLength();
for (int i = 0; i < n; ++i) {
String valueType = TestUtil.getFieldSpecs(
VectorCollections.fieldSpecs[i]);
value = TestUtil.makeNewVectorInstance(valueType, order);
collect.set(i, value);
if (debug)
logger.debug("Set " + i + "th value to: " + value.toString());
}
}
/** */
private void checkValues(Object oid, VectorCollections expectedValue)
{
StringBuffer sbuf = new StringBuffer();
VectorCollections pi = (VectorCollections)
pm.getObjectById(oid, true);
int n = pi.getLength();
for (int i = 0; i < n; i++) {
Vector expected = expectedValue.get(i);
Vector actual = pi.get(i);
if (actual.size() != expected.size()) {
sbuf.append("\nFor element " + i + ", expected size = " +
expected.size() + ", actual size = " + actual.size()
+ " . ");
}
else if (! expected.equals(actual)) {
if (debug) {
logger.debug("Field number is " + i);
logger.debug("Persisted vector is " + actual);
logger.debug("Expected vector is " + expected);
}
if (TestUtil.getFieldSpecs(VectorCollections.fieldSpecs[i]
).equals("BigDecimal")) {
for (int j = 0; j < actual.size(); j++) {
BigDecimal bigDecActual =
(BigDecimal)actual.elementAt(j);
BigDecimal bigDecExpected =
(BigDecimal)expected.elementAt(j);
if ((bigDecExpected.compareTo(bigDecActual) != 0)) {
sbuf.append("\nFor element " + i + "(" + j +
"), expected = " + expected +
", actual = " + actual + " . ");
}
}
}
else {
sbuf.append("\nFor element " + i + ", expected = " +
expected + ", actual = " + actual + " . ");
}
}
}
if (sbuf.length() > 0) {
fail(ASSERTION_FAILED,
"Expected and observed do not match!!" + sbuf.toString());
}
}
}
tck/src/java/org/apache/jdo/tck/models/inheritance/FieldWithSameNameInSuperclass.java 100664 26043 12500110373 31213 0 ustar mbouschen staff 0 0 /*
* 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.models.inheritance;
import java.util.Iterator;
import javax.jdo.Extent;
import javax.jdo.JDOException;
import javax.jdo.JDOUserException;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.inheritance.Constants;
import org.apache.jdo.tck.pc.inheritance.FieldSameName4;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Field With the Same Name as a Field in a Superclass
*Keywords: inheritance
*Assertion ID: A6.5-7.
*Assertion Description:
A class might define a new field with the same name as the field declared
in the superclass, and might define it to be different (persistent or not)
from the inherited field. But Java treats the declared field as a different
field from the inherited field, so there is no conflict.
*/
public class FieldWithSameNameInSuperclass extends TestParts {
/** */
private static final String ASSERTION_FAILED =
"Assertion A6.5-7 (FieldWithSameNameInSuperclass) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(FieldWithSameNameInSuperclass.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
addTearDownClass(FieldSameName4.class);
}
/** */
public void test() {
pm = getPM();
runTest(pm);
pm.close();
pm = null;
}
/** */
void runTest(PersistenceManager pm)
{
Transaction t = pm.currentTransaction();
try {
t.setRestoreValues(true);
t.begin();
FieldSameName4 refa = new FieldSameName4(Constants.intA_V[1], Constants.doubleB_V[1], Constants.intB_V[1], Constants.charC_V[1], Constants.booleanD_V[1], Constants.floatE_V[1], Constants.shortF_V[1], Constants.shortG_V[1], Constants.intH_V[1]);
pm.makePersistent(refa);
Object objPtrA = pm.getObjectId (refa);
refa.setSecondObj(new FieldSameName4(Constants.intA_V[2], Constants.doubleB_V[2], Constants.intB_V[2], Constants.charC_V[2], Constants.booleanD_V[2], Constants.floatE_V[2], Constants.shortF_V[2], Constants.shortG_V[2], Constants.intH_V[2]));
TestParts.secondObj_V[1] = refa.getSecondObj();
refa.setThirdObj(new FieldSameName4(Constants.intA_V[3], Constants.doubleB_V[3], Constants.intB_V[3], Constants.charC_V[3], Constants.booleanD_V[3], Constants.floatE_V[3], Constants.shortF_V[3], Constants.shortG_V[3], Constants.intH_V[3]));
TestParts.thirdObj_V[1] = refa.getThirdObj();
pm.makePersistent(TestParts.thirdObj_V[1]);
Object objPtrB = pm.getObjectId(TestParts.thirdObj_V[1]);
refa.setFourthObj(new FieldSameName4(Constants.intA_V[4], Constants.doubleB_V[4], Constants.intB_V[4], Constants.charC_V[4], Constants.booleanD_V[4], Constants.floatE_V[4], Constants.shortF_V[4], Constants.shortG_V[4], Constants.intH_V[4]));
TestParts.fourthObj_V[1] = refa.getFourthObj();
try {
t.commit();
} catch(JDOException e) {
Object o = e.getFailedObject();
String cname = o == null ? "null" : o.getClass().getName();
fail(ASSERTION_FAILED,
"Exception thrown, failed object class is " + cname + " exception is " + e);
}
t.begin();
FieldSameName4 a = null;
FieldSameName4 b = null;
try { // retrieve object created in previous transaction & store in value array for later comparison
TestParts.thirdObj_V[1] = (FieldSameName4) pm.getObjectById(objPtrB, true);
}
catch (JDOUserException e) {
// could not locate persistent object created in previous
// transaction
fail(ASSERTION_FAILED,
"JDOUserException " + e + " could not reference thirdObj.");
}
try { // retrieve object created in previous transaction
a = (FieldSameName4) pm.getObjectById(objPtrA, true);
checkPersistentAreCorrect(ASSERTION_FAILED, persistentAfterCommit, 1, a.getDoubleB(), a.getIntB(), a.getShortF(), a.getThirdObj(), a.getIntH());
// verify referenced persistent object contains correct values
b = a.getThirdObj();
if(b != null) { // if previous error caused b to be null, then these tests cannot be performed.
checkPersistentAreCorrect(ASSERTION_FAILED, persistentAfterCommit, 3, b.getDoubleB(), b.getIntB(), b.getShortF(), b.getThirdObj(), b.getIntH());
}
}
catch (JDOUserException e) {
// could not locate persistent object created in previous transaction
fail(ASSERTION_FAILED,
"JDOUserException " + e + " could not reference previously created object.");
}
// set in new values
a.setIntA(Constants.intA_V[5]);
a.setCharC(Constants.charC_V[5]);
a.setBooleanD(Constants.booleanD_V[5]);
a.setShortG(Constants.shortG_V[5]);
FieldSameName4 fourth = new FieldSameName4(Constants.intA_V[6], Constants.doubleB_V[6], Constants.intB_V[6], Constants.charC_V[6], Constants.booleanD_V[6], Constants.floatE_V[6], Constants.shortF_V[6], Constants.shortG_V[6], Constants.intH_V[6]);
a.setFourthObj(fourth);
a.setFloatE(Constants.floatE_V[5]);
a.setSecondObj(null);
a.setDoubleB(Constants.doubleB_V[5]);
a.setIntB(Constants.intB_V[5]);
a.setShortF(Constants.shortF_V[5]);
a.setThirdObj(null);
a.setIntH(Constants.intH_V[5]);
b.setIntA(Constants.intA_V[7]);
b.setCharC(Constants.charC_V[7]);
b.setBooleanD(Constants.booleanD_V[7]);
b.setShortG(Constants.shortG_V[7]);
b.setFourthObj(null);
b.setFloatE(Constants.floatE_V[7]);
b.setSecondObj(null);
b.setDoubleB(Constants.doubleB_V[7]);
b.setIntB(Constants.intB_V[7]);
b.setShortF(Constants.shortF_V[7]);
b.setThirdObj(null);
b.setIntH(Constants.intH_V[7]);
// create new objects and make persistent
FieldSameName4 c = new FieldSameName4(Constants.intA_V[8], Constants.doubleB_V[8], Constants.intB_V[8], Constants.charC_V[8], Constants.booleanD_V[8], Constants.floatE_V[8], Constants.shortF_V[8], Constants.shortG_V[8], Constants.intH_V[8]);
FieldSameName4 d = new FieldSameName4(Constants.intA_V[9], Constants.doubleB_V[9], Constants.intB_V[9], Constants.charC_V[9], Constants.booleanD_V[9], Constants.floatE_V[9], Constants.shortF_V[9], Constants.shortG_V[9], Constants.intH_V[9]);
c.setThirdObj(d);
c.setFourthObj(d);
TestParts.thirdObj_V[8] = d;
TestParts.fourthObj_V[8] = d;
pm.makePersistent(c);
// change values of newly persistent object
c.setIntA(Constants.intA_V[10]);
c.setCharC(Constants.charC_V[10]);
c.setBooleanD(Constants.booleanD_V[10]);
c.setShortG(Constants.shortG_V[10]);
c.setFourthObj(null);
c.setFloatE(Constants.floatE_V[10]);
c.setSecondObj(null);
c.setDoubleB(Constants.doubleB_V[10]);
c.setIntB(Constants.intB_V[10]);
c.setShortF(Constants.shortF_V[10]);
c.setThirdObj(null);
c.setIntH(Constants.intH_V[10]);
t.rollback();
// verify objects revert back to transient after rollback
checkPersistentAreCorrect(ASSERTION_FAILED, transientAfterRollback, 8, c.getDoubleB(), c.getIntB(), c.getShortF(), c.getThirdObj(), c.getIntH());
checkTransactionalAreCorrect(ASSERTION_FAILED, transientAfterRollback, 8, c.getFloatE(), c.getSecondObj());
checkNonpersistentAreCorrect(ASSERTION_FAILED, transientAfterRollback, 10, c.getIntA(), c.getCharC(), c.getBooleanD(), c.getShortG(), c.getFourthObj());
t.begin();
// verify rollback lost all persistent changes.
try { // retrieve object created in previous transaction & store in value array for later comparison
TestParts.thirdObj_V[1] = (FieldSameName4) pm.getObjectById(objPtrB, true);
}
catch (JDOUserException e) {
// could not locate persistent object created in previous transaction
fail(ASSERTION_FAILED,
"JDOUserException " + e + " could not reference thirdObj.");
}
try { // retrieve object created in previous transaction
a = (FieldSameName4) pm.getObjectById(objPtrA, true);
checkPersistentAreCorrect(ASSERTION_FAILED, persistentAfterRollback, 1, a.getDoubleB(), a.getIntB(), a.getShortF(), a.getThirdObj(), a.getIntH());
b = a.getThirdObj();
if(b != null) { // if previous error caused b to be null, then these tests cannot be performed.
checkPersistentAreCorrect(ASSERTION_FAILED, persistentAfterRollback, 3, b.getDoubleB(), b.getIntB(), b.getShortF(), b.getThirdObj(), b.getIntH());
}
}
catch (JDOUserException e) {
// could not locate persistent object created in previous transaction
fail(ASSERTION_FAILED,
"JDOUserException " + e + " could not reference previously created object.");
}
t.rollback();
t = null;
}
finally {
if ((t != null) && t.isActive())
t.rollback();
}
}
void removeAllInstances(PersistenceManager pm)
{
Extent e = pm.getExtent(FieldSameName4.class, true);
Iterator i = e.iterator();
while( i.hasNext() ){
pm.deletePersistent(i.next());
}
}
}
././@LongLink 100644 0 0 150 12500111677 10247 L ustar 0 0 tck/src/java/org/apache/jdo/tck/models/inheritance/NonPersistentFieldsAreNonPersistentInSubclasses.java tck/src/java/org/apache/jdo/tck/models/inheritance/NonPersistentFieldsAreNonPersistentInSubclasses.j100664 11007 12500110373 34340 0 ustar mbouschen staff 0 0 /*
* 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.models.inheritance;
import java.util.Iterator;
import javax.jdo.Extent;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.inheritance.AllPersist4;
import org.apache.jdo.tck.pc.inheritance.Constants;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Non-Persistent Fields Are Non-Persistent in Subclasses
*Keywords: inheritance
*Assertion ID: A6.5-6.
*Assertion Description:
Fields marked as non-persistent in persistence-capable classes
will be non-persistent in subclasses.
*/
public class NonPersistentFieldsAreNonPersistentInSubclasses extends TestParts {
/** */
private static final String ASSERTION_FAILED =
"Assertion A6.5-6 (NonPersistentFieldsAreNonPersistentInSubclasses) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(NonPersistentFieldsAreNonPersistentInSubclasses.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
addTearDownClass(AllPersist4.class);
}
/** */
public void test() {
pm = getPM();
runTest(pm);
pm.close();
pm = null;
}
/** */
void runTest(PersistenceManager pm)
{
Transaction t = pm.currentTransaction();
try {
t.setRestoreValues(true);
t.begin();
// create new objects and make persistent
AllPersist4 c = new AllPersist4(Constants.intA_V[8], Constants.doubleB_V[8], Constants.intB_V[8], Constants.charC_V[8], Constants.booleanD_V[8], Constants.floatE_V[8], Constants.shortF_V[8], Constants.shortG_V[8], Constants.intH_V[8]);
AllPersist4 d = new AllPersist4(Constants.intA_V[9], Constants.doubleB_V[9], Constants.intB_V[9], Constants.charC_V[9], Constants.booleanD_V[9], Constants.floatE_V[9], Constants.shortF_V[9], Constants.shortG_V[9], Constants.intH_V[9]);
c.thirdObj = d;
c.fourthObj = d;
TestParts.thirdObj_V[8] = d;
TestParts.fourthObj_V[8] = d;
pm.makePersistent(c);
// change values of newly persistent object
c.intA = Constants.intA_V[10];
c.charC = Constants.charC_V[10];
c.booleanD = Constants.booleanD_V[10];
c.shortG = Constants.shortG_V[10];
c.fourthObj = null;
c.floatE = Constants.floatE_V[10];
c.secondObj = null;
c.doubleB = Constants.doubleB_V[10];
c.intB = Constants.intB_V[10];
c.shortF = Constants.shortF_V[10];
c.thirdObj = null;
c.intH = Constants.intH_V[10];
t.rollback();
t = null;
// verify objects revert back to transient after rollback
checkNonpersistentAreCorrect(ASSERTION_FAILED, transientAfterRollback, 10, c.intA, c.charC, c.booleanD, c.shortG, c.fourthObj);
}
finally {
if ((t != null) && t.isActive())
t.rollback();
}
}
void removeAllInstances(PersistenceManager pm)
{
AllPersist4 a = new AllPersist4(0, 0.0, 0, '0', false, 0.0f, (short)0, (short)0, 0);
pm.makePersistent(a); // guarantee the class is registered; this will be removed
Extent e = pm.getExtent(AllPersist4.class, true);
Iterator i = e.iterator();
while( i.hasNext() ){
pm.deletePersistent(i.next());
}
}
}
tck/src/java/org/apache/jdo/tck/models/inheritance/NonpersistentSuperClass.java 100664 24236 12500110373 30253 0 ustar mbouschen staff 0 0 /*
* 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.models.inheritance;
import java.util.Iterator;
import javax.jdo.Extent;
import javax.jdo.JDOUserException;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.inheritance.Constants;
import org.apache.jdo.tck.pc.inheritance.TopNonPersistH;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Non-persistent Super Class
*Keywords: inheritance
*Assertion ID: A6.5-1.
*Assertion Description:
A class might be persistence-capable even if its superclass is not persistence-capable.
*/
public class NonpersistentSuperClass extends TestParts {
/** */
private static final String ASSERTION_FAILED =
"Assertion A6.5-1 (NonpersistentSuperClass) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(NonpersistentSuperClass.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
addTearDownClass(TopNonPersistH.class);
}
/** */
public void test() {
pm = getPM();
runTest(pm);
pm.close();
pm = null;
}
/** */
void runTest(PersistenceManager pm)
{
Transaction t = pm.currentTransaction();
try {
t.setRestoreValues(true);
t.begin();
TopNonPersistH refa = new TopNonPersistH(Constants.intA_V[1], Constants.doubleB_V[1], Constants.intB_V[1], Constants.charC_V[1], Constants.booleanD_V[1], Constants.floatE_V[1], Constants.shortF_V[1], Constants.shortG_V[1], Constants.intH_V[1]);
pm.makePersistent(refa);
Object objPtrA = pm.getObjectId(refa);
refa.secondObj = new TopNonPersistH(Constants.intA_V[2], Constants.doubleB_V[2], Constants.intB_V[2], Constants.charC_V[2], Constants.booleanD_V[2], Constants.floatE_V[2], Constants.shortF_V[2], Constants.shortG_V[2], Constants.intH_V[2]);
TestParts.secondObj_V[1] = refa.secondObj;
refa.thirdObj = new TopNonPersistH(Constants.intA_V[3], Constants.doubleB_V[3], Constants.intB_V[3], Constants.charC_V[3], Constants.booleanD_V[3], Constants.floatE_V[3], Constants.shortF_V[3], Constants.shortG_V[3], Constants.intH_V[3]);
TestParts.thirdObj_V[1] = refa.thirdObj;
pm.makePersistent(refa.thirdObj);
Object objPtrB = pm.getObjectId(refa.thirdObj);
refa.fourthObj = new TopNonPersistH(Constants.intA_V[4], Constants.doubleB_V[4], Constants.intB_V[4], Constants.charC_V[4], Constants.booleanD_V[4], Constants.floatE_V[4], Constants.shortF_V[4], Constants.shortG_V[4], Constants.intH_V[4]);
TestParts.fourthObj_V[1] = refa.fourthObj;
t.commit();
t.begin();
TopNonPersistH a = null;
TopNonPersistH b = null;
try { // retrieve object created in previous transaction & store in value array for later comparison
TestParts.thirdObj_V[1] = (TopNonPersistH)pm.getObjectById(objPtrB, true);
}
catch (JDOUserException e) {
// could not locate persistent object created in previous transaction
fail(ASSERTION_FAILED,
"JDOUserException " + e + " could not reference thirdObj.");
}
try { // retrieve object created in previous transaction
a = (TopNonPersistH)pm.getObjectById(objPtrA, true);
checkPersistentAreCorrect(ASSERTION_FAILED, persistentAfterCommit, 1, a.doubleB, a.intB, a.shortF, a.thirdObj, a.intH);
// verify referenced persistent object contains correct values
b = a.thirdObj;
if(b != null) { // if previous error caused b to be null, then these tests cannot be performed.
checkPersistentAreCorrect(ASSERTION_FAILED, persistentAfterCommit, 3, b.doubleB, b.intB, b.shortF, b.thirdObj, b.intH);
}
}
catch (JDOUserException e) {
// could not locate persistent object created in previous transaction
fail(ASSERTION_FAILED,
"JDOUserException " + e + " could not reference previously created object.");
}
// set in new values
a.intA = Constants.intA_V[5];
a.charC = Constants.charC_V[5];
a.booleanD = Constants.booleanD_V[5];
a.shortG = Constants.shortG_V[5];
a.fourthObj = new TopNonPersistH(Constants.intA_V[6], Constants.doubleB_V[6], Constants.intB_V[6], Constants.charC_V[6], Constants.booleanD_V[6], Constants.floatE_V[6], Constants.shortF_V[6], Constants.shortG_V[6], Constants.intH_V[6]);
TestParts.fourthObj_V[5] = a.fourthObj;
a.floatE = Constants.floatE_V[5];
a.secondObj = null;
a.doubleB = Constants.doubleB_V[5];
a.intB = Constants.intB_V[5];
a.shortF = Constants.shortF_V[5];
a.thirdObj = null;
a.intH = Constants.intH_V[5];
b.intA = Constants.intA_V[7];
b.charC = Constants.charC_V[7];
b.booleanD = Constants.booleanD_V[7];
b.shortG = Constants.shortG_V[7];
b.fourthObj = null;
b.floatE = Constants.floatE_V[7];
b.secondObj = null;
b.doubleB = Constants.doubleB_V[7];
b.intB = Constants.intB_V[7];
b.shortF = Constants.shortF_V[7];
b.thirdObj = null;
b.intH = Constants.intH_V[7];
// create new objects and make persistent
TopNonPersistH c = new TopNonPersistH(Constants.intA_V[8], Constants.doubleB_V[8], Constants.intB_V[8], Constants.charC_V[8], Constants.booleanD_V[8], Constants.floatE_V[8], Constants.shortF_V[8], Constants.shortG_V[8], Constants.intH_V[8]);
TopNonPersistH d = new TopNonPersistH(Constants.intA_V[9], Constants.doubleB_V[9], Constants.intB_V[9], Constants.charC_V[9], Constants.booleanD_V[9], Constants.floatE_V[9], Constants.shortF_V[9], Constants.shortG_V[9], Constants.intH_V[9]);
c.thirdObj = d;
c.fourthObj = d;
TestParts.thirdObj_V[8] = d;
TestParts.fourthObj_V[8] = d;
pm.makePersistent(c);
// change values of newly persistent object
c.intA = Constants.intA_V[10];
c.charC = Constants.charC_V[10];
c.booleanD = Constants.booleanD_V[10];
c.shortG = Constants.shortG_V[10];
c.fourthObj = null;
c.floatE = Constants.floatE_V[10];
c.secondObj = null;
c.doubleB = Constants.doubleB_V[10];
c.intB = Constants.intB_V[10];
c.shortF = Constants.shortF_V[10];
c.thirdObj = null;
c.intH = Constants.intH_V[10];
t.rollback();
// verify objects revert back to transient after rollback
checkPersistentAreCorrect(ASSERTION_FAILED, transientAfterRollback, 8, c.doubleB, c.intB, c.shortF, c.thirdObj, c.intH);
checkTransactionalAreCorrect(ASSERTION_FAILED, transientAfterRollback, 8, c.floatE, c.secondObj);
checkNonpersistentAreCorrect(ASSERTION_FAILED, transientAfterRollback, 10, c.intA, c.charC, c.booleanD, c.shortG, c.fourthObj);
t.begin();
// verify rollback lost all persistent changes.
try { // retrieve object created in previous transaction & store in value array for later comparison
TestParts.thirdObj_V[1] = (TopNonPersistH)pm.getObjectById(objPtrB, true);
}
catch (JDOUserException e) {
// could not locate persistent object created in previous transaction
fail(ASSERTION_FAILED,
"JDOUserException " + e + " could not reference thirdObj.");
}
try { // retrieve object created in previous transaction
a = (TopNonPersistH)pm.getObjectById(objPtrA, true);
checkPersistentAreCorrect(ASSERTION_FAILED, persistentAfterRollback, 1, a.doubleB, a.intB, a.shortF, a.thirdObj, a.intH);
b = a.thirdObj;
if(b != null) { // if previous error caused b to be null, then these tests cannot be performed.
checkPersistentAreCorrect(ASSERTION_FAILED, persistentAfterRollback, 3, b.doubleB, b.intB, b.shortF, b.thirdObj, b.intH);
}
}
catch (JDOUserException e) {
// could not locate persistent object created in previous transaction
fail(ASSERTION_FAILED,
"JDOUserException " + e + " could not reference previously created object.");
}
t.rollback();
t = null;
}
finally {
if ((t != null) && t.isActive())
t.rollback();
}
}
void removeAllInstances(PersistenceManager pm)
{
Extent e = pm.getExtent(TopNonPersistH.class, true);
Iterator i = e.iterator();
while( i.hasNext() ){
pm.deletePersistent(i.next());
}
}
}
././@LongLink 100644 0 0 154 12500111677 10253 L ustar 0 0 tck/src/java/org/apache/jdo/tck/models/inheritance/PersistenceCapableFlexibilityInInheritanceHierarchy.java tck/src/java/org/apache/jdo/tck/models/inheritance/PersistenceCapableFlexibilityInInheritanceHierarc100664 24617 12500110373 34356 0 ustar mbouschen staff 0 0 /*
* 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.models.inheritance;
import java.util.Iterator;
import javax.jdo.Extent;
import javax.jdo.JDOUserException;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.inheritance.Constants;
import org.apache.jdo.tck.pc.inheritance.TopPersistH;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Persistence Capable Flexibility in Inheritance Hierarchy
*Keywords: inheritance
*Assertion ID: A6.5-3.
*Assertion Description:
Subclasses of such classes that are not persistence-capable,
but have a superclass that is persistence-capable might be persistence-capable.
That is, it is possible for classes in the inheritance hierarchy to be
alternately persistence-capable and not persistence-capable.
*/
public class PersistenceCapableFlexibilityInInheritanceHierarchy extends TestParts {
/** */
private static final String ASSERTION_FAILED =
"Assertion A6.5-3 (PersistenceCapableFlexibilityInInheritanceHierarchy) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(PersistenceCapableFlexibilityInInheritanceHierarchy.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
addTearDownClass(TopPersistH.class);
}
/** */
public void test() {
pm = getPM();
runTest(pm);
pm.close();
pm = null;
}
/** */
void runTest(PersistenceManager pm)
{
Transaction t = pm.currentTransaction();
try {
t.setRestoreValues(true);
t.begin();
TopPersistH refa = new TopPersistH(Constants.intA_V[1], Constants.doubleB_V[1], Constants.intB_V[1], Constants.charC_V[1], Constants.booleanD_V[1], Constants.floatE_V[1], Constants.shortF_V[1], Constants.shortG_V[1], Constants.intH_V[1]);
pm.makePersistent(refa);
Object objPtrA = pm.getObjectId(refa);
refa.secondObj = new TopPersistH(Constants.intA_V[2], Constants.doubleB_V[2], Constants.intB_V[2], Constants.charC_V[2], Constants.booleanD_V[2], Constants.floatE_V[2], Constants.shortF_V[2], Constants.shortG_V[2], Constants.intH_V[2]);
TestParts.secondObj_V[1] = refa.secondObj;
refa.thirdObj = new TopPersistH(Constants.intA_V[3], Constants.doubleB_V[3], Constants.intB_V[3], Constants.charC_V[3], Constants.booleanD_V[3], Constants.floatE_V[3], Constants.shortF_V[3], Constants.shortG_V[3], Constants.intH_V[3]);
TestParts.thirdObj_V[1] = refa.thirdObj;
pm.makePersistent(refa.thirdObj);
Object objPtrB = pm.getObjectId(refa.thirdObj);
refa.fourthObj = new TopPersistH(Constants.intA_V[4], Constants.doubleB_V[4], Constants.intB_V[4], Constants.charC_V[4], Constants.booleanD_V[4], Constants.floatE_V[4], Constants.shortF_V[4], Constants.shortG_V[4], Constants.intH_V[4]);
TestParts.fourthObj_V[1] = refa.fourthObj;
t.commit();
t.begin();
TopPersistH a = null;
TopPersistH b = null;
try { // retrieve object created in previous transaction & store in value array for later comparison
TestParts.thirdObj_V[1] = (TopPersistH)pm.getObjectById(objPtrB, true);
}
catch (JDOUserException e) {
// could not locate persistent object created in previous transaction
fail(ASSERTION_FAILED,
"JDOUserException " + e + " could not reference thirdObj.");
}
try { // retrieve object created in previous transaction
a = (TopPersistH)pm.getObjectById(objPtrA, true);
checkPersistentAreCorrect(ASSERTION_FAILED, persistentAfterCommit, 1, a.doubleB, a.intB, a.shortF, a.thirdObj, a.intH);
// verify referenced persistent object contains correct values
b = a.thirdObj;
if(b != null) { // if previous error caused b to be null, then these tests cannot be performed.
checkPersistentAreCorrect(ASSERTION_FAILED, persistentAfterCommit, 3, b.doubleB, b.intB, b.shortF, b.thirdObj, b.intH);
}
}
catch (JDOUserException e) {
// could not locate persistent object created in previous transaction
fail(ASSERTION_FAILED,
"JDOUserException " + e + " could not reference previously created object.");
}
// set in new values
a.intA = Constants.intA_V[5];
a.charC = Constants.charC_V[5];
a.booleanD = Constants.booleanD_V[5];
a.shortG = Constants.shortG_V[5];
a.fourthObj = new TopPersistH(Constants.intA_V[6], Constants.doubleB_V[6], Constants.intB_V[6], Constants.charC_V[6], Constants.booleanD_V[6], Constants.floatE_V[6], Constants.shortF_V[6], Constants.shortG_V[6], Constants.intH_V[6]);
TestParts.fourthObj_V[5] = a.fourthObj;
a.floatE = Constants.floatE_V[5];
a.secondObj = null;
a.doubleB = Constants.doubleB_V[5];
a.intB = Constants.intB_V[5];
a.shortF = Constants.shortF_V[5];
a.thirdObj = null;
a.intH = Constants.intH_V[5];
b.intA = Constants.intA_V[7];
b.charC = Constants.charC_V[7];
b.booleanD = Constants.booleanD_V[7];
b.shortG = Constants.shortG_V[7];
b.fourthObj = null;
b.floatE = Constants.floatE_V[7];
b.secondObj = null;
b.doubleB = Constants.doubleB_V[7];
b.intB = Constants.intB_V[7];
b.shortF = Constants.shortF_V[7];
b.thirdObj = null;
b.intH = Constants.intH_V[7];
// create new objects and make persistent
TopPersistH c = new TopPersistH(Constants.intA_V[8], Constants.doubleB_V[8], Constants.intB_V[8], Constants.charC_V[8], Constants.booleanD_V[8], Constants.floatE_V[8], Constants.shortF_V[8], Constants.shortG_V[8], Constants.intH_V[8]);
TopPersistH d = new TopPersistH(Constants.intA_V[9], Constants.doubleB_V[9], Constants.intB_V[9], Constants.charC_V[9], Constants.booleanD_V[9], Constants.floatE_V[9], Constants.shortF_V[9], Constants.shortG_V[9], Constants.intH_V[9]);
c.thirdObj = d;
c.fourthObj = d;
TestParts.thirdObj_V[8] = d;
TestParts.fourthObj_V[8] = d;
pm.makePersistent(c);
// change values of newly persistent object
c.intA = Constants.intA_V[10];
c.charC = Constants.charC_V[10];
c.booleanD = Constants.booleanD_V[10];
c.shortG = Constants.shortG_V[10];
c.fourthObj = null;
c.floatE = Constants.floatE_V[10];
c.secondObj = null;
c.doubleB = Constants.doubleB_V[10];
c.intB = Constants.intB_V[10];
c.shortF = Constants.shortF_V[10];
c.thirdObj = null;
c.intH = Constants.intH_V[10];
t.rollback();
// verify objects revert back to transient after rollback
checkPersistentAreCorrect(ASSERTION_FAILED, transientAfterRollback, 8, c.doubleB, c.intB, c.shortF, c.thirdObj, c.intH);
checkTransactionalAreCorrect(ASSERTION_FAILED, transientAfterRollback, 8, c.floatE, c.secondObj);
checkNonpersistentAreCorrect(ASSERTION_FAILED, transientAfterRollback, 10, c.intA, c.charC, c.booleanD, c.shortG, c.fourthObj);
t.begin();
// verify rollback lost all persistent changes.
try { // retrieve object created in previous transaction & store in value array for later comparison
TestParts.thirdObj_V[1] = (TopPersistH)pm.getObjectById(objPtrB, true);
}
catch (JDOUserException e) {
// could not locate persistent object created in previous transaction
fail(ASSERTION_FAILED,
"JDOUserException " + e + " could not reference thirdObj.");
}
try { // retrieve object created in previous transaction
a = (TopPersistH)pm.getObjectById(objPtrA, true);
checkPersistentAreCorrect(ASSERTION_FAILED, persistentAfterRollback, 1, a.doubleB, a.intB, a.shortF, a.thirdObj, a.intH);
b = a.thirdObj;
if(b != null) { // if previous error caused b to be null, then these tests cannot be performed.
checkPersistentAreCorrect(ASSERTION_FAILED, persistentAfterRollback, 3, b.doubleB, b.intB, b.shortF, b.thirdObj, b.intH);
}
}
catch (JDOUserException e) {
// could not locate persistent object created in previous transaction
fail(ASSERTION_FAILED,
"JDOUserException " + e + " could not reference previously created object.");
}
t.rollback();
t = null;
}
finally {
if ((t != null) && t.isActive())
t.rollback();
}
}
void removeAllInstances(PersistenceManager pm)
{
Extent e = pm.getExtent(TopPersistH.class, true);
Iterator i = e.iterator();
while( i.hasNext() ){
pm.deletePersistent(i.next());
}
}
}
tck/src/java/org/apache/jdo/tck/models/inheritance/PersistentFieldsArePersistentInSubClasses.java 100664 24201 12500110373 33642 0 ustar mbouschen staff 0 0 /*
* 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.models.inheritance;
import java.util.Iterator;
import javax.jdo.Extent;
import javax.jdo.JDOUserException;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.inheritance.AllPersist4;
import org.apache.jdo.tck.pc.inheritance.Constants;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Persistent Fields Are Persistent in SubClasses
*Keywords: inheritance
*Assertion ID: A6.5-4.
*Assertion Description:
Fields identified as persistent in persistence-capable classes
will be persistent in subclasses.
*/
public class PersistentFieldsArePersistentInSubClasses extends TestParts {
/** */
private static final String ASSERTION_FAILED =
"Assertion A6.5-4 (PersistentFieldsArePersistentInSubClasses) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(PersistentFieldsArePersistentInSubClasses.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
addTearDownClass(AllPersist4.class);
}
/** */
public void test() {
pm = getPM();
runTest(pm);
pm.close();
pm = null;
}
/** */
void runTest(PersistenceManager pm)
{
Transaction t = pm.currentTransaction();
try {
t.setRestoreValues(true);
t.begin();
AllPersist4 refa = new AllPersist4(Constants.intA_V[1], Constants.doubleB_V[1], Constants.intB_V[1], Constants.charC_V[1], Constants.booleanD_V[1], Constants.floatE_V[1], Constants.shortF_V[1], Constants.shortG_V[1], Constants.intH_V[1]);
pm.makePersistent(refa);
Object objPtrA = pm.getObjectId (refa);
refa.secondObj = new AllPersist4(Constants.intA_V[2], Constants.doubleB_V[2], Constants.intB_V[2], Constants.charC_V[2], Constants.booleanD_V[2], Constants.floatE_V[2], Constants.shortF_V[2], Constants.shortG_V[2], Constants.intH_V[2]);
TestParts.secondObj_V[1] = refa.secondObj;
refa.thirdObj = new AllPersist4(Constants.intA_V[3], Constants.doubleB_V[3], Constants.intB_V[3], Constants.charC_V[3], Constants.booleanD_V[3], Constants.floatE_V[3], Constants.shortF_V[3], Constants.shortG_V[3], Constants.intH_V[3]);
TestParts.thirdObj_V[1] = refa.thirdObj;
pm.makePersistent(refa.thirdObj);
Object objPtrB = pm.getObjectId (refa.thirdObj);
refa.fourthObj = new AllPersist4(Constants.intA_V[4], Constants.doubleB_V[4], Constants.intB_V[4], Constants.charC_V[4], Constants.booleanD_V[4], Constants.floatE_V[4], Constants.shortF_V[4], Constants.shortG_V[4], Constants.intH_V[4]);
TestParts.fourthObj_V[1] = refa.fourthObj;
t.commit();
t.begin();
AllPersist4 a = null;
AllPersist4 b = null;
try { // retrieve object created in previous transaction & store in value array for later comparison
TestParts.thirdObj_V[1] = (AllPersist4)pm.getObjectById(objPtrB, true);
}
catch (JDOUserException e) {
// could not locate persistent object created in previous transaction
fail(ASSERTION_FAILED,
"JDOUserException " + e + " could not reference thirdObj.");
}
try { // retrieve object created in previous transaction
a = (AllPersist4)pm.getObjectById(objPtrA, true);
checkPersistentAreCorrect(ASSERTION_FAILED, persistentAfterCommit, 1, a.doubleB, a.intB, a.shortF, a.thirdObj, a.intH);
// verify referenced persistent object contains correct values
b = a.thirdObj;
if(b != null) { // if previous error caused b to be null, then these tests cannot be performed.
checkPersistentAreCorrect(ASSERTION_FAILED, persistentAfterCommit, 3, b.doubleB, b.intB, b.shortF, b.thirdObj, b.intH);
}
}
catch (JDOUserException e) {
// could not locate persistent object created in previous transaction
fail(ASSERTION_FAILED,
"JDOUserException " + e + " could not reference previously created object.");
}
// set in new values
a.intA = Constants.intA_V[5];
a.charC = Constants.charC_V[5];
a.booleanD = Constants.booleanD_V[5];
a.shortG = Constants.shortG_V[5];
a.fourthObj = new AllPersist4(Constants.intA_V[6], Constants.doubleB_V[6], Constants.intB_V[6], Constants.charC_V[6], Constants.booleanD_V[6], Constants.floatE_V[6], Constants.shortF_V[6], Constants.shortG_V[6], Constants.intH_V[6]);
TestParts.fourthObj_V[5] = a.fourthObj;
a.floatE = Constants.floatE_V[5];
a.secondObj = null;
a.doubleB = Constants.doubleB_V[5];
a.intB = Constants.intB_V[5];
a.shortF = Constants.shortF_V[5];
a.thirdObj = null;
a.intH = Constants.intH_V[5];
b.intA = Constants.intA_V[7];
b.charC = Constants.charC_V[7];
b.booleanD = Constants.booleanD_V[7];
b.shortG = Constants.shortG_V[7];
b.fourthObj = null;
b.floatE = Constants.floatE_V[7];
b.secondObj = null;
b.doubleB = Constants.doubleB_V[7];
b.intB = Constants.intB_V[7];
b.shortF = Constants.shortF_V[7];
b.thirdObj = null;
b.intH = Constants.intH_V[7];
// create new objects and make persistent
AllPersist4 c = new AllPersist4(Constants.intA_V[8], Constants.doubleB_V[8], Constants.intB_V[8], Constants.charC_V[8], Constants.booleanD_V[8], Constants.floatE_V[8], Constants.shortF_V[8], Constants.shortG_V[8], Constants.intH_V[8]);
AllPersist4 d = new AllPersist4(Constants.intA_V[9], Constants.doubleB_V[9], Constants.intB_V[9], Constants.charC_V[9], Constants.booleanD_V[9], Constants.floatE_V[9], Constants.shortF_V[9], Constants.shortG_V[9], Constants.intH_V[9]);
c.thirdObj = d;
c.fourthObj = d;
TestParts.thirdObj_V[8] = d;
TestParts.fourthObj_V[8] = d;
pm.makePersistent(c);
// change values of newly persistent object
c.intA = Constants.intA_V[10];
c.charC = Constants.charC_V[10];
c.booleanD = Constants.booleanD_V[10];
c.shortG = Constants.shortG_V[10];
c.fourthObj = null;
c.floatE = Constants.floatE_V[10];
c.secondObj = null;
c.doubleB = Constants.doubleB_V[10];
c.intB = Constants.intB_V[10];
c.shortF = Constants.shortF_V[10];
c.thirdObj = null;
c.intH = Constants.intH_V[10];
t.rollback();
// verify objects revert back to transient after rollback
checkPersistentAreCorrect(ASSERTION_FAILED, transientAfterRollback, 8, c.doubleB, c.intB, c.shortF, c.thirdObj, c.intH);
t.begin();
// verify rollback lost all persistent changes.
try { // retrieve object created in previous transaction & store in value array for later comparison
TestParts.thirdObj_V[1] = (AllPersist4)pm.getObjectById(objPtrB, true);
}
catch (JDOUserException e) {
// could not locate persistent object created in previous transaction
fail(ASSERTION_FAILED,
"JDOUserException " + e + " could not reference thirdObj.");
}
try { // retrieve object created in previous transaction
a = (AllPersist4)pm.getObjectById(objPtrA, true);
checkPersistentAreCorrect(ASSERTION_FAILED, persistentAfterRollback, 1, a.doubleB, a.intB, a.shortF, a.thirdObj, a.intH);
b = a.thirdObj;
if(b != null) { // if previous error caused b to be null, then these tests cannot be performed.
checkPersistentAreCorrect(ASSERTION_FAILED, persistentAfterRollback, 3, b.doubleB, b.intB, b.shortF, b.thirdObj, b.intH);
}
}
catch (JDOUserException e) {
// could not locate persistent object created in previous transaction
fail(ASSERTION_FAILED,
"JDOUserException " + e + " could not reference previously created object.");
}
t.rollback();
t = null;
}
finally {
if ((t != null) && t.isActive())
t.rollback();
}
}
void removeAllInstances(PersistenceManager pm)
{
AllPersist4 a = new AllPersist4(0, 0.0, 0, '0', false, 0.0f, (short)0, (short)0, 0);
pm.makePersistent(a); // guarantee the class is registered; this will be removed
Extent e = pm.getExtent(AllPersist4.class, true);
Iterator i = e.iterator();
while( i.hasNext() ){
pm.deletePersistent(i.next());
}
}
}
tck/src/java/org/apache/jdo/tck/models/inheritance/TestParts.java 100664 13724 12500110373 25324 0 ustar mbouschen staff 0 0 /*
* 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.models.inheritance;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.inheritance.Constants;
/**
* The test data is in arrays, making it easy to change values. The Inheritance test classes refer to the
* data via array index and the checkXXXX() routines carry an index value--indicating the expected value.
* If those attributes are references and should be other than null, as is the case with thirdObj, then the
* test code inserts the reference into the data array.
*
* Each test class follows the same pattern:
* 1. Persistent and transient object are created in the first transaction.
* 2. A second transaction is started, the first persistent object retrieved and checking is done on
* its attribute values.
* 3. A rollback is performed and value comparisions are made on the transient instances that were created.
* 4. A third transation is started and the first persistent object again retrieved and checking is done on
* its attribute values.
*/
public abstract class TestParts extends JDO_Test {
// 0 1 2 3 4 5 6 7 8 9 10 11
static final Object[] secondObj_V = { null, null, null, null, null, null, null, null, null, null, null, null};
static final Object[] thirdObj_V = { null, null, null, null, null, null, null, null, null, null, null, null};
static final Object[] fourthObj_V = { null, null, null, null, null, null, null, null, null, null, null, null};
static String persistentAfterCommit = "Read object back after committed to Database. ";
static String persistentAfterRollback = "Read object back after rollback. ";
static String transientAfterRollback = "Object reverted to transient after rollback. ";
/** */
void checkPersistentAreCorrect(String assertion, String title, int index,
double doubleB, int intB, short shortF,
Object thirdObj, int intH) {
if(doubleB != Constants.doubleB_V[index]) {
fail(assertion,
title + "Persistent attribute doubleB is " + doubleB +
", it should be " + Constants.doubleB_V[index]);
}
if(intB != Constants.intB_V[index]) {
fail(assertion,
title + "Persistent attribute intB is " + intB +
", it should be " + Constants.intB_V[index]);
}
if(shortF != Constants.shortF_V[index]) {
fail(assertion,
title + "Persistent attribute shortF is " + shortF +
", it should be " + Constants.shortF_V[index]);
}
if(thirdObj != TestParts.thirdObj_V[index]) {
fail(assertion,
title + "Persistent attribute thirdObj is " + thirdObj +
", it should be " + TestParts.thirdObj_V[index]);
}
if(intH != Constants.intH_V[index]) {
fail(assertion,
title + "Persistent attribute intH is " + intH +
", it should be " + Constants.intH_V[index]);
}
}
/** */
void checkTransactionalAreCorrect(String assertion, String title, int index,
float floatE, Object secondObj) {
if(floatE != Constants.floatE_V[index]) {
fail(assertion,
title + "Transactional attribute floatE is " + floatE +
", it should be " + Constants.floatE_V[index]);
}
if(secondObj != TestParts.secondObj_V[index]) {
fail(assertion,
title + "Transactional attribute secondObj is " + secondObj +
", it should be " + TestParts.secondObj_V[index]);
}
}
/** */
void checkNonpersistentAreCorrect(String assertion, String title, int index,
int intA, char charC, boolean booleanD,
short shortG, Object fourthObj) {
if(intA != Constants.intA_V[index]) {
fail(assertion,
title + "In non-persistent class, attribute intA is " + intA +
", it should be " + Constants.intA_V[index]);
}
if(charC != Constants.charC_V[index]) {
fail(assertion,
title + "In non-persistent class, attribute charC is " + charC +
", it should be " + Constants.charC_V[index]);
}
if(booleanD != Constants.booleanD_V[index]) {
fail(assertion,
title + "In non-persistent class, attribute booleanD is " + booleanD +
", it should be " + Constants.booleanD_V[index]);
}
if(shortG != Constants.shortG_V[index]) {
fail(assertion,
title + "In non-persistent class, attribute shortG is " + shortG +
", it should be " + Constants.shortG_V[index]);
}
if(fourthObj != TestParts.fourthObj_V[index]) {
fail(assertion,
title + "In non-persistent class, attribute fourthObj is " + fourthObj +
", it should be " + TestParts.fourthObj_V[index]);
}
}
}
././@LongLink 100644 0 0 150 12500111677 10247 L ustar 0 0 tck/src/java/org/apache/jdo/tck/models/inheritance/TransactionalFieldsAreTransactionalInSubclasses.java tck/src/java/org/apache/jdo/tck/models/inheritance/TransactionalFieldsAreTransactionalInSubclasses.j100664 10736 12500110373 34326 0 ustar mbouschen staff 0 0 /*
* 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.models.inheritance;
import java.util.Iterator;
import javax.jdo.Extent;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.jdo.tck.JDO_Test;
import org.apache.jdo.tck.pc.inheritance.AllPersist4;
import org.apache.jdo.tck.pc.inheritance.Constants;
import org.apache.jdo.tck.util.BatchTestRunner;
/**
*Title: Transactional Fields are Transactional in Subclasses
*Keywords: inheritance
*Assertion ID: A6.5-5.
*Assertion Description:
Fields marked as transactional in persistence-capable classes
will be transactional in subclasses.
*/
public class TransactionalFieldsAreTransactionalInSubclasses extends TestParts {
/** */
private static final String ASSERTION_FAILED =
"Assertion A6.5-5 (TransactionalFieldsAreTransactionalInSubclasses) failed: ";
/**
* The main is called when the class
* is directly executed from the command line.
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(TransactionalFieldsAreTransactionalInSubclasses.class);
}
/**
* @see JDO_Test#localSetUp()
*/
protected void localSetUp() {
addTearDownClass(AllPersist4.class);
}
/** */
public void test() {
pm = getPM();
runTest(pm);
pm.close();
pm = null;
}
/** */
void runTest(PersistenceManager pm)
{
Transaction t = pm.currentTransaction();
try {
t.setRestoreValues(true);
t.begin();
// create new objects and make persistent
AllPersist4 c = new AllPersist4(Constants.intA_V[8], Constants.doubleB_V[8], Constants.intB_V[8], Constants.charC_V[8], Constants.booleanD_V[8], Constants.floatE_V[8], Constants.shortF_V[8], Constants.shortG_V[8], Constants.intH_V[8]);
AllPersist4 d = new AllPersist4(Constants.intA_V[9], Constants.doubleB_V[9], Constants.intB_V[9], Constants.charC_V[9], Constants.booleanD_V[9], Constants.floatE_V[9], Constants.shortF_V[9], Constants.shortG_V[9], Constants.intH_V[9]);
c.thirdObj = d;
c.fourthObj = d;
TestParts.thirdObj_V[8] = d;
TestParts.fourthObj_V[8] = d;
pm.makePersistent(c);
// change values of newly persistent object
c.intA = Constants.intA_V[10];
c.charC = Constants.charC_V[10];
c.booleanD = Constants.booleanD_V[10];
c.shortG = Constants.shortG_V[10];
c.fourthObj = null;
c.floatE = Constants.floatE_V[10];
c.secondObj = d;
c.doubleB = Constants.doubleB_V[10];
c.intB = Constants.intB_V[10];
c.shortF = Constants.shortF_V[10];
c.thirdObj = null;
c.intH = Constants.intH_V[10];
t.rollback();
t = null;
// verify objects revert back to transient after rollback
checkTransactionalAreCorrect(ASSERTION_FAILED, transientAfterRollback, 8, c.floatE, c.secondObj);
}
finally {
if ((t != null) && t.isActive())
t.rollback();
}
}
void removeAllInstances(PersistenceManager pm)
{
AllPersist4 a = new AllPersist4(0, 0.0, 0, '0', false, 0.0f, (short)0, (short)0, 0);
pm.makePersistent(a); // guarantee the class is registered; this will be removed
Extent e = pm.getExtent(AllPersist4.class, true);
Iterator i = e.iterator();
while( i.hasNext() ){
pm.deletePersistent(i.next());
}
}
}
tck/src/java/org/apache/jdo/tck/pc/building/Kitchen.java 100664 5626 12500110372 23364 0 ustar mbouschen staff 0 0 /*
* 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.pc.building;
import java.io.Serializable;
/** This class represents an online shopping cart. It has a list of entries of
* type CartEntry.
*/
public class Kitchen implements Serializable {
protected static long nextId = System.currentTimeMillis();
public synchronized static long nextId() {
return nextId++;
}
/** Identity field for use with application identity */
protected long id;
/** The Oven we are using. */
protected Oven oven;
public Kitchen() {
this(nextId());
}
public Kitchen(long id) {
setId(id);
}
public long getId() {
return id;
}
protected void setId(long id) {
this.id = id;
}
public void setOven(Oven ov) {
this.oven = ov;
}
public Oven getOven() {
return oven;
}
public boolean equals(Object that) {
if (this == that) {
return true;
}
if (that == null) {
return false;
}
if (!(that instanceof Kitchen)) {
return false;
}
return equals((Kitchen) that);
}
public boolean equals(Kitchen that) {
if (this == that) {
return true;
}
if (that == null) {
return false;
}
return this.id == that.id;
}
public int hashCode() {
return (int) id;
}
public static class Oid implements Serializable {
public long id;
public Oid() {
}
public Oid(String s) {
id = Long.parseLong(justTheId(s));
}
public String toString() {
return this.getClass().getName() + ":" + id;
}
public int hashCode() {
return (int) id;
}
public boolean equals(Object other) {
if (other != null && (other instanceof Oid)) {
Oid that = (Oid) other;
return that.id == this.id;
}
return false;
}
protected static String justTheId(String str) {
return str.substring(str.indexOf(':') + 1);
}
}
}
tck/src/java/org/apache/jdo/tck/pc/building/MultifunctionOven.java 100664 4103 12500110372 25454 0 ustar mbouschen staff 0 0 /*
* 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.pc.building;
import java.io.Serializable;
/**
* Representation of a multifunction oven in a fitted kitchen.
*/
public class MultifunctionOven extends Oven implements Serializable {
/** Whether this oven provides a microwave. */
protected boolean microwave;
/** Capabilities of this model */
protected String capabilities;
public MultifunctionOven(String make, String model) {
super(make, model);
}
public void setMicrowave(boolean micro) {
this.microwave = micro;
}
public boolean getMicrowave() {
return microwave;
}
public void setCapabilities(String caps) {
this.capabilities = caps;
}
public String getCapabilities() {
return capabilities;
}
public boolean equals(Object that) {
if (this == that) {
return true;
}
if (that == null) {
return false;
}
if (!(that instanceof MultifunctionOven)) {
return false;
}
return super.equals((MultifunctionOven) that);
}
public boolean equals(MultifunctionOven that) {
if (this == that) {
return true;
}
if (that == null) {
return false;
}
return super.equals(that);
}
}
tck/src/java/org/apache/jdo/tck/pc/building/Oven.java 100664 4551 12500110372 22702 0 ustar mbouschen staff 0 0 /*
* 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.pc.building;
import java.io.Serializable;
/**
* Representation of an oven in a fitted kitchen.
*/
public class Oven implements Serializable {
/** Manufacturer of the appliance. */
protected String make;
/** Model of this appliance. */
protected String model;
public Oven(String make, String model) {
setMake(make);
setModel(model);
}
public void setMake(String make) {
this.make = make;
}
public String getMake() {
return make;
}
public void setModel(String model) {
this.model = model;
}
public String getModel() {
return model;
}
public boolean equals(Object that) {
if (this == that) {
return true;
}
if (that == null) {
return false;
}
if (!(that instanceof Oven)) {
return false;
}
return equals((Oven) that);
}
public boolean equals(Oven that) {
if (this == that) {
return true;
}
if (that == null) {
return false;
}
if ((make == null && that.make != null) ||
(make != null && that.make == null)) {
return false;
}
if ((model == null && that.model != null) ||
(model != null && that.model == null)) {
return false;
}
return this.make.equals(that.make) && this.model.equals(that.make);
}
public int hashCode() {
return (make != null ? make.hashCode() : 0) ^ (model != null ? model.hashCode() : 0);
}
}
tck/src/java/org/apache/jdo/tck/pc/building/package.html 100664 1654 12500110372 23412 0 ustar mbouschen staff 0 0
Package providing a simple model for testing embedding of objects and, in particular,
the use of inheritance of the embedded objects.
tck/src/java/org/apache/jdo/tck/pc/company/Address.java 100664 24604 12500110373 23253 0 ustar mbouschen staff 0 0 /*
* 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.pc.company;
import java.io.Serializable;
import java.util.Comparator;
import org.apache.jdo.tck.util.DeepEquality;
import org.apache.jdo.tck.util.EqualityHelper;
/**
* This class represents a postal address.
*/
public class Address
implements IAddress, Serializable, Comparable, Comparator, DeepEquality {
private long addrid;
private String street;
private String city;
private String state;
private String zipcode;
private String country;
/** This is the JDO-required no-args constructor. The TCK relies on
* this constructor for testing PersistenceManager.newInstance(PCClass).
*/
public Address() {}
/**
* This constructor initializes the Address components.
* @param addrid The address ID.
* @param street The street address.
* @param city The city.
* @param state The state.
* @param zipcode The zip code.
* @param country The zip country.
*/
public Address(long addrid, String street, String city,
String state, String zipcode, String country)
{
this.addrid = addrid;
this.street = street;
this.city = city;
this.state = state;
this.zipcode = zipcode;
this.country = country;
}
/**
* Get the addrid associated with this object.
* @return the addrid.
*/
public long getAddrid() {
return addrid;
}
/**
* Set the id associated with this object.
* @param id the id.
*/
public void setAddrid(long id) {
if (this.addrid != 0)
throw new IllegalStateException("Id is already set.");
this.addrid = id;
}
/**
* Get the street component of the address.
* @return The street component of the address.
*/
public String getStreet() {
return street;
}
/**
* Set the street component of the address.
* @param street The street component.
*/
public void setStreet(String street) {
this.street = street;
}
/**
* Get the city.
* @return The city component of the address.
*/
public String getCity() {
return city;
}
/**
* Set the city component of the address.
* @param city The city.
*/
public void setCity(String city) {
this.city = city;
}
/**
* Get the state component of the address.
* @return The state.
*/
public String getState() {
return state;
}
/**
* Set the state component of the address.
* @param state The state.
*/
public void setState(String state) {
this.state = state;
}
/**
* Get the zipcode component of the address.
* @return The zipcode.
*/
public String getZipcode() {
return zipcode;
}
/**
* Set the zip code component of the address.
* @param zipcode The zipcode.
*/
public void setZipcode(String zipcode) {
this.zipcode = zipcode;
}
/**
* Get the country component of the address.
* @return The country.
*/
public String getCountry() {
return country;
}
/**
* Set the country component of the address.
* @param country The country.
*/
public void setCountry(String country) {
this.country = country;
}
/**
* Returns a String representation of a Address object.
* @return a String representation of a Address object.
*/
public String toString() {
return "Address(" + getFieldRepr() + ")";
}
/**
* Returns a String representation of the non-relationship fields.
* @return a String representation of the non-relationship fields.
*/
protected String getFieldRepr() {
StringBuffer rc = new StringBuffer();
rc.append(addrid);
rc.append(", street ").append(street);
rc.append(", city ").append(city);
rc.append(", state ").append(state);
rc.append(", zipcode ").append(zipcode);
rc.append(", country ").append(country);
return rc.toString();
}
/**
* Returns true if all the fields of this instance are
* deep equal to the coresponding fields of the specified Person.
* @param other the object with which to compare.
* @param helper EqualityHelper to keep track of instances that have
* already been processed.
* @return true if all the fields are deep equal;
* false otherwise.
* @throws ClassCastException if the specified instances' type prevents
* it from being compared to this instance.
*/
public boolean deepCompareFields(Object other,
EqualityHelper helper) {
IAddress otherAddress = (IAddress)other;
String where = "Address<" + addrid + ">";
return
helper.equals(addrid, otherAddress.getAddrid(), where + ".addrid") &
helper.equals(street, otherAddress.getStreet(), where + ".street") &
helper.equals(city, otherAddress.getCity(), where + ".city") &
helper.equals(state, otherAddress.getState(), where + ".state") &
helper.equals(zipcode, otherAddress.getZipcode(), where + ".zipcode") &
helper.equals(country, otherAddress.getCountry(), where + ".country");
}
/**
* Compares this object with the specified object for order. Returns a
* negative integer, zero, or a positive integer as this object is less
* than, equal to, or greater than the specified object.
* @param o The Object to be compared.
* @return a negative integer, zero, or a positive integer as this
* object is less than, equal to, or greater than the specified object.
* @throws ClassCastException - if the specified object's type prevents
* it from being compared to this Object.
*/
public int compareTo(Object o) {
return compareTo((IAddress)o);
}
/**
* Compare two instances. This is a method in Comparator.
*/
public int compare(Object o1, Object o2) {
return compare((IAddress)o1, (IAddress)o2);
}
/**
* Compares this object with the specified Address object for
* order. Returns a negative integer, zero, or a positive integer as
* this object is less than, equal to, or greater than the specified
* object.
* @param other The Address object to be compared.
* @return a negative integer, zero, or a positive integer as this
* object is less than, equal to, or greater than the specified Address
* object.
*/
public int compareTo(IAddress other) {
return compare(this, other);
}
/**
* Compares its two IAddress arguments for order. Returns a negative
* integer, zero, or a positive integer as the first argument is less
* than, equal to, or greater than the second.
* @param o1 the first IAddress object to be compared.
* @param o2 the second IAddress object to be compared.
* @return a negative integer, zero, or a positive integer as the first
* object is less than, equal to, or greater than the second object.
*/
public static int compare(IAddress o1, IAddress o2) {
return EqualityHelper.compare(o1.getAddrid(), o2.getAddrid());
}
/**
* Indicates whether some other object is "equal to" this one.
* @param obj the object with which to compare.
* @return true if this object is the same as the obj
* argument; false otherwise.
*/
public boolean equals(Object obj) {
if (obj instanceof IAddress) {
return compareTo((IAddress)obj) == 0;
}
return false;
}
/**
* Returns a hash code value for the object.
* @return a hash code value for this object.
*/
public int hashCode() {
return (int)addrid;
}
/**
* This class is used to represent the application identifier
* for the Address class.
*/
public static class Oid implements Serializable, Comparable {
/**
* This is the identifier field for Address and must
* correspond in type and name to the field in
* Address.
*/
public long addrid;
/** The required public, no-arg constructor. */
public Oid()
{
addrid = 0;
}
/**
* A constructor to initialize the identifier field.
* @param addrid the id of the Address.
*/
public Oid(long addrid) {
this.addrid = addrid;
}
public Oid(String s) { addrid = Long.parseLong(justTheId(s)); }
public String toString() { return this.getClass().getName() + ": " + addrid;}
/** */
public boolean equals(java.lang.Object obj) {
if( obj==null || !this.getClass().equals(obj.getClass()) )
return( false );
Oid o = (Oid) obj;
if( this.addrid != o.addrid ) return( false );
return( true );
}
/** */
public int hashCode() {
return( (int) addrid );
}
protected static String justTheId(String str) {
return str.substring(str.indexOf(':') + 1);
}
/** */
public int compareTo(Object obj) {
// may throw ClassCastException which the user must handle
Oid other = (Oid) obj;
if( addrid < other.addrid ) return -1;
if( addrid > other.addrid ) return 1;
return 0;
}
}
}
tck/src/java/org/apache/jdo/tck/pc/company/Company.java 100664 27307 12500110373 23277 0 ustar mbouschen staff 0 0 /*
* 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.pc.company;
import java.io.Serializable;
import java.io.ObjectInputStream;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Collections;
import java.util.Comparator;
import java.util.Set;
import java.util.HashSet;
import java.util.Date;
import org.apache.jdo.tck.util.DeepEquality;
import org.apache.jdo.tck.util.EqualityHelper;
/**
* This class represents information about a company.
*/
public class Company
implements ICompany, Serializable, Comparable, Comparator, DeepEquality {
private long companyid;
private String name;
private Date founded;
private Address address;
private transient Set departments = new HashSet(); // element type is Department
protected static SimpleDateFormat formatter =
new SimpleDateFormat("d/MMM/yyyy");
/** This is the JDO-required no-args constructor. The TCK relies on
* this constructor for testing PersistenceManager.newInstance(PCClass).
*/
public Company() {}
/**
* Initialize the Company instance.
* @param companyid The company id.
* @param name The company name.
* @param founded The date the company was founded.
*/
public Company(long companyid, String name, Date founded) {
this.companyid = companyid;
this.name = name;
this.founded = founded;
}
/**
* Initialize the Company instance.
* @param companyid The company id.
* @param name The company name.
* @param founded The date the company was founded.
* @param addr The company's address.
*/
public Company(long companyid, String name, Date founded, IAddress addr) {
this(companyid, name, founded);
this.address = (Address)addr;
}
/**
* Get the company id.
* @return The company id.
*/
public long getCompanyid() {
return companyid;
}
/**
* Set the id associated with this object.
* @param id the id.
*/
public void setCompanyid(long id) {
if (this.companyid != 0)
throw new IllegalStateException("Id is already set.");
this.companyid = id;
}
/**
* Get the name of the company.
* @return The name of the company.
*/
public String getName() {
return name;
}
/**
* Set the name of the company.
* @param name The value to use for the name of the company.
*/
public void setName(String name) {
this.name = name;
}
/**
* Get the date that the company was founded.
* @return The date the company was founded.
*/
public Date getFounded() {
return founded;
}
/**
* Set the date that the company was founded.
* @param founded The date to set that the company was founded.
*/
public void setFounded(Date founded) {
this.founded = founded;
}
/**
* Get the address of the company.
* @return The primary address of the company.
*/
public IAddress getAddress() {
return address;
}
/**
* Set the primary address for the company.
* @param address The address to set for the company.
*/
public void setAddress(IAddress address) {
this.address = (Address)address;
}
/**
* Get the departments contained in the company.
* @return An unmodifiable Set that contains all the
* Departments of the company.
*/
public Set getDepartments() {
return Collections.unmodifiableSet(departments);
}
/**
* Add a Department instance to the company.
* @param dept The Department instance to add.
*/
public void addDepartment(Department dept) {
departments.add(dept);
}
/**
* Remove a Department instance from the company.
* @param dept The Department instance to remove.
*/
public void removeDepartment(Department dept) {
departments.remove(dept);
}
/**
* Initialize the set of Departments in the company to the
* parameter.
* @param departments The set of Departments for the
* company.
*/
public void setDepartments(Set departments) {
// workaround: create a new HashSet, because fostore does not
// support LinkedHashSet
this.departments =
(departments != null) ? new HashSet(departments) : null;
}
/** Serialization support: initialize transient fields. */
private void readObject(ObjectInputStream in)
throws IOException, ClassNotFoundException {
in.defaultReadObject();
departments = new HashSet();
}
/**
* Returns a String representation of a Company object.
* @return a String representation of a Company object.
*/
public String toString() {
return "Company(" + getFieldRepr()+ ")";
}
/**
* Returns a String representation of the non-relationship fields.
* @return a String representation of the non-relationship fields.
*/
protected String getFieldRepr() {
StringBuffer rc = new StringBuffer();
rc.append(companyid);
rc.append(", name ").append(name);
rc.append(", founded ").append(
founded==null ? "null" : formatter.format(founded));
return rc.toString();
}
/**
* Returns true if all the fields of this instance are
* deep equal to the coresponding fields of the specified Person.
* @param other the object with which to compare.
* @param helper EqualityHelper to keep track of instances that have
* already been processed.
* @return true if all the fields are deep equal;
* false otherwise.
* @throws ClassCastException if the specified instances' type prevents
* it from being compared to this instance.
*/
public boolean deepCompareFields(Object other,
EqualityHelper helper) {
ICompany otherCompany = (ICompany)other;
String where = "Company<" + companyid + ">";
return
helper.equals(companyid, otherCompany.getCompanyid(), where + ".companyid") &
helper.equals(name, otherCompany.getName(), where + ".name") &
helper.equals(founded, otherCompany.getFounded(), where + ".founded") &
helper.deepEquals(address, otherCompany.getAddress(), where + ".address") &
helper.deepEquals(departments, otherCompany.getDepartments(), where + ".departments");
}
/**
* Compares this object with the specified object for order. Returns a
* negative integer, zero, or a positive integer as this object is less
* than, equal to, or greater than the specified object.
* @param o The Object to be compared.
* @return a negative integer, zero, or a positive integer as this
* object is less than, equal to, or greater than the specified object.
* @throws ClassCastException - if the specified object's type prevents
* it from being compared to this Object.
*/
public int compareTo(Object o) {
return compareTo((ICompany)o);
}
/**
* Compare two instances. This is a method in Comparator.
*/
public int compare(Object o1, Object o2) {
return compare((ICompany)o1, (ICompany)o2);
}
/**
* Compares this object with the specified Company object for
* order. Returns a negative integer, zero, or a positive integer as
* this object is less than, equal to, or greater than the specified
* object.
* @param other The Company object to be compared.
* @return a negative integer, zero, or a positive integer as this
* object is less than, equal to, or greater than the specified Company
* object.
*/
public int compareTo(ICompany other) {
return compare(this, other);
}
/**
* Compares its two ICompany arguments for order. Returns a negative
* integer, zero, or a positive integer as the first argument is less
* than, equal to, or greater than the second.
* @param o1 the first ICompany object to be compared.
* @param o2 the second ICompany object to be compared.
* @return a negative integer, zero, or a positive integer as the first
* object is less than, equal to, or greater than the second object.
*/
public static int compare(ICompany o1, ICompany o2) {
return EqualityHelper.compare(o1.getCompanyid(), o2.getCompanyid());
}
/**
* Indicates whether some other object is "equal to" this one.
* @param obj the object with which to compare.
* @return true if this object is the same as the obj
* argument; false otherwise.
*/
public boolean equals(Object obj) {
if (obj instanceof ICompany) {
return compareTo((ICompany)obj) == 0;
}
return false;
}
/**
* Returns a hash code value for the object.
* @return a hash code value for this object.
*/
public int hashCode() {
return (int)companyid;
}
/**
* The class to be used as the application identifier
* for the Company class. It consists of both the company
* name and the date that the company was founded.
*/
public static class Oid implements Serializable, Comparable {
/**
* This field is part of the identifier and should match in name
* and type with a field in the Company class.
*/
public long companyid;
/** The required public no-arg constructor. */
public Oid() { }
/**
* Initialize the identifier.
* @param companyid The id of the company.
*/
public Oid(long companyid) {
this.companyid = companyid;
}
public Oid(String s) { companyid = Long.parseLong(justTheId(s)); }
public String toString() { return this.getClass().getName() + ": " + companyid;}
/** */
public boolean equals(Object obj) {
if (obj==null || !this.getClass().equals(obj.getClass()))
return false;
Oid o = (Oid) obj;
if (this.companyid != o.companyid)
return false;
return true;
}
/** */
public int hashCode() {
return (int)companyid;
}
protected static String justTheId(String str) {
return str.substring(str.indexOf(':') + 1);
}
/** */
public int compareTo(Object obj) {
// may throw ClassCastException which the user must handle
Oid other = (Oid) obj;
if( companyid < other.companyid ) return -1;
if( companyid > other.companyid ) return 1;
return 0;
}
}
}
tck/src/java/org/apache/jdo/tck/pc/company/company.jpg 100664 263513 12500110373 23217 0 ustar mbouschen staff 0 0 ÿØÿà JFIF ÿÛ C
$.' ",# (7),01444 '9=82<.342ÿÛ C
2! !22222222222222222222222222222222222222222222222222ÿÀ ¶'" ÿÄ ÿÄ W !"12AQV•Ó#6TUu“³Ô$35Ba”Ò%4R‘´bqC&7Scs‚Ddrƒ’µãEFv†ÁÃÅÿÄ ÿÄ 4 Q!1R‘ÑAaq¡Ááð23±"ñ#C4BÿÚ ? ÷úR””¥ ¥)@)JP
R””¥ ¥)@)JP
R””¥ ¥)@)JP
R””¥ ¥)@)JP
R””¥ ¥)@)JP
R””¥ ¥)@)JP
R””¥ ¥)@)JP
R””¥ ¥)@)JP
R””¥ ¥)@)JP
R””¥ ¥)@)JP
R””¥ ¥)@)JP
R””¥ ¥)@)JP
R””¥ ¥)@)JP
R””¥ ¥)@)JP
R””¯‰¦ŠÞ 'žDŠ(Ô»ÈìU@Ù$Ÿ€€û¥Fù_Ó?h± ëcÿ u>WôÏÚ,GúØÿ ÝCMMNȳJò¿¦~Ñb?ÖÇþê|¯éŸ´Xõ±ÿ ºƒSS…ò,Ò£|¯éŸ´Xõ±ÿ ºŸ+úgí#ýlî ÔÔá|‹4¨ß+úgí#ýlî§Êþ™ûEˆÿ [ û¨558_"Í*7Êþ™ûEˆÿ [ û©ò¿¦~Ñb?ÖÇþê
MNȳJò¿¦~Ñb?ÖÇþê|¯éŸ´Xõ±ÿ ºƒSS…ò,Ò£|¯éŸ´Xõ±ÿ º¬Ð¬¡(ýÊ”¥
ŠR””¥ ¥)@)JP
R””¥ ¥)@)JP
R””¥ ¥)@)JP
R””¥ ¥)@)JP
R””¥ ¥)@)JP
R””¥ ¥)@)\Ná-ïúcysy—y糆Y Þ×C“2N„š OÑT¾MXþ“—ûÞëñ+é0NÆò§¶›{;½ËÔ¨?&¬IËýïuø”ù5cúN_ï{¯Ä¨ú¨dÊà†o—¹z•äÕé9½î¿Ÿ&¬IËýïuø”ú¨dÆfù{—©P~MXþ“—ûÞëñ)òjÇôœ¿Þ÷_‰Oª†L`†o—¹z•äÕé9½î¿Ÿ&¬IËýïuø”ú¨dÆfù{—©P~MXþ“—ûÞëñ)òjÇôœ¿Þ÷_‰Oª†L`†o—¹z•äÕé9½î¿Ÿ&¬IËýïuø”ú¨dÆfù{—©P~MXþ“—ûÞëñ)òjÇôœ¿Þ÷_‰Oª†L`†o—¹z•äÕé9½î¿Ÿ&¬IËýïuø”ú¨dÆfù{—©P~MXþ“—ûÞëñ)òjÇôœ¿Þ÷_‰Oª†L`†o—¹z•äÕé9½î¿Ÿ&¬IËýïuø”ú¨dÆfù{—©RzZin:G <ò<²Éa¼ŽÅ™˜Æ¤’OÄ“U«¤¤£†N9
R”*)JP
R””¥ ¥)@)JP
R”£uæV{öuÇðÚ¬Ôn¯üÊÏ~θþPÒäŠ)Ò”¯
׳½·È@ÓZÉÜe’x‘§Ù yú™Xž¼xŠóœU³ärÖ÷¾¾‚ÍåÏK4V·-t®A픆æNÔƒñâX%rF¥ymÎræ\?Od¯òŽ×8‹k…‚+ç³™ç+ÉÚÞ5S ܬJ zTª
jZ©–ÎûC'Ÿ+ì÷³çñÞÅl÷ $’Ý¢¿mIÙŒ‘0:ðO=ý58¹ßR¼æK‡·é»«ÛÌô‚ç5wyòmioQÜ\W™Ahcô€}LÆ8Éá¥ð^õ˜ {ëìŒ5¾[»7RÄÎ!»Š8•Ü…”•]z:<¾s‚ÀJ¥y–eoíñ7=E›º²yðV76OíOvâC7ÓÄïâ É•p9(ãë!²d2/—ÓÛ Ø ™2Éi ™)’Gµ+ —…š¡I”“8î·Í<‰*"0=Âç£R”ªFêï̼ïìûáµ_¨ ]ù—ýŸqü6«õÛ¢îe§ø׋ô¥+¨ÄR” ¥()JJR€R” ¥()JJR€R” ¥( Kqsm‡
ipöóIumuY•dž4mo‹ ˆ5‡Ý µoÝZþ}õO÷7hÔ›ÿ ý
cÉr]ÿ Ý µoÝZþ=Ñ‘ûQ–ýÕ¯àT{¾£ËÃy›Çb-¬ò¸ëfevs$âØq°8¡œ·ð6œy2,Õãå¬q÷ðØÜ\ÛæšÉîRƒÍƒÜ #RÌcm0CêmŽ_Z u3Ç’äº=Ñ‘ûQ–ýÕ¯àSÝ µoÝZþr˜Î¿ÈO‡ºÌM`óZ D¹UQaqj°Ue€Í +1`ÇN€É“Ćßê3Õ6¸4
“Ç,ç%`©s¬©É^åÇÝ'[*IçêRËÅ~qœu/fÈÖ<—%йîŒÚŒ·îžèÈý¨Ë~ê×ð*½*šéæN±ä¹.„td~Ôe¿ukø÷FGíF[÷V¿UéMtóÇ’äº=Ñ‘ûQ–ýÕ¯àSÝ µoÝZþW¥5ÓÌk K’èNé«‹›œ9k»‡¸š;«˜{®ª¬Ë ò"ì(|T| ªõ¥¿¹æý¡}ÿ •-Z¯J;‘J»*JÙ±JR¤ÌR” ¥( #ù—‚ýŸoü5«5Èô¿QYAÒXhž ™d±IL]Ë©"5 FA æUùOaú>[ï.Qw{º´§Ž_åï}…šTo”ö £å¾èºü:|§°ý -÷E×áÕp¼ŒõU8_"Í*7Ê{Ñòßt]~ >SØ~–û¢ëðé…ä5U8_"Í*7Ê{Ñòßt]~ >SØ~–û¢ëðé…ä5U8_"O]ÃÄ7Î#Þð¶U¹Yp‰»¿Õ.>‰YSÁõy#áãΫAd—¥l²¹k,¹¬¦ö;X1ý”n34ÍÏÙ·fâX¼)ý®>=&¯\fqSÚM5žY¤´”Í÷UØàå ñ ŸK°óõýz¥îg‘³’ÖêÏ,ð¾‰v¤A ¬#X`A"®¯d¬558_"L]Mž¸·±‚hÍÎU¬ÍåŒö©$~ÊówV<Ç^hÒºvß(r1ØfDüÚES¾1Fí¾N‘àŽvÛePO7Ùõ6Íw
UNÈšzÏ/O6VT±“Û0«8–_gí¤l"ó=Ý÷”r?˜|z½= ##‘“1}ŒÉ¯~x.ÕƒE•¥^ÙävåL'×¥åÈz^c$ *–÷vþìÌ´Vïjѽû,p¸ÓG*DHF½1ñ •ÿ ¤j¢fqä&¿[<°¹š(á‘ýÕwå¹Q®Þ¼ þÿ ä(ÖHjªp¾GAJòžÃô|·Ý_‡O”ö £å¾èºü:¦ÕTá|‹4¨ß)ì?GË}ÑuøtùOaú>[æÕTá|‹4¨ß)ì?GË}ÑuøtùOaú>[æÕTá|‹4¨ß)ì?GË}ÑuøtùOaú>[æÕTá|ŒÝ!ù•ýoü5«5¤?2°?³ÿ †µf½b•¿$¼X¥)C1JR€R” ¥()JJR€R” «ÿ 2³ß³®?†Õf£uæV{öuÇðÚ†”$|Q3)Ô|5ªÜ_c±h¯"Å¥üò<Ž~
ˆ–Řø'@ Ÿ€4Åõ_3j×8ì[ªHÑH¯AÑÁàEr?Ò@ƒ!Ô©mt.HÇؤÐÇk,HÓw^C"¸• Y«FèÉØmTnŽ¾»Ã䧟lÒÛ]ÛFnW%"©·uc"D¢(Ð/¦Y¯ÒFÀÜ´tYÖIA]™ée ›«VÊ+·oSÕ=§©Tâ~ó“ùz{ORþ©Äýç'òõ zòÒx®2XÛ‹Õ0ØE¹ ¹šê[rŠ¤öÃ++zÓø ¸€Õ·sÖYcn^êÊÖ Ë[Ñepe½+g –`ï9Mªu]”þÑ‚ëD5sÊŒœe4lªE«¨¯>¥/iê_Õ8Ÿ¼äþ^žÓÔ¿ªq?yÉü½M¸ê¸m×#yhü"÷ ÆÚìJ†8Z ð …8pÈç‰è^LL%öRç¬röù+ehqöeaŽç½ -%ÎÝ”ùAÚ©ÚkD&¶Ù{Ž<+Ï©½í=Kú§÷œŸËÓÚz—õN'ï9?—ª±™‹Ê%ê"®X²ñ Xhq<¹
ø ï·(™»Ë<¶fÚý®æã4––qO9Ž$þ¡Ì b‹¥øS¶o€Ù ¶ö qá^}JÞÓÔ¿ªq?yÉü½=§©Tâ~ó“ùzš½[}u5…¦?“^]%àIwÛŠ¶™!“oÀ±BÌÜX.ϧj%uïúñ£ÃÉ•Æb òÞ Dyy’IÖ)UÌaFˆ$v›Ÿ‘Äy^gÓL/!Ž<+Ï©kÚz—õN'ï9?—§´õ/êœOÞr/ViUºÈc
óêr=QqÔ
ÒY‘63‘òddfUí¶È³þ[ ûŠí*W~eçgÜ
ªývèÏcpVVÚý)Jé0¥()JJR€R” ¥()JJR€R” ¥()JW;&šDŽ(ï¬ÝØUQI? +çåwM}¡Äÿ ýÕ—ª¹áý¡cÿ •p½s—ÌÝõ"ã±®ãfnÅ·qpP¹ ð;€ \/å’ÅBŽZñÅ$Žˆ¸ªKí~Çkò»¦¾ÐâÖÇþê|®é¯´8Ÿõ±ÿ º¹n‚ë6Þåê;¸áËE2GRN³;Äê8• Wõ‡@ÛÙÒõ¸åÛ ¶9oÒÁ²¢ñÝ‘-ÌËÜfUÀ.öHVV#è À×<é¸ïET©¾ÇÏØÒù]Ó_hq?ëcÿ u>Wt×Ú OúØÿ Ý[3gqð\O6VÆ(mõß‘îV-»F9}>´eóþ%#â
|]f!ŽÝn-îqÏÙKw ’ÞÕÕBÛ
õ¦õIþ ¯ƒËÅ,²&ôò|ýŒ?+ºkí'ýlî¬}AÒXø\î&8ÚY&#Ûíävw>[éfcþ[ñâ¶s Cg‰xàîÁ-ëËl¾ÉÞ Ž[„‡¹ÇÉâ üu¢F¶*œ“à Ēʈó?•˜íĶ—ë~Ç7.O¢¦Šú938’·Ò¬ó‘PLŠ¨ªêCmÓEtAPFš–.ºn ¶,ZgpÑØÙ\5ëÏ.[½qq1†Hx¿2Id™rtxëDu™ Ÿ°^âm»<ýátÖܹk·¨e—–µçû-kÇÎßÑ¢;ˆ›Û»Y[÷~ý³Â fÖ÷Üóè×øë柪¦âôò|ýŽ~Ön‚³ïò¸—Žhšù!4i|è£Gr±ÆtDHUÒc' ÚÂ{7ÎÙÈ“¼o$²æÝæÜl =Ld2 ¬9 I#âwÔ&[ %½ÝÂd-Z 7tº‘fR°2
¸s½)QñáôÖKKë<„F[+¨.c vðÈ J y Z²°úÃð4¿ˆ½<Ÿ?bwÊîšûC‰ÿ [ û©ò»¦¾ÐâÖÇþê³J®Ázy>~Äo•Ý5ö‡þ¶?÷SåwM}¡Äÿ ýÕf”Ø/O'ÏØò»¦¾ÐâÖÇþê|®é¯´8Ÿõ±ÿ º¬Ò›éäùû:Bh®0/42$‘I}zèèÀ«)º”‚øƒWj/KsÍûBûÿ *Zµ^¬w"•¿$¼X¥)Rf)JP
R”’õÕä¿Ñ×Láln ·–ï“LnKˆd‚8£FŠ+7—š#Ä
2«@:1ú?::c4²,Ö×XlšH[â ~s¨X 1ìåRè y^~˜íí:Zרú7¦$’îòÎæÛ Ž{GPÜZ8Ë)¬¤ˆ~Fˆó¾në£3]3’1a-}í ÷äíî®
¡´sê~ð@lúŸ’€Ä€¤ÄÖz :5g«©+oùrŸôjV§Ê„qJûïøw³u~¬ÜÞ3›Ô‘í¢† $’^ÙPêT·%,9.¹
6Ç¥µ–ëª0Ö}“%ç8æ‰gÁÍDß6Y Xã:$;¤+ éN¹;lïLõ. \Ñd/䱿¸»’þFŒ]9’ÍI ¡»ZÒh`ëg˜ýºþn=žÒÒ9òˆ·ÄÎd¾¹´P± Ã'S ɳ.¸è7¨‘ÉV”Úƒ¼{>|ýn4ƒ–iÕËÕho/ óúŇsÄìc,¢ø YûŠFË…« ùOŠ÷¶÷§ãÝìv}–_hîk—Ç ç.>½qß WÍóZs`.^ ¢ me9 Øî IÔi!4YtÑ¿(IW]”‘Uá32‚HÙÖÍekì >«qÝü€~û^Þ[Ç
¬³»$7.´§&Öaðäl\õ~Öá “"Œïo Ð1#H¢,Å”"ô¹Z-äP÷Á›Ú Z4RŽ –-³ÈÖ€ŽŽÎö|
y±Ëœ³Ç]YÜÅ$ï5´W1òv •iäIev QtߧJ9 ”ê ŽœaÆo‘x¥Ä&(\Cw+WX½¤7¥ùn —Û«)U«õ
Ëæ÷vÙ‹¬H·@ƒxð5»†s+È±È *bâH}
¥úµñY,Šõ mx—؉쯥i¦vY‡ £TFVRÜⱞL‰rà2鬯¼ +…N¸™°öÙÛŒ3ÀdÁ]åaƒÛ‰Üq¬
Å€ vÅý-䪀.Ê´ä껋e¼Šóؽ‹ÙL0{@`ÂæS "FÐÁÔó
(ò¥þ\ Ý]ù—ýŸqü6«õÄä3nêø®ì=ŠâÂídA0”9öe“’¤÷jâîç¦Æ8Å™˜ xßÜGÝ·HÀ•Iñ"¶Ø$gÎùrø17ì°÷M—Íã-lÞà Æ4É•šei
ÛEi)¦bBž%ym¶zŽ~‚ë6Þåê;¸áËE2GRN³;Äê8• Wõ‡@ÛÙÒõ¸åÙ%ö"ß$Ö‰uc ý̧”"DË"Æ„í~,Â>Ù?H^?F«]7L«[ e’Ýo7áݹ Z.‡F„§(]¹;¶Ýßrð]Ç3÷ggy3¹qoŸ¾ÈÏoF²Ü$¦æ4`Y‚–á,GÔÃJºø€µ #„ÈIm&4[ÿ _¿Âõ‘[—]†¸¸†DF;ãÈw »D5èQå±Óe%ÆEµ|„)Î[E™L¨¾<²o`z—É HúëB,·K[¾C'C”ï®’h”•eü‰•Áø#‰cä À¤îu3[ù2—P®ïë;c“†ñ^ ˳£òæáÃñ†Oš§aÀß’m$Œ¬/ wâÌ¥uâO&Ù[ xÙÛÙ÷™lv>âÖÞ÷!km=Ûð·Ži•fØ@NØí‡õ®¶&žt<©T ìf
£ÏÒX€ÒHVÛ°&f,®.²?41òŽÓ óNyÁ
´èŸ©Ôxúþ×ý7›¸éaŒ÷kÅ>;¦.°êÏ,|næ‘!Uh´Ä„Ü'Ì©||x÷Y¬Ÿºq¦èCÞ‘¥Š£-Ä4’ȱ§&ÑÒòuÙ 6@'Á‘yÕ˜;˾¤ÆÁim¬—"k;³: Gm™ãŒ,Œ]B/žZo†¼Ì\»¡œÂKåäöÖðAd‘aÒÚ0é»[ÞI!… !‘T )gQ±ç[}¬/:¥žÁ, L¿uÑ”ñ-knÛb¾9íµ±È3|ãS#—ÄIŠ^óé‰$»¼³¹¶ÇÂ#žÑÔ7Ž2ÊC«)¢ †ÁQ¢<èÌ×LäŒXK_{G}ù;{«‚¨m úŸ¼Û>§ä 1 )ñ5ž‡NYêêJÛþ\§ý•©Ær¡ R¾Åûþ 6k¢Ž{8q·‘A ¶7 o§ÇÏqqà èU
i¼¶öÛRJòu«’õFËëG¼þ±aÄ\Ʊ;Ë(¾–~â„Q²çaA*ÀróG“˹¶´½[‹‹¬NBÚâæéˆ2Üܾ€!Pu¡ó@PòjäØ —‡¨‡YNBö;¨FuH`M]4oÊU×e ‘ƸëF’›TÝ×gÏŸ£H9áX÷ö‰ºÊÁn°ðÁÔÞñ½k6Öd{v4Ÿ”B›Btž¥¹üÕ&·,ú£
È5çru–Häœ –2ÁâæG àâÍÃ|ŠŽ@qóQíð¸Ó$’@íg•7FÞkÙgìÀÖòBʳº•¹Hd ÀùÜ6ƒ[½9yºyIö<ÕîBM1ó ÞÕÄ 8wÓG†ò|o6¢XÜN®Â=½ÝǵºÁkn÷M#ÛÈ«$(6ÒDJ*¯T|‡©êÇòק¿XêþÆOì¿û?ÍþÃÿ ·ÿ gÿ ª¹‰º=uï&¹¾‚Y®0·¸Ñ$·“ÉÝš^Þ¦âÛHUŠ Çé44\h-üïN^dþSvd}é…L| ØŽ2hÙm¥ü²ü6|
Í¢
“u2ß(1ÒNâ~k0‚CnÚâ(^çk¥fóMRï~I–'‰92¿ã0‰oQJ4§ÉÐއĀy ®¸›ªî/ø¤¶—7°^³>BåMÄû2 ‡p‚ ˜h°Ú°@¯Ì !hÈ_R–r¥W‰ò£G‘åÄhëÁ'~4jÒ쎧Ë͇²¶’)ím{·×ŠZ EàíÎAÉ|UŒm—Õ"ù?4˸ê{ü5orkRÒymÖ÷o IDòp "´é]8méùª?ùTÊ —𢗜NÜá8²ð.Šh²¾Âðãà1#™›¦ró[dn"´ÅY\Ü]Y\Œ.`y!¸I+ÉÚ¹ Ò“ÀŸÉ®Éø,ÆÖÚ w]MŒKÛŒ|YKË[ˆ"¸V·’A‘â
§Z ¸•B’u¾GÈG%ŸTa²±µ¼îN²Éü“„ÆX<\ÈãÜ Y¸o‘QÈ>j}×N^Oïn2@=³5el|G²òÇÎ=‡×Ñå|:Zôåä éå$ØóW¹ 4ÇÌs{W<|áßMý Éñµ£`PÇõF)wË–‰§D1:ó‰JŽê’ hÉqÅÆÕ¼ñ'‰ÕzóžŽw~¡ÃYEwcum‡ÂÍbM©c$d=°Sp¬†G·äHÚ˜ßÔÞxú5D•˜¥*¤ŠR””¥3¤?2°?³ÿ †µf£t‡æVöu¿ð֬׮+~Ix±JR†b”¥ ¥)@)JP
R””¥ ¥)@*7Wþeg¿g\
ªÍjä¬bÊbîñó³¬WP¼P€ÁYJo~th^›QšlÓÉà±®×½qV7ýöýªÝ%á½o\Öô?ì+‘ºþ"|Ÿ³Ú_5¯MÎÆ[œlC‰
½˜âaó"rIaôkK ÇSî+ï´ùÝÚþ=Å}öŸ/û»_À¬tw¤híºRµþsÉ‘WG£U%RÎÎûSÞ¿Fž™¶–å%³»»Æ¯³¥¬±X”e… pÊ“^nŒ£_ ¬wÝ%gk¦¼¾‰ ê Ù-¡”,rO‹·ŽGÓ)]ñÐßúaµî+ï´ùÝÚþ=Å}öŸ/û»_À¬>ž¦f˜cļú 0ôåœ ÅÆIϱä.2퇙&ïrÇÍ ÷×Óá|Ÿ;×n”&²ÈßY\Å-Ô‹siŸÄ½éNŒ¼Kñקà<ù;Ú÷÷Ú|¿îí´²Ö7ØÌd×C¨òóH8¤1pµ^ì¬BÆ›ìxäÌ£gÀÞÏŠ}=LÉP‹vR^}
V˜‹{,„·±<í$–°Z,…ý
žM¶,{²IÞ‡Ó½îØ\<¦g(Ȫ"!x©í‡ìì²G¤h;ç°v<ŽÚæ㩲‹tT¥Ê$V¼Rd%dQùà:°ÞÎõàŸP÷÷Ú|¿îí£é§š„bÚr^}œ†Ýä
ý¦Vûrñ,3=¨…»¨…Š%Àâ]þn·ÈïzÇiÓÖW¸ë¸.î„–ir²„\›‡Y%i=> ‘Cú8€|ÇÅf÷÷Ú|¿îí¹ùjÓ¨/ìî³9yl`Ž’{H –UY9(
·$úâ“ÊïA“ƹ0Ÿ§©š-Jw´—ŸB”Ž—mŒiî»ø‰pèÁב†EY§\õèë^O«&s—+}SÏw4V¨#ŽUB¾Ï+J`W¸Ë þ†*¡´ Ï"æâ烫2’Å"‡I-YHØ ˆ|‚+ïÜWßiòÿ »µü
}=LÊaóèswè^±ží.‘ïÒ{·’¤“ê©2%-0T¯=rßY¿oÔ
Ý•àRÎEåÉÖÃì|GúhGÔ6w=C*ÒX.yErÓK Á»2Bð«FÀoMù`H$¯‡Ÿ ~&γ„nÎ =•“&ERë§m17PÙMjª¯È Lò«Ÿ•Ðhƒ t};ôé¤h2Bóê¼P¨ ·’€;?NÐ'@éÛçqVr]Ûålf¶Š.ü“GpŒ‰ Øs,‚í oáèo¨Ö¤Ý]‚…ðárv³&^áí$ŠtdvUbH<¼ŽJÆýN£é£n]€ÛͥĘ‰ã¶´‚ñ›ˆ’Úp
ÍaÝ@ ±Nay¼ˆäuºãn°w÷8|åž u‡³¸Ä][Œ|óÂ#–áÔŒ) Ž‘ù^ZàÈ ävW¾’xax’YQ gá³ ]¸–ÒýgŠ±Ðú?ELÏe¯1†ÂÊ «›û£l‹=Á…QI)bÁ ü"#Zúj"ÚØ;½Ë|¦½Ææÿ ¦ÒÆÔJÑ÷SíâäåâÙß@òuãîï§nÞã;q’wï3¸ë”
%¼&Ô±'{Ò”›J|üt=^j[g¯ÕÍŽJÒÆÒöfrô¼- ò4k§hÔ÷7€œtOËÔxÓls_½‚ä-Mâ:£Û‰—¸¬Ê]A]ìªÌÒŸ€©¼8X-凨úv'±‚HáÏä™2+*8nò^Hc[a¯› n:xÀÇ‘èÕÄá2Ïaê«þšÅX.^(Ûígï\þ[€‰eÜ(x’Q|3hññÄ^ª<¶:l¤¸È²¯…9Ëh³)•Ç–MìRù#é ]'pnR¦>{ %¾M¬²8éçÇ#„kµU€o°ÙŒmNÉ 4| Vs–Ç-úX6BÔ^;²%¹™{ŒÊ¡ØÞÉ
ÊÄ}ø˜7)Sýûˆ÷G½ýëcîÏÓ=¡;?;Ïß ããññ_5 ¹Œu•¿ ྲšò;˜äJ£Bµáƒ ·½ý Nü,ÁùÒßÜó~оÿ Ê–T^–þç›ö…÷þTµj½XîDÖü’ñb”¥I˜¥)@)JP KÔW’ÿ G]3…±º‚Þ[¼jM1¹.!’â6(¬Þ^h4ʬ èÇèüèéŒÒȳ[]a²i"AoˆùÎ b0Æ?³•K¢åyøNc·´ék^£èÞ˜’K»Ë;›l|"9í Cqhã,¤:²J!øl#Îù»®ŒÍtÎHÅ„µ÷´wß“·º¸*†ÑÏ©ûÁ ³ê~JOYètèÕž®¤¿åÊÑ©Zœg*Å+ì_¿áÜü§¶|¥‡jâßÝsãîï%¸”í˜^<‰#Ž»È0Ø+çZ"¶aê|TÖw&iá[~=È®-e†oQÒj'Píɶ« y0*6A ÑX‰"’Ç*ÞÖÖ7±Ï™yÈn¦6üeŸOè&À (óäÖÉÂsS\-«›ë{T†Úl…Õ×m¡’V#¿!æ¤óR²( ì!)·ã«JmSw]œþtFr±ïí+ÍÖV u‡†®¦÷ëY°6³#Û°‰¤ü¢Ú¤ðÜ}-Ïæ©5¹gÕl†A¬mo;“¬²@$á±–28÷näTršo€ÍƘy$’k<©º6ó^Ë?f·’UмÊC æÎá°ØµéËÈ=ÓÊH±æ¯ri˜æö® xùþ›ú<7“ãyµÆâuvíîî=Ö [wºi ÞEY!A¶’"T P
z£ä=Kÿ PÞ?–½=úÃÿ Wö2eÿ Ùþoö ý¿û?ýUÌMÐÙë¯y5ÍôÍq…½Æ‰%¼žNìÒöõ7ÚB¬Pî8×I¡¢ãAoçzró'ò›³$ ïL*càæÄq{FËh /å—á³àøønmT›¨q–ùAŽ’wóXÙ„£v×yBðG;]+0'šhz—{òL±N†ô>$È]t}ÄÝWqÅ%´¹½‚õ™ò("h– Ùˆä;„ìÃE†Õ‚ Ý|†`ñ£FBú”³•*¼O•<.#G^ ;ñ£V—`$u>^l=•´‘Okh“Ü¥¾¼RÐZ/nrKಬcl¾©Éù¦]ÇSß౫{“X2–“Ëh¶·¸»yJ'“¥oJéÃoOÍPyøßʦPŸ§€Í¼ä‚và— Å—p¬SE•öï‡ ‰ ÌÝ3—šÛ#q¦*ÊæâêÊål`¹sÉ
ÀšI^NÐ=É”žþMvOÁf6¶Ð[ºêlb^ÜcâÈ"^ZÜAµ¼’ÌU:ÐĪ“ò>B8,ú£
È5çru–Häœ –2ÁâæG àâÍÃ|ŠŽ@qóSîºrò{q’홫,„{câ8}—>>qì>¾+äyÒק/ ÷O) >Çš½ÈI¦>c›Ú¸ãçúoèðÞO†?ª0ÙL€°³¼î\´M:!‰×œJTwTFKŽ.6ç‰kmK#!í‚›…` 28¿"FÔÆþ¦óÇѪ$¬À¥)U$R” ¥( !ù•ýoü5«5¤?2°?³ÿ †µf½q[òKÅŠR”3¥()JJR€R” ¥()JJR€R” ¥(Fþ1œ[ÿ '‹‘Ò?þÛpW‰u#èEi#ø³8 îe罶Ä]Kµö«åŒû<;Pþ ½²oÉòךeœÇa,1×¹{y‡äÂMc$Ï+è±bñ+#» ÎJ’wÈ èmNqn;_Ë›½?ù³6Kæ;lŒœ øžê$í¿þúfü€ø“f¹œn_ yÖ·"ÒòÞã ãFõÀa‘ù Púžú€ÞÕÁÖ¼ôÔ"²j[{mó˜¨Ùoê¹Ì-øð ’YJÍóQ%^@ïè&H¢A¿ ½h’5f§ç,eÈá®mÙè¨{grx¤ÈCFÇãà:©ÖŽõä …
ÓiKo˘fÂ,3Éwˆ‘,.äbÒz A)'Ôdˆ2†cñæod©ûÃæS+í1˜»w’vgT‘e@ãâÔèùÃqp4YWcs.çÍæñqgkwEŒH¶³K‹³ñ1’öA]¯-‡ wé᧹Ž–Òl|
`mUxFˆœôðã¡Ä©*@ ‚¡¤ÓPÿ [_ðÚ¥)CJR€R” ¥()JJR€R” ¥()JJR€R” ¥(½SýÏí ü¨«•êŸèÞ^¡¿ÈKVÞ+[ò¯qosbgõ„DÚ°‘
Ž1'ÖAï·cŸ²¹Èb»6bp—óªÌå»s$„ ‘°¤oFµ»ÝMú§÷œŸË×=USp7ŠÅM.÷Ûàymž 5qwsÓc bÌ̼oî#îÛ¤`J¤ø‘[l3ç|¹|žž>œ¿·Èd,#Æ]J.2x똞X[¹
²Û$n]Âû†P=äûð #«ïu7êœGÞr/N÷S~©Ä}ç'òõ¶—¤×ÒV’Ë?‡&ÿ :ž)ÊlÝÛrMøoÜ·#ŸµÆå`Ëâl›9·³Í^ä$¿ÅÙ1Ì·E@ ûœú5°ÞHÑ0ߦïÎ YÝcS lzNë>VæXD2·B0ebý¡ÂVÛªèàEwî¦ýSˆûÎOåë¦G?}l—6ØÜD¾ø?¼¥†õ±» üA ÑãÕÕÈëÕ;_g4rW–ù¬ßR1‹¼’ßv#W„Ü?fæf,Oª>éPY—A96…ž)øË÷³ÈÏ+çMå×µÍlgHÍ›Ûsa À‡¥ >|’TXÇcò˜{v·Æt×OXÀÎ]£¶½h”¶€Ù nôŸò¹ÞêoÕ8¼äþ^ŽNÄFæ¹¢”’2ÑYûÝMú§÷œŸËÕU‰ÞÄêݯ³š9xúz飺lnÜöR]c 1ßM
Ø’i¸ÄÌžcà7¾Gµx]ëÁo,=GÓ±=ŒG$É‘YQÃw’òC zÛ
|ÙqÓÆ <ŽÃ½Ôߪq yÉü½iÇÊC”—'Mtòd&NÝë ]|xgö}‘é_ýê«jêv¢5o5ÍðÖ9‹¾”Àtõæë lÅ®.®%ЛfÊ ŽFf,Ñä( “½€¬ÄôöRß©"g"ö–¹+Ëø‰–ØZñ› ÎÏ©ôCqPyÄ
Òwº›õN#ï9?—§{©¿Tâ>ó“ùzU\†æ¹®§.¸|¬¿ÑõÇO¶ íž\dWrMåä1*j DlP_¶|'¤ùã±’éio~QsÆÁ7¼sXù0‡¿k²ó
¿ŠŽzOùèz¼ô î¦ýSˆûÎOåéÞêoÕ8¼äþ^šº¹
[Ís]HWجÄSåîmœ™résÛöäEìqDZ÷äÕù©SÏ^Žæ¼•ßÇJà³8ûÌTÙ8¿) YQq'u o=ärÆv¡wÉU›aW_HSâº÷S~©Ä}ç'òôïu7êœGÞr/MU[ZÃVó\×S륿¹æý¡}ÿ •-Z©˜ +œ~+³x!qq;,.]W¹3È b: ô*wGb+U§RMfÅ)J“1JR€R” <—¨.¯%þŽºg cu¼·xÔšcr\C$Å4lQY¼¼Ñ i•XÑÑùÑÓ¥‘f¶ºÃdÒD‚ßó@*ÄaŒg*—EÊóðœÇoiÒÖ½Gѽ1$—w–w6ØøDsÚ:†âÑÆYHue ”CðØ*4Gów]šéœ‘‹ kïhï¿'oupU
£ŸS÷‚ ;gÔü”$ ž&³ÐéÑ«=]I[Ë”ÿ £Rµ8ÎT#ŠWؿý›«ðpEfæñœÞ¤m0I$’öʇPŠ¥¹)aÉuÈi¶=-¯‰:»
6?!=–V6Ö²\‹žËË D §Bº* ±Ñ!IŠÒÀôk`r¶7Iv×L¶×Bòâb{“Ï+[Á~
¡`â (óäÖŒý‘—¥¬1‹=¯~ߦ.pîÅÛ‰šDU‡§|7lë~G«Ž¤i*Sw]çÎå¸ÒxV=ý¥|ÿ VZbæŠÎ ‘¯žöÒØ«Æå?+4jÉÌi{½·.|µ¦âV—]Yh:‡‰³™$–æöKy¹ÆàH&v17…r¯«q-Äž-¢Eiäº/.Bí-ÆK+ìžFi¦¸t’ Ƀ’*Ø>Ÿ –_/xÙ[ôþ^ ¾:.-Œ²ÊÝd}£Ú Lýå¸ôv»|Fšã[ævzÐ¥£bÆÆ3¬¬›§°×¹I{W7¸ø/'[ÈñÀ /#(a{å¦r•¼úN¨7Ta“/&(Þ\ŠT†Uí9XÕY¾¸§>jdrmªíèúù±øûY ð[\UØ÷ͼiÚøE¯hSÜ>‡)áu±Ìêý×N^Oïn2@=³5el|G²òÇÎ=‡×Ñå|:5‚¤=CŒ¸Ê ts¹Ÿ›F¬`E#®ù"JWƒ¸ÓmU‰ cÒÚŸ]ôåÕ¼SÛß¼É2·ZÊÍrÙì¨]ÊWüa)£ËŽOù/˜“¬lr·‰-½¥ìÓ’×s“$o¨Š°eš®À%À,J«n`ºróòg½$
î¼+ãçàÄòû>Šì
¯ä[ã£äxøê-PºêŒ5ŸdÉyÎ9¢YÄ°DóF‘7Í–G@V8Ήä)
ÇzSªsL° wAuODlçlÁG€ ÖÏ“ðdèkÏ_ú>¾l~>ÖCÇü×v=ãsovƒ†~kÚ÷¡Êx]ls:ô)ŒÊ€Á;óPC¹QÇävòd¤€67±In‡PäfÄáf¼Pº¼hd”«:«JàèEbíäxSå~#Ÿ›©ò8œîv{Œv{”×Üâ¡h×¹ Fu$¥ƒÛq ¶åññÓäã¾’Á†6dŠí] ;ƒÒáX3FNê
r •å° ®W!Ó9|ÌY¹e´Åc.oñWL-n^Qu$Š« “7iä•_ u#kZÓLmÚ
ù ÅZE<&ûÙ¯ oÂÍi+¡âäJñ€ˆí° • ñS¦eaº£ ™y1FóúäR¤2¯iÊÄîªÈ õÅ9óP»#“mWlòÝ=‘ÊÛõ1µ†|®
;A+2Ç0 ¶ÜA)¹—G[:>‘Y.ºrò{q’홫,„{câ8}—>>qì>¾+äyÒÑêŒ3åãÅ Ïë’ÊðĽ§ +¢³8G×áÁƒhž-¥m1 ׯ9µw^®Äâ »±ž;<Õíä°¡ojA,wMÎHÈ ¨Õ¥Ô$æŒ
‚z5D•€¥)U$R” &t‡æVöu¿ðÖ¬ÔnüÊÀþηþÕšõÅoÉ/)JPÌR” ¥()JJR€R” ¥()JJR€R” 1ëÍtôkêu½’VQä„ó)b> ΃
²¤Uš?¯l8z»8ëžæ¼ðç$ 7õràúúø6¾†”·¿ü,Ò”¡˜¥)@*5ßüýò+ÿ #u 7ü¾œDûø¤DaðOé
å¬Ò…£+
Tloüæ<+ø³¨ÇHßH î
ý%A貟ñv6h% ,R”¡QJR€R” ¥()JJR€R” ¥(+^þúߎ¹¿¼“·kkÍ3ñ'Š(%Ž‡“ ±ß屸¤ç‘ÈZY Bü®&XÇʤúˆñÉÐoëe H 7)Zïg âÙ½Ü túã m‡#Kñò#ÿ 1¾£Zqgñ·Ö Ù‹Éco ÀÒ¥Ú˜Ã3ªñ伇=8Òÿ ˆ• 7º¥+N<¶6l¤Ø¸²…9Ëh³)•Ç–MìRù#é ]OÈu~ ‹Ë߶NÒtÄ¡7‘Á:3ÆÃ`! ¼;0*ÖÏŠå*|¹Ü<>ÃÝÊØÇï
{+„ Ó½k·ç×¾KðßÎ ]P ¥IÈM.BvÅØÈèU“Û.ˆì¦ÃÁ {Ž¾<Q[žÁàZ1ÄÏ‹¿øôc÷trw7Ñ1VÙ~† d'c[O$· 5ñ 1[Á F‘E„HÑBª¨ ð WÝ¥}‹p¥)B¤nªõ`Zæ;›‹kY—þ¨¥#‘ËjÌ6<øѪ³O
²žXâBê‚‚ÌÁTyúK úI¥g¿)wƒµ0Ï‘ Åÿ «·“'ŸˆÔ‘!ÿ å£àt:Ç’ÌÛAì[è8]Ù³[B-øi.QÚ]ÉnJ ° ´xÄì‚4–ÈEx¿OC¨¥yþO¦ò/‘ê`’ú÷&? 8ëé™bcpÆóÊ” ‘Cª† WøŽm¹øìDö¶w¹l}¯°–ÚîÞÚË.9 Fd8$rÒM$4|Š…;ŒÚ’ƒ3ÓŒn # „¤¯$¨ó½v õ
çY+Ëî:w1eÉÛ,]Ë©1ø·¼™!y¡¸“Û.%½Ò&E!ä&%Ñe~ @R >bÏ ï äný®k{P˜·³Žg…#ü³—)¹H¦rÁN’V «zÀõ
W—ÝtîaqYu‹pâ»8û0¼‹ìféf”p Lñû0·—e™¡•Ëù-±F, ±»²’çïƒ5Å”Xi „[û+ T²%ä)í ‚»æLœx€ä¡úÂ&šÞ FJþyÞñDpvT¨¶˜C#$Š4Y†´I ùªbrÉ•ŠêÓÚÜ[KÙ¸¶Ÿ8ŸŠ¸£2££zXüí @àð8Kéîp¾Ëq™ÅÀ‰šapaü¯ /£hÖOhÈ.¾¯PäxﱕéHZão0»É$ù†¹ÈÏ6·/õ)£AT ¥Š2º
ÃAäviXà‘¦·ŠW†H Ð3E!RÈHù§‰#cáà‘õ\ 3 éÕŽ1ÓÇ—Lä¹ ÓjËݲaqÙSpGTrµÔa˜¯ð;g.17÷ý=ÓåSòrôÕŒXù†&KÙ ¹àüÚWUµ“Õ î9PHS°#:Ú+^Îúß!Mk'r5–HIâFž7hÜyú™Xž¼x®OØí¬ï¥Éaîîr^ÂøÛ¸œ˜mÄQàic@ë9hË‚À·¥»€4xp––ýqf˜™-¢ƒ;xòÛûç‚E2ËÛ2[¯ž.
ø²Æ~¶€ôÊT~–G§-K?dãÌ$ 2€œÛ‹*1-²é„Gû0B†¬P
R”’õÕä¿Ñ×Láln ·–ï“LnKˆd‚8£FŠ+7—š#Ä
2«@:1ú?::c4²,Ö×XlšH[â ~s¨X 1ìåRè y^~˜íí:Zרú7¦$’îòÎæÛ Ž{GPÜZ8Ë)¬¤ˆ~Fˆó¾në£3]3’1a-}í ÷äíî®
¡´sê~ð@lúŸ’€Ä€¤ÄÖz :5g«©+oùrŸôjV§Ê„qJûïøvW]gco”ĪL%°¿´¹•LPI$ï,O
ðXÔ$“’ñ,8 ë‹VåÇTblÌ÷79kU±K{Y»OYätI •(Ä 5®½qß WÍóRîz{#=ÆeAµ]åì20¿u¹q„Û÷—ŽÕ¹ã¢wËÏ R秲)“¹ÉÚ›Yg\¸ÈÛÁ,ȾĶ¥]±C²Íá[zÆÉÚ%Œ˜Î²²¸ÃGq/{¿uw ºãíä¹2ÅïÈ0ìWˆM·ÍÛ‡ +bß«q÷Ëû Üm1ðß›ò@Ñ¿=‘!^ BªÁˆ;m|ÆÔ“9çÃ[[˜!‘®¯'¸† éâDiçiA$a$“¶‡lðWå²ÊUMc²è¼Šaî1Ú¤]1m‡’â7fhæeRÁ
€ÈDÛß }:×…¢«š²ËwE«N²E¢ñ\ÛIo"ƒ½7 [‰Ó ÚÑ*À ƒÈæY^TPàÄü”l ž!½$0Ó#c{ @Ó+Œ]ÅíÝÜ ÷ Z+›ö*…Èܳh¹”(ד¶å¥¿˜¼¢XÑP>¢*å‹/冇ËÐ߀üèQ¥}€ç÷¨ï³9”°¸Å%¶:é Kyíd/7ä"”îQ&“fB7Ûmkzo…lGÖXfÇãïd–x£½µŽðnï؉ÆÕæd ±/ÇÔä/¥¼éNµÒ˨ìs9—°·Å=¶Fé'K‰î¤ä"ˆî! ŸF2uÜ]ï[_Hê>†É^tôx,U÷õ(±BÂh¼š Ó*äë„üÇ!ô©ÇWäÊoh½à¿iÕ–SÏIãžÞAAÑtEf¡F±ŠR” R” ¥()JJR€R” ¥(¬zhu?O_Y$ÓÅtö“EnVòhcæé¡ÜXȻ׆
ã~<ÃÈc× Ö¸°ÆÝåLVWóžù¦ kT-\9ÑÖ¹¨âÎA'ÒÝåc0B× pÑFgDdI
ŽJ¬A`ÄUI OõP C_.!’+Ok~’¶ÂÁxN׺«:È×0›h‰ñçÇ‚F†LÌW·3\æn±Óããžï j\¼m!1_ò-ù7uâ{Ê«{VØDöYÜ=ŽF uæVÆÞú~=›i®$“‘â¼T@×ÄÖÄÖw–דZA%Õ¯/g™ãâä4ÜXù]_‹ÄtîVß©ag$ö–™;Ì„DËl-xÍÇ€
ggÔú!ø¨<Èb†Æ¸l´¿ÑåÇO6õŸOËŒŠîI¢ü¼†%MC¦$FÅ%ûgÂzOž=àž¸{u–3:"»ÆrUbB’> ¬úxŸª²P _QXeonÖ;v“ßY$#=³ÀÚ.DW‰&ÏiL³30iøPžÒ•?+}-´ ‹%I2S« Xœ¼€ù﯄jH,̶eLS“²>2—s·,n9øäfŒ‘.ªv¬ƒä +þ2ð2îÚZAcl–öéÂ4Þ†É$“²I>I$’IÙ$’vMc±±ŠÂDg’GnrÍ!år ,Äk΀ T-&…n¥(PR” #d?/Õ8[fð‘Gsz¤|y H€?åÆáÏ×°¾~ Ù¨ËýceçãرÉÛ×Óß‘¹ïÿ ogM|>-½øÕšTÝÝïêOºÎáìr0c¯2¶6÷ÓñìÛMp‰$œâ¤ì삾&¨WŸæ¿6?¥/ÿ Oÿ ìØ+Ð(fcÂ×n²ÆgDWxÃJ¬HRGÄU€?OõVJçíz3 eÕõ6P-ü܉aoâHòÀ„äîB[{nã,è()JJR€×¾²‹!g%¬Ï:FúÙ‚w…ƈ> aðúŸ‡Â²A6¶ñ[ÛÅ 0D#Ž5
¨ h € ñªÉJJR€R” ¥(%ê «É£®™ÂØÝAo-Þ5&˜Ü—ÉqFVo/4GˆeV€tcô~ttÆidY®°Ù4‘ ·Ä üçP
±c ÙÊ¥Ñ@ò¼ü'1ÛÚtµ¯QôoLI%ÝåͶ> öŽ¡¸´q–R YH%ü6
ç|Ý×Ffºg$bÂZûÚ;ïÉÛÝ\ChçÔýà€Ùõ?%‰H'‰¬ô:tjÏWRVßòå?èÔN3•â•ö/ßðïfêü Y¹¼g7©#ÛE I$½²¡Ô"©nJXr]rmKkRN³ÇÛu Ö—p{ÇÛ^[Í
´œ–G˜<ŒË°"Q dÈt«ËËyÛ{Ó=K†‡4Y ù,oî.ä¿‘£Nd³RC(nÖ´šX@ºÙæ7~DÞAÓÙLT7PIßé»|4¸)¹#IÔ» =Õ> ? ¨o’¬iFmAÞ=œþ{AÉÅcßÚtsu2ß(1ÒNâ~k0‚CnÚâ(^çk¥fóMRï ŸTa²±µ¼îN²Éü“„ÆX<\ÈãÜ Y¸o‘QÈ>j]çOdfÊ^Gµ÷}öJ×%,í+ bh; “Xøá½}E×\ϤñõdµéËÈ=ÓÊH±æ¯ri˜æö® xùþ›ú<7“ãyZ6,2}ed½=™½ÅËݹ²ÇÏy žÞDŽpˆHxÙ‚‰cß ²4ËçÔ7‘:’i¥ÃÄ-Òî2RØ^Àä±…’ ¤ôŸLcFRÀrGˆä5ÎYÿ G×Öý=}ŒÜ á…Ÿks.Fæ~ç4UçÛEº’ŠJ ˆ €¾®Žÿ ¦æ›«q™‹K„Žî;×–ì– ¢Y^9êP°v¨žG
4µn?Ta£ÇÃ~ך¶› &J7í?›dYõø'Ÿ‡ƒZÿ -z{õ‡þ¯ìdþËÿ ³üßì?ûöú«œ~ŽÎ͇‡ä‚Ó§n°Ö· rìÓ´‹
¤Ž°#‡d}rÐÞ¶mçzró'ò›³$ ïL*càæÄq{FËh /å—á³àøømhƒ%¯VZ ¡Êâo&H嶽ŽÞ ¹^]LåP³ÈʼŠò#ŠìƒT!ê eÆPã£ÌüÚ5c‚) wÉR¼ Æ›j¬Hàû –Ô;ŽŸËÏ—ÈÅÂÅq—¹[\´{C™“²¶þŽ×o‰Û[ë|ƃïGZ8ñ} qcÔ‚îUI-â½¹½ŠvÈ\¹å1ñ[mˆ£#¼ËÌØñö±hØ!ëLÎ>ÞúÖê{¨.6aö[9¦y
Y• ^J¬ÚÒ±âHo_ÛmÛ íñI߶1w•íÔËÜMl ²Û ;ßѺå¥òô·OX$6·7xÛ$µ”®Bâɶ)<@·
§”+¦ô’A@OwÖ¸x¢y’û!¸V–AÙYå óÜ7Ÿ ë~¨ivRdfÃô¶_'n¨ÓÙÙMqÈ RÈ…€: ëcë©oÖ¸‹¬Î ‡Ìb¯ä¼ºx¦Ž ”•Ò1²r[Ç©lìyúȪIŽ›1ÒÙ|e»"Ïye5¼m!!C:蟪™Lt×Ù %ÄL,oZâPÄì©·š-/)㯠ÿ íEkm;^¨Ã^wŒwœ#†&œËw??W §~+O ÑsaãĤs£ <“\IÉÉÜ)höé ¾Ø„·ÑË™ 4)þl ÕØG·»¸ö·X-mÞé¤{yd…ÚH‰P%@5êõ/ýC{xÌÞ?1ÝöŽïoDíy+o‹¯ 9ÆÚ<]v£¢tkÏs}/˜±ÃçòÙĸôîBÕØÝÏ+M#ª7x#ú!
ÛmÅ| ÎáÛâ1ÙóÙ<›Z÷æ·‚ÑVرWXšVî ChXÌ}n뇾ÈÁ‘¼ÅXÜ_Adzs5º<‘ñ<—‹±¢IøØk 7îr´»²¤òn0yÈœx¹úØpM ˆâ¿PŠPÌR” ¥()JJR€R” ¥(|M4VðI<ò$QF¥ÞG`ªªÉ$ü ??&B D³c[RGë‘V.äùÂ!ðîkÊìH Œ6xhh °âlä=ë™Âôäqáo-3Ö6é sC"7 E5È#äƒÞ5½ÔÃgÕMf|¦%* ªc¥eV× œloéÐÿ ØVi¿âùÄ·_6xÙ9Üoüw U£Mˆ*¿pøðÝ¢Õ€³Yê¡‘µZÎËb¾ýˡغ—õ¾'î¹?˜§±u/ë|OÝr1W)ML22×K»’èCö.¥ýo‰û®Oæ)ì]Kúß÷\ŸÌUÊSS †º]Ü—B ±u/ë|OÝr1Obê_ÖøŸºäþb®Rš˜d5Òîäºý‹©[â~ë“ùŠ{Rþ·Äý×'ór”ÔÃ!®—w%Їì]Kúß÷\ŸÌVµê »ÏWª³K‹ QÈÑ·Âãáµ:ÿ -WKQº_û¦Ú7ßùRÓS ‹*’ÀÞÎÎÅßÜ|{Rþ·Äý×'óö.¥ýo‰û®Oæ*å)©†EuÒîäºý‹©[â~ë“ùŠ{Rþ·Äý×'ór”ÔÃ!®—w%Їì]Kúß÷\ŸÌSغ—õ¾'î¹?˜«”¦¦
t»¹.„?bê_ÖøŸºäþbžÅÔ¿ñ?uÉüÅ\¥50Èk¥ÝÉt!ûRþ·Äý×'óö.¥ýo‰û®Oæ*å)©†C].îK¡¥ˆ°÷Và Ýîû%¼pw8ñçÅBï[:Þ¾»JV†m¶îÅ)J)JP
R””¥ ¥)@)JP
R””¥ ¥)@)JPº³×ÒÙ aóï#ö(ÏÐ b"RÈ3‚~'[ð~f£u å¢ÆÙ/‰.r6ü øÓ÷Ûýì,ù‘ð"Í
Ø— ¥)C1JR€ƒ—kÙúƒ am’¸±ŠK[‰¤6é32¡¼Å™2Ë=Ôv–½CrÐ<Ä ;¨#R|ëKµGˆ: ^«¸´ƒ$/q^Ïsi?h ‹ÎÈ3¨ø˜ÜÈG5E ƒ?²XõC]Èv·µq‘½{EšÎõn !a–^q¸PXn"„¤7/ˆ ´k*æ5%Ét7=Ñ‘ûQ–ýÕ¯àSÝ µoÝZþO¶ê»‹Ì¶+›\Ë|!¸aK[•…œøÙä` }\Tø%×Aÿ ¤$‡ßËmb÷6û›ñmk‘Y¤A¹Gpu ›eÆÃùôŽLusÇ’äºýÑ‘ûQ–ýÕ¯àSÝ µoÝZþO“ªî-–ò+ÌWbö/e0Áíƒ ™L0‰CSÌ(p£Ê—øS+ÕW,Telìl®çºöXÌù –›í´œŒÅ9*ñF_1ƒÏÆ´CÓ \Ʊä¹.…td~Ôe¿ukøŠÐ_ØõEœÙ{»Ûyì®%d¸ŽÅ‘á ƒ j~7Çu³ÓÙ¨zƒ J 䌘¤!hÝ£bŽ5É )*Ú:Ðø›ó×û:óø–ÕzU&ê$ÙhËÓKsìY)JWqÌ)JP
R””¥ñ4Ñ[Á$óÈ‘E—y ‚ª¨$“ð TÌt2ä^ µôoçki"m•‡Åÿ âté¨ÿ ?ÅŸü±’—û·Ó5œ'ÿ ‹ô¬Î?ìQ> ÞìÐÑÿ ¿6
R”3¥()JJV®Jú,^.ï!:»Ek Îá ,UT±ÖõçB„¤Û²4:W×Ó°\™y$×±¤$Ò¼ªù…pÄo~OƬÔüŒ¸¾žÆcçdimm"ÊT² SëÆÅP¡j9¶³¥(PR” ¥()JJR€R” [ì¦6šòá"Vn–‘È$"(òÌtt ~Z íŸ3ëÍE ³>¨ñ¬€úŒÇed#â*IùåUÀºŽË½ˆwîsž›CØÄ¿Æí$"[ôˆ€ ”?ý“{ md¬ÃsÓÛ“i5ݤ‘°6½ÂÍí 80fÙÎñߨ«7# ‚”,ª[e¶dibl=ÙŒ†ÔËÞry¥ãÇ»+Ò>·ã“3 z +v”¡›m»±JR„
R””¥ ¥)@*7Kÿ tÏûFûÿ *Z³Qº_û¦Ú7ßùRÐÑ~7â½K4¥(f)JP
R””¥ ¥)@)JP
R””¥ ¥)@)JP
R””¥ ¥)@)JP
R””¥)ù~¢Á[/‡ŠI¯XŸ‡ˆÄ@ÿ >W~óðÍFoë k ÅŽ~æþžü‹Ã_û{;ïáñ]oάÐÒ{¢»½X¥)C1JR€æ³Y gVâf¿¼·´‰¬nÐ=Ä«–î[lŸƒÿ jÅ–Ît¦c}Œ¸êØBÈ)fEr¡—l§‰ßþÞj.Méäùû Õñèûüƒ]7VÛÄuì–ÐäaXäž# oñ LH¥wÇC|Cé†;ˆ:&âÖâÝú¢Ì$öù v"þ …¼”K) æz~¡ñßƬàzƒ#‘ŠK¬Ž; f·Ú,‰iY¦IÌ tÑ Ó2 [;QŸçËcD¦ã!k‰ÊHd™Wƒû¤ ŸGë×ý>~ iv¶ ÓÉóö9ûœ—J\^ÞÞ/UÙÁquo Hr1)´ò:2ùøòì6Õ€ ‚6Ÿ>“ö]|²·÷‡µ{g¼}¶Û½ÞíöyqãÚþËÑ®×rõWQuÄXãáÈ]ålmì§ãÙ¹šá99KʼnÑØ|EnO<6¶òÜ\JÁ’I*¢²I> 騸½<Ÿ?cÅOÒ8©'^¬³¸žÝ.×¹5ôÜ̳HÌ(ß%Ð |V‡»º$ÛËnÝ_ÀØÙñPÆÙ(xÛÛHpAmB
3mø‹iuÛå²0áð÷Ù;…v‚ÎÞK‰0 E,@Ùz ]L\Î^ÊxÛ9‹±µ²~a®ožeƒŠ3–—”Q„HG-ŸQQ¯;Ÿh½<Ÿ?buýßGän¯.eê[šæ+hù%ü?’h$ybu~ ï¿VÔñ ‚69.ºfk(£—â{Øn=¦+ö¿·2¤œ {U×hÛ2ñ ¯%µÈò«¸¾§Äe±ì”7Ð$9–XYP9Û*Ð'Ô Õ阉’ ö;Ùìšë#ŽŠ{¤„¢%Ú²»J Uø\N‡ƒQ~ázy>~Æ•—QôÕ•œp ¨°¸eÙi§ÈFÎìI$Ÿ:$ø (ø |[eñ¹^µ°÷vFÒó·Ž»çìó,œw%¾·ÄoGþÕ^l¶:ÞôYOµŠì¢¸æUr¬áñ'z.Bƒô’ƵfüõÆ~μþ%µiBÚÄZ.lžçÛÝà\¥)^Ì)JP
R”£ þÉ,gÆ&) )é»tb¬¤}†ñrùŸÚ}Í4¹yä´´‘Ⲋ\ÝFÅYØ ¢#àAðÎ>o•_^Ìtá†+x#‚Ò(£P‰(UU@ >
}›{žçÝ)JŠR””¥ ¥)@*7VúºK+ ó%Í»Z¿õK(íÆ¿å¶e>üèUšÔ¿”´±µO3O‘µí¯ý]¹VgóðŽ'?ü´<Ò—ä^%šR”3¥()JJR€R” ¥(O¾Ê-´ëgo ÜߺòHP * 4Ž¯†ò|ž,1¬3_\ä'’Ï®‘«›!¥)L±ƒóäÆõÁNöIR‡rÆÆ+žI ¹Ë4„•È ³¯: h
0¨í—.¿.a±ÇKíy}:]_2ðî$f46=(„·H’Ä
*…¡JP£““»¥(@¥)@)JP
R””¥ ¥)@*7Kÿ tÏûFûÿ *Z³Qº_û¦Ú7ßùRÐÑ~7â½K4¥(f)JP
R””¥ ¥)@)JP
R””¥ ¥)@)JP
R””¥ ¥)@)JP
R””¥ ù~©Í\¯„Š;k&ãÍÊHÿ .7>½†ñð&ÍFéïË{ÖûáíY½ ôöµoñúwÙåþ\µç[6hiWî¶VòB”¥ Å)J˜ê,t9ŒÜˆu‚ó·‘£ 0Wku$l½ ª¸L×ôwš²c™pe¥E)q
•™¶¸–ÜØ#w1؉ ë|H:¯DËì AŽ¿¶ÆÜ_E Ä2 w‰YYÞ¿Ú:øü›|+÷Þù ²ùoÞÚþ=cŽ¥:ªqWY=ÆÓ§¬¦•û3³Þÿ hó1wYNÍgÕ †µÃ^Ecà÷hÐ0æÃ[X|©ã‘Uc º¹py;¹&1 `Šø‹xíRXÊ„µ»2ÈñëCµÁý;
ljÚ/€oÏ»º·–Þ㤲SA*’9 Ñ•ÔA›DôVO{ä~Ëå¿{køõ]zÚMLn6ËÃ×ÄæÑ4h”UV²ï\÷œââ:úÇ3Àé´É\\:FÖélâœ#Æ¡{¬ç¸;…ØzÝŠ«)Úçén»Ä'I#Y%ºXশºT)¤¸v¶b< $´r’Ã`I>Fî{ß#ö_-ûÛ_ǧ½ò?eòß½µüzæp©‘Õ«y®k©>Û§î.z?'ˆ¸od¸¹º¾’€a2\Ë$2®Î^HãÈ ð#Ç8U®0• q‘Ëœ³A#(bd¶¸•3xg8"âi< ù½]í̹+9-/ú6þêÚMs†sfèÚ ©›GDÿ ʲI»™âyzK$ï ó‰™í FâWkùo‹0Øú M*dFæ¹®§1&9j1¹ uÈÅ"¾I¥‡Ö¦áÕÊΊÝýÇ¥ ¦âIå®%—fºüM›`úZÆÉ-ÞW±²Ž%†9UÙÊ C°@IÖ¶Bƒñ<~Œço. Žx:o',R(t‘&´ee#`‚'ò¯¿{ä~Ëå¿{køõGØN©®ÕÍu7ï½³Ý÷>ïì{oi½ŸÚ7Ûîhñç¯ ñB9kJn{ß#ö_-ûÛ_ǧ½ò?eòß½µüz*uµ†æ¹®¤šÀÞÇò6\Ž3³&' 5¤æÚÿ « *UÎXåÑæ ª—Hd×¥¯à“ žð~Ž¶ÄÂKÆ[¾q$A·àrh¶wÄøòuã³÷¾Gì¾[÷¶¿O{ä~Ëå¿{køõ8jdFæ¹®§!Ô6ò¦Bõ}† ¨dêLeßµ÷P‹Vݤ\8ùq)zÐ^Ü›å³Äö~zã?g^Ú´¤a6R,œ½xùS„Wl,Œ¨¾|+÷¶©¼ôŸ®³Úû¼›weo•ÄL÷By3¼$ #‘Â6øê´¥ )«¢ÑŽ¶ÖçÚ²:*R•ØsŠR”¦]ÝÏurøìsð‘5í7Z[‚6 Á‚aA ÛUþﯥYÖÆÅRKç^^°J@„‘Ü}kÆÁv @Ð Ë› c:Ím¢g`ÝÈäîìYØëCe˜ ߀Š%…]™-- ±¶K{táoCd’IÙ$Ÿ$’I$ì’I;&³R”(Ýö±JR„
R””¥ ¥)@*6cךéè×Ôë{$¬£É-æRÄ}Aþe H«5_ZØpõvq×=ÍyáÎH8oêåÁõõðm|
)o~øY¥)C1JR€R” ¥()ZWùKlwm%~w3l[Ú¡YÈÖÂ)#zØÙðyb &„¤Û²6¦š+x$žy(£Rï#°UUd’~
“Æç;âXîì1ÃÈ Ã ÷è;SÊ4ø m\Ÿ î d·ÓÇyšŠÝ剃[Û#"·`|8,£”›ÿ ˆð z™ëP½Ô7où»ç†gÄ0ÅopAEj#E
ª h À_t¥ Å)JJR€R” ¥()JJR€R” ¥ÿ ºgý£}ÿ •-Y¨Ý/ýÓ?íïü©hh¿ñ^¥šR”3¥()JJR€R” ¥()JJR€R” ¥()JJR€R” ¥()JJV–^ÿ ÝXKük»ì–òOÛåÇŸ-èëzøД›vFŸJzúfÒëáí¼ï¸ÿ Ñßv›Žþž<õ¿Öô>f´± êÂXc»½ßd·Žç <ø¨]ëg[×·hZ£Nm¬Å)J¥()Xæžd<±Ä…Õ;™‚¨óô– ô’’”¥ ¥*~;,™Eî[ÛN!ÜÂÒ?á”ÄA ·ê*Äh|ÎŽ…)Zw¹(ln±Öò¬…ïî
¼E@Ða’í¼ü8ÆÃÆü‘ÿ ¸K¤?2°?³ÿ †µf¦ôìöW]3‰¸ÆÅ$62ÙÂöÑIó’2€¨>O4>'ÿ sT¨^rÅ'%Ú)JP ¥)@)JP
R”´¯ïý“· 1wïgØ‚ Üyk[f:sÑ‹žkk1åïÖ!¹>¡u*Àø&M €¼‰%£Ì×yNw/ŽÆ¼3dW]ÀO%µl< Ò»þ ̹¬,=“¹4Ò÷ïgÑžr¼ykzUpiYÂÌ R¨?4»¨Œ{^ãï i;ÜÍ’¾N72úa‰ˆcm—ò{ 6HäÄ}$.Ø"š§JP‰K¸¥)B¢”¥ ¥)@)JP
R””¥ ¨Ý/ýÓ?íïü©jÍFé = †ùyl¢–Fú]ÝC3ô’Ä’~$’hh¿ñ^¥šR”3¥(a»»‚ÆÙî. „iI'@ <’I ²I lšÁì¸a‹¿{>ÄãËZÛ1Ñ⋱¶ÑÖÀ ±U8m1Ž×)È¿vôl¢,Œa·ØÖ‘N „r<›æ©ÔU¯-ß>\Ãìsç=yH&¶³ Á¥“ë3b¬#ÙR -ÈÍ)B%&Å)J¥()JJR€R” ¥(rw½omgÕVø³k’h
½ËLˈ»vîFñ*ðã ™4ï¶PGÍò67ÖV»ØÛÉ‘†ý£ÝÔ1I oÈúQÊøy1§ý¿ÌÐ úõ‚/WǸK’y^¢L‚Év¥ci9É ˆÙPÜÉõGµˆXëÖW
‘³ÍÝÙOoˆù?{”!œI߈gNHxñ™T¶×ÊŽzÛmtôœY‹l‚Þ_qµ»–òÞÓº;1É*È%:ã¶äefõTøRªJ{~…°ò3Þß]Ø.>ld634b8m¤à‘Câ4PY˜è|vw@K“©²øÌæbkü\$6ø¸’ÆÞðI´÷SD^&`£d2ƒÉSf=Ä;ÿ HÙõânÓ éqogq ÈhïL# Ã@dˆSnJ +ž>
èøšk‰ï²ù+ùç{62OÙR¢Úc4jq¨Ñf;Ø$ƒàŠÜnŸO|IBúÞ9åIî-!uXç•UUY à𑂪áHMAn@i㺥² KqŠ[kE¼ˆÑûjû\a»’[•bb ćŒñMuKu
Äè-#HÐ9HoVYí‰>#¹‹Š˜eøúG0
8,49n/O§¾#¿›!}q ¼öö“:´pJÊȨ̂pøy Vr >€ /?§ÒÇ"/dÈ_^ÉM°»uog‰Š–PÁC>ûqú¤.Þçe¶ŠÒÿ Ý3þѾÿ Ê–¬Ôn—þéŸö÷þT´4_ø¯RÍ)JŠR””¥ ¥)@)JP
R””¥ ¥)@*7Wþeg¿g\
ªÍFêÿ ̬÷ìëáµ
(þHø¢)Jò ¥)@)JP
Ÿ•ÍYab‚KÖŸúĽ˜’ i'w~,ú ³|Ôcðú*…s ]}g¿é{»û¨-m£Ê¿9§".ìî@Û dÿ Φ*ì‚Þ;'i•·i ÈG(é,O‘¶Ó£€ÊtAÑaøkr¼÷5šägs¸9Ò{-ñ¶‚ò9ÊDê·2›L •EŠoT«¾ Hu¯c%îBÛl2î,ns¯oŽÉKrÜXÊÍ ´º«J Šä°ÙRt¬ãl ôc<+p–í* ÝÒ2Ó*ñ ]Ÿ£úë õí¾7 sw'nÚÚ&šgâOPK '@ …p8VŠ^´ÀÍy{9¸H³6vÂ[·ü¢Ãvˆ‹Ä¶¤a$’ 7 ÌIPD ¬Ô÷Xþ¡µIgkyúo#<â{ùndï(Œ•vò¨‘¹ÃÒ— €nU=¢ç®ÛÞÛÝOw 2r’ÒQ ㉠¢¸ ~>—Sãëú÷[ç·)5ÇSÜÙÇ{uk ×Sˆç6Ò˜ÚHÆ!X¡#Ȩò4G‚¤0kÞßÈ0vM{—Hâ½ÈZ…½ÊÍYW- E®ã‹ª! îNLä“5éT¯5ê£ln 7=ÞRë ÷]1 ãÆBU·™®xÜâ£@L7 ƒ`”øzj…ÜÓG/X_M}‘híïaµŠîŒQAAjÎÅ€&4%‰y<˜Ð;',Yƒº¥yn"ú÷.¶v 𺷴ùDÖªmo嘽¿»šb¢yd‘‰`ÿ (ÚTa¸¹š ¬Ò ™X ÙÖÿ ÃZ™s–Æàºë#q—ÈZcà¹ÆY¤]̱,¬’Ü—
X€ÅC¡ |9®þ"©ô‡æVöu¿ðÖ¬ÖÄVü’ñg7Ò3Ãè\5½ü±ÚÏc‡¶{¸ç`n¢- >Tm lëæ·ÔiÔB½IÒ× bwɲ
Ò±±•gkëæI/xú )m7¯ –Ð,@'@*
“IaB”¯‰¦ŠÞ 'žDŠ(Ô»ÈìU@Ù$Ÿ€…º“6N[éä³ÂËnòÄÅn.]L‘[°>P…aÊMÿ „Äyb=*ÿ ËÌçö
5Ž4ú]¤‰â¸Ÿë ½4CèäG#¶ãÃJæ´0ÅopAEj#E
ª h ÀCK(oßóÏ [ ]¶;¸ñ';™´n.œ,äoEؽlèx
<( [´¥
6Û»¥(@¥)@)JP
R””¥ ¥)@)JP
R””¥çøž;.ˆËûmô—y¾ ßÞ¼–Häçg,ÍÆ&b‘þQŽ
ºCJH¯@® Òpcç±ÿ ˆß\Zc¿ä,¦íví}5âU¶£fAÍ›ÁÙÛh‹Û˳ó½ž^ÔF7æw›Óëm(Óx?7Šú†€‡Ò|/:Ž …ü—²Ã“UËÅT[w*‹çŠfÐÙ>|–$±é+NË
ÖFâ&½ýÀ¸”1 "Ž-/‡Ôùß’ö”£t¿÷Lÿ ´o¿ò¥«5¥ÿ ºgý£}ÿ •-
ã~+Ô³JR†b”¥ ¥)@)JP
R””¥ ¥)@)JP
Õÿ ™YïÙ× Ãj³Qº¿ó+=û:ãømCJ?’>(™”ê ¾Õn/±Ø´W‘bRþy G?DKbÌ| €OÀbúƒ/™µk‹ v-Õ$h¤W¿ž7ÇÅ] Ø2Ÿ èàƒð"¹ é AêT¶º$cìRhcµ–$i»¯!‘\JŽ¬¿Õ£täÀì6ª7G_]áòS϶im®í£7+’‘TÛº±‘"QhÓ,ŠW‰ é#`nZ:,ë$ ®Ìô2ŽMÕ«eÛ·©êžÓÔ¿ªq?yÉü½=§©Tâ~ó“ùzæ¡êË|–Bã#j÷ã凱B.1 ’_O © é€å¢UÂkeNëNÇ«îqQ<ùWÇE’È^ß*›üÓÅh±[Nb⥣!\r
æ¨]/„©Ê-ŨÙT‹WQ^}NÇÚz—õN'ï9?—§´õ/êœOÞr/\ÓõuåÜY쉵僦àÊ[Ä.ŒSžâÌÚ%WhÌ‚Cž<–¥/iê_Õ8Ÿ¼äþ^žÓÔ¿ªq?yÉü½I½ëvØÉíöö6·ñä=Ä÷ü-C ¸ÎSaLd™¾gŽµê¬vùµêé±±ÌðØÝÛÞÍ;Y]2™ ÞháÒL„7h³³^%‚¦ô )Yä1Ç…yõ-{ORþ©Äýç'òôöž¥ýS‰ûÎOåê,ù‰ºVï#c WY+ktǽ¼2Ü—›•ÍÃÂÊ$í€(so‹È/ºyÞ¢ö ë^À‰%–w Ø]sb¬Ö¬ñdŒÂCåžã)Ò¨$£~ÁŽ<+Ï©ÔûORþ©Äýç'òôöž¥ýS‰ûÎOåëGåEçc÷l ø÷‡»û Ö}Ÿ¹ìþÓ¾ïo— ×ÿ kß/ת¢dò“fòØAì‰ÛäRâÏ‘6äMðÄ[Ÿv.h¸~Hpx:%šã¼úO´õ/êœOÞr/Oiê_Õ8Ÿ¼äþ^¹«~¨ù;Œ»[–ìï*,í Ìä8û&í–b³Ü'ÇNÊA“ûH×kä&ý¯Z\e˜|d“_ÅvüÍèXÛÊ‘9î%£bÇ‹*’};P•ay qá^}JÞÓÔ¿ªq?yÉü½=§©Tâ~ó“ùzç²Òv:ÂÞÖéEªA&6,£¥íêÛÌðȪša,ºFÚòQ²ƒ‘屎<–Hõ•ó\Û÷f\©ÇcÑr³G
¯°›ÜSÙ 8«02 lF¼˜_jã¼ú/´õ/êœOÞr/Oiê_Õ8Ÿ¼äþ^¾z:þû)Ñx\†H¡¼¹²ŠYYÖPy|Õ A
Hf¼f·‰®#Hç( ‰—Umyˆý:ú…Uìv°Ç çÔ•í=Kú§÷œŸËÓÚz—õN'ï9?—® §æ¼NœéÌ‘¶ê;{™ýƒ»’¾Ê™í¥î¥/iê_Õ8Ÿ¼äþ^žÓÔ¿ªq?yÉü½sض¬³ {u&FÞ pXûÈí²s±´Íp[}¶@ÇJ£d„|(z屘ë8o'ÇÉn/¡[ŒêÙDémpaÙpŒ;¬
!@>²8€aì°Ç çÔè}§©Tâ~ó“ùz{ORþ©Äýç'òõ£UÜe=•ð¸¯jñöùV{ ‚)¹ðXÆ™ZOɾÃ2(<}Z$®;ž¥šÏ'sie‹{«™rã ª÷…W‘²Yùú€
¨?`îã¼ú”½§©Tâ~ó“ùz{ORþ©Äýç'òõ£Žê»‹ËË8î1^Ïosu6=eɹ„Hd⺋ò2 ä«äÀ;¨™Ž·k¬?RãÑm²b/nbö,ŠÏ5±‰B‘0P;2†uÐVqµW¤*.ö°Ç çÔ¿m.JNµ°÷¥¥¾±×|=žé¦åùK}ï”i¯£ëÿ å]MC›ó×û:óø–Õr»¨~4EW|> ¬Ò ™X ÙÖÿ ÃZ³QºCó+û:ßøkVkRµ¿$¼X¥)C1JR€“Ô“J˜i-äxî¯Ym!x؇Fñ2.¼’ŠZM
xCä|FÝÃ{³ýK %À…U"´´í¡ãà ¼ÙT ?Ìx >ªÑŸúïVÛ@|ÇŽ·7L§Çåe- l5ñÒÀ øõ¯ÄüÛ44–Ȩþþ|í<þ׬³ÍÓ“Ý{’qt2k·ÒB°°l‡`DLNÌQ¸òàFП_Ž[ƒ¨³Ö×+v1²ÁÉÛc® (å® :dRÄD\&ödçÄÿ g⺉±V3Ú‹W¶Œ@.ë‚zue‡ôëÏpr?YÞ÷³XäÂc¥öžvûö›¸¯eõ·ªh»|ãã]˜üvv39¼WVä2=J-VÖG³{Û›6EÆÜ(·™º×GòN¢€ ƒ(%-|7QuVZ߬0Ð쪮 ‚8ŠW[UA-¯ e.f]
ÇÃϪMyê!éìe¾Päc‚A?6‘PÏ!Š7mòtˆ·sÉ¶Ê žo³êmä³Âc¬=ßìÖý¿wÚ+_[ Ü'†×Éóý’y;>Ÿ“°8?”¹&¸¿ê«+{H /a”¹‚bÒ1Pn¤ì¡ @$;‡|t=
¿M‹®È'V\címd– [Û{9 LmĦA"ÄÍ/´¯ä¢&ÙF‘ò9TnŠÀ·³ec‚Ò+!
ÞL±É|¸G"ã*ŽL4ᶃ°krnžÆ\eFH$3óYò¤u×xƒpw WLÊHàš>•Ð øê ¡—u|°Z,C'qg ÚMtÐÅÓ'uâB BÅ#N óvd'[Eé0—Ï‘ÃÁs,I#rVx•IV*vê¼z£m”m©$®Î9z{5‡±$H…Ä—JÑO$r$²;;ºH¬ I.ûâG†+ð:Ë|uœv¶±öáM $’K31Ùf$’X’I$’I 6)JP
R””©÷Ùblì`K«æ^}·Æ‘¦Ï©Üâ ¢Xƒ¡¥b¢T\‘÷ì¸a‹¿{>ÄãËZÛ1Ñ⋱¶ÑÖÀ ±U+ dîM4½ûÙôgœ¯ ZÞ•FÏ].ζI%‹1XX{'ri¥ïÞÏ£<åxòÖôª6x¢ìévu²I,YŽí 6’à žß<¥O¾Éµ¼ëiij÷—¬¼»HÁV5$€ò1ù«±¯ ±ÓqVât*¢äìŒ××ÑX@®êòHíÂ(c ¼®A!T yÐ'd€ $#Nœ„ñÞdÙÒ5`ðãö¥# íZB>|€ùÖø)Ö* æ±Å´íyq3Üߺñyœž* ¬hI¯…ð<ž*X±ª/‰GdyôùqJR†b”¥ ¥)@)JP
R””¥ ¥)@)JP
R””¥Íc³]A“ÆZ_ÆÆ,WP¤È ' `¬ êšÙöÞ¥ýQ‰ûÒOåëã¤2ð_³íÿ †µf¸ ‘4Κ˜#6”WŸRO¶õ/êŒOÞ’/Omê_ÕŸ½$þ^«R£êfSxWŸRO¶õ/êŒOÞ’/Omê_ÕŸ½$þ^´®ú’k~«‡ ¶èØðñAqu³¨æ•ddRß#·ñ>XÝExÏõe¦.h¬à™ùïm-Š¼nSò³F¬œÆ—»Ûrá7ËZn%jÚúƒxWŸSwÛz—õF'ïI?—â¾ûO—ýݯàSÜWßiòÿ »µü
ÇGzFŽÛ¥+_ç<™tz5RU,ìïµ=ëôaŸ¥qÓNÒ(’+d‹_÷v¿X}=LÍ0ljyô5o:JÎóÛÕ¯/–ìPÅM t>ã ø¿'Ì€JþKwäæ¶&éË9ý·”“lÈ[ä$ÓCÙâš{ ¿§Ëy 5õî+ï´ùÝÚþ=Å}öŸ/û»_À§ÓÔÌaóèa¹é‹i幸ŽîêÚîkÑ|—-¢€ð ¥H1‚4Á¾q#GZÉ7O¤–vè¹ èïmùvò!Õ§õ¾ù)B¬~)Ç€ÒñUàœ~½Å}öŸ/û»_À§¸¯¾Óåÿ wkøúz™¡†ž¦haóèjü”ƒÙuïïx{W¶{Çò]î÷o³Ë×ö^pּ뗪·-°pÛÞÙ^5ÕÔ÷¶ó@$š@ÆNëÆîÍããÊ1 ºU€ Ð >â¾ûO—ýݯàSÜWßiòÿ »µü
}=LÐà %çÐч£mì ³ÉdmÞÊ L2 k˜""»%Häþ¨Ê7¬ùðºÜù9gïOxw'ï{ÃÞä8÷=›Ùµðù¼<ý|¾x¯¯q_}§Ëþî×ð+J çÉÜØÍÔyxdM<KSß‹K· ú•#É ’t vúz™’¡ºKÏ¡KŠLËÄ÷ÙÄ°Ç$üyð_
Qàh|>;;5¹m
¼Q<Ï;¢id
È 8ñ lü| > *w¸¯¾Óåÿ wkø÷÷Ú|¿îí£é¦ûQcļúl:1l¬ì,$Îåo1Ö=žÍœâÜ'䊘¶É¹âȧçyãç`uò¸b¶¯µÊÜê[¶•ì.¡Ž~7÷¤òœTFÍþ%e‘x§åˆµî+ï´ùÝÚþ=Å}öŸ/û»_À«j*f†ñ/>„\WF]Xãñœs·Ö°bq÷ Ä xäì†Ñ ؘüd«c^*¤ý1mÂÏÝ÷wXÉíH㸶(îRFV7u\1fEbÄ$o—–Þoq_}§Ëþî×ð)î+ï´ùÝÚþCÑê>Ô0ljyô0ÜôÌ2Ü$Öù ™öxígìÎ \Ä…Š«ÈáœÍýhÊþ²Kl2|œ³÷§¼;“÷½áï
r {žÍìÚø|Þ ~¾_N¼W׸¯¾Óåÿ wkø÷÷Ú|¿îíŸOS1†Éó¹ qÆÞ[v¾È¼
Ÿ m*ñ·¶ àƒŽ¶¡™¶ÇüE´ºî+ï´ùÝÚþ=Å}öŸ/û»_À§ÓÔÌaóè~MùëŒýyüKj¹R,°Mm”L…ÆVúúXáx\,!U]‘›û8×Îã_W®šQp‚‹+Q§džî¬Ò ™X ÙÖÿ ÃZ³QºCó+û:ßøkVkA[òKÅŠR”3¥Lê¹ìðw/jý»¹xÛÛI BM+ãc¿ 3©>€| … F8šŠí0ôïåãÈd‡„¿½yc QaVüAÖ àü4ããñ;9<î Ú÷¶VÆý¾ßµÜ$\õë‘ÖÇÃëµgi…”vÉÛ··b‰6OQ 6|Ÿé¨¶ýaæeXî„ÎX¤ÚÜtŒÏ
Ü%»KÑ#,92©ˆ eý ‡×Púÿ «Îšý•kü%¥×Fa/z¢¢šÊ¿‡‰ mâ<ˆ ’œ‹
FCokÛP¥Ap‡AJR€R” ¥()JJTË»¹î®_ Ž~&½¦ë@‹pFÀ ø2A ì(!›`ª¸´csîúúUllU$¾uåë¤I ÇÖ¼l`±
̹¬lb°‘ä‘Ûœ³HAy\€ 1ó € ÆÆ+žI ¹Ë4„•È ³¯: h mP–Õ¬…+
Ýåµ…³ÜÞ\Ãmnšå,ÎWgCdø H3±sœõ]ŽÆ%þÜ ÊIô¡ÿ ìzÙ r#m c}¯p÷”ùŸFXM™ôÉ’W Ö!+! ÄñRGÏ*È7ìqÖ˜Ø;t‰Y¹¹ ZG îÇË1ÐÛIúMmRËe–Ä)JP ¥)@)JP
R””¥ ¥)@)JP
R””¥ ¥)@)JP:Gó/û>ßøkVkDzÝCyÒ½ ÒÑÃÔw–×8ŒFhíL0ª¬@€±ü¢ÉÔ¶g|Öè õïW&BÞN¨¿’êÁ—¹5´V‚7Vg àFüXvØ”Ž,¬Chy²¦ìåØuUŒu’ÿ K{Ï¡ét¨Þå¿ûO–ýÕ¯àÖ Ë)ñð,×]W–Ž6–8AìÛ ¼Ž¨ƒÄ K2òߟKw”Á %çЙ ô}gy‹—Þ·Y”½i»šÓ)pˆ·>hÓ— FU|”#MïUñ'Oõ ¼’TÅIíÙ ôËq"vd‡Ùû‰vÛšŸgÚ–e>½ãfµÅ”ö³ÚC7Uå–K¹L0ͱæáÈñJ1óõ}z¯³‹½[„€õ6g›£8"ÞØ® í»Ô4 Ùóèê×yŒâ^} ¶ý?—ƒ/Ž‹…‹c,²·Y hö‡?yn= ®ß¦¸Öù„Þ†ô5%èÜ‚aúb4)=Þ'ìÅ NâÅ\•‡n%‰K :âWG–Ί€m%”òd&°^«Ë˜bŽi³má ¸S¾Æ¼˜ßþßæ+?¹oþÓå¿ukø4»Ì`óèE½éL„VøÛ|Iµí¬¢´[¸®®-šÜÆWí‚âå{X¥:`Y»„ËÌ Iúo¬Ìд±É%Äws#P¡Ñí†â™™T§uˆeV]
Ƥ緲žê{¸aê¼³Ii(†qÙ¶ ¢¸ `óéu>>¿¯uŸÜ·ÿ iòߺµü]æ0G‰yô,Ò£{–ÿ í>[÷V¿ƒOrßý§Ë~ê×ðj–YŒâ^} 4¨Þå¿ûO–ýÕ¯àÓÜ·ÿ iòߺµüYf0G‰yô3t‡æVöu¿ðÖ¬ÔnüÊÀþηþÕšõŠVü’ñb”¥ Å)JJR€R” ¥(kß^ų’êdãMlAÌçd€±øýÇÇá[ 8¼w_Gy‡¸¸ö+¶»[Ù-aI,§·‰·wìðò‘Ó@ú£.Øzý;Rµ¦aq‡©²©µÄ™´²†;쀎ÚìQH-£Æ3ÅÙ};%×j¥›]dø ±2ã‘d‚'¸7jѶÙ'3wûƒ–ÆľWè >>‰!˜¶_%%ûÞûrä³ÝŽ^ȃj¢1 »@®Š œOÇD§kÖ·UÅ& ä×ñ]¿pß
¼©žàRZ6,x²©'Óµ‰V©ò9|åäðÙ÷1„³ÈYÂ%Q;4½ÒR†nþȤ¤‹Û8‡`Aö™Öy7ãèe }Cã³æ€7]£{¡ìí íä!»…oïVÖIÄ¿6(e˜xÚ–P ÇêÓlP¸êg÷—õ>^Å•´Æÿ k®}ÿ gõüß%*Ïp!E?> Ó+Iù7ØfE«D•×¿ëë; ¨l; É]Ág$o|í¤˜GÅ£ƒ®1ÝM· F¤ðxŽ[ômµ½”Y,•¢[ÙCa)†D
s@„Wb„© ŸÕFõŸ>[Óéï‰/áÈ_[Ç<©=Ť.« òªª«1ãÜ 0U\) ¢-È ?/c-墽«"_Ú±žÍä'€—‹(åñÚ̧éÓ4@"…(L[‹º5q÷ÑdlÖæ%u HèÅ]N¶6HØ$ x$yª‘ÿ ƒÞŒºx´}%ú/䪬çè !G’OmV¬Ð´’Þ·1JR…)JJR€R” ¥(Ý!ù•ýoü5«5¤?2°?³ÿ †µf†•¿$¼X¥)C1Q®ÿ ®õN>ØyKÞöB<w
@ïâ
›ƒãÈ(»#àÖj7Oÿ Zöü±óí·
Ù'Î òqño¥‹J5ãòÇ[ÞÈҗ;×,Ôüž ›í{ÛcÙßoÚíÒ^ÖõÈ oCáõ
¡JšóXYÜ{G~Ò }¦!üã
ÝŒrÒ6þrúÛÁñê?YŠR€R” ¥()JJT™¦—/<––’ÇÍò«ëÙŒZ1¸›"Ùä±ÄÜ!hØ¥ÕÚiÖ؃¢ƒâ ¿úO…ùÌ>j½ KH,m’ÞÝ8F›ÐÙ$’vI'É$’I;$’Nɯ¸aŠÞà‚4Š(Ô"FŠU@Ð €¾èL¥Ø·
Ò¿ÉÁí£$Ó\K¾Õ¼—y5¯£à£eAf!Aa²7Xnò3½ËØã`ï\®„³¶»6ÄŽ~Ac¯!Ï•äP0jÍaŒƒ Üuy¦¸—]Û‰ä.òkOÁF˪‚Ç@n„¨¥¶\Œ6˜éÞå/²S÷®Wf(]›bF ±×‚íçËqS¥(VRrÞ)JP¨¥)@)JP
R””¥ ¥)@)JP
R””¥ ¥)@)JP
R”É‹êOuâ/°–דGu‚²·g±ºŽ)"hÖS²$e ð#[ù§`xß<“±™¯:’æùòÖl=ŒHÞÐò±F_J±Û3¢ºq%AÓƒ°8uÙ ·^‘莒·ŒÁ ÕýŒ=¹®tcETˆ7‚éÉq@•@äÌÀ.ŽßCgñk•¸¿¹³²Ÿ7‡^Êß@£nFp ß‹Û¦q£µb$"«¡é1¡'R¤.–ï ›;·™ÿ ÒÑ¥¤©RŒÜnöµ¾×Ú»¯šþº£7Åà#›&ïvß×(£#$)ÜÈ) 1‘u"*¡•X” *;ßê[¸[;qö]íï—;ŒK¹.-»–¬JÂ|8™OqG-¡^\TzUcŽxfyR)QÞá*«Q¸†Ó}G‹)Ñú?Myòª¥,V·²VV<æ¸gë "Üåݳ;z'Ç=È%aX®ÖìŸ1Ž×oEB‡¹¤kØ]fz[qg‘ÈÞd®ºNòø\ÌÒ\„´íé5¢Fô¶vIÛ3õ*Uq÷q=#..^±Î{Ÿ1ïK5ÇØ…“Û}«´{—D§seÇ—©‰ µ°¼@ë͹žìC7rA(¯x¿mø.—Dž ž'ˆ×Îå±'$Ãuoż©4 xäƒ+©à‚>šÉU“»žß\-¾W..¯ Ï'Q"d.áÄq{²"¼¥R `Ê" 6H_<´XÕ¹Íd0–w<ˆ±{|«¯bíã70Gu
Û±‘O6 ¶VäÀì±Üºx:·sqQÉuÂW ËØΖòt¼f(#!‰Hm1#Žö7^á¸BðJ’ vBÈÁ€eb¬<}!}Wrk° M—ÏÞOÑÆÿ !š¾´½~•·»°{Y M=ÓÇ)œª Ôš"ÞiO0cùÕëµ%…‡¨R@÷ù-%Gµ»µP.c ÊÊË" í‡8ø– D"ÝDš`R”ªLé̬ìëáY¨Ý!ù•ýoü5«5ëŠß’^,R”¡˜¥)@)JP
R””¥ ¥)@)JP
R””¥ ¥)@)JP
ãñ C˜¹NÈ^=‹ØçõÙ¶†ÝÒK^Vï:òÈÂMÊ "lž^5ÄöÇâ:{1l;¼K±Àk³s
ü—\mÞåD{:wÑ |ï°¨};—¾Ê˘Kû8í ÎôA *üÙPÁ £™ 9þPïŽÀøÚäjB÷ìýø NQ? ‹p“Ó¥]¨ä¾[ÔxŸÓäëOšÇ#œ¸•£)z·'aE¼1i¼|yFÇÆüÿ °¥FÇÁïN!üZ>ÞÁÛÀòYšô £Ç£À¶ÍVkVúÆ+ø ž9¹Å4d‰À 2“¿:$h‚$A ‹ÅÏs6©SñÒÞZ2]*%ý«/0x x« ? © ¬>0D(P¬“‹³¥(@¥)@)JP
R”nüÊÀþηþÕšÒ ™X ÙÖÿ ÃZ³CJß’^,R”¡™3¨nç³Áܽ«öîåãom& 4¬#Žþ€Î¤ø>ð~»gi…”vÉÛ··b‰6OQ 6|Ÿé©™ ë½AŒÇ1ÁÊúqó‡§Ñ°ú6Ì]Iú`:[44–È%ûùó´R±™á[„·icº3¤e‡&U 1â@, Ÿ£úë% Å)Xá‘¥BÏ ì¼\©$ 7¤‘¢ÇÓ¢6Ø d¥)@)JP
WÄÓEo“Ï"Ej]äv
ª l’OÀR8¿cçûŸâùŸÚ F7Ú÷íÎwͤþω> èvè}&&pO£ž‰`I^>—jÐüÁiQ¨D*ª }ÖöFÓÍyp‘+7ËHäyf::P ?@¡-¹˜£j£wîsž›CØÄ¿Æí$"[ôˆ€ ”?ý“{ md§»gÌúóQBlϪ£1ÙYø…Š’~yUqf„ì†í¯ç̼L6–XÛ%½ºp7¡²I$ì’O’I$’vI$“Y©JnûX¥)B)JJR€R” ¥()JJR€R” ¥()JJR€R” ¥(!“ÔžëÄ_a-¯&ŽëenÏcu RDѬ§dHÊ=àF·óNÀñ¾y'c3^u%Íóå¬Ø{‘½¡åbŒ¾•c¶gEtâJƒ§`pë²=n½#Ñ %o‚;«û{s\èÆŠ©oÓ“ †*É™€] ¾†Ïã:×+qsge>o½•¾G ÜŒà ¿ ¶LãGjÄHEWCÒcBN¥H]-Þ?6wo3ÿ ¥£KIR¥¸Ýík}¯µw_5ü4rwù{(1²uð#ì…¾Eí¦îìUSµ{9^Ø1À: ²ÖK…[[Ž¯ŠÃ'um}/QcÚ;¶y"IM äË”‹åtBñÑU
=*µý¶ÜOÙy;r{($RÇáÏI½sôìúwó[éS¯>U1I»[Ãq²VV<öæë!oÖÍŽù!x/m"²KŒµÇzKN™xÚ„apçg$©äKÞÃuÈu|¶w7É ¯{yÜ –¸7ÐwV/ꪜmÆ„ & ¤Ž'‘2húU*¸ön$æ?£“n£~6³w£÷|@·xɧâ9®É:Ór î 4/Ø›vÇÛI»öÆ%0ËÞ2÷C‹s$–ØÑäIßÇfµòy«,Oh]4í$»)µ´—0ÛpY¸¨-Ê ÙYfñù£xn8³Ê`N ¢@¥øÜ
ÀsÑ+êøy¨w{AÄã²ØÛh1v8ÌÄð™m¢ 9|!{«%UBiÑ ·î ò?9H-Zø›x½ßŒÆXå/¢I:«#oyÙ¾v“Š‹¶í³1,»UŒŸƒló9å^•$ËÄŒ ™_‚ñ˜Ä·¨¥SäèoCâ@9*qƒÏlç3™ÇÙÝdò)lÏ›iR ·ˆÊ#¿#RÊC øâA qßÊbeó÷“ôq¿Èf¯/_¥mîì ÖCOtñÊg*ˆ5&€ˆ·ƒÚSÌþuzíHÌôúf¹Ç.Búi¢0][BëÛ¹ˆïjÁ”•Øf£(Ä 'Òº•5} ¯JR³$™Ò ™X ÙÖÿ ÃZ³QºCó+û:ßøkVk׿$¼X¥)C1JR€R” ¥()JJR€R” ¥()JJR€R” ¥()JJR€“—†[W\ÅœnóÛ)ïÃ’÷P€Ç¶ÒÀžKãâ
‚¡ØÕ8fŠâç‚D–):HŒYHØ ˆ"¾ê2ÿ Árì§Æ;!!pÇÂÁpxŽ^ í¾_/$È
ûVí_>áf”¥ Å)JJR€R” #t‡æVöu¿ðÖ¬ÔnüÊÀþηþÕšVü’ñb”©ùËéqØk››uFº
Ù /3±©øx.Ê7±ù#ãB‘NM$ka?Þårç½pmbß‚±@Jq#áý¯}òHq¿¨Y\mŒX¼]¦>vŠÖ Xª¨Q½kÎ…mPµFœ›[Ž>ÿ ¦2÷ eiQebµ[Kµ.‰iùò@V%
%HFòyÛ ¡³ËŸ¼éùãÀ‰ÖÇûn ¼›"·VÞ¬–ýÛ®Ðku!¤›Æê«à3w5óz…(Pó8ús%îìm´BF·Ê¤–áZì¾ÐÓ"ööæ…¹¹‰ Àͤù UëAbnì£|zÞåÚX¯0Ò䓸÷¥¡gŒ†ÙNáY<€ñö˜î¬ƒ!=ü:úÞÓ#ÿ !{7k·uè2/®]w³Žj¾Ž›@Üže¶·–w °Ž6v
øU±ÿ ?Eæ÷ 5Ô}›lmÄî¬ ¼šâðr>Ým @ò°æ™E‹… ÊE¼¿ <õòx«Û”Çe/ì£{|ƒÝÝÝC}†—"GhE¨{hÈ)*[ÇÛ/¢«‚I}·yÓýKeÔO-”7Ѭ¼MívrA²®Èt\ |¡ð×À`§ÅX <þϧ. òåïÓ+5Ü 5gmÒÈs>®VFF.c 0õr<{‡ÕÅÉ;½ã ÉÉìV¶6©!¸‡ .. 7=ÛÊÇE@Reð0_þ u·wpXÛ=ÅÃð5³¢I$è ’I 6I
“Sáµ»ÉO ÆR‚˜<K'?P;W”¢ËãH6ªÃ—&UÍðÍëÐŽµ*L××9 ä³Æ+¤jÅ&ÈiJFAÓ,`üùñ½pS½’T¡¶}ɯ²‹m:ÙÛÂ÷7î¼’Š‚H
#€Dk἟'‹ F©cŽ–)Úòútº¾eáÜHÌilzQ n ;%ˆ:U šÆÆ+žI ¹Ë4„•È ³¯: h mP‡$•¢)JP ¥)@)JP
R””¥ ¥)@)JP
R””¥ ¥)@)JP
R””¥ ¥)@)JP C&/©=׈¾Â[^M Ö
ÊÝžÆê8¤‰£YNÈ‘”{Àoæã|òNÆf¼êK›çËX°ö1#{CÊÅ}*ÇlΊéÄ•NÀá×dzÝzG¢:JÞ3wWö0öæ¹ÑR Þ §&=Å U“3 º;}
ŸÆu®VâþæÎÊ|Þ {+}Ž=¹À ~,;l™ÆŽÕˆŠ®‡¤Æ„Jº[¼~lîÞgÿ KF–’¥J3q»ÚÖû_jî¾køaKËŹ‚.³ÊÍŒ¼\|2Y¥Û#Ipd›˜UM-Ì¡Vß’puä})§Ñdš)ºÒÒKûÙÒ;nªX íãEå‹VT 0rkCéæÃàì£V8ç†g•"• á~ª°%ˆm7Ôx² ƒôן*˜¤åk_-ËÀÙ++ ¥Ê7YÉŠ–iÍ•„³d†m¼‰0$>¨ù½à ¯O³Å½x/Ó¹·÷„!¦ÕÉŠC ]â9&Ó“pÞ›G€å£Ç–¶9 ê[XÛc²“ÞO|òÞd aF¸dSÁ;Ž P …
+yµ½’ Õ:£dœÇTMµÈcç¾ËÏ„˜E2E“W…#U&2б™Y99
Àq娛D Aç îÓ'“éÛë«›R¨ŒK‘°•ííïØÙ9W 9 y‡Ë>Ìl»ŠW¥TüžjËÚM;I.ÊEmm%ÄŒ¶Ü#Vn#j k@²‚vFæ2ì#‹’ño172d¯¦k¾¤È[ºI9(°Æ/¸FáÄÎÏ…Ò Yxë¬Õ—Kcn,²9Ü–C¤î/‰™Ìì÷1¥¿g‚@#ºÃJ6ûù·šô+,Þ?!o
ÇyL)Ñ¡”H¿€Á¸z#e}_5±wÚ’!k/|-Ï(w0FÔ’y§”ð›c΀;"§Ý¨ §I]ÚMÕ9˜1™{¬Ž.;+6¥¹{ˆÕ™î9öäm™*6Ü›DØà{:™‹ÂŒuÅÅÔ×÷W÷“¢F÷"0Ý´,Q t ¹Þ·ê;$ :¬Ø¥*¤“:Có+û:ßøkVj7H~e`g[ÿ
jÍzâ·ä—‹¥(f)JP
R””¥ ¥)@)JP
R””¥ ¥)@)JP
R””¥ ¥)@)Xçž[yn.%Ž"BòI#TP6I'À yÝd †îÒ ëg·¸Nq¾¶6A ‚ò Fˆ ¢+5(JvÚ‰˜«¹Ì“ã¯Ÿí®˜¾‡åafaž ÈUÑe]˜ä §jGÐA E É_ý#j•Žs2ÛÊÖñÇ$á $rŠÍ¯ °¿§G_Q¯?^ ê¬}·ZßÏa)Žye äe˜BÉcŠˆ†%ä…´O©<»øñ¶ž‰Jó·Ìu5¥ý¹žîÞu¸Æ¼¹e´–qߺíIÊ;f Úâ âÄ™4Þ ƒ‘ÎXÜ^³æ$¹ƒ˜³Ç*Kok•¸6üÚfUj.Ø\.{ ;ÊÇðÝ[Åqo,sA*ŽHØ2º‘°A #Îë‡Ãgrså-e—/ ÜwÛüSÚ,Q…·H½¢DäG«»¨l
0ô–õ˜øܾNסm峿’Ù0%e’H’8Ùn\Å.Ò^JOÈ(ô>¦óðÐ ˆ°÷Và Ýîû%¼pw8ñçÅBï[:Þ¾»\öS/V $O' Ë‹{˜nD@ˆmÕXÍ µê U.NÔÞ§ÃJ~#;¼êX^D»äï,[¼Ö«kÂ2©„ﴤ»
±£! ¤ m·vw•#ýw¨1˜ñæ89_N>pôú"V FÙ‹©?LCckÎtFw;–¸ÇÏ‘Kµ·Éc
ñmj_q-–&îvµ#lÊ “Ùôxëy|¶Oü
"ÙBG€É.DŽÄ¯2ý …]¤‹ÓÙyeóܳJR†b”¥çøžK.ˆÄ{ôwxN ßÞ³–8ãág,-ÆVP’~QÔ Ûcj ®âاö~ 8ïÄfNp:iG
°87¨z[Mññé:Ø¥¯gagˆÅei´gŽÒÂÅB/õ*ª¨( _WwpXÛ=ÅÃð5³¢I$è ’I 6I
“Xﯢ°]Õä‘Û„PÆy\‚B¨:ó NÉ I Fµ¦/ÊdrI ÙßlÉmA)#cÁõ6§@*¨ºŠµå¸ZZOur™ Šp‘7ìÖ»[‚4I#Á‚A#aA*»™èM4VðI<ò$QF¥ÞG`ªªÉ$ü «”¶ÇvÒWçs6Žªeœl"’7ŸG– kZ d·ÓÇyšŠÝ剃[Û#"·`|8,£”›ÿ ˆð z™Åõ-‹æïžgÇœï‰c»°Ç w 3Ü íO(Óàuµr|0PzÐüÁiQ¨D*ª }Ò…%+ìì¥(TR” ¥()JJR€R” ¥()JJR€R” ¥()JJR€R” ¥()JÈdÅõ'ºñØKkÉ£ºÁY[³ØÝG‘4k)Ù2‚xüÓ°¶e å¿>+b¨¶ƒÍ^îÓ'“éÛë«›R¨ŒK‘°•ííïØÙ9W 9 y‡Ë>Ìl»ŠVæ.KżÄÜÉ’¾™®ú“!né$ä¢Ã¾á_‡T ;>oH{ꟓÍYb{Bé§i%ÙH¤¸‘€ÖÛ„jÍÄmAmhPNÈݱ_b@óÜuÖjË¥±·Y îK!ÒwÄÌæv{˜Òß³Á Ýa¥}‚üÛÍ_é+»Iº§33/u‘ÅÇefÐ4·/q³=Ç>ܳ %FÛ“h‚» ¯AW˜²1¥ËÆ. »oܶœ?Åxž2#ðõ㦠4k ?˜›Ç¸¸½¾È^Þð€ÜÏ’º©í"¢¨-!ä@Ù}lúEK•Ó¸+Ò”¬É&t‡æVöu¿ðÖ¬ÔnüÊÀþηþÕšõÅoÉ/)JPÌR” ¥(iä²pbÖ{ˆîÝÂki-ÃoDùXÕˆ >:×Ãë¹JÎáë+ÜÖ+£¯l.Úþæâ3sna–Ò ZK+†Ðyž Ê•ç €Çˆ7-z²âöÿ eoŠå5ßµ‹†7 %¹¶!”캒ÍÄ€ Òì(f)Qp1C…‚’0îÒ5m€/V'd€² §{ÏÇxìznÏ
äRNÒEíœC° ûLë<›ñô2€>¡ñÙó@C‹úB¶Žã'ìVìl®/ž ô¹ž$„¨t™ 9}` àã—¤Ž¢ÊZu•Üyk g„Å‚EŽï» FY.•eOH-Éû1 ª|ª†4-úä渾¹µù±qÚÍ7äâ´“‡ä”(ÀŒ ä— ú™´¼rŠDÊ{v_%}>BÞ+sq7e ;FÑöãP®!`ÄR>ø:Ñe‹!’\|ÊÚæk¦í<Ï:E+5pA+¾‹*1 l
Ü‹ªî.16[YØÜ]ßݵ©ƒ"$´”¬o!a:¡n!cuþÏ|×Zãëª
Óvk-Ä–²OdÒÚ[Ú ´a`ghÊ 5àÈv§j@ ©_äœ Ë¯xß{ÃÚý·Þ_’ïw»]ž\xv¿²üž¸k^uËÕ@kÚõeÅíþ*ÊßÊk¿k n Ksm:C)Ùu%›‰ ¥ØPÌS¨¨ö 7gŽº³¹ŠIÞkh®cäì?*פ²» ¨ºoÓ¥ ˆ
b€R” ¥()J^ùï#³‘¬ ‚{¡®Ï1‰ÈÞØ+ãá?Wyý¶ªmºFòækH 6V[Xå·¾3Îò&ˆ²Æ¨8«0BÍÇЛP Ò+ ðCuo-½ÄQͨRHäPÊêFˆ ø 88²G0°Ç5ìöSI›k&–é-e¹ì{Î{‚cY9O #,¬
±‰Ëf}³-ÖKÚ!ºÊÞbL&AÛ€\ñ•ˆ31· ªiˆ‚9WYm‰ÆÙ[Û[Úcí ‚ÕËÛÇ*« À” iIà‘ÿ QúÍd[ 4íñ´{R¼ñê08Hü¹8ú˜ó}Ÿ‰äßY <®LîO#ý Ë-î^<Ët•õä¥"bŽ$*œ<ïr¸~Dú—Òmk¨¿ËäãÊdnã¿‘ °ÌYcVÈGŠT›Ù¹;’¼ùimqe „Ø>®V0}-ÃàbƵ¥Ã›(lï'6ʦñcŒF;ƒÏ!ÇcDª¡&'6R ¤¸ûGÈBœ"»hTʋ羶©¼ôŸ®€çìr™yº°á%y8YÜ\\Írb Mnʦõ¯Hå;(pvÆÉþ;`¼Þ7«ú:z|ÝÌSñ—§çË"_›Q u7QBÝÓ·ÜÛÛ '}å†*k|ÎC)us ÓÝ$p"Åc†6‘ ³}Êûm€|iFŽö,ñ8Ü}ÅÕÅ–>ÒÚ{·çs$0ª4Ͳvä
±Û³õŸ®€‡Ò×™wÈä,²bû·PËÉ=¡¹Û™mm ¡x’'Ÿ’ûŸø.N\‡ÍÇ]z¯XùíJ*ËþIÅx¹òmÍ«w‰ÆáÚß´±œ»Gk
Ä¥´ÈPô ßù
Ùš® ’ ãIb‘JÍk·ãÑ®+ð×Í UOê»ì¥…µ„¸ù ŠÈZErî¼’K˜£(£à6 ¶ÄøÖ€ÛrN‚€ç°ÑM™ºÇõ=ı¢IÖÖ8È1,Â';’{‡”kÄ…M
ì ‚*ljÆÔ›)>Ñ2' nÖºøðÏ‘é_ýê.üÊÀþηþÕš¨’›K25ÜÞš±Êe¬qV‘ÝJ¦Y¬Oy/ž
X
³36†övþ6Mnb,=׈µ²2÷žÂÉ7 _âÒ 'Ë6Øù$’|šÓËÿ [ËâqŸàiö`|Hxñ üv%x[è+lýÍ { –{}:ŠR”3¥(i_äRÇ·Á5ÕÔ»í[AÇ›®GÔB€66Id‹ W÷þÉÛ†»÷³ìA n<µ³ (»m l R°°öNäÓKß½ŸFyÊñåéTlñEÙÒìëd’X³t’X¥óÛç‡ÅŒ«;__2I|ëÇÐIH{i½xضb:U~.òœî_ xfÈ®»€žKjØy@; ¥v ý™pûdùÏF.y¬Ç—¿X†äú„!Ô«à™4T‚ò$”§ii²[Û§Óz$’NÉ$ù$’I'd’IÙ4,ö;Ë~_?† dîM4½ûÙôgœ¯ ZÞ•FÏ].ζI%‹1Ý®3Ö¼FòsŒÝ›ûòöQ§˜ˆ,ë+`•€`<Ô¶ÈC-½³M=¢Ï3˜xE8u3(nähÄÅJ>üè;GC6Ûwfå+NË-É<‰a´ºxÒ7u‚erªëÉ Ñð|ƒô"§ÙõN6úöù`º´“ keáÈ%Ê´E]çVõ /`ìïé?
y\¥O÷î Üþ÷÷»?Mö„ìüî??|~wÇÅC W’¼»µ´Åâm%žgÈö«æ…Umn
‚±9%‹Ö†¼š¬¥K‡'5¥‘›¨}Ûrì…ñ‘
ª'“¤~B«’5à);øëb ¶6êâ+{|…¤ÓËn.£Ž9•™á'B@ÙB|røP”;,¶7$ò%†BÒéãHÝÖ •Ê«¯$'GÀeòÒ<ŠcrØÜÍ»\bò—Ð+”i-fYT6Ñ*HÞˆ:ÿ 1@nR” ¥()JJR€Vœ™[n.àšæ8žÎÝn® ž•Ž&.–>5ù7ú|qó¯¹\—D[YõUÆP]dšol°«eîÝ»‘¼¬ÜùI¦M:iX‘ó¼
¹ÓÝWgœÁœ»Ïcojbö¥ãx Çnw§›À¶Ò@ÃlF ŽŽª ¶5oÒÁ²‚ñÝ‘-ÌËÜfTÀ.öHVV#è À×ËÓÙë šÂ<4÷wWý)mˆ)Ðgž8æ
Ü.ê8îa¢œ¾k|Erw;•—«/ 9'ÇÞdír A-²Z¯e`þÔ²™¹òƒzOI %Û×é« »›Ûv‹ ö½G“¿–õ]8Ï·ºƒ‹ÝÛ¯Äàƒ×¿@´Áælú‡e—°~v·q,©² ]üU´H ÁðAB¡ômµÝEa,¯ídµ»µ²ŠÞX]‘ˆdP„í ; ~oG`\ ¥()JJR€ò1}Iî¼EöÚòhî°VVìö7QÅ$MÊvDŒ ƒÞk4ìç’v35çR\ß>ZÀ-‡±‰Ú V(ËéV;ftWN$¨:pv»#ÖëÒ=ÒVñ˜#º¿±‡·5ÎŒhª‘ð]91î( ²¨ ™˜ÑÛèlþ3r·÷6vSæðëÙ[èqíÈÎ ;ñaÛ`tÎ4v¬D„Ut=&4$êT…ÒÝãógvó?úZ4´•*Q›ÞÖ·ÚûWuó_ÃG)y
‡UgF ;4"âéÓ4öÑÇrƒÁ• ¥7ÀâFS¨ÕNÆo$ñæ'Šï-}iaò‘`™à•—„ ëÊHßùm™†¸ù}© ‡£Væ:ë¬}Ĭáìn
ÄAHÑc‘i¼|8Èß
yÿ jóåQJMÚÛþ#d¬¬p©‘‰í± ËÏiƒxvîÞýíD¼.m7:²³ò€»
±îÌò#u6Iáö¢ùkè®cÂÅ6 K+ZÉwz{Û ‘ÀM&Ößq2 Às ú5cžxmm常•!‚$/$’0UEd’| ÓUÇ·q'œõ-Ü-¸‚û.ö÷ËÆ%‹\„ÝËV%a> L§¸£–Я.*V²ar+Ž¸íK{Ü …Ú\Ûœ”ÒLmTÊ!ÝŸÜ+¡ v9>I—MèÔ¦=–°5ÜÛûÂÓjäÅ!Ž.ñ “iɸoM£ÀrÑãË[ ŽàuDØÛ\†>{ì¼øI„S$Y5xR5Rc- •““¬ Z‰´@ ž¤^õ66ÂòKWÓM „‚Ï =ÈŒVh‘‚¶ˆv|(Þ‘öÖ×Öwœ}–ê ùD“ŽÔ·ïƒøÿ qm Ñײ •® š"¹&6 ¢HmhŸIØcÆõ±»9vX cŽºÍYt¶6âË#‘½Éd:Nâø™œÎÏs[öx!;¬4£o°_›y«ý%wi7Tæ`Æeî²8¸ì¬Ú–åî#Vg¸çÛ‘¶d¨ÛrmWc€Uëç…n-åË„‘
1ŽFF xe ©ÿ 0A Ehbð£ qqu5ýÕýä葽ÅÈŒ7m @#D]îwúŽÉ .I¦H~e`g[ÿ
jÍFé̬ìëáY¯Lšß’^,R”¡˜¥)@)JP
R””¥'š×¡z†âÞY!ž,eËÇ$lU‘„LAy ;©öØœn ®±ÖøŒ}¦> œeãÏ ¤+ÊÉ-°BÁ@ T;€OÛkâjýÝÖ.ksÞOfó]DÃئu-4d}Ë.ƒoƼԵéŒmŸ|ÆožI¢hLÓä.&‘¾pÝËG½x²ª~*4%¦·•'¦·–$šH ЪËRÈHùÃ#cãäõƒ\ÿ CB¶Ý7$d) O Šd‘ˆ“,Ä–?æI'鮀B«póƒ'7EB ŒWJI]è QÙgÆ÷¡¬vv6øøXûq´²LG"vò;HçÏÖÌÇü·ãÅ6)JP
R””¥ ¥)@)JP
R””¥ ¥+Ïð-~
Ø¥ Ž.‡—…í[½ÝÅÙÌGrUò3KƒÞ+>øÈüyˆÆÉ×"CybÇy-q™h3›&ÅNmìów¹ /ıvLs-ÑP>ç gE#†¶É' ±êŒNFò;ky§-.ûÉi,pÏ Oä¥e &Ô íAa° ª“Ï
¼·Ç !y$‘‚ª($“à <î€ó¸º/"zKˆ†Ò I¥/1Óí”$wS-¿Îã½í’BXð'âFò_ár¹›¼õý¾ï%ÂbÝK½·~y-® W+ÅÝ ðàªdÐ$(:Qºì0½I…ê$™ðùKKá”—±(b‡“/‘ñ •m ƒ±±æªP ¶+k ¶Y¬òWW)˜9 ö©TÙµ¨Ð„*FÔë‘ô©<¹ ]¿K¼1ášû¢=¾Æzë ÆÑý—½v’CéyɆ ‚uð¯P¥ÅÇ€·¹8iÒqâ-,óî{WŠÙ@Õ´ª³q‰ÙIæÑ€wÈ@
Ó Ó—vŠqc NGºe( ŽE»Xäm Q+$#é h hë´¥åý ƒ¸Éô–
$ÂA
Œ}5-¡ŒÜŠôܬ°È9¦ÄmÜ%A þž:ºÎ—ƒ*··(®Àt‰#“"¶ÞÖÜK’Ûz C*¨3I¿jÓÉa†Æ©‘í¬lmÑQKŠ(—¨ Àÿ °”Oã a‘È ˆ0ۘїþµ–^¸øk‹ ƒ±±²ã KjEšTn]GwêqØÔøªÌ¯tìÀ0VP¤pIð|l¾Ow¿ç³{½|Ïë>ÍÇëÿ —òß½kƶv'_sõöó7/òøÌWoÞ9K>æû~Ñ:ÇÏZÞ¹½lÞ´þP÷¿äpù{½|ÿ êÞÍÇêÿ ˜1òߟ›½kζ7¹aˆÆb»žîÇZY÷5Üöx>zÞ·Ä
ëgþõ»Ax-Êÿ 2÷#ôšãõF?ÿ t¼çü :ÿ ï·¿£^_'»ßóÙŒ½Þ¾gõŸfãõÿ ˈùoÇÎÞµã[;³J
k_nÏ™ïó#{Ýß•ÁÉìœ|ûõk'þž:=¯§Ìzòy0}hæ´Ì£Ü¥ü^Ã~ûíÁ$ŠDú Z&ÖÐ
UØÝ:Ãwgmlö×–ÐÜÛ¾¹E2VÑØØ>
<_>ßs5*7g)ˆõ[É6VÌxöi8ûB}\$fUp4ZÀ-‡±‰Ú V(ËéV;ftWN$¨:pvKé~¨éû~’ÃC6w ±ØÀŽwea‚'Á±.W¢gÌ[ååÊ`ß!mE
Ã]Å; ÿ ïÿ ¶Û_8îš — ªC^?9úZ
]%Jœe(Ýík}¯µ_²ù¯áÏ¥åâÜÁYåfÆ^.>,ÖÒ푤¸2MÌ*¦–æP«oÉ8:ò>”Óèìd¯Ý:žíFxò镳‹ d.™{¶L ï0·ŒŠ9\îB¤¯ò;cKò»¦¾ÐâÖÇþê|®é¯´8Ÿõ±ÿ º¸e')9aµû;
•‰ZÌæ¬ó¿ñ|."\¯üOßùh³kË{?Æ‹’o—od®ÆµÀ¢¹Ë¥¹oèî%¹ÉänŽO£®¯®š{·%¥Ž;s ´@PŒæ¯™Ù¯Hù]Ó_hq?ëcÿ u>Wt×Ú OúØÿ ÝP›Oq:šœ/‘+5Ìu%í¥¶k"¸ÕÁZ{3ZÞ±Ên“¼ ì³ñ †$‚tÄ1U+¹Ñ×yL´WyL¨íLÝ»Og‰ÿ "êb«³¦´ñ“¿+kcLÛSõONÍo,IÔøØ ÐªË ä%‘ó‡-GÖ
`Æg:S`¶õ 5Àw‘ä’ú"ÒHì]Üè¶ffÐ
è 4* ÚÜ558_"å¹·3݈fîH%uïí¿Òè“ÃÓÄñùܵ¶$ò9,–7žÉ4}Qõ¥G’Û&aö{¶í"÷‚±Yx€›IyD| 7+¿+ºkí'ýlî§ÊîšûC‰ÿ [ ûªk°jªp¾Gsh€CœéLU‚ÚCÔx×ÞG’Kè‹I#±ws¢Ù™›@ 7 ШwkpÔÔá|Š=!ù•ýoü5«5¤?2°?³ÿ †µf½2•¿$¼X¥)C1JR€R” ¥()JŸk;kþ¬ËÛ^[Csnøë.QLÕµ-ÉÁò¬ÿ %±qy°Žli TXLÐ o¡ÌJ{l~ 9NÀ ì
RÛó×)û:Ïø—5f†óœ¢ìŸbþ"7»svÿ ò½AÞåó½ãf’ëêãÚ1kéÞù}×½¯¨-¼ÏŠ´º<³»"Y>ŽK Šª»ødð7åˆóf”)¬¾ôŸ—òÄo”Aã#a‘ÇŸ‰3[™Wþ¶–.q øï“
³¡¢w,2ø̯sÝÙKÎÞ»žÏ:ÉÃ{Öø“èÿ Ú·kJÿ ŒÊöý㎴¼íï·í,œ7ë:Þ‡ý¨/½[æ^æí*7É«H½V7y_ìû7ŽÉú–'-ð
ðÖ†žÉÔÞ ÊÚ]FžBÞZ,ŸO’6U]üøðÄy 1{¥Ïã,Ò£{Ë7oÿ 5Óýî_7Ý׉.¾¾]Ѿk—Ó½xÛåF:/ùÕ»°ãâG¼´’(£?SLW·ñðb Ö‰ØØj§Ø¯á·øY¥a´¼¶¿¶K›;˜nmß|e…ëhèèÈ"³P£VØÅ)J)JP
R”¹üwIÁžÇþ#}qiŽÿ ²›µÛµô׉TÚ™6ogm¢:
PðÛ˳ó½ž^ÔF7æw›Óëm(Óx?7Šú†±Ùca±ºÈÜDÒ¿¸†#A„QÅ¥ñðãŸ;òOþÃr””¥ ÿ ½8‡ñhû{oÉfhÐ8
Û5Y[ë¯àTvxäFçÑ ' €ÊNüè‘¢ Aƒ‡}-å£%Ò¢_Ú°‚ñ#€—Š±ãñÚÊÃéÓ tA i/ô±vöõùÚP¥)C27H~e`g[ÿ
i›þ·{ŠÅ¯žõÀº—^
ÅÈ ‡ö½…#É!ξ°é̬ìëá1ß×zƒ'>cƒŒçO®VSôm˜#ôÀ6v4£¢[*JY\³JR‡8©—wsÝ\¾; ü$M{MÖà€ðd ‚ØPC6ÁU|7—²^÷ÒÖ÷Øl¹{VDpô•ùÈœÁ_N6 ¢£mÈÇ‚Ò ¯’ÚÀMŽÄ.Ã4‘È—7±ˆhöw·`]‰b8ž.ÃhÂßê_>eÏa÷Âð8¾œkrmÙ–{™74p>Éem02J[dŽ@–c²¡èXbí±Ýlj9ÜÍ£qtàg#z.À
ëgCÀQá@
Ú†àŽ#H¢B$h¡UT
ø +î…e;ì_ûâ)JPÌR” <ߧ¯ìÑö*Þî ²XÎß·ÙÇ i8ØMwPyM;* @i˜‰¯@†þÎãÙûpKí1àá nìcŽÝuó—Ö¾GPúÅlTûìæ+:ÛÞd-â¹eä–æ@e@áõ1$ “ày¡*.NÉ1¸»LM»[Ù¤‰9r W“l@ÙÛvHäOø˜³ ³w*7¾îný8¼=ÜÛñÞ¼SiŸ‰
Ìw> ±°$¿ŽžÉž½ós’‡ ‡ÈŠÂ1#©øhË*•`~:©C~!}[_s·Ì·–j7ʼ#ÿ ÊÞû~¾w»¢{¾ W.Ðn;óëz:ø|–ÅËæþ9²Dùa3N…¾—1í©øüÕ uVh?ù¬ß—R7¶ç®¿å°ðÙ¡ô—¿¹ Ðÿ Ô#‹š¸ Q‘I OƒOtd.ÿ ¼óS2| ì¨Ãè%¹4 ïéY ×ÇviA¬·Ú’ùÞL´éìE•Ê]Åa ^&õw0îÏäk̯·>¼Ÿ‡‡Š§JP¬¤å¶N┥
ŠR””¥ ¥)@*}ö"ÞòuºG{Kõ^ {nª% ³èÛ|ŸK7ç[ Š¡*N.èï[œ_£5ã }ám kÿ Zòf‹^vÇh ¸'ˆÝËcaÌᯱw
"Á{o%¼‚º•$l½ ¨ÖåF÷+ã?)€0ÚñYHÙÜ|tŠ¡$ïÔ SW:пù—sòöù¸ªccp’‰¤¨Êbx±$iìh¢¨ì ӻĥþ2ÞÊêæy{2ÛÌfšÏ¶~ÞyHƺDáDøÌ‚Þ@Ç[+ÏŠãÁ ®´ÊA;!nP
R””¥ ¥)@)JP
R”koÏ\§ìë?â\Õšmùë”ýgüKš³CJ¿wé¥)C1JR€R” ¥( —};…¾¹{«Œ]£Ý¾·sÚ`@Ð"Aêhh‚ÐÖµX~Oväs{Müÿ ë>ÓËêÿ ˜qן›ïÎô5f”4Uf¶_aµÔvŸÙÜc²(=*“#Û>¾†iš±úÀA'cZÑ{ã#oé½éû¿O™&³–9âãµÛ,¡ñ=ìxÝšPkßüþ¾Uáþj÷Ø7ó}ãÚsúø÷Bò×ëzØßÄUšTo’xóm†Åþ™,7jä}Eâ*Ä‘:Øè üÞkÏ¡f•ÜwpÈç²0¢ùŽ ¸\ ?S3©•?ÜG@¯?úMoú£!Ëÿ ºYðþ7-ÿ ÷º×Ó¿=Ò_<¼Ë5Åô¿KôýÇIa¦›Œ’Y,`ww´Œ³1I$‘äš½ncHô×ÙìOú(ÿ Û\V;«º‰:z|ÕÌSñ—>UøÛû¨‘ºˆ&m¾æØØä ;éú^ï.ù …–H_vâŠb9´7;s m±â#ô/@$óò@ñ-IvuN'ÌÞù#Ó_g±?è£ÿ m>Hô×ÙìOú(ÿ ÛViTÄóÚœO™äM}žÄÿ ¢ý´ù#Ó_g±?è£ÿ mY¥1<ƶ§ær=QÒý?oÒY™¡Ác#–;Ý -# ¬#b x"ºë»Ëk g¹¼¹†ÚÝ5ÊYœ"®Î†Éð<*7W~eçgÜ
«~, * È.>Üßfö§Œ4Û;ß¬íµ£ 7 4€»tfÚw-9b‚ÆÞ÷èk|¥¶¸þëµ»Êý<ìã ¢>’³9XÛGÁ
Äï~< ;½Gwý¾; ‡Ô¯3½ËëèVx*Ÿ¬‰47½Œ½A’›‰ïÛ¬fy.-íc2Ui’ ä /ËŽÆõìkáïò^ù¾Äe%´¸žÚÞ ¥¸µ R²´«À£;ƒ <¹y䆶zL±Å}«žßo#ïä÷{þ{1—»×Ìþ³ìÜ~¿ùq -øùÛÖ¼kg{ö8Û \
>ÊÞÒ&nf;x–5- 7 ÿ jú¾šâ 9$´µö«8Œ$¶cðQ½’:AŽÓ鬔ٞ•Äe.5žöʉ0B†t @Ù'[?Y¡¤š³{
”¥(PR” ¥()JJR€R” ¥()JJR€R” 9¶¿»éûkËx® |‹rŠd«iÈØ>
}|‘鯳؟ôQÿ ¶²g½:sö‹ÿ âÜUZáÒ[SØtã”a¶z²ý3Ò–¶òÜ\`ðÐÁ’I-"UEd’F€éLf; ó]ßuYôÝÿ k]ÏeŠ xozßu½ ûÙë¯þ¯º—öU×𚙿ÎN™ìÿ Ì{TÝÎ ?ÙýžN{מßs±¿£—oéãX¦í¼®¶§æfù#Ó_g±?è£ÿ m>Hô×ÙìOú(ÿ Û\5¯Uu+ôµÞZSu ¸éÛŒœMuìœc™Q=™#%ÌC¸wÝ F£ìÜ9»ÛeÉÛ¶kÛlnm¯-íãbÏu,‘ˆà Ä”A·ûvu-IvuN'Ì»òG¦¾ÏbÑGþÚ|‘鯳؟ôQÿ ¶¹+ Ídž> ŒöÒ.~Ld·ÛË?mlšg
Ú&! }€WÀ⼕ˆef'Þ¶xŒe¦ju{î¤ÈÁ5ÄÐDî#
vÍÄ
´AÁ €ÇàSÑSi.Ñ®©ÄùoÉ šû=‰ÿ E ûiòG¦¾ÏbÑGþÚ…ŠÊæ}³-ÖKÚ!ºÊÝâŒ&QÛ€\jV lÊM¸ÙSL@@Fê ¯Uu+ôµÞZSu ¸éÛŒœMuìœc™Q=™#%ÌC¸wÝ F£ìÅ¥˜×Tâ|ÎçäM}žÄÿ ¢ý´ù#Ó_g±?è£ÿ mr]IïY
Æ ç5;47X{±q!
5錢‚¬jcWPy6Æ™œx¯F¨w]£[S‰ó#|‘鯳؟ôQÿ ¶¾ºBð/ 1¤qG}zˆˆ *¨º” øUê_KsÍûBûÿ *ZèÑ›mÜ™NR¦îïµz–©JWaÎ)JP
R”£t‡æVöu¿ðÖ¬ÔnüÊÀþηþÐÑ~7â½J)co FkõWSE 2?#êD.TkáàÈÿ ÷ÿ !\ý¿Aââüœ××6£ 6.;Y¦üœV’pü’… ø€ ’ä S6— ¶Zò×#iÆÙAu}s· \ܘ#Xã1«z• òÜ©¡ÇZåäh±…Éûß.Œ=™YmåŒ7 ²E#Fü[CkÉD€HÑ fK^‰Íô—¹|•õÅÒ[¨žnÊ´& X™qªí]Ëzƒ #`ä±é8-.cº›#}{t¹3OÚä6ÆÛD"(âè ïèŒþ{Üke«)îZêî rPi"Y%H‹³ ‹¥fúƒ2Ø #ÙôúXäZâ …ðµ2É:XsQ
K!fvØPí¶wOÖ~ºc¤\=»[ã:"òÆrí ²ÙÄ¥´ÈY€Þ€óþBµ2ÝgugdÝœòdcº³ŽK9ÌÄ3ÍÛ
ËÃÔVE_Và XóU.:žÚß(ö†ÒéàŠâ+Yï'jäáÂ6¹’{±yU*9‘¦ÓnC xWŸSëßWÿ f2ß½µüj{êÿ ìÆ[÷¶¿ViTºÈc
óêF÷Õÿ ÙŒ·ïmžú¿û1–ýí¯ãUšRë!Ž<+Ï©ÈõF^öN’ÌÆý;“‰ZÆpdy-Š 1·“©‰Ðÿ OùWiP:»ó/;û>ãøm[3u ŒÉ Á”-%1W.¤ƒ¯ # óF»tg±–šs‚à ׺ýÇ×PcfÊâ{íž;‹{¨Ä„…v†d”! ¡Šqå£ïGZ:xë,Âå¯s¶Ö1]\Åmj-¡ºycŽIŸ¸cSËS6—Ž½ÕêôçùQý /÷EßáÓåF?ô|¿Ý‡]&Zšœ/‘V31y„±Æ¨ QrÅ—ˆòÃC‰åÈhoÀ~t'ôÖ6l7Jâ1w
Oee
¼%K"$l¨V/•ÿ Ñòÿ t]þ >Tcÿ GËýÑwøtšœ/‘f•åF?ô|¿Ý‡O•ÿ Ñòÿ t]þ ¦§ äY¥FùQý /÷EßáÓåF?ô|¿Ý‡A©©ÂùiQ¾Tcÿ GËýÑwøtùQý /÷EßáÐjjp¾EšTo•ÿ Ñòÿ t]þ >Tcÿ GËýÑwøtšœ/‘f•åF?ô|¿Ý‡O•ÿ Ñòÿ t]þ ¦§ äY¥FùQý /÷EßáÓåF?ô|¿Ý‡A©©ÂùiQ¾Tcÿ GËýÑwøtùQý /÷EßáÐjjp¾EšTo•ÿ Ñòÿ t]þ >Tcÿ GËýÑwøtšœ/‘f•åF?ô|¿Ý‡O•ÿ Ñòÿ t]þ ¦§ äY¥FùQý /÷EßáÓåF?ô|¿Ý‡A©©ÂùýQ4–÷}?,V²Ý:ä[PÂP3VŸáÍ•ÏÉ
ÒÉõ½¾µï\mŇw}¿j½²‹žµ½rœo[ ÷÷™µÈæºz"¾FîÄÜXOëÙg 9Ð|ü7¿ûW™õíwÔ9,¤™»»ws&68ÒÒIDE$0&äYã KDîÇor· ßæ« U-Ük'‚1RgmógªO“¹º·–Þã¤òSA*’9Ñ•ÔA›DôV¦1-ð½ßut Ňw]ÏeŽÊ.zÞ·ÆQ½lÿ Ü×5ÐÝWî¬Bbïá˜ã즒”b>òM&ÉHÓ‘Œù!8/’9ú+Ž©kŽ¡ÃYYCu ´Ù)¤¸h”Åp"‚~â©òT¬±¨õ-Ä•ä šÊ¥
”Š6Oi=&G% 7gµìyo5²6 u‡ÎYYtuå„ù‹yb¸¹†;0Îά9¾¦È.O“ôŸ>j‚H±ÛÝÛ§D^,Žïu˜YÙÆœ¸ïi‹‰? ¦¾®,=ßq%•ôVÉ—%l챟l¶Œ)gŒ$xxüIÀúÇ
|·ZËmdÏe‡¾{´º³Co:";A<ݵ”‘xòâêªÄ2¶¹ªšËnëc
óêmÁ"Úˆ…¿D^B"pñˆÖÍx0´ÔÞÑ¿ú|| Q5ÈbúÐEÒØ›«ø.¯'÷E¾G%q
FÚ7BL® ) ””ñŒ1ô O•®÷!Ž<+Ï©¿y"ät½è‹Ë”&Y–ÍÄŠŒYCno 1$ð$šÛ÷Õÿ ÙŒ·ïm°ÉÕ¶qeîlÎûÔV—]¡ÙŽIV3ÞöÜŒª¾JŸ,Hb«låËÛX-÷«©m-î»C³$‘,†Q½íx˜™}@>T2‚Á·!Ž<+Ï©›ßWÿ f2ß½µüjúéi0/#Äñ3_^“Y º—ÁÑ#cü‰ çUê_KsÍûBûÿ *ZèÑžÖL¤7em«>òÕ)Jì9Å)JJR€TnüÊÀþηþÕšÒ ™X ÙÖÿ ÃZ/ÆüW©ƒ3í·Pãs6¸éòÁisjð[î9/ ÑÃßåÚH‘PÆYCz§WŸ
ø?F“n)aq¦ñ.Õê}Ž•3\<ý—°ºÆÞ8‚âw¹ö¦±u.®YŒƒGÄl|3ƒ¾$ë³ÃôuŽöÂkeKkkˆ¤îR\I3ÂÍ+¿ÒÛ‡Ïñ
h(æ=5œŸÔ±åln.³)Š[g·xä·1ב¥–WeWF__•ï7 íPúZuÎ)íîä r$¶¶rª%‘ù0"òõJÆ4< ôD$Ro¤ÕÒçB1—ضxøçmË©çÒ†‹
"x,ªJÍæÖäü
[^‡ök+[oxòö{\U·.ƹ{Æ^Zåãžõ¯ðü}_
ÉqÑÓu[æ‚ã˜ËqÌ>9%¹WQTE3 "j5ñÀKÊH+¹?WX,ý›8§ÈÈý¡±˜Ù'yäŽÌŠ3!äG¥‚K Gªà’ _cÇ_^]Üw¿©ÃÚY#츎nEÝSÑ!
tÇdíy
šóï3°×‡¥ï ËÙJ¹(2Ï!qŽÜÚ ñ’e›2÷8ñ
;‘èÞ‚Ÿ$ÈOèÍÞd Y.ñWXÆ•,UdKÃSLü¹M/¤–b@bv \©ÃÕɘžH¦{«ñ¶7ø"Œ '’f¸:@Ú;eO¨€¡K 1‹\ûC˜ÊÛÞ³´/ »…P´†Aͼxi¨'d´ˆ¿HÔÞhy®‡LæB+û³Ššåcµ¹{¬ZÏ …+pìDLLó»ƒÂl '—W0™$D~jIt,8ò † JìôŽ´yIú¶WÍbÂÎúîÒöÖù’Þ´íЪJ ˆQFvV,•×âJŠÜ¹ëLtVéuoÕ埱G‘žâP¶Öά® •ˆ! ñ@Íè;] 5'`Pê \ÙŒO²ÛÜ¥´ëqÄrÉ•CE2JPÊH%5ñ Ó^Ÿ¼¼ö‰²ÙNw¯k-œã¢6¾Í œK²î{„ª D8.€õØ›¨ìàöÞQÎ}!o“J<É7g‰ ~hï¦þŸ
àøÞšõ´©!·Æäfq{%„1ˆÑ
Ìñ´Ö2³ò$.¼\±[`$[GmgA/1Ö—oc([LZÃoÛNeF®
°Ü‚ykJ»÷ m7U¾h.9Œ·\Èóã’[•xÕDS1Ò&£_ ¹ ¤‚½ •×¶ÙÇ9‚{vm††tâèÀAúˆ>A*~ A9 ‘¦·ŠW…àw@Í…K!#æž$‡‚GÔMN9%+ŒN¶†lŵÃ-Õ¦b.ò/$гĎd+Èë‹Ièðãc’
®ê/UÀ‹*Þ㯬®b–Ö6¶›´ÏÆâ^Ìo´v^%ùoÕÈp><Æ ô®S5Õ-k“²‚Ω;Y`¹†(•ÚrlžuTú‡&‹ÔJ£²I:²’³»yžß¸ÜÅärF E%´°#Çd”&Uô’Ärði…‚—W~eçgÜ
ªýq¹œÐÈô§RÚÍauay2Y ÞäÆ[¶é G7uÑ(ã[ߤì A=•uèªÉ–Ÿã^/ÐR¸û§ËÜu•Ý„½;•ŠÕm-#½§ä É8iX¬Ä•!ÀäGlúFÇ(ö}–¹éëüºÙóÜ“å!/Œ¸‚;gDVHZG¤áâ2u¦ zŒH¥pù.¤êL_½ûñâ›ÝXõËOÁd<£=Ý[.ÈÛ~E¿.t<Èüu±qÔ™ˆ3#Û±÷eŽVÓ Ç‹™¦ï¸Þ÷Å84ü·¦æ=:Mr`;
W…¿Ép‡‹–ÒÞ{›ÜÍÓ\]@Ó¨X¯Êð®‡dÌ.^8‘£½Œ’õ½áÆc‚938¨.qѱ.#¸’Hã+3ln0×6þToBCñâ Å+‹ºêÜ‚ueÆ>ÖÖI`µ½·³’ÆÜJd,LÒûJþJ ‚m”`IŸ#˜ÓÕ¹ R‹Uµ‘ìÞöæÍ‘q·
-Ä&EîµÑü“†h€à ÊÉCÈÒ•æþÁgÿ à³å‡²Aò“Üžò÷§l{G´v;œ¹üxïÇ™ÃÑ® šÓê 49,Wô•}™¶ÆßÏd“%Œ²Y-²‹(äP®ÌÄ \ / _6ÿ ”T¥p÷˜tõ–Ó¥ìñXÎæ>ýÜû6£OÊZm»qñæÇŠ¯Î_{ÈcaždÈ-ÍÄÑ;ªµÂAÍ# I< Ž<‡©¸éùüŽc%œÀõ^BYã wÑ°^Ed‰…¥ŽàüþZ'ÒÀƒáðáêÕ)Pðù,”™›ì^Qm;ð[Ávj*,*öÏ#·*a>½/.Cкór€R” ¥()J&wûÓ§?h¿þ-Ås}MÓ òÜf/cÄ\_se“Þ¯j ÿ ‰Ñ9„-²úNÉÙÞÎúLï÷§N~Ñü[Šò>¢®ú‡%”“7wb.îdÆÇZI(ˆ¤†Ü‹òM&ÉHÓ‘Œù!8/’9úë ³¿È-ªÙßDu=”w3D9'ˆÉÉÏ#é‰Ø6¸èk}¨¶WJ©%*ùlËÇÅï},qhÑi©SѬ¬ÝÒì{Ýþw ÅÇ@¦£³ñXAc,žå¸²µ[,bÇs01èwdšYù¡%‰RJñ·uÒW×q]Ë.a$ÈJöb+‡´ô„µœÍ qÇ',Ì” ;U׉ºÆÚÖÞö{ÌnFÑ-즿ˆM¹‚ ²(rTŽIé#zÇ
¬su½¿´w±™X½ž!u?8ö-\6ÛÒ¾†ü™ü·¤þOÁ®+ÍfKž˜™ï.oíoÒ+ÆÉ ¹–$q·²±WPÊ\q |2è‘ñ ƒC§ñsañ>Ëqr—3µÄ÷K F%-,Ï)K1 ×Äü+^ã©íòhm.ž®"µžñBv¡žN #`[™'»•R£˜ÙmW’FG‰V;ñfRºŒq'“lƒ€6øÇg –T×ý2Éé;úwÀ‘ñõP¶¯¹¥ó»if§ßg1XÙÖÞó!oË/$·2,€’Ç©‰ € $ŸÍk|›‚9üŽ@üšàÆŒ¿ô4QpÇÇ|”ì ¿c±ÅÀÐcìí"fæc·‰cRÚz yÐ ö ´÷Ÿ;
”=ïù >^ï_?ú·³qú¿æ |·çæïZó¿úMqú£ Çÿ º^sþ ÷Ûßѯ6iA/µzûy¾Ow¿ç³{½|Ïë>ÍÇëÿ —òß½kƶw³cƒÅcgk‹<}¼W,¼^àF ²A<ä>¦$€I$’|Ÿ5B”!Ô›V¾Á\^7¦ñ=EÑ 8™;f”Ãaã™âuÜk° m
èè xí+ž´é{‹ (,íº“.AÅpµ,Ú‡“h#3õ.Q%* ª-«*¶¼€M¸ØßÓ¡ÿ °®mE\Î\R¾%çЙ/CÛÔ¾‚tŽòÚÊÒÖÆãÙ=¹ämú8€’èœPTŒ}G‹{L.}íÄ÷7ùK¤¹°HmÙ»WI BDl@ŒYôƒzo Ö±¾9uÇÃÔyy #\1KU#r ¯Èz‹27àbHô†Ý÷÷Ú|¿î횊™ á¾KÏ¡ómÓööY TÖÙ¶Æãå°†ßE½ a+ê'~‘ w¾_ aü…š<;mú|8òe¦›íETvR^} Ðô,Ín˜ûÜ¢K‹ƒ> Þ8mLs,2ˆ—“È]•œ,CÈE’uôVä/yz·— ”dgö^ܶö†8SÙ¥3E¸ÚF-ëcËÖ6º‰õ^â¾ûO—ýݯàSÜWßiòÿ »µü
¶¢¦hŒ1â^}¿%2ýÏm÷ͼýëï 统³ÿ )ìÜ;}î_7Õ¾ ¢²7DC=¯³ÜÞ»$¶Y k“a µä©,Œ›'ˆ ÅO/llÖ÷÷Ú|¿îížâ¾ûO—ýݯàSQS40ljyô9ËŽšNŸè¾§q *9.1ò†\f5lãÒÆú$rffõ %µ 4ä[¨›©1¶sÉFWÇ”b½ËÄ1DÞ|q”þM‰ ¡¹k{ ‚¥ßKÜ_ÙOgsÔ™w‚xÚ)…¨ä¬4FÄ; Ñ]
mJñ' û÷~³F1+p÷ bwEG(äʤ•üH˜ôr?]GNÁ¥½Ý¿²HÐ][½«F÷²Ç 4qÄB„hqˆô¯ý+¯¿“ø=XÎö%ÇÃØ ¶€ý$Å£?µ#GÕñð5.פQer÷°Ç$·7±ÜCÂG ªA
(•|+•xÝ—n$ò]koå5” 20Ýãho eŠ?«”˸¼øׯâ@øøªÐÍÄω,R(t‘2²‘°A E
ÊŽôJŸ¥ñ3À‘vg‡„³L²[]Ë¥s$ƒ¸Œ‹9äW|vǤk Î irØD·‚ÒÛŠswéô"øoãæ¨R€×{y20ß´{º†)!ù J9BÃ_&4ÿ ·ùš–ý!ƒ{{Kd‘`µ·KU.%U’X候 Øã'!êoú›w)@O“ Ž—ÚyÛïÚnâ½—ÖÞ©¢íðovcð< >AÙÞ;žžÆ]‹žä+ÜÜ §–)äŽA(bŽ¬
x‘±°~qÝJPí0˜ëme··á%¬R×bxÈÊò$ú™™‹6ØìéŽÁ»Û¤‚Æ.%ãñkU*ËD€Ì|áÈùóW)@k¥¼y¯Ö=]MpÈü©¹Q¯‡ƒ#ÿ ßü…lR””¥ ¥)@)JP3¿Þ9ûEÿ ñn*VSú;é̬÷WouoqsÉšK[Ù¢
çâá¸rߨú|“½ÓêU·‘lU®o¢½Žc5ªXF²JíÁøee ©4Y´ ²í†ë ¦0öÈ×E‘†àï’Bm¤QçƘÛ)>5ôÿ ÍaRœÜÔ ìtaNmÛÿ YÉâz#uz–ÝHö’b1åV {eâ—ìº*ò'ÁQ|ßX}!Aê-úg±îïë|½‹+u‘þÏ\ûÞÑèøø×´||ï‡ÀoÆ׸¯¾Óåÿ wkø÷÷Ú|¿îí¯¥OIÒd¥RKgÏ>Ó›GÑ4} 8(Ú*íì¿oèå“ú3D÷K¼UÖ1¥KY$ðÔÓ?.SKé%˜€‡—+ù~™÷¯¿ÿ ö½íŠ\wö|»\{þ¿ˆåý¿ÃÇÍøùñµî+ï´ùÝÚþ=Å}öŸ/û»_À®wB£íFøcļún:"Ún«|Ð\sn"¹‘çÇ$·*ñª*ˆ¦c¤MF¾8 rIzyÅâ1HŠ÷(d,YxŸ
v8ž\NÎü5çbw¸¯¾Óåÿ wkø¥ˆ±¾Êá,2?(òñ{]¼söøZ·J[ì
뇣Ô{Ú'µñ/>…,•åäP5…÷²\ÛËÝFt2Dþ–R² e.ºb@ä4ʧδb]t®Fþ+»‹¬µ©ÊNöe&ŠÅ–[iÌÈ fRÄ–gó Ð$Ö÷÷Ú|¿îížâ¾ûO—ýݯàQhõj# x—ŸCVã¦{þñþ·ÇÛr¶¹ ì÷óìþû?Çƹü¼úg±îïë|½‹+u‘þÏ\ûÞÑèøø×´||ï‡ÀoÆ׸¯¾Óåÿ wkø÷÷Ú|¿îíŸOS40ljyô9n”°¼‹¨q«»ãeŠÅMXîlM¿`sƒ¶¥ŽÄòò’61úAyÝWKsÍûBûÿ *Zü÷÷Ú|¿îí·±XÔÄØ Džiÿ )$,Üy3;³±<@ ? +jTåÛ ÒwÚ³ï7iJVæ"”¥ ¥)@*7H~e`g[ÿ
jÍFé̬ìëá
ã~+Ô³JR†b”¥ ¥)@)JP
R””¥ ¥)@)JP
R”koÏ\§ìë?â\ÕšçÚòÚë2÷7—0Û[¦:Ë”³8E]ËrÉð<+?Êk)üc¡»É±þÌÙÀÍŸ_›Qxó¿_ÄññCyÂRwK±f•Úú‚çÌ«KXßÀk˲eèäÑƬ¯ˆO#^TŸtå.¼ßç¦ úZ+Ý ~KsärW_ÖˆÙÕÛ{_ßáZi¢·‚Iç‘"Š5.ò;UP6I'à ©?*ðÿ +{íúùÞî‰îø}\»A¸ïηèëàkî ™ÃEFΔYk5õôV+º¼’;pŠÀ/+HU^t Ù $ H˱–Ù%¸¼d’þá‹M"’B®ÉHÔzP gl@,Ô Ž_=ŒÖ61X@ÈŒòHíÎY¤ ¼®@˜yÐ@ Vú[h;J’d§V±8%yóß_ÔXÿ ˜lÊ
ç&kü&C#•¹¶Kø&Q¹`‘!{x“‘Te‘‚]»9ì—× hL)]ïþŒÕŒV(‘ä‘òv/,Ò^W7P‚ÌF¼è Ñ×-šÍØdl"·‚gK‘bæÞâ'‚^ ×çÛp®Î¹k[ñ½ŠêhME%‹}ß¡©)icjžfŸ#kÛ_ú»r¬Ïçà5 Nùhy . °áq$¢^Žÿ j'”/.ÅÚȾÍ7
Ž^®*ÛÞøÄ”19©¢¼*I"D¶Í>BY$`¨±GDÛ?AÜè|øÐo> ?õWO^÷¬ã¸÷šÿ ,–V²^'ØÓ˜Õ”oMàý4†4¢â®·ùû/ÙOïLE鋲óFHylÄÿ Œø U¶§À ƒàVíqý×øùî±YKkˆV{›Oh‘ ž5*¾ ×ör;9<Î@ðIì(eZ
in#Yÿ À;Ù»}0ÙÌø_BÂçþÁ éðêÑ’Í|M WIñ¤±H¥ 7PÊÊFˆ üA3 4¸ù×}#¹fc¸v'¼›,#$ùî"øòIu^{'˜Qýííù´JR†b”¥ ¥+›¼9 §U]âàËÝã`³²·¸
i ,Ò´¯2ÝØÜhW\@ùͽøÐ %I›¦ñ¯<—Ñ=…ÔŒ]ç±s ;“¾NÓ!gNy><ýtÖJlÏJâ2— Ï{e
Ä‹!C: l“Ÿ¬ÔûÅê¿–6¾Éqh0<52µ˜fÙÑùÝàI r
OS ´e(îfßc¨,¼Aui“àðy~¾M$jÊÚø #_yØõ>RÛ[ÿ zZÝ⾞w‘ŽÐ Ai´k³à`w¯ FìÒ…±§÷.[=¼ˆfŠâç‚D–):HŒYHØ ˆ"¾êLÝ7y丶‰ì.¤bï=‹˜YÜòp¾™;:pÃÉñäïã±Ô^ º´ÉÇð x
¼¿_&’5em| ¯‚<ìzƒ _ÚùüèY¥FùKmoýékwŠúyÞF;@}¦BѮπ޼y Ñ\A ðH’Å"‡Iƒ+)ñP¬¡(ïGÝ)J¥()JJR€R” ¥i_å-±Ý´•ùÜͱoj„g#[¤ëcgÀQåˆ š“nÈݨÞòŸ3èÂË ³>™2Já€úÄ#Ed#àXž*HùåYÝ×9^\öí”ÇÆÄxú§emIãâƒÑê`{šV«4/þaÞü½ÿ ž&•†.Û Üx“ÌÚ7N–r7¢ì Þ¶t< ÚŸïÜ?¾=Ñï[ yþ…í Þù¼¾fù|ß?‡š¡B¶îÅ+ž¸{u–3:"»ÆrUbB’> ¬úxŸª²PJR€TnüÊÀþηþÕšÒ ™X ÙÖÿ ÃZ/ÆüW©ñ˜É{æL^# iu<ñÜN×wn¡diñŽBÇq>ö½:ÞΨbrPæpÖ9Ku‘`½·Žâ5 Á]C tHÞÖj=àÈbúªï)"ï%啽¸[I!V‰¢y˜–îȃDLºâOÍmëÆö0×x.•Çâæµ’â|v2Ë@ÉÆy8”‘S½ òÁG|üt35ï:®KN±µéñ…»”Nœ½©g€(Þµé2Ö„ÇÈ {/Å\+ÒR””¥ ¥)@)JP
R”£t‡æVöu¿ðÖ¬ÔnüÊÀþηþÐÑ~7â½K4¥(f)JP
R””¥ ¥)@)JP
R””¥ ¥)@j¾6Æ\„y ,Þö%á ËD¦D_>k`y?÷?]mR”%¶÷œ½Õ Íu•õ…ÝÍòZÚcíf…-/f¶ÓÉ%ÀrLL¥¶"O½hë[;¡Òw×>ÁßÞIܺºÇÛÍ3ñ“´jXèx$ü)À›¼‰¿´Êßc.ž%†g´·u±@D±¸ K¿ÍÖù ïC[Ø”±Ç-…Ìö¶±Z%²'öp€€Ê]I-¢¿?ô ˆ%Þas“u®J íÜX¸ÓŒ–jñmèŸI„’7-Ëò¯Å“:JR€R” ¥()JJR€R” ¥O¾Éµ¼ëiij÷—¬¼»HÁV5$€ò1ù«±¯ ±ÓqVât%EÉÙ¯²Øè[–p¸"GHîÚ'JŠ 1Ð'À: Ÿ€5§
ÞBxîrœa$
7Áô´¬ Ã@€4ªÇüeUÆk c[Î×wwOyzËǺêcRA)š»òK /&n#T(^ê;#Ï ¬7wpXÛ=ÅÃð5³¢I$è ’I 6I
“Yª5Ÿü±’—û·Ó5œ'ÿ ‹ô¬Î?ìQ> ÞÄF7Ú÷¬-'’öLêvî$ŒE¹!½ž=“ù Øè¿ ” ® š)B%,Nâ£u/õ‹+|_ë;…µ}ü Z/*“ñ ¢Içl> f£Z]꜅Éò–¥”`ø*îYH×Ä6ãÏQ´Å…©ìx²ÛÓ̧qgmyÚö›hgìÈ%‹º¸8ø2ïàGÐGšÍJP¥Í[œmìöóÝÙ[Ï-³s‚IbVh›`íI “°> P —õ~¦ÁÝ|î÷~ÇÃ\ÐMËåìú×þ½ïÆšÕ?’Á½øðqòGzX|à‘°iŸ£'Ð" šRmÉGõÌuõKhs é|t‚Yÿ ÉÉ`Úò@M¿ñhÐèèf•§?©Ù6üI‹ãn›ø¼ü“ÿ ž×JN€æ’àPº Ïýþ–k
ݤÖÏopœã}ll‚;ä@ @#DVjP¢vÚ‰˜ë¹Òælmóò¹‹Õ ¬›˜t¿”Ðñ°Oé´¡ÔU:Õ¾±ŠþGgŽDnqMâp ¤ïΉ ‚ H8lo¥iÚÆùR;ä^^€BN€ÜMïÆÈvJ’Ø*Ì.Ö/ôŠ¥(f* þ %ï™2˜Œ¥¬óÛÇo:Ýٵ•¤d+ÆHÊÊûÙ;ôëZ;¹J^?6#
.Âæ1¥”v¶ Ѩ¿†÷ìrV9H|}í½ÜJÜ –ò¬Š@ë`Ÿ:#þô!Ó’WkaµJR…+Vû!mŽe¹g›‚$q´Ží¢t¨ ³ | øZ Ás™õeâìZ™c äó霮ƒxô˜Ç$ùÛ/µâ.¡²ïb öŸ+èÀöd„ÿ üJ@$·øª`Ò €ðBW«’”;–È1ýÇWšk‰uݸžBï&·ôül±
(,tëv”{- ˆR”¡CÏÿ þHÿ û¯ÿ ûUè?ÜX|{ßÝV>óý7ÙÓ½óxüýrù¾>?°¶iÛãiö¥yãÔ`p‘ùrqõ1æû?ɾ³@sø›{/é¨
¼|Z|}”Ò±bÌîe»òIòt Qõ*ª ê+‚¸{…Š1;¢£ÈreRJ‚~$Ì@ú9 ®²P
R”£t‡æVöu¿ð֬ןdo3?ÐÄâbƒÑÓÅä®Þ Õ¸!£
ɇ“ä¯<ùØ/ÆüW©è5Ž ặŠâÞXæ‚T ‘°eu#`‚<G×/=çQÝfqø¹^Ó<¶÷7a$öµ~Ó@¨¯Î4< ™¹*…oJé×f¸û,îvÓ¥qb’ì¦;¥ìo…Rì’
\´ì‹ò#Ìd ìüÝ Ï\¥pw9Üœ}A™dËÆbÇf,,Ó "û+‘l¬Ò ŸÉ!Mqõ+l¸ôª.¥¼^·ÇÚ-ÝÜö™ Û«UGo ¿RRÝ¥
íÑãTf}¡%ˆ 2hò•æý/ïl†s£²ù<Ü÷3ÞtýÅÌ‘$GåìžòóÈ1<¼²úx©)Y0I”·é¸®zŠ@ùœ9È\Kœ!¡( Їj@-ÞÛ—ÀG± =•å÷=_ÔwØëkÛ(§Y#éû\³‹Sk ·vQ)"á®0„v‡öd0öÛã«YlÌ9ŒµÐÉS²ÍÙXEeØN,“ª¿7×#®û2è®›|‹®”ÜR¼ï2¶ #Ù³É]Ï<ùÛôb¦ÙnEÅÆÄÕb.Y9°aóL¼u¥°éëƾÂC4—O"¼Èòı¸tvFW
JóR¥X¯¥ˆ%@RR”¥ ¨Ý!ù•ýoü5Ì¥ÿ »¬šT‹¿rûKkpÚ3Ë¢UÑÖôv~
c ¦"ÃÝXK ww»ì–ñÁÜãÇŸ ½lëzøPÓu7Þú›´¥(f)JP
R””¥ ¥)@)JP
R””¥ ¥)@iäòPâRâu‘‘î · '”²¬J|‘ã“‚Ë …G¼êÛL_U]âòGÙ[ÜÆ˳o2ÈïÇabQmÈ
¼½MäVN¥èì?S¬O{±’ê9`aq5¢Jý¸åY=Ÿï_ ÃÔØûkU’{™.]î."D³±šG=©Yòhô„g×H>9(¨pt]äñâ%¿x#¸ƒ!usrL]rÝ‹µTb€³ "I =Ϥ©'él‚㢎(-.'KÛé½9 ‹ =Ãʺž[Z*2ºbïÐ9rëªpÖ}ƒ%ç8æ‰gAÍDß6Y Xã:$;¤+ éN²MÔ8Ë| ÇI<‚~k8‚CnÚâ(^ç’éY<ÓCÔ»åó=É\,“ÜG‘{œd8ûÉd½¸²RPÉÊS ƒwXöÙ:
ê$l]tuÄÝYqÆ9m.¯m#s‰¢X€_fB#”î!Ù†‹
«€è!ê eÆP㣞C?6\Á ŠG]òD”¯qŶªÄŽ±émT®^Ï“µê†»ŒÁmbe’I s2Ü+†<
«~N&äÁÚTbÌÈN‡q€ê()JJR€R¾&š+x$žy(£Rï#°UUd’~
“Ú¹Îø»ƒÙñ'ÈÉîÝ J¤ ôðÙ,
ÇÔŒ-ßkÜ}Í}sžK%ÿ ŽÞÍh}X˜=3ø]K²"è]@l1J4¼§.¦¿Hr³ÜÏàE*ÎŒlÝOwòjÃÎÀGµ¹ž†óòŸ±šÊ·º°‰”ƒÑ<®Ï´îFÖ¶¿‘_ÈCäþOá¯H¥æ÷Y'^¯ËD™kïyE›²ŠÊǼÂ3Gkí á.‘¤f—liÀBÜ› V‘%¤9Œœ˜ì+ÞæšIÅóÙ©¸äD¦Ue;*Óœ´tNG Yca±ºÈÜDÒ¿¸†#A„QÅ¥ñðãŸ;òOþÃr€ó¹§ê7ÅôúÍ-Ú]çñ–öW…›´ö÷ —‘ãQ®Ü½—»ruÁÖÀVÇ‘Èdÿ ü Ol/`‚dÈZ¥œräæI Ô¬&^j…&RLãºß4ò$¨ˆÜ\bRï1ižæw[M´Þ‘JUËáyàìº-ÇG|w£T(7Âd2w sÚšö¸ ´¹·99¤˜Ú©”C»> ¸Bìr |“.›s¢¯Ì¹™›!%üþÎÍs4WòN¦@Ê7<(6R’X¬)ãĀɮ»ÊP
R””¥ ©÷Ø“T)BTœ]Ó#{§)kæÃ=1Ò±_À·‹ô W„„“;xÞöNÃÚúÿ !î«Hfo>ÑífX~ *ìàùáÅTþ >*Í(_Y}é?Þ¤û E½œítî÷wì¼ öáTÊScѵ *ø • oζI4)Jrrwg'eÖö×Uq‹¹%€[Û4,Ø‹´nä*·>QéSHšf |ï'GR׬®#g›»²žßò~÷)C8“¿6Îœñã2©m¯• ô ¶ÚîÆÞ<Œ×ë ®¦Š8d~GÔˆ\¨×ÃÁ‘ÿ ïþB¹û~…°ò3Þß]Ø.>ld634b8m¤à‘Câ4PY˜è|vwB öÿ Ò"Mc}$VÖ9 «IlÐLjÉ-Ìn.fì¨2 •
qõzõ]ž&þk›;{» µµº3äDv‘$ gd
Ĭˆ¿Ùï›k\}u5Ów8'´9 –Ny¯l™äšt…’îcváÚª¡Û’€çÀÙÒ¹òNe×¼o½áí~Ûï/Éw»Ý®Ï.<;_Ù~O\5¯:åê 'ÚõÆUqI‡ÅÁy5üWoÜ7Á`Co*D縖‹ ,ªIôí@bW_ Õ9ÛŒ KDq^år¸¦½’V»D¼;>§"=ŽBPtªx¶—Evâæ'¥lpÓZKm5Û›T»DïËÜ$\L³?&>¦! IÞ·½Ÿ4Ãô½¶1+ ÝÝÁÅÙIcNSf'hΛŠ€JˆP5ã{Ù; %Ûõâ6;Þ—x¹íì&ÅM—´ü¢¼ÒABüÐzQu
€í°O.jµíÿ ¤DšÆúH¬rV’Ù¡’[˜Ü\ÍÙP$e@$1*@ãêõ 6£±c ca/~k[LT˜€ŽúîA ˆ7" Z…||Oùk é¡-«C–É_¹¸·œK;F¥{2¬¨¡Q ä¾O D áx ~¥ÍK˜ÃÙEgi‹˜k ’ ¢èG²4ê#cØqem‡’qò¬Xv•n—¶—"/ÒîîÆMr[B„âܦ™O Æ<ý;$‚Ð^;«½À…{ŒÊ…–ÖÉ
Ì ýˆøÜ¥¦¸œj½“®>Ð=‚³a
îÝJ…"? €T¡¯U’ ;gìZA³D`ƒ„a{Qž;E×Í_Bø =#ê±J|¸,<ÞÃÝÅXÉîý{+t>Ík·ãÑ®+ð×Í Ul5…›÷9Z@ÝÙRy7<äN<\ýl8&Äq_¨VÅ( ï‚ÃÉgug&*Åínå3ÜÂÖèRi »®´Í°ÏŸ· ‚[xíâŽ"@‘Ç…TP4 À xÕd¥ ¯‰¦ŠÞ 'žDŠ(Ô»ÈìU@Ù$Ÿ€¾ê4ŸñÌ‹AñÆÙȎοü{„}ðßÕ*“¯‹zv8:‘hÆû÷ xØe½»÷ÅÜoœd†ÖR¦8KÉóÉø#Àq . Zµ)A)bb”¥
ŠR””¥ ¥)@)JP
R””¥ ¥)@)JP
R””¥ ¥)@)JP
R””¥ +ü¥¶;¶’¿;™¶-íPƒ,äka‘½llø
<± Xnòn×/Ç'vôh;´la·ØÞ݆ D`ò<—æ©.3Xc’ǹ#O5ÕÔºîÜÏÇ›¾#Ò€6t dŸ‹FŠ)m—#Z T·sÇwšö{™b`öð"³oa‡/Ÿ >;„Ò©¶åZ”¡YIËx¥+K#ì1±ÅÞº¹“³o.!ß‹7–Ñâ«1>N”è D$Û²>/¯¥YÖÆÅRKç^^°J@„‘Ü}kÆÁv @Ð Ë› c7 œ,î±.Œ’^Fø³± c¶'é$Ÿ¦¾,,=“¹4Ò÷ïgÑžr¼ykzU
»…–R5ñM¸óämñk53§'³ÁÛ%Òvîååqs Á 4¬d‘F¾€ÎÀy> ò~5N…ê?õe¹lùã¼R”¡˜¥)@Foêýk>ÛŽ~æþŽÄ‹Ã_ûûCïãð]kÎìÔn¡üº¯¾>Ë‘‡Ñÿ Wwvÿ £]î_çÇ^7±f†“Û¿›=¬F²ÿ ‡õ%å€ôÛÝÇí¶ëÿ ¬ 3…˜ŸÏ’Ò¹Ùó«5©¿«c£Ë'!½+ÿ Reké=·“9qÙÖêÍö¥/›>!JR†b¦dí'Y#MÞÅÅ]Ú!
¶Œï@ $1ø…g(Z2Âîa´»‚úÙ.-ßœo½ AD|‚ ƒ¢ èŠÍRr0ËŽyòÖ1¼ŒÕ¤jI¹U ÿ Š Ðÿ ¨ §ü,”áš+ˆ#ž X¤Pé"0ee#`‚> Š(öÇÝ)J¥()JJR€R” ¥()JJR€R” ¥()JJR€R” ¥(Fé̬ìëáY¨Ý!ù•ýoü5¡¢üoÅz–iJPÌR” ¥()JJV–Rÿ ÝÖM*Eß¹}¥µ¸måÑ*€èëz;? ±ÐД›vF Üïs6ÅøÜËêšU´:oÊhøÙ#Šƒô’Ú`Œ+vÎÒ (,í“·ooÅlž*£@lù>ÓX1Ö Ã Í$½ë«™;×ñâ øªø]ž *ªäéFÉ;'v…¤×Ú·
R”()JP
R””¥ ¥)@)JP
R””¥ ¥)@)JP
R””¥ ¥)@)JP
R°ÝÝÁcl÷Â4ÖΉ$“ I$€ Ù$€6M Jûš£{]ÞoÓŽy¬ì~>ðP„Ì>ŽÈnC[ø».ˆ×Áƒ«Ø.s>¬¼]‹Aó,cœž`ý3•Ðo “äŸ;eö¼lоÈw¿/s
¥¤6Éonœ#Mèl’I;$“ä’I$’I'dÖjR…¾Ö)Jøšhà’yäH¢K¼ŽÁUT
’Iø (Añww³Ü\?Ó[:$’N€ y$’ d’ Ù5¥‹´¸ä²)Ç#4`¶µS¢bR< roñ€WâÎrz\Æé(Vò© Ÿ84¬¿áf ©T š]ÔV¡£ÿ +
ßóg_—R”¡˜¥)@*7PZö Hóí· ÞÎ ò’r_¥ŠÄwãòÃ{Þšiýwªr'ÊXF–Qƒà«¸Ye#_TÛ>AFÐ SØܲø¼Ë4¥(f)JP
R”ü匹,õ»"\Ë $r@Ž]m cÈ*ÜXäò+66ú,¦.Ó!ºÅu
NÀ ”0Þ·çF¶ª7LþC.8ú[ q%¨ãÛˆ P®þŸÈ´^|Ÿ>|m7Üÿ ¿f£tïõKi°ïé|t†(×ÿ ÉÉ&»ò@M'#ñhÜlè“f£_ÿ Ãú‚Ç ¾#¼ÕÉ> ùÏ ~nHŽFq䢂SÍŸf”¥ Å)JRf†\Dò]ÚFòÙHÅîmcRÌŒṈñ$ùd ;Ë/¯bJÔ¡hÊÇÄ3EqsÁ"KŠ $F ¬¤lGÄ_uÿ ôzId>q2ÈòÈßM£»f'錱$ŸŠOÌþÎÍ£m«p¥)B¢”¥ ¥)@)JP
R””¥ ¥)@)JP
R””¥ ¥)@)JP
R”£t‡æVöu¿ðÖ¬ÔnüÊÀþηþÐÑ~7â½K4¥(f)JP
R””¥ñ4Ñ[Á$óÈ‘E—y ‚ª¨$“ð TÌd2ßOjò7†W„¥µ»©V·‰Ê±>™ªúˆQðf？ÕaŽ¸ÿ Ü\ΣþÅ·þýÄÿ oÕf†ü+v¿Ÿ9f)JPÌR” ¥()JJR€R” ¥()JJR€R” ¥()JJR€R” ¥I›'-ôòYáe·ybb·.¦HØ (B°å&ÿ Ââ<± •qhÅÈÍ}•ŠÚu²ƒ…ÆJEå pŽÈæÿ ‚Û_äbüZbùܦG$Í‘]öÈ –Ô¢‘6< ShútªìØØÅa"3É#·9f‚ò¹ b5ç@
ªrKdE)JŠR”£'ü~æÞáºíäÄ~>Öà -¯‡mIä§â̆•T¿ÝÔÒä²âíäx`…TÝÜFÄ7«dDŒ>khÇÃ*²ñòá–œ0ÅopAEj#E
ª h ÀCO±_´ÖÉI’ŠÝ[iis?0.®Z £ä2Æäëƾ“çÇž
”ê›®–訥¹‚ɲ=ˆšõ&7sO²šFfF¡$Ú#· ¾<€!½"±É3 ³ hk~ øV–VZ뇶Š8Ò{³{2Æ¡HHœJÎ>™ÌA¾$÷ýl.ÐÑì‚Yíùæ)JPÌR” ¥(F²þ«Õ9[o‚]Ç
êø»èÅ _¬*Ç ?H2y> *ÍFÊ~C¨°W+åå’k&áÁâ2’?Ï•º«E¼|SÛušþmô,Ö–^ÃÞ˜‹«!/e挬sqÙ‰þ+ ò<«i‡AÈÚP¢m;£Kï
Q ¡¤ÊÄÿ _>M¨aŠÞà‚4Š(Ô"FŠU@Ð €¾éJŠR””¥ ¥)@)JP
R””¥ ¥)@)JP
R””¥ ¥)@)JP
R”¾&š+x$žy(£Rï#°UUd’~
Á}}„
î¯$ŽÜ"†0 ÊäA×vH I 4áÇËž;좺”`ðYwtv € 2I°ª8ùØ]Geå¸øåsó—váàžÙ†{ƒô0å|Fô®O•* /Zb·‚8 "Š5‘¢…UP4 à ¯ºP‰JûáJR…E)JS27s½Ì8Ûãs/ªiT6Ðé¿)£ãdŽ*ÒKi‚0¬×÷þÉÛ†»÷³ìA n<µ³ (»m l RÅØ{ºÉby{÷/§¹¸+£<ºœoCCà
EaXŸëçÏéžÒÒ d··N¦ô6I$’IòI$’NÉ$“²kÎXYåúËŽÉZA{bq÷³›k˜Ä‘™KeWâÛ €w ü@fúÍu?'…²ËöÒβE°“[\Éo"ƒ¯8Ù[‰Ò’»Ñ*¤¡Fﵓú3ÓÓïñ 9 è"AðŽ4»•}
ªª ZýqkÞÇã®
Äê°el… Š;È -¯-¡Ë@ž>HR·,ñv˜ô-RHÒuUî¹
̓3>ÏË
—m¶Ë ú›iqv“ØAe2I,<.É]›”N®„±<˜†E;$ï^w³B
ÊR””\•ôX¼]ÞBuvŠÖ Xª©cëÎ… I·dhc¿®õO |ÇÎ Ÿ\¬§èÛ0Fé€lìilÔü Œ¸ì5µµÃ#]/rèO™Éi|<f:ÐÖüðª-Q§-›…)J¥()JQº¯ÑÓ7w_ bá}Çþ¾Ã¬ÜwôráùÖ÷£ð«5ñ41\A$Æ’Å"”xÝC+) ƒñP´%†JY t©=34²ôåš\HòÜÛ©µžGbÆIbc¶Ï’ #O’ÞŠA(á“ŽDž¡†SŽöÞ7’æÂdºcRÎʾ$U_ñ3DÒ(éað:"œ3EqsÁ"KŠ $F ¬¤lGÄ_u§¿ªGu†>6A ø&ܨhˆ (&.[<ŒLw½€-÷CÃùÿ ¿Óöûª18ëÉ-®&œ4ZïË ¤²CÀ?••T¤zRóa¥!Ž¬W›õ
ý®7úAÅ\]ÁK'Üö 9$ 5ß+c^Ò /·VAÄ ²‘ñè
fÎWp/jT‚MÈ ?S i¡ñ<—ë3'Ûõ_OÝg$Â[æ¬eÉÇáRu/±Ëjü°àÛQåu²ÆìVœx»H²“d‘$s' Êä2hq'ZØðYÈÑwå¹@)JPní ¾¶{{„çëcdAØ ‚h‚"´.çµ¹LvEùÈûök . àH $ À] Ê”ëVúÆ+ø ž9¹Å4d‰À 2“¿:$h‚$A ‹Å¯µî6©Sìo¥iÚÆùR;ä^^€BN€ÜMïÆÈvJ’Ø*ÍB…ZiÙŠR” R” ¥()JJR€R” ¥()JJR€çúbû)wsž‹-$
5®Ab _DHm “€'ËèÈÞ¢þ:Q¥'3-¼o rN˜ÒG(¬Úð HútuõŸmŠšÊ\Üö÷1÷ò7â3$E–EÆâåñ_Ž¼|j€{C³I€¢„@„0mžD¶ôA t45£äïÀúJòúûÒä®#¸»KÛÈ Hâí©ÜËévt8¨ I><’|›•?
Œ÷EŒ–Ýîï;»›ž\xë½3ËÇ[?zßÓøøU
QºCó+û:ßøkVj7H~e`g[ÿ
hh¿ñ^¥šR”3¥(a¼»‚ÂÊ{Ë—íÛÛÆÒÊú'Š¨Ù: OôVj üs"³üq¶r:*7ÿ á \õõFÊÀoâÞÄ^1¾×¸ÍŽ´îfÉ_'™}0ÄÄ1¶‡Kù=$rb>’lMS¥(D¥‰ÜR”¡QJR€R” ¥()JJR€R” ¥()JJR€R” #å²×–¹Ln6Ê «ë˜¥¸æäÁÇ[Ô¨ç–åM:×/#@ Œ.OÞøÁtaìȲËo,a¹’)7âÚ^HÚ$F‰ øó1^Ûu73kŽŸ! —6¯³Æ²+ÂÁ¿(è¼GeõolºlŒ5mwÇ-½Õ¬ˆ÷—Œy!÷nUô~4xò]£z¾i`2góÞã[-YOr×Wp[’ƒIÉ*D]˜øðd](Û7Ð4–ÅCÏ[]å°V‹
¬‰9½°¸x$d
¥ÌR8$»UVø½xߊ¹@*}öFX§[;êù—Ÿmä1¤i³êw¸‚A h– èiX®·¼§Ìú0²ÂlϦL’¸`>±ÑYø'Š’>yVA¿cŽ´ÆÀÐÙÛ¤JÍÍÈòÒ9 v>YŽ†Ø’OÒhi…Cîß—S
Ž-m§kˉžæý׋ÌäñPH%cBH|/äñRňÝP¥(QÉÉÝŠR” R” «}}„
î¯$ŽÜ"†0 ÊäA×vH I 3Í4VðI<ò$QF¥ÞG`ªªÉ$ü 3 ¹ƒ-}ÆÅyÚÚH¤eañ`ø¤ úA*?ÄÎ/¾ç¸ÍŒ±–Ýî.îÙöíƒKÀ’±¨XП%WÉó³;iyhP¥(VMÉÝŠR” R” ¥(FÍÿ [½Åb×Ïzà]K¯b€‡äÃû^‘äç_X³Q±ß×zƒ'>cƒŒçO®VSôm˜#ôÀ6v4£J{/,‹4¥(f)JP
R””¥ ¥)@FÂÿ UÉæ1ÇÒ©p. 㨦 ‹oüæ ‘þCY¨Òÿ Të$ø%ý“Dìßp·(ÕOÖVY‰ Iìk‰ÝšTÚÓÍ|ó'ýC7Ê|!“úμhËÚcô¶¤ô¯ ö; Ù\ŒY,|ös3¢ÊºF@xÛ⮤üN˜ €~Š”¶î6©SðwÒäpÖ×7
‹tT¥Ê wÐ¥jØßE:+Ç"7 a ñ8 •`7çD ‚AH ™=wÿ ÕçRþʺþP«M;2†3;‡Í÷}Ó•±¿ìë¹ì— /
ï[âN·£ñúP®~óÿ ¬<7ì«ÿ âÚUÉá[›y`s I£äd`׆R
ŸóôP ðÜ¡x%ŽTÈY0 ¬U‡¤0 ‚+%s}
6½7%½¼QÃY<‚G jQEäÀ € ñªé()JJR€R” ¥(oªú®>œŠX.äžK‹e%1óÍ nIÒ7õ¢•çĶ—{'ƒ°õ=Íåéƒ
‰’èCn—7 vÏg/yDqÈ›g&<9Œ|ÏV˜‘röÆß!Ãu r5–9€äFž7Yøú™Tÿ ž¼ø©ùŸK쉽!}e$±,"ÑÕ}¢%,UK,šîIꌣzÏ…Ðw]Q5¾Râ5°ñö—¶øû™ÍÁ‰¦ípá ?/Éu#×¥: ´Ó¬²2Ê‚,(î28ËV7Š ³ÄÒŽl8úaã ’Û. FÃLÕ.:^Úç(÷fîí šâ+¹ì”§jiãáÛ‘‰RàŽÔ^‚ž`í¹d‡¦ìàö.2N}!ql<É7{>>hﾇÇÂù>vµêëë¹±ö˜ü4s^]%àKyÛŠµ™!“oÀ±BÌÜX.ϧj%5òßÒ¶3
̘#ÇÝÙ-ðöëô·žD*¤1黲…#jJ² ÇgŽKŽ‘•søç±¼¾µ‚²2µÜ2§8游Š^>[Èñ|f:Vêܶ^\²ÆñGmsyYû’Žé]E¸òC ʆPh‚£t‡æVöu¿ðÖ¬ÔnüÊÀþηþÐÑ~7â½K4¥(f)JŸ•¾–ÚÅ’¤™)Õ…¬N ^@|÷×Â5$?æ Û2‚&)ÉÙo¦—!x¸Ë9 cFþ¿4lTÆ…I«„ŒJü<ªv¤¡4á†+x#‚Ò(£P‰(UU@ >
Ácc„ ˆÏ$ŽÜåšB Êä Yˆ× 4 6¨ZMn[…)J¥()JJR€R” ¥()JJR€R” ¥()JJW/žëpÙ¬e‡³_?zìÅpÉŒ¹”pìI í²!WnJ› ËC–ÀÑ ¢•ÉŽ²™¯îBâ$ÛkÛk9.¤”Ç!k„„ÇÆ^@†C‡ãÄy ŽÕQõuõÊj 4bIòsãl»÷œRg…§æìU¢q€ëÁ%‰]زµr8ûl®>{Åw¶xH©#!eúFÔƒ£ð>|ƒà×3aÔ™L—Uâ-㶂+ m/ÅÚöÂ{yã…ŠþOÔ¡¶íy,„¥@:xÏéCoutÂÒH"ÆK•D±½[‰Ò–Y“J"—Nº^L6 r vD¦Óº:?’øÿ Ò2ÿ {Ýþ%>Kãÿ HËýïwø•"ën1K•LÆ. 9¬"´~à¾
›‰^$= ¬jTrfPG«JB‚Õ:_¨áê[+™¢6Œö·ÞW²º3pGÜriy2(;Q¦ <ëd_]S‰ó>þKãÿ HËýïwø”ù/ý#/÷½ßâUšPkªq>do’øÿ Ò2ÿ {Ýþ%>Kãÿ HËýïwø•f”êœO™ä¾?ôŒ¿Þ÷‰O’øÿ Ò2ÿ {Ýþ%Y¥º§æI‡¦ñÐÏ ¥¯¦1°uKœ„ó' v Gr¤ƒ¢6<òV¥(VR”¾çqJR…E)JJR€R” 5rWÑbñwy ÕÚ+X^wbª¥Ž·¯:‡c.;
mmpÈ×AKܺÅærZF ÙŽ´5¿ |+[3ýw#ŒÄI=¶Vÿ ÑnèÀ)úÌÄk? ê¬ÐÑì‚Yíùæ)JPÌR” ¥()JJR€Ô?‘÷U÷ÇÙr0ú?êîîßãôk½ËüøëÆö,Ôü팹NžÉãàdYn% ’3!Q½oÆÍfÆßE”ÅÚd WX®¡IÐ8‚²†ÖüèÐÑí‚y|êmR”¡™&ã¦ñדݖ¾Š[†/³ä'…Y‚…Š8âª> E||—Çþ‘—ûÞïñ*Í(i©»æFù/ý#/÷½ßâSä¾?ôŒ¿Þ÷‰ViA®©Äù‘¾Kãÿ HËýïwø”ù/ý#/÷½ßâUšPkªq>do’øÿ Ò2ÿ {Ýþ%>Kãÿ HËýïwø•f”êœO™ä¾?ôŒ¿Þ÷‰O’øÿ Ò2ÿ {Ýþ%Y{缎ÎF°‚ G<Æ$o#{`¬Gÿ „ý^>4êœO™©a€°ÆÞÉynnÚâHÄNóÞÍ6Ô@Ó¹ :ú¶~³TëÍís=X½-<Ì,m¤lÛ[Gtnžé”¶O´c1´i¸Â³(!Áâ« ¤úwG9cqzϘ’æ fbÏ ©-¼A®VàÛói™T
¨¸<;b=p ¹î…e''y;EŸM`qö÷VöXLm´iÂæ8mQeÑp˜iˆÑúÏ×TÃÜ,Q‰Ý @£“*’Tñ bÑÈýuÃÅÔ·‹ÖøûE»»žÓ!{uj¢Híã·ã
J[´¡½ ºª2ðTâïwËÜèiP~MXþ“—ûÞëñ)òjÇôœ¿Þ÷_‰Oª†L¦fù{—©P~MXþ“—ûÞëñ)òjÇôœ¿Þ÷_‰Oª†L`†o—¹z•äÕé9½î¿Ÿ&¬IËýïuø”ú¨dÆfù{—©\&Íû·^ä[Ž /ä¯æ‹nýîlÜ r'ŠìŸwäÕé9½î¿:ñ„°²ó¥K žßrõ*É« Òrÿ {Ý~%>MXþ“—ûÞëñ*¿U ™LÍò÷/R üš±ý'/÷½×âSäÕé9½î¿ŸU ˜Á ß/rõFËUÎaoÇ€d’ÊVoš‰*òA2E
øõëD‘¬_&¬IËýïuø•ñ/Jc'@“K”‘C+€ùk¢) §ÌŸ@#ê Sê¡“/N.÷|½Î†•äÕé9½î¿Ÿ&¬IËýïuø”ú¨dÊ`†o—¹z•äÕé9½î¿Ÿ&¬IËýïuø”ú¨dÆfù{—©P~MXþ“—ûÞëñ)òjÇôœ¿Þ÷_‰Oª†L`†o—¹z•äÕé9½î¿Ÿ&¬IËýïuø”ú¨dÆfù{—©Pzm »Q5ıA~©´Nó2©·…ˆäärf? ¦¯WD]ÕÊN8]…)J’¢”¥ ¥)@)JP
R””¥ ¥)@)JP
æîomñ½Kœ¿»“·mm‰¶šgâOWº,t< ~ÒW/ÇC˜Îõ2á`¼Ã[ÛÈÑ+µÒ’6ÞÕYWünæ´÷KÃÕ Y.c® •ò²Fã(’•„Áá<§l]p)¿G×=zûœëØp½Eˆê+s>&ú;¨Â£ 6ˆ_þL¬§Ê° ošþŽóVLs"î ´¨¥.!²³6×À[›nã; ñ o‰U÷鬇Vb//- Æã[qe‹‰“¶n„±IãiÀªkgŠ¹ UÖ‹F¦*Îi[bñÊÛöö~ßaÃR½hé¥
mÅݹv+_ÏIµÎâ/±ód-2¶7Prï\Ãp |G&äÀèhNþ‹Ä>><‚ålZÊ^}»‘p†7â›M½ r~ õ‰‘‚ÿ 7Žžápeq Å”¡g– h¸X.bž†e@„äãÔí°ƒÔu{ËZänñ¸dÏŒ‹[Ü4lð"X›‹2òâ[[Sàƒ¯7
;ª ¶:êâ+{|…¬ÓËn.£Ž9•™á'B@ÙBÅð¥–[ ’yÇ!ktñ¢;¬+•W^HN€Ëä ¤yÌcúvîÑñN,’7N¢¿È]2”Ç"ݬr6¨•’ô4´u¤19 ΓÁ´{xàé¹m£[’¯mw%ÂÀêÅWÕÄöÏp2ƒ·