Package: MappingSegmentIdeDescriptor_Test

MappingSegmentIdeDescriptor_Test

name	instruction	branch	complexity	line	method
MappingSegmentIdeDescriptor_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%
getEStructuralFeatureSelectionValidator_invalid_attribute()	M: 0 C: 32 100%	M: 0 C: 0 100%	M: 0 C: 1 100%	M: 0 C: 8 100%	M: 0 C: 1 100%
getEStructuralFeatureSelectionValidator_invalid_illegalMap()	M: 0 C: 96 100%	M: 0 C: 0 100%	M: 0 C: 1 100%	M: 0 C: 19 100%	M: 0 C: 1 100%
getEStructuralFeatureSelectionValidator_valid()	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%
getReferenceTypeResolver()	M: 0 C: 34 100%	M: 0 C: 0 100%	M: 0 C: 1 100%	M: 0 C: 9 100%	M: 0 C: 1 100%
getReferenceTypeResolver_illegalSegment()	M: 8 C: 4 33%	M: 0 C: 0 100%	M: 0 C: 1 100%	M: 2 C: 1 33%	M: 0 C: 1 100%
getReferenceTypeResolver_noMappedEClass()	M: 0 C: 37 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%

Coverage

1: /*******************************************************************************
2: * Copyright (c) 2011-2019 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.ide.view.mappingsegment;
15:
16: import static org.junit.Assert.assertFalse;
17: import static org.junit.Assert.assertNotNull;
18: import static org.junit.Assert.assertNull;
19: import static org.junit.Assert.assertSame;
20: import static org.mockito.Mockito.mock;
21: import static org.mockito.Mockito.when;
22:
23: import org.eclipse.emf.ecore.EAttribute;
24: import org.eclipse.emf.ecore.EClass;
25: import org.eclipse.emf.ecore.EReference;
26: import org.eclipse.emf.ecore.EcorePackage;
27: import org.eclipse.emf.ecp.view.spi.editor.controls.EStructuralFeatureSelectionValidator;
28: import org.eclipse.emf.ecp.view.spi.editor.controls.ReferenceTypeResolver;
29: import org.eclipse.emf.ecp.view.spi.model.VFeatureDomainModelReferenceSegment;
30: import org.eclipse.emfforms.spi.view.mappingsegment.model.VMappingDomainModelReferenceSegment;
31: import org.eclipse.emfforms.spi.view.mappingsegment.model.VMappingsegmentPackage;
32: import org.junit.Before;
33: import org.junit.Test;
34:
35: /**
36: * Unit tests for {@link MappingSegmentIdeDescriptor}.
37: *
38: * @author Lucas Koehler
39: *
40: */
41: public class MappingSegmentIdeDescriptor_Test {
42:
43:         private MappingSegmentIdeDescriptor descriptor;
44:
45:         @Before
46:         public void setUp() {
47:                 descriptor = new MappingSegmentIdeDescriptor();
48:         }
49:
50:         @Test
51:         public void getEStructuralFeatureSelectionValidator_valid() {
52:                 final EStructuralFeatureSelectionValidator validator = descriptor.getEStructuralFeatureSelectionValidator();
53:                 final String result = validator.isValid(TestUtil.mockMapReference());
54:
55:                 assertNull(result);
56:         }
57:
58:         @Test
59:         public void getEStructuralFeatureSelectionValidator_invalid_illegalMap() {
60:                 final EReference keyReference = mock(EReference.class);
61:                 // This makes it invalid, because a valid map for a mapping segment must have the EClass EClass as reference
62:                 // type
63:                 when(keyReference.getEReferenceType()).thenReturn(EcorePackage.Literals.ECLASSIFIER);
64:                 when(keyReference.getName()).thenReturn("key"); //$NON-NLS-1$
65:
66:                 final EReference valueReference = mock(EReference.class);
67:                 when(valueReference.getEReferenceType()).thenReturn(mock(EClass.class));
68:                 when(valueReference.getName()).thenReturn("value"); //$NON-NLS-1$
69:
70:                 final EClass referenceType = mock(EClass.class);
71:                 when(referenceType.getInstanceClassName()).thenReturn("java.util.Map$Entry"); //$NON-NLS-1$
72:                 when(referenceType.getEStructuralFeature("key")).thenReturn(keyReference); //$NON-NLS-1$
73:                 when(referenceType.getEStructuralFeature("value")).thenReturn(valueReference); //$NON-NLS-1$
74:                 when(referenceType.getName()).thenReturn("EClassToMockMap"); //$NON-NLS-1$
75:
76:                 final EReference eRef = mock(EReference.class);
77:                 when(eRef.isMany()).thenReturn(true);
78:                 when(eRef.getEReferenceType()).thenReturn(referenceType);
79:
80:                 final EStructuralFeatureSelectionValidator validator = descriptor.getEStructuralFeatureSelectionValidator();
81:                 final String result = validator.isValid(eRef);
82:
83:                 assertNotNull(result);
84:                 assertFalse(result.isEmpty());
85:         }
86:
87:         @Test
88:         public void getEStructuralFeatureSelectionValidator_invalid_attribute() {
89:                 final EAttribute eRef = mock(EAttribute.class);
90:                 when(eRef.isMany()).thenReturn(true);
91:                 when(eRef.getName()).thenReturn("fakeMap"); //$NON-NLS-1$
92:
93:                 final EStructuralFeatureSelectionValidator validator = descriptor.getEStructuralFeatureSelectionValidator();
94:                 final String result = validator.isValid(eRef);
95:
96:                 assertNotNull(result);
97:                 assertFalse(result.isEmpty());
98:         }
99:
100:         @Test
101:         public void getReferenceTypeResolver() {
102:                 final VMappingDomainModelReferenceSegment mappingSegment = mock(VMappingDomainModelReferenceSegment.class);
103:                 when(mappingSegment.eClass())
104:                         .thenReturn(VMappingsegmentPackage.Literals.MAPPING_DOMAIN_MODEL_REFERENCE_SEGMENT);
105:
106:                 final EClass mappedClass = mock(EClass.class);
107:                 when(mappingSegment.getMappedClass()).thenReturn(mappedClass);
108:
109:                 final ReferenceTypeResolver resolver = descriptor.getReferenceTypeResolver();
110:                 final EClass result = resolver.resolveNextEClass(TestUtil.mockMapReference(), mappingSegment);
111:
112:                 assertSame("Mapped EClass was not resolved correctly.", mappedClass, result); //$NON-NLS-1$
113:         }
114:
115:         @Test
116:         public void getReferenceTypeResolver_noMappedEClass() {
117:                 final VMappingDomainModelReferenceSegment mappingSegment = mock(VMappingDomainModelReferenceSegment.class);
118:                 when(mappingSegment.eClass())
119:                         .thenReturn(VMappingsegmentPackage.Literals.MAPPING_DOMAIN_MODEL_REFERENCE_SEGMENT);
120:                 when(mappingSegment.getMappedClass()).thenReturn(null);
121:
122:                 final ReferenceTypeResolver resolver = descriptor.getReferenceTypeResolver();
123:                 final EClass expected = mock(EClass.class);
124:                 final EReference mapReference = TestUtil.mockMapReference(expected);
125:                 final EClass result = resolver.resolveNextEClass(mapReference, mappingSegment);
126:
127:                 assertSame("Mapped EClass was not resolved correctly.", expected, result); //$NON-NLS-1$
128:         }
129:
130:         @Test(expected = IllegalArgumentException.class)
131:         public void getReferenceTypeResolver_illegalSegment() {
132:                 final ReferenceTypeResolver resolver = descriptor.getReferenceTypeResolver();
133:                 resolver.resolveNextEClass(TestUtil.mockMapReference(), mock(VFeatureDomainModelReferenceSegment.class));
134:         }
135:
136: }