| /******************************************************************************* |
| * Copyright (c) 2005 IBM Corporation 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: |
| * IBM Corporation - initial API and implementation |
| *******************************************************************************/ |
| |
| package org.eclipse.ui.tests.operations; |
| |
| import junit.framework.TestCase; |
| |
| import org.eclipse.core.commands.ExecutionException; |
| import org.eclipse.core.commands.operations.DefaultOperationHistory; |
| import org.eclipse.core.commands.operations.ICompositeOperation; |
| import org.eclipse.core.commands.operations.IOperationHistoryListener; |
| import org.eclipse.core.commands.operations.IUndoableOperation; |
| import org.eclipse.core.commands.operations.IOperationApprover; |
| import org.eclipse.core.commands.operations.IOperationHistory; |
| import org.eclipse.core.commands.operations.LinearUndoEnforcer; |
| import org.eclipse.core.commands.operations.ObjectUndoContext; |
| import org.eclipse.core.commands.operations.OperationHistoryEvent; |
| import org.eclipse.core.commands.operations.OperationHistoryFactory; |
| import org.eclipse.core.commands.operations.OperationStatus; |
| import org.eclipse.core.commands.operations.TriggeredOperations; |
| import org.eclipse.core.runtime.IAdaptable; |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.core.runtime.Status; |
| |
| /** |
| * Tests the Operations Framework API. |
| * |
| * @since 3.1 |
| */ |
| public class OperationsAPITest extends TestCase { |
| |
| ObjectUndoContext contextA, contextB, contextC, contextW; |
| IOperationHistory history; |
| |
| IUndoableOperation op1, op2, op3, op4, op5, op6, localA, localB, localC; |
| ICompositeOperation refactor; |
| |
| int preExec, postExec, preUndo, postUndo, preRedo, postRedo, add, remove, notOK, changed = 0; |
| IOperationHistoryListener listener; |
| |
| public OperationsAPITest() { |
| super(); |
| } |
| |
| /** |
| * @param testName |
| */ |
| public OperationsAPITest(String name) { |
| super(name); |
| } |
| |
| protected void setUp() throws Exception { |
| history = new DefaultOperationHistory(); |
| contextA = new ObjectUndoContext("A"); |
| contextB = new ObjectUndoContext("B"); |
| contextC = new ObjectUndoContext("C"); |
| op1 = new TestOperation("op1"); |
| op1.addContext(contextA); |
| op2 = new TestOperation("op2"); |
| op2.addContext(contextB); |
| op2.addContext(contextC); |
| op3 = new TestOperation("op3"); |
| op3.addContext(contextC); |
| op4 = new TestOperation("op4"); |
| op4.addContext(contextA); |
| op5 = new TestOperation("op5"); |
| op5.addContext(contextB); |
| op6 = new TestOperation("op6"); |
| op6.addContext(contextC); |
| op6.addContext(contextA); |
| history.execute(op1, null, null); |
| history.execute(op2, null, null); |
| history.execute(op3, null, null); |
| history.execute(op4, null, null); |
| history.execute(op5, null, null); |
| history.execute(op6, null, null); |
| preExec = 0; postExec = 0; |
| preUndo = 0; postUndo = 0; |
| preRedo = 0; postRedo = 0; |
| add = 0; remove = 0; notOK = 0; |
| listener = new IOperationHistoryListener() { |
| public void historyNotification(OperationHistoryEvent event) { |
| switch (event.getEventType()) { |
| case OperationHistoryEvent.ABOUT_TO_EXECUTE: |
| preExec++; |
| break; |
| case OperationHistoryEvent.ABOUT_TO_UNDO: |
| preUndo++; |
| break; |
| case OperationHistoryEvent.ABOUT_TO_REDO: |
| preRedo++; |
| break; |
| case OperationHistoryEvent.DONE: |
| postExec++; |
| break; |
| case OperationHistoryEvent.UNDONE: |
| postUndo++; |
| break; |
| case OperationHistoryEvent.REDONE: |
| postRedo++; |
| break; |
| case OperationHistoryEvent.OPERATION_ADDED: |
| add++; |
| break; |
| case OperationHistoryEvent.OPERATION_REMOVED: |
| remove++; |
| break; |
| case OperationHistoryEvent.OPERATION_NOT_OK: |
| notOK++; |
| break; |
| case OperationHistoryEvent.OPERATION_CHANGED: |
| changed++; |
| break; |
| } |
| } |
| }; |
| history.addOperationHistoryListener(listener); |
| |
| } |
| |
| protected void tearDown() throws Exception { |
| super.tearDown(); |
| history.removeOperationHistoryListener(listener); |
| history.dispose(IOperationHistory.GLOBAL_UNDO_CONTEXT, true, true, false); |
| } |
| |
| public void testContextDispose() throws ExecutionException { |
| assertSame(history.getUndoOperation(contextA), op6); |
| assertSame(history.getUndoOperation(contextC), op6); |
| history.dispose(contextA, true, true, false); |
| assertSame(history.getUndoOperation(contextC), op6); |
| assertFalse(op6.hasContext(contextA)); |
| history.undo(contextC, null, null); |
| history.dispose(contextC, true, false, false); |
| assertFalse(history.canUndo(contextC)); |
| assertTrue(history.canRedo(contextC)); |
| history.redo(contextC, null, null); |
| IUndoableOperation[] ops = history.getUndoHistory(IOperationHistory.GLOBAL_UNDO_CONTEXT); |
| assertEquals(ops.length, 3); |
| ops = history.getUndoHistory(contextC); |
| assertEquals(ops.length, 1); |
| ops = history.getUndoHistory(contextB); |
| assertEquals(ops.length, 2); |
| } |
| |
| public void testContextHistories() throws ExecutionException { |
| assertSame(history.getUndoOperation(contextA), op6); |
| assertSame(history.getUndoOperation(contextB), op5); |
| assertSame(history.getUndoOperation(contextC), op6); |
| IStatus status = history.undo(contextC, null, null); |
| assertTrue("Status should be ok", status.isOK()); |
| assertSame(history.getRedoOperation(contextC), op6); |
| assertSame(history.getUndoOperation(contextC), op3); |
| assertTrue("Should be able to redo in c3", history.canRedo(contextC)); |
| assertTrue("Should be able to redo in c1", history.canRedo(contextA)); |
| history.redo(contextA, null, null); |
| assertSame(history.getUndoOperation(contextC), op6); |
| assertSame(history.getUndoOperation(contextA), op6); |
| } |
| |
| public void testHistoryLimit() throws ExecutionException { |
| history.setLimit(contextA, 2); |
| assertTrue(history.getUndoHistory(contextA).length == 2); |
| history.add(op1); |
| assertTrue(history.getUndoHistory(contextA).length == 2); |
| history.setLimit(contextB, 1); |
| assertTrue(history.getUndoHistory(contextB).length == 1); |
| assertFalse(op2.hasContext(contextB)); |
| history.undo(contextB, null, null); |
| assertTrue(history.getRedoHistory(contextB).length == 1); |
| assertTrue(history.getUndoHistory(contextB).length == 0); |
| history.redo(contextB, null, null); |
| assertTrue(history.getRedoHistory(contextB).length == 0); |
| assertTrue(history.getUndoHistory(contextB).length == 1); |
| } |
| |
| public void testLocalHistoryLimits() throws ExecutionException { |
| history.setLimit(contextC, 2); |
| assertTrue(history.getUndoHistory(contextC).length == 2); |
| // op2 should have context c3 removed as part of forcing the limit |
| assertFalse(op2.hasContext(contextC)); |
| assertTrue(history.getUndoHistory(contextB).length == 2); |
| |
| history.setLimit(contextB, 1); |
| assertTrue(history.getUndoHistory(contextB).length == 1); |
| history.undo(contextB, null, null); |
| op2.addContext(contextC); |
| history.add(op2); |
| assertSame(history.getUndoOperation(contextB), op2); |
| assertTrue(history.getUndoHistory(contextB).length == 1); |
| |
| history.setLimit(contextA, 0); |
| assertTrue(history.getUndoHistory(contextA).length == 0); |
| history.add(op1); |
| assertTrue(history.getUndoHistory(contextA).length == 0); |
| } |
| |
| public void testOpenOperation() throws ExecutionException { |
| // clear out history which will also reset operation execution counts |
| history.dispose(IOperationHistory.GLOBAL_UNDO_CONTEXT, true, true, false); |
| ICompositeOperation batch = new TriggeredOperations(op1, history); |
| history.openOperation(batch, IOperationHistory.EXECUTE); |
| op1.execute(null, null); |
| op2.execute(null, null); |
| history.add(op2); |
| history.execute(op3, null, null); |
| IUndoableOperation op = history.getUndoOperation(IOperationHistory.GLOBAL_UNDO_CONTEXT); |
| assertTrue("no operations should be in history yet", op == null); |
| history.closeOperation(true, true, IOperationHistory.EXECUTE); |
| op = history.getUndoOperation(IOperationHistory.GLOBAL_UNDO_CONTEXT); |
| assertTrue("Operation should be batching", op == batch); |
| op.removeContext(contextB); |
| assertFalse("Operation should not have context", op.hasContext(contextB)); |
| } |
| |
| public void test94459() throws ExecutionException { |
| // clear out history which will also reset operation execution counts |
| history.dispose(IOperationHistory.GLOBAL_UNDO_CONTEXT, true, true, false); |
| op2.execute(null, null); |
| ICompositeOperation batch = new TriggeredOperations(op2, history); |
| history.openOperation(batch, IOperationHistory.EXECUTE); |
| history.setLimit(contextA, 0); |
| op1.execute(null, null); |
| history.add(op1); |
| history.closeOperation(true, true, IOperationHistory.EXECUTE); |
| IUndoableOperation op = history.getUndoOperation(IOperationHistory.GLOBAL_UNDO_CONTEXT); |
| assertTrue("Operation should be batching", op == batch); |
| assertFalse("Operation should not have context", op.hasContext(contextA)); |
| } |
| |
| public void test94459AllContextsEmpty() throws ExecutionException { |
| // clear out history which will also reset operation execution counts |
| history.dispose(IOperationHistory.GLOBAL_UNDO_CONTEXT, true, true, false); |
| op2.execute(null, null); |
| ICompositeOperation batch = new TriggeredOperations(op2, history); |
| history.openOperation(batch, IOperationHistory.EXECUTE); |
| history.setLimit(contextA, 0); |
| history.setLimit(contextB, 0); |
| history.setLimit(contextC, 0); |
| op1.execute(null, null); |
| history.add(op1); |
| history.closeOperation(true, true, IOperationHistory.EXECUTE); |
| IUndoableOperation op = history.getUndoOperation(IOperationHistory.GLOBAL_UNDO_CONTEXT); |
| assertTrue("Operation should not have been added", op == null); |
| } |
| |
| public void test94400() throws ExecutionException { |
| UnredoableTestOperation op = new UnredoableTestOperation("troubled op"); |
| op.addContext(contextA); |
| history.execute(op, null, null); |
| assertTrue("Operation should be undoable", history.canUndo(contextA)); |
| history.undo(contextA, null, null); |
| assertFalse("Operation should not be in redo history", history.getRedoOperation(contextA) == op); |
| assertTrue("Operation should be disposed", op.disposed); |
| } |
| |
| public void testUnsuccessfulOpenOperation() throws ExecutionException { |
| // clear out history which will also reset operation execution counts |
| history.dispose(IOperationHistory.GLOBAL_UNDO_CONTEXT, true, true, false); |
| ICompositeOperation batch = new TriggeredOperations(op1, history); |
| history.openOperation(batch, IOperationHistory.EXECUTE); |
| op1.execute(null, null); |
| op2.execute(null, null); |
| history.add(op2); |
| history.execute(op3, null, null); |
| IUndoableOperation op = history.getUndoOperation(IOperationHistory.GLOBAL_UNDO_CONTEXT); |
| assertTrue("no operations should be in history yet", op == null); |
| history.closeOperation(false, true, IOperationHistory.EXECUTE); |
| op = history.getUndoOperation(IOperationHistory.GLOBAL_UNDO_CONTEXT); |
| assertNull("Unsuccessful operation should not be added to history", op); |
| assertTrue("NOT_OK notification should have been received", notOK == 1); |
| assertTrue("DONE should not be sent while batching", postExec == 0); |
| assertTrue("ADDED should not have been sent while batching", add == 0); |
| } |
| |
| public void testNotAddedOpenOperation() throws ExecutionException { |
| // clear out history which will also reset operation execution counts |
| history.dispose(IOperationHistory.GLOBAL_UNDO_CONTEXT, true, true, false); |
| ICompositeOperation batch = new TriggeredOperations(op1, history); |
| history.openOperation(batch, IOperationHistory.EXECUTE); |
| op1.execute(null, null); |
| op2.execute(null, null); |
| history.add(op2); |
| history.execute(op3, null, null); |
| IUndoableOperation op = history.getUndoOperation(IOperationHistory.GLOBAL_UNDO_CONTEXT); |
| assertTrue("no operations should be in history yet", op == null); |
| history.closeOperation(true, false, IOperationHistory.EXECUTE); |
| op = history.getUndoOperation(IOperationHistory.GLOBAL_UNDO_CONTEXT); |
| assertNull("Operation should not be added to history", op); |
| assertTrue("DONE notification should have been received", postExec == 1); |
| assertTrue("ADDED should not have occurred or be sent while batching", add == 0); |
| } |
| |
| public void testMultipleOpenOperation() throws ExecutionException { |
| // clear out history which will also reset operation execution counts |
| boolean failure = false; |
| history.dispose(IOperationHistory.GLOBAL_UNDO_CONTEXT, true, true, false); |
| ICompositeOperation comp1 = new TriggeredOperations(op1, history); |
| history.openOperation(comp1, IOperationHistory.EXECUTE); |
| op1.execute(null, null); |
| op2.execute(null, null); |
| history.add(op2); |
| history.execute(op3, null, null); |
| ICompositeOperation comp2 = new TriggeredOperations(op4, history); |
| try { |
| history.openOperation(comp2, IOperationHistory.EXECUTE); |
| } catch (IllegalStateException e) { |
| failure = true; |
| } |
| assertTrue("Exception should have been thrown for second open operation", failure); |
| IUndoableOperation op = history.getUndoOperation(IOperationHistory.GLOBAL_UNDO_CONTEXT); |
| assertNull("Unexpected nested open should not add original", op); |
| history.closeOperation(true, true, IOperationHistory.EXECUTE); |
| op = history.getUndoOperation(IOperationHistory.GLOBAL_UNDO_CONTEXT); |
| assertSame("First operation should be closed", op, comp1); |
| } |
| |
| public void testAbortedOpenOperation() throws ExecutionException { |
| history.dispose(IOperationHistory.GLOBAL_UNDO_CONTEXT, true, true, false); |
| history.openOperation(new TriggeredOperations(op1, history), IOperationHistory.EXECUTE); |
| op1.execute(null, null); |
| history.execute(op2, null, null); |
| // flush history while operation is open |
| history.dispose(IOperationHistory.GLOBAL_UNDO_CONTEXT, true, true, false); |
| // op3 should be added as its own op since we flushed while open |
| history.add(op3); |
| // should really have no effect |
| history.closeOperation(true, true, IOperationHistory.EXECUTE); |
| IUndoableOperation op = history.getUndoOperation(IOperationHistory.GLOBAL_UNDO_CONTEXT); |
| assertTrue("Open operation should be flushed", op == op3); |
| } |
| |
| public void testOperationApproval() throws ExecutionException { |
| history.addOperationApprover(new LinearUndoEnforcer()); |
| // the first undo should be fine |
| IStatus status = history.undo(contextB, null, null); |
| assertTrue(status.isOK()); |
| |
| // the second causes a linear violation on C |
| assertTrue(history.canUndo(contextB)); |
| status = history.undo(contextB, null, null); |
| assertFalse(status.isOK()); |
| |
| // undo the newer C items |
| status = history.undo(contextC, null, null); |
| assertTrue(status.isOK()); |
| status = history.undo(contextC, null, null); |
| assertTrue(status.isOK()); |
| |
| // now we should be okay in B |
| status = history.undo(contextB, null, null); |
| assertTrue(status.isOK()); |
| |
| history.addOperationApprover(new IOperationApprover() { |
| |
| public IStatus proceedRedoing(IUndoableOperation o, IOperationHistory h, IAdaptable a) { |
| return Status.CANCEL_STATUS; |
| } |
| public IStatus proceedUndoing(IUndoableOperation o, IOperationHistory h, IAdaptable a) { |
| return Status.CANCEL_STATUS; |
| } |
| }); |
| // everything should fail now |
| assertFalse(history.redo(contextB, null, null).isOK()); |
| assertFalse(history.redo(contextC, null, null).isOK()); |
| assertFalse(history.undo(contextA, null, null).isOK()); |
| assertFalse(history.undo(contextB, null, null).isOK()); |
| assertFalse(history.undo(contextC, null, null).isOK()); |
| } |
| |
| public void testOperationFailure() throws ExecutionException { |
| history.addOperationApprover(new IOperationApprover() { |
| |
| public IStatus proceedRedoing(IUndoableOperation o, IOperationHistory h, IAdaptable a) { |
| return Status.OK_STATUS; |
| } |
| public IStatus proceedUndoing(IUndoableOperation o, IOperationHistory h, IAdaptable a) { |
| if (o == op6) |
| return Status.CANCEL_STATUS; |
| if (o == op5) |
| return new OperationStatus(IStatus.ERROR, "org.eclipse.ui.tests", 0, "Error", null); |
| return Status.OK_STATUS; |
| } |
| }); |
| |
| // should fail but still keep op6 on the stack since it's cancelled |
| IStatus status = history.undo(contextC, null, null); |
| assertFalse(status.isOK()); |
| assertSame(history.getUndoOperation(contextC), op6); |
| |
| // should fail since it's an error |
| status = history.undo(contextB, null, null); |
| assertFalse(status.isOK()); |
| |
| // operation remains on stack (see bug#92506) |
| assertSame(history.getUndoOperation(contextB), op5); |
| } |
| |
| public void testOperationRedo() throws ExecutionException { |
| history.undo(contextB, null, null); |
| history.undo(contextB, null, null); |
| history.undo(contextC, null, null); |
| history.undo(contextC, null, null); |
| assertSame(history.getRedoOperation(contextB), op2); |
| assertSame(history.getUndoOperation(contextA), op4); |
| assertTrue(history.canUndo(contextA)); |
| assertFalse(history.canUndo(contextB)); |
| assertFalse(history.canUndo(contextC)); |
| assertTrue(preUndo == 4); |
| assertTrue(postUndo == 4); |
| history.redo(contextB, null, null); |
| assertTrue(postRedo == 1); |
| assertTrue(history.canUndo(contextB)); |
| assertTrue(history.canUndo(contextC)); |
| } |
| |
| public void testOperationUndo() throws ExecutionException { |
| history.undo(contextA, null, null); |
| history.undo(contextA, null, null); |
| assertSame(history.getRedoOperation(contextA), op4); |
| assertSame(history.getUndoOperation(contextA), op1); |
| history.undo(contextA, null, null); |
| assertTrue(preUndo == 3); |
| assertTrue(postUndo == 3); |
| assertFalse("Shouldn't be able to undo in c1", history.canUndo(contextA)); |
| assertTrue("Should be able to undo in c2", history.canUndo(contextB)); |
| assertTrue("Should be able to undo in c3", history.canUndo(contextC)); |
| } |
| |
| public void testHistoryFactory() { |
| IOperationHistory anotherHistory = OperationHistoryFactory.getOperationHistory(); |
| assertNotNull(anotherHistory); |
| } |
| |
| public void testOperationChanged() { |
| history.operationChanged(op1); |
| history.operationChanged(op2); |
| history.operationChanged(new TestOperation("New op")); |
| assertTrue("should not notify about changes if not in the history", changed == 2); |
| } |
| |
| // the setup for the infamous (local conflict on top of composite and composite gets pruned) case |
| private void setup87675() throws ExecutionException { |
| // clear everything out. special setup for this test case |
| history.dispose(IOperationHistory.GLOBAL_UNDO_CONTEXT, true, true, false); |
| contextA = new ObjectUndoContext("A"); |
| contextB = new ObjectUndoContext("B"); |
| contextC = new ObjectUndoContext("C"); |
| contextW = new ObjectUndoContext("W"); |
| history.addOperationApprover(new LinearUndoEnforcer()); |
| |
| // local edits on A, B, C are added first |
| IUndoableOperation op = new TestOperation("op1a"); |
| op.addContext(contextA); |
| history.execute(op, null, null); |
| op = new TestOperation("op1b"); |
| op.addContext(contextB); |
| history.execute(op, null, null); |
| op = new TestOperation("op1c"); |
| op.addContext(contextC); |
| history.execute(op, null, null); |
| |
| // now we create the "refactoring op" which touches them all |
| op = new TestOperation("Refactoring"); |
| op.addContext(contextW); |
| op.execute(null, null); |
| refactor = new TriggeredOperations(op, history); |
| history.openOperation(refactor, IOperationHistory.EXECUTE); |
| localA = new TestOperation("op2a"); |
| localA.addContext(contextA); |
| history.execute(localA, null, null); |
| localB = new TestOperation("op2b"); |
| localB.addContext(contextB); |
| history.execute(localB, null, null); |
| localC = new TestOperation("op2c"); |
| localC.addContext(contextC); |
| history.execute(localC, null, null); |
| |
| // close off the composite |
| history.closeOperation(true, true, IOperationHistory.EXECUTE); |
| |
| // subsequent local edit to C |
| op = new TestOperation("op3c"); |
| op.addContext(contextC); |
| history.execute(op, null, null); |
| } |
| |
| public void test87675_split() throws ExecutionException { |
| setup87675(); |
| IUndoableOperation op; |
| |
| // check setup |
| op = history.getUndoOperation(contextA); |
| assertTrue("Refactoring should be next op for context A", op == refactor); |
| op = history.getUndoOperation(contextB); |
| assertTrue("Refactoring should be next op for context B", op == refactor); |
| op = history.getUndoOperation(contextW); |
| assertTrue("Refactoring should be next op for context W", op == refactor); |
| op = history.getUndoOperation(contextC); |
| assertFalse("Refactoring should not be next op for context C", op == refactor); |
| |
| // try a bogus undo |
| IStatus status = history.undo(contextW, null, null); |
| assertFalse("Undo should not be permitted due to linear conflict", status.isOK()); |
| |
| // prune the history for contextW |
| history.dispose(contextW, true, true, false); |
| |
| // refactoring op should have been broken up into pieces |
| op = history.getUndoOperation(contextA); |
| assertTrue("Local edit A should be atomic", op == localA); |
| op = history.getUndoOperation(contextB); |
| assertTrue("Local edit B should be atomic", op == localB); |
| op = history.getUndoOperation(contextC); |
| assertFalse("Local edit C should not be refactoring edit", op == localC); |
| |
| // now the refactoring C edit should be the next one |
| history.undo(contextC, null, null); |
| op = history.getUndoOperation(contextC); |
| assertTrue("Local edit C should be refactoring edit", op == localC); |
| } |
| |
| public void test87675_undoredo() throws ExecutionException { |
| setup87675(); |
| IUndoableOperation op; |
| |
| // undo the local edit to C |
| history.undo(contextC, null, null); |
| |
| // undo the refactoring operation via context C |
| history.undo(contextC, null, null); |
| |
| // check that there are no new operations in the undo list for A, B, C |
| op = history.getUndoOperation(contextC); |
| assertTrue("Local edit C should be original edit", op.getLabel().equals("op1c")); |
| |
| op = history.getUndoOperation(contextB); |
| assertTrue("Local edit B should be original edit", op.getLabel().equals("op1b")); |
| |
| op = history.getUndoOperation(contextA); |
| assertTrue("Local edit A should be original edit", op.getLabel().equals("op1a")); |
| |
| // test that the redo operation has all contexts |
| op = history.getRedoOperation(contextW); |
| assertTrue("operation should have context A", op.hasContext(contextA)); |
| assertTrue("operation should have context B", op.hasContext(contextB)); |
| assertTrue("operation should have context C", op.hasContext(contextC)); |
| |
| // now redo the operation |
| history.redo(contextA, null, null); |
| |
| // test that the next undo is our refactoring operation |
| op = history.getUndoOperation(IOperationHistory.GLOBAL_UNDO_CONTEXT); |
| assertTrue("operation should have context W", op.hasContext(contextW)); |
| |
| // undo again and check that no side effect ops were left on the undo stack |
| history.undo(contextW, null, null); |
| |
| op = history.getUndoOperation(contextC); |
| assertTrue("Local edit C should be original edit", op.getLabel().equals("op1c")); |
| |
| op = history.getUndoOperation(contextB); |
| assertTrue("Local edit B should be original edit", op.getLabel().equals("op1b")); |
| |
| op = history.getUndoOperation(contextA); |
| assertTrue("Local edit A should be original edit", op.getLabel().equals("op1a")); |
| |
| } |
| } |
