public void populate(DatabaseSession session) {
    Employee instance;
    PopulationManager manager = PopulationManager.getDefaultManager();

    instance = Employee.example1();
    session.writeObject(instance);
    manager.registerObject(instance, "example1");
    manager.registerObject(instance.computer, "example1");
    manager.registerObject(instance.shipments.firstElement(), "example1");
    manager.registerObject(
        ((Shipment) instance.shipments.firstElement()).orders.firstElement(), "example1");

    instance = Employee.example2();
    session.writeObject(instance);
    manager.registerObject(instance, "example2");
    manager.registerObject(instance.computer, "example2");
    manager.registerObject(instance.shipments.firstElement(), "example2");
    manager.registerObject(
        ((Shipment) instance.shipments.firstElement()).orders.firstElement(), "example2");

    instance = Employee.example3();
    session.writeObject(instance);
    manager.registerObject(instance, "example3");
    manager.registerObject(instance.computer, "example3");
    manager.registerObject(instance.shipments.firstElement(), "example3");
    manager.registerObject(
        ((Shipment) instance.shipments.firstElement()).orders.firstElement(), "example3");
  }
  /**
   * Return the first employee that has a long enough name for the test. If no match is found throw
   * a warning exception. See bug 223005
   *
   * @param vectorOfEmployees
   * @param minFirstNameLength
   * @param testName
   * @return
   */
  public Employee getEmployeeWithRequiredNameLength(
      Vector vectorOfEmployees, int minFirstNameLength, String testName) {
    Employee empMatch = null;
    Vector<Employee> employees = vectorOfEmployees;
    String firstName;
    StringBuffer partialFirstName;

    // Loop through the collection of employees to find one that matches our test requirements
    for (int i = 0; i < employees.size(); i++) {
      empMatch = employees.get(i);
      firstName = empMatch.getFirstName();
      // Verify length criteria
      if (firstName.length() >= minFirstNameLength) {
        // exit the for loop - return the last empMatch
        i = employees.size();
      }
    }

    // If we could not find a proper employee for testing - throw a warning
    if (null == empMatch) {
      throw new RuntimeException(
          testName
              + " Setup Failed: unable to find an Employee with firstName size of at least  "
              + minFirstNameLength);
    } else {
      return empMatch;
    }
  }
  public void test() {
    // test readAll
    getSession().readAllObjects(Employee.class);
    getSession().getIdentityMapAccessor().initializeIdentityMap(Employee.class);

    // test readObject
    Employee employee =
        (Employee)
            getSession().readObject(Employee.class, new ExpressionBuilder().get("id").equal(99));

    // test delete with an employee read from the database
    employee = (Employee) getSession().readObject(Employee.class);
    try {
      getAbstractSession().deleteObject(employee);
    } catch (DatabaseException exc) {
      // if we get an integrity exception here, the query went to the DB and was not redirected
      redirectedDeleteObject = false;
    }

    UnitOfWork uow = getSession().acquireUnitOfWork();
    // test update with an employee read from the database
    employee = (Employee) uow.readObject(Employee.class);
    employee.setFirstName(employee.getFirstName() + "-changed");

    // insert an employee to test the insert behavior
    employee = new Employee();
    employee.setFirstName("Paul");
    employee.setLastName("Sheldon");
    uow.registerObject(employee);

    uow.commit();
  }
  protected void verify() {
    if (!employee.getAddress().getCity().equals("null")) {
      throw new TestErrorException("Null value not converted correctly for string.");
    }

    if (employee.getSalary() != -1) {
      throw new TestErrorException("Null value not converted correctly for int.");
    }
  }
  protected void test() {
    UnitOfWork uow = getSession().acquireUnitOfWork();
    ReadObjectQuery query = new ReadObjectQuery(Employee.class);
    query.setLockMode(ObjectLevelReadQuery.LOCK_NOWAIT);
    Employee emp = (Employee) uow.executeQuery(query);

    emp.setSalary(emp.getSalary() + 1);
    uow.commit();
  }
  protected void test() {
    UnitOfWork uow = getSession().acquireUnitOfWork();

    Employee empInsert = new Employee();
    empInsert.setFirstName("TestPerson");
    empInsert.setFemale();
    empInsert.setLastName("Smith");
    empInsert.setSalary(55555);
    uow.registerObject(empInsert);
    uow.commit();
  }
  private void setArgumentsForTestUsing(Vector employees) {
    setArguments(new Vector());

    Enumeration names = getExpressionParameters().elements();
    Enumeration employeeEnum = employees.elements();
    while (names.hasMoreElements()) {
      Employee emp = (Employee) employeeEnum.nextElement();
      getArguments().add(emp.getId());
      names.nextElement();
    }
  }
  public void setup() {

    // This method tests the specail operations:
    employee = new Employee();
    policy = new QueryByExamplePolicy();
    employee.setFirstName("J__l");
    employee.setLastName("M%");
    employee.setSalary(60000);

    policy.addSpecialOperation(Integer.class, "lessThan");
    policy.addSpecialOperation(String.class, "like");
  }
 public void test() {
   UnitOfWork uow = getSession().acquireUnitOfWork();
   Employee managerClone = (Employee) uow.registerObject(employee[0]);
   // remove all managed Employees (1 and 2)
   managerClone.getManagedEmployees().clear();
   // add to managed list new Employees (3 and 4)
   Employee employee3Clone = (Employee) uow.registerObject(employee[3]);
   Employee employee4Clone = (Employee) uow.registerObject(employee[4]);
   managerClone.addManagedEmployee(employee3Clone);
   managerClone.addManagedEmployee(employee4Clone);
   // after commit the  versions of all Employees should be changed.
   uow.commit();
 }
  public void test() {
    int size = getCacheIdentityMap().getMaxSize() * factor;

    for (int i = 0; i < size; i++) {
      BigDecimal id = new java.math.BigDecimal(i);
      Employee employee = new Employee();
      Vector pk = new Vector(1);
      employee.setId(id);
      employee.setFirstName("Joe");
      employee.setLastName("Blow");
      pk.add(id);
      getPrimaryKeys().add(pk);
      getCacheIdentityMap().put(primaryKeys, employee, null, 0);
    }
  }
 public void test() {
   UnitOfWork uow = getSession().acquireUnitOfWork();
   this.emp = Employee.example1();
   this.emp.asset1.asset = Vehicle.example1();
   uow.registerObject(this.emp);
   uow.commit();
   uow = getSession().acquireUnitOfWork();
   Employee empClone = (Employee) uow.registerObject(this.emp);
   Employee newClone = (Employee) empClone.clone();
   ((Vehicle) newClone.asset1.asset).make = "Beamer";
   uow.deepMergeClone(newClone);
   uow.commit();
   if (!((AbstractSession) getSession()).compareObjects(newClone, this.emp)) {
     throw new TestErrorException("Failed to merge the Variable 1 to 1 properly");
   }
 }
  public void test() {

    ReadObjectQuery query = new ReadObjectQuery();
    query.setReferenceClass(Employee.class);
    query.setExampleObject(employee);
    query.setQueryByExamplePolicy(policy);
    Employee emp = new Employee();
    emp = (Employee) getSession().executeQuery(query);
    if (!(emp.getFirstName().charAt(0) == 'J')
        && (emp.getFirstName().charAt(3) == 'l')
        && (emp.getLastName().charAt(0) == 'M')) {
      throw (new TestErrorException("Error in using specail operators."));
    }
    if (!(emp.getSalary() < 60000)) {
      throw (new TestErrorException("Error is using spcial operators."));
    }
  }
  public void setup() {
    if ((getSession().getLogin().getPlatform().isSQLServer())) {
      throw new TestWarningException(
          "This test is not supported on SQL Server. Because 'LENGTH' is not a recognized function name on SQL Server.");
    }

    Employee emp = (Employee) getSomeEmployees().firstElement();

    String ejbqlString;
    ejbqlString = "SELECT OBJECT(emp) FROM Employee emp WHERE ";
    ejbqlString = ejbqlString + emp.getFirstName().length();
    ejbqlString = ejbqlString + " = LENGTH(emp.firstName)";

    setEjbqlString(ejbqlString);
    setOriginalOject(emp);
    super.setup();
  }
 public void test() {
   UnitOfWork uow = getSession().acquireUnitOfWork();
   employee = (Employee) uow.readObject(Employee.class);
   originalReadTime =
       ((AbstractSession) getSession())
           .getIdentityMapAccessorInstance()
           .getCacheKeyForObject(employee)
           .getReadTime();
   employee.setFirstName(employee.getFirstName() + "-mutated");
   try {
     Thread.sleep(100);
   } catch (InterruptedException exc) {
   }
   uow.commit();
   secondReadTime =
       getAbstractSession()
           .getIdentityMapAccessorInstance()
           .getCacheKeyForObject(employee)
           .getReadTime();
 }
    long getVersion(Employee emp) {
      Vector pk = new Vector(1);
      pk.add(emp.getId());

      return ((Long)
              getSession()
                  .getDescriptor(Employee.class)
                  .getOptimisticLockingPolicy()
                  .getWriteLockValue(emp, pk, getAbstractSession()))
          .longValue();
    }
  private void createEmployeeAndSearchExpression() {
    // Create the example employee
    employee =
        (org.eclipse.persistence.testing.models.employee.domain.Employee)
            new org.eclipse.persistence.testing.models.employee.domain.EmployeePopulator()
                .basicEmployeeExample1();
    employee.setFirstName("Timugen");
    employee.setLastName("Singaera");
    employee.addResponsibility("Answer the phones.");

    // Create an expression to retreive the employee from the database
    ExpressionBuilder expressionBuilder = new ExpressionBuilder();
    Expression exp1;
    Expression exp2;
    Expression expression;

    exp1 = expressionBuilder.get("firstName").equal(employee.getFirstName());
    exp2 = expressionBuilder.get("lastName").equal(employee.getLastName());

    searchExpression = exp1.or(exp2);
  }
 protected void changeObject() {
   UnitOfWork uow = (UnitOfWork) getSession();
   Employee cloneEmployee = (Employee) workingCopy;
   for (int i = 0; i < managedEmployeesToAdd.size(); i++) {
     Employee cloneEmployeeToAdd = (Employee) uow.registerObject(managedEmployeesToAdd.get(i));
     cloneEmployee.addManagedEmployee(cloneEmployeeToAdd);
   }
   for (int i = 0; i < managedEmployeesToRemove.size(); i++) {
     Employee cloneEmployeeToRemove =
         (Employee) uow.registerObject(managedEmployeesToRemove.get(i));
     cloneEmployee.removeManagedEmployee(cloneEmployeeToRemove);
   }
   for (int i = 0; i < phonesToRemove.size(); i++) {
     PhoneNumber clonePhoneToRemove = (PhoneNumber) uow.registerObject(phonesToRemove.get(i));
     cloneEmployee.removePhoneNumber(clonePhoneToRemove);
   }
   for (int i = 0; i < phonesToAdd.size(); i++) {
     PhoneNumber clonePhoneToAdd = (PhoneNumber) uow.registerObject(phonesToAdd.get(i));
     cloneEmployee.addPhoneNumber(clonePhoneToAdd);
   }
 }
  public static TestSuite getComplexUpdateObjectTestSuite() {
    TestSuite suite = new TestSuite();
    suite.setName("EmployeeComplexUpdateTestSuite");
    suite.setDescription(
        "This suite tests the updating of each an employee by adding and/or removing managed employees and/or phones.");

    Class employeeClass = Employee.class;
    PopulationManager manager = PopulationManager.getDefaultManager();
    Employee originalEmployee = (Employee) manager.getObject(employeeClass, "0001");
    Employee otherEmployee = (Employee) manager.getObject(employeeClass, "0002");

    // add a managed Employee from other Employee managed List; remove the first managed Employee.
    suite.addTest(
        new EmployeeComplexUpdateTest(
            originalEmployee,
            otherEmployee.getManagedEmployees().get(0),
            originalEmployee.getManagedEmployees().get(0)));
    // remove the first Phone.
    suite.addTest(
        new EmployeeComplexUpdateTest(
            originalEmployee, (Object) null, originalEmployee.getPhoneNumbers().get(0)));
    // add a managed Employee from other Employee managed List and new phone;
    // remove the first two managed Employees and the first Phone.
    Employee newEmployee = new Employee();
    newEmployee.setFirstName("New");
    PhoneNumber newPhoneNumber = new PhoneNumber("home", "001", "0000001");
    suite.addTest(
        new EmployeeComplexUpdateTest(
            originalEmployee,
            new Object[] {otherEmployee.getManagedEmployees().get(0), newEmployee, newPhoneNumber},
            new Object[] {
              originalEmployee.getManagedEmployees().get(0),
              originalEmployee.getManagedEmployees().get(1),
              originalEmployee.getPhoneNumbers().get(0)
            }));
    suite.addTest(new CascadeLockingTest());
    suite.addTest(new TargetLockingTest_AddRemoveTarget());

    return suite;
  }
  protected void setup() {
    // save current null values for later restoration
    saveDefaultDefaultNullValues = ConversionManager.getDefaultManager().getDefaultNullValues();
    saveDefaultNullValues =
        getSession().getLogin().getPlatform().getConversionManager().getDefaultNullValues();
    getSession()
        .getLogin()
        .getPlatform()
        .getConversionManager()
        .setDefaultNullValues(new Hashtable());
    getSession().getLogin().setDefaultNullValue(String.class, "null");
    getSession().getLogin().setDefaultNullValue(int.class, new Integer(-1));
    // Reinit mappings.
    for (DatabaseMapping mapping : getSession().getDescriptor(Address.class).getMappings()) {
      if (mapping.isDirectToFieldMapping()) {
        mapping.preInitialize(getAbstractSession());
      }
    }
    getAbstractSession().beginTransaction();

    employee = new Employee();
    employee.setFirstName("Fred");
    employee.setLastName("Flintstone");
    employee.setSalary(22);
    employee.setGender("Male");
    Address address = new Address();
    address.setCity(null);
    employee.setAddress(address);

    getAbstractSession().writeObject(employee);
    // force the salary to be NULL
    getSession()
        .executeNonSelectingCall(
            new SQLCall("update SALARY set SALARY = null where EMP_ID = " + employee.getId()));
  }
  public static TestSuite getReadObjectTestSuite() {
    TestSuite suite = new TestSuite();
    suite.setName("EmployeeReadObjectTestSuite");
    suite.setDescription("This suite test the reading of each object in the employee demo.");

    Class employeeClass = Employee.class;
    PopulationManager manager = PopulationManager.getDefaultManager();

    suite.addTest(new ReadObjectTest(manager.getObject(employeeClass, "0001")));
    suite.addTest(new ReadObjectTest(manager.getObject(employeeClass, "0002")));
    suite.addTest(new ReadObjectTest(manager.getObject(employeeClass, "0003")));
    suite.addTest(new ReadObjectTest(manager.getObject(employeeClass, "0004")));
    suite.addTest(new ReadObjectTest(manager.getObject(employeeClass, "0005")));

    Employee employee = (Employee) manager.getObject(employeeClass, "0001");
    suite.addTest(
        new ReadObjectCallTest(
            employeeClass,
            new SQLCall(
                "SELECT VERSION, EMP_ID, L_NAME, F_NAME FROM UNIDIR_EMPLOYEE WHERE F_NAME = '"
                    + employee.getFirstName()
                    + "' AND L_NAME = '"
                    + employee.getLastName()
                    + "'")));
    employee = (Employee) manager.getObject(employeeClass, "0002");
    suite.addTest(
        new ReadObjectCallTest(
            employeeClass,
            new SQLCall(
                "SELECT VERSION, EMP_ID, L_NAME, F_NAME FROM UNIDIR_EMPLOYEE WHERE F_NAME = '"
                    + employee.getFirstName()
                    + "' AND L_NAME = '"
                    + employee.getLastName()
                    + "'")));
    employee = (Employee) manager.getObject(employeeClass, "0003");
    suite.addTest(
        new ReadObjectCallTest(
            employeeClass,
            new SQLCall(
                "SELECT VERSION, EMP_ID, L_NAME, F_NAME FROM UNIDIR_EMPLOYEE WHERE F_NAME = '"
                    + employee.getFirstName()
                    + "' AND L_NAME = '"
                    + employee.getLastName()
                    + "'")));

    return suite;
  }
 public EmployeeComplexUpdateTest(
     Employee originalEmployee, Object[] objectsToAdd, Object[] objectsToRemove) {
   super(originalEmployee);
   this.usesUnitOfWork = true;
   if (objectsToAdd != null) {
     for (int i = 0; i < objectsToAdd.length; i++) {
       Object objectToAdd = objectsToAdd[i];
       if (objectToAdd instanceof Employee) {
         if (!originalEmployee.getManagedEmployees().contains(objectToAdd)) {
           managedEmployeesToAdd.add((Employee) objectToAdd);
         } else {
           throw new TestWarningException(
               "OriginalEmployee: "
                   + originalEmployee
                   + " already manages employee to be added: "
                   + objectToAdd);
         }
       } else {
         // must be Phone
         if (!originalEmployee.getPhoneNumbers().contains(objectToAdd)) {
           phonesToAdd.add((PhoneNumber) objectToAdd);
         } else {
           throw new TestWarningException(
               "OriginalEmployee: "
                   + originalEmployee
                   + " already has the phonee to be added: "
                   + objectToAdd);
         }
       }
     }
   }
   if (objectsToRemove != null) {
     for (int i = 0; i < objectsToRemove.length; i++) {
       Object objectToRemove = objectsToRemove[i];
       if (objectToRemove instanceof Employee) {
         if (originalEmployee.getManagedEmployees().contains(objectToRemove)) {
           managedEmployeesToRemove.add((Employee) objectToRemove);
         } else {
           throw new TestWarningException(
               "OriginalEmployee: "
                   + originalEmployee
                   + " doesn't manage employee to be removed: "
                   + objectToRemove);
         }
       } else {
         // must be Phone
         if (originalEmployee.getPhoneNumbers().contains(objectToRemove)) {
           phonesToRemove.add((PhoneNumber) objectToRemove);
         } else {
           throw new TestWarningException(
               "OriginalEmployee: "
                   + originalEmployee
                   + " doesn't have the phonee to be removed: "
                   + objectToRemove);
         }
       }
     }
   }
   // generate a meaningful test name
   String employeeString = "";
   if (managedEmployeesToAdd.size() > 0 || managedEmployeesToRemove.size() > 0) {
     String addString = "";
     if (managedEmployeesToAdd.size() > 0) {
       addString = "add " + managedEmployeesToAdd.size();
     }
     String removeString = "";
     if (managedEmployeesToRemove.size() > 0) {
       removeString = "remove " + managedEmployeesToRemove.size();
     }
     employeeString =
         addString
             + (addString.length() > 0 && removeString.length() > 0 ? " and " : " ")
             + removeString
             + " Employees";
   }
   String phoneString = "";
   if (phonesToAdd.size() > 0 || phonesToRemove.size() > 0) {
     String addString = "";
     if (phonesToAdd.size() > 0) {
       addString = "add " + phonesToAdd.size();
     }
     String removeString = "";
     if (phonesToRemove.size() > 0) {
       removeString = "remove " + phonesToRemove.size();
     }
     phoneString =
         addString
             + (addString.length() > 0 && removeString.length() > 0 ? " and " : "")
             + removeString
             + " Phones";
   }
   setName(
       "EmployeeComplexUpdateTest: "
           + employeeString
           + (employeeString.length() > 0 && phoneString.length() > 0 ? "; " : "")
           + phoneString
           + ";");
   setDescription(
       "The test updates original Employee object: "
           + originalObject.toString()
           + " from the database by adding and/or removing managedEmployees and/or PhoneNumbers and verifies that the object updated correctly.");
 }
    public void test() {
      // setup
      Employee manager = new Employee();
      manager.setFirstName("Manager");
      Employee employee = new Employee();
      employee.setFirstName("Employee");

      UnitOfWork uow = getSession().acquireUnitOfWork();
      uow.registerObject(manager);
      uow.registerObject(employee);
      uow.commit();

      Vector pk = new Vector(1);
      pk.add(manager.getId());

      version[0] =
          ((Long)
                  getSession()
                      .getDescriptor(Employee.class)
                      .getOptimisticLockingPolicy()
                      .getWriteLockValue(manager, pk, getAbstractSession()))
              .longValue();

      // test1 - add managed employee, manager's version should increment.
      uow = getSession().acquireUnitOfWork();
      Employee managerClone = (Employee) uow.registerObject(manager);
      Employee employeeClone = (Employee) uow.registerObject(employee);
      managerClone.addManagedEmployee(employeeClone);
      uow.commit();
      version[1] =
          ((Long)
                  getSession()
                      .getDescriptor(Employee.class)
                      .getOptimisticLockingPolicy()
                      .getWriteLockValue(manager, pk, getAbstractSession()))
              .longValue();

      // test2 - alter managed employee, manager's version should NOT increment.
      uow = getSession().acquireUnitOfWork();
      employeeClone = (Employee) uow.registerObject(employee);
      employeeClone.setFirstName("Altered");
      uow.commit();
      version[2] =
          ((Long)
                  getSession()
                      .getDescriptor(Employee.class)
                      .getOptimisticLockingPolicy()
                      .getWriteLockValue(manager, pk, getAbstractSession()))
              .longValue();

      // test3- remove managed employee, manager's version should increment.
      uow = getSession().acquireUnitOfWork();
      managerClone = (Employee) uow.registerObject(manager);
      employeeClone = (Employee) uow.registerObject(employee);
      managerClone.removeManagedEmployee(employeeClone);
      uow.commit();
      version[3] =
          ((Long)
                  getSession()
                      .getDescriptor(Employee.class)
                      .getOptimisticLockingPolicy()
                      .getWriteLockValue(manager, pk, getAbstractSession()))
              .longValue();

      PhoneNumber phone = new PhoneNumber("home", "613", "1111111");

      // test4 - add phone, manager's version should increment.
      uow = getSession().acquireUnitOfWork();
      managerClone = (Employee) uow.registerObject(manager);
      PhoneNumber phoneClone = (PhoneNumber) uow.registerObject(phone);
      managerClone.addPhoneNumber(phoneClone);
      uow.commit();
      version[4] =
          ((Long)
                  getSession()
                      .getDescriptor(Employee.class)
                      .getOptimisticLockingPolicy()
                      .getWriteLockValue(manager, pk, getAbstractSession()))
              .longValue();

      // test5- alter phone, manager's version should increment.
      uow = getSession().acquireUnitOfWork();
      phoneClone = (PhoneNumber) uow.registerObject(phone);
      phoneClone.setType("work");
      uow.commit();
      version[5] =
          ((Long)
                  getSession()
                      .getDescriptor(Employee.class)
                      .getOptimisticLockingPolicy()
                      .getWriteLockValue(manager, pk, getAbstractSession()))
              .longValue();

      // test6- remove phone, manager's version should increment.
      uow = getSession().acquireUnitOfWork();
      managerClone = (Employee) uow.registerObject(manager);
      phoneClone = (PhoneNumber) uow.registerObject(phone);
      managerClone.removePhoneNumber(phoneClone);
      uow.commit();
      version[6] =
          ((Long)
                  getSession()
                      .getDescriptor(Employee.class)
                      .getOptimisticLockingPolicy()
                      .getWriteLockValue(manager, pk, getAbstractSession()))
              .longValue();
    }
    public void test() {
      // clear cache
      getSession().getIdentityMapAccessor().initializeAllIdentityMaps();
      // create batch read query, set its selectionCriteria
      ReadAllQuery query = new ReadAllQuery(Employee.class);
      setSelectionCriteria(query);
      // before adding batch read attributes clone the query to create control query
      ReadAllQuery controlQuery = (ReadAllQuery) query.clone();
      // add batch read attributes
      Expression managedEmployees = query.getExpressionBuilder().get("managedEmployees");
      Expression managedEmployeesPhoneNumbers = managedEmployees.get("phoneNumbers");
      query.addBatchReadAttribute(managedEmployeesPhoneNumbers);
      // execute the query
      List employees = (List) getSession().executeQuery(query);
      if (employees.isEmpty()) {
        throw new TestProblemException("No Employees were read");
      }
      // need to instantiate only a single Phone on a single managed Employee to trigger sql that
      // reads data from the db for all.
      // still need to trigger all the indirections - but (except the first one) they are not
      // accessing the db
      // (the data is already cached in the value holders).
      printDebug("Trigger batch reading results");
      boolean isConnected = true;
      for (int i = 0; i < employees.size(); i++) {
        Employee manager = (Employee) employees.get(i);
        if (!manager.getManagedEmployees().isEmpty()) {
          printDebug("Manager = " + manager);
          for (int j = 0; j < manager.getManagedEmployees().size(); j++) {
            Employee emp = (Employee) manager.getManagedEmployees().get(j);
            printDebug("     " + emp);
            for (int k = 0; k < emp.getPhoneNumbers().size(); k++) {
              if (isConnected) {
                // need to instantiate only a single Phone on a single managed Employee to trigger
                // sql that reads data from the db for all.
                // to ensure that no other sql is issued close connection.
                ((AbstractSession) getSession()).getAccessor().closeConnection();
                isConnected = false;
              }
              PhoneNumber phone = (PhoneNumber) emp.getPhoneNumbers().get(k);
              printDebug("          " + phone);
            }
          }
        } else {
          printDebug(manager.toString());
        }
      }
      if (!isConnected) {
        // reconnect connection
        ((AbstractSession) getSession())
            .getAccessor()
            .reestablishConnection((AbstractSession) getSession());
      }
      printDebug("");

      // obtain control results
      // clear cache
      getSession().getIdentityMapAccessor().initializeAllIdentityMaps();
      // execute control query
      List controlEmployees = (List) getSession().executeQuery(controlQuery);
      // instantiate all value holders that the batch query expected to instantiate
      printDebug("Trigger control results");
      for (int i = 0; i < controlEmployees.size(); i++) {
        Employee manager = (Employee) controlEmployees.get(i);
        if (!manager.getManagedEmployees().isEmpty()) {
          printDebug("Manager = " + manager);
          for (int j = 0; j < manager.getManagedEmployees().size(); j++) {
            Employee emp = (Employee) manager.getManagedEmployees().get(j);
            printDebug("     " + emp);
            for (int k = 0; k < emp.getPhoneNumbers().size(); k++) {
              PhoneNumber phone = (PhoneNumber) emp.getPhoneNumbers().get(k);
              printDebug("          " + phone);
            }
          }
        } else {
          printDebug(manager.toString());
        }
      }

      // compare results
      String errorMsg =
          JoinedAttributeTestHelper.compareCollections(
              employees,
              controlEmployees,
              getSession().getClassDescriptor(Employee.class),
              ((AbstractSession) getSession()));
      if (errorMsg.length() > 0) {
        throw new TestErrorException(errorMsg);
      }
    }