| /* |
| * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved. |
| * |
| * This program and the accompanying materials are made available under the |
| * terms of the Eclipse Public License v. 2.0 which is available at |
| * http://www.eclipse.org/legal/epl-2.0, |
| * or the Eclipse Distribution License v. 1.0 which is available at |
| * http://www.eclipse.org/org/documents/edl-v10.php. |
| * |
| * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause |
| */ |
| |
| // Contributors: |
| // 05/05/2009 Andrei Ilitchev |
| // - JPA 2.0 - OrderedList support. |
| package org.eclipse.persistence.testing.tests.orderedlist; |
| |
| import java.util.ArrayList; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Vector; |
| |
| import org.eclipse.persistence.annotations.OrderCorrectionType; |
| import org.eclipse.persistence.descriptors.ClassDescriptor; |
| import org.eclipse.persistence.descriptors.changetracking.AttributeChangeTrackingPolicy; |
| import org.eclipse.persistence.descriptors.changetracking.ObjectChangePolicy; |
| import org.eclipse.persistence.descriptors.changetracking.ObjectChangeTrackingPolicy; |
| import org.eclipse.persistence.exceptions.QueryException; |
| import org.eclipse.persistence.expressions.Expression; |
| import org.eclipse.persistence.expressions.ExpressionBuilder; |
| import org.eclipse.persistence.indirection.IndirectList; |
| import org.eclipse.persistence.internal.databaseaccess.DatabasePlatform; |
| import org.eclipse.persistence.internal.queries.OrderedListContainerPolicy; |
| import org.eclipse.persistence.internal.sessions.AbstractRecord; |
| import org.eclipse.persistence.mappings.CollectionMapping; |
| import org.eclipse.persistence.queries.DataReadQuery; |
| import org.eclipse.persistence.queries.ReadAllQuery; |
| import org.eclipse.persistence.queries.ReadObjectQuery; |
| import org.eclipse.persistence.queries.ReadQuery; |
| import org.eclipse.persistence.queries.ReportQuery; |
| import org.eclipse.persistence.queries.ReportQueryResult; |
| import org.eclipse.persistence.sessions.UnitOfWork; |
| import org.eclipse.persistence.testing.framework.TestCase; |
| import org.eclipse.persistence.testing.framework.TestErrorException; |
| import org.eclipse.persistence.testing.framework.TestModel; |
| import org.eclipse.persistence.testing.models.orderedlist.*; |
| import org.eclipse.persistence.testing.models.orderedlist.EmployeeSystem.ChangeTracking; |
| import org.eclipse.persistence.testing.models.orderedlist.EmployeeSystem.JoinFetchOrBatchRead; |
| |
| import org.eclipse.persistence.testing.framework.TestProblemException; |
| |
| public class OrderListTestModel extends TestModel { |
| /* |
| * Indicates whether to run configuration that don't use listOrderField (useListOrderField==false). |
| * By default is set to false. |
| * Set it to true for debugging: |
| * if something fails with listOrderField (useListOrderField==true) see if it also fails without it. |
| */ |
| static boolean shouldRunWithoutListOrderField = false; |
| |
| /* |
| * There is a single top level model (contained in TestRunModel) that contains multiple models. |
| */ |
| boolean isTopLevel; |
| |
| /* |
| * Top level model loops through all possible combinations of the attributes below and decides whether the combination should run. |
| * Foe each combination of values that should run a model is created and added to the top level model. |
| */ |
| boolean useListOrderField; |
| boolean isPrivatelyOwned; |
| boolean useIndirection; |
| boolean useSecondaryTable; |
| boolean useVarcharOrder; |
| ChangeTracking changeTracking; |
| OrderCorrectionType orderCorrectionType; |
| boolean shouldOverrideContainerPolicy; |
| JoinFetchOrBatchRead joinFetchOrBatchRead; |
| |
| /* |
| * Variables below used by setup / reset: |
| * setup saves there the original state of something, sets a new state required for testing, |
| * then reset brings back the saved original state. |
| */ |
| Map<Class, ObjectChangeTrackingPolicy> originalChangeTrackingPolicies; |
| |
| /* |
| * Constants used by WhereToAdd tests. |
| */ |
| static final String front = "front"; |
| static final String middle = "middle"; |
| static final String end = "end"; |
| |
| /** |
| * Return the JUnit suite to allow JUnit runner to find it. |
| * Unfortunately JUnit only allows suite methods to be static, |
| * so it is not possible to generically do this. |
| */ |
| public static junit.framework.TestSuite suite() { |
| return new OrderListTestModel(); |
| } |
| |
| public OrderListTestModel() { |
| setDescription("This model tests ordered list."); |
| isTopLevel = true; |
| } |
| |
| void addTestModel(DatabasePlatform platform) { |
| if (shouldAddModel(platform)) { |
| addTest(new OrderListTestModel(useListOrderField, useIndirection, isPrivatelyOwned, useSecondaryTable, useVarcharOrder, changeTracking, orderCorrectionType, shouldOverrideContainerPolicy, joinFetchOrBatchRead)); |
| } |
| } |
| |
| /* |
| * Loops through all possible model configurations and adds those for which shouldAddModel returns true. |
| */ |
| void addModels() { |
| DatabasePlatform platform = getSession().getPlatform(); |
| changeTracking = ChangeTracking.ATTRIBUTE; |
| orderCorrectionType = OrderCorrectionType.READ_WRITE; |
| joinFetchOrBatchRead = JoinFetchOrBatchRead.NONE; |
| useVarcharOrder = false; |
| useSecondaryTable = false; |
| isPrivatelyOwned = false; |
| useIndirection = true; |
| useListOrderField = true; |
| shouldOverrideContainerPolicy = false; |
| useVarcharOrder = true; |
| addTestModel(platform); |
| useVarcharOrder = false; |
| useSecondaryTable = true; |
| addTestModel(platform); |
| useSecondaryTable = false; |
| useIndirection = false; |
| changeTracking = ChangeTracking.DEFERRED; |
| addTestModel(platform); |
| changeTracking = ChangeTracking.ATTRIBUTE; |
| useIndirection = true; |
| shouldOverrideContainerPolicy = true; |
| addTestModel(platform); |
| shouldOverrideContainerPolicy = false; |
| for (int i=0; i < ChangeTracking.values().length; i++) { |
| changeTracking = ChangeTracking.values()[i]; |
| addTestModel(platform); |
| } |
| isPrivatelyOwned = true; |
| for (int i=0; i < ChangeTracking.values().length; i++) { |
| changeTracking = ChangeTracking.values()[i]; |
| addTestModel(platform); |
| } |
| changeTracking = ChangeTracking.ATTRIBUTE; |
| isPrivatelyOwned = false; |
| for (int j=0; j < OrderCorrectionType.values().length; j++) { |
| orderCorrectionType = OrderCorrectionType.values()[j]; |
| addTestModel(platform); |
| } |
| orderCorrectionType = OrderCorrectionType.READ_WRITE; |
| for (int k=0; k < JoinFetchOrBatchRead.values().length; k++) { |
| joinFetchOrBatchRead = JoinFetchOrBatchRead.values()[k]; |
| addTestModel(platform); |
| } |
| joinFetchOrBatchRead = JoinFetchOrBatchRead.NONE; |
| useSecondaryTable = true; |
| for (int k=0; k < JoinFetchOrBatchRead.values().length; k++) { |
| joinFetchOrBatchRead = JoinFetchOrBatchRead.values()[k]; |
| addTestModel(platform); |
| } |
| joinFetchOrBatchRead = JoinFetchOrBatchRead.NONE; |
| useSecondaryTable = false; |
| /** Un-comment to run 2^6 * 3 * 6 * 15 tests... (a lot...) |
| do { |
| do { |
| do { |
| do { |
| do { |
| for(int i=0; i < ChangeTracking.values().length; i++) { |
| changeTracking = ChangeTracking.values()[i]; |
| for(int j=0; j < OrderCorrectionType.values().length; j++) { |
| orderCorrectionType = OrderCorrectionType.values()[j]; |
| do{ |
| for(int k=0; k < JoinFetchOrBatchRead.values().length; k++) { |
| joinFetchOrBatchRead = JoinFetchOrBatchRead.values()[k]; |
| addTestModel(platform); |
| } |
| shouldOverrideContainerPolicy = !shouldOverrideContainerPolicy; |
| } while(shouldOverrideContainerPolicy); |
| } |
| } |
| useVarcharOrder = !useVarcharOrder; |
| } while(useVarcharOrder); |
| useSecondaryTable = !useSecondaryTable; |
| } while(useSecondaryTable); |
| isPrivatelyOwned = !isPrivatelyOwned; |
| } while(isPrivatelyOwned); |
| useIndirection = !useIndirection; |
| } while(useIndirection); |
| useListOrderField = !useListOrderField; |
| } while(useListOrderField);*/ |
| } |
| |
| /* |
| * Verifies whether the current model configuration should be added. |
| * Cuts the models with invalid configurations, configurations that don't make any difference. |
| */ |
| boolean shouldAddModel(DatabasePlatform platform) { |
| // listOrderField is not used |
| if(!useListOrderField) { |
| // explicitly asked not to run the model that don't use listOrderField. |
| if(!shouldRunWithoutListOrderField) { |
| return false; |
| } |
| // the model would be identical to OrderCorrectionType.READ |
| if(orderCorrectionType != OrderCorrectionType.READ) { |
| return false; |
| } |
| // the model would be identical to useVarcharOrder==false |
| if(useVarcharOrder) { |
| return false; |
| } |
| } |
| |
| // H2 has an issue with large outer joins, causes null-pointer in driver. |
| // |
| // There is an Eclipselink bug: when using old Oracle-style (+) outer joins the inner joins between |
| // primary and secondary tables substituted by outer joins (employee outer join manager causes manager's salary to outer join to manager). |
| // If there happens to be another outer join to the secondary table (in useSecondaryTable case manager_id is in salary table) |
| // then suddenly the secondary table auto joined to two tables - that causes exception: |
| // ORA-01417: a table may be outer joined to at most one other table. |
| // Now by default Oracle joins in FROM clause, TimesTen can't, therefore TimesTen can't run this model. |
| // |
| if (useSecondaryTable && (joinFetchOrBatchRead == JoinFetchOrBatchRead.OUTER_JOIN)) { |
| if (platform.isH2() || platform.isHSQL() || platform.isTimesTen()) { |
| return false; |
| } |
| } |
| if (useVarcharOrder && !platform.supportsAutoConversionToNumericForArithmeticOperations()) { |
| return false; |
| } |
| |
| return true; |
| } |
| |
| public OrderListTestModel(boolean useListOrderField, boolean useIndirection, boolean isPrivatelyOwned, boolean useSecondaryTable, boolean useVarcharOrder, ChangeTracking changeTracking, OrderCorrectionType orderCorrectionType, boolean shouldOverrideContainerPolicy, JoinFetchOrBatchRead joinFetchOrBatchRead) { |
| this.useListOrderField = useListOrderField; |
| this.useIndirection = useIndirection; |
| this.isPrivatelyOwned = isPrivatelyOwned; |
| this.useSecondaryTable = useSecondaryTable; |
| this.useVarcharOrder = useVarcharOrder; |
| this.changeTracking = changeTracking; |
| this.orderCorrectionType = orderCorrectionType; |
| this.shouldOverrideContainerPolicy = shouldOverrideContainerPolicy; |
| this.joinFetchOrBatchRead = joinFetchOrBatchRead; |
| |
| setDescription("This model tests ordered list"); |
| |
| setName(""); |
| addToName(useListOrderField ? "" : "NO_ORDER_LIST"); |
| addToName(useIndirection ? "" : "NO_INDIRECTION"); |
| addToName(isPrivatelyOwned ? "PRIVATE" : ""); |
| addToName(useSecondaryTable ? "SECONDARY_TABLE" : ""); |
| addToName(useVarcharOrder ? "VARCHAR_ORDER" : ""); |
| addToName(changeTracking.toString()); |
| addToName(orderCorrectionType == OrderCorrectionType.READ ? "" : orderCorrectionType.toString()); |
| addToName(shouldOverrideContainerPolicy ? "OVERRIDE_CONTAINER_POLICY" : ""); |
| addToName(joinFetchOrBatchRead.toString()); |
| } |
| |
| void addToName(String strToAdd) { |
| if(strToAdd.length() > 0) { |
| setName(getName() + " " + strToAdd); |
| } |
| } |
| |
| @Override |
| public void addRequiredSystems() { |
| if(!isTopLevel) { |
| addRequiredSystem(new EmployeeSystem(useListOrderField, useIndirection, isPrivatelyOwned, useSecondaryTable, useVarcharOrder, changeTracking, orderCorrectionType, shouldOverrideContainerPolicy, joinFetchOrBatchRead)); |
| } |
| } |
| |
| @Override |
| public void addTests() { |
| if(!isTopLevel) { |
| addTest(new CreateTest()); |
| addTest(new SimpleAddRemoveTest()); |
| // takes too long with joins |
| if(joinFetchOrBatchRead != JoinFetchOrBatchRead.INNER_JOIN && joinFetchOrBatchRead != JoinFetchOrBatchRead.OUTER_JOIN) { |
| addTest(new SimpleAddRemoveTest2()); |
| } |
| // can't run with inner joins because the test sets useResponsibilities and usePhones to false and these lists are empty. |
| if(joinFetchOrBatchRead != JoinFetchOrBatchRead.INNER_JOIN) { |
| addTest(new AddRemoveUpdateTest()); |
| } |
| addTest(new VerifyForeignKeyOfRemovedObject(false)); |
| addTest(new VerifyForeignKeyOfRemovedObject(true)); |
| addTest(new SimpleSetTest()); |
| addTest(new SimpleSetListTest()); |
| addTest(new SimpleSetListTest(false)); |
| addTest(new SimpleSetListTest(true)); |
| addTest(new TranspositionTest(new int[]{0, 1}, new int[]{1, 0}, false)); |
| addTest(new TranspositionTest(new int[]{0, 1}, new int[]{1, 0}, true)); |
| addTest(new TranspositionMergeTest(new int[]{0, 1}, new int[]{1, 0})); |
| addTest(new TranspositionTest(new int[]{1, 3, 5}, new int[]{5, 1, 3}, false)); |
| addTest(new TranspositionTest(new int[]{1, 3, 5}, new int[]{5, 1, 3}, true)); |
| addTest(new TranspositionMergeTest(new int[]{1, 3, 5}, new int[]{5, 1, 3})); |
| // currently only DirectCollectionMapping supports nulls. |
| // bug 278126: Aggregate and Direct collections containing nulls read incorrectly if join is used. |
| // When the bug is fixed the tests should work and condition should be removed. |
| // The bug is partially fixed - the only case result is wrong for DirectCollectionMapping |
| // is a collection that has a single element - null. That collection is read in as empty. |
| addTest(new AddNullTest(front)); |
| addTest(new AddNullTest(middle)); |
| addTest(new AddNullTest(end)); |
| // currently only DirectCollectionMapping supports duplicates. |
| // Duplication doesn't work with joining because of SELECT DISTINCT (would work without DISTINCT). |
| // Should DISTINCT be there? |
| if(joinFetchOrBatchRead != JoinFetchOrBatchRead.INNER_JOIN && joinFetchOrBatchRead != JoinFetchOrBatchRead.OUTER_JOIN) { |
| addTest(new AddDuplicateTest(front)); |
| addTest(new AddDuplicateTest(middle)); |
| addTest(new AddDuplicateTest(end)); |
| } |
| if(joinFetchOrBatchRead == JoinFetchOrBatchRead.OUTER_JOIN) { |
| addTest(new CreateEmptyTest()); |
| addTest(new CreateEmptyManagersTest()); |
| } |
| if(this.useListOrderField) { |
| addTest(new SimpleIndexTest(true)); |
| if(this.shouldOverrideContainerPolicy) { |
| addTest(new VerifyContainerPolicyClassTest()); |
| } |
| if(orderCorrectionType == OrderCorrectionType.EXCEPTION) { |
| if(joinFetchOrBatchRead != JoinFetchOrBatchRead.INNER_JOIN) { |
| addTest(new BreakOrderExceptionTest_OneToMany()); |
| } |
| addTest(new BreakOrderExceptionTest_UnidirectionalOneToMany()); |
| addTest(new BreakOrderExceptionTest_ManyToMany()); |
| addTest(new BreakOrderExceptionTest_DirectCollection()); |
| if(this.changeTracking == ChangeTracking.DEFERRED) { |
| addTest(new BreakOrderExceptionTest_AggregateCollection()); |
| } |
| } else if(orderCorrectionType == OrderCorrectionType.READ_WRITE) { |
| addTest(new BreakOrderCorrectionAndRemoveTest(false)); |
| addTest(new BreakOrderCorrectionAndRemoveTest(true)); |
| addTest(new BreakOrderCorrectionTest(false)); |
| addTest(new BreakOrderCorrectionTest(true)); |
| } |
| } |
| |
| addTest(new CreateManagersTest()); |
| } else { |
| addModels(); |
| } |
| } |
| |
| @Override |
| public void setup() { |
| if(!isTopLevel) { |
| if(changeTracking == ChangeTracking.ATTRIBUTE) { |
| // Save change policies for the all employee demo class in order to restore them at reset time. |
| Map<Class, ObjectChangePolicy> originalChangeTrackingPolicies = new HashMap<>(); |
| |
| originalChangeTrackingPolicies.put(Employee.class, getSession().getDescriptor(Employee.class).getObjectChangePolicy()); |
| getSession().getDescriptor(Employee.class).setObjectChangePolicy(new AttributeChangeTrackingPolicy()); |
| |
| originalChangeTrackingPolicies.put(Project.class, getSession().getDescriptor(Project.class).getObjectChangePolicy()); |
| getSession().getDescriptor(Project.class).setObjectChangePolicy(new AttributeChangeTrackingPolicy()); |
| |
| originalChangeTrackingPolicies.put(SmallProject.class, getSession().getDescriptor(SmallProject.class).getObjectChangePolicy()); |
| getSession().getDescriptor(SmallProject.class).setObjectChangePolicy(new AttributeChangeTrackingPolicy()); |
| |
| originalChangeTrackingPolicies.put(LargeProject.class, getSession().getDescriptor(LargeProject.class).getObjectChangePolicy()); |
| getSession().getDescriptor(LargeProject.class).setObjectChangePolicy(new AttributeChangeTrackingPolicy()); |
| |
| // currently attribute change tracking is incompatible with AggregateCollectionMapping |
| if(this.changeTracking != ChangeTracking.ATTRIBUTE) { |
| originalChangeTrackingPolicies.put(PhoneNumber.class, getSession().getDescriptor(PhoneNumber.class).getObjectChangePolicy()); |
| getSession().getDescriptor(PhoneNumber.class).setObjectChangePolicy(new AttributeChangeTrackingPolicy()); |
| } |
| } |
| } |
| } |
| |
| @Override |
| public void reset() { |
| if(!isTopLevel) { |
| // restore original change policies. |
| if(originalChangeTrackingPolicies != null) { |
| Iterator<Map.Entry<Class, ObjectChangeTrackingPolicy>> it = originalChangeTrackingPolicies.entrySet().iterator(); |
| while(it.hasNext()) { |
| Map.Entry<Class, ObjectChangeTrackingPolicy> entry = it.next(); |
| getSession().getDescriptor(entry.getKey()).setObjectChangePolicy(entry.getValue()); |
| } |
| originalChangeTrackingPolicies = null; |
| } |
| } |
| } |
| |
| /* |
| * Defines operations on Lists that consist of (in that order): |
| * Employees (for empManager.managerEmployees); |
| * Children (for empManager.children); |
| * Projects (for empManager.projects); |
| * Strings (for empManager.responsibilitiesList); |
| * PhoneNumbers (for empManager.phoneNumbers). |
| * That allows to easily create tests that test all mappings using list order field: |
| * OneToMany, UnidirectionalOneToMany, ManyToMany, DirectCollection, AggregateCollection. |
| * |
| * Note that (for debugging purposes) some of these mappings could be "switched off" by setting the corresponding "use..." flag to false. |
| * Don't do that in INNER_JOIN case - or no objects will be ever read back from db. |
| */ |
| class BaseTest extends TestCase { |
| boolean useManagedEmployees; |
| boolean useChildren; |
| boolean useProjects; |
| boolean useResponsibilities; |
| boolean usePhones; |
| |
| String errorMsg; |
| |
| BaseTest() { |
| this.useManagedEmployees = true; |
| this.useChildren = true; |
| this.useProjects = true; |
| this.useResponsibilities = true; |
| this.usePhones = true; |
| setValidFlags(); |
| |
| errorMsg = ""; |
| |
| setName(getShortClassName()); |
| } |
| |
| /* |
| * Sets some of useManagedEmployees, useChildren, useProjects, useResponsibilities, usePhones to false |
| * as required by the flags copied from OrderListTestModel.this. |
| * If changing this method change validateFlags method accordingly. |
| */ |
| protected void setValidFlags() { |
| // currently attribute change tracking is incompatible with AggregateCollectionMapping |
| if(OrderListTestModel.this.changeTracking == ChangeTracking.ATTRIBUTE) { |
| usePhones = false; |
| } |
| // managedEmployees have nothing: no managedEmployees, no children, no projects, no responsibilities, no phones - |
| // can't read them using INNER_JOIN |
| if(OrderListTestModel.this.joinFetchOrBatchRead == JoinFetchOrBatchRead.INNER_JOIN) { |
| useManagedEmployees = false; |
| } |
| } |
| /* |
| * Validate useManagedEmployees, useChildren, useProjects, useResponsibilities, usePhones flags |
| * so their value don't contradict the flags copied from OrderListTestModel.this. |
| * If changing this method change setValidFlags method accordingly. |
| */ |
| protected void validateFlags() { |
| // currently attribute change tracking is incompatible with AggregateCollectionMapping |
| if(OrderListTestModel.this.changeTracking == ChangeTracking.ATTRIBUTE) { |
| if(usePhones) { |
| errorMsg += "ChangeTracking.ATTRIBUTE requires usePhones==false; "; |
| } |
| } |
| // managedEmployees have nothing: no managedEmployees, no children, no projects, no responsibilities, no phones - |
| // can't read them using INNER_JOIN |
| if(OrderListTestModel.this.joinFetchOrBatchRead == JoinFetchOrBatchRead.INNER_JOIN) { |
| if(useManagedEmployees) { |
| errorMsg += "JoinFetchOrBatchRead.INNER_JOIN requires useManagedEmployees==false; "; |
| } |
| } |
| if(errorMsg.length() > 0) { |
| throw new TestProblemException(errorMsg); |
| } |
| } |
| |
| /* |
| * Debugging: putting a breakpoint at the first line of this method is a good place to set some of |
| * useManagedEmployees, useChildren, useProjects, useResponsibilities, usePhones to false if desired. |
| */ |
| @Override |
| public void setup() { |
| if(!useManagedEmployees && !useChildren && !useProjects && !useResponsibilities && !usePhones) { |
| throw new TestProblemException("useManagedEmployees, useChildren, useProjects, useResponsibilities, usePhones are all false - nothing to test"); |
| } |
| validateFlags(); |
| } |
| |
| @Override |
| public void reset() { |
| if(useManagedEmployees) { |
| if(useSecondaryTable) { |
| getSession().executeNonSelectingSQL("UPDATE OL_SALARY SET MANAGER_ID = NULL"); |
| } else { |
| getSession().executeNonSelectingSQL("UPDATE OL_EMPLOYEE SET MANAGER_ID = NULL"); |
| } |
| } |
| if(useChildren) { |
| getSession().executeNonSelectingSQL("DELETE FROM OL_ALLOWANCE"); |
| getSession().executeNonSelectingSQL("DELETE FROM OL_CHILD"); |
| } |
| if(useProjects) { |
| getSession().executeNonSelectingSQL("DELETE FROM OL_PROJ_EMP"); |
| getSession().executeNonSelectingSQL("DELETE FROM OL_LPROJECT"); |
| getSession().executeNonSelectingSQL("DELETE FROM OL_PROJECT"); |
| } |
| if(useResponsibilities) { |
| getSession().executeNonSelectingSQL("DELETE FROM OL_RESPONS"); |
| } |
| if(usePhones) { |
| getSession().executeNonSelectingSQL("DELETE FROM OL_PHONE"); |
| } |
| |
| getSession().executeNonSelectingSQL("DELETE FROM OL_SALARY"); |
| getSession().executeNonSelectingSQL("DELETE FROM OL_EMPLOYEE"); |
| |
| getSession().getIdentityMapAccessor().initializeAllIdentityMaps(); |
| |
| errorMsg = ""; |
| } |
| |
| /* |
| * Creates a list of objects that could be added to manager: Employee, Child, Project, Responsibility (String), PhoneNumber. |
| * Note that indexForName here is used as part of a state of the object being created - not as its position in any list. |
| */ |
| List create(String prefix, int indexForName) { |
| List list = new ArrayList(); |
| String iString = Integer.toString(indexForName); |
| String str = prefix + iString; |
| if(useManagedEmployees) { |
| list.add(new Employee(iString, prefix)); |
| } |
| if(useChildren) { |
| list.add(new Child(iString, prefix)); |
| } |
| if(useProjects) { |
| if(indexForName % 2 == 0) { |
| list.add(new SmallProject(str)); |
| } else { |
| list.add(new LargeProject(str)); |
| } |
| } |
| if(useResponsibilities) { |
| list.add(str); |
| } |
| if(usePhones) { |
| if(prefix.length() > 3) { |
| prefix = prefix.substring(0, 3); |
| } |
| list.add(new PhoneNumber(prefix, iString)); |
| } |
| return list; |
| } |
| |
| /* |
| * Creates a list of nulls that could be added to manager: Employee, Child, Project, Responsibility (String), PhoneNumber. |
| */ |
| List createNull() { |
| List list = new ArrayList(); |
| if(useManagedEmployees) { |
| list.add(null); |
| } |
| if(useChildren) { |
| list.add(null); |
| } |
| if(useProjects) { |
| list.add(null); |
| } |
| if(useResponsibilities) { |
| list.add(null); |
| } |
| if(usePhones) { |
| list.add(null); |
| } |
| return list; |
| } |
| |
| /* |
| * Adds a list of objects to empManager: Employee, Child, Project, Responsibility (String), PhoneNumber. |
| * The list should be obtained from getFrom, create, removeFrom or setInto methods. |
| */ |
| void addTo(Employee empManager, List list) { |
| int i = 0; |
| if(useManagedEmployees) { |
| empManager.addManagedEmployee((Employee)list.get(i++)); |
| } |
| if(useChildren) { |
| empManager.getChildren().add(list.get(i++)); |
| } |
| if(useProjects) { |
| empManager.addProject((Project)list.get(i++)); |
| } |
| if(useResponsibilities) { |
| empManager.addResponsibility((String)list.get(i++)); |
| } |
| if(usePhones) { |
| empManager.addPhoneNumber((PhoneNumber)list.get(i++)); |
| } |
| } |
| |
| /* |
| * Adds a list of objects to empManager at index: Employee, Child, Project, Responsibility (String), PhoneNumber. |
| * The list should be obtained from getFrom, create, removeFrom or setInto methods. |
| */ |
| void addTo(Employee empManager, int index, List list) { |
| int i = 0; |
| if(useManagedEmployees) { |
| empManager.addManagedEmployee(index, (Employee)list.get(i++)); |
| } |
| if(useChildren) { |
| empManager.getChildren().add(index, list.get(i++)); |
| } |
| if(useProjects) { |
| empManager.addProject(index, (Project)list.get(i++)); |
| } |
| if(useResponsibilities) { |
| empManager.addResponsibility(index, (String)list.get(i++)); |
| } |
| if(usePhones) { |
| empManager.addPhoneNumber(index, (PhoneNumber)list.get(i++)); |
| } |
| } |
| |
| /* |
| * Adds a list of objects to empManager at index: Employee, Child, Project, Responsibility (String), PhoneNumber. |
| * The list should be obtained from getFrom, create, removeFrom or setInto methods. |
| */ |
| void addTo_NoRelMaintanence(Employee empManager, int index, List list) { |
| int i = 0; |
| if(useManagedEmployees) { |
| empManager.getManagedEmployees().add(index, (Employee)list.get(i++)); |
| } |
| if(useChildren) { |
| empManager.getChildren().add(index, list.get(i++)); |
| } |
| if(useProjects) { |
| empManager.getProjects().add(index, (Project)list.get(i++)); |
| } |
| if(useResponsibilities) { |
| empManager.addResponsibility(index, (String)list.get(i++)); |
| } |
| if(usePhones) { |
| empManager.addPhoneNumber(index, (PhoneNumber)list.get(i++)); |
| } |
| } |
| |
| /* |
| * Removes a list of objects from empManager at index. |
| * Returns list of removed objects: Employee, Child, Project, Responsibility (String), PhoneNumber. |
| */ |
| List removeFrom(Employee empManager, int index) { |
| List list = new ArrayList(); |
| if(useManagedEmployees) { |
| list.add(empManager.removeManagedEmployee(index)); |
| } |
| if(useChildren) { |
| list.add(empManager.getChildren().remove(index)); |
| } |
| if(useProjects) { |
| list.add(empManager.removeProject(index)); |
| } |
| if(useResponsibilities) { |
| list.add(empManager.removeResponsibility(index)); |
| } |
| if(usePhones) { |
| list.add(empManager.removePhoneNumber(index)); |
| } |
| return list; |
| } |
| |
| /* |
| * Removes a list of objects from empManager at index. |
| * Returns list of removed objects: Employee, Child, Project, Responsibility (String), PhoneNumber. |
| */ |
| List removeFrom_NoRelMaintanence(Employee empManager, int index) { |
| List list = new ArrayList(); |
| if(useManagedEmployees) { |
| list.add(empManager.getManagedEmployees().remove(index)); |
| } |
| if(useChildren) { |
| list.add(empManager.getChildren().remove(index)); |
| } |
| if(useProjects) { |
| list.add(empManager.getProjects().remove(index)); |
| } |
| if(useResponsibilities) { |
| list.add(empManager.removeResponsibility(index)); |
| } |
| if(usePhones) { |
| list.add(empManager.removePhoneNumber(index)); |
| } |
| return list; |
| } |
| |
| /* |
| * Gets a list of objects from empManager at index: Employee, Child, Project, Responsibility (String), PhoneNumber. |
| */ |
| List getFrom(Employee empManager, int index) { |
| List list = new ArrayList(); |
| if(useManagedEmployees) { |
| list.add(empManager.getManagedEmployees().get(index)); |
| } |
| if(useChildren) { |
| list.add(empManager.getChildren().get(index)); |
| } |
| if(useProjects) { |
| list.add(empManager.getProjects().get(index)); |
| } |
| if(useResponsibilities) { |
| list.add(empManager.getResponsibilitiesList().get(index)); |
| } |
| if(usePhones) { |
| list.add(empManager.getPhoneNumbers().get(index)); |
| } |
| return list; |
| } |
| |
| /* |
| * Sets a list of objects into empManager at index. |
| * Returns list of removed objects: Employee, Child, Project, Responsibility (String), PhoneNumber. |
| */ |
| List setInto(Employee empManager, int index, List list) { |
| int i = 0; |
| List listOut = new ArrayList(); |
| if(useManagedEmployees) { |
| listOut.add(empManager.setManagedEmployee(index, (Employee)list.get(i++))); |
| } |
| if(useChildren) { |
| listOut.add(empManager.getChildren().set(index, list.get(i++))); |
| } |
| if(useProjects) { |
| listOut.add(empManager.setProject(index, (Project)list.get(i++))); |
| } |
| if(useResponsibilities) { |
| listOut.add(empManager.setResponsibility(index, (String)list.get(i++))); |
| } |
| if(usePhones) { |
| listOut.add(empManager.setPhoneNumber(index, (PhoneNumber)list.get(i++))); |
| } |
| return listOut; |
| } |
| |
| /* |
| * Sets a list of objects into empManager at index. |
| * Returns list of removed objects: Employee, Child, Project, Responsibility (String), PhoneNumber. |
| */ |
| List setInto_NoRelMaintanence(Employee empManager, int index, List list) { |
| int i = 0; |
| List listOut = new ArrayList(); |
| if(useManagedEmployees) { |
| listOut.add(empManager.getManagedEmployees().set(index, (Employee)list.get(i++))); |
| } |
| if(useChildren) { |
| listOut.add(empManager.getChildren().set(index, list.get(i++))); |
| } |
| if(useProjects) { |
| listOut.add(empManager.getProjects().set(index, (Project)list.get(i++))); |
| } |
| if(useResponsibilities) { |
| listOut.add(empManager.setResponsibility(index, (String)list.get(i++))); |
| } |
| if(usePhones) { |
| listOut.add(empManager.setPhoneNumber(index, (PhoneNumber)list.get(i++))); |
| } |
| return listOut; |
| } |
| |
| /* |
| * Sets lists of objects into empManager using setManagedEmployees, setChildren, setProjects, setResponsibilityList, setPhoneNumbers methods. |
| * The list should be created with createList method. |
| */ |
| void setListInto(Employee empManager, List<List> listOfLists) { |
| int i = 0; |
| if(useManagedEmployees) { |
| List<Employee> newList = listOfLists.get(i++); |
| List<Employee> oldList = empManager.getManagedEmployees(); |
| empManager.setManagedEmployees(newList); |
| if(oldList != null) { |
| for(int j=0; j < oldList.size(); j++) { |
| oldList.get(j).setManager(null); |
| } |
| } |
| if(newList != null) { |
| for(int j=0; j < newList.size(); j++) { |
| newList.get(j).setManager(empManager); |
| } |
| } |
| } |
| if(useChildren) { |
| empManager.setChildren((Vector)listOfLists.get(i++)); |
| } |
| if(useProjects) { |
| List<Project> newList = listOfLists.get(i++); |
| List<Project> oldList = empManager.getProjects(); |
| empManager.setProjects(newList); |
| if(oldList != null) { |
| for(int j=0; j < oldList.size(); j++) { |
| oldList.get(j).getEmployees().remove(empManager); |
| } |
| } |
| if(newList != null) { |
| for(int j=0; j < newList.size(); j++) { |
| newList.get(j).getEmployees().add(empManager); |
| } |
| } |
| } |
| if(useResponsibilities) { |
| empManager.setResponsibilitiesList(listOfLists.get(i++)); |
| } |
| if(usePhones) { |
| empManager.setPhoneNumbers(listOfLists.get(i++)); |
| } |
| } |
| |
| /* |
| * Updates a list of objects that could be added to manager: Employee, Child, Project, Responsibility (String), PhoneNumber. |
| * Note that indexForName here is used as part of a state of the object being updated - not as its position in any list. |
| */ |
| void update( List list, String prefix, int indexForName) { |
| String iString = Integer.toString(indexForName); |
| int i = 0; |
| if(useManagedEmployees) { |
| Employee emp = (Employee)list.get(i++); |
| emp.setFirstName(iString); |
| emp.setLastName(prefix); |
| } |
| if(useChildren) { |
| Child child = (Child)list.get(i++); |
| child.setFirstName(iString); |
| child.setLastName(prefix); |
| } |
| if(useProjects) { |
| Project project = (Project)list.get(i++); |
| project.setName(iString); |
| } |
| if(useResponsibilities) { |
| throw new TestProblemException("Can't update a String. Set useResponsibilities to false"); |
| } |
| if(usePhones) { |
| if(prefix.length() > 3) { |
| prefix = prefix.substring(0, 3); |
| } |
| PhoneNumber phone = (PhoneNumber)list.get(i++); |
| phone.setAreaCode(prefix); |
| phone.setNumber(iString); |
| } |
| } |
| |
| /* |
| * Registers in uow a list of mapped non-aggregated objects that could be added to manager: Employee, Child, Project. |
| * Returns a list that contains clones that could be updated. |
| */ |
| List register(List list, UnitOfWork uow) { |
| ArrayList listClone = new ArrayList(list.size()); |
| int i = 0; |
| if(useManagedEmployees) { |
| listClone.add(uow.registerObject(list.get(i++))); |
| } |
| if(useChildren) { |
| listClone.add(uow.registerObject(list.get(i++))); |
| } |
| if(useProjects) { |
| listClone.add(uow.registerObject(list.get(i++))); |
| } |
| if(useResponsibilities) { |
| throw new TestProblemException("Can't register a String in uow. Set useResponsibilities to false"); |
| } |
| if(usePhones) { |
| throw new TestProblemException("Can't register aggregate in uow. Set usePhones to false"); |
| } |
| return listClone; |
| } |
| |
| /* |
| * Creates a list of Lists that could be set to manager: List<Employee>, Vector, List<Project>, List<String>, List<PhoneNumber>. |
| */ |
| List<List> createList() { |
| List<List> listOfLists = new ArrayList(); |
| if(useManagedEmployees) { |
| listOfLists.add(new ArrayList<Employee>()); |
| } |
| if(useChildren) { |
| listOfLists.add(new Vector()); |
| } |
| if(useProjects) { |
| listOfLists.add(new ArrayList<Project>()); |
| } |
| if(useResponsibilities) { |
| listOfLists.add(new ArrayList<String>()); |
| } |
| if(usePhones) { |
| listOfLists.add(new ArrayList<PhoneNumber>()); |
| } |
| return listOfLists; |
| } |
| |
| /* |
| * Adds a list of objects to listOfLists: Employee, Child, Project, Responsibility (String), PhoneNumber. |
| * listOfLists should be created with createList method. |
| * list should be obtained from getFrom, create, removeFrom or setInto methods. |
| */ |
| void addTo(List<List> listOfLists, List list) { |
| int i = 0; |
| if(useManagedEmployees) { |
| listOfLists.get(i).add(list.get(i++)); |
| } |
| if(useChildren) { |
| listOfLists.get(i).add(list.get(i++)); |
| } |
| if(useProjects) { |
| listOfLists.get(i).add(list.get(i++)); |
| } |
| if(useResponsibilities) { |
| listOfLists.get(i).add(list.get(i++)); |
| } |
| if(usePhones) { |
| listOfLists.get(i).add(list.get(i++)); |
| } |
| } |
| |
| /* |
| * Breaks order in the db by assigning wrong values to order fields |
| */ |
| String getManagegedEmployeesOrderTable() { |
| return useSecondaryTable ? "OL_SALARY" : "OL_EMPLOYEE"; |
| } |
| String getManagegedEmployeesOrderField() { |
| return useVarcharOrder ? "MANAGED_ORDER_VARCHAR" : "MANAGED_ORDER"; |
| } |
| void breakManagedEmployeesOrder() { |
| executeBreak(getManagegedEmployeesOrderTable(), getManagegedEmployeesOrderField(), "1", "NULL"); |
| } |
| String getChildrenOrderTable() { |
| return useSecondaryTable ? "OL_ALLOWANCE" : "OL_CHILD"; |
| } |
| String getChildrenOrderField() { |
| return useVarcharOrder ? "CHILDREN_ORDER_VARCHAR" : "CHILDREN_ORDER"; |
| } |
| void breakChildrenOrder() { |
| executeBreak(getChildrenOrderTable(), getChildrenOrderField(), "0", "NULL"); |
| } |
| void breakProjectsOrder() { |
| String tableName = "OL_PROJ_EMP"; |
| String fieldName; |
| if(useVarcharOrder) { |
| fieldName = "PROJ_ORDER_VARCHAR"; |
| } else { |
| fieldName = "PROJ_ORDER"; |
| } |
| executeBreak(tableName, fieldName, "0", "5"); |
| } |
| void breakResponsibilitiesOrder() { |
| String tableName = "OL_RESPONS"; |
| String fieldName; |
| if(useVarcharOrder) { |
| fieldName = "RESPONS_ORDER_VARCHAR"; |
| } else { |
| fieldName = "RESPONS_ORDER"; |
| } |
| executeBreak(tableName, fieldName, "1", "0"); |
| } |
| void breakPhonesOrder() { |
| String tableName = "OL_PHONE"; |
| String fieldName; |
| if(useVarcharOrder) { |
| fieldName = "PHONE_ORDER_VARCHAR"; |
| } else { |
| fieldName = "PHONE_ORDER"; |
| } |
| executeBreak(tableName, fieldName, "0", "1"); |
| } |
| void executeBreak(String tableName, String fieldName, String oldValue, String newValue) { |
| getSession().executeNonSelectingSQL("UPDATE "+tableName+" SET "+fieldName+" = "+newValue+" WHERE "+fieldName+" = " + oldValue); |
| } |
| void breakOrder() { |
| if(useManagedEmployees) { |
| breakManagedEmployeesOrder(); |
| } |
| if(useChildren) { |
| breakChildrenOrder(); |
| } |
| if(useProjects) { |
| breakProjectsOrder(); |
| } |
| if(useResponsibilities) { |
| breakResponsibilitiesOrder(); |
| } |
| if(usePhones) { |
| breakPhonesOrder(); |
| } |
| } |
| |
| /* |
| * Set the new OrderCorrectionType, return the old one. |
| * Verify that the old modes are the same for all mappings. |
| */ |
| OrderCorrectionType changeOrderCorrectionType(OrderCorrectionType mode) { |
| OrderCorrectionType oldMode = null; |
| if(useManagedEmployees) { |
| oldMode = changeOrderCorrectionType("managedEmployees", mode, oldMode); |
| } |
| if(useChildren) { |
| oldMode = changeOrderCorrectionType("children", mode, oldMode); |
| } |
| if(useProjects) { |
| oldMode = changeOrderCorrectionType("projects", mode, oldMode); |
| } |
| if(useResponsibilities) { |
| oldMode = changeOrderCorrectionType("responsibilitiesList", mode, oldMode); |
| } |
| if(usePhones) { |
| oldMode = changeOrderCorrectionType("phoneNumbers", mode, oldMode); |
| } |
| return oldMode; |
| } |
| OrderCorrectionType changeOrderCorrectionType(String attribute, OrderCorrectionType mode, OrderCorrectionType oldMode) { |
| ClassDescriptor desc = getSession().getDescriptor(Employee.class); |
| CollectionMapping mapping = (CollectionMapping)desc.getMappingForAttributeName(attribute); |
| OrderCorrectionType currOldMode = changeOrderCorrectionType(mapping, mode); |
| if(oldMode != null) { |
| if(oldMode != currOldMode) { |
| throw new TestProblemException("OrderCorrectionTypes for " + attribute+ " is " + currOldMode +"; for previous mapping(s) it was " + oldMode); |
| } |
| } |
| return currOldMode; |
| } |
| OrderCorrectionType changeOrderCorrectionType(CollectionMapping mapping, OrderCorrectionType mode) { |
| OrderedListContainerPolicy policy = (OrderedListContainerPolicy)mapping.getContainerPolicy(); |
| OrderCorrectionType oldMode = policy.getOrderCorrectionType(); |
| policy.setOrderCorrectionType(mode); |
| |
| OrderedListContainerPolicy queryPolicy = null; |
| if(mapping.getSelectionQuery().isReadAllQuery()) { |
| queryPolicy = (OrderedListContainerPolicy)((ReadAllQuery)mapping.getSelectionQuery()).getContainerPolicy(); |
| } else if(mapping.getSelectionQuery().isDataReadQuery()) { |
| queryPolicy = (OrderedListContainerPolicy)((DataReadQuery)mapping.getSelectionQuery()).getContainerPolicy(); |
| } |
| if(policy != queryPolicy) { |
| OrderCorrectionType oldModeQuery = queryPolicy.getOrderCorrectionType(); |
| if(oldMode != oldModeQuery) { |
| throw new TestErrorException(mapping.getAttributeName() + ": OrderCorrectionTypes in container policy is " + oldMode +"; is query is " + oldModeQuery); |
| } |
| queryPolicy.setOrderCorrectionType(mode); |
| } |
| return oldMode; |
| } |
| |
| /* |
| * Verify IndirectList.isListOrderBrokenInDb flag value. |
| * Throw exception if it's not expected one. |
| */ |
| String verifyIsListOrderBrokenInDb(Employee empManager, boolean expected) { |
| String localErrorMsg = ""; |
| if(useManagedEmployees) { |
| localErrorMsg += verifyIsListOrderBrokenInDb(empManager, expected, "managedEmployees"); |
| } |
| if(useChildren) { |
| localErrorMsg += verifyIsListOrderBrokenInDb(empManager, expected, "children"); |
| } |
| if(useProjects) { |
| localErrorMsg += verifyIsListOrderBrokenInDb(empManager, expected, "projects"); |
| } |
| if(useResponsibilities) { |
| localErrorMsg += verifyIsListOrderBrokenInDb(empManager, expected, "responsibilitiesList"); |
| } |
| if(usePhones) { |
| localErrorMsg += verifyIsListOrderBrokenInDb(empManager, expected, "phoneNumbers"); |
| } |
| if(localErrorMsg.length() > 0) { |
| localErrorMsg = "isListOrderBrokenInDb expected to be " + expected + ". For the following attributes it is " + !expected +": " + localErrorMsg; |
| } |
| return localErrorMsg; |
| } |
| String verifyIsListOrderBrokenInDb(Employee empManager, boolean expected, String attribute) { |
| String localErrorMsg = ""; |
| ClassDescriptor desc = getSession().getDescriptor(Employee.class); |
| CollectionMapping mapping = (CollectionMapping)desc.getMappingForAttributeName(attribute); |
| Object attributeValue = mapping.getRealAttributeValueFromObject(empManager, getAbstractSession()); |
| if(((IndirectList)attributeValue).isListOrderBrokenInDb() != expected) { |
| localErrorMsg = attribute + "; "; |
| } |
| return localErrorMsg; |
| } |
| |
| /* |
| * Indicates whether all lists were read in |
| */ |
| boolean isInstantiated(Employee empManager) { |
| List list; |
| String instantiatedStr = ""; |
| String notInstantiatedStr = ""; |
| String str; |
| boolean isInstantiated; |
| if(useManagedEmployees) { |
| list = empManager.getManagedEmployees(); |
| isInstantiated = isInstantiated(list); |
| str = (isInstantiated ? instantiatedStr : notInstantiatedStr); |
| str += "managedEmployees; "; |
| } |
| if(useChildren) { |
| list = empManager.getChildren(); |
| isInstantiated = isInstantiated(list); |
| str = (isInstantiated ? instantiatedStr : notInstantiatedStr); |
| str += "children; "; |
| } |
| if(useProjects) { |
| list = empManager.getProjects(); |
| isInstantiated = isInstantiated(list); |
| str = (isInstantiated ? instantiatedStr : notInstantiatedStr); |
| str += "projects; "; |
| } |
| if(useResponsibilities) { |
| list = empManager.getResponsibilitiesList(); |
| isInstantiated = isInstantiated(list); |
| str = (isInstantiated ? instantiatedStr : notInstantiatedStr); |
| str += "responsibilities; "; |
| } |
| if(usePhones) { |
| list = empManager.getPhoneNumbers(); |
| isInstantiated = isInstantiated(list); |
| str = (isInstantiated ? instantiatedStr : notInstantiatedStr); |
| str += "phoneNumbers; "; |
| } |
| if(instantiatedStr.length() > 0 && notInstantiatedStr.length() > 0) { |
| throw new TestProblemException("Some attributes are instantiated: " + instantiatedStr + " and some are not: " + notInstantiatedStr); |
| } else { |
| return instantiatedStr.length() > 0; |
| } |
| } |
| boolean isInstantiated(List list) { |
| return !(list instanceof IndirectList && !((IndirectList)list).isInstantiated()); |
| } |
| |
| String getShortClassName() { |
| String name = this.getClass().getName(); |
| int begin = name.indexOf('$') + 1; |
| int end = name.length(); |
| return name.substring(begin, end); |
| } |
| } |
| |
| /* |
| * Base class for tests using Employee manager object. |
| * createManager method creates a manager with nSize of managedEmployees, children, projects, responsibilities, phones. |
| */ |
| class BaseManagerTest extends BaseTest { |
| /* |
| * Number of manager's managedEmployees, children, projects, responsibilities, phones |
| * created by createManager method. |
| */ |
| int nSize; |
| |
| Employee manager; |
| /* |
| * manager's clone in uow. |
| */ |
| Employee managerClone; |
| |
| BaseManagerTest() { |
| super(); |
| this.nSize = 2; |
| } |
| |
| /* |
| * Creates manager with nSize members |
| */ |
| void createManager() { |
| manager = new Employee("Manager"); |
| for(int i=0; i < nSize; i++) { |
| this.addTo(manager, create("old", i)); |
| } |
| UnitOfWork uow = getSession().acquireUnitOfWork(); |
| managerClone = (Employee)uow.registerObject(manager); |
| uow.commit(); |
| } |
| |
| @Override |
| protected void verify() { |
| if(manager == null) { |
| throw new TestErrorException("manager == null. Nothing to verify"); |
| } |
| |
| String textNameExt; |
| for(int k=0; k<2; k++) { |
| if(k == 0) { |
| textNameExt = "Cache"; |
| } else { |
| textNameExt = "DB"; |
| |
| // Read back the inserted objects, make sure the order is correct. |
| getSession().getIdentityMapAccessor().initializeAllIdentityMaps(); |
| manager = (Employee)getSession().readObject(manager); |
| } |
| if(!getAbstractSession().compareObjects(managerClone, manager)) { |
| errorMsg += textNameExt + ": " + "objects not equal\n"; |
| } |
| } |
| if(errorMsg.length() > 0) { |
| throw new TestErrorException('\n' + errorMsg); |
| } |
| } |
| |
| // assumes that listToVerify is in cache and contains mapped object only (can't contain, say String). |
| protected void verifyList(List listToVerify, List listToCompareTo) { |
| if(listToVerify == null) { |
| throw new TestErrorException("listToVerify is null. Nothing to verify"); |
| } |
| int size = listToVerify.size(); |
| String textNameExt; |
| for(int k=0; k<2; k++) { |
| if(k == 0) { |
| textNameExt = "Cache"; |
| } else { |
| textNameExt = "DB"; |
| |
| // Read back the objects from db |
| getSession().getIdentityMapAccessor().initializeAllIdentityMaps(); |
| for(int i=0; i < size; i++) { |
| listToVerify.set(i, getSession().readObject(listToVerify.get(i))); |
| } |
| } |
| for(int i=0; i < size; i++) { |
| Object toVerify = listToVerify.get(i); |
| Object toCompareTo = listToCompareTo.get(i); |
| if(!getAbstractSession().compareObjects(toCompareTo, toVerify)) { |
| errorMsg += textNameExt + ": " + "objects not equal\n"; |
| } |
| } |
| } |
| } |
| |
| // verifies that listToVerify is not in cache and not in db. listToVerify contains mapped object only (can't contain, say String). |
| protected void verifyListRemoved(List listToVerify) { |
| if(listToVerify == null) { |
| throw new TestErrorException("listToVerify is null. Nothing to verify"); |
| } |
| int size = listToVerify.size(); |
| String textNameExt; |
| for(int k=0; k<2; k++) { |
| if(k == 0) { |
| textNameExt = "Cache"; |
| |
| for(int i=0; i < size; i++) { |
| ReadObjectQuery query = new ReadObjectQuery(); |
| query.setSelectionObject(listToVerify.get(i)); |
| query.checkCacheOnly(); |
| Object readObject = getSession().executeQuery(query); |
| if(readObject != null) { |
| errorMsg += textNameExt + ": " + readObject + " was not removed\n"; |
| } |
| } |
| } else { |
| textNameExt = "DB"; |
| |
| // Read back the objects from db |
| getSession().getIdentityMapAccessor().initializeAllIdentityMaps(); |
| for(int i=0; i < size; i++) { |
| Object readObject = getSession().readObject(listToVerify.get(i)); |
| if(readObject != null) { |
| errorMsg += textNameExt + ": " + readObject + " was not removed\n"; |
| } |
| } |
| } |
| } |
| } |
| |
| @Override |
| public void reset() { |
| super.reset(); |
| manager = null; |
| managerClone = null; |
| } |
| |
| String nSizeName() { |
| return getShortClassName() + ": "+nSize+":"; |
| } |
| } |
| |
| /* |
| * Create manager, save to the db, verify that it was correctly merged into shared cache and written into the db. |
| */ |
| class CreateTest extends BaseManagerTest { |
| CreateTest() { |
| super(); |
| } |
| @Override |
| public void test() { |
| createManager(); |
| } |
| } |
| |
| /* |
| * Create empty manager, save to the db, verify that it was correctly merged into shared cache and written into the db. |
| * For OUTER_JOIN case to verify that read back lists are empty (as opposed to having null members). |
| */ |
| class CreateEmptyTest extends CreateTest { |
| CreateEmptyTest() { |
| super(); |
| nSize = 0; |
| } |
| } |
| |
| /* |
| * Create manager, save to the db. Meant as a base to the tests that change manager. |
| */ |
| class ChangeTest extends BaseManagerTest { |
| ChangeTest() { |
| super(); |
| } |
| @Override |
| public void setup() { |
| super.setup(); |
| createManager(); |
| } |
| } |
| |
| /* |
| * Switch positions of list members. |
| * [0, 2], [7, 5] means that old[0] = new[7], old[2] = new[5]; |
| * [0, 2, 5], [7, 5, 4] means that old[0] = new[7], old[2] = new[5], old[5] = new[4]. |
| * useSet indicates whether to use set(index, obj) method or remove(index)/add(index, obj). |
| */ |
| class TranspositionTest extends ChangeTest { |
| int[] oldIndexes, newIndexes; |
| boolean useSet; |
| /* |
| * nSize is number of members in each of the lists (managedEmployees, children etc), it should be greater than any old or new index |
| */ |
| TranspositionTest(int nSize, int[] oldIndexes, int[] newIndexes, boolean useSet) { |
| super(); |
| this.nSize = nSize; |
| this.oldIndexes = oldIndexes; |
| this.newIndexes = newIndexes; |
| this.useSet = useSet; |
| verifyIndexes(); |
| for(int i=0; i<oldIndexes.length; i++) { |
| if(oldIndexes[i] >= nSize) { |
| throw new TestProblemException("oldIndex["+i+"] = "+oldIndexes[i]+", which is greater than nSize ="+nSize); |
| } |
| if(newIndexes[i] >= nSize) { |
| throw new TestProblemException("newIndex["+i+"] = "+newIndexes[i]+", which is greater than nSize ="+nSize); |
| } |
| } |
| setName(); |
| } |
| /* |
| * nSize is number of members in each of the lists (managedEmployees, children etc), |
| * it will be set to the max index + 1. |
| */ |
| TranspositionTest(int[] oldIndexes, int[] newIndexes, boolean useSet) { |
| super(); |
| this.oldIndexes = oldIndexes; |
| this.newIndexes = newIndexes; |
| this.useSet = useSet; |
| verifyIndexes(); |
| nSize = 0; |
| for(int i=0; i<oldIndexes.length; i++) { |
| if(oldIndexes[i] > nSize) { |
| nSize = oldIndexes[i]; |
| } |
| if(newIndexes[i] > nSize) { |
| nSize = newIndexes[i]; |
| } |
| } |
| nSize++; |
| setName(); |
| } |
| public void verifyIndexes() { |
| if(oldIndexes.length != newIndexes.length) { |
| throw new TestProblemException("oldIndexes.length != newIndexes.length"); |
| } |
| for(int i=0; i < oldIndexes.length; i++) { |
| int oldIndex = oldIndexes[i]; |
| boolean found = false; |
| for(int j=0; j < newIndexes.length; j++) { |
| if(oldIndex == newIndexes[j]) { |
| found = true; |
| break; |
| } |
| } |
| if(!found) { |
| throw new TestProblemException("oldIndexes["+i+"] value "+oldIndex+" not found in newIndexes"); |
| } |
| } |
| } |
| String toString(int[] array) { |
| String str = "["; |
| for(int i=0; i<array.length; i++) { |
| str += Integer.toString(array[i]); |
| if(i < array.length-1) { |
| str += ", "; |
| } else { |
| str += "]"; |
| } |
| } |
| return str; |
| } |
| void setName() { |
| setName(getName() + " " + toString(oldIndexes) + " -> " + toString(newIndexes) + (useSet ? " set" : " remove/add")); |
| } |
| public void transpose(UnitOfWork uow) { |
| managerClone = (Employee)uow.registerObject(manager); |
| |
| int n = oldIndexes.length; |
| List[] lists = new ArrayList[n]; |
| for(int i=0; i<n; i++) { |
| lists[i] = getFrom(managerClone, oldIndexes[i]); |
| } |
| for(int i=0; i<n; i++) { |
| int newIndex = newIndexes[i]; |
| if(useSet) { |
| setInto_NoRelMaintanence(managerClone, newIndex, lists[i]); |
| } else { |
| removeFrom_NoRelMaintanence(managerClone, newIndex); |
| addTo_NoRelMaintanence(managerClone, newIndex, lists[i]); |
| } |
| } |
| } |
| @Override |
| public void test() { |
| UnitOfWork uow = getSession().acquireUnitOfWork(); |
| transpose(uow); |
| uow.commit(); |
| } |
| } |
| |
| /* |
| * Same as TranspositionTest, but the owner of transposed lists is detached, then merged. |
| */ |
| class TranspositionMergeTest extends TranspositionTest { |
| // This test transposes objects in detached collection, doesn't care whether set or remove/add |
| TranspositionMergeTest(int nSize, int[] oldIndexes, int[] newIndexes) { |
| super(nSize, oldIndexes, newIndexes, true); |
| } |
| TranspositionMergeTest(int[] oldIndexes, int[] newIndexes) { |
| // This test transposes objects in detached collection, doesn't care whether set or remove/add |
| super(oldIndexes, newIndexes, true); |
| } |
| @Override |
| void setName() { |
| setName(getName() + " " + toString(oldIndexes) + " -> " + toString(newIndexes)); |
| } |
| @Override |
| public void test() { |
| UnitOfWork uow = getSession().acquireUnitOfWork(); |
| transpose(uow); |
| uow.unregisterObject(this.managerClone); |
| uow.release(); |
| |
| uow = getSession().acquireUnitOfWork(); |
| this.managerClone = (Employee)uow.mergeCloneWithReferences(this.managerClone); |
| uow.commit(); |
| } |
| } |
| |
| /* |
| * For each mapping: add one new object, remove one existing object |
| */ |
| class SimpleAddRemoveTest extends ChangeTest { |
| SimpleAddRemoveTest() { |
| super(); |
| } |
| |
| @Override |
| public void test() { |
| UnitOfWork uow = getSession().acquireUnitOfWork(); |
| managerClone = (Employee)uow.registerObject(manager); |
| |
| addTo(managerClone, create("new", 1)); |
| removeFrom(managerClone, 0); |
| |
| uow.commit(); |
| } |
| } |
| |
| /* |
| * For each mapping: add one new object, remove one existing object |
| */ |
| class AddRemoveUpdateTest extends ChangeTest { |
| List removedList; |
| List removedListClone; |
| AddRemoveUpdateTest() { |
| super(); |
| } |
| |
| @Override |
| public void setup() { |
| // Strings are immutable - can't update. |
| useResponsibilities = false; |
| // Can't directly register an aggregate in uow. |
| usePhones = false; |
| super.setup(); |
| } |
| |
| @Override |
| public void test() { |
| // create a list of objects to be added |
| List newList = this.create("new", 0); |
| UnitOfWork uow = getSession().acquireUnitOfWork(); |
| List newListClone = this.register(newList, uow); |
| uow.commit(); |
| |
| // save list to be removed |
| removedList = this.getFrom(manager, 0); |
| |
| uow = getSession().acquireUnitOfWork(); |
| managerClone = (Employee)uow.registerObject(manager); |
| // update new list clone |
| newListClone = this.register(newList, uow); |
| update(newListClone, "updated", 0); |
| // add updated objects to managerClone |
| addTo(managerClone, newListClone); |
| |
| // remove from managerClone |
| removedListClone = removeFrom(managerClone, 0); |
| // update removed objects |
| update(removedListClone, "updated", 0); |
| |
| uow.commit(); |
| } |
| |
| @Override |
| public void verify() { |
| super.verify(); |
| if(isPrivatelyOwned) { |
| verifyListRemoved(removedList); |
| } else { |
| verifyList(removedList, removedListClone); |
| } |
| if(errorMsg.length() > 0) { |
| throw new TestErrorException('\n' + errorMsg); |
| } |
| } |
| } |
| |
| /* |
| * For each mapping: add one new object, remove one existing object |
| */ |
| class SimpleAddRemoveTest2 extends ChangeTest { |
| SimpleAddRemoveTest2() { |
| super(); |
| nSize = 12; |
| } |
| |
| @Override |
| public void test() { |
| UnitOfWork uow = getSession().acquireUnitOfWork(); |
| managerClone = (Employee)uow.registerObject(manager); |
| |
| addTo(managerClone, 0, create("new", 0)); |
| addTo(managerClone, 4, create("new", 4)); |
| removeFrom(managerClone, 8); |
| |
| uow.commit(); |
| } |
| } |
| |
| /* |
| * For each mapping: set a new object |
| */ |
| class SimpleSetTest extends ChangeTest { |
| SimpleSetTest() { |
| super(); |
| } |
| |
| @Override |
| public void test() { |
| UnitOfWork uow = getSession().acquireUnitOfWork(); |
| managerClone = (Employee)uow.registerObject(manager); |
| |
| setInto(managerClone, 1, create("new", 1)); |
| |
| uow.commit(); |
| } |
| } |
| |
| /* |
| * For each mapping: create a new List of two objects, set the new List into managerClone; |
| * if useSet is not null, before setting a new list either add or set a new object into the old list. |
| */ |
| class SimpleSetListTest extends ChangeTest { |
| Boolean useSet; |
| SimpleSetListTest() { |
| super(); |
| } |
| SimpleSetListTest(boolean useSet) { |
| super(); |
| this.useSet = useSet; |
| setName(getName() + (useSet ? " set" : " remove/add")); |
| } |
| |
| @Override |
| public void test() { |
| UnitOfWork uow = getSession().acquireUnitOfWork(); |
| managerClone = (Employee)uow.registerObject(manager); |
| |
| if(useSet != null) { |
| if(useSet) { |
| setInto(managerClone, 1, create("temp", 1)); |
| } else { |
| addTo(managerClone, create("temp", 2)); |
| } |
| } |
| List<List> list = createList(); |
| addTo(list, create("new", 0)); |
| addTo(list, create("new", 1)); |
| setListInto(managerClone, list); |
| |
| uow.commit(); |
| } |
| } |
| |
| class SimpleIndexTest extends ChangeTest { |
| int min; |
| int max; |
| int nExpected; |
| boolean useIndex; |
| |
| SimpleIndexTest(boolean useIndex) { |
| super(); |
| nSize = 12; |
| min = 1; |
| max = 4; |
| nExpected = max - min + 1; |
| |
| this.useIndex = useIndex; |
| setName(getName() + (useIndex ? " use index()" : " use getField()")); |
| } |
| @Override |
| public void test() { |
| getSession().getIdentityMapAccessor().initializeAllIdentityMaps(); |
| if(useManagedEmployees) { |
| test("managedEmployees"); |
| } |
| if(useChildren) { |
| test("children"); |
| } |
| if(useProjects) { |
| test("projects"); |
| } |
| if(useResponsibilities) { |
| test("responsibilitiesList"); |
| } |
| if(usePhones) { |
| test("phoneNumbers"); |
| } |
| } |
| void test(String attributeName) { |
| ReportQuery query = new ReportQuery(); |
| query.setReferenceClass(Employee.class); |
| ExpressionBuilder builder = query.getExpressionBuilder(); |
| Expression exp; |
| Expression firstNameManager = builder.get("firstName").equal("Manager"); |
| Expression anyOfAttribute = builder.anyOf(attributeName); |
| if(useIndex) { |
| // tests index() expression |
| exp = firstNameManager.and(anyOfAttribute.index().between(min, max)); |
| } else { |
| // tests getField() expression (or getTable().getField() expression) equivalent to index(). |
| if(isTableExpressionRequired(attributeName)) { |
| exp = firstNameManager.and(anyOfAttribute.getTable(getTableName(attributeName)).getField(getFieldName(attributeName)).between(min, max)); |
| } else { |
| exp = firstNameManager.and(anyOfAttribute.getField(getFieldName(attributeName)).between(min, max)); |
| } |
| } |
| query.setSelectionCriteria(exp); |
| query.addAttribute(attributeName, anyOfAttribute); |
| |
| ArrayList indexesRead = new ArrayList(nExpected); |
| boolean error = false; |
| List<ReportQueryResult> results = (List)getSession().executeQuery(query); |
| for(int i=0; i < results.size(); i++) { |
| ReportQueryResult result = results.get(i); |
| int index = getIndex(result.getResults().get(0), attributeName); |
| error |= max < index || index < min; |
| indexesRead.add(index); |
| } |
| String localErrorMsg = ""; |
| if(error) { |
| localErrorMsg += "Wrong index values read: " + indexesRead +"; expected all numbers between (inclusive) " + min + " and " + max; |
| } |
| // query with joins return Cartesian product of all rows - the same values returned more than once. |
| if(OrderListTestModel.this.joinFetchOrBatchRead != JoinFetchOrBatchRead.OUTER_JOIN && OrderListTestModel.this.joinFetchOrBatchRead != JoinFetchOrBatchRead.INNER_JOIN) { |
| if(indexesRead.size() != nExpected) { |
| localErrorMsg += attributeName + " Wrong number of objects read: " + indexesRead.size() +"; expected " + nExpected; |
| } |
| } |
| |
| if(localErrorMsg.length() > 0) { |
| localErrorMsg = attributeName + ": " + localErrorMsg + "\n"; |
| errorMsg += localErrorMsg; |
| } |
| } |
| /* |
| * all objects were constructed to incorporate the index, see createManager method. |
| */ |
| int getIndex(Object obj, String attributeName) { |
| int index = -1; |
| if(attributeName.equals("managedEmployees")) { |
| index = Integer.parseInt(((Employee)obj).getFirstName()); |
| } else if(attributeName.equals("children")) { |
| index = Integer.parseInt(((Child)obj).getFirstName()); |
| } else if(attributeName.equals("projects")) { |
| index = getNumberFromString(((Project)obj).getName()); |
| } else if(attributeName.equals("responsibilitiesList")) { |
| index = getNumberFromString((String)obj); |
| } else if(attributeName.equals("phoneNumbers")) { |
| index = Integer.parseInt(((PhoneNumber)obj).getNumber()); |
| } |
| return index; |
| } |
| int getNumberFromString(String str) { |
| int nEnd = str.length(); |
| int nStart = 0; |
| for(nStart=0; nStart < nEnd; nStart++) { |
| char ch = str.charAt(nStart); |
| if('0' <= ch && ch <='9') { |
| break; |
| } |
| } |
| str = str.substring(nStart); |
| return Integer.parseInt(str); |
| } |
| |
| @Override |
| protected void verify() { |
| if(errorMsg.length() > 0) { |
| errorMsg = "\n" + errorMsg; |
| throw new TestErrorException(errorMsg); |
| } |
| } |
| |
| /* |
| * ManyToMany and DirectCollection mapping require table name expression. |
| * Used to test getField() expression (or getTable().getField() expression) equivalent to index(). |
| */ |
| boolean isTableExpressionRequired(String attributeName) { |
| return attributeName.equals("projects") || attributeName.equals("responsibilitiesList"); |
| } |
| /* |
| * ManyToMany and DirectCollection mapping require table name expression. |
| * Used to test getTable().getField() expression equivalent to index(). |
| */ |
| String getTableName(String attributeName) { |
| if(attributeName.equals("projects")) { |
| return "OL_PROJ_EMP"; |
| } else if(attributeName.equals("responsibilitiesList")) { |
| return "OL_RESPONS"; |
| } else { |
| throw new TestProblemException(attributeName + " should not be looking for table name."); |
| } |
| } |
| /* |
| * Used to test getField() expression (or getTable().getField() expression) equivalent to index(). |
| */ |
| String getFieldName(String attributeName) { |
| String fieldName = null; |
| if(attributeName.equals("managedEmployees")) { |
| fieldName = "MANAGED_ORDER"; |
| } else if(attributeName.equals("children")) { |
| fieldName = "CHILDREN_ORDER"; |
| } else if(attributeName.equals("projects")) { |
| fieldName = "PROJ_ORDER"; |
| } else if(attributeName.equals("responsibilitiesList")) { |
| fieldName = "RESPONS_ORDER"; |
| } else if(attributeName.equals("phoneNumbers")) { |
| fieldName = "PHONE_ORDER"; |
| } |
| return fieldName; |
| } |
| } |
| |
| /* |
| * For each mapping: add object in front, or in the middle, or to the end of the list. |
| * Currently only DirectCollectionMapping supports duplicates and nulls. |
| * The test still uses all mappings so that it could be run with INNER_JOIN. |
| */ |
| abstract class WhereToAddTest extends ChangeTest { |
| String whereToAdd; |
| WhereToAddTest(String whereToAdd) { |
| super(); |
| this.whereToAdd = whereToAdd; |
| if(!front.equals(whereToAdd) && !middle.equals(whereToAdd) && !end.equals(whereToAdd)) { |
| throw new TestProblemException("Wrong whereToAdd = " + whereToAdd +"; Supported values: " + front +"; " +middle +"; " + end); |
| } |
| setName(getName() + " " + whereToAdd); |
| } |
| |
| @Override |
| public void test() { |
| UnitOfWork uow = getSession().acquireUnitOfWork(); |
| managerClone = (Employee)uow.registerObject(manager); |
| |
| if(front.equals(whereToAdd)) { |
| addTo(managerClone, 0, objectToAdd()); |
| } else if(middle.equals(whereToAdd)) { |
| addTo(managerClone, 1, objectToAdd()); |
| } else if(end.equals(whereToAdd)) { |
| addTo(managerClone, objectToAdd()); |
| } |
| |
| uow.commit(); |
| } |
| |
| abstract List objectToAdd(); |
| } |
| |
| /* |
| * For each mapping: add null. |
| * Currently only DirectCollectionMapping supports nulls. |
| */ |
| class AddNullTest extends WhereToAddTest { |
| AddNullTest(String whereToAdd) { |
| super(whereToAdd); |
| } |
| @Override |
| List objectToAdd() { |
| List list = create("new", 0); |
| for(int i=0; i < list.size(); i++) { |
| if(list.get(i) instanceof String) { |
| // Currently only DirectCollectionMapping (responsibilities) supports nulls. |
| list.set(i, null); |
| break; |
| } |
| } |
| return list; |
| } |
| } |
| |
| /* |
| * For each mapping: add duplicate. |
| * Currently only DirectCollectionMapping supports duplicates. |
| */ |
| class AddDuplicateTest extends WhereToAddTest { |
| AddDuplicateTest(String whereToAdd) { |
| super(whereToAdd); |
| } |
| @Override |
| List objectToAdd() { |
| List newList = create("new", 0); |
| List oldList = getFrom(managerClone, 0); |
| // the two lists are of the same size |
| for(int i=0; i < newList.size(); i++) { |
| if(newList.get(i) instanceof String) { |
| // Currently only DirectCollectionMapping (responsibilities) supports duplicates. |
| newList.set(i, oldList.get(i)); |
| break; |
| } |
| } |
| return newList; |
| } |
| } |
| |
| /* |
| * Break the order in the db, read the lists (with broken order) back, get the expected exception. |
| * Note that a separate test required for each mapping to make sure they all throw correct exception. |
| */ |
| abstract class BreakOrderExceptionTest extends ChangeTest { |
| BreakOrderExceptionTest() { |
| super(); |
| if(orderCorrectionType != OrderCorrectionType.EXCEPTION) { |
| throw new TestProblemException("Requires OrderCorrectionType.EXCEPTION"); |
| } |
| } |
| @Override |
| abstract public void test(); |
| |
| @Override |
| protected void verify() { |
| try { |
| super.verify(); |
| throw new TestErrorException("Expected QueryException.LIST_ORDER_FIELD_WRONG_VALUE was not thrown."); |
| } catch (QueryException queryException) { |
| if(queryException.getErrorCode() == QueryException.LIST_ORDER_FIELD_WRONG_VALUE) { |
| // expected query exception on attempt to read broken order list |
| return; |
| } else { |
| throw queryException; |
| } |
| } |
| } |
| } |
| class BreakOrderExceptionTest_OneToMany extends BreakOrderExceptionTest { |
| BreakOrderExceptionTest_OneToMany() { |
| super(); |
| } |
| @Override |
| public void test() { |
| breakManagedEmployeesOrder(); |
| } |
| } |
| class BreakOrderExceptionTest_UnidirectionalOneToMany extends BreakOrderExceptionTest { |
| BreakOrderExceptionTest_UnidirectionalOneToMany() { |
| super(); |
| } |
| @Override |
| public void test() { |
| breakChildrenOrder(); |
| } |
| } |
| class BreakOrderExceptionTest_ManyToMany extends BreakOrderExceptionTest { |
| BreakOrderExceptionTest_ManyToMany() { |
| super(); |
| } |
| @Override |
| public void test() { |
| breakProjectsOrder(); |
| } |
| } |
| class BreakOrderExceptionTest_DirectCollection extends BreakOrderExceptionTest { |
| BreakOrderExceptionTest_DirectCollection() { |
| super(); |
| } |
| @Override |
| public void test() { |
| breakResponsibilitiesOrder(); |
| } |
| } |
| class BreakOrderExceptionTest_AggregateCollection extends BreakOrderExceptionTest { |
| BreakOrderExceptionTest_AggregateCollection() { |
| super(); |
| } |
| @Override |
| public void test() { |
| breakPhonesOrder(); |
| } |
| } |
| |
| /* |
| * bug 331144: Removing from a collection that is broken results in an |
| * ArrayIndexOutOfBoundsException when the collection is fixed. |
| */ |
| class BreakOrderCorrectionAndRemoveTest extends BreakOrderCorrectionTest { |
| BreakOrderCorrectionAndRemoveTest(boolean shoulReadManagerThroughUow) { |
| super(shoulReadManagerThroughUow); |
| } |
| @Override |
| public void test() { |
| breakOrder(); |
| |
| // clear cache to force reading back the objects |
| getSession().getIdentityMapAccessor().initializeAllIdentityMaps(); |
| if(!shoulReadManagerThroughUow) { |
| // read in the object with broken order in the db |
| manager = (Employee)getSession().readObject(manager); |
| if(isInstantiated(manager)) { |
| // verify that all attribute values are marked as having broken order |
| errorMsg = this.verifyIsListOrderBrokenInDb(manager, true); |
| if(errorMsg.length() > 0) { |
| errorMsg = "manager in test: " + errorMsg; |
| throw new TestErrorException(errorMsg); |
| } |
| } |
| } |
| |
| UnitOfWork uow = getSession().acquireUnitOfWork(); |
| if(shoulReadManagerThroughUow) { |
| managerClone = (Employee)uow.readObject(manager); |
| } else { |
| managerClone = (Employee)uow.registerObject(manager); |
| } |
| // remove element 1 |
| List list1 = removeFrom(managerClone, 1); |
| |
| // verify that all attribute values are marked as having broken order, |
| // at this point they should be instantiated |
| errorMsg = this.verifyIsListOrderBrokenInDb(managerClone, true); |
| if(errorMsg.length() > 0) { |
| errorMsg = "managerClone in test: " + errorMsg; |
| uow.release(); |
| throw new TestErrorException(errorMsg); |
| } |
| |
| try { |
| uow.commit(); |
| } catch (ArrayIndexOutOfBoundsException exception){ |
| throw new TestErrorException("Test received exception commit when fixing a broken collection", exception); |
| } |
| } |
| } |
| |
| /* |
| * Break the order in the db, read the lists (with broken order) back, update lists, write out updated lists. |
| * For verification temporary switch container policy into EXCEPTION mode, read back the list - |
| * exception thrown if the order is still broken. |
| */ |
| class BreakOrderCorrectionTest extends ChangeTest { |
| boolean shoulReadManagerThroughUow; |
| BreakOrderCorrectionTest(boolean shoulReadManagerThroughUow) { |
| super(); |
| this.nSize = 4; |
| this.shoulReadManagerThroughUow = shoulReadManagerThroughUow; |
| |
| if(orderCorrectionType != OrderCorrectionType.READ_WRITE) { |
| throw new TestProblemException("Requires OrderCorrectionType.CORRECTION"); |
| } |
| setName(getName() + (shoulReadManagerThroughUow ? " ReadThroughUow" : " ReadThroughSession")); |
| } |
| @Override |
| public void test() { |
| breakOrder(); |
| |
| // clear cache to force reading back the objects |
| getSession().getIdentityMapAccessor().initializeAllIdentityMaps(); |
| if(!shoulReadManagerThroughUow) { |
| // read in the object with broken order in the db |
| manager = (Employee)getSession().readObject(manager); |
| if(isInstantiated(manager)) { |
| // verify that all attribute values are marked as having broken order |
| errorMsg = this.verifyIsListOrderBrokenInDb(manager, true); |
| if(errorMsg.length() > 0) { |
| errorMsg = "manager in test: " + errorMsg; |
| throw new TestErrorException(errorMsg); |
| } |
| } |
| } |
| |
| // change the order of elements 0 <-> 1 |
| UnitOfWork uow = getSession().acquireUnitOfWork(); |
| if(shoulReadManagerThroughUow) { |
| managerClone = (Employee)uow.readObject(manager); |
| } else { |
| managerClone = (Employee)uow.registerObject(manager); |
| } |
| List list1 = removeFrom(managerClone, 1); |
| |
| // verify that all attribute values are marked as having broken order, |
| // at this point they should be instantiated |
| errorMsg = this.verifyIsListOrderBrokenInDb(managerClone, true); |
| if(errorMsg.length() > 0) { |
| errorMsg = "managerClone in test: " + errorMsg; |
| uow.release(); |
| throw new TestErrorException(errorMsg); |
| } |
| |
| List list0 = removeFrom(managerClone, 0); |
| addTo(managerClone, list1); |
| addTo(managerClone, list0); |
| |
| uow.commit(); |
| } |
| |
| @Override |
| protected void verify() { |
| OrderCorrectionType originalMode = this.changeOrderCorrectionType(OrderCorrectionType.EXCEPTION); |
| try { |
| if(shoulReadManagerThroughUow) { |
| // manager is not in shared cache - bring the one from the shared cache. |
| ReadObjectQuery query = new ReadObjectQuery(); |
| query.setReferenceClass(Employee.class); |
| query.checkCacheOnly(); |
| manager = (Employee)getSession().readObject(manager); |
| } |
| // verify that all attribute values are marked as having NOT broken order |
| errorMsg = this.verifyIsListOrderBrokenInDb(manager, false); |
| if(errorMsg.length() > 0) { |
| errorMsg = "manager in verify: " + errorMsg; |
| } |
| String localErrorMsg = this.verifyIsListOrderBrokenInDb(managerClone, false); |
| if(localErrorMsg.length() > 0) { |
| localErrorMsg = "managerClone in verify: " + localErrorMsg; |
| errorMsg += localErrorMsg; |
| } |
| super.verify(); |
| } finally { |
| this.changeOrderCorrectionType(originalMode); |
| } |
| } |
| } |
| |
| class BaseMultipleManagersTest extends BaseTest { |
| /* number of managers created by createManagers method.*/ |
| int nManagers; |
| /* |
| * Number of each manager's managedEmployees, children, projects, responsibilities, phones |
| * created by createManager method. |
| */ |
| int nSize; |
| |
| /* managers */ |
| List<Employee> managers = new ArrayList(nManagers); |
| /* their uow clones */ |
| List<Employee> managerClones = new ArrayList(nManagers); |
| |
| BaseMultipleManagersTest() { |
| super(); |
| nManagers = 2; |
| nSize = 2; |
| } |
| |
| /* |
| * Creates manager with nSize members |
| */ |
| void createManagers() { |
| UnitOfWork uow = getSession().acquireUnitOfWork(); |
| |
| for(int i=0; i < nManagers; i++) { |
| String iStr = Integer.toString(i); |
| Employee manager = new Employee("Manager", iStr); |
| for(int j=0; j < nSize; j++) { |
| addTo(manager, create(iStr, j)); |
| } |
| Employee managerClone = (Employee)uow.registerObject(manager); |
| |
| managers.add(manager); |
| managerClones.add(managerClone); |
| } |
| |
| uow.commit(); |
| } |
| |
| @Override |
| public void reset() { |
| super.reset(); |
| managers.clear(); |
| managerClones.clear(); |
| } |
| |
| @Override |
| public void verify() { |
| if(managers == null || managers.isEmpty()) { |
| throw new TestErrorException("managers is null or empty. Nothing to verify"); |
| } |
| |
| String textNameExt; |
| for(int k=0; k<2; k++) { |
| if(k == 0) { |
| textNameExt = "Cache"; |
| } else { |
| textNameExt = "DB"; |
| |
| // Read back the inserted objects, make sure the order is correct. |
| getSession().getIdentityMapAccessor().initializeAllIdentityMaps(); |
| ReadAllQuery query = new ReadAllQuery(); |
| query.setReferenceClass(Employee.class); |
| Expression exp = query.getExpressionBuilder().get("firstName").equal("Manager"); |
| query.setSelectionCriteria(exp); |
| query.addOrdering(query.getExpressionBuilder().get("lastName")); |
| |
| managers.clear(); |
| managers.addAll((List<Employee>)getSession().executeQuery(query)); |
| } |
| if(managers.size() != managerClones.size()) { |
| errorMsg = "wrong managers size " + managers.size() + "; expected size is " + managerClones.size(); |
| } else { |
| for(int i=0; i<managers.size(); i++) { |
| if(!getAbstractSession().compareObjects(managerClones.get(i), managers.get(i))) { |
| String localErrorMsg = textNameExt + ": " + "manager["+i+"] not equal\n"; |
| errorMsg += localErrorMsg; |
| } |
| } |
| } |
| } |
| if(errorMsg.length() > 0) { |
| throw new TestErrorException(errorMsg); |
| } |
| } |
| } |
| |
| /* |
| * Creates managers, verifies that they were correctly merged into cache and written to the db. |
| */ |
| class CreateManagersTest extends BaseMultipleManagersTest { |
| CreateManagersTest() { |
| super(); |
| } |
| |
| @Override |
| public void setup() { |
| createManagers(); |
| } |
| } |
| |
| /* |
| * Creates empty managers, verifies that they were correctly merged into cache and written to the db. |
| * For OUTER_JOIN case to verify that read back lists are empty (as opposed to having null members). |
| */ |
| class CreateEmptyManagersTest extends CreateManagersTest { |
| CreateEmptyManagersTest() { |
| super(); |
| nSize = 0; |
| } |
| } |
| |
| /* |
| * Verify that for each mapping both its container policy and its select query's container policy |
| * are of the expected type. |
| */ |
| class VerifyContainerPolicyClassTest extends TestCase { |
| Class expectedClass; |
| VerifyContainerPolicyClassTest() { |
| this(NullsLastOrderedListContainerPolicy.class); |
| } |
| VerifyContainerPolicyClassTest(Class expectedClass) { |
| super(); |
| this.expectedClass = expectedClass; |
| setName("VerifyContainerPolicyClassTest"); |
| } |
| @Override |
| public void verify() { |
| String errorMsg = ""; |
| List<CollectionMapping> listOrderMappings = EmployeeSystem.getListOrderMappings(getDatabaseSession()); |
| for(int i=0; i < listOrderMappings.size(); i++) { |
| CollectionMapping mapping = listOrderMappings.get(i); |
| if(!mapping.getContainerPolicy().getClass().equals(expectedClass)) { |
| errorMsg += mapping.getAttributeName() + ".containerPolicy type is wrong; "; |
| } |
| ReadQuery selectQuery = mapping.getSelectionQuery(); |
| if(selectQuery.isReadAllQuery()) { |
| if(!((ReadAllQuery)selectQuery).getContainerPolicy().getClass().equals(expectedClass)) { |
| errorMsg += mapping.getAttributeName() + ".queryContainerPolicy type is wrong; "; |
| } |
| } else { |
| if(!((DataReadQuery)selectQuery).getContainerPolicy().getClass().equals(expectedClass)) { |
| errorMsg += mapping.getAttributeName() + ".queryContainerPolicy type is wrong; "; |
| } |
| } |
| } |
| if(errorMsg.length() > 0) { |
| throw new TestErrorException(errorMsg); |
| } |
| } |
| } |
| |
| /* |
| * Test for OneToMany and UnideirectionalOneToMany mappings only: |
| * verify that the row in the db corresponding to the removed object |
| * has its order field value set to null. |
| */ |
| class VerifyForeignKeyOfRemovedObject extends ChangeTest { |
| boolean deleteSourceObject; |
| VerifyForeignKeyOfRemovedObject(boolean deleteSourceObject) { |
| super(); |
| this.deleteSourceObject = deleteSourceObject; |
| setName(getShortClassName() + (deleteSourceObject ? "_deleteSource" : "_removeTarget")); |
| } |
| // Only tests OneToMany and UnideirectionalOneToMany |
| @Override |
| public void setup() { |
| this.usePhones = false; |
| this.useProjects = false; |
| this.useResponsibilities = false; |
| super.setup(); |
| } |
| @Override |
| public void test() { |
| UnitOfWork uow = getSession().acquireUnitOfWork(); |
| managerClone = (Employee)uow.registerObject(manager); |
| if(deleteSourceObject) { |
| for(int i=0; i < nSize; i++) { |
| if(useManagedEmployees) { |
| managerClone.getManagedEmployees().get(i).setManager(null); |
| } |
| } |
| uow.deleteObject(managerClone); |
| } else { |
| for(int i=nSize-1; 0 <= i; i--) { |
| if(useManagedEmployees) { |
| managerClone.removeManagedEmployee(i); |
| } |
| if(useChildren) { |
| managerClone.getChildren().remove(i); |
| } |
| } |
| } |
| uow.commit(); |
| } |
| @Override |
| public void verify() { |
| // assume (as usual) that there were no objects in the db when the test started, |
| // then all the objects left should have their order set to null (including manager if not deleted). |
| if(useManagedEmployees) { |
| String sqlString = "SELECT COUNT(*) FROM "+this.getManagegedEmployeesOrderTable()+" WHERE "+this.getManagegedEmployeesOrderField()+" IS NOT NULL"; |
| int nonNulls = ((Number)((AbstractRecord)getSession().executeSQL(sqlString).get(0)).getValues().get(0)).intValue(); |
| if(nonNulls != 0) { |
| errorMsg += "useManagedEmployees has "+nonNulls+" non nulls; "; |
| } |
| } |
| if(useChildren) { |
| String sqlString = "SELECT COUNT(*) FROM "+this.getChildrenOrderTable()+" WHERE "+this.getChildrenOrderField()+" IS NOT NULL"; |
| int nonNulls = ((Number)((AbstractRecord)getSession().executeSQL(sqlString).get(0)).getValues().get(0)).intValue(); |
| if(nonNulls != 0) { |
| errorMsg += "useManagedEmployees has "+nonNulls+" non nulls; "; |
| } |
| } |
| } |
| } |
| } |
