Examples with Address org.geotoolkit.sml.xml.v101.Address used on opensource projects

Example 96 with Address

use of org.geotoolkit.sml.xml.v101.Address in project eclipselink by eclipse-ee4j.

the class EntityManagerJUnitTestSuite method internalTestChangeRecordKeepOldValue.

public void internalTestChangeRecordKeepOldValue(boolean addSecondStep) {
    if (isOnServer()) {
        // the test relies upon keeping attached objects between transactions.
        return;
    }
    DatabaseSessionImpl dbs = getDatabaseSession();
    ChangeRecordKeepOldValueListener listener = new ChangeRecordKeepOldValueListener();
    dbs.getEventManager().addListener(listener);
    EntityManager em = createEntityManager();
    try {
        // setup
        // create original object and referenced objects
        Employee emp = new Employee();
        emp.setFirstName("TestChangeRecordKeepOldValue");
        emp.setLastName("Manager_OriginalName");
        emp.setMale();
        emp.setSalary(35000);
        emp.setPeriod(new EmploymentPeriod(Helper.dateFromYearMonthDate(1993, 0, 1), Helper.dateFromYearMonthDate(1996, 11, 31)));
        emp.setFormerEmployment(new FormerEmployment("Original", new EmploymentPeriod(Helper.dateFromYearMonthDate(1990, 0, 1), Helper.dateFromYearMonthDate(1993, 11, 31))));
        Address address = new Address();
        address.setCountry("Original");
        address.setProvince("Original");
        address.setCity("Original");
        address.setStreet("Original");
        address.setPostalCode("Original");
        emp.setAddress(address);
        Department dep = new Department();
        dep.setName("Original");
        emp.setDepartment(dep);
        emp.addResponsibility("Original_1");
        emp.addResponsibility("Original_2");
        PhoneNumber phone1 = new PhoneNumber("Original_1", "111", "1111111");
        emp.addPhoneNumber(phone1);
        PhoneNumber phone2 = new PhoneNumber("Original_2", "222", "2222222");
        emp.addPhoneNumber(phone2);
        emp.setNormalHours(new Time[] { Helper.timeFromHourMinuteSecond(9, 0, 0), Helper.timeFromHourMinuteSecond(17, 0, 0) });
        Employee emp1 = new Employee();
        emp1.setFirstName("TestChangeRecordKeepOldValue");
        emp1.setLastName("Original_1");
        emp.addManagedEmployee(emp1);
        Employee emp2 = new Employee();
        emp2.setFirstName("TestChangeRecordKeepOldValue");
        emp2.setLastName("Original_2");
        emp.addManagedEmployee(emp2);
        Project proj1 = new SmallProject();
        proj1.setName("Original_1");
        emp.addProject(proj1);
        Project proj2 = new LargeProject();
        proj2.setName("Original_2");
        emp.addProject(proj2);
        Project proj3 = new LargeProject();
        proj3.setName("Original_3");
        proj3.setTeamLeader(emp);
        emp1.addProject(proj3);
        emp2.addProject(proj3);
        // persist original object and all referenced objects
        beginTransaction(em);
        Equipment equipment1 = new Equipment();
        equipment1.setDescription("Original_1");
        // persist is not cascaded for department.equipment - have to explicitly persist it.
        em.persist(equipment1);
        dep.addEquipment(equipment1);
        Equipment equipment2 = new Equipment();
        equipment2.setDescription("Original_2");
        // persist is not cascaded for department.equipment - have to explicitly persist it.
        // moreover, equipment.id is used as a key in dep.equipment Map, therefore equipmet
        // should be persisted before been added to dep.
        em.persist(equipment2);
        dep.addEquipment(equipment2);
        // persist is not cascaded for employee.department - have to explicitly persist it.
        // moreover, equipment.id is used as a key in dep.equipment Map, therefore equipmet
        // should be persisted before been added to dep.
        em.persist(dep);
        em.persist(emp);
        commitTransaction(em);
        // backup original object and all referenced objects
        CopyGroup copyGroupBackup = new CopyGroup();
        copyGroupBackup.cascadeAllParts();
        dbs.copy(emp, copyGroupBackup);
        // emp references (directly or through other objects) all the created objects, therefore all of them are copied.
        Map backupMap = copyGroupBackup.getCopies();
        // verify that backup objects are identical to originals
        Iterator<Map.Entry> it = backupMap.entrySet().iterator();
        while (it.hasNext()) {
            Map.Entry entry = it.next();
            Object original = entry.getKey();
            ClassDescriptor descriptor = dbs.getDescriptor(original);
            if (!descriptor.isAggregateDescriptor()) {
                Object backup = entry.getValue();
                if (original == backup) {
                    fail("Test problem: backup failed: original == backup: " + original);
                }
                if (!dbs.compareObjects(original, backup)) {
                    fail("Test problem: backup failed: compareObjects(original, backup) == false: " + original + "; " + backup);
                }
            }
        }
        // change original object
        beginTransaction(em);
        // DirectToField
        emp.setLastName("Manager_NewName");
        // DirectToField
        emp.setSalary(100);
        // Aggregate
        emp.getPeriod().setStartDate(Helper.dateFromYearMonthDate(2000, 0, 1));
        emp.getPeriod().setEndDate(Helper.dateFromYearMonthDate(2002, 0, 1));
        // Aggregate
        // emp.setFormerEmployment(new FormerEmployment("New", new EmploymentPeriod(Helper.dateFromYearMonthDate(1989, 0, 1), Helper.dateFromYearMonthDate(1992, 11, 31))));
        emp.getFormerEmployment().setFormerCompany("New");
        emp.getFormerEmployment().getPeriod().setStartDate(Helper.dateFromYearMonthDate(1989, 0, 1));
        emp.getFormerEmployment().getPeriod().setStartDate(Helper.dateFromYearMonthDate(1992, 11, 31));
        // Transformation
        emp.setStartTime(Helper.timeFromHourMinuteSecond(10, 0, 0));
        // DirectCollection
        emp.removeResponsibility("Original_1");
        emp.addResponsibility("New_1");
        // Private Collection 1 to many
        PhoneNumber phone1New = new PhoneNumber("New_1", "111", "1111111");
        emp.addPhoneNumber(phone1New);
        emp.removePhoneNumber(phone1);
        // Collection 1 to many
        emp.removeManagedEmployee(emp1);
        emp1.setManager(null);
        em.remove(emp1);
        Employee emp1New = new Employee();
        emp1New.setFirstName("TestChangeRecordKeepOldValue");
        emp1New.setLastName("New_1");
        emp1New.addProject(proj3);
        emp.addManagedEmployee(emp1New);
        // Collection many to many
        emp.removeProject(proj1);
        em.remove(proj1);
        Project proj1New = new LargeProject();
        proj1New.setName("New_1");
        emp.addProject(proj1New);
        // ObjectReference
        proj3.setTeamLeader(null);
        // ObjectReference
        Address addressNew = new Address();
        addressNew.setCountry("New");
        addressNew.setProvince("New");
        addressNew.setCity("New");
        addressNew.setStreet("New");
        addressNew.setPostalCode("New");
        emp.setAddress(addressNew);
        em.remove(address);
        // Map 1 to many
        dep.getEquipment().remove(equipment1.getId());
        Equipment equipment1New = new Equipment();
        equipment1New.setDescription("New_1");
        em.persist(equipment1New);
        dep.addEquipment(equipment1New);
        // additional change typically overrides existing aggregate or collection with the new one, then alters aggregate or adds to collection.
        if (addSecondStep) {
            // Aggregate
            emp.setPeriod(new EmploymentPeriod());
            emp.getPeriod().setStartDate(Helper.dateFromYearMonthDate(2001, 0, 1));
            emp.getPeriod().setEndDate(Helper.dateFromYearMonthDate(2003, 0, 1));
            // Aggregate
            emp.setFormerEmployment(new FormerEmployment("New_New", new EmploymentPeriod(Helper.dateFromYearMonthDate(1988, 0, 1), Helper.dateFromYearMonthDate(1991, 11, 31))));
            emp.getFormerEmployment().setPeriod(new EmploymentPeriod());
            emp.getFormerEmployment().getPeriod().setStartDate(Helper.dateFromYearMonthDate(1987, 0, 1));
            emp.getFormerEmployment().getPeriod().setEndDate(Helper.dateFromYearMonthDate(1990, 0, 1));
            // Transformation
            emp.setEndTime(Helper.timeFromHourMinuteSecond(18, 0, 0));
            // DirectCollection
            emp.setResponsibilities(new ArrayList());
            emp.addResponsibility("New_New_1");
            // Private Collection 1 to many
            emp.setPhoneNumbers(new HashSet());
            PhoneNumber phone1NewNew = new PhoneNumber("New_New_1", "111", "1111111");
            emp.addPhoneNumber(phone1NewNew);
            // Collection 1 to many
            emp1New.setManager(null);
            emp2.setManager(null);
            emp.setManagedEmployees(new Vector());
            Employee emp1NewNew = new Employee();
            emp1NewNew.setFirstName("TestChangeRecordKeepOldValue");
            emp1NewNew.setLastName("New_New_1");
            emp1NewNew.addProject(proj3);
            emp.addManagedEmployee(emp1NewNew);
            em.remove(emp1New);
            em.remove(emp2);
            // Collection many to many
            emp.setProjects(new ArrayList());
            Project proj1NewNew = new LargeProject();
            proj1NewNew.setName("New_New_1");
            emp.addProject(proj1NewNew);
            em.remove(proj1New);
            em.remove(proj2);
            // ObjectReference
            Address addressNewNew = new Address();
            addressNewNew.setCountry("New_New");
            addressNewNew.setProvince("New_New");
            addressNewNew.setCity("New_New");
            addressNewNew.setStreet("New_New");
            addressNewNew.setPostalCode("New_New");
            emp.setAddress(addressNewNew);
            em.remove(addressNew);
            // Map 1 to many
            // We are about to override equipment map.
            // It's a private OneToMany mapping so normally all the
            // members would be removed automatically.
            // However in theis case we have explicitly persisted the the new member added in thhe current transaction
            // (because Equipment's id is used as its key in the Department.equipment Map)
            // therefore we have to explicitly em.remove it.
            em.remove(equipment1New);
            dep.setEquipment(new HashMap());
            Equipment equipment1NewNew = new Equipment();
            equipment1NewNew.setDescription("New_New_1");
            em.persist(equipment1NewNew);
            dep.addEquipment(equipment1NewNew);
        }
        commitTransaction(em);
        // backup updated objects
        CopyGroup copyGroupUpdated = new CopyGroup();
        copyGroupUpdated.cascadeAllParts();
        dbs.copy(emp, copyGroupUpdated);
        // copies of the updated objects will be altered to contain old values.
        // if altering the test, make sure that emp still references (directly or through other objects) all the updated objects, so that all of them are copied.
        Map oldValueMap = copyGroupUpdated.getCopies();
        // using ChangeRecords bring back the original state of the object
        Iterator<Map.Entry<Object, org.eclipse.persistence.internal.sessions.ObjectChangeSet>> itChangeSets = ((org.eclipse.persistence.internal.sessions.UnitOfWorkChangeSet) listener.uowChangeSet).getCloneToObjectChangeSet().entrySet().iterator();
        while (itChangeSets.hasNext()) {
            Map.Entry<Object, org.eclipse.persistence.internal.sessions.ObjectChangeSet> entry = itChangeSets.next();
            Object object = entry.getKey();
            ClassDescriptor descriptor = dbs.getDescriptor(object);
            if (!descriptor.isAggregateDescriptor()) {
                org.eclipse.persistence.internal.sessions.ObjectChangeSet changeSet = entry.getValue();
                if (!changeSet.shouldBeDeleted() && !changeSet.isNew()) {
                    List<ChangeRecord> changes = changeSet.getChanges();
                    if (changes != null && !changes.isEmpty()) {
                        Object oldValueObject = oldValueMap.get(object);
                        for (ChangeRecord changeRecord : changeSet.getChanges()) {
                            Object oldValue = changeRecord.getOldValue();
                            DatabaseMapping mapping = ((org.eclipse.persistence.internal.sessions.ChangeRecord) changeRecord).getMapping();
                            mapping.setRealAttributeValueInObject(oldValueObject, oldValue);
                        }
                    }
                }
            }
        }
        String errorMsgOldValues = "";
        // now compare oldValue objects with corresponding backup objects
        itChangeSets = ((org.eclipse.persistence.internal.sessions.UnitOfWorkChangeSet) listener.uowChangeSet).getCloneToObjectChangeSet().entrySet().iterator();
        while (itChangeSets.hasNext()) {
            Map.Entry<Object, org.eclipse.persistence.internal.sessions.ObjectChangeSet> entry = itChangeSets.next();
            Object object = entry.getKey();
            ClassDescriptor descriptor = dbs.getDescriptor(object);
            if (!descriptor.isAggregateDescriptor()) {
                ObjectChangeSet changeSet = entry.getValue();
                if (!changeSet.shouldBeDeleted() && !changeSet.isNew()) {
                    List<ChangeRecord> changes = changeSet.getChanges();
                    if (changes != null && !changes.isEmpty()) {
                        Object oldValueObject = oldValueMap.get(object);
                        Object backupObject = backupMap.get(object);
                        // compare oldValue with backup object
                        if (!dbs.compareObjects(oldValueObject, backupObject)) {
                            errorMsgOldValues += '\t' + object.toString() + '\n';
                        }
                    }
                }
            }
        }
        // set of attached to em objects
        Set updatedObjects = new HashSet();
        for (Object object : oldValueMap.keySet()) {
            ClassDescriptor descriptor = dbs.getDescriptor(object);
            if (!descriptor.isAggregateDescriptor()) {
                updatedObjects.add(object);
            }
        }
        // verify that the objects were correctly written to the db
        String errorMsgDb = "";
        clearCache();
        Map updatedToReadBack = new HashMap();
        EntityManager em2 = createEntityManager();
        beginTransaction(em2);
        UnitOfWork uow2 = ((EntityManagerImpl) em2.getDelegate()).getActivePersistenceContext(null);
        // before comparison clear all read-only mappings that we didn't set in the attached to em objects.
        for (Object object : updatedObjects) {
            Object readBack = uow2.readObject(object);
            if (readBack instanceof Address) {
                ((Address) readBack).getEmployees().clear();
            } else if (readBack instanceof PhoneNumber) {
                ((PhoneNumber) readBack).setId(null);
            } else if (readBack instanceof Department) {
                ((Department) readBack).getEmployees().clear();
            }
            updatedToReadBack.put(object, readBack);
        }
        // now compare object attached to em with the object read from the db
        for (Object entryObject : updatedToReadBack.entrySet()) {
            Map.Entry entry = (Map.Entry) entryObject;
            Object object = entry.getKey();
            Object readBack = entry.getValue();
            if (!dbs.compareObjects(object, readBack)) {
                errorMsgDb += '\t' + object.toString() + '\n';
            }
        }
        rollbackTransaction(em2);
        // clean up
        beginTransaction(em);
        Set objectsToRemove = new HashSet();
        // remove all dependencies and add cache objects to be directly removed.
        for (Object object : updatedObjects) {
            if (object instanceof Employee) {
                ((Employee) object).getManagedEmployees().clear();
                ((Employee) object).setManager(null);
                ((Employee) object).setAddress((Address) null);
                ((Employee) object).getProjects().clear();
                ((Employee) object).setDepartment(null);
                objectsToRemove.add(object);
            } else if (object instanceof Project) {
                ((Project) object).setTeamLeader(null);
                objectsToRemove.add(object);
            } else if (object instanceof Address || object instanceof Department) {
                objectsToRemove.add(object);
            }
        }
        // remove objects that should be removed directly.
        for (Object object : objectsToRemove) {
            em.remove(object);
        }
        commitTransaction(em);
        String errorMsg = "";
        if (errorMsgOldValues.length() > 0) {
            errorMsgOldValues = "Some old values and back up objects are not equal:\n" + errorMsgOldValues;
            errorMsg += errorMsgOldValues;
        }
        if (errorMsgDb.length() > 0) {
            errorMsgDb = "\nSome values were incorrectly written into the db:\n" + errorMsgDb;
            errorMsg += errorMsgDb;
        }
        if (errorMsg.length() > 0) {
            fail(errorMsg);
        }
    } finally {
        if (isTransactionActive(em)) {
            rollbackTransaction(em);
        }
        closeEntityManager(em);
        dbs.getEventManager().removeListener(listener);
    }
}

Example 97 with Address

use of org.geotoolkit.sml.xml.v101.Address in project eclipselink by eclipse-ee4j.

the class EntityManagerJUnitTestSuite method testOverwrittingAndOverLoadingMethods.

// This test weaving works with over-writing methods in subclasses, and overloading methods.
public void testOverwrittingAndOverLoadingMethods() {
    EntityManager em = createEntityManager();
    beginTransaction(em);
    try {
        Address address = new Address();
        address.setCity("Ottawa");
        Employee employee = new Employee();
        employee.setAddress(address);
        LargeProject project = new LargeProject();
        project.setTeamLeader(employee);
        em.persist(employee);
        em.persist(project);
        commitTransaction(em);
        closeEntityManager(em);
        em = createEntityManager();
        beginTransaction(em);
        employee = em.find(Employee.class, employee.getId());
        project = em.find(LargeProject.class, project.getId());
        if ((employee.getAddress("Home") == null) || (!employee.getAddress("Home").getCity().equals("Ottawa"))) {
            fail("Get address did not work.");
        }
        employee.setAddress("Toronto");
        if (!employee.getAddress().getCity().equals("Toronto")) {
            fail("Set address did not work.");
        }
        if (project.getTeamLeader() != employee) {
            fail("Get team leader did not work, team is: " + project.getTeamLeader() + " but should be:" + employee);
        }
        em.remove(employee.getAddress());
        em.remove(employee);
        em.remove(project);
    } finally {
        if (isTransactionActive(em)) {
            rollbackTransaction(em);
        }
        closeEntityManager(em);
    }
}

Example 98 with Address

use of org.geotoolkit.sml.xml.v101.Address in project eclipselink by eclipse-ee4j.

the class EntityManagerJUnitTestSuite method internalTestPostAcquirePreReleaseEvents.

public void internalTestPostAcquirePreReleaseEvents(boolean useExternalConnectionPool) {
    if (isOnServer()) {
        // Uses DefaultConnector.
        return;
    }
    SessionBroker broker = ((JpaEntityManagerFactory) getEntityManagerFactory()).getSessionBroker();
    // Testing ExclusiveConnectionMode.Isolated requires a session that has isolated descriptors.
    ServerSession ss = (ServerSession) broker.getSessionForClass(Address.class);
    if (ss.getPlatform().isSybase()) {
        warning("Warning Sybase Driver does not work with DriverWrapper, testPostAcquirePreReleaseEvents can't run on this platform.");
        return;
    }
    if (ss.getPlatform().isSymfoware()) {
        warning("Test testPostAcquirePreReleaseEvents skipped for this platform, " + "Symfoware platform doesn't support failover.");
        return;
    }
    // normally false; set to true for debug output for just this single test
    boolean shouldForceFinest = false;
    int originalLogLevel = -1;
    // cache the original driver name and connection string.
    String originalDriverName = ss.getLogin().getDriverClassName();
    String originalConnectionString = ss.getLogin().getConnectionString();
    // cache original connector for external connection pool case
    Connector originalConnector = ss.getLogin().getConnector();
    // the new driver name and connection string to be used by the test
    String newDriverName = DriverWrapper.class.getName();
    String newConnectionString = DriverWrapper.codeUrl(originalConnectionString);
    // setup the wrapper driver
    DriverWrapper.initialize(originalDriverName);
    // The test need to connect with the new driver and connection string.
    // That could be done in JPA:
    // // close the existing emf
    // closeEntityManagerFactory();
    // HashMap properties = new HashMap(JUnitTestCaseHelper.getDatabaseProperties());
    // properties.put(PersistenceUnitProperties.JDBC_DRIVER, newDriverName);
    // properties.put(PersistenceUnitProperties.JDBC_URL, newConnectionString);
    // emf = getEntityManagerFactory(properties);
    // However this only works in case closeEntityManagerFactory disconnects the original ServerSession,
    // which requires the factory to be the only one using the persistence unit.
    // Alternative - and faster - approach is to disconnect the original session directly
    // and then reconnected it with the new driver and connection string.
    broker.logout();
    if (useExternalConnectionPool) {
        ss.getLogin().setConnector(new JNDIConnector(new DataSourceImpl(null, newConnectionString, null, null)));
        ss.getLogin().useExternalConnectionPooling();
    } else {
        ss.getLogin().setDriverClassName(newDriverName);
        ss.getLogin().setConnectionString(newConnectionString);
    }
    if (shouldForceFinest) {
        if (broker.getLogLevel() != SessionLog.FINEST) {
            originalLogLevel = broker.getLogLevel();
            broker.setLogLevel(SessionLog.FINEST);
        }
    }
    // switch off reconnection
    boolean originalIsConnectionHealthValidatedOnError = ss.getLogin().isConnectionHealthValidatedOnError();
    ss.getLogin().setConnectionHealthValidatedOnError(false);
    // Using DriverWrapper the listener will repair connection on postAcquireConnection and break it on preReleaseConnection event.
    // Also the listener will verify that neither postAcquireConnection nor preReleaseConnection events not called two in a row.
    AcquireRepair_ReleaseBreak_Listener listener = new AcquireRepair_ReleaseBreak_Listener();
    ss.getEventManager().addListener(listener);
    // Driver's connect method will still work, however any method called on any acquired connection will throw SQLException.
    // On postAcquireConnection connection will be repaired; on preReleaseConnection - broken again.
    broker.log(SessionLog.FINEST, SessionLog.CONNECTION, "testPostAcquirePreReleaseEvents: DriverWrapper.breakOldConnections(); DriverWrapper.breakNewConnections();", null, null, false);
    DriverWrapper.breakOldConnections();
    DriverWrapper.breakNewConnections();
    broker.login();
    // test several configurations:
    // all exclusive connection modes
    String[] exclusiveConnectionModeArray = new String[] { ExclusiveConnectionMode.Transactional, ExclusiveConnectionMode.Isolated, ExclusiveConnectionMode.Always };
    // Normally the user wishing to use not pooled connection would specify user and password properties (and possibly db url, too).
    // However if these properties have the same values that those in the logging then no non pooled connection is created and the pooled one used instead.
    // In the test we must use the same user as already in the session login (don't know any others) that forces usage of ConnectionPolicy property.
    ConnectionPolicy connectionPolicy = (ConnectionPolicy) ss.getDefaultConnectionPolicy().clone();
    connectionPolicy.setLogin(ss.getLogin());
    connectionPolicy.setPoolName(null);
    try {
        HashMap emProperties = new HashMap(1);
        HashMap mapOfProperties = new HashMap(1);
        emProperties.put(PersistenceUnitProperties.COMPOSITE_UNIT_PROPERTIES, mapOfProperties);
        HashMap memberProperties = new HashMap();
        mapOfProperties.put(ss.getName(), memberProperties);
        String mode, pooled = "", exclusiveConnectionMode;
        for (int k = 0; k < 2; k++) {
            if (k == 1) {
                // use non pooled connections
                pooled = "non pooled; ";
                memberProperties.put(EntityManagerProperties.CONNECTION_POLICY, connectionPolicy);
            }
            for (int i = 0; i < exclusiveConnectionModeArray.length; i++) {
                exclusiveConnectionMode = exclusiveConnectionModeArray[i];
                for (int j = 0; j < 3; j++) {
                    // either beginning early transaction or not
                    boolean shouldBeginEarlyTransaction = (j == 2);
                    boolean shouldReadBeforeTransaction = (j == 1);
                    mode = pooled + exclusiveConnectionMode + (shouldBeginEarlyTransaction ? "; beginEarlyTransaction" : "") + (shouldReadBeforeTransaction ? "; readBeforeTransaction" : "");
                    broker.log(SessionLog.FINEST, SessionLog.CONNECTION, "testPostAcquirePreReleaseEvents: " + mode, null, null, false);
                    memberProperties.put(EntityManagerProperties.EXCLUSIVE_CONNECTION_MODE, exclusiveConnectionMode);
                    EntityManager em = createEntityManager(emProperties);
                    if (shouldReadBeforeTransaction) {
                        em.find(Address.class, 1);
                    }
                    Address address = null;
                    try {
                        em.getTransaction().begin();
                        if (shouldBeginEarlyTransaction) {
                            em.unwrap(UnitOfWorkImpl.class).beginEarlyTransaction();
                        }
                        address = new Address();
                        address.setCountry("testPostAcquirePreReleaseEvents");
                        em.persist(address);
                        em.getTransaction().commit();
                    } finally {
                        // expected exception - connection is invalid and cannot be reconnected.
                        if (em.getTransaction().isActive()) {
                            em.getTransaction().rollback();
                        }
                        closeEntityManager(em);
                    }
                    if (listener.hasAcquiredConnections()) {
                        fail(mode + " connection was not passed to preReleaseConnection event");
                    }
                }
            }
        }
    } finally {
        // clear the driver wrapper
        DriverWrapper.clear();
        // reconnect the session using the original driver and connection string
        ss.getEventManager().removeListener(listener);
        // clean-up
        // remove the inserted object
        EntityManager em = createEntityManager();
        em.getTransaction().begin();
        try {
            em.createQuery("DELETE FROM Address a WHERE a.country = 'testPostAcquirePreReleaseEvents'");
            em.getTransaction().commit();
        } finally {
            if (em.getTransaction().isActive()) {
                em.getTransaction().rollback();
            }
            closeEntityManager(em);
            broker.logout();
            if (originalLogLevel >= 0) {
                broker.setLogLevel(originalLogLevel);
            }
            if (useExternalConnectionPool) {
                ss.getLogin().setConnector(originalConnector);
                ss.getLogin().dontUseExternalConnectionPooling();
            } else {
                ss.getLogin().setDriverClassName(originalDriverName);
                ss.getLogin().setConnectionString(originalConnectionString);
            }
            ss.getLogin().setConnectionHealthValidatedOnError(originalIsConnectionHealthValidatedOnError);
            broker.login();
        }
    }
}

Example 99 with Address

use of org.geotoolkit.sml.xml.v101.Address in project eclipselink by eclipse-ee4j.

the class EntityManagerJUnitTestSuite method testClassInstanceConverter.

public void testClassInstanceConverter() {
    EntityManager em = createEntityManager();
    beginTransaction(em);
    Address add = new Address();
    add.setCity("St. Louis");
    add.setType(new Bungalow());
    em.persist(add);
    commitTransaction(em);
    int assignedSequenceNumber = add.getID();
    em.clear();
    getDatabaseSession().getIdentityMapAccessor().initializeAllIdentityMaps();
    add = em.find(Address.class, assignedSequenceNumber);
    assertTrue("Did not correctly persist a mapping using a class-instance converter", (add.getType() instanceof Bungalow));
    beginTransaction(em);
    add = em.find(Address.class, assignedSequenceNumber);
    em.remove(add);
    commitTransaction(em);
}

Example 100 with Address

use of org.geotoolkit.sml.xml.v101.Address in project eclipselink by eclipse-ee4j.

the class EntityManagerJUnitTestSuite method testWeaving.

/**
 * Test that all of the classes in the advanced model were weaved as expected.
 */
public void testWeaving() {
    // Only test if weaving was on, test runs without weaving must set this system property.
    if (isWeavingEnabled()) {
        internalTestWeaving(new Employee(), true, true);
        internalTestWeaving(new FormerEmployment(), true, false);
        internalTestWeaving(new Address(), true, false);
        internalTestWeaving(new PhoneNumber(), true, false);
        internalTestWeaving(new EmploymentPeriod(), true, false);
        /*            internalTestWeaving(new Buyer(), false, false);  // field-locking
            internalTestWeaving(new GoldBuyer(), false, false);  // field-locking
            internalTestWeaving(new PlatinumBuyer(), false, false);  // field-locking
            internalTestWeaving(new Department(), true, false);  // eager 1-m
            internalTestWeaving(new Golfer(), true, false);
            internalTestWeaving(new GolferPK(), true, false);
             */
        internalTestWeaving(new SmallProject(), true, false);
        internalTestWeaving(new LargeProject(), true, false);
    /*
            internalTestWeaving(new Man(), true, false);
            internalTestWeaving(new Woman(), true, false);
            internalTestWeaving(new Vegetable(), false, false);  // serialized
            internalTestWeaving(new VegetablePK(), false, false);
            internalTestWeaving(new WorldRank(), true, false);
            internalTestWeaving(new Equipment(), true, false);
            internalTestWeaving(new EquipmentCode(), true, false);
            internalTestWeaving(new PartnerLink(), true, false);
             */
    }
}