![[Jenkins]](/ecp/static/e8bbdb94/images/svgs/logo.svg){kind=logo}
Package: ViewValidation_PTest$2
ViewValidation_PTest$2
| name | instruction | branch | complexity | line | method | ||||||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| matchesSafely(Diagnostic) |
|
|
|
|
|
||||||||||||||||||||
| {...} |
|
|
|
|
|
||||||||||||||||||||
Coverage
1: /*******************************************************************************
2: * Copyright (c) 2011-2019 EclipseSource Muenchen GmbH and others.
3: *
4: * All rights reserved. This program and the accompanying materials
5: * are made available under the terms of the Eclipse Public License 2.0
6: * which accompanies this distribution, and is available at
7: * https://www.eclipse.org/legal/epl-2.0/
8: *
9: * SPDX-License-Identifier: EPL-2.0
10: *
11: * Contributors:
12: * Eugen Neufeld - initial API and implementation
13: * Christian W. Damus - bugs 545686, 548761
14: ******************************************************************************/
15: package org.eclipse.emf.ecp.view.validation.test;
16:
17: import static java.util.stream.Collectors.toList;
18: import static org.eclipse.emf.ecp.view.spi.validation.ValidationServiceConstants.PROPAGATION_LIMIT_KEY;
19: import static org.hamcrest.CoreMatchers.everyItem;
20: import static org.hamcrest.CoreMatchers.hasItem;
21: import static org.hamcrest.CoreMatchers.is;
22: import static org.hamcrest.CoreMatchers.notNullValue;
23: import static org.junit.Assert.assertEquals;
24: import static org.junit.Assert.assertNull;
25: import static org.junit.Assert.assertThat;
26: import static org.junit.Assert.fail;
27:
28: import java.util.ArrayList;
29: import java.util.Arrays;
30: import java.util.Collection;
31: import java.util.Collections;
32: import java.util.Iterator;
33: import java.util.LinkedHashSet;
34: import java.util.List;
35: import java.util.Map;
36: import java.util.Set;
37: import java.util.concurrent.ArrayBlockingQueue;
38: import java.util.concurrent.BlockingQueue;
39: import java.util.concurrent.CountDownLatch;
40: import java.util.concurrent.TimeUnit;
41: import java.util.stream.Stream;
42:
43: import org.eclipse.emf.common.util.Diagnostic;
44: import org.eclipse.emf.ecore.EObject;
45: import org.eclipse.emf.ecore.EReference;
46: import org.eclipse.emf.ecore.EStructuralFeature;
47: import org.eclipse.emf.ecp.test.common.DefaultRealm;
48: import org.eclipse.emf.ecp.view.spi.context.GlobalViewModelService;
49: import org.eclipse.emf.ecp.view.spi.context.ViewModelContext;
50: import org.eclipse.emf.ecp.view.spi.context.ViewModelContextFactory;
51: import org.eclipse.emf.ecp.view.spi.model.VControl;
52: import org.eclipse.emf.ecp.view.spi.model.VDiagnostic;
53: import org.eclipse.emf.ecp.view.spi.model.VDomainModelReference;
54: import org.eclipse.emf.ecp.view.spi.model.VFeaturePathDomainModelReference;
55: import org.eclipse.emf.ecp.view.spi.model.VView;
56: import org.eclipse.emf.ecp.view.spi.model.VViewFactory;
57: import org.eclipse.emf.ecp.view.spi.table.model.VTableControl;
58: import org.eclipse.emf.ecp.view.spi.table.model.VTableDomainModelReference;
59: import org.eclipse.emf.ecp.view.spi.table.model.VTableFactory;
60: import org.eclipse.emf.ecp.view.spi.validation.ValidationService;
61: import org.eclipse.emf.ecp.view.spi.validation.ValidationUpdateListener;
62: import org.eclipse.emf.ecp.view.spi.validation.ViewValidationListener;
63: import org.eclipse.emf.ecp.view.spi.vertical.model.VVerticalFactory;
64: import org.eclipse.emf.ecp.view.spi.vertical.model.VVerticalLayout;
65: import org.eclipse.emf.ecp.view.validation.test.model.Computer;
66: import org.eclipse.emf.ecp.view.validation.test.model.Container;
67: import org.eclipse.emf.ecp.view.validation.test.model.Content;
68: import org.eclipse.emf.ecp.view.validation.test.model.Library;
69: import org.eclipse.emf.ecp.view.validation.test.model.Mainboard;
70: import org.eclipse.emf.ecp.view.validation.test.model.PowerBlock;
71: import org.eclipse.emf.ecp.view.validation.test.model.Referencer;
72: import org.eclipse.emf.ecp.view.validation.test.model.TestFactory;
73: import org.eclipse.emf.ecp.view.validation.test.model.TestPackage;
74: import org.eclipse.emf.ecp.view.validation.test.model.Writer;
75: import org.eclipse.emfforms.spi.core.services.view.EMFFormsViewContext;
76: import org.eclipse.emfforms.spi.core.services.view.EMFFormsViewServiceFactory;
77: import org.eclipse.emfforms.spi.core.services.view.EMFFormsViewServicePolicy;
78: import org.eclipse.emfforms.spi.core.services.view.EMFFormsViewServiceScope;
79: import org.hamcrest.CustomTypeSafeMatcher;
80: import org.hamcrest.Matcher;
81: import org.junit.After;
82: import org.junit.Before;
83: import org.junit.Ignore;
84: import org.junit.Test;
85:
86: /**
87: * @author Eugen Neufeld
88: * @author emueller
89: */
90:
91: public class ViewValidation_PTest extends CommonValidationTest {
92:
93: private DefaultRealm defaultRealm;
94:
95: //
96: // Test framework
97: //
98:
99: @Before
100: public void setup() {
101: defaultRealm = new DefaultRealm();
102: }
103:
104: @After
105: public void tearDown() {
106: defaultRealm.dispose();
107: }
108:
109: static Matcher<Diagnostic> isOK() {
110: return new CustomTypeSafeMatcher<Diagnostic>("is OK") {
111: @Override
112: protected boolean matchesSafely(Diagnostic item) {
113: return item.getSeverity() == Diagnostic.OK;
114: }
115: };
116: }
117:
118: static Matcher<Diagnostic> isError() {
119: return new CustomTypeSafeMatcher<Diagnostic>("is error") {
120: @Override
121: protected boolean matchesSafely(Diagnostic item) {
122:• return item.getSeverity() == Diagnostic.ERROR;
123: }
124: };
125: }
126:
127: //
128: // Tests
129: //
130:
131: @Test
132: public void testValidationMissingElementOnInit() {
133: final Computer computer = TestFactory.eINSTANCE.createComputer();
134: computer.setName("bla");
135: final VControl control = VViewFactory.eINSTANCE.createControl();
136:
137: control.setDomainModelReference(getVFeaturePathDomainModelReference(TestPackage.eINSTANCE.getMainboard_Name(),
138: TestPackage.eINSTANCE.getComputer_Mainboard()));
139: ViewModelContextFactory.INSTANCE.createViewModelContext(control, computer);
140:
141: assertEquals("Severity must be error", Diagnostic.ERROR, control.getDiagnostic().getHighestSeverity());
142: }
143:
144: @Test
145: public void testValidationMissingElementSetValueAfterInit() {
146: final Computer computer = TestFactory.eINSTANCE.createComputer();
147: computer.setName("bla");
148: final VControl control = VViewFactory.eINSTANCE.createControl();
149:
150: control.setDomainModelReference(getVFeaturePathDomainModelReference(TestPackage.eINSTANCE.getMainboard_Name(),
151: TestPackage.eINSTANCE.getComputer_Mainboard()));
152: ViewModelContextFactory.INSTANCE.createViewModelContext(control, computer);
153: computer.getMainboard().setName("bla");
154: assertEquals("Severity must be ok", Diagnostic.OK, control.getDiagnostic().getHighestSeverity());
155: }
156:
157: private VDomainModelReference getVTableDomainModelReference(EStructuralFeature feature,
158: EReference... eReferences) {
159: final VTableDomainModelReference result = VTableFactory.eINSTANCE.createTableDomainModelReference();
160: result.setDomainModelEFeature(feature);
161: result.getDomainModelEReferencePath().addAll(Arrays.asList(eReferences));
162: return result;
163: }
164:
165: @Test
166: public void testValidationInitOk() {
167: final Computer computer = TestFactory.eINSTANCE.createComputer();
168: computer.setName("bla");
169: final VControl control = VViewFactory.eINSTANCE.createControl();
170:
171: control.setDomainModelReference(
172: getVFeaturePathDomainModelReference(TestPackage.eINSTANCE.getComputer_Name()));
173: ViewModelContextFactory.INSTANCE.createViewModelContext(control, computer);
174:
175: assertEquals("Severity must be ok", Diagnostic.OK, control.getDiagnostic().getHighestSeverity());
176: }
177:
178: @Test
179: public void testValidationSameFeature() {
180: final Mainboard mainboard = TestFactory.eINSTANCE.createMainboard();
181: final PowerBlock powerBlock = TestFactory.eINSTANCE.createPowerBlock();
182: final Computer computer = TestFactory.eINSTANCE.createComputer();
183: computer.setMainboard(mainboard);
184: computer.setPowerBlock(powerBlock);
185:
186: final VView view = VViewFactory.eINSTANCE.createView();
187: final VControl powerBlockControl = VViewFactory.eINSTANCE.createControl();
188: final VControl mainboardControl = VViewFactory.eINSTANCE.createControl();
189: view.getChildren().add(powerBlockControl);
190: view.getChildren().add(mainboardControl);
191:
192: powerBlockControl.setDomainModelReference(
193: getVFeaturePathDomainModelReference(TestPackage.eINSTANCE.getPowerBlock_Name(),
194: TestPackage.eINSTANCE.getComputer_PowerBlock()));
195:
196: mainboardControl.setDomainModelReference(
197: getVFeaturePathDomainModelReference(TestPackage.eINSTANCE.getMainboard_Name(),
198: TestPackage.eINSTANCE.getComputer_Mainboard()));
199:
200: ViewModelContextFactory.INSTANCE.createViewModelContext(view, computer);
201:
202: mainboard.setName("foo");
203:
204: assertEquals("Severity must be ok", Diagnostic.OK,
205: mainboardControl.getDiagnostic().getHighestSeverity());
206: assertEquals("Severity must be error", Diagnostic.ERROR,
207: powerBlockControl.getDiagnostic().getHighestSeverity());
208: assertEquals("Severity must be error", Diagnostic.ERROR,
209: view.getDiagnostic().getHighestSeverity());
210: }
211:
212: @Test
213: public void testValidationInitDisabledControlOk() {
214: final Computer computer = TestFactory.eINSTANCE.createComputer();
215: computer.setName("bla");
216: final VControl control = VViewFactory.eINSTANCE.createControl();
217: control.setEnabled(false);
218:
219: control.setDomainModelReference(
220: getVFeaturePathDomainModelReference(TestPackage.eINSTANCE.getComputer_Name()));
221: ViewModelContextFactory.INSTANCE.createViewModelContext(control, computer);
222: assertNull(control.getDiagnostic());
223: }
224:
225: @Test
226: public void testValidationInitHiddenControlError() {
227: final Computer computer = TestFactory.eINSTANCE.createComputer();
228: final VControl control = VViewFactory.eINSTANCE.createControl();
229: control.setVisible(false);
230:
231: control.setDomainModelReference(
232: getVFeaturePathDomainModelReference(TestPackage.eINSTANCE.getComputer_Name()));
233: ViewModelContextFactory.INSTANCE.createViewModelContext(control, computer);
234: assertNull(control.getDiagnostic());
235: }
236:
237: @Test
238: public void testValidationDisabledControlOk() {
239: final Computer computer = TestFactory.eINSTANCE.createComputer();
240: final VControl control = VViewFactory.eINSTANCE.createControl();
241:
242: control.setDomainModelReference(
243: getVFeaturePathDomainModelReference(TestPackage.eINSTANCE.getComputer_Name()));
244: ViewModelContextFactory.INSTANCE.createViewModelContext(control, computer);
245: assertEquals("Severity must be Error", Diagnostic.ERROR, control.getDiagnostic().getHighestSeverity());
246: control.setEnabled(false);
247: assertNull(control.getDiagnostic());
248:
249: }
250:
251: @Test
252: public void testValidationHiddenControlOk() {
253: final Computer computer = TestFactory.eINSTANCE.createComputer();
254: computer.setName("bla");
255: final VControl control = VViewFactory.eINSTANCE.createControl();
256:
257: control.setDomainModelReference(
258: getVFeaturePathDomainModelReference(TestPackage.eINSTANCE.getComputer_Name()));
259: ViewModelContextFactory.INSTANCE.createViewModelContext(control, computer);
260: control.setVisible(false);
261:
262: assertEquals("Severity must be ok", Diagnostic.OK, control.getDiagnostic().getHighestSeverity());
263: }
264:
265: @Test
266: public void testValidationInitHiddenControlOk() {
267: final Computer computer = TestFactory.eINSTANCE.createComputer();
268: computer.setName("bla");
269: final VControl control = VViewFactory.eINSTANCE.createControl();
270:
271: control.setDomainModelReference(
272: getVFeaturePathDomainModelReference(TestPackage.eINSTANCE.getComputer_Name()));
273: ViewModelContextFactory.INSTANCE.createViewModelContext(control, computer);
274:
275: assertEquals("Severity must be ok", Diagnostic.OK, control.getDiagnostic().getHighestSeverity());
276: }
277:
278: @Test
279: public void testValidationInitError() {
280: final Computer computer = TestFactory.eINSTANCE.createComputer();
281: final VControl control = VViewFactory.eINSTANCE.createControl();
282: control.setDomainModelReference(
283: getVFeaturePathDomainModelReference(TestPackage.eINSTANCE.getComputer_Name()));
284:
285: ViewModelContextFactory.INSTANCE.createViewModelContext(control, computer);
286:
287: assertEquals("Severity must be error", Diagnostic.ERROR, control.getDiagnostic().getHighestSeverity());
288: }
289:
290: @Test
291: public void testValidationInitAggregation() {
292: final Computer computer = TestFactory.eINSTANCE.createComputer();
293: computer.setName("bla");
294: final PowerBlock power = TestFactory.eINSTANCE.createPowerBlock();
295: power.setName("bla");
296: final Mainboard board = TestFactory.eINSTANCE.createMainboard();
297: computer.setMainboard(board);
298: computer.setPowerBlock(power);
299:
300: final VView view = VViewFactory.eINSTANCE.createView();
301: final VControl controlPower = VViewFactory.eINSTANCE.createControl();
302: controlPower.setDomainModelReference(getVFeaturePathDomainModelReference(
303: TestPackage.eINSTANCE.getPowerBlock_Name(), TestPackage.eINSTANCE.getComputer_PowerBlock()));
304:
305: final VControl controlBoard = VViewFactory.eINSTANCE.createControl();
306: controlBoard.setDomainModelReference(getVFeaturePathDomainModelReference(
307: TestPackage.eINSTANCE.getMainboard_Name(), TestPackage.eINSTANCE.getComputer_Mainboard()));
308:
309: view.getChildren().add(controlBoard);
310: view.getChildren().add(controlPower);
311:
312: ViewModelContextFactory.INSTANCE.createViewModelContext(view, computer);
313:
314: assertEquals("Severity of mainboard must be error", Diagnostic.ERROR, controlBoard.getDiagnostic()
315: .getHighestSeverity());
316: assertEquals("Severity of power must be ok", Diagnostic.OK, controlPower.getDiagnostic().getHighestSeverity());
317: assertEquals("Severity of view must be ok", Diagnostic.ERROR, view.getDiagnostic().getHighestSeverity());
318: }
319:
320: @Test
321: public void testValidationInitPropagation1LevelOk() {
322: final Computer computer = TestFactory.eINSTANCE.createComputer();
323: computer.setName("bla");
324: final VVerticalLayout column = VVerticalFactory.eINSTANCE.createVerticalLayout();
325: final VControl control = VViewFactory.eINSTANCE.createControl();
326:
327: control.setDomainModelReference(
328: getVFeaturePathDomainModelReference(TestPackage.eINSTANCE.getComputer_Name()));
329: column.getChildren().add(control);
330:
331: ViewModelContextFactory.INSTANCE.createViewModelContext(column, computer);
332:
333: assertEquals("Severity of control must be ok", Diagnostic.OK, control.getDiagnostic().getHighestSeverity());
334: assertEquals("Severity of column must be ok", Diagnostic.OK, column.getDiagnostic().getHighestSeverity());
335: }
336:
337: @Test
338: public void testValidationInitPropagation1LevelError() {
339: final Computer computer = TestFactory.eINSTANCE.createComputer();
340:
341: final VVerticalLayout column = VVerticalFactory.eINSTANCE.createVerticalLayout();
342: final VControl control = VViewFactory.eINSTANCE.createControl();
343: control.setDomainModelReference(
344: getVFeaturePathDomainModelReference(TestPackage.eINSTANCE.getComputer_Name()));
345:
346: column.getChildren().add(control);
347:
348: ViewModelContextFactory.INSTANCE.createViewModelContext(column, computer);
349:
350: assertEquals("Severity of control must be error", Diagnostic.ERROR, control.getDiagnostic()
351: .getHighestSeverity());
352: assertEquals("Severity of column must be error", Diagnostic.ERROR, column.getDiagnostic().getHighestSeverity());
353: }
354:
355: @Test
356: public void testValidationInitPropagation2LevelOk() {
357: final Computer computer = TestFactory.eINSTANCE.createComputer();
358: computer.setName("bla");
359: final VView view = VViewFactory.eINSTANCE.createView();
360: final VVerticalLayout column = VVerticalFactory.eINSTANCE.createVerticalLayout();
361: final VControl control = VViewFactory.eINSTANCE.createControl();
362: control.setDomainModelReference(
363: getVFeaturePathDomainModelReference(TestPackage.eINSTANCE.getComputer_Name()));
364:
365: column.getChildren().add(control);
366: view.getChildren().add(column);
367:
368: ViewModelContextFactory.INSTANCE.createViewModelContext(view, computer);
369:
370: assertEquals("Severity of control must be ok", Diagnostic.OK, control.getDiagnostic().getHighestSeverity());
371: assertEquals("Severity of column must be ok", Diagnostic.OK, column.getDiagnostic().getHighestSeverity());
372: assertEquals("Severity of view must be ok", Diagnostic.OK, view.getDiagnostic().getHighestSeverity());
373: }
374:
375: @Test
376: public void testValidationInitPropagation2LevelError() {
377: final Computer computer = TestFactory.eINSTANCE.createComputer();
378:
379: final VView view = VViewFactory.eINSTANCE.createView();
380:
381: final VVerticalLayout column = VVerticalFactory.eINSTANCE.createVerticalLayout();
382: final VControl control = VViewFactory.eINSTANCE.createControl();
383: control.setDomainModelReference(
384: getVFeaturePathDomainModelReference(TestPackage.eINSTANCE.getComputer_Name()));
385:
386: column.getChildren().add(control);
387: view.getChildren().add(column);
388:
389: ViewModelContextFactory.INSTANCE.createViewModelContext(view, computer);
390:
391: assertEquals("Severity of control must be error", Diagnostic.ERROR, control.getDiagnostic()
392: .getHighestSeverity());
393: assertEquals("Severity of column must be error", Diagnostic.ERROR, column.getDiagnostic().getHighestSeverity());
394: assertEquals("Severity of view must be error", Diagnostic.ERROR, view.getDiagnostic().getHighestSeverity());
395: }
396:
397: /**
398: * Test the limiting of validation propagation by annotation.
399: */
400: @Test
401: public void testValidationInitPropagation_limited() {
402: final List<Computer> computers = Stream.generate(TestFactory.eINSTANCE::createComputer)
403: .limit(3L).collect(toList());
404:
405: final Map<String, Object> contextValues = Collections.singletonMap(PROPAGATION_LIMIT_KEY, 1);
406:
407: final VView view = VViewFactory.eINSTANCE.createView();
408: final VVerticalLayout column = VVerticalFactory.eINSTANCE.createVerticalLayout();
409: view.getChildren().add(column);
410:
411: computers.forEach(c -> {
412: final VControl control = VViewFactory.eINSTANCE.createControl();
413: control.setDomainModelReference(
414: getVFeaturePathDomainModelReference(TestPackage.eINSTANCE.getComputer_Name()));
415: column.getChildren().add(control);
416: ViewModelContextFactory.INSTANCE.createViewModelContext(control, c, contextValues);
417: });
418:
419: final VDiagnostic columnDiagnostic = column.getDiagnostic();
420: assertThat("Severity of column must be error", columnDiagnostic.getHighestSeverity(), is(Diagnostic.ERROR));
421: // But we only propagated one error, plus the one that indicates more
422: assertThat("Wrong number of problems", columnDiagnostic.getDiagnostics().size(), is(2));
423: final Diagnostic additional = columnDiagnostic.getDiagnostics().stream()
424: .filter(Diagnostic.class::isInstance).map(Diagnostic.class::cast)
425: .filter(d -> d.getMessage() != null)
426: .filter(d -> d.getMessage().startsWith("Additional problems"))
427: .findAny().orElse(null);
428: assertThat("No placeholder for additional problems", additional, notNullValue());
429: assertThat("Placehold is not an error", additional.getSeverity(), is(Diagnostic.ERROR));
430: }
431:
432: @Test
433: public void testValidationChangeOkToError() {
434: final Computer computer = TestFactory.eINSTANCE.createComputer();
435: computer.setName("bla");
436: final VControl control = VViewFactory.eINSTANCE.createControl();
437: control.setDomainModelReference(
438: getVFeaturePathDomainModelReference(TestPackage.eINSTANCE.getComputer_Name()));
439:
440: ViewModelContextFactory.INSTANCE.createViewModelContext(control, computer);
441:
442: computer.setName(null);
443:
444: assertEquals("Severity must be error", Diagnostic.ERROR, control.getDiagnostic().getHighestSeverity());
445: }
446:
447: @Test
448: public void testValidationChangeErrorToOk() {
449: final Computer computer = TestFactory.eINSTANCE.createComputer();
450: final VControl control = VViewFactory.eINSTANCE.createControl();
451: control.setDomainModelReference(
452: getVFeaturePathDomainModelReference(TestPackage.eINSTANCE.getComputer_Name()));
453:
454: ViewModelContextFactory.INSTANCE.createViewModelContext(control, computer);
455:
456: computer.setName("bla");
457:
458: assertEquals("Severity must be ok", Diagnostic.OK, control.getDiagnostic().getHighestSeverity());
459: }
460:
461: @Test
462: public void testValidationPropagationChangeOkToError() {
463: final Computer computer = TestFactory.eINSTANCE.createComputer();
464: computer.setName("bla");
465: final VView view = VViewFactory.eINSTANCE.createView();
466: final VControl control = VViewFactory.eINSTANCE.createControl();
467: control.setDomainModelReference(
468: getVFeaturePathDomainModelReference(TestPackage.eINSTANCE.getComputer_Name()));
469: view.getChildren().add(control);
470:
471: ViewModelContextFactory.INSTANCE.createViewModelContext(view, computer);
472:
473: computer.setName(null);
474:
475: assertEquals("Severity of control must be error", Diagnostic.ERROR, control.getDiagnostic()
476: .getHighestSeverity());
477: assertEquals("Severity of view must be error", Diagnostic.ERROR, view.getDiagnostic().getHighestSeverity());
478: }
479:
480: @Test
481: public void testValidationPropagationChangeErrorTokWithErrorControlInBackground() {
482:
483: final Writer writer = TestFactory.eINSTANCE.createWriter();
484: writer.setLastName("foo");
485:
486: final VView view = VViewFactory.eINSTANCE.createView();
487: final VControl firstNameControl = VViewFactory.eINSTANCE.createControl();
488: final VControl lastNameControl = VViewFactory.eINSTANCE.createControl();
489: firstNameControl.setDomainModelReference(
490: getVFeaturePathDomainModelReference(TestPackage.eINSTANCE.getWriter_FirstName()));
491: lastNameControl.setDomainModelReference(
492: getVFeaturePathDomainModelReference(TestPackage.eINSTANCE.getWriter_LastName()));
493: view.getChildren().add(firstNameControl);
494: view.getChildren().add(lastNameControl);
495:
496: ViewModelContextFactory.INSTANCE.createViewModelContext(view, writer);
497:
498: // first name is null -> ERR, last name is 'foo' -> ERR
499: assertEquals("Severity of control must be error", Diagnostic.ERROR, firstNameControl.getDiagnostic()
500: .getHighestSeverity());
501: assertEquals("Severity of view must be error", Diagnostic.ERROR, lastNameControl.getDiagnostic()
502: .getHighestSeverity());
503:
504: writer.setLastName("hello!");
505:
506: assertEquals("Severity of firstname control must be error", Diagnostic.ERROR, firstNameControl.getDiagnostic()
507: .getHighestSeverity());
508: assertEquals("Severity of lastname control must be ok", Diagnostic.OK, lastNameControl.getDiagnostic()
509: .getHighestSeverity());
510: }
511:
512: @Test
513: public void testValidationPropagationChangeErrorTokWithErrorTableControlInBackground() {
514:
515: final Library lib = TestFactory.eINSTANCE.createLibrary();
516: lib.setName("bla");
517: final Writer writer = TestFactory.eINSTANCE.createWriter();
518: lib.getWriters().add(writer);
519: writer.setLastName("foo");
520:
521: final VView view = VViewFactory.eINSTANCE.createView();
522: final VTableControl control = VTableFactory.eINSTANCE.createTableControl();
523: control
524: .setDomainModelReference(
525: getVTableDomainModelReference(TestPackage.eINSTANCE.getLibrary_Writers()));
526: final VFeaturePathDomainModelReference tc = VViewFactory.eINSTANCE.createFeaturePathDomainModelReference();
527: tc.setDomainModelEFeature(TestPackage.eINSTANCE.getWriter_FirstName());
528: VTableDomainModelReference.class.cast(control.getDomainModelReference()).getColumnDomainModelReferences()
529: .add(tc);
530:
531: final VTableControl control2 = VTableFactory.eINSTANCE.createTableControl();
532: control2
533: .setDomainModelReference(
534: getVTableDomainModelReference(TestPackage.eINSTANCE.getLibrary_Writers()));
535: final VFeaturePathDomainModelReference tc2 = VViewFactory.eINSTANCE.createFeaturePathDomainModelReference();
536: tc2.setDomainModelEFeature(TestPackage.eINSTANCE.getWriter_LastName());
537: VTableDomainModelReference.class.cast(control2.getDomainModelReference()).getColumnDomainModelReferences()
538: .add(tc2);
539:
540: view.getChildren().add(control);
541: view.getChildren().add(control2);
542:
543: ViewModelContextFactory.INSTANCE.createViewModelContext(view, lib);
544:
545: // first name is null -> ERR, last name is 'foo' -> ERR
546: assertEquals("Severity of control must be error", Diagnostic.ERROR, control.getDiagnostic()
547: .getHighestSeverity());
548: assertEquals("Severity of view must be error", Diagnostic.ERROR, control2.getDiagnostic()
549: .getHighestSeverity());
550:
551: writer.setLastName("hello!");
552:
553: assertEquals("Severity of control must be error", Diagnostic.ERROR, control.getDiagnostic()
554: .getHighestSeverity());
555: assertEquals("Severity of view must be ok", Diagnostic.OK, control2.getDiagnostic().getHighestSeverity());
556: }
557:
558: @Test
559: public void testValidationPropagationChangeErrorToOk() {
560: final Computer computer = TestFactory.eINSTANCE.createComputer();
561: final VView view = VViewFactory.eINSTANCE.createView();
562: final VControl control = VViewFactory.eINSTANCE.createControl();
563: control.setDomainModelReference(
564: getVFeaturePathDomainModelReference(TestPackage.eINSTANCE.getComputer_Name()));
565:
566: view.getChildren().add(control);
567:
568: ViewModelContextFactory.INSTANCE.createViewModelContext(view, computer);
569:
570: computer.setName("bla");
571:
572: assertEquals("Severity of control must be ok", Diagnostic.OK, control.getDiagnostic().getHighestSeverity());
573: assertEquals("Severity of view must be ok", Diagnostic.OK, control.getDiagnostic().getHighestSeverity());
574: }
575:
576: // TODO fails as the control creates all intermediate domain objects it needs and registers with them, thus the
577: // added object is not recognized during validation and the validation is not successful.
578: // In order to allow the dynamic behavior on normal controls, each control has to know its domain object directly
579: @Test
580: public void testValidationDynamicExtension() {
581: final Computer computer = TestFactory.eINSTANCE.createComputer();
582: computer.setName("bla");
583:
584: final VView view = VViewFactory.eINSTANCE.createView();
585:
586: ViewModelContextFactory.INSTANCE.createViewModelContext(view, computer);
587:
588: final VControl control = VViewFactory.eINSTANCE.createControl();
589:
590: control.setDomainModelReference(
591: getVFeaturePathDomainModelReference(TestPackage.eINSTANCE.getMainboard_Name(),
592: TestPackage.eINSTANCE.getComputer_Mainboard()));
593: view.getChildren().add(control);
594:
595: // TODO
596: // final Mainboard mainboard = TestFactory.eINSTANCE.createMainboard();
597: // computer.setMainboard(mainboard);
598:
599: assertEquals("Severity of mainboard name must be error", Diagnostic.ERROR, control.getDiagnostic()
600: .getHighestSeverity());
601: }
602:
603: @Test
604: public void testValidationDynamicExtensionWithAlreadyInvalidDomainElement() {
605: final Computer computer = TestFactory.eINSTANCE.createComputer();
606: computer.setName("bla");
607:
608: final VView view = VViewFactory.eINSTANCE.createView();
609:
610: ViewModelContextFactory.INSTANCE.createViewModelContext(view, computer);
611:
612: final VControl control = VViewFactory.eINSTANCE.createControl();
613:
614: control.setDomainModelReference(
615: getVFeaturePathDomainModelReference(TestPackage.eINSTANCE.getMainboard_Name(),
616: TestPackage.eINSTANCE.getComputer_Mainboard()));
617: final Mainboard mainboard = TestFactory.eINSTANCE.createMainboard();
618: computer.setMainboard(mainboard);
619:
620: view.getChildren().add(control);
621:
622: assertEquals("Severity of mainboard name must be error", Diagnostic.ERROR, control.getDiagnostic()
623: .getHighestSeverity());
624: }
625:
626: @Test
627: public void testValidationDynamicRemove() {
628: final Computer computer = TestFactory.eINSTANCE.createComputer();
629: computer.setName("bla");
630:
631: final VView view = VViewFactory.eINSTANCE.createView();
632:
633: ViewModelContextFactory.INSTANCE.createViewModelContext(view, computer);
634:
635: final VControl control = VViewFactory.eINSTANCE.createControl();
636:
637: control.setDomainModelReference(
638: getVFeaturePathDomainModelReference(TestPackage.eINSTANCE.getMainboard_Name(),
639: TestPackage.eINSTANCE.getComputer_Mainboard()));
640: view.getChildren().add(control);
641:
642: // TODO
643: // final Mainboard mainboard = TestFactory.eINSTANCE.createMainboard();
644: // computer.setMainboard(mainboard);
645:
646: assertEquals("Severity of mainboard name must be error", Diagnostic.ERROR, view.getDiagnostic()
647: .getHighestSeverity());
648:
649: view.getChildren().remove(control);
650:
651: assertEquals("Severity of mainboard name must be ok", Diagnostic.OK, view.getDiagnostic()
652: .getHighestSeverity());
653: }
654:
655: @Test
656: public void testValidationDynamicExtension2Level() {
657: final Library library = TestFactory.eINSTANCE.createLibrary();
658: final Writer writer = TestFactory.eINSTANCE.createWriter();
659: library.getWriters().add(writer);
660:
661: final VView view = VViewFactory.eINSTANCE.createView();
662:
663: ViewModelContextFactory.INSTANCE.createViewModelContext(view, library);
664:
665: final VTableControl control = VTableFactory.eINSTANCE.createTableControl();
666: control.setDomainModelReference(
667: getVTableDomainModelReference(TestPackage.eINSTANCE.getLibrary_Writers()));
668: final VFeaturePathDomainModelReference tc = VViewFactory.eINSTANCE.createFeaturePathDomainModelReference();
669: tc.setDomainModelEFeature(TestPackage.eINSTANCE.getWriter_FirstName());
670: VTableDomainModelReference.class.cast(control.getDomainModelReference()).getColumnDomainModelReferences()
671: .add(tc);
672:
673: final VVerticalLayout column = VVerticalFactory.eINSTANCE.createVerticalLayout();
674: column.getChildren().add(control);
675: view.getChildren().add(column);
676:
677: assertEquals("Severity of table must be error", Diagnostic.ERROR, control.getDiagnostic()
678: .getHighestSeverity());
679: assertEquals("Severity of column must be error", Diagnostic.ERROR, column.getDiagnostic()
680: .getHighestSeverity());
681: assertEquals("Severity of view must be error", Diagnostic.ERROR, view.getDiagnostic()
682: .getHighestSeverity());
683:
684: writer.setFirstName("hello!");
685:
686: assertEquals("Severity of table must be ok", Diagnostic.OK, control.getDiagnostic()
687: .getHighestSeverity());
688: assertEquals("Severity of column must be ok", Diagnostic.OK, column.getDiagnostic()
689: .getHighestSeverity());
690: assertEquals("Severity of view must be ok", Diagnostic.OK, view.getDiagnostic()
691: .getHighestSeverity());
692: }
693:
694: @Test
695: public void testValidationTableControl() {
696: final Library lib = TestFactory.eINSTANCE.createLibrary();
697: lib.setName("bla");
698:
699: final VView view = VViewFactory.eINSTANCE.createView();
700: final VTableControl control = VTableFactory.eINSTANCE.createTableControl();
701: view.getChildren().add(control);
702: control
703: .setDomainModelReference(
704: getVTableDomainModelReference(TestPackage.eINSTANCE.getLibrary_Writers()));
705:
706: ViewModelContextFactory.INSTANCE.createViewModelContext(view, lib);
707:
708: assertEquals("Severity of table must be error", Diagnostic.ERROR, control.getDiagnostic().getHighestSeverity());
709: }
710:
711: @Test
712: public void testValidationTableControlChildren() {
713: final Library lib = TestFactory.eINSTANCE.createLibrary();
714: lib.setName("bla");
715: final Writer writer = TestFactory.eINSTANCE.createWriter();
716: lib.getWriters().add(writer);
717:
718: final VView view = VViewFactory.eINSTANCE.createView();
719: final VTableControl control = VTableFactory.eINSTANCE.createTableControl();
720: view.getChildren().add(control);
721: control
722: .setDomainModelReference(
723: getVTableDomainModelReference(TestPackage.eINSTANCE.getLibrary_Writers()));
724: final VFeaturePathDomainModelReference tc = VViewFactory.eINSTANCE.createFeaturePathDomainModelReference();
725: tc.setDomainModelEFeature(TestPackage.eINSTANCE.getWriter_FirstName());
726: VTableDomainModelReference.class.cast(control.getDomainModelReference()).getColumnDomainModelReferences()
727: .add(tc);
728:
729: ViewModelContextFactory.INSTANCE.createViewModelContext(view, lib);
730:
731: assertEquals("Severity of table must be error", Diagnostic.ERROR, control.getDiagnostic().getHighestSeverity());
732: }
733:
734: @Test
735: public void testValidationTableControlChildrenTwoEntries() {
736: final Library lib = TestFactory.eINSTANCE.createLibrary();
737: lib.setName("bla");
738: final Writer writer = TestFactory.eINSTANCE.createWriter();
739: lib.getWriters().add(writer);
740: final Writer writer2 = TestFactory.eINSTANCE.createWriter();
741: writer2.setFirstName("bla");
742: lib.getWriters().add(writer2);
743:
744: final VTableControl control = VTableFactory.eINSTANCE.createTableControl();
745: control
746: .setDomainModelReference(
747: getVTableDomainModelReference(TestPackage.eINSTANCE.getLibrary_Writers()));
748: final VFeaturePathDomainModelReference tc = VViewFactory.eINSTANCE.createFeaturePathDomainModelReference();
749: tc.setDomainModelEFeature(TestPackage.eINSTANCE.getWriter_FirstName());
750: VTableDomainModelReference.class.cast(control.getDomainModelReference()).getColumnDomainModelReferences()
751: .add(tc);
752:
753: ViewModelContextFactory.INSTANCE.createViewModelContext(control, lib);
754:
755: assertEquals("Severity of table must be error", Diagnostic.ERROR, control.getDiagnostic().getHighestSeverity());
756: }
757:
758: @Test
759: public void testValidationTableControlChildrenUpdateExisting() {
760: final Library lib = TestFactory.eINSTANCE.createLibrary();
761: lib.setName("bla");
762: final Writer writer = TestFactory.eINSTANCE.createWriter();
763: lib.getWriters().add(writer);
764:
765: final VTableControl control = VTableFactory.eINSTANCE.createTableControl();
766: control
767: .setDomainModelReference(
768: getVTableDomainModelReference(TestPackage.eINSTANCE.getLibrary_Writers()));
769: final VFeaturePathDomainModelReference tc = VViewFactory.eINSTANCE.createFeaturePathDomainModelReference();
770: tc.setDomainModelEFeature(TestPackage.eINSTANCE.getWriter_FirstName());
771: VTableDomainModelReference.class.cast(control.getDomainModelReference()).getColumnDomainModelReferences()
772: .add(tc);
773:
774: ViewModelContextFactory.INSTANCE.createViewModelContext(control, lib);
775:
776: writer.setFirstName("bla");
777: assertEquals("Severity of table must be ok", Diagnostic.OK, control.getDiagnostic().getHighestSeverity());
778: }
779:
780: @Ignore
781: @Test
782: public void testValidationTableControlChildrenUpdateExistingTwoEntries() {
783: final Library lib = TestFactory.eINSTANCE.createLibrary();
784: lib.setName("bla");
785: final Writer writer = TestFactory.eINSTANCE.createWriter();
786: lib.getWriters().add(writer);
787: final Writer writer2 = TestFactory.eINSTANCE.createWriter();
788: lib.getWriters().add(writer2);
789:
790: final VTableControl control = VTableFactory.eINSTANCE.createTableControl();
791: control
792: .setDomainModelReference(
793: getVFeaturePathDomainModelReference(TestPackage.eINSTANCE.getLibrary_Writers()));
794: final VFeaturePathDomainModelReference tc = VViewFactory.eINSTANCE.createFeaturePathDomainModelReference();
795: tc.setDomainModelEFeature(TestPackage.eINSTANCE.getWriter_FirstName());
796: VTableDomainModelReference.class.cast(control.getDomainModelReference()).getColumnDomainModelReferences()
797: .add(tc);
798:
799: ViewModelContextFactory.INSTANCE.createViewModelContext(control, lib);
800: assertEquals("Severity of table must be error", Diagnostic.ERROR, control.getDiagnostic().getHighestSeverity());
801: writer2.setFirstName("bla");
802: assertEquals("Severity of table must be error", Diagnostic.ERROR, control.getDiagnostic().getHighestSeverity());
803: writer.setFirstName("bla");
804: assertEquals("Severity of table must be ok", Diagnostic.OK, control.getDiagnostic().getHighestSeverity());
805: }
806:
807: @Test
808: public void testValidationTableControlChildrenAddNew() {
809: final Library lib = TestFactory.eINSTANCE.createLibrary();
810: lib.setName("bla");
811: final Writer writer = TestFactory.eINSTANCE.createWriter();
812: lib.getWriters().add(writer);
813: writer.setFirstName("bla");
814:
815: final VView view = VViewFactory.eINSTANCE.createView();
816:
817: final VTableControl control = VTableFactory.eINSTANCE.createTableControl();
818: view.getChildren().add(control);
819: control
820: .setDomainModelReference(
821: getVTableDomainModelReference(TestPackage.eINSTANCE.getLibrary_Writers()));
822: final VFeaturePathDomainModelReference tc = VViewFactory.eINSTANCE.createFeaturePathDomainModelReference();
823: tc.setDomainModelEFeature(TestPackage.eINSTANCE.getWriter_FirstName());
824: VTableDomainModelReference.class.cast(control.getDomainModelReference()).getColumnDomainModelReferences()
825: .add(tc);
826:
827: ViewModelContextFactory.INSTANCE.createViewModelContext(view, lib);
828: assertEquals("Severity of table must be OK", Diagnostic.OK, control.getDiagnostic().getHighestSeverity());
829:
830: final Writer writer2 = TestFactory.eINSTANCE.createWriter();
831: lib.getWriters().add(writer2);
832: assertEquals("Severity of table must be error", Diagnostic.ERROR, control.getDiagnostic().getHighestSeverity());
833: }
834:
835: @Test
836: public void testValidationTableControlChildrenAddNewWithoutError() {
837: final Library lib = TestFactory.eINSTANCE.createLibrary();
838: lib.setName("bla");
839: final Writer writer = TestFactory.eINSTANCE.createWriter();
840: lib.getWriters().add(writer);
841:
842: final VTableControl control = VTableFactory.eINSTANCE.createTableControl();
843: control
844: .setDomainModelReference(
845: getVTableDomainModelReference(TestPackage.eINSTANCE.getLibrary_Writers()));
846: final VFeaturePathDomainModelReference tc = VViewFactory.eINSTANCE.createFeaturePathDomainModelReference();
847: tc.setDomainModelEFeature(TestPackage.eINSTANCE.getWriter_FirstName());
848: VTableDomainModelReference.class.cast(control.getDomainModelReference()).getColumnDomainModelReferences()
849: .add(tc);
850:
851: ViewModelContextFactory.INSTANCE.createViewModelContext(control, lib);
852: assertEquals("Severity of table must be error", Diagnostic.ERROR, control.getDiagnostic().getHighestSeverity());
853:
854: final Writer writer2 = TestFactory.eINSTANCE.createWriter();
855: writer2.setFirstName("bla");
856: lib.getWriters().add(writer2);
857: assertEquals("Severity of table must be error", Diagnostic.ERROR, control.getDiagnostic().getHighestSeverity());
858: }
859:
860: @Test
861: public void testValidationTableControlChildrenRemoveAdded() {
862: final Library lib = TestFactory.eINSTANCE.createLibrary();
863: lib.setName("bla");
864: final Writer writer = TestFactory.eINSTANCE.createWriter();
865: writer.setFirstName("H");
866: lib.getWriters().add(writer);
867:
868: final VView view = VViewFactory.eINSTANCE.createView();
869:
870: final VTableControl control = VTableFactory.eINSTANCE.createTableControl();
871: view.getChildren().add(control);
872: control
873: .setDomainModelReference(
874: getVTableDomainModelReference(TestPackage.eINSTANCE.getLibrary_Writers()));
875: final VFeaturePathDomainModelReference tc = VViewFactory.eINSTANCE.createFeaturePathDomainModelReference();
876: tc.setDomainModelEFeature(TestPackage.eINSTANCE.getWriter_FirstName());
877: VTableDomainModelReference.class.cast(control.getDomainModelReference()).getColumnDomainModelReferences()
878: .add(tc);
879:
880: ViewModelContextFactory.INSTANCE.createViewModelContext(view, lib);
881:
882: assertEquals("Severity of table must be warning", Diagnostic.WARNING, control.getDiagnostic()
883: .getHighestSeverity());
884:
885: final Writer writer2 = TestFactory.eINSTANCE.createWriter();
886: lib.getWriters().add(writer2);
887:
888: assertEquals("Severity of table must be error", Diagnostic.ERROR, control.getDiagnostic().getHighestSeverity());
889:
890: lib.getWriters().remove(writer2);
891:
892: assertEquals("Severity of table must be warning", Diagnostic.WARNING, control.getDiagnostic()
893: .getHighestSeverity());
894: }
895:
896: @Test
897: public void testValidationTableControlChildrenPropagation() {
898: final Library lib = TestFactory.eINSTANCE.createLibrary();
899: lib.setName("bla");
900: final Writer writer = TestFactory.eINSTANCE.createWriter();
901: lib.getWriters().add(writer);
902: final Writer writer2 = TestFactory.eINSTANCE.createWriter();
903: writer2.setFirstName("bla");
904: lib.getWriters().add(writer2);
905:
906: final VTableControl control = VTableFactory.eINSTANCE.createTableControl();
907: control.setDomainModelReference(
908: getVTableDomainModelReference(TestPackage.eINSTANCE.getLibrary_Writers()));
909: final VFeaturePathDomainModelReference tc = VViewFactory.eINSTANCE.createFeaturePathDomainModelReference();
910: tc.setDomainModelEFeature(TestPackage.eINSTANCE.getWriter_FirstName());
911: VTableDomainModelReference.class.cast(control.getDomainModelReference()).getColumnDomainModelReferences()
912: .add(tc);
913: final VView view = VViewFactory.eINSTANCE.createView();
914: view.getChildren().add(control);
915:
916: ViewModelContextFactory.INSTANCE.createViewModelContext(view, lib);
917:
918: assertEquals("Severity of table must be error", Diagnostic.ERROR, control.getDiagnostic().getHighestSeverity());
919: assertEquals("Severity of view must be error", Diagnostic.ERROR, view.getDiagnostic().getHighestSeverity());
920: }
921:
922: @Test
923: public void testValidationChildHasMoreSevereValidationPropagation() {
924: final Library lib = TestFactory.eINSTANCE.createLibrary();
925: lib.setName("warning");
926: final Writer writer = TestFactory.eINSTANCE.createWriter();
927: final Writer validWriter = TestFactory.eINSTANCE.createWriter();
928: validWriter.setFirstName("hello");
929: lib.getWriters().add(writer);
930: lib.getWriters().add(validWriter);
931:
932: final VTableControl control = VTableFactory.eINSTANCE.createTableControl();
933: control.setDomainModelReference(
934: getVTableDomainModelReference(TestPackage.eINSTANCE.getLibrary_Writers()));
935: final VFeaturePathDomainModelReference tc = VViewFactory.eINSTANCE.createFeaturePathDomainModelReference();
936: tc.setDomainModelEFeature(TestPackage.eINSTANCE.getWriter_FirstName());
937: VTableDomainModelReference.class.cast(control.getDomainModelReference()).getColumnDomainModelReferences()
938: .add(tc);
939: final VView view = VViewFactory.eINSTANCE.createView();
940: view.getChildren().add(control);
941:
942: ViewModelContextFactory.INSTANCE.createViewModelContext(view, lib);
943:
944: assertEquals("Severity of table must be error", Diagnostic.ERROR, control.getDiagnostic().getHighestSeverity());
945: assertEquals("Severity of view must be error", Diagnostic.ERROR, view.getDiagnostic().getHighestSeverity());
946:
947: lib.getWriters().remove(writer);
948:
949: // library name does not influence validation result
950: assertEquals("Severity of table must be ok", Diagnostic.OK, control.getDiagnostic()
951: .getHighestSeverity());
952: assertEquals("Severity of view must be ok", Diagnostic.OK, view.getDiagnostic().getHighestSeverity());
953: }
954:
955: @Test
956: public void testValidationNotReferencedAttributesAreIgnored() {
957: final Library lib = TestFactory.eINSTANCE.createLibrary();
958: lib.setName("warning");
959: final Writer validWriter = TestFactory.eINSTANCE.createWriter();
960: validWriter.setFirstName("hello");
961: lib.getWriters().add(validWriter);
962:
963: final VTableControl control = VTableFactory.eINSTANCE.createTableControl();
964: control.setDomainModelReference(
965: getVTableDomainModelReference(TestPackage.eINSTANCE.getLibrary_Writers()));
966: final VFeaturePathDomainModelReference tc = VViewFactory.eINSTANCE.createFeaturePathDomainModelReference();
967: tc.setDomainModelEFeature(TestPackage.eINSTANCE.getWriter_FirstName());
968: VTableDomainModelReference.class.cast(control.getDomainModelReference()).getColumnDomainModelReferences()
969: .add(tc);
970: final VView view = VViewFactory.eINSTANCE.createView();
971: view.getChildren().add(control);
972:
973: ViewModelContextFactory.INSTANCE.createViewModelContext(view, lib);
974: // library name does not influence validation result
975: assertEquals("Severity of table must be ok", Diagnostic.OK, control.getDiagnostic()
976: .getHighestSeverity());
977: assertEquals("Severity of view must be ok", Diagnostic.OK, view.getDiagnostic().getHighestSeverity());
978: }
979:
980: @Test
981: public void testValidationTableControlChildrenPropagationErrorToOk() {
982: final Library lib = TestFactory.eINSTANCE.createLibrary();
983: lib.setName("bla");
984: final Writer writer = TestFactory.eINSTANCE.createWriter();
985: lib.getWriters().add(writer);
986: final Writer writer2 = TestFactory.eINSTANCE.createWriter();
987: writer2.setFirstName("bla");
988: lib.getWriters().add(writer2);
989:
990: final VTableControl control = VTableFactory.eINSTANCE.createTableControl();
991: control.setDomainModelReference(
992: getVTableDomainModelReference(TestPackage.eINSTANCE.getLibrary_Writers()));
993: final VFeaturePathDomainModelReference tc = VViewFactory.eINSTANCE.createFeaturePathDomainModelReference();
994: tc.setDomainModelEFeature(TestPackage.eINSTANCE.getWriter_FirstName());
995: VTableDomainModelReference.class.cast(control.getDomainModelReference()).getColumnDomainModelReferences()
996: .add(tc);
997: final VView view = VViewFactory.eINSTANCE.createView();
998: view.getChildren().add(control);
999:
1000: ViewModelContextFactory.INSTANCE.createViewModelContext(view, lib);
1001:
1002: writer.setFirstName("foo");
1003:
1004: assertEquals("Severity of table must be ok", Diagnostic.OK, control.getDiagnostic().getHighestSeverity());
1005: assertEquals("Severity of view must be ok", Diagnostic.OK, view.getDiagnostic().getHighestSeverity());
1006: }
1007:
1008: @Test
1009: public void testValidationTableControlChildrenPropagationErrorToOkByRemove() {
1010: final Library lib = TestFactory.eINSTANCE.createLibrary();
1011: lib.setName("bla");
1012: final Writer writer = TestFactory.eINSTANCE.createWriter();
1013: lib.getWriters().add(writer);
1014: final Writer writer2 = TestFactory.eINSTANCE.createWriter();
1015: writer2.setFirstName("bla");
1016: lib.getWriters().add(writer2);
1017:
1018: final VTableControl control = VTableFactory.eINSTANCE.createTableControl();
1019: control.setDomainModelReference(
1020: getVTableDomainModelReference(TestPackage.eINSTANCE.getLibrary_Writers()));
1021: final VFeaturePathDomainModelReference tc = VViewFactory.eINSTANCE.createFeaturePathDomainModelReference();
1022: tc.setDomainModelEFeature(TestPackage.eINSTANCE.getWriter_FirstName());
1023: VTableDomainModelReference.class.cast(control.getDomainModelReference()).getColumnDomainModelReferences()
1024: .add(tc);
1025: final VView view = VViewFactory.eINSTANCE.createView();
1026: view.getChildren().add(control);
1027:
1028: ViewModelContextFactory.INSTANCE.createViewModelContext(view, lib);
1029:
1030: lib.getWriters().remove(writer);
1031:
1032: assertEquals("Severity of table must be ok", Diagnostic.OK, control.getDiagnostic().getHighestSeverity());
1033: assertEquals("Severity of view must be ok", Diagnostic.OK, view.getDiagnostic().getHighestSeverity());
1034: }
1035:
1036: @Test
1037: public void testValidationTableControlParentReferencingEntityNotValid() {
1038: final Writer writer = TestFactory.eINSTANCE.createWriter();
1039: final Library lib = TestFactory.eINSTANCE.createLibrary();
1040: lib.getWriters().add(writer);
1041: writer.setFirstName("bar");
1042: writer.setLastName("foo"); // error
1043:
1044: final VTableControl control = VTableFactory.eINSTANCE.createTableControl();
1045: control.setDomainModelReference(
1046: getVTableDomainModelReference(TestPackage.eINSTANCE.getLibrary_Writers()));
1047: final VFeaturePathDomainModelReference tc = VViewFactory.eINSTANCE.createFeaturePathDomainModelReference();
1048: tc.setDomainModelEFeature(TestPackage.eINSTANCE.getWriter_FirstName());
1049: VTableDomainModelReference.class.cast(control.getDomainModelReference()).getColumnDomainModelReferences()
1050: .add(tc);
1051: final VView view = VViewFactory.eINSTANCE.createView();
1052: view.getChildren().add(control);
1053:
1054: ViewModelContextFactory.INSTANCE.createViewModelContext(view, lib);
1055:
1056: assertEquals("Severity of table must be ok", Diagnostic.OK, control.getDiagnostic().getHighestSeverity());
1057: assertEquals("Severity of view must be ok", Diagnostic.OK, view.getDiagnostic().getHighestSeverity());
1058:
1059: writer.setFirstName("");
1060: assertEquals("Severity of table must be error", Diagnostic.ERROR, control.getDiagnostic().getHighestSeverity());
1061: assertEquals("Severity of view must be error", Diagnostic.ERROR, view.getDiagnostic().getHighestSeverity());
1062:
1063: }
1064:
1065: @Test
1066: public void testValidationTableControlAggregation() {
1067: final VView view = VViewFactory.eINSTANCE.createView();
1068: final Library lib = TestFactory.eINSTANCE.createLibrary();
1069: final Writer writer = TestFactory.eINSTANCE.createWriter();
1070: final Writer writer2 = TestFactory.eINSTANCE.createWriter();
1071: final Writer writer3 = TestFactory.eINSTANCE.createWriter();
1072:
1073: lib.setName("bla");
1074: lib.getWriters().add(writer);
1075: lib.getWriters().add(writer2);
1076: lib.getWriters().add(writer3);
1077: writer3.setFirstName("bla");
1078:
1079: final VTableControl control1 = VTableFactory.eINSTANCE.createTableControl();
1080: control1.setName("firstNameTable");
1081: control1.setDomainModelReference(
1082: getVTableDomainModelReference(TestPackage.eINSTANCE.getLibrary_Writers()));
1083: final VFeaturePathDomainModelReference tc1 = VViewFactory.eINSTANCE.createFeaturePathDomainModelReference();
1084: tc1.setDomainModelEFeature(TestPackage.eINSTANCE.getWriter_FirstName());
1085: VTableDomainModelReference.class.cast(control1.getDomainModelReference()).getColumnDomainModelReferences()
1086: .add(tc1);
1087:
1088: final VTableControl control2 = VTableFactory.eINSTANCE.createTableControl();
1089: control2.setName("lastNameTable");
1090: control2.setDomainModelReference(
1091: getVTableDomainModelReference(TestPackage.eINSTANCE.getLibrary_Writers()));
1092: final VFeaturePathDomainModelReference tc2 = VViewFactory.eINSTANCE.createFeaturePathDomainModelReference();
1093: tc2.setDomainModelEFeature(TestPackage.eINSTANCE.getWriter_LastName());
1094: VTableDomainModelReference.class.cast(control2.getDomainModelReference()).getColumnDomainModelReferences()
1095: .add(tc2);
1096:
1097: view.getChildren().add(control1);
1098: view.getChildren().add(control2);
1099: ViewModelContextFactory.INSTANCE.createViewModelContext(view, lib);
1100:
1101: assertEquals("Severity of table must be error", Diagnostic.ERROR,
1102: control1.getDiagnostic().getHighestSeverity());
1103: assertEquals("Severity of table must be ok", Diagnostic.OK, control2.getDiagnostic().getHighestSeverity());
1104:
1105: lib.getWriters().remove(writer);
1106: lib.getWriters().remove(writer2);
1107:
1108: assertEquals("Severity of table must be ok", Diagnostic.OK, control1.getDiagnostic()
1109: .getHighestSeverity());
1110: }
1111:
1112: @Test
1113: public void testValidationTableControlMultipleDiagnosticsInitOk() {
1114: final VView view = VViewFactory.eINSTANCE.createView();
1115: final Container container = TestFactory.eINSTANCE.createContainer();
1116: final Content content1 = TestFactory.eINSTANCE.createContent();
1117: content1.setUniqueAttribute("a");
1118: container.getContents().add(content1);
1119: final Content content2 = TestFactory.eINSTANCE.createContent();
1120: content2.setUniqueAttribute("b");
1121: container.getContents().add(content2);
1122:
1123: final VTableControl control1 = VTableFactory.eINSTANCE.createTableControl();
1124: control1.setDomainModelReference(
1125: getVTableDomainModelReference(TestPackage.eINSTANCE.getContainer_Contents()));
1126: final VFeaturePathDomainModelReference tc1 = VViewFactory.eINSTANCE.createFeaturePathDomainModelReference();
1127: tc1.setDomainModelEFeature(TestPackage.eINSTANCE.getContent_UniqueAttribute());
1128: VTableDomainModelReference.class.cast(control1.getDomainModelReference()).getColumnDomainModelReferences()
1129: .add(tc1);
1130:
1131: view.getChildren().add(control1);
1132: ViewModelContextFactory.INSTANCE.createViewModelContext(view, container);
1133:
1134: assertEquals("Severity of table must be ok", Diagnostic.OK, control1.getDiagnostic().getHighestSeverity());
1135: assertEquals("There must be 0 diagnostics", 0, control1.getDiagnostic().getDiagnostics().size());
1136: }
1137:
1138: @Test
1139: public void testValidationTableControlMultipleDiagnosticsInitError() {
1140: final VView view = VViewFactory.eINSTANCE.createView();
1141: final Container container = TestFactory.eINSTANCE.createContainer();
1142: final Content content1 = TestFactory.eINSTANCE.createContent();
1143: content1.setUniqueAttribute("a");
1144: container.getContents().add(content1);
1145: final Content content2 = TestFactory.eINSTANCE.createContent();
1146: content2.setUniqueAttribute("a");
1147: container.getContents().add(content2);
1148:
1149: final VTableControl control1 = VTableFactory.eINSTANCE.createTableControl();
1150: control1.setDomainModelReference(
1151: getVTableDomainModelReference(TestPackage.eINSTANCE.getContainer_Contents()));
1152: final VFeaturePathDomainModelReference tc1 = VViewFactory.eINSTANCE.createFeaturePathDomainModelReference();
1153: tc1.setDomainModelEFeature(TestPackage.eINSTANCE.getContent_UniqueAttribute());
1154: VTableDomainModelReference.class.cast(control1.getDomainModelReference()).getColumnDomainModelReferences()
1155: .add(tc1);
1156:
1157: view.getChildren().add(control1);
1158: ViewModelContextFactory.INSTANCE.createViewModelContext(view, container);
1159:
1160: assertEquals("Severity of table must be error", Diagnostic.ERROR,
1161: control1.getDiagnostic().getHighestSeverity());
1162: // ok for container, 2x error for contents
1163: // assertEquals("There must be 3 diagnostics", 3, control1.getDiagnostic().getDiagnostics().size());
1164: }
1165:
1166: @Test
1167: public void testValidationTableControlMultipleDiagnosticsDynamicFirstOkToError() {
1168: final VView view = VViewFactory.eINSTANCE.createView();
1169: final Container container = TestFactory.eINSTANCE.createContainer();
1170: final Content content1 = TestFactory.eINSTANCE.createContent();
1171: content1.setUniqueAttribute("a");
1172: container.getContents().add(content1);
1173: final Content content2 = TestFactory.eINSTANCE.createContent();
1174: content2.setUniqueAttribute("b");
1175: container.getContents().add(content2);
1176:
1177: final VTableControl control1 = VTableFactory.eINSTANCE.createTableControl();
1178: control1.setDomainModelReference(
1179: getVTableDomainModelReference(TestPackage.eINSTANCE.getContainer_Contents()));
1180: final VFeaturePathDomainModelReference tc1 = VViewFactory.eINSTANCE.createFeaturePathDomainModelReference();
1181: tc1.setDomainModelEFeature(TestPackage.eINSTANCE.getContent_UniqueAttribute());
1182: VTableDomainModelReference.class.cast(control1.getDomainModelReference()).getColumnDomainModelReferences()
1183: .add(tc1);
1184:
1185: view.getChildren().add(control1);
1186: ViewModelContextFactory.INSTANCE.createViewModelContext(view, container);
1187:
1188: assertEquals("Severity of table must be ok", Diagnostic.OK, control1.getDiagnostic().getHighestSeverity());
1189: assertEquals("There must be 0 diagnostics", 0, control1.getDiagnostic().getDiagnostics().size());
1190:
1191: content1.setUniqueAttribute("b");
1192:
1193: assertEquals("Severity of table must be error", Diagnostic.ERROR,
1194: control1.getDiagnostic().getHighestSeverity());
1195: }
1196:
1197: @Test
1198: public void testValidationTableControlMultipleDiagnosticsDynamicSecondOkToError() {
1199: final VView view = VViewFactory.eINSTANCE.createView();
1200: final Container container = TestFactory.eINSTANCE.createContainer();
1201: final Content content1 = TestFactory.eINSTANCE.createContent();
1202: content1.setUniqueAttribute("a");
1203: container.getContents().add(content1);
1204: final Content content2 = TestFactory.eINSTANCE.createContent();
1205: content2.setUniqueAttribute("b");
1206: container.getContents().add(content2);
1207:
1208: final VTableControl control1 = VTableFactory.eINSTANCE.createTableControl();
1209: control1.setDomainModelReference(
1210: getVTableDomainModelReference(TestPackage.eINSTANCE.getContainer_Contents()));
1211: final VFeaturePathDomainModelReference tc1 = VViewFactory.eINSTANCE.createFeaturePathDomainModelReference();
1212: tc1.setDomainModelEFeature(TestPackage.eINSTANCE.getContent_UniqueAttribute());
1213: VTableDomainModelReference.class.cast(control1.getDomainModelReference()).getColumnDomainModelReferences()
1214: .add(tc1);
1215:
1216: view.getChildren().add(control1);
1217: ViewModelContextFactory.INSTANCE.createViewModelContext(view, container);
1218:
1219: assertEquals("Severity of table must be ok", Diagnostic.OK, control1.getDiagnostic().getHighestSeverity());
1220: assertEquals("There must be 0 diagnostics", 0, control1.getDiagnostic().getDiagnostics().size());
1221:
1222: content2.setUniqueAttribute("a");
1223:
1224: assertEquals("Severity of table must be error", Diagnostic.ERROR,
1225: control1.getDiagnostic().getHighestSeverity());
1226: }
1227:
1228: @Test
1229: public void testValidationTableControlMultipleDiagnosticsDynamicFirstErrorToOk() {
1230: final VView view = VViewFactory.eINSTANCE.createView();
1231: final Container container = TestFactory.eINSTANCE.createContainer();
1232: final Content content1 = TestFactory.eINSTANCE.createContent();
1233: content1.setUniqueAttribute("a");
1234: container.getContents().add(content1);
1235: final Content content2 = TestFactory.eINSTANCE.createContent();
1236: content2.setUniqueAttribute("a");
1237: container.getContents().add(content2);
1238:
1239: final VTableControl control1 = VTableFactory.eINSTANCE.createTableControl();
1240: control1.setDomainModelReference(
1241: getVTableDomainModelReference(TestPackage.eINSTANCE.getContainer_Contents()));
1242: final VFeaturePathDomainModelReference tc1 = VViewFactory.eINSTANCE.createFeaturePathDomainModelReference();
1243: tc1.setDomainModelEFeature(TestPackage.eINSTANCE.getContent_UniqueAttribute());
1244: VTableDomainModelReference.class.cast(control1.getDomainModelReference()).getColumnDomainModelReferences()
1245: .add(tc1);
1246:
1247: view.getChildren().add(control1);
1248: ViewModelContextFactory.INSTANCE.createViewModelContext(view, container);
1249:
1250: assertEquals("Severity of table must be error", Diagnostic.ERROR,
1251: control1.getDiagnostic().getHighestSeverity());
1252: // ok for container, 2x error for contents
1253: // assertEquals("There must be 3 diagnostics", 3, control1.getDiagnostic().getDiagnostics().size());
1254:
1255: content1.setUniqueAttribute("b");
1256:
1257: assertEquals("Severity of table must be ok", Diagnostic.OK, control1.getDiagnostic().getHighestSeverity());
1258: assertEquals("There must be 0 diagnostics", 0, control1.getDiagnostic().getDiagnostics().size());
1259: }
1260:
1261: @Test
1262: public void testValidationTableControlMultipleDiagnosticsDynamicSecondErrorToOk() {
1263: final VView view = VViewFactory.eINSTANCE.createView();
1264: final Container container = TestFactory.eINSTANCE.createContainer();
1265: final Content content1 = TestFactory.eINSTANCE.createContent();
1266: content1.setUniqueAttribute("a");
1267: container.getContents().add(content1);
1268: final Content content2 = TestFactory.eINSTANCE.createContent();
1269: content2.setUniqueAttribute("a");
1270: container.getContents().add(content2);
1271:
1272: final VTableControl control1 = VTableFactory.eINSTANCE.createTableControl();
1273: control1.setDomainModelReference(
1274: getVTableDomainModelReference(TestPackage.eINSTANCE.getContainer_Contents()));
1275: final VFeaturePathDomainModelReference tc1 = VViewFactory.eINSTANCE.createFeaturePathDomainModelReference();
1276: tc1.setDomainModelEFeature(TestPackage.eINSTANCE.getContent_UniqueAttribute());
1277: VTableDomainModelReference.class.cast(control1.getDomainModelReference()).getColumnDomainModelReferences()
1278: .add(tc1);
1279:
1280: view.getChildren().add(control1);
1281: ViewModelContextFactory.INSTANCE.createViewModelContext(view, container);
1282:
1283: assertEquals("Severity of table must be error", Diagnostic.ERROR,
1284: control1.getDiagnostic().getHighestSeverity());
1285: // ok for container, 2x error for contents
1286: // assertEquals("There must be 3 diagnostics", 3, control1.getDiagnostic().getDiagnostics().size());
1287:
1288: content2.setUniqueAttribute("b");
1289:
1290: assertEquals("Severity of table must be ok", Diagnostic.OK, control1.getDiagnostic().getHighestSeverity());
1291: assertEquals("There must be 0 diagnostics", 0, control1.getDiagnostic().getDiagnostics().size());
1292: }
1293:
1294: @Test
1295: public void testValidationTableControlMultipleDiagnosticsMultipleDuplicatesInitError() {
1296: final VView view = VViewFactory.eINSTANCE.createView();
1297: final Container container = TestFactory.eINSTANCE.createContainer();
1298: final Content content1 = TestFactory.eINSTANCE.createContent();
1299: content1.setUniqueAttribute("a");
1300: container.getContents().add(content1);
1301: final Content content2 = TestFactory.eINSTANCE.createContent();
1302: content2.setUniqueAttribute("a");
1303: container.getContents().add(content2);
1304:
1305: final Content content3 = TestFactory.eINSTANCE.createContent();
1306: content3.setUniqueAttribute("b");
1307: container.getContents().add(content3);
1308: final Content content4 = TestFactory.eINSTANCE.createContent();
1309: content4.setUniqueAttribute("b");
1310: container.getContents().add(content4);
1311:
1312: final VTableControl control1 = VTableFactory.eINSTANCE.createTableControl();
1313: control1.setDomainModelReference(
1314: getVTableDomainModelReference(TestPackage.eINSTANCE.getContainer_Contents()));
1315: final VFeaturePathDomainModelReference tc1 = VViewFactory.eINSTANCE.createFeaturePathDomainModelReference();
1316: tc1.setDomainModelEFeature(TestPackage.eINSTANCE.getContent_UniqueAttribute());
1317: VTableDomainModelReference.class.cast(control1.getDomainModelReference()).getColumnDomainModelReferences()
1318: .add(tc1);
1319:
1320: view.getChildren().add(control1);
1321: ViewModelContextFactory.INSTANCE.createViewModelContext(view, container);
1322:
1323: assertEquals("Severity of table must be error", Diagnostic.ERROR,
1324: control1.getDiagnostic().getHighestSeverity());
1325: // ok for container, 4x error for contents
1326: // assertEquals("There must be 5 diagnostics", 5, control1.getDiagnostic().getDiagnostics().size());
1327: }
1328:
1329: @Test
1330: public void testValidationTableControlMultipleDiagnosticsMultipleDuplicatesDynamic4ErrorTo3Error() {
1331: final VView view = VViewFactory.eINSTANCE.createView();
1332: final Container container = TestFactory.eINSTANCE.createContainer();
1333: final Content content1 = TestFactory.eINSTANCE.createContent();
1334: content1.setUniqueAttribute("a");
1335: container.getContents().add(content1);
1336: final Content content2 = TestFactory.eINSTANCE.createContent();
1337: content2.setUniqueAttribute("a");
1338: container.getContents().add(content2);
1339:
1340: final Content content3 = TestFactory.eINSTANCE.createContent();
1341: content3.setUniqueAttribute("b");
1342: container.getContents().add(content3);
1343: final Content content4 = TestFactory.eINSTANCE.createContent();
1344: content4.setUniqueAttribute("b");
1345: container.getContents().add(content4);
1346:
1347: final VTableControl control1 = VTableFactory.eINSTANCE.createTableControl();
1348: control1.setDomainModelReference(
1349: getVTableDomainModelReference(TestPackage.eINSTANCE.getContainer_Contents()));
1350: final VFeaturePathDomainModelReference tc1 = VViewFactory.eINSTANCE.createFeaturePathDomainModelReference();
1351: tc1.setDomainModelEFeature(TestPackage.eINSTANCE.getContent_UniqueAttribute());
1352: VTableDomainModelReference.class.cast(control1.getDomainModelReference()).getColumnDomainModelReferences()
1353: .add(tc1);
1354:
1355: view.getChildren().add(control1);
1356: ViewModelContextFactory.INSTANCE.createViewModelContext(view, container);
1357:
1358: assertEquals("Severity of table must be error", Diagnostic.ERROR,
1359: control1.getDiagnostic().getHighestSeverity());
1360: // ok for container, 4x error for contents
1361: // assertEquals("There must be 5 diagnostics", 5, control1.getDiagnostic().getDiagnostics().size());
1362:
1363: content3.setUniqueAttribute("a");
1364:
1365: assertEquals("Severity of table must be error", Diagnostic.ERROR,
1366: control1.getDiagnostic().getHighestSeverity());
1367: // ok for container, 1x ok , 3x error for contents
1368: // assertEquals("There must be 5 diagnostics", 5, control1.getDiagnostic().getDiagnostics().size());
1369: }
1370:
1371: @Test
1372: public void testValidationTableControlMultipleDiagnosticsMultipleDuplicatesDynamic4ErrorTo2Error() {
1373: final VView view = VViewFactory.eINSTANCE.createView();
1374: final Container container = TestFactory.eINSTANCE.createContainer();
1375: final Content content1 = TestFactory.eINSTANCE.createContent();
1376: content1.setUniqueAttribute("a");
1377: container.getContents().add(content1);
1378: final Content content2 = TestFactory.eINSTANCE.createContent();
1379: content2.setUniqueAttribute("a");
1380: container.getContents().add(content2);
1381:
1382: final Content content3 = TestFactory.eINSTANCE.createContent();
1383: content3.setUniqueAttribute("b");
1384: container.getContents().add(content3);
1385: final Content content4 = TestFactory.eINSTANCE.createContent();
1386: content4.setUniqueAttribute("b");
1387: container.getContents().add(content4);
1388:
1389: final VTableControl control1 = VTableFactory.eINSTANCE.createTableControl();
1390: control1.setDomainModelReference(
1391: getVTableDomainModelReference(TestPackage.eINSTANCE.getContainer_Contents()));
1392: final VFeaturePathDomainModelReference tc1 = VViewFactory.eINSTANCE.createFeaturePathDomainModelReference();
1393: tc1.setDomainModelEFeature(TestPackage.eINSTANCE.getContent_UniqueAttribute());
1394: VTableDomainModelReference.class.cast(control1.getDomainModelReference()).getColumnDomainModelReferences()
1395: .add(tc1);
1396:
1397: view.getChildren().add(control1);
1398: ViewModelContextFactory.INSTANCE.createViewModelContext(view, container);
1399:
1400: assertEquals("Severity of table must be error", Diagnostic.ERROR,
1401: control1.getDiagnostic().getHighestSeverity());
1402: // ok for container, 4x error for contents
1403: // assertEquals("There must be 5 diagnostics", 5, control1.getDiagnostic().getDiagnostics().size());
1404:
1405: content3.setUniqueAttribute("c");
1406:
1407: assertEquals("Severity of table must be error", Diagnostic.ERROR,
1408: control1.getDiagnostic().getHighestSeverity());
1409: // ok for container,2x ok, 2x error for contents
1410: // assertEquals("There must be 4 diagnostics", 4, control1.getDiagnostic().getDiagnostics().size());
1411: }
1412:
1413: @Test
1414: public void testValidationTableControlTwoColumns() {
1415: final VView view = VViewFactory.eINSTANCE.createView();
1416: final Library lib = TestFactory.eINSTANCE.createLibrary();
1417: final Writer writer = TestFactory.eINSTANCE.createWriter();
1418:
1419: lib.setName("bla");
1420: lib.getWriters().add(writer);
1421:
1422: final VTableControl control1 = VTableFactory.eINSTANCE.createTableControl();
1423: control1.setDomainModelReference(
1424: getVTableDomainModelReference(TestPackage.eINSTANCE.getLibrary_Writers()));
1425: final VFeaturePathDomainModelReference tc1 = VViewFactory.eINSTANCE.createFeaturePathDomainModelReference();
1426: tc1.setDomainModelEFeature(TestPackage.eINSTANCE.getWriter_FirstName());
1427: final VFeaturePathDomainModelReference tc2 = VViewFactory.eINSTANCE.createFeaturePathDomainModelReference();
1428: tc2.setDomainModelEFeature(TestPackage.eINSTANCE.getWriter_LastName());
1429: VTableDomainModelReference.class.cast(control1.getDomainModelReference()).getColumnDomainModelReferences()
1430: .add(tc1);
1431: VTableDomainModelReference.class.cast(control1.getDomainModelReference()).getColumnDomainModelReferences()
1432: .add(tc2);
1433:
1434: view.getChildren().add(control1);
1435: ViewModelContextFactory.INSTANCE.createViewModelContext(view, lib);
1436:
1437: assertEquals("Severity of table must be error", Diagnostic.ERROR,
1438: control1.getDiagnostic().getHighestSeverity());
1439: assertEquals("Severity of table must be error", Diagnostic.ERROR, view.getDiagnostic().getHighestSeverity());
1440:
1441: writer.setFirstName("asdf");
1442:
1443: assertEquals("Severity of table must be ok", Diagnostic.OK, control1.getDiagnostic().getHighestSeverity());
1444: assertEquals("Severity of table must be ok", Diagnostic.OK, view.getDiagnostic().getHighestSeverity());
1445: }
1446:
1447: @Test
1448: public void testValidationTableControlChildrenRemoveEntry() {
1449: final Library lib = TestFactory.eINSTANCE.createLibrary();
1450: lib.setName("bla");
1451: final Writer writer = TestFactory.eINSTANCE.createWriter();
1452: lib.getWriters().add(writer);
1453:
1454: final Writer writer2 = TestFactory.eINSTANCE.createWriter();
1455: lib.getWriters().add(writer2);
1456: final Writer writer3 = TestFactory.eINSTANCE.createWriter();
1457: lib.getWriters().add(writer3);
1458: writer3.setFirstName("bla");
1459:
1460: final VTableControl control = VTableFactory.eINSTANCE.createTableControl();
1461: control
1462: .setDomainModelReference(
1463: getVTableDomainModelReference(TestPackage.eINSTANCE.getLibrary_Writers()));
1464: final VFeaturePathDomainModelReference tc = VViewFactory.eINSTANCE.createFeaturePathDomainModelReference();
1465: tc.setDomainModelEFeature(TestPackage.eINSTANCE.getWriter_FirstName());
1466: VTableDomainModelReference.class.cast(control.getDomainModelReference()).getColumnDomainModelReferences()
1467: .add(tc);
1468:
1469: ViewModelContextFactory.INSTANCE.createViewModelContext(control, lib);
1470:
1471: assertEquals("Severity of table must be error", Diagnostic.ERROR, control.getDiagnostic().getHighestSeverity());
1472:
1473: lib.getWriters().remove(writer);
1474:
1475: assertEquals("Severity of table must be error", Diagnostic.ERROR, control.getDiagnostic().getHighestSeverity());
1476:
1477: lib.getWriters().remove(writer2);
1478:
1479: assertEquals("Severity of table must be ok", Diagnostic.OK, control.getDiagnostic()
1480: .getHighestSeverity());
1481: }
1482:
1483: @Test
1484: public void testValidationNonDomainWithDomainLoseChild() {
1485: // domain
1486: final Library library = TestFactory.eINSTANCE.createLibrary();
1487: final Writer writer = TestFactory.eINSTANCE.createWriter();
1488: final Writer writer2 = TestFactory.eINSTANCE.createWriter();
1489:
1490: // non domain
1491: final VView view = VViewFactory.eINSTANCE.createView();
1492: final VTableControl tableControl = VTableFactory.eINSTANCE.createTableControl();
1493: tableControl.setDomainModelReference(
1494: getVTableDomainModelReference(TestPackage.eINSTANCE.getLibrary_Writers()));
1495: final VFeaturePathDomainModelReference tc = VViewFactory.eINSTANCE.createFeaturePathDomainModelReference();
1496: tc.setDomainModelEFeature(TestPackage.eINSTANCE.getWriter_FirstName());
1497: VTableDomainModelReference.class.cast(tableControl.getDomainModelReference()).getColumnDomainModelReferences()
1498: .add(tc);
1499: final VVerticalLayout column = VVerticalFactory.eINSTANCE.createVerticalLayout();
1500:
1501: column.getChildren().add(tableControl);
1502: view.getChildren().add(column);
1503:
1504: library.getWriters().add(writer);
1505: writer.setFirstName("aaa");
1506: library.getWriters().add(writer2);
1507:
1508: ViewModelContextFactory.INSTANCE.createViewModelContext(view, library);
1509:
1510: assertEquals("Severity of control must be error", Diagnostic.ERROR, tableControl.getDiagnostic()
1511: .getHighestSeverity());
1512: assertEquals("Severity of column must be error", Diagnostic.ERROR, column.getDiagnostic().getHighestSeverity());
1513: assertEquals("Severity of view must be error", Diagnostic.ERROR, view.getDiagnostic().getHighestSeverity());
1514:
1515: library.getWriters().remove(writer2);
1516:
1517: assertEquals("Severity of control must be ok", Diagnostic.OK,
1518: tableControl.getDiagnostic().getHighestSeverity());
1519: assertEquals("Severity of column must be OK", Diagnostic.OK, column.getDiagnostic().getHighestSeverity());
1520: assertEquals("Severity of view must be OK", Diagnostic.OK, view.getDiagnostic().getHighestSeverity());
1521: }
1522:
1523: @Test
1524: public void testValidationPropagation2LevelErrorToOkDomainObjectChanges() {
1525: final Library library = TestFactory.eINSTANCE.createLibrary();
1526: final Writer writer = TestFactory.eINSTANCE.createWriter();
1527: library.getWriters().add(writer);
1528:
1529: final VView view = VViewFactory.eINSTANCE.createView();
1530:
1531: final VTableControl tableControl = VTableFactory.eINSTANCE.createTableControl();
1532: tableControl.setDomainModelReference(getVTableDomainModelReference(TestPackage.eINSTANCE
1533: .getLibrary_Writers()));
1534: final VFeaturePathDomainModelReference tc = VViewFactory.eINSTANCE.createFeaturePathDomainModelReference();
1535: tc.setDomainModelEFeature(TestPackage.eINSTANCE.getWriter_FirstName());
1536: VTableDomainModelReference.class.cast(tableControl.getDomainModelReference()).getColumnDomainModelReferences()
1537: .add(tc);
1538: final VVerticalLayout column = VVerticalFactory.eINSTANCE.createVerticalLayout();
1539:
1540: column.getChildren().add(tableControl);
1541: view.getChildren().add(column);
1542:
1543: ViewModelContextFactory.INSTANCE.createViewModelContext(view, library);
1544:
1545: assertEquals("Severity of control must be error", Diagnostic.ERROR, tableControl.getDiagnostic()
1546: .getHighestSeverity());
1547: assertEquals("Severity of column must be error", Diagnostic.ERROR, column.getDiagnostic().getHighestSeverity());
1548: assertEquals("Severity of view must be error", Diagnostic.ERROR, view.getDiagnostic().getHighestSeverity());
1549:
1550: writer.setFirstName("hello");
1551:
1552: assertEquals("Severity of control must be ok", Diagnostic.OK, tableControl.getDiagnostic()
1553: .getHighestSeverity());
1554: assertEquals("Severity of column must be OK", Diagnostic.OK, column.getDiagnostic().getHighestSeverity());
1555: assertEquals("Severity of view must be OK", Diagnostic.OK, view.getDiagnostic().getHighestSeverity());
1556: }
1557:
1558: @Test
1559: public void testValidationDynamicAddManyToDomain() {
1560: // setup
1561: final Library library = TestFactory.eINSTANCE.createLibrary();
1562: final Writer writer = TestFactory.eINSTANCE.createWriter();
1563: writer.setFirstName("Name");
1564: library.getWriters().add(writer);
1565:
1566: final VView view = VViewFactory.eINSTANCE.createView();
1567: view.setRootEClass(TestPackage.eINSTANCE.getLibrary());
1568:
1569: final VTableControl tableControl = VTableFactory.eINSTANCE.createTableControl();
1570: tableControl.setDomainModelReference(getVTableDomainModelReference(TestPackage.eINSTANCE
1571: .getLibrary_Writers()));
1572: final VFeaturePathDomainModelReference tc = VViewFactory.eINSTANCE.createFeaturePathDomainModelReference();
1573: tc.setDomainModelEFeature(TestPackage.eINSTANCE.getWriter_FirstName());
1574: VTableDomainModelReference.class.cast(tableControl.getDomainModelReference()).getColumnDomainModelReferences()
1575: .add(tc);
1576: view.getChildren().add(tableControl);
1577:
1578: ViewModelContextFactory.INSTANCE.createViewModelContext(view, library);
1579:
1580: assertEquals("Severity of control must be ok", Diagnostic.OK, tableControl.getDiagnostic()
1581: .getHighestSeverity());
1582:
1583: // act
1584: final Writer writer2 = TestFactory.eINSTANCE.createWriter();
1585: final Writer writer3 = TestFactory.eINSTANCE.createWriter();
1586: writer3.setFirstName("H");
1587: final List<Writer> writers = new ArrayList<Writer>();
1588: writers.add(writer2);
1589: writers.add(writer3);
1590: library.getWriters().addAll(writers);
1591:
1592: // assert
1593: assertEquals("Severity of control must be Error", Diagnostic.ERROR, tableControl.getDiagnostic()
1594: .getHighestSeverity());
1595:
1596: }
1597:
1598: @Test
1599: public void testNonContainmentReferenceInitialValidationOK() {
1600: /* setup model */
1601: final Referencer referencer = TestFactory.eINSTANCE.createReferencer();
1602: final Computer computer = TestFactory.eINSTANCE.createComputer();
1603: referencer.setReferencedContent(computer);
1604: computer.setName("Raspberry Pi");
1605:
1606: /* setup view */
1607: final VView view = VViewFactory.eINSTANCE.createView();
1608: final VControl control = VViewFactory.eINSTANCE.createControl();
1609: view.getChildren().add(control);
1610: control.setDomainModelReference(TestPackage.eINSTANCE.getComputer_Name(),
1611: Collections.singleton(TestPackage.eINSTANCE.getReferencer_ReferencedContent()));
1612:
1613: /* act */
1614: ViewModelContextFactory.INSTANCE.createViewModelContext(view, referencer);
1615:
1616: /* assert */
1617: assertEquals("Severity of control must be ok", Diagnostic.OK, control.getDiagnostic().getHighestSeverity());
1618: }
1619:
1620: @Test
1621: public void testNonContainmentReferenceInitialValidationError() {
1622: /* setup model */
1623: final Referencer referencer = TestFactory.eINSTANCE.createReferencer();
1624: final Computer computer = TestFactory.eINSTANCE.createComputer();
1625: referencer.setReferencedContent(computer);
1626: computer.setName(null);
1627:
1628: /* setup view */
1629: final VView view = VViewFactory.eINSTANCE.createView();
1630: final VControl control = VViewFactory.eINSTANCE.createControl();
1631: view.getChildren().add(control);
1632: control.setDomainModelReference(TestPackage.eINSTANCE.getComputer_Name(),
1633: Collections.singleton(TestPackage.eINSTANCE.getReferencer_ReferencedContent()));
1634:
1635: /* act */
1636: ViewModelContextFactory.INSTANCE.createViewModelContext(view, referencer);
1637:
1638: /* assert */
1639: assertEquals("Severity of control must be error", Diagnostic.ERROR,
1640: control.getDiagnostic().getHighestSeverity());
1641: }
1642:
1643: @Test
1644: public void testNonContainmentReferenceValidationOnChangeOK() {
1645: /* setup model */
1646: final Referencer referencer = TestFactory.eINSTANCE.createReferencer();
1647: final Computer computer = TestFactory.eINSTANCE.createComputer();
1648: referencer.setReferencedContent(computer);
1649: computer.setName(null);
1650:
1651: /* setup view */
1652: final VView view = VViewFactory.eINSTANCE.createView();
1653: final VControl control = VViewFactory.eINSTANCE.createControl();
1654: view.getChildren().add(control);
1655: control.setDomainModelReference(TestPackage.eINSTANCE.getComputer_Name(),
1656: Collections.singleton(TestPackage.eINSTANCE.getReferencer_ReferencedContent()));
1657:
1658: /* setup validation service */
1659: final ViewModelContext context = ViewModelContextFactory.INSTANCE.createViewModelContext(view, referencer);
1660:
1661: /* act */
1662: computer.setName("Raspberry Pi");
1663: /*
1664: * auto revalidate does not work with our model, since we have a non-containment and made no adjustments to the
1665: * model impl. this _is_ expected
1666: */
1667: context.getService(ValidationService.class).validate(Collections.<EObject> singleton(computer));
1668:
1669: /* assert */
1670: assertEquals("Severity of control must be ok", Diagnostic.OK, control.getDiagnostic().getHighestSeverity());
1671: }
1672:
1673: @Test
1674: public void testNonContainmentReferenceValidationOnChangeError() {
1675: /* setup model */
1676: final Referencer referencer = TestFactory.eINSTANCE.createReferencer();
1677: final Computer computer = TestFactory.eINSTANCE.createComputer();
1678: referencer.setReferencedContent(computer);
1679: computer.setName("Raspberry Pi");
1680:
1681: /* setup view */
1682: final VView view = VViewFactory.eINSTANCE.createView();
1683: final VControl control = VViewFactory.eINSTANCE.createControl();
1684: view.getChildren().add(control);
1685: control.setDomainModelReference(TestPackage.eINSTANCE.getComputer_Name(),
1686: Collections.singleton(TestPackage.eINSTANCE.getReferencer_ReferencedContent()));
1687:
1688: /* setup validation service */
1689: final ViewModelContext context = ViewModelContextFactory.INSTANCE.createViewModelContext(view, referencer);
1690:
1691: /* act */
1692: computer.setName(null);
1693: /*
1694: * auto revalidate does not work with our model, since we have a non-containment and made no adjustments to the
1695: * model impl. this _is_ expected
1696: */
1697: context.getService(ValidationService.class).validate(Collections.<EObject> singleton(computer));
1698:
1699: /* assert */
1700: assertEquals("Severity of control must be error", Diagnostic.ERROR,
1701: control.getDiagnostic().getHighestSeverity());
1702: }
1703:
1704: @Test
1705: public void testRegisterListener() {
1706: final Writer writer = TestFactory.eINSTANCE.createWriter();
1707: final VControl control = VViewFactory.eINSTANCE.createControl();
1708: control
1709: .setDomainModelReference(
1710: getVFeaturePathDomainModelReference(TestPackage.eINSTANCE.getWriter_FirstName()));
1711: final ViewModelContext vmc = ViewModelContextFactory.INSTANCE.createViewModelContext(control, writer);
1712:
1713: final Set<Diagnostic> result = new LinkedHashSet<Diagnostic>();
1714:
1715: final ViewValidationListener listener = new ViewValidationListener() {
1716: @Override
1717: public void onNewValidation(Set<Diagnostic> validationResults) {
1718: result.addAll(validationResults);
1719: }
1720: };
1721:
1722: final ValidationService service = vmc.getService(ValidationService.class);
1723: service.registerValidationListener(listener);
1724:
1725: assertEquals("One Diagnostic expected", 1, result.size());
1726: assertEquals("Severity of control must be Error", Diagnostic.ERROR, result.iterator().next().getSeverity());
1727: }
1728:
1729: @Test
1730: public void testListenerUponChange() throws InterruptedException {
1731: final Writer writer = TestFactory.eINSTANCE.createWriter();
1732: final VControl control = VViewFactory.eINSTANCE.createControl();
1733: control
1734: .setDomainModelReference(
1735: getVFeaturePathDomainModelReference(TestPackage.eINSTANCE.getWriter_FirstName()));
1736:
1737: final ViewModelContext vmc = ViewModelContextFactory.INSTANCE.createViewModelContext(control, writer);
1738:
1739: final List<CountDownLatch> latch = new ArrayList<CountDownLatch>();
1740: latch.add(new CountDownLatch(1));
1741: final Set<Diagnostic> lastResult = new LinkedHashSet<Diagnostic>();
1742:
1743: final ViewValidationListener listener = new ViewValidationListener() {
1744: @Override
1745: public void onNewValidation(Set<Diagnostic> validationResults) {
1746: lastResult.clear();
1747: lastResult.addAll(validationResults);
1748: latch.get(0).countDown();
1749: }
1750: };
1751:
1752: final ValidationService service = vmc.getService(ValidationService.class);
1753: service.registerValidationListener(listener);
1754:
1755: latch.get(0).await(1, TimeUnit.SECONDS);
1756: assertEquals("One Diagnostic expected", 1, lastResult.size());
1757: latch.clear();
1758: latch.add(new CountDownLatch(1));
1759:
1760: writer.setFirstName("Hans");
1761: latch.get(0).await(1, TimeUnit.SECONDS);
1762: assertEquals("No Diagnostic expected since OK", 0, lastResult.size());
1763: latch.clear();
1764: latch.add(new CountDownLatch(1));
1765:
1766: writer.setFirstName("");
1767: latch.get(0).await(1, TimeUnit.SECONDS);
1768: assertEquals("One Diagnostic expected", 1, lastResult.size());
1769: assertEquals("Severity of control must be Error", Diagnostic.ERROR, lastResult.iterator().next().getSeverity());
1770: }
1771:
1772: @Test
1773: public void testIncrementalUpdateListener() throws InterruptedException {
1774: final Writer writer = TestFactory.eINSTANCE.createWriter();
1775: final VControl control = VViewFactory.eINSTANCE.createControl();
1776: control
1777: .setDomainModelReference(
1778: getVFeaturePathDomainModelReference(TestPackage.eINSTANCE.getWriter_FirstName()));
1779:
1780: final ViewModelContext vmc = ViewModelContextFactory.INSTANCE.createViewModelContext(control, writer);
1781:
1782: final BlockingQueue<Collection<Diagnostic>> update = new ArrayBlockingQueue<>(1);
1783:
1784: final ValidationUpdateListener listener = diagnostics -> {
1785: try {
1786: update.offer(diagnostics, 1L, TimeUnit.SECONDS);
1787: } catch (final InterruptedException e) {
1788: e.printStackTrace();
1789: fail("Interrupted");
1790: }
1791: };
1792:
1793: final ValidationService service = vmc.getService(ValidationService.class);
1794: ValidationUpdateListener.register(service, listener);
1795:
1796: // Initial validation
1797: service.validate(Collections.singleton(writer));
1798:
1799: Collection<Diagnostic> diagnostics = update.poll(1L, TimeUnit.SECONDS);
1800: assertThat("No error found", diagnostics, hasItem(isError()));
1801: assertThat("No OKs found", diagnostics, hasItem(isOK()));
1802:
1803: writer.setFirstName("Hans");
1804: diagnostics = update.poll(1L, TimeUnit.SECONDS);
1805: assertThat("Nothing reported", diagnostics.isEmpty(), is(false));
1806: assertThat("Previously reported problems not cleared", diagnostics, everyItem(isOK()));
1807:
1808: writer.setFirstName("");
1809: diagnostics = update.poll(1L, TimeUnit.SECONDS);
1810: assertThat("No error found", diagnostics, hasItem(isError()));
1811: assertThat("No OKs found", diagnostics, hasItem(isOK()));
1812: }
1813:
1814: @Test
1815: public void incrementalUpdateUnmodifiable() throws InterruptedException {
1816: final Writer writer = TestFactory.eINSTANCE.createWriter();
1817: final VControl control = VViewFactory.eINSTANCE.createControl();
1818: control
1819: .setDomainModelReference(
1820: getVFeaturePathDomainModelReference(TestPackage.eINSTANCE.getWriter_FirstName()));
1821:
1822: final ViewModelContext vmc = ViewModelContextFactory.INSTANCE.createViewModelContext(control, writer);
1823:
1824: final ValidationUpdateListener listener = diagnostics -> {
1825: try {
1826: final Iterator<?> iter = diagnostics.iterator();
1827: iter.next();
1828: iter.remove();
1829: fail("Should have thrown on attempt to remove from entry set");
1830: } catch (final UnsupportedOperationException e) {
1831: // Success
1832: }
1833: };
1834:
1835: final ValidationService service = vmc.getService(ValidationService.class);
1836: ValidationUpdateListener.register(service, listener);
1837:
1838: // validate
1839: service.validate(Collections.singleton(writer));
1840: }
1841:
1842: //
1843: // Nested types
1844: //
1845:
1846: /**
1847: * A global service that injects the validation problems propagation limit
1848: * into the view-model context.
1849: */
1850: static final class PropagationLimitService implements GlobalViewModelService {
1851: private final int limit;
1852:
1853: /**
1854: * Initializes me with the propagation limit.
1855: *
1856: * @param limit the propagation limit
1857: */
1858: PropagationLimitService(int limit) {
1859: super();
1860:
1861: this.limit = limit;
1862: }
1863:
1864: @Override
1865: public void instantiate(ViewModelContext context) {
1866: context.putContextValue(PROPAGATION_LIMIT_KEY, limit);
1867: }
1868:
1869: @Override
1870: public void dispose() {
1871: // Nothing to dispose
1872: }
1873:
1874: @Override
1875: public int getPriority() {
1876: return Integer.MIN_VALUE;
1877: }
1878:
1879: @Override
1880: public void childViewModelContextAdded(ViewModelContext childContext) {
1881: // Not interesting
1882: }
1883:
1884: //
1885: // Nested types
1886: //
1887:
1888: /**
1889: * Factory for the propagation-limit injection service.
1890: */
1891: static final class Factory implements EMFFormsViewServiceFactory<PropagationLimitService> {
1892:
1893: private final int limit;
1894:
1895: Factory(int limit) {
1896: super();
1897:
1898: this.limit = limit;
1899: }
1900:
1901: @Override
1902: public EMFFormsViewServicePolicy getPolicy() {
1903: return EMFFormsViewServicePolicy.IMMEDIATE;
1904: }
1905:
1906: @Override
1907: public EMFFormsViewServiceScope getScope() {
1908: return EMFFormsViewServiceScope.GLOBAL;
1909: }
1910:
1911: @Override
1912: public double getPriority() {
1913: // Don't use -∞ because that prevents registration of the factory!
1914: return Integer.MIN_VALUE;
1915: }
1916:
1917: @Override
1918: public Class<PropagationLimitService> getType() {
1919: return PropagationLimitService.class;
1920: }
1921:
1922: @Override
1923: public PropagationLimitService createService(EMFFormsViewContext emfFormsViewContext) {
1924: final PropagationLimitService result = new PropagationLimitService(limit);
1925:
1926: if (emfFormsViewContext instanceof ViewModelContext) {
1927: result.instantiate((ViewModelContext) emfFormsViewContext);
1928: }
1929:
1930: return result;
1931: }
1932:
1933: }
1934:
1935: }
1936:
1937: }