use of org.jpox.samples.dependentfield.DependentHolder in project tests by datanucleus.
the class DependentFieldTest method testDependentKeysRemovalUsingForeignKey.
/**
* test removal of dependent key from a map using ForeignKey.
*/
public void testDependentKeysRemovalUsingForeignKey() {
try {
DependentHolder field;
Object fieldObjectId = null;
Object[] keys = new Object[COLLECTION_SIZE * 2];
Object[] values = new Object[COLLECTION_SIZE * 2];
Object[] keyObjectId = new Object[COLLECTION_SIZE * 2];
boolean[] expectedDelete = new boolean[COLLECTION_SIZE * 2];
// JoinTable map
field = new DependentHolder(400, "field400");
int keyNumber = 0;
for (int i = 0; i < COLLECTION_SIZE; i++) {
keys[keyNumber] = new DependentElement7(400 + keyNumber, "mapDepKey" + i);
values[keyNumber] = new DependentElement7(450 + keyNumber, "mapDepValue" + i);
field.getMapDependentKeys2().put(keys[keyNumber], values[keyNumber]);
expectedDelete[keyNumber] = true;
keyNumber++;
}
for (int i = 0; i < COLLECTION_SIZE; i++) {
keys[keyNumber] = new DependentElement8(400 + keyNumber, "mapDepKey" + i);
values[keyNumber] = new DependentElement8(450 + keyNumber, "mapDepValue" + i);
field.getMapNonDependentKeys2().put(keys[keyNumber], values[keyNumber]);
expectedDelete[keyNumber] = false;
keyNumber++;
}
PersistenceManager pm = pmf.getPersistenceManager();
Transaction tx = pm.currentTransaction();
DependentHolder loaded;
try {
// Persist the objects
tx.begin();
pm.makePersistent(field);
tx.commit();
// Access the ids of the objects
fieldObjectId = pm.getObjectId(field);
for (int i = 0; i < COLLECTION_SIZE * 2; i++) {
keyObjectId[i] = pm.getObjectId(keys[i]);
}
tx.begin();
loaded = (DependentHolder) pm.getObjectById(fieldObjectId, true);
// make sure persistence is fine
assertEquals(COLLECTION_SIZE, loaded.getMapDependentKeys2().size());
assertEquals(COLLECTION_SIZE, loaded.getMapNonDependentKeys2().size());
tx.commit();
} catch (Exception e) {
e.printStackTrace();
LOG.error(e);
fail("Exception thrown while persisting dependent field data : " + e.getMessage());
} finally {
if (tx.isActive()) {
tx.rollback();
}
pm.close();
}
pm = pmf.getPersistenceManager();
tx = pm.currentTransaction();
try {
// Remove the elements from each Map
// This operation should remove the dependent keys and leave the
// non-dependent keys
tx.begin();
loaded = (DependentHolder) pm.getObjectById(fieldObjectId, true);
keyNumber = 0;
for (int i = 0; i < COLLECTION_SIZE; i++) {
Object retrievedKey = pm.getObjectById(keyObjectId[keyNumber]);
loaded.getMapDependentKeys2().remove(retrievedKey);
keyNumber++;
}
for (int i = 0; i < COLLECTION_SIZE; i++) {
Object retrievedKey = pm.getObjectById(keyObjectId[keyNumber]);
loaded.getMapNonDependentKeys2().remove(retrievedKey);
keyNumber++;
}
tx.commit();
} catch (Exception e) {
e.printStackTrace();
LOG.error(e);
fail("Exception thrown while persisting dependent field data : " + e.getMessage());
} finally {
if (tx.isActive()) {
tx.rollback();
}
pm.close();
}
// Check the results
pm = pmf.getPersistenceManager();
tx = pm.currentTransaction();
try {
tx.begin();
// Check that the maps are now empty
loaded = (DependentHolder) pm.getObjectById(fieldObjectId, true);
assertEquals(0, loaded.getMapDependentKeys2().size());
assertEquals(0, loaded.getMapNonDependentKeys2().size());
// non-dependent keys
for (int i = 0; i < COLLECTION_SIZE * 2; i++) {
try {
pm.getObjectById(keyObjectId[i]);
if (expectedDelete[i]) {
fail("Key " + i + " hasnt been deleted yet should have been since it is dependent and was removed from the ForeignKey map");
}
} catch (JDOObjectNotFoundException e) {
if (!expectedDelete[i]) {
fail("Key " + i + " has been deleted yet should only have been nulled when being removed from the ForeignKey map");
}
}
}
tx.commit();
} catch (Exception e) {
e.printStackTrace();
LOG.error(e);
fail("Exception thrown while persisting dependent field data : " + e.getMessage());
} finally {
if (tx.isActive()) {
tx.rollback();
}
pm.close();
}
} finally {
// Clean out our data
clearDependentData(pmf);
}
}
use of org.jpox.samples.dependentfield.DependentHolder in project tests by datanucleus.
the class DependentFieldTest method testNullify1to1Relation.
/**
* Test the nullification of a 1-1 relation marked as dependent.
*/
public void testNullify1to1Relation() {
try {
Object holderId = null;
Object dependentObjectId = null;
// Persist the objects
PersistenceManager pm = pmf.getPersistenceManager();
Transaction tx = pm.currentTransaction();
try {
DependentHolder field = new DependentHolder(0, "field0");
DependentElement dependent = new DependentElement(0, "el" + 0);
field.setElement(dependent);
// Persist the objects
tx.begin();
pm.makePersistent(field);
tx.commit();
holderId = pm.getObjectId(field);
dependentObjectId = pm.getObjectId(dependent);
} catch (Exception e) {
e.printStackTrace();
LOG.error(e);
fail("Exception thrown while persisting dependent field data : " + e.getMessage());
} finally {
if (tx.isActive()) {
tx.rollback();
}
pm.close();
}
// Retrieve the object and nullify the element
pm = pmf.getPersistenceManager();
tx = pm.currentTransaction();
try {
// This operation should remove the dependent element
tx.begin();
DependentHolder loaded = (DependentHolder) pm.getObjectById(holderId, true);
loaded.setElement(null);
tx.commit();
} catch (Exception e) {
e.printStackTrace();
LOG.error(e);
fail("Exception thrown while persisting dependent field data : " + e.getMessage());
} finally {
if (tx.isActive()) {
tx.rollback();
}
pm.close();
}
// Check the results
pm = pmf.getPersistenceManager();
tx = pm.currentTransaction();
try {
tx.begin();
// Check that the dependent field is empty
DependentHolder loaded = (DependentHolder) pm.getObjectById(holderId, true);
assertNull(loaded.getElement());
// Check that the dependent element has been removed.
try {
DependentElement retrievedElement = (DependentElement) pm.getObjectById(dependentObjectId);
if (retrievedElement != null) {
fail("Dependent field hasnt been deleted yet should have been since it is dependent and was removed from the 1-1 Relation");
}
} catch (JDOObjectNotFoundException e) {
}
tx.commit();
} catch (Exception e) {
e.printStackTrace();
LOG.error(e);
fail("Exception thrown while persisting dependent field data : " + e.getMessage());
} finally {
if (tx.isActive()) {
tx.rollback();
}
pm.close();
}
} finally {
// Clean out our data
clearDependentData(pmf);
}
}
use of org.jpox.samples.dependentfield.DependentHolder in project tests by datanucleus.
the class DependentFieldTest method testDependentKeysRemovalUsingJoinTable.
/**
* test removal of dependent key from a map using JoinTable.
*/
public void testDependentKeysRemovalUsingJoinTable() {
try {
DependentHolder holder;
Object fieldObjectId = null;
DependentElement[] keys = new DependentElement[COLLECTION_SIZE * 2];
DependentElement[] values = new DependentElement[COLLECTION_SIZE * 2];
Object[] keyObjectId = new Object[COLLECTION_SIZE * 2];
boolean[] expectedDelete = new boolean[COLLECTION_SIZE * 2];
// JoinTable map
holder = new DependentHolder(300, "field300");
int keyNumber = 0;
for (int i = 0; i < COLLECTION_SIZE; i++) {
keys[keyNumber] = new DependentElement(300 + keyNumber, "mapDepKey" + i);
values[keyNumber] = new DependentElement(350 + keyNumber, "mapDepValue" + i);
holder.getMapDependentKeys1().put(keys[keyNumber], values[keyNumber]);
expectedDelete[keyNumber] = true;
keyNumber++;
}
for (int i = 0; i < COLLECTION_SIZE; i++) {
keys[keyNumber] = new DependentElement(300 + keyNumber, "mapDepKey" + i);
values[keyNumber] = new DependentElement(350 + keyNumber, "mapDepValue" + i);
holder.getMapNonDependentKeys1().put(keys[keyNumber], values[keyNumber]);
expectedDelete[keyNumber] = false;
keyNumber++;
}
PersistenceManager pm = pmf.getPersistenceManager();
Transaction tx = pm.currentTransaction();
DependentHolder loaded;
try {
// Persist the objects
tx.begin();
pm.makePersistent(holder);
tx.commit();
// Access the ids of the objects
fieldObjectId = pm.getObjectId(holder);
for (int i = 0; i < COLLECTION_SIZE * 2; i++) {
keyObjectId[i] = pm.getObjectId(keys[i]);
}
tx.begin();
loaded = (DependentHolder) pm.getObjectById(fieldObjectId, true);
// make sure persistence is fine
assertEquals(COLLECTION_SIZE, loaded.getMapDependentKeys1().size());
assertEquals(COLLECTION_SIZE, loaded.getMapNonDependentKeys1().size());
tx.commit();
} catch (Exception e) {
e.printStackTrace();
LOG.error(e);
fail("Exception thrown while persisting dependent field data : " + e.getMessage());
} finally {
if (tx.isActive()) {
tx.rollback();
}
pm.close();
}
pm = pmf.getPersistenceManager();
tx = pm.currentTransaction();
try {
// Remove the elements from each Map
// This operation should remove the dependent keys and leave the non-dependent keys
tx.begin();
loaded = (DependentHolder) pm.getObjectById(fieldObjectId, true);
keyNumber = 0;
for (int i = 0; i < COLLECTION_SIZE; i++) {
DependentElement retrievedKey = (DependentElement) pm.getObjectById(keyObjectId[keyNumber]);
loaded.getMapDependentKeys1().remove(retrievedKey);
keyNumber++;
}
for (int i = 0; i < COLLECTION_SIZE; i++) {
DependentElement retrievedKey = (DependentElement) pm.getObjectById(keyObjectId[keyNumber]);
loaded.getMapNonDependentKeys1().remove(retrievedKey);
keyNumber++;
}
tx.commit();
} catch (Exception e) {
e.printStackTrace();
LOG.error(e);
fail("Exception thrown while persisting dependent field data : " + e.getMessage());
} finally {
if (tx.isActive()) {
tx.rollback();
}
pm.close();
}
// Check the results
pm = pmf.getPersistenceManager();
tx = pm.currentTransaction();
try {
tx.begin();
// Check that the maps are now empty
loaded = (DependentHolder) pm.getObjectById(fieldObjectId, true);
assertEquals(0, loaded.getMapDependentKeys1().size());
assertEquals(0, loaded.getMapNonDependentKeys1().size());
// Check that the dependent keys have been removed but not the non-dependent keys
for (int i = 0; i < COLLECTION_SIZE * 2; i++) {
try {
pm.getObjectById(keyObjectId[i]);
if (expectedDelete[i]) {
fail("Key " + i + " hasnt been deleted yet should have been since it is dependent and was removed from the JoinTable map");
}
} catch (JDOObjectNotFoundException e) {
if (!expectedDelete[i]) {
fail("Key " + i + " has been deleted yet should only have been nulled when being removed from the JoinTable map");
}
}
}
tx.commit();
} catch (Exception e) {
e.printStackTrace();
LOG.error(e);
fail("Exception thrown while persisting dependent field data : " + e.getMessage());
} finally {
if (tx.isActive()) {
tx.rollback();
}
pm.close();
}
} finally {
// Clean out our data
clearDependentData(pmf);
}
}
use of org.jpox.samples.dependentfield.DependentHolder in project tests by datanucleus.
the class DependentFieldTest method testDependentFieldsDeletion.
/**
* Test delete of objects with dependent fields using "deletePersistent".
* Container object "DependentField" contains
* <ul>
* <li>1-1 relation (dependent)</li>
* <li>2 join-table sets (1 dependent, 1 non-dependent)</li>
* <li>2 join-table lists (1 dependent, 1 non-dependent)</li>
* <li>8 maps (all combos of dependent, non-dependent)</li>
* <li>1 array (dependent)</li>
* </ul>
*/
public void testDependentFieldsDeletion() {
try {
// Populate the objects - add 2 elements to each set/list/map
int nextElement = 0;
DependentElement[] element = new DependentElement[ELEMENTS_SIZE];
Object[] elementObjectId = new Object[ELEMENTS_SIZE];
boolean[] expectedDelete = new boolean[ELEMENTS_SIZE];
for (int i = 0; i < ELEMENTS_SIZE; i++) {
element[i] = new DependentElement(i, "el" + i);
}
DependentHolder holder = new DependentHolder(0, "field0");
// 1-1 dependent
expectedDelete[nextElement] = true;
holder.setElement(element[nextElement++]);
int indexDependents = nextElement;
// a). dependents
for (int i = 0; i < COLLECTION_SIZE; i++) {
expectedDelete[nextElement] = true;
holder.getListDependent1().add(element[nextElement++]);
}
for (int i = 0; i < COLLECTION_SIZE; i++) {
expectedDelete[nextElement] = true;
expectedDelete[nextElement + 1] = true;
holder.getMapDependent1().put(element[nextElement++], element[nextElement++]);
}
for (int i = 0; i < COLLECTION_SIZE; i++) {
expectedDelete[nextElement] = true;
expectedDelete[nextElement + 1] = false;
holder.getMapDependentKeys1().put(element[nextElement++], element[nextElement++]);
}
for (int i = 0; i < COLLECTION_SIZE; i++) {
expectedDelete[nextElement] = false;
expectedDelete[nextElement + 1] = true;
holder.getMapDependentValues1().put(element[nextElement++], element[nextElement++]);
}
for (int i = 0; i < COLLECTION_SIZE; i++) {
expectedDelete[nextElement] = true;
holder.getSetDependent1().add(element[nextElement++]);
}
DependentElement[] array = new DependentElement[COLLECTION_SIZE];
for (int i = 0; i < COLLECTION_SIZE; i++) {
expectedDelete[nextElement] = true;
array[i] = element[nextElement++];
}
holder.setArrayDependent1(array);
// b). non dependents
for (int i = 0; i < COLLECTION_SIZE; i++) {
expectedDelete[nextElement] = false;
holder.getListNonDependent1().add(element[nextElement++]);
}
for (int i = 0; i < COLLECTION_SIZE; i++) {
expectedDelete[nextElement] = false;
expectedDelete[nextElement + 1] = false;
holder.getMapNonDependent1().put(element[nextElement++], element[nextElement++]);
}
for (int i = 0; i < COLLECTION_SIZE; i++) {
expectedDelete[nextElement] = false;
expectedDelete[nextElement + 1] = false;
holder.getMapNonDependentKeys1().put(element[nextElement++], element[nextElement++]);
}
for (int i = 0; i < COLLECTION_SIZE; i++) {
expectedDelete[nextElement] = false;
expectedDelete[nextElement + 1] = false;
holder.getMapNonDependentValues1().put(element[nextElement++], element[nextElement++]);
}
for (int i = 0; i < COLLECTION_SIZE; i++) {
expectedDelete[nextElement] = false;
holder.getSetNonDependent1().add(element[nextElement++]);
}
DependentElement[] nonArray = new DependentElement[COLLECTION_SIZE];
for (int i = 0; i < COLLECTION_SIZE; i++) {
expectedDelete[nextElement] = false;
nonArray[i] = element[nextElement++];
}
holder.setArrayNonDependent1(nonArray);
PersistenceManager pm = pmf.getPersistenceManager();
Object holderId;
DependentHolder loaded;
try {
// Persist the objects
pm.currentTransaction().begin();
pm.makePersistent(holder);
pm.currentTransaction().commit();
// Access the ids of the objects
holderId = pm.getObjectId(holder);
for (int i = 0; i < ELEMENTS_SIZE; i++) {
elementObjectId[i] = pm.getObjectId(element[i]);
}
pm.currentTransaction().begin();
loaded = (DependentHolder) pm.getObjectById(holderId, true);
// make sure persistence is fine
assertEquals(COLLECTION_SIZE, loaded.getListDependent1().size());
assertEquals(COLLECTION_SIZE, loaded.getMapDependent1().size());
assertEquals(COLLECTION_SIZE, loaded.getMapDependentKeys1().size());
assertEquals(COLLECTION_SIZE, loaded.getMapDependentValues1().size());
assertEquals(COLLECTION_SIZE, loaded.getSetDependent1().size());
assertEquals(COLLECTION_SIZE, loaded.getArrayDependent1().length);
assertEquals(COLLECTION_SIZE, loaded.getListNonDependent1().size());
assertEquals(COLLECTION_SIZE, loaded.getMapNonDependent1().size());
assertEquals(COLLECTION_SIZE, loaded.getMapNonDependentKeys1().size());
assertEquals(COLLECTION_SIZE, loaded.getMapNonDependentValues1().size());
assertEquals(COLLECTION_SIZE, loaded.getSetNonDependent1().size());
assertNotNull(loaded.getElement());
// Delete the container object
pm.deletePersistent(loaded);
pm.currentTransaction().commit();
// ====================================================================
// Check the existence of the various objects
// Only the non-dependent ones should exist
// ====================================================================
// Container object
pm.currentTransaction().begin();
boolean success = false;
try {
success = false;
loaded = (DependentHolder) pm.getObjectById(holderId, true);
} catch (JDOObjectNotFoundException ex) {
success = true;
} finally {
if (!success) {
fail("field should have been deleted");
}
}
// 1-1 element
try {
success = false;
pm.getObjectById(elementObjectId[0], true);
} catch (JDOObjectNotFoundException ex) {
success = true;
} finally {
if (!success) {
fail("dependent field element should have been deleted.");
}
}
// collection/map elements
for (int i = 0; i < COLLECTION_ELEMENTS_FOR_ALL_FIELDS; i++) {
try {
success = false;
Object pc = pm.getObjectById(elementObjectId[i + indexDependents], true);
if (!expectedDelete[i + indexDependents] && !JDOHelper.isDeleted(pc)) {
success = true;
}
} catch (JDOObjectNotFoundException ex) {
if (expectedDelete[i + indexDependents]) {
success = true;
}
} finally {
if (!success && expectedDelete[i + indexDependents]) {
fail("dependent field " + (i + indexDependents) + " should have been deleted.");
} else if (!success && !expectedDelete[i + indexDependents]) {
fail("dependent field " + (i + indexDependents) + " should have not been deleted.");
}
}
}
pm.currentTransaction().commit();
} finally {
if (pm.currentTransaction().isActive()) {
pm.currentTransaction().rollback();
}
pm.close();
}
} finally {
// Clean out our data
clearDependentData(pmf);
}
}
use of org.jpox.samples.dependentfield.DependentHolder in project tests by datanucleus.
the class DependentFieldTest method testDependentElementsRemovalUsingJoinTable.
/**
* test removal of dependent element from a set/list using JoinTable.
*/
public void testDependentElementsRemovalUsingJoinTable() {
try {
DependentHolder holder;
Object fieldObjectId = null;
DependentElement[] element = new DependentElement[COLLECTION_SIZE * 4];
Object[] elementObjectId = new Object[COLLECTION_SIZE * 4];
boolean[] expectedDelete = new boolean[COLLECTION_SIZE * 4];
holder = new DependentHolder(100, "field100");
int elementNumber = 0;
for (int i = 0; i < COLLECTION_SIZE; i++) {
element[elementNumber] = new DependentElement(100 + elementNumber, "setDepElement" + i);
holder.getSetDependent1().add(element[elementNumber]);
expectedDelete[elementNumber] = true;
elementNumber++;
}
for (int i = 0; i < COLLECTION_SIZE; i++) {
element[elementNumber] = new DependentElement(100 + elementNumber, "setElement" + i);
holder.getSetNonDependent1().add(element[elementNumber]);
expectedDelete[elementNumber] = false;
elementNumber++;
}
for (int i = 0; i < COLLECTION_SIZE; i++) {
element[elementNumber] = new DependentElement(100 + elementNumber, "listDepElement" + i);
holder.getListDependent1().add(element[elementNumber]);
expectedDelete[elementNumber] = true;
elementNumber++;
}
for (int i = 0; i < COLLECTION_SIZE; i++) {
element[elementNumber] = new DependentElement(100 + elementNumber, "listElement" + i);
holder.getListNonDependent1().add(element[elementNumber]);
expectedDelete[elementNumber] = false;
elementNumber++;
}
PersistenceManager pm = pmf.getPersistenceManager();
Transaction tx = pm.currentTransaction();
DependentHolder loaded;
try {
// Persist the objects
tx.begin();
pm.makePersistent(holder);
tx.commit();
// Access the ids of the objects
fieldObjectId = pm.getObjectId(holder);
for (int i = 0; i < COLLECTION_SIZE * 4; i++) {
elementObjectId[i] = pm.getObjectId(element[i]);
}
tx.begin();
loaded = (DependentHolder) pm.getObjectById(fieldObjectId, true);
// make sure persistence is fine
assertEquals(COLLECTION_SIZE, loaded.getSetDependent1().size());
assertEquals(COLLECTION_SIZE, loaded.getSetNonDependent1().size());
assertEquals(COLLECTION_SIZE, loaded.getListDependent1().size());
assertEquals(COLLECTION_SIZE, loaded.getListNonDependent1().size());
tx.commit();
} catch (Exception e) {
e.printStackTrace();
LOG.error(e);
fail("Exception thrown while persisting dependent field data : " + e.getMessage());
} finally {
if (tx.isActive()) {
tx.rollback();
}
pm.close();
}
pm = pmf.getPersistenceManager();
tx = pm.currentTransaction();
try {
// Remove the elements from each Set/List
// This operation should remove the dependent elements and leave the non-dependent elements
tx.begin();
loaded = (DependentHolder) pm.getObjectById(fieldObjectId, true);
elementNumber = 0;
for (int i = 0; i < COLLECTION_SIZE; i++) {
DependentElement retrievedElement = (DependentElement) pm.getObjectById(elementObjectId[elementNumber]);
loaded.getSetDependent1().remove(retrievedElement);
elementNumber++;
}
for (int i = 0; i < COLLECTION_SIZE; i++) {
DependentElement retrievedElement = (DependentElement) pm.getObjectById(elementObjectId[elementNumber]);
loaded.getSetNonDependent1().remove(retrievedElement);
elementNumber++;
}
for (int i = 0; i < COLLECTION_SIZE; i++) {
DependentElement retrievedElement = (DependentElement) pm.getObjectById(elementObjectId[elementNumber]);
loaded.getListDependent1().remove(retrievedElement);
elementNumber++;
}
for (int i = 0; i < COLLECTION_SIZE; i++) {
DependentElement retrievedElement = (DependentElement) pm.getObjectById(elementObjectId[elementNumber]);
loaded.getListNonDependent1().remove(retrievedElement);
elementNumber++;
}
tx.commit();
} catch (Exception e) {
e.printStackTrace();
LOG.error(e);
fail("Exception thrown while persisting dependent field data : " + e.getMessage());
} finally {
if (tx.isActive()) {
tx.rollback();
}
pm.close();
}
// Check the results
pm = pmf.getPersistenceManager();
tx = pm.currentTransaction();
try {
tx.begin();
// Check that the sets/lists are now empty
loaded = (DependentHolder) pm.getObjectById(fieldObjectId, true);
assertEquals(0, loaded.getSetDependent1().size());
assertEquals(0, loaded.getSetNonDependent1().size());
assertEquals(0, loaded.getListDependent1().size());
assertEquals(0, loaded.getListNonDependent1().size());
// Check that the dependent elements have been removed but not the non-dependent elements
for (int i = 0; i < COLLECTION_SIZE * 4; i++) {
try {
DependentElement retrievedElement = (DependentElement) pm.getObjectById(elementObjectId[i]);
if (retrievedElement != null && expectedDelete[i]) {
fail("Element " + i + " hasnt been deleted yet should have been since it is dependent and was removed from the JoinTable set/list");
}
} catch (JDOObjectNotFoundException e) {
if (!expectedDelete[i]) {
fail("Element " + i + " has been deleted yet should only have been nulled when being removed from the JoinTable set/list");
}
}
}
tx.commit();
} catch (Exception e) {
e.printStackTrace();
LOG.error(e);
fail("Exception thrown while persisting dependent field data : " + e.getMessage());
} finally {
if (tx.isActive()) {
tx.rollback();
}
pm.close();
}
} finally {
// Clean out our data
clearDependentData(pmf);
}
}
Aggregations