/**
* 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.Iterator;
import javax.jdo.FetchPlan;
import javax.jdo.JDODetachedFieldAccessException;
import javax.jdo.JDOException;
import javax.jdo.PersistenceManager;
import javax.jdo.Query;
import org.objectweb.speedo.SpeedoTestHelper;
import org.objectweb.speedo.api.ExceptionHelper;
import org.objectweb.speedo.pobjects.fetchgroup.Author;
import org.objectweb.speedo.pobjects.fetchgroup.Dictionnary;
import org.objectweb.speedo.pobjects.fetchgroup.Editor;
import org.objectweb.speedo.pobjects.fetchgroup.Novel;
import org.objectweb.speedo.pobjects.fetchgroup.PocketNovel;
import org.objectweb.speedo.pobjects.fetchgroup.Style;
import org.objectweb.speedo.pobjects.fetchgroup.Thesis;
import org.objectweb.speedo.pobjects.fetchgroup.University;
import org.objectweb.util.monolog.api.BasicLevel;
/**
*
* @author Y.Bersihand
*/
public class TestInheritanceFetchGroup extends SpeedoTestHelper {
public TestInheritanceFetchGroup(String s) {
super(s);
}
protected String getLoggerName() {
return LOG_NAME + ".rt.fetchgroup.TestInheritanceFetchGroup";
}
/**
* Test the Inheritance 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 testInheritanceReference() {
logger.log(BasicLevel.DEBUG, "***************testInheritanceReference*****************");
Author author1 = new Author("Marx", "Karl");
Author author2 = new Author("Kissinger", "Henry");
Editor editor1 = new Editor("Plon");
Editor editor2 = new Editor("Robert");
Style style1 = new Style("act", "action");
Style style2 = new Style("thr", "thriller");
Dictionnary dictionnary = new Dictionnary(332, author2, 950, 12000, 1999, editor2);
Novel novel = new Novel(724, author1, 325, "Am I", style2);
PocketNovel pocketNovel = new PocketNovel(945, author1, 230, "Why o why", style1, 12);
PersistenceManager pm = pmf.getPersistenceManager();
FetchPlan fp = pm.getFetchPlan();
fp.addGroup("detail").removeGroup("default");
pm.currentTransaction().begin();
logger.log(BasicLevel.DEBUG, "make persistent the dictionnary\n " + dictionnary.toString());
pm.makePersistent(dictionnary);
logger.log(BasicLevel.DEBUG, "make persistent the novel\n" + novel.toString());
pm.makePersistent(novel);
logger.log(BasicLevel.DEBUG, "make persistent the pocketNovel\n" + pocketNovel.toString());
pm.makePersistent(pocketNovel);
pm.currentTransaction().commit();
logger.log(BasicLevel.DEBUG, "FG: " + fp.getGroups());
Dictionnary detachedDictionnary = (Dictionnary) pm.detachCopy(dictionnary);
try{
assertEquals(dictionnary.getIsbn(), detachedDictionnary.getIsbn());
assertEquals(dictionnary.getType(), detachedDictionnary.getType());
assertEquals(dictionnary.getPageNb(), detachedDictionnary.getPageNb());
assertEquals(dictionnary.getAuthor().getFirstName(), detachedDictionnary.getAuthor().getFirstName());
assertEquals(dictionnary.getAuthor().getName(), detachedDictionnary.getAuthor().getName());
assertEquals(dictionnary.getWordNb(), detachedDictionnary.getWordNb());
assertEquals(dictionnary.getYear(), detachedDictionnary.getYear());
assertEquals(dictionnary.getEditor().getName(), detachedDictionnary.getEditor().getName());
logger.log(BasicLevel.DEBUG, "Isbn can be accessed: " + detachedDictionnary.getIsbn());
logger.log(BasicLevel.DEBUG, "Type can be accessed: " + detachedDictionnary.getType());
logger.log(BasicLevel.DEBUG, "PageNb can be accessed: " + detachedDictionnary.getPageNb());
logger.log(BasicLevel.DEBUG, "Author can be accessed: " + detachedDictionnary.getAuthor().toString());
logger.log(BasicLevel.DEBUG, "WordNb can be accessed: " + detachedDictionnary.getWordNb());
logger.log(BasicLevel.DEBUG, "Year can be accessed: " + detachedDictionnary.getYear());
logger.log(BasicLevel.DEBUG, "Editor can be accessed: " + detachedDictionnary.getEditor().toString() + "\n");
} catch(Exception e){
fail("Detach failed: " + e.getMessage());
}
Novel detachedNovel = (Novel) pm.detachCopy(novel);
try{
assertEquals(novel.getIsbn(), detachedNovel.getIsbn());
assertEquals(novel.getType(), detachedNovel.getType());
assertEquals(novel.getPageNb(), detachedNovel.getPageNb());
assertEquals(novel.getAuthor().getFirstName(), detachedNovel.getAuthor().getFirstName());
assertEquals(novel.getAuthor().getName(), detachedNovel.getAuthor().getName());
assertEquals(novel.getTitle(), detachedNovel.getTitle());
logger.log(BasicLevel.DEBUG, "Isbn can be accessed: " + detachedNovel.getIsbn());
logger.log(BasicLevel.DEBUG, "Type can be accessed: " + detachedNovel.getType());
logger.log(BasicLevel.DEBUG, "PageNb can be accessed: " + detachedNovel.getPageNb());
logger.log(BasicLevel.DEBUG, "Author can be accessed: " + detachedNovel.getAuthor().toString());
logger.log(BasicLevel.DEBUG, "Title can be accessed: " + detachedNovel.getTitle());
logger.log(BasicLevel.DEBUG, "Style should not be accessed: " + detachedNovel.getStyle().toString() + "\n");
}
catch(Exception e){
assertEquals(JDODetachedFieldAccessException.class, e.getClass());
assertTrue(e.getMessage().indexOf("style") != -1);
if(e instanceof JDODetachedFieldAccessException && e.getMessage().indexOf("style") != -1)
logger.log(BasicLevel.DEBUG, "correct type exception caught: " + e + "\n");
else {
logger.log(BasicLevel.DEBUG, "Error: " + e);
fail(e.getMessage());
}
}
PocketNovel detachedPocketNovel = (PocketNovel) pm.detachCopy(pocketNovel);
try{
assertEquals(pocketNovel.getIsbn(), detachedPocketNovel.getIsbn());
assertEquals(pocketNovel.getType(), detachedPocketNovel.getType());
assertEquals(pocketNovel.getPageNb(), detachedPocketNovel.getPageNb());
assertEquals(pocketNovel.getAuthor().getFirstName(), detachedPocketNovel.getAuthor().getFirstName());
assertEquals(pocketNovel.getAuthor().getName(), detachedPocketNovel.getAuthor().getName());
assertEquals(pocketNovel.getTitle(), detachedPocketNovel.getTitle());
assertEquals(pocketNovel.getSize(), detachedPocketNovel.getSize());
logger.log(BasicLevel.DEBUG, "Isbn can be accessed: " + detachedPocketNovel.getIsbn());
logger.log(BasicLevel.DEBUG, "Type can be accessed: " + detachedPocketNovel.getType());
logger.log(BasicLevel.DEBUG, "PageNb can be accessed: " + detachedPocketNovel.getPageNb());
logger.log(BasicLevel.DEBUG, "Author can be accessed: " + detachedPocketNovel.getAuthor().toString());
logger.log(BasicLevel.DEBUG, "Title can be accessed: " + detachedPocketNovel.getTitle());
logger.log(BasicLevel.DEBUG, "Size can be accessed: " + detachedPocketNovel.getSize());
logger.log(BasicLevel.DEBUG, "Style should not be accessed: " + detachedPocketNovel.getStyle().toString() + "\n");
}
catch(Exception e){
assertEquals(JDODetachedFieldAccessException.class, e.getClass());
assertTrue(e.getMessage().indexOf("style") != -1);
if (pm.currentTransaction().isActive())
pm.currentTransaction().rollback();
if(e instanceof JDODetachedFieldAccessException && e.getMessage().indexOf("style") != -1)
logger.log(BasicLevel.DEBUG, "correct type exception caught: " + e + "\n");
else
logger.log(BasicLevel.DEBUG, "Error: " + e);
} finally {
pm.close();
}
}
/**
* Test the Inheritance with the detail fetch group :
* test the definition of a fetch-group in the jdo file with a a@X field
* <field name="a" depth="1">
*/
public void testInheritanceDepth() {
logger.log(BasicLevel.DEBUG, "***************testInheritanceDepth*****************");
Author author1 = new Author("Nyberg", "Carl");
Author author2 = new Author("Levy", "Eric");
Author author3 = new Author("Sudarshan", "Sam");
University uni1 = new University("Wisconsin");
University uni2 = new University("Arkansas");
University uni3 = new University("Tokyo");
Thesis thesis1 = new Thesis(400, author1, 124, "Performance in mmdbms", null, uni1);
Thesis thesis2 = new Thesis(401, author2, 156, "QoS in mmdbms", thesis1, uni2);
Thesis thesis3 = new Thesis(402, author3, 113, "Why mmdbms?", thesis2, uni3);
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 thesis\n " + thesis1.toString() + "\n");
pm.makePersistent(thesis1);
logger.log(BasicLevel.DEBUG, "make persistent the thesis\n " + thesis2.toString() + "\n");
pm.makePersistent(thesis2);
logger.log(BasicLevel.DEBUG, "make persistent the thesis\n " + thesis3.toString() + "\n");
pm.makePersistent(thesis3);
pm.currentTransaction().commit();
FetchPlan f = pm.getFetchPlan();
logger.log(BasicLevel.DEBUG, "FG: " + f.getGroups());
pm.currentTransaction().begin();
Thesis detachedT3 = (Thesis) pm.detachCopy(thesis3);
try{
assertEquals(thesis3.getIsbn(), detachedT3.getIsbn());
assertEquals(thesis3.getType(), detachedT3.getType());
assertEquals(thesis3.getPageNb(), detachedT3.getPageNb());
assertEquals(thesis3.getAuthor().getFirstName(), detachedT3.getAuthor().getFirstName());
assertEquals(thesis3.getAuthor().getName(), detachedT3.getAuthor().getName());
assertEquals(thesis3.getTitle(), detachedT3.getTitle());
assertEquals(thesis3.getUniversity().getName(), detachedT3.getUniversity().getName());
logger.log(BasicLevel.DEBUG, "Isbn can be accessed: " + detachedT3.getIsbn());
logger.log(BasicLevel.DEBUG, "Type can be accessed: " + detachedT3.getType());
logger.log(BasicLevel.DEBUG, "PageNb can be accessed: " + detachedT3.getPageNb());
logger.log(BasicLevel.DEBUG, "Author can be accessed: " + detachedT3.getAuthor().toString());
logger.log(BasicLevel.DEBUG, "Title can be accessed: " + detachedT3.getTitle());
logger.log(BasicLevel.DEBUG, "University can be accessed: " + detachedT3.getUniversity().toString());
logger.log(BasicLevel.DEBUG, "Reference can be accessed: " );
}
catch(Exception e){
if (pm.currentTransaction().isActive())
pm.currentTransaction().rollback();
logger.log(BasicLevel.DEBUG, "Error: " + e);
fail(e.getMessage());
}
Thesis detachedT2 = detachedT3.getReference();
try{
assertEquals(thesis2.getIsbn(), detachedT2.getIsbn());
assertEquals(thesis2.getType(), detachedT2.getType());
assertEquals(thesis2.getPageNb(), detachedT2.getPageNb());
assertEquals(thesis2.getAuthor().getFirstName(), detachedT2.getAuthor().getFirstName());
assertEquals(thesis2.getAuthor().getName(), detachedT2.getAuthor().getName());
assertEquals(thesis2.getTitle(), detachedT2.getTitle());
assertEquals(thesis2.getUniversity().getName(), detachedT2.getUniversity().getName());
logger.log(BasicLevel.DEBUG, "\tIsbn can be accessed: " + detachedT2.getIsbn());
logger.log(BasicLevel.DEBUG, "\tType can be accessed: " + detachedT2.getType());
logger.log(BasicLevel.DEBUG, "\tPageNb can be accessed: " + detachedT2.getPageNb());
logger.log(BasicLevel.DEBUG, "\tAuthor can be accessed: " + detachedT2.getAuthor().toString());
logger.log(BasicLevel.DEBUG, "\tTitle can be accessed: " + detachedT2.getTitle());
logger.log(BasicLevel.DEBUG, "\tUniversity can be accessed: " + detachedT2.getUniversity().toString());
logger.log(BasicLevel.DEBUG, "\tReference should not be accessed: " + detachedT2.getReference().toString());
}
catch(Exception e){
assertEquals(JDODetachedFieldAccessException.class, e.getClass());
assertTrue(e.getMessage().indexOf("reference") != -1);
if (pm.currentTransaction().isActive())
pm.currentTransaction().rollback();
if(e instanceof JDODetachedFieldAccessException && e.getMessage().indexOf("reference") != -1)
logger.log(BasicLevel.DEBUG, "correct type exception caught: " + e);
else
logger.log(BasicLevel.DEBUG, "Error: " + e);
} finally {
pm.close();
}
}
public void testRemovingOfPersistentObject() {
PersistenceManager pm = pmf.getPersistenceManager();
try {
Class[] cs = new Class[]{Author.class, Dictionnary.class, Editor.class, Novel.class, PocketNovel.class,
Style.class, Thesis.class, University.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();
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();
}
}
}