Attachment #173657 for bug #319134




        <antcall target="server-test-ddlgeneration" inheritRefs="true"/>
        <antcall target="server-test-cascadedeletes" inheritRefs="true"/>
        <antcall target="server-test-delimited" inheritRefs="true"/>
        <antcall target="server-test-fetchgroups" inheritRefs="true"/>
        <antcall target="server-test-fieldaccess-advanced" inheritRefs="true"/>
        <antcall target="server-test-fieldaccess-relationships" inheritRefs="true"/>
        <antcall target="server-test-inheritance" inheritRefs="true"/>

        </antcall>
    </target>

    <target name="server-test-fetchgroups">
        <antcall target="server-run-all" inheritRefs="true">
            <param name="PERSISTENCE_UNIT_NAME" value="default"/>
            <param name="MODEL_DIR" value="org/eclipse/persistence/testing/models/jpa/advanced"/>
            <param name="MODEL_NAME" value="eclipselink-fetchgroups-model"/>
            <param name="TEST_DIR" value="org/eclipse/persistence/testing/tests/jpa/fetchgroups"/>
            <param name="TEST_NAME" value="eclipselink-fetchgroups-model"/>
            <param name="EAR_NAME" value="eclipselink-fetchgroups-model"/>
            <param name="TEST_SUITE" value="org.eclipse.persistence.testing.tests.jpa.fetchgroups.FetchGroupsServerTestSuite"/>
            <param name="eclipselink.jpa.test.dir" value="."/>
        </antcall>
    </target>

    <target name="server-test-fieldaccess-advanced">
        <antcall target="server-run-all" inheritRefs="true">
            <param name="PERSISTENCE_UNIT_NAME" value="fieldaccess"/>

Lines 13-18 Link Here

(-)jpa/eclipselink.jpa.test/src/org/eclipse/persistence/testing/tests/jpa/advanced/AdvancedServerTestSuite.java (+4 lines)
13	package org.eclipse.persistence.testing.tests.jpa.advanced;	13	package org.eclipse.persistence.testing.tests.jpa.advanced;
14		14
15	import org.eclipse.persistence.testing.tests.jpa.advanced.compositepk.AdvancedCompositePKJunitTest;	15	import org.eclipse.persistence.testing.tests.jpa.advanced.compositepk.AdvancedCompositePKJunitTest;
		16	import org.eclipse.persistence.testing.tests.jpa.advanced.fetchgroup.AdvancedFetchGroupJunitTest;
16	import org.eclipse.persistence.testing.framework.junit.JUnitTestCase;	17	import org.eclipse.persistence.testing.framework.junit.JUnitTestCase;
17		18
18	import junit.framework.TestSuite;	19	import junit.framework.TestSuite;
Lines 40-45 Link Here
40	suite.addTest(AdvancedJunitTest.suite());	41	suite.addTest(AdvancedJunitTest.suite());
41	suite.addTest(AdvancedCompositePKJunitTest.suite());	42	suite.addTest(AdvancedCompositePKJunitTest.suite());
42	suite.addTest(QueryCastTestSuite.suite());	43	suite.addTest(QueryCastTestSuite.suite());
		44	if (! JUnitTestCase.isJPA10()) {
		45	suite.addTest(AdvancedFetchGroupJunitTest.suite());
		46	}
43	return suite;	47	return suite;
44	}	48	}
45	}	49	}




        super(name);
    }

    /*
     * Fetch Group tests require weaving.
     */
    public void runBare() throws Throwable {
        if (isWeavingEnabled()) {
            super.runBare();
        }
    }

    /**
     * Any FetchGroups setup in test cases are removed.
     * Descriptors should not be isolated.

    }
    
    protected QuerySQLTracker getQuerySQLTracker(EntityManager em) {
        return QuerySQLTracker.getTracker(getServerSession());
                .getActiveSession());
    }

    ClassDescriptor getDescriptor(String entityName) {




import java.util.Map;

import javax.persistence.EntityManagerFactory;
import org.eclipse.persistence.testing.framework.junit.JUnitTestCase;

import org.eclipse.persistence.descriptors.ClassDescriptor;
import org.eclipse.persistence.descriptors.VersionLockingPolicy;

     */
    public static boolean isValid(FetchGroup fetchGroup, EntityManagerFactory emf, Class<?> entityClass) {
        assertNotNull(fetchGroup);
        Session session = JUnitTestCase.getServerSession();
        ClassDescriptor descriptor = session.getDescriptor(entityClass);
        try {
            for (Map.Entry<String, AttributeItem> entry : fetchGroup.getItems().entrySet()) {

    public static void assertFetchedAttribute(EntityManagerFactory emf, Object entity, String... attribute) {
        assertNotNull("EntityManagerFactory is null", emf);
        assertNotNull("Entity is null", entity);
        Server session = JUnitTestCase.getServerSession();
        assertNotNull("No Server session found for: " + emf, session);
        ClassDescriptor desc = session.getClassDescriptor(entity);
        assertNotNull("No descriptor found for: " + entity, desc);

    public static void assertNotFetchedAttribute(EntityManagerFactory emf, Object entity, String... attribute) {
        assertNotNull("EntityManagerFactory is null", emf);
        assertNotNull("Entity is null", entity);
        Server session = JUnitTestCase.getServerSession();
        assertNotNull("No Server session found for: " + emf, session);
        ClassDescriptor desc = session.getClassDescriptor(entity);
        assertNotNull("No descriptor found for: " + entity, desc);

        }
        assertTrue("FetchGroup on entity does not equal provided", tracker._persistence_getFetchGroup().equals(groupToCompare));

        Server session = JUnitTestCase.getServerSession();
        assertNotNull(session);
        ClassDescriptor descriptor = session.getClassDescriptor(entity);
        assertNotNull(descriptor);

    public static void assertDefaultFetched(EntityManagerFactory emf, Object entity) {
        assertNotNull("Null entity", entity);

        ClassDescriptor descriptor = JUnitTestCase.getServerSession().getClassDescriptor(entity);
        assertNotNull("No descriptor found for: " + entity, descriptor);

        assertTrue("No FetchGroupManager on: " + descriptor, descriptor.hasFetchGroupManager());

    public static void assertFetched(EntityManagerFactory emf, Object entity, String fetchGroupName) {
        assertNotNull("Null entity", entity);

        ClassDescriptor descriptor = JUnitTestCase.getServerSession().getClassDescriptor(entity);
        assertNotNull("No descriptor found for: " + entity, descriptor);

        assertTrue("No FetchGroupManager on: " + descriptor, descriptor.hasFetchGroupManager());

    }

    public static void assertConfig(EntityManagerFactory emf, String entityName, FetchGroup defaultFetchGroup, int numNamedFetchGroups) {
        ClassDescriptor descriptor = JUnitTestCase.getServerSession().getClassDescriptorForAlias(entityName);
        assertNotNull("Not descriptor found for: " + entityName, descriptor);
        assertConfig(descriptor, defaultFetchGroup, numNamedFetchGroups);
    }




/*******************************************************************************
 * Copyright (c) 1998, 2010 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.fetchgroups;

import junit.framework.TestSuite;
import junit.framework.Test;
import org.eclipse.persistence.testing.framework.junit.JUnitTestCase;

/**
 * <p><b>Purpose</b>: To collect the tests that will run against Application Server only.
 */
public class FetchGroupsServerTestSuite extends TestSuite {
    
    public static Test suite() {
        TestSuite suite = new TestSuite();
        suite.setName("FetchGroups ServerTestSuite");
        suite.addTest(FetchGroupAPITests.suite());
        suite.addTest(FetchGroupTrackerWeavingTests.suite()); 
        suite.addTest(NestedFetchGroupTests.suite());
        suite.addTest(NestedNamedFetchGroupTests.suite());
        suite.addTest(SimpleDefaultFetchGroupTests.suite()); 
        suite.addTest(SimpleNamedFetchGroupTests.suite());
        if (! JUnitTestCase.isJPA10()) {
            suite.addTest(FetchGroupMergeWithCacheTests.suite());
            suite.addTest(NestedDefaultFetchGroupTests.suite());
            suite.addTest(SimpleFetchGroupTests.suite());
            suite.addTest(SimpleSerializeFetchGroupTests.suite());
        }
        return suite;
    }
}




    public FetchGroupTrackerWeavingTests(String name) {
        super(name);
    }
    
    /*
     * Fetch Group tests require weaving.
     */
    public void runBare() throws Throwable {
        if (isWeavingEnabled()) {
            super.runBare();
        }
    }

    public static junit.framework.Test suite() {
        TestSuite suite = new TestSuite();

Lines 117-122 Link Here

(-)jpa/eclipselink.jpa.test/src/org/eclipse/persistence/testing/tests/jpa/fetchgroups/NestedDefaultFetchGroupTests.java (+4 lines)
117		117
118	void internalFindMinEmployee(boolean loadAddress, boolean loadPhones, boolean useLoadGroup) {	118	void internalFindMinEmployee(boolean loadAddress, boolean loadPhones, boolean useLoadGroup) {
119	EntityManager em = createEntityManager();	119	EntityManager em = createEntityManager();
		120	beginTransaction(em);
		121
120	int minId = minEmployeeIdWithAddressAndPhones(em);	122	int minId = minEmployeeIdWithAddressAndPhones(em);
121	assertEquals(1, getQuerySQLTracker(em).getTotalSQLSELECTCalls());	123	assertEquals(1, getQuerySQLTracker(em).getTotalSQLSELECTCalls());
122		124
Lines 189-194 Link Here
189	}	191	}
190	}	192	}
191	}	193	}
		194	commitTransaction(em);
		195	closeEntityManager(em);
192	}	196	}
193	/* void internalFindMinEmployee(boolean loadAddress, boolean loadPhones) {	197	/* void internalFindMinEmployee(boolean loadAddress, boolean loadPhones) {
194	EntityManager em = createEntityManager();	198	EntityManager em = createEntityManager();

Lines 97-102 Link Here

(-)jpa/eclipselink.jpa.test/src/org/eclipse/persistence/testing/tests/jpa/fetchgroups/NestedFetchGroupTests.java (-2 / +29 lines)
97	@Test	97	@Test
98	public void dynamicFetchGroup_EmployeeAddress() throws Exception {	98	public void dynamicFetchGroup_EmployeeAddress() throws Exception {
99	EntityManager em = createEntityManager();	99	EntityManager em = createEntityManager();
		100	beginTransaction(em);
100		101
101	Query query = em.createQuery("SELECT e FROM Employee e WHERE e.gender = :GENDER");	102	Query query = em.createQuery("SELECT e FROM Employee e WHERE e.gender = :GENDER");
102	query.setParameter("GENDER", Gender.Male);	103	query.setParameter("GENDER", Gender.Male);
Lines 161-171 Link Here
161	assertFalse(phoneTracker._persistence_isAttributeFetched("areaCode"));	162	assertFalse(phoneTracker._persistence_isAttributeFetched("areaCode"));
162	}	163	}
163	}	164	}
		165	commitTransaction(em);
		166	closeEntityManager(em);
164	}	167	}
165		168
166	@Test	169	@Test
167	public void dynamicFetchGroup_Employee_NullAddress() throws Exception {	170	public void dynamicFetchGroup_Employee_NullAddress() throws Exception {
168	EntityManager em = createEntityManager();	171	EntityManager em = createEntityManager();
		172	beginTransaction(em);
169		173
170	Query query = em.createQuery("SELECT e FROM Employee e WHERE e.gender = :GENDER");	174	Query query = em.createQuery("SELECT e FROM Employee e WHERE e.gender = :GENDER");
171	query.setParameter("GENDER", Gender.Male);	175	query.setParameter("GENDER", Gender.Male);
Lines 224-234 Link Here
224	assertFalse(phoneTracker._persistence_isAttributeFetched("areaCode"));	228	assertFalse(phoneTracker._persistence_isAttributeFetched("areaCode"));
225	}	229	}
226	}	230	}
		231	commitTransaction(em);
		232	closeEntityManager(em);
227	}	233	}
228		234
229	@Test	235	@Test
230	public void dynamicFetchGroup_EmployeeAddressNullPhone() throws Exception {	236	public void dynamicFetchGroup_EmployeeAddressNullPhone() throws Exception {
231	EntityManager em = createEntityManager();	237	EntityManager em = createEntityManager();
		238	beginTransaction(em);
232		239
233	Query query = em.createQuery("SELECT e FROM Employee e WHERE e.gender = :GENDER");	240	Query query = em.createQuery("SELECT e FROM Employee e WHERE e.gender = :GENDER");
234	query.setParameter("GENDER", Gender.Male);	241	query.setParameter("GENDER", Gender.Male);
Lines 290-295 Link Here
290	assertNull("PhoneNumber has a FetchGroup", phoneTracker._persistence_getFetchGroup());	297	assertNull("PhoneNumber has a FetchGroup", phoneTracker._persistence_getFetchGroup());
291	}	298	}
292	}	299	}
		300	commitTransaction(em);
		301	closeEntityManager(em);
293	}	302	}
294		303
295	@Test	304	@Test
Lines 301-306 Link Here
301	}	310	}
302	void internal_dynamicFetchGroup_EmployeeAddressEmptyPhone(boolean shouldLoad) {	311	void internal_dynamicFetchGroup_EmployeeAddressEmptyPhone(boolean shouldLoad) {
303	EntityManager em = createEntityManager();	312	EntityManager em = createEntityManager();
		313	beginTransaction(em);
304		314
305	Query query = em.createQuery("SELECT e FROM Employee e WHERE e.gender = :GENDER");	315	Query query = em.createQuery("SELECT e FROM Employee e WHERE e.gender = :GENDER");
306	query.setParameter("GENDER", Gender.Male);	316	query.setParameter("GENDER", Gender.Male);
Lines 372-377 Link Here
372	assertTrue(phoneTracker._persistence_isAttributeFetched("areaCode"));	382	assertTrue(phoneTracker._persistence_isAttributeFetched("areaCode"));
373	}	383	}
374	}	384	}
		385	commitTransaction(em);
		386	closeEntityManager(em);
375	}	387	}
376		388
377	@Test	389	@Test
Lines 421-427 Link Here
421	void internalDynamicHierarchicalFetchGroup_JOIN_FETCH(boolean useCopy) throws Exception {	433	void internalDynamicHierarchicalFetchGroup_JOIN_FETCH(boolean useCopy) throws Exception {
422		434
423	EntityManager em = createEntityManager();	435	EntityManager em = createEntityManager();
424		436	beginTransaction(em);
		437
425	Query query = em.createQuery("SELECT e FROM Employee e JOIN FETCH e.manager WHERE e.lastName LIKE :LNAME AND e.manager.lastName <> e.lastName");	438	Query query = em.createQuery("SELECT e FROM Employee e JOIN FETCH e.manager WHERE e.lastName LIKE :LNAME AND e.manager.lastName <> e.lastName");
426	query.setParameter("LNAME", "%");	439	query.setParameter("LNAME", "%");
427		440
Lines 584-589 Link Here
584	}	597	}
585	}	598	}
586	}	599	}
		600	commitTransaction(em);
		601	closeEntityManager(em);
587	}	602	}
588		603
589	@Test	604	@Test
Lines 598-603 Link Here
598		613
599	void managerNestedFetchGroupWithJoinFetch(boolean isDouble) {	614	void managerNestedFetchGroupWithJoinFetch(boolean isDouble) {
600	EntityManager em = createEntityManager();	615	EntityManager em = createEntityManager();
		616	beginTransaction(em);
601		617
602	Query query = em.createQuery("SELECT e FROM Employee e WHERE e.manager.manager IS NOT NULL");	618	Query query = em.createQuery("SELECT e FROM Employee e WHERE e.manager.manager IS NOT NULL");
603	FetchGroup managerFG = new FetchGroup();	619	FetchGroup managerFG = new FetchGroup();
Lines 668-678 Link Here
668	assertNoFetchGroup(phone);	684	assertNoFetchGroup(phone);
669	}	685	}
670	assertEquals(nSql, getQuerySQLTracker(em).getTotalSQLSELECTCalls());	686	assertEquals(nSql, getQuerySQLTracker(em).getTotalSQLSELECTCalls());
		687	commitTransaction(em);
		688	closeEntityManager(em);
671	}	689	}
672		690
673	@Test	691	@Test
674	public void allNestedFetchGroupWithJoinFetch() {	692	public void allNestedFetchGroupWithJoinFetch() {
675	EntityManager em = createEntityManager();	693	EntityManager em = createEntityManager();
		694	beginTransaction(em);
676		695
677	// select employees who are neither managers nor team leaders	696	// select employees who are neither managers nor team leaders
678	Query query = em.createQuery("SELECT e FROM Employee e WHERE NOT EXISTS(SELECT p.id FROM Project p WHERE p.teamLeader = e) AND NOT EXISTS(SELECT e2.id FROM Employee e2 WHERE e2.manager = e)");	697	Query query = em.createQuery("SELECT e FROM Employee e WHERE NOT EXISTS(SELECT p.id FROM Project p WHERE p.teamLeader = e) AND NOT EXISTS(SELECT e2.id FROM Employee e2 WHERE e2.manager = e)");
Lines 749-754 Link Here
749	}	768	}
750	}	769	}
751	assertEquals(1, getQuerySQLTracker(em).getTotalSQLSELECTCalls());	770	assertEquals(1, getQuerySQLTracker(em).getTotalSQLSELECTCalls());
		771	commitTransaction(em);
		772	closeEntityManager(em);
752	}	773	}
753		774
754	@Test	775	@Test
Lines 786-791 Link Here
786	@Test	807	@Test
787	public void simpleNestedFetchGroupWithBatch() {	808	public void simpleNestedFetchGroupWithBatch() {
788	EntityManager em = createEntityManager();	809	EntityManager em = createEntityManager();
		810	beginTransaction(em);
789		811
790	Query query = em.createQuery("SELECT e FROM Employee e");	812	Query query = em.createQuery("SELECT e FROM Employee e");
791		813
Lines 866-877 Link Here
866	assertNoFetchGroup(project);	888	assertNoFetchGroup(project);
867	}	889	}
868	}	890	}
		891	commitTransaction(em);
		892	closeEntityManager(em);
869	}	893	}
870		894
871	@Test	895	@Test
872	public void simpleLoadGroup() {	896	public void simpleLoadGroup() {
873	EntityManager em = createEntityManager();	897	EntityManager em = createEntityManager();
874		898	beginTransaction(em);
		899
875	Query query = em.createQuery("SELECT e FROM Employee e WHERE e.gender = :GENDER");	900	Query query = em.createQuery("SELECT e FROM Employee e WHERE e.gender = :GENDER");
876	query.setParameter("GENDER", Gender.Female);	901	query.setParameter("GENDER", Gender.Female);
877	List<Employee> employees = query.getResultList();	902	List<Employee> employees = query.getResultList();
Lines 895-899 Link Here
895		920
896	int numSelectAfter = getQuerySQLTracker(em).getTotalSQLSELECTCalls();	921	int numSelectAfter = getQuerySQLTracker(em).getTotalSQLSELECTCalls();
897	assertEquals(numSelectBefore, numSelectAfter);	922	assertEquals(numSelectBefore, numSelectAfter);
		923	commitTransaction(em);
		924	closeEntityManager(em);
898	}	925	}
899	}	926	}

Lines 83-88 Link Here

(-)jpa/eclipselink.jpa.test/src/org/eclipse/persistence/testing/tests/jpa/fetchgroups/NestedNamedFetchGroupTests.java (+9 lines)
83	@Test	83	@Test
84	public void dynamicFetchGroup_EmployeeAddress() throws Exception {	84	public void dynamicFetchGroup_EmployeeAddress() throws Exception {
85	EntityManager em = createEntityManager();	85	EntityManager em = createEntityManager();
		86	beginTransaction(em);
86		87
87	Query query = em.createQuery("SELECT e FROM Employee e WHERE e.gender = :GENDER");	88	Query query = em.createQuery("SELECT e FROM Employee e WHERE e.gender = :GENDER");
88	query.setParameter("GENDER", Gender.Male);	89	query.setParameter("GENDER", Gender.Male);
Lines 140-145 Link Here
140	assertFalse(phoneTracker._persistence_isAttributeFetched("areaCode"));	141	assertFalse(phoneTracker._persistence_isAttributeFetched("areaCode"));
141	}	142	}
142	}	143	}
		144	commitTransaction(em);
		145	closeEntityManager(em);
143	}	146	}
144		147
145	@Test	148	@Test
Lines 208-213 Link Here
208	@Test	211	@Test
209	public void dynamicFetchGroup_EmployeeAddressNullPhone() throws Exception {	212	public void dynamicFetchGroup_EmployeeAddressNullPhone() throws Exception {
210	EntityManager em = createEntityManager();	213	EntityManager em = createEntityManager();
		214	beginTransaction(em);
211		215
212	Query query = em.createQuery("SELECT e FROM Employee e WHERE e.gender = :GENDER");	216	Query query = em.createQuery("SELECT e FROM Employee e WHERE e.gender = :GENDER");
213	query.setParameter("GENDER", Gender.Male);	217	query.setParameter("GENDER", Gender.Male);
Lines 274-284 Link Here
274	assertNull("PhoneNumber has a FetchGroup", phoneTracker._persistence_getFetchGroup());	278	assertNull("PhoneNumber has a FetchGroup", phoneTracker._persistence_getFetchGroup());
275	}	279	}
276	}	280	}
		281	commitTransaction(em);
		282	closeEntityManager(em);
277	}	283	}
278		284
279	@Test	285	@Test
280	public void dynamicFetchGroup_EmployeeAddressEmptyPhone() throws Exception {	286	public void dynamicFetchGroup_EmployeeAddressEmptyPhone() throws Exception {
281	EntityManager em = createEntityManager();	287	EntityManager em = createEntityManager();
		288	beginTransaction(em);
282		289
283	Query query = em.createQuery("SELECT e FROM Employee e WHERE e.gender = :GENDER");	290	Query query = em.createQuery("SELECT e FROM Employee e WHERE e.gender = :GENDER");
284	query.setParameter("GENDER", Gender.Male);	291	query.setParameter("GENDER", Gender.Male);
Lines 350-355 Link Here
350	assertTrue(phoneTracker._persistence_isAttributeFetched("areaCode"));	357	assertTrue(phoneTracker._persistence_isAttributeFetched("areaCode"));
351	}	358	}
352	}	359	}
		360	commitTransaction(em);
		361	closeEntityManager(em);
353	}	362	}
354		363
355	@Test	364	@Test

Lines 284-289 Link Here

(-)jpa/eclipselink.jpa.test/src/org/eclipse/persistence/testing/tests/jpa/fetchgroups/SimpleDefaultFetchGroupTests.java (+13 lines)
284	@Test	284	@Test
285	public void singleResultNoFetchGroup() throws Exception {	285	public void singleResultNoFetchGroup() throws Exception {
286	EntityManager em = createEntityManager();	286	EntityManager em = createEntityManager();
		287	beginTransaction(em);
287		288
288	Query query = em.createQuery("SELECT e FROM Employee e WHERE e.id = :ID");	289	Query query = em.createQuery("SELECT e FROM Employee e WHERE e.id = :ID");
289	query.setParameter("ID", minimumEmployeeId(em));	290	query.setParameter("ID", minimumEmployeeId(em));
Lines 308-313 Link Here
308	}	309	}
309		310
310	assertEquals(4, getQuerySQLTracker(em).getTotalSQLSELECTCalls());	311	assertEquals(4, getQuerySQLTracker(em).getTotalSQLSELECTCalls());
		312
		313	commitTransaction(em);
		314	closeEntityManager(em);
311	}	315	}
312		316
313	@Test	317	@Test
Lines 341-346 Link Here
341	@Test	345	@Test
342	public void emptyFetchGroup() throws Exception {	346	public void emptyFetchGroup() throws Exception {
343	EntityManager em = createEntityManager();	347	EntityManager em = createEntityManager();
		348	beginTransaction(em);
344		349
345	// Use q query since find will only use default fetch group	350	// Use q query since find will only use default fetch group
346	Query query = em.createQuery("SELECT e FROM Employee e WHERE e.id = :ID");	351	Query query = em.createQuery("SELECT e FROM Employee e WHERE e.id = :ID");
Lines 359-369 Link Here
359	phone.getAreaCode();	364	phone.getAreaCode();
360	assertNoFetchGroup(phone);	365	assertNoFetchGroup(phone);
361	}	366	}
		367	commitTransaction(em);
		368	closeEntityManager(em);
362	}	369	}
363		370
364	@Test	371	@Test
365	public void managerFetchGroup() throws Exception {	372	public void managerFetchGroup() throws Exception {
366	EntityManager em = createEntityManager();	373	EntityManager em = createEntityManager();
		374	beginTransaction(em);
367		375
368	// Use q query since find will only use default fetch group	376	// Use q query since find will only use default fetch group
369	// Query query = em.createQuery("SELECT e FROM Employee e WHERE e.id = :ID");	377	// Query query = em.createQuery("SELECT e FROM Employee e WHERE e.id = :ID");
Lines 408-418 Link Here
408	}	416	}
409	// 1 sql to read all the phones with a fetch group + 1 sql per phone to re-read each phone without fetch group	417	// 1 sql to read all the phones with a fetch group + 1 sql per phone to re-read each phone without fetch group
410	assertEquals(3 + numPhones, getQuerySQLTracker(em).getTotalSQLSELECTCalls());	418	assertEquals(3 + numPhones, getQuerySQLTracker(em).getTotalSQLSELECTCalls());
		419	commitTransaction(em);
		420	closeEntityManager(em);
411	}	421	}
412		422
413	@Test	423	@Test
414	public void employeeNamesFetchGroup() throws Exception {	424	public void employeeNamesFetchGroup() throws Exception {
415	EntityManager em = createEntityManager();	425	EntityManager em = createEntityManager();
		426	beginTransaction(em);
416		427
417	int minId = minimumEmployeeId(em);	428	int minId = minimumEmployeeId(em);
418	assertEquals(1, getQuerySQLTracker(em).getTotalSQLSELECTCalls());	429	assertEquals(1, getQuerySQLTracker(em).getTotalSQLSELECTCalls());
Lines 467-472 Link Here
467	// If manager_id field is null then getManager() does not trigger an sql.	478	// If manager_id field is null then getManager() does not trigger an sql.
468	assertEquals(4 + numPhones, getQuerySQLTracker(em).getTotalSQLSELECTCalls());	479	assertEquals(4 + numPhones, getQuerySQLTracker(em).getTotalSQLSELECTCalls());
469	}	480	}
		481	commitTransaction(em);
		482	closeEntityManager(em);
470	}	483	}
471		484
472	@Test	485	@Test




    @Test
    public void findEmptyFetchGroup() throws Exception {
        EntityManager em = createEntityManager();
        try {
            beginTransaction(em);

            int minId = minimumEmployeeId(em);

            assertEquals(1, getQuerySQLTracker(em).getTotalSQLSELECTCalls());
        FetchGroup emptyFG = new FetchGroup();
        properties.put(QueryHints.FETCH_GROUP, emptyFG);

            Map<String, Object> properties = new HashMap<String, Object>();
            FetchGroup emptyFG = new FetchGroup();
            properties.put(QueryHints.FETCH_GROUP, emptyFG);

            Employee emp = em.find(Employee.class, minId, properties);
        assertFetched(emp, emptyFG);
        assertEquals(2, getQuerySQLTracker(em).getTotalSQLSELECTCalls());

            assertNotNull(emp);
            assertFetched(emp, emptyFG);
            assertEquals(2, getQuerySQLTracker(em).getTotalSQLSELECTCalls());
        assertNotFetchedAttribute(emp, "firstName");
        assertNotFetchedAttribute(emp, "lastName");
        assertNotFetchedAttribute(emp, "gender");
        assertNotFetchedAttribute(emp, "salary");
        assertNotFetchedAttribute(emp, "startTime");
        assertNotFetchedAttribute(emp, "endTime");
        if (emp.getPeriod() != null) {
            assertFetchedAttribute(emp.getPeriod(), "startDate");
            assertFetchedAttribute(emp.getPeriod(), "endDate");
        }

            // Check Basics
            assertFetchedAttribute(emp, "id");
            assertFetchedAttribute(emp, "version");
            assertNotFetchedAttribute(emp, "firstName");
            assertNotFetchedAttribute(emp, "lastName");
            assertNotFetchedAttribute(emp, "gender");
            assertNotFetchedAttribute(emp, "salary");
            assertNotFetchedAttribute(emp, "startTime");
            assertNotFetchedAttribute(emp, "endTime");
            if (emp.getPeriod() != null) {
                assertFetchedAttribute(emp.getPeriod(), "startDate");
                assertFetchedAttribute(emp.getPeriod(), "endDate");
            }

            // Check Relationships
            assertNotFetchedAttribute(emp, "address");
            assertNotFetchedAttribute(emp, "manager");
            assertNotFetchedAttribute(emp, "phoneNumbers");
            assertNotFetchedAttribute(emp, "projects");

            emp.getSalary();

            assertFetchedAttribute(emp, "salary");
        assertNoFetchGroup(emp);

            assertEquals(3, getQuerySQLTracker(em).getTotalSQLSELECTCalls());
            assertNoFetchGroup(emp);

            emp.getAddress();
        assertNoFetchGroup(emp.getAddress());

            assertEquals(4, getQuerySQLTracker(em).getTotalSQLSELECTCalls());
            assertNoFetchGroup(emp.getAddress());

            emp.getPhoneNumbers().size();
        for (PhoneNumber phone : emp.getPhoneNumbers()) {
            assertNoFetchGroup(phone);
        }

        if (emp.getManager() != null) {
            assertEquals(6, getQuerySQLTracker(em).getTotalSQLSELECTCalls());
        } else {
            // If manager_id field is null then getManager() does not trigger an sql.
            assertEquals(5, getQuerySQLTracker(em).getTotalSQLSELECTCalls());
            for (PhoneNumber phone : emp.getPhoneNumbers()) {
                assertNoFetchGroup(phone);
            }

            if (emp.getManager() != null) {
                assertEquals(6, getQuerySQLTracker(em).getTotalSQLSELECTCalls());
            } else {
                // If manager_id field is null then getManager() does not trigger an sql.
                assertEquals(5, getQuerySQLTracker(em).getTotalSQLSELECTCalls());
            } 
        }finally {
            if (isTransactionActive(em)){
                rollbackTransaction(em);
            }
            closeEntityManager(em);
        }
    }

    @Test
    public void findEmptyFetchGroup_setUnfetchedSalary() throws Exception {
        EntityManager em = createEntityManager();
        beginTransaction(em);

        int minId = minimumEmployeeId(em);

        assertEquals(1, getQuerySQLTracker(em).getTotalSQLSELECTCalls());

        for (PhoneNumber phone : emp.getPhoneNumbers()) {
            assertNoFetchGroup(phone);
        }
        commitTransaction(em);
        closeEntityManager(em);
    }

    @Test
    public void singleResultEmptyFetchGroup() throws Exception {
        EntityManager em = createEntityManager();
        beginTransaction(em);

        Query query = em.createQuery("SELECT e FROM Employee e WHERE e.id = :ID");
        query.setParameter("ID", minimumEmployeeId(em));

        for (PhoneNumber phone : emp.getPhoneNumbers()) {
            assertNoFetchGroup(phone);
        }
        commitTransaction(em);
        closeEntityManager(em);
    }

    /**

    @Test
    public void resultListEmptyFetchGroup() throws Exception {
        EntityManager em = createEntityManager();
        beginTransaction(em);

        Query query = em.createQuery("SELECT e FROM Employee e WHERE e.id = :ID");
        query.setParameter("ID", minimumEmployeeId(em));

            assertNoFetchGroup(phone);
        }
        assertEquals(5, getQuerySQLTracker(em).getTotalSQLSELECTCalls());
        commitTransaction(em);
        closeEntityManager(em);
    }

    /**

    @Test
    public void resultListPeriodFetchGroup() throws Exception {
        EntityManager em = createEntityManager();
        beginTransaction(em);

        Query query = em.createQuery("SELECT e FROM Employee e WHERE e.id = :ID");
        query.setParameter("ID", minimumEmployeeId(em));

            assertNoFetchGroup(phone);
        }
        assertEquals(5, getQuerySQLTracker(em).getTotalSQLSELECTCalls());
        commitTransaction(em);
        closeEntityManager(em);
    }

    @Test
    public void managerFetchGroup() throws Exception {
        EntityManager em = createEntityManager();
        beginTransaction(em);

        // Use q query since find will only use default fetch group
//        Query query = em.createQuery("SELECT e FROM Employee e WHERE e.id = :ID");

        }

        assertEquals(3 + nSqlToAdd, getQuerySQLTracker(em).getTotalSQLSELECTCalls());
        commitTransaction(em);
        closeEntityManager(em);
    }

    @Test
    public void managerFetchGroupWithJoinFetch() throws Exception {
        EntityManager em = createEntityManager();
        beginTransaction(em);

//        int minId = minimumEmployeeId(em);
//        assertEquals(1, getQuerySQLTracker(em).getTotalSQLSELECTCalls());

        }

        assertEquals(3, getQuerySQLTracker(em).getTotalSQLSELECTCalls());
        commitTransaction(em);
        closeEntityManager(em);
    }

    @Test
    public void employeeNamesFetchGroup() throws Exception {
        EntityManager em = createEntityManager();
        beginTransaction(em);

        int minId = minimumEmployeeId(em);
        assertEquals(1, getQuerySQLTracker(em).getTotalSQLSELECTCalls());

            // If manager_id field is null then getManager() does not trigger an sql.
            assertEquals(4, getQuerySQLTracker(em).getTotalSQLSELECTCalls());
        }
        commitTransaction(em);
        closeEntityManager(em);
    }

    @Test

    @Test
    public void verifyUnfetchedAttributes() throws Exception {
        EntityManager em = createEntityManager();
        try {
            beginTransaction(em);
            TypedQuery<Employee> q = em.createQuery("SELECT e FROM Employee e WHERE e.id IN (SELECT MIN(p.id) FROM PhoneNumber p)", Employee.class);
            FetchGroup fg = new FetchGroup("Employee.empty");
            q.setHint(QueryHints.FETCH_GROUP, fg);
            Employee emp = q.getSingleResult();

            assertNotNull(emp);
            assertEquals(1, getQuerySQLTracker(em).getTotalSQLSELECTCalls());
        q.setHint(QueryHints.FETCH_GROUP, fg);
        Employee emp = q.getSingleResult();

            // This check using the mapping returns a default (empty) IndirectList
            /*OneToManyMapping phoneMapping = (OneToManyMapping) employeeDescriptor.getMappingForAttributeName("phoneNumbers");
            IndirectList phones = (IndirectList) phoneMapping.getAttributeValueFromObject(emp);
            assertNotNull(phones);
            assertTrue(phones.isInstantiated());
            assertEquals(0, phones.size());
            assertEquals(1, getQuerySQLTracker(em).getTotalSQLSELECTCalls());*/

            IndirectList phonesIL = (IndirectList) emp.getPhoneNumbers();
            assertFalse(phonesIL.isInstantiated());
            assertEquals(2, getQuerySQLTracker(em).getTotalSQLSELECTCalls());
        assertNotNull(phones);
        assertTrue(phones.isInstantiated());
        assertEquals(0, phones.size());
        assertEquals(1, getQuerySQLTracker(em).getTotalSQLSELECTCalls());*/

            assertTrue(emp.getPhoneNumbers().size() > 0);
            assertEquals(3, getQuerySQLTracker(em).getTotalSQLSELECTCalls());
        } finally {
            if (isTransactionActive(em)){
                rollbackTransaction(em);
            }
            closeEntityManager(em);
        }
    }

    @Test


    @Test
    public void explicitlyDetachedObjectWithFetchGroup() {
        // detach not supported on JPA 1.0
        if (! isJPA10()) {
            EntityManager em = createEntityManager();
            try {
                beginTransaction(em);
                FetchGroup fg = new FetchGroup();
                fg.addAttribute("firstName");
                fg.addAttribute("lastName");

                Map<String, Object> hints = new HashMap<String, Object>();
                hints.put(QueryHints.FETCH_GROUP, fg);
        fg.addAttribute("lastName");

                Employee emp = minimumEmployee(em, hints);
                em.detach(emp);
                assertFetched(emp, fg);
                
                // trigger the fetch group
                emp.getSalary();
                assertNoFetchGroup(emp);
            } finally {
                if (isTransactionActive(em)){
                    rollbackTransaction(em);
                }
                closeEntityManager(em);
            }
        }
    }
}

Lines 269-274 Link Here

(-)jpa/eclipselink.jpa.test/src/org/eclipse/persistence/testing/tests/jpa/fetchgroups/SimpleNamedFetchGroupTests.java (+3 lines)
269	@Test	269	@Test
270	public void managerFetchGroup() throws Exception {	270	public void managerFetchGroup() throws Exception {
271	EntityManager em = createEntityManager();	271	EntityManager em = createEntityManager();
		272	beginTransaction(em);
272		273
273	// Use q query since find will only use default fetch group	274	// Use q query since find will only use default fetch group
274	// Query query = em.createQuery("SELECT e FROM Employee e WHERE e.id = :ID");	275	// Query query = em.createQuery("SELECT e FROM Employee e WHERE e.id = :ID");
Lines 311-316 Link Here
311	}	312	}
312		313
313	assertEquals(3 + nSqlToAdd, getQuerySQLTracker(em).getTotalSQLSELECTCalls());	314	assertEquals(3 + nSqlToAdd, getQuerySQLTracker(em).getTotalSQLSELECTCalls());
		315	commitTransaction(em);
		316	closeEntityManager(em);
314	}	317	}
315		318
316	@Test	319	@Test

Lines 12-17 Link Here

(-)jpa/eclipselink.jpa.test/src/org/eclipse/persistence/testing/tests/jpa/fetchgroups/SimpleSerializeFetchGroupTests.java (-106 / +224 lines)
12	******************************************************************************/	12	******************************************************************************/
13	package org.eclipse.persistence.testing.tests.jpa.fetchgroups;	13	package org.eclipse.persistence.testing.tests.jpa.fetchgroups;
14		14
		15	import org.eclipse.persistence.exceptions.ValidationException;
		16	import java.io.ByteArrayInputStream;
		17	import java.io.ByteArrayOutputStream;
		18	import java.io.InputStream;
		19	import java.io.ObjectInputStream;
		20	import java.io.ObjectOutputStream;
		21	import java.io.OutputStream;
		22
15	import java.io.IOException;	23	import java.io.IOException;
16	import java.io.Serializable;	24	import java.io.Serializable;
17	import java.util.HashMap;	25	import java.util.HashMap;
Lines 185-190 Link Here
185	public void findEmptyFetchGroup_setUnfetchedSalary() throws Exception {	193	public void findEmptyFetchGroup_setUnfetchedSalary() throws Exception {
186	EntityManager em = createEntityManager();	194	EntityManager em = createEntityManager();
187	int minId = minimumEmployeeId(em);	195	int minId = minimumEmployeeId(em);
		196	beginTransaction(em);
188		197
189	assertEquals(1, getQuerySQLTracker(em).getTotalSQLSELECTCalls());	198	assertEquals(1, getQuerySQLTracker(em).getTotalSQLSELECTCalls());
190		199
Lines 237-242 Link Here
237	for (PhoneNumber phone : emp.getPhoneNumbers()) {	246	for (PhoneNumber phone : emp.getPhoneNumbers()) {
238	assertNoFetchGroup(phone);	247	assertNoFetchGroup(phone);
239	}	248	}
		249	commitTransaction(em);
		250	closeEntityManager(em);
240	}	251	}
241		252
242	/**	253	/**
Lines 288-293 Link Here
288	@Test	299	@Test
289	public void singleResultEmptyFetchGroup() throws Exception {	300	public void singleResultEmptyFetchGroup() throws Exception {
290	EntityManager em = createEntityManager();	301	EntityManager em = createEntityManager();
		302	beginTransaction(em);
291		303
292	Query query = em.createQuery("SELECT e FROM Employee e WHERE e.id = :ID");	304	Query query = em.createQuery("SELECT e FROM Employee e WHERE e.id = :ID");
293	query.setParameter("ID", minimumEmployeeId(em));	305	query.setParameter("ID", minimumEmployeeId(em));
Lines 338-343 Link Here
338	for (PhoneNumber phone : emp.getPhoneNumbers()) {	350	for (PhoneNumber phone : emp.getPhoneNumbers()) {
339	assertNoFetchGroup(phone);	351	assertNoFetchGroup(phone);
340	}	352	}
		353	commitTransaction(em);
		354	closeEntityManager(em);
341	}	355	}
342		356
343	/**	357	/**
Lines 346-351 Link Here
346	@Test	360	@Test
347	public void resultListEmptyFetchGroup() throws Exception {	361	public void resultListEmptyFetchGroup() throws Exception {
348	EntityManager em = createEntityManager();	362	EntityManager em = createEntityManager();
		363	beginTransaction(em);
349		364
350	Query query = em.createQuery("SELECT e FROM Employee e WHERE e.id = :ID");	365	Query query = em.createQuery("SELECT e FROM Employee e WHERE e.id = :ID");
351	query.setParameter("ID", minimumEmployeeId(em));	366	query.setParameter("ID", minimumEmployeeId(em));
Lines 399-404 Link Here
399	assertNoFetchGroup(phone);	414	assertNoFetchGroup(phone);
400	}	415	}
401	assertEquals(5, getQuerySQLTracker(em).getTotalSQLSELECTCalls());	416	assertEquals(5, getQuerySQLTracker(em).getTotalSQLSELECTCalls());
		417	commitTransaction(em);
		418	closeEntityManager(em);
402	}	419	}
403		420
404	/**	421	/**
Lines 407-412 Link Here
407	@Test	424	@Test
408	public void resultListPeriodFetchGroup() throws Exception {	425	public void resultListPeriodFetchGroup() throws Exception {
409	EntityManager em = createEntityManager();	426	EntityManager em = createEntityManager();
		427	beginTransaction(em);
410		428
411	Query query = em.createQuery("SELECT e FROM Employee e WHERE e.id = :ID");	429	Query query = em.createQuery("SELECT e FROM Employee e WHERE e.id = :ID");
412	query.setParameter("ID", minimumEmployeeId(em));	430	query.setParameter("ID", minimumEmployeeId(em));
Lines 461-471 Link Here
461	assertNoFetchGroup(phone);	479	assertNoFetchGroup(phone);
462	}	480	}
463	assertEquals(5, getQuerySQLTracker(em).getTotalSQLSELECTCalls());	481	assertEquals(5, getQuerySQLTracker(em).getTotalSQLSELECTCalls());
		482	commitTransaction(em);
		483	closeEntityManager(em);
464	}	484	}
465		485
466	@Test	486	@Test
467	public void managerFetchGroup() throws Exception {	487	public void managerFetchGroup() throws Exception {
468	EntityManager em = createEntityManager();	488	EntityManager em = createEntityManager();
		489	beginTransaction(em);
469		490
470	// Use q query since find will only use default fetch group	491	// Use q query since find will only use default fetch group
471	// Query query = em.createQuery("SELECT e FROM Employee e WHERE e.id = :ID");	492	// Query query = em.createQuery("SELECT e FROM Employee e WHERE e.id = :ID");
Lines 510-520 Link Here
510	}	531	}
511		532
512	assertEquals(3 + nSqlToAdd, getQuerySQLTracker(em).getTotalSQLSELECTCalls());	533	assertEquals(3 + nSqlToAdd, getQuerySQLTracker(em).getTotalSQLSELECTCalls());
		534	commitTransaction(em);
		535	closeEntityManager(em);
513	}	536	}
514		537
515	@Test	538	@Test
516	public void managerFetchGroupWithJoinFetch() throws Exception {	539	public void managerFetchGroupWithJoinFetch() throws Exception {
517	EntityManager em = createEntityManager();	540	EntityManager em = createEntityManager();
		541	beginTransaction(em);
518		542
519	// int minId = minimumEmployeeId(em);	543	// int minId = minimumEmployeeId(em);
520	// assertEquals(1, getQuerySQLTracker(em).getTotalSQLSELECTCalls());	544	// assertEquals(1, getQuerySQLTracker(em).getTotalSQLSELECTCalls());
Lines 558-568 Link Here
558	}	582	}
559		583
560	assertEquals(3, getQuerySQLTracker(em).getTotalSQLSELECTCalls());	584	assertEquals(3, getQuerySQLTracker(em).getTotalSQLSELECTCalls());
		585	commitTransaction(em);
		586	closeEntityManager(em);
561	}	587	}
562		588
563	@Test	589	@Test
564	public void employeeNamesFetchGroup() throws Exception {	590	public void employeeNamesFetchGroup() throws Exception {
565	EntityManager em = createEntityManager();	591	EntityManager em = createEntityManager();
		592	beginTransaction(em);
566		593
567	int minId = minimumEmployeeId(em);	594	int minId = minimumEmployeeId(em);
568	assertEquals(1, getQuerySQLTracker(em).getTotalSQLSELECTCalls());	595	assertEquals(1, getQuerySQLTracker(em).getTotalSQLSELECTCalls());
Lines 611-616 Link Here
611	// If manager_id field is null then getManager() does not trigger an sql.	638	// If manager_id field is null then getManager() does not trigger an sql.
612	assertEquals(4, getQuerySQLTracker(em).getTotalSQLSELECTCalls());	639	assertEquals(4, getQuerySQLTracker(em).getTotalSQLSELECTCalls());
613	}	640	}
		641	commitTransaction(em);
		642	closeEntityManager(em);
614	}	643	}
615		644
616	@Test	645	@Test
Lines 648-653 Link Here
648	@Test	677	@Test
649	public void verifyUnfetchedAttributes() throws Exception {	678	public void verifyUnfetchedAttributes() throws Exception {
650	EntityManager em = createEntityManager();	679	EntityManager em = createEntityManager();
		680	beginTransaction(em);
651		681
652	TypedQuery<Employee> q = em.createQuery("SELECT e FROM Employee e WHERE e.id IN (SELECT MIN(p.id) FROM PhoneNumber p)", Employee.class);	682	TypedQuery<Employee> q = em.createQuery("SELECT e FROM Employee e WHERE e.id IN (SELECT MIN(p.id) FROM PhoneNumber p)", Employee.class);
653	FetchGroup fg = new FetchGroup("Employee.empty");	683	FetchGroup fg = new FetchGroup("Employee.empty");
Lines 671-676 Link Here
671		701
672	assertTrue(emp.getPhoneNumbers().size() > 0);	702	assertTrue(emp.getPhoneNumbers().size() > 0);
673	assertEquals(3, getQuerySQLTracker(em).getTotalSQLSELECTCalls());	703	assertEquals(3, getQuerySQLTracker(em).getTotalSQLSELECTCalls());
		704	commitTransaction(em);
		705	closeEntityManager(em);
674	}	706	}
675		707
676	@Test	708	@Test
Lines 925-1043 Link Here
925	public void partialMerge() throws Exception {	957	public void partialMerge() throws Exception {
926	EntityManager em = createEntityManager();	958	EntityManager em = createEntityManager();
927	// Search for an Employee with an Address and Phone Numbers	959	// Search for an Employee with an Address and Phone Numbers
928	TypedQuery<Employee> query = em.createQuery("SELECT e FROM Employee e WHERE e.address IS NOT NULL AND e.id IN (SELECT MIN(p.id) FROM PhoneNumber p)", Employee.class);	960	try {
929		961	beginTransaction(em);
930	// Load only its names and phone Numbers	962	TypedQuery<Employee> query = em.createQuery("SELECT e FROM Employee e WHERE e.address IS NOT NULL AND e.id IN (SELECT MIN(p.id) FROM PhoneNumber p)", Employee.class);
931	FetchGroup fetchGroup = new FetchGroup();	963
932	fetchGroup.addAttribute("firstName");	964	// Load only its names and phone Numbers
933	fetchGroup.addAttribute("lastName");	965	FetchGroup fetchGroup = new FetchGroup();
934	FetchGroup phonesFG = phoneDescriptor.getFetchGroupManager().createFullFetchGroup();	966	fetchGroup.addAttribute("firstName");
935	// that ensures the owner is not instantiated	967	fetchGroup.addAttribute("lastName");
936	phonesFG.addAttribute("owner.id");	968	FetchGroup phonesFG = phoneDescriptor.getFetchGroupManager().createFullFetchGroup();
937	phonesFG.removeAttribute("status");	969	// that ensures the owner is not instantiated
938	phonesFG.setShouldLoad(true);	970	phonesFG.addAttribute("owner.id");
939	fetchGroup.addAttribute("phoneNumbers", phonesFG);	971	phonesFG.removeAttribute("status");
940		972	phonesFG.setShouldLoad(true);
941	// Make sure the FetchGroup also forces the relationships to be loaded	973	fetchGroup.addAttribute("phoneNumbers", phonesFG);
942	fetchGroup.setShouldLoad(true);	974
943	query.setHint(QueryHints.FETCH_GROUP, fetchGroup);	975	// Make sure the FetchGroup also forces the relationships to be loaded
944		976	fetchGroup.setShouldLoad(true);
945	Employee emp = query.getSingleResult();	977	query.setHint(QueryHints.FETCH_GROUP, fetchGroup);
946		978
947	// Detach Employee through Serialization	979	Employee emp = query.getSingleResult();
948	Employee detachedEmp = (Employee) SerializationHelper.clone(emp);	980
949	// Modify the detached Employee inverting the names, adding a phone number, and setting the salary	981	// Detach Employee through Serialization
950	detachedEmp.setFirstName(emp.getLastName());	982	Employee detachedEmp;
951	detachedEmp.setLastName(emp.getFirstName());	983	if (isOnServer()) {
952	detachedEmp.addPhoneNumber(new PhoneNumber("TEST", "999", "999999"));	984	detachedEmp = (Employee) clone(emp);
953	// NOte that salary was not part of the original FetchGroupdetachedEmp.setSalary(1);	985	} else {
954	detachedEmp.setSalary(1);	986	detachedEmp = (Employee) SerializationHelper.clone(emp);
955		987	}
956	beginTransaction(em);	988
957	// Merge the detached employee	989	// Modify the detached Employee inverting the names, adding a phone number, and setting the salary
958	em.merge(detachedEmp);	990	detachedEmp.setFirstName(emp.getLastName());
959	// Flush the changes to the database	991	detachedEmp.setLastName(emp.getFirstName());
960	em.flush();	992	detachedEmp.addPhoneNumber(new PhoneNumber("TEST", "999", "999999"));
961	rollbackTransaction(em);	993	// NOte that salary was not part of the original FetchGroupdetachedEmp.setSalary(1);
		994	detachedEmp.setSalary(1);
		995
		996	// Merge the detached employee
		997	em.merge(detachedEmp);
		998	// Flush the changes to the database
		999	em.flush();
		1000	} finally {
		1001	rollbackTransaction(em);
		1002	closeEntityManager(em);
		1003	}
962	}	1004	}
963		1005
964	public void copyGroupMerge() {	1006	public void copyGroupMerge() {
965	// Search for an Employee with an Address and Phone Numbers	1007	// Search for an Employee with an Address and Phone Numbers
966	EntityManager em = createEntityManager();	1008	// unWrap not supported on 1.0
967	TypedQuery<Employee> query = em.createQuery("SELECT e FROM Employee e WHERE e.id IN (SELECT MIN(ee.id) FROM Employee ee)", Employee.class);	1009	if (! isJPA10()) {
968	Employee emp = query.getSingleResult();	1010	EntityManager em = createEntityManager();
969	assertEquals(1, getQuerySQLTracker(em).getTotalSQLSELECTCalls());	1011	try {
970	System.out.println(">>> Employee retrieved");	1012	beginTransaction(em);
971		1013	TypedQuery<Employee> query = em.createQuery("SELECT e FROM Employee e WHERE e.id IN (SELECT MIN(ee.id) FROM Employee ee)", Employee.class);
972	// Copy only its names and phone Numbers	1014	Employee emp = query.getSingleResult();
973	AttributeGroup group = new CopyGroup();	1015	assertEquals(1, getQuerySQLTracker(em).getTotalSQLSELECTCalls());
974	group.addAttribute("firstName");	1016	System.out.println(">>> Employee retrieved");
975	group.addAttribute("lastName");	1017
976	group.addAttribute("address");	1018	// Copy only its names and phone Numbers
977		1019	AttributeGroup group = new CopyGroup();
978	Employee empCopy = (Employee) em.unwrap(JpaEntityManager.class).copy(emp, group);	1020	group.addAttribute("firstName");
979	assertEquals(2, getQuerySQLTracker(em).getTotalSQLSELECTCalls());	1021	group.addAttribute("lastName");
980	System.out.println(">>> Employee copied");	1022	group.addAttribute("address");
981		1023
982	// Modify the detached Employee inverting the names, adding a phone number, and setting the salary	1024	Employee empCopy = (Employee) em.unwrap(JpaEntityManager.class).copy(emp, group);
983	empCopy.setFirstName(emp.getLastName());	1025	assertEquals(2, getQuerySQLTracker(em).getTotalSQLSELECTCalls());
984	empCopy.setLastName(emp.getFirstName());	1026	System.out.println(">>> Employee copied");
985		1027
986	// Note that salary was not part of the original FetchGroup	1028	// Modify the detached Employee inverting the names, adding a phone number, and setting the salary
987	//empCopy.setSalary(1);	1029	empCopy.setFirstName(emp.getLastName());
988		1030	empCopy.setLastName(emp.getFirstName());
989	beginTransaction(em);	1031
990	// Merge the detached employee	1032	// Note that salary was not part of the original FetchGroup
991	em.merge(empCopy);	1033	//empCopy.setSalary(1);
992	System.out.println(">>> Sparse merge complete");	1034
993		1035	// Merge the detached employee
994	// Flush the changes to the database	1036	em.merge(empCopy);
995	em.flush();	1037	System.out.println(">>> Sparse merge complete");
996	System.out.println(">>> Flush complete");	1038
997		1039	// Flush the changes to the database
998	rollbackTransaction(em);	1040	em.flush();
		1041	System.out.println(">>> Flush complete");
		1042
		1043	} finally {
		1044	rollbackTransaction(em);
		1045	closeEntityManager(em);
		1046	}
		1047	}
999	}	1048	}
1000		1049
1001	public void copyGroupMerge2() {	1050	public void copyGroupMerge2() {
1002	// Search for an Employee with an Address and Phone Numbers	1051	// Search for an Employee with an Address and Phone Numbers
1003	EntityManager em = createEntityManager();	1052	// unWrap not supported on 1.0
1004	TypedQuery<Employee> query = em.createQuery("SELECT e FROM Employee e", Employee.class);	1053	if (! isJPA10()) {
1005	query.setHint(QueryHints.BATCH, "e.address");	1054	EntityManager em = createEntityManager();
1006	List<Employee> employees = query.getResultList();	1055	try {
1007	assertEquals(1, getQuerySQLTracker(em).getTotalSQLSELECTCalls());	1056	beginTransaction(em);
1008	System.out.println(">>> Employees retrieved");	1057	TypedQuery<Employee> query = em.createQuery("SELECT e FROM Employee e", Employee.class);
1009		1058	query.setHint(QueryHints.BATCH, "e.address");
1010	// Copy only its names and phone Numbers	1059	List<Employee> employees = query.getResultList();
1011	AttributeGroup group = new CopyGroup();	1060	assertEquals(1, getQuerySQLTracker(em).getTotalSQLSELECTCalls());
1012	group.addAttribute("firstName");	1061	System.out.println(">>> Employees retrieved");
1013	group.addAttribute("lastName");	1062
1014	group.addAttribute("address");	1063	// Copy only its names and phone Numbers
1015		1064	AttributeGroup group = new CopyGroup();
1016	List<Employee> employeesCopy = (List<Employee>) em.unwrap(JpaEntityManager.class).copy(employees, group);	1065	group.addAttribute("firstName");
1017	assertEquals(2, getQuerySQLTracker(em).getTotalSQLSELECTCalls());	1066	group.addAttribute("lastName");
1018	System.out.println(">>> Employees copied");	1067	group.addAttribute("address");
1019		1068
1020	beginTransaction(em);	1069	List<Employee> employeesCopy = (List<Employee>) em.unwrap(JpaEntityManager.class).copy(employees, group);
1021	for(Employee empCopy : employeesCopy) {	1070	assertEquals(2, getQuerySQLTracker(em).getTotalSQLSELECTCalls());
1022	// Modify the detached Employee inverting the names, adding a phone number, and setting the salary	1071	System.out.println(">>> Employees copied");
1023	String firstName = empCopy.getFirstName();	1072
1024	String lastName = empCopy.getLastName();	1073	for(Employee empCopy : employeesCopy) {
1025	empCopy.setFirstName(lastName);	1074	// Modify the detached Employee inverting the names, adding a phone number, and setting the salary
1026	empCopy.setLastName(firstName);	1075	String firstName = empCopy.getFirstName();
1027		1076	String lastName = empCopy.getLastName();
1028	// Note that salary was not part of the original FetchGroup	1077	empCopy.setFirstName(lastName);
1029	//empCopy.setSalary(1);	1078	empCopy.setLastName(firstName);
1030		1079
1031	// Merge the detached employee	1080	// Note that salary was not part of the original FetchGroup
1032	em.merge(empCopy);	1081	//empCopy.setSalary(1);
		1082
		1083	// Merge the detached employee
		1084	em.merge(empCopy);
		1085	}
		1086	System.out.println(">>> Sparse merge complete");
		1087
		1088	// Flush the changes to the database
		1089	em.flush();
		1090	System.out.println(">>> Flush complete");
		1091
		1092	} finally {
		1093	rollbackTransaction(em);
		1094	closeEntityManager(em);
		1095	}
1033	}	1096	}
1034	System.out.println(">>> Sparse merge complete");
1035
1036	// Flush the changes to the database
1037	em.flush();
1038	System.out.println(">>> Flush complete");
1039
1040	rollbackTransaction(em);
1041	}	1097	}
1042		1098
1043	public void copyNoPk() {	1099	public void copyNoPk() {
Lines 1083-1092 Link Here
1083	}	1139	}
1084	}	1140	}
1085	}	1141	}
1086
1087		1142
1088	private <T> T serialize(Serializable entity) throws IOException, ClassNotFoundException {	1143	private <T> T serialize(Serializable entity) throws IOException, ClassNotFoundException {
1089	byte[] bytes = SerializationHelper.serialize(entity);	1144	if (isOnServer()) {
1090	return (T) SerializationHelper.deserialize(bytes);	1145	ByteArrayOutputStream outStream = new ByteArrayOutputStream(512);
		1146	serialize(entity, outStream);
		1147	byte[] bytes = outStream.toByteArray();
		1148	ByteArrayInputStream inStream = new ByteArrayInputStream(bytes);
		1149	return (T) deserialize(inStream);
		1150	} else {
		1151	byte[] bytes = SerializationHelper.serialize(entity);
		1152	return (T) SerializationHelper.deserialize(bytes);
		1153	}
1091	}	1154	}
		1155
		1156	// The following private method are only for server testing since the entity couldn't be loaded if call from SerializationHelper.
		1157	private static Object clone(Serializable object) throws IOException, ClassNotFoundException {
		1158	ByteArrayOutputStream outStream = new ByteArrayOutputStream(512);
		1159	serialize(object, outStream);
		1160	byte[] bytes = outStream.toByteArray();
		1161	return deserialize(bytes);
		1162	}
		1163
		1164	private static void serialize(Serializable obj, OutputStream outputStream) throws IOException {
		1165	if (outputStream == null) {
		1166	throw ValidationException.invalidNullMethodArguments();
		1167	}
		1168	ObjectOutputStream outStream = null;
		1169
		1170	try {
		1171	outStream = new ObjectOutputStream(outputStream);
		1172	outStream.writeObject(obj);
		1173	} finally {
		1174	try {
		1175	if (outStream != null) {
		1176	outStream.close();
		1177	}
		1178	} catch (IOException ex) {
		1179	// ignore;
		1180	}
		1181	}
		1182	}
		1183
		1184	private static Object deserialize(InputStream inputStream) throws IOException, ClassNotFoundException {
		1185	if (inputStream == null) {
		1186	throw new IllegalArgumentException("The inputStream argument cannot be null");
		1187	}
		1188	ObjectInputStream inStream = null;
		1189	try {
		1190	inStream = new ObjectInputStream(inputStream);
		1191	return inStream.readObject();
		1192	} finally {
		1193	try {
		1194	if (inStream != null) {
		1195	inStream.close();
		1196	}
		1197	} catch (IOException ex) {
		1198	// ignore
		1199	}
		1200	}
		1201	}
		1202
		1203	private static Object deserialize(byte[] objectBytes) throws IOException, ClassNotFoundException {
		1204	if (objectBytes == null) {
		1205	throw ValidationException.invalidNullMethodArguments();
		1206	}
		1207	ByteArrayInputStream inStream = new ByteArrayInputStream(objectBytes);
		1208	return deserialize(inStream);
		1209	}
1092	}	1210	}

Return to bug 319134

Lines 1949-1954 Link Here

(-)jpa/eclipselink.jpa.test/build.xml (+14 lines)
1949	<antcall target="server-test-ddlgeneration" inheritRefs="true"/>	1949	<antcall target="server-test-ddlgeneration" inheritRefs="true"/>
1950	<antcall target="server-test-cascadedeletes" inheritRefs="true"/>	1950	<antcall target="server-test-cascadedeletes" inheritRefs="true"/>
1951	<antcall target="server-test-delimited" inheritRefs="true"/>	1951	<antcall target="server-test-delimited" inheritRefs="true"/>
		1952	<antcall target="server-test-fetchgroups" inheritRefs="true"/>
1952	<antcall target="server-test-fieldaccess-advanced" inheritRefs="true"/>	1953	<antcall target="server-test-fieldaccess-advanced" inheritRefs="true"/>
1953	<antcall target="server-test-fieldaccess-relationships" inheritRefs="true"/>	1954	<antcall target="server-test-fieldaccess-relationships" inheritRefs="true"/>
1954	<antcall target="server-test-inheritance" inheritRefs="true"/>	1955	<antcall target="server-test-inheritance" inheritRefs="true"/>
Lines 2086-2091 Link Here
2086	</antcall>	2087	</antcall>
2087	</target>	2088	</target>
2088		2089
		2090	<target name="server-test-fetchgroups">
		2091	<antcall target="server-run-all" inheritRefs="true">
		2092	<param name="PERSISTENCE_UNIT_NAME" value="default"/>
		2093	<param name="MODEL_DIR" value="org/eclipse/persistence/testing/models/jpa/advanced"/>
		2094	<param name="MODEL_NAME" value="eclipselink-fetchgroups-model"/>
		2095	<param name="TEST_DIR" value="org/eclipse/persistence/testing/tests/jpa/fetchgroups"/>
		2096	<param name="TEST_NAME" value="eclipselink-fetchgroups-model"/>
		2097	<param name="EAR_NAME" value="eclipselink-fetchgroups-model"/>
		2098	<param name="TEST_SUITE" value="org.eclipse.persistence.testing.tests.jpa.fetchgroups.FetchGroupsServerTestSuite"/>
		2099	<param name="eclipselink.jpa.test.dir" value="."/>
		2100	</antcall>
		2101	</target>
		2102
2089	<target name="server-test-fieldaccess-advanced">	2103	<target name="server-test-fieldaccess-advanced">
2090	<antcall target="server-run-all" inheritRefs="true">	2104	<antcall target="server-run-all" inheritRefs="true">
2091	<param name="PERSISTENCE_UNIT_NAME" value="fieldaccess"/>	2105	<param name="PERSISTENCE_UNIT_NAME" value="fieldaccess"/>

Lines 69-83 Link Here

(-)jpa/eclipselink.jpa.test/src/org/eclipse/persistence/testing/tests/jpa/fetchgroups/BaseFetchGroupTests.java (-11 / +1 lines)
69	super(name);	69	super(name);
70	}	70	}
71		71
72	/*
73	* Fetch Group tests require weaving.
74	*/
75	public void runBare() throws Throwable {
76	if (isWeavingEnabled()) {
77	super.runBare();
78	}
79	}
80
81	/**	72	/**
82	* Any FetchGroups setup in test cases are removed.	73	* Any FetchGroups setup in test cases are removed.
83	* Descriptors should not be isolated.	74	* Descriptors should not be isolated.
Lines 447-454 Link Here
447	}	438	}
448		439
449	protected QuerySQLTracker getQuerySQLTracker(EntityManager em) {	440	protected QuerySQLTracker getQuerySQLTracker(EntityManager em) {
450	return QuerySQLTracker.getTracker(JpaHelper.getEntityManager(em)	441	return QuerySQLTracker.getTracker(getServerSession());
451	.getActiveSession());
452	}	442	}
453		443
454	ClassDescriptor getDescriptor(String entityName) {	444	ClassDescriptor getDescriptor(String entityName) {

Lines 22-27 Link Here

(-)jpa/eclipselink.jpa.test/src/org/eclipse/persistence/testing/tests/jpa/fetchgroups/FetchGroupAssert.java (-7 / +8 lines)
22	import java.util.Map;	22	import java.util.Map;
23		23
24	import javax.persistence.EntityManagerFactory;	24	import javax.persistence.EntityManagerFactory;
		25	import org.eclipse.persistence.testing.framework.junit.JUnitTestCase;
25		26
26	import org.eclipse.persistence.descriptors.ClassDescriptor;	27	import org.eclipse.persistence.descriptors.ClassDescriptor;
27	import org.eclipse.persistence.descriptors.VersionLockingPolicy;	28	import org.eclipse.persistence.descriptors.VersionLockingPolicy;
Lines 53-59 Link Here
53	*/	54	*/
54	public static boolean isValid(FetchGroup fetchGroup, EntityManagerFactory emf, Class<?> entityClass) {	55	public static boolean isValid(FetchGroup fetchGroup, EntityManagerFactory emf, Class<?> entityClass) {
55	assertNotNull(fetchGroup);	56	assertNotNull(fetchGroup);
56	Session session = JpaHelper.getServerSession(emf);	57	Session session = JUnitTestCase.getServerSession();
57	ClassDescriptor descriptor = session.getDescriptor(entityClass);	58	ClassDescriptor descriptor = session.getDescriptor(entityClass);
58	try {	59	try {
59	for (Map.Entry<String, AttributeItem> entry : fetchGroup.getItems().entrySet()) {	60	for (Map.Entry<String, AttributeItem> entry : fetchGroup.getItems().entrySet()) {
Lines 82-88 Link Here
82	public static void assertFetchedAttribute(EntityManagerFactory emf, Object entity, String... attribute) {	83	public static void assertFetchedAttribute(EntityManagerFactory emf, Object entity, String... attribute) {
83	assertNotNull("EntityManagerFactory is null", emf);	84	assertNotNull("EntityManagerFactory is null", emf);
84	assertNotNull("Entity is null", entity);	85	assertNotNull("Entity is null", entity);
85	Server session = JpaHelper.getServerSession(emf);	86	Server session = JUnitTestCase.getServerSession();
86	assertNotNull("No Server session found for: " + emf, session);	87	assertNotNull("No Server session found for: " + emf, session);
87	ClassDescriptor desc = session.getClassDescriptor(entity);	88	ClassDescriptor desc = session.getClassDescriptor(entity);
88	assertNotNull("No descriptor found for: " + entity, desc);	89	assertNotNull("No descriptor found for: " + entity, desc);
Lines 128-134 Link Here
128	public static void assertNotFetchedAttribute(EntityManagerFactory emf, Object entity, String... attribute) {	129	public static void assertNotFetchedAttribute(EntityManagerFactory emf, Object entity, String... attribute) {
129	assertNotNull("EntityManagerFactory is null", emf);	130	assertNotNull("EntityManagerFactory is null", emf);
130	assertNotNull("Entity is null", entity);	131	assertNotNull("Entity is null", entity);
131	Server session = JpaHelper.getServerSession(emf);	132	Server session = JUnitTestCase.getServerSession();
132	assertNotNull("No Server session found for: " + emf, session);	133	assertNotNull("No Server session found for: " + emf, session);
133	ClassDescriptor desc = session.getClassDescriptor(entity);	134	ClassDescriptor desc = session.getClassDescriptor(entity);
134	assertNotNull("No descriptor found for: " + entity, desc);	135	assertNotNull("No descriptor found for: " + entity, desc);
Lines 178-184 Link Here
178	}	179	}
179	assertTrue("FetchGroup on entity does not equal provided", tracker._persistence_getFetchGroup().equals(groupToCompare));	180	assertTrue("FetchGroup on entity does not equal provided", tracker._persistence_getFetchGroup().equals(groupToCompare));
180		181
181	Server session = JpaHelper.getServerSession(emf);	182	Server session = JUnitTestCase.getServerSession();
182	assertNotNull(session);	183	assertNotNull(session);
183	ClassDescriptor descriptor = session.getClassDescriptor(entity);	184	ClassDescriptor descriptor = session.getClassDescriptor(entity);
184	assertNotNull(descriptor);	185	assertNotNull(descriptor);
Lines 220-226 Link Here
220	public static void assertDefaultFetched(EntityManagerFactory emf, Object entity) {	221	public static void assertDefaultFetched(EntityManagerFactory emf, Object entity) {
221	assertNotNull("Null entity", entity);	222	assertNotNull("Null entity", entity);
222		223
223	ClassDescriptor descriptor = JpaHelper.getServerSession(emf).getClassDescriptor(entity);	224	ClassDescriptor descriptor = JUnitTestCase.getServerSession().getClassDescriptor(entity);
224	assertNotNull("No descriptor found for: " + entity, descriptor);	225	assertNotNull("No descriptor found for: " + entity, descriptor);
225		226
226	assertTrue("No FetchGroupManager on: " + descriptor, descriptor.hasFetchGroupManager());	227	assertTrue("No FetchGroupManager on: " + descriptor, descriptor.hasFetchGroupManager());
Lines 234-240 Link Here
234	public static void assertFetched(EntityManagerFactory emf, Object entity, String fetchGroupName) {	235	public static void assertFetched(EntityManagerFactory emf, Object entity, String fetchGroupName) {
235	assertNotNull("Null entity", entity);	236	assertNotNull("Null entity", entity);
236		237
237	ClassDescriptor descriptor = JpaHelper.getServerSession(emf).getClassDescriptor(entity);	238	ClassDescriptor descriptor = JUnitTestCase.getServerSession().getClassDescriptor(entity);
238	assertNotNull("No descriptor found for: " + entity, descriptor);	239	assertNotNull("No descriptor found for: " + entity, descriptor);
239		240
240	assertTrue("No FetchGroupManager on: " + descriptor, descriptor.hasFetchGroupManager());	241	assertTrue("No FetchGroupManager on: " + descriptor, descriptor.hasFetchGroupManager());
Lines 263-269 Link Here
263	}	264	}
264		265
265	public static void assertConfig(EntityManagerFactory emf, String entityName, FetchGroup defaultFetchGroup, int numNamedFetchGroups) {	266	public static void assertConfig(EntityManagerFactory emf, String entityName, FetchGroup defaultFetchGroup, int numNamedFetchGroups) {
266	ClassDescriptor descriptor = JpaHelper.getServerSession(emf).getClassDescriptorForAlias(entityName);	267	ClassDescriptor descriptor = JUnitTestCase.getServerSession().getClassDescriptorForAlias(entityName);
267	assertNotNull("Not descriptor found for: " + entityName, descriptor);	268	assertNotNull("Not descriptor found for: " + entityName, descriptor);
268	assertConfig(descriptor, defaultFetchGroup, numNamedFetchGroups);	269	assertConfig(descriptor, defaultFetchGroup, numNamedFetchGroups);
269	}	270	}

Line 0 Link Here

(-)jpa/eclipselink.jpa.test/src/org/eclipse/persistence/testing/tests/jpa/fetchgroups/FetchGroupsServerTestSuite.java (+41 lines)
	1	/*******************************************************************************
	2	* Copyright (c) 1998, 2010 Oracle. All rights reserved.
	3	* This program and the accompanying materials are made available under the
	4	* terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0
	5	* which accompanies this distribution.
	6	* The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
	7	* and the Eclipse Distribution License is available at
	8	* http://www.eclipse.org/org/documents/edl-v10.php.
	9	*
	10	* Contributors:
	11	* Oracle - initial API and implementation from Oracle TopLink
	12	******************************************************************************/
	13	package org.eclipse.persistence.testing.tests.jpa.fetchgroups;
	14
	15	import junit.framework.TestSuite;
	16	import junit.framework.Test;
	17	import org.eclipse.persistence.testing.framework.junit.JUnitTestCase;
	18
	19	/**
	20	* <p><b>Purpose</b>: To collect the tests that will run against Application Server only.
	21	*/
	22	public class FetchGroupsServerTestSuite extends TestSuite {
	23
	24	public static Test suite() {
	25	TestSuite suite = new TestSuite();
	26	suite.setName("FetchGroups ServerTestSuite");
	27	suite.addTest(FetchGroupAPITests.suite());
	28	suite.addTest(FetchGroupTrackerWeavingTests.suite());
	29	suite.addTest(NestedFetchGroupTests.suite());
	30	suite.addTest(NestedNamedFetchGroupTests.suite());
	31	suite.addTest(SimpleDefaultFetchGroupTests.suite());
	32	suite.addTest(SimpleNamedFetchGroupTests.suite());
	33	if (! JUnitTestCase.isJPA10()) {
	34	suite.addTest(FetchGroupMergeWithCacheTests.suite());
	35	suite.addTest(NestedDefaultFetchGroupTests.suite());
	36	suite.addTest(SimpleFetchGroupTests.suite());
	37	suite.addTest(SimpleSerializeFetchGroupTests.suite());
	38	}
	39	return suite;
	40	}
	41	}

Lines 51-65 Link Here

(-)jpa/eclipselink.jpa.test/src/org/eclipse/persistence/testing/tests/jpa/fetchgroups/FetchGroupTrackerWeavingTests.java (-9 lines)
51	public FetchGroupTrackerWeavingTests(String name) {	51	public FetchGroupTrackerWeavingTests(String name) {
52	super(name);	52	super(name);
53	}	53	}
54
55	/*
56	* Fetch Group tests require weaving.
57	*/
58	public void runBare() throws Throwable {
59	if (isWeavingEnabled()) {
60	super.runBare();
61	}
62	}
63		54
64	public static junit.framework.Test suite() {	55	public static junit.framework.Test suite() {
65	TestSuite suite = new TestSuite();	56	TestSuite suite = new TestSuite();