/* | |
* BaseKernelTest.java | |
* | |
* Created on October 9, 2006, 12:56 PM | |
* | |
* To change this template, choose Tools | Template Manager | |
* and open the template in the editor. | |
*/ | |
/* | |
* Licensed to the Apache Software Foundation (ASF) under one | |
* or more contributor license agreements. See the NOTICE file | |
* distributed with this work for additional information | |
* regarding copyright ownership. The ASF licenses this file | |
* to you under the Apache License, Version 2.0 (the | |
* "License"); you may not use this file except in compliance | |
* with the License. You may obtain a copy of the License at | |
* | |
* http://www.apache.org/licenses/LICENSE-2.0 | |
* | |
* Unless required by applicable law or agreed to in writing, | |
* software distributed under the License is distributed on an | |
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY | |
* KIND, either express or implied. See the License for the | |
* specific language governing permissions and limitations | |
* under the License. | |
*/ | |
package org.apache.openjpa.persistence.kernel; | |
import java.beans.BeanInfo; | |
import java.beans.Introspector; | |
import java.beans.PropertyDescriptor; | |
import java.lang.reflect.InvocationTargetException; | |
import java.lang.reflect.Method; | |
import java.math.BigDecimal; | |
import java.math.BigInteger; | |
import java.util.*; | |
import javax.management.IntrospectionException; | |
import org.apache.openjpa.kernel.Broker; | |
import org.apache.openjpa.kernel.OpenJPAStateManager; | |
import org.apache.openjpa.lib.conf.ConfigurationProvider; | |
import org.apache.openjpa.lib.conf.Configurations; | |
import org.apache.openjpa.persistence.OpenJPAPersistence; | |
import org.apache.openjpa.persistence.JPAFacadeHelper; | |
import org.apache.openjpa.persistence.kernel.common.apps.*; | |
import java.lang.annotation.Annotation; | |
import junit.framework.*; | |
import javax.persistence.EntityManager; | |
import javax.persistence.EntityManagerFactory; | |
import org.apache.openjpa.persistence.OpenJPAEntityManagerFactory; | |
import org.apache.openjpa.persistence.OpenJPAEntityManager; | |
public abstract class BaseKernelTest extends org.apache.openjpa.persistence.common.utils.AbstractTestCase | |
{ | |
private static Map _sysprops = new HashMap(); | |
/** Creates a new instance of BaseKernelTest */ | |
public BaseKernelTest() { | |
} | |
public BaseKernelTest(String name) { | |
super(name, "kernelcactusapp"); | |
} | |
protected OpenJPAEntityManager getPM() { | |
return currentEntityManager(); | |
} | |
protected OpenJPAEntityManager getPM(boolean optimistic,boolean retainValues) | |
{ | |
OpenJPAEntityManager em = currentEntityManager(); | |
em.setNontransactionalRead(true); | |
em.setRetainState(retainValues); | |
if(em.getTransaction().isActive()) | |
{ | |
em.getTransaction().commit(); | |
em.setOptimistic(optimistic); | |
} | |
return em; | |
} | |
protected Object persist(Object ob) { | |
//FIXME - this is just a workaround | |
// Broker broker = .getBrokerFactory().newBroker(); | |
Broker broker = JPAFacadeHelper.toBroker(currentEntityManager()); | |
broker.begin(); | |
broker.persist(ob, null); | |
Object id = broker.getObjectId(ob); | |
broker.commit(); | |
broker.close(); | |
return id; | |
} | |
protected Properties getProperties() { | |
return getProperties(null); | |
} | |
/** | |
* Return the runtime properties, optionally overriding or setting | |
* some via the given array, which should be in the form | |
* { key, val, key, val, ... }. | |
*/ | |
protected synchronized Properties getProperties(String[] props) { | |
Properties p = new Properties(System.getProperties()); | |
String str = p.getProperty("openjpa.properties", "kodo.properties"); | |
if (str != null && str.length() > 0) { | |
// cache system properties to reduce load on file system | |
Properties loaded = (Properties) _sysprops.get(str); | |
if (loaded == null) { | |
loaded = new Properties(); | |
ConfigurationProvider cp = (ConfigurationProvider) Configurations.getProperty(str, null); | |
if (cp != null) | |
loaded.putAll(cp.getProperties()); | |
_sysprops.put(str, loaded); | |
} | |
p.putAll(loaded); | |
} | |
for (int i = 0; props != null && i < props.length; i += 2) { | |
if (props[i + 1] != null) { | |
// remove any duplicate kodo/openjpa property so we don't clash | |
if (props[i].startsWith("openjpa.")) | |
p.remove("openjpa." + props[i].substring(5)); | |
else if (props[i].startsWith("openjpa.")) | |
p.remove("openjpa." + props[i].substring(8)); | |
p.setProperty(props[i], props[i + 1]); | |
} else { | |
p.remove(props[i]); | |
} | |
} | |
return p; | |
} | |
// | |
// | |
// /** | |
// * Assert that the given List contain the exact same | |
// * elements. This is different than the normal List contract, which | |
// * states that list1.equals(list2) if each element e1.equals(e2). | |
// * This method asserts that e1 == n2. | |
// */ | |
// public static void assertIdentical(List c1, List c2) { | |
// assertEquals(c1.size(), c2.size()); | |
// for (Iterator i1 = c1.iterator(), i2 = c2.iterator(); | |
// i1.hasNext() && i2.hasNext();) | |
// assertTrue(i1.next() == i2.next()); | |
// } | |
// | |
// /** | |
// * Assert that the collection parameter is already ordered | |
// * according to the specified comparator. | |
// */ | |
// public void assertOrdered(Collection c, Comparator comp) { | |
// List l1 = new LinkedList(c); | |
// List l2 = new LinkedList(c); | |
// assertEquals(l1, l2); | |
// Collections.sort(l2, comp); | |
// assertEquals(l1, l2); | |
// Collections.sort(l1, comp); | |
// assertEquals(l1, l2); | |
// } | |
// | |
// //////////////////// | |
// // Assertion Helpers | |
// //////////////////// | |
// | |
// public void assertNotEquals(Object a, Object b) { | |
// if (a == null && b != null) | |
// return; | |
// if (a != null && b == null) | |
// return; | |
// if (!(a.equals(b))) | |
// return; | |
// if (!(b.equals(a))) | |
// return; | |
// | |
// fail("expected !<" + a + ">.equals(<" + b + ">)"); | |
// } | |
// | |
// public void assertSize(int size, Object ob) { | |
// if (ob == null) { | |
// assertEquals(size, 0); | |
// return; | |
// } | |
// | |
// if (ob instanceof Collection) | |
// ob = ((Collection) ob).iterator(); | |
// if (ob instanceof Iterator) { | |
// Iterator i = (Iterator) ob; | |
// int count = 0; | |
// while (i.hasNext()) { | |
// count++; | |
// i.next(); | |
// } | |
// | |
// assertEquals(size, count); | |
// } else | |
// fail("assertSize: expected Collection, Iterator, " | |
// + "Query, or Extent, but got " | |
// + ob.getClass().getName()); | |
// } | |
} |