| /* |
| * Copyright (c) 2011-2013 Eike Stepper (Berlin, Germany) and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * Pascal Lehmann - initial API and implementation |
| */ |
| package org.eclipse.emf.cdo.tests; |
| |
| import org.eclipse.emf.cdo.CDOState; |
| import org.eclipse.emf.cdo.common.CDOCommonSession; |
| import org.eclipse.emf.cdo.eresource.CDOResource; |
| import org.eclipse.emf.cdo.session.CDOSession; |
| import org.eclipse.emf.cdo.tests.config.IModelConfig; |
| import org.eclipse.emf.cdo.tests.config.impl.ConfigTest.Skips; |
| import org.eclipse.emf.cdo.tests.model6.BaseObject; |
| import org.eclipse.emf.cdo.tests.model6.ContainmentObject; |
| import org.eclipse.emf.cdo.tests.model6.ReferenceObject; |
| import org.eclipse.emf.cdo.tests.model6.Root; |
| import org.eclipse.emf.cdo.transaction.CDOConflictResolver; |
| import org.eclipse.emf.cdo.transaction.CDOTransaction; |
| import org.eclipse.emf.cdo.util.CDOUtil; |
| import org.eclipse.emf.cdo.util.CommitException; |
| |
| import org.eclipse.net4j.util.io.IOUtil; |
| |
| import org.eclipse.emf.common.notify.Notification; |
| import org.eclipse.emf.common.notify.impl.AdapterImpl; |
| import org.eclipse.emf.common.util.EList; |
| import org.eclipse.emf.spi.cdo.CDOMergingConflictResolver; |
| import org.eclipse.emf.spi.cdo.DefaultCDOMerger.ResolutionPreference; |
| |
| import java.util.List; |
| |
| /** |
| * @author Pascal Lehmann |
| */ |
| @Skips(IModelConfig.CAPABILITY_LEGACY) |
| public class ConflictResolverExtendedTest extends AbstractCDOTest |
| { |
| private static final String TEST_RESOURCE_NAME = "/test1"; |
| |
| // --- initialize model ---------------------------------------------------- |
| |
| // --- conflict test ------------------------------------------------------- |
| |
| public void _testProvokeConflictOnServerTest() throws Exception |
| { |
| initTestModelSimple(); |
| |
| // Should provoke an "attempt to modify historical revision" error. |
| CDOSession session = openSessionWithAdditionsMode(); |
| CDOTransaction thisTransaction = session.openTransaction(); |
| CDOTransaction thatTransaction = session.openTransaction(); |
| |
| BaseObject thisObject = getTestModelRoot(thisTransaction).getListA().get(0); |
| BaseObject thatObject = thatTransaction.getObject(thisObject); |
| |
| thisObject.setAttributeOptional("this"); |
| thatObject.setAttributeOptional("that"); |
| |
| thisTransaction.commit(); |
| |
| try |
| { |
| commitAndSync(thatTransaction, thisTransaction); |
| fail("CommitException expected"); |
| } |
| catch (CommitException expected) |
| { |
| } |
| } |
| |
| public void _testProvokeConflictLocalTest() throws Exception |
| { |
| initTestModelSimple(); |
| |
| // Should provoke an "this transaction has conflicts" error. |
| CDOSession session = openSessionWithAdditionsMode(); |
| CDOTransaction thisTransaction = session.openTransaction(); |
| CDOTransaction thatTransaction = session.openTransaction(); |
| |
| BaseObject thisObject = getTestModelRoot(thisTransaction).getListA().get(0); |
| BaseObject thatObject = thatTransaction.getObject(thisObject); |
| |
| thisObject.setAttributeOptional("this"); |
| thatObject.setAttributeOptional("that"); |
| |
| commitAndSync(thisTransaction, thatTransaction); |
| |
| try |
| { |
| commitAndSync(thatTransaction, thisTransaction); |
| fail("CommitException expected"); |
| } |
| catch (CommitException expected) |
| { |
| } |
| } |
| |
| // --- single value conflict resolver tests -------------------------- |
| |
| public void testChangeChangeTest() throws Exception |
| { |
| initTestModelSimple(); |
| |
| CDOSession session = openSessionWithAdditionsMode(); |
| CDOTransaction thisTransaction = session.openTransaction(); |
| CDOTransaction thatTransaction = session.openTransaction(); |
| addConflictResolver(thatTransaction); |
| |
| BaseObject thisObject = getTestModelRoot(thisTransaction).getListA().get(0); |
| thisObject.setAttributeOptional("this"); |
| |
| BaseObject thatObject = thatTransaction.getObject(thisObject); |
| thatObject.setAttributeOptional("that"); |
| |
| commitAndSync(thisTransaction, thatTransaction); |
| assertEquals(false, thisTransaction.isDirty()); |
| assertEquals(true, thatTransaction.isDirty()); |
| assertEquals(true, thatTransaction.hasConflict()); |
| } |
| |
| public void testRemoveChangeTest() throws Exception |
| { |
| initTestModelSimple(); |
| |
| CDOSession session = openSessionWithAdditionsMode(); |
| CDOTransaction thisTransaction = session.openTransaction(); |
| CDOTransaction thatTransaction = session.openTransaction(); |
| addConflictResolver(thatTransaction); |
| |
| BaseObject thisObject = getTestModelRoot(thisTransaction).getListA().get(0); |
| BaseObject thatObject = thatTransaction.getObject(thisObject); |
| |
| // Remove object. |
| getTestModelRoot(thisTransaction).getListA().remove(0); |
| |
| // Change object. |
| thatObject.setAttributeOptional("that"); |
| |
| commitAndSync(thisTransaction, thatTransaction); |
| assertEquals(true, thatTransaction.hasConflict()); |
| } |
| |
| public void testChangeRemoveTest() throws Exception |
| { |
| initTestModelSimple(); |
| |
| CDOSession session = openSessionWithAdditionsMode(); |
| CDOTransaction thisTransaction = session.openTransaction(); |
| CDOTransaction thatTransaction = session.openTransaction(); |
| addConflictResolver(thatTransaction); |
| |
| BaseObject thisObject = getTestModelRoot(thisTransaction).getListA().get(0); |
| BaseObject thatObject = thatTransaction.getObject(thisObject); |
| assertNotNull(thatObject); |
| int objects = getTestModelRoot(thisTransaction).getListA().size(); |
| |
| // Change object. |
| thisObject.setAttributeOptional("this"); |
| |
| // Remove object. |
| Root thatRoot = thatTransaction.getObject(getTestModelRoot(thisTransaction)); |
| thatRoot.getListA().remove(0); |
| |
| commitAndSync(thisTransaction, thatTransaction); |
| commitAndSync(thatTransaction, thisTransaction); |
| |
| assertEquals(false, thisTransaction.isDirty()); |
| assertEquals(false, thatTransaction.isDirty()); |
| assertEquals(objects - 1, getTestModelRoot(thisTransaction).getListA().size()); |
| } |
| |
| public void testRemoveAddTest() throws Exception |
| { |
| initTestModelSimple(); |
| |
| CDOSession session = openSessionWithAdditionsMode(); |
| CDOTransaction thisTransaction = session.openTransaction(); |
| CDOTransaction thatTransaction = session.openTransaction(); |
| addConflictResolver(thatTransaction); |
| |
| Root thisRoot = getTestModelRoot(thisTransaction); |
| EList<BaseObject> thisList = thisRoot.getListB(); |
| ContainmentObject thisObject = (ContainmentObject)thisList.get(0); |
| |
| ContainmentObject thatObject = thatTransaction.getObject(thisObject); |
| ContainmentObject thatChild = (ContainmentObject)thatObject.getContainmentList().get(0); |
| |
| // Remove object. |
| thisList.remove(0); |
| |
| // Add object. |
| BaseObject addObject = createBaseObject("AddObject"); |
| thatChild.getContainmentList().add(addObject); |
| |
| commitAndSync(thisTransaction, thatTransaction); |
| assertEquals(true, thatTransaction.hasConflict()); |
| } |
| |
| public void testAddRemoveTest() throws Exception |
| { |
| initTestModelSimple(); |
| |
| CDOSession session = openSessionWithAdditionsMode(); |
| CDOTransaction thisTransaction = session.openTransaction(); |
| CDOTransaction thatTransaction = session.openTransaction(); |
| addConflictResolver(thatTransaction); |
| |
| ContainmentObject thisObject = (ContainmentObject)getTestModelRoot(thisTransaction).getListB().get(0); |
| ContainmentObject thatObject = thatTransaction.getObject(thisObject); |
| assertNotNull(thatObject); |
| int objects = getTestModelRoot(thisTransaction).getListB().size(); |
| |
| // Add object. |
| BaseObject addObject = createBaseObject("AddObject"); |
| |
| ContainmentObject thisChild = (ContainmentObject)thisObject.getContainmentList().get(0); |
| thisChild.getContainmentList().add(addObject); |
| |
| // Remove object. |
| Root thatRoot = thatTransaction.getObject(getTestModelRoot(thisTransaction)); |
| thatRoot.getListB().remove(0); |
| |
| commitAndSync(thisTransaction, thatTransaction); |
| commitAndSync(thatTransaction, thisTransaction); |
| |
| assertEquals(false, thisTransaction.isDirty()); |
| assertEquals(false, thatTransaction.isDirty()); |
| assertEquals(objects - 1, getTestModelRoot(thisTransaction).getListB().size()); |
| } |
| |
| public void testRemoveRemoveTest() throws Exception |
| { |
| initTestModelSimple(); |
| |
| CDOSession session = openSessionWithAdditionsMode(); |
| CDOTransaction thisTransaction = session.openTransaction(); |
| CDOTransaction thatTransaction = session.openTransaction(); |
| addConflictResolver(thatTransaction); |
| |
| Root thisRoot = getTestModelRoot(thisTransaction); |
| Root thatRoot = thatTransaction.getObject(thisRoot); |
| |
| ContainmentObject thisObject = (ContainmentObject)thisRoot.getListB().get(0); |
| ContainmentObject thatObject = thatTransaction.getObject(thisObject); |
| assertNotNull(thatObject); |
| |
| // Remove object. |
| thisRoot.getListB().remove(0); |
| |
| // Remove object. |
| thatRoot.getListB().remove(0); |
| |
| commitAndSync(thisTransaction, thatTransaction); |
| assertEquals(false, thatTransaction.isDirty()); |
| assertEquals(false, thatTransaction.hasConflict()); |
| } |
| |
| // --- resolve many valued changes ------------------------------------- |
| |
| public void testManyValuedAddAddTest() throws Exception |
| { |
| initTestModelSimple(); |
| |
| CDOSession session = openSessionWithAdditionsMode(); |
| CDOTransaction thisTransaction = session.openTransaction(); |
| CDOTransaction thatTransaction = session.openTransaction(); |
| addConflictResolver(thatTransaction); |
| |
| Root thisRoot = getTestModelRoot(thisTransaction); |
| EList<BaseObject> thisList = thisRoot.getListA(); |
| int objects = thisList.size(); |
| |
| Root thatRoot = thatTransaction.getObject(thisRoot); |
| EList<BaseObject> thatList = thatRoot.getListA(); |
| |
| // Add elements |
| thisList.add(createBaseObject("ThisObject")); |
| thatList.add(createBaseObject("ThatObject")); |
| |
| commitAndSync(thisTransaction, thatTransaction); |
| commitAndSync(thatTransaction, thisTransaction); |
| |
| assertEquals(objects + 2, thisList.size()); |
| assertEquals(false, thisTransaction.isDirty()); |
| assertEquals(false, thatTransaction.isDirty()); |
| } |
| |
| public void testManyValuedAddChangeTest() throws Exception |
| { |
| initTestModelSimple(); |
| |
| CDOSession session = openSessionWithAdditionsMode(); |
| CDOTransaction thisTransaction = session.openTransaction(); |
| CDOTransaction thatTransaction = session.openTransaction(); |
| addConflictResolver(thatTransaction); |
| |
| int objects = getTestModelRoot(thisTransaction).getListA().size(); |
| |
| // Create new objects. |
| BaseObject thisObject = createBaseObject("ThisObject"); |
| |
| // Add elements. |
| Root thisRoot = getTestModelRoot(thisTransaction); |
| thisRoot.getListA().add(thisObject); |
| |
| // Move element. |
| Root thatRoot = thatTransaction.getObject(thisRoot); |
| EList<BaseObject> containmentList = thatRoot.getListA(); |
| containmentList.move(2, containmentList.get(0)); |
| |
| commitAndSync(thisTransaction, thatTransaction); |
| commitAndSync(thatTransaction, thisTransaction); |
| |
| assertEquals(false, thisTransaction.isDirty()); |
| assertEquals(false, thatTransaction.isDirty()); |
| assertEquals(objects + 1, getTestModelRoot(thisTransaction).getListA().size()); |
| } |
| |
| public void testManyValuedChangeAddTest() throws Exception |
| { |
| initTestModelSimple(); |
| |
| CDOSession session = openSessionWithAdditionsMode(); |
| CDOTransaction thisTransaction = session.openTransaction(); |
| CDOTransaction thatTransaction = session.openTransaction(); |
| addConflictResolver(thatTransaction); |
| |
| int objects = getTestModelRoot(thisTransaction).getListA().size(); |
| |
| // Move element. |
| Root thisRoot = getTestModelRoot(thisTransaction); |
| EList<BaseObject> containmentList = thisRoot.getListA(); |
| containmentList.move(2, containmentList.get(0)); |
| |
| // Create new objects. |
| BaseObject thatObject = createBaseObject("ThatObject"); |
| |
| // Add elements. |
| Root thatRoot = thatTransaction.getObject(thisRoot); |
| thatRoot.getListA().add(thatObject); |
| |
| commitAndSync(thisTransaction, thatTransaction); |
| commitAndSync(thatTransaction, thisTransaction); |
| |
| assertEquals(false, thisTransaction.isDirty()); |
| assertEquals(false, thatTransaction.isDirty()); |
| assertEquals(objects + 1, getTestModelRoot(thisTransaction).getListA().size()); |
| } |
| |
| public void testManyValuedAddRemoveTest() throws Exception |
| { |
| initTestModelSimple(); |
| |
| CDOSession session = openSessionWithAdditionsMode(); |
| CDOTransaction thisTransaction = session.openTransaction(); |
| CDOTransaction thatTransaction = session.openTransaction(); |
| addConflictResolver(thatTransaction); |
| |
| int objects = getTestModelRoot(thisTransaction).getListA().size(); |
| |
| // Create new objects. |
| BaseObject thisObject = createBaseObject("ThisObject"); |
| |
| // Add elements. |
| Root thisRoot = getTestModelRoot(thisTransaction); |
| thisRoot.getListA().add(thisObject); |
| |
| // Remove element. |
| Root thatRoot = thatTransaction.getObject(thisRoot); |
| thatRoot.getListA().remove(1); |
| |
| commitAndSync(thisTransaction, thatTransaction); |
| commitAndSync(thatTransaction, thisTransaction); |
| |
| assertEquals(false, thisTransaction.isDirty()); |
| assertEquals(false, thatTransaction.isDirty()); |
| assertEquals(objects, getTestModelRoot(thisTransaction).getListA().size()); |
| } |
| |
| public void testManyValuedRemoveAddTest() throws Exception |
| { |
| initTestModelSimple(); |
| |
| CDOSession session = openSessionWithAdditionsMode(); |
| CDOTransaction thisTransaction = session.openTransaction(); |
| CDOTransaction thatTransaction = session.openTransaction(); |
| addConflictResolver(thatTransaction); |
| |
| Root thisRoot = getTestModelRoot(thisTransaction); |
| EList<BaseObject> thisList = thisRoot.getListA(); |
| int objects = thisList.size(); |
| |
| Root thatRoot = thatTransaction.getObject(thisRoot); |
| EList<BaseObject> thatList = thatRoot.getListA(); |
| |
| // Remove 1 element |
| thisList.remove(1); |
| |
| // Add 1 element |
| thatList.add(createBaseObject("ThatObject")); |
| |
| commitAndSync(thisTransaction, thatTransaction); |
| commitAndSync(thatTransaction, thisTransaction); |
| |
| assertEquals(false, thisTransaction.isDirty()); |
| assertEquals(false, thatTransaction.isDirty()); |
| assertEquals(objects, thisList.size()); |
| } |
| |
| public void testManyValuedChangeRemoveTest() throws Exception |
| { |
| initTestModelSimple(); |
| |
| CDOSession session = openSessionWithAdditionsMode(); |
| CDOTransaction thisTransaction = session.openTransaction(); |
| CDOTransaction thatTransaction = session.openTransaction(); |
| addConflictResolver(thatTransaction); |
| |
| int objects = getTestModelRoot(thisTransaction).getListA().size(); |
| |
| // Move element. |
| Root thisRoot = getTestModelRoot(thisTransaction); |
| EList<BaseObject> containmentList = thisRoot.getListA(); |
| containmentList.move(2, containmentList.get(0)); |
| |
| // Remove element. |
| Root thatRoot = thatTransaction.getObject(thisRoot); |
| thatRoot.getListA().remove(1); |
| |
| commitAndSync(thisTransaction, thatTransaction); |
| commitAndSync(thatTransaction, thisTransaction); |
| |
| assertEquals(false, thisTransaction.isDirty()); |
| assertEquals(false, thatTransaction.isDirty()); |
| assertEquals(objects - 1, getTestModelRoot(thisTransaction).getListA().size()); |
| } |
| |
| public void testManyValuedChangeRemoveTest2() throws Exception |
| { |
| initTestModelSimple(); |
| |
| CDOSession session = openSessionWithAdditionsMode(); |
| CDOTransaction thisTransaction = session.openTransaction(); |
| CDOTransaction thatTransaction = session.openTransaction(); |
| addConflictResolver(thatTransaction); |
| |
| Root thisRoot = getTestModelRoot(thisTransaction); |
| EList<BaseObject> thisList = thisRoot.getListA(); |
| BaseObject this0 = thisList.get(0); |
| int objects = thisList.size(); |
| |
| Root thatRoot = thatTransaction.getObject(thisRoot); |
| EList<BaseObject> thatList = thatRoot.getListA(); |
| |
| // Move first element to end |
| thisList.move(2, this0); |
| |
| // Remove first element |
| thatList.remove(0); |
| |
| commitAndSync(thisTransaction, thatTransaction); |
| commitAndSync(thatTransaction, thisTransaction); |
| |
| assertEquals(false, thisTransaction.isDirty()); |
| assertEquals(false, thatTransaction.isDirty()); |
| assertEquals(objects - 1, thisList.size()); |
| } |
| |
| public void testManyValuedRemoveChangeTest() throws Exception |
| { |
| initTestModelSimple(); |
| |
| CDOSession session = openSessionWithAdditionsMode(); |
| CDOTransaction thisTransaction = session.openTransaction(); |
| CDOTransaction thatTransaction = session.openTransaction(); |
| addConflictResolver(thatTransaction); |
| |
| int objects = getTestModelRoot(thisTransaction).getListA().size(); |
| |
| // Remove element. |
| Root thisRoot = getTestModelRoot(thisTransaction); |
| thisRoot.getListA().remove(1); |
| |
| // Move element. |
| Root thatRoot = thatTransaction.getObject(thisRoot); |
| EList<BaseObject> listA = thatRoot.getListA(); |
| listA.move(2, 0); |
| |
| commitAndSync(thisTransaction, thatTransaction); |
| commitAndSync(thatTransaction, thisTransaction); |
| |
| assertEquals(false, thisTransaction.isDirty()); |
| assertEquals(false, thatTransaction.isDirty()); |
| assertEquals(objects - 1, getTestModelRoot(thisTransaction).getListA().size()); |
| } |
| |
| public void testManyValuedRemoveChangeTest2() throws Exception |
| { |
| initTestModelSimple(); |
| |
| CDOSession session = openSessionWithAdditionsMode(); |
| CDOTransaction thisTransaction = session.openTransaction(); |
| CDOTransaction thatTransaction = session.openTransaction(); |
| addConflictResolver(thatTransaction); |
| |
| // Remove element |
| Root thisRoot = getTestModelRoot(thisTransaction); |
| thisRoot.getListA().remove(0); |
| |
| // Move same element |
| Root thatRoot = thatTransaction.getObject(thisRoot); |
| EList<BaseObject> containmentList = thatRoot.getListA(); |
| containmentList.move(2, containmentList.get(0)); |
| |
| commitAndSync(thisTransaction, thatTransaction); |
| assertEquals(false, thatTransaction.isDirty()); |
| assertEquals(false, thatTransaction.hasConflict()); |
| } |
| |
| public void testManyValuedChangeChangeTest() throws Exception |
| { |
| initTestModelSimple(); |
| |
| CDOSession session = openSessionWithAdditionsMode(); |
| CDOTransaction thisTransaction = session.openTransaction(); |
| CDOTransaction thatTransaction = session.openTransaction(); |
| addConflictResolver(thatTransaction); |
| |
| int objects = getTestModelRoot(thisTransaction).getListA().size(); |
| |
| // Move element. |
| Root thisRoot = getTestModelRoot(thisTransaction); |
| EList<BaseObject> containmentList = thisRoot.getListA(); |
| containmentList.move(2, containmentList.get(0)); |
| |
| // Move element. |
| Root thatRoot = thatTransaction.getObject(thisRoot); |
| EList<BaseObject> thatContainmentList = thatRoot.getListA(); |
| thatContainmentList.move(2, thatContainmentList.get(1)); |
| |
| commitAndSync(thisTransaction, thatTransaction); |
| commitAndSync(thatTransaction, thisTransaction); |
| |
| assertEquals(false, thisTransaction.isDirty()); |
| assertEquals(false, thatTransaction.isDirty()); |
| assertEquals(objects, getTestModelRoot(thisTransaction).getListA().size()); |
| } |
| |
| public void testManyValuedChangeChangeTest2() throws Exception |
| { |
| initTestModelSimple(); |
| |
| CDOSession session = openSessionWithAdditionsMode(); |
| CDOTransaction thisTransaction = session.openTransaction(); |
| CDOTransaction thatTransaction = session.openTransaction(); |
| addConflictResolver(thatTransaction); |
| |
| int objects = getTestModelRoot(thisTransaction).getListA().size(); |
| |
| // Move element. |
| Root thisRoot = getTestModelRoot(thisTransaction); |
| EList<BaseObject> containmentList = thisRoot.getListA(); |
| containmentList.move(2, containmentList.get(0)); |
| |
| // Move element. |
| Root thatRoot = thatTransaction.getObject(thisRoot); |
| EList<BaseObject> thatContainmentList = thatRoot.getListA(); |
| thatContainmentList.move(2, thatContainmentList.get(0)); |
| |
| commitAndSync(thisTransaction, thatTransaction); |
| commitAndSync(thatTransaction, thisTransaction); |
| |
| assertEquals(false, thisTransaction.isDirty()); |
| assertEquals(false, thatTransaction.isDirty()); |
| assertEquals(objects, getTestModelRoot(thisTransaction).getListA().size()); |
| } |
| |
| public void testManyValuedRemoveRemoveTest() throws Exception |
| { |
| initTestModelSimple(); |
| |
| CDOSession session = openSessionWithAdditionsMode(); |
| CDOTransaction thisTransaction = session.openTransaction(); |
| CDOTransaction thatTransaction = session.openTransaction(); |
| addConflictResolver(thatTransaction); |
| |
| int objects = getTestModelRoot(thisTransaction).getListA().size(); |
| |
| // Remove element. |
| Root thisRoot = getTestModelRoot(thisTransaction); |
| thisRoot.getListA().remove(0); |
| |
| // Remove element. |
| Root thatRoot = thatTransaction.getObject(thisRoot); |
| thatRoot.getListA().remove(2); |
| |
| commitAndSync(thisTransaction, thatTransaction); |
| commitAndSync(thatTransaction, thisTransaction); |
| |
| assertEquals(false, thisTransaction.isDirty()); |
| assertEquals(false, thatTransaction.isDirty()); |
| assertEquals(objects - 2, getTestModelRoot(thisTransaction).getListA().size()); |
| } |
| |
| public void testManyValuedRemoveRemoveTest2() throws Exception |
| { |
| initTestModelSimple(); |
| |
| CDOSession session = openSessionWithAdditionsMode(); |
| CDOTransaction thisTransaction = session.openTransaction(); |
| CDOTransaction thatTransaction = session.openTransaction(); |
| addConflictResolver(thatTransaction); |
| |
| int objects = getTestModelRoot(thisTransaction).getListA().size(); |
| |
| // Remove element. |
| Root thisRoot = getTestModelRoot(thisTransaction); |
| thisRoot.getListA().remove(0); |
| |
| // Remove same element. |
| Root thatRoot = thatTransaction.getObject(thisRoot); |
| thatRoot.getListA().remove(0); |
| |
| commitAndSync(thisTransaction, thatTransaction); |
| commitAndSync(thatTransaction, thisTransaction); |
| |
| assertEquals(false, thisTransaction.isDirty()); |
| assertEquals(false, thatTransaction.isDirty()); |
| assertEquals(objects - 1, getTestModelRoot(thisTransaction).getListA().size()); |
| } |
| |
| public void testManyValuedAddAddRemoveRemoveTest() throws Exception |
| { |
| initTestModelSimple(); |
| |
| // test to produce exception of bug #306710 |
| CDOSession session = openSessionWithAdditionsMode(); |
| CDOTransaction thisTransaction = session.openTransaction(); |
| CDOTransaction thatTransaction = session.openTransaction(); |
| addConflictResolver(thatTransaction); |
| |
| Root thisRoot = getTestModelRoot(thisTransaction); |
| EList<BaseObject> thisList = thisRoot.getListA(); |
| int objects = thisList.size(); |
| |
| Root thatRoot = thatTransaction.getObject(thisRoot); |
| EList<BaseObject> thatList = thatRoot.getListA(); |
| |
| // Add 2 elements and remove 1 element |
| thisList.add(0, createBaseObject("ThisObject1")); |
| thisList.add(0, createBaseObject("ThisObject2")); |
| thisList.remove(4); |
| |
| // Remove 1 element |
| thatList.remove(0); |
| |
| commitAndSync(thisTransaction, thatTransaction); |
| commitAndSync(thatTransaction, thisTransaction); |
| |
| assertEquals(false, thisTransaction.isDirty()); |
| assertEquals(false, thatTransaction.isDirty()); |
| assertEquals(objects, thisList.size()); |
| } |
| |
| public void testManyValuedAddAddRemoveRemove2Test() throws Exception |
| { |
| initTestModelSimple(); |
| |
| CDOSession session = openSessionWithAdditionsMode(); |
| CDOTransaction thisTransaction = session.openTransaction(); |
| CDOTransaction thatTransaction = session.openTransaction(); |
| addConflictResolver(thatTransaction); |
| |
| Root thisRoot = getTestModelRoot(thisTransaction); |
| EList<BaseObject> thisList = thisRoot.getListA(); |
| int objects = thisList.size(); |
| |
| Root thatRoot = thatTransaction.getObject(thisRoot); |
| EList<BaseObject> thatList = thatRoot.getListA(); |
| |
| // Remove elements |
| thisList.remove(0); |
| thisList.remove(0); |
| |
| // Add elements |
| thatList.add(createBaseObject("ThatObject1")); |
| thatList.add(createBaseObject("ThatObject2")); |
| |
| commitAndSync(thisTransaction, thatTransaction); |
| commitAndSync(thatTransaction, thisTransaction); |
| |
| assertEquals(false, thisTransaction.isDirty()); |
| assertEquals(false, thatTransaction.isDirty()); |
| assertEquals(objects, thisList.size()); |
| |
| } |
| |
| // --- initialize model ---------------------------------------------------- |
| |
| public void testManyValuedRemoveRemoveAddAddTest() throws Exception |
| { |
| initTestModelSimple(); |
| |
| CDOSession session = openSessionWithAdditionsMode(); |
| CDOTransaction thisTransaction = session.openTransaction(); |
| CDOTransaction thatTransaction = session.openTransaction(); |
| addConflictResolver(thatTransaction); |
| |
| int objects = getTestModelRoot(thisTransaction).getListA().size(); |
| |
| // Add elements. |
| BaseObject thisObject = createBaseObject("ThisObject"); |
| BaseObject thisObject2 = createBaseObject("ThisObject2"); |
| |
| Root thisRoot = getTestModelRoot(thisTransaction); |
| thisRoot.getListA().add(thisObject); |
| thisRoot.getListA().add(thisObject2); |
| |
| // Remove elements. |
| Root thatRoot = thatTransaction.getObject(thisRoot); |
| thatRoot.getListA().remove(0); |
| thatRoot.getListA().remove(0); |
| |
| commitAndSync(thisTransaction, thatTransaction); |
| commitAndSync(thatTransaction, thisTransaction); |
| |
| assertEquals(false, thisTransaction.isDirty()); |
| assertEquals(false, thatTransaction.isDirty()); |
| assertEquals(objects, getTestModelRoot(thisTransaction).getListA().size()); |
| |
| } |
| |
| // --- list conflict resolver tests ---------------------------------------- |
| |
| public void testAddHeadAddHeadTest() throws Exception |
| { |
| initTestModel(); |
| |
| CDOSession session = openSessionWithAdditionsMode(); |
| CDOTransaction thisTransaction = session.openTransaction(); |
| CDOTransaction thatTransaction = session.openTransaction(); |
| addConflictResolver(thatTransaction); |
| |
| // Access objects. |
| Root thisRoot = getTestModelRoot(thisTransaction); |
| Root thatRoot = thatTransaction.getObject(thisRoot); |
| |
| // Attach adapters. |
| thisRoot.eAdapters().add(new ListPrintingAdapter("This root: ")); |
| thatRoot.eAdapters().add(new ListPrintingAdapter("That root: ")); |
| |
| // Create objects. |
| BaseObject thisObject = createBaseObject("ThisBaseObject 0"); |
| EList<BaseObject> thisListA = thisRoot.getListA(); |
| thisListA.add(0, thisObject); |
| |
| BaseObject thatObject = createBaseObject("ThatBaseObject 0"); |
| EList<BaseObject> thatListA = thatRoot.getListA(); |
| thatListA.add(0, thatObject); |
| |
| commitAndSync(thisTransaction, thatTransaction); |
| commitAndSync(thatTransaction, thisTransaction); |
| |
| // Print contents of lists |
| printList("This ", thisListA); |
| printList("That ", thatListA); |
| |
| // Check indices. |
| assertEquals(false, thisTransaction.isDirty()); |
| assertEquals(false, thatTransaction.isDirty()); |
| assertEquals(thisListA.get(1), thisObject); |
| assertEquals(thisListA.get(0), thisTransaction.getObject(thatObject)); |
| assertEquals(thatListA.get(1), thatTransaction.getObject(thisObject)); |
| assertEquals(thatListA.get(0), thatObject); |
| } |
| |
| public void testAddHeadAddTailTest() throws Exception |
| { |
| initTestModel(); |
| |
| CDOSession session = openSessionWithAdditionsMode(); |
| CDOTransaction thisTransaction = session.openTransaction(); |
| CDOTransaction thatTransaction = session.openTransaction(); |
| addConflictResolver(thatTransaction); |
| |
| Root thisRoot = getTestModelRoot(thisTransaction); |
| EList<BaseObject> thisList = thisRoot.getListA(); |
| int objects = thisList.size(); |
| |
| Root thatRoot = thatTransaction.getObject(thisRoot); |
| EList<BaseObject> thatList = thatRoot.getListA(); |
| |
| // Attach adapters |
| thisRoot.eAdapters().add(new ListPrintingAdapter("This root: ")); |
| thatRoot.eAdapters().add(new ListPrintingAdapter("That root: ")); |
| |
| // Add element to head |
| BaseObject thisObject = createBaseObject("ThisBaseObject 0"); |
| thisList.add(0, thisObject); |
| |
| // Add element to tail |
| BaseObject thatObject = createBaseObject("ThatBaseObject 0"); |
| thatList.add(thatObject); |
| |
| commitAndSync(thisTransaction, thatTransaction); |
| commitAndSync(thatTransaction, thisTransaction); |
| |
| // Print contents of lists |
| printList("This ", thisList); |
| printList("That ", thatList); |
| |
| // Check indices |
| assertEquals(false, thisTransaction.isDirty()); |
| assertEquals(false, thatTransaction.isDirty()); |
| assertEquals(objects + 2, thisList.size()); |
| assertEquals(objects + 2, thatList.size()); |
| } |
| |
| public void testAddTailAddTailTest() throws Exception |
| { |
| initTestModel(); |
| |
| CDOSession session = openSessionWithAdditionsMode(); |
| CDOTransaction thisTransaction = session.openTransaction(); |
| CDOTransaction thatTransaction = session.openTransaction(); |
| addConflictResolver(thatTransaction); |
| |
| // Access objects. |
| Root thisRoot = getTestModelRoot(thisTransaction); |
| Root thatRoot = thatTransaction.getObject(thisRoot); |
| |
| // Attach adapters. |
| thisRoot.eAdapters().add(new ListPrintingAdapter("This root: ")); |
| thatRoot.eAdapters().add(new ListPrintingAdapter("That root: ")); |
| |
| // Create objects. |
| BaseObject thisObject = createBaseObject("ThisBaseObject 0"); |
| thisRoot.getListA().add(thisObject); |
| |
| BaseObject thatObject = createBaseObject("ThatBaseObject 0"); |
| thatRoot.getListA().add(thatObject); |
| |
| commitAndSync(thisTransaction, thatTransaction); |
| commitAndSync(thatTransaction, thisTransaction); |
| |
| // Print contents of lists |
| printList("This ", thisRoot.getListA()); |
| printList("That ", thatRoot.getListA()); |
| |
| // Check indices. |
| int size = thisRoot.getListA().size(); |
| assertEquals(false, thisTransaction.isDirty()); |
| assertEquals(false, thatTransaction.isDirty()); |
| assertEquals(thisRoot.getListA().get(size - 1), thisObject); |
| assertEquals(thisRoot.getListA().get(size - 2), thisTransaction.getObject(thatObject)); |
| assertEquals(thatRoot.getListA().get(size - 1), thatTransaction.getObject(thisObject)); |
| assertEquals(thatRoot.getListA().get(size - 2), thatObject); |
| } |
| |
| public void testAddTailAddHeadTest() throws Exception |
| { |
| initTestModel(); |
| |
| CDOSession session = openSessionWithAdditionsMode(); |
| CDOTransaction thisTransaction = session.openTransaction(); |
| CDOTransaction thatTransaction = session.openTransaction(); |
| addConflictResolver(thatTransaction); |
| |
| Root thisRoot = getTestModelRoot(thisTransaction); |
| EList<BaseObject> thisList = thisRoot.getListA(); |
| |
| Root thatRoot = thatTransaction.getObject(thisRoot); |
| EList<BaseObject> thatList = thatRoot.getListA(); |
| |
| // Attach adapters |
| thisRoot.eAdapters().add(new ListPrintingAdapter("This root: ")); |
| thatRoot.eAdapters().add(new ListPrintingAdapter("That root: ")); |
| |
| // Add element to tail |
| BaseObject thisObject = createBaseObject("ThisBaseObject 0"); |
| thisList.add(thisObject); |
| |
| // Add element to head |
| BaseObject thatObject = createBaseObject("ThatBaseObject 0"); |
| thatList.add(0, thatObject); |
| |
| commitAndSync(thisTransaction, thatTransaction); |
| commitAndSync(thatTransaction, thisTransaction); |
| |
| // Print contents of lists |
| printList("This ", thisList); |
| printList("That ", thatList); |
| |
| // Check indices |
| int size = thisList.size(); |
| assertEquals(false, thisTransaction.isDirty()); |
| assertEquals(false, thatTransaction.isDirty()); |
| assertEquals(thisList.get(size - 1), thisObject); |
| assertEquals(thisList.get(0), thisTransaction.getObject(thatObject)); |
| assertEquals(thatList.get(size - 1), thatTransaction.getObject(thisObject)); |
| assertEquals(thatList.get(0), thatObject); |
| } |
| |
| // Add - remove |
| |
| public void testAddHeadRemoveHeadTest() throws Exception |
| { |
| initTestModel(); |
| |
| CDOSession session = openSessionWithAdditionsMode(); |
| CDOTransaction thisTransaction = session.openTransaction(); |
| CDOTransaction thatTransaction = session.openTransaction(); |
| addConflictResolver(thatTransaction); |
| |
| // Access objects. |
| Root thisRoot = getTestModelRoot(thisTransaction); |
| Root thatRoot = thatTransaction.getObject(thisRoot); |
| |
| // Attach adapters. |
| thisRoot.eAdapters().add(new ListPrintingAdapter("This root: ")); |
| thatRoot.eAdapters().add(new ListPrintingAdapter("That root: ")); |
| |
| // Create object. |
| BaseObject thisObject = createBaseObject("ThisBaseObject 0"); |
| thisRoot.getListA().add(0, thisObject); |
| |
| // Remove object (get it before deletion). |
| BaseObject thatRemoveObject = thatRoot.getListA().get(0); |
| BaseObject thisRemoveObject = thisTransaction.getObject(thatRemoveObject); |
| |
| thatRoot.getListA().remove(0); |
| BaseObject thatAfterRemoveObject = thatRoot.getListA().get(0); |
| |
| commitAndSync(thisTransaction, thatTransaction); |
| commitAndSync(thatTransaction, thisTransaction); |
| |
| // Print contents of lists |
| printList("This ", thisRoot.getListA()); |
| printList("That ", thatRoot.getListA()); |
| |
| // Check indices. |
| assertEquals(false, thisTransaction.isDirty()); |
| assertEquals(false, thatTransaction.isDirty()); |
| assertEquals(thisRoot.getListA().get(0), thisObject); |
| assertEquals(thisRoot.getListA().get(1), thisTransaction.getObject(thatAfterRemoveObject)); |
| assertEquals(thatRoot.getListA().get(0), thatTransaction.getObject(thisObject)); |
| assertEquals(thatRoot.getListA().get(1), thatAfterRemoveObject); |
| assertEquals(CDOUtil.getCDOObject(thisRemoveObject).cdoState(), CDOState.INVALID); |
| assertEquals(CDOUtil.getCDOObject(thatRemoveObject).cdoState(), CDOState.TRANSIENT); |
| } |
| |
| public void testAddHeadRemoveTailTest() throws Exception |
| { |
| initTestModel(); |
| |
| CDOSession session = openSessionWithAdditionsMode(); |
| CDOTransaction thisTransaction = session.openTransaction(); |
| CDOTransaction thatTransaction = session.openTransaction(); |
| addConflictResolver(thatTransaction); |
| |
| // Access objects. |
| Root thisRoot = getTestModelRoot(thisTransaction); |
| Root thatRoot = thatTransaction.getObject(thisRoot); |
| |
| // Attach adapters. |
| thisRoot.eAdapters().add(new ListPrintingAdapter("This root: ")); |
| thatRoot.eAdapters().add(new ListPrintingAdapter("That root: ")); |
| |
| // Create object. |
| BaseObject thisObject = createBaseObject("ThisBaseObject 0"); |
| thisRoot.getListA().add(0, thisObject); |
| |
| // Remove object (get it before deletion). |
| int listSize = thatRoot.getListA().size(); |
| BaseObject thatRemoveObject = thatRoot.getListA().get(listSize - 1); |
| BaseObject thisRemoveObject = thisTransaction.getObject(thatRemoveObject); |
| |
| thatRoot.getListA().remove(listSize - 1); |
| BaseObject thatBeforeRemoveObject = thatRoot.getListA().get(thatRoot.getListA().size() - 1); |
| |
| commitAndSync(thisTransaction, thatTransaction); |
| commitAndSync(thatTransaction, thisTransaction); |
| |
| // Print contents of lists |
| printList("This ", thisRoot.getListA()); |
| printList("That ", thatRoot.getListA()); |
| |
| // Check indices. |
| int size = thisRoot.getListA().size(); |
| assertEquals(false, thisTransaction.isDirty()); |
| assertEquals(false, thatTransaction.isDirty()); |
| assertEquals(thisRoot.getListA().get(0), thisObject); |
| assertEquals(thisRoot.getListA().get(size - 1), thisTransaction.getObject(thatBeforeRemoveObject)); |
| assertEquals(thatRoot.getListA().get(0), thatTransaction.getObject(thisObject)); |
| assertEquals(thatRoot.getListA().get(size - 1), thatBeforeRemoveObject); |
| assertEquals(CDOUtil.getCDOObject(thisRemoveObject).cdoState(), CDOState.INVALID); |
| assertEquals(CDOUtil.getCDOObject(thatRemoveObject).cdoState(), CDOState.TRANSIENT); |
| } |
| |
| public void testAddTailRemoveTailTest() throws Exception |
| { |
| initTestModel(); |
| |
| CDOSession session = openSessionWithAdditionsMode(); |
| CDOTransaction thisTransaction = session.openTransaction(); |
| CDOTransaction thatTransaction = session.openTransaction(); |
| addConflictResolver(thatTransaction); |
| |
| // Access objects. |
| Root thisRoot = getTestModelRoot(thisTransaction); |
| Root thatRoot = thatTransaction.getObject(thisRoot); |
| |
| // Attach adapters. |
| thisRoot.eAdapters().add(new ListPrintingAdapter("This root: ")); |
| thatRoot.eAdapters().add(new ListPrintingAdapter("That root: ")); |
| |
| // Create object. |
| BaseObject thisObject = createBaseObject("ThisBaseObject 0"); |
| thisRoot.getListA().add(thisObject); |
| |
| // Remove object (get it before deletion). |
| int listSize = thatRoot.getListA().size(); |
| BaseObject thatRemoveObject = thatRoot.getListA().get(listSize - 1); |
| BaseObject thisRemoveObject = thisTransaction.getObject(thatRemoveObject); |
| |
| thatRoot.getListA().remove(listSize - 1); |
| BaseObject thatBeforeRemoveObject = thatRoot.getListA().get(thatRoot.getListA().size() - 1); |
| |
| commitAndSync(thisTransaction, thatTransaction); |
| commitAndSync(thatTransaction, thisTransaction); |
| |
| // Print contents of lists |
| printList("This ", thisRoot.getListA()); |
| printList("That ", thatRoot.getListA()); |
| |
| // Check indices. |
| int size = thisRoot.getListA().size(); |
| assertEquals(false, thisTransaction.isDirty()); |
| assertEquals(false, thatTransaction.isDirty()); |
| assertEquals(thisRoot.getListA().get(size - 1), thisObject); |
| assertEquals(thisRoot.getListA().get(size - 2), thisTransaction.getObject(thatBeforeRemoveObject)); |
| assertEquals(thatRoot.getListA().get(size - 1), thatTransaction.getObject(thisObject)); |
| assertEquals(thatRoot.getListA().get(size - 2), thatBeforeRemoveObject); |
| assertEquals(CDOUtil.getCDOObject(thisRemoveObject).cdoState(), CDOState.INVALID); |
| assertEquals(CDOUtil.getCDOObject(thatRemoveObject).cdoState(), CDOState.TRANSIENT); |
| } |
| |
| public void testAddTailRemoveHeadTest() throws Exception |
| { |
| initTestModel(); |
| |
| CDOSession session = openSessionWithAdditionsMode(); |
| CDOTransaction thisTransaction = session.openTransaction(); |
| CDOTransaction thatTransaction = session.openTransaction(); |
| addConflictResolver(thatTransaction); |
| |
| // Access objects. |
| Root thisRoot = getTestModelRoot(thisTransaction); |
| Root thatRoot = thatTransaction.getObject(thisRoot); |
| |
| // Attach adapters. |
| thisRoot.eAdapters().add(new ListPrintingAdapter("This root: ")); |
| thatRoot.eAdapters().add(new ListPrintingAdapter("That root: ")); |
| |
| // Create objects. |
| BaseObject thisObject = createBaseObject("ThisBaseObject 0"); |
| thisRoot.getListA().add(thisObject); |
| |
| // Remove object (get it before deletion). |
| BaseObject thatRemoveObject = thatRoot.getListA().get(0); |
| BaseObject thisRemoveObject = thisTransaction.getObject(thatRemoveObject); |
| |
| thatRoot.getListA().remove(0); |
| BaseObject thatAfterRemoveObject = thatRoot.getListA().get(0); |
| |
| commitAndSync(thisTransaction, thatTransaction); |
| commitAndSync(thatTransaction, thisTransaction); |
| |
| // Print contents of lists |
| printList("This ", thisRoot.getListA()); |
| printList("That ", thatRoot.getListA()); |
| |
| // Check indices. |
| int size = thisRoot.getListA().size(); |
| assertEquals(false, thisTransaction.isDirty()); |
| assertEquals(false, thatTransaction.isDirty()); |
| assertEquals(thisRoot.getListA().get(size - 1), thisObject); |
| assertEquals(thisRoot.getListA().get(0), thisTransaction.getObject(thatAfterRemoveObject)); |
| assertEquals(thatRoot.getListA().get(size - 1), thatTransaction.getObject(thisObject)); |
| assertEquals(thatRoot.getListA().get(0), thatAfterRemoveObject); |
| assertEquals(CDOUtil.getCDOObject(thisRemoveObject).cdoState(), CDOState.INVALID); |
| assertEquals(CDOUtil.getCDOObject(thatRemoveObject).cdoState(), CDOState.TRANSIENT); |
| } |
| |
| // Add - move |
| |
| public void testAddHeadMoveHeadTest() throws Exception |
| { |
| initTestModel(); |
| |
| CDOSession session = openSessionWithAdditionsMode(); |
| CDOTransaction thisTransaction = session.openTransaction(); |
| CDOTransaction thatTransaction = session.openTransaction(); |
| addConflictResolver(thatTransaction); |
| |
| // Access objects. |
| Root thisRoot = getTestModelRoot(thisTransaction); |
| Root thatRoot = thatTransaction.getObject(thisRoot); |
| |
| // Attach adapters. |
| thisRoot.eAdapters().add(new ListPrintingAdapter("This root: ")); |
| thatRoot.eAdapters().add(new ListPrintingAdapter("That root: ")); |
| |
| // Create object. |
| BaseObject thisObject = createBaseObject("ThisBaseObject 0"); |
| thisRoot.getListA().add(0, thisObject); |
| |
| // Move object. |
| BaseObject thatMoveObject = thatRoot.getListA().get(0); |
| thatRoot.getListA().move(thatRoot.getListA().size() - 1, 0); |
| |
| commitAndSync(thisTransaction, thatTransaction); |
| commitAndSync(thatTransaction, thisTransaction); |
| |
| // Print contents of lists |
| printList("This ", thisRoot.getListA()); |
| printList("That ", thatRoot.getListA()); |
| |
| // Check indices. |
| int size = thisRoot.getListA().size(); |
| assertEquals(false, thisTransaction.isDirty()); |
| assertEquals(false, thatTransaction.isDirty()); |
| assertEquals(thisRoot.getListA().get(0), thisObject); |
| assertEquals(thisRoot.getListA().get(size - 1), thisTransaction.getObject(thatMoveObject)); |
| assertEquals(thatRoot.getListA().get(0), thatTransaction.getObject(thisObject)); |
| assertEquals(thatRoot.getListA().get(size - 1), thatMoveObject); |
| } |
| |
| public void testAddHeadMoveTailTest() throws Exception |
| { |
| initTestModel(); |
| |
| CDOSession session = openSessionWithAdditionsMode(); |
| CDOTransaction thisTransaction = session.openTransaction(); |
| CDOTransaction thatTransaction = session.openTransaction(); |
| addConflictResolver(thatTransaction); |
| |
| Root thisRoot = getTestModelRoot(thisTransaction); |
| EList<BaseObject> thisList = thisRoot.getListA(); |
| int objects = thisList.size(); |
| |
| Root thatRoot = thatTransaction.getObject(thisRoot); |
| EList<BaseObject> thatList = thatRoot.getListA(); |
| |
| // Attach adapters |
| thisRoot.eAdapters().add(new ListPrintingAdapter("This root: ")); |
| thatRoot.eAdapters().add(new ListPrintingAdapter("That root: ")); |
| |
| // Add element to head |
| thisList.add(0, createBaseObject("ThisBaseObject 0")); |
| |
| // Move head element |
| thatList.move(0, thatList.size() - 1); |
| |
| commitAndSync(thisTransaction, thatTransaction); |
| commitAndSync(thatTransaction, thisTransaction); |
| |
| // Print contents of lists |
| printList("This ", thisList); |
| printList("That ", thatList); |
| |
| // Check indices |
| assertEquals(false, thisTransaction.isDirty()); |
| assertEquals(false, thatTransaction.isDirty()); |
| assertEquals(objects + 1, thisList.size()); |
| assertEquals(objects + 1, thatList.size()); |
| } |
| |
| public void testAddTailMoveTailTest() throws Exception |
| { |
| initTestModel(); |
| |
| CDOSession session = openSessionWithAdditionsMode(); |
| CDOTransaction thisTransaction = session.openTransaction(); |
| CDOTransaction thatTransaction = session.openTransaction(); |
| addConflictResolver(thatTransaction); |
| |
| // Access objects. |
| Root thisRoot = getTestModelRoot(thisTransaction); |
| Root thatRoot = thatTransaction.getObject(thisRoot); |
| |
| // Attach adapters. |
| thisRoot.eAdapters().add(new ListPrintingAdapter("This root: ")); |
| thatRoot.eAdapters().add(new ListPrintingAdapter("That root: ")); |
| |
| // Create object. |
| BaseObject thisObject = createBaseObject("ThisBaseObject 0"); |
| thisRoot.getListA().add(thisObject); |
| |
| // Move object. |
| BaseObject thatMoveObject = thatRoot.getListA().get(thatRoot.getListA().size() - 1); |
| thatRoot.getListA().move(0, thatRoot.getListA().size() - 1); |
| |
| commitAndSync(thisTransaction, thatTransaction); |
| commitAndSync(thatTransaction, thisTransaction); |
| |
| // Print contents of lists |
| printList("This ", thisRoot.getListA()); |
| printList("That ", thatRoot.getListA()); |
| |
| // Check indices. |
| int size = thisRoot.getListA().size(); |
| assertEquals(false, thisTransaction.isDirty()); |
| assertEquals(false, thatTransaction.isDirty()); |
| assertEquals(thisRoot.getListA().get(size - 1), thisObject); |
| assertEquals(thisRoot.getListA().get(0), thisTransaction.getObject(thatMoveObject)); |
| assertEquals(thatRoot.getListA().get(size - 1), thatTransaction.getObject(thisObject)); |
| assertEquals(thatRoot.getListA().get(0), thatMoveObject); |
| } |
| |
| public void testAddTailMoveHeadTest() throws Exception |
| { |
| initTestModel(); |
| |
| CDOSession session = openSessionWithAdditionsMode(); |
| CDOTransaction thisTransaction = session.openTransaction(); |
| CDOTransaction thatTransaction = session.openTransaction(); |
| addConflictResolver(thatTransaction); |
| |
| // Access objects. |
| Root thisRoot = getTestModelRoot(thisTransaction); |
| Root thatRoot = thatTransaction.getObject(thisRoot); |
| |
| // Attach adapters. |
| thisRoot.eAdapters().add(new ListPrintingAdapter("This root: ")); |
| thatRoot.eAdapters().add(new ListPrintingAdapter("That root: ")); |
| |
| // Create objects. |
| BaseObject thisObject = createBaseObject("ThisBaseObject 0"); |
| thisRoot.getListA().add(thisObject); |
| |
| // Remove object. |
| thatRoot.getListA().remove(0); |
| BaseObject thatAfterRemoveObject = thatRoot.getListA().get(0); |
| |
| commitAndSync(thisTransaction, thatTransaction); |
| commitAndSync(thatTransaction, thisTransaction); |
| |
| // Print contents of lists |
| printList("This ", thisRoot.getListA()); |
| printList("That ", thatRoot.getListA()); |
| |
| // Check indices. |
| int size = thisRoot.getListA().size(); |
| assertEquals(false, thisTransaction.isDirty()); |
| assertEquals(false, thatTransaction.isDirty()); |
| assertEquals(thisRoot.getListA().get(size - 1), thisObject); |
| assertEquals(thisRoot.getListA().get(0), thisTransaction.getObject(thatAfterRemoveObject)); |
| assertEquals(thatRoot.getListA().get(size - 1), thatTransaction.getObject(thisObject)); |
| assertEquals(thatRoot.getListA().get(0), thatAfterRemoveObject); |
| } |
| |
| public void testAddHeadClearTest() throws Exception |
| { |
| initTestModel(); |
| |
| CDOSession session = openSessionWithAdditionsMode(); |
| CDOTransaction thisTransaction = session.openTransaction(); |
| CDOTransaction thatTransaction = session.openTransaction(); |
| addConflictResolver(thatTransaction); |
| |
| // Access objects. |
| Root thisRoot = getTestModelRoot(thisTransaction); |
| Root thatRoot = thatTransaction.getObject(thisRoot); |
| |
| // Access lists. |
| EList<BaseObject> thisListA = thisRoot.getListA(); |
| EList<BaseObject> thatListA = thatRoot.getListA(); |
| |
| // Attach adapters. |
| thisRoot.eAdapters().add(new ListPrintingAdapter("This root: ")); |
| thatRoot.eAdapters().add(new ListPrintingAdapter("That root: ")); |
| |
| // Create objects. |
| BaseObject thisObject = createBaseObject("ThisBaseObject 0"); |
| thisListA.add(0, thisObject); |
| |
| // Clear list. |
| thatListA.clear(); |
| |
| commitAndSync(thisTransaction, thatTransaction); |
| commitAndSync(thatTransaction, thisTransaction); |
| |
| // Print contents of lists |
| printList("This ", thisListA); |
| printList("That ", thatListA); |
| |
| // Check indices. |
| assertEquals(false, thisTransaction.isDirty()); |
| assertEquals(false, thatTransaction.isDirty()); |
| assertEquals(false, thisTransaction.hasConflict()); |
| assertEquals(false, thatTransaction.hasConflict()); |
| assertEquals(1, thisListA.size()); // CLEAR means remove all *originally existing* elements |
| assertEquals(1, thatListA.size()); // CLEAR means remove all *originally existing* elements |
| assertEquals(CDOState.CLEAN, CDOUtil.getCDOObject(thisObject).cdoState()); |
| } |
| |
| public void testAddTailClearTest() throws Exception |
| { |
| initTestModel(); |
| |
| CDOSession session = openSessionWithAdditionsMode(); |
| CDOTransaction thisTransaction = session.openTransaction(); |
| CDOTransaction thatTransaction = session.openTransaction(); |
| addConflictResolver(thatTransaction); |
| |
| // Access objects. |
| Root thisRoot = getTestModelRoot(thisTransaction); |
| Root thatRoot = thatTransaction.getObject(thisRoot); |
| |
| // Access lists. |
| EList<BaseObject> thisListA = thisRoot.getListA(); |
| EList<BaseObject> thatListA = thatRoot.getListA(); |
| |
| // Attach adapters. |
| thisRoot.eAdapters().add(new ListPrintingAdapter("This root: ")); |
| thatRoot.eAdapters().add(new ListPrintingAdapter("That root: ")); |
| |
| // Create objects. |
| BaseObject thisObject = createBaseObject("ThisBaseObject 0"); |
| thisListA.add(thisObject); |
| |
| // Clear list. |
| thatListA.clear(); |
| |
| commitAndSync(thisTransaction, thatTransaction); |
| commitAndSync(thatTransaction, thisTransaction); |
| |
| // Print contents of lists |
| printList("This ", thisListA); |
| printList("That ", thatListA); |
| |
| // Check indices. |
| assertEquals(false, thisTransaction.isDirty()); |
| assertEquals(false, thatTransaction.isDirty()); |
| assertEquals(false, thisTransaction.hasConflict()); |
| assertEquals(false, thatTransaction.hasConflict()); |
| assertEquals(1, thisListA.size()); // CLEAR means remove all *originally existing* elements |
| assertEquals(1, thatListA.size()); // CLEAR means remove all *originally existing* elements |
| assertEquals(CDOState.CLEAN, CDOUtil.getCDOObject(thisObject).cdoState()); |
| } |
| |
| public void testRemoveHeadAddHeadTest() throws Exception |
| { |
| initTestModel(); |
| |
| CDOSession session = openSessionWithAdditionsMode(); |
| CDOTransaction thisTransaction = session.openTransaction(); |
| CDOTransaction thatTransaction = session.openTransaction(); |
| addConflictResolver(thatTransaction); |
| |
| // Access objects. |
| Root thisRoot = getTestModelRoot(thisTransaction); |
| Root thatRoot = thatTransaction.getObject(thisRoot); |
| |
| // Attach adapters. |
| thisRoot.eAdapters().add(new ListPrintingAdapter("This root: ")); |
| thatRoot.eAdapters().add(new ListPrintingAdapter("That root: ")); |
| |
| // Remove object (get it before deletion). |
| BaseObject thisRemoveObject = thisRoot.getListA().get(0); |
| BaseObject thatRemoveObject = thatTransaction.getObject(thisRemoveObject); |
| |
| thisRoot.getListA().remove(0); |
| BaseObject thisAfterRemoveObject = thisRoot.getListA().get(0); |
| |
| // Create object. |
| BaseObject thatObject = createBaseObject("ThatBaseObject 0"); |
| thatRoot.getListA().add(0, thatObject); |
| |
| commitAndSync(thisTransaction, thatTransaction); |
| commitAndSync(thatTransaction, thisTransaction); |
| |
| // Print contents of lists |
| printList("This ", thisRoot.getListA()); |
| printList("That ", thatRoot.getListA()); |
| |
| // Check indices. |
| assertEquals(false, thisTransaction.isDirty()); |
| assertEquals(false, thatTransaction.isDirty()); |
| assertEquals(thisRoot.getListA().get(0), thisTransaction.getObject(thatObject)); |
| assertEquals(thisRoot.getListA().get(1), thisAfterRemoveObject); |
| assertEquals(thatRoot.getListA().get(0), thatTransaction.getObject(thatObject)); |
| assertEquals(thatRoot.getListA().get(1), thatTransaction.getObject(thisAfterRemoveObject)); |
| assertEquals(CDOState.TRANSIENT, CDOUtil.getCDOObject(thisRemoveObject).cdoState()); |
| assertEquals(CDOState.INVALID, CDOUtil.getCDOObject(thatRemoveObject).cdoState()); |
| } |
| |
| public void testRemoveHeadAddTailTest() throws Exception |
| { |
| initTestModel(); |
| |
| CDOSession session = openSessionWithAdditionsMode(); |
| CDOTransaction thisTransaction = session.openTransaction(); |
| CDOTransaction thatTransaction = session.openTransaction(); |
| addConflictResolver(thatTransaction); |
| |
| // Access objects. |
| Root thisRoot = getTestModelRoot(thisTransaction); |
| Root thatRoot = thatTransaction.getObject(thisRoot); |
| |
| // Attach adapters. |
| thisRoot.eAdapters().add(new ListPrintingAdapter("This root: ")); |
| thatRoot.eAdapters().add(new ListPrintingAdapter("That root: ")); |
| |
| // Remove object (get it before deletion). |
| BaseObject thisRemoveObject = thisRoot.getListA().get(0); |
| BaseObject thatRemoveObject = thatTransaction.getObject(thisRemoveObject); |
| |
| thisRoot.getListA().remove(0); |
| BaseObject thisAfterRemoveObject = thisRoot.getListA().get(0); |
| |
| // Create object. |
| BaseObject thatObject = createBaseObject("ThatBaseObject 0"); |
| thatRoot.getListA().add(thatObject); |
| |
| commitAndSync(thisTransaction, thatTransaction); |
| commitAndSync(thatTransaction, thisTransaction); |
| |
| // Print contents of lists |
| printList("This ", thisRoot.getListA()); |
| printList("That ", thatRoot.getListA()); |
| |
| // Check indices. |
| int listSize = thisRoot.getListA().size(); |
| assertEquals(false, thisTransaction.isDirty()); |
| assertEquals(false, thatTransaction.isDirty()); |
| assertEquals(thisRoot.getListA().get(listSize - 1), thisTransaction.getObject(thatObject)); |
| assertEquals(thisRoot.getListA().get(0), thisAfterRemoveObject); |
| assertEquals(thatRoot.getListA().get(listSize - 1), thatTransaction.getObject(thatObject)); |
| assertEquals(thatRoot.getListA().get(0), thatTransaction.getObject(thisAfterRemoveObject)); |
| assertEquals(CDOState.TRANSIENT, CDOUtil.getCDOObject(thisRemoveObject).cdoState()); |
| assertEquals(CDOState.INVALID, CDOUtil.getCDOObject(thatRemoveObject).cdoState()); |
| } |
| |
| public void testRemoveTailAddHeadTest() throws Exception |
| { |
| initTestModel(); |
| |
| CDOSession session = openSessionWithAdditionsMode(); |
| CDOTransaction thisTransaction = session.openTransaction(); |
| CDOTransaction thatTransaction = session.openTransaction(); |
| addConflictResolver(thatTransaction); |
| |
| // Access objects. |
| Root thisRoot = getTestModelRoot(thisTransaction); |
| Root thatRoot = thatTransaction.getObject(thisRoot); |
| |
| // Attach adapters. |
| thisRoot.eAdapters().add(new ListPrintingAdapter("This root: ")); |
| thatRoot.eAdapters().add(new ListPrintingAdapter("That root: ")); |
| |
| // Remove object (get it before deletion). |
| BaseObject thisRemoveObject = thisRoot.getListA().get(thisRoot.getListA().size() - 1); |
| BaseObject thatRemoveObject = thatTransaction.getObject(thisRemoveObject); |
| |
| thisRoot.getListA().remove(thisRoot.getListA().size() - 1); |
| BaseObject thisAfterRemoveObject = thisRoot.getListA().get(thisRoot.getListA().size() - 1); |
| |
| // Create object. |
| BaseObject thatObject = createBaseObject("ThatBaseObject 0"); |
| thatRoot.getListA().add(0, thatObject); |
| |
| commitAndSync(thisTransaction, thatTransaction); |
| commitAndSync(thatTransaction, thisTransaction); |
| |
| // Print contents of lists |
| printList("This ", thisRoot.getListA()); |
| printList("That ", thatRoot.getListA()); |
| |
| // Check indices. |
| int listSize = thisRoot.getListA().size(); |
| assertEquals(false, thisTransaction.isDirty()); |
| assertEquals(false, thatTransaction.isDirty()); |
| assertEquals(thisRoot.getListA().get(0), thisTransaction.getObject(thatObject)); |
| assertEquals(thisRoot.getListA().get(listSize - 1), thisAfterRemoveObject); |
| assertEquals(thatRoot.getListA().get(0), thatTransaction.getObject(thatObject)); |
| assertEquals(thatRoot.getListA().get(listSize - 1), thatTransaction.getObject(thisAfterRemoveObject)); |
| assertEquals(CDOState.TRANSIENT, CDOUtil.getCDOObject(thisRemoveObject).cdoState()); |
| assertEquals(CDOState.INVALID, CDOUtil.getCDOObject(thatRemoveObject).cdoState()); |
| } |
| |
| public void testRemoveTailAddTailTest() throws Exception |
| { |
| initTestModel(); |
| |
| CDOSession session = openSessionWithAdditionsMode(); |
| CDOTransaction thisTransaction = session.openTransaction(); |
| CDOTransaction thatTransaction = session.openTransaction(); |
| addConflictResolver(thatTransaction); |
| |
| // Access objects. |
| Root thisRoot = getTestModelRoot(thisTransaction); |
| Root thatRoot = thatTransaction.getObject(thisRoot); |
| |
| // Attach adapters. |
| thisRoot.eAdapters().add(new ListPrintingAdapter("This root: ")); |
| thatRoot.eAdapters().add(new ListPrintingAdapter("That root: ")); |
| |
| // Remove object (get it before deletion). |
| BaseObject thisRemoveObject = thisRoot.getListA().get(thisRoot.getListA().size() - 1); |
| BaseObject thatRemoveObject = thatTransaction.getObject(thisRemoveObject); |
| |
| thisRoot.getListA().remove(thisRoot.getListA().size() - 1); |
| BaseObject thisAfterRemoveObject = thisRoot.getListA().get(thisRoot.getListA().size() - 1); |
| |
| // Create object. |
| BaseObject thatObject = createBaseObject("ThatBaseObject 0"); |
| thatRoot.getListA().add(thatObject); |
| |
| commitAndSync(thisTransaction, thatTransaction); |
| commitAndSync(thatTransaction, thisTransaction); |
| |
| // Print contents of lists |
| printList("This ", thisRoot.getListA()); |
| printList("That ", thatRoot.getListA()); |
| |
| // Check indices. |
| int listSize = thisRoot.getListA().size(); |
| assertEquals(false, thisTransaction.isDirty()); |
| assertEquals(false, thatTransaction.isDirty()); |
| assertEquals(thisRoot.getListA().get(listSize - 1), thisTransaction.getObject(thatObject)); |
| assertEquals(thisRoot.getListA().get(listSize - 2), thisAfterRemoveObject); |
| assertEquals(thatRoot.getListA().get(listSize - 1), thatTransaction.getObject(thatObject)); |
| assertEquals(thatRoot.getListA().get(listSize - 2), thatTransaction.getObject(thisAfterRemoveObject)); |
| assertEquals(CDOState.TRANSIENT, CDOUtil.getCDOObject(thisRemoveObject).cdoState()); |
| assertEquals(CDOState.INVALID, CDOUtil.getCDOObject(thatRemoveObject).cdoState()); |
| } |
| |
| public void testRemoveHeadRemoveHeadTest() throws Exception |
| { |
| initTestModel(); |
| |
| CDOSession session = openSessionWithAdditionsMode(); |
| CDOTransaction thisTransaction = session.openTransaction(); |
| CDOTransaction thatTransaction = session.openTransaction(); |
| addConflictResolver(thatTransaction); |
| |
| // Access objects. |
| Root thisRoot = getTestModelRoot(thisTransaction); |
| Root thatRoot = thatTransaction.getObject(thisRoot); |
| |
| // Attach adapters. |
| thisRoot.eAdapters().add(new ListPrintingAdapter("This root: ")); |
| thatRoot.eAdapters().add(new ListPrintingAdapter("That root: ")); |
| |
| // Remove object (get it before deletion). |
| BaseObject thisRemoveObject1 = thisRoot.getListA().get(0); |
| BaseObject thatRemoveObject1 = thatTransaction.getObject(thisRemoveObject1); |
| |
| thisRoot.getListA().remove(0); |
| BaseObject thisAfterRemoveObject1 = thisRoot.getListA().get(0); |
| |
| // // Remove object (get it before deletion). |
| BaseObject thatRemoveObject2 = thatRoot.getListA().get(0); |
| BaseObject thisRemoveObject2 = thisTransaction.getObject(thatRemoveObject2); |
| |
| thatRoot.getListA().remove(0); |
| BaseObject thatAfterRemoveObject2 = thatRoot.getListA().get(0); |
| |
| commitAndSync(thisTransaction, thatTransaction); |
| commitAndSync(thatTransaction, thisTransaction); |
| |
| // Print contents of lists |
| printList("This ", thisRoot.getListA()); |
| printList("That ", thatRoot.getListA()); |
| |
| // Check indices. |
| assertEquals(false, thisTransaction.isDirty()); |
| assertEquals(false, thatTransaction.isDirty()); |
| assertEquals(thisAfterRemoveObject1, thisRoot.getListA().get(0)); |
| assertEquals(thatAfterRemoveObject2, thatRoot.getListA().get(0)); |
| assertEquals(CDOState.TRANSIENT, CDOUtil.getCDOObject(thisRemoveObject1).cdoState()); |
| assertEquals(CDOState.TRANSIENT, CDOUtil.getCDOObject(thatRemoveObject1).cdoState()); |
| assertEquals(CDOState.TRANSIENT, CDOUtil.getCDOObject(thisRemoveObject2).cdoState()); |
| assertEquals(CDOState.TRANSIENT, CDOUtil.getCDOObject(thatRemoveObject2).cdoState()); |
| } |
| |
| public void testRemoveHeadRemoveTailTest() throws Exception |
| { |
| initTestModel(); |
| |
| CDOSession session = openSessionWithAdditionsMode(); |
| CDOTransaction thisTransaction = session.openTransaction(); |
| CDOTransaction thatTransaction = session.openTransaction(); |
| addConflictResolver(thatTransaction); |
| |
| // Access objects. |
| Root thisRoot = getTestModelRoot(thisTransaction); |
| Root thatRoot = thatTransaction.getObject(thisRoot); |
| |
| // Attach adapters. |
| thisRoot.eAdapters().add(new ListPrintingAdapter("This root: ")); |
| thatRoot.eAdapters().add(new ListPrintingAdapter("That root: ")); |
| |
| // Remove object (get it before deletion). |
| BaseObject thisRemoveObject1 = thisRoot.getListA().get(0); |
| BaseObject thatRemoveObject1 = thatTransaction.getObject(thisRemoveObject1); |
| |
| thisRoot.getListA().remove(0); |
| BaseObject thisAfterRemoveObject1 = thisRoot.getListA().get(0); |
| |
| // // Remove object (get it before deletion). |
| BaseObject thatRemoveObject2 = thatRoot.getListA().get(thatRoot.getListA().size() - 1); |
| BaseObject thisRemoveObject2 = thisTransaction.getObject(thatRemoveObject2); |
| |
| thatRoot.getListA().remove(thatRoot.getListA().size() - 1); |
| BaseObject thatAfterRemoveObject2 = thatRoot.getListA().get(thatRoot.getListA().size() - 1); |
| |
| commitAndSync(thisTransaction, thatTransaction); |
| commitAndSync(thatTransaction, thisTransaction); |
| |
| // Print contents of lists |
| printList("This ", thisRoot.getListA()); |
| printList("That ", thatRoot.getListA()); |
| |
| // Check indices. |
| int listSize = thisRoot.getListA().size(); |
| assertEquals(false, thisTransaction.isDirty()); |
| assertEquals(false, thatTransaction.isDirty()); |
| assertEquals(thisAfterRemoveObject1, thisRoot.getListA().get(0)); |
| assertEquals(thatTransaction.getObject(thisAfterRemoveObject1), thatRoot.getListA().get(0)); |
| assertEquals(thisTransaction.getObject(thatAfterRemoveObject2), thisRoot.getListA().get(listSize - 1)); |
| assertEquals(thatAfterRemoveObject2, thatRoot.getListA().get(listSize - 1)); |
| assertEquals(CDOState.TRANSIENT, CDOUtil.getCDOObject(thisRemoveObject1).cdoState()); |
| assertEquals(CDOState.INVALID, CDOUtil.getCDOObject(thatRemoveObject1).cdoState()); |
| assertEquals(CDOState.INVALID, CDOUtil.getCDOObject(thisRemoveObject2).cdoState()); |
| assertEquals(CDOState.TRANSIENT, CDOUtil.getCDOObject(thatRemoveObject2).cdoState()); |
| } |
| |
| public void testRemoveTailRemoveHeadTest() throws Exception |
| { |
| initTestModel(); |
| |
| CDOSession session = openSessionWithAdditionsMode(); |
| CDOTransaction thisTransaction = session.openTransaction(); |
| CDOTransaction thatTransaction = session.openTransaction(); |
| addConflictResolver(thatTransaction); |
| |
| // Access objects. |
| Root thisRoot = getTestModelRoot(thisTransaction); |
| Root thatRoot = thatTransaction.getObject(thisRoot); |
| |
| // Attach adapters. |
| thisRoot.eAdapters().add(new ListPrintingAdapter("This root: ")); |
| thatRoot.eAdapters().add(new ListPrintingAdapter("That root: ")); |
| |
| // Remove object (get it before deletion). |
| BaseObject thisRemoveObject1 = thisRoot.getListA().get(thisRoot.getListA().size() - 1); |
| BaseObject thatRemoveObject1 = thatTransaction.getObject(thisRemoveObject1); |
| |
| thisRoot.getListA().remove(thisRoot.getListA().size() - 1); |
| BaseObject thisAfterRemoveObject1 = thisRoot.getListA().get(thisRoot.getListA().size() - 1); |
| |
| // // Remove object (get it before deletion). |
| BaseObject thatRemoveObject2 = thatRoot.getListA().get(0); |
| BaseObject thisRemoveObject2 = thisTransaction.getObject(thatRemoveObject2); |
| |
| thatRoot.getListA().remove(0); |
| BaseObject thatAfterRemoveObject2 = thatRoot.getListA().get(0); |
| |
| commitAndSync(thisTransaction, thatTransaction); |
| commitAndSync(thatTransaction, thisTransaction); |
| |
| // Print contents of lists |
| printList("This ", thisRoot.getListA()); |
| printList("That ", thatRoot.getListA()); |
| |
| // Check indices. |
| int listSize = thisRoot.getListA().size(); |
| assertEquals(false, thisTransaction.isDirty()); |
| assertEquals(false, thatTransaction.isDirty()); |
| assertEquals(thisAfterRemoveObject1, thisRoot.getListA().get(listSize - 1)); |
| assertEquals(thatTransaction.getObject(thisAfterRemoveObject1), thatRoot.getListA().get(listSize - 1)); |
| assertEquals(thisTransaction.getObject(thatAfterRemoveObject2), thisRoot.getListA().get(0)); |
| assertEquals(thatAfterRemoveObject2, thatRoot.getListA().get(0)); |
| assertEquals(CDOState.TRANSIENT, CDOUtil.getCDOObject(thisRemoveObject1).cdoState()); |
| assertEquals(CDOState.INVALID, CDOUtil.getCDOObject(thatRemoveObject1).cdoState()); |
| assertEquals(CDOState.INVALID, CDOUtil.getCDOObject(thisRemoveObject2).cdoState()); |
| assertEquals(CDOState.TRANSIENT, CDOUtil.getCDOObject(thatRemoveObject2).cdoState()); |
| } |
| |
| public void testRemoveTailRemoveTailTest() throws Exception |
| { |
| initTestModel(); |
| |
| CDOSession session = openSessionWithAdditionsMode(); |
| CDOTransaction thisTransaction = session.openTransaction(); |
| CDOTransaction thatTransaction = session.openTransaction(); |
| addConflictResolver(thatTransaction); |
| |
| // Access objects. |
| Root thisRoot = getTestModelRoot(thisTransaction); |
| Root thatRoot = thatTransaction.getObject(thisRoot); |
| |
| // Attach adapters. |
| thisRoot.eAdapters().add(new ListPrintingAdapter("This root: ")); |
| thatRoot.eAdapters().add(new ListPrintingAdapter("That root: ")); |
| |
| // Remove object (get it before deletion). |
| BaseObject thisRemoveObject1 = thisRoot.getListA().get(thisRoot.getListA().size() - 1); |
| BaseObject thatRemoveObject1 = thatTransaction.getObject(thisRemoveObject1); |
| |
| thisRoot.getListA().remove(thisRoot.getListA().size() - 1); |
| BaseObject thisAfterRemoveObject1 = thisRoot.getListA().get(thisRoot.getListA().size() - 1); |
| |
| // // Remove object (get it before deletion). |
| BaseObject thatRemoveObject2 = thatRoot.getListA().get(thatRoot.getListA().size() - 1); |
| BaseObject thisRemoveObject2 = thisTransaction.getObject(thatRemoveObject2); |
| |
| thatRoot.getListA().remove(thatRoot.getListA().size() - 1); |
| BaseObject thatAfterRemoveObject2 = thatRoot.getListA().get(thatRoot.getListA().size() - 1); |
| |
| commitAndSync(thisTransaction, thatTransaction); |
| commitAndSync(thatTransaction, thisTransaction); |
| |
| // Print contents of lists |
| printList("This ", thisRoot.getListA()); |
| printList("That ", thatRoot.getListA()); |
| |
| // Check indices. |
| int listSize = thisRoot.getListA().size(); |
| assertEquals(false, thisTransaction.isDirty()); |
| assertEquals(false, thatTransaction.isDirty()); |
| assertEquals(thisAfterRemoveObject1, thisRoot.getListA().get(listSize - 1)); |
| assertEquals(thatTransaction.getObject(thisAfterRemoveObject1), thatRoot.getListA().get(listSize - 1)); |
| assertEquals(thisTransaction.getObject(thatAfterRemoveObject2), thisRoot.getListA().get(listSize - 1)); |
| assertEquals(thatAfterRemoveObject2, thatRoot.getListA().get(listSize - 1)); |
| assertEquals(CDOState.TRANSIENT, CDOUtil.getCDOObject(thisRemoveObject1).cdoState()); |
| assertEquals(CDOState.TRANSIENT, CDOUtil.getCDOObject(thatRemoveObject1).cdoState()); |
| assertEquals(CDOState.TRANSIENT, CDOUtil.getCDOObject(thisRemoveObject2).cdoState()); |
| assertEquals(CDOState.TRANSIENT, CDOUtil.getCDOObject(thatRemoveObject2).cdoState()); |
| } |
| |
| public void testRemoveHeadMoveHeadTest() throws Exception |
| { |
| initTestModel(); |
| |
| CDOSession session = openSessionWithAdditionsMode(); |
| CDOTransaction thisTransaction = session.openTransaction(); |
| CDOTransaction thatTransaction = session.openTransaction(); |
| addConflictResolver(thatTransaction); |
| |
| Root thisRoot = getTestModelRoot(thisTransaction); |
| EList<BaseObject> thisList = thisRoot.getListA(); |
| |
| Root thatRoot = thatTransaction.getObject(thisRoot); |
| EList<BaseObject> thatList = thatRoot.getListA(); |
| |
| // Attach adapters |
| thisRoot.eAdapters().add(new ListPrintingAdapter("This root: ")); |
| thatRoot.eAdapters().add(new ListPrintingAdapter("That root: ")); |
| |
| // Remove first element (get it before deletion) |
| BaseObject thisRemoveObject = thisList.get(0); |
| BaseObject thatRemoveObject = thatTransaction.getObject(thisRemoveObject); |
| |
| thisList.remove(0); |
| BaseObject thisAfterRemoveObject = thisList.get(0); |
| |
| // Move first element |
| BaseObject thatMoveObject = thatList.get(0); |
| thatList.move(thatList.size() - 1, 0); |
| BaseObject thatAfterMoveObject = thatList.get(0); |
| |
| commitAndSync(thisTransaction, thatTransaction); |
| commitAndSync(thatTransaction, thisTransaction); |
| |
| // Print contents of lists |
| printList("This ", thisList); |
| printList("That ", thatList); |
| |
| // Check indices |
| assertEquals(false, thisTransaction.isDirty()); |
| assertEquals(false, thatTransaction.isDirty()); |
| assertEquals(thisAfterRemoveObject, thisList.get(0)); |
| assertEquals(thatTransaction.getObject(thisAfterRemoveObject), thatList.get(0)); |
| assertEquals(thisTransaction.getObject(thatAfterMoveObject), thisList.get(0)); |
| assertEquals(thatAfterMoveObject, thatList.get(0)); |
| assertEquals(CDOState.TRANSIENT, CDOUtil.getCDOObject(thisRemoveObject).cdoState()); |
| assertEquals(CDOState.INVALID, CDOUtil.getCDOObject(thatRemoveObject).cdoState()); |
| assertEquals(CDOState.INVALID, CDOUtil.getCDOObject(thatMoveObject).cdoState()); |
| } |
| |
| public void testRemoveHeadMoveTailTest() throws Exception |
| { |
| initTestModel(); |
| |
| CDOSession session = openSessionWithAdditionsMode(); |
| CDOTransaction thisTransaction = session.openTransaction(); |
| CDOTransaction thatTransaction = session.openTransaction(); |
| addConflictResolver(thatTransaction); |
| |
| // Access objects. |
| Root thisRoot = getTestModelRoot(thisTransaction); |
| Root thatRoot = thatTransaction.getObject(thisRoot); |
| |
| // Attach adapters. |
| thisRoot.eAdapters().add(new ListPrintingAdapter("This root: ")); |
| thatRoot.eAdapters().add(new ListPrintingAdapter("That root: ")); |
| |
| // Remove object (get it before deletion). |
| BaseObject thisRemoveObject = thisRoot.getListA().get(0); |
| BaseObject thatRemoveObject = thatTransaction.getObject(thisRemoveObject); |
| |
| thisRoot.getListA().remove(0); |
| BaseObject thisAfterRemoveObject = thisRoot.getListA().get(0); |
| |
| // Move object. |
| BaseObject thatMoveObject = thatRoot.getListA().get(thatRoot.getListA().size() - 1); |
| thatRoot.getListA().move(0, thatRoot.getListA().size() - 1); |
| BaseObject thatAfterMoveObject = thatRoot.getListA().get(thatRoot.getListA().size() - 1); |
| |
| commitAndSync(thisTransaction, thatTransaction); |
| commitAndSync(thatTransaction, thisTransaction); |
| |
| // Print contents of lists |
| printList("This ", thisRoot.getListA()); |
| printList("That ", thatRoot.getListA()); |
| |
| // Check indices. |
| int listSize = thisRoot.getListA().size(); |
| assertEquals(false, thisTransaction.isDirty()); |
| assertEquals(false, thatTransaction.isDirty()); |
| assertEquals(thisAfterRemoveObject, thisRoot.getListA().get(1)); |
| assertEquals(thatTransaction.getObject(thisAfterRemoveObject), thatRoot.getListA().get(1)); |
| assertEquals(thisTransaction.getObject(thatMoveObject), thisRoot.getListA().get(0)); |
| assertEquals(thatMoveObject, thatRoot.getListA().get(0)); |
| assertEquals(thisTransaction.getObject(thatAfterMoveObject), thisRoot.getListA().get(listSize - 1)); |
| assertEquals(thatAfterMoveObject, thatRoot.getListA().get(listSize - 1)); |
| assertEquals(CDOState.TRANSIENT, CDOUtil.getCDOObject(thisRemoveObject).cdoState()); |
| assertEquals(CDOState.INVALID, CDOUtil.getCDOObject(thatRemoveObject).cdoState()); |
| } |
| |
| public void testRemoveTailMoveHeadTest() throws Exception |
| { |
| initTestModel(); |
| |
| CDOSession session = openSessionWithAdditionsMode(); |
| CDOTransaction thisTransaction = session.openTransaction(); |
| CDOTransaction thatTransaction = session.openTransaction(); |
| addConflictResolver(thatTransaction); |
| |
| // Access objects. |
| Root thisRoot = getTestModelRoot(thisTransaction); |
| Root thatRoot = thatTransaction.getObject(thisRoot); |
| |
| // Attach adapters. |
| thisRoot.eAdapters().add(new ListPrintingAdapter("This root: ")); |
| thatRoot.eAdapters().add(new ListPrintingAdapter("That root: ")); |
| |
| // Remove object (get it before deletion). |
| BaseObject thisRemoveObject = thisRoot.getListA().get(thisRoot.getListA().size() - 1); |
| BaseObject thatRemoveObject = thatTransaction.getObject(thisRemoveObject); |
| |
| thisRoot.getListA().remove(thisRoot.getListA().size() - 1); |
| BaseObject thisAfterRemoveObject = thisRoot.getListA().get(thisRoot.getListA().size() - 1); |
| |
| // Move object. |
| BaseObject thatMoveObject = thatRoot.getListA().get(0); |
| thatRoot.getListA().move(thatRoot.getListA().size() - 1, 0); |
| BaseObject thatAfterMoveObject = thatRoot.getListA().get(0); |
| |
| commitAndSync(thisTransaction, thatTransaction); |
| commitAndSync(thatTransaction, thisTransaction); |
| |
| // Print contents of lists |
| printList("This ", thisRoot.getListA()); |
| printList("That ", thatRoot.getListA()); |
| |
| // Check indices. |
| int listSize = thisRoot.getListA().size(); |
| assertEquals(false, thisTransaction.isDirty()); |
| assertEquals(false, thatTransaction.isDirty()); |
| assertEquals(thisAfterRemoveObject, thisRoot.getListA().get(listSize - 2)); |
| assertEquals(thatTransaction.getObject(thisAfterRemoveObject), thatRoot.getListA().get(listSize - 2)); |
| assertEquals(thisTransaction.getObject(thatMoveObject), thisRoot.getListA().get(listSize - 1)); |
| assertEquals(thatMoveObject, thatRoot.getListA().get(listSize - 1)); |
| assertEquals(thisTransaction.getObject(thatAfterMoveObject), thisRoot.getListA().get(0)); |
| assertEquals(thatAfterMoveObject, thatRoot.getListA().get(0)); |
| assertEquals(CDOState.TRANSIENT, CDOUtil.getCDOObject(thisRemoveObject).cdoState()); |
| assertEquals(CDOState.INVALID, CDOUtil.getCDOObject(thatRemoveObject).cdoState()); |
| } |
| |
| public void testRemoveTailMoveTailTest() throws Exception |
| { |
| initTestModel(); |
| |
| CDOSession session = openSessionWithAdditionsMode(); |
| CDOTransaction thisTransaction = session.openTransaction(); |
| CDOTransaction thatTransaction = session.openTransaction(); |
| addConflictResolver(thatTransaction); |
| |
| // Access objects. |
| Root thisRoot = getTestModelRoot(thisTransaction); |
| Root thatRoot = thatTransaction.getObject(thisRoot); |
| |
| // Attach adapters. |
| thisRoot.eAdapters().add(new ListPrintingAdapter("This root: ")); |
| thatRoot.eAdapters().add(new ListPrintingAdapter("That root: ")); |
| |
| // Remove object (get it before deletion). |
| BaseObject thisRemoveObject = thisRoot.getListA().get(thisRoot.getListA().size() - 1); |
| BaseObject thatRemoveObject = thatTransaction.getObject(thisRemoveObject); |
| |
| thisRoot.getListA().remove(thisRoot.getListA().size() - 1); |
| BaseObject thisAfterRemoveObject = thisRoot.getListA().get(thisRoot.getListA().size() - 1); |
| |
| // Move object. |
| BaseObject thatMoveObject = thatRoot.getListA().get(thatRoot.getListA().size() - 1); |
| thatRoot.getListA().move(0, thatRoot.getListA().size() - 1); |
| BaseObject thatAfterMoveObject = thatRoot.getListA().get(thatRoot.getListA().size() - 1); |
| |
| commitAndSync(thisTransaction, thatTransaction); |
| commitAndSync(thatTransaction, thisTransaction); |
| |
| // Print contents of lists |
| printList("This ", thisRoot.getListA()); |
| printList("That ", thatRoot.getListA()); |
| |
| // Check indices. |
| int listSize = thisRoot.getListA().size(); |
| assertEquals(false, thisTransaction.isDirty()); |
| assertEquals(false, thatTransaction.isDirty()); |
| assertEquals(thisAfterRemoveObject, thisRoot.getListA().get(listSize - 1)); |
| assertEquals(thatTransaction.getObject(thisAfterRemoveObject), thatRoot.getListA().get(listSize - 1)); |
| assertEquals(thisTransaction.getObject(thatAfterMoveObject), thisRoot.getListA().get(listSize - 1)); |
| assertEquals(thatAfterMoveObject, thatRoot.getListA().get(listSize - 1)); |
| assertEquals(CDOState.TRANSIENT, CDOUtil.getCDOObject(thisRemoveObject).cdoState()); |
| assertEquals(CDOState.INVALID, CDOUtil.getCDOObject(thatRemoveObject).cdoState()); |
| assertEquals(CDOState.INVALID, CDOUtil.getCDOObject(thatMoveObject).cdoState()); |
| } |
| |
| public void testRemoveHeadClearTest() throws Exception |
| { |
| initTestModel(); |
| |
| CDOSession session = openSessionWithAdditionsMode(); |
| CDOTransaction thisTransaction = session.openTransaction(); |
| CDOTransaction thatTransaction = session.openTransaction(); |
| addConflictResolver(thatTransaction); |
| |
| // Access objects. |
| Root thisRoot = getTestModelRoot(thisTransaction); |
| Root thatRoot = thatTransaction.getObject(thisRoot); |
| |
| // Access lists. |
| EList<BaseObject> thisListA = thisRoot.getListA(); |
| EList<BaseObject> thatListA = thatRoot.getListA(); |
| |
| // Attach adapters. |
| thisRoot.eAdapters().add(new ListPrintingAdapter("This root: ")); |
| thatRoot.eAdapters().add(new ListPrintingAdapter("That root: ")); |
| |
| // Remove object (get it before deletion). |
| BaseObject thisRemoveObject = thisListA.get(0); |
| BaseObject thatRemoveObject = thatTransaction.getObject(thisRemoveObject); |
| |
| thisListA.remove(0); |
| BaseObject thisAfterRemoveObject = thisListA.get(0); |
| |
| // Clear. |
| thatListA.clear(); |
| |
| commitAndSync(thisTransaction, thatTransaction); |
| commitAndSync(thatTransaction, thisTransaction); |
| |
| // Print contents of lists |
| printList("This ", thisListA); |
| printList("That ", thatListA); |
| |
| // Check indices. |
| assertEquals(false, thisTransaction.isDirty()); |
| assertEquals(false, thatTransaction.isDirty()); |
| assertEquals(0, thisListA.size()); |
| assertEquals(0, thatListA.size()); |
| assertEquals(CDOState.TRANSIENT, CDOUtil.getCDOObject(thisRemoveObject).cdoState()); |
| assertEquals(CDOState.TRANSIENT, CDOUtil.getCDOObject(thatRemoveObject).cdoState()); |
| assertEquals(CDOState.INVALID, CDOUtil.getCDOObject(thisAfterRemoveObject).cdoState()); |
| } |
| |
| public void testRemoveTailClearTest() throws Exception |
| { |
| initTestModel(); |
| |
| CDOSession session = openSessionWithAdditionsMode(); |
| CDOTransaction thisTransaction = session.openTransaction(); |
| CDOTransaction thatTransaction = session.openTransaction(); |
| addConflictResolver(thatTransaction); |
| |
| // Access objects. |
| Root thisRoot = getTestModelRoot(thisTransaction); |
| Root thatRoot = thatTransaction.getObject(thisRoot); |
| |
| // Attach adapters. |
| thisRoot.eAdapters().add(new ListPrintingAdapter("This root: ")); |
| thatRoot.eAdapters().add(new ListPrintingAdapter("That root: ")); |
| |
| // Remove object (get it before deletion). |
| BaseObject thisRemoveObject = thisRoot.getListA().get(thisRoot.getListA().size() - 1); |
| BaseObject thatRemoveObject = thatTransaction.getObject(thisRemoveObject); |
| |
| thisRoot.getListA().remove(thisRoot.getListA().size() - 1); |
| BaseObject thisAfterRemoveObject = thisRoot.getListA().get(thisRoot.getListA().size() - 1); |
| |
| // Clear. |
| thatRoot.getListA().clear(); |
| |
| commitAndSync(thisTransaction, thatTransaction); |
| commitAndSync(thatTransaction, thisTransaction); |
| |
| // Print contents of lists |
| printList("This ", thisRoot.getListA()); |
| printList("That ", thatRoot.getListA()); |
| |
| // Check indices. |
| assertEquals(false, thisTransaction.isDirty()); |
| assertEquals(false, thatTransaction.isDirty()); |
| assertEquals(0, thisRoot.getListA().size()); |
| assertEquals(0, thatRoot.getListA().size()); |
| assertEquals(CDOState.TRANSIENT, CDOUtil.getCDOObject(thisRemoveObject).cdoState()); |
| assertEquals(CDOState.TRANSIENT, CDOUtil.getCDOObject(thatRemoveObject).cdoState()); |
| assertEquals(CDOState.INVALID, CDOUtil.getCDOObject(thisAfterRemoveObject).cdoState()); |
| } |
| |
| public void testMoveHeadAddHeadTest() throws Exception |
| { |
| initTestModel(); |
| |
| CDOSession session = openSessionWithAdditionsMode(); |
| CDOTransaction thisTransaction = session.openTransaction(); |
| CDOTransaction thatTransaction = session.openTransaction(); |
| addConflictResolver(thatTransaction); |
| |
| // Access objects. |
| Root thisRoot = getTestModelRoot(thisTransaction); |
| Root thatRoot = thatTransaction.getObject(thisRoot); |
| |
| // Attach adapters. |
| thisRoot.eAdapters().add(new ListPrintingAdapter("This root: ")); |
| thatRoot.eAdapters().add(new ListPrintingAdapter("That root: ")); |
| |
| // Move object. |
| BaseObject thisMoveObject = thisRoot.getListA().get(0); |
| thisRoot.getListA().move(thisRoot.getListA().size() - 1, 0); |
| BaseObject thisAfterMoveObject = thisRoot.getListA().get(0); |
| |
| // Create object. |
| BaseObject thatObject = createBaseObject("ThatBaseObject 0"); |
| thatRoot.getListA().add(0, thatObject); |
| |
| commitAndSync(thisTransaction, thatTransaction); |
| commitAndSync(thatTransaction, thisTransaction); |
| |
| // Print contents of lists |
| printList("This ", thisRoot.getListA()); |
| printList("That ", thatRoot.getListA()); |
| |
| // Check indices. |
| int size = thisRoot.getListA().size(); |
| assertEquals(false, thisTransaction.isDirty()); |
| assertEquals(false, thatTransaction.isDirty()); |
| assertEquals(thisTransaction.getObject(thatObject), thisRoot.getListA().get(0)); |
| assertEquals(thatObject, thatRoot.getListA().get(0)); |
| assertEquals(thisAfterMoveObject, thisRoot.getListA().get(1)); |
| assertEquals(thatTransaction.getObject(thisAfterMoveObject), thatRoot.getListA().get(1)); |
| assertEquals(thisMoveObject, thisRoot.getListA().get(size - 1)); |
| assertEquals(thatTransaction.getObject(thisMoveObject), thatRoot.getListA().get(size - 1)); |
| } |
| |
| public void testMoveHeadAddTailTest() throws Exception |
| { |
| initTestModel(); |
| |
| CDOSession session = openSessionWithAdditionsMode(); |
| CDOTransaction thisTransaction = session.openTransaction(); |
| CDOTransaction thatTransaction = session.openTransaction(); |
| addConflictResolver(thatTransaction); |
| |
| // Access objects. |
| Root thisRoot = getTestModelRoot(thisTransaction); |
| Root thatRoot = thatTransaction.getObject(thisRoot); |
| |
| // Attach adapters. |
| thisRoot.eAdapters().add(new ListPrintingAdapter("This root: ")); |
| thatRoot.eAdapters().add(new ListPrintingAdapter("That root: ")); |
| |
| // Move object. |
| BaseObject thisMoveObject = thisRoot.getListA().get(0); |
| thisRoot.getListA().move(thisRoot.getListA().size() - 1, 0); |
| BaseObject thisAfterMoveObject = thisRoot.getListA().get(0); |
| |
| // Create object. |
| BaseObject thatObject = createBaseObject("ThatBaseObject 0"); |
| thatRoot.getListA().add(thatObject); |
| |
| commitAndSync(thisTransaction, thatTransaction); |
| commitAndSync(thatTransaction, thisTransaction); |
| |
| // Print contents of lists |
| printList("This ", thisRoot.getListA()); |
| printList("That ", thatRoot.getListA()); |
| |
| // Check indices. |
| int size = thisRoot.getListA().size(); |
| assertEquals(false, thisTransaction.isDirty()); |
| assertEquals(false, thatTransaction.isDirty()); |
| assertEquals(thisTransaction.getObject(thatObject), thisRoot.getListA().get(size - 1)); |
| assertEquals(thatObject, thatRoot.getListA().get(size - 1)); |
| assertEquals(thisAfterMoveObject, thisRoot.getListA().get(0)); |
| assertEquals(thatTransaction.getObject(thisAfterMoveObject), thatRoot.getListA().get(0)); |
| assertEquals(thisMoveObject, thisRoot.getListA().get(size - 2)); |
| assertEquals(thatTransaction.getObject(thisMoveObject), thatRoot.getListA().get(size - 2)); |
| } |
| |
| public void testMoveTailAddHeadTest() throws Exception |
| { |
| initTestModel(); |
| |
| CDOSession session = openSessionWithAdditionsMode(); |
| CDOTransaction thisTransaction = session.openTransaction(); |
| CDOTransaction thatTransaction = session.openTransaction(); |
| addConflictResolver(thatTransaction); |
| |
| // Access objects. |
| Root thisRoot = getTestModelRoot(thisTransaction); |
| Root thatRoot = thatTransaction.getObject(thisRoot); |
| |
| // Attach adapters. |
| thisRoot.eAdapters().add(new ListPrintingAdapter("This root: ")); |
| thatRoot.eAdapters().add(new ListPrintingAdapter("That root: ")); |
| |
| // Move object. |
| BaseObject thisMoveObject = thisRoot.getListA().get(thisRoot.getListA().size() - 1); |
| thisRoot.getListA().move(0, thisRoot.getListA().size() - 1); |
| BaseObject thisAfterMoveObject = thisRoot.getListA().get(thisRoot.getListA().size() - 1); |
| |
| // Create object. |
| BaseObject thatObject = createBaseObject("ThatBaseObject 0"); |
| thatRoot.getListA().add(0, thatObject); |
| |
| commitAndSync(thisTransaction, thatTransaction); |
| commitAndSync(thatTransaction, thisTransaction); |
| |
| // Print contents of lists |
| printList("This ", thisRoot.getListA()); |
| printList("That ", thatRoot.getListA()); |
| |
| // Check indices. |
| int size = thisRoot.getListA().size(); |
| assertEquals(false, thisTransaction.isDirty()); |
| assertEquals(false, thatTransaction.isDirty()); |
| assertEquals(thisTransaction.getObject(thatObject), thisRoot.getListA().get(0)); |
| assertEquals(thatObject, thatRoot.getListA().get(0)); |
| assertEquals(thisAfterMoveObject, thisRoot.getListA().get(size - 1)); |
| assertEquals(thatTransaction.getObject(thisAfterMoveObject), thatRoot.getListA().get(size - 1)); |
| assertEquals(thisMoveObject, thisRoot.getListA().get(1)); |
| assertEquals(thatTransaction.getObject(thisMoveObject), thatRoot.getListA().get(1)); |
| } |
| |
| public void testMoveTailAddTailTest() throws Exception |
| { |
| initTestModel(); |
| |
| CDOSession session = openSessionWithAdditionsMode(); |
| CDOTransaction thisTransaction = session.openTransaction(); |
| CDOTransaction thatTransaction = session.openTransaction(); |
| addConflictResolver(thatTransaction); |
| |
| // Access objects. |
| Root thisRoot = getTestModelRoot(thisTransaction); |
| Root thatRoot = thatTransaction.getObject(thisRoot); |
| |
| // Attach adapters. |
| thisRoot.eAdapters().add(new ListPrintingAdapter("This root: ")); |
| thatRoot.eAdapters().add(new ListPrintingAdapter("That root: ")); |
| |
| // Move object. |
| BaseObject thisMoveObject = thisRoot.getListA().get(thisRoot.getListA().size() - 1); |
| thisRoot.getListA().move(0, thisRoot.getListA().size() - 1); |
| BaseObject thisAfterMoveObject = thisRoot.getListA().get(thisRoot.getListA().size() - 1); |
| |
| // Create object. |
| BaseObject thatObject = createBaseObject("ThatBaseObject 0"); |
| thatRoot.getListA().add(thatObject); |
| |
| commitAndSync(thisTransaction, thatTransaction); |
| commitAndSync(thatTransaction, thisTransaction); |
| |
| // Print contents of lists |
| printList("This ", thisRoot.getListA()); |
| printList("That ", thatRoot.getListA()); |
| |
| // Check indices. |
| int size = thisRoot.getListA().size(); |
| assertEquals(false, thisTransaction.isDirty()); |
| assertEquals(false, thatTransaction.isDirty()); |
| assertEquals(thisTransaction.getObject(thatObject), thisRoot.getListA().get(size - 1)); |
| assertEquals(thatObject, thatRoot.getListA().get(size - 1)); |
| assertEquals(thisAfterMoveObject, thisRoot.getListA().get(size - 2)); |
| assertEquals(thatTransaction.getObject(thisAfterMoveObject), thatRoot.getListA().get(size - 2)); |
| assertEquals(thisMoveObject, thisRoot.getListA().get(0)); |
| assertEquals(thatTransaction.getObject(thisMoveObject), thatRoot.getListA().get(0)); |
| } |
| |
| public void testMoveHeadRemoveHeadTest() throws Exception |
| { |
| initTestModel(); |
| |
| CDOSession session = openSessionWithAdditionsMode(); |
| CDOTransaction thisTransaction = session.openTransaction(); |
| CDOTransaction thatTransaction = session.openTransaction(); |
| addConflictResolver(thatTransaction); |
| |
| // Access objects. |
| Root thisRoot = getTestModelRoot(thisTransaction); |
| Root thatRoot = thatTransaction.getObject(thisRoot); |
| |
| // Attach adapters. |
| thisRoot.eAdapters().add(new ListPrintingAdapter("This root: ")); |
| thatRoot.eAdapters().add(new ListPrintingAdapter("That root: ")); |
| |
| // Move object. |
| BaseObject thisMoveObject = thisRoot.getListA().get(0); |
| thisRoot.getListA().move(thisRoot.getListA().size() - 1, 0); |
| BaseObject thisAfterMoveObject = thisRoot.getListA().get(0); |
| |
| // Remove object. |
| BaseObject thatRemoveObject = thatRoot.getListA().get(0); |
| BaseObject thisRemoveObject = thisTransaction.getObject(thatRemoveObject); |
| thatRoot.getListA().remove(0); |
| BaseObject thatAfterRemoveObject = thatRoot.getListA().get(0); |
| |
| commitAndSync(thisTransaction, thatTransaction); |
| commitAndSync(thatTransaction, thisTransaction); |
| |
| // Print contents of lists |
| printList("This ", thisRoot.getListA()); |
| printList("That ", thatRoot.getListA()); |
| |
| // Check indices. |
| assertEquals(false, thisTransaction.isDirty()); |
| assertEquals(false, thatTransaction.isDirty()); |
| assertEquals(thisAfterMoveObject, thisRoot.getListA().get(0)); |
| assertEquals(thatTransaction.getObject(thisAfterMoveObject), thatRoot.getListA().get(0)); |
| assertEquals(thisTransaction.getObject(thatAfterRemoveObject), thisRoot.getListA().get(0)); |
| assertEquals(thatAfterRemoveObject, thatRoot.getListA().get(0)); |
| assertEquals(CDOState.INVALID, CDOUtil.getCDOObject(thisRemoveObject).cdoState()); |
| assertEquals(CDOState.TRANSIENT, CDOUtil.getCDOObject(thatRemoveObject).cdoState()); |
| assertEquals(CDOState.INVALID, CDOUtil.getCDOObject(thisMoveObject).cdoState()); |
| } |
| |
| public void testMoveHeadRemoveTailTest() throws Exception |
| { |
| initTestModel(); |
| |
| CDOSession session = openSessionWithAdditionsMode(); |
| CDOTransaction thisTransaction = session.openTransaction(); |
| CDOTransaction thatTransaction = session.openTransaction(); |
| addConflictResolver(thatTransaction); |
| |
| // Access objects. |
| Root thisRoot = getTestModelRoot(thisTransaction); |
| Root thatRoot = thatTransaction.getObject(thisRoot); |
| |
| // Attach adapters. |
| thisRoot.eAdapters().add(new ListPrintingAdapter("This root: ")); |
| thatRoot.eAdapters().add(new ListPrintingAdapter("That root: ")); |
| |
| // Move object. |
| BaseObject thisMoveObject = thisRoot.getListA().get(0); |
| thisRoot.getListA().move(thisRoot.getListA().size() - 1, 0); |
| BaseObject thisAfterMoveObject = thisRoot.getListA().get(0); |
| |
| // Remove object. |
| BaseObject thatRemoveObject = thatRoot.getListA().get(thatRoot.getListA().size() - 1); |
| BaseObject thisRemoveObject = thisTransaction.getObject(thatRemoveObject); |
| thatRoot.getListA().remove(thatRoot.getListA().size() - 1); |
| BaseObject thatAfterRemoveObject = thatRoot.getListA().get(thatRoot.getListA().size() - 1); |
| |
| commitAndSync(thisTransaction, thatTransaction); |
| commitAndSync(thatTransaction, thisTransaction); |
| |
| // Print contents of lists |
| printList("This ", thisRoot.getListA()); |
| printList("That ", thatRoot.getListA()); |
| |
| // Check indices. |
| int size = thisRoot.getListA().size(); |
| assertEquals(false, thisTransaction.isDirty()); |
| assertEquals(false, thatTransaction.isDirty()); |
| assertEquals(thisAfterMoveObject, thisRoot.getListA().get(0)); |
| assertEquals(thatTransaction.getObject(thisAfterMoveObject), thatRoot.getListA().get(0)); |
| assertEquals(thisMoveObject, thisRoot.getListA().get(size - 1)); |
| assertEquals(thatTransaction.getObject(thisMoveObject), thatRoot.getListA().get(size - 1)); |
| assertEquals(thisTransaction.getObject(thatAfterRemoveObject), thisRoot.getListA().get(size - 2)); |
| assertEquals(thatAfterRemoveObject, thatRoot.getListA().get(size - 2)); |
| assertEquals(CDOState.INVALID, CDOUtil.getCDOObject(thisRemoveObject).cdoState()); |
| assertEquals(CDOState.TRANSIENT, CDOUtil.getCDOObject(thatRemoveObject).cdoState()); |
| } |
| |
| public void testMoveTailRemoveHeadTest() throws Exception |
| { |
| initTestModel(); |
| |
| CDOSession session = openSessionWithAdditionsMode(); |
| CDOTransaction thisTransaction = session.openTransaction(); |
| CDOTransaction thatTransaction = session.openTransaction(); |
| addConflictResolver(thatTransaction); |
| |
| // Access objects. |
| Root thisRoot = getTestModelRoot(thisTransaction); |
| Root thatRoot = thatTransaction.getObject(thisRoot); |
| |
| // Attach adapters. |
| thisRoot.eAdapters().add(new ListPrintingAdapter("This root: ")); |
| thatRoot.eAdapters().add(new ListPrintingAdapter("That root: ")); |
| |
| // Move object. |
| BaseObject thisMoveObject = thisRoot.getListA().get(thisRoot.getListA().size() - 1); |
| thisRoot.getListA().move(0, thisRoot.getListA().size() - 1); |
| BaseObject thisAfterMoveObject = thisRoot.getListA().get(thisRoot.getListA().size() - 1); |
| |
| // Remove object. |
| BaseObject thatRemoveObject = thatRoot.getListA().get(0); |
| BaseObject thisRemoveObject = thisTransaction.getObject(thatRemoveObject); |
| thatRoot.getListA().remove(0); |
| BaseObject thatAfterRemoveObject = thatRoot.getListA().get(0); |
| |
| commitAndSync(thisTransaction, thatTransaction); |
| commitAndSync(thatTransaction, thisTransaction); |
| |
| // Print contents of lists |
| printList("This ", thisRoot.getListA()); |
| printList("That ", thatRoot.getListA()); |
| |
| // Check indices. |
| int size = thisRoot.getListA().size(); |
| assertEquals(false, thisTransaction.isDirty()); |
| assertEquals(false, thatTransaction.isDirty()); |
| assertEquals(thisAfterMoveObject, thisRoot.getListA().get(size - 1)); |
| assertEquals(thatTransaction.getObject(thisAfterMoveObject), thatRoot.getListA().get(size - 1)); |
| assertEquals(thisMoveObject, thisRoot.getListA().get(0)); |
| assertEquals(thatTransaction.getObject(thisMoveObject), thatRoot.getListA().get(0)); |
| assertEquals(thisTransaction.getObject(thatAfterRemoveObject), thisRoot.getListA().get(1)); |
| assertEquals(thatAfterRemoveObject, thatRoot.getListA().get(1)); |
| assertEquals(CDOState.INVALID, CDOUtil.getCDOObject(thisRemoveObject).cdoState()); |
| assertEquals(CDOState.TRANSIENT, CDOUtil.getCDOObject(thatRemoveObject).cdoState()); |
| } |
| |
| public void testMoveTailRemoveTailTest() throws Exception |
| { |
| initTestModel(); |
| |
| CDOSession session = openSessionWithAdditionsMode(); |
| CDOTransaction thisTransaction = session.openTransaction(); |
| CDOTransaction thatTransaction = session.openTransaction(); |
| addConflictResolver(thatTransaction); |
| |
| // Access objects. |
| Root thisRoot = getTestModelRoot(thisTransaction); |
| Root thatRoot = thatTransaction.getObject(thisRoot); |
| |
| // Attach adapters. |
| thisRoot.eAdapters().add(new ListPrintingAdapter("This root: ")); |
| thatRoot.eAdapters().add(new ListPrintingAdapter("That root: ")); |
| |
| // Move object. |
| BaseObject thisMoveObject = thisRoot.getListA().get(thisRoot.getListA().size() - 1); |
| thisRoot.getListA().move(0, thisRoot.getListA().size() - 1); |
| BaseObject thisAfterMoveObject = thisRoot.getListA().get(thisRoot.getListA().size() - 1); |
| |
| // Remove object. |
| BaseObject thatRemoveObject = thatRoot.getListA().get(thatRoot.getListA().size() - 1); |
| BaseObject thisRemoveObject = thisTransaction.getObject(thatRemoveObject); |
| thatRoot.getListA().remove(thatRoot.getListA().size() - 1); |
| BaseObject thatAfterRemoveObject = thatRoot.getListA().get(thatRoot.getListA().size() - 1); |
| |
| commitAndSync(thisTransaction, thatTransaction); |
| commitAndSync(thatTransaction, thisTransaction); |
| |
| // Print contents of lists |
| printList("This ", thisRoot.getListA()); |
| printList("That ", thatRoot.getListA()); |
| |
| // Check indices. |
| int size = thisRoot.getListA().size(); |
| assertEquals(false, thisTransaction.isDirty()); |
| assertEquals(false, thatTransaction.isDirty()); |
| assertEquals(thisAfterMoveObject, thisRoot.getListA().get(size - 1)); |
| assertEquals(thatTransaction.getObject(thisAfterMoveObject), thatRoot.getListA().get(size - 1)); |
| assertEquals(thisTransaction.getObject(thatAfterRemoveObject), thisRoot.getListA().get(size - 1)); |
| assertEquals(thatAfterRemoveObject, thatRoot.getListA().get(size - 1)); |
| assertEquals(CDOState.INVALID, CDOUtil.getCDOObject(thisRemoveObject).cdoState()); |
| assertEquals(CDOState.TRANSIENT, CDOUtil.getCDOObject(thatRemoveObject).cdoState()); |
| assertEquals(CDOState.INVALID, CDOUtil.getCDOObject(thisMoveObject).cdoState()); |
| } |
| |
| public void testMoveHeadMoveHeadTest() throws Exception |
| { |
| initTestModel(); |
| |
| CDOSession session = openSessionWithAdditionsMode(); |
| CDOTransaction thisTransaction = session.openTransaction(); |
| CDOTransaction thatTransaction = session.openTransaction(); |
| addConflictResolver(thatTransaction); |
| |
| // Access objects. |
| Root thisRoot = getTestModelRoot(thisTransaction); |
| Root thatRoot = thatTransaction.getObject(thisRoot); |
| |
| // Attach adapters. |
| thisRoot.eAdapters().add(new ListPrintingAdapter("This root: ")); |
| thatRoot.eAdapters().add(new ListPrintingAdapter("That root: ")); |
| |
| // Move object. |
| BaseObject thisMoveObject1 = thisRoot.getListA().get(0); |
| BaseObject thatMoveObject1 = thatTransaction.getObject(thisMoveObject1); |
| thisRoot.getListA().move(thisRoot.getListA().size() - 1, 0); |
| BaseObject thisAfterMoveObject1 = thisRoot.getListA().get(0); |
| BaseObject thatAfterMoveObject1 = thatTransaction.getObject(thisAfterMoveObject1); |
| |
| // Move object. |
| BaseObject thatMoveObject2 = thatRoot.getListA().get(0); |
| BaseObject thisMoveObject2 = thisTransaction.getObject(thatMoveObject2); |
| thatRoot.getListA().move(thatRoot.getListA().size() - 1, 0); |
| BaseObject thatAfterMoveObject2 = thatRoot.getListA().get(0); |
| BaseObject thisAfterMoveObject2 = thisTransaction.getObject(thatAfterMoveObject2); |
| |
| commitAndSync(thisTransaction, thatTransaction); |
| commitAndSync(thatTransaction, thisTransaction); |
| |
| // Print contents of lists |
| printList("This ", thisRoot.getListA()); |
| printList("That ", thatRoot.getListA()); |
| |
| // Check indices. |
| int size = thisRoot.getListA().size(); |
| assertEquals(false, thisTransaction.isDirty()); |
| assertEquals(false, thatTransaction.isDirty()); |
| assertEquals(thisMoveObject1, thisRoot.getListA().get(size - 1)); |
| assertEquals(thatMoveObject1, thatRoot.getListA().get(size - 1)); |
| assertEquals(thisMoveObject2, thisRoot.getListA().get(size - 1)); |
| assertEquals(thatMoveObject2, thatRoot.getListA().get(size - 1)); |
| assertEquals(thisAfterMoveObject1, thisRoot.getListA().get(0)); |
| assertEquals(thatAfterMoveObject1, thatRoot.getListA().get(0)); |
| assertEquals(thisAfterMoveObject2, thisRoot.getListA().get(0)); |
| assertEquals(thatAfterMoveObject2, thatRoot.getListA().get(0)); |
| } |
| |
| public void testMoveHeadMoveTailTest() throws Exception |
| { |
| initTestModel(); |
| |
| CDOSession session = openSessionWithAdditionsMode(); |
| CDOTransaction thisTransaction = session.openTransaction(); |
| CDOTransaction thatTransaction = session.openTransaction(); |
| addConflictResolver(thatTransaction); |
| |
| // Access objects. |
| Root thisRoot = getTestModelRoot(thisTransaction); |
| Root thatRoot = thatTransaction.getObject(thisRoot); |
| |
| // Attach adapters. |
| thisRoot.eAdapters().add(new ListPrintingAdapter("This root: ")); |
| thatRoot.eAdapters().add(new ListPrintingAdapter("That root: ")); |
| |
| // Move object. |
| BaseObject thisMoveObject1 = thisRoot.getListA().get(0); |
| BaseObject thatMoveObject1 = thatTransaction.getObject(thisMoveObject1); |
| thisRoot.getListA().move(thisRoot.getListA().size() - 1, 0); |
| BaseObject thisAfterMoveObject1 = thisRoot.getListA().get(0); |
| BaseObject thatAfterMoveObject1 = thatTransaction.getObject(thisAfterMoveObject1); |
| |
| // Move object. |
| BaseObject thatMoveObject2 = thatRoot.getListA().get(thatRoot.getListA().size() - 1); |
| BaseObject thisMoveObject2 = thisTransaction.getObject(thatMoveObject2); |
| thatRoot.getListA().move(0, thatRoot.getListA().size() - 1); |
| BaseObject thatAfterMoveObject2 = thatRoot.getListA().get(thatRoot.getListA().size() - 1); |
| BaseObject thisAfterMoveObject2 = thisTransaction.getObject(thatAfterMoveObject2); |
| |
| commitAndSync(thisTransaction, thatTransaction); |
| commitAndSync(thatTransaction, thisTransaction); |
| |
| // Print contents of lists |
| printList("This ", thisRoot.getListA()); |
| printList("That ", thatRoot.getListA()); |
| |
| // Check indices. |
| int size = thisRoot.getListA().size(); |
| assertEquals(false, thisTransaction.isDirty()); |
| assertEquals(false, thatTransaction.isDirty()); |
| assertEquals(thisMoveObject1, thisRoot.getListA().get(size - 1)); |
| assertEquals(thatMoveObject1, thatRoot.getListA().get(size - 1)); |
| assertEquals(thisMoveObject2, thisRoot.getListA().get(0)); |
| assertEquals(thatMoveObject2, thatRoot.getListA().get(0)); |
| assertEquals(thisAfterMoveObject1, thisRoot.getListA().get(1)); |
| assertEquals(thatAfterMoveObject1, thatRoot.getListA().get(1)); |
| assertEquals(thisAfterMoveObject2, thisRoot.getListA().get(size - 2)); |
| assertEquals(thatAfterMoveObject2, thatRoot.getListA().get(size - 2)); |
| } |
| |
| public void testMoveTailMoveHeadTest() throws Exception |
| { |
| initTestModel(); |
| |
| CDOSession session = openSessionWithAdditionsMode(); |
| CDOTransaction thisTransaction = session.openTransaction(); |
| CDOTransaction thatTransaction = session.openTransaction(); |
| addConflictResolver(thatTransaction); |
| |
| // Access objects. |
| Root thisRoot = getTestModelRoot(thisTransaction); |
| Root thatRoot = thatTransaction.getObject(thisRoot); |
| |
| // Attach adapters. |
| thisRoot.eAdapters().add(new ListPrintingAdapter("This root: ")); |
| thatRoot.eAdapters().add(new ListPrintingAdapter("That root: ")); |
| |
| // Move object. |
| BaseObject thisMoveObject1 = thisRoot.getListA().get(thisRoot.getListA().size() - 1); |
| BaseObject thatMoveObject1 = thatTransaction.getObject(thisMoveObject1); |
| thisRoot.getListA().move(0, thisRoot.getListA().size() - 1); |
| BaseObject thisAfterMoveObject1 = thisRoot.getListA().get(thisRoot.getListA().size() - 1); |
| BaseObject thatAfterMoveObject1 = thatTransaction.getObject(thisAfterMoveObject1); |
| |
| // Move object. |
| BaseObject thatMoveObject2 = thatRoot.getListA().get(0); |
| BaseObject thisMoveObject2 = thisTransaction.getObject(thatMoveObject2); |
| thatRoot.getListA().move(thatRoot.getListA().size() - 1, 0); |
| BaseObject thatAfterMoveObject2 = thatRoot.getListA().get(0); |
| BaseObject thisAfterMoveObject2 = thisTransaction.getObject(thatAfterMoveObject2); |
| |
| commitAndSync(thisTransaction, thatTransaction); |
| commitAndSync(thatTransaction, thisTransaction); |
| |
| // Print contents of lists |
| printList("This ", thisRoot.getListA()); |
| printList("That ", thatRoot.getListA()); |
| |
| // Check indices. |
| int size = thisRoot.getListA().size(); |
| assertEquals(false, thisTransaction.isDirty()); |
| assertEquals(false, thatTransaction.isDirty()); |
| assertEquals(thisMoveObject1, thisRoot.getListA().get(0)); |
| assertEquals(thatMoveObject1, thatRoot.getListA().get(0)); |
| assertEquals(thisMoveObject2, thisRoot.getListA().get(size - 1)); |
| assertEquals(thatMoveObject2, thatRoot.getListA().get(size - 1)); |
| assertEquals(thisAfterMoveObject1, thisRoot.getListA().get(size - 2)); |
| assertEquals(thatAfterMoveObject1, thatRoot.getListA().get(size - 2)); |
| assertEquals(thisAfterMoveObject2, thisRoot.getListA().get(1)); |
| assertEquals(thatAfterMoveObject2, thatRoot.getListA().get(1)); |
| } |
| |
| public void testMoveTailMoveTailTest() throws Exception |
| { |
| initTestModel(); |
| |
| CDOSession session = openSessionWithAdditionsMode(); |
| CDOTransaction thisTransaction = session.openTransaction(); |
| CDOTransaction thatTransaction = session.openTransaction(); |
| addConflictResolver(thatTransaction); |
| |
| // Access objects. |
| Root thisRoot = getTestModelRoot(thisTransaction); |
| Root thatRoot = thatTransaction.getObject(thisRoot); |
| |
| // Attach adapters. |
| thisRoot.eAdapters().add(new ListPrintingAdapter("This root: ")); |
| thatRoot.eAdapters().add(new ListPrintingAdapter("That root: ")); |
| |
| // Move object. |
| BaseObject thisMoveObject1 = thisRoot.getListA().get(thisRoot.getListA().size() - 1); |
| BaseObject thatMoveObject1 = thatTransaction.getObject(thisMoveObject1); |
| thisRoot.getListA().move(0, thisRoot.getListA().size() - 1); |
| BaseObject thisAfterMoveObject1 = thisRoot.getListA().get(thisRoot.getListA().size() - 1); |
| BaseObject thatAfterMoveObject1 = thatTransaction.getObject(thisAfterMoveObject1); |
| |
| // Move object. |
| BaseObject thatMoveObject2 = thatRoot.getListA().get(thatRoot.getListA().size() - 1); |
| BaseObject thisMoveObject2 = thisTransaction.getObject(thatMoveObject2); |
| thatRoot.getListA().move(0, thatRoot.getListA().size() - 1); |
| BaseObject thatAfterMoveObject2 = thatRoot.getListA().get(thatRoot.getListA().size() - 1); |
| BaseObject thisAfterMoveObject2 = thisTransaction.getObject(thatAfterMoveObject2); |
| |
| commitAndSync(thisTransaction, thatTransaction); |
| commitAndSync(thatTransaction, thisTransaction); |
| |
| // Print contents of lists |
| printList("This ", thisRoot.getListA()); |
| printList("That ", thatRoot.getListA()); |
| |
| // Check indices. |
| int size = thisRoot.getListA().size(); |
| assertEquals(false, thisTransaction.isDirty()); |
| assertEquals(false, thatTransaction.isDirty()); |
| assertEquals(thisMoveObject1, thisRoot.getListA().get(0)); |
| assertEquals(thatMoveObject1, thatRoot.getListA().get(0)); |
| assertEquals(thisMoveObject2, thisRoot.getListA().get(0)); |
| assertEquals(thatMoveObject2, thatRoot.getListA().get(0)); |
| assertEquals(thisAfterMoveObject1, thisRoot.getListA().get(size - 1)); |
| assertEquals(thatAfterMoveObject1, thatRoot.getListA().get(size - 1)); |
| assertEquals(thisAfterMoveObject2, thisRoot.getListA().get(size - 1)); |
| assertEquals(thatAfterMoveObject2, thatRoot.getListA().get(size - 1)); |
| } |
| |
| public void testMoveHeadClearTest() throws Exception |
| { |
| initTestModel(); |
| |
| CDOSession session = openSessionWithAdditionsMode(); |
| CDOTransaction thisTransaction = session.openTransaction(); |
| CDOTransaction thatTransaction = session.openTransaction(); |
| addConflictResolver(thatTransaction); |
| |
| // Access objects. |
| Root thisRoot = getTestModelRoot(thisTransaction); |
| Root thatRoot = thatTransaction.getObject(thisRoot); |
| |
| // Attach adapters. |
| thisRoot.eAdapters().add(new ListPrintingAdapter("This root: ")); |
| thatRoot.eAdapters().add(new ListPrintingAdapter("That root: ")); |
| |
| // Move object. |
| BaseObject thisMoveObject = thisRoot.getListA().get(0); |
| BaseObject thatMoveObject = thatTransaction.getObject(thisMoveObject); |
| thisRoot.getListA().move(thisRoot.getListA().size() - 1, 0); |
| BaseObject thisAfterMoveObject = thisRoot.getListA().get(0); |
| BaseObject thatAfterMoveObject = thatTransaction.getObject(thisAfterMoveObject); |
| |
| // Clear. |
| thatRoot.getListA().clear(); |
| |
| commitAndSync(thisTransaction, thatTransaction); |
| commitAndSync(thatTransaction, thisTransaction); |
| |
| // Print contents of lists |
| printList("This ", thisRoot.getListA()); |
| printList("That ", thatRoot.getListA()); |
| |
| // Check indices. |
| assertEquals(false, thisTransaction.isDirty()); |
| assertEquals(false, thatTransaction.isDirty()); |
| assertEquals(0, thisRoot.getListA().size()); |
| assertEquals(0, thatRoot.getListA().size()); |
| assertEquals(CDOState.INVALID, CDOUtil.getCDOObject(thisMoveObject).cdoState()); |
| assertEquals(CDOState.INVALID, CDOUtil.getCDOObject(thisAfterMoveObject).cdoState()); |
| assertEquals(CDOState.TRANSIENT, CDOUtil.getCDOObject(thatMoveObject).cdoState()); |
| assertEquals(CDOState.TRANSIENT, CDOUtil.getCDOObject(thatAfterMoveObject).cdoState()); |
| } |
| |
| public void testMoveTailClearTest() throws Exception |
| { |
| initTestModel(); |
| |
| CDOSession session = openSessionWithAdditionsMode(); |
| CDOTransaction thisTransaction = session.openTransaction(); |
| CDOTransaction thatTransaction = session.openTransaction(); |
| addConflictResolver(thatTransaction); |
| |
| // Access objects. |
| Root thisRoot = getTestModelRoot(thisTransaction); |
| Root thatRoot = thatTransaction.getObject(thisRoot); |
| |
| // Attach adapters. |
| thisRoot.eAdapters().add(new ListPrintingAdapter("This root: ")); |
| thatRoot.eAdapters().add(new ListPrintingAdapter("That root: ")); |
| |
| // Move object. |
| BaseObject thisMoveObject = thisRoot.getListA().get(thisRoot.getListA().size() - 1); |
| BaseObject thatMoveObject = thatTransaction.getObject(thisMoveObject); |
| thisRoot.getListA().move(0, thisRoot.getListA().size() - 1); |
| BaseObject thisAfterMoveObject = thisRoot.getListA().get(thisRoot.getListA().size() - 1); |
| BaseObject thatAfterMoveObject = thatTransaction.getObject(thisAfterMoveObject); |
| |
| // Clear. |
| thatRoot.getListA().clear(); |
| |
| commitAndSync(thisTransaction, thatTransaction); |
| commitAndSync(thatTransaction, thisTransaction); |
| |
| // Print contents of lists |
| printList("This ", thisRoot.getListA()); |
| printList("That ", thatRoot.getListA()); |
| |
| // Check indices. |
| assertEquals(false, thisTransaction.isDirty()); |
| assertEquals(false, thatTransaction.isDirty()); |
| assertEquals(0, thisRoot.getListA().size()); |
| assertEquals(0, thatRoot.getListA().size()); |
| assertEquals(CDOState.INVALID, CDOUtil.getCDOObject(thisMoveObject).cdoState()); |
| assertEquals(CDOState.INVALID, CDOUtil.getCDOObject(thisAfterMoveObject).cdoState()); |
| assertEquals(CDOState.TRANSIENT, CDOUtil.getCDOObject(thatMoveObject).cdoState()); |
| assertEquals(CDOState.TRANSIENT, CDOUtil.getCDOObject(thatAfterMoveObject).cdoState()); |
| } |
| |
| public void testClearAddHeadTest() throws Exception |
| { |
| initTestModel(); |
| |
| CDOSession session = openSessionWithAdditionsMode(); |
| CDOTransaction thisTransaction = session.openTransaction(); |
| CDOTransaction thatTransaction = session.openTransaction(); |
| addConflictResolver(thatTransaction); |
| |
| // Access objects. |
| Root thisRoot = getTestModelRoot(thisTransaction); |
| Root thatRoot = thatTransaction.getObject(thisRoot); |
| |
| // Attach adapters. |
| thisRoot.eAdapters().add(new ListPrintingAdapter("This root: ")); |
| thatRoot.eAdapters().add(new ListPrintingAdapter("That root: ")); |
| |
| // Clear. |
| thisRoot.getListA().clear(); |
| |
| // Create objects. |
| BaseObject thatObject = createBaseObject("ThatBaseObject 0"); |
| thatRoot.getListA().add(0, thatObject); |
| |
| commitAndSync(thisTransaction, thatTransaction); |
| commitAndSync(thatTransaction, thisTransaction); |
| |
| // Print contents of lists |
| printList("This ", thisRoot.getListA()); |
| printList("That ", thatRoot.getListA()); |
| |
| // Check indices. |
| assertEquals(false, thisTransaction.isDirty()); |
| assertEquals(false, thatTransaction.isDirty()); |
| assertEquals(1, thisRoot.getListA().size()); |
| assertEquals(1, thatRoot.getListA().size()); |
| assertEquals(thisTransaction.getObject(thatObject), thisRoot.getListA().get(0)); |
| assertEquals(thatObject, thatRoot.getListA().get(0)); |
| } |
| |
| public void testClearAddTailTest() throws Exception |
| { |
| initTestModel(); |
| |
| CDOSession session = openSessionWithAdditionsMode(); |
| CDOTransaction thisTransaction = session.openTransaction(); |
| CDOTransaction thatTransaction = session.openTransaction(); |
| addConflictResolver(thatTransaction); |
| |
| // Access objects. |
| Root thisRoot = getTestModelRoot(thisTransaction); |
| Root thatRoot = thatTransaction.getObject(thisRoot); |
| |
| // Attach adapters. |
| thisRoot.eAdapters().add(new ListPrintingAdapter("This root: ")); |
| thatRoot.eAdapters().add(new ListPrintingAdapter("That root: ")); |
| |
| // Clear. |
| thisRoot.getListA().clear(); |
| |
| // Create objects. |
| BaseObject thatObject = createBaseObject("ThatBaseObject 0"); |
| thatRoot.getListA().add(thatObject); |
| |
| commitAndSync(thisTransaction, thatTransaction); |
| commitAndSync(thatTransaction, thisTransaction); |
| |
| // Print contents of lists |
| printList("This ", thisRoot.getListA()); |
| printList("That ", thatRoot.getListA()); |
| |
| // Check indices. |
| assertEquals(false, thisTransaction.isDirty()); |
| assertEquals(false, thatTransaction.isDirty()); |
| assertEquals(1, thisRoot.getListA().size()); |
| assertEquals(1, thatRoot.getListA().size()); |
| assertEquals(thisTransaction.getObject(thatObject), thisRoot.getListA().get(0)); |
| assertEquals(thatObject, thatRoot.getListA().get(0)); |
| } |
| |
| public void testClearRemoveHeadTest() throws Exception |
| { |
| initTestModel(); |
| |
| CDOSession session = openSessionWithAdditionsMode(); |
| CDOTransaction thisTransaction = session.openTransaction(); |
| CDOTransaction thatTransaction = session.openTransaction(); |
| addConflictResolver(thatTransaction); |
| |
| // Access objects. |
| Root thisRoot = getTestModelRoot(thisTransaction); |
| Root thatRoot = thatTransaction.getObject(thisRoot); |
| |
| // Attach adapters. |
| thisRoot.eAdapters().add(new ListPrintingAdapter("This root: ")); |
| thatRoot.eAdapters().add(new ListPrintingAdapter("That root: ")); |
| |
| // Create objects. |
| BaseObject thatRemoveObject = thatRoot.getListA().get(0); |
| BaseObject thisRemoveObject = thisTransaction.getObject(thatRemoveObject); |
| thatRoot.getListA().remove(0); |
| BaseObject thatAfterRemoveObject = thatRoot.getListA().get(0); |
| |
| // Clear. |
| thisRoot.getListA().clear(); |
| |
| commitAndSync(thisTransaction, thatTransaction); |
| commitAndSync(thatTransaction, thisTransaction); |
| |
| // Print contents of lists |
| printList("This ", thisRoot.getListA()); |
| printList("That ", thatRoot.getListA()); |
| |
| // Check indices. |
| assertEquals(false, thisTransaction.isDirty()); |
| assertEquals(false, thatTransaction.isDirty()); |
| assertEquals(0, thisRoot.getListA().size()); |
| assertEquals(0, thatRoot.getListA().size()); |
| assertEquals(CDOState.TRANSIENT, CDOUtil.getCDOObject(thisRemoveObject).cdoState()); |
| assertEquals(CDOState.TRANSIENT, CDOUtil.getCDOObject(thatRemoveObject).cdoState()); |
| assertEquals(CDOState.INVALID, CDOUtil.getCDOObject(thatAfterRemoveObject).cdoState()); |
| } |
| |
| public void testClearRemoveTailTest() throws Exception |
| { |
| initTestModel(); |
| |
| CDOSession session = openSessionWithAdditionsMode(); |
| CDOTransaction thisTransaction = session.openTransaction(); |
| CDOTransaction thatTransaction = session.openTransaction(); |
| addConflictResolver(thatTransaction); |
| |
| // Access objects. |
| Root thisRoot = getTestModelRoot(thisTransaction); |
| Root thatRoot = thatTransaction.getObject(thisRoot); |
| |
| // Attach adapters. |
| thisRoot.eAdapters().add(new ListPrintingAdapter("This root: ")); |
| thatRoot.eAdapters().add(new ListPrintingAdapter("That root: ")); |
| |
| // Create objects. |
| BaseObject thatRemoveObject = thatRoot.getListA().get(thatRoot.getListA().size() - 1); |
| BaseObject thisRemoveObject = thisTransaction.getObject(thatRemoveObject); |
| thatRoot.getListA().remove(thatRoot.getListA().size() - 1); |
| BaseObject thatAfterRemoveObject = thatRoot.getListA().get(thatRoot.getListA().size() - 1); |
| |
| // Clear. |
| thisRoot.getListA().clear(); |
| |
| commitAndSync(thisTransaction, thatTransaction); |
| commitAndSync(thatTransaction, thisTransaction); |
| |
| // Print contents of lists |
| printList("This ", thisRoot.getListA()); |
| printList("That ", thatRoot.getListA()); |
| |
| // Check indices. |
| assertEquals(false, thisTransaction.isDirty()); |
| assertEquals(false, thatTransaction.isDirty()); |
| assertEquals(0, thisRoot.getListA().size()); |
| assertEquals(0, thatRoot.getListA().size()); |
| assertEquals(CDOState.TRANSIENT, CDOUtil.getCDOObject(thisRemoveObject).cdoState()); |
| assertEquals(CDOState.TRANSIENT, CDOUtil.getCDOObject(thatRemoveObject).cdoState()); |
| assertEquals(CDOState.INVALID, CDOUtil.getCDOObject(thatAfterRemoveObject).cdoState()); |
| } |
| |
| public void testClearMoveHeadTest() throws Exception |
| { |
| initTestModel(); |
| |
| CDOSession session = openSessionWithAdditionsMode(); |
| CDOTransaction thisTransaction = session.openTransaction(); |
| CDOTransaction thatTransaction = session.openTransaction(); |
| addConflictResolver(thatTransaction); |
| |
| // Access objects. |
| Root thisRoot = getTestModelRoot(thisTransaction); |
| Root thatRoot = thatTransaction.getObject(thisRoot); |
| |
| // Attach adapters. |
| thisRoot.eAdapters().add(new ListPrintingAdapter("This root: ")); |
| thatRoot.eAdapters().add(new ListPrintingAdapter("That root: ")); |
| |
| // Move object. |
| BaseObject thatMoveObject = thatRoot.getListA().get(0); |
| BaseObject thisMoveObject = thisTransaction.getObject(thatMoveObject); |
| thatRoot.getListA().move(thatRoot.getListA().size() - 1, 0); |
| BaseObject thatAfterMoveObject = thatRoot.getListA().get(0); |
| BaseObject thisAfterMoveObject = thisTransaction.getObject(thatAfterMoveObject); |
| |
| // Clear. |
| thisRoot.getListA().clear(); |
| |
| commitAndSync(thisTransaction, thatTransaction); |
| commitAndSync(thatTransaction, thisTransaction); |
| |
| // Print contents of lists |
| printList("This ", thisRoot.getListA()); |
| printList("That ", thatRoot.getListA()); |
| |
| // Check indices. |
| assertEquals(false, thisTransaction.isDirty()); |
| assertEquals(false, thatTransaction.isDirty()); |
| assertEquals(0, thisRoot.getListA().size()); |
| assertEquals(0, thatRoot.getListA().size()); |
| assertEquals(CDOState.TRANSIENT, CDOUtil.getCDOObject(thisMoveObject).cdoState()); |
| assertEquals(CDOState.INVALID, CDOUtil.getCDOObject(thatMoveObject).cdoState()); |
| assertEquals(CDOState.TRANSIENT, CDOUtil.getCDOObject(thisAfterMoveObject).cdoState()); |
| } |
| |
| public void testClearMoveTailTest() throws Exception |
| { |
| initTestModel(); |
| |
| CDOSession session = openSessionWithAdditionsMode(); |
| CDOTransaction thisTransaction = session.openTransaction(); |
| CDOTransaction thatTransaction = session.openTransaction(); |
| addConflictResolver(thatTransaction); |
| |
| // Access objects. |
| Root thisRoot = getTestModelRoot(thisTransaction); |
| Root thatRoot = thatTransaction.getObject(thisRoot); |
| |
| // Attach adapters. |
| thisRoot.eAdapters().add(new ListPrintingAdapter("This root: ")); |
| thatRoot.eAdapters().add(new ListPrintingAdapter("That root: ")); |
| |
| // Move object. |
| BaseObject thatMoveObject = thatRoot.getListA().get(thatRoot.getListA().size() - 1); |
| BaseObject thisMoveObject = thisTransaction.getObject(thatMoveObject); |
| thatRoot.getListA().move(0, thatRoot.getListA().size() - 1); |
| BaseObject thatAfterMoveObject = thatRoot.getListA().get(thatRoot.getListA().size() - 1); |
| BaseObject thisAfterMoveObject = thisTransaction.getObject(thatAfterMoveObject); |
| |
| // Clear. |
| thisRoot.getListA().clear(); |
| |
| commitAndSync(thisTransaction, thatTransaction); |
| commitAndSync(thatTransaction, thisTransaction); |
| |
| // Print contents of lists |
| printList("This ", thisRoot.getListA()); |
| printList("That ", thatRoot.getListA()); |
| |
| // Check indices. |
| assertEquals(false, thisTransaction.isDirty()); |
| assertEquals(false, thatTransaction.isDirty()); |
| assertEquals(0, thisRoot.getListA().size()); |
| assertEquals(0, thatRoot.getListA().size()); |
| assertEquals(CDOState.TRANSIENT, CDOUtil.getCDOObject(thisMoveObject).cdoState()); |
| assertEquals(CDOState.INVALID, CDOUtil.getCDOObject(thatMoveObject).cdoState()); |
| assertEquals(CDOState.TRANSIENT, CDOUtil.getCDOObject(thisAfterMoveObject).cdoState()); |
| } |
| |
| public void testClearClearTest() throws Exception |
| { |
| initTestModel(); |
| |
| CDOSession session = openSessionWithAdditionsMode(); |
| CDOTransaction thisTransaction = session.openTransaction(); |
| CDOTransaction thatTransaction = session.openTransaction(); |
| addConflictResolver(thatTransaction); |
| |
| // Access objects. |
| Root thisRoot = getTestModelRoot(thisTransaction); |
| Root thatRoot = thatTransaction.getObject(thisRoot); |
| |
| // Attach adapters. |
| thisRoot.eAdapters().add(new ListPrintingAdapter("This root: ")); |
| thatRoot.eAdapters().add(new ListPrintingAdapter("That root: ")); |
| |
| // Clear. |
| BaseObject thisObject = thisRoot.getListA().get(0); |
| thisRoot.getListA().clear(); |
| |
| BaseObject thatObject = thatRoot.getListA().get(0); |
| thatRoot.getListA().clear(); |
| |
| commitAndSync(thisTransaction, thatTransaction); |
| commitAndSync(thatTransaction, thisTransaction); |
| |
| // Print contents of lists |
| printList("This ", thisRoot.getListA()); |
| printList("That ", thatRoot.getListA()); |
| |
| // Check indices. |
| assertEquals(false, thisTransaction.isDirty()); |
| assertEquals(false, thatTransaction.isDirty()); |
| assertEquals(0, thisRoot.getListA().size()); |
| assertEquals(0, thatRoot.getListA().size()); |
| assertEquals(CDOState.TRANSIENT, CDOUtil.getCDOObject(thisObject).cdoState()); |
| assertEquals(CDOState.TRANSIENT, CDOUtil.getCDOObject(thatObject).cdoState()); |
| } |
| |
| public void testRemoveHeadMoveHeadRemoveMiddleTest() throws Exception |
| { |
| initTestModel(); |
| |
| CDOSession session = openSessionWithAdditionsMode(); |
| CDOTransaction thisTransaction = session.openTransaction(); |
| CDOTransaction thatTransaction = session.openTransaction(); |
| addConflictResolver(thatTransaction); |
| |
| // Access objects. |
| Root thisRoot = getTestModelRoot(thisTransaction); |
| Root thatRoot = thatTransaction.getObject(thisRoot); |
| |
| // Attach adapters. |
| thisRoot.eAdapters().add(new ListPrintingAdapter("This root: ")); |
| thatRoot.eAdapters().add(new ListPrintingAdapter("That root: ")); |
| |
| // Remove object (get it before deletion). |
| BaseObject thisRemoveObject = thisRoot.getListA().get(0); |
| BaseObject thatRemoveObject = thatTransaction.getObject(thisRemoveObject); |
| |
| thisRoot.getListA().remove(0); |
| BaseObject thisAfterRemoveObject = thisRoot.getListA().get(0); |
| |
| // Move object. |
| BaseObject thatMoveObject = thatRoot.getListA().get(0); |
| BaseObject thatRemoveAfterMoveObject = thatRoot.getListA().get(2); |
| BaseObject thatAfterRemoveAfterMoveObject = thatRoot.getListA().get(3); |
| msg(thatAfterRemoveAfterMoveObject); |
| |
| thatRoot.getListA().move(thatRoot.getListA().size() - 1, 0); |
| BaseObject thatAfterMoveObject = thatRoot.getListA().get(0); |
| |
| // Remove object. |
| thatRoot.getListA().remove(thatRemoveAfterMoveObject); |
| |
| commitAndSync(thisTransaction, thatTransaction); |
| commitAndSync(thatTransaction, thisTransaction); |
| |
| // Print contents of lists |
| printList("This ", thisRoot.getListA()); |
| printList("That ", thatRoot.getListA()); |
| |
| // Check indices. |
| assertEquals(false, thisTransaction.isDirty()); |
| assertEquals(false, thatTransaction.isDirty()); |
| assertEquals(thisAfterRemoveObject, thisRoot.getListA().get(0)); |
| assertEquals(thatTransaction.getObject(thisAfterRemoveObject), thatRoot.getListA().get(0)); |
| assertEquals(thisTransaction.getObject(thatAfterMoveObject), thisRoot.getListA().get(0)); |
| assertEquals(thatAfterMoveObject, thatRoot.getListA().get(0)); |
| assertEquals(CDOState.TRANSIENT, CDOUtil.getCDOObject(thisRemoveObject).cdoState()); |
| assertEquals(CDOState.INVALID, CDOUtil.getCDOObject(thatRemoveObject).cdoState()); |
| assertEquals(CDOState.INVALID, CDOUtil.getCDOObject(thatMoveObject).cdoState()); |
| } |
| |
| public void testMoveHeadMoveHeadRemoveMiddleTest() throws Exception |
| { |
| initTestModel(); |
| |
| CDOSession session = openSessionWithAdditionsMode(); |
| CDOTransaction thisTransaction = session.openTransaction(); |
| CDOTransaction thatTransaction = session.openTransaction(); |
| addConflictResolver(thatTransaction); |
| |
| // Access objects. |
| Root thisRoot = getTestModelRoot(thisTransaction); |
| Root thatRoot = thatTransaction.getObject(thisRoot); |
| |
| // Attach adapters. |
| thisRoot.eAdapters().add(new ListPrintingAdapter("This root: ")); |
| thatRoot.eAdapters().add(new ListPrintingAdapter("That root: ")); |
| |
| // Move object. |
| BaseObject thisMoveObject = thisRoot.getListA().get(0); |
| thisRoot.getListA().move(thisRoot.getListA().size() - 1, 0); |
| BaseObject thisAfterMoveObject = thisRoot.getListA().get(0); |
| |
| // Move object. |
| BaseObject thatMoveObject = thatRoot.getListA().get(0); |
| BaseObject thatRemoveAfterMoveObject = thatRoot.getListA().get(2); |
| BaseObject thatAfterRemoveAfterMoveObject = thatRoot.getListA().get(3); |
| thatRoot.getListA().move(thatRoot.getListA().size() - 1, 0); |
| BaseObject thatAfterMoveObject = thatRoot.getListA().get(0); |
| |
| // Remove object. |
| BaseObject thisRemoveAfterMoveObject = thisTransaction.getObject(thatRemoveAfterMoveObject); |
| thatRoot.getListA().remove(thatRemoveAfterMoveObject); |
| |
| commitAndSync(thisTransaction, thatTransaction); |
| commitAndSync(thatTransaction, thisTransaction); |
| |
| // Print contents of lists |
| printList("This ", thisRoot.getListA()); |
| printList("That ", thatRoot.getListA()); |
| |
| // Check indices. |
| int listSize = thisRoot.getListA().size(); |
| assertEquals(false, thisTransaction.isDirty()); |
| assertEquals(false, thatTransaction.isDirty()); |
| assertEquals(thisMoveObject, thisRoot.getListA().get(listSize - 1)); |
| assertEquals(thatMoveObject, thatRoot.getListA().get(listSize - 1)); |
| assertEquals(thisAfterMoveObject, thisRoot.getListA().get(0)); |
| assertEquals(thatAfterMoveObject, thatRoot.getListA().get(0)); |
| assertEquals(thisTransaction.getObject(thatAfterRemoveAfterMoveObject), thisRoot.getListA().get(1)); |
| assertEquals(thatAfterRemoveAfterMoveObject, thatRoot.getListA().get(1)); |
| assertEquals(CDOState.TRANSIENT, CDOUtil.getCDOObject(thatRemoveAfterMoveObject).cdoState()); |
| assertEquals(CDOState.INVALID, CDOUtil.getCDOObject(thisRemoveAfterMoveObject).cdoState()); |
| } |
| |
| public void testMoveHeadRemoveHeadRemoveMiddleTest() throws Exception |
| { |
| initTestModel(); |
| |
| CDOSession session = openSessionWithAdditionsMode(); |
| CDOTransaction thisTransaction = session.openTransaction(); |
| CDOTransaction thatTransaction = session.openTransaction(); |
| addConflictResolver(thatTransaction); |
| |
| // Access objects. |
| Root thisRoot = getTestModelRoot(thisTransaction); |
| Root thatRoot = thatTransaction.getObject(thisRoot); |
| |
| // Attach adapters. |
| thisRoot.eAdapters().add(new ListPrintingAdapter("This root: ")); |
| thatRoot.eAdapters().add(new ListPrintingAdapter("That root: ")); |
| |
| // Remove object. |
| BaseObject thisRemoveObject = thisRoot.getListA().get(0); |
| BaseObject thatRemoveObject = thatTransaction.getObject(thisRemoveObject); |
| thisRoot.getListA().remove(0); |
| BaseObject thisAfterRemveObject = thisRoot.getListA().get(0); |
| |
| // Move object. |
| BaseObject thatMoveObject = thatRoot.getListA().get(0); |
| msg(thatMoveObject); |
| |
| BaseObject thatRemoveAfterMoveObject = thatRoot.getListA().get(2); |
| BaseObject thatAfterRemoveAfterMoveObject = thatRoot.getListA().get(3); |
| thatRoot.getListA().move(thatRoot.getListA().size() - 1, 0); |
| BaseObject thatAfterMoveObject = thatRoot.getListA().get(0); |
| |
| // Remove object. |
| BaseObject thisRemoveAfterMoveObject = thisTransaction.getObject(thatRemoveAfterMoveObject); |
| thatRoot.getListA().remove(thatRemoveAfterMoveObject); |
| |
| commitAndSync(thisTransaction, thatTransaction); |
| commitAndSync(thatTransaction, thisTransaction); |
| |
| // Print contents of lists |
| printList("This ", thisRoot.getListA()); |
| printList("That ", thatRoot.getListA()); |
| |
| // Check indices. |
| assertEquals(false, thisTransaction.isDirty()); |
| assertEquals(false, thatTransaction.isDirty()); |
| assertEquals(thisAfterRemveObject, thisRoot.getListA().get(0)); |
| assertEquals(thatTransaction.getObject(thisAfterRemveObject), thatRoot.getListA().get(0)); |
| assertEquals(thisTransaction.getObject(thatAfterMoveObject), thisRoot.getListA().get(0)); |
| assertEquals(thatAfterMoveObject, thatRoot.getListA().get(0)); |
| assertEquals(thisTransaction.getObject(thatAfterRemoveAfterMoveObject), thisRoot.getListA().get(1)); |
| assertEquals(thatAfterRemoveAfterMoveObject, thatRoot.getListA().get(1)); |
| assertEquals(CDOState.TRANSIENT, CDOUtil.getCDOObject(thatRemoveAfterMoveObject).cdoState()); |
| assertEquals(CDOState.INVALID, CDOUtil.getCDOObject(thisRemoveAfterMoveObject).cdoState()); |
| assertEquals(CDOState.TRANSIENT, CDOUtil.getCDOObject(thisRemoveObject).cdoState()); |
| assertEquals(CDOState.INVALID, CDOUtil.getCDOObject(thatRemoveObject).cdoState()); |
| } |
| |
| public void testRemoveHeadAddChildHead() throws Exception |
| { |
| initTestModel(); |
| |
| CDOSession session = openSessionWithAdditionsMode(); |
| CDOTransaction thisTransaction = session.openTransaction(); |
| CDOTransaction thatTransaction = session.openTransaction(); |
| addConflictResolver(thatTransaction); |
| |
| // Access objects. |
| Root thisRoot = getTestModelRoot(thisTransaction); |
| Root thatRoot = thatTransaction.getObject(thisRoot); |
| |
| // Access lists. |
| EList<BaseObject> thisList = thisRoot.getListB(); |
| EList<BaseObject> thatList = thatRoot.getListB(); |
| |
| // Attach adapters |
| thisRoot.eAdapters().add(new ListPrintingAdapter("This root: ")); |
| thatRoot.eAdapters().add(new ListPrintingAdapter("That root: ")); |
| |
| // Remove containment |
| thisList.remove(0); |
| |
| ContainmentObject thatAddContainment = createContainmentObject("AddContainmentObject 0"); |
| thatAddContainment.setAttributeRequired("AddContainmentObject 0"); |
| thatAddContainment.setContainmentOptional(createBaseObject("AddBaseContainmentObject 0")); |
| |
| ContainmentObject thatParent = (ContainmentObject)thatList.get(0); |
| EList<BaseObject> thatParentList = thatParent.getContainmentList(); |
| |
| // Detach an object |
| ContainmentObject thatReattachContainment = (ContainmentObject)thatParentList.remove(0); |
| |
| // Add a new object |
| thatParentList.add(thatAddContainment); |
| |
| // Reattach containment |
| thatParentList.add(thatReattachContainment); |
| |
| commitAndSync(thisTransaction, thatTransaction); |
| assertEquals(false, thisTransaction.isDirty()); |
| assertEquals(false, thisTransaction.hasConflict()); |
| assertEquals(true, thatTransaction.isDirty()); |
| assertEquals(true, thatTransaction.hasConflict()); |
| } |
| |
| public void testRemoveHeadSetChildHead() throws Exception |
| { |
| initTestModel(); |
| |
| CDOSession session = openSessionWithAdditionsMode(); |
| CDOTransaction thisTransaction = session.openTransaction(); |
| CDOTransaction thatTransaction = session.openTransaction(); |
| addConflictResolver(thatTransaction); |
| |
| // Access objects. |
| Root thisRoot = getTestModelRoot(thisTransaction); |
| Root thatRoot = thatTransaction.getObject(thisRoot); |
| |
| // Attach adapters. |
| thisRoot.eAdapters().add(new ListPrintingAdapter("This root: ")); |
| thatRoot.eAdapters().add(new ListPrintingAdapter("That root: ")); |
| |
| // Remove containment. |
| thisRoot.getListB().remove(0); |
| |
| // Add child to containment. |
| BaseObject bcObject0 = createBaseObject("AddBaseContainmentObject 0"); |
| ContainmentObject thatAddContainment = createContainmentObject("AddContainmentObject 0"); |
| thatAddContainment.setAttributeRequired("AddContainmentObject 0"); |
| thatAddContainment.setContainmentOptional(bcObject0); |
| |
| ContainmentObject thatParent = (ContainmentObject)thatRoot.getListB().get(0); |
| |
| // Set a new object. |
| BaseObject thatUnsetContainment = thatParent.getContainmentOptional(); |
| msg(thatUnsetContainment); |
| |
| thatParent.setContainmentOptional(thatAddContainment); |
| |
| commitAndSync(thisTransaction, thatTransaction); |
| assertEquals(false, thisTransaction.isDirty()); |
| assertEquals(true, thatTransaction.isDirty()); |
| assertEquals(false, thisTransaction.hasConflict()); |
| assertEquals(true, thatTransaction.hasConflict()); |
| } |
| |
| public void testRemoveHeadRemoveChildHead() throws Exception |
| { |
| initTestModel(); |
| |
| CDOSession session = openSessionWithAdditionsMode(); |
| CDOTransaction thisTransaction = session.openTransaction(); |
| CDOTransaction thatTransaction = session.openTransaction(); |
| addConflictResolver(thatTransaction); |
| |
| // Access objects. |
| Root thisRoot = getTestModelRoot(thisTransaction); |
| Root thatRoot = thatTransaction.getObject(thisRoot); |
| |
| // Attach adapters. |
| thisRoot.eAdapters().add(new ListPrintingAdapter("This root: ")); |
| thatRoot.eAdapters().add(new ListPrintingAdapter("That root: ")); |
| |
| // Remove containment. |
| thisRoot.getListB().remove(0); |
| |
| // Remove child from containment. |
| ((ContainmentObject)thatRoot.getListB().get(0)).getContainmentList().remove(0); |
| |
| commitAndSync(thisTransaction, thatTransaction); |
| assertEquals(false, thisTransaction.isDirty()); |
| assertEquals(true, thatTransaction.isDirty()); |
| assertEquals(false, thisTransaction.hasConflict()); |
| assertEquals(true, thatTransaction.hasConflict()); |
| } |
| |
| public void testRemoveHeadRemoveChildChildHead() throws Exception |
| { |
| initTestModel(); |
| |
| CDOSession session = openSessionWithAdditionsMode(); |
| CDOTransaction thisTransaction = session.openTransaction(); |
| CDOTransaction thatTransaction = session.openTransaction(); |
| addConflictResolver(thatTransaction); |
| |
| // Access objects. |
| Root thisRoot = getTestModelRoot(thisTransaction); |
| Root thatRoot = thatTransaction.getObject(thisRoot); |
| |
| // Attach adapters. |
| thisRoot.eAdapters().add(new ListPrintingAdapter("This root: ")); |
| thatRoot.eAdapters().add(new ListPrintingAdapter("That root: ")); |
| |
| // Remove containment. |
| thisRoot.getListB().remove(0); |
| |
| // Get parent object. |
| ContainmentObject thatParent = (ContainmentObject)thatRoot.getListB().get(0); |
| |
| // Get child from containment. |
| ContainmentObject thatChildContainment = (ContainmentObject)thatParent.getContainmentList().get(0); |
| |
| // Remove child from containment child. |
| thatChildContainment.getContainmentList().remove(0); |
| |
| commitAndSync(thisTransaction, thatTransaction); |
| assertEquals(false, thisTransaction.isDirty()); |
| assertEquals(false, thisTransaction.hasConflict()); |
| assertEquals(true, thatTransaction.isDirty()); |
| assertEquals(true, thatTransaction.hasConflict()); |
| } |
| |
| public void testRemoveHeadMoveChildHead() throws Exception |
| { |
| initTestModel(); |
| |
| CDOSession session = openSessionWithAdditionsMode(); |
| CDOTransaction thisTransaction = session.openTransaction(); |
| CDOTransaction thatTransaction = session.openTransaction(); |
| addConflictResolver(thatTransaction); |
| |
| // Access objects. |
| Root thisRoot = getTestModelRoot(thisTransaction); |
| Root thatRoot = thatTransaction.getObject(thisRoot); |
| |
| // Attach adapters. |
| thisRoot.eAdapters().add(new ListPrintingAdapter("This root: ")); |
| thatRoot.eAdapters().add(new ListPrintingAdapter("That root: ")); |
| |
| // Remove containment. |
| thisRoot.getListB().remove(0); |
| |
| // Add child to containment. |
| BaseObject bcObject0 = createBaseObject("AddBaseContainmentObject 0"); |
| ContainmentObject thatAddContainment = createContainmentObject("AddContainmentObject 0"); |
| thatAddContainment.setContainmentOptional(bcObject0); |
| |
| ContainmentObject thatParent = (ContainmentObject)thatRoot.getListB().get(0); |
| |
| // Detach an object. |
| ContainmentObject thatReattachContainment = (ContainmentObject)thatParent.getContainmentList().remove(0); |
| |
| // Add a new object. |
| thatParent.getContainmentList().add(thatAddContainment); |
| |
| // Reattach containment. |
| thatParent.getContainmentList().add(thatReattachContainment); |
| |
| commitAndSync(thisTransaction, thatTransaction); |
| assertEquals(false, thisTransaction.isDirty()); |
| assertEquals(false, thisTransaction.hasConflict()); |
| assertEquals(true, thatTransaction.isDirty()); |
| assertEquals(true, thatTransaction.hasConflict()); |
| } |
| |
| public void testRemoveHeadReAttachHead() throws Exception |
| { |
| initTestModel(); |
| |
| CDOSession session = openSessionWithAdditionsMode(); |
| CDOTransaction thisTransaction = session.openTransaction(); |
| CDOTransaction thatTransaction = session.openTransaction(); |
| addConflictResolver(thatTransaction); |
| |
| // Access objects. |
| Root thisRoot = getTestModelRoot(thisTransaction); |
| Root thatRoot = thatTransaction.getObject(thisRoot); |
| |
| // Attach adapters. |
| thisRoot.eAdapters().add(new ListPrintingAdapter("This root: ")); |
| thatRoot.eAdapters().add(new ListPrintingAdapter("That root: ")); |
| |
| // Remove containment. |
| ContainmentObject thisToRemoveContainment = (ContainmentObject)thisRoot.getListB().get(0); |
| ContainmentObject thisAfterRemoveContainment = (ContainmentObject)thisRoot.getListB().get(1); |
| thisRoot.getListB().remove(0); |
| |
| // Detach and re-attach containment. |
| ContainmentObject thatAddContainment = (ContainmentObject)thatRoot.getListB().get(0); |
| thatRoot.getListB().add(thatAddContainment); |
| // TODO: re-add at other position (add some objects in between)? |
| |
| commitAndSync(thisTransaction, thatTransaction); |
| commitAndSync(thatTransaction, thisTransaction); |
| |
| // Print contents of lists |
| printList("This ", thisRoot.getListB()); |
| printList("That ", thatRoot.getListB()); |
| |
| // Check indices. |
| assertEquals(false, thisTransaction.isDirty()); |
| assertEquals(false, thatTransaction.isDirty()); |
| assertEquals(thisAfterRemoveContainment, thisRoot.getListB().get(0)); |
| assertEquals(thatTransaction.getObject(thisAfterRemoveContainment), thatRoot.getListB().get(0)); |
| |
| assertEquals(CDOState.TRANSIENT, CDOUtil.getCDOObject(thisToRemoveContainment).cdoState()); |
| assertEquals(CDOState.INVALID, CDOUtil.getCDOObject(thatAddContainment).cdoState()); |
| } |
| |
| public void testContainerAddDifferentParent() throws Exception |
| { |
| initTestModel(); |
| |
| CDOSession session = openSessionWithAdditionsMode(); |
| CDOTransaction thisTransaction = session.openTransaction(); |
| CDOTransaction thatTransaction = session.openTransaction(); |
| addConflictResolver(thatTransaction); |
| |
| // Create initial model. |
| Root thisRoot = getTestModelRoot(thisTransaction); |
| EList<BaseObject> thisListC = thisRoot.getListC(); |
| |
| ContainmentObject thisGroup1 = createContainmentObject("Group 1"); |
| thisGroup1.setAttributeRequired("Group 1"); |
| |
| ContainmentObject thisGroup2 = createContainmentObject("Group 2"); |
| thisGroup2.setAttributeRequired("Group 2"); |
| |
| BaseObject thisElement0 = createBaseObject("Element 0"); |
| thisElement0.setAttributeRequired("Element 0"); |
| |
| BaseObject thisElement1 = createBaseObject("Element 1"); |
| thisElement1.setAttributeRequired("Element 1"); |
| |
| BaseObject thisElement2 = createBaseObject("Element 2"); |
| thisElement2.setAttributeRequired("Element 2"); |
| |
| thisListC.add(thisGroup1); |
| thisListC.add(thisGroup2); |
| thisListC.add(thisElement0); |
| thisListC.add(thisElement1); |
| thisListC.add(thisElement2); |
| |
| commitAndSync(thisTransaction, thatTransaction); |
| |
| // Get objects from that transaction. |
| ContainmentObject thatGroup2 = thatTransaction.getObject(thisGroup2); |
| BaseObject thatElement1 = thatTransaction.getObject(thisElement1); |
| BaseObject thatElement2 = thatTransaction.getObject(thisElement2); |
| |
| // THIS: Create group 1 (element 0 & 1). |
| thisGroup1.getContainmentList().add(thisElement0); // Move element0 from listC to group1 |
| thisGroup1.getContainmentList().add(thisElement1); // Move element1 from listC to group1 |
| |
| // THAT: Create group 2 (element 1 & 2). |
| thatGroup2.getContainmentList().add(thatElement1); // Move element1 from listC to group2 (CONFLICT) |
| thatGroup2.getContainmentList().add(thatElement2); // Move element2 from listC to group2 |
| |
| commitAndSync(thisTransaction, thatTransaction); |
| assertEquals(false, thisTransaction.isDirty()); |
| assertEquals(false, thisTransaction.hasConflict()); |
| assertEquals(true, thatTransaction.isDirty()); |
| assertEquals(true, thatTransaction.hasConflict()); |
| } |
| |
| // ========== HELPERS ====================================================== |
| |
| protected BaseObject createBaseObject(String attribute) |
| { |
| BaseObject baseObj = getModel6Factory().createBaseObject(); |
| baseObj.setAttributeRequired(attribute); |
| return baseObj; |
| } |
| |
| protected ReferenceObject createReferenceObject(String attribute) |
| { |
| ReferenceObject refObject = getModel6Factory().createReferenceObject(); |
| refObject.setAttributeRequired(attribute); |
| return refObject; |
| } |
| |
| protected ContainmentObject createContainmentObject(String attribute) |
| { |
| ContainmentObject contObject = getModel6Factory().createContainmentObject(); |
| contObject.setAttributeRequired(attribute); |
| return contObject; |
| } |
| |
| private CDOSession openSessionWithAdditionsMode() |
| { |
| CDOSession session = openSession(); |
| session.options().setPassiveUpdateEnabled(true); |
| session.options().setPassiveUpdateMode(CDOCommonSession.Options.PassiveUpdateMode.ADDITIONS); |
| return session; |
| } |
| |
| // --- initialize model ---------------------------------------------------- |
| |
| private void initTestModelSimple() throws CommitException |
| { |
| CDOSession session = openSessionWithAdditionsMode(); |
| CDOTransaction transaction = session.openTransaction(); |
| CDOResource resource = transaction.getOrCreateResource(getResourcePath(TEST_RESOURCE_NAME)); |
| |
| Root testRoot = getModel6Factory().createRoot(); |
| resource.getContents().add(testRoot); |
| |
| BaseObject bObject1 = createBaseObject("BaseObject 1"); |
| BaseObject bObject2 = createBaseObject("BaseObject 2"); |
| BaseObject bObject3 = createBaseObject("BaseObject 3"); |
| |
| testRoot.getListA().add(bObject1); |
| testRoot.getListA().add(bObject2); |
| testRoot.getListA().add(bObject3); |
| |
| ContainmentObject cObject1L1 = createContainmentObject("ContainmentObject 1 - Level 1"); |
| ContainmentObject cObject1L2 = createContainmentObject("ContainmentObject 1 - Level 2"); |
| cObject1L1.getContainmentList().add(cObject1L2); |
| |
| testRoot.getListB().add(cObject1L1); |
| |
| transaction.commit(); |
| session.close(); |
| } |
| |
| private void initTestModel() throws CommitException |
| { |
| CDOSession session = openSessionWithAdditionsMode(); |
| CDOTransaction transaction = session.openTransaction(); |
| CDOResource resource = transaction.getOrCreateResource(getResourcePath(TEST_RESOURCE_NAME)); |
| |
| Root root = getModel6Factory().createRoot(); |
| resource.getContents().add(root); |
| |
| // Setup base objects. |
| BaseObject bObject0 = createBaseObject("BaseObject 0"); |
| BaseObject bObject1 = createBaseObject("BaseObject 1"); |
| BaseObject bObject2 = createBaseObject("BaseObject 2"); |
| BaseObject bObject3 = createBaseObject("BaseObject 3"); |
| BaseObject bObject4 = createBaseObject("BaseObject 4"); |
| |
| root.getListA().add(bObject0); |
| root.getListA().add(bObject1); |
| root.getListA().add(bObject2); |
| root.getListA().add(bObject3); |
| root.getListA().add(bObject4); |
| |
| // Containment objects. |
| ContainmentObject cObject0 = createContainmentObject("ContainmentObject 0"); |
| ContainmentObject cObject00 = createContainmentObject("ContainmentObject 00"); |
| BaseObject bcObject01 = createBaseObject("BaseContainmentObject 01"); |
| |
| cObject00.getContainmentList().add(bcObject01); |
| cObject0.getContainmentList().add(cObject00); |
| |
| ContainmentObject cObject1 = createContainmentObject("ContainmentObject 1"); |
| |
| root.getListB().add(cObject0); |
| root.getListB().add(cObject1); |
| |
| // Commit the model. |
| transaction.commit(); |
| } |
| |
| private Root getTestModelRoot(CDOTransaction transaction) |
| { |
| CDOResource resource = transaction.getResource(getResourcePath(TEST_RESOURCE_NAME)); |
| return (Root)resource.getContents().get(0); |
| } |
| |
| private void printList(String identifier, List<BaseObject> list) |
| { |
| StringBuilder builder = new StringBuilder(); |
| for (BaseObject element : list) |
| { |
| if (builder.length() != 0) |
| { |
| builder.append(", "); |
| } |
| |
| builder.append(element.getAttributeRequired() + " [" + CDOUtil.getCDOObject(element).cdoID() + "]"); |
| } |
| |
| IOUtil.OUT().println(identifier + "List: " + builder); |
| } |
| |
| private void addConflictResolver(CDOTransaction transaction) |
| { |
| transaction.options().addConflictResolver(createConflictResolver()); |
| } |
| |
| protected CDOConflictResolver createConflictResolver() |
| { |
| return new CDOMergingConflictResolver(ResolutionPreference.NONE); |
| } |
| |
| /** |
| * @author Pascal Lehmann |
| */ |
| private static class ListPrintingAdapter extends AdapterImpl |
| { |
| private String identifier; |
| |
| public ListPrintingAdapter(String identifier) |
| { |
| this.identifier = identifier; |
| } |
| |
| @Override |
| public void notifyChanged(Notification msg) |
| { |
| try |
| { |
| System.err.println(identifier + msg); |
| } |
| catch (Exception e) |
| { |
| // ignore. |
| } |
| } |
| } |
| } |