![[Jenkins]](/ecp/static/e8bbdb94/images/svgs/logo.svg){kind=logo}
Package: MappingDMRValidation_Test$DiagnosticInfo
MappingDMRValidation_Test$DiagnosticInfo
| name | instruction | branch | complexity | line | method | ||||||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| MappingDMRValidation_Test.DiagnosticInfo(MappingDMRValidation_Test, int, EObject, EStructuralFeature) |
|
|
|
|
|
||||||||||||||||||||
| sameData(Diagnostic) |
|
|
|
|
|
||||||||||||||||||||
Coverage
1: /*******************************************************************************
2: * Copyright (c) 2011-2014 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: * jfaltermeier - initial API and implementation
13: ******************************************************************************/
14: package org.eclipse.emf.ecp.view.mappingdmr.model.test;
15:
16: import static org.junit.Assert.assertEquals;
17: import static org.junit.Assert.assertFalse;
18: import static org.junit.Assert.assertTrue;
19: import static org.junit.Assert.fail;
20:
21: import java.util.ArrayList;
22: import java.util.Arrays;
23: import java.util.Collection;
24: import java.util.Iterator;
25: import java.util.LinkedHashMap;
26: import java.util.LinkedHashSet;
27: import java.util.List;
28: import java.util.Set;
29:
30: import org.eclipse.emf.common.util.BasicDiagnostic;
31: import org.eclipse.emf.common.util.Diagnostic;
32: import org.eclipse.emf.ecore.EObject;
33: import org.eclipse.emf.ecore.EStructuralFeature;
34: import org.eclipse.emf.ecore.EValidator;
35: import org.eclipse.emf.ecp.view.mapping.test.example.ExamplePackage;
36: import org.eclipse.emf.ecp.view.spi.mappingdmr.model.VMappingDomainModelReference;
37: import org.eclipse.emf.ecp.view.spi.mappingdmr.model.VMappingdmrFactory;
38: import org.eclipse.emf.ecp.view.spi.mappingdmr.model.VMappingdmrPackage;
39: import org.eclipse.emf.ecp.view.spi.model.VControl;
40: import org.eclipse.emf.ecp.view.spi.model.VFeaturePathDomainModelReference;
41: import org.eclipse.emf.ecp.view.spi.model.VView;
42: import org.eclipse.emf.ecp.view.spi.model.VViewFactory;
43: import org.eclipse.emf.ecp.view.spi.model.VViewPackage;
44: import org.eclipse.emf.ecp.view.spi.model.util.ViewValidator;
45: import org.junit.Before;
46: import org.junit.Test;
47: import org.junit.runner.RunWith;
48: import org.junit.runners.Parameterized;
49: import org.junit.runners.Parameterized.Parameters;
50:
51: /**
52: * @author jfaltermeier
53: *
54: */
55: @RunWith(Parameterized.class)
56: public class MappingDMRValidation_Test {
57: private VView view;
58: private VControl control;
59: private VMappingDomainModelReference mapping;
60:
61: private EValidator validator;
62: private BasicDiagnostic chain;
63: private LinkedHashMap<Object, Object> context;
64: private final Boolean createChain;
65: private VFeaturePathDomainModelReference target;
66:
67: public MappingDMRValidation_Test(Boolean createChain) {
68: this.createChain = createChain;
69: }
70:
71: @Parameters
72: public static Collection<Object[]> data() {
73: // run all tests once with a diagnostic chain and once without
74: final List<Object[]> parameters = new ArrayList<Object[]>();
75: parameters.add(new Object[] { true });
76: parameters.add(new Object[] { false });
77: return parameters;
78: }
79:
80: @SuppressWarnings("restriction")
81: @Before
82: public void before() {
83: view = VViewFactory.eINSTANCE.createView();
84: view.setRootEClass(ExamplePackage.eINSTANCE.getRoot());
85: control = VViewFactory.eINSTANCE.createControl();
86: view.getChildren().add(control);
87: mapping = VMappingdmrFactory.eINSTANCE.createMappingDomainModelReference();
88: mapping.setMappedClass(ExamplePackage.eINSTANCE.getChild());
89: target = VViewFactory.eINSTANCE.createFeaturePathDomainModelReference();
90: mapping.setDomainModelReference(target);
91: control.setDomainModelReference(mapping);
92:
93: validator = org.eclipse.emf.ecp.view.spi.mappingdmr.model.util.MappingdmrValidator.INSTANCE;
94: context = new LinkedHashMap<Object, Object>();
95: if (createChain) {
96: chain = new BasicDiagnostic();
97: } else {
98: chain = null;
99: }
100: }
101:
102: private void noContainer() {
103: control.eUnset(VViewPackage.eINSTANCE.getControl_DomainModelReference());
104: }
105:
106: private void okMapping() {
107: mapping.getDomainModelEReferencePath().add(ExamplePackage.eINSTANCE.getRoot_Intermediate());
108: mapping.getDomainModelEReferencePath().add(ExamplePackage.eINSTANCE.getIntermediate_Container());
109: mapping.setDomainModelEFeature(ExamplePackage.eINSTANCE.getContainer_Children());
110: }
111:
112: private void okTarget() {
113: target.getDomainModelEReferencePath().add(ExamplePackage.eINSTANCE.getChild_IntermediateTarget());
114: target.getDomainModelEReferencePath().add(ExamplePackage.eINSTANCE.getIntermediateTarget_Target());
115: target.setDomainModelEFeature(ExamplePackage.eINSTANCE.getTarget_Name());
116: }
117:
118: private DiagnosticInfo controlDMR() {
119: return new DiagnosticInfo(Diagnostic.ERROR, control, VViewPackage.eINSTANCE.getControl_DomainModelReference());
120: }
121:
122: private DiagnosticInfo mappingFeature() {
123: return new DiagnosticInfo(Diagnostic.ERROR, mapping,
124: VViewPackage.eINSTANCE.getFeaturePathDomainModelReference_DomainModelEFeature());
125: }
126:
127: private DiagnosticInfo mappingPath() {
128: return new DiagnosticInfo(Diagnostic.ERROR, mapping,
129: VViewPackage.eINSTANCE.getFeaturePathDomainModelReference_DomainModelEReferencePath());
130: }
131:
132: private DiagnosticInfo mappingTarget() {
133: return new DiagnosticInfo(Diagnostic.ERROR, mapping,
134: VMappingdmrPackage.eINSTANCE.getMappingDomainModelReference_DomainModelReference());
135: }
136:
137: private DiagnosticInfo targetPath() {
138: return new DiagnosticInfo(Diagnostic.ERROR, target,
139: VViewPackage.eINSTANCE.getFeaturePathDomainModelReference_DomainModelEReferencePath());
140: }
141:
142: private boolean validate() {
143: return validator.validate(mapping, chain, context);
144: }
145:
146: @Test
147: public void testNoTargetDMR() {
148: okMapping();
149: mapping.setDomainModelReference(null);
150: assertFalse(validate());
151: if (createChain) {
152: assertEquals(Diagnostic.ERROR, chain.getSeverity());
153: assertChain(controlDMR(), mappingTarget());
154: }
155: }
156:
157: @Test
158: public void testNoTargetDMRNoContainer() {
159: noContainer();
160: okMapping();
161: mapping.setDomainModelReference(null);
162: assertFalse(validate());
163: if (createChain) {
164: assertEquals(Diagnostic.ERROR, chain.getSeverity());
165: assertChain(mappingTarget());
166: }
167: }
168:
169: @Test
170: public void testNoEFeatureOnPathToIndex() {
171: okTarget();
172: assertFalse(validate());
173: if (createChain) {
174: assertEquals(Diagnostic.ERROR, chain.getSeverity());
175: assertChain(controlDMR(), mappingFeature());
176: }
177: }
178:
179: @Test
180: public void testNoEFeatureOnPathToIndexNoContainer() {
181: noContainer();
182: okTarget();
183: assertFalse(validate());
184: if (createChain) {
185: assertEquals(Diagnostic.ERROR, chain.getSeverity());
186: assertChain(mappingFeature());
187: }
188: }
189:
190: @Test
191: public void testBadReferenceOnPathToIndex() {
192: okTarget();
193: mapping.getDomainModelEReferencePath().add(ExamplePackage.eINSTANCE.getIntermediate_Container());
194: mapping.setDomainModelEFeature(ExamplePackage.eINSTANCE.getContainer_Children());
195: assertFalse(validate());
196: if (createChain) {
197: assertEquals(Diagnostic.ERROR, chain.getSeverity());
198: assertChain(controlDMR(), mappingPath());
199: }
200: }
201:
202: @Test
203: public void testBadReferenceOnPathToIndexNoContainer() {
204: noContainer();
205: okTarget();
206: mapping.getDomainModelEReferencePath().add(ExamplePackage.eINSTANCE.getIntermediate_Container());
207: mapping.getDomainModelEReferencePath().add(ExamplePackage.eINSTANCE.getIntermediate_Container());
208: mapping.setDomainModelEFeature(ExamplePackage.eINSTANCE.getContainer_Children());
209: assertFalse(validate());
210: if (createChain) {
211: assertEquals(Diagnostic.ERROR, chain.getSeverity());
212: assertChain(mappingPath());
213: }
214: }
215:
216: @Test
217: public void testBadEFeatureOnPathToIndexSingleReference() {
218: okTarget();
219: mapping.getDomainModelEReferencePath().add(ExamplePackage.eINSTANCE.getRoot_Intermediate());
220: mapping.setDomainModelEFeature(ExamplePackage.eINSTANCE.getIntermediate_Container());
221: assertFalse(validate());
222: if (createChain) {
223: assertEquals(Diagnostic.ERROR, chain.getSeverity());
224: assertChain(controlDMR(), mappingFeature());
225: }
226: }
227:
228: @Test
229: public void testBadEFeatureOnPathToIndexSingleReferenceNoContainer() {
230: noContainer();
231: okTarget();
232: mapping.getDomainModelEReferencePath().add(ExamplePackage.eINSTANCE.getRoot_Intermediate());
233: mapping.setDomainModelEFeature(ExamplePackage.eINSTANCE.getIntermediate_Container());
234: assertFalse(validate());
235: if (createChain) {
236: assertEquals(Diagnostic.ERROR, chain.getSeverity());
237: assertChain(mappingFeature());
238: }
239: }
240:
241: @Test
242: public void testBadEFeatureOnPathToIndexAttribute() {
243: okTarget();
244: mapping.setDomainModelEFeature(ExamplePackage.eINSTANCE.getTarget_Name());
245: assertFalse(validate());
246: if (createChain) {
247: assertEquals(Diagnostic.ERROR, chain.getSeverity());
248: assertChain(controlDMR(), mappingFeature());
249: }
250: }
251:
252: @Test
253: public void testBadEFeatureOnPathToIndexAttributeNoContainer() {
254: noContainer();
255: okTarget();
256: mapping.setDomainModelEFeature(ExamplePackage.eINSTANCE.getTarget_Name());
257: assertFalse(validate());
258: if (createChain) {
259: assertEquals(Diagnostic.ERROR, chain.getSeverity());
260: assertChain(mappingFeature());
261: }
262: }
263:
264: @Test
265: public void testBadClass() {
266: okMapping();
267: okTarget();
268: mapping.setMappedClass(ExamplePackage.eINSTANCE.getContainer());
269: assertFalse(validate());
270: if (createChain) {
271: assertEquals(Diagnostic.ERROR, chain.getSeverity());
272: assertChain(controlDMR(), mappingTarget(), targetPath());
273: }
274: }
275:
276: @Test
277: public void testBadClassNoContainer() {
278: noContainer();
279: okMapping();
280: okTarget();
281: mapping.setMappedClass(ExamplePackage.eINSTANCE.getContainer());
282: assertFalse(validate());
283: if (createChain) {
284: assertEquals(Diagnostic.ERROR, chain.getSeverity());
285: assertChain(mappingTarget(), targetPath());
286: }
287: }
288:
289: @Test
290: public void testOK() {
291: okMapping();
292: okTarget();
293: assertTrue(validate());
294: if (createChain) {
295: assertEquals(Diagnostic.OK, chain.getSeverity());
296: assertChain();
297: }
298: }
299:
300: @Test
301: public void testOKNoContainer() {
302: noContainer();
303: okMapping();
304: okTarget();
305: assertTrue(validate());
306: if (createChain) {
307: assertEquals(Diagnostic.OK, chain.getSeverity());
308: assertChain();
309: }
310: }
311:
312: @Test
313: public void testBadRootEClass() {
314: okMapping();
315: okTarget();
316: view.setRootEClass(ExamplePackage.eINSTANCE.getIntermediate());
317: assertFalse(validate());
318: if (createChain) {
319: assertEquals(Diagnostic.ERROR, chain.getSeverity());
320: assertChain(controlDMR(), mappingPath());
321: }
322: }
323:
324: @Test
325: public void testBadRootEClassGoodRootEClassInContext() {
326: okMapping();
327: okTarget();
328: view.setRootEClass(ExamplePackage.eINSTANCE.getIntermediate());
329: context.put(ViewValidator.ECLASS_KEY, ExamplePackage.eINSTANCE.getRoot());
330: assertTrue(validate());
331: if (createChain) {
332: assertEquals(Diagnostic.OK, chain.getSeverity());
333: assertChain();
334: }
335: }
336:
337: @Test
338: public void testBadPathOnTarget() {
339: okMapping();
340: okTarget();
341: target.getDomainModelEReferencePath().remove(0);
342: assertFalse(validate());
343: if (createChain) {
344: assertEquals(Diagnostic.ERROR, chain.getSeverity());
345: assertChain(controlDMR(), mappingTarget(), targetPath());
346: }
347: }
348:
349: @Test
350: public void testBadPathOnTargetNoContainer() {
351: noContainer();
352: okMapping();
353: okTarget();
354: target.getDomainModelEReferencePath().remove(0);
355: assertFalse(validate());
356: if (createChain) {
357: assertEquals(Diagnostic.ERROR, chain.getSeverity());
358: assertChain(mappingTarget(), targetPath());
359: }
360: }
361:
362: private void assertChain(DiagnosticInfo... infos) {
363: final Set<DiagnosticInfo> infoSet = new LinkedHashSet<DiagnosticInfo>(Arrays.asList(infos));
364: assertEquals(infos.length, chain.getChildren().size());
365: for (final Diagnostic child : chain.getChildren()) {
366: boolean found = false;
367: final Iterator<DiagnosticInfo> iterator = infoSet.iterator();
368: while (iterator.hasNext()) {
369: final DiagnosticInfo next = iterator.next();
370: if (next.sameData(child)) {
371: found = true;
372: iterator.remove();
373: break;
374: }
375: }
376: if (!found) {
377: fail("Chain is missing child diagnostic."); //$NON-NLS-1$
378: }
379: }
380: }
381:
382: private class DiagnosticInfo {
383: private final int severity;
384: private final EObject object;
385: private final EStructuralFeature feature;
386:
387: DiagnosticInfo(int severity, EObject object, EStructuralFeature feature) {
388: this.severity = severity;
389: this.object = object;
390: this.feature = feature;
391: }
392:
393: public boolean sameData(Diagnostic diagnostic) {
394:• if (diagnostic.getSeverity() != severity) {
395: return false;
396: }
397:• if (!object.equals(diagnostic.getData().get(0))) {
398: return false;
399: }
400:• if (!feature.equals(diagnostic.getData().get(1))) {
401: return false;
402: }
403: return true;
404: }
405:
406: }
407: }