![[Jenkins]](/ecp/static/e8bbdb94/images/svgs/logo.svg){kind=logo}
Package: ChildrenDescriptorExtension_PTest$1
ChildrenDescriptorExtension_PTest$1
| name | instruction | branch | complexity | line | method | ||||||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| matchesSafely(CommandParameter) |
|
|
|
|
|
||||||||||||||||||||
| {...} |
|
|
|
|
|
||||||||||||||||||||
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: * Jonas - initial API and implementation
13: * Christian W. Damus - bug 530900
14: ******************************************************************************/
15: package org.eclipse.emf.ecp.view.model.integrationtest;
16:
17: import static org.hamcrest.CoreMatchers.hasItem;
18: import static org.junit.Assert.assertEquals;
19: import static org.junit.Assert.assertThat;
20:
21: import java.util.ArrayList;
22: import java.util.Collection;
23: import java.util.List;
24:
25: import org.eclipse.emf.common.command.BasicCommandStack;
26: import org.eclipse.emf.common.util.URI;
27: import org.eclipse.emf.ecore.EClass;
28: import org.eclipse.emf.ecore.EObject;
29: import org.eclipse.emf.ecore.resource.Resource;
30: import org.eclipse.emf.ecore.resource.ResourceSet;
31: import org.eclipse.emf.ecore.util.EcoreUtil;
32: import org.eclipse.emf.ecp.common.spi.ChildrenDescriptorCollector;
33: import org.eclipse.emf.ecp.view.spi.categorization.model.VCategorizationPackage;
34: import org.eclipse.emf.ecp.view.spi.compoundcontrol.model.VCompoundcontrolPackage;
35: import org.eclipse.emf.ecp.view.spi.custom.model.VCustomPackage;
36: import org.eclipse.emf.ecp.view.spi.group.model.VGroupPackage;
37: import org.eclipse.emf.ecp.view.spi.groupedgrid.model.VGroupedGridPackage;
38: import org.eclipse.emf.ecp.view.spi.horizontal.model.VHorizontalPackage;
39: import org.eclipse.emf.ecp.view.spi.label.model.VLabelPackage;
40: import org.eclipse.emf.ecp.view.spi.model.VViewPackage;
41: import org.eclipse.emf.ecp.view.spi.rule.model.RulePackage;
42: import org.eclipse.emf.ecp.view.spi.section.model.VSectionPackage;
43: import org.eclipse.emf.ecp.view.spi.stack.model.VStackPackage;
44: import org.eclipse.emf.ecp.view.spi.table.model.VTablePackage;
45: import org.eclipse.emf.ecp.view.spi.vertical.model.VVerticalPackage;
46: import org.eclipse.emf.ecp.view.spi.viewproxy.model.VViewproxyPackage;
47: import org.eclipse.emf.ecp.view.treemasterdetail.model.VTreeMasterDetailPackage;
48: import org.eclipse.emf.edit.command.CommandParameter;
49: import org.eclipse.emf.edit.domain.AdapterFactoryEditingDomain;
50: import org.eclipse.emf.edit.provider.ComposedAdapterFactory;
51: import org.hamcrest.CustomTypeSafeMatcher;
52: import org.hamcrest.Matcher;
53: import org.junit.Test;
54:
55: @SuppressWarnings("restriction")
56: public class ChildrenDescriptorExtension_PTest {
57:
58: /**
59: * Needs to be adapted after refactoring
60: * These are the counts for a fully integrated model with all elements
61: */
62: // showrule, enablerule, span, datetimedisplay
63: private static final int ATTACHMENT_CHILD_COUNT = 4;
64: private static final int RENDERABLE_CHILD_COUNT = 0 + ATTACHMENT_CHILD_COUNT;
65: private static final int COMPOSITE_CHILD_COUNT = RENDERABLE_CHILD_COUNT;
66: private static final int ABSTRACTCATEGORIZATION_CHILD_COUNT = RENDERABLE_CHILD_COUNT + 1;
67: private static final int NUMBER_OF_MAIN_COMPOSITES = 1;
68: // label, table, vertical, horizontal, group, groupedgrid, categorizationElement, custom control, section,
69: // stack,viewproxy, compoundcontrol, treemasterdetail
70: private static final int NUMBER_OF_EXTERNAL_COMPOSITES = 13;
71: // DMRs should not be creatable via child extender. Existing Dmrs: DMR, VFeaturePathDR, VPredefinedDR,
72: // VTableDR,KEYDMR, MAPPINGDMR,IndexDMR
73: private static final int DOMAINMODELREFERENCE_COUNT = 0;
74: private static final int NUMBER_OF_COMPOSITES = NUMBER_OF_MAIN_COMPOSITES + NUMBER_OF_EXTERNAL_COMPOSITES;
75: // categorization, category
76: private static final int NUMBER_OF_CATEGORIZATIONS = 2;
77: private static final int CATEGORIZATION_CHILD_COUNT = ABSTRACTCATEGORIZATION_CHILD_COUNT
78: + NUMBER_OF_CATEGORIZATIONS;
79: private static final int COMPOSITECOLLECTION_CHILD_COUNT = COMPOSITE_CHILD_COUNT + NUMBER_OF_COMPOSITES;
80: private static final int VIEW_CHILD_COUNT = NUMBER_OF_COMPOSITES + RENDERABLE_CHILD_COUNT;
81: // Neither the main dmr nor the value dmr should be returned as children
82: private static final int LEAFCONDITION_CHILD_COUNT = 0;
83: private static final int CATEGORY_CHILD_COUNT = NUMBER_OF_COMPOSITES + ABSTRACTCATEGORIZATION_CHILD_COUNT;
84:
85: private static final int CONTROL_CHILD_COUNT = COMPOSITE_CHILD_COUNT + DOMAINMODELREFERENCE_COUNT;
86: private static final int TABLECONTROL_CHILD_COUNT = CONTROL_CHILD_COUNT + 3;
87: private static final int ACTION_CHILD_COUNT = 0;
88: private static final int GROUPEDGRID_CHILD_COUNT = RENDERABLE_CHILD_COUNT + 1;
89: private static final int GRIDEDGROUP_CHILD_COUNT = 1;
90: // TODO: Should be not - NUMBER_OF_EXTERNAL_COMPOSITES are missing
91: // TODO: upper hierarchy is missing, can't find children
92: private static final int GRIDEDGROUPROW_CHILD_COUNT = NUMBER_OF_COMPOSITES - NUMBER_OF_EXTERNAL_COMPOSITES + 1;
93: private static final int GRIDEDGROUPSPAN_CHILD_COUNT = 0;
94:
95: private static final ChildrenDescriptorCollector DESCRIPTOR_COLLECTOR = new ChildrenDescriptorCollector();
96:
97: @Test
98: public void testGroupedGridChildDescriptors() {
99: final int size = getChildrenSize(VGroupedGridPackage.eINSTANCE.getGroupedGrid());
100: assertEquals(GROUPEDGRID_CHILD_COUNT, size);
101: }
102:
103: @Test
104: public void testGridedGroupChildDescriptors() {
105: final int size = getChildrenSize(VGroupedGridPackage.eINSTANCE.getGroup());
106: assertEquals(GRIDEDGROUP_CHILD_COUNT, size);
107: }
108:
109: @Test
110: public void testGridedGroupRowChildDescriptors() {
111: final int size = getChildrenSize(VGroupedGridPackage.eINSTANCE.getRow());
112: assertEquals(GRIDEDGROUPROW_CHILD_COUNT, size);
113: }
114:
115: @Test
116: public void testGridedSpanChildDescriptors() {
117: final int size = getChildrenSize(VGroupedGridPackage.eINSTANCE.getSpan());
118: assertEquals(GRIDEDGROUPSPAN_CHILD_COUNT, size);
119: }
120:
121: @Test
122: public void testViewChildDescriptors() {
123: final int size = getChildrenSize(VViewPackage.eINSTANCE.getView());
124: assertEquals(VIEW_CHILD_COUNT, size);
125: }
126:
127: /**
128: * Class is abstract, Exception expected
129: */
130: @Test(expected = IllegalArgumentException.class)
131: public void testAbstractCategorizationChildDescriptors() {
132: getChildrenSize(VCategorizationPackage.eINSTANCE.getAbstractCategorization());
133: }
134:
135: /**
136: * Class is abstract, Exception expected
137: */
138: @Test(expected = IllegalArgumentException.class)
139: public void testRuleChildDescriptors() {
140: getChildrenSize(RulePackage.eINSTANCE.getRule());
141: }
142:
143: @Test
144: public void testShowRuleChildDescriptors() {
145: assertThat(getChildDescriptors(RulePackage.Literals.SHOW_RULE),
146: hasItem(isChildDescriptor(RulePackage.Literals.IS_PROXY_CONDITION)));
147: }
148:
149: @Test
150: public void testEnableRuleChildDescriptors() {
151: assertThat(getChildDescriptors(RulePackage.Literals.ENABLE_RULE),
152: hasItem(isChildDescriptor(RulePackage.Literals.IS_PROXY_CONDITION)));
153: }
154:
155: /**
156: * Class is abstract, Exception expected
157: */
158: @Test(expected = IllegalArgumentException.class)
159: public void testConditionChildDescriptors() {
160: getChildrenSize(RulePackage.eINSTANCE.getCondition());
161: }
162:
163: @Test
164: public void testLeafConditionChildDescriptors() {
165: final int size = getChildrenSize(RulePackage.eINSTANCE.getLeafCondition());
166: assertEquals(LEAFCONDITION_CHILD_COUNT, size);
167: }
168:
169: @Test
170: public void testOrConditionChildDescriptors() {
171: assertThat(getChildDescriptors(RulePackage.Literals.OR_CONDITION),
172: hasItem(isChildDescriptor(RulePackage.Literals.IS_PROXY_CONDITION)));
173: }
174:
175: @Test
176: public void testAndConditionChildDescriptors() {
177: assertThat(getChildDescriptors(RulePackage.Literals.AND_CONDITION),
178: hasItem(isChildDescriptor(RulePackage.Literals.IS_PROXY_CONDITION)));
179: }
180:
181: @Test
182: public void testCategorizationChildDescriptors() {
183: final int size = getChildrenSize(VCategorizationPackage.eINSTANCE.getCategorization());
184: assertEquals(CATEGORIZATION_CHILD_COUNT, size);
185: }
186:
187: @Test
188: public void testCategoryChildDescriptors() {
189: final int size = getChildrenSize(VCategorizationPackage.eINSTANCE.getCategory());
190: assertEquals(CATEGORY_CHILD_COUNT, size);
191: }
192:
193: /**
194: * Class is abstract, Exception expected
195: */
196: @Test(expected = IllegalArgumentException.class)
197: public void testCompositeChildDescriptors() {
198: getChildrenSize(VViewPackage.eINSTANCE.getContainedElement());
199: }
200:
201: @Test
202: public void testControlChildDescriptors() {
203: final int size = getChildrenSize(VViewPackage.eINSTANCE.getControl());
204: assertEquals(CONTROL_CHILD_COUNT, size);
205: }
206:
207: @Test
208: public void testTableControlChildDescriptors() {
209: final int size = getChildrenSize(VTablePackage.eINSTANCE.getTableControl());
210: assertEquals(TABLECONTROL_CHILD_COUNT, size);
211: }
212:
213: /**
214: * Class is abstract, Exception expected
215: */
216: @Test(expected = IllegalArgumentException.class)
217: public void testCompositeCollectionDescriptors() {
218: getChildrenSize(VViewPackage.eINSTANCE.getContainer());
219: }
220:
221: @Test
222: public void testGroupDescriptors() {
223: final int size = getChildrenSize(VGroupPackage.eINSTANCE.getGroup());
224: assertEquals(COMPOSITECOLLECTION_CHILD_COUNT, size);
225: }
226:
227: @Test
228: public void testHorizontalDescriptors() {
229: final int size = getChildrenSize(VHorizontalPackage.eINSTANCE.getHorizontalLayout());
230: assertEquals(COMPOSITECOLLECTION_CHILD_COUNT, size);
231: }
232:
233: @Test
234: public void testVerticalDescriptors() {
235: final int size = getChildrenSize(VVerticalPackage.eINSTANCE.getVerticalLayout());
236: assertEquals(COMPOSITECOLLECTION_CHILD_COUNT, size);
237: }
238:
239: @Test
240: public void testLabelDescriptors() {
241: final int size = getChildrenSize(VLabelPackage.eINSTANCE.getLabel());
242: assertEquals(ATTACHMENT_CHILD_COUNT, size);
243: }
244:
245: @Test
246: public void testCustomControlDescriptors() {
247: final int size = getChildrenSize(VCustomPackage.eINSTANCE.getCustomControl());
248: assertEquals(CONTROL_CHILD_COUNT, size);
249: }
250:
251: @Test
252: public void testSectionDescriptors() {
253: final int size = getChildrenSize(VSectionPackage.eINSTANCE.getSection());
254: assertEquals(COMPOSITECOLLECTION_CHILD_COUNT, size);
255: }
256:
257: @Test
258: public void testSectionAreaDescriptors() {
259: final int size = getChildrenSize(VSectionPackage.eINSTANCE.getSectionedArea());
260: // +1 because of section
261: assertEquals(ATTACHMENT_CHILD_COUNT + 1, size);
262: }
263:
264: @Test
265: public void testStackItemDescriptors() {
266: final int size = getChildrenSize(VStackPackage.eINSTANCE.getStackItem());
267: // -1 because of treemasterdetail as it only can be added to containedContainer
268: assertEquals(COMPOSITECOLLECTION_CHILD_COUNT - 1, size);
269: }
270:
271: @Test
272: public void testStackLayoutDescriptors() {
273: final int size = getChildrenSize(VStackPackage.eINSTANCE.getStackLayout());
274: // +1 for stack items
275: assertEquals(ATTACHMENT_CHILD_COUNT + 1, size);
276: }
277:
278: @Test
279: public void testViewProxyDescriptors() {
280: final int size = getChildrenSize(VViewproxyPackage.eINSTANCE.getViewProxy());
281: assertEquals(ATTACHMENT_CHILD_COUNT, size);
282: }
283:
284: @Test
285: public void testCompoundControlDescriptors() {
286: final int size = getChildrenSize(VCompoundcontrolPackage.eINSTANCE.getCompoundControl());
287: // +1 because of vcontrol TODO table and custom control is missing
288: assertEquals(ATTACHMENT_CHILD_COUNT + DOMAINMODELREFERENCE_COUNT + 1, size);
289: }
290:
291: @Test
292: public void testTreeMasterDetailDescriptors() {
293: final int size = getChildrenSize(VTreeMasterDetailPackage.eINSTANCE.getTreeMasterDetail());
294: // +1 because of VView
295: assertEquals(ATTACHMENT_CHILD_COUNT + 1, size);
296: }
297:
298: /**
299: * Class is abstract, Exception expected
300: */
301: @Test(expected = IllegalArgumentException.class)
302: public void testRenderableDescriptors() {
303: getChildrenSize(VViewPackage.eINSTANCE.getElement());
304: }
305:
306: @Test
307: public void testActionDescriptors() {
308: final int size = getChildrenSize(VCategorizationPackage.eINSTANCE.getAction());
309: assertEquals(ACTION_CHILD_COUNT, size);
310: }
311:
312: /**
313: * @param category
314: * @return
315: */
316: static int getChildrenSize(EClass eClass) {
317: final EObject eObject = getEObjectWithResource(eClass);
318: return DESCRIPTOR_COLLECTOR.getDescriptors(eObject).size();
319: }
320:
321: static Collection<CommandParameter> getChildDescriptors(EClass eClass) {
322: final EObject eObject = getEObjectWithResource(eClass);
323: final Collection<?> collected = DESCRIPTOR_COLLECTOR.getDescriptors(eObject);
324: final List<CommandParameter> result = new ArrayList<CommandParameter>(collected.size());
325: for (final Object next : collected) {
326: if (next instanceof CommandParameter) {
327: result.add((CommandParameter) next);
328: }
329: }
330: return result;
331: }
332:
333: private static EObject getEObjectWithResource(EClass eClass) {
334: final EObject eObject = EcoreUtil.create(eClass);
335: final AdapterFactoryEditingDomain adapterFactoryEditingDomain = new AdapterFactoryEditingDomain(
336: new ComposedAdapterFactory(ComposedAdapterFactory.Descriptor.Registry.INSTANCE),
337: new BasicCommandStack());
338: final ResourceSet resourceSet = adapterFactoryEditingDomain.getResourceSet();
339: final Resource virtualResource = resourceSet.createResource(URI.createURI("VIRTUAL_URI"));
340: virtualResource.getContents().add(eObject);
341: return eObject;
342: }
343:
344: /**
345: * Obtain a matcher for {@link CommandParameter}s creating children of the given class.
346: *
347: * @param childClass the child class to match
348: * @return the matcher
349: */
350: Matcher<CommandParameter> isChildDescriptor(final EClass childClass) {
351: return new CustomTypeSafeMatcher<CommandParameter>("child of type " + childClass.getName()) {
352: @Override
353: public boolean matchesSafely(CommandParameter item) {
354: return childClass.isInstance(item.getEValue());
355: }
356: };
357: }
358: }