Skip to content

Package: GenerateControlsHandler_Test

GenerateControlsHandler_Test

nameinstructionbranchcomplexitylinemethod
GenerateControlsHandler_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%
cleanup(Resource)
M: 0 C: 14
100%
M: 0 C: 0
100%
M: 0 C: 1
100%
M: 0 C: 5
100%
M: 0 C: 1
100%
getResource()
M: 0 C: 42
100%
M: 0 C: 0
100%
M: 0 C: 1
100%
M: 0 C: 10
100%
M: 0 C: 1
100%
setUp()
M: 0 C: 6
100%
M: 0 C: 0
100%
M: 0 C: 1
100%
M: 0 C: 2
100%
M: 0 C: 1
100%
testInnerExecuteOnContainer()
M: 0 C: 129
100%
M: 0 C: 0
100%
M: 0 C: 1
100%
M: 0 C: 26
100%
M: 0 C: 1
100%
testInnerExecuteOnContainerNoParent()
M: 0 C: 16
100%
M: 0 C: 0
100%
M: 0 C: 1
100%
M: 0 C: 4
100%
M: 0 C: 1
100%
testInnerExecuteOnElement()
M: 0 C: 17
100%
M: 0 C: 0
100%
M: 0 C: 1
100%
M: 0 C: 4
100%
M: 0 C: 1
100%
testInnerExecuteOnView()
M: 0 C: 109
100%
M: 0 C: 0
100%
M: 0 C: 1
100%
M: 0 C: 22
100%
M: 0 C: 1
100%
testInnerExecuteOnViewNoFeatures()
M: 0 C: 21
100%
M: 0 C: 0
100%
M: 0 C: 1
100%
M: 0 C: 5
100%
M: 0 C: 1
100%
testShouldShow()
M: 0 C: 51
100%
M: 0 C: 0
100%
M: 0 C: 1
100%
M: 0 C: 12
100%
M: 0 C: 1
100%

Coverage

1: /*******************************************************************************
2: * Copyright (c) 2011-2018 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: * Lucas Koehler - initial API and implementation
13: ******************************************************************************/
14: package org.eclipse.emf.ecp.view.internal.editor.handler;
15:
16: import static org.junit.Assert.assertEquals;
17: import static org.junit.Assert.assertFalse;
18: import static org.junit.Assert.assertSame;
19: import static org.junit.Assert.assertTrue;
20: import static org.mockito.Mockito.mock;
21: import static org.mockito.Mockito.when;
22:
23: import java.util.Collections;
24: import java.util.Set;
25:
26: import org.eclipse.emf.common.command.BasicCommandStack;
27: import org.eclipse.emf.common.notify.Adapter;
28: import org.eclipse.emf.common.util.BasicEList;
29: import org.eclipse.emf.common.util.EList;
30: import org.eclipse.emf.common.util.URI;
31: import org.eclipse.emf.ecore.EStructuralFeature;
32: import org.eclipse.emf.ecore.EcorePackage;
33: import org.eclipse.emf.ecore.resource.Resource;
34: import org.eclipse.emf.ecore.resource.ResourceSet;
35: import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl;
36: import org.eclipse.emf.ecore.xmi.impl.XMIResourceFactoryImpl;
37: import org.eclipse.emf.ecp.view.internal.editor.handler.GenerateControlsHandler.CallbackFeatureSupplier;
38: import org.eclipse.emf.ecp.view.spi.model.VContainedContainer;
39: import org.eclipse.emf.ecp.view.spi.model.VContainedElement;
40: import org.eclipse.emf.ecp.view.spi.model.VContainer;
41: import org.eclipse.emf.ecp.view.spi.model.VControl;
42: import org.eclipse.emf.ecp.view.spi.model.VElement;
43: import org.eclipse.emf.ecp.view.spi.model.VFeaturePathDomainModelReference;
44: import org.eclipse.emf.ecp.view.spi.model.VView;
45: import org.eclipse.emf.edit.domain.AdapterFactoryEditingDomain;
46: import org.eclipse.emf.edit.provider.ComposedAdapterFactory;
47: import org.junit.Before;
48: import org.junit.Test;
49: import org.mockito.Mockito;
50:
51: /**
52: * JUnit tests for {@link GenerateControlsHandler}.
53: *
54: * @author Lucas Koehler
55: *
56: */
57: public class GenerateControlsHandler_Test {
58:         private GenerateControlsHandler controlsHandler;
59:
60:         @Before
61:         public void setUp() {
62:                 controlsHandler = new GenerateControlsHandler();
63:         }
64:
65:         @Test
66:         public void testShouldShow() {
67:                 final VElement element = mock(VElement.class);
68:                 final VControl control = mock(VControl.class);
69:                 final VContainer container = mock(VContainer.class);
70:                 final VContainedContainer containedContainer = mock(VContainedContainer.class);
71:                 final VView view = mock(VView.class);
72:
73:                 assertFalse(controlsHandler.shouldShow(null));
74:                 assertFalse(controlsHandler.shouldShow(element));
75:                 assertFalse(controlsHandler.shouldShow(control));
76:                 assertTrue(controlsHandler.shouldShow(container));
77:                 assertTrue(controlsHandler.shouldShow(containedContainer));
78:                 assertTrue(controlsHandler.shouldShow(view));
79:         }
80:
81:         @Test
82:         public void testInnerExecuteOnView() {
83:                 final EStructuralFeature suppliedFeature = EcorePackage.eINSTANCE.getENamedElement_Name();
84:                 final CallbackFeatureSupplier featureSupplier = new CallbackFeatureSupplier() {
85:
86:                         @Override
87:                         public Set<EStructuralFeature> get(VView view) {
88:                                 return Collections.singleton(suppliedFeature);
89:                         }
90:                 };
91:
92:                 final Resource resource = getResource();
93:                 final VView vView = mock(VView.class);
94:                 final EList<Adapter> adapters = new BasicEList<Adapter>();
95:                 when(vView.eAdapters()).thenReturn(adapters);
96:                 when(vView.eResource()).thenReturn(resource);
97:                 when(vView.getRootEClass()).thenReturn(EcorePackage.eINSTANCE.getEClass());
98:                 final EList<VContainedElement> children = new BasicEList<VContainedElement>();
99:                 when(vView.getChildren()).thenReturn(children);
100:
101:                 controlsHandler.execute(vView, featureSupplier);
102:
103:                 Mockito.inOrder(vView).verify(vView, Mockito.times(1)).getChildren();
104:                 assertEquals(1, children.size());
105:                 assertTrue(VControl.class.isInstance(children.get(0)));
106:                 final VControl control = VControl.class.cast(children.get(0));
107:                 assertTrue(VFeaturePathDomainModelReference.class.isInstance(control.getDomainModelReference()));
108:                 final VFeaturePathDomainModelReference domainModelReference = VFeaturePathDomainModelReference.class
109:                         .cast(control.getDomainModelReference());
110:                 assertSame(suppliedFeature, domainModelReference.getDomainModelEFeature());
111:                 assertTrue(domainModelReference.getDomainModelEReferencePath().isEmpty());
112:                 cleanup(resource);
113:         }
114:
115:         @Test
116:         public void testInnerExecuteOnViewNoFeatures() {
117:                 final CallbackFeatureSupplier featureSupplier = new CallbackFeatureSupplier() {
118:
119:                         @Override
120:                         public Set<EStructuralFeature> get(VView view) {
121:                                 return Collections.emptySet();
122:                         }
123:                 };
124:
125:                 final VView vView = mock(VView.class);
126:
127:                 controlsHandler.execute(vView, featureSupplier);
128:
129:                 Mockito.verify(vView, Mockito.never()).getChildren();
130:         }
131:
132:         @Test
133:         public void testInnerExecuteOnElement() {
134:
135:                 final VContainedElement vContainedElement = mock(VContainedElement.class);
136:
137:                 controlsHandler.execute(vContainedElement, null);
138:
139:                 Mockito.verifyZeroInteractions(vContainedElement);
140:
141:         }
142:
143:         @Test
144:         public void testInnerExecuteOnContainerNoParent() {
145:
146:                 final VContainer vContainedElement = mock(VContainer.class);
147:
148:                 controlsHandler.execute(vContainedElement, null);
149:
150:                 Mockito.verify(vContainedElement, Mockito.never()).getChildren();
151:
152:         }
153:
154:         @Test
155:         public void testInnerExecuteOnContainer() {
156:
157:                 final EStructuralFeature suppliedFeature = EcorePackage.eINSTANCE.getENamedElement_Name();
158:                 final CallbackFeatureSupplier featureSupplier = new CallbackFeatureSupplier() {
159:
160:                         @Override
161:                         public Set<EStructuralFeature> get(VView view) {
162:                                 return Collections.singleton(suppliedFeature);
163:                         }
164:                 };
165:
166:                 final Resource resource = getResource();
167:                 final VView vView = mock(VView.class);
168:                 final EList<Adapter> adapters = new BasicEList<Adapter>();
169:                 when(vView.eAdapters()).thenReturn(adapters);
170:                 when(vView.eResource()).thenReturn(resource);
171:                 when(vView.getRootEClass()).thenReturn(EcorePackage.eINSTANCE.getEClass());
172:                 final EList<VContainedElement> viewChildren = new BasicEList<VContainedElement>();
173:                 when(vView.getChildren()).thenReturn(viewChildren);
174:
175:                 final VContainer vContainer = mock(VContainer.class);
176:                 final EList<VContainedElement> children = new BasicEList<VContainedElement>();
177:                 when(vContainer.getChildren()).thenReturn(children);
178:                 when(vContainer.eContainer()).thenReturn(vView);
179:
180:                 controlsHandler.execute(vContainer, featureSupplier);
181:
182:                 Mockito.inOrder(vContainer).verify(vContainer, Mockito.times(1)).getChildren();
183:                 assertEquals(1, children.size());
184:                 assertTrue(VControl.class.isInstance(children.get(0)));
185:                 final VControl control = VControl.class.cast(children.get(0));
186:                 assertTrue(VFeaturePathDomainModelReference.class.isInstance(control.getDomainModelReference()));
187:                 final VFeaturePathDomainModelReference domainModelReference = VFeaturePathDomainModelReference.class
188:                         .cast(control.getDomainModelReference());
189:                 assertSame(suppliedFeature, domainModelReference.getDomainModelEFeature());
190:                 assertTrue(domainModelReference.getDomainModelEReferencePath().isEmpty());
191:                 cleanup(resource);
192:         }
193:
194:         private Resource getResource() {
195:                 final ResourceSet rs = new ResourceSetImpl();
196:                 final ComposedAdapterFactory adapterFactory = new ComposedAdapterFactory(
197:                         ComposedAdapterFactory.Descriptor.Registry.INSTANCE);
198:                 final AdapterFactoryEditingDomain domain = new AdapterFactoryEditingDomain(
199:                         adapterFactory,
200:                         new BasicCommandStack(), rs);
201:                 rs.eAdapters().add(new AdapterFactoryEditingDomain.EditingDomainProvider(domain));
202:                 rs.getResourceFactoryRegistry().getExtensionToFactoryMap().put("*", new XMIResourceFactoryImpl());
203:                 final Resource resource = rs.createResource(URI.createURI("VIRTAUAL_URI")); //$NON-NLS-1$
204:                 return resource;
205:         }
206:
207:         private void cleanup(Resource resource) {
208:                 final AdapterFactoryEditingDomain editingDomain = (AdapterFactoryEditingDomain) ((AdapterFactoryEditingDomain.EditingDomainProvider) resource
209:                         .getResourceSet()
210:                         .eAdapters().get(0)).getEditingDomain();
211:                 ((ComposedAdapterFactory) editingDomain.getAdapterFactory()).dispose();
212:         }
213: }