/**
* 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.query;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.NoSuchElementException;
import javax.jdo.Extent;
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.basic.BasicA;
import org.objectweb.speedo.pobjects.basic.Product;
import org.objectweb.speedo.pobjects.collection.AMMB;
import org.objectweb.speedo.pobjects.collection.BMMB;
import org.objectweb.speedo.pobjects.collection.Group;
import org.objectweb.speedo.pobjects.collection.Ref2Ref2AMMB;
import org.objectweb.speedo.pobjects.collection.User;
import org.objectweb.speedo.pobjects.inheritance.query.GroupUser;
import org.objectweb.speedo.pobjects.inheritance.query.MailingList;
import org.objectweb.speedo.pobjects.inheritance.query.NewsGroup;
import org.objectweb.speedo.pobjects.inheritance.userCache.Litem;
import org.objectweb.speedo.pobjects.ref.Department;
import org.objectweb.speedo.pobjects.ref.Employee;
import org.objectweb.speedo.pobjects.ref.GeoRef;
import org.objectweb.speedo.pobjects.userid.AutoIncFieldId;
import org.objectweb.speedo.pobjects.userid.Ref2AutoIncFieldId;
import org.objectweb.util.monolog.api.BasicLevel;
/**
* This test tests the access to 2 fields from the Employee class (name
* and salary), Salary is a Float (with 2 parameters, a String and a Float
* object).
*/
public class TestQueries extends SpeedoTestHelper {
public TestQueries(String name) {
super(name);
}
protected String getLoggerName() {
return LOG_NAME + ".rt.query.TestQueries";
}
public void test0Parameter() {
logger.log(BasicLevel.DEBUG, "test0Parameter");
PersistenceManager pm = pmf.getPersistenceManager();
try {
Class empClass = Employee.class;
Query query = pm.newQuery(empClass);
Collection col = (Collection) query.execute();
Iterator it = col.iterator();
while(it.hasNext()) {
Employee e = (Employee) it.next();
Assert.assertNotNull("null element in the query result", e);
Assert.assertNotNull("null name of a element in the query result", e.getName());
}
query.close(col);
} catch (JDOException e) {
Exception ie = ExceptionHelper.getNested(e);
logger.log(BasicLevel.ERROR, "", ie);
fail(ie.getMessage());
} finally {
pm.close();
}
}
public void test10rder() {
logger.log(BasicLevel.DEBUG, "test10rder");
PersistenceManager pm = pmf.getPersistenceManager();
try {
Class empClass = Employee.class;
Query query = pm.newQuery(empClass);
query.setOrdering("name ascending");
Collection col = (Collection) query.execute();
Iterator it = col.iterator();
int i=0;
while(it.hasNext()) {
assertTrue("More result than expected ", i<POBuilder.nameOrder.length);
Employee e = (Employee) it.next();
Assert.assertNotNull("null element in the query result", e);
try {
Assert.assertEquals("Bad order (" + i + ")",
POBuilder.names[POBuilder.nameOrder[i]],e.getName());
} catch (Throwable e1) {
e1.printStackTrace();
}
i++;
}
assertEquals("Not enough result", POBuilder.nameOrder.length, i);
query.close(col);
} catch (JDOException e) {
Exception ie = ExceptionHelper.getNested(e);
logger.log(BasicLevel.ERROR, "", ie);
fail(ie.getMessage());
} finally {
pm.close();
}
}
public void test20rder() {
logger.log(BasicLevel.DEBUG, "test20rder");
PersistenceManager pm = pmf.getPersistenceManager();
Class empClass = Employee.class;
Query query = pm.newQuery(empClass);
Collection col = null;
try {
query.setOrdering("salary descending, name ascending");
col = (Collection) query.execute();
Iterator it = col.iterator();
int i=0;
while(it.hasNext()) {
assertTrue("More result than expected ", i<POBuilder.salariesOrder.length);
Assert.assertTrue("No enough values in the result", it.hasNext());
Employee e = (Employee) it.next();
Assert.assertNotNull("null element in the query result", e);
try {
Assert.assertEquals("Bad order (" + i + ")",
POBuilder.names[POBuilder.salariesOrder[i]],e.getName());
} catch (Throwable e1) {
e1.printStackTrace();
}
i++;
}
assertEquals("Not enough result", POBuilder.salariesOrder.length, i);
} catch (JDOException e) {
Exception ie = ExceptionHelper.getNested(e);
logger.log(BasicLevel.ERROR, "", ie);
fail(ie.getMessage());
} finally {
try {
query.closeAll();
} finally {
pm.close();
}
}
}
public void test1Parameter() {
logger.log(BasicLevel.DEBUG, "test1Parameter");
PersistenceManager pm = pmf.getPersistenceManager();
try {
Class empClass = Employee.class;
Query query = pm.newQuery(empClass);
query.declareParameters("String aName");
query.setFilter("(name == aName)");
Collection col = (Collection) query.execute(POBuilder.names[1]);
Iterator iter = col.iterator();
Assert.assertTrue("The query result is empty", iter.hasNext());
Employee e = (Employee) iter.next();
Assert.assertNotNull("Null collection element", e);
Assert.assertEquals("Bad employee name", POBuilder.names[1], e.getName());
Assert.assertTrue("More than one element in the query result", !iter.hasNext());
Assert.assertEquals("Bad query result size", 1, col.size());
query.close(col);
} catch (JDOException e) {
Exception ie = ExceptionHelper.getNested(e);
logger.log(BasicLevel.ERROR, "", ie);
fail(ie.getMessage());
} finally {
pm.close();
}
}
public void test1ParameterBis() {
logger.log(BasicLevel.DEBUG, "test1ParameterBis");
PersistenceManager pm = pmf.getPersistenceManager();
try {
Class empClass = Employee.class;
Query query = pm.newQuery(empClass);
query.declareParameters("float sal");
query.setFilter("(salary > sal)");
Collection col = (Collection) query.execute(new Float(POBuilder.salaries[2]));
Iterator iter = col.iterator();
HashSet s = new HashSet();
while(iter.hasNext()) {
Employee e = (Employee) iter.next();
s.add(e.getName());
}
query.close(col);
assertSameCollection("Bad query result",
Arrays.asList(new String[]{POBuilder.names[0],POBuilder.names[1],POBuilder.names[3]}),
s);
} catch (JDOException e) {
Exception ie = ExceptionHelper.getNested(e);
logger.log(BasicLevel.ERROR, "", ie);
fail(ie.getMessage());
} finally {
pm.close();
}
}
public void testFieldParameter() {
logger.log(BasicLevel.DEBUG, "testFieldParameter");
PersistenceManager pm = pmf.getPersistenceManager();
try {
Class empClass = Employee.class;
Query query = pm.newQuery(empClass);
String filterFieldParameter = "((salary == mysalary) && (name == myname))";
String param = "String myname, Float mysalary";
query.declareParameters(param);
query.setFilter(filterFieldParameter);
Collection col = (Collection)
query.execute(POBuilder.names[1], new Float(3000.0));
Iterator iter = col.iterator();
Assert.assertTrue("The query result is empty", iter.hasNext());
Employee e = (Employee) iter.next();
Assert.assertNotNull("Null collection element", e);
Assert.assertEquals("Bad employee name", POBuilder.names[1], e.getName());
Assert.assertEquals("Bad employee salary", new Float(3000.0), new Float(e.getSalary()));
Assert.assertTrue("More than one element in the query result", !iter.hasNext());
Assert.assertEquals("Bad query result size", 1, col.size());
query.close(col);
} catch (JDOException e) {
Exception ie = ExceptionHelper.getNested(e);
logger.log(BasicLevel.ERROR, "", ie);
fail(ie.getMessage());
} finally {
pm.close();
}
}
public void testMatches() {
logger.log(BasicLevel.DEBUG, "testMatches");
PersistenceManager pm = pmf.getPersistenceManager();
try {
Query query = pm.newQuery(Employee.class);
String filterFieldParameter = "((name.toUpperCase().matches(\"%IE\")) && (name.length()>2))";
query.setFilter(filterFieldParameter);
ArrayList col = new ArrayList((Collection) query.execute());
query.closeAll();
for(int i=0; i<col.size(); i++) {
col.add(i, ((Employee) col.remove(i)).getName());
}
assertSameCollection("Bad result of the testMatches method",
Arrays.asList(new String[]{ POBuilder.names[2], POBuilder.names[3]}),
col);
} catch (JDOException e) {
Exception ie = ExceptionHelper.getNested(e);
logger.log(BasicLevel.ERROR, "", ie);
fail(ie.getMessage());
} finally {
pm.close();
}
}
public void testStartsWith() {
logger.log(BasicLevel.DEBUG, "testStartsWith");
PersistenceManager pm = pmf.getPersistenceManager();
try {
Query query = pm.newQuery(Employee.class);
String filterFieldParameter = "(name.toUpperCase().startsWith(\"JOH\"))";
query.setFilter(filterFieldParameter);
ArrayList col = new ArrayList((Collection) query.execute());
query.closeAll();
for(int i=0; i<col.size(); i++) {
col.add(i, ((Employee) col.remove(i)).getName());
}
assertSameCollection("Bad result of the testStartsWith method",
Arrays.asList(new String[]{ POBuilder.names[0]}),
col);
} catch (JDOException e) {
Exception ie = ExceptionHelper.getNested(e);
logger.log(BasicLevel.ERROR, "", ie);
fail(ie.getMessage());
} finally {
pm.close();
}
}
public void _testSubString() {
//TODO: support Substring operator in parsing
logger.log(BasicLevel.DEBUG, "testMatches");
PersistenceManager pm = pmf.getPersistenceManager();
try {
Query query = pm.newQuery(Employee.class);
String filterFieldParameter = "(name.substring(0 2).matches(\"%ie\"))";
query.setFilter(filterFieldParameter);
ArrayList col = new ArrayList((Collection) query.execute());
query.closeAll();
for(int i=0; i<col.size(); i++) {
col.add(i, ((Employee) col.remove(i)).getName());
}
assertSameCollection("Bad result of the testMatches method",
Arrays.asList(new String[]{ POBuilder.names[2], POBuilder.names[3]}),
col);
} catch (JDOException e) {
Exception ie = ExceptionHelper.getNested(e);
logger.log(BasicLevel.ERROR, "", ie);
fail(ie.getMessage());
} finally {
pm.close();
}
}
public void testUpper() {
logger.log(BasicLevel.DEBUG, "testMatches");
PersistenceManager pm = pmf.getPersistenceManager();
try {
Query query = pm.newQuery(Employee.class);
String filterFieldParameter = "(name.toUpperCase().matches(\"%IE\"))";
query.setFilter(filterFieldParameter);
ArrayList col = new ArrayList((Collection) query.execute());
query.closeAll();
for(int i=0; i<col.size(); i++) {
col.add(i, ((Employee) col.remove(i)).getName());
}
assertSameCollection("Bad result of the testMatches method",
Arrays.asList(new String[]{ POBuilder.names[2], POBuilder.names[3]}),
col);
} catch (JDOException e) {
Exception ie = ExceptionHelper.getNested(e);
logger.log(BasicLevel.ERROR, "", ie);
fail(ie.getMessage());
} finally {
pm.close();
}
}
public void test2Parameters() {
logger.log(BasicLevel.DEBUG, "test2Parameters");
PersistenceManager pm = pmf.getPersistenceManager();
try {
Class empClass = Employee.class;
Query query = pm.newQuery(empClass);
query.declareParameters("String aName, String anotherName");
query.setFilter("((name == aName) || (name == anotherName))");
Collection col = (Collection)
query.execute(POBuilder.names[1], POBuilder.names[2]);
Iterator iter = col.iterator();
Assert.assertTrue("The query result is empty", iter.hasNext());
Employee e1 = (Employee) iter.next();
Assert.assertNotNull("Null collection element 1", e1);
Assert.assertTrue("Only one element in the query result", iter.hasNext());
Employee e2 = (Employee) iter.next();
Assert.assertNotNull("Null collection element 2", e2);
Assert.assertTrue("More than one element in the query result", !iter.hasNext());
Assert.assertEquals("Bad query result size", 2, col.size());
query.close(col);
if (POBuilder.names[1].equals(e1.getName())) {
Assert.assertEquals("Bad employee name", POBuilder.names[2], e2.getName());
} else if (POBuilder.names[1].equals(e2.getName())) {
Assert.assertEquals("Bad employee name", POBuilder.names[2], e1.getName());
} else {
fail("Bad employee name");
}
} catch (JDOException e) {
Exception ie = ExceptionHelper.getNested(e);
logger.log(BasicLevel.ERROR, "", ie);
fail(ie.getMessage());
} finally {
pm.close();
}
}
public void test3Parameters() {
logger.log(BasicLevel.DEBUG, "test3Parameters");
PersistenceManager pm = pmf.getPersistenceManager();
try {
Class empClass = Employee.class;
Query query = pm.newQuery(empClass);
String filter = "(name == aName) | (name == anotherName) | (name == thirdName)";
String param = "String aName, String anotherName, String thirdName";
query.declareParameters(param);
query.setFilter(filter);
Collection col = (Collection) query.execute(POBuilder.names[1],
POBuilder.names[2],
POBuilder.names[3]);
Iterator iter = col.iterator();
Collection expectedNames = new ArrayList(3);
Collection foundNames = new ArrayList(3);
expectedNames.add(POBuilder.names[1]);
expectedNames.add(POBuilder.names[2]);
expectedNames.add(POBuilder.names[3]);
Assert.assertTrue("The query result is empty", iter.hasNext());
Employee e = (Employee) iter.next();
Assert.assertNotNull("Null collection element 1", e);
foundNames.add(e.getName());
Assert.assertTrue("Only one element in the query result", iter.hasNext());
e = (Employee) iter.next();
Assert.assertNotNull("Null collection element 2", e);
foundNames.add(e.getName());
e = (Employee) iter.next();
Assert.assertNotNull("Null collection element 3", e);
foundNames.add(e.getName());
Assert.assertTrue("More than one element in the query result", !iter.hasNext());
Assert.assertEquals("Bad query result size", expectedNames.size(), col.size());
query.close(col);
Assert.assertTrue("Bad Employee names, expected:"
+ expectedNames + " / found: " + foundNames,
expectedNames.containsAll(foundNames)
&& foundNames.containsAll(expectedNames));
} catch (JDOException e) {
Exception ie = ExceptionHelper.getNested(e);
logger.log(BasicLevel.ERROR, "", ie);
fail(ie.getMessage());
} finally {
pm.close();
}
}
public void testMapParameters() {
logger.log(BasicLevel.DEBUG, "testMapParameters");
PersistenceManager pm = pmf.getPersistenceManager();
try {
Class empClass = Employee.class;
Query query = pm.newQuery(empClass);
String filter = "((name == aName) || (name == anotherName))";
String param = "String aName, String anotherName";
query.declareParameters(param);
query.setFilter(filter);
Map map = new HashMap();
map.put("aName", POBuilder.names[1]);
map.put("anotherName", POBuilder.names[2]);
Collection col = (Collection) query.executeWithMap(map);
Iterator iter = col.iterator();
Collection foundNames = new ArrayList(2);
Collection expectedNames = map.values();
Assert.assertTrue("The query result is empty", iter.hasNext());
Employee e = (Employee) iter.next();
Assert.assertNotNull("Null collection element 1", e);
foundNames.add(e.getName());
Assert.assertTrue("Only one element in the query result", iter.hasNext());
e = (Employee) iter.next();
Assert.assertNotNull("Null collection element 2", e);
foundNames.add(e.getName());
Assert.assertTrue("More than one element in the query result", !iter.hasNext());
Assert.assertEquals("Bad query result size", expectedNames.size(), col.size());
query.close(col);
Assert.assertTrue("Bad Employee names, expected:"
+ expectedNames + " / found: " + foundNames,
expectedNames.containsAll(foundNames)
&& foundNames.containsAll(expectedNames));
} catch (JDOException e) {
Exception ie = ExceptionHelper.getNested(e);
logger.log(BasicLevel.ERROR, "", ie);
fail(ie.getMessage());
} finally {
pm.close();
}
}
public void testArrayParameters() {
logger.log(BasicLevel.DEBUG, "testArrayParameters");
PersistenceManager pm = pmf.getPersistenceManager();
try {
Class empClass = Employee.class;
Query query = pm.newQuery(empClass);
String filter = "((name == aName) | (name == anotherName))";
String param = "String aName, String anotherName";
query.declareParameters(param);
query.setFilter(filter);
Collection expectedNames = new ArrayList(2);
expectedNames.add(POBuilder.names[1]);
expectedNames.add(POBuilder.names[2]);
Collection col = (Collection) query.executeWithArray(expectedNames.toArray());
Iterator iter = col.iterator();
Collection foundNames = new ArrayList(2);
Assert.assertTrue("The query result is empty", iter.hasNext());
Employee e = (Employee) iter.next();
Assert.assertNotNull("Null collection element 1", e);
foundNames.add(e.getName());
Assert.assertTrue("Only one element in the query result", iter.hasNext());
e = (Employee) iter.next();
Assert.assertNotNull("Null collection element 2", e);
foundNames.add(e.getName());
Assert.assertTrue("More than one element in the query result", !iter.hasNext());
Assert.assertEquals("Bad query result size", expectedNames.size(), col.size());
query.close(col);
Assert.assertTrue("Bad Employee names, expected:"
+ expectedNames + " / found: " + foundNames,
expectedNames.containsAll(foundNames)
&& foundNames.containsAll(expectedNames));
} catch (JDOException e) {
Exception ie = ExceptionHelper.getNested(e);
logger.log(BasicLevel.ERROR, "", ie);
fail(ie.getMessage());
} finally {
pm.close();
}
}
public void testFieldRef() {
logger.log(BasicLevel.DEBUG, "testFieldRef");
PersistenceManager pm = pmf.getPersistenceManager();
try {
Class empClass = Employee.class;
Query query = pm.newQuery(empClass);
String filterFieldRef = "((dept.name == depName) && (name == \""
+ POBuilder.names[0] + "\"))";
String param = "String depName";
query.declareParameters(param);
query.setFilter(filterFieldRef);
Collection col = (Collection) query.execute("RD");
Iterator iter = col.iterator();
Assert.assertTrue("The query result is empty", iter.hasNext());
Employee e = (Employee) iter.next();
Assert.assertNotNull("Null collection element", e);
Assert.assertEquals("Bad employee name", POBuilder.names[0], e.getName());
Assert.assertTrue("More than one element in the query result", !iter.hasNext());
Assert.assertEquals("Bad query result size", 1, col.size());
iter = col.iterator();
Assert.assertTrue("The query result is empty", iter.hasNext());
e = (Employee) iter.next();
Assert.assertNotNull("Null collection element", e);
Assert.assertEquals("Bad employee name", POBuilder.names[0], e.getName());
Assert.assertTrue("More than one element in the query result", !iter.hasNext());
query.close(col);
} catch (Exception e) {
Exception ie = ExceptionHelper.getNested(e);
logger.log(BasicLevel.ERROR, "", ie);
fail(ie.getMessage());
} finally {
pm.close();
}
}
public void testFieldRefNull() {
logger.log(BasicLevel.DEBUG, "testFieldRef");
PersistenceManager pm = pmf.getPersistenceManager();
final int nbEmp = 5;
Object[] oid = new Object[nbEmp];
for(int i=0; i<nbEmp; i++) {
Employee e = new Employee("testFieldRefNull" + i, null);
pm.makePersistent(e);
oid[i] = pm.getObjectId(e);
}
pm.close();
try {
pm = pmf.getPersistenceManager();
Query query = pm.newQuery(Employee.class);
query.declareParameters("Department d");
query.setFilter("(dept == d)");
Collection col = (Collection) query.execute(null);
int size = col.size();
query.close(col);
assertEquals("Bad number of employee without department", nbEmp, size);
} catch (Exception e) {
Exception ie = ExceptionHelper.getNested(e);
logger.log(BasicLevel.ERROR, "", ie);
fail(ie.getMessage());
} finally {
pm.currentTransaction().begin();
for(int i=0; i<nbEmp; i++) {
Employee e = (Employee) pm.getObjectById(oid[i], false);
pm.deletePersistent(e);
}
pm.currentTransaction().commit();
pm.close();
}
}
public void testThis() {
logger.log(BasicLevel.DEBUG, "testThis");
PersistenceManager pm = pmf.getPersistenceManager();
try {
Class empClass = Employee.class;
Query query = pm.newQuery(empClass);
String filter = "(this.name == aName)";
String param = "String aName";
query.declareParameters(param);
query.setFilter(filter);
Collection col = (Collection) query.execute(POBuilder.names[1]);
Iterator iter = col.iterator();
Assert.assertTrue("The query result is empty", iter.hasNext());
Employee e = (Employee) iter.next();
Assert.assertNotNull("Null collection element", e);
Assert.assertEquals("Bad employee name", POBuilder.names[1], e.getName());
Assert.assertTrue("More than one element in the query result", !iter.hasNext());
Assert.assertEquals("Bad query result size", 1, col.size());
query.close(col);
} catch (Exception e) {
Exception ie = ExceptionHelper.getNested(e);
logger.log(BasicLevel.ERROR, "", ie);
fail(ie.getMessage());
} finally {
pm.close();
}
}
public void testParamRef() {
logger.log(BasicLevel.DEBUG, "testParamRef");
PersistenceManager pm = pmf.getPersistenceManager();
try {
Query query = pm.newQuery(Department.class);
String filter = "(this.name == \"" + POBuilder.depName + "\")";
query.setFilter(filter);
Collection col = (Collection) query.execute();
Iterator iter = col.iterator();
Assert.assertTrue("", iter.hasNext());
Department d = (Department) iter.next();
query.closeAll();
query = pm.newQuery(Employee.class);
filter = "(this.dept == d)";
String param = "Department d";
query.declareParameters(param);
query.setFilter(filter);
col = (Collection) query.execute(d);
iter = col.iterator();
Assert.assertTrue("The query result is empty", iter.hasNext());
Assert.assertEquals("Bad size", POBuilder.names.length, col.size());
query.closeAll();
} catch (Exception e) {
Exception ie = ExceptionHelper.getNested(e);
logger.log(BasicLevel.ERROR, "", ie);
fail(ie.getMessage());
} finally {
pm.close();
}
}
public void testVarContains() {
logger.log(BasicLevel.DEBUG, "testVarContains");
PersistenceManager pm = pmf.getPersistenceManager();
try {
Query query = pm.newQuery(Department.class);
query.setFilter("(depts.contains(name))");
query.declareParameters("Collection depts");
Collection col = (Collection) query.execute(Arrays.asList(
new String[]{POBuilder.depName}));
Assert.assertEquals("Bad size", 1, col.size());
query.closeAll();
query = pm.newQuery(Department.class);
query.setFilter("(depts.contains(name))");
query.declareParameters("Collection depts");
col = (Collection) query.execute(Arrays.asList(
new String[]{"toto", "titi"}));
Assert.assertEquals("Bad size", 0, col.size());
query.closeAll();
} catch (Exception e) {
Exception ie = ExceptionHelper.getNested(e);
logger.log(BasicLevel.ERROR, "", ie);
fail(ie.getMessage());
} finally {
pm.close();
}
}
public void testBsContainsParam(long ida,long idb, boolean exist) {
logger.log(BasicLevel.DEBUG, "testBsContainsParam_" + ida + '_' + idb + '_' + exist);
PersistenceManager pm = pmf.getPersistenceManager();
try {
Query query = pm.newQuery(BMMB.class);
query.setFilter("(idb == param)");
query.declareParameters("long param");
Collection col = (Collection) query.execute(new Long(idb));
Iterator iter = col.iterator();
if (!iter.hasNext()) {
fail("Test not initialized: impossible to load BMMB(" + idb
+ "): not found");
}
BMMB bmmb = (BMMB) iter.next();
query.close(col);
// loggerFactory.getLogger("org.objectweb.speedo.rt.query").setIntLevel(BasicLevel.DEBUG);
// loggerFactory.getLogger("org.objectweb.medor").setIntLevel(BasicLevel.DEBUG);
query = pm.newQuery(AMMB.class);
String filter = "((ida == a) && bs.contains(b))";
query.declareParameters("BMMB b, long a");
query.setFilter(filter);
col = (Collection) query.execute(bmmb, new Long(ida));
iter = col.iterator();
Assert.assertEquals("The BMMB(" + idb + ") was " + (exist ? "not " : "")
+ "found in the collection AMMB(" + ida + ").bs",
exist, iter.hasNext());
if (exist) {
Assert.assertEquals("Not the same value", ida, ((AMMB) iter.next()).getIda());
}
query.close(col);
} catch (Exception e) {
Exception ie = ExceptionHelper.getNested(e);
logger.log(BasicLevel.ERROR, "", ie);
fail(ie.getMessage());
} finally {
pm.close();
}
}
public void testBsContains2Param_0_3() {
testBsContains2Param(0,3);
}
public void testBsContains2Param(long ida,long idb) {
logger.log(BasicLevel.DEBUG, "testBsContainsParam_" + ida + '_' + idb);
PersistenceManager pm = pmf.getPersistenceManager();
try {
Query query = pm.newQuery(BMMB.class);
query.setFilter("((idb == param1) || (idb == param2))");
query.declareParameters("long param1, long param2");
Collection col = (Collection) query.execute(new Long(idb), new Long(ida));
Iterator iter = col.iterator();
if (!iter.hasNext()) {
fail("Test not initialized: impossible to load BMMB(" + idb
+ "): not found");
}
BMMB bmmb1 = (BMMB) iter.next();
BMMB bmmb2 = (BMMB) iter.next();
query.close(col);
// loggerFactory.getLogger("org.objectweb.speedo.rt.query").setIntLevel(BasicLevel.DEBUG);
// loggerFactory.getLogger("org.objectweb.medor").setIntLevel(BasicLevel.DEBUG);
query = pm.newQuery(AMMB.class);
String filter = "((bs.contains(b1)) || (bs.contains(b2)))";
query.declareParameters("BMMB b1, BMMB b2");
query.setFilter(filter);
col = (Collection) query.execute(bmmb1, bmmb2);
iter = col.iterator();
Assert.assertEquals("The BMMB(" + idb + ") was not found in the collection AMMB.bs",
true, iter.hasNext());
iter.next();
Assert.assertEquals("The BMMB(" + ida + ") was not found in the collection AMMB.bs",
true, iter.hasNext());
query.close(col);
} catch (Exception e) {
Exception ie = ExceptionHelper.getNested(e);
logger.log(BasicLevel.ERROR, "", ie);
fail(ie.getMessage());
} finally {
pm.close();
}
}
public void testBsContainsParamA0B0() {
testBsContainsParam(0, 0, true);
}
public void testBsContainsParamA0B2() {
testBsContainsParam(0, 2, false);
}
public void testBsContainsVar(long id, Collection aNames) {
String testName = "testBsContainsVar_" + id + '_' + aNames;
logger.log(BasicLevel.DEBUG, testName);
PersistenceManager pm = pmf.getPersistenceManager();
try {
Query query = pm.newQuery(AMMB.class);
String filter = "(bs.contains(b) && (b.name==name))";
query.declareParameters("String name");
query.declareVariables("BMMB b");
query.setFilter(filter);
Collection col = (Collection) query.execute("B" + id);
Collection res = new ArrayList();
Iterator iter = col.iterator();
while(iter.hasNext()) {
res.add(((AMMB) iter.next()).getName());
}
query.close(col);
assertSameCollection(testName + ":", aNames, res);
} catch (Exception e) {
Exception ie = ExceptionHelper.getNested(e);
logger.log(BasicLevel.ERROR, "", ie);
fail(ie.getMessage());
} finally {
pm.close();
}
}
public void testBsContainsVarB3EmptyShortPath() {
testBsContainsVar(3, Collections.EMPTY_LIST);
}
public void testBsContainsVarB0ShortPath() {
testBsContainsVar(0, Arrays.asList(new String[]{"A0", "A1"}));
}
public void testBsContainsVarB1ShortPath() {
testBsContainsVar(1, Arrays.asList(new String[]{"A0", "A1", "A2"}));
}
public void testBsContainsVarLongPath(long id, Collection ids) {
String testName = "testBsContainsVarLongPath_" + id + '_' + ids;
logger.log(BasicLevel.DEBUG, testName);
//NavigatorNodeFactory.logger = logger;
PersistenceManager pm = pmf.getPersistenceManager();
try {
Query query = pm.newQuery(Ref2Ref2AMMB.class);
String filter = "(ref.ref.bs.contains(b) && (b.name==name))";
query.declareParameters("String name");
query.declareVariables("BMMB b");
query.setFilter(filter);
Collection col = (Collection) query.execute("B" + id);
Collection res = new ArrayList();
Iterator iter = col.iterator();
while(iter.hasNext()) {
res.add(new Long(((Ref2Ref2AMMB) iter.next()).getId()));
}
query.close(col);
assertSameCollection(testName + ":", ids, res);
} catch (Exception e) {
Exception ie = ExceptionHelper.getNested(e);
logger.log(BasicLevel.ERROR, "", ie);
fail(ie.getMessage());
} finally {
pm.close();
}
}
public void testBsContainsVarB3EmptyLongPath() {
testBsContainsVarLongPath(3, Collections.EMPTY_LIST);
}
public void testBsContainsVarB0LongPath() {
testBsContainsVarLongPath(0, Arrays.asList(new Long[]{new Long(0), new Long(100)}));
}
public void testBsContainsVarB1LongPath() {
testBsContainsVarLongPath(1, Arrays.asList(new Long[]{new Long(0), new Long(100), new Long(200)}));
}
public void testBsIsEmpty(long ida, boolean isEmpty) {
logger.log(BasicLevel.DEBUG, "testBsIsEmpty_" + ida + '_' + isEmpty);
//fail("The isEmpty operator is not support in Medor");
PersistenceManager pm = pmf.getPersistenceManager();
try {
Query query = pm.newQuery(AMMB.class);
String filter = "((ida == a) && bs.isEmpty())";
query.declareParameters("long a");
query.setFilter(filter);
Collection col = (Collection) query.execute(new Long(ida));
Iterator iter = col.iterator();
Assert.assertEquals("The AMMB(" + ida + ").bs is " + (isEmpty
? "not " : "") + "empty.", isEmpty, iter.hasNext());
query.close(col);
} catch (Exception e) {
Exception ie = ExceptionHelper.getNested(e);
logger.log(BasicLevel.ERROR, "", ie);
fail(ie.getMessage());
} finally {
pm.close();
}
}
public void testBsIsEmptyA0() {
testBsIsEmpty(0, false);
}
public void testBsIsEmptyA3() {
testBsIsEmpty(3, true);
}
public void testBsIsEmptyWithNot(long ida, boolean hasResult) {
logger.log(BasicLevel.DEBUG, "testBsIsEmptyWithNot_" + ida + '_' + hasResult);
//fail("The isEmpty operator is not support in Medor");
PersistenceManager pm = pmf.getPersistenceManager();
try {
Query query = pm.newQuery(AMMB.class);
String filter = "(!(ida == a) && bs.isEmpty())";
query.declareParameters("long a");
query.setFilter(filter);
Collection col = (Collection) query.execute(new Long(ida));
Iterator iter = col.iterator();
Assert.assertEquals("It " + (hasResult
? " does not exist"
: "exists ") + " ida != "
+ ida + " with empty collection.",
hasResult, iter.hasNext());
query.close(col);
} catch (Exception e) {
Exception ie = ExceptionHelper.getNested(e);
logger.log(BasicLevel.ERROR, "", ie);
fail(ie.getMessage());
} finally {
pm.close();
}
}
public void testBsIsEmptyA0WithNot() {
testBsIsEmptyWithNot(0, true);
}
public void testBsIsEmptyA3WithNot() {
testBsIsEmptyWithNot(3, false);
}
public void testBsIsNotEmpty(long ida, boolean isNotEmpty, boolean globalNot) {
logger.log(BasicLevel.DEBUG, "testBsIsNotEmpty_" + ida + "_ise=" + isNotEmpty + "_gn=" + globalNot);
//fail("The isEmpty operator is not support in Medor");
PersistenceManager pm = pmf.getPersistenceManager();
try {
Query query = pm.newQuery(AMMB.class);
String filter = (globalNot
? "(!((ida != a) || bs.isEmpty()))"
: "((ida == a) && !(bs.isEmpty()))");
query.declareParameters("long a");
query.setFilter(filter);
Collection col = (Collection) query.execute(new Long(ida));
Iterator iter = col.iterator();
Assert.assertEquals("The AMMB(" + ida + ").bs is " + (isNotEmpty
? "" : "not ") + "empty.", isNotEmpty, iter.hasNext());
query.close(col);
} catch (Exception e) {
Exception ie = ExceptionHelper.getNested(e);
logger.log(BasicLevel.ERROR, "", ie);
fail(ie.getMessage());
} finally {
pm.close();
}
}
public void testBsIsNotEmptyA0Global() {
testBsIsNotEmpty(0, true, true);
}
public void testBsIsNotEmptyA0Local() {
testBsIsNotEmpty(0, true, false);
}
public void testBsIsNotEmptyA3Global() {
testBsIsNotEmpty(3, false, true);
}
public void testBsIsNotEmptyA3Local() {
testBsIsNotEmpty(3, false, false);
}
public void testNot(long ida, Collection idsa) {
logger.log(BasicLevel.DEBUG, "testNot_" + ida + '_' + idsa);
PersistenceManager pm = pmf.getPersistenceManager();
try {
Query query = pm.newQuery(AMMB.class);
String filter = "(!(ida == a))";
query.declareParameters("long a");
query.setFilter(filter);
Collection col = (Collection) query.execute(new Long(ida));
ArrayList res = new ArrayList(idsa.size());
Iterator iter = col.iterator();
while(iter.hasNext()) {
res.add(new Long(((AMMB) iter.next()).getIda()));
}
query.close(col);
this.assertSameCollection("", idsa, res);
} catch (Exception e) {
Exception ie = ExceptionHelper.getNested(e);
logger.log(BasicLevel.ERROR, "", ie);
fail(ie.getMessage());
} finally {
pm.close();
}
}
public void testNotA0() {
testNot(0, Arrays.asList(new Long[]{new Long(1), new Long(2), new Long(3)}));
}
public void testExtent(Class clazz, boolean withSubclass, Collection ids) {
logger.log(BasicLevel.DEBUG, "testExtent_" + clazz.getName() + "_sc=" + withSubclass);
PersistenceManager pm = pmf.getPersistenceManager();
try {
Extent e = pm.getExtent(clazz, withSubclass);
Assert.assertEquals("Bad candidate class on the extent",
clazz, e.getCandidateClass());
Assert.assertEquals("Bad sub class value on the extent",
withSubclass, e.hasSubclasses());
Iterator it = e.iterator();
ArrayList found = new ArrayList(ids.size());
while(it.hasNext()) {
Object o = it.next();
if (o == null) {
fail("Null object returned by the extent iterator of the class "
+ clazz.getName());
} else if (o instanceof AMMB) {
AMMB a = (AMMB) o;
found.add(new Long(a.getIda()));
} else if (o instanceof BMMB) {
BMMB b = (BMMB) o;
found.add(new Long(b.getIdb()));
} else {
fail("the test does not manage the class " + o.getClass().getName());
}
}
try {
it.remove();
fail("the remove operation does not throw an exception");
} catch (UnsupportedOperationException e1) {
}
assertSameCollection("Bad extent of the class " + clazz.getName(), ids, found);
e.close(it);
try {
it.hasNext();
fail("the iterator does not throw an exception on the use of " +
"the 'hasNext' method whereas it has been closed");
} catch (NoSuchElementException e1) {
}
try {
it.next();
fail("the iterator does not throw an exception on the use of " +
"the 'next' method whereas it has been closed");
} catch (NoSuchElementException e1) {
}
e = pm.getExtent(clazz, withSubclass);
Iterator[] its = new Iterator[5];
for(int i=0; i<its.length; i++) {
its[i] = e.iterator();
}
e.closeAll();
for(int i=0; i<its.length; i++) {
try {
its[i].next();
fail("the iterator " + i +" does not throw an exception on "
+ "the use of the 'next' method whereas all"
+ " iterator have been closed");
} catch (NoSuchElementException e1) {
}
}
it = e.iterator();
for(int i=0; i<ids.size(); i++) {
try {
it.next();
} catch (NoSuchElementException e1) {
Assert.assertEquals("Bad size: ", ids.size(), i);
}
}
e.close(it);
} catch (Exception e) {
Exception ie = ExceptionHelper.getNested(e);
logger.log(BasicLevel.ERROR, "", ie);
fail(ie.getMessage());
} finally {
pm.close();
}
}
public void testExtentAMMBfalse() {
ArrayList al = new ArrayList(POBuilder.NB_XMMB);
for(int i=0; i<POBuilder.NB_XMMB; i++) {
al.add(new Long(i));
}
testExtent(AMMB.class, false, al);
}
public void testExtentBMMBfalse() {
ArrayList al = new ArrayList(POBuilder.NB_XMMB);
for(int i=0; i<POBuilder.NB_XMMB; i++) {
al.add(new Long(i));
}
testExtent(BMMB.class, false, al);
}
public void testQueryBasedOnExtent() {
Class clazz = AMMB.class;
boolean withSubclass = false;
logger.log(BasicLevel.DEBUG, "testExtent_" + clazz.getName() + "_sc=" + withSubclass);
PersistenceManager pm = pmf.getPersistenceManager();
try {
Extent e = pm.getExtent(clazz, false);
Query q = pm.newQuery(e);
Collection c = (Collection) q.execute();
Assert.assertEquals("bad size", POBuilder.NB_XMMB, c.size());
q.close(c);
} catch (Exception e) {
Exception ie = ExceptionHelper.getNested(e);
logger.log(BasicLevel.ERROR, "", ie);
fail(ie.getMessage());
} finally {
pm.close();
}
}
public void testSequenceIdNavigateToPrimitive() {
logger.log(BasicLevel.DEBUG, "testSequenceIdNavigateToPrimitive");
PersistenceManager pm = pmf.getPersistenceManager();
try {
Query query = pm.newQuery(Ref2AutoIncFieldId.class);
query.setFilter("(simpleRef.f1 == \"toto\")");
Collection col = (Collection) query.execute();
Iterator iter = col.iterator();
Assert.assertTrue("The query result is empty", !iter.hasNext());
query.close(col);
} catch (Exception e) {
Exception ie = ExceptionHelper.getNested(e);
logger.log(BasicLevel.ERROR, "", ie);
fail(ie.getMessage());
} finally {
pm.close();
}
}
public void testSequenceIdNavigateToPrimitive2() {
logger.log(BasicLevel.DEBUG, "testSequenceIdNavigateToPrimitive");
PersistenceManager pm = pmf.getPersistenceManager();
try {
Query query = pm.newQuery(AutoIncFieldId.class);
query.setFilter("(independantRef.f1 == \"toto\")");
query.setOrdering("independantRef.f1 ascending");
Collection col = (Collection) query.execute();
Iterator iter = col.iterator();
Assert.assertTrue("The query result is empty", !iter.hasNext());
query.close(col);
} catch (Exception e) {
Exception ie = ExceptionHelper.getNested(e);
logger.log(BasicLevel.ERROR, "", ie);
fail(ie.getMessage());
} finally {
pm.close();
}
}
public void testNotIgnoreCache() {
logger.log(BasicLevel.DEBUG, "testSequenceIdNavigateToPrimitive");
PersistenceManager pm = pmf.getPersistenceManager();
BasicA ba = new BasicA();
ba.writeF1("testNotIgnoreCache1");
ba.writeF2(1);
pm.makePersistent(ba);
pm.close();
pm = pmf.getPersistenceManager();
ba.writeF1("testNotIgnoreCache2");
pm.setIgnoreCache(false);
Assert.assertTrue("Bad ignore cache value", !pm.getIgnoreCache());
Query query = pm.newQuery(BasicA.class);
query.setFilter("(f1 == \"testNotIgnoreCache2\")");
Collection col = (Collection) query.execute();
assertEquals("The cache is ignored", 1, col.size());
query.close(col);
pm.close();
pm = pmf.getPersistenceManager();
pm.currentTransaction().begin();
pm.deletePersistent(ba);
pm.currentTransaction().commit();
pm.close();
}
public void testAvgSingle() {
testAggregateSingle("AVG(salary)", new Float(3250), false);
testAggregateSingle("avg(salary)", new Float(3250), false);
testAggregateSingle("AVG(salary)", new Float(3250), true);
testAggregateSingle("avg(salary)", new Float(3250), true);
}
public void testSumSingle() {
testAggregateSingle("SUM(salary)", new Float(13000), false);
testAggregateSingle("sum(salary)", new Float(13000), false);
testAggregateSingle("SUM(salary)", new Float(13000), true);
testAggregateSingle("sum(salary)", new Float(13000), true);
}
public void testMaxSingle() {
testAggregateSingle("MAX(salary)", new Float(4000), false);
testAggregateSingle("max(salary)", new Float(4000), false);
testAggregateSingle("MAX(salary)", new Float(4000), true);
testAggregateSingle("max(salary)", new Float(4000), true);
}
public void testMinSingle() {
testAggregateSingle("MIN(salary)", new Float(2999), false);
testAggregateSingle("min(salary)", new Float(2999), false);
testAggregateSingle("MIN(salary)", new Float(2999), true);
testAggregateSingle("min(salary)", new Float(2999), true);
}
public void testCountSingle() {
testAggregateSingle("COUNT(salary)", new Long(4), false);
testAggregateSingle("count(salary)", new Long(4), false);
testAggregateSingle("count(this)", new Long(4), false);
testAggregateSingle("count(*)", new Long(4), false);
testAggregateSingle("COUNT(salary)", new Long(4), true);
testAggregateSingle("count(salary)", new Long(4), true);
testAggregateSingle("count(this)", new Long(4), true);
testAggregateSingle("count(*)", new Long(4), true);
}
public void testAggregateSingle(String select, Object result, boolean unique) {
logger.log(BasicLevel.DEBUG, "testAggregateSingle(" + select + ", " + result + ")");
PersistenceManager pm = pmf.getPersistenceManager();
try {
Query query = pm.newQuery(Employee.class);
query.setResult(select);
query.setUnique(unique);
Object res = query.execute();
if (unique) {
assertEquals("Bad result", result, res);
} else {
Iterator it = ((List) res).iterator();
assertTrue("Not result!", it.hasNext());
Object o = it.next();
assertNotNull("Result is null", o);
assertEquals("Bad result type: ", o.getClass(), result.getClass());
assertEquals("Bad result value", o, result);
assertTrue("More than one result!", !it.hasNext());
}
query.closeAll();
} catch (JDOException e) {
Exception ie = ExceptionHelper.getNested(e);
logger.log(BasicLevel.ERROR, "", ie);
fail(ie.getMessage());
} finally {
pm.close();
}
}
public void testSingleField() {
logger.log(BasicLevel.DEBUG, "testSingleField");
PersistenceManager pm = pmf.getPersistenceManager();
try {
Query query = pm.newQuery(Employee.class);
query.setResult("name");
Collection col = (Collection) query.execute();
assertSameCollection("Bad name collection",
Arrays.asList(POBuilder.names),col);
query.close(col);
} catch (JDOException e) {
Exception ie = ExceptionHelper.getNested(e);
logger.log(BasicLevel.ERROR, "", ie);
fail(ie.getMessage());
} finally {
pm.close();
}
}
public void testSingleFieldRef() {
logger.log(BasicLevel.DEBUG, "testSingleFieldRef");
PersistenceManager pm = pmf.getPersistenceManager();
try {
Query query = pm.newQuery(Employee.class);
query.setResult("dept");
List list = (List) query.execute();
assertEquals("bad collection size", 4, list.size());
assertEquals("Bad dept", POBuilder.depName,
((Department) list.get(0)).getName());
assertEquals("0!=1", list.get(0), list.get(1));
assertEquals("1!=2", list.get(1), list.get(2));
assertEquals("2!=3", list.get(2), list.get(3));
query.close(list);
} catch (JDOException e) {
Exception ie = ExceptionHelper.getNested(e);
logger.log(BasicLevel.ERROR, "", ie);
fail(ie.getMessage());
} finally {
pm.close();
}
}
public void testDistinctSingleFieldRef() {
logger.log(BasicLevel.DEBUG, "testDistinctSingleFieldRef");
PersistenceManager pm = pmf.getPersistenceManager();
try {
Query query = pm.newQuery(Employee.class);
query.setResult("distinct dept");
Collection col = (Collection) query.execute();
List list = (List) query.execute();
assertEquals("bad collection size", 1, list.size());
assertEquals("Bad dept", POBuilder.depName,
((Department) list.get(0)).getName());
query.close(col);
} catch (JDOException e) {
Exception ie = ExceptionHelper.getNested(e);
logger.log(BasicLevel.ERROR, "", ie);
fail(ie.getMessage());
} finally {
pm.close();
}
}
public static class StringFloat {
public String name;
public Float value;
public StringFloat(String n, Float v) {
name = n;
value = v;
}
}
public void testCompositeResultWithUserClass() {
testCompositeResult(true);
}
public void testCompositeResultWithoutUserClass() {
testCompositeResult(false);
}
public void testCompositeResult(boolean withUserClassResult) {
logger.log(BasicLevel.DEBUG, "testUserClassResult");
PersistenceManager pm = pmf.getPersistenceManager();
try {
Query query = pm.newQuery(Employee.class);
query.setResult("distinct dept.name, salary");
if (withUserClassResult) {
query.setResultClass(StringFloat.class);
}
Collection col = (Collection) query.execute();
Iterator it = col.iterator();
query.closeAll();
} catch (JDOException e) {
Exception ie = ExceptionHelper.getNested(e);
logger.log(BasicLevel.ERROR, "", ie);
fail(ie.getMessage());
} finally {
pm.close();
}
}
public void testCompositeResultAgregWithUserClass() {
testCompositeResultAgreg(true);
}
public void testCompositeResultAgregWithoutUserClass() {
testCompositeResultAgreg(false);
}
public void testCompositeResultAgreg(boolean withUserClassResult) {
logger.log(BasicLevel.DEBUG, "testUserClassResult");
PersistenceManager pm = pmf.getPersistenceManager();
try {
Query query = pm.newQuery(Employee.class);
query.setResult("dept.name, avg(salary)");
if (withUserClassResult) {
query.setResultClass(StringFloat.class);
}
query.setGrouping("dept.name");
Collection col = (Collection) query.execute();
Iterator it = col.iterator();
query.closeAll();
} catch (JDOException e) {
Exception ie = ExceptionHelper.getNested(e);
logger.log(BasicLevel.ERROR, "", ie);
fail(ie.getMessage());
} finally {
pm.close();
}
}
public void _testCompositeWithRefResultAgregWithUserClass() {
testCompositeWithRefResultAgreg(true);
}
public void testCompositeWithRefResultAgregWithoutUserClass() {
testCompositeWithRefResultAgreg(false);
}
public void testCompositeWithRefResultAgreg(boolean withUserClassResult) {
logger.log(BasicLevel.DEBUG, "testUserClassResult");
PersistenceManager pm = pmf.getPersistenceManager();
try {
Query query = pm.newQuery(Employee.class);
query.setResult("avg(salary)");
if (withUserClassResult) {
query.setResultClass(StringFloat.class);
}
query.setGrouping("dept");
Collection col = (Collection) query.execute();
Iterator it = col.iterator();
query.closeAll();
} catch (JDOException e) {
Exception ie = ExceptionHelper.getNested(e);
logger.log(BasicLevel.ERROR, "", ie);
fail(ie.getMessage());
} finally {
pm.close();
}
}
public void testUserCacheSingle() {
logger.log(BasicLevel.DEBUG, "testUserCacheSingle");
PersistenceManager pm = pmf.getPersistenceManager();
pm.currentTransaction().begin();
final String n = "testUserCacheSingle_";
for(int i=0; i<10; i++) {
Product p = new Product(i);
p.setProductName(n + i);
pm.makePersistent(p);
}
pm.currentTransaction().commit();
try {
pm.currentTransaction().begin();
Query query = pm.newQuery(Product.class);
query.setFilter("productName == p");
query.declareParameters("String p");
query.setUnique(true);
final String id = n + 3;
Product p = (Product) query.execute(id); //no query
assertNotNull("Null value for " + id, p);
p.setProductName(id + "bis");
//Check that the old value is unbound
p = (Product) query.execute(id); //query
assertNull("Old value not unbound from the user cache, " + id, p);
p = (Product) query.execute(id + "bis");//query because the cache
// does not contains the old value neither the new value
assertNotNull("Null value for " + id + "bis", p);
p = (Product) query.execute(n + 10); //query because the object does not exist
assertNull("Non null value for " + n + 10, p);
pm.currentTransaction().commit();
//At this time, the user cache has been updated with the modified Product
pm.currentTransaction().begin();
p = (Product) query.execute(id + "bis"); //no query
assertNotNull("Null value for " + id + "bis", p);
pm.currentTransaction().commit();
pm.evictAll();
pm.currentTransaction().begin();
p = (Product) query.execute(id + "bis"); //query
assertNotNull("Null value for " + id + "bis", p);
pm.currentTransaction().commit();
pm.currentTransaction().begin();
Extent e = pm.getExtent(Product.class);
for (Iterator iter = e.iterator(); iter.hasNext();) {
pm.deletePersistent(iter.next());
}
pm.currentTransaction().commit();
} catch (JDOException e) {
Exception ie = ExceptionHelper.getNested(e);
logger.log(BasicLevel.ERROR, "", ie);
fail(ie.getMessage());
} finally {
pm.close();
}
}
public void testUserCacheInheritance() {
logger.log(BasicLevel.DEBUG, "testUserCacheInheritance");
PersistenceManager pm = pmf.getPersistenceManager();
pm.currentTransaction().begin();
final String n = "testUserCacheInheritance_";
for(int i=0; i<10; i++) {
org.objectweb.speedo.pobjects.inheritance.userCache.GeoRef geoRef =
new org.objectweb.speedo.pobjects.inheritance.userCache.GeoRef(n + i);
pm.makePersistent(geoRef);
}
pm.currentTransaction().commit();
try {
pm.currentTransaction().begin();
Extent e = pm.getExtent(Litem.class, true);//with subclasses
Query query = pm.newQuery(e);
query.setFilter("name == id");
query.declareParameters("String id");
query.setUnique(true);
final String id = n + 3;
Litem litem = (Litem) query.execute(id);//no query
assertNotNull("Null value for " + id, litem);
litem.setName(id + "bis");
//Check that the old value is unbound
litem = (Litem) query.execute(id);//query
assertNull("Old value not unbound from the user cache, " + id, litem);
litem = (Litem) query.execute(id + "bis");//query
assertNotNull("Null value for " + id + "bis", litem);
litem = (Litem) query.execute(n + 10);//query
assertNull("Non null value for " + n + 10, litem);
pm.currentTransaction().commit();
pm.evictAll();
pm.currentTransaction().begin();
litem = (Litem) query.execute(id + "bis"); //query
assertNotNull("Null value for " + id + "bis", litem);
pm.currentTransaction().commit();
pm.currentTransaction().begin();
String myId = n+1;
litem = (Litem) query.execute(myId);//no query
assertNotNull("Null value for " + myId, litem);
litem = (Litem) query.execute(myId);//no query
assertNotNull("Null value for " + myId, litem);
pm.currentTransaction().commit();
pm.currentTransaction().begin();
e = pm.getExtent(Litem.class, true);
for (Iterator iter = e.iterator(); iter.hasNext();) {
pm.deletePersistent(iter.next());
}
pm.currentTransaction().commit();
} catch (JDOException e) {
Exception ie = ExceptionHelper.getNested(e);
logger.log(BasicLevel.ERROR, "", ie);
fail(ie.getMessage());
} finally {
pm.close();
}
}
public void testNotContains() {
logger.log(BasicLevel.DEBUG, "testUserCacheSingle");
PersistenceManager pm = pmf.getPersistenceManager();
Query q = pm.newQuery(Group.class);
q.declareParameters("String p1");
q.declareVariables("User u");
q.setFilter("!(this.users.contains(u)) && (u.name == p1)");
Collection c = (Collection) q.execute("user_g0_u0");
Collection founds = new ArrayList(c.size());
for (Iterator iter = c.iterator(); iter.hasNext();) {
Group g = (Group) iter.next();
founds.add(g.getName());
}
q.closeAll();
pm.close();
assertSameCollection("Bad group found",
Arrays.asList(new String[]{"group_1", "group_2"}),
founds);
}
public final static int NB_GROUP = 2;
public final static int NB_USER_PER_GROUP = 2;
protected GroupUser commonUser = new GroupUser("user_0and2");
public void notContainsInheritanceABuilder() {
PersistenceManager pm = pmf.getPersistenceManager();
pm.currentTransaction().begin();
//add newsgroup_0 -> [user_0and2]
NewsGroup ng0 = new NewsGroup("newsgroup_0");
Collection users = ng0.getUsers();
users.add(commonUser);
pm.makePersistent(ng0);
//add newsgroup_1 -> [user_1]
NewsGroup ng1 = new NewsGroup("newsgroup_1");
users = ng1.getUsers();
users.add(new GroupUser("user_1"));
pm.makePersistent(ng1);
pm.currentTransaction().commit();
pm.close();
}
//not contains user_Oand2 --> newsgroup_1
public void testNotContainsInheritanceA1() {
notContainsInheritanceABuilder();
logger.log(BasicLevel.DEBUG, "testNotContainsInheritanceA1");
try {
notContainsInheritance("user_0and2", new String[]{"newsgroup_1"});
} finally {
removingOfPersistentObject();
}
}
//not contains user_1 --> newsgroup_0
public void testNotContainsInheritanceA2() {
notContainsInheritanceABuilder();
logger.log(BasicLevel.DEBUG, "testNotContainsInheritanceA2");
try {
notContainsInheritance("user_1", new String[]{"newsgroup_0"});
} finally {
removingOfPersistentObject();
}
}
//not contains dummy --> all
public void testNotContainsInheritanceA3() {
notContainsInheritanceABuilder();
logger.log(BasicLevel.DEBUG, "testNotContainsInheritanceA3");
try {
notContainsInheritance("dummy", new String[]{"newsgroup_0", "newsgroup_1"});
} finally {
removingOfPersistentObject();
}
}
public void notContainsInheritanceBBuilder() {
notContainsInheritanceABuilder();
PersistenceManager pm = pmf.getPersistenceManager();
//add newsgroup_2 -> [user_0and2]
NewsGroup ng = new NewsGroup("newsgroup_2");
Collection users = ng.getUsers();
users.add(commonUser);
pm.makePersistent(ng);
pm.close();
}
//not contains user_Oand2 --> newsgroup_1
public void testNotContainsInheritanceB1() {
notContainsInheritanceBBuilder();
logger.log(BasicLevel.DEBUG, "testNotContainsInheritanceB1");
try {
notContainsInheritance("user_0and2", new String[]{"newsgroup_1"});
} finally {
removingOfPersistentObject();
}
}
//not contains user_1 --> newsgroup_0, newsgroup_2
public void testNotContainsInheritanceB2() {
notContainsInheritanceBBuilder();
logger.log(BasicLevel.DEBUG, "testNotContainsInheritanceB2");
try {
notContainsInheritance("user_1", new String[]{"newsgroup_0", "newsgroup_2"});
} finally {
removingOfPersistentObject();
}
}
//not contains dummy --> all
public void testNotContainsInheritanceB3() {
notContainsInheritanceBBuilder();
logger.log(BasicLevel.DEBUG, "testNotContainsInheritanceB3");
try {
notContainsInheritance("dummy", new String[]{"newsgroup_0", "newsgroup_1", "newsgroup_2"});
} finally {
removingOfPersistentObject();
}
}
public void notContainsInheritanceCBuilder() {
notContainsInheritanceBBuilder();
PersistenceManager pm = pmf.getPersistenceManager();
//add newsgroup_3 -> [empty]
NewsGroup ng = new NewsGroup("newsgroup_3");
pm.makePersistent(ng);
pm.close();
}
//not contains user_Oand2 --> newsgroup_1 and newsgroup_3
public void testNotContainsInheritanceC1() {
notContainsInheritanceCBuilder();
logger.log(BasicLevel.DEBUG, "testNotContainsInheritanceC1");
try {
notContainsInheritance("user_0and2", new String[]{"newsgroup_1", "newsgroup_3"});
} finally {
removingOfPersistentObject();
}
}
//not contains user_1 --> newsgroup_0, newsgroup_2, newsgroup_3
public void testNotContainsInheritanceC2() {
notContainsInheritanceCBuilder();
logger.log(BasicLevel.DEBUG, "testNotContainsInheritanceC2");
try {
notContainsInheritance("user_1", new String[]{"newsgroup_0", "newsgroup_2", "newsgroup_3"});
} finally {
removingOfPersistentObject();
}
}
//not contains dummy --> all
public void testNotContainsInheritanceC3() {
notContainsInheritanceCBuilder();
logger.log(BasicLevel.DEBUG, "testNotContainsInheritanceC3");
try {
notContainsInheritance("dummy", new String[]{"newsgroup_0", "newsgroup_1", "newsgroup_2", "newsgroup_3"});
} finally {
removingOfPersistentObject();
}
}
private void notContainsInheritance(String parameter, String[] resultExpected) {
PersistenceManager pm = pmf.getPersistenceManager();
Query q = pm.newQuery(NewsGroup.class);
q.declareParameters("String p1");
q.declareVariables("GroupUser u");
q.setFilter("!(this.users.contains(u)) && (u.name == p1)");
Collection c = (Collection) q.execute(parameter);
Collection founds = new ArrayList(c.size());
for (Iterator iter = c.iterator(); iter.hasNext();) {
NewsGroup ng = (NewsGroup) iter.next();
founds.add(ng.getName());
}
q.closeAll();
pm.close();
assertSameCollection("Bad group found",
Arrays.asList(resultExpected),
founds);
}
public void removingOfPersistentObject() {
PersistenceManager pm = pmf.getPersistenceManager();
try {
Class[] cs = new Class[]{NewsGroup.class,
GroupUser.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();
}
}
public void testNotContainsComposite() {
logger.log(BasicLevel.DEBUG, "testNotContainsComposite");
PersistenceManager pm = pmf.getPersistenceManager();
Query q = pm.newQuery(MailingList.class);
q.declareParameters("String p1, String p2");
q.declareVariables("GroupModerator gm");
q.setFilter("!(this.moderators.contains(gm)) && (gm.firstName == p1) && (gm.lastName == p2)");
Collection c = (Collection) q.execute("moderator_ml0", "mod0");
Collection founds = new ArrayList(c.size());
for (Iterator iter = c.iterator(); iter.hasNext();) {
MailingList ml = (MailingList) iter.next();
founds.add(ml.getName());
}
q.closeAll();
pm.close();
assertSameCollection("Bad group found",
Arrays.asList(new String[]{"mailinglist_1", "mailinglist_2"}),
founds);
}
public void testTwoSameContains() {
logger.log(BasicLevel.DEBUG, "testUserCacheSingle");
PersistenceManager pm = pmf.getPersistenceManager();
Query q = pm.newQuery(Group.class);
q.declareParameters("String p1, String p2");
q.declareVariables("User u1 ; User u2");
q.setFilter("((this.users.contains(u1)) && (u1.name == p1)) && ((this.users.contains(u2)) && (u2.name == p2))");
Collection c = (Collection) q.execute("user_g0_u0", "user_g0_u1");
Collection founds = new ArrayList(c.size());
for (Iterator iter = c.iterator(); iter.hasNext();) {
Group g = (Group) iter.next();
founds.add(g.getName());
}
q.closeAll();
pm.close();
assertSameCollection("Bad group found",
Arrays.asList(new String[]{"group_0"}),
founds);
}
public void testAutoRef() {
String nameToFind = "g1";
logger.log(BasicLevel.DEBUG, "testAutoRef");
PersistenceManager pm = pmf.getPersistenceManager();
String filter = "(previousRef != null) && (previousRef != this) && (previousRef.name == referenceName)";
Query q = pm.newQuery(GeoRef.class, filter);
q.declareParameters("String referenceName");
Collection results = (Collection) q.execute(nameToFind);
assertTrue("Result is empty", !results.isEmpty());
Iterator it = results.iterator();
while (it.hasNext()) {
GeoRef g = (GeoRef) it.next();
assertTrue("Name of previous ref is not correct", nameToFind.equals(g.getPreviousRef().getName()));
}
q.closeAll();
pm.close();
}
public void testSetRange() {
logger.log(BasicLevel.DEBUG, "testSetRange");
List expectedNames = POBuilder.getUserNames();
Collections.sort(expectedNames);
PersistenceManager pm = pmf.getPersistenceManager();
pm.currentTransaction().begin();
Query q = pm.newQuery(User.class);
q.setOrdering("name ascending");
q.setRange(0, 5);
Collection c = (Collection) q.execute();
ArrayList foundNames = new ArrayList();
for (Iterator it = c.iterator(); it.hasNext();) {
User u = (User) it.next();
foundNames.add(u.getName());
}
q.closeAll();
pm.currentTransaction().commit();
pm.evictAll();
assertEquals("not expected result", expectedNames.subList(0, 5), foundNames);
pm.currentTransaction().begin();
q = pm.newQuery(User.class);
q.setOrdering("name ascending");
q.setRange(2, 5);
c = (Collection) q.execute();
foundNames.clear();
for (Iterator it = c.iterator(); it.hasNext();) {
User u = (User) it.next();
foundNames.add(u.getName());
}
q.closeAll();
pm.currentTransaction().commit();
pm.evictAll();
assertEquals("not expected result", expectedNames.subList(2, 5), foundNames);
pm.currentTransaction().begin();
q = pm.newQuery(User.class);
q.setOrdering("name ascending");
c = (Collection) q.execute();
foundNames.clear();
for (Iterator it = c.iterator(); it.hasNext();) {
User u = (User) it.next();
foundNames.add(u.getName());
}
q.closeAll();
pm.currentTransaction().commit();
pm.evictAll();
assertEquals("not expected result", expectedNames, foundNames);
pm.currentTransaction().begin();
q = pm.newQuery(Group.class);
Query q2 = pm.newQuery(Group.class);
Collection usernames = Arrays.asList(new String[]{
"user_g0_u0","user_g0_u1","user_g1_u0"});
String var = "User u";
q.declareVariables(var);
q2.declareVariables(var);
String param = "Collection usernames";
q.declareParameters(param);
q2.declareParameters(param);
String filter = "(users.contains(u)) && usernames.contains(u.name)";
q.setFilter(filter);
q2.setFilter(filter);
q.setOrdering("name ascending");
q.setRange(0, 5);
q2.setOrdering("name ascending");
q2.setResult("count(*)");
q2.setUnique(true);
int count = ((Long) q2.execute(usernames)).intValue();
c = (Collection) q.execute(usernames);
int s = c.size();
q.closeAll();
q2.closeAll();
pm.evictAll();
assertEquals("Bad count result", 3, count);
assertEquals("Bad result size", 3, s);
pm.currentTransaction().begin();
q = pm.newQuery(Group.class);
q2 = pm.newQuery(Group.class);
usernames = Arrays.asList(new String[]{
"user_g0_u0","user_g0_u1","user_g1_u0"});
var = "User u";
q.declareVariables(var);
q2.declareVariables(var);
param = "Collection usernames";
q.declareParameters(param);
q2.declareParameters(param);
filter = "(users.contains(u)) && usernames.contains(u.name)";
q.setFilter(filter);
q2.setFilter(filter);
q.setGrouping("name");
q.setRange(0, 5);
q2.setGrouping("name");
q2.setResult("count(*)");
Collection c1 = (Collection) q2.execute(usernames);
Iterator itC1 = c1.iterator();
count = 0;
while (itC1.hasNext()) {
count += ((Long) itC1.next()).intValue();
}
c = (Collection) q.execute(usernames);
s = c.size();
q.closeAll();
q2.closeAll();
pm.currentTransaction().commit();
pm.close();
assertEquals("Bad count result", 3, count);
assertEquals("Bad result size", 3, s);
}
public void testSetRange2() {
logger.log(BasicLevel.DEBUG, "testSetRange2");
List expectedNames = Arrays.asList(POBuilder.names);
Collections.sort(expectedNames);
PersistenceManager pm = pmf.getPersistenceManager();
pm.currentTransaction().begin();
Query q = pm.newQuery(Employee.class, "dept.name == p1");
q.declareParameters("String p1");
q.setOrdering("name ascending");
q.setRange(2, 4);
Collection c = (Collection) q.execute(POBuilder.depName);
ArrayList foundNames = new ArrayList();
for (Iterator it = c.iterator(); it.hasNext();) {
Employee e = (Employee) it.next();
foundNames.add(e.getName());
}
q.closeAll();
pm.currentTransaction().commit();
pm.close();
assertEquals("not expected result", expectedNames.subList(2, 4), foundNames);
}
public void testNullEqualityWithPrimitive() {
PersistenceManager pm = pmf.getPersistenceManager();
Query q = pm.newQuery(Group.class);
q.setFilter("name != null");
Collection c = (Collection) q.execute();
int s = c.size();
q.closeAll();
pm.close();
assertEquals("Bad result size", 3, s);
}
}