| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| <<<<<<< Updated upstream |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| ======= |
| * |
| * https://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| >>>>>>> Stashed changes |
| * limitations under the License. |
| */ |
| |
| package org.apache.jdo.tck.api.fetchgroup; |
| |
| import java.util.Arrays; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.Iterator; |
| import java.util.Map; |
| import java.util.Set; |
| import javax.jdo.FetchGroup; |
| import javax.jdo.JDOException; |
| import org.apache.jdo.tck.JDO_Test; |
| import org.apache.jdo.tck.pc.company.Address; |
| import org.apache.jdo.tck.pc.company.Company; |
| import org.apache.jdo.tck.pc.company.DentalInsurance; |
| import org.apache.jdo.tck.pc.company.Department; |
| import org.apache.jdo.tck.pc.company.Employee; |
| import org.apache.jdo.tck.pc.company.FullTimeEmployee; |
| import org.apache.jdo.tck.pc.company.IEmployee; |
| import org.apache.jdo.tck.pc.company.Insurance; |
| import org.apache.jdo.tck.pc.company.MedicalInsurance; |
| import org.apache.jdo.tck.pc.company.PIEmployee; |
| import org.apache.jdo.tck.pc.company.PartTimeEmployee; |
| import org.apache.jdo.tck.pc.company.Person; |
| import org.apache.jdo.tck.pc.company.Project; |
| import org.apache.jdo.tck.util.BatchTestRunner; |
| |
| /** |
| * This class is an abstract superclass for the fetch plan tests. It contains methods useful for |
| * testing the behavior of the fetch plan. |
| */ |
| public class FetchGroupTest extends JDO_Test { |
| |
| /** |
| * The <code>main</code> is called when the class is directly executed from the command line. |
| * |
| * @param args The arguments passed to the program. |
| */ |
| public static void main(String[] args) { |
| BatchTestRunner.run(FetchGroupTest.class); |
| } |
| |
| /** All fetch groups in this PMF. */ |
| protected Set<FetchGroup> allPMFFetchGroups; |
| |
| /** |
| * Employee.java: private Date hiredate; private double weeklyhours; private DentalInsurance |
| * dentalInsurance; private MedicalInsurance medicalInsurance; private Department department; |
| * private Department fundingDept; private Employee manager; private Employee mentor; private |
| * Employee protege; private Employee hradvisor; private transient Set reviewedProjects = new |
| * HashSet(); // element-type is Project private transient Set projects = new HashSet(); // |
| * element-type is Project private transient Set team = new HashSet(); // element-type is Employee |
| * private transient Set hradvisees = new HashSet(); // element-type is Employee Person.java: |
| * private long personid; private String firstname; private String lastname; private String |
| * middlename; private Date birthdate; private Address address; private Map phoneNumbers = new |
| * HashMap(); |
| */ |
| protected final String[] basicMembers = |
| new String[] { |
| "hiredate", "weeklyhours", "personid", "firstname", "lastname", "middlename", "birthdate" |
| }; |
| /** In org/apache/jdo/tck/pc/package.jdo, middlename is not in DFG */ |
| protected final String[] defaultMembers = |
| new String[] {"hiredate", "weeklyhours", "personid", "firstname", "lastname", "birthdate"}; |
| |
| protected final String[] allMembers = |
| new String[] { |
| "hiredate", |
| "weeklyhours", |
| "dentalInsurance", |
| "medicalInsurance", |
| "department", |
| "fundingDept", |
| "manager", |
| "mentor", |
| "protege", |
| "hradvisor", |
| "reviewedProjects", |
| "projects", |
| "team", |
| "hradvisees", |
| "personid", |
| "firstname", |
| "lastname", |
| "middlename", |
| "birthdate", |
| "address", |
| "phoneNumbers" |
| }; |
| /** Address address is of type Address and is a relationship */ |
| protected final String[] relationshipMembers = |
| new String[] { |
| "dentalInsurance", |
| "medicalInsurance", |
| "department", |
| "fundingDept", |
| "manager", |
| "mentor", |
| "protege", |
| "hradvisor", |
| "reviewedProjects", |
| "projects", |
| "team", |
| "hradvisees", |
| "address" |
| }; |
| /** Map phoneNumbers is not a relationship but is multivalued */ |
| protected final String[] multivaluedMembers = |
| new String[] {"reviewedProjects", "projects", "team", "hradvisees", "phoneNumbers"}; |
| |
| protected final String[] allButMultivaluedMembers = |
| new String[] { |
| "hiredate", |
| "weeklyhours", |
| "dentalInsurance", |
| "medicalInsurance", |
| "department", |
| "fundingDept", |
| "manager", |
| "mentor", |
| "protege", |
| "hradvisor", |
| "personid", |
| "firstname", |
| "lastname", |
| "middlename", |
| "birthdate", |
| "address" |
| }; |
| |
| /** SetUp for test. */ |
| public void localSetUp() { |
| getPM(); // initialize pmf and pm fields |
| } |
| |
| @SuppressWarnings("unchecked") |
| public void testPMFGetFetchGroup() { |
| allPMFFetchGroups = pmf.getFetchGroups(); |
| Map<String, FetchGroup> unscopedFetchGroupMap = new HashMap<>(); |
| unscopedFetchGroupMap.put("Address+default", pmf.getFetchGroup(Address.class, "default")); |
| unscopedFetchGroupMap.put("Company+default", pmf.getFetchGroup(Company.class, "default")); |
| unscopedFetchGroupMap.put( |
| "DentalInsurance+default", pmf.getFetchGroup(DentalInsurance.class, "default")); |
| unscopedFetchGroupMap.put("Department+default", pmf.getFetchGroup(Department.class, "default")); |
| unscopedFetchGroupMap.put("Employee+default", pmf.getFetchGroup(Employee.class, "default")); |
| unscopedFetchGroupMap.put( |
| "FullTimeEmployee+default", pmf.getFetchGroup(FullTimeEmployee.class, "default")); |
| unscopedFetchGroupMap.put("Insurance+default", pmf.getFetchGroup(Insurance.class, "default")); |
| unscopedFetchGroupMap.put( |
| "MedicalInsurance+default", pmf.getFetchGroup(MedicalInsurance.class, "default")); |
| unscopedFetchGroupMap.put( |
| "PartTimeEmployee+default", pmf.getFetchGroup(PartTimeEmployee.class, "default")); |
| unscopedFetchGroupMap.put("Person+default", pmf.getFetchGroup(Person.class, "default")); |
| unscopedFetchGroupMap.put("Project+default", pmf.getFetchGroup(Project.class, "default")); |
| } |
| |
| public void testPMFGetFetchGroupHashCode() { |
| FetchGroup scoped = pm.getFetchGroup(Address.class, "default"); |
| FetchGroup unscoped = pmf.getFetchGroup(Address.class, "default"); |
| int actual = scoped.hashCode(); |
| int expected = unscoped.hashCode(); |
| assertEquals( |
| "Scoped hash code does not equal unscoped hash code;" |
| + "Expected: " |
| + expected |
| + " actual: " |
| + actual, |
| actual, |
| expected); |
| } |
| |
| public void testPMGetFetchGroupIdentical() { |
| FetchGroup scoped = pm.getFetchGroup(Address.class, "default"); |
| FetchGroup identical = pm.getFetchGroup(Address.class, "default"); |
| assertSame( |
| "Modifiable FetchGroup is not identical to modifiable FetchGroup;" |
| + "FetchGroup: " |
| + printFetchGroup(scoped) |
| + " identical: " |
| + printFetchGroup(identical), |
| scoped, |
| identical); |
| } |
| |
| public void testPMGetFetchGroupUnmodifiableNotIdentical() { |
| FetchGroup scoped = pm.getFetchGroup(Address.class, "default"); |
| scoped.setUnmodifiable(); |
| FetchGroup modifiable = pm.getFetchGroup(Address.class, "default"); |
| assertNotSame( |
| "Unmodifiable FetchGroup is identical to modifiable FetchGroup;" |
| + "\nunmodifiable: " |
| + printFetchGroup(scoped) |
| + "\n modifiable: " |
| + printFetchGroup(modifiable), |
| scoped, |
| modifiable); |
| } |
| |
| public void testPMFGetFetchGroupNotIdentical() { |
| FetchGroup first = pmf.getFetchGroup(Address.class, "default"); |
| FetchGroup second = pmf.getFetchGroup(Address.class, "default"); |
| assertNotSame( |
| "First FetchGroup is identical to second FetchGroup;" |
| + "\n first: " |
| + printFetchGroup(first) |
| + "\nsecond: " |
| + printFetchGroup(second), |
| first, |
| second); |
| } |
| |
| public void testPMGetFetchGroupEquals() { |
| FetchGroup unmodifiable = pm.getFetchGroup(Address.class, "default"); |
| unmodifiable.setUnmodifiable(); |
| FetchGroup modifiable = pm.getFetchGroup(Address.class, "default"); |
| assertEquals( |
| "Unmodifiable FetchGroup is not equal to modifiable FetchGroup;" |
| + "\nunmodifiable: " |
| + printFetchGroup(unmodifiable) |
| + "\n modifiable: " |
| + printFetchGroup(modifiable), |
| unmodifiable, |
| modifiable); |
| } |
| |
| public void testPMModifiable() { |
| FetchGroup scoped = pm.getFetchGroup(Address.class, "default"); |
| assertFalse( |
| "Scoped FetchGroup should be modifiable initially, but is unmodifiable.", |
| scoped.isUnmodifiable()); |
| scoped.setUnmodifiable(); |
| assertTrue( |
| "Scoped FetchGroup should be unmodifiable after setUnmodifiable, but is modifiable.", |
| scoped.isUnmodifiable()); |
| } |
| |
| public void testPMFModifiable() { |
| FetchGroup scoped = pmf.getFetchGroup(Address.class, "default"); |
| assertFalse( |
| "Unscoped FetchGroup should be modifiable initially, but is unmodifiable.", |
| scoped.isUnmodifiable()); |
| scoped.setUnmodifiable(); |
| assertTrue( |
| "Unscoped FetchGroup should be unmodifiable after setUnmodifiable, but is modifiable.", |
| scoped.isUnmodifiable()); |
| } |
| |
| public void testCategoriesClass() { |
| checkAddCategory(Employee.class, FetchGroup.ALL, allMembers); |
| checkAddCategory(Employee.class, FetchGroup.BASIC, basicMembers); |
| checkAddCategory(Employee.class, FetchGroup.DEFAULT, defaultMembers); |
| checkAddCategory(Employee.class, FetchGroup.RELATIONSHIP, relationshipMembers); |
| checkAddCategory(Employee.class, FetchGroup.MULTIVALUED, multivaluedMembers); |
| failOnError(); |
| } |
| |
| public void testCategoriesInterface() { |
| checkAddCategory(PIEmployee.class, FetchGroup.ALL, allMembers); |
| checkAddCategory(PIEmployee.class, FetchGroup.BASIC, basicMembers); |
| checkAddCategory(PIEmployee.class, FetchGroup.DEFAULT, defaultMembers); |
| checkAddCategory(PIEmployee.class, FetchGroup.RELATIONSHIP, relationshipMembers); |
| checkAddCategory(PIEmployee.class, FetchGroup.MULTIVALUED, multivaluedMembers); |
| failOnError(); |
| } |
| |
| @SuppressWarnings("unchecked") |
| public void testRemoveCategory() { |
| FetchGroup fg = pm.getFetchGroup(Employee.class, "testRemoveCategory"); |
| Set<String> expectedSet = new HashSet<>(); |
| expectedSet.addAll(Arrays.asList(allButMultivaluedMembers)); |
| Set<String> members = fg.getMembers(); |
| fg.addCategory(FetchGroup.ALL); |
| fg.removeCategory(FetchGroup.MULTIVALUED); |
| members = fg.getMembers(); |
| assertEquals( |
| "FetchGroup.addCategory(all).removeCategory(multivalued)" |
| + " should contain all but multivalued members.\n", |
| expectedSet, |
| members); |
| } |
| |
| @SuppressWarnings("unchecked") |
| public void testAddMember() { |
| FetchGroup fg = pm.getFetchGroup(Employee.class, "testAddMember"); |
| for (int i = 0; i < allMembers.length; ++i) { |
| String member = allMembers[i]; |
| fg.addMember(member); |
| Set<String> members = fg.getMembers(); |
| assertTrue( |
| "FetchGroup should contain " + member + " but does not.\n" + printFetchGroup(fg), |
| members.contains(member)); |
| assertEquals( |
| "FetchGroup should contain " + i + 1 + "members, but does not; ", i + 1, members.size()); |
| } |
| } |
| |
| @SuppressWarnings("unchecked") |
| public void testAddMembers() { |
| FetchGroup fg = pm.getFetchGroup(Employee.class, "testAddMembers"); |
| fg.addMembers(multivaluedMembers); |
| fg.addMembers(allButMultivaluedMembers); |
| Set<String> members = fg.getMembers(); |
| Set<String> expectedSet = new HashSet<>(); |
| expectedSet.addAll(Arrays.asList(allMembers)); |
| assertEquals("FetchGroup should contain all members.\n", expectedSet, members); |
| } |
| |
| @SuppressWarnings("unchecked") |
| public void testRemoveMembers() { |
| FetchGroup fg = pm.getFetchGroup(Employee.class, "testRemoveMembers"); |
| fg.addMembers(allMembers); |
| fg.removeMembers(relationshipMembers); |
| Set<String> members = fg.getMembers(); |
| Set<String> expectedSet = new HashSet<>(); |
| expectedSet.addAll(Arrays.asList(basicMembers)); |
| expectedSet.add("phoneNumbers"); |
| assertEquals( |
| "FetchGroup should contain basic members " + "plus address plus phoneNumbers.\n", |
| expectedSet, |
| members); |
| fg.removeMembers(basicMembers); |
| members = fg.getMembers(); |
| expectedSet = new HashSet<>(); |
| expectedSet.add("phoneNumbers"); |
| assertEquals("FetchGroup should contain address plus phoneNumbers.\n", expectedSet, members); |
| } |
| |
| @SuppressWarnings("unchecked") |
| public void testRemoveMember() { |
| FetchGroup fg = pm.getFetchGroup(Employee.class, "testRemoveMember"); |
| fg.addCategory(FetchGroup.ALL); |
| for (int i = allMembers.length - 1; i >= 0; --i) { |
| String member = allMembers[i]; |
| fg.removeMember(member); |
| Set<String> members = fg.getMembers(); |
| assertFalse( |
| "FetchGroup should not contain " + member + " but does.\n" + printFetchGroup(fg), |
| members.contains(member)); |
| assertEquals("FetchGroup should contain " + i + "members, but does not; ", i, members.size()); |
| } |
| } |
| |
| public void testRecursionDepth() { |
| FetchGroup fg = pm.getFetchGroup(Employee.class, "testRecursionDepth"); |
| fg.addMember("manager"); |
| int depth = fg.getRecursionDepth("manager"); |
| assertEquals( |
| "Initial recursion depth for manager should be 1." + printFetchGroup(fg), 1, depth); |
| fg.setRecursionDepth("manager", 64); |
| assertEquals( |
| "Recursion depth for manager should be 64." + printFetchGroup(fg), |
| 64, |
| fg.getRecursionDepth("manager")); |
| } |
| |
| public void testPostLoad() { |
| FetchGroup fg = pm.getFetchGroup(Employee.class, "testPostLoad"); |
| assertFalse( |
| "New FetchGroup should have post-load false; " + printFetchGroup(fg), fg.getPostLoad()); |
| fg.setPostLoad(true); |
| assertTrue( |
| "After setPostLoad(true) FetchGroup should have post-load true; " + printFetchGroup(fg), |
| fg.getPostLoad()); |
| fg.setPostLoad(false); |
| assertFalse( |
| "After setPostLoad, FetchGroup should have post-load false; " + printFetchGroup(fg), |
| fg.getPostLoad()); |
| } |
| |
| public void testUnmodifiableSetPostLoad() { |
| FetchGroup fg = pm.getFetchGroup(Employee.class, "testUnmodifiableSetPostLoad"); |
| fg.setUnmodifiable(); |
| try { |
| fg.setPostLoad(true); |
| fail("Unmodifiable FetchGroup should throw on setPostLoad."); |
| } catch (JDOException ex) { |
| // good catch! |
| } |
| } |
| |
| public void testUnmodifiableAddMember() { |
| FetchGroup fg = pm.getFetchGroup(Employee.class, "testUnmodifiableAddMember"); |
| fg.setUnmodifiable(); |
| try { |
| fg.addMember("hiredate"); |
| fail("Unmodifiable FetchGroup should throw on addMember."); |
| } catch (JDOException ex) { |
| // good catch! |
| } |
| } |
| |
| public void testUnmodifiableAddMembers() { |
| FetchGroup fg = pm.getFetchGroup(Employee.class, "testUnmodifiableAddMembers"); |
| fg.setUnmodifiable(); |
| try { |
| fg.addMembers(allMembers); |
| fail("Unmodifiable FetchGroup should throw on addMembers."); |
| } catch (JDOException ex) { |
| // good catch! |
| } |
| } |
| |
| public void testUnmodifiableRemoveMember() { |
| FetchGroup fg = pm.getFetchGroup(Employee.class, "testUnmodifiableRemoveMember"); |
| fg.addMembers(allMembers); |
| fg.setUnmodifiable(); |
| try { |
| fg.removeMember("hiredate"); |
| fail("Unmodifiable FetchGroup should throw on removeMember."); |
| } catch (JDOException ex) { |
| // good catch! |
| } |
| } |
| |
| public void testUnmodifiableRemoveMembers() { |
| FetchGroup fg = pm.getFetchGroup(Employee.class, "testUnmodifiableRemoveMembers"); |
| fg.addMembers(allMembers); |
| fg.setUnmodifiable(); |
| try { |
| fg.removeMembers(allMembers); |
| fail("Unmodifiable FetchGroup should throw on removeMembers."); |
| } catch (JDOException ex) { |
| // good catch! |
| } |
| } |
| |
| public void testUnmodifiableAddCategory() { |
| FetchGroup fg = pm.getFetchGroup(Employee.class, "testUnmodifiableAddCategory"); |
| fg.setUnmodifiable(); |
| try { |
| fg.addCategory(FetchGroup.ALL); |
| fail("Unmodifiable FetchGroup should throw on addCategory."); |
| } catch (JDOException ex) { |
| // good catch! |
| } |
| } |
| |
| public void testUnmodifiableRemoveCategory() { |
| FetchGroup fg = pm.getFetchGroup(Employee.class, "testUnmodifiableRemoveCategory"); |
| fg.addCategory(FetchGroup.ALL); |
| fg.setUnmodifiable(); |
| try { |
| fg.removeCategory(FetchGroup.ALL); |
| fail("Unmodifiable FetchGroup should throw on removeCategory."); |
| } catch (JDOException ex) { |
| // good catch! |
| } |
| } |
| |
| public void testUnmodifiableSetRecursionDepth() { |
| FetchGroup fg = pm.getFetchGroup(Employee.class, "testUnmodifiableSetRecursionDepth"); |
| fg.setUnmodifiable(); |
| try { |
| fg.setRecursionDepth("hiredate", 64); |
| fail("Unmodifiable FetchGroup should throw on setRecursionDepth."); |
| } catch (JDOException ex) { |
| // good catch! |
| } |
| } |
| |
| public void testUnmodifiableSetUnmodifiable() { |
| FetchGroup fg = pm.getFetchGroup(Employee.class, "testUnmodifiableSetUnmodifiable"); |
| fg.setUnmodifiable(); |
| fg.setUnmodifiable(); // should be ok |
| } |
| |
| public void testPMGetFetchGroupClassNotPersistenceCapable() { |
| try { |
| FetchGroup fg = |
| pm.getFetchGroup(Integer.class, "testPMGetFetchGroupClassNotPersistenceCapable"); |
| fail("getFetchGroup should throw on nonPersistenceCapable class."); |
| } catch (JDOException ex) { |
| // good catch! |
| } |
| } |
| |
| public void testPMGetFetchGroupInterfaceNotPersistenceCapable() { |
| try { |
| FetchGroup fg = |
| pm.getFetchGroup(IEmployee.class, "testPMGetFetchGroupInterfaceNotPersistenceCapable"); |
| fail("getFetchGroup should throw on nonPersistenceCapable interface."); |
| } catch (JDOException ex) { |
| // good catch! |
| } |
| } |
| |
| public void testPMFGetFetchGroupClassNotPersistenceCapable() { |
| try { |
| FetchGroup fg = |
| pmf.getFetchGroup( |
| Integer.class, |
| "testtestPMFGetFetchGroupClassNotPersistenceCapableGetFetchGroupClassNotPersistenceCapable"); |
| fail("getFetchGroup should throw on nonPersistenceCapable class."); |
| } catch (JDOException ex) { |
| // good catch! |
| } |
| } |
| |
| public void testPMFGetFetchGroupInterfaceNotPersistenceCapable() { |
| try { |
| FetchGroup fg = |
| pmf.getFetchGroup(IEmployee.class, "testPMFGetFetchGroupInterfaceNotPersistenceCapable"); |
| fail("getFetchGroup should throw on nonPersistenceCapable interface."); |
| } catch (JDOException ex) { |
| // good catch! |
| } |
| } |
| |
| public void testAddMemberNotAMember() { |
| FetchGroup fg = pm.getFetchGroup(Employee.class, "testAddMemberNotAMember"); |
| try { |
| fg.addMember("NotAMember"); |
| fail("FetchGroup should throw on addMember(NotAMember)."); |
| } catch (JDOException ex) { |
| // good catch! |
| } |
| } |
| |
| public void testAddMembersNotAMember() { |
| FetchGroup fg = pm.getFetchGroup(Employee.class, "testAddMembersNotAMember"); |
| try { |
| fg.addMembers(new String[] {"NotAMember"}); |
| fail("FetchGroup should throw on addMembers(NotAMember)."); |
| } catch (JDOException ex) { |
| // good catch! |
| } |
| } |
| |
| public void testRemoveMemberNotAMember() { |
| FetchGroup fg = pm.getFetchGroup(Employee.class, "testRemoveMemberNotAMember"); |
| fg.addCategory(FetchGroup.ALL); |
| try { |
| fg.removeMember("NotAMember"); |
| fail("FetchGroup should throw on removeMember(NotAMember)."); |
| } catch (JDOException ex) { |
| // good catch! |
| } |
| } |
| |
| public void testRemoveMembersNotAMember() { |
| FetchGroup fg = pm.getFetchGroup(Employee.class, "testRemoveMembersNotAMember"); |
| fg.addCategory(FetchGroup.ALL); |
| try { |
| fg.removeMembers(new String[] {"NotAMember"}); |
| fail("FetchGroup should throw on removeMembers(NotAMember)."); |
| } catch (JDOException ex) { |
| // good catch! |
| } |
| } |
| |
| public void testSetRecursionDepthNotAMember() { |
| FetchGroup fg = pm.getFetchGroup(Employee.class, "testSetRecursionDepthNotAMember"); |
| try { |
| fg.setRecursionDepth("NotAMember", 64); |
| fail("FetchGroup should throw on setRecursionDepth(NotAMember)."); |
| } catch (JDOException ex) { |
| // good catch! |
| } |
| } |
| |
| @SuppressWarnings("unchecked") |
| private void checkAddCategory(Class<?> cls, String category, String[] expected) { |
| FetchGroup fg = pm.getFetchGroup(cls, "test" + count() + category); |
| Set<String> expectedSet = new HashSet<>(); |
| expectedSet.addAll(Arrays.asList(expected)); |
| Set<String> members = fg.getMembers(); |
| assertTrue("New FetchGroup should have no members; " + printFetchGroup(fg), members.isEmpty()); |
| fg.addCategory(category); |
| members = fg.getMembers(); |
| if (!members.equals(expectedSet)) { |
| appendMessage( |
| "FetchGroup(" |
| + cls.getName() |
| + ".addCategory(" |
| + category |
| + ") should contain\n" |
| + expectedSet |
| + " but contains\n" |
| + members); |
| } |
| } |
| |
| @SuppressWarnings("unchecked") |
| private String printFetchGroup(FetchGroup fg) { |
| StringBuffer sb = new StringBuffer("FetchGroup ("); |
| sb.append(fg.getType().isInterface() ? "interface: " : "class: "); |
| sb.append(fg.getType().getName()); |
| sb.append("; name: "); |
| sb.append(fg.getName()); |
| sb.append(fg.isUnmodifiable() ? "; unmodifiable" : "; modifiable"); |
| Set<String> members = fg.getMembers(); |
| Iterator<String> it = members.iterator(); |
| if (it.hasNext()) { |
| sb.append("; members: "); |
| String member = it.next(); |
| formatMember(sb, fg, member); |
| } |
| while (it.hasNext()) { |
| sb.append(", "); |
| String member = it.next(); |
| formatMember(sb, fg, member); |
| } |
| sb.append(")"); |
| return sb.toString(); |
| } |
| |
| protected void formatMember(StringBuffer sb, FetchGroup fg, String member) { |
| sb.append(member); |
| sb.append("["); |
| sb.append(fg.getRecursionDepth(member)); |
| sb.append("]"); |
| } |
| |
| /** Counter */ |
| protected int counter = 0; |
| |
| protected String count() { |
| return String.valueOf(counter++); |
| } |
| } |