Examples with DependentElement1 org.jpox.samples.dependentfield.DependentElement1 used on opensource projects

Example 1 with DependentElement1

use of org.jpox.samples.dependentfield.DependentElement1 in project tests by datanucleus.

the class DependentFieldTest method initElementsForInverse.

private void initElementsForInverse(Object[] element, int testType) {
    element[0] = new DependentElement(0, "el" + 0);
    int index = 1;
    if (testType == TEST_LISTS) {
        for (int i = 0; i < (COLLECTION_SIZE * 2); i++) {
            element[index] = new DependentElement3(index, "el" + index);
            index++;
        }
        for (int i = 0; i < (COLLECTION_SIZE * 2); i++) {
            element[index] = new DependentElement4(index, "el" + index);
            index++;
        }
    } else if (testType == TEST_MAP) {
        String desc = "key";
        for (int i = 0; i < (COLLECTION_SIZE * 2); i++) {
            element[index] = new DependentElement9(index, desc + index);
            desc = desc.equals("key") ? "value" : "key";
            index++;
        }
        desc = "key";
        for (int i = 0; i < (COLLECTION_SIZE * 2); i++) {
            element[index] = new DependentElement10(index, desc + index);
            desc = desc.equals("key") ? "value" : "key";
            index++;
        }
    } else if (testType == TEST_MAP_KEYS) {
        String desc = "key";
        for (int i = 0; i < (COLLECTION_SIZE * 2); i++) {
            element[index] = new DependentElement7(index, desc + index);
            desc = desc.equals("key") ? "value" : "key";
            index++;
        }
        desc = "key";
        for (int i = 0; i < (COLLECTION_SIZE * 2); i++) {
            element[index] = new DependentElement8(index, desc + index);
            desc = desc.equals("key") ? "value" : "key";
            index++;
        }
    } else if (testType == TEST_MAP_VALUES) {
        String desc = "key";
        for (int i = 0; i < (COLLECTION_SIZE * 2); i++) {
            element[index] = new DependentElement5(index, desc + index);
            desc = desc.equals("key") ? "value" : "key";
            index++;
        }
        desc = "key";
        for (int i = 0; i < (COLLECTION_SIZE * 2); i++) {
            element[index] = new DependentElement6(index, desc + index);
            desc = desc.equals("key") ? "value" : "key";
            index++;
        }
    } else if (testType == TEST_SET) {
        for (int i = 0; i < (COLLECTION_SIZE * 2); i++) {
            element[index] = new DependentElement1(index, "el" + index);
            index++;
        }
        for (int i = 0; i < (COLLECTION_SIZE * 2); i++) {
            element[index] = new DependentElement2(index, "el" + index);
            index++;
        }
    }
}

Example 2 with DependentElement1

use of org.jpox.samples.dependentfield.DependentElement1 in project tests by datanucleus.

the class DependentFieldTest method testDependentElementsRemovalUsingForeignKey.

/**
 * test removal of dependent element from a set/list using ForeignKey.
 */
public void testDependentElementsRemovalUsingForeignKey() {
    try {
        DependentHolder field;
        Object fieldObjectId = null;
        Object[] elements = new Object[COLLECTION_SIZE * 4];
        Object[] elementObjectId = new Object[COLLECTION_SIZE * 4];
        boolean[] expectedDelete = new boolean[COLLECTION_SIZE * 4];
        field = new DependentHolder(200, "field200");
        int elementNumber = 0;
        for (int i = 0; i < COLLECTION_SIZE; i++) {
            elements[elementNumber] = new DependentElement1(200 + i, "setDepElement" + i);
            field.getSetDependent2().add(elements[elementNumber]);
            expectedDelete[elementNumber++] = true;
        }
        for (int i = 0; i < COLLECTION_SIZE; i++) {
            elements[elementNumber] = new DependentElement2(200 + i, "setElement" + i);
            field.getSetNonDependent2().add(elements[elementNumber]);
            expectedDelete[elementNumber++] = false;
        }
        for (int i = 0; i < COLLECTION_SIZE; i++) {
            elements[elementNumber] = new DependentElement3(200 + i, "listDepElement" + i);
            field.getListDependent2().add(elements[elementNumber]);
            expectedDelete[elementNumber++] = true;
        }
        for (int i = 0; i < COLLECTION_SIZE; i++) {
            elements[elementNumber] = new DependentElement4(200 + i, "listElement" + i);
            field.getListNonDependent2().add(elements[elementNumber]);
            expectedDelete[elementNumber++] = false;
        }
        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 * 4; i++) {
                elementObjectId[i] = pm.getObjectId(elements[i]);
            }
            tx.begin();
            loaded = (DependentHolder) pm.getObjectById(fieldObjectId, true);
            // make sure persistence is fine
            assertEquals(COLLECTION_SIZE, loaded.getSetDependent2().size());
            assertEquals(COLLECTION_SIZE, loaded.getSetNonDependent2().size());
            assertEquals(COLLECTION_SIZE, loaded.getListDependent2().size());
            assertEquals(COLLECTION_SIZE, loaded.getListNonDependent2().size());
            tx.commit();
        } catch (Exception e) {
            e.printStackTrace();
            LOG.error(e);
            fail("Exception thrown while persisting dependent field data using ForeignKey : " + 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++) {
                Object retrievedElement = pm.getObjectById(elementObjectId[elementNumber]);
                loaded.getSetDependent2().remove(retrievedElement);
                elementNumber++;
            }
            for (int i = 0; i < COLLECTION_SIZE; i++) {
                Object retrievedElement = pm.getObjectById(elementObjectId[elementNumber]);
                loaded.getSetNonDependent2().remove(retrievedElement);
                elementNumber++;
            }
            for (int i = 0; i < COLLECTION_SIZE; i++) {
                Object retrievedElement = pm.getObjectById(elementObjectId[elementNumber]);
                loaded.getListDependent2().remove(retrievedElement);
                elementNumber++;
            }
            for (int i = 0; i < COLLECTION_SIZE; i++) {
                Object retrievedElement = pm.getObjectById(elementObjectId[elementNumber]);
                loaded.getListNonDependent2().remove(retrievedElement);
                elementNumber++;
            }
            tx.commit();
        } catch (Exception e) {
            e.printStackTrace();
            LOG.error(e);
            fail("Exception thrown while persisting dependent field ForeignKey set/list 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.getSetDependent2().size());
            assertEquals(0, loaded.getSetNonDependent2().size());
            assertEquals(0, loaded.getListDependent2().size());
            assertEquals(0, loaded.getListNonDependent2().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 {
                    pm.getObjectById(elementObjectId[i]);
                    if (expectedDelete[i]) {
                        fail("Element " + i + " hasnt been deleted yet should have been since it is dependent and was removed from the ForeignKey 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 ForeignKey set/list");
                    }
                }
            }
            tx.commit();
        } catch (Exception e) {
            e.printStackTrace();
            LOG.error(e);
            fail("Exception thrown while persisting dependent field data using ForeignKey : " + e.getMessage());
        } finally {
            if (tx.isActive()) {
                tx.rollback();
            }
            pm.close();
        }
    } finally {
        // Clean out our data
        clearDependentData(pmf);
    }
}

Example 3 with DependentElement1

use of org.jpox.samples.dependentfield.DependentElement1 in project tests by datanucleus.

the class DependentFieldTest method clearDependentData.

/**
 * Convenience method to clean out dependent data
 * @param pmf The pmf to use
 */
private void clearDependentData(PersistenceManagerFactory pmf) {
    PersistenceManager pm = pmf.getPersistenceManager();
    Transaction tx = pm.currentTransaction();
    try {
        // disassociate all dependent fields
        tx.begin();
        Extent ext = pm.getExtent(DependentHolder.class, false);
        Iterator it = ext.iterator();
        while (it.hasNext()) {
            DependentHolder holder = (DependentHolder) it.next();
            DependentElement element = holder.getElement();
            if (element != null) {
                element.setOwner(null);
                element.setKey(null);
                pm.flush();
            }
            holder.setElement(null);
            holder.setListDependent1(null);
            holder.setListNonDependent1(null);
            holder.setSetDependent1(null);
            holder.setSetNonDependent1(null);
            holder.setMapDependent1(null);
            holder.setMapNonDependent1(null);
            holder.setMapDependentKeys1(null);
            holder.setMapDependentValues1(null);
            holder.setMapNonDependentKeys1(null);
            holder.setMapNonDependentValues1(null);
            pm.flush();
        }
        ext = pm.getExtent(DependentHolder.class, false);
        it = ext.iterator();
        while (it.hasNext()) {
            DependentHolder holder = (DependentHolder) it.next();
            DependentElement element = holder.getElement();
            if (element != null) {
                element.setOwner(null);
                element.setKey(null);
                pm.flush();
            }
            holder.setElement(null);
            holder.setListDependent2(null);
            holder.setListNonDependent2(null);
            holder.setSetDependent2(null);
            holder.setSetNonDependent2(null);
            holder.setMapDependent2(null);
            holder.setMapNonDependent2(null);
            holder.setMapDependentKeys2(null);
            holder.setMapDependentValues2(null);
            holder.setMapNonDependentKeys2(null);
            holder.setMapNonDependentValues2(null);
            pm.flush();
        }
        ext = pm.getExtent(DependentElement1.class, false);
        it = ext.iterator();
        while (it.hasNext()) {
            DependentElement1 field = (DependentElement1) it.next();
            field.setKey(null);
            field.setOwner(null);
            pm.flush();
        }
        ext = pm.getExtent(DependentElement2.class, false);
        it = ext.iterator();
        while (it.hasNext()) {
            DependentElement2 field = (DependentElement2) it.next();
            field.setKey(null);
            field.setOwner(null);
            pm.flush();
        }
        ext = pm.getExtent(DependentElement3.class, false);
        it = ext.iterator();
        while (it.hasNext()) {
            DependentElement3 field = (DependentElement3) it.next();
            field.setKey(null);
            field.setOwner(null);
            pm.flush();
        }
        ext = pm.getExtent(DependentElement4.class, false);
        it = ext.iterator();
        while (it.hasNext()) {
            DependentElement4 field = (DependentElement4) it.next();
            field.setKey(null);
            field.setOwner(null);
            pm.flush();
        }
        ext = pm.getExtent(DependentElement5.class, false);
        it = ext.iterator();
        while (it.hasNext()) {
            DependentElement5 field = (DependentElement5) it.next();
            field.setKey(null);
            field.setOwner(null);
            pm.flush();
        }
        ext = pm.getExtent(DependentElement6.class, false);
        it = ext.iterator();
        while (it.hasNext()) {
            DependentElement6 field = (DependentElement6) it.next();
            field.setKey(null);
            field.setOwner(null);
            pm.flush();
        }
        ext = pm.getExtent(DependentElement7.class, false);
        it = ext.iterator();
        while (it.hasNext()) {
            DependentElement7 field = (DependentElement7) it.next();
            field.setKey(null);
            field.setOwner(null);
            pm.flush();
        }
        ext = pm.getExtent(DependentElement8.class, false);
        it = ext.iterator();
        while (it.hasNext()) {
            DependentElement8 field = (DependentElement8) it.next();
            field.setKey(null);
            field.setOwner(null);
            pm.flush();
        }
        ext = pm.getExtent(DependentElement9.class, false);
        it = ext.iterator();
        while (it.hasNext()) {
            DependentElement9 field = (DependentElement9) it.next();
            field.setKey(null);
            field.setOwner(null);
            pm.flush();
        }
        ext = pm.getExtent(DependentElement10.class, false);
        it = ext.iterator();
        while (it.hasNext()) {
            DependentElement10 field = (DependentElement10) it.next();
            field.setKey(null);
            field.setOwner(null);
            pm.flush();
        }
        tx.commit();
        clean(pmf, DependentHolder.class);
        clean(pmf, DependentElement1.class);
        clean(pmf, DependentElement2.class);
        clean(pmf, DependentElement3.class);
        clean(pmf, DependentElement4.class);
        clean(pmf, DependentElement5.class);
        clean(pmf, DependentElement6.class);
        clean(pmf, DependentElement7.class);
        clean(pmf, DependentElement8.class);
        clean(pmf, DependentElement9.class);
        clean(pmf, DependentElement10.class);
        clean(pmf, DependentHolder.class);
        clean(pmf, DepInterfaceImpl1.class);
        clean(pmf, DepInterfaceImpl2.class);
    } finally {
        if (tx.isActive()) {
            tx.rollback();
        }
        pm.close();
    }
}

Example 4 with DependentElement1

use of org.jpox.samples.dependentfield.DependentElement1 in project tests by datanucleus.

the class DependentFieldTest method testBidirectionalDependentFields.

/**
 * Test of an Inverse 1-N with dependent specified at both ends.
 */
public void testBidirectionalDependentFields() {
    try {
        PersistenceManager pm = pmf.getPersistenceManager();
        Transaction tx = pm.currentTransaction();
        Object containerId = null;
        Object element1Id = null;
        Object element2Id = null;
        try {
            tx.begin();
            DependentHolder holder = new DependentHolder(1, "Basic Container");
            DependentElement1 element1 = new DependentElement1(1, "Element 1");
            DependentElement1 element2 = new DependentElement1(2, "Element 2");
            holder.getSetDependent2().add(element1);
            holder.getSetDependent2().add(element2);
            pm.makePersistent(holder);
            tx.commit();
            containerId = pm.getObjectId(holder);
            element1Id = pm.getObjectId(element1);
            element2Id = pm.getObjectId(element2);
        } catch (Exception e) {
            e.printStackTrace();
            LOG.error(e);
            fail("Exception thrown while persisting bidirectional dependent objects : " + e.getMessage());
        } finally {
            if (tx.isActive()) {
                tx.rollback();
            }
            pm.close();
        }
        // Delete the container
        pm = pmf.getPersistenceManager();
        tx = pm.currentTransaction();
        try {
            tx.begin();
            DependentHolder holder = (DependentHolder) pm.getObjectById(containerId);
            pm.getObjectById(element1Id);
            pm.getObjectById(element2Id);
            assertEquals("Dependent container has incorrect number of dependent elements", 2, holder.getSetDependent2().size());
            // Delete the container
            pm.deletePersistent(holder);
            tx.commit();
        } catch (Exception e) {
            e.printStackTrace();
            LOG.error(e);
            fail("Exception thrown while deleting bidirectional dependent objects : " + e.getMessage());
        } finally {
            if (tx.isActive()) {
                tx.rollback();
            }
            pm.close();
        }
        // Check that none of the objects is still present
        pm = pmf.getPersistenceManager();
        tx = pm.currentTransaction();
        try {
            tx.begin();
            try {
                DependentHolder holder = (DependentHolder) pm.getObjectById(containerId);
                if (holder != null) {
                    fail("Bidirectional dependent container still exists after deletion!");
                }
            } catch (Exception e) {
            }
            try {
                DependentElement1 element1 = (DependentElement1) pm.getObjectById(element1Id);
                if (element1 != null) {
                    fail("Bidirectional dependent element 1 still exists after deletion!");
                }
            } catch (Exception e) {
            }
            try {
                DependentElement1 element2 = (DependentElement1) pm.getObjectById(element2Id);
                if (element2 != null) {
                    fail("Bidirectional dependent element 2 still exists after deletion!");
                }
            } catch (Exception e) {
            }
            tx.commit();
        } catch (Exception e) {
            e.printStackTrace();
            LOG.error(e);
            fail("Exception thrown while checking for deleted bidirectional dependent objects : " + e.getMessage());
        } finally {
            if (tx.isActive()) {
                tx.rollback();
            }
            pm.close();
        }
        // Recreate the container and elements
        pm = pmf.getPersistenceManager();
        tx = pm.currentTransaction();
        try {
            tx.begin();
            DependentHolder holder = new DependentHolder(11, "Basic Container 11");
            DependentElement1 element1 = new DependentElement1(11, "Element 11");
            DependentElement1 element2 = new DependentElement1(12, "Element 12");
            holder.getSetDependent2().add(element1);
            holder.getSetDependent2().add(element2);
            pm.makePersistent(holder);
            tx.commit();
            containerId = pm.getObjectId(holder);
            element1Id = pm.getObjectId(element1);
            element2Id = pm.getObjectId(element2);
        } catch (Exception e) {
            e.printStackTrace();
            LOG.error(e);
            fail("Exception thrown while persisting bidirectional dependent objects : " + e.getMessage());
        } finally {
            if (tx.isActive()) {
                tx.rollback();
            }
            pm.close();
        }
        // Remove an element
        pm = pmf.getPersistenceManager();
        tx = pm.currentTransaction();
        try {
            tx.begin();
            DependentHolder holder = (DependentHolder) pm.getObjectById(containerId);
            DependentElement1 element2 = (DependentElement1) pm.getObjectById(element2Id);
            assertEquals("Dependent container has incorrect number of dependent elements", 2, holder.getSetDependent2().size());
            // Remove the second element from the container. This will empty the collection, and then
            // will delete it since it is dependent on the owner, and delete the container since that
            // is dependent on the elements.
            holder.getSetDependent2().remove(element2);
            tx.commit();
        } catch (Exception e) {
            e.printStackTrace();
            LOG.error(e);
            fail("Exception thrown while removing element from container : " + e.getMessage());
        } finally {
            if (tx.isActive()) {
                tx.rollback();
            }
            pm.close();
        }
        // Check that none of the objects is still present
        pm = pmf.getPersistenceManager();
        tx = pm.currentTransaction();
        try {
            tx.begin();
            try {
                DependentHolder holder = (DependentHolder) pm.getObjectById(containerId);
                if (holder == null) {
                    fail("Bidirectional dependent container doesn't exist after removal of element!");
                }
            } catch (Exception e) {
            }
            try {
                DependentElement1 element1 = (DependentElement1) pm.getObjectById(element1Id);
                if (element1 == null) {
                    fail("Bidirectional dependent element 1 doesn't exist after removal of element!");
                }
            } catch (Exception e) {
            }
            try {
                DependentElement1 element2 = (DependentElement1) pm.getObjectById(element2Id);
                if (element2 != null) {
                    fail("Bidirectional dependent element 2 still exists after its removal from container. Should have been deleted when removed from the container!");
                }
            } catch (Exception e) {
            }
            tx.commit();
        } catch (Exception e) {
            e.printStackTrace();
            LOG.error(e);
            fail("Exception thrown while checking for bidirectional dependent objects : " + e.getMessage());
        } finally {
            if (tx.isActive()) {
                tx.rollback();
            }
            pm.close();
        }
    } finally {
        clearDependentData(pmf);
    }
}