jpa/eclipselink.jpa.wdf.test/src/it/java/org/eclipse/persistence/testing/tests/wdf/jpa1/relation/TestBidirectionalManyToMany.java - eclipselink - Git at Google

 /*
  * Copyright (c) 2005, 2021 Oracle and/or its affiliates. All rights reserved.
  * Copyright (c) 2005, 2015 SAP. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
  * http://www.eclipse.org/legal/epl-2.0,
  * or the Eclipse Distribution License v. 1.0 which is available at
  * http://www.eclipse.org/org/documents/edl-v10.php.
  *
  * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
  */

 // Contributors:
 //     SAP - initial API and implementation

 package org.eclipse.persistence.testing.tests.wdf.jpa1.relation;

 import java.io.IOException;
 import java.sql.Connection;
 import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.util.Collections;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.Set;

 import jakarta.persistence.EntityManager;
 import javax.sql.DataSource;

 import org.eclipse.persistence.testing.framework.wdf.AbstractBaseTest;
 import org.eclipse.persistence.testing.framework.wdf.Bugzilla;
 import org.eclipse.persistence.testing.framework.wdf.JPAEnvironment;
 import org.eclipse.persistence.testing.models.wdf.jpa1.employee.Bicycle;
 import org.eclipse.persistence.testing.models.wdf.jpa1.employee.Department;
 import org.eclipse.persistence.testing.models.wdf.jpa1.employee.Employee;
 import org.eclipse.persistence.testing.models.wdf.jpa1.employee.Item_Byte;
 import org.eclipse.persistence.testing.models.wdf.jpa1.employee.Project;
 import org.eclipse.persistence.testing.models.wdf.jpa1.employee.TravelProfile;
 import org.eclipse.persistence.testing.models.wdf.jpa1.employee.Vehicle;
 import org.eclipse.persistence.testing.tests.wdf.jpa1.JPA1Base;
 import org.junit.Before;
 import org.junit.Test;

 @SuppressWarnings("unchecked")
 public class TestBidirectionalManyToMany extends JPA1Base {

     private static final int HANS_ID_VALUE = 1;
     private static final Integer HANS_ID = HANS_ID_VALUE;
     private static final Set<Pair> HANS_SET = new HashSet<Pair>();
     private static final int FRED_ID_VALUE = 2;
     private static final Integer FRED_ID = FRED_ID_VALUE;
     private static final Set<Pair> FRED_SET = new HashSet<Pair>();
     private static final Set<Pair> SEED_SET = new HashSet<Pair>();
     private static final Project PUHLEN = new Project("G\u00fcrteltiere puhlen");
     private static final Project PINSELN = new Project("B\u00e4uche pinseln");
     private static final Project FALTEN = new Project("Zitronen falten");
     private static final Project ZAEHLEN = new Project("Erbsen z\u00e4hlen");
     private static final Project LINKEN = new Project("Eclipse Linken");

     @Before
     public void initData() throws SQLException {
         /*
          * 5 Projects:
          */
         clearAllTables();
         JPAEnvironment env = getEnvironment();
         EntityManager em = env.getEntityManager();
         try {
             env.beginTransaction(em);
             Department dep = new Department(17, "diverses");
             em.persist(dep);
             em.persist(PUHLEN);
             em.persist(PINSELN);
             em.persist(FALTEN);
             em.persist(ZAEHLEN);
             em.persist(LINKEN);
             Employee hans = new Employee(HANS_ID_VALUE, "Hans", "Wurst", dep);
             Set<Project> hansProjects = new HashSet<Project>();
             hansProjects.add(PUHLEN);
             hansProjects.add(PINSELN);
             hansProjects.add(FALTEN);
             hans.setProjects(hansProjects);
             Employee fred = new Employee(FRED_ID_VALUE, "Fred von", "Jupiter", dep);
             Set<Project> fredProjects = new HashSet<Project>();
             fredProjects.add(FALTEN);
             fredProjects.add(ZAEHLEN);
             fred.setProjects(fredProjects);
             em.persist(hans);
             em.persist(fred);
             env.commitTransactionAndClear(em);
             HANS_SET.clear();
             for (final Project element : hansProjects) {
                 HANS_SET.add(new Pair(HANS_ID_VALUE, element.getId()));
             }
             FRED_SET.clear();
             for (final Project element : fredProjects) {
                 FRED_SET.add(new Pair(FRED_ID_VALUE, element.getId()));
             }
             SEED_SET.clear();
             SEED_SET.addAll(HANS_SET);
             SEED_SET.addAll(FRED_SET);
         } finally {
             env.evictAll(em);
             closeEntityManager(em);
         }
     }

     @Test
     public void testUnchanged() throws SQLException {
         JPAEnvironment env = getEnvironment();
         EntityManager em = env.getEntityManager();
         try {
             // 1. do nothing
             env.beginTransaction(em);
             Employee emp = em.find(Employee.class, HANS_ID);
             // do nothing
             emp.clearPostUpdate();
             env.commitTransactionAndClear(em);
             verify(!emp.postUpdateWasCalled(), "postUpdate was called");
             checkJoinTable(SEED_SET);
             // 2. touch the projects
             env.beginTransaction(em);
             emp = em.find(Employee.class, HANS_ID);
             emp.getProjects().size();
             emp.clearPostUpdate();
             env.commitTransactionAndClear(em);
             verify(!emp.postUpdateWasCalled(), "postUpdate was called");
             checkJoinTable(SEED_SET);
             // 3. trivial update
             env.beginTransaction(em);
             emp = em.find(Employee.class, HANS_ID);
             Set<Project> projects = emp.getProjects();
             emp.setProjects(new HashSet<Project>(projects));
             emp.clearPostUpdate();
             env.commitTransactionAndClear(em);
             verify(!emp.postUpdateWasCalled(), "postUpdate was called");
             checkJoinTable(SEED_SET);
         } finally {
             closeEntityManager(em);
         }
     }

     private void checkJoinTable(final Set<Pair> expected) throws SQLException {
         DataSource ds = getEnvironment().getDataSource();
         Connection conn = ds.getConnection();
         Set<Pair> actual = new HashSet<Pair>();
         try {
             PreparedStatement pstmt = conn.prepareStatement("SELECT EMP_ID, PROJECT_ID FROM TMP_EMP_PROJECT");
             try {
                 ResultSet rs = pstmt.executeQuery();
                 try {
                     while (rs.next()) {
                         actual.add(new Pair(rs.getInt("EMP_ID"), rs.getInt("PROJECT_ID")));
                     }
                 } finally {
                     rs.close();
                 }
             } finally {
                 pstmt.close();
             }
         } finally {
             conn.close();
         }
         if (expected.size() != actual.size()) {
             flop("actual set has wrong size " + actual.size() + " expected: " + expected.size());
         } else {
             verify(true, "");
         }
         verify(expected.containsAll(actual), "actual set contains some elements missing in the expected set");
         verify(actual.containsAll(expected), "expected set contains some elements missing in the actual set");
     }

     @Test
     public void testDeleteEmployee() throws SQLException {
         JPAEnvironment env = getEnvironment();
         EntityManager em = env.getEntityManager();
         try {
             env.beginTransaction(em);
             Employee emp = em.find(Employee.class, HANS_ID);
             verify(emp != null, "employee not found");
             em.remove(emp);
             env.commitTransactionAndClear(em);
             checkJoinTable(FRED_SET);
         } finally {
             closeEntityManager(em);
         }
     }

     @Test
     public void testDeleteNonSharedProject() throws SQLException {
         // remove a project that is not shared between employees:
         // 1) remove project from set of projects of employee
         // 2) remove employee from set of employees of project
         // 3) remove the project from the database
         JPAEnvironment env = getEnvironment();
         EntityManager em = env.getEntityManager();
         try {
             final int removeId = PUHLEN.getId();
             env.beginTransaction(em);
             Employee emp = em.find(Employee.class, HANS_ID);
             verify(emp != null, "employee not found");
             Set<Project> projects = emp.getProjects();
             verify(projects != null, "projects are null");
             verify(projects.size() == 3, "not exactly 3 projects but " + projects.size());
             Iterator<Project> iter = projects.iterator();
             while (iter.hasNext()) {
                 Project project = iter.next();
                 if (project.getId() == removeId) {
                     Set<Employee> employeesOfProject = project.getEmployees();
                     employeesOfProject.remove(emp);
                     em.remove(project);
                     iter.remove();
                     break;
                 }
             }
             verify(projects.size() == 2, "no project removed");
             emp.clearPostUpdate();
             env.commitTransactionAndClear(em);
             verify(emp.postUpdateWasCalled(), "post update was not called");
             Set<Pair> expected = new HashSet<Pair>(SEED_SET);
             expected.remove(new Pair(HANS_ID_VALUE, removeId));
             checkJoinTable(expected);
             env.beginTransaction(em);
             emp = em.find(Employee.class, HANS_ID);
             projects = emp.getProjects();
             verify(projects.size() == 2, "not exactly 2 projects but " + projects.size());
             Object object = em.find(Project.class, removeId);
             verify(object == null, "project found");
             env.rollbackTransactionAndClear(em);
         } finally {
             closeEntityManager(em);
         }
     }

     @Test
     public void testDeleteSharedProject() throws SQLException {
         // remove a project that is shared between employees:
         // 1) remove project from set of projects of employee
         // 2) remove employee from set of employees of project
         // 3) don't remove the project from the database
         JPAEnvironment env = getEnvironment();
         EntityManager em = env.getEntityManager();
         try {
             final int REMOVE_ID = FALTEN.getId();
             env.beginTransaction(em);
             Employee emp = em.find(Employee.class, HANS_ID);
             verify(emp != null, "employee not found");
             Set<Project> projects = emp.getProjects();
             verify(projects != null, "projects are null");
             verify(projects.size() == 3, "not exactly 3 projects but " + projects.size());
             Iterator<Project> iter = projects.iterator();
             while (iter.hasNext()) {
                 Project project = iter.next();
                 if (project.getId() == REMOVE_ID) {
                     Set<Employee> employeesOfProject = project.getEmployees();
                     employeesOfProject.remove(emp);
                     iter.remove();
                 }
             }
             verify(projects.size() == 2, "no project removed");
             emp.clearPostUpdate();
             env.commitTransactionAndClear(em);
             verify(emp.postUpdateWasCalled(), "post update was not called");
             Set<Pair> expected = new HashSet<Pair>(SEED_SET);
             expected.remove(new Pair(HANS_ID_VALUE, REMOVE_ID));
             checkJoinTable(expected);
             env.beginTransaction(em);
             emp = em.find(Employee.class, HANS_ID);
             projects = emp.getProjects();
             verify(projects.size() == 2, "not exactly 2 projects but " + projects.size());
             env.rollbackTransactionAndClear(em);
         } finally {
             closeEntityManager(em);
         }
     }

     @Test
     public void testAdd() throws SQLException {
         JPAEnvironment env = getEnvironment();
         EntityManager em = env.getEntityManager();
         try {
             env.beginTransaction(em);
             final int newId;
             Employee emp = em.find(Employee.class, HANS_ID);
             verify(emp != null, "employee not found");
             Set<Project> projects = emp.getProjects();
             Project p6 = new Project("Nasen bohren");
             em.persist(p6);
             newId = p6.getId();
             projects.add(p6);
             emp.clearPostUpdate();
             env.commitTransactionAndClear(em);
             verify(emp.postUpdateWasCalled(), "post update was not called");
             Set<Pair> expected = new HashSet<Pair>(SEED_SET);
             expected.add(new Pair(HANS_ID_VALUE, newId));
             checkJoinTable(expected);
             env.beginTransaction(em);
             emp = em.find(Employee.class, HANS_ID);
             projects = emp.getProjects();
             verify(projects.size() == 4, "not exactly 4 projects but " + projects.size());
             env.rollbackTransactionAndClear(em);
         } finally {
             closeEntityManager(em);
         }
     }

     @Test
     public void testExchange() throws SQLException {
         JPAEnvironment env = getEnvironment();
         EntityManager em = env.getEntityManager();
         try {
             final int newId;
             env.beginTransaction(em);
             Employee emp = em.find(Employee.class, HANS_ID);
             verify(emp != null, "employee not found");
             Set<Project> projects = emp.getProjects();
             Iterator<Project> iter = projects.iterator();
             Project project = iter.next();
             int removedId = project.getId();
             // there are no managed relationships -> we have to remove the projects on both sides
             em.remove(project);
             iter.remove();
             Project p7 = new Project("Ohren wacklen");
             em.persist(p7);
             newId = p7.getId();
             projects.add(p7);
             emp.clearPostUpdate();
             env.commitTransactionAndClear(em);
             verify(emp.postUpdateWasCalled(), "post update was not called");
             Set<Pair> expected = new HashSet<Pair>(SEED_SET);
             expected.remove(new Pair(HANS_ID_VALUE, removedId));
             //we need to remove also record with Fred (if applicable), because if Fred had associated project, which is now removed,
             //he is not associated with the project anymore
             expected.remove(new Pair(FRED_ID_VALUE, removedId));
             expected.add(new Pair(HANS_ID_VALUE, newId));
             checkJoinTable(expected);
             env.beginTransaction(em);
             emp = em.find(Employee.class, HANS_ID);
             projects = emp.getProjects();
             verify(projects.size() == 3, "not exactly 3 projects but " + projects.size());
             env.rollbackTransactionAndClear(em);
         } finally {
             env.evictAll(em);
             closeEntityManager(em);
         }
     }

     private void verifyEmployees(EntityManager em, int id, int size) {
         Project project = em.find(Project.class, id);
         verify(project != null, "project not found");
         Set<Employee> employees = project.getEmployees();
         verify(employees.size() == size, "wrong number of employees: " + employees.size() + " expected: " + size);
     }

     @Test
     public void testGetEmployees() {
         JPAEnvironment env = getEnvironment();
         EntityManager em = env.getEntityManager();
         try {
             env.beginTransaction(em);
             verifyEmployees(em, LINKEN.getId(), 0);
             verifyEmployees(em, PUHLEN.getId(), 1);
             verifyEmployees(em, FALTEN.getId(), 2);
             env.rollbackTransactionAndClear(em);
         } finally {
             closeEntityManager(em);
         }
     }

     @Test
     public void testCopyProjectsToNew() throws SQLException {
         // copy all projects from hans to a new employee with out actually touching them
         JPAEnvironment env = getEnvironment();
         EntityManager em = env.getEntityManager();
         try {
             final int newId = 19;
             env.beginTransaction(em);
             Employee hans = em.find(Employee.class, HANS_ID);
             Employee paul = new Employee(19, "Paul", "Knack", null);
             paul.setProjects(hans.getProjects());
             em.persist(paul);
             env.commitTransactionAndClear(em);
             Set<Pair> expected = new HashSet<Pair>(SEED_SET);
             for (Pair pair : HANS_SET) {
                 expected.add(new Pair(newId, pair.getProjectId()));
             }
             checkJoinTable(expected);
             env.beginTransaction(em);
             paul = em.find(Employee.class, newId);
             verify(paul.getProjects().size() == HANS_SET.size(), "Paul has wrong number of projects");
             env.rollbackTransactionAndClear(em);
         } finally {
             closeEntityManager(em);
         }
     }

     @Bugzilla(bugid=300503)
     @Test
     public void testCopyProjectsToExisting() throws SQLException {
         // copy all projects from hans to a new employee with out actually touching them
         JPAEnvironment env = getEnvironment();
         EntityManager em = env.getEntityManager();
         try {
             env.beginTransaction(em);
             Employee hans = em.find(Employee.class, HANS_ID);
             Employee fred = em.find(Employee.class, FRED_ID);
             fred.setProjects(hans.getProjects());
             env.commitTransactionAndClear(em);
             Set<Pair> expected = new HashSet<Pair>(SEED_SET);
             expected.removeAll(FRED_SET);
             for (Pair pair : HANS_SET) {
                 expected.add(new Pair(FRED_ID_VALUE, pair.getProjectId()));
             }
             checkJoinTable(expected);
             env.beginTransaction(em);
             fred = em.find(Employee.class, FRED_ID);
             verify(fred.getProjects().size() == HANS_SET.size(), "Paul has wrong number of projects");
             env.rollbackTransactionAndClear(em);
         } finally {
             closeEntityManager(em);
         }
     }

     @Test
     public void testCopyProjectsToExistingTouching() throws SQLException {
         // copy all projects from hans to a new employee with out actually touching them
         JPAEnvironment env = getEnvironment();
         EntityManager em = env.getEntityManager();
         try {
             env.beginTransaction(em);
             Employee hans = em.find(Employee.class, HANS_ID);
             Employee fred = em.find(Employee.class, FRED_ID);
             hans.getProjects().size();
             fred.setProjects(hans.getProjects());
             env.commitTransactionAndClear(em);
             Set<Pair> expected = new HashSet<Pair>(SEED_SET);
             expected.removeAll(FRED_SET);
             for (Pair pair : HANS_SET) {
                 expected.add(new Pair(FRED_ID_VALUE, pair.getProjectId()));
             }
             checkJoinTable(expected);
             env.beginTransaction(em);
             fred = em.find(Employee.class, FRED_ID);
             verify(fred.getProjects().size() == HANS_SET.size(), "Paul has wrong number of projects");
             env.rollbackTransactionAndClear(em);
         } finally {
             closeEntityManager(em);
         }
     }

     @Test
     public void testGuidCollection() throws SQLException {
         JPAEnvironment env = getEnvironment();
         EntityManager em = env.getEntityManager();
         byte[] id1 = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 };
         byte[] id2 = new byte[] { 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 };
         try {
             TravelProfile profile1 = new TravelProfile(id1, true, "neverComeBack");
             TravelProfile profile2 = new TravelProfile(id2, true, "flyAway");
             Set<TravelProfile> profileSet = new HashSet<TravelProfile>();
             profileSet.add(profile1);
             profileSet.add(profile2);

             Vehicle vehicle = new Vehicle();
             Set<Vehicle> vehicleSet = new HashSet<Vehicle>();
             vehicleSet.add(vehicle);

             profile1.setVehicles(vehicleSet);
             profile2.setVehicles(vehicleSet);
             vehicle.setProfiles(profileSet);

             env.beginTransaction(em);
             em.persist(profile1);
             em.persist(profile2);
             em.persist(vehicle);
             env.commitTransactionAndClear(em);
         } finally {
             closeEntityManager(em);
         }
     }

     @Test
     public void testByteItem() {
         JPAEnvironment env = getEnvironment();
         EntityManager em = env.getEntityManager();
         byte[] id1 = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 };
         try {
             env.beginTransaction(em);
             Item_Byte item = new Item_Byte(id1, "a", "b", "c");
             item.addAttr("key1", "value1");
             em.persist(item);
             env.commitTransactionAndClear(em);
             item = em.find(Item_Byte.class, id1);
             item.getAttributes();
         } finally {
             closeEntityManager(em);
         }
     }

     @Test
     public void testCascadeMerge() throws IOException, ClassNotFoundException {
         JPAEnvironment env = getEnvironment();
         EntityManager em = env.getEntityManager();

         try {
             env.beginTransaction(em);
             em.createQuery("delete from Employee").executeUpdate();
             em.createQuery("delete from Vehicle").executeUpdate();
             env.commitTransactionAndClear(em);

             env.beginTransaction(em);
             Bicycle bicycle = new Bicycle();
             em.persist(bicycle);

             Short bikeId = bicycle.getId();
             env.commitTransaction(em);

             bicycle = em.find(Bicycle.class, bikeId);
             em.clear();

             bicycle = AbstractBaseTest.serializeDeserialize(bicycle);
             // bicycle should be detached

             Employee emp = new Employee(9999, "Robbi", "Tobbi", null);
             emp.clearPostPersist();
             bicycle.setRiders(Collections.singleton(emp));
             env.beginTransaction(em);
             Bicycle mergedBike = em.merge(bicycle);
             env.commitTransactionAndClear(em);

             Employee mergedEmp = mergedBike.getRiders().iterator().next();

             verify(mergedEmp.postPersistWasCalled(), "merge did not cascade to employee");

             verify(em.find(Employee.class, 9999) != null, "employee not found");

         } finally {
             closeEntityManager(em);
         }
     }

     private static class Pair {
         @Override
         public boolean equals(Object obj) {
             if (obj instanceof Pair) {
                 Pair other = (Pair) obj;
                 return other.empId == empId && other.projectId == projectId;
             }
             return false;
         }

         @Override
         public int hashCode() {
             return empId + 17 * projectId;
         }

         /**
          * @return Returns the empId.
          */
         @SuppressWarnings("unused")
         public int getEmpId() {
             return empId;
         }

         /**
          * @return Returns the projectId.
          */
         public int getProjectId() {
             return projectId;
         }

         final int empId;
         final int projectId;

         Pair(int e, int r) {
             empId = e;
             projectId = r;
         }
     }
 }
	/*
	* Copyright (c) 2005, 2021 Oracle and/or its affiliates. All rights reserved.
	* Copyright (c) 2005, 2015 SAP. All rights reserved.
	*
	* This program and the accompanying materials are made available under the
	* terms of the Eclipse Public License v. 2.0 which is available at
	* http://www.eclipse.org/legal/epl-2.0,
	* or the Eclipse Distribution License v. 1.0 which is available at
	* http://www.eclipse.org/org/documents/edl-v10.php.
	*
	* SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
	*/

	// Contributors:
	// SAP - initial API and implementation

	package org.eclipse.persistence.testing.tests.wdf.jpa1.relation;

	import java.io.IOException;
	import java.sql.Connection;
	import java.sql.PreparedStatement;
	import java.sql.ResultSet;
	import java.sql.SQLException;
	import java.util.Collections;
	import java.util.HashSet;
	import java.util.Iterator;
	import java.util.Set;

	import jakarta.persistence.EntityManager;
	import javax.sql.DataSource;

	import org.eclipse.persistence.testing.framework.wdf.AbstractBaseTest;
	import org.eclipse.persistence.testing.framework.wdf.Bugzilla;
	import org.eclipse.persistence.testing.framework.wdf.JPAEnvironment;
	import org.eclipse.persistence.testing.models.wdf.jpa1.employee.Bicycle;
	import org.eclipse.persistence.testing.models.wdf.jpa1.employee.Department;
	import org.eclipse.persistence.testing.models.wdf.jpa1.employee.Employee;
	import org.eclipse.persistence.testing.models.wdf.jpa1.employee.Item_Byte;
	import org.eclipse.persistence.testing.models.wdf.jpa1.employee.Project;
	import org.eclipse.persistence.testing.models.wdf.jpa1.employee.TravelProfile;
	import org.eclipse.persistence.testing.models.wdf.jpa1.employee.Vehicle;
	import org.eclipse.persistence.testing.tests.wdf.jpa1.JPA1Base;
	import org.junit.Before;
	import org.junit.Test;

	@SuppressWarnings("unchecked")
	public class TestBidirectionalManyToMany extends JPA1Base {

	private static final int HANS_ID_VALUE = 1;
	private static final Integer HANS_ID = HANS_ID_VALUE;
	private static final Set<Pair> HANS_SET = new HashSet<Pair>();
	private static final int FRED_ID_VALUE = 2;
	private static final Integer FRED_ID = FRED_ID_VALUE;
	private static final Set<Pair> FRED_SET = new HashSet<Pair>();
	private static final Set<Pair> SEED_SET = new HashSet<Pair>();
	private static final Project PUHLEN = new Project("G\u00fcrteltiere puhlen");
	private static final Project PINSELN = new Project("B\u00e4uche pinseln");
	private static final Project FALTEN = new Project("Zitronen falten");
	private static final Project ZAEHLEN = new Project("Erbsen z\u00e4hlen");
	private static final Project LINKEN = new Project("Eclipse Linken");

	@Before
	public void initData() throws SQLException {
	/*
	* 5 Projects:
	*/
	clearAllTables();
	JPAEnvironment env = getEnvironment();
	EntityManager em = env.getEntityManager();
	try {
	env.beginTransaction(em);
	Department dep = new Department(17, "diverses");
	em.persist(dep);
	em.persist(PUHLEN);
	em.persist(PINSELN);
	em.persist(FALTEN);
	em.persist(ZAEHLEN);
	em.persist(LINKEN);
	Employee hans = new Employee(HANS_ID_VALUE, "Hans", "Wurst", dep);
	Set<Project> hansProjects = new HashSet<Project>();
	hansProjects.add(PUHLEN);
	hansProjects.add(PINSELN);
	hansProjects.add(FALTEN);
	hans.setProjects(hansProjects);
	Employee fred = new Employee(FRED_ID_VALUE, "Fred von", "Jupiter", dep);
	Set<Project> fredProjects = new HashSet<Project>();
	fredProjects.add(FALTEN);
	fredProjects.add(ZAEHLEN);
	fred.setProjects(fredProjects);
	em.persist(hans);
	em.persist(fred);
	env.commitTransactionAndClear(em);
	HANS_SET.clear();
	for (final Project element : hansProjects) {
	HANS_SET.add(new Pair(HANS_ID_VALUE, element.getId()));
	}
	FRED_SET.clear();
	for (final Project element : fredProjects) {
	FRED_SET.add(new Pair(FRED_ID_VALUE, element.getId()));
	}
	SEED_SET.clear();
	SEED_SET.addAll(HANS_SET);
	SEED_SET.addAll(FRED_SET);
	} finally {
	env.evictAll(em);
	closeEntityManager(em);
	}
	}

	@Test
	public void testUnchanged() throws SQLException {
	JPAEnvironment env = getEnvironment();
	EntityManager em = env.getEntityManager();
	try {
	// 1. do nothing
	env.beginTransaction(em);
	Employee emp = em.find(Employee.class, HANS_ID);
	// do nothing
	emp.clearPostUpdate();
	env.commitTransactionAndClear(em);
	verify(!emp.postUpdateWasCalled(), "postUpdate was called");
	checkJoinTable(SEED_SET);
	// 2. touch the projects
	env.beginTransaction(em);
	emp = em.find(Employee.class, HANS_ID);
	emp.getProjects().size();
	emp.clearPostUpdate();
	env.commitTransactionAndClear(em);
	verify(!emp.postUpdateWasCalled(), "postUpdate was called");
	checkJoinTable(SEED_SET);
	// 3. trivial update
	env.beginTransaction(em);
	emp = em.find(Employee.class, HANS_ID);
	Set<Project> projects = emp.getProjects();
	emp.setProjects(new HashSet<Project>(projects));
	emp.clearPostUpdate();
	env.commitTransactionAndClear(em);
	verify(!emp.postUpdateWasCalled(), "postUpdate was called");
	checkJoinTable(SEED_SET);
	} finally {
	closeEntityManager(em);
	}
	}

	private void checkJoinTable(final Set<Pair> expected) throws SQLException {
	DataSource ds = getEnvironment().getDataSource();
	Connection conn = ds.getConnection();
	Set<Pair> actual = new HashSet<Pair>();
	try {
	PreparedStatement pstmt = conn.prepareStatement("SELECT EMP_ID, PROJECT_ID FROM TMP_EMP_PROJECT");
	try {
	ResultSet rs = pstmt.executeQuery();
	try {
	while (rs.next()) {
	actual.add(new Pair(rs.getInt("EMP_ID"), rs.getInt("PROJECT_ID")));
	}
	} finally {
	rs.close();
	}
	} finally {
	pstmt.close();
	}
	} finally {
	conn.close();
	}
	if (expected.size() != actual.size()) {
	flop("actual set has wrong size " + actual.size() + " expected: " + expected.size());
	} else {
	verify(true, "");
	}
	verify(expected.containsAll(actual), "actual set contains some elements missing in the expected set");
	verify(actual.containsAll(expected), "expected set contains some elements missing in the actual set");
	}

	@Test
	public void testDeleteEmployee() throws SQLException {
	JPAEnvironment env = getEnvironment();
	EntityManager em = env.getEntityManager();
	try {
	env.beginTransaction(em);
	Employee emp = em.find(Employee.class, HANS_ID);
	verify(emp != null, "employee not found");
	em.remove(emp);
	env.commitTransactionAndClear(em);
	checkJoinTable(FRED_SET);
	} finally {
	closeEntityManager(em);
	}
	}

	@Test
	public void testDeleteNonSharedProject() throws SQLException {
	// remove a project that is not shared between employees:
	// 1) remove project from set of projects of employee
	// 2) remove employee from set of employees of project
	// 3) remove the project from the database
	JPAEnvironment env = getEnvironment();
	EntityManager em = env.getEntityManager();
	try {
	final int removeId = PUHLEN.getId();
	env.beginTransaction(em);
	Employee emp = em.find(Employee.class, HANS_ID);
	verify(emp != null, "employee not found");
	Set<Project> projects = emp.getProjects();
	verify(projects != null, "projects are null");
	verify(projects.size() == 3, "not exactly 3 projects but " + projects.size());
	Iterator<Project> iter = projects.iterator();
	while (iter.hasNext()) {
	Project project = iter.next();
	if (project.getId() == removeId) {
	Set<Employee> employeesOfProject = project.getEmployees();
	employeesOfProject.remove(emp);
	em.remove(project);
	iter.remove();
	break;
	}
	}
	verify(projects.size() == 2, "no project removed");
	emp.clearPostUpdate();
	env.commitTransactionAndClear(em);
	verify(emp.postUpdateWasCalled(), "post update was not called");
	Set<Pair> expected = new HashSet<Pair>(SEED_SET);
	expected.remove(new Pair(HANS_ID_VALUE, removeId));
	checkJoinTable(expected);
	env.beginTransaction(em);
	emp = em.find(Employee.class, HANS_ID);
	projects = emp.getProjects();
	verify(projects.size() == 2, "not exactly 2 projects but " + projects.size());
	Object object = em.find(Project.class, removeId);
	verify(object == null, "project found");
	env.rollbackTransactionAndClear(em);
	} finally {
	closeEntityManager(em);
	}
	}

	@Test
	public void testDeleteSharedProject() throws SQLException {
	// remove a project that is shared between employees:
	// 1) remove project from set of projects of employee
	// 2) remove employee from set of employees of project
	// 3) don't remove the project from the database
	JPAEnvironment env = getEnvironment();
	EntityManager em = env.getEntityManager();
	try {
	final int REMOVE_ID = FALTEN.getId();
	env.beginTransaction(em);
	Employee emp = em.find(Employee.class, HANS_ID);
	verify(emp != null, "employee not found");
	Set<Project> projects = emp.getProjects();
	verify(projects != null, "projects are null");
	verify(projects.size() == 3, "not exactly 3 projects but " + projects.size());
	Iterator<Project> iter = projects.iterator();
	while (iter.hasNext()) {
	Project project = iter.next();
	if (project.getId() == REMOVE_ID) {
	Set<Employee> employeesOfProject = project.getEmployees();
	employeesOfProject.remove(emp);
	iter.remove();
	}
	}
	verify(projects.size() == 2, "no project removed");
	emp.clearPostUpdate();
	env.commitTransactionAndClear(em);
	verify(emp.postUpdateWasCalled(), "post update was not called");
	Set<Pair> expected = new HashSet<Pair>(SEED_SET);
	expected.remove(new Pair(HANS_ID_VALUE, REMOVE_ID));
	checkJoinTable(expected);
	env.beginTransaction(em);
	emp = em.find(Employee.class, HANS_ID);
	projects = emp.getProjects();
	verify(projects.size() == 2, "not exactly 2 projects but " + projects.size());
	env.rollbackTransactionAndClear(em);
	} finally {
	closeEntityManager(em);
	}
	}

	@Test
	public void testAdd() throws SQLException {
	JPAEnvironment env = getEnvironment();
	EntityManager em = env.getEntityManager();
	try {
	env.beginTransaction(em);
	final int newId;
	Employee emp = em.find(Employee.class, HANS_ID);
	verify(emp != null, "employee not found");
	Set<Project> projects = emp.getProjects();
	Project p6 = new Project("Nasen bohren");
	em.persist(p6);
	newId = p6.getId();
	projects.add(p6);
	emp.clearPostUpdate();
	env.commitTransactionAndClear(em);
	verify(emp.postUpdateWasCalled(), "post update was not called");
	Set<Pair> expected = new HashSet<Pair>(SEED_SET);
	expected.add(new Pair(HANS_ID_VALUE, newId));
	checkJoinTable(expected);
	env.beginTransaction(em);
	emp = em.find(Employee.class, HANS_ID);
	projects = emp.getProjects();
	verify(projects.size() == 4, "not exactly 4 projects but " + projects.size());
	env.rollbackTransactionAndClear(em);
	} finally {
	closeEntityManager(em);
	}
	}

	@Test
	public void testExchange() throws SQLException {
	JPAEnvironment env = getEnvironment();
	EntityManager em = env.getEntityManager();
	try {
	final int newId;
	env.beginTransaction(em);
	Employee emp = em.find(Employee.class, HANS_ID);
	verify(emp != null, "employee not found");
	Set<Project> projects = emp.getProjects();
	Iterator<Project> iter = projects.iterator();
	Project project = iter.next();
	int removedId = project.getId();
	// there are no managed relationships -> we have to remove the projects on both sides
	em.remove(project);
	iter.remove();
	Project p7 = new Project("Ohren wacklen");
	em.persist(p7);
	newId = p7.getId();
	projects.add(p7);
	emp.clearPostUpdate();
	env.commitTransactionAndClear(em);
	verify(emp.postUpdateWasCalled(), "post update was not called");
	Set<Pair> expected = new HashSet<Pair>(SEED_SET);
	expected.remove(new Pair(HANS_ID_VALUE, removedId));
	//we need to remove also record with Fred (if applicable), because if Fred had associated project, which is now removed,
	//he is not associated with the project anymore
	expected.remove(new Pair(FRED_ID_VALUE, removedId));
	expected.add(new Pair(HANS_ID_VALUE, newId));
	checkJoinTable(expected);
	env.beginTransaction(em);
	emp = em.find(Employee.class, HANS_ID);
	projects = emp.getProjects();
	verify(projects.size() == 3, "not exactly 3 projects but " + projects.size());
	env.rollbackTransactionAndClear(em);
	} finally {
	env.evictAll(em);
	closeEntityManager(em);
	}
	}

	private void verifyEmployees(EntityManager em, int id, int size) {
	Project project = em.find(Project.class, id);
	verify(project != null, "project not found");
	Set<Employee> employees = project.getEmployees();
	verify(employees.size() == size, "wrong number of employees: " + employees.size() + " expected: " + size);
	}

	@Test
	public void testGetEmployees() {
	JPAEnvironment env = getEnvironment();
	EntityManager em = env.getEntityManager();
	try {
	env.beginTransaction(em);
	verifyEmployees(em, LINKEN.getId(), 0);
	verifyEmployees(em, PUHLEN.getId(), 1);
	verifyEmployees(em, FALTEN.getId(), 2);
	env.rollbackTransactionAndClear(em);
	} finally {
	closeEntityManager(em);
	}
	}

	@Test
	public void testCopyProjectsToNew() throws SQLException {
	// copy all projects from hans to a new employee with out actually touching them
	JPAEnvironment env = getEnvironment();
	EntityManager em = env.getEntityManager();
	try {
	final int newId = 19;
	env.beginTransaction(em);
	Employee hans = em.find(Employee.class, HANS_ID);
	Employee paul = new Employee(19, "Paul", "Knack", null);
	paul.setProjects(hans.getProjects());
	em.persist(paul);
	env.commitTransactionAndClear(em);
	Set<Pair> expected = new HashSet<Pair>(SEED_SET);
	for (Pair pair : HANS_SET) {
	expected.add(new Pair(newId, pair.getProjectId()));
	}
	checkJoinTable(expected);
	env.beginTransaction(em);
	paul = em.find(Employee.class, newId);
	verify(paul.getProjects().size() == HANS_SET.size(), "Paul has wrong number of projects");
	env.rollbackTransactionAndClear(em);
	} finally {
	closeEntityManager(em);
	}
	}

	@Bugzilla(bugid=300503)
	@Test
	public void testCopyProjectsToExisting() throws SQLException {
	// copy all projects from hans to a new employee with out actually touching them
	JPAEnvironment env = getEnvironment();
	EntityManager em = env.getEntityManager();
	try {
	env.beginTransaction(em);
	Employee hans = em.find(Employee.class, HANS_ID);
	Employee fred = em.find(Employee.class, FRED_ID);
	fred.setProjects(hans.getProjects());
	env.commitTransactionAndClear(em);
	Set<Pair> expected = new HashSet<Pair>(SEED_SET);
	expected.removeAll(FRED_SET);
	for (Pair pair : HANS_SET) {
	expected.add(new Pair(FRED_ID_VALUE, pair.getProjectId()));
	}
	checkJoinTable(expected);
	env.beginTransaction(em);
	fred = em.find(Employee.class, FRED_ID);
	verify(fred.getProjects().size() == HANS_SET.size(), "Paul has wrong number of projects");
	env.rollbackTransactionAndClear(em);
	} finally {
	closeEntityManager(em);
	}
	}

	@Test
	public void testCopyProjectsToExistingTouching() throws SQLException {
	// copy all projects from hans to a new employee with out actually touching them
	JPAEnvironment env = getEnvironment();
	EntityManager em = env.getEntityManager();
	try {
	env.beginTransaction(em);
	Employee hans = em.find(Employee.class, HANS_ID);
	Employee fred = em.find(Employee.class, FRED_ID);
	hans.getProjects().size();
	fred.setProjects(hans.getProjects());
	env.commitTransactionAndClear(em);
	Set<Pair> expected = new HashSet<Pair>(SEED_SET);
	expected.removeAll(FRED_SET);
	for (Pair pair : HANS_SET) {
	expected.add(new Pair(FRED_ID_VALUE, pair.getProjectId()));
	}
	checkJoinTable(expected);
	env.beginTransaction(em);
	fred = em.find(Employee.class, FRED_ID);
	verify(fred.getProjects().size() == HANS_SET.size(), "Paul has wrong number of projects");
	env.rollbackTransactionAndClear(em);
	} finally {
	closeEntityManager(em);
	}
	}

	@Test
	public void testGuidCollection() throws SQLException {
	JPAEnvironment env = getEnvironment();
	EntityManager em = env.getEntityManager();
	byte[] id1 = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 };
	byte[] id2 = new byte[] { 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 };
	try {
	TravelProfile profile1 = new TravelProfile(id1, true, "neverComeBack");
	TravelProfile profile2 = new TravelProfile(id2, true, "flyAway");
	Set<TravelProfile> profileSet = new HashSet<TravelProfile>();
	profileSet.add(profile1);
	profileSet.add(profile2);

	Vehicle vehicle = new Vehicle();
	Set<Vehicle> vehicleSet = new HashSet<Vehicle>();
	vehicleSet.add(vehicle);

	profile1.setVehicles(vehicleSet);
	profile2.setVehicles(vehicleSet);
	vehicle.setProfiles(profileSet);

	env.beginTransaction(em);
	em.persist(profile1);
	em.persist(profile2);
	em.persist(vehicle);
	env.commitTransactionAndClear(em);
	} finally {
	closeEntityManager(em);
	}
	}

	@Test
	public void testByteItem() {
	JPAEnvironment env = getEnvironment();
	EntityManager em = env.getEntityManager();
	byte[] id1 = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 };
	try {
	env.beginTransaction(em);
	Item_Byte item = new Item_Byte(id1, "a", "b", "c");
	item.addAttr("key1", "value1");
	em.persist(item);
	env.commitTransactionAndClear(em);
	item = em.find(Item_Byte.class, id1);
	item.getAttributes();
	} finally {
	closeEntityManager(em);
	}
	}

	@Test
	public void testCascadeMerge() throws IOException, ClassNotFoundException {
	JPAEnvironment env = getEnvironment();
	EntityManager em = env.getEntityManager();

	try {
	env.beginTransaction(em);
	em.createQuery("delete from Employee").executeUpdate();
	em.createQuery("delete from Vehicle").executeUpdate();
	env.commitTransactionAndClear(em);

	env.beginTransaction(em);
	Bicycle bicycle = new Bicycle();
	em.persist(bicycle);

	Short bikeId = bicycle.getId();
	env.commitTransaction(em);

	bicycle = em.find(Bicycle.class, bikeId);
	em.clear();

	bicycle = AbstractBaseTest.serializeDeserialize(bicycle);
	// bicycle should be detached

	Employee emp = new Employee(9999, "Robbi", "Tobbi", null);
	emp.clearPostPersist();
	bicycle.setRiders(Collections.singleton(emp));
	env.beginTransaction(em);
	Bicycle mergedBike = em.merge(bicycle);
	env.commitTransactionAndClear(em);

	Employee mergedEmp = mergedBike.getRiders().iterator().next();

	verify(mergedEmp.postPersistWasCalled(), "merge did not cascade to employee");

	verify(em.find(Employee.class, 9999) != null, "employee not found");

	} finally {
	closeEntityManager(em);
	}
	}

	private static class Pair {
	@Override
	public boolean equals(Object obj) {
	if (obj instanceof Pair) {
	Pair other = (Pair) obj;
	return other.empId == empId && other.projectId == projectId;
	}
	return false;
	}

	@Override
	public int hashCode() {
	return empId + 17 * projectId;
	}

	/**
	* @return Returns the empId.
	*/
	@SuppressWarnings("unused")
	public int getEmpId() {
	return empId;
	}

	/**
	* @return Returns the projectId.
	*/
	public int getProjectId() {
	return projectId;
	}

	final int empId;
	final int projectId;

	Pair(int e, int r) {
	empId = e;
	projectId = r;
	}
	}
	}