/**
* 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
*
* Authors: S.Chassande-Barrioz.
*
*/
package org.objectweb.speedo.runtime.relations;
import org.objectweb.speedo.SpeedoTestHelper;
import org.objectweb.speedo.pobjects.relations.A;
import org.objectweb.speedo.pobjects.relations.B;
import org.objectweb.speedo.pobjects.relations.ni_ejboo.Article;
import org.objectweb.speedo.pobjects.relations.ni_ejboo.Catalogue;
import org.objectweb.speedo.pobjects.relations.ni_ejboo.Marche;
import org.objectweb.util.monolog.api.BasicLevel;
import javax.jdo.Extent;
import javax.jdo.PersistenceManager;
import javax.jdo.Query;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Arrays;
import java.util.Collections;
import java.util.Iterator;
public class TestRelations extends SpeedoTestHelper {
public TestRelations(String s) {
super(s);
}
protected String getLoggerName() {
return LOG_NAME + "rt.relations.Relations";
}
public void testOneOne() {
A a1 = new A("testOneOne_a1");
A a2 = new A("testOneOne_a2");
B b1 = new B("testOneOne_b1");
B b2 = new B("testOneOne_b2");
a1.setB(b1);
assertTrue(b1.getA() == a1);
a2.setB(b2);
assertTrue(b2.getA() == a2);
a1.setB(b2);
assertTrue(b1.getA() == null);
assertTrue(b2.getA() == a1);
assertTrue(a2.getB() == null);
b1.setA(a2);
assertTrue(a2.getB() == b1);
b1.setA(a1);
assertTrue(a1.getB() == b1);
assertTrue(b2.getA() == null);
assertTrue(a2.getB() == null);
}
public void testOneMany() { // tests on active persistent objects
A a1 = new A("testOneMany_a1");
A a2 = new A("testOneMany_a2");
B b1 = new B("testOneMany_b1");
B b2 = new B("testOneMany_b2");
B b3 = new B("testOneMany_b3");
B b4 = new B("testOneMany_b4");
PersistenceManager pm = pmf.getPersistenceManager();
pm.makePersistent(a1);
pm.makePersistent(a2);
pm.makePersistent(b1);
pm.makePersistent(b2);
pm.makePersistent(b3);
pm.makePersistent(b4);
pm.close();
try {
pm = pmf.getPersistenceManager();
a1.getNbs().add(b1);
assertTrue(b1.getNa() == a1);
a1.getNbs().add(b2);
assertTrue(b2.getNa() == a1);
a2.getNbs().add(b3);
assertTrue(b3.getNa() == a2);
a2.getNbs().add(b4);
assertTrue(b4.getNa() == a2);
a1.getNbs().add(b3);
assertTrue(b3.getNa() == a1);
assertTrue(!a2.getNbs().contains(b3));
a1.getNbs().remove(b1);
assertTrue(b1.getNa() == null);
b3.setNa(a2);
assertTrue(!a1.getNbs().contains(b3));
assertTrue(a2.getNbs().contains(b3));
a1.setNbs(a2.getNbs());
// reload objects before testing effects of the above assignement
pm.close();
pm = pmf.getPersistenceManager();
assertTrue(!a1.getNbs().contains(b1));
assertTrue(!a1.getNbs().contains(b2));
assertTrue(a1.getNbs().contains(b3));
assertTrue(a1.getNbs().contains(b4));
assertTrue(a1.getNbs().size() == 2);
assertTrue(!a2.getNbs().contains(b1));
assertTrue(!a2.getNbs().contains(b2));
assertTrue(!a2.getNbs().contains(b3));
assertTrue(!a2.getNbs().contains(b4));
assertTrue(b1.getNa() == null);
assertTrue(b2.getNa() == null);
assertTrue(b3.getNa() == a1);
assertTrue(b4.getNa() == a1);
pm.close();
} finally {
pm = pmf.getPersistenceManager();
pm.currentTransaction().begin();
pm.deletePersistent(a1);
pm.deletePersistent(a2);
pm.deletePersistent(b1);
pm.deletePersistent(b2);
pm.deletePersistent(b3);
pm.deletePersistent(b4);
pm.currentTransaction().commit();
pm.close();
}
}
public void testOneMany2() { // tests on non persistent objects
A a1 = new A("testOneMany2_a1");
A a2 = new A("testOneMany2_a2");
B b1 = new B("testOneMany2_b1");
B b2 = new B("testOneMany2_b2");
B b3 = new B("testOneMany2_b3");
B b4 = new B("testOneMany2_b4");
PersistenceManager pm = pmf.getPersistenceManager();
b1.setNa(a1);
// tests that a1.nbs, initially null, is created and contains b1
assertTrue(a1.getNbs() != null);
assertTrue(a1.getNbs().contains(b1));
b2.setNa(a1);
assertTrue(a1.getNbs().contains(b2));
b3.setNa(a2);
assertTrue(a2.getNbs() != null);
assertTrue(a2.getNbs().contains(b3));
b4.setNa(a2);
assertTrue(a2.getNbs().contains(b4));
pm.makePersistent(a1);
pm.makePersistent(a2);
pm.close();
try {
pm = pmf.getPersistenceManager();
Collection c = new ArrayList();
c.addAll(a2.getNbs());
a1.setNbs(c);
pm.close();
pm = pmf.getPersistenceManager();
assertTrue(!a1.getNbs().contains(b1));
assertTrue(!a1.getNbs().contains(b2));
assertTrue(a1.getNbs().contains(b3));
assertTrue(a1.getNbs().contains(b4));
assertTrue(a2.getNbs().size() == 0);
assertTrue(b1.getNa() == null);
assertTrue(b2.getNa() == null);
assertTrue(b3.getNa() == a1);
assertTrue(b4.getNa() == a1);
pm.close();
} finally {
pm = pmf.getPersistenceManager();
pm.currentTransaction().begin();
pm.deletePersistent(a1);
pm.deletePersistent(a2);
pm.deletePersistent(b1);
pm.deletePersistent(b2);
pm.deletePersistent(b3);
pm.deletePersistent(b4);
pm.currentTransaction().commit();
pm.close();
}
}
public void testOneMany3() { // tests with manually managed consistency
A a1 = new A("testOneMany3_a1");
B b1 = new B("testOneMany3_b1");
B b2 = new B("testOneMany3_b2");
PersistenceManager pm = pmf.getPersistenceManager();
ArrayList l = new ArrayList();
l.add(b1);
l.add(b2);
a1.setNbs(l);
b1.setNa(a1);
b2.setNa(a1);
assertTrue(a1.getNbs().size() == 2);
pm.makePersistent(a1);
pm.close();
try {
pm = pmf.getPersistenceManager();
assertTrue(a1.getNbs().size() == 2);
pm.close();
} finally {
pm = pmf.getPersistenceManager();
pm.currentTransaction().begin();
pm.deletePersistent(a1);
pm.deletePersistent(b1);
pm.deletePersistent(b1);
pm.currentTransaction().commit();
pm.close();
}
}
public void testOneManyDelete() {
A a1 = new A("testOneManyDelete_a1");
A a2 = new A("testOneManyDelete_a2");
B b1 = new B("testOneManyDelete_b1");
B b2 = new B("testOneManyDelete_b2");
B b3 = new B("testOneManyDelete_b3");
B b4 = new B("testOneManyDelete_b4");
PersistenceManager pm = pmf.getPersistenceManager();
pm.makePersistent(a1);
pm.makePersistent(a2);
pm.makePersistent(b1);
pm.makePersistent(b2);
pm.makePersistent(b3);
pm.makePersistent(b4);
pm.close();
try {
pm = pmf.getPersistenceManager();
a1.getNbs().add(b1);
assertTrue(b1.getNa() == a1);
a1.getNbs().add(b2);
assertTrue(b2.getNa() == a1);
a2.getNbs().add(b3);
assertTrue(b3.getNa() == a2);
a2.getNbs().add(b4);
assertTrue(b4.getNa() == a2);
pm.close();
pm = pmf.getPersistenceManager();
pm.currentTransaction().begin();
pm.deletePersistent(a1);
pm.currentTransaction().commit();
assertNull("reverse reference of a1.nbs (b1.na) must be null", b1.getNa());
assertNull("reverse reference of a1.nbs (b2.na) must be null", b2.getNa());
pm.currentTransaction().begin();
pm.deletePersistent(b3);
pm.currentTransaction().commit();
assertTrue("reverse reference of b3.na (a2.nbs) must not contain b3",
!a2.getNbs().contains(b3));
pm.close();
pm = pmf.getPersistenceManager();
assertTrue("reverse reference of b3.na (a2.nbs) must not contain b3",
!a2.getNbs().contains(b3));
assertEquals("Bad a2.nbs size", 1, a2.getNbs().size());
assertTrue("reverse reference of b3.na (a2.nbs) must not contain b3",
!a2.getNbs().contains(b3));
assertTrue(a2.getNbs().contains(b4));
assertNull("reverse reference of a1.nbs (b1.na) must be null", b1.getNa());
assertNull("reverse reference of a1.nbs (b2.na) must be null", b2.getNa());
assertTrue(b4.getNa() == a2);
pm.close();
} finally {
pm = pmf.getPersistenceManager();
pm.currentTransaction().begin();
pm.deletePersistent(a2);
pm.deletePersistent(b1);
pm.deletePersistent(b2);
pm.deletePersistent(b4);
pm.currentTransaction().commit();
pm.close();
}
}
public void testManyMany() { // tests on active persistent objects
A a1 = new A("testManyMany_a1");
A a2 = new A("testManyMany_a2");
A a3 = new A("testManyMany_a3");
B b1 = new B("testManyMany_b1");
B b2 = new B("testManyMany_b2");
B b3 = new B("testManyMany_b3");
PersistenceManager pm = pmf.getPersistenceManager();
pm.makePersistent(a1);
pm.makePersistent(a2);
pm.makePersistent(a3);
pm.makePersistent(b1);
pm.makePersistent(b2);
pm.makePersistent(b3);
pm.close();
try {
pm = pmf.getPersistenceManager();
a1.getBs().add(b1);
assertTrue(b1.getAs().contains(a1));
a1.getBs().add(b2);
assertTrue(b2.getAs().contains(a1));
a2.getBs().add(b1);
assertTrue(b1.getAs().contains(a2));
a2.getBs().add(b2);
assertTrue(b2.getAs().contains(a2));
a2.getBs().add(b3);
assertTrue(b3.getAs().contains(a2));
a3.getBs().add(b2);
assertTrue(b2.getAs().contains(a3));
a3.getBs().add(b3);
assertTrue(b3.getAs().contains(a3));
a1.getBs().add(b3);
assertTrue(b3.getAs().contains(a1));
a1.getBs().remove(b1);
assertTrue(!b1.getAs().contains(a1));
b2.getAs().remove(a2);
assertTrue(!a2.getBs().contains(b2));
a1.setBs(a2.getBs());
// reload objects before testing effects of the above assignement
pm.close();
pm = pmf.getPersistenceManager();
assertTrue(a1.getBs().contains(b1));
assertTrue(!a1.getBs().contains(b2));
assertTrue(a1.getBs().contains(b3));
assertTrue(a2.getBs().contains(b1));
assertTrue(!a2.getBs().contains(b2));
assertTrue(a2.getBs().contains(b3));
assertTrue(!a3.getBs().contains(b1));
assertTrue(a3.getBs().contains(b2));
assertTrue(a3.getBs().contains(b3));
assertTrue(b1.getAs().contains(a1));
assertTrue(b1.getAs().contains(a2));
assertTrue(!b1.getAs().contains(a3));
assertTrue(!b2.getAs().contains(a1));
assertTrue(!b2.getAs().contains(a2));
assertTrue(b2.getAs().contains(a3));
assertTrue(b3.getAs().contains(a1));
assertTrue(b3.getAs().contains(a2));
assertTrue(b3.getAs().contains(a3));
pm.close();
} finally {
pm = pmf.getPersistenceManager();
pm.currentTransaction().begin();
pm.deletePersistent(a1);
pm.deletePersistent(a2);
pm.deletePersistent(a3);
pm.deletePersistent(b1);
pm.deletePersistent(b2);
pm.deletePersistent(b3);
pm.currentTransaction().commit();
pm.close();
}
}
public void testManyMany2() { // tests on non persistent objects
A a1 = new A("testManyMany2_a1");
A a2 = new A("testManyMany2_a2");
A a3 = new A("testManyMany2_a3");
B b1 = new B("testManyMany2_b1");
B b2 = new B("testManyMany2_b2");
B b3 = new B("testManyMany2_b3");
PersistenceManager pm = pmf.getPersistenceManager();
a1.getBs().add(b1);
a1.getBs().add(b2);
a2.getBs().add(b1);
a2.getBs().add(b2);
a2.getBs().add(b3);
a3.getBs().add(b2);
a3.getBs().add(b3);
pm.makePersistent(a1);
pm.makePersistent(a2);
pm.makePersistent(a3);
pm.close();
try {
pm = pmf.getPersistenceManager();
assertTrue(b1.getAs().contains(a1));
assertTrue(b2.getAs().contains(a1));
assertTrue(b1.getAs().contains(a2));
assertTrue(b2.getAs().contains(a2));
assertTrue(b3.getAs().contains(a2));
assertTrue(b2.getAs().contains(a3));
assertTrue(b3.getAs().contains(a3));
Collection c = new ArrayList();
c.addAll(a2.getBs());
a1.setBs(c);
pm.close();
pm = pmf.getPersistenceManager();
assertTrue(a1.getBs().contains(b1));
assertTrue(a1.getBs().contains(b2));
assertTrue(a1.getBs().contains(b3));
assertTrue(a2.getBs().contains(b1));
assertTrue(a2.getBs().contains(b2));
assertTrue(a2.getBs().contains(b3));
assertTrue(!a3.getBs().contains(b1));
assertTrue(a3.getBs().contains(b2));
assertTrue(a3.getBs().contains(b3));
assertTrue(b1.getAs().contains(a1));
assertTrue(b1.getAs().contains(a2));
assertTrue(!b1.getAs().contains(a3));
assertTrue(b2.getAs().contains(a1));
assertTrue(b2.getAs().contains(a2));
assertTrue(b2.getAs().contains(a3));
assertTrue(b3.getAs().contains(a1));
assertTrue(b3.getAs().contains(a2));
assertTrue(b3.getAs().contains(a3));
pm.close();
} finally {
pm = pmf.getPersistenceManager();
pm.currentTransaction().begin();
pm.deletePersistent(a1);
pm.deletePersistent(a2);
pm.deletePersistent(a3);
pm.deletePersistent(b1);
pm.deletePersistent(b2);
pm.deletePersistent(b3);
pm.currentTransaction().commit();
pm.close();
}
}
public void testManyMany3() { // tests with manually managed consistency
A a1 = new A("testManyMany3_a1");
A a2 = new A("testManyMany3_a2");
A a3 = new A("testManyMany3_a3");
B b1 = new B("testManyMany3_b1");
B b2 = new B("testManyMany3_b2");
B b3 = new B("testManyMany3_b3");
PersistenceManager pm = pmf.getPersistenceManager();
a1.setBs(Arrays.asList(new Object[] { b1, b2 }));
a2.setBs(Arrays.asList(new Object[] { b1, b2, b3 }));
a3.setBs(Arrays.asList(new Object[] { b2, b3 }));
b1.setAs(Arrays.asList(new Object[] { a1, a2 }));
b2.setAs(Arrays.asList(new Object[] { a1, a2, a3 }));
b3.setAs(Arrays.asList(new Object[] { a2, a3 }));
pm.makePersistent(a1);
pm.makePersistent(a2);
pm.makePersistent(a3);
pm.close();
try {
pm = pmf.getPersistenceManager();
assertTrue(a1.getBs().size() == 2);
assertTrue(a1.getBs().contains(b1));
assertTrue(a1.getBs().contains(b2));
assertTrue(a2.getBs().size() == 3);
assertTrue(a2.getBs().contains(b1));
assertTrue(a2.getBs().contains(b2));
assertTrue(a2.getBs().contains(b3));
assertTrue(a3.getBs().size() == 2);
assertTrue(a3.getBs().contains(b2));
assertTrue(a3.getBs().contains(b3));
assertTrue(b1.getAs().size() == 2);
assertTrue(b1.getAs().contains(a1));
assertTrue(b1.getAs().contains(a2));
assertTrue(b2.getAs().size() == 3);
assertTrue(b2.getAs().contains(a1));
assertTrue(b2.getAs().contains(a2));
assertTrue(b2.getAs().contains(a3));
assertTrue(b3.getAs().size() == 2);
assertTrue(b3.getAs().contains(a2));
assertTrue(b3.getAs().contains(a3));
pm.close();
} finally {
pm = pmf.getPersistenceManager();
pm.currentTransaction().begin();
pm.deletePersistent(a1);
pm.deletePersistent(a2);
pm.deletePersistent(a3);
pm.deletePersistent(b1);
pm.deletePersistent(b2);
pm.deletePersistent(b3);
pm.currentTransaction().commit();
pm.close();
}
}
public void testManyManyDelete() {
A a1 = new A("testManyManyDelete_a1");
A a2 = new A("testManyManyDelete_a2");
A a3 = new A("testManyManyDelete_a3");
B b1 = new B("testManyManyDelete_b1");
B b2 = new B("testManyManyDelete_b2");
B b3 = new B("testManyManyDelete_b3");
PersistenceManager pm = pmf.getPersistenceManager();
pm.makePersistent(a1);
pm.makePersistent(a2);
pm.makePersistent(a3);
pm.makePersistent(b1);
pm.makePersistent(b2);
pm.makePersistent(b3);
pm.close();
try {
pm = pmf.getPersistenceManager();
a1.getBs().add(b1);
assertTrue(b1.getAs().contains(a1));
a1.getBs().add(b2);
assertTrue(b2.getAs().contains(a1));
a2.getBs().add(b1);
assertTrue(b1.getAs().contains(a2));
a2.getBs().add(b2);
assertTrue(b2.getAs().contains(a2));
a2.getBs().add(b3);
assertTrue(b3.getAs().contains(a2));
a3.getBs().add(b2);
assertTrue(b2.getAs().contains(a3));
a3.getBs().add(b3);
assertTrue(b3.getAs().contains(a3));
pm.close();
pm = pmf.getPersistenceManager();
pm.currentTransaction().begin();
pm.deletePersistent(b2);
pm.currentTransaction().commit();
pm.close();
pm = pmf.getPersistenceManager();
assertTrue(a1.getBs().size() == 1);
assertTrue(a1.getBs().contains(b1));
assertTrue(a2.getBs().size() == 2);
assertTrue(a2.getBs().contains(b1));
assertTrue(a2.getBs().contains(b3));
assertTrue(a3.getBs().size() == 1);
assertTrue(a3.getBs().contains(b3));
assertTrue(b1.getAs().contains(a1));
assertTrue(b1.getAs().contains(a2));
assertTrue(!b1.getAs().contains(a3));
assertTrue(!b3.getAs().contains(a1));
assertTrue(b3.getAs().contains(a2));
assertTrue(b3.getAs().contains(a3));
pm.close();
} finally {
pm = pmf.getPersistenceManager();
pm.currentTransaction().begin();
pm.deletePersistent(a1);
pm.deletePersistent(a2);
pm.deletePersistent(a3);
pm.deletePersistent(b1);
pm.deletePersistent(b3);
pm.currentTransaction().commit();
pm.close();
}
}
public void testNIEjboo() {
final int NB_ARTICLE = 10;
final int CATLAOGUE_SIZE = 2;
final int MARCHE_SIZE = 2;
PersistenceManager pm = pmf.getPersistenceManager();
pm.currentTransaction().begin();
Catalogue cat = null;
int nbCat = 0;
Marche mar= null;
int nbMar = 0;
Article a;
for(int idArt=0; idArt<NB_ARTICLE; idArt++) {
if ((idArt / CATLAOGUE_SIZE) == nbCat) {
cat = new Catalogue();
pm.makePersistent(cat);
nbCat ++;
}
if ((idArt / MARCHE_SIZE) == nbMar) {
mar = new Marche();
pm.makePersistent(mar);
nbMar ++;
}
a = new Article(idArt);
pm.makePersistent(a);
a.setCatalogue(cat);
mar.getArticles().add(a);
}
pm.currentTransaction().commit();
a = null;
cat = null;
mar = null;
pm.evictAll();
Extent extent = pm.getExtent(Catalogue.class, true);
Iterator it = extent.iterator();
while(it.hasNext()) {
cat = (Catalogue) it.next();
logger.log(BasicLevel.DEBUG, "Catalogue " + cat.getId());
Collection arts = cat.getArticles();
Iterator articles = arts.iterator();
while(articles.hasNext()) {
a = (Article) articles.next();
logger.log(BasicLevel.DEBUG, "\tArticle " + a.getId());
Collection mars = a.getMarches();
Iterator marches = mars.iterator();
while (marches.hasNext()) {
mar = (Marche) marches.next();
logger.log(BasicLevel.DEBUG, "\t\tMarche " + mar.getId());
Collection m2as = mar.getArticles();
assertTrue("The article '" + a.getId()
+ "' is not in the collection marche(" + mar.getId()
+ ").articles", m2as.contains(a));
}
}
}
extent.closeAll();
pm.currentTransaction().begin();
Query q = pm.newQuery(Catalogue.class);
q.setResult("distinct this");
q.setFilter("articles.contains(a) && a.marches.contains(m) && m.id==MID");
q.declareParameters("long MID");
q.declareVariables("Marche m;Article a");
Collection c = (Collection) q.execute(new Long(mar.getId()));
Collection expectedResults = Collections.singletonList(cat);
assertSameCollection("Collection of results is not the one expected", expectedResults, c);
q.closeAll();
pm.currentTransaction().commit();
a = null;
cat = null;
mar = null;
pm.currentTransaction().begin();
extent = pm.getExtent(Article.class, true);
it = extent.iterator();
while (it.hasNext()) {
a = (Article) it.next();
cat = a.getCatalogue();
if (cat != null) {
pm.deletePersistent(cat);
}
pm.deletePersistentAll(a.getMarches());
pm.deletePersistent(a);
}
pm.currentTransaction().commit();
pm.close();
}
}