![[Jenkins]](/ecp/static/e8bbdb94/images/svgs/logo.svg){kind=logo}
Package: CreateSegmentDmrWizard_PTest$FeatureListMatcher
CreateSegmentDmrWizard_PTest$FeatureListMatcher
| name | instruction | branch | complexity | line | method | ||||||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| CreateSegmentDmrWizard_PTest.FeatureListMatcher(EStructuralFeature[]) |
|
|
|
|
|
||||||||||||||||||||
| matches(Object) |
|
|
|
|
|
||||||||||||||||||||
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.emf.ecp.view.internal.editor.handler;
15:
16: import static org.junit.Assert.assertEquals;
17: import static org.junit.Assert.assertFalse;
18: import static org.junit.Assert.assertNotNull;
19: import static org.junit.Assert.assertNotSame;
20: import static org.junit.Assert.assertSame;
21: import static org.junit.Assert.assertTrue;
22: import static org.mockito.Matchers.argThat;
23: import static org.mockito.Mockito.atLeastOnce;
24: import static org.mockito.Mockito.mock;
25: import static org.mockito.Mockito.spy;
26: import static org.mockito.Mockito.verify;
27: import static org.mockito.Mockito.when;
28:
29: import java.text.MessageFormat;
30: import java.util.Collection;
31: import java.util.LinkedList;
32: import java.util.List;
33: import java.util.Optional;
34:
35: import org.eclipse.emf.ecore.EAttribute;
36: import org.eclipse.emf.ecore.EClass;
37: import org.eclipse.emf.ecore.EPackage;
38: import org.eclipse.emf.ecore.EReference;
39: import org.eclipse.emf.ecore.EStructuralFeature;
40: import org.eclipse.emf.ecore.EcoreFactory;
41: import org.eclipse.emf.ecore.EcorePackage;
42: import org.eclipse.emf.ecp.view.spi.editor.controls.EStructuralFeatureSelectionValidator;
43: import org.eclipse.emf.ecp.view.spi.editor.controls.SegmentIdeDescriptor;
44: import org.eclipse.emf.ecp.view.spi.model.VDomainModelReference;
45: import org.eclipse.emf.ecp.view.spi.model.VDomainModelReferenceSegment;
46: import org.eclipse.emf.ecp.view.spi.model.VFeatureDomainModelReferenceSegment;
47: import org.eclipse.emf.ecp.view.spi.model.VViewFactory;
48: import org.eclipse.emf.ecp.view.spi.model.VViewPackage;
49: import org.eclipse.emf.ecp.view.test.common.swt.spi.SWTTestUtil;
50: import org.eclipse.emfforms.spi.swt.core.SWTDataElementIdHelper;
51: import org.eclipse.jface.window.Window;
52: import org.eclipse.jface.wizard.Wizard;
53: import org.eclipse.jface.wizard.WizardDialog;
54: import org.eclipse.swt.widgets.Shell;
55: import org.eclipse.swt.widgets.Text;
56: import org.eclipse.swt.widgets.Widget;
57: import org.eclipse.swtbot.swt.finder.SWTBot;
58: import org.eclipse.swtbot.swt.finder.matchers.AbstractMatcher;
59: import org.eclipse.swtbot.swt.finder.widgets.SWTBotButton;
60: import org.eclipse.swtbot.swt.finder.widgets.SWTBotCombo;
61: import org.eclipse.swtbot.swt.finder.widgets.SWTBotTable;
62: import org.eclipse.swtbot.swt.finder.widgets.SWTBotTree;
63: import org.eclipse.swtbot.swt.finder.widgets.SWTBotTreeItem;
64: import org.hamcrest.Description;
65: import org.junit.After;
66: import org.junit.Before;
67: import org.junit.Test;
68: import org.mockito.ArgumentMatcher;
69:
70: /**
71: * Test cases for the {@link CreateSegmentDmrWizard}.
72: *
73: * @author Lucas Koehler
74: *
75: */
76: public class CreateSegmentDmrWizard_PTest {
77: // Wizard button labels
78: private static final String BACK = "< Back";
79: private static final String NEXT = "Next >";
80: private static final String CANCEL = "Cancel";
81: private static final String FINISH = "Finish";
82:
83: private static final String WINDOW_TITLE = "Test Window Title";
84:
85: private Collection<SegmentIdeDescriptor> descriptors;
86:
87: private SegmentGenerator segmentGenerator;
88: private EStructuralFeatureSelectionValidator selectionValidator;
89:
90: private EClass testClass;
91: private EReference testReference;
92: private EReference subTestReference;
93: private Shell shell;
94:
95: @Before
96: public void setUp() {
97: // Set up test model
98: final EPackage testPackage = EcoreFactory.eINSTANCE.createEPackage();
99: testPackage.setName("TestPackage");
100: testPackage.setNsPrefix("TestPackage");
101: testPackage.setNsURI("http://TestPackage");
102: testClass = EcoreFactory.eINSTANCE.createEClass();
103: testClass.setName("TestClass");
104: testPackage.getEClassifiers().add(testClass);
105:
106: final EAttribute testAttribute = EcoreFactory.eINSTANCE.createEAttribute();
107: testAttribute.setName("TestAttribute");
108: testAttribute.setEType(EcorePackage.Literals.ESTRING);
109:
110: final EClass refTestClass = EcoreFactory.eINSTANCE.createEClass();
111: refTestClass.setName("RefTestClass");
112: testPackage.getEClassifiers().add(refTestClass);
113: subTestReference = EcoreFactory.eINSTANCE.createEReference();
114: subTestReference.setName("SubTestReference");
115: subTestReference.setEType(EcorePackage.Literals.ECLASSIFIER);
116: refTestClass.getEStructuralFeatures().add(subTestReference);
117:
118: testReference = EcoreFactory.eINSTANCE.createEReference();
119: testReference.setName("TestReference");
120: testReference.setEType(refTestClass);
121: testClass.getEStructuralFeatures().add(testAttribute);
122: testClass.getEStructuralFeatures().add(testReference);
123:
124: selectionValidator = feature -> feature instanceof EReference ? null : "Illegal Selection";
125:
126: segmentGenerator = spy(new FeatureSegmentGenerator());
127: descriptors = new LinkedList<>();
128:
129: shell = new Shell();
130: shell.open();
131: }
132:
133: @After
134: public void disposeShell() {
135: if (shell != null) {
136: shell.dispose();
137: }
138: }
139:
140: @Test
141: public void simpleMode() {
142: final TestWizard testWizard = new TestWizard(testClass, WINDOW_TITLE, null, selectionValidator,
143: segmentGenerator, null, true);
144: final WizardDialog wizardDialog = openWizard(testWizard);
145:
146: final SWTBot bot = new SWTBot(wizardDialog.getShell());
147: assertFalse(bot.button(BACK).isEnabled());
148: assertFalse(bot.button(NEXT).isEnabled());
149: assertTrue(bot.button(CANCEL).isEnabled());
150: assertFalse(bot.button(FINISH).isEnabled());
151:
152: SWTTestUtil.waitForUIThread();
153:
154: assertEquals(2, bot.tree().widget.getItemCount());
155:
156: // select invalid feature
157: bot.tree().getTreeItem("TestAttribute : EString").select();
158: assertFalse(bot.button(FINISH).isEnabled());
159:
160: final SWTBotTreeItem testRefItem = bot.tree().getTreeItem("TestReference : RefTestClass");
161: testRefItem.select();
162: assertTrue(bot.button(FINISH).isEnabled());
163: assertEquals(1, testRefItem.getItems().length);
164: testRefItem.expand();
165: testRefItem.getItems()[0].select();
166: assertTrue(bot.button(FINISH).isEnabled());
167:
168: bot.button(FINISH).click();
169:
170: assertTrue(testWizard.getRootEClass().isPresent());
171: assertSame(testClass, testWizard.getRootEClass().get());
172: // Verify that the segment generator was called once and the wizard handed in the correct list of features to
173: // the segment generator
174: verify(segmentGenerator, atLeastOnce())
175: .generateSegments(argThat(new FeatureListMatcher(testReference, subTestReference)));
176: assertTrue(testWizard.getDomainModelReference().isPresent());
177: final VDomainModelReference dmr = testWizard.getDomainModelReference().get();
178: assertEquals(2, dmr.getSegments().size());
179: }
180:
181: @Test
182: public void simpleMode_cancel() {
183: final TestWizard testWizard = new TestWizard(testClass, WINDOW_TITLE, null, selectionValidator,
184: segmentGenerator, null, true);
185: final WizardDialog wizardDialog = openWizard(testWizard);
186:
187: final SWTBot bot = new SWTBot(wizardDialog.getShell());
188: final SWTBotTreeItem testRefItem = bot.tree().getTreeItem("TestReference : RefTestClass");
189: testRefItem.select();
190: assertTrue(bot.button(FINISH).isEnabled());
191: bot.button(CANCEL).click();
192: SWTTestUtil.waitForUIThread();
193:
194: assertFalse(testWizard.getDomainModelReference().isPresent());
195: assertEquals(Window.CANCEL, wizardDialog.getReturnCode());
196: }
197:
198: @Test
199: public void simpleMode_initialSelection() {
200: // Create initial Dmr with two segments
201: final VDomainModelReference initialDmr = VViewFactory.eINSTANCE.createDomainModelReference();
202: final VFeatureDomainModelReferenceSegment initialFeatureSeg0 = VViewFactory.eINSTANCE
203: .createFeatureDomainModelReferenceSegment();
204: initialFeatureSeg0.setDomainModelFeature(testReference.getName());
205: final VFeatureDomainModelReferenceSegment initialFeatureSeg1 = VViewFactory.eINSTANCE
206: .createFeatureDomainModelReferenceSegment();
207: initialFeatureSeg1.setDomainModelFeature(subTestReference.getName());
208: initialDmr.getSegments().add(initialFeatureSeg0);
209: initialDmr.getSegments().add(initialFeatureSeg1);
210:
211: final TestWizard testWizard = new TestWizard(testClass, WINDOW_TITLE, initialDmr, selectionValidator,
212: segmentGenerator, null,
213: true);
214: final WizardDialog dialog = openWizard(testWizard);
215: final SWTBot bot = new SWTBot(dialog.getShell());
216:
217: final SWTBotTree botTree = bot.tree();
218: assertEquals(1, botTree.widget.getSelectionCount());
219: assertSame(subTestReference, botTree.widget.getSelection()[0].getData());
220:
221: bot.tree().getTreeItem("TestReference : RefTestClass").click();
222: SWTTestUtil.waitForUIThread();
223:
224: bot.button(FINISH).click();
225: SWTTestUtil.waitForUIThread();
226:
227: assertTrue(testWizard.getDomainModelReference().isPresent());
228:
229: final VDomainModelReference resultDmr = testWizard.getDomainModelReference().get();
230: // The wizard must create a new dmr and not manipulate the input dmr
231: assertNotSame(initialDmr, resultDmr);
232: assertEquals(2, initialDmr.getSegments().size());
233:
234: assertEquals(1, resultDmr.getSegments().size());
235: }
236:
237: /** Verifies that the switch to the advanced mode is disabled if there are no SegmentIdeDescriptors. */
238: @Test
239: public void advancedMode_noSegmentIdeDescriptors() {
240: final TestWizard testWizard = new TestWizard(testClass, WINDOW_TITLE, null, selectionValidator,
241: segmentGenerator, null, true);
242: final WizardDialog wizardDialog = openWizard(testWizard);
243:
244: final SWTBot bot = new SWTBot(wizardDialog.getShell());
245: final SWTBotButton advancedButton = bot.button("Switch To Advanced DMR Creation");
246: assertFalse("The advanced mode button must not be enabled if there are no SegmentIdeDescriptors.",
247: advancedButton.isEnabled());
248: assertNotNull(advancedButton.getToolTipText());
249: assertFalse("The advanced button must have a tooltip.", advancedButton.getToolTipText().isEmpty());
250: }
251:
252: @Test
253: public void advancedMode() {
254: final EClass segmentTypeA = createSegmentType("A");
255: final SegmentIdeDescriptor descriptorA = mockSimpleDescriptor(segmentTypeA);
256: final EClass segmentTypeB = createSegmentType("B");
257: final SegmentIdeDescriptor descriptorB = mockSimpleDescriptor(segmentTypeB);
258:
259: descriptors.add(descriptorA);
260: descriptors.add(descriptorB);
261: final TestWizard testWizard = new TestWizard(testClass, WINDOW_TITLE, null, selectionValidator,
262: segmentGenerator, null, true);
263: final WizardDialog wizardDialog = openWizard(testWizard);
264:
265: final SWTBot bot = new SWTBot(wizardDialog.getShell());
266: final SWTBotButton advancedButton = bot.button("Switch To Advanced DMR Creation");
267: assertTrue("The advanced mode button must be enabled if there are SegmentIdeDescriptors.",
268: advancedButton.isEnabled());
269: assertNotNull(advancedButton.getToolTipText());
270: assertFalse("The advanced button must have a tooltip.", advancedButton.getToolTipText().isEmpty());
271:
272: advancedButton.click();
273: SWTTestUtil.waitForUIThread();
274:
275: assertTrue(bot.button(BACK).isEnabled());
276: assertFalse(bot.button(NEXT).isEnabled());
277: assertTrue(bot.button(CANCEL).isEnabled());
278: assertFalse(bot.button(FINISH).isEnabled());
279:
280: // Advanced page 1; The root EClass for this page is TestClass
281: {
282: final SWTBotCombo combo = bot.comboBox();
283: assertTrue(combo.isEnabled());
284: assertEquals("One combo box entry for every segment ide descriptor.", 2, combo.itemCount());
285: assertEquals("A", combo.items()[0]);
286: assertEquals("B", combo.items()[1]);
287: combo.setSelection(0); // Select descriptor A
288: SWTTestUtil.waitForUIThread();
289: final String textBeforeFeatureSelect = bot
290: .widget(new WithClassAndData<Text>(Text.class, SWTDataElementIdHelper.ELEMENT_ID_KEY))
291: .getText();
292: assertTrue(textBeforeFeatureSelect == null || textBeforeFeatureSelect.isEmpty());
293: final SWTBotTable table = bot.table();
294: assertEquals("One entry for every feature in the current segment's root EClass.", 2,
295: table.widget.getItemCount());
296:
297: table.select(0);
298: SWTTestUtil.waitForUIThread();
299: assertFalse(bot.button(NEXT).isEnabled()); // EAttribute selected => next not possible
300:
301: table.select(1);
302: SWTTestUtil.waitForUIThread();
303: final String textAfterFeatureSelect = bot
304: .widget(new WithClassAndData<Text>(Text.class, SWTDataElementIdHelper.ELEMENT_ID_KEY))
305: .getText();
306: assertEquals(testReference.getName(), textAfterFeatureSelect);
307: assertTrue(bot.button(NEXT).isEnabled());
308: assertTrue(bot.button(FINISH).isEnabled());
309: }
310:
311: bot.button(NEXT).click();
312:
313: // Advanced page 2; The root EClass for this page is RefTestClass
314: {
315: final SWTBotCombo combo = bot.comboBox();
316: assertEquals("One combo box entry for every segment ide descriptor.", 2, combo.itemCount());
317: combo.setSelection(1); // Select descriptor B
318: SWTTestUtil.waitForUIThread();
319:
320: final String textBeforeFeatureSelect = bot
321: .widget(new WithClassAndData<Text>(Text.class, SWTDataElementIdHelper.ELEMENT_ID_KEY))
322: .getText();
323: assertTrue(textBeforeFeatureSelect == null || textBeforeFeatureSelect.isEmpty());
324: final SWTBotTable table = bot.table();
325: assertEquals("One entry for every feature in the current segment's root EClass.", 1,
326: table.widget.getItemCount());
327: table.select(0);
328: SWTTestUtil.waitForUIThread();
329: final String textAfterFeatureSelect = bot
330: .widget(new WithClassAndData<Text>(Text.class, SWTDataElementIdHelper.ELEMENT_ID_KEY))
331: .getText();
332: assertEquals(subTestReference.getName(), textAfterFeatureSelect);
333: assertTrue(bot.button(NEXT).isEnabled());
334: assertTrue(bot.button(FINISH).isEnabled());
335:
336: bot.button(FINISH).click();
337: SWTTestUtil.waitForUIThread();
338: }
339:
340: // Verify results of advanced mode
341: assertEquals(Window.OK, wizardDialog.getReturnCode());
342: final Optional<VDomainModelReference> dmr = testWizard.getDomainModelReference();
343: assertTrue(dmr.isPresent());
344: assertEquals(dmr.get().getSegments().size(), 2);
345: final VDomainModelReferenceSegment segment0 = dmr.get().getSegments().get(0);
346: final VDomainModelReferenceSegment segment1 = dmr.get().getSegments().get(1);
347: assertSame(segmentTypeA, segment0.eClass());
348: assertSame(segmentTypeB, segment1.eClass());
349: assertEquals(testReference.getName(),
350: segment0.eGet(VViewPackage.Literals.FEATURE_DOMAIN_MODEL_REFERENCE_SEGMENT__DOMAIN_MODEL_FEATURE));
351: assertEquals(subTestReference.getName(),
352: segment1.eGet(VViewPackage.Literals.FEATURE_DOMAIN_MODEL_REFERENCE_SEGMENT__DOMAIN_MODEL_FEATURE));
353: assertTrue(testWizard.getRootEClass().isPresent());
354: assertSame(testClass, testWizard.getRootEClass().get());
355: }
356:
357: /** Tests that using the back button in advanced mode works properly. */
358: @Test
359: public void advancedMode_back() {
360: final EClass segmentTypeA = createSegmentType("A");
361: final SegmentIdeDescriptor descriptorA = mockSimpleDescriptor(segmentTypeA);
362:
363: descriptors.add(descriptorA);
364: final TestWizard testWizard = new TestWizard(testClass, WINDOW_TITLE, null, selectionValidator,
365: segmentGenerator, null, true);
366: final WizardDialog wizardDialog = openWizard(testWizard);
367:
368: final SWTBot bot = new SWTBot(wizardDialog.getShell());
369: final SWTBotButton advancedButton = bot.button("Switch To Advanced DMR Creation");
370:
371: advancedButton.click();
372: SWTTestUtil.waitForUIThread();
373:
374: assertTrue(bot.button(BACK).isEnabled());
375: assertFalse(bot.button(NEXT).isEnabled());
376: assertTrue(bot.button(CANCEL).isEnabled());
377: assertFalse(bot.button(FINISH).isEnabled());
378:
379: // Advanced page 1; The root EClass for this page is TestClass
380: {
381: final SWTBotCombo combo = bot.comboBox();
382: assertEquals("A", combo.items()[0]);
383: combo.setSelection(0); // Select descriptor A
384: SWTTestUtil.waitForUIThread();
385: bot.table().select(1);
386: SWTTestUtil.waitForUIThread();
387: bot.button(NEXT).click();
388: }
389:
390: // Advanced page 2; The root EClass for this page is RefTestClass
391: {
392: final SWTBotCombo combo = bot.comboBox();
393: combo.setSelection(0); // Select descriptor A
394: SWTTestUtil.waitForUIThread();
395: bot.table().select(0);
396: SWTTestUtil.waitForUIThread();
397: assertTrue(bot.button(BACK).isEnabled());
398: bot.button(BACK).click();
399: SWTTestUtil.waitForUIThread();
400: }
401:
402: // Back at page one the finish button should still be activated
403: assertTrue(bot.button(FINISH).isEnabled());
404: bot.button(FINISH).click();
405: SWTTestUtil.waitForUIThread();
406:
407: // Verify results of advanced mode
408: assertEquals(Window.OK, wizardDialog.getReturnCode());
409: final Optional<VDomainModelReference> dmr = testWizard.getDomainModelReference();
410: assertTrue(dmr.isPresent());
411: // No segment must have been created for the page we backed out of.
412: assertEquals(dmr.get().getSegments().size(), 1);
413: final VDomainModelReferenceSegment segment = dmr.get().getSegments().get(0);
414: assertSame(segmentTypeA, segment.eClass());
415: assertEquals(testReference.getName(),
416: segment.eGet(VViewPackage.Literals.FEATURE_DOMAIN_MODEL_REFERENCE_SEGMENT__DOMAIN_MODEL_FEATURE));
417: assertTrue(testWizard.getRootEClass().isPresent());
418: assertSame(testClass, testWizard.getRootEClass().get());
419: }
420:
421: /** Tests that the advanced mode only allows to finish if the last segment's type matches a configured one. */
422: @Test
423: public void advancedMode_lastSegmentType() {
424: final EClass segmentTypeA = createSegmentType("A");
425: final SegmentIdeDescriptor descriptorA = mockSimpleDescriptor(segmentTypeA);
426: final EClass segmentTypeB = createSegmentType("B");
427: final SegmentIdeDescriptor descriptorB = mockSimpleDescriptor(segmentTypeB);
428:
429: descriptors.add(descriptorA);
430: descriptors.add(descriptorB);
431: // Require segmentTypeB as last segment
432: final TestWizard testWizard = new TestWizard(testClass, WINDOW_TITLE, null, selectionValidator,
433: segmentGenerator, segmentTypeB,
434: true);
435: final WizardDialog wizardDialog = openWizard(testWizard);
436:
437: final SWTBot bot = new SWTBot(wizardDialog.getShell());
438: final SWTBotButton advancedButton = bot.button("Switch To Advanced DMR Creation");
439: assertTrue("The advanced mode button must be enabled if there are SegmentIdeDescriptors.",
440: advancedButton.isEnabled());
441:
442: advancedButton.click();
443: SWTTestUtil.waitForUIThread();
444:
445: // Advanced page 1; The root EClass for this page is TestClass
446: {
447: final SWTBotCombo combo = bot.comboBox();
448: assertTrue(combo.isEnabled());
449: assertEquals("One combo box entry for every segment ide descriptor.", 2, combo.itemCount());
450: assertEquals("A", combo.items()[0]);
451: assertEquals("B", combo.items()[1]);
452: combo.setSelection(0); // Select descriptor A
453: SWTTestUtil.waitForUIThread();
454:
455: final SWTBotTable table = bot.table();
456: table.select(1);
457: SWTTestUtil.waitForUIThread();
458: assertTrue(bot.button(NEXT).isEnabled());
459: assertFalse(bot.button(FINISH).isEnabled());
460:
461: combo.setSelection(1); // Select descriptor B
462: SWTTestUtil.waitForUIThread();
463: assertTrue(bot.button(NEXT).isEnabled());
464: assertTrue(bot.button(FINISH).isEnabled());
465:
466: }
467: bot.button(FINISH).click();
468:
469: // Verify results of advanced mode
470: assertEquals(Window.OK, wizardDialog.getReturnCode());
471: final Optional<VDomainModelReference> dmr = testWizard.getDomainModelReference();
472: assertTrue(dmr.isPresent());
473: assertEquals(dmr.get().getSegments().size(), 1);
474: final VDomainModelReferenceSegment segment = dmr.get().getSegments().get(0);
475: assertSame(segmentTypeB, segment.eClass());
476: assertEquals(testReference.getName(),
477: segment.eGet(VViewPackage.Literals.FEATURE_DOMAIN_MODEL_REFERENCE_SEGMENT__DOMAIN_MODEL_FEATURE));
478: assertTrue(testWizard.getRootEClass().isPresent());
479: assertSame(testClass, testWizard.getRootEClass().get());
480: }
481:
482: //
483: // Test Framework
484: //
485:
486: /**
487: * @return the opened {@link WizardDialog} showing the wizard
488: */
489: private WizardDialog openWizard(Wizard wizard) {
490: final WizardDialog wizardDialog = new WizardDialog(shell, wizard);
491: wizardDialog.setBlockOnOpen(false);
492: wizardDialog.open();
493: SWTTestUtil.waitForUIThread();
494: return wizardDialog;
495: }
496:
497: private static EClass createSegmentType(String name) {
498: final EClass segmentClass = EcoreFactory.eINSTANCE.createEClass();
499: segmentClass.setName(name);
500: segmentClass.getESuperTypes().add(VViewPackage.Literals.FEATURE_DOMAIN_MODEL_REFERENCE_SEGMENT);
501:
502: final EPackage segmentPackage = EcoreFactory.eINSTANCE.createEPackage();
503: segmentPackage.setName("package-" + name);
504: segmentPackage.setNsPrefix("package-" + name);
505: segmentPackage.setNsURI("http://package-" + name);
506: segmentPackage.getEClassifiers().add(segmentClass);
507:
508: return segmentClass;
509: }
510:
511: private static SegmentIdeDescriptor mockSimpleDescriptor(EClass segmentType) {
512: final SegmentIdeDescriptor descriptor = mock(SegmentIdeDescriptor.class);
513: when(descriptor.getEStructuralFeatureSelectionValidator()).thenReturn(feature -> null); // always valid
514: when(descriptor.getReferenceTypeResolver()).thenReturn((ref, seg) -> ref.getEReferenceType());
515: when(descriptor.getSegmentType()).thenReturn(segmentType);
516: when(descriptor.isAllowedAsLastElementInPath()).thenReturn(true);
517: when(descriptor.isAvailableInIde()).thenReturn(true);
518: when(descriptor.isLastElementInPath()).thenReturn(false);
519: return descriptor;
520: }
521:
522: /**
523: * Argument matcher that validates that a list of structural features contains the specified features in the correct
524: * order.
525: */
526: private static class FeatureListMatcher extends ArgumentMatcher<List<EStructuralFeature>> {
527: private final EStructuralFeature[] features;
528:
529: FeatureListMatcher(EStructuralFeature... features) {
530: this.features = features;
531: }
532:
533: @Override
534: public boolean matches(Object argument) {
535: @SuppressWarnings("unchecked")
536: final List<EStructuralFeature> list = (List<EStructuralFeature>) argument;
537:• if (features.length != list.size()) {
538: return false;
539: }
540:• for (int i = 0; i < features.length; i++) {
541:• if (features[i] != list.get(i)) {
542: return false;
543: }
544: }
545: return true;
546: }
547: }
548:
549: /** Extend to avoid ide descriptor collection via OSGI */
550: private class TestWizard extends CreateSegmentDmrWizard {
551:
552: TestWizard(EClass rootEClass, String windowTitle, VDomainModelReference existingDMR,
553: EStructuralFeatureSelectionValidator selectionValidator, SegmentGenerator segmentGenerator,
554: EClass lastSegmentType, boolean ignoreSegmentIdeRestriction) {
555: super(rootEClass, windowTitle, existingDMR, selectionValidator, segmentGenerator, lastSegmentType,
556: ignoreSegmentIdeRestriction);
557: }
558:
559: @Override
560: protected Collection<SegmentIdeDescriptor> collectSegmentIdeDescriptors(boolean ignoreSegmentIdeRestriction) {
561: return descriptors;
562: }
563: }
564:
565: /** Matches a widget of a given class which has data for the given key. */
566: private static class WithClassAndData<T extends Widget> extends AbstractMatcher<T> {
567: private final String dataKey;
568: private final Class<T> clazz;
569:
570: WithClassAndData(Class<T> clazz, String dataKey) {
571: this.clazz = clazz;
572: this.dataKey = dataKey;
573: }
574:
575: @Override
576: public void describeTo(Description description) {
577: description
578: .appendText(
579: MessageFormat.format("with class ''{0}'' and data for key ''{1}''.", clazz.getName(), dataKey));
580: }
581:
582: @Override
583: protected boolean doMatch(Object item) {
584: if (!clazz.isInstance(item)) {
585: return false;
586: }
587: final Widget widget = (Widget) item;
588: return widget.getData(dataKey) != null;
589: }
590:
591: }
592: }