/******************************************************************************* | |
* Copyright (c) 1998, 2013 Oracle and/or its affiliates. All rights reserved. | |
* This program and the accompanying materials are made available under the | |
* terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0 | |
* which accompanies this distribution. | |
* The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html | |
* and the Eclipse Distribution License is available at | |
* http://www.eclipse.org/org/documents/edl-v10.php. | |
* | |
* Contributors: | |
* bdoughan - Jan 27/2009 - 1.1 - Initial implementation | |
******************************************************************************/ | |
package org.eclipse.persistence.testing.sdo.helper.jaxbhelper.helpercontext; | |
import java.io.IOException; | |
import java.io.InputStream; | |
import java.io.StringWriter; | |
import java.util.Collection; | |
import java.util.HashSet; | |
import java.util.List; | |
import java.util.Set; | |
import javax.xml.bind.JAXBContext; | |
import javax.xml.bind.JAXBException; | |
import javax.xml.bind.SchemaOutputResolver; | |
import javax.xml.transform.Result; | |
import javax.xml.transform.stream.StreamResult; | |
import org.eclipse.persistence.exceptions.SDOException; | |
import org.eclipse.persistence.oxm.XMLContext; | |
import org.eclipse.persistence.oxm.XMLDescriptor; | |
import org.eclipse.persistence.sdo.SDODataObject; | |
import org.eclipse.persistence.sdo.helper.SDODataFactory; | |
import org.eclipse.persistence.sdo.helper.SDOXMLHelper; | |
import org.eclipse.persistence.sdo.helper.delegates.SDODataFactoryDelegator; | |
import org.eclipse.persistence.sdo.helper.delegates.SDOTypeHelperDelegator; | |
import org.eclipse.persistence.sdo.helper.delegates.SDOXMLHelperDelegator; | |
import org.eclipse.persistence.sdo.helper.delegates.SDOXSDHelperDelegator; | |
import org.eclipse.persistence.sdo.helper.jaxb.JAXBHelperContext; | |
import org.eclipse.persistence.sdo.helper.jaxb.JAXBValueStore; | |
import org.eclipse.persistence.testing.sdo.SDOTestCase; | |
import commonj.sdo.DataObject; | |
import commonj.sdo.Type; | |
import commonj.sdo.helper.DataFactory; | |
import commonj.sdo.helper.HelperContext; | |
import commonj.sdo.helper.TypeHelper; | |
import commonj.sdo.helper.XMLHelper; | |
import commonj.sdo.helper.XSDHelper; | |
import commonj.sdo.impl.HelperProvider; | |
public class HelperContextTestCases extends SDOTestCase { | |
private JAXBHelperContext jaxbHelperContext; | |
public HelperContextTestCases(String name) { | |
super(name); | |
} | |
public void setUp() { | |
try { | |
Class[] classes = new Class[1]; | |
classes[0] = Root.class; | |
JAXBContext jaxbContext = JAXBContext.newInstance(classes); | |
jaxbHelperContext = new JAXBHelperContext(jaxbContext); | |
jaxbHelperContext.makeDefaultContext(); | |
JAXBSchemaOutputResolver sor = new JAXBSchemaOutputResolver(); | |
jaxbContext.generateSchema(sor); | |
String xmlSchema = sor.getSchema(); | |
jaxbHelperContext.getXSDHelper().define(xmlSchema); | |
} catch(Exception e) { | |
throw new RuntimeException(e); | |
} | |
} | |
public void testGetType() { | |
Type pojoType = jaxbHelperContext.getType(Root.class); | |
assertNotNull(pojoType); | |
Type rootType = jaxbHelperContext.getTypeHelper().getType("urn:helpercontext", "root"); | |
assertSame(rootType, pojoType); | |
} | |
public void testGetClass() { | |
Type rootType = jaxbHelperContext.getTypeHelper().getType("urn:helpercontext", "root"); | |
Class pojoClass = jaxbHelperContext.getClass(rootType); | |
assertSame(Root.class, pojoClass); | |
} | |
public void testGetClassNull() { | |
Class pojoClass = jaxbHelperContext.getClass(null); | |
assertNull(pojoClass); | |
} | |
public void testGetClassNegative() { | |
try { | |
Type propertyType = jaxbHelperContext.getTypeHelper().getType("commonj.sdo", "Property"); | |
Class pojoClass = jaxbHelperContext.getClass(propertyType); | |
} catch(SDOException e) { | |
assertEquals(SDOException.SDO_JAXB_NO_DESCRIPTOR_FOR_TYPE, e.getErrorCode()); | |
return; | |
} | |
fail("An exception should have been thrown, but was not."); | |
} | |
public void testDataFactoryGetHelperContext() { | |
SDODataFactoryDelegator sdoDataFactoryDelegator = (SDODataFactoryDelegator) DataFactory.INSTANCE; | |
HelperContext testDefaultHelperContext = sdoDataFactoryDelegator.getHelperContext(); | |
assertSame(HelperProvider.getDefaultContext(), testDefaultHelperContext); | |
HelperContext testHelperContext = sdoDataFactoryDelegator.getDataFactoryDelegate().getHelperContext(); | |
assertSame(jaxbHelperContext, testHelperContext); | |
} | |
public void testTypeHelperGetHelperContext() { | |
SDOTypeHelperDelegator sdoTypeHelperDelegator = (SDOTypeHelperDelegator) TypeHelper.INSTANCE; | |
HelperContext testDefaultHelperContext = sdoTypeHelperDelegator.getHelperContext(); | |
assertSame(HelperProvider.getDefaultContext(), testDefaultHelperContext); | |
HelperContext testHelperContext = sdoTypeHelperDelegator.getTypeHelperDelegate().getHelperContext(); | |
assertSame(jaxbHelperContext, testHelperContext); | |
} | |
public void testXMLHelperGetHelperContext() { | |
SDOXMLHelperDelegator sdoXMLHelperDelegator = (SDOXMLHelperDelegator) XMLHelper.INSTANCE; | |
HelperContext testDefaultHelperContext = sdoXMLHelperDelegator.getHelperContext(); | |
assertSame(HelperProvider.getDefaultContext(), testDefaultHelperContext); | |
HelperContext testHelperContext = sdoXMLHelperDelegator.getXMLHelperDelegate().getHelperContext(); | |
assertSame(jaxbHelperContext, testHelperContext); | |
} | |
public void testXSDHelperGetHelperContext() { | |
SDOXSDHelperDelegator sdoXSDHelperDelegator = (SDOXSDHelperDelegator) XSDHelper.INSTANCE; | |
HelperContext testDefaultHelperContext = sdoXSDHelperDelegator.getHelperContext(); | |
assertSame(HelperProvider.getDefaultContext(), testDefaultHelperContext); | |
HelperContext testHelperContext = sdoXSDHelperDelegator.getXSDHelperDelegate().getHelperContext(); | |
assertSame(jaxbHelperContext, testHelperContext); | |
} | |
public void testWrap() { | |
Root root = new Root(); | |
SDODataObject rootDO = (SDODataObject) jaxbHelperContext.wrap(root); | |
assertNotNull(rootDO); | |
assertSame(JAXBValueStore.class, rootDO._getCurrentValueStore().getClass()); | |
} | |
public void testWrapTwice() { | |
Root root = new Root(); | |
SDODataObject rootDO1 = (SDODataObject) jaxbHelperContext.wrap(root); | |
assertNotNull(rootDO1); | |
SDODataObject rootDO2 = (SDODataObject) jaxbHelperContext.wrap(root); | |
assertNotNull(rootDO2); | |
assertSame(rootDO1, rootDO2); | |
} | |
public void testWrapCollection() { | |
Root root1 = new Root(); | |
Root root2 = new Root(); | |
Set collection = new HashSet(2); | |
collection.add(root1); | |
collection.add(root2); | |
List<DataObject> wrappedList = jaxbHelperContext.wrap(collection); | |
for(DataObject dataObject: wrappedList) { | |
assertNotNull(dataObject); | |
assertSame(JAXBValueStore.class, ((SDODataObject) dataObject)._getCurrentValueStore().getClass()); | |
} | |
} | |
public void testWrapNullCollection() { | |
List<DataObject> wrappedList = jaxbHelperContext.wrap(null); | |
assertNotNull(wrappedList); | |
assertEquals(0, wrappedList.size()); | |
} | |
public void testWrapEmptyCollection() { | |
Set collection = new HashSet(0); | |
List<DataObject> wrappedList = jaxbHelperContext.wrap(collection); | |
assertNotNull(wrappedList); | |
assertEquals(0, wrappedList.size()); | |
} | |
public void testWrapNull() { | |
DataObject nullDO = jaxbHelperContext.wrap((Object) null); | |
assertNull(nullDO); | |
} | |
public void testWrapUnknownObject() { | |
boolean fail = true; | |
try { | |
Object unknownObject = "FOO"; | |
jaxbHelperContext.wrap(unknownObject); | |
} catch(SDOException e) { | |
if(e.getErrorCode() == SDOException.SDO_JAXB_NO_TYPE_FOR_CLASS) { | |
fail = false; | |
} | |
} | |
if(fail) { | |
fail(); | |
} | |
} | |
public void testWrapObjectWithoutSchemaReference() { | |
boolean fail = true; | |
try { | |
org.eclipse.persistence.jaxb.JAXBContext jaxbContext = (org.eclipse.persistence.jaxb.JAXBContext) jaxbHelperContext.getJAXBContext(); | |
XMLDescriptor xmlDescriptor = (XMLDescriptor) jaxbContext.getXMLContext().getSession(Root.class).getDescriptor(Root.class); | |
xmlDescriptor.setSchemaReference(null); | |
jaxbHelperContext.wrap(new Root()); | |
} catch(SDOException e) { | |
if(e.getErrorCode() == SDOException.SDO_JAXB_NO_SCHEMA_REFERENCE) { | |
fail = false; | |
} | |
} | |
if(fail) { | |
fail(); | |
} | |
} | |
public void testWrapObjectWithoutSchemaContext() { | |
boolean fail = true; | |
try { | |
org.eclipse.persistence.jaxb.JAXBContext jaxbContext = (org.eclipse.persistence.jaxb.JAXBContext) jaxbHelperContext.getJAXBContext(); | |
XMLDescriptor xmlDescriptor = (XMLDescriptor) jaxbContext.getXMLContext().getSession(Root.class).getDescriptor(Root.class); | |
xmlDescriptor.getSchemaReference().setSchemaContext(null); | |
xmlDescriptor.getSchemaReference().setSchemaContextAsQName(null); | |
jaxbHelperContext.wrap(new Root()); | |
} catch(SDOException e) { | |
if(e.getErrorCode() == SDOException.SDO_JAXB_NO_SCHEMA_CONTEXT) { | |
fail = false; | |
} | |
} | |
if(fail) { | |
fail(); | |
} | |
} | |
public void testWrapObjectWithIncorrectSchemaContext() { | |
boolean fail = true; | |
try { | |
org.eclipse.persistence.jaxb.JAXBContext jaxbContext = (org.eclipse.persistence.jaxb.JAXBContext) jaxbHelperContext.getJAXBContext(); | |
XMLDescriptor xmlDescriptor = (XMLDescriptor) jaxbContext.getXMLContext().getSession(Root.class).getDescriptor(Root.class); | |
xmlDescriptor.getSchemaReference().setSchemaContext("/INVALID"); | |
xmlDescriptor.getSchemaReference().setSchemaContextAsQName(null); | |
jaxbHelperContext.wrap(new Root()); | |
} catch(SDOException e) { | |
if(e.getErrorCode() == SDOException.SDO_JAXB_NO_TYPE_FOR_CLASS_BY_SCHEMA_CONTEXT) { | |
fail = false; | |
} | |
} | |
if(fail) { | |
fail(); | |
} | |
} | |
public void testUnwrap() { | |
Root root = new Root(); | |
SDODataObject rootDO = (SDODataObject) jaxbHelperContext.wrap(root); | |
assertSame(root, jaxbHelperContext.unwrap(rootDO)); | |
} | |
public void testUnwrapNull() { | |
Object object = jaxbHelperContext.unwrap((DataObject) null); | |
assertNull(object); | |
} | |
public void testUnwrapCollection() { | |
Root root1 = new Root(); | |
Root root2 = new Root(); | |
Set collection = new HashSet(2); | |
collection.add(root1); | |
collection.add(root2); | |
Collection<DataObject> wrappedEntities = jaxbHelperContext.wrap(collection); | |
List<Object> entities = jaxbHelperContext.unwrap(wrappedEntities); | |
assertNotNull(entities); | |
assertEquals(2, entities.size()); | |
assertTrue(entities.contains(root1)); | |
assertTrue(entities.contains(root2)); | |
} | |
public void testUnwrapNullCollection() { | |
List<Object> entities = jaxbHelperContext.unwrap((Collection) null); | |
assertNotNull(entities); | |
assertEquals(0, entities.size()); | |
} | |
public void testUnwrapEmptyCollection() { | |
Collection wrappedCollection = new HashSet(0); | |
List entities = jaxbHelperContext.unwrap(wrappedCollection); | |
assertNotNull(entities); | |
assertEquals(0, entities.size()); | |
} | |
public void tearDown() { | |
} | |
private class JAXBSchemaOutputResolver extends SchemaOutputResolver { | |
private StringWriter schemaWriter; | |
public String getSchema() { | |
return schemaWriter.toString(); | |
} | |
public Result createOutput(String arg0, String arg1) throws IOException { | |
schemaWriter = new StringWriter(); | |
return new StreamResult(schemaWriter); | |
} | |
} | |
} |