Skip to contentPackage: UnsetService_PTest$1
UnsetService_PTest$1
Coverage
1: /*******************************************************************************
2: * Copyright (c) 2011-2017 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: * Johannes Faltermeier - initial API and implementation
13: * Christian W. Damus - bug 527740
14: ******************************************************************************/
15: package org.eclipse.emf.ecp.view.unset.test;
16:
17: import static org.junit.Assert.assertEquals;
18: import static org.junit.Assert.assertFalse;
19: import static org.junit.Assert.assertTrue;
20:
21: import java.math.BigDecimal;
22: import java.util.Set;
23:
24: import org.eclipse.emf.ecore.EObject;
25: import org.eclipse.emf.ecore.EStructuralFeature;
26: import org.eclipse.emf.ecore.EStructuralFeature.Setting;
27: import org.eclipse.emf.ecp.common.spi.UniqueSetting;
28: import org.eclipse.emf.ecp.test.common.DefaultRealm;
29: import org.eclipse.emf.ecp.view.internal.unset.UnsetService;
30: import org.eclipse.emf.ecp.view.spi.categorization.model.VCategorization;
31: import org.eclipse.emf.ecp.view.spi.categorization.model.VCategorizationElement;
32: import org.eclipse.emf.ecp.view.spi.categorization.model.VCategorizationFactory;
33: import org.eclipse.emf.ecp.view.spi.categorization.model.VCategory;
34: import org.eclipse.emf.ecp.view.spi.context.ViewModelContext;
35: import org.eclipse.emf.ecp.view.spi.context.ViewModelContextDisposeListener;
36: import org.eclipse.emf.ecp.view.spi.context.ViewModelContextFactory;
37: import org.eclipse.emf.ecp.view.spi.context.ViewModelService;
38: import org.eclipse.emf.ecp.view.spi.context.ViewModelServiceProvider;
39: import org.eclipse.emf.ecp.view.spi.model.ModelChangeListener;
40: import org.eclipse.emf.ecp.view.spi.model.VContainedContainer;
41: import org.eclipse.emf.ecp.view.spi.model.VControl;
42: import org.eclipse.emf.ecp.view.spi.model.VElement;
43: import org.eclipse.emf.ecp.view.spi.model.VFeaturePathDomainModelReference;
44: import org.eclipse.emf.ecp.view.spi.model.VView;
45: import org.eclipse.emf.ecp.view.spi.model.VViewFactory;
46: import org.eclipse.emf.ecp.view.spi.model.VViewPackage;
47: import org.eclipse.emf.ecp.view.spi.table.model.VTableControl;
48: import org.eclipse.emf.ecp.view.spi.table.model.VTableDomainModelReference;
49: import org.eclipse.emf.ecp.view.spi.table.model.VTableFactory;
50: import org.eclipse.emf.ecp.view.spi.vertical.model.VVerticalFactory;
51: import org.eclipse.emf.ecp.view.spi.vertical.model.VVerticalLayout;
52: import org.eclipse.emf.emfstore.bowling.BowlingFactory;
53: import org.eclipse.emf.emfstore.bowling.BowlingPackage;
54: import org.eclipse.emf.emfstore.bowling.Fan;
55: import org.eclipse.emf.emfstore.bowling.Merchandise;
56: import org.eclipse.emfforms.spi.core.services.view.EMFFormsContextListener;
57: import org.eclipse.emfforms.spi.core.services.view.RootDomainModelChangeListener;
58: import org.junit.After;
59: import org.junit.Before;
60: import org.junit.Test;
61:
62: /**
63: * @author jfaltermeier
64: *
65: */
66: public class UnsetService_PTest {
67:
68: private Fan fan;
69: private Merchandise merchandise;
70:
71: private final EStructuralFeature merchandisePriceFeature = BowlingPackage.eINSTANCE.getMerchandise_Price();
72: private final EStructuralFeature merchandiseNameFeature = BowlingPackage.eINSTANCE.getMerchandise_Name();
73: private final EStructuralFeature fanNameFeature = BowlingPackage.eINSTANCE.getFan_Name();
74: private final BigDecimal price = new BigDecimal(19.84);
75: private final String mercName = "Wimpel";
76: private final String fanName = "Max Morlock";
77:
78: private VView view;
79:
80: private ViewModelContext context;
81: private DefaultRealm realm;
82:
83: @Before
84: public void before() {
85: realm = new DefaultRealm();
86: fan = BowlingFactory.eINSTANCE.createFan();
87: merchandise = BowlingFactory.eINSTANCE.createMerchandise();
88: merchandise.setPrice(price);
89: merchandise.setName(mercName);
90: fan.setFavouriteMerchandise(merchandise);
91: fan.setName(fanName);
92:
93: view = VViewFactory.eINSTANCE.createView();
94: view.setRootEClass(fan.eClass());
95: }
96:
97: @After
98: public void after() {
99: if (context != null) {
100: context.dispose();
101: }
102: realm.dispose();
103: }
104:
105: // ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
106: // Public methods
107: // ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
108:
109: @Test
110: public void testInstantiate() {
111: final UnsetService unsetService = new UnsetService();
112: final ViewModelContextStub contextStub = new ViewModelContextStub();
113: unsetService.instantiate(contextStub);
114: assertTrue(contextStub.hasRegisteredViewListener);
115: assertFalse(contextStub.hasRegisteredDomainListener);
116: }
117:
118: @Test(expected = IllegalStateException.class)
119: public void testInstantiateWithNullDomainModel() {
120: final UnsetService unsetService = new UnsetService();
121: final ViewModelContextStub contextStub = new ViewModelContextStub() {
122: @Override
123: public EObject getDomainModel() {
124: return null;
125: }
126: };
127: unsetService.instantiate(contextStub);
128: }
129:
130: @Test(expected = IllegalStateException.class)
131: public void testInstantiateWithNullViewModel() {
132: final UnsetService unsetService = new UnsetService();
133: final ViewModelContextStub contextStub = new ViewModelContextStub() {
134: @Override
135: public VElement getViewModel() {
136: return null;
137: }
138: };
139: unsetService.instantiate(contextStub);
140: }
141:
142: @Test
143: public void testDispose() {
144: final UnsetService unsetService = new UnsetService();
145: final ViewModelContextStub contextStub = new ViewModelContextStub();
146: unsetService.instantiate(contextStub);
147: assertTrue(contextStub.hasRegisteredViewListener);
148: assertFalse(contextStub.hasRegisteredDomainListener);
149: unsetService.dispose();
150: assertFalse(contextStub.hasRegisteredViewListener);
151: assertFalse(contextStub.hasRegisteredDomainListener);
152: }
153:
154: @Test
155: public void testGetPriority() {
156: assertEquals(5, unsetService().getPriority());
157: }
158:
159: // ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
160: // Init
161: // ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
162:
163: @Test
164: public void testInitSingleControlInViewAllVisible() {
165: addControlToView(merchandisePriceReferenceFromFan());
166: unsetService();
167: assertEquals(price, merchandise.getPrice());
168: assertTrue(merchandise.eIsSet(merchandisePriceFeature));
169: }
170:
171: @Test
172: public void testInitSingleControlInViewWithHiddenControl() {
173: addControlToView(merchandisePriceReferenceFromFan()).setVisible(false);
174: unsetService();
175: assertEquals(merchandisePriceFeature.getDefaultValue(), merchandise.getPrice());
176: assertFalse(merchandise.eIsSet(merchandisePriceFeature));
177: }
178:
179: @Test
180: public void testInitSingleControlInViewWithHiddenView() {
181: addControlToView(merchandisePriceReferenceFromFan());
182: view.setVisible(false);
183: unsetService();
184: assertEquals(merchandisePriceFeature.getDefaultValue(), merchandise.getPrice());
185: assertFalse(merchandise.eIsSet(merchandisePriceFeature));
186: }
187:
188: @Test
189: public void testInitSingleControlInContainerAllVisible() {
190: addControlToContainer(addVerticalLayoutToView(), merchandisePriceReferenceFromFan());
191: unsetService();
192: assertEquals(price, merchandise.getPrice());
193: assertTrue(merchandise.eIsSet(merchandisePriceFeature));
194: }
195:
196: @Test
197: public void testInitSingleControlInContainerWithHiddenControl() {
198: addControlToContainer(addVerticalLayoutToView(), merchandisePriceReferenceFromFan()).setVisible(false);
199: unsetService();
200: assertEquals(merchandisePriceFeature.getDefaultValue(), merchandise.getPrice());
201: assertFalse(merchandise.eIsSet(merchandisePriceFeature));
202: }
203:
204: @Test
205: public void testInitSingleControlInContainerWithHiddenContainer() {
206: final VContainedContainer container = addVerticalLayoutToView();
207: addControlToContainer(container, merchandisePriceReferenceFromFan());
208: container.setVisible(false);
209: unsetService();
210: assertEquals(merchandisePriceFeature.getDefaultValue(), merchandise.getPrice());
211: assertFalse(merchandise.eIsSet(merchandisePriceFeature));
212: }
213:
214: @Test
215: public void testInitSingleControlInContainerWithHiddenView() {
216: addControlToContainer(addVerticalLayoutToView(), merchandisePriceReferenceFromFan());
217: view.setVisible(false);
218: unsetService();
219: assertEquals(merchandisePriceFeature.getDefaultValue(), merchandise.getPrice());
220: assertFalse(merchandise.eIsSet(merchandisePriceFeature));
221: }
222:
223: @Test
224: public void testInitTwoControlsInViewAllVisible() {
225: addControlToView(merchandisePriceReferenceFromFan());
226: addControlToView(merchandisePriceReferenceFromFan());
227: unsetService();
228: assertEquals(price, merchandise.getPrice());
229: assertTrue(merchandise.eIsSet(merchandisePriceFeature));
230: }
231:
232: @Test
233: public void testInitTwoControlsInViewWithOneHiddenControl() {
234: addControlToView(merchandisePriceReferenceFromFan());
235: addControlToView(merchandisePriceReferenceFromFan()).setVisible(false);
236: unsetService();
237: assertEquals(price, merchandise.getPrice());
238: assertTrue(merchandise.eIsSet(merchandisePriceFeature));
239: }
240:
241: @Test
242: public void testInitTwoControlsInViewWithTwoHiddenControls() {
243: addControlToView(merchandisePriceReferenceFromFan()).setVisible(false);
244: addControlToView(merchandisePriceReferenceFromFan()).setVisible(false);
245: unsetService();
246: assertEquals(merchandisePriceFeature.getDefaultValue(), merchandise.getPrice());
247: assertFalse(merchandise.eIsSet(merchandisePriceFeature));
248: }
249:
250: @Test
251: public void testInitTwoControlsInViewWithHiddenView() {
252: addControlToView(merchandisePriceReferenceFromFan());
253: addControlToView(merchandisePriceReferenceFromFan());
254: view.setVisible(false);
255: unsetService();
256: assertEquals(merchandisePriceFeature.getDefaultValue(), merchandise.getPrice());
257: assertFalse(merchandise.eIsSet(merchandisePriceFeature));
258: }
259:
260: @Test
261: public void testInitTwoControlsInOneContainerAllVisible() {
262: final VContainedContainer container = addVerticalLayoutToView();
263: addControlToContainer(container, merchandisePriceReferenceFromFan());
264: addControlToContainer(container, merchandisePriceReferenceFromFan());
265: unsetService();
266: assertEquals(price, merchandise.getPrice());
267: assertTrue(merchandise.eIsSet(merchandisePriceFeature));
268: }
269:
270: @Test
271: public void testInitTwoControlsInOneContainerWithOneHiddenControl() {
272: final VContainedContainer container = addVerticalLayoutToView();
273: addControlToContainer(container, merchandisePriceReferenceFromFan());
274: addControlToContainer(container, merchandisePriceReferenceFromFan()).setVisible(false);
275: unsetService();
276: assertEquals(price, merchandise.getPrice());
277: assertTrue(merchandise.eIsSet(merchandisePriceFeature));
278: }
279:
280: @Test
281: public void testInitTwoControlsInOneContainerWithTwoHiddenControls() {
282: final VContainedContainer container = addVerticalLayoutToView();
283: addControlToContainer(container, merchandisePriceReferenceFromFan()).setVisible(false);
284: addControlToContainer(container, merchandisePriceReferenceFromFan()).setVisible(false);
285: unsetService();
286: assertEquals(merchandisePriceFeature.getDefaultValue(), merchandise.getPrice());
287: assertFalse(merchandise.eIsSet(merchandisePriceFeature));
288: }
289:
290: @Test
291: public void testInitTwoControlsInOneContainerWithHiddenContainer() {
292: final VContainedContainer container = addVerticalLayoutToView();
293: addControlToContainer(container, merchandisePriceReferenceFromFan());
294: addControlToContainer(container, merchandisePriceReferenceFromFan());
295: container.setVisible(false);
296: unsetService();
297: assertEquals(merchandisePriceFeature.getDefaultValue(), merchandise.getPrice());
298: assertFalse(merchandise.eIsSet(merchandisePriceFeature));
299: }
300:
301: @Test
302: public void testInitTwoControlsInOneContainerWithHiddenView() {
303: final VContainedContainer container = addVerticalLayoutToView();
304: addControlToContainer(container, merchandisePriceReferenceFromFan());
305: addControlToContainer(container, merchandisePriceReferenceFromFan());
306: view.setVisible(false);
307: unsetService();
308: assertEquals(merchandisePriceFeature.getDefaultValue(), merchandise.getPrice());
309: assertFalse(merchandise.eIsSet(merchandisePriceFeature));
310: }
311:
312: @Test
313: public void testInitTwoControlsInTwoContainersAllVisible() {
314: final VContainedContainer container1 = addVerticalLayoutToView();
315: final VContainedContainer container2 = addVerticalLayoutToView();
316: addControlToContainer(container1, merchandisePriceReferenceFromFan());
317: addControlToContainer(container2, merchandisePriceReferenceFromFan());
318: unsetService();
319: assertEquals(price, merchandise.getPrice());
320: assertTrue(merchandise.eIsSet(merchandisePriceFeature));
321: }
322:
323: @Test
324: public void testInitTwoControlsInTwoContainersWithOneHiddenControl() {
325: final VContainedContainer container1 = addVerticalLayoutToView();
326: final VContainedContainer container2 = addVerticalLayoutToView();
327: addControlToContainer(container1, merchandisePriceReferenceFromFan());
328: addControlToContainer(container2, merchandisePriceReferenceFromFan()).setVisible(false);
329: unsetService();
330: assertEquals(price, merchandise.getPrice());
331: assertTrue(merchandise.eIsSet(merchandisePriceFeature));
332: }
333:
334: @Test
335: public void testInitTwoControlsInTwoContainersWithOneHiddenContainer() {
336: final VContainedContainer container1 = addVerticalLayoutToView();
337: final VContainedContainer container2 = addVerticalLayoutToView();
338: addControlToContainer(container1, merchandisePriceReferenceFromFan());
339: addControlToContainer(container2, merchandisePriceReferenceFromFan());
340: container1.setVisible(false);
341: unsetService();
342: assertEquals(price, merchandise.getPrice());
343: assertTrue(merchandise.eIsSet(merchandisePriceFeature));
344: }
345:
346: @Test
347: public void testInitTwoControlsInTwoContainersWithTwoHiddenControls() {
348: final VContainedContainer container1 = addVerticalLayoutToView();
349: final VContainedContainer container2 = addVerticalLayoutToView();
350: addControlToContainer(container1, merchandisePriceReferenceFromFan()).setVisible(false);
351: addControlToContainer(container2, merchandisePriceReferenceFromFan()).setVisible(false);
352: unsetService();
353: assertEquals(merchandisePriceFeature.getDefaultValue(), merchandise.getPrice());
354: assertFalse(merchandise.eIsSet(merchandisePriceFeature));
355: }
356:
357: @Test
358: public void testInitTwoControlsInTwoContainersWithTwoHiddenContainers() {
359: final VContainedContainer container1 = addVerticalLayoutToView();
360: final VContainedContainer container2 = addVerticalLayoutToView();
361: addControlToContainer(container1, merchandisePriceReferenceFromFan());
362: addControlToContainer(container2, merchandisePriceReferenceFromFan());
363: container1.setVisible(false);
364: container2.setVisible(false);
365: unsetService();
366: assertEquals(merchandisePriceFeature.getDefaultValue(), merchandise.getPrice());
367: assertFalse(merchandise.eIsSet(merchandisePriceFeature));
368: }
369:
370: @Test
371: public void testInitTwoControlsInTwoContainersWithHiddenView() {
372: final VContainedContainer container1 = addVerticalLayoutToView();
373: final VContainedContainer container2 = addVerticalLayoutToView();
374: addControlToContainer(container1, merchandisePriceReferenceFromFan());
375: addControlToContainer(container2, merchandisePriceReferenceFromFan());
376: view.setVisible(false);
377: unsetService();
378: assertEquals(merchandisePriceFeature.getDefaultValue(), merchandise.getPrice());
379: assertFalse(merchandise.eIsSet(merchandisePriceFeature));
380: }
381:
382: // ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
383: // Dynamic
384: // ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
385:
386: @Test
387: public void testChangeSingleControlInViewAllVisibleToHiddenControl() {
388: final VControl control = addControlToView(merchandisePriceReferenceFromFan());
389: unsetService();
390: control.setVisible(false);
391: assertEquals(merchandisePriceFeature.getDefaultValue(), merchandise.getPrice());
392: assertFalse(merchandise.eIsSet(merchandisePriceFeature));
393: }
394:
395: @Test
396: public void testChangeSingleControlInViewAllVisibleToHiddenView() {
397: addControlToView(merchandisePriceReferenceFromFan());
398: unsetService();
399: view.setVisible(false);
400: assertEquals(merchandisePriceFeature.getDefaultValue(), merchandise.getPrice());
401: assertFalse(merchandise.eIsSet(merchandisePriceFeature));
402: }
403:
404: @Test
405: public void testChangeSingleControlInViewWithHiddenControlToVisibleControl() {
406: final VControl control = addControlToView(merchandisePriceReferenceFromFan());
407: control.setVisible(false);
408: unsetService();
409: control.setVisible(true);
410: // we dont change the state of the domain model when shown again. if this changes assertions can be added here
411: merchandise.setPrice(price);
412: control.setVisible(false);
413: assertEquals(merchandisePriceFeature.getDefaultValue(), merchandise.getPrice());
414: assertFalse(merchandise.eIsSet(merchandisePriceFeature));
415: }
416:
417: @Test
418: public void testChangeSingleControlInViewWithHiddenControlToHiddenView() {
419: final VControl control = addControlToView(merchandisePriceReferenceFromFan());
420: control.setVisible(false);
421: unsetService();
422: view.setVisible(false);
423: assertEquals(merchandisePriceFeature.getDefaultValue(), merchandise.getPrice());
424: assertFalse(merchandise.eIsSet(merchandisePriceFeature));
425: }
426:
427: @Test
428: public void testChangeSingleControlInViewWithHiddenViewToHiddenControl() {
429: final VControl control = addControlToView(merchandisePriceReferenceFromFan());
430: view.setVisible(false);
431: unsetService();
432: control.setVisible(false);
433: assertEquals(merchandisePriceFeature.getDefaultValue(), merchandise.getPrice());
434: assertFalse(merchandise.eIsSet(merchandisePriceFeature));
435: }
436:
437: @Test
438: public void testChangeSingleControlInViewWithHiddenViewToVisibleView() {
439: addControlToView(merchandisePriceReferenceFromFan());
440: view.setVisible(false);
441: unsetService();
442: view.setVisible(true);
443:
444: // we dont change the state of the domain model when shown again. if this changes assertions can be added here
445: merchandise.setPrice(price);
446: view.setVisible(false);
447: assertEquals(merchandisePriceFeature.getDefaultValue(), merchandise.getPrice());
448: assertFalse(merchandise.eIsSet(merchandisePriceFeature));
449: }
450:
451: @Test
452: public void testChangeSingleControlInContainerAllVisibleToHiddenControl() {
453: final VControl control = addControlToContainer(addVerticalLayoutToView(), merchandisePriceReferenceFromFan());
454: unsetService();
455: control.setVisible(false);
456: assertEquals(merchandisePriceFeature.getDefaultValue(), merchandise.getPrice());
457: assertFalse(merchandise.eIsSet(merchandisePriceFeature));
458: }
459:
460: @Test
461: public void testChangeSingleControlInContainerAllVisibleToHiddenContainer() {
462: final VContainedContainer container = addVerticalLayoutToView();
463: addControlToContainer(container, merchandisePriceReferenceFromFan());
464: unsetService();
465: container.setVisible(false);
466: assertEquals(merchandisePriceFeature.getDefaultValue(), merchandise.getPrice());
467: assertFalse(merchandise.eIsSet(merchandisePriceFeature));
468: }
469:
470: @Test
471: public void testChangeSingleControlInContainerAllVisibleToHiddenView() {
472: final VContainedContainer container = addVerticalLayoutToView();
473: addControlToContainer(container, merchandisePriceReferenceFromFan());
474: unsetService();
475: view.setVisible(false);
476: assertEquals(merchandisePriceFeature.getDefaultValue(), merchandise.getPrice());
477: assertFalse(merchandise.eIsSet(merchandisePriceFeature));
478: }
479:
480: @Test
481: public void testChangeSingleControlInContainerWithHiddenControlToHiddenContainer() {
482: final VContainedContainer container = addVerticalLayoutToView();
483: addControlToContainer(container, merchandisePriceReferenceFromFan()).setVisible(false);
484: unsetService();
485: container.setVisible(false);
486: assertEquals(merchandisePriceFeature.getDefaultValue(), merchandise.getPrice());
487: assertFalse(merchandise.eIsSet(merchandisePriceFeature));
488: }
489:
490: @Test
491: public void testChangeSingleControlInContainerWithHiddenControlToHiddenView() {
492: final VContainedContainer container = addVerticalLayoutToView();
493: addControlToContainer(container, merchandisePriceReferenceFromFan()).setVisible(false);
494: unsetService();
495: view.setVisible(false);
496: assertEquals(merchandisePriceFeature.getDefaultValue(), merchandise.getPrice());
497: assertFalse(merchandise.eIsSet(merchandisePriceFeature));
498: }
499:
500: @Test
501: public void testChangeSingleControlInContainerWithHiddenControlToVisibleControl() {
502: final VContainedContainer container = addVerticalLayoutToView();
503: final VControl control = addControlToContainer(container, merchandisePriceReferenceFromFan());
504: control.setVisible(false);
505: unsetService();
506: control.setVisible(true);
507:
508: // we dont change the state of the domain model when shown again. if this changes assertions can be added here
509: merchandise.setPrice(price);
510: control.setVisible(false);
511: assertEquals(merchandisePriceFeature.getDefaultValue(), merchandise.getPrice());
512: assertFalse(merchandise.eIsSet(merchandisePriceFeature));
513: }
514:
515: @Test
516: public void testChangeSingleControlInContainerWithHiddenContainerToHiddenControl() {
517: final VContainedContainer container = addVerticalLayoutToView();
518: final VControl control = addControlToContainer(container, merchandisePriceReferenceFromFan());
519: container.setVisible(false);
520: unsetService();
521: control.setVisible(false);
522: assertEquals(merchandisePriceFeature.getDefaultValue(), merchandise.getPrice());
523: assertFalse(merchandise.eIsSet(merchandisePriceFeature));
524: }
525:
526: @Test
527: public void testChangeSingleControlInContainerWithHiddenContainerToHiddenView() {
528: final VContainedContainer container = addVerticalLayoutToView();
529: addControlToContainer(container, merchandisePriceReferenceFromFan());
530: container.setVisible(false);
531: unsetService();
532: view.setVisible(false);
533: assertEquals(merchandisePriceFeature.getDefaultValue(), merchandise.getPrice());
534: assertFalse(merchandise.eIsSet(merchandisePriceFeature));
535: }
536:
537: @Test
538: public void testChangeSingleControlInContainerWithHiddenContainerToVisibleContainer() {
539: final VContainedContainer container = addVerticalLayoutToView();
540: addControlToContainer(container, merchandisePriceReferenceFromFan());
541: container.setVisible(false);
542: unsetService();
543: container.setVisible(true);
544:
545: // we dont change the state of the domain model when shown again. if this changes assertions can be added here
546: merchandise.setPrice(price);
547: container.setVisible(false);
548: assertEquals(merchandisePriceFeature.getDefaultValue(), merchandise.getPrice());
549: assertFalse(merchandise.eIsSet(merchandisePriceFeature));
550: }
551:
552: @Test
553: public void testChangeSingleControlInContainerWithHiddenViewToHiddenControl() {
554: final VControl control = addControlToContainer(addVerticalLayoutToView(), merchandisePriceReferenceFromFan());
555: view.setVisible(false);
556: unsetService();
557: control.setVisible(false);
558: assertEquals(merchandisePriceFeature.getDefaultValue(), merchandise.getPrice());
559: assertFalse(merchandise.eIsSet(merchandisePriceFeature));
560: }
561:
562: @Test
563: public void testChangeSingleControlInContainerWithHiddenViewToHiddenContainer() {
564: final VContainedContainer container = addVerticalLayoutToView();
565: addControlToContainer(container, merchandisePriceReferenceFromFan());
566: view.setVisible(false);
567: unsetService();
568: container.setVisible(false);
569: assertEquals(merchandisePriceFeature.getDefaultValue(), merchandise.getPrice());
570: assertFalse(merchandise.eIsSet(merchandisePriceFeature));
571: }
572:
573: @Test
574: public void testChangeSingleControlInContainerWithHiddenViewToVisibleView() {
575: final VContainedContainer container = addVerticalLayoutToView();
576: addControlToContainer(container, merchandisePriceReferenceFromFan());
577: view.setVisible(false);
578: unsetService();
579: view.setVisible(true);
580:
581: // we dont change the state of the domain model when shown again. if this changes assertions can be added here
582: merchandise.setPrice(price);
583: view.setVisible(false);
584: assertEquals(merchandisePriceFeature.getDefaultValue(), merchandise.getPrice());
585: assertFalse(merchandise.eIsSet(merchandisePriceFeature));
586: }
587:
588: @Test
589: public void testChangeTwoControlsInViewAllVisibleToOneHiddenControl() {
590: addControlToView(merchandisePriceReferenceFromFan());
591: final VControl control = addControlToView(merchandisePriceReferenceFromFan());
592: unsetService();
593: control.setVisible(false);
594: assertEquals(price, merchandise.getPrice());
595: assertTrue(merchandise.eIsSet(merchandisePriceFeature));
596: }
597:
598: @Test
599: public void testChangeTwoControlsInViewAllVisibleToOneHiddenView() {
600: addControlToView(merchandisePriceReferenceFromFan());
601: addControlToView(merchandisePriceReferenceFromFan());
602: unsetService();
603: view.setVisible(false);
604: assertEquals(merchandisePriceFeature.getDefaultValue(), merchandise.getPrice());
605: assertFalse(merchandise.eIsSet(merchandisePriceFeature));
606: }
607:
608: @Test
609: public void testChangeTwoControlsInViewWithOneHiddenControlToTwoVisibleControls() {
610: addControlToView(merchandisePriceReferenceFromFan());
611: final VControl control = addControlToView(merchandisePriceReferenceFromFan());
612: control.setVisible(false);
613: unsetService();
614: control.setVisible(true);
615: assertEquals(price, merchandise.getPrice());
616: assertTrue(merchandise.eIsSet(merchandisePriceFeature));
617: }
618:
619: @Test
620: public void testChangeTwoControlsInViewWithOneHiddenControlToTwoHiddenControls() {
621: final VControl control = addControlToView(merchandisePriceReferenceFromFan());
622: addControlToView(merchandisePriceReferenceFromFan()).setVisible(false);
623: unsetService();
624: control.setVisible(false);
625: assertEquals(merchandisePriceFeature.getDefaultValue(), merchandise.getPrice());
626: assertFalse(merchandise.eIsSet(merchandisePriceFeature));
627: }
628:
629: @Test
630: public void testChangeTwoControlsInViewWithOneHiddenControlToHiddenView() {
631: addControlToView(merchandisePriceReferenceFromFan());
632: addControlToView(merchandisePriceReferenceFromFan()).setVisible(false);
633: unsetService();
634: view.setVisible(false);
635: assertEquals(merchandisePriceFeature.getDefaultValue(), merchandise.getPrice());
636: assertFalse(merchandise.eIsSet(merchandisePriceFeature));
637: }
638:
639: @Test
640: public void testChangeTwoControlsInViewWithTwoHiddenControlsToHiddenView() {
641: addControlToView(merchandisePriceReferenceFromFan()).setVisible(false);
642: addControlToView(merchandisePriceReferenceFromFan()).setVisible(false);
643: unsetService();
644: view.setVisible(false);
645: assertEquals(merchandisePriceFeature.getDefaultValue(), merchandise.getPrice());
646: assertFalse(merchandise.eIsSet(merchandisePriceFeature));
647: }
648:
649: @Test
650: public void testChangeTwoControlsInViewWithTwoHiddenControlsToOneVisibleControl() {
651: addControlToView(merchandisePriceReferenceFromFan()).setVisible(false);
652: final VControl control = addControlToView(merchandisePriceReferenceFromFan());
653: control.setVisible(false);
654: unsetService();
655: control.setVisible(true);
656:
657: // we dont change the state of the domain model when shown again. if this changes assertions can be added here
658: merchandise.setPrice(price);
659: control.setVisible(false);
660: assertEquals(merchandisePriceFeature.getDefaultValue(), merchandise.getPrice());
661: assertFalse(merchandise.eIsSet(merchandisePriceFeature));
662: }
663:
664: @Test
665: public void testChangeTwoControlsInViewWithHiddenViewToHiddenControl() {
666: addControlToView(merchandisePriceReferenceFromFan());
667: final VControl control = addControlToView(merchandisePriceReferenceFromFan());
668: view.setVisible(false);
669: unsetService();
670: control.setVisible(false);
671: assertEquals(merchandisePriceFeature.getDefaultValue(), merchandise.getPrice());
672: assertFalse(merchandise.eIsSet(merchandisePriceFeature));
673: }
674:
675: @Test
676: public void testChangeTwoControlsInViewWithHiddenViewToVisibleView() {
677: addControlToView(merchandisePriceReferenceFromFan());
678: addControlToView(merchandisePriceReferenceFromFan());
679: view.setVisible(false);
680: unsetService();
681: view.setVisible(true);
682:
683: // we dont change the state of the domain model when shown again. if this changes assertions can be added here
684: merchandise.setPrice(price);
685: view.setVisible(false);
686: assertEquals(merchandisePriceFeature.getDefaultValue(), merchandise.getPrice());
687: assertFalse(merchandise.eIsSet(merchandisePriceFeature));
688: }
689:
690: @Test
691: public void testChangeTwoControlsInOneContainerAllVisibleToOneHiddenControl() {
692: final VContainedContainer container = addVerticalLayoutToView();
693: addControlToContainer(container, merchandisePriceReferenceFromFan());
694: final VControl control = addControlToContainer(container, merchandisePriceReferenceFromFan());
695: unsetService();
696: control.setVisible(false);
697: assertEquals(price, merchandise.getPrice());
698: assertTrue(merchandise.eIsSet(merchandisePriceFeature));
699: }
700:
701: @Test
702: public void testChangeTwoControlsInOneContainerAllVisibleToHiddenContainer() {
703: final VContainedContainer container = addVerticalLayoutToView();
704: addControlToContainer(container, merchandisePriceReferenceFromFan());
705: addControlToContainer(container, merchandisePriceReferenceFromFan());
706: unsetService();
707: container.setVisible(false);
708: assertEquals(merchandisePriceFeature.getDefaultValue(), merchandise.getPrice());
709: assertFalse(merchandise.eIsSet(merchandisePriceFeature));
710: }
711:
712: @Test
713: public void testChangeTwoControlsInOneContainerAllVisibleToHiddenView() {
714: final VContainedContainer container = addVerticalLayoutToView();
715: addControlToContainer(container, merchandisePriceReferenceFromFan());
716: addControlToContainer(container, merchandisePriceReferenceFromFan());
717: unsetService();
718: view.setVisible(false);
719: assertEquals(merchandisePriceFeature.getDefaultValue(), merchandise.getPrice());
720: assertFalse(merchandise.eIsSet(merchandisePriceFeature));
721: }
722:
723: @Test
724: public void testChangeTwoControlsInOneContainerWithOneHiddenControlToTwoVisibleControls() {
725: final VContainedContainer container = addVerticalLayoutToView();
726: addControlToContainer(container, merchandisePriceReferenceFromFan());
727: final VControl control = addControlToContainer(container, merchandisePriceReferenceFromFan());
728: control.setVisible(false);
729: unsetService();
730: control.setVisible(true);
731: assertEquals(price, merchandise.getPrice());
732: assertTrue(merchandise.eIsSet(merchandisePriceFeature));
733: }
734:
735: @Test
736: public void testChangeTwoControlsInOneContainerWithOneHiddenControlToTwoHiddenControls() {
737: final VContainedContainer container = addVerticalLayoutToView();
738: final VControl control = addControlToContainer(container, merchandisePriceReferenceFromFan());
739: addControlToContainer(container, merchandisePriceReferenceFromFan()).setVisible(false);
740: unsetService();
741: control.setVisible(false);
742: assertEquals(merchandisePriceFeature.getDefaultValue(), merchandise.getPrice());
743: assertFalse(merchandise.eIsSet(merchandisePriceFeature));
744: }
745:
746: @Test
747: public void testChangeTwoControlsInOneContainerWithOneHiddenControlToHiddenContainer() {
748: final VContainedContainer container = addVerticalLayoutToView();
749: addControlToContainer(container, merchandisePriceReferenceFromFan());
750: addControlToContainer(container, merchandisePriceReferenceFromFan()).setVisible(false);
751: unsetService();
752: container.setVisible(false);
753: assertEquals(merchandisePriceFeature.getDefaultValue(), merchandise.getPrice());
754: assertFalse(merchandise.eIsSet(merchandisePriceFeature));
755: }
756:
757: @Test
758: public void testChangeTwoControlsInOneContainerWithOneHiddenControlToHiddenView() {
759: final VContainedContainer container = addVerticalLayoutToView();
760: addControlToContainer(container, merchandisePriceReferenceFromFan());
761: addControlToContainer(container, merchandisePriceReferenceFromFan()).setVisible(false);
762: unsetService();
763: view.setVisible(false);
764: assertEquals(merchandisePriceFeature.getDefaultValue(), merchandise.getPrice());
765: assertFalse(merchandise.eIsSet(merchandisePriceFeature));
766: }
767:
768: @Test
769: public void testChangeTwoControlsInOneContainerWithTwoHiddenControlsToHiddenContainer() {
770: final VContainedContainer container = addVerticalLayoutToView();
771: addControlToContainer(container, merchandisePriceReferenceFromFan()).setVisible(false);
772: addControlToContainer(container, merchandisePriceReferenceFromFan()).setVisible(false);
773: unsetService();
774: container.setVisible(false);
775: assertEquals(merchandisePriceFeature.getDefaultValue(), merchandise.getPrice());
776: assertFalse(merchandise.eIsSet(merchandisePriceFeature));
777: }
778:
779: @Test
780: public void testChangeTwoControlsInOneContainerWithTwoHiddenControlsToHiddenView() {
781: final VContainedContainer container = addVerticalLayoutToView();
782: addControlToContainer(container, merchandisePriceReferenceFromFan()).setVisible(false);
783: addControlToContainer(container, merchandisePriceReferenceFromFan()).setVisible(false);
784: unsetService();
785: view.setVisible(false);
786: assertEquals(merchandisePriceFeature.getDefaultValue(), merchandise.getPrice());
787: assertFalse(merchandise.eIsSet(merchandisePriceFeature));
788: }
789:
790: @Test
791: public void testChangeTwoControlsInOneContainerWithTwoHiddenControlsToOneVisibleControl() {
792: final VContainedContainer container = addVerticalLayoutToView();
793: addControlToContainer(container, merchandisePriceReferenceFromFan()).setVisible(false);
794: final VControl control = addControlToContainer(container, merchandisePriceReferenceFromFan());
795: control.setVisible(false);
796: unsetService();
797: control.setVisible(true);
798:
799: // we dont change the state of the domain model when shown again. if this changes assertions can be added here
800: merchandise.setPrice(price);
801: control.setVisible(false);
802: assertEquals(merchandisePriceFeature.getDefaultValue(), merchandise.getPrice());
803: assertFalse(merchandise.eIsSet(merchandisePriceFeature));
804: }
805:
806: @Test
807: public void testChangeTwoControlsInOneContainerWithHiddenContainerToOneHiddenControl() {
808: final VContainedContainer container = addVerticalLayoutToView();
809: addControlToContainer(container, merchandisePriceReferenceFromFan());
810: final VControl control = addControlToContainer(container, merchandisePriceReferenceFromFan());
811: container.setVisible(false);
812: unsetService();
813: control.setVisible(false);
814: assertEquals(merchandisePriceFeature.getDefaultValue(), merchandise.getPrice());
815: assertFalse(merchandise.eIsSet(merchandisePriceFeature));
816: }
817:
818: @Test
819: public void testChangeTwoControlsInOneContainerWithHiddenContainerToHiddenView() {
820: final VContainedContainer container = addVerticalLayoutToView();
821: addControlToContainer(container, merchandisePriceReferenceFromFan());
822: addControlToContainer(container, merchandisePriceReferenceFromFan());
823: container.setVisible(false);
824: unsetService();
825: view.setVisible(false);
826: assertEquals(merchandisePriceFeature.getDefaultValue(), merchandise.getPrice());
827: assertFalse(merchandise.eIsSet(merchandisePriceFeature));
828: }
829:
830: @Test
831: public void testChangeTwoControlsInOneContainerWithHiddenContainerToVisibleContainer() {
832: final VContainedContainer container = addVerticalLayoutToView();
833: addControlToContainer(container, merchandisePriceReferenceFromFan());
834: addControlToContainer(container, merchandisePriceReferenceFromFan());
835: container.setVisible(false);
836: unsetService();
837: container.setVisible(true);
838:
839: // we dont change the state of the domain model when shown again. if this changes assertions can be added here
840: merchandise.setPrice(price);
841: container.setVisible(false);
842: assertEquals(merchandisePriceFeature.getDefaultValue(), merchandise.getPrice());
843: assertFalse(merchandise.eIsSet(merchandisePriceFeature));
844: }
845:
846: @Test
847: public void testChangeTwoControlsInOneContainerWithHiddenViewToOneHiddenControl() {
848: final VContainedContainer container = addVerticalLayoutToView();
849: addControlToContainer(container, merchandisePriceReferenceFromFan());
850: final VControl control = addControlToContainer(container, merchandisePriceReferenceFromFan());
851: view.setVisible(false);
852: unsetService();
853: control.setVisible(false);
854: assertEquals(merchandisePriceFeature.getDefaultValue(), merchandise.getPrice());
855: assertFalse(merchandise.eIsSet(merchandisePriceFeature));
856: }
857:
858: @Test
859: public void testChangeTwoControlsInOneContainerWithHiddenViewToHiddenContainer() {
860: final VContainedContainer container = addVerticalLayoutToView();
861: addControlToContainer(container, merchandisePriceReferenceFromFan());
862: addControlToContainer(container, merchandisePriceReferenceFromFan());
863: view.setVisible(false);
864: unsetService();
865: container.setVisible(false);
866: assertEquals(merchandisePriceFeature.getDefaultValue(), merchandise.getPrice());
867: assertFalse(merchandise.eIsSet(merchandisePriceFeature));
868: }
869:
870: @Test
871: public void testChangeTwoControlsInOneContainerWithHiddenViewToVisibleView() {
872: final VContainedContainer container = addVerticalLayoutToView();
873: addControlToContainer(container, merchandisePriceReferenceFromFan());
874: addControlToContainer(container, merchandisePriceReferenceFromFan());
875: view.setVisible(false);
876: unsetService();
877: view.setVisible(true);
878:
879: // we dont change the state of the domain model when shown again. if this changes assertions can be added here
880: merchandise.setPrice(price);
881: view.setVisible(false);
882: assertEquals(merchandisePriceFeature.getDefaultValue(), merchandise.getPrice());
883: assertFalse(merchandise.eIsSet(merchandisePriceFeature));
884: }
885:
886: @Test
887: public void testChangeTwoControlsInTwoContainersAllVisibleToOneHiddenControl() {
888: final VContainedContainer container1 = addVerticalLayoutToView();
889: final VContainedContainer container2 = addVerticalLayoutToView();
890: addControlToContainer(container1, merchandisePriceReferenceFromFan());
891: final VControl control = addControlToContainer(container2, merchandisePriceReferenceFromFan());
892: unsetService();
893: control.setVisible(false);
894: assertEquals(price, merchandise.getPrice());
895: assertTrue(merchandise.eIsSet(merchandisePriceFeature));
896: }
897:
898: @Test
899: public void testChangeTwoControlsInTwoContainersAllVisibleToOneHiddenContainer() {
900: final VContainedContainer container1 = addVerticalLayoutToView();
901: final VContainedContainer container2 = addVerticalLayoutToView();
902: addControlToContainer(container1, merchandisePriceReferenceFromFan());
903: addControlToContainer(container2, merchandisePriceReferenceFromFan());
904: unsetService();
905: container1.setVisible(false);
906: assertEquals(price, merchandise.getPrice());
907: assertTrue(merchandise.eIsSet(merchandisePriceFeature));
908: }
909:
910: @Test
911: public void testChangeTwoControlsInTwoContainersAllVisibleToHiddenView() {
912: final VContainedContainer container1 = addVerticalLayoutToView();
913: final VContainedContainer container2 = addVerticalLayoutToView();
914: addControlToContainer(container1, merchandisePriceReferenceFromFan());
915: addControlToContainer(container2, merchandisePriceReferenceFromFan());
916: unsetService();
917: view.setVisible(false);
918: assertEquals(merchandisePriceFeature.getDefaultValue(), merchandise.getPrice());
919: assertFalse(merchandise.eIsSet(merchandisePriceFeature));
920: }
921:
922: @Test
923: public void testChangeTwoControlsInTwoContainersWithOneHiddenControlToTwoVisibleControls() {
924: final VContainedContainer container1 = addVerticalLayoutToView();
925: final VContainedContainer container2 = addVerticalLayoutToView();
926: addControlToContainer(container1, merchandisePriceReferenceFromFan());
927: final VControl control = addControlToContainer(container2, merchandisePriceReferenceFromFan());
928: control.setVisible(false);
929: unsetService();
930: control.setVisible(true);
931: assertEquals(price, merchandise.getPrice());
932: assertTrue(merchandise.eIsSet(merchandisePriceFeature));
933: }
934:
935: @Test
936: public void testChangeTwoControlsInTwoContainersWithOneHiddenControlToHiddenContainerOfHiddenControl() {
937: final VContainedContainer container1 = addVerticalLayoutToView();
938: final VContainedContainer container2 = addVerticalLayoutToView();
939: addControlToContainer(container1, merchandisePriceReferenceFromFan());
940: addControlToContainer(container2, merchandisePriceReferenceFromFan()).setVisible(false);
941: unsetService();
942: container2.setVisible(false);
943: assertEquals(price, merchandise.getPrice());
944: assertTrue(merchandise.eIsSet(merchandisePriceFeature));
945: }
946:
947: @Test
948: public void testChangeTwoControlsInTwoContainersWithOneHiddenControlToTwoHiddenControls() {
949: final VContainedContainer container1 = addVerticalLayoutToView();
950: final VContainedContainer container2 = addVerticalLayoutToView();
951: final VControl control = addControlToContainer(container1, merchandisePriceReferenceFromFan());
952: addControlToContainer(container2, merchandisePriceReferenceFromFan()).setVisible(false);
953: unsetService();
954: control.setVisible(false);
955: assertEquals(merchandisePriceFeature.getDefaultValue(), merchandise.getPrice());
956: assertFalse(merchandise.eIsSet(merchandisePriceFeature));
957: }
958:
959: @Test
960: public void testChangeTwoControlsInTwoContainersWithOneHiddenControlToHiddenContainerOfVisibleControl() {
961: final VContainedContainer container1 = addVerticalLayoutToView();
962: final VContainedContainer container2 = addVerticalLayoutToView();
963: addControlToContainer(container1, merchandisePriceReferenceFromFan());
964: addControlToContainer(container2, merchandisePriceReferenceFromFan()).setVisible(false);
965: unsetService();
966: container1.setVisible(false);
967: assertEquals(merchandisePriceFeature.getDefaultValue(), merchandise.getPrice());
968: assertFalse(merchandise.eIsSet(merchandisePriceFeature));
969: }
970:
971: @Test
972: public void testChangeTwoControlsInTwoContainersWithOneHiddenControlToHiddenView() {
973: final VContainedContainer container1 = addVerticalLayoutToView();
974: final VContainedContainer container2 = addVerticalLayoutToView();
975: addControlToContainer(container1, merchandisePriceReferenceFromFan());
976: addControlToContainer(container2, merchandisePriceReferenceFromFan()).setVisible(false);
977: unsetService();
978: view.setVisible(false);
979: assertEquals(merchandisePriceFeature.getDefaultValue(), merchandise.getPrice());
980: assertFalse(merchandise.eIsSet(merchandisePriceFeature));
981: }
982:
983: @Test
984: public void testChangeTwoControlsInTwoContainersWithOneHiddenContainerToHiddenControlInHiddenContainer() {
985: final VContainedContainer container1 = addVerticalLayoutToView();
986: final VContainedContainer container2 = addVerticalLayoutToView();
987: final VControl control = addControlToContainer(container1, merchandisePriceReferenceFromFan());
988: addControlToContainer(container2, merchandisePriceReferenceFromFan());
989: container1.setVisible(false);
990: unsetService();
991: control.setVisible(false);
992: assertEquals(price, merchandise.getPrice());
993: assertTrue(merchandise.eIsSet(merchandisePriceFeature));
994: }
995:
996: @Test
997: public void testChangeTwoControlsInTwoContainersWithOneHiddenContainerToTwoVisibleContainers() {
998: final VContainedContainer container1 = addVerticalLayoutToView();
999: final VContainedContainer container2 = addVerticalLayoutToView();
1000: addControlToContainer(container1, merchandisePriceReferenceFromFan());
1001: addControlToContainer(container2, merchandisePriceReferenceFromFan());
1002: container1.setVisible(false);
1003: unsetService();
1004: container1.setVisible(true);
1005: assertEquals(price, merchandise.getPrice());
1006: assertTrue(merchandise.eIsSet(merchandisePriceFeature));
1007: }
1008:
1009: @Test
1010: public void testChangeTwoControlsInTwoContainersWithOneHiddenContainerToHiddenControlInVisibleContainer() {
1011: final VContainedContainer container1 = addVerticalLayoutToView();
1012: final VContainedContainer container2 = addVerticalLayoutToView();
1013: addControlToContainer(container1, merchandisePriceReferenceFromFan());
1014: final VControl control = addControlToContainer(container2, merchandisePriceReferenceFromFan());
1015: container1.setVisible(false);
1016: unsetService();
1017: control.setVisible(false);
1018: assertEquals(merchandisePriceFeature.getDefaultValue(), merchandise.getPrice());
1019: assertFalse(merchandise.eIsSet(merchandisePriceFeature));
1020: }
1021:
1022: @Test
1023: public void testChangeTwoControlsInTwoContainersWithOneHiddenContainerToTwoHiddenContainer() {
1024: final VContainedContainer container1 = addVerticalLayoutToView();
1025: final VContainedContainer container2 = addVerticalLayoutToView();
1026: addControlToContainer(container1, merchandisePriceReferenceFromFan());
1027: addControlToContainer(container2, merchandisePriceReferenceFromFan());
1028: container1.setVisible(false);
1029: unsetService();
1030: container2.setVisible(false);
1031: assertEquals(merchandisePriceFeature.getDefaultValue(), merchandise.getPrice());
1032: assertFalse(merchandise.eIsSet(merchandisePriceFeature));
1033: }
1034:
1035: @Test
1036: public void testChangeTwoControlsInTwoContainersWithOneHiddenContainerToHiddenView() {
1037: final VContainedContainer container1 = addVerticalLayoutToView();
1038: final VContainedContainer container2 = addVerticalLayoutToView();
1039: addControlToContainer(container1, merchandisePriceReferenceFromFan());
1040: addControlToContainer(container2, merchandisePriceReferenceFromFan());
1041: container1.setVisible(false);
1042: unsetService();
1043: view.setVisible(false);
1044: assertEquals(merchandisePriceFeature.getDefaultValue(), merchandise.getPrice());
1045: assertFalse(merchandise.eIsSet(merchandisePriceFeature));
1046: }
1047:
1048: @Test
1049: public void testChangeTwoControlsInTwoContainersWithTwoHiddenControlsToOneHiddenContainer() {
1050: final VContainedContainer container1 = addVerticalLayoutToView();
1051: final VContainedContainer container2 = addVerticalLayoutToView();
1052: addControlToContainer(container1, merchandisePriceReferenceFromFan()).setVisible(false);
1053: addControlToContainer(container2, merchandisePriceReferenceFromFan()).setVisible(false);
1054: unsetService();
1055: container1.setVisible(false);
1056: assertEquals(merchandisePriceFeature.getDefaultValue(), merchandise.getPrice());
1057: assertFalse(merchandise.eIsSet(merchandisePriceFeature));
1058: }
1059:
1060: @Test
1061: public void testChangeTwoControlsInTwoContainersWithTwoHiddenControlsToHiddenView() {
1062: final VContainedContainer container1 = addVerticalLayoutToView();
1063: final VContainedContainer container2 = addVerticalLayoutToView();
1064: addControlToContainer(container1, merchandisePriceReferenceFromFan()).setVisible(false);
1065: addControlToContainer(container2, merchandisePriceReferenceFromFan()).setVisible(false);
1066: unsetService();
1067: view.setVisible(false);
1068: assertEquals(merchandisePriceFeature.getDefaultValue(), merchandise.getPrice());
1069: assertFalse(merchandise.eIsSet(merchandisePriceFeature));
1070: }
1071:
1072: @Test
1073: public void testChangeTwoControlsInTwoContainersWithTwoHiddenControlsToOneVisibleControl() {
1074: final VContainedContainer container1 = addVerticalLayoutToView();
1075: final VContainedContainer container2 = addVerticalLayoutToView();
1076: addControlToContainer(container1, merchandisePriceReferenceFromFan()).setVisible(false);
1077: final VControl control = addControlToContainer(container2, merchandisePriceReferenceFromFan());
1078: control.setVisible(false);
1079: unsetService();
1080: control.setVisible(true);
1081:
1082: // we dont change the state of the domain model when shown again. if this changes assertions can be added here
1083: merchandise.setPrice(price);
1084: control.setVisible(false);
1085: assertEquals(merchandisePriceFeature.getDefaultValue(), merchandise.getPrice());
1086: assertFalse(merchandise.eIsSet(merchandisePriceFeature));
1087: }
1088:
1089: @Test
1090: public void testChangeTwoControlsInTwoContainersWithTwoHiddenContainersToOneHiddenControl() {
1091: final VContainedContainer container1 = addVerticalLayoutToView();
1092: final VContainedContainer container2 = addVerticalLayoutToView();
1093: addControlToContainer(container1, merchandisePriceReferenceFromFan());
1094: final VControl control = addControlToContainer(container2, merchandisePriceReferenceFromFan());
1095: container1.setVisible(false);
1096: container2.setVisible(false);
1097: unsetService();
1098: control.setVisible(false);
1099: assertEquals(merchandisePriceFeature.getDefaultValue(), merchandise.getPrice());
1100: assertFalse(merchandise.eIsSet(merchandisePriceFeature));
1101: }
1102:
1103: @Test
1104: public void testChangeTwoControlsInTwoContainersWithTwoHiddenContainersToHiddenView() {
1105: final VContainedContainer container1 = addVerticalLayoutToView();
1106: final VContainedContainer container2 = addVerticalLayoutToView();
1107: addControlToContainer(container1, merchandisePriceReferenceFromFan());
1108: addControlToContainer(container2, merchandisePriceReferenceFromFan());
1109: container1.setVisible(false);
1110: container2.setVisible(false);
1111: unsetService();
1112: view.setVisible(false);
1113: assertEquals(merchandisePriceFeature.getDefaultValue(), merchandise.getPrice());
1114: assertFalse(merchandise.eIsSet(merchandisePriceFeature));
1115: }
1116:
1117: @Test
1118: public void testChangeTwoControlsInTwoContainersWithTwoHiddenContainersToOneVisibleContainer() {
1119: final VContainedContainer container1 = addVerticalLayoutToView();
1120: final VContainedContainer container2 = addVerticalLayoutToView();
1121: addControlToContainer(container1, merchandisePriceReferenceFromFan());
1122: addControlToContainer(container2, merchandisePriceReferenceFromFan());
1123: container1.setVisible(false);
1124: container2.setVisible(false);
1125: unsetService();
1126: container1.setVisible(true);
1127:
1128: // we dont change the state of the domain model when shown again. if this changes assertions can be added here
1129: merchandise.setPrice(price);
1130: container1.setVisible(false);
1131: assertEquals(merchandisePriceFeature.getDefaultValue(), merchandise.getPrice());
1132: assertFalse(merchandise.eIsSet(merchandisePriceFeature));
1133: }
1134:
1135: @Test
1136: public void testChangeTwoControlsInTwoContainersWithHiddenViewToOneHiddenControl() {
1137: final VContainedContainer container1 = addVerticalLayoutToView();
1138: final VContainedContainer container2 = addVerticalLayoutToView();
1139: addControlToContainer(container1, merchandisePriceReferenceFromFan());
1140: final VControl control = addControlToContainer(container2, merchandisePriceReferenceFromFan());
1141: view.setVisible(false);
1142: unsetService();
1143: control.setVisible(false);
1144: assertEquals(merchandisePriceFeature.getDefaultValue(), merchandise.getPrice());
1145: assertFalse(merchandise.eIsSet(merchandisePriceFeature));
1146: }
1147:
1148: @Test
1149: public void testChangeTwoControlsInTwoContainersWithHiddenViewToOneHiddenContainer() {
1150: final VContainedContainer container1 = addVerticalLayoutToView();
1151: final VContainedContainer container2 = addVerticalLayoutToView();
1152: addControlToContainer(container1, merchandisePriceReferenceFromFan());
1153: addControlToContainer(container2, merchandisePriceReferenceFromFan());
1154: view.setVisible(false);
1155: unsetService();
1156: container1.setVisible(false);
1157: assertEquals(merchandisePriceFeature.getDefaultValue(), merchandise.getPrice());
1158: assertFalse(merchandise.eIsSet(merchandisePriceFeature));
1159: }
1160:
1161: @Test
1162: public void testChangeTwoControlsInTwoContainersWithHiddenViewToVisibleView() {
1163: final VContainedContainer container1 = addVerticalLayoutToView();
1164: final VContainedContainer container2 = addVerticalLayoutToView();
1165: addControlToContainer(container1, merchandisePriceReferenceFromFan());
1166: addControlToContainer(container2, merchandisePriceReferenceFromFan());
1167: view.setVisible(false);
1168: unsetService();
1169: view.setVisible(true);
1170:
1171: // we dont change the state of the domain model when shown again. if this changes assertions can be added here
1172: merchandise.setPrice(price);
1173: view.setVisible(false);
1174: assertEquals(merchandisePriceFeature.getDefaultValue(), merchandise.getPrice());
1175: assertFalse(merchandise.eIsSet(merchandisePriceFeature));
1176: }
1177:
1178: // ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
1179: // More specific test
1180: // ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
1181:
1182: @Test
1183: public void testChangeOtherViewFeatures() {
1184: final VControl control = addControlToView(merchandisePriceReferenceFromFan());
1185: unsetService();
1186: for (final EStructuralFeature feature : control.eClass().getEAllStructuralFeatures()) {
1187: if (feature == VViewPackage.eINSTANCE.getElement_Visible()) {
1188: continue;
1189: }
1190: if (!feature.isMany()) {
1191: control.eSet(feature, feature.getDefaultValue());
1192: }
1193: }
1194: assertEquals(price, merchandise.getPrice());
1195: assertTrue(merchandise.eIsSet(merchandisePriceFeature));
1196: }
1197:
1198: @Test
1199: public void testInitDifferentControls() {
1200: addControlToContainer(addVerticalLayoutToView(), merchandisePriceReferenceFromFan()).setVisible(false);
1201: addControlToContainer(addVerticalLayoutToView(), merchandiseNameReferenceFromFan());
1202: unsetService();
1203: assertEquals(merchandisePriceFeature.getDefaultValue(), merchandise.getPrice());
1204: assertFalse(merchandise.eIsSet(merchandisePriceFeature));
1205: assertEquals(mercName, merchandise.getName());
1206: assertTrue(merchandise.eIsSet(merchandiseNameFeature));
1207: }
1208:
1209: @Test
1210: public void testChangeDifferentControls() {
1211: final VControl mercControl = addControlToContainer(addVerticalLayoutToView(),
1212: merchandisePriceReferenceFromFan());
1213: final VControl fanControl = addControlToContainer(addVerticalLayoutToView(), fanNameReference());
1214: unsetService();
1215: mercControl.setVisible(false);
1216: assertEquals(merchandisePriceFeature.getDefaultValue(), merchandise.getPrice());
1217: assertFalse(merchandise.eIsSet(merchandisePriceFeature));
1218: assertEquals(fanName, fan.getName());
1219: assertTrue(fan.eIsSet(fanNameFeature));
1220: fanControl.setVisible(false);
1221: assertEquals(merchandisePriceFeature.getDefaultValue(), merchandise.getPrice());
1222: assertFalse(merchandise.eIsSet(merchandisePriceFeature));
1223: assertEquals(fanNameFeature.getDefaultValue(), fan.getName());
1224: assertFalse(fan.eIsSet(fanNameFeature));
1225: }
1226:
1227: @Test
1228: public void testComplexCategorization() {
1229: final VCategorizationElement categorizationElement = VCategorizationFactory.eINSTANCE
1230: .createCategorizationElement();
1231:
1232: final VCategorization categorization1 = VCategorizationFactory.eINSTANCE.createCategorization();
1233: final VCategorization categorization1a = VCategorizationFactory.eINSTANCE.createCategorization();
1234: final VCategorization categorization2 = VCategorizationFactory.eINSTANCE.createCategorization();
1235:
1236: final VCategory category11 = VCategorizationFactory.eINSTANCE.createCategory();
1237: final VControl control11 = addControlToCategory(category11, merchandisePriceReferenceFromFan());
1238: final VCategory category12 = VCategorizationFactory.eINSTANCE.createCategory();
1239: final VControl control12 = addControlToCategory(category12, merchandisePriceReferenceFromFan());
1240:
1241: final VCategory category1a1 = VCategorizationFactory.eINSTANCE.createCategory();
1242: addControlToCategory(category1a1, merchandisePriceReferenceFromFan());
1243: final VCategory category1a2 = VCategorizationFactory.eINSTANCE.createCategory();
1244: final VControl control1a2 = addControlToCategory(category1a2, merchandiseNameReferenceFromFan());
1245:
1246: final VCategory category21 = VCategorizationFactory.eINSTANCE.createCategory();
1247: addControlToCategory(category21, merchandisePriceReferenceFromFan());
1248: final VCategory category22 = VCategorizationFactory.eINSTANCE.createCategory();
1249: addControlToCategory(category22, fanNameReference());
1250:
1251: categorization1.getCategorizations().add(category11);
1252: categorization1.getCategorizations().add(category12);
1253:
1254: categorization1a.getCategorizations().add(category1a1);
1255: categorization1a.getCategorizations().add(category1a2);
1256:
1257: categorization2.getCategorizations().add(category21);
1258: categorization2.getCategorizations().add(category22);
1259:
1260: categorization1.getCategorizations().add(categorization1a);
1261: categorizationElement.getCategorizations().add(categorization1);
1262: categorizationElement.getCategorizations().add(categorization2);
1263: view.getChildren().add(categorizationElement);
1264:
1265: unsetService();
1266:
1267: doLogicForComplexCategorizationTest(categorization2, control11, control12, category1a1, control1a2);
1268:
1269: }
1270:
1271: private void doLogicForComplexCategorizationTest(final VCategorization categorization2,
1272: final VControl control11, final VControl control12, final VCategory category1a1, final VControl control1a2) {
1273:
1274: control11.setVisible(false);
1275: assertEquals(price, merchandise.getPrice());
1276: assertTrue(merchandise.eIsSet(merchandisePriceFeature));
1277: assertEquals(mercName, merchandise.getName());
1278: assertTrue(merchandise.eIsSet(merchandiseNameFeature));
1279: assertEquals(fanName, fan.getName());
1280: assertTrue(fan.eIsSet(fanNameFeature));
1281:
1282: control1a2.setVisible(false);
1283: assertEquals(price, merchandise.getPrice());
1284: assertTrue(merchandise.eIsSet(merchandisePriceFeature));
1285: assertEquals(merchandiseNameFeature.getDefaultValue(), merchandise.getName());
1286: assertFalse(merchandise.eIsSet(merchandiseNameFeature));
1287: assertEquals(fanName, fan.getName());
1288: assertTrue(fan.eIsSet(fanNameFeature));
1289:
1290: categorization2.setVisible(false);
1291: assertEquals(price, merchandise.getPrice());
1292: assertTrue(merchandise.eIsSet(merchandisePriceFeature));
1293: assertEquals(merchandiseNameFeature.getDefaultValue(), merchandise.getName());
1294: assertFalse(merchandise.eIsSet(merchandiseNameFeature));
1295: assertEquals(fanNameFeature.getDefaultValue(), fan.getName());
1296: assertFalse(fan.eIsSet(fanNameFeature));
1297:
1298: category1a1.setVisible(false);
1299: assertEquals(price, merchandise.getPrice());
1300: assertTrue(merchandise.eIsSet(merchandisePriceFeature));
1301: assertEquals(merchandiseNameFeature.getDefaultValue(), merchandise.getName());
1302: assertFalse(merchandise.eIsSet(merchandiseNameFeature));
1303: assertEquals(fanNameFeature.getDefaultValue(), fan.getName());
1304: assertFalse(fan.eIsSet(fanNameFeature));
1305:
1306: control12.setVisible(false);
1307: assertEquals(merchandisePriceFeature.getDefaultValue(), merchandise.getPrice());
1308: assertFalse(merchandise.eIsSet(merchandisePriceFeature));
1309: assertEquals(merchandiseNameFeature.getDefaultValue(), merchandise.getName());
1310: assertFalse(merchandise.eIsSet(merchandiseNameFeature));
1311: assertEquals(fanNameFeature.getDefaultValue(), fan.getName());
1312: assertFalse(fan.eIsSet(fanNameFeature));
1313: }
1314:
1315: @Test
1316: public void testTable() {
1317: final Merchandise merc = BowlingFactory.eINSTANCE.createMerchandise();
1318: merc.setName("Foo");
1319: fan.getFanMerchandise().add(merc);
1320:
1321: final VTableControl table = VTableFactory.eINSTANCE.createTableControl();
1322: final VTableDomainModelReference tableDomainModelReference = VTableFactory.eINSTANCE
1323: .createTableDomainModelReference();
1324: tableDomainModelReference.setDomainModelEFeature(BowlingPackage.eINSTANCE.getFan_FanMerchandise());
1325: table.setDomainModelReference(tableDomainModelReference);
1326:
1327: final VFeaturePathDomainModelReference nameCol = VViewFactory.eINSTANCE.createFeaturePathDomainModelReference();
1328: nameCol.setDomainModelEFeature(BowlingPackage.eINSTANCE.getMerchandise_Name());
1329: final VFeaturePathDomainModelReference priceCol = VViewFactory.eINSTANCE
1330: .createFeaturePathDomainModelReference();
1331: priceCol.setDomainModelEFeature(BowlingPackage.eINSTANCE.getMerchandise_Price());
1332: VTableDomainModelReference.class.cast(table.getDomainModelReference()).getColumnDomainModelReferences()
1333: .add(nameCol);
1334: VTableDomainModelReference.class.cast(table.getDomainModelReference()).getColumnDomainModelReferences()
1335: .add(priceCol);
1336:
1337: view.getChildren().add(table);
1338:
1339: unsetService();
1340: assertEquals(1, fan.getFanMerchandise().size());
1341: assertEquals(merc, fan.getFanMerchandise().get(0));
1342: assertTrue(fan.eIsSet(BowlingPackage.eINSTANCE.getFan_FanMerchandise()));
1343:
1344: table.setVisible(false);
1345:
1346: assertEquals(0, fan.getFanMerchandise().size());
1347: assertFalse(fan.eIsSet(BowlingPackage.eINSTANCE.getFan_FanMerchandise()));
1348: assertEquals("Foo", merc.getName());
1349: }
1350:
1351: // ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
1352: // Factory methods
1353: // ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
1354:
1355: /**
1356: * Creates the unset service.
1357: *
1358: * @return
1359: */
1360: private UnsetService unsetService() {
1361: final UnsetService unsetService = new UnsetService();
1362: context = ViewModelContextFactory.INSTANCE.createViewModelContext(view, fan);
1363: unsetService.instantiate(context);
1364: return unsetService;
1365: }
1366:
1367: /**
1368: * Adds a control with the given feature path domain model reference as a direct child of the view.
1369: *
1370: * @param domainModelReference
1371: * @return the created control
1372: */
1373: private VControl addControlToView(VFeaturePathDomainModelReference domainModelReference) {
1374: final VControl control = VViewFactory.eINSTANCE.createControl();
1375: control.setDomainModelReference(domainModelReference);
1376: view.getChildren().add(control);
1377: return control;
1378: }
1379:
1380: /**
1381: * Adds a control with the given feature path domain model reference as a direct child of the container.
1382: *
1383: * @param domainModelReference
1384: * @return the created control
1385: */
1386: private VControl addControlToContainer(VContainedContainer container,
1387: VFeaturePathDomainModelReference domainModelReference) {
1388: final VControl control = VViewFactory.eINSTANCE.createControl();
1389: control.setDomainModelReference(domainModelReference);
1390: container.getChildren().add(control);
1391: return control;
1392: }
1393:
1394: private VControl addControlToCategory(VCategory category, VFeaturePathDomainModelReference domainModelReference) {
1395: final VControl control = VViewFactory.eINSTANCE.createControl();
1396: control.setDomainModelReference(domainModelReference);
1397: category.setComposite(control);
1398: return control;
1399: }
1400:
1401: /**
1402: * Adds a vertical layout as a direct child of the view.
1403: *
1404: * @return the created layout
1405: */
1406: private VVerticalLayout addVerticalLayoutToView() {
1407: final VVerticalLayout layout = VVerticalFactory.eINSTANCE.createVerticalLayout();
1408: view.getChildren().add(layout);
1409: return layout;
1410: }
1411:
1412: /**
1413: * References the player name from a league object.
1414: *
1415: * @return
1416: */
1417: private VFeaturePathDomainModelReference merchandisePriceReferenceFromFan() {
1418: final VFeaturePathDomainModelReference domainModelReference = VViewFactory.eINSTANCE
1419: .createFeaturePathDomainModelReference();
1420: domainModelReference.setDomainModelEFeature(BowlingPackage.eINSTANCE.getMerchandise_Price());
1421: domainModelReference.getDomainModelEReferencePath().add(BowlingPackage.eINSTANCE.getFan_FavouriteMerchandise());
1422: return domainModelReference;
1423: }
1424:
1425: private VFeaturePathDomainModelReference merchandiseNameReferenceFromFan() {
1426: final VFeaturePathDomainModelReference domainModelReference = VViewFactory.eINSTANCE
1427: .createFeaturePathDomainModelReference();
1428: domainModelReference.setDomainModelEFeature(BowlingPackage.eINSTANCE.getMerchandise_Name());
1429: domainModelReference.getDomainModelEReferencePath().add(BowlingPackage.eINSTANCE.getFan_FavouriteMerchandise());
1430: return domainModelReference;
1431: }
1432:
1433: private VFeaturePathDomainModelReference fanNameReference() {
1434: final VFeaturePathDomainModelReference domainModelReference = VViewFactory.eINSTANCE
1435: .createFeaturePathDomainModelReference();
1436: domainModelReference.setDomainModelEFeature(BowlingPackage.eINSTANCE.getFan_Name());
1437: return domainModelReference;
1438: }
1439:
1440: // ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
1441: // Helper- & stub classes
1442: // ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
1443:
1444: /**
1445: * @author Jonas
1446: *
1447: */
1448: private class ViewModelContextStub implements ViewModelContext {
1449:
1450: private boolean hasRegisteredViewListener;
1451: private boolean hasRegisteredDomainListener;
1452:
1453: @Override
1454: public void unregisterViewChangeListener(ModelChangeListener modelChangeListener) {
1455: hasRegisteredViewListener = false;
1456: }
1457:
1458: @Override
1459: public void unregisterDomainChangeListener(ModelChangeListener modelChangeListener) {
1460: hasRegisteredDomainListener = false;
1461: }
1462:
1463: @Override
1464: public void registerViewChangeListener(ModelChangeListener modelChangeListener) {
1465: hasRegisteredViewListener = true;
1466: }
1467:
1468: @Override
1469: public void registerDomainChangeListener(ModelChangeListener modelChangeListener) {
1470: hasRegisteredDomainListener = true;
1471: }
1472:
1473: @Override
1474: public VElement getViewModel() {
1475: return view;
1476: }
1477:
1478: @Override
1479: public EObject getDomainModel() {
1480: return fan;
1481: }
1482:
1483: @Override
1484: public void dispose() {
1485: }
1486:
1487: @Override
1488: public <T> boolean hasService(Class<T> serviceType) {
1489: return false;
1490: }
1491:
1492: @Override
1493: public <T> T getService(Class<T> serviceType) {
1494: return null;
1495: }
1496:
1497: /**
1498: * {@inheritDoc}
1499: *
1500: * @see org.eclipse.emf.ecp.view.spi.context.ViewModelContext#getControlsFor(org.eclipse.emf.ecore.EStructuralFeature.Setting)
1501: * @deprecated
1502: */
1503: @Deprecated
1504: @Override
1505: public Set<VControl> getControlsFor(Setting setting) {
1506: return null;
1507: }
1508:
1509: /**
1510: * {@inheritDoc}
1511: *
1512: * @see org.eclipse.emf.ecp.view.spi.context.ViewModelContext#getControlsFor(UniqueSetting)
1513: * @deprecated
1514: */
1515: @Deprecated
1516: @Override
1517: public Set<VElement> getControlsFor(UniqueSetting setting) {
1518: return null;
1519: }
1520:
1521: @Override
1522: public Object getContextValue(String key) {
1523: return null;
1524: }
1525:
1526: @Override
1527: public void putContextValue(String key, Object value) {
1528: }
1529:
1530: @Override
1531: public void registerDisposeListener(ViewModelContextDisposeListener listener) {
1532: }
1533:
1534: @Override
1535: public void addContextUser(Object user) {
1536: }
1537:
1538: @Override
1539: public void removeContextUser(Object user) {
1540: }
1541:
1542: @Deprecated
1543: @Override
1544: public ViewModelContext getChildContext(EObject eObject, VElement parent, VView vView,
1545: ViewModelService... viewModelServices) {
1546: return null;
1547: }
1548:
1549: @Override
1550: public ViewModelContext getChildContext(EObject eObject, VElement parent, VView vView,
1551: ViewModelServiceProvider viewModelServiceProvider) {
1552: return null;
1553: }
1554:
1555: @Override
1556: public void registerEMFFormsContextListener(EMFFormsContextListener contextListener) {
1557: contextListener.contextInitialised();
1558: }
1559:
1560: @Override
1561: public void unregisterEMFFormsContextListener(EMFFormsContextListener contextListener) {
1562: }
1563:
1564: @Override
1565: public ViewModelContext getParentContext() {
1566: return null;
1567: }
1568:
1569: @Override
1570: public VElement getParentVElement() {
1571: return null;
1572: }
1573:
1574: @Override
1575: public void changeDomainModel(EObject newDomainModel) {
1576: // do nothing
1577: }
1578:
1579: @Override
1580: public void registerRootDomainModelChangeListener(RootDomainModelChangeListener rootDomainModelChangeListener) {
1581: // do nothing
1582: }
1583:
1584: @Override
1585: public void unregisterRootDomainModelChangeListener(
1586: RootDomainModelChangeListener rootDomainModelChangeListener) {
1587: // do nothing
1588: }
1589:
1590: @Override
1591: public void pause() {
1592: // do nothing
1593: }
1594:
1595: @Override
1596: public void reactivate() {
1597: // do nothing
1598: }
1599: }
1600:
1601: }
![[Jenkins]](/ecp/static/e8bbdb94/images/svgs/logo.svg){kind=logo}
