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
