/**
* Speedo: an implementation of JDO compliant personality on top of JORM generic
* I/O sub-system.
* Copyright (C) 2001-2004 France Telecom R&D
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*
*
* Contact: speedo@objectweb.org
*
*/
package org.objectweb.speedo.runtime.fetchgroup;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import javax.jdo.FetchPlan;
import javax.jdo.JDODetachedFieldAccessException;
import javax.jdo.JDOException;
import javax.jdo.PersistenceManager;
import javax.jdo.Query;
import junit.framework.Assert;
import org.objectweb.speedo.SpeedoTestHelper;
import org.objectweb.speedo.api.ExceptionHelper;
import org.objectweb.speedo.pobjects.fetchgroup.Address;
import org.objectweb.speedo.pobjects.fetchgroup.Country;
import org.objectweb.speedo.pobjects.fetchgroup.EdgeWeight;
import org.objectweb.speedo.pobjects.fetchgroup.Node;
import org.objectweb.speedo.pobjects.fetchgroup.Person;
import org.objectweb.util.monolog.api.BasicLevel;
/**
*
* @author Y.Bersihand
*/
public class TestDefinedFetchGroup extends SpeedoTestHelper {
public TestDefinedFetchGroup(String s) {
super(s);
}
protected String getLoggerName() {
return LOG_NAME + ".rt.fetchgroup.TestDefinedFetchGroup";
}
/**
* Test the loading with the detail fetch group :
* test the definition of a fetch-group in the jdo file with a a.b.c field
* <field name="a.b.c">
*/
public void testLoadingReference() {
logger.log(BasicLevel.DEBUG, "***************testLoadingReference*****************");
Country country = new Country("it","Italie");
Address address = new Address("Rue Spiaggi", "Milan", country);
Person parent = new Person();
parent.setName("Del Piero Joel");
parent.setAge(32);
parent.setAddress(address);
Person child1 = new Person("Del Piero Sophie", address, null, 14);
Person child2 = new Person("Del Piero Mikael", address, null, 11);
Set children = new HashSet();
children.add(child1);
children.add(child2);
parent.setChildren(children);
PersistenceManager pm = pmf.getPersistenceManager();
FetchPlan fp = pm.getFetchPlan();
fp.clearGroups();
fp.addGroup("detail").removeGroup("default");
pm.currentTransaction().begin();
logger.log(BasicLevel.DEBUG, "make persistent the person " + parent.toString());
pm.makePersistent(parent);
pm.currentTransaction().commit();
logger.log(BasicLevel.DEBUG, "FG: " + fp.getGroups());
try {
pm.currentTransaction().begin();
Person detachedParent = (Person) pm.detachCopy(parent);
logger.log(BasicLevel.DEBUG, "Name can be accessed: " + detachedParent.getName());
logger.log(BasicLevel.DEBUG, "Age can be accessed: " + detachedParent.getAge());
logger.log(BasicLevel.DEBUG, "Address can be accessed: " + detachedParent.getAddress().toString());
assertEquals(parent.getName(), detachedParent.getName());
assertEquals(parent.getAge(), detachedParent.getAge());
assertEquals(parent.getAddress().getCity(), detachedParent.getAddress().getCity());
assertEquals(parent.getAddress().getCountry().getCode(), detachedParent.getAddress().getCountry().getCode());
assertEquals(parent.getAddress().getCountry().getName(), detachedParent.getAddress().getCountry().getName());
assertEquals(parent.getAddress().getStreet(), detachedParent.getAddress().getStreet());
logger.log(BasicLevel.DEBUG, "Children should not be accessed: " + detachedParent.getChildren().toString());
} catch(Exception e) {
if (!JDODetachedFieldAccessException.class.equals(e.getClass())) {
logger.log(BasicLevel.ERROR, "Exception found: ", e);
assertEquals(e.getClass(), JDODetachedFieldAccessException.class);
}
if (e instanceof JDODetachedFieldAccessException && e.getMessage().indexOf("children") != -1) {
logger.log(BasicLevel.DEBUG, "correct type exception caught: " + e);
} else {
logger.log(BasicLevel.DEBUG, "Error: " + e);
fail(e.getMessage());
}
} finally {
if (pm.currentTransaction().isActive())
pm.currentTransaction().rollback();
pm.close();
}
}
/**
* Test the loading with the detail+children-names fetch group:
* test the definition of a fetch-group in the jdo file with a a#element.b field
* <field name="a#element.b">
*/
public void testLoadingArrayElement() {
logger.log(BasicLevel.DEBUG, "************testLoadingArrayElement**************");
Country country = new Country("be","Belgique");
Address address = new Address("Rue Anvers", "Bruges", country);
Person parent = new Person();
parent.setName("Dermuck Joel");
parent.setAge(32);
parent.setAddress(address);
Person child1 = new Person("Dermuck Sophie", address, null, 14);
Person child2 = new Person("Dermuck Mikael", address, null, 11);
Set children = new HashSet();
children.add(child1);
children.add(child2);
parent.setChildren(children);
PersistenceManager pm = pmf.getPersistenceManager();
FetchPlan fp = pm.getFetchPlan();
fp.clearGroups();
fp.addGroup("detail+children-names").removeGroup("default");
pm.currentTransaction().begin();
logger.log(BasicLevel.DEBUG, "make persistent the person " + parent.toString());
pm.makePersistent(parent);
pm.currentTransaction().commit();
logger.log(BasicLevel.DEBUG, "FG: " + fp.getGroups());
try {
pm.currentTransaction().begin();
Person detachedParent = (Person) pm.detachCopy(parent);
logger.log(BasicLevel.DEBUG, "Name can be accessed: " + detachedParent.getName());
logger.log(BasicLevel.DEBUG, "Age can be accessed: " + detachedParent.getAge());
logger.log(BasicLevel.DEBUG, "Address can be accessed: " +
detachedParent.getAddress().getStreet() + ", " + detachedParent.getAddress().getCity()
+ ", " + detachedParent.getAddress().getCountry().getCode());
assertEquals(parent.getName(), detachedParent.getName());
assertEquals(parent.getAge(), detachedParent.getAge());
assertEquals(parent.getAddress().getCity(), detachedParent.getAddress().getCity());
assertEquals(parent.getAddress().getCountry().getCode(), detachedParent.getAddress().getCountry().getCode());
assertEquals(parent.getAddress().getCountry().getName(), detachedParent.getAddress().getCountry().getName());
assertEquals(parent.getAddress().getStreet(), detachedParent.getAddress().getStreet());
assertEquals(parent.getChildren().size(), detachedParent.getChildren().size());
Collection childrenTmp = detachedParent.getChildren();
logger.log(BasicLevel.DEBUG, "Children names can be accessed: ");
Iterator it = childrenTmp.iterator();
while(it.hasNext()){
Person p = (Person) it.next();
logger.log(BasicLevel.DEBUG, "Child: " + p.getName() + ", " + p.getAge());
}
it = childrenTmp.iterator();
while(it.hasNext()){
Person p = (Person) it.next();
logger.log(BasicLevel.DEBUG, "Children address should not be accessed: " + p.getAddress().toString());
}
} catch(Exception e) {
assertEquals(e.getClass(), JDODetachedFieldAccessException.class);
assertTrue(e.getMessage().indexOf("address") != -1);
if (e instanceof JDODetachedFieldAccessException && e.getMessage().indexOf("address") != -1) {
logger.log(BasicLevel.DEBUG, "correct type exception caught: " + e);
} else {
logger.log(BasicLevel.DEBUG, "Error: " + e);
fail(e.getMessage());
}
} finally {
if (pm.currentTransaction().isActive())
pm.currentTransaction().rollback();
pm.close();
}
}
/**
* Test the loading with the detail+children-list fetch group:
* test the definition of a fetch-group in the jdo file with a fetch-group attribute in a field
* <field name="a" fetch-group="fg"/>
*/
public void testLoadingFetchGroupField() {
logger.log(BasicLevel.DEBUG, "************testLoadingFetchGroupField**************");
Country country = new Country("us","Etats-Unis");
Address address = new Address("Rue Enclif", "San Diego", country);
Person parent = new Person();
parent.setName("Smith Joel");
parent.setAge(32);
parent.setAddress(address);
Person child1 = new Person("Smith Sofia", address, null, 14);
Person child2 = new Person("Smith Michael", address, null, 11);
Set children = new HashSet();
children.add(child1);
children.add(child2);
parent.setChildren(children);
PersistenceManager pm = pmf.getPersistenceManager();
FetchPlan fp = pm.getFetchPlan();
fp.clearGroups();
fp.addGroup("detail+children-list").removeGroup("default");
pm.currentTransaction().begin();
logger.log(BasicLevel.DEBUG, "make persistent the person " + parent.toString());
pm.makePersistent(parent);
pm.currentTransaction().commit();
logger.log(BasicLevel.DEBUG, "FG: " + fp.getGroups());
try {
pm.currentTransaction().begin();
Person detachedParent = (Person) pm.detachCopy(parent);
logger.log(BasicLevel.DEBUG, "Name can be accessed: " + detachedParent.getName());
logger.log(BasicLevel.DEBUG, "Age can be accessed: " + detachedParent.getAge());
logger.log(BasicLevel.DEBUG, "Address can be accessed: " +
detachedParent.getAddress().getStreet() + ", " + detachedParent.getAddress().getCity()
+ ", " + detachedParent.getAddress().getCountry().getCode());
Collection childrenTmp = detachedParent.getChildren();
logger.log(BasicLevel.DEBUG, "Children names can be accessed: ");
assertEquals(parent.getName(), detachedParent.getName());
assertEquals(parent.getAge(), detachedParent.getAge());
assertEquals(parent.getAddress().getCity(), detachedParent.getAddress().getCity());
assertEquals(parent.getAddress().getCountry().getCode(), detachedParent.getAddress().getCountry().getCode());
assertEquals(parent.getAddress().getCountry().getName(), detachedParent.getAddress().getCountry().getName());
assertEquals(parent.getAddress().getStreet(), detachedParent.getAddress().getStreet());
assertEquals(parent.getChildren().size(), detachedParent.getChildren().size());
Iterator it = childrenTmp.iterator();
while(it.hasNext()){
Person p = (Person) it.next();
logger.log(BasicLevel.DEBUG, "Child: " + p.getName() + ", " + p.getAge());
}
it = childrenTmp.iterator();
while(it.hasNext()){
Person p = (Person) it.next();
logger.log(BasicLevel.DEBUG, "Child address should not be accessed: " + p.getAddress().toString());
}
} catch(Exception e){
assertEquals(e.getClass(), JDODetachedFieldAccessException.class);
assertTrue(e.getMessage().indexOf("address") != -1);
if (e instanceof JDODetachedFieldAccessException && e.getMessage().indexOf("address") != -1) {
logger.log(BasicLevel.DEBUG, "correct type exception caught: " + e);
} else {
logger.log(BasicLevel.DEBUG, "Error: " + e);
fail(e.getMessage());
}
} finally {
if (pm.currentTransaction().isActive())
pm.currentTransaction().rollback();
pm.close();
}
}
/**
* Test the loading with the detailChildren fetch group:
* test the definition of a fetch-group in the jdo file with a depth attribute in a field
* for recursive reference
* <field name="a" depth="X"/>
*/
public void testLoadingRecursiveDepth() {
logger.log(BasicLevel.DEBUG, "************testLoadingRecursiveDepth**************");
Country country = new Country("sp","Espagne");
Address address = new Address("Rue Rio", "Santander", country);
Person parent = new Person();
parent.setName("Casillas Joel");
parent.setAge(63);
parent.setAddress(address);
Person child1 = new Person("Casillas Sofia", address, null, 30);
Person child2 = new Person("Casillas Michael", address, null, 40);
Set children = new HashSet();
children.add(child1);
children.add(child2);
parent.setChildren(children);
Person child11 = new Person("Casillas Maria", address, null, 14);
Person child21 = new Person("Casillas Juan", address, null, 11);
Set children1 = new HashSet();
children1.add(child11);
Set children2 = new HashSet();
children2.add(child21);
child1.setChildren(children1);
child2.setChildren(children2);
PersistenceManager pm = pmf.getPersistenceManager();
FetchPlan fp = pm.getFetchPlan();
fp.clearGroups();
fp.addGroup("detailChildren").removeGroup("default");
pm.currentTransaction().begin();
logger.log(BasicLevel.DEBUG, "make persistent the person " + parent.toString());
pm.makePersistent(parent);
pm.currentTransaction().commit();
logger.log(BasicLevel.DEBUG, "FG: " + fp.getGroups());
try {
pm.currentTransaction().begin();
Person detachedParent = (Person) pm.detachCopy(parent);
assertEquals(parent.getName(), detachedParent.getName());
assertEquals(parent.getAge(), detachedParent.getAge());
assertEquals(parent.getAddress().getCity(), detachedParent.getAddress().getCity());
assertEquals(parent.getAddress().getCountry().getCode(), detachedParent.getAddress().getCountry().getCode());
assertEquals(parent.getAddress().getCountry().getName(), detachedParent.getAddress().getCountry().getName());
assertEquals(parent.getAddress().getStreet(), detachedParent.getAddress().getStreet());
assertEquals(parent.getChildren().size(), detachedParent.getChildren().size());
logger.log(BasicLevel.DEBUG, "Name can be accessed: " + detachedParent.getName());
logger.log(BasicLevel.DEBUG, "Age can be accessed: " + detachedParent.getAge());
logger.log(BasicLevel.DEBUG, "Address can be accessed: " +
detachedParent.getAddress().getStreet() + ", " + detachedParent.getAddress().getCity()
+ ", " + detachedParent.getAddress().getCountry().getCode());
Collection childrenTmp = detachedParent.getChildren();
logger.log(BasicLevel.DEBUG, "Children names and address.country.code can be accessed: ");
Iterator it = childrenTmp.iterator();
while(it.hasNext()){
Person p = (Person) it.next();
logger.log(BasicLevel.DEBUG, "Child: " + p.getName() + ", " + p.getAge() + ", " + p.getAddress().getStreet() + ", " + p.getAddress().getCity()
+ ", " + p.getAddress().getCountry().getCode());
}
it = childrenTmp.iterator();
while(it.hasNext()){
Person p = (Person) it.next();
Iterator it2 = p.getChildren().iterator();
while(it2.hasNext()){
Person person = (Person) it2.next();
logger.log(BasicLevel.DEBUG, "\tChild of children should not be accessed: " + person.toString());
}
}
} catch(Exception e) {
assertEquals(e.getClass(), JDODetachedFieldAccessException.class);
assertTrue(e.getMessage().indexOf("children") != -1);
if (e instanceof JDODetachedFieldAccessException && e.getMessage().indexOf("children") != -1) {
logger.log(BasicLevel.DEBUG, "correct type exception caught: " + e);
} else {
logger.log(BasicLevel.DEBUG, "Error: " + e);
fail(e.getMessage());
}
} finally {
if (pm.currentTransaction().isActive())
pm.currentTransaction().rollback();
pm.close();
}
}
/**
* Test the loading with the detailChildren fetch group:
* test the definition of a fetch-group in the jdo file with a depth attribute defined twice for a field
* <field name="a" depth="X"/>
*/
public void testLoadingDoubleDepth() {
logger.log(BasicLevel.DEBUG, "************testLoadingDoubleDepth**************");
Country country = new Country("bl","Belarus");
Address address = new Address("Rue Kaloc", "Minsk", country);
Person parent = new Person();
parent.setName("Castuk Joel");
parent.setAge(63);
parent.setAddress(address);
Person child1 = new Person("Castuk Sofia", address, null, 30);
Person child2 = new Person("Castuk Michael", address, null, 40);
Set children = new HashSet();
children.add(child1);
children.add(child2);
parent.setChildren(children);
Person child11 = new Person("Castuk Maria", address, null, 14);
Person child21 = new Person("Castuk Juan", address, null, 11);
Set children1 = new HashSet();
children1.add(child11);
Set children2 = new HashSet();
children2.add(child21);
child1.setChildren(children1);
child2.setChildren(children2);
PersistenceManager pm = pmf.getPersistenceManager();
FetchPlan fp = pm.getFetchPlan();
fp.clearGroups();
fp.addGroup("detailChildren2").removeGroup("default");
pm.currentTransaction().begin();
logger.log(BasicLevel.DEBUG, "make persistent the person " + parent.toString());
pm.makePersistent(parent);
pm.currentTransaction().commit();
logger.log(BasicLevel.DEBUG, "FG: " + fp.getGroups());
try{
pm.currentTransaction().begin();
Person detachedParent = (Person) pm.detachCopy(parent);
assertEquals(parent.getName(), detachedParent.getName());
assertEquals(parent.getAge(), detachedParent.getAge());
assertEquals(parent.getAddress().getCity(), detachedParent.getAddress().getCity());
assertEquals(parent.getAddress().getCountry().getCode(), detachedParent.getAddress().getCountry().getCode());
assertEquals(parent.getAddress().getCountry().getName(), detachedParent.getAddress().getCountry().getName());
assertEquals(parent.getAddress().getStreet(), detachedParent.getAddress().getStreet());
assertEquals(parent.getChildren().size(), detachedParent.getChildren().size());
logger.log(BasicLevel.DEBUG, "Name can be accessed: " + detachedParent.getName());
logger.log(BasicLevel.DEBUG, "Age can be accessed: " + detachedParent.getAge());
logger.log(BasicLevel.DEBUG, "Address can be accessed: " +
detachedParent.getAddress().getStreet() + ", " + detachedParent.getAddress().getCity()
+ ", " + detachedParent.getAddress().getCountry().getCode());
Collection childrenTmp = detachedParent.getChildren();
logger.log(BasicLevel.DEBUG, "Children names and address.country.code can be accessed: ");
Iterator it = childrenTmp.iterator();
while(it.hasNext()){
Person p = (Person) it.next();
logger.log(BasicLevel.DEBUG, "Child: " + p.getName() + ", " + p.getAge() + ", " + p.getAddress().getStreet() + ", " + p.getAddress().getCity()
+ ", " + p.getAddress().getCountry().getCode());
}
it = childrenTmp.iterator();
while(it.hasNext()){
Person p = (Person) it.next();
Iterator it2 = p.getChildren().iterator();
while(it2.hasNext()){
Person person = (Person) it2.next();
logger.log(BasicLevel.DEBUG, "\tChild of children " + person.getName() + ", " + person.getAge() + ", " + person.getAddress().getStreet() + ", " + person.getAddress().getCity()
+ ", " + person.getAddress().getCountry().getCode());
}
}
it = childrenTmp.iterator();
while(it.hasNext()){
Person p = (Person) it.next();
Iterator it2 = p.getChildren().iterator();
while(it2.hasNext()){
Person person = (Person) it2.next();
Iterator it3 = person.getChildren().iterator();
while(it3.hasNext()){
Person pf = (Person) it3.next();
logger.log(BasicLevel.DEBUG, "\t\tChild: " + pf.toString());
}
}
}
} catch(Exception e){
assertEquals("Supposed to be a " + JDODetachedFieldAccessException.class.getName(), JDODetachedFieldAccessException.class, e.getClass());
assertTrue(e.getMessage().indexOf("children") != -1);
if (e instanceof JDODetachedFieldAccessException && e.getMessage().indexOf("children") != -1) {
logger.log(BasicLevel.DEBUG, "correct type exception caught: " + e);
} else {
logger.log(BasicLevel.DEBUG, "Error: " + e);
fail(e.getMessage());
}
} finally {
if (pm.currentTransaction().isActive())
pm.currentTransaction().rollback();
pm.close();
}
}
/**
* Test the loading with the detailChildren fetch group:
* test the definition of a fetch-group in the jdo file with a depth attribute defined twice for a field
* one of them is unlimited
* <field name="a" depth="X"/>
*/
public void testLoadingDoubleDepthUnlimited() {
logger.log(BasicLevel.DEBUG, "************testLoadingDoubleDepthUnlimited**************");
Country country = new Country("p","Portugal");
Address address = new Address("Rue Christiano", "Lisbonne", country);
Person parent = new Person();
parent.setName("Simoes Joel");
parent.setAge(63);
parent.setAddress(address);
Person child1 = new Person("Simoes Sofia", address, null, 30);
Person child2 = new Person("Simoes Michael", address, null, 40);
Set children = new HashSet();
children.add(child1);
children.add(child2);
parent.setChildren(children);
Person child11 = new Person("Simoes Maria", address, null, 14);
Person child21 = new Person("Simoes Juan", address, null, 11);
Set children1 = new HashSet();
children1.add(child11);
Set children2 = new HashSet();
children2.add(child21);
child1.setChildren(children1);
child2.setChildren(children2);
PersistenceManager pm = pmf.getPersistenceManager();
FetchPlan fp = pm.getFetchPlan();
fp.clearGroups();
fp.addGroup("detailChildren3").removeGroup("default");
pm.currentTransaction().begin();
logger.log(BasicLevel.DEBUG, "make persistent the person " + parent.toString());
pm.makePersistent(parent);
pm.currentTransaction().commit();
logger.log(BasicLevel.DEBUG, "FG: " + fp.getGroups());
try {
pm.currentTransaction().begin();
Person detachedParent = (Person) pm.detachCopy(parent);
assertEquals(parent.getName(), detachedParent.getName());
assertEquals(parent.getAge(), detachedParent.getAge());
assertEquals(parent.getAddress().getCity(), detachedParent.getAddress().getCity());
assertEquals(parent.getAddress().getCountry().getCode(), detachedParent.getAddress().getCountry().getCode());
assertEquals(parent.getAddress().getCountry().getName(), detachedParent.getAddress().getCountry().getName());
assertEquals(parent.getAddress().getStreet(), detachedParent.getAddress().getStreet());
assertEquals(parent.getChildren().size(), detachedParent.getChildren().size());
logger.log(BasicLevel.DEBUG, "Name can be accessed: " + detachedParent.getName());
logger.log(BasicLevel.DEBUG, "Age can be accessed: " + detachedParent.getAge());
logger.log(BasicLevel.DEBUG, "Address can be accessed: " +
detachedParent.getAddress().getStreet() + ", " + detachedParent.getAddress().getCity()
+ ", " + detachedParent.getAddress().getCountry().getCode());
Collection childrenTmp = detachedParent.getChildren();
logger.log(BasicLevel.DEBUG, "Children names and address.country.code can be accessed: ");
Iterator it = childrenTmp.iterator();
while(it.hasNext()){
Person p = (Person) it.next();
logger.log(BasicLevel.DEBUG, "Child: " + p.getName() + ", " + p.getAge() + ", " + p.getAddress().getStreet() + ", " + p.getAddress().getCity()
+ ", " + p.getAddress().getCountry().getCode());
}
it = childrenTmp.iterator();
while(it.hasNext()){
Person p = (Person) it.next();
Iterator it2 = p.getChildren().iterator();
while(it2.hasNext()){
Person person = (Person) it2.next();
logger.log(BasicLevel.DEBUG, "\tChild of children " + person.toString());
}
}
pm.close();
} catch(Exception e) {
logger.log(BasicLevel.DEBUG, "Error: " + e);
fail(e.getMessage());
} finally {
if (pm.currentTransaction().isActive())
pm.currentTransaction().rollback();
pm.close();
}
}
/**
* Test the loading with the keyValue fetchgroup:
* test the definition of a fetch-group with a map, loading both keys and values
* <field name="map#key">
* <field name="map#value">
*/
public void testLoadingMapKeyValue() {
logger.log(BasicLevel.DEBUG, "************testLoadingMapKeyValue**************");
Node n1 = new Node("n1");
Node n2 = new Node("n2");
Node n3 = new Node("n3");
Node n4 = new Node("n4");
Node n5 = new Node("n5");
n1.addEdge(n2.getName(), new EdgeWeight(1));
n1.addEdge(n3.getName(), new EdgeWeight(2));
n2.addEdge(n4.getName(), new EdgeWeight(7));
n2.addEdge(n5.getName(), new EdgeWeight(4));
PersistenceManager pm = pmf.getPersistenceManager();
FetchPlan fp = pm.getFetchPlan();
fp.clearGroups();
fp.addGroup("keyValue").removeGroup("default");
pm.currentTransaction().begin();
logger.log(BasicLevel.DEBUG, "make persistent the nodes " + n1.toString() + ", " + n2.toString()
+ ", " + n3.toString() + ", " + n4.toString() + ", " + n5.toString());
pm.makePersistent(n1);
pm.makePersistent(n2);
pm.makePersistent(n3);
pm.makePersistent(n4);
pm.makePersistent(n5);
pm.currentTransaction().commit();
logger.log(BasicLevel.DEBUG, "FG: " + fp.getGroups());
try {
Node detachedN1 = (Node) pm.detachCopy(n1);
assertEquals(n1.getName(), detachedN1.getName());
assertEquals(n1.getEdges().size(), detachedN1.getEdges().size());
logger.log(BasicLevel.DEBUG, "Name can be accessed: " + detachedN1.getName());
logger.log(BasicLevel.DEBUG, "ToString(): " + detachedN1.toString());
} catch(Exception e){
logger.log(BasicLevel.DEBUG, "Error: " + e);
fail(e.getMessage());
} finally {
if (pm.currentTransaction().isActive())
pm.currentTransaction().rollback();
pm.close();
}
}
/**
* Test the loading with the keyOnly fetchgroup:
* test the definition of a fetch-group with a map, loading only keys
* <field name="map#key">
*/
public void testLoadingMapKeyOnly() {
logger.log(BasicLevel.DEBUG, "************testLoadingMapKeyOnly**************");
Node n1 = new Node("n11");
Node n2 = new Node("n21");
Node n3 = new Node("n31");
Node n4 = new Node("n41");
Node n5 = new Node("n51");
n1.addEdge(n2.getName(), new EdgeWeight(1));
n1.addEdge(n3.getName(), new EdgeWeight(2));
n2.addEdge(n4.getName(), new EdgeWeight(7));
n2.addEdge(n5.getName(), new EdgeWeight(4));
PersistenceManager pm = pmf.getPersistenceManager();
FetchPlan fp = pm.getFetchPlan();
fp.clearGroups();
fp.addGroup("keyOnly").removeGroup("default");
pm.currentTransaction().begin();
logger.log(BasicLevel.DEBUG, "make persistent the nodes " + n1.toString() + ", " + n2.toString()
+ ", " + n3.toString() + ", " + n4.toString() + ", " + n5.toString());
pm.makePersistent(n1);
pm.makePersistent(n2);
pm.makePersistent(n3);
pm.makePersistent(n4);
pm.makePersistent(n5);
pm.currentTransaction().commit();
logger.log(BasicLevel.DEBUG, "FG: " + fp.getGroups());
try {
Node detachedN1 = (Node) pm.detachCopy(n1);
assertEquals(n1.getName(), detachedN1.getName());
assertEquals(n1.getEdges().size(), detachedN1.getEdges().size());
logger.log(BasicLevel.DEBUG, "Name can be accessed: " + detachedN1.getName());
logger.log(BasicLevel.DEBUG, "ToString(): " + detachedN1.toString());
} catch(Exception e){
logger.log(BasicLevel.DEBUG, "Error: " + e);
fail(e.getMessage());
} finally {
if (pm.currentTransaction().isActive())
pm.currentTransaction().rollback();
pm.close();
}
}
public void testRemovingOfPersistentObject() {
PersistenceManager pm = pmf.getPersistenceManager();
try {
Class[] cs = new Class[]{Person.class, Address.class, Country.class,
Node.class, EdgeWeight.class};
pm.currentTransaction().begin();
for(int i=0; i<cs.length; i++) {
Query query = pm.newQuery(cs[i]);
Collection col = (Collection) query.execute();
Iterator it = col.iterator();
while(it.hasNext()) {
Object o = it.next();
Assert.assertNotNull("null object in the query result"
+ cs[i].getName(), o);
pm.deletePersistent(o);
}
query.close(col);
}
pm.currentTransaction().commit();
} catch (JDOException e) {
Exception ie = ExceptionHelper.getNested(e);
logger.log(BasicLevel.ERROR, "", ie);
fail(ie.getMessage());
} finally {
pm.close();
}
}
}