Skip to content

Package: MappingDmrSegmentGenerator_Test

MappingDmrSegmentGenerator_Test

nameinstructionbranchcomplexitylinemethod
MappingDmrSegmentGenerator_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%
assertFeatureSegment(VDomainModelReferenceSegment, String)
M: 0 C: 12
100%
M: 0 C: 0
100%
M: 0 C: 1
100%
M: 0 C: 5
100%
M: 0 C: 1
100%
generateSegments()
M: 0 C: 102
100%
M: 0 C: 0
100%
M: 0 C: 1
100%
M: 0 C: 20
100%
M: 0 C: 1
100%
generateSegments_emptyTargetDmr()
M: 0 C: 50
100%
M: 0 C: 0
100%
M: 0 C: 1
100%
M: 0 C: 11
100%
M: 0 C: 1
100%
generateSegments_noDomainModelEFeature()
M: 0 C: 53
100%
M: 0 C: 0
100%
M: 0 C: 1
100%
M: 0 C: 12
100%
M: 0 C: 1
100%
generateSegments_noTargetDmr()
M: 0 C: 46
100%
M: 0 C: 0
100%
M: 0 C: 1
100%
M: 0 C: 10
100%
M: 0 C: 1
100%
generateSegments_nullDmr()
M: 6 C: 0
0%
M: 0 C: 0
100%
M: 1 C: 0
0%
M: 2 C: 0
0%
M: 1 C: 0
0%
isApplicable_mappingDmr()
M: 0 C: 11
100%
M: 0 C: 0
100%
M: 0 C: 1
100%
M: 0 C: 4
100%
M: 0 C: 1
100%
isApplicable_nullDmr()
M: 6 C: 0
0%
M: 0 C: 0
100%
M: 1 C: 0
0%
M: 2 C: 0
0%
M: 1 C: 0
0%
isApplicable_subtypeOfmappingDmr()
M: 0 C: 15
100%
M: 0 C: 0
100%
M: 0 C: 1
100%
M: 0 C: 4
100%
M: 0 C: 1
100%
isApplicable_unrelatedDmr()
M: 0 C: 12
100%
M: 0 C: 0
100%
M: 0 C: 1
100%
M: 0 C: 3
100%
M: 0 C: 1
100%
mockMappingDmr()
M: 0 C: 22
100%
M: 0 C: 0
100%
M: 0 C: 1
100%
M: 0 C: 5
100%
M: 0 C: 1
100%
setUp()
M: 0 C: 36
100%
M: 0 C: 0
100%
M: 0 C: 1
100%
M: 0 C: 8
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.emfforms.internal.core.services.segments.mapping;
15:
16: import static org.junit.Assert.assertEquals;
17: import static org.junit.Assert.assertNotNull;
18: import static org.junit.Assert.assertSame;
19: import static org.junit.Assert.assertTrue;
20: import static org.mockito.Matchers.any;
21: import static org.mockito.Mockito.atLeastOnce;
22: import static org.mockito.Mockito.mock;
23: import static org.mockito.Mockito.times;
24: import static org.mockito.Mockito.verify;
25: import static org.mockito.Mockito.when;
26:
27: import java.util.Collections;
28: import java.util.LinkedList;
29: import java.util.List;
30:
31: import org.eclipse.emf.common.util.BasicEList;
32: import org.eclipse.emf.common.util.EList;
33: import org.eclipse.emf.ecore.EClass;
34: import org.eclipse.emf.ecore.EReference;
35: import org.eclipse.emf.ecore.EcoreFactory;
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.mappingdmr.model.impl.VMappingDomainModelReferenceImpl;
40: import org.eclipse.emf.ecp.view.spi.model.VDomainModelReference;
41: import org.eclipse.emf.ecp.view.spi.model.VDomainModelReferenceSegment;
42: import org.eclipse.emf.ecp.view.spi.model.VFeatureDomainModelReferenceSegment;
43: import org.eclipse.emfforms.core.services.databinding.testmodel.test.model.TestPackage;
44: import org.eclipse.emfforms.spi.common.report.AbstractReport;
45: import org.eclipse.emfforms.spi.common.report.ReportService;
46: import org.eclipse.emfforms.spi.core.services.segments.DmrSegmentGenerator;
47: import org.eclipse.emfforms.spi.core.services.segments.EMFFormsSegmentGenerator;
48: import org.eclipse.emfforms.spi.view.mappingsegment.model.VMappingDomainModelReferenceSegment;
49: import org.junit.Before;
50: import org.junit.Test;
51:
52: /**
53: * @author Lucas Koehler
54: *
55: */
56: @SuppressWarnings("restriction")
57: public class MappingDmrSegmentGenerator_Test {
58:
59:         private MappingDmrSegmentGenerator generator;
60:         private EMFFormsSegmentGenerator emfFormsSegmentGenerator;
61:         private ReportService reportService;
62:
63:         @Before
64:         public void setUp() {
65:                 generator = new MappingDmrSegmentGenerator();
66:                 emfFormsSegmentGenerator = mock(EMFFormsSegmentGenerator.class);
67:                 // the interface defines that null is never returned
68:                 when(emfFormsSegmentGenerator.generateSegments(any(VDomainModelReference.class)))
69:                         .thenReturn(Collections.emptyList());
70:                 generator.setEMFFormsSegmentGenerator(emfFormsSegmentGenerator);
71:                 reportService = mock(ReportService.class);
72:                 generator.setReportService(reportService);
73:         }
74:
75:         @Test(expected = IllegalArgumentException.class)
76:         public void isApplicable_nullDmr() {
77:                 generator.isApplicable(null);
78:         }
79:
80:         @Test
81:         public void isApplicable_mappingDmr() {
82:                 final double applicable = generator
83:                         .isApplicable(VMappingdmrFactory.eINSTANCE.createMappingDomainModelReference());
84:                 assertEquals(5d, applicable, 0d);
85:         }
86:
87:         @Test
88:         public void isApplicable_unrelatedDmr() {
89:                 final double applicable = generator.isApplicable(mock(VDomainModelReference.class));
90:                 assertEquals(DmrSegmentGenerator.NOT_APPLICABLE, applicable, 0d);
91:         }
92:
93:         @Test
94:         public void isApplicable_subtypeOfmappingDmr() {
95:                 final MappingDmrSubType subtypeDmr = new MappingDmrSubType();
96:                 final double applicable = generator.isApplicable(subtypeDmr);
97:                 assertEquals(DmrSegmentGenerator.NOT_APPLICABLE, applicable, 0d);
98:         }
99:
100:         @Test(expected = IllegalArgumentException.class)
101:         public void generateSegments_nullDmr() {
102:                 generator.generateSegments(null);
103:         }
104:
105:         @Test
106:         public void generateSegments() {
107:                 final VMappingDomainModelReference mappingDmr = mockMappingDmr();
108:                 mappingDmr.getDomainModelEReferencePath().add(TestPackage.Literals.B__C);
109:                 when(mappingDmr.getDomainModelEFeature()).thenReturn(TestPackage.Literals.C__ECLASS_TO_E);
110:                 when(mappingDmr.getMappedClass()).thenReturn(TestPackage.Literals.A);
111:
112:                 final VDomainModelReference targetDmr = mock(VDomainModelReference.class);
113:                 when(mappingDmr.getDomainModelReference()).thenReturn(targetDmr);
114:
115:                 final List<VDomainModelReferenceSegment> targetSegments = new LinkedList<>();
116:                 final VDomainModelReferenceSegment targetSegment = mock(VDomainModelReferenceSegment.class);
117:                 targetSegments.add(targetSegment);
118:                 when(emfFormsSegmentGenerator.generateSegments(targetDmr)).thenReturn(targetSegments);
119:
120:                 final List<VDomainModelReferenceSegment> result = generator.generateSegments(mappingDmr);
121:                 assertEquals(3, result.size());
122:                 assertFeatureSegment(result.get(0), TestPackage.Literals.B__C.getName());
123:                 assertTrue(result.get(1) instanceof VMappingDomainModelReferenceSegment);
124:                 final VMappingDomainModelReferenceSegment mappingSegment = (VMappingDomainModelReferenceSegment) result.get(1);
125:                 assertEquals(TestPackage.Literals.A, mappingSegment.getMappedClass());
126:                 assertEquals(TestPackage.Literals.C__ECLASS_TO_E.getName(), mappingSegment.getDomainModelFeature());
127:                 assertSame(targetSegment, result.get(2));
128:
129:                 verify(emfFormsSegmentGenerator, times(1)).generateSegments(targetDmr);
130:         }
131:
132:         @Test
133:         public void generateSegments_noDomainModelEFeature() {
134:                 final VMappingDomainModelReference mappingDmr = mockMappingDmr();
135:
136:                 final VDomainModelReference targetDmr = mock(VDomainModelReference.class);
137:                 when(mappingDmr.getDomainModelReference()).thenReturn(targetDmr);
138:
139:                 final List<VDomainModelReferenceSegment> targetSegments = new LinkedList<>();
140:                 final VDomainModelReferenceSegment targetSegment = mock(VDomainModelReferenceSegment.class);
141:                 targetSegments.add(targetSegment);
142:                 when(emfFormsSegmentGenerator.generateSegments(targetDmr)).thenReturn(targetSegments);
143:
144:                 final List<VDomainModelReferenceSegment> result = generator.generateSegments(mappingDmr);
145:
146:                 assertNotNull(result);
147:                 assertTrue(result.isEmpty());
148:                 verify(reportService, atLeastOnce()).report(any(AbstractReport.class));
149:         }
150:
151:         @Test
152:         public void generateSegments_noTargetDmr() {
153:                 final VMappingDomainModelReference mappingDmr = mockMappingDmr();
154:                 mappingDmr.getDomainModelEReferencePath().add(TestPackage.Literals.B__C);
155:                 when(mappingDmr.getDomainModelEFeature()).thenReturn(TestPackage.Literals.C__ECLASS_TO_E);
156:                 when(mappingDmr.getMappedClass()).thenReturn(TestPackage.Literals.A);
157:
158:                 when(mappingDmr.getDomainModelReference()).thenReturn(null);
159:
160:                 final List<VDomainModelReferenceSegment> result = generator.generateSegments(mappingDmr);
161:
162:                 assertNotNull(result);
163:                 assertTrue(result.isEmpty());
164:                 verify(reportService, atLeastOnce()).report(any(AbstractReport.class));
165:         }
166:
167:         @Test
168:         public void generateSegments_emptyTargetDmr() {
169:                 final VMappingDomainModelReference mappingDmr = mockMappingDmr();
170:                 mappingDmr.getDomainModelEReferencePath().add(TestPackage.Literals.B__C);
171:                 when(mappingDmr.getDomainModelEFeature()).thenReturn(TestPackage.Literals.C__ECLASS_TO_E);
172:                 when(mappingDmr.getMappedClass()).thenReturn(TestPackage.Literals.A);
173:
174:                 final VDomainModelReference targetDmr = mock(VDomainModelReference.class);
175:                 when(mappingDmr.getDomainModelReference()).thenReturn(targetDmr);
176:
177:                 final List<VDomainModelReferenceSegment> result = generator.generateSegments(mappingDmr);
178:
179:                 assertNotNull(result);
180:                 assertTrue(result.isEmpty());
181:                 verify(reportService, atLeastOnce()).report(any(AbstractReport.class));
182:         }
183:
184:         private VMappingDomainModelReference mockMappingDmr() {
185:                 final VMappingDomainModelReference mappingDmr = mock(VMappingDomainModelReference.class);
186:                 final EList<EReference> path = new BasicEList<EReference>();
187:                 when(mappingDmr.getDomainModelEReferencePath()).thenReturn(path);
188:                 when(mappingDmr.eClass()).thenReturn(VMappingdmrPackage.Literals.MAPPING_DOMAIN_MODEL_REFERENCE);
189:                 return mappingDmr;
190:         }
191:
192:         private void assertFeatureSegment(VDomainModelReferenceSegment segment, String expectedDomainModelFeature) {
193:                 assertTrue(segment instanceof VFeatureDomainModelReferenceSegment);
194:                 final VFeatureDomainModelReferenceSegment featureSegment = (VFeatureDomainModelReferenceSegment) segment;
195:                 assertEquals("Segment does not reference the expected feature.", expectedDomainModelFeature, //$NON-NLS-1$
196:                         featureSegment.getDomainModelFeature());
197:         }
198:
199:         private static class MappingDmrSubType extends VMappingDomainModelReferenceImpl {
200:                 @Override
201:                 public EClass eClass() {
202:                         final EClass eClass = EcoreFactory.eINSTANCE.createEClass();
203:                         eClass.setName("IndexDmrSubType"); //$NON-NLS-1$
204:                         eClass.getESuperTypes().add(VMappingdmrPackage.Literals.MAPPING_DOMAIN_MODEL_REFERENCE);
205:                         return eClass;
206:                 }
207:         }
208: }