/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES 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.
* <p>
* 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;
}
}
}