Skip to contentPackage: ResourceSetHelper_PTest$1
ResourceSetHelper_PTest$1
Coverage
1: /*******************************************************************************
2: * Copyright (c) 2011-2018 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: * Alexandra Buzila - initial API and implementation
13: ******************************************************************************/
14: package org.eclipse.emfforms.common.tests;
15:
16: import static org.junit.Assert.assertEquals;
17: import static org.junit.Assert.assertNotNull;
18: import static org.junit.Assert.assertTrue;
19: import static org.mockito.Matchers.any;
20: import static org.mockito.Mockito.mock;
21: import static org.mockito.Mockito.verify;
22: import static org.mockito.Mockito.when;
23:
24: import java.io.IOException;
25: import java.util.ArrayList;
26: import java.util.HashMap;
27: import java.util.List;
28: import java.util.Map;
29: import java.util.function.Consumer;
30:
31: import javax.xml.parsers.DocumentBuilderFactory;
32: import javax.xml.parsers.ParserConfigurationException;
33:
34: import org.eclipse.emf.common.command.BasicCommandStack;
35: import org.eclipse.emf.common.util.URI;
36: import org.eclipse.emf.ecore.EAnnotation;
37: import org.eclipse.emf.ecore.EAttribute;
38: import org.eclipse.emf.ecore.EClass;
39: import org.eclipse.emf.ecore.EObject;
40: import org.eclipse.emf.ecore.EPackage;
41: import org.eclipse.emf.ecore.EReference;
42: import org.eclipse.emf.ecore.EStructuralFeature;
43: import org.eclipse.emf.ecore.EcoreFactory;
44: import org.eclipse.emf.ecore.EcorePackage;
45: import org.eclipse.emf.ecore.resource.Resource;
46: import org.eclipse.emf.ecore.resource.Resource.IOWrappedException;
47: import org.eclipse.emf.ecore.resource.ResourceSet;
48: import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl;
49: import org.eclipse.emf.ecore.util.EcoreUtil;
50: import org.eclipse.emf.ecore.xmi.XMIResource;
51: import org.eclipse.emf.ecore.xmi.XMLResource;
52: import org.eclipse.emf.ecore.xmi.impl.EMOFResourceImpl;
53: import org.eclipse.emf.ecore.xmi.impl.XMIResourceImpl;
54: import org.eclipse.emfforms.spi.editor.helpers.ResourceSetHelpers;
55: import org.junit.After;
56: import org.junit.Test;
57: import org.mockito.Mockito;
58: import org.w3c.dom.Document;
59: import org.xml.sax.SAXException;
60:
61: @SuppressWarnings("nls")
62: public class ResourceSetHelper_PTest {
63:
64: private final List<Resource> cleanupList = new ArrayList<Resource>();
65:
66: @After
67: public void cleanup() {
68: cleanupList.stream().forEach(new Consumer<Resource>() {
69: @Override
70: public void accept(Resource resource) {
71: try {
72: resource.delete(null);
73: } catch (final IOException ex) {
74: // do nothing
75: }
76: }
77: });
78: cleanupList.clear();
79: }
80:
81: @Test
82: public void saveResourceWithNoOptions() throws IOException, SAXException, ParserConfigurationException {
83: // setup
84: final EClass class1 = setupClass("package1", "class1");
85: final URI resourceURI = URI.createURI("MyResource.xmi");
86: final XMIResource resource = createResource(resourceURI);
87:
88: resource.getContents().add(class1);
89: resource.save(null);
90:
91: final ResourceSet resourceSet = new ResourceSetImpl();
92: resourceSet.getResources().add(resource);
93:
94: Document document = DocumentBuilderFactory.newInstance().newDocumentBuilder()
95: .parse("MyResource.xmi");
96: assertEquals(document.getDocumentElement().getAttribute("name"), "class1");
97:
98: // modify resource contents
99: class1.setName("test");
100:
101: // save
102: ResourceSetHelpers.save(resourceSet, null);
103:
104: // verify
105: document = DocumentBuilderFactory.newInstance().newDocumentBuilder()
106: .parse("MyResource.xmi");
107: assertEquals(document.getDocumentElement().getAttribute("name"), "test");
108: }
109:
110: @Test
111: public void saveResourceWithOptions() throws IOException, SAXException, ParserConfigurationException {
112: // setup
113: final URI resourceURI = URI.createURI("MyResource.xmi");
114: final XMIResource resource = createResource(resourceURI);
115: resource.save(null);
116: final ResourceSet resourceSet = new ResourceSetImpl();
117: resourceSet.getResources().add(resource);
118:
119: Document document = DocumentBuilderFactory.newInstance().newDocumentBuilder()
120: .parse("MyResource.xmi");
121: assertEquals(document.getXmlEncoding(), "ASCII"); // default encoding
122:
123: final Map<Object, Object> saveOptions = new HashMap<Object, Object>();
124: saveOptions.put(XMLResource.OPTION_ENCODING, "UTF-16");
125:
126: // save
127: ResourceSetHelpers.save(resourceSet, saveOptions);
128:
129: // verify
130: document = DocumentBuilderFactory.newInstance().newDocumentBuilder()
131: .parse("MyResource.xmi");
132: assertEquals(document.getXmlEncoding(), "UTF-16");
133: }
134:
135: @Test
136: public void loadResourceWithProxies() throws IOException, SAXException, ParserConfigurationException {
137: // setup
138: final EClass classA = setupClass("package1", "classA");
139: final EReference refB = EcoreFactory.eINSTANCE.createEReference();
140: classA.getEStructuralFeatures().add(refB);
141:
142: final EClass classB = setupClass("package2", "classB");
143: final EReference refC = EcoreFactory.eINSTANCE.createEReference();
144: classB.getEStructuralFeatures().add(refC);
145:
146: final EClass classC = setupClass("package3", "classC");
147:
148: refB.setEType(classB);
149: refC.setEType(classC);
150:
151: final URI cURI = URI.createURI("c.xmi");
152: XMIResource resource = createResource(cURI);
153: cleanupList.add(resource);
154: resource.getContents().add(classC);
155: resource.save(null);
156:
157: final URI bURI = URI.createURI("b.xmi");
158: resource = createResource(bURI);
159: resource.getContents().add(classB);
160: resource.save(null);
161:
162: final URI aURI = URI.createURI("a.xmi");
163: resource = createResource(aURI);
164: resource.getContents().add(classA);
165: resource.save(null);
166:
167: final ResourceSet resourceSet = new ResourceSetImpl();
168:
169: // load A
170: ResourceSetHelpers.loadResourceWithProxies(aURI, resourceSet, null);
171:
172: // verify
173: assertEquals(3, resourceSet.getResources().size());
174:
175: }
176:
177: @Test(expected = IOWrappedException.class)
178: public void loadResourceWithNoOptions() throws IOException {
179: // setup
180: final EClass classA = setupClass("package1", "classA");
181:
182: final URI modelURI = URI.createURI("model.xmi");
183: final Resource resource = createResource(modelURI);
184: resource.getContents().add(classA);
185:
186: final EObject instance = EcoreUtil.create(classA);
187: final URI instanceURI = URI.createURI("instance.xmi");
188: final XMIResource instanceResource = createResource(instanceURI);
189: instanceResource.getContents().add(instance);
190: instanceResource.save(null);
191:
192: final ResourceSet instanceResourceSet = new ResourceSetImpl();
193: // this will throw an exception:
194: ResourceSetHelpers.loadResourceWithProxies(instanceURI, instanceResourceSet, null);
195: }
196:
197: @Test
198: public void loadResourceWithOptions() throws IOException {
199: // setup
200: final EClass classA = setupClass("package1", "classA");
201:
202: final URI modelURI = URI.createURI("model.xmi");
203: final Resource resource = createResource(modelURI);
204: resource.getContents().add(classA);
205:
206: final EObject instance = EcoreUtil.create(classA);
207: final URI instanceURI = URI.createURI("instance.xmi");
208: final XMIResource instanceResource = createResource(instanceURI);
209: instanceResource.getContents().add(instance);
210: instanceResource.save(null);
211:
212: final XMLResource.MissingPackageHandler handler = mock(XMLResource.MissingPackageHandler.class);
213: when(handler.getPackage(any(String.class))).thenReturn(classA.getEPackage());
214:
215: // load instance
216: final Map<Object, Object> loadOptions = new HashMap<Object, Object>();
217: loadOptions.put(XMLResource.OPTION_MISSING_PACKAGE_HANDLER, handler);
218:
219: final ResourceSet instanceResourceSet = new ResourceSetImpl();
220: ResourceSetHelpers.loadResourceWithProxies(instanceURI, instanceResourceSet, loadOptions);
221:
222: verify(handler, Mockito.atLeastOnce()).getPackage(any(String.class));
223: }
224:
225: @Test
226: public void loadResourceSetWithOptions() throws IOException {
227: // setup
228: final EClass classA = setupClass("package1", "classA");
229:
230: final URI modelURI = URI.createURI("model.xmi");
231: final Resource resource = createResource(modelURI);
232: resource.getContents().add(classA);
233:
234: final EObject instance = EcoreUtil.create(classA);
235: final URI instanceURI = URI.createURI("instance.xmi");
236: final XMIResource instanceResource = createResource(instanceURI);
237: instanceResource.getContents().add(instance);
238: instanceResource.save(null);
239:
240: final XMLResource.MissingPackageHandler handler = mock(XMLResource.MissingPackageHandler.class);
241: when(handler.getPackage(any(String.class))).thenReturn(classA.getEPackage());
242:
243: // load instance
244: final Map<Object, Object> loadOptions = new HashMap<Object, Object>();
245: loadOptions.put(XMLResource.OPTION_MISSING_PACKAGE_HANDLER, handler);
246:
247: final ResourceSet resourceSet = ResourceSetHelpers.loadResourceSetWithProxies(instanceURI,
248: new BasicCommandStack(), loadOptions);
249: verify(handler, Mockito.atLeastOnce()).getPackage(any(String.class));
250: assertNotNull(resourceSet);
251: }
252:
253: @Test
254: public void addResourceToSet() throws IOException {
255: // setup
256: final EClass classA = setupClass("package1", "classA");
257:
258: final URI modelURI = URI.createURI("model.xmi");
259: final Resource resource = createResource(modelURI);
260: resource.getContents().add(classA);
261:
262: final EObject instance = EcoreUtil.create(classA);
263: final URI instanceURI = URI.createURI("instance.xmi");
264: final XMIResource instanceResource = createResource(instanceURI);
265: instanceResource.getContents().add(instance);
266: instanceResource.save(null);
267:
268: final XMLResource.MissingPackageHandler handler = mock(XMLResource.MissingPackageHandler.class);
269: when(handler.getPackage(any(String.class))).thenReturn(classA.getEPackage());
270: final Map<Object, Object> loadOptions = new HashMap<Object, Object>();
271: loadOptions.put(XMLResource.OPTION_MISSING_PACKAGE_HANDLER, handler);
272:
273: final ResourceSet resourceSet = new ResourceSetImpl();
274:
275: assertTrue(ResourceSetHelpers.addResourceToSet(resourceSet, instanceURI, loadOptions));
276: verify(handler, Mockito.atLeastOnce()).getPackage(any(String.class));
277: assertEquals(1, resourceSet.getResources().size());
278: }
279:
280: /**
281: * @see <a href="https://bugs.eclipse.org/527110">Bug 527110 - Issue with serialisation code in Generic Editor</a>
282: */
283: @Test
284: public void extendedMetadataTestXMIResource() throws IOException, SAXException, ParserConfigurationException {
285: // setup
286: final EClass class1 = setupClassWithMetadata();
287: final EObject instance = EcoreUtil.create(class1);
288: final EStructuralFeature attribute = class1.getEStructuralFeature("attribute1");
289: instance.eSet(attribute, "nnn");
290:
291: final URI instanceResourceURI = URI.createURI("MyInstance.xmi");
292: final XMIResource instanceResource = createResource(instanceResourceURI);
293: instanceResource.save(null);
294: final ResourceSet resourceSet = ResourceSetHelpers.loadResourceSetWithProxies(instanceResourceURI,
295: new BasicCommandStack(), null);
296: // get resource loaded into resource set
297: final Resource resource = resourceSet.getResource(instanceResourceURI, true);
298: resource.getContents().add(instance);
299: ResourceSetHelpers.save(resourceSet, null);
300:
301: // verify - metadata will NOT be used
302: final Document document = DocumentBuilderFactory.newInstance().newDocumentBuilder()
303: .parse("MyInstance.xmi");
304: assertTrue(document.getDocumentElement().getAttribute("attr1").isEmpty());
305: assertEquals(document.getDocumentElement().getAttribute("attribute1"), "nnn");
306: }
307:
308: /**
309: * @see <a href="https://bugs.eclipse.org/527110">Bug 527110 - Issue with serialisation code in Generic Editor</a>
310: */
311: @Test
312: public void extendedMetadataTestXMLResourceWithMetadata()
313: throws IOException, SAXException, ParserConfigurationException {
314: final EClass class1 = setupClassWithMetadata();
315: final EObject instance = EcoreUtil.create(class1);
316: final EStructuralFeature attribute = class1.getEStructuralFeature("attribute1");
317: instance.eSet(attribute, "nnn");
318:
319: // the EMOF resource factory will set the XMLResource.OPTION_EXTENDED_META_DATA to true
320: final URI instanceResourceURI = URI.createURI("MyInstance.emof");
321:
322: final EMOFResourceImpl instanceResource = new EMOFResourceImpl(instanceResourceURI);
323: cleanupList.add(instanceResource);
324: instanceResource.save(null);
325:
326: final ResourceSet resourceSet = ResourceSetHelpers.loadResourceSetWithProxies(instanceResourceURI,
327: new BasicCommandStack(), null);
328: // get resource loaded into resource set
329: final Resource resource = resourceSet.getResource(instanceResourceURI, true);
330: resource.getContents().add(instance);
331: ResourceSetHelpers.save(resourceSet, null);
332:
333: // verify - metadata will be used
334: final Document document = DocumentBuilderFactory.newInstance().newDocumentBuilder()
335: .parse("MyInstance.emof");
336: assertEquals(document.getDocumentElement().getAttribute("attr1"), "nnn");
337: assertTrue(document.getDocumentElement().getAttribute("attribute1").isEmpty());
338: }
339:
340: /**
341: * @see <a href="https://bugs.eclipse.org/527110">Bug 527110 - Issue with serialisation code in Generic Editor</a>
342: */
343: @Test
344: public void extendedMetadataTestXMLResourceNoMetadata()
345: throws IOException, SAXException, ParserConfigurationException {
346: final EClass class1 = setupClassWithMetadata();
347: final EObject instance = EcoreUtil.create(class1);
348: final EStructuralFeature attribute = class1.getEStructuralFeature("attribute1");
349: instance.eSet(attribute, "nnn");
350:
351: // the EMOF resource factory will set the XMLResource.OPTION_EXTENDED_META_DATA to true
352: final URI instanceResourceURI = URI.createURI("MyInstance.xml");
353:
354: final EMOFResourceImpl instanceResource = new EMOFResourceImpl(instanceResourceURI);
355: cleanupList.add(instanceResource);
356: instanceResource.save(null);
357:
358: final ResourceSet resourceSet = ResourceSetHelpers.loadResourceSetWithProxies(instanceResourceURI,
359: new BasicCommandStack(), null);
360: // get resource loaded into resource set
361: final Resource resource = resourceSet.getResource(instanceResourceURI, true);
362: resource.getContents().add(instance);
363: ResourceSetHelpers.save(resourceSet, null);
364:
365: // verify - metadata will NOT be used
366: final Document document = DocumentBuilderFactory.newInstance().newDocumentBuilder()
367: .parse("MyInstance.xml");
368: assertTrue(document.getDocumentElement().getAttribute("attr1").isEmpty());
369: assertEquals(document.getDocumentElement().getAttribute("attribute1"), "nnn");
370: }
371:
372: private XMIResource createResource(URI resourceURI) {
373: final XMIResource resource = new XMIResourceImpl(resourceURI);
374: cleanupList.add(resource);
375: return resource;
376: }
377:
378: private EClass setupClassWithMetadata() {
379: final EClass class1 = setupClass("package1", "class1");
380:
381: final EAttribute attribute = EcoreFactory.eINSTANCE.createEAttribute();
382: attribute.setName("attribute1");
383: attribute.setEType(EcorePackage.eINSTANCE.getEString());
384:
385: final EAnnotation annotation = EcoreFactory.eINSTANCE.createEAnnotation();
386: annotation.setSource("http:///org/eclipse/emf/ecore/util/ExtendedMetaData");
387: annotation.getDetails().put("name", "attr1");
388: annotation.getDetails().put("kind", "attribute");
389: attribute.getEAnnotations().add(annotation);
390:
391: class1.getEStructuralFeatures().add(attribute);
392: return class1;
393: }
394:
395: private EClass setupClass(String packageName, String className) {
396: final EPackage package1 = EcoreFactory.eINSTANCE.createEPackage();
397: package1.setName(packageName);
398: package1.setNsURI(packageName);
399:
400: final EClass class1 = EcoreFactory.eINSTANCE.createEClass();
401: class1.setName(className);
402: package1.getEClassifiers().add(class1);
403:
404: return class1;
405: }
406: }
![[Jenkins]](/ecp/static/e8bbdb94/images/svgs/logo.svg){kind=logo}
