Attachment 115148 Details for Bug 242289 – patch for the bug (phase 4)

[patch] patch for the bug (phase 4)

bug242289_4.patch (text/plain), 300.45 KB, created by Kevin Yuan

on 2008-10-15 11:12:53 EDT

(hide)

Description:

Filename:

MIME Type:

Creator: Kevin Yuan

Created: 2008-10-15 11:12:53 EDT

Size: 300.45 KB

patch

obsolete

>Index: jpa/eclipselink.jpa.test/resource/eclipselink-advanced-properties/server/persistence.xml
>===================================================================
>--- jpa/eclipselink.jpa.test/resource/eclipselink-advanced-properties/server/persistence.xml	(revision 0)
>+++ jpa/eclipselink.jpa.test/resource/eclipselink-advanced-properties/server/persistence.xml	(revision 0)
>@@ -0,0 +1,25 @@
>+<persistence xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence persistence_1_0.xsd" version="1.0">
>+    <persistence-unit name="%%default%%">
>+        <provider>org.eclipse.persistence.jpa.PersistenceProvider</provider>
>+        <jta-data-source>%%data-source-name%%</jta-data-source>
>+        <mapping-file>META-INF/RelationshipProject.xml</mapping-file>
>+        <exclude-unlisted-classes>false</exclude-unlisted-classes>
>+        <properties>
>+             <property name="eclipselink.target-server" value="%%server-platform%%"/>
>+             <property name="eclipselink.sessions-xml" value="META-INF/sessions.xml"/>
>+             <property name="eclipselink.session-name" value="JPASessionXML"/>
>+             <property name="eclipselink.exception-handler" value="org.eclipse.persistence.testing.tests.jpa.jpaadvancedproperties.CustomizedExceptionHandler"/>
>+             <property name="eclipselink.session-event-listener" value="org.eclipse.persistence.testing.tests.jpa.jpaadvancedproperties.CustomizedSessionEventListener"/>
>+
>+             <property name="eclipselink.jdbc.batch-writing" value="BUFFERED"/>
>+             <property name="eclipselink.jdbc.native-sql" value="true"/>
>+             <property name="eclipselink.jdbc.cache-statements.size" value="100"/>
>+             <property name="eclipselink.jdbc.cache-statements" value="true"/>
>+             <property name="eclipselink.logging.logger" value="JavaLogger"/>
>+             <property name="eclipselink.logging.file" value="JPAAdvancedProperties.log"/>
>+             <property name="eclipselink.session.include.descriptor.queries" value="true"/>
>+             <property name="eclipselink.profiler" value="NoProfiler"/>
>+
>+        </properties>
>+    </persistence-unit>
>+</persistence>
>Index: jpa/eclipselink.jpa.test/resource/eclipselink-advanced-properties/server/sessions.xml
>===================================================================
>--- jpa/eclipselink.jpa.test/resource/eclipselink-advanced-properties/server/sessions.xml	(revision 0)
>+++ jpa/eclipselink.jpa.test/resource/eclipselink-advanced-properties/server/sessions.xml	(revision 0)
>@@ -0,0 +1,8 @@
>+<?xml version="1.0" encoding="US-ASCII"?>
>+<sessions xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="file://xsd/eclipse_persistence_sessions_1_0.xsd" version="1.0">
>+   <session xsi:type="server-session">
>+      <name>JPASessionXML</name>
>+      <logging xsi:type="java-log"/>
>+      <primary-project xsi:type="xml">META-INF/RelationshipProject.xml</primary-project>
>+   </session>
>+</sessions>
>Index: jpa/eclipselink.jpa.test/resource/eclipselink-advanced-properties/server/RelationshipProject.xml
>===================================================================
>--- jpa/eclipselink.jpa.test/resource/eclipselink-advanced-properties/server/RelationshipProject.xml	(revision 0)
>+++ jpa/eclipselink.jpa.test/resource/eclipselink-advanced-properties/server/RelationshipProject.xml	(revision 0)
>@@ -0,0 +1,574 @@
>+<?xml version="1.0" encoding="UTF-8"?>
>+<object-persistence version="Eclipse Persistence Services - 0.1-incubation" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns="http://www.eclipse.org/eclipselink/xsds/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
>+   <name></name>
>+   <class-mapping-descriptors>
>+      <class-mapping-descriptor xsi:type="relational-class-mapping-descriptor">
>+         <class>org.eclipse.persistence.testing.models.jpa.jpaadvancedproperties.Customer</class>
>+         <alias>Customer</alias>
>+         <primary-key>
>+            <field table="JPA_PROPS_CUSTOMER" name="CUST_ID" xsi:type="column"/>
>+         </primary-key>
>+         <events xsi:type="event-policy"/>
>+         <querying xsi:type="query-policy">
>+             <queries>
>+               <query name="customerReadByName" xsi:type="read-object-query">
>+                  <criteria operator="equal" xsi:type="relation-expression">
>+                     <left name="name" xsi:type="query-key-expression">
>+                        <base xsi:type="base-expression"/>
>+                     </left>
>+                     <right xsi:type="constant-expression">
>+                        <value xsi:type="xsd:string">George W.</value>
>+                     </right>
>+                  </criteria>
>+                  <arguments>
>+                     <argument name="name">
>+                        <type>java.lang.Object</type>
>+                     </argument>
>+                  </arguments>
>+                  <reference-class>org.eclipse.persistence.testing.models.jpa.jpaadvancedproperties.Customer</reference-class>
>+               </query>
>+            </queries>
>+            <timeout>0</timeout>
>+            <insert-query xsi:type="insert-object-query"/>
>+            <delete-query xsi:type="delete-object-query"/>
>+            <does-exist-query xsi:type="does-exist-query">
>+               <existence-check>check-database</existence-check>
>+            </does-exist-query>
>+            <read-object-query xsi:type="read-object-query">
>+               <criteria operator="equal" xsi:type="relation-expression">
>+                  <left xsi:type="field-expression">
>+                     <field table="JPA_PROPS_CUSTOMER" name="CUST_ID" xsi:type="column"/>
>+                     <base xsi:type="base-expression"/>
>+                  </left>
>+                  <right xsi:type="parameter-expression">
>+                     <parameter table="JPA_PROPS_CUSTOMER" name="CUST_ID" xsi:type="column"/>
>+                  </right>
>+               </criteria>
>+               <reference-class>org.eclipse.persistence.testing.models.jpa.jpaadvancedproperties.Customer</reference-class>
>+            </read-object-query>
>+         </querying>
>+         <attribute-mappings>
>+            <attribute-mapping xsi:type="direct-mapping">
>+               <attribute-name>customerId</attribute-name>
>+               <get-method>getCustomerId</get-method>
>+               <set-method>setCustomerId</set-method>
>+               <field table="JPA_PROPS_CUSTOMER" name="CUST_ID" xsi:type="column"/>
>+            </attribute-mapping>
>+            <attribute-mapping xsi:type="direct-mapping">
>+               <attribute-name>name</attribute-name>
>+               <get-method>getName</get-method>
>+               <set-method>setName</set-method>
>+               <field table="JPA_PROPS_CUSTOMER" name="NAME" xsi:type="column"/>
>+            </attribute-mapping>
>+            <attribute-mapping xsi:type="direct-mapping">
>+               <attribute-name>version</attribute-name>
>+               <get-method>getVersion</get-method>
>+               <set-method>setVersion</set-method>
>+               <field table="JPA_PROPS_CUSTOMER" name="CUST_VERSION" xsi:type="column"/>
>+            </attribute-mapping>
>+            <attribute-mapping xsi:type="direct-mapping">
>+               <attribute-name>city</attribute-name>
>+               <get-method>getCity</get-method>
>+               <set-method>setCity</set-method>
>+               <field table="JPA_PROPS_CUSTOMER" name="CITY" xsi:type="column"/>
>+            </attribute-mapping>
>+            <attribute-mapping xsi:type="one-to-many-mapping">
>+               <attribute-name>orders</attribute-name>
>+               <get-method>getOrders</get-method>
>+               <set-method>setOrders</set-method>
>+               <reference-class>org.eclipse.persistence.testing.models.jpa.jpaadvancedproperties.Order</reference-class>
>+               <cascade-persist>true</cascade-persist>
>+               <cascade-merge>true</cascade-merge>
>+               <cascade-refresh>true</cascade-refresh>
>+               <cascade-remove>true</cascade-remove>
>+               <target-foreign-key>
>+                  <field-reference>
>+                     <source-field table="JPA_PROPS_ORDER" name="CUSTOMER_CUST_ID" xsi:type="column"/>
>+                     <target-field table="JPA_PROPS_CUSTOMER" name="CUST_ID" xsi:type="column"/>
>+                  </field-reference>
>+               </target-foreign-key>
>+               <container xsi:type="container-policy">
>+                  <collection-type>org.eclipse.persistence.indirection.IndirectList</collection-type>
>+               </container>
>+               <indirection xsi:type="transparent-collection-indirection-policy"/>
>+               <selection-query xsi:type="read-all-query">
>+                  <criteria operator="equal" xsi:type="relation-expression">
>+                     <left xsi:type="field-expression">
>+                        <field table="JPA_PROPS_ORDER" name="CUSTOMER_CUST_ID" xsi:type="column"/>
>+                        <base xsi:type="base-expression"/>
>+                     </left>
>+                     <right xsi:type="parameter-expression">
>+                        <parameter table="JPA_PROPS_CUSTOMER" name="CUST_ID" xsi:type="column"/>
>+                     </right>
>+                  </criteria>
>+                  <reference-class>org.eclipse.persistence.testing.models.jpa.jpaadvancedproperties.Order</reference-class>
>+                  <container xsi:type="container-policy">
>+                     <collection-type>org.eclipse.persistence.indirection.IndirectList</collection-type>
>+                  </container>
>+               </selection-query>
>+            </attribute-mapping>
>+            <attribute-mapping xsi:type="many-to-many-mapping">
>+               <attribute-name>cCustomers</attribute-name>
>+               <get-method>getCCustomers</get-method>
>+               <set-method>setCCustomers</set-method>
>+               <reference-class>org.eclipse.persistence.testing.models.jpa.jpaadvancedproperties.Customer</reference-class>
>+               <relation-table>JPA_PROPS_C_C</relation-table>
>+               <source-relation-foreign-key>
>+                  <field-reference>
>+                     <source-field table="JPA_PROPS_C_C" name="C_C_ID" xsi:type="column"/>
>+                     <target-field table="JPA_PROPS_CUSTOMER" name="CUST_ID" xsi:type="column"/>
>+                  </field-reference>
>+               </source-relation-foreign-key>
>+               <target-relation-foreign-key>
>+                  <field-reference>
>+                     <source-field table="JPA_PROPS_C_C" name="CC_C_ID" xsi:type="column"/>
>+                     <target-field table="JPA_PROPS_CUSTOMER" name="CUST_ID" xsi:type="column"/>
>+                  </field-reference>
>+               </target-relation-foreign-key>
>+               <container xsi:type="container-policy">
>+                  <collection-type>org.eclipse.persistence.indirection.IndirectList</collection-type>
>+               </container>
>+               <indirection xsi:type="transparent-collection-indirection-policy"/>
>+               <selection-query xsi:type="read-all-query">
>+                  <criteria operator="and" xsi:type="logic-expression">
>+                     <left operator="equal" xsi:type="relation-expression">
>+                        <left xsi:type="field-expression">
>+                           <field table="JPA_PROPS_C_C" name="C_C_ID" xsi:type="column"/>
>+                           <base xsi:type="base-expression"/>
>+                        </left>
>+                        <right xsi:type="parameter-expression">
>+                           <parameter table="JPA_PROPS_CUSTOMER" name="CUST_ID" xsi:type="column"/>
>+                        </right>
>+                     </left>
>+                     <right operator="equal" xsi:type="relation-expression">
>+                        <left xsi:type="field-expression">
>+                           <field table="JPA_PROPS_CUSTOMER" name="CUST_ID" xsi:type="column"/>
>+                           <base xsi:type="base-expression"/>
>+                        </left>
>+                        <right xsi:type="field-expression">
>+                           <field table="JPA_PROPS_C_C" name="CC_C_ID" xsi:type="column"/>
>+                           <base xsi:type="base-expression"/>
>+                        </right>
>+                     </right>
>+                  </criteria>
>+                  <reference-class>org.eclipse.persistence.testing.models.jpa.jpaadvancedproperties.Customer</reference-class>
>+                  <container xsi:type="container-policy">
>+                     <collection-type>org.eclipse.persistence.indirection.IndirectList</collection-type>
>+                  </container>
>+               </selection-query>
>+               <insert-query xsi:type="data-modify-query"/>
>+               <delete-query xsi:type="data-modify-query">
>+                  <criteria operator="and" xsi:type="logic-expression">
>+                     <left operator="equal" xsi:type="relation-expression">
>+                        <left xsi:type="field-expression">
>+                           <field table="JPA_PROPS_C_C" name="CC_C_ID" xsi:type="column"/>
>+                           <base xsi:type="base-expression"/>
>+                        </left>
>+                        <right xsi:type="parameter-expression">
>+                           <parameter table="JPA_PROPS_C_C" name="CC_C_ID" xsi:type="column"/>
>+                        </right>
>+                     </left>
>+                     <right operator="equal" xsi:type="relation-expression">
>+                        <left xsi:type="field-expression">
>+                           <field table="JPA_PROPS_C_C" name="C_C_ID" xsi:type="column"/>
>+                           <base xsi:type="base-expression"/>
>+                        </left>
>+                        <right xsi:type="parameter-expression">
>+                           <parameter table="JPA_PROPS_C_C" name="C_C_ID" xsi:type="column"/>
>+                        </right>
>+                     </right>
>+                  </criteria>
>+               </delete-query>
>+               <delete-all-query xsi:type="data-modify-query">
>+                  <criteria operator="equal" xsi:type="relation-expression">
>+                     <left xsi:type="field-expression">
>+                        <field table="JPA_PROPS_C_C" name="C_C_ID" xsi:type="column"/>
>+                        <base xsi:type="base-expression"/>
>+                     </left>
>+                     <right xsi:type="parameter-expression">
>+                        <parameter table="JPA_PROPS_CUSTOMER" name="CUST_ID" xsi:type="column"/>
>+                     </right>
>+                  </criteria>
>+               </delete-all-query>
>+            </attribute-mapping>
>+         </attribute-mappings>
>+         <descriptor-type>independent</descriptor-type>
>+         <locking xsi:type="version-locking-policy">
>+            <version-field table="JPA_PROPS_CUSTOMER" name="CUST_VERSION" xsi:type="column"/>
>+            <store-version-in-cache>false</store-version-in-cache>
>+         </locking>
>+         <sequencing>
>+            <sequence-name>JPA_PROPS_CUSTOMER_SEQ</sequence-name>
>+            <sequence-field table="JPA_PROPS_CUSTOMER" name="CUST_ID" xsi:type="column"/>
>+         </sequencing>
>+         <caching>
>+            <cache-size>500</cache-size>
>+         </caching>
>+         <remote-caching>
>+            <cache-size>500</cache-size>
>+         </remote-caching>
>+         <instantiation/>
>+         <copying xsi:type="instantiation-copy-policy"/>
>+         <change-policy xsi:type="deferred-detection-change-policy"/>
>+         <tables>
>+            <table name="JPA_PROPS_CUSTOMER"/>
>+         </tables>
>+      </class-mapping-descriptor>
>+      <class-mapping-descriptor xsi:type="relational-class-mapping-descriptor">
>+         <class>org.eclipse.persistence.testing.models.jpa.jpaadvancedproperties.Order</class>
>+         <alias>OrderBean</alias>
>+         <primary-key>
>+            <field table="JPA_PROPS_ORDER" name="ORDER_ID" xsi:type="column"/>
>+         </primary-key>
>+         <events xsi:type="event-policy"/>
>+         <querying xsi:type="query-policy">
>+            <timeout>0</timeout>
>+            <insert-query xsi:type="insert-object-query"/>
>+            <delete-query xsi:type="delete-object-query"/>
>+            <does-exist-query xsi:type="does-exist-query">
>+               <existence-check>check-database</existence-check>
>+            </does-exist-query>
>+            <read-object-query xsi:type="read-object-query">
>+               <criteria operator="equal" xsi:type="relation-expression">
>+                  <left xsi:type="field-expression">
>+                     <field table="JPA_PROPS_ORDER" name="ORDER_ID" xsi:type="column"/>
>+                     <base xsi:type="base-expression"/>
>+                  </left>
>+                  <right xsi:type="parameter-expression">
>+                     <parameter table="JPA_PROPS_ORDER" name="ORDER_ID" xsi:type="column"/>
>+                  </right>
>+               </criteria>
>+               <reference-class>org.eclipse.persistence.testing.models.jpa.jpaadvancedproperties.Order</reference-class>
>+            </read-object-query>
>+         </querying>
>+         <attribute-mappings>
>+            <attribute-mapping xsi:type="direct-mapping">
>+               <attribute-name>orderId</attribute-name>
>+               <get-method>getOrderId</get-method>
>+               <set-method>setOrderId</set-method>
>+               <field table="JPA_PROPS_ORDER" name="ORDER_ID" xsi:type="column"/>
>+            </attribute-mapping>
>+            <attribute-mapping xsi:type="direct-mapping">
>+               <attribute-name>version</attribute-name>
>+               <get-method>getVersion</get-method>
>+               <set-method>setVersion</set-method>
>+               <field table="JPA_PROPS_ORDER" name="ORDER_VERSION" xsi:type="column"/>
>+            </attribute-mapping>
>+            <attribute-mapping xsi:type="direct-mapping">
>+               <attribute-name>shippingAddress</attribute-name>
>+               <get-method>getShippingAddress</get-method>
>+               <set-method>setShippingAddress</set-method>
>+               <field table="JPA_PROPS_ORDER" name="SHIP_ADDR" xsi:type="column"/>
>+            </attribute-mapping>
>+            <attribute-mapping xsi:type="direct-mapping">
>+               <attribute-name>quantity</attribute-name>
>+               <get-method>getQuantity</get-method>
>+               <set-method>setQuantity</set-method>
>+               <field table="JPA_PROPS_ORDER" name="QUANTITY" xsi:type="column"/>
>+            </attribute-mapping>
>+            <attribute-mapping xsi:type="one-to-one-mapping">
>+               <attribute-name>customer</attribute-name>
>+               <get-method>getCustomer</get-method>
>+               <set-method>setCustomer</set-method>
>+               <reference-class>org.eclipse.persistence.testing.models.jpa.jpaadvancedproperties.Customer</reference-class>
>+               <foreign-key>
>+                  <field-reference>
>+                     <source-field table="JPA_PROPS_ORDER" name="CUSTOMER_CUST_ID" xsi:type="column"/>
>+                     <target-field table="JPA_PROPS_CUSTOMER" name="CUST_ID" xsi:type="column"/>
>+                  </field-reference>
>+               </foreign-key>
>+               <foreign-key-fields>
>+                  <field table="JPA_PROPS_ORDER" name="CUSTOMER_CUST_ID" xsi:type="column"/>
>+               </foreign-key-fields>
>+               <selection-query xsi:type="read-object-query">
>+                  <criteria operator="equal" xsi:type="relation-expression">
>+                     <left xsi:type="field-expression">
>+                        <field table="JPA_PROPS_CUSTOMER" name="CUST_ID" xsi:type="column"/>
>+                        <base xsi:type="base-expression"/>
>+                     </left>
>+                     <right xsi:type="parameter-expression">
>+                        <parameter table="JPA_PROPS_ORDER" name="CUSTOMER_CUST_ID" xsi:type="column"/>
>+                     </right>
>+                  </criteria>
>+                  <reference-class>org.eclipse.persistence.testing.models.jpa.jpaadvancedproperties.Customer</reference-class>
>+               </selection-query>
>+            </attribute-mapping>
>+            <attribute-mapping xsi:type="one-to-one-mapping">
>+               <attribute-name>salesPerson</attribute-name>
>+               <get-method>getSalesPerson</get-method>
>+               <set-method>setSalesPerson</set-method>
>+               <reference-class>org.eclipse.persistence.testing.models.jpa.jpaadvancedproperties.SalesPerson</reference-class>
>+               <foreign-key>
>+                  <field-reference>
>+                     <source-field table="JPA_PROPS_ORDER" name="SALESPERSON_ID" xsi:type="column"/>
>+                     <target-field table="JPA_PROPS_SALESPERSON" name="ID" xsi:type="column"/>
>+                  </field-reference>
>+               </foreign-key>
>+               <foreign-key-fields>
>+                  <field table="JPA_PROPS_ORDER" name="SALESPERSON_ID" xsi:type="column"/>
>+               </foreign-key-fields>
>+               <selection-query xsi:type="read-object-query">
>+                  <criteria operator="equal" xsi:type="relation-expression">
>+                     <left xsi:type="field-expression">
>+                        <field table="JPA_PROPS_SALESPERSON" name="ID" xsi:type="column"/>
>+                        <base xsi:type="base-expression"/>
>+                     </left>
>+                     <right xsi:type="parameter-expression">
>+                        <parameter table="JPA_PROPS_ORDER" name="SALESPERSON_ID" xsi:type="column"/>
>+                     </right>
>+                  </criteria>
>+                  <reference-class>org.eclipse.persistence.testing.models.jpa.jpaadvancedproperties.SalesPerson</reference-class>
>+               </selection-query>
>+            </attribute-mapping>
>+            <attribute-mapping xsi:type="one-to-one-mapping">
>+               <attribute-name>billedCustomer</attribute-name>
>+               <get-method>getBilledCustomer</get-method>
>+               <set-method>setBilledCustomer</set-method>
>+               <reference-class>org.eclipse.persistence.testing.models.jpa.jpaadvancedproperties.Customer</reference-class>
>+               <foreign-key>
>+                  <field-reference>
>+                     <source-field table="JPA_PROPS_ORDER" name="BILLEDCUSTOMER_CUST_ID" xsi:type="column"/>
>+                     <target-field table="JPA_PROPS_CUSTOMER" name="CUST_ID" xsi:type="column"/>
>+                  </field-reference>
>+               </foreign-key>
>+               <foreign-key-fields>
>+                  <field table="JPA_PROPS_ORDER" name="BILLEDCUSTOMER_CUST_ID" xsi:type="column"/>
>+               </foreign-key-fields>
>+               <selection-query xsi:type="read-object-query">
>+                  <criteria operator="equal" xsi:type="relation-expression">
>+                     <left xsi:type="field-expression">
>+                        <field table="JPA_PROPS_CUSTOMER" name="CUST_ID" xsi:type="column"/>
>+                        <base xsi:type="base-expression"/>
>+                     </left>
>+                     <right xsi:type="parameter-expression">
>+                        <parameter table="JPA_PROPS_ORDER" name="BILLEDCUSTOMER_CUST_ID" xsi:type="column"/>
>+                     </right>
>+                  </criteria>
>+                  <reference-class>org.eclipse.persistence.testing.models.jpa.jpaadvancedproperties.Customer</reference-class>
>+               </selection-query>
>+            </attribute-mapping>
>+            <attribute-mapping xsi:type="one-to-one-mapping">
>+               <attribute-name>item</attribute-name>
>+               <get-method>getItem</get-method>
>+               <set-method>setItem</set-method>
>+               <reference-class>org.eclipse.persistence.testing.models.jpa.jpaadvancedproperties.Item</reference-class>
>+               <cascade-persist>true</cascade-persist>
>+               <cascade-merge>true</cascade-merge>
>+               <cascade-refresh>true</cascade-refresh>
>+               <cascade-remove>true</cascade-remove>
>+               <foreign-key>
>+                  <field-reference>
>+                     <source-field table="JPA_PROPS_ORDER" name="ITEM_ID" xsi:type="column"/>
>+                     <target-field table="JPA_PROPS_ITEM" name="ID" xsi:type="column"/>
>+                  </field-reference>
>+               </foreign-key>
>+               <foreign-key-fields>
>+                  <field table="JPA_PROPS_ORDER" name="ITEM_ID" xsi:type="column"/>
>+               </foreign-key-fields>
>+               <selection-query xsi:type="read-object-query">
>+                  <criteria operator="equal" xsi:type="relation-expression">
>+                     <left xsi:type="field-expression">
>+                        <field table="JPA_PROPS_ITEM" name="ID" xsi:type="column"/>
>+                        <base xsi:type="base-expression"/>
>+                     </left>
>+                     <right xsi:type="parameter-expression">
>+                        <parameter table="JPA_PROPS_ORDER" name="ITEM_ID" xsi:type="column"/>
>+                     </right>
>+                  </criteria>
>+                  <reference-class>org.eclipse.persistence.testing.models.jpa.jpaadvancedproperties.Item</reference-class>
>+               </selection-query>
>+            </attribute-mapping>
>+         </attribute-mappings>
>+         <descriptor-type>independent</descriptor-type>
>+         <locking xsi:type="version-locking-policy">
>+            <version-field table="JPA_PROPS_ORDER" name="ORDER_VERSION" xsi:type="column"/>
>+            <store-version-in-cache>false</store-version-in-cache>
>+         </locking>
>+         <sequencing>
>+            <sequence-name>JPA_PROPS_ORDER_SEQ</sequence-name>
>+            <sequence-field table="JPA_PROPS_ORDER" name="ORDER_ID" xsi:type="column"/>
>+         </sequencing>
>+         <caching>
>+            <cache-size>500</cache-size>
>+         </caching>
>+         <remote-caching>
>+            <cache-size>500</cache-size>
>+         </remote-caching>
>+         <instantiation/>
>+         <copying xsi:type="instantiation-copy-policy"/>
>+         <change-policy xsi:type="deferred-detection-change-policy"/>
>+         <tables>
>+            <table name="JPA_PROPS_ORDER"/>
>+         </tables>
>+      </class-mapping-descriptor>
>+      <class-mapping-descriptor xsi:type="relational-class-mapping-descriptor">
>+         <class>org.eclipse.persistence.testing.models.jpa.jpaadvancedproperties.Item</class>
>+         <alias>Item</alias>
>+         <primary-key>
>+            <field table="JPA_PROPS_ITEM" name="ID" xsi:type="column"/>
>+         </primary-key>
>+         <events xsi:type="event-policy"/>
>+         <querying xsi:type="query-policy">
>+            <timeout>0</timeout>
>+            <insert-query xsi:type="insert-object-query"/>
>+            <delete-query xsi:type="delete-object-query"/>
>+            <does-exist-query xsi:type="does-exist-query">
>+               <existence-check>check-database</existence-check>
>+            </does-exist-query>
>+            <read-object-query xsi:type="read-object-query">
>+               <criteria operator="equal" xsi:type="relation-expression">
>+                  <left xsi:type="field-expression">
>+                     <field table="JPA_PROPS_ITEM" name="ID" xsi:type="column"/>
>+                     <base xsi:type="base-expression"/>
>+                  </left>
>+                  <right xsi:type="parameter-expression">
>+                     <parameter table="JPA_PROPS_ITEM" name="ID" xsi:type="column"/>
>+                  </right>
>+               </criteria>
>+               <reference-class>org.eclipse.persistence.testing.models.jpa.jpaadvancedproperties.Item</reference-class>
>+            </read-object-query>
>+         </querying>
>+         <attribute-mappings>
>+            <attribute-mapping xsi:type="direct-mapping">
>+               <attribute-name>itemId</attribute-name>
>+               <get-method>getItemId</get-method>
>+               <set-method>setItemId</set-method>
>+               <field table="JPA_PROPS_ITEM" name="ID" xsi:type="column"/>
>+            </attribute-mapping>
>+            <attribute-mapping xsi:type="direct-mapping">
>+               <attribute-name>name</attribute-name>
>+               <get-method>getName</get-method>
>+               <set-method>setName</set-method>
>+               <field table="JPA_PROPS_ITEM" name="NAME" xsi:type="column"/>
>+            </attribute-mapping>
>+            <attribute-mapping xsi:type="direct-mapping">
>+               <attribute-name>version</attribute-name>
>+               <get-method>getVersion</get-method>
>+               <set-method>setVersion</set-method>
>+               <field table="JPA_PROPS_ITEM" name="ITEM_VERSION" xsi:type="column"/>
>+            </attribute-mapping>
>+            <attribute-mapping xsi:type="direct-mapping">
>+               <attribute-name>description</attribute-name>
>+               <get-method>getDescription</get-method>
>+               <set-method>setDescription</set-method>
>+               <field table="JPA_PROPS_ITEM" name="DESCRIPTION" xsi:type="column"/>
>+            </attribute-mapping>
>+         </attribute-mappings>
>+         <descriptor-type>independent</descriptor-type>
>+         <locking xsi:type="version-locking-policy">
>+            <version-field table="JPA_PROPS_ITEM" name="ITEM_VERSION" xsi:type="column"/>
>+            <store-version-in-cache>false</store-version-in-cache>
>+         </locking>
>+         <sequencing>
>+            <sequence-name>ITEM_SEQ</sequence-name>
>+            <sequence-field table="JPA_PROPS_ITEM" name="ID" xsi:type="column"/>
>+         </sequencing>
>+         <caching>
>+            <cache-size>500</cache-size>
>+         </caching>
>+         <remote-caching>
>+            <cache-size>500</cache-size>
>+         </remote-caching>
>+         <instantiation/>
>+         <copying xsi:type="instantiation-copy-policy"/>
>+         <change-policy xsi:type="deferred-detection-change-policy"/>
>+         <tables>
>+            <table name="JPA_PROPS_ITEM"/>
>+         </tables>
>+      </class-mapping-descriptor>
>+      <class-mapping-descriptor xsi:type="relational-class-mapping-descriptor">
>+         <class>org.eclipse.persistence.testing.models.jpa.jpaadvancedproperties.SalesPerson</class>
>+         <alias>SalesPerson</alias>
>+         <primary-key>
>+            <field table="JPA_PROPS_SALESPERSON" name="ID" xsi:type="column"/>
>+         </primary-key>
>+         <events xsi:type="event-policy"/>
>+         <querying xsi:type="query-policy">
>+            <timeout>0</timeout>
>+            <insert-query xsi:type="insert-object-query"/>
>+            <delete-query xsi:type="delete-object-query"/>
>+            <does-exist-query xsi:type="does-exist-query">
>+               <existence-check>check-database</existence-check>
>+            </does-exist-query>
>+            <read-object-query xsi:type="read-object-query">
>+               <criteria operator="equal" xsi:type="relation-expression">
>+                  <left xsi:type="field-expression">
>+                     <field table="JPA_PROPS_SALESPERSON" name="ID" xsi:type="column"/>
>+                     <base xsi:type="base-expression"/>
>+                  </left>
>+                  <right xsi:type="parameter-expression">
>+                     <parameter table="JPA_PROPS_SALESPERSON" name="ID" xsi:type="column"/>
>+                  </right>
>+               </criteria>
>+               <reference-class>org.eclipse.persistence.testing.models.jpa.jpaadvancedproperties.SalesPerson</reference-class>
>+            </read-object-query>
>+         </querying>
>+         <attribute-mappings>
>+            <attribute-mapping xsi:type="direct-mapping">
>+               <attribute-name>id</attribute-name>
>+               <get-method>getId</get-method>
>+               <set-method>setId</set-method>
>+               <field table="JPA_PROPS_SALESPERSON" name="ID" xsi:type="column"/>
>+            </attribute-mapping>
>+            <attribute-mapping xsi:type="direct-mapping">
>+               <attribute-name>name</attribute-name>
>+               <get-method>getName</get-method>
>+               <set-method>setName</set-method>
>+               <field table="JPA_PROPS_SALESPERSON" name="NAME" xsi:type="column"/>
>+            </attribute-mapping>
>+            <attribute-mapping xsi:type="one-to-many-mapping">
>+               <attribute-name>orders</attribute-name>
>+               <get-method>getOrders</get-method>
>+               <set-method>setOrders</set-method>
>+               <reference-class>org.eclipse.persistence.testing.models.jpa.jpaadvancedproperties.Order</reference-class>
>+               <cascade-persist>true</cascade-persist>
>+               <cascade-merge>true</cascade-merge>
>+               <cascade-refresh>true</cascade-refresh>
>+               <cascade-remove>true</cascade-remove>
>+               <target-foreign-key>
>+                  <field-reference>
>+                     <source-field table="JPA_PROPS_ORDER" name="SALESPERSON_ID" xsi:type="column"/>
>+                     <target-field table="JPA_PROPS_SALESPERSON" name="ID" xsi:type="column"/>
>+                  </field-reference>
>+               </target-foreign-key>
>+               <container xsi:type="container-policy">
>+                  <collection-type>org.eclipse.persistence.indirection.IndirectList</collection-type>
>+               </container>
>+               <indirection xsi:type="transparent-collection-indirection-policy"/>
>+               <selection-query xsi:type="read-all-query">
>+                  <criteria operator="equal" xsi:type="relation-expression">
>+                     <left xsi:type="field-expression">
>+                        <field table="JPA_PROPS_ORDER" name="SALESPERSON_ID" xsi:type="column"/>
>+                        <base xsi:type="base-expression"/>
>+                     </left>
>+                     <right xsi:type="parameter-expression">
>+                        <parameter table="JPA_PROPS_SALESPERSON" name="ID" xsi:type="column"/>
>+                     </right>
>+                  </criteria>
>+                  <reference-class>org.eclipse.persistence.testing.models.jpa.jpaadvancedproperties.Order</reference-class>
>+                  <container xsi:type="container-policy">
>+                     <collection-type>org.eclipse.persistence.indirection.IndirectList</collection-type>
>+                  </container>
>+               </selection-query>
>+            </attribute-mapping>
>+         </attribute-mappings>
>+         <descriptor-type>independent</descriptor-type>
>+         <sequencing>
>+            <sequence-name>SALESPERSON_SEQ</sequence-name>
>+            <sequence-field table="JPA_PROPS_SALESPERSON" name="ID" xsi:type="column"/>
>+         </sequencing>
>+         <caching>
>+            <cache-size>500</cache-size>
>+         </caching>
>+         <remote-caching>
>+            <cache-size>500</cache-size>
>+         </remote-caching>
>+         <instantiation/>
>+         <copying xsi:type="instantiation-copy-policy"/>
>+         <change-policy xsi:type="deferred-detection-change-policy"/>
>+         <tables>
>+            <table name="JPA_PROPS_SALESPERSON"/>
>+         </tables>
>+      </class-mapping-descriptor>
>+   </class-mapping-descriptors>
>+</object-persistence>
>Index: jpa/eclipselink.jpa.test/resource/eclipselink-advanced-properties/server/persistence.xml
>===================================================================
>--- jpa/eclipselink.jpa.test/resource/eclipselink-advanced-properties/server/persistence.xml	(revision 0)
>+++ jpa/eclipselink.jpa.test/resource/eclipselink-advanced-properties/server/persistence.xml	(revision 0)
>@@ -0,0 +1,25 @@
>+<persistence xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence persistence_1_0.xsd" version="1.0">
>+    <persistence-unit name="%%default%%">
>+        <provider>org.eclipse.persistence.jpa.PersistenceProvider</provider>
>+        <jta-data-source>%%data-source-name%%</jta-data-source>
>+        <mapping-file>META-INF/RelationshipProject.xml</mapping-file>
>+        <exclude-unlisted-classes>false</exclude-unlisted-classes>
>+        <properties>
>+             <property name="eclipselink.target-server" value="%%server-platform%%"/>
>+             <property name="eclipselink.sessions-xml" value="META-INF/sessions.xml"/>
>+             <property name="eclipselink.session-name" value="JPASessionXML"/>
>+             <property name="eclipselink.exception-handler" value="org.eclipse.persistence.testing.tests.jpa.jpaadvancedproperties.CustomizedExceptionHandler"/>
>+             <property name="eclipselink.session-event-listener" value="org.eclipse.persistence.testing.tests.jpa.jpaadvancedproperties.CustomizedSessionEventListener"/>
>+
>+             <property name="eclipselink.jdbc.batch-writing" value="BUFFERED"/>
>+             <property name="eclipselink.jdbc.native-sql" value="true"/>
>+             <property name="eclipselink.jdbc.cache-statements.size" value="100"/>
>+             <property name="eclipselink.jdbc.cache-statements" value="true"/>
>+             <property name="eclipselink.logging.logger" value="JavaLogger"/>
>+             <property name="eclipselink.logging.file" value="JPAAdvancedProperties.log"/>
>+             <property name="eclipselink.session.include.descriptor.queries" value="true"/>
>+             <property name="eclipselink.profiler" value="NoProfiler"/>
>+
>+        </properties>
>+    </persistence-unit>
>+</persistence>
>Index: jpa/eclipselink.jpa.test/resource/eclipselink-advanced-properties/server/RelationshipProject.xml
>===================================================================
>--- jpa/eclipselink.jpa.test/resource/eclipselink-advanced-properties/server/RelationshipProject.xml	(revision 0)
>+++ jpa/eclipselink.jpa.test/resource/eclipselink-advanced-properties/server/RelationshipProject.xml	(revision 0)
>@@ -0,0 +1,574 @@
>+<?xml version="1.0" encoding="UTF-8"?>
>+<object-persistence version="Eclipse Persistence Services - 0.1-incubation" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns="http://www.eclipse.org/eclipselink/xsds/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
>+   <name></name>
>+   <class-mapping-descriptors>
>+      <class-mapping-descriptor xsi:type="relational-class-mapping-descriptor">
>+         <class>org.eclipse.persistence.testing.models.jpa.jpaadvancedproperties.Customer</class>
>+         <alias>Customer</alias>
>+         <primary-key>
>+            <field table="JPA_PROPS_CUSTOMER" name="CUST_ID" xsi:type="column"/>
>+         </primary-key>
>+         <events xsi:type="event-policy"/>
>+         <querying xsi:type="query-policy">
>+             <queries>
>+               <query name="customerReadByName" xsi:type="read-object-query">
>+                  <criteria operator="equal" xsi:type="relation-expression">
>+                     <left name="name" xsi:type="query-key-expression">
>+                        <base xsi:type="base-expression"/>
>+                     </left>
>+                     <right xsi:type="constant-expression">
>+                        <value xsi:type="xsd:string">George W.</value>
>+                     </right>
>+                  </criteria>
>+                  <arguments>
>+                     <argument name="name">
>+                        <type>java.lang.Object</type>
>+                     </argument>
>+                  </arguments>
>+                  <reference-class>org.eclipse.persistence.testing.models.jpa.jpaadvancedproperties.Customer</reference-class>
>+               </query>
>+            </queries>
>+            <timeout>0</timeout>
>+            <insert-query xsi:type="insert-object-query"/>
>+            <delete-query xsi:type="delete-object-query"/>
>+            <does-exist-query xsi:type="does-exist-query">
>+               <existence-check>check-database</existence-check>
>+            </does-exist-query>
>+            <read-object-query xsi:type="read-object-query">
>+               <criteria operator="equal" xsi:type="relation-expression">
>+                  <left xsi:type="field-expression">
>+                     <field table="JPA_PROPS_CUSTOMER" name="CUST_ID" xsi:type="column"/>
>+                     <base xsi:type="base-expression"/>
>+                  </left>
>+                  <right xsi:type="parameter-expression">
>+                     <parameter table="JPA_PROPS_CUSTOMER" name="CUST_ID" xsi:type="column"/>
>+                  </right>
>+               </criteria>
>+               <reference-class>org.eclipse.persistence.testing.models.jpa.jpaadvancedproperties.Customer</reference-class>
>+            </read-object-query>
>+         </querying>
>+         <attribute-mappings>
>+            <attribute-mapping xsi:type="direct-mapping">
>+               <attribute-name>customerId</attribute-name>
>+               <get-method>getCustomerId</get-method>
>+               <set-method>setCustomerId</set-method>
>+               <field table="JPA_PROPS_CUSTOMER" name="CUST_ID" xsi:type="column"/>
>+            </attribute-mapping>
>+            <attribute-mapping xsi:type="direct-mapping">
>+               <attribute-name>name</attribute-name>
>+               <get-method>getName</get-method>
>+               <set-method>setName</set-method>
>+               <field table="JPA_PROPS_CUSTOMER" name="NAME" xsi:type="column"/>
>+            </attribute-mapping>
>+            <attribute-mapping xsi:type="direct-mapping">
>+               <attribute-name>version</attribute-name>
>+               <get-method>getVersion</get-method>
>+               <set-method>setVersion</set-method>
>+               <field table="JPA_PROPS_CUSTOMER" name="CUST_VERSION" xsi:type="column"/>
>+            </attribute-mapping>
>+            <attribute-mapping xsi:type="direct-mapping">
>+               <attribute-name>city</attribute-name>
>+               <get-method>getCity</get-method>
>+               <set-method>setCity</set-method>
>+               <field table="JPA_PROPS_CUSTOMER" name="CITY" xsi:type="column"/>
>+            </attribute-mapping>
>+            <attribute-mapping xsi:type="one-to-many-mapping">
>+               <attribute-name>orders</attribute-name>
>+               <get-method>getOrders</get-method>
>+               <set-method>setOrders</set-method>
>+               <reference-class>org.eclipse.persistence.testing.models.jpa.jpaadvancedproperties.Order</reference-class>
>+               <cascade-persist>true</cascade-persist>
>+               <cascade-merge>true</cascade-merge>
>+               <cascade-refresh>true</cascade-refresh>
>+               <cascade-remove>true</cascade-remove>
>+               <target-foreign-key>
>+                  <field-reference>
>+                     <source-field table="JPA_PROPS_ORDER" name="CUSTOMER_CUST_ID" xsi:type="column"/>
>+                     <target-field table="JPA_PROPS_CUSTOMER" name="CUST_ID" xsi:type="column"/>
>+                  </field-reference>
>+               </target-foreign-key>
>+               <container xsi:type="container-policy">
>+                  <collection-type>org.eclipse.persistence.indirection.IndirectList</collection-type>
>+               </container>
>+               <indirection xsi:type="transparent-collection-indirection-policy"/>
>+               <selection-query xsi:type="read-all-query">
>+                  <criteria operator="equal" xsi:type="relation-expression">
>+                     <left xsi:type="field-expression">
>+                        <field table="JPA_PROPS_ORDER" name="CUSTOMER_CUST_ID" xsi:type="column"/>
>+                        <base xsi:type="base-expression"/>
>+                     </left>
>+                     <right xsi:type="parameter-expression">
>+                        <parameter table="JPA_PROPS_CUSTOMER" name="CUST_ID" xsi:type="column"/>
>+                     </right>
>+                  </criteria>
>+                  <reference-class>org.eclipse.persistence.testing.models.jpa.jpaadvancedproperties.Order</reference-class>
>+                  <container xsi:type="container-policy">
>+                     <collection-type>org.eclipse.persistence.indirection.IndirectList</collection-type>
>+                  </container>
>+               </selection-query>
>+            </attribute-mapping>
>+            <attribute-mapping xsi:type="many-to-many-mapping">
>+               <attribute-name>cCustomers</attribute-name>
>+               <get-method>getCCustomers</get-method>
>+               <set-method>setCCustomers</set-method>
>+               <reference-class>org.eclipse.persistence.testing.models.jpa.jpaadvancedproperties.Customer</reference-class>
>+               <relation-table>JPA_PROPS_C_C</relation-table>
>+               <source-relation-foreign-key>
>+                  <field-reference>
>+                     <source-field table="JPA_PROPS_C_C" name="C_C_ID" xsi:type="column"/>
>+                     <target-field table="JPA_PROPS_CUSTOMER" name="CUST_ID" xsi:type="column"/>
>+                  </field-reference>
>+               </source-relation-foreign-key>
>+               <target-relation-foreign-key>
>+                  <field-reference>
>+                     <source-field table="JPA_PROPS_C_C" name="CC_C_ID" xsi:type="column"/>
>+                     <target-field table="JPA_PROPS_CUSTOMER" name="CUST_ID" xsi:type="column"/>
>+                  </field-reference>
>+               </target-relation-foreign-key>
>+               <container xsi:type="container-policy">
>+                  <collection-type>org.eclipse.persistence.indirection.IndirectList</collection-type>
>+               </container>
>+               <indirection xsi:type="transparent-collection-indirection-policy"/>
>+               <selection-query xsi:type="read-all-query">
>+                  <criteria operator="and" xsi:type="logic-expression">
>+                     <left operator="equal" xsi:type="relation-expression">
>+                        <left xsi:type="field-expression">
>+                           <field table="JPA_PROPS_C_C" name="C_C_ID" xsi:type="column"/>
>+                           <base xsi:type="base-expression"/>
>+                        </left>
>+                        <right xsi:type="parameter-expression">
>+                           <parameter table="JPA_PROPS_CUSTOMER" name="CUST_ID" xsi:type="column"/>
>+                        </right>
>+                     </left>
>+                     <right operator="equal" xsi:type="relation-expression">
>+                        <left xsi:type="field-expression">
>+                           <field table="JPA_PROPS_CUSTOMER" name="CUST_ID" xsi:type="column"/>
>+                           <base xsi:type="base-expression"/>
>+                        </left>
>+                        <right xsi:type="field-expression">
>+                           <field table="JPA_PROPS_C_C" name="CC_C_ID" xsi:type="column"/>
>+                           <base xsi:type="base-expression"/>
>+                        </right>
>+                     </right>
>+                  </criteria>
>+                  <reference-class>org.eclipse.persistence.testing.models.jpa.jpaadvancedproperties.Customer</reference-class>
>+                  <container xsi:type="container-policy">
>+                     <collection-type>org.eclipse.persistence.indirection.IndirectList</collection-type>
>+                  </container>
>+               </selection-query>
>+               <insert-query xsi:type="data-modify-query"/>
>+               <delete-query xsi:type="data-modify-query">
>+                  <criteria operator="and" xsi:type="logic-expression">
>+                     <left operator="equal" xsi:type="relation-expression">
>+                        <left xsi:type="field-expression">
>+                           <field table="JPA_PROPS_C_C" name="CC_C_ID" xsi:type="column"/>
>+                           <base xsi:type="base-expression"/>
>+                        </left>
>+                        <right xsi:type="parameter-expression">
>+                           <parameter table="JPA_PROPS_C_C" name="CC_C_ID" xsi:type="column"/>
>+                        </right>
>+                     </left>
>+                     <right operator="equal" xsi:type="relation-expression">
>+                        <left xsi:type="field-expression">
>+                           <field table="JPA_PROPS_C_C" name="C_C_ID" xsi:type="column"/>
>+                           <base xsi:type="base-expression"/>
>+                        </left>
>+                        <right xsi:type="parameter-expression">
>+                           <parameter table="JPA_PROPS_C_C" name="C_C_ID" xsi:type="column"/>
>+                        </right>
>+                     </right>
>+                  </criteria>
>+               </delete-query>
>+               <delete-all-query xsi:type="data-modify-query">
>+                  <criteria operator="equal" xsi:type="relation-expression">
>+                     <left xsi:type="field-expression">
>+                        <field table="JPA_PROPS_C_C" name="C_C_ID" xsi:type="column"/>
>+                        <base xsi:type="base-expression"/>
>+                     </left>
>+                     <right xsi:type="parameter-expression">
>+                        <parameter table="JPA_PROPS_CUSTOMER" name="CUST_ID" xsi:type="column"/>
>+                     </right>
>+                  </criteria>
>+               </delete-all-query>
>+            </attribute-mapping>
>+         </attribute-mappings>
>+         <descriptor-type>independent</descriptor-type>
>+         <locking xsi:type="version-locking-policy">
>+            <version-field table="JPA_PROPS_CUSTOMER" name="CUST_VERSION" xsi:type="column"/>
>+            <store-version-in-cache>false</store-version-in-cache>
>+         </locking>
>+         <sequencing>
>+            <sequence-name>JPA_PROPS_CUSTOMER_SEQ</sequence-name>
>+            <sequence-field table="JPA_PROPS_CUSTOMER" name="CUST_ID" xsi:type="column"/>
>+         </sequencing>
>+         <caching>
>+            <cache-size>500</cache-size>
>+         </caching>
>+         <remote-caching>
>+            <cache-size>500</cache-size>
>+         </remote-caching>
>+         <instantiation/>
>+         <copying xsi:type="instantiation-copy-policy"/>
>+         <change-policy xsi:type="deferred-detection-change-policy"/>
>+         <tables>
>+            <table name="JPA_PROPS_CUSTOMER"/>
>+         </tables>
>+      </class-mapping-descriptor>
>+      <class-mapping-descriptor xsi:type="relational-class-mapping-descriptor">
>+         <class>org.eclipse.persistence.testing.models.jpa.jpaadvancedproperties.Order</class>
>+         <alias>OrderBean</alias>
>+         <primary-key>
>+            <field table="JPA_PROPS_ORDER" name="ORDER_ID" xsi:type="column"/>
>+         </primary-key>
>+         <events xsi:type="event-policy"/>
>+         <querying xsi:type="query-policy">
>+            <timeout>0</timeout>
>+            <insert-query xsi:type="insert-object-query"/>
>+            <delete-query xsi:type="delete-object-query"/>
>+            <does-exist-query xsi:type="does-exist-query">
>+               <existence-check>check-database</existence-check>
>+            </does-exist-query>
>+            <read-object-query xsi:type="read-object-query">
>+               <criteria operator="equal" xsi:type="relation-expression">
>+                  <left xsi:type="field-expression">
>+                     <field table="JPA_PROPS_ORDER" name="ORDER_ID" xsi:type="column"/>
>+                     <base xsi:type="base-expression"/>
>+                  </left>
>+                  <right xsi:type="parameter-expression">
>+                     <parameter table="JPA_PROPS_ORDER" name="ORDER_ID" xsi:type="column"/>
>+                  </right>
>+               </criteria>
>+               <reference-class>org.eclipse.persistence.testing.models.jpa.jpaadvancedproperties.Order</reference-class>
>+            </read-object-query>
>+         </querying>
>+         <attribute-mappings>
>+            <attribute-mapping xsi:type="direct-mapping">
>+               <attribute-name>orderId</attribute-name>
>+               <get-method>getOrderId</get-method>
>+               <set-method>setOrderId</set-method>
>+               <field table="JPA_PROPS_ORDER" name="ORDER_ID" xsi:type="column"/>
>+            </attribute-mapping>
>+            <attribute-mapping xsi:type="direct-mapping">
>+               <attribute-name>version</attribute-name>
>+               <get-method>getVersion</get-method>
>+               <set-method>setVersion</set-method>
>+               <field table="JPA_PROPS_ORDER" name="ORDER_VERSION" xsi:type="column"/>
>+            </attribute-mapping>
>+            <attribute-mapping xsi:type="direct-mapping">
>+               <attribute-name>shippingAddress</attribute-name>
>+               <get-method>getShippingAddress</get-method>
>+               <set-method>setShippingAddress</set-method>
>+               <field table="JPA_PROPS_ORDER" name="SHIP_ADDR" xsi:type="column"/>
>+            </attribute-mapping>
>+            <attribute-mapping xsi:type="direct-mapping">
>+               <attribute-name>quantity</attribute-name>
>+               <get-method>getQuantity</get-method>
>+               <set-method>setQuantity</set-method>
>+               <field table="JPA_PROPS_ORDER" name="QUANTITY" xsi:type="column"/>
>+            </attribute-mapping>
>+            <attribute-mapping xsi:type="one-to-one-mapping">
>+               <attribute-name>customer</attribute-name>
>+               <get-method>getCustomer</get-method>
>+               <set-method>setCustomer</set-method>
>+               <reference-class>org.eclipse.persistence.testing.models.jpa.jpaadvancedproperties.Customer</reference-class>
>+               <foreign-key>
>+                  <field-reference>
>+                     <source-field table="JPA_PROPS_ORDER" name="CUSTOMER_CUST_ID" xsi:type="column"/>
>+                     <target-field table="JPA_PROPS_CUSTOMER" name="CUST_ID" xsi:type="column"/>
>+                  </field-reference>
>+               </foreign-key>
>+               <foreign-key-fields>
>+                  <field table="JPA_PROPS_ORDER" name="CUSTOMER_CUST_ID" xsi:type="column"/>
>+               </foreign-key-fields>
>+               <selection-query xsi:type="read-object-query">
>+                  <criteria operator="equal" xsi:type="relation-expression">
>+                     <left xsi:type="field-expression">
>+                        <field table="JPA_PROPS_CUSTOMER" name="CUST_ID" xsi:type="column"/>
>+                        <base xsi:type="base-expression"/>
>+                     </left>
>+                     <right xsi:type="parameter-expression">
>+                        <parameter table="JPA_PROPS_ORDER" name="CUSTOMER_CUST_ID" xsi:type="column"/>
>+                     </right>
>+                  </criteria>
>+                  <reference-class>org.eclipse.persistence.testing.models.jpa.jpaadvancedproperties.Customer</reference-class>
>+               </selection-query>
>+            </attribute-mapping>
>+            <attribute-mapping xsi:type="one-to-one-mapping">
>+               <attribute-name>salesPerson</attribute-name>
>+               <get-method>getSalesPerson</get-method>
>+               <set-method>setSalesPerson</set-method>
>+               <reference-class>org.eclipse.persistence.testing.models.jpa.jpaadvancedproperties.SalesPerson</reference-class>
>+               <foreign-key>
>+                  <field-reference>
>+                     <source-field table="JPA_PROPS_ORDER" name="SALESPERSON_ID" xsi:type="column"/>
>+                     <target-field table="JPA_PROPS_SALESPERSON" name="ID" xsi:type="column"/>
>+                  </field-reference>
>+               </foreign-key>
>+               <foreign-key-fields>
>+                  <field table="JPA_PROPS_ORDER" name="SALESPERSON_ID" xsi:type="column"/>
>+               </foreign-key-fields>
>+               <selection-query xsi:type="read-object-query">
>+                  <criteria operator="equal" xsi:type="relation-expression">
>+                     <left xsi:type="field-expression">
>+                        <field table="JPA_PROPS_SALESPERSON" name="ID" xsi:type="column"/>
>+                        <base xsi:type="base-expression"/>
>+                     </left>
>+                     <right xsi:type="parameter-expression">
>+                        <parameter table="JPA_PROPS_ORDER" name="SALESPERSON_ID" xsi:type="column"/>
>+                     </right>
>+                  </criteria>
>+                  <reference-class>org.eclipse.persistence.testing.models.jpa.jpaadvancedproperties.SalesPerson</reference-class>
>+               </selection-query>
>+            </attribute-mapping>
>+            <attribute-mapping xsi:type="one-to-one-mapping">
>+               <attribute-name>billedCustomer</attribute-name>
>+               <get-method>getBilledCustomer</get-method>
>+               <set-method>setBilledCustomer</set-method>
>+               <reference-class>org.eclipse.persistence.testing.models.jpa.jpaadvancedproperties.Customer</reference-class>
>+               <foreign-key>
>+                  <field-reference>
>+                     <source-field table="JPA_PROPS_ORDER" name="BILLEDCUSTOMER_CUST_ID" xsi:type="column"/>
>+                     <target-field table="JPA_PROPS_CUSTOMER" name="CUST_ID" xsi:type="column"/>
>+                  </field-reference>
>+               </foreign-key>
>+               <foreign-key-fields>
>+                  <field table="JPA_PROPS_ORDER" name="BILLEDCUSTOMER_CUST_ID" xsi:type="column"/>
>+               </foreign-key-fields>
>+               <selection-query xsi:type="read-object-query">
>+                  <criteria operator="equal" xsi:type="relation-expression">
>+                     <left xsi:type="field-expression">
>+                        <field table="JPA_PROPS_CUSTOMER" name="CUST_ID" xsi:type="column"/>
>+                        <base xsi:type="base-expression"/>
>+                     </left>
>+                     <right xsi:type="parameter-expression">
>+                        <parameter table="JPA_PROPS_ORDER" name="BILLEDCUSTOMER_CUST_ID" xsi:type="column"/>
>+                     </right>
>+                  </criteria>
>+                  <reference-class>org.eclipse.persistence.testing.models.jpa.jpaadvancedproperties.Customer</reference-class>
>+               </selection-query>
>+            </attribute-mapping>
>+            <attribute-mapping xsi:type="one-to-one-mapping">
>+               <attribute-name>item</attribute-name>
>+               <get-method>getItem</get-method>
>+               <set-method>setItem</set-method>
>+               <reference-class>org.eclipse.persistence.testing.models.jpa.jpaadvancedproperties.Item</reference-class>
>+               <cascade-persist>true</cascade-persist>
>+               <cascade-merge>true</cascade-merge>
>+               <cascade-refresh>true</cascade-refresh>
>+               <cascade-remove>true</cascade-remove>
>+               <foreign-key>
>+                  <field-reference>
>+                     <source-field table="JPA_PROPS_ORDER" name="ITEM_ID" xsi:type="column"/>
>+                     <target-field table="JPA_PROPS_ITEM" name="ID" xsi:type="column"/>
>+                  </field-reference>
>+               </foreign-key>
>+               <foreign-key-fields>
>+                  <field table="JPA_PROPS_ORDER" name="ITEM_ID" xsi:type="column"/>
>+               </foreign-key-fields>
>+               <selection-query xsi:type="read-object-query">
>+                  <criteria operator="equal" xsi:type="relation-expression">
>+                     <left xsi:type="field-expression">
>+                        <field table="JPA_PROPS_ITEM" name="ID" xsi:type="column"/>
>+                        <base xsi:type="base-expression"/>
>+                     </left>
>+                     <right xsi:type="parameter-expression">
>+                        <parameter table="JPA_PROPS_ORDER" name="ITEM_ID" xsi:type="column"/>
>+                     </right>
>+                  </criteria>
>+                  <reference-class>org.eclipse.persistence.testing.models.jpa.jpaadvancedproperties.Item</reference-class>
>+               </selection-query>
>+            </attribute-mapping>
>+         </attribute-mappings>
>+         <descriptor-type>independent</descriptor-type>
>+         <locking xsi:type="version-locking-policy">
>+            <version-field table="JPA_PROPS_ORDER" name="ORDER_VERSION" xsi:type="column"/>
>+            <store-version-in-cache>false</store-version-in-cache>
>+         </locking>
>+         <sequencing>
>+            <sequence-name>JPA_PROPS_ORDER_SEQ</sequence-name>
>+            <sequence-field table="JPA_PROPS_ORDER" name="ORDER_ID" xsi:type="column"/>
>+         </sequencing>
>+         <caching>
>+            <cache-size>500</cache-size>
>+         </caching>
>+         <remote-caching>
>+            <cache-size>500</cache-size>
>+         </remote-caching>
>+         <instantiation/>
>+         <copying xsi:type="instantiation-copy-policy"/>
>+         <change-policy xsi:type="deferred-detection-change-policy"/>
>+         <tables>
>+            <table name="JPA_PROPS_ORDER"/>
>+         </tables>
>+      </class-mapping-descriptor>
>+      <class-mapping-descriptor xsi:type="relational-class-mapping-descriptor">
>+         <class>org.eclipse.persistence.testing.models.jpa.jpaadvancedproperties.Item</class>
>+         <alias>Item</alias>
>+         <primary-key>
>+            <field table="JPA_PROPS_ITEM" name="ID" xsi:type="column"/>
>+         </primary-key>
>+         <events xsi:type="event-policy"/>
>+         <querying xsi:type="query-policy">
>+            <timeout>0</timeout>
>+            <insert-query xsi:type="insert-object-query"/>
>+            <delete-query xsi:type="delete-object-query"/>
>+            <does-exist-query xsi:type="does-exist-query">
>+               <existence-check>check-database</existence-check>
>+            </does-exist-query>
>+            <read-object-query xsi:type="read-object-query">
>+               <criteria operator="equal" xsi:type="relation-expression">
>+                  <left xsi:type="field-expression">
>+                     <field table="JPA_PROPS_ITEM" name="ID" xsi:type="column"/>
>+                     <base xsi:type="base-expression"/>
>+                  </left>
>+                  <right xsi:type="parameter-expression">
>+                     <parameter table="JPA_PROPS_ITEM" name="ID" xsi:type="column"/>
>+                  </right>
>+               </criteria>
>+               <reference-class>org.eclipse.persistence.testing.models.jpa.jpaadvancedproperties.Item</reference-class>
>+            </read-object-query>
>+         </querying>
>+         <attribute-mappings>
>+            <attribute-mapping xsi:type="direct-mapping">
>+               <attribute-name>itemId</attribute-name>
>+               <get-method>getItemId</get-method>
>+               <set-method>setItemId</set-method>
>+               <field table="JPA_PROPS_ITEM" name="ID" xsi:type="column"/>
>+            </attribute-mapping>
>+            <attribute-mapping xsi:type="direct-mapping">
>+               <attribute-name>name</attribute-name>
>+               <get-method>getName</get-method>
>+               <set-method>setName</set-method>
>+               <field table="JPA_PROPS_ITEM" name="NAME" xsi:type="column"/>
>+            </attribute-mapping>
>+            <attribute-mapping xsi:type="direct-mapping">
>+               <attribute-name>version</attribute-name>
>+               <get-method>getVersion</get-method>
>+               <set-method>setVersion</set-method>
>+               <field table="JPA_PROPS_ITEM" name="ITEM_VERSION" xsi:type="column"/>
>+            </attribute-mapping>
>+            <attribute-mapping xsi:type="direct-mapping">
>+               <attribute-name>description</attribute-name>
>+               <get-method>getDescription</get-method>
>+               <set-method>setDescription</set-method>
>+               <field table="JPA_PROPS_ITEM" name="DESCRIPTION" xsi:type="column"/>
>+            </attribute-mapping>
>+         </attribute-mappings>
>+         <descriptor-type>independent</descriptor-type>
>+         <locking xsi:type="version-locking-policy">
>+            <version-field table="JPA_PROPS_ITEM" name="ITEM_VERSION" xsi:type="column"/>
>+            <store-version-in-cache>false</store-version-in-cache>
>+         </locking>
>+         <sequencing>
>+            <sequence-name>ITEM_SEQ</sequence-name>
>+            <sequence-field table="JPA_PROPS_ITEM" name="ID" xsi:type="column"/>
>+         </sequencing>
>+         <caching>
>+            <cache-size>500</cache-size>
>+         </caching>
>+         <remote-caching>
>+            <cache-size>500</cache-size>
>+         </remote-caching>
>+         <instantiation/>
>+         <copying xsi:type="instantiation-copy-policy"/>
>+         <change-policy xsi:type="deferred-detection-change-policy"/>
>+         <tables>
>+            <table name="JPA_PROPS_ITEM"/>
>+         </tables>
>+      </class-mapping-descriptor>
>+      <class-mapping-descriptor xsi:type="relational-class-mapping-descriptor">
>+         <class>org.eclipse.persistence.testing.models.jpa.jpaadvancedproperties.SalesPerson</class>
>+         <alias>SalesPerson</alias>
>+         <primary-key>
>+            <field table="JPA_PROPS_SALESPERSON" name="ID" xsi:type="column"/>
>+         </primary-key>
>+         <events xsi:type="event-policy"/>
>+         <querying xsi:type="query-policy">
>+            <timeout>0</timeout>
>+            <insert-query xsi:type="insert-object-query"/>
>+            <delete-query xsi:type="delete-object-query"/>
>+            <does-exist-query xsi:type="does-exist-query">
>+               <existence-check>check-database</existence-check>
>+            </does-exist-query>
>+            <read-object-query xsi:type="read-object-query">
>+               <criteria operator="equal" xsi:type="relation-expression">
>+                  <left xsi:type="field-expression">
>+                     <field table="JPA_PROPS_SALESPERSON" name="ID" xsi:type="column"/>
>+                     <base xsi:type="base-expression"/>
>+                  </left>
>+                  <right xsi:type="parameter-expression">
>+                     <parameter table="JPA_PROPS_SALESPERSON" name="ID" xsi:type="column"/>
>+                  </right>
>+               </criteria>
>+               <reference-class>org.eclipse.persistence.testing.models.jpa.jpaadvancedproperties.SalesPerson</reference-class>
>+            </read-object-query>
>+         </querying>
>+         <attribute-mappings>
>+            <attribute-mapping xsi:type="direct-mapping">
>+               <attribute-name>id</attribute-name>
>+               <get-method>getId</get-method>
>+               <set-method>setId</set-method>
>+               <field table="JPA_PROPS_SALESPERSON" name="ID" xsi:type="column"/>
>+            </attribute-mapping>
>+            <attribute-mapping xsi:type="direct-mapping">
>+               <attribute-name>name</attribute-name>
>+               <get-method>getName</get-method>
>+               <set-method>setName</set-method>
>+               <field table="JPA_PROPS_SALESPERSON" name="NAME" xsi:type="column"/>
>+            </attribute-mapping>
>+            <attribute-mapping xsi:type="one-to-many-mapping">
>+               <attribute-name>orders</attribute-name>
>+               <get-method>getOrders</get-method>
>+               <set-method>setOrders</set-method>
>+               <reference-class>org.eclipse.persistence.testing.models.jpa.jpaadvancedproperties.Order</reference-class>
>+               <cascade-persist>true</cascade-persist>
>+               <cascade-merge>true</cascade-merge>
>+               <cascade-refresh>true</cascade-refresh>
>+               <cascade-remove>true</cascade-remove>
>+               <target-foreign-key>
>+                  <field-reference>
>+                     <source-field table="JPA_PROPS_ORDER" name="SALESPERSON_ID" xsi:type="column"/>
>+                     <target-field table="JPA_PROPS_SALESPERSON" name="ID" xsi:type="column"/>
>+                  </field-reference>
>+               </target-foreign-key>
>+               <container xsi:type="container-policy">
>+                  <collection-type>org.eclipse.persistence.indirection.IndirectList</collection-type>
>+               </container>
>+               <indirection xsi:type="transparent-collection-indirection-policy"/>
>+               <selection-query xsi:type="read-all-query">
>+                  <criteria operator="equal" xsi:type="relation-expression">
>+                     <left xsi:type="field-expression">
>+                        <field table="JPA_PROPS_ORDER" name="SALESPERSON_ID" xsi:type="column"/>
>+                        <base xsi:type="base-expression"/>
>+                     </left>
>+                     <right xsi:type="parameter-expression">
>+                        <parameter table="JPA_PROPS_SALESPERSON" name="ID" xsi:type="column"/>
>+                     </right>
>+                  </criteria>
>+                  <reference-class>org.eclipse.persistence.testing.models.jpa.jpaadvancedproperties.Order</reference-class>
>+                  <container xsi:type="container-policy">
>+                     <collection-type>org.eclipse.persistence.indirection.IndirectList</collection-type>
>+                  </container>
>+               </selection-query>
>+            </attribute-mapping>
>+         </attribute-mappings>
>+         <descriptor-type>independent</descriptor-type>
>+         <sequencing>
>+            <sequence-name>SALESPERSON_SEQ</sequence-name>
>+            <sequence-field table="JPA_PROPS_SALESPERSON" name="ID" xsi:type="column"/>
>+         </sequencing>
>+         <caching>
>+            <cache-size>500</cache-size>
>+         </caching>
>+         <remote-caching>
>+            <cache-size>500</cache-size>
>+         </remote-caching>
>+         <instantiation/>
>+         <copying xsi:type="instantiation-copy-policy"/>
>+         <change-policy xsi:type="deferred-detection-change-policy"/>
>+         <tables>
>+            <table name="JPA_PROPS_SALESPERSON"/>
>+         </tables>
>+      </class-mapping-descriptor>
>+   </class-mapping-descriptors>
>+</object-persistence>
>Index: jpa/eclipselink.jpa.test/resource/eclipselink-advanced-properties/server/sessions.xml
>===================================================================
>--- jpa/eclipselink.jpa.test/resource/eclipselink-advanced-properties/server/sessions.xml	(revision 0)
>+++ jpa/eclipselink.jpa.test/resource/eclipselink-advanced-properties/server/sessions.xml	(revision 0)
>@@ -0,0 +1,8 @@
>+<?xml version="1.0" encoding="US-ASCII"?>
>+<sessions xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="file://xsd/eclipse_persistence_sessions_1_0.xsd" version="1.0">
>+   <session xsi:type="server-session">
>+      <name>JPASessionXML</name>
>+      <logging xsi:type="java-log"/>
>+      <primary-project xsi:type="xml">META-INF/RelationshipProject.xml</primary-project>
>+   </session>
>+</sessions>
>Index: jpa/eclipselink.jpa.test/resource/eclipselink-ddl-generation-model/server/persistence.xml
>===================================================================
>--- jpa/eclipselink.jpa.test/resource/eclipselink-ddl-generation-model/server/persistence.xml	(revision 2560)
>+++ jpa/eclipselink.jpa.test/resource/eclipselink-ddl-generation-model/server/persistence.xml	(working copy)
>@@ -7,7 +7,7 @@
>         <provider>org.eclipse.persistence.jpa.PersistenceProvider</provider>
>         <jta-data-source>%%data-source-name%%</jta-data-source>
> 
>-        
>+        <mapping-file>META-INF/ddl-generation-model.xml</mapping-file>
> 
>         <properties>
>             <property name="eclipselink.target-server" value="%%server-platform%%"/>
>Index: jpa/eclipselink.jpa.test/src/org/eclipse/persistence/testing/tests/jpa/ddlgeneration/DDLGenerationJUnitTestSuite.java
>===================================================================
>--- jpa/eclipselink.jpa.test/src/org/eclipse/persistence/testing/tests/jpa/ddlgeneration/DDLGenerationJUnitTestSuite.java	(revision 2560)
>+++ jpa/eclipselink.jpa.test/src/org/eclipse/persistence/testing/tests/jpa/ddlgeneration/DDLGenerationJUnitTestSuite.java	(working copy)
>@@ -246,10 +246,6 @@
>     
>     // Test to check if unique constraints are generated correctly
>     public void testDDLUniqueConstraintsByXML() {
>-        if (isOnServer()) {
>-            // Not work on server.
>-            return;
>-        }
>         if(!getServerSession(DDL_PU).getPlatform().supportsUniqueKeyConstraints()) {
>             return;
>         }
>Index: jpa/eclipselink.jpa.test/src/org/eclipse/persistence/testing/tests/jpa/jpaadvancedproperties/JPAAdvPropertiesJUnitTestCase.java
>===================================================================
>--- jpa/eclipselink.jpa.test/src/org/eclipse/persistence/testing/tests/jpa/jpaadvancedproperties/JPAAdvPropertiesJUnitTestCase.java	(revision 2560)
>+++ jpa/eclipselink.jpa.test/src/org/eclipse/persistence/testing/tests/jpa/jpaadvancedproperties/JPAAdvPropertiesJUnitTestCase.java	(working copy)
>@@ -18,6 +18,7 @@
> import java.util.Vector;
> 
> import javax.persistence.EntityManager;
>+import javax.persistence.Query;
> 
> import junit.extensions.TestSetup;
> import junit.framework.Test;
>@@ -50,6 +51,7 @@
>     
>     public static Test suite() {
>         TestSuite suite = new TestSuite("JPA Advanced Properties Model");
>+        suite.addTest(new JPAAdvPropertiesJUnitTestCase("testSetup"));
>         suite.addTest(new JPAAdvPropertiesJUnitTestCase("testSessionXMLProperty"));
>         suite.addTest(new JPAAdvPropertiesJUnitTestCase("testSessionEventListenerProperty"));
>         suite.addTest(new JPAAdvPropertiesJUnitTestCase("testExceptionHandlerProperty"));
>@@ -60,26 +62,22 @@
>         suite.addTest(new JPAAdvPropertiesJUnitTestCase("testLoggingTyperProperty"));
>         suite.addTest(new JPAAdvPropertiesJUnitTestCase("testProfilerTyperProperty"));
>         
>-        return new TestSetup(suite) {
>-            
>-            protected void setUp(){               
>-                ServerSession session = JUnitTestCase.getServerSession(persistenceUnitName);
>-                session.logout();
>-                session.loginAndDetectDatasource();
>-                JPAPropertiesRelationshipTableManager tm = new JPAPropertiesRelationshipTableManager();
>-                tm.replaceTables(session);
>-            }
>-        
>-            protected void tearDown() {
>-                clearCache();
>-            }
>-        };
>+        return suite;
>     }
>     
>+    /**
>+     * The setup is done as a test, both to record its failure, and to allow execution in the server.
>+     */
>+    public void testSetup() {
>+        new JPAPropertiesRelationshipTableManager().replaceTables(JUnitTestCase.getServerSession(persistenceUnitName));
>+        clearCache();
>+    }
>+
>+    
>     public void testSessionEventListenerProperty() {
>         
>         EntityManager em = createEntityManager(persistenceUnitName);
>-        org.eclipse.persistence.sessions.server.ServerSession session = ((org.eclipse.persistence.jpa.JpaEntityManager)em.getDelegate()).getServerSession();
>+        ServerSession session = getServerSession();
>         try {
>             //Create new customer
>             beginTransaction(em);
>@@ -135,7 +133,7 @@
> 
>     public void testExceptionHandlerProperty() {
>         EntityManager em = createEntityManager(persistenceUnitName);
>-        org.eclipse.persistence.sessions.server.ServerSession session = ((org.eclipse.persistence.jpa.JpaEntityManager)em.getDelegate()).getServerSession();
>+        ServerSession session = getServerSession();
>         Expression exp = new ExpressionBuilder().get("name1").equal("George W.");
>         try {
>             Object result = session.readObject(Customer.class, exp);
>@@ -149,7 +147,7 @@
>     
>     public void testNativeSQLProperty() {
>         EntityManager em = createEntityManager(persistenceUnitName);
>-        org.eclipse.persistence.sessions.server.ServerSession session = ((org.eclipse.persistence.jpa.JpaEntityManager)em.getDelegate()).getServerSession();
>+        ServerSession session = getServerSession();
>         if(!session.getProject().getLogin().shouldUseNativeSQL()){
>             fail("The native sql flag specified as true by the property eclipselink.jdbc.native-sql in persistence.xml, it however read as false.");
>         }
>@@ -158,7 +156,7 @@
>     
>     public void testBatchwritingProperty(){
>         EntityManager em = createEntityManager(persistenceUnitName);
>-        org.eclipse.persistence.sessions.server.ServerSession session = ((org.eclipse.persistence.jpa.JpaEntityManager)em.getDelegate()).getServerSession();
>+        ServerSession session = getServerSession();
>         
>         if(!(session.getPlatform().usesBatchWriting() && 
>            !session.getPlatform().usesJDBCBatchWriting() &&
>@@ -170,7 +168,7 @@
>     
>     public void testCopyDescriptorNamedQueryToSessionProperty(){
>         EntityManager em = createEntityManager(persistenceUnitName);
>-        org.eclipse.persistence.sessions.server.ServerSession session = ((org.eclipse.persistence.jpa.JpaEntityManager)em.getDelegate()).getServerSession();
>+        ServerSession session = getServerSession();
>         org.eclipse.persistence.queries.DatabaseQuery query = session.getQuery("customerReadByName");
>         if(query == null){
>             fail("The copy descriptor named query is enable by the property eclipselink.session.include.descriptor.queries in persistence.xml, one descriptor named query has not been copied to the session");
>@@ -180,7 +178,7 @@
>     
>     public void testCacheStatementsAndItsSizeProperty() {
>         EntityManager em = createEntityManager(persistenceUnitName);
>-        org.eclipse.persistence.sessions.server.ServerSession session = ((org.eclipse.persistence.jpa.JpaEntityManager)em.getDelegate()).getServerSession();
>+        ServerSession session = getServerSession();
>         if(session.getConnectionPools().size()>0){//And if connection pooling is configured,
>             if(!session.getProject().getLogin().shouldCacheAllStatements()){
>                 fail("Caching all statements flag set equals to true by property eclipselink.jdbc.cache-statements in persistence.xml, it however read as false.");
>@@ -195,7 +193,7 @@
>     
>     public void testLoggingTyperProperty(){
>         EntityManager em = createEntityManager(persistenceUnitName);
>-        org.eclipse.persistence.sessions.server.ServerSession session = ((org.eclipse.persistence.jpa.JpaEntityManager)em.getDelegate()).getServerSession();
>+        ServerSession session = getServerSession();
>         if(!(session.getSessionLog() instanceof org.eclipse.persistence.logging.JavaLog)){
>             fail("Logging type set to JavaLog, it however has been detected as different type logger.");
>         }
>@@ -203,15 +201,19 @@
>     }
>     
>     public void testProfilerTyperProperty(){
>+        if (isOnServer()) {
>+            // Multi-persistece-unit not work on server.
>+            return;
>+        }
>         EntityManager em = createEntityManager("JPAADVProperties2");
>-        org.eclipse.persistence.sessions.server.ServerSession session = ((org.eclipse.persistence.jpa.JpaEntityManager)em.getDelegate()).getServerSession();
>+        ServerSession session = getServerSession();
>         if (!(session.getProfiler() instanceof org.eclipse.persistence.tools.profiler.PerformanceProfiler)) {
>             fail("Profiler type set to PerformanceProfiler, it however has been detected as different type Profiler.");
>         }
>         closeEntityManager(em);
>                 
>         em = createEntityManager("JPAADVProperties3");
>-        session = ((org.eclipse.persistence.jpa.JpaEntityManager)em.getDelegate()).getServerSession();
>+        session = getServerSession();
>         if (session.getProfiler() !=null) {
>             fail("no profiler has been set,it however has been detected.");
>         }
>@@ -245,22 +247,35 @@
>         
>         //Find customer
>         beginTransaction(em);
>+        try {
>         Customer cm1 = em.find(org.eclipse.persistence.testing.models.jpa.jpaadvancedproperties.Customer.class, customerId);
>         if(cm1==null){
>             fail("Error finding customer ");    
>         }
> 
>-        ArrayList orders = (ArrayList)cm1.getOrders();
>+        //ArrayList orders = (ArrayList)cm1.getOrders();
>+        Vector orders = (Vector)cm1.getOrders();
>         if(orders == null || orders.size()!=3){
>             fail("Error finding order pertaining to the customer ");    
>+            }
>+            commitTransaction(em);
>+        } catch (RuntimeException e) {
>+            if (isTransactionActive(em)){
>+                rollbackTransaction(em);
>+            }
>+            closeEntityManager(em);
>+            throw e;
>         }
>+    
>         
>         //Query the customer
>         Customer cm2 = null;
>+        beginTransaction(em);
>         try {
>-            EJBQueryImpl query = (EJBQueryImpl) createEntityManager(persistenceUnitName).createNamedQuery("customerReadByName");
>+            Query query = createEntityManager(persistenceUnitName).createNamedQuery("customerReadByName");
>             query.setParameter("name", "George W.");
>             cm2 = (Customer) query.getSingleResult();
>+            commitTransaction(em);
>         }catch (RuntimeException e) {
>             if (isTransactionActive(em)){
>                 rollbackTransaction(em);
>@@ -272,6 +287,7 @@
> 
>         
>         //Update customer
>+        beginTransaction(em);
>         String originalName = null;
>         try {
>             Customer cm = em.find(org.eclipse.persistence.testing.models.jpa.jpaadvancedproperties.Customer.class, customerId);
>Index: jpa/eclipselink.jpa.test/src/org/eclipse/persistence/testing/tests/jpa/jpql/AdvancedQueryTestSuite.java
>===================================================================
>--- jpa/eclipselink.jpa.test/src/org/eclipse/persistence/testing/tests/jpa/jpql/AdvancedQueryTestSuite.java	(revision 2560)
>+++ jpa/eclipselink.jpa.test/src/org/eclipse/persistence/testing/tests/jpa/jpql/AdvancedQueryTestSuite.java	(working copy)
>@@ -75,6 +75,7 @@
>     public static Test suite() {
>         TestSuite suite = new TestSuite();
>         suite.setName("AdvancedQueryTestSuite");
>+        suite.addTest(new AdvancedQueryTestSuite("testSetup"));
>         suite.addTest(new AdvancedQueryTestSuite("testQueryCacheFirstCacheHits"));
>         suite.addTest(new AdvancedQueryTestSuite("testQueryCacheOnlyCacheHits"));
>         suite.addTest(new AdvancedQueryTestSuite("testQueryCacheOnlyCacheHitsOnSession"));
>@@ -82,34 +83,30 @@
>         suite.addTest(new AdvancedQueryTestSuite("testQueryExactPrimaryKeyCacheHits"));
>         suite.addTest(new AdvancedQueryTestSuite("testQueryTypeCacheHits"));
>         suite.addTest(new AdvancedQueryTestSuite("testQueryCache"));
>-        return new TestSetup(suite) {
>-
>-                //This method is run at the end of the SUITE only
>-
>-                protected void tearDown() {
>-                    clearCache();
>-                }
>-                // This method is run at the start of the SUITE only.
>-
>-                protected void setUp() {
>-                    //get session to start setup
>-                    DatabaseSession session = JUnitTestCase.getServerSession();
>-                    //create a new EmployeePopulator
>-                    EmployeePopulator employeePopulator = new EmployeePopulator();
>-                    new AdvancedTableCreator().replaceTables(session);
>-                    //initialize the global comparer object
>-                    comparer = new JUnitDomainObjectComparer();
>-                    //set the session for the comparer to use
>-                    comparer.setSession((AbstractSession)session.getActiveSession());
>-                    //Populate the tables
>-                    employeePopulator.buildExamples();
>-                    //Persist the examples in the database
>-                    employeePopulator.persistExample(session);
>-                }
>-            };
>+        
>+        return suite;
>     }
>-
>+    
>     /**
>+     * The setup is done as a test, both to record its failure, and to allow execution in the server.
>+     */
>+    public void testSetup() {
>+        clearCache();
>+        DatabaseSession session = JUnitTestCase.getServerSession();
>+        //create a new EmployeePopulator
>+        EmployeePopulator employeePopulator = new EmployeePopulator();
>+        new AdvancedTableCreator().replaceTables(session);
>+        //initialize the global comparer object
>+        comparer = new JUnitDomainObjectComparer();
>+        //set the session for the comparer to use
>+        comparer.setSession((AbstractSession)session.getActiveSession());
>+        //Populate the tables
>+        employeePopulator.buildExamples();
>+        //Persist the examples in the database
>+        employeePopulator.persistExample(session);
>+    }
>+    
>+    /**
>      * Test that a cache hit will occur on a primary key query.
>      */
>     public void testQueryPrimaryKeyCacheHits() {
>Index: jpa/eclipselink.jpa.test/src/org/eclipse/persistence/testing/tests/jpa/jpql/JUnitJPQLComplexAggregateTestSuite.java
>===================================================================
>--- jpa/eclipselink.jpa.test/src/org/eclipse/persistence/testing/tests/jpa/jpql/JUnitJPQLComplexAggregateTestSuite.java	(revision 2560)
>+++ jpa/eclipselink.jpa.test/src/org/eclipse/persistence/testing/tests/jpa/jpql/JUnitJPQLComplexAggregateTestSuite.java	(working copy)
>@@ -21,6 +21,7 @@
> 
> import java.util.Vector;
> import javax.persistence.Query;
>+import javax.persistence.EntityManager;
> import junit.framework.Assert;
> import junit.framework.Test;
> import junit.framework.TestSuite;
>@@ -86,6 +87,7 @@
>     {
>         TestSuite suite = new TestSuite();
>         suite.setName("JUnitJPQLComplexAggregateTestSuite");
>+        suite.addTest(new JUnitJPQLComplexAggregateTestSuite("testSetup"));
>         suite.addTest(new JUnitJPQLComplexAggregateTestSuite("complexAVGTest"));
>         suite.addTest(new JUnitJPQLComplexAggregateTestSuite("complexCountDistinctWithGroupByAndHavingTest"));
>         suite.addTest(new JUnitJPQLComplexAggregateTestSuite("complexCountDistinctWithGroupByTest"));
>@@ -102,52 +104,47 @@
>         suite.addTest(new JUnitJPQLComplexAggregateTestSuite("complexCountOnJoinedVariableCompositePK"));
>         suite.addTest(new JUnitJPQLComplexAggregateTestSuite("complexCountOnJoinedVariableOverManyToManySelfRefRelationship"));
>         suite.addTest(new JUnitJPQLComplexAggregateTestSuite("complexCountOnJoinedCompositePK"));
>+        
>+        return suite;
>+    }
>+    
>+    /**
>+     * The setup is done as a test, both to record its failure, and to allow execution in the server.
>+     */
>+    public void testSetup() {
>+        clearCache();
>+        //get session to start setup
>+        DatabaseSession session = JUnitTestCase.getServerSession();
>+        
>+        //create a new EmployeePopulator
>+        EmployeePopulator employeePopulator = new EmployeePopulator();
>+        
>+        new AdvancedTableCreator().replaceTables(session);
>+        new CompositePKTableCreator().replaceTables(session);
> 
>-        return new TestSetup(suite) {
>-     
>-            //This method is run at the end of the SUITE only
>-            protected void tearDown() {
>-                clearCache();
>-            }
>-            
>-            //This method is run at the start of the SUITE only
>-            protected void setUp() {
>-                clearCache();
>-                
>-                //get session to start setup
>-                DatabaseSession session = JUnitTestCase.getServerSession();
>-                
>-                //create a new EmployeePopulator
>-                EmployeePopulator employeePopulator = new EmployeePopulator();
>-                
>-                new AdvancedTableCreator().replaceTables(session);
>-                new CompositePKTableCreator().replaceTables(session);
>+        RelationshipsExamples relationshipExamples = new RelationshipsExamples();
>+        new RelationshipsTableManager().replaceTables(session);
>+        
>+        //initialize the global comparer object
>+        comparer = new JUnitDomainObjectComparer();
>+        
>+        //set the session for the comparer to use
>+        comparer.setSession((AbstractSession)session.getActiveSession());              
>+        
>+        //Populate the tables
>+        employeePopulator.buildExamples();
>+        
>+        //Persist the examples in the database
>+        employeePopulator.persistExample(session);  
> 
>-                RelationshipsExamples relationshipExamples = new RelationshipsExamples();
>-                new RelationshipsTableManager().replaceTables(session);
>-                
>-                //initialize the global comparer object
>-                comparer = new JUnitDomainObjectComparer();
>-                
>-                //set the session for the comparer to use
>-                comparer.setSession((AbstractSession)session.getActiveSession());              
>-                
>-                //Populate the tables
>-                employeePopulator.buildExamples();
>-                
>-                //Persist the examples in the database
>-                employeePopulator.persistExample(session);  
>-
>-                //populate the relationships model and persist as well
>-                relationshipExamples.buildExamples(session);
>-            }     
>-        };    
>-  }
>-  
>+        //populate the relationships model and persist as well
>+        relationshipExamples.buildExamples(session);
>+    }
>+    
>     public void complexAVGTest()
>     {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager) createEntityManager();                  
>-               
>+        EntityManager em = createEntityManager();
>+        beginTransaction(em);
>         ExpressionBuilder expbldr = new ExpressionBuilder();
>             
>         ReportQuery rq = new ReportQuery(Employee.class, expbldr);
>@@ -161,9 +158,9 @@
>         rq.useDistinct();
>         rq.addAverage("salary", Double.class);
>         
>-        String ejbqlString = "SELECT AVG(DISTINCT emp.salary) FROM Employee emp WHERE emp.lastName = \"Smith\"";      
>+        String ejbqlString = "SELECT AVG(DISTINCT emp.salary) FROM Employee emp WHERE emp.lastName = \"Smith\"";
>         
>-        Vector expectedResultVector = (Vector) em.getActiveSession().executeQuery(rq);
>+        Vector expectedResultVector = (Vector) getServerSession().executeQuery(rq);
>         Double expectedResult = (Double)expectedResultVector.get(0);
>         
>         clearCache();
>@@ -171,6 +168,8 @@
>         Double result = (Double) em.createQuery(ejbqlString).getSingleResult();
>  
>         Assert.assertEquals("Complex AVG test failed", expectedResult, result);
>+        rollbackTransaction(em);
>+        closeEntityManager(em);
>     }
>     
>     /*
>@@ -180,7 +179,8 @@
>     public void complexCountDistinctWithGroupByAndHavingTest()
>     {
>         String havingFilterString = "Toronto";
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager) createEntityManager();                  
>+        EntityManager em = createEntityManager();
>+        beginTransaction(em);
>         //Need to set the class in the expressionbuilder, as the Count(Distinct) will cause the 
>         // query to change and be built around the Employee class instead of the Address class.
>         ExpressionBuilder expbldr = new ExpressionBuilder(Address.class);
>@@ -193,14 +193,15 @@
>         rq.addCount("COUNT",exp.distinct(),Long.class );
>         rq.addGrouping(exp2);
>         rq.setHavingExpression(exp2.equal(havingFilterString));
>-        Vector expectedResult = (Vector) em.getActiveSession().executeQuery(rq);
>-        
>+        Vector expectedResult = (Vector) getServerSession().executeQuery(rq);
>         String ejbqlString3 = "SELECT a.city, COUNT( DISTINCT e ) FROM Address a JOIN a.employees e GROUP BY a.city HAVING a.city =?1";
>         Query q = em.createQuery(ejbqlString3);
>         q.setParameter(1,havingFilterString);
>         List result = q.getResultList();
>         
>-        Assert.assertTrue("Complex COUNT test failed", comparer.compareObjects(result, expectedResult));                      
>+        Assert.assertTrue("Complex COUNT test failed", comparer.compareObjects(result, expectedResult));
>+        rollbackTransaction(em);
>+        closeEntityManager(em);
>     }
> 
> 
>@@ -210,8 +211,8 @@
>      */
>     public void complexCountDistinctWithGroupByTest()
>     {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager) createEntityManager();                  
>-        
>+        EntityManager em = createEntityManager();
>+        beginTransaction(em);
>         //need to set the class in the expressionbuilder, as the Count(Distinct) will cause the 
>         // query to change and be built around the Employee class instead of the Address class.  
>         ExpressionBuilder expbldr = new ExpressionBuilder(Address.class);
>@@ -223,13 +224,14 @@
>         rq.addAttribute("city", exp2);
>         rq.addCount("COUNT",exp.distinct(),Long.class );
>         rq.addGrouping(exp2);
>-        Vector expectedResult = (Vector) em.getActiveSession().executeQuery(rq);
>-        
>+        Vector expectedResult = (Vector) getServerSession().executeQuery(rq);
>         String ejbqlString3 = "SELECT a.city, COUNT( DISTINCT e ) FROM Address a JOIN a.employees e GROUP BY a.city";
>         Query q = em.createQuery(ejbqlString3);
>         List result = q.getResultList();
>         
>-        Assert.assertTrue("Complex COUNT(Distinct) with Group By test failed", comparer.compareObjects(result, expectedResult));                      
>+        Assert.assertTrue("Complex COUNT(Distinct) with Group By test failed", comparer.compareObjects(result, expectedResult));
>+        rollbackTransaction(em);
>+        closeEntityManager(em);
>     }
>     
>     /*
>@@ -238,8 +240,8 @@
>      */
>     public void complexCountDistinctWithGroupByTest2()
>     {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager) createEntityManager();                  
>-        
>+        EntityManager em = createEntityManager();
>+        beginTransaction(em);
>         //need to set the class in the expressionbuilder, as the Count(Distinct) will cause the 
>         // query to change and be built around the Employee class instead of the Address class.  
>         ExpressionBuilder expbldr = new ExpressionBuilder(Address.class);
>@@ -252,13 +254,14 @@
>         rq.addCount("COUNT1",exp, Long.class);
>         rq.addCount("COUNT2",exp.get("lastName").distinct(),Long.class );
>         rq.addGrouping(exp2);
>-        Vector expectedResult = (Vector) em.getActiveSession().executeQuery(rq);
>-        
>+        Vector expectedResult = (Vector) getServerSession().executeQuery(rq);
>         String ejbqlString3 = "SELECT a.city, COUNT( e ), COUNT( DISTINCT e.lastName ) FROM Address a JOIN a.employees e GROUP BY a.city";
>         Query q = em.createQuery(ejbqlString3);
>         List result = q.getResultList();
>         
>-        Assert.assertTrue("Complex COUNT(Distinct) with Group By test failed", comparer.compareObjects(result, expectedResult));                      
>+        Assert.assertTrue("Complex COUNT(Distinct) with Group By test failed", comparer.compareObjects(result, expectedResult));
>+        rollbackTransaction(em);
>+        closeEntityManager(em);
>     }
>     
>     /**
>@@ -266,8 +269,8 @@
>      */
>     public void complexHavingWithAggregate()
>     {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager) createEntityManager();
>-        
>+        EntityManager em = createEntityManager();
>+        beginTransaction(em);
>         // Test using the project id in COUNT, GROUP BY and HAVING
>         ExpressionBuilder employeeBuilder = new ExpressionBuilder(Employee.class);
>         ReportQuery rq = new ReportQuery(Employee.class, employeeBuilder);
>@@ -279,8 +282,8 @@
>         rq.addGrouping(pid);
>         rq.setHavingExpression(count.greaterThan(1));
>         rq.setShouldReturnWithoutReportQueryResult(true);
>-        Vector expectedResult = (Vector) em.getActiveSession().executeQuery(rq);
>-
>+        //Vector expectedResult = (Vector) em.getActiveSession().executeQuery(rq);
>+        Vector expectedResult = (Vector) getServerSession().executeQuery(rq);
>         String jpql = 
>             "SELECT p.id, COUNT(p.id) FROM Employee e JOIN e.projects p " + 
>             "GROUP BY p.id HAVING COUNT(p.id)>1";
>@@ -299,7 +302,7 @@
>         rq.addGrouping(projects);
>         rq.setHavingExpression(count.greaterThan(1));
>         rq.setShouldReturnWithoutReportQueryResult(true);
>-        expectedResult = (Vector) em.getActiveSession().executeQuery(rq);
>+        expectedResult = (Vector) getServerSession().executeQuery(rq);
> 
>         jpql = 
>             "SELECT p, COUNT(p) FROM Employee e JOIN e.projects p " + 
>@@ -308,30 +311,37 @@
> 
>         Assert.assertTrue("Complex HAVING with aggregate function failed", 
>                           comparer.compareObjects(result, expectedResult));
>+        rollbackTransaction(em);
>+        closeEntityManager(em);
>     }
>     
>     public void complexCountTest()
>     {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager) createEntityManager();                  
>-               
>-        ExpressionBuilder expbldr = new ExpressionBuilder();
>+        EntityManager em = createEntityManager();
>+        beginTransaction(em);
>+        try {
>+            ExpressionBuilder expbldr = new ExpressionBuilder();
>             
>-        ReportQuery rq = new ReportQuery(Employee.class, expbldr);
>+            ReportQuery rq = new ReportQuery(Employee.class, expbldr);
>         
>-        Expression exp = expbldr.get("lastName").equal("Smith");
>+            Expression exp = expbldr.get("lastName").equal("Smith");
>         
>-        rq.setReferenceClass(Employee.class);
>-        rq.setSelectionCriteria(exp);
>-        rq.returnSingleAttribute();
>-        rq.dontRetrievePrimaryKeys();
>-        rq.addCount("COUNT", expbldr, Long.class);
>-        Vector expectedResultVector = (Vector) em.getActiveSession().executeQuery(rq);
>-        Long expectedResult = (Long) expectedResultVector.get(0);
>+            rq.setReferenceClass(Employee.class);
>+            rq.setSelectionCriteria(exp);
>+            rq.returnSingleAttribute();
>+            rq.dontRetrievePrimaryKeys();
>+            rq.addCount("COUNT", expbldr, Long.class);
>+            Vector expectedResultVector = (Vector) getServerSession().executeQuery(rq);
>+            Long expectedResult = (Long) expectedResultVector.get(0);
>         
>-        String ejbqlString = "SELECT COUNT(emp) FROM Employee emp WHERE emp.lastName = \"Smith\"";    
>-        Long result = (Long) em.createQuery(ejbqlString).getSingleResult();
>+            String ejbqlString = "SELECT COUNT(emp) FROM Employee emp WHERE emp.lastName = \"Smith\"";    
>+            Long result = (Long) em.createQuery(ejbqlString).getSingleResult();
>  
>-        Assert.assertEquals("Complex COUNT test failed", expectedResult, result);
>+            Assert.assertEquals("Complex COUNT test failed", expectedResult, result);
>+        } finally {
>+            rollbackTransaction(em);
>+            closeEntityManager(em);
>+        }
>     }
>     
>     /*
>@@ -340,7 +350,8 @@
>      */
>     public void complexCountWithGroupByTest()
>     {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager) createEntityManager();                  
>+        EntityManager em = createEntityManager();
>+        beginTransaction(em);
>         //Need to set the class in the expressionbuilder, as the Count(Distinct) will cause the 
>         // query to change and be built around the Employee class instead of the Address class.  
>         ExpressionBuilder expbldr = new ExpressionBuilder(Address.class);
>@@ -352,19 +363,20 @@
>         rq.addAttribute("city", exp2);
>         rq.addCount("COUNT",exp.distinct(),Long.class );
>         rq.addGrouping(exp2);
>-        Vector expectedResult = (Vector) em.getActiveSession().executeQuery(rq);
>-
>+        Vector expectedResult = (Vector) getServerSession().executeQuery(rq);
>         String ejbqlString3 = "SELECT a.city, COUNT( DISTINCT e ) FROM Address a JOIN a.employees e GROUP BY a.city";
>         Query q = em.createQuery(ejbqlString3);
>         List result = q.getResultList();
>         
>-        Assert.assertTrue("Complex COUNT with Group By test failed", comparer.compareObjects(result, expectedResult));                      
>+        Assert.assertTrue("Complex COUNT with Group By test failed", comparer.compareObjects(result, expectedResult));
>+        rollbackTransaction(em);
>+        closeEntityManager(em);
>     }
>     
>     public void complexDistinctCountTest()
>     {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager) createEntityManager();                  
>-               
>+        EntityManager em = createEntityManager();
>+        beginTransaction(em);
>         ExpressionBuilder expbldr = new ExpressionBuilder();
>             
>         ReportQuery rq = new ReportQuery(Employee.class, expbldr);
>@@ -377,19 +389,21 @@
>         rq.returnSingleAttribute();
>         rq.dontRetrievePrimaryKeys();
>         rq.addCount("COUNT", expbldr.get("lastName").distinct(), Long.class);
>-        Vector expectedResultVector = (Vector) em.getActiveSession().executeQuery(rq);
>+        Vector expectedResultVector = (Vector) getServerSession().executeQuery(rq);
>         Long expectedResult = (Long) expectedResultVector.get(0);
>         
>         String ejbqlString = "SELECT COUNT(DISTINCT emp.lastName) FROM Employee emp WHERE emp.lastName = \"Smith\"";
>         Long result = (Long) em.createQuery(ejbqlString).getSingleResult();
>  
>         Assert.assertEquals("Complex DISTINCT COUNT test failed", expectedResult, result);
>+        rollbackTransaction(em);
>+        closeEntityManager(em);
>     }
>     
>     public void complexMaxTest()
>     {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager) createEntityManager();                  
>-               
>+        EntityManager em = createEntityManager();
>+        beginTransaction(em);
>         ExpressionBuilder expbldr = new ExpressionBuilder();
>             
>         ReportQuery rq = new ReportQuery(Employee.class, expbldr);
>@@ -397,40 +411,43 @@
>         rq.returnSingleAttribute();     
>         rq.dontRetrievePrimaryKeys();
>         rq.addAttribute("salary", expbldr.get("salary").distinct().maximum());
>-        Vector expectedResultVector = (Vector) em.getActiveSession().executeQuery(rq);
>+        Vector expectedResultVector = (Vector) getServerSession().executeQuery(rq);
>         Number expectedResult = (Number) expectedResultVector.get(0);
>         
>         String ejbqlString = "SELECT MAX(DISTINCT emp.salary) FROM Employee emp";
>         Number result = (Number) em.createQuery(ejbqlString).getSingleResult();
>  
>         Assert.assertEquals("Complex MAX test failed", expectedResult, result);
>+        rollbackTransaction(em);
>+        closeEntityManager(em);
>     }
>     
>     public void complexMinTest()
>     {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager) createEntityManager();                  
>-               
>+        EntityManager em = createEntityManager();
>+        beginTransaction(em);
>         ExpressionBuilder expbldr = new ExpressionBuilder();
>-            
>+        
>         ReportQuery rq = new ReportQuery(Employee.class, expbldr);
>         rq.setReferenceClass(Employee.class);
>         rq.returnSingleAttribute();     
>         rq.dontRetrievePrimaryKeys();
>         rq.addAttribute("salary", expbldr.get("salary").distinct().minimum());
>-        Vector expectedResultVector = (Vector) em.getActiveSession().executeQuery(rq);
>+        Vector expectedResultVector = (Vector) getServerSession().executeQuery(rq);
>         Number expectedResult = (Number) expectedResultVector.get(0);
> 
>         String ejbqlString = "SELECT MIN(DISTINCT emp.salary) FROM Employee emp";
>         Number result = (Number) em.createQuery(ejbqlString).getSingleResult();
>- 
>+
>         Assert.assertEquals("Complex MIN test failed", expectedResult, result);  
>-        
>+        rollbackTransaction(em);
>+        closeEntityManager(em);
>     }
>     
>     public void complexSumTest()
>     {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager) createEntityManager();                  
>-               
>+        EntityManager em = createEntityManager();
>+        beginTransaction(em);
>         ExpressionBuilder expbldr = new ExpressionBuilder();
>             
>         ReportQuery rq = new ReportQuery(Employee.class, expbldr);
>@@ -438,14 +455,15 @@
>         rq.returnSingleAttribute();     
>         rq.dontRetrievePrimaryKeys();
>         rq.addAttribute("salary", expbldr.get("salary").distinct().sum(), Long.class);
>-        Vector expectedResultVector = (Vector) em.getActiveSession().executeQuery(rq);
>+        Vector expectedResultVector = (Vector) getServerSession().executeQuery(rq);
>         Long expectedResult = (Long) expectedResultVector.get(0);
>         
>         String ejbqlString = "SELECT SUM(DISTINCT emp.salary) FROM Employee emp";
>         Long result = (Long) em.createQuery(ejbqlString).getSingleResult();
>  
>         Assert.assertEquals("Complex SUMtest failed", expectedResult, result);
>-        
>+        rollbackTransaction(em);
>+        closeEntityManager(em);
>     }
> 
>     /**
>@@ -453,16 +471,19 @@
>      */
>     public void complexCountDistinctOnBaseQueryClass()
>     {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = 
>-            (org.eclipse.persistence.jpa.JpaEntityManager) createEntityManager();
>+        EntityManager em = createEntityManager();
>+        beginTransaction(em);
>         
>-        Long expectedResult = Long.valueOf(em.getActiveSession().readAllObjects(Employee.class).size());
>+        Long expectedResult = Long.valueOf(getServerSession().readAllObjects(Employee.class).size());
>         
>         String jpql = "SELECT COUNT(DISTINCT e) FROM Employee e";
>         Query q = em.createQuery(jpql);
>         Long result = (Long) q.getSingleResult();
> 
>         Assert.assertEquals("Complex COUNT DISTINCT on base query class ", expectedResult, result);
>+
>+        rollbackTransaction(em);
>+        closeEntityManager(em);
>     }
>     
>     /**
>@@ -470,8 +491,7 @@
>      */
>     public void complexCountOnJoinedVariableSimplePK()
>     {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = 
>-            (org.eclipse.persistence.jpa.JpaEntityManager) createEntityManager();
>+        EntityManager em = createEntityManager();
> 
>         // Need to create the expected result manually, because using the
>         // TopLink query API would run into the same issue 2497.
>@@ -499,8 +519,7 @@
>      */
>     public void complexCountOnJoinedVariableCompositePK()
>     {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = 
>-            (org.eclipse.persistence.jpa.JpaEntityManager) createEntityManager();
>+        EntityManager em = createEntityManager();
> 
>         // Need to create the expected result manually, because using the
>         // TopLink query API would run into the same issue 2497.
>@@ -528,8 +547,7 @@
>      */
>     public void complexCountOnJoinedCompositePK()
>     {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = 
>-            (org.eclipse.persistence.jpa.JpaEntityManager) createEntityManager();
>+        EntityManager em = createEntityManager();
>         try{
>             beginTransaction(em);
>                 Scientist s = new Scientist();
>@@ -569,8 +587,7 @@
>      */
>     public void complexCountOnJoinedVariableOverManyToManySelfRefRelationship()
>     {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = 
>-            (org.eclipse.persistence.jpa.JpaEntityManager) createEntityManager();
>+        EntityManager em = createEntityManager();
> 
>         Long zero = Long.valueOf(0);
>         List expectedResult = Arrays.asList(new Long[] { zero, zero, zero, zero });
>Index: jpa/eclipselink.jpa.test/src/org/eclipse/persistence/testing/tests/jpa/jpql/JUnitJPQLComplexTestSuite.java
>===================================================================
>--- jpa/eclipselink.jpa.test/src/org/eclipse/persistence/testing/tests/jpa/jpql/JUnitJPQLComplexTestSuite.java	(revision 2560)
>+++ jpa/eclipselink.jpa.test/src/org/eclipse/persistence/testing/tests/jpa/jpql/JUnitJPQLComplexTestSuite.java	(working copy)
>@@ -29,6 +29,7 @@
> import junit.framework.TestSuite;
> 
> import javax.persistence.Query;
>+import javax.persistence.EntityManager;
> 
> import org.eclipse.persistence.jpa.JpaEntityManager;
> import org.eclipse.persistence.expressions.Expression;
>@@ -95,6 +96,7 @@
>     {
>         TestSuite suite = new TestSuite();
>         suite.setName("JUnitJPQLComplexTestSuite");
>+        suite.addTest(new JUnitJPQLComplexTestSuite("testSetup"));
>         suite.addTest(new JUnitJPQLComplexTestSuite("complexABSTest"));
>         suite.addTest(new JUnitJPQLComplexTestSuite("complexABSWithParameterTest"));
>         suite.addTest(new JUnitJPQLComplexTestSuite("compexInTest"));
>@@ -135,68 +137,61 @@
>         suite.addTest(new JUnitJPQLComplexTestSuite("complexNavigatingTwoLevelOfEmbeddeds"));
>         suite.addTest(new JUnitJPQLComplexTestSuite("complexNamedQueryResultPropertiesTest"));
>         suite.addTest(new JUnitJPQLComplexTestSuite("complexOuterJoinQuery"));
>-	/* Removed because this functionality requires implementation in ReportQuery
>+        /*Removed because this functionality requires implementation in ReportQuery
>         suite.addTest(new JUnitJPQLComplexTestSuite("complexInheritanceTest"));
>-	
>-
>         suite.addTest(new JUnitJPQLComplexTestSuite("complexInheritanceUsingNamedQueryTest"));
>-    */
>+        */
>         
>-        return new TestSetup(suite) {
>-     
>-            //This method is run at the end of the SUITE only
>-            protected void tearDown() {
>-                
>-                clearCache();
>-            }
>-            
>-            //This method is run at the start of the SUITE only
>-            protected void setUp() {
>-                
>-                //get session to start setup
>-                DatabaseSession session = JUnitTestCase.getServerSession();
>-                
>-                //create a new EmployeePopulator
>-                EmployeePopulator employeePopulator = new EmployeePopulator();
>+        return suite;
>+    }
>+    
>+    /**
>+     * The setup is done as a test, both to record its failure, and to allow execution in the server.
>+     */
>+    public void testSetup() {
>+        clearCache();
>+        //get session to start setup
>+        DatabaseSession session = JUnitTestCase.getServerSession();
>+        
>+        //create a new EmployeePopulator
>+        EmployeePopulator employeePopulator = new EmployeePopulator();
>+        
>+        //create a new PartnerLinkPopulator
>+        PartnerLinkPopulator partnerLinkPopulator = new PartnerLinkPopulator();
>+        new AdvancedTableCreator().replaceTables(session);
>+        
>+        //initialize the global comparer object
>+        comparer = new JUnitDomainObjectComparer();
>+        
>+        //set the session for the comparer to use
>+        comparer.setSession((AbstractSession)session.getActiveSession());              
>+        
>+        //Populate the tables
>+        employeePopulator.buildExamples();
>+        
>+        //Persist the examples in the database
>+        employeePopulator.persistExample(session);       
> 
>-                //create a new PartnerLinkPopulator
>-                PartnerLinkPopulator partnerLinkPopulator = new PartnerLinkPopulator();
>-                
>-                new AdvancedTableCreator().replaceTables(session);
>-                
>-                //initialize the global comparer object
>-                comparer = new JUnitDomainObjectComparer();
>-                
>-                //set the session for the comparer to use
>-                comparer.setSession((AbstractSession)session.getActiveSession());              
>-                
>-                //Populate the tables
>-                employeePopulator.buildExamples();
>-                
>-                //Persist the examples in the database
>-                employeePopulator.persistExample(session);       
>+        //Populate the tables
>+        partnerLinkPopulator.buildExamples();
>+        
>+        //Persist the examples in the database
>+        partnerLinkPopulator.persistExample(session);       
> 
>-                //Populate the tables
>-                partnerLinkPopulator.buildExamples();
>-                
>-                //Persist the examples in the database
>-                partnerLinkPopulator.persistExample(session);       
>-            }            
>-        };    
>-  }
>+    }
>+    
> 
>-
>     public void complexABSTest()
>     {
>-        JpaEntityManager em = (JpaEntityManager) createEntityManager();                  
>-         
>-        Employee emp1 = (Employee)em.getActiveSession().readAllObjects(Employee.class).firstElement();
>-	    Employee emp2 = (Employee)em.getActiveSession().readAllObjects(Employee.class).lastElement();
>+        EntityManager em = createEntityManager();                  
>+        beginTransaction(em);
>+        Employee emp1 = (Employee)getServerSession().readAllObjects(Employee.class).firstElement();
>+        Employee emp2 = (Employee)getServerSession().readAllObjects(Employee.class).lastElement();
>         
>         clearCache();
>-	    String ejbqlString = "SELECT OBJECT(emp) FROM Employee emp WHERE ";
>-	    ejbqlString = ejbqlString + "(ABS(emp.salary) = ";
>-	    ejbqlString = ejbqlString + emp1.getSalary() + ")";
>+        String ejbqlString = "SELECT OBJECT(emp) FROM Employee emp WHERE ";
>+        ejbqlString = ejbqlString + "(ABS(emp.salary) = ";
>+        ejbqlString = ejbqlString + emp1.getSalary() + ")";
>         ejbqlString = ejbqlString + " OR (ABS(emp.salary) = ";
>         ejbqlString = ejbqlString + emp2.getSalary() + ")";
>         
>@@ -207,56 +202,62 @@
>         List result = em.createQuery(ejbqlString).getResultList();
>    
>         Assert.assertTrue("Complex ABS test failed", comparer.compareObjects(result, expectedResult));                 
>-        
>+        rollbackTransaction(em);
>+        closeEntityManager(em);
>     }
> 
>     public void complexABSWithParameterTest()
>     {
>-        JpaEntityManager em = (JpaEntityManager) createEntityManager();
>-
>-        Employee emp = (Employee)em.getActiveSession().readAllObjects(Employee.class).firstElement();
>-        clearCache();
>-        Query q = em.createQuery(
>-            "SELECT emp FROM Employee emp WHERE emp.salary = ABS(:sal)");
>-        q.setParameter("sal", -emp.getSalary());
>-        List<Employee> result = q.getResultList();
>-        boolean found = false;
>-        for (Employee e : result) {
>-            if (e.equals(emp)) {
>-                found = true;
>-                break;
>+        EntityManager em = createEntityManager();
>+        beginTransaction(em);
>+        try {
>+            Employee emp = (Employee)getServerSession().readAllObjects(Employee.class).firstElement();
>+            Employee emp2 = (Employee) em.merge(emp);
>+            clearCache();
>+            Query q = em.createQuery("SELECT emp FROM Employee emp WHERE emp.salary = ABS(:sal)");
>+            q.setParameter("sal", emp.getSalary());
>+            List<Employee> result = q.getResultList();
>+            boolean found = false;
>+            for (Employee e : result) {
>+                if (e.equals(emp2)) {
>+                    found = true;
>+                    break;
>+                }
>             }
>+            Assert.assertTrue("Complex ABS with parameter test failed", found);           
>+        } finally {
>+            rollbackTransaction(em);
>+            closeEntityManager(em);
>         }
>-        Assert.assertTrue("Complex ABS with parameter test failed", found);                 
>     }
>     
>     public void compexInTest()
>     {
>-        JpaEntityManager em = (JpaEntityManager) createEntityManager();                  
>+        EntityManager em = createEntityManager();                  
>          
>-        Employee emp1 = (Employee)em.getActiveSession().readAllObjects(Employee.class).firstElement();
>-	    Employee emp2 = (Employee)em.getActiveSession().readAllObjects(Employee.class).elementAt(1);
>-        Employee emp3 = (Employee)em.getActiveSession().readAllObjects(Employee.class).elementAt(2);
>+        Employee emp1 = (Employee)getServerSession().readAllObjects(Employee.class).firstElement();
>+        Employee emp2 = (Employee)getServerSession().readAllObjects(Employee.class).elementAt(1);
>+        Employee emp3 = (Employee)getServerSession().readAllObjects(Employee.class).elementAt(2);
>         
>-	    Vector expectedResult = new Vector();
>-	    Vector idVector = new Vector();
>-	    idVector.add(emp1.getId());
>-	    idVector.add(emp2.getId());
>-	    idVector.add(emp3.getId());
>-	    
>-	    ReadAllQuery raq = new ReadAllQuery();
>-	    raq.setReferenceClass(Employee.class);
>-	    ExpressionBuilder eb = new ExpressionBuilder();
>-	    Expression whereClause = eb.get("id").in(idVector);
>-	    raq.setSelectionCriteria(whereClause);
>-	    expectedResult = (Vector)em.getActiveSession().executeQuery(raq);
>-	    clearCache();
>-    	String ejbqlString = "SELECT OBJECT(emp) FROM Employee emp WHERE emp.id IN (";
>-	    ejbqlString = ejbqlString + emp1.getId().toString() + ", "; 
>-	    ejbqlString = ejbqlString + emp2.getId().toString() + ", "; 
>-	    ejbqlString = ejbqlString + emp3.getId().toString();
>-	    ejbqlString = ejbqlString + ")";
>+        Vector expectedResult = new Vector();
>+        Vector idVector = new Vector();
>+        idVector.add(emp1.getId());
>+        idVector.add(emp2.getId());
>+        idVector.add(emp3.getId());
>         
>+        ReadAllQuery raq = new ReadAllQuery();
>+        raq.setReferenceClass(Employee.class);
>+        ExpressionBuilder eb = new ExpressionBuilder();
>+        Expression whereClause = eb.get("id").in(idVector);
>+        raq.setSelectionCriteria(whereClause);
>+        expectedResult = (Vector)getServerSession().executeQuery(raq);
>+        clearCache();
>+        String ejbqlString = "SELECT OBJECT(emp) FROM Employee emp WHERE emp.id IN (";
>+        ejbqlString = ejbqlString + emp1.getId().toString() + ", "; 
>+        ejbqlString = ejbqlString + emp2.getId().toString() + ", "; 
>+        ejbqlString = ejbqlString + emp3.getId().toString();
>+        ejbqlString = ejbqlString + ")";
>+        
>         List result = em.createQuery(ejbqlString).getResultList();
>  
>         Assert.assertTrue("Complex IN test failed", comparer.compareObjects(result, expectedResult));                 
>@@ -265,11 +266,11 @@
>     
>     public void complexLengthTest()
>     {
>-        JpaEntityManager em = (JpaEntityManager) createEntityManager();          
>+        EntityManager em = createEntityManager();          
>         
>         Assert.assertFalse("Warning SQL doesnot support LENGTH function",  ((Session) JUnitTestCase.getServerSession()).getPlatform().isSQLServer());
>         
>-        Employee expectedResult = (Employee)em.getActiveSession().readAllObjects(Employee.class).firstElement();
>+        Employee expectedResult = (Employee)getServerSession().readAllObjects(Employee.class).firstElement();
>         clearCache();
>         String ejbqlString = "SELECT OBJECT(emp) FROM Employee emp WHERE ";
>         ejbqlString = ejbqlString + "(LENGTH(emp.firstName) = ";
>@@ -285,9 +286,9 @@
>     
>     public void complexLikeTest()
>     {
>-        JpaEntityManager em = (JpaEntityManager) createEntityManager();          
>+        EntityManager em = createEntityManager();          
>         
>-        Employee emp = (Employee)em.getActiveSession().readAllObjects(Employee.class).firstElement();
>+        Employee emp = (Employee)getServerSession().readAllObjects(Employee.class).firstElement();
>         
>         String firstName = emp.getFirstName();
>         String partialFirstName = emp.getFirstName().substring(0, 1);
>@@ -300,7 +301,7 @@
>         ExpressionBuilder eb = new ExpressionBuilder();
>         Expression whereClause = eb.get("firstName").like(partialFirstName);
>         raq.setSelectionCriteria(whereClause);
>-        Vector expectedResult = (Vector)em.getActiveSession().executeQuery(raq);
>+        Vector expectedResult = (Vector)getServerSession().executeQuery(raq);
>         clearCache();
>         String ejbqlString = "SELECT OBJECT(emp) FROM Employee emp WHERE emp.firstName LIKE \"" + partialFirstName + "\"";
>         
>@@ -312,11 +313,11 @@
>     
>     public void complexNotInTest()
>     {
>-        JpaEntityManager em = (JpaEntityManager) createEntityManager();                  
>+        EntityManager em = createEntityManager();                  
>          
>-        Employee emp1 = (Employee)em.getActiveSession().readAllObjects(Employee.class).firstElement();
>-        Employee emp2 = (Employee)em.getActiveSession().readAllObjects(Employee.class).elementAt(1);
>-        Employee emp3 = (Employee)em.getActiveSession().readAllObjects(Employee.class).elementAt(2);
>+        Employee emp1 = (Employee)getServerSession().readAllObjects(Employee.class).firstElement();
>+        Employee emp2 = (Employee)getServerSession().readAllObjects(Employee.class).elementAt(1);
>+        Employee emp3 = (Employee)getServerSession().readAllObjects(Employee.class).elementAt(2);
>         
>         ExpressionBuilder builder = new ExpressionBuilder();
>         
>@@ -333,8 +334,8 @@
>         
>         Vector expectedResult = (Vector)getServerSession().executeQuery(raq);
>         clearCache();
>-	    
>-    	String ejbqlString = "SELECT OBJECT(emp) FROM Employee emp WHERE emp.id NOT IN (";
>+        
>+        String ejbqlString = "SELECT OBJECT(emp) FROM Employee emp WHERE emp.id NOT IN (";
>         ejbqlString = ejbqlString + emp1.getId().toString() + ", "; 
>         ejbqlString = ejbqlString + emp2.getId().toString() + ", "; 
>         ejbqlString = ejbqlString + emp3.getId().toString();
>@@ -348,27 +349,27 @@
>     
>     public void complexNotLikeTest()
>     {
>-        JpaEntityManager em = (JpaEntityManager) createEntityManager();                  
>+        EntityManager em = createEntityManager();                  
>         
>-        Employee emp = (Employee)em.getActiveSession().readAllObjects(Employee.class).firstElement();
>+        Employee emp = (Employee)getServerSession().readAllObjects(Employee.class).firstElement();
>         
>         String firstName = emp.getFirstName();
>-	    String partialFirstName = emp.getFirstName().substring(0, 1);
>-	    partialFirstName = partialFirstName + "_";
>-	    partialFirstName = partialFirstName + firstName.substring(2, Math.min(4, (firstName.length() - 1)));
>-	    partialFirstName = partialFirstName + "%";
>-	    
>-	    ExpressionBuilder builder = new ExpressionBuilder();
>-	    Expression whereClause = builder.get("firstName").notLike(partialFirstName);
>-	    
>-	    ReadAllQuery raq = new ReadAllQuery();
>-	    raq.setReferenceClass(Employee.class);
>-	    raq.setSelectionCriteria(whereClause);
>-	    
>-	    Vector expectedResult = (Vector)em.getActiveSession().executeQuery(raq);
>-	    clearCache();	    
>-	    String ejbqlString = "SELECT OBJECT(emp) FROM Employee emp WHERE emp.firstName NOT LIKE \"" + partialFirstName + "\"";
>+        String partialFirstName = emp.getFirstName().substring(0, 1);
>+        partialFirstName = partialFirstName + "_";
>+        partialFirstName = partialFirstName + firstName.substring(2, Math.min(4, (firstName.length() - 1)));
>+        partialFirstName = partialFirstName + "%";
>         
>+        ExpressionBuilder builder = new ExpressionBuilder();
>+        Expression whereClause = builder.get("firstName").notLike(partialFirstName);
>+        
>+        ReadAllQuery raq = new ReadAllQuery();
>+        raq.setReferenceClass(Employee.class);
>+        raq.setSelectionCriteria(whereClause);
>+        
>+        Vector expectedResult = (Vector)getServerSession().executeQuery(raq);
>+        clearCache();        
>+        String ejbqlString = "SELECT OBJECT(emp) FROM Employee emp WHERE emp.firstName NOT LIKE \"" + partialFirstName + "\"";
>+        
>         List result = em.createQuery(ejbqlString).getResultList();
>         
>         Assert.assertTrue("Complex Not LIKE test failed", comparer.compareObjects(result, expectedResult));                 
>@@ -377,9 +378,9 @@
>     
>     public void complexParameterTest()
>     {
>-        JpaEntityManager em = (JpaEntityManager) createEntityManager();                  
>+        EntityManager em = createEntityManager();                  
>         
>-        Employee emp = (Employee)em.getActiveSession().readAllObjects(Employee.class).firstElement();
>+        Employee emp = (Employee)getServerSession().readAllObjects(Employee.class).firstElement();
>                 
>         String firstName = "firstName";
>         String lastName = "lastName";
>@@ -394,21 +395,21 @@
>         raq.addArgument(firstName);
>         raq.addArgument(lastName);
>         
>-	    Vector parameters = new Vector();
>-	    parameters.add(emp.getFirstName());
>-	    parameters.add(emp.getLastName());
>-	    
>-	    Vector expectedResult = (Vector)em.getActiveSession().executeQuery(raq, parameters);
>-	    clearCache();
>+        Vector parameters = new Vector();
>+        parameters.add(emp.getFirstName());
>+        parameters.add(emp.getLastName());
>         
>-	    emp = (Employee)expectedResult.firstElement();
>-	    
>-	    // Set up the EJBQL using the retrieved employees
>-	    String ejbqlString = "SELECT OBJECT(emp) FROM Employee emp WHERE ";
>-	    ejbqlString = ejbqlString + "emp.firstName = ?1 ";
>-	    ejbqlString = ejbqlString + " AND ";
>-	    ejbqlString = ejbqlString + "emp.lastName = ?2";
>+        Vector expectedResult = (Vector)getServerSession().executeQuery(raq, parameters);
>+        clearCache();
>         
>+        emp = (Employee)expectedResult.firstElement();
>+        
>+        // Set up the EJBQL using the retrieved employees
>+        String ejbqlString = "SELECT OBJECT(emp) FROM Employee emp WHERE ";
>+        ejbqlString = ejbqlString + "emp.firstName = ?1 ";
>+        ejbqlString = ejbqlString + " AND ";
>+        ejbqlString = ejbqlString + "emp.lastName = ?2";
>+        
>         List result = em.createQuery(ejbqlString).setParameter(1,emp.getFirstName()).setParameter(2,emp.getLastName()).getResultList();
>     
>         Assert.assertTrue("Complex Paramter test failed", comparer.compareObjects(result, expectedResult));                 
>@@ -417,15 +418,15 @@
>     
>     public void complexReverseAbsTest()
>     {
>-       JpaEntityManager em = (JpaEntityManager) createEntityManager();                  
>+       EntityManager em = createEntityManager();                  
>          
>-        Employee emp1 = (Employee)em.getActiveSession().readAllObjects(Employee.class).firstElement();
>-	    Employee emp2 = (Employee)em.getActiveSession().readAllObjects(Employee.class).elementAt(1);
>+        Employee emp1 = (Employee)getServerSession().readAllObjects(Employee.class).firstElement();
>+        Employee emp2 = (Employee)getServerSession().readAllObjects(Employee.class).elementAt(1);
>         clearCache();
>-	    String ejbqlString = "SELECT OBJECT(emp) FROM Employee emp WHERE ";
>-	    ejbqlString = ejbqlString + emp1.getSalary();
>-	    ejbqlString = ejbqlString + " = ABS(emp.salary)";
>-	    ejbqlString = ejbqlString + " OR ";
>+        String ejbqlString = "SELECT OBJECT(emp) FROM Employee emp WHERE ";
>+        ejbqlString = ejbqlString + emp1.getSalary();
>+        ejbqlString = ejbqlString + " = ABS(emp.salary)";
>+        ejbqlString = ejbqlString + " OR ";
>         ejbqlString = ejbqlString + emp2.getSalary();
>         ejbqlString = ejbqlString + " = ABS(emp.salary)";
>           
>@@ -442,17 +443,17 @@
>     public void complexReverseLengthTest()
>     {
>         
>-        JpaEntityManager em = (JpaEntityManager) createEntityManager();          
>+        EntityManager em = createEntityManager();          
>         
>         Assert.assertFalse("Warning SQL doesnot support LENGTH function",  ((Session) JUnitTestCase.getServerSession()).getPlatform().isSQLServer());
>         
>-        Employee expectedResult = (Employee) em.getActiveSession().readAllObjects(Employee.class).firstElement();
>+        Employee expectedResult = (Employee) getServerSession().readAllObjects(Employee.class).firstElement();
>         clearCache();
>         
>         String ejbqlString = "SELECT OBJECT(emp) FROM Employee emp WHERE ";
>-	    ejbqlString = ejbqlString + expectedResult.getFirstName().length();
>+        ejbqlString = ejbqlString + expectedResult.getFirstName().length();
>         ejbqlString = ejbqlString + " = LENGTH(emp.firstName)";
>-	    ejbqlString = ejbqlString + " AND ";
>+        ejbqlString = ejbqlString + " AND ";
>         ejbqlString = ejbqlString + expectedResult.getLastName().length();
>         ejbqlString = ejbqlString + " = LENGTH(emp.lastName)";
>         
>@@ -463,9 +464,9 @@
>     
>     public void complexReverseParameterTest()
>     {
>-        JpaEntityManager em = (JpaEntityManager) createEntityManager();          
>+        EntityManager em = createEntityManager();          
>         
>-        Employee emp = (Employee)em.getActiveSession().readAllObjects(Employee.class).firstElement();
>+        Employee emp = (Employee)getServerSession().readAllObjects(Employee.class).firstElement();
>         
>         String firstName = "firstName";
>         String lastName = "lastName";
>@@ -480,22 +481,22 @@
>         raq.addArgument(firstName);
>         raq.addArgument(lastName);
>         
>-	    Vector parameters = new Vector();
>-	    parameters.add(emp.getFirstName());
>-	    parameters.add(emp.getLastName());
>-	    
>-	    Vector expectedResult = (Vector)getServerSession().executeQuery(raq, parameters);
>-	    
>+        Vector parameters = new Vector();
>+        parameters.add(emp.getFirstName());
>+        parameters.add(emp.getLastName());
>+        
>+        Vector expectedResult = (Vector)getServerSession().executeQuery(raq, parameters);
>+        
>         clearCache();
>         
>-	    emp = (Employee)expectedResult.firstElement();
>-	    
>-	    // Set up the EJBQL using the retrieved employees
>-	    String ejbqlString = "SELECT OBJECT(emp) FROM Employee emp WHERE ";
>-	    ejbqlString = ejbqlString + "?1 = emp.firstName";
>-	    ejbqlString = ejbqlString + " AND ";
>-	    ejbqlString = ejbqlString + "?2 = emp.lastName";
>+        emp = (Employee)expectedResult.firstElement();
>         
>+        // Set up the EJBQL using the retrieved employees
>+        String ejbqlString = "SELECT OBJECT(emp) FROM Employee emp WHERE ";
>+        ejbqlString = ejbqlString + "?1 = emp.firstName";
>+        ejbqlString = ejbqlString + " AND ";
>+        ejbqlString = ejbqlString + "?2 = emp.lastName";
>+        
>         List result = em.createQuery(ejbqlString).setParameter(1,emp.getFirstName()).setParameter(2,emp.getLastName()).getResultList();
> 
>         Assert.assertTrue("Complex Reverse Paramter test failed", comparer.compareObjects(result, expectedResult));                 
>@@ -504,7 +505,7 @@
>     
>     public void complexReverseSqrtTest()
>     {
>-        JpaEntityManager em = (JpaEntityManager) createEntityManager();                  
>+        EntityManager em = createEntityManager();                  
>          
>         ReadAllQuery raq = new ReadAllQuery();
>         ExpressionBuilder expbldr = new ExpressionBuilder();
>@@ -513,22 +514,22 @@
>         raq.setReferenceClass(Employee.class);
>         raq.setSelectionCriteria(whereClause1.or(whereClause2));
>         
>-        Vector expectedResult = (Vector) em.getActiveSession().executeQuery(raq);
>+        Vector expectedResult = (Vector) getServerSession().executeQuery(raq);
>         
>         clearCache();
>         
>         Employee emp1 = (Employee) expectedResult.elementAt(0);
>         Employee emp2 = (Employee) expectedResult.elementAt(1);
>         
>-	    double salarySquareRoot1 = Math.sqrt((new Double(emp1.getSalary()).doubleValue()));
>-	    double salarySquareRoot2 = Math.sqrt((new Double(emp2.getSalary()).doubleValue()));
>+        double salarySquareRoot1 = Math.sqrt((new Double(emp1.getSalary()).doubleValue()));
>+        double salarySquareRoot2 = Math.sqrt((new Double(emp2.getSalary()).doubleValue()));
>         
>-	    String ejbqlString = "SELECT OBJECT(emp) FROM Employee emp WHERE ";
>-	    ejbqlString = ejbqlString + salarySquareRoot1;
>-	    ejbqlString = ejbqlString + " = SQRT(emp.salary)";
>-		ejbqlString = ejbqlString + " OR ";
>-		ejbqlString = ejbqlString + salarySquareRoot2;
>-		ejbqlString = ejbqlString + " = SQRT(emp.salary)";
>+        String ejbqlString = "SELECT OBJECT(emp) FROM Employee emp WHERE ";
>+        ejbqlString = ejbqlString + salarySquareRoot1;
>+        ejbqlString = ejbqlString + " = SQRT(emp.salary)";
>+        ejbqlString = ejbqlString + " OR ";
>+        ejbqlString = ejbqlString + salarySquareRoot2;
>+        ejbqlString = ejbqlString + " = SQRT(emp.salary)";
>         
>         List result = em.createQuery(ejbqlString).getResultList();
> 
>@@ -538,7 +539,7 @@
>     
>     public void complexSqrtTest()
>     {
>-        JpaEntityManager em = (JpaEntityManager) createEntityManager();                  
>+        EntityManager em = createEntityManager();                  
>          
>         ReadAllQuery raq = new ReadAllQuery();
>         ExpressionBuilder expbldr = new ExpressionBuilder();
>@@ -547,7 +548,7 @@
>         raq.setReferenceClass(Employee.class);
>         raq.setSelectionCriteria(whereClause1.or(whereClause2));
>         
>-        Vector expectedResult = (Vector) em.getActiveSession().executeQuery(raq);
>+        Vector expectedResult = (Vector) getServerSession().executeQuery(raq);
>         
>         clearCache();
>         
>@@ -555,14 +556,14 @@
>         Employee emp2 = (Employee) expectedResult.elementAt(1);
>         
>         double salarySquareRoot1 = Math.sqrt((new Double(emp1.getSalary()).doubleValue()));
>-	    double salarySquareRoot2 = Math.sqrt((new Double(emp2.getSalary()).doubleValue()));
>+        double salarySquareRoot2 = Math.sqrt((new Double(emp2.getSalary()).doubleValue()));
> 
>-	    String ejbqlString = "SELECT OBJECT(emp) FROM Employee emp WHERE ";
>-	    ejbqlString = ejbqlString + "(SQRT(emp.salary) = ";
>-	    ejbqlString = ejbqlString + salarySquareRoot1 + ")";
>-		ejbqlString = ejbqlString + " OR ";
>-		ejbqlString = ejbqlString + "(SQRT(emp.salary) = ";
>-		ejbqlString = ejbqlString + salarySquareRoot2 + ")";
>+        String ejbqlString = "SELECT OBJECT(emp) FROM Employee emp WHERE ";
>+        ejbqlString = ejbqlString + "(SQRT(emp.salary) = ";
>+        ejbqlString = ejbqlString + salarySquareRoot1 + ")";
>+        ejbqlString = ejbqlString + " OR ";
>+        ejbqlString = ejbqlString + "(SQRT(emp.salary) = ";
>+        ejbqlString = ejbqlString + salarySquareRoot2 + ")";
>         
>         List result = em.createQuery(ejbqlString).getResultList();
>         
>@@ -571,31 +572,31 @@
>     
>     public void complexStringInTest()
>     {
>-        JpaEntityManager em = (JpaEntityManager) createEntityManager();                  
>+        EntityManager em = createEntityManager();                  
>          
>-        Employee emp1 = (Employee)em.getActiveSession().readAllObjects(Employee.class).firstElement();
>-	    Employee emp2 = (Employee)em.getActiveSession().readAllObjects(Employee.class).elementAt(1);
>-        Employee emp3 = (Employee)em.getActiveSession().readAllObjects(Employee.class).elementAt(2);
>+        Employee emp1 = (Employee)getServerSession().readAllObjects(Employee.class).firstElement();
>+        Employee emp2 = (Employee)getServerSession().readAllObjects(Employee.class).elementAt(1);
>+        Employee emp3 = (Employee)getServerSession().readAllObjects(Employee.class).elementAt(2);
>         
>         Vector fnVector = new Vector();
>-	    fnVector.add(emp1.getFirstName());
>-	    fnVector.add(emp2.getFirstName());
>-	    fnVector.add(emp3.getFirstName());
>-	    
>-	    ReadAllQuery raq = new ReadAllQuery();
>-	    raq.setReferenceClass(Employee.class);
>-	    ExpressionBuilder eb = new ExpressionBuilder();
>-	    Expression whereClause = eb.get("firstName").in(fnVector);
>-	    raq.setSelectionCriteria(whereClause);
>-	    Vector expectedResult = (Vector)getServerSession().executeQuery(raq);
>-	    
>+        fnVector.add(emp1.getFirstName());
>+        fnVector.add(emp2.getFirstName());
>+        fnVector.add(emp3.getFirstName());
>+        
>+        ReadAllQuery raq = new ReadAllQuery();
>+        raq.setReferenceClass(Employee.class);
>+        ExpressionBuilder eb = new ExpressionBuilder();
>+        Expression whereClause = eb.get("firstName").in(fnVector);
>+        raq.setSelectionCriteria(whereClause);
>+        Vector expectedResult = (Vector)getServerSession().executeQuery(raq);
>+        
>         clearCache();
>         
>-    	String ejbqlString = "SELECT OBJECT(emp) FROM Employee emp WHERE emp.firstName IN (";
>-	    ejbqlString = ejbqlString + "\"" + emp1.getFirstName() + "\"" + ", "; 
>-	    ejbqlString = ejbqlString + "\"" + emp2.getFirstName() + "\"" + ", "; 
>-	    ejbqlString = ejbqlString + "\"" + emp3.getFirstName() + "\"" ;
>-	    ejbqlString = ejbqlString + ")";
>+        String ejbqlString = "SELECT OBJECT(emp) FROM Employee emp WHERE emp.firstName IN (";
>+        ejbqlString = ejbqlString + "\"" + emp1.getFirstName() + "\"" + ", "; 
>+        ejbqlString = ejbqlString + "\"" + emp2.getFirstName() + "\"" + ", "; 
>+        ejbqlString = ejbqlString + "\"" + emp3.getFirstName() + "\"" ;
>+        ejbqlString = ejbqlString + ")";
>         
>         List result = em.createQuery(ejbqlString).getResultList();
> 
>@@ -605,35 +606,35 @@
>     
>     public void complexStringNotInTest()
>     {
>-        JpaEntityManager em = (JpaEntityManager) createEntityManager();                  
>+        EntityManager em = createEntityManager();                  
>          
>-        Employee emp1 = (Employee)em.getActiveSession().readAllObjects(Employee.class).firstElement();
>-	    Employee emp2 = (Employee)em.getActiveSession().readAllObjects(Employee.class).elementAt(1);
>-        Employee emp3 = (Employee)em.getActiveSession().readAllObjects(Employee.class).elementAt(2);
>+        Employee emp1 = (Employee)getServerSession().readAllObjects(Employee.class).firstElement();
>+        Employee emp2 = (Employee)getServerSession().readAllObjects(Employee.class).elementAt(1);
>+        Employee emp3 = (Employee)getServerSession().readAllObjects(Employee.class).elementAt(2);
>         
>-	    
>-	    ExpressionBuilder builder = new ExpressionBuilder();
>-	    
>+        
>+        ExpressionBuilder builder = new ExpressionBuilder();
>+        
>         Vector nameVector = new Vector();
>-	    nameVector.add(emp1.getFirstName());   
>-	    nameVector.add(emp2.getFirstName());        
>-	    nameVector.add(emp3.getFirstName());        
>-	    
>-	    
>-	    Expression whereClause = builder.get("firstName").notIn(nameVector);
>-	    ReadAllQuery raq = new ReadAllQuery();
>-	    raq.setReferenceClass(Employee.class);
>-	    raq.setSelectionCriteria(whereClause);
>-	    
>-	    Vector expectedResult = (Vector)em.getActiveSession().executeQuery(raq);
>+        nameVector.add(emp1.getFirstName());   
>+        nameVector.add(emp2.getFirstName());        
>+        nameVector.add(emp3.getFirstName());        
>         
>+        
>+        Expression whereClause = builder.get("firstName").notIn(nameVector);
>+        ReadAllQuery raq = new ReadAllQuery();
>+        raq.setReferenceClass(Employee.class);
>+        raq.setSelectionCriteria(whereClause);
>+        
>+        Vector expectedResult = (Vector)getServerSession().executeQuery(raq);
>+        
>         clearCache();
>         
>-    	String ejbqlString = "SELECT OBJECT(emp) FROM Employee emp WHERE emp.firstName NOT IN (";
>-	    ejbqlString = ejbqlString + "\"" + emp1.getFirstName() + "\"" + ", "; 
>-	    ejbqlString = ejbqlString + "\"" + emp2.getFirstName() + "\"" + ", "; 
>-	    ejbqlString = ejbqlString + "\"" + emp3.getFirstName() + "\"" ;
>-	    ejbqlString = ejbqlString + ")";
>+        String ejbqlString = "SELECT OBJECT(emp) FROM Employee emp WHERE emp.firstName NOT IN (";
>+        ejbqlString = ejbqlString + "\"" + emp1.getFirstName() + "\"" + ", "; 
>+        ejbqlString = ejbqlString + "\"" + emp2.getFirstName() + "\"" + ", "; 
>+        ejbqlString = ejbqlString + "\"" + emp3.getFirstName() + "\"" ;
>+        ejbqlString = ejbqlString + ")";
>         
>          List result = em.createQuery(ejbqlString).getResultList();
> 
>@@ -643,20 +644,20 @@
>     
>     public void complexSubstringTest()
>     {
>-        JpaEntityManager em = (JpaEntityManager) createEntityManager();                  
>+        EntityManager em = createEntityManager();                  
>          
>-        Employee expectedResult = (Employee)em.getActiveSession().readAllObjects(Employee.class).firstElement();
>+        Employee expectedResult = (Employee)getServerSession().readAllObjects(Employee.class).firstElement();
>         
>         String firstNamePart, lastNamePart;
>-	    String ejbqlString;
>+        String ejbqlString;
> 
>-	    firstNamePart = expectedResult.getFirstName().substring(0, 2);
>+        firstNamePart = expectedResult.getFirstName().substring(0, 2);
>         
>-	    lastNamePart = expectedResult.getLastName().substring(0, 1);
>+        lastNamePart = expectedResult.getLastName().substring(0, 1);
>         
>-	    ejbqlString = "SELECT OBJECT(emp) FROM Employee emp WHERE ";
>-	    ejbqlString = ejbqlString + "(SUBSTRING(emp.firstName, 1, 2) = ";//changed from 0, 2 to 1, 2(ZYP)
>-	    ejbqlString = ejbqlString + "\"" + firstNamePart + "\")";
>+        ejbqlString = "SELECT OBJECT(emp) FROM Employee emp WHERE ";
>+        ejbqlString = ejbqlString + "(SUBSTRING(emp.firstName, 1, 2) = ";//changed from 0, 2 to 1, 2(ZYP)
>+        ejbqlString = ejbqlString + "\"" + firstNamePart + "\")";
>         ejbqlString = ejbqlString + " AND ";
>         ejbqlString = ejbqlString + "(SUBSTRING(emp.lastName, 1, 1) = ";//changed from 0, 1 to 1, 1(ZYP)
>         ejbqlString = ejbqlString + "\"" + lastNamePart + "\")";
>@@ -668,7 +669,8 @@
>     
>     public void complexLocateTest()
>     {
>-        JpaEntityManager em = (JpaEntityManager) createEntityManager();
>+        EntityManager em = createEntityManager();
>+        beginTransaction(em);
>         String jpql = "SELECT e FROM Employee e WHERE e.firstName = 'Emanual' AND e.lastName = 'Smith'";
>         Employee expectedResult = (Employee)em.createQuery(jpql).getSingleResult();
> 
>@@ -679,30 +681,32 @@
>         jpql = "SELECT e FROM Employee e WHERE LOCATE('a', e.firstName, 4) = 6 AND e.lastName = 'Smith'";
>         result = (Employee)em.createQuery(jpql).getSingleResult();
>         Assert.assertTrue("Complex LOCATE(String, String) test failed", result.equals(expectedResult));
>+        rollbackTransaction(em);
>+        closeEntityManager(em);
>     }
>     
>     public void complexNestedOneToManyUsingInClause()
>     {
>-        JpaEntityManager em = (JpaEntityManager) createEntityManager();                  
>+        EntityManager em = createEntityManager();                  
>          
>-        Employee emp = (Employee)em.getActiveSession().readAllObjects(Employee.class).firstElement();
>+        Employee emp = (Employee)getServerSession().readAllObjects(Employee.class).firstElement();
>         
>         ExpressionBuilder builder = new ExpressionBuilder();
>-    	Expression whereClause = builder.anyOf("managedEmployees").anyOf("projects").
>-    	    get("name").equal("Enterprise");
>-    	ReadAllQuery readQuery = new ReadAllQuery();
>-    	readQuery.dontMaintainCache();
>-    	readQuery.setReferenceClass(Employee.class);
>+        Expression whereClause = builder.anyOf("managedEmployees").anyOf("projects").
>+            get("name").equal("Enterprise");
>+        ReadAllQuery readQuery = new ReadAllQuery();
>+        readQuery.dontMaintainCache();
>+        readQuery.setReferenceClass(Employee.class);
>         readQuery.setSelectionCriteria(whereClause);
> 
>-    	Vector expectedResult = (Vector)em.getActiveSession().executeQuery(readQuery);
>-    	
>+        Vector expectedResult = (Vector)getServerSession().executeQuery(readQuery);
>+        
>         clearCache();
>         
>-    	String ejbqlString;
>-    	ejbqlString = "SELECT OBJECT(emp) FROM Employee emp, " +
>-    	    "IN(emp.managedEmployees) mEmployees, IN(mEmployees.projects) projects " +
>-    	    "WHERE projects.name = 'Enterprise'";
>+        String ejbqlString;
>+        ejbqlString = "SELECT OBJECT(emp) FROM Employee emp, " +
>+            "IN(emp.managedEmployees) mEmployees, IN(mEmployees.projects) projects " +
>+            "WHERE projects.name = 'Enterprise'";
>         
>         List result = em.createQuery(ejbqlString).getResultList();
>  
>@@ -712,22 +716,22 @@
> 
>     public void complexUnusedVariableTest()
>     {
>-        JpaEntityManager em = (JpaEntityManager) createEntityManager();                  
>+        EntityManager em = createEntityManager();                  
>          
>-        Employee emp = (Employee)em.getActiveSession().readAllObjects(Employee.class).firstElement();
>+        Employee emp = (Employee)getServerSession().readAllObjects(Employee.class).firstElement();
>         ReportQuery reportQuery = new ReportQuery();
>-    	reportQuery.dontMaintainCache();
>+        reportQuery.dontMaintainCache();
>         reportQuery.setShouldReturnWithoutReportQueryResult(true);
>-    	reportQuery.setReferenceClass(Employee.class);
>+        reportQuery.setReferenceClass(Employee.class);
>         ExpressionBuilder builder = reportQuery.getExpressionBuilder();
>         reportQuery.addNonFetchJoinedAttribute(builder.get("address"));
>         reportQuery.addItem("emp", builder);
>-    	Vector expectedResult = (Vector)em.getActiveSession().executeQuery(reportQuery);
>-    	
>+        Vector expectedResult = (Vector)getServerSession().executeQuery(reportQuery);
>+        
>         clearCache();
>         
>-    	String ejbqlString;
>-    	ejbqlString = "SELECT emp FROM Employee emp JOIN emp.address a";
>+        String ejbqlString;
>+        ejbqlString = "SELECT emp FROM Employee emp JOIN emp.address a";
>         List result = em.createQuery(ejbqlString).getResultList();
>  
>         Assert.assertTrue("Complex Unused Variable test failed", comparer.compareObjects(result, expectedResult));              
>@@ -736,8 +740,8 @@
> 
>     public void complexJoinTest()
>     {
>-        JpaEntityManager em = (JpaEntityManager) createEntityManager();
>-        Collection emps = em.getActiveSession().readAllObjects(Employee.class);
>+        EntityManager em = createEntityManager();
>+        Collection emps = getServerSession().readAllObjects(Employee.class);
>         Employee empWithManager = null;
>         Employee empWithOutManager = null;
>         // find an employee w/ and w/o manager
>@@ -786,7 +790,7 @@
>      */
>     public void complexMultipleJoinOfSameRelationship()
>     {
>-        JpaEntityManager em = (JpaEntityManager) createEntityManager();
>+        EntityManager em = createEntityManager();
>         String jpql = "SELECT p1, p2 FROM Employee emp JOIN emp.phoneNumbers p1 JOIN emp.phoneNumbers p2 " +
>                       "WHERE p1.type = 'Pager' AND p2.areaCode = '613'";
>         Query query = em.createQuery(jpql);
>@@ -800,7 +804,7 @@
>      */
>     public void complexMultipleLeftOuterJoinOfSameRelationship()
>     {
>-        JpaEntityManager em = (JpaEntityManager) createEntityManager();
>+        EntityManager em = createEntityManager();
>         String jpql = "SELECT p1, p2 FROM Employee emp LEFT JOIN emp.phoneNumbers p1 LEFT JOIN emp.phoneNumbers p2 " +
>                       "WHERE p1.type = 'Pager' AND p2.areaCode = '613'";
>         Query query = em.createQuery(jpql);
>@@ -811,23 +815,23 @@
> 
>     public void complexFetchJoinTest()
>     {
>-        JpaEntityManager em = (JpaEntityManager) createEntityManager();                  
>+        EntityManager em = createEntityManager();                  
>          
>-        Employee emp = (Employee)em.getServerSession().readAllObjects(Employee.class).firstElement();
>+        Employee emp = (Employee)getServerSession().readAllObjects(Employee.class).firstElement();
>         ReportQuery reportQuery = new ReportQuery();
>-    	reportQuery.dontMaintainCache();
>+        reportQuery.dontMaintainCache();
>         reportQuery.setShouldReturnWithoutReportQueryResult(true);
>-    	reportQuery.setReferenceClass(Employee.class);
>+        reportQuery.setReferenceClass(Employee.class);
>         ExpressionBuilder builder = reportQuery.getExpressionBuilder();
>         List joins = new ArrayList(1);
>         joins.add(builder.get("address"));
>         reportQuery.addItem("emp", builder, joins);    
>-    	Vector expectedResult = (Vector)em.getServerSession().executeQuery(reportQuery);
>-    	
>+        Vector expectedResult = (Vector)getServerSession().executeQuery(reportQuery);
>+        
>         clearCache();
>         
>-    	String ejbqlString;
>-    	ejbqlString = "SELECT emp FROM Employee emp JOIN FETCH emp.address";
>+        String ejbqlString;
>+        ejbqlString = "SELECT emp FROM Employee emp JOIN FETCH emp.address";
>         List result = em.createQuery(ejbqlString).getResultList();
>  
>         Assert.assertTrue("Complex Fetch Join test failed", comparer.compareObjects(result, expectedResult));              
>@@ -839,9 +843,9 @@
>      */    
>     public void complexOneToOneFetchJoinTest()
>     {
>-        JpaEntityManager em = (JpaEntityManager) createEntityManager();                  
>+        EntityManager em = createEntityManager();                  
>         
>-        List<Man> allMen = em.getServerSession().readAllObjects(Man.class);
>+        List<Man> allMen = getServerSession().readAllObjects(Man.class);
>         List<Integer> allMenIds = new ArrayList(allMen.size());
>         for (Man man : allMen) {
>             allMenIds.add((man != null) ? man.getId() : null);
>@@ -849,7 +853,7 @@
>         Collections.sort(allMenIds);
>         clearCache();
>         
>-    	String ejbqlString = "SELECT m FROM Man m LEFT JOIN FETCH m.partnerLink";
>+        String ejbqlString = "SELECT m FROM Man m LEFT JOIN FETCH m.partnerLink";
>         List<Man> result = em.createQuery(ejbqlString).getResultList();
>         List<Integer> ids = new ArrayList(result.size());
>         for (Man man : result) {
>@@ -864,9 +868,13 @@
> 
>     public void complexSelectRelationshipTest()
>     {
>-        JpaEntityManager em = (JpaEntityManager) createEntityManager(); 
>-        
>-        Collection emps = em.getActiveSession().readAllObjects(Employee.class);
>+        if (isOnServer()) {
>+            // Cannot create parallel entity managers in the server.
>+            return;
>+        }
>+        EntityManager em = createEntityManager(); 
>+        beginTransaction(em);
>+        Collection emps = getServerSession().readAllObjects(Employee.class);
>         Employee empWithManager = null;
>         Employee empWithOutManager = null;
>         // find an employee w/ and w/o manager
>@@ -888,7 +896,7 @@
>         }
> 
>         // constructor query including relationship field
>-    	String ejbqlString = "SELECT emp.manager FROM Employee emp WHERE emp.id = :id";
>+        String ejbqlString = "SELECT emp.manager FROM Employee emp WHERE emp.id = :id";
>         Query query = em.createQuery(ejbqlString);
> 
>         // execute query using employee with manager
>@@ -902,45 +910,61 @@
>         result = (Employee)query.getSingleResult();
>         Assert.assertNull("Select Relationship Test Case Failed (employee without manager)",
>                           result);
>+        rollbackTransaction(em);
>+        closeEntityManager(em);
>     }
> 
>     public void complexConstructorTest()
>     {
>-        JpaEntityManager em = (JpaEntityManager) createEntityManager(); 
>-        
>-        Employee emp = (Employee)em.getActiveSession().readAllObjects(Employee.class).firstElement();
>+        EntityManager em = createEntityManager(); 
>+        beginTransaction(em);
>+        Employee emp = (Employee)getServerSession().readAllObjects(Employee.class).firstElement();
> 
>         // simple constructor query
>-    	String ejbqlString = "SELECT NEW org.eclipse.persistence.testing.tests.jpa.jpql.JUnitJPQLComplexTestSuite.EmployeeDetail(emp.firstName, emp.lastName) FROM Employee emp WHERE emp.id = :id";
>+        String ejbqlString = "SELECT NEW org.eclipse.persistence.testing.tests.jpa.jpql.JUnitJPQLComplexTestSuite.EmployeeDetail(emp.firstName, emp.lastName) FROM Employee emp WHERE emp.id = :id";
>         Query query = em.createQuery(ejbqlString);
>         query.setParameter("id", emp.getId());
>         EmployeeDetail result = (EmployeeDetail)query.getSingleResult();
>         EmployeeDetail expectedResult = new EmployeeDetail(emp.getFirstName(), emp.getLastName());
> 
>         Assert.assertTrue("Constructor Test Case Failed", result.equals(expectedResult));
>+        rollbackTransaction(em);
>+        closeEntityManager(em);
>+
>     }
> 
>     public void complexConstructorVariableTest()
>     {
>-        JpaEntityManager em = (JpaEntityManager) createEntityManager(); 
>-        
>-        Employee emp = (Employee)em.getActiveSession().readAllObjects(Employee.class).firstElement();
>-
>-        // constructor query using a variable as argument
>-    	String jpqlString = "SELECT NEW org.eclipse.persistence.testing.tests.jpa.jpql.JUnitJPQLComplexTestSuite.EmployeeDetail(emp) FROM Employee emp WHERE emp.id = :id";
>-        Query query = em.createQuery(jpqlString);
>-        query.setParameter("id", emp.getId());
>-        EmployeeDetail result = (EmployeeDetail)query.getSingleResult();
>-        EmployeeDetail expectedResult = new EmployeeDetail(emp);
>-
>-        Assert.assertTrue("Constructor with variable argument Test Case Failed", result.equals(expectedResult));
>+        if (isOnServer()) {
>+            // Not work on the server.
>+            return;
>+        }
>+        EntityManager em = createEntityManager();
>+        beginTransaction(em);
>+        try {
>+            Employee emp = (Employee)getServerSession().readAllObjects(Employee.class).firstElement();
>+            // constructor query using a variable as argument
>+            String jpqlString = "SELECT NEW org.eclipse.persistence.testing.tests.jpa.jpql.JUnitJPQLComplexTestSuite.EmployeeDetail(emp) FROM Employee emp WHERE emp.id = :id";
>+            Query query = em.createQuery(jpqlString);
>+            query.setParameter("id", emp.getId());
>+            EmployeeDetail result = (EmployeeDetail)query.getSingleResult();
>+            EmployeeDetail expectedResult = new EmployeeDetail(emp);
>+            Assert.assertTrue("Constructor with variable argument Test Case Failed", result.equals(expectedResult));
>+        } finally {
>+            rollbackTransaction(em);
>+            closeEntityManager(em);
>+        }
>     }
> 
>     public void complexConstructorRelationshipTest()
>     {
>-        JpaEntityManager em = (JpaEntityManager) createEntityManager(); 
>-        
>-        Collection emps = em.getActiveSession().readAllObjects(Employee.class);
>+        if (isOnServer()) {
>+            // Cannot create parallel entity managers in the server.
>+            return;
>+        }
>+        EntityManager em = createEntityManager(); 
>+        beginTransaction(em);
>+        Collection emps = getServerSession().readAllObjects(Employee.class);
>         Employee empWithManager = null;
>         Employee empWithOutManager = null;
>         // find an employee w/ and w/o manager
>@@ -962,7 +986,7 @@
>         }
> 
>         // constructor query including relationship field
>-    	String ejbqlString = "SELECT NEW org.eclipse.persistence.testing.tests.jpa.jpql.JUnitJPQLComplexTestSuite.EmployeeDetail(emp.firstName, emp.lastName, emp.manager) FROM Employee emp WHERE emp.id = :id";
>+        String ejbqlString = "SELECT NEW org.eclipse.persistence.testing.tests.jpa.jpql.JUnitJPQLComplexTestSuite.EmployeeDetail(emp.firstName, emp.lastName, emp.manager) FROM Employee emp WHERE emp.id = :id";
>         Query query = em.createQuery(ejbqlString);
> 
>         // execute query using employee with manager
>@@ -971,8 +995,7 @@
>         EmployeeDetail expectedResult = new EmployeeDetail(
>             empWithManager.getFirstName(), empWithManager.getLastName(), 
>             empWithManager.getManager());
>-        Assert.assertTrue("Constructor Relationship Test Case Failed (employee with manager)", 
>-                          result.equals(expectedResult));
>+        Assert.assertTrue("Constructor Relationship Test Case Failed (employee with manager)", comparer.compareObjects(result, expectedResult));
> 
>         // execute query using employee with manager
>         query.setParameter("id", empWithOutManager.getId());
>@@ -980,15 +1003,16 @@
>         expectedResult = new EmployeeDetail(
>             empWithOutManager.getFirstName(), empWithOutManager.getLastName(), 
>             empWithOutManager.getManager());
>-        Assert.assertTrue("Constructor Relationship Test Case Failed (employee without manager)", 
>-                          result.equals(expectedResult));
>+        Assert.assertTrue("Constructor Relationship Test Case Failed (employee without manager)", comparer.compareObjects(result, expectedResult));
>+        rollbackTransaction(em);
>+        closeEntityManager(em);
>     }
> 
>     public void complexConstructorAggregatesTest()
>     {
>-        JpaEntityManager em = (JpaEntityManager) createEntityManager(); 
>+        EntityManager em = createEntityManager(); 
> 
>-        Collection emps = em.getActiveSession().readAllObjects(Employee.class);
>+        Collection emps = getServerSession().readAllObjects(Employee.class);
>         Employee emp = null;
>         // find an employee with managed employees
>         for (Iterator i = emps.iterator(); i.hasNext();) {
>@@ -1024,10 +1048,10 @@
> 
>     public void complexConstructorCountOnJoinedVariableTest()
>     {
>-        JpaEntityManager em = (JpaEntityManager) createEntityManager();
>+        EntityManager em = createEntityManager();
> 
>         // find all employees with managed employees
>-        Collection emps = em.getActiveSession().readAllObjects(Employee.class);
>+        Collection emps = getServerSession().readAllObjects(Employee.class);
>         List<EmployeeDetail> expectedResult = new ArrayList<EmployeeDetail>();
>         for (Iterator i = emps.iterator(); i.hasNext();) {
>             Employee e = (Employee)i.next();
>@@ -1050,8 +1074,8 @@
>     
>     public void complexResultPropertiesTest() 
>     {
>-        JpaEntityManager em = (JpaEntityManager) createEntityManager();
>-
>+        EntityManager em = createEntityManager();
>+        beginTransaction(em);
>         String ejbql = "SELECT e FROM Employee e ORDER BY e.id";
>         Query query = em.createQuery(ejbql);
>         List allEmps = query.getResultList();
>@@ -1083,14 +1107,15 @@
>         result = query.getResultList();
>         expectedResult = allEmps.subList(firstResult, nrOfEmps - 1);
>         Assert.assertTrue("Query.setFirstResult and Query.setMaxResults Test Case Failed", result.equals(expectedResult));
>-        
>+        rollbackTransaction(em);
>+        closeEntityManager(em);
>     }
> 
>     public void complexNamedQueryResultPropertiesTest() 
>     {
>         //This new added test case is for glassFish bug 2689 
>-        JpaEntityManager em = (JpaEntityManager) createEntityManager();
>-        
>+        EntityManager em = createEntityManager();
>+        beginTransaction(em);
>         Query query = em.createNamedQuery("findAllEmployeesOrderById");
>         List allEmps = query.getResultList();
>         int nrOfEmps = allEmps.size();
>@@ -1139,11 +1164,14 @@
>         List result4 = query4.getResultList();
>         List expectedResult4 = allEmps.subList(0, nrOfEmps-3);
>         Assert.assertTrue("Query4 set MaxResult only Test Case Failed", result4.equals(expectedResult4));
>+        rollbackTransaction(em);
>+        closeEntityManager(em);
>+
>     }
> 
>     public void complexInSubqueryTest() 
>     {
>-        JpaEntityManager em = (JpaEntityManager) createEntityManager();
>+        EntityManager em = createEntityManager();
> 
>         ReportQuery reportQuery = new ReportQuery();
>         reportQuery.dontMaintainCache();
>@@ -1152,7 +1180,7 @@
>         ExpressionBuilder builder = reportQuery.getExpressionBuilder();
>         reportQuery.setSelectionCriteria(builder.get("address").get("city").equal("Ottawa"));
>         reportQuery.addItem("id", builder.get("id"));    
>-        Vector expectedResult = (Vector)em.getServerSession().executeQuery(reportQuery);
>+        Vector expectedResult = (Vector)getServerSession().executeQuery(reportQuery);
>      
>         String ejbqlString = "SELECT e.id FROM Employee e WHERE e.address.city IN (SELECT a.city FROM e.address a WHERE a.city = 'Ottawa')";
>         List result = em.createQuery(ejbqlString).getResultList();
>@@ -1161,9 +1189,9 @@
>     
>     public void complexExistsTest() 
>     {
>-        JpaEntityManager em = (JpaEntityManager) createEntityManager();
>+        EntityManager em = createEntityManager();
>         
>-        Collection allEmps = em.getActiveSession().readAllObjects(Employee.class);
>+        Collection allEmps = getServerSession().readAllObjects(Employee.class);
>         List expectedResult = new ArrayList();
>         // find an employees with projects
>         for (Iterator i = allEmps.iterator(); i.hasNext();) {
>@@ -1183,9 +1211,9 @@
>     
>     public void complexNotExistsTest() 
>     {
>-        JpaEntityManager em = (JpaEntityManager) createEntityManager();
>+        EntityManager em = createEntityManager();
>         
>-        Collection allEmps = em.getActiveSession().readAllObjects(Employee.class);
>+        Collection allEmps = getServerSession().readAllObjects(Employee.class);
>         List expectedResult = new ArrayList();
>         // find an employees with projects
>         for (Iterator i = allEmps.iterator(); i.hasNext();) {
>@@ -1205,9 +1233,9 @@
> 
>     public void complexMemberOfTest() 
>     {
>-        JpaEntityManager em = (JpaEntityManager) createEntityManager();
>+        EntityManager em = createEntityManager();
>         
>-        Collection allEmps = em.getActiveSession().readAllObjects(Employee.class);
>+        Collection allEmps = getServerSession().readAllObjects(Employee.class);
> 
>         // MEMBER OF using self-referencing relationship
>         // return employees who are incorrectly entered as reporting to themselves
>@@ -1235,9 +1263,9 @@
>     
>     public void complexNotMemberOfTest() 
>     {
>-        JpaEntityManager em = (JpaEntityManager) createEntityManager();
>+        EntityManager em = createEntityManager();
>         
>-        Collection allEmps = em.getActiveSession().readAllObjects(Employee.class);
>+        Collection allEmps = getServerSession().readAllObjects(Employee.class);
>         List expectedResult = new ArrayList();
>         String ejbqlString = "SELECT e FROM Employee e WHERE e NOT MEMBER OF e.managedEmployees";
>         List result = em.createQuery(ejbqlString).getResultList();
>@@ -1247,25 +1275,25 @@
>     public void complexInheritanceTest()
>     {
>     
>-        JpaEntityManager em = (JpaEntityManager) createEntityManager();                  
>+        EntityManager em = createEntityManager();                  
>         
>-        ((AbstractSession) em.getActiveSession()).addAlias("ProjectBaseClass", getServerSession().getDescriptor(Project.class));
>+        ((AbstractSession) getServerSession()).addAlias("ProjectBaseClass", getServerSession().getDescriptor(Project.class));
>         
>-        Project expectedResult = (Project)em.getActiveSession().readAllObjects(Project.class).firstElement();
>+        Project expectedResult = (Project)getServerSession().readAllObjects(Project.class).firstElement();
>         String projectName = expectedResult.getName();
>-	    ReadObjectQuery roq = new ReadObjectQuery();
>-	    ExpressionBuilder eb = new ExpressionBuilder();
>-	    Expression whereClause = eb.get("name").equal(projectName);
>-	    roq.setSelectionCriteria(whereClause);
>-	    roq.setReferenceClass(LargeProject.class);
>-	    LargeProject proj = (LargeProject)em.getActiveSession().executeQuery(roq);
>+        ReadObjectQuery roq = new ReadObjectQuery();
>+        ExpressionBuilder eb = new ExpressionBuilder();
>+        Expression whereClause = eb.get("name").equal(projectName);
>+        roq.setSelectionCriteria(whereClause);
>+        roq.setReferenceClass(LargeProject.class);
>+        LargeProject proj = (LargeProject)getServerSession().executeQuery(roq);
> 
>         //Set criteria for EJBQL and call super-class method to construct the EJBQL query
>-	    String ejbqlString = "SELECT OBJECT(project) FROM ProjectBaseClass project WHERE project.name = \"" + projectName +"\"";
>+        String ejbqlString = "SELECT OBJECT(project) FROM ProjectBaseClass project WHERE project.name = \"" + projectName +"\"";
>         
>         List result = em.createQuery(ejbqlString).getResultList();
>         
>-        ((AbstractSession)em.getActiveSession()).getAliasDescriptors().remove("ProjectBaseClass");
>+        ((AbstractSession)getServerSession()).getAliasDescriptors().remove("ProjectBaseClass");
>  
>         Assert.assertTrue("Complex Inheritance test failed", comparer.compareObjects(result, expectedResult));                  
> 
>@@ -1273,27 +1301,27 @@
>     
>     public void complexInheritanceUsingNamedQueryTest()
>     {
>-        JpaEntityManager em = (JpaEntityManager) createEntityManager();                  
>+        EntityManager em = createEntityManager();                  
>         
>-        Project expectedResult = (Project)em.getActiveSession().readAllObjects(Project.class).firstElement();
>-	    
>+        Project expectedResult = (Project)getServerSession().readAllObjects(Project.class).firstElement();
>+        
>         String argument = expectedResult.getName();
>-	    
>-	    //set up query, using query framework, to return a Project object which will be compared
>-	    //against the Project object which is returned by the EJBQL query
>-	    ReadObjectQuery roq = new ReadObjectQuery();
>-	    roq.setReferenceClass(LargeProject.class);
>-	    ExpressionBuilder eb = new ExpressionBuilder();
>-	    Expression whereClause = eb.get("name").equal(argument);
>-	    roq.setSelectionCriteria(whereClause);
>-	    Project proj = (Project)getServerSession().executeQuery(roq);
>         
>+        //set up query, using query framework, to return a Project object which will be compared
>+        //against the Project object which is returned by the EJBQL query
>+        ReadObjectQuery roq = new ReadObjectQuery();
>+        roq.setReferenceClass(LargeProject.class);
>+        ExpressionBuilder eb = new ExpressionBuilder();
>+        Expression whereClause = eb.get("name").equal(argument);
>+        roq.setSelectionCriteria(whereClause);
>+        Project proj = (Project)getServerSession().executeQuery(roq);
>+        
>         String queryName = "findLargeProjectByNameEJBQL";
>         
>-        Session uow = em.getActiveSession();
>+        Session uow = getServerSession();
>         
>-        if (!(em.getActiveSession().containsQuery(queryName))) {
>-            ((AbstractSession)em.getActiveSession()).addAlias("ProjectBaseClass", getServerSession().getDescriptor(Project.class));
>+        if (!(getServerSession().containsQuery(queryName))) {
>+            ((AbstractSession)getServerSession()).addAlias("ProjectBaseClass", getServerSession().getDescriptor(Project.class));
> 
>             //Named query must be built and registered with the session
>             ReadObjectQuery query = new ReadObjectQuery();
>@@ -1306,8 +1334,8 @@
>         
>         Project result = (Project)uow.executeQuery("findLargeProjectByNameEJBQL",argument);
>         
>-        em.getActiveSession().removeQuery("findLargeProjectByBudgetEJBQL");
>-        ((AbstractSession)em.getActiveSession()).getAliasDescriptors().remove("ProjectBaseClass");
>+        getServerSession().removeQuery("findLargeProjectByBudgetEJBQL");
>+        ((AbstractSession)getServerSession()).getAliasDescriptors().remove("ProjectBaseClass");
>   
>         Assert.assertTrue("Complex Inheritance using named query test failed", comparer.compareObjects(result, expectedResult));                  
>         
>@@ -1315,8 +1343,8 @@
> 
>     public void complexNavigatingEmbedded ()
>     {
>-        JpaEntityManager em = (JpaEntityManager) createEntityManager();
>-    	String jpqlString = "SELECT e.formerEmployment.formerCompany FROM Employee e WHERE e.formerEmployment.formerCompany = 'Former company'";
>+        EntityManager em = createEntityManager();
>+        String jpqlString = "SELECT e.formerEmployment.formerCompany FROM Employee e WHERE e.formerEmployment.formerCompany = 'Former company'";
>         Query query = em.createQuery(jpqlString);
>         List result = query.getResultList();
> 
>@@ -1327,8 +1355,8 @@
> 
>     public void complexNavigatingTwoLevelOfEmbeddeds ()
>     {
>-        JpaEntityManager em = (JpaEntityManager) createEntityManager();
>-    	String jpqlString = "SELECT emp.formerEmployment.period.startDate FROM Employee emp";
>+        EntityManager em = createEntityManager();
>+        String jpqlString = "SELECT emp.formerEmployment.period.startDate FROM Employee emp";
>         Query query = em.createQuery(jpqlString);
>         List result = query.getResultList();
> 
>@@ -1344,7 +1372,7 @@
>      */
>     public void complexOuterJoinQuery()
>     {
>-        JpaEntityManager em = (JpaEntityManager) createEntityManager();
>+        EntityManager em = createEntityManager();
> 
>         // JPQL query using one INNER JOIN and three OUTER JOINs
> 
>Index: jpa/eclipselink.jpa.test/src/org/eclipse/persistence/testing/tests/jpa/jpql/JUnitJPQLDateTimeTestSuite.java
>===================================================================
>--- jpa/eclipselink.jpa.test/src/org/eclipse/persistence/testing/tests/jpa/jpql/JUnitJPQLDateTimeTestSuite.java	(revision 2560)
>+++ jpa/eclipselink.jpa.test/src/org/eclipse/persistence/testing/tests/jpa/jpql/JUnitJPQLDateTimeTestSuite.java	(working copy)
>@@ -33,21 +33,25 @@
>         super();
>     }
> 
>+    public JUnitJPQLDateTimeTestSuite(String name) {
>+        super(name);
>+    }
>+
>     public static Test suite() {
>         TestSuite suite = new TestSuite(JUnitJPQLDateTimeTestSuite.class);
>+        suite.addTest(new JUnitJPQLDateTimeTestSuite("testSetup"));
> 
>-        return new TestSetup(suite) {
>-            protected void setUp(){
>-                new DateTimeTableCreator().replaceTables(JUnitTestCase.getServerSession());
>-                
>+        return suite;
>+    }
>+    
>+    /**
>+     * The setup is done as a test, both to record its failure, and to allow execution in the server.
>+     */
>+    public void testSetup() {
>+        new DateTimeTableCreator().replaceTables(JUnitTestCase.getServerSession());
>                 DateTimePopulator dateTimePopulator = new DateTimePopulator();                
>                 dateTimePopulator.persistExample(getServerSession());   
>-            }
>-
>-            protected void tearDown() {
>-                clearCache();
>-            }
>-        };
>+        clearCache();
>     }
>     
>     public void testSqlDate() {
>Index: jpa/eclipselink.jpa.test/src/org/eclipse/persistence/testing/tests/jpa/jpql/JUnitJPQLExamplesTestSuite.java
>===================================================================
>--- jpa/eclipselink.jpa.test/src/org/eclipse/persistence/testing/tests/jpa/jpql/JUnitJPQLExamplesTestSuite.java	(revision 2560)
>+++ jpa/eclipselink.jpa.test/src/org/eclipse/persistence/testing/tests/jpa/jpql/JUnitJPQLExamplesTestSuite.java	(working copy)
>@@ -19,6 +19,8 @@
> import java.util.List;
> import java.util.Vector;
> 
>+import javax.persistence.EntityManager;
>+
> import junit.framework.Assert;
> 
> import org.eclipse.persistence.jpa.JpaEntityManager;
>@@ -75,6 +77,7 @@
>     public static Test suite() {
>         TestSuite suite = new TestSuite();
>         suite.setName("JUnitJPQLExamplesTestSuite");
>+        suite.addTest(new JUnitJPQLExamplesTestSuite("testSetup"));
>         suite.addTest(new JUnitJPQLExamplesTestSuite("findAllOrders"));
>         suite.addTest(new JUnitJPQLExamplesTestSuite("findEmployeesInOntario"));
>         suite.addTest(new JUnitJPQLExamplesTestSuite("findAllProvinceWithEmployees"));
>@@ -112,52 +115,45 @@
>         // Bug 5090182
>         suite.addTest(new JUnitJPQLExamplesTestSuite("testEJBQLQueryString"));
>         suite.addTest(new JUnitJPQLExamplesTestSuite("updateEmbeddedFieldTest"));
>+        
>+        return suite;
>+    }
>+    
>+    /**
>+     * The setup is done as a test, both to record its failure, and to allow execution in the server.
>+     */
>+    public void testSetup() {
>+        clearCache();
>+        //get session to start setup
>+        DatabaseSession session = JUnitTestCase.getServerSession();
>+        
>+        //create a new EmployeePopulator
>+        EmployeePopulator employeePopulator = new EmployeePopulator();
>+        
>+        RelationshipsExamples relationshipExamples = new RelationshipsExamples();
> 
>-        return new TestSetup(suite) {
>+        new AdvancedTableCreator().replaceTables(session);
> 
>-                //This method is run at the end of the SUITE only
>+        new RelationshipsTableManager().replaceTables(session);
> 
>-                protected void tearDown() {
>-                    clearCache();
>-                }
>+        //initialize the global comparer object
>+        comparer = new JUnitDomainObjectComparer();
> 
>-                //This method is run at the start of the SUITE only
>+        //set the session for the comparer to use
>+        comparer.setSession((AbstractSession)session.getActiveSession());
> 
>-                protected void setUp() {
>+        //Populate the advanced model
>+        employeePopulator.buildExamples();
>+        //populate the relationships model and persist as well
>+        relationshipExamples.buildExamples(session);
> 
>-                    //get session to start setup
>-                    DatabaseSession session = JUnitTestCase.getServerSession();
>-
>-                    //create a new EmployeePopulator
>-                    employeePopulator = new EmployeePopulator();
>-
>-                    RelationshipsExamples relationshipExamples = new RelationshipsExamples();
>-
>-                    new AdvancedTableCreator().replaceTables(session);
>-
>-                    new RelationshipsTableManager().replaceTables(session);
>-
>-                    //initialize the global comparer object
>-                    comparer = new JUnitDomainObjectComparer();
>-
>-                    //set the session for the comparer to use
>-                    comparer.setSession((AbstractSession)session.getActiveSession());
>-
>-
>-                    //Populate the advanced model
>-                    employeePopulator.buildExamples();
>-                    //populate the relationships model and persist as well
>-                    relationshipExamples.buildExamples(session);
>-
>-                    //Persist the advanced model examples in the database
>-                    employeePopulator.persistExample(session);
>-                }
>-            };
>+        //Persist the advanced model examples in the database
>+        employeePopulator.persistExample(session);
>     }
> 
>     public void findAllOrders() {
>-        JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>-        List expectedResult = em.getActiveSession().readAllObjects(Order.class);
>+        EntityManager em = createEntityManager();
>+        List expectedResult = getServerSession().readAllObjects(Order.class);
> 
>         String ejbqlString = "SELECT o FROM OrderBean o";
>         List result = em.createQuery(ejbqlString).getResultList();
>@@ -167,11 +163,11 @@
>     }
> 
>     public void findEmployeesInOntario() {
>-        JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
>         ExpressionBuilder builder = new ExpressionBuilder();
>         Expression whereClause = builder.get("address").get("province").equal("ONT");
> 
>-        List expectedResult = em.getActiveSession().readAllObjects(Employee.class, whereClause);
>+        List expectedResult = getServerSession().readAllObjects(Employee.class, whereClause);
> 
>         String ejbqlString = "SELECT e FROM Employee e WHERE e.address.province='ONT'";
>         List result = em.createQuery(ejbqlString).getResultList();
>@@ -183,7 +179,7 @@
> 
>     public void findAllProvinceWithEmployees() {
>         boolean testPass = false;
>-        JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
>         ExpressionBuilder builder = new ExpressionBuilder();
>         Expression whereClause = builder.get("address").get("province");
> 
>@@ -193,7 +189,7 @@
>         rq.addItem("province", whereClause);
>         rq.useDistinct();
> 
>-        List expectedResult = (List)em.getActiveSession().executeQuery(rq);
>+        List expectedResult = (List)getServerSession().executeQuery(rq);
> 
>         String ejbqlString = "SELECT DISTINCT e.address.province FROM Employee e";
>         List result = em.createQuery(ejbqlString).getResultList();
>@@ -206,7 +202,7 @@
>     }
> 
>     public void findAllEmployeesWithPhoneNumbers() {
>-        JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
>         ExpressionBuilder builder = new ExpressionBuilder();
>         Expression whereClause = builder.isEmpty("phoneNumbers").not();
> 
>@@ -214,7 +210,7 @@
>         raq.setSelectionCriteria(whereClause);
>         raq.useDistinct();
> 
>-        List expectedResult = (List)em.getActiveSession().executeQuery(raq);
>+        List expectedResult = (List)getServerSession().executeQuery(raq);
> 
>         String ejbqlString = "SELECT DISTINCT e FROM Employee e, IN (e.phoneNumbers) l";
>         List firstResult = em.createQuery(ejbqlString).getResultList();
>@@ -228,7 +224,7 @@
>     }
> 
>     public void findAllEmployeesWithOutPhoneNumbers() {
>-        JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
>         ExpressionBuilder builder = new ExpressionBuilder();
>         Expression whereClause = builder.isEmpty("phoneNumbers");
> 
>@@ -236,7 +232,7 @@
>         raq.setSelectionCriteria(whereClause);
>         raq.useDistinct();
> 
>-        List expectedResult = (List)em.getActiveSession().executeQuery(raq);
>+        List expectedResult = (List)getServerSession().executeQuery(raq);
> 
>         String ejbqlString = "SELECT DISTINCT e FROM Employee e WHERE e.phoneNumbers IS EMPTY";
>         List result = em.createQuery(ejbqlString).getResultList();
>@@ -246,7 +242,7 @@
>     }
> 
>     public void findAllEmployeesWithCellPhones() {
>-        JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
>         ExpressionBuilder builder = new ExpressionBuilder();
>         Expression whereClause = builder.anyOf("phoneNumbers").get("type").equal("Cellular");
> 
>@@ -254,7 +250,7 @@
>         raq.setSelectionCriteria(whereClause);
>         raq.useDistinct();
> 
>-        List expectedResult = (List)em.getActiveSession().executeQuery(raq);
>+        List expectedResult = (List)getServerSession().executeQuery(raq);
> 
>         String ejbqlString = "SELECT DISTINCT e FROM Employee e JOIN e.phoneNumbers p " + "WHERE p.type = 'Cellular'";
>         List firstResult = em.createQuery(ejbqlString).getResultList();
>@@ -267,14 +263,14 @@
>     }
> 
>     public void findOrdersWithDifferentBilledCustomer() {
>-        JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
>         ExpressionBuilder builder = new ExpressionBuilder();
>         Expression whereClause = builder.get("customer").equal(builder.get("billedCustomer")).not();
> 
>         ReadAllQuery raq = new ReadAllQuery(Order.class);
>         raq.setSelectionCriteria(whereClause);
> 
>-        List expectedResult = (List)em.getActiveSession().executeQuery(raq);
>+        List expectedResult = (List)getServerSession().executeQuery(raq);
> 
>         String ejbqlString = "SELECT o FROM OrderBean o WHERE o.customer <> o.billedCustomer";
>         List firstResult = em.createQuery(ejbqlString).getResultList();
>@@ -287,7 +283,7 @@
>     }
> 
>     public void findEmployeeWithWorkPhone2258812() {
>-        JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
>         ExpressionBuilder builder = new ExpressionBuilder();
>         Expression whereClause1 = builder.anyOf("phoneNumbers").get("type").equal("Work");
>         Expression whereClause2 = builder.anyOf("phoneNumbers").get("number").equal("2258812");
>@@ -296,7 +292,7 @@
>         raq.setSelectionCriteria(whereClause1.and(whereClause2));
>         raq.useDistinct();
> 
>-        List expectedResult = (List)em.getActiveSession().executeQuery(raq);
>+        List expectedResult = (List)getServerSession().executeQuery(raq);
> 
>         String ejbqlString = "SELECT DISTINCT e FROM Employee e JOIN e.phoneNumbers p " + "WHERE p.type = 'Work' AND p.number = '2258812' ";
>         List result = em.createQuery(ejbqlString).getResultList();
>@@ -306,8 +302,8 @@
>     }
> 
>     public void parameterTest() {
>-        JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>-        List employeeList = em.getActiveSession().readAllObjects(Employee.class);
>+        EntityManager em = createEntityManager();
>+        List employeeList = getServerSession().readAllObjects(Employee.class);
>         Employee expectedEmployee = (Employee)employeeList.get(0);
>         int i = 1;
>         while (expectedEmployee.getPhoneNumbers().size() == 0) {
>@@ -327,7 +323,7 @@
> 
> 
>     public void getOrderLargerThan() {
>-        JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
> 
>         ExpressionBuilder builder1 = new ExpressionBuilder(Order.class);
>         ExpressionBuilder builder2 = new ExpressionBuilder(Order.class);
>@@ -342,7 +338,7 @@
>         raq.setSelectionCriteria(whereClause);
>         raq.setReferenceClass(Order.class);
>         raq.useDistinct();
>-        List expectedResult = (List)em.getActiveSession().executeQuery(raq);
>+        List expectedResult = (List)getServerSession().executeQuery(raq);
> 
>         String ejbqlString = "SELECT DISTINCT o1 FROM OrderBean o1, OrderBean o2 WHERE o1.quantity > o2.quantity AND" + " o2.customer.name = 'Jane Smith' ";
>         List result = em.createQuery(ejbqlString).getResultList();
>@@ -352,14 +348,14 @@
>     }
> 
>     public void getOrderForCustomer() {
>-        JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
>         ExpressionBuilder builder = new ExpressionBuilder();
>         Expression whereClause = builder.get("name").equal("Jane Smith");
> 
>         ReadAllQuery raq = new ReadAllQuery(Customer.class);
>         raq.setSelectionCriteria(whereClause);
> 
>-        Customer expectedCustomer = (Customer)(((List)em.getActiveSession().executeQuery(raq)).get(0));
>+        Customer expectedCustomer = (Customer)(((List)getServerSession().executeQuery(raq)).get(0));
>         SalesPerson salesPerson = ((Order)(expectedCustomer.getOrders().iterator().next())).getSalesPerson();
> 
>         String ejbqlString = "SELECT DISTINCT c FROM Customer c JOIN c.orders o JOIN o.salesPerson s WHERE s.id = " + salesPerson.getId();
>@@ -374,9 +370,9 @@
>     }
> 
>     public void getSalesPersonForOrders() {
>-        JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
> 
>-        List expectedResult = em.getActiveSession().readAllObjects(SalesPerson.class);
>+        List expectedResult = getServerSession().readAllObjects(SalesPerson.class);
> 
>         String ejbqlString = "SELECT DISTINCT o.salesPerson FROM Customer AS c, IN(c.orders) o";
>         List result = em.createQuery(ejbqlString).getResultList();
>@@ -386,12 +382,12 @@
>     }
> 
>     public void testOuterJoin() {
>-        JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
>         ExpressionBuilder builder = new ExpressionBuilder();
>         Expression whereClause = builder.anyOfAllowingNone("phoneNumbers").get("type").equal("Cellular");
>         ReadAllQuery raq = new ReadAllQuery(Employee.class);
>         raq.setSelectionCriteria(whereClause);
>-        List expectedResult = (List)em.getActiveSession().executeQuery(raq);
>+        List expectedResult = (List)getServerSession().executeQuery(raq);
> 
>         String ejbqlString = "SELECT e FROM Employee e LEFT JOIN e.phoneNumbers p " + "WHERE p.type = 'Cellular'";
>         List firstResult = em.createQuery(ejbqlString).getResultList();
>@@ -404,7 +400,7 @@
>     }
> 
>     public void testExistsExpression() {
>-        JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
>         boolean testPass = false;
>         ExpressionBuilder employeeBuilder = new ExpressionBuilder(Employee.class);
>         ExpressionBuilder managerBuilder = new ExpressionBuilder(Employee.class);
>@@ -421,7 +417,7 @@
>         mainQuery.setSelectionCriteria(employeeExpression);
>         mainQuery.addAttribute("id");
>         mainQuery.returnWithoutReportQueryResult();
>-        List expectedResult = (List)em.getActiveSession().executeQuery(mainQuery);
>+        List expectedResult = (List)getServerSession().executeQuery(mainQuery);
> 
>         String ejbqlString = "SELECT DISTINCT emp.id FROM Employee emp WHERE EXISTS ( SELECT managedEmp.id FROM Employee managedEmp WHERE managedEmp = emp.manager)";
>         List result = em.createQuery(ejbqlString).getResultList();
>@@ -434,7 +430,7 @@
>     }
> 
>     public void testAllExpressions() {
>-        JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
>         boolean testPass = false;
>         ExpressionBuilder mainQueryBuilder = new ExpressionBuilder(Employee.class);
>         ExpressionBuilder subQueryBuilder = new ExpressionBuilder(Employee.class);
>@@ -450,7 +446,7 @@
>         mainQuery.addAttribute("id");
>         mainQuery.setSelectionCriteria(mainQueryExpression);
>         mainQuery.returnWithoutReportQueryResult();
>-        List expectedResult = (List)em.getActiveSession().executeQuery(mainQuery);
>+        List expectedResult = (List)getServerSession().executeQuery(mainQuery);
> 
>         String ejbqlString = "SELECT emp.id FROM Employee emp WHERE emp.salary > ALL ( SELECT e.salary FROM Employee e WHERE e.address.city = emp.address.city AND e.salary < 1000)";
>         List result = em.createQuery(ejbqlString).getResultList();
>@@ -463,7 +459,7 @@
>     }
> 
>     public void testCountInSubQuery() {
>-        JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
>         boolean testPass = false;
>         ReportQuery mainQuery = new ReportQuery(Customer.class, new ExpressionBuilder());
>         ReportQuery subQuery = new ReportQuery(Order.class, new ExpressionBuilder());
>@@ -472,7 +468,7 @@
>         mainQuery.setSelectionCriteria(mainQuery.getExpressionBuilder().subQuery(subQuery).greaterThan(0));
>         mainQuery.addAttribute("customerId");
>         mainQuery.returnWithoutReportQueryResult();
>-        List expectedResult = (List)em.getActiveSession().executeQuery(mainQuery);
>+        List expectedResult = (List)getServerSession().executeQuery(mainQuery);
>         String ejbqlString = "SELECT c.customerId FROM Customer c WHERE (SELECT COUNT(o) FROM c.orders o) > 0";
>         List result = em.createQuery(ejbqlString).getResultList();
>         if (result.containsAll(expectedResult) && expectedResult.containsAll(result))
>@@ -483,7 +479,7 @@
>     }
> 
>     public void testGroupByHavingExpression() {
>-        JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
>         boolean testPass = true;
> 
>         ReadAllQuery raq = new ReadAllQuery(Employee.class, new ExpressionBuilder());
>@@ -493,7 +489,7 @@
>         Expression whereClause4 = raq.getExpressionBuilder().get("lastName").equal("Way");
> 
>         raq.setSelectionCriteria((whereClause1.and(whereClause2)).or(whereClause3.and(whereClause4)));
>-        List employees = (List)em.getActiveSession().executeQuery(raq);
>+        List employees = (List)getServerSession().executeQuery(raq);
>         int firstManagerId = ((Employee)employees.get(0)).getId();
>         int secondManagerId = ((Employee)employees.get(1)).getId();
>         int expectedEmployeesManaged = ((Employee)employees.get(0)).getManagedEmployees().size() + ((Employee)employees.get(1)).getManagedEmployees().size();
>@@ -509,7 +505,7 @@
>         query.addCount("id", Long.class);
> 
> 
>-        List expectedResult = (List)em.getActiveSession().executeQuery(query);
>+        List expectedResult = (List)getServerSession().executeQuery(query);
> 
>         String ejbqlString = "SELECT e.manager.id, avg(e.salary), count(e) FROM Employee e" + " GROUP BY e.manager.id HAVING e.manager.id IN (" + firstManagerId + "," + secondManagerId + ")";
> 
>@@ -536,7 +532,7 @@
>     }
> 
>     public void testGroupByHavingCount() {
>-        JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
>         boolean testPass = true;
>         ReportQuery query = new ReportQuery(Employee.class, new ExpressionBuilder());
>         query.returnWithoutReportQueryResult();
>@@ -544,7 +540,7 @@
>         query.addAttribute("province", query.getExpressionBuilder().get("address").get("province"));
>         query.addCount("provinces", query.getExpressionBuilder().get("address").get("province"), Long.class);
>         query.setHavingExpression(query.getExpressionBuilder().get("address").get("province").count().greaterThan(3));
>-        List expectedResult = (List)em.getActiveSession().executeQuery(query);
>+        List expectedResult = (List)getServerSession().executeQuery(query);
> 
>         String ejbqlString = "SELECT e.address.province, COUNT(e) FROM Employee e GROUP BY e.address.province HAVING COUNT(e.address.province) > 3";
>         List result = em.createQuery(ejbqlString).getResultList();
>@@ -566,7 +562,7 @@
>     }
> 
>     public void testConstructorQuery() {
>-        JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
>         String ejbqlString = "SELECT NEW org.eclipse.persistence.testing.models.jpa.relationships.CustomerDetails(c.customerId, o.quantity) FROM Customer " + "c JOIN c.orders o WHERE o.quantity > 100";
> 
>         List custDetails = em.createQuery(ejbqlString).getResultList();
>@@ -575,26 +571,26 @@
>     }
> 
>     public void testSumExpression() {
>-        JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
> 
>         ReportQuery query = new ReportQuery(Employee.class, new ExpressionBuilder());
>         Expression whereClause = query.getExpressionBuilder().get("address").get("province").equal("QUE");
>         query.addSum("areaCodeSums", query.getExpressionBuilder().anyOf("phoneNumbers").get("id"), Long.class);
>         query.setSelectionCriteria(whereClause);
>         query.returnWithoutReportQueryResult();
>-        Long expectedResult = (Long)((List)em.getActiveSession().executeQuery(query)).get(0);
>+        Long expectedResult = (Long)((List)getServerSession().executeQuery(query)).get(0);
>         String ejbqlString = "SELECT SUM(p.id) FROM Employee e JOIN e.phoneNumbers p JOIN e.address a" + " WHERE a.province = 'QUE' ";
>         Long result = (Long)em.createQuery(ejbqlString).getSingleResult();
>         Assert.assertEquals("Average expression test failed", expectedResult, result);
>     }
> 
>     public void testAvgExpression() {
>-        JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
> 
>         ReportQuery query = new ReportQuery(Order.class, new ExpressionBuilder());
>         query.addAverage("average quantity", query.getExpressionBuilder().get("quantity"), Double.class);
>         query.returnSingleResult();
>-        Double expectedResult = (Double)((ReportQueryResult)em.getActiveSession().executeQuery(query)).get("average quantity");
>+        Double expectedResult = (Double)((ReportQueryResult)getServerSession().executeQuery(query)).get("average quantity");
>         String ejbqlString = "SELECT AVG(o.quantity) FROM OrderBean o";
>         Double result = (Double)em.createQuery(ejbqlString).getSingleResult();
>         Assert.assertEquals("Average expression test failed", expectedResult, result);
>@@ -603,7 +599,7 @@
>     //bug 5166658
> 
>     public void testCountExpression() {
>-        JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
> 
>         ReportQuery query = new ReportQuery(Employee.class, new ExpressionBuilder());
>         Expression whereClause1 = query.getExpressionBuilder().get("address").get("province").equal("QUE");
>@@ -611,7 +607,7 @@
>         query.setSelectionCriteria(whereClause1.and(whereClause2));
>         query.addCount("areaCodeCount", query.getExpressionBuilder().anyOf("phoneNumbers").get("areaCode"), Long.class);
>         query.returnSingleResult();
>-        Long expectedResult = (Long)((ReportQueryResult)em.getActiveSession().executeQuery(query)).get("areaCodeCount");
>+        Long expectedResult = (Long)((ReportQueryResult)getServerSession().executeQuery(query)).get("areaCodeCount");
> 
>         String ejbqlString = "SELECT COUNT(p.areaCode) FROM Employee e JOIN e.phoneNumbers p JOIN e.address a " + " WHERE a.province='QUE' AND a.city='Montreal'";
>         Long result = (Long)em.createQuery(ejbqlString).getSingleResult();
>@@ -627,14 +623,14 @@
>     }
> 
>     public void testOrderByExpression() {
>-        JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
> 
>         ReadAllQuery raq = new ReadAllQuery(PhoneNumber.class, new ExpressionBuilder());
>         Expression whereClause = raq.getExpressionBuilder().get("owner").get("address").get("province").equal("ONT");
>         raq.setSelectionCriteria(whereClause);
>         raq.addOrdering(raq.getExpressionBuilder().get("areaCode"));
>         raq.addOrdering(raq.getExpressionBuilder().get("type"));
>-        List expectedResult = (List)em.getActiveSession().executeQuery(raq);
>+        List expectedResult = (List)getServerSession().executeQuery(raq);
> 
>         String ejbqlString = "SELECT p FROM Employee e JOIN e.phoneNumbers p JOIN e.address a WHERE a.province = 'ONT' " + "ORDER BY p.areaCode, p.type";
>         List result = em.createQuery(ejbqlString).getResultList();
>@@ -643,7 +639,7 @@
>     }
> 
>     public void testOrderByExpressionWithSelect() {
>-        JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
>         boolean testPass = true;
>         ReportQuery query = new ReportQuery(PhoneNumber.class, new ExpressionBuilder());
>         Expression whereClause = query.getExpressionBuilder().get("owner").get("address").get("province").equal("ONT");
>@@ -654,7 +650,7 @@
>         query.addAttribute("type", query.getExpressionBuilder().get("type"));
>         //query.useDistinct(); //removed as distinct no longer used on joins in JPQL
>         query.returnWithoutReportQueryResult();
>-        List expectedResult = (List)em.getActiveSession().executeQuery(query);
>+        List expectedResult = (List)getServerSession().executeQuery(query);
> 
>         String ejbqlString = "SELECT p.areaCode, p.type FROM Employee e JOIN e.phoneNumbers p JOIN e.address a WHERE a.province = 'ONT' " + "ORDER BY p.areaCode, p.type";
>         List result = em.createQuery(ejbqlString).getResultList();
>@@ -676,7 +672,7 @@
>     }
> 
>     public void testDeleteExpression() {
>-        JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
>         try {
>             beginTransaction(em);
>             String orderString = "DELETE FROM OrderBean o WHERE o.customer.name ='Karen McDonald' ";
>@@ -691,7 +687,7 @@
>             ReadAllQuery raq = new ReadAllQuery(Customer.class, new ExpressionBuilder());
>             Expression whereClause = raq.getExpressionBuilder().get("name").equal("Karen McDonald");
>             raq.setSelectionCriteria(whereClause);
>-            List customerFound = (List)em.getActiveSession().executeQuery(raq);
>+            List customerFound = (List)getServerSession().executeQuery(raq);
>             Assert.assertEquals("Delete Expression test failed", 0, customerFound.size());
>         } finally {
>             rollbackTransaction(em);
>@@ -706,7 +702,7 @@
>     }
> 
>     public void testComplexDeleteExpression() {
>-        JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
>         try {
>             beginTransaction(em);
>             String orderString = "DELETE FROM OrderBean o WHERE o.customer.name ='Karen McDonald' ";
>@@ -722,7 +718,7 @@
>             Expression whereClause1 = raq.getExpressionBuilder().get("name").equal("Karen McDonald");
>             Expression whereClause2 = raq.getExpressionBuilder().isEmpty("orders");
>             raq.setSelectionCriteria(whereClause1.and(whereClause2));
>-            List customerFound = (List)em.getActiveSession().executeQuery(raq);
>+            List customerFound = (List)getServerSession().executeQuery(raq);
>             Assert.assertEquals("Complex Delete Expression test failed", 0, customerFound.size());
>         } finally {
>             rollbackTransaction(em);
>@@ -732,7 +728,7 @@
>     //bug 5159164, 5159198   
> 
>     public void testUpdateExpression() {
>-        JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
>         int result = 0;
>         UpdateAllQuery uaq = new UpdateAllQuery(Customer.class, new ExpressionBuilder());
>         uaq.addUpdate(uaq.getExpressionBuilder().get("name"), "Test Case");
>@@ -744,7 +740,7 @@
>         Expression whereClause2 = uaq.getExpressionBuilder().subQuery(innerQuery).greaterThan(0);
>         uaq.setSelectionCriteria(whereClause1.and(whereClause2));
>         beginTransaction(em);
>-        List expectedResult = (List)em.getActiveSession().executeQuery(uaq);
>+        List expectedResult = (List)getServerSession().executeQuery(uaq);
>         commitTransaction(em);
> 
>         String ejbqlString = "UPDATE Customer c SET c.name = 'Test Case' WHERE c.name = 'Jane Smith' " + "AND 0 < (SELECT COUNT(o) FROM Customer cust JOIN cust.orders o)";
>@@ -757,7 +753,7 @@
>     //Bug5097278 Test case for updating the manager of ALL employees that have a certain address 
> 
>     public void updateAllTest() {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
> 
>         String empName = "Saunders";
>         String manName = "Smitty";
>@@ -785,7 +781,7 @@
> 
>     public void updateEmbeddedFieldTest() {
> 
>-        JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
>         Calendar startCalendar = Calendar.getInstance();
>         startCalendar.set(1905, 11, 31, 0, 0, 0);
>         java.sql.Date startDate = new java.sql.Date(startCalendar.getTime().getTime());
>@@ -799,7 +795,7 @@
>     //Bug5040609  Test if EJBQuery makes a clone of the original DatabaseQuery from the session
> 
>     public void namedQueryCloneTest() {
>-        JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
> 
>         List result1 = em.createNamedQuery("findAllCustomers").getResultList();
> 
>@@ -815,7 +811,7 @@
>     //Bug5040609 Test case for aggregates as parameters in EJBQL
> 
>     public void aggregateParameterTest() {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
> 
>         ExpressionBuilder builder = new ExpressionBuilder();
>         ReportQuery query = new ReportQuery(org.eclipse.persistence.testing.models.jpa.advanced.Employee.class, builder);
>@@ -836,7 +832,7 @@
>         Vector args = new Vector();
>         args.add(period);
> 
>-        List expectedResult = (Vector)em.getActiveSession().executeQuery(query, args);
>+        List expectedResult = (Vector)getServerSession().executeQuery(query, args);
> 
>         List result = em.createQuery("SELECT e FROM Employee e WHERE e.period = :period ").setParameter("period", period).getResultList();
> 
>Index: jpa/eclipselink.jpa.test/src/org/eclipse/persistence/testing/tests/jpa/jpql/JUnitJPQLInheritanceTestSuite.java
>===================================================================
>--- jpa/eclipselink.jpa.test/src/org/eclipse/persistence/testing/tests/jpa/jpql/JUnitJPQLInheritanceTestSuite.java	(revision 2560)
>+++ jpa/eclipselink.jpa.test/src/org/eclipse/persistence/testing/tests/jpa/jpql/JUnitJPQLInheritanceTestSuite.java	(working copy)
>@@ -17,6 +17,8 @@
> import junit.framework.TestSuite;
> import junit.extensions.TestSetup;
> 
>+import javax.persistence.EntityManager;
>+
> import org.eclipse.persistence.internal.sessions.AbstractSession;
> import org.eclipse.persistence.queries.ReadObjectQuery;
> import org.eclipse.persistence.sessions.DatabaseSession;
>@@ -64,6 +66,7 @@
>     public static Test suite() {
>         TestSuite suite = new TestSuite();
>         suite.setName("JUnitJPQLInheritanceTestSuite");
>+        suite.addTest(new JUnitJPQLInheritanceTestSuite("testSetup"));
>         suite.addTest(new JUnitJPQLInheritanceTestSuite("testStraightReadSuperClass"));
>         suite.addTest(new JUnitJPQLInheritanceTestSuite("testStraightReadSubClass"));
>         suite.addTest(new JUnitJPQLInheritanceTestSuite("testJoinSuperClass"));
>@@ -75,72 +78,70 @@
>         suite.addTest(new JUnitJPQLInheritanceTestSuite("testJoinedInheritanceWithLeftOuterJoin2"));
>         suite.addTest(new JUnitJPQLInheritanceTestSuite("testJoinedInheritanceWithLeftOuterJoin3"));
>         
>-        return new TestSetup(suite) {
>-     
>-            //This method is run at the end of the SUITE only
>-            protected void tearDown() {
>-                clearCache();
>-            }
>-            
>-            //This method is run at the start of the SUITE only
>-            protected void setUp() {
>-                //get session to start setup
>-                DatabaseSession session = JUnitTestCase.getServerSession();
>-                
>-                //create a new EmployeePopulator
>-                EmployeePopulator employeePopulator = new EmployeePopulator();
>-                
>-                //initialize the global comparer object
>-                comparer = new JUnitDomainObjectComparer();
>+        return suite;
>+    }
>+    
>+    /**
>+     * The setup is done as a test, both to record its failure, and to allow execution in the server.
>+     */
>+    public void testSetup() {
>+        clearCache();
>+        //get session to start setup
>+        DatabaseSession session = JUnitTestCase.getServerSession();
>+        
>+        //create a new EmployeePopulator
>+        EmployeePopulator employeePopulator = new EmployeePopulator();
>+        
>+        //initialize the global comparer object
>+        comparer = new JUnitDomainObjectComparer();
> 
>-                //set the session for the comparer to use
>-                comparer.setSession((AbstractSession)session.getActiveSession());   
>-                
>-                new AdvancedTableCreator().replaceTables(session);
>-                new InheritanceTableCreator().replaceTables(session);
>-                
>-                //Populate the tables
>-                employeePopulator.buildExamples();
>-                
>-                //Persist the examples in the database
>-                employeePopulator.persistExample(session);
>-                
>-                //Populate the tables
>-                InheritancePopulator inheritancePopulator = new InheritancePopulator();
>-                inheritancePopulator.buildExamples();
>-                
>-                //Persist the examples in the database
>-                inheritancePopulator.persistExample(session);       
>-            }            
>-        };    
>+        //set the session for the comparer to use
>+        comparer.setSession((AbstractSession)session.getActiveSession());   
>+        
>+        new AdvancedTableCreator().replaceTables(session);
>+        new InheritanceTableCreator().replaceTables(session);
>+        
>+        //Populate the tables
>+        employeePopulator.buildExamples();
>+        
>+        //Persist the examples in the database
>+        employeePopulator.persistExample(session);
>+        
>+        //Populate the tables
>+        InheritancePopulator inheritancePopulator = new InheritancePopulator();
>+        inheritancePopulator.buildExamples();
>+        
>+        //Persist the examples in the database
>+        inheritancePopulator.persistExample(session);
>+
>     }
> 
>     public void testStraightReadSuperClass() {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager) createEntityManager();                  
>+        EntityManager em = createEntityManager();                  
>          
>         Project project = (Project)em.createQuery("SELECT p from Project p").getResultList().get(0);
>         clearCache();
>         ReadObjectQuery tlQuery = new ReadObjectQuery(Project.class);
>         tlQuery.setSelectionCriteria(tlQuery.getExpressionBuilder().get("id").equal(project.getId()));
>         
>-        Project tlProject = (Project)em.getActiveSession().executeQuery(tlQuery);
>+        Project tlProject = (Project)getServerSession().executeQuery(tlQuery);
>         Assert.assertTrue("SuperClass Inheritance Test Failed", comparer.compareObjects(project, tlProject));                    
>     }
>     
>     public void testStraightReadSubClass() {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager) createEntityManager();                  
>+        EntityManager em = createEntityManager();                  
>          
>         SmallProject project = (SmallProject)em.createQuery("SELECT s from SmallProject s").getResultList().get(0);
>         clearCache();
>         ReadObjectQuery tlQuery = new ReadObjectQuery(SmallProject.class);
>         tlQuery.setSelectionCriteria(tlQuery.getExpressionBuilder().get("id").equal(project.getId()));
>         
>-        SmallProject tlProject = (SmallProject)em.getActiveSession().executeQuery(tlQuery);
>+        SmallProject tlProject = (SmallProject)getServerSession().executeQuery(tlQuery);
>         Assert.assertTrue("Subclass Inheritance Test Failed", comparer.compareObjects(project, tlProject));                 
>     }
> 
>     public void testJoinSuperClass() {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager) createEntityManager();                  
>+        EntityManager em = createEntityManager();                  
>          
>         Employee emp = (Employee)em.createQuery("SELECT e from Employee e JOIN e.projects p where e.lastName is not null").getResultList().get(0);
>         clearCache();
>@@ -148,12 +149,12 @@
>         tlQuery.setSelectionCriteria(tlQuery.getExpressionBuilder().get("id").equal(emp.getId()));
>         tlQuery.addJoinedAttribute(tlQuery.getExpressionBuilder().anyOf("projects"));
>         
>-        Employee tlEmp = (Employee)em.getActiveSession().executeQuery(tlQuery);
>+        Employee tlEmp = (Employee)getServerSession().executeQuery(tlQuery);
>         Assert.assertTrue("Join superclass Inheritance Test Failed", comparer.compareObjects(emp, tlEmp));                 
>     }
> 
>     public void testJoinSubClass() {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager) createEntityManager();                  
>+        EntityManager em = createEntityManager();                  
>          
>         Engineer emp = (Engineer)em.createQuery("SELECT e from Engineer e JOIN e.bestFriend b WHERE e.title is not null").getResultList().get(0);
>         clearCache();
>@@ -161,12 +162,12 @@
>         tlQuery.setSelectionCriteria(tlQuery.getExpressionBuilder().get("id").equal(emp.getId()));
>         tlQuery.addJoinedAttribute(tlQuery.getExpressionBuilder().get("bestFriend"));
>         
>-        Engineer tlEmp = (Engineer)em.getActiveSession().executeQuery(tlQuery);
>+        Engineer tlEmp = (Engineer)getServerSession().executeQuery(tlQuery);
>         Assert.assertTrue("Join Subclass Inheritance Test Failed", comparer.compareObjects(emp, tlEmp));                 
>     }
> 
>     public void testJoinFetchSuperClass() {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager) createEntityManager();                  
>+        EntityManager em = createEntityManager();                  
>          
>         Employee emp = (Employee)em.createQuery("SELECT e from Employee e JOIN FETCH e.projects").getResultList().get(0);
>         clearCache();
>@@ -174,12 +175,12 @@
>         tlQuery.setSelectionCriteria(tlQuery.getExpressionBuilder().get("id").equal(emp.getId()));
>         tlQuery.addJoinedAttribute(tlQuery.getExpressionBuilder().anyOf("projects"));
>         
>-        Employee tlEmp = (Employee)em.getActiveSession().executeQuery(tlQuery);
>+        Employee tlEmp = (Employee)getServerSession().executeQuery(tlQuery);
>         Assert.assertTrue("Join superclass Inheritance Test Failed", comparer.compareObjects(emp, tlEmp));                 
>     }
> 
>     public void testJoinFetchSubClass() {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager) createEntityManager();                  
>+        EntityManager em = createEntityManager();                  
>          
>         Engineer emp = (Engineer)em.createQuery("SELECT e from Engineer e JOIN FETCH e.bestFriend").getResultList().get(0);
>         clearCache();
>@@ -187,7 +188,7 @@
>         tlQuery.setSelectionCriteria(tlQuery.getExpressionBuilder().get("id").equal(emp.getId()));
>         tlQuery.addJoinedAttribute(tlQuery.getExpressionBuilder().get("bestFriend"));
>         
>-        Engineer tlEmp = (Engineer)em.getActiveSession().executeQuery(tlQuery);
>+        Engineer tlEmp = (Engineer)getServerSession().executeQuery(tlQuery);
>         Assert.assertTrue("Join Subclass Inheritance Test Failed", comparer.compareObjects(emp, tlEmp));                 
>     }
> 
>@@ -197,7 +198,7 @@
>      * See issue 860.
>      */
>     public void testJoinedInheritance() {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager) createEntityManager();
>+        EntityManager em = createEntityManager();
> 
>         String ejbqlString = "SELECT OBJECT(b) FROM BBB b WHERE b.foo = ?1";
>         // query throws exception, if result not unique!
>@@ -205,7 +206,7 @@
>     }
>     
>     public void testJoinedInheritanceWithLeftOuterJoin1() {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager) createEntityManager();        
>+        EntityManager em = createEntityManager();        
>         String ejbqlString = "SELECT t0.maxSpeed, t0.color, t0.description, t0.fuelCapacity, t0.fuelType, t0.id, t0.passengerCapacity, t1.name, t1.id FROM SportsCar t0 LEFT OUTER JOIN t0.owner t1";
>         try {
>             em.createQuery(ejbqlString).getResultList();
>@@ -215,7 +216,7 @@
>     }
>     
>     public void testJoinedInheritanceWithLeftOuterJoin2() {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager) createEntityManager();
>+        EntityManager em = createEntityManager();
>         String ejbqlString = "SELECT t0.color, t0.description, t0.fuelCapacity, t0.fuelType, t0.id, t0.passengerCapacity, t1.name, t1.id FROM FueledVehicle t0 LEFT OUTER JOIN t0.owner t1";
>         try {
>             em.createQuery(ejbqlString).getResultList();
>@@ -225,7 +226,7 @@
>     }
>     
>     public void testJoinedInheritanceWithLeftOuterJoin3() {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager) createEntityManager();
>+        EntityManager em = createEntityManager();
>         String ejbqlString = "SELECT t0.color, t0.description, t0.fuelCapacity, t0.fuelType, t0.id, t0.passengerCapacity, t1.name, t1.id FROM Bus t0 LEFT OUTER JOIN t0.busDriver t1";
>         try {
>             em.createQuery(ejbqlString).getResultList();
>Index: jpa/eclipselink.jpa.test/src/org/eclipse/persistence/testing/tests/jpa/jpql/JUnitJPQLModifyTestSuite.java
>===================================================================
>--- jpa/eclipselink.jpa.test/src/org/eclipse/persistence/testing/tests/jpa/jpql/JUnitJPQLModifyTestSuite.java	(revision 2560)
>+++ jpa/eclipselink.jpa.test/src/org/eclipse/persistence/testing/tests/jpa/jpql/JUnitJPQLModifyTestSuite.java	(working copy)
>@@ -91,6 +91,7 @@
>     {
>         TestSuite suite = new TestSuite();
>         suite.setName("JUnitJPQLModifyTestSuite");
>+        suite.addTest(new JUnitJPQLModifyTestSuite("testSetup"));
>         suite.addTest(new JUnitJPQLModifyTestSuite("simpleUpdate"));
>         suite.addTest(new JUnitJPQLModifyTestSuite("updateWithSubquery"));
>         suite.addTest(new JUnitJPQLModifyTestSuite("updateEmbedded"));
>@@ -99,28 +100,26 @@
>         suite.addTest(new JUnitJPQLModifyTestSuite("updateUnqualifiedAttributeInWhere"));
>         suite.addTest(new JUnitJPQLModifyTestSuite("updateDateTimeFields"));
>         suite.addTest(new JUnitJPQLModifyTestSuite("simpleDelete"));
>-        return new TestSetup(suite) {
>-     
>-            //This method is run at the end of the SUITE only
>-            protected void tearDown() {
>-                clearCache();
>-            }
>-            
>-            //This method is run at the start of the SUITE only
>-            protected void setUp() {
>-                
>-                //get session to start setup
>-                DatabaseSession session = JUnitTestCase.getServerSession();
>-                
>-                //initialize the global comparer object
>-                comparer = new JUnitDomainObjectComparer();
>-                
>-                //set the session for the comparer to use
>-                comparer.setSession((AbstractSession)session.getActiveSession());              
>-            }            
>-        };    
>+        
>+        return suite;
>     }
>-  
>+    
>+    /**
>+     * The setup is done as a test, both to record its failure, and to allow execution in the server.
>+     */
>+    public void testSetup() {
>+        clearCache();
>+        //get session to start setup
>+        DatabaseSession session = JUnitTestCase.getServerSession();
>+        
>+        //initialize the global comparer object
>+        comparer = new JUnitDomainObjectComparer();
>+        
>+        //set the session for the comparer to use
>+        comparer.setSession((AbstractSession)session.getActiveSession());
>+
>+    }
>+    
>     public void simpleUpdate()
>     {          
>         EntityManager em = createEntityManager();
>Index: jpa/eclipselink.jpa.test/src/org/eclipse/persistence/testing/tests/jpa/jpql/JUnitJPQLParameterTestSuite.java
>===================================================================
>--- jpa/eclipselink.jpa.test/src/org/eclipse/persistence/testing/tests/jpa/jpql/JUnitJPQLParameterTestSuite.java	(revision 2560)
>+++ jpa/eclipselink.jpa.test/src/org/eclipse/persistence/testing/tests/jpa/jpql/JUnitJPQLParameterTestSuite.java	(working copy)
>@@ -16,20 +16,21 @@
> 
> import java.util.List;
> import java.util.Vector;
>+
> import junit.framework.Assert;
> import junit.framework.Test;
> import junit.framework.TestSuite;
>+import junit.extensions.TestSetup;
>+
>+import javax.persistence.Query;
>+import javax.persistence.EntityManager;
>+
> import org.eclipse.persistence.testing.models.jpa.advanced.Employee;
> import org.eclipse.persistence.testing.models.jpa.advanced.EmployeePopulator;
> import org.eclipse.persistence.testing.framework.junit.JUnitTestCase;
>-
>-import junit.extensions.TestSetup;
> import org.eclipse.persistence.sessions.DatabaseSession;
> import org.eclipse.persistence.internal.sessions.AbstractSession;
> import org.eclipse.persistence.testing.models.jpa.advanced.AdvancedTableCreator;
>-import javax.persistence.Query;
>-import javax.persistence.EntityManager;
>-
> /**
>  * <p>
>  * <b>Purpose</b>: Test EJBQL parameter functionality.
>@@ -76,47 +77,45 @@
>     {
>         TestSuite suite = new TestSuite();
>         suite.setName("JUnitJPQLParameterTestSuite");
>+        suite.addTest(new JUnitJPQLParameterTestSuite("testSetup"));
>         suite.addTest(new JUnitJPQLParameterTestSuite("multipleParameterTest"));
>         suite.addTest(new JUnitJPQLParameterTestSuite("updateEnumParameter"));
>-        return new TestSetup(suite) {
>-     
>-            //This method is run at the end of the SUITE only
>-            protected void tearDown() {
>-                clearCache();
>-            }
>-            
>-            //This method is run at the start of the SUITE only
>-            protected void setUp() {
>-                
>-                //get session to start setup
>-                DatabaseSession session = JUnitTestCase.getServerSession();
>-                
>-                //create a new EmployeePopulator
>-                EmployeePopulator employeePopulator = new EmployeePopulator();
>-                
>-                new AdvancedTableCreator().replaceTables(session);
>-                
>-                //initialize the global comparer object
>-                comparer = new JUnitDomainObjectComparer();
>-                
>-                //set the session for the comparer to use
>-                comparer.setSession((AbstractSession)session.getActiveSession());              
>-                
>-                //Populate the tables
>-                employeePopulator.buildExamples();
>-                
>-                //Persist the examples in the database
>-                employeePopulator.persistExample(session);       
>-            }            
>-        };    
>+        
>+        return suite;
>     }
>-  
>+    
>+    /**
>+     * The setup is done as a test, both to record its failure, and to allow execution in the server.
>+     */
>+    public void testSetup() {
>+        clearCache();
>+        //get session to start setup
>+        DatabaseSession session = JUnitTestCase.getServerSession();
>+        
>+        //create a new EmployeePopulator
>+        EmployeePopulator employeePopulator = new EmployeePopulator();
>+        
>+        new AdvancedTableCreator().replaceTables(session);
>+        
>+        //initialize the global comparer object
>+        comparer = new JUnitDomainObjectComparer();
>+        
>+        //set the session for the comparer to use
>+        comparer.setSession((AbstractSession)session.getActiveSession());              
>+        
>+        //Populate the tables
>+        employeePopulator.buildExamples();
>+        
>+        //Persist the examples in the database
>+        employeePopulator.persistExample(session);
>+    }
>+    
>     //Test case for selecting employee from the database using parameters 
>     public void multipleParameterTest()
>     {          
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager) createEntityManager();
>+        EntityManager em = createEntityManager();
>       
>-        Employee employee = (Employee) (em.getActiveSession().readAllObjects(Employee.class).firstElement());
>+        Employee employee = (Employee) (getServerSession().readAllObjects(Employee.class).firstElement());
>         Vector expectedResult = new Vector();
>         expectedResult.add(employee);
>       
>Index: jpa/eclipselink.jpa.test/src/org/eclipse/persistence/testing/tests/jpa/jpql/JUnitJPQLSimpleTestSuite.java
>===================================================================
>--- jpa/eclipselink.jpa.test/src/org/eclipse/persistence/testing/tests/jpa/jpql/JUnitJPQLSimpleTestSuite.java	(revision 2560)
>+++ jpa/eclipselink.jpa.test/src/org/eclipse/persistence/testing/tests/jpa/jpql/JUnitJPQLSimpleTestSuite.java	(working copy)
>@@ -17,9 +17,7 @@
> import java.io.ByteArrayOutputStream;
> import java.io.ObjectInputStream;
> import java.io.ObjectOutputStream;
>-
> import java.math.BigDecimal;
>-
> import java.util.ArrayList;
> import java.util.HashSet;
> import java.util.Iterator;
>@@ -28,21 +26,19 @@
> import java.util.Vector;
> 
> import javax.persistence.EntityManager;
>-
> import javax.persistence.Query;
> 
> import junit.framework.Assert;
> import junit.framework.Test;
> import junit.framework.TestSuite;
>+import junit.extensions.TestSetup;
> 
> import org.eclipse.persistence.expressions.Expression;
> import org.eclipse.persistence.expressions.ExpressionBuilder;
> import org.eclipse.persistence.expressions.ExpressionMath;
> import org.eclipse.persistence.sessions.Session;
>-
> import org.eclipse.persistence.queries.ReadAllQuery;
> import org.eclipse.persistence.queries.ReadObjectQuery;
>-
> import org.eclipse.persistence.queries.ReportQuery;
> import org.eclipse.persistence.sessions.UnitOfWork;
> import org.eclipse.persistence.testing.models.jpa.advanced.Address;
>@@ -51,9 +47,6 @@
> import org.eclipse.persistence.testing.models.jpa.advanced.PhoneNumber;
> import org.eclipse.persistence.testing.models.jpa.advanced.SmallProject;
> import org.eclipse.persistence.testing.framework.junit.JUnitTestCase;
>-
>-import junit.extensions.TestSetup;
>-
> import org.eclipse.persistence.internal.jpa.EntityManagerImpl;
> import org.eclipse.persistence.sessions.DatabaseSession;
> import org.eclipse.persistence.internal.sessions.AbstractSession;
>@@ -97,6 +90,7 @@
>     public static Test suite() {
>         TestSuite suite = new TestSuite();
>         suite.setName("JUnitJPQLSimpleTestSuite");
>+        suite.addTest(new JUnitJPQLSimpleTestSuite("testSetup"));
>         suite.addTest(new JUnitJPQLSimpleTestSuite("simpleJoinFetchTest"));
>         suite.addTest(new JUnitJPQLSimpleTestSuite("simpleJoinFetchTest2"));
>         suite.addTest(new JUnitJPQLSimpleTestSuite("baseTestCase"));
>@@ -166,42 +160,36 @@
>         suite.addTest(new JUnitJPQLSimpleTestSuite("multipleExecutionOfNamedQueryTest"));
>         suite.addTest(new JUnitJPQLSimpleTestSuite("selectNamedNativeQueryWithPositionalParameterTest"));
>         suite.addTest(new JUnitJPQLSimpleTestSuite("selectNativeQueryWithPositionalParameterTest"));
>-
>-        return new TestSetup(suite) {
>-
>-                //This method is run at the end of the SUITE only
>-
>-                protected void tearDown() {
>-                    clearCache();
>-                }
>-
>-                //This method is run at the start of the SUITE only
>-
>-                protected void setUp() {
>-
>-                    //get session to start setup
>-                    DatabaseSession session = JUnitTestCase.getServerSession();
>-
>-                    //create a new EmployeePopulator
>-                    EmployeePopulator employeePopulator = new EmployeePopulator();
>-
>-                    new AdvancedTableCreator().replaceTables(session);
>-
>-                    //initialize the global comparer object
>-                    comparer = new JUnitDomainObjectComparer();
>-
>-                    //set the session for the comparer to use
>-                    comparer.setSession((AbstractSession)session.getActiveSession());
>-
>-                    //Populate the tables
>-                    employeePopulator.buildExamples();
>-
>-                    //Persist the examples in the database
>-                    employeePopulator.persistExample(session);
>-                }
>-            };
>+        
>+        return suite;
>     }
>-
>+    
>+    /**
>+     * The setup is done as a test, both to record its failure, and to allow execution in the server.
>+     */
>+    public void testSetup() {
>+        clearCache();
>+        //get session to start setup
>+        DatabaseSession session = JUnitTestCase.getServerSession();
>+        
>+        //create a new EmployeePopulator
>+        EmployeePopulator employeePopulator = new EmployeePopulator();
>+        
>+        new AdvancedTableCreator().replaceTables(session);
>+        
>+        //initialize the global comparer object
>+        comparer = new JUnitDomainObjectComparer();
>+        
>+        //set the session for the comparer to use
>+        comparer.setSession((AbstractSession)session.getActiveSession());              
>+        
>+        //Populate the tables
>+        employeePopulator.buildExamples();
>+        
>+        //Persist the examples in the database
>+        employeePopulator.persistExample(session);
>+    }
>+    
>     //GF Bug#404
>     //1.  Fetch join now works with LAZY.  The fix is to trigger the value holder during object registration.  The test is to serialize
>     //the results and deserialize it, then call getPhoneNumbers().size().  It used to throw an exception because the value holder 
>@@ -209,6 +197,10 @@
>     //2.  Test both scenarios of using the cache and bypassing the cache
> 
>     public void simpleJoinFetchTest() throws Exception {
>+        if (isOnServer()) {
>+            // Not work on server.
>+            return;
>+        }
>         org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>         simpleJoinFetchTest(em);
>     }
>@@ -218,6 +210,10 @@
>     // tests that Fetch join works when returning objects that may already have been loaded in the em/uow (without the joined relationships)
>     // Builds on simpleJoinFetchTest
>     public void simpleJoinFetchTest2() throws Exception {
>+        if (isOnServer()) {
>+            // Not work on server.
>+            return;
>+        }
>         org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>         //preload employees into the cache so that phonenumbers are not prefetched
>         String ejbqlString = "SELECT e FROM Employee e";
>@@ -293,9 +289,9 @@
>     //Test case for selecting ALL employees from the database
> 
>     public void baseTestCase() {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
> 
>-        List expectedResult = em.getActiveSession().readAllObjects(Employee.class);
>+        List expectedResult = getServerSession().readAllObjects(Employee.class);
> 
>         clearCache();
> 
>@@ -307,9 +303,9 @@
>     //Test case for ABS function in EJBQL
> 
>     public void simpleABSTest() {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
> 
>-        Employee expectedResult = (Employee)(em.getActiveSession().readAllObjects(Employee.class).firstElement());
>+        Employee expectedResult = (Employee)(getServerSession().readAllObjects(Employee.class).firstElement());
> 
>         clearCache();
> 
>@@ -329,9 +325,9 @@
>     public void simpleBetweenAndTest() {
>         BigDecimal empId = new BigDecimal(0);
> 
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
> 
>-        Employee employee = (Employee)(em.getActiveSession().readAllObjects(Employee.class).lastElement());
>+        Employee employee = (Employee)(getServerSession().readAllObjects(Employee.class).lastElement());
> 
>         ExpressionBuilder builder = new ExpressionBuilder();
>         Expression whereClause = builder.get("id").between(empId, employee.getId());
>@@ -339,7 +335,7 @@
>         raq.setReferenceClass(Employee.class);
>         raq.setSelectionCriteria(whereClause);
> 
>-        Vector expectedResult = (Vector)em.getActiveSession().executeQuery(raq);
>+        Vector expectedResult = (Vector)getServerSession().executeQuery(raq);
>         clearCache();
> 
>         String ejbqlString = "SELECT OBJECT(emp) FROM Employee emp WHERE emp.id BETWEEN " + empId + "AND " + employee.getId();
>@@ -353,9 +349,9 @@
>     public void simpleBetweenTest() {
>         BigDecimal empId = new BigDecimal(0);
> 
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
> 
>-        Employee employee = (Employee)(em.getActiveSession().readAllObjects(Employee.class).lastElement());
>+        Employee employee = (Employee)(getServerSession().readAllObjects(Employee.class).lastElement());
> 
>         ExpressionBuilder builder = new ExpressionBuilder();
>         Expression whereClause = builder.get("id").between(empId, employee.getId());
>@@ -363,7 +359,7 @@
>         raq.setReferenceClass(Employee.class);
>         raq.setSelectionCriteria(whereClause);
> 
>-        Vector expectedResult = (Vector)em.getActiveSession().executeQuery(raq);
>+        Vector expectedResult = (Vector)getServerSession().executeQuery(raq);
> 
>         clearCache();
> 
>@@ -376,9 +372,9 @@
>     //Test case for concat function in EJBQL
> 
>     public void simpleConcatTest() {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
> 
>-        Employee expectedResult = (Employee)(em.getActiveSession().readAllObjects(Employee.class).firstElement());
>+        Employee expectedResult = (Employee)(getServerSession().readAllObjects(Employee.class).firstElement());
> 
>         clearCache();
> 
>@@ -404,9 +400,9 @@
>     //Test case for concat function in EJBQL taking parameters
> 
>     public void simpleConcatTestWithParameters() {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
> 
>-        Employee expectedResult = (Employee)(em.getActiveSession().readAllObjects(Employee.class).firstElement());
>+        Employee expectedResult = (Employee)(getServerSession().readAllObjects(Employee.class).firstElement());
> 
>         clearCache();
> 
>@@ -433,9 +429,9 @@
>     //Test case for concat function with constants in EJBQL
> 
>     public void simpleConcatTestWithConstants1() {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
> 
>-        Employee emp = (Employee)(em.getActiveSession().readAllObjects(Employee.class).firstElement());
>+        Employee emp = (Employee)(getServerSession().readAllObjects(Employee.class).firstElement());
> 
>         String partOne;
>         String ejbqlString;
>@@ -449,7 +445,7 @@
>         raq.setReferenceClass(Employee.class);
>         raq.setSelectionCriteria(whereClause);
> 
>-        Vector expectedResult = (Vector)em.getActiveSession().executeQuery(raq);
>+        Vector expectedResult = (Vector)getServerSession().executeQuery(raq);
> 
>         clearCache();
> 
>@@ -466,7 +462,7 @@
>     //Test case for double OR function in EJBQL
> 
>     public void simpleDistinctTest() {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
>         String ejbqlString = "SELECT DISTINCT e FROM Employee e JOIN FETCH e.phoneNumbers ";
>         List result = em.createQuery(ejbqlString).getResultList();
>         Set testSet = new HashSet();
>@@ -478,7 +474,7 @@
>     }
> 
>     public void simpleDistinctNullTest() {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
>         Employee emp = (Employee)em.createQuery("SELECT e from Employee e").getResultList().get(0);
>         String oldFirstName = emp.getFirstName();
>         beginTransaction(em);
>@@ -515,7 +511,7 @@
>     }
> 
>     public void simpleDistinctMultipleResultTest() {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
>         String ejbqlString = "SELECT DISTINCT e, e.firstName FROM Employee e JOIN FETCH e.phoneNumbers ";
>         List result = em.createQuery(ejbqlString).getResultList();
>         Set testSet = new HashSet();
>@@ -535,11 +531,11 @@
>     public void simpleDoubleOrTest() {
>         Employee emp1, emp2, emp3;
> 
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
> 
>-        emp1 = (Employee)(em.getActiveSession().readAllObjects(Employee.class).firstElement());
>-        emp2 = (Employee)(em.getActiveSession().readAllObjects(Employee.class).elementAt(1));
>-        emp3 = (Employee)(em.getActiveSession().readAllObjects(Employee.class).elementAt(2));
>+        emp1 = (Employee)(getServerSession().readAllObjects(Employee.class).firstElement());
>+        emp2 = (Employee)(getServerSession().readAllObjects(Employee.class).elementAt(1));
>+        emp3 = (Employee)(getServerSession().readAllObjects(Employee.class).elementAt(2));
> 
>         clearCache();
> 
>@@ -558,9 +554,9 @@
>     //Test case for equals brackets in EJBQL
> 
>     public void simpleEqualsBracketsTest() {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
> 
>-        Employee expectedResult = (Employee)(em.getActiveSession().readAllObjects(Employee.class).firstElement());
>+        Employee expectedResult = (Employee)(getServerSession().readAllObjects(Employee.class).firstElement());
> 
>         clearCache();
> 
>@@ -576,9 +572,9 @@
>     //Test case for equals in EJBQL
> 
>     public void simpleEqualsTest() {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
> 
>-        Employee expectedResult = (Employee)(em.getActiveSession().readAllObjects(Employee.class).firstElement());
>+        Employee expectedResult = (Employee)(getServerSession().readAllObjects(Employee.class).firstElement());
> 
>         clearCache();
> 
>@@ -594,12 +590,12 @@
>     //Test case for equals with join in EJBQL
> 
>     public void simpleEqualsTestWithJoin() {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
> 
>         ExpressionBuilder builder = new ExpressionBuilder();
>         Expression whereClause = builder.anyOf("managedEmployees").get("address").get("city").equal("Ottawa");
> 
>-        Vector expectedResult = em.getActiveSession().readAllObjects(Employee.class, whereClause);
>+        Vector expectedResult = getServerSession().readAllObjects(Employee.class, whereClause);
> 
>         clearCache();
> 
>@@ -611,8 +607,8 @@
>     }
> 
>     public void simpleEqualsWithAs() {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>-        Employee expectedResult = (Employee)(em.getActiveSession().readAllObjects(Employee.class).firstElement());
>+        EntityManager em = createEntityManager();
>+        Employee expectedResult = (Employee)(getServerSession().readAllObjects(Employee.class).firstElement());
> 
>         clearCache();
> 
>@@ -626,12 +622,12 @@
>     }
> 
>     public void collectionMemberIdentifierEqualsTest() {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
> 
>         ExpressionBuilder employees = new ExpressionBuilder();
>         Expression exp = employees.get("firstName").equal("Bob");
>         exp = exp.and(employees.get("lastName").equal("Smith"));
>-        Employee expectedResult = (Employee)em.getActiveSession().readAllObjects(Employee.class, exp).firstElement();
>+        Employee expectedResult = (Employee)getServerSession().readAllObjects(Employee.class, exp).firstElement();
> 
>         clearCache();
> 
>@@ -645,9 +641,9 @@
>     }
> 
>     public void abstractSchemaIdentifierEqualsTest() {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
> 
>-        Employee expectedResult = (Employee)em.getActiveSession().readAllObjects(Employee.class).firstElement();
>+        Employee expectedResult = (Employee)getServerSession().readAllObjects(Employee.class).firstElement();
> 
>         clearCache();
> 
>@@ -659,9 +655,9 @@
>     }
> 
>     public void abstractSchemaIdentifierNotEqualsTest() {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
> 
>-        Vector expectedResult = em.getActiveSession().readAllObjects(Employee.class);
>+        Vector expectedResult = getServerSession().readAllObjects(Employee.class);
> 
>         clearCache();
> 
>@@ -678,7 +674,7 @@
> 
>     public void simpleInOneDotTest() {
>         //select a specifif employee using Expr Bob Smithn
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
> 
>         ReadObjectQuery roq = new ReadObjectQuery(Employee.class);
> 
>@@ -689,7 +685,7 @@
> 
>         roq.setSelectionCriteria(exp1.and(exp2));
> 
>-        Employee expectedResult = (Employee)em.getActiveSession().executeQuery(roq);
>+        Employee expectedResult = (Employee)getServerSession().executeQuery(roq);
> 
>         clearCache();
> 
>@@ -704,7 +700,7 @@
>     }
> 
>     public void selectAverageQueryForByteColumnTest() {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
> 
>         String ejbqlString = "Select AVG(emp.salary)from Employee emp";
>         Object result = em.createQuery(ejbqlString).getSingleResult();
>@@ -713,9 +709,9 @@
>     }
> 
>     public void simpleInTest() {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
> 
>-        Employee expectedResult = (Employee)em.getActiveSession().readAllObjects(Employee.class).elementAt(0);
>+        Employee expectedResult = (Employee)getServerSession().readAllObjects(Employee.class).elementAt(0);
> 
>         clearCache();
> 
>@@ -727,11 +723,11 @@
>     }
> 
>     public void simpleLengthTest() {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
> 
>         Assert.assertFalse("Warning SQL doesnot support LENGTH function", (JUnitTestCase.getServerSession()).getPlatform().isSQLServer());
> 
>-        Employee expectedResult = (Employee)em.getActiveSession().readAllObjects(Employee.class).elementAt(0);
>+        Employee expectedResult = (Employee)getServerSession().readAllObjects(Employee.class).elementAt(0);
> 
>         clearCache();
> 
>@@ -747,9 +743,9 @@
> 
> 
>     public void simpleLikeTest() {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
> 
>-        Employee expectedResult = (Employee)em.getActiveSession().readAllObjects(Employee.class).elementAt(0);
>+        Employee expectedResult = (Employee)getServerSession().readAllObjects(Employee.class).elementAt(0);
> 
>         clearCache();
> 
>@@ -762,9 +758,9 @@
>     }
> 
>     public void simpleLikeTestWithParameter() {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
> 
>-        Employee emp = (Employee)em.getActiveSession().readAllObjects(Employee.class).elementAt(0);
>+        Employee emp = (Employee)getServerSession().readAllObjects(Employee.class).elementAt(0);
> 
>         String partialFirstName = "%" + emp.getFirstName().substring(0, 3) + "%";
> 
>@@ -777,7 +773,7 @@
>         ExpressionBuilder eb = new ExpressionBuilder();
>         Expression whereClause = eb.get("firstName").like(partialFirstName);
>         raq.setSelectionCriteria(whereClause);
>-        Vector expectedResult = (Vector)em.getActiveSession().executeQuery(raq);
>+        Vector expectedResult = (Vector)getServerSession().executeQuery(raq);
> 
>         clearCache();
> 
>@@ -789,7 +785,7 @@
>     }
> 
>     public void simpleLikeEscapeTestWithParameter() {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
> 
>         Address expectedResult = new Address();
>         expectedResult.setCity("TAIYUAN");
>@@ -809,7 +805,7 @@
>         String patternString = null;
>         Character escChar = null;
>         // \ is always treated as escape in MySQL.  Therefore ESCAPE '\' is considered a syntax error
>-        if (((EntityManagerImpl)em.getDelegate()).getServerSession().getPlatform().isMySQL()) {
>+            if (getServerSession().getPlatform().isMySQL()) {
>             patternString = "234 RUBY $_Way";
>             escChar = new Character('$');
>         } else {
>@@ -823,10 +819,10 @@
>     }
> 
>     public void simpleNotBetweenTest() {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
> 
>-        Employee emp1 = (Employee)em.getActiveSession().readAllObjects(Employee.class).firstElement();
>-        Employee emp2 = (Employee)em.getActiveSession().readAllObjects(Employee.class).lastElement();
>+        Employee emp1 = (Employee)getServerSession().readAllObjects(Employee.class).firstElement();
>+        Employee emp2 = (Employee)getServerSession().readAllObjects(Employee.class).lastElement();
> 
>         ReadAllQuery raq = new ReadAllQuery();
>         raq.setReferenceClass(Employee.class);
>@@ -853,9 +849,9 @@
>     }
> 
>     public void simpleNotEqualsVariablesInteger() {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
> 
>-        Vector expectedResult = em.getActiveSession().readAllObjects(Employee.class);
>+        Vector expectedResult = getServerSession().readAllObjects(Employee.class);
> 
>         clearCache();
> 
>@@ -872,9 +868,9 @@
>     }
> 
>     public void simpleNotInTest() {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
> 
>-        Employee emp = (Employee)em.getActiveSession().readAllObjects(Employee.class).elementAt(0);
>+        Employee emp = (Employee)getServerSession().readAllObjects(Employee.class).elementAt(0);
> 
>         ExpressionBuilder builder = new ExpressionBuilder();
> 
>@@ -886,7 +882,7 @@
>         raq.setReferenceClass(Employee.class);
>         raq.setSelectionCriteria(whereClause);
> 
>-        Vector expectedResult = (Vector)em.getActiveSession().executeQuery(raq);
>+        Vector expectedResult = (Vector)getServerSession().executeQuery(raq);
> 
>         clearCache();
> 
>@@ -898,9 +894,9 @@
>     }
> 
>     public void simpleNotLikeTest() {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
> 
>-        Employee emp = (Employee)em.getActiveSession().readAllObjects(Employee.class).elementAt(0);
>+        Employee emp = (Employee)getServerSession().readAllObjects(Employee.class).elementAt(0);
> 
>         String partialFirstName = emp.getFirstName().substring(0, 3) + "%";
> 
>@@ -911,7 +907,7 @@
>         raq.setReferenceClass(Employee.class);
>         raq.setSelectionCriteria(whereClause);
> 
>-        Vector expectedResult = (Vector)em.getActiveSession().executeQuery(raq);
>+        Vector expectedResult = (Vector)getServerSession().executeQuery(raq);
> 
>         clearCache();
> 
>@@ -923,11 +919,11 @@
>     }
> 
>     public void simpleOrFollowedByAndTest() {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
> 
>-        Employee emp1 = (Employee)em.getActiveSession().readAllObjects(Employee.class).elementAt(0);
>-        Employee emp2 = (Employee)em.getActiveSession().readAllObjects(Employee.class).elementAt(1);
>-        Employee emp3 = (Employee)em.getActiveSession().readAllObjects(Employee.class).elementAt(2);
>+        Employee emp1 = (Employee)getServerSession().readAllObjects(Employee.class).elementAt(0);
>+        Employee emp2 = (Employee)getServerSession().readAllObjects(Employee.class).elementAt(1);
>+        Employee emp3 = (Employee)getServerSession().readAllObjects(Employee.class).elementAt(2);
> 
>         Vector expectedResult = new Vector();
>         expectedResult.add(emp1);
>@@ -940,7 +936,7 @@
>     }
> 
>     public void simpleOrFollowedByAndTestWithStaticNames() {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
> 
>         ExpressionBuilder builder = new ExpressionBuilder();
>         Expression whereClause = builder.get("firstName").equal("John").or(builder.get("firstName").equal("Bob").and(builder.get("lastName").equal("Smith")));
>@@ -949,7 +945,7 @@
>         raq.setReferenceClass(Employee.class);
>         raq.setSelectionCriteria(whereClause);
> 
>-        Vector expectedResult = (Vector)em.getActiveSession().executeQuery(raq);
>+        Vector expectedResult = (Vector)getServerSession().executeQuery(raq);
> 
>         clearCache();
> 
>@@ -961,10 +957,10 @@
>     }
> 
>     public void simpleOrTest() {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
> 
>-        Employee emp1 = (Employee)em.getActiveSession().readAllObjects(Employee.class).elementAt(0);
>-        Employee emp2 = (Employee)em.getActiveSession().readAllObjects(Employee.class).elementAt(1);
>+        Employee emp1 = (Employee)getServerSession().readAllObjects(Employee.class).elementAt(0);
>+        Employee emp2 = (Employee)getServerSession().readAllObjects(Employee.class).elementAt(1);
> 
>         Vector expectedResult = new Vector();
>         expectedResult.add(emp1);
>@@ -979,9 +975,9 @@
>     }
> 
>     public void simpleParameterTest() {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
> 
>-        Employee expectedResult = (Employee)em.getActiveSession().readAllObjects(Employee.class).elementAt(0);
>+        Employee expectedResult = (Employee)getServerSession().readAllObjects(Employee.class).elementAt(0);
> 
>         String parameterName = "firstName";
>         ExpressionBuilder builder = new ExpressionBuilder();
>@@ -1009,10 +1005,10 @@
> 
>     public void simpleParameterTestChangingParameters() {
> 
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
> 
>-        Employee emp1 = (Employee)em.getActiveSession().readAllObjects(Employee.class).elementAt(0);
>-        Employee emp2 = (Employee)em.getActiveSession().readAllObjects(Employee.class).elementAt(1);
>+        Employee emp1 = (Employee)getServerSession().readAllObjects(Employee.class).elementAt(0);
>+        Employee emp2 = (Employee)getServerSession().readAllObjects(Employee.class).elementAt(1);
> 
>         String parameterName = "firstName";
>         ExpressionBuilder builder = new ExpressionBuilder();
>@@ -1051,9 +1047,9 @@
>     }
> 
>     public void simpleReverseAbsTest() {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
> 
>-        Employee expectedResult = (Employee)em.getActiveSession().readAllObjects(Employee.class).elementAt(0);
>+        Employee expectedResult = (Employee)getServerSession().readAllObjects(Employee.class).elementAt(0);
>         clearCache();
> 
>         String ejbqlString = "SELECT OBJECT(emp) FROM Employee emp WHERE " + expectedResult.getSalary() + " = ABS(emp.salary)";
>@@ -1065,9 +1061,9 @@
>     }
> 
>     public void simpleReverseConcatTest() {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
> 
>-        Employee expectedResult = (Employee)em.getActiveSession().readAllObjects(Employee.class).elementAt(0);
>+        Employee expectedResult = (Employee)getServerSession().readAllObjects(Employee.class).elementAt(0);
> 
>         clearCache();
> 
>@@ -1088,9 +1084,9 @@
>     }
> 
>     public void simpleReverseEqualsTest() {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
> 
>-        Employee expectedResult = (Employee)em.getActiveSession().readAllObjects(Employee.class).elementAt(0);
>+        Employee expectedResult = (Employee)getServerSession().readAllObjects(Employee.class).elementAt(0);
> 
>         clearCache();
> 
>@@ -1104,9 +1100,9 @@
>     }
> 
>     public void simpleReverseLengthTest() {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
> 
>-        Employee expectedResult = (Employee)em.getActiveSession().readAllObjects(Employee.class).elementAt(0);
>+        Employee expectedResult = (Employee)getServerSession().readAllObjects(Employee.class).elementAt(0);
> 
>         clearCache();
>         String ejbqlString = "SELECT OBJECT(emp) FROM Employee emp WHERE ";
>@@ -1120,9 +1116,9 @@
>     }
> 
>     public void simpleReverseParameterTest() {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
> 
>-        Employee emp = (Employee)em.getActiveSession().readAllObjects(Employee.class).elementAt(0);
>+        Employee emp = (Employee)getServerSession().readAllObjects(Employee.class).elementAt(0);
> 
>         clearCache();
> 
>@@ -1150,7 +1146,7 @@
>     }
> 
>     public void simpleReverseSqrtTest() {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
> 
>         ExpressionBuilder expbldr = new ExpressionBuilder();
>         Expression whereClause = expbldr.get("firstName").equal("SquareRoot").and(expbldr.get("lastName").equal("TestCase1"));
>@@ -1158,7 +1154,7 @@
>         raq.setReferenceClass(Employee.class);
>         raq.setSelectionCriteria(whereClause);
> 
>-        Vector expectedResult = (Vector)em.getActiveSession().executeQuery(raq);
>+        Vector expectedResult = (Vector)getServerSession().executeQuery(raq);
> 
>         double salarySquareRoot = Math.sqrt((new Double(((Employee)expectedResult.firstElement()).getSalary()).doubleValue()));
> 
>@@ -1176,9 +1172,9 @@
>     }
> 
>     public void simpleReverseSubstringTest() {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
> 
>-        Employee expectedResult = (Employee)em.getActiveSession().readAllObjects(Employee.class).elementAt(0);
>+        Employee expectedResult = (Employee)getServerSession().readAllObjects(Employee.class).elementAt(0);
> 
>         clearCache();
> 
>@@ -1198,7 +1194,7 @@
> 
> 
>     public void simpleSqrtTest() {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
> 
>         ExpressionBuilder expbldr = new ExpressionBuilder();
>         Expression whereClause = expbldr.get("firstName").equal("SquareRoot").and(expbldr.get("lastName").equal("TestCase1"));
>@@ -1206,7 +1202,7 @@
>         raq.setReferenceClass(Employee.class);
>         raq.setSelectionCriteria(whereClause);
> 
>-        Vector expectedResult = (Vector)em.getActiveSession().executeQuery(raq);
>+        Vector expectedResult = (Vector)getServerSession().executeQuery(raq);
> 
>         double salarySquareRoot = Math.sqrt((new Double(((Employee)expectedResult.firstElement()).getSalary()).doubleValue()));
> 
>@@ -1223,9 +1219,9 @@
>     }
> 
>     public void simpleSubstringTest() {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
> 
>-        Employee expectedResult = (Employee)em.getActiveSession().readAllObjects(Employee.class).elementAt(0);
>+        Employee expectedResult = (Employee)getServerSession().readAllObjects(Employee.class).elementAt(0);
> 
>         clearCache();
> 
>@@ -1239,7 +1235,7 @@
>     }
> 
>     public void simpleNullTest() {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
> 
>         Employee nullEmployee = new Employee();
>         nullEmployee.setFirstName(null);
>@@ -1258,7 +1254,7 @@
>         Expression whereClause = builder.get("firstName").isNull();
>         raq.setSelectionCriteria(whereClause);
> 
>-        Vector expectedResult = (Vector)em.getActiveSession().executeQuery(raq);
>+        Vector expectedResult = (Vector)getServerSession().executeQuery(raq);
> 
>         clearCache();
> 
>@@ -1275,7 +1271,7 @@
>     }
> 
>     public void simpleNotNullTest() {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
>         Employee nullEmployee = new Employee();
>         nullEmployee.setFirstName(null);
>         nullEmployee.setLastName("Test");
>@@ -1293,7 +1289,7 @@
>         Expression whereClause = builder.get("firstName").isNull().not();
>         raq.setSelectionCriteria(whereClause);
> 
>-        Vector expectedResult = (Vector)em.getActiveSession().executeQuery(raq);
>+        Vector expectedResult = (Vector)getServerSession().executeQuery(raq);
> 
>         clearCache();
> 
>@@ -1308,7 +1304,7 @@
>     }
> 
>     public void distinctTest() {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
>         ReadAllQuery raq = new ReadAllQuery();
> 
>         ExpressionBuilder employee = new ExpressionBuilder();
>@@ -1318,7 +1314,7 @@
>         raq.setSelectionCriteria(whereClause);
>         raq.useDistinct();
> 
>-        Vector expectedResult = (Vector)em.getActiveSession().executeQuery(raq);
>+        Vector expectedResult = (Vector)getServerSession().executeQuery(raq);
> 
>         clearCache();
> 
>@@ -1360,7 +1356,7 @@
>     }
> 
>     public void conformResultsInUnitOfWorkTest() {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
>         ReadObjectQuery readObjectQuery = new ReadObjectQuery();
> 
>         readObjectQuery.setReferenceClass(Employee.class);
>@@ -1370,7 +1366,7 @@
> 
> 
>         //ServerSession next
>-        Server serverSession = ((EntityManagerImpl)em.getDelegate()).getServerSession().getProject().createServerSession();
>+        Server serverSession = getServerSession().getProject().createServerSession();
>         serverSession.setSessionLog(getServerSession().getSessionLog());
>         serverSession.login();
>         UnitOfWork unitOfWork = serverSession.acquireUnitOfWork();
>@@ -1389,7 +1385,7 @@
>     }
> 
>     public void simpleModTest() {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
> 
>         Assert.assertFalse("Warning SQL/Sybase doesnot support MOD function", (JUnitTestCase.getServerSession()).getPlatform().isSQLServer() || (JUnitTestCase.getServerSession()).getPlatform().isSybase());
> 
>@@ -1400,7 +1396,7 @@
>         raq.setReferenceClass(Employee.class);
>         raq.setSelectionCriteria(whereClause);
> 
>-        Vector expectedResult = (Vector)em.getActiveSession().executeQuery(raq);
>+        Vector expectedResult = (Vector)getServerSession().executeQuery(raq);
> 
>         clearCache();
> 
>@@ -1412,7 +1408,7 @@
> 
>         // Test MOD(fieldAccess, fieldAccess) glassfish issue 2771
> 
>-        expectedResult = em.getActiveSession().readAllObjects(Employee.class);
>+        expectedResult = getServerSession().readAllObjects(Employee.class);
>         clearCache();
>         
>         ejbqlString = "SELECT emp FROM Employee emp WHERE MOD(emp.salary, emp.salary) = 0";        
>@@ -1422,7 +1418,7 @@
>     }
> 
>     public void simpleIsEmptyTest() {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
> 
>         ExpressionBuilder builder = new ExpressionBuilder();
>         Expression whereClause = builder.isEmpty("phoneNumbers");
>@@ -1431,7 +1427,7 @@
>         raq.setReferenceClass(Employee.class);
>         raq.setSelectionCriteria(whereClause);
> 
>-        Vector expectedResult = (Vector)em.getActiveSession().executeQuery(raq);
>+        Vector expectedResult = (Vector)getServerSession().executeQuery(raq);
> 
>         clearCache();
> 
>@@ -1443,7 +1439,7 @@
>     }
> 
>     public void simpleIsNotEmptyTest() {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
> 
>         ExpressionBuilder builder = new ExpressionBuilder();
>         Expression whereClause = builder.notEmpty("phoneNumbers");
>@@ -1452,7 +1448,7 @@
>         raq.setReferenceClass(Employee.class);
>         raq.setSelectionCriteria(whereClause);
> 
>-        Vector expectedResult = (Vector)em.getActiveSession().executeQuery(raq);
>+        Vector expectedResult = (Vector)getServerSession().executeQuery(raq);
> 
>         clearCache();
> 
>@@ -1465,9 +1461,9 @@
>     }
> 
>     public void simpleApostrohpeTest() {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
> 
>-        Vector addresses = em.getActiveSession().readAllObjects(Address.class);
>+        Vector addresses = getServerSession().readAllObjects(Address.class);
> 
>         clearCache();
> 
>@@ -1491,7 +1487,7 @@
>     }
> 
>     public void simpleEscapeUnderscoreTest() {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
> 
>         Address expectedResult = new Address();
>         expectedResult.setCity("Perth");
>@@ -1509,7 +1505,7 @@
>         //test the apostrophe
>         String ejbqlString = "SELECT OBJECT(address) FROM Address address WHERE ";
>         // \ is always treated as escape in MySQL.  Therefore ESCAPE '\' is considered a syntax error
>-        if (((EntityManagerImpl)em.getDelegate()).getServerSession().getPlatform().isMySQL()) {
>+        if (getServerSession().getPlatform().isMySQL()) {
>             ejbqlString = ejbqlString + "address.street LIKE '234 Wandering $_Way' ESCAPE '$'";
>         } else {
>             ejbqlString = ejbqlString + "address.street LIKE '234 Wandering \\_Way' ESCAPE '\\'";
>@@ -1521,7 +1517,7 @@
>     }
> 
>     public void smallProjectMemberOfProjectsTest() {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
> 
>         ReadAllQuery query = new ReadAllQuery();
>         Expression selectionCriteria = new ExpressionBuilder().anyOf("projects").equal(new ExpressionBuilder(SmallProject.class));
>@@ -1529,7 +1525,7 @@
>         query.setReferenceClass(Employee.class);
>         query.dontUseDistinct(); //gf 1395 changed jpql to not use distinct on joins
> 
>-        Vector expectedResult = (Vector)em.getActiveSession().executeQuery(query);
>+        Vector expectedResult = (Vector)getServerSession().executeQuery(query);
> 
>         clearCache();
> 
>@@ -1544,14 +1540,14 @@
>     }
> 
>     public void smallProjectNOTMemberOfProjectsTest() {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
> 
>         //query for those employees with Project named "Enterprise" (which should be
>         //a SmallProject)
>         ReadObjectQuery smallProjectQuery = new ReadObjectQuery();
>         smallProjectQuery.setReferenceClass(SmallProject.class);
>         smallProjectQuery.setSelectionCriteria(new ExpressionBuilder().get("name").equal("Enterprise"));
>-        SmallProject smallProject = (SmallProject)em.getActiveSession().executeQuery(smallProjectQuery);
>+        SmallProject smallProject = (SmallProject)getServerSession().executeQuery(smallProjectQuery);
> 
>         ReadAllQuery query = new ReadAllQuery();
>         query.addArgument("smallProject");
>@@ -1562,7 +1558,7 @@
> 
>         Vector arguments = new Vector();
>         arguments.add(smallProject);
>-        Vector expectedResult = (Vector)em.getActiveSession().executeQuery(query, arguments);
>+        Vector expectedResult = (Vector)getServerSession().executeQuery(query, arguments);
> 
> 
>         //setup the EJBQL to do the same
>@@ -1578,7 +1574,7 @@
>     //This test demonstrates the bug 4616218, waiting for bug fix
> 
>     public void selectCountOneToOneTest() {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
> 
>         ReportQuery query = new ReportQuery();
>         query.setReferenceClass(PhoneNumber.class);
>@@ -1588,7 +1584,7 @@
>         query.dontRetrievePrimaryKeys();
>         query.setName("selectEmployeesThatHavePhoneNumbers");
> 
>-        Vector expectedResult = (Vector)em.getActiveSession().executeQuery(query);
>+        Vector expectedResult = (Vector)getServerSession().executeQuery(query);
> 
>         clearCache();
> 
>@@ -1602,7 +1598,7 @@
>     }
> 
>     public void selectOneToOneTest() {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
> 
>         ReadAllQuery query = new ReadAllQuery();
>         query.setReferenceClass(Address.class);
>@@ -1610,7 +1606,7 @@
>         ExpressionBuilder employeeBuilder = new ExpressionBuilder(Employee.class);
>         Expression selectionCriteria = new ExpressionBuilder(Address.class).equal(employeeBuilder.get("address")).and(employeeBuilder.get("lastName").like("%Way%"));
>         query.setSelectionCriteria(selectionCriteria);
>-        Vector expectedResult = (Vector)em.getActiveSession().executeQuery(query);
>+        Vector expectedResult = (Vector)getServerSession().executeQuery(query);
> 
>         clearCache();
> 
>@@ -1625,7 +1621,7 @@
> 
> 
>     public void selectPhonenumberDeclaredInINClauseTest() {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
> 
>         ReadAllQuery query = new ReadAllQuery();
>         ExpressionBuilder employeeBuilder = new ExpressionBuilder(Employee.class);
>@@ -1637,7 +1633,7 @@
>         query.addAscendingOrdering("number");
>         query.addAscendingOrdering("areaCode");
> 
>-        Vector expectedResult = (Vector)em.getActiveSession().executeQuery(query);
>+        Vector expectedResult = (Vector)getServerSession().executeQuery(query);
> 
>         clearCache();
> 
>@@ -1676,7 +1672,7 @@
>         query.setSelectionCriteria(selectionCriteria);
>         query.setReferenceClass(Employee.class);
> 		
>-        Vector expectedResult = (Vector)em.getActiveSession().executeQuery(query);
>+        Vector expectedResult = (Vector)getServerSession().executeQuery(query);
> 		
>         clearCache();
> 
>@@ -1695,7 +1691,7 @@
>      * This test was added to mirror a CTS failure.
>      */
>     public void selectPhoneUsingALLTest() {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
> 
>         ReadAllQuery query = new ReadAllQuery();
>         ExpressionBuilder employeeBuilder = new ExpressionBuilder(Employee.class);
>@@ -1708,7 +1704,7 @@
>         query.setSelectionCriteria(selectionCriteria);
>         query.setReferenceClass(Employee.class);
> 
>-        Vector expectedResult = (Vector)em.getActiveSession().executeQuery(query);
>+        Vector expectedResult = (Vector)getServerSession().executeQuery(query);
> 
>         clearCache();
> 
>@@ -1725,9 +1721,9 @@
>     }
> 
>     public void selectSimpleMemberOfWithParameterTest() {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
> 
>-        Employee expectedResult = (Employee)em.getActiveSession().readObject(Employee.class);
>+        Employee expectedResult = (Employee)getServerSession().readObject(Employee.class);
> 
>         PhoneNumber phone = new PhoneNumber();
>         phone.setAreaCode("613");
>@@ -1761,9 +1757,9 @@
>     }
> 
>     public void selectSimpleNotMemberOfWithParameterTest() {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
> 
>-        Vector expectedResult = em.getActiveSession().readAllObjects(Employee.class);
>+        Vector expectedResult = getServerSession().readAllObjects(Employee.class);
> 
>         clearCache();
> 
>@@ -1802,9 +1798,9 @@
> 
>     public void selectUsingLockModeQueryHintTest() {
>         Exception exception = null;
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
> 
>-        Vector employees = em.getActiveSession().readAllObjects(Employee.class);
>+        Vector employees = getServerSession().readAllObjects(Employee.class);
>         Employee emp1 = (Employee)employees.lastElement();
>         Employee emp2 = new Employee();
> 
>@@ -1823,9 +1819,9 @@
>     }
> 
>     public void selectSimpleBetweenWithParameterTest() {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
> 
>-        Vector employees = em.getActiveSession().readAllObjects(Employee.class);
>+        Vector employees = getServerSession().readAllObjects(Employee.class);
> 
>         BigDecimal empId1 = new BigDecimal(0);
> 
>@@ -1850,9 +1846,9 @@
>     }
> 
>     public void selectSimpleInWithParameterTest() {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
> 
>-        Vector employees = em.getActiveSession().readAllObjects(Employee.class);
>+        Vector employees = getServerSession().readAllObjects(Employee.class);
> 
>         BigDecimal empId1 = new BigDecimal(0);
> 
>@@ -1883,7 +1879,7 @@
>     //Test case for ABS function in EJBQL
> 
>     public void simpleEnumTest() {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
> 
>         String ejbqlString;
> 
>@@ -1893,7 +1889,7 @@
>     }
> 
>     public void selectNamedNativeQueryWithPositionalParameterTest() {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
> 
>         List results_QuestionMark_Number = null;
>         List results_QuestionMark = null;
>@@ -1959,7 +1955,7 @@
>     }
> 
>     public void selectNativeQueryWithPositionalParameterTest() {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager)createEntityManager();
>+        EntityManager em = createEntityManager();
> 
>         List results_QuestionMark_Number = null;
>         List results_QuestionMark = null;
>Index: jpa/eclipselink.jpa.test/src/org/eclipse/persistence/testing/tests/jpa/jpql/JUnitJPQLUnitTestSuite.java
>===================================================================
>--- jpa/eclipselink.jpa.test/src/org/eclipse/persistence/testing/tests/jpa/jpql/JUnitJPQLUnitTestSuite.java	(revision 2560)
>+++ jpa/eclipselink.jpa.test/src/org/eclipse/persistence/testing/tests/jpa/jpql/JUnitJPQLUnitTestSuite.java	(working copy)
>@@ -10,13 +10,20 @@
>  * Contributors:
>  *     Oracle - initial API and implementation from Oracle TopLink
>  ******************************************************************************/  
>-
>-
>- 
> package org.eclipse.persistence.testing.tests.jpa.jpql;
>+
> import java.util.List;
> import java.util.Vector;
> import java.util.Iterator;
>+
>+import junit.framework.Assert;
>+import junit.framework.Test;
>+import junit.framework.TestSuite;
>+import junit.extensions.TestSetup;
>+
>+import javax.persistence.Query;
>+import javax.persistence.EntityManager;
>+
> import org.eclipse.persistence.expressions.Expression;
> import org.eclipse.persistence.expressions.ExpressionBuilder;
> import org.eclipse.persistence.internal.sessions.AbstractSession;
>@@ -26,17 +33,11 @@
> import org.eclipse.persistence.queries.ReportQueryResult;
> import org.eclipse.persistence.testing.models.jpa.advanced.EmployeePopulator;
> import org.eclipse.persistence.testing.framework.junit.JUnitTestCase;
>-import junit.framework.Assert;
>-import junit.framework.Test;
>-import junit.framework.TestSuite;
>-import junit.extensions.TestSetup;
> import org.eclipse.persistence.sessions.DatabaseSession;
> import org.eclipse.persistence.testing.models.jpa.advanced.AdvancedTableCreator;
> import org.eclipse.persistence.testing.models.jpa.advanced.Employee;
> import org.eclipse.persistence.testing.models.jpa.advanced.PhoneNumber;
>-import javax.persistence.Query;
> 
>-
> /**
>  * <p>
>  * <b>Purpose</b>: Test Unit EJBQL functionality.
>@@ -52,7 +53,6 @@
>  * @see JUnitDomainObjectComparer
>  */
>  
>- 
> //This test suite demonstrates the bug 4616218, waiting for bug fix
> public class JUnitJPQLUnitTestSuite extends JUnitTestCase
> { 
>@@ -74,13 +74,13 @@
>       clearCache();
>   }
>   
>-  
>   //This suite contains all tests contained in this class
>   public static Test suite() 
>   {
>     TestSuite suite = new TestSuite();
>     suite.setName("JUnitJPQLUnitTestSuite");
>-    suite.addTest(new JUnitJPQLUnitTestSuite("testSelectPhoneNumberAreaCode"));   
>+    suite.addTest(new JUnitJPQLUnitTestSuite("testSetup"));   
>+    suite.addTest(new JUnitJPQLUnitTestSuite("testSelectPhoneNumberAreaCode"));
>     suite.addTest(new JUnitJPQLUnitTestSuite("testSelectPhoneNumberAreaCodeWithEmployee"));   
>     suite.addTest(new JUnitJPQLUnitTestSuite("testSelectPhoneNumberNumberWithEmployeeWithExplicitJoin"));   
>     suite.addTest(new JUnitJPQLUnitTestSuite("testSelectPhoneNumberNumberWithEmployeeWithFirstNameFirst"));
>@@ -93,51 +93,46 @@
>     suite.addTest(new JUnitJPQLUnitTestSuite("testMaxAndFirstResultsOnDataQuery"));
>     suite.addTest(new JUnitJPQLUnitTestSuite("testMaxAndFirstResultsOnDataQueryWithGroupBy"));
>     suite.addTest(new JUnitJPQLUnitTestSuite("testDistinctSelectForEmployeeWithNullAddress"));
>-
>-     return new TestSetup(suite) {
>-            
>-            //This method is run at the end of the SUITE only
>-            protected void tearDown() {
>-                clearCache();
>-            }
>-            
>-            //This method is run at the start of the SUITE only
>-            protected void setUp() {
>-            
>-                //get session to start setup
>-                DatabaseSession session = JUnitTestCase.getServerSession();
>-                
>-                //create a new EmployeePopulator
>-                EmployeePopulator employeePopulator = new EmployeePopulator();
>-                
>-                new AdvancedTableCreator().replaceTables(session);
>-                
>-                //initialize the global comparer object
>-                comparer = new JUnitDomainObjectComparer();
>-                
>-                //set the session for the comparer to use
>-                comparer.setSession((AbstractSession)session.getActiveSession());              
>-                
>-                //Populate the tables
>-                employeePopulator.buildExamples();
>-                
>-                //Persist the examples in the database
>-                employeePopulator.persistExample(session);               
>-            }            
>-        };
>     
>+    return suite;
>   }
>     
>+    /**
>+     * The setup is done as a test, both to record its failure, and to allow execution in the server.
>+     */
>+    public void testSetup() {
>+        clearCache();
>+        //get session to start setup
>+        DatabaseSession session = JUnitTestCase.getServerSession();
>+        
>+        //create a new EmployeePopulator
>+        EmployeePopulator employeePopulator = new EmployeePopulator();
>+        
>+        new AdvancedTableCreator().replaceTables(session);
>+        
>+        //initialize the global comparer object
>+        comparer = new JUnitDomainObjectComparer();
>+        
>+        //set the session for the comparer to use
>+        comparer.setSession((AbstractSession)session.getActiveSession());              
>+        
>+        //Populate the tables
>+        employeePopulator.buildExamples();
>+        
>+        //Persist the examples in the database
>+        employeePopulator.persistExample(session);
>+    }
>+    
>     public Vector getAttributeFromAll(String attributeName, Vector objects, Class referenceClass){
>-	   
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager) createEntityManager();
>+    
>+        EntityManager em = createEntityManager();
>         
>-        ClassDescriptor descriptor = em.getActiveSession().getClassDescriptor(referenceClass);
>-	    DirectToFieldMapping mapping = (DirectToFieldMapping)descriptor.getMappingForAttributeName(attributeName);
>-	    
>-	    Vector attributes = new Vector();
>-	    Object currentObject;
>-	    for(int i = 0; i < objects.size(); i++) {
>+        ClassDescriptor descriptor = getServerSession().getClassDescriptor(referenceClass);
>+        DirectToFieldMapping mapping = (DirectToFieldMapping)descriptor.getMappingForAttributeName(attributeName);
>+        
>+        Vector attributes = new Vector();
>+        Object currentObject;
>+        for(int i = 0; i < objects.size(); i++) {
>             currentObject = objects.elementAt(i);
>             if(currentObject.getClass() == ReportQueryResult.class) {
>                 attributes.addElement(
>@@ -146,12 +141,12 @@
>                 attributes.addElement(
>                     mapping.getAttributeValueFromObject(currentObject));
>             }
>-	    }
>-	    return attributes;
>-	}
>+        }
>+        return attributes;
>+    }
>     
>     public void testFirstResultOnNamedQuery(){
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager) createEntityManager();
>+        EntityManager em = createEntityManager();
>         clearCache();
> 
>         Query query = em.createNamedQuery("findAllEmployeesByFirstName");
>@@ -161,16 +156,16 @@
> 
>         Iterator i = initialList.iterator();
>         while (i.hasNext()){
>-        	assertTrue("Employee with incorrect name returned on first query.", ((Employee)i.next()).getFirstName().equals("Nancy"));
>+            assertTrue("Employee with incorrect name returned on first query.", ((Employee)i.next()).getFirstName().equals("Nancy"));
>         }
>         i = secondList.iterator();
>         while (i.hasNext()){
>-        	assertTrue("Employee with incorrect name returned on second query.", ((Employee)i.next()).getFirstName().equals("Nancy"));
>+            assertTrue("Employee with incorrect name returned on second query.", ((Employee)i.next()).getFirstName().equals("Nancy"));
>         }
>     }
>     
>     public void testOuterJoinOnOneToOne(){
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager) createEntityManager();
>+        EntityManager em = createEntityManager();
>         clearCache();
>         beginTransaction(em);
>         int initialSize = em.createQuery("SELECT e from Employee e JOIN e.address a").getResultList().size(); 
>@@ -185,7 +180,7 @@
>     }
> 
>     public void testOuterJoinPolymorphic(){
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager) createEntityManager();
>+        EntityManager em = createEntityManager();
>         clearCache();
>         List resultList = null;
>         try{
>@@ -201,56 +196,56 @@
>   {
>         
>         ExpressionBuilder employeeBuilder = new ExpressionBuilder();
>-		Expression phones = employeeBuilder.anyOf("phoneNumbers");
>-    	Expression whereClause = phones.get("areaCode").equal("613");
>-    	    
>-    	ReportQuery rq = new ReportQuery();
>-    	rq.setSelectionCriteria(whereClause);
>-		rq.addAttribute("areaCode", new ExpressionBuilder().anyOf("phoneNumbers").get("areaCode"));
>-    	rq.setReferenceClass(Employee.class);    
>+        Expression phones = employeeBuilder.anyOf("phoneNumbers");
>+        Expression whereClause = phones.get("areaCode").equal("613");
>+            
>+        ReportQuery rq = new ReportQuery();
>+        rq.setSelectionCriteria(whereClause);
>+        rq.addAttribute("areaCode", new ExpressionBuilder().anyOf("phoneNumbers").get("areaCode"));
>+        rq.setReferenceClass(Employee.class);    
>         rq.dontUseDistinct(); // distinct no longer used on joins in JPQL for gf bug 1395
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager) createEntityManager();
>-        Vector expectedResult = getAttributeFromAll("areaCode", (Vector)em.getActiveSession().executeQuery(rq),Employee.class);
>+        EntityManager em = createEntityManager();
>+        Vector expectedResult = getAttributeFromAll("areaCode", (Vector)getServerSession().executeQuery(rq),Employee.class);
>         
>         clearCache();
>         
>         List result = em.createQuery("SELECT phone.areaCode FROM Employee employee, IN (employee.phoneNumbers) phone " + 
>-		    "WHERE phone.areaCode = \"613\"").getResultList();                     
>+            "WHERE phone.areaCode = \"613\"").getResultList();                     
>       
>-        Assert.assertTrue("SimpleSelectPhoneNumberAreaCode test failed !", comparer.compareObjects(result,expectedResult));    	
>+        Assert.assertTrue("SimpleSelectPhoneNumberAreaCode test failed !", comparer.compareObjects(result,expectedResult));        
>   }
>   
>   
>     public void testSelectPhoneNumberAreaCodeWithEmployee()
>     {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager) createEntityManager();
>+        EntityManager em = createEntityManager();
>         ExpressionBuilder employees = new ExpressionBuilder();
>         Expression exp = employees.get("firstName").equal("Bob");
>         exp = exp.and(employees.get("lastName").equal("Smith"));
>-        Employee emp = (Employee) em.getActiveSession().readAllObjects(Employee.class, exp).firstElement();
>+        Employee emp = (Employee) getServerSession().readAllObjects(Employee.class, exp).firstElement();
>     
>         PhoneNumber phone = (PhoneNumber) ((Vector)emp.getPhoneNumbers()).firstElement();
>         String areaCode = phone.getAreaCode();
>         String firstName = emp.getFirstName();
> 
>-		ExpressionBuilder employeeBuilder = new ExpressionBuilder();
>-		Expression phones = employeeBuilder.anyOf("phoneNumbers");
>-    	Expression whereClause = phones.get("areaCode").equal(areaCode).and(
>-    	phones.get("owner").get("firstName").equal(firstName));
>-    	    
>-    	ReportQuery rq = new ReportQuery();
>-    	rq.setSelectionCriteria(whereClause);
>-    	rq.addAttribute("areaCode", phones.get("areaCode"));
>-		rq.setReferenceClass(Employee.class);
>-    	rq.dontMaintainCache();
>-    	
>-        Vector expectedResult = getAttributeFromAll("areaCode", (Vector)em.getActiveSession().executeQuery(rq),Employee.class);   	
>+        ExpressionBuilder employeeBuilder = new ExpressionBuilder();
>+        Expression phones = employeeBuilder.anyOf("phoneNumbers");
>+        Expression whereClause = phones.get("areaCode").equal(areaCode).and(
>+        phones.get("owner").get("firstName").equal(firstName));
>+            
>+        ReportQuery rq = new ReportQuery();
>+        rq.setSelectionCriteria(whereClause);
>+        rq.addAttribute("areaCode", phones.get("areaCode"));
>+        rq.setReferenceClass(Employee.class);
>+        rq.dontMaintainCache();
>         
>-    	clearCache();
>+        Vector expectedResult = getAttributeFromAll("areaCode", (Vector)getServerSession().executeQuery(rq),Employee.class);       
>+        
>+        clearCache();
>     
>-    	String ejbqlString;
>-    	ejbqlString = "SELECT phone.areaCode FROM Employee employee, IN (employee.phoneNumbers) phone " + 
>-		    "WHERE phone.areaCode = \"" + areaCode + "\" AND phone.owner.firstName = \"" + firstName + "\"";    
>+        String ejbqlString;
>+        ejbqlString = "SELECT phone.areaCode FROM Employee employee, IN (employee.phoneNumbers) phone " + 
>+            "WHERE phone.areaCode = \"" + areaCode + "\" AND phone.owner.firstName = \"" + firstName + "\"";    
>         
>         List result = em.createQuery(ejbqlString).getResultList();                     
>         
>@@ -260,35 +255,35 @@
>     
>     public void testSelectPhoneNumberNumberWithEmployeeWithExplicitJoin()
>     {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager) createEntityManager();
>+        EntityManager em = createEntityManager();
>         ExpressionBuilder employees = new ExpressionBuilder();
>         Expression exp = employees.get("firstName").equal("Bob");
>         exp = exp.and(employees.get("lastName").equal("Smith"));
>-        Employee emp = (Employee) em.getActiveSession().readAllObjects(Employee.class, exp).firstElement();
>+        Employee emp = (Employee) getServerSession().readAllObjects(Employee.class, exp).firstElement();
>     
>         PhoneNumber phone = (PhoneNumber) ((Vector)emp.getPhoneNumbers()).firstElement();
>         String areaCode = phone.getAreaCode();
>         String firstName = emp.getFirstName();
>         
>         ExpressionBuilder employeeBuilder = new ExpressionBuilder(Employee.class);
>-		Expression phones = employeeBuilder.anyOf("phoneNumbers");
>-    	Expression whereClause = phones.get("areaCode").equal(areaCode).and(
>-    	    phones.get("owner").get("id").equal(employeeBuilder.get("id")).and(
>-    	        employeeBuilder.get("firstName").equal(firstName)));
>+        Expression phones = employeeBuilder.anyOf("phoneNumbers");
>+        Expression whereClause = phones.get("areaCode").equal(areaCode).and(
>+            phones.get("owner").get("id").equal(employeeBuilder.get("id")).and(
>+                employeeBuilder.get("firstName").equal(firstName)));
> 
>-    	
>-    	ReportQuery rq = new ReportQuery();
>-		rq.addAttribute("number", new ExpressionBuilder().anyOf("phoneNumbers").get("number"));
>-    	rq.setSelectionCriteria(whereClause);
>-		rq.setReferenceClass(Employee.class);
>-    	
>-        Vector expectedResult = getAttributeFromAll("number", (Vector)em.getActiveSession().executeQuery(rq),Employee.class);
>         
>-    	clearCache();    	
>+        ReportQuery rq = new ReportQuery();
>+        rq.addAttribute("number", new ExpressionBuilder().anyOf("phoneNumbers").get("number"));
>+        rq.setSelectionCriteria(whereClause);
>+        rq.setReferenceClass(Employee.class);
>+        
>+        Vector expectedResult = getAttributeFromAll("number", (Vector)getServerSession().executeQuery(rq),Employee.class);
>+        
>+        clearCache();        
>     
>-    	String ejbqlString;
>-    	ejbqlString = "SELECT phone.number FROM Employee employee, IN (employee.phoneNumbers) phone " + 
>-    		"WHERE phone.areaCode = \"" + areaCode + "\" AND (phone.owner.id = employee.id AND employee.firstName = \"" + firstName + "\")";
>+        String ejbqlString;
>+        ejbqlString = "SELECT phone.number FROM Employee employee, IN (employee.phoneNumbers) phone " + 
>+            "WHERE phone.areaCode = \"" + areaCode + "\" AND (phone.owner.id = employee.id AND employee.firstName = \"" + firstName + "\")";
>     
>         List result = em.createQuery(ejbqlString).getResultList();                     
>         
>@@ -298,33 +293,33 @@
>     
>     public void testSelectPhoneNumberNumberWithEmployeeWithFirstNameFirst()
>     {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager) createEntityManager();
>+        EntityManager em = createEntityManager();
>         ExpressionBuilder employees = new ExpressionBuilder();
>         Expression exp = employees.get("firstName").equal("Bob");
>         exp = exp.and(employees.get("lastName").equal("Smith"));
>-        Employee emp = (Employee) em.getActiveSession().readAllObjects(Employee.class, exp).firstElement();
>+        Employee emp = (Employee) getServerSession().readAllObjects(Employee.class, exp).firstElement();
>     
>         PhoneNumber phone = (PhoneNumber) ((Vector)emp.getPhoneNumbers()).firstElement();
>         String areaCode = phone.getAreaCode();
>         String firstName = emp.getFirstName();
>         
>         ExpressionBuilder employeeBuilder = new ExpressionBuilder();
>-		Expression phones = employeeBuilder.anyOf("phoneNumbers");
>-    	Expression whereClause = phones.get("owner").get("firstName").equal(firstName).and(
>-            	phones.get("areaCode").equal(areaCode));
>-    	
>-    	ReportQuery rq = new ReportQuery();
>-    	rq.setSelectionCriteria(whereClause);
>-    	rq.addAttribute("number", phones.get("number"));
>-		rq.setReferenceClass(Employee.class);
>-		
>-        Vector expectedResult = getAttributeFromAll("number", (Vector)em.getActiveSession().executeQuery(rq),Employee.class);	
>+        Expression phones = employeeBuilder.anyOf("phoneNumbers");
>+        Expression whereClause = phones.get("owner").get("firstName").equal(firstName).and(
>+                phones.get("areaCode").equal(areaCode));
>         
>+        ReportQuery rq = new ReportQuery();
>+        rq.setSelectionCriteria(whereClause);
>+        rq.addAttribute("number", phones.get("number"));
>+        rq.setReferenceClass(Employee.class);
>+        
>+        Vector expectedResult = getAttributeFromAll("number", (Vector)getServerSession().executeQuery(rq),Employee.class);    
>+        
>         clearCache();
>         
>-    	String ejbqlString;
>-    	ejbqlString = "SELECT phone.number FROM Employee employee, IN(employee.phoneNumbers) phone " + 
>-		    "WHERE phone.owner.firstName = \"" + firstName + "\" AND phone.areaCode = \"" + areaCode + "\"";
>+        String ejbqlString;
>+        ejbqlString = "SELECT phone.number FROM Employee employee, IN(employee.phoneNumbers) phone " + 
>+            "WHERE phone.owner.firstName = \"" + firstName + "\" AND phone.areaCode = \"" + areaCode + "\"";
>             
>         List result = em.createQuery(ejbqlString).getResultList();                     
>         
>@@ -367,7 +362,7 @@
>      * throws an SQl exception.
>      */
>     public void testMaxAndFirstResultsOnDataQuery(){
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager) createEntityManager();
>+        EntityManager em = createEntityManager();
>         Exception exception = null;
>         List resultList = null;
>         clearCache();
>@@ -389,7 +384,7 @@
>      * throws an SQl exception.
>      */
>     public void testMaxAndFirstResultsOnDataQueryWithGroupBy() {
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager) createEntityManager();
>+        EntityManager em = createEntityManager();
>         Exception exception = null;
>         List resultList = null;
>         clearCache();
>@@ -427,7 +422,7 @@
>      * For GF3233, Distinct process fail with NPE when relationship has NULL-valued target.
>      */
>     public void testDistinctSelectForEmployeeWithNullAddress(){
>-        org.eclipse.persistence.jpa.JpaEntityManager em = (org.eclipse.persistence.jpa.JpaEntityManager) createEntityManager();
>+        EntityManager em = createEntityManager();
>         try {
>             beginTransaction(em);
>             Employee emp = new Employee();
>Index: jpa/eclipselink.jpa.test/src/org/eclipse/persistence/testing/tests/jpa/jpql/JUnitJPQLValidationTestSuite.java
>===================================================================
>--- jpa/eclipselink.jpa.test/src/org/eclipse/persistence/testing/tests/jpa/jpql/JUnitJPQLValidationTestSuite.java	(revision 2560)
>+++ jpa/eclipselink.jpa.test/src/org/eclipse/persistence/testing/tests/jpa/jpql/JUnitJPQLValidationTestSuite.java	(working copy)
>@@ -81,6 +81,7 @@
>     {
>         TestSuite suite = new TestSuite();
>         suite.setName("JUnitJPQLValidationTestSuite");
>+        suite.addTest(new JUnitJPQLValidationTestSuite("testSetup"));
>         suite.addTest(new JUnitJPQLValidationTestSuite("generalExceptionTest"));
>         suite.addTest(new JUnitJPQLValidationTestSuite("recognitionExceptionTest"));
>         suite.addTest(new JUnitJPQLValidationTestSuite("missingSelectExceptionTest"));
>@@ -125,39 +126,36 @@
>         suite.addTest(new JUnitJPQLValidationTestSuite("testInvalidSetClause"));
>         suite.addTest(new JUnitJPQLValidationTestSuite("testUnsupportedCountDistinctOnOuterJoinedCompositePK"));
>         suite.addTest(new JUnitJPQLValidationTestSuite("testInvalidHint"));
>-        return new TestSetup(suite) {
>-     
>-            //This method is run at the end of the SUITE only
>-            protected void tearDown() {
>-                clearCache();
>-            }
>-            
>-            //This method is run at the start of the SUITE only
>-            protected void setUp() {
>-                
>-                //get session to start setup
>-                DatabaseSession session = JUnitTestCase.getServerSession();
>-                
>-                //create a new EmployeePopulator
>-                EmployeePopulator employeePopulator = new EmployeePopulator();
>-                
>-                new AdvancedTableCreator().replaceTables(session);
>-                
>-                //initialize the global comparer object
>-                comparer = new JUnitDomainObjectComparer();
>-                
>-                //set the session for the comparer to use
>-                comparer.setSession((AbstractSession)session.getActiveSession());              
>-                
>-                //Populate the tables
>-                employeePopulator.buildExamples();
>-                
>-                //Persist the examples in the database
>-                employeePopulator.persistExample(session);     
>-            }            
>-        };    
>-  }
>-  
>+        
>+        return suite;
>+    }
>+    
>+    /**
>+     * The setup is done as a test, both to record its failure, and to allow execution in the server.
>+     */
>+    public void testSetup() {
>+        clearCache();
>+        //get session to start setup
>+        DatabaseSession session = JUnitTestCase.getServerSession();
>+        
>+        //create a new EmployeePopulator
>+        EmployeePopulator employeePopulator = new EmployeePopulator();
>+        
>+        new AdvancedTableCreator().replaceTables(session);
>+        
>+        //initialize the global comparer object
>+        comparer = new JUnitDomainObjectComparer();
>+        
>+        //set the session for the comparer to use
>+        comparer.setSession((AbstractSession)session.getActiveSession());              
>+        
>+        //Populate the tables
>+        employeePopulator.buildExamples();
>+        
>+        //Persist the examples in the database
>+        employeePopulator.persistExample(session);
>+    }
>+    
>     public void illegalArgumentExceptionTest() 
>     {
>         
>@@ -545,7 +543,7 @@
>         }
>     }
> 
>-	public void unknownAbstractSchemaTypeTest()
>+    public void unknownAbstractSchemaTypeTest()
>     {
>         String ejbqlString =  " SELECT OBJECT(i) FROM Integer i WHERE i.city = \"Ottawa\"";
>         
>@@ -597,19 +595,20 @@
>         Query query = em.createQuery("Select e from Employee e where e.lastName like :name ");
>         try{
>             query.setParameter("l", "%ay");
>+            query.getResultList();
>         }catch (IllegalArgumentException ex){
>             assertTrue("Failed to throw expected IllegalArgumentException, when incorrect parameter name is used", ex.getMessage().contains("using a name"));
>             return;
>         }
>         fail("Failed to throw expected IllegalArgumentException, when incorrect parameter name is used");
>     }
>-    
>    
>     public void testParameterPositionValidation(){
>         EntityManager em = this.createEntityManager();
>         Query query = em.createQuery("Select e from Employee e where e.firstName like ?1 ");
>         try{
>             query.setParameter(2, "%ay");
>+            query.getResultList();
>         }catch (IllegalArgumentException ex){
>             assertTrue("Failed to throw expected IllegalArgumentException, when incorrect parameter name is used", ex.getMessage().contains("parameter at position"));
>             return;
>@@ -625,6 +624,7 @@
>             query.setParameter(1, "foo");
>             query.setParameter(2, "");
>             query.setParameter(3, "bar");
>+            query.getResultList();
>         } catch (IllegalArgumentException ex) {
>             assertTrue("Failed to throw expected IllegalArgumentException, when incorrect parameter name is used", ex.getMessage().contains("parameter at position"));
>             return;
>@@ -638,6 +638,7 @@
>         try {
>             query.setParameter("fname", "foo");
>             query.setParameter("lname", new Integer(1));
>+            query.getResultList();
>         } catch (IllegalArgumentException ex) {
>             assertTrue("Failed to throw expected IllegalArgumentException, when parameter with incorrect type is used", ex.getMessage().contains("attempted to set a value of type"));
>             return;
>@@ -807,7 +808,9 @@
>     public void testUnknownEnumConstant() {
>         EntityManager em = this.createEntityManager();
>         try {
>-            em.createQuery("SELECT e FROM Employee e WHERE e.status = EmployeeStatus.FULL_TIME");
>+            //em.createQuery("SELECT e FROM Employee e WHERE e.status = EmployeeStatus.FULL_TIME");
>+            Query query = em.createQuery("SELECT e FROM Employee e WHERE e.status = EmployeeStatus.FULL_TIME");
>+            query.getResultList();
>             fail("Failed to throw expected IllegalArgumentException for a query"+
>                 "unknown enumerated class constant.");
>         } catch (IllegalArgumentException ex) {
>@@ -817,15 +820,16 @@
>         }
>     }
> 
>-
>-
>-
>   /**
>    * For this test you need to add a persistence unit named default1 in the persistence.xml file
>    * in essentials_testmodels.jar.
>    */
>-  public void flushOptimisticLockExceptionTest()
>+    public void flushOptimisticLockExceptionTest()
>     {
>+        if (isOnServer()) {
>+            // Multi-persistece-unit not work on server.
>+            return;
>+        }
>         EntityManager firstEm = createEntityManager();        
>         EntityManager secondEm = createAlternateEntityManager();
>         
>@@ -871,10 +875,12 @@
>     
>      /* For this test you need to add a persistence unit named default1 in the persistence.xml file 
>        in essentials_testmodels.jar */   
>-  
>-
>-  public void commitOptimisticLockExceptionTest()
>+    public void commitOptimisticLockExceptionTest()
>     {
>+          if (isOnServer()) {
>+            // Multi-persistece-unit not work on server.
>+            return;
>+        }
>         EntityManager firstEm = createEntityManager();        
>         EntityManager secondEm = createAlternateEntityManager();
>         
>@@ -921,6 +927,10 @@
>     //this test fakes a JTA transaction
>     public void JTAOptimisticLockExceptionTest() 
>     {
>+        if (isOnServer()) {
>+            // Multi-persistece-unit not work on server.
>+            return;
>+        }
>         EntityManager firstEm = createEntityManager();        
>         EntityManager secondEm = createAlternateEntityManager();
>         
>@@ -1110,6 +1120,10 @@
> 
>     public void testCommitRollbackException() 
>     {
>+        if (isOnServer()) {
>+            // Cannot create parallel entity managers in the server.
>+            return;
>+        }
>         EntityManager em = createEntityManager();
>         String ejbqlString = "SELECT OBJECT (emp) FROM Employee emp WHERE emp.firstName='Bob'";
>         DirectToFieldMapping idMapping = null;
>Index: jpa/eclipselink.jpa.test/src/org/eclipse/persistence/testing/tests/jpa/jpql/ServerTestSuite.java
>===================================================================
>--- jpa/eclipselink.jpa.test/src/org/eclipse/persistence/testing/tests/jpa/jpql/ServerTestSuite.java	(revision 0)
>+++ jpa/eclipselink.jpa.test/src/org/eclipse/persistence/testing/tests/jpa/jpql/ServerTestSuite.java	(revision 0)
>@@ -0,0 +1,40 @@
>+/*******************************************************************************
>+ * Copyright (c) 1998, 2008 Oracle. All rights reserved.
>+ * This program and the accompanying materials are made available under the 
>+ * terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0 
>+ * which accompanies this distribution. 
>+ * The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
>+ * and the Eclipse Distribution License is available at 
>+ * http://www.eclipse.org/org/documents/edl-v10.php.
>+ *
>+ * Contributors:
>+ *     Oracle - initial API and implementation from Oracle TopLink
>+ ******************************************************************************/  
>+package org.eclipse.persistence.testing.tests.jpa.jpql;
>+
>+import junit.framework.TestSuite;
>+import junit.framework.Test;
>+
>+/**
>+ * <p><b>Purpose</b>: To collect the tests that will run against Application Server only.
>+ */
>+public class ServerTestSuite extends TestSuite {
>+    
>+    public static Test suite() {
>+        TestSuite suite = new TestSuite();
>+        suite.setName("JPQL ServerTestSuite");
>+        suite.addTest(AdvancedQueryTestSuite.suite());
>+        /**suite.addTest(JUnitJPQLComplexAggregateTestSuite.suite());
>+        suite.addTest(JUnitJPQLComplexTestSuite.suite());
>+        suite.addTest(JUnitJPQLDateTimeTestSuite.suite());
>+        suite.addTest(JUnitJPQLExamplesTestSuite.suite());
>+        suite.addTest(JUnitJPQLInheritanceTestSuite.suite());
>+        suite.addTest(JUnitJPQLModifyTestSuite.suite());
>+        suite.addTest(JUnitJPQLParameterTestSuite.suite());
>+        suite.addTest(JUnitJPQLSimpleTestSuite.suite());
>+        suite.addTest(JUnitJPQLUnitTestSuite.suite());
>+        suite.addTest(JUnitJPQLValidationTestSuite.suite());*/
>+
>+        return suite;
>+    }
>+}

Actions: View | Diff

Attachments on bug 242289: 108692 | 108752 | 114045 | 115148 | 117483 | 119562 | 121081