@Before
public void setUp() throws Exception {
preferredValidatorFactory = Validation.buildDefaultValidatorFactory();
JAXBContext ctx = JAXBContextFactory.createContext(EMPLOYEE, null);
marshallerValidOn = (JAXBMarshaller) ctx.createMarshaller();
marshallerValidOn.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
marshallerValidOff = (JAXBMarshaller) ctx.createMarshaller();
/* tests setting the property through marshaller */
marshallerValidOff.setProperty(
MarshallerProperties.BEAN_VALIDATION_MODE, BeanValidationMode.NONE);
marshallerValidOff.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
JAXBContext ctxValidationOff =
JAXBContextFactory.createContext(
EMPLOYEE,
new HashMap<String, Object>() {
{
put(JAXBContextProperties.BEAN_VALIDATION_MODE, BeanValidationMode.NONE);
put(JAXBContextProperties.BEAN_VALIDATION_FACTORY, preferredValidatorFactory);
}
});
unmarshallerValidOn = (JAXBUnmarshaller) ctxValidationOff.createUnmarshaller();
/* tests setting the property through unmarshaller */
unmarshallerValidOn.setProperty(
UnmarshallerProperties.BEAN_VALIDATION_MODE, BeanValidationMode.CALLBACK);
unmarshallerValidOff = (JAXBUnmarshaller) ctxValidationOff.createUnmarshaller();
}
protected JAXBContext createJaxbContextFromJSONBindings() throws JAXBException {
if (classes != null) {
return JAXBContextFactory.createContext(classes, getPropertiesFromJSON(), classLoader);
} else if (types != null) {
return JAXBContextFactory.createContext(types, getPropertiesFromJSON(), classLoader);
} else if (contextPath != null) {
return JAXBContextFactory.createContext(contextPath, classLoader, getPropertiesFromJSON());
}
return null;
}
public void testCreateContextUnrelatedSessionsXmlInvalidPath() throws Exception {
try {
JAXBContext context =
JAXBContextFactory.createContext(
"org.eclipse.persistence.testing.jaxb.jaxbcontext.fake",
new ClassLoader() {
public URL getResource(String resourceName) {
if (resourceName.equals("sessions.xml")) {
return getParent()
.getResource(
"org/eclipse/persistence/testing/jaxb/jaxbcontext/sessions.xml");
}
return this.getParent().getResource(resourceName);
}
});
} catch (JAXBException ex) {
assertTrue(
((org.eclipse.persistence.exceptions.JAXBException) ex.getLinkedException())
.getErrorCode()
== org.eclipse.persistence.exceptions.JAXBException
.NO_OBJECT_FACTORY_OR_JAXB_INDEX_IN_PATH);
assertTrue(
((org.eclipse.persistence.exceptions.JAXBException) ex.getLinkedException())
.getInternalException()
instanceof SessionLoaderException);
}
}
public void testBindingFormatList() throws Exception {
List<Object> inputFiles = new ArrayList<Object>();
inputFiles.add(new File(FILE_OXM_XML));
inputFiles.add(new InputSource(new FileInputStream(INPUT_SRC_OXM_XML)));
inputFiles.add(new FileInputStream(INPUT_STRM_OXM_XML));
inputFiles.add(new InputStreamReader(new FileInputStream(READER_OXM_XML)));
inputFiles.add(new StreamSource(ClassLoader.getSystemResourceAsStream(SOURCE_OXM_XML)));
Map<String, Object> properties = new HashMap<String, Object>();
properties.put(JAXBContextFactory.ECLIPSELINK_OXM_XML_KEY, inputFiles);
Class[] listClasses =
new Class[] {
org.eclipse.persistence.testing.jaxb.externalizedmetadata.jaxbcontextfactory.bindingformat
.file.Foo.class,
org.eclipse.persistence.testing.jaxb.externalizedmetadata.jaxbcontextfactory.bindingformat
.inputsource.Foo.class,
org.eclipse.persistence.testing.jaxb.externalizedmetadata.jaxbcontextfactory.bindingformat
.inputstream.Foo.class,
org.eclipse.persistence.testing.jaxb.externalizedmetadata.jaxbcontextfactory.bindingformat
.reader.Foo.class,
org.eclipse.persistence.testing.jaxb.externalizedmetadata.jaxbcontextfactory.bindingformat
.source.Foo.class
};
JAXBContext jCtx =
(JAXBContext) JAXBContextFactory.createContext(listClasses, properties, loader);
doTestFile(jCtx);
doTestInputSrc(jCtx);
doTestInputStrm(jCtx);
doTestReader(jCtx);
doTestSource(jCtx);
}
public void testOptimizedUnmarshal() throws Exception {
if (null != XML_INPUT_FACTORY) {
InputStream instream = ClassLoader.getSystemResourceAsStream(XML_RESOURCE);
XMLStreamReader xmlStreamReader = XML_INPUT_FACTORY.createXMLStreamReader(instream);
XMLReader xmlReader = new LargeInlineBinaryDataXMLStreamReaderReader();
InputSource inputSource = new XMLStreamReaderInputSource(xmlStreamReader);
SAXSource saxSource = new SAXSource(xmlReader, inputSource);
JAXBContext jc =
JAXBContextFactory.createContext(new Class[] {LargeInlineBinaryRoot.class}, null);
Unmarshaller unmarshaller = jc.createUnmarshaller();
LargeInlineBinaryRoot root = (LargeInlineBinaryRoot) unmarshaller.unmarshal(saxSource);
assertSame(LargeInlineBinaryDataXMLStreamReaderReader.DATA_HANDLER, root.getDataHandler());
assertSame(LargeInlineBinaryDataXMLStreamReaderReader.IMAGE, root.getImage());
assertSame(LargeInlineBinaryDataXMLStreamReaderReader.SOURCE, root.getSource());
assertSame(
LargeInlineBinaryDataXMLStreamReaderReader.MIME_MULTIPART, root.getMimeMultipart());
assertSame(
LargeInlineBinaryDataXMLStreamReaderReader.DATA_HANDLER,
root.getDataHandlerList().get(0));
assertSame(LargeInlineBinaryDataXMLStreamReaderReader.IMAGE, root.getImageList().get(0));
assertSame(LargeInlineBinaryDataXMLStreamReaderReader.SOURCE, root.getSourceList().get(0));
assertSame(
LargeInlineBinaryDataXMLStreamReaderReader.MIME_MULTIPART,
root.getMimeMultipartList().get(0));
}
}
private Suggestions transformJsonResponse(final InputStream is, final Path transformation)
throws IOException, TransformationException {
try (final ByteArrayOutputStream os = new ByteArrayOutputStream()) {
jsonTransformer.transform(is, transformation, os);
try (final InputStream resultIs = new ByteArrayInputStream(os.toByteArray())) {
final JAXBContext context =
org.eclipse.persistence.jaxb.JAXBContextFactory.createContext(
new Class[] {Suggestions.class}, null);
final Unmarshaller unmarshaller = context.createUnmarshaller();
unmarshaller.setProperty(
UnmarshallerProperties.MEDIA_TYPE,
org.eclipse.persistence.oxm.MediaType.APPLICATION_JSON);
unmarshaller.setProperty(UnmarshallerProperties.JSON_ATTRIBUTE_PREFIX, null);
unmarshaller.setProperty(UnmarshallerProperties.JSON_WRAPPER_AS_ARRAY_NAME, false);
unmarshaller.setProperty(UnmarshallerProperties.JSON_INCLUDE_ROOT, false);
unmarshaller.setProperty(
UnmarshallerProperties.JSON_NAMESPACE_PREFIX_MAPPER, namespacePrefixMapper);
unmarshaller.setProperty(UnmarshallerProperties.JSON_NAMESPACE_SEPARATOR, ':');
final JAXBElement<Suggestions> jaxbElement =
unmarshaller.unmarshal(new StreamSource(resultIs), Suggestions.class);
return jaxbElement.getValue();
} catch (final JAXBException e) {
throw new TransformationException(e);
}
}
}
public void testCreateContextWith_TypeMappingInfoArray_Map_NullClassLoader()
throws JAXBException {
TypeMappingInfo[] typeMappingInfos = new TypeMappingInfo[1];
TypeMappingInfo listTMI = new TypeMappingInfo();
listTMI.setType(List.class);
listTMI.setXmlTagName(new QName("urn:example", "my-list"));
typeMappingInfos[0] = listTMI;
JAXBContextFactory.createContext(typeMappingInfos, null, null);
}
public void testCreateContext() throws Exception {
try {
JAXBContextFactory.createContext(new Class[] {InvalidChild.class}, null);
} catch (javax.xml.bind.JAXBException e) {
JAXBException moxyException = (JAXBException) e.getCause();
assertEquals(JAXBException.SUBCLASS_CANNOT_HAVE_XMLVALUE, moxyException.getErrorCode());
return;
}
fail();
}
public void testBindingFormatFile() throws Exception {
Map<String, Object> properties = new HashMap<String, Object>();
properties.put(JAXBContextFactory.ECLIPSELINK_OXM_XML_KEY, new File(FILE_OXM_XML));
Class[] classes =
new Class[] {
org.eclipse.persistence.testing.jaxb.externalizedmetadata.jaxbcontextfactory.bindingformat
.file.Foo.class
};
JAXBContext jCtx = (JAXBContext) JAXBContextFactory.createContext(classes, properties, loader);
doTestFile(jCtx);
}
public void setClasses(Class[] newClasses) throws Exception {
classLoader = Thread.currentThread().getContextClassLoader();
jaxbContext = JAXBContextFactory.createContext(newClasses, getProperties(), classLoader);
classes = newClasses;
xmlContext = ((org.eclipse.persistence.jaxb.JAXBContext) jaxbContext).getXMLContext();
setProject(xmlContext.getSession(0).getProject());
jaxbMarshaller = jaxbContext.createMarshaller();
jaxbUnmarshaller = jaxbContext.createUnmarshaller();
}
public void testBindingFormatSource() throws Exception {
Map<String, Object> properties = new HashMap<String, Object>();
InputStream is = ClassLoader.getSystemResourceAsStream(SOURCE_OXM_XML);
properties.put(JAXBContextFactory.ECLIPSELINK_OXM_XML_KEY, new StreamSource(is));
Class[] classes =
new Class[] {
org.eclipse.persistence.testing.jaxb.externalizedmetadata.jaxbcontextfactory.bindingformat
.source.Foo.class
};
JAXBContext jCtx = (JAXBContext) JAXBContextFactory.createContext(classes, properties, loader);
doTestSource(jCtx);
}
@Override
protected void setUp() throws Exception {
Class[] classes = {Employee.class};
JAXBContext jc = JAXBContextFactory.createContext(classes, null);
unmarshaller = (JAXBUnmarshaller) jc.createUnmarshaller();
SchemaFactory sf = SchemaFactory.newInstance(XMLConstants.SCHEMA_URL);
InputStream stream = ClassLoader.getSystemResourceAsStream(SCHEMA);
Schema schema = sf.newSchema(new StreamSource(stream));
stream.close();
this.schema = schema;
}
public void testCreateContextUnrelatedSessionsXml() throws Exception {
JAXBContext context =
JAXBContextFactory.createContext(
"org.eclipse.persistence.testing.jaxb.jaxbcontext",
new ClassLoader() {
public URL getResource(String resourceName) {
if (resourceName.equals("sessions.xml")) {
return getParent()
.getResource("org/eclipse/persistence/testing/jaxb/jaxbcontext/sessions.xml");
}
return this.getParent().getResource(resourceName);
}
});
}
public void testBindingFormatNoPackageSet() {
try {
Map<String, Object> properties = new HashMap<String, Object>();
properties.put(
JAXBContextFactory.ECLIPSELINK_OXM_XML_KEY,
new FileInputStream(new File(NO_PKG_OXM_XML)));
JAXBContext jaxbContext =
(JAXBContext) JAXBContextFactory.createContext(new Class[] {}, properties, loader);
} catch (org.eclipse.persistence.exceptions.JAXBException jaxbe) {
return;
} catch (Exception e) {
}
fail("The expected exception was not thrown.");
}
@Override
protected void setUp() throws Exception {
SchemaFactory sf = SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);
InputStream schemaStream =
Thread.currentThread().getContextClassLoader().getResourceAsStream(XSD_RESOURCE);
Schema s = sf.newSchema(new StreamSource(schemaStream));
marshaller = JAXBContextFactory.createContext(getClasses(), null).createMarshaller();
marshaller.setSchema(s);
child = new Child();
child.setName("123456789");
root = setupRootObject();
}
public void testCreateConcreteClassWithMultiArgConstructor() throws JAXBException {
try {
Class[] classes = new Class[1];
classes[0] = ConcreteClassWithMultiArgConstructor.class;
JAXBContextFactory.createContext(classes, null);
} catch (JAXBException e) {
org.eclipse.persistence.exceptions.JAXBException je =
(org.eclipse.persistence.exceptions.JAXBException) e.getLinkedException();
assertEquals(
org.eclipse.persistence.exceptions.JAXBException.FACTORY_METHOD_OR_ZERO_ARG_CONST_REQ,
je.getErrorCode());
return;
}
fail();
}
public void testCreateContextNoClassesOrSessions() throws Exception {
try {
JAXBContext context =
JAXBContextFactory.createContext(
"org.eclipse.persistence.testing.jaxb.jaxbcontext.fake",
Thread.currentThread().getContextClassLoader());
} catch (JAXBException ex) {
assertTrue(
((org.eclipse.persistence.exceptions.JAXBException) ex.getLinkedException())
.getErrorCode()
== org.eclipse.persistence.exceptions.JAXBException
.NO_OBJECT_FACTORY_OR_JAXB_INDEX_IN_PATH);
assertTrue(
((org.eclipse.persistence.exceptions.JAXBException) ex.getLinkedException())
.getInternalException()
instanceof ValidationException);
}
}
/** Test passing a String[] into the context factory via Class[]. */
public void testStringArrayInClassesToBeBound() {
ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
String metadataFile = PATH + "stringarray/a/eclipselink-oxm.xml";
InputStream iStream = classLoader.getResourceAsStream(metadataFile);
if (iStream == null) {
fail("Couldn't load metadata file [" + metadataFile + "]");
}
HashMap<String, Source> metadataSourceMap = new HashMap<String, Source>();
metadataSourceMap.put(
"org.eclipse.persistence.testing.jaxb.externalizedmetadata.jaxbcontextfactory.stringarray.a",
new StreamSource(iStream));
metadataFile = PATH + "stringarray/b/eclipselink-oxm.xml";
iStream = classLoader.getResourceAsStream(metadataFile);
if (iStream == null) {
fail("Couldn't load metadata file [" + metadataFile + "]");
}
metadataSourceMap.put(
"org.eclipse.persistence.testing.jaxb.externalizedmetadata.jaxbcontextfactory.stringarray.b",
new StreamSource(iStream));
Map<String, Map<String, Source>> properties = new HashMap<String, Map<String, Source>>();
properties.put(JAXBContextFactory.ECLIPSELINK_OXM_XML_KEY, metadataSourceMap);
MySchemaOutputResolver outputResolver = new MySchemaOutputResolver();
JAXBContext jaxbContext;
try {
Class<?>[] types = {BeanA.class, BeanB.class, String[].class};
jaxbContext = (JAXBContext) JAXBContextFactory.createContext(types, properties, loader);
jaxbContext.generateSchema(outputResolver);
String controlSchema = PATH + "stringarray/bean_schema.xsd";
compareSchemas(outputResolver.schemaFiles.get(BEAN_NAMESPACE), new File(controlSchema));
controlSchema = PATH + "stringarray/string_array_schema.xsd";
compareSchemas(outputResolver.schemaFiles.get(ARRAY_NAMESPACE), new File(controlSchema));
} catch (JAXBException e) {
e.printStackTrace();
fail(e.getMessage());
}
}
public void setContextPath(String contextPath) throws Exception {
classLoader = Thread.currentThread().getContextClassLoader();
this.contextPath = contextPath;
Map props = getProperties();
if (props != null) {
Map overrides = (Map) props.get(JAXBContextFactory.ECLIPSELINK_OXM_XML_KEY);
if (overrides != null) {
Iterator valuesIter = overrides.values().iterator();
while (valuesIter.hasNext()) {
Object next = valuesIter.next();
validateBindingsFileAgainstSchema(next);
}
}
}
jaxbContext = JAXBContextFactory.createContext(contextPath, classLoader, getProperties());
xmlContext = ((org.eclipse.persistence.jaxb.JAXBContext) jaxbContext).getXMLContext();
setProject(xmlContext.getSession(0).getProject());
jaxbMarshaller = jaxbContext.createMarshaller();
jaxbUnmarshaller = jaxbContext.createUnmarshaller();
}
public void testNamespaceCollision() throws Exception {
String xml =
"<ns0:employee xmlns:ns1=\"mynamespace3\" xmlns:ns2=\"mynamespace2\" xmlns:ns0=\"mynamespace1\"><ns2:address><street>123 Fake Street</street></ns2:address><firstName>Matt</firstName><id>123</id></ns0:employee>";
String controlSource = "org/eclipse/persistence/testing/jaxb/binder/nscollision/employee.xml";
Document controlDocument =
parser.parse(Thread.currentThread().getContextClassLoader().getResource(controlSource));
JAXBContext ctx = JAXBContextFactory.createContext(new Class[] {Employee.class}, null);
Binder binder = ctx.createBinder();
JAXBElement elem = binder.unmarshal(parser.parse(new StringReader(xml)), Employee.class);
Employee emp = (Employee) elem.getValue();
emp.address.city = "Toronto";
binder.updateXML(emp.address);
JAXBXMLComparer comparer = new JAXBXMLComparer();
assertTrue(
"Marshalled document does not match the control document.",
comparer.isNodeEqual(controlDocument, ((Node) binder.getXMLNode(emp)).getOwnerDocument()));
}
public void testCreateContextWith_String_NullClassLoader_Map() throws JAXBException {
JAXBContextFactory.createContext(
"org.eclipse.persistence.testing.jaxb.jaxbcontext", null, null);
}
public void testCreateContextWith_TypeArray_Map_NullClassLoader() throws JAXBException {
Type[] types = new Type[1];
types[0] = List.class;
JAXBContextFactory.createContext(types, null, null);
}
public void testCreateContextWithStringClass() throws JAXBException {
Class[] classes = new Class[1];
classes[0] = String.class;
JAXBContextFactory.createContext(classes, null);
}
public void testCreateContextWith_ClassArray_Map_NullClassLoader_Map() throws JAXBException {
Class[] classes = new Class[1];
int[] ints = new int[1];
classes[0] = ints.getClass();
JAXBContextFactory.createContext(classes, null, null);
}
public void testCreateContextWithObjectFactory() throws Exception {
JAXBContext context =
JAXBContextFactory.createContext(
"org.eclipse.persistence.testing.jaxb.jaxbcontext",
Thread.currentThread().getContextClassLoader());
}
public void testCreateContextXmlAnyAttributeSubTypeMap() throws Exception {
JAXBContextFactory.createContext(new Class[] {XmlAnyAttributeSubTypeMapModel.class}, null);
}
@Override
protected void setUp() throws Exception {
JAXBContext jc = JAXBContextFactory.createContext(new Class[] {FlushRoot.class}, null);
marshaller = jc.createMarshaller();
unmarshaller = jc.createUnmarshaller();
}
public void testCreateAbstractClassWithMultiArgConstructor() throws JAXBException {
Class[] classes = new Class[1];
classes[0] = AbstractClassWithMultiArgConstructor.class;
JAXBContextFactory.createContext(classes, null);
}
public void testCreateContextWithGenerics() throws JAXBException {
Class[] classes = new Class[1];
classes[0] = ConcreteClassWithGenerics.class;
JAXBContextFactory.createContext(classes, null);
}
public void testCreateContextWithIntArrayClass() throws JAXBException {
Class[] classes = new Class[1];
int[] ints = new int[1];
classes[0] = ints.getClass();
JAXBContextFactory.createContext(classes, null);
}