![[Jenkins]](/ecp/static/e8bbdb94/images/svgs/logo.svg){kind=logo}
Package: RuleRegistry_PTest$1
RuleRegistry_PTest$1
| name | instruction | branch | complexity | line | method | ||||||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| getViewModelServices(VElement, EObject) |
|
|
|
|
|
||||||||||||||||||||
| {...} |
|
|
|
|
|
||||||||||||||||||||
Coverage
1: /*******************************************************************************
2: * Copyright (c) 2011-2014 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: * jfaltermeier - initial API and implementation
13: ******************************************************************************/
14: package org.eclipse.emf.ecp.view.rule.test;
15:
16: import static org.junit.Assert.assertEquals;
17: import static org.junit.Assert.assertTrue;
18: import static org.junit.Assert.fail;
19:
20: import java.lang.reflect.Field;
21: import java.util.Collection;
22: import java.util.Collections;
23: import java.util.Iterator;
24: import java.util.Map;
25: import java.util.Map.Entry;
26: import java.util.Set;
27:
28: import org.eclipse.emf.ecore.EObject;
29: import org.eclipse.emf.ecp.common.spi.BidirectionalMap;
30: import org.eclipse.emf.ecp.common.spi.UniqueSetting;
31: import org.eclipse.emf.ecp.test.common.DefaultRealm;
32: import org.eclipse.emf.ecp.view.internal.rule.RuleRegistry;
33: import org.eclipse.emf.ecp.view.internal.rule.RuleService;
34: import org.eclipse.emf.ecp.view.spi.context.ViewModelContextFactory;
35: import org.eclipse.emf.ecp.view.spi.context.ViewModelService;
36: import org.eclipse.emf.ecp.view.spi.context.ViewModelServiceProvider;
37: import org.eclipse.emf.ecp.view.spi.model.VControl;
38: import org.eclipse.emf.ecp.view.spi.model.VElement;
39: import org.eclipse.emf.ecp.view.spi.model.VFeaturePathDomainModelReference;
40: import org.eclipse.emf.ecp.view.spi.model.VView;
41: import org.eclipse.emf.ecp.view.spi.model.VViewFactory;
42: import org.eclipse.emf.ecp.view.spi.rule.model.Condition;
43: import org.eclipse.emf.ecp.view.spi.rule.model.LeafCondition;
44: import org.eclipse.emf.ecp.view.spi.rule.model.OrCondition;
45: import org.eclipse.emf.ecp.view.spi.rule.model.RuleFactory;
46: import org.eclipse.emf.ecp.view.spi.rule.model.ShowRule;
47: import org.eclipse.emf.emfstore.bowling.BowlingFactory;
48: import org.eclipse.emf.emfstore.bowling.BowlingPackage;
49: import org.eclipse.emf.emfstore.bowling.Fan;
50: import org.eclipse.emf.emfstore.bowling.Merchandise;
51: import org.eclipse.emf.emfstore.bowling.Tournament;
52: import org.junit.After;
53: import org.junit.Before;
54: import org.junit.Test;
55:
56: /**
57: * Tests that assert that the {@link RuleRegistry}'s maps are updated correctly, especially on deletes.
58: *
59: * @author jfaltermeier
60: *
61: */
62: public class RuleRegistry_PTest {
63: // assertions are pretty complex
64: // BEGIN COMPLEX CODE
65: private static final String CONDITION_TO_SETTINGS_FIELD_NAME = "conditionToSettings";
66: private static final String RULES_TO_RENDERABLES_FIELD_NAME = "rulesToRenderables";
67: private static final String SETTING_TO_RULES_FIELD_NAME = "settingToRules";
68: private static final String REFLECTION_FAIL_FIX_TEST_SETUP = "Reflection fail. Fix test setup!";
69: private static final String SHOW_RULE_REGISTRY_FIELD_NAME = "showRuleRegistry";
70: private static final String FM_RIGHT = "Bowling Ball";
71: private static final String M2_RIGHT = "Shirt";
72: private static final String M1_RIGHT = "Scarf";
73:
74: private RuleService ruleService;
75:
76: private Fan fan;
77: private Merchandise merchandise1;
78: private Merchandise merchandise2;
79: private Merchandise favMerchandise;
80:
81: private UniqueSetting favMerchandiseSetting;
82: private UniqueSetting merchandise1Setting;
83: private UniqueSetting merchandise2Setting;
84: private UniqueSetting fanSetting;
85:
86: private VView view;
87: private VControl control1;
88: private VControl control2;
89: private DefaultRealm realm;
90:
91: @Before
92: public void setUp() {
93: realm = new DefaultRealm();
94: ruleService = new RuleService();
95: createView();
96: createDomainObject();
97: }
98:
99: @After
100: public void tearDown() {
101: realm.dispose();
102: }
103:
104: private void createDomainObject() {
105: fan = BowlingFactory.eINSTANCE.createFan();
106:
107: merchandise1 = BowlingFactory.eINSTANCE.createMerchandise();
108: merchandise1.setName(M1_RIGHT);
109: merchandise1Setting = UniqueSetting.createSetting(merchandise1, BowlingPackage.eINSTANCE.getMerchandise_Name());
110:
111: merchandise2 = BowlingFactory.eINSTANCE.createMerchandise();
112: merchandise2.setName(M2_RIGHT);
113: merchandise2Setting = UniqueSetting.createSetting(merchandise2, BowlingPackage.eINSTANCE.getMerchandise_Name());
114:
115: favMerchandise = BowlingFactory.eINSTANCE.createMerchandise();
116: favMerchandise.setName(FM_RIGHT);
117: favMerchandiseSetting = UniqueSetting.createSetting(favMerchandise,
118: BowlingPackage.eINSTANCE.getMerchandise_Name());
119:
120: fan.setFavouriteMerchandise(favMerchandise);
121: fan.getFanMerchandise().add(merchandise1);
122: fan.getFanMerchandise().add(merchandise2);
123: fanSetting = UniqueSetting.createSetting(fan, BowlingPackage.eINSTANCE.getFan_FanMerchandise());
124: }
125:
126: private void createView() {
127: view = VViewFactory.eINSTANCE.createView();
128:
129: control1 = VViewFactory.eINSTANCE.createControl();
130: control1.setDomainModelReference(BowlingPackage.eINSTANCE.getFan_DateOfBirth());
131:
132: control2 = VViewFactory.eINSTANCE.createControl();
133: control2.setDomainModelReference(BowlingPackage.eINSTANCE.getFan_EMails());
134:
135: view.getChildren().add(control1);
136: view.getChildren().add(control2);
137: }
138:
139: private void initialize() {
140: ViewModelContextFactory.INSTANCE.createViewModelContext(view, fan,
141: new ViewModelServiceProvider() {
142:
143: @Override
144: public Collection<? extends ViewModelService> getViewModelServices(VElement view, EObject eObject) {
145: return Collections.singleton(ruleService);
146: }
147:
148: });
149: }
150:
151: private static ShowRule addFavMerchandiseRule(VElement element) {
152: final ShowRule rule = RuleFactory.eINSTANCE.createShowRule();
153:
154: final LeafCondition condition = RuleFactory.eINSTANCE.createLeafCondition();
155:
156: final VFeaturePathDomainModelReference dmr = VViewFactory.eINSTANCE.createFeaturePathDomainModelReference();
157: dmr.getDomainModelEReferencePath().add(BowlingPackage.eINSTANCE.getFan_FavouriteMerchandise());
158: dmr.setDomainModelEFeature(BowlingPackage.eINSTANCE.getMerchandise_Name());
159:
160: condition.setExpectedValue(FM_RIGHT);
161: condition.setDomainModelReference(dmr);
162: rule.setCondition(condition);
163:
164: element.getAttachments().add(rule);
165:
166: return rule;
167: }
168:
169: private static ShowRule addFanMerchandiseRule(VElement element) {
170: final ShowRule rule = RuleFactory.eINSTANCE.createShowRule();
171:
172: final LeafCondition condition = RuleFactory.eINSTANCE.createLeafCondition();
173:
174: final VFeaturePathDomainModelReference dmr = VViewFactory.eINSTANCE.createFeaturePathDomainModelReference();
175: dmr.setDomainModelEFeature(BowlingPackage.eINSTANCE.getFan_FanMerchandise());
176:
177: final VFeaturePathDomainModelReference valueDMR = VViewFactory.eINSTANCE
178: .createFeaturePathDomainModelReference();
179: valueDMR.setDomainModelEFeature(BowlingPackage.eINSTANCE.getMerchandise_Name());
180:
181: condition.setExpectedValue(M1_RIGHT);
182: condition.setDomainModelReference(dmr);
183: condition.setValueDomainModelReference(valueDMR);
184: rule.setCondition(condition);
185:
186: element.getAttachments().add(rule);
187:
188: return rule;
189: }
190:
191: private static ShowRule addFanMerchandiseOrRule(VElement element) {
192: final ShowRule rule = RuleFactory.eINSTANCE.createShowRule();
193:
194: final OrCondition condition = RuleFactory.eINSTANCE.createOrCondition();
195:
196: final LeafCondition condition1 = RuleFactory.eINSTANCE.createLeafCondition();
197: final VFeaturePathDomainModelReference dmr1 = VViewFactory.eINSTANCE.createFeaturePathDomainModelReference();
198: dmr1.setDomainModelEFeature(BowlingPackage.eINSTANCE.getFan_FanMerchandise());
199: final VFeaturePathDomainModelReference valueDMR1 = VViewFactory.eINSTANCE
200: .createFeaturePathDomainModelReference();
201: valueDMR1.setDomainModelEFeature(BowlingPackage.eINSTANCE.getMerchandise_Name());
202: condition1.setExpectedValue(M1_RIGHT);
203: condition1.setDomainModelReference(dmr1);
204: condition1.setValueDomainModelReference(valueDMR1);
205:
206: final LeafCondition condition2 = RuleFactory.eINSTANCE.createLeafCondition();
207: final VFeaturePathDomainModelReference dmr2 = VViewFactory.eINSTANCE.createFeaturePathDomainModelReference();
208: dmr2.setDomainModelEFeature(BowlingPackage.eINSTANCE.getFan_FanMerchandise());
209: final VFeaturePathDomainModelReference valueDMR2 = VViewFactory.eINSTANCE
210: .createFeaturePathDomainModelReference();
211: valueDMR2.setDomainModelEFeature(BowlingPackage.eINSTANCE.getMerchandise_Name());
212: condition2.setExpectedValue(M2_RIGHT);
213: condition2.setDomainModelReference(dmr2);
214: condition2.setValueDomainModelReference(valueDMR2);
215:
216: condition.getConditions().add(condition1);
217: condition.getConditions().add(condition2);
218:
219: rule.setCondition(condition);
220:
221: element.getAttachments().add(rule);
222:
223: return rule;
224: }
225:
226: private Map<UniqueSetting, BidirectionalMap<Condition, ShowRule>> getSettingsToRules() {
227: try {
228: final RuleRegistry<ShowRule> ruleRegistry = getRuleRegistry();
229:
230: final Field field = ruleRegistry.getClass().getDeclaredField(SETTING_TO_RULES_FIELD_NAME);
231: field.setAccessible(true);
232: @SuppressWarnings("unchecked")
233: final Map<UniqueSetting, BidirectionalMap<Condition, ShowRule>> result = (Map<UniqueSetting, BidirectionalMap<Condition, ShowRule>>) field
234: .get(ruleRegistry);
235: return result;
236: } catch (final SecurityException ex) {
237: } catch (final NoSuchFieldException ex) {
238: } catch (final IllegalArgumentException ex) {
239: } catch (final IllegalAccessException ex) {
240: }
241: fail(REFLECTION_FAIL_FIX_TEST_SETUP);
242: return null;
243: }
244:
245: private BidirectionalMap<ShowRule, VElement> getRulesToRenderables() {
246: try {
247: final RuleRegistry<ShowRule> ruleRegistry = getRuleRegistry();
248:
249: final Field field = ruleRegistry.getClass().getDeclaredField(RULES_TO_RENDERABLES_FIELD_NAME);
250: field.setAccessible(true);
251: @SuppressWarnings("unchecked")
252: final BidirectionalMap<ShowRule, VElement> result = (BidirectionalMap<ShowRule, VElement>) field
253: .get(ruleRegistry);
254: return result;
255: } catch (final SecurityException ex) {
256: } catch (final NoSuchFieldException ex) {
257: } catch (final IllegalArgumentException ex) {
258: } catch (final IllegalAccessException ex) {
259: }
260: fail(REFLECTION_FAIL_FIX_TEST_SETUP);
261: return null;
262: }
263:
264: private Map<Condition, Set<UniqueSetting>> getConditionsToSettings() {
265: try {
266: final RuleRegistry<ShowRule> ruleRegistry = getRuleRegistry();
267:
268: final Field field = ruleRegistry.getClass().getDeclaredField(CONDITION_TO_SETTINGS_FIELD_NAME);
269: field.setAccessible(true);
270: @SuppressWarnings("unchecked")
271: final Map<Condition, Set<UniqueSetting>> result = (Map<Condition, Set<UniqueSetting>>) field
272: .get(ruleRegistry);
273: return result;
274: } catch (final SecurityException ex) {
275: } catch (final NoSuchFieldException ex) {
276: } catch (final IllegalArgumentException ex) {
277: } catch (final IllegalAccessException ex) {
278: }
279: fail(REFLECTION_FAIL_FIX_TEST_SETUP);
280: return null;
281: }
282:
283: private RuleRegistry<ShowRule> getRuleRegistry() {
284: try {
285: final Field field = ruleService.getClass().getDeclaredField(SHOW_RULE_REGISTRY_FIELD_NAME);
286: field.setAccessible(true);
287: @SuppressWarnings("unchecked")
288: final RuleRegistry<ShowRule> result = (RuleRegistry<ShowRule>) field.get(ruleService);
289: return result;
290: } catch (final SecurityException ex) {
291: } catch (final NoSuchFieldException ex) {
292: } catch (final IllegalArgumentException ex) {
293: } catch (final IllegalAccessException ex) {
294: }
295: fail(REFLECTION_FAIL_FIX_TEST_SETUP);
296: return null;
297: }
298:
299: @Test
300: public void testInitOneSingleRefRule() {
301: // setup
302: final ShowRule rule = addFavMerchandiseRule(control1);
303:
304: // act
305: initialize();
306:
307: // assert settingsToRules
308: {
309: final Map<UniqueSetting, BidirectionalMap<Condition, ShowRule>> settingsToRules = getSettingsToRules();
310: assertEquals(1, settingsToRules.size());
311: final Entry<UniqueSetting, BidirectionalMap<Condition, ShowRule>> entry = settingsToRules.entrySet()
312: .iterator()
313: .next();
314: assertEquals(favMerchandiseSetting, entry.getKey());
315: final BidirectionalMap<Condition, ShowRule> conditionToRules = entry.getValue();
316: assertEquals(1, conditionToRules.keys().size());
317: assertEquals(1, conditionToRules.values().size());
318: final Condition condition = conditionToRules.keys().iterator().next();
319: assertEquals(rule.getCondition(), condition);
320: assertEquals(rule, conditionToRules.getValue(condition));
321: }
322:
323: // assert rulesToRenderables
324: {
325: final BidirectionalMap<ShowRule, VElement> rulesToRenderables = getRulesToRenderables();
326: assertEquals(1, rulesToRenderables.keys().size());
327: assertEquals(1, rulesToRenderables.values().size());
328: final ShowRule ruleKey = rulesToRenderables.keys().iterator().next();
329: assertEquals(rule, ruleKey);
330: assertEquals(control1, rulesToRenderables.getValue(ruleKey));
331: }
332:
333: // assert conditionToSettings
334: {
335: final Map<Condition, Set<UniqueSetting>> conditionsToSettings = getConditionsToSettings();
336: assertEquals(1, conditionsToSettings.size());
337: final Entry<Condition, Set<UniqueSetting>> entry = conditionsToSettings.entrySet().iterator().next();
338: assertEquals(rule.getCondition(), entry.getKey());
339: assertEquals(1, entry.getValue().size());
340: assertEquals(favMerchandiseSetting, entry.getValue().iterator().next());
341: }
342: }
343:
344: @Test
345: public void testInitTwoSimilarSingleRefRule() {
346: // setup
347: final ShowRule rule1 = addFavMerchandiseRule(control1);
348: final ShowRule rule2 = addFavMerchandiseRule(control2);
349:
350: // act
351: initialize();
352:
353: // assert settingsToRules
354: {
355: final Map<UniqueSetting, BidirectionalMap<Condition, ShowRule>> settingsToRules = getSettingsToRules();
356: assertEquals(1, settingsToRules.size());
357: final Entry<UniqueSetting, BidirectionalMap<Condition, ShowRule>> entry = settingsToRules.entrySet()
358: .iterator().next();
359: assertEquals(favMerchandiseSetting, entry.getKey());
360: final BidirectionalMap<Condition, ShowRule> conditionToRules = entry.getValue();
361: assertEquals(2, conditionToRules.keys().size());
362: assertEquals(2, conditionToRules.values().size());
363: final Iterator<Condition> iterator = conditionToRules.keys().iterator();
364: final Condition condition1 = iterator.next();
365: assertEquals(rule1.getCondition(), condition1);
366: assertEquals(rule1, conditionToRules.getValue(condition1));
367: final Condition condition2 = iterator.next();
368: assertEquals(rule2.getCondition(), condition2);
369: assertEquals(rule2, conditionToRules.getValue(condition2));
370: }
371:
372: // assert rulesToRenderables
373: {
374: final BidirectionalMap<ShowRule, VElement> rulesToRenderables = getRulesToRenderables();
375: assertEquals(2, rulesToRenderables.keys().size());
376: assertEquals(2, rulesToRenderables.values().size());
377: final Iterator<ShowRule> iterator = rulesToRenderables.keys().iterator();
378: final ShowRule ruleKey1 = iterator.next();
379: assertEquals(rule1, ruleKey1);
380: assertEquals(control1, rulesToRenderables.getValue(ruleKey1));
381: final ShowRule ruleKey2 = iterator.next();
382: assertEquals(rule2, ruleKey2);
383: assertEquals(control2, rulesToRenderables.getValue(ruleKey2));
384: }
385:
386: // assert conditionToSettings
387: {
388: final Map<Condition, Set<UniqueSetting>> conditionsToSettings = getConditionsToSettings();
389: assertEquals(2, conditionsToSettings.size());
390: final Iterator<Entry<Condition, Set<UniqueSetting>>> iterator = conditionsToSettings.entrySet().iterator();
391: final Entry<Condition, Set<UniqueSetting>> entry1 = iterator.next();
392: assertEquals(rule1.getCondition(), entry1.getKey());
393: assertEquals(1, entry1.getValue().size());
394: assertEquals(favMerchandiseSetting, entry1.getValue().iterator().next());
395: final Entry<Condition, Set<UniqueSetting>> entry2 = iterator.next();
396: assertEquals(rule2.getCondition(), entry2.getKey());
397: assertEquals(1, entry2.getValue().size());
398: assertEquals(favMerchandiseSetting, entry2.getValue().iterator().next());
399: }
400: }
401:
402: @Test
403: public void testInitOneMultiRefRule() {
404: // setup
405: final ShowRule rule = addFanMerchandiseRule(control1);
406:
407: // act
408: initialize();
409:
410: // assert settingsToRules
411: {
412: final Map<UniqueSetting, BidirectionalMap<Condition, ShowRule>> settingsToRules = getSettingsToRules();
413: assertEquals(3, settingsToRules.size());
414: final Iterator<Entry<UniqueSetting, BidirectionalMap<Condition, ShowRule>>> iterator = settingsToRules
415: .entrySet().iterator();
416:
417: final Entry<UniqueSetting, BidirectionalMap<Condition, ShowRule>> entry1 = iterator.next();
418: assertEquals(fanSetting, entry1.getKey());
419: final BidirectionalMap<Condition, ShowRule> conditionToRules1 = entry1.getValue();
420: assertEquals(1, conditionToRules1.keys().size());
421: assertEquals(1, conditionToRules1.values().size());
422: final Condition condition1 = conditionToRules1.keys().iterator().next();
423: assertEquals(rule.getCondition(), condition1);
424: assertEquals(rule, conditionToRules1.getValue(condition1));
425:
426: final Entry<UniqueSetting, BidirectionalMap<Condition, ShowRule>> entry2 = iterator.next();
427: assertEquals(merchandise1Setting, entry2.getKey());
428: final BidirectionalMap<Condition, ShowRule> conditionToRules2 = entry2.getValue();
429: assertEquals(1, conditionToRules2.keys().size());
430: assertEquals(1, conditionToRules2.values().size());
431: final Condition condition2 = conditionToRules2.keys().iterator().next();
432: assertEquals(rule.getCondition(), condition2);
433: assertEquals(rule, conditionToRules2.getValue(condition2));
434:
435: final Entry<UniqueSetting, BidirectionalMap<Condition, ShowRule>> entry3 = iterator.next();
436: assertEquals(merchandise2Setting, entry3.getKey());
437: final BidirectionalMap<Condition, ShowRule> conditionToRules3 = entry3.getValue();
438: assertEquals(1, conditionToRules3.keys().size());
439: assertEquals(1, conditionToRules3.values().size());
440: final Condition condition3 = conditionToRules3.keys().iterator().next();
441: assertEquals(rule.getCondition(), condition3);
442: assertEquals(rule, conditionToRules3.getValue(condition3));
443: }
444:
445: // assert rulesToRenderables
446: {
447: final BidirectionalMap<ShowRule, VElement> rulesToRenderables = getRulesToRenderables();
448: assertEquals(1, rulesToRenderables.keys().size());
449: assertEquals(1, rulesToRenderables.values().size());
450: final ShowRule ruleKey = rulesToRenderables.keys().iterator().next();
451: assertEquals(rule, ruleKey);
452: assertEquals(control1, rulesToRenderables.getValue(ruleKey));
453: }
454:
455: // assert conditionToSettings
456: {
457: final Map<Condition, Set<UniqueSetting>> conditionsToSettings = getConditionsToSettings();
458: assertEquals(1, conditionsToSettings.size());
459: final Entry<Condition, Set<UniqueSetting>> entry = conditionsToSettings.entrySet().iterator().next();
460: assertEquals(rule.getCondition(), entry.getKey());
461: assertEquals(3, entry.getValue().size());
462: final Iterator<UniqueSetting> iterator = entry.getValue().iterator();
463: assertEquals(fanSetting, iterator.next());
464: assertEquals(merchandise1Setting, iterator.next());
465: assertEquals(merchandise2Setting, iterator.next());
466: }
467: }
468:
469: @Test
470: public void testInitTwoSimilarMultiRefRule() {
471: // setup
472: final ShowRule rule1 = addFanMerchandiseRule(control1);
473: final ShowRule rule2 = addFanMerchandiseRule(control2);
474:
475: // act
476: initialize();
477:
478: // assert settingsToRules
479: {
480: final Map<UniqueSetting, BidirectionalMap<Condition, ShowRule>> settingsToRules = getSettingsToRules();
481: assertEquals(3, settingsToRules.size());
482: final Iterator<Entry<UniqueSetting, BidirectionalMap<Condition, ShowRule>>> iterator = settingsToRules
483: .entrySet().iterator();
484:
485: final Entry<UniqueSetting, BidirectionalMap<Condition, ShowRule>> entry1 = iterator.next();
486: assertEquals(fanSetting, entry1.getKey());
487: final BidirectionalMap<Condition, ShowRule> conditionToRules1 = entry1.getValue();
488: assertEquals(2, conditionToRules1.keys().size());
489: assertEquals(2, conditionToRules1.values().size());
490: final Iterator<Condition> conditionToRulesIterator1 = conditionToRules1.keys().iterator();
491: final Condition condition11 = conditionToRulesIterator1.next();
492: assertEquals(rule1.getCondition(), condition11);
493: assertEquals(rule1, conditionToRules1.getValue(condition11));
494: final Condition condition12 = conditionToRulesIterator1.next();
495: assertEquals(rule2.getCondition(), condition12);
496: assertEquals(rule2, conditionToRules1.getValue(condition12));
497:
498: final Entry<UniqueSetting, BidirectionalMap<Condition, ShowRule>> entry2 = iterator.next();
499: assertEquals(merchandise1Setting, entry2.getKey());
500: final BidirectionalMap<Condition, ShowRule> conditionToRules2 = entry2.getValue();
501: assertEquals(2, conditionToRules2.keys().size());
502: assertEquals(2, conditionToRules2.values().size());
503: final Iterator<Condition> conditionToRulesIterator2 = conditionToRules2.keys().iterator();
504: final Condition condition21 = conditionToRulesIterator2.next();
505: assertEquals(rule1.getCondition(), condition21);
506: assertEquals(rule1, conditionToRules2.getValue(condition21));
507: final Condition condition22 = conditionToRulesIterator2.next();
508: assertEquals(rule2.getCondition(), condition22);
509: assertEquals(rule2, conditionToRules2.getValue(condition22));
510:
511: final Entry<UniqueSetting, BidirectionalMap<Condition, ShowRule>> entry3 = iterator.next();
512: assertEquals(merchandise2Setting, entry3.getKey());
513: final BidirectionalMap<Condition, ShowRule> conditionToRules3 = entry3.getValue();
514: assertEquals(2, conditionToRules3.keys().size());
515: assertEquals(2, conditionToRules3.values().size());
516: final Iterator<Condition> conditionToRulesIterator3 = conditionToRules3.keys().iterator();
517: final Condition condition31 = conditionToRulesIterator3.next();
518: assertEquals(rule1.getCondition(), condition31);
519: assertEquals(rule1, conditionToRules3.getValue(condition31));
520: final Condition condition32 = conditionToRulesIterator3.next();
521: assertEquals(rule2.getCondition(), condition32);
522: assertEquals(rule2, conditionToRules3.getValue(condition32));
523: }
524:
525: // assert rulesToRenderables
526: {
527: final BidirectionalMap<ShowRule, VElement> rulesToRenderables = getRulesToRenderables();
528: assertEquals(2, rulesToRenderables.keys().size());
529: assertEquals(2, rulesToRenderables.values().size());
530: final Iterator<ShowRule> iterator = rulesToRenderables.keys().iterator();
531:
532: final ShowRule ruleKey1 = iterator.next();
533: assertEquals(rule1, ruleKey1);
534: assertEquals(control1, rulesToRenderables.getValue(ruleKey1));
535:
536: final ShowRule ruleKey2 = iterator.next();
537: assertEquals(rule2, ruleKey2);
538: assertEquals(control2, rulesToRenderables.getValue(ruleKey2));
539: }
540:
541: // assert conditionToSettings
542: {
543: final Map<Condition, Set<UniqueSetting>> conditionsToSettings = getConditionsToSettings();
544: assertEquals(2, conditionsToSettings.size());
545: final Iterator<Entry<Condition, Set<UniqueSetting>>> iterator = conditionsToSettings.entrySet().iterator();
546:
547: final Entry<Condition, Set<UniqueSetting>> entry1 = iterator.next();
548: assertEquals(rule1.getCondition(), entry1.getKey());
549: assertEquals(3, entry1.getValue().size());
550: assertTrue(entry1.getValue().contains(fanSetting));
551: assertTrue(entry1.getValue().contains(merchandise1Setting));
552: assertTrue(entry1.getValue().contains(merchandise2Setting));
553:
554: final Entry<Condition, Set<UniqueSetting>> entry2 = iterator.next();
555: assertEquals(rule2.getCondition(), entry2.getKey());
556: assertEquals(3, entry2.getValue().size());
557: assertTrue(entry2.getValue().contains(fanSetting));
558: assertTrue(entry2.getValue().contains(merchandise1Setting));
559: assertTrue(entry2.getValue().contains(merchandise2Setting));
560: }
561: }
562:
563: @Test
564: public void testInitOrMultiRefRule() {
565: // setup
566: final ShowRule rule = addFanMerchandiseOrRule(control1);
567: final OrCondition orCondition = (OrCondition) rule.getCondition();
568:
569: // act
570: initialize();
571:
572: // assert settingsToRules
573: {
574: final Map<UniqueSetting, BidirectionalMap<Condition, ShowRule>> settingsToRules = getSettingsToRules();
575: assertEquals(3, settingsToRules.size());
576: final Iterator<Entry<UniqueSetting, BidirectionalMap<Condition, ShowRule>>> iterator = settingsToRules
577: .entrySet().iterator();
578:
579: final Entry<UniqueSetting, BidirectionalMap<Condition, ShowRule>> entry1 = iterator.next();
580: assertEquals(fanSetting, entry1.getKey());
581: final BidirectionalMap<Condition, ShowRule> conditionToRules1 = entry1.getValue();
582: assertEquals(1, conditionToRules1.keys().size());
583: assertEquals(1, conditionToRules1.values().size());
584: assertTrue(conditionToRules1.keys().contains(orCondition));
585: assertEquals(rule, conditionToRules1.getValue(orCondition));
586:
587: final Entry<UniqueSetting, BidirectionalMap<Condition, ShowRule>> entry2 = iterator.next();
588: assertEquals(merchandise1Setting, entry2.getKey());
589: final BidirectionalMap<Condition, ShowRule> conditionToRules2 = entry2.getValue();
590: assertEquals(1, conditionToRules2.keys().size());
591: assertEquals(1, conditionToRules2.values().size());
592: assertTrue(conditionToRules2.keys().contains(orCondition));
593: assertEquals(rule, conditionToRules2.getValue(orCondition));
594:
595: final Entry<UniqueSetting, BidirectionalMap<Condition, ShowRule>> entry3 = iterator.next();
596: assertEquals(merchandise2Setting, entry3.getKey());
597: final BidirectionalMap<Condition, ShowRule> conditionToRules3 = entry3.getValue();
598: assertEquals(1, conditionToRules3.keys().size());
599: assertEquals(1, conditionToRules3.values().size());
600: assertTrue(conditionToRules3.keys().contains(orCondition));
601: assertEquals(rule, conditionToRules3.getValue(orCondition));
602: }
603:
604: // assert rulesToRenderables
605: {
606: final BidirectionalMap<ShowRule, VElement> rulesToRenderables = getRulesToRenderables();
607: assertEquals(1, rulesToRenderables.keys().size());
608: assertEquals(1, rulesToRenderables.values().size());
609: final ShowRule ruleKey = rulesToRenderables.keys().iterator().next();
610: assertEquals(rule, ruleKey);
611: assertEquals(control1, rulesToRenderables.getValue(ruleKey));
612: }
613:
614: // assert conditionToSettings
615: {
616: final Map<Condition, Set<UniqueSetting>> conditionsToSettings = getConditionsToSettings();
617: assertEquals(1, conditionsToSettings.size());
618: final Iterator<Entry<Condition, Set<UniqueSetting>>> iterator = conditionsToSettings.entrySet().iterator();
619:
620: final Entry<Condition, Set<UniqueSetting>> entry1 = iterator.next();
621: assertEquals(orCondition, entry1.getKey());
622: assertEquals(3, entry1.getValue().size());
623: assertTrue(entry1.getValue().contains(fanSetting));
624: assertTrue(entry1.getValue().contains(merchandise1Setting));
625: assertTrue(entry1.getValue().contains(merchandise2Setting));
626:
627: }
628: }
629:
630: @Test
631: public void testInitOneMultiRefRuleEmptyList() {
632: // setup
633: fan.getFanMerchandise().clear();
634: final ShowRule rule = addFanMerchandiseRule(control1);
635:
636: // act
637: initialize();
638:
639: // assert settingsToRules
640: {
641: final Map<UniqueSetting, BidirectionalMap<Condition, ShowRule>> settingsToRules = getSettingsToRules();
642: assertEquals(1, settingsToRules.size());
643: final Iterator<Entry<UniqueSetting, BidirectionalMap<Condition, ShowRule>>> iterator = settingsToRules
644: .entrySet().iterator();
645:
646: final Entry<UniqueSetting, BidirectionalMap<Condition, ShowRule>> entry1 = iterator.next();
647: assertEquals(fanSetting, entry1.getKey());
648: final BidirectionalMap<Condition, ShowRule> conditionToRules1 = entry1.getValue();
649: assertEquals(1, conditionToRules1.keys().size());
650: assertEquals(1, conditionToRules1.values().size());
651: final Condition condition1 = conditionToRules1.keys().iterator().next();
652: assertEquals(rule.getCondition(), condition1);
653: assertEquals(rule, conditionToRules1.getValue(condition1));
654: }
655:
656: // assert rulesToRenderables
657: {
658: final BidirectionalMap<ShowRule, VElement> rulesToRenderables = getRulesToRenderables();
659: assertEquals(1, rulesToRenderables.keys().size());
660: assertEquals(1, rulesToRenderables.values().size());
661: final ShowRule ruleKey = rulesToRenderables.keys().iterator().next();
662: assertEquals(rule, ruleKey);
663: assertEquals(control1, rulesToRenderables.getValue(ruleKey));
664: }
665:
666: // assert conditionToSettings
667: {
668: final Map<Condition, Set<UniqueSetting>> conditionsToSettings = getConditionsToSettings();
669: assertEquals(1, conditionsToSettings.size());
670: final Entry<Condition, Set<UniqueSetting>> entry = conditionsToSettings.entrySet().iterator().next();
671: assertEquals(rule.getCondition(), entry.getKey());
672: assertEquals(1, entry.getValue().size());
673: final Iterator<UniqueSetting> iterator = entry.getValue().iterator();
674: assertEquals(fanSetting, iterator.next());
675: }
676: }
677:
678: @Test
679: public void testDynmicOneSingleRefRuleChangeDomain() {
680: // setup
681: final ShowRule rule = addFavMerchandiseRule(control1);
682: initialize();
683:
684: // act
685: final Merchandise newMerchandise = BowlingFactory.eINSTANCE.createMerchandise();
686: fan.setFavouriteMerchandise(newMerchandise);
687: final UniqueSetting newSetting = UniqueSetting.createSetting(newMerchandise,
688: BowlingPackage.eINSTANCE.getMerchandise_Name());
689:
690: // assert settingsToRules
691: {
692: final Map<UniqueSetting, BidirectionalMap<Condition, ShowRule>> settingsToRules = getSettingsToRules();
693: assertEquals(1, settingsToRules.size());
694: final Entry<UniqueSetting, BidirectionalMap<Condition, ShowRule>> entry = settingsToRules.entrySet()
695: .iterator()
696: .next();
697: assertEquals(newSetting, entry.getKey());
698: final BidirectionalMap<Condition, ShowRule> conditionToRules = entry.getValue();
699: assertEquals(1, conditionToRules.keys().size());
700: assertEquals(1, conditionToRules.values().size());
701: final Condition condition = conditionToRules.keys().iterator().next();
702: assertEquals(rule.getCondition(), condition);
703: assertEquals(rule, conditionToRules.getValue(condition));
704: }
705:
706: // assert rulesToRenderables
707: {
708: final BidirectionalMap<ShowRule, VElement> rulesToRenderables = getRulesToRenderables();
709: assertEquals(1, rulesToRenderables.keys().size());
710: assertEquals(1, rulesToRenderables.values().size());
711: final ShowRule ruleKey = rulesToRenderables.keys().iterator().next();
712: assertEquals(rule, ruleKey);
713: assertEquals(control1, rulesToRenderables.getValue(ruleKey));
714: }
715:
716: // assert conditionToSettings
717: {
718: final Map<Condition, Set<UniqueSetting>> conditionsToSettings = getConditionsToSettings();
719: assertEquals(1, conditionsToSettings.size());
720: final Entry<Condition, Set<UniqueSetting>> entry = conditionsToSettings.entrySet().iterator().next();
721: assertEquals(rule.getCondition(), entry.getKey());
722: assertEquals(1, entry.getValue().size());
723: assertEquals(newSetting, entry.getValue().iterator().next());
724: }
725: }
726:
727: @Test
728: public void testDynamicOneSingleRefRuleChangeDomainToNull() {
729: // setup
730: addFavMerchandiseRule(control1);
731: initialize();
732:
733: // act
734: final Merchandise newMerchandise = BowlingFactory.eINSTANCE.createMerchandise();
735: fan.setFavouriteMerchandise(newMerchandise);
736: fan.setFavouriteMerchandise(null);
737:
738: // assert settingsToRules
739: {
740: final Map<UniqueSetting, BidirectionalMap<Condition, ShowRule>> settingsToRules = getSettingsToRules();
741: assertEquals(0, settingsToRules.size());
742: }
743:
744: // assert rulesToRenderables
745: {
746: final BidirectionalMap<ShowRule, VElement> rulesToRenderables = getRulesToRenderables();
747: assertEquals(0, rulesToRenderables.keys().size());
748: assertEquals(0, rulesToRenderables.values().size());
749: }
750:
751: // assert conditionToSettings
752: {
753: final Map<Condition, Set<UniqueSetting>> conditionsToSettings = getConditionsToSettings();
754: assertEquals(0, conditionsToSettings.size());
755: }
756: }
757:
758: @Test
759: public void testDynamicOneMultiRefRuleChangeDomainAdd() {
760: // setup
761: final ShowRule rule = addFanMerchandiseRule(control1);
762: initialize();
763:
764: // act
765: final Merchandise newMerchandise = BowlingFactory.eINSTANCE.createMerchandise();
766: fan.getFanMerchandise().add(newMerchandise);
767: final UniqueSetting newSetting = UniqueSetting.createSetting(newMerchandise,
768: BowlingPackage.eINSTANCE.getMerchandise_Name());
769:
770: // assert settingsToRules
771: {
772: final Map<UniqueSetting, BidirectionalMap<Condition, ShowRule>> settingsToRules = getSettingsToRules();
773: assertEquals(4, settingsToRules.size());
774: final Iterator<Entry<UniqueSetting, BidirectionalMap<Condition, ShowRule>>> iterator = settingsToRules
775: .entrySet().iterator();
776:
777: final Entry<UniqueSetting, BidirectionalMap<Condition, ShowRule>> entry1 = iterator.next();
778: assertEquals(fanSetting, entry1.getKey());
779: final BidirectionalMap<Condition, ShowRule> conditionToRules1 = entry1.getValue();
780: assertEquals(1, conditionToRules1.keys().size());
781: assertEquals(1, conditionToRules1.values().size());
782: final Condition condition1 = conditionToRules1.keys().iterator().next();
783: assertEquals(rule.getCondition(), condition1);
784: assertEquals(rule, conditionToRules1.getValue(condition1));
785:
786: final Entry<UniqueSetting, BidirectionalMap<Condition, ShowRule>> entry2 = iterator.next();
787: assertEquals(merchandise1Setting, entry2.getKey());
788: final BidirectionalMap<Condition, ShowRule> conditionToRules2 = entry2.getValue();
789: assertEquals(1, conditionToRules2.keys().size());
790: assertEquals(1, conditionToRules2.values().size());
791: final Condition condition2 = conditionToRules2.keys().iterator().next();
792: assertEquals(rule.getCondition(), condition2);
793: assertEquals(rule, conditionToRules2.getValue(condition2));
794:
795: final Entry<UniqueSetting, BidirectionalMap<Condition, ShowRule>> entry3 = iterator.next();
796: assertEquals(merchandise2Setting, entry3.getKey());
797: final BidirectionalMap<Condition, ShowRule> conditionToRules3 = entry3.getValue();
798: assertEquals(1, conditionToRules3.keys().size());
799: assertEquals(1, conditionToRules3.values().size());
800: final Condition condition3 = conditionToRules3.keys().iterator().next();
801: assertEquals(rule.getCondition(), condition3);
802: assertEquals(rule, conditionToRules3.getValue(condition3));
803:
804: final Entry<UniqueSetting, BidirectionalMap<Condition, ShowRule>> entry4 = iterator.next();
805: assertEquals(newSetting, entry4.getKey());
806: final BidirectionalMap<Condition, ShowRule> conditionToRules4 = entry4.getValue();
807: assertEquals(1, conditionToRules4.keys().size());
808: assertEquals(1, conditionToRules4.values().size());
809: final Condition condition4 = conditionToRules4.keys().iterator().next();
810: assertEquals(rule.getCondition(), condition4);
811: assertEquals(rule, conditionToRules4.getValue(condition4));
812: }
813:
814: // assert rulesToRenderables
815: {
816: final BidirectionalMap<ShowRule, VElement> rulesToRenderables = getRulesToRenderables();
817: assertEquals(1, rulesToRenderables.keys().size());
818: assertEquals(1, rulesToRenderables.values().size());
819: final ShowRule ruleKey = rulesToRenderables.keys().iterator().next();
820: assertEquals(rule, ruleKey);
821: assertEquals(control1, rulesToRenderables.getValue(ruleKey));
822: }
823:
824: // assert conditionToSettings
825: {
826: final Map<Condition, Set<UniqueSetting>> conditionsToSettings = getConditionsToSettings();
827: assertEquals(1, conditionsToSettings.size());
828: final Entry<Condition, Set<UniqueSetting>> entry = conditionsToSettings.entrySet().iterator().next();
829: assertEquals(rule.getCondition(), entry.getKey());
830: assertEquals(4, entry.getValue().size());
831: final Iterator<UniqueSetting> iterator = entry.getValue().iterator();
832: assertEquals(fanSetting, iterator.next());
833: assertEquals(merchandise1Setting, iterator.next());
834: assertEquals(merchandise2Setting, iterator.next());
835: assertEquals(newSetting, iterator.next());
836: }
837: }
838:
839: @Test
840: public void testDynamicOneMultiRefRuleChangeDomainRemove() {
841: // setup
842: final ShowRule rule = addFanMerchandiseRule(control1);
843: initialize();
844:
845: // act
846: fan.getFanMerchandise().remove(1);
847:
848: // assert settingsToRules
849: {
850: final Map<UniqueSetting, BidirectionalMap<Condition, ShowRule>> settingsToRules = getSettingsToRules();
851: assertEquals(2, settingsToRules.size());
852: final Iterator<Entry<UniqueSetting, BidirectionalMap<Condition, ShowRule>>> iterator = settingsToRules
853: .entrySet().iterator();
854:
855: final Entry<UniqueSetting, BidirectionalMap<Condition, ShowRule>> entry1 = iterator.next();
856: assertEquals(fanSetting, entry1.getKey());
857: final BidirectionalMap<Condition, ShowRule> conditionToRules1 = entry1.getValue();
858: assertEquals(1, conditionToRules1.keys().size());
859: assertEquals(1, conditionToRules1.values().size());
860: final Condition condition1 = conditionToRules1.keys().iterator().next();
861: assertEquals(rule.getCondition(), condition1);
862: assertEquals(rule, conditionToRules1.getValue(condition1));
863:
864: final Entry<UniqueSetting, BidirectionalMap<Condition, ShowRule>> entry2 = iterator.next();
865: assertEquals(merchandise1Setting, entry2.getKey());
866: final BidirectionalMap<Condition, ShowRule> conditionToRules2 = entry2.getValue();
867: assertEquals(1, conditionToRules2.keys().size());
868: assertEquals(1, conditionToRules2.values().size());
869: final Condition condition2 = conditionToRules2.keys().iterator().next();
870: assertEquals(rule.getCondition(), condition2);
871: assertEquals(rule, conditionToRules2.getValue(condition2));
872: }
873:
874: // assert rulesToRenderables
875: {
876: final BidirectionalMap<ShowRule, VElement> rulesToRenderables = getRulesToRenderables();
877: assertEquals(1, rulesToRenderables.keys().size());
878: assertEquals(1, rulesToRenderables.values().size());
879: final ShowRule ruleKey = rulesToRenderables.keys().iterator().next();
880: assertEquals(rule, ruleKey);
881: assertEquals(control1, rulesToRenderables.getValue(ruleKey));
882: }
883:
884: // assert conditionToSettings
885: {
886: final Map<Condition, Set<UniqueSetting>> conditionsToSettings = getConditionsToSettings();
887: assertEquals(1, conditionsToSettings.size());
888: final Entry<Condition, Set<UniqueSetting>> entry = conditionsToSettings.entrySet().iterator().next();
889: assertEquals(rule.getCondition(), entry.getKey());
890: assertEquals(2, entry.getValue().size());
891: final Iterator<UniqueSetting> iterator = entry.getValue().iterator();
892: assertEquals(fanSetting, iterator.next());
893: assertEquals(merchandise1Setting, iterator.next());
894: }
895: }
896:
897: @Test
898: public void testDynamicOneMultiRefRuleChangeDomainClear() {
899: // setup
900: final ShowRule rule = addFanMerchandiseRule(control1);
901: initialize();
902:
903: // act
904: fan.getFanMerchandise().clear();
905:
906: // assert settingsToRules
907: {
908: final Map<UniqueSetting, BidirectionalMap<Condition, ShowRule>> settingsToRules = getSettingsToRules();
909: assertEquals(1, settingsToRules.size());
910: final Iterator<Entry<UniqueSetting, BidirectionalMap<Condition, ShowRule>>> iterator = settingsToRules
911: .entrySet().iterator();
912:
913: final Entry<UniqueSetting, BidirectionalMap<Condition, ShowRule>> entry1 = iterator.next();
914: assertEquals(fanSetting, entry1.getKey());
915: final BidirectionalMap<Condition, ShowRule> conditionToRules1 = entry1.getValue();
916: assertEquals(1, conditionToRules1.keys().size());
917: assertEquals(1, conditionToRules1.values().size());
918: final Condition condition1 = conditionToRules1.keys().iterator().next();
919: assertEquals(rule.getCondition(), condition1);
920: assertEquals(rule, conditionToRules1.getValue(condition1));
921: }
922:
923: // assert rulesToRenderables
924: {
925: final BidirectionalMap<ShowRule, VElement> rulesToRenderables = getRulesToRenderables();
926: assertEquals(1, rulesToRenderables.keys().size());
927: assertEquals(1, rulesToRenderables.values().size());
928: final ShowRule ruleKey = rulesToRenderables.keys().iterator().next();
929: assertEquals(rule, ruleKey);
930: assertEquals(control1, rulesToRenderables.getValue(ruleKey));
931: }
932:
933: // assert conditionToSettings
934: {
935: final Map<Condition, Set<UniqueSetting>> conditionsToSettings = getConditionsToSettings();
936: assertEquals(1, conditionsToSettings.size());
937: final Entry<Condition, Set<UniqueSetting>> entry = conditionsToSettings.entrySet().iterator().next();
938: assertEquals(rule.getCondition(), entry.getKey());
939: assertEquals(1, entry.getValue().size());
940: final Iterator<UniqueSetting> iterator = entry.getValue().iterator();
941: assertEquals(fanSetting, iterator.next());
942: }
943: }
944:
945: @Test
946: public void testDynamicOneMultiRefRuleChangeDomainUnaffected() {
947: // setup
948: final ShowRule rule = addFanMerchandiseRule(control1);
949: initialize();
950:
951: // act
952: fan.getVisitedTournaments().add(BowlingFactory.eINSTANCE.createTournament());
953:
954: // assert settingsToRules
955: {
956: final Map<UniqueSetting, BidirectionalMap<Condition, ShowRule>> settingsToRules = getSettingsToRules();
957: assertEquals(3, settingsToRules.size());
958: final Iterator<Entry<UniqueSetting, BidirectionalMap<Condition, ShowRule>>> iterator = settingsToRules
959: .entrySet().iterator();
960:
961: final Entry<UniqueSetting, BidirectionalMap<Condition, ShowRule>> entry1 = iterator.next();
962: assertEquals(fanSetting, entry1.getKey());
963: final BidirectionalMap<Condition, ShowRule> conditionToRules1 = entry1.getValue();
964: assertEquals(1, conditionToRules1.keys().size());
965: assertEquals(1, conditionToRules1.values().size());
966: final Condition condition1 = conditionToRules1.keys().iterator().next();
967: assertEquals(rule.getCondition(), condition1);
968: assertEquals(rule, conditionToRules1.getValue(condition1));
969:
970: final Entry<UniqueSetting, BidirectionalMap<Condition, ShowRule>> entry2 = iterator.next();
971: assertEquals(merchandise1Setting, entry2.getKey());
972: final BidirectionalMap<Condition, ShowRule> conditionToRules2 = entry2.getValue();
973: assertEquals(1, conditionToRules2.keys().size());
974: assertEquals(1, conditionToRules2.values().size());
975: final Condition condition2 = conditionToRules2.keys().iterator().next();
976: assertEquals(rule.getCondition(), condition2);
977: assertEquals(rule, conditionToRules2.getValue(condition2));
978:
979: final Entry<UniqueSetting, BidirectionalMap<Condition, ShowRule>> entry3 = iterator.next();
980: assertEquals(merchandise2Setting, entry3.getKey());
981: final BidirectionalMap<Condition, ShowRule> conditionToRules3 = entry3.getValue();
982: assertEquals(1, conditionToRules3.keys().size());
983: assertEquals(1, conditionToRules3.values().size());
984: final Condition condition3 = conditionToRules3.keys().iterator().next();
985: assertEquals(rule.getCondition(), condition3);
986: assertEquals(rule, conditionToRules3.getValue(condition3));
987: }
988:
989: // assert rulesToRenderables
990: {
991: final BidirectionalMap<ShowRule, VElement> rulesToRenderables = getRulesToRenderables();
992: assertEquals(1, rulesToRenderables.keys().size());
993: assertEquals(1, rulesToRenderables.values().size());
994: final ShowRule ruleKey = rulesToRenderables.keys().iterator().next();
995: assertEquals(rule, ruleKey);
996: assertEquals(control1, rulesToRenderables.getValue(ruleKey));
997: }
998:
999: // assert conditionToSettings
1000: {
1001: final Map<Condition, Set<UniqueSetting>> conditionsToSettings = getConditionsToSettings();
1002: assertEquals(1, conditionsToSettings.size());
1003: final Entry<Condition, Set<UniqueSetting>> entry = conditionsToSettings.entrySet().iterator().next();
1004: assertEquals(rule.getCondition(), entry.getKey());
1005: assertEquals(3, entry.getValue().size());
1006: final Iterator<UniqueSetting> iterator = entry.getValue().iterator();
1007: assertEquals(fanSetting, iterator.next());
1008: assertEquals(merchandise1Setting, iterator.next());
1009: assertEquals(merchandise2Setting, iterator.next());
1010: }
1011: }
1012:
1013: @Test
1014: public void testDynamicOneMultiRefRuleChangeDomainAddNonContainment() {
1015: // setup
1016: final ShowRule rule = RuleFactory.eINSTANCE.createShowRule();
1017: final LeafCondition condition = RuleFactory.eINSTANCE.createLeafCondition();
1018: final VFeaturePathDomainModelReference dmr = VViewFactory.eINSTANCE.createFeaturePathDomainModelReference();
1019: dmr.setDomainModelEFeature(BowlingPackage.eINSTANCE.getFan_VisitedTournaments());
1020: final VFeaturePathDomainModelReference valueDMR = VViewFactory.eINSTANCE
1021: .createFeaturePathDomainModelReference();
1022: valueDMR.setDomainModelEFeature(BowlingPackage.eINSTANCE.getTournament_PriceMoney());
1023: condition.setExpectedValue(99.99);
1024: condition.setDomainModelReference(dmr);
1025: condition.setValueDomainModelReference(valueDMR);
1026: rule.setCondition(condition);
1027: control1.getAttachments().add(rule);
1028:
1029: final Tournament tournament1 = BowlingFactory.eINSTANCE.createTournament();
1030: fan.getVisitedTournaments().add(tournament1);
1031:
1032: final UniqueSetting newSettingList = UniqueSetting.createSetting(fan,
1033: BowlingPackage.eINSTANCE.getFan_VisitedTournaments());
1034: final UniqueSetting newSettingLeaf1 = UniqueSetting.createSetting(tournament1,
1035: BowlingPackage.eINSTANCE.getTournament_PriceMoney());
1036:
1037: initialize();
1038:
1039: // act
1040: final Tournament tournament2 = BowlingFactory.eINSTANCE.createTournament();
1041: fan.getVisitedTournaments().add(tournament2);
1042: final UniqueSetting newSettingLeaf2 = UniqueSetting.createSetting(tournament2,
1043: BowlingPackage.eINSTANCE.getTournament_PriceMoney());
1044:
1045: // assert settingsToRules
1046: {
1047: final Map<UniqueSetting, BidirectionalMap<Condition, ShowRule>> settingsToRules = getSettingsToRules();
1048: assertEquals(3, settingsToRules.size());
1049: final Iterator<Entry<UniqueSetting, BidirectionalMap<Condition, ShowRule>>> iterator = settingsToRules
1050: .entrySet().iterator();
1051:
1052: final Entry<UniqueSetting, BidirectionalMap<Condition, ShowRule>> entry1 = iterator.next();
1053: assertEquals(newSettingList, entry1.getKey());
1054: final BidirectionalMap<Condition, ShowRule> conditionToRules1 = entry1.getValue();
1055: assertEquals(1, conditionToRules1.keys().size());
1056: assertEquals(1, conditionToRules1.values().size());
1057: final Condition condition1 = conditionToRules1.keys().iterator().next();
1058: assertEquals(rule.getCondition(), condition1);
1059: assertEquals(rule, conditionToRules1.getValue(condition1));
1060:
1061: final Entry<UniqueSetting, BidirectionalMap<Condition, ShowRule>> entry2 = iterator.next();
1062: assertEquals(newSettingLeaf1, entry2.getKey());
1063: final BidirectionalMap<Condition, ShowRule> conditionToRules2 = entry2.getValue();
1064: assertEquals(1, conditionToRules2.keys().size());
1065: assertEquals(1, conditionToRules2.values().size());
1066: final Condition condition2 = conditionToRules2.keys().iterator().next();
1067: assertEquals(rule.getCondition(), condition2);
1068: assertEquals(rule, conditionToRules2.getValue(condition2));
1069:
1070: final Entry<UniqueSetting, BidirectionalMap<Condition, ShowRule>> entry3 = iterator.next();
1071: assertEquals(newSettingLeaf2, entry3.getKey());
1072: final BidirectionalMap<Condition, ShowRule> conditionToRules3 = entry3.getValue();
1073: assertEquals(1, conditionToRules3.keys().size());
1074: assertEquals(1, conditionToRules3.values().size());
1075: final Condition condition3 = conditionToRules3.keys().iterator().next();
1076: assertEquals(rule.getCondition(), condition3);
1077: assertEquals(rule, conditionToRules3.getValue(condition3));
1078: }
1079:
1080: // assert rulesToRenderables
1081: {
1082: final BidirectionalMap<ShowRule, VElement> rulesToRenderables = getRulesToRenderables();
1083: assertEquals(1, rulesToRenderables.keys().size());
1084: assertEquals(1, rulesToRenderables.values().size());
1085: final ShowRule ruleKey = rulesToRenderables.keys().iterator().next();
1086: assertEquals(rule, ruleKey);
1087: assertEquals(control1, rulesToRenderables.getValue(ruleKey));
1088: }
1089:
1090: // assert conditionToSettings
1091: {
1092: final Map<Condition, Set<UniqueSetting>> conditionsToSettings = getConditionsToSettings();
1093: assertEquals(1, conditionsToSettings.size());
1094: final Entry<Condition, Set<UniqueSetting>> entry = conditionsToSettings.entrySet().iterator().next();
1095: assertEquals(rule.getCondition(), entry.getKey());
1096: assertEquals(3, entry.getValue().size());
1097: final Iterator<UniqueSetting> iterator = entry.getValue().iterator();
1098: assertEquals(newSettingList, iterator.next());
1099: assertEquals(newSettingLeaf1, iterator.next());
1100: assertEquals(newSettingLeaf2, iterator.next());
1101: }
1102: }
1103:
1104: @Test
1105: public void testDynamicOneSingleRefRuleRemoveRule() {
1106: // setup
1107: addFavMerchandiseRule(control1);
1108: initialize();
1109:
1110: // act
1111: control1.getAttachments().clear();
1112:
1113: // assert settingsToRules
1114: {
1115: final Map<UniqueSetting, BidirectionalMap<Condition, ShowRule>> settingsToRules = getSettingsToRules();
1116: assertEquals(0, settingsToRules.size());
1117: }
1118:
1119: // assert rulesToRenderables
1120: {
1121: final BidirectionalMap<ShowRule, VElement> rulesToRenderables = getRulesToRenderables();
1122: assertEquals(0, rulesToRenderables.keys().size());
1123: assertEquals(0, rulesToRenderables.values().size());
1124: }
1125:
1126: // assert conditionToSettings
1127: {
1128: final Map<Condition, Set<UniqueSetting>> conditionsToSettings = getConditionsToSettings();
1129: assertEquals(0, conditionsToSettings.size());
1130: }
1131: }
1132:
1133: @Test
1134: public void testDynamicTwoSimilarSingleRefRuleRemoveOneRule() {
1135: // setup
1136: final ShowRule rule1 = addFavMerchandiseRule(control1);
1137: addFavMerchandiseRule(control2);
1138: initialize();
1139:
1140: // act
1141: control2.getAttachments().clear();
1142:
1143: // assert settingsToRules
1144: {
1145: final Map<UniqueSetting, BidirectionalMap<Condition, ShowRule>> settingsToRules = getSettingsToRules();
1146: assertEquals(1, settingsToRules.size());
1147: final Entry<UniqueSetting, BidirectionalMap<Condition, ShowRule>> entry = settingsToRules.entrySet()
1148: .iterator().next();
1149: assertEquals(favMerchandiseSetting, entry.getKey());
1150: final BidirectionalMap<Condition, ShowRule> conditionToRules = entry.getValue();
1151: assertEquals(1, conditionToRules.keys().size());
1152: assertEquals(1, conditionToRules.values().size());
1153: final Iterator<Condition> iterator = conditionToRules.keys().iterator();
1154: final Condition condition1 = iterator.next();
1155: assertEquals(rule1.getCondition(), condition1);
1156: assertEquals(rule1, conditionToRules.getValue(condition1));
1157: }
1158:
1159: // assert rulesToRenderables
1160: {
1161: final BidirectionalMap<ShowRule, VElement> rulesToRenderables = getRulesToRenderables();
1162: assertEquals(1, rulesToRenderables.keys().size());
1163: assertEquals(1, rulesToRenderables.values().size());
1164: final Iterator<ShowRule> iterator = rulesToRenderables.keys().iterator();
1165: final ShowRule ruleKey1 = iterator.next();
1166: assertEquals(rule1, ruleKey1);
1167: assertEquals(control1, rulesToRenderables.getValue(ruleKey1));
1168: }
1169:
1170: // assert conditionToSettings
1171: {
1172: final Map<Condition, Set<UniqueSetting>> conditionsToSettings = getConditionsToSettings();
1173: assertEquals(1, conditionsToSettings.size());
1174: final Iterator<Entry<Condition, Set<UniqueSetting>>> iterator = conditionsToSettings.entrySet().iterator();
1175: final Entry<Condition, Set<UniqueSetting>> entry1 = iterator.next();
1176: assertEquals(rule1.getCondition(), entry1.getKey());
1177: assertEquals(1, entry1.getValue().size());
1178: assertEquals(favMerchandiseSetting, entry1.getValue().iterator().next());
1179: }
1180: }
1181:
1182: @Test
1183: public void testDynmicOneMultiRefRuleRemoveRule() {
1184: // setup
1185: addFanMerchandiseRule(control1);
1186: initialize();
1187:
1188: // act
1189: control1.getAttachments().clear();
1190:
1191: // assert settingsToRules
1192: {
1193: final Map<UniqueSetting, BidirectionalMap<Condition, ShowRule>> settingsToRules = getSettingsToRules();
1194: assertEquals(0, settingsToRules.size());
1195: }
1196:
1197: // assert rulesToRenderables
1198: {
1199: final BidirectionalMap<ShowRule, VElement> rulesToRenderables = getRulesToRenderables();
1200: assertEquals(0, rulesToRenderables.keys().size());
1201: assertEquals(0, rulesToRenderables.values().size());
1202: }
1203:
1204: // assert conditionToSettings
1205: {
1206: final Map<Condition, Set<UniqueSetting>> conditionsToSettings = getConditionsToSettings();
1207: assertEquals(0, conditionsToSettings.size());
1208: }
1209: }
1210:
1211: @Test
1212: public void testDynamicTwoSimilarMultiRefRuleRemoveOneRule() {
1213: // setup
1214: final ShowRule rule1 = addFanMerchandiseRule(control1);
1215: addFanMerchandiseRule(control2);
1216: initialize();
1217:
1218: // act
1219: control2.getAttachments().clear();
1220:
1221: // assert settingsToRules
1222: {
1223: final Map<UniqueSetting, BidirectionalMap<Condition, ShowRule>> settingsToRules = getSettingsToRules();
1224: assertEquals(3, settingsToRules.size());
1225: final Iterator<Entry<UniqueSetting, BidirectionalMap<Condition, ShowRule>>> iterator = settingsToRules
1226: .entrySet().iterator();
1227:
1228: final Entry<UniqueSetting, BidirectionalMap<Condition, ShowRule>> entry1 = iterator.next();
1229: assertEquals(fanSetting, entry1.getKey());
1230: final BidirectionalMap<Condition, ShowRule> conditionToRules1 = entry1.getValue();
1231: assertEquals(1, conditionToRules1.keys().size());
1232: assertEquals(1, conditionToRules1.values().size());
1233: final Iterator<Condition> conditionToRulesIterator1 = conditionToRules1.keys().iterator();
1234: final Condition condition11 = conditionToRulesIterator1.next();
1235: assertEquals(rule1.getCondition(), condition11);
1236: assertEquals(rule1, conditionToRules1.getValue(condition11));
1237:
1238: final Entry<UniqueSetting, BidirectionalMap<Condition, ShowRule>> entry2 = iterator.next();
1239: assertEquals(merchandise1Setting, entry2.getKey());
1240: final BidirectionalMap<Condition, ShowRule> conditionToRules2 = entry2.getValue();
1241: assertEquals(1, conditionToRules2.keys().size());
1242: assertEquals(1, conditionToRules2.values().size());
1243: final Iterator<Condition> conditionToRulesIterator2 = conditionToRules2.keys().iterator();
1244: final Condition condition21 = conditionToRulesIterator2.next();
1245: assertEquals(rule1.getCondition(), condition21);
1246: assertEquals(rule1, conditionToRules2.getValue(condition21));
1247:
1248: final Entry<UniqueSetting, BidirectionalMap<Condition, ShowRule>> entry3 = iterator.next();
1249: assertEquals(merchandise2Setting, entry3.getKey());
1250: final BidirectionalMap<Condition, ShowRule> conditionToRules3 = entry3.getValue();
1251: assertEquals(1, conditionToRules3.keys().size());
1252: assertEquals(1, conditionToRules3.values().size());
1253: final Iterator<Condition> conditionToRulesIterator3 = conditionToRules3.keys().iterator();
1254: final Condition condition31 = conditionToRulesIterator3.next();
1255: assertEquals(rule1.getCondition(), condition31);
1256: assertEquals(rule1, conditionToRules3.getValue(condition31));
1257: }
1258:
1259: // assert rulesToRenderables
1260: {
1261: final BidirectionalMap<ShowRule, VElement> rulesToRenderables = getRulesToRenderables();
1262: assertEquals(1, rulesToRenderables.keys().size());
1263: assertEquals(1, rulesToRenderables.values().size());
1264: final Iterator<ShowRule> iterator = rulesToRenderables.keys().iterator();
1265:
1266: final ShowRule ruleKey1 = iterator.next();
1267: assertEquals(rule1, ruleKey1);
1268: assertEquals(control1, rulesToRenderables.getValue(ruleKey1));
1269: }
1270:
1271: // assert conditionToSettings
1272: {
1273: final Map<Condition, Set<UniqueSetting>> conditionsToSettings = getConditionsToSettings();
1274: assertEquals(1, conditionsToSettings.size());
1275: final Iterator<Entry<Condition, Set<UniqueSetting>>> iterator = conditionsToSettings.entrySet().iterator();
1276:
1277: final Entry<Condition, Set<UniqueSetting>> entry1 = iterator.next();
1278: assertEquals(rule1.getCondition(), entry1.getKey());
1279: assertEquals(3, entry1.getValue().size());
1280: assertTrue(entry1.getValue().contains(fanSetting));
1281: assertTrue(entry1.getValue().contains(merchandise1Setting));
1282: assertTrue(entry1.getValue().contains(merchandise2Setting));
1283: }
1284: }
1285:
1286: @Test
1287: public void testDynmicOneSingleRefRuleChangeCondition() {
1288: // setup
1289: final ShowRule rule = addFavMerchandiseRule(control1);
1290: initialize();
1291:
1292: // act
1293: final LeafCondition leafCondition = (LeafCondition) rule.getCondition();
1294: final VFeaturePathDomainModelReference reference = (VFeaturePathDomainModelReference) leafCondition
1295: .getDomainModelReference();
1296: reference.setDomainModelEFeature(BowlingPackage.eINSTANCE.getMerchandise_SerialNumber());
1297: leafCondition.setExpectedValue(1234567890);
1298: final UniqueSetting newSetting = UniqueSetting.createSetting(favMerchandise,
1299: BowlingPackage.eINSTANCE.getMerchandise_SerialNumber());
1300:
1301: // assert settingsToRules
1302: {
1303: final Map<UniqueSetting, BidirectionalMap<Condition, ShowRule>> settingsToRules = getSettingsToRules();
1304: assertEquals(1, settingsToRules.size());
1305: final Entry<UniqueSetting, BidirectionalMap<Condition, ShowRule>> entry = settingsToRules.entrySet()
1306: .iterator()
1307: .next();
1308: assertEquals(newSetting, entry.getKey());
1309: final BidirectionalMap<Condition, ShowRule> conditionToRules = entry.getValue();
1310: assertEquals(1, conditionToRules.keys().size());
1311: assertEquals(1, conditionToRules.values().size());
1312: final Condition condition = conditionToRules.keys().iterator().next();
1313: assertEquals(rule.getCondition(), condition);
1314: assertEquals(rule, conditionToRules.getValue(condition));
1315: }
1316:
1317: // assert rulesToRenderables
1318: {
1319: final BidirectionalMap<ShowRule, VElement> rulesToRenderables = getRulesToRenderables();
1320: assertEquals(1, rulesToRenderables.keys().size());
1321: assertEquals(1, rulesToRenderables.values().size());
1322: final ShowRule ruleKey = rulesToRenderables.keys().iterator().next();
1323: assertEquals(rule, ruleKey);
1324: assertEquals(control1, rulesToRenderables.getValue(ruleKey));
1325: }
1326:
1327: // assert conditionToSettings
1328: {
1329: final Map<Condition, Set<UniqueSetting>> conditionsToSettings = getConditionsToSettings();
1330: assertEquals(1, conditionsToSettings.size());
1331: final Entry<Condition, Set<UniqueSetting>> entry = conditionsToSettings.entrySet().iterator().next();
1332: assertEquals(rule.getCondition(), entry.getKey());
1333: assertEquals(1, entry.getValue().size());
1334: assertEquals(newSetting, entry.getValue().iterator().next());
1335: }
1336: }
1337:
1338: @Test
1339: public void testDynamicTwoSimilarSingleRefRuleChangeOneCondition() {
1340: // setup
1341: final ShowRule rule1 = addFavMerchandiseRule(control1);
1342: final ShowRule rule2 = addFavMerchandiseRule(control2);
1343: initialize();
1344:
1345: // act
1346: final LeafCondition leafCondition = (LeafCondition) rule2.getCondition();
1347: final VFeaturePathDomainModelReference reference = (VFeaturePathDomainModelReference) leafCondition
1348: .getDomainModelReference();
1349: reference.setDomainModelEFeature(BowlingPackage.eINSTANCE.getMerchandise_SerialNumber());
1350: leafCondition.setExpectedValue(1234567890);
1351: final UniqueSetting newSetting = UniqueSetting.createSetting(favMerchandise,
1352: BowlingPackage.eINSTANCE.getMerchandise_SerialNumber());
1353:
1354: // assert settingsToRules
1355: {
1356: final Map<UniqueSetting, BidirectionalMap<Condition, ShowRule>> settingsToRules = getSettingsToRules();
1357: assertEquals(2, settingsToRules.size());
1358:
1359: assertTrue(settingsToRules.containsKey(favMerchandiseSetting));
1360: final BidirectionalMap<Condition, ShowRule> conditionToRules1 = settingsToRules.get(favMerchandiseSetting);
1361: assertEquals(1, conditionToRules1.keys().size());
1362: assertEquals(1, conditionToRules1.values().size());
1363: final Iterator<Condition> iterator1 = conditionToRules1.keys().iterator();
1364: final Condition condition1 = iterator1.next();
1365: assertEquals(rule1.getCondition(), condition1);
1366: assertEquals(rule1, conditionToRules1.getValue(condition1));
1367:
1368: assertTrue(settingsToRules.containsKey(newSetting));
1369: final BidirectionalMap<Condition, ShowRule> conditionToRules2 = settingsToRules.get(newSetting);
1370: assertEquals(1, conditionToRules2.keys().size());
1371: assertEquals(1, conditionToRules2.values().size());
1372: final Iterator<Condition> iterator2 = conditionToRules2.keys().iterator();
1373: final Condition condition2 = iterator2.next();
1374: assertEquals(rule2.getCondition(), condition2);
1375: assertEquals(rule2, conditionToRules2.getValue(condition2));
1376: }
1377:
1378: // assert rulesToRenderables
1379: {
1380: final BidirectionalMap<ShowRule, VElement> rulesToRenderables = getRulesToRenderables();
1381: assertEquals(2, rulesToRenderables.keys().size());
1382: assertEquals(2, rulesToRenderables.values().size());
1383: final Iterator<ShowRule> iterator = rulesToRenderables.keys().iterator();
1384: final ShowRule ruleKey1 = iterator.next();
1385: assertEquals(rule1, ruleKey1);
1386: assertEquals(control1, rulesToRenderables.getValue(ruleKey1));
1387: final ShowRule ruleKey2 = iterator.next();
1388: assertEquals(rule2, ruleKey2);
1389: assertEquals(control2, rulesToRenderables.getValue(ruleKey2));
1390: }
1391:
1392: // assert conditionToSettings
1393: {
1394: final Map<Condition, Set<UniqueSetting>> conditionsToSettings = getConditionsToSettings();
1395: assertEquals(2, conditionsToSettings.size());
1396: final Iterator<Entry<Condition, Set<UniqueSetting>>> iterator = conditionsToSettings.entrySet().iterator();
1397: final Entry<Condition, Set<UniqueSetting>> entry1 = iterator.next();
1398: assertEquals(rule1.getCondition(), entry1.getKey());
1399: assertEquals(1, entry1.getValue().size());
1400: assertEquals(favMerchandiseSetting, entry1.getValue().iterator().next());
1401: final Entry<Condition, Set<UniqueSetting>> entry2 = iterator.next();
1402: assertEquals(rule2.getCondition(), entry2.getKey());
1403: assertEquals(1, entry2.getValue().size());
1404: assertEquals(newSetting, entry2.getValue().iterator().next());
1405: }
1406: }
1407:
1408: @Test
1409: public void testDynamicOneMultiRefRuleChangeConditionToOtherMultiRef() {
1410: // setup
1411: final ShowRule rule = addFanMerchandiseRule(control1);
1412: initialize();
1413:
1414: // act
1415: final Tournament tournament = BowlingFactory.eINSTANCE.createTournament();
1416: fan.getVisitedTournaments().add(tournament);
1417:
1418: final LeafCondition leafCondition = (LeafCondition) rule.getCondition();
1419: final VFeaturePathDomainModelReference reference = (VFeaturePathDomainModelReference) leafCondition
1420: .getDomainModelReference();
1421: reference.setDomainModelEFeature(BowlingPackage.eINSTANCE.getFan_VisitedTournaments());
1422: final VFeaturePathDomainModelReference valueDMR = (VFeaturePathDomainModelReference) leafCondition
1423: .getValueDomainModelReference();
1424: valueDMR.setDomainModelEFeature(BowlingPackage.eINSTANCE.getTournament_PriceMoney());
1425: leafCondition.setExpectedValue(99.99);
1426:
1427: final UniqueSetting newSettingList = UniqueSetting.createSetting(fan,
1428: BowlingPackage.eINSTANCE.getFan_VisitedTournaments());
1429: final UniqueSetting newSettingLeaf = UniqueSetting.createSetting(tournament,
1430: BowlingPackage.eINSTANCE.getTournament_PriceMoney());
1431:
1432: // assert settingsToRules
1433: {
1434: final Map<UniqueSetting, BidirectionalMap<Condition, ShowRule>> settingsToRules = getSettingsToRules();
1435: assertEquals(2, settingsToRules.size());
1436: final Iterator<Entry<UniqueSetting, BidirectionalMap<Condition, ShowRule>>> iterator = settingsToRules
1437: .entrySet().iterator();
1438:
1439: final Entry<UniqueSetting, BidirectionalMap<Condition, ShowRule>> entry1 = iterator.next();
1440: assertEquals(newSettingList, entry1.getKey());
1441: final BidirectionalMap<Condition, ShowRule> conditionToRules1 = entry1.getValue();
1442: assertEquals(1, conditionToRules1.keys().size());
1443: assertEquals(1, conditionToRules1.values().size());
1444: final Condition condition1 = conditionToRules1.keys().iterator().next();
1445: assertEquals(rule.getCondition(), condition1);
1446: assertEquals(rule, conditionToRules1.getValue(condition1));
1447:
1448: final Entry<UniqueSetting, BidirectionalMap<Condition, ShowRule>> entry2 = iterator.next();
1449: assertEquals(newSettingLeaf, entry2.getKey());
1450: final BidirectionalMap<Condition, ShowRule> conditionToRules2 = entry2.getValue();
1451: assertEquals(1, conditionToRules2.keys().size());
1452: assertEquals(1, conditionToRules2.values().size());
1453: final Condition condition2 = conditionToRules2.keys().iterator().next();
1454: assertEquals(rule.getCondition(), condition2);
1455: assertEquals(rule, conditionToRules2.getValue(condition2));
1456: }
1457:
1458: // assert rulesToRenderables
1459: {
1460: final BidirectionalMap<ShowRule, VElement> rulesToRenderables = getRulesToRenderables();
1461: assertEquals(1, rulesToRenderables.keys().size());
1462: assertEquals(1, rulesToRenderables.values().size());
1463: final ShowRule ruleKey = rulesToRenderables.keys().iterator().next();
1464: assertEquals(rule, ruleKey);
1465: assertEquals(control1, rulesToRenderables.getValue(ruleKey));
1466: }
1467:
1468: // assert conditionToSettings
1469: {
1470: final Map<Condition, Set<UniqueSetting>> conditionsToSettings = getConditionsToSettings();
1471: assertEquals(1, conditionsToSettings.size());
1472: final Entry<Condition, Set<UniqueSetting>> entry = conditionsToSettings.entrySet().iterator().next();
1473: assertEquals(rule.getCondition(), entry.getKey());
1474: assertEquals(2, entry.getValue().size());
1475: final Iterator<UniqueSetting> iterator = entry.getValue().iterator();
1476: assertEquals(newSettingList, iterator.next());
1477: assertEquals(newSettingLeaf, iterator.next());
1478: }
1479: }
1480:
1481: @Test
1482: public void testDynamicTwoSimilarMultiRefRuleChangeOneConditionNoNonMulti() {
1483: // setup
1484: final ShowRule rule1 = addFanMerchandiseRule(control1);
1485: final ShowRule rule2 = addFanMerchandiseRule(control2);
1486: initialize();
1487:
1488: // act
1489: final LeafCondition leafCondition = (LeafCondition) rule2.getCondition();
1490: final VFeaturePathDomainModelReference reference = (VFeaturePathDomainModelReference) leafCondition
1491: .getDomainModelReference();
1492: reference.getDomainModelEReferencePath().clear();
1493: reference.getDomainModelEReferencePath().add(BowlingPackage.eINSTANCE.getFan_FavouriteMerchandise());
1494: reference.setDomainModelEFeature(BowlingPackage.eINSTANCE.getMerchandise_SerialNumber());
1495: leafCondition.setExpectedValue(1234567890);
1496: final UniqueSetting newSetting = UniqueSetting.createSetting(favMerchandise,
1497: BowlingPackage.eINSTANCE.getMerchandise_SerialNumber());
1498:
1499: // assert settingsToRules
1500: {
1501: final Map<UniqueSetting, BidirectionalMap<Condition, ShowRule>> settingsToRules = getSettingsToRules();
1502: assertEquals(4, settingsToRules.size());
1503: final Iterator<Entry<UniqueSetting, BidirectionalMap<Condition, ShowRule>>> iterator = settingsToRules
1504: .entrySet().iterator();
1505:
1506: final Entry<UniqueSetting, BidirectionalMap<Condition, ShowRule>> entry1 = iterator.next();
1507: assertEquals(fanSetting, entry1.getKey());
1508: final BidirectionalMap<Condition, ShowRule> conditionToRules1 = entry1.getValue();
1509: assertEquals(1, conditionToRules1.keys().size());
1510: assertEquals(1, conditionToRules1.values().size());
1511: final Iterator<Condition> conditionToRulesIterator1 = conditionToRules1.keys().iterator();
1512: final Condition condition11 = conditionToRulesIterator1.next();
1513: assertEquals(rule1.getCondition(), condition11);
1514: assertEquals(rule1, conditionToRules1.getValue(condition11));
1515:
1516: final Entry<UniqueSetting, BidirectionalMap<Condition, ShowRule>> entry2 = iterator.next();
1517: assertEquals(merchandise1Setting, entry2.getKey());
1518: final BidirectionalMap<Condition, ShowRule> conditionToRules2 = entry2.getValue();
1519: assertEquals(1, conditionToRules2.keys().size());
1520: assertEquals(1, conditionToRules2.values().size());
1521: final Iterator<Condition> conditionToRulesIterator2 = conditionToRules2.keys().iterator();
1522: final Condition condition21 = conditionToRulesIterator2.next();
1523: assertEquals(rule1.getCondition(), condition21);
1524: assertEquals(rule1, conditionToRules2.getValue(condition21));
1525:
1526: final Entry<UniqueSetting, BidirectionalMap<Condition, ShowRule>> entry3 = iterator.next();
1527: assertEquals(merchandise2Setting, entry3.getKey());
1528: final BidirectionalMap<Condition, ShowRule> conditionToRules3 = entry3.getValue();
1529: assertEquals(1, conditionToRules3.keys().size());
1530: assertEquals(1, conditionToRules3.values().size());
1531: final Iterator<Condition> conditionToRulesIterator3 = conditionToRules3.keys().iterator();
1532: final Condition condition31 = conditionToRulesIterator3.next();
1533: assertEquals(rule1.getCondition(), condition31);
1534: assertEquals(rule1, conditionToRules3.getValue(condition31));
1535:
1536: final Entry<UniqueSetting, BidirectionalMap<Condition, ShowRule>> entry4 = iterator.next();
1537: assertEquals(newSetting, entry4.getKey());
1538: final BidirectionalMap<Condition, ShowRule> conditionToRules4 = entry4.getValue();
1539: assertEquals(1, conditionToRules4.keys().size());
1540: assertEquals(1, conditionToRules4.values().size());
1541: final Iterator<Condition> conditionToRulesIterator4 = conditionToRules4.keys().iterator();
1542: final Condition condition41 = conditionToRulesIterator4.next();
1543: assertEquals(rule2.getCondition(), condition41);
1544: assertEquals(rule2, conditionToRules4.getValue(condition41));
1545: }
1546:
1547: // assert rulesToRenderables
1548: {
1549: final BidirectionalMap<ShowRule, VElement> rulesToRenderables = getRulesToRenderables();
1550: assertEquals(2, rulesToRenderables.keys().size());
1551: assertEquals(2, rulesToRenderables.values().size());
1552: final Iterator<ShowRule> iterator = rulesToRenderables.keys().iterator();
1553:
1554: final ShowRule ruleKey1 = iterator.next();
1555: assertEquals(rule1, ruleKey1);
1556: assertEquals(control1, rulesToRenderables.getValue(ruleKey1));
1557:
1558: final ShowRule ruleKey2 = iterator.next();
1559: assertEquals(rule2, ruleKey2);
1560: assertEquals(control2, rulesToRenderables.getValue(ruleKey2));
1561: }
1562:
1563: // assert conditionToSettings
1564: {
1565: final Map<Condition, Set<UniqueSetting>> conditionsToSettings = getConditionsToSettings();
1566: assertEquals(2, conditionsToSettings.size());
1567: final Iterator<Entry<Condition, Set<UniqueSetting>>> iterator = conditionsToSettings.entrySet().iterator();
1568:
1569: final Entry<Condition, Set<UniqueSetting>> entry1 = iterator.next();
1570: assertEquals(rule1.getCondition(), entry1.getKey());
1571: assertEquals(3, entry1.getValue().size());
1572: assertTrue(entry1.getValue().contains(fanSetting));
1573: assertTrue(entry1.getValue().contains(merchandise1Setting));
1574: assertTrue(entry1.getValue().contains(merchandise2Setting));
1575:
1576: final Entry<Condition, Set<UniqueSetting>> entry2 = iterator.next();
1577: assertEquals(rule2.getCondition(), entry2.getKey());
1578: assertEquals(1, entry2.getValue().size());
1579: assertTrue(entry2.getValue().contains(newSetting));
1580: }
1581: }
1582:
1583: }// END COMPLEX CODE