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

Example 1 with DependentElement

use of org.jpox.samples.dependentfield.DependentElement 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 DependentElement

use of org.jpox.samples.dependentfield.DependentElement 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);
    }
}

Example 3 with DependentElement

use of org.jpox.samples.dependentfield.DependentElement 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);
    }
}

Example 4 with DependentElement

use of org.jpox.samples.dependentfield.DependentElement 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);
    }
}

Example 5 with DependentElement

use of org.jpox.samples.dependentfield.DependentElement 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);
    }
}