Skip to contentPackage: ValidationProvider_PTest$7
ValidationProvider_PTest$7
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 - bug 552715
14: ******************************************************************************/
15: package org.eclipse.emf.ecp.view.validation.test;
16:
17: import static org.hamcrest.CoreMatchers.notNullValue;
18: import static org.hamcrest.MatcherAssert.assertThat;
19: import static org.junit.Assert.assertEquals;
20: import static org.junit.Assert.assertTrue;
21:
22: import java.util.ArrayList;
23: import java.util.Collections;
24: import java.util.List;
25:
26: import org.eclipse.emf.common.util.BasicDiagnostic;
27: import org.eclipse.emf.common.util.Diagnostic;
28: import org.eclipse.emf.ecore.EObject;
29: import org.eclipse.emf.ecp.test.common.DefaultRealm;
30: import org.eclipse.emf.ecp.view.internal.validation.ValidationNotification;
31: import org.eclipse.emf.ecp.view.spi.context.ViewModelContext;
32: import org.eclipse.emf.ecp.view.spi.context.ViewModelContextFactory;
33: import org.eclipse.emf.ecp.view.spi.model.VControl;
34: import org.eclipse.emf.ecp.view.spi.model.VFeaturePathDomainModelReference;
35: import org.eclipse.emf.ecp.view.spi.model.VView;
36: import org.eclipse.emf.ecp.view.spi.model.VViewFactory;
37: import org.eclipse.emf.ecp.view.spi.validation.ValidationProvider;
38: import org.eclipse.emf.ecp.view.spi.validation.ValidationService;
39: import org.eclipse.emf.ecp.view.validation.test.model.Computer;
40: import org.eclipse.emf.ecp.view.validation.test.model.PowerBlock;
41: import org.eclipse.emf.ecp.view.validation.test.model.TestFactory;
42: import org.eclipse.emf.ecp.view.validation.test.model.TestPackage;
43: import org.junit.After;
44: import org.junit.Before;
45: import org.junit.Test;
46:
47: /**
48: * @author Eugen Neufeld
49: *
50: */
51: public class ValidationProvider_PTest {
52:
53: private DefaultRealm defaultRealm;
54:
55: private VControl control;
56: private Computer computer;
57: private ValidationService validationService;
58:
59: /**
60: * @throws java.lang.Exception
61: */
62: @Before
63: public void setUp() throws Exception {
64: defaultRealm = new DefaultRealm();
65: final VView view = VViewFactory.eINSTANCE.createView();
66: view.setRootEClass(TestPackage.eINSTANCE.getComputer());
67:
68: control = VViewFactory.eINSTANCE.createControl();
69:
70: final VFeaturePathDomainModelReference domainModelReference = VViewFactory.eINSTANCE
71: .createFeaturePathDomainModelReference();
72: domainModelReference.setDomainModelEFeature(TestPackage.eINSTANCE.getComputer_Name());
73: control.setDomainModelReference(domainModelReference);
74:
75: view.getChildren().add(control);
76:
77: computer = TestFactory.eINSTANCE.createComputer();
78: computer.setName("initial");
79: final PowerBlock powerBlock = TestFactory.eINSTANCE.createPowerBlock();
80: // powerBlock.setName("powerblock");
81: computer.setPowerBlock(powerBlock);
82: final ViewModelContext vmc = ViewModelContextFactory.INSTANCE.createViewModelContext(view, computer);
83: validationService = vmc.getService(ValidationService.class);
84:
85: }
86:
87: /**
88: * @throws java.lang.Exception
89: */
90: @After
91: public void tearDown() throws Exception {
92: defaultRealm.dispose();
93: }
94:
95: @Test
96: public void testValidationProviderIsCalled() {
97: final List<Boolean> called = new ArrayList<Boolean>(1);
98: called.add(false);
99: validationService.addValidationProvider(new ValidationProvider() {
100:
101: @Override
102: public List<Diagnostic> validate(EObject eObject) {
103: called.set(0, true);
104: return Collections.emptyList();
105: }
106: });
107:
108: assertTrue(called.get(0));
109: }
110:
111: @Test
112: public void testValidationProviderSeverityHigher() {
113: validationService.addValidationProvider(new ValidationProvider() {
114:
115: @Override
116: public List<Diagnostic> validate(EObject eObject) {
117: if (!Computer.class.isInstance(eObject)) {
118: return Collections.emptyList();
119: }
120: final Diagnostic diagnostic = new BasicDiagnostic(Diagnostic.WARNING, "bla", 0, "bl", new Object[] {
121: eObject, TestPackage.eINSTANCE.getComputer_Name() });
122: return Collections.singletonList(diagnostic);
123: }
124: });
125:
126: assertEquals(Diagnostic.WARNING, control.getDiagnostic().getHighestSeverity());
127: }
128:
129: @Test
130: public void testValidationProviderSeverityLower() {
131: validationService.addValidationProvider(new ValidationProvider() {
132:
133: @Override
134: public List<Diagnostic> validate(EObject eObject) {
135: if (!Computer.class.isInstance(eObject)) {
136: return Collections.emptyList();
137: }
138: final Diagnostic diagnostic = new BasicDiagnostic(Diagnostic.WARNING, "bla", 0, "bl", new Object[] {
139: eObject, TestPackage.eINSTANCE.getComputer_Name() });
140: return Collections.singletonList(diagnostic);
141: }
142: });
143: computer.setName(null);
144:
145: assertEquals(Diagnostic.ERROR, control.getDiagnostic().getHighestSeverity());
146: }
147:
148: @Test
149: public void testValidationProviderTriggerAdditionalValidation() {
150: final List<Integer> called = new ArrayList<Integer>(1);
151: called.add(0);
152: validationService.addValidationProvider(new ValidationProvider() {
153:
154: @Override
155: public List<Diagnostic> validate(EObject eObject) {
156: if (Computer.class.isInstance(eObject)) {
157: ((Computer) eObject).eNotify(new ValidationNotification(((Computer) eObject).getPowerBlock()));
158: final Diagnostic diagnostic = new BasicDiagnostic(Diagnostic.WARNING, "bla", 0, "bl", new Object[] {
159: eObject, TestPackage.eINSTANCE.getComputer_Name() });
160: return Collections.singletonList(diagnostic);
161: }
162: if (PowerBlock.class.isInstance(eObject)) {
163: called.set(0, called.get(0) + 1);
164: }
165: return Collections.emptyList();
166: }
167: });
168: computer.setName("test");
169: assertEquals(Diagnostic.WARNING, control.getDiagnostic().getHighestSeverity());
170: assertEquals((Integer) 2, called.get(0));
171: }
172:
173: @Test
174: public void testValidationProviderTriggerSelfValidation() {
175: final List<Integer> called = new ArrayList<Integer>(1);
176: called.add(0);
177: validationService.addValidationProvider(new ValidationProvider() {
178:
179: @Override
180: public List<Diagnostic> validate(EObject eObject) {
181: if (Computer.class.isInstance(eObject)) {
182:
183: eObject.eNotify(new ValidationNotification(eObject));
184: called.set(0, called.get(0) + 1);
185: }
186: return Collections.emptyList();
187: }
188: });
189: assertEquals((Integer) 1, called.get(0));
190: }
191:
192: @Test
193: public void testRemoveValidationProvider() {
194: // setup
195: final ValidationProvider validationProvider = new ValidationProvider() {
196: @Override
197: public List<Diagnostic> validate(EObject eObject) {
198: if (!Computer.class.isInstance(eObject)) {
199: return Collections.emptyList();
200: }
201: final Diagnostic diagnostic = new BasicDiagnostic(Diagnostic.WARNING, "bla", 0, "bl", new Object[] {
202: eObject, TestPackage.eINSTANCE.getComputer_Name() });
203: return Collections.singletonList(diagnostic);
204: }
205: };
206: validationService.addValidationProvider(validationProvider);
207: assertEquals(Diagnostic.WARNING, control.getDiagnostic().getHighestSeverity());
208:
209: // act
210: validationService.removeValidationProvider(validationProvider);
211: assertEquals(Diagnostic.OK, control.getDiagnostic().getHighestSeverity());
212: }
213:
214: @Test
215: public void testValidationProviderTriggerNoSelfValidation() {
216: final List<Integer> called = new ArrayList<Integer>(1);
217: called.add(0);
218: validationService.addValidationProvider(new ValidationProvider() {
219:
220: @Override
221: public List<Diagnostic> validate(EObject eObject) {
222:• if (Computer.class.isInstance(eObject)) {
223:
224: eObject.eNotify(new ValidationNotification(eObject));
225: called.set(0, called.get(0) + 1);
226: }
227: return Collections.emptyList();
228: }
229: }, false);
230: assertEquals((Integer) 0, called.get(0));
231: }
232:
233: @Test
234: public void testRemoveValidationProviderNoRevalidation() {
235: // setup
236: final ValidationProvider validationProvider = new ValidationProvider() {
237: @Override
238: public List<Diagnostic> validate(EObject eObject) {
239: if (!Computer.class.isInstance(eObject)) {
240: return Collections.emptyList();
241: }
242: final Diagnostic diagnostic = new BasicDiagnostic(Diagnostic.WARNING, "bla", 0, "bl", new Object[] {
243: eObject, TestPackage.eINSTANCE.getComputer_Name() });
244: return Collections.singletonList(diagnostic);
245: }
246: };
247: validationService.addValidationProvider(validationProvider);
248: assertEquals(Diagnostic.WARNING, control.getDiagnostic().getHighestSeverity());
249:
250: // act
251: validationService.removeValidationProvider(validationProvider, false);
252: /* no revalidation yet */
253: assertEquals(Diagnostic.WARNING, control.getDiagnostic().getHighestSeverity());
254: /* revalidate to see if provider was removed */
255: validationService.validate(Collections.singleton(EObject.class.cast(computer)));
256: assertEquals(Diagnostic.OK, control.getDiagnostic().getHighestSeverity());
257: }
258:
259: /**
260: * @see <a href="http://eclip.se/552715">bug 552715</a>
261: */
262: @Test
263: public void testValidationProviderInitializedWithContext() {
264: final ViewModelContext[] capturedContext = { null };
265:
266: validationService.addValidationProvider(new ValidationProvider() {
267:
268: @Override
269: public List<Diagnostic> validate(EObject eObject) {
270: return Collections.emptyList();
271: }
272:
273: @Override
274: public void setContext(ViewModelContext context) {
275: capturedContext[0] = context;
276: }
277: });
278:
279: assertThat("No view-model context captured", capturedContext[0], notNullValue());
280: }
281:
282: /**
283: * @see <a href="http://eclip.se/552715">bug 552715</a>
284: */
285: @Test
286: public void testValidationProviderDisposedWithContext() {
287: final ViewModelContext[] capturedContext = { null };
288:
289: final ValidationProvider provider = new ValidationProvider() {
290:
291: @Override
292: public List<Diagnostic> validate(EObject eObject) {
293: return Collections.emptyList();
294: }
295:
296: @Override
297: public void unsetContext(ViewModelContext context) {
298: capturedContext[0] = context;
299: }
300: };
301: validationService.addValidationProvider(provider);
302: validationService.removeValidationProvider(provider);
303:
304: assertThat("No view-model context captured", capturedContext[0], notNullValue());
305: }
306:
307: /**
308: * @see <a href="http://eclip.se/552715">bug 552715</a>
309: */
310: @Test
311: public void testValidationProviderInvokedWithContext() {
312: final ViewModelContext[] capturedContext = { null };
313:
314: final ValidationProvider provider = new ValidationProvider.ContextSensitive() {
315:
316: @Override
317: public Iterable<? extends Diagnostic> validate(ViewModelContext context, EObject object) {
318: capturedContext[0] = context;
319: return Collections.emptyList();
320: }
321: };
322:
323: validationService.addValidationProvider(provider);
324:
325: assertThat("No view-model context captured", capturedContext[0], notNullValue());
326: }
327:
328: }
![[Jenkins]](/ecp/static/e8bbdb94/images/svgs/logo.svg){kind=logo}
