![[Jenkins]](/ecp/static/e8bbdb94/images/svgs/logo.svg){kind=logo}
Package: IterateCondition_PTest$1
IterateCondition_PTest$1
| name | instruction | branch | complexity | line | method | ||||||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| invoke(Object, Method, Object[]) |
|
|
|
|
|
||||||||||||||||||||
| {...} |
|
|
|
|
|
||||||||||||||||||||
Coverage
1: /*******************************************************************************
2: * Copyright (c) 2017 Christian W. Damus 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: * Christian W. Damus - initial API and implementation
13: ******************************************************************************/
14: package org.eclipse.emf.ecp.view.rule.test;
15:
16: import static org.eclipse.emf.ecp.view.spi.model.ModelReferenceHelper.createDomainModelReference;
17: import static org.hamcrest.CoreMatchers.is;
18: import static org.hamcrest.MatcherAssert.assertThat;
19: import static org.mockito.Mockito.atLeastOnce;
20:
21: import java.lang.reflect.InvocationHandler;
22: import java.lang.reflect.Method;
23: import java.lang.reflect.Proxy;
24: import java.util.ArrayList;
25: import java.util.Arrays;
26: import java.util.HashMap;
27: import java.util.HashSet;
28: import java.util.LinkedHashSet;
29: import java.util.List;
30: import java.util.Map;
31: import java.util.Set;
32:
33: import org.eclipse.emf.common.util.BasicEList;
34: import org.eclipse.emf.ecore.EClass;
35: import org.eclipse.emf.ecore.EClassifier;
36: import org.eclipse.emf.ecore.EPackage;
37: import org.eclipse.emf.ecore.EStructuralFeature;
38: import org.eclipse.emf.ecore.EcoreFactory;
39: import org.eclipse.emf.ecore.EcorePackage;
40: import org.eclipse.emf.ecore.InternalEObject;
41: import org.eclipse.emf.ecore.util.EcoreUtil;
42: import org.eclipse.emf.ecp.common.spi.UniqueSetting;
43: import org.eclipse.emf.ecp.view.spi.model.VDomainModelReference;
44: import org.eclipse.emf.ecp.view.spi.model.VDomainModelReferenceSegment;
45: import org.eclipse.emf.ecp.view.spi.model.VFeaturePathDomainModelReference;
46: import org.eclipse.emf.ecp.view.spi.rule.model.Condition;
47: import org.eclipse.emf.ecp.view.spi.rule.model.IterateCondition;
48: import org.eclipse.emf.ecp.view.spi.rule.model.LeafCondition;
49: import org.eclipse.emf.ecp.view.spi.rule.model.Quantifier;
50: import org.eclipse.emf.ecp.view.spi.rule.model.RuleFactory;
51: import org.junit.Test;
52:
53: /**
54: * Test the {@link IterateCondition} and its service.
55: *
56: * @author Christian W. Damus
57: */
58: public class IterateCondition_PTest extends AbstractConditionTest<IterateCondition> {
59:
60: private Condition inner;
61:
62: /**
63: * Initializes me.
64: */
65: public IterateCondition_PTest() {
66: super();
67: }
68:
69: @Test
70: public void evaluateAllTrue() {
71: getFixture().setQuantifier(Quantifier.ALL);
72: assertThat(evaluate(getNested(1)), is(true));
73: }
74:
75: @Test
76: public void evaluateAllFalse() {
77: getFixture().setQuantifier(Quantifier.ALL);
78: assertThat(evaluate(getNested(2)), is(false));
79: assertThat(evaluate(getNested(3)), is(false));
80: assertThat(evaluate(getNested(4)), is(false));
81: }
82:
83: @Test
84: public void evaluateAnyTrue() {
85: getFixture().setQuantifier(Quantifier.ANY);
86: assertThat(evaluate(getNested(1)), is(true));
87: assertThat(evaluate(getNested(3)), is(true));
88: assertThat(evaluate(getNested(4)), is(true));
89: }
90:
91: @Test
92: public void evaluateAnyFalse() {
93: getFixture().setQuantifier(Quantifier.ANY);
94: assertThat(evaluate(getNested(2)), is(false));
95: }
96:
97: @Test
98: public void evaluateEmptyTrue() {
99: getFixture().setIfEmpty(true);
100: getFixture().setQuantifier(Quantifier.ALL);
101:
102: getNested(1).getEClassifiers().clear();
103: assertThat(evaluate(getNested(1)), is(true));
104: }
105:
106: @Test
107: public void evaluateIfEmptyFalse() {
108: getFixture().setIfEmpty(false);
109: getFixture().setQuantifier(Quantifier.ANY);
110:
111: getNested(1).getEClassifiers().clear();
112: assertThat(evaluate(getNested(1)), is(false));
113: }
114:
115: @Test
116: public void settings() {
117: final Set<UniqueSetting> expected = new HashSet<UniqueSetting>();
118:
119: final EPackage nested = getNested(1);
120:
121: // The setting for the reference path
122: expected.add(UniqueSetting.createSetting(nested,
123: EcorePackage.Literals.EPACKAGE__ECLASSIFIERS));
124:
125: // And the settings for the classes' names
126: expected.add(UniqueSetting.createSetting(nested.getEClassifiers().get(0),
127: EcorePackage.Literals.ENAMED_ELEMENT__NAME));
128: expected.add(UniqueSetting.createSetting(nested.getEClassifiers().get(1),
129: EcorePackage.Literals.ENAMED_ELEMENT__NAME));
130:
131: assertThat(getConditionSettings(getNested(1)), is(expected));
132: }
133:
134: @Test
135: public void references() {
136: final Set<VDomainModelReference> expected = new LinkedHashSet<>();
137: expected.addAll(getDomainModelReferences(inner));
138: expected.add(getFixture().getItemReference());
139: assertThat(getDomainModelReferences(), is(expected));
140: }
141:
142: /**
143: * Pre-evaluate proposed changes in the constrained values of the iteration targets.
144: */
145: @Test
146: public void preEvaluateChangesInTargets() {
147: getFixture().setIfEmpty(false);
148: getFixture().setQuantifier(Quantifier.ALL);
149:
150: final Map<EStructuralFeature.Setting, Object> possibleNewValues = new HashMap<EStructuralFeature.Setting, Object>();
151:
152: final EPackage ePackage = getNested(1);
153: final EClassifier eClass2 = ePackage.getEClassifiers().get(1);
154: final EStructuralFeature.Setting eClass2Name = nameSetting(eClass2);
155:
156: possibleNewValues.put(eClass2Name, "X");
157: assertThat(evaluateChangedValues(ePackage, possibleNewValues), is(false));
158:
159: // This is the value that they're supposed to have
160: possibleNewValues.put(eClass2Name, "A");
161: assertThat(evaluateChangedValues(ePackage, possibleNewValues), is(true));
162: }
163:
164: /**
165: * Pre-evaluate proposed changes in the set of iteration targets that are constrained.
166: */
167: @Test
168: public void preEvaluateChangesOfTargets() {
169: getFixture().setIfEmpty(false);
170: getFixture().setQuantifier(Quantifier.ALL);
171:
172: final Map<EStructuralFeature.Setting, Object> possibleNewValues = new HashMap<EStructuralFeature.Setting, Object>();
173:
174: // The classifiers in this package are all named "A"
175: final EPackage ePackage = getNested(1);
176: final EStructuralFeature.Setting classifiers = classifiersSetting(ePackage);
177:
178: final EClass newEClass = EcoreFactory.eINSTANCE.createEClass();
179: newEClass.setName("X");
180: final List<EClassifier> newValue = new ArrayList<EClassifier>(ePackage.getEClassifiers());
181: newValue.add(newEClass);
182:
183: possibleNewValues.put(classifiers, newValue);
184: assertThat(evaluateChangedValues(ePackage, possibleNewValues), is(false));
185:
186: // Give the new classifier the same name as the others
187: newEClass.setName("A");
188: assertThat(evaluateChangedValues(ePackage, possibleNewValues), is(true));
189: }
190:
191: /**
192: * Verify proper handling of data-binding failures.
193: */
194: @Test
195: public void dataBindingFailure() {
196: final VDomainModelReference fake = (VDomainModelReference) Proxy.newProxyInstance(getClass().getClassLoader(),
197: new Class<?>[] { VDomainModelReference.class, InternalEObject.class },
198: new InvocationHandler() {
199:
200: @Override
201: public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
202:• if ("getSegments".equals(method.getName())) {
203: return new BasicEList<VDomainModelReferenceSegment>();
204: }
205: return null;
206: }
207: });
208: getFixture().setItemReference(fake);
209:
210: try {
211: getConditionSettings(getModel());
212: // BEGIN COMPLEX CODE
213: } catch (final Exception e) {
214: // END COMPLEX CODE
215: // Expected for this fake reference
216: } finally {
217: assertReports(atLeastOnce());
218: }
219: }
220:
221: //
222: // Test framework
223: //
224:
225: @Override
226: protected IterateCondition createCondition() {
227: final IterateCondition result = RuleFactory.eINSTANCE.createIterateCondition();
228:
229: final LeafCondition inner = RuleFactory.eINSTANCE.createLeafCondition();
230: result.setItemCondition(inner);
231:
232: inner.setExpectedValue("A");
233:
234: final VDomainModelReference innerRef = createDomainModelReference(
235: EcorePackage.Literals.ENAMED_ELEMENT__NAME);
236: inner.setDomainModelReference(innerRef);
237:
238: final VFeaturePathDomainModelReference ref = (VFeaturePathDomainModelReference) createDomainModelReference(
239: EcorePackage.Literals.EPACKAGE__ECLASSIFIERS);
240: result.setItemReference(ref);
241:
242: this.inner = inner;
243:
244: return result;
245: }
246:
247: @Override
248: protected EPackage createModel() {
249: final EPackage result = super.createModel();
250:
251: for (final String name : Arrays.asList("A", "A", "B", "B", "A", "B", "B", "A")) {
252: createEClass(result, name);
253: }
254:
255: for (int index = 0; index < 4; index++) {
256: createNestedPackage(result, index);
257: }
258:
259: return result;
260: }
261:
262: private EClass createEClass(EPackage ePackage, String name) {
263: final EClass result = EcoreFactory.eINSTANCE.createEClass();
264: ePackage.getEClassifiers().add(result);
265: result.setName(name);
266: return result;
267: }
268:
269: private EPackage createNestedPackage(EPackage nesting, int index) {
270: final EPackage result = EcoreFactory.eINSTANCE.createEPackage();
271: nesting.getESubpackages().add(result);
272: result.setName("nested" + index);
273:
274: final int offset = 2 * index;
275: for (int subindex = 0; subindex < 2; subindex++) {
276: result.getEClassifiers().add(EcoreUtil.copy(nesting.getEClassifiers().get(offset + subindex)));
277: }
278:
279: return result;
280: }
281:
282: EPackage getNested(int index) {
283: return getModel().getESubpackages().get(index - 1);
284: }
285:
286: EClass getEClass(int index) {
287: return (EClass) getModel().getEClassifiers().get(index - 1);
288: }
289:
290: EStructuralFeature.Setting classifiersSetting(EPackage ePackage) {
291: return ((InternalEObject) ePackage).eSetting(EcorePackage.Literals.EPACKAGE__ECLASSIFIERS);
292: }
293: }