Skip to content

Package: ChangeBrokerDeleteObserver_Test

ChangeBrokerDeleteObserver_Test

nameinstructionbranchcomplexitylinemethod
ChangeBrokerDeleteObserver_Test()
M: 0 C: 3
100%
M: 0 C: 0
100%
M: 0 C: 1
100%
M: 0 C: 1
100%
M: 0 C: 1
100%
before()
M: 0 C: 9
100%
M: 0 C: 0
100%
M: 0 C: 1
100%
M: 0 C: 3
100%
M: 0 C: 1
100%
subscribePostDeleteObserver()
M: 0 C: 11
100%
M: 0 C: 0
100%
M: 0 C: 1
100%
M: 0 C: 3
100%
M: 0 C: 1
100%
subscribePreDeleteObserver()
M: 0 C: 11
100%
M: 0 C: 0
100%
M: 0 C: 1
100%
M: 0 C: 3
100%
M: 0 C: 1
100%
subscribeVetoableDeleteListener()
M: 0 C: 11
100%
M: 0 C: 0
100%
M: 0 C: 1
100%
M: 0 C: 3
100%
M: 0 C: 1
100%
testOnePostDeleteObserver()
M: 0 C: 15
100%
M: 0 C: 0
100%
M: 0 C: 1
100%
M: 0 C: 5
100%
M: 0 C: 1
100%
testOnePreDeleteObserver()
M: 0 C: 15
100%
M: 0 C: 0
100%
M: 0 C: 1
100%
M: 0 C: 5
100%
M: 0 C: 1
100%
testOneVetoableDeleteObserver()
M: 0 C: 18
100%
M: 0 C: 0
100%
M: 0 C: 1
100%
M: 0 C: 6
100%
M: 0 C: 1
100%
testUnsubscribeOnePostDeleteObserver()
M: 0 C: 19
100%
M: 0 C: 0
100%
M: 0 C: 1
100%
M: 0 C: 6
100%
M: 0 C: 1
100%
testUnsubscribeOnePreDeleteObserver()
M: 0 C: 19
100%
M: 0 C: 0
100%
M: 0 C: 1
100%
M: 0 C: 6
100%
M: 0 C: 1
100%
testUnsubscribeOneVetoableDeleteObserver()
M: 0 C: 22
100%
M: 0 C: 0
100%
M: 0 C: 1
100%
M: 0 C: 7
100%
M: 0 C: 1
100%

Coverage

1: /*******************************************************************************
2: * Copyright (c) 2011-2015 EclipseSource Muenchen GmbH and others.
3: *
4: * All rights reserved. This program and the accompanying materials
5: * are made available under the terms of the Eclipse Public License 2.0
6: * which accompanies this distribution, and is available at
7: * https://www.eclipse.org/legal/epl-2.0/
8: *
9: * SPDX-License-Identifier: EPL-2.0
10: *
11: * Contributors:
12: * Jonas - initial API and implementation
13: ******************************************************************************/
14: package org.eclipse.emf.ecp.changebroker.test;
15:
16: import static org.junit.Assert.assertFalse;
17: import static org.junit.Assert.assertSame;
18: import static org.junit.Assert.assertTrue;
19:
20: import org.eclipse.emf.ecore.EObject;
21: import org.eclipse.emf.ecp.changebroker.internal.ChangeBrokerImpl;
22: import org.eclipse.emf.ecp.changebroker.spi.PostDeleteObserver;
23: import org.eclipse.emf.ecp.changebroker.spi.PreDeleteObserver;
24: import org.eclipse.emf.ecp.changebroker.spi.VetoableDeleteObserver;
25: import org.eclipse.emf.emfstore.bowling.BowlingFactory;
26: import org.junit.Before;
27: import org.junit.Test;
28:
29: /**
30: * @author Jonas
31: *
32: */
33: public class ChangeBrokerDeleteObserver_Test {
34:
35:         private ChangeBrokerImpl broker;
36:         private EObject receivedPreDeleteObject;
37:
38:         @Before
39:         public void before() {
40:                 broker = new ChangeBrokerImpl();
41:                 receivedPreDeleteObject = null;
42:         }
43:
44:         @Test
45:         public void testOnePreDeleteObserver() {
46:                 final EObject toBeDeleted = BowlingFactory.eINSTANCE.createTournament();
47:                 subscribePreDeleteObserver();
48:                 broker.notifyPreDelete(toBeDeleted);
49:                 assertSame(toBeDeleted, receivedPreDeleteObject);
50:
51:         }
52:
53:         @Test
54:         public void testUnsubscribeOnePreDeleteObserver() {
55:                 final EObject toBeDeleted = BowlingFactory.eINSTANCE.createTournament();
56:                 final PreDeleteObserver predeleteObserver = subscribePreDeleteObserver();
57:                 broker.unsubsribe(predeleteObserver);
58:                 broker.notifyPreDelete(toBeDeleted);
59:                 assertSame(null, receivedPreDeleteObject);
60:
61:         }
62:
63:         private PreDeleteObserver subscribePreDeleteObserver() {
64:                 final PreDeleteObserver preDeleteObserver = new PreDeleteObserver() {
65:
66:                         @Override
67:                         public void preDelete(EObject objectToBeDeleted) {
68:                                 receivedPreDeleteObject = objectToBeDeleted;
69:
70:                         }
71:                 };
72:                 broker.subscribe(preDeleteObserver);
73:                 return preDeleteObserver;
74:         }
75:
76:         @Test
77:         public void testOnePostDeleteObserver() {
78:                 final EObject toBeDeleted = BowlingFactory.eINSTANCE.createTournament();
79:                 subscribePostDeleteObserver();
80:                 broker.notifyPostDelete(toBeDeleted);
81:                 assertSame(toBeDeleted, receivedPreDeleteObject);
82:
83:         }
84:
85:         @Test
86:         public void testUnsubscribeOnePostDeleteObserver() {
87:                 final EObject toBeDeleted = BowlingFactory.eINSTANCE.createTournament();
88:                 final PostDeleteObserver postdeleteObserver = subscribePostDeleteObserver();
89:                 broker.unsubsribe(postdeleteObserver);
90:                 broker.notifyPostDelete(toBeDeleted);
91:                 assertSame(null, receivedPreDeleteObject);
92:
93:         }
94:
95:         private PostDeleteObserver subscribePostDeleteObserver() {
96:                 final PostDeleteObserver postDeleteObserver = new PostDeleteObserver() {
97:
98:                         @Override
99:                         public void postDelete(EObject objectToBeDeleted) {
100:                                 receivedPreDeleteObject = objectToBeDeleted;
101:
102:                         }
103:                 };
104:                 broker.subscribe(postDeleteObserver);
105:                 return postDeleteObserver;
106:         }
107:
108:         @Test
109:         public void testOneVetoableDeleteObserver() {
110:                 final EObject toBeDeleted = BowlingFactory.eINSTANCE.createTournament();
111:                 subscribeVetoableDeleteListener();
112:                 final boolean canDelete = broker.canDelete(toBeDeleted);
113:                 assertFalse(canDelete);
114:                 assertSame(toBeDeleted, receivedPreDeleteObject);
115:
116:         }
117:
118:         @Test
119:         public void testUnsubscribeOneVetoableDeleteObserver() {
120:                 final EObject toBeDeleted = BowlingFactory.eINSTANCE.createTournament();
121:                 final VetoableDeleteObserver vetoableDeleteListener = subscribeVetoableDeleteListener();
122:                 broker.unsubsribe(vetoableDeleteListener);
123:                 final boolean canDelete = broker.canDelete(toBeDeleted);
124:                 assertTrue(canDelete);
125:                 assertSame(null, receivedPreDeleteObject);
126:
127:         }
128:
129:         private VetoableDeleteObserver subscribeVetoableDeleteListener() {
130:                 final VetoableDeleteObserver vetoableDeleteObserver = new VetoableDeleteObserver() {
131:
132:                         @Override
133:                         public boolean canDelete(EObject objectToBeDeleted) {
134:                                 receivedPreDeleteObject = objectToBeDeleted;
135:                                 return false;
136:                         }
137:                 };
138:                 broker.subscribe(vetoableDeleteObserver);
139:                 return vetoableDeleteObserver;
140:         }
141:
142: }