Skip to contentPackage: Validation_PTest
Validation_PTest
Coverage
1: /*******************************************************************************
2: * Copyright (c) 2011-2013 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: * Johannes Faltermeier
14: *
15: *******************************************************************************/
16: package org.eclipse.emf.ecp.validation.test;
17:
18: import static org.junit.Assert.assertEquals;
19: import static org.junit.Assert.assertTrue;
20:
21: import java.util.HashSet;
22: import java.util.Set;
23:
24: import org.eclipse.emf.common.util.Diagnostic;
25: import org.eclipse.emf.ecore.EObject;
26: import org.eclipse.emf.ecp.core.ECPProject;
27: import org.eclipse.emf.ecp.core.exceptions.ECPProjectWithNameExistsException;
28: import org.eclipse.emf.ecp.core.util.ECPUtil;
29: import org.eclipse.emf.ecp.emfstore.core.internal.EMFStoreProvider;
30: import org.eclipse.emf.ecp.validation.api.IValidationService;
31: import org.eclipse.emf.ecp.validation.api.IValidationServiceProvider;
32: import org.eclipse.emf.ecp.validation.test.test.Library;
33: import org.eclipse.emf.ecp.validation.test.test.TestFactory;
34: import org.eclipse.emf.ecp.validation.test.test.TestPackage;
35: import org.eclipse.emf.ecp.validation.test.test.Writer;
36: import org.junit.After;
37: import org.junit.AfterClass;
38: import org.junit.Before;
39: import org.junit.BeforeClass;
40: import org.junit.Test;
41: import org.osgi.framework.BundleContext;
42: import org.osgi.framework.FrameworkUtil;
43: import org.osgi.framework.ServiceReference;
44:
45: @SuppressWarnings("restriction")
46: public class Validation_PTest {
47:
48: private static IValidationServiceProvider validationServiceProvider;
49:
50: @BeforeClass
51: public static void setUpBeforeClass() {
52:
53: final BundleContext bundleContext = FrameworkUtil.getBundle(Validation_PTest.class).getBundleContext();
54: final ServiceReference<?> eventServiceReference = bundleContext
55: .getServiceReference(IValidationServiceProvider.class
56: .getName());
57:• if (eventServiceReference != null) {
58: validationServiceProvider = (IValidationServiceProvider) bundleContext.getService(eventServiceReference);
59: }
60: }
61:
62: @AfterClass
63: public static void tearDownAfterClass() {
64: }
65:
66: @Before
67: public void setUp() throws Exception {
68: }
69:
70: @After
71: public void tearDown() throws Exception {
72: }
73:
74: @Test
75: public void testSingleObject() {
76:
77: final Writer writer = TestFactory.eINSTANCE.createWriter();
78: final IValidationService validationService = validationServiceProvider.getValidationService(writer);
79:
80: validationService.validate(writer);
81: final Diagnostic diagnostic = validationService.getDiagnostic(writer);
82: assertEquals(Diagnostic.ERROR, diagnostic.getSeverity());
83: assertEquals(1, diagnostic.getChildren().size());
84: assertEquals(2, diagnostic.getChildren().get(0).getData().size());
85: assertEquals(TestPackage.eINSTANCE.getWriter_FirstName(), diagnostic.getChildren().get(0).getData().get(1));
86: }
87:
88: @Test
89: public void testCorrectValidation() {
90: final Writer writer = TestFactory.eINSTANCE.createWriter();
91: final IValidationService validationService = validationServiceProvider.getValidationService(writer);
92: writer.setFirstName("Test");
93: validationService.validate(writer);
94: final Diagnostic diagnostic = validationService.getDiagnostic(writer);
95: assertEquals(Diagnostic.OK, diagnostic.getSeverity());
96: }
97:
98: @Test
99: public void testPropagation() {
100: final Library library = TestFactory.eINSTANCE.createLibrary();
101: final Writer writer = TestFactory.eINSTANCE.createWriter();
102: library.setName("TesLib");
103: library.getWriters().add(writer);
104:
105: final IValidationService validationService = validationServiceProvider.getValidationService(library);
106:
107: final Set<EObject> affectedElements = validationService.validate(writer);
108: assertEquals(1, affectedElements.size());
109:
110: final Diagnostic diagnosticWriter = validationService.getDiagnostic(writer);
111: assertEquals(Diagnostic.ERROR, diagnosticWriter.getSeverity());
112:
113: final Diagnostic diagnosticLib = validationService.getDiagnostic(library);
114: assertEquals(Diagnostic.ERROR, diagnosticLib.getSeverity());
115:
116: assertEquals(1, diagnosticLib.getChildren().size());
117: assertEquals(2, diagnosticLib.getChildren().get(0).getData().size());
118: assertEquals(TestPackage.eINSTANCE.getWriter_FirstName(), diagnosticLib.getChildren().get(0).getData().get(1));
119: }
120:
121: @Test
122: public void testMultipleObjects() {
123: final Writer writer1 = TestFactory.eINSTANCE.createWriter();
124: writer1.setFirstName("Hans");
125: final Writer writer2 = TestFactory.eINSTANCE.createWriter();
126: final Writer writer3 = TestFactory.eINSTANCE.createWriter();
127:
128: final Library lib = TestFactory.eINSTANCE.createLibrary();
129: lib.setName("Bücherei");
130: lib.getWriters().add(writer1);
131: lib.getWriters().add(writer2);
132: lib.getWriters().add(writer3);
133:
134: final Set<EObject> writers = new HashSet<EObject>();
135: writers.add(writer1);
136: writers.add(writer2);
137:
138: final IValidationService validationService = validationServiceProvider.getValidationService(lib);
139: validationService.validate(writers);
140:
141: final Diagnostic diagnosticW1 = validationService.getDiagnostic(writer1);
142: assertEquals(Diagnostic.OK, diagnosticW1.getSeverity());
143:
144: final Diagnostic diagnosticW2 = validationService.getDiagnostic(writer2);
145: assertEquals(Diagnostic.ERROR, diagnosticW2.getSeverity());
146: assertEquals(1, diagnosticW2.getChildren().size());
147: assertEquals(2, diagnosticW2.getChildren().get(0).getData().size());
148: assertEquals(TestPackage.eINSTANCE.getWriter_FirstName(), diagnosticW2.getChildren().get(0).getData().get(1));
149:
150: final Diagnostic diagnosticW3 = validationService.getDiagnostic(writer3);
151: // TODO add correct assert
152: // fail("When there is no (cached) value for a object you want to get a diagnostic for, "
153: // + "returning OK may not be the best idea?! Return CANCEL maybe? discuss");
154: assertEquals(Diagnostic.OK, diagnosticW3.getSeverity());
155: }
156:
157: @Test
158: public void testRootDiagnostic() {
159: final Writer writer1 = TestFactory.eINSTANCE.createWriter();
160: final Writer writer2 = TestFactory.eINSTANCE.createWriter();
161: writer2.setFirstName("Hans");
162: final Library library = TestFactory.eINSTANCE.createLibrary();
163: library.setName("Bücherei");
164: library.getWriters().add(writer1);
165: library.getWriters().add(writer2);
166:
167: final Set<EObject> collection = new HashSet<EObject>();
168: collection.add(library);
169: collection.add(writer1);
170: collection.add(writer2);
171:
172: final IValidationService validationService = validationServiceProvider.getValidationService(library);
173: validationService.validate(collection);
174:
175: Diagnostic diagnostic = validationService.getRootDiagnostic();
176: assertEquals(Diagnostic.ERROR, diagnostic.getSeverity());
177:
178: writer1.setFirstName("Sepp");
179: validationService.validate(collection);
180: diagnostic = validationService.getRootDiagnostic();
181: assertEquals(Diagnostic.OK, diagnostic.getSeverity());
182:
183: // warning when firstname is same as lastname
184: writer1.setLastName("Sepp");
185: validationService.validate(collection);
186: diagnostic = validationService.getRootDiagnostic();
187: assertEquals(Diagnostic.WARNING, diagnostic.getSeverity());
188:
189: writer2.setFirstName("");
190: validationService.validate(collection);
191: diagnostic = validationService.getRootDiagnostic();
192: assertEquals(Diagnostic.ERROR, diagnostic.getSeverity());
193: }
194:
195: @Test
196: public void testECPProject() {
197: try {
198: final ECPProject project = ECPUtil.getECPProjectManager().createProject(
199: ECPUtil.getECPProviderRegistry().getProvider(EMFStoreProvider.NAME), "Project");
200:
201: final Writer correctWriter = TestFactory.eINSTANCE.createWriter();
202: correctWriter.setFirstName("Hans");
203: final Writer errorWriter = TestFactory.eINSTANCE.createWriter();
204:
205: project.getContents().add(errorWriter);
206: project.getContents().add(correctWriter);
207:
208: final IValidationService validationService = validationServiceProvider.getValidationService(project);
209:
210: validationService.validate(correctWriter);
211: assertEquals(Diagnostic.OK, validationService.getDiagnostic(correctWriter).getSeverity());
212:
213: validationService.validate(errorWriter);
214: final Diagnostic diagnostic = validationService.getDiagnostic(errorWriter);
215: assertEquals(Diagnostic.ERROR, diagnostic.getSeverity());
216: assertEquals(1, diagnostic.getChildren().size());
217: assertEquals(2, diagnostic.getChildren().get(0).getData().size());
218: assertEquals(TestPackage.eINSTANCE.getWriter_FirstName(), diagnostic.getChildren().get(0).getData().get(1));
219:
220: } catch (final ECPProjectWithNameExistsException ex) {
221: }
222: }
223:
224: @Test
225: public void testAlreadyInMapping() {
226: final Writer writer = TestFactory.eINSTANCE.createWriter();
227: final IValidationService validationService1 = validationServiceProvider.getValidationService(writer);
228: final IValidationService validationService2 = validationServiceProvider.getValidationService(writer);
229: assertEquals(validationService1, validationService2);
230:
231: validationServiceProvider.deleteValidationService(writer);
232: final IValidationService validationService3 = validationServiceProvider.getValidationService(writer);
233:• assertTrue(!validationService3.equals(validationService1));
234: }
235: }
![[Jenkins]](/ecp/static/e8bbdb94/images/svgs/logo.svg){kind=logo}
