You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@cxf.apache.org by bi...@apache.org on 2009/03/21 03:17:08 UTC
svn commit: r756862 - in /cxf/trunk/common/common: ./
src/main/java/org/apache/cxf/common/xmlschema/
src/test/java/org/apache/cxf/common/xmlschema/
Author: bimargulies
Date: Sat Mar 21 02:17:08 2009
New Revision: 756862
URL: http://svn.apache.org/viewvc?rev=756862&view=rev
Log:
Getting ready to fix CXF-2123. Add utility, to be migrated to XML schema, that
finds all the possible reasons to add an <xs:import/> to a schema, and adds them.
I will make Aegis if not everything else call this.
Note that this adds a test dependency on Xerces to get a known-behavior DOM3 validator
of xml schemas. We may want to employ this for other kinds of tests to make sure that
we produce only valid schemata.
Added:
cxf/trunk/common/common/src/test/java/org/apache/cxf/common/xmlschema/
cxf/trunk/common/common/src/test/java/org/apache/cxf/common/xmlschema/DOMErrorException.java (with props)
cxf/trunk/common/common/src/test/java/org/apache/cxf/common/xmlschema/DOMLSInput.java (with props)
cxf/trunk/common/common/src/test/java/org/apache/cxf/common/xmlschema/ImportRepairTest.java (with props)
Modified:
cxf/trunk/common/common/pom.xml
cxf/trunk/common/common/src/main/java/org/apache/cxf/common/xmlschema/SchemaCollection.java
cxf/trunk/common/common/src/main/java/org/apache/cxf/common/xmlschema/XmlSchemaUtils.java
Modified: cxf/trunk/common/common/pom.xml
URL: http://svn.apache.org/viewvc/cxf/trunk/common/common/pom.xml?rev=756862&r1=756861&r2=756862&view=diff
==============================================================================
--- cxf/trunk/common/common/pom.xml (original)
+++ cxf/trunk/common/common/pom.xml Sat Mar 21 02:17:08 2009
@@ -153,7 +153,13 @@
<artifactId>geronimo-ws-metadata_2.0_spec</artifactId>
<scope>test</scope>
</dependency>
-
+ <dependency>
+<!-- this is probably not quite what we want in terms of the behavior of the other tests
+ than the schema surgery test. -->
+ <groupId>xerces</groupId>
+ <artifactId>xercesImpl</artifactId>
+ <scope>test</scope>
+ </dependency>
</dependencies>
<scm>
Modified: cxf/trunk/common/common/src/main/java/org/apache/cxf/common/xmlschema/SchemaCollection.java
URL: http://svn.apache.org/viewvc/cxf/trunk/common/common/src/main/java/org/apache/cxf/common/xmlschema/SchemaCollection.java?rev=756862&r1=756861&r2=756862&view=diff
==============================================================================
--- cxf/trunk/common/common/src/main/java/org/apache/cxf/common/xmlschema/SchemaCollection.java (original)
+++ cxf/trunk/common/common/src/main/java/org/apache/cxf/common/xmlschema/SchemaCollection.java Sat Mar 21 02:17:08 2009
@@ -33,8 +33,19 @@
import org.apache.ws.commons.schema.XmlSchema;
import org.apache.ws.commons.schema.XmlSchemaAttribute;
import org.apache.ws.commons.schema.XmlSchemaCollection;
+import org.apache.ws.commons.schema.XmlSchemaComplexContentExtension;
+import org.apache.ws.commons.schema.XmlSchemaComplexContentRestriction;
+import org.apache.ws.commons.schema.XmlSchemaComplexType;
+import org.apache.ws.commons.schema.XmlSchemaContent;
+import org.apache.ws.commons.schema.XmlSchemaContentModel;
import org.apache.ws.commons.schema.XmlSchemaElement;
+import org.apache.ws.commons.schema.XmlSchemaObject;
+import org.apache.ws.commons.schema.XmlSchemaObjectCollection;
import org.apache.ws.commons.schema.XmlSchemaObjectTable;
+import org.apache.ws.commons.schema.XmlSchemaParticle;
+import org.apache.ws.commons.schema.XmlSchemaSequence;
+import org.apache.ws.commons.schema.XmlSchemaSimpleContentExtension;
+import org.apache.ws.commons.schema.XmlSchemaSimpleContentRestriction;
import org.apache.ws.commons.schema.XmlSchemaSimpleType;
import org.apache.ws.commons.schema.XmlSchemaType;
import org.apache.ws.commons.schema.extensions.ExtensionRegistry;
@@ -44,33 +55,33 @@
import org.apache.ws.commons.schema.utils.TargetNamespaceValidator;
/**
- * Wrapper class for XmlSchemaCollection that deals with various quirks and bugs.
- * One bug is WSCOMMONS-272.
+ * Wrapper class for XmlSchemaCollection that deals with various quirks and bugs. One bug is WSCOMMONS-272.
*/
public class SchemaCollection {
private static final Method GET_ELEMENT_BY_NAME_METHOD;
static {
Method m = null;
try {
- m = XmlSchema.class.getMethod("getElementByName",
- new Class[] {String.class});
+ m = XmlSchema.class.getMethod("getElementByName", new Class[] {
+ String.class
+ });
} catch (Exception ex) {
- //ignore
+ // ignore
}
GET_ELEMENT_BY_NAME_METHOD = m;
}
-
+
private XmlSchemaCollection schemaCollection;
-
+
public SchemaCollection() {
this(new XmlSchemaCollection());
}
-
+
public SchemaCollection(XmlSchemaCollection col) {
schemaCollection = col;
col.getExtReg().setDefaultExtensionDeserializer(new FixedExtensionDeserializer());
if (schemaCollection.getNamespaceContext() == null) {
- // an empty prefix map avoids extra checks for null.
+ // an empty prefix map avoids extra checks for null.
schemaCollection.setNamespaceContext(new NamespaceMap());
}
}
@@ -78,7 +89,7 @@
public XmlSchemaCollection getXmlSchemaCollection() {
return schemaCollection;
}
-
+
public boolean equals(Object obj) {
return schemaCollection.equals(obj);
}
@@ -86,7 +97,7 @@
public XmlSchemaElement getElementByQName(QName qname) {
return schemaCollection.getElementByQName(qname);
}
-
+
public XmlSchemaAttribute getAttributeByQName(QName qname) {
String uri = qname.getNamespaceURI();
for (XmlSchema schema : schemaCollection.getXmlSchemas()) {
@@ -111,12 +122,11 @@
public XmlSchemaType getTypeByQName(QName schemaTypeName) {
XmlSchemaType xst = schemaCollection.getTypeByQName(schemaTypeName);
-
- //HACKY workaround for WSCOMMONS-355
- if (xst == null
- && "http://www.w3.org/2001/XMLSchema".equals(schemaTypeName.getNamespaceURI())) {
+
+ // HACKY workaround for WSCOMMONS-355
+ if (xst == null && "http://www.w3.org/2001/XMLSchema".equals(schemaTypeName.getNamespaceURI())) {
XmlSchema sch = getSchemaByTargetNamespace(schemaTypeName.getNamespaceURI());
-
+
if ("anySimpleType".equals(schemaTypeName.getLocalPart())) {
XmlSchemaSimpleType type = new XmlSchemaSimpleType(sch);
type.setName(schemaTypeName.getLocalPart());
@@ -129,7 +139,7 @@
xst = type;
}
}
-
+
return xst;
}
@@ -197,9 +207,10 @@
public void setSchemaResolver(URIResolver schemaResolver) {
schemaCollection.setSchemaResolver(schemaResolver);
}
-
+
/**
* This function is not part of the XmlSchema API. Who knows why?
+ *
* @param namespaceURI targetNamespace
* @return schema, or null.
*/
@@ -216,13 +227,14 @@
for (XmlSchema schema : schemaCollection.getXmlSchemas()) {
if (name.getNamespaceURI().equals(schema.getTargetNamespace())) {
- //for XmlSchema 1.4, we should use:
- //schema.getElementByName(name.getLocalPart()) != null
- //but that doesn't exist in 1.3 so for now, use reflection
+ // for XmlSchema 1.4, we should use:
+ // schema.getElementByName(name.getLocalPart()) != null
+ // but that doesn't exist in 1.3 so for now, use reflection
try {
if (GET_ELEMENT_BY_NAME_METHOD != null) {
- if (GET_ELEMENT_BY_NAME_METHOD.invoke(schema,
- new Object[] {name.getLocalPart()}) != null) {
+ if (GET_ELEMENT_BY_NAME_METHOD.invoke(schema, new Object[] {
+ name.getLocalPart()
+ }) != null) {
return schema;
}
} else if (schema.getElementByName(name) != null) {
@@ -230,9 +242,9 @@
}
} catch (java.lang.reflect.InvocationTargetException ex) {
- //ignore
+ // ignore
} catch (IllegalAccessException ex) {
- //ignore
+ // ignore
}
}
}
@@ -242,6 +254,7 @@
/**
* Once upon a time, XmlSchema had a bug in the constructor used in this function. So this wrapper was
* created to hold a workaround.
+ *
* @param namespaceURI TNS for new schema.
* @return new schema
*/
@@ -249,15 +262,16 @@
public XmlSchema newXmlSchemaInCollection(String namespaceURI) {
return new XmlSchema(namespaceURI, schemaCollection);
}
-
+
/**
* Validate that a qualified name points to some namespace in the schema.
+ *
* @param qname
*/
public void validateQNameNamespace(QName qname) {
// astonishingly, xmlSchemaCollection has no accessor by target URL.
if ("".equals(qname.getNamespaceURI())) {
- return; // references to the 'unqualified' namespace are OK even if there is no schema for it.
+ return; // references to the 'unqualified' namespace are OK even if there is no schema for it.
}
for (XmlSchema schema : schemaCollection.getXmlSchemas()) {
if (schema.getTargetNamespace().equals(qname.getNamespaceURI())) {
@@ -270,8 +284,7 @@
public void validateElementName(QName referrer, QName elementQName) {
XmlSchemaElement element = schemaCollection.getElementByQName(elementQName);
if (element == null) {
- throw new InvalidXmlSchemaReferenceException(referrer
- + " references non-existent element "
+ throw new InvalidXmlSchemaReferenceException(referrer + " references non-existent element "
+ elementQName);
}
}
@@ -279,12 +292,11 @@
public void validateTypeName(QName referrer, QName typeQName) {
XmlSchemaType type = schemaCollection.getTypeByQName(typeQName);
if (type == null) {
- throw new InvalidXmlSchemaReferenceException(referrer
- + " references non-existent type "
+ throw new InvalidXmlSchemaReferenceException(referrer + " references non-existent type "
+ typeQName);
}
}
-
+
public void addGlobalElementToSchema(XmlSchemaElement element) {
synchronized (this) {
XmlSchema schema = getSchemaByTargetNamespace(element.getQName().getNamespaceURI());
@@ -292,11 +304,114 @@
schema = newXmlSchemaInCollection(element.getQName().getNamespaceURI());
}
schema.getItems().add(element);
- // believe it or not, it is up to us to do both of these adds!
+ // believe it or not, it is up to us to do both of these adds!
schema.getElements().add(element.getQName(), element);
}
}
-
+
+ public void addCrossImports() {
+ /*
+ * We need to inventory all the cross-imports to see if any are missing.
+ */
+ for (XmlSchema schema : schemaCollection.getXmlSchemas()) {
+ addOneSchemaCrossImports(schema);
+ }
+ }
+
+ private void addOneSchemaCrossImports(XmlSchema schema) {
+ /*
+ * We need to visit all the top-level items.
+ */
+ for (int x = 0; x < schema.getItems().getCount(); x++) {
+ XmlSchemaObject item = schema.getItems().getItem(x);
+ if (item instanceof XmlSchemaElement) {
+ addElementCrossImportsElement(schema, item);
+ } else if (item instanceof XmlSchemaAttribute) {
+ XmlSchemaAttribute attr = (XmlSchemaAttribute)item;
+ XmlSchemaUtils.addImportIfNeeded(schema, attr.getRefName());
+ XmlSchemaUtils.addImportIfNeeded(schema, attr.getSchemaTypeName());
+ if (attr.getSchemaType() != null) {
+ XmlSchemaUtils.addImportIfNeeded(schema, attr.getSchemaType().getBaseSchemaTypeName());
+ }
+ } else if (item instanceof XmlSchemaType) {
+ XmlSchemaType type = (XmlSchemaType)item;
+ addCrossImportsType(schema, type);
+ }
+ }
+ }
+
+ private void addElementCrossImportsElement(XmlSchema schema, XmlSchemaObject item) {
+ XmlSchemaElement element = (XmlSchemaElement)item;
+ XmlSchemaUtils.addImportIfNeeded(schema, element.getRefName());
+ XmlSchemaUtils.addImportIfNeeded(schema, element.getSchemaTypeName());
+ // if there's an anonymous type, it might have element refs in it.
+ XmlSchemaType schemaType = element.getSchemaType();
+ addCrossImportsType(schema, schemaType);
+ }
+
+ private void addCrossImportsType(XmlSchema schema, XmlSchemaType schemaType) {
+ if (schemaType != null) {
+ // the base type might cross schemas.
+ XmlSchemaUtils.addImportIfNeeded(schema, schemaType.getBaseSchemaTypeName());
+ if (schemaType instanceof XmlSchemaComplexType) {
+ XmlSchemaComplexType complexType = (XmlSchemaComplexType)schemaType;
+ addCrossImports(schema, complexType.getContentModel());
+ addCrossImportsAttributeList(schema, complexType.getAttributes());
+ // could it be a choice or something else?
+ XmlSchemaSequence sequence = XmlSchemaUtils.getSequence(complexType);
+ addCrossImportsSequence(schema, sequence);
+ }
+ }
+ }
+
+ private void addCrossImportsSequence(XmlSchema schema, XmlSchemaSequence sequence) {
+ XmlSchemaObjectCollection items = sequence.getItems();
+ for (int x = 0; x < items.getCount(); x++) {
+ XmlSchemaObject seqItem = items.getItem(x);
+ if (seqItem instanceof XmlSchemaElement) {
+ addElementCrossImportsElement(schema, seqItem);
+ }
+ }
+ }
+
+ private void addCrossImportsAttributeList(XmlSchema schema, XmlSchemaObjectCollection attributes) {
+ for (int x = 0; x < attributes.getCount(); x++) {
+ XmlSchemaAttribute attr = (XmlSchemaAttribute)attributes.getItem(x);
+ XmlSchemaUtils.addImportIfNeeded(schema, attr.getRefName());
+ }
+ }
+
+ private void addCrossImports(XmlSchema schema, XmlSchemaContentModel contentModel) {
+ if (contentModel == null) {
+ return;
+ }
+ XmlSchemaContent content = contentModel.getContent();
+ if (content == null) {
+ return;
+ }
+ if (content instanceof XmlSchemaComplexContentExtension) {
+ XmlSchemaComplexContentExtension extension = (XmlSchemaComplexContentExtension) content;
+ XmlSchemaUtils.addImportIfNeeded(schema, extension.getBaseTypeName());
+ addCrossImportsAttributeList(schema, extension.getAttributes());
+ XmlSchemaParticle particle = extension.getParticle();
+ if (particle instanceof XmlSchemaSequence) {
+ addCrossImportsSequence(schema, (XmlSchemaSequence)particle);
+ }
+ } else if (content instanceof XmlSchemaComplexContentRestriction) {
+ XmlSchemaComplexContentRestriction restriction = (XmlSchemaComplexContentRestriction) content;
+ XmlSchemaUtils.addImportIfNeeded(schema, restriction.getBaseTypeName());
+ addCrossImportsAttributeList(schema, restriction.getAttributes());
+ } else if (content instanceof XmlSchemaSimpleContentExtension) {
+ XmlSchemaSimpleContentExtension extension = (XmlSchemaSimpleContentExtension) content;
+ XmlSchemaUtils.addImportIfNeeded(schema, extension.getBaseTypeName());
+ addCrossImportsAttributeList(schema, extension.getAttributes());
+ } else if (content instanceof XmlSchemaSimpleContentRestriction) {
+ XmlSchemaSimpleContentRestriction restriction = (XmlSchemaSimpleContentRestriction) content;
+ XmlSchemaUtils.addImportIfNeeded(schema, restriction.getBaseTypeName());
+ addCrossImportsAttributeList(schema, restriction.getAttributes());
+ }
+ }
+
public static void addGlobalElementToSchema(XmlSchema schema, XmlSchemaElement element) {
synchronized (schema) {
schema.getItems().add(element);
@@ -304,7 +419,7 @@
schema.getElements().add(element.getQName(), element);
}
}
-
+
public static void addGlobalTypeToSchema(XmlSchema schema, XmlSchemaType type) {
synchronized (schema) {
schema.getItems().add(type);
Modified: cxf/trunk/common/common/src/main/java/org/apache/cxf/common/xmlschema/XmlSchemaUtils.java
URL: http://svn.apache.org/viewvc/cxf/trunk/common/common/src/main/java/org/apache/cxf/common/xmlschema/XmlSchemaUtils.java?rev=756862&r1=756861&r2=756862&view=diff
==============================================================================
--- cxf/trunk/common/common/src/main/java/org/apache/cxf/common/xmlschema/XmlSchemaUtils.java (original)
+++ cxf/trunk/common/common/src/main/java/org/apache/cxf/common/xmlschema/XmlSchemaUtils.java Sat Mar 21 02:17:08 2009
@@ -224,6 +224,23 @@
inc.add(imp);
schema.getItems().add(imp);
}
+
+ /**
+ * For convenience, start from a qname, and add the import if it is non-null
+ * and has a namespace.
+ * @see #addImportIfNeeded(XmlSchema, String)
+ * @param schema
+ * @param qname
+ */
+ public static void addImportIfNeeded(XmlSchema schema, QName qname) {
+ if (qname == null) {
+ return;
+ }
+ if (qname.getNamespaceURI() == null) {
+ return;
+ }
+ addImportIfNeeded(schema, qname.getNamespaceURI());
+ }
/**
* This copes with an observed phenomenon in the schema built by the
@@ -636,7 +653,7 @@
throw new UnsupportedConstruct(message);
}
-
+
public static void unsupportedConstruct(String messageKey, XmlSchemaType subject) {
Message message = new Message(messageKey, LOG, subject.getQName(),
cleanedUpSchemaSource(subject));
Added: cxf/trunk/common/common/src/test/java/org/apache/cxf/common/xmlschema/DOMErrorException.java
URL: http://svn.apache.org/viewvc/cxf/trunk/common/common/src/test/java/org/apache/cxf/common/xmlschema/DOMErrorException.java?rev=756862&view=auto
==============================================================================
--- cxf/trunk/common/common/src/test/java/org/apache/cxf/common/xmlschema/DOMErrorException.java (added)
+++ cxf/trunk/common/common/src/test/java/org/apache/cxf/common/xmlschema/DOMErrorException.java Sat Mar 21 02:17:08 2009
@@ -0,0 +1,38 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.cxf.common.xmlschema;
+
+import org.w3c.dom.DOMError;
+
+/**
+ *
+ */
+public class DOMErrorException extends RuntimeException {
+ private DOMError error;
+
+ public DOMErrorException(DOMError error) {
+ this.error = error;
+ }
+
+ public DOMError getError() {
+ return error;
+ }
+
+}
Propchange: cxf/trunk/common/common/src/test/java/org/apache/cxf/common/xmlschema/DOMErrorException.java
------------------------------------------------------------------------------
svn:eol-style = native
Propchange: cxf/trunk/common/common/src/test/java/org/apache/cxf/common/xmlschema/DOMErrorException.java
------------------------------------------------------------------------------
svn:keywords = Rev Date
Added: cxf/trunk/common/common/src/test/java/org/apache/cxf/common/xmlschema/DOMLSInput.java
URL: http://svn.apache.org/viewvc/cxf/trunk/common/common/src/test/java/org/apache/cxf/common/xmlschema/DOMLSInput.java?rev=756862&view=auto
==============================================================================
--- cxf/trunk/common/common/src/test/java/org/apache/cxf/common/xmlschema/DOMLSInput.java (added)
+++ cxf/trunk/common/common/src/test/java/org/apache/cxf/common/xmlschema/DOMLSInput.java Sat Mar 21 02:17:08 2009
@@ -0,0 +1,131 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.cxf.common.xmlschema;
+
+import java.io.InputStream;
+import java.io.Reader;
+import java.io.StringWriter;
+import java.util.logging.Logger;
+
+import javax.xml.transform.Transformer;
+import javax.xml.transform.TransformerException;
+import javax.xml.transform.TransformerFactory;
+import javax.xml.transform.dom.DOMSource;
+import javax.xml.transform.stream.StreamResult;
+
+import org.w3c.dom.Document;
+import org.w3c.dom.ls.LSInput;
+
+import org.apache.cxf.common.logging.LogUtils;
+
+/**
+ *
+ */
+class DOMLSInput implements LSInput {
+ private static final Logger LOG = LogUtils.getL7dLogger(DOMLSInput.class);
+ private String systemId;
+ private String data;
+
+ DOMLSInput(Document doc, String systemId) throws TransformerException {
+ this.systemId = systemId;
+ TransformerFactory factory = TransformerFactory.newInstance();
+ Transformer transformer = factory.newTransformer();
+ DOMSource source = new DOMSource(doc);
+ source.setSystemId(systemId);
+ StringWriter writer = new StringWriter();
+ StreamResult result = new StreamResult(writer);
+ transformer.transform(source, result);
+ data = writer.toString();
+ LOG.fine(systemId + ": " + data);
+
+ }
+
+ /** {@inheritDoc}*/
+ public String getBaseURI() {
+ return null;
+ }
+
+ /** {@inheritDoc}*/
+ public InputStream getByteStream() {
+ return null;
+ }
+
+ /** {@inheritDoc}*/
+ public boolean getCertifiedText() {
+ return false;
+ }
+
+ /** {@inheritDoc}*/
+ public Reader getCharacterStream() {
+ return null;
+ }
+
+ /** {@inheritDoc}*/
+ public String getEncoding() {
+ return "utf-8";
+ }
+
+ /** {@inheritDoc}*/
+ public String getPublicId() {
+ return null;
+ }
+
+ /** {@inheritDoc}*/
+ public String getStringData() {
+ return data;
+ }
+
+ /** {@inheritDoc}*/
+ public String getSystemId() {
+ return systemId;
+ }
+
+ /** {@inheritDoc}*/
+ public void setBaseURI(String baseURI) {
+ }
+
+ /** {@inheritDoc}*/
+ public void setByteStream(InputStream byteStream) {
+ }
+
+ /** {@inheritDoc}*/
+ public void setCertifiedText(boolean certifiedText) {
+ }
+
+ /** {@inheritDoc}*/
+ public void setCharacterStream(Reader characterStream) {
+ }
+
+ /** {@inheritDoc}*/
+ public void setEncoding(String encoding) {
+ }
+
+ /** {@inheritDoc}*/
+ public void setPublicId(String publicId) {
+ }
+
+ /** {@inheritDoc}*/
+ public void setStringData(String stringData) {
+ }
+
+ /** {@inheritDoc}*/
+ public void setSystemId(String systemId) {
+ }
+}
Propchange: cxf/trunk/common/common/src/test/java/org/apache/cxf/common/xmlschema/DOMLSInput.java
------------------------------------------------------------------------------
svn:eol-style = native
Propchange: cxf/trunk/common/common/src/test/java/org/apache/cxf/common/xmlschema/DOMLSInput.java
------------------------------------------------------------------------------
svn:keywords = Rev Date
Added: cxf/trunk/common/common/src/test/java/org/apache/cxf/common/xmlschema/ImportRepairTest.java
URL: http://svn.apache.org/viewvc/cxf/trunk/common/common/src/test/java/org/apache/cxf/common/xmlschema/ImportRepairTest.java?rev=756862&view=auto
==============================================================================
--- cxf/trunk/common/common/src/test/java/org/apache/cxf/common/xmlschema/ImportRepairTest.java (added)
+++ cxf/trunk/common/common/src/test/java/org/apache/cxf/common/xmlschema/ImportRepairTest.java Sat Mar 21 02:17:08 2009
@@ -0,0 +1,297 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.cxf.common.xmlschema;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.logging.Logger;
+
+import javax.xml.XMLConstants;
+import javax.xml.namespace.QName;
+import javax.xml.transform.TransformerException;
+
+import org.w3c.dom.DOMError;
+import org.w3c.dom.DOMErrorHandler;
+import org.w3c.dom.Document;
+import org.w3c.dom.bootstrap.DOMImplementationRegistry;
+import org.w3c.dom.ls.LSInput;
+import org.w3c.dom.ls.LSResourceResolver;
+
+import org.apache.cxf.common.logging.LogUtils;
+import org.apache.ws.commons.schema.XmlSchema;
+import org.apache.ws.commons.schema.XmlSchemaAttribute;
+import org.apache.ws.commons.schema.XmlSchemaComplexContent;
+import org.apache.ws.commons.schema.XmlSchemaComplexContentExtension;
+import org.apache.ws.commons.schema.XmlSchemaComplexContentRestriction;
+import org.apache.ws.commons.schema.XmlSchemaComplexType;
+import org.apache.ws.commons.schema.XmlSchemaElement;
+import org.apache.ws.commons.schema.XmlSchemaSequence;
+import org.apache.ws.commons.schema.XmlSchemaSerializer;
+import org.apache.ws.commons.schema.XmlSchemaSerializer.XmlSchemaSerializerException;
+import org.apache.ws.commons.schema.XmlSchemaSimpleType;
+import org.apache.ws.commons.schema.XmlSchemaSimpleTypeRestriction;
+import org.apache.ws.commons.schema.utils.NamespaceMap;
+import org.apache.xerces.xs.LSInputList;
+import org.apache.xerces.xs.XSImplementation;
+import org.apache.xerces.xs.XSLoader;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+/**
+ *
+ */
+public class ImportRepairTest extends Assert {
+ private static final class ListLSInput implements LSInputList {
+ private final List<DOMLSInput> inputs;
+
+ private ListLSInput(List<DOMLSInput> inputs) {
+ this.inputs = inputs;
+ }
+
+ public int getLength() {
+ return inputs.size();
+ }
+
+ public LSInput item(int index) {
+ return inputs.get(index);
+ }
+ }
+
+ private static final Logger LOG = LogUtils.getL7dLogger(ImportRepairTest.class);
+
+ private static final String IMPORTING_SCHEMA = "urn:importing";
+ private static final String BASE_TYPE_SCHEMA1 = "urn:baseType1";
+ private static final String BASE_TYPE_SCHEMA2 = "urn:baseType2";
+ private static final String ELEMENT_TYPE_SCHEMA = "urn:elementType";
+ private static final String ELEMENT_SCHEMA = "urn:element";
+ private static final String ATTRIBUTE_SCHEMA = "urn:attribute";
+ private static final String ATTRIBUTE_TYPE_SCHEMA = "urn:attributeType";
+
+ private SchemaCollection collection;
+
+ @Test
+ public void testImportRepairs() throws Exception {
+ collection = new SchemaCollection();
+ XmlSchema importingSchema = newSchema(IMPORTING_SCHEMA);
+ XmlSchema baseTypeSchema1 = newSchema(BASE_TYPE_SCHEMA1);
+ XmlSchema baseTypeSchema2 = newSchema(BASE_TYPE_SCHEMA2);
+ XmlSchema elementTypeSchema = newSchema(ELEMENT_TYPE_SCHEMA);
+ XmlSchema elementSchema = newSchema(ELEMENT_SCHEMA);
+ XmlSchema attributeSchema = newSchema(ATTRIBUTE_SCHEMA);
+ XmlSchema attributeTypeSchema = newSchema(ATTRIBUTE_TYPE_SCHEMA);
+
+ createBaseType1(baseTypeSchema1);
+
+ createBaseType2(baseTypeSchema2);
+ XmlSchemaComplexContentExtension derivedType1Extension = createDerivedType1(importingSchema);
+ createDerivedType2(importingSchema);
+
+ createImportedElement(elementSchema);
+
+ createTypeImportingElement(importingSchema);
+
+ createTypeImportedByElement(elementTypeSchema);
+
+ createElementWithImportedType(importingSchema);
+
+ createImportedAttribute(attributeSchema);
+
+ XmlSchemaAttribute importingAttribute = new XmlSchemaAttribute();
+ importingAttribute.setRefName(new QName(ATTRIBUTE_SCHEMA, "imported"));
+ // borrow derivedType1 to make the reference.
+ derivedType1Extension.getAttributes().add(importingAttribute);
+
+ createImportedAttributeType(attributeTypeSchema);
+
+ createAttributeImportingType(importingSchema);
+
+ /*
+ * Notice that no imports have been added. In an ideal world, XmlSchema would do this for us.
+ */
+ boolean threw = false;
+ try {
+ tryToParseSchemas();
+ } catch (DOMErrorException e) {
+ threw = true;
+ }
+ assertTrue(threw);
+ LOG.info("adding imports");
+ collection.addCrossImports();
+ tryToParseSchemas();
+ }
+
+ private void tryToParseSchemas() throws ClassNotFoundException, InstantiationException,
+ IllegalAccessException, XmlSchemaSerializerException, TransformerException {
+ // Get DOM Implementation using DOM Registry
+ final List<DOMLSInput> inputs = new ArrayList<DOMLSInput>();
+ final Map<String, LSInput> resolverMap = new HashMap<String, LSInput>();
+
+ for (XmlSchema schema : collection.getXmlSchemas()) {
+ if (XMLConstants.W3C_XML_SCHEMA_NS_URI.equals(schema.getTargetNamespace())) {
+ continue;
+ }
+ Document document = new XmlSchemaSerializer().serializeSchema(schema, false)[0];
+ DOMLSInput input = new DOMLSInput(document, schema.getTargetNamespace());
+ resolverMap.put(schema.getTargetNamespace(), input);
+ inputs.add(input);
+ }
+
+ System.setProperty(DOMImplementationRegistry.PROPERTY,
+ "org.apache.xerces.dom.DOMXSImplementationSourceImpl");
+ DOMImplementationRegistry registry = DOMImplementationRegistry.newInstance();
+
+ XSImplementation impl = (XSImplementation)registry.getDOMImplementation("XS-Loader");
+
+ XSLoader schemaLoader = impl.createXSLoader(null);
+ schemaLoader.getConfig().setParameter("validate", Boolean.TRUE);
+ schemaLoader.getConfig().setParameter("error-handler", new DOMErrorHandler() {
+
+ public boolean handleError(DOMError error) {
+ LOG.info("Schema parsing error: " + error.getMessage());
+ throw new DOMErrorException(error);
+ }
+ });
+ schemaLoader.getConfig().setParameter("resource-resolver", new LSResourceResolver() {
+
+ public LSInput resolveResource(String type, String namespaceURI, String publicId,
+ String systemId, String baseURI) {
+ return resolverMap.get(namespaceURI);
+ }
+ });
+
+ schemaLoader.loadInputList(new ListLSInput(inputs));
+ }
+
+ private void createTypeImportedByElement(XmlSchema elementTypeSchema) {
+ XmlSchemaComplexType elementImportedType = new XmlSchemaComplexType(elementTypeSchema);
+ elementImportedType.setName("importedElementType");
+ elementTypeSchema.addType(elementImportedType);
+ elementTypeSchema.getItems().add(elementImportedType);
+ elementImportedType.setParticle(new XmlSchemaSequence());
+ }
+
+ private XmlSchema newSchema(String uri) {
+ XmlSchema schema = collection.newXmlSchemaInCollection(uri);
+ schema.setNamespaceContext(new NamespaceMap());
+ return schema;
+ }
+
+ private void createAttributeImportingType(XmlSchema importingSchema) {
+ XmlSchemaAttribute attributeImportingType = new XmlSchemaAttribute();
+ attributeImportingType.setName("importingType");
+ importingSchema.getAttributes().add(new QName(ELEMENT_SCHEMA, "importingTypeAttribute"),
+ attributeImportingType);
+ importingSchema.getItems().add(attributeImportingType);
+ attributeImportingType.setSchemaTypeName(new QName(ATTRIBUTE_TYPE_SCHEMA, "importedAttributeType"));
+ }
+
+ private void createImportedAttributeType(XmlSchema attributeTypeSchema) {
+ XmlSchemaSimpleType attributeImportedType = new XmlSchemaSimpleType(attributeTypeSchema);
+ attributeImportedType.setName("importedAttributeType");
+ attributeTypeSchema.addType(attributeImportedType);
+ attributeTypeSchema.getItems().add(attributeImportedType);
+ XmlSchemaSimpleTypeRestriction simpleContent = new XmlSchemaSimpleTypeRestriction();
+ attributeImportedType.setContent(simpleContent);
+ simpleContent.setBaseTypeName(new QName(XMLConstants.W3C_XML_SCHEMA_NS_URI, "string"));
+ }
+
+ private void createImportedAttribute(XmlSchema attributeSchema) {
+ XmlSchemaAttribute importedAttribute = new XmlSchemaAttribute();
+ importedAttribute.setName("imported");
+ importedAttribute.setSchemaTypeName(new QName(XMLConstants.W3C_XML_SCHEMA_NS_URI, "string"));
+ attributeSchema.getAttributes().add(new QName(ATTRIBUTE_SCHEMA, "imported"), importedAttribute);
+ attributeSchema.getItems().add(importedAttribute);
+ }
+
+ private void createElementWithImportedType(XmlSchema importingSchema) {
+ XmlSchemaElement elementWithImportedType = new XmlSchemaElement();
+ elementWithImportedType.setName("elementWithImportedType");
+ elementWithImportedType.setSchemaTypeName(new QName(ELEMENT_TYPE_SCHEMA, "importedElementType"));
+ importingSchema.getItems().add(elementWithImportedType);
+ importingSchema.getElements().add(elementWithImportedType.getQName(), elementWithImportedType);
+ }
+
+ private void createTypeImportingElement(XmlSchema importingSchema) {
+ XmlSchemaComplexType typeWithElementRef = new XmlSchemaComplexType(importingSchema);
+ typeWithElementRef.setName("typeWithRef");
+ importingSchema.addType(typeWithElementRef);
+ importingSchema.getItems().add(typeWithElementRef);
+ XmlSchemaSequence sequence = new XmlSchemaSequence();
+ typeWithElementRef.setParticle(sequence);
+ XmlSchemaElement refElement = new XmlSchemaElement();
+ sequence.getItems().add(refElement);
+ refElement.setRefName(new QName(ELEMENT_SCHEMA, "importedElement"));
+ }
+
+ private void createImportedElement(XmlSchema elementSchema) {
+ XmlSchemaElement importedElement = new XmlSchemaElement();
+ importedElement.setName("importedElement");
+ importedElement.setSchemaTypeName(new QName(XMLConstants.W3C_XML_SCHEMA_NS_URI, "string"));
+ elementSchema.getElements().add(new QName(ELEMENT_SCHEMA, "importedElement"), importedElement);
+ elementSchema.getItems().add(importedElement);
+ }
+
+ private void createDerivedType2(XmlSchema importingSchema) {
+ XmlSchemaComplexContent complexContent;
+ XmlSchemaComplexType derivedType2 = new XmlSchemaComplexType(importingSchema);
+ derivedType2.setName("derivedRestriction");
+ XmlSchemaComplexContentRestriction restriction = new XmlSchemaComplexContentRestriction();
+ restriction.setBaseTypeName(new QName(BASE_TYPE_SCHEMA2, "baseType2"));
+ complexContent = new XmlSchemaComplexContent();
+ complexContent.setContent(restriction);
+ derivedType2.setContentModel(complexContent);
+ importingSchema.addType(derivedType2);
+ importingSchema.getItems().add(derivedType2);
+ }
+
+ private XmlSchemaComplexContentExtension createDerivedType1(XmlSchema importingSchema) {
+ XmlSchemaComplexType derivedType1 = new XmlSchemaComplexType(importingSchema);
+ derivedType1.setName("derivedExtension");
+ XmlSchemaComplexContentExtension extension = new XmlSchemaComplexContentExtension();
+ extension.setBaseTypeName(new QName(BASE_TYPE_SCHEMA1, "baseType1"));
+ XmlSchemaComplexContent complexContent = new XmlSchemaComplexContent();
+ complexContent.setContent(extension);
+ derivedType1.setContentModel(complexContent);
+ importingSchema.addType(derivedType1);
+ importingSchema.getItems().add(derivedType1);
+ return extension;
+ }
+
+ private XmlSchemaComplexType createBaseType2(XmlSchema baseTypeSchema2) {
+ XmlSchemaComplexType baseType2 = new XmlSchemaComplexType(baseTypeSchema2);
+ baseType2.setName("baseType2");
+ baseTypeSchema2.addType(baseType2);
+ baseTypeSchema2.getItems().add(baseType2);
+ baseType2.setParticle(new XmlSchemaSequence());
+ return baseType2;
+ }
+
+ private void createBaseType1(XmlSchema baseTypeSchema1) {
+ XmlSchemaComplexType baseType1 = new XmlSchemaComplexType(baseTypeSchema1);
+ baseType1.setName("baseType1");
+ baseTypeSchema1.addType(baseType1);
+ baseTypeSchema1.getItems().add(baseType1);
+ baseType1.setParticle(new XmlSchemaSequence());
+ }
+
+}
Propchange: cxf/trunk/common/common/src/test/java/org/apache/cxf/common/xmlschema/ImportRepairTest.java
------------------------------------------------------------------------------
svn:eol-style = native
Propchange: cxf/trunk/common/common/src/test/java/org/apache/cxf/common/xmlschema/ImportRepairTest.java
------------------------------------------------------------------------------
svn:keywords = Rev Date